diff --git a/test/.classpath b/test/.classpath
new file mode 100644
index 00000000..ab564941
--- /dev/null
+++ b/test/.classpath
@@ -0,0 +1,17 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/test/.project b/test/.project
new file mode 100644
index 00000000..24e3c941
--- /dev/null
+++ b/test/.project
@@ -0,0 +1,34 @@
+
+
+ CordovaTest
+
+
+ Phonegapdemo
+
+
+
+ com.android.ide.eclipse.adt.ResourceManagerBuilder
+
+
+
+
+ com.android.ide.eclipse.adt.PreCompilerBuilder
+
+
+
+
+ org.eclipse.jdt.core.javabuilder
+
+
+
+
+ com.android.ide.eclipse.adt.ApkBuilder
+
+
+
+
+
+ com.android.ide.eclipse.adt.AndroidNature
+ org.eclipse.jdt.core.javanature
+
+
diff --git a/test/AndroidManifest.xml b/test/AndroidManifest.xml
new file mode 100644
index 00000000..87da52fc
--- /dev/null
+++ b/test/AndroidManifest.xml
@@ -0,0 +1,98 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/test/assets/www/LICENSE b/test/assets/www/LICENSE
new file mode 100644
index 00000000..5652ae1c
--- /dev/null
+++ b/test/assets/www/LICENSE
@@ -0,0 +1,208 @@
+The MIT License
+
+
+ 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 2009-2011 Rob Ellis, Brock Whitten, Brian LeRoux
+ Copyright 2010-2011, IBM Corporation
+ Copyright 2011 Adobe
+
+ 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.
+
+
diff --git a/test/assets/www/README.md b/test/assets/www/README.md
new file mode 100644
index 00000000..86e876c7
--- /dev/null
+++ b/test/assets/www/README.md
@@ -0,0 +1,18 @@
+## Mobile Spec Suite ##
+
+These specs are designed to run inside the mobile device that implements it - _it will fail in the DESKTOP browser_.
+
+These set of tests is designed to be used with Cordova. You should initialize a fresh Cordova repository for a target platform and then toss these files into the www folder, replacing the
+contents.
+
+Make sure you include Cordova-\*.js in the www folder. You also need to edit Cordova.js to reference the Cordova-\*.js file you are testing.
+For example, to test with Cordova-0.9.6.1, the Cordova.js file would be:
+
+ document.write('');
+ document.write('');
+
+This is done so that you don't have to modify every HTML file when you want to test a new version of Cordova.
+
+The goal is to test mobile device functionality inside a mobile browser.
+Where possible, the Cordova API lines up with HTML 5 spec. Maybe down
+the road we could use this spec for parts of HTML 5, too :)
diff --git a/test/assets/www/accelerometer/index.html b/test/assets/www/accelerometer/index.html
new file mode 100755
index 00000000..07135e16
--- /dev/null
+++ b/test/assets/www/accelerometer/index.html
@@ -0,0 +1,138 @@
+
+
+
+
+
+ PhoneGap
+
+
+
+
+
+
+
+
+
+
Back
+
+
diff --git a/test/assets/www/cordova-1.4.1.js b/test/assets/www/cordova-1.4.1.js
new file mode 100644
index 00000000..edbbb47b
--- /dev/null
+++ b/test/assets/www/cordova-1.4.1.js
@@ -0,0 +1,5510 @@
+/*
+ * 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.
+ */
+
+if (typeof Cordova === "undefined") {
+
+/**
+ * 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
+ * onPause User event fired to indicate a pause lifecycle event
+ * onDestroy Internal event fired when app is being destroyed (User should use window.onunload event, not this one).
+ *
+ * The only Cordova events that user code should register for are:
+ * deviceready Cordova native code is initialized and Cordova APIs can be called from JavaScript
+ * pause App has moved to background
+ * resume App has returned to foreground
+ *
+ * Listeners can be registered as:
+ * document.addEventListener("deviceready", myDeviceReadyListener, false);
+ * document.addEventListener("resume", myResumeListener, false);
+ * document.addEventListener("pause", myPauseListener, false);
+ *
+ * The DOM lifecycle events should be used for saving and restoring state
+ * window.onload
+ * window.onunload
+ */
+
+/**
+ * This represents the Cordova API itself, and provides a global namespace for accessing
+ * information about the state of Cordova.
+ * @class
+ */
+var Cordova = {
+ documentEventHandler: {}, // Collection of custom document event handlers
+ windowEventHandler: {} // Collection of custom window event handlers
+};
+
+/**
+ * List of resource files loaded by Cordova.
+ * This is used to ensure JS and other files are loaded only once.
+ */
+Cordova.resources = {base: true};
+
+/**
+ * Determine if resource has been loaded by Cordova
+ *
+ * @param name
+ * @return
+ */
+Cordova.hasResource = function(name) {
+ return Cordova.resources[name];
+};
+
+/**
+ * Add a resource to list of loaded resources by Cordova
+ *
+ * @param name
+ */
+Cordova.addResource = function(name) {
+ Cordova.resources[name] = true;
+};
+
+/**
+ * Custom pub-sub channel that can have functions subscribed to it
+ * @constructor
+ */
+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" && typeof f === "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" && typeof f === "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 (typeof g === "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;
+ var item, handler, rv;
+ for (item in this.handlers) {
+ if (this.handlers.hasOwnProperty(item)) {
+ handler = this.handlers[item];
+ if (typeof handler === "function") {
+ 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();
+ }
+ };
+ var len = i;
+ var j;
+ for (j=0; j
+ *
+ * @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("Error: 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');
+
+/**
+ * onCordovaConnectionReady channel is fired when the Cordova connection properties
+ * has been set.
+ */
+Cordova.onCordovaConnectionReady = new Cordova.Channel('onCordovaConnectionReady');
+
+/**
+ * onDestroy channel is fired when the Cordova native code
+ * is destroyed. It is used internally.
+ * Window.onunload should be used by the user.
+ */
+Cordova.onDestroy = new Cordova.Channel('onDestroy');
+Cordova.onDestroy.subscribeOnce(function() {
+ Cordova.shuttingDown = true;
+});
+Cordova.shuttingDown = false;
+
+// _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');
+
+
+// Array of channels that must fire before "deviceready" is fired
+Cordova.deviceReadyChannelsArray = [ Cordova.onCordovaReady, Cordova.onCordovaInfoReady, Cordova.onCordovaConnectionReady];
+
+// Hashtable of user defined channels that must also fire before "deviceready" is fired
+Cordova.deviceReadyChannelsMap = {};
+
+/**
+ * Indicate that a feature needs to be initialized before it is ready to be used.
+ * This holds up Cordova's "deviceready" event until the feature has been initialized
+ * and Cordova.initComplete(feature) is called.
+ *
+ * @param feature {String} The unique feature name
+ */
+Cordova.waitForInitialization = function(feature) {
+ if (feature) {
+ var channel = new Cordova.Channel(feature);
+ Cordova.deviceReadyChannelsMap[feature] = channel;
+ Cordova.deviceReadyChannelsArray.push(channel);
+ }
+};
+
+/**
+ * Indicate that initialization code has completed and the feature is ready to be used.
+ *
+ * @param feature {String} The unique feature name
+ */
+Cordova.initializationComplete = function(feature) {
+ var channel = Cordova.deviceReadyChannelsMap[feature];
+ if (channel) {
+ channel.fire();
+ }
+};
+
+/**
+ * Create all Cordova objects once page has fully loaded and native side is ready.
+ */
+Cordova.Channel.join(function() {
+
+ // Start listening for XHR callbacks
+ setTimeout(function() {
+ if (Cordova.UsePolling) {
+ Cordova.JSCallbackPolling();
+ }
+ else {
+ var polling = prompt("usePolling", "gap_callbackServer:");
+ Cordova.UsePolling = polling;
+ if (polling == "true") {
+ Cordova.UsePolling = true;
+ Cordova.JSCallbackPolling();
+ }
+ else {
+ Cordova.UsePolling = false;
+ Cordova.JSCallback();
+ }
+ }
+ }, 1);
+
+ // Run Cordova constructors
+ Cordova.onCordovaInit.fire();
+
+ // Fire event to notify that all objects are created
+ Cordova.onCordovaReady.fire();
+
+ // Fire onDeviceReady event once all constructors have run and Cordova info has been
+ // received from native side, and any user defined initialization channels.
+ Cordova.Channel.join(function() {
+ // Let native code know we are inited on JS side
+ prompt("", "gap_init:");
+
+ Cordova.onDeviceReady.fire();
+ }, Cordova.deviceReadyChannelsArray);
+
+}, [ Cordova.onDOMContentLoaded, Cordova.onNativeReady ]);
+
+// 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;
+
+// Intercept calls to window.addEventListener
+Cordova.m_window_addEventListener = window.addEventListener;
+
+/**
+ * Add a custom window event handler.
+ *
+ * @param {String} event The event name that callback handles
+ * @param {Function} callback The event handler
+ */
+Cordova.addWindowEventHandler = function(event, callback) {
+ Cordova.windowEventHandler[event] = callback;
+};
+
+/**
+ * Add a custom document event handler.
+ *
+ * @param {String} event The event name that callback handles
+ * @param {Function} callback The event handler
+ */
+Cordova.addDocumentEventHandler = function(event, callback) {
+ Cordova.documentEventHandler[event] = callback;
+};
+
+/**
+ * Intercept adding document event listeners and handle our own
+ *
+ * @param {Object} evt
+ * @param {Function} handler
+ * @param capture
+ */
+document.addEventListener = function(evt, handler, capture) {
+ var e = evt.toLowerCase();
+ if (e === 'deviceready') {
+ Cordova.onDeviceReady.subscribeOnce(handler);
+ }
+ else {
+ // If subscribing to Android backbutton
+ if (e === 'backbutton') {
+ Cordova.exec(null, null, "App", "overrideBackbutton", [true]);
+ }
+
+ // If subscribing to an event that is handled by a plugin
+ else if (typeof Cordova.documentEventHandler[e] !== "undefined") {
+ if (Cordova.documentEventHandler[e](e, handler, true)) {
+ return; // Stop default behavior
+ }
+ }
+
+ Cordova.m_document_addEventListener.call(document, evt, handler, capture);
+ }
+};
+
+/**
+ * Intercept adding window event listeners and handle our own
+ *
+ * @param {Object} evt
+ * @param {Function} handler
+ * @param capture
+ */
+window.addEventListener = function(evt, handler, capture) {
+ var e = evt.toLowerCase();
+
+ // If subscribing to an event that is handled by a plugin
+ if (typeof Cordova.windowEventHandler[e] !== "undefined") {
+ if (Cordova.windowEventHandler[e](e, handler, true)) {
+ return; // Stop default behavior
+ }
+ }
+
+ Cordova.m_window_addEventListener.call(window, evt, handler, capture);
+};
+
+// Intercept calls to document.removeEventListener and watch for events that
+// are generated by Cordova native code
+Cordova.m_document_removeEventListener = document.removeEventListener;
+
+// Intercept calls to window.removeEventListener
+Cordova.m_window_removeEventListener = window.removeEventListener;
+
+/**
+ * Intercept removing document event listeners and handle our own
+ *
+ * @param {Object} evt
+ * @param {Function} handler
+ * @param capture
+ */
+document.removeEventListener = function(evt, handler, capture) {
+ var e = evt.toLowerCase();
+
+ // If unsubscribing to Android backbutton
+ if (e === 'backbutton') {
+ Cordova.exec(null, null, "App", "overrideBackbutton", [false]);
+ }
+
+ // If unsubcribing from an event that is handled by a plugin
+ if (typeof Cordova.documentEventHandler[e] !== "undefined") {
+ if (Cordova.documentEventHandler[e](e, handler, false)) {
+ return; // Stop default behavior
+ }
+ }
+
+ Cordova.m_document_removeEventListener.call(document, evt, handler, capture);
+};
+
+/**
+ * Intercept removing window event listeners and handle our own
+ *
+ * @param {Object} evt
+ * @param {Function} handler
+ * @param capture
+ */
+window.removeEventListener = function(evt, handler, capture) {
+ var e = evt.toLowerCase();
+
+ // If unsubcribing from an event that is handled by a plugin
+ if (typeof Cordova.windowEventHandler[e] !== "undefined") {
+ if (Cordova.windowEventHandler[e](e, handler, false)) {
+ return; // Stop default behavior
+ }
+ }
+
+ Cordova.m_window_removeEventListener.call(window, evt, handler, capture);
+};
+
+/**
+ * Method to fire document event
+ *
+ * @param {String} type The event type to fire
+ * @param {Object} data Data to send with event
+ */
+Cordova.fireDocumentEvent = function(type, data) {
+ var e = document.createEvent('Events');
+ e.initEvent(type);
+ if (data) {
+ for (var i in data) {
+ e[i] = data[i];
+ }
+ }
+ document.dispatchEvent(e);
+};
+
+/**
+ * Method to fire window event
+ *
+ * @param {String} type The event type to fire
+ * @param {Object} data Data to send with event
+ */
+Cordova.fireWindowEvent = function(type, data) {
+ var e = document.createEvent('Events');
+ e.initEvent(type);
+ if (data) {
+ for (var i in data) {
+ e[i] = data[i];
+ }
+ }
+ window.dispatchEvent(e);
+};
+
+/**
+ * Does a deep clone of the object.
+ *
+ * @param obj
+ * @return {Object}
+ */
+Cordova.clone = function(obj) {
+ var i, retVal;
+ if(!obj) {
+ return obj;
+ }
+
+ if(obj instanceof Array){
+ retVal = [];
+ for(i = 0; i < obj.length; ++i){
+ retVal.push(Cordova.clone(obj[i]));
+ }
+ return retVal;
+ }
+
+ if (typeof obj === "function") {
+ return obj;
+ }
+
+ if(!(obj instanceof Object)){
+ return obj;
+ }
+
+ if (obj instanceof Date) {
+ return obj;
+ }
+
+ retVal = {};
+ for(i in obj){
+ if(!(i in retVal) || retVal[i] !== obj[i]) {
+ retVal[i] = Cordova.clone(obj[i]);
+ }
+ }
+ return retVal;
+};
+
+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
+ };
+
+
+/**
+ * Execute a Cordova command. It is up to the native side whether this action is synch or async.
+ * The native side can return:
+ * Synchronous: PluginResult object as a JSON string
+ * Asynchrounous: Empty string ""
+ * If async, the native side will 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 Action to be run in Cordova
+ * @param {Array.} [args] Zero or more arguments to pass to the method
+ */
+Cordova.exec = function(success, fail, service, action, args) {
+ try {
+ var callbackId = service + Cordova.callbackId++;
+ if (success || fail) {
+ Cordova.callbacks[callbackId] = {success:success, fail:fail};
+ }
+
+ var r = prompt(JSON.stringify(args), "gap:"+JSON.stringify([service, action, callbackId, true]));
+
+ // If a result was returned
+ if (r.length > 0) {
+ eval("var v="+r+";");
+
+ // If status is OK, then return value back to caller
+ if (v.status === Cordova.callbackStatus.OK) {
+
+ // If there is a success callback, then call it now with
+ // returned value
+ if (success) {
+ try {
+ success(v.message);
+ } catch (e) {
+ console.log("Error in success callback: " + callbackId + " = " + e);
+ }
+
+ // Clear callback if not expecting any more results
+ if (!v.keepCallback) {
+ delete Cordova.callbacks[callbackId];
+ }
+ }
+ return v.message;
+ }
+
+ // If no result
+ else if (v.status === Cordova.callbackStatus.NO_RESULT) {
+
+ // Clear callback if not expecting any more results
+ if (!v.keepCallback) {
+ delete Cordova.callbacks[callbackId];
+ }
+ }
+
+ // If error, then display error
+ else {
+ console.log("Error: Status="+v.status+" Message="+v.message);
+
+ // If there is a fail callback, then call it now with returned value
+ if (fail) {
+ try {
+ fail(v.message);
+ }
+ catch (e1) {
+ console.log("Error in error callback: "+callbackId+" = "+e1);
+ }
+
+ // Clear callback if not expecting any more results
+ if (!v.keepCallback) {
+ delete Cordova.callbacks[callbackId];
+ }
+ }
+ return null;
+ }
+ }
+ } catch (e2) {
+ console.log("Error: "+e2);
+ }
+};
+
+/**
+ * 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];
+ }
+ }
+};
+
+Cordova.JSCallbackPort = null;
+Cordova.JSCallbackToken = null;
+
+/**
+ * This is only for Android.
+ *
+ * Internal function that uses XHR to call into Cordova Java code and retrieve
+ * any JavaScript code that needs to be run. This is used for callbacks from
+ * Java to JavaScript.
+ */
+Cordova.JSCallback = function() {
+
+ // Exit if shutting down app
+ if (Cordova.shuttingDown) {
+ return;
+ }
+
+ // If polling flag was changed, start using polling from now on
+ if (Cordova.UsePolling) {
+ Cordova.JSCallbackPolling();
+ return;
+ }
+
+ var xmlhttp = new XMLHttpRequest();
+
+ // Callback function when XMLHttpRequest is ready
+ xmlhttp.onreadystatechange=function(){
+ if(xmlhttp.readyState === 4){
+
+ // Exit if shutting down app
+ if (Cordova.shuttingDown) {
+ return;
+ }
+
+ // If callback has JavaScript statement to execute
+ if (xmlhttp.status === 200) {
+
+ // Need to url decode the response
+ var msg = decodeURIComponent(xmlhttp.responseText);
+ setTimeout(function() {
+ try {
+ var t = eval(msg);
+ }
+ catch (e) {
+ // If we're getting an error here, seeing the message will help in debugging
+ console.log("JSCallback: Message from Server: " + msg);
+ console.log("JSCallback Error: "+e);
+ }
+ }, 1);
+ setTimeout(Cordova.JSCallback, 1);
+ }
+
+ // If callback ping (used to keep XHR request from timing out)
+ else if (xmlhttp.status === 404) {
+ setTimeout(Cordova.JSCallback, 10);
+ }
+
+ // If security error
+ else if (xmlhttp.status === 403) {
+ console.log("JSCallback Error: Invalid token. Stopping callbacks.");
+ }
+
+ // If server is stopping
+ else if (xmlhttp.status === 503) {
+ console.log("JSCallback Server Closed: Stopping callbacks.");
+ }
+
+ // If request wasn't GET
+ else if (xmlhttp.status === 400) {
+ console.log("JSCallback Error: Bad request. Stopping callbacks.");
+ }
+
+ // If error, revert to polling
+ else {
+ console.log("JSCallback Error: Request failed.");
+ Cordova.UsePolling = true;
+ Cordova.JSCallbackPolling();
+ }
+ }
+ };
+
+ if (Cordova.JSCallbackPort === null) {
+ Cordova.JSCallbackPort = prompt("getPort", "gap_callbackServer:");
+ }
+ if (Cordova.JSCallbackToken === null) {
+ Cordova.JSCallbackToken = prompt("getToken", "gap_callbackServer:");
+ }
+ xmlhttp.open("GET", "http://127.0.0.1:"+Cordova.JSCallbackPort+"/"+Cordova.JSCallbackToken , true);
+ xmlhttp.send();
+};
+
+/**
+ * The polling period to use with JSCallbackPolling.
+ * This can be changed by the application. The default is 50ms.
+ */
+Cordova.JSCallbackPollingPeriod = 50;
+
+/**
+ * Flag that can be set by the user to force polling to be used or force XHR to be used.
+ */
+Cordova.UsePolling = false; // T=use polling, F=use XHR
+
+/**
+ * This is only for Android.
+ *
+ * Internal function that uses polling to call into Cordova Java code and retrieve
+ * any JavaScript code that needs to be run. This is used for callbacks from
+ * Java to JavaScript.
+ */
+Cordova.JSCallbackPolling = function() {
+
+ // Exit if shutting down app
+ if (Cordova.shuttingDown) {
+ return;
+ }
+
+ // If polling flag was changed, stop using polling from now on
+ if (!Cordova.UsePolling) {
+ Cordova.JSCallback();
+ return;
+ }
+
+ var msg = prompt("", "gap_poll:");
+ if (msg) {
+ setTimeout(function() {
+ try {
+ var t = eval(""+msg);
+ }
+ catch (e) {
+ console.log("JSCallbackPolling: Message from Server: " + msg);
+ console.log("JSCallbackPolling Error: "+e);
+ }
+ }, 1);
+ setTimeout(Cordova.JSCallbackPolling, 1);
+ }
+ else {
+ setTimeout(Cordova.JSCallbackPolling, Cordova.JSCallbackPollingPeriod);
+ }
+};
+
+/**
+ * Create a UUID
+ *
+ * @return {String}
+ */
+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 = "";
+ var i, uuidchar;
+ for (i=0; i frequency + 10 sec
+ Cordova.exec(
+ function(timeout) {
+ if (timeout < (frequency + 10000)) {
+ Cordova.exec(null, null, "Accelerometer", "setTimeout", [frequency + 10000]);
+ }
+ },
+ function(e) { }, "Accelerometer", "getTimeout", []);
+
+ // Start watch timer
+ var id = Cordova.createUUID();
+ navigator.accelerometer.timers[id] = setInterval(function() {
+ Cordova.exec(successCallback, errorCallback, "Accelerometer", "getAcceleration", []);
+ }, (frequency ? frequency : 1));
+
+ return 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 && navigator.accelerometer.timers[id] !== undefined) {
+ clearInterval(navigator.accelerometer.timers[id]);
+ delete navigator.accelerometer.timers[id];
+ }
+};
+
+Cordova.addConstructor(function() {
+ if (typeof navigator.accelerometer === "undefined") {
+ navigator.accelerometer = new Accelerometer();
+ }
+});
+}
+/*
+ * 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.
+ */
+
+if (!Cordova.hasResource("app")) {
+Cordova.addResource("app");
+(function() {
+
+/**
+ * Constructor
+ * @constructor
+ */
+var App = function() {};
+
+/**
+ * Clear the resource cache.
+ */
+App.prototype.clearCache = function() {
+ Cordova.exec(null, null, "App", "clearCache", []);
+};
+
+/**
+ * Load the url into the webview or into new browser instance.
+ *
+ * @param url The URL to load
+ * @param props Properties that can be passed in to the activity:
+ * wait: int => wait msec before loading URL
+ * loadingDialog: "Title,Message" => display a native loading dialog
+ * loadUrlTimeoutValue: int => time in msec to wait before triggering a timeout error
+ * clearHistory: boolean => clear webview history (default=false)
+ * openExternal: boolean => open in a new browser (default=false)
+ *
+ * Example:
+ * navigator.app.loadUrl("http://server/myapp/index.html", {wait:2000, loadingDialog:"Wait,Loading App", loadUrlTimeoutValue: 60000});
+ */
+App.prototype.loadUrl = function(url, props) {
+ Cordova.exec(null, null, "App", "loadUrl", [url, props]);
+};
+
+/**
+ * Cancel loadUrl that is waiting to be loaded.
+ */
+App.prototype.cancelLoadUrl = function() {
+ Cordova.exec(null, null, "App", "cancelLoadUrl", []);
+};
+
+/**
+ * Clear web history in this web view.
+ * Instead of BACK button loading the previous web page, it will exit the app.
+ */
+App.prototype.clearHistory = function() {
+ Cordova.exec(null, null, "App", "clearHistory", []);
+};
+
+/**
+ * Go to previous page displayed.
+ * This is the same as pressing the backbutton on Android device.
+ */
+App.prototype.backHistory = function() {
+ Cordova.exec(null, null, "App", "backHistory", []);
+};
+
+/**
+ * Exit and terminate the application.
+ */
+App.prototype.exitApp = function() {
+ return Cordova.exec(null, null, "App", "exitApp", []);
+};
+
+Cordova.addConstructor(function() {
+ navigator.app = new App();
+});
+}());
+}
+/*
+ * 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.
+ */
+
+if (!Cordova.hasResource("battery")) {
+Cordova.addResource("battery");
+
+/**
+ * This class contains information about the current battery status.
+ * @constructor
+ */
+var Battery = function() {
+ this._level = null;
+ this._isPlugged = null;
+ this._batteryListener = [];
+ this._lowListener = [];
+ this._criticalListener = [];
+};
+
+/**
+ * Registers as an event producer for battery events.
+ *
+ * @param {Object} eventType
+ * @param {Object} handler
+ * @param {Object} add
+ */
+Battery.prototype.eventHandler = function(eventType, handler, add) {
+ var me = navigator.battery;
+ if (add) {
+ // If there are no current registered event listeners start the battery listener on native side.
+ if (me._batteryListener.length === 0 && me._lowListener.length === 0 && me._criticalListener.length === 0) {
+ Cordova.exec(me._status, me._error, "Battery", "start", []);
+ }
+
+ // Register the event listener in the proper array
+ if (eventType === "batterystatus") {
+ if (me._batteryListener.indexOf(handler) === -1) {
+ me._batteryListener.push(handler);
+ }
+ } else if (eventType === "batterylow") {
+ if (me._lowListener.indexOf(handler) === -1) {
+ me._lowListener.push(handler);
+ }
+ } else if (eventType === "batterycritical") {
+ if (me._criticalListener.indexOf(handler) === -1) {
+ me._criticalListener.push(handler);
+ }
+ }
+ } else {
+ var pos = -1;
+ // Remove the event listener from the proper array
+ if (eventType === "batterystatus") {
+ pos = me._batteryListener.indexOf(handler);
+ if (pos > -1) {
+ me._batteryListener.splice(pos, 1);
+ }
+ } else if (eventType === "batterylow") {
+ pos = me._lowListener.indexOf(handler);
+ if (pos > -1) {
+ me._lowListener.splice(pos, 1);
+ }
+ } else if (eventType === "batterycritical") {
+ pos = me._criticalListener.indexOf(handler);
+ if (pos > -1) {
+ me._criticalListener.splice(pos, 1);
+ }
+ }
+
+ // If there are no more registered event listeners stop the battery listener on native side.
+ if (me._batteryListener.length === 0 && me._lowListener.length === 0 && me._criticalListener.length === 0) {
+ Cordova.exec(null, null, "Battery", "stop", []);
+ }
+ }
+};
+
+/**
+ * Callback for battery status
+ *
+ * @param {Object} info keys: level, isPlugged
+ */
+Battery.prototype._status = function(info) {
+ if (info) {
+ var me = this;
+ var level = info.level;
+ if (me._level !== level || me._isPlugged !== info.isPlugged) {
+ // Fire batterystatus event
+ Cordova.fireWindowEvent("batterystatus", info);
+
+ // Fire low battery event
+ if (level === 20 || level === 5) {
+ if (level === 20) {
+ Cordova.fireWindowEvent("batterylow", info);
+ }
+ else {
+ Cordova.fireWindowEvent("batterycritical", info);
+ }
+ }
+ }
+ me._level = level;
+ me._isPlugged = info.isPlugged;
+ }
+};
+
+/**
+ * Error callback for battery start
+ */
+Battery.prototype._error = function(e) {
+ console.log("Error initializing Battery: " + e);
+};
+
+Cordova.addConstructor(function() {
+ if (typeof navigator.battery === "undefined") {
+ navigator.battery = new Battery();
+ Cordova.addWindowEventHandler("batterystatus", navigator.battery.eventHandler);
+ Cordova.addWindowEventHandler("batterylow", navigator.battery.eventHandler);
+ Cordova.addWindowEventHandler("batterycritical", navigator.battery.eventHandler);
+ }
+});
+}
+/*
+ * 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.
+ */
+
+if (!Cordova.hasResource("camera")) {
+Cordova.addResource("camera");
+
+/**
+ * This class provides access to the device camera.
+ *
+ * @constructor
+ */
+var Camera = function() {
+ this.successCallback = null;
+ this.errorCallback = null;
+ 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 (content://media/external/images/media/2 for Android)
+};
+Camera.prototype.DestinationType = Camera.DestinationType;
+
+/**
+ * Encoding of image returned from getPicture.
+ *
+ * Example: navigator.camera.getPicture(success, fail,
+ * { quality: 80,
+ * destinationType: Camera.DestinationType.DATA_URL,
+ * sourceType: Camera.PictureSourceType.CAMERA,
+ * encodingType: Camera.EncodingType.PNG})
+*/
+Camera.EncodingType = {
+ JPEG: 0, // Return JPEG encoded image
+ PNG: 1 // Return PNG encoded image
+};
+Camera.prototype.EncodingType = Camera.EncodingType;
+
+/**
+ * Type of pictures to select from. Only applicable when
+ * PictureSourceType is PHOTOLIBRARY or SAVEDPHOTOALBUM
+ *
+ * Example: navigator.camera.getPicture(success, fail,
+ * { quality: 80,
+ * destinationType: Camera.DestinationType.DATA_URL,
+ * sourceType: Camera.PictureSourceType.PHOTOLIBRARY,
+ * mediaType: Camera.MediaType.PICTURE})
+ */
+Camera.MediaType = {
+ PICTURE: 0, // allow selection of still pictures only. DEFAULT. Will return format specified via DestinationType
+ VIDEO: 1, // allow selection of video only, ONLY RETURNS URL
+ ALLMEDIA : 2 // allow selection from all media types
+};
+Camera.prototype.MediaType = Camera.MediaType;
+
+
+/**
+ * Source to getPicture from.
+ *
+ * Example: navigator.camera.getPicture(success, fail,
+ * { quality: 80,
+ * destinationType: Camera.DestinationType.DATA_URL,
+ * sourceType: Camera.PictureSourceType.PHOTOLIBRARY})
+ */
+Camera.PictureSourceType = {
+ PHOTOLIBRARY : 0, // Choose image from picture library (same as SAVEDPHOTOALBUM for Android)
+ CAMERA : 1, // Take picture from camera
+ SAVEDPHOTOALBUM : 2 // Choose image from picture library (same as PHOTOLIBRARY for Android)
+};
+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;
+ }
+
+ if (options === null || typeof options === "undefined") {
+ options = {};
+ }
+ if (options.quality === null || typeof options.quality === "undefined") {
+ options.quality = 80;
+ }
+ if (options.maxResolution === null || typeof options.maxResolution === "undefined") {
+ options.maxResolution = 0;
+ }
+ if (options.destinationType === null || typeof options.destinationType === "undefined") {
+ options.destinationType = Camera.DestinationType.FILE_URI;
+ }
+ if (options.sourceType === null || typeof options.sourceType === "undefined") {
+ options.sourceType = Camera.PictureSourceType.CAMERA;
+ }
+ if (options.encodingType === null || typeof options.encodingType === "undefined") {
+ options.encodingType = Camera.EncodingType.JPEG;
+ }
+ if (options.mediaType === null || typeof options.mediaType === "undefined") {
+ options.mediaType = Camera.MediaType.PICTURE;
+ }
+ if (options.targetWidth === null || typeof options.targetWidth === "undefined") {
+ options.targetWidth = -1;
+ }
+ else if (typeof options.targetWidth === "string") {
+ var width = new Number(options.targetWidth);
+ if (isNaN(width) === false) {
+ options.targetWidth = width.valueOf();
+ }
+ }
+ if (options.targetHeight === null || typeof options.targetHeight === "undefined") {
+ options.targetHeight = -1;
+ }
+ else if (typeof options.targetHeight === "string") {
+ var height = new Number(options.targetHeight);
+ if (isNaN(height) === false) {
+ options.targetHeight = height.valueOf();
+ }
+ }
+
+ Cordova.exec(successCallback, errorCallback, "Camera", "takePicture", [options]);
+};
+
+Cordova.addConstructor(function() {
+ if (typeof navigator.camera === "undefined") {
+ navigator.camera = new Camera();
+ }
+});
+}
+/*
+ * 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.
+ */
+
+if (!Cordova.hasResource("capture")) {
+Cordova.addResource("capture");
+
+/**
+ * Represents a single file.
+ *
+ * name {DOMString} name of the file, without path information
+ * fullPath {DOMString} the full path of the file, including the name
+ * type {DOMString} mime type
+ * lastModifiedDate {Date} last modified date
+ * size {Number} size of the file in bytes
+ */
+var MediaFile = function(name, fullPath, type, lastModifiedDate, size){
+ this.name = name || null;
+ this.fullPath = fullPath || null;
+ this.type = type || null;
+ this.lastModifiedDate = lastModifiedDate || null;
+ this.size = size || 0;
+};
+
+/**
+ * Launch device camera application for recording video(s).
+ *
+ * @param {Function} successCB
+ * @param {Function} errorCB
+ */
+MediaFile.prototype.getFormatData = function(successCallback, errorCallback){
+ Cordova.exec(successCallback, errorCallback, "Capture", "getFormatData", [this.fullPath, this.type]);
+};
+
+/**
+ * MediaFileData encapsulates format information of a media file.
+ *
+ * @param {DOMString} codecs
+ * @param {long} bitrate
+ * @param {long} height
+ * @param {long} width
+ * @param {float} duration
+ */
+var MediaFileData = function(codecs, bitrate, height, width, duration){
+ this.codecs = codecs || null;
+ this.bitrate = bitrate || 0;
+ this.height = height || 0;
+ this.width = width || 0;
+ this.duration = duration || 0;
+};
+
+/**
+ * The CaptureError interface encapsulates all errors in the Capture API.
+ */
+var CaptureError = function(){
+ this.code = null;
+};
+
+// Capture error codes
+CaptureError.CAPTURE_INTERNAL_ERR = 0;
+CaptureError.CAPTURE_APPLICATION_BUSY = 1;
+CaptureError.CAPTURE_INVALID_ARGUMENT = 2;
+CaptureError.CAPTURE_NO_MEDIA_FILES = 3;
+CaptureError.CAPTURE_NOT_SUPPORTED = 20;
+
+/**
+ * The Capture interface exposes an interface to the camera and microphone of the hosting device.
+ */
+var Capture = function(){
+ this.supportedAudioModes = [];
+ this.supportedImageModes = [];
+ this.supportedVideoModes = [];
+};
+
+/**
+ * Launch audio recorder application for recording audio clip(s).
+ *
+ * @param {Function} successCB
+ * @param {Function} errorCB
+ * @param {CaptureAudioOptions} options
+ */
+Capture.prototype.captureAudio = function(successCallback, errorCallback, options){
+ Cordova.exec(successCallback, errorCallback, "Capture", "captureAudio", [options]);
+};
+
+/**
+ * Launch camera application for taking image(s).
+ *
+ * @param {Function} successCB
+ * @param {Function} errorCB
+ * @param {CaptureImageOptions} options
+ */
+Capture.prototype.captureImage = function(successCallback, errorCallback, options){
+ Cordova.exec(successCallback, errorCallback, "Capture", "captureImage", [options]);
+};
+
+/**
+ * Launch camera application for taking image(s).
+ *
+ * @param {Function} successCB
+ * @param {Function} errorCB
+ * @param {CaptureImageOptions} options
+ */
+Capture.prototype._castMediaFile = function(pluginResult){
+ var mediaFiles = [];
+ var i;
+ for (i = 0; i < pluginResult.message.length; i++) {
+ var mediaFile = new MediaFile();
+ mediaFile.name = pluginResult.message[i].name;
+ mediaFile.fullPath = pluginResult.message[i].fullPath;
+ mediaFile.type = pluginResult.message[i].type;
+ mediaFile.lastModifiedDate = pluginResult.message[i].lastModifiedDate;
+ mediaFile.size = pluginResult.message[i].size;
+ mediaFiles.push(mediaFile);
+ }
+ pluginResult.message = mediaFiles;
+ return pluginResult;
+};
+
+/**
+ * Launch device camera application for recording video(s).
+ *
+ * @param {Function} successCB
+ * @param {Function} errorCB
+ * @param {CaptureVideoOptions} options
+ */
+Capture.prototype.captureVideo = function(successCallback, errorCallback, options){
+ Cordova.exec(successCallback, errorCallback, "Capture", "captureVideo", [options]);
+};
+
+/**
+ * Encapsulates a set of parameters that the capture device supports.
+ */
+var ConfigurationData = function(){
+ // The ASCII-encoded string in lower case representing the media type.
+ this.type = null;
+ // The height attribute represents height of the image or video in pixels.
+ // In the case of a sound clip this attribute has value 0.
+ this.height = 0;
+ // The width attribute represents width of the image or video in pixels.
+ // In the case of a sound clip this attribute has value 0
+ this.width = 0;
+};
+
+/**
+ * Encapsulates all image capture operation configuration options.
+ */
+var CaptureImageOptions = function(){
+ // Upper limit of images user can take. Value must be equal or greater than 1.
+ this.limit = 1;
+ // The selected image mode. Must match with one of the elements in supportedImageModes array.
+ this.mode = null;
+};
+
+/**
+ * Encapsulates all video capture operation configuration options.
+ */
+var CaptureVideoOptions = function(){
+ // Upper limit of videos user can record. Value must be equal or greater than 1.
+ this.limit = 1;
+ // Maximum duration of a single video clip in seconds.
+ this.duration = 0;
+ // The selected video mode. Must match with one of the elements in supportedVideoModes array.
+ this.mode = null;
+};
+
+/**
+ * Encapsulates all audio capture operation configuration options.
+ */
+var CaptureAudioOptions = function(){
+ // Upper limit of sound clips user can record. Value must be equal or greater than 1.
+ this.limit = 1;
+ // Maximum duration of a single sound clip in seconds.
+ this.duration = 0;
+ // The selected audio mode. Must match with one of the elements in supportedAudioModes array.
+ this.mode = null;
+};
+
+Cordova.addConstructor(function(){
+ if (typeof navigator.device.capture === "undefined") {
+ navigator.device.capture = window.device.capture = new Capture();
+ }
+});
+}
+/*
+ * 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.
+ */
+
+if (!Cordova.hasResource("compass")) {
+Cordova.addResource("compass");
+
+var CompassError = function(){
+ this.code = null;
+};
+
+// Capture error codes
+CompassError.COMPASS_INTERNAL_ERR = 0;
+CompassError.COMPASS_NOT_SUPPORTED = 20;
+
+var CompassHeading = function() {
+ this.magneticHeading = null;
+ this.trueHeading = null;
+ this.headingAccuracy = null;
+ this.timestamp = null;
+};
+
+/**
+ * This class provides access to device Compass data.
+ * @constructor
+ */
+var Compass = function() {
+ /**
+ * The last known Compass position.
+ */
+ this.lastHeading = null;
+
+ /**
+ * List of compass watch timers
+ */
+ this.timers = {};
+};
+
+Compass.ERROR_MSG = ["Not running", "Starting", "", "Failed to start"];
+
+/**
+ * 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. (OPTIONAL)
+ * @param {PositionOptions} options The options for getting the heading data such as timeout. (OPTIONAL)
+ */
+Compass.prototype.getCurrentHeading = function(successCallback, errorCallback, options) {
+
+ // successCallback required
+ if (typeof successCallback !== "function") {
+ console.log("Compass Error: successCallback is not a function");
+ return;
+ }
+
+ // errorCallback optional
+ if (errorCallback && (typeof errorCallback !== "function")) {
+ console.log("Compass Error: errorCallback is not a function");
+ return;
+ }
+
+ // Get heading
+ Cordova.exec(successCallback, errorCallback, "Compass", "getHeading", []);
+};
+
+/**
+ * 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. (OPTIONAL)
+ * @param {HeadingOptions} options The options for getting the heading data such as timeout and the frequency of the watch. (OPTIONAL)
+ * @return String The watch id that must be passed to #clearWatch to stop watching.
+ */
+Compass.prototype.watchHeading= function(successCallback, errorCallback, options) {
+
+ // Default interval (100 msec)
+ var frequency = (options !== undefined) ? options.frequency : 100;
+
+ // successCallback required
+ if (typeof successCallback !== "function") {
+ console.log("Compass Error: successCallback is not a function");
+ return;
+ }
+
+ // errorCallback optional
+ if (errorCallback && (typeof errorCallback !== "function")) {
+ console.log("Compass Error: errorCallback is not a function");
+ return;
+ }
+
+ // Make sure compass timeout > frequency + 10 sec
+ Cordova.exec(
+ function(timeout) {
+ if (timeout < (frequency + 10000)) {
+ Cordova.exec(null, null, "Compass", "setTimeout", [frequency + 10000]);
+ }
+ },
+ function(e) { }, "Compass", "getTimeout", []);
+
+ // Start watch timer to get headings
+ var id = Cordova.createUUID();
+ navigator.compass.timers[id] = setInterval(
+ function() {
+ Cordova.exec(successCallback, errorCallback, "Compass", "getHeading", []);
+ }, (frequency ? frequency : 1));
+
+ return id;
+};
+
+
+/**
+ * Clears the specified heading watch.
+ *
+ * @param {String} id The ID of the watch returned from #watchHeading.
+ */
+Compass.prototype.clearWatch = function(id) {
+
+ // Stop javascript timer & remove from timer list
+ if (id && navigator.compass.timers[id]) {
+ clearInterval(navigator.compass.timers[id]);
+ delete navigator.compass.timers[id];
+ }
+};
+
+Compass.prototype._castDate = function(pluginResult) {
+ if (pluginResult.message.timestamp) {
+ var timestamp = new Date(pluginResult.message.timestamp);
+ pluginResult.message.timestamp = timestamp;
+ }
+ return pluginResult;
+};
+
+Cordova.addConstructor(function() {
+ if (typeof navigator.compass === "undefined") {
+ navigator.compass = new Compass();
+ }
+});
+}
+/*
+ * 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.
+ */
+
+if (!Cordova.hasResource("contact")) {
+Cordova.addResource("contact");
+
+/**
+* Contains information about a single contact.
+* @constructor
+* @param {DOMString} id unique identifier
+* @param {DOMString} displayName
+* @param {ContactName} name
+* @param {DOMString} nickname
+* @param {Array.} phoneNumbers array of phone numbers
+* @param {Array.} emails array of email addresses
+* @param {Array.} addresses array of addresses
+* @param {Array.} ims instant messaging user ids
+* @param {Array.} organizations
+* @param {DOMString} birthday contact's birthday
+* @param {DOMString} note user notes about contact
+* @param {Array.} photos
+* @param {Array.} categories
+* @param {Array.} urls contact's web sites
+*/
+var Contact = function (id, displayName, name, nickname, phoneNumbers, emails, addresses,
+ ims, organizations, birthday, note, photos, categories, urls) {
+ this.id = id || null;
+ this.rawId = 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.birthday = birthday || null;
+ this.note = note || null;
+ this.photos = photos || null; // ContactField[]
+ this.categories = categories || null; // ContactField[]
+ this.urls = urls || null; // ContactField[]
+};
+
+/**
+ * ContactError.
+ * An error code assigned by an implementation when an error has occurreds
+ * @constructor
+ */
+var ContactError = function() {
+ this.code=null;
+};
+
+/**
+ * Error codes
+ */
+ContactError.UNKNOWN_ERROR = 0;
+ContactError.INVALID_ARGUMENT_ERROR = 1;
+ContactError.TIMEOUT_ERROR = 2;
+ContactError.PENDING_OPERATION_ERROR = 3;
+ContactError.IO_ERROR = 4;
+ContactError.NOT_SUPPORTED_ERROR = 5;
+ContactError.PERMISSION_DENIED_ERROR = 20;
+
+/**
+* Removes contact from device storage.
+* @param successCB success callback
+* @param errorCB error callback
+*/
+Contact.prototype.remove = function(successCB, errorCB) {
+ if (this.id === null) {
+ var errorObj = new ContactError();
+ errorObj.code = ContactError.UNKNOWN_ERROR;
+ errorCB(errorObj);
+ }
+ else {
+ Cordova.exec(successCB, errorCB, "Contacts", "remove", [this.id]);
+ }
+};
+
+/**
+* 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);
+ var i;
+ clonedContact.id = null;
+ clonedContact.rawId = 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.tags) {
+ for (i = 0; i < clonedContact.tags.length; i++) {
+ clonedContact.tags[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
+*/
+Contact.prototype.save = function(successCB, errorCB) {
+ Cordova.exec(successCB, errorCB, "Contacts", "save", [this]);
+};
+
+/**
+* Contact name.
+* @constructor
+* @param formatted
+* @param familyName
+* @param givenName
+* @param middle
+* @param prefix
+* @param suffix
+*/
+var ContactName = function(formatted, familyName, givenName, middle, prefix, suffix) {
+ this.formatted = formatted || null;
+ this.familyName = familyName || null;
+ this.givenName = givenName || null;
+ this.middleName = middle || null;
+ this.honorificPrefix = prefix || null;
+ this.honorificSuffix = suffix || null;
+};
+
+/**
+* Generic contact field.
+* @constructor
+* @param {DOMString} id unique identifier, should only be set by native code
+* @param type
+* @param value
+* @param pref
+*/
+var ContactField = function(type, value, pref) {
+ this.id = null;
+ this.type = type || null;
+ this.value = value || null;
+ this.pref = pref || null;
+};
+
+/**
+* Contact address.
+* @constructor
+* @param {DOMString} id unique identifier, should only be set by native code
+* @param formatted
+* @param streetAddress
+* @param locality
+* @param region
+* @param postalCode
+* @param country
+*/
+var ContactAddress = function(pref, type, formatted, streetAddress, locality, region, postalCode, country) {
+ this.id = null;
+ this.pref = pref || null;
+ this.type = type || null;
+ this.formatted = formatted || null;
+ this.streetAddress = streetAddress || null;
+ this.locality = locality || null;
+ this.region = region || null;
+ this.postalCode = postalCode || null;
+ this.country = country || null;
+};
+
+/**
+* Contact organization.
+* @constructor
+* @param {DOMString} id unique identifier, should only be set by native code
+* @param name
+* @param dept
+* @param title
+* @param startDate
+* @param endDate
+* @param location
+* @param desc
+*/
+var ContactOrganization = function(pref, type, name, dept, title) {
+ this.id = null;
+ this.pref = pref || null;
+ this.type = type || null;
+ this.name = name || null;
+ this.department = dept || null;
+ this.title = title || null;
+};
+
+/**
+* Represents a group of Contacts.
+* @constructor
+*/
+var Contacts = function() {
+ this.inProgress = false;
+ this.records = [];
+};
+/**
+* Returns an array of Contacts matching the search criteria.
+* @param fields that should be searched
+* @param successCB success callback
+* @param errorCB error callback
+* @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) {
+ if (successCB === null) {
+ throw new TypeError("You must specify a success callback for the find command.");
+ }
+ if (fields === null || fields === "undefined" || fields.length === "undefined" || fields.length <= 0) {
+ if (typeof errorCB === "function") {
+ errorCB({"code": ContactError.INVALID_ARGUMENT_ERROR});
+ }
+ } else {
+ Cordova.exec(successCB, errorCB, "Contacts", "search", [fields, 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 i;
+ var contact = new Contact();
+ for (i in properties) {
+ if (contact[i] !== 'undefined') {
+ contact[i] = properties[i];
+ }
+ }
+ return contact;
+};
+
+/**
+* This function returns and array of contacts. It is required as we need to convert raw
+* JSON objects into concrete Contact objects. Currently this method is called after
+* navigator.contacts.find but before the find methods success call back.
+*
+* @param jsonArray an array of JSON Objects that need to be converted to Contact objects.
+* @returns an array of Contact objects
+*/
+Contacts.prototype.cast = function(pluginResult) {
+ var contacts = [];
+ var i;
+ for (i=0; i][;base64],
+ *
+ * @param file {File} File object containing file properties
+ */
+FileReader.prototype.readAsDataURL = function(file) {
+ this.fileName = "";
+ if (typeof file.fullPath === "undefined") {
+ this.fileName = file;
+ } else {
+ this.fileName = file.fullPath;
+ }
+
+ // LOADING state
+ this.readyState = FileReader.LOADING;
+
+ // If loadstart callback
+ if (typeof this.onloadstart === "function") {
+ this.onloadstart({"type":"loadstart", "target":this});
+ }
+
+ var me = this;
+
+ // Read file
+ Cordova.exec(
+ // Success callback
+ function(r) {
+ var evt;
+
+ // If DONE (cancelled), then don't do anything
+ if (me.readyState === FileReader.DONE) {
+ return;
+ }
+
+ // Save result
+ me.result = r;
+
+ // If onload callback
+ if (typeof me.onload === "function") {
+ me.onload({"type":"load", "target":me});
+ }
+
+ // DONE state
+ me.readyState = FileReader.DONE;
+
+ // If onloadend callback
+ if (typeof me.onloadend === "function") {
+ me.onloadend({"type":"loadend", "target":me});
+ }
+ },
+ // Error callback
+ function(e) {
+ var evt;
+ // If DONE (cancelled), then don't do anything
+ if (me.readyState === FileReader.DONE) {
+ return;
+ }
+
+ // Save error
+ me.error = e;
+
+ // If onerror callback
+ if (typeof me.onerror === "function") {
+ me.onerror({"type":"error", "target":me});
+ }
+
+ // DONE state
+ me.readyState = FileReader.DONE;
+
+ // If onloadend callback
+ if (typeof me.onloadend === "function") {
+ me.onloadend({"type":"loadend", "target":me});
+ }
+ }, "File", "readAsDataURL", [this.fileName]);
+};
+
+/**
+ * Read file and return data as a binary data.
+ *
+ * @param file {File} File object containing file properties
+ */
+FileReader.prototype.readAsBinaryString = function(file) {
+ // TODO - Can't return binary data to browser.
+ this.fileName = file;
+};
+
+/**
+ * Read file and return data as a binary data.
+ *
+ * @param file {File} File object containing file properties
+ */
+FileReader.prototype.readAsArrayBuffer = function(file) {
+ // TODO - Can't return binary data to browser.
+ this.fileName = file;
+};
+
+//-----------------------------------------------------------------------------
+// File Writer
+//-----------------------------------------------------------------------------
+
+/**
+ * This class writes to the mobile device file system.
+ *
+ * For Android:
+ * The root directory is the root of the file system.
+ * To write to the SD card, the file name is "sdcard/my_file.txt"
+ *
+ * @constructor
+ * @param file {File} File object containing file properties
+ * @param append if true write to the end of the file, otherwise overwrite the file
+ */
+var FileWriter = function(file) {
+ this.fileName = "";
+ this.length = 0;
+ if (file) {
+ this.fileName = file.fullPath || file;
+ this.length = file.size || 0;
+ }
+ // default is to write at the beginning of the file
+ this.position = 0;
+
+ this.readyState = 0; // EMPTY
+
+ this.result = null;
+
+ // 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() {
+ // check for invalid state
+ if (this.readyState === FileWriter.DONE || this.readyState === FileWriter.INIT) {
+ throw FileError.INVALID_STATE_ERR;
+ }
+
+ // set error
+ var error = new FileError(), evt;
+ error.code = error.ABORT_ERR;
+ this.error = error;
+
+ // If error callback
+ if (typeof this.onerror === "function") {
+ this.onerror({"type":"error", "target":this});
+ }
+ // If abort callback
+ if (typeof this.onabort === "function") {
+ this.onabort({"type":"abort", "target":this});
+ }
+
+ this.readyState = FileWriter.DONE;
+
+ // If write end callback
+ if (typeof this.onwriteend === "function") {
+ this.onwriteend({"type":"writeend", "target":this});
+ }
+};
+
+/**
+ * Writes data to the file
+ *
+ * @param text to be written
+ */
+FileWriter.prototype.write = function(text) {
+ // 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;
+
+ var me = this;
+
+ // If onwritestart callback
+ if (typeof me.onwritestart === "function") {
+ me.onwritestart({"type":"writestart", "target":me});
+ }
+
+ // Write file
+ Cordova.exec(
+ // Success callback
+ function(r) {
+ var evt;
+ // If DONE (cancelled), then don't do anything
+ if (me.readyState === FileWriter.DONE) {
+ return;
+ }
+
+ // position always increases by bytes written because file would be extended
+ me.position += r;
+ // The length of the file is now where we are done writing.
+ me.length = me.position;
+
+ // If onwrite callback
+ if (typeof me.onwrite === "function") {
+ me.onwrite({"type":"write", "target":me});
+ }
+
+ // DONE state
+ me.readyState = FileWriter.DONE;
+
+ // If onwriteend callback
+ if (typeof me.onwriteend === "function") {
+ me.onwriteend({"type":"writeend", "target":me});
+ }
+ },
+ // Error callback
+ function(e) {
+ var evt;
+
+ // If DONE (cancelled), then don't do anything
+ if (me.readyState === FileWriter.DONE) {
+ return;
+ }
+
+ // Save error
+ me.error = e;
+
+ // If onerror callback
+ if (typeof me.onerror === "function") {
+ me.onerror({"type":"error", "target":me});
+ }
+
+ // DONE state
+ me.readyState = FileWriter.DONE;
+
+ // If onwriteend callback
+ if (typeof me.onwriteend === "function") {
+ me.onwriteend({"type":"writeend", "target":me});
+ }
+ }, "File", "write", [this.fileName, text, this.position]);
+};
+
+/**
+ * Moves the file pointer to the location specified.
+ *
+ * If the offset is a negative number the position of the file
+ * pointer is rewound. If the offset is greater than the file
+ * size the position is set to the end of the file.
+ *
+ * @param offset is the location to move the file pointer to.
+ */
+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;
+ }
+
+ // See back from end of file.
+ if (offset < 0) {
+ this.position = Math.max(offset + this.length, 0);
+ }
+ // Offset is bigger then file size so set position
+ // to the end of the file.
+ else if (offset > this.length) {
+ this.position = this.length;
+ }
+ // Offset is between 0 and file size so set the position
+ // to start writing.
+ else {
+ this.position = offset;
+ }
+};
+
+/**
+ * Truncates the file to the size specified.
+ *
+ * @param size to chop the file at.
+ */
+FileWriter.prototype.truncate = function(size) {
+ // 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;
+
+ var me = this;
+
+ // If onwritestart callback
+ if (typeof me.onwritestart === "function") {
+ me.onwritestart({"type":"writestart", "target":this});
+ }
+
+ // Write file
+ Cordova.exec(
+ // Success callback
+ function(r) {
+ var evt;
+ // If DONE (cancelled), then don't do anything
+ if (me.readyState === FileWriter.DONE) {
+ return;
+ }
+
+ // Update the length of the file
+ me.length = r;
+ me.position = Math.min(me.position, r);
+
+ // If onwrite callback
+ if (typeof me.onwrite === "function") {
+ me.onwrite({"type":"write", "target":me});
+ }
+
+ // DONE state
+ me.readyState = FileWriter.DONE;
+
+ // If onwriteend callback
+ if (typeof me.onwriteend === "function") {
+ me.onwriteend({"type":"writeend", "target":me});
+ }
+ },
+ // Error callback
+ function(e) {
+ var evt;
+ // If DONE (cancelled), then don't do anything
+ if (me.readyState === FileWriter.DONE) {
+ return;
+ }
+
+ // Save error
+ me.error = e;
+
+ // If onerror callback
+ if (typeof me.onerror === "function") {
+ me.onerror({"type":"error", "target":me});
+ }
+
+ // DONE state
+ me.readyState = FileWriter.DONE;
+
+ // If onwriteend callback
+ if (typeof me.onwriteend === "function") {
+ me.onwriteend({"type":"writeend", "target":me});
+ }
+ }, "File", "truncate", [this.fileName, size]);
+};
+
+/**
+ * Information about the state of the file or directory
+ *
+ * @constructor
+ * {Date} modificationTime (readonly)
+ */
+var Metadata = function() {
+ this.modificationTime=null;
+};
+
+/**
+ * Supplies arguments to methods that lookup or create files and directories
+ *
+ * @constructor
+ * @param {boolean} create file or directory if it doesn't exist
+ * @param {boolean} exclusive if true the command will fail if the file or directory exists
+ */
+var Flags = function(create, exclusive) {
+ this.create = create || false;
+ this.exclusive = exclusive || false;
+};
+
+/**
+ * An interface representing a file system
+ *
+ * @constructor
+ * {DOMString} name the unique name of the file system (readonly)
+ * {DirectoryEntry} root directory of the file system (readonly)
+ */
+var FileSystem = function() {
+ this.name = null;
+ this.root = null;
+};
+
+/**
+ * An interface that lists the files and directories in a directory.
+ * @constructor
+ */
+var DirectoryReader = function(fullPath){
+ this.fullPath = fullPath || null;
+};
+
+/**
+ * Returns a list of entries from a directory.
+ *
+ * @param {Function} successCallback is called with a list of entries
+ * @param {Function} errorCallback is called with a FileError
+ */
+DirectoryReader.prototype.readEntries = function(successCallback, errorCallback) {
+ Cordova.exec(successCallback, errorCallback, "File", "readEntries", [this.fullPath]);
+};
+
+/**
+ * An interface representing a directory on the file system.
+ *
+ * @constructor
+ * {boolean} isFile always false (readonly)
+ * {boolean} isDirectory always true (readonly)
+ * {DOMString} name of the directory, excluding the path leading to it (readonly)
+ * {DOMString} fullPath the absolute full path to the directory (readonly)
+ * {FileSystem} filesystem on which the directory resides (readonly)
+ */
+var DirectoryEntry = function() {
+ this.isFile = false;
+ this.isDirectory = true;
+ this.name = null;
+ this.fullPath = null;
+ this.filesystem = null;
+};
+
+/**
+ * Copies a directory to a new location
+ *
+ * @param {DirectoryEntry} parent the directory to which to copy the entry
+ * @param {DOMString} newName the new name of the entry, defaults to the current name
+ * @param {Function} successCallback is called with the new entry
+ * @param {Function} errorCallback is called with a FileError
+ */
+DirectoryEntry.prototype.copyTo = function(parent, newName, successCallback, errorCallback) {
+ Cordova.exec(successCallback, errorCallback, "File", "copyTo", [this.fullPath, parent, newName]);
+};
+
+/**
+ * Looks up the metadata of the entry
+ *
+ * @param {Function} successCallback is called with a Metadata object
+ * @param {Function} errorCallback is called with a FileError
+ */
+DirectoryEntry.prototype.getMetadata = function(successCallback, errorCallback) {
+ Cordova.exec(successCallback, errorCallback, "File", "getMetadata", [this.fullPath]);
+};
+
+/**
+ * Gets the parent of the entry
+ *
+ * @param {Function} successCallback is called with a parent entry
+ * @param {Function} errorCallback is called with a FileError
+ */
+DirectoryEntry.prototype.getParent = function(successCallback, errorCallback) {
+ Cordova.exec(successCallback, errorCallback, "File", "getParent", [this.fullPath]);
+};
+
+/**
+ * Moves a directory to a new location
+ *
+ * @param {DirectoryEntry} parent the directory to which to move the entry
+ * @param {DOMString} newName the new name of the entry, defaults to the current name
+ * @param {Function} successCallback is called with the new entry
+ * @param {Function} errorCallback is called with a FileError
+ */
+DirectoryEntry.prototype.moveTo = function(parent, newName, successCallback, errorCallback) {
+ Cordova.exec(successCallback, errorCallback, "File", "moveTo", [this.fullPath, parent, newName]);
+};
+
+/**
+ * Removes the entry
+ *
+ * @param {Function} successCallback is called with no parameters
+ * @param {Function} errorCallback is called with a FileError
+ */
+DirectoryEntry.prototype.remove = function(successCallback, errorCallback) {
+ Cordova.exec(successCallback, errorCallback, "File", "remove", [this.fullPath]);
+};
+
+/**
+ * Returns a URI that can be used to identify this entry.
+ *
+ * @param {DOMString} mimeType for a FileEntry, the mime type to be used to interpret the file, when loaded through this URI.
+ * @return uri
+ */
+DirectoryEntry.prototype.toURI = function(mimeType) {
+ return "file://" + this.fullPath;
+};
+
+/**
+ * Creates a new DirectoryReader to read entries from this directory
+ */
+DirectoryEntry.prototype.createReader = function(successCallback, errorCallback) {
+ return new DirectoryReader(this.fullPath);
+};
+
+/**
+ * Creates or looks up a directory
+ *
+ * @param {DOMString} path either a relative or absolute path from this directory in which to look up or create a directory
+ * @param {Flags} options to create or excluively create the directory
+ * @param {Function} successCallback is called with the new entry
+ * @param {Function} errorCallback is called with a FileError
+ */
+DirectoryEntry.prototype.getDirectory = function(path, options, successCallback, errorCallback) {
+ Cordova.exec(successCallback, errorCallback, "File", "getDirectory", [this.fullPath, path, options]);
+};
+
+/**
+ * Creates or looks up a file
+ *
+ * @param {DOMString} path either a relative or absolute path from this directory in which to look up or create a file
+ * @param {Flags} options to create or excluively create the file
+ * @param {Function} successCallback is called with the new entry
+ * @param {Function} errorCallback is called with a FileError
+ */
+DirectoryEntry.prototype.getFile = function(path, options, successCallback, errorCallback) {
+ Cordova.exec(successCallback, errorCallback, "File", "getFile", [this.fullPath, path, options]);
+};
+
+/**
+ * Deletes a directory and all of it's contents
+ *
+ * @param {Function} successCallback is called with no parameters
+ * @param {Function} errorCallback is called with a FileError
+ */
+DirectoryEntry.prototype.removeRecursively = function(successCallback, errorCallback) {
+ Cordova.exec(successCallback, errorCallback, "File", "removeRecursively", [this.fullPath]);
+};
+
+/**
+ * An interface representing a directory on the file system.
+ *
+ * @constructor
+ * {boolean} isFile always true (readonly)
+ * {boolean} isDirectory always false (readonly)
+ * {DOMString} name of the file, excluding the path leading to it (readonly)
+ * {DOMString} fullPath the absolute full path to the file (readonly)
+ * {FileSystem} filesystem on which the directory resides (readonly)
+ */
+var FileEntry = function() {
+ this.isFile = true;
+ this.isDirectory = false;
+ this.name = null;
+ this.fullPath = null;
+ this.filesystem = null;
+};
+
+/**
+ * Copies a file to a new location
+ *
+ * @param {DirectoryEntry} parent the directory to which to copy the entry
+ * @param {DOMString} newName the new name of the entry, defaults to the current name
+ * @param {Function} successCallback is called with the new entry
+ * @param {Function} errorCallback is called with a FileError
+ */
+FileEntry.prototype.copyTo = function(parent, newName, successCallback, errorCallback) {
+ Cordova.exec(successCallback, errorCallback, "File", "copyTo", [this.fullPath, parent, newName]);
+};
+
+/**
+ * Looks up the metadata of the entry
+ *
+ * @param {Function} successCallback is called with a Metadata object
+ * @param {Function} errorCallback is called with a FileError
+ */
+FileEntry.prototype.getMetadata = function(successCallback, errorCallback) {
+ Cordova.exec(successCallback, errorCallback, "File", "getMetadata", [this.fullPath]);
+};
+
+/**
+ * Gets the parent of the entry
+ *
+ * @param {Function} successCallback is called with a parent entry
+ * @param {Function} errorCallback is called with a FileError
+ */
+FileEntry.prototype.getParent = function(successCallback, errorCallback) {
+ Cordova.exec(successCallback, errorCallback, "File", "getParent", [this.fullPath]);
+};
+
+/**
+ * Moves a directory to a new location
+ *
+ * @param {DirectoryEntry} parent the directory to which to move the entry
+ * @param {DOMString} newName the new name of the entry, defaults to the current name
+ * @param {Function} successCallback is called with the new entry
+ * @param {Function} errorCallback is called with a FileError
+ */
+FileEntry.prototype.moveTo = function(parent, newName, successCallback, errorCallback) {
+ Cordova.exec(successCallback, errorCallback, "File", "moveTo", [this.fullPath, parent, newName]);
+};
+
+/**
+ * Removes the entry
+ *
+ * @param {Function} successCallback is called with no parameters
+ * @param {Function} errorCallback is called with a FileError
+ */
+FileEntry.prototype.remove = function(successCallback, errorCallback) {
+ Cordova.exec(successCallback, errorCallback, "File", "remove", [this.fullPath]);
+};
+
+/**
+ * Returns a URI that can be used to identify this entry.
+ *
+ * @param {DOMString} mimeType for a FileEntry, the mime type to be used to interpret the file, when loaded through this URI.
+ * @return uri
+ */
+FileEntry.prototype.toURI = function(mimeType) {
+ return "file://" + this.fullPath;
+};
+
+/**
+ * Creates a new FileWriter associated with the file that this FileEntry represents.
+ *
+ * @param {Function} successCallback is called with the new FileWriter
+ * @param {Function} errorCallback is called with a FileError
+ */
+FileEntry.prototype.createWriter = function(successCallback, errorCallback) {
+ this.file(function(filePointer) {
+ var writer = new FileWriter(filePointer);
+
+ if (writer.fileName === null || writer.fileName === "") {
+ if (typeof errorCallback === "function") {
+ errorCallback({
+ "code": FileError.INVALID_STATE_ERR
+ });
+ }
+ }
+
+ if (typeof successCallback === "function") {
+ successCallback(writer);
+ }
+ }, errorCallback);
+};
+
+/**
+ * Returns a File that represents the current state of the file that this FileEntry represents.
+ *
+ * @param {Function} successCallback is called with the new File object
+ * @param {Function} errorCallback is called with a FileError
+ */
+FileEntry.prototype.file = function(successCallback, errorCallback) {
+ Cordova.exec(successCallback, errorCallback, "File", "getFileMetadata", [this.fullPath]);
+};
+
+/** @constructor */
+var LocalFileSystem = function() {
+};
+
+// File error codes
+LocalFileSystem.TEMPORARY = 0;
+LocalFileSystem.PERSISTENT = 1;
+LocalFileSystem.RESOURCE = 2;
+LocalFileSystem.APPLICATION = 3;
+
+/**
+ * Requests a filesystem in which to store application data.
+ *
+ * @param {int} type of file system being requested
+ * @param {Function} successCallback is called with the new FileSystem
+ * @param {Function} errorCallback is called with a FileError
+ */
+LocalFileSystem.prototype.requestFileSystem = function(type, size, successCallback, errorCallback) {
+ if (type < 0 || type > 3) {
+ if (typeof errorCallback === "function") {
+ errorCallback({
+ "code": FileError.SYNTAX_ERR
+ });
+ }
+ }
+ else {
+ Cordova.exec(successCallback, errorCallback, "File", "requestFileSystem", [type, size]);
+ }
+};
+
+/**
+ *
+ * @param {DOMString} uri referring to a local file in a filesystem
+ * @param {Function} successCallback is called with the new entry
+ * @param {Function} errorCallback is called with a FileError
+ */
+LocalFileSystem.prototype.resolveLocalFileSystemURI = function(uri, successCallback, errorCallback) {
+ Cordova.exec(successCallback, errorCallback, "File", "resolveLocalFileSystemURI", [uri]);
+};
+
+/**
+* This function returns and array of contacts. It is required as we need to convert raw
+* JSON objects into concrete Contact objects. Currently this method is called after
+* navigator.service.contacts.find but before the find methods success call back.
+*
+* @param a JSON Objects that need to be converted to DirectoryEntry or FileEntry objects.
+* @returns an entry
+*/
+LocalFileSystem.prototype._castFS = function(pluginResult) {
+ var entry = null;
+ entry = new DirectoryEntry();
+ entry.isDirectory = pluginResult.message.root.isDirectory;
+ entry.isFile = pluginResult.message.root.isFile;
+ entry.name = pluginResult.message.root.name;
+ entry.fullPath = pluginResult.message.root.fullPath;
+ pluginResult.message.root = entry;
+ return pluginResult;
+};
+
+LocalFileSystem.prototype._castEntry = function(pluginResult) {
+ var entry = null;
+ if (pluginResult.message.isDirectory) {
+ entry = new DirectoryEntry();
+ }
+ else if (pluginResult.message.isFile) {
+ entry = new FileEntry();
+ }
+ entry.isDirectory = pluginResult.message.isDirectory;
+ entry.isFile = pluginResult.message.isFile;
+ entry.name = pluginResult.message.name;
+ entry.fullPath = pluginResult.message.fullPath;
+ pluginResult.message = entry;
+ return pluginResult;
+};
+
+LocalFileSystem.prototype._castEntries = function(pluginResult) {
+ var entries = pluginResult.message;
+ var retVal = [];
+ for (var i=0; i
+ *
+ * @param name The plugin name
+ * @param obj The plugin object
+ */
+PhoneGap.addPlugin = function(name, obj) {
+ if (!window.plugins[name]) {
+ window.plugins[name] = obj;
+ }
+ else {
+ console.log("Error: Plugin "+name+" already exists.");
+ }
+};
+
+/**
+ * onDOMContentLoaded channel is fired when the DOM content
+ * of the page has been parsed.
+ */
+PhoneGap.onDOMContentLoaded = new PhoneGap.Channel('onDOMContentLoaded');
+
+/**
+ * onNativeReady channel is fired when the PhoneGap native code
+ * has been initialized.
+ */
+PhoneGap.onNativeReady = new PhoneGap.Channel('onNativeReady');
+
+/**
+ * onPhoneGapInit channel is fired when the web page is fully loaded and
+ * PhoneGap native code has been initialized.
+ */
+PhoneGap.onPhoneGapInit = new PhoneGap.Channel('onPhoneGapInit');
+
+/**
+ * onPhoneGapReady channel is fired when the JS PhoneGap objects have been created.
+ */
+PhoneGap.onPhoneGapReady = new PhoneGap.Channel('onPhoneGapReady');
+
+/**
+ * onPhoneGapInfoReady channel is fired when the PhoneGap device properties
+ * has been set.
+ */
+PhoneGap.onPhoneGapInfoReady = new PhoneGap.Channel('onPhoneGapInfoReady');
+
+/**
+ * onPhoneGapConnectionReady channel is fired when the PhoneGap connection properties
+ * has been set.
+ */
+PhoneGap.onPhoneGapConnectionReady = new PhoneGap.Channel('onPhoneGapConnectionReady');
+
+/**
+ * onDestroy channel is fired when the PhoneGap native code
+ * is destroyed. It is used internally.
+ * Window.onunload should be used by the user.
+ */
+PhoneGap.onDestroy = new PhoneGap.Channel('onDestroy');
+PhoneGap.onDestroy.subscribeOnce(function() {
+ PhoneGap.shuttingDown = true;
+});
+PhoneGap.shuttingDown = false;
+
+// _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 PhoneGap JS is ready.
+if (typeof _nativeReady !== 'undefined') { PhoneGap.onNativeReady.fire(); }
+
+/**
+ * onDeviceReady is fired only after all PhoneGap objects are created and
+ * the device properties are set.
+ */
+PhoneGap.onDeviceReady = new PhoneGap.Channel('onDeviceReady');
+
+
+// Array of channels that must fire before "deviceready" is fired
+PhoneGap.deviceReadyChannelsArray = [ PhoneGap.onPhoneGapReady, PhoneGap.onPhoneGapInfoReady, PhoneGap.onPhoneGapConnectionReady];
+
+// Hashtable of user defined channels that must also fire before "deviceready" is fired
+PhoneGap.deviceReadyChannelsMap = {};
+
+/**
+ * Indicate that a feature needs to be initialized before it is ready to be used.
+ * This holds up PhoneGap's "deviceready" event until the feature has been initialized
+ * and PhoneGap.initComplete(feature) is called.
+ *
+ * @param feature {String} The unique feature name
+ */
+PhoneGap.waitForInitialization = function(feature) {
+ if (feature) {
+ var channel = new PhoneGap.Channel(feature);
+ PhoneGap.deviceReadyChannelsMap[feature] = channel;
+ PhoneGap.deviceReadyChannelsArray.push(channel);
+ }
+};
+
+/**
+ * Indicate that initialization code has completed and the feature is ready to be used.
+ *
+ * @param feature {String} The unique feature name
+ */
+PhoneGap.initializationComplete = function(feature) {
+ var channel = PhoneGap.deviceReadyChannelsMap[feature];
+ if (channel) {
+ channel.fire();
+ }
+};
+
+/**
+ * Create all PhoneGap objects once page has fully loaded and native side is ready.
+ */
+PhoneGap.Channel.join(function() {
+
+ // Start listening for XHR callbacks
+ setTimeout(function() {
+ if (PhoneGap.UsePolling) {
+ PhoneGap.JSCallbackPolling();
+ }
+ else {
+ var polling = prompt("usePolling", "gap_callbackServer:");
+ PhoneGap.UsePolling = polling;
+ if (polling == "true") {
+ PhoneGap.UsePolling = true;
+ PhoneGap.JSCallbackPolling();
+ }
+ else {
+ PhoneGap.UsePolling = false;
+ PhoneGap.JSCallback();
+ }
+ }
+ }, 1);
+
+ // Run PhoneGap constructors
+ PhoneGap.onPhoneGapInit.fire();
+
+ // Fire event to notify that all objects are created
+ PhoneGap.onPhoneGapReady.fire();
+
+ // Fire onDeviceReady event once all constructors have run and PhoneGap info has been
+ // received from native side, and any user defined initialization channels.
+ PhoneGap.Channel.join(function() {
+ // Let native code know we are inited on JS side
+ prompt("", "gap_init:");
+
+ PhoneGap.onDeviceReady.fire();
+ }, PhoneGap.deviceReadyChannelsArray);
+
+}, [ PhoneGap.onDOMContentLoaded, PhoneGap.onNativeReady ]);
+
+// Listen for DOMContentLoaded and notify our channel subscribers
+document.addEventListener('DOMContentLoaded', function() {
+ PhoneGap.onDOMContentLoaded.fire();
+}, false);
+
+// Intercept calls to document.addEventListener and watch for deviceready
+PhoneGap.m_document_addEventListener = document.addEventListener;
+
+// Intercept calls to window.addEventListener
+PhoneGap.m_window_addEventListener = window.addEventListener;
+
+/**
+ * Add a custom window event handler.
+ *
+ * @param {String} event The event name that callback handles
+ * @param {Function} callback The event handler
+ */
+PhoneGap.addWindowEventHandler = function(event, callback) {
+ PhoneGap.windowEventHandler[event] = callback;
+};
+
+/**
+ * Add a custom document event handler.
+ *
+ * @param {String} event The event name that callback handles
+ * @param {Function} callback The event handler
+ */
+PhoneGap.addDocumentEventHandler = function(event, callback) {
+ PhoneGap.documentEventHandler[event] = callback;
+};
+
+/**
+ * Intercept adding document event listeners and handle our own
+ *
+ * @param {Object} evt
+ * @param {Function} handler
+ * @param capture
+ */
+document.addEventListener = function(evt, handler, capture) {
+ var e = evt.toLowerCase();
+ if (e === 'deviceready') {
+ PhoneGap.onDeviceReady.subscribeOnce(handler);
+ }
+ else {
+ // If subscribing to Android backbutton
+ if (e === 'backbutton') {
+ PhoneGap.exec(null, null, "App", "overrideBackbutton", [true]);
+ }
+
+ // If subscribing to an event that is handled by a plugin
+ else if (typeof PhoneGap.documentEventHandler[e] !== "undefined") {
+ if (PhoneGap.documentEventHandler[e](e, handler, true)) {
+ return; // Stop default behavior
+ }
+ }
+
+ PhoneGap.m_document_addEventListener.call(document, evt, handler, capture);
+ }
+};
+
+/**
+ * Intercept adding window event listeners and handle our own
+ *
+ * @param {Object} evt
+ * @param {Function} handler
+ * @param capture
+ */
+window.addEventListener = function(evt, handler, capture) {
+ var e = evt.toLowerCase();
+
+ // If subscribing to an event that is handled by a plugin
+ if (typeof PhoneGap.windowEventHandler[e] !== "undefined") {
+ if (PhoneGap.windowEventHandler[e](e, handler, true)) {
+ return; // Stop default behavior
+ }
+ }
+
+ PhoneGap.m_window_addEventListener.call(window, evt, handler, capture);
+};
+
+// Intercept calls to document.removeEventListener and watch for events that
+// are generated by PhoneGap native code
+PhoneGap.m_document_removeEventListener = document.removeEventListener;
+
+// Intercept calls to window.removeEventListener
+PhoneGap.m_window_removeEventListener = window.removeEventListener;
+
+/**
+ * Intercept removing document event listeners and handle our own
+ *
+ * @param {Object} evt
+ * @param {Function} handler
+ * @param capture
+ */
+document.removeEventListener = function(evt, handler, capture) {
+ var e = evt.toLowerCase();
+
+ // If unsubscribing to Android backbutton
+ if (e === 'backbutton') {
+ PhoneGap.exec(null, null, "App", "overrideBackbutton", [false]);
+ }
+
+ // If unsubcribing from an event that is handled by a plugin
+ if (typeof PhoneGap.documentEventHandler[e] !== "undefined") {
+ if (PhoneGap.documentEventHandler[e](e, handler, false)) {
+ return; // Stop default behavior
+ }
+ }
+
+ PhoneGap.m_document_removeEventListener.call(document, evt, handler, capture);
+};
+
+/**
+ * Intercept removing window event listeners and handle our own
+ *
+ * @param {Object} evt
+ * @param {Function} handler
+ * @param capture
+ */
+window.removeEventListener = function(evt, handler, capture) {
+ var e = evt.toLowerCase();
+
+ // If unsubcribing from an event that is handled by a plugin
+ if (typeof PhoneGap.windowEventHandler[e] !== "undefined") {
+ if (PhoneGap.windowEventHandler[e](e, handler, false)) {
+ return; // Stop default behavior
+ }
+ }
+
+ PhoneGap.m_window_removeEventListener.call(window, evt, handler, capture);
+};
+
+/**
+ * Method to fire document event
+ *
+ * @param {String} type The event type to fire
+ * @param {Object} data Data to send with event
+ */
+PhoneGap.fireDocumentEvent = function(type, data) {
+ var e = document.createEvent('Events');
+ e.initEvent(type);
+ if (data) {
+ for (var i in data) {
+ e[i] = data[i];
+ }
+ }
+ document.dispatchEvent(e);
+};
+
+/**
+ * Method to fire window event
+ *
+ * @param {String} type The event type to fire
+ * @param {Object} data Data to send with event
+ */
+PhoneGap.fireWindowEvent = function(type, data) {
+ var e = document.createEvent('Events');
+ e.initEvent(type);
+ if (data) {
+ for (var i in data) {
+ e[i] = data[i];
+ }
+ }
+ window.dispatchEvent(e);
+};
+
+/**
+ * Does a deep clone of the object.
+ *
+ * @param obj
+ * @return {Object}
+ */
+PhoneGap.clone = function(obj) {
+ var i, retVal;
+ if(!obj) {
+ return obj;
+ }
+
+ if(obj instanceof Array){
+ retVal = [];
+ for(i = 0; i < obj.length; ++i){
+ retVal.push(PhoneGap.clone(obj[i]));
+ }
+ return retVal;
+ }
+
+ if (typeof obj === "function") {
+ return obj;
+ }
+
+ if(!(obj instanceof Object)){
+ return obj;
+ }
+
+ if (obj instanceof Date) {
+ return obj;
+ }
+
+ retVal = {};
+ for(i in obj){
+ if(!(i in retVal) || retVal[i] !== obj[i]) {
+ retVal[i] = PhoneGap.clone(obj[i]);
+ }
+ }
+ return retVal;
+};
+
+PhoneGap.callbackId = 0;
+PhoneGap.callbacks = {};
+PhoneGap.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
+ };
+
+
+/**
+ * Execute a PhoneGap command. It is up to the native side whether this action is synch or async.
+ * The native side can return:
+ * Synchronous: PluginResult object as a JSON string
+ * Asynchrounous: Empty string ""
+ * If async, the native side will PhoneGap.callbackSuccess or PhoneGap.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 Action to be run in PhoneGap
+ * @param {Array.} [args] Zero or more arguments to pass to the method
+ */
+PhoneGap.exec = function(success, fail, service, action, args) {
+ try {
+ var callbackId = service + PhoneGap.callbackId++;
+ if (success || fail) {
+ PhoneGap.callbacks[callbackId] = {success:success, fail:fail};
+ }
+
+ var r = prompt(JSON.stringify(args), "gap:"+JSON.stringify([service, action, callbackId, true]));
+
+ // If a result was returned
+ if (r.length > 0) {
+ eval("var v="+r+";");
+
+ // If status is OK, then return value back to caller
+ if (v.status === PhoneGap.callbackStatus.OK) {
+
+ // If there is a success callback, then call it now with
+ // returned value
+ if (success) {
+ try {
+ success(v.message);
+ } catch (e) {
+ console.log("Error in success callback: " + callbackId + " = " + e);
+ }
+
+ // Clear callback if not expecting any more results
+ if (!v.keepCallback) {
+ delete PhoneGap.callbacks[callbackId];
+ }
+ }
+ return v.message;
+ }
+
+ // If no result
+ else if (v.status === PhoneGap.callbackStatus.NO_RESULT) {
+
+ // Clear callback if not expecting any more results
+ if (!v.keepCallback) {
+ delete PhoneGap.callbacks[callbackId];
+ }
+ }
+
+ // If error, then display error
+ else {
+ console.log("Error: Status="+v.status+" Message="+v.message);
+
+ // If there is a fail callback, then call it now with returned value
+ if (fail) {
+ try {
+ fail(v.message);
+ }
+ catch (e1) {
+ console.log("Error in error callback: "+callbackId+" = "+e1);
+ }
+
+ // Clear callback if not expecting any more results
+ if (!v.keepCallback) {
+ delete PhoneGap.callbacks[callbackId];
+ }
+ }
+ return null;
+ }
+ }
+ } catch (e2) {
+ console.log("Error: "+e2);
+ }
+};
+
+/**
+ * Called by native code when returning successful result from an action.
+ *
+ * @param callbackId
+ * @param args
+ */
+PhoneGap.callbackSuccess = function(callbackId, args) {
+ if (PhoneGap.callbacks[callbackId]) {
+
+ // If result is to be sent to callback
+ if (args.status === PhoneGap.callbackStatus.OK) {
+ try {
+ if (PhoneGap.callbacks[callbackId].success) {
+ PhoneGap.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 PhoneGap.callbacks[callbackId];
+ }
+ }
+};
+
+/**
+ * Called by native code when returning error result from an action.
+ *
+ * @param callbackId
+ * @param args
+ */
+PhoneGap.callbackError = function(callbackId, args) {
+ if (PhoneGap.callbacks[callbackId]) {
+ try {
+ if (PhoneGap.callbacks[callbackId].fail) {
+ PhoneGap.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 PhoneGap.callbacks[callbackId];
+ }
+ }
+};
+
+PhoneGap.JSCallbackPort = null;
+PhoneGap.JSCallbackToken = null;
+
+/**
+ * This is only for Android.
+ *
+ * Internal function that uses XHR to call into PhoneGap Java code and retrieve
+ * any JavaScript code that needs to be run. This is used for callbacks from
+ * Java to JavaScript.
+ */
+PhoneGap.JSCallback = function() {
+
+ // Exit if shutting down app
+ if (PhoneGap.shuttingDown) {
+ return;
+ }
+
+ // If polling flag was changed, start using polling from now on
+ if (PhoneGap.UsePolling) {
+ PhoneGap.JSCallbackPolling();
+ return;
+ }
+
+ var xmlhttp = new XMLHttpRequest();
+
+ // Callback function when XMLHttpRequest is ready
+ xmlhttp.onreadystatechange=function(){
+ if(xmlhttp.readyState === 4){
+
+ // Exit if shutting down app
+ if (PhoneGap.shuttingDown) {
+ return;
+ }
+
+ // If callback has JavaScript statement to execute
+ if (xmlhttp.status === 200) {
+
+ // Need to url decode the response
+ var msg = decodeURIComponent(xmlhttp.responseText);
+ setTimeout(function() {
+ try {
+ var t = eval(msg);
+ }
+ catch (e) {
+ // If we're getting an error here, seeing the message will help in debugging
+ console.log("JSCallback: Message from Server: " + msg);
+ console.log("JSCallback Error: "+e);
+ }
+ }, 1);
+ setTimeout(PhoneGap.JSCallback, 1);
+ }
+
+ // If callback ping (used to keep XHR request from timing out)
+ else if (xmlhttp.status === 404) {
+ setTimeout(PhoneGap.JSCallback, 10);
+ }
+
+ // If security error
+ else if (xmlhttp.status === 403) {
+ console.log("JSCallback Error: Invalid token. Stopping callbacks.");
+ }
+
+ // If server is stopping
+ else if (xmlhttp.status === 503) {
+ console.log("JSCallback Server Closed: Stopping callbacks.");
+ }
+
+ // If request wasn't GET
+ else if (xmlhttp.status === 400) {
+ console.log("JSCallback Error: Bad request. Stopping callbacks.");
+ }
+
+ // If error, revert to polling
+ else {
+ console.log("JSCallback Error: Request failed.");
+ PhoneGap.UsePolling = true;
+ PhoneGap.JSCallbackPolling();
+ }
+ }
+ };
+
+ if (PhoneGap.JSCallbackPort === null) {
+ PhoneGap.JSCallbackPort = prompt("getPort", "gap_callbackServer:");
+ }
+ if (PhoneGap.JSCallbackToken === null) {
+ PhoneGap.JSCallbackToken = prompt("getToken", "gap_callbackServer:");
+ }
+ xmlhttp.open("GET", "http://127.0.0.1:"+PhoneGap.JSCallbackPort+"/"+PhoneGap.JSCallbackToken , true);
+ xmlhttp.send();
+};
+
+/**
+ * The polling period to use with JSCallbackPolling.
+ * This can be changed by the application. The default is 50ms.
+ */
+PhoneGap.JSCallbackPollingPeriod = 50;
+
+/**
+ * Flag that can be set by the user to force polling to be used or force XHR to be used.
+ */
+PhoneGap.UsePolling = false; // T=use polling, F=use XHR
+
+/**
+ * This is only for Android.
+ *
+ * Internal function that uses polling to call into PhoneGap Java code and retrieve
+ * any JavaScript code that needs to be run. This is used for callbacks from
+ * Java to JavaScript.
+ */
+PhoneGap.JSCallbackPolling = function() {
+
+ // Exit if shutting down app
+ if (PhoneGap.shuttingDown) {
+ return;
+ }
+
+ // If polling flag was changed, stop using polling from now on
+ if (!PhoneGap.UsePolling) {
+ PhoneGap.JSCallback();
+ return;
+ }
+
+ var msg = prompt("", "gap_poll:");
+ if (msg) {
+ setTimeout(function() {
+ try {
+ var t = eval(""+msg);
+ }
+ catch (e) {
+ console.log("JSCallbackPolling: Message from Server: " + msg);
+ console.log("JSCallbackPolling Error: "+e);
+ }
+ }, 1);
+ setTimeout(PhoneGap.JSCallbackPolling, 1);
+ }
+ else {
+ setTimeout(PhoneGap.JSCallbackPolling, PhoneGap.JSCallbackPollingPeriod);
+ }
+};
+
+/**
+ * Create a UUID
+ *
+ * @return {String}
+ */
+PhoneGap.createUUID = function() {
+ return PhoneGap.UUIDcreatePart(4) + '-' +
+ PhoneGap.UUIDcreatePart(2) + '-' +
+ PhoneGap.UUIDcreatePart(2) + '-' +
+ PhoneGap.UUIDcreatePart(2) + '-' +
+ PhoneGap.UUIDcreatePart(6);
+};
+
+PhoneGap.UUIDcreatePart = function(length) {
+ var uuidpart = "";
+ var i, uuidchar;
+ for (i=0; i
+
+
+
+
+ PhoneGap
+
+
+
+
+
+
+
+
+
+
Back
+
+
diff --git a/test/assets/www/phonegap-1.4.0.js b/test/assets/www/phonegap-1.4.0.js
new file mode 100644
index 00000000..df49a46c
--- /dev/null
+++ b/test/assets/www/phonegap-1.4.0.js
@@ -0,0 +1,5554 @@
+/*
+ * 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.
+ */
+
+// Version 1.2.0
+
+if (typeof PhoneGap === "undefined") {
+
+/**
+ * The order of events during page load and PhoneGap 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 PhoneGap native side is ready.
+ * onPhoneGapInit Internal event that kicks off creation of all PhoneGap JavaScript objects (runs constructors).
+ * onPhoneGapReady Internal event fired when all PhoneGap JavaScript objects have been created
+ * onPhoneGapInfoReady Internal event fired when device properties are available
+ * onDeviceReady User event fired to indicate that PhoneGap is ready
+ * onResume User event fired to indicate a start/resume lifecycle event
+ * onPause User event fired to indicate a pause lifecycle event
+ * onDestroy Internal event fired when app is being destroyed (User should use window.onunload event, not this one).
+ *
+ * The only PhoneGap events that user code should register for are:
+ * deviceready PhoneGap native code is initialized and PhoneGap APIs can be called from JavaScript
+ * pause App has moved to background
+ * resume App has returned to foreground
+ *
+ * Listeners can be registered as:
+ * document.addEventListener("deviceready", myDeviceReadyListener, false);
+ * document.addEventListener("resume", myResumeListener, false);
+ * document.addEventListener("pause", myPauseListener, false);
+ *
+ * The DOM lifecycle events should be used for saving and restoring state
+ * window.onload
+ * window.onunload
+ */
+
+/**
+ * This represents the PhoneGap API itself, and provides a global namespace for accessing
+ * information about the state of PhoneGap.
+ * @class
+ */
+var PhoneGap = {
+ documentEventHandler: {}, // Collection of custom document event handlers
+ windowEventHandler: {} // Collection of custom window event handlers
+};
+
+/**
+ * List of resource files loaded by PhoneGap.
+ * This is used to ensure JS and other files are loaded only once.
+ */
+PhoneGap.resources = {base: true};
+
+/**
+ * Determine if resource has been loaded by PhoneGap
+ *
+ * @param name
+ * @return
+ */
+PhoneGap.hasResource = function(name) {
+ return PhoneGap.resources[name];
+};
+
+/**
+ * Add a resource to list of loaded resources by PhoneGap
+ *
+ * @param name
+ */
+PhoneGap.addResource = function(name) {
+ PhoneGap.resources[name] = true;
+};
+
+/**
+ * Custom pub-sub channel that can have functions subscribed to it
+ * @constructor
+ */
+PhoneGap.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.
+ */
+PhoneGap.Channel.prototype.subscribe = function(f, c, g) {
+ // need a function to call
+ if (f === null) { return; }
+
+ var func = f;
+ if (typeof c === "object" && typeof f === "function") { func = PhoneGap.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.
+ */
+PhoneGap.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" && typeof f === "function") { f = PhoneGap.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.
+ */
+PhoneGap.Channel.prototype.unsubscribe = function(g) {
+ if (typeof g === "function") { g = g.observer_guid; }
+ this.handlers[g] = null;
+ delete this.handlers[g];
+};
+
+/**
+ * Calls all functions subscribed to this channel.
+ */
+PhoneGap.Channel.prototype.fire = function(e) {
+ if (this.enabled) {
+ var fail = false;
+ var item, handler, rv;
+ for (item in this.handlers) {
+ if (this.handlers.hasOwnProperty(item)) {
+ handler = this.handlers[item];
+ if (typeof handler === "function") {
+ 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.
+ */
+PhoneGap.Channel.join = function(h, c) {
+ var i = c.length;
+ var f = function() {
+ if (!(--i)) {
+ h();
+ }
+ };
+ var len = i;
+ var j;
+ for (j=0; j
+ *
+ * @param name The plugin name
+ * @param obj The plugin object
+ */
+PhoneGap.addPlugin = function(name, obj) {
+ if (!window.plugins[name]) {
+ window.plugins[name] = obj;
+ }
+ else {
+ console.log("Error: Plugin "+name+" already exists.");
+ }
+};
+
+/**
+ * onDOMContentLoaded channel is fired when the DOM content
+ * of the page has been parsed.
+ */
+PhoneGap.onDOMContentLoaded = new PhoneGap.Channel('onDOMContentLoaded');
+
+/**
+ * onNativeReady channel is fired when the PhoneGap native code
+ * has been initialized.
+ */
+PhoneGap.onNativeReady = new PhoneGap.Channel('onNativeReady');
+
+/**
+ * onPhoneGapInit channel is fired when the web page is fully loaded and
+ * PhoneGap native code has been initialized.
+ */
+PhoneGap.onPhoneGapInit = new PhoneGap.Channel('onPhoneGapInit');
+
+/**
+ * onPhoneGapReady channel is fired when the JS PhoneGap objects have been created.
+ */
+PhoneGap.onPhoneGapReady = new PhoneGap.Channel('onPhoneGapReady');
+
+/**
+ * onPhoneGapInfoReady channel is fired when the PhoneGap device properties
+ * has been set.
+ */
+PhoneGap.onPhoneGapInfoReady = new PhoneGap.Channel('onPhoneGapInfoReady');
+
+/**
+ * onPhoneGapConnectionReady channel is fired when the PhoneGap connection properties
+ * has been set.
+ */
+PhoneGap.onPhoneGapConnectionReady = new PhoneGap.Channel('onPhoneGapConnectionReady');
+
+/**
+ * onDestroy channel is fired when the PhoneGap native code
+ * is destroyed. It is used internally.
+ * Window.onunload should be used by the user.
+ */
+PhoneGap.onDestroy = new PhoneGap.Channel('onDestroy');
+PhoneGap.onDestroy.subscribeOnce(function() {
+ PhoneGap.shuttingDown = true;
+});
+PhoneGap.shuttingDown = false;
+
+// _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 PhoneGap JS is ready.
+if (typeof _nativeReady !== 'undefined') { PhoneGap.onNativeReady.fire(); }
+
+/**
+ * onDeviceReady is fired only after all PhoneGap objects are created and
+ * the device properties are set.
+ */
+PhoneGap.onDeviceReady = new PhoneGap.Channel('onDeviceReady');
+
+
+// Array of channels that must fire before "deviceready" is fired
+PhoneGap.deviceReadyChannelsArray = [ PhoneGap.onPhoneGapReady, PhoneGap.onPhoneGapInfoReady, PhoneGap.onPhoneGapConnectionReady];
+
+// Hashtable of user defined channels that must also fire before "deviceready" is fired
+PhoneGap.deviceReadyChannelsMap = {};
+
+/**
+ * Indicate that a feature needs to be initialized before it is ready to be used.
+ * This holds up PhoneGap's "deviceready" event until the feature has been initialized
+ * and PhoneGap.initComplete(feature) is called.
+ *
+ * @param feature {String} The unique feature name
+ */
+PhoneGap.waitForInitialization = function(feature) {
+ if (feature) {
+ var channel = new PhoneGap.Channel(feature);
+ PhoneGap.deviceReadyChannelsMap[feature] = channel;
+ PhoneGap.deviceReadyChannelsArray.push(channel);
+ }
+};
+
+/**
+ * Indicate that initialization code has completed and the feature is ready to be used.
+ *
+ * @param feature {String} The unique feature name
+ */
+PhoneGap.initializationComplete = function(feature) {
+ var channel = PhoneGap.deviceReadyChannelsMap[feature];
+ if (channel) {
+ channel.fire();
+ }
+};
+
+/**
+ * Create all PhoneGap objects once page has fully loaded and native side is ready.
+ */
+PhoneGap.Channel.join(function() {
+
+ // Start listening for XHR callbacks
+ setTimeout(function() {
+ if (PhoneGap.UsePolling) {
+ PhoneGap.JSCallbackPolling();
+ }
+ else {
+ var polling = prompt("usePolling", "gap_callbackServer:");
+ PhoneGap.UsePolling = polling;
+ if (polling == "true") {
+ PhoneGap.UsePolling = true;
+ PhoneGap.JSCallbackPolling();
+ }
+ else {
+ PhoneGap.UsePolling = false;
+ PhoneGap.JSCallback();
+ }
+ }
+ }, 1);
+
+ // Run PhoneGap constructors
+ PhoneGap.onPhoneGapInit.fire();
+
+ // Fire event to notify that all objects are created
+ PhoneGap.onPhoneGapReady.fire();
+
+ // Fire onDeviceReady event once all constructors have run and PhoneGap info has been
+ // received from native side, and any user defined initialization channels.
+ PhoneGap.Channel.join(function() {
+ // Let native code know we are inited on JS side
+ prompt("", "gap_init:");
+
+ PhoneGap.onDeviceReady.fire();
+ }, PhoneGap.deviceReadyChannelsArray);
+
+}, [ PhoneGap.onDOMContentLoaded, PhoneGap.onNativeReady ]);
+
+// Listen for DOMContentLoaded and notify our channel subscribers
+document.addEventListener('DOMContentLoaded', function() {
+ PhoneGap.onDOMContentLoaded.fire();
+}, false);
+
+// Intercept calls to document.addEventListener and watch for deviceready
+PhoneGap.m_document_addEventListener = document.addEventListener;
+
+// Intercept calls to window.addEventListener
+PhoneGap.m_window_addEventListener = window.addEventListener;
+
+/**
+ * Add a custom window event handler.
+ *
+ * @param {String} event The event name that callback handles
+ * @param {Function} callback The event handler
+ */
+PhoneGap.addWindowEventHandler = function(event, callback) {
+ PhoneGap.windowEventHandler[event] = callback;
+};
+
+/**
+ * Add a custom document event handler.
+ *
+ * @param {String} event The event name that callback handles
+ * @param {Function} callback The event handler
+ */
+PhoneGap.addDocumentEventHandler = function(event, callback) {
+ PhoneGap.documentEventHandler[event] = callback;
+};
+
+/**
+ * Intercept adding document event listeners and handle our own
+ *
+ * @param {Object} evt
+ * @param {Function} handler
+ * @param capture
+ */
+document.addEventListener = function(evt, handler, capture) {
+ var e = evt.toLowerCase();
+ if (e === 'deviceready') {
+ PhoneGap.onDeviceReady.subscribeOnce(handler);
+ }
+ else {
+ // If subscribing to Android backbutton
+ if (e === 'backbutton') {
+ PhoneGap.exec(null, null, "App", "overrideBackbutton", [true]);
+ }
+
+ // If subscribing to an event that is handled by a plugin
+ else if (typeof PhoneGap.documentEventHandler[e] !== "undefined") {
+ if (PhoneGap.documentEventHandler[e](e, handler, true)) {
+ return; // Stop default behavior
+ }
+ }
+
+ PhoneGap.m_document_addEventListener.call(document, evt, handler, capture);
+ }
+};
+
+/**
+ * Intercept adding window event listeners and handle our own
+ *
+ * @param {Object} evt
+ * @param {Function} handler
+ * @param capture
+ */
+window.addEventListener = function(evt, handler, capture) {
+ var e = evt.toLowerCase();
+
+ // If subscribing to an event that is handled by a plugin
+ if (typeof PhoneGap.windowEventHandler[e] !== "undefined") {
+ if (PhoneGap.windowEventHandler[e](e, handler, true)) {
+ return; // Stop default behavior
+ }
+ }
+
+ PhoneGap.m_window_addEventListener.call(window, evt, handler, capture);
+};
+
+// Intercept calls to document.removeEventListener and watch for events that
+// are generated by PhoneGap native code
+PhoneGap.m_document_removeEventListener = document.removeEventListener;
+
+// Intercept calls to window.removeEventListener
+PhoneGap.m_window_removeEventListener = window.removeEventListener;
+
+/**
+ * Intercept removing document event listeners and handle our own
+ *
+ * @param {Object} evt
+ * @param {Function} handler
+ * @param capture
+ */
+document.removeEventListener = function(evt, handler, capture) {
+ var e = evt.toLowerCase();
+
+ // If unsubscribing to Android backbutton
+ if (e === 'backbutton') {
+ PhoneGap.exec(null, null, "App", "overrideBackbutton", [false]);
+ }
+
+ // If unsubcribing from an event that is handled by a plugin
+ if (typeof PhoneGap.documentEventHandler[e] !== "undefined") {
+ if (PhoneGap.documentEventHandler[e](e, handler, false)) {
+ return; // Stop default behavior
+ }
+ }
+
+ PhoneGap.m_document_removeEventListener.call(document, evt, handler, capture);
+};
+
+/**
+ * Intercept removing window event listeners and handle our own
+ *
+ * @param {Object} evt
+ * @param {Function} handler
+ * @param capture
+ */
+window.removeEventListener = function(evt, handler, capture) {
+ var e = evt.toLowerCase();
+
+ // If unsubcribing from an event that is handled by a plugin
+ if (typeof PhoneGap.windowEventHandler[e] !== "undefined") {
+ if (PhoneGap.windowEventHandler[e](e, handler, false)) {
+ return; // Stop default behavior
+ }
+ }
+
+ PhoneGap.m_window_removeEventListener.call(window, evt, handler, capture);
+};
+
+/**
+ * Method to fire document event
+ *
+ * @param {String} type The event type to fire
+ * @param {Object} data Data to send with event
+ */
+PhoneGap.fireDocumentEvent = function(type, data) {
+ var e = document.createEvent('Events');
+ e.initEvent(type);
+ if (data) {
+ for (var i in data) {
+ e[i] = data[i];
+ }
+ }
+ document.dispatchEvent(e);
+};
+
+/**
+ * Method to fire window event
+ *
+ * @param {String} type The event type to fire
+ * @param {Object} data Data to send with event
+ */
+PhoneGap.fireWindowEvent = function(type, data) {
+ var e = document.createEvent('Events');
+ e.initEvent(type);
+ if (data) {
+ for (var i in data) {
+ e[i] = data[i];
+ }
+ }
+ window.dispatchEvent(e);
+};
+
+/**
+ * Does a deep clone of the object.
+ *
+ * @param obj
+ * @return {Object}
+ */
+PhoneGap.clone = function(obj) {
+ var i, retVal;
+ if(!obj) {
+ return obj;
+ }
+
+ if(obj instanceof Array){
+ retVal = [];
+ for(i = 0; i < obj.length; ++i){
+ retVal.push(PhoneGap.clone(obj[i]));
+ }
+ return retVal;
+ }
+
+ if (typeof obj === "function") {
+ return obj;
+ }
+
+ if(!(obj instanceof Object)){
+ return obj;
+ }
+
+ if (obj instanceof Date) {
+ return obj;
+ }
+
+ retVal = {};
+ for(i in obj){
+ if(!(i in retVal) || retVal[i] !== obj[i]) {
+ retVal[i] = PhoneGap.clone(obj[i]);
+ }
+ }
+ return retVal;
+};
+
+PhoneGap.callbackId = 0;
+PhoneGap.callbacks = {};
+PhoneGap.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
+ };
+
+
+/**
+ * Execute a PhoneGap command. It is up to the native side whether this action is synch or async.
+ * The native side can return:
+ * Synchronous: PluginResult object as a JSON string
+ * Asynchrounous: Empty string ""
+ * If async, the native side will PhoneGap.callbackSuccess or PhoneGap.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 Action to be run in PhoneGap
+ * @param {Array.} [args] Zero or more arguments to pass to the method
+ */
+PhoneGap.exec = function(success, fail, service, action, args) {
+ try {
+ var callbackId = service + PhoneGap.callbackId++;
+ if (success || fail) {
+ PhoneGap.callbacks[callbackId] = {success:success, fail:fail};
+ }
+
+ var r = prompt(JSON.stringify(args), "gap:"+JSON.stringify([service, action, callbackId, true]));
+
+ // If a result was returned
+ if (r.length > 0) {
+ eval("var v="+r+";");
+
+ // If status is OK, then return value back to caller
+ if (v.status === PhoneGap.callbackStatus.OK) {
+
+ // If there is a success callback, then call it now with
+ // returned value
+ if (success) {
+ try {
+ success(v.message);
+ } catch (e) {
+ console.log("Error in success callback: " + callbackId + " = " + e);
+ }
+
+ // Clear callback if not expecting any more results
+ if (!v.keepCallback) {
+ delete PhoneGap.callbacks[callbackId];
+ }
+ }
+ return v.message;
+ }
+
+ // If no result
+ else if (v.status === PhoneGap.callbackStatus.NO_RESULT) {
+
+ // Clear callback if not expecting any more results
+ if (!v.keepCallback) {
+ delete PhoneGap.callbacks[callbackId];
+ }
+ }
+
+ // If error, then display error
+ else {
+ console.log("Error: Status="+v.status+" Message="+v.message);
+
+ // If there is a fail callback, then call it now with returned value
+ if (fail) {
+ try {
+ fail(v.message);
+ }
+ catch (e1) {
+ console.log("Error in error callback: "+callbackId+" = "+e1);
+ }
+
+ // Clear callback if not expecting any more results
+ if (!v.keepCallback) {
+ delete PhoneGap.callbacks[callbackId];
+ }
+ }
+ return null;
+ }
+ }
+ } catch (e2) {
+ console.log("Error: "+e2);
+ }
+};
+
+/**
+ * Called by native code when returning successful result from an action.
+ *
+ * @param callbackId
+ * @param args
+ */
+PhoneGap.callbackSuccess = function(callbackId, args) {
+ if (PhoneGap.callbacks[callbackId]) {
+
+ // If result is to be sent to callback
+ if (args.status === PhoneGap.callbackStatus.OK) {
+ try {
+ if (PhoneGap.callbacks[callbackId].success) {
+ PhoneGap.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 PhoneGap.callbacks[callbackId];
+ }
+ }
+};
+
+/**
+ * Called by native code when returning error result from an action.
+ *
+ * @param callbackId
+ * @param args
+ */
+PhoneGap.callbackError = function(callbackId, args) {
+ if (PhoneGap.callbacks[callbackId]) {
+ try {
+ if (PhoneGap.callbacks[callbackId].fail) {
+ PhoneGap.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 PhoneGap.callbacks[callbackId];
+ }
+ }
+};
+
+PhoneGap.JSCallbackPort = null;
+PhoneGap.JSCallbackToken = null;
+
+/**
+ * This is only for Android.
+ *
+ * Internal function that uses XHR to call into PhoneGap Java code and retrieve
+ * any JavaScript code that needs to be run. This is used for callbacks from
+ * Java to JavaScript.
+ */
+PhoneGap.JSCallback = function() {
+
+ // Exit if shutting down app
+ if (PhoneGap.shuttingDown) {
+ return;
+ }
+
+ // If polling flag was changed, start using polling from now on
+ if (PhoneGap.UsePolling) {
+ PhoneGap.JSCallbackPolling();
+ return;
+ }
+
+ var xmlhttp = new XMLHttpRequest();
+
+ // Callback function when XMLHttpRequest is ready
+ xmlhttp.onreadystatechange=function(){
+ if(xmlhttp.readyState === 4){
+
+ // Exit if shutting down app
+ if (PhoneGap.shuttingDown) {
+ return;
+ }
+
+ // If callback has JavaScript statement to execute
+ if (xmlhttp.status === 200) {
+
+ // Need to url decode the response
+ var msg = decodeURIComponent(xmlhttp.responseText);
+ setTimeout(function() {
+ try {
+ var t = eval(msg);
+ }
+ catch (e) {
+ // If we're getting an error here, seeing the message will help in debugging
+ console.log("JSCallback: Message from Server: " + msg);
+ console.log("JSCallback Error: "+e);
+ }
+ }, 1);
+ setTimeout(PhoneGap.JSCallback, 1);
+ }
+
+ // If callback ping (used to keep XHR request from timing out)
+ else if (xmlhttp.status === 404) {
+ setTimeout(PhoneGap.JSCallback, 10);
+ }
+
+ // If security error
+ else if (xmlhttp.status === 403) {
+ console.log("JSCallback Error: Invalid token. Stopping callbacks.");
+ }
+
+ // If server is stopping
+ else if (xmlhttp.status === 503) {
+ console.log("JSCallback Server Closed: Stopping callbacks.");
+ }
+
+ // If request wasn't GET
+ else if (xmlhttp.status === 400) {
+ console.log("JSCallback Error: Bad request. Stopping callbacks.");
+ }
+
+ // If error, revert to polling
+ else {
+ console.log("JSCallback Error: Request failed.");
+ PhoneGap.UsePolling = true;
+ PhoneGap.JSCallbackPolling();
+ }
+ }
+ };
+
+ if (PhoneGap.JSCallbackPort === null) {
+ PhoneGap.JSCallbackPort = prompt("getPort", "gap_callbackServer:");
+ }
+ if (PhoneGap.JSCallbackToken === null) {
+ PhoneGap.JSCallbackToken = prompt("getToken", "gap_callbackServer:");
+ }
+ xmlhttp.open("GET", "http://127.0.0.1:"+PhoneGap.JSCallbackPort+"/"+PhoneGap.JSCallbackToken , true);
+ xmlhttp.send();
+};
+
+/**
+ * The polling period to use with JSCallbackPolling.
+ * This can be changed by the application. The default is 50ms.
+ */
+PhoneGap.JSCallbackPollingPeriod = 50;
+
+/**
+ * Flag that can be set by the user to force polling to be used or force XHR to be used.
+ */
+PhoneGap.UsePolling = false; // T=use polling, F=use XHR
+
+/**
+ * This is only for Android.
+ *
+ * Internal function that uses polling to call into PhoneGap Java code and retrieve
+ * any JavaScript code that needs to be run. This is used for callbacks from
+ * Java to JavaScript.
+ */
+PhoneGap.JSCallbackPolling = function() {
+
+ // Exit if shutting down app
+ if (PhoneGap.shuttingDown) {
+ return;
+ }
+
+ // If polling flag was changed, stop using polling from now on
+ if (!PhoneGap.UsePolling) {
+ PhoneGap.JSCallback();
+ return;
+ }
+
+ var msg = prompt("", "gap_poll:");
+ if (msg) {
+ setTimeout(function() {
+ try {
+ var t = eval(""+msg);
+ }
+ catch (e) {
+ console.log("JSCallbackPolling: Message from Server: " + msg);
+ console.log("JSCallbackPolling Error: "+e);
+ }
+ }, 1);
+ setTimeout(PhoneGap.JSCallbackPolling, 1);
+ }
+ else {
+ setTimeout(PhoneGap.JSCallbackPolling, PhoneGap.JSCallbackPollingPeriod);
+ }
+};
+
+/**
+ * Create a UUID
+ *
+ * @return {String}
+ */
+PhoneGap.createUUID = function() {
+ return PhoneGap.UUIDcreatePart(4) + '-' +
+ PhoneGap.UUIDcreatePart(2) + '-' +
+ PhoneGap.UUIDcreatePart(2) + '-' +
+ PhoneGap.UUIDcreatePart(2) + '-' +
+ PhoneGap.UUIDcreatePart(6);
+};
+
+PhoneGap.UUIDcreatePart = function(length) {
+ var uuidpart = "";
+ var i, uuidchar;
+ for (i=0; i frequency + 10 sec
+ PhoneGap.exec(
+ function(timeout) {
+ if (timeout < (frequency + 10000)) {
+ PhoneGap.exec(null, null, "Accelerometer", "setTimeout", [frequency + 10000]);
+ }
+ },
+ function(e) { }, "Accelerometer", "getTimeout", []);
+
+ // Start watch timer
+ var id = PhoneGap.createUUID();
+ navigator.accelerometer.timers[id] = setInterval(function() {
+ PhoneGap.exec(successCallback, errorCallback, "Accelerometer", "getAcceleration", []);
+ }, (frequency ? frequency : 1));
+
+ return 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 && navigator.accelerometer.timers[id] !== undefined) {
+ clearInterval(navigator.accelerometer.timers[id]);
+ delete navigator.accelerometer.timers[id];
+ }
+};
+
+PhoneGap.addConstructor(function() {
+ if (typeof navigator.accelerometer === "undefined") {
+ navigator.accelerometer = new Accelerometer();
+ }
+});
+}
+/*
+ * 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.
+ */
+
+if (!PhoneGap.hasResource("app")) {
+PhoneGap.addResource("app");
+(function() {
+
+/**
+ * Constructor
+ * @constructor
+ */
+var App = function() {};
+
+/**
+ * Clear the resource cache.
+ */
+App.prototype.clearCache = function() {
+ PhoneGap.exec(null, null, "App", "clearCache", []);
+};
+
+/**
+ * Load the url into the webview or into new browser instance.
+ *
+ * @param url The URL to load
+ * @param props Properties that can be passed in to the activity:
+ * wait: int => wait msec before loading URL
+ * loadingDialog: "Title,Message" => display a native loading dialog
+ * loadUrlTimeoutValue: int => time in msec to wait before triggering a timeout error
+ * clearHistory: boolean => clear webview history (default=false)
+ * openExternal: boolean => open in a new browser (default=false)
+ *
+ * Example:
+ * navigator.app.loadUrl("http://server/myapp/index.html", {wait:2000, loadingDialog:"Wait,Loading App", loadUrlTimeoutValue: 60000});
+ */
+App.prototype.loadUrl = function(url, props) {
+ PhoneGap.exec(null, null, "App", "loadUrl", [url, props]);
+};
+
+/**
+ * Cancel loadUrl that is waiting to be loaded.
+ */
+App.prototype.cancelLoadUrl = function() {
+ PhoneGap.exec(null, null, "App", "cancelLoadUrl", []);
+};
+
+/**
+ * Clear web history in this web view.
+ * Instead of BACK button loading the previous web page, it will exit the app.
+ */
+App.prototype.clearHistory = function() {
+ PhoneGap.exec(null, null, "App", "clearHistory", []);
+};
+
+/**
+ * Go to previous page displayed.
+ * This is the same as pressing the backbutton on Android device.
+ */
+App.prototype.backHistory = function() {
+ PhoneGap.exec(null, null, "App", "backHistory", []);
+};
+
+/**
+ * Override the default behavior of the Android back button.
+ * If overridden, when the back button is pressed, the "backKeyDown" JavaScript event will be fired.
+ *
+ * Note: The user should not have to call this method. Instead, when the user
+ * registers for the "backbutton" event, this is automatically done.
+ *
+ * @param override T=override, F=cancel override
+ */
+App.prototype.overrideBackbutton = function(override) {
+ PhoneGap.exec(null, null, "App", "overrideBackbutton", [override]);
+};
+
+/**
+ * Exit and terminate the application.
+ */
+App.prototype.exitApp = function() {
+ return PhoneGap.exec(null, null, "App", "exitApp", []);
+};
+
+PhoneGap.addConstructor(function() {
+ navigator.app = new App();
+});
+}());
+}
+/*
+ * 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.
+ */
+
+if (!PhoneGap.hasResource("battery")) {
+PhoneGap.addResource("battery");
+
+/**
+ * This class contains information about the current battery status.
+ * @constructor
+ */
+var Battery = function() {
+ this._level = null;
+ this._isPlugged = null;
+ this._batteryListener = [];
+ this._lowListener = [];
+ this._criticalListener = [];
+};
+
+/**
+ * Registers as an event producer for battery events.
+ *
+ * @param {Object} eventType
+ * @param {Object} handler
+ * @param {Object} add
+ */
+Battery.prototype.eventHandler = function(eventType, handler, add) {
+ var me = navigator.battery;
+ if (add) {
+ // If there are no current registered event listeners start the battery listener on native side.
+ if (me._batteryListener.length === 0 && me._lowListener.length === 0 && me._criticalListener.length === 0) {
+ PhoneGap.exec(me._status, me._error, "Battery", "start", []);
+ }
+
+ // Register the event listener in the proper array
+ if (eventType === "batterystatus") {
+ if (me._batteryListener.indexOf(handler) === -1) {
+ me._batteryListener.push(handler);
+ }
+ } else if (eventType === "batterylow") {
+ if (me._lowListener.indexOf(handler) === -1) {
+ me._lowListener.push(handler);
+ }
+ } else if (eventType === "batterycritical") {
+ if (me._criticalListener.indexOf(handler) === -1) {
+ me._criticalListener.push(handler);
+ }
+ }
+ } else {
+ var pos = -1;
+ // Remove the event listener from the proper array
+ if (eventType === "batterystatus") {
+ pos = me._batteryListener.indexOf(handler);
+ if (pos > -1) {
+ me._batteryListener.splice(pos, 1);
+ }
+ } else if (eventType === "batterylow") {
+ pos = me._lowListener.indexOf(handler);
+ if (pos > -1) {
+ me._lowListener.splice(pos, 1);
+ }
+ } else if (eventType === "batterycritical") {
+ pos = me._criticalListener.indexOf(handler);
+ if (pos > -1) {
+ me._criticalListener.splice(pos, 1);
+ }
+ }
+
+ // If there are no more registered event listeners stop the battery listener on native side.
+ if (me._batteryListener.length === 0 && me._lowListener.length === 0 && me._criticalListener.length === 0) {
+ PhoneGap.exec(null, null, "Battery", "stop", []);
+ }
+ }
+};
+
+/**
+ * Callback for battery status
+ *
+ * @param {Object} info keys: level, isPlugged
+ */
+Battery.prototype._status = function(info) {
+ if (info) {
+ var me = this;
+ var level = info.level;
+ if (me._level !== level || me._isPlugged !== info.isPlugged) {
+ // Fire batterystatus event
+ PhoneGap.fireWindowEvent("batterystatus", info);
+
+ // Fire low battery event
+ if (level === 20 || level === 5) {
+ if (level === 20) {
+ PhoneGap.fireWindowEvent("batterylow", info);
+ }
+ else {
+ PhoneGap.fireWindowEvent("batterycritical", info);
+ }
+ }
+ }
+ me._level = level;
+ me._isPlugged = info.isPlugged;
+ }
+};
+
+/**
+ * Error callback for battery start
+ */
+Battery.prototype._error = function(e) {
+ console.log("Error initializing Battery: " + e);
+};
+
+PhoneGap.addConstructor(function() {
+ if (typeof navigator.battery === "undefined") {
+ navigator.battery = new Battery();
+ PhoneGap.addWindowEventHandler("batterystatus", navigator.battery.eventHandler);
+ PhoneGap.addWindowEventHandler("batterylow", navigator.battery.eventHandler);
+ PhoneGap.addWindowEventHandler("batterycritical", navigator.battery.eventHandler);
+ }
+});
+}
+/*
+ * 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.
+ */
+
+if (!PhoneGap.hasResource("camera")) {
+PhoneGap.addResource("camera");
+
+/**
+ * This class provides access to the device camera.
+ *
+ * @constructor
+ */
+var Camera = function() {
+ this.successCallback = null;
+ this.errorCallback = null;
+ 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 (content://media/external/images/media/2 for Android)
+};
+Camera.prototype.DestinationType = Camera.DestinationType;
+
+/**
+ * Encoding of image returned from getPicture.
+ *
+ * Example: navigator.camera.getPicture(success, fail,
+ * { quality: 80,
+ * destinationType: Camera.DestinationType.DATA_URL,
+ * sourceType: Camera.PictureSourceType.CAMERA,
+ * encodingType: Camera.EncodingType.PNG})
+*/
+Camera.EncodingType = {
+ JPEG: 0, // Return JPEG encoded image
+ PNG: 1 // Return PNG encoded image
+};
+Camera.prototype.EncodingType = Camera.EncodingType;
+
+/**
+ * Type of pictures to select from. Only applicable when
+ * PictureSourceType is PHOTOLIBRARY or SAVEDPHOTOALBUM
+ *
+ * Example: navigator.camera.getPicture(success, fail,
+ * { quality: 80,
+ * destinationType: Camera.DestinationType.DATA_URL,
+ * sourceType: Camera.PictureSourceType.PHOTOLIBRARY,
+ * mediaType: Camera.MediaType.PICTURE})
+ */
+Camera.MediaType = {
+ PICTURE: 0, // allow selection of still pictures only. DEFAULT. Will return format specified via DestinationType
+ VIDEO: 1, // allow selection of video only, ONLY RETURNS URL
+ ALLMEDIA : 2 // allow selection from all media types
+};
+Camera.prototype.MediaType = Camera.MediaType;
+
+
+/**
+ * Source to getPicture from.
+ *
+ * Example: navigator.camera.getPicture(success, fail,
+ * { quality: 80,
+ * destinationType: Camera.DestinationType.DATA_URL,
+ * sourceType: Camera.PictureSourceType.PHOTOLIBRARY})
+ */
+Camera.PictureSourceType = {
+ PHOTOLIBRARY : 0, // Choose image from picture library (same as SAVEDPHOTOALBUM for Android)
+ CAMERA : 1, // Take picture from camera
+ SAVEDPHOTOALBUM : 2 // Choose image from picture library (same as PHOTOLIBRARY for Android)
+};
+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;
+ }
+
+ if (options === null || typeof options === "undefined") {
+ options = {};
+ }
+ if (options.quality === null || typeof options.quality === "undefined") {
+ options.quality = 80;
+ }
+ if (options.maxResolution === null || typeof options.maxResolution === "undefined") {
+ options.maxResolution = 0;
+ }
+ if (options.destinationType === null || typeof options.destinationType === "undefined") {
+ options.destinationType = Camera.DestinationType.FILE_URI;
+ }
+ if (options.sourceType === null || typeof options.sourceType === "undefined") {
+ options.sourceType = Camera.PictureSourceType.CAMERA;
+ }
+ if (options.encodingType === null || typeof options.encodingType === "undefined") {
+ options.encodingType = Camera.EncodingType.JPEG;
+ }
+ if (options.mediaType === null || typeof options.mediaType === "undefined") {
+ options.mediaType = Camera.MediaType.PICTURE;
+ }
+ if (options.targetWidth === null || typeof options.targetWidth === "undefined") {
+ options.targetWidth = -1;
+ }
+ else if (typeof options.targetWidth === "string") {
+ var width = new Number(options.targetWidth);
+ if (isNaN(width) === false) {
+ options.targetWidth = width.valueOf();
+ }
+ }
+ if (options.targetHeight === null || typeof options.targetHeight === "undefined") {
+ options.targetHeight = -1;
+ }
+ else if (typeof options.targetHeight === "string") {
+ var height = new Number(options.targetHeight);
+ if (isNaN(height) === false) {
+ options.targetHeight = height.valueOf();
+ }
+ }
+
+ PhoneGap.exec(successCallback, errorCallback, "Camera", "takePicture", [options]);
+};
+
+PhoneGap.addConstructor(function() {
+ if (typeof navigator.camera === "undefined") {
+ navigator.camera = new Camera();
+ }
+});
+}
+/*
+ * 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.
+ */
+
+if (!PhoneGap.hasResource("capture")) {
+PhoneGap.addResource("capture");
+
+/**
+ * Represents a single file.
+ *
+ * name {DOMString} name of the file, without path information
+ * fullPath {DOMString} the full path of the file, including the name
+ * type {DOMString} mime type
+ * lastModifiedDate {Date} last modified date
+ * size {Number} size of the file in bytes
+ */
+var MediaFile = function(name, fullPath, type, lastModifiedDate, size){
+ this.name = name || null;
+ this.fullPath = fullPath || null;
+ this.type = type || null;
+ this.lastModifiedDate = lastModifiedDate || null;
+ this.size = size || 0;
+};
+
+/**
+ * Launch device camera application for recording video(s).
+ *
+ * @param {Function} successCB
+ * @param {Function} errorCB
+ */
+MediaFile.prototype.getFormatData = function(successCallback, errorCallback){
+ PhoneGap.exec(successCallback, errorCallback, "Capture", "getFormatData", [this.fullPath, this.type]);
+};
+
+/**
+ * MediaFileData encapsulates format information of a media file.
+ *
+ * @param {DOMString} codecs
+ * @param {long} bitrate
+ * @param {long} height
+ * @param {long} width
+ * @param {float} duration
+ */
+var MediaFileData = function(codecs, bitrate, height, width, duration){
+ this.codecs = codecs || null;
+ this.bitrate = bitrate || 0;
+ this.height = height || 0;
+ this.width = width || 0;
+ this.duration = duration || 0;
+};
+
+/**
+ * The CaptureError interface encapsulates all errors in the Capture API.
+ */
+var CaptureError = function(){
+ this.code = null;
+};
+
+// Capture error codes
+CaptureError.CAPTURE_INTERNAL_ERR = 0;
+CaptureError.CAPTURE_APPLICATION_BUSY = 1;
+CaptureError.CAPTURE_INVALID_ARGUMENT = 2;
+CaptureError.CAPTURE_NO_MEDIA_FILES = 3;
+CaptureError.CAPTURE_NOT_SUPPORTED = 20;
+
+/**
+ * The Capture interface exposes an interface to the camera and microphone of the hosting device.
+ */
+var Capture = function(){
+ this.supportedAudioModes = [];
+ this.supportedImageModes = [];
+ this.supportedVideoModes = [];
+};
+
+/**
+ * Launch audio recorder application for recording audio clip(s).
+ *
+ * @param {Function} successCB
+ * @param {Function} errorCB
+ * @param {CaptureAudioOptions} options
+ */
+Capture.prototype.captureAudio = function(successCallback, errorCallback, options){
+ PhoneGap.exec(successCallback, errorCallback, "Capture", "captureAudio", [options]);
+};
+
+/**
+ * Launch camera application for taking image(s).
+ *
+ * @param {Function} successCB
+ * @param {Function} errorCB
+ * @param {CaptureImageOptions} options
+ */
+Capture.prototype.captureImage = function(successCallback, errorCallback, options){
+ PhoneGap.exec(successCallback, errorCallback, "Capture", "captureImage", [options]);
+};
+
+/**
+ * Launch camera application for taking image(s).
+ *
+ * @param {Function} successCB
+ * @param {Function} errorCB
+ * @param {CaptureImageOptions} options
+ */
+Capture.prototype._castMediaFile = function(pluginResult){
+ var mediaFiles = [];
+ var i;
+ for (i = 0; i < pluginResult.message.length; i++) {
+ var mediaFile = new MediaFile();
+ mediaFile.name = pluginResult.message[i].name;
+ mediaFile.fullPath = pluginResult.message[i].fullPath;
+ mediaFile.type = pluginResult.message[i].type;
+ mediaFile.lastModifiedDate = pluginResult.message[i].lastModifiedDate;
+ mediaFile.size = pluginResult.message[i].size;
+ mediaFiles.push(mediaFile);
+ }
+ pluginResult.message = mediaFiles;
+ return pluginResult;
+};
+
+/**
+ * Launch device camera application for recording video(s).
+ *
+ * @param {Function} successCB
+ * @param {Function} errorCB
+ * @param {CaptureVideoOptions} options
+ */
+Capture.prototype.captureVideo = function(successCallback, errorCallback, options){
+ PhoneGap.exec(successCallback, errorCallback, "Capture", "captureVideo", [options]);
+};
+
+/**
+ * Encapsulates a set of parameters that the capture device supports.
+ */
+var ConfigurationData = function(){
+ // The ASCII-encoded string in lower case representing the media type.
+ this.type = null;
+ // The height attribute represents height of the image or video in pixels.
+ // In the case of a sound clip this attribute has value 0.
+ this.height = 0;
+ // The width attribute represents width of the image or video in pixels.
+ // In the case of a sound clip this attribute has value 0
+ this.width = 0;
+};
+
+/**
+ * Encapsulates all image capture operation configuration options.
+ */
+var CaptureImageOptions = function(){
+ // Upper limit of images user can take. Value must be equal or greater than 1.
+ this.limit = 1;
+ // The selected image mode. Must match with one of the elements in supportedImageModes array.
+ this.mode = null;
+};
+
+/**
+ * Encapsulates all video capture operation configuration options.
+ */
+var CaptureVideoOptions = function(){
+ // Upper limit of videos user can record. Value must be equal or greater than 1.
+ this.limit = 1;
+ // Maximum duration of a single video clip in seconds.
+ this.duration = 0;
+ // The selected video mode. Must match with one of the elements in supportedVideoModes array.
+ this.mode = null;
+};
+
+/**
+ * Encapsulates all audio capture operation configuration options.
+ */
+var CaptureAudioOptions = function(){
+ // Upper limit of sound clips user can record. Value must be equal or greater than 1.
+ this.limit = 1;
+ // Maximum duration of a single sound clip in seconds.
+ this.duration = 0;
+ // The selected audio mode. Must match with one of the elements in supportedAudioModes array.
+ this.mode = null;
+};
+
+PhoneGap.addConstructor(function(){
+ if (typeof navigator.device.capture === "undefined") {
+ navigator.device.capture = window.device.capture = new Capture();
+ }
+});
+}
+/*
+ * 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.
+ */
+
+if (!PhoneGap.hasResource("compass")) {
+PhoneGap.addResource("compass");
+
+var CompassError = function(){
+ this.code = null;
+};
+
+// Capture error codes
+CompassError.COMPASS_INTERNAL_ERR = 0;
+CompassError.COMPASS_NOT_SUPPORTED = 20;
+
+var CompassHeading = function() {
+ this.magneticHeading = null;
+ this.trueHeading = null;
+ this.headingAccuracy = null;
+ this.timestamp = null;
+};
+
+/**
+ * This class provides access to device Compass data.
+ * @constructor
+ */
+var Compass = function() {
+ /**
+ * The last known Compass position.
+ */
+ this.lastHeading = null;
+
+ /**
+ * List of compass watch timers
+ */
+ this.timers = {};
+};
+
+Compass.ERROR_MSG = ["Not running", "Starting", "", "Failed to start"];
+
+/**
+ * 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. (OPTIONAL)
+ * @param {PositionOptions} options The options for getting the heading data such as timeout. (OPTIONAL)
+ */
+Compass.prototype.getCurrentHeading = function(successCallback, errorCallback, options) {
+
+ // successCallback required
+ if (typeof successCallback !== "function") {
+ console.log("Compass Error: successCallback is not a function");
+ return;
+ }
+
+ // errorCallback optional
+ if (errorCallback && (typeof errorCallback !== "function")) {
+ console.log("Compass Error: errorCallback is not a function");
+ return;
+ }
+
+ // Get heading
+ PhoneGap.exec(successCallback, errorCallback, "Compass", "getHeading", []);
+};
+
+/**
+ * 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. (OPTIONAL)
+ * @param {HeadingOptions} options The options for getting the heading data such as timeout and the frequency of the watch. (OPTIONAL)
+ * @return String The watch id that must be passed to #clearWatch to stop watching.
+ */
+Compass.prototype.watchHeading= function(successCallback, errorCallback, options) {
+
+ // Default interval (100 msec)
+ var frequency = (options !== undefined) ? options.frequency : 100;
+
+ // successCallback required
+ if (typeof successCallback !== "function") {
+ console.log("Compass Error: successCallback is not a function");
+ return;
+ }
+
+ // errorCallback optional
+ if (errorCallback && (typeof errorCallback !== "function")) {
+ console.log("Compass Error: errorCallback is not a function");
+ return;
+ }
+
+ // Make sure compass timeout > frequency + 10 sec
+ PhoneGap.exec(
+ function(timeout) {
+ if (timeout < (frequency + 10000)) {
+ PhoneGap.exec(null, null, "Compass", "setTimeout", [frequency + 10000]);
+ }
+ },
+ function(e) { }, "Compass", "getTimeout", []);
+
+ // Start watch timer to get headings
+ var id = PhoneGap.createUUID();
+ navigator.compass.timers[id] = setInterval(
+ function() {
+ PhoneGap.exec(successCallback, errorCallback, "Compass", "getHeading", []);
+ }, (frequency ? frequency : 1));
+
+ return id;
+};
+
+
+/**
+ * Clears the specified heading watch.
+ *
+ * @param {String} id The ID of the watch returned from #watchHeading.
+ */
+Compass.prototype.clearWatch = function(id) {
+
+ // Stop javascript timer & remove from timer list
+ if (id && navigator.compass.timers[id]) {
+ clearInterval(navigator.compass.timers[id]);
+ delete navigator.compass.timers[id];
+ }
+};
+
+Compass.prototype._castDate = function(pluginResult) {
+ if (pluginResult.message.timestamp) {
+ var timestamp = new Date(pluginResult.message.timestamp);
+ pluginResult.message.timestamp = timestamp;
+ }
+ return pluginResult;
+};
+
+PhoneGap.addConstructor(function() {
+ if (typeof navigator.compass === "undefined") {
+ navigator.compass = new Compass();
+ }
+});
+}
+/*
+ * 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.
+ */
+
+if (!PhoneGap.hasResource("contact")) {
+PhoneGap.addResource("contact");
+
+/**
+* Contains information about a single contact.
+* @constructor
+* @param {DOMString} id unique identifier
+* @param {DOMString} displayName
+* @param {ContactName} name
+* @param {DOMString} nickname
+* @param {Array.} phoneNumbers array of phone numbers
+* @param {Array.} emails array of email addresses
+* @param {Array.} addresses array of addresses
+* @param {Array.} ims instant messaging user ids
+* @param {Array.} organizations
+* @param {DOMString} birthday contact's birthday
+* @param {DOMString} note user notes about contact
+* @param {Array.} photos
+* @param {Array.} categories
+* @param {Array.} urls contact's web sites
+*/
+var Contact = function (id, displayName, name, nickname, phoneNumbers, emails, addresses,
+ ims, organizations, birthday, note, photos, categories, urls) {
+ this.id = id || null;
+ this.rawId = 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.birthday = birthday || null;
+ this.note = note || null;
+ this.photos = photos || null; // ContactField[]
+ this.categories = categories || null; // ContactField[]
+ this.urls = urls || null; // ContactField[]
+};
+
+/**
+ * ContactError.
+ * An error code assigned by an implementation when an error has occurreds
+ * @constructor
+ */
+var ContactError = function() {
+ this.code=null;
+};
+
+/**
+ * Error codes
+ */
+ContactError.UNKNOWN_ERROR = 0;
+ContactError.INVALID_ARGUMENT_ERROR = 1;
+ContactError.TIMEOUT_ERROR = 2;
+ContactError.PENDING_OPERATION_ERROR = 3;
+ContactError.IO_ERROR = 4;
+ContactError.NOT_SUPPORTED_ERROR = 5;
+ContactError.PERMISSION_DENIED_ERROR = 20;
+
+/**
+* Removes contact from device storage.
+* @param successCB success callback
+* @param errorCB error callback
+*/
+Contact.prototype.remove = function(successCB, errorCB) {
+ if (this.id === null) {
+ var errorObj = new ContactError();
+ errorObj.code = ContactError.UNKNOWN_ERROR;
+ errorCB(errorObj);
+ }
+ else {
+ PhoneGap.exec(successCB, errorCB, "Contacts", "remove", [this.id]);
+ }
+};
+
+/**
+* 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 = PhoneGap.clone(this);
+ var i;
+ clonedContact.id = null;
+ clonedContact.rawId = 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.tags) {
+ for (i = 0; i < clonedContact.tags.length; i++) {
+ clonedContact.tags[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
+*/
+Contact.prototype.save = function(successCB, errorCB) {
+ PhoneGap.exec(successCB, errorCB, "Contacts", "save", [this]);
+};
+
+/**
+* Contact name.
+* @constructor
+* @param formatted
+* @param familyName
+* @param givenName
+* @param middle
+* @param prefix
+* @param suffix
+*/
+var ContactName = function(formatted, familyName, givenName, middle, prefix, suffix) {
+ this.formatted = formatted || null;
+ this.familyName = familyName || null;
+ this.givenName = givenName || null;
+ this.middleName = middle || null;
+ this.honorificPrefix = prefix || null;
+ this.honorificSuffix = suffix || null;
+};
+
+/**
+* Generic contact field.
+* @constructor
+* @param {DOMString} id unique identifier, should only be set by native code
+* @param type
+* @param value
+* @param pref
+*/
+var ContactField = function(type, value, pref) {
+ this.id = null;
+ this.type = type || null;
+ this.value = value || null;
+ this.pref = pref || null;
+};
+
+/**
+* Contact address.
+* @constructor
+* @param {DOMString} id unique identifier, should only be set by native code
+* @param formatted
+* @param streetAddress
+* @param locality
+* @param region
+* @param postalCode
+* @param country
+*/
+var ContactAddress = function(pref, type, formatted, streetAddress, locality, region, postalCode, country) {
+ this.id = null;
+ this.pref = pref || null;
+ this.type = type || null;
+ this.formatted = formatted || null;
+ this.streetAddress = streetAddress || null;
+ this.locality = locality || null;
+ this.region = region || null;
+ this.postalCode = postalCode || null;
+ this.country = country || null;
+};
+
+/**
+* Contact organization.
+* @constructor
+* @param {DOMString} id unique identifier, should only be set by native code
+* @param name
+* @param dept
+* @param title
+* @param startDate
+* @param endDate
+* @param location
+* @param desc
+*/
+var ContactOrganization = function(pref, type, name, dept, title) {
+ this.id = null;
+ this.pref = pref || null;
+ this.type = type || null;
+ this.name = name || null;
+ this.department = dept || null;
+ this.title = title || null;
+};
+
+/**
+* Represents a group of Contacts.
+* @constructor
+*/
+var Contacts = function() {
+ this.inProgress = false;
+ this.records = [];
+};
+/**
+* Returns an array of Contacts matching the search criteria.
+* @param fields that should be searched
+* @param successCB success callback
+* @param errorCB error callback
+* @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) {
+ if (successCB === null) {
+ throw new TypeError("You must specify a success callback for the find command.");
+ }
+ if (fields === null || fields === "undefined" || fields.length === "undefined" || fields.length <= 0) {
+ if (typeof errorCB === "function") {
+ errorCB({"code": ContactError.INVALID_ARGUMENT_ERROR});
+ }
+ } else {
+ PhoneGap.exec(successCB, errorCB, "Contacts", "search", [fields, 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 i;
+ var contact = new Contact();
+ for (i in properties) {
+ if (contact[i] !== 'undefined') {
+ contact[i] = properties[i];
+ }
+ }
+ return contact;
+};
+
+/**
+* This function returns and array of contacts. It is required as we need to convert raw
+* JSON objects into concrete Contact objects. Currently this method is called after
+* navigator.contacts.find but before the find methods success call back.
+*
+* @param jsonArray an array of JSON Objects that need to be converted to Contact objects.
+* @returns an array of Contact objects
+*/
+Contacts.prototype.cast = function(pluginResult) {
+ var contacts = [];
+ var i;
+ for (i=0; i][;base64],
+ *
+ * @param file {File} File object containing file properties
+ */
+FileReader.prototype.readAsDataURL = function(file) {
+ this.fileName = "";
+ if (typeof file.fullPath === "undefined") {
+ this.fileName = file;
+ } else {
+ this.fileName = file.fullPath;
+ }
+
+ // LOADING state
+ this.readyState = FileReader.LOADING;
+
+ // If loadstart callback
+ if (typeof this.onloadstart === "function") {
+ this.onloadstart({"type":"loadstart", "target":this});
+ }
+
+ var me = this;
+
+ // Read file
+ PhoneGap.exec(
+ // Success callback
+ function(r) {
+ var evt;
+
+ // If DONE (cancelled), then don't do anything
+ if (me.readyState === FileReader.DONE) {
+ return;
+ }
+
+ // Save result
+ me.result = r;
+
+ // If onload callback
+ if (typeof me.onload === "function") {
+ me.onload({"type":"load", "target":me});
+ }
+
+ // DONE state
+ me.readyState = FileReader.DONE;
+
+ // If onloadend callback
+ if (typeof me.onloadend === "function") {
+ me.onloadend({"type":"loadend", "target":me});
+ }
+ },
+ // Error callback
+ function(e) {
+ var evt;
+ // If DONE (cancelled), then don't do anything
+ if (me.readyState === FileReader.DONE) {
+ return;
+ }
+
+ // Save error
+ me.error = e;
+
+ // If onerror callback
+ if (typeof me.onerror === "function") {
+ me.onerror({"type":"error", "target":me});
+ }
+
+ // DONE state
+ me.readyState = FileReader.DONE;
+
+ // If onloadend callback
+ if (typeof me.onloadend === "function") {
+ me.onloadend({"type":"loadend", "target":me});
+ }
+ }, "File", "readAsDataURL", [this.fileName]);
+};
+
+/**
+ * Read file and return data as a binary data.
+ *
+ * @param file {File} File object containing file properties
+ */
+FileReader.prototype.readAsBinaryString = function(file) {
+ // TODO - Can't return binary data to browser.
+ this.fileName = file;
+};
+
+/**
+ * Read file and return data as a binary data.
+ *
+ * @param file {File} File object containing file properties
+ */
+FileReader.prototype.readAsArrayBuffer = function(file) {
+ // TODO - Can't return binary data to browser.
+ this.fileName = file;
+};
+
+//-----------------------------------------------------------------------------
+// File Writer
+//-----------------------------------------------------------------------------
+
+/**
+ * This class writes to the mobile device file system.
+ *
+ * For Android:
+ * The root directory is the root of the file system.
+ * To write to the SD card, the file name is "sdcard/my_file.txt"
+ *
+ * @constructor
+ * @param file {File} File object containing file properties
+ * @param append if true write to the end of the file, otherwise overwrite the file
+ */
+var FileWriter = function(file) {
+ this.fileName = "";
+ this.length = 0;
+ if (file) {
+ this.fileName = file.fullPath || file;
+ this.length = file.size || 0;
+ }
+ // default is to write at the beginning of the file
+ this.position = 0;
+
+ this.readyState = 0; // EMPTY
+
+ this.result = null;
+
+ // 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() {
+ // check for invalid state
+ if (this.readyState === FileWriter.DONE || this.readyState === FileWriter.INIT) {
+ throw FileError.INVALID_STATE_ERR;
+ }
+
+ // set error
+ var error = new FileError(), evt;
+ error.code = error.ABORT_ERR;
+ this.error = error;
+
+ // If error callback
+ if (typeof this.onerror === "function") {
+ this.onerror({"type":"error", "target":this});
+ }
+ // If abort callback
+ if (typeof this.onabort === "function") {
+ this.onabort({"type":"abort", "target":this});
+ }
+
+ this.readyState = FileWriter.DONE;
+
+ // If write end callback
+ if (typeof this.onwriteend === "function") {
+ this.onwriteend({"type":"writeend", "target":this});
+ }
+};
+
+/**
+ * Writes data to the file
+ *
+ * @param text to be written
+ */
+FileWriter.prototype.write = function(text) {
+ // 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;
+
+ var me = this;
+
+ // If onwritestart callback
+ if (typeof me.onwritestart === "function") {
+ me.onwritestart({"type":"writestart", "target":me});
+ }
+
+ // Write file
+ PhoneGap.exec(
+ // Success callback
+ function(r) {
+ var evt;
+ // If DONE (cancelled), then don't do anything
+ if (me.readyState === FileWriter.DONE) {
+ return;
+ }
+
+ // position always increases by bytes written because file would be extended
+ me.position += r;
+ // The length of the file is now where we are done writing.
+ me.length = me.position;
+
+ // If onwrite callback
+ if (typeof me.onwrite === "function") {
+ me.onwrite({"type":"write", "target":me});
+ }
+
+ // DONE state
+ me.readyState = FileWriter.DONE;
+
+ // If onwriteend callback
+ if (typeof me.onwriteend === "function") {
+ me.onwriteend({"type":"writeend", "target":me});
+ }
+ },
+ // Error callback
+ function(e) {
+ var evt;
+
+ // If DONE (cancelled), then don't do anything
+ if (me.readyState === FileWriter.DONE) {
+ return;
+ }
+
+ // Save error
+ me.error = e;
+
+ // If onerror callback
+ if (typeof me.onerror === "function") {
+ me.onerror({"type":"error", "target":me});
+ }
+
+ // DONE state
+ me.readyState = FileWriter.DONE;
+
+ // If onwriteend callback
+ if (typeof me.onwriteend === "function") {
+ me.onwriteend({"type":"writeend", "target":me});
+ }
+ }, "File", "write", [this.fileName, text, this.position]);
+};
+
+/**
+ * Moves the file pointer to the location specified.
+ *
+ * If the offset is a negative number the position of the file
+ * pointer is rewound. If the offset is greater than the file
+ * size the position is set to the end of the file.
+ *
+ * @param offset is the location to move the file pointer to.
+ */
+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;
+ }
+
+ // See back from end of file.
+ if (offset < 0) {
+ this.position = Math.max(offset + this.length, 0);
+ }
+ // Offset is bigger then file size so set position
+ // to the end of the file.
+ else if (offset > this.length) {
+ this.position = this.length;
+ }
+ // Offset is between 0 and file size so set the position
+ // to start writing.
+ else {
+ this.position = offset;
+ }
+};
+
+/**
+ * Truncates the file to the size specified.
+ *
+ * @param size to chop the file at.
+ */
+FileWriter.prototype.truncate = function(size) {
+ // 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;
+
+ var me = this;
+
+ // If onwritestart callback
+ if (typeof me.onwritestart === "function") {
+ me.onwritestart({"type":"writestart", "target":this});
+ }
+
+ // Write file
+ PhoneGap.exec(
+ // Success callback
+ function(r) {
+ var evt;
+ // If DONE (cancelled), then don't do anything
+ if (me.readyState === FileWriter.DONE) {
+ return;
+ }
+
+ // Update the length of the file
+ me.length = r;
+ me.position = Math.min(me.position, r);
+
+ // If onwrite callback
+ if (typeof me.onwrite === "function") {
+ me.onwrite({"type":"write", "target":me});
+ }
+
+ // DONE state
+ me.readyState = FileWriter.DONE;
+
+ // If onwriteend callback
+ if (typeof me.onwriteend === "function") {
+ me.onwriteend({"type":"writeend", "target":me});
+ }
+ },
+ // Error callback
+ function(e) {
+ var evt;
+ // If DONE (cancelled), then don't do anything
+ if (me.readyState === FileWriter.DONE) {
+ return;
+ }
+
+ // Save error
+ me.error = e;
+
+ // If onerror callback
+ if (typeof me.onerror === "function") {
+ me.onerror({"type":"error", "target":me});
+ }
+
+ // DONE state
+ me.readyState = FileWriter.DONE;
+
+ // If onwriteend callback
+ if (typeof me.onwriteend === "function") {
+ me.onwriteend({"type":"writeend", "target":me});
+ }
+ }, "File", "truncate", [this.fileName, size]);
+};
+
+/**
+ * Information about the state of the file or directory
+ *
+ * @constructor
+ * {Date} modificationTime (readonly)
+ */
+var Metadata = function() {
+ this.modificationTime=null;
+};
+
+/**
+ * Supplies arguments to methods that lookup or create files and directories
+ *
+ * @constructor
+ * @param {boolean} create file or directory if it doesn't exist
+ * @param {boolean} exclusive if true the command will fail if the file or directory exists
+ */
+var Flags = function(create, exclusive) {
+ this.create = create || false;
+ this.exclusive = exclusive || false;
+};
+
+/**
+ * An interface representing a file system
+ *
+ * @constructor
+ * {DOMString} name the unique name of the file system (readonly)
+ * {DirectoryEntry} root directory of the file system (readonly)
+ */
+var FileSystem = function() {
+ this.name = null;
+ this.root = null;
+};
+
+/**
+ * An interface that lists the files and directories in a directory.
+ * @constructor
+ */
+var DirectoryReader = function(fullPath){
+ this.fullPath = fullPath || null;
+};
+
+/**
+ * Returns a list of entries from a directory.
+ *
+ * @param {Function} successCallback is called with a list of entries
+ * @param {Function} errorCallback is called with a FileError
+ */
+DirectoryReader.prototype.readEntries = function(successCallback, errorCallback) {
+ PhoneGap.exec(successCallback, errorCallback, "File", "readEntries", [this.fullPath]);
+};
+
+/**
+ * An interface representing a directory on the file system.
+ *
+ * @constructor
+ * {boolean} isFile always false (readonly)
+ * {boolean} isDirectory always true (readonly)
+ * {DOMString} name of the directory, excluding the path leading to it (readonly)
+ * {DOMString} fullPath the absolute full path to the directory (readonly)
+ * {FileSystem} filesystem on which the directory resides (readonly)
+ */
+var DirectoryEntry = function() {
+ this.isFile = false;
+ this.isDirectory = true;
+ this.name = null;
+ this.fullPath = null;
+ this.filesystem = null;
+};
+
+/**
+ * Copies a directory to a new location
+ *
+ * @param {DirectoryEntry} parent the directory to which to copy the entry
+ * @param {DOMString} newName the new name of the entry, defaults to the current name
+ * @param {Function} successCallback is called with the new entry
+ * @param {Function} errorCallback is called with a FileError
+ */
+DirectoryEntry.prototype.copyTo = function(parent, newName, successCallback, errorCallback) {
+ PhoneGap.exec(successCallback, errorCallback, "File", "copyTo", [this.fullPath, parent, newName]);
+};
+
+/**
+ * Looks up the metadata of the entry
+ *
+ * @param {Function} successCallback is called with a Metadata object
+ * @param {Function} errorCallback is called with a FileError
+ */
+DirectoryEntry.prototype.getMetadata = function(successCallback, errorCallback) {
+ PhoneGap.exec(successCallback, errorCallback, "File", "getMetadata", [this.fullPath]);
+};
+
+/**
+ * Gets the parent of the entry
+ *
+ * @param {Function} successCallback is called with a parent entry
+ * @param {Function} errorCallback is called with a FileError
+ */
+DirectoryEntry.prototype.getParent = function(successCallback, errorCallback) {
+ PhoneGap.exec(successCallback, errorCallback, "File", "getParent", [this.fullPath]);
+};
+
+/**
+ * Moves a directory to a new location
+ *
+ * @param {DirectoryEntry} parent the directory to which to move the entry
+ * @param {DOMString} newName the new name of the entry, defaults to the current name
+ * @param {Function} successCallback is called with the new entry
+ * @param {Function} errorCallback is called with a FileError
+ */
+DirectoryEntry.prototype.moveTo = function(parent, newName, successCallback, errorCallback) {
+ PhoneGap.exec(successCallback, errorCallback, "File", "moveTo", [this.fullPath, parent, newName]);
+};
+
+/**
+ * Removes the entry
+ *
+ * @param {Function} successCallback is called with no parameters
+ * @param {Function} errorCallback is called with a FileError
+ */
+DirectoryEntry.prototype.remove = function(successCallback, errorCallback) {
+ PhoneGap.exec(successCallback, errorCallback, "File", "remove", [this.fullPath]);
+};
+
+/**
+ * Returns a URI that can be used to identify this entry.
+ *
+ * @param {DOMString} mimeType for a FileEntry, the mime type to be used to interpret the file, when loaded through this URI.
+ * @return uri
+ */
+DirectoryEntry.prototype.toURI = function(mimeType) {
+ return "file://" + this.fullPath;
+};
+
+/**
+ * Creates a new DirectoryReader to read entries from this directory
+ */
+DirectoryEntry.prototype.createReader = function(successCallback, errorCallback) {
+ return new DirectoryReader(this.fullPath);
+};
+
+/**
+ * Creates or looks up a directory
+ *
+ * @param {DOMString} path either a relative or absolute path from this directory in which to look up or create a directory
+ * @param {Flags} options to create or excluively create the directory
+ * @param {Function} successCallback is called with the new entry
+ * @param {Function} errorCallback is called with a FileError
+ */
+DirectoryEntry.prototype.getDirectory = function(path, options, successCallback, errorCallback) {
+ PhoneGap.exec(successCallback, errorCallback, "File", "getDirectory", [this.fullPath, path, options]);
+};
+
+/**
+ * Creates or looks up a file
+ *
+ * @param {DOMString} path either a relative or absolute path from this directory in which to look up or create a file
+ * @param {Flags} options to create or excluively create the file
+ * @param {Function} successCallback is called with the new entry
+ * @param {Function} errorCallback is called with a FileError
+ */
+DirectoryEntry.prototype.getFile = function(path, options, successCallback, errorCallback) {
+ PhoneGap.exec(successCallback, errorCallback, "File", "getFile", [this.fullPath, path, options]);
+};
+
+/**
+ * Deletes a directory and all of it's contents
+ *
+ * @param {Function} successCallback is called with no parameters
+ * @param {Function} errorCallback is called with a FileError
+ */
+DirectoryEntry.prototype.removeRecursively = function(successCallback, errorCallback) {
+ PhoneGap.exec(successCallback, errorCallback, "File", "removeRecursively", [this.fullPath]);
+};
+
+/**
+ * An interface representing a directory on the file system.
+ *
+ * @constructor
+ * {boolean} isFile always true (readonly)
+ * {boolean} isDirectory always false (readonly)
+ * {DOMString} name of the file, excluding the path leading to it (readonly)
+ * {DOMString} fullPath the absolute full path to the file (readonly)
+ * {FileSystem} filesystem on which the directory resides (readonly)
+ */
+var FileEntry = function() {
+ this.isFile = true;
+ this.isDirectory = false;
+ this.name = null;
+ this.fullPath = null;
+ this.filesystem = null;
+};
+
+/**
+ * Copies a file to a new location
+ *
+ * @param {DirectoryEntry} parent the directory to which to copy the entry
+ * @param {DOMString} newName the new name of the entry, defaults to the current name
+ * @param {Function} successCallback is called with the new entry
+ * @param {Function} errorCallback is called with a FileError
+ */
+FileEntry.prototype.copyTo = function(parent, newName, successCallback, errorCallback) {
+ PhoneGap.exec(successCallback, errorCallback, "File", "copyTo", [this.fullPath, parent, newName]);
+};
+
+/**
+ * Looks up the metadata of the entry
+ *
+ * @param {Function} successCallback is called with a Metadata object
+ * @param {Function} errorCallback is called with a FileError
+ */
+FileEntry.prototype.getMetadata = function(successCallback, errorCallback) {
+ PhoneGap.exec(successCallback, errorCallback, "File", "getMetadata", [this.fullPath]);
+};
+
+/**
+ * Gets the parent of the entry
+ *
+ * @param {Function} successCallback is called with a parent entry
+ * @param {Function} errorCallback is called with a FileError
+ */
+FileEntry.prototype.getParent = function(successCallback, errorCallback) {
+ PhoneGap.exec(successCallback, errorCallback, "File", "getParent", [this.fullPath]);
+};
+
+/**
+ * Moves a directory to a new location
+ *
+ * @param {DirectoryEntry} parent the directory to which to move the entry
+ * @param {DOMString} newName the new name of the entry, defaults to the current name
+ * @param {Function} successCallback is called with the new entry
+ * @param {Function} errorCallback is called with a FileError
+ */
+FileEntry.prototype.moveTo = function(parent, newName, successCallback, errorCallback) {
+ PhoneGap.exec(successCallback, errorCallback, "File", "moveTo", [this.fullPath, parent, newName]);
+};
+
+/**
+ * Removes the entry
+ *
+ * @param {Function} successCallback is called with no parameters
+ * @param {Function} errorCallback is called with a FileError
+ */
+FileEntry.prototype.remove = function(successCallback, errorCallback) {
+ PhoneGap.exec(successCallback, errorCallback, "File", "remove", [this.fullPath]);
+};
+
+/**
+ * Returns a URI that can be used to identify this entry.
+ *
+ * @param {DOMString} mimeType for a FileEntry, the mime type to be used to interpret the file, when loaded through this URI.
+ * @return uri
+ */
+FileEntry.prototype.toURI = function(mimeType) {
+ return "file://" + this.fullPath;
+};
+
+/**
+ * Creates a new FileWriter associated with the file that this FileEntry represents.
+ *
+ * @param {Function} successCallback is called with the new FileWriter
+ * @param {Function} errorCallback is called with a FileError
+ */
+FileEntry.prototype.createWriter = function(successCallback, errorCallback) {
+ this.file(function(filePointer) {
+ var writer = new FileWriter(filePointer);
+
+ if (writer.fileName === null || writer.fileName === "") {
+ if (typeof errorCallback === "function") {
+ errorCallback({
+ "code": FileError.INVALID_STATE_ERR
+ });
+ }
+ }
+
+ if (typeof successCallback === "function") {
+ successCallback(writer);
+ }
+ }, errorCallback);
+};
+
+/**
+ * Returns a File that represents the current state of the file that this FileEntry represents.
+ *
+ * @param {Function} successCallback is called with the new File object
+ * @param {Function} errorCallback is called with a FileError
+ */
+FileEntry.prototype.file = function(successCallback, errorCallback) {
+ PhoneGap.exec(successCallback, errorCallback, "File", "getFileMetadata", [this.fullPath]);
+};
+
+/** @constructor */
+var LocalFileSystem = function() {
+};
+
+// File error codes
+LocalFileSystem.TEMPORARY = 0;
+LocalFileSystem.PERSISTENT = 1;
+LocalFileSystem.RESOURCE = 2;
+LocalFileSystem.APPLICATION = 3;
+
+/**
+ * Requests a filesystem in which to store application data.
+ *
+ * @param {int} type of file system being requested
+ * @param {Function} successCallback is called with the new FileSystem
+ * @param {Function} errorCallback is called with a FileError
+ */
+LocalFileSystem.prototype.requestFileSystem = function(type, size, successCallback, errorCallback) {
+ if (type < 0 || type > 3) {
+ if (typeof errorCallback === "function") {
+ errorCallback({
+ "code": FileError.SYNTAX_ERR
+ });
+ }
+ }
+ else {
+ PhoneGap.exec(successCallback, errorCallback, "File", "requestFileSystem", [type, size]);
+ }
+};
+
+/**
+ *
+ * @param {DOMString} uri referring to a local file in a filesystem
+ * @param {Function} successCallback is called with the new entry
+ * @param {Function} errorCallback is called with a FileError
+ */
+LocalFileSystem.prototype.resolveLocalFileSystemURI = function(uri, successCallback, errorCallback) {
+ PhoneGap.exec(successCallback, errorCallback, "File", "resolveLocalFileSystemURI", [uri]);
+};
+
+/**
+* This function returns and array of contacts. It is required as we need to convert raw
+* JSON objects into concrete Contact objects. Currently this method is called after
+* navigator.service.contacts.find but before the find methods success call back.
+*
+* @param a JSON Objects that need to be converted to DirectoryEntry or FileEntry objects.
+* @returns an entry
+*/
+LocalFileSystem.prototype._castFS = function(pluginResult) {
+ var entry = null;
+ entry = new DirectoryEntry();
+ entry.isDirectory = pluginResult.message.root.isDirectory;
+ entry.isFile = pluginResult.message.root.isFile;
+ entry.name = pluginResult.message.root.name;
+ entry.fullPath = pluginResult.message.root.fullPath;
+ pluginResult.message.root = entry;
+ return pluginResult;
+};
+
+LocalFileSystem.prototype._castEntry = function(pluginResult) {
+ var entry = null;
+ if (pluginResult.message.isDirectory) {
+ entry = new DirectoryEntry();
+ }
+ else if (pluginResult.message.isFile) {
+ entry = new FileEntry();
+ }
+ entry.isDirectory = pluginResult.message.isDirectory;
+ entry.isFile = pluginResult.message.isFile;
+ entry.name = pluginResult.message.name;
+ entry.fullPath = pluginResult.message.fullPath;
+ pluginResult.message = entry;
+ return pluginResult;
+};
+
+LocalFileSystem.prototype._castEntries = function(pluginResult) {
+ var entries = pluginResult.message;
+ var retVal = [];
+ for (var i=0; i
+ *
+ * @param name The plugin name
+ * @param obj The plugin object
+ */
+PhoneGap.addPlugin = function(name, obj) {
+ if (!window.plugins[name]) {
+ window.plugins[name] = obj;
+ }
+ else {
+ console.log("Error: Plugin "+name+" already exists.");
+ }
+};
+
+/**
+ * onDOMContentLoaded channel is fired when the DOM content
+ * of the page has been parsed.
+ */
+PhoneGap.onDOMContentLoaded = new PhoneGap.Channel('onDOMContentLoaded');
+
+/**
+ * onNativeReady channel is fired when the PhoneGap native code
+ * has been initialized.
+ */
+PhoneGap.onNativeReady = new PhoneGap.Channel('onNativeReady');
+
+/**
+ * onPhoneGapInit channel is fired when the web page is fully loaded and
+ * PhoneGap native code has been initialized.
+ */
+PhoneGap.onPhoneGapInit = new PhoneGap.Channel('onPhoneGapInit');
+
+/**
+ * onPhoneGapReady channel is fired when the JS PhoneGap objects have been created.
+ */
+PhoneGap.onPhoneGapReady = new PhoneGap.Channel('onPhoneGapReady');
+
+/**
+ * onPhoneGapInfoReady channel is fired when the PhoneGap device properties
+ * has been set.
+ */
+PhoneGap.onPhoneGapInfoReady = new PhoneGap.Channel('onPhoneGapInfoReady');
+
+/**
+ * onPhoneGapConnectionReady channel is fired when the PhoneGap connection properties
+ * has been set.
+ */
+PhoneGap.onPhoneGapConnectionReady = new PhoneGap.Channel('onPhoneGapConnectionReady');
+
+/**
+ * onDestroy channel is fired when the PhoneGap native code
+ * is destroyed. It is used internally.
+ * Window.onunload should be used by the user.
+ */
+PhoneGap.onDestroy = new PhoneGap.Channel('onDestroy');
+PhoneGap.onDestroy.subscribeOnce(function() {
+ PhoneGap.shuttingDown = true;
+});
+PhoneGap.shuttingDown = false;
+
+// _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 PhoneGap JS is ready.
+if (typeof _nativeReady !== 'undefined') { PhoneGap.onNativeReady.fire(); }
+
+/**
+ * onDeviceReady is fired only after all PhoneGap objects are created and
+ * the device properties are set.
+ */
+PhoneGap.onDeviceReady = new PhoneGap.Channel('onDeviceReady');
+
+
+// Array of channels that must fire before "deviceready" is fired
+PhoneGap.deviceReadyChannelsArray = [ PhoneGap.onPhoneGapReady, PhoneGap.onPhoneGapInfoReady, PhoneGap.onPhoneGapConnectionReady];
+
+// Hashtable of user defined channels that must also fire before "deviceready" is fired
+PhoneGap.deviceReadyChannelsMap = {};
+
+/**
+ * Indicate that a feature needs to be initialized before it is ready to be used.
+ * This holds up PhoneGap's "deviceready" event until the feature has been initialized
+ * and PhoneGap.initComplete(feature) is called.
+ *
+ * @param feature {String} The unique feature name
+ */
+PhoneGap.waitForInitialization = function(feature) {
+ if (feature) {
+ var channel = new PhoneGap.Channel(feature);
+ PhoneGap.deviceReadyChannelsMap[feature] = channel;
+ PhoneGap.deviceReadyChannelsArray.push(channel);
+ }
+};
+
+/**
+ * Indicate that initialization code has completed and the feature is ready to be used.
+ *
+ * @param feature {String} The unique feature name
+ */
+PhoneGap.initializationComplete = function(feature) {
+ var channel = PhoneGap.deviceReadyChannelsMap[feature];
+ if (channel) {
+ channel.fire();
+ }
+};
+
+/**
+ * Create all PhoneGap objects once page has fully loaded and native side is ready.
+ */
+PhoneGap.Channel.join(function() {
+
+ // Start listening for XHR callbacks
+ setTimeout(function() {
+ if (PhoneGap.UsePolling) {
+ PhoneGap.JSCallbackPolling();
+ }
+ else {
+ var polling = prompt("usePolling", "gap_callbackServer:");
+ PhoneGap.UsePolling = polling;
+ if (polling == "true") {
+ PhoneGap.UsePolling = true;
+ PhoneGap.JSCallbackPolling();
+ }
+ else {
+ PhoneGap.UsePolling = false;
+ PhoneGap.JSCallback();
+ }
+ }
+ }, 1);
+
+ // Run PhoneGap constructors
+ PhoneGap.onPhoneGapInit.fire();
+
+ // Fire event to notify that all objects are created
+ PhoneGap.onPhoneGapReady.fire();
+
+ // Fire onDeviceReady event once all constructors have run and PhoneGap info has been
+ // received from native side, and any user defined initialization channels.
+ PhoneGap.Channel.join(function() {
+ // Let native code know we are inited on JS side
+ prompt("", "gap_init:");
+
+ PhoneGap.onDeviceReady.fire();
+ }, PhoneGap.deviceReadyChannelsArray);
+
+}, [ PhoneGap.onDOMContentLoaded, PhoneGap.onNativeReady ]);
+
+// Listen for DOMContentLoaded and notify our channel subscribers
+document.addEventListener('DOMContentLoaded', function() {
+ PhoneGap.onDOMContentLoaded.fire();
+}, false);
+
+// Intercept calls to document.addEventListener and watch for deviceready
+PhoneGap.m_document_addEventListener = document.addEventListener;
+
+// Intercept calls to window.addEventListener
+PhoneGap.m_window_addEventListener = window.addEventListener;
+
+/**
+ * Add a custom window event handler.
+ *
+ * @param {String} event The event name that callback handles
+ * @param {Function} callback The event handler
+ */
+PhoneGap.addWindowEventHandler = function(event, callback) {
+ PhoneGap.windowEventHandler[event] = callback;
+};
+
+/**
+ * Add a custom document event handler.
+ *
+ * @param {String} event The event name that callback handles
+ * @param {Function} callback The event handler
+ */
+PhoneGap.addDocumentEventHandler = function(event, callback) {
+ PhoneGap.documentEventHandler[event] = callback;
+};
+
+/**
+ * Intercept adding document event listeners and handle our own
+ *
+ * @param {Object} evt
+ * @param {Function} handler
+ * @param capture
+ */
+document.addEventListener = function(evt, handler, capture) {
+ var e = evt.toLowerCase();
+ if (e === 'deviceready') {
+ PhoneGap.onDeviceReady.subscribeOnce(handler);
+ }
+ else {
+ // If subscribing to Android backbutton
+ if (e === 'backbutton') {
+ PhoneGap.exec(null, null, "App", "overrideBackbutton", [true]);
+ }
+
+ // If subscribing to an event that is handled by a plugin
+ else if (typeof PhoneGap.documentEventHandler[e] !== "undefined") {
+ if (PhoneGap.documentEventHandler[e](e, handler, true)) {
+ return; // Stop default behavior
+ }
+ }
+
+ PhoneGap.m_document_addEventListener.call(document, evt, handler, capture);
+ }
+};
+
+/**
+ * Intercept adding window event listeners and handle our own
+ *
+ * @param {Object} evt
+ * @param {Function} handler
+ * @param capture
+ */
+window.addEventListener = function(evt, handler, capture) {
+ var e = evt.toLowerCase();
+
+ // If subscribing to an event that is handled by a plugin
+ if (typeof PhoneGap.windowEventHandler[e] !== "undefined") {
+ if (PhoneGap.windowEventHandler[e](e, handler, true)) {
+ return; // Stop default behavior
+ }
+ }
+
+ PhoneGap.m_window_addEventListener.call(window, evt, handler, capture);
+};
+
+// Intercept calls to document.removeEventListener and watch for events that
+// are generated by PhoneGap native code
+PhoneGap.m_document_removeEventListener = document.removeEventListener;
+
+// Intercept calls to window.removeEventListener
+PhoneGap.m_window_removeEventListener = window.removeEventListener;
+
+/**
+ * Intercept removing document event listeners and handle our own
+ *
+ * @param {Object} evt
+ * @param {Function} handler
+ * @param capture
+ */
+document.removeEventListener = function(evt, handler, capture) {
+ var e = evt.toLowerCase();
+
+ // If unsubscribing to Android backbutton
+ if (e === 'backbutton') {
+ PhoneGap.exec(null, null, "App", "overrideBackbutton", [false]);
+ }
+
+ // If unsubcribing from an event that is handled by a plugin
+ if (typeof PhoneGap.documentEventHandler[e] !== "undefined") {
+ if (PhoneGap.documentEventHandler[e](e, handler, false)) {
+ return; // Stop default behavior
+ }
+ }
+
+ PhoneGap.m_document_removeEventListener.call(document, evt, handler, capture);
+};
+
+/**
+ * Intercept removing window event listeners and handle our own
+ *
+ * @param {Object} evt
+ * @param {Function} handler
+ * @param capture
+ */
+window.removeEventListener = function(evt, handler, capture) {
+ var e = evt.toLowerCase();
+
+ // If unsubcribing from an event that is handled by a plugin
+ if (typeof PhoneGap.windowEventHandler[e] !== "undefined") {
+ if (PhoneGap.windowEventHandler[e](e, handler, false)) {
+ return; // Stop default behavior
+ }
+ }
+
+ PhoneGap.m_window_removeEventListener.call(window, evt, handler, capture);
+};
+
+/**
+ * Method to fire document event
+ *
+ * @param {String} type The event type to fire
+ * @param {Object} data Data to send with event
+ */
+PhoneGap.fireDocumentEvent = function(type, data) {
+ var e = document.createEvent('Events');
+ e.initEvent(type);
+ if (data) {
+ for (var i in data) {
+ e[i] = data[i];
+ }
+ }
+ document.dispatchEvent(e);
+};
+
+/**
+ * Method to fire window event
+ *
+ * @param {String} type The event type to fire
+ * @param {Object} data Data to send with event
+ */
+PhoneGap.fireWindowEvent = function(type, data) {
+ var e = document.createEvent('Events');
+ e.initEvent(type);
+ if (data) {
+ for (var i in data) {
+ e[i] = data[i];
+ }
+ }
+ window.dispatchEvent(e);
+};
+
+/**
+ * Does a deep clone of the object.
+ *
+ * @param obj
+ * @return {Object}
+ */
+PhoneGap.clone = function(obj) {
+ var i, retVal;
+ if(!obj) {
+ return obj;
+ }
+
+ if(obj instanceof Array){
+ retVal = [];
+ for(i = 0; i < obj.length; ++i){
+ retVal.push(PhoneGap.clone(obj[i]));
+ }
+ return retVal;
+ }
+
+ if (typeof obj === "function") {
+ return obj;
+ }
+
+ if(!(obj instanceof Object)){
+ return obj;
+ }
+
+ if (obj instanceof Date) {
+ return obj;
+ }
+
+ retVal = {};
+ for(i in obj){
+ if(!(i in retVal) || retVal[i] !== obj[i]) {
+ retVal[i] = PhoneGap.clone(obj[i]);
+ }
+ }
+ return retVal;
+};
+
+PhoneGap.callbackId = 0;
+PhoneGap.callbacks = {};
+PhoneGap.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
+ };
+
+
+/**
+ * Execute a PhoneGap command. It is up to the native side whether this action is synch or async.
+ * The native side can return:
+ * Synchronous: PluginResult object as a JSON string
+ * Asynchrounous: Empty string ""
+ * If async, the native side will PhoneGap.callbackSuccess or PhoneGap.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 Action to be run in PhoneGap
+ * @param {Array.} [args] Zero or more arguments to pass to the method
+ */
+PhoneGap.exec = function(success, fail, service, action, args) {
+ try {
+ var callbackId = service + PhoneGap.callbackId++;
+ if (success || fail) {
+ PhoneGap.callbacks[callbackId] = {success:success, fail:fail};
+ }
+
+ var r = prompt(JSON.stringify(args), "gap:"+JSON.stringify([service, action, callbackId, true]));
+
+ // If a result was returned
+ if (r.length > 0) {
+ eval("var v="+r+";");
+
+ // If status is OK, then return value back to caller
+ if (v.status === PhoneGap.callbackStatus.OK) {
+
+ // If there is a success callback, then call it now with
+ // returned value
+ if (success) {
+ try {
+ success(v.message);
+ } catch (e) {
+ console.log("Error in success callback: " + callbackId + " = " + e);
+ }
+
+ // Clear callback if not expecting any more results
+ if (!v.keepCallback) {
+ delete PhoneGap.callbacks[callbackId];
+ }
+ }
+ return v.message;
+ }
+
+ // If no result
+ else if (v.status === PhoneGap.callbackStatus.NO_RESULT) {
+
+ // Clear callback if not expecting any more results
+ if (!v.keepCallback) {
+ delete PhoneGap.callbacks[callbackId];
+ }
+ }
+
+ // If error, then display error
+ else {
+ console.log("Error: Status="+v.status+" Message="+v.message);
+
+ // If there is a fail callback, then call it now with returned value
+ if (fail) {
+ try {
+ fail(v.message);
+ }
+ catch (e1) {
+ console.log("Error in error callback: "+callbackId+" = "+e1);
+ }
+
+ // Clear callback if not expecting any more results
+ if (!v.keepCallback) {
+ delete PhoneGap.callbacks[callbackId];
+ }
+ }
+ return null;
+ }
+ }
+ } catch (e2) {
+ console.log("Error: "+e2);
+ }
+};
+
+/**
+ * Called by native code when returning successful result from an action.
+ *
+ * @param callbackId
+ * @param args
+ */
+PhoneGap.callbackSuccess = function(callbackId, args) {
+ if (PhoneGap.callbacks[callbackId]) {
+
+ // If result is to be sent to callback
+ if (args.status === PhoneGap.callbackStatus.OK) {
+ try {
+ if (PhoneGap.callbacks[callbackId].success) {
+ PhoneGap.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 PhoneGap.callbacks[callbackId];
+ }
+ }
+};
+
+/**
+ * Called by native code when returning error result from an action.
+ *
+ * @param callbackId
+ * @param args
+ */
+PhoneGap.callbackError = function(callbackId, args) {
+ if (PhoneGap.callbacks[callbackId]) {
+ try {
+ if (PhoneGap.callbacks[callbackId].fail) {
+ PhoneGap.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 PhoneGap.callbacks[callbackId];
+ }
+ }
+};
+
+PhoneGap.JSCallbackPort = null;
+PhoneGap.JSCallbackToken = null;
+
+/**
+ * This is only for Android.
+ *
+ * Internal function that uses XHR to call into PhoneGap Java code and retrieve
+ * any JavaScript code that needs to be run. This is used for callbacks from
+ * Java to JavaScript.
+ */
+PhoneGap.JSCallback = function() {
+
+ // Exit if shutting down app
+ if (PhoneGap.shuttingDown) {
+ return;
+ }
+
+ // If polling flag was changed, start using polling from now on
+ if (PhoneGap.UsePolling) {
+ PhoneGap.JSCallbackPolling();
+ return;
+ }
+
+ var xmlhttp = new XMLHttpRequest();
+
+ // Callback function when XMLHttpRequest is ready
+ xmlhttp.onreadystatechange=function(){
+ if(xmlhttp.readyState === 4){
+
+ // Exit if shutting down app
+ if (PhoneGap.shuttingDown) {
+ return;
+ }
+
+ // If callback has JavaScript statement to execute
+ if (xmlhttp.status === 200) {
+
+ // Need to url decode the response
+ var msg = decodeURIComponent(xmlhttp.responseText);
+ setTimeout(function() {
+ try {
+ var t = eval(msg);
+ }
+ catch (e) {
+ // If we're getting an error here, seeing the message will help in debugging
+ console.log("JSCallback: Message from Server: " + msg);
+ console.log("JSCallback Error: "+e);
+ }
+ }, 1);
+ setTimeout(PhoneGap.JSCallback, 1);
+ }
+
+ // If callback ping (used to keep XHR request from timing out)
+ else if (xmlhttp.status === 404) {
+ setTimeout(PhoneGap.JSCallback, 10);
+ }
+
+ // If security error
+ else if (xmlhttp.status === 403) {
+ console.log("JSCallback Error: Invalid token. Stopping callbacks.");
+ }
+
+ // If server is stopping
+ else if (xmlhttp.status === 503) {
+ console.log("JSCallback Server Closed: Stopping callbacks.");
+ }
+
+ // If request wasn't GET
+ else if (xmlhttp.status === 400) {
+ console.log("JSCallback Error: Bad request. Stopping callbacks.");
+ }
+
+ // If error, revert to polling
+ else {
+ console.log("JSCallback Error: Request failed.");
+ PhoneGap.UsePolling = true;
+ PhoneGap.JSCallbackPolling();
+ }
+ }
+ };
+
+ if (PhoneGap.JSCallbackPort === null) {
+ PhoneGap.JSCallbackPort = prompt("getPort", "gap_callbackServer:");
+ }
+ if (PhoneGap.JSCallbackToken === null) {
+ PhoneGap.JSCallbackToken = prompt("getToken", "gap_callbackServer:");
+ }
+ xmlhttp.open("GET", "http://127.0.0.1:"+PhoneGap.JSCallbackPort+"/"+PhoneGap.JSCallbackToken , true);
+ xmlhttp.send();
+};
+
+/**
+ * The polling period to use with JSCallbackPolling.
+ * This can be changed by the application. The default is 50ms.
+ */
+PhoneGap.JSCallbackPollingPeriod = 50;
+
+/**
+ * Flag that can be set by the user to force polling to be used or force XHR to be used.
+ */
+PhoneGap.UsePolling = false; // T=use polling, F=use XHR
+
+/**
+ * This is only for Android.
+ *
+ * Internal function that uses polling to call into PhoneGap Java code and retrieve
+ * any JavaScript code that needs to be run. This is used for callbacks from
+ * Java to JavaScript.
+ */
+PhoneGap.JSCallbackPolling = function() {
+
+ // Exit if shutting down app
+ if (PhoneGap.shuttingDown) {
+ return;
+ }
+
+ // If polling flag was changed, stop using polling from now on
+ if (!PhoneGap.UsePolling) {
+ PhoneGap.JSCallback();
+ return;
+ }
+
+ var msg = prompt("", "gap_poll:");
+ if (msg) {
+ setTimeout(function() {
+ try {
+ var t = eval(""+msg);
+ }
+ catch (e) {
+ console.log("JSCallbackPolling: Message from Server: " + msg);
+ console.log("JSCallbackPolling Error: "+e);
+ }
+ }, 1);
+ setTimeout(PhoneGap.JSCallbackPolling, 1);
+ }
+ else {
+ setTimeout(PhoneGap.JSCallbackPolling, PhoneGap.JSCallbackPollingPeriod);
+ }
+};
+
+/**
+ * Create a UUID
+ *
+ * @return {String}
+ */
+PhoneGap.createUUID = function() {
+ return PhoneGap.UUIDcreatePart(4) + '-' +
+ PhoneGap.UUIDcreatePart(2) + '-' +
+ PhoneGap.UUIDcreatePart(2) + '-' +
+ PhoneGap.UUIDcreatePart(2) + '-' +
+ PhoneGap.UUIDcreatePart(6);
+};
+
+PhoneGap.UUIDcreatePart = function(length) {
+ var uuidpart = "";
+ var i, uuidchar;
+ for (i=0; i');
+document.write('');
+
+function backHome() {
+ if (device.platform.toLowerCase() == 'android') {
+ navigator.app.backHistory();
+ }
+ else {
+ document.location = "../index.html";
+ }
+}
diff --git a/test/assets/www/sql/index.html b/test/assets/www/sql/index.html
new file mode 100755
index 00000000..c9e1a539
--- /dev/null
+++ b/test/assets/www/sql/index.html
@@ -0,0 +1,132 @@
+
+
+
+
+
+ PhoneGap
+
+
+
+
+
+
+
+
+
+