incubator-callback-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From a...@apache.org
Subject [1/3] bada commit: more renaming
Date Wed, 28 Mar 2012 18:50:49 GMT
Updated Branches:
  refs/heads/master a7ea36dee -> d3ab54272


more renaming


Project: http://git-wip-us.apache.org/repos/asf/incubator-cordova-bada/repo
Commit: http://git-wip-us.apache.org/repos/asf/incubator-cordova-bada/commit/d3ab5427
Tree: http://git-wip-us.apache.org/repos/asf/incubator-cordova-bada/tree/d3ab5427
Diff: http://git-wip-us.apache.org/repos/asf/incubator-cordova-bada/diff/d3ab5427

Branch: refs/heads/master
Commit: d3ab5427236abd53027517e15610037ec4b4de83
Parents: a7ea36d
Author: Anis Kadri <anis.kadri@gmail.com>
Authored: Wed Mar 28 11:50:37 2012 -0700
Committer: Anis Kadri <anis.kadri@gmail.com>
Committed: Wed Mar 28 11:50:37 2012 -0700

----------------------------------------------------------------------
 LICENSE                       |  202 +++++++++++
 README.md                     |    2 +-
 Res/cordova/accelerometer.js  |  117 +++++++
 Res/cordova/camera.js         |   90 +++++
 Res/cordova/compass.js        |   56 +++
 Res/cordova/contact.js        |  342 ++++++++++++++++++
 Res/cordova/cordova.base.js   |  549 +++++++++++++++++++++++++++++
 Res/cordova/cordova.bat       |    1 +
 Res/cordova/debugconsole.js   |  105 ++++++
 Res/cordova/device.js         |   25 ++
 Res/cordova/file.js           |  670 ++++++++++++++++++++++++++++++++++++
 Res/cordova/geolocation.js    |  140 ++++++++
 Res/cordova/network.js        |   58 +++
 Res/cordova/notification.js   |  105 ++++++
 Res/cordova/position.js       |   62 ++++
 Res/phonegap/accelerometer.js |  117 -------
 Res/phonegap/camera.js        |   90 -----
 Res/phonegap/compass.js       |   56 ---
 Res/phonegap/contact.js       |  342 ------------------
 Res/phonegap/debugconsole.js  |  105 ------
 Res/phonegap/device.js        |   25 --
 Res/phonegap/file.js          |  670 ------------------------------------
 Res/phonegap/geolocation.js   |  140 --------
 Res/phonegap/network.js       |   58 ---
 Res/phonegap/notification.js  |  105 ------
 Res/phonegap/phonegap.base.js |  549 -----------------------------
 Res/phonegap/phonegap.bat     |    1 -
 Res/phonegap/position.js      |   62 ----
 src/Accelerometer.cpp         |    6 +-
 src/Compass.cpp               |    6 +-
 src/Contacts.cpp              |    6 +-
 src/DebugConsole.cpp          |    2 +-
 src/Device.cpp                |    2 +-
 src/GeoLocation.cpp           |    6 +-
 src/Kamera.cpp                |    2 +-
 src/Network.cpp               |    2 +-
 src/Notification.cpp          |    6 +-
 src/WebForm.cpp               |   16 +-
 38 files changed, 2550 insertions(+), 2348 deletions(-)
----------------------------------------------------------------------


http://git-wip-us.apache.org/repos/asf/incubator-cordova-bada/blob/d3ab5427/LICENSE
----------------------------------------------------------------------
diff --git a/LICENSE b/LICENSE
new file mode 100644
index 0000000..7a4a3ea
--- /dev/null
+++ b/LICENSE
@@ -0,0 +1,202 @@
+
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed 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.
\ No newline at end of file

http://git-wip-us.apache.org/repos/asf/incubator-cordova-bada/blob/d3ab5427/README.md
----------------------------------------------------------------------
diff --git a/README.md b/README.md
index e66bc6f..92f5573 100644
--- a/README.md
+++ b/README.md
@@ -12,7 +12,7 @@ Steps to build a Cordova app
 1. Download Source Code (clone the repository)
 2. Import in bada C++ IDE
 3. Put your HTML/CSS files in the Res/ folder
-4. Run phonegap.bat under Res/phonegap directory
+4. Run cordova.bat under Res/cordova directory
 5. Build&Run!
 
 Runnning in the simulator

http://git-wip-us.apache.org/repos/asf/incubator-cordova-bada/blob/d3ab5427/Res/cordova/accelerometer.js
----------------------------------------------------------------------
diff --git a/Res/cordova/accelerometer.js b/Res/cordova/accelerometer.js
new file mode 100644
index 0000000..9941beb
--- /dev/null
+++ b/Res/cordova/accelerometer.js
@@ -0,0 +1,117 @@
+/*
+ * Cordova is available under *either* the terms of the modified BSD license *or* the
+ * MIT License (2008). See http://opensource.org/licenses/alphabetical for full text.
+ * 
+ * Copyright (c) 2005-2010, Nitobi Software Inc.
+ * Copyright (c) 2010, IBM Corporation
+ */
+function Acceleration(x, y, z, timestamp) {
+  this.x = x;
+  this.y = y;
+  this.z = z;
+  this.timestamp = timestamp || new Date().getTime();
+};
+
+/**
+ * Class provides access to device accelerometer data.
+ * @constructor
+ */
+function Accelerometer() {
+
+    /**
+     * The last known acceleration.  type=Acceleration()
+     */
+    this.lastAcceleration = null;
+    this.id = null;
+};
+
+/**
+ * Asynchronously acquires the current acceleration.
+ *
+ * @param {Function} successCallback    The function to call when the acceleration data is available
+ * @param {Function} errorCallback      The function to call when there is an error getting the acceleration data. (OPTIONAL)
+ * @param {AccelerationOptions} options The options for getting the accelerometer data such as timeout. (OPTIONAL)
+ */
+Accelerometer.prototype.getCurrentAcceleration = function(successCallback, errorCallback, options) {
+
+    // successCallback required
+    if (typeof successCallback != "function") {
+        console.log("Accelerometer Error: successCallback is not a function");
+        return;
+    }
+
+    // errorCallback optional
+    if (errorCallback && (typeof errorCallback != "function")) {
+        console.log("Accelerometer Error: errorCallback is not a function");
+        return;
+    }
+
+    // Get acceleration
+    Cordova.exec(successCallback, errorCallback, "com.cordova.Accelerometer", "getCurrentAcceleration", []);
+};
+
+/**
+ * Asynchronously acquires the device acceleration at a given interval.
+ *
+ * @param {Function} successCallback    The function to call each time the acceleration data is available
+ * @param {Function} errorCallback      The function to call when there is an error getting the acceleration data. (OPTIONAL)
+ * @param {AccelerationOptions} options The options for getting the accelerometer data such as timeout. (OPTIONAL)
+ * @return String                       The watch id that must be passed to #clearWatch to stop watching.
+ */
+Accelerometer.prototype.watchAcceleration = function(successCallback, errorCallback, options) {
+
+    // Default interval (10 sec)
+    var frequency = (options != undefined) ? options.frequency : 10000;
+
+    // successCallback required
+    if (typeof successCallback != "function") {
+        console.log("Accelerometer Error: successCallback is not a function");
+        return;
+    }
+
+    // errorCallback optional
+    if (errorCallback && (typeof errorCallback != "function")) {
+        console.log("Accelerometer Error: errorCallback is not a function");
+        return;
+    }
+    // Start watch timer
+    this.id = Cordova.createUUID();
+    Cordova.exec(successCallback, errorCallback, "com.cordova.Accelerometer", "watchAcceleration", []);
+    return this.id;
+};
+
+/**
+ * Clears the specified accelerometer watch.
+ *
+ * @param {String} id The id of the watch returned from #watchAcceleration.
+ */
+Accelerometer.prototype.clearWatch = function(id) {
+
+    // Stop javascript timer & remove from timer list
+    if (id == this.id) {
+        Cordova.exec(null, null, "com.cordova.Accelerometer", "clearWatch", []);
+    }
+};
+
+/*
+ * Native callback when watchAcceleration has a new acceleration.
+ */
+Accelerometer.prototype.success = function(id, result) {
+	try {
+        var accel = new Acceleration(result.x, result.y, result.z, result.timestamp);
+        navigator.accelerometer.lastAcceleration = accel;
+        navigator.accelerometer.listeners[id].success(accel);
+    }
+    catch (e) {
+        debugPrint("Geolocation Error: "+e.message);
+        console.log("Geolocation Error: Error calling success callback function.");
+    }
+
+    if (id == "global") {
+        delete navigator.accelerometer.listeners["global"];
+    }
+};
+
+Cordova.addConstructor(function() {
+    if (typeof navigator.accelerometer == "undefined") navigator.accelerometer = new Accelerometer();
+});

