You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@cordova.apache.org by gt...@apache.org on 2012/11/02 15:14:50 UTC
[2/4] Updated BlackBerry to only use one javascript
http://git-wip-us.apache.org/repos/asf/incubator-cordova-blackberry-webworks/blob/7e385cb5/javascript/cordova.blackberry.js
----------------------------------------------------------------------
diff --git a/javascript/cordova.blackberry.js b/javascript/cordova.blackberry.js
index cdd95f1..7890da6 100644
--- a/javascript/cordova.blackberry.js
+++ b/javascript/cordova.blackberry.js
@@ -1,6 +1,6 @@
-// commit 02b91c5313ff37d74a58f71775170afd360f4a1f
+// commit 0919268c22c87e3b2640999d963ae074a33d445e
-// File generated at :: Wed Oct 31 2012 14:46:38 GMT-0700 (PDT)
+// File generated at :: Fri Nov 02 2012 09:45:24 GMT-0400 (EDT)
/*
Licensed to the Apache Software Foundation (ASF) under one
@@ -912,11 +912,11 @@ module.exports = {
});
-// file: lib/webworks/exec.js
+// file: lib/blackberry/exec.js
define("cordova/exec", function(require, exports, module) {
-var manager = require('cordova/plugin/manager'),
- cordova = require('cordova'),
+var cordova = require('cordova'),
+ platform = require('cordova/platform'),
utils = require('cordova/utils');
/**
@@ -936,7 +936,8 @@ var manager = require('cordova/plugin/manager'),
module.exports = function(success, fail, service, action, args) {
try {
- var v = manager.exec(success, fail, service, action, args);
+ var manager = require('cordova/plugin/' + platform.runtime() + '/manager'),
+ v = manager.exec(success, fail, service, action, args);
// If status is OK, then return value back to caller
if (v.status == cordova.callbackStatus.OK) {
@@ -976,170 +977,33 @@ module.exports = function(success, fail, service, action, args) {
});
-// file: lib/webworks/java/platform.js
+// file: lib/blackberry/platform.js
define("cordova/platform", function(require, exports, module) {
module.exports = {
id: "blackberry",
- initialize:function() {
- var cordova = require('cordova'),
- exec = require('cordova/exec'),
- channel = require('cordova/channel'),
- manager = require('cordova/plugin/manager'),
- app = require('cordova/plugin/java/app');
-
- // BB OS 5 does not define window.console.
- if (typeof window.console === 'undefined') {
- window.console = {};
+ runtime: function () {
+ var version = blackberry.system.softwareVersion;
+ window.wtf = version;
+ if (version.match(/^10/)) {
+ return 'qnx';
}
-
- // Override console.log with native logging ability.
- // BB OS 7 devices define console.log for use with web inspector
- // debugging. If console.log is already defined, invoke it in addition
- // to native logging.
- var origLog = window.console.log;
- window.console.log = function(msg) {
- if (typeof origLog === 'function') {
- origLog.call(window.console, msg);
- }
- org.apache.cordova.Logger.log(''+msg);
- };
-
- // Mapping of button events to BlackBerry key identifier.
- var buttonMapping = {
- 'backbutton' : blackberry.system.event.KEY_BACK,
- 'conveniencebutton1' : blackberry.system.event.KEY_CONVENIENCE_1,
- 'conveniencebutton2' : blackberry.system.event.KEY_CONVENIENCE_2,
- 'endcallbutton' : blackberry.system.event.KEY_ENDCALL,
- 'menubutton' : blackberry.system.event.KEY_MENU,
- 'startcallbutton' : blackberry.system.event.KEY_STARTCALL,
- 'volumedownbutton' : blackberry.system.event.KEY_VOLUMEDOWN,
- 'volumeupbutton' : blackberry.system.event.KEY_VOLUMEUP
- };
-
- // Generates a function which fires the specified event.
- var fireEvent = function(event) {
- return function() {
- cordova.fireDocumentEvent(event, null);
- };
- };
-
- var eventHandler = function(event) {
- return function() {
- // If we just attached the first handler, let native know we
- // need to override the hardware button.
- if (this.numHandlers) {
- blackberry.system.event.onHardwareKey(
- buttonMapping[event], fireEvent(event));
- }
- // If we just detached the last handler, let native know we
- // no longer override the hardware button.
- else {
- blackberry.system.event.onHardwareKey(
- buttonMapping[event], null);
- }
- };
- };
-
- // Inject listeners for buttons on the document.
- for (var button in buttonMapping) {
- if (buttonMapping.hasOwnProperty(button)) {
- var buttonChannel = cordova.addDocumentEventHandler(button);
- buttonChannel.onHasSubscribersChange = eventHandler(button);
- }
+ else if (version.match(/^BlackBerry/)) {
+ return 'air';
}
-
- // Fires off necessary code to pause/resume app
- var resume = function() {
- cordova.fireDocumentEvent('resume');
- manager.resume();
- };
- var pause = function() {
- cordova.fireDocumentEvent('pause');
- manager.pause();
- };
-
- /************************************************
- * Patch up the generic pause/resume listeners. *
- ************************************************/
-
- // Unsubscribe handler - turns off native backlight change
- // listener
- var onHasSubscribersChange = function() {
- // If we just attached the first handler and there are
- // no pause handlers, start the backlight system
- // listener on the native side.
- if (this.numHandlers && (channel.onResume.numHandlers + channel.onPause.numHandlers === 1)) {
- exec(backlightWin, backlightFail, "App", "detectBacklight", []);
- } else if (channel.onResume.numHandlers === 0 && channel.onPause.numHandlers === 0) {
- exec(null, null, 'App', 'ignoreBacklight', []);
- }
- };
-
- // Native backlight detection win/fail callbacks
- var backlightWin = function(isOn) {
- if (isOn === true) {
- resume();
- } else {
- pause();
- }
- };
- var backlightFail = function(e) {
- console.log("Error detecting backlight on/off.");
- };
-
- // Override stock resume and pause listeners so we can trigger
- // some native methods during attach/remove
- channel.onResume = cordova.addDocumentEventHandler('resume');
- channel.onResume.onHasSubscribersChange = onHasSubscribersChange;
- channel.onPause = cordova.addDocumentEventHandler('pause');
- channel.onPause.onHasSubscribersChange = onHasSubscribersChange;
-
- // Fire resume event when application brought to foreground.
- blackberry.app.event.onForeground(resume);
-
- // Fire pause event when application sent to background.
- blackberry.app.event.onBackground(pause);
-
- // Trap BlackBerry WebWorks exit. Allow plugins to clean up before exiting.
- blackberry.app.event.onExit(app.exitApp);
- },
- objects: {
- navigator: {
- children: {
- app: {
- path: "cordova/plugin/java/app"
- }
- }
- },
- File: { // exists natively on BlackBerry OS 7, override
- path: "cordova/plugin/File"
+ else {
+ return 'java';
}
},
- merges: {
- navigator: {
- children: {
- contacts: {
- path: 'cordova/plugin/java/contacts'
- },
- notification: {
- path: 'cordova/plugin/java/notification'
- }
- }
- },
- Contact: {
- path: 'cordova/plugin/java/Contact'
- },
- DirectoryEntry: {
- path: 'cordova/plugin/java/DirectoryEntry'
- },
- Entry: {
- path: 'cordova/plugin/java/Entry'
- },
- MediaError: { // Exists natively on BB OS 6+, merge in Cordova specifics
- path: 'cordova/plugin/java/MediaError'
- }
- }
+ initialize: function() {
+ var builder = require('cordova/builder'),
+ platform = require('cordova/plugin/' + this.runtime() + '/platform');
+
+ builder.build(platform.objects).intoAndClobber(window);
+ builder.build(platform.merges).intoAndMerge(window);
+ platform.initialize();
+ },
+ objects: {}
};
});
@@ -3735,1722 +3599,4323 @@ module.exports = accelerometer;
});
-// file: lib/common/plugin/battery.js
-define("cordova/plugin/battery", function(require, exports, module) {
+// file: lib/blackberry/plugin/air/DirectoryEntry.js
+define("cordova/plugin/air/DirectoryEntry", function(require, exports, module) {
-/**
- * This class contains information about the current battery status.
- * @constructor
- */
-var cordova = require('cordova'),
- exec = require('cordova/exec');
+var DirectoryEntry = require('cordova/plugin/DirectoryEntry'),
+ DirectoryReader = require('cordova/plugin/air/DirectoryReader'),
+ FileEntry = require('cordova/plugin/FileEntry'),
+ FileError = require('cordova/plugin/FileError');
-function handlers() {
- return battery.channels.batterystatus.numHandlers +
- battery.channels.batterylow.numHandlers +
- battery.channels.batterycritical.numHandlers;
-}
+var validFileRe = new RegExp('^[a-zA-Z][0-9a-zA-Z._ ]*$');
-var Battery = function() {
- this._level = null;
- this._isPlugged = null;
- // Create new event handlers on the window (returns a channel instance)
- this.channels = {
- batterystatus:cordova.addWindowEventHandler("batterystatus"),
- batterylow:cordova.addWindowEventHandler("batterylow"),
- batterycritical:cordova.addWindowEventHandler("batterycritical")
- };
- for (var key in this.channels) {
- this.channels[key].onHasSubscribersChange = Battery.onHasSubscribersChange;
- }
-};
-/**
- * Event handlers for when callbacks get registered for the battery.
- * Keep track of how many handlers we have so we can start and stop the native battery listener
- * appropriately (and hopefully save on battery life!).
- */
-Battery.onHasSubscribersChange = function() {
- // If we just registered the first handler, make sure native listener is started.
- if (this.numHandlers === 1 && handlers() === 1) {
- exec(battery._status, battery._error, "Battery", "start", []);
- } else if (handlers() === 0) {
- exec(null, null, "Battery", "stop", []);
- }
-};
+module.exports = {
+ createReader : function() {
+ return new DirectoryReader(this.fullPath);
+ },
+ /**
+ * Creates or looks up a directory; override for BlackBerry.
+ *
+ * @param path
+ * {DOMString} either a relative or absolute path from this
+ * directory in which to look up or create a directory
+ * @param options
+ * {Flags} options to create or exclusively create the directory
+ * @param successCallback
+ * {Function} called with the new DirectoryEntry
+ * @param errorCallback
+ * {Function} called with a FileError
+ */
+ getDirectory : function(path, options, successCallback, errorCallback) {
+ // create directory if it doesn't exist
+ var create = (options && options.create === true) ? true : false,
+ // if true, causes failure if create is true and path already exists
+ exclusive = (options && options.exclusive === true) ? true : false,
+ // directory exists
+ exists,
+ // create a new DirectoryEntry object and invoke success callback
+ createEntry = function() {
+ var path_parts = path.split('/'),
+ name = path_parts[path_parts.length - 1],
+ dirEntry = new DirectoryEntry(name, path);
-/**
- * Callback for battery status
- *
- * @param {Object} info keys: level, isPlugged
- */
-Battery.prototype._status = function(info) {
- if (info) {
- var me = battery;
- var level = info.level;
- if (me._level !== level || me._isPlugged !== info.isPlugged) {
- // Fire batterystatus event
- cordova.fireWindowEvent("batterystatus", info);
+ // invoke success callback
+ if (typeof successCallback === 'function') {
+ successCallback(dirEntry);
+ }
+ };
- // Fire low battery event
- if (level === 20 || level === 5) {
- if (level === 20) {
- cordova.fireWindowEvent("batterylow", info);
- }
- else {
- cordova.fireWindowEvent("batterycritical", info);
- }
+ var fail = function(error) {
+ if (typeof errorCallback === 'function') {
+ errorCallback(new FileError(error));
}
- }
- me._level = level;
- me._isPlugged = info.isPlugged;
- }
-};
-
-/**
- * Error callback for battery start
- */
-Battery.prototype._error = function(e) {
- console.log("Error initializing Battery: " + e);
-};
-
-var battery = new Battery();
-
-module.exports = battery;
-
-});
+ };
-// file: lib/common/plugin/capture.js
-define("cordova/plugin/capture", function(require, exports, module) {
+ // invalid path
+ if(!validFileRe.exec(path)){
+ fail(FileError.ENCODING_ERR);
+ return;
+ }
-var exec = require('cordova/exec'),
- MediaFile = require('cordova/plugin/MediaFile');
+ // determine if path is relative or absolute
+ if (!path) {
+ fail(FileError.ENCODING_ERR);
+ return;
+ } else if (path.indexOf(this.fullPath) !== 0) {
+ // path does not begin with the fullPath of this directory
+ // therefore, it is relative
+ path = this.fullPath + '/' + path;
+ }
-/**
- * Launches a capture of different types.
- *
- * @param (DOMString} type
- * @param {Function} successCB
- * @param {Function} errorCB
- * @param {CaptureVideoOptions} options
- */
-function _capture(type, successCallback, errorCallback, options) {
- var win = function(pluginResult) {
- var mediaFiles = [];
- var i;
- for (i = 0; i < pluginResult.length; i++) {
- var mediaFile = new MediaFile();
- mediaFile.name = pluginResult[i].name;
- mediaFile.fullPath = pluginResult[i].fullPath;
- mediaFile.type = pluginResult[i].type;
- mediaFile.lastModifiedDate = pluginResult[i].lastModifiedDate;
- mediaFile.size = pluginResult[i].size;
- mediaFiles.push(mediaFile);
+ // determine if directory exists
+ try {
+ // will return true if path exists AND is a directory
+ exists = blackberry.io.dir.exists(path);
+ } catch (e) {
+ // invalid path
+ // TODO this will not work on playbook - need to think how to find invalid urls
+ fail(FileError.ENCODING_ERR);
+ return;
}
- successCallback(mediaFiles);
- };
- exec(win, errorCallback, "Capture", type, [options]);
-}
-/**
- * The Capture interface exposes an interface to the camera and microphone of the hosting device.
- */
-function Capture() {
- this.supportedAudioModes = [];
- this.supportedImageModes = [];
- this.supportedVideoModes = [];
-}
-/**
- * Launch audio recorder application for recording audio clip(s).
- *
- * @param {Function} successCB
- * @param {Function} errorCB
- * @param {CaptureAudioOptions} options
- */
-Capture.prototype.captureAudio = function(successCallback, errorCallback, options){
- _capture("captureAudio", successCallback, errorCallback, options);
-};
-/**
- * Launch camera application for taking image(s).
- *
- * @param {Function} successCB
- * @param {Function} errorCB
- * @param {CaptureImageOptions} options
- */
-Capture.prototype.captureImage = function(successCallback, errorCallback, options){
- _capture("captureImage", successCallback, errorCallback, options);
-};
+ // path is a directory
+ if (exists) {
+ if (create && exclusive) {
+ // can't guarantee exclusivity
+ fail(FileError.PATH_EXISTS_ERR);
+ } else {
+ // create entry for existing directory
+ createEntry();
+ }
+ }
+ // will return true if path exists AND is a file
+ else if (blackberry.io.file.exists(path)) {
+ // the path is a file
+ fail(FileError.TYPE_MISMATCH_ERR);
+ }
+ // path does not exist, create it
+ else if (create) {
+ try {
+ // directory path must have trailing slash
+ var dirPath = path;
+ if (dirPath.substr(-1) !== '/') {
+ dirPath += '/';
+ }
+ console.log('creating dir path at: ' + dirPath);
+ blackberry.io.dir.createNewDir(dirPath);
+ createEntry();
+ } catch (eone) {
+ // unable to create directory
+ fail(FileError.NOT_FOUND_ERR);
+ }
+ }
+ // path does not exist, don't create
+ else {
+ // directory doesn't exist
+ fail(FileError.NOT_FOUND_ERR);
+ }
+ },
-/**
- * Launch device camera application for recording video(s).
- *
- * @param {Function} successCB
- * @param {Function} errorCB
- * @param {CaptureVideoOptions} options
- */
-Capture.prototype.captureVideo = function(successCallback, errorCallback, options){
- _capture("captureVideo", successCallback, errorCallback, options);
-};
+ /**
+ * Create or look up a file.
+ *
+ * @param path {DOMString}
+ * either a relative or absolute path from this directory in
+ * which to look up or create a file
+ * @param options {Flags}
+ * options to create or exclusively create the file
+ * @param successCallback {Function}
+ * called with the new FileEntry object
+ * @param errorCallback {Function}
+ * called with a FileError object if error occurs
+ */
+ getFile : function(path, options, successCallback, errorCallback) {
+ // create file if it doesn't exist
+ var create = (options && options.create === true) ? true : false,
+ // if true, causes failure if create is true and path already exists
+ exclusive = (options && options.exclusive === true) ? true : false,
+ // file exists
+ exists,
+ // create a new FileEntry object and invoke success callback
+ createEntry = function() {
+ var path_parts = path.split('/'),
+ name = path_parts[path_parts.length - 1],
+ fileEntry = new FileEntry(name, path);
+ // invoke success callback
+ if (typeof successCallback === 'function') {
+ successCallback(fileEntry);
+ }
+ };
-module.exports = new Capture();
+ var fail = function(error) {
+ if (typeof errorCallback === 'function') {
+ errorCallback(new FileError(error));
+ }
+ };
-});
+ // invalid path
+ if(!validFileRe.exec(path)){
+ fail(FileError.ENCODING_ERR);
+ return;
+ }
+ // determine if path is relative or absolute
+ if (!path) {
+ fail(FileError.ENCODING_ERR);
+ return;
+ }
+ else if (path.indexOf(this.fullPath) !== 0) {
+ // path does not begin with the fullPath of this directory
+ // therefore, it is relative
+ path = this.fullPath + '/' + path;
+ }
-// file: lib/common/plugin/compass.js
-define("cordova/plugin/compass", function(require, exports, module) {
+ // determine if file exists
+ try {
+ // will return true if path exists AND is a file
+ exists = blackberry.io.file.exists(path);
+ }
+ catch (e) {
+ // invalid path
+ fail(FileError.ENCODING_ERR);
+ return;
+ }
-var exec = require('cordova/exec'),
- utils = require('cordova/utils'),
- CompassHeading = require('cordova/plugin/CompassHeading'),
- CompassError = require('cordova/plugin/CompassError'),
- timers = {},
- compass = {
- /**
- * Asynchronously acquires the current heading.
- * @param {Function} successCallback The function to call when the heading
- * data is available
- * @param {Function} errorCallback The function to call when there is an error
- * getting the heading data.
- * @param {CompassOptions} options The options for getting the heading data (not used).
- */
- getCurrentHeading:function(successCallback, errorCallback, options) {
- // successCallback required
- if (typeof successCallback !== "function") {
- console.log("Compass Error: successCallback is not a function");
- return;
+ // path is a file
+ if (exists) {
+ if (create && exclusive) {
+ // can't guarantee exclusivity
+ fail(FileError.PATH_EXISTS_ERR);
}
-
- // errorCallback optional
- if (errorCallback && (typeof errorCallback !== "function")) {
- console.log("Compass Error: errorCallback is not a function");
- return;
+ else {
+ // create entry for existing file
+ createEntry();
}
+ }
+ // will return true if path exists AND is a directory
+ else if (blackberry.io.dir.exists(path)) {
+ // the path is a directory
+ fail(FileError.TYPE_MISMATCH_ERR);
+ }
+ // path does not exist, create it
+ else if (create) {
+ // create empty file
+ var emptyBlob = blackberry.utils.stringToBlob('');
+ blackberry.io.file.saveFile(path,emptyBlob);
+ createEntry();
+ }
+ // path does not exist, don't create
+ else {
+ // file doesn't exist
+ fail(FileError.NOT_FOUND_ERR);
+ }
+ },
- var win = function(result) {
- var ch = new CompassHeading(result.magneticHeading, result.trueHeading, result.headingAccuracy, result.timestamp);
- successCallback(ch);
- };
- var fail = function(code) {
- var ce = new CompassError(code);
- errorCallback(ce);
- };
-
- // Get heading
- exec(win, fail, "Compass", "getHeading", [options]);
- },
-
- /**
- * Asynchronously acquires the heading repeatedly at a given interval.
- * @param {Function} successCallback The function to call each time the heading
- * data is available
- * @param {Function} errorCallback The function to call when there is an error
- * getting the heading data.
- * @param {HeadingOptions} options The options for getting the heading data
- * such as timeout and the frequency of the watch. For iOS, filter parameter
- * specifies to watch via a distance filter rather than time.
- */
- watchHeading:function(successCallback, errorCallback, options) {
- // Default interval (100 msec)
- var frequency = (options !== undefined && options.frequency !== undefined) ? options.frequency : 100;
- var filter = (options !== undefined && options.filter !== undefined) ? options.filter : 0;
-
- // successCallback required
- if (typeof successCallback !== "function") {
- console.log("Compass Error: successCallback is not a function");
- return;
- }
+ /**
+ * Delete a directory and all of it's contents.
+ *
+ * @param successCallback {Function} called with no parameters
+ * @param errorCallback {Function} called with a FileError
+ */
+ removeRecursively : function(successCallback, errorCallback) {
+ // we're removing THIS directory
+ var path = this.fullPath;
- // errorCallback optional
- if (errorCallback && (typeof errorCallback !== "function")) {
- console.log("Compass Error: errorCallback is not a function");
- return;
+ var fail = function(error) {
+ if (typeof errorCallback === 'function') {
+ errorCallback(new FileError(error));
}
+ };
- var id = utils.createUUID();
- if (filter > 0) {
- // is an iOS request for watch by filter, no timer needed
- timers[id] = "iOS";
- compass.getCurrentHeading(successCallback, errorCallback, options);
- } else {
- // Start watch timer to get headings
- timers[id] = window.setInterval(function() {
- compass.getCurrentHeading(successCallback, errorCallback);
- }, frequency);
+ // attempt to delete directory
+ if (blackberry.io.dir.exists(path)) {
+ // it is an error to attempt to remove the file system root
+ //exec(null, null, "File", "isFileSystemRoot", [ path ]) === true
+ if (false) {
+ fail(FileError.NO_MODIFICATION_ALLOWED_ERR);
}
-
- return id;
- },
-
- /**
- * Clears the specified heading watch.
- * @param {String} watchId The ID of the watch returned from #watchHeading.
- */
- clearWatch:function(id) {
- // Stop javascript timer & remove from timer list
- if (id && timers[id]) {
- if (timers[id] != "iOS") {
- clearInterval(timers[id]);
- } else {
- // is iOS watch by filter so call into device to stop
- exec(null, null, "Compass", "stopHeading", []);
+ else {
+ try {
+ // delete the directory, setting recursive flag to true
+ blackberry.io.dir.deleteDirectory(path, true);
+ if (typeof successCallback === "function") {
+ successCallback();
+ }
+ } catch (e) {
+ // permissions don't allow deletion
+ console.log(e);
+ fail(FileError.NO_MODIFICATION_ALLOWED_ERR);
}
- delete timers[id];
}
}
- };
-
-module.exports = compass;
+ // it's a file, not a directory
+ else if (blackberry.io.file.exists(path)) {
+ fail(FileError.TYPE_MISMATCH_ERR);
+ }
+ // not found
+ else {
+ fail(FileError.NOT_FOUND_ERR);
+ }
+ }
+};
});
-// file: lib/common/plugin/console-via-logger.js
-define("cordova/plugin/console-via-logger", function(require, exports, module) {
-
-//------------------------------------------------------------------------------
-
-var logger = require("cordova/plugin/logger");
-var utils = require("cordova/utils");
+// file: lib/blackberry/plugin/air/DirectoryReader.js
+define("cordova/plugin/air/DirectoryReader", function(require, exports, module) {
-//------------------------------------------------------------------------------
-// object that we're exporting
-//------------------------------------------------------------------------------
-var console = module.exports;
+var FileError = require('cordova/plugin/FileError');
-//------------------------------------------------------------------------------
-// copy of the original console object
-//------------------------------------------------------------------------------
-var WinConsole = window.console;
+/**
+ * An interface that lists the files and directories in a directory.
+ */
+function DirectoryReader(path) {
+ this.path = path || null;
+}
-//------------------------------------------------------------------------------
-// whether to use the logger
-//------------------------------------------------------------------------------
-var UseLogger = false;
+/**
+ * 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));
+ };
-//------------------------------------------------------------------------------
-// Timers
-//------------------------------------------------------------------------------
-var Timers = {};
+ var theEntries = [];
+ // Entry object is borked - unable to instantiate a new Entry object so just create one
+ var anEntry = function (isDirectory, name, fullPath) {
+ this.isDirectory = (isDirectory ? true : false);
+ this.isFile = (isDirectory ? false : true);
+ this.name = name;
+ this.fullPath = fullPath;
+ };
-//------------------------------------------------------------------------------
-// used for unimplemented methods
-//------------------------------------------------------------------------------
-function noop() {}
+ if(blackberry.io.dir.exists(this.path)){
+ var theDirectories = blackberry.io.dir.listDirectories(this.path);
+ var theFiles = blackberry.io.dir.listFiles(this.path);
-//------------------------------------------------------------------------------
-// used for unimplemented methods
-//------------------------------------------------------------------------------
-console.useLogger = function (value) {
- if (arguments.length) UseLogger = !!value;
+ var theDirectoriesLength = theDirectories.length;
+ var theFilesLength = theFiles.length;
+ for(var i=0;i<theDirectoriesLength;i++){
+ theEntries.push(new anEntry(true, theDirectories[i], this.path+theDirectories[i]));
+ }
- if (UseLogger) {
- if (logger.useConsole()) {
- throw new Error("console and logger are too intertwingly");
+ for(var j=0;j<theFilesLength;j++){
+ theEntries.push(new anEntry(false, theFiles[j], this.path+theFiles[j]));
}
+ win(theEntries);
+ }else{
+ fail(FileError.NOT_FOUND_ERR);
}
- return UseLogger;
-};
-//------------------------------------------------------------------------------
-console.log = function() {
- if (logger.useConsole()) return;
- logger.log.apply(logger, [].slice.call(arguments));
};
-//------------------------------------------------------------------------------
-console.error = function() {
- if (logger.useConsole()) return;
- logger.error.apply(logger, [].slice.call(arguments));
-};
+module.exports = DirectoryReader;
-//------------------------------------------------------------------------------
-console.warn = function() {
- if (logger.useConsole()) return;
- logger.warn.apply(logger, [].slice.call(arguments));
-};
+});
-//------------------------------------------------------------------------------
-console.info = function() {
- if (logger.useConsole()) return;
- logger.info.apply(logger, [].slice.call(arguments));
-};
+// file: lib/blackberry/plugin/air/Entry.js
+define("cordova/plugin/air/Entry", function(require, exports, module) {
-//------------------------------------------------------------------------------
-console.debug = function() {
- if (logger.useConsole()) return;
- logger.debug.apply(logger, [].slice.call(arguments));
-};
+var FileError = require('cordova/plugin/FileError'),
+ LocalFileSystem = require('cordova/plugin/LocalFileSystem'),
+ Metadata = require('cordova/plugin/Metadata'),
+ resolveLocalFileSystemURI = require('cordova/plugin/air/resolveLocalFileSystemURI'),
+ DirectoryEntry = require('cordova/plugin/DirectoryEntry'),
+ FileEntry = require('cordova/plugin/FileEntry'),
+ requestFileSystem = require('cordova/plugin/air/requestFileSystem');
-//------------------------------------------------------------------------------
-console.assert = function(expression) {
- if (expression) return;
+var recursiveCopy = function(srcDirPath, dstDirPath){
+ // get all the contents (file+dir) of the dir
+ var files = blackberry.io.dir.listFiles(srcDirPath);
+ var dirs = blackberry.io.dir.listDirectories(srcDirPath);
- var message = utils.vformat(arguments[1], [].slice.call(arguments, 2));
- console.log("ASSERT: " + message);
+ for(var i=0;i<files.length;i++){
+ blackberry.io.file.copy(srcDirPath + '/' + files[i], dstDirPath + '/' + files[i]);
+ }
+
+ for(var j=0;j<dirs.length;j++){
+ if(!blackberry.io.dir.exists(dstDirPath + '/' + dirs[j])){
+ blackberry.io.dir.createNewDir(dstDirPath + '/' + dirs[j]);
+ }
+ recursiveCopy(srcDirPath + '/' + dirs[j], dstDirPath + '/' + dirs[j]);
+ }
};
-//------------------------------------------------------------------------------
-console.clear = function() {};
+var validFileRe = new RegExp('^[a-zA-Z][0-9a-zA-Z._ ]*$');
-//------------------------------------------------------------------------------
-console.dir = function(object) {
- console.log("%o", object);
-};
+module.exports = {
+ 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));
+ };
-//------------------------------------------------------------------------------
-console.dirxml = function(node) {
- console.log(node.innerHTML);
-};
+ if(this.isFile){
+ if(blackberry.io.file.exists(this.fullPath)){
+ var theFileProperties = blackberry.io.file.getFileProperties(this.fullPath);
+ success(theFileProperties.dateModified);
+ }
+ }else{
+ console.log('Unsupported for directories');
+ fail(FileError.INVALID_MODIFICATION_ERR);
+ }
+ },
-//------------------------------------------------------------------------------
-console.trace = noop;
+ setMetadata : function(successCallback, errorCallback , metadataObject){
+ console.log('setMetadata is unsupported for PlayBook');
+ },
-//------------------------------------------------------------------------------
-console.group = console.log;
+ 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 DirectoryEntry(entry.name, entry.fullPath) : new FileEntry(entry.name, entry.fullPath);
+ try {
+ successCallback(result);
+ }
+ catch (e) {
+ console.log('Error invoking callback: ' + e);
+ }
+ }
+ }
+ else {
+ // no Entry object returned
+ fail(FileError.NOT_FOUND_ERR);
+ }
+ };
-//------------------------------------------------------------------------------
-console.groupCollapsed = console.log;
-//------------------------------------------------------------------------------
-console.groupEnd = noop;
+ // Entry object is borked
+ var theEntry = {};
+ var dstPath = parent.fullPath + '/' + name;
-//------------------------------------------------------------------------------
-console.time = function(name) {
- Timers[name] = new Date().valueOf();
-};
+ // invalid path
+ if(!validFileRe.exec(name)){
+ fail(FileError.ENCODING_ERR);
+ return;
+ }
-//------------------------------------------------------------------------------
-console.timeEnd = function(name) {
- var timeStart = Timers[name];
- if (!timeStart) {
- console.warn("unknown timer: " + name);
- return;
- }
+ if(this.isFile){
+ if(srcPath != dstPath){
+ if(blackberry.io.file.exists(dstPath)){
+ blackberry.io.file.deleteFile(dstPath);
+ blackberry.io.file.copy(srcPath,dstPath);
+ blackberry.io.file.deleteFile(srcPath);
+
+ theEntry.fullPath = dstPath;
+ theEntry.name = name;
+ theEntry.isDirectory = false;
+ theEntry.isFile = true;
+ success(theEntry);
+ }else if(blackberry.io.dir.exists(dstPath)){
+ // destination path is a directory
+ fail(FileError.INVALID_MODIFICATION_ERR);
+ }else{
+ // make sure the directory that we are moving to actually exists
+ if(blackberry.io.dir.exists(parent.fullPath)){
+ blackberry.io.file.copy(srcPath,dstPath);
+ blackberry.io.file.deleteFile(srcPath);
+
+ theEntry.fullPath = dstPath;
+ theEntry.name = name;
+ theEntry.isDirectory = false;
+ theEntry.isFile = true;
+ success(theEntry);
+ }else{
+ fail(FileError.NOT_FOUND_ERR);
+ }
+ }
+ }else{
+ // file onto itself
+ fail(FileError.INVALID_MODIFICATION_ERR);
+ }
+ }else{
+ if(srcPath != dstPath){
+ if(blackberry.io.file.exists(dstPath) || srcPath == parent.fullPath){
+ // destination path is either a file path or moving into parent
+ fail(FileError.INVALID_MODIFICATION_ERR);
+ }else{
+ if(!blackberry.io.dir.exists(dstPath)){
+ blackberry.io.dir.createNewDir(dstPath);
+ recursiveCopy(srcPath,dstPath);
+ blackberry.io.dir.deleteDirectory(srcPath, true);
+ theEntry.fullPath = dstPath;
+ theEntry.name = name;
+ theEntry.isDirectory = true;
+ theEntry.isFile = false;
+ success(theEntry);
+ }else{
+ var numOfEntries = 0;
+ numOfEntries += blackberry.io.dir.listDirectories(dstPath).length;
+ numOfEntries += blackberry.io.dir.listFiles(dstPath).length;
+ if(numOfEntries === 0){
+ blackberry.io.dir.createNewDir(dstPath);
+ recursiveCopy(srcPath,dstPath);
+ blackberry.io.dir.deleteDirectory(srcPath, true);
+ theEntry.fullPath = dstPath;
+ theEntry.name = name;
+ theEntry.isDirectory = true;
+ theEntry.isFile = false;
+ success(theEntry);
+ }else{
+ // destination directory not empty
+ fail(FileError.INVALID_MODIFICATION_ERR);
+ }
+ }
+ }
+ }else{
+ // directory onto itself
+ fail(FileError.INVALID_MODIFICATION_ERR);
+ }
+ }
- var timeElapsed = new Date().valueOf() - timeStart;
- console.log(name + ": " + timeElapsed + "ms");
-};
+ },
-//------------------------------------------------------------------------------
-console.timeStamp = noop;
+ 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 = function(entry) {
+ if (entry) {
+ if (typeof successCallback === 'function') {
+ // create appropriate Entry object
+ var result = (entry.isDirectory) ? new DirectoryEntry(entry.name, entry.fullPath) : new FileEntry(entry.name, entry.fullPath);
+ try {
+ successCallback(result);
+ }
+ catch (e) {
+ console.log('Error invoking callback: ' + e);
+ }
+ }
+ }
+ else {
+ // no Entry object returned
+ fail(FileError.NOT_FOUND_ERR);
+ }
+ };
-//------------------------------------------------------------------------------
-console.profile = noop;
+ // Entry object is borked
+ var theEntry = {};
+ var dstPath = parent.fullPath + '/' + name;
-//------------------------------------------------------------------------------
-console.profileEnd = noop;
+ // invalid path
+ if(!validFileRe.exec(name)){
+ fail(FileError.ENCODING_ERR);
+ return;
+ }
-//------------------------------------------------------------------------------
-console.count = noop;
+ if(this.isFile){
+ if(srcPath != dstPath){
+ if(blackberry.io.file.exists(dstPath)){
+ if(blackberry.io.dir.exists(dstPath)){
+ blackberry.io.file.copy(srcPath,dstPath);
+
+ theEntry.fullPath = dstPath;
+ theEntry.name = name;
+ theEntry.isDirectory = false;
+ theEntry.isFile = true;
+ success(theEntry);
+ }else{
+ // destination directory doesn't exist
+ fail(FileError.NOT_FOUND_ERR);
+ }
-//------------------------------------------------------------------------------
-console.exception = console.log;
+ }else{
+ blackberry.io.file.copy(srcPath,dstPath);
-//------------------------------------------------------------------------------
-console.table = function(data, columns) {
- console.log("%o", data);
-};
+ theEntry.fullPath = dstPath;
+ theEntry.name = name;
+ theEntry.isDirectory = false;
+ theEntry.isFile = true;
+ success(theEntry);
+ }
+ }else{
+ // file onto itself
+ fail(FileError.INVALID_MODIFICATION_ERR);
+ }
+ }else{
+ if(srcPath != dstPath){
+ // allow back up to the root but not child dirs
+ if((parent.name != "root" && dstPath.indexOf(srcPath)>=0) || blackberry.io.file.exists(dstPath)){
+ // copying directory into child or is file path
+ fail(FileError.INVALID_MODIFICATION_ERR);
+ }else{
+ recursiveCopy(srcPath, dstPath);
+
+ theEntry.fullPath = dstPath;
+ theEntry.name = name;
+ theEntry.isDirectory = true;
+ theEntry.isFile = false;
+ success(theEntry);
+ }
+ }else{
+ // directory onto itself
+ fail(FileError.INVALID_MODIFICATION_ERR);
+ }
+ }
-//------------------------------------------------------------------------------
-// return a new function that calls both functions passed as args
-//------------------------------------------------------------------------------
-function wrappedOrigCall(orgFunc, newFunc) {
- return function() {
- var args = [].slice.call(arguments);
- try { orgFunc.apply(WinConsole, args); } catch (e) {}
- try { newFunc.apply(console, args); } catch (e) {}
- };
-}
+ },
-//------------------------------------------------------------------------------
-// For every function that exists in the original console object, that
-// also exists in the new console object, wrap the new console method
-// with one that calls both
-//------------------------------------------------------------------------------
-for (var key in console) {
- if (typeof WinConsole[key] == "function") {
- console[key] = wrappedOrigCall(WinConsole[key], console[key]);
+ remove : function(successCallback, errorCallback) {
+ var path = this.fullPath,
+ // directory contents
+ contents = [];
+
+ var fail = function(error) {
+ if (typeof errorCallback === 'function') {
+ errorCallback(new FileError(error));
+ }
+ };
+
+ // file
+ if (blackberry.io.file.exists(path)) {
+ try {
+ blackberry.io.file.deleteFile(path);
+ if (typeof successCallback === "function") {
+ successCallback();
+ }
+ } catch (e) {
+ // permissions don't allow
+ fail(FileError.INVALID_MODIFICATION_ERR);
+ }
+ }
+ // directory
+ else if (blackberry.io.dir.exists(path)) {
+ // it is an error to attempt to remove the file system root
+ console.log('entry directory');
+ // TODO: gotta figure out how to get root dirs on playbook -
+ // getRootDirs doesn't work
+ if (false) {
+ fail(FileError.NO_MODIFICATION_ALLOWED_ERR);
+ } else {
+ // check to see if directory is empty
+ contents = blackberry.io.dir.listFiles(path);
+ if (contents.length !== 0) {
+ fail(FileError.INVALID_MODIFICATION_ERR);
+ } else {
+ try {
+ // delete
+ blackberry.io.dir.deleteDirectory(path, false);
+ if (typeof successCallback === "function") {
+ successCallback();
+ }
+ } catch (eone) {
+ // permissions don't allow
+ fail(FileError.NO_MODIFICATION_ALLOWED_ERR);
+ }
+ }
+ }
+ }
+ // not found
+ else {
+ fail(FileError.NOT_FOUND_ERR);
+ }
+ },
+ getParent : function(successCallback, errorCallback) {
+ var that = this;
+
+ try {
+ // On BlackBerry, the TEMPORARY file system is actually a temporary
+ // directory that is created on a per-application basis. This is
+ // to help ensure that applications do not share the same temporary
+ // space. So we check to see if this is the TEMPORARY file system
+ // (directory). If it is, we must return this Entry, rather than
+ // the Entry for its parent.
+ requestFileSystem(LocalFileSystem.TEMPORARY, 0,
+ function(fileSystem) {
+ if (fileSystem.root.fullPath === that.fullPath) {
+ if (typeof successCallback === 'function') {
+ successCallback(fileSystem.root);
+ }
+ } else {
+ resolveLocalFileSystemURI(blackberry.io.dir
+ .getParentDirectory(that.fullPath),
+ successCallback, errorCallback);
+ }
+ }, errorCallback);
+ } catch (e) {
+ if (typeof errorCallback === 'function') {
+ errorCallback(new FileError(FileError.NOT_FOUND_ERR));
+ }
+ }
}
-}
+};
-});
-// file: lib/common/plugin/contacts.js
-define("cordova/plugin/contacts", function(require, exports, module) {
+});
-var exec = require('cordova/exec'),
- ContactError = require('cordova/plugin/ContactError'),
- utils = require('cordova/utils'),
- Contact = require('cordova/plugin/Contact');
+// file: lib/blackberry/plugin/air/File.js
+define("cordova/plugin/air/File", function(require, exports, module) {
/**
-* Represents a group of Contacts.
-* @constructor
-*/
-var contacts = {
+ * 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/blackberry/plugin/air/FileEntry.js
+define("cordova/plugin/air/FileEntry", function(require, exports, module) {
+
+var FileEntry = require('cordova/plugin/FileEntry'),
+ Entry = require('cordova/plugin/air/Entry'),
+ FileWriter = require('cordova/plugin/air/FileWriter'),
+ File = require('cordova/plugin/air/File'),
+ FileError = require('cordova/plugin/FileError');
+
+module.exports = {
/**
- * Returns an array of Contacts matching the search criteria.
- * @param fields that should be searched
- * @param successCB success callback
- * @param errorCB error callback
- * @param {ContactFindOptions} options that can be applied to contact searching
- * @return array of Contacts matching search criteria
+ * 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
*/
- find:function(fields, successCB, errorCB, options) {
- if (!successCB) {
- throw new TypeError("You must specify a success callback for the find command.");
- }
- if (!fields || (utils.isArray(fields) && fields.length === 0)) {
- if (typeof errorCB === "function") {
- errorCB(new ContactError(ContactError.INVALID_ARGUMENT_ERROR));
- }
- } else {
- var win = function(result) {
- var cs = [];
- for (var i = 0, l = result.length; i < l; i++) {
- cs.push(contacts.create(result[i]));
+ 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));
}
- successCB(cs);
- };
- exec(win, errorCB, "Contacts", "search", [fields, options]);
- }
+ } else {
+ if (typeof successCallback === "function") {
+ successCallback(writer);
+ }
+ }
+ }, errorCallback);
},
/**
- * This function creates a new contact, but it does not persist the contact
- * to device storage. To persist the contact to device storage, invoke
- * contact.save().
- * @param properties an object whose properties will be examined to create a new Contact
- * @returns new Contact object
+ * 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
*/
- create:function(properties) {
- var i;
- var contact = new Contact();
- for (i in properties) {
- if (typeof contact[i] !== 'undefined' && properties.hasOwnProperty(i)) {
- contact[i] = properties[i];
- }
+ 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));
+ };
+
+ if(blackberry.io.file.exists(this.fullPath)){
+ var theFileProperties = blackberry.io.file.getFileProperties(this.fullPath);
+ var theFile = {};
+
+ theFile.fullPath = this.fullPath;
+ theFile.type = theFileProperties.fileExtension;
+ theFile.lastModifiedDate = theFileProperties.dateModified;
+ theFile.size = theFileProperties.size;
+ win(theFile);
+ }else{
+ fail(FileError.NOT_FOUND_ERR);
}
- return contact;
}
};
-module.exports = contacts;
});
-// file: lib/common/plugin/device.js
-define("cordova/plugin/device", function(require, exports, module) {
+// file: lib/blackberry/plugin/air/FileReader.js
+define("cordova/plugin/air/FileReader", function(require, exports, module) {
-var channel = require('cordova/channel'),
- utils = require('cordova/utils'),
- exec = require('cordova/exec');
-
-// Tell cordova channel to wait on the CordovaInfoReady event
-channel.waitForInitialization('onCordovaInfoReady');
+var FileError = require('cordova/plugin/FileError'),
+ ProgressEvent = require('cordova/plugin/ProgressEvent');
/**
- * This represents the mobile device, and provides properties for inspecting the model, version, UUID of the
- * phone, etc.
+ * 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
*/
-function Device() {
- this.available = false;
- this.platform = null;
- this.version = null;
- this.name = null;
- this.uuid = null;
- this.cordova = null;
+var FileReader = function() {
+ this.fileName = "";
- var me = this;
+ this.readyState = 0; // FileReader.EMPTY
- channel.onCordovaReady.subscribe(function() {
- me.getInfo(function(info) {
- me.available = true;
- me.platform = info.platform;
- me.version = info.version;
- me.name = info.name;
- me.uuid = info.uuid;
- me.cordova = info.cordova;
- channel.onCordovaInfoReady.fire();
- },function(e) {
- me.available = false;
- utils.alert("[ERROR] Error initializing Cordova: " + e);
- });
- });
-}
+ // 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;
/**
- * Get device info
+ * 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 {Function} successCallback The function to call when the heading data is available
- * @param {Function} errorCallback The function to call when there is an error getting the heading data. (OPTIONAL)
+ * @param file {File} File object containing file properties
+ * @param encoding [Optional] (see http://www.iana.org/assignments/character-sets)
*/
-Device.prototype.getInfo = function(successCallback, errorCallback) {
+FileReader.prototype.readAsText = function(file, encoding) {
+ // Figure out pathing
+ this.fileName = '';
+ if (typeof file.fullPath === 'undefined') {
+ this.fileName = file;
+ } else {
+ this.fileName = file.fullPath;
+ }
- // successCallback required
- if (typeof successCallback !== "function") {
- console.log("Device Error: successCallback is not a function");
- return;
+ // Already loading something
+ if (this.readyState == FileReader.LOADING) {
+ throw new FileError(FileError.INVALID_STATE_ERR);
}
- // errorCallback optional
- if (errorCallback && (typeof errorCallback !== "function")) {
- console.log("Device Error: errorCallback is not a function");
- return;
+ // LOADING state
+ this.readyState = FileReader.LOADING;
+
+ // If loadstart callback
+ if (typeof this.onloadstart === "function") {
+ this.onloadstart(new ProgressEvent("loadstart", {target:this}));
}
- // Get info
- exec(successCallback, errorCallback, "Device", "getDeviceInfo", []);
-};
+ // Default encoding is UTF-8
+ var enc = encoding ? encoding : "UTF-8";
-module.exports = new Device();
+ var me = this;
+ // Read file
+ if(blackberry.io.file.exists(this.fileName)){
+ var theText = '';
+ var getFileContents = function(path,blob){
+ if(blob){
-});
+ theText = blackberry.utils.blobToString(blob, enc);
+ me.result = theText;
-// file: lib/common/plugin/echo.js
-define("cordova/plugin/echo", function(require, exports, module) {
+ if (typeof me.onload === "function") {
+ me.onload(new ProgressEvent("load", {target:me}));
+ }
+
+ me.readyState = FileReader.DONE;
+
+ if (typeof me.onloadend === "function") {
+ me.onloadend(new ProgressEvent("loadend", {target:me}));
+ }
+ }
+ };
+ // setting asynch to off
+ blackberry.io.file.readFile(this.fileName, getFileContents, false);
+
+ }else{
+ // 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(FileError.NOT_FOUND_ERR);
+
+ // 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}));
+ }
+ }
+};
-var exec = require('cordova/exec');
/**
- * Sends the given message through exec() to the Echo plugin, which sends it back to the successCallback.
- * @param successCallback invoked with a FileSystem object
- * @param errorCallback invoked if error occurs retrieving file system
- * @param message The string to be echoed.
- * @param forceAsync Whether to force an async return value (for testing native->js bridge).
+ * 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
*/
-module.exports = function(successCallback, errorCallback, message, forceAsync) {
- var action = forceAsync ? 'echoAsync' : 'echo';
- exec(successCallback, errorCallback, "Echo", action, [message]);
-};
+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}));
+ }
-// file: lib/common/plugin/geolocation.js
-define("cordova/plugin/geolocation", function(require, exports, module) {
+ var enc = "BASE64";
-var utils = require('cordova/utils'),
- exec = require('cordova/exec'),
- PositionError = require('cordova/plugin/PositionError'),
- Position = require('cordova/plugin/Position');
+ var me = this;
-var timers = {}; // list of timers in use
+ // Read file
+ if(blackberry.io.file.exists(this.fileName)){
+ var theText = '';
+ var getFileContents = function(path,blob){
+ if(blob){
+ theText = blackberry.utils.blobToString(blob, enc);
+ me.result = "data:text/plain;base64," +theText;
+
+ if (typeof me.onload === "function") {
+ me.onload(new ProgressEvent("load", {target:me}));
+ }
-// Returns default params, overrides if provided with values
-function parseParameters(options) {
- var opt = {
- maximumAge: 0,
- enableHighAccuracy: false,
- timeout: Infinity
- };
+ me.readyState = FileReader.DONE;
- if (options) {
- if (options.maximumAge !== undefined && !isNaN(options.maximumAge) && options.maximumAge > 0) {
- opt.maximumAge = options.maximumAge;
+ if (typeof me.onloadend === "function") {
+ me.onloadend(new ProgressEvent("loadend", {target:me}));
+ }
+ }
+ };
+ // setting asynch to off
+ blackberry.io.file.readFile(this.fileName, getFileContents, false);
+
+ }else{
+ // If DONE (cancelled), then don't do anything
+ if (me.readyState === FileReader.DONE) {
+ return;
}
- if (options.enableHighAccuracy !== undefined) {
- opt.enableHighAccuracy = options.enableHighAccuracy;
+
+ // DONE state
+ me.readyState = FileReader.DONE;
+
+ me.result = null;
+
+ // Save error
+ me.error = new FileError(FileError.NOT_FOUND_ERR);
+
+ // If onerror callback
+ if (typeof me.onerror === "function") {
+ me.onerror(new ProgressEvent("error", {target:me}));
}
- if (options.timeout !== undefined && !isNaN(options.timeout)) {
- if (options.timeout < 0) {
- opt.timeout = 0;
- } else {
- opt.timeout = options.timeout;
- }
+
+ // If onloadend callback
+ if (typeof me.onloadend === "function") {
+ me.onloadend(new ProgressEvent("loadend", {target:me}));
}
}
+};
- return opt;
+/**
+ * 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/blackberry/plugin/air/FileTransfer.js
+define("cordova/plugin/air/FileTransfer", function(require, exports, module) {
+
+var cordova = require('cordova'),
+FileTransferError = require('cordova/plugin/FileTransferError'),
+FileUploadResult = require('cordova/plugin/FileUploadResult');
+
+var validURLProtocol = new RegExp('^(https?|ftp):\/\/');
+
+function getParentPath(filePath) {
+ var pos = filePath.lastIndexOf('/');
+ return filePath.substring(0, pos + 1);
}
-// Returns a timeout failure, closed over a specified timeout value and error callback.
-function createTimeout(errorCallback, timeout) {
- var t = setTimeout(function() {
- clearTimeout(t);
- t = null;
- errorCallback({
- code:PositionError.TIMEOUT,
- message:"Position retrieval timed out."
- });
- }, timeout);
- return t;
+function getFileName(filePath) {
+ var pos = filePath.lastIndexOf('/');
+ return filePath.substring(pos + 1);
}
-var geolocation = {
- lastPosition:null, // reference to last known (cached) position returned
- /**
- * Asynchronously acquires the current position.
- *
- * @param {Function} successCallback The function to call when the position data is available
- * @param {Function} errorCallback The function to call when there is an error getting the heading position. (OPTIONAL)
- * @param {PositionOptions} options The options for getting the position data. (OPTIONAL)
- */
- getCurrentPosition:function(successCallback, errorCallback, options) {
- if (arguments.length === 0) {
- throw new Error("getCurrentPosition must be called with at least one argument.");
+module.exports = {
+ upload: function (args, win, fail) {
+ var filePath = args[0],
+ server = args[1],
+ fileKey = args[2],
+ fileName = args[3],
+ mimeType = args[4],
+ params = args[5],
+ trustAllHosts = args[6],
+ chunkedMode = args[7],
+ headers = args[8];
+
+ if(!validURLProtocol.exec(server)){
+ return { "status" : cordova.callbackStatus.ERROR, "message" : new FileTransferError(FileTransferError.INVALID_URL_ERR) };
}
- options = parseParameters(options);
- // Timer var that will fire an error callback if no position is retrieved from native
- // before the "timeout" param provided expires
- var timeoutTimer = {timer:null};
+ window.resolveLocalFileSystemURI(filePath, fileWin, fail);
- var win = function(p) {
- clearTimeout(timeoutTimer.timer);
- if (!(timeoutTimer.timer)) {
- // Timeout already happened, or native fired error callback for
- // this geo request.
- // Don't continue with success callback.
- return;
- }
- var pos = new Position(
- {
- latitude:p.latitude,
- longitude:p.longitude,
- altitude:p.altitude,
- accuracy:p.accuracy,
- heading:p.heading,
- velocity:p.velocity,
- altitudeAccuracy:p.altitudeAccuracy
- },
- (p.timestamp === undefined ? new Date() : ((p.timestamp instanceof Date) ? p.timestamp : new Date(p.timestamp)))
- );
- geolocation.lastPosition = pos;
- successCallback(pos);
- };
- var fail = function(e) {
- clearTimeout(timeoutTimer.timer);
- timeoutTimer.timer = null;
- var err = new PositionError(e.code, e.message);
- if (errorCallback) {
- errorCallback(err);
+ function fileWin(entryObject){
+ blackberry.io.file.readFile(filePath, readWin, false);
+ }
+
+ function readWin(filePath, blobFile){
+ var fd = new FormData();
+
+ fd.append(fileKey, blobFile, fileName);
+ for (var prop in params) {
+ if(params.hasOwnProperty(prop)) {
+ fd.append(prop, params[prop]);
+ }
}
- };
- // Check our cached position, if its timestamp difference with current time is less than the maximumAge, then just
- // fire the success callback with the cached position.
- if (geolocation.lastPosition && options.maximumAge && (((new Date()).getTime() - geolocation.lastPosition.timestamp.getTime()) <= options.maximumAge)) {
- successCallback(geolocation.lastPosition);
- // If the cached position check failed and the timeout was set to 0, error out with a TIMEOUT error object.
- } else if (options.timeout === 0) {
- fail({
- code:PositionError.TIMEOUT,
- message:"timeout value in PositionOptions set to 0 and no cached Position object available, or cached Position object's age exceeds provided PositionOptions' maximumAge parameter."
- });
- // Otherwise we have to call into native to retrieve a position.
- } else {
- if (options.timeout !== Infinity) {
- // If the timeout value was not set to Infinity (default), then
- // set up a timeout function that will fire the error callback
- // if no successful position was retrieved before timeout expired.
- timeoutTimer.timer = createTimeout(fail, options.timeout);
- } else {
- // This is here so the check in the win function doesn't mess stuff up
- // may seem weird but this guarantees timeoutTimer is
- // always truthy before we call into native
- timeoutTimer.timer = true;
+ var xhr = new XMLHttpRequest();
+ xhr.open("POST", server);
+ xhr.onload = function(evt) {
+ if (xhr.status == 200) {
+ var result = new FileUploadResult();
+ result.bytesSent = xhr.response.length;
+ result.responseCode = xhr.status;
+ result.response = xhr.response;
+ win(result);
+ } else if (xhr.status == 404) {
+ fail(new FileTransferError(FileTransferError.INVALID_URL_ERR, null, null, xhr.status));
+ } else if (xhr.status == 403) {
+ fail(new FileTransferError(FileTransferError.INVALID_URL_ERR, null, null, xhr.status));
+ } else {
+ fail(new FileTransferError(FileTransferError.CONNECTION_ERR, null, null, xhr.status));
+ }
+ };
+ xhr.ontimeout = function(evt) {
+ fail(new FileTransferError(FileTransferError.CONNECTION_ERR, null, null, xhr.status));
+ };
+
+ if(headers){
+ for(var i in headers){
+ xhr.setRequestHeader(i, headers[i]);
+ }
}
- exec(win, fail, "Geolocation", "getLocation", [options.enableHighAccuracy, options.maximumAge]);
+ xhr.send(fd);
}
- return timeoutTimer;
+
+ return { "status" : cordova.callbackStatus.NO_RESULT, "message" : "WebWorks Is On It" };
},
- /**
- * Asynchronously watches the geolocation for changes to geolocation. When a change occurs,
- * the successCallback is called with the new location.
- *
- * @param {Function} successCallback The function to call each time the location data is available
- * @param {Function} errorCallback The function to call when there is an error getting the location data. (OPTIONAL)
- * @param {PositionOptions} options The options for getting the location data such as frequency. (OPTIONAL)
- * @return String The watch id that must be passed to #clearWatch to stop watching.
- */
- watchPosition:function(successCallback, errorCallback, options) {
- if (arguments.length === 0) {
- throw new Error("watchPosition must be called with at least one argument.");
+
+ download: function(args, win, fail){
+ var url = args[0],
+ filePath = args[1];
+
+ if(!validURLProtocol.exec(url)){
+ return { "status" : cordova.callbackStatus.ERROR, "message" : new FileTransferError(FileTransferError.INVALID_URL_ERR) };
}
- options = parseParameters(options);
- var id = utils.createUUID();
+ var xhr = new XMLHttpRequest();
- // Tell device to get a position ASAP, and also retrieve a reference to the timeout timer generated in getCurrentPosition
- timers[id] = geolocation.getCurrentPosition(successCallback, errorCallback, options);
+ function writeFile(fileEntry) {
+ fileEntry.createWriter(function(writer) {
+ writer.onwriteend = function(evt) {
+ if (!evt.target.error) {
+ win(new window.FileEntry(fileEntry.name, fileEntry.toURL()));
+ } else {
+ fail(new FileTransferError(FileTransferError.FILE_NOT_FOUND_ERR));
+ }
+ };
- var fail = function(e) {
- clearTimeout(timers[id].timer);
- var err = new PositionError(e.code, e.message);
- if (errorCallback) {
- errorCallback(err);
- }
- };
+ writer.onerror = function(evt) {
+ fail(new FileTransferError(FileTransferError.FILE_NOT_FOUND_ERR));
+ };
- var win = function(p) {
- clearTimeout(timers[id].timer);
- if (options.timeout !== Infinity) {
- timers[id].timer = createTimeout(fail, options.timeout);
+ var blob = blackberry.utils.stringToBlob(xhr.response);
+ writer.write(blob);
+
+ },
+ function(error) {
+ fail(new FileTransferError(FileTransferError.FILE_NOT_FOUND_ERR));
+ });
+ }
+
+ xhr.onreadystatechange = function () {
+ if (xhr.readyState == xhr.DONE) {
+ if (xhr.status == 200 && xhr.response) {
+ window.resolveLocalFileSystemURI(getParentPath(filePath), function(dir) {
+ dir.getFile(getFileName(filePath), {create: true}, writeFile, function(error) {
+ fail(new FileTransferError(FileTransferError.FILE_NOT_FOUND_ERR));
+ });
+ }, function(error) {
+ fail(new FileTransferError(FileTransferError.FILE_NOT_FOUND_ERR));
+ });
+ } else if (xhr.status == 404) {
+ fail(new FileTransferError(FileTransferError.INVALID_URL_ERR, null, null, xhr.status));
+ } else {
+ fail(new FileTransferError(FileTransferError.CONNECTION_ERR, null, null, xhr.status));
+ }
}
- var pos = new Position(
- {
- latitude:p.latitude,
- longitude:p.longitude,
- altitude:p.altitude,
- accuracy:p.accuracy,
- heading:p.heading,
- velocity:p.velocity,
- altitudeAccuracy:p.altitudeAccuracy
- },
- (p.timestamp === undefined ? new Date() : ((p.timestamp instanceof Date) ? p.timestamp : new Date(p.timestamp)))
- );
- geolocation.lastPosition = pos;
- successCallback(pos);
};
- exec(win, fail, "Geolocation", "addWatch", [id, options.enableHighAccuracy]);
+ xhr.open("GET", url, true);
+ xhr.responseType = "arraybuffer";
+ xhr.send();
- return id;
- },
- /**
- * Clears the specified heading watch.
- *
- * @param {String} id The ID of the watch returned from #watchPosition
- */
- clearWatch:function(id) {
- if (id && timers[id] !== undefined) {
- clearTimeout(timers[id].timer);
- timers[id].timer = false;
- exec(null, null, "Geolocation", "clearWatch", [id]);
- }
+ return { "status" : cordova.callbackStatus.NO_RESULT, "message" : "WebWorks Is On It" };
}
};
-module.exports = geolocation;
-
});
-// file: lib/common/plugin/globalization.js
-define("cordova/plugin/globalization", function(require, exports, module) {
-
-var exec = require('cordova/exec'),
- GlobalizationError = require('cordova/plugin/GlobalizationError');
+// file: lib/blackberry/plugin/air/FileWriter.js
+define("cordova/plugin/air/FileWriter", function(require, exports, module) {
-var globalization = {
+var FileError = require('cordova/plugin/FileError'),
+ ProgressEvent = require('cordova/plugin/ProgressEvent');
/**
-* Returns the string identifier for the client's current language.
-* It returns the language identifier string to the successCB callback with a
-* properties object as a parameter. If there is an error getting the language,
-* then the errorCB callback is invoked.
-*
-* @param {Function} successCB
-* @param {Function} errorCB
-*
-* @return Object.value {String}: The language identifier
-*
-* @error GlobalizationError.UNKNOWN_ERROR
-*
-* Example
-* globalization.getPreferredLanguage(function (language) {alert('language:' + language.value + '\n');},
-* function () {});
-*/
-getPreferredLanguage:function(successCB, failureCB) {
- // successCallback required
- if (typeof successCB != "function") {
- console.log("Globalization.getPreferredLanguage Error: successCB is not a function");
- return;
+ * @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;
- // errorCallback required
- if (typeof failureCB != "function") {
- console.log("Globalization.getPreferredLanguage Error: failureCB is not a function");
- return;
- }
+ this.readyState = 0; // EMPTY
- exec(successCB, failureCB, "Globalization","getPreferredLanguage", []);
-},
+ 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;
/**
-* Returns the string identifier for the client's current locale setting.
-* It returns the locale identifier string to the successCB callback with a
-* properties object as a parameter. If there is an error getting the locale,
-* then the errorCB callback is invoked.
-*
-* @param {Function} successCB
-* @param {Function} errorCB
-*
-* @return Object.value {String}: The locale identifier
-*
-* @error GlobalizationError.UNKNOWN_ERROR
-*
-* Example
-* globalization.getLocaleName(function (locale) {alert('locale:' + locale.value + '\n');},
-* function () {});
-*/
-getLocaleName:function(successCB, failureCB) {
- // successCallback required
- if (typeof successCB != "function") {
- console.log("Globalization.getLocaleName Error: successCB is not a function");
- return;
+ * 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);
}
- // errorCallback required
- if (typeof failureCB != "function") {
- console.log("Globalization.getLocaleName Error: failureCB is not a function");
- return;
- }
- exec(successCB, failureCB, "Globalization","getLocaleName", []);
-},
+ // set error
+ this.error = new FileError(FileError.ABORT_ERR);
+ this.readyState = FileWriter.DONE;
-/**
-* Returns a date formatted as a string according to the client's user preferences and
-* calendar using the time zone of the client. It returns the formatted date string to the
-* successCB callback with a properties object as a parameter. If there is an error
-* formatting the date, then the errorCB callback is invoked.
-*
-* The defaults are: formatLenght="short" and selector="date and time"
-*
-* @param {Date} date
-* @param {Function} successCB
-* @param {Function} errorCB
-* @param {Object} options {optional}
-* formatLength {String}: 'short', 'medium', 'long', or 'full'
-* selector {String}: 'date', 'time', or 'date and time'
-*
-* @return Object.value {String}: The localized date string
-*
-* @error GlobalizationError.FORMATTING_ERROR
-*
-* Example
-* globalization.dateToString(new Date(),
-* function (date) {alert('date:' + date.value + '\n');},
-* function (errorCode) {alert(errorCode);},
-* {formatLength:'short'});
-*/
-dateToString:function(date, successCB, failureCB, options) {
- // successCallback required
- if (typeof successCB != "function") {
- console.log("Globalization.dateToString Error: successCB is not a function");
- return;
+ // If abort callback
+ if (typeof this.onabort === "function") {
+ this.onabort(new ProgressEvent("abort", {"target":this}));
}
- // errorCallback required
- if (typeof failureCB != "function") {
- console.log("Globalization.dateToString Error: failureCB is not a function");
- return;
+ // If write end callback
+ if (typeof this.onwriteend === "function") {
+ this.onwriteend(new ProgressEvent("writeend", {"target":this}));
+ }
+};
+
+/**
+ * Writes data to the file
+ *
+ * @param text to be written
+ */
+FileWriter.prototype.write = function(text) {
+ // Throw an exception if we are already writing a file
+ if (this.readyState === FileWriter.WRITING) {
+ throw new FileError(FileError.INVALID_STATE_ERR);
}
+ // WRITING state
+ this.readyState = FileWriter.WRITING;
- if (date instanceof Date){
- var dateValue;
- dateValue = date.valueOf();
- exec(successCB, failureCB, "Globalization", "dateToString", [{"date": dateValue, "options": options}]);
+ var me = this;
+
+ // If onwritestart callback
+ if (typeof me.onwritestart === "function") {
+ me.onwritestart(new ProgressEvent("writestart", {"target":me}));
}
- else {
- console.log("Globalization.dateToString Error: date is not a Date object");
+
+ var textBlob = blackberry.utils.stringToBlob(text);
+
+ if(blackberry.io.file.exists(this.fileName)){
+
+ var oldText = '';
+ var newText = text;
+
+ var getFileContents = function(path,blob){
+
+ if(blob){
+ oldText = blackberry.utils.blobToString(blob);
+ if(oldText.length>0){
+ newText = oldText.substr(0,me.position) + text;
+ }
+ }
+
+ var tempFile = me.fileName+'temp';
+ if(blackberry.io.file.exists(tempFile)){
+ blackberry.io.file.deleteFile(tempFile);
+ }
+
+ var newTextBlob = blackberry.utils.stringToBlob(newText);
+
+ // crete a temp file, delete file we are 'overwriting', then rename temp file
+ blackberry.io.file.saveFile(tempFile, newTextBlob);
+ blackberry.io.file.deleteFile(me.fileName);
+ blackberry.io.file.rename(tempFile, me.fileName.split('/').pop());
+
+ me.position = newText.length;
+ me.length = me.position;
+
+ if (typeof me.onwrite === "function") {
+ me.onwrite(new ProgressEvent("write", {"target":me}));
+ }
+ };
+
+ // setting asynch to off
+ blackberry.io.file.readFile(this.fileName, getFileContents, false);
+
+ }else{
+
+ // file is new so just save it
+ blackberry.io.file.saveFile(this.fileName, textBlob);
+ me.position = text.length;
+ me.length = me.position;
}
-},
+ me.readyState = FileWriter.DONE;
+
+ if (typeof me.onwriteend === "function") {
+ me.onwriteend(new ProgressEvent("writeend", {"target":me}));
+ }
+};
/**
-* Parses a date formatted as a string according to the client's user
-* preferences and calendar using the time zone of the client and returns
-* the corresponding date object. It returns the date to the successCB
-* callback with a properties object as a parameter. If there is an error
-* parsing the date string, then the errorCB callback is invoked.
-*
-* The defaults are: formatLength="short" and selector="date and time"
-*
-* @param {String} dateString
-* @param {Function} successCB
-* @param {Function} errorCB
-* @param {Object} options {optional}
-* formatLength {String}: 'short', 'medium', 'long', or 'full'
-* selector {String}: 'date', 'time', or 'date and time'
-*
-* @return Object.year {Number}: The four digit year
-* Object.month {Number}: The month from (0 - 11)
-* Object.day {Number}: The day from (1 - 31)
-* Object.hour {Number}: The hour from (0 - 23)
-* Object.minute {Number}: The minute from (0 - 59)
-* Ob
<TRUNCATED>