You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@cordova.apache.org by mw...@apache.org on 2013/06/19 20:46:53 UTC
[03/12] Version 2.9.0rc1
http://git-wip-us.apache.org/repos/asf/cordova-docs/blob/50865138/docs/en/2.9.0rc1/guide/plugin-development/android/index.md
----------------------------------------------------------------------
diff --git a/docs/en/2.9.0rc1/guide/plugin-development/android/index.md b/docs/en/2.9.0rc1/guide/plugin-development/android/index.md
new file mode 100644
index 0000000..2f372e7
--- /dev/null
+++ b/docs/en/2.9.0rc1/guide/plugin-development/android/index.md
@@ -0,0 +1,192 @@
+---
+license: Licensed to the Apache Software Foundation (ASF) under one
+ or more contributor license agreements. See the NOTICE file
+ distributed with this work for additional information
+ regarding copyright ownership. The ASF licenses this file
+ to you under the Apache License, Version 2.0 (the
+ "License"); you may not use this file except in compliance
+ with the License. You may obtain a copy of the License at
+
+ http://www.apache.org/licenses/LICENSE-2.0
+
+ Unless required by applicable law or agreed to in writing,
+ software distributed under the License is distributed on an
+ "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ KIND, either express or implied. See the License for the
+ specific language governing permissions and limitations
+ under the License.
+---
+
+# Developing a Plugin on Android
+
+Writing a plugin requires an understanding of the architecture of Cordova-Android. Cordova-Android consists
+of an Android WebView with hooks attached to it. These plugins are represented as class mappings in the config.xml
+file.
+
+A plugin consists of at least one Java class that extends the `CordovaPlugin` class. A plugin must override one
+of the `execute` methods from `CordovaPlugin`.
+As best practice, the plugin should handle `pause` and `resume` events, and any message passing between plugins.
+Plugins with long-running requests, background activity such as media payback, listeners, or internal state should implement the `onReset()` method as well. This method is run when the `WebView` navigates to a new page or refreshes, which reloads the JavaScript.
+
+## Plugin Class Mapping
+
+The JavaScript portion of a plugin always uses the `cordova.exec` method as follows:
+
+ exec(<successFunction>, <failFunction>, <service>, <action>, [<args>]);
+
+This marshals a request from the WebView to the Android native side,
+more or less boiling down to calling the `action` method on the
+`service` class, with the arguments passed in the `args` Array.
+
+Whether you distribute your plugin as Java file or as a JAR of its own, the plugin must be added to the `config.xml` file in your Cordova-Android application's `res/xml/` folder.
+
+ <plugin name="<service_name>" value="<full_name_including_namespace>"/>
+
+The service name should match the one used in the JavaScript `exec`
+call, and the value is the Java classes full name, including the
+namespace. Otherwise the plugin may compile but still be unreachable
+by Cordova.
+
+## Writing an Android Java Plugin
+
+We have JavaScript to fire off a plugin request to the native side. We
+have the Android Java plugin mapped properly via the `config.xml` file.
+So what does the final Android Java Plugin class look like?
+
+What gets dispatched to the plugin via JavaScript's `exec` function gets
+passed into the Plugin class's `execute` method. Most `execute`
+implementations look like this:
+
+ @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.
+ }
+
+We compare the value of the `action` parameter, and dispatch the
+request off to a (private) method in the class, optionally passing
+some of the parameters to the method.
+
+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
+
+JavaScript in the WebView does *not* run on the UI thread. It runs on
+the WebCore thread. The `execute` method also runs on the WebCore thread.
+
+If you need to interact with the UI, you should use the following:
+
+ @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 want to block the WebCore thread:
+
+ @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;
+ }
+
+### Echo Android Plugin Example
+
+We would add the following to our config.xml:
+
+ <plugin name="Echo" value="org.apache.cordova.plugin.Echo" />
+
+Then we would add the following file to
+`src/org/apache/cordova/plugin/Echo.java` inside our Cordova-Android
+application:
+
+ package org.apache.cordova.plugin;
+
+ import org.apache.cordova.api.CordovaPlugin;
+ import org.apache.cordova.api.PluginResult;
+ 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.");
+ }
+ }
+ }
+
+Let's take a look at the code. The necessary `imports` are at
+the top. Our class extends from `CordovaPlugin`. We override the
+execute() method in order to recieve messages from exec(). Our method
+first compares against `action`: this plugin only supports one action,
+the `echo` action. Any other action returns false, which results in an
+error of type `INVALID_ACTION`, which translates into an error
+callback invocation on the JavaScript side. Next, we grab the echo
+string using the `getString` method on our `args`, telling it we want
+to get the 0th parameter in the parameter array. We do a bit of
+parameter checking: make sure it is not `null`, and make sure it is
+not a zero-length string. If it is, we call `callbackContext.error()`
+(which, by now, you should know invokes the error callback). If all of
+those checks pass, then we call `callbackContext.success()` and pass
+in the `message` string we received as a parameter. This finally
+translates into a success callback invocation on the JavaScript
+side. It also passes the `message` parameter as a parameter into the
+JavaScript success callback function.
+
+## Debugging Plugins
+
+Eclipse can be used to debug an Android project, and the plugins can be debugged if the Java source is included in the project. Only the latest version of the Android Developer Tools is known to allow source code attachment to JAR dependencies, so this is not fully supported at this time.
+
+## Common Pitfalls
+
+* Plugins have access to a `CordovaInterface` object. This object has access to the Android `Activity` that is running the application. This is the `Context` required to launch
+a new Android `Intent`. The `CordovaInterface` allows plugins to start an `Activity` for a result, and to set the callback plugin for when the `Intent` comes back to the application. This is important, since the
+`Intent`s system is how Android communicates between processes.
+* Plugins do not have direct access to the `Context` as they have in the past. The legacy `ctx` member is deprecated, and will be removed six months after 2.0 is released. All of `ctx` methods exist on the `Context`, so both `getContext()` and `getActivity()` are capable of returning the proper object required.
+
+## Use the Source
+
+One of the best ways to prepare yourself to write your own plugin is to
+[look over existing plugins](https://github.com/apache/cordova-android/tree/master/framework/src/org/apache/cordova).
+
+You should also read through the comments in [CordovaPlugin.java](https://github.com/apache/cordova-android/blob/master/framework/src/org/apache/cordova/api/CordovaPlugin.java).
http://git-wip-us.apache.org/repos/asf/cordova-docs/blob/50865138/docs/en/2.9.0rc1/guide/plugin-development/bada/index.md
----------------------------------------------------------------------
diff --git a/docs/en/2.9.0rc1/guide/plugin-development/bada/index.md b/docs/en/2.9.0rc1/guide/plugin-development/bada/index.md
new file mode 100644
index 0000000..a33b98c
--- /dev/null
+++ b/docs/en/2.9.0rc1/guide/plugin-development/bada/index.md
@@ -0,0 +1,74 @@
+---
+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.
+---
+
+Developing a Plugin on Bada
+===========================
+
+Plugins are only supported on Bada 2.0 and above. Bada 1.2 does not support plugins.
+
+The Bada implementation is a full JavaScript implementation. Therefore, adding a custom plugin involves updating CordovaJS with your plugin code. Follow these steps to add a simple _Hello World_ plugin:
+
+1. Clone the CordovaJS repository
+
+ git clone https://git-wip-us.apache.org/repos/asf/cordova-js.git
+
+2. Create a new JavaScript file under __lib/bada/plugin/bada/__ and name it _HelloWorld.js_. Add the following content:
+
+ function HelloWorld() {
+ }
+
+ HelloWorld.prototype.printHello = function(success, fail, arg) {
+ alert(Osp.Core.StringHelper('Hello %1', arg[0]));
+ }
+
+ module.exports = new HelloWorld();
+
+3. Add a link to your newly created plugin in __lib/bada/platform.js__ under the objects property:
+
+ objects: {
+ ...
+ HelloWorld: {
+ 'cordova/plugin/bada/HelloWorld'
+ },
+ ...
+ }
+ ...
+4. Update the plugin list under __lib/bada/exec.js__ to include your plugin
+
+ var plugins = {
+ ...
+ "HelloWorld": require('cordova/plugin/bada/HelloWorld')
+ };
+5. Now you can write your user-facing JavaScript however you like but remember that in order for your plugin to execute you need to call the following method
+
+ exec(success, fail, 'HelloWorld', 'printHello', ['Jackson!']);
+
+ success is the success callback that gets executed when the plugin succeeds
+ fail is the failure callback that gets executed if the plugin fails
+ 'HelloWorld' is the name of your plugin
+ 'printHello' is your plugin action
+ Finally, the last argument is your plugin parameters (if any).
+
+6. Run the following command to generate the new common JavaScript (make sure you have the jake npm module installed)
+
+ jake
+
+7. Copy the newly generated JavaScript under __pkg/cordova.bada.js__ to your Bada project under __Res/js__
+
+6. That is it! You can now add new Bada plugins and implement the many features that are not currently supported by Cordova Bada.
http://git-wip-us.apache.org/repos/asf/cordova-docs/blob/50865138/docs/en/2.9.0rc1/guide/plugin-development/blackberry/index.md
----------------------------------------------------------------------
diff --git a/docs/en/2.9.0rc1/guide/plugin-development/blackberry/index.md b/docs/en/2.9.0rc1/guide/plugin-development/blackberry/index.md
new file mode 100644
index 0000000..3e4fc30
--- /dev/null
+++ b/docs/en/2.9.0rc1/guide/plugin-development/blackberry/index.md
@@ -0,0 +1,153 @@
+---
+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.
+---
+
+Developing a Plugin on BlackBerry
+=================================
+
+## How to make the Echo plugin on Blackberry
+
+This guide explores how to develop the Echo plugin on BlackBerry.
+If you haven't read the top-level guide about the JavaScript part of
+the plugin, it would be best if you read that first and then this
+guide. In addition, please download the [Cordova Blackberry
+repo](https://git-wip-us.apache.org/repos/asf?p=cordova-blackberry-webworks.git;a=summary).
+
+The Cordova-BlackBerry project allows you to deploy to BlackBerry
+devices such a the Torch and Bold, as well as the Playbook. There's a
+difference between deploying to normal BlackBerry handheld devices and
+the Playbook. They use two different code bases, so when you develop
+for one, you have to duplicate your efforts for the other! This guide
+focuses on the handheld devices rather than the tablet. (In the future,
+this guide should cover both platforms.)
+
+Continuing on from the previous guide, the Echo plugin essentially
+returns whatever message a user provides to the `window.echo`
+function.
+
+The Echo function:
+
+ window.echo = function(str, callback) {
+ cordova.exec(callback, function(err) {
+ callback('Nothing to echo.');
+ }, "Echo", "echo", [str]);
+ };
+
+## Modifying plugins.xml
+
+Your project's `www/plugins.xml` folder contains all of the necessary
+references to your Cordova project's plugins. Add an
+additional reference so that when `cordova.exec` is called, Cordova
+knows how to map the `Echo` argument of `cordova.exec` to the `Echo`
+class that we want to write natively:
+
+ <plugins>
+ ...
+ <plugin name="Echo" value="org.apache.cordova.echo.Echo"/>
+ ...
+ </plugins>
+
+## Adding Echo.java
+
+If you notice the structure of the value attribute, you'll see a
+defined path that leads to the Echo plugin. In the root folder of the
+Cordova BlackBerry WebWorks repo, look for a folder called framework.
+This folder contains all of the source code that runs natively on the
+BlackBerry. Navigate to `framework/ext/src/org/apache/cordova`. At
+this point, you'll see all of the plugin folders, inside of which is
+the source code. So add the folder echo to
+`framework/ext/src/org/apache/cordova/echo` and create a file called
+`Echo.java` at `framework/ext/src/org/apache/cordova/echo/Echo.java`.
+
+## Writing Echo.java
+
+The basic idea behind writing a plugin is to create a class that
+extends the Plugin class and have a method called `execute` to return
+a `PluginResult` class. Any call to `cordova.exec` passes in the
+action to execute within the class, as well as the arguments. In this
+case, "echo" is the action we want to execute within the class "Echo"
+and [str] are the arguments we are passing in.
+
+ package org.apache.cordova.echo;
+
+ import org.apache.cordova.api.Plugin;
+ import org.apache.cordova.api.PluginResult;
+ import org.apache.cordova.json4j.JSONArray;
+ import org.apache.cordova.json4j.JSONException;
+ import org.apache.cordova.json4j.JSONObject;
+ /**
+ * A simple plugin to demonstrate how to build a plugin for Blackberry
+ * Basically echos back the msg that a user calls to this plugin
+ */
+ public final class Echo extends Plugin {
+
+ public static final String echo = "echo";
+
+ public PluginResult execute(String action, JSONArray args, String callbackId) {
+ PluginResult result = new PluginResult(PluginResult.Status.INVALID_ACTION, "Echo: Invalid action:" + action);
+ if(action.equals(echo)){
+ try {
+ String theMsg = args.getString(0);
+ if(theMsg!= null || theMsg.length()>0){
+ result = new PluginResult(PluginResult.Status.OK, theMsg);
+ }else{
+ result = new PluginResult(PluginResult.Status.ERROR, "Nothing to echo.");
+ }
+ } catch (JSONException e) {
+ result = new PluginResult(PluginResult.Status.JSON_EXCEPTION, e.getMessage());
+ }
+ }
+
+ return result;
+ }
+
+ }
+
+So if we look at the code above, we can see that within the execute
+method, we are first looking for what actions are coming in. The Echo
+plugin has only one action, `echo`, so we will be only checking for
+that. If our plugin had more actions, it's simply a matter of adding
+more conditional tests to check for those actions.
+
+We are then going to grab the message coming in from the arguments
+which is supplied by the args parameter. We can grab the first
+argument by simply doing `String theMsg = args.getString(0);`.
+
+We will do some error checking and if the message looks okay, we will
+instantiate a new PluginResult with an ok status:
+`PluginResult.Status.OK` and return the message: `theMsg`. After this,
+we return the result which to be passed back to JavaScript to be fired
+in the success callback. If something fails, we can return various
+status exceptions like `PluginResult.Status.ERROR`,
+`PluginResult.Status.JSON_EXCEPTION`, or
+`PluginResult.Status.INVALID_ACTION`. When passed back, these types of
+results fire the fail callback in JavaScript.
+
+## Updating the .jar in your project's www folder
+
+The added `Echo.java` needs to be updated in your project. To build
+the `.jar` file, Navigate to the BlackBerry WebWorks repo's root
+directory and run the `ant` command:
+
+ ant update -Dproject.path="~/path_to_my_project"
+
+This builds a new `.jar` file in the `build/ext` directory. Copy the
+`build/ext/cordova.jar` file into your `project/www/ext` directory.
+
+If all goes well, that allows you to use the Echo plugin in
+BlackBerry.
http://git-wip-us.apache.org/repos/asf/cordova-docs/blob/50865138/docs/en/2.9.0rc1/guide/plugin-development/blackberry10/index.md
----------------------------------------------------------------------
diff --git a/docs/en/2.9.0rc1/guide/plugin-development/blackberry10/index.md b/docs/en/2.9.0rc1/guide/plugin-development/blackberry10/index.md
new file mode 100644
index 0000000..2b6bfca
--- /dev/null
+++ b/docs/en/2.9.0rc1/guide/plugin-development/blackberry10/index.md
@@ -0,0 +1,191 @@
+---
+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.
+---
+
+# Developing a Plugin on BlackBerry 10
+
+This is a continuation of the Plugin Development Guide for Cordova. Once you have reviewed that content, now let's look at things we need to have the Echo plugin for the BlackBerry 10 platform. Recall that the Echo plugin basically returns whatever string a user provides to the `window.echo` function:
+
+ window.echo = function(str, callback) {
+ cordova.exec(callback, function(err) {
+ callback('Nothing to echo.');
+ }, "Echo", "echo", [str]);
+ };
+
+A native BlackBerry 10 plugin for Cordova contains JavaScript code and may also contain native code. The Echo plugin example demonstrates how to invoke native functionality from JavaScript. The native and JavaScript code communicate with each other through a framework provided by JNEXT. Every plugin must also include a plugin.xml file.
+
+
+## Creating the native part of your plugin ##
+
+To create the native portion of your plugin, open the BlackBerry 10 NDK IDE and select File > New > BlackBerry Project > Native Extension > BlackBerry WebWorks. Enter your desired project name / location and click finish.
+
+The project created by the IDE contains sample code for a memory plugin. You may replace or modify these files to include your own functionality.
+
+- ***name*_js.hpp** - C++ header for the JNEXT code.
+- ***name*_js.cpp** - C++ code for JNEXT.
+
+The native interface for the JNEXT extension can be viewed in the plugin header file located in the public folder of your project. It also contains constants and utility functions that can be used in your native code. Your plugin must be derived from JSExt which is defined in plugin.h. That is, you must implement the following class:
+
+ class JSExt
+ {
+ public:
+ virtual ~JSExt() {};
+ virtual string InvokeMethod( const string& strCommand ) = 0;
+ virtual bool CanDelete( void ) = 0;
+ private:
+ std::string m_id;
+ };
+
+Therefore, your extension should include the plugin.h header file. In the Echo example, you use JSExt as follows in the echo_js.hpp file:
+
+ #include "../public/plugin.h"
+ #include <string>
+
+ #ifndef ECHO_JS_H_
+ #define ECHO_JS_H_
+
+ class Echo : public JSExt
+ {
+ public:
+ explicit Echo(const std::string& id);
+ virtual ~Echo();
+ virtual std::string InvokeMethod(const std::string& command);
+ virtual bool CanDelete();
+ private:
+ std::string m_id;
+ };
+
+ #endif // ECHO_JS_H_
+
+The `m_id` is an attribute that contains the JNEXT id for this object. The id is passed to the class as an argument to the constructor. It is needed to trigger events on the JavaScript side from native.
+The CanDelete method is used by JNEXT to determine whether your native object can be deleted.
+The InvokeMethod function is called as a result from a request from JavaScript to invoke a method of this particular object. The only argument to this function is a string passed from JavaScript that this method should parse in order to determine which method of the native object should be executed.
+Now we implement these functions in echo_js.cpp. For the Echo example, we implement InvokeMethod function as follows:
+
+ string Echo::InvokeMethod(const string& command) {
+
+ //parse command and args from string
+ int index = command.find_first_of(" ");
+ string strCommand = command.substr(0, index);
+ string strValue = command.substr(index + 1, command.length());
+
+ // Determine which function should be executed
+ if (strCommand == "echo") {
+ return strValue;
+ } else {
+ return "Unsupported Method";
+ }
+ }
+
+Your native plugin must also implement the following callback functions:
+
+- `extern char* onGetObjList( void );`
+- `extern JSExt* onCreateObject( const string& strClassName, const string& strObjId );`
+
+The `onGetObjList` function returns a comma separated list of classes supported by JNEXT. JNEXT uses this function to determine the set of classes that JNEXT can instantiate. In our Echo plugin, we have the following in `echo_js.cpp`:
+
+ char* onGetObjList() {
+ static char name[] = "Echo";
+ return name;
+ }
+
+The `onCreateObject ` function takes two parameters. The first parameter is the name of the class requested to be created from the JavaScript side. Valid names are those that are returned in `onGetObjList`. The second parameter is the unique object id for the class. This method returns a pointer to the created plugin object. In our Echo plugin, we have the following in `echo_js.cpp`:
+
+ JSExt* onCreateObject(const string& className, const string& id) {
+ if (className == "Echo") {
+ return new Echo(id);
+ }
+ return NULL;
+ }
+
+##Creating the JavaScript part of your plugin##
+
+The JavaScript portion of your plugin must contain the following files:
+
+- **client.js** – This is considered the client side and contains the API that a Cordova application can call. The API in client.js calls makes calls to index.js. The API in client.js also connects callback functions to the events that fire the callbacks.
+
+- **index.js** – Cordova loads index.js and makes it accessible through the cordova.exec bridge. The client.js file makes calls to the API in the index.js file, which in turn makes call to JNEXT to communicate with the native side.
+
+The client and server side (client.js and index.js) interacts through the `Cordova.exec `function. So, in client.js you invoke the exec function and provide the necessary arguments. In the Echo plugin, we have the following in the client.js file:
+
+ var service = "org.apache.cordova.blackberry.echo",
+ exec = cordova.require("cordova/exec");
+
+ module.exports = {
+ echo: function (data, success, fail) {
+ exec(success, fail, service, "echo", { data: data });
+ }
+ };
+
+Now, index.js interacts with the native side using JNEXT. So you attach a constructor function named Echo to JNEXT. Within the constructor you perform the following key operations using the init function:
+
+- Specify the required module exported by the native side. The name of the required module must match the name of a shared library file (.so file).
+
+`JNEXT.require("libecho")`
+
+- Create an object by using an acquired module and save the ID that's returned by the call.
+self.m_id = JNEXT.createObject("libecho.Echo");
+When your application calls the echo function in client.js, that call in turn calls the echo function in index.js, where the PluginResult object sends a response (data) back to client.js. Since the args argument passed into the functions was converted by JSON.stringfy() and encoded as a URIcomponent, you must call the following:
+
+`data = JSON.parse(decodeURIComponent(args.data));`
+
+You can now send the data back. Let’s put it all together:
+
+ module.exports = {
+
+ echo: function (success, fail, args, env) {
+
+ var result = new PluginResult(args, env),
+ data = JSON.parse(decodeURIComponent(args.data)),
+ response = echo.getInstance().echo(data);
+ result.ok(response, false);
+ }
+ };
+
+## Architecture of the plugin ##
+
+You can place the artifacts of the plugin, which includes the plugin.xml file, the source files (JavaScript, C++), and the binary files (.so) within any directory structure, as long as you correctly specify the file locations in the plugin.xml file. Below we show a typical structure that you can follow:
+
+***your_project_folder*** (>plugin.xml)
+
+- **www** (>client.js)
+- **src**
+ - **blackberry10** (>index.js, **native** >*.cpp, *.hpp)
+ - **device** (>*biary file* *.so)
+ - **simulator** (>*binary file* *.so)
+
+(The list shows the hierarchical relationship among the top level folders. The parenthesis shows the contents of a given folder. All folder names appear in bold text. File names are preceded by the '>' sign.)
+
+## Contents of the plugin.xml file##
+The plugin.xml file contains the namespace of the extension and other metadata. Define the namespace and specify other metadata for the Echo plugin as follows:
+
+ <plugin xmlns="http://www.phonegap.com/ns/plugins/1.0"
+ id="org.apache.cordova.blackberry.echo"
+ version="1.0.0">
+ <js-module src="www/client.js">
+ <merges target="navigator" />
+ </js-module>
+ <platform name="blackberry10">
+ <source-file src="src/blackberry10/index.js" />
+ <lib-file src="src/blackberry10/native/device/libecho.so" arch="device" />
+ <lib-file src="src/blackberry10/native/simulator/libecho.so" arch="simulator" />
+ <config-file target="www/config.xml" parent="/widget">
+ <feature name="org.apache.cordova.blackberry.echo" value="org.apache.cordova.blackberry.echo" />
+ </config-file>
+ </platform>
+ </plugin>
http://git-wip-us.apache.org/repos/asf/cordova-docs/blob/50865138/docs/en/2.9.0rc1/guide/plugin-development/index.md
----------------------------------------------------------------------
diff --git a/docs/en/2.9.0rc1/guide/plugin-development/index.md b/docs/en/2.9.0rc1/guide/plugin-development/index.md
new file mode 100644
index 0000000..ac94ab6
--- /dev/null
+++ b/docs/en/2.9.0rc1/guide/plugin-development/index.md
@@ -0,0 +1,111 @@
+---
+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.
+---
+
+# Plugin Development Guide
+
+A Cordova plugin bridges a bit of functionality between the WebView
+powering a Cordova application and the native platform the Cordova
+application is running on. Plugins are composed of a single JavaScript
+interface used across all platforms, and native implementations
+following platform-specific Plugin interfaces that the JavaScript
+calls into. All of the core Cordova APIs are implemented using this
+architecture.
+
+This guide steps the process of writing a simple Echo Plugin that
+passes a string from JavaScript and sends it into the native
+environment for the supported platforms. The native code then returns
+the same string back to the callbacks inside the plugin's JavaScript.
+
+This guide provides enough overview on which you can build to write
+more complex plugins.
+
+## JavaScript
+
+The entry point for any plugin is JavaScript. The reason developers use
+Cordova is so they can use and write JavaScript, not Objective-C,
+not Java, not C#. The JavaScript interface for your plugin is the
+front-facing and arguably most important part of your Cordova plugin.
+
+You can structure your plugin's JavaScript however you like. The one
+thing you _must_ use to communicate between the Cordova JavaScript
+ and native environments is the `cordova.exec` function. Here is an example:
+
+ cordova.exec(function(winParam) {}, function(error) {}, "service",
+ "action", ["firstArgument", "secondArgument", 42,
+ false]);
+
+The parameters are detailed below:
+
+1. `function(winParam) {}` - Success function callback. Assuming your
+ `exec` call completes successfully, this function is invoked
+ (optionally with any parameters you pass back to it).
+2. `function(error) {}` - Error function callback. If the operation does
+ not complete successfully, this function is invoked (optionally
+ with an error parameter).
+3. `"service"` - The service name to call into on the native side. This
+ is mapped to a native class, about which more information is
+ available in the native guides listed below.
+4. `"action"` - The action name to call into. This is picked up by the
+ native class receiving the `exec` call, and, depending on the
+ platform, essentially maps to a class's method.
+ The native guides listed below provide details.
+5. `[/* arguments */]` - Arguments to pass into the native environment.
+
+### Echo Plugin JavaScript Example
+
+ window.echo = function(str, callback) {
+ cordova.exec(callback, function(err) {
+ callback('Nothing to echo.');
+ }, "Echo", "echo", [str]);
+ };
+
+Let's dive into this. The plugin attaches itself to `window`,
+specifically to the `echo` function. Plugin users would then use it as
+follows:
+
+ window.echo("echome", function(echoValue) {
+ alert(echoValue == "echome"); // should alert true.
+ });
+
+First, let's take a look at the last three arguments to the `exec`
+function. We will be calling the `Echo` "service", requesting the `echo`
+"action", and passing an array of arguments containing the echo string,
+which is the first parameter into the `window.echo` function.
+
+The success callback passed into `exec` is simply a reference to the
+callback function that `window.echo` takes. We do a bit more for the
+error callback: if the native side fires off the error callback, we
+simply invoke the success callback and pass into it a "default"
+string.
+
+## Native
+
+Once you define JavaScript for your plugin, you need to complement it
+with at least one native implementation. Details to do so for each
+platform are listed below. These guides continue to build on the
+simple Echo Plugin example discussed above.
+
+- Developing a Plugin on Android
+- Developing a Plugin on Bada
+- Developing a Plugin on BlackBerry
+- Developing a Plugin on BlackBerry 10
+- Developing a Plugin on iOS
+- Developing a Plugin on Windows Phone
+
+The webOS and Tizen platforms currently do not support plugins.
http://git-wip-us.apache.org/repos/asf/cordova-docs/blob/50865138/docs/en/2.9.0rc1/guide/plugin-development/ios/index.md
----------------------------------------------------------------------
diff --git a/docs/en/2.9.0rc1/guide/plugin-development/ios/index.md b/docs/en/2.9.0rc1/guide/plugin-development/ios/index.md
new file mode 100644
index 0000000..be6e916
--- /dev/null
+++ b/docs/en/2.9.0rc1/guide/plugin-development/ios/index.md
@@ -0,0 +1,227 @@
+---
+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.
+---
+
+# Developing a Plugin on iOS
+
+A plugin is an Objective-C class that extends the `CDVPlugin` class.
+
+Each plugin class must be registered using the config.xml file, as a <plugin> tag under the <plugins> key.
+
+## Plugin Class Mapping
+
+The JavaScript portion of a plugin always uses the `cordova.exec` method as follows:
+
+ exec(<successFunction>, <failFunction>, <service>, <action>, [<args>]);
+
+This marshals a request from the `UIWebView` to the iOS native side,
+more or less boiling down to calling the `action` method on the
+`service` class, with the arguments passed in the `args` array.
+
+The plugin must be added under the `<plugins>` tag of your Cordova-iOS
+application's project's `config.xml` file.
+
+ <plugin name="service_name" value="PluginClassName" />
+
+The key `service_name` should match what you use in the JavaScript
+`exec` call, and the value matches the name of the plugin's
+Objective-C class. Otherwise the plugin may compile but would not be
+reachable by Cordova.
+
+## Plugin Initialization and Lifetime
+
+There is one instance of a plugin object that is created per-UIWebView, and the lifetime of the instance is tied to the UIWebView. Plugins are not instantiated until they are first referenced by a call from JS, unless the `onload` attribute set within config.xml. E.g.:
+
+ <plugin name="Echo" value="Echo" onload="true" />
+
+There is *no* designated initializer for plugins. Instead, plugins should use the `pluginInitialize` method for their start-up logic.
+
+Plugins with long-running requests, background activity (e.g. playing media), listeners or internal state should implement the `onReset` method and stop or clean up those activities. This method is run when the `UIWebView` navigates to a new page or refreshes, which reloads the JavaScript.
+
+## Writing an iOS Cordova Plugin
+
+We have JavaScript fire off a plugin request to the native side. We have the iOS Objective-C plugin mapped properly via the `config.xml` file. So what does the final iOS Objective-C Plugin class look like?
+
+What gets dispatched to the plugin via JavaScript's `exec` function gets passed into the corresponding Plugin class's `action` method. A plugin method has this signature:
+
+ - (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];
+ }
+
+1. [CDVInvokedUrlCommand.h](https://github.com/apache/cordova-ios/blob/master/CordovaLib/Classes/CDVInvokedUrlCommand.h)
+2. [CDVPluginResult.h](https://github.com/apache/cordova-ios/blob/master/CordovaLib/Classes/CDVPluginResult.h)
+3. [CDVCommandDelegate.h](https://github.com/apache/cordova-ios/blob/master/CordovaLib/Classes/CDVCommandDelegate.h)
+
+## iOS CDVPluginResult message types
+
+Using CDVPluginResult you can return a variety of result types back to your JavaScript callbacks, using class methods that look like:
+
+ + (CDVPluginResult*)resultWithStatus:(CDVCommandStatus)statusOrdinal messageAs...
+
+You can create `String`, `Int`, `Double`, `Bool`, `Array`,
+`Dictionary`, `ArrayBuffer`, and `Multipart` types. Or, don't attach
+any arguments (just send a status). Or, return an Error. You can
+even choose to not send any plugin result at all, in which case the
+callback does not fire.
+
+### Notes
+
+ * `messageAsArrayBuffer` expects `NSData*` and converts to an `ArrayBuffer` for your JavaScript callback (and `ArrayBuffers` sent to a plugin from JavaScript are converted to `NSData*`).
+ * `messageAsMultipart` expects an `NSArray*` containing any of the other supported types, and sends the whole array as the `arguments` to your JavaScript callback.
+ * Quirk: this is not just syntactic sugar (though it is sweet). This way, all of the arguments are serialized/deserialized as necessary. e.g. it is safe to return `NSData*` as multipart, but not as `Array`/`Dictionary`.
+
+## Plugin Signatures
+
+The **new signature** supported beginning in **Cordova 2.1.0** is:
+
+ - (void)myMethod:(CDVInvokedUrlCommand*)command;
+
+The **old (deprecated)** signature is:
+
+ - (void)myMethod:(NSMutableArray*)arguments withDict:(NSMutableDictionary*)options;
+
+Basically, the options dictionary has been removed for the new signature, and the callbackId is not the 0th index item for the arguments array, but it is now in a separate property.
+
+## Echo Plugin iOS Plugin
+
+We would add the following to the `<plugins>` tag of the project's `config.xml` file:
+
+ <plugin name="Echo" value="Echo" />
+
+Then we would add the following files (`Echo.h` and `Echo.m`) to the Plugins folder inside our Cordova-iOS
+application folder:
+
+ /********* Echo.h Cordova Plugin Header *******/
+
+ #import <Cordova/CDV.h>
+
+ @interface Echo : CDVPlugin
+
+ - (void)echo:(CDVInvokedUrlCommand*)command;
+
+ @end
+
+ /********* Echo.m Cordova Plugin Implementation *******/
+
+ #import "Echo.h"
+ #import <Cordova/CDV.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
+
+Let's take a look at the code. At the top we have all of the necessary
+Cordova imports. Our class extends from `CDVPlugin` - very important.
+
+This plugin only supports one action, the `echo` action. First, we
+grab the echo string using the `objectAtIndex` method on our `args`,
+telling it we want to get the 0th parameter in the arguments array. We
+do a bit of parameter checking: make sure it is not `nil`, and make
+sure it is not a zero-length string.
+
+If it is, we return a `PluginResult` with an `ERROR` status. If all of
+those checks pass, then we return a `PluginResult` with an `OK`
+status, and pass in the `echo` string we received in the first place
+as a parameter.
+
+Finally, we send 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.
+
+## Threading
+
+Plugin methods are executed in the same thread as the UI. If your
+plugin requires a great deal of processing or requires a blocking
+call, you should use a background thread. For example:
+
+ - (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];
+ }];
+ }
+
+## Advanced Plugin Functionality
+
+See other methods that you can override in:
+
+1. [CDVPlugin.h](https://github.com/apache/cordova-ios/blob/master/CordovaLib/Classes/CDVPlugin.h)
+2. [CDVPlugin.m](https://github.com/apache/cordova-ios/blob/master/CordovaLib/Classes/CDVPlugin.m)
+
+For example, you can hook into the `pause`, `resume`, app terminate and `handleOpenURL` events.
+
+## Debugging Plugins
+
+To debug the Objective-C side, you would use Xcode's built-in debugger.
+For JavaScript, on iOS 5.0 you can use
+[Weinre, an Apache Cordova Project](https://github.com/apache/cordova-weinre) or
+[iWebInspector, a third-party utility](http://www.iwebinspector.com/)
+
+For iOS 6, you would use Safari 6.0 to simply attach to your app
+running in the iOS 6 Simulator.
+
+## Common Pitfalls
+
+* Don't forget to add your plugin's mapping to config.xml. If you forget, an error is logged in the Xcode console.
+* Don't forget to add any hosts you connect to in the [whitelist](guide_whitelist_index.md.html#Domain%20Whitelist%20Guide). If you forget, an error is logged in the Xcode console.
+
+## Deprecated Plugin Signature Note
+
+The **old (deprecated)** signature is:
+
+ - (void) myMethod:(NSMutableArray*)arguments withDict:(NSMutableDictionary*)options;
+
+The Objective-C plugin method's `options` parameter is deprecated, and
+should not be used. For legacy reasons, the last JavaScript object
+passed in the `args` array is passed in as the `options` dictionary of
+the Objective-C method. You must make sure that any JavaScript object
+that is passed in as an element in the `args` appears as the last item
+in the array. Otherwise it throws off the array index for all
+subsequent parameters of the Objective-C array. Only one JavaScript
+object is supported for the options dictionary, and only the last one
+encountered will be passed to the native method. Errors stemming from
+this problem are the reason `options` has been deprecated.
http://git-wip-us.apache.org/repos/asf/cordova-docs/blob/50865138/docs/en/2.9.0rc1/guide/plugin-development/tizen/index.md
----------------------------------------------------------------------
diff --git a/docs/en/2.9.0rc1/guide/plugin-development/tizen/index.md b/docs/en/2.9.0rc1/guide/plugin-development/tizen/index.md
new file mode 100644
index 0000000..5736f29
--- /dev/null
+++ b/docs/en/2.9.0rc1/guide/plugin-development/tizen/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.
+---
+
+Developing a Plugin on Tizen
+============================
+
+Plugins are currently not supported by the Tizen platform.
http://git-wip-us.apache.org/repos/asf/cordova-docs/blob/50865138/docs/en/2.9.0rc1/guide/plugin-development/webos/index.md
----------------------------------------------------------------------
diff --git a/docs/en/2.9.0rc1/guide/plugin-development/webos/index.md b/docs/en/2.9.0rc1/guide/plugin-development/webos/index.md
new file mode 100644
index 0000000..a66ef9f
--- /dev/null
+++ b/docs/en/2.9.0rc1/guide/plugin-development/webos/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.
+---
+
+Developing a Plugin on webOS
+============================
+
+Plugins are currently not supported by the webOS platform.
http://git-wip-us.apache.org/repos/asf/cordova-docs/blob/50865138/docs/en/2.9.0rc1/guide/plugin-development/windows-phone/index.md
----------------------------------------------------------------------
diff --git a/docs/en/2.9.0rc1/guide/plugin-development/windows-phone/index.md b/docs/en/2.9.0rc1/guide/plugin-development/windows-phone/index.md
new file mode 100644
index 0000000..8b16fe3
--- /dev/null
+++ b/docs/en/2.9.0rc1/guide/plugin-development/windows-phone/index.md
@@ -0,0 +1,194 @@
+---
+license: Licensed to the Apache Software Foundation (ASF) under one
+ or more contributor license agreements. See the NOTICE file
+ distributed with this work for additional information
+ regarding copyright ownership. The ASF licenses this file
+ to you under the Apache License, Version 2.0 (the
+ "License"); you may not use this file except in compliance
+ with the License. You may obtain a copy of the License at
+
+ http://www.apache.org/licenses/LICENSE-2.0
+
+ Unless required by applicable law or agreed to in writing,
+ software distributed under the License is distributed on an
+ "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ KIND, either express or implied. See the License for the
+ specific language governing permissions and limitations
+ under the License.
+---
+
+Developing a Plugin on Windows Phone
+====================================
+
+Writing a plugin for Cordova on Windows Phone requires a basic understanding of
+the architecture of Cordova. Cordova-WP7 consists of a WebBrowser which hosts the
+application JavaScript code and manages native API calls. There is a BaseCommand
+(`WP7CordovaClassLib.Cordova.Commands.BaseCommand`) class in C# which you can extend,
+and it comes with the majority of the 'plumbing' built for you already.
+
+1. Select your project, and right-click to choose __Add → New Item...__
+ - Preferably add it to the 'Plugins' folder, but it is up to you
+2. Select 'Class' and name it `Echo.cs`
+ - The name of this class must _exactly_ match what you call into `cordova.exec(win, fail, "Echo", ...)`
+3. Include the base classes implementation
+
+ using WPCordovaClassLib.Cordova;
+ using WPCordovaClassLib.Cordova.Commands;
+ using WPCordovaClassLib.Cordova.JSON;
+
+4. Extend your class from BaseCommand
+
+ public class Echo : BaseCommand
+ {
+ // ...
+ }
+
+5. Add a method that is callable from JS
+
+ public class Echo : BaseCommand
+ {
+ public void echo(string options)
+ {
+ // all JS callable plugin methods MUST have this signature!
+ // public, returning void, 1 argument that is a string
+ }
+ }
+
+Namespaces
+----------
+
+The default namespace for unqualified commands is:
+
+ namespace Cordova.Extension.Commands
+ {
+ // ...
+ }
+
+If you want to use your own namespace, you need to make a fully
+qualified call to `cordova.exec`. For example, if you want to define
+your C# class like this:
+
+ namespace com.mydomain.cordovaExtensions
+ {
+ public class Echo : BaseCommand
+ {
+ // ...
+ }
+ }
+
+Then, in JS you need to call `exec` like this:
+
+ cordova.exec(win, fail, "com.mydomain.cordovaExtensions.Echo", ...);
+
+Interpreting your arguments in C#
+----------------------------------
+
+The data received by your plugin method is a string value, but in actuality
+looking at our JavaScript code, we see our intention was to pass an array of strings.
+Looking back at our JS call to `cordova.exec`, we see we passed `[str]`:
+
+ cordova.exec(win, fail, "Echo", "echo", ["input string"]);
+
+If we inspect the options string passed in to our `Echo.echo` method,
+we see that the value is actually:
+
+ "[\"input string\"]"
+
+All JavaScript exec arguments are JSON encoded before being passed into C#.
+
+If we want to treat this as the string we were expecting, we need to decode it.
+We can use simple JSON deserialization.
+
+ string optVal = JsonHelper.Deserialize<string[]>(options)[0];
+ // optVal now has the value of "input string"
+
+Passing results from C# to JS
+-----------------------------
+
+The base class BaseCommand provides methods for passing data to your JS callback handlers.
+To simply signal that the command has succeeded, when no additional result info is needed,
+you can can simply call:
+
+ DispatchCommandResult(); // calls back with an empty plugin result, considered a success callback
+
+To pass data back, you need to call a different version of `DispatchCommandResult`:
+
+ DispatchCommandResult(new PluginResult(PluginResult.Status.OK, "Everything went as planned, this is a result that is passed to the success handler."));
+
+To pass structured object data back to JS, it should be encoded as a JSON string:
+
+ DispatchCommandResult(new PluginResult(PluginResult.Status.OK, "{result:\"super awesome!\"}"));
+
+If you need to signal that an error has occurred, you can call `DispatchCommandResult` with a `PluginResult` object:
+
+ DispatchCommandResult(new PluginResult(PluginResult.Status.ERROR, "Echo signaled an error"));
+
+Handling serialization errors in your plugin's C# method
+--------------------------------------------------------
+
+When interpreting your arguments, it is a good idea to use a try/catch block
+in case we have bad input. This is a pattern used throughout the Cordova C# code:
+
+ string optVal = null;
+
+ try
+ {
+ optVal = JsonHelper.Deserialize<string[]>(options)[0];
+ }
+ catch(Exception)
+ {
+ // simply catch the exception, we handle null values and exceptions together
+ }
+
+ if (optVal == null)
+ {
+ DispatchCommandResult(new PluginResult(PluginResult.Status.JSON_EXCEPTION));
+ }
+ else
+ {
+ // ... continue on to do our work
+ }
+
+Advanced Plugin Functionality
+-----------------------------
+
+See other methods that you can override in:
+
+1. [BaseCommand.cs](https://github.com/apache/cordova-wp7/blob/master/templates/standalone/cordovalib/Commands/BaseCommand.cs)
+
+For example, you can hook into the 'pause' and 'resume' application events.
+
+### Debugging Plugins
+
+To debug the C# side, you can use Visual Studio's debugger, just set a break point
+at any of the methods exposed by your class.
+
+JavaScript is a little more difficult to debug on Windows Phone. You
+need to use `console.log` to output the state of your plugin, or
+inform yourself of errors.
+
+Common Pitfalls
+---------------
+
+- Be careful when deciding on the arguments you pass to native in your JavaScript
+ implementation. Most device platforms expect the args passed to cordova.exec
+ to be an array, but if you have different types of objects in this array, it
+ becomes difficult or impossible to deserialize.
+
+ cordova.exec(win, fail, "ServiceName", "MethodName", ["this is a string", 54, {literal:'trouble'}]);
+
+ - This means that your C# code receives a difficult to decode string value, such as:
+
+ "[\"this is a string\", 54, { literal:'trouble' }]"
+
+ - Consider converting ALL parameters to strings before calling exec:
+
+ cordova.exec(win, fail, "ServiceName", "MethodName", ["this is a string", "54", "{literal:'trouble'}"]) ;
+
+ string[] optValues = JsonHelper.Deserialize<string[]>(options);
+
+- It is usually a good idea to do parameter checking in your
+ JavaScript code, before you call `exec`. This allows you to re-use
+ more JavaScript code among your plug-in's various native
+ implementations.
+
http://git-wip-us.apache.org/repos/asf/cordova-docs/blob/50865138/docs/en/2.9.0rc1/guide/privacy/index.md
----------------------------------------------------------------------
diff --git a/docs/en/2.9.0rc1/guide/privacy/index.md b/docs/en/2.9.0rc1/guide/privacy/index.md
new file mode 100644
index 0000000..1731700
--- /dev/null
+++ b/docs/en/2.9.0rc1/guide/privacy/index.md
@@ -0,0 +1,63 @@
+---
+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.
+---
+
+Privacy Guide
+=============
+
+Mobile privacy is a critical issue that every app developer must address. Your users expect that their private information will be collected and treated appropriately by your app. Also, there are an increasing number of jurisdictions that now have legal requirements regarding mobile privacy practices.
+
+This guide on mobile app privacy should be considered a "primer" addressing some the most significant issues. It outlines some broadly accepted best practices and provides references to other more detailed guides and references.
+
+* Privacy Policy.
+
+ You app should include a privacy policy that addresses topics such as what kind of information your 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 standar
ds 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 fo
r 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 your 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:
+
+* California Attorney General, [Privacy on the Go: Recommendations for the Mobile Ecosystem][1]
+
+* Center for Democracy & Technology, Future of Privacy Forum, [Best Practices for Mobile App Developers][2]
+
+* CTIA-The Wireless Association, [Best Practices and Guidelines for Location Based Services][3]
+
+* Federal Trade Commission, [Mobile Privacy Disclosures: Building Trust Through Transparency][4]
+
+* Future of Privacy Forum, [Application Privacy][5] Website
+
+[1]: http://oag.ca.gov/sites/all/files/pdfs/privacy/privacy_on_the_go.pdf
+[2]: http://www.futureofprivacy.org/wp-content/uploads/Best-Practices-for-Mobile-App-Developers_Final.pdf
+[3]: http://www.ctia.org/business_resources/wic/index.cfm/AID/11300
+[4]: http://www.ftc.gov/os/2013/02/130201mobileprivacyreport.pdf
+[5]: http://www.applicationprivacy.org
http://git-wip-us.apache.org/repos/asf/cordova-docs/blob/50865138/docs/en/2.9.0rc1/guide/project-settings/android/index.md
----------------------------------------------------------------------
diff --git a/docs/en/2.9.0rc1/guide/project-settings/android/index.md b/docs/en/2.9.0rc1/guide/project-settings/android/index.md
new file mode 100644
index 0000000..e4b627a
--- /dev/null
+++ b/docs/en/2.9.0rc1/guide/project-settings/android/index.md
@@ -0,0 +1,43 @@
+<!--
+#
+# 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.
+#
+-->
+
+Project Settings for Android
+===================================
+
+The `config.xml` settings file controls various settings of Cordova. This is application wide, and not set per CordovaWebView Instance.
+
+## <preference>
+
+Various **other** preferences (as **<preference>** tags) default on not breaking existing apps. The available preferences are:
+
+1. **useBrowserHistory (boolean, defaults to true)** - set to false if you want to use the history shim that was used to work around the hashtag error present in Android 3.x prior to the history fix. (Note: This setting will be deprecated in April 2013)
+2. **loadingDialog** - Display a native loading dialog when loading the app. The value's format is _Title, Message_
+3. **loadingPageDialog** - Display a native loading dialog when loading sub-pages. The value's format is _Title, Message_
+4. **errorUrl** - Set the error page for your application. Should be located in your Android project in file://android_asset/www/
+5. **backgroundColor** - Set the background color for your application. Supports a four-byte hex value, with the first byte representing alpha value, and the following three bytes with standard RGB values. (i.e. 0x00000000 = Black)
+6. **loadUrlTimeoutValue** - How much time Cordova should wait before throwing a timeout error on the application.
+7. **keepRunning (boolean, defaults to true)** - Determines whether Cordova will keep running in the background or not
+8. **splashscreen** - The name of the file minus its extension in the res/drawable directory. If you have multiple assets, they all must share this common name in their respective directories.
+9. **disallowOverscroll (boolean, defaults to false)** - set to true if you want to disable the glow when a user scrolls beyond the edge of the webview.
+
+## <plugin>
+
+Android supports using <feature> as analogues to <plugin> elements.
http://git-wip-us.apache.org/repos/asf/cordova-docs/blob/50865138/docs/en/2.9.0rc1/guide/project-settings/bada/index.md
----------------------------------------------------------------------
diff --git a/docs/en/2.9.0rc1/guide/project-settings/bada/index.md b/docs/en/2.9.0rc1/guide/project-settings/bada/index.md
new file mode 100644
index 0000000..ab7be31
--- /dev/null
+++ b/docs/en/2.9.0rc1/guide/project-settings/bada/index.md
@@ -0,0 +1,24 @@
+<!--
+#
+# 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.
+#
+-->
+
+Project Settings for Bada
+===================================
+
http://git-wip-us.apache.org/repos/asf/cordova-docs/blob/50865138/docs/en/2.9.0rc1/guide/project-settings/blackberry/index.md
----------------------------------------------------------------------
diff --git a/docs/en/2.9.0rc1/guide/project-settings/blackberry/index.md b/docs/en/2.9.0rc1/guide/project-settings/blackberry/index.md
new file mode 100644
index 0000000..69b870b
--- /dev/null
+++ b/docs/en/2.9.0rc1/guide/project-settings/blackberry/index.md
@@ -0,0 +1,29 @@
+<!--
+#
+# 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.
+#
+-->
+
+Project Settings for BlackBerry
+===================================
+
+BlackBerry fully supports the
+[W3C Widget Specification](http://www.w3.org/TR/widgets/)
+as well as proprietary RIM extensions. Please see the full
+[BlackBerry WebWorks documentation regarding config.xml](https://developer.blackberry.com/html5/documentation/working_with_config_xml_file_1866970_11.html)
+for details.
http://git-wip-us.apache.org/repos/asf/cordova-docs/blob/50865138/docs/en/2.9.0rc1/guide/project-settings/firefoxos/index.md
----------------------------------------------------------------------
diff --git a/docs/en/2.9.0rc1/guide/project-settings/firefoxos/index.md b/docs/en/2.9.0rc1/guide/project-settings/firefoxos/index.md
new file mode 100644
index 0000000..aed24a3
--- /dev/null
+++ b/docs/en/2.9.0rc1/guide/project-settings/firefoxos/index.md
@@ -0,0 +1,24 @@
+<!--
+#
+# 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.
+#
+-->
+
+Project Settings for FirefoxOS
+===================================
+
http://git-wip-us.apache.org/repos/asf/cordova-docs/blob/50865138/docs/en/2.9.0rc1/guide/project-settings/index.md
----------------------------------------------------------------------
diff --git a/docs/en/2.9.0rc1/guide/project-settings/index.md b/docs/en/2.9.0rc1/guide/project-settings/index.md
new file mode 100644
index 0000000..ab90101
--- /dev/null
+++ b/docs/en/2.9.0rc1/guide/project-settings/index.md
@@ -0,0 +1,80 @@
+---
+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.
+---
+
+Project Settings
+================
+
+You can set various application configuration parameters using a platform-agnostic configuration file, `config.xml`.
+This file is based on the W3C [Packaged Web Apps (Widgets)](http://www.w3.org/TR/widgets/) specification.
+
+The location of the `config.xml` file is different depending on the platform. The contents, in general, are not.
+
+## Platform-Specific Properties
+
+As with any abstraction layer, Apache Cordova cannot be a perfect silver bullet. As such, some native and platform-specific
+properties, characteristics and behaviours are encapsulated as much as possible as `<preference>` elements inside the
+`config.xml` file. The following sub-sections linked to are guides which go into more details about these preferences.
+
+- Project Settings for iOS
+- Project Settings for Android
+- Project Settings for BlackBerry
+- Project Settings for Windows Phone 7
+- Project Settings for Windows Phone 8
+- Project Settings for Windows 8
+- Project Settings for webOS
+- Project Settings for Bada
+- Project Settings for FirefoxOS
+
+## config.xml Elements
+
+The [Apache Cordova](http://cordova.io) project strives abstract away native platform specifics via web-inspired and web-based
+abstractions that are heavily standards driven and adopted by the web community. Please take a few minutes to familiarize
+yourself with the [config.xml specification](http://www.w3.org/TR/widgets/), to understand the type of application metadata the
+Apache Cordova project aims to abstract and provide simple entry points for.
+
+An example:
+
+ <widget>
+ <preference name="MySetting" value="true" />
+ <plugins>
+ <plugin name="MyPlugin" value="MyPluginClass" />
+ </plugins>
+ <access origin="*" />
+ </widget>
+
+A list of supported elements across major platforms which are supported in Apache Cordova follow.
+
+### `<plugin>`
+
+These elements map to native APIs that the application accesses. At
+runtime, the Apache Cordova framework checks the `<plugin>` elements
+and maps them to native code to enable your Cordova application to
+access device APIs otherwise unavailable to typical web-based
+applications.
+
+### `<access>`
+
+These elements define how your whitelist works. Please see the
+Domain Whitelist Guide for more information.
+
+### `<content>`
+
+This element defines your application's start page relative to the
+project's standard web assets root folder. The default is
+`index.html`.
http://git-wip-us.apache.org/repos/asf/cordova-docs/blob/50865138/docs/en/2.9.0rc1/guide/project-settings/ios/index.md
----------------------------------------------------------------------
diff --git a/docs/en/2.9.0rc1/guide/project-settings/ios/index.md b/docs/en/2.9.0rc1/guide/project-settings/ios/index.md
new file mode 100644
index 0000000..60e1129
--- /dev/null
+++ b/docs/en/2.9.0rc1/guide/project-settings/ios/index.md
@@ -0,0 +1,60 @@
+<!--
+#
+# 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.
+#
+-->
+
+Project Settings for iOS
+========================
+
+The `config.xml` settings file controls various settings of Cordova. This is application wide, and not set per CDVViewController instance.
+The `config.xml` file is located in your `<project folder>/<appname>` directory.
+
+## <preference>
+
+Various preferences (as **<preference>** tags) default on not breaking existing apps. The available preferences are:
+
+1. **DisallowOverscroll (boolean, defaults to false)** - set to true if you don't want the WebView to rubber-band
+
+2. **TopActivityIndicator (string, defaults to 'gray')** - this is the top spinning throbber in the status/battery bar, valid values are `whiteLarge`, `white`, and `gray`
+
+3. **EnableLocation (boolean, defaults to false)** - set to true, to initialize the Geolocation plugin at start-up (so the fix on your location can be more accurate) **DEPRECATED**: please set the **onload** attribute of the **Geolocation** plugin to **true** instead.
+
+4. **EnableViewportScale (boolean, defaults to false)** - set to true to prevent viewport scaling through a meta tag
+
+5. **AutoHideSplashScreen (boolean, defaults to true)** - set to false to control when the splashscreen is hidden through a JavaScript API
+
+6. **FadeSplashScreen (boolean, defaults to true)** - set to false to prevent the splash-screen to fade in and out when showing/hiding it.
+
+7. **FadeSplashScreenDuration (float, defaults to 2)** - The splash-screen Fade duration in seconds.
+
+8. **ShowSplashScreenSpinner (boolean, defaults to true)** - set to false to hide the splash-screen spinner
+
+9. **MediaPlaybackRequiresUserAction (boolean, defaults to false)** - set to true to not allow autoplayed HTML5 video
+
+10. **AllowInlineMediaPlayback (boolean, defaults to false)** - set to true to allow inline HTML5 media playback, also, the video element in the HTML document must also include the webkit-playsinline attribute
+
+11. **BackupWebStorage (string, defaults to 'cloud')** - valid values are 'none', 'cloud' and 'local'. Set to 'cloud' to allow the web storage data to be backed up to iCloud, and set to 'local' to only allow local backups (iTunes sync). Set to 'none' to not allow any backups of web storage.
+
+12. **KeyboardDisplayRequiresUserAction (boolean, defaults to true)** - set to false to open the keyboard when form elements get focus via the JavaScript focus() call.
+
+13. **SuppressesIncrementalRendering (boolean, defaults to false)** - set to true to wait until all new view content has been received before it is rendered.
+
+14. **HideKeyboardFormAccessoryBar (boolean, defaults to false)** - set to true to hide the additional toolbar that is on top of the keyboard (this is the toolbar that has the Prev, Next and Done buttons)
+
+15. **KeyboardShrinksView (boolean, defaults to false)** - set to true to shrink the WebView when the keyboard comes up. The WebView shrinks instead of the viewport shrinking and the page scrollable. This applies to apps that position their elements relative to the bottom of the WebView. This is the default behaviour on Android, and makes a lot of sense when building apps as opposed to webpages.
http://git-wip-us.apache.org/repos/asf/cordova-docs/blob/50865138/docs/en/2.9.0rc1/guide/project-settings/webos/index.md
----------------------------------------------------------------------
diff --git a/docs/en/2.9.0rc1/guide/project-settings/webos/index.md b/docs/en/2.9.0rc1/guide/project-settings/webos/index.md
new file mode 100644
index 0000000..ad1ab0d
--- /dev/null
+++ b/docs/en/2.9.0rc1/guide/project-settings/webos/index.md
@@ -0,0 +1,25 @@
+<!--
+#
+# 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.
+#
+-->
+
+Project Settings for webOS
+===================================
+
+WebOS does not currently have any additional configurable features.
http://git-wip-us.apache.org/repos/asf/cordova-docs/blob/50865138/docs/en/2.9.0rc1/guide/project-settings/windows8/index.md
----------------------------------------------------------------------
diff --git a/docs/en/2.9.0rc1/guide/project-settings/windows8/index.md b/docs/en/2.9.0rc1/guide/project-settings/windows8/index.md
new file mode 100644
index 0000000..7a4f706
--- /dev/null
+++ b/docs/en/2.9.0rc1/guide/project-settings/windows8/index.md
@@ -0,0 +1,26 @@
+<!--
+#
+# 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.
+#
+-->
+
+Project Settings for Windows 8
+===================================
+
+Windows 8 does not currently support this feature.
+
http://git-wip-us.apache.org/repos/asf/cordova-docs/blob/50865138/docs/en/2.9.0rc1/guide/project-settings/wp7/index.md
----------------------------------------------------------------------
diff --git a/docs/en/2.9.0rc1/guide/project-settings/wp7/index.md b/docs/en/2.9.0rc1/guide/project-settings/wp7/index.md
new file mode 100644
index 0000000..8c4da6c
--- /dev/null
+++ b/docs/en/2.9.0rc1/guide/project-settings/wp7/index.md
@@ -0,0 +1,25 @@
+<!--
+#
+# 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.
+#
+-->
+
+Project Settings for Windows Phone 7
+===================================
+
+Windows Phone 7 does not currently have any additional configurable features.
http://git-wip-us.apache.org/repos/asf/cordova-docs/blob/50865138/docs/en/2.9.0rc1/guide/project-settings/wp8/index.md
----------------------------------------------------------------------
diff --git a/docs/en/2.9.0rc1/guide/project-settings/wp8/index.md b/docs/en/2.9.0rc1/guide/project-settings/wp8/index.md
new file mode 100644
index 0000000..5a59d78
--- /dev/null
+++ b/docs/en/2.9.0rc1/guide/project-settings/wp8/index.md
@@ -0,0 +1,25 @@
+<!--
+#
+# 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.
+#
+-->
+
+Project Settings for Windows Phone 8
+===================================
+
+Windows Phone 8 does not currently have any additional configurable features.