Plugin.xml reference documentation

Plugin.xml file defines the structure and settings required for your plugin. It has several elements to provide details about your plugin.

The plugin element is the plugin manifest's top-level element.

Example:

<?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 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 for more information

Examples:

<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.

<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:

<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:

<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:

<name>Foo</name>

description

The description element is used to specify the description of the plugin. This element does not (yet) handle localization.

Example:

<description>Foo plugin description</description>

author

The content of the author element contains the name of the plugin author.

Example:

<author>Foo plugin author</author>

keywords

The content of the keywords element contains comma separated keywords to describe the plugin.

Example:

<keywords>foo,bar</keywords>

license

This element is used to specify the license of the plugin.

Example:

<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.

Examples:

<!-- 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.

<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.

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.

<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.

Example:

<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.

Example:

<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:

<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.

Examples:

<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.

Example:

<platform name="android">
  <!-- android-specific elements -->
</platform>

source-file

Identifies executable source code that should be installed into a project.

Examples:

<!-- 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. This is not supported by Windows.

Example:

For iOS:

<header-file src="CDVFoo.h" />

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.

Examples:

For Android:

<resource-file src="FooPluginStrings.xml" target="res/values/FooPluginStrings.xml" />

For Windows:

<resource-file src="src/windows/win81/MobServices.pri" target="win81/MobServices.pri" device-target="windows" versions="8.1" arch="x64"/>

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.

Examples:

For 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:

<config-file target="*-Info.plist" parent="CFBundleURLTypes">
    <array>
        <dict>
            <key>PackageName</key>
            <string>$PACKAGE_NAME</string>
        </dict>
    </array>
</config-file>

For windows-specific attributes:

<config-file target="package.appxmanifest" parent="/Package/Capabilities" versions="<8.1.0">
    <Capability Name="picturesLibrary" />
    <DeviceCapability Name="webcam" />
</config-file>
<config-file target="package.appxmanifest" parent="/Package/Capabilities" versions=">=8.1.0" device-target="phone">
    <DeviceCapability Name="webcam" />
</config-file>

The above example will set pre-8.1 platforms (Windows 8, specifically) to require the webcam device capability and the picturesLibrary general capability, and apply the webcam device capability only to Windows 8.1 projects that build for Windows Phone. Windows desktop 8.1 systems are unmodified.

plugins-plist

Specifies a key and value to append to the correct AppInfo.plist file in an iOS Cordova project. This is outdated as it only applies to cordova-ios 2.2.0 and below. Use the <config-file> tag for newer versions of Cordova.

Example:

<plugins-plist key="Foo" string="CDVFoo" />

lib-file

Like source, resource, and header files, but specifically for platforms such as BlackBerry 10 that use user-generated libraries. For the Windows platform, the <lib-file> element allows the inclusion of an <SDKReference> in the generated Windows project files.

Examples:

<lib-file src="src/BlackBerry10/native/device/libfoo.so" arch="device" />
<lib-file src="src/BlackBerry10/native/simulator/libfoo.so" arch="simulator" />

For Windows:

<lib-file src="Microsoft.WinJS.2.0, Version=1.0" arch="x86" />
<lib-file src="Microsoft.WinJS.2.0, Version=1.0" versions=">=8.1" />
<lib-file src="Microsoft.WinJS.2.0, Version=1.0" target="phone" />
<lib-file src="Microsoft.WinJS.2.0, Version=1.0" target="win" versions="8.0" arch="x86" />

framework

Identifies a framework (usually part of the OS/platform) on which the plugin depends.

Examples:

For iOS:

<framework src="libsqlite3.dylib" />
<framework src="social.framework" weak="true" />
<framework src="relative/path/to/my.framework" custom="true" />

On Android (as of cordova-android@4.0.0), framework tags are used to include Maven dependencies, or to include bundled library projects.

<!-- Depend on latest version of GCM from play services -->
<framework src="com.google.android.gms:play-services-gcm:+" />
<!-- Depend on v21 of appcompat-v7 support library -->
<framework src="com.android.support:appcompat-v7:21+" />
<!-- Depend on library project included in plugin -->
<framework src="relative/path/FeedbackLib" custom="true" />

Framework can also be used to have custom .gradle files sub-included into the main project's .gradle file:

<framework src="relative/path/rules.gradle" custom="true" type="gradleReference" />

On Windows, using custom='true' and type='projectReference' will add a reference to the project which will be added to the compile+link steps of the cordova project. This essentially is the only way currently that a 'custom' framework can target multiple architectures as they are explicitly built as a dependency by the referencing cordova application.

<framework src="path/to/project/LibProj.csproj" custom="true" type="projectReference"/>

Examples of using these Windows specific attributes:

<framework src="src/windows/example.dll" arch="x64" />
<framework src="src/windows/example.dll" versions=">=8.0" />
<framework src="src/windows/example.vcxproj" type="projectReference" target="win" />
<framework src="src/windows/example.vcxproj" type="projectReference" target="all" versions="8.1" arch="x86" />
<framework src="src/windows/example.dll" target-dir="bin/x64" arch="x64" custom="true"/>

info

Additional information provided to users. This is useful when you require extra steps that can't be easily automated or are beyond the CLI's scope. The contents of this tag gets printed out when the CLI installs the plugin.

Example:

<info>
You need to install __Google Play Services__ from the `Android Extras` section using the Android SDK manager (run `android`).

You need to add the following line to the `local.properties`:

android.library.reference.1=PATH_TO_ANDROID_SDK/sdk/extras/google/google_play_services/libproject/google-play-services_lib
</info>

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 for more information.

Example:

<hook type="after_plugin_install" src="scripts/afterPluginInstall.js" />

uses-permission

In certain cases, a plugin may need to make configuration changes dependent on the target application. For example, to register for C2DM on Android, an app whose package id is my-app-id would require a permission such as:

<uses-permission android:name="my-app-id.permission.C2D_MESSAGE"/>

In such cases where the content inserted from the plugin.xml file is not known ahead of time, variables can be indicated by a dollar-sign followed by a series of capital letters, digits, or underscores. For the above example, the plugin.xml file would include this tag:

<uses-permission android:name="$PACKAGE_NAME.permission.C2D_MESSAGE"/>

The CLI replaces variable references with the specified value, or the empty string if not found. The value of the variable reference may be detected (in this case, from the AndroidManifest.xml file) or specified by the user of the tool; the exact process is dependent on the particular tool.

Plugman can request users to specify a plugin's required variables. For example, API keys for C2M and Google Maps can be specified as a command-line argument:

plugman --platform android --project /path/to/project --plugin name|git-url|path --variable API_KEY=!@CFATGWE%^WGSFDGSDFW$%^#$%YTHGsdfhsfhyer56734

Certain variable names should be reserved, like $PACKAGE_NAME. This is the reverse-domain style unique identifier for the package, corresponding to the CFBundleIdentifier on iOS or the package attribute of the top-level manifest element in an AndroidManifest.xml file.

preference

As seen in the previous section, sometimes plugin might require user to specify values for their variables. To make those variable mandatory, the <platform> tag needs to contain a <preference> tag. The CLI checks that these required preferences are passed in. If not, it should warn the user how to pass the variable in and exit with a non-zero code.

Example:

<preference name="API_KEY" default="default-value" />