// Platform: windows8 | |
// 2.7.0rc1-106-gd81abfc | |
/* | |
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. | |
*/ | |
;(function() { | |
var CORDOVA_JS_BUILD_LABEL = '2.7.0rc1-106-gd81abfc'; | |
// file: lib/scripts/require.js | |
var require, | |
define; | |
(function () { | |
var modules = {}, | |
// Stack of moduleIds currently being built. | |
requireStack = [], | |
// Map of module ID -> index into requireStack of modules currently being built. | |
inProgressModules = {}, | |
SEPERATOR = "."; | |
function build(module) { | |
var factory = module.factory, | |
localRequire = function (id) { | |
var resultantId = id; | |
//Its a relative path, so lop off the last portion and add the id (minus "./") | |
if (id.charAt(0) === ".") { | |
resultantId = module.id.slice(0, module.id.lastIndexOf(SEPERATOR)) + SEPERATOR + id.slice(2); | |
} | |
return require(resultantId); | |
}; | |
module.exports = {}; | |
delete module.factory; | |
factory(localRequire, module.exports, module); | |
return module.exports; | |
} | |
require = function (id) { | |
if (!modules[id]) { | |
throw "module " + id + " not found"; | |
} else if (id in inProgressModules) { | |
var cycle = requireStack.slice(inProgressModules[id]).join('->') + '->' + id; | |
throw "Cycle in require graph: " + cycle; | |
} | |
if (modules[id].factory) { | |
try { | |
inProgressModules[id] = requireStack.length; | |
requireStack.push(id); | |
return build(modules[id]); | |
} finally { | |
delete inProgressModules[id]; | |
requireStack.pop(); | |
} | |
} | |
return modules[id].exports; | |
}; | |
define = function (id, factory) { | |
if (modules[id]) { | |
throw "module " + id + " already defined"; | |
} | |
modules[id] = { | |
id: id, | |
factory: factory | |
}; | |
}; | |
define.remove = function (id) { | |
delete modules[id]; | |
}; | |
define.moduleMap = modules; | |
})(); | |
//Export for use in node | |
if (typeof module === "object" && typeof require === "function") { | |
module.exports.require = require; | |
module.exports.define = define; | |
} | |
// file: lib/cordova.js | |
define("cordova", function(require, exports, module) { | |
var channel = require('cordova/channel'); | |
/** | |
* Listen for DOMContentLoaded and notify our channel subscribers. | |
*/ | |
document.addEventListener('DOMContentLoaded', function() { | |
channel.onDOMContentLoaded.fire(); | |
}, false); | |
if (document.readyState == 'complete' || document.readyState == 'interactive') { | |
channel.onDOMContentLoaded.fire(); | |
} | |
/** | |
* Intercept calls to addEventListener + removeEventListener and handle deviceready, | |
* resume, and pause events. | |
*/ | |
var m_document_addEventListener = document.addEventListener; | |
var m_document_removeEventListener = document.removeEventListener; | |
var m_window_addEventListener = window.addEventListener; | |
var m_window_removeEventListener = window.removeEventListener; | |
/** | |
* Houses custom event handlers to intercept on document + window event listeners. | |
*/ | |
var documentEventHandlers = {}, | |
windowEventHandlers = {}; | |
document.addEventListener = function(evt, handler, capture) { | |
var e = evt.toLowerCase(); | |
if (typeof documentEventHandlers[e] != 'undefined') { | |
documentEventHandlers[e].subscribe(handler); | |
} else { | |
m_document_addEventListener.call(document, evt, handler, capture); | |
} | |
}; | |
window.addEventListener = function(evt, handler, capture) { | |
var e = evt.toLowerCase(); | |
if (typeof windowEventHandlers[e] != 'undefined') { | |
windowEventHandlers[e].subscribe(handler); | |
} else { | |
m_window_addEventListener.call(window, evt, handler, capture); | |
} | |
}; | |
document.removeEventListener = function(evt, handler, capture) { | |
var e = evt.toLowerCase(); | |
// If unsubscribing from an event that is handled by a plugin | |
if (typeof documentEventHandlers[e] != "undefined") { | |
documentEventHandlers[e].unsubscribe(handler); | |
} else { | |
m_document_removeEventListener.call(document, evt, handler, capture); | |
} | |
}; | |
window.removeEventListener = function(evt, handler, capture) { | |
var e = evt.toLowerCase(); | |
// If unsubscribing from an event that is handled by a plugin | |
if (typeof windowEventHandlers[e] != "undefined") { | |
windowEventHandlers[e].unsubscribe(handler); | |
} else { | |
m_window_removeEventListener.call(window, evt, handler, capture); | |
} | |
}; | |
function createEvent(type, data) { | |
var event = document.createEvent('Events'); | |
event.initEvent(type, false, false); | |
if (data) { | |
for (var i in data) { | |
if (data.hasOwnProperty(i)) { | |
event[i] = data[i]; | |
} | |
} | |
} | |
return event; | |
} | |
if(typeof window.console === "undefined") { | |
window.console = { | |
log:function(){} | |
}; | |
} | |
var cordova = { | |
define:define, | |
require:require, | |
/** | |
* Methods to add/remove your own addEventListener hijacking on document + window. | |
*/ | |
addWindowEventHandler:function(event) { | |
return (windowEventHandlers[event] = channel.create(event)); | |
}, | |
addStickyDocumentEventHandler:function(event) { | |
return (documentEventHandlers[event] = channel.createSticky(event)); | |
}, | |
addDocumentEventHandler:function(event) { | |
return (documentEventHandlers[event] = channel.create(event)); | |
}, | |
removeWindowEventHandler:function(event) { | |
delete windowEventHandlers[event]; | |
}, | |
removeDocumentEventHandler:function(event) { | |
delete documentEventHandlers[event]; | |
}, | |
/** | |
* Retrieve original event handlers that were replaced by Cordova | |
* | |
* @return object | |
*/ | |
getOriginalHandlers: function() { | |
return {'document': {'addEventListener': m_document_addEventListener, 'removeEventListener': m_document_removeEventListener}, | |
'window': {'addEventListener': m_window_addEventListener, 'removeEventListener': m_window_removeEventListener}}; | |
}, | |
/** | |
* Method to fire event from native code | |
* bNoDetach is required for events which cause an exception which needs to be caught in native code | |
*/ | |
fireDocumentEvent: function(type, data, bNoDetach) { | |
var evt = createEvent(type, data); | |
if (typeof documentEventHandlers[type] != 'undefined') { | |
if( bNoDetach ) { | |
documentEventHandlers[type].fire(evt); | |
} | |
else { | |
setTimeout(function() { | |
// Fire deviceready on listeners that were registered before cordova.js was loaded. | |
if (type == 'deviceready') { | |
document.dispatchEvent(evt); | |
} | |
documentEventHandlers[type].fire(evt); | |
}, 0); | |
} | |
} else { | |
document.dispatchEvent(evt); | |
} | |
}, | |
fireWindowEvent: function(type, data) { | |
var evt = createEvent(type,data); | |
if (typeof windowEventHandlers[type] != 'undefined') { | |
setTimeout(function() { | |
windowEventHandlers[type].fire(evt); | |
}, 0); | |
} else { | |
window.dispatchEvent(evt); | |
} | |
}, | |
/** | |
* Plugin callback mechanism. | |
*/ | |
// Randomize the starting callbackId to avoid collisions after refreshing or navigating. | |
// This way, it's very unlikely that any new callback would get the same callbackId as an old callback. | |
callbackId: Math.floor(Math.random() * 2000000000), | |
callbacks: {}, | |
callbackStatus: { | |
NO_RESULT: 0, | |
OK: 1, | |
CLASS_NOT_FOUND_EXCEPTION: 2, | |
ILLEGAL_ACCESS_EXCEPTION: 3, | |
INSTANTIATION_EXCEPTION: 4, | |
MALFORMED_URL_EXCEPTION: 5, | |
IO_EXCEPTION: 6, | |
INVALID_ACTION: 7, | |
JSON_EXCEPTION: 8, | |
ERROR: 9 | |
}, | |
/** | |
* Called by native code when returning successful result from an action. | |
*/ | |
callbackSuccess: function(callbackId, args) { | |
try { | |
cordova.callbackFromNative(callbackId, true, args.status, [args.message], args.keepCallback); | |
} catch (e) { | |
console.log("Error in error callback: " + callbackId + " = "+e); | |
} | |
}, | |
/** | |
* Called by native code when returning error result from an action. | |
*/ | |
callbackError: function(callbackId, args) { | |
// TODO: Deprecate callbackSuccess and callbackError in favour of callbackFromNative. | |
// Derive success from status. | |
try { | |
cordova.callbackFromNative(callbackId, false, args.status, [args.message], args.keepCallback); | |
} catch (e) { | |
console.log("Error in error callback: " + callbackId + " = "+e); | |
} | |
}, | |
/** | |
* Called by native code when returning the result from an action. | |
*/ | |
callbackFromNative: function(callbackId, success, status, args, keepCallback) { | |
var callback = cordova.callbacks[callbackId]; | |
if (callback) { | |
if (success && status == cordova.callbackStatus.OK) { | |
callback.success && callback.success.apply(null, args); | |
} else if (!success) { | |
callback.fail && callback.fail.apply(null, args); | |
} | |
// Clear callback if not expecting any more results | |
if (!keepCallback) { | |
delete cordova.callbacks[callbackId]; | |
} | |
} | |
}, | |
addConstructor: function(func) { | |
channel.onCordovaReady.subscribe(function() { | |
try { | |
func(); | |
} catch(e) { | |
console.log("Failed to run constructor: " + e); | |
} | |
}); | |
} | |
}; | |
// Register pause, resume and deviceready channels as events on document. | |
channel.onPause = cordova.addDocumentEventHandler('pause'); | |
channel.onResume = cordova.addDocumentEventHandler('resume'); | |
channel.onDeviceReady = cordova.addStickyDocumentEventHandler('deviceready'); | |
module.exports = cordova; | |
}); | |
// file: lib/common/argscheck.js | |
define("cordova/argscheck", function(require, exports, module) { | |
var exec = require('cordova/exec'); | |
var utils = require('cordova/utils'); | |
var moduleExports = module.exports; | |
var typeMap = { | |
'A': 'Array', | |
'D': 'Date', | |
'N': 'Number', | |
'S': 'String', | |
'F': 'Function', | |
'O': 'Object' | |
}; | |
function extractParamName(callee, argIndex) { | |
return (/.*?\((.*?)\)/).exec(callee)[1].split(', ')[argIndex]; | |
} | |
function checkArgs(spec, functionName, args, opt_callee) { | |
if (!moduleExports.enableChecks) { | |
return; | |
} | |
var errMsg = null; | |
var typeName; | |
for (var i = 0; i < spec.length; ++i) { | |
var c = spec.charAt(i), | |
cUpper = c.toUpperCase(), | |
arg = args[i]; | |
// Asterix means allow anything. | |
if (c == '*') { | |
continue; | |
} | |
typeName = utils.typeName(arg); | |
if ((arg === null || arg === undefined) && c == cUpper) { | |
continue; | |
} | |
if (typeName != typeMap[cUpper]) { | |
errMsg = 'Expected ' + typeMap[cUpper]; | |
break; | |
} | |
} | |
if (errMsg) { | |
errMsg += ', but got ' + typeName + '.'; | |
errMsg = 'Wrong type for parameter "' + extractParamName(opt_callee || args.callee, i) + '" of ' + functionName + ': ' + errMsg; | |
// Don't log when running unit tests. | |
if (typeof jasmine == 'undefined') { | |
console.error(errMsg); | |
} | |
throw TypeError(errMsg); | |
} | |
} | |
function getValue(value, defaultValue) { | |
return value === undefined ? defaultValue : value; | |
} | |
moduleExports.checkArgs = checkArgs; | |
moduleExports.getValue = getValue; | |
moduleExports.enableChecks = true; | |
}); | |
// file: lib/common/builder.js | |
define("cordova/builder", function(require, exports, module) { | |
var utils = require('cordova/utils'); | |
function each(objects, func, context) { | |
for (var prop in objects) { | |
if (objects.hasOwnProperty(prop)) { | |
func.apply(context, [objects[prop], prop]); | |
} | |
} | |
} | |
function clobber(obj, key, value) { | |
exports.replaceHookForTesting(obj, key); | |
obj[key] = value; | |
// Getters can only be overridden by getters. | |
if (obj[key] !== value) { | |
utils.defineGetter(obj, key, function() { | |
return value; | |
}); | |
} | |
} | |
function assignOrWrapInDeprecateGetter(obj, key, value, message) { | |
if (message) { | |
utils.defineGetter(obj, key, function() { | |
console.log(message); | |
delete obj[key]; | |
clobber(obj, key, value); | |
return value; | |
}); | |
} else { | |
clobber(obj, key, value); | |
} | |
} | |
function include(parent, objects, clobber, merge) { | |
each(objects, function (obj, key) { | |
try { | |
var result = obj.path ? require(obj.path) : {}; | |
if (clobber) { | |
// Clobber if it doesn't exist. | |
if (typeof parent[key] === 'undefined') { | |
assignOrWrapInDeprecateGetter(parent, key, result, obj.deprecated); | |
} else if (typeof obj.path !== 'undefined') { | |
// If merging, merge properties onto parent, otherwise, clobber. | |
if (merge) { | |
recursiveMerge(parent[key], result); | |
} else { | |
assignOrWrapInDeprecateGetter(parent, key, result, obj.deprecated); | |
} | |
} | |
result = parent[key]; | |
} else { | |
// Overwrite if not currently defined. | |
if (typeof parent[key] == 'undefined') { | |
assignOrWrapInDeprecateGetter(parent, key, result, obj.deprecated); | |
} else { | |
// Set result to what already exists, so we can build children into it if they exist. | |
result = parent[key]; | |
} | |
} | |
if (obj.children) { | |
include(result, obj.children, clobber, merge); | |
} | |
} catch(e) { | |
utils.alert('Exception building cordova JS globals: ' + e + ' for key "' + key + '"'); | |
} | |
}); | |
} | |
/** | |
* Merge properties from one object onto another recursively. Properties from | |
* the src object will overwrite existing target property. | |
* | |
* @param target Object to merge properties into. | |
* @param src Object to merge properties from. | |
*/ | |
function recursiveMerge(target, src) { | |
for (var prop in src) { | |
if (src.hasOwnProperty(prop)) { | |
if (target.prototype && target.prototype.constructor === target) { | |
// If the target object is a constructor override off prototype. | |
clobber(target.prototype, prop, src[prop]); | |
} else { | |
if (typeof src[prop] === 'object' && typeof target[prop] === 'object') { | |
recursiveMerge(target[prop], src[prop]); | |
} else { | |
clobber(target, prop, src[prop]); | |
} | |
} | |
} | |
} | |
} | |
exports.buildIntoButDoNotClobber = function(objects, target) { | |
include(target, objects, false, false); | |
}; | |
exports.buildIntoAndClobber = function(objects, target) { | |
include(target, objects, true, false); | |
}; | |
exports.buildIntoAndMerge = function(objects, target) { | |
include(target, objects, true, true); | |
}; | |
exports.recursiveMerge = recursiveMerge; | |
exports.assignOrWrapInDeprecateGetter = assignOrWrapInDeprecateGetter; | |
exports.replaceHookForTesting = function() {}; | |
}); | |
// file: lib/common/channel.js | |
define("cordova/channel", function(require, exports, module) { | |
var utils = require('cordova/utils'), | |
nextGuid = 1; | |
/** | |
* Custom pub-sub "channel" that can have functions subscribed to it | |
* This object is used to define and control firing of events for | |
* cordova initialization, as well as for custom events thereafter. | |
* | |
* 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. | |
* onNativeReady* Internal event that indicates the Cordova native side is ready. | |
* onCordovaReady* Internal event fired when all Cordova JavaScript objects have been created. | |
* onCordovaInfoReady* Internal event fired when device properties are available. | |
* onCordovaConnectionReady* Internal event fired when the connection property has been set. | |
* 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 events marked with an * are sticky. Once they have fired, they will stay in the fired state. | |
* All listeners that subscribe after the event is fired will be executed right away. | |
* | |
* 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 | |
* | |
*/ | |
/** | |
* Channel | |
* @constructor | |
* @param type String the channel name | |
*/ | |
var Channel = function(type, sticky) { | |
this.type = type; | |
// Map of guid -> function. | |
this.handlers = {}; | |
// 0 = Non-sticky, 1 = Sticky non-fired, 2 = Sticky fired. | |
this.state = sticky ? 1 : 0; | |
// Used in sticky mode to remember args passed to fire(). | |
this.fireArgs = null; | |
// Used by onHasSubscribersChange to know if there are any listeners. | |
this.numHandlers = 0; | |
// Function that is called when the first listener is subscribed, or when | |
// the last listener is unsubscribed. | |
this.onHasSubscribersChange = null; | |
}, | |
channel = { | |
/** | |
* Calls the provided function only after all of the channels specified | |
* have been fired. All channels must be sticky channels. | |
*/ | |
join: function(h, c) { | |
var len = c.length, | |
i = len, | |
f = function() { | |
if (!(--i)) h(); | |
}; | |
for (var j=0; j<len; j++) { | |
if (c[j].state === 0) { | |
throw Error('Can only use join with sticky channels.'); | |
} | |
c[j].subscribe(f); | |
} | |
if (!len) h(); | |
}, | |
create: function(type) { | |
return channel[type] = new Channel(type, false); | |
}, | |
createSticky: function(type) { | |
return channel[type] = new Channel(type, true); | |
}, | |
/** | |
* cordova Channels that must fire before "deviceready" is fired. | |
*/ | |
deviceReadyChannelsArray: [], | |
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 | |
*/ | |
waitForInitialization: function(feature) { | |
if (feature) { | |
var c = channel[feature] || this.createSticky(feature); | |
this.deviceReadyChannelsMap[feature] = c; | |
this.deviceReadyChannelsArray.push(c); | |
} | |
}, | |
/** | |
* Indicate that initialization code has completed and the feature is ready to be used. | |
* | |
* @param feature {String} The unique feature name | |
*/ | |
initializationComplete: function(feature) { | |
var c = this.deviceReadyChannelsMap[feature]; | |
if (c) { | |
c.fire(); | |
} | |
} | |
}; | |
function forceFunction(f) { | |
if (typeof f != 'function') throw "Function required as first argument!"; | |
} | |
/** | |
* 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. | |
*/ | |
Channel.prototype.subscribe = function(f, c) { | |
// need a function to call | |
forceFunction(f); | |
if (this.state == 2) { | |
f.apply(c || this, this.fireArgs); | |
return; | |
} | |
var func = f, | |
guid = f.observer_guid; | |
if (typeof c == "object") { func = utils.close(c, f); } | |
if (!guid) { | |
// first time any channel has seen this subscriber | |
guid = '' + nextGuid++; | |
} | |
func.observer_guid = guid; | |
f.observer_guid = guid; | |
// Don't add the same handler more than once. | |
if (!this.handlers[guid]) { | |
this.handlers[guid] = func; | |
this.numHandlers++; | |
if (this.numHandlers == 1) { | |
this.onHasSubscribersChange && this.onHasSubscribersChange(); | |
} | |
} | |
}; | |
/** | |
* Unsubscribes the function with the given guid from the channel. | |
*/ | |
Channel.prototype.unsubscribe = function(f) { | |
// need a function to unsubscribe | |
forceFunction(f); | |
var guid = f.observer_guid, | |
handler = this.handlers[guid]; | |
if (handler) { | |
delete this.handlers[guid]; | |
this.numHandlers--; | |
if (this.numHandlers === 0) { | |
this.onHasSubscribersChange && this.onHasSubscribersChange(); | |
} | |
} | |
}; | |
/** | |
* Calls all functions subscribed to this channel. | |
*/ | |
Channel.prototype.fire = function(e) { | |
var fail = false, | |
fireArgs = Array.prototype.slice.call(arguments); | |
// Apply stickiness. | |
if (this.state == 1) { | |
this.state = 2; | |
this.fireArgs = fireArgs; | |
} | |
if (this.numHandlers) { | |
// Copy the values first so that it is safe to modify it from within | |
// callbacks. | |
var toCall = []; | |
for (var item in this.handlers) { | |
toCall.push(this.handlers[item]); | |
} | |
for (var i = 0; i < toCall.length; ++i) { | |
toCall[i].apply(this, fireArgs); | |
} | |
if (this.state == 2 && this.numHandlers) { | |
this.numHandlers = 0; | |
this.handlers = {}; | |
this.onHasSubscribersChange && this.onHasSubscribersChange(); | |
} | |
} | |
}; | |
// defining them here so they are ready super fast! | |
// DOM event that is received when the web page is loaded and parsed. | |
channel.createSticky('onDOMContentLoaded'); | |
// Event to indicate the Cordova native side is ready. | |
channel.createSticky('onNativeReady'); | |
// Event to indicate that all Cordova JavaScript objects have been created | |
// and it's time to run plugin constructors. | |
channel.createSticky('onCordovaReady'); | |
// Event to indicate that device properties are available | |
channel.createSticky('onCordovaInfoReady'); | |
// Event to indicate that the connection property has been set. | |
channel.createSticky('onCordovaConnectionReady'); | |
// Event to indicate that all automatically loaded JS plugins are loaded and ready. | |
channel.createSticky('onPluginsReady'); | |
// Event to indicate that Cordova is ready | |
channel.createSticky('onDeviceReady'); | |
// Event to indicate a resume lifecycle event | |
channel.create('onResume'); | |
// Event to indicate a pause lifecycle event | |
channel.create('onPause'); | |
// Event to indicate a destroy lifecycle event | |
channel.createSticky('onDestroy'); | |
// Channels that must fire before "deviceready" is fired. | |
channel.waitForInitialization('onCordovaReady'); | |
channel.waitForInitialization('onCordovaConnectionReady'); | |
channel.waitForInitialization('onDOMContentLoaded'); | |
module.exports = channel; | |
}); | |
// file: lib/common/commandProxy.js | |
define("cordova/commandProxy", function(require, exports, module) { | |
// internal map of proxy function | |
var CommandProxyMap = {}; | |
module.exports = { | |
// example: cordova.commandProxy.add("Accelerometer",{getCurrentAcceleration: function(successCallback, errorCallback, options) {...},...); | |
add:function(id,proxyObj) { | |
console.log("adding proxy for " + id); | |
CommandProxyMap[id] = proxyObj; | |
return proxyObj; | |
}, | |
// cordova.commandProxy.remove("Accelerometer"); | |
remove:function(id) { | |
var proxy = CommandProxyMap[id]; | |
delete CommandProxyMap[id]; | |
CommandProxyMap[id] = null; | |
return proxy; | |
}, | |
get:function(service,action) { | |
return ( CommandProxyMap[service] ? CommandProxyMap[service][action] : null ); | |
} | |
}; | |
}); | |
// file: lib/windows8/exec.js | |
define("cordova/exec", function(require, exports, module) { | |
var cordova = require('cordova'); | |
var commandProxy = require('cordova/commandProxy'); | |
/** | |
* Execute a cordova command. It is up to the native side whether this action | |
* is synchronous or asynchronous. The native side can return: | |
* Synchronous: PluginResult object as a JSON string | |
* Asynchronous: 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 {String[]} [args] Zero or more arguments to pass to the method | |
*/ | |
module.exports = function(success, fail, service, action, args) { | |
var proxy = commandProxy.get(service,action); | |
if(proxy) { | |
var callbackId = service + cordova.callbackId++; | |
// console.log("EXEC:" + service + " : " + action); | |
if (typeof success == "function" || typeof fail == "function") { | |
cordova.callbacks[callbackId] = {success:success, fail:fail}; | |
} | |
try { | |
proxy(success, fail, args); | |
} | |
catch(e) { | |
console.log("Exception calling native with command :: " + service + " :: " + action + " ::exception=" + e); | |
} | |
} | |
else { | |
fail && fail("Missing Command Error"); | |
} | |
}; | |
}); | |
// file: lib/common/modulemapper.js | |
define("cordova/modulemapper", function(require, exports, module) { | |
var builder = require('cordova/builder'), | |
moduleMap = define.moduleMap, | |
symbolList, | |
deprecationMap; | |
exports.reset = function() { | |
symbolList = []; | |
deprecationMap = {}; | |
}; | |
function addEntry(strategy, moduleName, symbolPath, opt_deprecationMessage) { | |
if (!(moduleName in moduleMap)) { | |
throw new Error('Module ' + moduleName + ' does not exist.'); | |
} | |
symbolList.push(strategy, moduleName, symbolPath); | |
if (opt_deprecationMessage) { | |
deprecationMap[symbolPath] = opt_deprecationMessage; | |
} | |
} | |
// Note: Android 2.3 does have Function.bind(). | |
exports.clobbers = function(moduleName, symbolPath, opt_deprecationMessage) { | |
addEntry('c', moduleName, symbolPath, opt_deprecationMessage); | |
}; | |
exports.merges = function(moduleName, symbolPath, opt_deprecationMessage) { | |
addEntry('m', moduleName, symbolPath, opt_deprecationMessage); | |
}; | |
exports.defaults = function(moduleName, symbolPath, opt_deprecationMessage) { | |
addEntry('d', moduleName, symbolPath, opt_deprecationMessage); | |
}; | |
function prepareNamespace(symbolPath, context) { | |
if (!symbolPath) { | |
return context; | |
} | |
var parts = symbolPath.split('.'); | |
var cur = context; | |
for (var i = 0, part; part = parts[i]; ++i) { | |
cur = cur[part] = cur[part] || {}; | |
} | |
return cur; | |
} | |
exports.mapModules = function(context) { | |
var origSymbols = {}; | |
context.CDV_origSymbols = origSymbols; | |
for (var i = 0, len = symbolList.length; i < len; i += 3) { | |
var strategy = symbolList[i]; | |
var moduleName = symbolList[i + 1]; | |
var symbolPath = symbolList[i + 2]; | |
var lastDot = symbolPath.lastIndexOf('.'); | |
var namespace = symbolPath.substr(0, lastDot); | |
var lastName = symbolPath.substr(lastDot + 1); | |
var module = require(moduleName); | |
var deprecationMsg = symbolPath in deprecationMap ? 'Access made to deprecated symbol: ' + symbolPath + '. ' + deprecationMsg : null; | |
var parentObj = prepareNamespace(namespace, context); | |
var target = parentObj[lastName]; | |
if (strategy == 'm' && target) { | |
builder.recursiveMerge(target, module); | |
} else if ((strategy == 'd' && !target) || (strategy != 'd')) { | |
if (!(symbolPath in origSymbols)) { | |
origSymbols[symbolPath] = target; | |
} | |
builder.assignOrWrapInDeprecateGetter(parentObj, lastName, module, deprecationMsg); | |
} | |
} | |
}; | |
exports.getOriginalSymbol = function(context, symbolPath) { | |
var origSymbols = context.CDV_origSymbols; | |
if (origSymbols && (symbolPath in origSymbols)) { | |
return origSymbols[symbolPath]; | |
} | |
var parts = symbolPath.split('.'); | |
var obj = context; | |
for (var i = 0; i < parts.length; ++i) { | |
obj = obj && obj[parts[i]]; | |
} | |
return obj; | |
}; | |
exports.loadMatchingModules = function(matchingRegExp) { | |
for (var k in moduleMap) { | |
if (matchingRegExp.exec(k)) { | |
require(k); | |
} | |
} | |
}; | |
exports.reset(); | |
}); | |
// file: lib/windows8/platform.js | |
define("cordova/platform", function(require, exports, module) { | |
var cordova = require('cordova'), | |
exec = require('cordova/exec'), | |
channel = cordova.require("cordova/channel"), | |
modulemapper = require('cordova/modulemapper'); | |
/* | |
* Define native implementations ( there is no native layer, so need to make sure the proxies are there ) | |
*/ | |
modulemapper.loadMatchingModules(/cordova.*\/windows8\/.*Proxy$/); | |
module.exports = { | |
id: "windows8", | |
initialize:function() { | |
modulemapper.loadMatchingModules(/cordova.*\/plugininit$/); | |
modulemapper.loadMatchingModules(/cordova.*\/symbols$/); | |
modulemapper.clobbers('cordova/commandProxy', 'cordova.commandProxy'); | |
modulemapper.mapModules(window); | |
var onWinJSReady = function () { | |
var app = WinJS.Application; | |
var checkpointHandler = function checkpointHandler() { | |
cordova.fireDocumentEvent('pause'); | |
}; | |
var resumingHandler = function resumingHandler() { | |
cordova.fireDocumentEvent('resume'); | |
}; | |
app.addEventListener("checkpoint", checkpointHandler); | |
Windows.UI.WebUI.WebUIApplication.addEventListener("resuming", resumingHandler, false); | |
app.start(); | |
}; | |
if (!window.WinJS) { | |
// <script src="//Microsoft.WinJS.1.0/js/base.js"></script> | |
var scriptElem = document.createElement("script"); | |
scriptElem.src = "//Microsoft.WinJS.1.0/js/base.js"; | |
scriptElem.addEventListener("load", onWinJSReady); | |
document.head.appendChild(scriptElem); | |
console.log("added WinJS ... "); | |
} | |
else { | |
onWinJSReady(); | |
} | |
} | |
}; | |
}); | |
// file: lib/common/plugin/Acceleration.js | |
define("cordova/plugin/Acceleration", function(require, exports, module) { | |
var Acceleration = function(x, y, z, timestamp) { | |
this.x = x; | |
this.y = y; | |
this.z = z; | |
this.timestamp = timestamp || (new Date()).getTime(); | |
}; | |
module.exports = Acceleration; | |
}); | |
// file: lib/common/plugin/Camera.js | |
define("cordova/plugin/Camera", function(require, exports, module) { | |
var argscheck = require('cordova/argscheck'), | |
exec = require('cordova/exec'), | |
Camera = require('cordova/plugin/CameraConstants'), | |
CameraPopoverHandle = require('cordova/plugin/CameraPopoverHandle'); | |
var cameraExport = {}; | |
// Tack on the Camera Constants to the base camera plugin. | |
for (var key in Camera) { | |
cameraExport[key] = Camera[key]; | |
} | |
/** | |
* 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=FILE_URI. | |
* | |
* @param {Function} successCallback | |
* @param {Function} errorCallback | |
* @param {Object} options | |
*/ | |
cameraExport.getPicture = function(successCallback, errorCallback, options) { | |
argscheck.checkArgs('fFO', 'Camera.getPicture', arguments); | |
options = options || {}; | |
var getValue = argscheck.getValue; | |
var quality = getValue(options.quality, 50); | |
var destinationType = getValue(options.destinationType, Camera.DestinationType.FILE_URI); | |
var sourceType = getValue(options.sourceType, Camera.PictureSourceType.CAMERA); | |
var targetWidth = getValue(options.targetWidth, -1); | |
var targetHeight = getValue(options.targetHeight, -1); | |
var encodingType = getValue(options.encodingType, Camera.EncodingType.JPEG); | |
var mediaType = getValue(options.mediaType, Camera.MediaType.PICTURE); | |
var allowEdit = !!options.allowEdit; | |
var correctOrientation = !!options.correctOrientation; | |
var saveToPhotoAlbum = !!options.saveToPhotoAlbum; | |
var popoverOptions = getValue(options.popoverOptions, null); | |
var cameraDirection = getValue(options.cameraDirection, Camera.Direction.BACK); | |
var args = [quality, destinationType, sourceType, targetWidth, targetHeight, encodingType, | |
mediaType, allowEdit, correctOrientation, saveToPhotoAlbum, popoverOptions, cameraDirection]; | |
exec(successCallback, errorCallback, "Camera", "takePicture", args); | |
return new CameraPopoverHandle(); | |
}; | |
cameraExport.cleanup = function(successCallback, errorCallback) { | |
exec(successCallback, errorCallback, "Camera", "cleanup", []); | |
}; | |
module.exports = cameraExport; | |
}); | |
// file: lib/common/plugin/CameraConstants.js | |
define("cordova/plugin/CameraConstants", function(require, exports, module) { | |
module.exports = { | |
DestinationType:{ | |
DATA_URL: 0, // Return base64 encoded string | |
FILE_URI: 1, // Return file uri (content://media/external/images/media/2 for Android) | |
NATIVE_URI: 2 // Return native uri (eg. asset-library://... for iOS) | |
}, | |
EncodingType:{ | |
JPEG: 0, // Return JPEG encoded image | |
PNG: 1 // Return PNG encoded image | |
}, | |
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 | |
}, | |
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) | |
}, | |
PopoverArrowDirection:{ | |
ARROW_UP : 1, // matches iOS UIPopoverArrowDirection constants to specify arrow location on popover | |
ARROW_DOWN : 2, | |
ARROW_LEFT : 4, | |
ARROW_RIGHT : 8, | |
ARROW_ANY : 15 | |
}, | |
Direction:{ | |
BACK: 0, | |
FRONT: 1 | |
} | |
}; | |
}); | |
// file: lib/common/plugin/CameraPopoverHandle.js | |
define("cordova/plugin/CameraPopoverHandle", function(require, exports, module) { | |
var exec = require('cordova/exec'); | |
/** | |
* A handle to an image picker popover. | |
*/ | |
var CameraPopoverHandle = function() { | |
this.setPosition = function(popoverOptions) { | |
console.log('CameraPopoverHandle.setPosition is only supported on iOS.'); | |
}; | |
}; | |
module.exports = CameraPopoverHandle; | |
}); | |
// file: lib/common/plugin/CameraPopoverOptions.js | |
define("cordova/plugin/CameraPopoverOptions", function(require, exports, module) { | |
var Camera = require('cordova/plugin/CameraConstants'); | |
/** | |
* Encapsulates options for iOS Popover image picker | |
*/ | |
var CameraPopoverOptions = function(x,y,width,height,arrowDir){ | |
// information of rectangle that popover should be anchored to | |
this.x = x || 0; | |
this.y = y || 32; | |
this.width = width || 320; | |
this.height = height || 480; | |
// The direction of the popover arrow | |
this.arrowDir = arrowDir || Camera.PopoverArrowDirection.ARROW_ANY; | |
}; | |
module.exports = CameraPopoverOptions; | |
}); | |
// file: lib/common/plugin/CaptureAudioOptions.js | |
define("cordova/plugin/CaptureAudioOptions", function(require, exports, module) { | |
/** | |
* 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; | |
}; | |
module.exports = CaptureAudioOptions; | |
}); | |
// file: lib/common/plugin/CaptureError.js | |
define("cordova/plugin/CaptureError", function(require, exports, module) { | |
/** | |
* The CaptureError interface encapsulates all errors in the Capture API. | |
*/ | |
var CaptureError = function(c) { | |
this.code = c || null; | |
}; | |
// Camera or microphone failed to capture image or sound. | |
CaptureError.CAPTURE_INTERNAL_ERR = 0; | |
// Camera application or audio capture application is currently serving other capture request. | |
CaptureError.CAPTURE_APPLICATION_BUSY = 1; | |
// Invalid use of the API (e.g. limit parameter has value less than one). | |
CaptureError.CAPTURE_INVALID_ARGUMENT = 2; | |
// User exited camera application or audio capture application before capturing anything. | |
CaptureError.CAPTURE_NO_MEDIA_FILES = 3; | |
// The requested capture operation is not supported. | |
CaptureError.CAPTURE_NOT_SUPPORTED = 20; | |
module.exports = CaptureError; | |
}); | |
// file: lib/common/plugin/CaptureImageOptions.js | |
define("cordova/plugin/CaptureImageOptions", function(require, exports, module) { | |
/** | |
* 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; | |
}; | |
module.exports = CaptureImageOptions; | |
}); | |
// file: lib/common/plugin/CaptureVideoOptions.js | |
define("cordova/plugin/CaptureVideoOptions", function(require, exports, module) { | |
/** | |
* 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; | |
}; | |
module.exports = CaptureVideoOptions; | |
}); | |
// file: lib/common/plugin/CompassError.js | |
define("cordova/plugin/CompassError", function(require, exports, module) { | |
/** | |
* CompassError. | |
* An error code assigned by an implementation when an error has occurred | |
* @constructor | |
*/ | |
var CompassError = function(err) { | |
this.code = (err !== undefined ? err : null); | |
}; | |
CompassError.COMPASS_INTERNAL_ERR = 0; | |
CompassError.COMPASS_NOT_SUPPORTED = 20; | |
module.exports = CompassError; | |
}); | |
// file: lib/common/plugin/CompassHeading.js | |
define("cordova/plugin/CompassHeading", function(require, exports, module) { | |
var CompassHeading = function(magneticHeading, trueHeading, headingAccuracy, timestamp) { | |
this.magneticHeading = magneticHeading; | |
this.trueHeading = trueHeading; | |
this.headingAccuracy = headingAccuracy; | |
this.timestamp = timestamp || new Date().getTime(); | |
}; | |
module.exports = CompassHeading; | |
}); | |
// file: lib/common/plugin/ConfigurationData.js | |
define("cordova/plugin/ConfigurationData", function(require, exports, module) { | |
/** | |
* Encapsulates a set of parameters that the capture device supports. | |
*/ | |
function ConfigurationData() { | |
// 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; | |
} | |
module.exports = ConfigurationData; | |
}); | |
// file: lib/common/plugin/Connection.js | |
define("cordova/plugin/Connection", function(require, exports, module) { | |
/** | |
* Network status | |
*/ | |
module.exports = { | |
UNKNOWN: "unknown", | |
ETHERNET: "ethernet", | |
WIFI: "wifi", | |
CELL_2G: "2g", | |
CELL_3G: "3g", | |
CELL_4G: "4g", | |
CELL:"cellular", | |
NONE: "none" | |
}; | |
}); | |
// file: lib/common/plugin/Contact.js | |
define("cordova/plugin/Contact", function(require, exports, module) { | |
var argscheck = require('cordova/argscheck'), | |
exec = require('cordova/exec'), | |
ContactError = require('cordova/plugin/ContactError'), | |
utils = require('cordova/utils'); | |
/** | |
* Converts primitives into Complex Object | |
* Currently only used for Date fields | |
*/ | |
function convertIn(contact) { | |
var value = contact.birthday; | |
try { | |
contact.birthday = new Date(parseFloat(value)); | |
} catch (exception){ | |
console.log("Cordova Contact convertIn error: exception creating date."); | |
} | |
return contact; | |
} | |
/** | |
* Converts Complex objects into primitives | |
* Only conversion at present is for Dates. | |
**/ | |
function convertOut(contact) { | |
var value = contact.birthday; | |
if (value !== null) { | |
// try to make it a Date object if it is not already | |
if (!utils.isDate(value)){ | |
try { | |
value = new Date(value); | |
} catch(exception){ | |
value = null; | |
} | |
} | |
if (utils.isDate(value)){ | |
value = value.valueOf(); // convert to milliseconds | |
} | |
contact.birthday = value; | |
} | |
return contact; | |
} | |
/** | |
* Contains information about a single contact. | |
* @constructor | |
* @param {DOMString} id unique identifier | |
* @param {DOMString} displayName | |
* @param {ContactName} name | |
* @param {DOMString} nickname | |
* @param {Array.<ContactField>} phoneNumbers array of phone numbers | |
* @param {Array.<ContactField>} emails array of email addresses | |
* @param {Array.<ContactAddress>} addresses array of addresses | |
* @param {Array.<ContactField>} ims instant messaging user ids | |
* @param {Array.<ContactOrganization>} organizations | |
* @param {DOMString} birthday contact's birthday | |
* @param {DOMString} note user notes about contact | |
* @param {Array.<ContactField>} photos | |
* @param {Array.<ContactField>} categories | |
* @param {Array.<ContactField>} 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[] | |
}; | |
/** | |
* Removes contact from device storage. | |
* @param successCB success callback | |
* @param errorCB error callback | |
*/ | |
Contact.prototype.remove = function(successCB, errorCB) { | |
argscheck.checkArgs('FF', 'Contact.remove', arguments); | |
var fail = errorCB && function(code) { | |
errorCB(new ContactError(code)); | |
}; | |
if (this.id === null) { | |
fail(ContactError.UNKNOWN_ERROR); | |
} | |
else { | |
exec(successCB, fail, "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 = utils.clone(this); | |
clonedContact.id = null; | |
clonedContact.rawId = null; | |
function nullIds(arr) { | |
if (arr) { | |
for (var i = 0; i < arr.length; ++i) { | |
arr[i].id = null; | |
} | |
} | |
} | |
// Loop through and clear out any id's in phones, emails, etc. | |
nullIds(clonedContact.phoneNumbers); | |
nullIds(clonedContact.emails); | |
nullIds(clonedContact.addresses); | |
nullIds(clonedContact.ims); | |
nullIds(clonedContact.organizations); | |
nullIds(clonedContact.categories); | |
nullIds(clonedContact.photos); | |
nullIds(clonedContact.urls); | |
return clonedContact; | |
}; | |
/** | |
* Persists contact to device storage. | |
* @param successCB success callback | |
* @param errorCB error callback | |
*/ | |
Contact.prototype.save = function(successCB, errorCB) { | |
argscheck.checkArgs('FFO', 'Contact.save', arguments); | |
var fail = errorCB && function(code) { | |
errorCB(new ContactError(code)); | |
}; | |
var success = function(result) { | |
if (result) { | |
if (successCB) { | |
var fullContact = require('cordova/plugin/contacts').create(result); | |
successCB(convertIn(fullContact)); | |
} | |
} | |
else { | |
// no Entry object returned | |
fail(ContactError.UNKNOWN_ERROR); | |
} | |
}; | |
var dupContact = convertOut(utils.clone(this)); | |
exec(success, fail, "Contacts", "save", [dupContact]); | |
}; | |
module.exports = Contact; | |
}); | |
// file: lib/common/plugin/ContactAddress.js | |
define("cordova/plugin/ContactAddress", function(require, exports, module) { | |
/** | |
* Contact address. | |
* @constructor | |
* @param {DOMString} id unique identifier, should only be set by native code | |
* @param formatted // NOTE: not a W3C standard | |
* @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 = (typeof pref != 'undefined' ? pref : false); | |
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; | |
}; | |
module.exports = ContactAddress; | |
}); | |
// file: lib/common/plugin/ContactError.js | |
define("cordova/plugin/ContactError", function(require, exports, module) { | |
/** | |
* ContactError. | |
* An error code assigned by an implementation when an error has occurred | |
* @constructor | |
*/ | |
var ContactError = function(err) { | |
this.code = (typeof err != 'undefined' ? err : 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; | |
module.exports = ContactError; | |
}); | |
// file: lib/common/plugin/ContactField.js | |
define("cordova/plugin/ContactField", function(require, exports, module) { | |
/** | |
* Generic contact field. | |
* @constructor | |
* @param {DOMString} id unique identifier, should only be set by native code // NOTE: not a W3C standard | |
* @param type | |
* @param value | |
* @param pref | |
*/ | |
var ContactField = function(type, value, pref) { | |
this.id = null; | |
this.type = (type && type.toString()) || null; | |
this.value = (value && value.toString()) || null; | |
this.pref = (typeof pref != 'undefined' ? pref : false); | |
}; | |
module.exports = ContactField; | |
}); | |
// file: lib/common/plugin/ContactFindOptions.js | |
define("cordova/plugin/ContactFindOptions", function(require, exports, module) { | |
/** | |
* ContactFindOptions. | |
* @constructor | |
* @param filter used to match contacts against | |
* @param multiple boolean used to determine if more than one contact should be returned | |
*/ | |
var ContactFindOptions = function(filter, multiple) { | |
this.filter = filter || ''; | |
this.multiple = (typeof multiple != 'undefined' ? multiple : false); | |
}; | |
module.exports = ContactFindOptions; | |
}); | |
// file: lib/common/plugin/ContactName.js | |
define("cordova/plugin/ContactName", function(require, exports, module) { | |
/** | |
* Contact name. | |
* @constructor | |
* @param formatted // NOTE: not part of W3C standard | |
* @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; | |
}; | |
module.exports = ContactName; | |
}); | |
// file: lib/common/plugin/ContactOrganization.js | |
define("cordova/plugin/ContactOrganization", function(require, exports, module) { | |
/** | |
* Contact organization. | |
* @constructor | |
* @param {DOMString} id unique identifier, should only be set by native code // NOTE: not a W3C standard | |
* @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 = (typeof pref != 'undefined' ? pref : false); | |
this.type = type || null; | |
this.name = name || null; | |
this.department = dept || null; | |
this.title = title || null; | |
}; | |
module.exports = ContactOrganization; | |
}); | |
// file: lib/common/plugin/Coordinates.js | |
define("cordova/plugin/Coordinates", function(require, exports, module) { | |
/** | |
* This class contains position information. | |
* @param {Object} lat | |
* @param {Object} lng | |
* @param {Object} alt | |
* @param {Object} acc | |
* @param {Object} head | |
* @param {Object} vel | |
* @param {Object} altacc | |
* @constructor | |
*/ | |
var Coordinates = function(lat, lng, alt, acc, head, vel, altacc) { | |
/** | |
* The latitude of the position. | |
*/ | |
this.latitude = lat; | |
/** | |
* The longitude of the position, | |
*/ | |
this.longitude = lng; | |
/** | |
* The accuracy of the position. | |
*/ | |
this.accuracy = acc; | |
/** | |
* The altitude of the position. | |
*/ | |
this.altitude = (alt !== undefined ? alt : null); | |
/** | |
* The direction the device is moving at the position. | |
*/ | |
this.heading = (head !== undefined ? head : null); | |
/** | |
* The velocity with which the device is moving at the position. | |
*/ | |
this.speed = (vel !== undefined ? vel : null); | |
if (this.speed === 0 || this.speed === null) { | |
this.heading = NaN; | |
} | |
/** | |
* The altitude accuracy of the position. | |
*/ | |
this.altitudeAccuracy = (altacc !== undefined) ? altacc : null; | |
}; | |
module.exports = Coordinates; | |
}); | |
// file: lib/common/plugin/DirectoryEntry.js | |
define("cordova/plugin/DirectoryEntry", function(require, exports, module) { | |
var argscheck = require('cordova/argscheck'), | |
utils = require('cordova/utils'), | |
exec = require('cordova/exec'), | |
Entry = require('cordova/plugin/Entry'), | |
FileError = require('cordova/plugin/FileError'), | |
DirectoryReader = require('cordova/plugin/DirectoryReader'); | |
/** | |
* An interface representing a directory on the file system. | |
* | |
* {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) | |
* TODO: implement this!!! {FileSystem} filesystem on which the directory resides (readonly) | |
*/ | |
var DirectoryEntry = function(name, fullPath) { | |
DirectoryEntry.__super__.constructor.call(this, false, true, name, fullPath); | |
}; | |
utils.extend(DirectoryEntry, Entry); | |
/** | |
* Creates a new DirectoryReader to read entries from this directory | |
*/ | |
DirectoryEntry.prototype.createReader = function() { | |
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 exclusively 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) { | |
argscheck.checkArgs('sOFF', 'DirectoryEntry.getDirectory', arguments); | |
var win = successCallback && function(result) { | |
var entry = new DirectoryEntry(result.name, result.fullPath); | |
successCallback(entry); | |
}; | |
var fail = errorCallback && function(code) { | |
errorCallback(new FileError(code)); | |
}; | |
exec(win, fail, "File", "getDirectory", [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) { | |
argscheck.checkArgs('FF', 'DirectoryEntry.removeRecursively', arguments); | |
var fail = errorCallback && function(code) { | |
errorCallback(new FileError(code)); | |
}; | |
exec(successCallback, fail, "File", "removeRecursively", [this.fullPath]); | |
}; | |
/** | |
* 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 exclusively 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) { | |
argscheck.checkArgs('sOFF', 'DirectoryEntry.getFile', arguments); | |
var win = successCallback && function(result) { | |
var FileEntry = require('cordova/plugin/FileEntry'); | |
var entry = new FileEntry(result.name, result.fullPath); | |
successCallback(entry); | |
}; | |
var fail = errorCallback && function(code) { | |
errorCallback(new FileError(code)); | |
}; | |
exec(win, fail, "File", "getFile", [this.fullPath, path, options]); | |
}; | |
module.exports = DirectoryEntry; | |
}); | |
// file: lib/common/plugin/DirectoryReader.js | |
define("cordova/plugin/DirectoryReader", function(require, exports, module) { | |
var exec = require('cordova/exec'), | |
FileError = require('cordova/plugin/FileError') ; | |
/** | |
* An interface that lists the files and directories in a directory. | |
*/ | |
function DirectoryReader(path) { | |
this.path = path || 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) { | |
var win = typeof successCallback !== 'function' ? null : function(result) { | |
var retVal = []; | |
for (var i=0; i<result.length; i++) { | |
var entry = null; | |
if (result[i].isDirectory) { | |
entry = new (require('cordova/plugin/DirectoryEntry'))(); | |
} | |
else if (result[i].isFile) { | |
entry = new (require('cordova/plugin/FileEntry'))(); | |
} | |
entry.isDirectory = result[i].isDirectory; | |
entry.isFile = result[i].isFile; | |
entry.name = result[i].name; | |
entry.fullPath = result[i].fullPath; | |
retVal.push(entry); | |
} | |
successCallback(retVal); | |
}; | |
var fail = typeof errorCallback !== 'function' ? null : function(code) { | |
errorCallback(new FileError(code)); | |
}; | |
exec(win, fail, "File", "readEntries", [this.path]); | |
}; | |
module.exports = DirectoryReader; | |
}); | |
// file: lib/common/plugin/Entry.js | |
define("cordova/plugin/Entry", function(require, exports, module) { | |
var argscheck = require('cordova/argscheck'), | |
exec = require('cordova/exec'), | |
FileError = require('cordova/plugin/FileError'), | |
Metadata = require('cordova/plugin/Metadata'); | |
/** | |
* Represents a file or directory on the local file system. | |
* | |
* @param isFile | |
* {boolean} true if Entry is a file (readonly) | |
* @param isDirectory | |
* {boolean} true if Entry is a directory (readonly) | |
* @param name | |
* {DOMString} name of the file or directory, excluding the path | |
* leading to it (readonly) | |
* @param fullPath | |
* {DOMString} the absolute full path to the file or directory | |
* (readonly) | |
*/ | |
function Entry(isFile, isDirectory, name, fullPath, fileSystem) { | |
this.isFile = !!isFile; | |
this.isDirectory = !!isDirectory; | |
this.name = name || ''; | |
this.fullPath = fullPath || ''; | |
this.filesystem = fileSystem || null; | |
} | |
/** | |
* Look up the metadata of the entry. | |
* | |
* @param successCallback | |
* {Function} is called with a Metadata object | |
* @param errorCallback | |
* {Function} is called with a FileError | |
*/ | |
Entry.prototype.getMetadata = function(successCallback, errorCallback) { | |
argscheck.checkArgs('FF', 'Entry.getMetadata', arguments); | |
var success = successCallback && function(lastModified) { | |
var metadata = new Metadata(lastModified); | |
successCallback(metadata); | |
}; | |
var fail = errorCallback && function(code) { | |
errorCallback(new FileError(code)); | |
}; | |
exec(success, fail, "File", "getMetadata", [this.fullPath]); | |
}; | |
/** | |
* Set the metadata of the entry. | |
* | |
* @param successCallback | |
* {Function} is called with a Metadata object | |
* @param errorCallback | |
* {Function} is called with a FileError | |
* @param metadataObject | |
* {Object} keys and values to set | |
*/ | |
Entry.prototype.setMetadata = function(successCallback, errorCallback, metadataObject) { | |
argscheck.checkArgs('FFO', 'Entry.setMetadata', arguments); | |
exec(successCallback, errorCallback, "File", "setMetadata", [this.fullPath, metadataObject]); | |
}; | |
/** | |
* Move a file or directory to a new location. | |
* | |
* @param parent | |
* {DirectoryEntry} the directory to which to move this entry | |
* @param newName | |
* {DOMString} new name of the entry, defaults to the current name | |
* @param successCallback | |
* {Function} called with the new DirectoryEntry object | |
* @param errorCallback | |
* {Function} called with a FileError | |
*/ | |
Entry.prototype.moveTo = function(parent, newName, successCallback, errorCallback) { | |
argscheck.checkArgs('oSFF', 'Entry.moveTo', arguments); | |
var fail = errorCallback && function(code) { | |
errorCallback(new FileError(code)); | |
}; | |
// source path | |
var srcPath = this.fullPath, | |
// entry name | |
name = newName || this.name, | |
success = function(entry) { | |
if (entry) { | |
if (successCallback) { | |
// create appropriate Entry object | |
var result = (entry.isDirectory) ? new (require('cordova/plugin/DirectoryEntry'))(entry.name, entry.fullPath) : new (require('cordova/plugin/FileEntry'))(entry.name, entry.fullPath); | |
successCallback(result); | |
} | |
} | |
else { | |
// no Entry object returned | |
fail && fail(FileError.NOT_FOUND_ERR); | |
} | |
}; | |
// copy | |
exec(success, fail, "File", "moveTo", [srcPath, parent.fullPath, name]); | |
}; | |
/** | |
* Copy a directory to a different location. | |
* | |
* @param parent | |
* {DirectoryEntry} the directory to which to copy the entry | |
* @param newName | |
* {DOMString} new name of the entry, defaults to the current name | |
* @param successCallback | |
* {Function} called with the new Entry object | |
* @param errorCallback | |
* {Function} called with a FileError | |
*/ | |
Entry.prototype.copyTo = function(parent, newName, successCallback, errorCallback) { | |
argscheck.checkArgs('oSFF', 'Entry.copyTo', arguments); | |
var fail = errorCallback && function(code) { | |
errorCallback(new FileError(code)); | |
}; | |
// source path | |
var srcPath = this.fullPath, | |
// entry name | |
name = newName || this.name, | |
// success callback | |
success = function(entry) { | |
if (entry) { | |
if (successCallback) { | |
// create appropriate Entry object | |
var result = (entry.isDirectory) ? new (require('cordova/plugin/DirectoryEntry'))(entry.name, entry.fullPath) : new (require('cordova/plugin/FileEntry'))(entry.name, entry.fullPath); | |
successCallback(result); | |
} | |
} | |
else { | |
// no Entry object returned | |
fail && fail(FileError.NOT_FOUND_ERR); | |
} | |
}; | |
// copy | |
exec(success, fail, "File", "copyTo", [srcPath, parent.fullPath, name]); | |
}; | |
/** | |
* Return a URL that can be used to identify this entry. | |
*/ | |
Entry.prototype.toURL = function() { | |
// fullPath attribute contains the full URL | |
return 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 | |
*/ | |
Entry.prototype.toURI = function(mimeType) { | |
console.log("DEPRECATED: Update your code to use 'toURL'"); | |
// fullPath attribute contains the full URI | |
return this.toURL(); | |
}; | |
/** | |
* Remove a file or directory. It is an error to attempt to delete a | |
* directory that is not empty. It is an error to attempt to delete a | |
* root directory of a file system. | |
* | |
* @param successCallback {Function} called with no parameters | |
* @param errorCallback {Function} called with a FileError | |
*/ | |
Entry.prototype.remove = function(successCallback, errorCallback) { | |
argscheck.checkArgs('FF', 'Entry.remove', arguments); | |
var fail = errorCallback && function(code) { | |
errorCallback(new FileError(code)); | |
}; | |
exec(successCallback, fail, "File", "remove", [this.fullPath]); | |
}; | |
/** | |
* Look up the parent DirectoryEntry of this entry. | |
* | |
* @param successCallback {Function} called with the parent DirectoryEntry object | |
* @param errorCallback {Function} called with a FileError | |
*/ | |
Entry.prototype.getParent = function(successCallback, errorCallback) { | |
argscheck.checkArgs('FF', 'Entry.getParent', arguments); | |
var win = successCallback && function(result) { | |
var DirectoryEntry = require('cordova/plugin/DirectoryEntry'); | |
var entry = new DirectoryEntry(result.name, result.fullPath); | |
successCallback(entry); | |
}; | |
var fail = errorCallback && function(code) { | |
errorCallback(new FileError(code)); | |
}; | |
exec(win, fail, "File", "getParent", [this.fullPath]); | |
}; | |
module.exports = Entry; | |
}); | |
// file: lib/common/plugin/File.js | |
define("cordova/plugin/File", function(require, exports, module) { | |
/** | |
* Constructor. | |
* 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 File = function(name, fullPath, type, lastModifiedDate, size){ | |
this.name = name || ''; | |
this.fullPath = fullPath || null; | |
this.type = type || null; | |
this.lastModifiedDate = lastModifiedDate || null; | |
this.size = size || 0; | |
// These store the absolute start and end for slicing the file. | |
this.start = 0; | |
this.end = this.size; | |
}; | |
/** | |
* Returns a "slice" of the file. Since Cordova Files don't contain the actual | |
* content, this really returns a File with adjusted start and end. | |
* Slices of slices are supported. | |
* start {Number} The index at which to start the slice (inclusive). | |
* end {Number} The index at which to end the slice (exclusive). | |
*/ | |
File.prototype.slice = function(start, end) { | |
var size = this.end - this.start; | |
var newStart = 0; | |
var newEnd = size; | |
if (arguments.length) { | |
if (start < 0) { | |
newStart = Math.max(size + start, 0); | |
} else { | |
newStart = Math.min(size, start); | |
} | |
} | |
if (arguments.length >= 2) { | |
if (end < 0) { | |
newEnd = Math.max(size + end, 0); | |
} else { | |
newEnd = Math.min(end, size); | |
} | |
} | |
var newFile = new File(this.name, this.fullPath, this.type, this.lastModifiedData, this.size); | |
newFile.start = this.start + newStart; | |
newFile.end = this.start + newEnd; | |
return newFile; | |
}; | |
module.exports = File; | |
}); | |
// file: lib/common/plugin/FileEntry.js | |
define("cordova/plugin/FileEntry", function(require, exports, module) { | |
var utils = require('cordova/utils'), | |
exec = require('cordova/exec'), | |
Entry = require('cordova/plugin/Entry'), | |
FileWriter = require('cordova/plugin/FileWriter'), | |
File = require('cordova/plugin/File'), | |
FileError = require('cordova/plugin/FileError'); | |
/** | |
* An interface representing a file on the file system. | |
* | |
* {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 file resides (readonly) | |
*/ | |
var FileEntry = function(name, fullPath) { | |
FileEntry.__super__.constructor.apply(this, [true, false, name, fullPath]); | |
}; | |
utils.extend(FileEntry, Entry); | |
/** | |
* 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 === "") { | |
errorCallback && errorCallback(new FileError(FileError.INVALID_STATE_ERR)); | |
} else { | |
successCallback && 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) { | |
var win = successCallback && function(f) { | |
var file = new File(f.name, f.fullPath, f.type, f.lastModifiedDate, f.size); | |
successCallback(file); | |
}; | |
var fail = errorCallback && function(code) { | |
errorCallback(new FileError(code)); | |
}; | |
exec(win, fail, "File", "getFileMetadata", [this.fullPath]); | |
}; | |
module.exports = FileEntry; | |
}); | |
// file: lib/common/plugin/FileError.js | |
define("cordova/plugin/FileError", function(require, exports, module) { | |
/** | |
* FileError | |
*/ | |
function FileError(error) { | |
this.code = error || null; | |
} | |
// File error codes | |
// Found in DOMException | |
FileError.NOT_FOUND_ERR = 1; | |
FileError.SECURITY_ERR = 2; | |
FileError.ABORT_ERR = 3; | |
// Added by File API specification | |
FileError.NOT_READABLE_ERR = 4; | |
FileError.ENCODING_ERR = 5; | |
FileError.NO_MODIFICATION_ALLOWED_ERR = 6; | |
FileError.INVALID_STATE_ERR = 7; | |
FileError.SYNTAX_ERR = 8; | |
FileError.INVALID_MODIFICATION_ERR = 9; | |
FileError.QUOTA_EXCEEDED_ERR = 10; | |
FileError.TYPE_MISMATCH_ERR = 11; | |
FileError.PATH_EXISTS_ERR = 12; | |
module.exports = FileError; | |
}); | |
// file: lib/common/plugin/FileReader.js | |
define("cordova/plugin/FileReader", function(require, exports, module) { | |
var exec = require('cordova/exec'), | |
modulemapper = require('cordova/modulemapper'), | |
utils = require('cordova/utils'), | |
File = require('cordova/plugin/File'), | |
FileError = require('cordova/plugin/FileError'), | |
ProgressEvent = require('cordova/plugin/ProgressEvent'), | |
origFileReader = modulemapper.getOriginalSymbol(this, 'FileReader'); | |
/** | |
* This class reads the mobile device file system. | |
* | |
* For Android: | |
* The root directory is the root of the file system. | |
* To read from the SD card, the file name is "sdcard/my_file.txt" | |
* @constructor | |
*/ | |
var FileReader = function() { | |
this._readyState = 0; | |
this._error = null; | |
this._result = null; | |
this._fileName = ''; | |
this._realReader = origFileReader ? new origFileReader() : {}; | |
}; | |
// States | |
FileReader.EMPTY = 0; | |
FileReader.LOADING = 1; | |
FileReader.DONE = 2; | |
utils.defineGetter(FileReader.prototype, 'readyState', function() { | |
return this._fileName ? this._readyState : this._realReader.readyState; | |
}); | |
utils.defineGetter(FileReader.prototype, 'error', function() { | |
return this._fileName ? this._error: this._realReader.error; | |
}); | |
utils.defineGetter(FileReader.prototype, 'result', function() { | |
return this._fileName ? this._result: this._realReader.result; | |
}); | |
function defineEvent(eventName) { | |
utils.defineGetterSetter(FileReader.prototype, eventName, function() { | |
return this._realReader[eventName] || null; | |
}, function(value) { | |
this._realReader[eventName] = value; | |
}); | |
} | |
defineEvent('onloadstart'); // When the read starts. | |
defineEvent('onprogress'); // While reading (and decoding) file or fileBlob data, and reporting partial file data (progress.loaded/progress.total) | |
defineEvent('onload'); // When the read has successfully completed. | |
defineEvent('onerror'); // When the read has failed (see errors). | |
defineEvent('onloadend'); // When the request has completed (either in success or failure). | |
defineEvent('onabort'); // When the read has been aborted. For instance, by invoking the abort() method. | |
function initRead(reader, file) { | |
// Already loading something | |
if (reader.readyState == FileReader.LOADING) { | |
throw new FileError(FileError.INVALID_STATE_ERR); | |
} | |
reader._result = null; | |
reader._error = null; | |
reader._readyState = FileReader.LOADING; | |
if (typeof file.fullPath == 'string') { | |
reader._fileName = file.fullPath; | |
} else { | |
reader._fileName = ''; | |
return true; | |
} | |
reader.onloadstart && reader.onloadstart(new ProgressEvent("loadstart", {target:reader})); | |
} | |
/** | |
* Abort reading file. | |
*/ | |
FileReader.prototype.abort = function() { | |
if (origFileReader && !this._fileName) { | |
return this._realReader.abort(); | |
} | |
this._result = null; | |
if (this._readyState == FileReader.DONE || this._readyState == FileReader.EMPTY) { | |
return; | |
} | |
this._readyState = FileReader.DONE; | |
// If abort callback | |
if (typeof this.onabort === 'function') { | |
this.onabort(new ProgressEvent('abort', {target:this})); | |
} | |
// If load end callback | |
if (typeof this.onloadend === 'function') { | |
this.onloadend(new ProgressEvent('loadend', {target:this})); | |
} | |
}; | |
/** | |
* Read text file. | |
* | |
* @param file {File} File object containing file properties | |
* @param encoding [Optional] (see http://www.iana.org/assignments/character-sets) | |
*/ | |
FileReader.prototype.readAsText = function(file, encoding) { | |
if (initRead(this, file)) { | |
return this._realReader.readAsText(file, encoding); | |
} | |
// Default encoding is UTF-8 | |
var enc = encoding ? encoding : "UTF-8"; | |
var me = this; | |
var execArgs = [this._fileName, enc, file.start, file.end]; | |
// Read file | |
exec( | |
// Success callback | |
function(r) { | |
// 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(new ProgressEvent("load", {target:me})); | |
} | |
// DONE state | |
me._readyState = FileReader.DONE; | |
// If onloadend callback | |
if (typeof me.onloadend === "function") { | |
me.onloadend(new ProgressEvent("loadend", {target:me})); | |
} | |
}, | |
// Error callback | |
function(e) { | |
// If DONE (cancelled), then don't do anything | |
if (me._readyState === FileReader.DONE) { | |
return; | |
} | |
// DONE state | |
me._readyState = FileReader.DONE; | |
// null result | |
me._result = null; | |
// Save error | |
me._error = new FileError(e); | |
// If onerror callback | |
if (typeof me.onerror === "function") { | |
me.onerror(new ProgressEvent("error", {target:me})); | |
} | |
// If onloadend callback | |
if (typeof me.onloadend === "function") { | |
me.onloadend(new ProgressEvent("loadend", {target:me})); | |
} | |
}, "File", "readAsText", execArgs); | |
}; | |
/** | |
* Read file and return data as a base64 encoded data url. | |
* A data url is of the form: | |
* data:[<mediatype>][;base64],<data> | |
* | |
* @param file {File} File object containing file properties | |
*/ | |
FileReader.prototype.readAsDataURL = function(file) { | |
if (initRead(this, file)) { | |
return this._realReader.readAsDataURL(file); | |
} | |
var me = this; | |
var execArgs = [this._fileName, file.start, file.end]; | |
// Read file | |
exec( | |
// Success callback | |
function(r) { | |
// If DONE (cancelled), then don't do anything | |
if (me._readyState === FileReader.DONE) { | |
return; | |
} | |
// DONE state | |
me._readyState = FileReader.DONE; | |
// Save result | |
me._result = r; | |
// If onload callback | |
if (typeof me.onload === "function") { | |
me.onload(new ProgressEvent("load", {target:me})); | |
} | |
// If onloadend callback | |
if (typeof me.onloadend === "function") { | |
me.onloadend(new ProgressEvent("loadend", {target:me})); | |
} | |
}, | |
// Error callback | |
function(e) { | |
// If DONE (cancelled), then don't do anything | |
if (me._readyState === FileReader.DONE) { | |
return; | |
} | |
// DONE state | |
me._readyState = FileReader.DONE; | |
me._result = null; | |
// Save error | |
me._error = new FileError(e); | |
// If onerror callback | |
if (typeof me.onerror === "function") { | |
me.onerror(new ProgressEvent("error", {target:me})); | |
} | |
// If onloadend callback | |
if (typeof me.onloadend === "function") { | |
me.onloadend(new ProgressEvent("loadend", {target:me})); | |
} | |
}, "File", "readAsDataURL", execArgs); | |
}; | |
/** | |
* Read file and return data as a binary data. | |
* | |
* @param file {File} File object containing file properties | |
*/ | |
FileReader.prototype.readAsBinaryString = function(file) { | |
if (initRead(this, file)) { | |
return this._realReader.readAsBinaryString(file); | |
} | |
var me = this; | |
var execArgs = [this._fileName, file.start, file.end]; | |
// Read file | |
exec( | |
// Success callback | |
function(r) { | |
// If DONE (cancelled), then don't do anything | |
if (me._readyState === FileReader.DONE) { | |
return; | |
} | |
// DONE state | |
me._readyState = FileReader.DONE; | |
me._result = r; | |
// If onload callback | |
if (typeof me.onload === "function") { | |
me.onload(new ProgressEvent("load", {target:me})); | |
} | |
// If onloadend callback | |
if (typeof me.onloadend === "function") { | |
me.onloadend(new ProgressEvent("loadend", {target:me})); | |
} | |
}, | |
// Error callback | |
function(e) { | |
// If DONE (cancelled), then don't do anything | |
if (me._readyState === FileReader.DONE) { | |
return; | |
} | |
// DONE state | |
me._readyState = FileReader.DONE; | |
me._result = null; | |
// Save error | |
me._error = new FileError(e); | |
// If onerror callback | |
if (typeof me.onerror === "function") { | |
me.onerror(new ProgressEvent("error", {target:me})); | |
} | |
// If onloadend callback | |
if (typeof me.onloadend === "function") { | |
me.onloadend(new ProgressEvent("loadend", {target:me})); | |
} | |
}, "File", "readAsBinaryString", execArgs); | |
}; | |
/** | |
* Read file and return data as a binary data. | |
* | |
* @param file {File} File object containing file properties | |
*/ | |
FileReader.prototype.readAsArrayBuffer = function(file) { | |
if (initRead(this, file)) { | |
return this._realReader.readAsArrayBuffer(file); | |
} | |
var me = this; | |
var execArgs = [this._fileName, file.start, file.end]; | |
// Read file | |
exec( | |
// Success callback | |
function(r) { | |
// If DONE (cancelled), then don't do anything | |
if (me._readyState === FileReader.DONE) { | |
return; | |
} | |
// DONE state | |
me._readyState = FileReader.DONE; | |
me._result = r; | |
// If onload callback | |
if (typeof me.onload === "function") { | |
me.onload(new ProgressEvent("load", {target:me})); | |
} | |
// If onloadend callback | |
if (typeof me.onloadend === "function") { | |
me.onloadend(new ProgressEvent("loadend", {target:me})); | |
} | |
}, | |
// Error callback | |
function(e) { | |
// If DONE (cancelled), then don't do anything | |
if (me._readyState === FileReader.DONE) { | |
return; | |
} | |
// DONE state | |
me._readyState = FileReader.DONE; | |
me._result = null; | |
// Save error | |
me._error = new FileError(e); | |
// If onerror callback | |
if (typeof me.onerror === "function") { | |
me.onerror(new ProgressEvent("error", {target:me})); | |
} | |
// If onloadend callback | |
if (typeof me.onloadend === "function") { | |
me.onloadend(new ProgressEvent("loadend", {target:me})); | |
} | |
}, "File", "readAsArrayBuffer", execArgs); | |
}; | |
module.exports = FileReader; | |
}); | |
// file: lib/common/plugin/FileSystem.js | |
define("cordova/plugin/FileSystem", function(require, exports, module) { | |
var DirectoryEntry = require('cordova/plugin/DirectoryEntry'); | |
/** | |
* 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(name, root) { | |
this.name = name || null; | |
if (root) { | |
this.root = new DirectoryEntry(root.name, root.fullPath); | |
} | |
}; | |
module.exports = FileSystem; | |
}); | |
// file: lib/common/plugin/FileTransfer.js | |
define("cordova/plugin/FileTransfer", function(require, exports, module) { | |
var argscheck = require('cordova/argscheck'), | |
exec = require('cordova/exec'), | |
FileTransferError = require('cordova/plugin/FileTransferError'), | |
ProgressEvent = require('cordova/plugin/ProgressEvent'); | |
function newProgressEvent(result) { | |
var pe = new ProgressEvent(); | |
pe.lengthComputable = result.lengthComputable; | |
pe.loaded = result.loaded; | |
pe.total = result.total; | |
return pe; | |
} | |
function getBasicAuthHeader(urlString) { | |
var header = null; | |
if (window.btoa) { | |
// parse the url using the Location object | |
var url = document.createElement('a'); | |
url.href = urlString; | |
var credentials = null; | |
var protocol = url.protocol + "//"; | |
var origin = protocol + url.host; | |
// check whether there are the username:password credentials in the url | |
if (url.href.indexOf(origin) !== 0) { // credentials found | |
var atIndex = url.href.indexOf("@"); | |
credentials = url.href.substring(protocol.length, atIndex); | |
} | |
if (credentials) { | |
var authHeader = "Authorization"; | |
var authHeaderValue = "Basic " + window.btoa(credentials); | |
header = { | |
name : authHeader, | |
value : authHeaderValue | |
}; | |
} | |
} | |
return header; | |
} | |
var idCounter = 0; | |
/** | |
* FileTransfer uploads a file to a remote server. | |
* @constructor | |
*/ | |
var FileTransfer = function() { | |
this._id = ++idCounter; | |
this.onprogress = null; // optional callback | |
}; | |
/** | |
* Given an absolute file path, uploads a file on the device to a remote server | |
* using a multipart HTTP request. | |
* @param filePath {String} Full path of the file on the device | |
* @param server {String} URL of the server to receive the file | |
* @param successCallback (Function} Callback to be invoked when upload has completed | |
* @param errorCallback {Function} Callback to be invoked upon error | |
* @param options {FileUploadOptions} Optional parameters such as file name and mimetype | |
* @param trustAllHosts {Boolean} Optional trust all hosts (e.g. for self-signed certs), defaults to false | |
*/ | |
FileTransfer.prototype.upload = function(filePath, server, successCallback, errorCallback, options, trustAllHosts) { | |
argscheck.checkArgs('ssFFO*', 'FileTransfer.upload', arguments); | |
// check for options | |
var fileKey = null; | |
var fileName = null; | |
var mimeType = null; | |
var params = null; | |
var chunkedMode = true; | |
var headers = null; | |
var httpMethod = null; | |
var basicAuthHeader = getBasicAuthHeader(server); | |
if (basicAuthHeader) { | |
options = options || {}; | |
options.headers = options.headers || {}; | |
options.headers[basicAuthHeader.name] = basicAuthHeader.value; | |
} | |
if (options) { | |
fileKey = options.fileKey; | |
fileName = options.fileName; | |
mimeType = options.mimeType; | |
headers = options.headers; | |
httpMethod = options.httpMethod || "POST"; | |
if (httpMethod.toUpperCase() == "PUT"){ | |
httpMethod = "PUT"; | |
} else { | |
httpMethod = "POST"; | |
} | |
if (options.chunkedMode !== null || typeof options.chunkedMode != "undefined") { | |
chunkedMode = options.chunkedMode; | |
} | |
if (options.params) { | |
params = options.params; | |
} | |
else { | |
params = {}; | |
} | |
} | |
var fail = errorCallback && function(e) { | |
var error = new FileTransferError(e.code, e.source, e.target, e.http_status, e.body); | |
errorCallback(error); | |
}; | |
var self = this; | |
var win = function(result) { | |
if (typeof result.lengthComputable != "undefined") { | |
if (self.onprogress) { | |
self.onprogress(newProgressEvent(result)); | |
} | |
} else { | |
successCallback && successCallback(result); | |
} | |
}; | |
exec(win, fail, 'FileTransfer', 'upload', [filePath, server, fileKey, fileName, mimeType, params, trustAllHosts, chunkedMode, headers, this._id, httpMethod]); | |
}; | |
/** | |
* Downloads a file form a given URL and saves it to the specified directory. | |
* @param source {String} URL of the server to receive the file | |
* @param target {String} Full path of the file on the device | |
* @param successCallback (Function} Callback to be invoked when upload has completed | |
* @param errorCallback {Function} Callback to be invoked upon error | |
* @param trustAllHosts {Boolean} Optional trust all hosts (e.g. for self-signed certs), defaults to false | |
* @param options {FileDownloadOptions} Optional parameters such as headers | |
*/ | |
FileTransfer.prototype.download = function(source, target, successCallback, errorCallback, trustAllHosts, options) { | |
argscheck.checkArgs('ssFF*', 'FileTransfer.download', arguments); | |
var self = this; | |
var basicAuthHeader = getBasicAuthHeader(source); | |
if (basicAuthHeader) { | |
options = options || {}; | |
options.headers = options.headers || {}; | |
options.headers[basicAuthHeader.name] = basicAuthHeader.value; | |
} | |
var headers = null; | |
if (options) { | |
headers = options.headers || null; | |
} | |
var win = function(result) { | |
if (typeof result.lengthComputable != "undefined") { | |
if (self.onprogress) { | |
return self.onprogress(newProgressEvent(result)); | |
} | |
} else if (successCallback) { | |
var entry = null; | |
if (result.isDirectory) { | |
entry = new (require('cordova/plugin/DirectoryEntry'))(); | |
} | |
else if (result.isFile) { | |
entry = new (require('cordova/plugin/FileEntry'))(); | |
} | |
entry.isDirectory = result.isDirectory; | |
entry.isFile = result.isFile; | |
entry.name = result.name; | |
entry.fullPath = result.fullPath; | |
successCallback(entry); | |
} | |
}; | |
var fail = errorCallback && function(e) { | |
var error = new FileTransferError(e.code, e.source, e.target, e.http_status, e.body); | |
errorCallback(error); | |
}; | |
exec(win, fail, 'FileTransfer', 'download', [source, target, trustAllHosts, this._id, headers]); | |
}; | |
/** | |
* Aborts the ongoing file transfer on this object. The original error | |
* callback for the file transfer will be called if necessary. | |
*/ | |
FileTransfer.prototype.abort = function() { | |
exec(null, null, 'FileTransfer', 'abort', [this._id]); | |
}; | |
module.exports = FileTransfer; | |
}); | |
// file: lib/common/plugin/FileTransferError.js | |
define("cordova/plugin/FileTransferError", function(require, exports, module) { | |
/** | |
* FileTransferError | |
* @constructor | |
*/ | |
var FileTransferError = function(code, source, target, status, body) { | |
this.code = code || null; | |
this.source = source || null; | |
this.target = target || null; | |
this.http_status = status || null; | |
this.body = body || null; | |
}; | |
FileTransferError.FILE_NOT_FOUND_ERR = 1; | |
FileTransferError.INVALID_URL_ERR = 2; | |
FileTransferError.CONNECTION_ERR = 3; | |
FileTransferError.ABORT_ERR = 4; | |
module.exports = FileTransferError; | |
}); | |
// file: lib/common/plugin/FileUploadOptions.js | |
define("cordova/plugin/FileUploadOptions", function(require, exports, module) { | |
/** | |
* Options to customize the HTTP request used to upload files. | |
* @constructor | |
* @param fileKey {String} Name of file request parameter. | |
* @param fileName {String} Filename to be used by the server. Defaults to image.jpg. | |
* @param mimeType {String} Mimetype of the uploaded file. Defaults to image/jpeg. | |
* @param params {Object} Object with key: value params to send to the server. | |
* @param headers {Object} Keys are header names, values are header values. Multiple | |
* headers of the same name are not supported. | |
*/ | |
var FileUploadOptions = function(fileKey, fileName, mimeType, params, headers, httpMethod) { | |
this.fileKey = fileKey || null; | |
this.fileName = fileName || null; | |
this.mimeType = mimeType || null; | |
this.params = params || null; | |
this.headers = headers || null; | |
this.httpMethod = httpMethod || null; | |
}; | |
module.exports = FileUploadOptions; | |
}); | |
// file: lib/common/plugin/FileUploadResult.js | |
define("cordova/plugin/FileUploadResult", function(require, exports, module) { | |
/** | |
* FileUploadResult | |
* @constructor | |
*/ | |
var FileUploadResult = function() { | |
this.bytesSent = 0; | |
this.responseCode = null; | |
this.response = null; | |
}; | |
module.exports = FileUploadResult; | |
}); | |
// file: lib/common/plugin/FileWriter.js | |
define("cordova/plugin/FileWriter", function(require, exports, module) { | |
var exec = require('cordova/exec'), | |
FileError = require('cordova/plugin/FileError'), | |
ProgressEvent = require('cordova/plugin/ProgressEvent'); | |
/** | |
* 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 new FileError(FileError.INVALID_STATE_ERR); | |
} | |
// set error | |
this.error = new FileError(FileError.ABORT_ERR); | |
this.readyState = FileWriter.DONE; | |
// If abort callback | |
if (typeof this.onabort === "function") { | |
this.onabort(new ProgressEvent("abort", {"target":this})); | |
} | |
// If write end callback | |
if (typeof this.onwriteend === "function") { | |
this.onwriteend(new ProgressEvent("writeend", {"target":this})); | |
} | |
}; | |
/** | |
* Writes data to the file | |
* | |
* @param data text or blob to be written | |
*/ | |
FileWriter.prototype.write = function(data) { | |
var that=this; | |
var supportsBinary = (typeof window.Blob !== 'undefined' && typeof window.ArrayBuffer !== 'undefined'); | |
var isBinary; | |
// Check to see if the incoming data is a blob | |
if (data instanceof File || (supportsBinary && data instanceof Blob)) { | |
var fileReader = new FileReader(); | |
fileReader.onload = function() { | |
// Call this method again, with the arraybuffer as argument | |
FileWriter.prototype.write.call(that, this.result); | |
}; | |
if (supportsBinary) { | |
fileReader.readAsArrayBuffer(data); | |
} else { | |
fileReader.readAsText(data); | |
} | |
return; | |
} | |
// Mark data type for safer transport over the binary bridge | |
isBinary = supportsBinary && (data instanceof ArrayBuffer); | |
// Throw an exception if we are already writing a file | |
if (this.readyState === FileWriter.WRITING) { | |
throw new FileError(FileError.INVALID_STATE_ERR); | |
} | |
// WRITING state | |
this.readyState = FileWriter.WRITING; | |
var me = this; | |
// If onwritestart callback | |
if (typeof me.onwritestart === "function") { | |
me.onwritestart(new ProgressEvent("writestart", {"target":me})); | |
} | |
// Write file | |
exec( | |
// Success callback | |
function(r) { | |
// 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; | |
// DONE state | |
me.readyState = FileWriter.DONE; | |
// If onwrite callback | |
if (typeof me.onwrite === "function") { | |
me.onwrite(new ProgressEvent("write", {"target":me})); | |
} | |
// If onwriteend callback | |
if (typeof me.onwriteend === "function") { | |
me.onwriteend(new ProgressEvent("writeend", {"target":me})); | |
} | |
}, | |
// Error callback | |
function(e) { | |
// If DONE (cancelled), then don't do anything | |
if (me.readyState === FileWriter.DONE) { | |
return; | |
} | |
// DONE state | |
me.readyState = FileWriter.DONE; | |
// Save error | |
me.error = new FileError(e); | |
// If onerror callback | |
if (typeof me.onerror === "function") { | |
me.onerror(new ProgressEvent("error", {"target":me})); | |
} | |
// If onwriteend callback | |
if (typeof me.onwriteend === "function") { | |
me.onwriteend(new ProgressEvent("writeend", {"target":me})); | |
} | |
}, "File", "write", [this.fileName, data, this.position, isBinary]); | |
}; | |
/** | |
* 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 new FileError(FileError.INVALID_STATE_ERR); | |
} | |
if (!offset && offset !== 0) { | |
return; | |
} | |
// See back from end of file. | |
if (offset < 0) { | |
this.position = Math.max(offset + this.length, 0); | |
} | |
// Offset is bigger than 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 new FileError(FileError.INVALID_STATE_ERR); | |
} | |
// WRITING state | |
this.readyState = FileWriter.WRITING; | |
var me = this; | |
// If onwritestart callback | |
if (typeof me.onwritestart === "function") { | |
me.onwritestart(new ProgressEvent("writestart", {"target":this})); | |
} | |
// Write file | |
exec( | |
// Success callback | |
function(r) { | |
// If DONE (cancelled), then don't do anything | |
if (me.readyState === FileWriter.DONE) { | |
return; | |
} | |
// DONE state | |
me.readyState = FileWriter.DONE; | |
// 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(new ProgressEvent("write", {"target":me})); | |
} | |
// If onwriteend callback | |
if (typeof me.onwriteend === "function") { | |
me.onwriteend(new ProgressEvent("writeend", {"target":me})); | |
} | |
}, | |
// Error callback | |
function(e) { | |
// If DONE (cancelled), then don't do anything | |
if (me.readyState === FileWriter.DONE) { | |
return; | |
} | |
// DONE state | |
me.readyState = FileWriter.DONE; | |
// Save error | |
me.error = new FileError(e); | |
// If onerror callback | |
if (typeof me.onerror === "function") { | |
me.onerror(new ProgressEvent("error", {"target":me})); | |
} | |
// If onwriteend callback | |
if (typeof me.onwriteend === "function") { | |
me.onwriteend(new ProgressEvent("writeend", {"target":me})); | |
} | |
}, "File", "truncate", [this.fileName, size]); | |
}; | |
module.exports = FileWriter; | |
}); | |
// file: lib/common/plugin/Flags.js | |
define("cordova/plugin/Flags", function(require, exports, module) { | |
/** | |
* Supplies arguments to methods that lookup or create files and directories. | |
* | |
* @param create | |
* {boolean} file or directory if it doesn't exist | |
* @param exclusive | |
* {boolean} used with create; if true the command will fail if | |
* target path exists | |
*/ | |
function Flags(create, exclusive) { | |
this.create = create || false; | |
this.exclusive = exclusive || false; | |
} | |
module.exports = Flags; | |
}); | |
// file: lib/common/plugin/GlobalizationError.js | |
define("cordova/plugin/GlobalizationError", function(require, exports, module) { | |
/** | |
* Globalization error object | |
* | |
* @constructor | |
* @param code | |
* @param message | |
*/ | |
var GlobalizationError = function(code, message) { | |
this.code = code || null; | |
this.message = message || ''; | |
}; | |
// Globalization error codes | |
GlobalizationError.UNKNOWN_ERROR = 0; | |
GlobalizationError.FORMATTING_ERROR = 1; | |
GlobalizationError.PARSING_ERROR = 2; | |
GlobalizationError.PATTERN_ERROR = 3; | |
module.exports = GlobalizationError; | |
}); | |
// file: lib/common/plugin/InAppBrowser.js | |
define("cordova/plugin/InAppBrowser", function(require, exports, module) { | |
var exec = require('cordova/exec'); | |
var channel = require('cordova/channel'); | |
var modulemapper = require('cordova/modulemapper'); | |
function InAppBrowser() { | |
this.channels = { | |
'loadstart': channel.create('loadstart'), | |
'loadstop' : channel.create('loadstop'), | |
'loaderror' : channel.create('loaderror'), | |
'exit' : channel.create('exit') | |
}; | |
} | |
InAppBrowser.prototype = { | |
_eventHandler: function (event) { | |
if (event.type in this.channels) { | |
this.channels[event.type].fire(event); | |
} | |
}, | |
close: function (eventname) { | |
exec(null, null, "InAppBrowser", "close", []); | |
}, | |
show: function (eventname) { | |
exec(null, null, "InAppBrowser", "show", []); | |
}, | |
addEventListener: function (eventname,f) { | |
if (eventname in this.channels) { | |
this.channels[eventname].subscribe(f); | |
} | |
}, | |
removeEventListener: function(eventname, f) { | |
if (eventname in this.channels) { | |
this.channels[eventname].unsubscribe(f); | |
} | |
}, | |
executeScript: function(injectDetails, cb) { | |
if (injectDetails.code) { | |
exec(cb, null, "InAppBrowser", "injectScriptCode", [injectDetails.code, !!cb]); | |
} else if (injectDetails.file) { | |
exec(cb, null, "InAppBrowser", "injectScriptFile", [injectDetails.file, !!cb]); | |
} else { | |
throw new Error('executeScript requires exactly one of code or file to be specified'); | |
} | |
}, | |
insertCSS: function(injectDetails, cb) { | |
if (injectDetails.code) { | |
exec(cb, null, "InAppBrowser", "injectStyleCode", [injectDetails.code, !!cb]); | |
} else if (injectDetails.file) { | |
exec(cb, null, "InAppBrowser", "injectStyleFile", [injectDetails.file, !!cb]); | |
} else { | |
throw new Error('insertCSS requires exactly one of code or file to be specified'); | |
} | |
} | |
}; | |
module.exports = function(strUrl, strWindowName, strWindowFeatures) { | |
var iab = new InAppBrowser(); | |
var cb = function(eventname) { | |
iab._eventHandler(eventname); | |
}; | |
// Don't catch calls that write to existing frames (e.g. named iframes). | |
if (window.frames && window.frames[strWindowName]) { | |
var origOpenFunc = modulemapper.getOriginalSymbol(window, 'open'); | |
return origOpenFunc.apply(window, arguments); | |
} | |
exec(cb, cb, "InAppBrowser", "open", [strUrl, strWindowName, strWindowFeatures]); | |
return iab; | |
}; | |
}); | |
// file: lib/common/plugin/LocalFileSystem.js | |
define("cordova/plugin/LocalFileSystem", function(require, exports, module) { | |
var exec = require('cordova/exec'); | |
/** | |
* Represents a local file system. | |
*/ | |
var LocalFileSystem = function() { | |
}; | |
LocalFileSystem.TEMPORARY = 0; //temporary, with no guarantee of persistence | |
LocalFileSystem.PERSISTENT = 1; //persistent | |
module.exports = LocalFileSystem; | |
}); | |
// file: lib/common/plugin/Media.js | |
define("cordova/plugin/Media", function(require, exports, module) { | |
var argscheck = require('cordova/argscheck'), | |
utils = require('cordova/utils'), | |
exec = require('cordova/exec'); | |
var mediaObjects = {}; | |
/** | |
* This class provides access to the device media, interfaces to both sound and video | |
* | |
* @constructor | |
* @param src The file name or url to play | |
* @param successCallback The callback to be called when the file is done playing or recording. | |
* successCallback() | |
* @param errorCallback The callback to be called if there is an error. | |
* errorCallback(int errorCode) - OPTIONAL | |
* @param statusCallback The callback to be called when media status has changed. | |
* statusCallback(int statusCode) - OPTIONAL | |
*/ | |
var Media = function(src, successCallback, errorCallback, statusCallback) { | |
argscheck.checkArgs('SFFF', 'Media', arguments); | |
this.id = utils.createUUID(); | |
mediaObjects[this.id] = this; | |
this.src = src; | |
this.successCallback = successCallback; | |
this.errorCallback = errorCallback; | |
this.statusCallback = statusCallback; | |
this._duration = -1; | |
this._position = -1; | |
exec(null, this.errorCallback, "Media", "create", [this.id, this.src]); | |
}; | |
// Media messages | |
Media.MEDIA_STATE = 1; | |
Media.MEDIA_DURATION = 2; | |
Media.MEDIA_POSITION = 3; | |
Media.MEDIA_ERROR = 9; | |
// Media states | |
Media.MEDIA_NONE = 0; | |
Media.MEDIA_STARTING = 1; | |
Media.MEDIA_RUNNING = 2; | |
Media.MEDIA_PAUSED = 3; | |
Media.MEDIA_STOPPED = 4; | |
Media.MEDIA_MSG = ["None", "Starting", "Running", "Paused", "Stopped"]; | |
// "static" function to return existing objs. | |
Media.get = function(id) { | |
return mediaObjects[id]; | |
}; | |
/** | |
* Start or resume playing audio file. | |
*/ | |
Media.prototype.play = function(options) { | |
exec(null, null, "Media", "startPlayingAudio", [this.id, this.src, options]); | |
}; | |
/** | |
* Stop playing audio file. | |
*/ | |
Media.prototype.stop = function() { | |
var me = this; | |
exec(function() { | |
me._position = 0; | |
}, this.errorCallback, "Media", "stopPlayingAudio", [this.id]); | |
}; | |
/** | |
* Seek or jump to a new time in the track.. | |
*/ | |
Media.prototype.seekTo = function(milliseconds) { | |
var me = this; | |
exec(function(p) { | |
me._position = p; | |
}, this.errorCallback, "Media", "seekToAudio", [this.id, milliseconds]); | |
}; | |
/** | |
* Pause playing audio file. | |
*/ | |
Media.prototype.pause = function() { | |
exec(null, this.errorCallback, "Media", "pausePlayingAudio", [this.id]); | |
}; | |
/** | |
* Get duration of an audio file. | |
* The duration is only set for audio that is playing, paused or stopped. | |
* | |
* @return duration or -1 if not known. | |
*/ | |
Media.prototype.getDuration = function() { | |
return this._duration; | |
}; | |
/** | |
* Get position of audio. | |
*/ | |
Media.prototype.getCurrentPosition = function(success, fail) { | |
var me = this; | |
exec(function(p) { | |
me._position = p; | |
success(p); | |
}, fail, "Media", "getCurrentPositionAudio", [this.id]); | |
}; | |
/** | |
* Start recording audio file. | |
*/ | |
Media.prototype.startRecord = function() { | |
exec(null, this.errorCallback, "Media", "startRecordingAudio", [this.id, this.src]); | |
}; | |
/** | |
* Stop recording audio file. | |
*/ | |
Media.prototype.stopRecord = function() { | |
exec(null, this.errorCallback, "Media", "stopRecordingAudio", [this.id]); | |
}; | |
/** | |
* Release the resources. | |
*/ | |
Media.prototype.release = function() { | |
exec(null, this.errorCallback, "Media", "release", [this.id]); | |
}; | |
/** | |
* Adjust the volume. | |
*/ | |
Media.prototype.setVolume = function(volume) { | |
exec(null, null, "Media", "setVolume", [this.id, volume]); | |
}; | |
/** | |
* Audio has status update. | |
* PRIVATE | |
* | |
* @param id The media object id (string) | |
* @param msgType The 'type' of update this is | |
* @param value Use of value is determined by the msgType | |
*/ | |
Media.onStatus = function(id, msgType, value) { | |
var media = mediaObjects[id]; | |
if(media) { | |
switch(msgType) { | |
case Media.MEDIA_STATE : | |
media.statusCallback && media.statusCallback(value); | |
if(value == Media.MEDIA_STOPPED) { | |
media.successCallback && media.successCallback(); | |
} | |
break; | |
case Media.MEDIA_DURATION : | |
media._duration = value; | |
break; | |
case Media.MEDIA_ERROR : | |
media.errorCallback && media.errorCallback(value); | |
break; | |
case Media.MEDIA_POSITION : | |
media._position = Number(value); | |
break; | |
default : | |
console.error && console.error("Unhandled Media.onStatus :: " + msgType); | |
break; | |
} | |
} | |
else { | |
console.error && console.error("Received Media.onStatus callback for unknown media :: " + id); | |
} | |
}; | |
module.exports = Media; | |
}); | |
// file: lib/common/plugin/MediaError.js | |
define("cordova/plugin/MediaError", function(require, exports, module) { | |
/** | |
* This class contains information about any Media errors. | |
*/ | |
/* | |
According to :: http://dev.w3.org/html5/spec-author-view/video.html#mediaerror | |
We should never be creating these objects, we should just implement the interface | |
which has 1 property for an instance, 'code' | |
instead of doing : | |
errorCallbackFunction( new MediaError(3,'msg') ); | |
we should simply use a literal : | |
errorCallbackFunction( {'code':3} ); | |
*/ | |
var _MediaError = window.MediaError; | |
if(!_MediaError) { | |
window.MediaError = _MediaError = function(code, msg) { | |
this.code = (typeof code != 'undefined') ? code : null; | |
this.message = msg || ""; // message is NON-standard! do not use! | |
}; | |
} | |
_MediaError.MEDIA_ERR_NONE_ACTIVE = _MediaError.MEDIA_ERR_NONE_ACTIVE || 0; | |
_MediaError.MEDIA_ERR_ABORTED = _MediaError.MEDIA_ERR_ABORTED || 1; | |
_MediaError.MEDIA_ERR_NETWORK = _MediaError.MEDIA_ERR_NETWORK || 2; | |
_MediaError.MEDIA_ERR_DECODE = _MediaError.MEDIA_ERR_DECODE || 3; | |
_MediaError.MEDIA_ERR_NONE_SUPPORTED = _MediaError.MEDIA_ERR_NONE_SUPPORTED || 4; | |
// TODO: MediaError.MEDIA_ERR_NONE_SUPPORTED is legacy, the W3 spec now defines it as below. | |
// as defined by http://dev.w3.org/html5/spec-author-view/video.html#error-codes | |
_MediaError.MEDIA_ERR_SRC_NOT_SUPPORTED = _MediaError.MEDIA_ERR_SRC_NOT_SUPPORTED || 4; | |
module.exports = _MediaError; | |
}); | |
// file: lib/common/plugin/MediaFile.js | |
define("cordova/plugin/MediaFile", function(require, exports, module) { | |
var utils = require('cordova/utils'), | |
exec = require('cordova/exec'), | |
File = require('cordova/plugin/File'), | |
CaptureError = require('cordova/plugin/CaptureError'); | |
/** | |
* 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){ | |
MediaFile.__super__.constructor.apply(this, arguments); | |
}; | |
utils.extend(MediaFile, File); | |
/** | |
* Request capture format data for a specific file and type | |
* | |
* @param {Function} successCB | |
* @param {Function} errorCB | |
*/ | |
MediaFile.prototype.getFormatData = function(successCallback, errorCallback) { | |
if (typeof this.fullPath === "undefined" || this.fullPath === null) { | |
errorCallback(new CaptureError(CaptureError.CAPTURE_INVALID_ARGUMENT)); | |
} else { | |
exec(successCallback, errorCallback, "Capture", "getFormatData", [this.fullPath, this.type]); | |
} | |
}; | |
module.exports = MediaFile; | |
}); | |
// file: lib/common/plugin/MediaFileData.js | |
define("cordova/plugin/MediaFileData", function(require, exports, module) { | |
/** | |
* 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; | |
}; | |
module.exports = MediaFileData; | |
}); | |
// file: lib/common/plugin/Metadata.js | |
define("cordova/plugin/Metadata", function(require, exports, module) { | |
/** | |
* Information about the state of the file or directory | |
* | |
* {Date} modificationTime (readonly) | |
*/ | |
var Metadata = function(time) { | |
this.modificationTime = (typeof time != 'undefined'?new Date(time):null); | |
}; | |
module.exports = Metadata; | |
}); | |
// file: lib/common/plugin/Position.js | |
define("cordova/plugin/Position", function(require, exports, module) { | |
var Coordinates = require('cordova/plugin/Coordinates'); | |
var Position = function(coords, timestamp) { | |
if (coords) { | |
this.coords = new Coordinates(coords.latitude, coords.longitude, coords.altitude, coords.accuracy, coords.heading, coords.velocity, coords.altitudeAccuracy); | |
} else { | |
this.coords = new Coordinates(); | |
} | |
this.timestamp = (timestamp !== undefined) ? timestamp : new Date(); | |
}; | |
module.exports = Position; | |
}); | |
// file: lib/common/plugin/PositionError.js | |
define("cordova/plugin/PositionError", function(require, exports, module) { | |
/** | |
* Position error object | |
* | |
* @constructor | |
* @param code | |
* @param message | |
*/ | |
var PositionError = function(code, message) { | |
this.code = code || null; | |
this.message = message || ''; | |
}; | |
PositionError.PERMISSION_DENIED = 1; | |
PositionError.POSITION_UNAVAILABLE = 2; | |
PositionError.TIMEOUT = 3; | |
module.exports = PositionError; | |
}); | |
// file: lib/common/plugin/ProgressEvent.js | |
define("cordova/plugin/ProgressEvent", function(require, exports, module) { | |
// If ProgressEvent exists in global context, use it already, otherwise use our own polyfill | |
// Feature test: See if we can instantiate a native ProgressEvent; | |
// if so, use that approach, | |
// otherwise fill-in with our own implementation. | |
// | |
// NOTE: right now we always fill in with our own. Down the road would be nice if we can use whatever is native in the webview. | |
var ProgressEvent = (function() { | |
/* | |
var createEvent = function(data) { | |
var event = document.createEvent('Events'); | |
event.initEvent('ProgressEvent', false, false); | |
if (data) { | |
for (var i in data) { | |
if (data.hasOwnProperty(i)) { | |
event[i] = data[i]; | |
} | |
} | |
if (data.target) { | |
// TODO: cannot call <some_custom_object>.dispatchEvent | |
// need to first figure out how to implement EventTarget | |
} | |
} | |
return event; | |
}; | |
try { | |
var ev = createEvent({type:"abort",target:document}); | |
return function ProgressEvent(type, data) { | |
data.type = type; | |
return createEvent(data); | |
}; | |
} catch(e){ | |
*/ | |
return function ProgressEvent(type, dict) { | |
this.type = type; | |
this.bubbles = false; | |
this.cancelBubble = false; | |
this.cancelable = false; | |
this.lengthComputable = false; | |
this.loaded = dict && dict.loaded ? dict.loaded : 0; | |
this.total = dict && dict.total ? dict.total : 0; | |
this.target = dict && dict.target ? dict.target : null; | |
}; | |
//} | |
})(); | |
module.exports = ProgressEvent; | |
}); | |
// file: lib/common/plugin/accelerometer.js | |
define("cordova/plugin/accelerometer", function(require, exports, module) { | |
/** | |
* This class provides access to device accelerometer data. | |
* @constructor | |
*/ | |
var argscheck = require('cordova/argscheck'), | |
utils = require("cordova/utils"), | |
exec = require("cordova/exec"), | |
Acceleration = require('cordova/plugin/Acceleration'); | |
// Is the accel sensor running? | |
var running = false; | |
// Keeps reference to watchAcceleration calls. | |
var timers = {}; | |
// Array of listeners; used to keep track of when we should call start and stop. | |
var listeners = []; | |
// Last returned acceleration object from native | |
var accel = null; | |
// Tells native to start. | |
function start() { | |
exec(function(a) { | |
var tempListeners = listeners.slice(0); | |
accel = new Acceleration(a.x, a.y, a.z, a.timestamp); | |
for (var i = 0, l = tempListeners.length; i < l; i++) { | |
tempListeners[i].win(accel); | |
} | |
}, function(e) { | |
var tempListeners = listeners.slice(0); | |
for (var i = 0, l = tempListeners.length; i < l; i++) { | |
tempListeners[i].fail(e); | |
} | |
}, "Accelerometer", "start", []); | |
running = true; | |
} | |
// Tells native to stop. | |
function stop() { | |
exec(null, null, "Accelerometer", "stop", []); | |
running = false; | |
} | |
// Adds a callback pair to the listeners array | |
function createCallbackPair(win, fail) { | |
return {win:win, fail:fail}; | |
} | |
// Removes a win/fail listener pair from the listeners array | |
function removeListeners(l) { | |
var idx = listeners.indexOf(l); | |
if (idx > -1) { | |
listeners.splice(idx, 1); | |
if (listeners.length === 0) { | |
stop(); | |
} | |
} | |
} | |
var accelerometer = { | |
/** | |
* Asynchronously acquires the current acceleration. | |
* | |
* @param {Function} successCallback The function to call when the acceleration data is available | |
* @param {Function} errorCallback The function to call when there is an error getting the acceleration data. (OPTIONAL) | |
* @param {AccelerationOptions} options The options for getting the accelerometer data such as timeout. (OPTIONAL) | |
*/ | |
getCurrentAcceleration: function(successCallback, errorCallback, options) { | |
argscheck.checkArgs('fFO', 'accelerometer.getCurrentAcceleration', arguments); | |
var p; | |
var win = function(a) { | |
removeListeners(p); | |
successCallback(a); | |
}; | |
var fail = function(e) { | |
removeListeners(p); | |
errorCallback && errorCallback(e); | |
}; | |
p = createCallbackPair(win, fail); | |
listeners.push(p); | |
if (!running) { | |
start(); | |
} | |
}, | |
/** | |
* Asynchronously acquires the acceleration repeatedly at a given interval. | |
* | |
* @param {Function} successCallback The function to call each time the acceleration data is available | |
* @param {Function} errorCallback The function to call when there is an error getting the acceleration data. (OPTIONAL) | |
* @param {AccelerationOptions} options The options for getting the accelerometer data such as timeout. (OPTIONAL) | |
* @return String The watch id that must be passed to #clearWatch to stop watching. | |
*/ | |
watchAcceleration: function(successCallback, errorCallback, options) { | |
argscheck.checkArgs('fFO', 'accelerometer.watchAcceleration', arguments); | |
// Default interval (10 sec) | |
var frequency = (options && options.frequency && typeof options.frequency == 'number') ? options.frequency : 10000; | |
// Keep reference to watch id, and report accel readings as often as defined in frequency | |
var id = utils.createUUID(); | |
var p = createCallbackPair(function(){}, function(e) { | |
removeListeners(p); | |
errorCallback && errorCallback(e); | |
}); | |
listeners.push(p); | |
timers[id] = { | |
timer:window.setInterval(function() { | |
if (accel) { | |
successCallback(accel); | |
} | |
}, frequency), | |
listeners:p | |
}; | |
if (running) { | |
// If we're already running then immediately invoke the success callback | |
// but only if we have retrieved a value, sample code does not check for null ... | |
if (accel) { | |
successCallback(accel); | |
} | |
} else { | |
start(); | |
} | |
return id; | |
}, | |
/** | |
* Clears the specified accelerometer watch. | |
* | |
* @param {String} id The id of the watch returned from #watchAcceleration. | |
*/ | |
clearWatch: function(id) { | |
// Stop javascript timer & remove from timer list | |
if (id && timers[id]) { | |
window.clearInterval(timers[id].timer); | |
removeListeners(timers[id].listeners); | |
delete timers[id]; | |
} | |
} | |
}; | |
module.exports = accelerometer; | |
}); | |
// file: lib/common/plugin/accelerometer/symbols.js | |
define("cordova/plugin/accelerometer/symbols", function(require, exports, module) { | |
var modulemapper = require('cordova/modulemapper'); | |
modulemapper.defaults('cordova/plugin/Acceleration', 'Acceleration'); | |
modulemapper.defaults('cordova/plugin/accelerometer', 'navigator.accelerometer'); | |
}); | |
// file: lib/common/plugin/battery.js | |
define("cordova/plugin/battery", function(require, exports, module) { | |
/** | |
* This class contains information about the current battery status. | |
* @constructor | |
*/ | |
var cordova = require('cordova'), | |
exec = require('cordova/exec'); | |
function handlers() { | |
return battery.channels.batterystatus.numHandlers + | |
battery.channels.batterylow.numHandlers + | |
battery.channels.batterycritical.numHandlers; | |
} | |
var Battery = function() { | |
this._level = null; | |
this._isPlugged = null; | |
// Create new event handlers on the window (returns a channel instance) | |
this.channels = { | |
batterystatus:cordova.addWindowEventHandler("batterystatus"), | |
batterylow:cordova.addWindowEventHandler("batterylow"), | |
batterycritical:cordova.addWindowEventHandler("batterycritical") | |
}; | |
for (var key in this.channels) { | |
this.channels[key].onHasSubscribersChange = Battery.onHasSubscribersChange; | |
} | |
}; | |
/** | |
* Event handlers for when callbacks get registered for the battery. | |
* Keep track of how many handlers we have so we can start and stop the native battery listener | |
* appropriately (and hopefully save on battery life!). | |
*/ | |
Battery.onHasSubscribersChange = function() { | |
// If we just registered the first handler, make sure native listener is started. | |
if (this.numHandlers === 1 && handlers() === 1) { | |
exec(battery._status, battery._error, "Battery", "start", []); | |
} else if (handlers() === 0) { | |
exec(null, null, "Battery", "stop", []); | |
} | |
}; | |
/** | |
* Callback for battery status | |
* | |
* @param {Object} info keys: level, isPlugged | |
*/ | |
Battery.prototype._status = function(info) { | |
if (info) { | |
var me = battery; | |
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); | |
}; | |
var battery = new Battery(); | |
module.exports = battery; | |
}); | |
// file: lib/common/plugin/battery/symbols.js | |
define("cordova/plugin/battery/symbols", function(require, exports, module) { | |
var modulemapper = require('cordova/modulemapper'); | |
modulemapper.defaults('cordova/plugin/battery', 'navigator.battery'); | |
}); | |
// file: lib/common/plugin/camera/symbols.js | |
define("cordova/plugin/camera/symbols", function(require, exports, module) { | |
var modulemapper = require('cordova/modulemapper'); | |
modulemapper.defaults('cordova/plugin/Camera', 'navigator.camera'); | |
modulemapper.defaults('cordova/plugin/CameraConstants', 'Camera'); | |
modulemapper.defaults('cordova/plugin/CameraPopoverOptions', 'CameraPopoverOptions'); | |
}); | |
// file: lib/common/plugin/capture.js | |
define("cordova/plugin/capture", function(require, exports, module) { | |
var exec = require('cordova/exec'), | |
MediaFile = require('cordova/plugin/MediaFile'); | |
/** | |
* Launches a capture of different types. | |
* | |
* @param (DOMString} type | |
* @param {Function} successCB | |
* @param {Function} errorCB | |
* @param {CaptureVideoOptions} options | |
*/ | |
function _capture(type, successCallback, errorCallback, options) { | |
var win = function(pluginResult) { | |
var mediaFiles = []; | |
var i; | |
for (i = 0; i < pluginResult.length; i++) { | |
var mediaFile = new MediaFile(); | |
mediaFile.name = pluginResult[i].name; | |
mediaFile.fullPath = pluginResult[i].fullPath; | |
mediaFile.type = pluginResult[i].type; | |
mediaFile.lastModifiedDate = pluginResult[i].lastModifiedDate; | |
mediaFile.size = pluginResult[i].size; | |
mediaFiles.push(mediaFile); | |
} | |
successCallback(mediaFiles); | |
}; | |
exec(win, errorCallback, "Capture", type, [options]); | |
} | |
/** | |
* The Capture interface exposes an interface to the camera and microphone of the hosting device. | |
*/ | |
function Capture() { | |
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){ | |
_capture("captureAudio", successCallback, errorCallback, options); | |
}; | |
/** | |
* Launch camera application for taking image(s). | |
* | |
* @param {Function} successCB | |
* @param {Function} errorCB | |
* @param {CaptureImageOptions} options | |
*/ | |
Capture.prototype.captureImage = function(successCallback, errorCallback, options){ | |
_capture("captureImage", successCallback, errorCallback, options); | |
}; | |
/** | |
* Launch device camera application for recording video(s). | |
* | |
* @param {Function} successCB | |
* @param {Function} errorCB | |
* @param {CaptureVideoOptions} options | |
*/ | |
Capture.prototype.captureVideo = function(successCallback, errorCallback, options){ | |
_capture("captureVideo", successCallback, errorCallback, options); | |
}; | |
module.exports = new Capture(); | |
}); | |
// file: lib/windows8/plugin/capture/symbols.js | |
define("cordova/plugin/capture/symbols", function(require, exports, module) { | |
var modulemapper = require('cordova/modulemapper'); | |
modulemapper.clobbers('cordova/plugin/CaptureError', 'CaptureError'); | |
modulemapper.clobbers('cordova/plugin/CaptureAudioOptions', 'CaptureAudioOptions'); | |
modulemapper.clobbers('cordova/plugin/CaptureImageOptions', 'CaptureImageOptions'); | |
modulemapper.clobbers('cordova/plugin/CaptureVideoOptions', 'CaptureVideoOptions'); | |
modulemapper.clobbers('cordova/plugin/MediaFile', 'MediaFile'); | |
modulemapper.clobbers('cordova/plugin/MediaFileData', 'MediaFileData'); | |
modulemapper.clobbers('cordova/plugin/capture', 'navigator.device.capture'); | |
modulemapper.merges('cordova/plugin/windows8/MediaFile', 'MediaFile'); | |
}); | |
// file: lib/common/plugin/compass.js | |
define("cordova/plugin/compass", function(require, exports, module) { | |
var argscheck = require('cordova/argscheck'), | |
exec = require('cordova/exec'), | |
utils = require('cordova/utils'), | |
CompassHeading = require('cordova/plugin/CompassHeading'), | |
CompassError = require('cordova/plugin/CompassError'), | |
timers = {}, | |
compass = { | |
/** | |
* Asynchronously acquires the current heading. | |
* @param {Function} successCallback The function to call when the heading | |
* data is available | |
* @param {Function} errorCallback The function to call when there is an error | |
* getting the heading data. | |
* @param {CompassOptions} options The options for getting the heading data (not used). | |
*/ | |
getCurrentHeading:function(successCallback, errorCallback, options) { | |
argscheck.checkArgs('fFO', 'compass.getCurrentHeading', arguments); | |
var win = function(result) { | |
var ch = new CompassHeading(result.magneticHeading, result.trueHeading, result.headingAccuracy, result.timestamp); | |
successCallback(ch); | |
}; | |
var fail = errorCallback && function(code) { | |
var ce = new CompassError(code); | |
errorCallback(ce); | |
}; | |
// Get heading | |
exec(win, fail, "Compass", "getHeading", [options]); | |
}, | |
/** | |
* Asynchronously acquires the heading repeatedly at a given interval. | |
* @param {Function} successCallback The function to call each time the heading | |
* data is available | |
* @param {Function} errorCallback The function to call when there is an error | |
* getting the heading data. | |
* @param {HeadingOptions} options The options for getting the heading data | |
* such as timeout and the frequency of the watch. For iOS, filter parameter | |
* specifies to watch via a distance filter rather than time. | |
*/ | |
watchHeading:function(successCallback, errorCallback, options) { | |
argscheck.checkArgs('fFO', 'compass.watchHeading', arguments); | |
// Default interval (100 msec) | |
var frequency = (options !== undefined && options.frequency !== undefined) ? options.frequency : 100; | |
var filter = (options !== undefined && options.filter !== undefined) ? options.filter : 0; | |
var id = utils.createUUID(); | |
if (filter > 0) { | |
// is an iOS request for watch by filter, no timer needed | |
timers[id] = "iOS"; | |
compass.getCurrentHeading(successCallback, errorCallback, options); | |
} else { | |
// Start watch timer to get headings | |
timers[id] = window.setInterval(function() { | |
compass.getCurrentHeading(successCallback, errorCallback); | |
}, frequency); | |
} | |
return id; | |
}, | |
/** | |
* Clears the specified heading watch. | |
* @param {String} watchId The ID of the watch returned from #watchHeading. | |
*/ | |
clearWatch:function(id) { | |
// Stop javascript timer & remove from timer list | |
if (id && timers[id]) { | |
if (timers[id] != "iOS") { | |
clearInterval(timers[id]); | |
} else { | |
// is iOS watch by filter so call into device to stop | |
exec(null, null, "Compass", "stopHeading", []); | |
} | |
delete timers[id]; | |
} | |
} | |
}; | |
module.exports = compass; | |
}); | |
// file: lib/common/plugin/compass/symbols.js | |
define("cordova/plugin/compass/symbols", function(require, exports, module) { | |
var modulemapper = require('cordova/modulemapper'); | |
modulemapper.clobbers('cordova/plugin/CompassHeading', 'CompassHeading'); | |
modulemapper.clobbers('cordova/plugin/CompassError', 'CompassError'); | |
modulemapper.clobbers('cordova/plugin/compass', 'navigator.compass'); | |
}); | |
// file: lib/common/plugin/console-via-logger.js | |
define("cordova/plugin/console-via-logger", function(require, exports, module) { | |
//------------------------------------------------------------------------------ | |
var logger = require("cordova/plugin/logger"); | |
var utils = require("cordova/utils"); | |
//------------------------------------------------------------------------------ | |
// object that we're exporting | |
//------------------------------------------------------------------------------ | |
var console = module.exports; | |
//------------------------------------------------------------------------------ | |
// copy of the original console object | |
//------------------------------------------------------------------------------ | |
var WinConsole = window.console; | |
//------------------------------------------------------------------------------ | |
// whether to use the logger | |
//------------------------------------------------------------------------------ | |
var UseLogger = false; | |
//------------------------------------------------------------------------------ | |
// Timers | |
//------------------------------------------------------------------------------ | |
var Timers = {}; | |
//------------------------------------------------------------------------------ | |
// used for unimplemented methods | |
//------------------------------------------------------------------------------ | |
function noop() {} | |
//------------------------------------------------------------------------------ | |
// used for unimplemented methods | |
//------------------------------------------------------------------------------ | |
console.useLogger = function (value) { | |
if (arguments.length) UseLogger = !!value; | |
if (UseLogger) { | |
if (logger.useConsole()) { | |
throw new Error("console and logger are too intertwingly"); | |
} | |
} | |
return UseLogger; | |
}; | |
//------------------------------------------------------------------------------ | |
console.log = function() { | |
if (logger.useConsole()) return; | |
logger.log.apply(logger, [].slice.call(arguments)); | |
}; | |
//------------------------------------------------------------------------------ | |
console.error = function() { | |
if (logger.useConsole()) return; | |
logger.error.apply(logger, [].slice.call(arguments)); | |
}; | |
//------------------------------------------------------------------------------ | |
console.warn = function() { | |
if (logger.useConsole()) return; | |
logger.warn.apply(logger, [].slice.call(arguments)); | |
}; | |
//------------------------------------------------------------------------------ | |
console.info = function() { | |
if (logger.useConsole()) return; | |
logger.info.apply(logger, [].slice.call(arguments)); | |
}; | |
//------------------------------------------------------------------------------ | |
console.debug = function() { | |
if (logger.useConsole()) return; | |
logger.debug.apply(logger, [].slice.call(arguments)); | |
}; | |
//------------------------------------------------------------------------------ | |
console.assert = function(expression) { | |
if (expression) return; | |
var message = logger.format.apply(logger.format, [].slice.call(arguments, 1)); | |
console.log("ASSERT: " + message); | |
}; | |
//------------------------------------------------------------------------------ | |
console.clear = function() {}; | |
//------------------------------------------------------------------------------ | |
console.dir = function(object) { | |
console.log("%o", object); | |
}; | |
//------------------------------------------------------------------------------ | |
console.dirxml = function(node) { | |
console.log(node.innerHTML); | |
}; | |
//------------------------------------------------------------------------------ | |
console.trace = noop; | |
//------------------------------------------------------------------------------ | |
console.group = console.log; | |
//------------------------------------------------------------------------------ | |
console.groupCollapsed = console.log; | |
//------------------------------------------------------------------------------ | |
console.groupEnd = noop; | |
//------------------------------------------------------------------------------ | |
console.time = function(name) { | |
Timers[name] = new Date().valueOf(); | |
}; | |
//------------------------------------------------------------------------------ | |
console.timeEnd = function(name) { | |
var timeStart = Timers[name]; | |
if (!timeStart) { | |
console.warn("unknown timer: " + name); | |
return; | |
} | |
var timeElapsed = new Date().valueOf() - timeStart; | |
console.log(name + ": " + timeElapsed + "ms"); | |
}; | |
//------------------------------------------------------------------------------ | |
console.timeStamp = noop; | |
//------------------------------------------------------------------------------ | |
console.profile = noop; | |
//------------------------------------------------------------------------------ | |
console.profileEnd = noop; | |
//------------------------------------------------------------------------------ | |
console.count = noop; | |
//------------------------------------------------------------------------------ | |
console.exception = console.log; | |
//------------------------------------------------------------------------------ | |
console.table = function(data, columns) { | |
console.log("%o", data); | |
}; | |
//------------------------------------------------------------------------------ | |
// return a new function that calls both functions passed as args | |
//------------------------------------------------------------------------------ | |
function wrappedOrigCall(orgFunc, newFunc) { | |
return function() { | |
var args = [].slice.call(arguments); | |
try { orgFunc.apply(WinConsole, args); } catch (e) {} | |
try { newFunc.apply(console, args); } catch (e) {} | |
}; | |
} | |
//------------------------------------------------------------------------------ | |
// For every function that exists in the original console object, that | |
// also exists in the new console object, wrap the new console method | |
// with one that calls both | |
//------------------------------------------------------------------------------ | |
for (var key in console) { | |
if (typeof WinConsole[key] == "function") { | |
console[key] = wrappedOrigCall(WinConsole[key], console[key]); | |
} | |
} | |
}); | |
// file: lib/common/plugin/contacts.js | |
define("cordova/plugin/contacts", function(require, exports, module) { | |
var argscheck = require('cordova/argscheck'), | |
exec = require('cordova/exec'), | |
ContactError = require('cordova/plugin/ContactError'), | |
utils = require('cordova/utils'), | |
Contact = require('cordova/plugin/Contact'); | |
/** | |
* Represents a group of Contacts. | |
* @constructor | |
*/ | |
var contacts = { | |
/** | |
* 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 | |
*/ | |
find:function(fields, successCB, errorCB, options) { | |
argscheck.checkArgs('afFO', 'contacts.find', arguments); | |
if (!fields.length) { | |
errorCB && errorCB(new ContactError(ContactError.INVALID_ARGUMENT_ERROR)); | |
} else { | |
var win = function(result) { | |
var cs = []; | |
for (var i = 0, l = result.length; i < l; i++) { | |
cs.push(contacts.create(result[i])); | |
} | |
successCB(cs); | |
}; | |
exec(win, 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 whose properties will be examined to create a new Contact | |
* @returns new Contact object | |
*/ | |
create:function(properties) { | |
argscheck.checkArgs('O', 'contacts.create', arguments); | |
var contact = new Contact(); | |
for (var i in properties) { | |
if (typeof contact[i] !== 'undefined' && properties.hasOwnProperty(i)) { | |
contact[i] = properties[i]; | |
} | |
} | |
return contact; | |
} | |
}; | |
module.exports = contacts; | |
}); | |
// file: lib/common/plugin/contacts/symbols.js | |
define("cordova/plugin/contacts/symbols", function(require, exports, module) { | |
var modulemapper = require('cordova/modulemapper'); | |
modulemapper.clobbers('cordova/plugin/contacts', 'navigator.contacts'); | |
modulemapper.clobbers('cordova/plugin/Contact', 'Contact'); | |
modulemapper.clobbers('cordova/plugin/ContactAddress', 'ContactAddress'); | |
modulemapper.clobbers('cordova/plugin/ContactError', 'ContactError'); | |
modulemapper.clobbers('cordova/plugin/ContactField', 'ContactField'); | |
modulemapper.clobbers('cordova/plugin/ContactFindOptions', 'ContactFindOptions'); | |
modulemapper.clobbers('cordova/plugin/ContactName', 'ContactName'); | |
modulemapper.clobbers('cordova/plugin/ContactOrganization', 'ContactOrganization'); | |
}); | |
// file: lib/common/plugin/device.js | |
define("cordova/plugin/device", function(require, exports, module) { | |
var argscheck = require('cordova/argscheck'), | |
channel = require('cordova/channel'), | |
utils = require('cordova/utils'), | |
exec = require('cordova/exec'); | |
// Tell cordova channel to wait on the CordovaInfoReady event | |
channel.waitForInitialization('onCordovaInfoReady'); | |
/** | |
* This represents the mobile device, and provides properties for inspecting the model, version, UUID of the | |
* phone, etc. | |
* @constructor | |
*/ | |
function Device() { | |
this.available = false; | |
this.platform = null; | |
this.version = null; | |
this.uuid = null; | |
this.cordova = null; | |
this.model = null; | |
var me = this; | |
channel.onCordovaReady.subscribe(function() { | |
me.getInfo(function(info) { | |
var buildLabel = info.cordova; | |
if (buildLabel != CORDOVA_JS_BUILD_LABEL) { | |
buildLabel += ' JS=' + CORDOVA_JS_BUILD_LABEL; | |
} | |
me.available = true; | |
me.platform = info.platform; | |
me.version = info.version; | |
me.uuid = info.uuid; | |
me.cordova = buildLabel; | |
me.model = info.model; | |
channel.onCordovaInfoReady.fire(); | |
},function(e) { | |
me.available = false; | |
utils.alert("[ERROR] Error initializing Cordova: " + e); | |
}); | |
}); | |
} | |
/** | |
* Get device info | |
* | |
* @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) | |
*/ | |
Device.prototype.getInfo = function(successCallback, errorCallback) { | |
argscheck.checkArgs('fF', 'Device.getInfo', arguments); | |
exec(successCallback, errorCallback, "Device", "getDeviceInfo", []); | |
}; | |
module.exports = new Device(); | |
}); | |
// file: lib/common/plugin/device/symbols.js | |
define("cordova/plugin/device/symbols", function(require, exports, module) { | |
var modulemapper = require('cordova/modulemapper'); | |
modulemapper.clobbers('cordova/plugin/device', 'device'); | |
}); | |
// file: lib/common/plugin/echo.js | |
define("cordova/plugin/echo", function(require, exports, module) { | |
var exec = require('cordova/exec'), | |
utils = require('cordova/utils'); | |
/** | |
* Sends the given message through exec() to the Echo plugin, which sends it back to the successCallback. | |
* @param successCallback invoked with a FileSystem object | |
* @param errorCallback invoked if error occurs retrieving file system | |
* @param message The string to be echoed. | |
* @param forceAsync Whether to force an async return value (for testing native->js bridge). | |
*/ | |
module.exports = function(successCallback, errorCallback, message, forceAsync) { | |
var action = 'echo'; | |
var messageIsMultipart = (utils.typeName(message) == "Array"); | |
var args = messageIsMultipart ? message : [message]; | |
if (utils.typeName(message) == 'ArrayBuffer') { | |
if (forceAsync) { | |
console.warn('Cannot echo ArrayBuffer with forced async, falling back to sync.'); | |
} | |
action += 'ArrayBuffer'; | |
} else if (messageIsMultipart) { | |
if (forceAsync) { | |
console.warn('Cannot echo MultiPart Array with forced async, falling back to sync.'); | |
} | |
action += 'MultiPart'; | |
} else if (forceAsync) { | |
action += 'Async'; | |
} | |
exec(successCallback, errorCallback, "Echo", action, args); | |
}; | |
}); | |
// file: lib/windows8/plugin/file/symbols.js | |
define("cordova/plugin/file/symbols", function(require, exports, module) { | |
var modulemapper = require('cordova/modulemapper'), | |
symbolshelper = require('cordova/plugin/file/symbolshelper'); | |
symbolshelper(modulemapper.defaults); | |
modulemapper.clobbers('cordova/plugin/File', 'File'); | |
modulemapper.clobbers('cordova/plugin/FileReader', 'FileReader'); | |
}); | |
// file: lib/common/plugin/file/symbolshelper.js | |
define("cordova/plugin/file/symbolshelper", function(require, exports, module) { | |
module.exports = function(exportFunc) { | |
exportFunc('cordova/plugin/DirectoryEntry', 'DirectoryEntry'); | |
exportFunc('cordova/plugin/DirectoryReader', 'DirectoryReader'); | |
exportFunc('cordova/plugin/Entry', 'Entry'); | |
exportFunc('cordova/plugin/File', 'File'); | |
exportFunc('cordova/plugin/FileEntry', 'FileEntry'); | |
exportFunc('cordova/plugin/FileError', 'FileError'); | |
exportFunc('cordova/plugin/FileReader', 'FileReader'); | |
exportFunc('cordova/plugin/FileSystem', 'FileSystem'); | |
exportFunc('cordova/plugin/FileUploadOptions', 'FileUploadOptions'); | |
exportFunc('cordova/plugin/FileUploadResult', 'FileUploadResult'); | |
exportFunc('cordova/plugin/FileWriter', 'FileWriter'); | |
exportFunc('cordova/plugin/Flags', 'Flags'); | |
exportFunc('cordova/plugin/LocalFileSystem', 'LocalFileSystem'); | |
exportFunc('cordova/plugin/Metadata', 'Metadata'); | |
exportFunc('cordova/plugin/ProgressEvent', 'ProgressEvent'); | |
exportFunc('cordova/plugin/requestFileSystem', 'requestFileSystem'); | |
exportFunc('cordova/plugin/resolveLocalFileSystemURI', 'resolveLocalFileSystemURI'); | |
}; | |
}); | |
// file: lib/common/plugin/filetransfer/symbols.js | |
define("cordova/plugin/filetransfer/symbols", function(require, exports, module) { | |
var modulemapper = require('cordova/modulemapper'); | |
modulemapper.clobbers('cordova/plugin/FileTransfer', 'FileTransfer'); | |
modulemapper.clobbers('cordova/plugin/FileTransferError', 'FileTransferError'); | |
}); | |
// file: lib/common/plugin/geolocation.js | |
define("cordova/plugin/geolocation", function(require, exports, module) { | |
var argscheck = require('cordova/argscheck'), | |
utils = require('cordova/utils'), | |
exec = require('cordova/exec'), | |
PositionError = require('cordova/plugin/PositionError'), | |
Position = require('cordova/plugin/Position'); | |
var timers = {}; // list of timers in use | |
// Returns default params, overrides if provided with values | |
function parseParameters(options) { | |
var opt = { | |
maximumAge: 0, | |
enableHighAccuracy: false, | |
timeout: Infinity | |
}; | |
if (options) { | |
if (options.maximumAge !== undefined && !isNaN(options.maximumAge) && options.maximumAge > 0) { | |
opt.maximumAge = options.maximumAge; | |
} | |
if (options.enableHighAccuracy !== undefined) { | |
opt.enableHighAccuracy = options.enableHighAccuracy; | |
} | |
if (options.timeout !== undefined && !isNaN(options.timeout)) { | |
if (options.timeout < 0) { | |
opt.timeout = 0; | |
} else { | |
opt.timeout = options.timeout; | |
} | |
} | |
} | |
return opt; | |
} | |
// Returns a timeout failure, closed over a specified timeout value and error callback. | |
function createTimeout(errorCallback, timeout) { | |
var t = setTimeout(function() { | |
clearTimeout(t); | |
t = null; | |
errorCallback({ | |
code:PositionError.TIMEOUT, | |
message:"Position retrieval timed out." | |
}); | |
}, timeout); | |
return t; | |
} | |
var geolocation = { | |
lastPosition:null, // reference to last known (cached) position returned | |
/** | |
* Asynchronously acquires the current position. | |
* | |
* @param {Function} successCallback The function to call when the position data is available | |
* @param {Function} errorCallback The function to call when there is an error getting the heading position. (OPTIONAL) | |
* @param {PositionOptions} options The options for getting the position data. (OPTIONAL) | |
*/ | |
getCurrentPosition:function(successCallback, errorCallback, options) { | |
argscheck.checkArgs('fFO', 'geolocation.getCurrentPosition', arguments); | |
options = parseParameters(options); | |
// Timer var that will fire an error callback if no position is retrieved from native | |
// before the "timeout" param provided expires | |
var timeoutTimer = {timer:null}; | |
var win = function(p) { | |
clearTimeout(timeoutTimer.timer); | |
if (!(timeoutTimer.timer)) { | |
// Timeout already happened, or native fired error callback for | |
// this geo request. | |
// Don't continue with success callback. | |
return; | |
} | |
var pos = new Position( | |
{ | |
latitude:p.latitude, | |
longitude:p.longitude, | |
altitude:p.altitude, | |
accuracy:p.accuracy, | |
heading:p.heading, | |
velocity:p.velocity, | |
altitudeAccuracy:p.altitudeAccuracy | |
}, | |
(p.timestamp === undefined ? new Date() : ((p.timestamp instanceof Date) ? p.timestamp : new Date(p.timestamp))) | |
); | |
geolocation.lastPosition = pos; | |
successCallback(pos); | |
}; | |
var fail = function(e) { | |
clearTimeout(timeoutTimer.timer); | |
timeoutTimer.timer = null; | |
var err = new PositionError(e.code, e.message); | |
if (errorCallback) { | |
errorCallback(err); | |
} | |
}; | |
// Check our cached position, if its timestamp difference with current time is less than the maximumAge, then just | |
// fire the success callback with the cached position. | |
if (geolocation.lastPosition && options.maximumAge && (((new Date()).getTime() - geolocation.lastPosition.timestamp.getTime()) <= options.maximumAge)) { | |
successCallback(geolocation.lastPosition); | |
// If the cached position check failed and the timeout was set to 0, error out with a TIMEOUT error object. | |
} else if (options.timeout === 0) { | |
fail({ | |
code:PositionError.TIMEOUT, | |
message:"timeout value in PositionOptions set to 0 and no cached Position object available, or cached Position object's age exceeds provided PositionOptions' maximumAge parameter." | |
}); | |
// Otherwise we have to call into native to retrieve a position. | |
} else { | |
if (options.timeout !== Infinity) { | |
// If the timeout value was not set to Infinity (default), then | |
// set up a timeout function that will fire the error callback | |
// if no successful position was retrieved before timeout expired. | |
timeoutTimer.timer = createTimeout(fail, options.timeout); | |
} else { | |
// This is here so the check in the win function doesn't mess stuff up | |
// may seem weird but this guarantees timeoutTimer is | |
// always truthy before we call into native | |
timeoutTimer.timer = true; | |
} | |
exec(win, fail, "Geolocation", "getLocation", [options.enableHighAccuracy, options.maximumAge]); | |
} | |
return timeoutTimer; | |
}, | |
/** | |
* Asynchronously watches the geolocation for changes to geolocation. When a change occurs, | |
* the successCallback is called with the new location. | |
* | |
* @param {Function} successCallback The function to call each time the location data is available | |
* @param {Function} errorCallback The function to call when there is an error getting the location data. (OPTIONAL) | |
* @param {PositionOptions} options The options for getting the location data such as frequency. (OPTIONAL) | |
* @return String The watch id that must be passed to #clearWatch to stop watching. | |
*/ | |
watchPosition:function(successCallback, errorCallback, options) { | |
argscheck.checkArgs('fFO', 'geolocation.getCurrentPosition', arguments); | |
options = parseParameters(options); | |
var id = utils.createUUID(); | |
// Tell device to get a position ASAP, and also retrieve a reference to the timeout timer generated in getCurrentPosition | |
timers[id] = geolocation.getCurrentPosition(successCallback, errorCallback, options); | |
var fail = function(e) { | |
clearTimeout(timers[id].timer); | |
var err = new PositionError(e.code, e.message); | |
if (errorCallback) { | |
errorCallback(err); | |
} | |
}; | |
var win = function(p) { | |
clearTimeout(timers[id].timer); | |
if (options.timeout !== Infinity) { | |
timers[id].timer = createTimeout(fail, options.timeout); | |
} | |
var pos = new Position( | |
{ | |
latitude:p.latitude, | |
longitude:p.longitude, | |
altitude:p.altitude, | |
accuracy:p.accuracy, | |
heading:p.heading, | |
velocity:p.velocity, | |
altitudeAccuracy:p.altitudeAccuracy | |
}, | |
(p.timestamp === undefined ? new Date() : ((p.timestamp instanceof Date) ? p.timestamp : new Date(p.timestamp))) | |
); | |
geolocation.lastPosition = pos; | |
successCallback(pos); | |
}; | |
exec(win, fail, "Geolocation", "addWatch", [id, options.enableHighAccuracy]); | |
return id; | |
}, | |
/** | |
* Clears the specified heading watch. | |
* | |
* @param {String} id The ID of the watch returned from #watchPosition | |
*/ | |
clearWatch:function(id) { | |
if (id && timers[id] !== undefined) { | |
clearTimeout(timers[id].timer); | |
timers[id].timer = false; | |
exec(null, null, "Geolocation", "clearWatch", [id]); | |
} | |
} | |
}; | |
module.exports = geolocation; | |
}); | |
// file: lib/common/plugin/geolocation/symbols.js | |
define("cordova/plugin/geolocation/symbols", function(require, exports, module) { | |
var modulemapper = require('cordova/modulemapper'); | |
modulemapper.defaults('cordova/plugin/geolocation', 'navigator.geolocation'); | |
modulemapper.clobbers('cordova/plugin/PositionError', 'PositionError'); | |
modulemapper.clobbers('cordova/plugin/Position', 'Position'); | |
modulemapper.clobbers('cordova/plugin/Coordinates', 'Coordinates'); | |
}); | |
// file: lib/common/plugin/globalization.js | |
define("cordova/plugin/globalization", function(require, exports, module) { | |
var argscheck = require('cordova/argscheck'), | |
exec = require('cordova/exec'), | |
GlobalizationError = require('cordova/plugin/GlobalizationError'); | |
var globalization = { | |
/** | |
* Returns the string identifier for the client's current language. | |
* It returns the language identifier string to the successCB callback with a | |
* properties object as a parameter. If there is an error getting the language, | |
* then the errorCB callback is invoked. | |
* | |
* @param {Function} successCB | |
* @param {Function} errorCB | |
* | |
* @return Object.value {String}: The language identifier | |
* | |
* @error GlobalizationError.UNKNOWN_ERROR | |
* | |
* Example | |
* globalization.getPreferredLanguage(function (language) {alert('language:' + language.value + '\n');}, | |
* function () {}); | |
*/ | |
getPreferredLanguage:function(successCB, failureCB) { | |
argscheck.checkArgs('fF', 'Globalization.getPreferredLanguage', arguments); | |
exec(successCB, failureCB, "Globalization","getPreferredLanguage", []); | |
}, | |
/** | |
* Returns the string identifier for the client's current locale setting. | |
* It returns the locale identifier string to the successCB callback with a | |
* properties object as a parameter. If there is an error getting the locale, | |
* then the errorCB callback is invoked. | |
* | |
* @param {Function} successCB | |
* @param {Function} errorCB | |
* | |
* @return Object.value {String}: The locale identifier | |
* | |
* @error GlobalizationError.UNKNOWN_ERROR | |
* | |
* Example | |
* globalization.getLocaleName(function (locale) {alert('locale:' + locale.value + '\n');}, | |
* function () {}); | |
*/ | |
getLocaleName:function(successCB, failureCB) { | |
argscheck.checkArgs('fF', 'Globalization.getLocaleName', arguments); | |
exec(successCB, failureCB, "Globalization","getLocaleName", []); | |
}, | |
/** | |
* Returns a date formatted as a string according to the client's user preferences and | |
* calendar using the time zone of the client. It returns the formatted date string to the | |
* successCB callback with a properties object as a parameter. If there is an error | |
* formatting the date, then the errorCB callback is invoked. | |
* | |
* The defaults are: formatLenght="short" and selector="date and time" | |
* | |
* @param {Date} date | |
* @param {Function} successCB | |
* @param {Function} errorCB | |
* @param {Object} options {optional} | |
* formatLength {String}: 'short', 'medium', 'long', or 'full' | |
* selector {String}: 'date', 'time', or 'date and time' | |
* | |
* @return Object.value {String}: The localized date string | |
* | |
* @error GlobalizationError.FORMATTING_ERROR | |
* | |
* Example | |
* globalization.dateToString(new Date(), | |
* function (date) {alert('date:' + date.value + '\n');}, | |
* function (errorCode) {alert(errorCode);}, | |
* {formatLength:'short'}); | |
*/ | |
dateToString:function(date, successCB, failureCB, options) { | |
argscheck.checkArgs('dfFO', 'Globalization.dateToString', arguments); | |
var dateValue = date.valueOf(); | |
exec(successCB, failureCB, "Globalization", "dateToString", [{"date": dateValue, "options": options}]); | |
}, | |
/** | |
* Parses a date formatted as a string according to the client's user | |
* preferences and calendar using the time zone of the client and returns | |
* the corresponding date object. It returns the date to the successCB | |
* callback with a properties object as a parameter. If there is an error | |
* parsing the date string, then the errorCB callback is invoked. | |
* | |
* The defaults are: formatLength="short" and selector="date and time" | |
* | |
* @param {String} dateString | |
* @param {Function} successCB | |
* @param {Function} errorCB | |
* @param {Object} options {optional} | |
* formatLength {String}: 'short', 'medium', 'long', or 'full' | |
* selector {String}: 'date', 'time', or 'date and time' | |
* | |
* @return Object.year {Number}: The four digit year | |
* Object.month {Number}: The month from (0 - 11) | |
* Object.day {Number}: The day from (1 - 31) | |
* Object.hour {Number}: The hour from (0 - 23) | |
* Object.minute {Number}: The minute from (0 - 59) | |
* Object.second {Number}: The second from (0 - 59) | |
* Object.millisecond {Number}: The milliseconds (from 0 - 999), | |
* not available on all platforms | |
* | |
* @error GlobalizationError.PARSING_ERROR | |
* | |
* Example | |
* globalization.stringToDate('4/11/2011', | |
* function (date) { alert('Month:' + date.month + '\n' + | |
* 'Day:' + date.day + '\n' + | |
* 'Year:' + date.year + '\n');}, | |
* function (errorCode) {alert(errorCode);}, | |
* {selector:'date'}); | |
*/ | |
stringToDate:function(dateString, successCB, failureCB, options) { | |
argscheck.checkArgs('sfFO', 'Globalization.stringToDate', arguments); | |
exec(successCB, failureCB, "Globalization", "stringToDate", [{"dateString": dateString, "options": options}]); | |
}, | |
/** | |
* Returns a pattern string for formatting and parsing dates according to the client's | |
* user preferences. It returns the pattern to the successCB callback with a | |
* properties object as a parameter. If there is an error obtaining the pattern, | |
* then the errorCB callback is invoked. | |
* | |
* The defaults are: formatLength="short" and selector="date and time" | |
* | |
* @param {Function} successCB | |
* @param {Function} errorCB | |
* @param {Object} options {optional} | |
* formatLength {String}: 'short', 'medium', 'long', or 'full' | |
* selector {String}: 'date', 'time', or 'date and time' | |
* | |
* @return Object.pattern {String}: The date and time pattern for formatting and parsing dates. | |
* The patterns follow Unicode Technical Standard #35 | |
* http://unicode.org/reports/tr35/tr35-4.html | |
* Object.timezone {String}: The abbreviated name of the time zone on the client | |
* Object.utc_offset {Number}: The current difference in seconds between the client's | |
* time zone and coordinated universal time. | |
* Object.dst_offset {Number}: The current daylight saving time offset in seconds | |
* between the client's non-daylight saving's time zone | |
* and the client's daylight saving's time zone. | |
* | |
* @error GlobalizationError.PATTERN_ERROR | |
* | |
* Example | |
* globalization.getDatePattern( | |
* function (date) {alert('pattern:' + date.pattern + '\n');}, | |
* function () {}, | |
* {formatLength:'short'}); | |
*/ | |
getDatePattern:function(successCB, failureCB, options) { | |
argscheck.checkArgs('fFO', 'Globalization.getDatePattern', arguments); | |
exec(successCB, failureCB, "Globalization", "getDatePattern", [{"options": options}]); | |
}, | |
/** | |
* Returns an array of either the names of the months or days of the week | |
* according to the client's user preferences and calendar. It returns the array of names to the | |
* successCB callback with a properties object as a parameter. If there is an error obtaining the | |
* names, then the errorCB callback is invoked. | |
* | |
* The defaults are: type="wide" and item="months" | |
* | |
* @param {Function} successCB | |
* @param {Function} errorCB | |
* @param {Object} options {optional} | |
* type {String}: 'narrow' or 'wide' | |
* item {String}: 'months', or 'days' | |
* | |
* @return Object.value {Array{String}}: The array of names starting from either | |
* the first month in the year or the | |
* first day of the week. | |
* @error GlobalizationError.UNKNOWN_ERROR | |
* | |
* Example | |
* globalization.getDateNames(function (names) { | |
* for(var i = 0; i < names.value.length; i++) { | |
* alert('Month:' + names.value[i] + '\n');}}, | |
* function () {}); | |
*/ | |
getDateNames:function(successCB, failureCB, options) { | |
argscheck.checkArgs('fFO', 'Globalization.getDateNames', arguments); | |
exec(successCB, failureCB, "Globalization", "getDateNames", [{"options": options}]); | |
}, | |
/** | |
* Returns whether daylight savings time is in effect for a given date using the client's | |
* time zone and calendar. It returns whether or not daylight savings time is in effect | |
* to the successCB callback with a properties object as a parameter. If there is an error | |
* reading the date, then the errorCB callback is invoked. | |
* | |
* @param {Date} date | |
* @param {Function} successCB | |
* @param {Function} errorCB | |
* | |
* @return Object.dst {Boolean}: The value "true" indicates that daylight savings time is | |
* in effect for the given date and "false" indicate that it is not. | |
* | |
* @error GlobalizationError.UNKNOWN_ERROR | |
* | |
* Example | |
* globalization.isDayLightSavingsTime(new Date(), | |
* function (date) {alert('dst:' + date.dst + '\n');} | |
* function () {}); | |
*/ | |
isDayLightSavingsTime:function(date, successCB, failureCB) { | |
argscheck.checkArgs('dfF', 'Globalization.isDayLightSavingsTime', arguments); | |
var dateValue = date.valueOf(); | |
exec(successCB, failureCB, "Globalization", "isDayLightSavingsTime", [{"date": dateValue}]); | |
}, | |
/** | |
* Returns the first day of the week according to the client's user preferences and calendar. | |
* The days of the week are numbered starting from 1 where 1 is considered to be Sunday. | |
* It returns the day to the successCB callback with a properties object as a parameter. | |
* If there is an error obtaining the pattern, then the errorCB callback is invoked. | |
* | |
* @param {Function} successCB | |
* @param {Function} errorCB | |
* | |
* @return Object.value {Number}: The number of the first day of the week. | |
* | |
* @error GlobalizationError.UNKNOWN_ERROR | |
* | |
* Example | |
* globalization.getFirstDayOfWeek(function (day) | |
* { alert('Day:' + day.value + '\n');}, | |
* function () {}); | |
*/ | |
getFirstDayOfWeek:function(successCB, failureCB) { | |
argscheck.checkArgs('fF', 'Globalization.getFirstDayOfWeek', arguments); | |
exec(successCB, failureCB, "Globalization", "getFirstDayOfWeek", []); | |
}, | |
/** | |
* Returns a number formatted as a string according to the client's user preferences. | |
* It returns the formatted number string to the successCB callback with a properties object as a | |
* parameter. If there is an error formatting the number, then the errorCB callback is invoked. | |
* | |
* The defaults are: type="decimal" | |
* | |
* @param {Number} number | |
* @param {Function} successCB | |
* @param {Function} errorCB | |
* @param {Object} options {optional} | |
* type {String}: 'decimal', "percent", or 'currency' | |
* | |
* @return Object.value {String}: The formatted number string. | |
* | |
* @error GlobalizationError.FORMATTING_ERROR | |
* | |
* Example | |
* globalization.numberToString(3.25, | |
* function (number) {alert('number:' + number.value + '\n');}, | |
* function () {}, | |
* {type:'decimal'}); | |
*/ | |
numberToString:function(number, successCB, failureCB, options) { | |
argscheck.checkArgs('nfFO', 'Globalization.numberToString', arguments); | |
exec(successCB, failureCB, "Globalization", "numberToString", [{"number": number, "options": options}]); | |
}, | |
/** | |
* Parses a number formatted as a string according to the client's user preferences and | |
* returns the corresponding number. It returns the number to the successCB callback with a | |
* properties object as a parameter. If there is an error parsing the number string, then | |
* the errorCB callback is invoked. | |
* | |
* The defaults are: type="decimal" | |
* | |
* @param {String} numberString | |
* @param {Function} successCB | |
* @param {Function} errorCB | |
* @param {Object} options {optional} | |
* type {String}: 'decimal', "percent", or 'currency' | |
* | |
* @return Object.value {Number}: The parsed number. | |
* | |
* @error GlobalizationError.PARSING_ERROR | |
* | |
* Example | |
* globalization.stringToNumber('1234.56', | |
* function (number) {alert('Number:' + number.value + '\n');}, | |
* function () { alert('Error parsing number');}); | |
*/ | |
stringToNumber:function(numberString, successCB, failureCB, options) { | |
argscheck.checkArgs('sfFO', 'Globalization.stringToNumber', arguments); | |
exec(successCB, failureCB, "Globalization", "stringToNumber", [{"numberString": numberString, "options": options}]); | |
}, | |
/** | |
* Returns a pattern string for formatting and parsing numbers according to the client's user | |
* preferences. It returns the pattern to the successCB callback with a properties object as a | |
* parameter. If there is an error obtaining the pattern, then the errorCB callback is invoked. | |
* | |
* The defaults are: type="decimal" | |
* | |
* @param {Function} successCB | |
* @param {Function} errorCB | |
* @param {Object} options {optional} | |
* type {String}: 'decimal', "percent", or 'currency' | |
* | |
* @return Object.pattern {String}: The number pattern for formatting and parsing numbers. | |
* The patterns follow Unicode Technical Standard #35. | |
* http://unicode.org/reports/tr35/tr35-4.html | |
* Object.symbol {String}: The symbol to be used when formatting and parsing | |
* e.g., percent or currency symbol. | |
* Object.fraction {Number}: The number of fractional digits to use when parsing and | |
* formatting numbers. | |
* Object.rounding {Number}: The rounding increment to use when parsing and formatting. | |
* Object.positive {String}: The symbol to use for positive numbers when parsing and formatting. | |
* Object.negative: {String}: The symbol to use for negative numbers when parsing and formatting. | |
* Object.decimal: {String}: The decimal symbol to use for parsing and formatting. | |
* Object.grouping: {String}: The grouping symbol to use for parsing and formatting. | |
* | |
* @error GlobalizationError.PATTERN_ERROR | |
* | |
* Example | |
* globalization.getNumberPattern( | |
* function (pattern) {alert('Pattern:' + pattern.pattern + '\n');}, | |
* function () {}); | |
*/ | |
getNumberPattern:function(successCB, failureCB, options) { | |
argscheck.checkArgs('fFO', 'Globalization.getNumberPattern', arguments); | |
exec(successCB, failureCB, "Globalization", "getNumberPattern", [{"options": options}]); | |
}, | |
/** | |
* Returns a pattern string for formatting and parsing currency values according to the client's | |
* user preferences and ISO 4217 currency code. It returns the pattern to the successCB callback with a | |
* properties object as a parameter. If there is an error obtaining the pattern, then the errorCB | |
* callback is invoked. | |
* | |
* @param {String} currencyCode | |
* @param {Function} successCB | |
* @param {Function} errorCB | |
* | |
* @return Object.pattern {String}: The currency pattern for formatting and parsing currency values. | |
* The patterns follow Unicode Technical Standard #35 | |
* http://unicode.org/reports/tr35/tr35-4.html | |
* Object.code {String}: The ISO 4217 currency code for the pattern. | |
* Object.fraction {Number}: The number of fractional digits to use when parsing and | |
* formatting currency. | |
* Object.rounding {Number}: The rounding increment to use when parsing and formatting. | |
* Object.decimal: {String}: The decimal symbol to use for parsing and formatting. | |
* Object.grouping: {String}: The grouping symbol to use for parsing and formatting. | |
* | |
* @error GlobalizationError.FORMATTING_ERROR | |
* | |
* Example | |
* globalization.getCurrencyPattern('EUR', | |
* function (currency) {alert('Pattern:' + currency.pattern + '\n');} | |
* function () {}); | |
*/ | |
getCurrencyPattern:function(currencyCode, successCB, failureCB) { | |
argscheck.checkArgs('sfF', 'Globalization.getCurrencyPattern', arguments); | |
exec(successCB, failureCB, "Globalization", "getCurrencyPattern", [{"currencyCode": currencyCode}]); | |
} | |
}; | |
module.exports = globalization; | |
}); | |
// file: lib/common/plugin/globalization/symbols.js | |
define("cordova/plugin/globalization/symbols", function(require, exports, module) { | |
var modulemapper = require('cordova/modulemapper'); | |
modulemapper.clobbers('cordova/plugin/globalization', 'navigator.globalization'); | |
modulemapper.clobbers('cordova/plugin/GlobalizationError', 'GlobalizationError'); | |
}); | |
// file: lib/common/plugin/logger.js | |
define("cordova/plugin/logger", function(require, exports, module) { | |
//------------------------------------------------------------------------------ | |
// The logger module exports the following properties/functions: | |
// | |
// LOG - constant for the level LOG | |
// ERROR - constant for the level ERROR | |
// WARN - constant for the level WARN | |
// INFO - constant for the level INFO | |
// DEBUG - constant for the level DEBUG | |
// logLevel() - returns current log level | |
// logLevel(value) - sets and returns a new log level | |
// useConsole() - returns whether logger is using console | |
// useConsole(value) - sets and returns whether logger is using console | |
// log(message,...) - logs a message at level LOG | |
// error(message,...) - logs a message at level ERROR | |
// warn(message,...) - logs a message at level WARN | |
// info(message,...) - logs a message at level INFO | |
// debug(message,...) - logs a message at level DEBUG | |
// logLevel(level,message,...) - logs a message specified level | |
// | |
//------------------------------------------------------------------------------ | |
var logger = exports; | |
var exec = require('cordova/exec'); | |
var utils = require('cordova/utils'); | |
var UseConsole = true; | |
var UseLogger = true; | |
var Queued = []; | |
var DeviceReady = false; | |
var CurrentLevel; | |
var originalConsole = console; | |
/** | |
* Logging levels | |
*/ | |
var Levels = [ | |
"LOG", | |
"ERROR", | |
"WARN", | |
"INFO", | |
"DEBUG" | |
]; | |
/* | |
* add the logging levels to the logger object and | |
* to a separate levelsMap object for testing | |
*/ | |
var LevelsMap = {}; | |
for (var i=0; i<Levels.length; i++) { | |
var level = Levels[i]; | |
LevelsMap[level] = i; | |
logger[level] = level; | |
} | |
CurrentLevel = LevelsMap.WARN; | |
/** | |
* Getter/Setter for the logging level | |
* | |
* Returns the current logging level. | |
* | |
* When a value is passed, sets the logging level to that value. | |
* The values should be one of the following constants: | |
* logger.LOG | |
* logger.ERROR | |
* logger.WARN | |
* logger.INFO | |
* logger.DEBUG | |
* | |
* The value used determines which messages get printed. The logging | |
* values above are in order, and only messages logged at the logging | |
* level or above will actually be displayed to the user. E.g., the | |
* default level is WARN, so only messages logged with LOG, ERROR, or | |
* WARN will be displayed; INFO and DEBUG messages will be ignored. | |
*/ | |
logger.level = function (value) { | |
if (arguments.length) { | |
if (LevelsMap[value] === null) { | |
throw new Error("invalid logging level: " + value); | |
} | |
CurrentLevel = LevelsMap[value]; | |
} | |
return Levels[CurrentLevel]; | |
}; | |
/** | |
* Getter/Setter for the useConsole functionality | |
* | |
* When useConsole is true, the logger will log via the | |
* browser 'console' object. | |
*/ | |
logger.useConsole = function (value) { | |
if (arguments.length) UseConsole = !!value; | |
if (UseConsole) { | |
if (typeof console == "undefined") { | |
throw new Error("global console object is not defined"); | |
} | |
if (typeof console.log != "function") { | |
throw new Error("global console object does not have a log function"); | |
} | |
if (typeof console.useLogger == "function") { | |
if (console.useLogger()) { | |
throw new Error("console and logger are too intertwingly"); | |
} | |
} | |
} | |
return UseConsole; | |
}; | |
/** | |
* Getter/Setter for the useLogger functionality | |
* | |
* When useLogger is true, the logger will log via the | |
* native Logger plugin. | |
*/ | |
logger.useLogger = function (value) { | |
// Enforce boolean | |
if (arguments.length) UseLogger = !!value; | |
return UseLogger; | |
}; | |
/** | |
* Logs a message at the LOG level. | |
* | |
* Parameters passed after message are used applied to | |
* the message with utils.format() | |
*/ | |
logger.log = function(message) { logWithArgs("LOG", arguments); }; | |
/** | |
* Logs a message at the ERROR level. | |
* | |
* Parameters passed after message are used applied to | |
* the message with utils.format() | |
*/ | |
logger.error = function(message) { logWithArgs("ERROR", arguments); }; | |
/** | |
* Logs a message at the WARN level. | |
* | |
* Parameters passed after message are used applied to | |
* the message with utils.format() | |
*/ | |
logger.warn = function(message) { logWithArgs("WARN", arguments); }; | |
/** | |
* Logs a message at the INFO level. | |
* | |
* Parameters passed after message are used applied to | |
* the message with utils.format() | |
*/ | |
logger.info = function(message) { logWithArgs("INFO", arguments); }; | |
/** | |
* Logs a message at the DEBUG level. | |
* | |
* Parameters passed after message are used applied to | |
* the message with utils.format() | |
*/ | |
logger.debug = function(message) { logWithArgs("DEBUG", arguments); }; | |
// log at the specified level with args | |
function logWithArgs(level, args) { | |
args = [level].concat([].slice.call(args)); | |
logger.logLevel.apply(logger, args); | |
} | |
/** | |
* Logs a message at the specified level. | |
* | |
* Parameters passed after message are used applied to | |
* the message with utils.format() | |
*/ | |
logger.logLevel = function(level /* , ... */) { | |
// format the message with the parameters | |
var formatArgs = [].slice.call(arguments, 1); | |
var message = logger.format.apply(logger.format, formatArgs); | |
if (LevelsMap[level] === null) { | |
throw new Error("invalid logging level: " + level); | |
} | |
if (LevelsMap[level] > CurrentLevel) return; | |
// queue the message if not yet at deviceready | |
if (!DeviceReady && !UseConsole) { | |
Queued.push([level, message]); | |
return; | |
} | |
// Log using the native logger if that is enabled | |
if (UseLogger) { | |
exec(null, null, "Logger", "logLevel", [level, message]); | |
} | |
// Log using the console if that is enabled | |
if (UseConsole) { | |
// make sure console is not using logger | |
if (console.__usingCordovaLogger) { | |
throw new Error("console and logger are too intertwingly"); | |
} | |
// log to the console | |
switch (level) { | |
case logger.LOG: originalConsole.log(message); break; | |
case logger.ERROR: originalConsole.log("ERROR: " + message); break; | |
case logger.WARN: originalConsole.log("WARN: " + message); break; | |
case logger.INFO: originalConsole.log("INFO: " + message); break; | |
case logger.DEBUG: originalConsole.log("DEBUG: " + message); break; | |
} | |
} | |
}; | |
/** | |
* Formats a string and arguments following it ala console.log() | |
* | |
* Any remaining arguments will be appended to the formatted string. | |
* | |
* for rationale, see FireBug's Console API: | |
* http://getfirebug.com/wiki/index.php/Console_API | |
*/ | |
logger.format = function(formatString, args) { | |
return __format(arguments[0], [].slice.call(arguments,1)).join(' '); | |
}; | |
//------------------------------------------------------------------------------ | |
/** | |
* Formats a string and arguments following it ala vsprintf() | |
* | |
* format chars: | |
* %j - format arg as JSON | |
* %o - format arg as JSON | |
* %c - format arg as '' | |
* %% - replace with '%' | |
* any other char following % will format it's | |
* arg via toString(). | |
* | |
* Returns an array containing the formatted string and any remaining | |
* arguments. | |
*/ | |
function __format(formatString, args) { | |
if (formatString === null || formatString === undefined) return [""]; | |
if (arguments.length == 1) return [formatString.toString()]; | |
if (typeof formatString != "string") | |
formatString = formatString.toString(); | |
var pattern = /(.*?)%(.)(.*)/; | |
var rest = formatString; | |
var result = []; | |
while (args.length) { | |
var match = pattern.exec(rest); | |
if (!match) break; | |
var arg = args.shift(); | |
rest = match[3]; | |
result.push(match[1]); | |
if (match[2] == '%') { | |
result.push('%'); | |
args.unshift(arg); | |
continue; | |
} | |
result.push(__formatted(arg, match[2])); | |
} | |
result.push(rest); | |
var remainingArgs = [].slice.call(args); | |
remainingArgs.unshift(result.join('')); | |
return remainingArgs; | |
} | |
function __formatted(object, formatChar) { | |
try { | |
switch(formatChar) { | |
case 'j': | |
case 'o': return JSON.stringify(object); | |
case 'c': return ''; | |
} | |
} | |
catch (e) { | |
return "error JSON.stringify()ing argument: " + e; | |
} | |
if ((object === null) || (object === undefined)) { | |
return Object.prototype.toString.call(object); | |
} | |
return object.toString(); | |
} | |
//------------------------------------------------------------------------------ | |
// when deviceready fires, log queued messages | |
logger.__onDeviceReady = function() { | |
if (DeviceReady) return; | |
DeviceReady = true; | |
for (var i=0; i<Queued.length; i++) { | |
var messageArgs = Queued[i]; | |
logger.logLevel(messageArgs[0], messageArgs[1]); | |
} | |
Queued = null; | |
}; | |
// add a deviceready event to log queued messages | |
document.addEventListener("deviceready", logger.__onDeviceReady, false); | |
}); | |
// file: lib/common/plugin/logger/symbols.js | |
define("cordova/plugin/logger/symbols", function(require, exports, module) { | |
var modulemapper = require('cordova/modulemapper'); | |
modulemapper.clobbers('cordova/plugin/logger', 'cordova.logger'); | |
}); | |
// file: lib/windows8/plugin/media/symbols.js | |
define("cordova/plugin/media/symbols", function(require, exports, module) { | |
var modulemapper = require('cordova/modulemapper'); | |
modulemapper.defaults('cordova/plugin/Media', 'Media'); | |
modulemapper.clobbers('cordova/plugin/MediaError', 'MediaError'); | |
}); | |
// file: lib/common/plugin/network.js | |
define("cordova/plugin/network", function(require, exports, module) { | |
var exec = require('cordova/exec'), | |
cordova = require('cordova'), | |
channel = require('cordova/channel'), | |
utils = require('cordova/utils'); | |
// Link the onLine property with the Cordova-supplied network info. | |
// This works because we clobber the naviagtor object with our own | |
// object in bootstrap.js. | |
if (typeof navigator != 'undefined') { | |
utils.defineGetter(navigator, 'onLine', function() { | |
return this.connection.type != 'none'; | |
}); | |
} | |
function NetworkConnection() { | |
this.type = 'unknown'; | |
} | |
/** | |
* Get connection info | |
* | |
* @param {Function} successCallback The function to call when the Connection data is available | |
* @param {Function} errorCallback The function to call when there is an error getting the Connection data. (OPTIONAL) | |
*/ | |
NetworkConnection.prototype.getInfo = function(successCallback, errorCallback) { | |
exec(successCallback, errorCallback, "NetworkStatus", "getConnectionInfo", []); | |
}; | |
var me = new NetworkConnection(); | |
var timerId = null; | |
var timeout = 500; | |
channel.onCordovaReady.subscribe(function() { | |
me.getInfo(function(info) { | |
me.type = info; | |
if (info === "none") { | |
// set a timer if still offline at the end of timer send the offline event | |
timerId = setTimeout(function(){ | |
cordova.fireDocumentEvent("offline"); | |
timerId = null; | |
}, timeout); | |
} else { | |
// If there is a current offline event pending clear it | |
if (timerId !== null) { | |
clearTimeout(timerId); | |
timerId = null; | |
} | |
cordova.fireDocumentEvent("online"); | |
} | |
// should only fire this once | |
if (channel.onCordovaConnectionReady.state !== 2) { | |
channel.onCordovaConnectionReady.fire(); | |
} | |
}, | |
function (e) { | |
// If we can't get the network info we should still tell Cordova | |
// to fire the deviceready event. | |
if (channel.onCordovaConnectionReady.state !== 2) { | |
channel.onCordovaConnectionReady.fire(); | |
} | |
console.log("Error initializing Network Connection: " + e); | |
}); | |
}); | |
module.exports = me; | |
}); | |
// file: lib/common/plugin/networkstatus/symbols.js | |
define("cordova/plugin/networkstatus/symbols", function(require, exports, module) { | |
var modulemapper = require('cordova/modulemapper'); | |
modulemapper.clobbers('cordova/plugin/network', 'navigator.network.connection', 'navigator.network.connection is deprecated. Use navigator.connection instead.'); | |
modulemapper.clobbers('cordova/plugin/network', 'navigator.connection'); | |
modulemapper.defaults('cordova/plugin/Connection', 'Connection'); | |
}); | |
// file: lib/common/plugin/notification.js | |
define("cordova/plugin/notification", function(require, exports, module) { | |
var exec = require('cordova/exec'); | |
var platform = require('cordova/platform'); | |
/** | |
* Provides access to notifications on the device. | |
*/ | |
module.exports = { | |
/** | |
* Open a native alert dialog, with a customizable title and button text. | |
* | |
* @param {String} message Message to print in the body of the alert | |
* @param {Function} completeCallback The callback that is called when user clicks on a button. | |
* @param {String} title Title of the alert dialog (default: Alert) | |
* @param {String} buttonLabel Label of the close button (default: OK) | |
*/ | |
alert: function(message, completeCallback, title, buttonLabel) { | |
var _title = (title || "Alert"); | |
var _buttonLabel = (buttonLabel || "OK"); | |
exec(completeCallback, null, "Notification", "alert", [message, _title, _buttonLabel]); | |
}, | |
/** | |
* Open a native confirm dialog, with a customizable title and button text. | |
* The result that the user selects is returned to the result callback. | |
* | |
* @param {String} message Message to print in the body of the alert | |
* @param {Function} resultCallback The callback that is called when user clicks on a button. | |
* @param {String} title Title of the alert dialog (default: Confirm) | |
* @param {Array} buttonLabels Array of the labels of the buttons (default: ['OK', 'Cancel']) | |
*/ | |
confirm: function(message, resultCallback, title, buttonLabels) { | |
var _title = (title || "Confirm"); | |
var _buttonLabels = (buttonLabels || ["OK", "Cancel"]); | |
// Strings are deprecated! | |
if (typeof _buttonLabels === 'string') { | |
console.log("Notification.confirm(string, function, string, string) is deprecated. Use Notification.confirm(string, function, string, array)."); | |
} | |
// Some platforms take an array of button label names. | |
// Other platforms take a comma separated list. | |
// For compatibility, we convert to the desired type based on the platform. | |
if (platform.id == "android" || platform.id == "ios" || platform.id == "windowsphone" || platform.id == "blackberry10") { | |
if (typeof _buttonLabels === 'string') { | |
var buttonLabelString = _buttonLabels; | |
_buttonLabels = _buttonLabels.split(","); // not crazy about changing the var type here | |
} | |
} else { | |
if (Array.isArray(_buttonLabels)) { | |
var buttonLabelArray = _buttonLabels; | |
_buttonLabels = buttonLabelArray.toString(); | |
} | |
} | |
exec(resultCallback, null, "Notification", "confirm", [message, _title, _buttonLabels]); | |
}, | |
/** | |
* Open a native prompt dialog, with a customizable title and button text. | |
* The following results are returned to the result callback: | |
* buttonIndex Index number of the button selected. | |
* input1 The text entered in the prompt dialog box. | |
* | |
* @param {String} message Dialog message to display (default: "Prompt message") | |
* @param {Function} resultCallback The callback that is called when user clicks on a button. | |
* @param {String} title Title of the dialog (default: "Prompt") | |
* @param {Array} buttonLabels Array of strings for the button labels (default: ["OK","Cancel"]) | |
* @param {String} defaultText Textbox input value (default: "Default text") | |
*/ | |
prompt: function(message, resultCallback, title, buttonLabels, defaultText) { | |
var _message = (message || "Prompt message"); | |
var _title = (title || "Prompt"); | |
var _buttonLabels = (buttonLabels || ["OK","Cancel"]); | |
var _defaultText = (defaultText || "Default text"); | |
exec(resultCallback, null, "Notification", "prompt", [_message, _title, _buttonLabels, _defaultText]); | |
}, | |
/** | |
* Causes the device to vibrate. | |
* | |
* @param {Integer} mills The number of milliseconds to vibrate for. | |
*/ | |
vibrate: function(mills) { | |
exec(null, null, "Notification", "vibrate", [mills]); | |
}, | |
/** | |
* Causes the device to beep. | |
* On Android, the default notification ringtone is played "count" times. | |
* | |
* @param {Integer} count The number of beeps. | |
*/ | |
beep: function(count) { | |
exec(null, null, "Notification", "beep", [count]); | |
} | |
}; | |
}); | |
// file: lib/common/plugin/notification/symbols.js | |
define("cordova/plugin/notification/symbols", function(require, exports, module) { | |
var modulemapper = require('cordova/modulemapper'); | |
modulemapper.defaults('cordova/plugin/notification', 'navigator.notification'); | |
}); | |
// file: lib/common/plugin/requestFileSystem.js | |
define("cordova/plugin/requestFileSystem", function(require, exports, module) { | |
var argscheck = require('cordova/argscheck'), | |
FileError = require('cordova/plugin/FileError'), | |
FileSystem = require('cordova/plugin/FileSystem'), | |
exec = require('cordova/exec'); | |
/** | |
* Request a file system in which to store application data. | |
* @param type local file system type | |
* @param size indicates how much storage space, in bytes, the application expects to need | |
* @param successCallback invoked with a FileSystem object | |
* @param errorCallback invoked if error occurs retrieving file system | |
*/ | |
var requestFileSystem = function(type, size, successCallback, errorCallback) { | |
argscheck.checkArgs('nnFF', 'requestFileSystem', arguments); | |
var fail = function(code) { | |
errorCallback && errorCallback(new FileError(code)); | |
}; | |
if (type < 0 || type > 3) { | |
fail(FileError.SYNTAX_ERR); | |
} else { | |
// if successful, return a FileSystem object | |
var success = function(file_system) { | |
if (file_system) { | |
if (successCallback) { | |
// grab the name and root from the file system object | |
var result = new FileSystem(file_system.name, file_system.root); | |
successCallback(result); | |
} | |
} | |
else { | |
// no FileSystem object returned | |
fail(FileError.NOT_FOUND_ERR); | |
} | |
}; | |
exec(success, fail, "File", "requestFileSystem", [type, size]); | |
} | |
}; | |
module.exports = requestFileSystem; | |
}); | |
// file: lib/common/plugin/resolveLocalFileSystemURI.js | |
define("cordova/plugin/resolveLocalFileSystemURI", function(require, exports, module) { | |
var argscheck = require('cordova/argscheck'), | |
DirectoryEntry = require('cordova/plugin/DirectoryEntry'), | |
FileEntry = require('cordova/plugin/FileEntry'), | |
FileError = require('cordova/plugin/FileError'), | |
exec = require('cordova/exec'); | |
/** | |
* Look up file system Entry referred to by local URI. | |
* @param {DOMString} uri URI referring to a local file or directory | |
* @param successCallback invoked with Entry object corresponding to URI | |
* @param errorCallback invoked if error occurs retrieving file system entry | |
*/ | |
module.exports = function(uri, successCallback, errorCallback) { | |
argscheck.checkArgs('sFF', 'resolveLocalFileSystemURI', arguments); | |
// error callback | |
var fail = function(error) { | |
errorCallback && errorCallback(new FileError(error)); | |
}; | |
// sanity check for 'not:valid:filename' | |
if(!uri || uri.split(":").length > 2) { | |
setTimeout( function() { | |
fail(FileError.ENCODING_ERR); | |
},0); | |
return; | |
} | |
// if successful, return either a file or directory entry | |
var success = function(entry) { | |
var result; | |
if (entry) { | |
if (successCallback) { | |
// create appropriate Entry object | |
result = (entry.isDirectory) ? new DirectoryEntry(entry.name, entry.fullPath) : new FileEntry(entry.name, entry.fullPath); | |
successCallback(result); | |
} | |
} | |
else { | |
// no Entry object returned | |
fail(FileError.NOT_FOUND_ERR); | |
} | |
}; | |
exec(success, fail, "File", "resolveLocalFileSystemURI", [uri]); | |
}; | |
}); | |
// file: lib/common/plugin/splashscreen.js | |
define("cordova/plugin/splashscreen", function(require, exports, module) { | |
var exec = require('cordova/exec'); | |
var splashscreen = { | |
show:function() { | |
exec(null, null, "SplashScreen", "show", []); | |
}, | |
hide:function() { | |
exec(null, null, "SplashScreen", "hide", []); | |
} | |
}; | |
module.exports = splashscreen; | |
}); | |
// file: lib/common/plugin/splashscreen/symbols.js | |
define("cordova/plugin/splashscreen/symbols", function(require, exports, module) { | |
var modulemapper = require('cordova/modulemapper'); | |
modulemapper.clobbers('cordova/plugin/splashscreen', 'navigator.splashscreen'); | |
}); | |
// file: lib/windows8/plugin/windows8/AccelerometerProxy.js | |
define("cordova/plugin/windows8/AccelerometerProxy", function(require, exports, module) { | |
/*global Windows:true */ | |
var cordova = require('cordova'), | |
Acceleration = require('cordova/plugin/Acceleration'); | |
/* This is the actual implementation part that returns the result on Windows 8 | |
*/ | |
module.exports = { | |
onDataChanged:null, | |
start:function(win,lose){ | |
var accel = Windows.Devices.Sensors.Accelerometer.getDefault(); | |
if(!accel) { | |
lose && lose("No accelerometer found"); | |
} | |
else { | |
var self = this; | |
accel.reportInterval = Math.max(16,accel.minimumReportInterval); | |
// store our bound function | |
this.onDataChanged = function(e) { | |
var a = e.reading; | |
win(new Acceleration(a.accelerationX,a.accelerationY,a.accelerationZ)); | |
}; | |
accel.addEventListener("readingchanged",this.onDataChanged); | |
setTimeout(function(){ | |
var a = accel.getCurrentReading(); | |
win(new Acceleration(a.accelerationX,a.accelerationY,a.accelerationZ)); | |
},0); // async do later | |
} | |
}, | |
stop:function(win,lose){ | |
win = win || function(){}; | |
var accel = Windows.Devices.Sensors.Accelerometer.getDefault(); | |
if(!accel) { | |
lose && lose("No accelerometer found"); | |
} | |
else { | |
accel.removeEventListener("readingchanged",this.onDataChanged); | |
this.onDataChanged = null; | |
accel.reportInterval = 0; // back to the default | |
win(); | |
} | |
} | |
}; | |
require("cordova/commandProxy").add("Accelerometer",module.exports); | |
}); | |
// file: lib/windows8/plugin/windows8/CameraProxy.js | |
define("cordova/plugin/windows8/CameraProxy", function(require, exports, module) { | |
/*global Windows:true, URL:true */ | |
var cordova = require('cordova'), | |
Camera = require('cordova/plugin/CameraConstants'), | |
FileEntry = require('cordova/plugin/FileEntry'), | |
FileError = require('cordova/plugin/FileError'), | |
FileReader = require('cordova/plugin/FileReader'); | |
module.exports = { | |
// args will contain : | |
// ... it is an array, so be careful | |
// 0 quality:50, | |
// 1 destinationType:Camera.DestinationType.FILE_URI, | |
// 2 sourceType:Camera.PictureSourceType.CAMERA, | |
// 3 targetWidth:-1, | |
// 4 targetHeight:-1, | |
// 5 encodingType:Camera.EncodingType.JPEG, | |
// 6 mediaType:Camera.MediaType.PICTURE, | |
// 7 allowEdit:false, | |
// 8 correctOrientation:false, | |
// 9 saveToPhotoAlbum:false, | |
// 10 popoverOptions:null | |
takePicture: function (successCallback, errorCallback, args) { | |
var encodingType = args[5]; | |
var targetWidth = args[3]; | |
var targetHeight = args[4]; | |
var sourceType = args[2]; | |
var destinationType = args[1]; | |
var mediaType = args[6]; | |
var saveToPhotoAlbum = args[9]; | |
var pkg = Windows.ApplicationModel.Package.current; | |
var packageId = pkg.installedLocation; | |
var fail = function (fileError) { | |
errorCallback("FileError, code:" + fileError.code); | |
}; | |
// resize method :) | |
var resizeImage = function (file) { | |
var tempPhotoFileName = ""; | |
if (encodingType == Camera.EncodingType.PNG) { | |
tempPhotoFileName = "camera_cordova_temp_return.png"; | |
} else { | |
tempPhotoFileName = "camera_cordova_temp_return.jpg"; | |
} | |
var imgObj = new Image(); | |
var success = function (fileEntry) { | |
var successCB = function (filePhoto) { | |
var fileType = file.contentType, | |
reader = new FileReader(); | |
reader.onloadend = function () { | |
var image = new Image(); | |
image.src = reader.result; | |
image.onload = function () { | |
var imageWidth = targetWidth, | |
imageHeight = targetHeight; | |
var canvas = document.createElement('canvas'); | |
canvas.width = imageWidth; | |
canvas.height = imageHeight; | |
var ctx = canvas.getContext("2d"); | |
ctx.drawImage(this, 0, 0, imageWidth, imageHeight); | |
// The resized file ready for upload | |
var _blob = canvas.msToBlob(); | |
var _stream = _blob.msDetachStream(); | |
Windows.Storage.StorageFolder.getFolderFromPathAsync(packageId.path).done(function (storageFolder) { | |
storageFolder.createFileAsync(tempPhotoFileName, Windows.Storage.CreationCollisionOption.generateUniqueName).done(function (file) { | |
file.openAsync(Windows.Storage.FileAccessMode.readWrite).done(function (fileStream) { | |
Windows.Storage.Streams.RandomAccessStream.copyAndCloseAsync(_stream, fileStream).done(function () { | |
var _imageUrl = URL.createObjectURL(file); | |
successCallback(_imageUrl); | |
}, function () { errorCallback("Resize picture error."); }); | |
}, function () { errorCallback("Resize picture error."); }); | |
}, function () { errorCallback("Resize picture error."); }); | |
}); | |
}; | |
}; | |
reader.readAsDataURL(filePhoto); | |
}; | |
var failCB = function () { | |
errorCallback("File not found."); | |
}; | |
fileEntry.file(successCB, failCB); | |
}; | |
Windows.Storage.StorageFolder.getFolderFromPathAsync(packageId.path).done(function (storageFolder) { | |
file.copyAsync(storageFolder, file.name, Windows.Storage.NameCollisionOption.replaceExisting).then(function (storageFile) { | |
success(new FileEntry(storageFile.name, storageFile.path)); | |
}, function () { | |
fail(FileError.INVALID_MODIFICATION_ERR); | |
}, function () { | |
errorCallback("Folder not access."); | |
}); | |
}); | |
}; | |
// because of asynchronous method, so let the successCallback be called in it. | |
var resizeImageBase64 = function (file) { | |
var imgObj = new Image(); | |
var success = function (fileEntry) { | |
var successCB = function (filePhoto) { | |
var fileType = file.contentType, | |
reader = new FileReader(); | |
reader.onloadend = function () { | |
var image = new Image(); | |
image.src = reader.result; | |
image.onload = function () { | |
var imageWidth = targetWidth, | |
imageHeight = targetHeight; | |
var canvas = document.createElement('canvas'); | |
canvas.width = imageWidth; | |
canvas.height = imageHeight; | |
var ctx = canvas.getContext("2d"); | |
ctx.drawImage(this, 0, 0, imageWidth, imageHeight); | |
// The resized file ready for upload | |
var finalFile = canvas.toDataURL(fileType); | |
// Remove the prefix such as "data:" + contentType + ";base64," , in order to meet the Cordova API. | |
var arr = finalFile.split(","); | |
var newStr = finalFile.substr(arr[0].length + 1); | |
successCallback(newStr); | |
}; | |
}; | |
reader.readAsDataURL(filePhoto); | |
}; | |
var failCB = function () { | |
errorCallback("File not found."); | |
}; | |
fileEntry.file(successCB, failCB); | |
}; | |
Windows.Storage.StorageFolder.getFolderFromPathAsync(packageId.path).done(function (storageFolder) { | |
file.copyAsync(storageFolder, file.name, Windows.Storage.NameCollisionOption.replaceExisting).then(function (storageFile) { | |
success(new FileEntry(storageFile.name, storageFile.path)); | |
}, function () { | |
fail(FileError.INVALID_MODIFICATION_ERR); | |
}, function () { | |
errorCallback("Folder not access."); | |
}); | |
}); | |
}; | |
if (sourceType != Camera.PictureSourceType.CAMERA) { | |
var fileOpenPicker = new Windows.Storage.Pickers.FileOpenPicker(); | |
fileOpenPicker.suggestedStartLocation = Windows.Storage.Pickers.PickerLocationId.picturesLibrary; | |
if (mediaType == Camera.MediaType.PICTURE) { | |
fileOpenPicker.fileTypeFilter.replaceAll([".png", ".jpg", ".jpeg"]); | |
} else if (mediaType == Camera.MediaType.VIDEO) { | |
fileOpenPicker.fileTypeFilter.replaceAll([".avi", ".flv", ".asx", ".asf", ".mov", ".mp4", ".mpg", ".rm", ".srt", ".swf", ".wmv", ".vob"]); | |
} else { | |
fileOpenPicker.fileTypeFilter.replaceAll(["*"]); | |
} | |
fileOpenPicker.pickSingleFileAsync().then(function (file) { | |
if (file) { | |
if (destinationType == Camera.DestinationType.FILE_URI) { | |
if (targetHeight > 0 && targetWidth > 0) { | |
resizeImage(file); | |
} else { | |
Windows.Storage.StorageFolder.getFolderFromPathAsync(packageId.path).done(function (storageFolder) { | |
file.copyAsync(storageFolder, file.name, Windows.Storage.NameCollisionOption.replaceExisting).then(function (storageFile) { | |
var _imageUrl = URL.createObjectURL(storageFile); | |
successCallback(_imageUrl); | |
}, function () { | |
fail(FileError.INVALID_MODIFICATION_ERR); | |
}, function () { | |
errorCallback("Folder not access."); | |
}); | |
}); | |
} | |
} | |
else { | |
if (targetHeight > 0 && targetWidth > 0) { | |
resizeImageBase64(file); | |
} else { | |
Windows.Storage.FileIO.readBufferAsync(file).done(function (buffer) { | |
var strBase64 = Windows.Security.Cryptography.CryptographicBuffer.encodeToBase64String(buffer); | |
successCallback(strBase64); | |
}); | |
} | |
} | |
} else { | |
errorCallback("User didn't choose a file."); | |
} | |
}, function () { | |
errorCallback("User didn't choose a file."); | |
}); | |
} | |
else { | |
var cameraCaptureUI = new Windows.Media.Capture.CameraCaptureUI(); | |
cameraCaptureUI.photoSettings.allowCropping = true; | |
var allowCrop = !!args[7]; | |
if (!allowCrop) { | |
cameraCaptureUI.photoSettings.allowCropping = false; | |
} | |
if (encodingType == Camera.EncodingType.PNG) { | |
cameraCaptureUI.photoSettings.format = Windows.Media.Capture.CameraCaptureUIPhotoFormat.png; | |
} else { | |
cameraCaptureUI.photoSettings.format = Windows.Media.Capture.CameraCaptureUIPhotoFormat.jpeg; | |
} | |
// decide which max pixels should be supported by targetWidth or targetHeight. | |
if (targetWidth >= 1280 || targetHeight >= 960) { | |
cameraCaptureUI.photoSettings.maxResolution = Windows.Media.Capture.CameraCaptureUIMaxPhotoResolution.large3M; | |
} else if (targetWidth >= 1024 || targetHeight >= 768) { | |
cameraCaptureUI.photoSettings.maxResolution = Windows.Media.Capture.CameraCaptureUIMaxPhotoResolution.mediumXga; | |
} else if (targetWidth >= 800 || targetHeight >= 600) { | |
cameraCaptureUI.photoSettings.maxResolution = Windows.Media.Capture.CameraCaptureUIMaxPhotoResolution.mediumXga; | |
} else if (targetWidth >= 640 || targetHeight >= 480) { | |
cameraCaptureUI.photoSettings.maxResolution = Windows.Media.Capture.CameraCaptureUIMaxPhotoResolution.smallVga; | |
} else if (targetWidth >= 320 || targetHeight >= 240) { | |
cameraCaptureUI.photoSettings.maxResolution = Windows.Media.Capture.CameraCaptureUIMaxPhotoResolution.verySmallQvga; | |
} else { | |
cameraCaptureUI.photoSettings.maxResolution = Windows.Media.Capture.CameraCaptureUIMaxPhotoResolution.highestAvailable; | |
} | |
cameraCaptureUI.captureFileAsync(Windows.Media.Capture.CameraCaptureUIMode.photo).then(function (picture) { | |
if (picture) { | |
// save to photo album successCallback | |
var success = function (fileEntry) { | |
if (destinationType == Camera.DestinationType.FILE_URI) { | |
if (targetHeight > 0 && targetWidth > 0) { | |
resizeImage(picture); | |
} else { | |
Windows.Storage.StorageFolder.getFolderFromPathAsync(packageId.path).done(function (storageFolder) { | |
picture.copyAsync(storageFolder, picture.name, Windows.Storage.NameCollisionOption.replaceExisting).then(function (storageFile) { | |
var _imageUrl = URL.createObjectURL(storageFile); | |
successCallback(_imageUrl); | |
}, function () { | |
fail(FileError.INVALID_MODIFICATION_ERR); | |
}, function () { | |
errorCallback("Folder not access."); | |
}); | |
}); | |
} | |
} else { | |
if (targetHeight > 0 && targetWidth > 0) { | |
resizeImageBase64(picture); | |
} else { | |
Windows.Storage.FileIO.readBufferAsync(picture).done(function (buffer) { | |
var strBase64 = Windows.Security.Cryptography.CryptographicBuffer.encodeToBase64String(buffer); | |
successCallback(strBase64); | |
}); | |
} | |
} | |
}; | |
// save to photo album errorCallback | |
var fail = function () { | |
//errorCallback("FileError, code:" + fileError.code); | |
errorCallback("Save fail."); | |
}; | |
if (saveToPhotoAlbum) { | |
Windows.Storage.StorageFile.getFileFromPathAsync(picture.path).then(function (storageFile) { | |
storageFile.copyAsync(Windows.Storage.KnownFolders.picturesLibrary, picture.name, Windows.Storage.NameCollisionOption.generateUniqueName).then(function (storageFile) { | |
success(storageFile); | |
}, function () { | |
fail(); | |
}); | |
}); | |
//var directory = new DirectoryEntry("Pictures", parentPath); | |
//new FileEntry(picture.name, picture.path).copyTo(directory, null, success, fail); | |
} else { | |
if (destinationType == Camera.DestinationType.FILE_URI) { | |
if (targetHeight > 0 && targetWidth > 0) { | |
resizeImage(picture); | |
} else { | |
Windows.Storage.StorageFolder.getFolderFromPathAsync(packageId.path).done(function (storageFolder) { | |
picture.copyAsync(storageFolder, picture.name, Windows.Storage.NameCollisionOption.replaceExisting).then(function (storageFile) { | |
var _imageUrl = URL.createObjectURL(storageFile); | |
successCallback(_imageUrl); | |
}, function () { | |
fail(FileError.INVALID_MODIFICATION_ERR); | |
}, function () { | |
errorCallback("Folder not access."); | |
}); | |
}); | |
} | |
} else { | |
if (targetHeight > 0 && targetWidth > 0) { | |
resizeImageBase64(picture); | |
} else { | |
Windows.Storage.FileIO.readBufferAsync(picture).done(function (buffer) { | |
var strBase64 = Windows.Security.Cryptography.CryptographicBuffer.encodeToBase64String(buffer); | |
successCallback(strBase64); | |
}); | |
} | |
} | |
} | |
} else { | |
errorCallback("User didn't capture a photo."); | |
} | |
}, function () { | |
errorCallback("Fail to capture a photo."); | |
}); | |
} | |
} | |
}; | |
require("cordova/commandProxy").add("Camera",module.exports); | |
}); | |
// file: lib/windows8/plugin/windows8/CaptureProxy.js | |
define("cordova/plugin/windows8/CaptureProxy", function(require, exports, module) { | |
/*global Windows:true */ | |
var MediaFile = require('cordova/plugin/MediaFile'); | |
var CaptureError = require('cordova/plugin/CaptureError'); | |
var CaptureAudioOptions = require('cordova/plugin/CaptureAudioOptions'); | |
var CaptureImageOptions = require('cordova/plugin/CaptureImageOptions'); | |
var CaptureVideoOptions = require('cordova/plugin/CaptureVideoOptions'); | |
var MediaFileData = require('cordova/plugin/MediaFileData'); | |
module.exports = { | |
captureAudio:function(successCallback, errorCallback, args) { | |
var options = args[0]; | |
var audioOptions = new CaptureAudioOptions(); | |
if (typeof(options.duration) == 'undefined') { | |
audioOptions.duration = 3600; // Arbitrary amount, need to change later | |
} else if (options.duration > 0) { | |
audioOptions.duration = options.duration; | |
} else { | |
errorCallback(new CaptureError(CaptureError.CAPTURE_INVALID_ARGUMENT)); | |
return; | |
} | |
var cameraCaptureAudioDuration = audioOptions.duration; | |
var mediaCaptureSettings; | |
var initCaptureSettings = function () { | |
mediaCaptureSettings = null; | |
mediaCaptureSettings = new Windows.Media.Capture.MediaCaptureInitializationSettings(); | |
mediaCaptureSettings.streamingCaptureMode = Windows.Media.Capture.StreamingCaptureMode.audio; | |
}; | |
initCaptureSettings(); | |
var mediaCapture = new Windows.Media.Capture.MediaCapture(); | |
mediaCapture.initializeAsync(mediaCaptureSettings).done(function () { | |
Windows.Storage.KnownFolders.musicLibrary.createFileAsync("captureAudio.mp3", Windows.Storage.NameCollisionOption.generateUniqueName).then(function (storageFile) { | |
var mediaEncodingProfile = new Windows.Media.MediaProperties.MediaEncodingProfile.createMp3(Windows.Media.MediaProperties.AudioEncodingQuality.auto); | |
var stopRecord = function () { | |
mediaCapture.stopRecordAsync().then(function (result) { | |
storageFile.getBasicPropertiesAsync().then(function (basicProperties) { | |
var results = []; | |
results.push(new MediaFile(storageFile.name, storageFile.path, storageFile.contentType, basicProperties.dateModified, basicProperties.size)); | |
successCallback(results); | |
}, function () { | |
errorCallback(new CaptureError(CaptureError.CAPTURE_NO_MEDIA_FILES)); | |
}); | |
}, function () { errorCallback(new CaptureError(CaptureError.CAPTURE_NO_MEDIA_FILES)); }); | |
}; | |
mediaCapture.startRecordToStorageFileAsync(mediaEncodingProfile, storageFile).then(function () { | |
setTimeout(stopRecord, cameraCaptureAudioDuration * 1000); | |
}, function () { errorCallback(new CaptureError(CaptureError.CAPTURE_NO_MEDIA_FILES)); }); | |
}, function () { errorCallback(new CaptureError(CaptureError.CAPTURE_NO_MEDIA_FILES)); }); | |
}); | |
}, | |
captureImage:function (successCallback, errorCallback, args) { | |
var options = args[0]; | |
var imageOptions = new CaptureImageOptions(); | |
var cameraCaptureUI = new Windows.Media.Capture.CameraCaptureUI(); | |
cameraCaptureUI.photoSettings.allowCropping = true; | |
cameraCaptureUI.photoSettings.maxResolution = Windows.Media.Capture.CameraCaptureUIMaxPhotoResolution.highestAvailable; | |
cameraCaptureUI.photoSettings.format = Windows.Media.Capture.CameraCaptureUIPhotoFormat.jpeg; | |
cameraCaptureUI.captureFileAsync(Windows.Media.Capture.CameraCaptureUIMode.photo).then(function (file) { | |
file.moveAsync(Windows.Storage.KnownFolders.picturesLibrary, "cameraCaptureImage.jpg", Windows.Storage.NameCollisionOption.generateUniqueName).then(function () { | |
file.getBasicPropertiesAsync().then(function (basicProperties) { | |
var results = []; | |
results.push(new MediaFile(file.name, file.path, file.contentType, basicProperties.dateModified, basicProperties.size)); | |
successCallback(results); | |
}, function () { | |
errorCallback(new CaptureError(CaptureError.CAPTURE_NO_MEDIA_FILES)); | |
}); | |
}, function () { | |
errorCallback(new CaptureError(CaptureError.CAPTURE_NO_MEDIA_FILES)); | |
}); | |
}, function () { errorCallback(new CaptureError(CaptureError.CAPTURE_NO_MEDIA_FILES)); }); | |
}, | |
captureVideo:function (successCallback, errorCallback, args) { | |
var options = args[0]; | |
var videoOptions = new CaptureVideoOptions(); | |
if (options.duration && options.duration > 0) { | |
videoOptions.duration = options.duration; | |
} | |
if (options.limit > 1) { | |
videoOptions.limit = options.limit; | |
} | |
var cameraCaptureUI = new Windows.Media.Capture.CameraCaptureUI(); | |
cameraCaptureUI.videoSettings.allowTrimming = true; | |
cameraCaptureUI.videoSettings.format = Windows.Media.Capture.CameraCaptureUIVideoFormat.mp4; | |
cameraCaptureUI.videoSettings.maxDurationInSeconds = videoOptions.duration; | |
cameraCaptureUI.captureFileAsync(Windows.Media.Capture.CameraCaptureUIMode.video).then(function (file) { | |
file.moveAsync(Windows.Storage.KnownFolders.videosLibrary, "cameraCaptureVedio.mp4", Windows.Storage.NameCollisionOption.generateUniqueName).then(function () { | |
file.getBasicPropertiesAsync().then(function (basicProperties) { | |
var results = []; | |
results.push(new MediaFile(file.name, file.path, file.contentType, basicProperties.dateModified, basicProperties.size)); | |
successCallback(results); | |
}, function () { | |
errorCallback(new CaptureError(CaptureError.CAPTURE_NO_MEDIA_FILES)); | |
}); | |
}, function () { | |
errorCallback(new CaptureError(CaptureError.CAPTURE_NO_MEDIA_FILES)); | |
}); | |
}, function () { errorCallback(new CaptureError(CaptureError.CAPTURE_NO_MEDIA_FILES)); }); | |
}, | |
getFormatData: function (successCallback, errorCallback, args) { | |
Windows.Storage.StorageFile.getFileFromPathAsync(args[0]).then( | |
function (storageFile) { | |
var mediaTypeFlag = String(storageFile.contentType).split("/")[0].toLowerCase(); | |
if (mediaTypeFlag === "audio") { | |
storageFile.properties.getMusicPropertiesAsync().then(function (audioProperties) { | |
successCallback(new MediaFileData(null, audioProperties.bitrate, 0, 0, audioProperties.duration / 1000)); | |
}, function () { | |
errorCallback(new CaptureError(CaptureError.CAPTURE_INVALID_ARGUMENT)); | |
}); | |
} | |
else if (mediaTypeFlag === "video") { | |
storageFile.properties.getVideoPropertiesAsync().then(function (videoProperties) { | |
successCallback(new MediaFileData(null, videoProperties.bitrate, videoProperties.height, videoProperties.width, videoProperties.duration / 1000)); | |
}, function () { | |
errorCallback(new CaptureError(CaptureError.CAPTURE_INVALID_ARGUMENT)); | |
}); | |
} | |
else if (mediaTypeFlag === "image") { | |
storageFile.properties.getImagePropertiesAsync().then(function (imageProperties) { | |
successCallback(new MediaFileData(null, 0, imageProperties.height, imageProperties.width, 0)); | |
}, function () { | |
errorCallback(new CaptureError(CaptureError.CAPTURE_INVALID_ARGUMENT)); | |
}); | |
} | |
else { errorCallback(new CaptureError(CaptureError.CAPTURE_INVALID_ARGUMENT)); } | |
}, function () { | |
errorCallback(new CaptureError(CaptureError.CAPTURE_INVALID_ARGUMENT)); | |
} | |
); | |
} | |
}; | |
require("cordova/commandProxy").add("Capture",module.exports); | |
}); | |
// file: lib/windows8/plugin/windows8/CompassProxy.js | |
define("cordova/plugin/windows8/CompassProxy", function(require, exports, module) { | |
/*global Windows:true */ | |
var cordova = require('cordova'), | |
CompassHeading = require('cordova/plugin/CompassHeading'); | |
module.exports = { | |
onReadingChanged:null, | |
getHeading:function(win,lose) { | |
var deviceCompass = Windows.Devices.Sensors.Compass.getDefault(); | |
if(!deviceCompass) { | |
setTimeout(function(){lose("Compass not available");},0); | |
} | |
else { | |
deviceCompass.reportInterval = Math.max(16,deviceCompass.minimumReportInterval); | |
this.onReadingChanged = function(e) { | |
var reading = e.reading; | |
var heading = new CompassHeading(reading.headingMagneticNorth, reading.headingTrueNorth); | |
win(heading); | |
}; | |
deviceCompass.addEventListener("readingchanged",this.onReadingChanged); | |
} | |
}, | |
stopHeading:function(win,lose) { | |
var deviceCompass = Windows.Devices.Sensors.Compass.getDefault(); | |
if(!deviceCompass) { | |
setTimeout(function(){lose("Compass not available");},0); | |
} | |
else { | |
deviceCompass.removeEventListener("readingchanged",this.onReadingChanged); | |
this.onReadingChanged = null; | |
deviceCompass.reportInterval = 0; | |
win(); | |
} | |
} | |
}; | |
require("cordova/commandProxy").add("Compass",module.exports); | |
}); | |
// file: lib/windows8/plugin/windows8/ContactsProxy.js | |
define("cordova/plugin/windows8/ContactsProxy", function(require, exports, module) { | |
var cordova = require('cordova'); | |
module.exports = { | |
search: function (win, fail, args) { | |
var fields = args[0]; | |
var options = args[1]; | |
var picker = Windows.ApplicationModel.Contacts.ContactPicker(); | |
picker.commitButtonText = "Select"; | |
picker.selectionMode = Windows.ApplicationModel.Contacts.ContactSelectionMode.contacts; | |
picker.desiredFields.push.apply(picker.desiredFields, fields); | |
if (options.multiple) { | |
picker.pickMultipleContactsAsync().then(function (contacts) { | |
win(contacts); | |
}); | |
} | |
else { | |
picker.pickSingleContactAsync().then(function (contact) { | |
win([contact]); | |
}); | |
} | |
} | |
}; | |
require("cordova/commandProxy").add("Contacts",module.exports); | |
}); | |
// file: lib/windows8/plugin/windows8/DeviceProxy.js | |
define("cordova/plugin/windows8/DeviceProxy", function(require, exports, module) { | |
var cordova = require('cordova'); | |
var utils = require('cordova/utils'); | |
var FileError = require('cordova/plugin/FileError'); | |
module.exports = { | |
getDeviceInfo:function(win,fail,args) { | |
// deviceId aka uuid, stored in Windows.Storage.ApplicationData.current.localSettings.values.deviceId | |
var deviceId; | |
var localSettings = Windows.Storage.ApplicationData.current.localSettings; | |
if (localSettings.values.deviceId) { | |
deviceId = localSettings.values.deviceId; | |
} | |
else { | |
deviceId = localSettings.values.deviceId = utils.createUUID(); | |
} | |
setTimeout(function () { | |
win({ platform: "windows8", version: "8", uuid: deviceId, cordova: CORDOVA_JS_BUILD_LABEL }); | |
}, 0); | |
} | |
}; | |
require("cordova/commandProxy").add("Device",module.exports); | |
}); | |
// file: lib/windows8/plugin/windows8/FileProxy.js | |
define("cordova/plugin/windows8/FileProxy", function(require, exports, module) { | |
var cordova = require('cordova'); | |
var Entry = require('cordova/plugin/Entry'), | |
File = require('cordova/plugin/File'), | |
FileEntry = require('cordova/plugin/FileEntry'), | |
FileError = require('cordova/plugin/FileError'), | |
DirectoryEntry = require('cordova/plugin/DirectoryEntry'), | |
Flags = require('cordova/plugin/Flags'), | |
FileSystem = require('cordova/plugin/FileSystem'), | |
LocalFileSystem = require('cordova/plugin/LocalFileSystem'); | |
module.exports = { | |
getFileMetadata:function(win,fail,args) { | |
var fullPath = args[0]; | |
Windows.Storage.StorageFile.getFileFromPathAsync(fullPath).done( | |
function (storageFile) { | |
storageFile.getBasicPropertiesAsync().then( | |
function (basicProperties) { | |
win(new File(storageFile.name, storageFile.path, storageFile.fileType, basicProperties.dateModified, basicProperties.size)); | |
}, function () { | |
fail && fail(FileError.NOT_READABLE_ERR); | |
} | |
); | |
}, function () { | |
fail && fail(FileError.NOT_FOUND_ERR); | |
} | |
); | |
}, | |
getMetadata:function(success,fail,args) { | |
var fullPath = args[0]; | |
var dealFile = function (sFile) { | |
Windows.Storage.StorageFile.getFileFromPathAsync(fullPath).then( | |
function (storageFile) { | |
return storageFile.getBasicPropertiesAsync(); | |
}, | |
function () { | |
fail && fail(FileError.NOT_READABLE_ERR); | |
} | |
// get the basic properties of the file. | |
).then( | |
function (basicProperties) { | |
success(basicProperties.dateModified); | |
}, | |
function () { | |
fail && fail(FileError.NOT_READABLE_ERR); | |
} | |
); | |
}; | |
var dealFolder = function (sFolder) { | |
Windows.Storage.StorageFolder.getFolderFromPathAsync(fullPath).then( | |
function (storageFolder) { | |
return storageFolder.getBasicPropertiesAsync(); | |
}, | |
function () { | |
fail && fail(FileError.NOT_READABLE_ERR); | |
} | |
// get the basic properties of the folder. | |
).then( | |
function (basicProperties) { | |
success(basicProperties.dateModified); | |
}, | |
function () { | |
fail && fail(FileError.NOT_FOUND_ERR); | |
} | |
); | |
}; | |
Windows.Storage.StorageFile.getFileFromPathAsync(fullPath).then( | |
// the path is file. | |
function (sFile) { | |
dealFile(sFile); | |
}, | |
// the path is folder | |
function () { | |
Windows.Storage.StorageFolder.getFolderFromPathAsync(fullPath).then( | |
function (sFolder) { | |
dealFolder(sFolder); | |
}, function () { | |
fail && fail(FileError.NOT_FOUND_ERR); | |
} | |
); | |
} | |
); | |
}, | |
getParent:function(win,fail,args) { // ["fullPath"] | |
var fullPath = args[0]; | |
var storageFolderPer = Windows.Storage.ApplicationData.current.localFolder; | |
var storageFolderTem = Windows.Storage.ApplicationData.current.temporaryFolder; | |
if (fullPath == storageFolderPer.path) { | |
win(new DirectoryEntry(storageFolderPer.name, storageFolderPer.path)); | |
return; | |
} else if (fullPath == storageFolderTem.path) { | |
win(new DirectoryEntry(storageFolderTem.name, storageFolderTem.path)); | |
return; | |
} | |
var splitArr = fullPath.split(new RegExp(/\/|\\/g)); | |
var popItem = splitArr.pop(); | |
var result = new DirectoryEntry(popItem, fullPath.substr(0, fullPath.length - popItem.length - 1)); | |
Windows.Storage.StorageFolder.getFolderFromPathAsync(result.fullPath).done( | |
function () { win(result); }, | |
function () { fail && fail(FileError.INVALID_STATE_ERR); } | |
); | |
}, | |
readAsText:function(win,fail,args) { | |
var fileName = args[0]; | |
var enc = args[1]; | |
Windows.Storage.StorageFile.getFileFromPathAsync(fileName).done( | |
function (storageFile) { | |
var value = Windows.Storage.Streams.UnicodeEncoding.utf8; | |
if (enc == 'Utf16LE' || enc == 'utf16LE') { | |
value = Windows.Storage.Streams.UnicodeEncoding.utf16LE; | |
}else if (enc == 'Utf16BE' || enc == 'utf16BE') { | |
value = Windows.Storage.Streams.UnicodeEncoding.utf16BE; | |
} | |
Windows.Storage.FileIO.readTextAsync(storageFile, value).done( | |
function (fileContent) { | |
win(fileContent); | |
}, | |
function () { | |
fail && fail(FileError.ENCODING_ERR); | |
} | |
); | |
}, function () { | |
fail && fail(FileError.NOT_FOUND_ERR); | |
} | |
); | |
}, | |
readAsDataURL:function(win,fail,args) { | |
var fileName = args[0]; | |
Windows.Storage.StorageFile.getFileFromPathAsync(fileName).then( | |
function (storageFile) { | |
Windows.Storage.FileIO.readBufferAsync(storageFile).done( | |
function (buffer) { | |
var strBase64 = Windows.Security.Cryptography.CryptographicBuffer.encodeToBase64String(buffer); | |
//the method encodeToBase64String will add "77u/" as a prefix, so we should remove it | |
if(String(strBase64).substr(0,4) == "77u/") { | |
strBase64 = strBase64.substr(4); | |
} | |
var mediaType = storageFile.contentType; | |
var result = "data:" + mediaType + ";base64," + strBase64; | |
win(result); | |
} | |
); | |
}, function () { | |
fail && fail(FileError.NOT_FOUND_ERR); | |
} | |
); | |
}, | |
getDirectory:function(win,fail,args) { | |
var fullPath = args[0]; | |
var path = args[1]; | |
var options = args[2]; | |
var flag = ""; | |
if (options !== null) { | |
flag = new Flags(options.create, options.exclusive); | |
} else { | |
flag = new Flags(false, false); | |
} | |
Windows.Storage.StorageFolder.getFolderFromPathAsync(fullPath).then( | |
function (storageFolder) { | |
if (flag.create === true && flag.exclusive === true) { | |
storageFolder.createFolderAsync(path, Windows.Storage.CreationCollisionOption.failIfExists).done( | |
function (storageFolder) { | |
win(new DirectoryEntry(storageFolder.name, storageFolder.path)); | |
}, function () { | |
fail && fail(FileError.PATH_EXISTS_ERR); | |
} | |
); | |
} else if (flag.create === true && flag.exclusive === false) { | |
storageFolder.createFolderAsync(path, Windows.Storage.CreationCollisionOption.openIfExists).done( | |
function (storageFolder) { | |
win(new DirectoryEntry(storageFolder.name, storageFolder.path)); | |
}, function () { | |
fail && fail(FileError.INVALID_MODIFICATION_ERR); | |
} | |
); | |
} else if (flag.create === false) { | |
if (/\?|\\|\*|\||\"|<|>|\:|\//g.test(path)) { | |
fail && fail(FileError.ENCODING_ERR); | |
return; | |
} | |
storageFolder.getFolderAsync(path).done( | |
function (storageFolder) { | |
win(new DirectoryEntry(storageFolder.name, storageFolder.path)); | |
}, function () { | |
fail && fail(FileError.NOT_FOUND_ERR); | |
} | |
); | |
} | |
}, function () { | |
fail && fail(FileError.NOT_FOUND_ERR); | |
} | |
); | |
}, | |
remove:function(win,fail,args) { | |
var fullPath = args[0]; | |
Windows.Storage.StorageFile.getFileFromPathAsync(fullPath).then( | |
function (sFile) { | |
Windows.Storage.StorageFile.getFileFromPathAsync(fullPath).done(function (storageFile) { | |
storageFile.deleteAsync().done(win, function () { | |
fail && fail(FileError.INVALID_MODIFICATION_ERR); | |
}); | |
}); | |
}, | |
function () { | |
Windows.Storage.StorageFolder.getFolderFromPathAsync(fullPath).then( | |
function (sFolder) { | |
var removeEntry = function () { | |
var storageFolderTop = null; | |
Windows.Storage.StorageFolder.getFolderFromPathAsync(fullPath).then( | |
function (storageFolder) { | |
// FileSystem root can't be removed! | |
var storageFolderPer = Windows.Storage.ApplicationData.current.localFolder; | |
var storageFolderTem = Windows.Storage.ApplicationData.current.temporaryFolder; | |
if (fullPath == storageFolderPer.path || fullPath == storageFolderTem.path) { | |
fail && fail(FileError.NO_MODIFICATION_ALLOWED_ERR); | |
return; | |
} | |
storageFolderTop = storageFolder; | |
return storageFolder.createFileQuery().getFilesAsync(); | |
}, function () { | |
fail && fail(FileError.INVALID_MODIFICATION_ERR); | |
} | |
// check sub-files. | |
).then(function (fileList) { | |
if (fileList) { | |
if (fileList.length === 0) { | |
return storageFolderTop.createFolderQuery().getFoldersAsync(); | |
} else { | |
fail && fail(FileError.INVALID_MODIFICATION_ERR); | |
} | |
} | |
// check sub-folders. | |
}).then(function (folderList) { | |
if (folderList) { | |
if (folderList.length === 0) { | |
storageFolderTop.deleteAsync().done(win, function () { | |
fail && fail(FileError.INVALID_MODIFICATION_ERR); | |
}); | |
} else { | |
fail && fail(FileError.INVALID_MODIFICATION_ERR); | |
} | |
} | |
}); | |
}; | |
removeEntry(); | |
}, function () { | |
fail && fail(FileError.NOT_FOUND_ERR); | |
} | |
); | |
} | |
); | |
}, | |
removeRecursively:function(successCallback,fail,args) { | |
var fullPath = args[0]; | |
Windows.Storage.StorageFolder.getFolderFromPathAsync(fullPath).done(function (storageFolder) { | |
var storageFolderPer = Windows.Storage.ApplicationData.current.localFolder; | |
var storageFolderTem = Windows.Storage.ApplicationData.current.temporaryFolder; | |
if (storageFolder.path == storageFolderPer.path || storageFolder.path == storageFolderTem.path) { | |
fail && fail(FileError.NO_MODIFICATION_ALLOWED_ERR); | |
return; | |
} | |
var removeFolders = function (path) { | |
return new WinJS.Promise(function (complete) { | |
var filePromiseArr = []; | |
var storageFolderTop = null; | |
Windows.Storage.StorageFolder.getFolderFromPathAsync(path).then( | |
function (storageFolder) { | |
var fileListPromise = storageFolder.createFileQuery().getFilesAsync(); | |
storageFolderTop = storageFolder; | |
return fileListPromise; | |
} | |
// remove all the files directly under the folder. | |
).then(function (fileList) { | |
if (fileList !== null) { | |
for (var i = 0; i < fileList.length; i++) { | |
var filePromise = fileList[i].deleteAsync(); | |
filePromiseArr.push(filePromise); | |
} | |
} | |
WinJS.Promise.join(filePromiseArr).then(function () { | |
var folderListPromise = storageFolderTop.createFolderQuery().getFoldersAsync(); | |
return folderListPromise; | |
// remove empty folders. | |
}).then(function (folderList) { | |
var folderPromiseArr = []; | |
if (folderList.length !== 0) { | |
for (var j = 0; j < folderList.length; j++) { | |
folderPromiseArr.push(removeFolders(folderList[j].path)); | |
} | |
WinJS.Promise.join(folderPromiseArr).then(function () { | |
storageFolderTop.deleteAsync().then(complete); | |
}); | |
} else { | |
storageFolderTop.deleteAsync().then(complete); | |
} | |
}, function () { }); | |
}, function () { }); | |
}); | |
}; | |
removeFolders(storageFolder.path).then(function () { | |
Windows.Storage.StorageFolder.getFolderFromPathAsync(storageFolder.path).then( | |
function () {}, | |
function () { | |
if (typeof successCallback !== 'undefined' && successCallback !== null) { successCallback(); } | |
}); | |
}); | |
}); | |
}, | |
getFile:function(win,fail,args) { | |
var fullPath = args[0]; | |
var path = args[1]; | |
var options = args[2]; | |
var flag = ""; | |
if (options !== null) { | |
flag = new Flags(options.create, options.exclusive); | |
} else { | |
flag = new Flags(false, false); | |
} | |
Windows.Storage.StorageFolder.getFolderFromPathAsync(fullPath).then( | |
function (storageFolder) { | |
if (flag.create === true && flag.exclusive === true) { | |
storageFolder.createFileAsync(path, Windows.Storage.CreationCollisionOption.failIfExists).done( | |
function (storageFile) { | |
win(new FileEntry(storageFile.name, storageFile.path)); | |
}, function () { | |
fail && fail(FileError.PATH_EXISTS_ERR); | |
} | |
); | |
} else if (flag.create === true && flag.exclusive === false) { | |
storageFolder.createFileAsync(path, Windows.Storage.CreationCollisionOption.openIfExists).done( | |
function (storageFile) { | |
win(new FileEntry(storageFile.name, storageFile.path)); | |
}, function () { | |
fail && fail(FileError.INVALID_MODIFICATION_ERR); | |
} | |
); | |
} else if (flag.create === false) { | |
if (/\?|\\|\*|\||\"|<|>|\:|\//g.test(path)) { | |
fail && fail(FileError.ENCODING_ERR); | |
return; | |
} | |
storageFolder.getFileAsync(path).done( | |
function (storageFile) { | |
win(new FileEntry(storageFile.name, storageFile.path)); | |
}, function () { | |
fail && fail(FileError.NOT_FOUND_ERR); | |
} | |
); | |
} | |
}, function () { | |
fail && fail(FileError.NOT_FOUND_ERR); | |
} | |
); | |
}, | |
readEntries:function(win,fail,args) { // ["fullPath"] | |
var path = args[0]; | |
var result = []; | |
Windows.Storage.StorageFolder.getFolderFromPathAsync(path).then(function (storageFolder) { | |
var promiseArr = []; | |
var index = 0; | |
promiseArr[index++] = storageFolder.createFileQuery().getFilesAsync().then(function (fileList) { | |
if (fileList !== null) { | |
for (var i = 0; i < fileList.length; i++) { | |
result.push(new FileEntry(fileList[i].name, fileList[i].path)); | |
} | |
} | |
}); | |
promiseArr[index++] = storageFolder.createFolderQuery().getFoldersAsync().then(function (folderList) { | |
if (folderList !== null) { | |
for (var j = 0; j < folderList.length; j++) { | |
result.push(new FileEntry(folderList[j].name, folderList[j].path)); | |
} | |
} | |
}); | |
WinJS.Promise.join(promiseArr).then(function () { | |
win(result); | |
}); | |
}, function () { fail && fail(FileError.NOT_FOUND_ERR); }); | |
}, | |
write:function(win,fail,args) { | |
var fileName = args[0]; | |
var text = args[1]; | |
var position = args[2]; | |
Windows.Storage.StorageFile.getFileFromPathAsync(fileName).done( | |
function (storageFile) { | |
Windows.Storage.FileIO.writeTextAsync(storageFile,text,Windows.Storage.Streams.UnicodeEncoding.utf8).done( | |
function() { | |
win(String(text).length); | |
}, function () { | |
fail && fail(FileError.INVALID_MODIFICATION_ERR); | |
} | |
); | |
}, function() { | |
fail && fail(FileError.NOT_FOUND_ERR); | |
} | |
); | |
}, | |
truncate:function(win,fail,args) { // ["fileName","size"] | |
var fileName = args[0]; | |
var size = args[1]; | |
Windows.Storage.StorageFile.getFileFromPathAsync(fileName).done(function(storageFile){ | |
//the current length of the file. | |
var leng = 0; | |
storageFile.getBasicPropertiesAsync().then(function (basicProperties) { | |
leng = basicProperties.size; | |
if (Number(size) >= leng) { | |
win(this.length); | |
return; | |
} | |
if (Number(size) >= 0) { | |
Windows.Storage.FileIO.readTextAsync(storageFile, Windows.Storage.Streams.UnicodeEncoding.utf8).then(function (fileContent) { | |
fileContent = fileContent.substr(0, size); | |
var fullPath = storageFile.path; | |
var name = storageFile.name; | |
var entry = new Entry(true, false, name, fullPath); | |
var parentPath = ""; | |
var successCallBack = function (entry) { | |
parentPath = entry.fullPath; | |
storageFile.deleteAsync().then(function () { | |
return Windows.Storage.StorageFolder.getFolderFromPathAsync(parentPath); | |
}).then(function (storageFolder) { | |
storageFolder.createFileAsync(name).then(function (newStorageFile) { | |
Windows.Storage.FileIO.writeTextAsync(newStorageFile, fileContent).done(function () { | |
win(String(fileContent).length); | |
}, function () { | |
fail && fail(FileError.NO_MODIFICATION_ALLOWED_ERR); | |
}); | |
}); | |
}); | |
}; | |
entry.getParent(successCallBack, null); | |
}, function () { fail && fail(FileError.NOT_FOUND_ERR); }); | |
} | |
}); | |
}, function () { fail && fail(FileError.NOT_FOUND_ERR); }); | |
}, | |
copyTo:function(success,fail,args) { // ["fullPath","parent", "newName"] | |
var srcPath = args[0]; | |
var parentFullPath = args[1]; | |
var name = args[2]; | |
//name can't be invalid | |
if (/\?|\\|\*|\||\"|<|>|\:|\//g.test(name)) { | |
fail && fail(FileError.ENCODING_ERR); | |
return; | |
} | |
// copy | |
var copyFiles = ""; | |
Windows.Storage.StorageFile.getFileFromPathAsync(srcPath).then( | |
function (sFile) { | |
copyFiles = function (srcPath, parentPath) { | |
var storageFileTop = null; | |
Windows.Storage.StorageFile.getFileFromPathAsync(srcPath).then(function (storageFile) { | |
storageFileTop = storageFile; | |
return Windows.Storage.StorageFolder.getFolderFromPathAsync(parentPath); | |
}, function () { | |
fail && fail(FileError.NOT_FOUND_ERR); | |
}).then(function (storageFolder) { | |
storageFileTop.copyAsync(storageFolder, name, Windows.Storage.NameCollisionOption.failIfExists).then(function (storageFile) { | |
success(new FileEntry(storageFile.name, storageFile.path)); | |
}, function () { | |
fail && fail(FileError.INVALID_MODIFICATION_ERR); | |
}); | |
}, function () { | |
fail && fail(FileError.NOT_FOUND_ERR); | |
}); | |
}; | |
var copyFinish = function (srcPath, parentPath) { | |
copyFiles(srcPath, parentPath); | |
}; | |
copyFinish(srcPath, parentFullPath); | |
}, | |
function () { | |
Windows.Storage.StorageFolder.getFolderFromPathAsync(srcPath).then( | |
function (sFolder) { | |
copyFiles = function (srcPath, parentPath) { | |
var coreCopy = function (storageFolderTop, complete) { | |
storageFolderTop.createFolderQuery().getFoldersAsync().then(function (folderList) { | |
var folderPromiseArr = []; | |
if (folderList.length === 0) { complete(); } | |
else { | |
Windows.Storage.StorageFolder.getFolderFromPathAsync(parentPath).then(function (storageFolderTarget) { | |
var tempPromiseArr = []; | |
var index = 0; | |
for (var j = 0; j < folderList.length; j++) { | |
tempPromiseArr[index++] = storageFolderTarget.createFolderAsync(folderList[j].name).then(function (targetFolder) { | |
folderPromiseArr.push(copyFiles(folderList[j].path, targetFolder.path)); | |
}); | |
} | |
WinJS.Promise.join(tempPromiseArr).then(function () { | |
WinJS.Promise.join(folderPromiseArr).then(complete); | |
}); | |
}); | |
} | |
}); | |
}; | |
return new WinJS.Promise(function (complete) { | |
var storageFolderTop = null; | |
var filePromiseArr = []; | |
var fileListTop = null; | |
Windows.Storage.StorageFolder.getFolderFromPathAsync(srcPath).then(function (storageFolder) { | |
storageFolderTop = storageFolder; | |
return storageFolder.createFileQuery().getFilesAsync(); | |
}).then(function (fileList) { | |
fileListTop = fileList; | |
if (fileList) { | |
return Windows.Storage.StorageFolder.getFolderFromPathAsync(parentPath); | |
} | |
}).then(function (targetStorageFolder) { | |
for (var i = 0; i < fileListTop.length; i++) { | |
filePromiseArr.push(fileListTop[i].copyAsync(targetStorageFolder)); | |
} | |
WinJS.Promise.join(filePromiseArr).then(function () { | |
coreCopy(storageFolderTop, complete); | |
}); | |
}); | |
}); | |
}; | |
var copyFinish = function (srcPath, parentPath) { | |
Windows.Storage.StorageFolder.getFolderFromPathAsync(parentPath).then(function (storageFolder) { | |
storageFolder.createFolderAsync(name, Windows.Storage.CreationCollisionOption.openIfExists).then(function (newStorageFolder) { | |
//can't copy onto itself | |
if (srcPath == newStorageFolder.path) { | |
fail && fail(FileError.INVALID_MODIFICATION_ERR); | |
return; | |
} | |
//can't copy into itself | |
if (srcPath == parentPath) { | |
fail && fail(FileError.INVALID_MODIFICATION_ERR); | |
return; | |
} | |
copyFiles(srcPath, newStorageFolder.path).then(function () { | |
Windows.Storage.StorageFolder.getFolderFromPathAsync(newStorageFolder.path).done( | |
function (storageFolder) { | |
success(new DirectoryEntry(storageFolder.name, storageFolder.path)); | |
}, | |
function () { fail && fail(FileError.NOT_FOUND_ERR); } | |
); | |
}); | |
}, function () { fail && fail(FileError.INVALID_MODIFICATION_ERR); }); | |
}, function () { fail && fail(FileError.INVALID_MODIFICATION_ERR); }); | |
}; | |
copyFinish(srcPath, parentFullPath); | |
}, function () { | |
fail && fail(FileError.NOT_FOUND_ERR); | |
} | |
); | |
} | |
); | |
}, | |
moveTo:function(success,fail,args) { | |
var srcPath = args[0]; | |
var parentFullPath = args[1]; | |
var name = args[2]; | |
//name can't be invalid | |
if (/\?|\\|\*|\||\"|<|>|\:|\//g.test(name)) { | |
fail && fail(FileError.ENCODING_ERR); | |
return; | |
} | |
var moveFiles = ""; | |
Windows.Storage.StorageFile.getFileFromPathAsync(srcPath).then( | |
function (sFile) { | |
moveFiles = function (srcPath, parentPath) { | |
var storageFileTop = null; | |
Windows.Storage.StorageFile.getFileFromPathAsync(srcPath).then(function (storageFile) { | |
storageFileTop = storageFile; | |
return Windows.Storage.StorageFolder.getFolderFromPathAsync(parentPath); | |
}, function () { | |
fail && fail(FileError.NOT_FOUND_ERR); | |
}).then(function (storageFolder) { | |
storageFileTop.moveAsync(storageFolder, name, Windows.Storage.NameCollisionOption.replaceExisting).then(function () { | |
success(new FileEntry(name, storageFileTop.path)); | |
}, function () { | |
fail && fail(FileError.INVALID_MODIFICATION_ERR); | |
}); | |
}, function () { | |
fail && fail(FileError.NOT_FOUND_ERR); | |
}); | |
}; | |
var moveFinish = function (srcPath, parentPath) { | |
//can't copy onto itself | |
if (srcPath == parentPath + "\\" + name) { | |
fail && fail(FileError.INVALID_MODIFICATION_ERR); | |
return; | |
} | |
moveFiles(srcPath, parentFullPath); | |
}; | |
moveFinish(srcPath, parentFullPath); | |
}, | |
function () { | |
Windows.Storage.StorageFolder.getFolderFromPathAsync(srcPath).then( | |
function (sFolder) { | |
moveFiles = function (srcPath, parentPath) { | |
var coreMove = function (storageFolderTop, complete) { | |
storageFolderTop.createFolderQuery().getFoldersAsync().then(function (folderList) { | |
var folderPromiseArr = []; | |
if (folderList.length === 0) { | |
// If failed, we must cancel the deletion of folders & files.So here wo can't delete the folder. | |
complete(); | |
} | |
else { | |
Windows.Storage.StorageFolder.getFolderFromPathAsync(parentPath).then(function (storageFolderTarget) { | |
var tempPromiseArr = []; | |
var index = 0; | |
for (var j = 0; j < folderList.length; j++) { | |
tempPromiseArr[index++] = storageFolderTarget.createFolderAsync(folderList[j].name).then(function (targetFolder) { | |
folderPromiseArr.push(moveFiles(folderList[j].path, targetFolder.path)); | |
}); | |
} | |
WinJS.Promise.join(tempPromiseArr).then(function () { | |
WinJS.Promise.join(folderPromiseArr).then(complete); | |
}); | |
}); | |
} | |
}); | |
}; | |
return new WinJS.Promise(function (complete) { | |
var storageFolderTop = null; | |
Windows.Storage.StorageFolder.getFolderFromPathAsync(srcPath).then(function (storageFolder) { | |
storageFolderTop = storageFolder; | |
return storageFolder.createFileQuery().getFilesAsync(); | |
}).then(function (fileList) { | |
var filePromiseArr = []; | |
Windows.Storage.StorageFolder.getFolderFromPathAsync(parentPath).then(function (dstStorageFolder) { | |
if (fileList) { | |
for (var i = 0; i < fileList.length; i++) { | |
filePromiseArr.push(fileList[i].moveAsync(dstStorageFolder)); | |
} | |
} | |
WinJS.Promise.join(filePromiseArr).then(function () { | |
coreMove(storageFolderTop, complete); | |
}, function () { }); | |
}); | |
}); | |
}); | |
}; | |
var moveFinish = function (srcPath, parentPath) { | |
var originFolderTop = null; | |
Windows.Storage.StorageFolder.getFolderFromPathAsync(srcPath).then(function (originFolder) { | |
originFolderTop = originFolder; | |
return Windows.Storage.StorageFolder.getFolderFromPathAsync(parentPath); | |
}, function () { | |
fail && fail(FileError.INVALID_MODIFICATION_ERR); | |
}).then(function (storageFolder) { | |
return storageFolder.createFolderAsync(name, Windows.Storage.CreationCollisionOption.openIfExists); | |
}, function () { | |
fail && fail(FileError.INVALID_MODIFICATION_ERR); | |
}).then(function (newStorageFolder) { | |
//can't move onto directory that is not empty | |
newStorageFolder.createFileQuery().getFilesAsync().then(function (fileList) { | |
newStorageFolder.createFolderQuery().getFoldersAsync().then(function (folderList) { | |
if (fileList.length !== 0 || folderList.length !== 0) { | |
fail && fail(FileError.INVALID_MODIFICATION_ERR); | |
return; | |
} | |
//can't copy onto itself | |
if (srcPath == newStorageFolder.path) { | |
fail && fail(FileError.INVALID_MODIFICATION_ERR); | |
return; | |
} | |
//can't copy into itself | |
if (srcPath == parentPath) { | |
fail && fail(FileError.INVALID_MODIFICATION_ERR); | |
return; | |
} | |
moveFiles(srcPath, newStorageFolder.path).then(function () { | |
var successCallback = function () { | |
success(new DirectoryEntry(name, newStorageFolder.path)); | |
}; | |
var temp = new DirectoryEntry(originFolderTop.name, originFolderTop.path).removeRecursively(successCallback, fail); | |
}, function () { console.log("error!"); }); | |
}); | |
}); | |
}, function () { fail && fail(FileError.INVALID_MODIFICATION_ERR); }); | |
}; | |
moveFinish(srcPath, parentFullPath); | |
}, function () { | |
fail && fail(FileError.NOT_FOUND_ERR); | |
} | |
); | |
} | |
); | |
}, | |
tempFileSystem:null, | |
persistentFileSystem:null, | |
requestFileSystem:function(win,fail,args) { | |
var type = args[0]; | |
var size = args[1]; | |
var filePath = ""; | |
var result = null; | |
var fsTypeName = ""; | |
switch (type) { | |
case LocalFileSystem.TEMPORARY: | |
filePath = Windows.Storage.ApplicationData.current.temporaryFolder.path; | |
fsTypeName = "temporary"; | |
break; | |
case LocalFileSystem.PERSISTENT: | |
filePath = Windows.Storage.ApplicationData.current.localFolder.path; | |
fsTypeName = "persistent"; | |
break; | |
} | |
var MAX_SIZE = 10000000000; | |
if (size > MAX_SIZE) { | |
fail && fail(FileError.QUOTA_EXCEEDED_ERR); | |
return; | |
} | |
var fileSystem = new FileSystem(fsTypeName, new DirectoryEntry(fsTypeName, filePath)); | |
result = fileSystem; | |
win(result); | |
}, | |
resolveLocalFileSystemURI:function(success,fail,args) { | |
var uri = args[0]; | |
var path = uri; | |
// support for file name with parameters | |
if (/\?/g.test(path)) { | |
path = String(path).split("?")[0]; | |
} | |
// support for encodeURI | |
if (/\%5/g.test(path)) { | |
path = decodeURI(path); | |
} | |
// support for special path start with file:/// | |
if (path.substr(0, 8) == "file:///") { | |
path = Windows.Storage.ApplicationData.current.localFolder.path + "\\" + String(path).substr(8).split("/").join("\\"); | |
Windows.Storage.StorageFile.getFileFromPathAsync(path).then( | |
function (storageFile) { | |
success(new FileEntry(storageFile.name, storageFile.path)); | |
}, function () { | |
Windows.Storage.StorageFolder.getFolderFromPathAsync(path).then( | |
function (storageFolder) { | |
success(new DirectoryEntry(storageFolder.name, storageFolder.path)); | |
}, function () { | |
fail && fail(FileError.NOT_FOUND_ERR); | |
} | |
); | |
} | |
); | |
} else { | |
Windows.Storage.StorageFile.getFileFromPathAsync(path).then( | |
function (storageFile) { | |
success(new FileEntry(storageFile.name, storageFile.path)); | |
}, function () { | |
Windows.Storage.StorageFolder.getFolderFromPathAsync(path).then( | |
function (storageFolder) { | |
success(new DirectoryEntry(storageFolder.name, storageFolder.path)); | |
}, function () { | |
fail && fail(FileError.ENCODING_ERR); | |
} | |
); | |
} | |
); | |
} | |
} | |
}; | |
require("cordova/commandProxy").add("File",module.exports); | |
}); | |
// file: lib/windows8/plugin/windows8/FileTransferProxy.js | |
define("cordova/plugin/windows8/FileTransferProxy", function(require, exports, module) { | |
var FileTransferError = require('cordova/plugin/FileTransferError'), | |
FileUploadResult = require('cordova/plugin/FileUploadResult'), | |
FileEntry = require('cordova/plugin/FileEntry'); | |
module.exports = { | |
upload:function(successCallback, error, options) { | |
var filePath = options[0]; | |
var server = options[1]; | |
var win = function (fileUploadResult) { | |
successCallback(fileUploadResult); | |
}; | |
if (filePath === null || typeof filePath === 'undefined') { | |
error(FileTransferError.FILE_NOT_FOUND_ERR); | |
return; | |
} | |
if (String(filePath).substr(0, 8) == "file:///") { | |
filePath = Windows.Storage.ApplicationData.current.localFolder.path + String(filePath).substr(8).split("/").join("\\"); | |
} | |
Windows.Storage.StorageFile.getFileFromPathAsync(filePath).then(function (storageFile) { | |
storageFile.openAsync(Windows.Storage.FileAccessMode.read).then(function (stream) { | |
var blob = MSApp.createBlobFromRandomAccessStream(storageFile.contentType, stream); | |
var formData = new FormData(); | |
formData.append("source\";filename=\"" + storageFile.name + "\"", blob); | |
WinJS.xhr({ type: "POST", url: server, data: formData }).then(function (response) { | |
var code = response.status; | |
storageFile.getBasicPropertiesAsync().done(function (basicProperties) { | |
Windows.Storage.FileIO.readBufferAsync(storageFile).done(function (buffer) { | |
var dataReader = Windows.Storage.Streams.DataReader.fromBuffer(buffer); | |
var fileContent = dataReader.readString(buffer.length); | |
dataReader.close(); | |
win(new FileUploadResult(basicProperties.size, code, fileContent)); | |
}); | |
}); | |
}, function () { | |
error(FileTransferError.INVALID_URL_ERR); | |
}); | |
}); | |
},function(){error(FileTransferError.FILE_NOT_FOUND_ERR);}); | |
}, | |
download:function(win, error, options) { | |
var source = options[0]; | |
var target = options[1]; | |
if (target === null || typeof target === undefined) { | |
error(FileTransferError.FILE_NOT_FOUND_ERR); | |
return; | |
} | |
if (String(target).substr(0, 8) == "file:///") { | |
target = Windows.Storage.ApplicationData.current.localFolder.path + String(target).substr(8).split("/").join("\\"); | |
} | |
var path = target.substr(0, String(target).lastIndexOf("\\")); | |
var fileName = target.substr(String(target).lastIndexOf("\\") + 1); | |
if (path === null || fileName === null) { | |
error(FileTransferError.FILE_NOT_FOUND_ERR); | |
return; | |
} | |
var download = null; | |
Windows.Storage.StorageFolder.getFolderFromPathAsync(path).then(function (storageFolder) { | |
storageFolder.createFileAsync(fileName, Windows.Storage.CreationCollisionOption.generateUniqueName).then(function (storageFile) { | |
var uri = Windows.Foundation.Uri(source); | |
var downloader = new Windows.Networking.BackgroundTransfer.BackgroundDownloader(); | |
download = downloader.createDownload(uri, storageFile); | |
download.startAsync().then(function () { | |
win(new FileEntry(storageFile.name, storageFile.path)); | |
}, function () { | |
error(FileTransferError.INVALID_URL_ERR); | |
}); | |
}); | |
}); | |
} | |
}; | |
require("cordova/commandProxy").add("FileTransfer",module.exports); | |
}); | |
// file: lib/windows8/plugin/windows8/MediaFile.js | |
define("cordova/plugin/windows8/MediaFile", function(require, exports, module) { | |
/*global Windows:true */ | |
var MediaFileData = require('cordova/plugin/MediaFileData'); | |
var CaptureError = require('cordova/plugin/CaptureError'); | |
module.exports = { | |
getFormatData: function (successCallback, errorCallback, args) { | |
Windows.Storage.StorageFile.getFileFromPathAsync(this.fullPath).then( | |
function (storageFile) { | |
var mediaTypeFlag = String(storageFile.contentType).split("/")[0].toLowerCase(); | |
if (mediaTypeFlag === "audio") { | |
storageFile.properties.getMusicPropertiesAsync().then( | |
function (audioProperties) { | |
successCallback(new MediaFileData(null, audioProperties.bitrate, 0, 0, audioProperties.duration / 1000)); | |
}, function () { | |
errorCallback(new CaptureError(CaptureError.CAPTURE_INVALID_ARGUMENT)); | |
} | |
); | |
} else if (mediaTypeFlag === "video") { | |
storageFile.properties.getVideoPropertiesAsync().then( | |
function (videoProperties) { | |
successCallback(new MediaFileData(null, videoProperties.bitrate, videoProperties.height, videoProperties.width, videoProperties.duration / 1000)); | |
}, function () { | |
errorCallback(new CaptureError(CaptureError.CAPTURE_INVALID_ARGUMENT)); | |
} | |
); | |
} else if (mediaTypeFlag === "image") { | |
storageFile.properties.getImagePropertiesAsync().then( | |
function (imageProperties) { | |
successCallback(new MediaFileData(null, 0, imageProperties.height, imageProperties.width, 0)); | |
}, function () { | |
errorCallback(new CaptureError(CaptureError.CAPTURE_INVALID_ARGUMENT)); | |
} | |
); | |
} else { | |
errorCallback(new CaptureError(CaptureError.CAPTURE_INVALID_ARGUMENT)); | |
} | |
}, function () { | |
errorCallback(new CaptureError(CaptureError.CAPTURE_INVALID_ARGUMENT)); | |
} | |
); | |
} | |
}; | |
}); | |
// file: lib/windows8/plugin/windows8/MediaProxy.js | |
define("cordova/plugin/windows8/MediaProxy", function(require, exports, module) { | |
/*global Windows:true */ | |
var cordova = require('cordova'), | |
Media = require('cordova/plugin/Media'); | |
var MediaError = require('cordova/plugin/MediaError'); | |
module.exports = { | |
mediaCaptureMrg:null, | |
// Initiates the audio file | |
create:function(win, lose, args) { | |
var id = args[0]; | |
var src = args[1]; | |
var thisM = Media.get(id); | |
Media.onStatus(id, Media.MEDIA_STATE, Media.MEDIA_STARTING); | |
Media.prototype.node = null; | |
var fn = src.split('.').pop(); // gets the file extension | |
if (thisM.node === null) { | |
if (fn === 'mp3' || fn === 'wma' || fn === 'wma' || | |
fn === 'cda' || fn === 'adx' || fn === 'wm' || | |
fn === 'm3u' || fn === 'wmx') { | |
thisM.node = new Audio(src); | |
thisM.node.load(); | |
var dur = thisM.node.duration; | |
if (isNaN(dur)) { | |
dur = -1; | |
} | |
Media.onStatus(id, Media.MEDIA_DURATION, dur); | |
} | |
else { | |
lose && lose({code:MediaError.MEDIA_ERR_ABORTED}); | |
} | |
} | |
}, | |
// Start playing the audio | |
startPlayingAudio:function(win, lose, args) { | |
var id = args[0]; | |
//var src = args[1]; | |
//var options = args[2]; | |
Media.onStatus(id, Media.MEDIA_STATE, Media.MEDIA_RUNNING); | |
(Media.get(id)).node.play(); | |
}, | |
// Stops the playing audio | |
stopPlayingAudio:function(win, lose, args) { | |
var id = args[0]; | |
try { | |
(Media.get(id)).node.pause(); | |
(Media.get(id)).node.currentTime = 0; | |
Media.onStatus(id, Media.MEDIA_STATE, Media.MEDIA_STOPPED); | |
win(); | |
} catch (err) { | |
lose("Failed to stop: "+err); | |
} | |
}, | |
// Seeks to the position in the audio | |
seekToAudio:function(win, lose, args) { | |
var id = args[0]; | |
var milliseconds = args[1]; | |
try { | |
(Media.get(id)).node.currentTime = milliseconds / 1000; | |
win(); | |
} catch (err) { | |
lose("Failed to seek: "+err); | |
} | |
}, | |
// Pauses the playing audio | |
pausePlayingAudio:function(win, lose, args) { | |
var id = args[0]; | |
var thisM = Media.get(id); | |
try { | |
thisM.node.pause(); | |
Media.onStatus(id, Media.MEDIA_STATE, Media.MEDIA_PAUSED); | |
} catch (err) { | |
lose("Failed to pause: "+err); | |
} | |
}, | |
// Gets current position in the audio | |
getCurrentPositionAudio:function(win, lose, args) { | |
var id = args[0]; | |
try { | |
var p = (Media.get(id)).node.currentTime; | |
Media.onStatus(id, Media.MEDIA_POSITION, p); | |
win(p); | |
} catch (err) { | |
lose(err); | |
} | |
}, | |
// Start recording audio | |
startRecordingAudio:function(win, lose, args) { | |
var id = args[0]; | |
var src = args[1]; | |
// Initialize device | |
Media.prototype.mediaCaptureMgr = null; | |
var thisM = (Media.get(id)); | |
var captureInitSettings = new Windows.Media.Capture.MediaCaptureInitializationSettings(); | |
captureInitSettings.streamingCaptureMode = Windows.Media.Capture.StreamingCaptureMode.audio; | |
thisM.mediaCaptureMgr = new Windows.Media.Capture.MediaCapture(); | |
thisM.mediaCaptureMgr.addEventListener("failed", lose); | |
thisM.mediaCaptureMgr.initializeAsync(captureInitSettings).done(function (result) { | |
thisM.mediaCaptureMgr.addEventListener("recordlimitationexceeded", lose); | |
thisM.mediaCaptureMgr.addEventListener("failed", lose); | |
}, lose); | |
// Start recording | |
Windows.Storage.KnownFolders.musicLibrary.createFileAsync(src, Windows.Storage.CreationCollisionOption.replaceExisting).done(function (newFile) { | |
var storageFile = newFile; | |
var fileType = this.src.split('.').pop(); | |
var encodingProfile = null; | |
switch (fileType) { | |
case 'm4a': | |
encodingProfile = Windows.Media.MediaProperties.MediaEncodingProfile.createM4a(Windows.Media.MediaProperties.AudioEncodingQuality.auto); | |
break; | |
case 'mp3': | |
encodingProfile = Windows.Media.MediaProperties.MediaEncodingProfile.createMp3(Windows.Media.MediaProperties.AudioEncodingQuality.auto); | |
break; | |
case 'wma': | |
encodingProfile = Windows.Media.MediaProperties.MediaEncodingProfile.createWma(Windows.Media.MediaProperties.AudioEncodingQuality.auto); | |
break; | |
default: | |
lose("Invalid file type for record"); | |
break; | |
} | |
thisM.mediaCaptureMgr.startRecordToStorageFileAsync(encodingProfile, storageFile).done(win, lose); | |
}, lose); | |
}, | |
// Stop recording audio | |
stopRecordingAudio:function(win, lose, args) { | |
var id = args[0]; | |
var thisM = Media.get(id); | |
thisM.mediaCaptureMgr.stopRecordAsync().done(win, lose); | |
}, | |
// Release the media object | |
release:function(win, lose, args) { | |
var id = args[0]; | |
var thisM = Media.get(id); | |
try { | |
delete thisM.node; | |
} catch (err) { | |
lose("Failed to release: "+err); | |
} | |
}, | |
setVolume:function(win, lose, args) { | |
var id = args[0]; | |
var volume = args[1]; | |
var thisM = Media.get(id); | |
thisM.volume = volume; | |
} | |
}; | |
require("cordova/commandProxy").add("Media",module.exports); | |
}); | |
// file: lib/windows8/plugin/windows8/NetworkStatusProxy.js | |
define("cordova/plugin/windows8/NetworkStatusProxy", function(require, exports, module) { | |
/*global Windows:true */ | |
var cordova = require('cordova'); | |
var Connection = require('cordova/plugin/Connection'); | |
module.exports = { | |
getConnectionInfo:function(win,fail,args) | |
{ | |
console.log("NetworkStatusProxy::getConnectionInfo"); | |
var winNetConn = Windows.Networking.Connectivity; | |
var networkInfo = winNetConn.NetworkInformation; | |
var networkCostInfo = winNetConn.NetworkCostType; | |
var networkConnectivityInfo = winNetConn.NetworkConnectivityLevel; | |
var networkAuthenticationInfo = winNetConn.NetworkAuthenticationType; | |
var networkEncryptionInfo = winNetConn.NetworkEncryptionType; | |
var connectionType; | |
var profile = Windows.Networking.Connectivity.NetworkInformation.getInternetConnectionProfile(); | |
if(profile) { | |
var conLevel = profile.getNetworkConnectivityLevel(); | |
var interfaceType = profile.networkAdapter.ianaInterfaceType; | |
if (conLevel == Windows.Networking.Connectivity.NetworkConnectivityLevel.none) { | |
connectionType = Connection.NONE; | |
} | |
else { | |
switch (interfaceType) { | |
case 71: | |
connectionType = Connection.WIFI; | |
break; | |
case 6: | |
connectionType = Connection.ETHERNET; | |
break; | |
case 243: // (3GPP WWAN) // Fallthrough is intentional | |
case 244: // (3GPP2 WWAN) | |
connectionType = Connection.CELL_3G; | |
break; | |
default: | |
connectionType = Connection.UNKNOWN; | |
break; | |
} | |
} | |
} | |
// FYI | |
//Connection.UNKNOWN 'Unknown connection'; | |
//Connection.ETHERNET 'Ethernet connection'; | |
//Connection.WIFI 'WiFi connection'; | |
//Connection.CELL_2G 'Cell 2G connection'; | |
//Connection.CELL_3G 'Cell 3G connection'; | |
//Connection.CELL_4G 'Cell 4G connection'; | |
//Connection.NONE 'No network connection'; | |
setTimeout(function () { | |
if (connectionType) { | |
win(connectionType); | |
} else { | |
win(Connection.NONE); | |
} | |
},0); | |
} | |
}; | |
require("cordova/commandProxy").add("NetworkStatus",module.exports); | |
}); | |
// file: lib/windows8/plugin/windows8/NotificationProxy.js | |
define("cordova/plugin/windows8/NotificationProxy", function(require, exports, module) { | |
/*global Windows:true */ | |
var cordova = require('cordova'); | |
var isAlertShowing = false; | |
var alertStack = []; | |
module.exports = { | |
alert:function(win, loseX, args) { | |
if (isAlertShowing) { | |
var later = function () { | |
module.exports.alert(win, loseX, args); | |
}; | |
alertStack.push(later); | |
return; | |
} | |
isAlertShowing = true; | |
var message = args[0]; | |
var _title = args[1]; | |
var _buttonLabel = args[2]; | |
var md = new Windows.UI.Popups.MessageDialog(message, _title); | |
md.commands.append(new Windows.UI.Popups.UICommand(_buttonLabel)); | |
md.showAsync().then(function() { | |
isAlertShowing = false; | |
win && win(); | |
if (alertStack.length) { | |
setTimeout(alertStack.shift(), 0); | |
} | |
}); | |
}, | |
confirm:function(win, loseX, args) { | |
if (isAlertShowing) { | |
var later = function () { | |
module.exports.confirm(win, loseX, args); | |
}; | |
alertStack.push(later); | |
return; | |
} | |
isAlertShowing = true; | |
var message = args[0]; | |
var _title = args[1]; | |
var _buttonLabels = args[2]; | |
var btnList = []; | |
function commandHandler (command) { | |
win && win(btnList[command.label]); | |
} | |
var md = new Windows.UI.Popups.MessageDialog(message, _title); | |
var button = _buttonLabels.split(','); | |
for (var i = 0; i<button.length; i++) { | |
btnList[button[i]] = i+1; | |
md.commands.append(new Windows.UI.Popups.UICommand(button[i],commandHandler)); | |
} | |
md.showAsync().then(function() { | |
isAlertShowing = false; | |
if (alertStack.length) { | |
setTimeout(alertStack.shift(), 0); | |
} | |
}); | |
}, | |
vibrate:function(winX, loseX, args) { | |
var mills = args[0]; | |
//... | |
}, | |
beep:function(winX, loseX, args) { | |
var count = args[0]; | |
/* | |
var src = //filepath// | |
var playTime = 500; // ms | |
var quietTime = 1000; // ms | |
var media = new Media(src, function(){}); | |
var hit = 1; | |
var intervalId = window.setInterval( function () { | |
media.play(); | |
sleep(playTime); | |
media.stop(); | |
media.seekTo(0); | |
if (hit < count) { | |
hit++; | |
} else { | |
window.clearInterval(intervalId); | |
} | |
}, playTime + quietTime); */ | |
} | |
}; | |
require("cordova/commandProxy").add("Notification",module.exports); | |
}); | |
// file: lib/windows8/plugin/windows8/console.js | |
define("cordova/plugin/windows8/console", function(require, exports, module) { | |
if(!console || !console.log) | |
{ | |
var exec = require('cordova/exec'); | |
var debugConsole = { | |
log:function(msg){ | |
exec(null,null,"DebugConsole","log",msg); | |
}, | |
warn:function(msg){ | |
exec(null,null,"DebugConsole","warn",msg); | |
}, | |
error:function(msg){ | |
exec(null,null,"DebugConsole","error",msg); | |
} | |
}; | |
module.exports = debugConsole; | |
} | |
else if(console && console.log) { | |
console.log("console.log exists already!"); | |
console.warn = console.warn || function(msg){console.log("warn:"+msg);}; | |
console.error = console.error || function(msg){console.log("error:"+msg);}; | |
} | |
}); | |
// file: lib/windows8/plugin/windows8/console/symbols.js | |
define("cordova/plugin/windows8/console/symbols", function(require, exports, module) { | |
var modulemapper = require('cordova/modulemapper'); | |
modulemapper.clobbers('cordova/plugin/windows8/console', 'navigator.console'); | |
}); | |
// file: lib/windows8/plugin/windows8/notification/plugininit.js | |
define("cordova/plugin/windows8/notification/plugininit", function(require, exports, module) { | |
window.alert = window.alert || require("cordova/plugin/notification").alert; | |
window.confirm = window.confirm || require("cordova/plugin/notification").confirm; | |
}); | |
// file: lib/common/symbols.js | |
define("cordova/symbols", function(require, exports, module) { | |
var modulemapper = require('cordova/modulemapper'); | |
// Use merges here in case others symbols files depend on this running first, | |
// but fail to declare the dependency with a require(). | |
modulemapper.merges('cordova', 'cordova'); | |
modulemapper.clobbers('cordova/exec', 'cordova.exec'); | |
modulemapper.clobbers('cordova/exec', 'Cordova.exec'); | |
}); | |
// file: lib/common/utils.js | |
define("cordova/utils", function(require, exports, module) { | |
var utils = exports; | |
/** | |
* Defines a property getter / setter for obj[key]. | |
*/ | |
utils.defineGetterSetter = function(obj, key, getFunc, opt_setFunc) { | |
if (Object.defineProperty) { | |
var desc = { | |
get: getFunc, | |
configurable: true | |
}; | |
if (opt_setFunc) { | |
desc.set = opt_setFunc; | |
} | |
Object.defineProperty(obj, key, desc); | |
} else { | |
obj.__defineGetter__(key, getFunc); | |
if (opt_setFunc) { | |
obj.__defineSetter__(key, opt_setFunc); | |
} | |
} | |
}; | |
/** | |
* Defines a property getter for obj[key]. | |
*/ | |
utils.defineGetter = utils.defineGetterSetter; | |
utils.arrayIndexOf = function(a, item) { | |
if (a.indexOf) { | |
return a.indexOf(item); | |
} | |
var len = a.length; | |
for (var i = 0; i < len; ++i) { | |
if (a[i] == item) { | |
return i; | |
} | |
} | |
return -1; | |
}; | |
/** | |
* Returns whether the item was found in the array. | |
*/ | |
utils.arrayRemove = function(a, item) { | |
var index = utils.arrayIndexOf(a, item); | |
if (index != -1) { | |
a.splice(index, 1); | |
} | |
return index != -1; | |
}; | |
utils.typeName = function(val) { | |
return Object.prototype.toString.call(val).slice(8, -1); | |
}; | |
/** | |
* Returns an indication of whether the argument is an array or not | |
*/ | |
utils.isArray = function(a) { | |
return utils.typeName(a) == 'Array'; | |
}; | |
/** | |
* Returns an indication of whether the argument is a Date or not | |
*/ | |
utils.isDate = function(d) { | |
return utils.typeName(d) == 'Date'; | |
}; | |
/** | |
* Does a deep clone of the object. | |
*/ | |
utils.clone = function(obj) { | |
if(!obj || typeof obj == 'function' || utils.isDate(obj) || typeof obj != 'object') { | |
return obj; | |
} | |
var retVal, i; | |
if(utils.isArray(obj)){ | |
retVal = []; | |
for(i = 0; i < obj.length; ++i){ | |
retVal.push(utils.clone(obj[i])); | |
} | |
return retVal; | |
} | |
retVal = {}; | |
for(i in obj){ | |
if(!(i in retVal) || retVal[i] != obj[i]) { | |
retVal[i] = utils.clone(obj[i]); | |
} | |
} | |
return retVal; | |
}; | |
/** | |
* Returns a wrapped version of the function | |
*/ | |
utils.close = function(context, func, params) { | |
if (typeof params == 'undefined') { | |
return function() { | |
return func.apply(context, arguments); | |
}; | |
} else { | |
return function() { | |
return func.apply(context, params); | |
}; | |
} | |
}; | |
/** | |
* Create a UUID | |
*/ | |
utils.createUUID = function() { | |
return UUIDcreatePart(4) + '-' + | |
UUIDcreatePart(2) + '-' + | |
UUIDcreatePart(2) + '-' + | |
UUIDcreatePart(2) + '-' + | |
UUIDcreatePart(6); | |
}; | |
/** | |
* Extends a child object from a parent object using classical inheritance | |
* pattern. | |
*/ | |
utils.extend = (function() { | |
// proxy used to establish prototype chain | |
var F = function() {}; | |
// extend Child from Parent | |
return function(Child, Parent) { | |
F.prototype = Parent.prototype; | |
Child.prototype = new F(); | |
Child.__super__ = Parent.prototype; | |
Child.prototype.constructor = Child; | |
}; | |
}()); | |
/** | |
* Alerts a message in any available way: alert or console.log. | |
*/ | |
utils.alert = function(msg) { | |
if (window.alert) { | |
window.alert(msg); | |
} else if (console && console.log) { | |
console.log(msg); | |
} | |
}; | |
//------------------------------------------------------------------------------ | |
function UUIDcreatePart(length) { | |
var uuidpart = ""; | |
for (var i=0; i<length; i++) { | |
var uuidchar = parseInt((Math.random() * 256), 10).toString(16); | |
if (uuidchar.length == 1) { | |
uuidchar = "0" + uuidchar; | |
} | |
uuidpart += uuidchar; | |
} | |
return uuidpart; | |
} | |
}); | |
window.cordova = require('cordova'); | |
// file: lib/scripts/bootstrap.js | |
(function (context) { | |
if (context._cordovaJsLoaded) { | |
throw new Error('cordova.js included multiple times.'); | |
} | |
context._cordovaJsLoaded = true; | |
var channel = require('cordova/channel'); | |
var platformInitChannelsArray = [channel.onNativeReady, channel.onPluginsReady]; | |
function logUnfiredChannels(arr) { | |
for (var i = 0; i < arr.length; ++i) { | |
if (arr[i].state != 2) { | |
console.log('Channel not fired: ' + arr[i].type); | |
} | |
} | |
} | |
window.setTimeout(function() { | |
if (channel.onDeviceReady.state != 2) { | |
console.log('deviceready has not fired after 5 seconds.'); | |
logUnfiredChannels(platformInitChannelsArray); | |
logUnfiredChannels(channel.deviceReadyChannelsArray); | |
} | |
}, 5000); | |
// Replace navigator before any modules are required(), to ensure it happens as soon as possible. | |
// We replace it so that properties that can't be clobbered can instead be overridden. | |
function replaceNavigator(origNavigator) { | |
var CordovaNavigator = function() {}; | |
CordovaNavigator.prototype = origNavigator; | |
var newNavigator = new CordovaNavigator(); | |
// This work-around really only applies to new APIs that are newer than Function.bind. | |
// Without it, APIs such as getGamepads() break. | |
if (CordovaNavigator.bind) { | |
for (var key in origNavigator) { | |
if (typeof origNavigator[key] == 'function') { | |
newNavigator[key] = origNavigator[key].bind(origNavigator); | |
} | |
} | |
} | |
return newNavigator; | |
} | |
if (context.navigator) { | |
context.navigator = replaceNavigator(context.navigator); | |
} | |
// _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 (window._nativeReady) { | |
channel.onNativeReady.fire(); | |
} | |
/** | |
* Create all cordova objects once native side is ready. | |
*/ | |
channel.join(function() { | |
// Call the platform-specific initialization | |
require('cordova/platform').initialize(); | |
// Fire event to notify that all objects are created | |
channel.onCordovaReady.fire(); | |
// Fire onDeviceReady event once page has fully loaded, all | |
// constructors have run and cordova info has been received from native | |
// side. | |
// This join call is deliberately made after platform.initialize() in | |
// order that plugins may manipulate channel.deviceReadyChannelsArray | |
// if necessary. | |
channel.join(function() { | |
require('cordova').fireDocumentEvent('deviceready'); | |
}, channel.deviceReadyChannelsArray); | |
}, platformInitChannelsArray); | |
}(window)); | |
// file: lib/scripts/bootstrap-windows8.js | |
require('cordova/channel').onNativeReady.fire(); | |
// file: lib/scripts/plugin_loader.js | |
// Tries to load all plugins' js-modules. | |
// This is an async process, but onDeviceReady is blocked on onPluginsReady. | |
// onPluginsReady is fired when there are no plugins to load, or they are all done. | |
(function (context) { | |
// To be populated with the handler by handlePluginsObject. | |
var onScriptLoadingComplete; | |
var scriptCounter = 0; | |
function scriptLoadedCallback() { | |
scriptCounter--; | |
if (scriptCounter === 0) { | |
onScriptLoadingComplete && onScriptLoadingComplete(); | |
} | |
} | |
function scriptErrorCallback(err) { | |
// Open Question: If a script path specified in cordova_plugins.js does not exist, do we fail for all? | |
// this is currently just continuing. | |
scriptCounter--; | |
if (scriptCounter === 0) { | |
onScriptLoadingComplete && onScriptLoadingComplete(); | |
} | |
} | |
// Helper function to inject a <script> tag. | |
function injectScript(path) { | |
scriptCounter++; | |
var script = document.createElement("script"); | |
script.onload = scriptLoadedCallback; | |
script.onerror = scriptErrorCallback; | |
script.src = path; | |
document.head.appendChild(script); | |
} | |
// Called when: | |
// * There are plugins defined and all plugins are finished loading. | |
// * There are no plugins to load. | |
function finishPluginLoading() { | |
context.cordova.require('cordova/channel').onPluginsReady.fire(); | |
} | |
// Handler for the cordova_plugins.js content. | |
// See plugman's plugin_loader.js for the details of this object. | |
// This function is only called if the really is a plugins array that isn't empty. | |
// Otherwise the onerror response handler will just call finishPluginLoading(). | |
function handlePluginsObject(modules, path) { | |
// First create the callback for when all plugins are loaded. | |
var mapper = context.cordova.require('cordova/modulemapper'); | |
onScriptLoadingComplete = function() { | |
// Loop through all the plugins and then through their clobbers and merges. | |
for (var i = 0; i < modules.length; i++) { | |
var module = modules[i]; | |
if (module) { | |
try { | |
if (module.clobbers && module.clobbers.length) { | |
for (var j = 0; j < module.clobbers.length; j++) { | |
mapper.clobbers(module.id, module.clobbers[j]); | |
} | |
} | |
if (module.merges && module.merges.length) { | |
for (var k = 0; k < module.merges.length; k++) { | |
mapper.merges(module.id, module.merges[k]); | |
} | |
} | |
// Finally, if runs is truthy we want to simply require() the module. | |
// This can be skipped if it had any merges or clobbers, though, | |
// since the mapper will already have required the module. | |
if (module.runs && !(module.clobbers && module.clobbers.length) && !(module.merges && module.merges.length)) { | |
context.cordova.require(module.id); | |
} | |
} | |
catch(err) { | |
// error with module, most likely clobbers, should we continue? | |
} | |
} | |
} | |
finishPluginLoading(); | |
}; | |
// Now inject the scripts. | |
for (var i = 0; i < modules.length; i++) { | |
injectScript(path + modules[i].file); | |
} | |
} | |
// Find the root of the app | |
var path = ''; | |
var scripts = document.getElementsByTagName('script'); | |
var term = 'cordova.js'; | |
for (var n = scripts.length-1; n>-1; n--) { | |
var src = scripts[n].src; | |
if (src.indexOf(term) == (src.length - term.length)) { | |
path = src.substring(0, src.length - term.length); | |
break; | |
} | |
} | |
var plugins_json = path + 'cordova_plugins.json'; | |
var plugins_js = path + 'cordova_plugins.js'; | |
// One some phones (Windows) this xhr.open throws an Access Denied exception | |
// So lets keep trying, but with a script tag injection technique instead of XHR | |
var injectPluginScript = function injectPluginScript() { | |
try { | |
var script = document.createElement("script"); | |
script.onload = function(){ | |
var list = cordova.require("cordova/plugin_list"); | |
handlePluginsObject(list,path); | |
}; | |
script.onerror = function() { | |
// Error loading cordova_plugins.js, file not found or something | |
// this is an acceptable error, pre-3.0.0, so we just move on. | |
finishPluginLoading(); | |
}; | |
script.src = plugins_js; | |
document.head.appendChild(script); | |
} catch(err){ | |
finishPluginLoading(); | |
} | |
} | |
// Try to XHR the cordova_plugins.json file asynchronously. | |
var xhr = new XMLHttpRequest(); | |
xhr.onload = function() { | |
// If the response is a JSON string which composes an array, call handlePluginsObject. | |
// If the request fails, or the response is not a JSON array, just call finishPluginLoading. | |
var obj; | |
try { | |
obj = (this.status == 0 || this.status == 200) && this.responseText && JSON.parse(this.responseText); | |
} catch (err) { | |
// obj will be undefined. | |
} | |
if (Array.isArray(obj) && obj.length > 0) { | |
handlePluginsObject(obj, path); | |
} else { | |
finishPluginLoading(); | |
} | |
}; | |
xhr.onerror = function() { | |
// In this case, the json file was not present, but XHR was allowed, | |
// so we should still try the script injection technique with the js file | |
// in case that is there. | |
injectPluginScript(); | |
}; | |
try { // we commented we were going to try, so let us actually try and catch | |
xhr.open('GET', plugins_json, true); // Async | |
xhr.send(); | |
} catch(err){ | |
injectPluginScript(); | |
} | |
}(window)); | |
})(); |