http://git-wip-us.apache.org/repos/asf/incubator-cordova-bada/blob/d3ab5427/Res/cordova/camera.js
----------------------------------------------------------------------
diff --git a/Res/cordova/camera.js b/Res/cordova/camera.js
new file mode 100644
index 0000000..3258f22
--- /dev/null
+++ b/Res/cordova/camera.js
@@ -0,0 +1,90 @@
+
+/*
+ * Cordova is available under *either* the terms of the modified BSD license *or* the
+ * MIT License (2008). See http://opensource.org/licenses/alphabetical for full text.
+ * 
+ * Copyright (c) 2005-2010, Nitobi Software Inc.
+ * Copyright (c) 2010, IBM Corporation
+ */
+
+/**
+ * This class provides access to the device camera.
+ *
+ * @constructor
+ */
+Camera = function() {
+    this.options = null;
+};
+
+/**
+ * Format of image that returned from getPicture.
+ *
+ * Example: navigator.camera.getPicture(success, fail,
+ *              { quality: 80,
+ *                destinationType: Camera.DestinationType.DATA_URL,
+ *                sourceType: Camera.PictureSourceType.PHOTOLIBRARY})
+ */
+Camera.DestinationType = {
+    DATA_URL: 0,                // Return base64 encoded string
+    FILE_URI: 1                 // Return file URI
+};
+Camera.prototype.DestinationType = Camera.DestinationType;
+
+/**
+ * Source to getPicture from.
+ *
+ * Example: navigator.camera.getPicture(success, fail,
+ *              { quality: 80,
+ *                destinationType: Camera.DestinationType.DATA_URL,
+ *                sourceType: Camera.PictureSourceType.PHOTOLIBRARY})
+ */
+Camera.PictureSourceType = {    // Ignored on Blackberry
+    PHOTOLIBRARY : 0,           // Choose image from picture library 
+    CAMERA : 1,                 // Take picture from camera
+    SAVEDPHOTOALBUM : 2         // Choose image from picture library 
+};
+Camera.prototype.PictureSourceType = Camera.PictureSourceType;
+
+/**
+ * Gets a picture from source defined by "options.sourceType", and returns the
+ * image as defined by the "options.destinationType" option.
+
+ * The defaults are sourceType=CAMERA and destinationType=DATA_URL.
+ *
+ * @param {Function} successCallback
+ * @param {Function} errorCallback
+ * @param {Object} options
+ */
+Camera.prototype.getPicture = function(successCallback, errorCallback, options) {
+
+    // successCallback required
+    if (typeof successCallback != "function") {
+        console.log("Camera Error: successCallback is not a function");
+        return;
+    }
+
+    // errorCallback optional
+    if (errorCallback && (typeof errorCallback != "function")) {
+        console.log("Camera Error: errorCallback is not a function");
+        return;
+    }
+
+    this.options = options;
+    var quality = 80;
+    if (options.quality) {
+        quality = this.options.quality;
+    }
+    var destinationType = Camera.DestinationType.DATA_URL;
+    if (this.options.destinationType) {
+        destinationType = this.options.destinationType;
+    }
+    var sourceType = Camera.PictureSourceType.CAMERA;
+    if (typeof this.options.sourceType == "number") {
+        sourceType = this.options.sourceType;
+    }
+    Cordova.exec(successCallback, errorCallback, "com.cordova.Camera", "getPicture", [quality, destinationType, sourceType]);
+};
+
+Cordova.addConstructor(function() {
+	if (typeof navigator.camera == "undefined") navigator.camera = new Camera();
+});

http://git-wip-us.apache.org/repos/asf/incubator-cordova-bada/blob/d3ab5427/Res/cordova/compass.js
----------------------------------------------------------------------
diff --git a/Res/cordova/compass.js b/Res/cordova/compass.js
new file mode 100644
index 0000000..b300e39
--- /dev/null
+++ b/Res/cordova/compass.js
@@ -0,0 +1,56 @@
+/**
+ * This class provides access to device Compass data.
+ * @constructor
+ */
+function Compass() {
+    /**
+     * The last known Compass position.
+     */
+  this.uuid = null;
+};
+
+/**
+ * Asynchronously aquires the current heading.
+ * @param {Function} successCallback The function to call when the heading
+ * data is available
+ * @param {Function} errorCallback The function to call when there is an error 
+ * getting the heading data.
+ * @param {PositionOptions} options The options for getting the heading data
+ * such as timeout.
+ */
+Compass.prototype.getCurrentHeading = function(successCallback, errorCallback, options) {
+  Cordova.exec(successCallback, errorCallback, "com.cordova.Compass", "getCurrentHeading", options);
+};
+
+/**
+ * Asynchronously aquires the heading repeatedly at a given interval.
+ * @param {Function} successCallback The function to call each time the heading
+ * data is available
+ * @param {Function} errorCallback The function to call when there is an error 
+ * getting the heading data.
+ * @param {HeadingOptions} options The options for getting the heading data
+ * such as timeout and the frequency of the watch.
+ */
+Compass.prototype.watchHeading= function(successCallback, errorCallback, options) {
+  this.uuid = Cordova.createUUID();
+  Cordova.exec(successCallback, errorCallback, "com.cordova.Compass", "watchHeading", [this.uuid, options.frequency || 3000]);
+  return this.uuid;
+};
+
+
+/**
+ * Clears the specified heading watch.
+ * @param {String} watchId The ID of the watch returned from #watchHeading.
+ */
+Compass.prototype.clearWatch = function(watchId) {
+    if(this.uuid == watchId) {
+      Cordova.exec(null, null, "com.cordova.Compass", "clearWatch", [this.uuid]);
+      this.uuid = null;
+    } else {
+      debugPrint('no clear watch');
+    }
+};
+
+Cordova.addConstructor(function() {
+    if (typeof navigator.compass == "undefined") navigator.compass = new Compass();
+});

