You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@cordova.apache.org by pu...@apache.org on 2012/11/01 23:09:19 UTC
[44/58] [abbrv] Merge remote-tracking branch 'sgrebnov-wp7/master'
http://git-wip-us.apache.org/repos/asf/incubator-cordova-wp8/blob/8b958af0/templates/standalone/www/cordova-2.2.0.js
----------------------------------------------------------------------
diff --cc templates/standalone/www/cordova-2.2.0.js
index 0000000,0a39b5f..a63d217
mode 000000,100644..100644
--- a/templates/standalone/www/cordova-2.2.0.js
+++ b/templates/standalone/www/cordova-2.2.0.js
@@@ -1,0 -1,6352 +1,6125 @@@
-// commit 337b1f443491f3fdb816dc32f70e5378e0e1967c
++// commit 318c7ebf77718327d5ce5e2d87c5705bc00f332e
+
-// File generated at :: Mon Oct 15 2012 14:45:09 GMT-0700 (Pacific Daylight Time)
++// File generated at :: Sun Sep 30 2012 00:17:38 GMT+0400 (Russian Standard Time)
+
+ /*
+ 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 = {};
+ // Stack of moduleIds currently being built.
+ var requireStack = [];
+ // Map of module ID -> index into requireStack of modules currently being built.
+ var inProgressModules = {};
+
+ 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";
+ } else if (id in inProgressModules) {
+ var cycle = requireStack.slice(inProgressModules[id]).join('->') + '->' + id;
+ throw "Cycle in require graph: " + cycle;
+ }
+ if (modules[id].factory) {
+ try {
+ inProgressModules[id] = requireStack.length;
+ requireStack.push(id);
+ return build(modules[id]);
+ } finally {
+ delete inProgressModules[id];
+ requireStack.pop();
+ }
+ }
+ return modules[id].exports;
+ };
+
+ define = function (id, factory) {
+ if (modules[id]) {
+ throw "module " + id + " already defined";
+ }
+
+ modules[id] = {
+ id: id,
+ factory: factory
+ };
+ };
+
+ define.remove = function (id) {
+ delete modules[id];
+ };
+
+ })();
+
+ //Export for use in node
+ if (typeof module === "object" && typeof require === "function") {
+ module.exports.require = require;
+ module.exports.define = define;
+ }
+
+ // file: lib/cordova.js
+ define("cordova", function(require, exports, module) {
+
+
+ var channel = require('cordova/channel');
+
+ /**
+ * Listen for DOMContentLoaded and notify our channel subscribers.
+ */
+ document.addEventListener('DOMContentLoaded', function() {
+ channel.onDOMContentLoaded.fire();
+ }, false);
+ if (document.readyState == 'complete' || document.readyState == 'interactive') {
+ channel.onDOMContentLoaded.fire();
+ }
+
+ /**
+ * Intercept calls to addEventListener + removeEventListener and handle deviceready,
+ * resume, and pause events.
+ */
+ var m_document_addEventListener = document.addEventListener;
+ var m_document_removeEventListener = document.removeEventListener;
+ var m_window_addEventListener = window.addEventListener;
+ var m_window_removeEventListener = window.removeEventListener;
+
+ /**
+ * Houses custom event handlers to intercept on document + window event listeners.
+ */
+ var documentEventHandlers = {},
+ windowEventHandlers = {};
+
+ document.addEventListener = function(evt, handler, capture) {
+ var e = evt.toLowerCase();
+ if (typeof documentEventHandlers[e] != 'undefined') {
+ documentEventHandlers[e].subscribe(handler);
+ } else {
+ m_document_addEventListener.call(document, evt, handler, capture);
+ }
+ };
+
+ window.addEventListener = function(evt, handler, capture) {
+ var e = evt.toLowerCase();
+ if (typeof windowEventHandlers[e] != 'undefined') {
+ windowEventHandlers[e].subscribe(handler);
+ } else {
+ m_window_addEventListener.call(window, evt, handler, capture);
+ }
+ };
+
+ document.removeEventListener = function(evt, handler, capture) {
+ var e = evt.toLowerCase();
+ // If unsubscribing from an event that is handled by a plugin
+ if (typeof documentEventHandlers[e] != "undefined") {
+ documentEventHandlers[e].unsubscribe(handler);
+ } else {
+ m_document_removeEventListener.call(document, evt, handler, capture);
+ }
+ };
+
+ window.removeEventListener = function(evt, handler, capture) {
+ var e = evt.toLowerCase();
+ // If unsubscribing from an event that is handled by a plugin
+ if (typeof windowEventHandlers[e] != "undefined") {
+ windowEventHandlers[e].unsubscribe(handler);
+ } else {
+ m_window_removeEventListener.call(window, evt, handler, capture);
+ }
+ };
+
+ function createEvent(type, data) {
+ var event = document.createEvent('Events');
+ event.initEvent(type, false, false);
+ if (data) {
+ for (var i in data) {
+ if (data.hasOwnProperty(i)) {
+ event[i] = data[i];
+ }
+ }
+ }
+ return event;
+ }
+
+ if(typeof window.console === "undefined") {
+ window.console = {
+ log:function(){}
+ };
+ }
+
+ var cordova = {
+ define:define,
+ require:require,
+ /**
+ * Methods to add/remove your own addEventListener hijacking on document + window.
+ */
+ addWindowEventHandler:function(event) {
+ return (windowEventHandlers[event] = channel.create(event));
+ },
+ addStickyDocumentEventHandler:function(event) {
+ return (documentEventHandlers[event] = channel.createSticky(event));
+ },
+ addDocumentEventHandler:function(event) {
+ return (documentEventHandlers[event] = channel.create(event));
+ },
+ removeWindowEventHandler:function(event) {
+ delete windowEventHandlers[event];
+ },
+ removeDocumentEventHandler:function(event) {
+ delete documentEventHandlers[event];
+ },
+ /**
+ * Retrieve original event handlers that were replaced by Cordova
+ *
+ * @return object
+ */
+ getOriginalHandlers: function() {
+ return {'document': {'addEventListener': m_document_addEventListener, 'removeEventListener': m_document_removeEventListener},
+ 'window': {'addEventListener': m_window_addEventListener, 'removeEventListener': m_window_removeEventListener}};
+ },
+ /**
+ * Method to fire event from native code
- * bNoDetach is required for events which cause an exception which needs to be caught in native code
++ * bNoDetach is required for events which cause an exception which needs to be caught in native code
+ */
+ fireDocumentEvent: function(type, data, bNoDetach) {
+ var evt = createEvent(type, data);
+ if (typeof documentEventHandlers[type] != 'undefined') {
+ if( bNoDetach ) {
+ documentEventHandlers[type].fire(evt);
+ }
+ else {
+ setTimeout(function() {
+ documentEventHandlers[type].fire(evt);
+ }, 0);
+ }
+ } else {
+ document.dispatchEvent(evt);
+ }
+ },
+ fireWindowEvent: function(type, data) {
+ var evt = createEvent(type,data);
+ if (typeof windowEventHandlers[type] != 'undefined') {
+ setTimeout(function() {
+ windowEventHandlers[type].fire(evt);
+ }, 0);
+ } else {
+ window.dispatchEvent(evt);
+ }
+ },
+
++ // 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.
+ */
+ // Randomize the starting callbackId to avoid collisions after refreshing or navigating.
+ // This way, it's very unlikely that any new callback would get the same callbackId as an old callback.
+ callbackId: Math.floor(Math.random() * 2000000000),
+ callbacks: {},
+ callbackStatus: {
+ NO_RESULT: 0,
+ OK: 1,
+ CLASS_NOT_FOUND_EXCEPTION: 2,
+ ILLEGAL_ACCESS_EXCEPTION: 3,
+ INSTANTIATION_EXCEPTION: 4,
+ MALFORMED_URL_EXCEPTION: 5,
+ IO_EXCEPTION: 6,
+ INVALID_ACTION: 7,
+ JSON_EXCEPTION: 8,
+ ERROR: 9
+ },
+
+ /**
+ * Called by native code when returning successful result from an action.
+ */
+ callbackSuccess: function(callbackId, args) {
+ try {
+ cordova.callbackFromNative(callbackId, true, args.status, args.message, args.keepCallback);
+ } catch (e) {
+ console.log("Error in error callback: " + callbackId + " = "+e);
+ }
+ },
+
+ /**
+ * Called by native code when returning error result from an action.
+ */
+ callbackError: function(callbackId, args) {
+ // TODO: Deprecate callbackSuccess and callbackError in favour of callbackFromNative.
+ // Derive success from status.
+ try {
+ cordova.callbackFromNative(callbackId, false, args.status, args.message, args.keepCallback);
+ } catch (e) {
+ console.log("Error in error callback: " + callbackId + " = "+e);
+ }
+ },
+
+ /**
+ * Called by native code when returning the result from an action.
+ */
+ callbackFromNative: function(callbackId, success, status, message, keepCallback) {
+ var callback = cordova.callbacks[callbackId];
+ if (callback) {
+ if (success && status == cordova.callbackStatus.OK) {
+ callback.success && callback.success(message);
+ } else if (!success) {
+ callback.fail && callback.fail(message);
+ }
+
+ // Clear callback if not expecting any more results
+ if (!keepCallback) {
+ delete cordova.callbacks[callbackId];
+ }
+ }
+ },
+ addConstructor: function(func) {
+ channel.onCordovaReady.subscribe(function() {
+ try {
+ func();
+ } catch(e) {
+ console.log("Failed to run constructor: " + e);
+ }
+ });
+ }
+ };
+
+ // Register pause, resume and deviceready channels as events on document.
+ channel.onPause = cordova.addDocumentEventHandler('pause');
+ channel.onResume = cordova.addDocumentEventHandler('resume');
+ channel.onDeviceReady = cordova.addStickyDocumentEventHandler('deviceready');
+
+ module.exports = cordova;
+
+ });
+
+ // file: lib\common\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 assignOrWrapInDeprecateGetter(obj, key, value, message) {
+ if (message) {
+ utils.defineGetter(obj, key, function() {
+ window.console && console.log(message);
+ return value;
+ });
+ } else {
+ obj[key] = value;
+ }
+ }
+
+ function include(parent, objects, clobber, merge) {
+ each(objects, function (obj, key) {
+ try {
+ var result = obj.path ? require(obj.path) : {};
+
+ if (clobber) {
+ // Clobber if it doesn't exist.
+ if (typeof parent[key] === 'undefined') {
+ assignOrWrapInDeprecateGetter(parent, key, result, obj.deprecated);
+ } else if (typeof obj.path !== 'undefined') {
+ // If merging, merge properties onto parent, otherwise, clobber.
+ if (merge) {
+ recursiveMerge(parent[key], result);
+ } else {
+ assignOrWrapInDeprecateGetter(parent, key, result, obj.deprecated);
+ }
+ }
+ result = parent[key];
+ } else {
+ // Overwrite if not currently defined.
+ if (typeof parent[key] == 'undefined') {
+ assignOrWrapInDeprecateGetter(parent, key, result, obj.deprecated);
+ } else 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 {
+ intoButDoNotClobber: 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) {
+
+ var utils = require('cordova/utils'),
+ nextGuid = 1;
+
+ /**
+ * Custom pub-sub "channel" that can have functions subscribed to it
+ * This object is used to define and control firing of events for
+ * cordova initialization, as well as for custom events thereafter.
+ *
+ * The order of events during page load and Cordova startup is as follows:
+ *
+ * onDOMContentLoaded* Internal event that is received when the web page is loaded and parsed.
+ * onNativeReady* Internal event that indicates the Cordova native side is ready.
+ * onCordovaReady* Internal event fired when all Cordova JavaScript objects have been created.
+ * onCordovaInfoReady* Internal event fired when device properties are available.
+ * onCordovaConnectionReady* Internal event fired when the connection property has been set.
+ * onDeviceReady* User event fired to indicate that Cordova is ready
+ * onResume User event fired to indicate a start/resume lifecycle event
+ * onPause User event fired to indicate a pause lifecycle event
+ * onDestroy* Internal event fired when app is being destroyed (User should use window.onunload event, not this one).
+ *
+ * The events marked with an * are sticky. Once they have fired, they will stay in the fired state.
+ * All listeners that subscribe after the event is fired will be executed right away.
+ *
+ * The only Cordova events that user code should register for are:
+ * deviceready Cordova native code is initialized and Cordova APIs can be called from JavaScript
+ * pause App has moved to background
+ * resume App has returned to foreground
+ *
+ * Listeners can be registered as:
+ * document.addEventListener("deviceready", myDeviceReadyListener, false);
+ * document.addEventListener("resume", myResumeListener, false);
+ * document.addEventListener("pause", myPauseListener, false);
+ *
+ * The DOM lifecycle events should be used for saving and restoring state
+ * window.onload
+ * window.onunload
+ *
+ */
+
+ /**
+ * Channel
+ * @constructor
+ * @param type String the channel name
+ */
+ var Channel = function(type, sticky) {
+ this.type = type;
+ // Map of guid -> function.
+ this.handlers = {};
+ // 0 = Non-sticky, 1 = Sticky non-fired, 2 = Sticky fired.
+ this.state = sticky ? 1 : 0;
+ // Used in sticky mode to remember args passed to fire().
+ this.fireArgs = null;
+ // Used by onHasSubscribersChange to know if there are any listeners.
+ this.numHandlers = 0;
+ // Function that is called when the first listener is subscribed, or when
+ // the last listener is unsubscribed.
+ this.onHasSubscribersChange = null;
+ },
+ channel = {
+ /**
+ * Calls the provided function only after all of the channels specified
+ * have been fired. All channels must be sticky channels.
+ */
+ join: function(h, c) {
+ var len = c.length,
+ i = len,
+ f = function() {
+ if (!(--i)) h();
+ };
+ for (var j=0; j<len; j++) {
- if (c[j].state === 0) {
- throw Error('Can only use join with sticky channels.');
++ if (c[j].state == 0) {
++ throw Error('Can only use join with sticky channels.')
+ }
+ c[j].subscribe(f);
+ }
+ if (!len) h();
+ },
+ create: function(type) {
+ return channel[type] = new Channel(type, false);
+ },
+ createSticky: function(type) {
+ return channel[type] = new Channel(type, true);
+ },
+
+ /**
+ * cordova Channels that must fire before "deviceready" is fired.
+ */
+ deviceReadyChannelsArray: [],
+ deviceReadyChannelsMap: {},
+
+ /**
+ * Indicate that a feature needs to be initialized before it is ready to be used.
+ * This holds up Cordova's "deviceready" event until the feature has been initialized
+ * and Cordova.initComplete(feature) is called.
+ *
+ * @param feature {String} The unique feature name
+ */
+ waitForInitialization: function(feature) {
+ if (feature) {
+ var c = channel[feature] || this.createSticky(feature);
+ this.deviceReadyChannelsMap[feature] = c;
+ this.deviceReadyChannelsArray.push(c);
+ }
+ },
+
+ /**
+ * Indicate that initialization code has completed and the feature is ready to be used.
+ *
+ * @param feature {String} The unique feature name
+ */
+ initializationComplete: function(feature) {
+ var c = this.deviceReadyChannelsMap[feature];
+ if (c) {
+ c.fire();
+ }
+ }
+ };
+
+ function forceFunction(f) {
+ if (typeof f != 'function') throw "Function required as first argument!";
+ }
+
+ /**
+ * Subscribes the given function to the channel. Any time that
+ * Channel.fire is called so too will the function.
+ * Optionally specify an execution context for the function
+ * and a guid that can be used to stop subscribing to the channel.
+ * Returns the guid.
+ */
+ Channel.prototype.subscribe = function(f, c) {
+ // need a function to call
+ forceFunction(f);
+ if (this.state == 2) {
+ f.apply(c || this, this.fireArgs);
+ return;
+ }
+
+ var func = f,
+ guid = f.observer_guid;
+ if (typeof c == "object") { func = utils.close(c, f); }
+
+ if (!guid) {
+ // first time any channel has seen this subscriber
+ guid = '' + nextGuid++;
+ }
+ func.observer_guid = guid;
+ f.observer_guid = guid;
+
+ // Don't add the same handler more than once.
+ if (!this.handlers[guid]) {
+ this.handlers[guid] = func;
+ this.numHandlers++;
+ if (this.numHandlers == 1) {
+ this.onHasSubscribersChange && this.onHasSubscribersChange();
+ }
+ }
+ };
+
+ /**
+ * Unsubscribes the function with the given guid from the channel.
+ */
+ Channel.prototype.unsubscribe = function(f) {
+ // need a function to unsubscribe
+ forceFunction(f);
+
+ var guid = f.observer_guid,
+ handler = this.handlers[guid];
+ if (handler) {
+ delete this.handlers[guid];
+ this.numHandlers--;
- if (this.numHandlers === 0) {
++ if (this.numHandlers == 0) {
+ this.onHasSubscribersChange && this.onHasSubscribersChange();
+ }
+ }
+ };
+
+ /**
+ * Calls all functions subscribed to this channel.
+ */
+ Channel.prototype.fire = function(e) {
+ var fail = false,
+ fireArgs = Array.prototype.slice.call(arguments);
+ // Apply stickiness.
+ if (this.state == 1) {
+ this.state = 2;
+ this.fireArgs = fireArgs;
+ }
+ if (this.numHandlers) {
+ // Copy the values first so that it is safe to modify it from within
+ // callbacks.
+ var toCall = [];
+ for (var item in this.handlers) {
+ toCall.push(this.handlers[item]);
+ }
+ for (var i = 0; i < toCall.length; ++i) {
+ toCall[i].apply(this, fireArgs);
+ }
+ if (this.state == 2 && this.numHandlers) {
+ this.numHandlers = 0;
+ this.handlers = {};
+ this.onHasSubscribersChange && this.onHasSubscribersChange();
+ }
+ }
+ };
+
+
+ // defining them here so they are ready super fast!
+ // DOM event that is received when the web page is loaded and parsed.
+ channel.createSticky('onDOMContentLoaded');
+
+ // Event to indicate the Cordova native side is ready.
+ channel.createSticky('onNativeReady');
+
+ // Event to indicate that all Cordova JavaScript objects have been created
+ // and it's time to run plugin constructors.
+ channel.createSticky('onCordovaReady');
+
+ // Event to indicate that device properties are available
+ channel.createSticky('onCordovaInfoReady');
+
+ // Event to indicate that the connection property has been set.
+ channel.createSticky('onCordovaConnectionReady');
+
+ // Event to indicate that Cordova is ready
+ channel.createSticky('onDeviceReady');
+
+ // Event to indicate a resume lifecycle event
+ channel.create('onResume');
+
+ // Event to indicate a pause lifecycle event
+ channel.create('onPause');
+
+ // Event to indicate a destroy lifecycle event
+ channel.createSticky('onDestroy');
+
+ // Channels that must fire before "deviceready" is fired.
+ channel.waitForInitialization('onCordovaReady');
+ channel.waitForInitialization('onCordovaConnectionReady');
+
+ module.exports = channel;
+
+ });
+
-// file: lib\common\commandProxy.js
-define("cordova/commandProxy", function(require, exports, module) {
-
-
-// internal map of proxy function
-var CommandProxyMap = {};
-
-module.exports = {
-
- // example: cordova.commandProxy.add("Accelerometer",{getCurrentAcceleration: function(successCallback, errorCallback, options) {...},...);
- add:function(id,proxyObj) {
- console.log("adding proxy for " + id);
- CommandProxyMap[id] = proxyObj;
- return proxyObj;
- },
-
- // cordova.commandProxy.remove("Accelerometer");
- remove:function(id) {
- var proxy = CommandProxyMap[id];
- delete CommandProxyMap[id];
- CommandProxyMap[id] = null;
- return proxy;
- },
-
- get:function(service,action) {
- return ( CommandProxyMap[service] ? CommandProxyMap[service][action] : null );
- }
-};
-
-});
-
+ // file: lib\common\common.js
+ define("cordova/common", function(require, exports, module) {
+
+ module.exports = {
+ objects: {
+ cordova: {
+ path: 'cordova',
+ children: {
+ exec: {
+ path: 'cordova/exec'
+ },
+ logger: {
+ path: 'cordova/plugin/logger'
+ }
+ }
+ },
+ 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'
+ },
+ connection: {
+ path: 'cordova/plugin/network'
+ },
+ contacts: {
+ path: 'cordova/plugin/contacts'
+ },
+ device:{
+ children:{
+ capture: {
+ path: 'cordova/plugin/capture'
+ }
+ }
+ },
+ geolocation: {
+ path: 'cordova/plugin/geolocation'
+ },
+ globalization: {
+ path: 'cordova/plugin/globalization'
+ },
+ network: {
+ children: {
+ connection: {
+ path: 'cordova/plugin/network',
+ deprecated: 'navigator.network.connection is deprecated. Use navigator.connection instead.'
+ }
+ }
+ },
+ splashscreen: {
+ path: 'cordova/plugin/splashscreen'
+ }
+ }
+ },
+ Acceleration: {
+ path: 'cordova/plugin/Acceleration'
+ },
+ Camera:{
+ path: 'cordova/plugin/CameraConstants'
+ },
+ CameraPopoverOptions: {
+ path: 'cordova/plugin/CameraPopoverOptions'
+ },
+ 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'
+ },
+ device: {
+ path: 'cordova/plugin/device'
+ },
+ 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'
+ },
+ GlobalizationError: {
+ path: 'cordova/plugin/GlobalizationError'
+ },
+ 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\wp7\exec.js
++// file: lib\wp8\exec.js
+ define("cordova/exec", function(require, exports, module) {
-
+ var cordova = require('cordova');
+
+ /**
+ * Execute a cordova command. It is up to the native side whether this action
+ * is synchronous or asynchronous. The native side can return:
+ * Synchronous: PluginResult object as a JSON string
+ * Asynchronous: Empty string ""
+ * If async, the native side will cordova.callbackSuccess or cordova.callbackError,
+ * depending upon the result of the action.
+ *
+ * @param {Function} success The success callback
+ * @param {Function} fail The fail callback
+ * @param {String} service The name of the service to use
+ * @param {String} action Action to be run in cordova
+ * @param {String[]} [args] Zero or more arguments to pass to the method
+
+ */
+
+ module.exports = function(success, fail, service, action, args) {
+
+ var callbackId = service + cordova.callbackId++;
+ if (typeof success == "function" || typeof fail == "function") {
+ cordova.callbacks[callbackId] = {success:success, fail:fail};
+ }
+ // generate a new command string, ex. DebugConsole/log/DebugConsole23/["wtf dude?"]
+ for(var n = 0; n < args.length; n++)
+ {
+ if(typeof args[n] !== "string")
+ {
+ args[n] = JSON.stringify(args[n]);
+ }
+ }
+ var command = service + "/" + action + "/" + callbackId + "/" + JSON.stringify(args);
+ // pass it on to Notify
+ try {
+ if(window.external) {
+ window.external.Notify(command);
+ }
+ else {
+ console.log("window.external not available :: command=" + command);
+ }
+ }
+ catch(e) {
+ console.log("Exception calling native with command :: " + command + " :: exception=" + e);
+ }
+ };
+
+
+ });
+
-// file: lib\wp7\platform.js
++// file: lib\wp8\platform.js
+ define("cordova/platform", function(require, exports, module) {
-
+ var cordova = require('cordova'),
+ exec = require('cordova/exec');
+
+ // specifically require the following patches :
+
-// localStorage+SessionStorage APIs
-require("cordova/plugin/wp7/DOMStorage");
+
+ // Fix XHR calls to local file-system
-require("cordova/plugin/wp7/XHRPatch");
++require("cordova/plugin/wp/XHRPatch");
+
+
+ module.exports = {
- id: "wp7",
++ id: "wp8",
+ initialize:function() {
+ window.alert = require("cordova/plugin/notification").alert;
++ window.FileReader = require("cordova/plugin/FileReader");
+
+ // Inject a listener for the backbutton, and tell native to override the flag (true/false) when we have 1 or more, or 0, listeners
- var backButtonChannel = cordova.addDocumentEventHandler('backbutton');
- backButtonChannel.onHasSubscribersChange = function() {
- exec(null, null, "CoreEvents", "overridebackbutton", [this.numHandlers == 1]);
- };
++ var backButtonChannel = cordova.addDocumentEventHandler('backbutton', {
++ onSubscribe:function() {
++ if (this.numHandlers === 1) {
++ exec(null, null, "CoreEvents", "overridebackbutton", [true]);
++ }
++ },
++ onUnsubscribe:function() {
++ if (this.numHandlers === 0) {
++ exec(null, null, "CoreEvents", "overridebackbutton", [false]);
++ }
++ }
++
++ });
+ },
+ objects: {
+ CordovaCommandResult: {
- path:"cordova/plugin/wp7/CordovaCommandResult"
++ path:"cordova/plugin/wp/CordovaCommandResult"
+ },
+ CordovaMediaonStatus: {
- path:"cordova/plugin/wp7/CordovaMediaonStatus"
++ path:"cordova/plugin/wp/CordovaMediaonStatus"
+ },
+ navigator: {
+ children: {
+ device: {
+ children:{
+ capture:{
+ path:"cordova/plugin/capture"
+ }
+ }
+ },
+ console: {
- path: "cordova/plugin/wp7/console"
++ path: "cordova/plugin/wp/console"
+
+ }
+ }
+ },
+ console:{
- path: "cordova/plugin/wp7/console"
++ path: "cordova/plugin/wp/console"
+ },
+ FileTransfer: {
- path: 'cordova/plugin/wp7/FileTransfer'
++ path: 'cordova/plugin/wp/FileTransfer'
+ }
++
+ }
+ };
+
+ });
+
+ // 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_URI.
+ *
+ * @param {Function} successCallback
+ * @param {Function} errorCallback
+ * @param {Object} options
+ */
+ cameraExport.getPicture = function(successCallback, errorCallback, options) {
+ options = 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 (typeof options.quality == "number") {
+ quality = options.quality;
+ } else if (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;
+ }
+ var popoverOptions = null;
+ if (typeof options.popoverOptions == "object") {
+ popoverOptions = options.popoverOptions;
+ }
+
+ var args = [quality, destinationType, sourceType, targetWidth, targetHeight, encodingType,
+ mediaType, allowEdit, correctOrientation, saveToPhotoAlbum, popoverOptions];
+
+ exec(successCallback, errorCallback, "Camera", "takePicture", args);
+ };
+
+ cameraExport.cleanup = function(successCallback, errorCallback) {
+ exec(successCallback, errorCallback, "Camera", "cleanup", []);
+ };
+
+ module.exports = cameraExport;
+
+ });
+
+ // file: lib\common\plugin\CameraConstants.js
+ define("cordova/plugin/CameraConstants", function(require, exports, module) {
+
+ module.exports = {
+ DestinationType:{
+ DATA_URL: 0, // Return base64 encoded string
+ FILE_URI: 1 // Return file uri (content://media/external/images/media/2 for Android)
+ },
+ EncodingType:{
+ JPEG: 0, // Return JPEG encoded image
+ PNG: 1 // Return PNG encoded image
+ },
+ MediaType:{
+ PICTURE: 0, // allow selection of still pictures only. DEFAULT. Will return format specified via DestinationType
+ VIDEO: 1, // allow selection of video only, ONLY RETURNS URL
+ ALLMEDIA : 2 // allow selection from all media types
+ },
+ PictureSourceType:{
+ PHOTOLIBRARY : 0, // Choose image from picture library (same as SAVEDPHOTOALBUM for Android)
+ CAMERA : 1, // Take picture from camera
+ SAVEDPHOTOALBUM : 2 // Choose image from picture library (same as PHOTOLIBRARY for Android)
+ },
+ PopoverArrowDirection:{
+ ARROW_UP : 1, // matches iOS UIPopoverArrowDirection constants to specify arrow location on popover
+ ARROW_DOWN : 2,
+ ARROW_LEFT : 4,
+ ARROW_RIGHT : 8,
+ ARROW_ANY : 15
+ }
+ };
+
+ });
+
+ // file: lib\common\plugin\CameraPopoverOptions.js
+ define("cordova/plugin/CameraPopoverOptions", function(require, exports, module) {
+
+ var Camera = require('cordova/plugin/CameraConstants');
+
+ /**
+ * Encapsulates options for iOS Popover image picker
+ */
+ var CameraPopoverOptions = function(x,y,width,height,arrowDir){
+ // information of rectangle that popover should be anchored to
+ this.x = x || 0;
+ this.y = y || 32;
+ this.width = width || 320;
+ this.height = height || 480;
+ // The direction of the popover arrow
+ this.arrowDir = arrowDir || Camera.PopoverArrowDirection.ARROW_ANY;
+ };
+
+ module.exports = CameraPopoverOptions;
+
+ });
+
+ // file: lib\common\plugin\CaptureAudioOptions.js
+ define("cordova/plugin/CaptureAudioOptions", function(require, exports, module) {
+
+ /**
+ * Encapsulates all audio capture operation configuration options.
+ */
+ var CaptureAudioOptions = function(){
+ // Upper limit of sound clips user can record. Value must be equal or greater than 1.
+ this.limit = 1;
+ // Maximum duration of a single sound clip in seconds.
+ this.duration = 0;
+ // 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 occurred
+ * @constructor
+ */
+ var CompassError = function(err) {
+ this.code = (err !== undefined ? err : null);
+ };
+
+ CompassError.COMPASS_INTERNAL_ERR = 0;
+ CompassError.COMPASS_NOT_SUPPORTED = 20;
+
+ module.exports = CompassError;
+
+ });
+
+ // file: lib\common\plugin\CompassHeading.js
+ define("cordova/plugin/CompassHeading", function(require, exports, module) {
+
+ var CompassHeading = function(magneticHeading, trueHeading, headingAccuracy, timestamp) {
+ this.magneticHeading = (magneticHeading !== 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 (!utils.isDate(value)){
+ try {
+ value = new Date(value);
+ } catch(exception){
+ value = null;
+ }
+ }
+ if (utils.isDate(value)){
+ value = value.valueOf(); // convert to milliseconds
+ }
+ contact.birthday = value;
+ }
+ return contact;
+ }
+
+ /**
+ * Contains information about a single contact.
+ * @constructor
+ * @param {DOMString} id unique identifier
+ * @param {DOMString} displayName
+ * @param {ContactName} name
+ * @param {DOMString} nickname
+ * @param {Array.<ContactField>} phoneNumbers array of phone numbers
+ * @param {Array.<ContactField>} emails array of email addresses
+ * @param {Array.<ContactAddress>} addresses array of addresses
+ * @param {Array.<ContactField>} ims instant messaging user ids
+ * @param {Array.<ContactOrganization>} organizations
+ * @param {DOMString} birthday contact's birthday
+ * @param {DOMString} note user notes about contact
+ * @param {Array.<ContactField>} photos
+ * @param {Array.<ContactField>} categories
+ * @param {Array.<ContactField>} urls contact's web sites
+ */
+ var Contact = function (id, displayName, name, nickname, phoneNumbers, emails, addresses,
+ ims, organizations, birthday, note, photos, categories, urls) {
+ this.id = id || null;
+ this.rawId = null;
+ this.displayName = displayName || null;
+ this.name = name || null; // ContactName
+ this.nickname = nickname || null;
+ this.phoneNumbers = phoneNumbers || null; // ContactField[]
+ this.emails = emails || null; // ContactField[]
+ this.addresses = addresses || null; // ContactAddress[]
+ this.ims = ims || null; // ContactField[]
+ this.organizations = organizations || null; // ContactOrganization[]
+ this.birthday = birthday || null;
+ this.note = note || null;
+ this.photos = photos || null; // ContactField[]
+ this.categories = categories || null; // ContactField[]
+ this.urls = urls || null; // ContactField[]
+ };
+
+ /**
+ * Removes contact from device storage.
+ * @param successCB success callback
+ * @param errorCB error callback
+ */
+ Contact.prototype.remove = function(successCB, errorCB) {
+ 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 occurred
+ * @constructor
+ */
+ var ContactError = function(err) {
+ this.code = (typeof err != 'undefined' ? err : null);
+ };
+
+ /**
+ * Error codes
+ */
+ ContactError.UNKNOWN_ERROR = 0;
+ ContactError.INVALID_ARGUMENT_ERROR = 1;
+ ContactError.TIMEOUT_ERROR = 2;
+ ContactError.PENDING_OPERATION_ERROR = 3;
+ ContactError.IO_ERROR = 4;
+ ContactError.NOT_SUPPORTED_ERROR = 5;
+ ContactError.PERMISSION_DENIED_ERROR = 20;
+
+ module.exports = ContactError;
+
+ });
+
+ // file: lib\common\plugin\ContactField.js
+ define("cordova/plugin/ContactField", function(require, exports, module) {
+
+ /**
+ * Generic contact field.
+ * @constructor
+ * @param {DOMString} id unique identifier, should only be set by native code // NOTE: not a W3C standard
+ * @param type
+ * @param value
+ * @param pref
+ */
+ var ContactField = function(type, value, pref) {
+ this.id = null;
+ this.type = (type && type.toString()) || null;
+ this.value = (value && value.toString()) || null;
+ this.pref = (typeof pref != 'undefined' ? pref : false);
+ };
+
+ module.exports = ContactField;
+
+ });
+
+ // file: lib\common\plugin\ContactFindOptions.js
+ define("cordova/plugin/ContactFindOptions", function(require, exports, module) {
+
+ /**
+ * ContactFindOptions.
+ * @constructor
+ * @param filter used to match contacts against
+ * @param multiple boolean used to determine if more than one contact should be returned
+ */
+
+ var ContactFindOptions = function(filter, multiple) {
+ this.filter = filter || '';
+ this.multiple = (typeof multiple != 'undefined' ? multiple : false);
+ };
+
+ module.exports = ContactFindOptions;
+
+ });
+
+ // file: lib\common\plugin\ContactName.js
+ define("cordova/plugin/ContactName", function(require, exports, module) {
+
+ /**
+ * Contact name.
+ * @constructor
+ * @param formatted // NOTE: not part of W3C standard
+ * @param familyName
+ * @param givenName
+ * @param middle
+ * @param prefix
+ * @param suffix
+ */
+ var ContactName = function(formatted, familyName, givenName, middle, prefix, suffix) {
+ this.formatted = formatted || null;
+ this.familyName = familyName || null;
+ this.givenName = givenName || null;
+ this.middleName = middle || null;
+ this.honorificPrefix = prefix || null;
+ this.honorificSuffix = suffix || null;
+ };
+
+ module.exports = ContactName;
+
+ });
+
+ // file: lib\common\plugin\ContactOrganization.js
+ define("cordova/plugin/ContactOrganization", function(require, exports, module) {
+
+ /**
+ * Contact organization.
+ * @constructor
+ * @param {DOMString} id unique identifier, should only be set by native code // NOTE: not a W3C standard
+ * @param name
+ * @param dept
+ * @param title
+ * @param startDate
+ * @param endDate
+ * @param location
+ * @param desc
+ */
+
+ var ContactOrganization = function(pref, type, name, dept, title) {
+ this.id = null;
+ this.pref = (typeof pref != 'undefined' ? pref : false);
+ this.type = type || null;
+ this.name = name || null;
+ this.department = dept || null;
+ this.title = title || null;
+ };
+
+ module.exports = ContactOrganization;
+
+ });
+
+ // file: lib\common\plugin\Coordinates.js
+ define("cordova/plugin/Coordinates", function(require, exports, module) {
+
+ /**
+ * This class contains position information.
+ * @param {Object} lat
+ * @param {Object} lng
+ * @param {Object} alt
+ * @param {Object} acc
+ * @param {Object} head
+ * @param {Object} vel
+ * @param {Object} altacc
+ * @constructor
+ */
+ var Coordinates = function(lat, lng, alt, acc, head, vel, altacc) {
+ /**
+ * The latitude of the position.
+ */
+ this.latitude = lat;
+ /**
+ * The longitude of the position,
+ */
+ this.longitude = lng;
+ /**
+ * The accuracy of the position.
+ */
+ this.accuracy = acc;
+ /**
+ * The altitude of the position.
+ */
+ this.altitude = (alt !== undefined ? alt : null);
+ /**
+ * The direction the device is moving at the position.
+ */
+ this.heading = (head !== undefined ? head : null);
+ /**
+ * The velocity with which the device is moving at the position.
+ */
+ this.speed = (vel !== undefined ? vel : null);
+
+ if (this.speed === 0 || this.speed === null) {
+ this.heading = NaN;
+ }
+
+ /**
+ * The altitude accuracy of the position.
+ */
+ this.altitudeAccuracy = (altacc !== undefined) ? altacc : null;
+ };
+
+ module.exports = Coordinates;
+
+ });
+
+ // file: lib\common\plugin\DirectoryEntry.js
+ define("cordova/plugin/DirectoryEntry", function(require, exports, module) {
+
+ var utils = require('cordova/utils'),
+ exec = require('cordova/exec'),
+ Entry = require('cordova/plugin/Entry'),
+ FileError = require('cordova/plugin/FileError'),
+ DirectoryReader = require('cordova/plugin/DirectoryReader');
+
+ /**
+ * An interface representing a directory on the file system.
+ *
+ * {boolean} isFile always false (readonly)
+ * {boolean} isDirectory always true (readonly)
+ * {DOMString} name of the directory, excluding the path leading to it (readonly)
+ * {DOMString} fullPath the absolute full path to the directory (readonly)
+ * TODO: implement this!!! {FileSystem} filesystem on which the directory resides (readonly)
+ */
+ var DirectoryEntry = function(name, fullPath) {
+ DirectoryEntry.__super__.constructor.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 exclusively create the directory
+ * @param {Function} successCallback is called with the new entry
+ * @param {Function} errorCallback is called with a FileError
+ */
+ DirectoryEntry.prototype.getDirectory = function(path, options, successCallback, errorCallback) {
+ 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 exclusively create the file
+ * @param {Function} successCallback is called with the new entry
+ * @param {Function} errorCallback is called with a FileError
+ */
+ DirectoryEntry.prototype.getFile = function(path, options, successCallback, errorCallback) {
+ 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]);
+ };
+
+ /**
+ * Set the metadata of the entry.
+ *
+ * @param successCallback
+ * {Function} is called with a Metadata object
+ * @param errorCallback
+ * {Function} is called with a FileError
+ * @param metadataObject
+ * {Object} keys and values to set
+ */
+ Entry.prototype.setMetadata = function(successCallback, errorCallback, metadataObject) {
+
+ exec(successCallback, errorCallback, "File", "setMetadata", [this.fullPath, metadataObject]);
+ };
+
+ /**
+ * Move a file or directory to a new location.
+ *
+ * @param parent
+ * {DirectoryEntry} the directory to which to move this entry
+ * @param newName
+ * {DOMString} new name of the entry, defaults to the current name
+ * @param successCallback
+ * {Function} called with the new DirectoryEntry object
+ * @param errorCallback
+ * {Function} called with a FileError
+ */
+ Entry.prototype.moveTo = function(parent, newName, successCallback, errorCallback) {
+ 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.toURL();
+ };
+
+ /**
+ * Remove a file or directory. It is an error to attempt to delete a
+ * directory that is not empty. It is an error to attempt to delete a
+ * root directory of a file system.
+ *
+ * @param successCallback {Function} called with no parameters
+ * @param errorCallback {Function} called with a FileError
+ */
+ Entry.prototype.remove = function(successCallback, errorCallback) {
+ 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 (progress.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'),
+ FileTransferError = require('cordova/plugin/FileTransferError'),
+ ProgressEvent = require('cordova/plugin/ProgressEvent');
+
+ function newProgressEvent(result) {
+ var pe = new ProgressEvent();
+ pe.lengthComputable = result.lengthComputable;
+ pe.loaded = result.loaded;
+ pe.total = result.total;
+ return pe;
+ }
+
+ var idCounter = 0;
+
+ /**
+ * FileTransfer uploads a file to a remote server.
+ * @constructor
+ */
+ var FileTransfer = function() {
+ this._id = ++idCounter;
+ this.onprogress = null; // optional callback
+ };
+
+ /**
+ * Given an absolute file path, uploads a file on the device to a remote server
+ * using a multipart HTTP request.
+ * @param filePath {String} Full path of the file on the device
+ * @param server {String} URL of the server to receive the file
+ * @param successCallback (Function} Callback to be invoked when upload has completed
+ * @param errorCallback {Function} Callback to be invoked upon error
+ * @param options {FileUploadOptions} Optional parameters such as file name and mimetype
+ * @param trustAllHosts {Boolean} Optional trust all hosts (e.g. for self-signed certs), defaults to false
+ */
+ FileTransfer.prototype.upload = function(filePath, server, successCallback, errorCallback, options, trustAllHosts) {
+ // sanity parameter checking
+ if (!filePath || !server) throw new Error("FileTransfer.upload requires filePath and server URL parameters at the minimum.");
+ // check for options
+ var fileKey = null;
+ var fileName = null;
+ var mimeType = null;
+ var params = null;
+ var chunkedMode = true;
+ var headers = null;
+ if (options) {
+ fileKey = options.fileKey;
+ fileName = options.fileName;
+ mimeType = options.mimeType;
+ headers = options.headers;
+ if (options.chunkedMode !== null || typeof options.chunkedMode != "undefined") {
+ chunkedMode = options.chunkedMode;
+ }
+ if (options.params) {
+ params = options.params;
+ }
+ else {
+ params = {};
+ }
+ }
+
+ var fail = function(e) {
+ var error = new FileTransferError(e.code, e.source, e.target, e.http_status);
+ errorCallback(error);
+ };
+
+ var self = this;
+ var win = function(result) {
+ if (typeof result.lengthComputable != "undefined") {
+ if (self.onprogress) {
+ return self.onprogress(newProgressEvent(result));
+ }
+ } else {
+ return successCallback(result);
+ }
+ };
+ exec(win, fail, 'FileTransfer', 'upload', [filePath, server, fileKey, fileName, mimeType, params, trustAllHosts, chunkedMode, headers, this._id]);
+ };
+
+ /**
+ * Downloads a file form a given URL and saves it to the specified directory.
+ * @param source {String} URL of the server to receive the file
+ * @param target {String} Full path of the file on the device
+ * @param successCallback (Function} Callback to be invoked when upload has completed
+ * @param errorCallback {Function} Callback to be invoked upon error
+ * @param trustAllHosts {Boolean} Optional trust all hosts (e.g. for self-signed certs), defaults to false
+ */
+ FileTransfer.prototype.download = function(source, target, successCallback, errorCallback, trustAllHosts) {
+ // sanity parameter checking
+ if (!source || !target) throw new Error("FileTransfer.down
<TRUNCATED>