You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@cordova.apache.org by no...@apache.org on 2022/02/06 01:41:33 UTC
[cordova-docs] branch master updated: docs: CLI 11 (#1226)
This is an automated email from the ASF dual-hosted git repository.
normanbreau pushed a commit to branch master
in repository https://gitbox.apache.org/repos/asf/cordova-docs.git
The following commit(s) were added to refs/heads/master by this push:
new a76357f docs: CLI 11 (#1226)
a76357f is described below
commit a76357f58289bebd5733bbfcbde960a53464d633
Author: Norman Breau <no...@nbsolutions.ca>
AuthorDate: Sat Feb 5 21:41:24 2022 -0400
docs: CLI 11 (#1226)
---
VERSION | 2 +-
www/_data/toc/en_11-x-src.yml | 67 ++
www/docs/en/11.x/config_ref/images.md | 296 +++++++
www/docs/en/11.x/config_ref/index.md | 556 ++++++++++++++
www/docs/en/11.x/cordova/events/events.md | 468 +++++++++++
www/docs/en/11.x/cordova/storage/storage.md | 253 ++++++
www/docs/en/11.x/guide/appdev/allowlist/index.md | 205 +++++
www/docs/en/11.x/guide/appdev/hooks/index.md | 413 ++++++++++
www/docs/en/11.x/guide/appdev/privacy/index.md | 113 +++
www/docs/en/11.x/guide/appdev/security/index.md | 106 +++
www/docs/en/11.x/guide/cli/index.md | 330 ++++++++
www/docs/en/11.x/guide/cli/template.md | 72 ++
www/docs/en/11.x/guide/hybrid/plugins/index.md | 371 +++++++++
www/docs/en/11.x/guide/hybrid/webviews/index.md | 39 +
www/docs/en/11.x/guide/next/index.md | 194 +++++
www/docs/en/11.x/guide/overview/index.md | 164 ++++
www/docs/en/11.x/guide/platforms/android/index.md | 829 ++++++++++++++++++++
www/docs/en/11.x/guide/platforms/android/plugin.md | 517 +++++++++++++
.../en/11.x/guide/platforms/android/upgrade.md | 659 ++++++++++++++++
.../en/11.x/guide/platforms/android/webview.md | 134 ++++
www/docs/en/11.x/guide/platforms/electron/index.md | 466 +++++++++++
www/docs/en/11.x/guide/platforms/ios/index.md | 318 ++++++++
www/docs/en/11.x/guide/platforms/ios/plugin.md | 274 +++++++
www/docs/en/11.x/guide/platforms/ios/upgrade.md | 855 +++++++++++++++++++++
www/docs/en/11.x/guide/platforms/ios/webview.md | 224 ++++++
www/docs/en/11.x/guide/platforms/osx/config.md | 87 +++
www/docs/en/11.x/guide/platforms/osx/index.md | 146 ++++
www/docs/en/11.x/guide/platforms/osx/plugin.md | 27 +
www/docs/en/11.x/guide/platforms/windows/index.md | 448 +++++++++++
www/docs/en/11.x/guide/platforms/windows/plugin.md | 209 +++++
.../en/11.x/guide/platforms/windows/upgrade.md | 76 ++
www/docs/en/11.x/guide/support/index.md | 258 +++++++
www/docs/en/11.x/index.md | 23 +
www/docs/en/11.x/platform_pinning/index.md | 48 ++
.../11.x/platform_plugin_versioning_ref/index.md | 313 ++++++++
www/docs/en/11.x/plugin_ref/plugman.md | 276 +++++++
www/docs/en/11.x/plugin_ref/spec.md | 740 ++++++++++++++++++
www/docs/en/11.x/reference/cordova-cli/index.md | 629 +++++++++++++++
.../cordova-plugin-battery-status/index.md | 116 +++
.../11.x/reference/cordova-plugin-camera/index.md | 707 +++++++++++++++++
.../11.x/reference/cordova-plugin-device/index.md | 286 +++++++
.../11.x/reference/cordova-plugin-dialogs/index.md | 291 +++++++
.../en/11.x/reference/cordova-plugin-file/index.md | 837 ++++++++++++++++++++
.../reference/cordova-plugin-geolocation/index.md | 785 +++++++++++++++++++
.../reference/cordova-plugin-inappbrowser/index.md | 726 +++++++++++++++++
.../cordova-plugin-media-capture/index.md | 632 +++++++++++++++
.../11.x/reference/cordova-plugin-media/index.md | 700 +++++++++++++++++
.../cordova-plugin-network-information/index.md | 320 ++++++++
.../cordova-plugin-screen-orientation/index.md | 127 +++
.../reference/cordova-plugin-splashscreen/index.md | 612 +++++++++++++++
.../reference/cordova-plugin-statusbar/index.md | 336 ++++++++
.../reference/cordova-plugin-vibration/index.md | 152 ++++
www/docs/en/11.x/third-party/index.md | 58 ++
53 files changed, 17889 insertions(+), 1 deletion(-)
diff --git a/VERSION b/VERSION
index 759de19..248e754 100644
--- a/VERSION
+++ b/VERSION
@@ -1 +1 @@
-10.x
+11.x
diff --git a/www/_data/toc/en_11-x-src.yml b/www/_data/toc/en_11-x-src.yml
new file mode 100644
index 0000000..7cadb6e
--- /dev/null
+++ b/www/_data/toc/en_11-x-src.yml
@@ -0,0 +1,67 @@
+-
+ name: Introduction
+ children:
+ - url: guide/overview/index.html
+-
+ name: Create apps
+ children:
+ - url: guide/cli/index.html
+ - url: guide/cli/template.html
+ - url: guide/support/index.html
+ - url: third-party/index.html
+ -
+ name: Develop for platforms
+ children:
+ - url: guide/platforms/android/index.html
+ - url: guide/platforms/ios/index.html
+ - url: guide/platforms/windows/index.html
+ - url: guide/platforms/osx/index.html
+ - url: guide/platforms/electron/index.html
+ - url: platform_plugin_versioning_ref/index.html
+ - url: platform_pinning/index.html
+ - url: config_ref/images.html
+ - url: cordova/storage/storage.html
+ - url: guide/appdev/privacy/index.html
+ - url: guide/appdev/security/index.html
+ - url: guide/appdev/allowlist/index.html
+-
+ name: Create plugins
+ children:
+ - url: guide/hybrid/plugins/index.html
+ -
+ name: Develop for platforms
+ children:
+ - url: guide/platforms/android/plugin.html
+ - url: guide/platforms/ios/plugin.html
+ - url: guide/platforms/windows/plugin.html
+ - url: plugin_ref/plugman.html
+-
+ name: Advanced Topics
+ children:
+ - url: guide/hybrid/webviews/index.html
+ - url: guide/next/index.html
+-
+ name: Reference
+ children:
+ - url: config_ref/index.html
+ - url: cordova/events/events.html
+ - url: reference/cordova-cli/index.html
+ - url: guide/appdev/hooks/index.html
+ - url: plugin_ref/spec.html
+ -
+ name: Plugin APIs
+ children:
+ - url: reference/cordova-plugin-battery-status/index.html
+ - url: reference/cordova-plugin-camera/index.html
+ - url: reference/cordova-plugin-device/index.html
+ - url: reference/cordova-plugin-dialogs/index.html
+ - url: reference/cordova-plugin-file/index.html
+ - url: reference/cordova-plugin-geolocation/index.html
+ - url: reference/cordova-plugin-inappbrowser/index.html
+ - url: reference/cordova-plugin-media/index.html
+ - url: reference/cordova-plugin-media-capture/index.html
+ - url: reference/cordova-plugin-network-information/index.html
+ - url: reference/cordova-plugin-screen-orientation/index.html
+ - url: reference/cordova-plugin-splashscreen/index.html
+ - url: reference/cordova-plugin-statusbar/index.html
+ - url: reference/cordova-plugin-vibration/index.html
diff --git a/www/docs/en/11.x/config_ref/images.md b/www/docs/en/11.x/config_ref/images.md
new file mode 100644
index 0000000..fe2ba82
--- /dev/null
+++ b/www/docs/en/11.x/config_ref/images.md
@@ -0,0 +1,296 @@
+---
+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: Customize app icons
+toc_title: Customize icons
+description: Learn how to customize icons for your Cordova application.
+---
+
+# Customize Icons
+
+This section shows how to configure an application's icon for various platforms. Documentation about splash screen images can be found in the Cordova-Plugin-Splashscreen documentation [Splashscreen plugin docs][splashscreen_plugin].
+
+## Configuring Icons in the CLI
+
+When working in the CLI you can define application icon(s) via the `<icon>` element (`config.xml`).
+If you do not specify an icon, the Apache Cordova logo is used.
+
+```xml
+ <icon src="res/ios/icon.png" platform="ios" width="57" height="57" density="mdpi" />
+```
+
+Attributes | Description
+--------------|--------------------------------------------------------------------------------
+src | *Required* <br/> Location of the image file, relative to your project directory.
+platform | *Optional* <br/> Target platform
+width | *Optional* <br/> Icon width in pixels
+height | *Optional* <br/> Icon height in pixels
+target | *Optional* <br/> ==Windows== <br/> Destination filename for the image file and all its MRT companions
+
+
+The following configuration can be used to define a single default icon
+which will be used for all platforms.
+```xml
+ <icon src="res/icon.png" />
+```
+For each platform, you can also define a pixel-perfect icon set to fit
+different screen resolutions.
+
+## Android
+
+On Android, instead of using a single image for an icon, you can use two images (background and foreground) to create an **Adaptive Icon**. To use Adaptive Icons, you need to have installed at least version 9.0.0 of **Cordova** and version 8.0.0 of **Cordova-Android**.
+
+Attributes | Description
+--------------|--------------------------------------------------------------------------------
+background | *Required for Adaptive* <br/> Location of the image (png or vector) relative to your project directory, or color reference
+foreground | *Required for Adaptive* <br/> Location of the image (png or vector) relative to your project directory, or color reference
+density | *Required* <br/> Specified icon density
+
+### Adaptive Icons
+
+To use the adaptive icons the `background` and `foreground` attributes must be defined in place of the `src` attribute. The `src` attribute is not used for adaptive icons.
+
+#### Adaptive Icon with Images:
+```xml
+<platform name="android">
+ <icon background="res/icon/android/ldpi-background.png" density="ldpi" foreground="res/icon/android/ldpi-foreground.png" />
+ <icon background="res/icon/android/mdpi-background.png" density="mdpi" foreground="res/icon/android/mdpi-foreground.png" />
+ <icon background="res/icon/android/hdpi-background.png" density="hdpi" foreground="res/icon/android/hdpi-foreground.png" />
+ <icon background="res/icon/android/xhdpi-background.png" density="xhdpi" foreground="res/icon/android/xhdpi-foreground.png" />
+ <icon background="res/icon/android/xxhdpi-background.png" density="xxhdpi" foreground="res/icon/android/xxhdpi-foreground.png" />
+ <icon background="res/icon/android/xxxhdpi-background.png" density="xxxhdpi" foreground="res/icon/android/xxxhdpi-foreground.png" />
+</platform>
+```
+
+**Note:** In this example, the foreground image will also be used as the fallback icon for Android devices that do not support the adaptive icons. The fallback icon can be overridden by setting the src attribute.
+
+#### Adaptive Icon with Vectors:
+```xml
+<platform name="android">
+ <icon background="res/icon/android/ldpi-background.xml" density="ldpi" foreground="res/icon/android/ldpi-foreground.xml" src="res/android/ldpi.png" />
+ <icon background="res/icon/android/mdpi-background.xml" density="mdpi" foreground="res/icon/android/mdpi-foreground.xml" src="res/android/mdpi.png" />
+ <icon background="res/icon/android/hdpi-background.xml" density="hdpi" foreground="res/icon/android/hdpi-foreground.xml" src="res/android/hdpi.png" />
+ <icon background="res/icon/android/xhdpi-background.xml" density="xhdpi" foreground="res/icon/android/xhdpi-foreground.xml" src="res/android/xhdpi.png" />
+ <icon background="res/icon/android/xxhdpi-background.xml" density="xxhdpi" foreground="res/icon/android/xxhdpi-foreground.xml" src="res/android/xxhdpi.png" />
+ <icon background="res/icon/android/xxxhdpi-background.xml" density="xxxhdpi" foreground="res/icon/android/xxxhdpi-foreground.xml" src="res/android/xxxhdpi.png" />
+</platform>
+```
+
+**Note:** In this example, the src attribute must be defined when then foreground attribute is defined with a vector or color.
+
+#### Adaptive Icon with Colors:
+Create a `res/values/colors.xml` resource file in your project directory to store the app's color definitions.
+```xml
+<?xml version="1.0" encoding="utf-8"?>
+<resources>
+ <color name="background">#FF0000</color>
+</resources>
+```
+
+In the `config.xml`, we will add `resource-file` to copy the `colors.xml` into the approprate location so that the colors are available during build time.
+
+```xml
+<platform name="android">
+ <resource-file src="res/values/colors.xml" target="/app/src/main/res/values/colors.xml" />
+
+ <icon background="@color/background" density="ldpi" foreground="res/icon/android/ldpi-foreground.png" />
+ <icon background="@color/background" density="mdpi" foreground="res/icon/android/mdpi-foreground.png" />
+ <icon background="@color/background" density="hdpi" foreground="res/icon/android/hdpi-foreground.png" />
+ <icon background="@color/background" density="xhdpi" foreground="res/icon/android/xhdpi-foreground.png" />
+ <icon background="@color/background" density="xxhdpi" foreground="res/icon/android/xxhdpi-foreground.png" />
+ <icon background="@color/background" density="xxxhdpi" foreground="res/icon/android/xxxhdpi-foreground.png" />
+</platform>
+```
+
+### Standard Icons
+
+```xml
+ <platform name="android">
+ <!--
+ ldpi : 36x36 px
+ mdpi : 48x48 px
+ hdpi : 72x72 px
+ xhdpi : 96x96 px
+ xxhdpi : 144x144 px
+ xxxhdpi : 192x192 px
+ -->
+ <icon src="res/android/ldpi.png" density="ldpi" />
+ <icon src="res/android/mdpi.png" density="mdpi" />
+ <icon src="res/android/hdpi.png" density="hdpi" />
+ <icon src="res/android/xhdpi.png" density="xhdpi" />
+ <icon src="res/android/xxhdpi.png" density="xxhdpi" />
+ <icon src="res/android/xxxhdpi.png" density="xxxhdpi" />
+ </platform>
+```
+
+### See Also
+- [Android icon guide](https://developer.android.com/guide/practices/ui_guidelines/icon_design_adaptive)
+- [Android - Supporting multiple screens](http://developer.android.com/guide/practices/screens_support.html)
+
+## Browser
+Icons are not applicable to the Browser platform.
+
+## iOS
+```xml
+ <platform name="ios">
+ <!-- iOS 8.0+ -->
+ <!-- iPhone 6 Plus -->
+ <icon src="res/ios/icon-60@3x.png" width="180" height="180" />
+ <!-- iOS 7.0+ -->
+ <!-- iPhone / iPod Touch -->
+ <icon src="res/ios/icon-60.png" width="60" height="60" />
+ <icon src="res/ios/icon-60@2x.png" width="120" height="120" />
+ <!-- iPad -->
+ <icon src="res/ios/icon-76.png" width="76" height="76" />
+ <icon src="res/ios/icon-76@2x.png" width="152" height="152" />
+ <!-- Spotlight Icon -->
+ <icon src="res/ios/icon-40.png" width="40" height="40" />
+ <icon src="res/ios/icon-40@2x.png" width="80" height="80" />
+ <!-- iOS 6.1 -->
+ <!-- iPhone / iPod Touch -->
+ <icon src="res/ios/icon.png" width="57" height="57" />
+ <icon src="res/ios/icon@2x.png" width="114" height="114" />
+ <!-- iPad -->
+ <icon src="res/ios/icon-72.png" width="72" height="72" />
+ <icon src="res/ios/icon-72@2x.png" width="144" height="144" />
+ <!-- iPad Pro -->
+ <icon src="res/ios/icon-167.png" width="167" height="167" />
+ <!-- iPhone Spotlight and Settings Icon -->
+ <icon src="res/ios/icon-small.png" width="29" height="29" />
+ <icon src="res/ios/icon-small@2x.png" width="58" height="58" />
+ <icon src="res/ios/icon-small@3x.png" width="87" height="87" />
+ <!-- iPad Spotlight and Settings Icon -->
+ <icon src="res/ios/icon-50.png" width="50" height="50" />
+ <icon src="res/ios/icon-50@2x.png" width="100" height="100" />
+ <!-- iTunes Marketing Image -->
+ <icon src="res/ios/icon-1024.png" width="1024" height="1024" />
+ </platform>
+```
+### See Also
+- [App Icons on iPad and iPhone](https://developer.apple.com/library/content/qa/qa1686/_index.html)
+
+## Windows
+
+For Windows the recommended approach to define application icons is to use the `target` attribute.
+
+```xml
+ <platform name="windows">
+ <icon src="res/windows/storelogo.png" target="StoreLogo" />
+ <icon src="res/windows/smalllogo.png" target="Square30x30Logo" />
+ <icon src="res/windows/Square44x44Logo.png" target="Square44x44Logo" />
+ <icon src="res/windows/Square70x70Logo.png" target="Square70x70Logo" />
+ <icon src="res/windows/Square71x71Logo.png" target="Square71x71Logo" />
+ <icon src="res/windows/Square150x150Logo.png" target="Square150x150Logo" />
+ <icon src="res/windows/Square310x310Logo.png" target="Square310x310Logo" />
+ <icon src="res/windows/Wide310x150Logo.png" target="Wide310x150Logo" />
+ </platform>
+```
+
+where `src` is the path to the icon which needs to be added.
+
+The Windows platform handles MRT icons automatically, so if you specify `src="res/windows/storelogo.png"` the following files will be copied into the application's `images` folder: `res/windows/storelogo.scale-100.png`, `res/windows/storelogo.scale-200.png`, etc.
+
+TODO Define what MRT is.
+
+The `target` attribute specifies the base name for the resultant icons. For every icon file, its destination filename is calculated as `target + '.' + MRT_qualifiers + extension(src)`. For the icons to display properly in the application, every `target` value should be one of the icon filenames defined in the application's `.appxmanifest` file.
+
+Summarizing the above... using the `target` attribute it is possible to:
+
+ * define a group of icons for different device scale factors using a single `<icon ...>` element, for example:
+```xml
+ <icon src="res/windows/AppListIcon.png" target="Square44x44Logo" />
+```
+ which is equivalent to the following lines:
+```xml
+ <icon src="res/windows/Square44x44Logo.scale-100.png" width="44" height="44" />
+ <icon src="res/windows/Square44x44Logo.scale-150.png" width="66" height="66" />
+ <icon src="res/windows/Square44x44Logo.scale-200.png" width="88" height="88" />
+ <icon src="res/windows/Square44x44Logo.scale-240.png" width="106" height="106" />
+```
+ * define icons with scale factors other than `scale-100` and `scale-240` (and any other MRT qualifiers)
+
+Although it is not recommended, it is also possible to define icons using the `width` and `height` attributes:
+
+```xml
+ <platform name="windows">
+ <icon src="res/windows/logo.png" width="150" height="150" />
+ <icon src="res/windows/smalllogo.png" width="30" height="30" />
+ <icon src="res/windows/storelogo.png" width="50" height="50" />
+ <icon src="res/windows/Square44x44Logo.scale-100.png" width="44" height="44" />
+ <icon src="res/windows/Square44x44Logo.scale-240.png" width="106" height="106" />
+ <icon src="res/windows/Square70x70Logo.scale-100.png" width="70" height="70" />
+ <icon src="res/windows/Square71x71Logo.scale-100.png" width="71" height="71" />
+ <icon src="res/windows/Square71x71Logo.scale-240.png" width="170" height="170" />
+ <icon src="res/windows/Square150x150Logo.scale-240.png" width="360" height="360" />
+ <icon src="res/windows/Square310x310Logo.scale-100.png" width="310" height="310" />
+ <icon src="res/windows/Wide310x150Logo.scale-100.png" width="310" height="150" />
+ <icon src="res/windows/Wide310x150Logo.scale-240.png" width="744" height="360" />
+ </platform>
+```
+
+### See Also:
+- [Windows 10 platform guidelines for icons](https://msdn.microsoft.com/en-us/library/windows/apps/mt412102.aspx).
+- [Windows 8.1 tiles and icons sizes](https://msdn.microsoft.com/en-us/library/windows/apps/xaml/hh781198.aspx)
+
+[splashscreen_plugin]: ../reference/cordova-plugin-splashscreen/
+
+## Electron
+
+### Customizing the Application's Icon
+
+Customized icon(s) can be declared with the `<icon>` element(s) in the `config.xml` file. There are two types of icons that can be defined, the application icon and the package installer icon. These icons should be defined in the Electron's platform node `<platform name="electron">`.
+
+One icon can be used for the application and installer, but this icon should be at least **512x512** pixels to work across all operating systems.
+
+_Notice: If a customized icon is not provided, the Apache Cordova default icons are used._
+
+_Notice: macOS does not display custom icons when using `cordova run`. It defaults to the Electron's icon._
+
+```xml
+<platform name="electron">
+ <icon src="res/electron/icon.png" />
+</platform>
+```
+
+You can supply unique icons for the application and installer by setting the `target` attribute. As mentioned above, the installer image should be **512x512** pixels to work across all platforms.
+
+```xml
+<platform name="electron">
+ <icon src="res/electron/app.png" target="app" />
+ <icon src="res/electron/installer.png" target="installer" />
+</platform>
+```
+
+For devices that support high-DPI resolutions, such as Apple's Retina display, you can create a set of images with the same base filename but suffix with its multiplier.
+
+For example, if the base image's filename `icon.png` and is the standard resolution, then `icon@2x.png` will be treated as a high-resolution image that with a DPI doubled from the base.
+
+- icon.png (256px x 256px)
+- icon@2x.png (512px x 512px)
+
+If you want to support displays with different DPI densities at the same time, you can put images with different sizes in the same folder and use the filename without DPI suffixes. For example:
+
+```xml
+<platform name="electron">
+ <icon src="res/electron/icon.png" />
+ <icon src="res/electron/icon@1.5x.png" />
+ <icon src="res/electron/icon@2x.png" />
+ <icon src="res/electron/icon@4x.png" target="installer" />
+</platform>
+```
diff --git a/www/docs/en/11.x/config_ref/index.md b/www/docs/en/11.x/config_ref/index.md
new file mode 100644
index 0000000..934c2a3
--- /dev/null
+++ b/www/docs/en/11.x/config_ref/index.md
@@ -0,0 +1,556 @@
+---
+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: Config.xml
+description: List of supported tags in the config.xml file.
+---
+
+# Config.xml
+
+`config.xml` is a global configuration file that controls many aspects
+of a cordova application's behavior. This
+platform-agnostic XML file is arranged based on the W3C's [Packaged
+Web Apps (Widgets)](http://www.w3.org/TR/widgets/) specification, and
+extended to specify core Cordova API features, plugins, and
+platform-specific settings.
+
+For projects created with the Cordova CLI (described in [The
+Command-Line Interface](../guide/cli/index.html)), this file can be found in the top-level
+directory:
+
+```
+app/config.xml
+```
+
+Note that before version 3.3.1-0.2.0, the file existed at `app/www/config.xml`,
+and that having it here is still supported.
+
+When using the CLI to build a project, versions of this file are
+passively copied into various `platforms/` subdirectories.
+For example:
+
+```
+app/platforms/ios/AppName/config.xml
+app/platforms/android/res/xml/config.xml
+```
+
+In addition to the various configuration options detailed below, you
+can also configure an application's core set of images for each target
+platform. See [Customize icons topic](images.html) for more information.
+
+# widget
+Root element of the config.xml document.
+
+Attributes(type) <br/> <span class="sub-header">Only for platform:</span> | Description
+---------------- | ------------
+id(string) | *Required* <br/> Specifies the app's identifier. The `id` should be in a [reverse-DNS format](https://en.wikipedia.org/wiki/Reverse_domain_name_notation#Examples) however, only alphanumeric and dot characters are allowed. e.g: `com.example.myapp`
+version(string) | *Required* <br/> Full version number expressed in major/minor/patch notation.
+android-versionCode(string) <br/> ==Android== | Alternative version for Android. Sets the [version code](http://developer.android.com/tools/publishing/versioning.html) for the application. See [the Android guide](../guide/platforms/android/index.html#setting-the-version-code) for information on how this attribute may be modified.
+ios-CFBundleVersion(string) <br/> ==iOS== | Alternative version for iOS. For further details, see [iOS versioning](https://developer.apple.com/library/ios/documentation/General/Reference/InfoPlistKeyReference/Articles/CoreFoundationKeys.html#//apple_ref/doc/uid/20001431-102364).
+osx-CFBundleVersion(string) <br/> ==OS X== | Alternative version for OS X. For further details, see [OS X versioning](https://developer.apple.com/library/prerelease/mac/documentation/General/Reference/InfoPlistKeyReference/Articles/CoreFoundationKeys.html#//apple_ref/doc/uid/20001431-102364).
+windows-packageVersion(string) <br/> ==Windows== | Alternative version for Windows. For futher details, see [Windows versioning](https://msdn.microsoft.com/en-us/library/windows/apps/br211441.aspx)
+android-packageName(string) <br/> ==Android== | Alternative package name for Android, overrides `id`.
+ios-CFBundleIdentifier(string) <br/> ==iOS== | Alternative bundle id for iOS. Overrides `id`.
+packageName(string) <br/> ==Windows== | *Default: Cordova.Example* <br/> Package name for Windows.
+defaultlocale <br /> ==iOS== ==Windows== | Specified the default language of the app, as an IANA language code.
+android-activityName(string) <br/> ==Android== | Set the activity name for your app in AndroidManifest.xml. Note that this is only set once after the Android platform is first added.
+xmlns(string) | *Required* <br/> Namespace for the config.xml document.
+xmlns:cdv(string) | *Required* <br/> Namespace prefix.
+
+Examples:
+
+```xml
+<!-- Android -->
+<widget id="io.cordova.hellocordova" version="0.0.1" android-versionCode="13" xmlns="http://www.w3.org/ns/widgets" xmlns:cdv="http://cordova.apache.org/ns/1.0">
+</widget>
+
+<!-- iOS -->
+<widget id="io.cordova.hellocordova" version="0.0.1" ios-CFBundleVersion="0.1.3" xmlns="http://www.w3.org/ns/widgets" xmlns:cdv="http://cordova.apache.org/ns/1.0">
+</widget>
+
+<!-- Windows -->
+<widget id="io.cordova.hellocordova" version="0.0.1" windows-packageVersion="0.1.3" xmlns="http://www.w3.org/ns/widgets" xmlns:cdv="http://cordova.apache.org/ns/1.0">
+</widget>
+
+<!-- OS X -->
+<widget id="io.cordova.hellocordova" version="0.0.1" osx-CFBundleVersion="0.1.3" xmlns="http://www.w3.org/ns/widgets" xmlns:cdv="http://cordova.apache.org/ns/1.0">
+</widget>
+```
+
+## name
+Specifies the app's formal name, as it appears on the device's home screen and within app-store interfaces.
+
+Examples:
+
+```xml
+<widget ...>
+ <name>HelloCordova</name>
+</widget>
+```
+
+### short name
+Specifies an optional display name for the app. Sometimes the app name should be displayed differently on device's home screen than on informational and app-store interfaces due to limited space.
+
+Examples:
+
+```xml
+<widget ...>
+ <name short="HiCdv">HelloCordova</name>
+</widget>
+```
+
+## description
+Specifies metadata that may appear within app-store listings.
+
+Examples:
+
+```xml
+<widget ...>
+ <description>A sample Apache Cordova application</description>
+</widget>
+```
+
+## author
+Specifies contact information that may appear within app-store listings.
+
+Attributes(type) <br/> <span class="sub-header">Only for platform:</span> | Description
+----------------- | ------------
+email(string) | *Required* <br/> Email of the author.
+href(string) | *Required* <br/> Website of the author.
+
+Examples:
+
+```xml
+<widget ...>
+ <author email="dev@cordova.apache.org" href="http://cordova.io"></author>
+</widget>
+```
+
+
+## content
+Defines the app's starting page in the top-level web assets directory. The default value is index.html, which customarily
+appears in a project's top-level ```www``` directory.
+
+Attributes(type) <br/> <span class="sub-header">Only for platform:</span> | Description
+----------------- | ------------
+src(string) | *Required* <br/> Defines the app's starting page in the top-level web assets directory. The default value is index.html, which customarily
+appears in a project's top-level ```www``` directory.
+
+Examples:
+
+```xml
+<widget ...>
+ <content src="startPage.html"></content>
+</widget>
+```
+
+## access
+Defines the set of external domains the app is allowed to communicate with. The default value shown above allows it to access any server.
+See the Domain [Whitelist Guide](../guide/appdev/whitelist/index.html) for details.
+
+Attributes(type) <br/> <span class="sub-header">Only for platform:</span> | Description
+----------------- | ------------
+origin(string) | *Required* <br/> Defines the set of external domains the app is allowed to communicate with.
+The default value shown above allows it to access any server.
+See the Domain [Whitelist Guide](../guide/appdev/whitelist/index.html) for details.
+
+Examples:
+
+```xml
+<widget ...>
+ <access origin="*"></access>
+</widget>
+
+<widget ...>
+ <access origin="http://google.com"></access>
+</widget>
+```
+
+
+## allow-navigation
+Controls which URLs the WebView itself can be navigated to. Applies to top-level navigations only.
+
+Attributes(type) <br/> <span class="sub-header">Only for platform:</span> | Description
+----------------- | ------------
+href(string) | *Required* <br/> Defines the set of external domains the WebView is allowed to navigate to.
+See the cordova-plugin-whitelist [cordova-plugin-whitelist][whitelist_navigation] for details.
+
+Examples:
+
+```xml
+<!-- Allow links to example.com -->
+<allow-navigation href="http://example.com/*" />
+
+<!-- Wildcards are allowed for the protocol, as a prefix to the host, or as a suffix to the path -->
+<allow-navigation href="*://*.example.com/*" />
+```
+
+## allow-intent
+Controls which URLs the app is allowed to ask the system to open. By default, no external URLs are allowed.
+
+Attributes(type) <br/> <span class="sub-header">Only for platform:</span> | Description
+----------------- | ------------
+href(string) | *Required* <br/> Defines which URLs the app is allowed to ask the system to open.
+See the cordova-plugin-whitelist [cordova-plugin-whitelist][whitelist_intent] for details.
+
+Examples:
+
+```xml
+<allow-intent href="http://*/*" />
+<allow-intent href="https://*/*" />
+<allow-intent href="tel:*" />
+<allow-intent href="sms:*" />
+```
+## edit-config
+
+See [<edit-config> docs][edit_config] for plugin.xml.
+
+## config-file
+
+See [<config-file> docs][config_file] for plugin.xml.
+
+## engine
+Specifies details about what platform to restore during a prepare.
+
+Attributes(type) <br/> <span class="sub-header">Only for platform:</span> | Description
+----------------- | ------------
+name(string) | *Required* <br/> Name of the platform to be restored
+spec(string) | *Required* <br/> Details about the platform to be restored. This could be a ```major.minor.patch``` version number, a directory containing the platform or a url pointing to a git repository. This information will be used to retrieve the platform code to restore from NPM, a local directory or a git repository. See [Platform Spec][platform_spec] for further details.
+
+Examples:
+
+```xml
+<engine name="android" spec="https://github.com/apache/cordova-android.git#5.1.1" />
+<engine name="ios" spec="^4.0.0" />
+```
+
+## plugin
+Specifies details about what plugin to restore during a prepare. This element
+is automatically added to a project's `config.xml` when a plugin is added using
+the `--save` flag. See the [CLI reference][plugin_cli] for more information on
+adding plugins.
+
+Attributes(type) <br/> <span class="sub-header">Only for platform:</span> | Description
+----------------- | ------------
+name(string) | *Required* <br/> Name of the plugin to be restored
+spec(string) | *Required* <br/> Details about the plugin to be restored. This could be a ```major.minor.patch``` version number, a directory containing the plugin or a url pointing to a git repository. This information will be used to retrieve the plugin code to restore from NPM, a local directory or a git repository. See [Plugin Spec][plugin_spec] for further details.
+
+Examples:
+
+```xml
+<plugin name="cordova-plugin-device" spec="^1.1.0" />
+<plugin name="cordova-plugin-device" spec="https://github.com/apache/cordova-plugin-device.git#1.0.0" />
+```
+
+### variable
+Persists the value of a CLI variable to be used when restoring a plugin during a
+prepare. This element is added to `config.xml` when a plugin that uses CLI variables
+is added using the `--save` flag. See the [CLI reference][plugin_cli] for more
+information on adding plugins.
+
+Note that this value is only used when the plugin is restored to the project during a
+prepare, changing it will *not* change the value used by the plugin in the current
+project. In order for changes to this value to take effect, remove the plugin from the
+project and restore it by running `cordova prepare`. See the
+[preference element][plugin_preference] of `plugin.xml` for more details on CLI variables.
+
+Attributes(type) <br/> <span class="sub-header">Only for platform:</span> | Description
+----------------- | ------------
+name(string) | *Required* <br/> Name of the CLI variable. Can only contain capital letters, digits, and underscores.
+value(string) | *Required* <br/> Value of the CLI variable to be used when restoring the parent plugin during a prepare.
+
+Examples:
+
+```xml
+<plugin name="cordova-plugin-device" spec="^1.1.0">
+ <variable name="MY_VARIABLE" value="my_variable_value" />
+</plugin>
+```
+
+## preference
+Sets various options as pairs of name/value attributes. Each preference's name is case-insensitive. Many preferences are unique to specific platforms,
+and will be indicated as such.
+
+Attributes(type) <br/> <span class="sub-header">Only for platform:</span> | Description
+----------------- | ------------
+AllowInlineMediaPlayback(boolean) <br/> ==iOS== | *Default: false* <br/> Set to true to allow HTML5 media playback to appear inline within the screen layout, using browser-supplied controls rather than native controls. For this to work, add the ```playsinline``` attribute to any ```<video>``` elements. *NOTE*: Prior to iOS 10, ```<video>``` elements need to use the ```webkit-playsinline``` attribute name instead.
+AllowNewWindows(boolean) <br/> ==iOS== | *Default: false* <br/> Set to true to allow JavaScript `window.open` and HTML `target="\_blank"` links to open a new view overlaying the web view.
+AndroidLaunchMode(string) <br/> ==Android== | *Default: singleTop* <br/> Allowed values: standard, singleTop, singleTask, singleInstance <br/> Sets the Activity android:launchMode attribute. This changes what happens when the app is launched from app icon or intent and is already running.
+AndroidInsecureFileModeEnabled(boolean) <br/> ==Android== | *Default: false* <br/> If set to `true` loading `file:///` URLs is allowed. __Note__: Enabling this setting allows malicious scripts loaded in a file:// context to launch cross-site scripting attacks, either accessing arbitrary local files including WebView cookies, app private data or even credentials used on arbitrary web sites.
+android-maxSdkVersion(integer) <br/> ==Android== | *Default: Not Specified* <br/> Sets the `maxSdkVersion` attribute of the `<uses-sdk>` tag in the project's `AndroidManifest.xml` (see [here][uses-sdk]).
+android-minSdkVersion(integer) <br/> ==Android== | *Default: Dependent on cordova-android Version* <br/> Sets the `minSdkVersion` attribute of the `<uses-sdk>` tag in the project's `AndroidManifest.xml` (see [here][uses-sdk]).
+android-targetSdkVersion(integer) <br/> ==Android== | *Default: Dependent on cordova-android Version* <br/> Sets the `targetSdkVersion` attribute of the `<uses-sdk>` tag in the project's `AndroidManifest.xml` (see [here][uses-sdk]).
+AppendUserAgent(string) <br/> ==Android== ==iOS== | If set, the value will append to the end of old UserAgent of webview. When using with OverrideUserAgent, this value will be ignored.
+BackgroundColor(string) <br/> ==Android== ==iOS== ==Windows== | Sets the app's background color. Supports a four-byte hex value, with the first byte representing the alpha channel, and standard RGB values for the following three bytes. <br/> For Windows, the alpha channel is ignored. <br/> __Note__: `transparent` value will set the application tile background to the accent color on Windows.
+BackupWebStorage(string) <br/> ==iOS== | *Default: cloud* <br/> Allowed values: none, local, cloud. <br/> Set to cloud to allow web storage data to backup via iCloud. Set to local to allow only local backups via iTunes sync. Set to none prevent web storage backups.
+CordovaWebViewEngine(string) <br/> ==iOS== | *Default: CDVWebViewEngine* <br/> This sets the WebView engine plugin to be used to render the host app. The plugin must conform to the CDVWebViewEngineProtocol protocol. The 'value' here should match the 'feature' name of the WebView engine plugin that is installed. This preference usually would be set by the WebView engine plugin that is installed, automatically.
+DefaultVolumeStream(string) <br/> ==Android== | *Default: default* <br/> Added in cordova-android 3.7.0, This preference sets which volume the hardware volume buttons link to. By default this is "call" for phones and "media" for tablets. Set this to "media" to have your app's volume buttons always change the media volume. Note that when using Cordova's media plugin, the volume buttons will dynamically change to controlling the media volume when any Media objects are active.
+DisallowOverscroll(boolean) <br/> ==iOS== ==Android== | *Default: false* <br/> Set to **true** if you don't want the interface to display any feedback when users scroll past the beginning or end of content. On iOS, overscroll gestures cause content to bounce back to its original position. on Android, they produce a more subtle glowing effect along the top or bottom edge of the content. <br/>
+EnableViewportScale(boolean) <br/> ==iOS== | *Default: false* <br/> Set to true to allow a viewport meta tag to either disable or restrict the range of user scaling, which is enabled by default. Place a viewport such as the following in the HTML to disable scaling and fit content flexibly within the rendering WebView: <br/> ```<meta name='viewport' content='width=device-width, initial-scale=1, user-scalable=no' />```
+EnableWebGL(boolean) <br/> ==OS X== | *Default: false* <br/> **(OS X 4.0.0+)** Set to true to enable WebGL on the web view.
+ErrorUrl(URL) <br/> ==Android== | *Default: null* <br/> If set, will display the referenced page upon an error in the application instead of a dialog with the title "Application Error".
+ErrorUrl(string) <br/> ==iOS== | If set, will display the referenced local page upon an error in the application.
+ForegroundText(string) <br/> ==Windows== | *Default: "light"* <br/> Works for Windows 8.1 projects only. Allowed values: "light", "dark". Set to "dark" if you use the `BackgroundColor="white"` or another light color to avoid Windows Store submissions errors.
+FullScreen(boolean) <br/> ==Android== | *Default: false* <br/> Allows you to hide the status bar at the top of the screen. <br/> __Note__: Recommended platform-agnostic way to achieve this is to use the [StatusBar plugin][statusbar_plugin].
+GapBetweenPages(float) <br/> ==iOS== | *Default: 0* <br/> The size of the gap, in points, between pages.
+HideMousePointer(integer) <br/> ==OS X== | *Default: -1* <br/> **(OS X 4.0.0+)** Sets the timeout for hiding the mouse pointer. Set to 0 for immediate, set to -1 for never.
+GradlePluginGoogleServicesEnabled (boolean) <br/> ==Android== | *Default: false* <br/> Set to true to enable the Google Services Gradle plugin.
+GradlePluginGoogleServicesEnabled (semver) <br/> ==Android== | *Default: 4.2.0* <br/> Set version of Google Services Gradle plugin to be used.
+GradlePluginKotlinEnabled (boolean) <br/> ==Android== | *Default: false* <br/> Set to true to allow Kotlin files to be built.
+GradlePluginKotlinCodeStyle (string) <br/> ==Android== | *Default: official* <br/> Allowed values: official, obsolete<br/> Sets how the Kotlin code is formatting for readability.
+GradlePluginKotlinVersion (semver) <br/> ==Android== | *Default: 1.3.50* <br/> Set the version of the Kotlin Gradle plugin to be used.
+InAppBrowserStorageEnabled (boolean) <br/> ==Android== | *Default: true* <br/> Controls whether pages opened within an InAppBrowser can access the same localStorage and WebSQL storage as pages opened with the default browser.
+KeepRunning(boolean) <br/> ==Android== | *Default: true* <br/> Determines whether the application stays running in the background even after a [pause](../../../cordova/events/events.pause.html) event fires. Setting this to false does not kill the app after a [pause](../../../cordova/events/events.pause.html) event, but simply halts execution of code within the cordova webview while the app is in the background.
+KeyboardDisplayRequiresUserAction(boolean) <br/> ==iOS== | *Default: true* <br/> Set to false to allow the keyboard to appear when calling focus() on form inputs.
+LoadUrlTimeoutValue(number in milliseconds) <br/> ==Android== | *Default: 20000, 20 seconds* <br/> When loading a page, the amount of time to wait before throwing a timeout error.
+LoadingDialog(string) <br/> ==Android== | *Default: null* <br/> If set, displays a dialog with the specified title and message, and a spinner, when loading the first page of an application. The title and message are separated by a comma in this value string, and that comma is removed before the dialog is displayed.
+LogLevel(string) <br/> ==Android== | *Default: DEBUG* <br/> Allowed values: ERROR, WARN, INFO, DEBUG, VERBOSE <br/> Sets the minimum log level through which log messages from your application will be filtered.
+MediaPlaybackAllowsAirPlay(boolean) <br/> ==iOS== | *Default: true* <br/> Set to false to prevent Air Play from being used in this view. Available in default UIWebView and WKWebView.
+MediaPlaybackRequiresUserAction(boolean) <br/> ==iOS== | *Default: false* <br/> Set to true to prevent HTML5 videos or audios from playing automatically with the autoplay attribute or via JavaScript.
+Min/Max Version(Regex) <br/> ==Windows== | Allowed values: **/(Microsoft.+? | Windows.+?)-(MinVersion | MaxVersionTested)/i** <br/> Identifies the ecosystems and their min/max versions the app is compatible with. There are three parts to each value: the **SDK**, the **version restriction**, and the **version value**. These preferences are detected by beginning with `Windows` or `Microsoft` and ending in `-MinVersion` or `-MaxVersionTested`: <ul><li>The **SDK** defines what spe [...]
+Orientation(string) | *Default: default* <br/> Allowed values: default, landscape, portrait <br/> Allows you to lock orientation and prevent the interface from rotating in response to changes in orientation. <br/> **NOTE:** The default value means Cordova will strip the orientation preference entry from the platform's manifest/configuration file allowing the platform to fallback to its default behavior. For iOS, to specify both portrait & landscape mode you would use the platform specifi [...]
+OSXLocalStoragePath(string) <br/> ==OS X== | *Default: `~/Library/Application Support/{bundle.id}`* <br/> **(OS X 4.0.0+)** Sets the directory for the local storage path.
+OverrideUserAgent(string) <br/> ==Android== ==iOS== | If set, the value will replace the old UserAgent of webview. It is helpful to identify the request from app/browser when requesting remote pages. Use with caution, this may cause compatibility issues with web servers. For most cases, use AppendUserAgent instead.
+PageLength(float) <br/> ==iOS== | *Default: 0* <br/> The size of each page, in points, in the direction that the pages flow. When PaginationMode is right to left or left to right, this property represents the width of each page. When PaginationMode is topToBottom or bottomToTop, this property represents the height of each page. The default value is 0, which means the layout uses the size of the viewport to determine the dimensions of the page.
+PaginationBreakingMode(string) <br/> ==iOS== | *Default: page* <br/> Allowed values: page, column <br/> Valid values are page and column.The manner in which column- or page-breaking occurs. This property determines whether certain CSS properties regarding column- and page-breaking are honored or ignored. When this property is set to column, the content respects the CSS properties related to column-breaking in place of page-breaking.
+PaginationMode(string) <br/> ==iOS== | *Default: unpaginated* <br/> Allowed values: unpaginated, leftToRight, topToBottom, bottomToTop, rightToLeft <br/> This property determines whether content in the web view is broken up into pages that fill the view one screen at a time,or shown as one long scrolling view. If set to a paginated form, this property toggles a paginated layout on the content, causing the web view to use the values of PageLength and GapBetweenPages to relayout its content.
+PreferredContentMode(string) <br/> ==iOS== | *Default: auto* <br/> Sets the content mode (user agent) for the WebView and InAppBrowsers WebView on iPads. Valid values are: `mobile` and `desktop`.
+InAppBrowserStatusBarStyle(string) <br/> ==iOS== | *Default: default* <br/> Set text color style of the StatusBar for InAppBrowser for iOS. Valid values are: `lightcontent` and `default`.
+SetFullscreen(boolean) <br/> ==Android== | *Default: false* <br/> Same as the Fullscreen parameter in the global configuration of this xml file. This Android-specific element is deprecated in favor of the global Fullscreen element, and will be removed in a future version.
+ShowTitle(boolean) <br/> ==Android== | *Default: false* <br/> Show the title at the top of the screen.
+SplashScreenBackgroundColor <br/> ==Windows== | *Default: #464646* <br/> Sets the splashscreen background color. Supports a CSS color name or a four-byte hex value, with the first byte representing the alpha channel, and standard RGB values for the following three bytes. <br/> The alpha channel is ignored although `transparent` value will cause black/white background color in case of Dark/Light theme accordingly.
+Suppresses3DTouchGesture(boolean) <br/> ==iOS== | *Default: false* <br/> Set to true to avoid 3D Touch capable iOS devices rendering a magnifying glass widget when the user applies force while longpressing the webview. Test your app thoroughly since this disables onclick handlers, but plays nice with ontouchend. If this setting is true, SuppressesLongPressGesture will effectively be true as well.
+SuppressesIncrementalRendering(boolean) <br/> ==iOS== | *Default: false* <br/> Set to true to wait until all content has been received before it renders to the screen.
+SuppressesLongPressGesture(boolean) <br/> ==iOS== | *Default: false* <br/> Set to true to avoid iOS9+ rendering a magnifying glass widget when the user longpresses the webview. Test your app thoroughly since this may interfere with text selection capabilities.
+SwiftVersion(string) <br/> ==iOS== | *Default: (empty)* <br /> Set to specify the Swift Version.
+TopActivityIndicator(string) <br/> ==iOS== | *Default: gray* <br/> Allowed values: whiteLarge, white, gray. <br/> <br/> Controls the appearance of the small spinning icon in the status bar that indicates significant processor activity.
+uap-target-min-version(string) <br/> ==Windows== | This property sets the MinTargetVersion for the Windows UAP. If not specified, this is set to the initial release version 10.0.10240.0 <br/> **Note:** This preference is set in the jsproj file and not in the appxmanifest file. So users with OS version lower than this value would not be able to run the app.
+UIWebViewDecelerationSpeed(string) <br/> ==iOS== | *Default: normal* <br/> Allowed values: normal, fast <br/> This property controls the deceleration speed of momentum scrolling. normal is the default speed for most native apps, and fast is the default for Mobile Safari.
+WindowSize(string) <br/> ==OS X== | *Default: auto* <br/> **(OS X 4.0.0+)** Sets the size of the application window. <br/> Accepts the format `WxH` for a specific width and height or the special values `auto` and `fullscreen`. The latter will open a borderless window spanning the entire desktop area. Please note, that this is different from the _normal_ OS X fullscreen mode, which would never span multiple displays. <br/> **Note**: The global cordova `fullscreen` preference has no effect [...]
+WindowsDefaultUriPrefix(string) <br/> ==Windows== | Allowed values: `ms-appx://`, `ms-appx-web://` <br/> Identifies whether you want your app to target the local context or remote context as its startup URI. When building for Windows 10, the default is the remote context (`ms-appx-web://`). <br/> In order to have a local-mode application that is not impacted by Remote Mode capability restrictions, you must set this preference to `ms-appx://` and not declare any `<access>` elements with [...]
+WindowsStoreDisplayName(string) <br/> ==Windows== | A friendly name for the publisher that can be displayed to users.
+WindowsStoreIdentityName(string) <br/> ==Windows== | Identity name used for Windows store. The identity defines a globally unique identifier for a package. A package identity is represented as a tuple of attributes of the package. See the [identity page on the package manifest schema reference](https://msdn.microsoft.com/en-us/library/windows/apps/br211441.aspx) for further details.
+WindowsStorePublisherName(string) <br/> ==Windows== | Publisher Display Name.
+WindowsToastCapable(boolean) <br/> ==Windows== | *Default: false* <br/> A value of ```true``` indicates that the app is allowed to provide 'toast notifications'.
+deployment-target(string) <br/> ==iOS== | This sets the IPHONEOS_DEPLOYMENT_TARGET in the build, which ultimately translates to the MinimumOSVersion in the ipa. For more details please refer to Apple's documentation on Deployment Target Settings
+target-device(string) <br/> ==iOS== | *Default: universal* <br/> Allowed values: handset, tablet, universal <br/> This property maps directly to TARGETED_DEVICE_FAMILY in the xcode project. Note that if you target universal (which is the default) you will need to supply screen shots for both iPhone and iPad or your app may be rejected.
+windows-phone-target-version(string) <br/> ==Windows== | Sets the version of Windows Phone for which the package (resulting from ```cordova build```) will target. If none is specified, it will be set to the same version as ```windows-target-version``` (if found).
+windows-target-version(string) <br/> ==Windows== | Sets the version of Windows for which the package (resulting from ```cordova build```) will target. If none is specified, it will be set to '8.1'.
+
+Examples:
+
+```xml
+<preference name="DisallowOverscroll" value="true"/>
+<preference name="Fullscreen" value="true" />
+<preference name="BackgroundColor" value="0xff0000ff"/>
+<preference name="HideKeyboardFormAccessoryBar" value="true"/>
+<preference name="Orientation" value="landscape" />
+
+<!-- iOS only preferences -->
+<preference name="EnableViewportScale" value="true"/>
+<preference name="MediaPlaybackAllowsAirPlay" value="false"/>
+<preference name="MediaPlaybackRequiresUserAction" value="true"/>
+<preference name="AllowInlineMediaPlayback" value="true"/>
+<preference name="BackupWebStorage" value="local"/>
+<preference name="TopActivityIndicator" value="white"/>
+<preference name="SuppressesIncrementalRendering" value="true"/>
+<preference name="GapBetweenPages" value="0"/>
+<preference name="PageLength" value="0"/>
+<preference name="PaginationBreakingMode" value="page"/>
+<preference name="PaginationMode" value="unpaginated"/>
+<preference name="UIWebViewDecelerationSpeed" value="fast" />
+<preference name="ErrorUrl" value="myErrorPage.html"/>
+<preference name="OverrideUserAgent" value="Mozilla/5.0 My Browser" />
+<preference name="AppendUserAgent" value="My Browser" />
+<preference name="target-device" value="universal" />
+<preference name="deployment-target" value="7.0" />
+<preference name="CordovaWebViewEngine" value="CDVWebViewEngine" />
+<preference name="CordovaDefaultWebViewEngine" value="CDVWebViewEngine" />
+<preference name="SuppressesLongPressGesture" value="true" />
+<preference name="Suppresses3DTouchGesture" value="true" />
+
+<!-- Android only preferences -->
+<preference name="KeepRunning" value="false"/>
+<preference name="LoadUrlTimeoutValue" value="10000"/>
+<preference name="InAppBrowserStorageEnabled" value="true"/>
+<preference name="LoadingDialog" value="My Title,My Message"/>
+<preference name="ErrorUrl" value="myErrorPage.html"/>
+<preference name="ShowTitle" value="true"/>
+<preference name="LogLevel" value="VERBOSE"/>
+<preference name="AndroidLaunchMode" value="singleTop"/>
+<preference name="AndroidInsecureFileModeEnabled" value="true" />
+<preference name="DefaultVolumeStream" value="call" />
+<preference name="OverrideUserAgent" value="Mozilla/5.0 My Browser" />
+<preference name="AppendUserAgent" value="My Browser" />
+<preference name="GradlePluginGoogleServicesEnabled" value="true" />
+<preference name="GradlePluginGoogleServicesVersion" value="4.2.0" />
+<preference name="GradlePluginKotlinEnabled" value="true" />
+<preference name="GradlePluginKotlinCodeStyle" value="official" />
+<preference name="GradlePluginKotlinVersion" value="1.3.50" />
+
+<!-- Windows only preferences -->
+<preference name="windows-target-version" value="8.1" />
+<preference name="windows-phone-target-version" value="8.1" />
+<preference name="WindowsDefaultUriPrefix" value="ms-appx://" />
+<preference name="Windows.Mobile-MaxVersionTested" value="10.0.10031.0" />
+<preference name="Windows.Universal-MinVersion" value="10.0.0.0" />
+<preference name="WindowsStoreIdentityName" value="Cordova.Example.ApplicationDataSample" />
+<preference name="WindowsStorePublisherName" value="CN=Contoso Corp, O=Contoso Corp, L=Redmond, S=Washington, C=US" />
+<preference name="WindowsToastCapable" value="true" />
+<preference name="uap-target-min-version" value="10.0.10586.0" />
+
+<!-- OS X only preferences -->
+<preference name="HideMousePointer" value="5"/>
+<preference name="OSXLocalStoragePath" value="~/.myapp/database"/>
+<preference name="WindowSize" value="800x400"/>
+<preference name="EnableWebGL" value="true"/>
+```
+
+## feature
+If you use the CLI to build applications, you use the plugin command to enable device APIs. This does not modify the top-level config.xml file, so the <feature> element does not apply to your workflow. If you work directly in an SDK and using the platform-specific config.xml file as source, you use the <feature> tag to enable device-level APIs and external plugins. They often appear with custom values in platform-specific config.xml files. See the API Reference for details on how to spec [...]
+the [Plugin Development Guide](../guide/hybrid/plugins/index.html) for more information on plugins.
+NOTE: Most of the time, you do NOT want to set this directly.
+
+Attributes(type) <br/> <span class="sub-header">Only for platform:</span> | Description
+----------------- | ------------
+name(string) | *Required* <br/> The name of the plugin to enable.
+
+
+### param
+Used to specify certain plugin parameters such as: what package to retrieve the plugin code from, and whether the plugin code is to be initialized during the Webview's initialization.
+
+Attributes(type) <br/> <span class="sub-header">Only for platform:</span> | Description
+----------------- | ------------
+name(string) <br/> ==iOS== ==OS X== ==Android== | *Required* <br/> Allowed values: android-package, ios-package, osx-package, onload. <br/> 'ios-package', 'osx-package' and 'android-package' are used to specify the name of the package (as specified by the 'value' attribute) to be used to initialize the plugin code, while 'onload' is used to specify whether the corresponding plugin (as specified in the 'value' attribute) is to be instantiated when the controller is initialized.
+value(string or boolean) <br/> ==iOS== ==OS X== ==Android== | *Required* <br/> Specifies the name of the package to be used to initialize the plugin code (when the 'name' attribute is android-package, ios-package or osx-package), specifies the name of the plugin to be loaded during controller initialization (when 'name' attribute is set to 'onload').
+
+
+Examples:
+
+```xml
+<!-- Here is how to specify the Device API for Android projects -->
+<feature name="Device">
+ <param name="android-package" value="org.apache.cordova.device.Device" />
+</feature>
+
+<!-- Here's how the element appears for iOS projects -->
+<feature name="Device">
+ <param name="ios-package" value="CDVDevice" />
+ <param name="onload" value="true" />
+</feature>
+
+<!-- Here's how the element appears for OS X projects -->
+<feature name="Device">
+ <param name="osx-package" value="CDVDevice" />
+ <param name="onload" value="true" />
+</feature>
+```
+
+
+## platform
+When using the CLI to build applications, it is sometimes necessary to specify preferences or other elements specific to a particular platform. Use the <platform> element to specify configuration that should only appear in a single platform-specific config.xml file.
+
+Attributes(type) <br/> <span class="sub-header">Only for platform:</span> | Description
+----------------- | ------------
+name(string) | *Required* <br/> The platform whose preferences are being defined.
+
+Examples:
+
+```xml
+<platform name="android">
+ <preference name="Fullscreen" value="true" />
+</platform>
+```
+
+## hook
+Represents your custom script which will be called by Cordova when
+certain action occurs (for example, after plugin is added or platform
+prepare logic is invoked). This is useful when you need to extend
+default Cordova functionality. See [Hooks Guide](../guide/appdev/hooks/index.html) for more information.
+
+Attributes(type) <br/> <span class="sub-header">Only for platform:</span> | Description
+----------------- | ------------
+type(string) | *Required* <br/> Specifies the action during which the custom script is to be called.
+src(string) | *Required* <br/> Specifies the location of the script to be called when a specific action occurs.
+
+Examples:
+
+```xml
+<hook type="after_plugin_install" src="scripts/afterPluginInstall.js" />
+```
+
+## resource-file
+
+This tag installs resource files into your platform, and is similar to the same tag in plugin.xml. This tag is currently only supported on `cordova-ios@4.4.0` or greater and `cordova-android@6.2.1` or greater.
+
+Attributes(type) <br/> <span class="sub-header">Only for platform:</span> | Description
+---------------- | ------------
+src(string) <br/> ==iOS== ==Android==| *Required* <br/> Location of the file relative to `config.xml`.
+target(string) | Path to where the file will be copied in your directory.
+
+Examples:
+
+For Android:
+```xml
+<resource-file src="FooPluginStrings.xml" target="res/values/FooPluginStrings.xml" />
+```
+
+
+# Sample config.xml
+Below is a sample config.xml file:
+
+```xml
+<?xml version='1.0' encoding='utf-8'?>
+<widget id="io.cordova.hellocordova" version="0.0.1" xmlns="http://www.w3.org/ns/widgets" xmlns:cdv="http://cordova.apache.org/ns/1.0">
+ <name>HelloCordova</name>
+ <description>
+ A sample Apache Cordova application that responds to the deviceready event.
+ </description>
+ <author email="dev@cordova.apache.org" href="http://cordova.io">
+ Apache Cordova Team
+ </author>
+ <content src="index.html" />
+ <plugin name="cordova-plugin-whitelist" spec="1" />
+ <access origin="*" />
+ <allow-intent href="http://*/*" />
+ <allow-intent href="https://*/*" />
+ <allow-intent href="tel:*" />
+ <allow-intent href="sms:*" />
+ <allow-intent href="mailto:*" />
+ <allow-intent href="geo:*" />
+ <platform name="android">
+ <allow-intent href="market:*" />
+ </platform>
+ <platform name="ios">
+ <allow-intent href="itms:*" />
+ <allow-intent href="itms-apps:*" />
+ </platform>
+</widget>
+```
+
+[uses-sdk]: http://developer.android.com/guide/topics/manifest/uses-sdk-element.html
+[platform_spec]: ../reference/cordova-cli/index.html#platform-spec
+[plugin_preference]: ../plugin_ref/spec.html#preference
+[plugin_spec]: ../reference/cordova-cli/index.html#plugin-spec
+[plugin_cli]: ../reference/cordova-cli/index.html#cordova-plugin-command
+[whitelist_navigation]: ../reference/cordova-plugin-whitelist/index.html#navigation-whitelist
+[whitelist_intent]: ../reference/cordova-plugin-whitelist/index.html#intent-whitelist
+[statusbar_plugin]: ../reference/cordova-plugin-statusbar/
+[edit_config]: ../plugin_ref/spec.html#edit-config
+[config_file]: ../plugin_ref/spec.html#config-file
diff --git a/www/docs/en/11.x/cordova/events/events.md b/www/docs/en/11.x/cordova/events/events.md
new file mode 100644
index 0000000..2de50a7
--- /dev/null
+++ b/www/docs/en/11.x/cordova/events/events.md
@@ -0,0 +1,468 @@
+---
+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: Events
+description: List of Cordova JavaScript run-time events.
+---
+
+# Events
+
+There are various events provided by cordova to be used by the application.
+The application code could add listeners for these events. For example:
+
+**HTML File**
+
+```html
+<!DOCTYPE html>
+<html>
+ <head>
+ <title>Device Ready Example</title>
+
+ <script type="text/javascript" charset="utf-8" src="cordova.js"></script>
+ <script type="text/javascript" charset="utf-8" src="example.js"></script>
+ </head>
+ <body onload="onLoad()">
+ </body>
+</html>
+```
+
+**JS File**
+
+```javascript
+// example.js file
+// Wait for device API libraries to load
+//
+function onLoad() {
+ document.addEventListener("deviceready", onDeviceReady, false);
+}
+
+// device APIs are available
+//
+function onDeviceReady() {
+ document.addEventListener("pause", onPause, false);
+ document.addEventListener("resume", onResume, false);
+ document.addEventListener("menubutton", onMenuKeyDown, false);
+ // Add similar listeners for other events
+}
+
+function onPause() {
+ // Handle the pause event
+}
+
+function onResume() {
+ // Handle the resume event
+}
+
+function onMenuKeyDown() {
+ // Handle the menubutton event
+}
+
+// listen for uncaught cordova callback errors
+window.addEventListener("cordovacallbackerror", function (event) {
+ // event.error contains the original error object
+});
+```
+
+**Note**: Applications typically should use `document.addEventListener` to attach an event listener once the [deviceready](#deviceready)
+
+The following table lists the cordova events and the supported platforms:
+
+<!-- START HTML -->
+<table class="compat" width="100%">
+ <thead>
+ <tr>
+ <th>Supported Platforms/<br/>Events</th>
+ <th>android</th>
+ <th>ios</th>
+ <th>Windows</th>
+ </tr>
+ </thead>
+ <tbody>
+ <tr>
+ <th><a href="#deviceready">deviceready</a></th>
+ <td data-col="android" class="y"></td>
+ <td data-col="ios" class="y"></td>
+ <td data-col="win" class="y"></td>
+ </tr>
+ <tr>
+ <th><a href="#pause">pause</a></th>
+ <td data-col="android" class="y"></td>
+ <td data-col="ios" class="y"></td>
+ <td data-col="win" class="y"></td>
+ </tr>
+ <tr>
+ <th><a href="#resume">resume</a></th>
+ <td data-col="android" class="y"></td>
+ <td data-col="ios" class="y"></td>
+ <td data-col="win" class="y"></td>
+ </tr>
+ <tr>
+ <th><a href="#backbutton">backbutton</a></th>
+ <td data-col="android" class="y"></td>
+ <td data-col="ios" class="n"></td>
+ <td data-col="win" class="y"></td>
+ </tr>
+ <tr>
+ <th><a href="#menubutton">menubutton</a></th>
+ <td data-col="android" class="y"></td>
+ <td data-col="ios" class="n"></td>
+ <td data-col="win" class="n"></td>
+ </tr>
+ <tr>
+ <th><a href="#searchbutton">searchbutton</a></th>
+ <td data-col="android" class="y"></td>
+ <td data-col="ios" class="n"></td>
+ <td data-col="win" class="n"></td>
+ </tr>
+ <tr>
+ <th><a href="#startcallbutton">startcallbutton</a></th>
+ <td data-col="android" class="n"></td>
+ <td data-col="ios" class="n"></td>
+ <td data-col="win" class="n"></td>
+ </tr>
+ <tr>
+ <th><a href="#endcallbutton">endcallbutton</a></th>
+ <td data-col="android" class="n"></td>
+ <td data-col="ios" class="n"></td>
+ <td data-col="win" class="n"></td>
+ </tr>
+ <tr>
+ <th><a href="#volumedownbutton">volumedownbutton</a></th>
+ <td data-col="android" class="y"></td>
+ <td data-col="ios" class="n"></td>
+ <td data-col="win" class="n"></td>
+ </tr>
+ <tr>
+ <th><a href="#volumeupbutton">volumeupbutton</a></th>
+ <td data-col="android" class="y"></td>
+ <td data-col="ios" class="n"></td>
+ <td data-col="win" class="n"></td>
+ </tr>
+ <tr>
+ <th><a href="#activated">activated</a></th>
+ <td data-col="android" class="n"></td>
+ <td data-col="ios" class="n"></td>
+ <td data-col="win" class="y"></td>
+ </tr>
+ <tr>
+ <th><a href="#cordovacallbackerror">cordovacallbackerror</a></th>
+ <td data-col="android" class="y"></td>
+ <td data-col="ios" class="y"></td>
+ <td data-col="win" class="y"></td>
+ </tr>
+ </tbody>
+</table>
+<!-- END HTML -->
+
+
+## deviceready
+
+The deviceready event fires when Cordova is fully loaded. This event is
+essential to any application. It signals that Cordova's device APIs have
+loaded and are ready to access.
+
+Cordova consists of two code bases: native and JavaScript. While the
+native code loads, a custom loading image displays. However,
+JavaScript only loads once the DOM loads. This means the web app may
+potentially call a Cordova JavaScript function before the
+corresponding native code becomes available.
+
+The `deviceready` event fires once Cordova has fully loaded. Once the
+event fires, you can safely make calls to Cordova APIs. Applications
+typically attach an event listener with `document.addEventListener`
+once the HTML document's DOM has loaded.
+
+The `deviceready` event behaves somewhat differently from others. Any
+event handler registered after the `deviceready` event fires has its
+callback function called immediately.
+
+### Quick Example
+
+```javascript
+document.addEventListener("deviceready", onDeviceReady, false);
+
+function onDeviceReady() {
+ // Now safe to use device APIs
+}
+```
+
+## pause
+
+The pause event fires when the native platform puts the application into the background,
+typically when the user switches to a different application.
+
+### Quick Example
+
+```javascript
+document.addEventListener("pause", onPause, false);
+
+function onPause() {
+ // Handle the pause event
+}
+```
+
+### iOS Quirks
+
+In the `pause` handler, any calls to the Cordova API or to native
+plugins that go through Objective-C do not work, along with any
+interactive calls, such as alerts or `console.log()`. They are only
+processed when the app resumes, on the next run loop.
+
+The iOS-specific `resign` event is available as an alternative to
+`pause`, and detects when users enable the __Lock__ button to lock the
+device with the app running in the foreground. If the app (and
+device) is enabled for multi-tasking, this is paired with a subsequent
+`pause` event, but only under iOS 5. In effect, all locked apps in iOS
+5 that have multi-tasking enabled are pushed to the background. For
+apps to remain running when locked under iOS 5, disable the app's
+multi-tasking by setting [UIApplicationExitsOnSuspend][UIApplicationExitsOnSuspend]
+to `YES`. To run when locked on iOS 4, this setting does not matter.
+
+## resume
+
+The `resume` event fires when the native platform pulls the application out from the background.
+
+### Quick Example
+
+```javascript
+document.addEventListener("resume", onResume, false);
+
+function onResume() {
+ // Handle the resume event
+}
+```
+
+### iOS Quirks
+
+Any interactive functions called from a [pause](#pause) event handler execute
+later when the app resumes, as signaled by the `resume` event. These
+include alerts, `console.log()`, and any calls from plugins or the
+Cordova API, which go through Objective-C.
+
+- __active__ event
+
+ The iOS-specific `active` event is available as an alternative to
+`resume`, and detects when users disable the __Lock__ button to unlock
+the device with the app running in the foreground. If the app (and
+device) is enabled for multi-tasking, this is paired with a subsequent
+`resume` event, but only under iOS 5. In effect, all locked apps in
+iOS 5 that have multi-tasking enabled are pushed to the background.
+For apps to remain running when locked under iOS 5, disable the app's
+multi-tasking by setting [UIApplicationExitsOnSuspend][UIApplicationExitsOnSuspend]
+to `YES`. To run when locked on iOS 4, this setting does not matter.
+
+- __resume__ event
+
+ When called from a `resume` event handler, interactive functions such
+as `alert()` need to be wrapped in a `setTimeout()` call with a
+timeout value of zero, or else the app hangs. For example:
+
+ ```javascript
+ document.addEventListener("resume", onResume, false);
+ function onResume() {
+ setTimeout(function() {
+ // TODO: do your thing!
+ }, 0);
+ }
+ ```
+
+### Android Quirks
+
+Refer [Android Life Cycle Guide][AndroidLifeCycleGuide] for details on android quirks with
+the `resume` event.
+
+## backbutton
+
+The event fires when the user presses the back button. To override the default
+back-button behavior, register an event listener for the `backbutton` event.
+It is no longer necessary to call any other method to override the
+back-button behavior.
+
+### Quick Example
+
+```javascript
+document.addEventListener("backbutton", onBackKeyDown, false);
+
+function onBackKeyDown() {
+ // Handle the back button
+}
+```
+
+### Windows Quirks
+
+Throw an error in a `backbutton` callback to force the default behavior, which is an app exit:
+
+```javascript
+document.addEventListener('backbutton', function (evt) {
+ if (cordova.platformId !== 'windows') {
+ return;
+ }
+
+ if (window.location.href !== firstPageUrl) {
+ window.history.back();
+ } else {
+ throw new Error('Exit'); // This will suspend the app
+ }
+}, false);
+```
+
+## menubutton
+
+The event fires when the user presses the menu button. Applying an event handler
+overrides the default menu button behavior.
+
+### Quick Example
+
+```javascript
+document.addEventListener("menubutton", onMenuKeyDown, false);
+
+function onMenuKeyDown() {
+ // Handle the back button
+}
+```
+
+## searchbutton
+
+The event fires when the user presses the search button on Android. If you need to
+override the default search button behavior on Android you can register an event
+listener for the 'searchbutton' event.
+
+### Quick Example
+
+```javascript
+document.addEventListener("searchbutton", onSearchKeyDown, false);
+
+function onSearchKeyDown() {
+ // Handle the search button
+}
+```
+
+## startcallbutton
+
+The event fires when the user presses the start call button. If you need to override
+the default start call behavior you can register an event listener for the `startcallbutton` event.
+
+### Quick Example
+
+```javascript
+document.addEventListener("startcallbutton", onStartCallKeyDown, false);
+
+function onStartCallKeyDown() {
+ // Handle the start call button
+}
+```
+
+## endcallbutton
+
+This event fires when the user presses the end call button. The event overrides the
+default end call behavior.
+
+### Quick Example
+
+```javascript
+document.addEventListener("endcallbutton", onEndCallKeyDown, false);
+
+function onEndCallKeyDown() {
+ // Handle the end call button
+}
+```
+
+## volumedownbutton
+
+The event fires when the user presses the volume down button. If you need to override
+the default volume down behavior you can register an event listener for the `volumedownbutton` event.
+
+### Quick Example
+
+```javascript
+document.addEventListener("volumedownbutton", onVolumeDownKeyDown, false);
+
+function onVolumeDownKeyDown() {
+ // Handle the volume down button
+}
+```
+
+## volumeupbutton
+
+The event fires when the user presses the volume up button. If you need to override
+the default volume up behavior you can register an event listener for the `volumeupbutton` event.
+
+### Quick Example
+
+```javascript
+document.addEventListener("volumeupbutton", onVolumeUpKeyDown, false);
+
+function onVolumeUpKeyDown() {
+ // Handle the volume up button
+}
+```
+
+## activated
+
+The event fires when Windows Runtime activation has occurred. See [MSDN docs][MSDNActivatedEvent] for further details and activation types.
+
+### Quick Example
+
+```javascript
+document.addEventListener("activated", activated, false);
+
+function activated(args) {
+ if (args && args.kind === Windows.ApplicationModel.Activation.ActivationKind.file) {
+ // Using args.raw to get the native StorageFile object
+ Windows.Storage.FileIO.readTextAsync(args.raw.detail[0].files[0]).done(function (text) {
+ console.log(text);
+ }, function (err) {
+ console.error(err);
+ });
+ }
+}
+```
+
+### Windows Quirks
+
+* Original activated event args are available in `args.raw.detail[0]` property and can be used to get a type information or invoke methods of one of the activation arguments,
+
+* Original activated event args are also cloned to `args.detail[0]` and can be used as a fallback in case an inner args property has been lost.
+See https://issues.apache.org/jira/browse/CB-10653 for details.
+
+* `activated` event might be fired before `deviceready` so you should save the activation flag and args to the app context in case you need them - for example in the [Share target case](https://issues.apache.org/jira/browse/CB-11924).
+The subscription to the `activated` event should be done before `deviceready` handler (in `app.bindEvents` in terms of the Cordova template).
+
+[UIApplicationExitsOnSuspend]: http://developer.apple.com/library/ios/#documentation/general/Reference/InfoPlistKeyReference/Articles/iPhoneOSKeys.html
+[AndroidLifeCycleGuide]: ../../guide/platforms/android/index.html#lifecycle-guide
+[MSDNActivatedEvent]: https://msdn.microsoft.com/en-us/library/windows/apps/br212679.aspx
+
+## cordovacallbackerror
+
+This event fires when a native callback (success or error) throws an uncaught error.
+
+This does not stop propagation of the error. (eg. window.onerror event will also fire.)
+
+It is slightly different from the other events. You must listen on the `window` object, not the `document` object.
+
+The `event` object has the following properties:
+- `error`: The original `Error` thrown in the callback.
+
+### Quick Example
+
+```javascript
+window.addEventListener("cordovacallbackerror", function (event) {
+ // event.error contains the original error object
+});
+```
diff --git a/www/docs/en/11.x/cordova/storage/storage.md b/www/docs/en/11.x/cordova/storage/storage.md
new file mode 100644
index 0000000..7df3cc0
--- /dev/null
+++ b/www/docs/en/11.x/cordova/storage/storage.md
@@ -0,0 +1,253 @@
+---
+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: Storage
+toc_title: Store data
+description: Storing data on the device.
+---
+
+# Storage
+
+Several storage APIs are available for Cordova applications.
+See html5rocks [storage overview][Html5RocksStorageOverview] and
+[tutorial][Html5RocksStorageTutorial], for a more complete overview and
+examples.
+
+Each API offers advantages and disadvantages, which are summarized here. You
+should choose whichever best suits your needs. You can also use several
+different approaches within a single application for different purposes.
+
+## LocalStorage
+
+Local storage provides simple, synchronous key/value pair storage, and is
+supported by the underlying WebView implementations on all Cordova
+platforms.
+
+### Usage Summary
+
+Local storage can be accessed via `window.localStorage`. The following code
+snippet shows the most important methods exposed by the returned `Storage` object:
+
+```javascript
+var storage = window.localStorage;
+var value = storage.getItem(key); // Pass a key name to get its value.
+storage.setItem(key, value) // Pass a key name and its value to add or update that key.
+storage.removeItem(key) // Pass a key name to remove that key from storage.
+```
+
+For more information, see:
+
+- [W3C: Spec][W3CSpecStorage]
+- [MDN: Storage API][MDNStorage]
+- [MDN: Storage Guide][MDNStorageGuide]
+
+### Advantages
+
+- Supported by all Cordova platforms.
+- Its simple, synchronous API means it is easy to use.
+
+### Disadvantages
+
+- Only stores strings, so complex data structures have to be serialized,
+ and only data that can be serialized can be stored.
+- Performs poorly with large amounts of data. In particular:
+ - The lack of indexing means searches require manually iterating all data.
+ - Storing large or complex items is slow due to the need to serialize/de-serialize.
+ - Synchronous API means calls will lock up the user interface.
+- Limited total amount of storage (typically around 5MB).
+- iOS stores `localStorage` data in a location that may be cleaned out by
+ the OS when space is required.
+
+## IndexedDB
+
+The goal of the IndexedDB API is to combine the strengths of the LocalStorage
+and WebSQL APIs, while avoiding their weaknesses. IndexedDB lets you store
+arbitrary JavaScript objects (provided they are supported by the [structured clone algorithm][StructuredCloneAlgorithm]),
+indexed with a key. It provides some of the benefits of SQL tables, without
+constraining the structure or needing to define it up front.
+
+IndexedDB provides a simple and easy to understand data model, much like LocalStorage.
+But unlike LocalStorage, you can create multiple databases, with multiple stores per
+database, and its asynchronous API and search indexes provide performance benefits.
+
+IndexedDB is supported by the underlying WebView on all platforms, with known limitations on the following platforms:
+
+- browser
+- Windows
+
+### Web browser limitations
+
+The actual behavior may depend on which browser is used.
+There could be differences between the behavior on the Safari and Firefox browsers,
+for example.
+
+### Windows Limitations
+
+Windows platform support for IndexedDB is incomplete. For example, it lacks
+the following features:
+
+- Not available in web workers.
+- Doesn't support array keyPaths.
+- Doesn't support array keys.
+- Doesn't support object lookup via compound index.
+
+### Usage Summary
+
+- IndexedDB works asynchronously - you request a particular database
+ operation, then get notified of the result via a DOM event.
+- When you make a request, you get a request object, which provides `onerror`
+ and `onsuccess` events, as well as properties such as `result`, `error`
+ and `readyState`.
+
+The following code snippet demonstrates some simple usage of IndexedDB:
+
+```javascript
+var db;
+var databaseName = 'myDB';
+var databaseVersion = 1;
+var openRequest = window.indexedDB.open(databaseName, databaseVersion);
+openRequest.onerror = function (event) {
+ console.log(openRequest.errorCode);
+};
+openRequest.onsuccess = function (event) {
+ // Database is open and initialized - we're good to proceed.
+ db = openRequest.result;
+ displayData();
+};
+openRequest.onupgradeneeded = function (event) {
+ // This is either a newly created database, or a new version number
+ // has been submitted to the open() call.
+ var db = event.target.result;
+ db.onerror = function () {
+ console.log(db.errorCode);
+ };
+
+ // Create an object store and indexes. A key is a data value used to organize
+ // and retrieve values in the object store. The keyPath option identifies where
+ // the key is stored. If a key path is specified, the store can only contain
+ // JavaScript objects, and each object stored must have a property with the
+ // same name as the key path (unless the autoIncrement option is true).
+ var store = db.createObjectStore('customers', { keyPath: 'customerId' });
+
+ // Define the indexes we want to use. Objects we add to the store don't need
+ // to contain these properties, but they will only appear in the specified
+ // index of they do.
+ //
+ // syntax: store.createIndex(indexName, keyPath[, parameters]);
+ //
+ // All these values could have duplicates, so set unique to false
+ store.createIndex('firstName', 'firstName', { unique: false });
+ store.createIndex('lastName', 'lastName', { unique: false });
+ store.createIndex('street', 'street', { unique: false });
+ store.createIndex('city', 'city', { unique: false });
+ store.createIndex('zipCode', 'zipCode', { unique: false });
+ store.createIndex('country', 'country', { unique: false });
+
+ // Once the store is created, populate it
+ store.transaction.oncomplete = function (event) {
+ // The transaction method takes an array of the names of object stores
+ // and indexes that will be in the scope of the transaction (or a single
+ // string to access a single object store). The transaction will be
+ // read-only unless the optional 'readwrite' parameter is specified.
+ // It returns a transaction object, which provides an objectStore method
+ // to access one of the object stores that are in the scope of this
+ //transaction.
+ var customerStore = db.transaction('customers', 'readwrite').objectStore('customers');
+ customers.forEach(function (customer) {
+ customerStore.add(customer);
+ });
+ };
+};
+
+function displayData() {
+}
+```
+
+For more information, see:
+
+- [W3C: Spec][W3CIndexedDB]
+- [MDN: IndexedDB API Reference][MDNIndexedDBAPI]
+- [MDN: IndexedDB Basic Concepts][MDNIndexedDBBasicConcepts]
+- [MDN: Using IndexedDB Guide][MDNUsingIndexedDB]
+
+### Advantages
+
+- Good performance - asynchronous API won't block the UI, and indexing provides
+ good search performance.
+- Simple data model easier to learn than SQL.
+- More flexible structure than WebSQL.
+- Multiple databases and object stores provides more structure than LocalStorage.
+- Robustness from using a transactional database model.
+- Support for versioning.
+
+### Disadvantages
+
+- Complex API with nested callbacks.
+- Limited total amount of storage and possible eviction [as described on MDN][MDNIndexedDBLimitsAndEviction].
+
+## Plugin-Based Options
+
+### FileSystem API
+
+The FileSystem API was a W3C spec that was implemented by Chrome, but not other
+browsers. It provides APIs to store and retrieve data on the local file system,
+and is described in some detail in an excellent [html5rocks article][Html5RocksFileSystemTutorial].
+While the API is not supported natively by any Cordova platform, the [File plugin][FileAPI]
+provides an extensive implementation that is available across all Cordova platforms.
+
+### SQLite Plugin
+
+The SQLite plugin provides an API virtually identical to WebSQL described above.
+The main differences are:
+
+- It is available with support for the Windows platform.
+- It effectively has no size limitations.
+
+It is available in the following variations:
+
+* **[cordova-sqlite-storage][SQLiteStorage]** - core version that includes its own sqlite3 implementation. It supports iOS, Android & Windows platforms.
+* **[cordova-sqlite-ext][SQLiteExt]** - extended version with additional
+ features including REGEXP support on Android and iOS.
+* **[cordova-sqlite-evfree][SQLiteEVFree]** - similar to *cordova-sqlite-ext*
+ but with improved memory handling. Available under GPL v3 or commercial license.
+
+### Other Plugins
+
+Search [Cordova plugins][CordovaPlugins] for other plugins that provide
+alternative storage options.
+
+[Html5RocksStorageOverview]: http://www.html5rocks.com/en/features/storage
+[Html5RocksStorageTutorial]: http://www.html5rocks.com/en/tutorials/offline/storage/
+[W3CSpecStorage]: https://html.spec.whatwg.org/multipage/webstorage.html
+[MDNStorage]: https://developer.mozilla.org/en-US/docs/Web/API/Storage
+[MDNStorageGuide]: https://developer.mozilla.org/en-US/docs/Web/API/Web_Storage_API/Using_the_Web_Storage_API
+[w3schoolsSQL]: http://www.w3schools.com/sql/sql_intro.asp
+[SQLite]: https://www.sqlite.org/
+[W3CIndexedDB]: http://www.w3.org/TR/IndexedDB/
+[MDNIndexedDBAPI]: https://developer.mozilla.org/en-US/docs/Web/API/IndexedDB_API
+[MDNIndexedDBBasicConcepts]: https://developer.mozilla.org/en-US/docs/Web/API/IndexedDB_API/Basic_Concepts_Behind_IndexedDB
+[MDNUsingIndexedDB]: https://developer.mozilla.org/en-US/docs/Web/API/IndexedDB_API/Using_IndexedDB
+[MDNIndexedDBLimitsAndEviction]: https://developer.mozilla.org/en-US/docs/Web/API/IndexedDB_API/Browser_storage_limits_and_eviction_criteria
+[StructuredCloneAlgorithm]: http://w3c.github.io/html/infrastructure.html#safe-passing-of-structured-data
+[Html5RocksFileSystemTutorial]: http://www.html5rocks.com/en/tutorials/file/filesystem/
+[FileAPI]: https://github.com/apache/cordova-plugin-file/blob/master/README.md
+[SQLiteStorage]: https://github.com/litehelpers/Cordova-sqlite-storage#readme
+[SQLiteExt]: https://github.com/litehelpers/cordova-sqlite-ext#readme
+[SQLiteEVFree]: https://github.com/litehelpers/Cordova-sqlite-enterprise-free#readme
+[CordovaPlugins]: {{ site.baseurl }}/plugins
diff --git a/www/docs/en/11.x/guide/appdev/allowlist/index.md b/www/docs/en/11.x/guide/appdev/allowlist/index.md
new file mode 100644
index 0000000..688a869
--- /dev/null
+++ b/www/docs/en/11.x/guide/appdev/allowlist/index.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: Allow List Guide
+toc_title: Allow List
+description: Securely grant an application access to external resources.
+---
+
+# Allow List Guide
+
+Domain allow listing is a security model that controls access to external domains over which your application has no control. Cordova provides a configurable security policy to define which external sites may be accessed.
+
+By default, new apps are configured to allow access to any site. Before moving your application to production, you should formulate an allow list to provide access to specific network domains and subdomains.
+
+While it is possible to implement your own allow list plugin, it is not recommended unless your app needs a very specific security policy.
+
+## Network Request Allow List
+
+Cordova adheres to the [W3C Widget Access][1] specification, which relies on the `<access>` element within the app's `config.xml` file, which is located in the project's top-level directory.
+
+This controls which network requests (images, XHRs, etc) are allowed to be made to specific domains (via cordova native hooks).
+
+Note: It is suggested to use a [Content Security Policy (CSP)](#Content-Security-Policy-(CSP)) (see below), which is more secure. This network request allow list is mostly historical for webviews which do not support CSP.
+
+In `config.xml`, add `<access>` tags, like this:
+
+```xml
+<!-- Allow images, xhrs, etc. to google.com -->
+<access origin="http://google.com" />
+<access origin="https://google.com" />
+
+<!-- Access to the subdomain maps.google.com -->
+<access origin="http://maps.google.com" />
+
+<!-- Access to all the subdomains on google.com -->
+<access origin="http://*.google.com" />
+
+<!-- Enable requests to content: URLs -->
+<access origin="content:///*" />
+
+<!-- Don't block any requests -->
+<access origin="*" />
+```
+
+Without any `<access>` tags, only requests to `file://` URLs are allowed. However, the default Cordova application includes `<access origin="*">` by default.
+
+Note: Allow List cannot block network redirects from a allow listed remote website (i.e. `http` or `https`) to a non-allowlisted website. Use CSP rules to mitigate redirects to non-allowlisted websites for webviews that support CSP.
+
+Be aware that some websites may automatically redirect from their home page to a different url. Example scenarios could be, but not limited to:
+
+* Redirecting `http` protocol requests to the secure `https` SSL/TSL protocol.
+* Redirecting to country-specific domain. E.g. `https://www.google.com` to redirect to `https://www.google.co.uk` based on device geography.
+
+Such scenarios may require modified or adding to the allow list additional entries beyond your initial requirement. Please consider this when building the app's allow list.
+
+Quirk: Android also allows requests to https://ssl.gstatic.com/accessibility/javascript/android/ by default, since this is required for TalkBack to function properly.
+
+## Navigation Allow List
+
+This controls which URLs the WebView itself can be navigated to. It applies only to top-level navigations.
+
+By default navigations are only allowed to `file://` URLs. To allow others URLs, you must add `<allow-navigation>` tags to your `config.xml`:
+
+```xml
+<!-- Allow links to example.com -->
+<allow-navigation href="http://example.com/*" />
+
+<!-- Wildcards are allowed for the protocol, as a prefix
+ to the host, or as a suffix to the path -->
+<allow-navigation href="*://*.example.com/*" />
+
+<!--
+ A wildcard can be used to allow the entire network, over HTTP and HTTPS.
+ This is *NOT RECOMMENDED*
+-->
+<allow-navigation href="*" />
+
+<!-- The above is equivalent to these three declarations -->
+<allow-navigation href="http://*/*" />
+<allow-navigation href="https://*/*" />
+<allow-navigation href="data:*" />
+```
+
+Quirks: on Android it also applies to iframes for non-http(s) schemes.
+
+## Intent Allow List
+
+This controls which URLs the app is allowed to ask the system to open.
+
+In `config.xml`, add `<allow-intent>` tags, like this:
+
+```xml
+<!-- Allow links to web pages to open in a browser -->
+<allow-intent href="http://*/*" />
+<allow-intent href="https://*/*" />
+
+<!-- Allow links to example.com to open in a browser -->
+<allow-intent href="http://example.com/*" />
+
+<!-- Wildcards are allowed for the protocol, as a prefix
+ to the host, or as a suffix to the path -->
+<allow-intent href="*://*.example.com/*" />
+
+<!-- Allow SMS links to open messaging app -->
+<allow-intent href="sms:*" />
+
+<!-- Allow tel: links to open the dialer -->
+<allow-intent href="tel:*" />
+
+<!-- Allow geo: links to open maps -->
+<allow-intent href="geo:*" />
+
+<!-- Allow all unrecognized URLs to open installed apps
+ *NOT RECOMMENDED* -->
+<allow-intent href="*" />
+```
+
+Without any `<allow-intent>` tags, no requests to external URLs are allowed. However, the default Cordova application includes a quite liberal set of `allow-intent` entries by default. It is advised to narrow this down based on each app's needs.
+
+On Android, this equates to sending an intent of type **BROWSEABLE**.
+
+This allow list applies only to the main Cordova webview, and does not apply to any plugins, for example the InAppBrowser webview, or opening links in the system web browser. It is only aplied to **hyperlinks** and calls to `window.open()`.
+
+Note: `allow-navigation` takes precedence over `allow-intent`. Allowing navigation to all URLs with `<allow-navigation href="*" />` for example has the side effect of "capturing" all intents, so the webview navigates to them instead of triggering e.g. external apps.
+
+## Content Security Policy (CSP)
+
+Controls which network requests (images, XHRs, etc) are allowed to be made (via webview directly).
+
+On Android and iOS, the network request allow list (see above) is not able to filter all types of requests (e.g. `<video>` & WebSockets are not blocked). So, in addition to the allow list, you should use a [Content Security Policy](http://content-security-policy.com/) `<meta>` tag on all of your pages.
+
+Here are some example CSP declarations for your `.html` pages:
+
+```html
+<!-- Good default declaration:
+ * https://ssl.gstatic.com is required only on Android and is needed for TalkBack to function properly
+ * Disables use of eval() and inline scripts in order to mitigate risk of XSS vulnerabilities. To change this:
+ * Enable inline JS: add 'unsafe-inline' to default-src
+ * Enable eval(): add 'unsafe-eval' to default-src
+-->
+<meta http-equiv="Content-Security-Policy" content="default-src 'self' data: https://ssl.gstatic.com; style-src 'self' 'unsafe-inline'; media-src *">
+
+<!-- Allow everything but only from the same origin and foo.com -->
+<meta http-equiv="Content-Security-Policy" content="default-src 'self' foo.com">
+
+<!-- This policy allows everything (eg CSS, AJAX, object, frame, media, etc) except that
+ * CSS only from the same origin and inline styles,
+ * scripts only from the same origin and inline styles, and eval()
+-->
+<meta http-equiv="Content-Security-Policy" content="default-src *; style-src 'self' 'unsafe-inline'; script-src 'self' 'unsafe-inline' 'unsafe-eval'">
+
+<!-- Allows XHRs only over HTTPS on the same domain. -->
+<meta http-equiv="Content-Security-Policy" content="default-src 'self' https:">
+
+<!-- Allow iframe to https://cordova.apache.org/ -->
+<meta http-equiv="Content-Security-Policy" content="default-src 'self'; frame-src 'self' https://cordova.apache.org">
+```
+
+## Other Notes
+
+[Application Transport Security (ATS)](https://developer.apple.com/library/prerelease/ios/documentation/General/Reference/InfoPlistKeyReference/Articles/CocoaKeys.html#//apple_ref/doc/uid/TP40009251-SW33) is new in iOS 9 (Xcode 7). This new feature acts as an allow list for your app. Cordova CLI will automatically convert the `<access>` and `<allow-navigation>` tags to the appropriate ATS directives.
+
+The `<access>` and `<allow-navigation>` tags support these three attributes below, which have their equivalents in ATS:
+
+1. `minimum-tls-version` (String, defaults to 'TLSv1.2')
+2. `requires-forward-secrecy` (Boolean, defaults to 'true')
+3. `requires-certificate-transparency` (Boolean, defaults to 'false', new in iOS 10)
+
+**Example:**
+
+```xml
+<access origin='https://cordova.apache.org' minimum-tls-version='TLSv1.1' requires-forward-secrecy='false' requires-certificate-transparency='true' />
+```
+
+In iOS 10 and above, the `<access>` tag also supports these three attributes, described below, when paired with the origin wildcard `*`. These attributes also have their equivalents in ATS:
+
+1. `allows-arbitrary-loads-for-media` (Boolean, defaults to 'false', new in iOS 10. New in cordova-ios@4.5.0, fixed to use the proper attribute name). The old attribute `allows-arbitrary-loads-in-media` is now deprecated.
+2. `allows-arbitrary-loads-in-web-content` (Boolean, defaults to 'false', new in iOS 10)
+3. `allows-local-networking` (Boolean, defaults to 'false', new in iOS 10)
+
+**Example:**
+
+```xml
+<access origin='*' allows-arbitrary-loads-for-media='true' allows-arbitrary-loads-in-web-content='true' allows-local-networking='true' />
+```
+
+See the [ATS Technote](https://developer.apple.com/library/prerelease/ios/documentation/General/Reference/InfoPlistKeyReference/Articles/CocoaKeys.html#//apple_ref/doc/uid/TP40009251-SW33) for more details.
+
+[1]: http://www.w3.org/TR/widgets-access/
diff --git a/www/docs/en/11.x/guide/appdev/hooks/index.md b/www/docs/en/11.x/guide/appdev/hooks/index.md
new file mode 100644
index 0000000..647d627
--- /dev/null
+++ b/www/docs/en/11.x/guide/appdev/hooks/index.md
@@ -0,0 +1,413 @@
+---
+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: Hooks Guide
+toc_title: Hooks
+description: List of hooks supported by the Cordova CLI.
+---
+
+# Hooks
+
+## Introduction
+
+Cordova Hooks represent special scripts which could be added by application and
+plugin developers or even by your own build system to customize cordova commands.
+
+Cordova hooks allow you to perform special activities around cordova commands. For example,
+you may have a custom tool that checks for code formatting in your javascript file. And, you
+would like to run this tool before every build. In such a case, you could use a
+'before_build' hook and instruct the cordova run time to run the custom tool to be invoked
+before every build.
+
+Hooks might be related to your application activities such as `before_build`,
+`after_build`, etc. Or, they might be related to the plugins of your application. For example,
+hooks such as `before_plugin_add`, `after_plugin_add`, etc applies to plugin related
+activities. These hooks can be associated with all plugins within your application or
+be specific to only one plugin.
+
+Cordova supports the following hook types:
+
+<!-- START HTML -->
+
+<table class="hooks" width="100%">
+ <col width="20%">
+ <col width="30%">
+ <col width="50%">
+ <thead>
+ <tr>
+ <th>Hook Type</th>
+ <th>Associated Cordova Commands</th>
+ <th>Description</th>
+ </tr>
+ </thead>
+ <tbody>
+ <tr>
+ <th data-col="beforeplatformadd">before_platform_add</th>
+ <td data-col="code" rowspan="2" ><code>cordova platform add</code></td>
+ <td rowspan="2" class="description" data-col="description">To be executed before and after adding a platform.</td>
+ </tr>
+ <tr>
+ <th data-col="afterplatformadd">after_platform_add</th>
+ </tr>
+ <tr>
+ <th data-col="beforeplatformrm">before_platform_rm</th>
+ <td data-col="code" rowspan="2"><code>cordova platform rm</code></td>
+ <td rowspan="2" class="description" data-col="description">To be executed before and after removing a platform.</td>
+ </tr>
+ <tr>
+ <th data-col="afterplatformrm">after_platform_rm</th>
+ </tr>
+ <tr>
+ <th data-col="beforeplatformls">before_platform_ls</th>
+ <td data-col="code" rowspan="2"><code>cordova platform ls</code></td>
+ <td rowspan="2" class="description" data-col="description">To be executed before and after listing the installed and available platforms.</td>
+ </tr>
+ <tr>
+ <th data-col="afterplatformls">after_platform_ls</th>
+ </tr>
+ <tr>
+ <th data-col="beforeprepare">before_prepare</th>
+ <td data-col="code" rowspan="2"><code>cordova prepare</code><br/><code>cordova platform add</code><br/><code>cordova build</code><br/><code>cordova run</code></td>
+ <td rowspan="2" data-col="description">To be executed before and after preparing your application.</td>
+ </tr>
+ <tr>
+ <th data-col="afterprepare">after_prepare</th>
+ </tr>
+ <tr>
+ <th data-col="beforecompile">before_compile</th>
+ <td data-col="code" rowspan="2"><code>cordova compile</code><br/><code>cordova build</code></td>
+ <td rowspan="2" data-col="description">To be executed before and after compiling your application.</td>
+ </tr>
+ <tr>
+ <th data-col="aftercompile">after_compile</th>
+ </tr>
+ <tr>
+ <th data-col="beforedeploy">before_deploy</th>
+ <td data-col="code"><code>cordova emulate</code><br/><code>cordova run</code></td>
+ <td data-col="description">To be executed before deploying your application.</td>
+ </tr>
+ <tr>
+ <th data-col="beforebuild">before_build</th>
+ <td data-col="code" rowspan="2"><code>cordova build</code></td>
+ <td rowspan="2" data-col="description">To be executed before and after building your application.</td>
+ </tr>
+ <tr>
+ <th data-col="afterbuild">after_build</th>
+ </tr>
+ <tr>
+ <th data-col="beforeemulate">before_emulate</th>
+ <td data-col="code" rowspan="2"><code>cordova emulate</code></td>
+ <td rowspan="2" data-col="description">To be executed before and after emulating your application.</td>
+ </tr>
+ <tr>
+ <th data-col="afteremulate">after_emulate</th>
+ </tr>
+ <tr>
+ <th data-col="beforerun">before_run</th>
+ <td data-col="code" rowspan="2"><code>cordova run</code></td>
+ <td rowspan="2" data-col="description">To be executed before and after running your application.</td>
+ </tr>
+ <tr>
+ <th data-col="afterrun">after_run</th>
+ </tr>
+ <tr>
+ <th data-col="beforeserve">before_serve</th>
+ <td data-col="code" rowspan="2"><code>cordova serve</code></td>
+ <td rowspan="2" data-col="description">To be executed before and after serving your application.</td>
+ </tr>
+ <tr>
+ <th data-col="afterserve">after_serve</th>
+ </tr>
+ <tr>
+ <th data-col="beforeclean">before_clean</th>
+ <td data-col="code" rowspan="2"><code>cordova clean</code></td>
+ <td rowspan="2" data-col="description">To be executed before and after cleaning your application.</td>
+ </tr>
+ <tr>
+ <th data-col="afterclean">after_clean</th>
+ </tr>
+ <tr>
+ <th data-col="beforepluginadd">before_plugin_add</th>
+ <td data-col="code" rowspan="2"><code>cordova plugin add</code></td>
+ <td rowspan="2" data-col="description">To be executed before and after adding a plugin.</td>
+ </tr>
+ <tr>
+ <th data-col="afterpluginadd">after_plugin_add</th>
+ </tr>
+ <tr>
+ <th data-col="beforepluginrm">before_plugin_rm</th>
+ <td data-col="code" rowspan="2"><code>cordova plugin rm</code></td>
+ <td rowspan="2" data-col="description">To be executed before and after removing a plugin.</td>
+ </tr>
+ <tr>
+ <th data-col="afterpluginrm">after_plugin_rm</th>
+ </tr>
+ <tr>
+ <th data-col="beforepluginls">before_plugin_ls</th>
+ <td data-col="code" rowspan="2"><code>cordova plugin ls</code></td>
+ <td rowspan="2" data-col="description">To be executed before and after listing the plugins in your application.</td>
+ </tr>
+ <tr>
+ <th data-col="afterpluginls">after_plugin_ls</th>
+ </tr>
+ <tr>
+ <th data-col="beforeplugininstall">before_plugin_install</th>
+ <td data-col="code" rowspan="2"><code>cordova plugin add</code></td>
+ <td rowspan="2" data-col="description">To be executed before and after installing a plugin (to the platforms). Plugin hooks in plugin.xml are executed for a plugin being installed only</td>
+ </tr>
+ <tr>
+ <th data-col="afterplugininstall">after_plugin_install</th>
+ </tr>
+ <tr>
+ <th data-col="beforepluginuninstall">before_plugin_uninstall</th>
+ <td data-col="code" rowspan="2"><code>cordova plugin rm</code></td>
+ <td data-col="description">To be executed before uninstalling a plugin (from the platforms).Plugin hooks in plugin.xml are executed for a plugin being installed only</td>
+ </tr>
+ </tbody>
+</table>
+
+<!-- END HTML -->
+
+## Ways to define hooks
+
+### Config.xml
+
+Hooks could be defined in project's `config.xml` using `<hook>` elements, for example:
+
+```xml
+<hook type="before_build" src="scripts/appBeforeBuild.bat" />
+<hook type="before_build" src="scripts/appBeforeBuild.js" />
+<hook type="before_plugin_install" src="scripts/appBeforePluginInstall.js" />
+
+<platform name="android">
+ <hook type="before_build" src="scripts/android/appAndroidBeforeBuild.bat" />
+ <hook type="before_build" src="scripts/android/appAndroidBeforeBuild.js" />
+ <hook type="before_plugin_install" src="scripts/android/appAndroidBeforePluginInstall.js" />
+ ...
+</platform>
+
+<platform name="windows">
+ <hook type="before_build" src="scripts/windows/appWinBeforeBuild.bat" />
+ <hook type="before_build" src="scripts/windows/appWinBeforeBuild.js" />
+ <hook type="before_plugin_install" src="scripts/windows/appWinBeforePluginInstall.js" />
+ ...
+</platform>
+```
+
+### Plugin hooks (plugin.xml)
+
+As a plugin developer you can define hook scripts using `<hook>` elements in a `plugin.xml` like that:
+
+```xml
+<hook type="before_plugin_install" src="scripts/beforeInstall.js" />
+<hook type="after_build" src="scripts/afterBuild.js" />
+
+<platform name="android">
+ <hook type="before_plugin_install" src="scripts/androidBeforeInstall.js" />
+ <hook type="before_build" src="scripts/androidBeforeBuild.js" />
+ ...
+</platform>
+```
+
+`before_plugin_install`, `after_plugin_install`, `before_plugin_uninstall` plugin hooks will be fired
+exclusively for the plugin being installed/uninstalled.
+
+### Order of Hooks execution
+
+#### Based on Hooks Definition
+
+Hook scripts for one given hook run serially in the order of appearance in their file with application hooks from `config.xml` running before plugin hooks from `plugins/.../plugin.xml`.
+
+#### Based on the Internal order of execution
+
+The internal order of execution of hooks is fixed.
+
+##### Example 1 (cordova platform add)
+If there are hooks associated with `before_platform_add`, `after_platform_add`, `before_prepare`, `after_prepare`,
+`before_plugin_install` and `after_plugin_install` (and assuming you have one plugin installed on your project),
+adding a new platform will execute the hooks in the following order:
+
+```
+before_platform_add
+ before_prepare
+ after_prepare
+ before_plugin_install
+ after_plugin_install
+after_platform_add
+```
+
+##### Example 2 (cordova build)
+If there are hooks associated with `before_prepare`, `after_prepare`, `before_compile`, `after_compile`, `before_build`
+and `after_build` - running a build command will execute the hooks in the following order:
+
+```
+before_build
+ before_prepare
+ after_prepare
+ before_compile
+ after_compile
+after_build
+```
+
+## Script Interface
+
+### Javascript
+
+If you are writing hooks using Node.js you should use the following module definition:
+
+```javascript
+module.exports = function(context) {
+ ...
+}
+```
+
+Here is an example that showcases the contents of the `context` object:
+
+```javascript
+{
+ // The type of hook being run
+ hook: 'before_plugin_install',
+
+ // Absolute path to the hook script that is currently executing
+ scriptLocation: '/foo/scripts/appBeforePluginInstall.js',
+
+ // The CLI command that lead to this hook being executed
+ cmdLine: 'cordova plugin add plugin-withhooks',
+
+ // The options associated with the current operation.
+ // WARNING: The contents of this object vary among the different
+ // operations and are currently not documented anywhere.
+ opts: {
+ projectRoot: '/foo',
+
+ cordova: {
+ platforms: ['android'],
+ plugins: ['plugin-withhooks'],
+ version: '0.21.7-dev'
+ },
+
+ // Information about the plugin currently operated on.
+ // This object will only be passed to plugin hooks scripts.
+ plugin: {
+ id: 'plugin-withhooks',
+ pluginInfo: { /* ... */ },
+ platform: 'android',
+ dir: '/foo/plugins/plugin-withhooks'
+ }
+ },
+
+ // A reference to Cordova's API
+ cordova: { /* ... */ }
+}
+
+```
+
+You can also require additional Cordova modules in your script using `context.requireCordovaModule` in the following way:
+
+```javascript
+const cordovaCommon = context.requireCordovaModule('cordova-common');
+```
+
+You can make your scripts asynchronous using Promises.
+Here is an example that just waits for a second and then prints the amount of milliseconds spent waiting:
+
+```javascript
+module.exports = context => {
+ return new Promise(resolve => {
+ const start = Date.now();
+ setTimeout(() => resolve(Date.now() - start), 1000);
+ }).then(msWaited => {
+ console.log(`${context.scriptLocation} waited ${msWaited} ms`);
+ });
+};
+```
+
+### Non-javascript
+
+Non-javascript scripts are run via Node child_process spawn from the project's root directory and have the root directory passed as the first argument. All other options are passed to the script using environment variables:
+
+Environment Variable Name | Description
+------------------------------|--------------------------------------------
+CORDOVA_VERSION | The version of the Cordova-CLI.
+CORDOVA_PLATFORMS | Comma separated list of platforms that the command applies to (e.g: android, ios).
+CORDOVA_PLUGINS | Comma separated list of plugin IDs that the command applies to (e.g: cordova-plugin-file-transfer, cordova-plugin-file).
+CORDOVA_HOOK | Path to the hook that is being executed.
+CORDOVA_CMDLINE | The exact command-line arguments passed to cordova (e.g: cordova run ios --emulate).
+
+If a script returns a non-zero exit code, then the parent cordova command will be aborted.
+
+> __Note__: we highly recommend writing your hooks using Node.js so that they are cross-platform, see [Javascript](#link-javascript) section above.
+
+#### Windows Quirks
+
+If you are working on Windows, and your hook scripts aren't `*.bat` files, Cordova CLI will expect a shebang line as the first line of the script. This way it knows the interpreter it needs to use to launch the script. A shebang line for a Python script could look like this:
+
+```
+#!/usr/bin/env python
+```
+
+
+## Sample Usage
+
+This sample demonstrates Cordova hooks usage to trace to the console output the
+size of generated .apk file for Android platform.
+
+Create blank Cordova app and add the following definition to `config.xml` to
+tell Cordova to run `afterBuild.js` script after each platform build.
+
+```xml
+<hook type="after_build" src="scripts/afterBuild.js" />
+```
+
+Create `scripts/afterBuild.js` file and add the following implementation.
+We use async version of `fs.stat` method to demonstrate how async functions
+can be used in hooks.
+
+```javascript
+const fs = require('fs');
+const util = require('util');
+const stat = util.promisify(fs.stat);
+
+module.exports = function(ctx) {
+ // Make sure android platform is part of build
+ if (!ctx.opts.platforms.includes('android')) return;
+
+ const platformRoot = path.join(ctx.opts.projectRoot, 'platforms/android');
+ const apkFileLocation = path.join(platformRoot, 'build/outputs/apk/android-debug.apk');
+
+ return stat(apkFileLocation).then(stats => {
+ console.log(`Size of ${apkFileLocation} is ${stats.size} bytes`);
+ });
+};
+```
+
+Parameter `ctx` in example above is passed by Cordova and represents execution
+context such as script full path, target platform, command-line arguments, etc and
+also exposes additional helper functionality. See `Script Interface` section above
+for more details.
+
+You can now add android platform and execute build.
+
+```
+cordova platform add android
+..
+cordova build
+..
+Size of path\to\app\platforms\android\build\outputs\apk\android-debug.apk is 1821193 bytes
+```
diff --git a/www/docs/en/11.x/guide/appdev/privacy/index.md b/www/docs/en/11.x/guide/appdev/privacy/index.md
new file mode 100644
index 0000000..ae6f6af
--- /dev/null
+++ b/www/docs/en/11.x/guide/appdev/privacy/index.md
@@ -0,0 +1,113 @@
+---
+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: Privacy Guide
+toc_title: Manage privacy
+description: Learn about important mobile privacy issues.
+---
+
+# Privacy Guide
+
+Mobile privacy is a critical issue that every app developer must
+address. Your users expect that their private information will be
+collected and treated appropriately by your app. Also, there are an
+increasing number of jurisdictions that now have legal requirements
+regarding mobile privacy practices.
+
+This guide on mobile app privacy should be considered a _primer_
+addressing some the most significant issues. It outlines some broadly
+accepted best practices and provides references to other more detailed
+guides and references.
+
+* __Privacy Policy__: Your app should include a privacy policy that
+ addresses topics such as what kind of information the app collects
+ from or about your users, how that information is used, with whom it
+ is shared, and how users can make privacy-related choices within the
+ app. To aid understanding, you should use plain language and avoid
+ technical jargon. You should make your privacy policy available for
+ users to review prior to download, such as in the app description in
+ the app marketplace. In addition, you should make your privacy
+ policy available within the app itself. The limited size of mobile
+ device displays creates challenges for displaying privacy policies
+ to users. Consider developing a _short form_ of the policy that
+ includes the most important information, and then provide a link to
+ the "long form" policy for those interested in more details. Several
+ groups are attempting to develop icon-based standards for
+ communicating privacy practices, which you may want to consider once
+ these standards mature.
+
+* __Collection of sensitive information__: An app's collection of
+ sensitive personal information raises important privacy concerns.
+ Examples of sensitive personal information include financial
+ information, health information, and information from or about
+ children. It also includes information gathered from certain sensors
+ and databases typically found on mobile devices and tablets, such as
+ geolocation information, contacts/phonebook, microphone/camera, and
+ stored pictures/videos. See the following documentation pages for
+ more information: [camera](cordova_camera_camera.md.html),
+ [capture](cordova_media_capture_capture.md.html),
+ [contacts](cordova_contacts_contacts.md.html), and
+ [geolocation](cordova_geolocation_geolocation.md.html). Generally,
+ you should obtain a user's express permission before collecting
+ sensitive information and, if possible, provide a control mechanism
+ that allows a user to easily change permissions. App operating
+ systems can help in some instances by presenting just-in-time dialog
+ boxes that ask for the user's permission before collection. In these
+ cases, be sure to take advantage of any opportunity to customize the
+ dialog box text to clarify how the app uses and, if applicable,
+ shares such information.
+
+* __Avoiding user surprise__: If the app collects or uses information
+ in a way that may be surprising to users in light of the primary
+ purpose of your app (for example, a music player that accesses
+ stored pictures), you should take similar steps as with the
+ collection of sensitive personal information. That is, you should
+ strongly consider the use of just-in-time dialog boxes to inform the
+ user about the collection or use of that information and, if
+ appropriate, provide a corresponding privacy control.
+
+* __Third party data collection or sharing__: If you app collects
+ information that is provided to another company--such as a social
+ networking platform or an ad network (for example, if your app
+ displays advertising)--you should inform your users of that
+ collection and sharing. At a minimum, your privacy policy should
+ describe the information collection and sharing and, if appropriate,
+ offer your users the ability to control or opt-out of such
+ collection or sharing.
+
+* __Collection limitation and security__: Your users entrust your app
+ with their information and they expect that you will take
+ appropriate security precautions to protect it. One of the best ways
+ to avoid security compromises of personal information is not to
+ collect the information in the first place unless your app has a
+ specific and legitimate business reason for the collection. For
+ information that does need to be collected, ensure that you provide
+ appropriate security controls to protect that information, whether
+ it is stored on the device or on your backend servers. You should
+ also develop an appropriate data retention policy that is
+ implemented within the app and on your backend servers.
+
+Following are some additional helpful mobile privacy guides for developers:
+
+* Federal Trade Commission, [Mobile Privacy Disclosures: Building Trust Through Transparency][1]
+
+* Future of Privacy Forum, [Application Privacy][2] Website
+
+[1]: https://www.ftc.gov/os/2013/02/130201mobileprivacyreport.pdf
+[2]: https://www.applicationprivacy.org/learn-resources/leading-data-privacy-practices/
diff --git a/www/docs/en/11.x/guide/appdev/security/index.md b/www/docs/en/11.x/guide/appdev/security/index.md
new file mode 100644
index 0000000..7b62834
--- /dev/null
+++ b/www/docs/en/11.x/guide/appdev/security/index.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: Security Guide
+toc_title: Manage security
+description: Information and tips for building a secure application.
+---
+
+# Security Guide
+
+The following guide includes some security best practices that you should consider when developing a Cordova application. Please be aware that security is a very complicated topic and therefore this guide is not exhaustive. If you believe you can contribute to this guide, please feel free to create a pull request in Cordova's [cordova-docs](https://github.com/apache/cordova-docs/issues) repository. This guide is designed to be applicable to general Cordova development (all platforms) but [...]
+
+## This guide discusses the following topics:
+
+* Allow List
+* Iframes and the Callback Id Mechanism
+* Certificate Pinning
+* Self-signed Certificates
+* Encrypted storage
+* General Tips
+* Recommended Articles and Other Resources
+
+## Allow List
+
+By default the app's navigation is unrestricted. It's recommended to restrict the navigation only to trusted domains. Learn more by reading the [Allow List Guide](../allowlist/index.html)
+
+## Iframes and the Callback Id Mechanism
+
+If content is served in an iframe from a whitelisted domain, that domain will have access to the native Cordova bridge. This means that if you whitelist a third-party advertising network and serve those ads through an iframe, it is possible that a malicious ad will be able to break out of the iframe and perform malicious actions. Because of this, you should generally not use iframes unless you control the server that hosts the iframe content. Also note that there are third party plugins [...]
+
+## Certificate Pinning
+
+Cordova does not support true certificate pinning. The main barrier to this is a lack of native APIs in Android for intercepting SSL connections to perform the check of the server's certificate. (Although it is possible to do certificate pinning on Android in Java using JSSE, the webview on Android is written in C++, and server connections are handled for you by the webview, so it is not possible to use Java and JSSE there.) Since Apache Cordova is meant to offer consistent APIs across m [...]
+
+There are ways to approximate certificate pinning, such as checking the server's public key (fingerprint) is the expected value when your application starts or at other various times during your application's lifetime. There are third-party plugins available for Cordova that can do that. However, this is not the same as true certificate pinning which automatically verifies the expected value on every connection to the server.
+
+There are also plugins that can do true certificate pinning for some platforms, assuming your app is able to do all of its network requests using the plugin (i.e.: no traditional XHR/AJAX requests, etc).
+
+## Using TLS/SSL
+
+If your app communicates to an external server, it should be communicating using modern encryption standards. Use `https` protocol whenever possible.
+
+[Let's Encrypt](https://letsencrypt.org/) is a free, automated, and open certificate authority provided by the nonprofit [Internet Security Research Group](https://www.abetterinternet.org/). Let's Encrypt will offer free standard certificates, which will be sufficient for most developers. Enterprise organizations may still want to use a traditional certificate authority that offers more advanced features such as [Organization Validation](https://en.wikipedia.org/wiki/Public_key_certifica [...]
+
+It is also important to keep up to date with security standards as they change over time. What might be acceptable SSL/TLS configuration today may not be acceptable years in the future. Using tools to test your certificate and SSL/TLS configuration should be done regularly. [SSL Labs](https://www.ssllabs.com/ssltest/) is a free online service provided by Qualys, Inc to test your server's SSL/TLS configuration and encryption strength, in addition to supported platforms.
+
+## Self-signed Certificates
+
+Using self-signed certificates on your server is not recommended. If you desire SSL, then it is highly recommended that your server have a certificate that has been properly signed by a well-known CA (certificate authority). The inability to do true certificate pinning makes this important.
+
+The reason is that accepting self-signed certificates bypasses the certificate chain validation, which allows any server certificate to be considered valid by the device. This opens up the communication to man-in-the-middle attacks. It becomes very easy for a hacker to not only intercept and read all communication between the device and the server, but also to modify the communication. The device will never know this is happening because it doesn't verify that the server's certificate is [...]
+
+If the application is to be used only within a trusted network, such as an internal corporate network. Using self-signed certificates may be acceptable, however the public certificate should be pre-installed on the device(s) that will be running the application. A trusted third-party certificate authority will always be preferable.
+
+The principles described here are not specific to Apache Cordova, they apply to all client-server communication.
+
+When running Cordova on Android, using `android:debuggable="true"` in the application manifest will permit SSL errors such as certificate chain validation errors on self-signed certs. So you can use self-signed certs in this configuration, but this is not a configuration that should be used when your application is in production. It is meant to be used only during application development.
+
+
+## Encrypted storage
+
+(TBD)
+
+## General Tips
+
+### Do not use Android Gingerbread!
+* Set your min-target-sdk level higher than 10. API 10 is Gingerbread, and Gingerbread is no longer supported by Google or device manufacturers, and is therefore not recommend by the Cordova team.
+* Gingerbread has been shown to be insecure and one of the most targeted mobile OSs [http://www.mobilemag.com/2012/11/06/andriod-2-3-gingerbread-security/](http://bgr.com/2012/11/06/android-security-gingerbread-malware/).
+* The Whitelist on Android does not work with Gingerbread or lower. This means an attacker can load malicious code in an iframe that would then have access to all of the Cordova APIs and could use that access to steal personal data, send SMS messages to premium-rate numbers, and perform other malicious acts.
+
+### Use InAppBrowser for outside links
+* Use the InAppBrowser when opening links to any outside website. This is much safer than whitelisting a domain name and including the content directly in your application because the InAppBrowser will use the native browser's security features and will not give the website access to your Cordova environment. Even if you trust the third party website and include it directly in your application, that third party website could link to malicious web content.
+
+### Validate all user input
+* Always validate any and all input that your application accepts. This includes usernames, passwords, dates, uploaded media, etc. Because an attacker could manipulate your HTML and JS assets (either by decompiling your application or using debugging tools like chrome://inspect), this validation should also be performed on your server, especially before handing the data off to any backend service.
+* Other sources where data should be validated: user documents, contacts, push notifications
+
+### Do not cache sensitive data
+* If usernames, password, geolocation information, and other sensitive data is cached, then it could potentially be retrieved later by an unauthorized user or application.
+
+### Don't use eval() unless you know what you're doing
+* The JavaScript function eval() has a long history of being abused. Using it incorrectly can open your code up for injection attacks, debugging difficulties, and slower code execution.
+
+### Do not assume that your source code is secure
+* Since a Cordova application is built from HTML and JavaScript assets that get packaged in a native container, you should not consider your code to be secure. It is possible to reverse engineer a Cordova application.
+
+## Recommended Articles and Other Resources
+
+* [HTML5 Security cheat sheet, detailing how to secure your HTML5 application](https://www.owasp.org/index.php/HTML5_Security_Cheat_Sheet)
+* [Whitepaper about well known security flaws in Webview based hybrid applications](http://www.cis.syr.edu/~wedu/Research/paper/webview_acsac2011.pdf)
diff --git a/www/docs/en/11.x/guide/cli/index.md b/www/docs/en/11.x/guide/cli/index.md
new file mode 100644
index 0000000..8ef72ba
--- /dev/null
+++ b/www/docs/en/11.x/guide/cli/index.md
@@ -0,0 +1,330 @@
+---
+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: Creating your first Cordova app
+description: Learn how to create your first Cordova hybrid app using Cordova CLI.
+toc_title: Create your first app
+---
+
+# Create your first Cordova app
+
+This guide shows you how to create a JS/HTML Cordova application and deploy them to
+various native mobile platforms using the `cordova` command-line
+interface (CLI). For detailed reference on Cordova command-line, review the [CLI reference]
+
+## Installing the Cordova CLI
+
+The Cordova command-line tool is distributed as an npm package.
+
+To install the `cordova` command-line tool, follow these steps:
+
+1. Download and install [Node.js](https://nodejs.org/en/download/). On
+ installation you should be able to invoke `node` and `npm` on your
+ command line.
+
+1. (Optional) Download and install a [git client](http://git-scm.com/downloads), if you don't
+ already have one. Following installation, you should be able to invoke `git`
+ on your command line. The CLI uses it to download assets when they are referenced using a url to a git repo.
+
+1. Install the `cordova` module using `npm` utility of Node.js. The `cordova`
+ module will automatically be downloaded by the `npm` utility.
+
+ * on OS X and Linux:
+ ```bash
+ $ sudo npm install -g cordova
+ ```
+
+ On OS X and Linux, prefixing the `npm` command with
+ `sudo` may be necessary to install this development utility in
+ otherwise restricted directories such as
+ `/usr/local/share`. If you are using the optional
+ nvm/nave tool or have write access to the install directory,
+ you may be able to omit the `sudo` prefix.
+
+ * on Windows:
+ ```
+ C:\>npm install -g cordova
+ ```
+
+ The `-g` flag above tells `npm` to install `cordova` globally. Otherwise
+ it will be installed in the `node_modules` subdirectory of the current
+ working directory.
+
+ Following installation, you should be able to run
+ `cordova` on the command line with no arguments and it should
+ print help text.
+
+## Create the App
+
+Go to the directory where you maintain your source code, and create a cordova project:
+
+```bash
+$ cordova create hello com.example.hello HelloWorld
+```
+
+This creates the required directory structure for your cordova app. By default, the `cordova create` script generates a skeletal web-based application whose home page is the project's `www/index.html` file.
+
+### See Also
+- [Cordova create command reference documentation][cdv_create]
+- [Cordova project directory structure][cdv_dir]
+- [Cordova project templates][cdv_template]
+
+## Add Platforms
+
+All subsequent commands need to be run within the project's directory,
+or any subdirectories:
+
+```bash
+$ cd hello
+```
+
+Add the platforms that you want to target your app. We will add the 'ios' and 'android' platform and ensure they get saved to `config.xml` and `package.json`:
+
+```bash
+$ cordova platform add ios
+$ cordova platform add android
+```
+
+To check your current set of platforms:
+
+```bash
+$ cordova platform ls
+```
+
+Running commands to add or remove platforms affects the contents of
+the project's _platforms_ directory, where each specified platform
+appears as a subdirectory.
+
+> Note: When using the CLI to build your application, you should
+_not_ edit any files in the `/platforms/` directory. The files
+in this directory are routinely overwritten when preparing
+applications for building, or when plugins are re-installed.
+
+### See Also
+- [Cordova platform command reference documentation][cdv_platform]
+
+## Install pre-requisites for building
+To build and run apps, you need to install SDKs for each platform you wish to target. Alternatively, if you are using browser for development you can use `browser` platform which does not require any platform SDKs.
+
+To check if you satisfy requirements for building the platform:
+
+```
+$ cordova requirements
+Requirements check results for android:
+Java JDK: installed .
+Android SDK: installed
+Android target: installed android-19,android-21,android-22,android-23,Google Inc.:Google APIs:19,Google Inc.:Google APIs (x86 System Image):19,Google Inc.:Google APIs:23
+Gradle: installed
+
+Requirements check results for ios:
+Apple OS X: not installed
+Cordova tooling for iOS requires Apple OS X
+Error: Some of requirements check failed
+```
+
+### See Also
+- [Android platform requirements](../../guide/platforms/android/index.html#requirements-and-support)
+- [iOS platform requirements](../../guide/platforms/ios/index.html#requirements-and-support)
+- [Windows platform requirements](../../guide/platforms/windows/index.html#requirements-and-support)
+
+## Build the App
+
+By default, `cordova create` script generates a skeletal web-based application whose start page is the project's `www/index.html` file. Any
+initialization should be specified as part of the [deviceready][DeviceReadyEvent] event handler defined in `www/js/index.js`.
+
+Run the following command to build the project for _all_ platforms:
+
+```bash
+$ cordova build
+```
+
+You can optionally limit the scope of each build to specific platforms - 'ios' in this case:
+
+```bash
+$ cordova build ios
+```
+
+### See Also
+- [Cordova build command reference documentation][cdv_build]
+
+## Test the App
+
+SDKs for mobile platforms often come bundled with emulators that
+execute a device image, so that you can launch the app from the home
+screen and see how it interacts with many platform features. Run a
+command such as the following to rebuild the app and view it within a
+specific platform's emulator:
+
+```bash
+$ cordova emulate android
+```
+
+
+
+Following up with the `cordova emulate` command refreshes the emulator
+image to display the latest application, which is now available for
+launch from the home screen:
+
+
+
+Alternately, you can plug the handset into your computer and test the
+app directly:
+
+```bash
+$ cordova run android
+```
+
+Before running this command, you need to set up the device for
+testing, following procedures that vary for each platform.
+
+### See Also
+- [Setting up Android emulator](../../guide/platforms/android/index.html#setting-up-an-emulator)
+- [Cordova run command reference documentation][cdv_run]
+- [Cordova emulate command reference documentation][cdv_emulate]
+
+## Add Plugins
+
+You can modify the default generated app to take advantage of standard web technologies,
+but for the app to access device-level features, you need to add plugins.
+
+A _plugin_ exposes a Javascript API for native SDK functionality. Plugins are typically hosted on
+npm and you can search for them on the [plugin search page](/plugins/). Some key APIs are provided by the Apache Cordova open source project and these are referred to as [Core Plugin APIs]. You can also use the CLI to launch the search page:
+
+```bash
+$ cordova plugin search camera
+```
+
+To add and save the camera plugin to `package.json`, we will specify the npm package name for the camera plugin:
+
+```
+$ cordova plugin add cordova-plugin-camera
+Fetching plugin "cordova-plugin-camera@~2.1.0" via npm
+Installing "cordova-plugin-camera" for android
+Installing "cordova-plugin-camera" for ios
+```
+
+Plugins can also be added using a directory or a git repo.
+
+> __NOTE__: The CLI adds plugin code as appropriate for each platform.
+If you want to develop with lower-level shell tools or platform SDKs
+as discussed in the [Overview](../overview/index.html), you need to run the Plugman utility to
+add plugins separately for each platform. (For more information, see
+[Using Plugman to Manage Plugins](../../plugin_ref/plugman.html).)
+
+Use `plugin ls` (or `plugin list`, or `plugin` by itself) to view
+currently installed plugins. Each displays by its identifier:
+
+```
+$ cordova plugin ls
+cordova-plugin-camera 2.1.0 "Camera"
+cordova-plugin-whitelist 1.2.1 "Whitelist"
+```
+
+### See Also
+- [Cordova plugin command reference documentation][cdv_plugin]
+- [Cordova plugin search page](/plugins/)
+- [Core Plugin APIs]
+
+## Using _merges_ to Customize Each Platform
+
+While Cordova allows you to easily deploy an app for many different
+platforms, sometimes you need to add customizations. In that case,
+you don't want to modify the source files in various `www` directories
+within the top-level `platforms` directory, because they're regularly
+replaced with the top-level `www` directory's cross-platform source.
+
+Instead, the top-level `merges` directory offers a place to specify
+assets to deploy on specific platforms. Each platform-specific
+subdirectory within `merges` mirrors the directory structure of the
+`www` source tree, allowing you to override or add files as needed.
+For example, here is how you might use `merges` to boost the default
+font size for Android devices:
+
+* Edit the `www/index.html` file, adding a link to an additional CSS
+ file, `overrides.css` in this case:
+
+ ```html
+ <link rel="stylesheet" type="text/css" href="css/overrides.css" />
+ ```
+
+* Optionally create an empty `www/css/overrides.css` file, which would
+ apply for all non-Android builds, preventing a missing-file error.
+
+* Create a `css` subdirectory within `merges/android`, then add a
+ corresponding `overrides.css` file. Specify CSS that overrides the
+ 12-point default font size specified within `www/css/index.css`, for
+ example:
+
+ ```css
+ body { font-size:14px; }
+ ```
+
+When you rebuild the project, the Android version features the custom
+font size, while others remain unchanged.
+
+You can also use `merges` to add files not present in the original
+`www` directory. For example, an app can incorporate a _back button_
+graphic into the iOS interface, stored in
+`merges/ios/img/back_button.png`, while the Android version can
+instead capture [backbutton][BackButtonEvent] events from the corresponding hardware
+button.
+
+
+## Updating Cordova and Your Project
+
+After installing the `cordova` utility, you can always update it to
+the latest version by running the following command:
+
+```bash
+$ sudo npm update -g cordova
+```
+
+Use this syntax to install a specific version:
+
+```bash
+$ sudo npm install -g cordova@3.1.0-0.2.0
+```
+
+Run `cordova -v` to see which version is currently running. To find the latest released cordova version, you can run:
+
+```bash
+$ npm info cordova version
+```
+
+To update platform that you're targeting:
+
+```bash
+$ cordova platform update android --save
+$ cordova platform update ios --save
+...etc.
+```
+
+[DeviceReadyEvent]: ../../cordova/events/events.html#deviceready
+[BackButtonEvent]: ../../cordova/events/events.html#backbutton
+[Core Plugin APIs]: ../../guide/support/index.html#core-plugin-apis
+[cdv_template]: ../../guide/cli/template.html#
+
+[CLI reference]: ../../reference/cordova-cli/index.html
+[cdv_create]: ../../reference/cordova-cli/index.html#cordova-create-command
+[cdv_dir]: ../../reference/cordova-cli/index.html#directory-structure
+[cdv_platform]: ../../reference/cordova-cli/index.html#cordova-platform-command
+[cdv_run]: ../../reference/cordova-cli/index.html#cordova-run-command
+[cdv_emulate]: ../../reference/cordova-cli/index.html#cordova-emulate-command
+[cdv_plugin]: ../../reference/cordova-cli/index.html#cordova-plugin-command
+[cdv_build]: ../../reference/cordova-cli/index.html#cordova-build-command
diff --git a/www/docs/en/11.x/guide/cli/template.md b/www/docs/en/11.x/guide/cli/template.md
new file mode 100644
index 0000000..19ef28a
--- /dev/null
+++ b/www/docs/en/11.x/guide/cli/template.md
@@ -0,0 +1,72 @@
+---
+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: Cordova App Templates
+description: Learn how to find, use, and create templates in Cordova.
+toc_title: Templates for apps
+
+---
+
+# Cordova App Templates
+
+## Use a Template
+
+Templates allow you to use preexisting code to jumpstart your project.
+
+
+
+Find a template to create your app from by seaching for the keyword `cordova:template` on [npm](https://www.npmjs.com/search?q=cordova%3Atemplate). You can also use local templates on your computer, or a Git repository.
+
+After locating a template you wish to use. Create your project using that template, by specifying the `--template` flag during the `create` command, followed by your template source.
+
+Creating a cordova project from an NPM package, Git repository, or local path:
+```
+$ cordova create hello com.example.hello HelloWorld --template <npm-package-name>
+$ cordova create hello com.example.hello HelloWorld --template <git-remote-url>
+$ cordova create hello com.example.hello HelloWorld --template <path-to-template>
+```
+
+After succesfully using a template to create your project, you'll want to indicate the platforms that you intend to target with your app. Go into your project folder and [add platforms](http://cordova.apache.org/docs/en/latest/guide/cli/index.html#add-platforms).
+
+## Create a Template
+
+Begin by creating a cordova app that will become the basis for your template. Then you'll take the contents of your app and put them into the following structure. When your template is used, all of the contents within `template_src` will be used to create the new project, so be sure to include any necessary files in that folder. Reference [this example](https://github.com/apache/cordova-app-hello-world) for details.
+
+```
+template_package/
+├── package.json (optional; needed to publish template on npm)
+├── index.js (required)
+└── template_src/ (required)
+ └── CONTENTS OF APP TEMPLATE
+```
+> __NOTE__: `index.js` should export a reference to `template_src` and `package.json` should reference `index.js`. See [the example](https://github.com/apache/cordova-app-hello-world) for details on how that is done.
+
+To finish off your template, edit `package.json` to contain the keyword `"cordova:template"`.
+```javascript
+{
+ ...
+ "keywords": [
+ "ecosystem:cordova",
+ "cordova:template"
+ ]
+ ...
+}
+```
+
+Congrats! You've made a template for creating a Cordova project. Share your template on npm so that everyone can benefit from your hard work.
diff --git a/www/docs/en/11.x/guide/hybrid/plugins/index.md b/www/docs/en/11.x/guide/hybrid/plugins/index.md
new file mode 100644
index 0000000..070b079
--- /dev/null
+++ b/www/docs/en/11.x/guide/hybrid/plugins/index.md
@@ -0,0 +1,371 @@
+---
+license: >
+ Licensed to the Apache Software Foundation (ASF) under one
+ or more contributor license agreements. See the NOTICE file
+ distributed with this work for additional information
+ regarding copyright ownership. The ASF licenses this file
+ to you under the Apache License, Version 2.0 (the
+ "License"); you may not use this file except in compliance
+ with the License. You may obtain a copy of the License at
+
+ http://www.apache.org/licenses/LICENSE-2.0
+
+ Unless required by applicable law or agreed to in writing,
+ software distributed under the License is distributed on an
+ "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ KIND, either express or implied. See the License for the
+ specific language governing permissions and limitations
+ under the License.
+
+title: Plugin Development Guide
+toc_title: Create a plugin
+description: Develop your own plugin.
+---
+
+# Plugin Development Guide
+
+A _plugin_ is a package of injected code that allows the Cordova webview within
+which the app renders to communicate with the native platform on
+which it runs. Plugins provide access to device and platform
+functionality that is ordinarily unavailable to web-based apps. All
+the main Cordova API features are implemented as plugins, and many
+others are available that enable features such as bar code scanners,
+NFC communication, or to tailor calendar interfaces. You can search for available plugins
+on [Cordova Plugin Search page](/plugins/).
+
+Plugins comprise a single JavaScript interface along with
+corresponding native code libraries for each supported platform. In essence
+this hides the various native code implementations behind a common
+JavaScript interface.
+
+This section steps through a simple _echo_ plugin that passes a string from
+JavaScript to the native platform and back, one that you can use as a
+model to build far more complex features. This section discusses the
+basic plugin structure and the outward-facing JavaScript interface.
+For each corresponding native interface, see the list at the end of
+this section.
+
+In addition to these instructions, when preparing to write a plugin it
+is best to look over [existing plugins](http://cordova.apache.org/contribute)
+for guidance.
+
+## Building a Plugin
+
+Application developers use the CLI's [plugin add command][cdv_plugin] to add a plugin to a project. The
+command takes the URL for a _git_ repository containing
+the plugin code as an argument. This example implements Cordova's Device API:
+
+```bash
+cordova plugin add https://github.com/apache/cordova-plugin-device
+```
+
+If the plugin is published to _npm_, the command can also receive the package name as the argument:
+
+```bash
+cordova plugin add cordova-plugin-device
+```
+
+The plugin repository must feature a top-level `plugin.xml` manifest
+file. There are many ways to configure this file, details for which
+are available in the [Plugin Specification](../../../plugin_ref/spec.html).
+
+This abbreviated version of the `Device` plugin provides a simple example to use as a model:
+
+```xml
+<?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>
+```
+
+- The top-level `plugin` tag's `id` attribute usually follows the `cordova-plugin-{plugin name}` schema and matches the plugin's npm package name.
+- The `js-module` tag specifies the path to the [common
+JavaScript interface](#the-javascript-interface).
+- The `platform` tag specifies a corresponding
+set of native code, for the `ios` platform in this case.
+- The `config-file` tag encapsulates a `feature` tag that is injected into
+the platform-specific `config.xml` file to make the platform aware of
+the additional code library.
+- The `header-file` and `source-file` tags
+specify the path to the library's component files.
+
+## The JavaScript Interface
+
+The JavaScript interface provides the front-facing interface, making it perhaps
+the most important part of the plugin. You can structure your
+plugin's JavaScript however you like, but you need to call
+`cordova.exec` to communicate with the native platform, using the
+following syntax:
+
+```javascript
+cordova.exec(function(winParam) {},
+ function(error) {},
+ "service",
+ "action",
+ ["firstArgument", "secondArgument", 42, false]);
+```
+
+Here is how each parameter works:
+
+- `function(winParam) {}`: A success callback function. Assuming your
+ `exec` call completes successfully, this function executes along
+ with any parameters you pass to it.
+
+- `function(error) {}`: An error callback function. If the operation
+ does not complete successfully, this function executes with an
+ optional error parameter.
+
+- `"service"`: The service name to call on the native side. This
+ corresponds to a native class, for which more information is
+ available in the native guides listed below.
+
+- `"action"`: The action name to call on the native side. This
+ generally corresponds to the native class method. See the native
+ guides listed below.
+
+- `[/* arguments */]`: An array of arguments to pass into the native
+ environment.
+
+## Sample JavaScript
+
+This example shows one way to implement the plugin's JavaScript
+interface:
+
+```javascript
+window.echo = function(str, callback) {
+ cordova.exec(callback, function(err) {
+ callback('Nothing to echo.');
+ }, "Echo", "echo", [str]);
+};
+```
+
+In this example, the plugin attaches itself to the `window` object as
+the `echo` function, which plugin users would call as follows:
+
+```javascript
+window.echo("echome", function(echoValue) {
+ alert(echoValue == "echome"); // should alert true.
+});
+```
+
+Look at the last three arguments passed to the `cordova.exec` function. The
+first calls the `Echo` _service_, a class name. The second requests
+the `echo` _action_, a method within that class. The third is an array
+of arguments containing the echo string, which is the `window.echo`
+function's first parameter.
+
+The success callback passed into `exec` is simply a reference to the
+callback function of `window.echo`. If the native platform fires
+the error callback, it simply calls the success callback and passes it
+a default string.
+
+## Native Interfaces
+
+Once you define JavaScript for your plugin, you need to complement it
+with at least one native implementation. Details for each platform are
+listed below, and each builds on the simple Echo Plugin example above:
+
+- [Android Plugins](../../platforms/android/plugin.html)
+- [iOS Plugins](../../platforms/ios/plugin.html)
+- [Windows Plugins](../../platforms/windows/plugin.html)
+
+## Testing a Plugin during development
+
+The simplest way to manually test a plugin during development is to create a
+Cordova app as usual and add the plugin with the `--link` option:
+
+```bash
+cordova plugin add ../path/to/my/plugin/relative/to/project --link
+```
+
+This creates a symbolic link instead of copying the plugin files, which enables you
+to work on your plugin and then simply rebuild the app to use your changes.
+
+## Validating a Plugin using Plugman
+
+You can use the `plugman` utility to check whether the plugin installs
+correctly for each platform. Install `plugman` with the following
+[node](http://nodejs.org/) command:
+
+```bash
+npm install -g plugman
+```
+
+You need a valid app source directory, such as the top-level `www`
+directory included in a default CLI-generated project, as described in the
+[Create your first app](../../cli/index.html) guide.
+
+Then run a command such as the following to test whether iOS
+dependencies load properly:
+
+```bash
+plugman install --platform ios --project /path/to/my/project/www --plugin /path/to/my/plugin
+```
+
+For details on `plugman` options, see [Using Plugman to Manage Plugins](../../../plugin_ref/plugman.html). For information on how to actually _debug_ plugins, see [each platform's native interface listed above](#native-interfaces).
+
+## Publishing Plugins
+
+You can publish your plugin to any `npmjs`-based registry, but the recommended one is the [npm registry](https://www.npmjs.com). Other developers can install your plugin automatically using either `plugman` or the Cordova CLI.
+
+To publish a plugin to npm you need to follow these steps:
+
+ * install the `plugman` CLI:
+
+ ```bash
+ $ npm install -g plugman
+ ```
+
+ * create a `package.json` file for your plugin:
+
+ ```bash
+ $ plugman createpackagejson /path/to/your/plugin
+ ```
+
+ * publish it:
+
+ ```bash
+ $ npm adduser # that is if you don't have an account yet
+ $ npm publish /path/to/your/plugin
+ ```
+
+For more details on npm usage, refer to [Publishing npm Packages](https://docs.npmjs.com/getting-started/publishing-npm-packages) on the npm documentation site.
+
+## Integrating with Plugin Search
+
+To surface the plugin in [Cordova Plugin Search](/plugins/), add the `ecosystem:cordova` keyword to the `package.json` file of your plugin before publishing.
+
+To indicate support for a particular platform, add a keyword in the format `cordova-<platformName>` to the list of keywords in `package.json`.
+Plugman's `createpackagejson` command does this for you, but if you did not use it to generate your `package.json`, you should manually edit it as shown below.
+
+For example, for a plugin that supports Android, iOS & Windows, the keywords in `package.json` should include:
+
+```json
+"keywords": [
+ "ecosystem:cordova",
+ "cordova-android",
+ "cordova-ios",
+ "cordova-windows"
+]
+```
+
+For a more detailed example of a package.json, review the [package.json file of cordova-plugin-device](https://github.com/apache/cordova-plugin-device/blob/master/package.json).
+
+## Specifying Cordova Dependencies
+
+**Cordova 6.1.0** added support for specifying the Cordova-related dependencies of a plugin
+as part of the plugin's `package.json` file. Plugins may list the dependencies for multiple
+releases to provide guidance to the Cordova CLI when it is selecting the version of a
+plugin to fetch from npm. The CLI will choose the latest release of a plugin that is
+compatible with the local project's installed platforms and plugins as well as the
+the local Cordova CLI version. If no releases of the plugin are compatible, the CLI will warn
+the user about the failed requirements and fall back to the old behavior of fetching the
+latest release.
+
+This feature is intended to eventually replace the [engines element](../../../plugin_ref/spec.html#engines-and-engine) in plugin.xml.
+Listing dependencies is a good way to ensure that your plugin will not appear broken or cause
+build errors when fetched from npm. If the latest release of the plugin is not compatible with
+a project, the CLI will give the app developer a list of unmet project requirements so that
+they are aware of incompatibilites and can update their project to support your plugin. This
+allows your plugin to respond to breaking changes without fear of confusing devlopers who
+are building against old platforms and plugins.
+
+To specify Cordova-related dependencies for a plugin, alter the `engines` element in
+`package.json` to include a `cordovaDependencies` object with the following
+structure:
+
+```javascript
+"engines": {
+ "cordovaDependencies": {
+ PLUGIN_VERSION: {
+ DEPENDENCY: SEMVER_RANGE,
+ DEPENDENCY: SEMVER_RANGE,
+ ...
+ },
+ ...
+ }
+}
+```
+
+* `PLUGIN_VERSION` specifies the version of your plugin. It should adhere to the syntax for a single version as defined by [npm's semver package][npm-semver] or an upper bound (see [below](#upper-bounds))
+* `DEPENDENCY` may be one of the following:
+ * The Cordova CLI: `"cordova"`
+ * A Cordova platform: `"cordova-android"`, `"cordova-ios"`, `"cordova-windows"`, etc.
+ * Another Cordova plugin: `"cordova-plugin-camera"`, etc.
+* `SEMVER_RANGE` should adhere to the syntax for a range as defined by [npm's semver package][npm-semver]
+
+**NOTE:** A Cordova platform `DEPENDENCY` refers to the Cordova platform and not
+the OS, i.e. `cordova-android` rather than the Android OS.
+
+Your `cordovaDependencies` may list any number of `PLUGIN_VERSION` requirements
+and any number of `DEPENDENCY` constraints. Versions of your plugin
+that do not have their dependencies listed will be assumed to have the same
+dependency information as the highest `PLUGIN_VERSION` listed below them. For
+example, consider the following entry:
+
+```javascript
+"engines": {
+ "cordovaDependencies": {
+ "1.0.0": { "cordova-android": "<3.0.0"},
+ "2.1.0": { "cordova-android": ">4.0.0"}
+ }
+}
+```
+All plugin versions below the lowest entry (1.0.0 in this example) are assumed
+to have no dependencies. Any version of the plugin between 1.0.0 and 2.1.0 is
+assumed to have the same dependencies as version 1.0.0 (a cordova-android
+version less than 3.0.0). This lets you only update your `cordovaDependencies`
+information when there are breaking changes.
+
+### Upper Bounds
+
+In addition to a single version, a `PLUGIN_VERSION` in `cordovaDependencies`
+may also specify an upper bound to amend entries for older releases
+of your plugin. This is useful when a breaking change occurs in a `DEPENDENCY`
+and a new constraint must be added for all older versions of a plugin that do
+not support it. These bounds should be written as a `<` followed by a single
+[semver][npm-semver] version (**Not an arbitrary range!**). This will apply
+whatever `DEPENDENCY` values are given to all versions of the plugin below the
+specified version. For example, consider the following entry:
+
+```javascript
+"engines": {
+ "cordovaDependencies": {
+ "0.0.1": { "cordova-ios": ">1.0.0" },
+ "<1.0.0": { "cordova-ios": "<2.0.0" },
+ "<2.0.0": { "cordova-ios": "<5.0.0" }
+ }
+}
+```
+
+Here we specify one plugin version (0.0.1) and two upper bounds (<1.0.0 and <2.0.0)
+that constrain cordova-ios. The two upper bounds do not override the constraint
+of 0.0.1, they are combined via AND at evaluation time. When the CLI checks the
+cordova-ios version of the project, the constraint that will be evaluated for
+plugin version 0.0.1 will be the combination of these three:
+
+```
+ cordova-ios >1.0.0 AND cordova-ios <2.0.0 AND cordova-ios <5.0.0
+```
+
+Please note that the only `PLUGIN_VERSION` values allowed are single versions or
+upper bounds; no other semver ranges are supported.
+
+[cdv_plugin]: ../../../reference/cordova-cli/index.html#cordova-plugin-command
+[npm-semver]: https://www.npmjs.com/package/semver
diff --git a/www/docs/en/11.x/guide/hybrid/webviews/index.md b/www/docs/en/11.x/guide/hybrid/webviews/index.md
new file mode 100644
index 0000000..0d3bf3f
--- /dev/null
+++ b/www/docs/en/11.x/guide/hybrid/webviews/index.md
@@ -0,0 +1,39 @@
+---
+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: Embedding WebViews
+toc_title: Embed Cordova in native apps
+description: Include the Cordova WebView in your native project.
+---
+
+# Embedding WebViews
+
+Cordova applications are ordinarily implemented as a browser-based
+_WebView_ within the native mobile platform. This section shows how,
+for supporting platforms, to create your own WebView components that
+make full use of Cordova APIs. You can then deploy these Cordova
+application components along with native components in a hybrid
+application.
+
+To deploy a WebView, you need to be familiar with each native
+programming environment. The following provides instructions for
+supported platforms:
+
+- [Android WebViews](../../platforms/android/webview.html)
+- [iOS WebViews](../../platforms/ios/webview.html)
\ No newline at end of file
diff --git a/www/docs/en/11.x/guide/next/index.md b/www/docs/en/11.x/guide/next/index.md
new file mode 100644
index 0000000..62f8423
--- /dev/null
+++ b/www/docs/en/11.x/guide/next/index.md
@@ -0,0 +1,194 @@
+---
+license: >
+ Licensed to the Apache Software Foundation (ASF) under one
+ or more contributor license agreements. See the NOTICE file
+ distributed with this work for additional information
+ regarding copyright ownership. The ASF licenses this file
+ to you under the Apache License, Version 2.0 (the
+ "License"); you may not use this file except in compliance
+ with the License. You may obtain a copy of the License at
+
+ http://www.apache.org/licenses/LICENSE-2.0
+
+ Unless required by applicable law or agreed to in writing,
+ software distributed under the License is distributed on an
+ "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ KIND, either express or implied. See the License for the
+ specific language governing permissions and limitations
+ under the License.
+
+title: Next Steps
+description: A look at topics that new Cordova developers will encounter.
+---
+
+# Next Steps
+
+For developers who have an understanding of how to use the Cordova CLI and make use of plugins, there are a few things you may want to consider researching next to build better, more performant Cordova applications. The following document offers advice on various topics relating to best practices, testing, upgrades, and other topics, but is not meant to be prescriptive. Consider this your launching point for your growth as a Cordova developer. Also, if you see something that can be impro [...]
+
+# Best Practices for Cordova Apps
+
+## 1) SPA Is Your Friend
+
+First and foremost - your Cordova applications should adopt the SPA (Single Page Application) design. Loosely defined, a SPA is a client-side application that is run from one request of a web page. The user loads an initial set of resources (HTML, CSS, and JavaScript) and further updates (showing a new view, loading data) is done via XHR requests. SPAs are commonly used for more complex client-side applications. Gmail is a great example of this. After you load Gmail, mail views, editing, [...]
+
+Using a SPA can help you organize your application in a more efficient manner, but it also has specific benefits for Cordova applications. A Cordova application must wait for the [deviceready event][DeviceReadyEvent] to fire before any plugins may be used. If you do not use a SPA, and your user clicks to go from one page to another, you will have to wait for [deviceready][DeviceReadyEvent] to fire again before you make use of a plugin. This is easy to forget as your application gets larger.
+
+Even if you choose not to use Cordova, creating a mobile application without using a single page architecture will have serious performance implications. This is because navigating between pages will require scripts, assets, etc., to be reloaded. Even if these assets are cached, there will still be performance issues.
+
+Examples of SPA libraries you can use in your Cordova applications are:
+
+* [ReactJS](https://reactjs.org)
+* [Vue](https://vuejs.org/)
+* [Angular](https://angular.io/)
+* [EmberJS](https://emberjs.com)
+* [Backbone](https://backbonejs.org)
+* [Kendo UI](https://www.telerik.com/kendo-ui)
+* [Onsen UI](https://onsen.io)
+* [Sencha Ext JS](https://www.sencha.com/products/extjs/)
+
+And many, many, more.
+
+## 2) Performance Considerations
+
+Consider the following issues to improve the performance in your mobile applications:
+
+**Click versus Touch** - Many devices impose a 300ms delay on click events in order to distinguish between a tap and tap-to-zoom gesture. This can have the effect of making your app feel slow and unresponsive. Avoiding this delay is one of the most important ways of improving your app's perceived performance. For more information on the tap delay, see [300ms tap delay, gone away](https://developers.google.com/web/updates/2013/12/300ms-tap-delay-gone-away) on the Google Developer site.
+
+Most Android versions no longer impose this delay, but iOS by default still does. For iOS, using [WkWebView](https://github.com/apache/cordova-plugin-wkwebview-engine) instead of the default UIWebView gets rid of this delay. For both Android and iOS, you must ensure that your viewport meta tag has at least `width=device-width`, or you will still have the tap delay. If you need to support older devices (Android 4.4 or iOS 8), consider a polyfill such as [FastClick](https://github.com/ftla [...]
+
+**CSS Transitions versus DOM Manipulation** - Using hardware accelerated CSS transitions will be dramatically better than using JavaScript to create animations. See the list of resources at the end of this section for examples.
+
+**Networks Suck** - Ok, networks don't always suck, but the latency of mobile networks, even good mobile networks, is far worse than you probably think. A desktop app that slurps down 500 rows of JSON data, every 30 seconds, will be both slower on a mobile device as well as a battery hog. Keep in mind that Cordova apps have multiple ways to persist data in the app (LocalStorage and the file system for example). Cache that data locally and be aware of the amount of data you are sending ba [...]
+
+**Additional Performance Articles and Resources**
+
+* ["Fast Apps and Sites with JavaScript"](https://channel9.msdn.com/Events/Build/2013/4-313)
+
+## 3) Recognize and Handle Offline Status
+
+See the previous tip about networks. Not only can you be on a slow network, it is entirely possible for your application to be completely offline. Your application should handle this in an intelligent manner. If your application does not, people will think your application is broken. Given how easy it is to handle (Cordova supports listening for both an offline and online event), there is absolutely no reason for your application to not respond well when run offline. Be sure to test (see [...]
+
+Note that the online and offline events, as well as the Network Connection API, is not perfect. You may need to rely on using an XHR request to see if the device is truly offline or online. At the end of the day, be sure add some form of support for network issues - in fact, the Apple store (and probably other stores) will reject apps that don't properly handle offline/online states. For more discussion on this topic, see
+["Is This Thing On?"](https://www.telerik.com/blogs/is-this-thing-on-%28part-1%29)
+
+# Handling Upgrades
+
+## Upgrading Cordova Projects
+
+There is no upgrade command for Cordova projects. Instead, remove the platform from your project, and re-add it to get the latest version:
+
+```
+cordova platform rm android
+cordova platform add android
+```
+
+It is absolutely critical that you read up on what was changed in the updated version, as the update may break your code. The best place to find this information will be in the release notes published both in the repositories and on the Cordova blog. You will want to test your app thoroughly in order to verify that it is working correctly after you perform the update.
+
+Note: some plugins may not be compatible with the new version of Cordova. If a plugin is not compatible, you may be able to find a replacement plugin that does what you need, or you may need to delay upgrading your project. Alternatively, alter the plugin so that it does work under the new version and contribute back to the community.
+
+## Plugin Upgrades
+Upgrading plugins involves the same process as platforms - remove it, then re-add it.
+
+```
+cordova plugin rm some-plugin
+cordova plugin add some-plugin
+```
+Refer to [Manage versions and platforms](../../platform_plugin_versioning_ref/index.html) for more details.
+
+Be sure to check the updated plugin's documentation, as you may need to adjust your code to work with the new version. Also, double check that the new version of the plugin works with your project's version of Cordova.
+
+Always test your apps to ensure that installing the new plugin has not broken something that you did not anticipate.
+
+If your project has a lot of plugins that you need updated, it might save time to create a shell or batch script that removes and adds the plugins with one command.
+
+# Testing Cordova apps
+
+Testing your applications is super important. The Cordova team uses [Jasmine](https://jasmine.github.io/), but any web-friendly unit testing solution will do.
+
+## Testing on a simulator vs. on a real device
+
+It's not uncommon to use desktop browsers and device simulators/emulators when developing a Cordova application. However, it is incredibly important that you test your app on as many physical devices as you possibly can:
+
+* Simulators are just that: simulators. For example, your app may work in the iOS simulator without a problem, but it may fail on a real device (especially in certain circumstances, such as a low memory state). Or, your app may actually fail on the simulator while it works just fine on a real device.
+* Emulators are just that: emulators. They do not represent how well your app will run on a physical device. For example, some emulators may render your app with a garbled display, while a real device has no problem. (If you do encounter this problem, disable the host GPU in the emulator.)
+* Simulators are generally faster than your physical device. Emulators, on the other hand, are generally slower. Do not judge the performance of your app by how it performs in a simulator or an emulator. Do judge the performance of your app by how it runs on a spectrum of real devices.
+* It's impossible to get a good feel for how your app responds to your touch by using a simulator or an emulator. Instead, running the app on a real device can point out problems with the sizes of user interface elements, responsiveness, etc.
+* Although it would be nice to be able to test only on one device per platform, it is best to test on many devices sporting many different OS versions. For example, what works on your particular Android smartphone may fail on another Android device. What works on the latest iOS device may fail on an older one.
+
+It is, of course, impossible to test on every possible device on the market. For this reason, it's wise to recruit many testers who have different devices. Although they won't catch every problem, chances are good that they will discover quirks and issues that you would never find alone.
+
+# Debugging Cordova apps
+
+In most cases, debugging Cordova apps is quite straightforward.
+
+## iOS Debugging
+
+### Xcode
+With Xcode you can debug the iOS native side of your Cordova application. Make sure the Debug Area is showing (View -> Debug Area). Once your app is running on the device (or simulator), you can view log output in the debug area. This is where any errors or warnings will print. You can also set breakpoints within the source files. This will allow you to step through the code one line at a time and view the state of the variables at that time. The state of the variables is shown in the de [...]
+
+### Safari Remote Debugging with Web Inspector
+With Safari's web inspector you can debug the webview and js code in your Cordova application. This works only on macOS. It uses Safari to connect to your device (or the simulator) and will connect the browser's dev tools to the Cordova application. You get what you expect from dev tools - DOM inspection/manipulation, a JavaScript debugger, network inspection, the console, and more. Like Xcode, with Safari's web inspector you can set breakpoints in the JavaScript code and view the state [...]
+
+To start inspecting, first enable it on device at `Settings > Safari > Advanced > Web Inspector`. On your desktop, enable the developer tools from `Safari > Preferences > Advanced > Show Develop menu in menu bar`. In the `Develop` menu, you will now be able to select the connected device, and the app you want to inspect.
+
+## Chrome Remote Debugging
+Virtually the same as the Safari version, this works with Android only but can be used from any desktop operating system. Once connected, you get the same Chrome Dev Tools experience for your mobile applications as you do with your desktop applications. Even better, the Chrome Dev Tools have a mirror option that shows your app running on the mobile device. This is more than just a view - you can scroll and click from dev tools and it updates on the mobile device.
+
+To inspect, simply open up the URL `chrome://inspect` in Chrome on your desktop. Here you will see a list of connected devices and inspectable apps. Your device must be set up for USB debugging for this to work. Full instructions on getting set up can be found at [https://developers.google.com/chrome/mobile/docs/debugging](https://developers.google.com/chrome/mobile/docs/debugging).
+
+If you can see your device in the inspect devices section, but you can't see the Cordova webview you may need to add `android:debuggable="true"` in the `<application>` node of your `AndroidManifest.xml`.
+
+It is also possible to use Chrome Dev Tools to inspect iOS apps, through a WebKit proxy: [https://github.com/google/ios-webkit-debug-proxy/](https://github.com/google/ios-webkit-debug-proxy/)
+
+# User Interface
+
+Building a Cordova application that looks nice on mobile can be a challenge, especially for developers. Many people chose to use a UI framework to make this easier. Here is a short list of options you may want to consider.
+
+* [Ionic](https://ionicframework.com/) - This powerful UI framework actually has its own CLI to handle project creation.
+* [Ratchet](http://goratchet.com/) - Brought to you by the people who created Bootstrap.
+* [Kendo UI](https://www.telerik.com/kendo-ui) - Open source UI and application framework from Telerik.
+* [Onsen UI](https://onsen.io) - Open source UI framework for both websites and Cordova apps
+* [Topcoat](http://topcoat.io)
+* [ReactJS](https://reactjs.org/)
+
+When building your user interface, it is important to think about all platforms that you are targeting and the differences between the user's expectations. For example, an Android application that has an iOS-style UI will probably not go over well with users. This sometimes is even enforced by the various application stores. Because of this, it is important that you respect the conventions of each platform and therefore are familiar with the various Human Interface Guidelines:
+
+* [iOS](https://developer.apple.com/design/human-interface-guidelines/ios/overview/themes/)
+* [Android](https://developer.android.com/design/)
+* [Windows Phone](https://developer.microsoft.com/en-us/windows/apps/design)
+
+# Special Considerations
+
+Although Cordova makes cross-platform development easier, it's just not possible to provide 100% isolation from the underlying native platform, so do be aware of restrictions.
+
+## Platform Quirks
+
+While reading the documentation, look for sections which outline different behaviors or requirements on multiple platforms. If present, these would be in a section titled "Android Quirks", "iOS Quirks", etc. Read through these quirks and be aware of them as you work with Cordova.
+
+## Loading Remote Content
+
+Invoking Cordova JavaScript functions from a remotely-loaded HTML page (an HTML page not stored locally on the device) is an unsupported configuration. This is because Cordova was not designed for this, and the Apache Cordova community does no testing of this configuration. While it can work in some circumstances, it is not recommended nor supported. There are challenges with the same origin policy, keeping the JavaScript and native portions of Cordova synchronized at the same version (s [...]
+
+The display of remotely-loaded HTML content in a webview should be done using Cordova's InAppBrowser. The InAppBrowser is designed so that JavaScript running there does not have access to the Cordova JavaScript APIs for the reasons listed above. Please refer to the [Security Guide](../appdev/security/index.html).
+
+# Keeping Up
+
+Here are a few ways to keep up to date with Cordova.
+
+* Subscribe to the [Cordova blog](https://cordova.apache.org/blog/).
+* Subscribe to the [developer list](https://cordova.apache.org/contact/). Note - this is not a support group, but a place where development of Cordova is discussed.
+
+# Getting Help
+
+The following links are the best places to get help for Cordova:
+
+* Slack: [http://slack.cordova.io/](http://slack.cordova.io/) The official Cordova Slack channel is a great way to get help from the community, and the place you are most likely to get answers to your questions
+* StackOverflow: [https://stackoverflow.com/questions/tagged/cordova](https://stackoverflow.com/questions/tagged/cordova)
+By using the Cordova tag, you can view and browse all Cordova questions. Note that StackOverflow automatically converts the "Phonegap" tag to "Cordova", so this way you will be able to access historical questions as well
+* PhoneGap Google Group: [https://groups.google.com/forum/#!forum/phonegap](https://groups.google.com/forum/#!forum/phonegap)
+This Google Group was the old support forum when Cordova was still called PhoneGap. While there are still a lot of Cordova users that frequently visit this group, the Cordova community has expressed an interest in focusing less on this group and instead using StackOverflow for support
+* Meetup: [http://phonegap.meetup.com](https://phonegap.meetup.com) -
+Consider finding a local Cordova/PhoneGap meetup group
+
+
+[DeviceReadyEvent]: ../../cordova/events/events.html#deviceready
diff --git a/www/docs/en/11.x/guide/overview/index.md b/www/docs/en/11.x/guide/overview/index.md
new file mode 100644
index 0000000..88fb844
--- /dev/null
+++ b/www/docs/en/11.x/guide/overview/index.md
@@ -0,0 +1,164 @@
+---
+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: Architectural overview of Cordova platform
+toc_title: Overview
+description: Start here if you are new to Cordova. Includes installation and next steps.
+---
+
+# Overview
+
+Apache Cordova is an open-source mobile development framework. It allows you
+to use standard web technologies - HTML5, CSS3, and JavaScript
+for cross-platform development. Applications execute within wrappers targeted
+to each platform, and rely on standards-compliant API bindings to
+access each device's capabilities such as sensors, data, network status, etc.
+
+Use Apache Cordova if you are:
+
+* a mobile developer and want to extend an application across more
+ than one platform, without having to re-implement it with each
+ platform's language and tool set.
+
+* a web developer and want to deploy a web app that's packaged for
+ distribution in various app store portals.
+
+* a mobile developer interested in mixing native application
+ components with a _WebView_ (special browser window) that can access
+ device-level APIs, or if you want to develop a plugin interface
+ between native and WebView components.
+
+# Architecture
+
+There are several components to a Cordova application. The following
+diagram shows a high-level view of the Cordova application architecture.
+
+
+
+## WebView
+
+The Cordova-enabled WebView may provide the application with its
+entire user interface. On some platforms, it can also be a component
+within a larger, hybrid application that mixes the WebView with native
+application components.
+(See [Embedding WebViews](../hybrid/webviews/index.html) for details.)
+
+## Web App
+
+This is the part where your application code resides. The application itself is
+implemented as a web page, by default a local file named _index.html_, that
+references CSS, JavaScript, images, media files, or other resources
+are necessary for it to run. The app executes in a _WebView_ within the native
+application wrapper, which you distribute to app stores.
+
+This container has a very crucial file - [config.xml](../../config_ref/index.html)
+file that provides information about the app and specifies parameters affecting how it
+works, such as whether it responds to orientation shifts.
+
+## Plugins
+
+Plugins are an integral part of the Cordova ecosystem. They provide
+an interface for Cordova and native components to communicate with each
+other and bindings to standard device APIs. This enables you to invoke native
+code from JavaScript.
+
+Apache Cordova project maintains a set of plugins called the
+[Core Plugins](../support/index.html#core-plugin-apis). These core
+plugins provide your application to access device capabilities such as
+battery, camera, contacts, etc.
+
+In addition to the core plugins, there are several third-party plugins which
+provide additional bindings to features not necessarily available on all
+platforms. You can search for Cordova plugins using [plugin search](/plugins/) or [npm](https://www.npmjs.com/search?q=ecosystem%3Acordova). You can also
+develop your own plugins, as described in the
+[Plugin Development Guide](../hybrid/plugins/index.html). Plugins may be
+necessary, for example, to communicate between Cordova and custom native
+components.
+
+__NOTE__: When you create a Cordova project it does not have
+any plugins present. This is the new default behavior. Any plugins you
+desire, even the core plugins, must be explicitly added.
+
+Cordova does not provide any UI widgets or MV* frameworks. Cordova provides
+only the runtime in which those can execute. If you wish to use UI widgets
+and/or an MV* framework, you will need to select those and include them in
+your application.
+
+## Development Paths
+
+Cordova provides you two basic workflows to create a mobile
+app. While you can often use either workflow to accomplish the same
+task, they each offer advantages:
+
+- __Cross-platform (CLI) workflow__: Use this workflow if you want your app
+ to run on as many different mobile operating systems as possible,
+ with little need for platform-specific development. This workflow
+ centers around the `cordova` CLI. The CLI is a high-level tool that allows you to build projects
+ for many platforms at once, abstracting away much of the functionality of
+ lower-level shell scripts. The CLI copies a common set of web assets into
+ subdirectories for each mobile platform, makes any necessary
+ configuration changes for each, runs build scripts to generate
+ application binaries. The CLI also provides a common interface to
+ apply plugins to your app. To get started follow the steps in the
+ [Create your first app] guide. Unless you have a need for the platform-centered workflow, the cross-platform workflow is recommended.
+
+- __Platform-centered workflow__: Use this workflow if you want to
+ focus on building an app for a single platform and need to be able
+ to modify it at a lower level. You need to use this approach, for
+ example, if you want your app to mix custom native components with
+ web-based Cordova components, as discussed in
+ [Embedding WebViews](../hybrid/webviews/index.html). As a rule of thumb, use
+ this workflow if you need to modify the project within the SDK. This
+ workflow relies on a set of lower-level shell scripts that are tailored for
+ each supported platform, and a separate Plugman utility that allows you to
+ apply plugins. While you can use this workflow to build cross-platform
+ apps, it is generally more difficult because the lack of a
+ higher-level tool means separate build cycles and plugin
+ modifications for each platform.
+
+When first starting out, it may be easiest to use the cross-platform
+workflow to create an app, as described in [Create your first app] guide.
+You then have the option to switch to a platform-centered workflow if
+you need the greater control the SDK provides.
+
+> __NOTE__: Once you switch from the CLI-based workflow to one centered
+around the platform-specific SDKs and shell tools, you can't go back.
+The CLI maintains a common set of cross-platform source code, which on
+each build it uses to write over platform-specific source code. To
+preserve any modifications you make to the platform-specific assets,
+you need to switch to the platform-centered shell tools, which ignore
+the cross-platform source code, and instead relies on the
+platform-specific source code.
+
+## Installing Cordova
+
+The installation of Cordova will differ depending on the workflow above
+you choose:
+
+ * Cross-platform workflow: See [Create your first app] guide.
+
+ * Platform-centered workflow.
+
+After installing Cordova, it is recommended that you review the
+```Develop for Platforms``` section for the mobile platforms that you
+will be developing for. It is also recommended that you also review the
+[Privacy Guide](../appdev/privacy/index.html) and
+[Security Guide](../appdev/security/index.html).
+
+[Create your first app]:../cli/index.html
diff --git a/www/docs/en/11.x/guide/platforms/android/index.md b/www/docs/en/11.x/guide/platforms/android/index.md
new file mode 100644
index 0000000..a3f1386
--- /dev/null
+++ b/www/docs/en/11.x/guide/platforms/android/index.md
@@ -0,0 +1,829 @@
+---
+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 Platform Guide
+toc_title: Android
+---
+
+# Android Platform Guide
+
+This guide shows how to set up your SDK environment to deploy Cordova
+apps for Android devices, and how to optionally use Android-centered
+command-line tools in your development workflow. You need to install
+the Android SDK regardless of whether you want to use these
+platform-centered shell tools or cross-platform Cordova CLI for
+development. For a comparison of the two development paths, see the
+[Overview](../../overview/index.html#development-paths). For details on
+the CLI, see [Cordova CLI Reference][cli_reference].
+
+## Requirements and Support
+
+Cordova for Android requires the Android SDK which can be installed
+on OS X, Linux or Windows. See the Android SDK's
+[System Requirements](http://developer.android.com/sdk/index.html#Requirements).
+Cordova's latest Android package supports up to Android [API Level](https://developer.android.com/guide/topics/manifest/uses-sdk-element.html#ApiLevels) 30.
+The supported Android API Levels and Android Versions for the past
+few cordova-android releases can be found in this table:
+
+cordova-android Version | Supported Android API-Levels | Equivalent Android Version
+------------------------|------------------------------|-----------------------------
+10.X.X | 22 - 30 | 5.1 - 11.0.0
+9.X.X | 22 - 29 | 5.1 - 10.0.0
+8.X.X | 19 - 28 | 4.4 - 9.0.0
+7.X.X | 19 - 27 | 4.4 - 8.1
+6.X.X | 16 - 26 | 4.1 - 8.0.0
+5.X.X | 14 - 23 | 4.0 - 6.0.1
+4.1.X | 14 - 22 | 4.0 - 5.1
+4.0.X | 10 - 22 | 2.3.3 - 5.1
+3.7.X | 10 - 21 | 2.3.3 - 5.0.2
+
+Please note that the versions listed here are for Cordova's Android package,
+[cordova-android](https://github.com/apache/cordova-android), and not for the
+Cordova CLI. To determine what version of Cordova's Android package is installed
+in your Cordova project, run the command `cordova platform ls` in the directory
+that holds your project.
+
+As a general rule, Android versions become unsupported by Cordova as
+they dip below 5% on Google's
+[distribution dashboard](http://developer.android.com/about/dashboards/index.html).
+
+## Installing the Requirements
+
+### Java Development Kit (JDK)
+
+Install [Java Development Kit (JDK) 8](https://www.oracle.com/java/technologies/javase/javase-jdk8-downloads.html)
+or you can install [Java Development Kit (JDK) 11](https://www.oracle.com/java/technologies/javase-jdk11-downloads.html)
+if using `cordova-android` version 10+.
+
+When installing on Windows you also need to set `JAVA_HOME` Environment Variable
+according to your JDK installation path (see [Setting Environment Variables](#setting-environment-variables))
+
+### Gradle
+
+As of Cordova-Android 6.4.0, [Gradle](https://gradle.org/install/) is now required to be installed to build Android.
+
+When installing on Windows, you need to add Gradle to your path, (see [Setting Environment Variables](#setting-environment-variables))
+
+### Android SDK
+
+Install [Android Studio][android_studio]. Follow the instructions at the linked Android Developer site to get started.
+Opening Android Studio for the first time will guide you through the process of installing the Android SDK.
+
+#### Adding SDK Packages
+
+After installing the Android SDK, you must also install the packages for
+whatever [API level](http://developer.android.com/guide/topics/manifest/uses-sdk-element.html#ApiLevels)
+you wish to target. It is recommended that you install the highest SDK version
+that your version of cordova-android supports (see [Requirements and Support](#requirements-and-support)).
+
+Open the Android SDK Manager (`Tools > SDK Manager` in Android Studio, or `sdkmanager` on the command line),
+and make sure the following are installed:
+
+1. Android Platform SDK for your targeted version of Android
+1. Android SDK build-tools version 29.0.2 or higher
+
+#### Android SDK Tools:
+In Android Studio 3.6 or later, you need to manually add the old version of the Android SDK Tools. To do this:
+
+1. Open the Android Studio **SDK Manager**
+2. In the Android **SDK Tools** tab, uncheck `Hide Obsolete Packages`
+3. Check `Android SDK Tools (Obsolete)`
+
+See Android's documentation on [Installing SDK Packages](https://developer.android.com/studio/intro/update)
+for more details.
+
+### Setting environment variables
+
+Cordova's CLI tools require some environment variables to be set in order to
+function correctly. The CLI will attempt to set these variables for you, but
+in certain cases you may need to set them manually. The following variables
+should be updated:
+
+1. Set the `JAVA_HOME` environment variable to the location of your JDK
+ installation
+2. Set the `ANDROID_SDK_ROOT` environment variable to the location of your Android
+ SDK installation
+3. It is also recommended that you add the Android SDK's `cmdline-tools/latest/bin`, `emulator`
+ and `platform-tools` directories to your `PATH`
+4. For apksigner and zipalign, the Android SDK's `build-tools` must also be added to your `PATH`
+
+#### OS X and Linux
+
+On a Mac or Linux, you can use a text editor to create or modify the
+`~/.bash_profile` file. To set an environment variable, add a line that uses
+`export` like so (substitute the path with your local installation):
+
+```bash
+export ANDROID_SDK_ROOT=/Development/android-sdk/
+```
+
+To update your `PATH`, add a line resembling the following (substitute the paths
+with your local Android SDK installation's location):
+
+```bash
+export PATH=$PATH:$ANDROID_SDK_ROOT/platform-tools/
+export PATH=$PATH:$ANDROID_SDK_ROOT/cmdline-tools/latest/bin/
+export PATH=$PATH:$ANDROID_SDK_ROOT/emulator/
+```
+
+Reload your terminal to see this change reflected or run the following command:
+
+```bash
+$ source ~/.bash_profile
+```
+
+#### Windows
+
+These steps may vary depending on your installed version of Windows. Close and
+reopen any command prompt windows after making changes to see them reflected.
+
+1. Click on the __Start__ menu in the lower-left corner of the desktop
+
+1. In the search bar, search for __Environment Variables__ and select __Edit the
+ system Environment Variables__ from the options that appear
+
+1. In the window that appears, click the __Environment Variables__ button
+
+##### To create a new environment variable:
+
+1. Click __New...__ and enter the variable name and value
+
+##### To set your __PATH__:
+
+1. Select the __PATH__ variable and press __Edit__.
+
+1. Add entries for the relevant locations to the __PATH__. For example
+(substitute the paths with your local Android SDK installation's location):
+
+ ```
+ C:\Users\[your user]\AppData\Local\Android\Sdk\platform-tools
+ C:\Users\[your user]\AppData\Local\Android\Sdk\cmdline-tools\latest\bin
+ C:\Users\[your user]\AppData\Local\Android\Sdk\tools\emulator
+ ```
+
+## Project Configuration
+
+### Setting up an Emulator
+
+If you wish to run your Cordova app on an Android emulator, you will first need
+to create an Android Virtual Device (AVD). See the Android documentation for
+[managing AVDs](https://developer.android.com/studio/run/managing-avds.html),
+[configuring the emulator](https://developer.android.com/studio/run/emulator.html#about),
+and [setting up hardware acceleration](https://developer.android.com/studio/run/emulator-acceleration.html).
+
+Once your AVD is configured correctly, you should be able to deploy your Cordova
+application to the emulator by running:
+
+```bash
+$ cordova run --emulator
+```
+
+### Configuring Gradle
+
+As of **cordova-android@4.0.0**, Cordova for Android projects are built using
+[Gradle](http://www.gradle.org/). For instructions on building with Ant, refer
+to older versions of the documentation. Please note that Ant builds are
+deprecated as of the Android SDK Tools 25.3.0.
+
+#### Setting Gradle Properties
+
+It is possible to configure the Gradle build by setting the values of certain
+[Gradle properties](https://docs.gradle.org/current/userguide/build_environment.html)
+that Cordova exposes. The following properties are available to be set:
+
+| Property | Description
+|-----------------------------------|-------------------------------------------
+| `cdvBuildMultipleApks` | If this is set, then multiple APK files will be generated: One per native platform supported by library projects (x86, ARM, etc). This can be important if your project uses large native libraries, which can drastically increase the size of the generated APK. If not set, then a single APK will be generated which can be used on all devices
+| `cdvVersionCode` | Overrides the versionCode set in `AndroidManifest.xml`
+| `cdvReleaseSigningPropertiesFile` | *Default: `release-signing.properties`*<br>Path to a .properties file that contains signing information for release builds (see [Signing an App](#signing-an-app))
+| `cdvDebugSigningPropertiesFile` | *Default: `debug-signing.properties`*<br>Path to a .properties file that contains signing information for debug builds (see [Signing an App](#signing-an-app)). Useful when you need to share a signing key with other developers
+| `cdvMinSdkVersion` | Overrides the value of `minSdkVersion` set in `AndroidManifest.xml`. Useful when creating multiple APKs based on SDK version
+| `cdvBuildToolsVersion` | Overrides the automatically detected `android.buildToolsVersion` value
+| `cdvCompileSdkVersion` | Overrides the automatically detected `android.compileSdkVersion` value
+
+You can set these properties in one of four ways:
+
+ 1. By setting environment variables like so:
+
+ ```bash
+ $ export ORG_GRADLE_PROJECT_cdvMinSdkVersion=20
+ $ cordova build android
+ ```
+
+ 2. By using the `--gradleArg` flag in your Cordova `build` or `run` commands:
+
+ ```bash
+ $ cordova run android -- --gradleArg=-PcdvMinSdkVersion=20
+ ```
+
+ 3. By placing a file called `gradle.properties` in your Android platform
+ folder (`<your-project>/platforms/android`) and setting the properties in it
+ like so:
+
+ ```
+ # In <your-project>/platforms/android/app/gradle.properties
+ cdvMinSdkVersion=20
+ ```
+
+ 4. By extending `build.gradle` via a [`build-extras.gradle` file](#extending-buildgradle)
+ and setting the property like so:
+
+ ```groovy
+ // In <your-project>/platforms/android/app/build-extras.gradle
+ ext.cdvMinSdkVersion = 20
+ ```
+
+The latter two options both involve including an extra file in your Android
+platform folder. In general, it is discouraged that you edit the contents of
+this folder because it is easy for those changes to be lost or overwritten.
+Instead, these two files should be copied from another location into that folder
+as part of the build command by using the `before_build`
+[hook](../../appdev/hooks/index.html).
+
+#### Extending build.gradle
+
+If you need to customize `build.gradle`, rather than edit it directly, you
+should create a sibling file named `build-extras.gradle`. This file will be
+included by the main `build.gradle` when present. This file must be placed in
+the `app` folder of the Android platform directory (`<your-project>/platforms/android/app`),
+so it is recommended that you copy it over via a script attached to the
+`before_build` [hook](../../appdev/hooks/index.html).
+
+Here's an example:
+
+```groovy
+// Example build-extras.gradle
+// This file is included at the beginning of `build.gradle`
+
+// special properties (see `build.gradle`) can be set and overwrite the defaults
+ext.cdvDebugSigningPropertiesFile = '../../android-debug-keys.properties'
+
+// normal `build.gradle` configuration can happen
+android {
+ defaultConfig {
+ testInstrumentationRunner 'android.support.test.runner.AndroidJUnitRunner'
+ }
+}
+dependencies {
+ androidTestImplementation 'com.android.support.test.espresso:espresso-core:2.2.2', {
+ exclude group: 'com.android.support', module: 'support-annotations'
+ }
+}
+
+// When set, this function `ext.postBuildExtras` allows code to run at the end of `build.gradle`
+ext.postBuildExtras = {
+ android.buildTypes.debug.applicationIdSuffix = '.debug'
+}
+```
+
+Note that plugins can also include `build-extras.gradle` files via:
+
+```xml
+<framework src="some.gradle" custom="true" type="gradleReference" />
+```
+
+#### Configuring Gradle JVM Args
+
+To change the Gradle JVM args, the `--jvmargs` flag can be used with both cordova build and run commands. This is mostly useful for controlling how much memory gradle is allowed to use during the build process. It is recommended to allow at least 2048 MB.
+
+By default, JVM args has a value of `-Xmx2048m`. To increase the max allowed memory, use the `-Xmx` JVM arg. Example given below:
+
+```
+cordova build android -- --jvmargs='-Xmx4g'
+```
+
+The following units are supported:
+
+| unit | value | example
+|-----------|:---------:|---------
+| kilobyte |k |`-Xmx2097152k`
+| megabyte |m |`-Xmx2048m`
+| gigabyte |g |`-Xmx2g`
+
+### Setting the Version Code
+
+To change the [version code](https://developer.android.com/studio/publish/versioning.html)
+for your app's generated apk, set the `android-versionCode` attribute in the widget
+element of your application's [config.xml file](../../../config_ref/index.html).
+If the `android-versionCode` is not set, the version code will be determined
+using the `version` attribute. For example, if the version is `MAJOR.MINOR.PATCH`:
+
+```
+versionCode = MAJOR * 10000 + MINOR * 100 + PATCH
+```
+
+If your application has enabled the `cdvBuildMultipleApks` Gradle property (see
+[Setting Gradle Properties](#setting-gradle-properties)), the version code of
+your app will also be multiplied by 10 so that the last digit of the code can be
+used to indicate the architecture the apk was built for. This multiplication
+will happen regardless of whether the version code is taken from the
+`android-versionCode` attribute or generated using the `version`. Be aware that
+some plugins added to your project (including cordova-plugin-crosswalk-webview)
+may set this Gradle property automatically.
+
+**Please Note:** When updating the `android-versionCode` property, it is unwise
+to increment the version code taken from built apks. Instead, you should
+increment the code based off the value in your `config.xml` file's
+`android-versionCode` attribute. This is because the `cdvBuildMultipleApks`
+property causes the version code to be multiplied by 10 in the built apks and
+thus using that value will cause your next version code to be 100 times the
+original, etc.
+
+## Signing an App
+
+First, you should read the [Android app signing requirements](https://developer.android.com/studio/publish/app-signing.html).
+
+### Using Flags
+
+To sign an app, you need the following parameters:
+
+| Parameter | Flag | Description
+|-----------------------|-------------------|-----------------------------------
+| Keystore | `--keystore` | Path to a binary file which can hold a set of keys
+| Keystore Password | `--storePassword` | Password to the keystore
+| Alias | `--alias` | The id specifying the private key used for signing
+| Password | `--password` | Password for the private key specified
+| Type of the Keystore | `--keystoreType` | *Default: auto-detect based on file extension*<br>Either pkcs12 or jks
+| Package Type | `--packageType` | *Default: apk*<br>Specify whether to build an APK or an [Android App Bundle] (https://developer.android.com/guide/app-bundle) (.aab) file.<br>Accepts either `apk` or `bundle`
+
+These parameters can be specified using the command line arguments above to
+the [Cordova CLI][cli_reference] `build` or `run` commands.
+
+__Note__: You should use double `--` to indicate that these are platform-specific arguments, for example:
+
+`cordova run android --release -- --keystore=../my-release-key.keystore --storePassword=password --alias=alias_name --password=password --packageType=bundle`.
+
+### Using build.json
+
+Alternatively, you could specify them in a build configuration file (`build.json`)
+using the `--buildConfig` argument to the same commands. Here's a sample of a
+build configuration file:
+
+```json
+{
+ "android": {
+ "debug": {
+ "keystore": "../android.keystore",
+ "storePassword": "android",
+ "alias": "mykey1",
+ "password" : "password",
+ "keystoreType": "",
+ "packageType": "apk"
+ },
+ "release": {
+ "keystore": "../android.keystore",
+ "storePassword": "",
+ "alias": "mykey2",
+ "password" : "password",
+ "keystoreType": "",
+ "packageType": "bundle"
+ }
+ }
+}
+```
+
+There is also support to mix and match command line arguments and parameters in
+`build.json`. Values from the command line arguments will get precedence.
+This can be useful for specifying passwords on the command line.
+
+### Using Gradle
+
+You can also specify signing properties by including a `.properties` file and
+pointing to it with the `cdvReleaseSigningPropertiesFile` and
+`cdvDebugSigningPropertiesFile` Gradle properties (see [Setting Gradle Properties](#setting-gradle-properties)).
+The file should look like this:
+
+```
+storeFile=relative/path/to/keystore.p12
+storePassword=SECRET1
+storeType=pkcs12
+keyAlias=DebugSigningKey
+keyPassword=SECRET2
+```
+
+`storePassword` and `keyPassword` are required for automated signing.
+
+## Debugging
+
+For details on the debugging tools that come packaged with the Android SDK, see
+[Android's developer documentation for debugging](https://developer.android.com/studio/debug/index.html).
+Additionally, Android's developer documentation for [debugging web apps](http://developer.android.com/guide/webapps/debugging.html)
+provides an introduction for debugging the portion of your app running in the
+Webview.
+
+### Opening a Project in Android Studio
+
+Cordova for Android projects can be opened in the Android IDE,
+[Android Studio][android_studio].
+This can be useful if you wish to use Android Studio's built in Android
+debugging/profiling tools or if you are developing Android plugins. Please note
+that when opening your project in Android studio, it is recommended that you do
+NOT edit your code in the IDE. This will edit the code in the `platforms` folder
+of your project (not `www`), and changes are liable to be overwritten. Instead,
+edit the `www` folder and copy over your changes by running `cordova build`.
+
+Plugin developers wishing to edit their native code in the IDE should use the
+`--link` flag when adding their plugin to the project via `cordova plugin add`.
+This will link the files so that changes to the plugin files in the `platforms`
+folder are reflected in your plugin's source folder (and vice versa).
+
+To open a Cordova for Android project in Android Studio:
+
+ 1. Launch __Android Studio__.
+
+ 1. Select __Import Project (Eclipse ADT, Gradle, etc)__.
+
+ 
+
+ 1. Select the Android platform directory in your project (`<your-project>/platforms/android`).
+
+ 
+
+ 1. For the `Gradle Sync` question you can simply answer __Yes__.
+
+Once it finishes importing, you should be able to build and run the app directly
+from __Android Studio__. See [Android Studio Overview](https://developer.android.com/studio/intro/index.html)
+and [Building and Running from Android Studio](https://developer.android.com/studio/run/index.html)
+for more details.
+
+
+
+## Platform Centered Workflow
+
+cordova-android includes a number of scripts that allow the platform to be used
+without the full Cordova CLI. This development path may offer you a greater
+range of development options in certain situations than the cross-platform
+cordova CLI. For example, you need to use shell tools when deploying a custom
+Cordova WebView alongside native components. Before using this development path,
+you must still configure the Android SDK environment as described in
+[Requirements and Support](#requirements-and-support) above.
+
+For each of the scripts discussed below, refer to [Cordova CLI Reference][cli_reference]
+for more information on their arguments and usage. Each script has a name that
+matches the corresponding CLI command. For example, `cordova-android/bin/create`
+is equivalent to `cordova create`.
+
+To get started, either download the cordova-android package from
+[npm](https://www.npmjs.com/package/cordova-android) or
+[Github](https://github.com/apache/cordova-android).
+
+To create a project using this package, run the `create` script in the `bin`
+folder:
+
+```bash
+$ cordova-android/bin/create
+```
+
+The created project will have a folder named `cordova` inside that contains
+scripts for the project-specific Cordova commands (e.g. `run`, `build`, etc.).
+Additionally, the project will feature a structure different from that of a
+normal Cordova project. Notably, `/www` is moved to `/assets/www`.
+
+To install plugins in this project, use the [Cordova Plugman Utility](../../../plugin_ref/plugman.html).
+
+
+## Upgrading
+
+Refer to [this](./upgrade.html) article for instructions to upgrade your
+`cordova-android` version.
+
+## Lifecycle Guide
+
+### Cordova and Android
+
+Native Android apps typically consist of a series of [activities](http://developer.android.com/reference/android/app/Activity.html) that the user
+interacts with. Activities can be thought of as the individual screens that make
+up an application; different tasks in an app will often have their own activity.
+Each activity has its own lifecycle that is maintained as the activity enters
+and leaves the foreground of a user's device.
+
+In contrast, Cordova applications on the Android platform are executed within a
+Webview that is embedded in a *single* Android activity. The lifecycle of this
+activity is exposed to your application through the document events that are
+fired. The events are not guaranteed to line up with Android's lifecycle, but
+they can provide guidelines for saving and restoring your state. These events
+roughly map to Android callbacks as follows:
+
+Cordova Event | Rough Android Equivalent | Meaning
+----------------|---------------------------|-----------------
+`deviceready` | `onCreate()` | Application is starting (not from background)
+`pause` | `onPause()` | Application is moving to the background
+`resume` | `onResume()` | Application is returning to the foreground
+
+Most other Cordova platforms have a similar concept of lifecycles and should
+fire these same events when similar actions happen on a user's device. However,
+Android presents some unique challenges that can sometimes show up thanks to the
+native Activity lifecycle.
+
+### What makes Android different?
+
+In Android, the OS can choose to kill activities in the background in order to
+free up resources if the device is low on memory. Unfortunately, when the
+activity holding your application is killed, the Webview in which your
+application lives will be destroyed as well. Any state that your application is
+maintaining will be lost in this case. When the user navigates back to your
+application, the Activity and Webview will be recreated by the OS, but state
+will not be automatically restored for your Cordova app. For this reason, it is
+imperative that your application be aware of the lifecycle events that are fired
+and maintain whatever state is appropriate to make sure a user's context in your
+app is not lost when they leave the application.
+
+### When can this happen?
+
+Your application is susceptible to being destroyed by the OS whenever it leaves
+the sight of the user. There are two main situations in which this can occur.
+The first and most obvious case is when the user presses the home button or
+switches to another application.
+
+However, there is a second (and much more subtle) case that certain plugins can
+introduce. As noted above, Cordova applications are usually confined to the
+single activity that contains the Webview. However, there are instances in which
+other activities may be launched by plugins and temporarily push the Cordova
+activity to the background. These other Activities are typically launched in
+order to perform a specific task using a native application installed on the
+device. For example, the [Cordova camera plugin](../../../reference/cordova-plugin-camera/index.html)
+launches whatever camera activity is natively installed on the device in order
+to take a photo. Reusing the installed camera application in this way makes your
+application feel much more like a native app when the user tries to take a
+photo. Unfortunately, when the native Activity pushes your app to the background
+there is a chance the OS will kill it.
+
+For a clearer understanding of this second case, let's walk through an example
+using the camera plugin. Imagine you have an application that requires the user
+to take a profile photo. The flow of events in the application when everything
+goes as planned will look something like this:
+
+1. The user is interacting with your app and needs to take a picture
+2. The camera plugin launches the native camera activity
+ * *The Cordova activity is pushed to the background (pause event is fired)*
+3. The user takes a photo
+4. The camera activity finishes
+ * *The Cordova activity is moved to the foreground (resume event is fired)*
+5. The user is returned to your application where they left off
+
+However, this flow of events can be disrupted if a device is low on memory. If
+the Activity is killed by the OS, the above sequence of events instead plays out
+as follows:
+
+1. The user is interacting with your app and needs to take a picture
+2. The camera plugin launches the native camera activity
+ * *The OS destroys the Cordova activity (pause event is fired)*
+3. The user takes a photo
+4. The camera activity finishes
+ * *The OS recreates the Cordova activity (deviceready and resume events are fired)*
+5. The user is confused as to why they are suddenly back at your app's login screen
+
+In this instance, the OS killed the application in the background and the
+application did not maintain its state as part of the lifecycle. When the user
+returned to the app, the Webview was recreated and the app appeared to have
+restarted from scratch (hence the user's confusion). This sequence of events is
+equivalent to what happens when the home button is pressed or the user switches
+applications. The key to preventing the above experience is subscribing to
+events and properly maintaining state as part of the activity lifecycle.
+
+### Respecting the Lifecycle
+
+In the examples above, the javascript events that are fired are noted in
+italics. These events are your opportunity to save and restore your
+application's state. You should register callbacks in your application's
+`bindEvents` function that respond to the lifecycle events by saving state. What
+information you save and how you save it is left to your discretion, but you
+should be sure to save enough information so that you can restore the user to
+exactly where they left off when they return to your application.
+
+There is one additional factor in the example above that only applies in the
+second-discussed situation (i.e. when a plugin launches an external activity).
+Not only was the state of the application lost when the user finished taking a
+photo, but so was the photo that the user took. Normally, that photo would be
+delivered to your application through the callback that was registered with the
+camera plugin. However, when the Webview was destroyed that callback was lost
+forever. Luckily, cordova-android 5.1.0 and above provide a means for getting
+the result of that plugin call when your application resumes.
+
+### Retrieving plugin callback results (cordova-android 5.1.0+)
+
+When the OS destroys the Cordova activity that was pushed into the background
+by a plugin, any pending callbacks are lost as well. This means that if you
+passed a callback to the plugin that launched the new activity (e.g. the camera
+plugin), that callback will NOT be fired when the application is recreated.
+However, starting in cordova-android **5.1.0**, the `resume` event's payload will
+contain any pending plugin results from the plugin request that launched the
+external activity made prior to the activity being destroyed.
+
+The payload for the `resume` event adheres to the following format:
+
+```text
+{
+ action: "resume",
+ pendingResult: {
+ pluginServiceName: string,
+ pluginStatus: string,
+ result: any
+ }
+}
+```
+
+The fields of that payload are defined as follows:
+
+* `pluginServiceName`: The name of the plugin returning the result (e.g. "Camera"). This can be found in the `<name>` tag of a plugin's plugin.xml file
+* `pluginStatus`: The status of the plugin call (see below)
+* `result`: Whatever the result of the plugin call is
+
+The possible values for `pluginStatus` in the `pendingResult` field include the following:
+* `"OK"` - The plugin call was successful
+* `"No Result"` - The plugin call ended with no result
+* `"Error"` - The plugin call resulted in some general error
+* Other miscellaneous errors
+ * `"Class not found"`
+ * `"Illegal access"`
+ * `"Instantiation error"`
+ * `"Malformed url"`
+ * `"IO error"`
+ * `"Invalid action"`
+ * `"JSON error"`
+
+Please note that it is up to the plugin to decide what is contained in the
+`result` field and the meaning of the `pluginStatus` that is returned. Reference
+the API of the plugin you are using to see what you should expect those fields
+to contain and how to use their values.
+
+#### Example
+
+Below is a brief example application that uses the `resume` and `pause` events
+to manage state. It uses the Apache camera plugin as an example of how to
+retrieve the results of a plugin call from the `resume` event payload. The
+portion of the code dealing with the `resume`'s `event.pendingResult` object
+requires cordova-android **5.1.0+**
+
+```javascript
+// This state represents the state of our application and will be saved and
+// restored by onResume() and onPause()
+var appState = {
+ takingPicture: true,
+ imageUri: ""
+};
+
+var APP_STORAGE_KEY = "exampleAppState";
+
+var app = {
+ initialize: function() {
+ this.bindEvents();
+ },
+ bindEvents: function() {
+ // Here we register our callbacks for the lifecycle events we care about
+ document.addEventListener('deviceready', this.onDeviceReady, false);
+ document.addEventListener('pause', this.onPause, false);
+ document.addEventListener('resume', this.onResume, false);
+ },
+ onDeviceReady: function() {
+ document.getElementById("take-picture-button").addEventListener("click", function() {
+ // Because the camera plugin method launches an external Activity,
+ // there is a chance that our application will be killed before the
+ // success or failure callbacks are called. See onPause() and
+ // onResume() where we save and restore our state to handle this case
+ appState.takingPicture = true;
+
+ navigator.camera.getPicture(cameraSuccessCallback, cameraFailureCallback,
+ {
+ sourceType: Camera.PictureSourceType.CAMERA,
+ destinationType: Camera.DestinationType.FILE_URI,
+ targetWidth: 250,
+ targetHeight: 250
+ }
+ );
+ });
+ },
+ onPause: function() {
+ // Here, we check to see if we are in the middle of taking a picture. If
+ // so, we want to save our state so that we can properly retrieve the
+ // plugin result in onResume(). We also save if we have already fetched
+ // an image URI
+ if(appState.takingPicture || appState.imageUri) {
+ window.localStorage.setItem(APP_STORAGE_KEY, JSON.stringify(appState));
+ }
+ },
+ onResume: function(event) {
+ // Here we check for stored state and restore it if necessary. In your
+ // application, it's up to you to keep track of where any pending plugin
+ // results are coming from (i.e. what part of your code made the call)
+ // and what arguments you provided to the plugin if relevant
+ var storedState = window.localStorage.getItem(APP_STORAGE_KEY);
+
+ if(storedState) {
+ appState = JSON.parse(storedState);
+ }
+
+ // Check to see if we need to restore an image we took
+ if(!appState.takingPicture && appState.imageUri) {
+ document.getElementById("get-picture-result").src = appState.imageUri;
+ }
+ // Now we can check if there is a plugin result in the event object.
+ // This requires cordova-android 5.1.0+
+ else if(appState.takingPicture && event.pendingResult) {
+ // Figure out whether or not the plugin call was successful and call
+ // the relevant callback. For the camera plugin, "OK" means a
+ // successful result and all other statuses mean error
+ if(event.pendingResult.pluginStatus === "OK") {
+ // The camera plugin places the same result in the resume object
+ // as it passes to the success callback passed to getPicture(),
+ // thus we can pass it to the same callback. Other plugins may
+ // return something else. Consult the documentation for
+ // whatever plugin you are using to learn how to interpret the
+ // result field
+ cameraSuccessCallback(event.pendingResult.result);
+ } else {
+ cameraFailureCallback(event.pendingResult.result);
+ }
+ }
+ }
+}
+
+// Here are the callbacks we pass to getPicture()
+function cameraSuccessCallback(imageUri) {
+ appState.takingPicture = false;
+ appState.imageUri = imageUri;
+ document.getElementById("get-picture-result").src = imageUri;
+}
+
+function cameraFailureCallback(error) {
+ appState.takingPicture = false;
+ console.log(error);
+}
+
+app.initialize();
+```
+
+The corresponding html:
+
+```html
+<!DOCTYPE html>
+
+<html>
+ <head>
+ <meta http-equiv="Content-Security-Policy" content="default-src 'self' data: gap: https://ssl.gstatic.com 'unsafe-eval'; style-src 'self' 'unsafe-inline'; media-src *">
+ <meta name="format-detection" content="telephone=no">
+ <meta name="msapplication-tap-highlight" content="no">
+ <meta name="viewport" content="user-scalable=no, initial-scale=1, maximum-scale=1, minimum-scale=1, width=device-width">
+ <link rel="stylesheet" type="text/css" href="css/index.css">
+ <title>Cordova Android Lifecycle Example</title>
+ </head>
+ <body>
+ <div class="app">
+ <div>
+ <img id="get-picture-result" />
+ </div>
+ <Button id="take-picture-button">Take Picture</button>
+ </div>
+ <script type="text/javascript" src="cordova.js"></script>
+ <script type="text/javascript" src="js/index.js"></script>
+ </body>
+</html>
+```
+### Android Quirks
+The default API level in the Cordova Android platform has been upgraded. On an Android 9 device, clear text communication is now disabled by default.
+
+By default HTTP and FTP etc. will refuse the apps requests to use cleartext traffic. The key reason for avoiding cleartext traffic is the lack of confidentiality, authenticity, and protections against tampering; a network attacker can eavesdrop on transmitted data and also modify it without being detected. You can learn more about the `android:usesCleartextTraffic` or any other android application elements setting in the [documentation for Android developers](https://developer.android.co [...]
+
+To allow clear text communication again, set the `android:usesCleartextTraffic` on your application tag to true in `config.xml` file:
+```xml
+<platform name="android">
+ <edit-config file="app/src/main/AndroidManifest.xml" mode="merge" target="/manifest/application">
+ <application android:usesCleartextTraffic="true" />
+ </edit-config>
+</platform>
+```
+
+And also you need to add Android XML namespace `xmlns:android="http://schemas.android.com/apk/res/android"` to your widget tag in the same `config.xml`, like so:
+`<widget id="io.cordova.hellocordova" version="0.0.1" android-versionCode="13" xmlns="http://www.w3.org/ns/widgets" xmlns:cdv="http://cordova.apache.org/ns/1.0" xmlns:android="http://schemas.android.com/apk/res/android">
+</widget>`
+
+### Android Manifest Information
+
+You can learn more about the Android manifest information in the [documentation for Android developers](https://developer.android.com/guide/topics/manifest/manifest-intro).
+
+### Testing the Activity Lifecycle
+
+Android provides a developer setting for testing Activity destruction on low
+memory. Enable the "Don't keep activities" setting in the Developer Options menu
+on your device or emulator to simulate low memory scenarios. You should always
+do some amount of testing with this setting enabled to make sure that your
+application is properly maintaining state.
+
+[cli_reference]: ../../../reference/cordova-cli/index.html
+[android_studio]: https://developer.android.com/studio/index.html
diff --git a/www/docs/en/11.x/guide/platforms/android/plugin.md b/www/docs/en/11.x/guide/platforms/android/plugin.md
new file mode 100644
index 0000000..3c1c14f
--- /dev/null
+++ b/www/docs/en/11.x/guide/platforms/android/plugin.md
@@ -0,0 +1,517 @@
+---
+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
+toc_title: Android
+---
+
+# Android Plugin Development Guide
+
+This section provides details for how to implement native plugin code
+on the Android platform.
+
+Before reading this, see the [Plugin Development Guide][plugin-dev]
+for an overview of the plugin's structure and its common JavaScript
+interface. This section continues to demonstrate the sample _echo_
+plugin that communicates from the Cordova webview to the native
+platform and back. For another sample, see also the comments in
+[CordovaPlugin.java][cordova-plugin].
+
+Android plugins are based on Cordova-Android,
+which is built from an Android WebView with a native bridge.
+The native portion of an Android plugin
+consists of at least one Java class that extends the `CordovaPlugin` class and
+overrides one of its `execute` methods.
+
+## Plugin Class Mapping
+
+The plugin's JavaScript interface uses the `cordova.exec` method as
+follows:
+```js
+exec(<successFunction>, <failFunction>, <service>, <action>, [<args>]);
+```
+This marshals a request from the WebView to the Android native side,
+effectively calling the `action` method on the `service` class, with
+additional arguments passed in the `args` array.
+
+Whether you distribute a plugin as Java file or as a _jar_ file of its
+own, the plugin must be specified in your Cordova-Android
+application's `res/xml/config.xml` file. See Application Plugins for
+more information on how to use the `plugin.xml` file to inject this
+`feature` element:
+
+```xml
+<feature name="<service_name>">
+ <param name="android-package" value="<full_name_including_namespace>" />
+</feature>
+```
+
+The service name matches the one used in the JavaScript `exec` call.
+The value is the Java class's fully qualified namespace identifier.
+Otherwise, the plugin may compile but still be unavailable to Cordova.
+
+## Plugin Initialization and Lifetime
+
+One instance of a plugin object is created for the life of each
+`WebView`. Plugins are not instantiated until they are first
+referenced by a call from JavaScript, unless `<param>` with an `onload`
+`name` attribute is set to `"true"` in `config.xml`. For example,
+
+```xml
+<feature name="Echo">
+ <param name="android-package" value="<full_name_including_namespace>" />
+ <param name="onload" value="true" />
+</feature>
+```
+
+Plugins should use the `initialize` method for their start-up logic.
+
+```java
+@Override
+public void initialize(CordovaInterface cordova, CordovaWebView webView) {
+ super.initialize(cordova, webView);
+ // your init code here
+}
+```
+
+Plugins also have access to Android lifecycle events and can handle them
+by extending one of the provided methods (`onResume`, `onDestroy`, etc).
+Plugins with long-running requests, background activity such as media playback,
+listeners, or internal state should implement the `onReset()` method. It
+executes when the `WebView` navigates to a new page or refreshes, which reloads
+the JavaScript.
+
+## Writing an Android Java Plugin
+
+A JavaScript call fires off a plugin request to the native side, and
+the corresponding Java plugin is mapped properly in the `config.xml`
+file, but what does the final Android Java Plugin class look like?
+Whatever is dispatched to the plugin with JavaScript's `exec` function
+is passed into the plugin class's `execute` method. Most `execute`
+implementations look like this:
+
+```java
+@Override
+public boolean execute(String action, JSONArray args, CallbackContext callbackContext) throws JSONException {
+ if ("beep".equals(action)) {
+ this.beep(args.getLong(0));
+ callbackContext.success();
+ return true;
+ }
+ return false; // Returning false results in a "MethodNotFound" error.
+}
+```
+
+The JavaScript `exec` function's `action` parameter corresponds to a
+private class method to dispatch with optional parameters.
+
+When catching exceptions and returning errors, it's important for the
+sake of clarity that errors returned to JavaScript match Java's
+exception names as much as possible.
+
+## Threading
+
+The plugin's JavaScript does _not_ run in the main thread of the
+`WebView` interface; instead, it runs on the `WebCore` thread, as
+does the `execute` method. If you need to interact with the user
+interface, you should use the [Activity's `runOnUiThread`][ref-runonuithread]
+method like so:
+
+```java
+@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;
+}
+```
+
+If you do not need to run on the UI thread, but do not wish to block the
+`WebCore` thread either, you should execute your code using the Cordova
+[`ExecutorService`][ref-executor] obtained with `cordova.getThreadPool()` like
+so:
+
+```java
+@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;
+}
+```
+
+## Adding Dependency Libraries
+
+If your Android plugin has extra dependencies, they must be listed in the
+`plugin.xml` in one of two ways.
+
+The preferred way is to use the `<framework />` tag (see the
+[Plugin Specification][plugin-ref-framework] for more details).
+Specifying libraries in this manner allows them to be resolved via Gradle's
+[Dependency Management logic][gradle-dep-management]. This allows commonly used
+libraries such as _gson_, _android-support-v4_, and _google-play-services_ to be
+used by multiple plugins without conflict.
+
+The second option is to use the `<lib-file />` tag to specify the location of
+a jar file (see the [Plugin Specification][plugin-ref-lib-file] for
+more details). This approach should only be used if you are sure that no other
+plugin will be depending on the library you are referencing (e.g. if the library
+is specific to your plugin). Otherwise, you risk causing build errors for users
+of your plugin if another plugin adds the same library. It is worth noting that
+Cordova app developers are not necessarily native developers, so native platform
+build errors can be especially frustrating.
+
+## Echo Android Plugin Example
+
+To match the JavaScript interface's _echo_ feature described in
+Application Plugins, use the `plugin.xml` to inject a `feature`
+specification to the local platform's `config.xml` file:
+
+```xml
+<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>
+
+ <source-file src="src/android/Echo.java" target-dir="src/org/apache/cordova/plugin" />
+</platform>
+```
+
+Then add the following to the `src/android/Echo.java` file:
+
+```java
+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.");
+ }
+ }
+}
+```
+
+The necessary imports at the top of the file extends the class from
+`CordovaPlugin`, whose `execute()` method it overrides to receive
+messages from `exec()`. The `execute()` method first tests the value
+of `action`, for which in this case there is only one valid `echo`
+value. Any other action returns `false` and results in an
+`INVALID_ACTION` error, which translates to an error callback invoked
+on the JavaScript side.
+
+Next, the method retrieves the echo string using the `args` object's
+`getString` method, specifying the first parameter passed to the
+method. After the value is passed to a private `echo` method, it is
+parameter-checked to make sure it is not `null` or an empty string, in
+which case `callbackContext.error()` invokes JavaScript's error
+callback. If the various checks pass, the `callbackContext.success()`
+passes the original `message` string back to JavaScript's success
+callback as a parameter.
+
+## Android Integration
+
+Android features an [Intent][ref-intent] system that allows processes to
+communicate with each other. Plugins have access to a
+`CordovaInterface` object, which can access the Android [Activity][ref-activity]
+that runs the application. This is the [Context][ref-context] required to launch a
+new Android [Intent][ref-intent]. The `CordovaInterface` allows plugins to start
+an [Activity][ref-activity] for a result, and to set the callback plugin for when
+the [Intent][ref-intent] returns to the application.
+
+As of Cordova 2.0, Plugins can no longer directly access the
+[Context][ref-context], and the legacy `ctx` member is deprecated. All `ctx`
+methods exist on the [Context][ref-context], so both `getContext()` and
+`getActivity()` can return the required object.
+
+## Android Permissions
+
+Android permissions until recently have been handled at install-time instead
+of runtime. These permissions are required to be declared on an application that uses
+the permissions, and these permissions need to be added to the Android Manifest. This can be
+accomplished by using the `config.xml` to inject these permissions in the `AndroidManifest.xml` file.
+The example below uses the Contacts permission.
+
+```xml
+<config-file target="AndroidManifest.xml" parent="/*">
+ <uses-permission android:name="android.permission.READ_CONTACTS" />
+</config-file>
+```
+
+### Runtime Permissions (Cordova-Android 5.0.0+)
+
+Android 6.0 "Marshmallow" introduced a new permissions model where
+the user can turn on and off permissions as necessary. This means that
+applications must handle these permission changes to be future-proof, which
+was the focus of the Cordova-Android 5.0.0 release.
+
+The permissions that need to be handled at runtime can be found in the Android Developer
+documentation [here][permissions-guide].
+
+As far as a plugin is concerned, the permission can be requested by calling the permission method; the signature of which is as follows:
+
+```java
+cordova.requestPermission(CordovaPlugin plugin, int requestCode, String permission);
+```
+
+To cut down on verbosity, it's standard practice to assign this to a local static variable:
+
+```java
+public static final String READ = Manifest.permission.READ_CONTACTS;
+```
+
+It is also standard practice to define the requestCode as follows:
+
+```java
+public static final int SEARCH_REQ_CODE = 0;
+```
+
+Then, in the exec method, the permission should be checked:
+
+```java
+if(cordova.hasPermission(READ))
+{
+ search(executeArgs);
+}
+else
+{
+ getReadPermission(SEARCH_REQ_CODE);
+}
+```
+
+In this case, we just call requestPermission:
+
+```java
+protected void getReadPermission(int requestCode)
+{
+ cordova.requestPermission(this, requestCode, READ);
+}
+```
+
+This will call the activity and cause a prompt to appear, asking for the permission. Once the user has the permission, the result must be handled with the `onRequestPermissionResult` method, which
+every plugin should override. An example of this can be found below:
+
+```java
+public void onRequestPermissionResult(int requestCode, String[] permissions,
+ int[] grantResults) throws JSONException
+{
+ for(int r:grantResults)
+ {
+ if(r == PackageManager.PERMISSION_DENIED)
+ {
+ this.callbackContext.sendPluginResult(new PluginResult(PluginResult.Status.ERROR, PERMISSION_DENIED_ERROR));
+ return;
+ }
+ }
+ switch(requestCode)
+ {
+ case SEARCH_REQ_CODE:
+ search(executeArgs);
+ break;
+ case SAVE_REQ_CODE:
+ save(executeArgs);
+ break;
+ case REMOVE_REQ_CODE:
+ remove(executeArgs);
+ break;
+ }
+}
+```
+
+The switch statement above would return from the prompt and, depending on the `requestCode` that was passed in, would call the respective method. It should be noted that permission prompts may stack if the execution is not handled correctly, and that this should be avoided.
+
+In addition to asking for permission for a single permission, it is also possible to request permissions for an entire group by defining the `permissions` array, as what is done with the Geolocation plugin:
+
+```java
+String [] permissions = { Manifest.permission.ACCESS_COARSE_LOCATION, Manifest.permission.ACCESS_FINE_LOCATION };
+```
+
+Then when requesting the permission, all that needs to be done is the following:
+
+```java
+cordova.requestPermissions(this, 0, permissions);
+```
+
+This requests the permissions specified in the array. It's a good idea to provide a publicly accessible `permissions` array since this can be used by plugins that use your plugin as a
+dependency, although this is not required.
+
+## Debugging Android Plugins
+
+Android debugging can be done with either Eclipse or Android Studio, although Android
+Studio is recommended. Since Cordova-Android is currently used as a library project,
+and plugins are supported as source code, it is possible to debug the Java code inside
+a Cordova application just like a native Android application.
+
+## Launching Other Activities
+
+There are special considerations to be made if your plugin launches an Activity
+that pushes the Cordova [Activity][ref-activity] to the background. The Android OS will destroy
+Activities in the background if the device is running low on memory. In that
+case, the `CordovaPlugin` instance will be destroyed as well. If your plugin is
+waiting on a result from the [Activity][ref-activity] it launched, a new instance of your plugin
+will be created when the Cordova [Activity][ref-activity] is brought back to the foreground and
+the result is obtained. However, state for the plugin will not be automatically
+saved or restored and the `CallbackContext` for the plugin will be lost. There are
+two methods that your `CordovaPlugin` may implement to handle this situation:
+
+```java
+/**
+ * Called when the Activity is being destroyed (e.g. if a plugin calls out to an
+ * external Activity and the OS kills the CordovaActivity in the background).
+ * The plugin should save its state in this method only if it is awaiting the
+ * result of an external Activity and needs to preserve some information so as
+ * to handle that result; onRestoreStateForActivityResult() will only be called
+ * if the plugin is the recipient of an Activity result
+ *
+ * @return Bundle containing the state of the plugin or null if state does not
+ * need to be saved
+ */
+public Bundle onSaveInstanceState() {}
+
+/**
+ * Called when a plugin is the recipient of an Activity result after the
+ * CordovaActivity has been destroyed. The Bundle will be the same as the one
+ * the plugin returned in onSaveInstanceState()
+ *
+ * @param state Bundle containing the state of the plugin
+ * @param callbackContext Replacement Context to return the plugin result to
+ */
+public void onRestoreStateForActivityResult(Bundle state, CallbackContext callbackContext) {}
+```
+
+It is important to note that the above methods should only be used if your
+plugin launches an [Activity][ref-activity] for a result and should only restore the state
+necessary to handle that Activity result. The state of the plugin will *NOT* be
+restored except in the case where an Activity result is obtained that your
+plugin requested using the `CordovaInterface`'s `startActivityForResult()` method
+and the Cordova Activity was destroyed by the OS while in the background.
+
+As part of `onRestoreStateForActivityResult()`, your plugin will be passed a
+replacement CallbackContext. It is important to realize that this
+CallbackContext *IS NOT* the same one that was destroyed with the Activity. The
+original callback is lost, and will not be fired in the javascript application.
+Instead, this replacement `CallbackContext` will return the result as part of the
+[`resume`][event-resume] event that is fired when the application resumes. The
+payload of the [`resume`][event-resume] event follows this structure:
+
+```text
+{
+ action: "resume",
+ pendingResult: {
+ pluginServiceName: string,
+ pluginStatus: string,
+ result: any
+ }
+}
+```
+
+* `pluginServiceName` will match the [name element][plugin-ref-name] from your plugin.xml.
+* `pluginStatus` will be a String describing the status of the PluginResult
+ passed to the CallbackContext. See PluginResult.java for the String values
+ that correspond to plugin statuses
+* `result` will be whatever result the plugin passes to the CallbackContext
+ (e.g. a String, a number, a JSON object, etc.)
+
+This [`resume`][event-resume] payload will be passed to any callbacks that the javascript
+application has registered for the [`resume`][event-resume] event. This means that the result is
+going *directly* to the Cordova application; your plugin will not have a chance
+to process the result with javascript before the application receives it.
+Consequently, you should strive to make the result returned by the native code
+as complete as possible and not rely on any javascript callbacks when launching
+activities.
+
+Be sure to communicate how the Cordova application should interpret the result
+they receive in the [`resume`][event-resume] event. It is up to the Cordova application to
+maintain their own state and remember what requests they made and what arguments
+they provided if necessary. However, you should still clearly communicate the
+meaning of `pluginStatus` values and what sort of data is being returned in the
+[`resume`][event-resume] field as part of your plugin's API.
+
+The complete sequence of events for launching an Activity is as follows
+
+1. The Cordova application makes a call to your plugin
+2. Your plugin launches an Activity for a result
+3. The Android OS destroys the Cordova Activity and your plugin instance
+ * *`onSaveInstanceState()` is called*
+4. The user interacts with your Activity and the Activity finishes
+5. The Cordova Activity is recreated and the Activity result is received
+ * *`onRestoreStateForActivityResult()` is called*
+6. `onActivityResult()` is called and your plugin passes a result to the new
+ CallbackContext
+7. The [`resume`][event-resume] event is fired and received by the Cordova application
+
+Android provides a developer setting for debugging Activity destruction on low
+memory. Enable the "Don't keep activities" setting in the Developer Options menu
+on your device or emulator to simulate low memory scenarios. If your plugin
+launches external activities, you should always do some testing with this
+setting enabled to ensure that you are properly handling low memory scenarios.
+
+[cordova-plugin]: https://github.com/apache/cordova-android/blob/master/framework/src/org/apache/cordova/CordovaPlugin.java
+[event-resume]: ../../../cordova/events/events.html#resume
+[gradle-dep-management]: https://docs.gradle.org/current/userguide/dependency_management.html
+[permissions-guide]: http://developer.android.com/guide/topics/security/permissions.html#perm-groups
+[plugin-dev]: ../../hybrid/plugins/index.html
+[plugin-ref-framework]: ../../../plugin_ref/spec.html#framework
+[plugin-ref-lib-file]: ../../../plugin_ref/spec.html#lib-file
+[plugin-ref-name]: ../../../plugin_ref/spec.html#name
+[ref-context]: http://developer.android.com/reference/android/content/Context.html
+[ref-executor]: http://developer.android.com/reference/java/util/concurrent/ExecutorService.html
+[ref-intent]: http://developer.android.com/reference/android/content/Intent.html
+[ref-activity]: http://developer.android.com/reference/android/app/Activity.html
+[ref-runonuithread]: http://developer.android.com/reference/android/app/Activity.html#runOnUiThread(java.lang.Runnable)
diff --git a/www/docs/en/11.x/guide/platforms/android/upgrade.md b/www/docs/en/11.x/guide/platforms/android/upgrade.md
new file mode 100644
index 0000000..4fd6704
--- /dev/null
+++ b/www/docs/en/11.x/guide/platforms/android/upgrade.md
@@ -0,0 +1,659 @@
+---
+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: Upgrading Android
+---
+
+# Upgrading Android
+
+This guide shows how to modify Android projects to upgrade from older versions of Cordova.
+Most of these instructions apply to projects created with an older set
+of command-line tools that precede the `cordova` CLI utility. See [The Command-Line Interface](../../cli/index.html) for information how to update the
+version of the CLI.
+
+## Upgrading to 10.x.x
+
+The best way to upgrade to 10.X.X is to simply remove the Android platform from
+your project and re-add it with the new version. For example,
+
+```bash
+cordova platform remove android
+cordova platform add android@10.X.X
+```
+
+If you use the above method, be aware that any changes you made to the android
+platform folder will be lost (editing the contents of this folder is
+discouraged).
+
+### Breaking changes
+
+Version 10.0.0 introduces a signinificant change how URLs are loaded within the app.
+Prior versions load the apps web files like `index.html` via the file protocol.
+Which means the app starts with the URL `file:///android_asset/www/index.html`. Loading `file:///` URLs is considered insecure
+and [Android has deprecated support](https://developer.android.com/reference/android/webkit/WebSettings#setAllowUniversalAccessFromFileURLs(boolean)).
+Cordova Android 10.0.0 now uses an Android API called `WebViewAssetLoader` to load web content via the HTTP(S) scheme (`https://localhost`) by default.
+Therefore the app now starts with the URL `https://localhost/` instead of `file:///android_asset/www/index.html`. Because this is a new origin you might encouter data loss and you need to migrate your web data (Localstorage, IndexedDB etc).
+
+You can use the `config.xml` preference `<preference name="AndroidInsecureFileModeEnabled" value="true" />` to opt-out of the new WebViewAssetLoader and switch back to file URLs.
+
+## Upgrading to 7.X.X
+
+The best way to upgrade to 7.X.X is to simply remove the Android platform from
+your project and re-add it with the new version. For example,
+
+```bash
+cordova platform remove android
+cordova platform add android@7.X.X
+```
+
+If you use the above method, be aware that any changes you made to the android
+platform folder will be lost (editing the contents of this folder is
+discouraged).
+
+Unfortunately, due to the update in file structure, non-CLI projects will have
+to be updated manually, or a new Cordova project will have to be created, and the
+files transferred to the new project. This is due to the migration to Android Studio.
+
+## Upgrading to 6.X.X
+
+The best way to upgrade to 6.X.X is to simply remove the Android platform from
+your project and re-add it with the new version. For example,
+
+```bash
+cordova platform remove android
+cordova platform add android@6.X.X
+```
+
+If you use the above method, be aware that any changes you made to the android
+platform folder will be lost (editing the contents of this folder is
+discouraged).
+
+Alternatively, you may attempt to use the platform update script. For non-CLI
+projects, run:
+
+```
+bin/update path/to/project
+```
+
+
+
+## Upgrading to 5.X.X
+
+The best way to upgrade to 5.X.X is to simply remove the Android platform from
+your project and re-add it with the new version. For example,
+
+```bash
+cordova platform remove android
+cordova platform add android@5.X.X
+```
+
+If you use the above method, be aware that any changes you made to the android
+platform folder will be lost (editing the contents of this folder is
+discouraged).
+
+Alternatively, you may attempt to use the platform update script. For non-CLI
+projects, run:
+
+``
+bin/update path/to/project
+``
+
+For CLI projects:
+
+1. Update the `cordova` CLI version. See [The Command-Line Interface](../../cli/index.html).
+
+2. Run `cordova platform update android@5.0.0` in your existing projects.
+
+### Upgrading Plugins for Android Marshmallow
+
+Version 5.0.0 adds support for Android API level 23 (Marshmallow). Android
+Marshmallow introduced a new permissions model that may require you to update
+some installed plugins to ensure they are compatible with newer phones. Older
+plugin versions that do not properly handle permissions can cause your
+application to crash unexpectedly. Note that this does not affect every plugin,
+but only those that access Android permissions deemed *dangerous*
+(see [the table of dangerous permissions][android-dangerous-permissions]).
+
+The following core plugins are affected by this change and must be upgraded to
+be used with **cordova-android 5.0.0+**:
+
+Plugin | Minimum Compatible Version
+----------------------------|---------------------------
+cordova-plugin-camera | 2.0.0
+cordova-plugin-contacts | 2.0.0
+cordova-plugin-file | 4.0.0
+cordova-plugin-geolocation | 2.0.0
+cordova-plugin-media | 2.0.0
+
+For non-core plugins, you can verify if a plugin requests a
+[dangerous permission][android-dangerous-permissions] by checking the plugin's
+`plugin.xml` file. If the plugin uses Android permissions, you will see entries
+in `plugin.xml` that declare them. For example:
+
+```xml
+<uses-permission android:name="android.permission.PERMISSION_NAME" />
+```
+
+Where `PERMISSION_NAME` is replaced with the name of an Android permission.
+The `plugin.xml` file can be found in the plugin's folder in your Cordova
+project (e.g. `plugins/example-plugin/plugin.xml`). Consult the documentation of
+any plugins using dangerous permissions to determine what steps need to be taken
+to ensure **cordova-android 5.0.0+** compatibility.
+
+## Upgrading to 4.0.0
+
+There are specific upgrade steps required to take advantage of the significant
+changes in 4.0.0. First, the common upgrade steps are needed as below.
+
+For non-CLI projects, run:
+
+```
+bin/update path/to/project
+```
+
+For CLI projects:
+
+1. Update the `cordova` CLI version. See [The Command-Line Interface](../../cli/index.html).
+
+2. Run `cordova platform update android@4.0.0` in your existing projects.
+
+### Upgrading the Whitelist
+All whitelist functionality is now implemented via plugin. Without a plugin,
+your app is no longer protected by a whitelist after upgrading to 4.0.0. Cordova
+has two whitelist plugins, which provide different levels of protection.
+
+1. The `cordova-plugin-whitelist` plugin *(RECOMMENDED)*
+ * This plugin is highly recommended, as it is more secure and configurable
+ than the whitelist in previous versions
+ * See [cordova-plugin-whitelist](https://github.com/apache/cordova-plugin-whitelist)
+ for details on the configuration changes required
+ * Run: `cordova plugin add cordova-plugin-crosswalk-webview`
+
+2. The `cordova-plugin-legacy-whitelist` plugin
+ * This plugin provides the same whitelist behaviour as previous versions. See
+ [cordova-plugin-legacy-whitelist](https://github.com/apache/cordova-plugin-legacy-whitelist)
+ * No configuration changes are required, but it provides less protection than
+ the recommended plugin
+ * Run: `cordova plugin add cordova-plugin-legacy-whitelist`
+
+### Using the Crosswalk WebView
+By default, your app will continue to use the system WebView provided by the
+device. If you wish to use the Crosswalk WebView instead, simply add the
+Crosswalk plugin:
+
+```bash
+cordova plugin add cordova-plugin-crosswalk-webview
+```
+
+Upon adding the plugin, your app will get the Crosswalk WebView installed and
+configured correctly.
+
+### Upgrading to the Splashscreen Plugin
+If your app makes use of a splash screen, that functionality has been moved to
+a plugin. The configuration options for splash screens are unchanged. The only
+upgrade step required is to add the plugin:
+
+```bash
+cordova plugin add cordova-plugin-splashscreen
+```
+
+## Upgrading to 3.7.1 from 3.6.0
+
+For non-CLI projects, run:
+
+```
+bin/update path/to/project
+```
+
+For CLI projects:
+
+1. Update the `cordova` CLI version. See [The Command-Line Interface](../../cli/index.html).
+
+2. Run `cordova platform update android` in your existing projects.
+
+
+## Upgrading to 3.3.0 from 3.2.0
+
+Follow the same instructions as for `3.2.0`.
+
+Starting with 3.3.0, the Cordova runtime is now compiled as an Android Library
+instead of a Jar. This should have no effect for command-line usage, but IDE
+users will need to import the newly added `MyProject-CordovaLib` project into
+their workspace.
+
+## Upgrading to 3.2.0 from 3.1.0
+
+For projects that were created with the cordova CLI:
+
+1. Update the `cordova` CLI version. See [The Command-Line Interface](../../cli/index.html).
+
+2. Run `cordova platform update android`
+
+For projects not created with the cordova CLI, run:
+
+ bin/update <project_path>
+
+**WARNING:** On Android 4.4 - Android 4.4.3, creating a file input element with type="file" will not open the file picker dialog.
+This is a regression with Chromium on Android and the problem can be reproduced in the standalone Chrome browser on Android (see http://code.google.com/p/android/issues/detail?id=62220) The suggested workaround is to use the FileTransfer and File plugins for Android 4.4. You can listen for an onClick event from the input type="file" and then pop up a file picker UI. In order to tie the form data with the upload, you can use JavaScript to attach form values to the multi-part POST request [...]
+
+
+## Upgrading to 3.1.0 from 3.0.0
+
+For projects that were created with the cordova CLI:
+
+1. Update the `cordova` CLI version. See [The Command-Line Interface](../../cli/index.html).
+
+2. Run `cordova platform update android`
+
+For projects not created with the cordova CLI, run:
+
+ bin/update <project_path>
+
+## Upgrade to the CLI (3.0.0) from 2.9.0
+
+1. Create a new Apache Cordova 3.0.0 project using the cordova CLI, as
+ described in [The Command-Line Interface](../../cli/index.html).
+
+2. Add your platforms the cordova project, for example: `cordova
+ platform add android`.
+
+3. Copy the contents of your project's `www` directory to the `www` directory
+ at the root of the cordova project you just created.
+
+4. Copy any native assets from your old project into the appropriate
+ directories under `platforms/android`: this directory is where your
+ native cordova-android project exists.
+
+5. Use the cordova CLI tool to install any plugins you need. Note that
+ the CLI handles all core APIs as plugins, so they may need to be
+ added. Only 3.0.0 plugins are compatible with the CLI.
+
+## Upgrade to 3.0.0 from 2.9.0
+
+1. Create a new Apache Cordova Android project.
+
+2. Copy the contents of the `www` directory to the new project.
+
+3. Copy any native Android assets from the `res` directory to the new project.
+
+4. Copy over any plugins you installed from the `src` subdirectories into the new project.
+
+5. Make sure to upgrade any deprecated `<plugin>` references from your old `config.xml` file to the new `<feature>` specification.
+
+6. Update any references to the `org.apache.cordova.api` package to be `org.apache.cordova`.
+
+ __NOTE__: all core APIs have been removed and must be installed as plugins. Please see the [Using Plugman to Manage Plugins](../../../plugin_ref/plugman.html) Guide for details.
+
+## Upgrade to 2.9.0 from 2.8.0
+
+1. Run `bin/update <project_path>`.
+
+## Upgrade to 2.8.0 from 2.7.0
+
+1. Remove `cordova-2.7.0.jar` from the project's `libs` directory.
+
+2. Add `cordova-2.8.0.jar` to the project's `libs` directory.
+
+3. If you use Eclipse, please refresh your Eclipse project and do a clean.
+
+<!-- SS Eclipse -->
+
+4. Copy the new `cordova.js` into your project.
+
+5. Update your HTML to use the new `cordova.js` file.
+
+6. Copy the `res/xml/config.xml` file to match `framework/res/xml/config.xml`.
+
+7. Update `framework/res/xml/config.xml` to have similar settings as it did previously.
+
+8. Copy files from `bin/templates/cordova` to the project's `cordova` directory.
+
+## Upgrade to 2.7.0 from 2.6.0
+
+1. Remove `cordova-2.6.0.jar` from the project's `libs` directory.
+
+2. Add `cordova-2.7.0.jar` to the project's `libs` directory.
+
+3. If you use Eclipse, please refresh your Eclipse project and do a clean.
+
+4. Copy the new `cordova-2.7.0.js` into your project.
+
+5. Update your HTML to use the new `cordova-2.7.0.js` file.
+
+6. Copy the `res/xml/config.xml` to match `framework/res/xml/config.xml`.
+
+7. Update `framework/res/xml/config.xml` to have similar settings as it did previously.
+
+8. Copy files from `bin/templates/cordova` to the project's `cordova` directory.
+
+## Upgrade to 2.6.0 from 2.5.0
+
+1. Remove `cordova-2.5.0.jar` from the project's `libs` directory.
+
+2. Add `cordova-2.6.0.jar` to the project's `libs` directory.
+
+3. If you use Eclipse, please refresh your Eclipse project and do a clean.
+
+4. Copy the new `cordova-2.6.0.js` into your project.
+
+5. Update your HTML to use the new `cordova-2.6.0.js` file.
+
+6. Copy the `res/xml/config.xml` to match `framework/res/xml/config.xml`.
+
+7. Update `framework/res/xml/config.xml` to have similar settings as it did previously.
+
+8. Copy files from `bin/templates/cordova` to the project's `cordova` directory.
+
+Run `bin/update <project>` with the project path listed in the Cordova Source directory.
+
+## Upgrade to 2.5.0 from 2.4.0
+
+1. Remove `cordova-2.4.0.jar` from the project's `libs` directory.
+
+2. Add `cordova-2.5.0.jar` to the project's `libs` directory.
+
+3. If you use Eclipse, please refresh your Eclipse project and do a clean.
+
+4. Copy the new `cordova-2.5.0.js` into your project.
+
+5. Update your HTML to use the new `cordova-2.5.0.js` file.
+
+6. Copy the `res/xml/config.xml` to match `framework/res/xml/config.xml`.
+
+7. Update `framework/res/xml/config.xml` to have similar settings as it did previously.
+
+8. Copy files from `bin/templates/cordova` to the project's `cordova` directory.
+
+## Upgrade to 2.4.0 from 2.3.0
+
+1. Remove `cordova-2.3.0.jar` from the project's `libs` directory.
+
+2. Add `cordova-2.4.0.jar` to the project's `libs` directory.
+
+3. If you use Eclipse, please refresh your Eclipse project and do a clean.
+
+4. Copy the new `cordova-2.4.0.js` into your project.
+
+5. Update your HTML to use the new `cordova-2.4.0.js` file.
+
+6. Copy the `res/xml/config.xml` to match `framework/res/xml/config.xml`.
+
+7. Copy files from `bin/templates/cordova` to the project's `cordova` directory.
+
+## Upgrade to 2.3.0 from 2.2.0
+
+1. Remove `cordova-2.2.0.jar` from the project's `libs` directory.
+
+2. Add `cordova-2.3.0.jar` to the project's `libs` directory.
+
+3. If you use Eclipse, please refresh your Eclipse project and do a clean.
+
+4. Copy the new `cordova-2.3.0.js` into your project.
+
+5. Update your HTML to use the new `cordova-2.3.0.js` file.
+
+6. Copy the `res/xml/config.xml` to match `framework/res/xml/config.xml`.
+
+7. Copy files from `bin/templates/cordova` to the project's `cordova` directory.
+
+## Upgrade to 2.2.0 from 2.1.0
+
+1. Remove `cordova-2.1.0.jar` from the project's `libs` directory.
+
+2. Add `cordova-2.2.0.jar` to the project's `libs` directory.
+
+3. If you use Eclipse, please refresh your Eclipse project and do a clean.
+
+4. Copy the new `cordova-2.2.0.js` into your project.
+
+5. Update your HTML to use the new `cordova-2.2.0.js` file.
+
+6. Copy the `res/xml/config.xml` to match `framework/res/xml/config.xml`.
+
+7. Copy files from `bin/templates/cordova` to the project's `cordova` directory.
+
+## Upgrade to 2.1.0 from 2.0.0
+
+1. Remove `cordova-2.0.0.jar` from the project's `libs` directory.
+
+2. Add `cordova-2.1.0.jar` to the project's `libs` directory.
+
+3. If you use Eclipse, please refresh your Eclipse project and do a clean.
+
+4. Copy the new `cordova-2.1.0.js` into your project.
+
+5. Update your HTML to use the new `cordova-2.1.0.js` file.
+
+6. Copy the `res/xml/config.xml` to match `framework/res/xml/config.xml`.
+
+7. Copy files from `bin/templates/cordova` to the project's `cordova` directory.
+
+## Upgrade to 2.0.0 from 1.9.0
+
+1. Remove `cordova-1.9.0.jar` from the project's `libs` directory.
+
+2. Add `cordova-2.0.0.jar` to the project's `libs` directory.
+
+3. If you use Eclipse, please refresh your Eclipse project and do a clean.
+
+4. Copy the new `cordova-2.0.0.js` into your project.
+
+5. Update your HTML to use the new `cordova-2.0.0.js` file.
+
+6. Copy the `res/xml/config.xml` to match `framework/res/xml/config.xml`.
+
+In the 2.0.0 release, the `config.xml` file combines and replaces
+`cordova.xml` and `plugins.xml`. The old files are deprecated, and
+while they still work in 2.0.0, will stop working in a future release.
+
+## Upgrade to 1.9.0 from 1.8.1
+
+1. Remove `cordova-1.8.0.jar` from the project's `libs` directory.
+
+2. Add `cordova-1.9.0.jar` to the project's `libs` directory.
+
+3. If you use Eclipse, please refresh your Eclipse project and do a clean.
+
+4. Copy the new `cordova-1.9.0.js` into your project.
+
+5. Update your HTML to use the new `cordova-1.9.0.js` file.
+
+6. Update `res/xml/plugins.xml` to match `framework/res/xml/plugins.xml`.
+
+Due to the introduction of the `CordovaWebView` in the 1.9.0 release,
+third-party plugins may not work. These plugins need to get a context
+from the `CordovaInterface` using `getContext()` or `getActivity()`.
+If you are not an experienced Android developer, please contact the
+plugin maintainer and add this task to their bug tracker.
+
+## Upgrade to 1.8.0 from 1.8.0
+
+1. Remove `cordova-1.8.0.jar` from the project's `libs` directory.
+
+2. Add `cordova-1.8.1.jar` to the project's `libs` directory.
+
+3. If you use Eclipse, please refresh your Eclipse project and do a clean.
+
+4. Copy the new `cordova-1.8.1.js` into your project.
+
+5. Update your HTML to use the new `cordova-1.8.1.js` file.
+
+6. Update `res/xml/plugins.xml` to match `framework/res/xml/plugins.xml`.
+
+## Upgrade to 1.8.0 from 1.7.0
+
+1. Remove `cordova-1.7.0.jar` from the project's `libs` directory.
+
+2. Add `cordova-1.8.0.jar` to the project's `libs` directory.
+
+3. If you use Eclipse, please refresh your Eclipse project and do a clean.
+
+4. Copy the new `cordova-1.8.0.js` into your project.
+
+5. Update your HTML to use the new `cordova-1.8.0.js` file.
+
+6. Update `res/xml/plugins.xml` to match `framework/res/xml/plugins.xml`.
+
+## Upgrade to 1.8.0 from 1.7.0
+
+1. Remove `cordova-1.7.0.jar` from the project's `libs` directory.
+
+2. Add `cordova-1.8.0.jar` to the project's `libs` directory.
+
+3. If you use Eclipse, please refresh your Eclipse project and do a clean.
+
+4. Copy the new `cordova-1.8.0.js` into your project.
+
+5. Update your HTML to use the new `cordova-1.8.0.js` file.
+
+6. Update `res/xml/plugins.xml` to match `framework/res/xml/plugins.xml`.
+
+## Upgrade to 1.7.0 from 1.6.1
+
+1. Remove `cordova-1.6.1.jar` from the project's `libs` directory.
+
+2. Add `cordova-1.7.0.jar` to the project's `libs` directory.
+
+3. If you use Eclipse, please refresh your Eclipse project and do a clean.
+
+4. Copy the new `cordova-1.7.0.js` into your project.
+
+5. Update `res/xml/plugins.xml` to match `framework/res/xml/plugins.xml`.
+
+## Upgrade to 1.6.1 from 1.6.0
+
+1. Remove `cordova-1.6.0.jar` from the project's `libs` directory.
+
+2. Add `cordova-1.6.1.jar` to the project's `libs` directory.
+
+3. If you use Eclipse, please refresh your Eclipse project and do a clean.
+
+4. Copy the new `cordova-1.6.1.js` into your project.
+
+5. Update `res/xml/plugins.xml` to match `framework/res/xml/plugins.xml`.
+
+## Upgrade to 1.6.0 from 1.5.0
+
+1. Remove `cordova-1.5.0.jar` from the project's `libs` directory.
+
+2. Add `cordova-1.6.0.jar` to the project's `libs` directory.
+
+3. If you use Eclipse, please refresh your Eclipse project and do a clean.
+
+4. Copy the new `cordova-1.6.0.js` into your project.
+
+5. Update your HTML to use the new `cordova-1.6.0.js` file.
+
+6. Update `res/xml/plugins.xml` to match `framework/res/xml/plugins.xml`.
+
+7. Replace `res/xml/phonegap.xml` with `res/xml/cordova.xml` to match `framework/res/xml/cordova.xml`.
+
+## Upgrade to 1.5.0 from 1.4.0
+
+1. Remove `phonegap-1.4.0.jar` from the project's `libs` directory.
+
+2. Add `cordova-1.5.0.jar` to the project's `libs` directory.
+
+3. If you use Eclipse, please refresh your Eclipse project and do a clean.
+
+4. Copy the new `cordova-1.5.0.js` into your project.
+
+5. Update your HTML to use the new `cordova-1.5.0.js` file.
+
+6. Update `res/xml/plugins.xml` to match `framework/res/xml/plugins.xml`.
+
+7. Replace `res/xml/phonegap.xml` with `res/xml/cordova.xml` to match `framework/res/xml/cordova.xml`.
+
+## Upgrade to 1.4.0 from 1.3.0
+
+1. Remove `phonegap-1.3.0.jar` from the project's `libs` directory.
+
+2. Add `phonegap-1.4.0.jar` to the project's `libs` directory.
+
+3. If you use Eclipse, please refresh your Eclipse project and do a clean.
+
+4. Copy the new `phonegap-1.4.0.js` into your project.
+
+5. Update your HTML to use the new `phonegap-1.4.0.js` file.
+
+6. Update `res/xml/plugins.xml` to match `framework/res/xml/plugins.xml`.
+
+7. Update `res/xml/phonegap.xml` to match `framework/res/xml/phonegap.xml`.
+
+## Upgrade to 1.3.0 from 1.2.0
+
+1. Remove `phonegap-1.2.0.jar` from the project's `libs` directory.
+
+2. Add `phonegap-1.3.0.jar` to the project's `libs` directory.
+
+3. If you use Eclipse, please refresh your Eclipse project and do a clean.
+
+4. Copy the new `phonegap-1.3.0.js` into your project.
+
+5. Update your HTML to use the new `phonegap-1.2.0.js` file.
+
+6. Update `res/xml/plugins.xml` to match `framework/res/xml/plugins.xml`.
+
+7. Update `res/xml/phonegap.xml` to match `framework/res/xml/phonegap.xml`.
+
+## Upgrade to 1.2.0 from 1.1.0
+
+1. Remove `phonegap-1.1.0.jar` from the project's `libs` directory.
+
+2. Add `phonegap-1.2.0.jar` to the project's `libs` directory.
+
+3. If you use Eclipse, please refresh your Eclipse project and do a clean.
+
+4. Copy the new `phonegap-1.2.0.js` into your project.
+
+5. Update your HTML to use the new `phonegap-1.2.0.js` file.
+
+6. Update `res/xml/plugins.xml` to match `framework/res/xml/plugins.xml`.
+
+7. Update `res/xml/phonegap.xml` to match `framework/res/xml/phonegap.xml`.
+
+## Upgrade to 1.1.0 from 1.0.0
+
+1. Remove `phonegap-1.0.0.jar` from the project's `libs` directory.
+
+2. Add `phonegap-1.1.0.jar` to the project's `libs` directory.
+
+3. If you use Eclipse, please refresh your Eclipse project and do a clean.
+
+4. Copy the new `phonegap-1.1.0.js` into your project.
+
+5. Update your HTML to use the new `phonegap-1.1.0.js` file.
+
+6. Update `res/xml/plugins.xml` to match `framework/res/xml/plugins.xml`.
+
+## Upgrade to 1.0.0 from 0.9.6
+
+1. Remove `phonegap-0.9.6.jar` from the project's `libs` directory.
+
+2. Add `phonegap-1.0.0.jar` to the project's `libs` directory.
+
+3. If you use Eclipse, please refresh your Eclipse project and do a clean.
+
+4. Copy the new `phonegap-1.0.0.js` into your project.
+
+5. Update your HTML to use the new `phonegap-1.0.0.js` file.
+
+6. Add the `res/xml/plugins.xml` to match `framework/res/xml/plugins.xml`.
+
+[android-dangerous-permissions]: http://developer.android.com/guide/topics/security/permissions.html#perm-groups
diff --git a/www/docs/en/11.x/guide/platforms/android/webview.md b/www/docs/en/11.x/guide/platforms/android/webview.md
new file mode 100644
index 0000000..b07ac6a
--- /dev/null
+++ b/www/docs/en/11.x/guide/platforms/android/webview.md
@@ -0,0 +1,134 @@
+---
+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 WebViews
+---
+
+# Android WebViews
+
+This guide shows how to embed a Cordova-enabled WebView component
+within a larger Android application. For details on how these
+components can communicate with each other, see Application Plugins.
+
+If you're unfamiliar with Android, you should first familiarize
+yourself with the [Android Platform Guide](index.html) and have the latest Android
+SDK installed before you attempt the more unusual development option
+of embedding a WebView. Starting with Cordova 1.9, the Android
+platform relies on a `CordovaWebView` component, which builds on a
+legacy `CordovaActivity` component that pre-dates the 1.9 release.
+
+1. To follow these instructions, make sure you have the latest Cordova
+ distribution. Download it from
+ [cordova.apache.org](http://cordova.apache.org) and unzip its
+ Android package.
+
+1. Navigate to the Android package's `/framework` directory and run
+ `ant jar`. It creates the Cordova `.jar` file, formed as
+ `/framework/cordova-x.x.x.jar`.
+
+1. Copy the `.jar` file into the Android project's `/libs` directory.
+
+1. Add the following to the application's `/res/xml/main.xml` file,
+ with the `layout_height`, `layout_width` and `id` modified to suit
+ the application:
+
+ <org.apache.cordova.CordovaWebView
+ android:id="@+id/tutorialView"
+ android:layout_width="match_parent"
+ android:layout_height="match_parent" />
+
+1. Modify the activity so that it implements the `CordovaInterface`.
+ It should implement the included methods. You may wish to copy
+ them from `/framework/src/org/apache/cordova/CordovaActivity.java`,
+ or else implement them on your own. The following code fragment
+ shows a basic application that relies on the interface. Note how
+ the referenced view id matches the `id` attribute specified in the
+ XML fragment shown above:
+
+ 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. If the application needs to use the camera, implement the
+ following:
+
+ @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);
+ }
+ }
+
+1. Finally, remember to add the thread pool, otherwise plugins
+ have no threads on which to run:
+
+ @Override
+ public ExecutorService getThreadPool() {
+ return threadPool;
+ }
+
+1. Copy the application's HTML and JavaScript files to the Android
+ project's `/assets/www` directory.
+
+1. Copy the `config.xml` file from `/framework/res/xml` to the
+ project's `/res/xml` directory.
diff --git a/www/docs/en/11.x/guide/platforms/electron/index.md b/www/docs/en/11.x/guide/platforms/electron/index.md
new file mode 100644
index 0000000..552f27a
--- /dev/null
+++ b/www/docs/en/11.x/guide/platforms/electron/index.md
@@ -0,0 +1,466 @@
+---
+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: Electron Platform Guide
+toc_title: Electron
+---
+
+# Electron Platform Guide
+
+Electron is a framework that uses web technologies (HTML, CSS, and JS) to build cross-platform desktop applications.
+
+## System Requirements
+
+### Linux
+
+- **Python** version 2.7.x. It is recommended to check your Python version since some distributions like CentOS 6.x still use Python 2.6.x.
+
+### Mac
+
+- **Python** version 2.7.x with support for TLS 1.2.
+- **Xcode**, the IDE for macOS, comes bundled with necessary software development tools to code signing and compiling native code for macOS. Version 8.2.1 or higher.
+- **RedHat Build Support**
+ - **Homebrew**, one of the available macOS package managers, is used for installing additional tools and dependencies. Homebrew is needed to install RPM packaging dependencies. [**Brew Install Step**](https://brew.sh/)
+ - **RPM**, a standard package manager for multiple Linux distributions, is the tool used for creating the Linux RPM package. To install this tool, use the following [**Homebrew**](https://brew.sh/) command:
+
+ ```bash
+ brew install rpm
+ ```
+
+### Windows
+
+- **Python** version 2.7.10 or higher.
+- **PowerShell**, for Windows 7 users, must be at version 3.0 or greater for [app signing](https://www.electron.build/code-signing#windows).
+- **[Debugging Tools for Windows](https://docs.microsoft.com/en-us/windows-hardware/drivers/debugger/)** is a toolkit for enhancing debug capabilities. It is recommended to install with the **Windows SDK 10.0.15063.468**.
+
+## Quick Start
+
+### Create a Project
+
+```bash
+npm i -g cordova
+cordova create sampleApp
+cd sampleApp
+cordova platform add electron
+```
+
+_Notice: If using Cordova CLI prior to version 9.x, you will need to use the `cordova-electron` argument instead of `electron` for any command that requires the platform's name. For example:_
+
+```bash
+cordova platform add cordova-electron
+cordova run cordova-electron
+```
+
+### Preview a Project
+
+It is not necessary to build the Electron application for previewing. Since the building process can be slow, it is recommended to pass in the `--nobuild` flag to disable the build process when previewing.
+
+```bash
+cordova run electron --nobuild
+```
+
+### Build a Project
+
+**Debug Builds**
+
+```bash
+cordova build electron
+cordova build electron --debug
+```
+
+**Release Builds**
+
+```bash
+cordova build electron --release
+```
+
+## Customizing the Application's Window Options
+
+Electron provides many options to manipulate the [`BrowserWindow`](https://electronjs.org/docs/api/browser-window). This section will cover how to configure a few basic options. For a full list of options, please see the [Electron's Docs - BrowserWindow Options](https://electronjs.org/docs/api/browser-window#new-browserwindowoptions).
+
+Working with a Cordova project, it is recommended to create an Electron settings file within the project's root directory, and set its the relative path in the preference option `ElectronSettingsFilePath`, in the `config.xml` file.
+
+**Example `config.xml`:**
+
+```xml
+<platform name="electron">
+ <preference name="ElectronSettingsFilePath" value="res/electron/settings.json" />
+</platform>
+```
+
+To override or set any BrowserWindow options, in this file the options are added to the `browserWindow` property.
+
+**Example `res/electron/settings.json`:**
+
+```json
+{
+ "browserWindow": { ... }
+}
+```
+
+### How to Set the Window's Default Size
+
+By default, the `width` is set to **800** and the `height` set to **600**. This can be overridden by setting the `width` and `height` property.
+
+**Example:**
+
+```json
+{
+ "browserWindow": {
+ "width": 1024,
+ "height": 768
+ }
+}
+```
+
+### How to Disable the Window From Being Resizable
+
+Setting the `resizable` flag property, you can disable the user's ability to resize your application's window.
+
+**Example:**
+
+```json
+{
+ "browserWindow": {
+ "resizable": false
+ }
+}
+```
+
+### How to Make the Window Fullscreen
+
+Using the `fullscreen` flag property, you can force the application to launch in fullscreen.
+
+**Example:**
+
+```json
+{
+ "browserWindow": {
+ "fullscreen": true
+ }
+}
+```
+
+### How to Support Node.js and Electron APIs
+
+Set the `nodeIntegration` flag property to `true`. By default, this property flag is set to `false` to support popular libraries that insert symbols with the same names that Node.js and Electron already uses.
+
+> You can read more about this at Electron docs: [I can not use jQuery/RequireJS/Meteor/AngularJS in Electron](https://electronjs.org/docs/faq#i-can-not-use-jqueryrequirejsmeteorangularjs-in-electron).
+
+ **Example:**
+
+```json
+{
+ "browserWindow": {
+ "webPreferences": {
+ "nodeIntegration": false
+ }
+ }
+}
+```
+
+## Customizing the Electron's Main Process
+
+If it is necessary to customize the Electron's main process beyond the scope of the Electron's configuration settings, changes can be added directly to the `cdv-electron-main.js` file located in `{PROJECT_ROOT_DIR}/platform/electron/platform_www/`. This is the application's main process.
+
+> ❗ However, it is not recommended to modify this file as the upgrade process for `cordova-electron` is to remove the old platform before adding the new version.
+
+## DevTools
+
+The `--release` and `--debug` flags control the visibility of the DevTools. DevTools are shown by default on **Debug Builds** (`without a flag` or with `--debug`). If you want to hide the DevTools pass in the `--release` flag when building or running the application.
+
+> Note: DevTools can be closed or opened manually with the debug build.
+
+## Build Configurations
+
+### Default Build Configurations
+
+By default, with no additional configuration, `cordova build electron` will build default packages for the host operating system (OS) that triggers the command. Below, are the list of default packages for each OS.
+
+**Linux**
+
+| Package | Arch |
+| ------- | :---: |
+| tar.gz | x64 |
+
+**Mac**
+
+| Package | Arch |
+| ------- | :---: |
+| dmg | x64 |
+| zip | x64 |
+
+**Windows**
+
+| Package | Arch |
+| ------- | :---: |
+| nsis | x64 |
+
+### Customizing Build Configurations
+
+If for any reason you would like to customize the build configurations, modifications are placed within the `build.json` file located in the project's root directory. E.g. `{PROJECT_ROOT_DIR}/build.json`. This file contains all build configurations for all platforms (Android, Electron, iOS, Windows).
+
+**Example Config Structure**
+
+```json
+{
+ "electron": {}
+}
+```
+
+Since the Electron framework is for creating cross-platform applications, multiple configurations are required for each OS build. The `electron` node, in the `build.json` file, contains three properties that separate the build configurations for each OS.
+
+**Example Config Structure with Each Platform**
+
+```json
+{
+ "electron": {
+ "linux": {},
+ "mac": {},
+ "windows": {}
+ }
+}
+```
+
+Each OS node contains properties that are used to identify what package to generate and how to sign.
+
+**OS Properties:**
+
+- `package` is an array of package formats that will be generated.
+- `arch` is an array of architectures that each package is built for.
+- `signing` is an object that contains signing information. See [Signing Configurations](#signing-configurations) for more information.
+
+Any properties that are undefined will fallback to default values.
+
+#### Adding a `package`
+
+The `package` property is an array list of packages to be outputted. If the property is defined, the default packages are not used unless added. The order of the packages has no importance.
+
+The configuration example below will generate `tar.gz`, `dmg` and `zip` packages for macOS.
+
+```json
+{
+ "electron": {
+ "mac": {
+ "package": [
+ "dmg",
+ "tar.gz",
+ "zip"
+ ]
+ }
+ }
+}
+```
+
+**Available Packages by Operating System**
+
+| Package Type | Linux | macOS | Windows |
+| ------------ | :-----: | :--------------: | :------------------------: |
+| default | - | `dmg`<br />`zip` | - |
+| dmg | - | ✅ | - |
+| mas | - | ✅ | - |
+| mas-dev | - | ✅ | - |
+| pkg | - | ✅ | - |
+| 7z | ✅ | ✅ | ✅ |
+| zip | ✅ | ✅ | ✅ |
+| tar.xz | ✅ | ✅ | ✅ |
+| tar.lz | ✅ | ✅ | ✅ |
+| tar.gz | ✅ | ✅ | ✅ |
+| tar.bz2 | ✅ | ✅ | ✅ |
+| dir | ✅ | ✅ | ✅ |
+| nsis | - | - | ✅ |
+| nsis-web | - | - | ✅ |
+| portable | - | - | ✅ |
+| appx | - | - | ✅ <sup>**[1]**</sup> |
+| msi | - | - | ✅ |
+| AppImage | ✅ | - | - |
+| snap | ✅ | - | - |
+| deb | ✅ | - | - |
+| rpm | ✅ | - | - |
+| freebsd | ✅ | - | - |
+| pacman | ✅ | - | - |
+| p5p | ✅ | - | - |
+| apk | ✅ | - | - |
+
+- **[1]** Only Window 10 can build AppX packages.
+
+#### Setting the Package `arch`
+
+The `arch` property is an array list of architectures that each package is built for. When the property is defined, the default arch is not used unless added.
+
+> ❗ Not all architectures are available for every operating system. Please review the [Electron Releases](https://github.com/electron/electron/releases/) to identify valid combinations. For example, macOS (Darwin) only supports x64.
+
+**Available Arch**
+
+- ia32
+- x64
+- armv7l
+- arm64
+
+The example above will generate an `x64` `dmg` package.
+
+```json
+{
+ "electron": {
+ "mac": {
+ "package": [ "dmg" ],
+ "arch": [ "x64" ]
+ }
+ }
+}
+```
+
+### Multi-Platform Build Support
+
+> ❗ Not all platforms support this feature and may have limitations.
+
+Building for multiple platforms on a single operating system may possible but has limitations. It is recommended that the builder's operating system (host OS) matches with the platform that is being built.
+
+The matrix below shows each host OS and for which platforms they are capable of building applications.
+
+| Host <sup>**[1]**</sup> | Linux | Mac | Window |
+| ----------------------- | :-----: | :-----: | :-------------------------: |
+| Linux | ✅ | | ❗ <sup>**[2]**</sup> |
+| Mac <sup>**[3]**</sup> | ✅ | ✅ | ❗ <sup>**[2]**</sup> |
+| Window | | | ✅ |
+
+**Limitations:**
+
+- **[1]** If the app contains native dependency, it can only be compiled on the targeted platform.
+- **[2]** Linux and macOS are unable to build Windows Appx packages for Windows Store.
+- **[3]** [All required system dependencies, except rpm, will be downloaded automatically on demand. RPM can be installed with brew. (macOS Sierra 10.12+)](https://www.electron.build/multi-platform-build#macos)
+
+The example below enables multi-platform build for all OS and uses the default build configurations.
+
+```json
+{
+ "electron": {
+ "linux": {},
+ "mac": {},
+ "windows": {}
+ }
+}
+```
+
+## Signing Configurations
+
+### macOS Signing
+
+There are three types of signing targets. (`debug`, `release`, and `store`). Each section has the following properties:
+
+| key | description |
+| --------------------------------------------------------------------------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------- |
+| entitlements | String path value to entitlements file. |
+| entitlementsInherit | String path value to the entitlements file which inherits the security settings. |
+| identity | String value of the name of the certificate. |
+| [requirements](https://developer.apple.com/library/archive/documentation/Security/Conceptual/CodeSigningGuide/RequirementLang/RequirementLang.html) | String path value of requirements file. <br /><br />❗ This is not available for the `mas` (store) signing configurations. |
+| provisioningProfile | String path value of the provisioning profile. |
+
+**Example Config:**
+
+```json
+{
+ "electron": {
+ "mac": {
+ "package": [
+ "dmg",
+ "mas",
+ "mas-dev"
+ ],
+ "signing": {
+ "release": {
+ "identity": "APACHE CORDOVA (TEAMID)",
+ "provisioningProfile": "release.mobileprovision"
+ }
+ }
+ }
+ }
+}
+```
+
+For macOS signing, there are a few exceptions to how the signing information is used.
+By default, all packages with the exception of `mas` and `mas-dev`, use the `debug` and `release` signing configurations.
+
+Using the example config above, let's go over some use cases to better understand the exceptions.
+
+**Use Case 1:**
+
+```bash
+cordova build electron --debug
+```
+
+The command above will:
+
+- Generate a `dmg` build and `mas-dev` build using the `debug` signing configurations.
+- Ignore the `mas` target package.
+
+*Use Case 2:*
+
+```bash
+cordova build electron --release
+```
+
+The command above will:
+
+- Generate a `dmg` build using the `release` config.
+- Generate a `mas` build using the `store` config.
+- Ignore the `mas-dev` target package.
+
+### Windows Signing
+
+The signing information is comprised of two types. (`debug`, `release`). Each section has the following properties:
+
+| key | description |
+| ------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------- |
+| certificateFile | String path to the certificate file. |
+| certificatePassword | String value of the certificate file's password.<br /><br />**Alternative**: The password can be set on the environment variable `CSC_KEY_PASSWORD`. |
+| certificateSubjectName | String value of the signing certificate's subject.<br /><br />❗ Required for EV Code Signing and requires Windows |
+| certificateSha1 | String value of the SHA1 hash of the signing certificate.<br /><br />❗ Requires Windows |
+| signingHashAlgorithms | Collection of singing algorithms to be used. (`sha1`, `sha256`)<br /><br />❗ AppX builds only support `sha256` |
+| additionalCertificateFile | String path to the additional certificate files. |
+
+**Example Config:**
+
+```json
+{
+ "electron": {
+ "windows": {
+ "package": [ "nsis" ],
+ "signing": {
+ "release": {
+ "certificateFile": "path_to_files",
+ "certificatePassword": "password"
+ }
+ }
+ }
+ }
+}
+```
+
+### Linux Signing
+
+There are not signing requirements for Linux builds.
+
+## Plugins
+
+All browser-based plugins are usable with the Electron platform.
+
+When adding a plugin, if the plugin supports both the `electron` and `browser` platform, the `electron` portion will be used. If the plugin misses `electron` but contains the `browser` implementation, it will fall back on the `browser` implementation.
+
+Internally, Electron is using Chromium (Chrome) as its web view. Some plugins may have conditions written specifically for each different browser. In this case, it may affect the behavior of what is intended. Since Electron may support feature that the browser does not, these plugins would possibly need to be updated for the `electron` platform.
diff --git a/www/docs/en/11.x/guide/platforms/ios/index.md b/www/docs/en/11.x/guide/platforms/ios/index.md
new file mode 100644
index 0000000..4f0b3ba
--- /dev/null
+++ b/www/docs/en/11.x/guide/platforms/ios/index.md
@@ -0,0 +1,318 @@
+---
+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: iOS Platform Guide
+toc_title: iOS
+---
+
+# iOS Platform Guide
+
+This guide shows how to set up your SDK development environment to
+deploy Cordova apps for iOS devices such as iPhone and iPad,
+and how to optionally use iOS-centered command-line tools in your
+development workflow. You need to install the SDK tools regardless of
+whether you want to use these platform-centered shell tools
+or cross-platform Cordova CLI for development. For a comparison of the two
+development paths, see the [Overview](../../overview/index.html#development-paths).
+For details on the CLI, see [Cordova CLI Reference][cli].
+
+## Requirements and Support
+
+Apple® tools required to build iOS applications only run on the OS X
+operating system on Intel-based Macs. Xcode® 11.0 (the minimum required
+version) runs only on OS X version 10.14.4 (Mojave) or greater, and
+includes the iOS 13 SDK (Software Development Kit). To submit apps to
+the Apple App Store℠ requires the latest versions of the Apple tools.
+
+You can test many of the Cordova features using the iOS simulator
+installed with the iOS SDK and Xcode, but you need an actual device to
+fully test all of the app's device features before submitting to the
+App Store. The device must have at least iOS 11 installed, the
+minimum iOS version supported since the release of cordova-ios v6.0.0.
+
+## Installing the Requirements
+
+### Xcode
+
+There are two ways to download Xcode:
+
+* from the [App Store](https://itunes.apple.com/us/app/xcode/id497799835?mt=12),
+ available by searching for "Xcode" in the __App Store__ application.
+
+* from [Apple Developer Downloads](https://developer.apple.com/downloads/index.action),
+ which requires registration as an Apple Developer.
+
+Once Xcode is installed, several command-line tools need to be enabled
+for Cordova to run. From the command line, run:
+```bash
+$ xcode-select --install
+```
+
+### Deployment Tools
+
+The [ios-deploy](https://www.npmjs.org/package/ios-deploy) tools allow you
+to launch iOS apps on an iOS Device from the command-line.
+
+Install ios-deploy via [Homebrew](https://brew.sh/) by running:
+
+```bash
+$ brew install ios-deploy
+```
+
+### CocoaPods
+
+The [CocoaPods](https://cocoapods.org/#install) tools are needed to build iOS apps. A minimum version of 1.8.0 is required but the latest release is always recommended.
+
+To install CocoaPods, run the following from command-line terminal:
+
+```bash
+$ sudo gem install cocoapods
+```
+
+## Project Configuration
+
+Installing Xcode will mostly set everything needed to get started with the native side of things.
+You should now be able to create and build a cordova project.
+For more details on installing and using the CLI, refer to [Create your first app](../../cli/index.html) guide.
+
+### Deploying to Simulator
+
+To preview the app in the iOS simulator:
+
+1. Open the workspace file (`platforms/ios/HelloWorld.xcworkspace`) from Xcode, _or_ from the command line:
+
+ ```bash
+ $ open ./platforms/ios/HelloWorld.xcworkspace/
+ ```
+
+2. Make sure the `HelloWorld` project is selected in the left panel (1).
+
+ 
+
+3. Select the intended device from the toolbar's __Scheme__ menu, such
+ as the iPhone XR Simulator as highlighted in (2)
+
+4. Press the __Run__ button (3) in the same toolbar to the
+ left of the __Scheme__. That builds, deploys, and runs the
+ application in the simulator. A separate simulator application opens
+ to display the app:
+
+ 
+
+ Only one simulator may run at a time, so if you want to test the app
+ in a different simulator, you need to quit the simulator application
+ and run a different target within Xcode.
+
+Xcode comes bundled with simulators for the latest versions of iPhone
+and iPad. Older versions may be available from the __Xcode →
+Preferences... → Components__ panel.
+
+### Deploying to Device
+
+For details about various requirements to deploy to a device, refer
+to the _Launch Your App On Devices_ section of
+Apple's
+[About App Distribution Workflows](https://developer.apple.com/library/prerelease/ios/documentation/IDEs/Conceptual/AppDistributionGuide/Introduction/Introduction.html).
+Briefly, you need to do the following before deploying:
+
+1. Create a _Provisioning Profile_ within the
+ [iOS Provisioning Portal](https://developer.apple.com/ios/manage/overview/index.action).
+ You can use its _Development Provisioning Assistant_ to create and
+ install the profile and certificate Xcode requires.
+
+2. Verify that the _Code Signing Identity_ setting within the _Code Signing_ section
+ within the build settings is set to your provisioning profile
+ name.
+
+To deploy to the device:
+
+1. Use the USB cable to plug the device into your Mac.
+
+2. Select the name of the project in the Xcode window's __Scheme__
+ drop-down list.
+
+3. Select your device from the __Device__ drop-down list. If it is
+ plugged in via USB but still does not appear, press the
+ __Organizer__ button to resolve any errors.
+
+4. Press the __Run__ button to build, deploy and run the application
+ on your device.
+
+## Signing an App
+
+First, you should read through the [Code Signing Support Page](https://developer.apple.com/support/code-signing/)
+and the [App Distribution Workflows](https://developer.apple.com/library/prerelease/ios/documentation/IDEs/Conceptual/AppDistributionGuide/Introduction/Introduction.html).
+
+### Using Flags
+
+To sign an app, you need the following parameters:
+
+| Parameter | Flag | Description
+|--------------------------|--------------------------|-----------------------------------
+| Code Sign Identity | `--codeSignIdentity` | Code signing identity to use for signing. It can be created with Xcode and added to your keychain. Starting with Xcode 8 you should use `--codeSignIdentity="iPhone Developer"` both for `debug` and `release`.
+| Development Team | `--developmentTeam` | The development team ([Team ID](https://developer.apple.com/account/#/membership/)) to use for code signing. You would use this setting and a simplified Code Sign Identity (i.e. just 'iPhone Developer') to sign your apps, you do not need to provide a Provisioning Profile.
+| Packaging Type | `--packageType` | This will determine what type of build is generated by Xcode. Valid options are `development` (the default), `enterprise`, `ad-hoc`, and `app-store`.
+| Provisioning Profile | `--provisioningProfile` | (Optional) GUID of the provisioning profile to be used for manual signing. It is copied here on your Mac: ```~/Library/MobileDevice/Provisioning\ Profiles/```. Opening it in a text editor, you can find the GUID which needs to be specified here if using manual signing.
+| Code Sign Resource Rules | `--codesignResourceRules`| (Optional) Used to control which files in a bundle should be sealed by a code signature. For more details, read [The OS X Code Signing In Depth article](https://developer.apple.com/library/mac/technotes/tn2206/_index.html#//apple_ref/doc/uid/DTS40007919-CH1-TNTAG206)
+| Automatic Provisioning | `--automaticProvisioning`| (Optional) Enable to allow Xcode to automatically manage provisioning profiles. Valid options are `false` (the default) and `true`.
+
+### Using build.json
+
+Alternatively, you could specify them in a build configuration file (`build.json`)
+using the `--buildConfig` argument to the same commands. Here's a sample of a
+build configuration file:
+
+For automatic signing, where provisioning profiles are managed automatically by Xcode (recommended):
+
+```json
+{
+ "ios": {
+ "debug": {
+ "codeSignIdentity": "iPhone Developer",
+ "developmentTeam": "FG35JLLMXX4A",
+ "packageType": "development",
+ "automaticProvisioning": true,
+ "buildFlag": [
+ "EMBEDDED_CONTENT_CONTAINS_SWIFT = YES",
+ "ALWAYS_EMBED_SWIFT_STANDARD_LIBRARIES=NO",
+ "LD_RUNPATH_SEARCH_PATHS = \"@executable_path/Frameworks\""
+ ]
+ },
+ "release": {
+ "codeSignIdentity": "iPhone Developer",
+ "developmentTeam": "FG35JLLMXX4A",
+ "packageType": "app-store",
+ "automaticProvisioning": true,
+ "buildFlag": [
+ "EMBEDDED_CONTENT_CONTAINS_SWIFT = YES",
+ "ALWAYS_EMBED_SWIFT_STANDARD_LIBRARIES=NO",
+ "LD_RUNPATH_SEARCH_PATHS = \"@executable_path/Frameworks\""
+ ]
+ }
+ }
+}
+```
+
+For manual signing, specifying the provisioning profiles by UUID:
+
+```json
+{
+ "ios": {
+ "debug": {
+ "codeSignIdentity": "iPhone Development",
+ "provisioningProfile": "926c2bd6-8de9-4c2f-8407-1016d2d12954",
+ "developmentTeam": "FG35JLLMXX4A",
+ "packageType": "development"
+ },
+ "release": {
+ "codeSignIdentity": "iPhone Distribution",
+ "provisioningProfile": "70f699ad-faf1-4adE-8fea-9d84738fb306",
+ "developmentTeam": "FG35JLLMXX4A",
+ "packageType": "app-store"
+ }
+ }
+}
+```
+
+## Xcode Build Flags
+
+If you have a custom situation where you need to pass additional build flags to Xcode you would use one or more `--buildFlag` options to pass these flags to `xcodebuild`. If you use an `xcodebuild` built-in flag, it will show a warning.
+
+ cordova build --device --buildFlag="MYSETTING=myvalue" --buildFlag="MY_OTHER_SETTING=othervalue"
+ cordova run --device --buildFlag="DEVELOPMENT_TEAM=FG35JLLMXX4A" --buildFlag="-scheme TestSchemeFlag"
+
+You can also specify a `buildFlag` option in [`build.json` above](#using-buildjson) (the value for the `buildFlag` key is a string or an array of strings).
+
+## Debugging
+
+For details on the debugging tools that come with Xcode, see this [article](https://developer.apple.com/support/debugging)
+and this [video](https://developer.apple.com/videos/play/wwdc2014-413/).
+
+### Open a Project within Xcode
+
+Cordova for iOS projects can be opened in Xcode. This can be useful if
+you wish to use Xcode built in debugging/profiling tools or if you are
+developing iOS plugins. Please note that when opening your project in Xcode,
+it is recommended that you do NOT edit your code in the IDE. This will edit the code
+in the ```platforms``` folder of your project (not ```www```), and changes are liable to be overwritten.
+Instead, edit the ```www``` folder and copy over your changes by running ```cordova build```.
+
+Plugin developers wishing to edit their native code in the IDE should use the ```--link``` flag when adding their
+plugin to the project via cordova plugin add. This will link the files so that changes to the plugin files in the
+platforms folder are reflected in your plugin's source folder (and vice versa).
+
+Once the ios platform is added to your project and built using ```cordova build```, you can open it from
+within Xcode. Double-click to open the `${PROJECT_NAME}/platforms/ios/${PROJECT_NAME}.xcworkspace`
+file or open Xcode from your terminal:
+
+```bash
+$ open -a Xcode platforms/ios
+```
+
+The screen should look like this:
+
+
+
+## Platform Centered Workflow
+
+cordova-ios includes a number of scripts that allow the platform to be used
+without the full Cordova CLI. This development path may offer you a greater
+range of development options in certain situations than the cross-platform cordova CLI.
+For example, you need to use shell tools when deploying a custom
+Cordova WebView alongside native components. Before using this
+development path, you must still configure the SDK environment
+as described in [Requirements and Support](#link-requirements-and-support)
+above.
+
+For each of the scripts discussed below, refer to
+ [Cordova CLI Reference][cli] for more information on their
+arguments and usage. Each script has a name that matches the corresponding CLI
+command. For example, `cordova-ios/bin/create` is equivalent to
+`cordova create`.
+
+To get started, either download the cordova-ios package from
+[npm](https://www.npmjs.com/package/cordova-ios) or
+[Github](https://github.com/apache/cordova-ios).
+
+To create a project using this package, run the `create` script in the `bin`
+folder:
+
+```bash
+$ cordova-ios/bin/create ...
+```
+
+To run the app, use the `run` script in the `bin` folder:
+
+```bash
+$ cordova-ios/bin/run
+```
+
+The created project will have a folder named `cordova` inside that contains
+scripts for the project-specific Cordova commands (e.g. `run`, `build`, etc.).
+
+To install plugins in this project, use the [Cordova Plugman Utility](../../../plugin_ref/plugman.html).
+
+## Upgrading
+
+Refer to [this](./upgrade.html) article for instructions to upgrade your ```cordova-ios``` version.
+
+
+(Mac®, OS X®, Apple®, Xcode®, App Store℠, iPad®, iPhone®, iPod® and Finder® are Trademarks of Apple Inc.)
+
+[cli]: ../../../reference/cordova-cli/index.html
diff --git a/www/docs/en/11.x/guide/platforms/ios/plugin.md b/www/docs/en/11.x/guide/platforms/ios/plugin.md
new file mode 100644
index 0000000..9415e8a
--- /dev/null
+++ b/www/docs/en/11.x/guide/platforms/ios/plugin.md
@@ -0,0 +1,274 @@
+---
+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: iOS Plugin Development Guide
+toc_title: iOS
+---
+
+# iOS Plugin Development Guide
+
+This section provides details for how to implement native plugin code
+on the iOS platform.
+
+Before reading this, see [Plugin Development Guide][plugin-dev] for
+an overview of the plugin's structure and its common JavaScript
+interface. This section continues to demonstrate the sample _echo_
+plugin that communicates from the Cordova webview to the native
+platform and back.
+
+An iOS plugin is implemented as an Objective-C class that extends the
+`CDVPlugin` class. For JavaScript's `exec` method's `service`
+parameter to map to an Objective-C class, each plugin class must be
+registered as a `<feature>` tag in the named application directory's
+`config.xml` file.
+
+## Plugin Class Mapping
+
+The JavaScript portion of a plugin uses the `cordova.exec` method as
+follows:
+
+```javascript
+exec(<successFunction>, <failFunction>, <service>, <action>, [<args>]);
+```
+
+This marshals a request from the `UIWebView` to the iOS native side,
+effectively calling the `action` method on the `service` class, with
+the arguments passed in the `args` array.
+
+Specify the plugin as a `<feature>` tag in your Cordova-iOS
+application's project's `config.xml` file, using the `plugin.xml` file
+to inject this markup automatically, as described in [Plugin Development Guide][plugin-dev]:
+
+```xml
+<feature name="LocalStorage">
+ <param name="ios-package" value="CDVLocalStorage" />
+</feature>
+```
+
+The feature's `name` attribute should match what you specify as the
+JavaScript `exec` call's `service` parameter. The `value` attribute
+should match the name of the plugin's Objective-C class. The `<param>`
+element's `name` should always be `ios-package`. If you do not follow
+these guidelines, the plugin may compile, but Cordova may still not be
+able to access it.
+
+## Plugin Initialization and Lifetime
+
+One instance of a plugin object is created for the life of each
+`UIWebView`. Plugins are not instantiated until they are first
+referenced by a call from JavaScript, unless `<param>` with an `onload`
+`name` attribute is set to `"true"` in `config.xml`. For example,
+
+```xml
+<feature name="Echo">
+ <param name="ios-package" value="Echo" />
+ <param name="onload" value="true" />
+</feature>
+```
+
+Plugins should use the `pluginInitialize` method for their startup logic.
+
+Plugins with long-running requests or background activities such as media
+playback, listeners, or that maintain internal state should implement
+the `onReset` method to cancel those long-running requests or to clean up
+after those activities.
+The method runs when the `UIWebView` navigates to a new page or refreshes, which
+reloads the JavaScript.
+
+## Writing an iOS Cordova Plugin
+
+A JavaScript call fires off a plugin request to the native side, and
+the corresponding iOS Objective-C plugin is mapped properly in the
+`config.xml` file, but what does the final iOS Objective-C plugin
+class look like? Whatever is dispatched to the plugin with
+JavaScript's `exec` function is passed into the corresponding plugin
+class's `action` method. A plugin method has this signature:
+
+```objective_c
+- (void)myMethod:(CDVInvokedUrlCommand*)command
+{
+ CDVPluginResult* pluginResult = nil;
+ NSString* myarg = [command.arguments objectAtIndex:0];
+
+ if (myarg != nil) {
+ pluginResult = [CDVPluginResult resultWithStatus:CDVCommandStatus_OK];
+ } else {
+ pluginResult = [CDVPluginResult resultWithStatus:CDVCommandStatus_ERROR messageAsString:@"Arg was null"];
+ }
+ [self.commandDelegate sendPluginResult:pluginResult callbackId:command.callbackId];
+}
+```
+
+For more details, see
+ [CDVInvokedUrlCommand.h][CDVInvokedUrlCommand.h], [CDVPluginResult.h][CDVPluginResult.h],
+and [CDVCommandDelegate.h][CDVCommandDelegate.h].
+
+## iOS CDVPluginResult Message Types
+
+You can use `CDVPluginResult` to return a variety of result types back to
+the JavaScript callbacks, using class methods that follow this pattern:
+
+```objective_c
++ (CDVPluginResult*)resultWithStatus:(CDVCommandStatus)statusOrdinal messageAs...
+```
+
+You can create `String`, `Int`, `Double`, `Bool`, `Array`,
+`Dictionary`, `ArrayBuffer`, and `Multipart` types. You can also leave
+out any arguments to send a status, or return an error, or even choose
+not to send any plugin result, in which case neither callback fires.
+
+Note the following for complex return values:
+
+- `messageAsArrayBuffer` expects `NSData*` and converts to an
+ `ArrayBuffer` in the JavaScript callback. Likewise, any
+ `ArrayBuffer` the JavaScript sends to a plugin are converted to
+ `NSData*`.
+
+- `messageAsMultipart` expects an `NSArray*` containing any of the
+ other supported types, and sends the entire array as the `arguments`
+ to your JavaScript callback. This way, all of the arguments are
+ serialized or deserialized as necessary, so it is safe to return
+ `NSData*` as multipart, but not as `Array`/`Dictionary`.
+
+## Echo iOS Plugin Example
+
+To match the JavaScript interface's _echo_ feature described in
+Application Plugins, use the `plugin.xml` to inject a `feature`
+specification to the local platform's `config.xml` file:
+
+```xml
+<platform name="ios">
+ <config-file target="config.xml" parent="/*">
+ <feature name="Echo">
+ <param name="ios-package" value="Echo" />
+ </feature>
+ </config-file>
+</platform>
+```
+
+
+Then we would add the following `Echo.h` and `Echo.m` files to the
+`Plugins` folder within the Cordova-iOS application directory:
+
+
+```objective_c
+/********* Echo.h Cordova Plugin Header *******/
+
+#import <Cordova/CDVPlugin.h>
+
+@interface Echo : CDVPlugin
+
+- (void)echo:(CDVInvokedUrlCommand*)command;
+
+@end
+
+/********* Echo.m Cordova Plugin Implementation *******/
+
+#import "Echo.h"
+#import <Cordova/CDVPlugin.h>
+
+@implementation Echo
+
+- (void)echo:(CDVInvokedUrlCommand*)command
+{
+ CDVPluginResult* pluginResult = nil;
+ NSString* echo = [command.arguments objectAtIndex:0];
+
+ if (echo != nil && [echo length] > 0) {
+ pluginResult = [CDVPluginResult resultWithStatus:CDVCommandStatus_OK messageAsString:echo];
+ } else {
+ pluginResult = [CDVPluginResult resultWithStatus:CDVCommandStatus_ERROR];
+ }
+
+ [self.commandDelegate sendPluginResult:pluginResult callbackId:command.callbackId];
+}
+
+@end
+```
+
+The necessary imports at the top of the file extends the class from
+`CDVPlugin`. In this case, the plugin only supports a single `echo`
+action. It obtains the echo string by calling the `objectAtIndex`
+method get the first parameter of the `arguments` array, which
+corresponds to the arguments passed in by the JavaScript `exec()`
+function.
+
+It checks the parameter to make sure it is not `nil` or an empty
+string, returning a `PluginResult` with an `ERROR` status if so. If
+the parameter passes the check, it returns a `PluginResult` with an
+`OK` status, passing in the original `echo` string. Finally, it sends
+the result to `self.commandDelegate`, which executes the `exec`
+method's success or failure callbacks on the JavaScript side. If the
+success callback is called, it passes in the `echo` parameter.
+
+## iOS Integration
+
+The `CDVPlugin` class features other methods that your plugin can
+override. For example, you can capture the [pause][PauseEvent], [resume][ResumeEvent], app
+terminate and `handleOpenURL` events. See the
+[CDVPlugin.h][CDVPlugin.h] and [CDVPlugin.m][CDVPlugin.m]
+classes for guidance.
+
+### WKURLSchemeTask Hook
+
+The [WKURLSchemeTask](https://developer.apple.com/documentation/webkit/wkurlschemetask) is an interface Cordova's main WKWebView uses to load files from your app's bundle. You can create your own custom schemes or custom loading code for the webview by implementing the `- (BOOL) overrideSchemeTask: (id <WKURLSchemeTask>)urlSchemeTask` method in a plugin.
+
+## Threading
+
+Plugin methods ordinarily execute in the same thread as the main
+interface. If your plugin requires a great deal of processing or
+requires a blocking call, you should use a background thread. For
+example:
+
+```objective_c
+- (void)myPluginMethod:(CDVInvokedUrlCommand*)command
+{
+ // Check command.arguments here.
+ [self.commandDelegate runInBackground:^{
+ NSString* payload = nil;
+ // Some blocking logic...
+ CDVPluginResult* pluginResult = [CDVPluginResult resultWithStatus:CDVCommandStatus_OK messageAsString:payload];
+ // The sendPluginResult method is thread-safe.
+ [self.commandDelegate sendPluginResult:pluginResult callbackId:command.callbackId];
+ }];
+}
+```
+
+## Debugging iOS Plugins
+
+To debug on the Objective-C side, you need Xcode's built-in debugger.
+For JavaScript, you can attach Safari to the app running within the iOS Simulator/Device.
+
+## Common Pitfalls
+
+- Don't forget to add your plugin's mapping to `config.xml`. If you
+ forget, an error is logged in the Xcode console.
+
+- Don't forget to add any hosts you connect to in the whitelist, as
+ described in Domain [Whitelist Guide](../../appdev/whitelist/index.html). If you forget, an error is
+ logged in the Xcode console.
+
+[plugin-dev]: ../../hybrid/plugins/index.html
+[CDVInvokedUrlCommand.h]: https://github.com/apache/cordova-ios/blob/master/CordovaLib/Classes/Public/CDVInvokedUrlCommand.h
+[CDVPluginResult.h]: https://github.com/apache/cordova-ios/blob/master/CordovaLib/Classes/Public/CDVPluginResult.h
+[CDVCommandDelegate.h]: https://github.com/apache/cordova-ios/blob/master/CordovaLib/Classes/Public/CDVCommandDelegate.h
+[CDVPlugin.h]: https://github.com/apache/cordova-ios/blob/master/CordovaLib/Classes/Public/CDVPlugin.h
+[CDVPlugin.m]: https://github.com/apache/cordova-ios/blob/master/CordovaLib/Classes/Public/CDVPlugin.m
+[ResumeEvent]: ../../../cordova/events/events.html#resume
+[PauseEvent]: ../../../cordova/events/events.html#pause
diff --git a/www/docs/en/11.x/guide/platforms/ios/upgrade.md b/www/docs/en/11.x/guide/platforms/ios/upgrade.md
new file mode 100644
index 0000000..04e23ae
--- /dev/null
+++ b/www/docs/en/11.x/guide/platforms/ios/upgrade.md
@@ -0,0 +1,855 @@
+---
+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: Upgrading iOS
+---
+
+# Upgrading iOS
+
+This guide shows how to modify iOS projects to upgrade from older
+versions of Cordova. Most of these instructions apply to projects
+created with an older set of command-line tools that precede the
+`cordova` CLI utility. See [The Command-Line Interface](../../cli/index.html) for information
+how to update the version of the CLI.
+
+__NOTE__: You should use the latest shipped version of the iOS SDK, which is included with the latest version of Xcode.
+
+## Upgrading 4.x projects
+
+```
+cordova platform rm ios
+cordova platform add ios
+```
+
+
+## Upgrading 3.6.0 Projects to 4.0.0
+
+For non-CLI projects, run:
+
+```
+bin/update path/to/project
+```
+
+For CLI projects:
+
+1. Update the `cordova` CLI version. See [The Command-Line Interface](../../cli/index.html).
+
+2. Run `cordova platform update ios` in your existing projects.
+
+
+## Upgrading 3.3.0 Projects to 3.4.0
+
+For non-CLI projects, run:
+
+```
+bin/update path/to/project
+```
+
+For CLI projects:
+
+1. Update the `cordova` CLI version. See [The Command-Line Interface](../../cli/index.html).
+
+2. Run `cordova platform update ios`
+
+## Upgrading 3.2.0 Projects to 3.3.0
+
+For non-CLI projects, run:
+
+```
+bin/update path/to/project
+```
+
+For CLI projects:
+
+1. Update the `cordova` CLI version. See [The Command-Line Interface](../../cli/index.html).
+
+2. Run `cordova platform update ios`
+
+## Upgrading 3.1.0 Projects to 3.2.0
+
+For non-CLI projects, run:
+
+```
+bin/update path/to/project
+```
+
+For CLI projects:
+
+1. Update the `cordova` CLI version. See [The Command-Line Interface](../../cli/index.html).
+
+2. Run `cordova platform update ios`
+
+
+## Upgrading 3.0.0 Projects to 3.1.0
+
+For non-CLI projects, run:
+
+```
+bin/update path/to/project
+```
+
+For CLI projects:
+
+1. Update the `cordova` CLI version. See [The Command-Line Interface](../../cli/index.html).
+
+2. Run `cordova platform update ios`
+
+iOS 7 Issues:
+
+1. Remove `width=device-width, height=device-height` from the
+ `index.html` file's `viewport` `meta` tag. (See [the relevant
+ bug](https://issues.apache.org/jira/browse/CB-4323).)
+
+2. Update your media, media-capture and splashscreen core plugins for
+ iOS 7 support.
+
+Xcode 5 Issues:
+
+1. Update your Project Settings if Xcode 5 prompts you to do so (in the Issues Navigator).
+
+2. Update your __Compiler for C/C++/Objective-C__ setting, under the
+ __Build Settings__ tab, __Build Options__ section. Choose __Default
+ compiler (Apple LLVM 5.0)__.
+
+## Upgrade to the CLI (3.0.0) from 2.9.0
+
+1. Create a new Apache Cordova 3.0.0 project using the cordova CLI, as
+ described in [The Command-Line Interface](../../cli/index.html).
+
+2. Add your platforms to the cordova project, for example: `cordova
+ platform add ios`.
+
+3. Copy the contents of the project's `www` directory to the `www` directory
+ at the root of the cordova project you just created.
+
+4. Copy or overwrite any native assets from your original project
+ (`Resources`, etc.), making sure to add any
+ new files to the `.xcodeproj` project. The iOS project builds
+ inside the `platforms\ios` directory.
+
+5. Copy the `config.xml` into the `www` directory, and remove any plugin
+ definitions. Modify settings here instead of the platform directory.
+
+6. Use the cordova CLI tool to install any plugins you need. Note that
+ the CLI handles all core APIs as plugins, so they may need to be
+ added. Only 3.0.0 plugins are compatible with the CLI.
+
+7. Build and test.
+
+## Upgrading 2.9.0 Projects to 3.0.0
+
+1. Download and extract the Cordova 3.0.0 source to a permanent directory location on your hard drive, for example to `~/Documents/Cordova-3.0.0`.
+
+2. Quit Xcode if it is running.
+
+3. Using Terminal.app, navigate to the directory where you put the downloaded source above.
+
+4. Create a new project, as described in [iOS Shell Tool Guide](tools.html). You need the assets from this new project.
+
+5. Copy the `www/cordova.js` (note that it does not have a version suffix anymore, the version is in the file itself in the header) file from the new project into the `www` directory, and delete the `www/cordova.js` file.
+
+6. Update the Cordova script reference in the `www/index.html` file (and any other files that contain the script reference) to point to the new `cordova.js` file.
+
+7. Delete the `CordovaLib` directory, and copy the `CordovaLib` directory from the new project into your project's root directory.
+
+__NOTE__: Starting with Cordova 3.0.0, plugins are not pre-installed,
+and you need to use the `plugman` command-line utility to install them
+yourself. See [Using Plugman to Manage Plugins](../../../plugin_ref/plugman.html).
+
+## Upgrading 2.8.0 Projects to 2.9.0
+
+1. Download and extract the Cordova 2.9.0 source to a permanent directory location on your hard drive, for example to `~/Documents/Cordova-2.9.0`.
+
+2. Quit Xcode if it is running.
+
+3. Using Terminal.app, navigate to the directory where you put the downloaded source above.
+
+4. Create a new project, as described in [iOS Shell Tool Guide](tools.html). You need the assets from this new project.
+
+5. Copy the `www/cordova.js` (note that it does not have a version suffix anymore, the version is in the file itself in the header) file from the new project into the `www` directory, and delete the `www/cordova.js` file.
+
+6. Update the Cordova script reference in the `www/index.html` file (and any other files that contain the script reference) to point to the new `cordova.js` file.
+
+7. Delete the `CordovaLib` directory, and copy the `CordovaLib` directory from the new project into your project's root directory.
+
+## Upgrading 2.7.0 Projects to 2.8.0
+
+1. Download and extract the Cordova 2.8.0 source to a permanent directory location on your hard drive, for example to `~/Documents/Cordova-2.8.0`.
+
+2. Quit Xcode if it is running.
+
+3. Using Terminal.app, navigate to the directory where you put the downloaded source above.
+
+4. Create a new project, as described in [iOS Shell Tool Guide](tools.html). You need the assets from this new project.
+
+5. Copy the `www/cordova.js` (note that it does not have a version suffix anymore, the version is in the file itself in the header) file from the new project into the `www` directory, and delete the `www/cordova-2.7.0.js` file.
+
+6. Update the Cordova script reference in the `www/index.html` file (and any other files that contain the script reference) to point to the new `cordova.js` file.
+
+7. Update any `<plugin>` tags in the `config.xml` file to `<feature>`
+ tags. Note that existing `<plugin>` tags still work, but are
+ deprecated. You can copy this information in the `config.xml` file
+ for a new project. For example:
+
+ ```xml
+ <plugins>
+ <plugin name="LocalStorage" value="CDVLocalStorage" />
+ <!-- other plugins -->
+ </plugins>
+
+ <!-- change to: (note that a <feature> tag is on the same level as <plugins> -->
+ <feature name="LocalStorage">
+ <param name="ios-package" value="CDVLocalStorage" />
+ </feature>
+ <!-- other <feature> tags -->
+ ```
+
+8. Delete the `CordovaLib` directory, and copy the `CordovaLib` directory from the new project into your project's root directory.
+
+9. Add these two frameworks to your project:
+
+ ```
+ OpenAL
+ ImageIO
+ ```
+
+10. Update your project's target __Build Settings__. Under __Linking → Other Linker Flags__, edit __"-Obj-C"__ to be __"-ObjC"__.
+
+11. Update your project's target __Build Settings__. Under __Linking → Other Linker Flags__, change __"-all\_load"__ to be `-force\_load ${BUILT\_PRODUCTS\_DIR}/libCordova.a`. You would only need to do this if you have the problem defined in [this issue.](https://issues.apache.org/jira/browse/CB-3458).
+
+## Upgrading 2.6.0 Projects to 2.7.0
+
+1. Download and extract the Cordova 2.7.0 source to a permanent directory location on your hard drive, for example to `~/Documents/Cordova-2.7.0`.
+
+2. Quit Xcode if it is running.
+
+3. Using Terminal.app, navigate to the directory where you put the downloaded source above.
+
+4. Create a new project, as described in [iOS Shell Tool Guide](tools.html). you need the assets from this new project.
+
+5. Copy the `www/cordova-2.7.0.js` file from the new project into the `www` directory, and delete the `www/cordova-2.6.0.js` file.
+
+6. Update the Cordova script reference in the `www/index.html` file (and any other files that contain the script reference) to point to the new `cordova-2.7.0.js` file.
+
+7. Update (or replace, if you never changed the file) the `AppDelegate.m` file according to the one from the new project (see [this diff](https://git-wip-us.apache.org/repos/asf?p=cordova-ios.git;a=blobdiff;f=bin/templates/project/__TESTING__/Classes/AppDelegate.m;h=5c05ac80e056753c0e8736f887ba9f28d5b0774c;hp=623ad8ec3c46f656ea18c6c3a190d650dd64e479;hb=c6e71147386d4ad94b07428952d1aae0a9cbf3f5;hpb=c017fda8af00375a453cf27cfc488647972e9a23)).
+
+8. In the `config.xml` file, [remove this line](https://git-wip-us.apache.org/repos/asf?p=cordova-ios.git;a=blobdiff;f=bin/templates/project/__TESTING__/config.xml;h=537705d76a5ef6bc5e57a8ebfcab78c02bb4110b;hp=8889726d9a8f8c530fe1371c56d858c34552992a;hb=064239b7b5fa9a867144cf1ee8b2fb798ce1f988;hpb=c9f233250d4b800f3412eeded811daaafb17b2cc).
+
+9. Delete the `CordovaLib` directory, and copy the `CordovaLib` directory from the new project into your project's root directory.
+
+## Upgrading 2.5.0 Projects to 2.6.0
+
+1. Download and extract the Cordova 2.6.0 source to a permanent directory location on your hard drive, for example to `~/Documents/Cordova-2.6.0`.
+
+2. Quit Xcode if it is running.
+
+3. Using Terminal.app, navigate to the directory where you put the downloaded source above.
+
+4. Create a new project, as described in [iOS Shell Tool Guide](tools.html). You need the assets from this new project.
+
+5. Copy the project's `www/cordova-2.6.0.js` file into the `www` directory, and delete the `www/cordova-2.5.0.js` file.
+
+6. Update the Cordova script reference in the `www/index.html` file (along with any other files that reference the script) to refer to the new `cordova-2.6.0.js` file.
+
+7. Update (or replace, if you never changed the file) the `AppDelegate.m` file according to the one from the new project (see [this diff](https://git-wip-us.apache.org/repos/asf?p=cordova-ios.git;a=blobdiff;f=bin/templates/project/__TESTING__/Classes/AppDelegate.m;h=124a56bb4f361e95616f44d6d6f5a96ffa439b60;hp=318f79326176be8f16ebc93bad85dd745f4205b6;hb=a28c7712810a63396e9f32fa4eb94fe3f8b93985;hpb=36acdf55e4cab52802d73764c8a4b5b42cf18ef9)).
+
+8. In the `config.xml` file, [add this new line](https://git-wip-us.apache.org/repos/asf?p=cordova-ios.git;a=blobdiff;f=bin/templates/project/__TESTING__/config.xml;h=1555b5e81de326a07efe0bccaa5f5e2326b07a9a;hp=0652d60f8d35ac13c825c572dca6ed01fea4a540;hb=95f16a6dc252db0299b8e2bb53797995b1e39aa1;hpb=a2de90b8f5f5f68bd9520bcbbb9afa3ac409b96d).
+
+9. In the `config.xml` file, [add this new line](https://git-wip-us.apache.org/repos/asf?p=cordova-ios.git;a=blobdiff;f=bin/templates/project/__TESTING__/config.xml;h=d307827b7e67301171a913417fb10003d43ce39d;hp=04260aa9786d6d74ab20a07c86d7e8b34e31968c;hb=97b89edfae3527828c0ca6bb2f6d58d9ded95188;hpb=942d33c8e7174a5766029ea1232ba2e0df745c3f).
+
+10. In the `config.xml` file, [UIWebViewBounce has been changed to DisallowOverscroll, and default values are different](https://git-wip-us.apache.org/repos/asf?p=cordova-ios.git;a=blobdiff;f=bin/templates/project/__TESTING__/config.xml;h=8889726d9a8f8c530fe1371c56d858c34552992a;hp=d307827b7e67301171a913417fb10003d43ce39d;hb=57982de638a4dce6ae130a26662591741b065f00;hpb=ec411f18309d577b4debefd9a2f085ba719701d5).
+
+10. In the `config.xml` file, the `EnableLocation` preference has been deprecated.
+
+11. Delete the `CordovaLib` directory, and copy the `CordovaLib` directory from the new project into your project's root directory.
+
+## Upgrading 2.4.0 Projects to 2.5.0
+
+1. Download and extract the Cordova 2.5.0 source to a permanent directory location on your hard drive, for example to `~/Documents/Cordova-2.5.0`.
+
+2. Quit Xcode if it is running.
+
+3. Using Terminal.app, navigate to the directory where you put the downloaded source above.
+
+4. Create a new project, as described in [iOS Shell Tool Guide](tools.html). You need the assets from this new project.
+
+5. Copy the `www/cordova-2.5.0.js` file from the new project into the `www` directory and delete the `www/cordova-2.4.0.js` file.
+
+6. Update the Cordova script reference in the `www/index.html` file (and any other files that contain the script reference) to point to the new `cordova-2.5.0.js` file.
+
+7. Update (or replace, if you never changed the file) the `AppDelegate.m` file according to the one from the new project (see [this diff](https://git-wip-us.apache.org/repos/asf?p=cordova-ios.git;a=blobdiff;f=bin/templates/project/__TESTING__/Classes/AppDelegate.m;h=318f79326176be8f16ebc93bad85dd745f4205b6;hp=6dc7bfc84f0ecede4cc43d2a3256ef7c5383b9fe;hb=4001ae13fcb1fcbe73168327630fbc0ce44703d0;hpb=299a324e8c30065fc4511c1fe59c6515d4842f09)).
+
+8. In the `config.xml` file, [add these new lines](https://git-wip-us.apache.org/repos/asf?p=cordova-ios.git;a=blobdiff;f=bin/templates/project/__TESTING__/config.xml;h=903944c4b1e58575295c820e154be2f5f09e6314;hp=721c734120b13004a4a543ee25f4287e541f34be;hb=ae467249b4a256bd31ee89aea7a06f4f2316b8ac;hpb=9e39f7ef8096fb15b38121ab0e245a3a958d9cbb).
+
+9. In the `config.xml` file, [edit the root element, change it from cordova to widget](https://git-wip-us.apache.org/repos/asf?p=cordova-ios.git;a=blobdiff;f=bin/templates/project/__TESTING__/config.xml;h=64e71636f5dd79fa0978a97b9ff5aa3860a493f5;hp=d8579352dfb21c14e5748e09b2cf3f4396450163;hb=0e711f8d09377a7ac10ff6be4ec17d22cdbee88d;hpb=57c3c082ed9be41c0588d0d63a1d2bfcd2ed878c).
+
+10. In the `config.xml` file, [remove the OpenAllWhitelistURLsInWebView preference](https://git-wip-us.apache.org/repos/asf?p=cordova-ios.git;a=blobdiff;f=bin/templates/project/__TESTING__/config.xml;h=721c734120b13004a4a543ee25f4287e541f34be;hp=7d67508b70914aa921a16e79f79c00512502a8b6;hb=187bf21b308551bfb4b98b1a5e11edf04f699791;hpb=03b8854bdf039bcefbe0212db937abd81ac675e4).
+
+11. Delete the `cordova` directory, and copy the `cordova` directory from the new project into your project's root directory. In 2.5.0, this has updated scripts.
+
+12. Delete the `CordovaLib` directory, and copy the `CordovaLib` directory from the new project into your project's root directory.
+
+## Upgrading 2.3.0 Projects to 2.4.0
+
+1. Download and extract the Cordova 2.4.0 source to a permanent directory location on your hard drive, for example to `~/Documents/Cordova-2.4.0`.
+
+2. Quit Xcode if it is running.
+
+3. Using Terminal.app, navigate to the directory where you put the downloaded source above.
+
+4. Create a new project, as described in [iOS Shell Tool Guide](tools.html). You need the assets from this new project.
+
+5. Copy the `www/cordova-2.4.0.js` file from the new project into the `www` directory, and delete the `www/cordova-2.3.0.js` file.
+
+6. Update the Cordova script reference in the `www/index.html` file (and any other files that contain the script reference) to point to the new `cordova-2.4.0.js` file.
+
+7. Update (or replace, if you never changed the files) the `MainViewController.m` file according to the one from the new project (see [this diff](https://git-wip-us.apache.org/repos/asf?p=cordova-ios.git;a=blobdiff;f=bin/templates/project/__TESTING__/Classes/MainViewController.m;h=5f9eeac15c2437cd02a6eb5835b48374e9b94100;hp=89da1082d06ba5e5d0dffc5b2e75a3a06d5c2aa6;hb=b4a2e4ae0445ba7aec788090dce9b822d67edfd8;hpb=a484850f4610e73c7b20cd429a7794ba829ec997)).
+
+8. Update (or replace, if you never changed the file) the `AppDelegate.m` file according to the one from the new project (see [this diff](https://git-wip-us.apache.org/repos/asf?p=cordova-ios.git;a=blobdiff;f=bin/templates/project/__TESTING__/Classes/AppDelegate.m;h=6dc7bfc84f0ecede4cc43d2a3256ef7c5383b9fe;hp=1ca3dafeb354c4442b7e149da4f281675aa6b740;hb=6749c17640c5fed8a7d3a0b9cca204b89a855baa;hpb=deabeeb6fcb35bac9360b053c8bf902b45e6de4d)).
+
+9. In the `config.xml` file, [add this new line](https://git-wip-us.apache.org/repos/asf?p=cordova-ios.git;a=blobdiff;f=bin/templates/project/__TESTING__/config.xml;h=7d67508b70914aa921a16e79f79c00512502a8b6;hp=337d38da6f40c7432b0bce05aa3281d797eec40a;hb=6749c17640c5fed8a7d3a0b9cca204b89a855baa;hpb=deabeeb6fcb35bac9360b053c8bf902b45e6de4d).
+
+10. Delete the `cordova` directory, and copy the `cordova` directory from the new project into your project's root directory. In 2.4.0, this has fixed scripts.
+
+11. Delete the `CordovaLib` directory, and copy the `CordovaLib` directory from the new project into your project's root directory.
+
+12. Add AssetsLibrary.framework as a resource to your project. (See [Apple's documentation](https://developer.apple.com/library/ios/#recipes/xcode_help-project_editor/Articles/AddingaLibrarytoaTarget.html) for instructions on how to do so.).
+
+## Upgrading 2.2.0 Projects to 2.3.0
+
+1. Download and extract the Cordova 2.3.0 source to a permanent directory location on your hard drive, for example to `~/Documents/Cordova-2.3.0`.
+
+2. Quit Xcode if it is running.
+
+3. Using Terminal.app, navigate to the directory where you put the downloaded source above.
+
+4. Create a new project, as described in [iOS Shell Tool Guide](tools.html). You need the assets from this new project.
+
+5. Copy the `www/cordova-2.3.0.js` file from the new project into the `www` directory, and delete the `www/cordova-2.2.0.js` file.
+
+6. Update the Cordova script reference in the `www/index.html` file (and any other files that contain the script reference) to point to the new `cordova-2.3.0.js` file.
+
+7. Update (or replace, if you never changed the file) the `MainViewController.m` according to the one from the new project.
+
+8. Delete the `cordova` directory, and copy the `cordova` directory from the new project into your project's root directory. In 2.3.0, this has new scripts.
+
+9. Delete the `CordovaLib` directory, and copy the `CordovaLib` directory from the new project into your project's root directory.
+
+10. Convert the `Cordova.plist` file to `config.xml`, by running the script `bin/cordova\_plist\_to\_config\_xml` on your project file.
+
+11. Add the InAppBrowser plugin to the `config.xml`, by adding this tag under `<cordova><plugins>`:
+
+ ```xml
+ <plugin name="InAppBrowser" value="CDVInAppBrowser" />
+ ```
+
+12. Note that Objective-C plugins are _not_ whitelisted anymore. To whitelist your connections with the app whitelist, you need to set the `User-Agent` header of the connection to the same user-agent as the main Cordova WebView.
+You can get this by accessing the `userAgent` property off the main view-controller. The main view-controller (`CDVViewController`) also has a `URLisAllowed` method for you to check whether a URL passes the whitelist.
+
+13. Device API changes:
+ - For iOS, device.platform used to return `iPhone`, `iPad` or `iPod Touch`; now it returns (correctly) `iOS`.
+ - For iOS, device.name (now deprecated for all platforms) used to return the name of the user’s device (e.g. ‘Shazron’s iPhone 5′); now it returns what device.platform used to return: `iPhone`, `iPad` or `iPod Touch`.
+ - For all platforms, there is a new property called device.model; this returns the specific device model, e.g. `iPad2,5` (for other platforms, this returns what device.name used to return).
+
+## Upgrading 2.1.0 Projects to 2.2.0
+
+1. Download and extract the Cordova 2.2.0 source to a permanent directory location on your hard drive, for example to `~/Documents/Cordova-2.2.0`.
+
+2. Quit Xcode if it is running.
+
+3. Using Terminal.app, navigate to the directory where you put the downloaded source above.
+
+4. Create a new project, as described in [iOS Shell Tool Guide](tools.html). You need the assets from this new project.
+
+5. Copy the `www/cordova-2.2.0.js` file from the new project into the `www` directory, and delete the `www/cordova-2.1.0.js` file.
+
+6. Update the Cordova script reference in the `www/index.html` file (and any other files that contain the script reference) to point to the new `cordova-2.2.0.js` file.
+
+7. Update (or replace, if you never changed the file) the `MainViewController.m` according to the one from the new project:
+ - Updated → viewWillAppear
+
+8. Copy the `cordova` directory from the new project into your project's root directory. In 2.2.0, this has an updated 'emulate' script.
+
+9. Next, update the `CordovaLib` sub-project reference. Beginning with Cordova 2.1.0, we are not using the CORDOVALIB Xcode variable anymore when referencing where `CordovaLib` resides, the reference is an absolute file reference now.
+ 1. Launch Terminal.app
+ 2. Go to the location where you installed Cordova (see Step 1), in the `bin` subdirectory
+ 3. Run the script below where the first parameter is the path to your project's `.xcodeproj` file:
+
+ ```
+ update_cordova_subproject path/to/your/project/xcodeproj
+ ```
+
+__NOTE__: In 2.2.0, the `bin/create` script copy in the `CordovaLib` sub-project into your project. To have the same kind of setup, just copy in the right `CordovaLib` into your project directory, and update the `CordovaLib` sub-project location (relative to the project) in the Xcode File Inspector.
+
+## Upgrading 2.0.0 Projects to 2.1.0
+
+With Cordova 2.1.0, `CordovaLib` has been upgraded to use __Automatic Reference Counting (ARC)__. You don't need to upgrade to __ARC__ to use CordovaLib, but if you want to upgrade your project to use __ARC__, please use the Xcode migration wizard from the menu: __Edit → Refactor → Convert to Objective-C ARC...__, de-select libCordova.a, then run the wizard to completion.
+
+1. Download and extract the Cordova 2.1.0 source to a permanent directory location on your hard drive, for example to `~/Documents/Cordova-2.1.0`.
+
+2. Quit Xcode if it is running.
+
+3. Using Terminal.app, navigate to the directory where you put the downloaded source above.
+
+5. Create a new project, as described in [iOS Shell Tool Guide](tools.html). You need the assets from this new project.
+
+6. Copy the `www/cordova-2.1.0.js` file from the new project into the `www` directory, and delete the `www/cordova-2.0.0.js` file.
+
+7. Update the Cordova script reference in the `www/index.html` file (and any other files that contain the script reference) to point to the new `cordova-2.1.0.js` file.
+
+8. Update (or replace, if you never changed the file) the `AppDelegate.m` according to the one from the new project:
+ - Edited → application:didFinishLaunchingWithOptions:
+ - Added → application:supportedInterfaceOrientationsForWindow:
+
+9. Update (or replace, if you never changed the file) the `MainViewController.m` according to the one from the new project:
+ - Added → viewWillAppear
+
+10. Copy the `cordova` directory from the new project into your project's root directory. In 2.1.0, this has the updated scripts to support paths with spaces.
+
+11. Remove the `VERSION` file reference from your project (_not_ the one in `CordovaLib`).
+
+12. Next, update the `CordovaLib` sub-project reference. Beginning with Cordova 2.1.0, we are not using the CORDOVALIB Xcode variable anymore when referencing where `CordovaLib` resides, the reference is an absolute file reference now.
+ 1. Launch Terminal.app
+ 2. Go to the location where you installed Cordova (see Step 1), in the `bin` subdirectory
+ 3. Run the script below where the first parameter is the path to your project's `.xcodeproj` file:
+
+ ```
+ update_cordova_subproject path/to/your/project/xcodeproj
+ ```
+
+## Upgrading 1.9.0 Projects to 2.0.0
+
+1. Install Cordova 2.0.0.
+
+2. Create a new project, as described in [iOS Shell Tool Guide](tools.html). You need the assets from this new project.
+
+3. Copy the `www/cordova-2.0.0.js` file from the new project into the `www` directory, and delete the `www/cordova-1.9.0.js` file.
+
+4. Update the Cordova script reference in the `www/index.html` file (and any other files that contain the script reference) to point to the new `cordova-2.0.0.js` file.
+
+5. Copy the `cordova` directory from the new project into your project's root directory (if you want the project command-line tools).
+
+6. Add a new entry under `Plugins` in the `Cordova.plist` file, under
+ the __Supporting Files__ group. The key is `Device` and the value
+ is `CDVDevice`.
+
+7. Remove `Cordova.framework`.
+
+8. Remove `verify.sh` from the __Supporting Files__ group.
+
+9. Select the project icon in the Project Navigator, select your project __Target__, then select the __Build Settings__ tab.
+
+10. Search for __Preprocessor Macros__, then remove all __CORDOVA_FRAMEWORK=1__ values.
+
+11. Locate the `CordovaLib` directory that was installed in your hard-drive under your home folder's `Documents` subdirectory.
+
+12. Locate the `CordovaLib.xcodeproj` file in the `CordovaLib` directory, then drag and drop the file into your project. It should appear as a sub-project.
+
+13. Build your project, you should get some errors relating to `#import` directives.
+
+14. For the `#import` errors, change any quote-based imports in this style:
+
+ ```objective_c
+ #import "CDV.h"
+ ```
+
+ to this brackets-based style:
+
+ ```objective_c
+ #import <Cordova/CDV.h>
+ ```
+
+ and remove any `#ifdef` wrappers around any Cordova imports, they are not needed anymore (the imports are now unified)
+
+15. Build your project again, and it should not have any `#import` errors.
+
+16. Select the __project icon__ in the Project Navigator, select your project __Target__, then select the __Build Phases__ tab.
+
+17. Expand the __Target Dependencies__ phase, then select the __+__ button.
+
+18. Select the `CordovaLib` target, then select the __Add__ button.
+
+19. Expand the first __Link Binary with Libraries__ phase (it should already contain a bunch of frameworks), then select the __+__ button.
+
+20. Select the `libCordova.a` static library, then select the __Add__ button.
+
+21. Delete the __Run Script__ phase.
+
+22. Select the __project icon__ in the Project Navigator, select your project __Target__, then select the __Build Settings__ tab.
+
+23. Search for __Other Linker Flags__, and add the values __-force_load__ and __-Obj-C__.
+
+24. Expand the `CordovaLib` sub-project.
+
+25. Locate the `VERSION` file, drag it into your main project (we want to create a link to it, not a copy).
+
+26. Select the __Create groups for any added folders__ radio button, then select the __Finish__ button.
+
+27. Select the `VERSION` file that you just dragged in a previous step.
+
+28. Type the __Option-Command-1__ key combination to show the __File Inspector__ (or menuitem __View → Utilities → Show File Inspector__).
+
+29. Choose __Relative to CORDOVALIB__ in the __File Inspector__ for the drop-down menu for __Location__.
+
+30. Set the Xcode preference __Xcode Preferences → Locations → Derived Data → Advanced...__ to __Unique__, so that the unified headers can be found.
+
+31. Select the __project icon__ in the Project Navigator, select your __Target__, then select the __Build Settings__ tab.
+
+32. Search for __Header Search Paths__. For that setting, append these three values, including quotes:
+
+ ```bash
+ "$(TARGET_BUILD_DIR)/usr/local/lib/include"
+
+ "$(OBJROOT)/UninstalledProducts/include"
+
+ "$(BUILT_PRODUCTS_DIR)"
+ ```
+
+33. Search for __Other Linker Flags__. For that setting, append this value:
+
+ ```bash
+ -weak_framework CoreFoundation
+ ```
+
+34. Build your project, it should compile and link with __no issues__.
+
+35. Select your project from the __Scheme__ drop-down, and then select __iPhone 5.1 Simulator__.
+
+36. Select the __Run__ button.
+
+__NOTE__: If your project is not working as expected in the Simulator, please take a note of any errors in the console log in Xcode for clues.
+
+## Upgrading 1.8.x Projects to 1.9.0
+
+1. Install Cordova 1.9.0.
+
+2. Create a new project. You will need some of the assets from this new project.
+
+3. Copy the `www/cordova-1.9.0.js` file from the new project into the `www` directory, and delete the `www/cordova-1.8.x.js` file.
+
+4. Update the Cordova script reference in the `www/index.html` file (and any other files that contain the script reference) to point to the new `cordova-1.9.0.js` file.
+
+__NOTE__: 1.9.0 supports the new `BackupWebStorage` boolean `Cordova.plist` setting. It's enabled by default, so set it to
+`false` to disable it, especially on iOS 6. See [Release Notes: Safari and UIKit Section](https://developer.apple.com/library/prerelease/ios/#releasenotes/General/RN-iOSSDK-6_0/_index.html)
+
+## Upgrading 1.7.0 Projects to 1.8.x
+
+1. Install Cordova 1.8.0.
+
+2. Create a new project. You will need some of the assets from this new project.
+
+3. Copy the `www/cordova-1.8.0.js` file from the new project into the `www` directory, and delete the `www/cordova-1.7.x.js` file.
+
+4. Update the Cordova script reference in the `www/index.html` file (and any other files that contain the script reference) to point to the new `cordova-1.8.0.js` file.
+
+If you intend on using the Capture API, you will need the new __iPad retina-display__ assets:
+
+1. Copy the `Resources/Capture.bundle` item from the new project into your project directory, over-writing your existing `Resources/Capture.bundle` item.
+
+2. In your project, select the `Capture.bundle` item into your Project Navigator in Xcode, type the __Delete__ key, then select __Remove Reference__ from the resulting dialog.
+
+3. Drag the new `Capture.bundle` from Step 1 above into your Project Navigator in Xcode, then select the __Create groups for any added folders__ radio button.
+
+## Upgrading 1.6.x Projects to 1.7.0
+
+1. Install Cordova 1.7.0.
+
+2. Create a new project. You will need some of the assets from this new project.
+
+3. Copy the `www/cordova-1.7.0.js` file from the new project into the `www` directory, and delete the `www/cordova-1.6.0.js` file.
+
+4. Update the Cordova script reference in the `www/index.html` file (and any other files that contain the script reference) to point to the new `cordova-1.7.0.js` file.
+
+## Upgrading 1.5.0 Projects to 1.6.x
+
+1. Install Cordova 1.6.1.
+
+2. Make a backup of `AppDelegate.m`, `AppDelegate.h`, `MainViewController.m`, `MainViewController.h`, and `Cordova.plist` in your project.
+
+3. Create a new project. You will need some of the assets from this new project.
+
+4. Copy these files from the new project into your 1.5.0-based project directory on disk, replacing any old files (backup your files first from step 2 above):
+
+ ```
+ AppDelegate.h
+ AppDelegate.m
+ MainViewController.h
+ MainViewController.m
+ Cordova.plist
+ ```
+
+5. Add all the new `MainViewController` and `AppDelegate` files into your Xcode project.
+
+6. Copy the `www/cordova-1.6.1.js` file from the new project into the `www` directory, and delete the `www/cordova-1.5.0.js` file.
+
+7. Update the Cordova script reference in the `www/index.html` file (and any other files that contain the script reference) to point to the new `cordova-1.6.1.js` file.
+
+8. Add the new `Cordova.plist` file into your project. This is
+ necessary because the core plugin service names must change to
+ match the ones from Android and BlackBerry, for a unified Cordova
+ JavaScript file (`cordova-js`).
+
+9. Integrate any settings, __Plugins__ and __ExternalHosts__ entries that you had in your __backed-up Cordova.plist__ into the new `Cordova.plist`.
+
+10. Integrate any project-specific code that you have in your backed-up `AppDelegate.h` and `AppDelegate.m` into the new `AppDelegate` files. Any `UIWebViewDelegate` or `CDVCommandDelegate` code in `AppDelegate.m` needs to go into `MainViewController.m` now (see commented-out sections in that file).
+
+11. Integrate any project-specific code that you have in your backed-up `MainViewController.h` and `MainViewController.m` into the new MainViewController files.
+
+12. Click on the project icon in the Project Navigator, select your __Project__, then select the __Build Settings__ tab.
+
+13. Enter __Compiler for C/C++/Objective-C__ in the search field.
+
+14. Select the __Apple LLVM Compiler 3.1__ value.
+
+## Upgrading 1.4.x Projects to 1.5.0
+
+1. Install Cordova 1.5.0.
+
+2. Create a new project and run it once. You will need some of the assets from this new project.
+
+3. Copy the `www/cordova-1.5.0.js` file from the new project into the `www` directory, and delete the `www/phonegap-1.4.x.js` file.
+
+4. Update the Cordova script reference in the `www/index.html` file (and any other files that contain the script reference) to point to the new Cordova `cordova-1.5.0.js` file.
+
+5. Find `PhoneGap.framework` in your Project Navigator, select it.
+
+6. Type the __Delete__ key and delete the `PhoneGap.framework` reference in the Project Navigator.
+
+7. Type the __Option-Command-A__ key combination, which should drop down a sheet to add files to your project (the __Add Files...__ sheet). Make sure the __Created groups for any added folders__ radio button is selected.
+
+8. Type the __Shift-Command-G__ key combination, which should drop down another sheet for you to go to a folder (the __Go to the folder:__ sheet).
+
+9. Enter `/Users/Shared/Cordova/Frameworks/Cordova.framework` in the __Go to the folder:__ sheet and then press the __Go__ button.
+
+10. Press the __Add__ button in the __Add Files...__ sheet.
+
+11. Select `Cordova.framework` in the Project Navigator.
+
+12. Type the __Option-Command-1__ key combination to show the __File Inspector__.
+
+13. Choose __Absolute Path__ in the __File Inspector__ for the drop-down menu for __Location__.
+
+14. Type the __Option-Command-A__ key combination, which should drop down a sheet to add files to your project (the __Add Files...__ sheet). Make sure the __Created groups for any added folders__ radio button is selected.
+
+15. Type the __Shift-Command-G__ key combination, which should drop down another sheet for you to go to a folder (the __Go to the folder:__ sheet).
+
+16. Enter `~/Documents/CordovaLib/Classes/deprecated` in the __Go to the folder:__ sheet and then press the __Go__ button.
+
+17. Press the __Add__ button in the __Add Files...__ sheet.
+
+18. In the `AppDelegate.h`, `AppDelegate.m`, and `MainViewController.h` files, replace the whole `#ifdef PHONEGAP_FRAMEWORK` block with:
+
+ ```objective_c
+ #import "CDVDeprecated.h"
+ ```
+
+19. Click on the __project icon__ in the Project Navigator, select your __Target__, then select the __Build Settings__ tab.
+
+20. Search for __Framework Search Paths__.
+
+21. Replace the existing value with `/Users/Shared/Cordova/Frameworks`.
+
+22. Search for __Preprocessor Macros__.
+
+23. For the first (combined) value, replace the value with __CORDOVA_FRAMEWORK=YES__.
+
+24. Select the __Build Phases__ tab.
+
+25. Expand __Run Script__.
+
+26. Replace any occurrences of __PhoneGap__ with __Cordova__.
+
+27. Find the `PhoneGap.plist` file in the Project Navigator, and click on the filename once to enter name edit mode.
+
+28. Rename `PhoneGap.plist` to `Cordova.plist`.
+
+29. Right-click on `Cordova.plist` and choose __Open As → Source Code__.
+
+30. Press __Option-Command-F__, choose __Replace__ from the drop-down on the top left of the Source window.
+
+31. Enter `com.phonegap` for the Find string, and `org.apache.cordova`
+ for the Replace string, then press the __Replace All__ button.
+
+32. Enter __PG__ for the Find string, and __CDV__ for the Replace
+ string, then press the __Replace All__ button.
+
+33. Press __Command-B__ to build. You still have deprecations
+ that you can get rid of in the future (see `CDVDeprecated.h`. For
+ example, replace classes in your code that use PG* to CDV*).
+
+## Upgrading 1.4.0 Projects to 1.4.1
+
+1. Install Cordova 1.4.1.
+
+2. Make a backup of `MainViewController.m`.
+
+3. Create a new project. You will need some of the assets from this new project.
+
+4. Copy the `MainViewController.m` file from the new project into your 1.4.0-based project directory on disk, replacing the old file (backup your files first from step 2 above).
+
+5. Add the `MainViewController.m` file into your Xcode project.
+
+6. Integrate any project-specific code that you have in your backed-up `MainViewController.m` into the new file.
+
+7. Updating the `phonegap-1.4.0.js` file is optional, nothing has changed in the JavaScript between 1.4.0 and 1.4.1.
+
+## Upgrading 1.3.0 Projects to 1.4.0
+
+1. Install Cordova 1.4.0.
+
+2. Make a backup of `AppDelegate.m` and `AppDelegate.h` in your project.
+
+3. Create a new project. You will need some of the assets from this new project.
+
+4. Copy these files from the new project into your 1.3.0-based project directory on disk, replacing any old files (backup your files first from step 2 above):
+
+ ```
+ AppDelegate.h
+ AppDelegate.m
+ MainViewController.h
+ MainViewController.m
+ MainViewController.xib
+ ```
+
+5. Add all the `MainViewController` files into your Xcode project.
+
+6. Copy the `www/phonegap-1.4.0.js` file from the new project into the `www` directory, and delete the `www/phonegap-1.3.0.js` file.
+
+7. Update the Cordova script reference in the `www/index.html` file (and any other files that contain the script reference) to point to the new `phonegap-1.4.0.js` file.
+
+8. Add a new entry under `Plugins` in the `PhoneGap.plist` file. The
+ key is `com.phonegap.battery` and the value is `PGBattery`.
+
+9. Integrate any project-specific code that you have in your backed-up `AppDelegate.h` and `AppDelegate.m` into the new AppDelegate files.
+
+## Upgrading 1.2.0 Projects to 1.3.0
+
+1. Install Cordova 1.3.0.
+
+2. Make a backup of `AppDelegate.m` and `AppDelegate.h` in your project.
+
+3. Create a new project. You will need some of the assets from this new project.
+
+4. Copy these files from the new project into your 1.2.0-based project directory on disk, replacing any old files (backup your files first from step 2 above):
+
+ ```
+ AppDelegate.h
+ AppDelegate.m
+ MainViewController.h
+ MainViewController.m
+ MainViewController.xib
+ ```
+
+5. Add all the `MainViewController` files into your Xcode project.
+
+6. Copy the `www/phonegap-1.3.0.js` file from the new project into the `www` directory, and delete the `www/phonegap-1.2.0.js` file.
+
+7. Update the Cordova script reference in the `www/index.html` file (and any other files that contain the script reference) to point to the new `phonegap-1.3.0.js` file.
+
+8. Add a new entry under `Plugins` in the `PhoneGap.plist` file. The
+ key is `com.phonegap.battery` and the value is `PGBattery`.
+
+9. Integrate any project-specific code that you have in your backed-up `AppDelegate.h` and `AppDelegate.m` into the new AppDelegate files.
+
+## Upgrading 1.1.0 Projects to 1.2.0
+
+1. Install Cordova 1.2.0.
+
+2. Make a backup of `AppDelegate.m` and `AppDelegate.h` in your project.
+
+3. Create a new project. You will need some of the assets from this new project.
+
+4. Copy these files from the new project into your 1.1.0-based project directory on disk, replacing any old files (backup your files first from step 2 above):
+
+ ```
+ AppDelegate.h
+ AppDelegate.m
+ MainViewController.h
+ MainViewController.m
+ MainViewController.xib
+ ```
+
+5. Add all the `MainViewController` files into your Xcode project.
+
+6. Copy the `www/phonegap-1.2.0.js` file from the new project into the `www` directory, and delete the `www/phonegap-1.1.0.js` file.
+
+7. Update the Cordova script reference in the `www/index.html` file (and any other files that contain the script reference) to point to the new `phonegap-1.2.0.js` file.
+
+8. Add a new entry under `Plugins` in the `PhoneGap.plist` file. The
+ key is `com.phonegap.battery` and the value is `PGBattery`.
+
+9. Integrate any project-specific code that you have in your backed-up `AppDelegate.h` and `AppDelegate.m` into the new AppDelegate files.
+
+## Upgrading 1.0.0 Projects to 1.1.0
+
+1. Install Cordova 1.1.0.
+
+2. Make a backup of `AppDelegate.m` and `AppDelegate.h` in your project.
+
+3. Create a new project. You will need some of the assets from this new project.
+
+4. Copy these files from the new project into your 1.0.0-based project directory on disk, replacing any old files (backup your files first from step 2 above):
+
+ ```
+ AppDelegate.h
+ AppDelegate.m
+ MainViewController.h
+ MainViewController.m
+ MainViewController.xib
+ ```
+
+5. Add all the `MainViewController` files into your Xcode project.
+
+6. Copy the `www/phonegap-1.1.0.js` file from the new project into the `www` directory, and delete the `www/phonegap-1.0.0.js` file.
+
+7. Update the Cordova script reference in the `www/index.html` file (and any other files that contain the script reference) to point to the new `phonegap-1.1.0.js` file.
+
+8. Add a new entry under `Plugins` in the `PhoneGap.plist` file. The
+ key is `com.phonegap.battery` and the value is `PGBattery`.
+
+9. Integrate any project-specific code that you have in your backed-up `AppDelegate.h` and `AppDelegate.m` into the new AppDelegate files.
+
+## Upgrading 0.9.6 Projects to 1.0.0
+
+1. Install Cordova 1.0.0.
+
+2. Make a backup of `AppDelegate.m` and `AppDelegate.h` in your project.
+
+3. Create a new project. You will need some of the assets from this new project.
+
+4. Copy these files from the new project into your 0.9.6-based project directory on disk, replacing any old files (backup your files first from step 2 above):
+
+ ```
+ AppDelegate.h
+ AppDelegate.m
+ MainViewController.h
+ MainViewController.m
+ MainViewController.xib
+ ```
+
+5. Add all the `MainViewController` files into your Xcode project.
+
+6. Copy the `www/phonegap-1.0.0.js` file from the new project into the `www` directory, and delete the `www/phonegap-0.9.6.js` file.
+
+7. Update the Cordova script reference in the `www/index.html` file (and any other files that contain the script reference) to point to the new `phonegap-1.0.0.js` file.
+
+8. Add a new entry under `Plugins` in the `PhoneGap.plist` file. The
+ key is `com.phonegap.battery` and the value is `PGBattery`.
+
+9. Integrate any project-specific code that you have in your backed-up `AppDelegate.h` and `AppDelegate.m` into the new AppDelegate files.
diff --git a/www/docs/en/11.x/guide/platforms/ios/webview.md b/www/docs/en/11.x/guide/platforms/ios/webview.md
new file mode 100644
index 0000000..2ba6a57
--- /dev/null
+++ b/www/docs/en/11.x/guide/platforms/ios/webview.md
@@ -0,0 +1,224 @@
+---
+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: iOS WebViews
+---
+
+# iOS WebViews
+
+This guide shows how to embed a Cordova-enabled WebView component
+within a larger iOS application. For details on how these components
+can communicate with each other, see Application Plugins.
+
+Support for WebViews for iOS started with Cordova version 1.4, using a
+`Cleaver` component for which the Xcode template serves as a reference
+implementation. Cordova 2.0 and later versions only support the
+subproject-based Cleaver implementation.
+
+These instructions require at least Cordova 4.x and Xcode 8.0, along
+with a `config.xml` file from a newly created iOS project. You can use
+the procedure in [The Command-Line Interface](../../cli/index.html) to create a new project,
+then obtain the `config.xml` file from within the named application's
+subdirectory within `platforms/ios`.
+
+To follow these instructions, make sure you have the latest Cordova
+distribution. Download it from
+[cordova.apache.org](http://cordova.apache.org) and unzip its iOS
+package.
+
+You have two methods for adding Cordova to your project. The first is using [Carthage](https://github.com/Carthage/Carthage), and the
+second is to manually add Cordova. Note that Carthage support is only in cordova-ios version 4.4.0 or greater.
+
+After using either of these two methods, continue with the **"Using CDVViewController"** section.
+
+## 1. Add Cordova.framework to the Xcode Project using Carthage
+
+1. Install [Carthage](https://github.com/Carthage/Carthage)
+
+1. In your [Cartfile](https://github.com/Carthage/Carthage/blob/master/Documentation/Artifacts.md#cartfile), add (substitute <version_or_tag> for the appropriate version):
+
+ git "git://git.apache.org/cordova-ios.git" "<version_or_tag>" # Apache
+
+1. Run
+
+ carthage update
+
+1. Add `Carthage/Build/iOS/Cordova.framework` into your Xcode project.
+
+## 2. Adding Cleaver to the Xcode Project (CordovaLib Sub-Project)
+
+1. Quit Xcode if it is running.
+
+1. Open a terminal and navigate to the source directory for Cordova
+ iOS.
+
+1. Copy the `config.xml` file described above into the project
+ directory.
+
+1. Open Xcode and use the Finder to copy the `config.xml` file into
+ its __Project Navigator__ window.
+
+1. Choose __Create groups for any added folders__ and press
+ __Finish__.
+
+1. Use the Finder to copy the `CordovaLib/CordovaLib.xcodeproj` file
+ into Xcode's __Project Navigator__
+
+1. Select `CordovaLib.xcodeproj` within the __Project Navigator__.
+
+1. Type the __Option-Command-1__ key combination to show the __File
+ Inspector__.
+
+1. Choose __Relative to Group__ in the __File Inspector__ for the
+ drop-down menu for __Location__.
+
+1. Select the __project icon__ in the __Project Navigator__, select
+ the __Target__, then select the __Build Settings__ tab.
+
+1. Add `-force_load` and `-ObjC` for the __Other Linker Flags__ value.
+
+1. Click on the __project icon__ in the Project Navigator, select the
+ __Target__, then select the __Build Phases__ tab.
+
+1. Expand __Link Binaries with Libraries__.
+
+1. Select the __+__ button, and add the following __frameworks__.
+ Optionally within the __Project Navigator__, move them under the
+ __Frameworks__ group:
+
+ ```
+ AssetsLibrary.framework
+ CoreLocation.framework
+ CoreGraphics.framework
+ MobileCoreServices.framework
+ ```
+
+1. Expand __Target Dependencies__, the top box with that label if
+ there's more than one box.
+
+1. Select the __+__ button, and add the `CordovaLib` build product.
+
+1. Expand __Link Binaries with Libraries__, the top box with that label
+ if there's more than one box.
+
+1. Select the __+__ button, and add `libCordova.a`.
+
+1. Set the __Xcode Preferences → Locations → Derived Data
+ → Advanced...__ to __Unique__.
+
+1. Select the __project icon__ in the Project Navigator, select your
+ __Target__, then select the __Build Settings__ tab.
+
+1. Search for __Header Search Paths__. For that setting, add these
+ three values below, including the quotes:
+
+ ```
+ "$(TARGET_BUILD_DIR)/usr/local/lib/include"
+ "$(OBJROOT)/UninstalledProducts/include"
+ "$(OBJROOT)/UninstalledProducts/$(PLATFORM_NAME)/include"
+ "$(BUILT_PRODUCTS_DIR)"
+ ```
+
+ As of Cordova 2.1.0, `CordovaLib` has been upgraded to use
+ __Automatic Reference Counting (ARC)__. You don't need to upgrade
+ to __ARC__ to use `CordovaLib`, but if you want to upgrade your
+ project to use __ARC__, you should use the Xcode migration wizard
+ from the __Edit → Refactor → Convert to Objective-C
+ ARC...__ menu, __de-select libCordova.a__, then run the wizard to
+ completion.
+
+## Using CDVViewController
+
+1. Add the following header:
+
+ ```objective_c
+ #import <Cordova/CDVViewController.h>
+ ```
+
+1. Instantiate a new `CDVViewController` and retain it somewhere,
+ e.g., to a class property:
+
+ ```objective_c
+ CDVViewController* viewController = [CDVViewController new];
+ ```
+
+1. Optionally, set the `wwwFolderName` property, which defaults to `www`:
+
+ ```objective_c
+ viewController.wwwFolderName = @"myfolder";
+ ```
+
+1. Optionally, set the start page in the `config.xml` file's
+ `<content>` tag, either a local file:
+
+ ```xml
+ <content src="index.html" />
+ ```
+
+ ...or a remote site:
+
+ ```xml
+ <content src="http://apache.org" />
+ ```
+
+1. Optionally, set the `useSplashScreen` property, which defaults to
+ `NO`:
+
+ ```objective_c
+ viewController.useSplashScreen = YES;
+ ```
+
+1. Set the __view frame__. Always set this as the last property:
+
+ ```objective_c
+ viewController.view.frame = CGRectMake(0, 0, 320, 480);
+ ```
+
+1. Add Cleaver to the view:
+
+ ```objective_c
+ [myView addSubview:viewController.view];
+ ```
+
+## Adding HTML, CSS and JavaScript Assets
+
+1. Create a new directory within the project, `www` for example.
+
+1. Place HTML, CSS and JavaScript assets into this directory.
+
+1. Use the Finder to copy the directory into Xcode's __Project
+ Navigator__ window.
+
+1. Select __Create folder references for any added folders__.
+
+1. Set the appropriate `wwwFolderName` and `startPage` properties for
+ the directory you initially created, or use the defaults (specified
+ in the previous section) when instantiating the
+ `CDVViewController`.
+
+ ```objective_c
+ /*
+ if you created a folder called 'myfolder' and
+ you want the file 'mypage.html' in it to be
+ the startPage
+ */
+ viewController.wwwFolderName = @"myfolder";
+ viewController.startPage = @"mypage.html"
+ ```
+
diff --git a/www/docs/en/11.x/guide/platforms/osx/config.md b/www/docs/en/11.x/guide/platforms/osx/config.md
new file mode 100644
index 0000000..8bc2b19
--- /dev/null
+++ b/www/docs/en/11.x/guide/platforms/osx/config.md
@@ -0,0 +1,87 @@
+---
+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: OS X Configuration
+---
+
+# OS X Configuration
+
+The `config.xml` file controls an app's basic settings that apply
+across each application and CordovaWebView instance. This section
+details preferences that only apply to OS X builds. See [The config.xml
+File](../../../config_ref/index.html#The%20config.xml%20File) for information on global configuration options.
+
+## Overview
+
+| Name | Default | Version | Comment |
+|------|---------|---------|---------|
+| `HideMousePointer` | _disabled_ | 4.0.0 | Sets the timeout for hiding the mouse pointer |
+| `OSXLocalStoragePath` | `~/Library/Application Support/{bundle.id}`| 4.0.0 | Sets the local storage path |
+| `WindowSize` | `auto`| 4.0.0 | Sets the size of the application window. |
+| `EnableWebGL` | `false`| 4.0.0 | Enables WebGL on the web view. |
+
+
+## Details
+
+### HideMousePointer
+(integer, defaults to _disabled_)
+Idle duration in seconds after which the mouse pointer should be hidden.
+Set it to `0` for immediate.
+
+Example: hide mouse pointer after 5 seconds:
+
+```xml
+<preference name="HideMousePointer" value="5"/>
+```
+
+### OSXLocalStoragePath
+(string, defaults to `~/Library/Application Support/{bundle.id}`)
+Sets the directory for the local storage path.
+
+Example: use custom path:
+
+```xml
+<preference name="OSXLocalStoragePath" value="~/.myapp/database"/>
+```
+
+### WindowSize
+(string, defaults to `auto`)
+Defines the size of the application window in the format `WxH` or the special values `auto` and
+`fullscreen`. The latter will open a borderless window spanning the entire desktop area. Please note,
+that this is different from the _normal_ OS X fullscreen mode, which would never span multiple displays.
+
+Example: set the window size to 800 x 400:
+
+```xml
+<preference name="WindowSize" value="800x400"/>
+```
+
+> **Note**: The global cordova `fullscreen` preference is not supported.
+
+### EnableWebGL
+(boolean, defaults to `false`)
+If set to `true` it enables WebGL on the webview.
+
+Example: enable WebGL
+
+```xml
+<preference name="EnableWebGL" value="true" />
+```
+
+
diff --git a/www/docs/en/11.x/guide/platforms/osx/index.md b/www/docs/en/11.x/guide/platforms/osx/index.md
new file mode 100644
index 0000000..175c826
--- /dev/null
+++ b/www/docs/en/11.x/guide/platforms/osx/index.md
@@ -0,0 +1,146 @@
+---
+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: OS X Platform Guide
+toc_title: OS X (deprecated)
+---
+
+# OS X Platform Guide
+
+**NOTICE:** The OS X platform is now deprecated and may be removed from a future version of Cordova.
+
+This guide shows how to set up your SDK development environment to
+deploy Cordova apps for OS X computers. See the
+following for more detailed platform-specific information:
+
+* [OS X Configuration](config.html)
+* [OS X Plugins](plugin.html)
+
+The command-line tools above refer to versions prior to Cordova 3.0.
+See [The Command-Line Interface](../../cli/index.html) for information about the
+current interface.
+
+## Requirements and Support
+
+Apple® tools required to build OS X applications run only on the OS X
+operating system on Intel-based Macs. Xcode® 6.0 (the minimum required
+version) runs only on OS X version 10.9 (Mavericks) or greater, and
+includes the OS X SDK (Software Development Kit). To submit apps to
+the Apple App Store℠ requires the latest versions of the Apple tools.
+
+You can test all of the Cordova features using the XCode or any other
+IDE such as [JetBrain's AppCode](https://www.jetbrains.com/objc/), but
+you need to use XCode to sign before submitting to the
+App Store. To sign the apps, you must also be a member of Apple's
+[OS X Developer Program](https://developer.apple.com/osx/).
+
+## Install the SDK
+
+There are two ways to download Xcode:
+
+* from the [App Store](https://itunes.apple.com/us/app/xcode/id497799835?mt=12),
+ available by searching for "Xcode" in the __App Store__ application.
+
+* from [Apple Developer Downloads](https://developer.apple.com/downloads/index.action),
+ which requires registration as an Apple Developer.
+
+Once Xcode is installed, several command-line tools need to be enabled
+for Cordova to run. From the __Xcode__ menu, select __Preferences__,
+then the __Downloads__ tab. From the __Components__ panel, press the
+__Install__ button next to the __Command Line Tools__ listing.
+
+## Create a New Project
+
+Use the `cordova` utility to set up a new project, as described in The
+Cordova [The Command-Line Interface](../../cli/index.html). For example, in a source-code directory:
+
+```bash
+$ cordova create hello com.example.hello "HelloWorld"
+$ cd hello
+$ cordova platform add osx
+$ cordova prepare # or "cordova build"
+```
+
+## Run the app
+
+To run the app on your desktop:
+
+```bash
+$ cordova run
+```
+
+And you should see a bordered window with the example app:
+
+
+
+You can also use __cordova run --help__ to see additional build and run
+options.
+
+## Open a Project in the SDK
+
+Once osx platform is added to your project, you can open it from
+within Xcode. Double-click to open the `hello/platforms/osx/HelloWorld.xcodeproj`
+file. The screen should look like this:
+
+
+
+> **TIP**
+> You can also use the `open` command to open the XCode project directly
+> from the command line:
+> ```
+> $ open platforms/osx/HelloWorld.xcodeproj
+> ```
+
+## Common Problems
+
+__Deprecation Warnings__: When an application programming interface
+(API) is changed or replaced by another API, it is marked as
+_deprecated_. The API still works in the near term, but is eventually
+removed. Some of these deprecated interfaces are reflected in Apache
+Cordova, and Xcode issues warnings about them when you build and
+deploy an application.
+
+__Missing Headers__: Compilation errors relating to missing headers
+result from problems with the build location, and can be fixed
+via Xcode preferences:
+
+1. Select __Xcode → Preferences → Locations__.
+
+2. In the __Derived Data__ section, press the __Advanced__ button and
+ select __Unique__ as the __Build Location__ as shown here:
+
+ 
+
+This is the default setting for a new Xcode install, but it may be set
+differently following an upgrade from an older version of Xcode.
+
+For further information, consult Apple's documentation:
+
+* [Member Center home page](https://developer.apple.com/membercenter/index.action)
+ provides links to several OS X technical resources including
+ technical resources, the provisioning portal, distribution guides
+ and community forums.
+
+* [Xcode User Guide](http://developer.apple.com/library/ios/#documentation/ToolsLanguages/Conceptual/Xcode4UserGuide/000-About_Xcode/about.html#//apple_ref/doc/uid/TP40010215)
+
+* The [xcode-select command](http://developer.apple.com/library/mac/#documentation/Darwin/Reference/ManPages/man1/xcode-select.1.html),
+ which helps specify the correct version of Xcode if more than one is installed.
+
+(Mac®, OS X®, Apple®, Xcode®, App Store℠, iPad®, iPhone®, iPod® and Finder® are Trademarks of Apple Inc.)
+
diff --git a/www/docs/en/11.x/guide/platforms/osx/plugin.md b/www/docs/en/11.x/guide/platforms/osx/plugin.md
new file mode 100644
index 0000000..d0eddb8
--- /dev/null
+++ b/www/docs/en/11.x/guide/platforms/osx/plugin.md
@@ -0,0 +1,27 @@
+---
+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: OS X Plugins
+---
+
+# OS X Plugins
+
+This section is not written yet.
+Please refer to the [iOS Plugin Guide](../ios/plugin.html) that has many
+similarities to OS X.
diff --git a/www/docs/en/11.x/guide/platforms/windows/index.md b/www/docs/en/11.x/guide/platforms/windows/index.md
new file mode 100644
index 0000000..30d1e83
--- /dev/null
+++ b/www/docs/en/11.x/guide/platforms/windows/index.md
@@ -0,0 +1,448 @@
+---
+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: Windows Platform Guide
+toc_title: Windows (deprecated)
+---
+
+# Windows Platform Guide
+
+**NOTICE:** The Windows platform is now deprecated and may be removed from a future version of Cordova.
+
+This guide shows how to set up your SDK development environment to build and deploy Cordova apps Windows 10 (Universal Windows Platform [= UWP], formerly known as Universal App Platform [= UAP]), Windows 8.1 and Windows Phone 8.1. It shows how to use either shell tools to generate and build apps, or the cross-platform Cordova CLI. (See the [Overview](../../overview/index.html#development-paths) for a comparison of these development options.) This section also shows how to modify Cordova [...]
+
+Cordova Windows on Windows 8.1 and Windows Phone 8.1 rely on Internet Explorer 11 as their rendering engine, so as a practical matter you can use IE's powerful debugger to test any web content that doesn't invoke Cordova APIs. The Windows Phone Developer Blog provides [helpful guidance](https://blogs.windows.com/buildingapps/2012/11/15/adapting-your-webkit-optimized-site-for-internet-explorer-10/#qYPwLJDbYKToOveG.97) on how to support IE along with comparable WebKit browsers.
+
+## Requirements and Support
+
+To develop apps for Windows 10 you need:
+
+- [Windows] 10 or 8.1
+- [Visual Studio] 2017 or 2015
+
+> ❗ Visual Studio 2019 does not support Cordova-Windows. See [apache/cordova-windows#327](https://github.com/apache/cordova-windows/issues/327)
+
+To develop apps for Windows 8.1:
+
+- [Windows] 8.1
+- [Visual Studio] 2015 or 2013
+
+> ❗ Windows Phone 8 Emulator requires Windows 8.1 (x64) Professional edition or higher, and a processor that supports [Client Hyper-V and Second Level Address Translation (SLAT)](https://msdn.microsoft.com/en-us/library/windows/apps/ff626524(v=vs.105).aspx#hyperv)
+
+Cordova apps targeting Windows can be developed on a Mac, either by running a
+virtual machine environment or by using Boot Camp to dual-boot a
+Windows partition. Consult these resources to set up the required
+Windows development environment on a Mac:
+
+- [VMWare Fusion](http://msdn.microsoft.com/en-US/library/windows/apps/jj945426)
+- [Parallels Desktop](http://msdn.microsoft.com/en-US/library/windows/apps/jj945424)
+- [Boot Camp](http://msdn.microsoft.com/en-US/library/windows/apps/jj945423)
+
+## Installing the Requirements
+
+Install any edition of [Visual Studio](http://www.visualstudio.com/downloads) matching the version
+requirements listed above.
+
+### Visual Studio 2017
+
+You also need to install the Workload "Universal Windows Platform development" and the "Windows 10 SDK (10.0.10240.0)" as individual component.
+
+<br/><p align="center"><img src="{{ site.baseurl }}/static/img/guide/platforms/windows/vs17_workload.png" /></p><br/>
+
+See [here if you get error messages regarding `MSBuild v4.0`](#visual-studio-2017-and-msbuild-v40-is-not-supported-aborting).
+
+### Visual Studio 2015
+
+The tools and SDKs for the target Windows platforms (UWP, 8.1, etc.) must also be selected in the installer. They can be found under the "Windows and Web Development" heading.
+
+<br/><p align="center"><img src="{{ site.baseurl }}/static/img/guide/platforms/windows/win8_installTools.png" /></p><br/>
+
+## Project Configuration
+
+After installation, you should be ready to develop apps targetting Windows platform. Refer to [Create your first app](../../cli/index.html) guide for details.
+
+### Target Windows version
+
+By default the `cordova build` command produces one package for Windows 10.
+
+App compatibility is determined by the OS that the app targeted. Apps are forwardly-compatible but not backwardly-compatible, so an app targeting Windows 10 cannot run on 8.1, but an app built for 8.1 can run on 10.
+
+#### Target version configuration
+
+If you want to build Windows 8.1 and Windows Phone 8.1 packages by default, you have to target `8.1` and the following configuration setting must be added to configuration file (`config.xml`).
+
+```xml
+<preference name="windows-target-version" value="8.1" />
+```
+
+Once you add this setting, the `build` command will start producing Windows 8.1 and Windows Phone 8.1 packages.
+
+#### Overriding configuration with the --appx parameter
+
+You may decide that you want to build a particular version of your application targeting a particular OS (for example, you might have set that you want to target Windows 10, but you want to build for Windows Phone 8.1). To do this, you can use the `--appx` parameter:
+
+```
+cordova build windows -- --appx=8.1-phone
+```
+
+The build system will ignore the preference set in `config.xml` for the target Windows version and strictly build a package for Windows Phone 8.1.
+
+Valid values for the `--appx` flag are `8.1-win`, `8.1-phone`, and `uwp` or `uap` (for Windows 10 Universal Apps / Universal Windows Apps). These options also apply to the `cordova run` command.
+
+#### Considerations for target Windows version
+
+Windows 10 supports a new "Remote" mode for Cordova apps (and HTML apps in general). This mode enables
+apps to have much more freedom with respect to use of DOM manipulation and common web patterns such as the use
+of inline script, but does so by reducing the set of capabilities your app may use when
+submitted to the public Windows Store. For more information about Windows 10 and Remote Mode, look at
+the [Understanding Remote Mode vs Local Mode](#understanding-remote-mode-vs-local-mode) section.
+
+When using Remote Mode, developers are encouraged to apply a Content Security Policy (CSP) to their application
+to prevent script injection attacks.
+
+### Deploy options
+
+To deploy Windows package:
+
+```
+cordova run windows
+```
+
+This command will give you the list of all available targets:
+
+```
+cordova run windows --list
+```
+
+This allows you to run the application on a specific device or emulator, in this case "Emulator 8.1 720p 4.7 inch"
+
+```
+cordova run windows --target="Emulator 8.1 720P 4.7 inch" -- --phone
+```
+
+#### Architecture option
+
+- `--archs`
+- Specific chip architectures (`anycpu`, `arm`, `x86`, `x64`)
+
+#### Bundle option
+
+- `--bundle`
+- Generates an .appxbundle. Not valid if anycpu AND chip-specific architectures are used (at the same time)
+
+You can also use __cordova run --help__ to see additional build and run options.
+
+#### Deploy options when targetting Windows (Phone) 8.1
+
+With Windows (Phone) 8.1 packages you have more options for deployment.
+
+##### `--phone` and `--win`
+
+To deploy Windows 8.1 package:
+
+```
+cordova run windows -- --win # explicitly specify Windows as deployment target
+```
+
+To deploy Windows Phone 8.1 package:
+
+```
+cordova run windows -- --phone # deploy app to Windows Phone 8.1 emulator
+cordova run windows --device -- --phone # deploy app to connected device
+```
+
+##### `--win10tools`
+
+- `--win10tools`
+- Uses Windows 10 deployment tools (used for a Windows 8.1 app when) being deployed to a Windows 10 device
+
+### Using Visual Studio to deploy the app
+
+Once you build a Cordova app, you can open it with Visual Studio. The various `build` commands generate a Visual Studio
+Solution (_.sln_) file. Open the file in the File Explorer to modify the project within Visual Studio:
+
+<br/><p align="center"><img src="{{ site.baseurl }}/static/img/guide/platforms/windows/win8_sdk_openSLN.png" /></p><br/>
+
+The `CordovaApp` component displays within the solution, and its `www` directory contains the web-based source code, including the `index.html` home page:
+
+<br/><p align="center"><img src="{{ site.baseurl }}/static/img/guide/platforms/windows/win8_sdk.png" /></p><br/>
+
+The projects for different Windows versions are displayed separately in the solution explorer. You can choose the deploy target version by right clicking the 'solution' (topmost entry in the solution explorer) and then going into 'Properties'. Here you can update the 'Single start up' field. The controls below Visual Studio's main menu allow you to test or deploy the app:
+
+<br/><p align="center"><img src="{{ site.baseurl }}/static/img/guide/platforms/windows/win8_sdk_deploy.png" /></p><br/>
+
+With __Local Machine__ selected, press the green arrow to install the app on the same machine running Visual Studio. Once you do so, the app appears in Windows' app listings:
+
+<br/><p align="center"><img src="{{ site.baseurl }}/static/img/guide/platforms/windows/win8_sdk_runApp.png" /></p><br/>
+
+Each time you rebuild the app, the version available in the interface is refreshed.
+
+Once available in the app listings, holding down the __CTRL__ key while selecting the app allows you to pin it to the main screen:
+
+<br/><p align="center"><img src="{{ site.baseurl }}/static/img/guide/platforms/windows/win8_sdk_runHome.png" /></p><br/>
+
+Note that if you open the app within a virtual machine environment, you may need to click in the corners or along the sides of the windows to switch apps or access additional functionality:
+
+<br/><p align="center"><img src="{{ site.baseurl }}/static/img/guide/platforms/windows/win8_sdk_run.png" /></p><br/>
+
+Alternately, choose the __Simulator__ deployment option to view the app as if it were running on a tablet device:
+
+<br/><p align="center"><img src="{{ site.baseurl }}/static/img/guide/platforms/windows/win8_sdk_sim.png" /></p><br/>
+
+Unlike desktop deployment, this option allows you to simulate the tablet's orientation, location, and vary its network settings.
+
+__NOTE__: Consult the [Overview](../../overview/index.html) for advice on how to use Cordova's
+command-line tools or the SDK in your workflow. The Cordova CLI relies
+on cross-platform source code that routinely overwrites the
+platform-specific files used by the SDK. If you want to use the SDK to
+modify the project, use the lower-level shell tools as an alternative
+to the CLI.
+
+## Debugging
+
+Visual Studio provides powerful tools to debug your application. You can refer to [this article](https://msdn.microsoft.com/en-us/library/7seh8d72.aspx) to get started with it.
+
+**Note:** Resume and pause events are not triggered normally when debugging apps using Visual Studio. This is because Windows does not suspend your app when it is being debugged. The only way to change the application state is through the 'Lifecycle event' options inside Visual Studio. The events should work as expected when the app is run on a device/emulator without the debugger attached.
+
+## Signing an App
+
+You can learn more about signing and packaging of Windows Store Apps on [MSDN][1].
+
+To be able to correctly package and sign Windows apps there are few things required:
+
+- A signing certificate
+- Identity details matching the provided signing certificate
+
+In Windows project, identity details are kept in a file named `package.appxmanifest`. This file is automatically populated every time a Cordova app is built. Identity holds 3 important fields.
+
+- Name
+- Publisher
+- Version
+
+*Name* and *Version* can be set from `config.xml`. *Publisher* can be provided as a build parameter or can be set on `build.json` file.
+
+
+
+*Name* and *Version* can also be set as platform-specific preferences in **config.xml** in the following way:
+
+```xml
+<widget windows-packageVersion="2.0.0" ...> <!-- windows-packageVersion overrides version -->
+<preference name="WindowsStoreIdentityName" value="12345FakeCorp.CoolApp"/> <!-- WindowsStoreIdentityName overrides widget.id -->
+```
+
+*PublisherDisplayName* and *DisplayName* can also be overriden:
+
+```xml
+<preference name="WindowsStorePublisherName" value="FakeCorp"/> <!-- WindowsStorePublisherName overrides author -->
+<preference name="WindowsStoreDisplayName" value="CoolApp"/> <!-- WindowsStorePublisherName overrides name -->
+```
+
+A signing certificate can be provided from either CLI or through `build.json` file. The certificate related CLI flags are:
+
+| Parameter | Flag | Description
+|-----------------------|-------------------|-----------------------------------
+| Certificate File | `--packageCertificateKeyFile` | Path to the package signing certificate to be associated with the app
+| Thumb Print | `--packageThumbprint` | Used to validate the authenticity of package certificate key file. When creating a certificate key file, this value will be provided to the end user
+
+Example:
+```
+cordova build -- --packageCertificateKeyFile="platforms\windows\CordovaApp_TemporaryKey.pfx" --packageThumbprint="ABCABCABCABC123123123123"
+```
+
+Alternatively, these values could be specified using a build configuration file (`build.json`) using CLI (`--buildConfig`). A sample build configuration file:
+
+```json
+{
+ "windows": {
+ "debug": {
+ "packageCertificateKeyFile": "platforms\\windows\\CordovaApp_TemporaryKey.pfx"
+ },
+ "release": {
+ "packageCertificateKeyFile": "c:\\path-to-key\\keycert.pfx",
+ "packageThumbprint": "ABCABCABCABC123123123123",
+ "publisherId": "CN=FakeCorp.com, L=Redmond, S=Washington, C=US"
+ }
+ }
+}
+```
+
+There is also support to mix and match command line arguments and parameters in `build.json` file. Values from the command line arguments will get precedence.
+
+### Creating a certificate key
+
+Signing is required for distributing and installing Windows Store apps. This process is normally handled by Visual Studio when you deploy a package for release. To do this without Visual Studio we need to create our own certificates. [This article](https://msdn.microsoft.com/en-us/library/windows/desktop/jj835832(v=vs.85).aspx) has instructions on how to do that.
+
+Once you have the `.pfx` file created and provided to `build.json` file, you might get the following error: "The key file may be password protected. To correct this, try to import the certificate manually into the current user's personal certificate store.". In order to import it you have to use [certutil][2] from an admin prompt:
+
+`certutil -user -p PASSWORD -importPFX FakeCorp.com.pfx`
+
+Where:
+
+- user : Specifies "current user" personal store
+- p : Password for pfx file
+- importPFX : Name of pfx file
+
+Once installed, next step is to add packageThumbprint and packageCertificateKeyFile to build.json. In order to find the packageThumbprint, search for the CommonName you've associated with the certificate:
+
+```powershell
+powershell -Command " & {dir -path cert:\CurrentUser\My | where { $_.Subject -like \"*FakeCorp.com*\" }}"
+```
+
+Once these final values are provided. Cordova should successfully package and sign the app.
+
+## MSBuild build flags
+
+Similar to other platforms ([`--gradleArg` on Android](../android/index.html#setting-gradle-properties), [`--buildFlag` on iOS](../ios/index.html#xcode-build-flags)) you can pass custom flags to MSBuild. To do this you have two options:
+
+- add one or more `--buildFlag` options to `cordova build windows` or `cordova run windows` commands:
+
+ ```
+ cordova build windows -- --buildFlag /clp:Verbosity=normal --buildFlag /p:myCustomProperty=Value
+ cordova run windows -- --buildFlag /clp:Verbosity=minimal
+ ```
+
+- add `buildFlag` option to `build.json` file:
+
+ ```json
+ {
+ "windows": {
+ "debug": {
+ "buildFlag": [
+ "/clp:Verbosity=normal",
+ "/p:myCustomProperty=Value"
+ ]
+ }
+ }
+ }
+ ```
+
+
+Note that `cordova-windows` appends build flags from `build.json` and CLI arguments in specific order. In particular, flags from `build.json` are being appended _before_ build flags from CLI, which basically means that CLI flags _override_ ones from `build.json` in case of any conflicts.
+
+For the list of MSBuild's available command-line options please refer to [official MSBuild command-line reference](https://msdn.microsoft.com/library/ms164311.aspx).
+
+## Platform Centered Workflow
+
+If you want to use Cordova's Windows-centered shell tools in conjunction with the SDK, you have two basic options:
+
+- Access them locally from project code generated by the CLI. They are
+ available in the `platforms/windows/` directory after you add
+ the `windows` platform as described below.
+
+- Download them from a separate distribution
+ [here](https://www.apache.org/dist/cordova/platforms/).
+ The Cordova distribution contains separate archives for each platform.
+ Be sure to expand the appropriate archive, `cordova-windows` in
+ this case, within an empty directory. The relevant batch utilities
+ are available in `package/bin` directory. (Consult the
+ __README__ file if necessary for more detailed directions.)
+
+These shell tools allow you to create, build, and run Windows apps. Each cordova command corresponds to one of these shell tool scripts.
+
+For example, the lower-level shell-tool approach corresponding to `cordova create HelloWorld` is:
+
+```
+C:\path\to\cordova-windows\package\bin\create.bat C:\path\to\new\hello HelloWorld
+```
+
+Similarly for `cordova build --debug`:
+
+```
+C:\path\to\project\cordova\build.bat --debug
+```
+
+## Upgrading
+
+Refer to [this](upgrade.html) article for instructions to upgrade your `cordova-windows` version.
+
+## Supporting Toasts
+
+Windows requires an app manifest capability declaration in order to support
+toast notifications. When using the `cordova-plugin-local-notifications`
+plugin, or any other plugin that is attempting to use toast notifications,
+add the following preference to your config.xml to enable it to publish
+toast notifications, unless the plugin makes that change on it's own:
+
+```xml
+<preference name="WindowsToastCapable" value="true" />
+```
+
+This preference sets the corresponding flag in your app manifest. Plugins
+should do the work necessary to configure the appearance of the
+displayed notifications.
+
+## Understanding Remote Mode vs Local Mode
+
+Windows 10 introduces a new feature called "Remote mode" for HTML applications. Prior to it, Windows 8.1 apps
+worked on what is now termed as "Local Mode" in Windows 10, in which HTML Applications have full access to the native
+Windows API surface and capabilities. Local Mode disallows inline script in order to prevent script injection attacks,
+which could result in leaking personally-identifiable information due to malicious code. It also requires developers who
+perform DOM manipulation to do so within an explicit context
+(`MSApp.execUnsafeLocalFunction`).
+
+Remote Mode eliminates those requirements, which makes it possible to use unmodified libraries like jQuery
+or AngularJS directly in your code, without any changes. To do so, it removes your ability to declare certain
+capabilities when certifying your app in the Windows Store. The removal of these capabilities usually doesn't
+prevent accessing certain functionality, but it might require the use of a different combination of APIs or tactics.
+
+### Effect of Remote Mode on capabilities
+
+The following capabilities are unavailable when deploying your Remote Mode application to the Windows Store:
+
+- Enterprise Authentication (`enterpriseAuthentication`)
+- Shared User Certificates (`sharedUserCertificates`)
+- Documents Library (`documentsLibrary`)
+- Music Library (`musicLibrary`)
+- Pictures Library (`picturesLibrary`)
+- Videos Library (`videosLibrary`)
+- Removable [Storage](../../../cordova/storage/storage.html) (`removableStorage`)
+- Internet client/server (`internetClientServer`) - note that `internetClient` is still permitted
+- Private network client/server (`privateNetworkClientServer`)
+
+Each of the library restrictions may be worked around by requesting that the user interact with the file system via a [File Picker](https://msdn.microsoft.com/en-us/library/windows/apps/windows.storage.pickers.fileopenpicker.aspx). This prevents malicious injected code from arbitrarily accessing the file system.
+
+The network-related restrictions must be worked around by either using an API that doesn't use capability checks or by brokering communication via standard internet communication channels, such as `XMLHttpRequest` or Web Sockets.
+
+The Enterprise Authentication and Shared User Certificates capabilities are specifically targeted at Enterprise scenarios. These capabilities are supported for private/enterprise-enabled App Stores, so if you are building apps which are going to be deployed to an internal deployment mechanism, you can still support these. However, they are not supported for Remote Mode apps in the public Windows Store. When you build targeting Windows 10, if one of these capabilities is detected in yo [...]
+
+### Scrolling in Local Mode
+
+While scrolling of the WebView is enabled by default in "Remote mode" and on the other platforms, in "Local Mode" this is not the case. If scrolling is required in "Local Mode", it can be enabled using the CSS `overflow` property.
+
+
+## Common Problems and Workarounds
+
+### Visual Studio 2017 and `MSBuild v4.0 is not supported, aborting.`
+
+The support for Visual Studio 2017 in Cordova Windows unfortunately is not very stable and Cordova Windows sometime can not find MSBuild, Visual Studio's command line build tools. If this affects you, when trying to build a Cordova Windows project you will get an error message simlar to this:
+
+```
+MSBuild v4.0 is not supported, aborting.
+```
+
+To work around this problem, we implemented two environment variables that you can set to tell Cordova Windows where to look.
+- The first is `VSINSTALLDIR `and should be set to the installation directory of your Visual Studio (e.g. `C:\Program Files (x86)\Microsoft Visual Studio\2017\Community`).
+- If this doesn't work, the second one is called `MSBUILDDIR` and describes the path of your MSBuild `bin` directory (which is most often found at `C:\Program Files (x86)\Microsoft Visual Studio\2017\Community\MSBuild\15.0\Bin`).
+
+You can either set the environment variable on demand manually by executing `set KEY=VALUE` (e.g. `set MSBUILDDIR=C:\Program Files (x86)\Microsoft Visual Studio\2017\Community\MSBuild\15.0\Bin`) or [set it permanently via the "System Properties"](https://www.computerhope.com/issues/ch000549.htm).
+
+[1]: https://msdn.microsoft.com/en-us/library/hh446593(v=vs.85).aspx
+[2]: https://technet.microsoft.com/en-us/library/ee624045(v=ws.10).aspx
+[Visual Studio]: https://visualstudio.microsoft.com/vs/older-downloads/
+[Windows]: https://www.microsoft.com/windows
diff --git a/www/docs/en/11.x/guide/platforms/windows/plugin.md b/www/docs/en/11.x/guide/platforms/windows/plugin.md
new file mode 100644
index 0000000..258e81d
--- /dev/null
+++ b/www/docs/en/11.x/guide/platforms/windows/plugin.md
@@ -0,0 +1,209 @@
+---
+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: Windows Plugins
+toc_title: Windows
+---
+
+# Windows Plugins
+
+This section provides details for how to implement a plugin for use in
+a Windows Store app for Windows 8.1 phone and desktop, and Universal Windows Platform (Windows 10+). Before reading this, see [Create your first plugin](../../hybrid/plugins/index.html) for an overview of the plugin's structure and its common JavaScript interface. This section continues to demonstrate the sample _echo_ plugin that communicates from the Cordova webview to the native platform and back.
+
+## Creating a Windows Plugin in JavaScript
+
+Windows Cordova plugins are essentially a thin wrapper around existing WinJS provided functions, but assuming you will want to define your JS common interface for multiple devices, you will typically have one JS file that provides the API:
+
+```js
+// inside file www/echoplugin.js
+var EchoPlugin = {
+ // the echo function calls successCallback with the provided text in strInput
+ // if strInput is empty, it will call the errorCallback
+ echo:function(successCallback, errorCallback, strInput) {
+ cordova.exec(successCallback,errorCallback,"EchoPlugin","echo",[strInput]);
+ }
+}
+```
+
+The `cordova.exec` function is defined differently on every platform, this is because each platform has it's own way of communicating between the application js code, and the native wrapper code. But in the case of Windows, there is no native wrapper, so the exec call is there for consistency. So even though you could write the Windows specific code as a part of plugin's common JS code directly, this is not recommended and plugin authors should use the same exec API for Windows as for ot [...]
+
+### Plugin Exec Proxy
+
+On Windows, Cordova provides a proxy that you can use to register an object that will handle all `cordova.exec` calls to an API. So in our case, we will assume that the code in `echoplugin.js` is handling cross platform relevant JavaScript, and we can simply write a proxy for Windows.
+
+```js
+// in file www/echoplugin.js
+window.echo = function(str, callback) {
+ cordova.exec(callback, function(err) {
+ callback('Nothing to echo.');
+ }, "Echo", "echo", [str]);
+};
+```
+
+```js
+// in file src/windows/echopluginProxy.js
+cordova.commandProxy.add("Echo",{
+ echo:function(successCallback,errorCallback,strInput) {
+ if(!strInput || !strInput.length) {
+ errorCallback("Error, something was wrong with the input string. =>" + strInput);
+ }
+ else {
+ successCallback(strInput + "echo");
+ }
+ }
+});
+
+// or alternative syntax
+
+module.exports = {
+ echo: function(successCallback, errorCallback, strInput) {
+ if(!strInput || !strInput.length) {
+ errorCallback("Error, something was wrong with the input string. =>" + strInput);
+ }
+ else {
+ successCallback(strInput + "echo");
+ }
+ }
+};
+
+require('cordova/exec/proxy').add('Echo', module.exports);
+```
+
+The `www/echoplugin.js` file will forward the `echo` function call to this proxy through the `cordova.exec` command and execute this implementation in `src/windows/echopluginProxy.js`.
+
+The `plugin.xml` file will have the settings required for our plugin. In this case, we want to add our `echoplugin.js` file in the `www` directory and the `echopluginProxy.js` file inside the `windows` source code of our application. Details of these elements can be found in the [Plugin.xml](../../../plugin_ref/spec.html) reference.
+
+```xml
+<?xml version="1.0" encoding="UTF-8"?>
+<plugin xmlns="http://apache.org/cordova/ns/plugins/1.0"
+ id="echoplugin"
+ version="0.1.0">
+
+ <js-module src="www/echoplugin.js" name="echoplugin">
+ <clobbers target="window.echoplugin" />
+ </js-module>
+
+ <!-- windows -->
+ <platform name="windows">
+ <js-module src="src/windows/echopluginProxy.js" name="EchoProxy">
+ <merges target="" />
+ </js-module>
+ </platform>
+
+ <!-- other platforms -->
+
+</plugin>
+```
+
+
+This gives us a working Windows JavaScript plugin that uses a common file (`www/echoplugin.js`) and uses a proxy to provide the Windows only portion of implementation (`src/windows/echopluginProxy.js`). So how do we add native/managed code to this? Well we are going to start the same, the only difference will be what we do inside in echopluginProxy methods.
+
+## Creating a Windows Plugin in C++ or managed code.
+
+In Windows, Javascript authored apps are able to interop with native (C++) and managed code (C#, VB) by creating a Windows runtime component. You can learn the basics here and checkout more details in guides on MSDN:
+- [Creating Windows Runtime Components in C# and Visual Basic](https://msdn.microsoft.com/en-us/library/windows/apps/br230301.aspx)
+- [Creating Windows Runtime Components in C++](http://msdn.microsoft.com/en-us/library/windows/apps/hh441569.aspx)
+
+When you create your Windows Runtime Component, any class that is defined as `public ref class sealed` is considered an 'activatable class' and will be callable from JavaScript.
+
+```cpp
+// in your header file .h
+namespace EchoRuntimeComponent
+{
+ public ref class EchoPluginRT sealed
+ {
+ public:
+ static Platform::String^ Echo(Platform::String^ input);
+ }
+}
+
+// in the implementation file .cpp
+using namespace EchoRuntimeComponent;
+using namespace Platform;
+
+Platform::String^ EchoPluginRT::Echo(Platform::String^ input)
+{
+ if(input->IsEmpty())
+ {
+ return "Error: input string is empty.";
+ }
+ else
+ {
+ return input->ToString() + "echo";
+ }
+}
+```
+
+Now in order for us to call the native code, we use the namespace, classname, and lowerCamelCase the method we are calling.
+
+```js
+var res = EchoRuntimeComponent.EchoPluginRT.echo("boom");
+```
+
+Moving this to our echopluginProxy.js file, we get:
+
+```js
+// in file echopluginProxy.js
+cordova.commandProxy.add("EchoPlugin",{
+ echo:function(successCallback, errorCallback, strInput) {
+ var res = EchoRuntimeComponent.EchoPluginRT.echo(strInput);
+ if(res.indexOf("Error") == 0) {
+ errorCallback(res);
+ }
+ else {
+ successCallback(res);
+ }
+ }
+});
+```
+
+And that's it, we have an end to end C++ backed js callable plugin for use in Apache Cordova Windows!
+
+### Considerations
+
+- The callback is typically async, so calling the callback right away is probably not expected by the caller. In practice, if the call is not async, you should at least use a javascript timeout to force the callback to be called asynchronously.
+- Activatable classes can be used to do event dispatching, async callbacks, passing your own object types, arrays, collections, overloaded methods and much more. Refer to [Creating Windows Runtime Components in C++](http://msdn.microsoft.com/en-us/library/windows/apps/hh441569.aspx) for details.
+
+### Defining your plugin in plugin.xml
+
+Now that we have a working plugin, we need to revisit the plugin definition from earlier so we can publish it. We can now add the runtime component as a framework, through the `<framework>` tag inside our platfrom settings. Note that the output type of a WindowsRuntimeComponent can be either .winmd or .dll
+
+```xml
+<?xml version="1.0" encoding="UTF-8"?>
+<plugin xmlns="http://apache.org/cordova/ns/plugins/1.0"
+ id="echoplugin"
+ version="0.2.0">
+
+ <js-module src="www/echoplugin.js" name="echoplugin">
+ <clobbers target="window.echoplugin" />
+ </js-module>
+
+ <!-- windows -->
+ <platform name="windows">
+ <js-module src="src/windows/echopluginProxy.js" name="EchoProxy">
+ <merges target="" />
+ </js-module>
+ <framework src="src/windows/EchoRuntimeComponent.winmd" custom="true"/>
+ </platform>
+
+ <!-- other platforms -->
+</plugin>
+```
+
+That's it, you now have a distributable plugin that you can share with the world!
diff --git a/www/docs/en/11.x/guide/platforms/windows/upgrade.md b/www/docs/en/11.x/guide/platforms/windows/upgrade.md
new file mode 100644
index 0000000..6afb707
--- /dev/null
+++ b/www/docs/en/11.x/guide/platforms/windows/upgrade.md
@@ -0,0 +1,76 @@
+---
+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: Upgrading Windows
+---
+
+# Upgrading Windows
+
+For upgrading from `windows` version 4.0.0 or higher, run `cordova platform update windows`.
+
+For projects not created with the cordova CLI, run:
+
+```
+bin\update <project_path>
+```
+
+# Upgrading Windows 8
+
+This is for people still using `windows8` platform to upgrade from older versions of Cordova.
+Most of these instructions apply to projects created with an older set
+of command-line tools that precede the `cordova` CLI utility. See [The Command-Line Interface](../../cli/index.html) for information how to update the
+version of the CLI.
+
+## Upgrade to 4.0.0 from 3.1.0 or later
+
+For projects that were created with the cordova CLI:
+
+1. Update the `cordova` CLI version. See [The Command-Line Interface](../../cli/index.html).
+
+2. Run `cordova platform update windows8`.
+
+For projects not created with the cordova CLI, run:
+
+```
+bin\update <project_path>
+````
+
+## Upgrade to 3.1.0
+
+Cordova CLI support for Windows 8 was introduced in Cordova 3.1.0. To upgrade, we suggest creating a new Cordova CLI project and moving over all necessary assets.
+
+## Upgrade to 2.9.0 from 2.8.0
+
+The following commands should be done from within Visual Studio to be sure that the any project references are updated/deleted.
+
+1. Remove `cordova-2.8.0.js` from the project's `www` directory.
+
+2. Add `cordova.js` file from the source to the project's `www` directory. (Note that the file no longer contains a version number in the filename.)
+
+3. Build and test!
+
+## Upgrade to 2.8.0 from 2.7.0
+
+The following commands should be done from within Visual Studio to be sure that the any project references are updated/deleted.
+
+1. Remove `cordova-2.7.0.js` from the project's `www` directory.
+
+2. Add `cordova.js` file from the source to the project's `www` directory. (Note that the file no longer contains a version number in the filename.)
+
+3. Build and test!
diff --git a/www/docs/en/11.x/guide/support/index.md b/www/docs/en/11.x/guide/support/index.md
new file mode 100644
index 0000000..caf886c
--- /dev/null
+++ b/www/docs/en/11.x/guide/support/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: Cordova support by platform
+toc_title: Platform support
+description: Compatibility table for all major plugins and features.
+---
+
+# Platform Support
+
+The following shows the set of development tools and device APIs
+available for each platform. The device APIs listed here are provided by
+the core plugins, additional APIs are available via
+[third-party plugins](http://plugins.cordova.io).
+
+<!-- START HTML -->
+
+<table class="compat" width="100%">
+
+<thead>
+ <tr>
+ <th>Platform:</th>
+ <th><a href="../platforms/android/index.html">Android</a></th>
+ <th><a href="../platforms/ios/index.html">iOS</a></th>
+ <th><a href="../platforms/osx/index.html">OS X</a></th>
+ <th><a href="../platforms/windows/index.html">Windows<br>8.1, Phone 8.1, 10</a></th>
+ <th><a href="../platforms/electron/index.html">Electron</a></th>
+ </tr>
+ <tr>
+ <th>CLI shorthand:</th>
+ <th>android</th>
+ <th>ios</th>
+ <th>osx</th>
+ <th>windows</th>
+ <th>electron</th>
+ </tr>
+
+</thead>
+
+<tbody>
+ <tr>
+ <th></th>
+ <th colspan="20"><h2><a href="../cli/index.html">Cordova CLI</a> Development Platform</h2></th>
+ </tr>
+ <tr>
+ <th>Mac</th>
+ <td data-col="android" class="y"></td>
+ <td data-col="ios" class="y"></td>
+ <td data-col="osx" class="y"></td>
+ <td data-col="windows" class="n"></td>
+ <td data-col="electron" class="y"></td>
+ </tr>
+ <tr>
+ <th>Windows</th>
+ <td data-col="android" class="y"></td>
+ <td data-col="ios" class="n"></td>
+ <td data-col="osx" class="n"></td>
+ <td data-col="windows" class="y"></td>
+ <td data-col="electron" class="y"></td>
+ </tr>
+ <tr>
+ <th>Linux</th>
+ <td data-col="android" class="y"></td>
+ <td data-col="ios" class="n"></td>
+ <td data-col="osx" class="n"></td>
+ <td data-col="windows" class="n"></td>
+ <td data-col="electron" class="y"></td>
+ </tr>
+
+ <tr>
+ <th></th>
+ <th colspan="20"><h2>Core Plugin APIs</h2></th>
+ </tr>
+
+ <tr>
+ <th><a href="../../reference/cordova-plugin-battery-status/">BatteryStatus</a></th>
+ <td data-col="android" class="y"></td>
+ <td data-col="ios" class="y"></td>
+ <td data-col="osx" class="n"></td>
+ <td data-col="windows" class="y">Windows Phone 8.1 only</td>
+ <td data-col="electron" class="p">Tests Pending</td>
+ </tr>
+
+ <tr>
+ <th><a href="../../reference/cordova-plugin-camera/">Camera</a></th>
+ <td data-col="android" class="y"></td>
+ <td data-col="ios" class="y"></td>
+ <td data-col="osx" class="n"></td>
+ <td data-col="windows" class="y"></td>
+ <td data-col="electron" class="y"></td>
+ </tr>
+
+ <tr>
+ <th><a href="../../reference/cordova-plugin-media-capture/">Capture</a></th>
+ <td data-col="android" class="y"></td>
+ <td data-col="ios" class="y"></td>
+ <td data-col="osx" class="n"></td>
+ <td data-col="windows" class="y"></td>
+ <td data-col="electron" class="p">Tests Pending</td>
+ </tr>
+
+ <tr>
+ <th><a href="../../reference/cordova-plugin-network-information/">Connection</a></th>
+ <td data-col="android" class="y"></td>
+ <td data-col="ios" class="y"></td>
+ <td data-col="osx" class="n"></td>
+ <td data-col="windows" class="y"></td>
+ <td data-col="electron" class="p">Tests Pending</td>
+ </tr>
+
+ <tr>
+ <th><a href="../../reference/cordova-plugin-device/">Device</a></th>
+ <td data-col="android" class="y"></td>
+ <td data-col="ios" class="y"></td>
+ <td data-col="osx" class="y"></td>
+ <td data-col="windows" class="y"></td>
+ <td data-col="electron" class="p">Tests Pending</td>
+ </tr>
+
+ <tr>
+ <th><a href="../../cordova/events/events.html">Events</a></th>
+ <td data-col="android" class="y"></td>
+ <td data-col="ios" class="y"></td>
+ <td data-col="osx" class="n"></td>
+ <td data-col="windows" class="y"></td>
+ <td data-col="electron" class="p">Tests Pending</td>
+ </tr>
+
+ <tr>
+ <th><a href="../../reference/cordova-plugin-file">File</a></th>
+ <td data-col="android" class="y"></td>
+ <td data-col="ios" class="y"></td>
+ <td data-col="osx" class="y"></td>
+ <td data-col="windows" class="y"></td>
+ <td data-col="electron" class="p">Tests Pending</td>
+ </tr>
+
+ <tr>
+ <th><a href="../../reference/cordova-plugin-geolocation/">Geolocation</a></th>
+ <td data-col="android" class="y"></td>
+ <td data-col="ios" class="y"></td>
+ <td data-col="osx" class="n"></td>
+ <td data-col="windows" class="y"></td>
+ <td data-col="electron" class="p">Tests Pending</td>
+ </tr>
+
+ <tr>
+ <th><a href="../../reference/cordova-plugin-globalization/">Globalization</a></th>
+ <td data-col="android" class="y"></td>
+ <td data-col="ios" class="y"></td>
+ <td data-col="osx" class="n"></td>
+ <td data-col="windows" class="y"></td>
+ <td data-col="electron" class="p">Tests Pending</td>
+ </tr>
+
+ <tr>
+ <th><a href="../../reference/cordova-plugin-inappbrowser/">InAppBrowser</a></th>
+ <td data-col="android" class="y"></td>
+ <td data-col="ios" class="y"></td>
+ <td data-col="osx" class="n"></td>
+ <td data-col="windows" class="p">uses iframe</td>
+ <td data-col="electron" class="p">Tests Pending</td>
+ </tr>
+
+ <tr>
+ <th><a href="../../reference/cordova-plugin-media/">Media</a></th>
+ <td data-col="android" class="y"></td>
+ <td data-col="ios" class="y"></td>
+ <td data-col="osx"></td>
+ <td data-col="windows" class="y"></td>
+ <td data-col="electron" class="p">Tests Pending</td>
+ </tr>
+
+ <tr>
+ <th><a href="../../reference/cordova-plugin-dialogs/">Notification</a></th>
+ <td data-col="android" class="y"></td>
+ <td data-col="ios" class="y"></td>
+ <td data-col="osx" class="n"></td>
+ <td data-col="windows" class="y"></td>
+ <td data-col="electron" class="p">Tests Pending</td>
+ </tr>
+
+ <tr>
+ <th><a href="../../reference/cordova-plugin-splashscreen/">Splashscreen</a></th>
+ <td data-col="android" class="y"></td>
+ <td data-col="ios" class="y"></td>
+ <td data-col="osx" class="n"></td>
+ <td data-col="windows" class="y"></td>
+ <td data-col="electron" class="p">Tests Pending</td>
+ </tr>
+
+ <tr>
+ <th><a href="../../reference/cordova-plugin-statusbar/">Status Bar</a></th>
+ <td data-col="android" class="y"></td>
+ <td data-col="ios" class="y"></td>
+ <td data-col="osx" class="n"></td>
+ <td data-col="windows" class="y">WP 8.1 only</td>
+ <td data-col="electron" class="p">Tests Pending</td>
+ </tr>
+
+ <tr>
+ <th><a href="../../cordova/storage/storage.html">Storage</a></th>
+ <td data-col="android" class="y"></td>
+ <td data-col="ios" class="y"></td>
+ <td data-col="osx" class="n"></td>
+ <td data-col="windows" class="y">localStorage &<br> indexedDB</td>
+ <td data-col="electron" class="p">Tests Pending</td>
+ </tr>
+
+ <tr>
+ <th><a href="../../reference/cordova-plugin-vibration/">Vibration</a></th>
+ <td data-col="android" class="y"></td>
+ <td data-col="ios" class="y"></td>
+ <td data-col="osx" class="n"></td>
+ <td data-col="windows" class="y">WP 8.1 only</td>
+ <td data-col="electron" class="n"></td>
+ </tr>
+
+ <tr>
+ <th></th>
+ <th colspan="20"><h2>Platform Features</h2></th>
+ </tr>
+ <tr>
+ <th><a href="../hybrid/plugins/index.html">Plugin<br/>Interface</a></th>
+ <td data-col="android" class="y"><a href="../platforms/android/plugin.html">(see details)</a></td>
+ <td data-col="ios" class="y"><a href="../platforms/ios/plugin.html">(see details)</a></td>
+ <td data-col="osx" class="y"></td>
+ <td data-col="windows" class="y"></td>
+ <td data-col="electron" class="p">Tests Pending</td>
+ </tr>
+ <tr>
+ <th><a href="../hybrid/webviews/index.html">Embedded<br/>WebView</a></th>
+ <td data-col="android" class="y"><a href="../platforms/android/webview.html">(see details)</a></td>
+ <td data-col="ios" class="y"><a href="../platforms/ios/webview.html">(see details)</a></td>
+ <td data-col="osx" class="y"></td>
+ <td data-col="windows" class="n"></td>
+ <td data-col="electron" class="p">Tests Pending</td>
+ </tr>
+</tbody>
+</table>
+
+<!-- END HTML -->
diff --git a/www/docs/en/11.x/index.md b/www/docs/en/11.x/index.md
new file mode 100644
index 0000000..db1dda4
--- /dev/null
+++ b/www/docs/en/11.x/index.md
@@ -0,0 +1,23 @@
+---
+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: Documentation
+---
+
+{% include generated_docs_index.html %}
diff --git a/www/docs/en/11.x/platform_pinning/index.md b/www/docs/en/11.x/platform_pinning/index.md
new file mode 100644
index 0000000..21529b1
--- /dev/null
+++ b/www/docs/en/11.x/platform_pinning/index.md
@@ -0,0 +1,48 @@
+---
+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: Platform Pinning
+toc_title: Platform pinning
+description: Cordova CLI pinned platform versions.
+---
+
+## Platform Pinning
+
+Cordova CLI manages a list of pinned Apache Cordova maintained platforms. When there is a major release of Cordova CLI, the platform's pinned version is updated to the latest released version. Typically, the updating of this pin is made only on a major release of CLI. This is because the pinned versions are pinned with a caret `^` allowing CLI to continue to fetch new minor and patch releases of any given pinned platform.
+
+To see the pinned platforms for your CLI version, execute the command `cordova platform list` in a brand new project directory.
+
+**Cordova CLI 9.x:**
+
+```bash
+$ cordova platform list
+Installed platforms:
+
+Available platforms:
+ android ^8.0.0
+ browser ^6.0.0
+ electron ^1.0.0
+ ios ^5.0.0
+ osx ^5.0.0
+ windows ^7.0.0
+```
+
+Using the above information, when `cordova platform add android` is executed, the latest minor/patch release version starting from 8.0.0 or after (8.x.x) will be fetched. If a version is provided, it will fetch the given version. E.g `cordova platform add ios@5.0.1` will fetch Cordova iOS 5.0.1.
+
+_Note: When a platform is installed, the "**Installed platforms:**" section will display the actual installed platform version. The installed platform will no longer display in the "**Available platforms:**" section until it is removed from the project._
diff --git a/www/docs/en/11.x/platform_plugin_versioning_ref/index.md b/www/docs/en/11.x/platform_plugin_versioning_ref/index.md
new file mode 100644
index 0000000..31f994c
--- /dev/null
+++ b/www/docs/en/11.x/platform_plugin_versioning_ref/index.md
@@ -0,0 +1,313 @@
+---
+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: Platforms and Plugins Version Management
+toc_title: Manage versions and platforms
+description: How to manage platforms and Cordova CLI versions.
+---
+
+# Platforms and Plugins Version Management
+
+Cordova provides the ability to save and restore platforms and plugins.
+
+This feature allows developers to save and restore their app to a known state without having to check in all of the platform and plugin source code.
+
+When adding a platform or plugin, details about the app's platform and plugin versions are automatically saved to the `package.json` file. It is also possible to add a platform or plugin by editing the `package.json` file directly, assuming you know the right tags and syntax. It is not possible to remove plugins or platforms in this manner. The recommended method of adding and removing plugins and platforms is with the Cordova CLI commands `cordova plugin add|remove ...` and `cordova pla [...]
+
+The **restore** step happens automatically when a **`cordova prepare`** is issued, making use of information previously saved in the `package.json` and `config.xml` files.
+
+One scenario where save/restore capabilities come in handy is in large teams that work on an app, with each team member focusing on a platform or plugin. This feature makes it easier to share the project and reduce the amount of redundant code that is checked in the repository.
+
+## Platform Versioning
+
+### Saving Platforms
+
+To save a platform, issue the following command:
+
+```bash
+cordova platform add <platform[@<version>] | directory | git_url>
+```
+
+After running the above command, the **`package.json`** should contain something as seen below:
+
+```json
+"cordova": {
+ "platforms": [
+ "android"
+ ]
+},
+"dependencies": {
+ "cordova-android": "^8.0.0",
+}
+```
+
+The `--nosave` flag prevents adding and deleting specified platforms to the `package.json` file. To prevent saving a platform, issue the following command:
+
+```bash
+cordova platform add <platform[@<version>] | directory | git_url> --nosave
+```
+
+Some Examples:
+
+* **`cordova platform add android`**
+
+ Retrieves the pinned version of `cordova-android` platform from npm, adds it to the project and updates the `package.json` file.
+
+* **`cordova platform add android@7.1.4`**
+
+ Retrieves the `cordova-android` platform version `7.1.4` from npm, adds it to the project and updates the `package.json` file.
+
+* **`cordova platform add https://github.com/apache/cordova-android.git`**
+
+ **`cordova platform add https://github.com/apache/cordova-android`**
+
+ **`cordova platform add github:apache/cordova-android`**
+
+ npm retrieves the `cordova-android` platform from the git repository, adds it to the project and updates the `package.json`.
+
+* **`cordova platform add C:/path/to/android/platform`**
+
+ Retrieves the Android platform from the specified directory, adds it to the project, and updates the `package.json` file.
+
+* **`cordova platform add android --nosave`**
+
+ Retrieves the pinned version of `cordova-android` platform from npm, adds it to the project, but does not add it to the `package.json` file.
+
+### Updating or Removing Platforms
+
+It is possible to update and delete a platform from `config.xml` and `package.json`.
+
+To update a platform, execute the following command:
+
+```bash
+cordova platform update <platform[@<version>] | directory | git_url>
+```
+
+To remove a platform, execute one of the following commands:
+
+```bash
+cordova platform remove <platform>
+cordova platform rm <platform>
+```
+
+Some Examples:
+
+* **`cordova platform update android`**
+
+ In addition to updating the `cordova-android` platform to the pinned version, it updates the `package.json` file.
+
+* **`cordova platform update android@3.8.0`**
+
+ In addition to updating the `cordova-android` platform to version `3.8.0` it updates the `package.json` file.
+
+* **`cordova platform update /path/to/android/platform`**
+
+ In addition to updating the `cordova-android` platform to version found in the provided folder, it updates the `package.json` file.
+
+* **`cordova platform remove android`**
+
+ Removes the `cordova-android` platform from the project and removes it from the `package.json` file.
+
+ _Note: If the platform definition existed in `config.xml` from a previous version of Cordova CLI, it will also be removed from `config.xml`._
+
+* **`cordova platform remove android --nosave`**
+
+ Removes the `cordova-android` platform from the project, but does not remove it from the `package.json` file.
+
+### Restoring Platforms
+
+Platforms are automatically restored from the `package.json` (and `config.xml`) when executing the **`cordova prepare`** command.
+
+If a platform is defined in both files, the information defined in `package.json` is used as the source of truth.
+
+After `prepare`, any platforms restored from `config.xml` will update the `package.json` file to reflect the values taken from `config.xml`.
+
+If you add a platform without specifying a `<version | folder | git_url>`, the version that will be installed is taken from `package.json` or `config.xml`.
+
+**If discovered** in both files, `package.json` is given higher priority over `config.xml`.
+
+Example:
+
+Suppose your `config.xml` file contains the following entry:
+
+```xml
+<?xml version='1.0' encoding='utf-8'?>
+ ...
+ <engine name="android" spec="7.1.4" />
+ ...
+</xml>
+```
+
+If you run the command **`cordova platform add android`** with no `<version | folder | git_url>` specified, the platform `android@7.1.4` will be retrieved and installed.
+
+**Example Order of Priority for Restoring Platforms:**
+
+Suppose you have defined in `config.xml` and `package.json` a platform and version as follows:
+
+**`config.xml`**:
+
+```xml
+<engine name="android" spec=“7.4.1” />
+```
+
+**`package.json`**:
+
+```json
+"cordova": {
+ "platforms": [
+ "android"
+ ]
+},
+"dependencies": {
+ "cordova-android": "^8.0.0"
+}
+```
+
+When `prepare` is executed, the version from `package.json` has higher priority over `config.xml` and version `^8.0.0` will be installed.
+
+---
+
+## Plugin Versioning
+
+The plugin commands are a mirror of the platform commands:
+
+### Saving Plugins
+
+To save a plugin, you issue the following command:
+
+```bash
+cordova plugin add <plugin[@<version>] | directory | git_url>
+```
+
+After running the above command, the **`package.json`** should contain something as seen below:
+
+```json
+"cordova": {
+ "plugins": [
+ "cordova-plugin-device"
+ ]
+},
+"devDependencies": {
+ "cordova-plugin-device": "^1.0.0"
+}
+```
+
+The `--nosave` flag prevents adding and deleting specified plugins from `package.json`. To prevent saving a plugin, you issue the following command:
+
+```bash
+cordova plugin add <plugin[@<version>] | directory | git_url> --nosave
+```
+
+Some Examples:
+
+* **`cordova plugin add cordova-plugin-device`**
+
+ Retrieves the pinned version of the `cordova-plugin-device` plugin from npm, adds it to the project and updates the `package.json` file.
+
+* **`cordova plugin add cordova-plugin-device@2.0.1`**
+
+ Retrieves the `cordova-plugin-device` plugin at version `2.0.1` from npm, adds it to the project and updates the `package.json` file.
+
+* **`cordova plugin add https://github.com/apache/cordova-plugin-device.git`**
+
+ **`cordova plugin add https://github.com/apache/cordova-plugin-device`**
+
+ **`cordova plugin add github:apache/cordova-plugin-device`**
+
+ npm retrieves the `cordova-plugin-device` plugin from the git repository, adds it to the project and updates the `package.json`.
+
+* **`cordova plugin add C:/path/to/console/plugin`**
+
+ Retrieves the `cordova-plugin-device` plugin from the specified directory, adds it to the project, and updates the `package.json` file.
+
+### Mass Saving of Plugins on an Existing Project
+
+If you have a pre-existing project and you want to save all currently added plugins in the project, you can use:
+
+```bash
+cordova plugin save
+```
+
+### Removing Plugins
+
+It is possible to delete a plugin from `config.xml` and `package.json` with one of the following commands:
+
+```bash
+cordova plugin remove <plugin>
+cordova plugin rm <plugin>
+```
+
+For Example:
+
+* **`cordova plugin remove cordova-plugin-device`**
+
+ Removes the `cordova-plugin-device` plugin from the project and deletes its entry from `package.json`.
+
+ _Note: If the plugin definition existed in `config.xml` from a previous version of Cordova CLI, it will also be removed from `config.xml`._
+
+### Restoring Plugins
+
+Plugins are automatically restored from `package.json` and `config.xml` when executing the **`cordova prepare`** command.
+
+If a plugin is defined in both files, the information defined in `package.json` is used as the source of truth.
+
+After `prepare`, any plugins restored from `config.xml` will update the `package.json` file to reflect the values taken from `config.xml`.
+
+If you add a plugin without specifying a `<version | folder | git_url>`, the version that will be installed is taken from `package.json` or `config.xml`.
+
+**If discovered** in both files, `package.json` is given higher priority over `config.xml`.
+
+Example:
+
+Suppose your `config.xml` file contains the following entry:
+
+```xml
+<?xml version='1.0' encoding='utf-8'?>
+ ...
+ <plugin name="cordova-plugin-device" spec="2.0.1" />
+ ...
+</ xml>
+```
+
+If you run the command **`cordova plugin add cordova-plugin-device`** with no `<version | folder | git_url>` specified, the platform `cordova-plugin-device@2.0.1` will be retrieved and installed.
+
+**Example Order of Priority for Restoring Plugins:**
+
+Suppose you have defined in `config.xml` and `package.json` a plugin and version as follows:
+
+**`config.xml`**:
+
+```xml
+<plugin name="cordova-plugin-splashscreen"/>
+```
+
+**`package.json`**:
+
+```json
+"cordova": {
+ "plugins": [
+ "cordova-plugin-splashscreen"
+ ]
+},
+"devDependencies": {
+ "cordova-plugin-splashscreen": "1.0.0"
+}
+```
+
+When `prepare` is executed, the version from `package.json` has higher priority over `config.xml` and version `1.0.0` will be installed.
diff --git a/www/docs/en/11.x/plugin_ref/plugman.md b/www/docs/en/11.x/plugin_ref/plugman.md
new file mode 100644
index 0000000..79fc7b6
--- /dev/null
+++ b/www/docs/en/11.x/plugin_ref/plugman.md
@@ -0,0 +1,276 @@
+---
+license: >
+ Licensed to the Apache Software Foundation (ASF) under one
+ or more contributor license agreements. See the NOTICE file
+ distributed with this work for additional information
+ regarding copyright ownership. The ASF licenses this file
+ to you under the Apache License, Version 2.0 (the
+ "License"); you may not use this file except in compliance
+ with the License. You may obtain a copy of the License at
+
+ http://www.apache.org/licenses/LICENSE-2.0
+
+ Unless required by applicable law or agreed to in writing,
+ software distributed under the License is distributed on an
+ "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ KIND, either express or implied. See the License for the
+ specific language governing permissions and limitations
+ under the License.
+
+title: Using Plugman to Manage Plugins
+toc_title: Use Plugman
+description: Manage plugins without the CLI when using the platform-centered workflow.
+---
+
+# Using Plugman to Manage Plugins
+
+From version 3.0 onward, Cordova implements all device APIs as
+plugins, and leaves them disabled by default. It also supports two
+different ways to add and remove plugins, depending on your choice of
+workflow discussed in the [Overview](../guide/overview/index.html):
+
+- If you use a cross-platform workflow, you use the `cordova` CLI
+ utility to add plugins, as described in [The Command-Line Interface](../guide/cli/index.html).
+ The CLI modifies plugins for all specified platforms at once.
+
+- If you use a platform-centered workflow, you use a lower-level
+ [Plugman](https://github.com/apache/cordova-plugman/) command-line
+ interface, separately for each targeted platform.
+
+This section details the Plugman utility. For more information on
+consuming Plugman as a node module or modifying the source code, see
+[the README file in its repository](https://github.com/apache/cordova-plugman/blob/master/README.md).
+
+## Installing Plugman
+
+To install plugman, you must have [node](http://nodejs.org/) installed
+on your machine. Then you can run the following command from anywhere
+in your environment to install plugman globally, so that it is
+available from any directory:
+
+ $ npm install -g plugman
+
+You must have also have `git` on your `PATH` to be able to install plugins directly from remote git URLs.
+
+__TIP__: If you find that after installing plugman with `npm` you are
+still unable to run any `plugman` commands, make sure that you have
+added the `/npm/` directory into your `PATH`.
+
+__NOTE__: You can skip this step if you don't want to pollute your
+global `npm` namespace by installing Plugman globally. If this is the
+case, then when you create a Cordova project with the shell tools,
+there will be a `node_modules` directory inside your project which
+contains Plugman. Since you did not install globally, you need to
+invoke `node` for each Plugman command, for example `node
+./node_modules/plugman/main.js -version`. The rest of this guide
+assumes you have installed Plugman globally, meaning you can invoke it
+with just `plugman`.
+
+## Create a Cordova Project
+
+Before you can use Plugman, you must create a Cordova project. You can do this with either the Command-line Interface or with
+the lower level shell scripts. Instructions for using the shell scripts to create your project are located in the various "Command-line Tools" guides
+listed on the Platform guides page.
+
+## Adding a Plugin
+
+Once you have installed Plugman and have created a Cordova project, you can start adding plugins to the platform with:
+
+```bash
+$ plugman install --platform <ios|android> --project <directory> --plugin <name|url|path> [--plugins_dir <directory>] [--www <directory>] [--variable <name>=<value> [--variable <name>=<value> ...]]
+```
+
+Using minimum parameters, this command installs a plugin into a cordova project. You must specify a platform and cordova project location for that platform. You also must specify a plugin, with the different `--plugin` parameter forms being:
+
+ * `name`: The directory name where the plugin contents exist. This must be an existing directory under the `--plugins_dir` path (see below for more info) or a plugin in the Cordova registry.
+ * `url`: A URL starting with https:// or git://, pointing to a valid git repository that is clonable and contains a `plugin.xml` file. The contents of this repository would be copied into the `--plugins_dir`.
+ * `path`: A path to a directory containing a valid plugin which includes a `plugin.xml` file. This path's contents will be copied into the `--plugins_dir`.
+
+Other parameters:
+
+* `--plugins_dir` defaults to `<project>/cordova/plugins`, but can be any directory containing a subdirectory for each fetched plugin.
+* `--www` defaults to the project's `www` folder location, but can be any directory that is to be used as cordova project application web assets.
+* `--variable` allows to specify certain variables at install time, necessary for certain plugins requiring API keys or other custom, user-defined parameters. Please see the [plugin specification](spec.html#Plugin%20Specification) for more information.
+
+## Remove a Plugin
+
+To uninstall a plugin, you simply pass the `uninstall` command and provide the plugin ID.
+
+```bash
+$ plugman uninstall --platform <ios|android> --project <directory> --plugin <id> [--www <directory>] [--plugins_dir <directory>]
+```
+
+## Help Commands
+
+Plugman features a global help command which may help you if you get stuck or are experiencing problems. It will display
+a list of all available Plugman commands and their syntax:
+
+```bash
+plugman -help
+plugman # same as above
+```
+
+**NOTE**: `plugman -help` may show some additional registry-related commands. These commands are for plugin developers and may not be implemented on third-party plugin registries.
+
+
+You can also append the `--debug|-d` flag to any Plugman command to run that command in verbose mode, which will display
+any internal debugging messages as they are emitted and may help you track down problems like missing files.
+
+```bash
+# Adding Android battery-status plugin to "myProject":
+plugman -d install --platform android --project myProject --plugin cordova-plugin-battery-status
+```
+
+Finally, you can use the `--version|-v` flag to see which version of Plugman you are using.
+
+```bash
+plugman -v
+```
+
+## Registry Actions
+
+There are a number of plugman commands that can be used for interacting with the [Plugin registry](http://plugins.cordova.io).
+Please note that these registry commands are specific to the _plugins.cordova.io_ plugin registry and may not be implemented by
+third-party plugin registries.
+
+### Searching for a Plugin
+
+You can use Plugman to search the [Plugin registry](http://plugins.cordova.io) for plugin id's that match the given space separated list of keywords.
+
+```bash
+plugman search <plugin keywords>
+```
+
+### Changing the Plugin Registry
+
+You can get or set the URL of the current plugin registry that plugman is using. Generally you should leave this set at http://registry.cordova.io unless you want to use a third party plugin registry.
+
+```bash
+plugman config set registry <url-to-registry>
+plugman config get registry
+```
+
+### Get Plugin Information
+
+You can get information about any specific plugin stored in the plugin repository with:
+
+```bash
+plugman info <id>
+```
... 8273 lines suppressed ...
---------------------------------------------------------------------
To unsubscribe, e-mail: commits-unsubscribe@cordova.apache.org
For additional commands, e-mail: commits-help@cordova.apache.org