forked from github/cordova-android
2cd116e4e7
Contact search was not working for unicode letters. The CallbackServer was changed so that it returned url encode strings. On the JavaScript side the PhoneGap callback handler decodes the returned string.
936 lines
28 KiB
Plaintext
Executable File
936 lines
28 KiB
Plaintext
Executable File
/*
|
|
* PhoneGap is available under *either* the terms of the modified BSD license *or* the
|
|
* MIT License (2008). See http://opensource.org/licenses/alphabetical for full text.
|
|
*
|
|
* Copyright (c) 2005-2010, Nitobi Software Inc.
|
|
* Copyright (c) 2010-2011, IBM Corporation
|
|
*/
|
|
|
|
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:
|
|
* onDeviceReady
|
|
* onResume
|
|
*
|
|
* Listeners can be registered as:
|
|
* document.addEventListener("deviceready", myDeviceReadyListener, false);
|
|
* document.addEventListener("resume", myResumeListener, false);
|
|
* document.addEventListener("pause", myPauseListener, false);
|
|
*/
|
|
|
|
if (typeof(DeviceInfo) !== 'object') {
|
|
DeviceInfo = {};
|
|
}
|
|
|
|
/**
|
|
* This represents the PhoneGap API itself, and provides a global namespace for accessing
|
|
* information about the state of PhoneGap.
|
|
* @class
|
|
*/
|
|
var PhoneGap = {
|
|
queue: {
|
|
ready: true,
|
|
commands: [],
|
|
timer: null
|
|
}
|
|
};
|
|
|
|
/**
|
|
* 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
|
|
*/
|
|
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" && f instanceof 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" && f instanceof 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 (g instanceof 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 (handler instanceof 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<len; j++) {
|
|
if (!c[j].fired) {
|
|
c[j].subscribeOnce(f);
|
|
}
|
|
else {
|
|
i--;
|
|
}
|
|
}
|
|
if (!i) {
|
|
h();
|
|
}
|
|
};
|
|
|
|
/**
|
|
* Boolean flag indicating if the PhoneGap API is available and initialized.
|
|
*/ // TODO: Remove this, it is unused here ... -jm
|
|
PhoneGap.available = DeviceInfo.uuid !== undefined;
|
|
|
|
/**
|
|
* Add an initialization function to a queue that ensures it will run and initialize
|
|
* application constructors only once PhoneGap has been initialized.
|
|
* @param {Function} func The function callback you want run once PhoneGap is initialized
|
|
*/
|
|
PhoneGap.addConstructor = function(func) {
|
|
PhoneGap.onPhoneGapInit.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
|
|
*/
|
|
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');
|
|
|
|
/**
|
|
* onResume channel is fired when the PhoneGap native code
|
|
* resumes.
|
|
*/
|
|
PhoneGap.onResume = new PhoneGap.Channel('onResume');
|
|
|
|
/**
|
|
* onPause channel is fired when the PhoneGap native code
|
|
* pauses.
|
|
*/
|
|
PhoneGap.onPause = new PhoneGap.Channel('onPause');
|
|
|
|
/**
|
|
* 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];
|
|
|
|
// 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:");
|
|
if (polling == "true") {
|
|
PhoneGap.JSCallbackPolling();
|
|
}
|
|
else {
|
|
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() {
|
|
|
|
// Turn off app loading dialog
|
|
navigator.notification.activityStop();
|
|
|
|
PhoneGap.onDeviceReady.fire();
|
|
|
|
// Fire the onresume event, since first one happens before JavaScript is loaded
|
|
PhoneGap.onResume.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;
|
|
|
|
document.addEventListener = function(evt, handler, capture) {
|
|
var e = evt.toLowerCase();
|
|
if (e === 'deviceready') {
|
|
PhoneGap.onDeviceReady.subscribeOnce(handler);
|
|
} else if (e === 'resume') {
|
|
PhoneGap.onResume.subscribe(handler);
|
|
if (PhoneGap.onDeviceReady.fired) {
|
|
PhoneGap.onResume.fire();
|
|
}
|
|
} else if (e === 'pause') {
|
|
PhoneGap.onPause.subscribe(handler);
|
|
}
|
|
else {
|
|
// If subscribing to Android backbutton
|
|
if (e === 'backbutton') {
|
|
PhoneGap.exec(null, null, "App", "overrideBackbutton", [true]);
|
|
}
|
|
|
|
PhoneGap.m_document_addEventListener.call(document, 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;
|
|
|
|
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]);
|
|
}
|
|
|
|
PhoneGap.m_document_removeEventListener.call(document, evt, handler, capture);
|
|
};
|
|
|
|
/**
|
|
* Method to fire event from native code
|
|
*/
|
|
PhoneGap.fireEvent = function(type) {
|
|
var e = document.createEvent('Events');
|
|
e.initEvent(type);
|
|
document.dispatchEvent(e);
|
|
};
|
|
|
|
/**
|
|
* If JSON not included, use our own stringify. (Android 1.6)
|
|
* The restriction on ours is that it must be an array of simple types.
|
|
*
|
|
* @param args
|
|
* @return
|
|
*/
|
|
PhoneGap.stringify = function(args) {
|
|
if (typeof JSON === "undefined") {
|
|
var s = "[";
|
|
var i, type, start, name, nameType, a;
|
|
for (i = 0; i < args.length; i++) {
|
|
if (args[i] != null) {
|
|
if (i > 0) {
|
|
s = s + ",";
|
|
}
|
|
type = typeof args[i];
|
|
if ((type === "number") || (type === "boolean")) {
|
|
s = s + args[i];
|
|
} else if (args[i] instanceof Array) {
|
|
s = s + "[" + args[i] + "]";
|
|
} else if (args[i] instanceof Object) {
|
|
start = true;
|
|
s = s + '{';
|
|
for (name in args[i]) {
|
|
if (args[i][name] !== null) {
|
|
if (!start) {
|
|
s = s + ',';
|
|
}
|
|
s = s + '"' + name + '":';
|
|
nameType = typeof args[i][name];
|
|
if ((nameType === "number") || (nameType === "boolean")) {
|
|
s = s + args[i][name];
|
|
} else if ((typeof args[i][name]) === 'function') {
|
|
// don't copy the functions
|
|
s = s + '""';
|
|
} else if (args[i][name] instanceof Object) {
|
|
s = s + this.stringify(args[i][name]);
|
|
} else {
|
|
s = s + '"' + args[i][name] + '"';
|
|
}
|
|
start = false;
|
|
}
|
|
}
|
|
s = s + '}';
|
|
} else {
|
|
a = args[i].replace(/\\/g, '\\\\');
|
|
a = a.replace(/"/g, '\\"');
|
|
s = s + '"' + a + '"';
|
|
}
|
|
}
|
|
}
|
|
s = s + "]";
|
|
return s;
|
|
} else {
|
|
return JSON.stringify(args);
|
|
}
|
|
};
|
|
|
|
/**
|
|
* Does a deep clone of the object.
|
|
*
|
|
* @param obj
|
|
* @return
|
|
*/
|
|
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 (obj instanceof 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 {String[]} [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(this.stringify(args), "gap:"+this.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];
|
|
}
|
|
}
|
|
};
|
|
|
|
|
|
/**
|
|
* Internal function used to dispatch the request to PhoneGap. It processes the
|
|
* command queue and executes the next command on the list. If one of the
|
|
* arguments is a JavaScript object, it will be passed on the QueryString of the
|
|
* url, which will be turned into a dictionary on the other end.
|
|
* @private
|
|
*/
|
|
// TODO: Is this used?
|
|
PhoneGap.run_command = function() {
|
|
if (!PhoneGap.available || !PhoneGap.queue.ready) {
|
|
return;
|
|
}
|
|
PhoneGap.queue.ready = false;
|
|
|
|
var args = PhoneGap.queue.commands.shift();
|
|
if (PhoneGap.queue.commands.length === 0) {
|
|
clearInterval(PhoneGap.queue.timer);
|
|
PhoneGap.queue.timer = null;
|
|
}
|
|
|
|
var uri = [];
|
|
var dict = null;
|
|
var i;
|
|
for (i = 1; i < args.length; i++) {
|
|
var arg = args[i];
|
|
if (arg === undefined || arg === null) {
|
|
arg = '';
|
|
}
|
|
if (typeof(arg) === 'object') {
|
|
dict = arg;
|
|
} else {
|
|
uri.push(encodeURIComponent(arg));
|
|
}
|
|
}
|
|
var url = "gap://" + args[0] + "/" + uri.join("/");
|
|
if (dict !== null) {
|
|
var name;
|
|
var query_args = [];
|
|
for (name in dict) {
|
|
if (dict.hasOwnProperty(name) && (typeof (name) === 'string')) {
|
|
query_args.push(encodeURIComponent(name) + "=" + encodeURIComponent(dict[name]));
|
|
}
|
|
}
|
|
if (query_args.length > 0) {
|
|
url += "?" + query_args.join("&");
|
|
}
|
|
}
|
|
document.location = url;
|
|
|
|
};
|
|
|
|
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 and replace %20 with a space
|
|
var msg = decodeURIComponent(xmlhttp.responseText.replace(/\+/g, '%20'));
|
|
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 Error: Service unavailable. Stopping callbacks.");
|
|
}
|
|
|
|
// If request wasn't GET
|
|
else if (xmlhttp.status === 400) {
|
|
console.log("JSCallback Error: Bad request. Stopping callbacks.");
|
|
}
|
|
|
|
// If error, restart callback server
|
|
else {
|
|
console.log("JSCallback Error: Request failed.");
|
|
prompt("restartServer", "gap_callbackServer:");
|
|
PhoneGap.JSCallbackPort = null;
|
|
PhoneGap.JSCallbackToken = null;
|
|
setTimeout(PhoneGap.JSCallback, 100);
|
|
}
|
|
}
|
|
};
|
|
|
|
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
|
|
*/
|
|
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<length; i++) {
|
|
uuidchar = parseInt((Math.random() * 256),0).toString(16);
|
|
if (uuidchar.length === 1) {
|
|
uuidchar = "0" + uuidchar;
|
|
}
|
|
uuidpart += uuidchar;
|
|
}
|
|
return uuidpart;
|
|
};
|
|
|
|
PhoneGap.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.
|
|
*/
|
|
PhoneGap.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);
|
|
};
|
|
|
|
/**
|
|
* This class is provided to bridge the gap between the way plugins were setup in 0.9.3 and 0.9.4.
|
|
* Users should be calling navigator.add.addService() instead of PluginManager.addService().
|
|
* @class
|
|
* @deprecated
|
|
*/
|
|
var PluginManager = {
|
|
addService: function(serviceType, className) {
|
|
navigator.app.addService(serviceType, className);
|
|
}
|
|
};
|
|
|
|
};
|