mirror of
https://github.com/apache/cordova-android.git
synced 2026-04-23 00:00:09 +08:00
Rename to Cordova
This commit is contained in:
macdonst
Executable
+920
@@ -0,0 +1,920 @@
|
||||
/*
|
||||
* 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);
|
||||
};
|
||||
|
||||
}
|
||||
Reference in New Issue
Block a user