http://git-wip-us.apache.org/repos/asf/incubator-cordova-bada/blob/d3ab5427/Res/cordova/contact.js
----------------------------------------------------------------------
diff --git a/Res/cordova/contact.js b/Res/cordova/contact.js
new file mode 100644
index 0000000..9f43907
--- /dev/null
+++ b/Res/cordova/contact.js
@@ -0,0 +1,342 @@
+/*
+ * Cordova is available under *either* the terms of the modified BSD license *or* the
+ * MIT License (2008). See http://opensource.org/licenses/alphabetical for full text.
+ *
+ * Copyright (c) 2005-2010, Nitobi Software Inc.
+ * Copyright (c) 2010, IBM Corporation
+ */
+
+/**
+* Contains information about a single contact.
+* @param {DOMString} id unique identifier
+* @param {DOMString} displayName
+* @param {ContactName} name
+* @param {DOMString} nickname
+* @param {ContactField[]} phoneNumbers array of phone numbers
+* @param {ContactField[]} emails array of email addresses
+* @param {ContactAddress[]} addresses array of addresses
+* @param {ContactField[]} ims instant messaging user ids
+* @param {ContactOrganization[]} organizations
+* @param {DOMString} revision date contact was last updated
+* @param {DOMString} birthday contact's birthday
+* @param {DOMString} gender contact's gender
+* @param {DOMString} note user notes about contact
+* @param {ContactField[]} photos
+* @param {ContactField[]} urls contact's web sites
+* @param {DOMString} timezone UTC time zone offset
+*/
+
+var Contact = function(id, displayName, name, nickname, phoneNumbers, emails, addresses,
+    ims, organizations, revision, birthday, gender, note, photos, categories, urls, timezone) {
+    this.id = id || null;
+    this.displayName = displayName || null;
+    this.name = name || null; // ContactName
+    this.nickname = nickname || null;
+    this.phoneNumbers = phoneNumbers || null; // ContactField[]
+    this.emails = emails || null; // ContactField[]
+    this.addresses = addresses || null; // ContactAddress[]
+    this.ims = ims || null; // ContactField[]
+    this.organizations = organizations || null; // ContactOrganization[]
+    this.revision = revision || null; // JS Date
+    this.birthday = birthday || null; // JS Date
+    this.gender = gender || null;
+    this.note = note || null;
+    this.photos = photos || null; // ContactField[]
+    this.categories = categories || null; 
+    this.urls = urls || null; // ContactField[]
+    this.timezone = timezone || null;
+};
+
+/**
+* Removes contact from device storage.
+* @param successCB success callback
+* @param errorCB error callback (optional)
+*/
+Contact.prototype.remove = function(successCB, errorCB) {
+	if (this.id == null) {
+    var errorObj = new ContactError();
+    errorObj.code = ContactError.NOT_FOUND_ERROR;
+    errorCB(errorObj);
+  }
+  else {
+      Cordova.exec(successCB, errorCB, "com.cordova.Contacts", "remove", [this.id]);
+  }
+};
+/**
+* Bada ONLY
+* displays contact via Bada Contact UI
+*
+* @param errorCB error callback
+*/
+Contact.prototype.display = function(successCB, errorCB, options) { 
+	if (this.id == null) {
+    var errorObj = new ContactError();
+    errorObj.code = ContactError.NOT_FOUND_ERROR;
+    errorCB(errorObj);
+  }
+  else {
+      Cordova.exec(successCB, errorCB, "com.cordova.Contacts","displayContact", [this.id, options]);
+  }
+};
+
+/**
+* Creates a deep copy of this Contact.
+* With the contact ID set to null.
+* @return copy of this Contact
+*/
+Contact.prototype.clone = function() {
+    var clonedContact = Cordova.clone(this);
+    clonedContact.id = null;
+    // Loop through and clear out any id's in phones, emails, etc.
+    if (clonedContact.phoneNumbers) {
+    	for (i=0; i<clonedContact.phoneNumbers.length; i++) {
+    		clonedContact.phoneNumbers[i].id = null;
+    	}
+    }
+    if (clonedContact.emails) {
+    	for (i=0; i<clonedContact.emails.length; i++) {
+    		clonedContact.emails[i].id = null;
+    	}
+    }
+    if (clonedContact.addresses) {
+    	for (i=0; i<clonedContact.addresses.length; i++) {
+    		clonedContact.addresses[i].id = null;
+    	}
+    }
+    if (clonedContact.ims) {
+    	for (i=0; i<clonedContact.ims.length; i++) {
+    		clonedContact.ims[i].id = null;
+    	}
+    }
+    if (clonedContact.organizations) {
+    	for (i=0; i<clonedContact.organizations.length; i++) {
+    		clonedContact.organizations[i].id = null;
+    	}
+    }
+    if (clonedContact.photos) {
+    	for (i=0; i<clonedContact.photos.length; i++) {
+    		clonedContact.photos[i].id = null;
+    	}
+    }
+    if (clonedContact.urls) {
+    	for (i=0; i<clonedContact.urls.length; i++) {
+    		clonedContact.urls[i].id = null;
+    	}
+    }
+    return clonedContact;
+};
+
+/**
+* Persists contact to device storage.
+* @param successCB success callback
+* @param errorCB error callback - optional
+*/
+Contact.prototype.save = function(successCB, errorCB) {
+  // Read by Bada to create contact
+  var id = navigator.service.contacts.records.push(this) - 1;
+	Cordova.exec(successCB, errorCB, "com.cordova.Contacts", "save", [id]);
+};
+
+/**
+* Contact name.
+* @param formatted
+* @param familyName
+* @param givenName
+* @param middle
+* @param prefix
+* @param suffix
+*/
+var ContactName = function(formatted, familyName, givenName, middle, prefix, suffix) {
+    this.formatted = formatted != "undefined" ? formatted : null;
+    this.familyName = familyName != "undefined" ? familyName : null;
+    this.givenName = givenName != "undefined" ? givenName : null;
+    this.middleName = middle != "undefined" ? middle : null;
+    this.honorificPrefix = prefix != "undefined" ? prefix : null;
+    this.honorificSuffix = suffix != "undefined" ? suffix : null;
+};
+
+/**
+* Generic contact field.
+* @param type
+* @param value
+* @param primary
+* @param id
+*/
+var ContactField = function(type, value, pref, id) {
+    this.type = type != "undefined" ? type : null;
+    this.value = value != "undefined" ? value : null;
+    this.pref = pref != "undefined" ? pref : null;
+    this.id = id != "undefined" ? id : null;
+};
+
+/**
+* Contact address.
+* @param formatted
+* @param streetAddress
+* @param locality
+* @param region
+* @param postalCode
+* @param country
+*/
+var ContactAddress = function(formatted, streetAddress, locality, region, postalCode, country, id) {
+    this.formatted = formatted != "undefined" ? formatted : null;
+    this.streetAddress = streetAddress != "undefined" ? streetAddress : null;
+    this.locality = locality != "undefined" ? locality : null;
+    this.region = region != "undefined" ? region : null;
+    this.postalCode = postalCode != "undefined" ? postalCode : null;
+    this.country = country != "undefined" ? country : null;
+    this.id = id != "undefined" ? id : null;
+};
+
+/**
+* Contact organization.
+* @param name
+* @param dept
+* @param title
+* @param startDate
+* @param endDate
+* @param location
+* @param desc
+*/
+var ContactOrganization = function(name, dept, title, startDate, endDate, location, desc) {
+    this.name = name != "undefined" ? name : null;
+    this.department = dept != "undefined" ? dept : null;
+    this.title = title != "undefined" ? title : null;
+    this.startDate = startDate != "undefined" ? startDate : null;
+    this.endDate = endDate != "undefined" ? endDate : null;
+    this.location = location != "undefined" ? location : null;
+    this.description = desc != "undefined" ? desc : null;
+};
+
+/**
+* Contact account.
+* @param domain
+* @param username
+* @param userid
+*/
+var ContactAccount = function(domain, username, userid) {
+    this.domain = domain != "undefined" ? domain : null;
+    this.username = username != "undefined" ? username : null;
+    this.userid = userid != "undefined" ? userid : null;
+}
+
+/**
+* Represents a group of Contacts.
+*/
+var Contacts = function() {
+    this.inProgress = false;
+    this.records = new Array(); // used by bada to create contacts
+    this.results = new Array(); // used by bada to update contact results
+    this.resultsCallback = null;
+    this.errorCallback = null;
+};
+/**
+* Returns an array of Contacts matching the search criteria.
+* @param fields that should be searched
+* @param successCB success callback
+* @param errorCB error callback (optional)
+* @param {ContactFindOptions} options that can be applied to contact searching
+* @return array of Contacts matching search criteria
+*/
+Contacts.prototype.find = function(fields, successCB, errorCB, options) {
+  /* fields searched are: displayName, Email, Phone Number, User Id
+   * other fields are ignored
+   */
+	Cordova.exec(successCB, errorCB, "com.cordova.Contacts","find",[options.filter]);
+};
+
+/**
+* need to turn the JSON string representing contact object into actual object
+* @param JSON string with contact data
+* Call stored results function with  Contact object
+*/
+Contacts.prototype._findCallback = function(contact)
+{
+	if(contact) {
+		try {
+      this.results.push(this.create(contact));
+		} catch(e){
+			console.log("Error parsing contact");
+		}
+	}
+};
+/** 
+* Need to return an error object rather than just a single error code
+* @param error code
+* Call optional error callback if found.
+* Called from objective c find, remove, and save methods on error.
+*/
+Contacts.prototype._errCallback = function(pluginResult)
+{
+	var errorObj = new ContactError();
+   	errorObj.code = pluginResult.message;
+	pluginResult.message = errorObj;
+	return pluginResult;
+};
+// Bada only api to create a new contact via the GUI
+Contacts.prototype.newContactUI = function(successCallback) { 
+    Cordova.exec(successCallback, null, "com.cordova.Contacts","newContact", []);
+};
+// Bada only api to select a contact via the GUI
+Contacts.prototype.chooseContact = function(successCallback, options) {
+    Cordova.exec(successCallback, null, "com.cordova.Contacts","chooseContact", options);
+};
+
+
+/**
+* This function creates a new contact, but it does not persist the contact
+* to device storage. To persist the contact to device storage, invoke
+* contact.save().
+* @param properties an object who's properties will be examined to create a new Contact
+* @returns new Contact object
+*/
+Contacts.prototype.create = function(properties) {
+    var contact = new Contact();
+    for (i in properties) {
+        if (contact[i]!='undefined') {
+            contact[i]=properties[i];
+        }
+    }
+    return contact;
+};
+
+/**
+ * ContactFindOptions.
+ * @param filter used to match contacts against
+ * @param multiple boolean used to determine if more than one contact should be returned
+ * @param updatedSince return only contact records that have been updated on or after the given time
+ */
+var ContactFindOptions = function(filter, multiple, updatedSince) {
+    this.filter = filter || '';
+    this.multiple = multiple || true;
+    this.updatedSince = updatedSince || '';
+};
+
+/**
+ *  ContactError.
+ *  An error code assigned by an implementation when an error has occurred
+ */
+var ContactError = function() {
+    this.code=null;
+};
+
+/**
+ * Error codes
+ */
+ContactError.UNKNOWN_ERROR = 0;
+ContactError.INVALID_ARGUMENT_ERROR = 1;
+ContactError.NOT_FOUND_ERROR = 2;
+ContactError.TIMEOUT_ERROR = 3;
+ContactError.PENDING_OPERATION_ERROR = 4;
+ContactError.IO_ERROR = 5;
+ContactError.NOT_SUPPORTED_ERROR = 6;
+ContactError.PERMISSION_DENIED_ERROR = 20;
+
+/**
+ * Add the contact interface into the browser.
+ */
+Cordova.addConstructor(function() { 
+    if(typeof navigator.service == "undefined") navigator.service = new Object();
+    if(typeof navigator.service.contacts == "undefined") navigator.service.contacts = new Contacts();
+});
+

