cordova-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From purplecabb...@apache.org
Subject [44/58] [abbrv] Merge remote-tracking branch 'sgrebnov-wp7/master'
Date Thu, 01 Nov 2012 22:09:19 GMT
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>

Mime
View raw message