mobile_template 0.0.1

data/templates/cordova_android/framework/assets/js/cordova.js.base

@@ -0,0 +1,924 @@
+/*
+ *     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<len; j++) {
+        if (!c[j].fired) {
+            c[j].subscribeOnce(f);
+        }
+        else {
+            i--;
+        }
+    }
+    if (!i) {
+        h();
+    }
+};
+
+/**
+ * Add an initialization function to a queue that ensures it will run and initialize
+ * application constructors only once Cordova has been initialized.
+ * @param {Function} func The function callback you want run once Cordova is initialized
+ */
+Cordova.addConstructor = function(func) {
+    Cordova.onCordovaInit.subscribeOnce(function() {
+        try {
+            func();
+        } catch(e) {
+            console.log("Failed to run constructor: " + e);
+        }
+    });
+};
+
+/**
+ * Plugins object
+ */
+if (!window.plugins) {
+    window.plugins = {};
+}
+
+/**
+ * Adds a plugin object to window.plugins.
+ * The plugin is accessed using window.plugins.<name>
+ *
+ * @param name          The plugin name
+ * @param obj           The plugin object
+ */
+Cordova.addPlugin = function(name, obj) {
+    if (!window.plugins[name]) {
+        window.plugins[name] = obj;
+    }
+    else {
+        console.log("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.<String>} [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<length; i++) {
+        uuidchar = parseInt((Math.random() * 256),0).toString(16);
+        if (uuidchar.length === 1) {
+            uuidchar = "0" + uuidchar;
+        }
+        uuidpart += uuidchar;
+    }
+    return uuidpart;
+};
+
+Cordova.close = function(context, func, params) {
+    if (typeof params === 'undefined') {
+        return function() {
+            return func.apply(context, arguments);
+        };
+    } else {
+        return function() {
+            return func.apply(context, params);
+        };
+    }
+};
+
+/**
+ * Load a JavaScript file after page has loaded.
+ *
+ * @param {String} jsfile               The url of the JavaScript file to load.
+ * @param {Function} successCallback    The callback to call when the file has been loaded.
+ */
+Cordova.includeJavascript = function(jsfile, successCallback) {
+    var id = document.getElementsByTagName("head")[0];
+    var el = document.createElement('script');
+    el.type = 'text/javascript';
+    if (typeof successCallback === 'function') {
+        el.onload = successCallback;
+    }
+    el.src = jsfile;
+    id.appendChild(el);
+};
+
+/** 
+ * Legacy variable for old plugins.
+ */
+var PhoneGap = Cordova;
+}