http://git-wip-us.apache.org/repos/asf/incubator-cordova-bada/blob/d3ab5427/Res/cordova/cordova.base.js
----------------------------------------------------------------------
diff --git a/Res/cordova/cordova.base.js b/Res/cordova/cordova.base.js
new file mode 100644
index 0000000..aa08214
--- /dev/null
+++ b/Res/cordova/cordova.base.js
@@ -0,0 +1,549 @@
+
+/*
+ * Cordova is available under *either* the terms of the modified BSD license *or* the
+ * MIT License (2008). See http://opensource.org/licenses/alphabetical for full text.
+ * 
+ * Copyright (c) 2005-2010, Nitobi Software Inc.
+ * Copyright (c) 2010, IBM Corporation
+ */
+
+/**
+ * The order of events during page load and Cordova startup is as follows:
+ *
+ * onDOMContentLoaded         Internal event that is received when the web page is loaded and parsed.
+ * window.onload              Body onload event.
+ * onNativeReady              Internal event that indicates the Cordova native side is ready.
+ * onCordovaInit             Internal event that kicks off creation of all Cordova JavaScript objects (runs constructors).
+ * onCordovaReady            Internal event fired when all Cordova JavaScript objects have been created
+ * onCordovaInfoReady        Internal event fired when device properties are available
+ * onDeviceReady              User event fired to indicate that Cordova is ready
+ * onResume                   User event fired to indicate a start/resume lifecycle event
+ *
+ * The only Cordova events that user code should register for are:
+ *      onDeviceReady
+ *      onResume
+ *
+ * Listeners can be registered as:
+ *      document.addEventListener("deviceready", myDeviceReadyListener, false);
+ *      document.addEventListener("resume", myResumeListener, false);
+ */
+
+function debugPrint(body) {
+    var list = document.getElementById("debuglist");
+    var item = document.createElement("li");
+    item.appendChild(document.createTextNode(body));
+    list.appendChild(item);
+}
+/**
+ * This represents the Cordova API itself, and provides a global namespace for accessing
+ * information about the state of Cordova.
+ * @class
+ */
+Cordova = { 
+   queue: {
+        ready: true,
+        commands: [],
+        timer: null
+    },
+    _constructors: []
+};
+
+/**
+ * Boolean flag indicating if the Cordova API is available and initialized.
+ */ // TODO: Remove this, it is unused here ... -jm
+Cordova.available = function() {
+  return window.device.uuid != undefined;
+}
+
+/**
+ * Custom pub-sub channel that can have functions subscribed to it
+ */
+Cordova.Channel = function(type)
+{
+    this.type = type;
+    this.handlers = {};
+    this.guid = 0;
+    this.fired = false;
+    this.enabled = true;
+};
+
+/**
+ * Subscribes the given function to the channel. Any time that 
+ * Channel.fire is called so too will the function.
+ * Optionally specify an execution context for the function
+ * and a guid that can be used to stop subscribing to the channel.
+ * Returns the guid.
+ */
+Cordova.Channel.prototype.subscribe = function(f, c, g) {
+    // need a function to call
+    if (f == null) { return; }
+
+    var func = f;
+    if (typeof c == "object" && f instanceof Function) { func = Cordova.close(c, f); }
+
+    g = g || func.observer_guid || f.observer_guid || this.guid++;
+    func.observer_guid = g;
+    f.observer_guid = g;
+    this.handlers[g] = func;
+    return g;
+};
+
+/**
+ * Like subscribe but the function is only called once and then it
+ * auto-unsubscribes itself.
+ */
+Cordova.Channel.prototype.subscribeOnce = function(f, c) {
+    var g = null;
+    var _this = this;
+    var m = function() {
+        f.apply(c || null, arguments);
+        _this.unsubscribe(g);
+    }
+    if (this.fired) {
+        if (typeof c == "object" && f instanceof Function) { f = Cordova.close(c, f); }
+        f.apply(this, this.fireArgs);
+    } else {
+        g = this.subscribe(m);
+    }
+    return g;
+};
+
+/** 
+ * Unsubscribes the function with the given guid from the channel.
+ */
+Cordova.Channel.prototype.unsubscribe = function(g) {
+    if (g instanceof Function) { g = g.observer_guid; }
+    this.handlers[g] = null;
+    delete this.handlers[g];
+};
+
+/** 
+ * Calls all functions subscribed to this channel.
+ */
+Cordova.Channel.prototype.fire = function(e) {
+    if (this.enabled) {
+        var fail = false;
+        for (var item in this.handlers) {
+            var handler = this.handlers[item];
+            if (handler instanceof Function) {
+                var rv = (handler.apply(this, arguments)==false);
+                fail = fail || rv;
+            }
+        }
+        this.fired = true;
+        this.fireArgs = arguments;
+        return !fail;
+    }
+    return true;
+};
+
+/**
+ * Calls the provided function only after all of the channels specified
+ * have been fired.
+ */
+Cordova.Channel.join = function(h, c) {
+    var i = c.length;
+    var f = function() {
+        if (!(--i)) h();
+    }
+    for (var j=0; j<i; j++) {
+        (!c[j].fired?c[j].subscribeOnce(f):i--);
+    }
+    if (!i) h();
+};
+
+/**
+ * Add an initialization function to a queue that ensures it will run and initialize
+ * application constructors only once Cordova has been initialized.
+ * @param {Function} func The function callback you want run once Cordova is initialized
+ */
+Cordova.addConstructor = function(func) {
+    Cordova.onCordovaInit.subscribeOnce(function() {
+        // try {
+            func();
+        // } catch(e) {
+        //     if (typeof(debug['log']) == 'function') {
+        //         debug.log("Failed to run constructor: " + debug.processMessage(e));
+        //     } else {
+        //         alert("Failed to run constructor: " + e.message);
+        //     }
+        // }
+    });
+};
+
+/**
+ * Plugins object.
+ */
+if (!window.plugins) {
+    window.plugins = {};
+}
+
+/**
+ * Adds new plugin object to window.plugins.
+ * The plugin is accessed using window.plugins.<name>
+ * 
+ * @param name      The plugin name
+ * @param obj       The plugin object
+ */
+Cordova.addPlugin = function(name, obj) {
+    if (!window.plugins[name]) {
+        window.plugins[name] = obj;
+    }
+    else {
+        console.log("Plugin " + name + " already exists.");
+    }
+};
+
+/**
+ * onDOMContentLoaded channel is fired when the DOM content 
+ * of the page has been parsed.
+ */
+Cordova.onDOMContentLoaded = new Cordova.Channel('onDOMContentLoaded');
+
+/**
+ * onNativeReady channel is fired when the Cordova native code
+ * has been initialized.
+ */
+Cordova.onNativeReady = new Cordova.Channel('onNativeReady');
+
+/**
+ * onCordovaInit channel is fired when the web page is fully loaded and
+ * Cordova native code has been initialized.
+ */
+Cordova.onCordovaInit = new Cordova.Channel('onCordovaInit');
+
+/**
+ * onCordovaReady channel is fired when the JS Cordova objects have been created.
+ */
+Cordova.onCordovaReady = new Cordova.Channel('onCordovaReady');
+
+/**
+ * onCordovaInfoReady channel is fired when the Cordova device properties
+ * has been set.
+ */
+Cordova.onCordovaInfoReady = new Cordova.Channel('onCordovaInfoReady');
+
+/**
+ * onResume channel is fired when the Cordova native code
+ * resumes.
+ */
+Cordova.onResume = new Cordova.Channel('onResume');
+
+/**
+ * onPause channel is fired when the Cordova native code
+ * pauses.
+ */
+Cordova.onPause = new Cordova.Channel('onPause');
+
+// _nativeReady is global variable that the native side can set
+// to signify that the native code is ready. It is a global since 
+// it may be called before any Cordova JS is ready.
+if (typeof _nativeReady !== 'undefined') { Cordova.onNativeReady.fire(); }
+
+/**
+ * onDeviceReady is fired only after all Cordova objects are created and
+ * the device properties are set.
+ */
+Cordova.onDeviceReady = new Cordova.Channel('onDeviceReady');
+
+/**
+ * Create all Cordova objects once page has fully loaded and native side is ready.
+ */
+Cordova.Channel.join(function() {
+
+    // Run Cordova constructors
+    Cordova.onCordovaInit.fire();
+
+    // Fire event to notify that all objects are created
+    Cordova.onCordovaReady.fire();
+
+}, [ Cordova.onDOMContentLoaded, Cordova.onNativeReady ]);
+
+/**
+ * Fire onDeviceReady event once all constructors have run and Cordova info has been
+ * received from native side.
+ */
+Cordova.Channel.join(function() {
+    Cordova.onDeviceReady.fire();
+    
+    // Fire the onresume event, since first one happens before JavaScript is loaded
+    Cordova.onResume.fire();
+}, [ Cordova.onCordovaReady, Cordova.onCordovaInfoReady]);
+
+// Listen for DOMContentLoaded and notify our channel subscribers
+document.addEventListener('DOMContentLoaded', function() {
+    Cordova.onDOMContentLoaded.fire();
+}, false);
+
+// Intercept calls to document.addEventListener and watch for deviceready
+Cordova.m_document_addEventListener = document.addEventListener;
+
+document.addEventListener = function(evt, handler, capture) {
+    var e = evt.toLowerCase();
+    if (e == 'deviceready') {
+        Cordova.onDeviceReady.subscribeOnce(handler);
+    } else if (e == 'resume') {
+        Cordova.onResume.subscribe(handler);
+        // if subscribing listener after event has already fired, invoke the handler
+        if (Cordova.onResume.fired && handler instanceof Function) {
+            handler();
+        }
+    } else if (e == 'pause') {
+        Cordova.onPause.subscribe(handler);
+    } else {
+        Cordova.m_document_addEventListener.call(document, evt, handler, capture);
+    }
+};
+
+Cordova.m_element_addEventListener = Element.prototype.addEventListener;
+
+/**
+ * For BlackBerry, the touchstart event does not work so we need to do click
+ * events when touchstart events are attached.
+ */
+Element.prototype.addEventListener = function(evt, handler, capture) {
+    if (evt === 'touchstart') {
+        evt = 'click';
+    }
+    Cordova.m_element_addEventListener.call(this, evt, handler, capture);
+};
+
+/**
+ * Does a deep clone of the object.
+ *
+ * @param obj
+ * @return
+ */
+Cordova.clone = function(obj) {
+    if(!obj) { 
+        return obj;
+    }
+    
+    if(obj instanceof Array){
+        var retVal = new Array();
+        for(var i = 0; i < obj.length; ++i){
+            retVal.push(Cordova.clone(obj[i]));
+        }
+        return retVal;
+    }
+    
+    if (obj instanceof Function) {
+        return obj;
+    }
+    
+    if(!(obj instanceof Object)){
+        return obj;
+    }
+    
+    if(obj instanceof Date){
+        return obj;
+    }
+
+    retVal = new Object();
+    for(i in obj){
+        if(!(i in retVal) || retVal[i] != obj[i]) {
+            retVal[i] = Cordova.clone(obj[i]);
+        }
+    }
+    return retVal;
+};
+
+Cordova.close = function(context, func, params) {
+    if (typeof params === 'undefined') {
+        return function() {
+            return func.apply(context, arguments);
+        }
+    } else {
+        return function() {
+            return func.apply(context, params);
+        }
+    }
+};
+
+Cordova.callbackId = 0;
+Cordova.callbacks  = {};
+Cordova.callbackStatus = {
+    NO_RESULT: 0,
+    OK: 1,
+    CLASS_NOT_FOUND_EXCEPTION: 2,
+    ILLEGAL_ACCESS_EXCEPTION: 3,
+    INSTANTIATION_EXCEPTION: 4,
+    MALFORMED_URL_EXCEPTION: 5,
+    IO_EXCEPTION: 6,
+    INVALID_ACTION: 7,
+    JSON_EXCEPTION: 8,
+    ERROR: 9
+};
+
+/**
+ * Called by native code when returning successful result from an action.
+ *
+ * @param callbackId
+ * @param args
+ */
+Cordova.callbackSuccess = function(callbackId, args) {
+    if (Cordova.callbacks[callbackId]) {
+
+        // If result is to be sent to callback
+        if (args.status == Cordova.callbackStatus.OK) {
+            try {
+                if (Cordova.callbacks[callbackId].success) {
+                    Cordova.callbacks[callbackId].success(args.message);
+                }
+            }
+            catch (e) {
+                console.log("Error in success callback: "+callbackId+" = "+e);
+            }
+        }
+
+        // Clear callback if not expecting any more results
+        if (!args.keepCallback) {
+            delete Cordova.callbacks[callbackId];
+        }
+    }
+};
+
+/**
+ * Called by native code when returning error result from an action.
+ *
+ * @param callbackId
+ * @param args
+ */
+Cordova.callbackError = function(callbackId, args) {
+    if (Cordova.callbacks[callbackId]) {
+        try {
+            if (Cordova.callbacks[callbackId].fail) {
+                Cordova.callbacks[callbackId].fail(args.message);
+            }
+        }
+        catch (e) {
+            console.log("Error in error callback: "+callbackId+" = "+e);
+        }
+
+        // Clear callback if not expecting any more results
+        if (!args.keepCallback) {
+            delete Cordova.callbacks[callbackId];
+        }
+    }
+};
+
+/**
+ * Create a UUID
+ *
+ * @return
+ */
+Cordova.createUUID = function() {
+    return Cordova.UUIDcreatePart(4) + '-' +
+        Cordova.UUIDcreatePart(2) + '-' +
+        Cordova.UUIDcreatePart(2) + '-' +
+        Cordova.UUIDcreatePart(2) + '-' +
+        Cordova.UUIDcreatePart(6);
+};
+
+Cordova.UUIDcreatePart = function(length) {
+    var uuidpart = "";
+    for (var i=0; i<length; i++) {
+        var uuidchar = parseInt((Math.random() * 256)).toString(16);
+        if (uuidchar.length == 1) {
+            uuidchar = "0" + uuidchar;
+        }
+        uuidpart += uuidchar;
+    }
+    return uuidpart;
+};
+/**
+ * Execute a Cordova command in a queued fashion, to ensure commands do not
+ * execute with any race conditions, and only run when Cordova is ready to
+ * receive them.
+ *
+ */
+Cordova.exec = function() { 
+	
+    Cordova.queue.commands.push(arguments);
+    if (Cordova.queue.timer == null)
+        Cordova.queue.timer = setInterval(Cordova.run_command, 10);
+};
+
+/**
+ * Internal function used to dispatch the request to Cordova.  It processes the
+ * command queue and executes the next command on the list.  Simple parameters are passed
+ * as arguments on the url.  JavaScript objects converted into a JSON string and passed as a
+ * query string argument of the url.
+ * Arguments may be in one of two formats:
+ *   FORMAT ONE (preferable)
+ * The native side will call Cordova.callbackSuccess or Cordova.callbackError,
+ * depending upon the result of the action.
+ *
+ * @param {Function} success    The success callback
+ * @param {Function} fail       The fail callback
+ * @param {String} service      The name of the service to use
+ * @param {String} action		The name of the action to use
+ * @param {String[]} [args]     Zero or more arguments to pass to the method
+ *  	
+ * FORMAT TWO
+ * @param {String} command Command to be run in Cordova, e.g. "ClassName.method"
+ * @param {String[]} [args] Zero or more arguments to pass to the method
+ * object parameters are passed as an array object [object1, object2] each object will be passed as JSON strings 
+ * @private
+ */
+Cordova.run_command = function() {
+    if (!Cordova.available() || !Cordova.queue.ready)
+        return;
+
+    var args = Cordova.queue.commands.shift();
+    if (Cordova.queue.commands.length == 0) {
+        clearInterval(Cordova.queue.timer);
+        Cordova.queue.timer = null;
+    }
+	
+	var service;
+	var callbackId = null;
+	var start=0;
+    try {
+ 		if (args[0] == null || typeof args[0] === "function") {
+ 			var success = args[0];
+ 			var fail = args[1];
+ 			service = args[2] + "." + args[3];
+			args = args[4];  //array of arguments to 
+      if (success || fail) {
+          callbackId = service + Cordova.callbackId++;
+          Cordova.callbacks[callbackId] = {success:success, fail:fail};
+      }
+ 		} else { 
+ 			service = args[0]; 
+ 			start = 1;
+ 		}
+        
+      var uri = [];
+      var query = [];
+    	for (var i = start; i < args.length; i++) {
+        	var arg = args[i];
+        	if (arg == undefined || arg == null)
+            	continue;
+        	if (typeof(arg) == 'object') {
+              for(i in arg) {
+                if(typeof(arg[i]) != 'object') {
+                  query.push(encodeURIComponent(i) + '=' + encodeURIComponent(arg[i]));
+                }
+              }
+          }
+        	else {
+            	uri.push(encodeURIComponent(arg));
+          }
+    	}
+    	var next = callbackId != null  ?  ("/" + callbackId + "/") : "/";
+    	var url = "gap://" + service + next + uri.join("/");
+
+    	if (query.length > 0) {
+        	url += "?" + query.join("&");
+    	}
+      Cordova.queue.ready = false;
+      document.location = url;
+   
+    } catch (e) {
+        console.log("CordovaExec Error: "+e);
+    }
+    
+
+};
+

