cordova-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From agri...@apache.org
Subject [48/50] [abbrv] [CB-4048] Merge branch 'master' into 2.9.x
Date Fri, 28 Jun 2013 16:01:08 GMT
http://git-wip-us.apache.org/repos/asf/cordova-android/blob/67e97a89/framework/assets/www/cordova.js
----------------------------------------------------------------------
diff --cc framework/assets/www/cordova.js
index 873c068,b072c81..a7a1b38
--- a/framework/assets/www/cordova.js
+++ b/framework/assets/www/cordova.js
@@@ -1,5 -1,5 +1,5 @@@
  // Platform: android
- // 2.9.0-0-g83dc4bd
 -// 2.9.0rc1-0-g002f33d
++// 2.7.0rc1-154-g98a62ff
  /*
   Licensed to the Apache Software Foundation (ASF) under one
   or more contributor license agreements.  See the NOTICE file
@@@ -19,7 -19,7 +19,7 @@@
   under the License.
  */
  ;(function() {
- var CORDOVA_JS_BUILD_LABEL = '2.9.0-0-g83dc4bd';
 -var CORDOVA_JS_BUILD_LABEL = '2.9.0rc1-0-g002f33d';
++var CORDOVA_JS_BUILD_LABEL = '2.7.0rc1-154-g98a62ff';
  // file: lib/scripts/require.js
  
  var require,
@@@ -376,7 -376,7 +376,7 @@@ function checkArgs(spec, functionName, 
      if (errMsg) {
          errMsg += ', but got ' + typeName + '.';
          errMsg = 'Wrong type for parameter "' + extractParamName(opt_callee || args.callee, i) + '" of ' + functionName + ': ' + errMsg;
--        // Don't log when running jake test.
++        // Don't log when running unit tests.
          if (typeof jasmine == 'undefined') {
              console.error(errMsg);
          }
@@@ -524,8 -524,8 +524,6 @@@ var utils = require('cordova/utils')
   * 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
@@@ -728,12 -728,12 +726,6 @@@ channel.createSticky('onNativeReady')
  // and it's time to run plugin constructors.
  channel.createSticky('onCordovaReady');
  
--// Event to indicate that device properties are available
--channel.createSticky('onCordovaInfoReady');
--
--// Event to indicate that the connection property has been set.
--channel.createSticky('onCordovaConnectionReady');
--
  // Event to indicate that all automatically loaded JS plugins are loaded and ready.
  channel.createSticky('onPluginsReady');
  
@@@ -751,7 -751,7 +743,6 @@@ channel.createSticky('onDestroy')
  
  // Channels that must fire before "deviceready" is fired.
  channel.waitForInitialization('onCordovaReady');
--channel.waitForInitialization('onCordovaConnectionReady');
  channel.waitForInitialization('onDOMContentLoaded');
  
  module.exports = channel;
@@@ -1159,4689 -1159,4689 +1150,675 @@@ module.exports = 
  
  });
  
--// 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();
--};
++// file: lib/android/plugin/android/app.js
++define("cordova/plugin/android/app", function(require, exports, module) {
  
--module.exports = Acceleration;
++var exec = require('cordova/exec');
  
--});
++module.exports = {
++  /**
++   * Clear the resource cache.
++   */
++  clearCache:function() {
++    exec(null, null, "App", "clearCache", []);
++  },
  
--// file: lib/common/plugin/Camera.js
--define("cordova/plugin/Camera", function(require, exports, module) {
++  /**
++   * Load the url into the webview or into new browser instance.
++   *
++   * @param url           The URL to load
++   * @param props         Properties that can be passed in to the activity:
++   *      wait: int                           => wait msec before loading URL
++   *      loadingDialog: "Title,Message"      => display a native loading dialog
++   *      loadUrlTimeoutValue: int            => time in msec to wait before triggering a timeout error
++   *      clearHistory: boolean              => clear webview history (default=false)
++   *      openExternal: boolean              => open in a new browser (default=false)
++   *
++   * Example:
++   *      navigator.app.loadUrl("http://server/myapp/index.html", {wait:2000, loadingDialog:"Wait,Loading App", loadUrlTimeoutValue: 60000});
++   */
++  loadUrl:function(url, props) {
++    exec(null, null, "App", "loadUrl", [url, props]);
++  },
  
--var argscheck = require('cordova/argscheck'),
--    exec = require('cordova/exec'),
--    Camera = require('cordova/plugin/CameraConstants'),
--    CameraPopoverHandle = require('cordova/plugin/CameraPopoverHandle');
++  /**
++   * Cancel loadUrl that is waiting to be loaded.
++   */
++  cancelLoadUrl:function() {
++    exec(null, null, "App", "cancelLoadUrl", []);
++  },
  
--var cameraExport = {};
++  /**
++   * Clear web history in this web view.
++   * Instead of BACK button loading the previous web page, it will exit the app.
++   */
++  clearHistory:function() {
++    exec(null, null, "App", "clearHistory", []);
++  },
  
--// Tack on the Camera Constants to the base camera plugin.
--for (var key in Camera) {
--    cameraExport[key] = Camera[key];
--}
++  /**
++   * Go to previous page displayed.
++   * This is the same as pressing the backbutton on Android device.
++   */
++  backHistory:function() {
++    exec(null, null, "App", "backHistory", []);
++  },
  
--/**
-- * Gets a picture from source defined by "options.sourceType", and returns the
-- * image as defined by the "options.destinationType" option.
++  /**
++   * Override the default behavior of the Android back button.
++   * If overridden, when the back button is pressed, the "backKeyDown" JavaScript event will be fired.
++   *
++   * Note: The user should not have to call this method.  Instead, when the user
++   *       registers for the "backbutton" event, this is automatically done.
++   *
++   * @param override        T=override, F=cancel override
++   */
++  overrideBackbutton:function(override) {
++    exec(null, null, "App", "overrideBackbutton", [override]);
++  },
  
-- * The defaults are sourceType=CAMERA and destinationType=FILE_URI.
-- *
-- * @param {Function} successCallback
-- * @param {Function} errorCallback
-- * @param {Object} options
-- */
--cameraExport.getPicture = function(successCallback, errorCallback, options) {
--    argscheck.checkArgs('fFO', 'Camera.getPicture', arguments);
--    options = options || {};
--    var getValue = argscheck.getValue;
--
--    var quality = getValue(options.quality, 50);
--    var destinationType = getValue(options.destinationType, Camera.DestinationType.FILE_URI);
--    var sourceType = getValue(options.sourceType, Camera.PictureSourceType.CAMERA);
--    var targetWidth = getValue(options.targetWidth, -1);
--    var targetHeight = getValue(options.targetHeight, -1);
--    var encodingType = getValue(options.encodingType, Camera.EncodingType.JPEG);
--    var mediaType = getValue(options.mediaType, Camera.MediaType.PICTURE);
--    var allowEdit = !!options.allowEdit;
--    var correctOrientation = !!options.correctOrientation;
--    var saveToPhotoAlbum = !!options.saveToPhotoAlbum;
--    var popoverOptions = getValue(options.popoverOptions, null);
--    var cameraDirection = getValue(options.cameraDirection, Camera.Direction.BACK);
--
--    var args = [quality, destinationType, sourceType, targetWidth, targetHeight, encodingType,
--                mediaType, allowEdit, correctOrientation, saveToPhotoAlbum, popoverOptions, cameraDirection];
--
--    exec(successCallback, errorCallback, "Camera", "takePicture", args);
--    return new CameraPopoverHandle();
++  /**
++   * Exit and terminate the application.
++   */
++  exitApp:function() {
++    return exec(null, null, "App", "exitApp", []);
++  }
  };
  
--cameraExport.cleanup = function(successCallback, errorCallback) {
--    exec(successCallback, errorCallback, "Camera", "cleanup", []);
--};
++});
  
--module.exports = cameraExport;
++// file: lib/android/plugin/android/nativeapiprovider.js
++define("cordova/plugin/android/nativeapiprovider", function(require, exports, module) {
  
--});
++/**
++ * Exports the ExposedJsApi.java object if available, otherwise exports the PromptBasedNativeApi.
++ */
  
--// file: lib/common/plugin/CameraConstants.js
--define("cordova/plugin/CameraConstants", function(require, exports, module) {
++var nativeApi = this._cordovaNative || require('cordova/plugin/android/promptbasednativeapi');
++var currentApi = nativeApi;
  
  module.exports = {
--  DestinationType:{
--    DATA_URL: 0,         // Return base64 encoded string
--    FILE_URI: 1,         // Return file uri (content://media/external/images/media/2 for Android)
--    NATIVE_URI: 2        // Return native uri (eg. asset-library://... for iOS)
--  },
--  EncodingType:{
--    JPEG: 0,             // Return JPEG encoded image
--    PNG: 1               // Return PNG encoded image
--  },
--  MediaType:{
--    PICTURE: 0,          // allow selection of still pictures only. DEFAULT. Will return format specified via DestinationType
--    VIDEO: 1,            // allow selection of video only, ONLY RETURNS URL
--    ALLMEDIA : 2         // allow selection from all media types
--  },
--  PictureSourceType:{
--    PHOTOLIBRARY : 0,    // Choose image from picture library (same as SAVEDPHOTOALBUM for Android)
--    CAMERA : 1,          // Take picture from camera
--    SAVEDPHOTOALBUM : 2  // Choose image from picture library (same as PHOTOLIBRARY for Android)
--  },
--  PopoverArrowDirection:{
--      ARROW_UP : 1,        // matches iOS UIPopoverArrowDirection constants to specify arrow location on popover
--      ARROW_DOWN : 2,
--      ARROW_LEFT : 4,
--      ARROW_RIGHT : 8,
--      ARROW_ANY : 15
--  },
--  Direction:{
--      BACK: 0,
--      FRONT: 1
--  }
++    get: function() { return currentApi; },
++    setPreferPrompt: function(value) {
++        currentApi = value ? require('cordova/plugin/android/promptbasednativeapi') : nativeApi;
++    },
++    // Used only by tests.
++    set: function(value) {
++        currentApi = value;
++    }
  };
  
  });
  
--// file: lib/common/plugin/CameraPopoverHandle.js
--define("cordova/plugin/CameraPopoverHandle", function(require, exports, module) {
--
--var exec = require('cordova/exec');
++// file: lib/android/plugin/android/promptbasednativeapi.js
++define("cordova/plugin/android/promptbasednativeapi", function(require, exports, module) {
  
  /**
-- * A handle to an image picker popover.
++ * Implements the API of ExposedJsApi.java, but uses prompt() to communicate.
++ * This is used only on the 2.3 simulator, where addJavascriptInterface() is broken.
   */
--var CameraPopoverHandle = function() {
--    this.setPosition = function(popoverOptions) {
--        console.log('CameraPopoverHandle.setPosition is only supported on iOS.');
--    };
--};
  
--module.exports = CameraPopoverHandle;
++module.exports = {
++    exec: function(service, action, callbackId, argsJson) {
++        return prompt(argsJson, 'gap:'+JSON.stringify([service, action, callbackId]));
++    },
++    setNativeToJsBridgeMode: function(value) {
++        prompt(value, 'gap_bridge_mode:');
++    },
++    retrieveJsMessages: function() {
++        return prompt('', 'gap_poll:');
++    }
++};
  
  });
  
--// file: lib/common/plugin/CameraPopoverOptions.js
--define("cordova/plugin/CameraPopoverOptions", function(require, exports, module) {
++// file: lib/android/plugin/android/storage.js
++define("cordova/plugin/android/storage", function(require, exports, module) {
++
++var utils = require('cordova/utils'),
++    exec = require('cordova/exec'),
++    channel = require('cordova/channel');
  
--var Camera = require('cordova/plugin/CameraConstants');
++var queryQueue = {};
  
  /**
-- * Encapsulates options for iOS Popover image picker
++ * SQL result set object
++ * PRIVATE METHOD
++ * @constructor
   */
--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;
++var DroidDB_Rows = function() {
++    this.resultSet = [];    // results array
++    this.length = 0;        // number of rows
  };
  
--module.exports = CameraPopoverOptions;
--
--});
--
--// file: lib/common/plugin/CaptureAudioOptions.js
--define("cordova/plugin/CaptureAudioOptions", function(require, exports, module) {
--
  /**
-- * Encapsulates all audio capture operation configuration options.
++ * Get item from SQL result set
++ *
++ * @param row           The row number to return
++ * @return              The row object
   */
--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;
++DroidDB_Rows.prototype.item = function(row) {
++    return this.resultSet[row];
  };
  
--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.
++ * SQL result set that is returned to user.
++ * PRIVATE METHOD
++ * @constructor
   */
--var CaptureError = function(c) {
--   this.code = c || null;
++var DroidDB_Result = function() {
++    this.rows = new DroidDB_Rows();
  };
  
--// 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.
++ * Callback from native code when query is complete.
++ * PRIVATE METHOD
++ *
++ * @param id   Query id
   */
--var CaptureImageOptions = function(){
--    // Upper limit of images user can take. Value must be equal or greater than 1.
--    this.limit = 1;
--};
++function completeQuery(id, data) {
++    var query = queryQueue[id];
++    if (query) {
++        try {
++            delete queryQueue[id];
  
--module.exports = CaptureImageOptions;
++            // Get transaction
++            var tx = query.tx;
  
--});
++            // If transaction hasn't failed
++            // Note: We ignore all query results if previous query
++            //       in the same transaction failed.
++            if (tx && tx.queryList[id]) {
++
++                // Save query results
++                var r = new DroidDB_Result();
++                r.rows.resultSet = data;
++                r.rows.length = data.length;
++                try {
++                    if (typeof query.successCallback === 'function') {
++                        query.successCallback(query.tx, r);
++                    }
++                } catch (ex) {
++                    console.log("executeSql error calling user success callback: "+ex);
++                }
  
--// file: lib/common/plugin/CaptureVideoOptions.js
--define("cordova/plugin/CaptureVideoOptions", function(require, exports, module) {
++                tx.queryComplete(id);
++            }
++        } catch (e) {
++            console.log("executeSql error: "+e);
++        }
++    }
++}
  
  /**
-- * Encapsulates all video capture operation configuration options.
++ * Callback from native code when query fails
++ * PRIVATE METHOD
++ *
++ * @param reason            Error message
++ * @param id                Query id
   */
--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;
--};
++function failQuery(reason, id) {
++    var query = queryQueue[id];
++    if (query) {
++        try {
++            delete queryQueue[id];
  
--module.exports = CaptureVideoOptions;
++            // Get transaction
++            var tx = query.tx;
  
--});
++            // If transaction hasn't failed
++            // Note: We ignore all query results if previous query
++            //       in the same transaction failed.
++            if (tx && tx.queryList[id]) {
++                tx.queryList = {};
++
++                try {
++                    if (typeof query.errorCallback === 'function') {
++                        query.errorCallback(query.tx, reason);
++                    }
++                } catch (ex) {
++                    console.log("executeSql error calling user error callback: "+ex);
++                }
++
++                tx.queryFailed(id, reason);
++            }
  
--// file: lib/common/plugin/CompassError.js
--define("cordova/plugin/CompassError", function(require, exports, module) {
++        } catch (e) {
++            console.log("executeSql error: "+e);
++        }
++    }
++}
  
  /**
-- *  CompassError.
-- *  An error code assigned by an implementation when an error has occurred
++ * SQL query object
++ * PRIVATE METHOD
++ *
   * @constructor
++ * @param tx                The transaction object that this query belongs to
   */
--var CompassError = function(err) {
--    this.code = (err !== undefined ? err : null);
--};
--
--CompassError.COMPASS_INTERNAL_ERR = 0;
--CompassError.COMPASS_NOT_SUPPORTED = 20;
++var DroidDB_Query = function(tx) {
  
--module.exports = CompassError;
++    // Set the id of the query
++    this.id = utils.createUUID();
  
--});
++    // Add this query to the queue
++    queryQueue[this.id] = this;
  
--// file: lib/common/plugin/CompassHeading.js
--define("cordova/plugin/CompassHeading", function(require, exports, module) {
++    // Init result
++    this.resultSet = [];
  
--var CompassHeading = function(magneticHeading, trueHeading, headingAccuracy, timestamp) {
--  this.magneticHeading = magneticHeading;
--  this.trueHeading = trueHeading;
--  this.headingAccuracy = headingAccuracy;
--  this.timestamp = timestamp || new Date().getTime();
--};
++    // Set transaction that this query belongs to
++    this.tx = tx;
  
--module.exports = CompassHeading;
++    // Add this query to transaction list
++    this.tx.queryList[this.id] = this;
  
--});
++    // Callbacks
++    this.successCallback = null;
++    this.errorCallback = null;
  
--// file: lib/common/plugin/ConfigurationData.js
--define("cordova/plugin/ConfigurationData", function(require, exports, module) {
++};
  
  /**
-- * Encapsulates a set of parameters that the capture device supports.
++ * Transaction object
++ * PRIVATE METHOD
++ * @constructor
   */
--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;
++var DroidDB_Tx = function() {
  
--});
++    // Set the id of the transaction
++    this.id = utils.createUUID();
  
--// file: lib/common/plugin/Connection.js
--define("cordova/plugin/Connection", function(require, exports, module) {
++    // Callbacks
++    this.successCallback = null;
++    this.errorCallback = null;
  
--/**
-- * Network status
-- */
--module.exports = {
--        UNKNOWN: "unknown",
--        ETHERNET: "ethernet",
--        WIFI: "wifi",
--        CELL_2G: "2g",
--        CELL_3G: "3g",
--        CELL_4G: "4g",
--        CELL:"cellular",
--        NONE: "none"
++    // Query list
++    this.queryList = {};
  };
  
--});
--
--// file: lib/common/plugin/Contact.js
--define("cordova/plugin/Contact", function(require, exports, module) {
--
--var argscheck = require('cordova/argscheck'),
--    exec = require('cordova/exec'),
--    ContactError = require('cordova/plugin/ContactError'),
--    utils = require('cordova/utils');
--
  /**
--* Converts primitives into Complex Object
--* Currently only used for Date fields
--*/
--function convertIn(contact) {
--    var value = contact.birthday;
--    try {
--      contact.birthday = new Date(parseFloat(value));
--    } catch (exception){
--      console.log("Cordova Contact convertIn error: exception creating date.");
--    }
--    return contact;
--}
++ * Mark query in transaction as complete.
++ * If all queries are complete, call the user's transaction success callback.
++ *
++ * @param id                Query id
++ */
++DroidDB_Tx.prototype.queryComplete = function(id) {
++    delete this.queryList[id];
  
--/**
--* 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 no more outstanding queries, then fire transaction success
++    if (this.successCallback) {
++        var count = 0;
++        var i;
++        for (i in this.queryList) {
++            if (this.queryList.hasOwnProperty(i)) {
++                count++;
              }
          }
--        if (utils.isDate(value)){
--            value = value.valueOf(); // convert to milliseconds
++        if (count === 0) {
++            try {
++                this.successCallback();
++            } catch(e) {
++                console.log("Transaction error calling user success callback: " + e);
++            }
          }
--        contact.birthday = value;
      }
  };
  
  /**
--* Removes contact from device storage.
--* @param successCB success callback
--* @param errorCB error callback
--*/
--Contact.prototype.remove = function(successCB, errorCB) {
--    argscheck.checkArgs('FF', 'Contact.remove', arguments);
--    var fail = errorCB && function(code) {
--        errorCB(new ContactError(code));
--    };
--    if (this.id === null) {
--        fail(ContactError.UNKNOWN_ERROR);
--    }
--    else {
--        exec(successCB, fail, "Contacts", "remove", [this.id]);
--    }
--};
++ * Mark query in transaction as failed.
++ *
++ * @param id                Query id
++ * @param reason            Error message
++ */
++DroidDB_Tx.prototype.queryFailed = function(id, reason) {
  
--/**
--* Creates a deep copy of this Contact.
--* With the contact ID set to null.
--* @return copy of this Contact
--*/
--Contact.prototype.clone = function() {
--    var clonedContact = utils.clone(this);
--    clonedContact.id = null;
--    clonedContact.rawId = null;
--
--    function nullIds(arr) {
--        if (arr) {
--            for (var i = 0; i < arr.length; ++i) {
--                arr[i].id = null;
--            }
++    // The sql queries in this transaction have already been run, since
++    // we really don't have a real transaction implemented in native code.
++    // However, the user callbacks for the remaining sql queries in transaction
++    // will not be called.
++    this.queryList = {};
++
++    if (this.errorCallback) {
++        try {
++            this.errorCallback(reason);
++        } catch(e) {
++            console.log("Transaction error calling user error callback: " + e);
          }
      }
  };
  
  /**
--* Persists contact to device storage.
--* @param successCB success callback
--* @param errorCB error callback
--*/
--Contact.prototype.save = function(successCB, errorCB) {
--    argscheck.checkArgs('FFO', 'Contact.save', arguments);
--    var fail = errorCB && function(code) {
--        errorCB(new ContactError(code));
--    };
--    var success = function(result) {
--        if (result) {
--            if (successCB) {
--                var fullContact = require('cordova/plugin/contacts').create(result);
--                successCB(convertIn(fullContact));
--            }
--        }
--        else {
--            // no Entry object returned
--            fail(ContactError.UNKNOWN_ERROR);
--        }
--    };
--    var dupContact = convertOut(utils.clone(this));
--    exec(success, fail, "Contacts", "save", [dupContact]);
--};
--
--
--module.exports = Contact;
++ * Execute SQL statement
++ *
++ * @param sql                   SQL statement to execute
++ * @param params                Statement parameters
++ * @param successCallback       Success callback
++ * @param errorCallback         Error callback
++ */
++DroidDB_Tx.prototype.executeSql = function(sql, params, successCallback, errorCallback) {
  
--});
++    // Init params array
++    if (typeof params === 'undefined') {
++        params = [];
++    }
  
--// file: lib/common/plugin/ContactAddress.js
--define("cordova/plugin/ContactAddress", function(require, exports, module) {
++    // Create query and add to queue
++    var query = new DroidDB_Query(this);
++    queryQueue[query.id] = query;
  
--/**
--* 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
--*/
++    // Save callbacks
++    query.successCallback = successCallback;
++    query.errorCallback = errorCallback;
  
--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;
++    // Call native code
++    exec(null, null, "Storage", "executeSql", [sql, params, query.id]);
  };
  
--module.exports = ContactAddress;
--
--});
--
--// file: lib/common/plugin/ContactError.js
--define("cordova/plugin/ContactError", function(require, exports, module) {
++var DatabaseShell = function() {
++};
  
  /**
-- *  ContactError.
-- *  An error code assigned by an implementation when an error has occurred
-- * @constructor
++ * Start a transaction.
++ * Does not support rollback in event of failure.
++ *
++ * @param process {Function}            The transaction function
++ * @param successCallback {Function}
++ * @param errorCallback {Function}
   */
--var ContactError = function(err) {
--    this.code = (typeof err != 'undefined' ? err : null);
++DatabaseShell.prototype.transaction = function(process, errorCallback, successCallback) {
++    var tx = new DroidDB_Tx();
++    tx.successCallback = successCallback;
++    tx.errorCallback = errorCallback;
++    try {
++        process(tx);
++    } catch (e) {
++        console.log("Transaction error: "+e);
++        if (tx.errorCallback) {
++            try {
++                tx.errorCallback(e);
++            } catch (ex) {
++                console.log("Transaction error calling user error callback: "+e);
++            }
++        }
++    }
  };
  
  /**
-- * Error codes
++ * Open database
++ *
++ * @param name              Database name
++ * @param version           Database version
++ * @param display_name      Database display name
++ * @param size              Database size in bytes
++ * @return                  Database object
   */
--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;
--
--});
++var DroidDB_openDatabase = function(name, version, display_name, size) {
++    exec(null, null, "Storage", "openDatabase", [name, version, display_name, size]);
++    var db = new DatabaseShell();
++    return db;
++};
  
--// 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 = {
++  openDatabase:DroidDB_openDatabase,
++  failQuery:failQuery,
++  completeQuery:completeQuery
  };
  
--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
-- */
++// file: lib/android/plugin/android/storage/openDatabase.js
++define("cordova/plugin/android/storage/openDatabase", function(require, exports, module) {
  
--var ContactFindOptions = function(filter, multiple) {
--    this.filter = filter || '';
--    this.multiple = (typeof multiple != 'undefined' ? multiple : false);
--};
  
--module.exports = ContactFindOptions;
++var modulemapper = require('cordova/modulemapper'),
++    storage = require('cordova/plugin/android/storage');
  
--});
++var originalOpenDatabase = modulemapper.getOriginalSymbol(window, 'openDatabase');
  
--// file: lib/common/plugin/ContactName.js
--define("cordova/plugin/ContactName", function(require, exports, module) {
++module.exports = function(name, version, desc, size) {
++    // First patch WebSQL if necessary
++    if (!originalOpenDatabase) {
++        // Not defined, create an openDatabase function for all to use!
++        return storage.openDatabase.apply(this, arguments);
++    }
  
--/**
--* 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;
++    // Defined, but some Android devices will throw a SECURITY_ERR -
++    // so we wrap the whole thing in a try-catch and shim in our own
++    // if the device has Android bug 16175.
++    try {
++        return originalOpenDatabase(name, version, desc, size);
++    } catch (ex) {
++        if (ex.code !== 18) {
++            throw ex;
++        }
++    }
++    return storage.openDatabase(name, version, desc, size);
  };
  
--module.exports = ContactName;
++
  
  });
  
--// file: lib/common/plugin/ContactOrganization.js
--define("cordova/plugin/ContactOrganization", function(require, exports, module) {
++// file: lib/android/plugin/android/storage/symbols.js
++define("cordova/plugin/android/storage/symbols", 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;
--};
++var modulemapper = require('cordova/modulemapper');
++
++modulemapper.clobbers('cordova/plugin/android/storage/openDatabase', 'openDatabase');
  
  
  });
  
--// file: lib/common/plugin/Coordinates.js
--define("cordova/plugin/Coordinates", function(require, exports, module) {
++// file: lib/common/plugin/console-via-logger.js
++define("cordova/plugin/console-via-logger", 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;
--    }
++var logger = require("cordova/plugin/logger");
++var utils  = require("cordova/utils");
  
--    /**
--     * The altitude accuracy of the position.
--     */
--    this.altitudeAccuracy = (altacc !== undefined) ? altacc : null;
--};
++//------------------------------------------------------------------------------
++// object that we're exporting
++//------------------------------------------------------------------------------
++var console = module.exports;
  
--module.exports = Coordinates;
++//------------------------------------------------------------------------------
++// copy of the original console object
++//------------------------------------------------------------------------------
++var WinConsole = window.console;
  
--});
++//------------------------------------------------------------------------------
++// whether to use the logger
++//------------------------------------------------------------------------------
++var UseLogger = false;
  
--// file: lib/common/plugin/DirectoryEntry.js
--define("cordova/plugin/DirectoryEntry", function(require, exports, module) {
++//------------------------------------------------------------------------------
++// Timers
++//------------------------------------------------------------------------------
++var Timers = {};
  
--var argscheck = require('cordova/argscheck'),
--    utils = require('cordova/utils'),
--    exec = require('cordova/exec'),
--    Entry = require('cordova/plugin/Entry'),
--    FileError = require('cordova/plugin/FileError'),
--    DirectoryReader = require('cordova/plugin/DirectoryReader');
++//------------------------------------------------------------------------------
++// used for unimplemented methods
++//------------------------------------------------------------------------------
++function noop() {}
  
--/**
-- * An interface representing a directory on the file system.
-- *
-- * {boolean} isFile always false (readonly)
-- * {boolean} isDirectory always true (readonly)
-- * {DOMString} name of the directory, excluding the path leading to it (readonly)
-- * {DOMString} fullPath the absolute full path to the directory (readonly)
-- * TODO: implement this!!! {FileSystem} filesystem on which the directory resides (readonly)
-- */
--var DirectoryEntry = function(name, fullPath) {
--     DirectoryEntry.__super__.constructor.call(this, false, true, name, fullPath);
--};
++//------------------------------------------------------------------------------
++// used for unimplemented methods
++//------------------------------------------------------------------------------
++console.useLogger = function (value) {
++    if (arguments.length) UseLogger = !!value;
  
--utils.extend(DirectoryEntry, Entry);
++    if (UseLogger) {
++        if (logger.useConsole()) {
++            throw new Error("console and logger are too intertwingly");
++        }
++    }
  
--/**
-- * Creates a new DirectoryReader to read entries from this directory
-- */
--DirectoryEntry.prototype.createReader = function() {
--    return new DirectoryReader(this.fullPath);
--};
--
--/**
-- * Creates or looks up a directory
-- *
-- * @param {DOMString} path either a relative or absolute path from this directory in which to look up or create a directory
-- * @param {Flags} options to create or exclusively create the directory
-- * @param {Function} successCallback is called with the new entry
-- * @param {Function} errorCallback is called with a FileError
-- */
--DirectoryEntry.prototype.getDirectory = function(path, options, successCallback, errorCallback) {
--    argscheck.checkArgs('sOFF', 'DirectoryEntry.getDirectory', arguments);
--    var win = successCallback && function(result) {
--        var entry = new DirectoryEntry(result.name, result.fullPath);
--        successCallback(entry);
--    };
--    var fail = errorCallback && function(code) {
--        errorCallback(new FileError(code));
--    };
--    exec(win, fail, "File", "getDirectory", [this.fullPath, path, options]);
--};
--
--/**
-- * Deletes a directory and all of it's contents
-- *
-- * @param {Function} successCallback is called with no parameters
-- * @param {Function} errorCallback is called with a FileError
-- */
--DirectoryEntry.prototype.removeRecursively = function(successCallback, errorCallback) {
--    argscheck.checkArgs('FF', 'DirectoryEntry.removeRecursively', arguments);
--    var fail = errorCallback && function(code) {
--        errorCallback(new FileError(code));
--    };
--    exec(successCallback, fail, "File", "removeRecursively", [this.fullPath]);
--};
--
--/**
-- * Creates or looks up a file
-- *
-- * @param {DOMString} path either a relative or absolute path from this directory in which to look up or create a file
-- * @param {Flags} options to create or exclusively create the file
-- * @param {Function} successCallback is called with the new entry
-- * @param {Function} errorCallback is called with a FileError
-- */
--DirectoryEntry.prototype.getFile = function(path, options, successCallback, errorCallback) {
--    argscheck.checkArgs('sOFF', 'DirectoryEntry.getFile', arguments);
--    var win = successCallback && function(result) {
--        var FileEntry = require('cordova/plugin/FileEntry');
--        var entry = new FileEntry(result.name, result.fullPath);
--        successCallback(entry);
--    };
--    var fail = errorCallback && function(code) {
--        errorCallback(new FileError(code));
--    };
--    exec(win, fail, "File", "getFile", [this.fullPath, path, options]);
--};
--
--module.exports = DirectoryEntry;
--
--});
--
--// file: lib/common/plugin/DirectoryReader.js
--define("cordova/plugin/DirectoryReader", function(require, exports, module) {
--
--var exec = require('cordova/exec'),
--    FileError = require('cordova/plugin/FileError') ;
--
--/**
-- * An interface that lists the files and directories in a directory.
-- */
--function DirectoryReader(path) {
--    this.path = path || null;
--}
--
--/**
-- * Returns a list of entries from a directory.
-- *
-- * @param {Function} successCallback is called with a list of entries
-- * @param {Function} errorCallback is called with a FileError
-- */
--DirectoryReader.prototype.readEntries = function(successCallback, errorCallback) {
--    var win = typeof successCallback !== 'function' ? null : function(result) {
--        var retVal = [];
--        for (var i=0; i<result.length; i++) {
--            var entry = null;
--            if (result[i].isDirectory) {
--                entry = new (require('cordova/plugin/DirectoryEntry'))();
--            }
--            else if (result[i].isFile) {
--                entry = new (require('cordova/plugin/FileEntry'))();
--            }
--            entry.isDirectory = result[i].isDirectory;
--            entry.isFile = result[i].isFile;
--            entry.name = result[i].name;
--            entry.fullPath = result[i].fullPath;
--            retVal.push(entry);
--        }
--        successCallback(retVal);
--    };
--    var fail = typeof errorCallback !== 'function' ? null : function(code) {
--        errorCallback(new FileError(code));
--    };
--    exec(win, fail, "File", "readEntries", [this.path]);
--};
--
--module.exports = DirectoryReader;
--
--});
--
--// file: lib/common/plugin/Entry.js
--define("cordova/plugin/Entry", function(require, exports, module) {
--
--var argscheck = require('cordova/argscheck'),
--    exec = require('cordova/exec'),
--    FileError = require('cordova/plugin/FileError'),
--    Metadata = require('cordova/plugin/Metadata');
--
--/**
-- * Represents a file or directory on the local file system.
-- *
-- * @param isFile
-- *            {boolean} true if Entry is a file (readonly)
-- * @param isDirectory
-- *            {boolean} true if Entry is a directory (readonly)
-- * @param name
-- *            {DOMString} name of the file or directory, excluding the path
-- *            leading to it (readonly)
-- * @param fullPath
-- *            {DOMString} the absolute full path to the file or directory
-- *            (readonly)
-- */
--function Entry(isFile, isDirectory, name, fullPath, fileSystem) {
--    this.isFile = !!isFile;
--    this.isDirectory = !!isDirectory;
--    this.name = name || '';
--    this.fullPath = fullPath || '';
--    this.filesystem = fileSystem || null;
--}
--
--/**
-- * Look up the metadata of the entry.
-- *
-- * @param successCallback
-- *            {Function} is called with a Metadata object
-- * @param errorCallback
-- *            {Function} is called with a FileError
-- */
--Entry.prototype.getMetadata = function(successCallback, errorCallback) {
--    argscheck.checkArgs('FF', 'Entry.getMetadata', arguments);
--    var success = successCallback && function(lastModified) {
--        var metadata = new Metadata(lastModified);
--        successCallback(metadata);
--    };
--    var fail = errorCallback && function(code) {
--        errorCallback(new FileError(code));
--    };
--
--    exec(success, fail, "File", "getMetadata", [this.fullPath]);
--};
--
--/**
-- * Set the metadata of the entry.
-- *
-- * @param successCallback
-- *            {Function} is called with a Metadata object
-- * @param errorCallback
-- *            {Function} is called with a FileError
-- * @param metadataObject
-- *            {Object} keys and values to set
-- */
--Entry.prototype.setMetadata = function(successCallback, errorCallback, metadataObject) {
--    argscheck.checkArgs('FFO', 'Entry.setMetadata', arguments);
--    exec(successCallback, errorCallback, "File", "setMetadata", [this.fullPath, metadataObject]);
--};
--
--/**
-- * Move a file or directory to a new location.
-- *
-- * @param parent
-- *            {DirectoryEntry} the directory to which to move this entry
-- * @param newName
-- *            {DOMString} new name of the entry, defaults to the current name
-- * @param successCallback
-- *            {Function} called with the new DirectoryEntry object
-- * @param errorCallback
-- *            {Function} called with a FileError
-- */
--Entry.prototype.moveTo = function(parent, newName, successCallback, errorCallback) {
--    argscheck.checkArgs('oSFF', 'Entry.moveTo', arguments);
--    var fail = errorCallback && function(code) {
--        errorCallback(new FileError(code));
--    };
--    // source path
--    var srcPath = this.fullPath,
--        // entry name
--        name = newName || this.name,
--        success = function(entry) {
--            if (entry) {
--                if (successCallback) {
--                    // create appropriate Entry object
--                    var result = (entry.isDirectory) ? new (require('cordova/plugin/DirectoryEntry'))(entry.name, entry.fullPath) : new (require('cordova/plugin/FileEntry'))(entry.name, entry.fullPath);
--                    successCallback(result);
--                }
--            }
--            else {
--                // no Entry object returned
--                fail && fail(FileError.NOT_FOUND_ERR);
--            }
--        };
--
--    // copy
--    exec(success, fail, "File", "moveTo", [srcPath, parent.fullPath, name]);
--};
--
--/**
-- * Copy a directory to a different location.
-- *
-- * @param parent
-- *            {DirectoryEntry} the directory to which to copy the entry
-- * @param newName
-- *            {DOMString} new name of the entry, defaults to the current name
-- * @param successCallback
-- *            {Function} called with the new Entry object
-- * @param errorCallback
-- *            {Function} called with a FileError
-- */
--Entry.prototype.copyTo = function(parent, newName, successCallback, errorCallback) {
--    argscheck.checkArgs('oSFF', 'Entry.copyTo', arguments);
--    var fail = errorCallback && function(code) {
--        errorCallback(new FileError(code));
--    };
--
--        // source path
--    var srcPath = this.fullPath,
--        // entry name
--        name = newName || this.name,
--        // success callback
--        success = function(entry) {
--            if (entry) {
--                if (successCallback) {
--                    // create appropriate Entry object
--                    var result = (entry.isDirectory) ? new (require('cordova/plugin/DirectoryEntry'))(entry.name, entry.fullPath) : new (require('cordova/plugin/FileEntry'))(entry.name, entry.fullPath);
--                    successCallback(result);
--                }
--            }
--            else {
--                // no Entry object returned
--                fail && fail(FileError.NOT_FOUND_ERR);
--            }
--        };
--
--    // copy
--    exec(success, fail, "File", "copyTo", [srcPath, parent.fullPath, name]);
--};
--
--/**
-- * Return a URL that can be used to identify this entry.
-- */
--Entry.prototype.toURL = function() {
--    // fullPath attribute contains the full URL
--    return this.fullPath;
--};
--
--/**
-- * Returns a URI that can be used to identify this entry.
-- *
-- * @param {DOMString} mimeType for a FileEntry, the mime type to be used to interpret the file, when loaded through this URI.
-- * @return uri
-- */
--Entry.prototype.toURI = function(mimeType) {
--    console.log("DEPRECATED: Update your code to use 'toURL'");
--    // fullPath attribute contains the full URI
--    return this.toURL();
--};
--
--/**
-- * Remove a file or directory. It is an error to attempt to delete a
-- * directory that is not empty. It is an error to attempt to delete a
-- * root directory of a file system.
-- *
-- * @param successCallback {Function} called with no parameters
-- * @param errorCallback {Function} called with a FileError
-- */
--Entry.prototype.remove = function(successCallback, errorCallback) {
--    argscheck.checkArgs('FF', 'Entry.remove', arguments);
--    var fail = errorCallback && function(code) {
--        errorCallback(new FileError(code));
--    };
--    exec(successCallback, fail, "File", "remove", [this.fullPath]);
--};
--
--/**
-- * Look up the parent DirectoryEntry of this entry.
-- *
-- * @param successCallback {Function} called with the parent DirectoryEntry object
-- * @param errorCallback {Function} called with a FileError
-- */
--Entry.prototype.getParent = function(successCallback, errorCallback) {
--    argscheck.checkArgs('FF', 'Entry.getParent', arguments);
--    var win = successCallback && function(result) {
--        var DirectoryEntry = require('cordova/plugin/DirectoryEntry');
--        var entry = new DirectoryEntry(result.name, result.fullPath);
--        successCallback(entry);
--    };
--    var fail = errorCallback && function(code) {
--        errorCallback(new FileError(code));
--    };
--    exec(win, fail, "File", "getParent", [this.fullPath]);
--};
--
--module.exports = Entry;
--
--});
--
--// file: lib/common/plugin/File.js
--define("cordova/plugin/File", function(require, exports, module) {
--
--/**
-- * Constructor.
-- * name {DOMString} name of the file, without path information
-- * fullPath {DOMString} the full path of the file, including the name
-- * type {DOMString} mime type
-- * lastModifiedDate {Date} last modified date
-- * size {Number} size of the file in bytes
-- */
--
--var File = function(name, fullPath, type, lastModifiedDate, size){
--    this.name = name || '';
--    this.fullPath = fullPath || null;
--    this.type = type || null;
--    this.lastModifiedDate = lastModifiedDate || null;
--    this.size = size || 0;
--
--    // These store the absolute start and end for slicing the file.
--    this.start = 0;
--    this.end = this.size;
--};
--
--/**
-- * Returns a "slice" of the file. Since Cordova Files don't contain the actual
-- * content, this really returns a File with adjusted start and end.
-- * Slices of slices are supported.
-- * start {Number} The index at which to start the slice (inclusive).
-- * end {Number} The index at which to end the slice (exclusive).
-- */
--File.prototype.slice = function(start, end) {
--    var size = this.end - this.start;
--    var newStart = 0;
--    var newEnd = size;
--    if (arguments.length) {
--        if (start < 0) {
--            newStart = Math.max(size + start, 0);
--        } else {
--            newStart = Math.min(size, start);
--        }
--    }
--
--    if (arguments.length >= 2) {
--        if (end < 0) {
--            newEnd = Math.max(size + end, 0);
--        } else {
--            newEnd = Math.min(end, size);
--        }
--    }
--
--    var newFile = new File(this.name, this.fullPath, this.type, this.lastModifiedData, this.size);
--    newFile.start = this.start + newStart;
--    newFile.end = this.start + newEnd;
--    return newFile;
--};
--
--
--module.exports = File;
--
--});
--
--// file: lib/common/plugin/FileEntry.js
--define("cordova/plugin/FileEntry", function(require, exports, module) {
--
--var utils = require('cordova/utils'),
--    exec = require('cordova/exec'),
--    Entry = require('cordova/plugin/Entry'),
--    FileWriter = require('cordova/plugin/FileWriter'),
--    File = require('cordova/plugin/File'),
--    FileError = require('cordova/plugin/FileError');
--
--/**
-- * An interface representing a file on the file system.
-- *
-- * {boolean} isFile always true (readonly)
-- * {boolean} isDirectory always false (readonly)
-- * {DOMString} name of the file, excluding the path leading to it (readonly)
-- * {DOMString} fullPath the absolute full path to the file (readonly)
-- * {FileSystem} filesystem on which the file resides (readonly)
-- */
--var FileEntry = function(name, fullPath) {
--     FileEntry.__super__.constructor.apply(this, [true, false, name, fullPath]);
--};
--
--utils.extend(FileEntry, Entry);
--
--/**
-- * Creates a new FileWriter associated with the file that this FileEntry represents.
-- *
-- * @param {Function} successCallback is called with the new FileWriter
-- * @param {Function} errorCallback is called with a FileError
-- */
--FileEntry.prototype.createWriter = function(successCallback, errorCallback) {
--    this.file(function(filePointer) {
--        var writer = new FileWriter(filePointer);
--
--        if (writer.fileName === null || writer.fileName === "") {
--            errorCallback && errorCallback(new FileError(FileError.INVALID_STATE_ERR));
--        } else {
--            successCallback && successCallback(writer);
--        }
--    }, errorCallback);
--};
--
--/**
-- * Returns a File that represents the current state of the file that this FileEntry represents.
-- *
-- * @param {Function} successCallback is called with the new File object
-- * @param {Function} errorCallback is called with a FileError
-- */
--FileEntry.prototype.file = function(successCallback, errorCallback) {
--    var win = successCallback && function(f) {
--        var file = new File(f.name, f.fullPath, f.type, f.lastModifiedDate, f.size);
--        successCallback(file);
--    };
--    var fail = errorCallback && function(code) {
--        errorCallback(new FileError(code));
--    };
--    exec(win, fail, "File", "getFileMetadata", [this.fullPath]);
--};
--
--
--module.exports = FileEntry;
--
--});
--
--// file: lib/common/plugin/FileError.js
--define("cordova/plugin/FileError", function(require, exports, module) {
--
--/**
-- * FileError
-- */
--function FileError(error) {
--  this.code = error || null;
--}
--
--// File error codes
--// Found in DOMException
--FileError.NOT_FOUND_ERR = 1;
--FileError.SECURITY_ERR = 2;
--FileError.ABORT_ERR = 3;
--
--// Added by File API specification
--FileError.NOT_READABLE_ERR = 4;
--FileError.ENCODING_ERR = 5;
--FileError.NO_MODIFICATION_ALLOWED_ERR = 6;
--FileError.INVALID_STATE_ERR = 7;
--FileError.SYNTAX_ERR = 8;
--FileError.INVALID_MODIFICATION_ERR = 9;
--FileError.QUOTA_EXCEEDED_ERR = 10;
--FileError.TYPE_MISMATCH_ERR = 11;
--FileError.PATH_EXISTS_ERR = 12;
--
--module.exports = FileError;
--
--});
--
--// file: lib/common/plugin/FileReader.js
--define("cordova/plugin/FileReader", function(require, exports, module) {
--
--var exec = require('cordova/exec'),
--    modulemapper = require('cordova/modulemapper'),
--    utils = require('cordova/utils'),
--    File = require('cordova/plugin/File'),
--    FileError = require('cordova/plugin/FileError'),
--    ProgressEvent = require('cordova/plugin/ProgressEvent'),
--    origFileReader = modulemapper.getOriginalSymbol(this, 'FileReader');
--
--/**
-- * This class reads the mobile device file system.
-- *
-- * For Android:
-- *      The root directory is the root of the file system.
-- *      To read from the SD card, the file name is "sdcard/my_file.txt"
-- * @constructor
-- */
--var FileReader = function() {
--    this._readyState = 0;
--    this._error = null;
--    this._result = null;
--    this._fileName = '';
--    this._realReader = origFileReader ? new origFileReader() : {};
--};
--
--// States
--FileReader.EMPTY = 0;
--FileReader.LOADING = 1;
--FileReader.DONE = 2;
--
--utils.defineGetter(FileReader.prototype, 'readyState', function() {
--    return this._fileName ? this._readyState : this._realReader.readyState;
--});
--
--utils.defineGetter(FileReader.prototype, 'error', function() {
--    return this._fileName ? this._error: this._realReader.error;
--});
--
--utils.defineGetter(FileReader.prototype, 'result', function() {
--    return this._fileName ? this._result: this._realReader.result;
--});
--
--function defineEvent(eventName) {
--    utils.defineGetterSetter(FileReader.prototype, eventName, function() {
--        return this._realReader[eventName] || null;
--    }, function(value) {
--        this._realReader[eventName] = value;
--    });
--}
--defineEvent('onloadstart');    // When the read starts.
--defineEvent('onprogress');     // While reading (and decoding) file or fileBlob data, and reporting partial file data (progress.loaded/progress.total)
--defineEvent('onload');         // When the read has successfully completed.
--defineEvent('onerror');        // When the read has failed (see errors).
--defineEvent('onloadend');      // When the request has completed (either in success or failure).
--defineEvent('onabort');        // When the read has been aborted. For instance, by invoking the abort() method.
--
--function initRead(reader, file) {
--    // Already loading something
--    if (reader.readyState == FileReader.LOADING) {
--      throw new FileError(FileError.INVALID_STATE_ERR);
--    }
--
--    reader._result = null;
--    reader._error = null;
--    reader._readyState = FileReader.LOADING;
--
--    if (typeof file.fullPath == 'string') {
--        reader._fileName = file.fullPath;
--    } else {
--        reader._fileName = '';
--        return true;
--    }
--
--    reader.onloadstart && reader.onloadstart(new ProgressEvent("loadstart", {target:reader}));
--}
--
--/**
-- * Abort reading file.
-- */
--FileReader.prototype.abort = function() {
--    if (origFileReader && !this._fileName) {
--        return this._realReader.abort();
--    }
--    this._result = null;
--
--    if (this._readyState == FileReader.DONE || this._readyState == FileReader.EMPTY) {
--      return;
--    }
--
--    this._readyState = FileReader.DONE;
--
--    // If abort callback
--    if (typeof this.onabort === 'function') {
--        this.onabort(new ProgressEvent('abort', {target:this}));
--    }
--    // If load end callback
--    if (typeof this.onloadend === 'function') {
--        this.onloadend(new ProgressEvent('loadend', {target:this}));
--    }
--};
--
--/**
-- * Read text file.
-- *
-- * @param file          {File} File object containing file properties
-- * @param encoding      [Optional] (see http://www.iana.org/assignments/character-sets)
-- */
--FileReader.prototype.readAsText = function(file, encoding) {
--    if (initRead(this, file)) {
--        return this._realReader.readAsText(file, encoding);
--    }
--
--    // Default encoding is UTF-8
--    var enc = encoding ? encoding : "UTF-8";
--    var me = this;
--    var execArgs = [this._fileName, enc, file.start, file.end];
--
--    // Read file
--    exec(
--        // Success callback
--        function(r) {
--            // If DONE (cancelled), then don't do anything
--            if (me._readyState === FileReader.DONE) {
--                return;
--            }
--
--            // Save result
--            me._result = r;
--
--            // If onload callback
--            if (typeof me.onload === "function") {
--                me.onload(new ProgressEvent("load", {target:me}));
--            }
--
--            // DONE state
--            me._readyState = FileReader.DONE;
--
--            // If onloadend callback
--            if (typeof me.onloadend === "function") {
--                me.onloadend(new ProgressEvent("loadend", {target:me}));
--            }
--        },
--        // Error callback
--        function(e) {
--            // If DONE (cancelled), then don't do anything
--            if (me._readyState === FileReader.DONE) {
--                return;
--            }
--
--            // DONE state
--            me._readyState = FileReader.DONE;
--
--            // null result
--            me._result = null;
--
--            // Save error
--            me._error = new FileError(e);
--
--            // If onerror callback
--            if (typeof me.onerror === "function") {
--                me.onerror(new ProgressEvent("error", {target:me}));
--            }
--
--            // If onloadend callback
--            if (typeof me.onloadend === "function") {
--                me.onloadend(new ProgressEvent("loadend", {target:me}));
--            }
--        }, "File", "readAsText", execArgs);
--};
--
--
--/**
-- * Read file and return data as a base64 encoded data url.
-- * A data url is of the form:
-- *      data:[<mediatype>][;base64],<data>
-- *
-- * @param file          {File} File object containing file properties
-- */
--FileReader.prototype.readAsDataURL = function(file) {
--    if (initRead(this, file)) {
--        return this._realReader.readAsDataURL(file);
--    }
--
--    var me = this;
--    var execArgs = [this._fileName, file.start, file.end];
--
--    // Read file
--    exec(
--        // Success callback
--        function(r) {
--            // If DONE (cancelled), then don't do anything
--            if (me._readyState === FileReader.DONE) {
--                return;
--            }
--
--            // DONE state
--            me._readyState = FileReader.DONE;
--
--            // Save result
--            me._result = r;
--
--            // If onload callback
--            if (typeof me.onload === "function") {
--                me.onload(new ProgressEvent("load", {target:me}));
--            }
--
--            // If onloadend callback
--            if (typeof me.onloadend === "function") {
--                me.onloadend(new ProgressEvent("loadend", {target:me}));
--            }
--        },
--        // Error callback
--        function(e) {
--            // If DONE (cancelled), then don't do anything
--            if (me._readyState === FileReader.DONE) {
--                return;
--            }
--
--            // DONE state
--            me._readyState = FileReader.DONE;
--
--            me._result = null;
--
--            // Save error
--            me._error = new FileError(e);
--
--            // If onerror callback
--            if (typeof me.onerror === "function") {
--                me.onerror(new ProgressEvent("error", {target:me}));
--            }
--
--            // If onloadend callback
--            if (typeof me.onloadend === "function") {
--                me.onloadend(new ProgressEvent("loadend", {target:me}));
--            }
--        }, "File", "readAsDataURL", execArgs);
--};
--
--/**
-- * Read file and return data as a binary data.
-- *
-- * @param file          {File} File object containing file properties
-- */
--FileReader.prototype.readAsBinaryString = function(file) {
--    if (initRead(this, file)) {
--        return this._realReader.readAsBinaryString(file);
--    }
--
--    var me = this;
--    var execArgs = [this._fileName, file.start, file.end];
--
--    // Read file
--    exec(
--        // Success callback
--        function(r) {
--            // If DONE (cancelled), then don't do anything
--            if (me._readyState === FileReader.DONE) {
--                return;
--            }
--
--            // DONE state
--            me._readyState = FileReader.DONE;
--
--            me._result = r;
--
--            // If onload callback
--            if (typeof me.onload === "function") {
--                me.onload(new ProgressEvent("load", {target:me}));
--            }
--
--            // If onloadend callback
--            if (typeof me.onloadend === "function") {
--                me.onloadend(new ProgressEvent("loadend", {target:me}));
--            }
--        },
--        // Error callback
--        function(e) {
--            // If DONE (cancelled), then don't do anything
--            if (me._readyState === FileReader.DONE) {
--                return;
--            }
--
--            // DONE state
--            me._readyState = FileReader.DONE;
--
--            me._result = null;
--
--            // Save error
--            me._error = new FileError(e);
--
--            // If onerror callback
--            if (typeof me.onerror === "function") {
--                me.onerror(new ProgressEvent("error", {target:me}));
--            }
--
--            // If onloadend callback
--            if (typeof me.onloadend === "function") {
--                me.onloadend(new ProgressEvent("loadend", {target:me}));
--            }
--        }, "File", "readAsBinaryString", execArgs);
--};
--
--/**
-- * Read file and return data as a binary data.
-- *
-- * @param file          {File} File object containing file properties
-- */
--FileReader.prototype.readAsArrayBuffer = function(file) {
--    if (initRead(this, file)) {
--        return this._realReader.readAsArrayBuffer(file);
--    }
--
--    var me = this;
--    var execArgs = [this._fileName, file.start, file.end];
--
--    // Read file
--    exec(
--        // Success callback
--        function(r) {
--            // If DONE (cancelled), then don't do anything
--            if (me._readyState === FileReader.DONE) {
--                return;
--            }
--
--            // DONE state
--            me._readyState = FileReader.DONE;
--
--            me._result = r;
--
--            // If onload callback
--            if (typeof me.onload === "function") {
--                me.onload(new ProgressEvent("load", {target:me}));
--            }
--
--            // If onloadend callback
--            if (typeof me.onloadend === "function") {
--                me.onloadend(new ProgressEvent("loadend", {target:me}));
--            }
--        },
--        // Error callback
--        function(e) {
--            // If DONE (cancelled), then don't do anything
--            if (me._readyState === FileReader.DONE) {
--                return;
--            }
--
--            // DONE state
--            me._readyState = FileReader.DONE;
--
--            me._result = null;
--
--            // Save error
--            me._error = new FileError(e);
--
--            // If onerror callback
--            if (typeof me.onerror === "function") {
--                me.onerror(new ProgressEvent("error", {target:me}));
--            }
--
--            // If onloadend callback
--            if (typeof me.onloadend === "function") {
--                me.onloadend(new ProgressEvent("loadend", {target:me}));
--            }
--        }, "File", "readAsArrayBuffer", execArgs);
--};
--
--module.exports = FileReader;
--
--});
--
--// file: lib/common/plugin/FileSystem.js
--define("cordova/plugin/FileSystem", function(require, exports, module) {
--
--var DirectoryEntry = require('cordova/plugin/DirectoryEntry');
--
--/**
-- * An interface representing a file system
-- *
-- * @constructor
-- * {DOMString} name the unique name of the file system (readonly)
-- * {DirectoryEntry} root directory of the file system (readonly)
-- */
--var FileSystem = function(name, root) {
--    this.name = name || null;
--    if (root) {
--        this.root = new DirectoryEntry(root.name, root.fullPath);
--    }
--};
--
--module.exports = FileSystem;
--
--});
--
--// file: lib/common/plugin/FileTransfer.js
--define("cordova/plugin/FileTransfer", function(require, exports, module) {
--
--var argscheck = require('cordova/argscheck'),
--    exec = require('cordova/exec'),
--    FileTransferError = require('cordova/plugin/FileTransferError'),
--    ProgressEvent = require('cordova/plugin/ProgressEvent');
--
--function newProgressEvent(result) {
--    var pe = new ProgressEvent();
--    pe.lengthComputable = result.lengthComputable;
--    pe.loaded = result.loaded;
--    pe.total = result.total;
--    return pe;
--}
--
--function getBasicAuthHeader(urlString) {
--    var header =  null;
--
--    if (window.btoa) {
--        // parse the url using the Location object
--        var url = document.createElement('a');
--        url.href = urlString;
--
--        var credentials = null;
--        var protocol = url.protocol + "//";
--        var origin = protocol + url.host;
--
--        // check whether there are the username:password credentials in the url
--        if (url.href.indexOf(origin) !== 0) { // credentials found
--            var atIndex = url.href.indexOf("@");
--            credentials = url.href.substring(protocol.length, atIndex);
--        }
--
--        if (credentials) {
--            var authHeader = "Authorization";
--            var authHeaderValue = "Basic " + window.btoa(credentials);
--
--            header = {
--                name : authHeader,
--                value : authHeaderValue
--            };
--        }
--    }
--
--    return header;
--}
--
--var idCounter = 0;
--
--/**
-- * FileTransfer uploads a file to a remote server.
-- * @constructor
-- */
--var FileTransfer = function() {
--    this._id = ++idCounter;
--    this.onprogress = null; // optional callback
--};
--
--/**
--* Given an absolute file path, uploads a file on the device to a remote server
--* using a multipart HTTP request.
--* @param filePath {String}           Full path of the file on the device
--* @param server {String}             URL of the server to receive the file
--* @param successCallback (Function}  Callback to be invoked when upload has completed
--* @param errorCallback {Function}    Callback to be invoked upon error
--* @param options {FileUploadOptions} Optional parameters such as file name and mimetype
--* @param trustAllHosts {Boolean} Optional trust all hosts (e.g. for self-signed certs), defaults to false
--*/
--FileTransfer.prototype.upload = function(filePath, server, successCallback, errorCallback, options, trustAllHosts) {
--    argscheck.checkArgs('ssFFO*', 'FileTransfer.upload', arguments);
--    // check for options
--    var fileKey = null;
--    var fileName = null;
--    var mimeType = null;
--    var params = null;
--    var chunkedMode = true;
--    var headers = null;
--    var httpMethod = null;
--    var basicAuthHeader = getBasicAuthHeader(server);
--    if (basicAuthHeader) {
--        options = options || {};
--        options.headers = options.headers || {};
--        options.headers[basicAuthHeader.name] = basicAuthHeader.value;
--    }
--
--    if (options) {
--        fileKey = options.fileKey;
--        fileName = options.fileName;
--        mimeType = options.mimeType;
--        headers = options.headers;
--        httpMethod = options.httpMethod || "POST";
--        if (httpMethod.toUpperCase() == "PUT"){
--            httpMethod = "PUT";
--        } else {
--            httpMethod = "POST";
--        }
--        if (options.chunkedMode !== null || typeof options.chunkedMode != "undefined") {
--            chunkedMode = options.chunkedMode;
--        }
--        if (options.params) {
--            params = options.params;
--        }
--        else {
--            params = {};
--        }
--    }
--
--    var fail = errorCallback && function(e) {
--        var error = new FileTransferError(e.code, e.source, e.target, e.http_status, e.body);
--        errorCallback(error);
--    };
--
--    var self = this;
--    var win = function(result) {
--        if (typeof result.lengthComputable != "undefined") {
--            if (self.onprogress) {
--                self.onprogress(newProgressEvent(result));
--            }
--        } else {
--            successCallback && successCallback(result);
--        }
--    };
--    exec(win, fail, 'FileTransfer', 'upload', [filePath, server, fileKey, fileName, mimeType, params, trustAllHosts, chunkedMode, headers, this._id, httpMethod]);
--};
--
--/**
-- * Downloads a file form a given URL and saves it to the specified directory.
-- * @param source {String}          URL of the server to receive the file
-- * @param target {String}         Full path of the file on the device
-- * @param successCallback (Function}  Callback to be invoked when upload has completed
-- * @param errorCallback {Function}    Callback to be invoked upon error
-- * @param trustAllHosts {Boolean} Optional trust all hosts (e.g. for self-signed certs), defaults to false
-- * @param options {FileDownloadOptions} Optional parameters such as headers
-- */
--FileTransfer.prototype.download = function(source, target, successCallback, errorCallback, trustAllHosts, options) {
--    argscheck.checkArgs('ssFF*', 'FileTransfer.download', arguments);
--    var self = this;
--
--    var basicAuthHeader = getBasicAuthHeader(source);
--    if (basicAuthHeader) {
--        options = options || {};
--        options.headers = options.headers || {};
--        options.headers[basicAuthHeader.name] = basicAuthHeader.value;
--    }
--
--    var headers = null;
--    if (options) {
--        headers = options.headers || null;
--    }
--
--    var win = function(result) {
--        if (typeof result.lengthComputable != "undefined") {
--            if (self.onprogress) {
--                return self.onprogress(newProgressEvent(result));
--            }
--        } else if (successCallback) {
--            var entry = null;
--            if (result.isDirectory) {
--                entry = new (require('cordova/plugin/DirectoryEntry'))();
--            }
--            else if (result.isFile) {
--                entry = new (require('cordova/plugin/FileEntry'))();
--            }
--            entry.isDirectory = result.isDirectory;
--            entry.isFile = result.isFile;
--            entry.name = result.name;
--            entry.fullPath = result.fullPath;
--            successCallback(entry);
--        }
--    };
--
--    var fail = errorCallback && function(e) {
--        var error = new FileTransferError(e.code, e.source, e.target, e.http_status, e.body);
--        errorCallback(error);
--    };
--
--    exec(win, fail, 'FileTransfer', 'download', [source, target, trustAllHosts, this._id, headers]);
--};
--
--/**
-- * Aborts the ongoing file transfer on this object. The original error
-- * callback for the file transfer will be called if necessary.
-- */
--FileTransfer.prototype.abort = function() {
--    exec(null, null, 'FileTransfer', 'abort', [this._id]);
--};
--
--module.exports = FileTransfer;
--
--});
--
--// file: lib/common/plugin/FileTransferError.js
--define("cordova/plugin/FileTransferError", function(require, exports, module) {
--
--/**
-- * FileTransferError
-- * @constructor
-- */
--var FileTransferError = function(code, source, target, status, body) {
--    this.code = code || null;
--    this.source = source || null;
--    this.target = target || null;
--    this.http_status = status || null;
--    this.body = body || null;
--};
--
--FileTransferError.FILE_NOT_FOUND_ERR = 1;
--FileTransferError.INVALID_URL_ERR = 2;
--FileTransferError.CONNECTION_ERR = 3;
--FileTransferError.ABORT_ERR = 4;
--
--module.exports = FileTransferError;
--
--});
--
--// file: lib/common/plugin/FileUploadOptions.js
--define("cordova/plugin/FileUploadOptions", function(require, exports, module) {
--
--/**
-- * Options to customize the HTTP request used to upload files.
-- * @constructor
-- * @param fileKey {String}   Name of file request parameter.
-- * @param fileName {String}  Filename to be used by the server. Defaults to image.jpg.
-- * @param mimeType {String}  Mimetype of the uploaded file. Defaults to image/jpeg.
-- * @param params {Object}    Object with key: value params to send to the server.
-- * @param headers {Object}   Keys are header names, values are header values. Multiple
-- *                           headers of the same name are not supported.
-- */
--var FileUploadOptions = function(fileKey, fileName, mimeType, params, headers, httpMethod) {
--    this.fileKey = fileKey || null;
--    this.fileName = fileName || null;
--    this.mimeType = mimeType || null;
--    this.params = params || null;
--    this.headers = headers || null;
--    this.httpMethod = httpMethod || null;
--};
--
--module.exports = FileUploadOptions;
--
--});
--
--// file: lib/common/plugin/FileUploadResult.js
--define("cordova/plugin/FileUploadResult", function(require, exports, module) {
--
--/**
-- * FileUploadResult
-- * @constructor
-- */
--var FileUploadResult = function() {
--    this.bytesSent = 0;
--    this.responseCode = null;
--    this.response = null;
--};
--
--module.exports = FileUploadResult;
--
--});
--
--// file: lib/common/plugin/FileWriter.js
--define("cordova/plugin/FileWriter", function(require, exports, module) {
--
--var exec = require('cordova/exec'),
--    FileError = require('cordova/plugin/FileError'),
--    ProgressEvent = require('cordova/plugin/ProgressEvent');
--
--/**
-- * This class writes to the mobile device file system.
-- *
-- * For Android:
-- *      The root directory is the root of the file system.
-- *      To write to the SD card, the file name is "sdcard/my_file.txt"
-- *
-- * @constructor
-- * @param file {File} File object containing file properties
-- * @param append if true write to the end of the file, otherwise overwrite the file
-- */
--var FileWriter = function(file) {
--    this.fileName = "";
--    this.length = 0;
--    if (file) {
--        this.fileName = file.fullPath || file;
--        this.length = file.size || 0;
--    }
--    // default is to write at the beginning of the file
--    this.position = 0;
--
--    this.readyState = 0; // EMPTY
--
--    this.result = null;
--
--    // Error
--    this.error = null;
--
--    // Event handlers
--    this.onwritestart = null;   // When writing starts
--    this.onprogress = null;     // While writing the file, and reporting partial file data
--    this.onwrite = null;        // When the write has successfully completed.
--    this.onwriteend = null;     // When the request has completed (either in success or failure).
--    this.onabort = null;        // When the write has been aborted. For instance, by invoking the abort() method.
--    this.onerror = null;        // When the write has failed (see errors).
--};
--
--// States
--FileWriter.INIT = 0;
--FileWriter.WRITING = 1;
--FileWriter.DONE = 2;
--
--/**
-- * Abort writing file.
-- */
--FileWriter.prototype.abort = function() {
--    // check for invalid state
--    if (this.readyState === FileWriter.DONE || this.readyState === FileWriter.INIT) {
--        throw new FileError(FileError.INVALID_STATE_ERR);
--    }
--
--    // set error
--    this.error = new FileError(FileError.ABORT_ERR);
--
--    this.readyState = FileWriter.DONE;
--
--    // If abort callback
--    if (typeof this.onabort === "function") {
--        this.onabort(new ProgressEvent("abort", {"target":this}));
--    }
--
--    // If write end callback
--    if (typeof this.onwriteend === "function") {
--        this.onwriteend(new ProgressEvent("writeend", {"target":this}));
--    }
--};
--
--/**
-- * Writes data to the file
-- *
-- * @param data text or blob to be written
-- */
--FileWriter.prototype.write = function(data) {
--
--    var isBinary = false;
--
--    // If we don't have Blob or ArrayBuffer support, don't bother.
--    if (typeof window.Blob !== 'undefined' && typeof window.ArrayBuffer !== 'undefined') {
--
--        // Check to see if the incoming data is a blob
--        if (data instanceof Blob) {
--            var that=this;
--            var fileReader = new FileReader();
--            fileReader.onload = function() {
--                // Call this method again, with the arraybuffer as argument
--                FileWriter.prototype.write.call(that, this.result);
--            };
--            fileReader.readAsArrayBuffer(data);
--            return;
--        }
--
--        // Mark data type for safer transport over the binary bridge
--        isBinary = (data instanceof ArrayBuffer);
--    }
--
--    // Throw an exception if we are already writing a file
--    if (this.readyState === FileWriter.WRITING) {
--        throw new FileError(FileError.INVALID_STATE_ERR);
--    }
--
--    // WRITING state
--    this.readyState = FileWriter.WRITING;
--
--    var me = this;
--
--    // If onwritestart callback
--    if (typeof me.onwritestart === "function") {
--        me.onwritestart(new ProgressEvent("writestart", {"target":me}));
--    }
--
--    // Write file
--    exec(
--        // Success callback
--        function(r) {
--            // If DONE (cancelled), then don't do anything
--            if (me.readyState === FileWriter.DONE) {
--                return;
--            }
--
--            // position always increases by bytes written because file would be extended
--            me.position += r;
--            // The length of the file is now where we are done writing.
--
--            me.length = me.position;
--
--            // DONE state
--            me.readyState = FileWriter.DONE;
--
--            // If onwrite callback
--            if (typeof me.onwrite === "function") {
--                me.onwrite(new ProgressEvent("write", {"target":me}));
--            }
--
--            // If onwriteend callback
--            if (typeof me.onwriteend === "function") {
--                me.onwriteend(new ProgressEvent("writeend", {"target":me}));
--            }
--        },
--        // Error callback
--        function(e) {
--            // If DONE (cancelled), then don't do anything
--            if (me.readyState === FileWriter.DONE) {
--                return;
--            }
--
--            // DONE state
--            me.readyState = FileWriter.DONE;
--
--            // Save error
--            me.error = new FileError(e);
--
--            // If onerror callback
--            if (typeof me.onerror === "function") {
--                me.onerror(new ProgressEvent("error", {"target":me}));
--            }
--
--            // If onwriteend callback
--            if (typeof me.onwriteend === "function") {
--                me.onwriteend(new ProgressEvent("writeend", {"target":me}));
--            }
--        }, "File", "write", [this.fileName, data, this.position, isBinary]);
--};
--
--/**
-- * Moves the file pointer to the location specified.
-- *
-- * If the offset is a negative number the position of the file
-- * pointer is rewound.  If the offset is greater than the file
-- * size the position is set to the end of the file.
-- *
-- * @param offset is the location to move the file pointer to.
-- */
--FileWriter.prototype.seek = function(offset) {
--    // Throw an exception if we are already writing a file
--    if (this.readyState === FileWriter.WRITING) {
--        throw new FileError(FileError.INVALID_STATE_ERR);
--    }
--
--    if (!offset && offset !== 0) {
--        return;
--    }
--
--    // See back from end of file.
--    if (offset < 0) {
--        this.position = Math.max(offset + this.length, 0);
--    }
--    // Offset is bigger than file size so set position
--    // to the end of the file.
--    else if (offset > this.length) {
--        this.position = this.length;
--    }
--    // Offset is between 0 and file size so set the position
--    // to start writing.
--    else {
--        this.position = offset;
--    }
--};
--
--/**
-- * Truncates the file to the size specified.
-- *
-- * @param size to chop the file at.
-- */
--FileWriter.prototype.truncate = function(size) {
--    // Throw an exception if we are already writing a file
--    if (this.readyState === FileWriter.WRITING) {
--        throw new FileError(FileError.INVALID_STATE_ERR);
--    }
--
--    // WRITING state
--    this.readyState = FileWriter.WRITING;
--
--    var me = this;
--
--    // If onwritestart callback
--    if (typeof me.onwritestart === "function") {
--        me.onwritestart(new ProgressEvent("writestart", {"target":this}));
--    }
--
--    // Write file
--    exec(
--        // Success callback
--        function(r) {
--            // If DONE (cancelled), then don't do anything
--            if (me.readyState === FileWriter.DONE) {
--                return;
--            }
--
--            // DONE state
--            me.readyState = FileWriter.DONE;
--
--            // Update the length of the file
--            me.length = r;
--            me.position = Math.min(me.position, r);
--
--            // If onwrite callback
--            if (typeof me.onwrite === "function") {
--                me.onwrite(new ProgressEvent("write", {"target":me}));
--            }
--
--            // If onwriteend callback
--            if (typeof me.onwriteend === "function") {
--                me.onwriteend(new ProgressEvent("writeend", {"target":me}));
--            }
--        },
--        // Error callback
--        function(e) {
--            // If DONE (cancelled), then don't do anything
--            if (me.readyState === FileWriter.DONE) {
--                return;
--            }
--
--            // DONE state
--            me.readyState = FileWriter.DONE;
--
--            // Save error
--            me.error = new FileError(e);
--
--            // If onerror callback
--            if (typeof me.onerror === "function") {
--                me.onerror(new ProgressEvent("error", {"target":me}));
--            }
--
--            // If onwriteend callback
--            if (typeof me.onwriteend === "function") {
--                me.onwriteend(new ProgressEvent("writeend", {"target":me}));
--            }
--        }, "File", "truncate", [this.fileName, size]);
--};
--
--module.exports = FileWriter;
--
--});
--
--// file: lib/common/plugin/Flags.js
--define("cordova/plugin/Flags", function(require, exports, module) {
--
--/**
-- * Supplies arguments to methods that lookup or create files and directories.
-- *
-- * @param create
-- *            {boolean} file or directory if it doesn't exist
-- * @param exclusive
-- *            {boolean} used with create; if true the command will fail if
-- *            target path exists
-- */
--function Flags(create, exclusive) {
--    this.create = create || false;
--    this.exclusive = exclusive || false;
--}
--
--module.exports = Flags;
--
--});
--
--// file: lib/common/plugin/GlobalizationError.js
--define("cordova/plugin/GlobalizationError", function(require, exports, module) {
--
--
--/**
-- * Globalization error object
-- *
-- * @constructor
-- * @param code
-- * @param message
-- */
--var GlobalizationError = function(code, message) {
--    this.code = code || null;
--    this.message = message || '';
--};
--
--// Globalization error codes
--GlobalizationError.UNKNOWN_ERROR = 0;
--GlobalizationError.FORMATTING_ERROR = 1;
--GlobalizationError.PARSING_ERROR = 2;
--GlobalizationError.PATTERN_ERROR = 3;
--
--module.exports = GlobalizationError;
--
--});
--
--// file: lib/common/plugin/InAppBrowser.js
--define("cordova/plugin/InAppBrowser", function(require, exports, module) {
--
--var exec = require('cordova/exec');
--var channel = require('cordova/channel');
--var modulemapper = require('cordova/modulemapper');
--
--function InAppBrowser() {
--   this.channels = {
--        'loadstart': channel.create('loadstart'),
--        'loadstop' : channel.create('loadstop'),
--        'loaderror' : channel.create('loaderror'),
--        'exit' : channel.create('exit')
--   };
--}
--
--InAppBrowser.prototype = {
--    _eventHandler: function (event) {
--        if (event.type in this.channels) {
--            this.channels[event.type].fire(event);
--        }
--    },
--    close: function (eventname) {
--        exec(null, null, "InAppBrowser", "close", []);
--    },
--    show: function (eventname) {
--      exec(null, null, "InAppBrowser", "show", []);
--    },
--    addEventListener: function (eventname,f) {
--        if (eventname in this.channels) {
--            this.channels[eventname].subscribe(f);
--        }
--    },
--    removeEventListener: function(eventname, f) {
--        if (eventname in this.channels) {
--            this.channels[eventname].unsubscribe(f);
--        }
--    },
--
--    executeScript: function(injectDetails, cb) {
--        if (injectDetails.code) {
--            exec(cb, null, "InAppBrowser", "injectScriptCode", [injectDetails.code, !!cb]);
--        } else if (injectDetails.file) {
--            exec(cb, null, "InAppBrowser", "injectScriptFile", [injectDetails.file, !!cb]);
--        } else {
--            throw new Error('executeScript requires exactly one of code or file to be specified');
--        }
--    },
--
--    insertCSS: function(injectDetails, cb) {
--        if (injectDetails.code) {
--            exec(cb, null, "InAppBrowser", "injectStyleCode", [injectDetails.code, !!cb]);
--        } else if (injectDetails.file) {
--            exec(cb, null, "InAppBrowser", "injectStyleFile", [injectDetails.file, !!cb]);
--        } else {
--            throw new Error('insertCSS requires exactly one of code or file to be specified');
--        }
--    }
--};
--
--module.exports = function(strUrl, strWindowName, strWindowFeatures) {
--    var iab = new InAppBrowser();
--    var cb = function(eventname) {
--       iab._eventHandler(eventname);
--    };
--
--    // Don't catch calls that write to existing frames (e.g. named iframes).
--    if (window.frames && window.frames[strWindowName]) {
--        var origOpenFunc = modulemapper.getOriginalSymbol(window, 'open');
--        return origOpenFunc.apply(window, arguments);
--    }
--
--    exec(cb, cb, "InAppBrowser", "open", [strUrl, strWindowName, strWindowFeatures]);
--    return iab;
--};
--
--
--});
--
--// file: lib/common/plugin/LocalFileSystem.js
--define("cordova/plugin/LocalFileSystem", function(require, exports, module) {
--
--var exec = require('cordova/exec');
--
--/**
-- * Represents a local file system.
-- */
--var LocalFileSystem = function() {
--
--};
--
--LocalFileSystem.TEMPORARY = 0; //temporary, with no guarantee of persistence
--LocalFileSystem.PERSISTENT = 1; //persistent
--
--module.exports = LocalFileSystem;
--
--});
--
--// file

<TRUNCATED>

Mime
View raw message