| // commit a42f0ae6245e7609c9bad1eb582777a696201aad |
| |
| // File generated at :: Tue Apr 24 2012 15:08:45 GMT-0700 (PDT) |
| |
| /* |
| 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() { |
| |
| // file: lib/scripts/require.js |
| var require, |
| define; |
| |
| (function () { |
| var modules = {}; |
| |
| function build(module) { |
| var factory = module.factory; |
| module.exports = {}; |
| delete module.factory; |
| factory(require, module.exports, module); |
| return module.exports; |
| } |
| |
| require = function (id) { |
| if (!modules[id]) { |
| throw "module " + id + " not found"; |
| } |
| return modules[id].factory ? build(modules[id]) : 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]; |
| }; |
| |
| })(); |
| |
| //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') { |
| 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 (e == 'deviceready') { |
| channel.onDeviceReady.subscribeOnce(handler); |
| } else if (e == 'resume') { |
| channel.onResume.subscribe(handler); |
| // if subscribing listener after event has already fired, invoke the handler |
| if (channel.onResume.fired && handler instanceof Function) { |
| handler(); |
| } |
| } else if (e == 'pause') { |
| channel.onPause.subscribe(handler); |
| } else 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(); |
| // Check for pause/resume events first. |
| if (e == 'resume') { |
| channel.onResume.unsubscribe(handler); |
| } else if (e == 'pause') { |
| channel.onPause.unsubscribe(handler); |
| // If unsubcribing from an event that is handled by a plugin |
| } else 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 unsubcribing 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, opts) { |
| return (windowEventHandlers[event] = channel.create(event, opts)); |
| }, |
| addDocumentEventHandler:function(event, opts) { |
| return (documentEventHandlers[event] = channel.create(event, opts)); |
| }, |
| removeWindowEventHandler:function(event) { |
| delete windowEventHandlers[event]; |
| }, |
| removeDocumentEventHandler:function(event) { |
| delete documentEventHandlers[event]; |
| }, |
| /** |
| * Retreive 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 |
| */ |
| fireDocumentEvent: function(type, data) { |
| var evt = createEvent(type, data); |
| if (typeof documentEventHandlers[type] != 'undefined') { |
| documentEventHandlers[type].fire(evt); |
| } else { |
| document.dispatchEvent(evt); |
| } |
| }, |
| fireWindowEvent: function(type, data) { |
| var evt = createEvent(type,data); |
| if (typeof windowEventHandlers[type] != 'undefined') { |
| windowEventHandlers[type].fire(evt); |
| } else { |
| window.dispatchEvent(evt); |
| } |
| }, |
| // TODO: this is Android only; think about how to do this better |
| shuttingDown:false, |
| UsePolling:false, |
| // END TODO |
| |
| // TODO: iOS only |
| // This queue holds the currently executing command and all pending |
| // commands executed with cordova.exec(). |
| commandQueue:[], |
| // Indicates if we're currently in the middle of flushing the command |
| // queue on the native side. |
| commandQueueFlushing:false, |
| // END TODO |
| /** |
| * Plugin callback mechanism. |
| */ |
| callbackId: 0, |
| 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. |
| * |
| * @param callbackId |
| * @param args |
| */ |
| callbackSuccess: function(callbackId, args) { |
| if (cordova.callbacks[callbackId]) { |
| |
| // If result is to be sent to callback |
| if (args.status == cordova.callbackStatus.OK) { |
| try { |
| if (cordova.callbacks[callbackId].success) { |
| cordova.callbacks[callbackId].success(args.message); |
| } |
| } |
| catch (e) { |
| console.log("Error in success callback: "+callbackId+" = "+e); |
| } |
| } |
| |
| // Clear callback if not expecting any more results |
| if (!args.keepCallback) { |
| delete cordova.callbacks[callbackId]; |
| } |
| } |
| }, |
| |
| /** |
| * Called by native code when returning error result from an action. |
| * |
| * @param callbackId |
| * @param args |
| */ |
| callbackError: function(callbackId, args) { |
| if (cordova.callbacks[callbackId]) { |
| try { |
| if (cordova.callbacks[callbackId].fail) { |
| cordova.callbacks[callbackId].fail(args.message); |
| } |
| } |
| catch (e) { |
| console.log("Error in error callback: "+callbackId+" = "+e); |
| } |
| |
| // Clear callback if not expecting any more results |
| if (!args.keepCallback) { |
| delete cordova.callbacks[callbackId]; |
| } |
| } |
| }, |
| // TODO: remove in 2.0. |
| addPlugin: function(name, obj) { |
| console.log("[DEPRECATION NOTICE] window.addPlugin and window.plugins will be removed in version 2.0."); |
| if (!window.plugins[name]) { |
| window.plugins[name] = obj; |
| } |
| else { |
| console.log("Error: Plugin "+name+" already exists."); |
| } |
| }, |
| |
| addConstructor: function(func) { |
| channel.onCordovaReady.subscribeOnce(function() { |
| try { |
| func(); |
| } catch(e) { |
| console.log("Failed to run constructor: " + e); |
| } |
| }); |
| } |
| }; |
| |
| /** |
| * Legacy variable for plugin support |
| * TODO: remove in 2.0. |
| */ |
| if (!window.PhoneGap) { |
| window.PhoneGap = cordova; |
| } |
| if (!window.Cordova) { |
| window.Cordova = cordova; |
| } |
| |
| /** |
| * Plugins object |
| * TODO: remove in 2.0. |
| */ |
| if (!window.plugins) { |
| window.plugins = {}; |
| } |
| |
| module.exports = cordova; |
| |
| }); |
| |
| // 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 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') { |
| parent[key] = result; |
| } else if (typeof obj.path !== 'undefined') { |
| // If merging, merge properties onto parent, otherwise, clobber. |
| if (merge) { |
| recursiveMerge(parent[key], result); |
| } else { |
| parent[key] = result; |
| } |
| } |
| result = parent[key]; |
| } else { |
| // Overwrite if not currently defined. |
| if (typeof parent[key] == 'undefined') { |
| parent[key] = result; |
| } else if (merge && typeof obj.path !== 'undefined') { |
| // If merging, merge parent onto result |
| recursiveMerge(result, parent[key]); |
| parent[key] = result; |
| } 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 (typeof target.prototype !== 'undefined' && target.prototype.constructor === target) { |
| // If the target object is a constructor override off prototype. |
| target.prototype[prop] = src[prop]; |
| } else { |
| target[prop] = typeof src[prop] === 'object' ? recursiveMerge( |
| target[prop], src[prop]) : src[prop]; |
| } |
| } |
| } |
| return target; |
| } |
| |
| module.exports = { |
| build: function (objects) { |
| return { |
| intoButDontClobber: function (target) { |
| include(target, objects, false, false); |
| }, |
| intoAndClobber: function(target) { |
| include(target, objects, true, false); |
| }, |
| intoAndMerge: function(target) { |
| include(target, objects, true, true); |
| } |
| }; |
| } |
| }; |
| |
| }); |
| |
| // file: lib/common/channel.js |
| define("cordova/channel", function(require, exports, module) { |
| /** |
| * 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. |
| * |
| * 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 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 |
| * @param opts Object options to pass into the channel, currently |
| * supports: |
| * onSubscribe: callback that fires when |
| * something subscribes to the Channel. Sets |
| * context to the Channel. |
| * onUnsubscribe: callback that fires when |
| * something unsubscribes to the Channel. Sets |
| * context to the Channel. |
| */ |
| var Channel = function(type, opts) { |
| this.type = type; |
| this.handlers = {}; |
| this.numHandlers = 0; |
| this.guid = 0; |
| this.fired = false; |
| this.enabled = true; |
| this.events = { |
| onSubscribe:null, |
| onUnsubscribe:null |
| }; |
| if (opts) { |
| if (opts.onSubscribe) this.events.onSubscribe = opts.onSubscribe; |
| if (opts.onUnsubscribe) this.events.onUnsubscribe = opts.onUnsubscribe; |
| } |
| }, |
| channel = { |
| /** |
| * Calls the provided function only after all of the channels specified |
| * have been fired. |
| */ |
| join: function (h, c) { |
| var i = c.length; |
| var len = i; |
| var f = function() { |
| if (!(--i)) h(); |
| }; |
| for (var j=0; j<len; j++) { |
| !c[j].fired?c[j].subscribeOnce(f):i--; |
| } |
| if (!i) h(); |
| }, |
| create: function (type, opts) { |
| channel[type] = new Channel(type, opts); |
| return channel[type]; |
| }, |
| |
| /** |
| * 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 = null; |
| if (this[feature]) { |
| c = this[feature]; |
| } |
| else { |
| c = this.create(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(); |
| } |
| } |
| }, |
| utils = require('cordova/utils'); |
| |
| /** |
| * 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, g) { |
| // need a function to call |
| if (f === null || f === undefined) { return; } |
| |
| var func = f; |
| if (typeof c == "object" && f instanceof Function) { func = utils.close(c, f); } |
| |
| g = g || func.observer_guid || f.observer_guid || this.guid++; |
| func.observer_guid = g; |
| f.observer_guid = g; |
| this.handlers[g] = func; |
| this.numHandlers++; |
| if (this.events.onSubscribe) this.events.onSubscribe.call(this); |
| return g; |
| }; |
| |
| /** |
| * Like subscribe but the function is only called once and then it |
| * auto-unsubscribes itself. |
| */ |
| Channel.prototype.subscribeOnce = function(f, c) { |
| // need a function to call |
| if (f === null || f === undefined) { return; } |
| |
| var g = null; |
| var _this = this; |
| var m = function() { |
| f.apply(c || null, arguments); |
| _this.unsubscribe(g); |
| }; |
| if (this.fired) { |
| if (typeof c == "object" && f instanceof Function) { f = utils.close(c, f); } |
| f.apply(this, this.fireArgs); |
| } else { |
| g = this.subscribe(m); |
| } |
| return g; |
| }; |
| |
| /** |
| * Unsubscribes the function with the given guid from the channel. |
| */ |
| Channel.prototype.unsubscribe = function(g) { |
| // need a function to unsubscribe |
| if (g === null || g === undefined) { return; } |
| |
| if (g instanceof Function) { g = g.observer_guid; } |
| this.handlers[g] = null; |
| delete this.handlers[g]; |
| this.numHandlers--; |
| if (this.events.onUnsubscribe) this.events.onUnsubscribe.call(this); |
| }; |
| |
| /** |
| * Calls all functions subscribed to this channel. |
| */ |
| Channel.prototype.fire = function(e) { |
| if (this.enabled) { |
| var fail = false; |
| this.fired = true; |
| for (var item in this.handlers) { |
| var handler = this.handlers[item]; |
| if (handler instanceof Function) { |
| var rv = (handler.apply(this, arguments)===false); |
| fail = fail || rv; |
| } |
| } |
| this.fireArgs = arguments; |
| return !fail; |
| } |
| return true; |
| }; |
| |
| // defining them here so they are ready super fast! |
| // DOM event that is received when the web page is loaded and parsed. |
| channel.create('onDOMContentLoaded'); |
| |
| // Event to indicate the Cordova native side is ready. |
| channel.create('onNativeReady'); |
| |
| // Event to indicate that all Cordova JavaScript objects have been created |
| // and it's time to run plugin constructors. |
| channel.create('onCordovaReady'); |
| |
| // Event to indicate that device properties are available |
| channel.create('onCordovaInfoReady'); |
| |
| // Event to indicate that the connection property has been set. |
| channel.create('onCordovaConnectionReady'); |
| |
| // Event to indicate that Cordova is ready |
| channel.create('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.create('onDestroy'); |
| |
| // Channels that must fire before "deviceready" is fired. |
| channel.waitForInitialization('onCordovaReady'); |
| channel.waitForInitialization('onCordovaInfoReady'); |
| channel.waitForInitialization('onCordovaConnectionReady'); |
| |
| module.exports = channel; |
| }); |
| |
| // file: lib/common/common.js |
| define("cordova/common", function(require, exports, module) { |
| module.exports = { |
| objects: { |
| cordova: { |
| path: 'cordova', |
| children: { |
| exec: { |
| path: 'cordova/exec' |
| } |
| } |
| }, |
| navigator: { |
| children: { |
| notification: { |
| path: 'cordova/plugin/notification' |
| }, |
| accelerometer: { |
| path: 'cordova/plugin/accelerometer' |
| }, |
| battery: { |
| path: 'cordova/plugin/battery' |
| }, |
| camera:{ |
| path: 'cordova/plugin/Camera' |
| }, |
| compass:{ |
| path: 'cordova/plugin/compass' |
| }, |
| contacts: { |
| path: 'cordova/plugin/contacts' |
| }, |
| device:{ |
| children:{ |
| capture: { |
| path: 'cordova/plugin/capture' |
| } |
| } |
| }, |
| geolocation: { |
| path: 'cordova/plugin/geolocation' |
| }, |
| network: { |
| children: { |
| connection: { |
| path: 'cordova/plugin/network' |
| } |
| } |
| } |
| } |
| }, |
| Acceleration: { |
| path: 'cordova/plugin/Acceleration' |
| }, |
| Camera:{ |
| path: 'cordova/plugin/CameraConstants' |
| }, |
| CaptureError: { |
| path: 'cordova/plugin/CaptureError' |
| }, |
| CaptureAudioOptions:{ |
| path: 'cordova/plugin/CaptureAudioOptions' |
| }, |
| CaptureImageOptions: { |
| path: 'cordova/plugin/CaptureImageOptions' |
| }, |
| CaptureVideoOptions: { |
| path: 'cordova/plugin/CaptureVideoOptions' |
| }, |
| CompassHeading:{ |
| path: 'cordova/plugin/CompassHeading' |
| }, |
| CompassError:{ |
| path: 'cordova/plugin/CompassError' |
| }, |
| ConfigurationData: { |
| path: 'cordova/plugin/ConfigurationData' |
| }, |
| Connection: { |
| path: 'cordova/plugin/Connection' |
| }, |
| Contact: { |
| path: 'cordova/plugin/Contact' |
| }, |
| ContactAddress: { |
| path: 'cordova/plugin/ContactAddress' |
| }, |
| ContactError: { |
| path: 'cordova/plugin/ContactError' |
| }, |
| ContactField: { |
| path: 'cordova/plugin/ContactField' |
| }, |
| ContactFindOptions: { |
| path: 'cordova/plugin/ContactFindOptions' |
| }, |
| ContactName: { |
| path: 'cordova/plugin/ContactName' |
| }, |
| ContactOrganization: { |
| path: 'cordova/plugin/ContactOrganization' |
| }, |
| Coordinates: { |
| path: 'cordova/plugin/Coordinates' |
| }, |
| DirectoryEntry: { |
| path: 'cordova/plugin/DirectoryEntry' |
| }, |
| DirectoryReader: { |
| path: 'cordova/plugin/DirectoryReader' |
| }, |
| Entry: { |
| path: 'cordova/plugin/Entry' |
| }, |
| File: { |
| path: 'cordova/plugin/File' |
| }, |
| FileEntry: { |
| path: 'cordova/plugin/FileEntry' |
| }, |
| FileError: { |
| path: 'cordova/plugin/FileError' |
| }, |
| FileReader: { |
| path: 'cordova/plugin/FileReader' |
| }, |
| FileSystem: { |
| path: 'cordova/plugin/FileSystem' |
| }, |
| FileTransfer: { |
| path: 'cordova/plugin/FileTransfer' |
| }, |
| FileTransferError: { |
| path: 'cordova/plugin/FileTransferError' |
| }, |
| FileUploadOptions: { |
| path: 'cordova/plugin/FileUploadOptions' |
| }, |
| FileUploadResult: { |
| path: 'cordova/plugin/FileUploadResult' |
| }, |
| FileWriter: { |
| path: 'cordova/plugin/FileWriter' |
| }, |
| Flags: { |
| path: 'cordova/plugin/Flags' |
| }, |
| LocalFileSystem: { |
| path: 'cordova/plugin/LocalFileSystem' |
| }, |
| Media: { |
| path: 'cordova/plugin/Media' |
| }, |
| MediaError: { |
| path: 'cordova/plugin/MediaError' |
| }, |
| MediaFile: { |
| path: 'cordova/plugin/MediaFile' |
| }, |
| MediaFileData:{ |
| path: 'cordova/plugin/MediaFileData' |
| }, |
| Metadata:{ |
| path: 'cordova/plugin/Metadata' |
| }, |
| Position: { |
| path: 'cordova/plugin/Position' |
| }, |
| PositionError: { |
| path: 'cordova/plugin/PositionError' |
| }, |
| ProgressEvent: { |
| path: 'cordova/plugin/ProgressEvent' |
| }, |
| requestFileSystem:{ |
| path: 'cordova/plugin/requestFileSystem' |
| }, |
| resolveLocalFileSystemURI:{ |
| path: 'cordova/plugin/resolveLocalFileSystemURI' |
| } |
| } |
| }; |
| }); |
| |
| // file: lib/playbook/exec.js |
| define("cordova/exec", function(require, exports, module) { |
| var playbook = require('cordova/plugin/playbook/manager'), |
| cordova = require('cordova'), |
| utils = require('cordova/utils'); |
| |
| /** |
| * 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 |
| * Asynchrounous: Empty string "" |
| * If async, the native side will cordova.callbackSuccess or cordova.callbackError, |
| * depending upon the result of the action. |
| * |
| * @param {Function} success The success callback |
| * @param {Function} fail The fail callback |
| * @param {String} service The name of the service to use |
| * @param {String} action Action to be run in cordova |
| * @param {String[]} [args] Zero or more arguments to pass to the method |
| */ |
| |
| module.exports = function(success, fail, service, action, args) { |
| try { |
| var v = playbook.exec(success, fail, service, action, args); |
| |
| // If status is OK, then return value back to caller |
| if (v.status == cordova.callbackStatus.OK) { |
| |
| // If there is a success callback, then call it now with returned value |
| if (success) { |
| try { |
| success(v.message); |
| } |
| catch (e) { |
| console.log("Error in success callback: "+cordova.callbackId+" = "+e); |
| } |
| |
| } |
| return v.message; |
| } else if (v.status == cordova.callbackStatus.NO_RESULT) { |
| |
| } else { |
| // If error, then display error |
| console.log("Error: Status="+v.status+" Message="+v.message); |
| |
| // If there is a fail callback, then call it now with returned value |
| if (fail) { |
| try { |
| fail(v.message); |
| } |
| catch (e) { |
| console.log("Error in error callback: "+cordova.callbackId+" = "+e); |
| } |
| } |
| return null; |
| } |
| } catch (e) { |
| utils.alert("Error: "+e); |
| } |
| }; |
| }); |
| |
| // file: lib/playbook/platform.js |
| define("cordova/platform", function(require, exports, module) { |
| module.exports = { |
| id: "playbook", |
| initialize:function() {}, |
| objects: { |
| device: { |
| path: "cordova/plugin/playbook/device" |
| } |
| }, |
| merges: { |
| navigator: { |
| children: { |
| device: { |
| path: "cordova/plugin/playbook/device" |
| } |
| } |
| } |
| } |
| }; |
| }); |
| |
| // 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 exec = require('cordova/exec'), |
| Camera = require('cordova/plugin/CameraConstants'); |
| |
| 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_URL. |
| * |
| * @param {Function} successCallback |
| * @param {Function} errorCallback |
| * @param {Object} options |
| */ |
| cameraExport.getPicture = function(successCallback, errorCallback, options) { |
| // successCallback required |
| if (typeof successCallback != "function") { |
| console.log("Camera Error: successCallback is not a function"); |
| return; |
| } |
| |
| // errorCallback optional |
| if (errorCallback && (typeof errorCallback != "function")) { |
| console.log("Camera Error: errorCallback is not a function"); |
| return; |
| } |
| |
| var quality = 50; |
| if (options && typeof options.quality == "number") { |
| quality = options.quality; |
| } else if (options && typeof options.quality == "string") { |
| var qlity = parseInt(options.quality, 10); |
| if (isNaN(qlity) === false) { |
| quality = qlity.valueOf(); |
| } |
| } |
| |
| var destinationType = Camera.DestinationType.FILE_URI; |
| if (typeof options.destinationType == "number") { |
| destinationType = options.destinationType; |
| } |
| |
| var sourceType = Camera.PictureSourceType.CAMERA; |
| if (typeof options.sourceType == "number") { |
| sourceType = options.sourceType; |
| } |
| |
| var targetWidth = -1; |
| if (typeof options.targetWidth == "number") { |
| targetWidth = options.targetWidth; |
| } else if (typeof options.targetWidth == "string") { |
| var width = parseInt(options.targetWidth, 10); |
| if (isNaN(width) === false) { |
| targetWidth = width.valueOf(); |
| } |
| } |
| |
| var targetHeight = -1; |
| if (typeof options.targetHeight == "number") { |
| targetHeight = options.targetHeight; |
| } else if (typeof options.targetHeight == "string") { |
| var height = parseInt(options.targetHeight, 10); |
| if (isNaN(height) === false) { |
| targetHeight = height.valueOf(); |
| } |
| } |
| |
| var encodingType = Camera.EncodingType.JPEG; |
| if (typeof options.encodingType == "number") { |
| encodingType = options.encodingType; |
| } |
| |
| var mediaType = Camera.MediaType.PICTURE; |
| if (typeof options.mediaType == "number") { |
| mediaType = options.mediaType; |
| } |
| var allowEdit = false; |
| if (typeof options.allowEdit == "boolean") { |
| allowEdit = options.allowEdit; |
| } else if (typeof options.allowEdit == "number") { |
| allowEdit = options.allowEdit <= 0 ? false : true; |
| } |
| var correctOrientation = false; |
| if (typeof options.correctOrientation == "boolean") { |
| correctOrientation = options.correctOrientation; |
| } else if (typeof options.correctOrientation == "number") { |
| correctOrientation = options.correctOrientation <=0 ? false : true; |
| } |
| var saveToPhotoAlbum = false; |
| if (typeof options.saveToPhotoAlbum == "boolean") { |
| saveToPhotoAlbum = options.saveToPhotoAlbum; |
| } else if (typeof options.saveToPhotoAlbum == "number") { |
| saveToPhotoAlbum = options.saveToPhotoAlbum <=0 ? false : true; |
| } |
| |
| exec(successCallback, errorCallback, "Camera", "takePicture", [quality, destinationType, sourceType, targetWidth, targetHeight, encodingType, mediaType, allowEdit, correctOrientation, saveToPhotoAlbum]); |
| }; |
| |
| 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) |
| }, |
| 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) |
| } |
| }; |
| }); |
| |
| // 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; |
| // The selected audio mode. Must match with one of the elements in supportedAudioModes array. |
| this.mode = null; |
| }; |
| |
| 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; |
| // The selected image mode. Must match with one of the elements in supportedImageModes array. |
| this.mode = null; |
| }; |
| |
| 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; |
| // The selected video mode. Must match with one of the elements in supportedVideoModes array. |
| this.mode = null; |
| }; |
| |
| 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 occured |
| * @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 !== undefined ? magneticHeading : null); |
| this.trueHeading = (trueHeading !== undefined ? trueHeading : null); |
| this.headingAccuracy = (headingAccuracy !== undefined ? headingAccuracy : null); |
| this.timestamp = (timestamp !== undefined ? 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", |
| NONE: "none" |
| }; |
| }); |
| |
| // file: lib/common/plugin/Contact.js |
| define("cordova/plugin/Contact", function(require, exports, module) { |
| var 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 (!value instanceof Date){ |
| try { |
| value = new Date(value); |
| } catch(exception){ |
| value = null; |
| } |
| } |
| if (value instanceof Date){ |
| 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) { |
| var fail = 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); |
| var i; |
| clonedContact.id = null; |
| clonedContact.rawId = null; |
| // Loop through and clear out any id's in phones, emails, etc. |
| if (clonedContact.phoneNumbers) { |
| for (i = 0; i < clonedContact.phoneNumbers.length; i++) { |
| clonedContact.phoneNumbers[i].id = null; |
| } |
| } |
| if (clonedContact.emails) { |
| for (i = 0; i < clonedContact.emails.length; i++) { |
| clonedContact.emails[i].id = null; |
| } |
| } |
| if (clonedContact.addresses) { |
| for (i = 0; i < clonedContact.addresses.length; i++) { |
| clonedContact.addresses[i].id = null; |
| } |
| } |
| if (clonedContact.ims) { |
| for (i = 0; i < clonedContact.ims.length; i++) { |
| clonedContact.ims[i].id = null; |
| } |
| } |
| if (clonedContact.organizations) { |
| for (i = 0; i < clonedContact.organizations.length; i++) { |
| clonedContact.organizations[i].id = null; |
| } |
| } |
| if (clonedContact.categories) { |
| for (i = 0; i < clonedContact.categories.length; i++) { |
| clonedContact.categories[i].id = null; |
| } |
| } |
| if (clonedContact.photos) { |
| for (i = 0; i < clonedContact.photos.length; i++) { |
| clonedContact.photos[i].id = null; |
| } |
| } |
| if (clonedContact.urls) { |
| for (i = 0; i < clonedContact.urls.length; i++) { |
| clonedContact.urls[i].id = null; |
| } |
| } |
| return clonedContact; |
| }; |
| |
| /** |
| * Persists contact to device storage. |
| * @param successCB success callback |
| * @param errorCB error callback |
| */ |
| Contact.prototype.save = function(successCB, errorCB) { |
| var fail = function(code) { |
| errorCB(new ContactError(code)); |
| }; |
| var success = function(result) { |
| if (result) { |
| if (typeof successCB === 'function') { |
| 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 occured |
| * @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 || null; |
| this.value = value || 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; |
| /** |
| * The direction the device is moving at the position. |
| */ |
| this.heading = head; |
| /** |
| * The velocity with which the device is moving at the position. |
| */ |
| this.speed = vel; |
| /** |
| * 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 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) |
| * {FileSystem} filesystem on which the directory resides (readonly) |
| */ |
| var DirectoryEntry = function(name, fullPath) { |
| DirectoryEntry.__super__.constructor.apply(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 excluively create the directory |
| * @param {Function} successCallback is called with the new entry |
| * @param {Function} errorCallback is called with a FileError |
| */ |
| DirectoryEntry.prototype.getDirectory = function(path, options, successCallback, errorCallback) { |
| var win = typeof successCallback !== 'function' ? null : function(result) { |
| var entry = new DirectoryEntry(result.name, result.fullPath); |
| successCallback(entry); |
| }; |
| var fail = typeof errorCallback !== 'function' ? null : 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) { |
| var fail = typeof errorCallback !== 'function' ? null : 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 excluively create the file |
| * @param {Function} successCallback is called with the new entry |
| * @param {Function} errorCallback is called with a FileError |
| */ |
| DirectoryEntry.prototype.getFile = function(path, options, successCallback, errorCallback) { |
| var win = typeof successCallback !== 'function' ? null : function(result) { |
| var FileEntry = require('cordova/plugin/FileEntry'); |
| var entry = new FileEntry(result.name, result.fullPath); |
| successCallback(entry); |
| }; |
| var fail = typeof errorCallback !== 'function' ? null : 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 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 = (typeof isFile != 'undefined'?isFile:false); |
| this.isDirectory = (typeof isDirectory != 'undefined'?isDirectory:false); |
| 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) { |
| var success = typeof successCallback !== 'function' ? null : function(lastModified) { |
| var metadata = new Metadata(lastModified); |
| successCallback(metadata); |
| }; |
| var fail = typeof errorCallback !== 'function' ? null : function(code) { |
| errorCallback(new FileError(code)); |
| }; |
| |
| exec(success, fail, "File", "getMetadata", [this.fullPath]); |
| }; |
| |
| /** |
| * 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) { |
| var fail = function(code) { |
| if (typeof errorCallback === 'function') { |
| errorCallback(new FileError(code)); |
| } |
| }; |
| // user must specify parent Entry |
| if (!parent) { |
| fail(FileError.NOT_FOUND_ERR); |
| return; |
| } |
| // source path |
| var srcPath = this.fullPath, |
| // entry name |
| name = newName || this.name, |
| success = function(entry) { |
| if (entry) { |
| if (typeof successCallback === 'function') { |
| // 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); |
| try { |
| successCallback(result); |
| } |
| catch (e) { |
| console.log('Error invoking callback: ' + e); |
| } |
| } |
| } |
| else { |
| // no Entry object returned |
| 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) { |
| var fail = function(code) { |
| if (typeof errorCallback === 'function') { |
| errorCallback(new FileError(code)); |
| } |
| }; |
| |
| // user must specify parent Entry |
| if (!parent) { |
| fail(FileError.NOT_FOUND_ERR); |
| return; |
| } |
| |
| // source path |
| var srcPath = this.fullPath, |
| // entry name |
| name = newName || this.name, |
| // success callback |
| success = function(entry) { |
| if (entry) { |
| if (typeof successCallback === 'function') { |
| // 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); |
| try { |
| successCallback(result); |
| } |
| catch (e) { |
| console.log('Error invoking callback: ' + e); |
| } |
| } |
| } |
| else { |
| // no Entry object returned |
| 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.fullPath; |
| }; |
| |
| /** |
| * 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) { |
| var fail = typeof errorCallback !== 'function' ? null : 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) { |
| var win = typeof successCallback !== 'function' ? null : function(result) { |
| var DirectoryEntry = require('cordova/plugin/DirectoryEntry'); |
| var entry = new DirectoryEntry(result.name, result.fullPath); |
| successCallback(entry); |
| }; |
| var fail = typeof errorCallback !== 'function' ? null : 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; |
| }; |
| |
| 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 === "") { |
| if (typeof errorCallback === "function") { |
| errorCallback(new FileError(FileError.INVALID_STATE_ERR)); |
| } |
| } else { |
| if (typeof successCallback === "function") { |
| successCallback(writer); |
| } |
| } |
| }, errorCallback); |
| }; |
| |
| /** |
| * Returns a File that represents the current state of the file that this FileEntry represents. |
| * |
| * @param {Function} successCallback is called with the new File object |
| * @param {Function} errorCallback is called with a FileError |
| */ |
| FileEntry.prototype.file = function(successCallback, errorCallback) { |
| var win = typeof successCallback !== 'function' ? null : function(f) { |
| var file = new File(f.name, f.fullPath, f.type, f.lastModifiedDate, f.size); |
| successCallback(file); |
| }; |
| var fail = typeof errorCallback !== 'function' ? null : 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'), |
| FileError = require('cordova/plugin/FileError'), |
| ProgressEvent = require('cordova/plugin/ProgressEvent'); |
| |
| /** |
| * 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.fileName = ""; |
| |
| this.readyState = 0; // FileReader.EMPTY |
| |
| // File data |
| this.result = null; |
| |
| // Error |
| this.error = null; |
| |
| // Event handlers |
| this.onloadstart = null; // When the read starts. |
| this.onprogress = null; // While reading (and decoding) file or fileBlob data, and reporting partial file data (progess.loaded/progress.total) |
| this.onload = null; // When the read has successfully completed. |
| this.onerror = null; // When the read has failed (see errors). |
| this.onloadend = null; // When the request has completed (either in success or failure). |
| this.onabort = null; // When the read has been aborted. For instance, by invoking the abort() method. |
| }; |
| |
| // States |
| FileReader.EMPTY = 0; |
| FileReader.LOADING = 1; |
| FileReader.DONE = 2; |
| |
| /** |
| * Abort reading file. |
| */ |
| FileReader.prototype.abort = function() { |
| 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) { |
| // Figure out pathing |
| this.fileName = ''; |
| if (typeof file.fullPath === 'undefined') { |
| this.fileName = file; |
| } else { |
| this.fileName = file.fullPath; |
| } |
| |
| // Already loading something |
| if (this.readyState == FileReader.LOADING) { |
| throw new FileError(FileError.INVALID_STATE_ERR); |
| } |
| |
| // LOADING state |
| this.readyState = FileReader.LOADING; |
| |
| // If loadstart callback |
| if (typeof this.onloadstart === "function") { |
| this.onloadstart(new ProgressEvent("loadstart", {target:this})); |
| } |
| |
| // Default encoding is UTF-8 |
| var enc = encoding ? encoding : "UTF-8"; |
| |
| var me = this; |
| |
| // 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", [this.fileName, enc]); |
| }; |
| |
| |
| /** |
| * 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) { |
| this.fileName = ""; |
| if (typeof file.fullPath === "undefined") { |
| this.fileName = file; |
| } else { |
| this.fileName = file.fullPath; |
| } |
| |
| // Already loading something |
| if (this.readyState == FileReader.LOADING) { |
| throw new FileError(FileError.INVALID_STATE_ERR); |
| } |
| |
| // LOADING state |
| this.readyState = FileReader.LOADING; |
| |
| // If loadstart callback |
| if (typeof this.onloadstart === "function") { |
| this.onloadstart(new ProgressEvent("loadstart", {target:this})); |
| } |
| |
| var me = this; |
| |
| // 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", [this.fileName]); |
| }; |
| |
| /** |
| * Read file and return data as a binary data. |
| * |
| * @param file {File} File object containing file properties |
| */ |
| FileReader.prototype.readAsBinaryString = function(file) { |
| // TODO - Can't return binary data to browser. |
| console.log('method "readAsBinaryString" is not supported at this time.'); |
| }; |
| |
| /** |
| * Read file and return data as a binary data. |
| * |
| * @param file {File} File object containing file properties |
| */ |
| FileReader.prototype.readAsArrayBuffer = function(file) { |
| // TODO - Can't return binary data to browser. |
| console.log('This method is not supported at this time.'); |
| }; |
| |
| 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 exec = require('cordova/exec'); |
| |
| /** |
| * FileTransfer uploads a file to a remote server. |
| * @constructor |
| */ |
| var FileTransfer = function() {}; |
| |
| /** |
| * 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) { |
| // check for options |
| var fileKey = null; |
| var fileName = null; |
| var mimeType = null; |
| var params = null; |
| var chunkedMode = true; |
| if (options) { |
| fileKey = options.fileKey; |
| fileName = options.fileName; |
| mimeType = options.mimeType; |
| if (options.chunkedMode !== null || typeof options.chunkedMode !== "undefined") { |
| chunkedMode = options.chunkedMode; |
| } |
| if (options.params) { |
| params = options.params; |
| } |
| else { |
| params = {}; |
| } |
| } |
| |
| exec(successCallback, errorCallback, 'FileTransfer', 'upload', [filePath, server, fileKey, fileName, mimeType, params, trustAllHosts, chunkedMode]); |
| }; |
| |
| /** |
| * 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 |
| */ |
| FileTransfer.prototype.download = function(source, target, successCallback, errorCallback) { |
| var win = function(result) { |
| 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); |
| }; |
| exec(win, errorCallback, 'FileTransfer', 'download', [source, target]); |
| }; |
| |
| module.exports = FileTransfer; |
| |
| }); |
| |
| // file: lib/common/plugin/FileTransferError.js |
| define("cordova/plugin/FileTransferError", function(require, exports, module) { |
| /** |
| * FileTransferError |
| * @constructor |
| */ |
| var FileTransferError = function(code) { |
| this.code = code || null; |
| }; |
| |
| FileTransferError.FILE_NOT_FOUND_ERR = 1; |
| FileTransferError.INVALID_URL_ERR = 2; |
| FileTransferError.CONNECTION_ERR = 3; |
| |
| 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. |
| */ |
| var FileUploadOptions = function(fileKey, fileName, mimeType, params) { |
| this.fileKey = fileKey || null; |
| this.fileName = fileName || null; |
| this.mimeType = mimeType || null; |
| this.params = params || 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 text to be written |
| */ |
| FileWriter.prototype.write = function(text) { |
| // Throw an exception if we are already writing a file |
| if (this.readyState === FileWriter.WRITING) { |
| throw 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, text, this.position]); |
| }; |
| |
| /** |
| * Moves the file pointer to the location specified. |
| * |
| * If the offset is a negative number the position of the file |
| * pointer is rewound. If the offset is greater than the file |
| * size the position is set to the end of the file. |
| * |
| * @param offset is the location to move the file pointer to. |
| */ |
| FileWriter.prototype.seek = function(offset) { |
| // Throw an exception if we are already writing a file |
| if (this.readyState === FileWriter.WRITING) { |
| throw 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 then file size so set position |
| // to the end of the file. |
| else if (offset > this.length) { |
| this.position = this.length; |
| } |
| // Offset is between 0 and file size so set the position |
| // to start writing. |
| else { |
| this.position = offset; |
| } |
| }; |
| |
| /** |
| * Truncates the file to the size specified. |
| * |
| * @param size to chop the file at. |
| */ |
| FileWriter.prototype.truncate = function(size) { |
| // Throw an exception if we are already writing a file |
| if (this.readyState === FileWriter.WRITING) { |
| throw 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/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 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) { |
| |
| // successCallback optional |
| if (successCallback && (typeof successCallback !== "function")) { |
| console.log("Media Error: successCallback is not a function"); |
| return; |
| } |
| |
| // errorCallback optional |
| if (errorCallback && (typeof errorCallback !== "function")) { |
| console.log("Media Error: errorCallback is not a function"); |
| return; |
| } |
| |
| // statusCallback optional |
| if (statusCallback && (typeof statusCallback !== "function")) { |
| console.log("Media Error: statusCallback is not a function"); |
| return; |
| } |
| |
| 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; |
| me.successCallback(); |
| }, 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(this.successCallback, this.errorCallback, "Media", "startRecordingAudio", [this.id, this.src]); |
| }; |
| |
| /** |
| * Stop recording audio file. |
| */ |
| Media.prototype.stopRecord = function() { |
| exec(this.successCallback, 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 status The status code (int) |
| * @param msg The status message (string) |
| */ |
| Media.onStatus = function(id, msg, value) { |
| var media = mediaObjects[id]; |
| // If state update |
| if (msg === Media.MEDIA_STATE) { |
| if (value === Media.MEDIA_STOPPED) { |
| if (media.successCallback) { |
| media.successCallback(); |
| } |
| } |
| if (media.statusCallback) { |
| media.statusCallback(value); |
| } |
| } |
| else if (msg === Media.MEDIA_DURATION) { |
| media._duration = value; |
| } |
| else if (msg === Media.MEDIA_ERROR) { |
| if (media.errorCallback) { |
| // value should be a MediaError object when msg == MEDIA_ERROR |
| media.errorCallback(value); |
| } |
| } |
| else if (msg === Media.MEDIA_POSITION) { |
| media._position = value; |
| } |
| }; |
| |
| 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. |
| * @constructor |
| */ |
| var MediaError = function(code, msg) { |
| this.code = (code !== undefined ? code : null); |
| this.message = msg || ""; |
| }; |
| |
| MediaError.MEDIA_ERR_NONE_ACTIVE = 0; |
| MediaError.MEDIA_ERR_ABORTED = 1; |
| MediaError.MEDIA_ERR_NETWORK = 2; |
| MediaError.MEDIA_ERR_DECODE = 3; |
| MediaError.MEDIA_ERR_NONE_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]); |
| } |
| }; |
| |
| /** |
| * Casts a PluginResult message property (array of objects) to an array of MediaFile objects |
| * (used in Objective-C and Android) |
| * |
| * @param {PluginResult} pluginResult |
| */ |
| MediaFile.cast = function(pluginResult) { |
| var mediaFiles = []; |
| var i; |
| for (i=0; i<pluginResult.message.length; i++) { |
| var mediaFile = new MediaFile(); |
| mediaFile.name = pluginResult.message[i].name; |
| mediaFile.fullPath = pluginResult.message[i].fullPath; |
| mediaFile.type = pluginResult.message[i].type; |
| mediaFile.lastModifiedDate = pluginResult.message[i].lastModifiedDate; |
| mediaFile.size = pluginResult.message[i].size; |
| mediaFiles.push(mediaFile); |
| } |
| pluginResult.message = mediaFiles; |
| return pluginResult; |
| }; |
| |
| 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) { |
| this.coords = new Coordinates(coords.latitude, coords.longitude, coords.altitude, coords.accuracy, coords.heading, coords.velocity, coords.altitudeAccuracy); |
| this.timestamp = (timestamp !== undefined) ? timestamp : new Date().getTime(); |
| }; |
| |
| 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 utils = require("cordova/utils"), |
| exec = require("cordova/exec"); |
| |
| // Local singleton variables. |
| var timers = {}; |
| |
| var accelerometer = { |
| /** |
| * Asynchronously aquires 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) { |
| |
| // successCallback required |
| if (typeof successCallback !== "function") { |
| console.log("Accelerometer Error: successCallback is not a function"); |
| return; |
| } |
| |
| // errorCallback optional |
| if (errorCallback && (typeof errorCallback !== "function")) { |
| console.log("Accelerometer Error: errorCallback is not a function"); |
| return; |
| } |
| |
| // Get acceleration |
| exec(successCallback, errorCallback, "Accelerometer", "getAcceleration", []); |
| }, |
| |
| /** |
| * Asynchronously aquires 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) { |
| |
| // Default interval (10 sec) |
| var frequency = (options !== undefined && options.frequency !== undefined)? options.frequency : 10000; |
| |
| // successCallback required |
| if (typeof successCallback !== "function") { |
| console.log("Accelerometer Error: successCallback is not a function"); |
| return; |
| } |
| |
| // errorCallback optional |
| if (errorCallback && (typeof errorCallback !== "function")) { |
| console.log("Accelerometer Error: errorCallback is not a function"); |
| return; |
| } |
| |
| // Make sure accelerometer timeout > frequency + 10 sec |
| exec( |
| function(timeout) { |
| if (timeout < (frequency + 10000)) { |
| exec(null, null, "Accelerometer", "setTimeout", [frequency + 10000]); |
| } |
| }, |
| function(e) { }, "Accelerometer", "getTimeout", []); |
| |
| // Start watch timer |
| var id = utils.createUUID(); |
| timers[id] = window.setInterval(function() { |
| exec(successCallback, errorCallback, "Accelerometer", "getAcceleration", []); |
| }, (frequency ? frequency : 1)); |
| |
| return id; |
| }, |
| |
| /** |
| * Clears the specified accelerometer watch. |
| * |
| * @param {String} id The id of the watch returned from #watchAcceleration. |
| */ |
| clearWatch: function(id) { |
| |
| // Stop javascript timer & remove from timer list |
| if (id && timers[id] !== undefined) { |
| window.clearInterval(timers[id]); |
| delete timers[id]; |
| } |
| } |
| }; |
| |
| module.exports = 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) |
| var subscriptionEvents = { |
| onSubscribe:this.onSubscribe, |
| onUnsubscribe:this.onUnsubscribe |
| }; |
| this.channels = { |
| batterystatus:cordova.addWindowEventHandler("batterystatus", subscriptionEvents), |
| batterylow:cordova.addWindowEventHandler("batterylow", subscriptionEvents), |
| batterycritical:cordova.addWindowEventHandler("batterycritical", subscriptionEvents) |
| }; |
| }; |
| /** |
| * 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.prototype.onSubscribe = function() { |
| var me = battery; |
| // If we just registered the first handler, make sure native listener is started. |
| if (handlers() === 1) { |
| exec(me._status, me._error, "Battery", "start", []); |
| } |
| }; |
| |
| Battery.prototype.onUnsubscribe = function() { |
| var me = battery; |
| |
| // If we just unregistered the last handler, make sure native listener is stopped. |
| 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/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/common/plugin/compass.js |
| define("cordova/plugin/compass", function(require, exports, module) { |
| var 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) { |
| // successCallback required |
| if (typeof successCallback !== "function") { |
| console.log("Compass Error: successCallback is not a function"); |
| return; |
| } |
| |
| // errorCallback optional |
| if (errorCallback && (typeof errorCallback !== "function")) { |
| console.log("Compass Error: errorCallback is not a function"); |
| return; |
| } |
| |
| var win = function(result) { |
| var ch = new CompassHeading(result.magneticHeading, result.trueHeading, result.headingAccuracy, result.timestamp); |
| successCallback(ch); |
| }; |
| var fail = 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) { |
| // Default interval (100 msec) |
| var frequency = (options !== undefined && options.frequency !== undefined) ? options.frequency : 100; |
| var filter = (options !== undefined && options.filter !== undefined) ? options.filter : 0; |
| |
| // successCallback required |
| if (typeof successCallback !== "function") { |
| console.log("Compass Error: successCallback is not a function"); |
| return; |
| } |
| |
| // errorCallback optional |
| if (errorCallback && (typeof errorCallback !== "function")) { |
| console.log("Compass Error: errorCallback is not a function"); |
| return; |
| } |
| |
| 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/contacts.js |
| define("cordova/plugin/contacts", function(require, exports, module) { |
| var exec = require('cordova/exec'), |
| ContactError = require('cordova/plugin/ContactError'), |
| 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) { |
| if (!successCB) { |
| throw new TypeError("You must specify a success callback for the find command."); |
| } |
| if (!fields || (fields instanceof Array && fields.length === 0)) { |
| if (typeof errorCB === "function") { |
| 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 who's properties will be examined to create a new Contact |
| * @returns new Contact object |
| */ |
| create:function(properties) { |
| var i; |
| var contact = new Contact(); |
| for (i in properties) { |
| if (typeof contact[i] !== 'undefined' && properties.hasOwnProperty(i)) { |
| contact[i] = properties[i]; |
| } |
| } |
| return contact; |
| } |
| }; |
| |
| module.exports = contacts; |
| }); |
| |
| // file: lib/common/plugin/geolocation.js |
| define("cordova/plugin/geolocation", function(require, exports, module) { |
| var 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: 10000, |
| enableHighAccuracy: false, |
| timeout: 10000 |
| }; |
| |
| if (options) { |
| if (options.maximumAge !== undefined) { |
| opt.maximumAge = options.maximumAge; |
| } |
| if (options.enableHighAccuracy !== undefined) { |
| opt.enableHighAccuracy = options.enableHighAccuracy; |
| } |
| if (options.timeout !== undefined) { |
| opt.timeout = options.timeout; |
| } |
| } |
| |
| return opt; |
| } |
| |
| var geolocation = { |
| /** |
| * Asynchronously aquires 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) { |
| options = parseParameters(options); |
| |
| var win = function(p) { |
| successCallback(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 || new Date() |
| )); |
| }; |
| var fail = function(e) { |
| errorCallback(new PositionError(e.code, e.message)); |
| }; |
| |
| exec(win, fail, "Geolocation", "getLocation", [options.enableHighAccuracy, options.timeout, options.maximumAge]); |
| }, |
| /** |
| * 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) { |
| options = parseParameters(options); |
| |
| var id = utils.createUUID(); |
| timers[id] = window.setInterval(function() { |
| geolocation.getCurrentPosition(successCallback, errorCallback, options); |
| }, options.timeout); |
| |
| 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) { |
| window.clearInterval(timers[id]); |
| delete timers[id]; |
| } |
| } |
| }; |
| |
| module.exports = geolocation; |
| }); |
| |
| // 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'); |
| |
| var NetworkConnection = function () { |
| this.type = null; |
| this._firstRun = true; |
| this._timer = null; |
| this.timeout = 500; |
| |
| var me = this; |
| |
| channel.onCordovaReady.subscribeOnce(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 |
| me._timer = setTimeout(function(){ |
| cordova.fireDocumentEvent("offline"); |
| me._timer = null; |
| }, me.timeout); |
| } else { |
| // If there is a current offline event pending clear it |
| if (me._timer !== null) { |
| clearTimeout(me._timer); |
| me._timer = null; |
| } |
| cordova.fireDocumentEvent("online"); |
| } |
| |
| // should only fire this once |
| if (me._firstRun) { |
| me._firstRun = false; |
| channel.onCordovaConnectionReady.fire(); |
| } |
| }, |
| function (e) { |
| // If we can't get the network info we should still tell Cordova |
| // to fire the deviceready event. |
| if (me._firstRun) { |
| me._firstRun = false; |
| channel.onCordovaConnectionReady.fire(); |
| } |
| console.log("Error initializing Network Connection: " + e); |
| }); |
| }); |
| }; |
| |
| /** |
| * 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) { |
| // Get info |
| exec(successCallback, errorCallback, "NetworkStatus", "getConnectionInfo", []); |
| }; |
| |
| module.exports = new NetworkConnection(); |
| }); |
| |
| // file: lib/common/plugin/notification.js |
| define("cordova/plugin/notification", function(require, exports, module) { |
| var exec = require('cordova/exec'); |
| |
| /** |
| * 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 {String} buttonLabels Comma separated list of the labels of the buttons (default: 'OK,Cancel') |
| */ |
| confirm: function(message, resultCallback, title, buttonLabels) { |
| var _title = (title || "Confirm"); |
| var _buttonLabels = (buttonLabels || "OK,Cancel"); |
| exec(resultCallback, null, "Notification", "confirm", [message, _title, _buttonLabels]); |
| }, |
| |
| /** |
| * 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/playbook/plugin/playbook/device.js |
| define("cordova/plugin/playbook/device", function(require, exports, module) { |
| var me = {}, |
| exec = require('cordova/exec'), |
| channel = require('cordova/channel'); |
| |
| channel.onCordovaReady.subscribeOnce(function() { |
| exec(function (device) { |
| me.platform = device.platform; |
| me.version = device.version; |
| me.name = device.name; |
| me.uuid = device.uuid; |
| me.cordova = device.cordova; |
| |
| channel.onCordovaInfoReady.fire(); |
| }, |
| function (e) { |
| console.log("error initializing cordova: " + e); |
| }, |
| "Device", |
| "getDeviceInfo", |
| [] |
| ); |
| }); |
| |
| module.exports = me; |
| }); |
| |
| // file: lib/playbook/plugin/playbook/manager.js |
| define("cordova/plugin/playbook/manager", function(require, exports, module) { |
| var webworks = require('cordova/plugin/webworks/manager'), |
| cordova = require('cordova'), |
| MediaFile = require('cordova/plugin/MediaFile'), |
| /** |
| * Private list of HTML 5 audio objects, indexed by the Cordova media object ids |
| */ |
| audioObjects = {}, |
| retInvalidAction = function () { |
| return { "status" : cordova.callbackStatus.INVALID_ACTION, "message" : "Action not found" }; |
| }, |
| retAsyncCall = function () { |
| return { "status" : cordova.callbackStatus.NO_RESULT, "message" : "WebWorks Is On It" }; |
| }, |
| batteryAPI = { |
| execute: function (webWorksResult, action, args, win, fail) { |
| if (action === 'start') { |
| // Register one listener to each of level and state change |
| // events using WebWorks API. |
| blackberry.system.event.deviceBatteryStateChange(function(state) { |
| var me = navigator.battery; |
| // state is either CHARGING or UNPLUGGED |
| if (state === 2 || state === 3) { |
| var info = { |
| "level" : me._level, |
| "isPlugged" : state === 2 |
| }; |
| |
| if (me._isPlugged !== info.isPlugged && typeof win === 'function') { |
| win(info); |
| } |
| } |
| }); |
| blackberry.system.event.deviceBatteryLevelChange(function(level) { |
| var me = navigator.battery; |
| if (level != me._level && typeof win === 'function') { |
| win({'level' : level, 'isPlugged' : me._isPlugged}); |
| } |
| }); |
| } else if (action === 'stop') { |
| // Unregister battery listeners. |
| blackberry.system.event.deviceBatteryStateChange(null); |
| blackberry.system.event.deviceBatteryLevelChange(null); |
| } else { |
| return retInvalidAction(); |
| } |
| } |
| }, |
| cameraAPI = { |
| execute: function (webWorksResult, action, args, win, fail) { |
| if (action === 'takePicture') { |
| blackberry.media.camera.takePicture(win, fail, fail); |
| return retAsyncCall(); |
| } |
| else { |
| return retInvalidAction(); |
| } |
| } |
| }, |
| deviceAPI = { |
| execute: function (webWorksResult, action, args, win, fail) { |
| if (action === 'getDeviceInfo') { |
| return {"status" : cordova.callbackStatus.OK, |
| "message" : { |
| "version" : blackberry.system.softwareVersion, |
| "name" : blackberry.system.model, |
| "uuid" : blackberry.identity.PIN, |
| "platform" : "PlayBook", |
| "cordova" : "1.7.0rc1" |
| } |
| }; |
| } |
| return retInvalidAction(); |
| } |
| }, |
| loggerAPI = { |
| execute: function (webWorksResult, action, args, win, fail) { |
| if (action === 'log') { |
| console.log(args); |
| return {"status" : cordova.callbackStatus.OK, |
| "message" : 'Message logged to console: ' + args}; |
| } |
| else { |
| return retInvalidAction(); |
| } |
| } |
| }, |
| mediaAPI = { |
| execute: function (webWorksResult, action, args, win, fail) { |
| if (!args.length) { |
| return {"status" : 9, "message" : "Media Object id was not sent in arguments"}; |
| } |
| |
| var id = args[0], |
| audio = audioObjects[id], |
| result; |
| |
| switch (action) { |
| case 'startPlayingAudio': |
| if (args.length === 1) { |
| result = {"status" : 9, "message" : "Media source argument not found"}; |
| |
| } |
| |
| if (audio) { |
| audio.pause(); |
| audioObjects[id] = undefined; |
| } |
| |
| audio = audioObjects[id] = new Audio(args[1]); |
| audio.play(); |
| |
| result = {"status" : 1, "message" : "Audio play started" }; |
| break; |
| case 'stopPlayingAudio': |
| if (!audio) { |
| return {"status" : 2, "message" : "Audio Object has not been initialized"}; |
| } |
| |
| audio.pause(); |
| audioObjects[id] = undefined; |
| |
| result = {"status" : 1, "message" : "Audio play stopped" }; |
| break; |
| case 'seekToAudio': |
| if (!audio) { |
| result = {"status" : 2, "message" : "Audio Object has not been initialized"}; |
| } else if (args.length === 1) { |
| result = {"status" : 9, "message" : "Media seek time argument not found"}; |
| } else { |
| try { |
| audio.currentTime = args[1]; |
| } catch (e) { |
| console.log('Error seeking audio: ' + e); |
| return {"status" : 3, "message" : "Error seeking audio: " + e}; |
| } |
| |
| result = {"status" : 1, "message" : "Seek to audio succeeded" }; |
| } |
| break; |
| case 'pausePlayingAudio': |
| if (!audio) { |
| return {"status" : 2, "message" : "Audio Object has not been initialized"}; |
| } |
| |
| audio.pause(); |
| |
| result = {"status" : 1, "message" : "Audio paused" }; |
| break; |
| case 'getCurrentPositionAudio': |
| if (!audio) { |
| return {"status" : 2, "message" : "Audio Object has not been initialized"}; |
| } |
| |
| result = {"status" : 1, "message" : audio.currentTime }; |
| break; |
| case 'getDuration': |
| if (!audio) { |
| return {"status" : 2, "message" : "Audio Object has not been initialized"}; |
| } |
| |
| result = {"status" : 1, "message" : audio.duration }; |
| break; |
| case 'startRecordingAudio': |
| if (args.length <= 1) { |
| result = {"status" : 9, "message" : "Media start recording, insufficient arguments"}; |
| } |
| |
| blackberry.media.microphone.record(args[1], win, fail); |
| result = retAsyncCall(); |
| break; |
| case 'stopRecordingAudio': |
| break; |
| case 'release': |
| if (audio) { |
| audioObjects[id] = undefined; |
| audio.src = undefined; |
| //delete audio; |
| } |
| |
| result = {"status" : 1, "message" : "Media resources released"}; |
| break; |
| default: |
| result = retInvalidAction(); |
| } |
| |
| return result; |
| } |
| }, |
| mediaCaptureAPI = { |
| execute: function (webWorksResult, action, args, win, fail) { |
| var limit = args[0], |
| pictureFiles = [], |
| captureMethod; |
| |
| function captureCB(filePath) { |
| var mediaFile; |
| |
| if (filePath) { |
| mediaFile = new MediaFile(); |
| mediaFile.fullPath = filePath; |
| pictureFiles.push(mediaFile); |
| } |
| |
| if (limit > 0) { |
| limit--; |
| blackberry.media.camera[captureMethod](win, fail, fail); |
| return; |
| } |
| |
| win(pictureFiles); |
| |
| return retAsyncCall(); |
| } |
| |
| switch (action) { |
| case 'getSupportedAudioModes': |
| case 'getSupportedImageModes': |
| case 'getSupportedVideoModes': |
| return {"status": cordova.callbackStatus.OK, "message": []}; |
| case 'captureImage': |
| captureMethod = "takePicture"; |
| captureCB(); |
| break; |
| case 'captureVideo': |
| captureMethod = "takeVideo"; |
| captureCB(); |
| break; |
| case 'captureAudio': |
| return {"status": cordova.callbackStatus.INVALID_ACTION, "message": "captureAudio is not currently supported"}; |
| } |
| |
| return retAsyncCall(); |
| } |
| }, |
| networkAPI = { |
| execute: function (webWorksResult, action, args, win, fail) { |
| if (action !== 'getConnectionInfo') { |
| return retInvalidAction(); |
| } |
| |
| var connectionType = require("cordova/plugin/Connection").NONE, |
| eventType = "offline", |
| callbackID, |
| request; |
| |
| /** |
| * For PlayBooks, we currently only have WiFi connections, so |
| * return WiFi if there is any access at all. |
| * TODO: update if/when PlayBook gets other connection types... |
| */ |
| if (blackberry.system.hasDataCoverage()) { |
| connectionType = require("cordova/plugin/Connection").WIFI; |
| eventType = "online"; |
| } |
| |
| //Register an event handler for the networkChange event |
| callbackID = blackberry.events.registerEventHandler("networkChange", function (status) { |
| win(status.type); |
| }); |
| |
| //pass our callback id down to our network extension |
| request = new blackberry.transport.RemoteFunctionCall("org/apache/cordova/getConnectionInfo"); |
| request.addParam("networkStatusChangedID", callbackID); |
| request.makeSyncCall(); |
| |
| return { "status": cordova.callbackStatus.OK, "message": connectionType}; |
| } |
| }, |
| notificationAPI = { |
| execute: function (webWorksResult, action, args, win, fail) { |
| if (args.length !== 3) { |
| return {"status" : 9, "message" : "Notification action - " + action + " arguments not found"}; |
| |
| } |
| |
| //Unpack and map the args |
| var msg = args[0], |
| title = args[1], |
| btnLabel = args[2], |
| btnLabels; |
| |
| switch (action) { |
| case 'alert': |
| blackberry.ui.dialog.customAskAsync.apply(this, [ msg, [ btnLabel ], win, { "title" : title } ]); |
| return retAsyncCall(); |
| case 'confirm': |
| btnLabels = btnLabel.split(","); |
| blackberry.ui.dialog.customAskAsync.apply(this, [msg, btnLabels, win, {"title" : title} ]); |
| return retAsyncCall(); |
| } |
| return retInvalidAction(); |
| |
| } |
| }, |
| plugins = { |
| 'Battery' : batteryAPI, |
| 'Camera' : cameraAPI, |
| 'Device' : deviceAPI, |
| 'Logger' : loggerAPI, |
| 'Media' : mediaAPI, |
| 'Capture' : mediaCaptureAPI, |
| 'NetworkStatus' : networkAPI, |
| 'Notification' : notificationAPI |
| }; |
| |
| module.exports = { |
| exec: function (win, fail, clazz, action, args) { |
| var wwResult = webworks.exec(win, fail, clazz, action, args); |
| |
| //We got a sync result or a not found from WW that we can pass on to get a native mixin |
| //For async calls there's nothing to do |
| if ((wwResult.status === cordova.callbackStatus.OK || |
| wwResult.status === cordova.callbackStatus.CLASS_NOT_FOUND_EXCEPTION) && |
| plugins[clazz]) { |
| return plugins[clazz].execute(wwResult.message, action, args, win, fail); |
| } |
| |
| return wwResult; |
| }, |
| resume: function () {}, |
| pause: function () {}, |
| destroy: function () {} |
| }; |
| |
| }); |
| |
| // file: lib/common/plugin/requestFileSystem.js |
| define("cordova/plugin/requestFileSystem", function(require, exports, module) { |
| var 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) { |
| var fail = function(code) { |
| if (typeof errorCallback === 'function') { |
| 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 (typeof successCallback === 'function') { |
| // 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 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) { |
| // error callback |
| var fail = function(error) { |
| if (typeof errorCallback === 'function') { |
| errorCallback(new FileError(error)); |
| } |
| }; |
| // if successful, return either a file or directory entry |
| var success = function(entry) { |
| var result; |
| |
| if (entry) { |
| if (typeof successCallback === 'function') { |
| // create appropriate Entry object |
| result = (entry.isDirectory) ? new DirectoryEntry(entry.name, entry.fullPath) : new FileEntry(entry.name, entry.fullPath); |
| try { |
| successCallback(result); |
| } |
| catch (e) { |
| console.log('Error invoking callback: ' + e); |
| } |
| } |
| } |
| else { |
| // no Entry object returned |
| fail(FileError.NOT_FOUND_ERR); |
| } |
| }; |
| |
| exec(success, fail, "File", "resolveLocalFileSystemURI", [uri]); |
| }; |
| |
| }); |
| |
| // file: lib/webworks/plugin/webworks/manager.js |
| define("cordova/plugin/webworks/manager", function(require, exports, module) { |
| // Define JavaScript plugin implementations that are common across |
| // WebWorks platforms (phone/tablet). |
| var plugins = {}, |
| cordova = require('cordova'); |
| |
| module.exports = { |
| exec: function (win, fail, clazz, action, args) { |
| if (plugins[clazz]) { |
| return plugins[clazz].execute(action, args, win, fail); |
| } |
| |
| return {"status" : cordova.callbackStatus.CLASS_NOT_FOUND_EXCEPTION, "message" : "Class " + clazz + " cannot be found"}; |
| } |
| }; |
| }); |
| |
| // file: lib/common/utils.js |
| define("cordova/utils", function(require, exports, module) { |
| 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; |
| } |
| |
| var _self = { |
| /** |
| * Does a deep clone of the object. |
| */ |
| clone: function(obj) { |
| if(!obj) { |
| return obj; |
| } |
| |
| var retVal, i; |
| |
| if(obj instanceof Array){ |
| retVal = []; |
| for(i = 0; i < obj.length; ++i){ |
| retVal.push(_self.clone(obj[i])); |
| } |
| return retVal; |
| } |
| |
| if (obj instanceof Function) { |
| return obj; |
| } |
| |
| if(!(obj instanceof Object)){ |
| return obj; |
| } |
| |
| if(obj instanceof Date){ |
| return obj; |
| } |
| |
| retVal = {}; |
| for(i in obj){ |
| if(!(i in retVal) || retVal[i] != obj[i]) { |
| retVal[i] = _self.clone(obj[i]); |
| } |
| } |
| return retVal; |
| }, |
| |
| 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 |
| */ |
| 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. |
| */ |
| 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. |
| */ |
| alert:function(msg) { |
| if (alert) { |
| alert(msg); |
| } else if (console && console.log) { |
| console.log(msg); |
| } |
| } |
| }; |
| |
| module.exports = _self; |
| }); |
| |
| |
| window.cordova = require('cordova'); |
| |
| // file: lib/scripts/bootstrap.js |
| (function (context) { |
| var channel = require("cordova/channel"), |
| _self = { |
| boot: function () { |
| /** |
| * Create all cordova objects once page has fully loaded and native side is ready. |
| */ |
| channel.join(function() { |
| var builder = require('cordova/builder'), |
| base = require('cordova/common'), |
| platform = require('cordova/platform'); |
| |
| // Drop the common globals into the window object, but be nice and don't overwrite anything. |
| builder.build(base.objects).intoButDontClobber(window); |
| |
| // Drop the platform-specific globals into the window object |
| // and clobber any existing object. |
| builder.build(platform.objects).intoAndClobber(window); |
| |
| // Merge the platform-specific overrides/enhancements into |
| // the window object. |
| if (typeof platform.merges !== 'undefined') { |
| builder.build(platform.merges).intoAndMerge(window); |
| } |
| |
| // Call the platform-specific initialization |
| platform.initialize(); |
| |
| // Fire event to notify that all objects are created |
| channel.onCordovaReady.fire(); |
| |
| // Fire onDeviceReady event once all constructors have run and |
| // cordova info has been received from native side. |
| channel.join(function() { |
| channel.onDeviceReady.fire(); |
| }, channel.deviceReadyChannelsArray); |
| |
| }, [ channel.onDOMContentLoaded, channel.onNativeReady ]); |
| } |
| }; |
| |
| // boot up once native side is ready |
| channel.onNativeReady.subscribeOnce(_self.boot); |
| |
| // _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(); |
| } |
| |
| }(window)); |
| // file: lib/scripts/bootstrap-playbook.js |
| require('cordova/channel').onNativeReady.fire(); |
| |
| })(); |