http://git-wip-us.apache.org/repos/asf/incubator-cordova-bada/blob/d3ab5427/Res/cordova/cordova.bat
----------------------------------------------------------------------
diff --git a/Res/cordova/cordova.bat b/Res/cordova/cordova.bat
new file mode 100755
index 0000000..16e7ef2
--- /dev/null
+++ b/Res/cordova/cordova.bat
@@ -0,0 +1 @@
+copy /B cordova.base.js+geolocation.js+position.js+accelerometer.js+network.js+debugconsole.js+contact.js+device.js+compass.js+notification.js+camera.js cordova.js

http://git-wip-us.apache.org/repos/asf/incubator-cordova-bada/blob/d3ab5427/Res/cordova/debugconsole.js
----------------------------------------------------------------------
diff --git a/Res/cordova/debugconsole.js b/Res/cordova/debugconsole.js
new file mode 100644
index 0000000..8c84de1
--- /dev/null
+++ b/Res/cordova/debugconsole.js
@@ -0,0 +1,105 @@
+/**
+ * This class provides access to the debugging console.
+ * @constructor
+ */
+function DebugConsole(isDeprecated) {
+    this.logLevel = DebugConsole.INFO_LEVEL;
+    this.isDeprecated = isDeprecated ? true : false;
+}
+
+// from most verbose, to least verbose
+DebugConsole.ALL_LEVEL    = 1; // same as first level
+DebugConsole.INFO_LEVEL   = 1;
+DebugConsole.WARN_LEVEL   = 2;
+DebugConsole.ERROR_LEVEL  = 4;
+DebugConsole.NONE_LEVEL   = 8;
+													
+DebugConsole.prototype.setLevel = function(level) {
+    this.logLevel = level;
+}
+
+/**
+ * Utility function for rendering and indenting strings, or serializing
+ * objects to a string capable of being printed to the console.
+ * @param {Object|String} message The string or object to convert to an indented string
+ * @private
+ */
+DebugConsole.prototype.processMessage = function(message, maxDepth) {
+	if (maxDepth === undefined) maxDepth = 0;
+    if (typeof(message) != 'object') {
+        return (this.isDeprecated ? "WARNING: debug object is deprecated, please use console object " + message : message);
+    } else {
+        /**
+         * @function
+         * @ignore
+         */
+        function indent(str) {
+            return str.replace(/^/mg, "    ");
+        }
+        /**
+         * @function
+         * @ignore
+         */
+        function makeStructured(obj, depth) {
+            var str = "";
+            for (var i in obj) {
+                try {
+                    if (typeof(obj[i]) == 'object' && depth < maxDepth) {
+                        str += i + ": " + indent(makeStructured(obj[i])) + "   ";
+                    } else {
+                        str += i + " = " + indent(String(obj[i])).replace(/^    /, "") + "   ";
+                    }
+                } catch(e) {
+                    str += i + " = EXCEPTION: " + e.message + "   ";
+                }
+            }
+            return str;
+        }
+        
+        return ((this.isDeprecated ? "WARNING: debug object is deprecated, please use console object   " :  "") + "Object: " + makeStructured(message, maxDepth));
+    }
+};
+
+/**
+ * Print a normal log message to the console
+ * @param {Object|String} message Message or object to print to the console
+ */
+DebugConsole.prototype.log = function(message, maxDepth) {
+    if (Cordova.available && this.logLevel <= DebugConsole.INFO_LEVEL)
+        Cordova.exec(null, null, 'com.cordova.DebugConsole', 'log',
+            [this.processMessage(message, maxDepth), 'INFO']
+        );
+    else
+        console.log(message);
+};
+
+/**
+ * Print a warning message to the console
+ * @param {Object|String} message Message or object to print to the console
+ */
+DebugConsole.prototype.warn = function(message, maxDepth) {
+    if (Cordova.available && this.logLevel <= DebugConsole.WARN_LEVEL)
+        Cordova.exec(null, null, 'com.cordova.DebugConsole', 'log',
+            [this.processMessage(message, maxDepth), 'WARN']
+        );
+    else
+        console.error(message);
+};
+
+/**
+ * Print an error message to the console
+ * @param {Object|String} message Message or object to print to the console
+ */
+DebugConsole.prototype.error = function(message, maxDepth) {
+    if (Cordova.available && this.logLevel <= DebugConsole.ERROR_LEVEL)
+        Cordova.exec(null, null, 'com.cordova.DebugConsole', 'log',
+            [this.processMessage(message, maxDepth), 'ERROR']
+        );
+    else
+        console.error(message);
+};
+
+Cordova.addConstructor(function() {
+    window.console = new DebugConsole();
+    window.debug = new DebugConsole(true);
+});

