You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@cordova.apache.org by er...@apache.org on 2023/09/15 04:03:06 UTC
[cordova-docs] branch master updated: doc(snapshot): create 12.x (#1334)
This is an automated email from the ASF dual-hosted git repository.
erisu 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 73ab293df5 doc(snapshot): create 12.x (#1334)
73ab293df5 is described below
commit 73ab293df584efb856698bef9c6cc63c8d92665c
Author: エリス <er...@users.noreply.github.com>
AuthorDate: Fri Sep 15 13:03:00 2023 +0900
doc(snapshot): create 12.x (#1334)
---
VERSION | 2 +-
www/_data/toc/en_12-x-src.yml | 85 ++
www/docs/en/12.x/config_ref/images.md | 238 ++++++
www/docs/en/12.x/config_ref/index.md | 523 ++++++++++++
www/docs/en/12.x/cordova/events/events.md | 406 ++++++++++
www/docs/en/12.x/cordova/storage/storage.md | 240 ++++++
.../en/12.x/core/features/splashscreen/index.md | 603 ++++++++++++++
www/docs/en/12.x/guide/appdev/allowlist/index.md | 205 +++++
www/docs/en/12.x/guide/appdev/hooks/index.md | 406 ++++++++++
www/docs/en/12.x/guide/appdev/privacy/index.md | 113 +++
www/docs/en/12.x/guide/appdev/security/index.md | 106 +++
www/docs/en/12.x/guide/cli/index.md | 244 ++++++
www/docs/en/12.x/guide/cli/installation.md | 86 ++
www/docs/en/12.x/guide/cli/template.md | 75 ++
www/docs/en/12.x/guide/hybrid/plugins/index.md | 371 +++++++++
www/docs/en/12.x/guide/hybrid/webviews/index.md | 39 +
www/docs/en/12.x/guide/next/index.md | 222 ++++++
www/docs/en/12.x/guide/overview/index.md | 164 ++++
www/docs/en/12.x/guide/platforms/android/index.md | 852 ++++++++++++++++++++
www/docs/en/12.x/guide/platforms/android/plugin.md | 517 ++++++++++++
.../en/12.x/guide/platforms/android/upgrade.md | 659 +++++++++++++++
.../en/12.x/guide/platforms/android/webview.md | 134 ++++
www/docs/en/12.x/guide/platforms/electron/index.md | 466 +++++++++++
www/docs/en/12.x/guide/platforms/ios/index.md | 362 +++++++++
www/docs/en/12.x/guide/platforms/ios/plugin.md | 274 +++++++
www/docs/en/12.x/guide/platforms/ios/upgrade.md | 855 ++++++++++++++++++++
www/docs/en/12.x/guide/platforms/ios/webview.md | 224 ++++++
www/docs/en/12.x/guide/support/index.md | 198 +++++
www/docs/en/12.x/index.md | 23 +
www/docs/en/12.x/platform_pinning/index.md | 71 ++
.../12.x/platform_plugin_versioning_ref/index.md | 356 +++++++++
www/docs/en/12.x/plugin_ref/plugman.md | 276 +++++++
www/docs/en/12.x/plugin_ref/spec.md | 675 ++++++++++++++++
www/docs/en/12.x/reference/cordova-cli/index.md | 689 ++++++++++++++++
.../cordova-plugin-battery-status/index.md | 113 +++
.../12.x/reference/cordova-plugin-camera/index.md | 693 ++++++++++++++++
.../12.x/reference/cordova-plugin-device/index.md | 313 ++++++++
.../12.x/reference/cordova-plugin-dialogs/index.md | 291 +++++++
.../en/12.x/reference/cordova-plugin-file/index.md | 888 +++++++++++++++++++++
.../reference/cordova-plugin-geolocation/index.md | 785 ++++++++++++++++++
.../reference/cordova-plugin-inappbrowser/index.md | 726 +++++++++++++++++
.../cordova-plugin-media-capture/index.md | 637 +++++++++++++++
.../12.x/reference/cordova-plugin-media/index.md | 712 +++++++++++++++++
.../cordova-plugin-network-information/index.md | 320 ++++++++
.../cordova-plugin-screen-orientation/index.md | 127 +++
.../reference/cordova-plugin-splashscreen/index.md | 188 +++++
.../reference/cordova-plugin-statusbar/index.md | 292 +++++++
.../reference/cordova-plugin-vibration/index.md | 152 ++++
www/docs/en/12.x/third-party/index.md | 58 ++
49 files changed, 17053 insertions(+), 1 deletion(-)
diff --git a/VERSION b/VERSION
index 248e7548b3..48dd7885f5 100644
--- a/VERSION
+++ b/VERSION
@@ -1 +1 @@
-11.x
+12.x
diff --git a/www/_data/toc/en_12-x-src.yml b/www/_data/toc/en_12-x-src.yml
new file mode 100644
index 0000000000..4948dfdf9c
--- /dev/null
+++ b/www/_data/toc/en_12-x-src.yml
@@ -0,0 +1,85 @@
+-
+ name: Getting Started
+ children:
+ - url: guide/overview/index.html
+ - url: guide/cli/installation.html
+ - url: guide/cli/index.html
+
+-
+ name: Cordova Projects
+ children:
+ - url: reference/cordova-cli/index.html
+ - url: guide/support/index.html
+ - url: platform_pinning/index.html
+ - url: platform_plugin_versioning_ref/index.html
+ - url: guide/appdev/hooks/index.html
+
+-
+ name: App Development
+ children:
+ -
+ name: Platforms
+ children:
+ - url: guide/platforms/android/index.html
+ - url: guide/platforms/ios/index.html
+ - url: guide/platforms/electron/index.html
+ -
+ name: Customization
+ children:
+ - url: config_ref/images.html
+ - url: core/features/splashscreen/index.html
+ -
+ name: Security & Privacy
+ children:
+ - url: guide/appdev/security/index.html
+ - url: guide/appdev/privacy/index.html
+ - url: guide/appdev/allowlist/index.html
+ - url: cordova/storage/storage.html
+
+-
+ name: Plugin Development
+ children:
+ - url: guide/hybrid/plugins/index.html
+ -
+ name: Support a Platform
+ children:
+ - url: guide/platforms/android/plugin.html
+ - url: guide/platforms/ios/plugin.html
+ - url: plugin_ref/plugman.html
+
+-
+ name: References
+ children:
+ - url: config_ref/index.html
+ - url: plugin_ref/spec.html
+ - url: cordova/events/events.html
+
+-
+ name: Resources
+ children:
+ - url: third-party/index.html
+ - url: guide/cli/template.html
+ - url: guide/next/index.html
+
+-
+ name: Plugins
+ 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
+
+-
+ name: Advanced Topics
+ children:
+ - url: guide/hybrid/webviews/index.html
diff --git a/www/docs/en/12.x/config_ref/images.md b/www/docs/en/12.x/config_ref/images.md
new file mode 100644
index 0000000000..4a08e0e8da
--- /dev/null
+++ b/www/docs/en/12.x/config_ref/images.md
@@ -0,0 +1,238 @@
+---
+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: Icons
+description: Learn how to customize icons for your Cordova application.
+---
+
+{% cdv_platform inject %}
+
+# 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/> {% cdv_platform electron %} <br/> Set target to supply unique icons for `application` and `installer`
+
+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
+
+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 in Cordova, at minimum **Cordova CLI** 9.0.0 and **Cordova-Android** 8.0.0 is required.
+
+Android 13 has introduced themed icons which are monochrome images appended to the existing **Adaptive Icons**. To use Themed Icon in Cordova, at minimum **Cordova CLI** 12.0.0 and **Cordova-Android** 12.0.0 is required.
+
+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
+monochrome | *Optional for Adaptive but required for themed icons* <br/> Location of the image (png or vector) relative to your project directory
+density | *Required* <br/> Specified icon density
+
+### Adaptive Icons
+
+To use the adaptive icons the `background`, `foreground` and optionally `monochrome` 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 monochrome="res/icon/android/ldpi-monochrome.png" background="res/icon/android/ldpi-background.png" density="ldpi" foreground="res/icon/android/ldpi-foreground.png" />
+ <icon monochrome="res/icon/android/mdpi-monochrome.png" background="res/icon/android/mdpi-background.png" density="mdpi" foreground="res/icon/android/mdpi-foreground.png" />
+ <icon monochrome="res/icon/android/hdpi-monochrome.png" background="res/icon/android/hdpi-background.png" density="hdpi" foreground="res/icon/android/hdpi-foreground.png" />
+ <icon monochrome="res/icon/android/xhdpi-monochrome.png" background="res/icon/android/xhdpi-background.png" density="xhdpi" foreground="res/icon/android/xhdpi-foreground.png" />
+ <icon monochrome="res/icon/android/xxhdpi-monochrome.png" background="res/icon/android/xxhdpi-background.png" density="xxhdpi" foreground="res/icon/android/xxhdpi-foreground.png" />
+ <icon monochrome="res/icon/android/xxxhdpi-monochrome.png" 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 monochrome="res/icon/android/ldpi-monochrome.png" background="res/icon/android/ldpi-background.xml" density="ldpi" foreground="res/icon/android/ldpi-foreground.xml" src="res/android/ldpi.png" />
+ <icon monochrome="res/icon/android/mdpi-monochrome.png" background="res/icon/android/mdpi-background.xml" density="mdpi" foreground="res/icon/android/mdpi-foreground.xml" src="res/android/mdpi.png" />
+ <icon monochrome="res/icon/android/hdpi-monochrome.png" background="res/icon/android/hdpi-background.xml" density="hdpi" foreground="res/icon/android/hdpi-foreground.xml" src="res/android/hdpi.png" />
+ <icon monochrome="res/icon/android/xhdpi-monochrome.png" background="res/icon/android/xhdpi-background.xml" density="xhdpi" foreground="res/icon/android/xhdpi-foreground.xml" src="res/android/xhdpi.png" />
+ <icon monochrome="res/icon/android/xxhdpi-monochrome.png" background="res/icon/android/xxhdpi-background.xml" density="xxhdpi" foreground="res/icon/android/xxhdpi-foreground.xml" src="res/android/xxhdpi.png" />
+ <icon monochrome="res/icon/android/xxxhdpi-monochrome.png" 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 monochrome="res/icon/android/ldpi-monochrome.png" background="@color/background" density="ldpi" foreground="res/icon/android/ldpi-foreground.png" />
+ <icon monochrome="res/icon/android/mdpi-monochrome.png" background="@color/background" density="mdpi" foreground="res/icon/android/mdpi-foreground.png" />
+ <icon monochrome="res/icon/android/hdpi-monochrome.png" background="@color/background" density="hdpi" foreground="res/icon/android/hdpi-foreground.png" />
+ <icon monochrome="res/icon/android/xhdpi-monochrome.png" background="@color/background" density="xhdpi" foreground="res/icon/android/xhdpi-foreground.png" />
+ <icon monochrome="res/icon/android/xxhdpi-monochrome.png" background="@color/background" density="xxhdpi" foreground="res/icon/android/xxhdpi-foreground.png" />
+ <icon monochrome="res/icon/android/xxxhdpi-monochrome.png" 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 Adaptive icons - User theming](https://developer.android.com/develop/ui/views/launch/icon_design_adaptive#user-theming)
+- [Android - Supporting multiple screens](https://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)
+
+[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/12.x/config_ref/index.md b/www/docs/en/12.x/config_ref/index.md
new file mode 100644
index 0000000000..ecbd30ec7b
--- /dev/null
+++ b/www/docs/en/12.x/config_ref/index.md
@@ -0,0 +1,523 @@
+---
+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 API
+description: List of supported tags in the config.xml file.
+---
+
+{% cdv_platform inject %}
+
+# Config.xml API
+
+The `config.xml` file is a global configuration file that manages various aspects of a Cordova application's behavior. It is written in XML format and follows the structure outlined in the W3C's [Packaged Web Apps (Widgets)](https://www.w3.org/TR/widgets/) specification. Additionally, it is extended to include core Cordova API features, plugins, and platform-specific settings.
+
+If you are using the Cordova CLI to create your project (as explained in [The Command-Line Interface](../guide/cli/index.html)), you can locate the `config.xml` file in the top-level directory of your project.
+
+```bash
+./hellocordova
+└── config.xml
+```
+
+When using the CLI to build a project, versions of this file are passively copied into various `platforms/` subdirectories. For example:
+
+```bash
+./hellocordova
+└── platforms
+ ├── android
+ │ └── app
+ │ └── src
+ │ └── main
+ │ └── res
+ │ └── xml
+ │ └── config.xml
+ └── ios
+ └── HelloCordova
+ └── config.xml
+```
+
+Some platforms offer integrated development environments (IDEs) like Xcode for iOS and Android Studio for Android, which allow you to build and test your application. If you choose to use these IDEs for building and testing your project, it is recommended to run the `cordova prepare` CLI command whenever you make changes to the Cordova application's `config.xml`. This ensures that the updated configurations are copied into the respective `platforms/` subdirectories.
+
+In addition to the configuration options described below, you have the ability to customize the core set of images for your application on each target platform. For more information, please refer to the topic on [Customizing Icons](images.html).
+
+**Sample `config.xml`:**
+
+```xml
+<?xml version="1.0" encoding="UTF-8"?>
+<widget xmlns="http://www.w3.org/ns/widgets"
+ xmlns:cdv="http://cordova.apache.org/ns/1.0"
+ id="io.cordova.hellocordova"
+ version="1.0.0">
+ <name>HelloCordova</name>
+ <description>Sample Apache Cordova App</description>
+ <author email="dev@cordova.apache.org" href="https://cordova.apache.org">
+ Apache Cordova Team
+ </author>
+
+ <content src="index.html" />
+
+ <!-- Security Related Settings -->
+ <access origin="https://cordova.apache.org" />
+ <allow-intent href="http://*/*" />
+ <allow-intent href="https://*/*" />
+
+ <!-- Platform Configs & Platform Overriding Configs -->
+ <platform name="android"></platform>
+ <platform name="ios"></platform>
+</widget>
+```
+
+## widget
+
+Root element of the config.xml document.
+
+Attributes | Description
+---------------- | ------------
+id<br/>{% cdv_vartype 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<br/>{% cdv_vartype string %} | *Required* <br/> Full version number expressed in major/minor/patch notation.
+android-versionCode<br/>{% cdv_vartype string %} {% cdv_platform android %} | Alternative version for Android. Sets the [version code](https://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<br/>{% cdv_vartype string %} {% cdv_platform ios %} | Alternative version for iOS. For further details, see [Apple Developer - CFBundleVersion](https://developer.apple.com/documentation/bundleresources/information_property_list/cfbundleversion).
+android-packageName<br/>{% cdv_vartype string %} {% cdv_platform android %} | This preference overrides the id attribute with an alternative package name specifically for Android.
+ios-CFBundleIdentifier<br/>{% cdv_vartype string %} {% cdv_platform ios %} | This preference overrides the id attribute with an alternative bundle ID specifically for iOS.
+defaultlocale <br /> {% cdv_vartype string %}{% cdv_platform ios %} | Specify the default language of the app using an IANA language code. This preference key explicitly sets the value for [CFBundleDevelopmentRegion](https://developer.apple.com/documentation/bundleresources/information_property_list/cfbundledevelopmentregion). For example, you can use values like `en` or `en_US`.
+android-activityName<br/>{% cdv_vartype string %} {% cdv_platform 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<br/>{% cdv_vartype string %} | *Required* <br/> Namespace for the config.xml document.
+xmlns:cdv<br/>{% cdv_vartype 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>
+```
+
+## 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 | Description
+----------------- | ------------
+email<br/>{% cdv_vartype string %} | *Required* <br/> Email of the author.
+href<br/>{% cdv_vartype string %} | *Required* <br/> Website of the author.
+
+Examples:
+
+```xml
+<widget ...>
+ <author email="dev@cordova.apache.org" href="https://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 | Description
+----------------- | ------------
+src<br/>{% cdv_vartype 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 external domains that the app is allowed to communicate with. When the access origin is set to "*", the app can access any server, but this can potentially create a security risk. It is recommended to explicitly specify the permitted URLs to ensure a secure configuration. For detailed instructions, please refer to the [Allow List Guide](../guide/appdev/allowlist/index.html).
+
+Attributes | Description
+----------------- | ------------
+origin<br/>{% cdv_vartype string %} | *Required* <br/> Defines the external domain URL or URL pattern that the app is allowed to communicate with.
+
+Examples:
+
+```xml
+<widget ...>
+ <access origin="*"></access>
+</widget>
+
+<widget ...>
+ <access origin="http://google.com"></access>
+</widget>
+```
+
+## allow-navigation
+
+Controls which URLs the WebView can be navigated to. Applies to top-level navigations only. See the [Allow List Guide][allow_list_navigation] for details.
+
+Attributes | Description
+----------------- | ------------
+href<br/>{% cdv_vartype string %} | *Required* <br/> Defines the external domain or domain pattern that the WebView is allowed to navigate to.
+
+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. See the [Allow List Guide][allow_list_intent] for details.
+
+Attributes | Description
+----------------- | ------------
+href<br/>{% cdv_vartype string %} | *Required* <br/> Defines the URL or URL pattern that the app is allowed to ask the system to open.
+
+Examples:
+
+```xml
+<allow-intent href="http://*/*" />
+<allow-intent href="https://*/*" />
+<allow-intent href="tel:*" />
+<allow-intent href="sms:*" />
+```
+
+## edit-config
+
+See [<config-file> 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 | Description
+----------------- | ------------
+name<br/>{% cdv_vartype string %} | *Required* <br/> Name of the platform to be restored
+spec<br/>{% cdv_vartype 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.
+
+_Note: As of Cordova 9.x, this tag is obsolete. [Learn More](https://github.com/apache/cordova-lib/pull/750)_
+
+Attributes | Description
+----------------- | ------------
+name<br/>{% cdv_vartype string %} | *Required* <br/> Name of the plugin to be restored
+spec<br/>{% cdv_vartype 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 | Description
+----------------- | ------------
+name<br/>{% cdv_vartype string %} | *Required* <br/> Name of the CLI variable. Can only contain capital letters, digits, and underscores.
+value<br/>{% cdv_vartype 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 | Description
+----------------- | ------------
+AllowInlineMediaPlayback<br/>{% cdv_vartype boolean %} {% cdv_platform 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<br/>{% cdv_vartype boolean %} {% cdv_platform 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<br/>{% cdv_vartype string %} {% cdv_platform 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<br/>{% cdv_vartype boolean %} {% cdv_platform 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<br/>{% cdv_vartype number %} {% cdv_platform 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<br/>{% cdv_vartype number %} {% cdv_platform android %} | *Default: [Dependent on cordova-android Version](../../guide/platforms/android/index.html#android-api-level-support)* <br/> Sets the `minSdkVersion` attribute of the `<uses-sdk>` tag in the project's `AndroidManifest.xml` (see [here][uses-sdk]).
+android-targetSdkVersion<br/>{% cdv_vartype number %} {% cdv_platform android %} | *Default: [Dependent on cordova-android Version](../../guide/platforms/android/index.html#android-api-level-support)* <br/> Sets the `targetSdkVersion` attribute of the `<uses-sdk>` tag in the project's `AndroidManifest.xml` (see [here][uses-sdk]).
+android-compileSdkVersion<br/>{% cdv_vartype number %} {% cdv_platform android %} | *Default: [Dependent on cordova-android Version](../../guide/platforms/android/index.html#android-api-level-support)* <br/> Sets the `compileSdkVersion` attribute.
+android-buildToolsVersion<br/>{% cdv_vartype semver %} {% cdv_platform android %} | *Default: [Dependent on cordova-android Version](../../guide/platforms/android/index.html#android-api-level-support)* <br/> Expects a full version string eg. "32.0.0". Changing this may also requires changing the PATH environment variable to find the proper build tools.<br/><br/>This preference is primarily for cordova development, for testing upcoming versions of the Android SDK. Changing this has a high [...]
+GradleVersion<br/>{% cdv_vartype string %} {% cdv_platform android %} | *Default: [Dependent on cordova-android Version](../../guide/platforms/android/index.html#android-api-level-support)* <br/> Sets the gradle wrapper version to use.<br/> <br/>This preference is primarily for cordova development, for testing upcoming versions of the Android SDK. Changing this has a high risk of breaking builds as newer build tools frequently introduce breaking changes.
+AndroidGradlePluginVersion<br/>{% cdv_vartype semver %} {% cdv_platform android %} | *Default: [Dependent on cordova-android Version](../../guide/platforms/android/index.html#android-api-level-support)* <br/> Sets the Android Gradle Plugin version to use.<br/> <br/>This preference is primarily for cordova development, for testing upcoming versions of the Android SDK. Changing this has a high risk of breaking builds as newer build tools frequently introduce breaking changes.
+AndroidXAppCompatVersion<br/>{% cdv_vartype semver %} {% cdv_platform android %} | *Default: [Dependent on cordova-android Version](../../guide/platforms/android/index.html#android-api-level-support)* <br/> Overrides Android App Compat library version.
+AndroidXWebKitVersion<br/>{% cdv_vartype semver %} {% cdv_platform android %} | *Default: [Dependent on cordova-android Version](../../guide/platforms/android/index.html#android-api-level-support)* <br/>Overrides Android WebKit library version.
+AndroidGradlePluginGoogleServicesVersion<br/>{% cdv_vartype semver %} {% cdv_platform android %} | *Default: [Dependent on cordova-android Version](../../guide/platforms/android/index.html#android-api-level-support)* <br/>Overrides the Google Services library version.
+AndroidGradlePluginGoogleServicesEnabled<br/>{% cdv_vartype boolean %} {% cdv_platform android %} | *Default: false* <br/>Enables Google Services. The `google-services.json` file will be required.
+GradlePluginKotlinEnabled<br/>{% cdv_vartype boolean %} {% cdv_platform android %} | *Default: false* <br/>Enables Kotlin plugin for Kotline support.
+AppendUserAgent<br/>{% cdv_vartype string %} {% cdv_platform android %} {% cdv_platform 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<br/>{% cdv_vartype string %} {% cdv_platform android %} {% cdv_platform ios %} | 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/>__Note__: `transparent` value will set the application tile background to the accent color on Windows.
+CordovaWebViewEngine<br/>{% cdv_vartype string %} {% cdv_platform 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<br/>{% cdv_vartype string %} {% cdv_platform 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 ob [...]
+DisallowOverscroll<br/>{% cdv_vartype boolean %} {% cdv_platform ios %} {% cdv_platform 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<br/>{% cdv_vartype boolean %} {% cdv_platform 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' />```
+ErrorUrl<br/>{% cdv_vartype url %} {% cdv_platform android %} {% cdv_platform ios %} | *Default: null* <br/>When this preference is set, the application will display the specified local page upon encountering an error. Additionally, if this preference is set, the Android system will suppress the default dialog titled "Application Error".
+FullScreen<br/>{% cdv_vartype boolean %} {% cdv_platform 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<br/>{% cdv_vartype float %} {% cdv_platform ios %} | *Default: 0* <br/> The size of the gap, in points, between pages.
+GradlePluginGoogleServicesEnabled<br/>{% cdv_vartype boolean %} {% cdv_platform android %} | *Default: false* <br/> Set to true to enable the Google Services Gradle plugin.
+GradlePluginGoogleServicesEnabled<br/>{% cdv_vartype semver %} {% cdv_platform android %} | *Default: 4.2.0* <br/> Set version of Google Services Gradle plugin to be used.
+GradlePluginKotlinEnabled<br/>{% cdv_vartype boolean %} {% cdv_platform android %} | *Default: false* <br/> Set to true to allow Kotlin files to be built.
+GradlePluginKotlinCodeStyle <br/>{% cdv_vartype string %} {% cdv_platform android %} | *Default: official* <br/> Allowed values: official, obsolete<br/> Sets how the Kotlin code is formatting for readability.
+GradlePluginKotlinVersion<br/>{% cdv_vartype semver %} {% cdv_platform android %} | *Default: 1.3.50* <br/> Set the version of the Kotlin Gradle plugin to be used.
+InAppBrowserStorageEnabled<br/>{% cdv_vartype boolean %} {% cdv_platform 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.
+InspectableWebview<br/>{% cdv_vartype boolean %} {% cdv_platform android %} {% cdv_platform ios %} | *Default: depends on Debug/Release build* <br/> On iOS 16.4 or later, enables or disables the webview inspector. Defaults to `true` on debug builds and `false` on release builds. This preference is ignored on iOS 16.3 and earlier; the inspector is always enabled on debug builds and always disabled on release builds.
+KeepRunning<br/>{% cdv_vartype boolean %} {% cdv_platform android %} | *Default: true* <br/> Determines whether the application stays running in the background even after a [pause](../cordova/events/events.html#pause) event fires. Setting this to false does not kill the app after a [pause](../cordova/events/events.html#pause) event, but simply halts execution of code within the cordova webview while the app is in the background.
+KeyboardDisplayRequiresUserAction<br/>{% cdv_vartype boolean %} {% cdv_platform ios %} | *Default: true* <br/> Set to false to allow the keyboard to appear when calling focus() on form inputs.
+LoadUrlTimeoutValue<br/>{% cdv_vartype number %} {% cdv_platform android %} | *Default: 20000, 20 seconds* <br/> When loading a page, the amount of time in miliseconds to wait before throwing a timeout error.
+LoadingDialog<br/>{% cdv_vartype string %} {% cdv_platform 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<br/>{% cdv_vartype string %} {% cdv_platform 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<br/>{% cdv_vartype boolean %} {% cdv_platform ios %} | *Default: true* <br/> Set to false to prevent Air Play from being used in this view. Available in default UIWebView and WKWebView.
+MediaPlaybackRequiresUserAction<br/>{% cdv_vartype boolean %} {% cdv_platform ios %} | *Default: false* <br/> Set to true to prevent HTML5 videos or audios from playing automatically with the autoplay attribute or via JavaScript.
+Orientation<br/>{% cdv_vartype 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 [...]
+OverrideUserAgent<br/>{% cdv_vartype string %} {% cdv_platform android %} {% cdv_platform 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<br/>{% cdv_vartype float %} {% cdv_platform 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<br/>{% cdv_vartype string %} {% cdv_platform 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<br/>{% cdv_vartype string %} {% cdv_platform 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 GapBetw [...]
+PreferredContentMode<br/>{% cdv_vartype string %} {% cdv_platform 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<br/>{% cdv_vartype string %} {% cdv_platform ios %} | *Default: default* <br/> Set text color style of the StatusBar for InAppBrowser for iOS. Valid values are: `lightcontent` and `default`.
+SetFullscreen<br/>{% cdv_vartype boolean %} {% cdv_platform 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<br/>{% cdv_vartype boolean %} {% cdv_platform android %} | *Default: false* <br/> Show the title at the top of the screen.
+Suppresses3DTouchGesture<br/>{% cdv_vartype boolean %} {% cdv_platform 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<br/>{% cdv_vartype boolean %} {% cdv_platform ios %} | *Default: false* <br/> Set to true to wait until all content has been received before it renders to the screen.
+SuppressesLongPressGesture<br/>{% cdv_vartype boolean %} {% cdv_platform 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<br/>{% cdv_vartype string %} {% cdv_platform ios %} | *Default: (empty)* <br /> Set to specify the Swift Version.
+TopActivityIndicator<br/>{% cdv_vartype string %} {% cdv_platform 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.
+UIWebViewDecelerationSpeed<br/>{% cdv_vartype string %} {% cdv_platform 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.
+deployment-target<br/>{% cdv_vartype string %} {% cdv_platform 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<br/>{% cdv_vartype string %} {% cdv_platform 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.
+scheme<br/>{% cdv_vartype string %} {% cdv_platform android %} {% cdv_platform ios %} | *Default:* <br/> - Android: `https` <br/> - iOS: *not defined*, but falls back to `app` if the value is invalid.<br/><br/>*Allowed values:*<br/> - Android: `http` or `https`<br/> - iOS: Any non-reserved schemes. ([Example Reserved Schemes](https://github.com/WebKit/WebKit/blob/ba2a851809a33013068ec8511883055cabd239be/Tools/TestWebKitAPI/Tests/WebKitCocoa/WKURLSchemeHandler-1.mm#L222-L244))<br/><br/>T [...]
+hostname<br/>{% cdv_vartype string %} {% cdv_platform android %} {% cdv_platform ios %} | *Default:* `localhost`<br/><br/>This property contains the hostname which the app content is served from.<br/><br/>If the preference `scheme` is not defined for iOS, the `hostname` value will be ignored.
+
+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="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" />
+```
+
+## 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 | Description
+----------------- | ------------
+name<br/>{% cdv_vartype 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 | Description
+----------------- | ------------
+name<br/>{% cdv_vartype string %} {% cdv_platform ios %} {% cdv_platform android %} | *Required* <br/> Allowed values: android-package, ios-package, onload. <br/> 'ios-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 <br/> {% cdv_vartype String/Boolean %} {% cdv_platform ios %} {% cdv_platform android %} | *Required* <br/> Specifies the name of the package to be used to initialize the plugin code (when the 'name' attribute is android-package or ios-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>
+```
+
+
+## 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 | Description
+----------------- | ------------
+name<br/>{% cdv_vartype 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 | Description
+----------------- | ------------
+type<br/>{% cdv_vartype string %} | *Required* <br/> Specifies the action during which the custom script is to be called.
+src<br/>{% cdv_vartype 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 | Description
+---------------- | ------------
+src<br/>{% cdv_vartype string %} {% cdv_platform ios %} {% cdv_platform android %}| *Required* <br/> Location of the file relative to `config.xml`.
+target<br/>{% cdv_vartype 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" />
+```
+
+[uses-sdk]: https://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
+[allow_list_navigation]: ../guide/appdev/allowlist/index.html#navigation-allow-list
+[allow_list_intent]: ../guide/appdev/allowlist/index.html#intent-allow-list
+[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/12.x/cordova/events/events.md b/www/docs/en/12.x/cordova/events/events.md
new file mode 100644
index 0000000000..505640f8aa
--- /dev/null
+++ b/www/docs/en/12.x/cordova/events/events.md
@@ -0,0 +1,406 @@
+---
+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 JavaScript API
+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>
+ </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>
+ </tr>
+ <tr>
+ <th><a href="#pause">pause</a></th>
+ <td data-col="android" class="y"></td>
+ <td data-col="ios" 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>
+ </tr>
+ <tr>
+ <th><a href="#backbutton">backbutton</a></th>
+ <td data-col="android" class="y"></td>
+ <td data-col="ios" class="n"></td>
+ </tr>
+ <tr>
+ <th><a href="#menubutton">menubutton</a></th>
+ <td data-col="android" class="y"></td>
+ <td data-col="ios" 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>
+ </tr>
+ <tr>
+ <th><a href="#startcallbutton">startcallbutton</a></th>
+ <td data-col="android" class="n"></td>
+ <td data-col="ios" 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>
+ </tr>
+ <tr>
+ <th><a href="#volumedownbutton">volumedownbutton</a></th>
+ <td data-col="android" class="y"></td>
+ <td data-col="ios" 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>
+ </tr>
+ <tr>
+ <th><a href="#activated">activated</a></th>
+ <td data-col="android" class="n"></td>
+ <td data-col="ios" class="n"></td>
+ </tr>
+ <tr>
+ <th><a href="#cordovacallbackerror">cordovacallbackerror</a></th>
+ <td data-col="android" class="y"></td>
+ <td data-col="ios" 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
+}
+```
+
+## 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 menu 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
+
+This event is not fired for Cordova.
+
+## 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/12.x/cordova/storage/storage.md b/www/docs/en/12.x/cordova/storage/storage.md
new file mode 100644
index 0000000000..de74c52e3a
--- /dev/null
+++ b/www/docs/en/12.x/cordova/storage/storage.md
@@ -0,0 +1,240 @@
+---
+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: Data Storage
+toc_title: Data Storage
+description: Storing data on the device.
+---
+
+# Data 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 `browser` platform.
+
+### 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.
+
+### 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]: https://www.w3schools.com/sql/sql_intro.asp
+[SQLite]: https://www.sqlite.org/
+[W3CIndexedDB]: https://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]: https://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/12.x/core/features/splashscreen/index.md b/www/docs/en/12.x/core/features/splashscreen/index.md
new file mode 100644
index 0000000000..1699ec8bc7
--- /dev/null
+++ b/www/docs/en/12.x/core/features/splashscreen/index.md
@@ -0,0 +1,603 @@
+---
+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: Splash Screen
+toc_title: Splash Screen
+---
+
+# Splash Screen
+
+This core feature gives the ability to configure and control the platform's splash screen while your web application is launching.
+
+- [Splash Screen](#splash-screen)
+ - [Supported Platforms](#supported-platforms)
+ - [Platform Splash Screen Image Configuration](#platform-splash-screen-image-configuration)
+ - [Example Configuration](#example-configuration)
+ - [Android-specific Information](#android-specific-information)
+ - [Example Android Configuration](#example-android-configuration)
+ - [iOS-specific Information](#ios-specific-information)
+ - [Launch Storyboard Images](#launch-storyboard-images)
+ - [Designing Launch Storyboard Images](#designing-launch-storyboard-images)
+ - [Scale](#scale)
+ - [Idioms](#idioms)
+ - [Size classes](#size-classes)
+ - [Single-image launch screen](#single-image-launch-screen)
+ - [Multi-image launch screen](#multi-image-launch-screen)
+ - [Dark Mode](#dark-mode)
+ - [config.xml Preferences](#configxml-preferences)
+ - [`AutoHideSplashScreen`](#autohidesplashscreen)
+ - [`FadeSplashScreen`](#fadesplashscreen)
+ - [`FadeSplashScreenDuration`](#fadesplashscreenduration)
+ - [`ShowSplashScreenSpinner`](#showsplashscreenspinner)
+ - [`SplashScreenDelay`](#splashscreendelay)
+ - [`AndroidPostSplashScreenTheme`](#androidpostsplashscreentheme)
+ - [`AndroidWindowSplashScreenAnimatedIcon`](#androidwindowsplashscreenanimatedicon)
+ - [`AndroidWindowSplashScreenAnimationDuration`](#androidwindowsplashscreenanimationduration)
+ - [`AndroidWindowSplashScreenBackground`](#androidwindowsplashscreenbackground)
+ - [`AndroidWindowSplashScreenBrandingImage`](#androidwindowsplashscreenbrandingimage)
+ - [`AndroidWindowSplashScreenIconBackgroundColor`](#androidwindowsplashscreeniconbackgroundcolor)
+ - [JavaScript Public APIs](#javascript-public-apis)
+ - [`navigator.splashscreen.hide`](#navigatorsplashscreenhide)
+ - [`navigator.splashscreen.show`](#navigatorsplashscreenshow)
+ - [Quirks & Known Issues](#quirks--known-issues)
+ - [iOS](#ios)
+ - [Android](#android)
+
+## Supported Platforms
+
+- Android
+- iOS
+
+For other platforms, check the `cordova-plugin-splashscreen` for support.
+
+## Platform Splash Screen Image Configuration
+
+### Example Configuration
+
+In the top-level `config.xml` file (not the one in `platforms`), add configuration elements like those specified here.
+
+The value of the "src" attribute is relative to the project root directory and NOT to the `www` directory (see `Directory structure` below). You can name the source image file whatever you like. The internal name in the application is automatically determined by Cordova.
+
+**Directory structure:**
+
+```
+projectRoot
+ platforms
+ plugins
+ www
+ res
+ screen
+ android
+ ios
+```
+
+**Config.xml:**
+
+```xml
+<platform name="android">
+ <preference name="AndroidWindowSplashScreenAnimatedIcon" value="res/screen/android/splashscreen.xml" />
+</platform>
+
+<!--
+ Storyboard (supports all devices):
+ Note: images are determined by scale, idiom, and size traits. The following
+ are suggested based on current device form factors
+-->
+<platform name="ios">
+ <splash src="res/screen/ios/Default@2x~universal~anyany.png" />
+ <splash src="res/screen/ios/Default@2x~universal~comany.png" />
+ <splash src="res/screen/ios/Default@2x~universal~comcom.png" />
+ <splash src="res/screen/ios/Default@3x~universal~anyany.png" />
+ <splash src="res/screen/ios/Default@3x~universal~anycom.png" />
+ <splash src="res/screen/ios/Default@3x~universal~comany.png" />
+</platform>
+```
+
+### Android-specific Information
+
+Starting in Android 12, Google has implemented a new SplashScreen API to control the app launch animation which runs on a device with Android 12 and higher. For backwards compatibility, Cordova has included the `core-splashscreen` compatibility library which extends this features back to Android API 21 and higher.
+
+To effectively create your own Android SplashScreen assets, it is important to understand the requirements of an Adaptive Icon.
+
+**Resource:**
+
+- [Splash Screen dimensions](https://developer.android.com/guide/topics/ui/splash-screen#splash_screen_dimensions)
+- [Adaptive icons](https://developer.android.com/guide/practices/ui_guidelines/icon_design_adaptive)
+
+#### Example Android Configuration
+
+```xml
+<platform name="android">
+ <!-- Default -->
+ <preference name="AndroidWindowSplashScreenAnimatedIcon" value="res/screen/android/splashscreen.xml" />
+</platform>
+```
+
+### iOS-specific Information
+
+Launch storyboard images are sized based on scale, idiom, and size classes. It supports all devices, and can be used with split-screen/slide-over multitasking.
+
+There is no official support for providing a native-resolution launch image for the iPad Pro 12.9 or for providing launch images that work with split-screen multitasking or slide-over.
+
+**Note:** Since iOS 11, for iPhone X devices and greater (with notch screen), make sure to add `viewport-fit=cover` to the viewport meta tag in your `index.html` file to display the app correctly like so: `<meta name="viewport" content="user-scalable=no, initial-scale=1, width=device-width, viewport-fit=cover">` and make some modification to your app style by adding: `padding: env(safe-area-inset-top)` to your `index.css` file to avoid the unsafe areas behind notches in the screen.
+
+#### Launch Storyboard Images
+
+To support newer form factors and split-screen/slide-over multitasking, launch storyboard images are used.
+
+- images are not specific to a given device.
+- images are scaled to fill the available viewport (while maintaining the aspect ratio).
+- the outer edges of the images will be cropped, and the amount will vary based on device an viewport.
+- there is no need to provide an image for each possible device, viewport, and orientation; iOS will choose the best image for the situation automatically.
+
+##### Designing Launch Storyboard Images
+
+The key to designing a launch storyboard image is understanding that the edges of the image will almost certainly be cropped. Therefore, one should not place any important information near the edges of any images provided to the launch storyboard. Only the center is a safe area, and this all but guarantees that following Apple's advice of presenting an unpopulated user interface will not work well.
+
+Instead, the following tips should enable you to create a launch image that works across a multitude of form factors, viewports, and orientations:
+
+- Important graphics (logos, icons, titles) should be centered. The safe bounding region will vary, so you will need to test to ensure that the important graphics are never cropped. Better yet, don't supply any important graphics in the first place.
+
+ - You _can_ fine-tune the placement and size of these graphics.
+
+- Use a simple color wash. If you use two colors, you'll want one color to fill the top half of the image, and the second to fill the bottom half. If you use a gradient, you'll probably want to ensure that the middle of the gradient lines up with the center of the image.
+
+- Don't worry about pixel perfection -- because the images are scaled, there's almost no chance the images will be perfectly fit to the pixel grid. Since all supported iOS devices use retina screens, users will be hard pressed to notice it anyway.
+
+It is important to understand the concept of scale, idiom, and size class traits in order to use launch storyboard images effectively. Of the images supplied to the launch storyboard, iOS will choose the image that best matches the device and viewport and render that image. It is possible to supply only one launch image if so desired, but it is also possible to fine-tune the displayed launch image based on traits. When fine-tuning, one can ignore traits that aren't targeted or supported [...]
+
+##### Scale
+
+| scale | devices |
+|:-----------:|:----------------------:|
+| 1x | All non-retina devices |
+| 2x | Most retina devices |
+| 3x | iPhone 6+/6s+,7s+ |
+
+In general, you'll want to supply 2x and 3x images. Cordova only supports retina devices now, so there's no point in supplying 1x images.
+
+##### Idioms
+
+| idiom | devices |
+|:-----------:|:-------------:|
+| ipad | All iPads |
+| iphone | All iPhones and iPod Touches |
+| universal | All devices |
+
+You only need to provide universal images unless you need to fine-tune for a specific device idiom.
+
+##### Size classes
+
+There are two size classes applies to both screen axes. Narrow viewports are considered to be the "compact" size class, and remaining viewports are considered "regular". When supplying images to Xcode, however, one must choose between "any & compact" and "any & regular". To stay consistent with the native terminology, this feature will match based on "any" and "compact". `any` will match regular-sized viewports.
+
+Note: this feature uses `com` as an abbreviation for "compact" classes.
+
+The following classes are supported by this feature:
+
+| width | height | orientation |
+|:-----------:|:------------:|:-----------------:|
+| any | any | any |
+| com | any | portrait |
+| any | com | landscape (wide) |
+| com | com | landscape (narrow)|
+
+To see the complete list of size classes associated with devices and viewports, see <http://www.sizeclasses.com>.
+
+##### Single-image launch screen
+
+If your launch image is simple, you may be able to avoid creating a lot of different launch images and supply only one. The launch image needs to meet the following requirements:
+
+- the image should be square
+- the image should be large enough to fit on an iPad Pro 12.9": 2732x2732
+- anything important should fit within the center
+
+Keep in mind that the image will be cropped, possibly quite severely, depending upon the viewport.
+
+Once the image is created, you can include it in your project by adding the following to `config.xml`:
+
+```xml
+ <splash src="res/screen/ios/Default@2x~universal~anyany.png" />
+```
+
+Because only one image is provided, iOS will utilize it in every context.
+
+##### Multi-image launch screen
+
+If a single launch image won't meet your needs, you will probably need to supply at least six images, if not more. Furthermore, keep in mind that it will not be possible to fine tune the image to a specific device, but only to a device class, display factor, and viewport size.
+
+If you don't need to target images to a specific idiom, you should create six images, as follows:
+
+| scale | idiom | width | height | size | filename |
+|:-----------:|:-----------:|:-----------:|:------------:|:----------:|:--------------:|
+| 2x* | universal | any | any | 2732x2732 | `Default@2x~universal~anyany.png` |
+| 2x | universal | com | any | 1278x2732 | `Default@2x~universal~comany.png` |
+| 2x | universal | com | com | 1334x750 | `Default@2x~universal~comcom.png` |
+| 3x* | universal | any | any | 2208x2208 | `Default@3x~universal~anyany.png` |
+| 3x | universal | any | com | 2208x1242 | `Default@3x~universal~anycom.png` |
+| 3x | universal | com | any | 1242x2208 | `Default@3x~universal~comany.png` |
+
+\* this image is required in order for iOS utilize the other images within this scale and idiom.
+
+> Note: If the 3x sizes look small too you, that's because there's only one device class that currently has a 3x density: the iPhone 6+/6s+/7+.
+
+The above looks like the following snippet when present in `config.xml`:
+
+```xml
+ <splash src="res/screen/ios/Default@2x~universal~anyany.png" />
+ <splash src="res/screen/ios/Default@2x~universal~comany.png" />
+ <splash src="res/screen/ios/Default@2x~universal~comcom.png" />
+ <splash src="res/screen/ios/Default@3x~universal~anyany.png" />
+ <splash src="res/screen/ios/Default@3x~universal~anycom.png" />
+ <splash src="res/screen/ios/Default@3x~universal~comany.png" />
+```
+
+Should one need to further fine tune based upon device idiom, one can do so. This might look like so:
+
+| scale | idiom | width | height | size | filename |
+|:-----------:|:-----------:|:-----------:|:------------:|:----------:|:--------------:|
+| 2x* | iphone | any | any | 1334x1334 | `Default@2x~iphone~anyany.png` |
+| 2x | iphone | com | any | 750x1334 | `Default@2x~iphone~comany.png` |
+| 2x | iphone | com | com | 1334x750 | `Default@2x~iphone~comcom.png` |
+| 3x* | iphone | any | any | 2208x2208 | `Default@3x~iphone~anyany.png` |
+| 3x | iphone | any | com | 2208x1242 | `Default@3x~iphone~anycom.png` |
+| 3x | iphone | com | any | 1242x2208 | `Default@3x~iphone~comany.png` |
+| 2x* | ipad | any | any | 2732x2732 | `Default@2x~ipad~anyany.png` |
+| 2x | ipad | com | any | 1278x2732 | `Default@2x~ipad~comany.png` |
+
+\* this image is required in order for iOS utilize the other images within this scale and idiom.
+
+The above looks like the following in `config.xml`:
+
+```xml
+ <splash src="res/screen/ios/Default@2x~iphone~anyany.png" />
+ <splash src="res/screen/ios/Default@2x~iphone~comany.png" />
+ <splash src="res/screen/ios/Default@2x~iphone~comcom.png" />
+ <splash src="res/screen/ios/Default@3x~iphone~anyany.png" />
+ <splash src="res/screen/ios/Default@3x~iphone~anycom.png" />
+ <splash src="res/screen/ios/Default@3x~iphone~comany.png" />
+ <splash src="res/screen/ios/Default@2x~ipad~anyany.png" />
+ <splash src="res/screen/ios/Default@2x~ipad~comany.png" />
+```
+
+##### Dark Mode
+
+Since [Cordova-iOS@6.1.0](https://github.com/apache/cordova-ios), it is now possible to optionally specify different SplashScreen images to use when the app is running in dark mode. The luminosity of SplashScreen images can be defined in `config.xml` using the `~dark` and `~light` suffixes.
+
+```xml
+<!-- Default image to be used for all modes -->
+<splash src="res/screen/ios/Default@2x~universal~anyany.png" />
+
+<!-- Image to use specifically for dark mode devices -->
+<splash src="res/screen/ios/Default@2x~universal~anyany~dark.png" />
+
+<!-- Image to use specifically for light mode devices -->
+<splash src="res/screen/ios/Default@2x~universal~anyany~light.png" />
+```
+
+**Note:** This works since iOS 13. iOS 12 and below will use the default SplashScreen without a luminosity suffix specified.
+
+## config.xml Preferences
+
+### `AutoHideSplashScreen`
+
+Indicates whether to hide splash screen automatically or not. The splash screen is hidden after the amount of time specified in the `SplashScreenDelay` preference.
+
+**Supported Platforms:**
+
+- Android
+- iOS
+
+**Data Type:** `Boolean`
+
+**Default Value:** `true`
+
+**Usage Example:**
+
+```xml
+<preference name="AutoHideSplashScreen" value="true" />
+```
+
+### `FadeSplashScreen`
+
+Controlls the ability of the fade in and out of the splash screen.
+
+For Android, it controlls only the fade out.
+
+**Supported Platforms:**
+
+- Android
+- iOS
+
+**Data Type:** `Boolean`
+
+**Default Value:** `true`
+
+**Usage Example:**
+
+```xml
+<preference name="FadeSplashScreen" value="false"/>
+```
+
+### `FadeSplashScreenDuration`
+
+Controlls the length of the the splash screen fade effect.
+
+**Supported Platforms:**
+
+- Android
+- iOS
+
+**Data Type:** `Float`, in milliseconds
+
+**Default Value:** `500`
+
+**Usage Example:**
+
+```xml
+<preference name="FadeSplashScreenDuration" value="750"/>
+```
+
+_iOS Note_: `FadeSplashScreenDuration` is included into `SplashScreenDelay`, for example if you have `<preference name="SplashScreenDelay" value="3000" />` and `<preference name="FadeSplashScreenDuration" value="1000"/>` defined in `config.xml`:
+
+- 00:00 - splashscreen is shown
+- 00:02 - fading has started
+- 00:03 - splashscreen is hidden
+
+Turning the fading off via `<preference name="FadeSplashScreen" value="false"/>` technically means fading duration to be `0` so that in this example the overall splash screen delay will still be 3 seconds.
+
+_Note_: This only applies to the application startup - you need to take the fading timeout into account when manually showing/hiding the splash screen in your application's code:
+
+```javascript
+navigator.splashscreen.show();
+window.setTimeout(function () {
+ navigator.splashscreen.hide();
+}, splashDuration - fadeDuration);
+```
+
+### `ShowSplashScreenSpinner`
+
+Controlls the splash screen spinner.
+
+**Supported Platforms:**
+
+- iOS
+
+**Data Type:** `Boolean`
+
+**Default Value:** `true`
+
+**Usage Example:**
+
+```xml
+<preference name="ShowSplashScreenSpinner" value="false"/>
+```
+
+### `SplashScreenDelay`
+
+Amount of time in milliseconds to wait before automatically hide splash screen.
+
+**Supported Platforms:**
+
+- Android
+- iOS
+
+**Data Type:** `Number`, in milliseconds
+
+**Default Value:** `true`
+
+- Android
+ `-1`: The splash screen will automatically hide when the `onPageFinished` has been triggered.
+
+- iOS
+ `3000`: The splash screen will automatically hide in 3 seconds.
+
+**Usage Example:**
+
+```xml
+<preference name="SplashScreenDelay" value="3000" />
+```
+
+### `AndroidPostSplashScreenTheme`
+
+Sets the post-theme of the activity after splash screen hides.
+
+_Note:_ This setting is available but use at your own risk.
+
+**Supported Platforms:**
+
+- Android
+
+**Data Type:** `String`
+
+**Default Value:** `@style/Theme.AppCompat.NoActionBar`
+
+**Usage Example:**
+
+```xml
+<preference name="AndroidPostSplashScreenTheme" value="@style/Theme.AppCompat.NoActionBar"/>
+```
+
+### `AndroidWindowSplashScreenAnimatedIcon`
+
+The splash screen image. This preference is used for both animated and non-animated icons. The current acceptable asset files can either be a XML Vector Drawable or PNG.
+
+:warning: Using [Adaptive Icons](https://medium.com/androiddevelopers/implementing-adaptive-icons-1e4d1795470e) requires Minimum SDK 26 to be set.
+
+:warning: Some XML Vector [features](https://developer.android.com/develop/ui/views/graphics/vector-drawable-resources) requires Minimum SDK 24 to be set.
+
+**Supported Platforms:**
+
+- Android
+
+**Data Type:** `String`, file path to the asset file
+
+**Default Value:** If not supplied, the Cordova's default asset is used.
+
+**Usage Example:**
+
+```xml
+<preference name="AndroidWindowSplashScreenAnimatedIcon" value="res/screen/android/splashscreen.xml" />
+```
+
+### `AndroidWindowSplashScreenAnimationDuration`
+
+Defines the duration of the icon's animation if an Animated Vector Drawable is supplied as the splash screen image.
+
+**Supported Platforms:**
+
+- Android
+
+**Data Type:** `Number`, in milliseconds
+
+**Default Value:** `undefined`
+
+**Usage Example:**
+
+```xml
+<preference name="AndroidWindowSplashScreenAnimationDuration" value="3000"/>
+```
+
+### `AndroidWindowSplashScreenBackground`
+
+The splash screen background color.
+
+**Supported Platforms:**
+
+- Android
+
+**Data Type:** `String`, color hex code value.
+
+**Default Value:** `#ffffff`
+
+**Usage Example:**
+
+```xml
+<preference name="AndroidWindowSplashScreenBackground" value="#ffffff" />
+```
+
+### `AndroidWindowSplashScreenBrandingImage`
+
+> :warning: this setting is currently unsupported. The core-splashscreen compatibility library, that Cordova Android relies on for providing backwards support, has not implemented this functionality. [See Google Android Issue Tracker](https://issuetracker.google.com/issues/194301890)
+
+<!--
+The splash screen's branding image.
+
+**Supported Platforms:**
+
+- Android
+
+**Data Type:** `String`, file path to the asset file
+
+**Default Value:** `undefined`
+
+**Usage Example:**
+
+```xml
+<preference name="AndroidWindowSplashScreenBrandingImage" value="res/screen/android/splashscreen_branding.xml" />
+```
+-->
+
+### `AndroidWindowSplashScreenIconBackgroundColor`
+
+The splash screen's icons background color. Useful to seperate increase the contrast seperation between the background and icon.
+
+**Supported Platforms:**
+
+- Android
+
+**Data Type:** `String`, color hex code value.
+
+**Default Value:** `undefined`
+
+**Usage Example:**
+
+```xml
+<preference name="AndroidWindowSplashScreenIconBackgroundColor" value="#c0c0c0" />
+```
+
+## JavaScript Public APIs
+
+### `navigator.splashscreen.hide`
+
+Dismiss the splash screen.
+
+**Supported Platforms:**
+
+- Android
+- iOS
+
+**Usage Example:**
+
+```js
+navigator.splashscreen.hide();
+```
+
+**iOS Quirk:**
+
+The `config.xml` file's `AutoHideSplashScreen` setting must be `false`. To delay hiding the splash screen for two seconds, add a timer such as the following in the `deviceready` event handler:
+
+```js
+setTimeout(function() {
+ navigator.splashscreen.hide();
+}, 2000);
+```
+
+### `navigator.splashscreen.show`
+
+Displays the splash screen.
+
+**Supported Platforms:**
+
+- iOS
+
+**Usage Example:**
+
+```js
+navigator.splashscreen.show();
+```
+
+Your application cannot call `navigator.splashscreen.show()` until the application has
+started and the `deviceready` event has fired. But since typically the splash
+screen is meant to be visible before your application has started, that would seem to
+defeat the purpose of the splash screen. Providing any parameters in
+`config.xml` will automatically `show` the splash screen immediately after your
+application is launched and before it has fully started and received the `deviceready`
+event. For this reason, it is unlikely you will need to call `navigator.splashscreen.show()` to make the splash
+screen visible for application startup.
+
+## Quirks & Known Issues
+
+### iOS
+
+1. In iOS, the splash screen images are called launch images. These images are mandatory on iOS.
+
+2. **App on target may not reflect changes to images**
+ Once you run the app on a target, iOS caches the launch image. Unfortunately, when you change the image, iOS does _not_ invalidate the cache, which means you'll still see the old launch image. You should either: delete the app, or reset content & settings (simulator).
+
+3. **Simulator may not show expected images when launched from CLI**
+ When Xcode deploys to a specific simulator, it only copies the assets that match the simulator's characteristics. For example, if you try to run an app on the iPhone 6s Plus simulator, only @3x launch images are copied. When compiling from the CLI, however, the default is to assume an iPhone 5s, which means only @2x launch images are copied. Unless your launch images are markedly different, chances are good the difference would go unnoticed, but this does mean that the only accurate m [...]
+
+4. **`anyany` must be provided for other variations to be used**
+ If you don't provide an `anyany` version of the launch image for a specific scale and idiom, the other variations (like `anycom`, `comany`, and `comcom`) will ignored.
+
+### Android
+
+1. **Android 12 does not show the splash screen when launching the application from Android Studio or Cordova CLI.**
+ This is a known Android 12 issue. After uploading the app to the device or simulator, exiting and opening the app will show the Splash Screen. If changes are not shown, try also performing a clean build.
+It has been fixed on Android 13.
diff --git a/www/docs/en/12.x/guide/appdev/allowlist/index.md b/www/docs/en/12.x/guide/appdev/allowlist/index.md
new file mode 100644
index 0000000000..4f930ee216
--- /dev/null
+++ b/www/docs/en/12.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: Manage App's Allow List
+toc_title: Allow List
+description: Securely grant an application access to external resources.
+---
+
+# Allow List
+
+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]: https://www.w3.org/TR/widgets-access/
diff --git a/www/docs/en/12.x/guide/appdev/hooks/index.md b/www/docs/en/12.x/guide/appdev/hooks/index.md
new file mode 100644
index 0000000000..edcf19b586
--- /dev/null
+++ b/www/docs/en/12.x/guide/appdev/hooks/index.md
@@ -0,0 +1,406 @@
+---
+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>
+```
+
+### 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/12.x/guide/appdev/privacy/index.md b/www/docs/en/12.x/guide/appdev/privacy/index.md
new file mode 100644
index 0000000000..3f952921f4
--- /dev/null
+++ b/www/docs/en/12.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: Manage App's Privacy
+toc_title: Privacy
+description: Learn about important mobile privacy issues.
+---
+
+# Privacy
+
+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/12.x/guide/appdev/security/index.md b/www/docs/en/12.x/guide/appdev/security/index.md
new file mode 100644
index 0000000000..29671e9770
--- /dev/null
+++ b/www/docs/en/12.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: Manage App's Security
+toc_title: Security
+description: Information and tips for building a secure application.
+---
+
+# Security
+
+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 allow listed domain, that domain will have access to the native Cordova bridge. This means that if you allow 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 av [...]
+
+## 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 [https://www.mobilemag.com/2012/11/06/andriod-2-3-gingerbread-security/](https://bgr.com/2012/11/06/android-security-gingerbread-malware/).
+* The Allowlist 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 allow listing 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/12.x/guide/cli/index.md b/www/docs/en/12.x/guide/cli/index.md
new file mode 100644
index 0000000000..ca23476d35
--- /dev/null
+++ b/www/docs/en/12.x/guide/cli/index.md
@@ -0,0 +1,244 @@
+---
+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 an App
+description: Learn how to create your first Cordova hybrid app using Cordova CLI.
+toc_title: Creating an App
+---
+
+# Creating an 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]
+
+## Creating the Cordova Project Space
+
+In terminal, go to the directory where you would like to create your Cordova's project.
+
+Note that the next command will create a new project directory where your source code, resource files, configuration, and build artifacts will reside.
+
+```bash
+cordova create hello com.example.hello HelloWorld
+```
+
+The above command will create a project directory named "hello" with the required directory structure for your Cordova app.
+
+By default, the `cordova create` script generates a skeletal web-based application where the apps landing 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:
+
+```bash
+$ 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 macOS: not installed
+Cordova tooling for iOS requires Apple macOS
+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)
+
+## 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
+```
+
+<img src="{{ site.baseurl }}/static/img/guide/cli/2023-android-connecting-to-emulator.png" style="width: 30%;" alt="Launching Emulator Process" /> <img src="{{ site.baseurl }}/static/img/guide/cli/2023-android-launching-to-emulator.png" style="width: 30%;" alt="Booting Android Image" /> <img src="{{ site.baseurl }}/static/img/guide/cli/2023-android-app-running-on-emulator.png" style="width: 30%;" alt="Displaying Cordova App" />
+
+Running `cordova emulate` will also prepare, rebuild, and redeploy the latest app to the emulator.
+
+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].
+
+To add and save the camera plugin to `package.json`, we will specify the npm package name for the camera plugin:
+
+```bash
+$ 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:
+
+```bash
+$ cordova plugin ls
+cordova-plugin-camera 2.1.0 "Camera"
+```
+
+**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
+npm update -g cordova
+```
+
+Use this syntax to install a specific version:
+
+```bash
+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
+```
+
+[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/12.x/guide/cli/installation.md b/www/docs/en/12.x/guide/cli/installation.md
new file mode 100644
index 0000000000..f3ff7a37f0
--- /dev/null
+++ b/www/docs/en/12.x/guide/cli/installation.md
@@ -0,0 +1,86 @@
+---
+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: Installation
+description: Installing Cordova CLI
+toc_title: Installation
+---
+
+# Installation
+
+The Cordova command-line tool (CLI) is distributed as an npm package.
+
+To install the `cordova` CLI 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 line.
+
+2. (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 the `git` command in your command promt (terminal). The Cordova cli and npm invokes the git command when download assets that were referenced with a git repo url.
+
+3. Install the `cordova` module using `npm` utility of Node.js. The `cordova` module will automatically be downloaded by the `npm` utility.
+
+ - on macOS and Linux:
+
+ ```bash
+ npm install -g cordova
+ ```
+
+ For macOS and Linux users, you might need to use the `sudo` prefix when running the `npm` command to install this utility in restricted directories like `/usr/local/share`. However, if you are using the optional nvm/nave tool or have write access to the installation directory, you may be able to omit the `sudo` prefix.
+
+ It is also worth noting that it is generally recommended to avoid using `sudo` with `npm` to prevent potential issues with permissions and package installations.
+
+ Instead, it's recommended to use a version manager like nvm (Node Version Manager) or nave to manage Node.js and npm installations, which typically avoids the need for `sudo` when installing packages.
+
+ - on Windows:
+
+ ```bash
+ 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.
+
+## Requirements and Support
+
+<table>
+ <thead>
+ <tr>
+ <th>Cordova CLI Version</th>
+ <th>Node.js Supported Version</th>
+ </tr>
+ </thead>
+ <tbody>
+ <tr>
+ <td>12.x</td>
+ <td>>=16.13.0</td>
+ </tr>
+ <tr>
+ <td>11.x</td>
+ <td>>=12.0.0</td>
+ </tr>
+ <tr>
+ <td>10.x</td>
+ <td>>=10.0.0</td>
+ </tr>
+ <tr>
+ <td>9.x</td>
+ <td>>=6.0.0</td>
+ </tr>
+ </tbody>
+</table>
diff --git a/www/docs/en/12.x/guide/cli/template.md b/www/docs/en/12.x/guide/cli/template.md
new file mode 100644
index 0000000000..d5cb54763b
--- /dev/null
+++ b/www/docs/en/12.x/guide/cli/template.md
@@ -0,0 +1,75 @@
+---
+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: App Templates
+description: Learn how to find, use, and create templates in Cordova.
+toc_title: App Templates
+
+---
+
+# 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:
+
+```bash
+cordova create hello com.example.hello HelloWorld --template <npm-package-name|git-repo|local-dir-path>
+```
+
+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](https://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.
+
+```text
+template_package
+├── package.json (for your template package to be published on npm)
+├── index.js (required)
+└── template_src (required - contains template files)
+ ├── package.json
+ ├── config.xml
+ └── (files and folders that make up the 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"`.
+
+```json
+{
+ ...
+ "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/12.x/guide/hybrid/plugins/index.md b/www/docs/en/12.x/guide/hybrid/plugins/index.md
new file mode 100644
index 0000000000..095ab7744d
--- /dev/null
+++ b/www/docs/en/12.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: Create a Plugin
+toc_title: Create a Plugin
+description: Develop your own Cordova plugin.
+---
+
+# Create a Plugin
+
+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](https://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](https://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/12.x/guide/hybrid/webviews/index.md b/www/docs/en/12.x/guide/hybrid/webviews/index.md
new file mode 100644
index 0000000000..0d3bf3f181
--- /dev/null
+++ b/www/docs/en/12.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/12.x/guide/next/index.md b/www/docs/en/12.x/guide/next/index.md
new file mode 100644
index 0000000000..b2348f102a
--- /dev/null
+++ b/www/docs/en/12.x/guide/next/index.md
@@ -0,0 +1,222 @@
+---
+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:
+
+* [React](https://react.dev/)
+* [Vue.js](https://vuejs.org/)
+* [Angular](https://angular.io/)
+* [Ember.js](https://emberjs.com/)
+* [Backbone.js](https://backbonejs.org/)
+* [Kendo UI](https://www.telerik.com/kendo-ui)
+* [Onsen UI](https://onsen.io)
+
+And many, many, more.
+
+### 2) Performance Considerations
+
+Consider the following issues to improve the performance in your mobile applications:
+
+* **Click vs. 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://developer.chrome.com/blog/300ms-tap-delay-gone-away/) on the Google Developer site.
+
+ As of 2015, most Android and iOS devices no longer imposes the delay. For both Android and iOS, ensure that your viewport meta tag has set the `width=device-width` value or you will still have the tap delay.
+
+* **CSS Transitions vs. 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.
+
+* **Network**
+
+ 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 back and forth. This is an especially important considerat [...]
+
+### 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:
+
+```bash
+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.
+
+```bash
+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/)
+
+## 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:
+
+* [GitHub Discussions - Apache Cordova][GitHubDiscussionCommunity]
+
+ The official Apache Cordova GitHub Discussions channel is a recent addition to our support resources, aimed at centralizing community discussions and questions within our GitHub repositories.
+
+ This channel is highly recommended as it brings together all things Cordova and provides the advantage of retaining a complete history of discussions. By utilizing GitHub Discussions, we can ensure better continuity and accessibility for future reference.
+
+* [Slack - Apache Cordova][SlackCommunity]
+
+ The official Apache Cordova Slack workspace is an excellent resource for seeking help from the community and obtaining quick answers to your questions.
+
+ However, it's important to note that our Slack workspace does not retain message history. This limits the accessibility of information in the long term. To ensure better retention of your question, it is advisable to create a thread in GitHub Discussions and share the link and a summary of your question in the Slack.
+
+ This way, you can benefit from the immediate responsiveness of Slack while also preserving the discussion and making it more accessible for future reference.
+
+* [Stack Overflow - Apache Cordova](StackOverflowCommunity)
+
+ On Stack Overflow, the "cordova" tag can be used to browse all Cordova questions.
+
+ _Note: StackOverflow automatically converts the "phonegap" tag to "cordova" to maintain historical questions._
+
+ Stack Overflow has a vast and diverse community, making it an excellent choice for obtaining results depending on the nature of your question. For instance, even if you are developing a Cordova App, if your question pertains more to web or native app development, utilizing this platform could be more suitable. By doing so, you expose your question to a broader community that specializes in those specific fields.
+
+* [Google Group - PhoneGap](https://groups.google.com/forum/#!forum/phonegap)
+
+ This Google Group was previously the support forum for Cordova when it was known as PhoneGap. Although this group is currently inactive, it remains accessible for historical reference.
+
+ It is advisable to utilize alternative platforms such as [GitHub Discussions][GitHubDiscussionCommunity], [Stack Overflow][StackOverflowCommunity], or [Slack][SlackCommunity] for obtaining support and engaging with the Cordova community. These platforms provide more active for assistance and discussions.
+
+[DeviceReadyEvent]: ../../cordova/events/events.html#deviceready
+[SlackCommunity]: https://s.apache.org/cordova-slack
+[StackOverflowCommunity]: https://stackoverflow.com/questions/tagged/cordova
+[GitHubDiscussionCommunity]: https://github.com/apache/cordova/discussions
diff --git a/www/docs/en/12.x/guide/overview/index.md b/www/docs/en/12.x/guide/overview/index.md
new file mode 100644
index 0000000000..48f0627812
--- /dev/null
+++ b/www/docs/en/12.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/12.x/guide/platforms/android/index.md b/www/docs/en/12.x/guide/platforms/android/index.md
new file mode 100644
index 0000000000..fd9409786d
--- /dev/null
+++ b/www/docs/en/12.x/guide/platforms/android/index.md
@@ -0,0 +1,852 @@
+---
+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 will assist you in setting up your development environment for building Cordova apps on Android devices. Additionally, it provides the option to incorporate Android-specific command-line tools into your development workflow.
+
+Regardless of whether you intend to utilize Android-specific command-line tools or Cordova CLI commands, you will need to install and configure the necessary requirements.
+
+## Android API Level Support
+
+The supported [Android API Levels](https://developer.android.com/guide/topics/manifest/uses-sdk-element#ApiLevels) (versions of Android) corresponding with the Cordova-Android released versions are listed in the table below:
+
+<table>
+ <thead>
+ <tr>
+ <th>cordova-android Version</th>
+ <th>Android API-Levels (Android Version)</th>
+ <th>Library & Tooling Version</th>
+ </tr>
+ </thead>
+ <tbody>
+ <tr>
+ <td>12.0.x</td>
+ <td>24 (7.0) - 33 (13.0)</td>
+ <td>
+ <ul>
+ <li>Build Tools: ^33.0.2</li>
+ <li>Kotlin: 1.7.21</li>
+ <li>Gradle: 7.6</li>
+ <li>Android Gradle Plugin: 7.4.2</li>
+ <li>AndroidX Compat Library: 1.6.1</li>
+ <li>AndroidX WebKit Library: 1.6.0</li>
+ <li>AndroidX Core SplashScreen: 1.0.0</li>
+ <li>Google Services Gradle Plugin: 4.3.15</li>
+ </ul>
+ </td>
+ </tr>
+ <tr>
+ <td>11.0.x</td>
+ <td>22 (5.1) - 32 (12L)</td>
+ <td>
+ <ul>
+ <li>Build Tools: ^32.0.0</li>
+ <li>Kotlin: 1.7.21</li>
+ <li>Gradle: 7.4.2</li>
+ <li>Android Gradle Plugin: 7.2.1</li>
+ <li>AndroidX Compat Library: 1.4.2</li>
+ <li>AndroidX WebKit Library: 1.4.0</li>
+ <li>AndroidX Core SplashScreen: 1.0.0-rc01</li>
+ <li>Google Services Gradle Plugin: 4.3.10</li>
+ </ul>
+ </td>
+ </tr>
+ <tr>
+ <td>10.1.x</td>
+ <td>22 (5.1) - 30 (11.0)</td>
+ <td>
+ <ul>
+ <li>Build Tools: ^30.0.3</li>
+ <li>Kotlin: 1.5.21</li>
+ <li>Gradle: 7.1.1</li>
+ <li>Android Gradle Plugin: 4.2.2</li>
+ <li>AndroidX Compat Library: 1.3.1</li>
+ <li>AndroidX WebKit Library: 1.4.0</li>
+ <li>Google Services Gradle Plugin: 4.3.8</li>
+ </ul>
+ </td>
+ </tr>
+ <tr>
+ <td>10.0.x</td>
+ <td>22 (5.1) - 30 (11.0)</td>
+ <td>
+ <ul>
+ <li>Build Tools: ^30.0.3</li>
+ <li>Kotlin: 1.5.20</li>
+ <li>Gradle: 7.1.1</li>
+ <li>Android Gradle Plugin: 4.2.2</li>
+ <li>AndroidX Compat Library: 1.3.0</li>
+ <li>AndroidX WebKit Library: 1.4.0</li>
+ <li>Google Services Gradle Plugin: 4.3.5</li>
+ </ul>
+ </td>
+ </tr>
+ <tr>
+ <td>9.X.X</td>
+ <td>22 (5.1) - 29 (10.0)</td>
+ <td>-</td>
+ </tr>
+ <tr>
+ <td>8.X.X</td>
+ <td>19 (4.4) - 28 (9.0)</td>
+ <td>-</td>
+ </tr>
+ <tr>
+ <td>7.X.X</td>
+ <td>19 (4.4) - 27 (8.1)</td>
+ <td>-</td>
+ </tr>
+ <tr>
+ <td>6.X.X</td>
+ <td>16 (4.1) - 26 (8.0)</td>
+ <td>-</td>
+ </tr>
+ <tr>
+ <td>5.X.X</td>
+ <td>14 (4.0) - 23 (6.0)</td>
+ <td>-</td>
+ </tr>
+ <tr>
+ <td>4.1.X</td>
+ <td>14 (4.0) - 22 (5.1)</td>
+ <td>-</td>
+ </tr>
+ <tr>
+ <td>4.0.X</td>
+ <td>10 (2.3.3) - 22 (5.1)</td>
+ <td>-</td>
+ </tr>
+ <tr>
+ <td>3.7.X</td>
+ <td>10 (2.3.3) - 21 (5.0)</td>
+ <td>-</td>
+ </tr>
+ </tbody>
+</table>
+
+_**Note:** The [cordova-android](https://github.com/apache/cordova-android) versions listed above are not the Cordova CLI versions._
+
+To find out the version of the Cordova-Android package installed in your Cordova project, navigate to the root directory of your project and execute the command `cordova platform ls`.
+
+Cordova generally ceases support for Android versions that fall below 5% on Google's distribution dashboard. You can refer to Google's [Distribution dashboard](https://developer.android.com/about/dashboards/index.html) for more information.
+
+## System Requirements
+
+Cordova-Android relies on the Android SDK, which can be installed on macOS, Linux, or Windows operating systems.
+
+To ensure your system meets the necessary requirements, please refer to the "[Install Android Studio](https://developer.android.com/studio/install)" guide provided by Google.
+
+## The Required Software & Tools
+
+### Java Development Kit (JDK)
+
+If you are using `cordova-android` 10.0.0 or greater, install the [Java Development Kit (JDK) 11](https://www.oracle.com/java/technologies/javase-jdk11-downloads.html).
+
+If you are using any version below `cordova-android` 10.0.0, install the [Java Development Kit (JDK) 8](https://www.oracle.com/java/technologies/javase/javase-jdk8-downloads.html).
+
+The `JAVA_HOME` environment variable must be set according to your JDK installation path. See the [Setting Environment Variables](#setting-environment-variables) section on how to set up environment variables. Alternatively as of `cordova-android` 10.0.0 or greater, `CORDOVA_JAVA_HOME` can be set in place of `JAVA_HOME`, allowing a JDK install to be used specifically for Cordova development.
+
+### Gradle
+
+As of Cordova-Android 6.4.0, [Gradle](https://gradle.org/install/) is required to be installed.
+
+When installing on Windows, you need to add the path to the Gradle's binary directory to your `path` environment variable. See [Setting Environment Variables](#setting-environment-variables)) on how to configure system environment variables.
+
+_**Note:** This is the system's Gradle version. The system's Gradle binary will create the Gradle Wrapper file that declares and obtains the appropriate version of Gradle needed for building the Android application. The system-level and project-level version of Gradle may not and does not need to match. The project-level's version of Gradle is defined in the Cordova-Android's package and set based on what Android supports._
+
+### Android Studio
+
+Download and 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 packages.
+
+#### SDK Packages
+
+It is recommended to install the latest version of the SDK Platform & SDK Tools based on the project's installed version of Cordova-Android. Refer to the [Android API Level Support](#android-api-level-support) section to find which version is supported based on the Cordova-Android version.
+
+##### Installing SDK Platform
+
+1. Open Android Studio's
+2. Open **SDK Manager** (`Tools > SDK Manager`)
+3. Click on the **SDK Platforms** tab
+4. Select the Android version which matches the highest supported SDK based from the [Android API Level Support](#android-api-level-support)
+5. Click Apply
+
+For example: If the project has installed `cordova-android@12.0.0`, the highest supported SDK is 33. In step 3, of the above, "Android 13.0 (Tiramisu)", should have been selected.
+
+<img src="{{ site.baseurl }}/static/img/guide/platforms/android/android-studio-electric-eel-20220101-2/sdk-manager/sdk-platform.png" style="width: 100%;" alt="Android SDK Platform" />
+
+##### Installing Android SDK Build-Tools
+
+1. Open Android Studio's
+2. Open **SDK Manager** (`Tools > SDK Manager`)
+3. Click on the **SDK Tools** tab
+4. Check **Show Package Details**
+5. Expand **Android SDK Build-Tool**
+6. Check the highest supported Build-Tools based on the [Android API Level Support](#android-api-level-support).
+7. Click Apply
+
+For example: If the project has installed `cordova-android@12.0.0`, the highest supported SDK is 33. We want to select the highest available version of 33.x. At the time of this writing, "33.0.2" should have been selected in step 6.
+
+<img src="{{ site.baseurl }}/static/img/guide/platforms/android/android-studio-electric-eel-20220101-2/sdk-manager/sdk-build-tools.png" style="width: 100%;" alt="Android SDK Build-Tools" />
+
+##### Installing SDK Command-line Tools (latest)
+
+1. Open Android Studio's
+2. Open **SDK Manager** (`Tools > SDK Manager`)
+3. Click on the **SDK Tools** tab
+4. Check **Show Package Details**
+5. Expand **Android SDK Command-line Tools (latest)**
+6. Check **Android SDK Command-line Tools (latest)**
+7. Click Apply
+
+<img src="{{ site.baseurl }}/static/img/guide/platforms/android/android-studio-electric-eel-20220101-2/sdk-manager/command-line-tools-latest.png" style="width: 100%;" alt="SDK Command-line Tools (latest)" />
+
+##### Installing Android SDK Platform-Tools
+
+1. Open Android Studio's
+2. Open **SDK Manager** (`Tools > SDK Manager`)
+3. Click on the **SDK Tools** tab
+4. Check **Show Package Details**
+5. Check **Android SDK Platform-Tool**
+6. Click Apply
+
+<img src="{{ site.baseurl }}/static/img/guide/platforms/android/android-studio-electric-eel-20220101-2/sdk-manager/sdk-platform-tools.png" style="width: 100%;" alt="Android SDK Platform-Tools" />
+
+##### Installing Android Emulator
+
+1. Open Android Studio's
+2. Open **SDK Manager** (`Tools > SDK Manager`)
+3. Click on the **SDK Tools** tab
+4. Check **Show Package Details**
+5. Check **Android Emulator**
+6. Click Apply
+
+<img src="{{ site.baseurl }}/static/img/guide/platforms/android/android-studio-electric-eel-20220101-2/sdk-manager/android-emulator.png" style="width: 100%;" alt="Android Emulator" />
+
+### Setting environment variables
+
+Cordova's CLI requires specific environment variables so it can function correctly. If the environment variables are missing, the CLI will attempt to resolve the variable temporarily. If the missing variables fail to resolve, they must be set manually.
+
+The following variables must be set:
+
+- `JAVA_HOME` - The environment variable to the location of your JDK installation
+- `ANDROID_HOME` - The environment variable to the location of your Android SDK installation
+
+It is also recommended to update the `PATH` environment variable to include the following directories.
+
+- `cmdline-tools/latest/bin`
+- `platform-tools`
+- `build-tools`
+- `emulator`
+ - This is required for the `apksigner` and `zipalign` tools.
+
+_**Note:** The directories above are generally located in the Android SDK ROOT._
+
+#### macOS and Linux
+
+On a Mac or Linux, with a text editor, 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_HOME=/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_HOME/platform-tools/
+export PATH=$PATH:$ANDROID_HOME/cmdline-tools/latest/bin/
+export PATH=$PATH:$ANDROID_HOME/build-tools
+export PATH=$PATH:$ANDROID_HOME/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 or Press on the **Windows** Key (**Win**)
+2. Type in the search bar `Environment Variables`
+3. Select **Edit the system environment variables** options
+4. Click on the **Environment Variables...** button in the window that appears.
+
+##### To create a new environment variable
+
+1. Click on the **New...** button
+2. Type in the **Variable name**
+3. Type in the **Variable value**
+4. Click on the **OK** button
+
+##### To set your PATH
+
+1. Select **PATH** from the liste of already defined variable
+2. Click on the **Edit...** button
+3. Click on the **New** button
+4. Type in the relevant location.
+
+Repeat step 3 and 4 until all paths are added.
+
+Example paths (substitute the paths with your local Android SDK installation's location):
+
+```txt
+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\build-tools
+C:\Users\[your user]\AppData\Local\Android\Sdk\emulator
+```
+
+Once all paths are added, click the **OK** button until all opened windows for setting & editing environment variables are closed.
+
+## 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 following Android documentation for more details on:
+
+- [Create and manage virtual devices](https://developer.android.com/studio/run/managing-avds.html)
+- [Run apps on the Android Emulator](https://developer.android.com/studio/run/emulator.html#about)
+- [Configure hardware acceleration for the Android Emulator](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 the following command:
+
+```bash
+cordova run --emulator
+```
+
+### Configuring Gradle
+
+Cordova-Android projects are built by using [Gradle](https://gradle.org/).
+
+#### 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:
+
+| Property | Description |
+| -- | -- |
+| `cdvAndroidXAppCompatVersion` | Sets the version of the `androidx.appcompat:appcompat` library. |
+| `cdvAndroidXWebKitVersion` | Sets the version of the `androidx.webkit:webkit` library. |
+| `cdvBuildArch` | Overrides the build architecture of which the app is built for. The default value is automatically detected by Cordova's build script. |
+| `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 |
+| `cdvBuildToolsVersion` | Overrides the automatically detected `android.buildToolsVersion` value |
+| `cdvCompileSdkVersion` | Sets the SDK version of the framework which the app is been compiled for. Setting will override the automatic detection of the `android.compileSdkVersion` value. |
+| `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 |
+| `cdvMaxSdkVersion` | set the maximum API Level which the application can run on |
+| `cdvMinSdkVersion` | Overrides the value of `minSdkVersion` set in `AndroidManifest.xml`. Useful when creating multiple APKs based on SDK version |
+| `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)) |
+| `cdvSdkVersion` | Overrides the `targetSdkVersion` value. |
+| `cdvVersionCode` | Overrides the versionCode set in `AndroidManifest.xml` |
+| `cdvVersionCodeForceAbiDigit` | Whether to append a 0 "abi digit" to versionCode when only a single APK is build. |
+
+You can set these properties in one of four ways:
+
+- Using an Environment Variables:
+
+ **Example:**
+
+ ```bash
+ export ORG_GRADLE_PROJECT_cdvMinSdkVersion=20
+ cordova build android
+ ```
+
+- Using the `--gradleArg` flag with the Cordova `build` or `run` command:
+
+ **Example:**
+
+ ```bash
+ cordova run android -- --gradleArg=-PcdvMinSdkVersion=20
+ ```
+
+- Creating a `gradle.properties` in the project's Android platform directory
+
+ Create a file named `gradle.properties` in the directory `<project-root>/platforms/android` with the contents such as:
+
+ **Example File Contents:**
+
+ ```groovy
+ cdvMinSdkVersion=20
+ ```
+
+- [Extending `build.gradle`](#extending-buildgradle) with the `build-extras.gradle file
+
+ Create a file named `build-extras.gradle` in the directory `<project-root>/platforms/android/app` with the contents such as:
+
+ ```groovy
+ ext.cdvMinSdkVersion = 20
+ ```
+
+The latter two options both involve including an extra file in your Android platform folder. In general, it is discouraged to edit the contents of this folder because it is easy for those changes to be lost or overwritten. Instead, these files should be copied into the folder as part of the build command by using the `before_build` [hook script](../../appdev/hooks/index.html).
+
+#### Extending build.gradle
+
+If you need to customize the `build.gradle` file, rather than edit it directly, it is recommended to create a sibling file named `build-extras.gradle`. This file will be included by the main `build.gradle` script when present. This file must be placed in the `app` folder of the Android's platform directory (`<your-project>/platforms/android/app`). It is recommended to use the `before_build` [hook script](../../appdev/hooks/index.html) to copy this file over.
+
+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's `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 maximum 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) for your app's generated apk, set the `android-versionCode` attribute in the `widget` element of your application's [config.xml](../../../config_ref/index.html) file.
+
+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`:
+
+```groovy
+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`.
+
+_**Note:** Be aware that some plugins added to your project may set this Gradle property automatically._
+
+_**Note:** When updating the `android-versionCode` property, it is not recommended to increment the version code taken from built apks. It is recommended to 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
+
+It is recommended to read Android's documentation for [Sign your app](https://developer.android.com/studio/publish/app-signing) first, as it contains the necessary steps in creating required files for signing.
+
+### 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 for debug, bundle for release_<br>Specify whether to build an APK or an [AAB](https://developer.android.com/guide/app-bundle) (Android App Bundle) file.<br>Acceptable Values: `apk` or `bundle`
+
+The parameters above can be specified as an argument when using the [Cordova CLI][cli_reference] `build` or `run` commands.
+
+_**Note**: You should use double `--` to indicate that these are platform-specific arguments._
+
+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 the signing parameters in a build configuration file (`build.json`).
+
+By default, if the `build.json` file exists in the project's root directory, it will automatically be detected and used. If the file is not located in the project's root directory or has multiple configuration files, the command line argument `--buildConfig` must be supplied with the path to the file.
+
+**Example `build.json` 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 takes 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)).
+
+**Example file content:**
+
+```properties
+storeFile=relative/path/to/keystore.p12
+storePassword=SECRET1
+storeType=pkcs12
+keyAlias=DebugSigningKey
+keyPassword=SECRET2
+```
+
+The `storePassword` and `keyPassword` properties 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](https://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-Android projects can be opened in [Android Studio][android_studio]. This can be useful if you wish to use Android Studio's built in Android debugging and profiling tools or if you are developing Android plugins.
+
+_**Note:** When opening your project in Android Studio, it is recommended to NOT edit the code within the IDE. Editing in Android Studio will edit code residing in the `platforms` directory of your project. It is not updating the code in the projects root `www`)directory. The changes are liable to be overwritten. Instead, edit the `www` folder and copy over your changes by running `cordova prepare`._
+
+Plugin developers wishing to edit their native code in Android Studio should use the `--link` flag when adding their plugin to the project with the `cordova plugin add`. This will create a symbolic link of the plugin files from the plugin source directory to the project's `platforms` directory.
+
+To open a Cordova-Android project in Android Studio:
+
+1. Launch **Android Studio**
+2. Click the **Open** button
+ <img src="{{ site.baseurl }}/static/img/guide/platforms/android/android-studio-electric-eel-20220101-2/welcome-to-android-studio.png" style="width: 100%;" alt="Welcome to Android Studio" />
+3. Navigate to the project's Android platform directory: (`<project-root>/platforms/android`)
+4. Click **Open**
+
+Once it finishes importing, you should be able to build and run the app directly from **Android Studio**.
+
+For more resources, please see:
+
+- [Meet Android Studio](https://developer.android.com/studio/intro)
+- [Build and run your app](https://developer.android.com/studio/run/index.html)
+
+<img src="{{ site.baseurl }}/static/img/guide/platforms/android/android-studio-electric-eel-20220101-2/hello-cordova-main-activity.png" style="width: 100%;" alt="Hello Cordova MainActivity" />
+
+## 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](https://developer.android.com/reference/android/app/Activity) 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 [...]
+
+### 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 [...]
+
+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 maintain [...]
+
+### 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, cor [...]
+
+### 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 [...]
+
+The payload for the `resume` event adheres to the following format:
+
+```json
+{
+ 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"`
+
+_**Note:** It is up to the plugin to decide what is contained in the `result` field and the meaning of the `pluginStatus` that is returned. Refer to the plugin's API documentationf or the expect results and how to use the 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`.
+
+**Example:**
+
+```xml
+<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/12.x/guide/platforms/android/plugin.md b/www/docs/en/12.x/guide/platforms/android/plugin.md
new file mode 100644
index 0000000000..73cc7dc5a3
--- /dev/null
+++ b/www/docs/en/12.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]: https://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]: https://developer.android.com/reference/android/content/Context.html
+[ref-executor]: https://developer.android.com/reference/java/util/concurrent/ExecutorService.html
+[ref-intent]: https://developer.android.com/reference/android/content/Intent.html
+[ref-activity]: https://developer.android.com/reference/android/app/Activity.html
+[ref-runonuithread]: https://developer.android.com/reference/android/app/Activity.html#runOnUiThread(java.lang.Runnable)
diff --git a/www/docs/en/12.x/guide/platforms/android/upgrade.md b/www/docs/en/12.x/guide/platforms/android/upgrade.md
new file mode 100644
index 0000000000..e719faa005
--- /dev/null
+++ b/www/docs/en/12.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 https://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 reques [...]
+
+
+## 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]: https://developer.android.com/guide/topics/security/permissions.html#perm-groups
diff --git a/www/docs/en/12.x/guide/platforms/android/webview.md b/www/docs/en/12.x/guide/platforms/android/webview.md
new file mode 100644
index 0000000000..de9e2998d1
--- /dev/null
+++ b/www/docs/en/12.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](https://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/12.x/guide/platforms/electron/index.md b/www/docs/en/12.x/guide/platforms/electron/index.md
new file mode 100644
index 0000000000..53b8a20632
--- /dev/null
+++ b/www/docs/en/12.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 | Windows |
+| ----------------------- | :-----: | :-----: | :-------------------------: |
+| Linux | ✅ | | ❗ <sup>**[2]**</sup> |
+| Mac <sup>**[3]**</sup> | ✅ | ✅ | ❗ <sup>**[2]**</sup> |
+| Windows | | | ✅ |
+
+**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/12.x/guide/platforms/ios/index.md b/www/docs/en/12.x/guide/platforms/ios/index.md
new file mode 100644
index 0000000000..187328e13e
--- /dev/null
+++ b/www/docs/en/12.x/guide/platforms/ios/index.md
@@ -0,0 +1,362 @@
+---
+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 used for building iOS applications can only operate within the macOS environment. Xcode®, the primary tool for iOS application development, incorporates the iOS SDK (Software Development Kit). For submission to the Apple App Store℠, apps must be built using the most recent versions of these Apple tools.
+
+You can evaluate many Cordova features by utilizing the iOS simulator integrated with the iOS SDK and Xcode. However, testing all of an app's device-specific functionalities requires an actual device before final submission to the App Store.
+
+The table below outlines Cordova-iOS's prerequisites by version. Additionally, Xcode has its own set of system requirements and it is advisable to refer to the [Minimum requirements and supported SDKs](https://developer.apple.com/support/xcode/#:~:text=Minimum%20requirements%20and%20supported%C2%A0SDKs) documentation for verification.
+
+<table>
+ <thead>
+ <tr>
+ <th>Cordova-iOS Version</th>
+ <th>iOS Minimum-Support</th>
+ <th>Tooling Version</th>
+ </tr>
+ </thead>
+ <tbody>
+ <tr>
+ <td>7.x</td>
+ <td>11.0</td>
+ <td>
+ <ul>
+ <li>Cocoapods: >=1.8.0</li>
+ <li>ios-deploy: >=1.9.2</li>
+ <li>Node: >=16.13.0</li>
+ <li>Xcode (xcodebuild): >=11.0.0</li>
+ </ul>
+ </td>
+ </tr>
+ <tr>
+ <td>6.x</td>
+ <td>11.0</td>
+ <td>
+ <ul>
+ <li>Cocoapods: >=1.8.0</li>
+ <li>ios-deploy: >=1.9.2</li>
+ <li>Node: >=10.0.0</li>
+ <li>Xcode (xcodebuild): >=11.0.0</li>
+ </ul>
+ </td>
+ </tr>
+ <tr>
+ <td>5.x</td>
+ <td>10.0</td>
+ <td>
+ <ul>
+ <li>Cocoapods: >=1.0.1</li>
+ <li>ios-deploy: >=1.9.2</li>
+ <li>Node: >=6.0.0</li>
+ <li>Xcode (xcodebuild): >=10.0.0</li>
+ </ul>
+ </td>
+ </tr>
+ </tbody>
+</table>
+
+## 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.
+| Automatic Provisioning | `--automaticProvisioning` | (Optional) Enable to allow Xcode to automatically manage provisioning profiles. Valid options are `false` (the default) and `true`.
+| Authentication Key Path | `--authenticationKeyPath` | (Optional) The path to an [App Store Connect API](https://developer.apple.com/documentation/appstoreconnectapi/creating_api_keys_for_app_store_connect_api) p8 key file, for automatic distribution signing.
+| Authentication Key ID | `--authenticationKeyID` | (Optional) The key ID for the App Store Connect API key file, for automatic distribution signing.
+| Authentication Key Issuer ID | `--authenticationKeyIssuerID` | (Optional) The issuer ID value for the App Store Connect API credentials,for automatic distribution signing.
+
+
+These parameters can be specified using the command line arguments above to the Cordova CLI `build` or `run` commands.
+
+**Note**: You should use double `--` to indicate that these are platform-specific arguments, for example:
+
+`cordova run ios --release -- --codeSignIdentity="iPhone Developer" --developmentTeam=FG35JLLMXX4A --packageType=development`.
+
+### Using build.json
+
+Alternatively, you could specify these flags in a build configuration file (default: `build.json` or add the `--buildConfig` flag to the same commands, so you can also use other file names e.g. `cordova build ios --buildConfig=../customBuild.json`). 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
+ },
+ "release": {
+ "codeSignIdentity": "iPhone Developer",
+ "developmentTeam": "FG35JLLMXX4A",
+ "packageType": "app-store",
+ "automaticProvisioning": true,
+ "authenticationKeyPath": "/path/to/AuthKey_D383SF739.p8",
+ "authenticationKeyID": "D383SF739",
+ "authenticationKeyIssuerID": "6053b7fe-68a8-4acb-89be-165aa6465141"
+ }
+ }
+}
+```
+
+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"
+ }
+ }
+}
+```
+
+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.
+
+## 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/12.x/guide/platforms/ios/plugin.md b/www/docs/en/12.x/guide/platforms/ios/plugin.md
new file mode 100644
index 0000000000..f1ba5c1c7f
--- /dev/null
+++ b/www/docs/en/12.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 allow list, as
+ described in Domain [Allow List Guide](../../appdev/allowlist/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/12.x/guide/platforms/ios/upgrade.md b/www/docs/en/12.x/guide/platforms/ios/upgrade.md
new file mode 100644
index 0000000000..04e23aed98
--- /dev/null
+++ b/www/docs/en/12.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/12.x/guide/platforms/ios/webview.md b/www/docs/en/12.x/guide/platforms/ios/webview.md
new file mode 100644
index 0000000000..85d9e5a5d9
--- /dev/null
+++ b/www/docs/en/12.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](https://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="https://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/12.x/guide/support/index.md b/www/docs/en/12.x/guide/support/index.md
new file mode 100644
index 0000000000..818ef451a4
--- /dev/null
+++ b/www/docs/en/12.x/guide/support/index.md
@@ -0,0 +1,198 @@
+---
+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 Support
+toc_title: Platform Support
+description: Compatibility table for all major plugins and features.
+---
+
+# Platform Support
+
+The table below provides a comprehensive overview of the supported development platforms, core plugins, and features for each platform.
+
+For additional functionality, you can explore a wide range of third-party plugins available on the [npm registry](https://www.npmjs.com/search?q=keywords:ecosystem:cordova).
+
+<!-- START HTML -->
+
+<table class="compat" width="100%">
+
+<thead>
+ <tr>
+ <th></th>
+ <th colspan="3">Platforms</th>
+ </tr>
+ <tr>
+ <th></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/electron/index.html">Electron</a></th>
+ </tr>
+</thead>
+
+<tbody>
+ <tr>
+ <th colspan="4"><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="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="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="electron" class="y"></td>
+ </tr>
+
+ <tr>
+ <th colspan="4"><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="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="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="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="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="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="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="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="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="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="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="electron" class="p">Tests Pending</td>
+ </tr>
+
+ <tr>
+ <th><a href="../../core/features/splashscreen/index.html">Splashscreen</a></th>
+ <td data-col="android" class="y"></td>
+ <td data-col="ios" 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="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="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="electron" class="n"></td>
+ </tr>
+
+ <tr>
+ <th colspan="4"><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="electron"> - </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="electron"> - </td>
+ </tr>
+</tbody>
+</table>
+
+<!-- END HTML -->
diff --git a/www/docs/en/12.x/index.md b/www/docs/en/12.x/index.md
new file mode 100644
index 0000000000..db1dda4da3
--- /dev/null
+++ b/www/docs/en/12.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/12.x/platform_pinning/index.md b/www/docs/en/12.x/platform_pinning/index.md
new file mode 100644
index 0000000000..3db0b0b86d
--- /dev/null
+++ b/www/docs/en/12.x/platform_pinning/index.md
@@ -0,0 +1,71 @@
+---
+license: >
+ Licensed to the Apache Software Foundation (ASF) under one
+ or more contributor license agreements. See the NOTICE file
+ distributed with this work for additional information
+ regarding copyright ownership. The ASF licenses this file
+ to you under the Apache License, Version 2.0 (the
+ "License"); you may not use this file except in compliance
+ with the License. You may obtain a copy of the License at
+
+ http://www.apache.org/licenses/LICENSE-2.0
+
+ Unless required by applicable law or agreed to in writing,
+ software distributed under the License is distributed on an
+ "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ KIND, either express or implied. See the License for the
+ specific language governing permissions and limitations
+ under the License.
+
+title: Platform Pinning
+toc_title: Platform Pinning
+description: Cordova CLI pinned platform versions.
+---
+
+## Platform Pinning
+
+### Cordova CLI 12.x & Higher
+
+Starting from Cordova CLI 12.0.0, the CLI no longer maintains a list of pinned Apache Cordova platforms.
+
+When you run the `cordova platform add <PLATFORM>` command, it will always fetch the latest available platform from the npm registry. This ensures immediate access to newly released platforms.
+
+If you want to consistently fetch a specific version, you need to modify the command and include the version pinning. For example, use `cordova platform add <PLATFORM>@<VERSION>`.
+
+The `cordova platform list` command displays the list of platforms without their versions. However, it will continue to show the versions of the installed platforms.
+
+**Example Output:**
+
+```bash
+$ cordova platform list
+Installed platforms:
+ android 12.0.0
+Available platforms:
+ browser
+ electron
+ ios
+```
+
+### Cordova CLI 11.x & Lower
+
+Cordova CLI 11.x and lower versions still use platform pinning but won't receive further updates since Cordova CLI 12.0.0 has been released. Platforms are pinned with a `^` symbol, allowing the CLI to fetch new minor and patch releases for the pinned platforms.
+
+To view the pinned platforms for your CLI version, run the command `cordova platform list` in a new project directory.
+
+**Example Output:**
+
+```bash
+$ cordova platform list
+Installed platforms:
+
+Available platforms:
+ android ^10.1.1
+ browser ^6.0.0
+ electron ^3.0.0
+ ios ^6.2.0
+ osx ^6.0.0 (deprecated)
+```
+
+Based on the above information, executing `cordova platform add android` will fetch the latest minor/patch release version starting from 10.1.1 or higher. If you specify a version, it will fetch the specified version. For example, `cordova platform add ios@5.0.1` will fetch Cordova iOS 5.0.1.
+
+_Note: After installing a platform, the "**Installed platforms:**" section will display the actual installed platform version. The installed platform will no longer appear in the "**Available platforms:**" section until it is removed from the project._
diff --git a/www/docs/en/12.x/platform_plugin_versioning_ref/index.md b/www/docs/en/12.x/platform_plugin_versioning_ref/index.md
new file mode 100644
index 0000000000..e9c65eeaa7
--- /dev/null
+++ b/www/docs/en/12.x/platform_plugin_versioning_ref/index.md
@@ -0,0 +1,356 @@
+---
+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: Version Management
+toc_title: Version Management
+description: How to manage platforms & plugins versions.
+---
+
+# 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 update with the platform dependency and cordova related information.
+
+Example:
+
+```json
+"cordova": {
+ "platforms": [
+ "android"
+ ]
+},
+"dependencies": {
+ "cordova-android": "^8.0.0",
+}
+```
+
+The `--nosave` flag prevents adding and deleting the specified platform from the `package.json` file.
+
+Example:
+
+```bash
+cordova platform add <platform[@<version>] | directory | git_url> --nosave
+```
+
+The examples below fetch the package, extract it to `node_modules` and update the `package.json` file accordingly. Under the covers, this process is controlled by the npm CLI. Here are various ways to add platforms.
+
+*Adding with Cordova resolved name:*
+
+Example:
+
+```bash
+cordova platform add android
+```
+
+The avaialble Cordova resolved names are:
+
+| Cordova Resolved Name | NPM Package Name |
+| --- | --- |
+| `android` | `cordova-android` |
+| `electron` | `cordova-electron` |
+| `ios` | `cordova-ios` |
+| `browser` | `cordova-browser` |
+
+*Adding with Cordova resolved name and pinned version:*
+
+Example:
+
+```bash
+cordova platform add android@7.1.4
+```
+
+This command will explicitly fetch for version `7.1.4`.
+
+*Adding with npm package name:*
+
+Example:
+
+```bash
+cordova platform add cordova-android
+```
+
+*Adding with Git URL:*
+
+Example:
+
+```bash
+cordova platform add https://github.com/apache/cordova-android.git
+```
+
+or
+
+```bash
+cordova platform add https://github.com/apache/cordova-android
+```
+
+or
+
+```bash
+cordova platform add github:apache/cordova-android
+```
+
+* **`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/12.x/plugin_ref/plugman.md b/www/docs/en/12.x/plugin_ref/plugman.md
new file mode 100644
index 0000000000..d9729bd575
--- /dev/null
+++ b/www/docs/en/12.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](https://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](https://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](https://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>
+```
+
+This will contact the plugin registry and fetch information such as the plugin's version number.
+
+## Installing Core Plugins
+
+The examples below show how to add plugins as needed so that any
+Cordova APIs you use in your project still work after you upgrade to
+version 3.0. For each command, you need to select the target
+platform, and reference the platform's project directory.
+
+* cordova-plugin-battery-status
+
+ ```bash
+ plugman install --platform <ios|android> --project <directory> --plugin cordova-plugin-battery-status
+ ```
+
+* cordova-plugin-camera
+
+ ```bash
+ plugman install --platform <ios|android> --project <directory> --plugin cordova-plugin-camera
+ ```
+
+* cordova-plugin-console
+
+ ```bash
+ plugman install --platform <ios|android> --project <directory> --plugin cordova-plugin-console
+ ```
+
+* cordova-plugin-contacts
+
+ ```bash
+ plugman install --platform <ios|android> --project <directory> --plugin cordova-plugin-contacts
+ ```
+
+* cordova-plugin-device
+
+ ```bash
+ plugman install --platform <ios|android> --project <directory> --plugin cordova-plugin-device
+ ```
+
+* cordova-plugin-device-motion (accelerometer)
+
+ ```bash
+ plugman install --platform <ios|android> --project <directory> --plugin cordova-plugin-device-motion
+ ```
+
+* cordova-plugin-device-orientation (compass)
+
+ ```bash
+ plugman install --platform <ios|android> --project <directory> --plugin cordova-plugin-device-orientation
+ ```
+
+* cordova-plugin-dialogs
+
+ ```bash
+ plugman install --platform <ios|android> --project <directory> --plugin cordova-plugin-dialogs
+ ```
+
+* cordova-plugin-file
+
+ ```bash
+ plugman install --platform <ios|android> --project <directory> --plugin cordova-plugin-file
+ ```
+
+* cordova-plugin-file-transfer
+
+ ```bash
+ plugman install --platform <ios|android> --project <directory> --plugin cordova-plugin-file-transfer
+ ```
+
+* cordova-plugin-geolocation
+
+ ```bash
+ plugman install --platform <ios|android> --project <directory> --plugin cordova-plugin-geolocation
+ ```
+
+* cordova-plugin-globalization
+
+ ```bash
+ plugman install --platform <ios|android> --project <directory> --plugin cordova-plugin-globalization
+ ```
+
+* cordova-plugin-inappbrowser
+
+ ```bash
+ plugman install --platform <ios|android> --project <directory> --plugin cordova-plugin-inappbrowser
+ ```
+
+* cordova-plugin-media
+
+ ```bash
+ plugman install --platform <ios|android> --project <directory> --plugin cordova-plugin-media
+ ```
+
+* cordova-plugin-media-capture
+
+ ```bash
+ plugman install --platform <ios|android> --project <directory> --plugin cordova-plugin-media-capture
+ ```
+
+* cordova-plugin-network-information
+
+ ```bash
+ plugman install --platform <ios|android> --project <directory> --plugin cordova-plugin-network-information
+ ```
+
+* cordova-plugin-splashscreen
+
+ ```bash
+ plugman install --platform <ios|android> --project <directory> --plugin cordova-plugin-splashscreen
+ ```
+
+* cordova-plugin-vibration
+
+ ```bash
+ plugman install --platform <ios|android> --project <directory> --plugin cordova-plugin-vibration
+ ```
diff --git a/www/docs/en/12.x/plugin_ref/spec.md b/www/docs/en/12.x/plugin_ref/spec.md
new file mode 100644
index 0000000000..818c515a37
--- /dev/null
+++ b/www/docs/en/12.x/plugin_ref/spec.md
@@ -0,0 +1,675 @@
+---
+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.xml API
+toc_title: Plugin.xml API
+description: List of supported tags in the plugin.xml file.
+---
+
+{% cdv_platform inject %}
+
+# Plugin.xml API
+
+Plugin.xml file defines the structure and settings required for your plugin. It has several elements to provide details about your plugin.
+
+# plugin
+
+The `plugin` element is the plugin manifest's top-level element.
+
+Attributes | Description
+---------------- | ------------
+xmlns<br />{% cdv_vartype string %}| *Required* <br/> The plugin namespace, `http://apache.org/cordova/ns/plugins/1.0`. If the document contains XML from other namespaces, such as tags to be added to the `AndroidManifest.xml` file in the case of Android, those namespaces should also be included in the <plugin> element.
+id<br />{% cdv_vartype string %}| *Required* <br/> A npm-style identifier for the plugin.
+version<br />{% cdv_vartype string %}| *Required* <br/> A version number for the plugin. [Semver](https://semver.org/) syntax is supported.
+
+Example:
+```xml
+<?xml version="1.0" encoding="UTF-8"?>
+<plugin xmlns="http://apache.org/cordova/ns/plugins/1.0"
+ xmlns:android="http://schemas.android.com/apk/res/android"
+ id="my-plugin-id"
+ version="1.0.2">
+```
+
+## engines and engine
+
+The child elements of the `<engines>` element specify versions of Apache Cordova-based frameworks that this plugin supports. The CLI aborts with a non-zero code for any plugin whose target project does not meet the engine's constraints. If no <engine> tags are specified, the CLI attempts to install into the specified cordova project directory blindly.
+
+>NOTE: In **Cordova 6.1.0+**, the recommended place to specify platform, plugin, and CLI dependencies
+>is in a plugin's `package.json`. See [specifying Cordova dependencies](../guide/hybrid/plugins/index.html#specifying-cordova-dependencies)
+>for more information
+
+Attributes | Description
+---------------- | ------------
+name<br />{% cdv_vartype string %}| *Required* <br/>Name of the engine. Here are the default engines that are supported: `cordova`, `cordova-plugman`, `cordova-android`, `cordova-browser`, `cordova-ios`, `windows-os`, `android-sdk` (returns the highest Android api level installed) , `apple-xcode` (returns the xcode version), `apple-ios` (returns the highest iOS version installed), `apple-osx` (returns the macOS version). You can also specify a custom framework apart from the default ones.
+version<br />{% cdv_vartype string %}| *Required* <br/> The version that your framework must have in order to install. Semver syntax is supported.
+scriptSrc<br />{% cdv_vartype string %}| **For custom frameworks only** <br/> *Required* <br/> The script file that tells plugman the version of the custom framework. Ideally, this file should be within the top level directory of your plugin directory.
+platform<br />{% cdv_vartype string %}| **For custom frameworks only** <br/> *Required* <br/> The platforms your framework supports. You may use the wildcard `*` to say supported for all platforms, specify multiple with a pipe character like `android|ios` or just a single platform like `android`.
+
+Examples:
+```xml
+<engines>
+ <engine name="cordova-android" version="=1.8.0" />
+</engines>
+```
+
+Engine elements may also specify fuzzy matches using '>', '>=' etc. to avoid repetition, and to reduce maintenance when the underlying platform is updated.
+```xml
+<engines>
+ <engine name="cordova-android" version=">=1.8.0" />
+</engines>
+```
+
+The `<engine>` tags also has default support for all of the main platforms Cordova exists on. Specifying the cordova engine tag means that all versions of Cordova on any platform must satisfy the engine version attribute. You may also list specific platforms and their versions in order to override the catch-all cordova engine:
+```xml
+<engines>
+ <engine name="cordova" version=">=1.7.0" />
+ <engine name="cordova-android" version=">=1.8.0" />
+ <engine name="cordova-ios" version=">=1.7.1" />
+</engines>
+```
+
+Custom frameworks example:
+```xml
+<engines>
+ <engine name="my_custom_framework" version="1.0.0" platform="android" scriptSrc="path_to_my_custom_framework_version"/>
+ <engine name="another_framework" version=">0.2.0" platform="ios|android" scriptSrc="path_to_another_framework_version"/>
+ <engine name="even_more_framework" version=">=2.2.0" platform="*" scriptSrc="path_to_even_more_framework_version"/>
+</engines>
+```
+
+## name
+
+The `name` element is used to specify the name of the plugin. This element does not (yet) handle localization.
+
+Example:
+```xml
+<name>Foo</name>
+```
+
+## description
+
+The `description` element is used to specify the description of the plugin. This element does not (yet) handle localization.
+
+Example:
+```xml
+<description>Foo plugin description</description>
+```
+
+## author
+
+The content of the `author` element contains the name of the plugin author.
+
+Example:
+```xml
+<author>Foo plugin author</author>
+```
+
+## keywords
+
+The content of the `keywords` element contains comma separated keywords to describe the plugin.
+
+Example:
+```xml
+<keywords>foo,bar</keywords>
+```
+
+## license
+
+This element is used to specify the license of the plugin.
+
+Example:
+```xml
+<license>Apache 2.0 License</license>
+```
+
+## asset
+
+This element is used to list the files or directories to be copied into a Cordova app's `www` directory. Any `<asset>` elements that are nested within `<platform>` elements specify platform-specific web assets.
+
+Attributes | Description
+---------------- | ------------
+src<br />{% cdv_vartype string %}| *Required* <br/> Where the file or directory is located in the plugin package, relative to the `plugin.xml` document. If a file does not exist at the specified src location, the CLI stops and reverses the installation process, issues a notification about the conflict, and exits with a non-zero code.
+target<br />{% cdv_vartype string %}| *Required* <br/> Where the file or directory should be located in the Cordova app, relative to the `www` directory. If a file already exists at the target location, the CLI stops and reverses the installation process, issues a notification about the conflict, and exits with a non-zero code.
+
+Examples:
+```xml
+<!-- a single file, to be copied in the root directory -->
+<asset src="www/foo.js" target="foo.js" />
+<!-- a directory, also to be copied in the root directory -->
+<asset src="www/foo" target="foo" />
+```
+
+Assets can be targeted to subdirectories as well. This will create the `js/experimental` directory within the `www` directory, unless already present, and copy the `new-foo.js` file and renames it to `foo.js`.
+```xml
+<asset src="www/new-foo.js" target="js/experimental/foo.js" />
+```
+
+## js-module
+
+Most plugins include one or more JavaScript files. Each `<js-module>` tag corresponds to a JavaScript file, and prevents the plugin's users from having to add a `<script>` tag for each file. Do not wrap the file with cordova.define, as it is added automatically. The module is wrapped in a closure, with module, exports, and require in scope, as is normal for AMD modules. Nesting `<js-module>` elements within `<platform>` declares platform-specific JavaScript module bindings.
+
+Attributes | Description
+---------------- | ------------
+src<br />{% cdv_vartype string %}| References a file in the plugin directory relative to the `plugin.xml` file. If src does not resolve to an existing file, the CLI stops and reverses the installation, issues a notification of the problem, and exits with a non-zero code.
+name<br />{% cdv_vartype string %}| Provides the last part of the module name. It can generally be whatever you like, and it only matters if you want to use cordova.require to import other parts of your plugins in your JavaScript code. The module name for a `<js-module>` is your plugin's id followed by the value of name.
+
+Example:
+
+When installing a plugin with the example below, socket.js is copied to `www/plugins/my-plugin-id/socket.js`, and added as an entry to `www/cordova_plugins.js`. At load time, code in `cordova.js` uses XHR to read each file and inject a `<script>` tag into HTML.
+```xml
+<js-module src="socket.js" name="Socket">
+</js-module>
+```
+Also for this example, with a plugin id of `chrome-socket`, the module name will be `chrome-socket.Socket`.
+
+### clobbers
+
+Allowed within `<js-module>` element. Used to specify the namespace under `window` object where module.exports gets inserted. You can have as many `<clobbers>` as you
+like. Any object not available on `window` is created.
+
+Attributes | Description
+---------------- | ------------
+target<br />{% cdv_vartype string %}| The namespace where module.exports gets inserted to.
+
+Example:
+```xml
+<js-module src="socket.js" name="Socket">
+ <clobbers target="chrome.socket" />
+</js-module>
+```
+Here module.exports gets inserted into the `window` object as `window.chrome.socket`.
+
+### merges
+
+Allowed within `<js-module>` element. Used to specify the namespace under `window` object where module.exports gets merged with any existing value. If any key already exists, the module's version overrides the original. You can have as many `<merges>` as you like. Any object not available on `window` is created.
+
+Attributes | Description
+---------------- | ------------
+target<br />{% cdv_vartype string %}| The namespace which module.exports gets merged to.
+
+Example:
+```xml
+<js-module src="socket.js" name="Socket">
+ <merges target="chrome.socket" />
+</js-module>
+```
+Here module.exports gets merged with any existing value at `window.chrome.socket`.
+
+### runs
+
+Allowed within `<js-module>` element. It implies that your code should be specified with `cordova.require`, but not installed on the `window` object. This is useful when initializing the module, attaching event handlers or otherwise. You can only have up to one `<runs/>` tag. Note that including a `<runs/>` with `<clobbers/>` or `<merges/>` is redundant, since they also `cordova.require` your module.
+
+Example:
+```xml
+<js-module src="socket.js" name="Socket">
+ <runs/>
+</js-module>
+```
+
+## dependency
+
+The `<dependency>` tag allows you to specify other plugins on which the current plugin depends. The plugins are referenced by their unique npm ids or by github url.
+
+Attributes | Description
+---------------- | ------------
+id<br />{% cdv_vartype string %}| Provides the ID of the plugin.
+url<br />{% cdv_vartype string %}| A URL for the plugin. This should reference a git repository, which the CLI attempts to clone.
+commit<br />{% cdv_vartype string %}| This is any git reference understood by `git checkout`: a branch or tag name (e.g., `master`, `0.3.1`), or a commit hash (e.g., `975ddb228af811dd8bb37ed1dfd092a3d05295f9`).
+subdir<br />{% cdv_vartype string %}| Specifies that the targeted plugin dependency exists as a subdirectory of the git repository. This is helpful because it allows the repository to contain several related plugins, each specified individually. <br/> If you set the `url` of a `<dependency>` tag to `"."` and provide a `subdir`, the dependent plugin is installed from the same local or remote git repository as the parent plugin that specifies the `<dependency>` tag. <br/> Note that the `su [...]
+version<br />{% cdv_vartype string %}| The version of the plugin depended on. Semver syntax is supported.
+
+Examples:
+```xml
+<dependency id="cordova-plugin-someplugin" url="https://github.com/myuser/someplugin" commit="428931ada3891801" subdir="some/path/here" />
+<dependency id="cordova-plugin-someplugin" version="1.0.1" />
+```
+
+## platform
+
+Identifies platforms that have associated native code or require modifications to their configuration files. Tools using this specification can identify supported platforms and install the code into Cordova projects. Plugins without `<platform>` tags are assumed to be JavaScript-only, and therefore installable on any and all platforms.
+
+Attributes | Description
+---------------- | ------------
+name<br />{% cdv_vartype string %}| *Required* <br/> Allowed values: ios, android, browser, electron <br/> Identifies a platform as supported, associating the element's children with that platform.
+
+Example:
+```xml
+<platform name="android">
+ <!-- android-specific elements -->
+</platform>
+```
+
+## source-file
+
+Identifies executable source code that should be installed into a project.
+
+Attributes | Description
+---------------- | ------------
+src<br />{% cdv_vartype string %}| *Required* <br/> Location of the file relative to `plugin.xml`. If the src file can't be found, the CLI stops and reverses the installation, issues a notification about the problem, and exits with a non-zero code.
+target-dir<br />{% cdv_vartype string %}| A directory into which the files should be copied, relative to the root of the Cordova project. In practice, this is most important for Java-based platforms, where a file in the `com.alunny.foo` package must be located within the `com/alunny/foo` directory. For platforms where the source directory is not important, this attribute should be omitted.
+framework<br />{% cdv_vartype boolean %} {% cdv_platform ios %} | *Default: false* <br/> If set to true, also adds the specified file as a framework to the project.
+compiler-flags<br />{% cdv_vartype string %} {% cdv_platform ios %} | If set, assigns the specified compiler flags for the particular source file.
+
+Examples:
+```xml
+<!-- android -->
+<source-file src="src/android/Foo.java" target-dir="src/com/alunny/foo" />
+<!-- ios -->
+<source-file src="src/ios/CDVFoo.m" />
+<source-file src="src/ios/someLib.a" framework="true" />
+<source-file src="src/ios/someLib.a" compiler-flags="-fno-objc-arc" />
+```
+
+## header-file
+
+This is like `<source-file>` element but specifically for platforms such as iOS and Android that distinguish between source files, headers, and resources.
+
+Attributes | Description
+---------------- | ------------
+src<br />{% cdv_vartype string %}| *Required* <br/> Location of the file relative to `plugin.xml`. If the src file can't be found, the CLI stops and reverses the installation, issues a notification about the problem, and exits with a non-zero code.
+target-dir<br />{% cdv_vartype string %}| A directory into which the files should be copied, relative to the root of the Cordova project.
+type<br />{% cdv_vartype string %} {% cdv_platform ios %} | If this value is `BridgingHeader`, the file is imported in the `Bridging-Header.h` and can be called from swift program.
+
+Example:
+
+For iOS:
+```xml
+<header-file src="CDVFoo.h" />
+<header-file src="CDVSomeHeader.h" type="BridgingHeader" />
+```
+
+## resource-file
+
+This is like `<source-file>` element, but specifically for platforms such as iOS and Android that distinguish between source files, headers, and resources.
+
+Attributes | Description
+---------------- | ------------
+src<br />{% cdv_vartype string %}| *Required* <br/> Location of the file relative to `plugin.xml`. If the src file can't be found, the CLI stops and reverses the installation, issues a notification about the problem, and exits with a non-zero code.
+target<br />{% cdv_vartype string %}| Path to where the file will be copied in your directory.
+
+Android Examples:
+
+```xml
+<resource-file src="FooPluginStrings.xml" target="res/values/FooPluginStrings.xml" />
+```
+
+## config-file
+
+Identifies an XML-based configuration file to be modified, where in that document the modification should take place, and what should be modified.
+Two file types that have been tested for modification with this element are `xml` and `plist` files.
+The `config-file` element only allows you to append new children to an XML document tree. The children are XML literals to be inserted in the target document.
+
+Attributes | Description
+---------------- | ------------
+target<br />{% cdv_vartype string %}| The file to be modified, and the path relative to the root of the Cordova project. If the specified file does not exist, the tool ignores the configuration change and continues installation. <br/> The target can include wildcard (`*`) elements. In this case, the CLI recursively searches through the project directory structure and uses the first match. <br/> On iOS, the location of configuration files relative to the project directory root is not know [...]
+parent<br />{% cdv_vartype string %}| An XPath selector referencing the parent of the elements to be added to the config file. If you use absolute selectors, you can use a wildcard (`*`) to specify the root element, e.g., `/*/plugins`. If the selector does not resolve to a child of the specified document, the tool stops and reverses the installation process, issues a warning, and exits with a non-zero code. <br/> For `plist` files, the `parent` determines under what parent key the specif [...]
+after<br />{% cdv_vartype string %}| A prioritized list of accepted siblings after which to add the XML snippet. Useful for specifying changes in files which require strict ordering of XML elements.
+
+Examples:
+
+For XML:
+```xml
+<config-file target="AndroidManifest.xml" parent="/manifest/application">
+ <activity android:name="com.foo.Foo" android:label="@string/app_name">
+ <intent-filter>
+ </intent-filter>
+ </activity>
+</config-file>
+```
+
+For `plist`:
+```xml
+<config-file target="*-Info.plist" parent="CFBundleURLTypes">
+ <array>
+ <dict>
+ <key>PackageName</key>
+ <string>$PACKAGE_NAME</string>
+ </dict>
+ </array>
+</config-file>
... 7409 lines suppressed ...
---------------------------------------------------------------------
To unsubscribe, e-mail: commits-unsubscribe@cordova.apache.org
For additional commands, e-mail: commits-help@cordova.apache.org