http://git-wip-us.apache.org/repos/asf/incubator-cordova-bada/blob/d3ab5427/Res/cordova/device.js
----------------------------------------------------------------------
diff --git a/Res/cordova/device.js b/Res/cordova/device.js
new file mode 100644
index 0000000..9769e62
--- /dev/null
+++ b/Res/cordova/device.js
@@ -0,0 +1,25 @@
+
+/*
+ * Cordova is available under *either* the terms of the modified BSD license *or* the
+ * MIT License (2008). See http://opensource.org/licenses/alphabetical for full text.
+ * 
+ * Copyright (c) 2005-2010, Nitobi Software Inc.
+ * Copyright (c) 2010, IBM Corporation
+ */
+
+/**
+ * This represents the mobile device, and provides properties for inspecting the model, version, UUID of the
+ * phone, etc.
+ * @constructor
+ */
+function Device() {
+  this.platform = null;
+  this.version  = null;
+  this.name     = null;
+  this.uuid     = null;
+};
+
+Cordova.addConstructor(function() {
+  navigator.device = window.device = window.device || new Device();
+  Cordova.onCordovaInfoReady.fire();
+});

http://git-wip-us.apache.org/repos/asf/incubator-cordova-bada/blob/d3ab5427/Res/cordova/file.js
----------------------------------------------------------------------
diff --git a/Res/cordova/file.js b/Res/cordova/file.js
new file mode 100644
index 0000000..7406349
--- /dev/null
+++ b/Res/cordova/file.js
@@ -0,0 +1,670 @@
+
+/*
+ * Cordova is available under *either* the terms of the modified BSD license *or* the
+ * MIT License (2008). See http://opensource.org/licenses/alphabetical for full text.
+ * 
+ * Copyright (c) 2005-2010, Nitobi Software Inc.
+ * Copyright (c) 2010, IBM Corporation
+ */
+
+/**
+ * These classes provides generic read and write access to the mobile device file system.
+ * They are not used to read files from a server.
+ */
+
+/**
+ * Contains properties that describe a file.
+ */
+function FileProperties(filePath) {
+    this.filePath = filePath;
+    this.size = 0;
+    this.lastModifiedDate = null;
+};
+
+/**
+ * FileError
+ */
+function FileError() {
+    this.code = null;
+};
+
+// File error codes
+// Found in DOMException
+FileError.NOT_FOUND_ERR = 1;
+FileError.SECURITY_ERR = 2;
+FileError.ABORT_ERR = 3;
+
+// Added by File API specification
+FileError.NOT_READABLE_ERR = 4;
+FileError.ENCODING_ERR = 5;
+FileError.NO_MODIFICATION_ALLOWED_ERR = 6;
+FileError.INVALID_STATE_ERR = 7;
+FileError.SYNTAX_ERR = 8;
+FileError.INVALID_MODIFICATION_ERR = 9;
+FileError.QUOTA_EXCEEDED_ERR = 10;
+FileError.TYPE_MISMATCH_ERR = 11;
+FileError.PATH_EXISTS_ERR = 12;
+
+//-----------------------------------------------------------------------------
+//File manager
+//-----------------------------------------------------------------------------
+
+/**
+ * This class provides read and write access to mobile device file system in 
+ * support of FileReader and FileWriter APIs based on 
+ * http://www.w3.org/TR/2010/WD-FileAPI-20101026
+ * and
+ * <writer url>
+ */
+function FileMgr() {
+};
+
+/**
+ * Returns the root file system paths.
+ * 
+ * @return {String[]} array of root file system paths
+ */
+FileMgr.prototype.getRootPaths = function() {
+    return blackberry.io.dir.getRootDirs();
+};
+
+/**
+ * Returns the available memory in bytes for the root file system of the specified file path.
+ * 
+ * @param filePath          A file system path
+ */
+FileMgr.prototype.getFreeDiskSpace = function(filePath) {
+    return blackberry.io.dir.getFreeSpaceForRoot(filePath);
+};
+
+/**
+ * Reads a file from the device and encodes the contents using the specified 
+ * encoding. 
+ * 
+ * @param fileName          The full path of the file to read
+ * @param encoding          The encoding to use to encode the file's content
+ * @param successCallback   Callback invoked with file contents
+ * @param errorCallback     Callback invoked on error
+ */
+FileMgr.prototype.readAsText = function(fileName, encoding, successCallback, errorCallback) {
+    Cordova.exec(successCallback, errorCallback, "File", "readAsText", [fileName, encoding]);
+};
+
+/**
+ * Reads a file from the device and encodes the contents using BASE64 encoding.  
+ * 
+ * @param fileName          The full path of the file to read.
+ * @param successCallback   Callback invoked with file contents
+ * @param errorCallback     Callback invoked on error
+ */
+FileMgr.prototype.readAsDataURL = function(fileName, successCallback, errorCallback) {
+    Cordova.exec(successCallback, errorCallback, "File", "readAsDataURL", [fileName]);
+};
+
+/**
+ * Writes data to the specified file.
+ * 
+ * @param fileName          The full path of the file to write
+ * @param data              The data to be written
+ * @param position          The position in the file to begin writing
+ * @param successCallback   Callback invoked after successful write operation
+ * @param errorCallback     Callback invoked on error
+ */
+FileMgr.prototype.write = function(fileName, data, position, successCallback, errorCallback) {
+    Cordova.exec(successCallback, errorCallback, "File", "write", [fileName, data, position]);
+};
+
+/**
+ * Tests whether file exists.  Will return false if the path specifies a directory.
+ * 
+ * @param fullPath             The full path of the file 
+ */
+FileMgr.prototype.testFileExists = function(fullPath) {
+    return blackberry.io.file.exists(fullPath);
+};
+
+/**
+ * Tests whether directory exists.  Will return false if the path specifies a file.
+ * 
+ * @param fullPath             The full path of the directory
+ */
+FileMgr.prototype.testDirectoryExists = function(fullPath) {
+    return blackberry.io.dir.exists(fullPath);
+};
+
+/**
+ * Gets the properties of a file.  Throws an exception if fileName is a directory.
+ * 
+ * @param fileName          The full path of the file 
+ */
+FileMgr.prototype.getFileProperties = function(fileName) {    
+    var fileProperties = new FileProperties(fileName);
+    // attempt to get file properties
+    if (blackberry.io.file.exists(fileName)) {
+        var props = blackberry.io.file.getFileProperties(fileName);
+        fileProperties.size = props.size;
+        fileProperties.lastModifiedDate = props.dateModified;
+    }
+    // fileName is a directory
+    else if (blackberry.io.dir.exists(fileName)) {
+        throw FileError.TYPE_MISMATCH_ERR;
+    }
+    return fileProperties;
+};
+
+/**
+ * Changes the length of the specified file.  Data beyond new length is discarded.  
+ * 
+ * @param fileName          The full path of the file to truncate
+ * @param size              The size to which the length of the file is to be adjusted
+ * @param successCallback   Callback invoked after successful write operation
+ * @param errorCallback     Callback invoked on error
+ */
+FileMgr.prototype.truncate = function(fileName, size, successCallback, errorCallback) {
+    Cordova.exec(successCallback, errorCallback, "File", "truncate", [fileName, size]);
+};
+
+/**
+ * Removes a file from the file system.
+ * 
+ * @param fileName          The full path of the file to be deleted
+ */
+FileMgr.prototype.deleteFile = function(fileName) {
+    // delete file, if it exists
+    if (blackberry.io.file.exists(fileName)) {
+        blackberry.io.file.deleteFile(fileName);
+    }
+    // fileName is a directory
+    else if (blackberry.io.dir.exists(fileName)) {
+        throw FileError.TYPE_MISMATCH_ERR;
+    }
+    // fileName not found 
+    else {
+        throw FileError.NOT_FOUND_ERR;
+    }
+};
+
+/**
+ * Creates a directory on device storage.
+ * 
+ * @param dirName           The full path of the directory to be created
+ */
+FileMgr.prototype.createDirectory = function(dirName) {
+    if (!blackberry.io.dir.exists(dirName)) {
+        // createNewDir API requires trailing slash
+        if (dirName.substr(-1) !== "/") {
+            dirName += "/";
+        }
+        blackberry.io.dir.createNewDir(dirName);
+    }
+    // directory already exists
+    else {
+        throw FileError.PATH_EXISTS_ERR;
+    }
+};
+
+/**
+ * Deletes the specified directory from device storage.
+ * 
+ * @param dirName           The full path of the directory to be deleted
+ */
+FileMgr.prototype.deleteDirectory = function(dirName) {
+    blackberry.io.dir.deleteDirectory(dirName);
+};
+
+Cordova.addConstructor(function() {
+    if (typeof navigator.fileMgr == "undefined") navigator.fileMgr = new FileMgr();
+});
+
+//-----------------------------------------------------------------------------
+//File Reader
+//-----------------------------------------------------------------------------
+
+/**
+ * This class reads the mobile device file system.
+ */
+function FileReader() {
+    this.fileName = "";
+
+    this.readyState = 0;
+
+    // File data
+    this.result = null;
+
+    // Error
+    this.error = null;
+
+    // Event handlers
+    this.onloadstart = null;    // When the read starts.
+    this.onprogress = null;     // While reading (and decoding) file or fileBlob data, and reporting partial file data (progess.loaded/progress.total)
+    this.onload = null;         // When the read has successfully completed.
+    this.onerror = null;        // When the read has failed (see errors).
+    this.onloadend = null;      // When the request has completed (either in success or failure).
+    this.onabort = null;        // When the read has been aborted. For instance, by invoking the abort() method.
+};
+
+//States
+FileReader.EMPTY = 0;
+FileReader.LOADING = 1;
+FileReader.DONE = 2;
+
+/**
+ * Abort read file operation.
+ */
+FileReader.prototype.abort = function() {
+    var event;
+    
+    // reset everything
+    this.readyState = FileReader.DONE;
+    this.result = null;
+    
+    // set error
+    var error = new FileError();
+    error.code = error.ABORT_ERR;
+    this.error = error;
+
+    // abort procedure
+    if (typeof this.onerror == "function") {
+        event = {"type":"error", "target":this};
+        this.onerror(event);
+    }
+    if (typeof this.onabort == "function") {
+        event = {"type":"abort", "target":this};
+        this.onabort(event);
+    }
+    if (typeof this.onloadend == "function") {
+        event = {"type":"loadend", "target":this};
+        this.onloadend(event);
+    }
+};
+
+/**
+ * Reads and encodes text file.
+ *
+ * @param file          The name of the file
+ * @param encoding      [Optional] (see http://www.iana.org/assignments/character-sets)
+ */
+FileReader.prototype.readAsText = function(file, encoding) {
+    var event;
+    
+    // Use UTF-8 as default encoding
+    var enc = encoding ? encoding : "UTF-8";
+    
+    // start
+    this.readyState = FileReader.LOADING;
+    if (typeof this.onloadstart == "function") {
+        event = {"type":"loadstart", "target":this};
+        this.onloadstart(event);
+    }
+
+    // read and encode file
+    this.fileName = file;
+    var me = this;
+    navigator.fileMgr.readAsText(file, enc, 
+
+        // success callback
+        function(result) {
+            // If DONE (canceled), then don't do anything
+            if (me.readyState === FileReader.DONE) {
+                return;
+            }
+
+            // success procedure
+            me.result = result;
+            if (typeof me.onload == "function") {
+                event = {"type":"load", "target":me};
+                me.onload(event);
+            }
+            me.readyState = FileReader.DONE;
+            if (typeof me.onloadend == "function") {
+                event = {"type":"loadend", "target":me};
+                me.onloadend(event);
+            }
+        },
+
+        // error callback
+        function(error) {
+            // If DONE (canceled), then don't do anything
+            if (me.readyState === FileReader.DONE) {
+                return;
+            }
+
+            // capture error
+            var err = new FileError();
+            err.code = error;
+            me.error = err;
+            
+            // error procedure
+            me.result = null;
+            if (typeof me.onerror == "function") {
+                event = {"type":"error", "target":me};
+                me.onerror(event);
+            }
+            me.readyState = FileReader.DONE;
+            if (typeof me.onloadend == "function") {
+                event = {"type":"loadend", "target":me};
+                me.onloadend(event);
+            }
+        }
+    );
+};
+
+/**
+ * Read file and return data as a base64 encoded data url.
+ * A data url is of the form:
+ *      data:[<mediatype>][;base64],<data>
+ *
+ * @param file          The name of the file
+ */
+FileReader.prototype.readAsDataURL = function(file) {
+    var event;
+    
+    // start
+    this.readyState = FileReader.LOADING;
+    if (typeof this.onloadstart == "function") {
+        event = {"type":"loadstart", "target":this};
+        this.onloadstart(event);
+    }
+    
+    // read and encode file
+    this.fileName = file;
+    var me = this;
+    navigator.fileMgr.readAsDataURL(file, 
+
+        // success callback
+        function(result) {
+            // If DONE (canceled), then don't do anything
+            if (me.readyState === FileReader.DONE) {
+                return;
+            }
+
+            // success procedure
+            me.result = result;
+            if (typeof me.onload == "function") {
+                event = {"type":"load", "target":me};
+                me.onload(event);
+            }
+            me.readyState = FileReader.DONE;
+            if (typeof me.onloadend == "function") {
+                event = {"type":"loadend", "target":me};
+                me.onloadend(event);
+            }
+        },
+
+        // error callback
+        function(error) {
+            // If DONE (canceled), then don't do anything
+            if (me.readyState === FileReader.DONE) {
+                return;
+            }
+
+            // capture error
+            var err = new FileError();
+            err.code = error;
+            me.error = err;
+            
+            // error procedure
+            me.result = null;
+            if (typeof me.onerror == "function") {
+                event = {"type":"error", "target":me};
+                me.onerror(event);
+            }
+            me.readyState = FileReader.DONE;
+            if (typeof me.onloadend == "function") {
+                event = {"type":"loadend", "target":me};
+                me.onloadend(event);
+            }
+        }
+    );
+};
+
+//-----------------------------------------------------------------------------
+//File Writer
+//-----------------------------------------------------------------------------
+
+/**
+* This class writes to the mobile device file system.
+*
+* @param filePath       The full path to the file to be written to
+* @param append         If true, then data will be written to the end of the file rather than the beginning 
+*/
+function FileWriter(filePath, append) {
+    this.fileName = filePath;
+    this.length = 0;
+
+    // get the file properties
+    var fp = navigator.fileMgr.getFileProperties(filePath);
+    this.length = fp.size;
+    
+    // default is to write at the beginning of the file
+    this.position = (append !== true) ? 0 : this.length;
+    
+    this.readyState = 0; // EMPTY
+    
+    // Error
+    this.error = null;
+
+    // Event handlers
+    this.onwritestart = null;   // When writing starts
+    this.onprogress = null;     // While writing the file, and reporting partial file data
+    this.onwrite = null;        // When the write has successfully completed.
+    this.onwriteend = null;     // When the request has completed (either in success or failure).
+    this.onabort = null;        // When the write has been aborted. For instance, by invoking the abort() method.
+    this.onerror = null;        // When the write has failed (see errors).
+};
+
+//States
+FileWriter.INIT = 0;
+FileWriter.WRITING = 1;
+FileWriter.DONE = 2;
+
+/**
+ * Abort writing file.
+ */
+FileWriter.prototype.abort = function() {
+    var event;
+    // check for invalid state 
+    if (this.readyState === FileWriter.DONE || this.readyState === FileWriter.INIT) {
+        throw FileError.INVALID_STATE_ERR;
+    }
+    
+    // set error
+    var error = new FileError();
+    error.code = error.ABORT_ERR;
+    this.error = error;
+
+    // dispatch progress events
+    if (typeof this.onerror == "function") {
+        event = {"type":"error", "target":this};
+        this.onerror(event);
+    }
+    if (typeof this.onabort == "function") {
+        event = {"type":"abort", "target":this};
+        this.onabort(event);
+    }
+
+    // set state
+    this.readyState = FileWriter.DONE;
+    
+    // done
+    if (typeof this.writeend == "function") {
+        event = {"type":"writeend", "target":this};
+        this.writeend(event);
+    }
+};
+
+/**
+ * Sets the file position at which the next write will occur.
+ * 
+ * @param offset    Absolute byte offset into the file
+ */
+FileWriter.prototype.seek = function(offset) {
+    // Throw an exception if we are already writing a file
+    if (this.readyState === FileWriter.WRITING) {
+        throw FileError.INVALID_STATE_ERR;
+    }
+
+    if (!offset) {
+        return;
+    }
+    
+    // offset is bigger than file size, set to length of file
+    if (offset > this.length) { 
+        this.position = this.length;
+    }
+    // seek back from end of file
+    else if (offset < 0) { 
+        this.position = Math.max(offset + this.length, 0);
+    } 
+    // offset in the middle of file
+    else {
+        this.position = offset;
+    }
+};
+
+/**
+ * Truncates the file to the specified size.
+ * 
+ * @param size      The size to which the file length is to be adjusted
+ */
+FileWriter.prototype.truncate = function(size) {
+    var event;
+    
+    // Throw an exception if we are already writing a file
+    if (this.readyState === FileWriter.WRITING) {
+        throw FileError.INVALID_STATE_ERR;
+    }
+    
+    // start
+    this.readyState = FileWriter.WRITING;
+    if (typeof this.onwritestart == "function") {
+        event = {"type":"writestart", "target":this};
+        this.onwritestart(event);
+    }
+
+    // truncate file
+    var me = this;
+    navigator.fileMgr.truncate(this.fileName, size, 
+        // Success callback receives the new file size
+        function(result) {
+            // If DONE (canceled), then don't do anything
+            if (me.readyState === FileWriter.DONE) {
+                return;
+            }
+
+            // new file size is returned
+            me.length = result;
+            // position is lesser of old position or new file size
+            me.position = Math.min(me.position, result);
+
+            // success procedure
+            if (typeof me.onwrite == "function") {
+                event = {"type":"write", "target":me};
+                me.onwrite(event);
+            }
+            me.readyState = FileWriter.DONE;
+            if (typeof me.onwriteend == "function") {
+                event = {"type":"writeend", "target":me};
+                me.onwriteend(event);
+            }
+        },
+
+        // Error callback
+        function(error) {
+            // If DONE (canceled), then don't do anything
+            if (me.readyState === FileWriter.DONE) {
+                return;
+            }
+
+            // Save error
+            var err = new FileError();
+            err.code = error;
+            me.error = err;
+
+            // error procedure
+            if (typeof me.onerror == "function") {
+                event = {"type":"error", "target":me};
+                me.onerror(event);
+            }
+            me.readyState = FileWriter.DONE;
+            if (typeof me.onwriteend == "function") {
+                event = {"type":"writeend", "target":me};
+                me.onwriteend(event);
+            }
+        }            
+    );
+};
+
+/**
+ * Writes the contents of a file to the device.
+ * 
+ * @param data      contents to be written
+ */
+FileWriter.prototype.write = function(data) {
+    var event;
+    
+    // Throw an exception if we are already writing a file
+    if (this.readyState === FileWriter.WRITING) {
+        throw FileError.INVALID_STATE_ERR;
+    }
+
+    // WRITING state
+    this.readyState = FileWriter.WRITING;
+    if (typeof this.onwritestart == "function") {
+        event = {"type":"writestart", "target":this};
+        this.onwritestart(event);
+    }
+
+    // Write file
+    var me = this;
+    navigator.fileMgr.write(this.fileName, data, this.position,
+
+        // Success callback receives bytes written
+        function(result) {
+            // If DONE (canceled), then don't do anything
+            if (me.readyState === FileWriter.DONE) {
+                return;
+            }
+
+            // new length is maximum of old length, or position plus bytes written
+            me.length = Math.max(me.length, me.position + result);
+            // position always increases by bytes written because file would be extended
+            me.position += result;
+
+            // success procedure
+            if (typeof me.onwrite == "function") {
+                event = {"type":"write", "target":me};
+                me.onwrite(event);
+            }
+            me.readyState = FileWriter.DONE;
+            if (typeof me.onwriteend == "function") {
+                event = {"type":"writeend", "target":me};
+                me.onwriteend(event);
+            }
+        },
+
+        // Error callback
+        function(error) {
+            // If DONE (canceled), then don't do anything
+            if (me.readyState === FileWriter.DONE) {
+                return;
+            }
+
+            // Save error
+            var err = new FileError();
+            err.code = error;
+            me.error = err;
+
+            // error procedure
+            if (typeof me.onerror == "function") {
+                event = {"type":"error", "target":me};
+                me.onerror(event);
+            }
+            me.readyState = FileWriter.DONE;
+            if (typeof me.onwriteend == "function") {
+                event = {"type":"writeend", "target":me};
+                me.onwriteend(event);
+            }
+        }
+    );
+};

http://git-wip-us.apache.org/repos/asf/incubator-cordova-bada/blob/d3ab5427/Res/cordova/geolocation.js
----------------------------------------------------------------------
diff --git a/Res/cordova/geolocation.js b/Res/cordova/geolocation.js
new file mode 100644
index 0000000..7b57b2e
--- /dev/null
+++ b/Res/cordova/geolocation.js
@@ -0,0 +1,140 @@
+
+/*
+ * Cordova is available under *either* the terms of the modified BSD license *or* the
+ * MIT License (2008). See http://opensource.org/licenses/alphabetical for full text.
+ * 
+ * Copyright (c) 2005-2010, Nitobi Software Inc.
+ * Copyright (c) 2010, IBM Corporation
+ */
+
+/**
+ * This class provides access to device GPS data.
+ * @constructor
+ */
+function Geolocation() {
+
+    // The last known GPS position.
+    this.lastPosition = null;
+    this.id = null;
+};
+
+/**
+ * Position error object
+ *
+ * @param code
+ * @param message
+ */
+function PositionError(code, message) {
+    this.code = code || 0;
+    this.message = message || '';
+};
+
+PositionError.UNKNOWN_ERROR = 0;
+PositionError.PERMISSION_DENIED = 1;
+PositionError.POSITION_UNAVAILABLE = 2;
+PositionError.TIMEOUT = 3;
+
+/**
+ * Asynchronously aquires the current position.
+ *
+ * @param {Function} successCallback    The function to call when the position data is available
+ * @param {Function} errorCallback      The function to call when there is an error getting the heading position. (OPTIONAL)
+ * @param {PositionOptions} options     The options for getting the position data. (OPTIONAL)
+ */
+Geolocation.prototype.getCurrentPosition = function(successCallback, errorCallback, options) {
+    this.id = Cordova.createUUID();
+    // default maximumAge value should be 0, and set if positive 
+    var maximumAge = 0;
+
+    // default timeout value should be infinity, but that's a really long time
+    var timeout = 3600000; 
+
+    var enableHighAccuracy = false;
+    if (options) {
+        if (options.maximumAge && (options.maximumAge > 0)) {
+            maximumAge = options.maximumAge;
+        }
+        if (options.enableHighAccuracy) {
+            enableHighAccuracy = options.enableHighAccuracy;
+        }
+        if (options.timeout) {
+            timeout = (options.timeout < 0) ? 0 : options.timeout;
+        }
+    }
+    Cordova.exec(successCallback, errorCallback, "com.cordova.Geolocation", "getCurrentPosition", [maximumAge, timeout, enableHighAccuracy]);
+}
+
+/**
+ * Asynchronously watches the geolocation for changes to geolocation.  When a change occurs,
+ * the successCallback is called with the new location.
+ *
+ * @param {Function} successCallback    The function to call each time the location data is available
+ * @param {Function} errorCallback      The function to call when there is an error getting the location data. (OPTIONAL)
+ * @param {PositionOptions} options     The options for getting the location data such as frequency. (OPTIONAL)
+ * @return String                       The watch id that must be passed to #clearWatch to stop watching.
+ */
+Geolocation.prototype.watchPosition = function(successCallback, errorCallback, options) {
+
+    // default maximumAge value should be 0, and set if positive 
+    var maximumAge = 0;
+
+    // DO NOT set timeout to a large value for watchPosition in BlackBerry.  
+    // The interval used for updates is half the timeout value, so a large 
+    // timeout value will mean a long wait for the first location.
+    var timeout = 10000; 
+
+    var enableHighAccuracy = false;
+    if (options) {
+        if (options.maximumAge && (options.maximumAge > 0)) {
+            maximumAge = options.maximumAge;
+        }
+        if (options.enableHighAccuracy) {
+            enableHighAccuracy = options.enableHighAccuracy;
+        }
+        if (options.timeout) {
+            timeout = (options.timeout < 0) ? 0 : options.timeout;
+        }
+    }
+    this.id = Cordova.createUUID();
+    Cordova.exec(successCallback, errorCallback, "com.cordova.Geolocation", "watchPosition", [maximumAge, timeout, enableHighAccuracy]);
+    return this.id;
+};
+
+/**
+ * Clears the specified position watch.
+ *
+ * @param {String} id       The ID of the watch returned from #watchPosition
+ */
+Geolocation.prototype.clearWatch = function(id) {
+    Cordova.exec(null, null, "com.cordova.Geolocation", "stop", []);
+    this.id = null;
+};
+
+/**
+ * Force the Cordova geolocation to be used instead of built-in.
+ */
+Geolocation.usingCordova = false;
+Geolocation.useCordova = function() {
+    if (Geolocation.usingCordova) {
+        return;
+    }
+    Geolocation.usingCordova = true;
+
+    // Set built-in geolocation methods to our own implementations
+    // (Cannot replace entire geolocation, but can replace individual methods)
+    navigator.geolocation.getCurrentPosition = navigator._geo.getCurrentPosition;
+    navigator.geolocation.watchPosition = navigator._geo.watchPosition;
+    navigator.geolocation.clearWatch = navigator._geo.clearWatch;
+    navigator.geolocation.success = navigator._geo.success;
+    navigator.geolocation.fail = navigator._geo.fail;
+};
+
+Cordova.addConstructor(function() {
+    navigator._geo = new Geolocation();
+
+    // if no native geolocation object, use Cordova geolocation
+    if (typeof navigator.geolocation == 'undefined') {
+        navigator.geolocation = navigator._geo;
+        Geolocation.usingCordova = true;
+    }
+});

http://git-wip-us.apache.org/repos/asf/incubator-cordova-bada/blob/d3ab5427/Res/cordova/network.js
----------------------------------------------------------------------
diff --git a/Res/cordova/network.js b/Res/cordova/network.js
new file mode 100644
index 0000000..cbe3d68
--- /dev/null
+++ b/Res/cordova/network.js
@@ -0,0 +1,58 @@
+
+/*
+ * Cordova is available under *either* the terms of the modified BSD license *or* the
+ * MIT License (2008). See http://opensource.org/licenses/alphabetical for full text.
+ * 
+ * Copyright (c) 2005-2010, Nitobi Software Inc.
+ * Copyright (c) 2010, IBM Corporation
+ */
+
+/**
+ * Network status.
+ */
+NetworkStatus = {
+  NOT_REACHABLE: 0,
+  REACHABLE_VIA_CARRIER_DATA_NETWORK: 1,
+  REACHABLE_VIA_WIFI_NETWORK: 2
+};
+
+/**
+ * This class provides access to device Network data (reachability).
+ * @constructor
+ */
+function Network() {
+    /**
+     * The last known Network status.
+	 * { hostName: string, ipAddress: string, 
+		remoteHostStatus: int(0/1/2), internetConnectionStatus: int(0/1/2), localWiFiConnectionStatus: int (0/2) }
+     */
+	this.lastReachability = null;
+};
+
+/**
+ * Determine if a URI is reachable over the network.
+
+ * @param {Object} uri
+ * @param {Function} callback
+ * @param {Object} options  (isIpAddress:boolean)
+ */
+Network.prototype.isReachable = function(uri, callback, options) {
+    var isIpAddress = false;
+    if (options && options.isIpAddress) {
+        isIpAddress = options.isIpAddress;
+    }
+    Cordova.exec(callback, null, 'com.cordova.Network', 'isReachable', [uri, isIpAddress]);
+};
+
+/**
+ * Called by the geolocation framework when the reachability status has changed.
+ * @param {Reachibility} reachability The current reachability status.
+ */
+// TODO: Callback from native code not implemented for Android
+Network.prototype.updateReachability = function(reachability) {
+    this.lastReachability = reachability;
+};
+
+Cordova.addConstructor(function() {
+	if (typeof navigator.network == "undefined") navigator.network = new Network();
+});


Mime
View raw message