You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@cordova.apache.org by sh...@apache.org on 2012/02/17 02:38:49 UTC
[13/27] Rename PhoneGap to Cordova.
http://git-wip-us.apache.org/repos/asf/incubator-cordova-ios/blob/bcff9559/CordovaLib/javascripts/core/file.js
----------------------------------------------------------------------
diff --git a/CordovaLib/javascripts/core/file.js b/CordovaLib/javascripts/core/file.js
new file mode 100644
index 0000000..540963c
--- /dev/null
+++ b/CordovaLib/javascripts/core/file.js
@@ -0,0 +1,1169 @@
+if (!Cordova.hasResource("file")) {
+ Cordova.addResource("file");
+
+/**
+ * This class provides generic read and write access to the mobile device file system.
+ * They are not used to read files from a server.
+ */
+
+/**
+ * This class provides some useful information about a file.
+ * This is the fields returned when navigator.fileMgr.getFileProperties()
+ * is called.
+ */
+FileProperties = function(filePath) {
+ this.filePath = filePath;
+ this.size = 0;
+ this.lastModifiedDate = null;
+}
+/**
+ * Represents a single file.
+ *
+ * name {DOMString} name of the file, without path information
+ * fullPath {DOMString} the full path of the file, including the name
+ * type {DOMString} mime type
+ * lastModifiedDate {Date} last modified date
+ * size {Number} size of the file in bytes
+ */
+File = function(name, fullPath, type, lastModifiedDate, size) {
+ this.name = name || null;
+ this.fullPath = fullPath || null;
+ this.type = type || null;
+ this.lastModifiedDate = lastModifiedDate || null;
+ this.size = size || 0;
+}
+/**
+ * Create an event object since we can't set target on DOM event.
+ *
+ * @param type
+ * @param target
+ *
+ */
+File._createEvent = function(type, target) {
+ // Can't create event object, since we can't set target (its readonly)
+ //var evt = document.createEvent('Events');
+ //evt.initEvent("onload", false, false);
+ var evt = {"type": type};
+ evt.target = target;
+ return evt;
+};
+
+FileError = function() {
+ this.code = null;
+}
+
+// File error codes
+// Found in DOMException
+FileError.NOT_FOUND_ERR = 1;
+FileError.SECURITY_ERR = 2;
+FileError.ABORT_ERR = 3;
+
+// Added by this 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;
+
+//-----------------------------------------------------------------------------
+// File manager
+//-----------------------------------------------------------------------------
+
+FileMgr = function() {
+}
+
+FileMgr.prototype.testFileExists = function(fileName, successCallback, errorCallback) {
+ Cordova.exec(successCallback, errorCallback, "org.apache.cordova.file", "testFileExists", [fileName]);
+};
+
+FileMgr.prototype.testDirectoryExists = function(dirName, successCallback, errorCallback) {
+ Cordova.exec(successCallback, errorCallback, "org.apache.cordova.file", "testDirectoryExists", [dirName]);
+};
+
+FileMgr.prototype.getFreeDiskSpace = function(successCallback, errorCallback) {
+ Cordova.exec(successCallback, errorCallback, "org.apache.cordova.file", "getFreeDiskSpace", []);
+};
+
+FileMgr.prototype.write = function(fileName, data, position, successCallback, errorCallback) {
+ Cordova.exec(successCallback, errorCallback, "org.apache.cordova.file", "write", [fileName, data, position]);
+};
+
+FileMgr.prototype.truncate = function(fileName, size, successCallback, errorCallback) {
+ Cordova.exec(successCallback, errorCallback, "org.apache.cordova.file", "truncateFile", [fileName, size]);
+};
+
+FileMgr.prototype.readAsText = function(fileName, encoding, successCallback, errorCallback) {
+ Cordova.exec(successCallback, errorCallback, "org.apache.cordova.file", "readFile", [fileName, encoding]);
+};
+
+FileMgr.prototype.readAsDataURL = function(fileName, successCallback, errorCallback) {
+ Cordova.exec(successCallback, errorCallback, "org.apache.cordova.file", "readAsDataURL", [fileName]);
+};
+
+Cordova.addConstructor(function() {
+ if (typeof navigator.fileMgr === "undefined") {
+ navigator.fileMgr = new FileMgr();
+ }
+});
+
+
+//-----------------------------------------------------------------------------
+// File Reader
+//-----------------------------------------------------------------------------
+
+/**
+ * This class reads the mobile device file system.
+ *
+ */
+FileReader = function() {
+ this.fileName = "";
+
+ this.readyState = 0;
+
+ // File data
+ this.result = null;
+
+ // Error
+ this.error = null;
+
+ // Event handlers
+ this.onloadstart = null; // When the read starts.
+ this.onprogress = null; // While reading (and decoding) file or fileBlob data, and reporting partial file data (progess.loaded/progress.total)
+ this.onload = null; // When the read has successfully completed.
+ this.onerror = null; // When the read has failed (see errors).
+ this.onloadend = null; // When the request has completed (either in success or failure).
+ this.onabort = null; // When the read has been aborted. For instance, by invoking the abort() method.
+}
+
+// States
+FileReader.EMPTY = 0;
+FileReader.LOADING = 1;
+FileReader.DONE = 2;
+
+/**
+ * Abort reading file.
+ */
+FileReader.prototype.abort = function() {
+ var evt;
+ this.readyState = FileReader.DONE;
+ this.result = null;
+
+ // set error
+ var error = new FileError();
+ error.code = error.ABORT_ERR;
+ this.error = error;
+
+ // If error callback
+ if (typeof this.onerror === "function") {
+ evt = File._createEvent("error", this);
+ this.onerror(evt);
+ }
+ // If abort callback
+ if (typeof this.onabort === "function") {
+ evt = File._createEvent("abort", this);
+ this.onabort(evt);
+ }
+ // If load end callback
+ if (typeof this.onloadend === "function") {
+ evt = File._createEvent("loadend", this);
+ this.onloadend(evt);
+ }
+};
+
+/**
+ * Read text file.
+ *
+ * @param file The name of the file
+ * @param encoding [Optional] (see http://www.iana.org/assignments/character-sets)
+ */
+FileReader.prototype.readAsText = function(file, encoding) {
+ this.fileName = "";
+ if (typeof file.fullPath === "undefined") {
+ this.fileName = file;
+ } else {
+ this.fileName = file.fullPath;
+ }
+
+ // LOADING state
+ this.readyState = FileReader.LOADING;
+
+ // If loadstart callback
+ if (typeof this.onloadstart === "function") {
+ var evt = File._createEvent("loadstart", this);
+ this.onloadstart(evt);
+ }
+
+ // Default encoding is UTF-8
+ var enc = encoding ? encoding : "UTF-8";
+
+ var me = this;
+
+ // Read file
+ navigator.fileMgr.readAsText(this.fileName, enc,
+
+ // Success callback
+ function(r) {
+ var evt;
+
+ // If DONE (cancelled), then don't do anything
+ if (me.readyState === FileReader.DONE) {
+ return;
+ }
+
+ // Save result
+ me.result = decodeURIComponent(r);
+
+ // If onload callback
+ if (typeof me.onload === "function") {
+ evt = File._createEvent("load", me);
+ me.onload(evt);
+ }
+
+ // DONE state
+ me.readyState = FileReader.DONE;
+
+ // If onloadend callback
+ if (typeof me.onloadend === "function") {
+ evt = File._createEvent("loadend", me);
+ me.onloadend(evt);
+ }
+ },
+
+ // Error callback
+ function(e) {
+ var evt;
+ // If DONE (cancelled), then don't do anything
+ if (me.readyState === FileReader.DONE) {
+ return;
+ }
+
+ // Save error
+ me.error = e;
+
+ // If onerror callback
+ if (typeof me.onerror === "function") {
+ evt = File._createEvent("error", me);
+ me.onerror(evt);
+ }
+
+ // DONE state
+ me.readyState = FileReader.DONE;
+
+ // If onloadend callback
+ if (typeof me.onloadend === "function") {
+ evt = File._createEvent("loadend", me);
+ me.onloadend(evt);
+ }
+ }
+ );
+};
+
+
+/**
+ * Read file and return data as a base64 encoded data url.
+ * A data url is of the form:
+ * data:[<mediatype>][;base64],<data>
+ *
+ * @param file {File} File object containing file properties
+ */
+FileReader.prototype.readAsDataURL = function(file) {
+ this.fileName = "";
+
+ if (typeof file.fullPath === "undefined") {
+ this.fileName = file;
+ } else {
+ this.fileName = file.fullPath;
+ }
+
+ // LOADING state
+ this.readyState = FileReader.LOADING;
+
+ // If loadstart callback
+ if (typeof this.onloadstart === "function") {
+ var evt = File._createEvent("loadstart", this);
+ this.onloadstart(evt);
+ }
+
+ var me = this;
+
+ // Read file
+ navigator.fileMgr.readAsDataURL(this.fileName,
+
+ // Success callback
+ function(r) {
+ var evt;
+
+ // 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") {
+ evt = File._createEvent("load", me);
+ me.onload(evt);
+ }
+
+ // DONE state
+ me.readyState = FileReader.DONE;
+
+ // If onloadend callback
+ if (typeof me.onloadend === "function") {
+ evt = File._createEvent("loadend", me);
+ me.onloadend(evt);
+ }
+ },
+
+ // Error callback
+ function(e) {
+ var evt;
+ // If DONE (cancelled), then don't do anything
+ if (me.readyState === FileReader.DONE) {
+ return;
+ }
+
+ // Save error
+ me.error = e;
+
+ // If onerror callback
+ if (typeof me.onerror === "function") {
+ evt = File._createEvent("error", me);
+ me.onerror(evt);
+ }
+
+ // DONE state
+ me.readyState = FileReader.DONE;
+
+ // If onloadend callback
+ if (typeof me.onloadend === "function") {
+ evt = File._createEvent("loadend", me);
+ me.onloadend(evt);
+ }
+ }
+ );
+};
+
+/**
+ * Read file and return data as a binary data.
+ *
+ * @param file The name of the file
+ */
+FileReader.prototype.readAsBinaryString = function(file) {
+ // TODO - Can't return binary data to browser.
+ this.fileName = file;
+};
+
+/**
+ * Read file and return data as a binary data.
+ *
+ * @param file The name of the file
+ */
+FileReader.prototype.readAsArrayBuffer = function(file) {
+ // TODO - Can't return binary data to browser.
+ this.fileName = file;
+};
+
+//-----------------------------------------------------------------------------
+// File Writer
+//-----------------------------------------------------------------------------
+
+/**
+ * This class writes to the mobile device file system.
+ *
+ @param file {File} a File object representing a file on the file system
+*/
+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 FileError.INVALID_STATE_ERR;
+ }
+
+ // set error
+ var error = new FileError(), evt;
+ error.code = error.ABORT_ERR;
+ this.error = error;
+
+ // If error callback
+ if (typeof this.onerror === "function") {
+ evt = File._createEvent("error", this);
+ this.onerror(evt);
+ }
+ // If abort callback
+ if (typeof this.onabort === "function") {
+ evt = File._createEvent("abort", this);
+ this.onabort(evt);
+ }
+
+ this.readyState = FileWriter.DONE;
+
+ // If write end callback
+ if (typeof this.onwriteend == "function") {
+ evt = File._createEvent("writeend", this);
+ this.onwriteend(evt);
+ }
+};
+
+/**
+ * @Deprecated: use write instead
+ *
+ * @param file to write the data to
+ * @param text to be written
+ * @param bAppend if true write to end of file, otherwise overwrite the file
+ */
+FileWriter.prototype.writeAsText = function(file, text, bAppend) {
+ // Throw an exception if we are already writing a file
+ if (this.readyState === FileWriter.WRITING) {
+ throw FileError.INVALID_STATE_ERR;
+ }
+
+ if (bAppend !== true) {
+ bAppend = false; // for null values
+ }
+
+ this.fileName = file;
+
+ // WRITING state
+ this.readyState = FileWriter.WRITING;
+
+ var me = this;
+
+ // If onwritestart callback
+ if (typeof me.onwritestart === "function") {
+ var evt = File._createEvent("writestart", me);
+ me.onwritestart(evt);
+ }
+
+
+ // Write file
+ navigator.fileMgr.writeAsText(file, text, bAppend,
+ // Success callback
+ function(r) {
+ var evt;
+
+ // If DONE (cancelled), then don't do anything
+ if (me.readyState === FileWriter.DONE) {
+ return;
+ }
+
+ // Save result
+ me.result = r;
+
+ // If onwrite callback
+ if (typeof me.onwrite === "function") {
+ evt = File._createEvent("write", me);
+ me.onwrite(evt);
+ }
+
+ // DONE state
+ me.readyState = FileWriter.DONE;
+
+ // If onwriteend callback
+ if (typeof me.onwriteend === "function") {
+ evt = File._createEvent("writeend", me);
+ me.onwriteend(evt);
+ }
+ },
+
+ // Error callback
+ function(e) {
+ var evt;
+
+ // If DONE (cancelled), then don't do anything
+ if (me.readyState === FileWriter.DONE) {
+ return;
+ }
+
+ // Save error
+ me.error = e;
+
+ // If onerror callback
+ if (typeof me.onerror === "function") {
+ evt = File._createEvent("error", me);
+ me.onerror(evt);
+ }
+
+ // DONE state
+ me.readyState = FileWriter.DONE;
+
+ // If onwriteend callback
+ if (typeof me.onwriteend === "function") {
+ evt = File._createEvent("writeend", me);
+ me.onwriteend(evt);
+ }
+ }
+ );
+};
+
+/**
+ * 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 FileError.INVALID_STATE_ERR;
+ }
+
+ // WRITING state
+ this.readyState = FileWriter.WRITING;
+
+ var me = this;
+
+ // If onwritestart callback
+ if (typeof me.onwritestart === "function") {
+ var evt = File._createEvent("writestart", me);
+ me.onwritestart(evt);
+ }
+
+ // Write file
+ navigator.fileMgr.write(this.fileName, text, this.position,
+
+ // Success callback
+ function(r) {
+ var evt;
+ // 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;
+
+ // If onwrite callback
+ if (typeof me.onwrite === "function") {
+ evt = File._createEvent("write", me);
+ me.onwrite(evt);
+ }
+
+ // DONE state
+ me.readyState = FileWriter.DONE;
+
+ // If onwriteend callback
+ if (typeof me.onwriteend === "function") {
+ evt = File._createEvent("writeend", me);
+ me.onwriteend(evt);
+ }
+ },
+
+ // Error callback
+ function(e) {
+ var evt;
+
+ // If DONE (cancelled), then don't do anything
+ if (me.readyState === FileWriter.DONE) {
+ return;
+ }
+
+ // Save error
+ me.error = e;
+
+ // If onerror callback
+ if (typeof me.onerror === "function") {
+ evt = File._createEvent("error", me);
+ me.onerror(evt);
+ }
+
+ // DONE state
+ me.readyState = FileWriter.DONE;
+
+ // If onwriteend callback
+ if (typeof me.onwriteend === "function") {
+ evt = File._createEvent("writeend", me);
+ me.onwriteend(evt);
+ }
+ }
+ );
+
+};
+
+/**
+ * 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 FileError.INVALID_STATE_ERR;
+ }
+
+ if (!offset) {
+ return;
+ }
+
+ // See back from end of file.
+ if (offset < 0) {
+ this.position = Math.max(offset + this.length, 0);
+ }
+ // Offset is bigger then file size so set position
+ // to the end of the file.
+ else if (offset > this.length) {
+ this.position = this.length;
+ }
+ // Offset is between 0 and file size so set the position
+ // to start writing.
+ else {
+ this.position = offset;
+ }
+};
+
+/**
+ * Truncates the file to the size specified.
+ *
+ * @param size to chop the file at.
+ */
+FileWriter.prototype.truncate = function(size) {
+ // Throw an exception if we are already writing a file
+ if (this.readyState === FileWriter.WRITING) {
+ throw FileError.INVALID_STATE_ERR;
+ }
+ // what if no size specified?
+
+ // WRITING state
+ this.readyState = FileWriter.WRITING;
+
+ var me = this;
+
+ // If onwritestart callback
+ if (typeof me.onwritestart === "function") {
+ var evt = File._createEvent("writestart", me);
+ me.onwritestart(evt);
+ }
+
+ // Write file
+ navigator.fileMgr.truncate(this.fileName, size,
+
+ // Success callback
+ function(r) {
+ var evt;
+ // If DONE (cancelled), then don't do anything
+ if (me.readyState === FileWriter.DONE) {
+ return;
+ }
+
+ // Update the length of the file
+ me.length = r;
+ me.position = Math.min(me.position, r);
+
+ // If onwrite callback
+ if (typeof me.onwrite === "function") {
+ evt = File._createEvent("write", me);
+ me.onwrite(evt);
+ }
+
+ // DONE state
+ me.readyState = FileWriter.DONE;
+
+ // If onwriteend callback
+ if (typeof me.onwriteend === "function") {
+ evt = File._createEvent("writeend", me);
+ me.onwriteend(evt);
+ }
+ },
+
+ // Error callback
+ function(e) {
+ var evt;
+ // If DONE (cancelled), then don't do anything
+ if (me.readyState === FileWriter.DONE) {
+ return;
+ }
+
+ // Save error
+ me.error = e;
+
+ // If onerror callback
+ if (typeof me.onerror === "function") {
+ evt = File._createEvent("error", me);
+ me.onerror(evt);
+ }
+
+ // DONE state
+ me.readyState = FileWriter.DONE;
+
+ // If onwriteend callback
+ if (typeof me.onwriteend === "function") {
+ evt = File._createEvent("writeend", me);
+ me.onwriteend(evt);
+ }
+ }
+ );
+};
+
+LocalFileSystem = function() {
+};
+
+// File error codes
+LocalFileSystem.TEMPORARY = 0;
+LocalFileSystem.PERSISTENT = 1;
+LocalFileSystem.RESOURCE = 2;
+LocalFileSystem.APPLICATION = 3;
+
+/**
+ * Requests a filesystem in which to store application data.
+ *
+ * @param {int} type of file system being requested
+ * @param {Function} successCallback is called with the new FileSystem
+ * @param {Function} errorCallback is called with a FileError
+ */
+LocalFileSystem.prototype.requestFileSystem = function(type, size, successCallback, errorCallback) {
+ if (type < 0 || type > 3) {
+ if (typeof errorCallback == "function") {
+ errorCallback({
+ "code": FileError.SYNTAX_ERR
+ });
+ }
+ }
+ else {
+ Cordova.exec(successCallback, errorCallback, "org.apache.cordova.file", "requestFileSystem", [type, size]);
+ }
+};
+
+/**
+ *
+ * @param {DOMString} uri referring to a local file in a filesystem
+ * @param {Function} successCallback is called with the new entry
+ * @param {Function} errorCallback is called with a FileError
+ */
+LocalFileSystem.prototype.resolveLocalFileSystemURI = function(uri, successCallback, errorCallback) {
+ Cordova.exec(successCallback, errorCallback, "org.apache.cordova.file", "resolveLocalFileSystemURI", [uri]);
+};
+
+/**
+* This function is required as we need to convert raw
+* JSON objects into concrete File and Directory objects.
+*
+* @param a JSON Objects that need to be converted to DirectoryEntry or FileEntry objects.
+* @returns an entry
+*/
+LocalFileSystem.prototype._castFS = function(pluginResult) {
+ var entry = null;
+ entry = new DirectoryEntry();
+ entry.isDirectory = pluginResult.message.root.isDirectory;
+ entry.isFile = pluginResult.message.root.isFile;
+ entry.name = pluginResult.message.root.name;
+ entry.fullPath = pluginResult.message.root.fullPath;
+ pluginResult.message.root = entry;
+ return pluginResult;
+}
+
+LocalFileSystem.prototype._castEntry = function(pluginResult) {
+ var entry = null;
+ if (pluginResult.message.isDirectory) {
+ entry = new DirectoryEntry();
+ }
+ else if (pluginResult.message.isFile) {
+ entry = new FileEntry();
+ }
+ entry.isDirectory = pluginResult.message.isDirectory;
+ entry.isFile = pluginResult.message.isFile;
+ entry.name = pluginResult.message.name;
+ entry.fullPath = pluginResult.message.fullPath;
+ pluginResult.message = entry;
+ return pluginResult;
+}
+
+LocalFileSystem.prototype._castEntries = function(pluginResult) {
+ var entries = pluginResult.message;
+ var retVal = [];
+ for (i=0; i<entries.length; i++) {
+ retVal.push(window.localFileSystem._createEntry(entries[i]));
+ }
+ pluginResult.message = retVal;
+ return pluginResult;
+}
+
+LocalFileSystem.prototype._createEntry = function(castMe) {
+ var entry = null;
+ if (castMe.isDirectory) {
+ entry = new DirectoryEntry();
+ }
+ else if (castMe.isFile) {
+ entry = new FileEntry();
+ }
+ entry.isDirectory = castMe.isDirectory;
+ entry.isFile = castMe.isFile;
+ entry.name = castMe.name;
+ entry.fullPath = castMe.fullPath;
+ return entry;
+
+}
+
+LocalFileSystem.prototype._castDate = function(pluginResult) {
+ if (pluginResult.message.modificationTime) {
+ var metadataObj = new Metadata();
+
+ metadataObj.modificationTime = new Date(pluginResult.message.modificationTime);
+ pluginResult.message = metadataObj;
+ }
+ else if (pluginResult.message.lastModifiedDate) {
+ var file = new File();
+ file.size = pluginResult.message.size;
+ file.type = pluginResult.message.type;
+ file.name = pluginResult.message.name;
+ file.fullPath = pluginResult.message.fullPath;
+ file.lastModifiedDate = new Date(pluginResult.message.lastModifiedDate);
+ pluginResult.message = file;
+ }
+
+ return pluginResult;
+}
+LocalFileSystem.prototype._castError = function(pluginResult) {
+ var fileError = new FileError();
+ fileError.code = pluginResult.message;
+ pluginResult.message = fileError;
+ return pluginResult;
+}
+
+/**
+ * Information about the state of the file or directory
+ *
+ * {Date} modificationTime (readonly)
+ */
+Metadata = function() {
+ this.modificationTime=null;
+};
+
+/**
+ * Supplies arguments to methods that lookup or create files and directories
+ *
+ * @param {boolean} create file or directory if it doesn't exist
+ * @param {boolean} exclusive if true the command will fail if the file or directory exists
+ */
+Flags = function(create, exclusive) {
+ this.create = create || false;
+ this.exclusive = exclusive || false;
+};
+
+/**
+ * An interface representing a file system
+ *
+ * {DOMString} name the unique name of the file system (readonly)
+ * {DirectoryEntry} root directory of the file system (readonly)
+ */
+FileSystem = function() {
+ this.name = null;
+ this.root = null;
+};
+
+/**
+ * An interface representing a directory on the file system.
+ *
+ * {boolean} isFile always false (readonly)
+ * {boolean} isDirectory always true (readonly)
+ * {DOMString} name of the directory, excluding the path leading to it (readonly)
+ * {DOMString} fullPath the absolute full path to the directory (readonly)
+ * {FileSystem} filesystem on which the directory resides (readonly)
+ */
+DirectoryEntry = function() {
+ this.isFile = false;
+ this.isDirectory = true;
+ this.name = null;
+ this.fullPath = null;
+ this.filesystem = null;
+};
+
+/**
+ * Copies a directory to a new location
+ *
+ * @param {DirectoryEntry} parent the directory to which to copy the entry
+ * @param {DOMString} newName the new name of the entry, defaults to the current name
+ * @param {Function} successCallback is called with the new entry
+ * @param {Function} errorCallback is called with a FileError
+ */
+DirectoryEntry.prototype.copyTo = function(parent, newName, successCallback, errorCallback) {
+ Cordova.exec(successCallback, errorCallback, "org.apache.cordova.file", "copyTo", [this.fullPath, parent, newName]);
+};
+
+/**
+ * Looks up the metadata of the entry
+ *
+ * @param {Function} successCallback is called with a Metadata object
+ * @param {Function} errorCallback is called with a FileError
+ */
+DirectoryEntry.prototype.getMetadata = function(successCallback, errorCallback) {
+ Cordova.exec(successCallback, errorCallback, "org.apache.cordova.file", "getMetadata", [this.fullPath]);
+};
+
+/**
+ * Gets the parent of the entry
+ *
+ * @param {Function} successCallback is called with a parent entry
+ * @param {Function} errorCallback is called with a FileError
+ */
+DirectoryEntry.prototype.getParent = function(successCallback, errorCallback) {
+ Cordova.exec(successCallback, errorCallback, "org.apache.cordova.file", "getParent", [this.fullPath]);
+};
+
+/**
+ * Moves a directory to a new location
+ *
+ * @param {DirectoryEntry} parent the directory to which to move the entry
+ * @param {DOMString} newName the new name of the entry, defaults to the current name
+ * @param {Function} successCallback is called with the new entry
+ * @param {Function} errorCallback is called with a FileError
+ */
+DirectoryEntry.prototype.moveTo = function(parent, newName, successCallback, errorCallback) {
+ Cordova.exec(successCallback, errorCallback, "org.apache.cordova.file", "moveTo", [this.fullPath, parent, newName]);
+};
+
+/**
+ * Removes the entry
+ *
+ * @param {Function} successCallback is called with no parameters
+ * @param {Function} errorCallback is called with a FileError
+ */
+DirectoryEntry.prototype.remove = function(successCallback, errorCallback) {
+ Cordova.exec(successCallback, errorCallback, "org.apache.cordova.file", "remove", [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.
+ * @param {Function} successCallback is called with the new entry
+ * @param {Function} errorCallback is called with a FileError
+ */
+DirectoryEntry.prototype.toURI = function(mimeType, successCallback, errorCallback) {
+ return "file://localhost" + this.fullPath;
+ //Cordova.exec(successCallback, errorCallback, "org.apache.cordova.file", "toURI", [this.fullPath, mimeType]);
+};
+
+/**
+ * Creates a new DirectoryReader to read entries from this directory
+ */
+DirectoryEntry.prototype.createReader = function(successCallback, errorCallback) {
+ return new DirectoryReader(this.fullPath);
+};
+
+/**
+ * Creates or looks up a directory
+ *
+ * @param {DOMString} path either a relative or absolute path from this directory in which to look up or create a directory
+ * @param {Flags} options to create or excluively create the directory
+ * @param {Function} successCallback is called with the new entry
+ * @param {Function} errorCallback is called with a FileError
+ */
+DirectoryEntry.prototype.getDirectory = function(path, options, successCallback, errorCallback) {
+ Cordova.exec(successCallback, errorCallback, "org.apache.cordova.file", "getDirectory", [this.fullPath, path, options]);
+};
+
+/**
+ * Creates or looks up a file
+ *
+ * @param {DOMString} path either a relative or absolute path from this directory in which to look up or create a file
+ * @param {Flags} options to create or excluively create the file
+ * @param {Function} successCallback is called with the new entry
+ * @param {Function} errorCallback is called with a FileError
+ */
+DirectoryEntry.prototype.getFile = function(path, options, successCallback, errorCallback) {
+ Cordova.exec(successCallback, errorCallback, "org.apache.cordova.file", "getFile", [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) {
+ Cordova.exec(successCallback, errorCallback, "org.apache.cordova.file", "removeRecursively", [this.fullPath]);
+};
+
+/**
+ * An interface that lists the files and directories in a directory.
+ */
+DirectoryReader = function(fullPath){
+ this.fullPath = fullPath || 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) {
+ Cordova.exec(successCallback, errorCallback, "org.apache.cordova.file", "readEntries", [this.fullPath]);
+}
+
+/**
+ * An interface representing a directory 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 directory resides (readonly)
+ */
+FileEntry = function() {
+ this.isFile = true;
+ this.isDirectory = false;
+ this.name = null;
+ this.fullPath = null;
+ this.filesystem = null;
+};
+
+/**
+ * Copies a file to a new location
+ *
+ * @param {DirectoryEntry} parent the directory to which to copy the entry
+ * @param {DOMString} newName the new name of the entry, defaults to the current name
+ * @param {Function} successCallback is called with the new entry
+ * @param {Function} errorCallback is called with a FileError
+ */
+FileEntry.prototype.copyTo = function(parent, newName, successCallback, errorCallback) {
+ Cordova.exec(successCallback, errorCallback, "org.apache.cordova.file", "copyTo", [this.fullPath, parent, newName]);
+};
+
+/**
+ * Looks up the metadata of the entry
+ *
+ * @param {Function} successCallback is called with a Metadata object
+ * @param {Function} errorCallback is called with a FileError
+ */
+FileEntry.prototype.getMetadata = function(successCallback, errorCallback) {
+ Cordova.exec(successCallback, errorCallback, "org.apache.cordova.file", "getMetadata", [this.fullPath]);
+};
+
+/**
+ * Gets the parent of the entry
+ *
+ * @param {Function} successCallback is called with a parent entry
+ * @param {Function} errorCallback is called with a FileError
+ */
+FileEntry.prototype.getParent = function(successCallback, errorCallback) {
+ Cordova.exec(successCallback, errorCallback, "org.apache.cordova.file", "getParent", [this.fullPath]);
+};
+
+/**
+ * Moves a directory to a new location
+ *
+ * @param {DirectoryEntry} parent the directory to which to move the entry
+ * @param {DOMString} newName the new name of the entry, defaults to the current name
+ * @param {Function} successCallback is called with the new entry
+ * @param {Function} errorCallback is called with a FileError
+ */
+FileEntry.prototype.moveTo = function(parent, newName, successCallback, errorCallback) {
+ Cordova.exec(successCallback, errorCallback, "org.apache.cordova.file", "moveTo", [this.fullPath, parent, newName]);
+};
+
+/**
+ * Removes the entry
+ *
+ * @param {Function} successCallback is called with no parameters
+ * @param {Function} errorCallback is called with a FileError
+ */
+FileEntry.prototype.remove = function(successCallback, errorCallback) {
+ Cordova.exec(successCallback, errorCallback, "org.apache.cordova.file", "remove", [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.
+ * @param {Function} successCallback is called with the new entry
+ * @param {Function} errorCallback is called with a FileError
+ */
+FileEntry.prototype.toURI = function(mimeType, successCallback, errorCallback) {
+ return "file://localhost" + this.fullPath;
+ //Cordova.exec(successCallback, errorCallback, "org.apache.cordova.file", "toURI", [this.fullPath, mimeType]);
+};
+
+/**
+ * Creates a new FileWriter associated with the file that this FileEntry represents.
+ *
+ * @param {Function} successCallback is called with the new FileWriter
+ * @param {Function} errorCallback is called with a FileError
+ */
+FileEntry.prototype.createWriter = function(successCallback, errorCallback) {
+ this.file(function(filePointer) {
+ var writer = new FileWriter(filePointer);
+ if (writer.fileName == null || writer.fileName == "") {
+ if (typeof errorCallback == "function") {
+ errorCallback({
+ "code": FileError.INVALID_STATE_ERR
+ });
+ }
+ }
+ if (typeof successCallback == "function") {
+ successCallback(writer);
+ }
+ }, errorCallback);
+};
+
+/**
+ * Returns a File that represents the current state of the file that this FileEntry represents.
+ *
+ * @param {Function} successCallback is called with the new File object
+ * @param {Function} errorCallback is called with a FileError
+ */
+FileEntry.prototype.file = function(successCallback, errorCallback) {
+ Cordova.exec(successCallback, errorCallback, "org.apache.cordova.file", "getFileMetadata", [this.fullPath]);
+};
+
+/**
+ * Add the FileSystem interface into the browser.
+ */
+Cordova.addConstructor(function() {
+ var pgLocalFileSystem = new LocalFileSystem();
+ // Needed for cast methods
+ if(typeof window.localFileSystem == "undefined") window.localFileSystem = pgLocalFileSystem;
+ if(typeof window.requestFileSystem == "undefined") window.requestFileSystem = pgLocalFileSystem.requestFileSystem;
+ if(typeof window.resolveLocalFileSystemURI == "undefined") window.resolveLocalFileSystemURI = pgLocalFileSystem.resolveLocalFileSystemURI;
+});
+};
+
+
+
+
http://git-wip-us.apache.org/repos/asf/incubator-cordova-ios/blob/bcff9559/CordovaLib/javascripts/core/filetransfer.js
----------------------------------------------------------------------
diff --git a/CordovaLib/javascripts/core/filetransfer.js b/CordovaLib/javascripts/core/filetransfer.js
new file mode 100644
index 0000000..aed07ac
--- /dev/null
+++ b/CordovaLib/javascripts/core/filetransfer.js
@@ -0,0 +1,119 @@
+/*
+ * Copyright (c) 2011, Matt Kane
+ */
+
+if (!Cordova.hasResource("filetransfer")) {
+ Cordova.addResource("filetransfer");
+
+/**
+ * FileTransfer uploads a file to a remote server.
+ */
+FileTransfer = function() {}
+
+/**
+ * FileUploadResult
+ */
+FileUploadResult = function() {
+ this.bytesSent = 0;
+ this.responseCode = null;
+ this.response = null;
+}
+
+/**
+ * FileTransferError
+ */
+FileTransferError = function(errorCode) {
+ this.code = errorCode || null;
+}
+
+FileTransferError.FILE_NOT_FOUND_ERR = 1;
+FileTransferError.INVALID_URL_ERR = 2;
+FileTransferError.CONNECTION_ERR = 3;
+
+/**
+* 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
+*/
+FileTransfer.prototype.upload = function(filePath, server, successCallback, errorCallback, options) {
+ if(!options.params) {
+ options.params = {};
+ }
+ options.filePath = filePath;
+ options.server = server;
+ if(!options.fileKey) {
+ options.fileKey = 'file';
+ }
+ if(!options.fileName) {
+ options.fileName = 'image.jpg';
+ }
+ if(!options.mimeType) {
+ options.mimeType = 'image/jpeg';
+ }
+
+ // successCallback required
+ if (typeof successCallback != "function") {
+ console.log("FileTransfer Error: successCallback is not a function");
+ return;
+ }
+
+
+ // errorCallback optional
+ if (errorCallback && (typeof errorCallback != "function")) {
+ console.log("FileTransfer Error: errorCallback is not a function");
+ return;
+ }
+
+ Cordova.exec(successCallback, errorCallback, 'org.apache.cordova.filetransfer', 'upload', [options]);
+};
+
+FileTransfer.prototype._castTransferError = function(pluginResult) {
+ var fileError = new FileTransferError(pluginResult.message);
+ //fileError.code = pluginResult.message;
+ pluginResult.message = fileError;
+ return pluginResult;
+}
+
+FileTransfer.prototype._castUploadResult = function(pluginResult) {
+ var result = new FileUploadResult();
+ result.bytesSent = pluginResult.message.bytesSent;
+ result.responseCode = pluginResult.message.responseCode;
+ result.response = decodeURIComponent(pluginResult.message.response);
+ pluginResult.message = result;
+ return pluginResult;
+}
+
+/**
+ * Downloads a file form a given URL and saves it to the specified directory.
+ * @param source {String} URL of the server to receive the file
+ * @param target {String} Full path of the file on the device
+ * @param successCallback (Function} Callback to be invoked when upload has completed
+ * @param errorCallback {Function} Callback to be invoked upon error
+ */
+FileTransfer.prototype.download = function(source, target, successCallback, errorCallback) {
+ Cordova.exec(successCallback, errorCallback, 'org.apache.cordova.filetransfer', 'download', [source, target]);
+};
+
+/**
+ * Options to customize the HTTP request used to upload files.
+ * @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.
+ */
+FileUploadOptions = function(fileKey, fileName, mimeType, params) {
+ this.fileKey = fileKey || null;
+ this.fileName = fileName || null;
+ this.mimeType = mimeType || null;
+ this.params = params || null;
+}
+
+
+Cordova.addConstructor(function() {
+ if (typeof navigator.fileTransfer == "undefined") navigator.fileTransfer = new FileTransfer();
+});
+};
http://git-wip-us.apache.org/repos/asf/incubator-cordova-ios/blob/bcff9559/CordovaLib/javascripts/core/geolocation.js
----------------------------------------------------------------------
diff --git a/CordovaLib/javascripts/core/geolocation.js b/CordovaLib/javascripts/core/geolocation.js
new file mode 100755
index 0000000..90f1ebf
--- /dev/null
+++ b/CordovaLib/javascripts/core/geolocation.js
@@ -0,0 +1,285 @@
+if (!Cordova.hasResource("geolocation")) {
+ Cordova.addResource("geolocation");
+
+/**
+ * This class provides access to device GPS data.
+ * @constructor
+ */
+Geolocation = function() {
+ // The last known GPS position.
+ this.lastPosition = null;
+ this.listener = null;
+ this.timeoutTimerId = 0;
+
+};
+
+
+/**
+ * Asynchronously aquires the current position.
+ * @param {Function} successCallback The function to call when the position
+ * data is available
+ * @param {Function} errorCallback The function to call when there is an error
+ * getting the position data.
+ * @param {PositionOptions} options The options for getting the position data
+ * such as timeout.
+ * PositionOptions.forcePrompt:Bool default false,
+ * - tells iPhone to prompt the user to turn on location services.
+ * - may cause your app to exit while the user is sent to the Settings app
+ * PositionOptions.distanceFilter:double aka Number
+ * - used to represent a distance in meters.
+PositionOptions
+{
+ desiredAccuracy:Number
+ - a distance in meters
+ < 10 = best accuracy ( Default value )
+ < 100 = Nearest Ten Meters
+ < 1000 = Nearest Hundred Meters
+ < 3000 = Accuracy Kilometers
+ 3000+ = Accuracy 3 Kilometers
+
+ forcePrompt:Boolean default false ( iPhone Only! )
+ - tells iPhone to prompt the user to turn on location services.
+ - may cause your app to exit while the user is sent to the Settings app
+
+ distanceFilter:Number
+ - The minimum distance (measured in meters) a device must move laterally before an update event is generated.
+ - measured relative to the previously delivered location
+ - default value: null ( all movements will be reported )
+
+}
+
+ */
+
+Geolocation.prototype.getCurrentPosition = function(successCallback, errorCallback, options)
+{
+ // create an always valid local success callback
+ var win = successCallback;
+ if (!win || typeof(win) != 'function')
+ {
+ win = function(position) {};
+ }
+
+ // create an always valid local error callback
+ var fail = errorCallback;
+ if (!fail || typeof(fail) != 'function')
+ {
+ fail = function(positionError) {};
+ }
+
+ var self = this;
+ var totalTime = 0;
+ var timeoutTimerId;
+
+ // set params to our default values
+ var params = new PositionOptions();
+
+ if (options)
+ {
+ if (options.maximumAge)
+ {
+ // special case here if we have a cached value that is younger than maximumAge
+ if(this.lastPosition)
+ {
+ var now = new Date().getTime();
+ if((now - this.lastPosition.timestamp) < options.maximumAge)
+ {
+ win(this.lastPosition); // send cached position immediately
+ return; // Note, execution stops here -jm
+ }
+ }
+ params.maximumAge = options.maximumAge;
+ }
+ if (options.enableHighAccuracy)
+ {
+ params.enableHighAccuracy = (options.enableHighAccuracy == true); // make sure it's truthy
+ }
+ if (options.timeout)
+ {
+ params.timeout = options.timeout;
+ }
+ }
+
+ var successListener = win;
+ var failListener = fail;
+ if (!this.locationRunning)
+ {
+ successListener = function(position)
+ {
+ win(position);
+ self.stop();
+ };
+ errorListener = function(positionError)
+ {
+ fail(positionError);
+ self.stop();
+ };
+ }
+
+ this.listener = {"success":successListener,"fail":failListener};
+ this.start(params);
+
+ var onTimeout = function()
+ {
+ self.setError(new PositionError(PositionError.TIMEOUT,"Geolocation Error: Timeout."));
+ };
+
+ clearTimeout(this.timeoutTimerId);
+ this.timeoutTimerId = setTimeout(onTimeout, params.timeout);
+};
+
+/**
+ * Asynchronously aquires the position repeatedly at a given interval.
+ * @param {Function} successCallback The function to call each time the position
+ * data is available
+ * @param {Function} errorCallback The function to call when there is an error
+ * getting the position data.
+ * @param {PositionOptions} options The options for getting the position data
+ * such as timeout and the frequency of the watch.
+ */
+Geolocation.prototype.watchPosition = function(successCallback, errorCallback, options) {
+ // Invoke the appropriate callback with a new Position object every time the implementation
+ // determines that the position of the hosting device has changed.
+
+ var self = this; // those == this & that
+
+ var params = new PositionOptions();
+
+ if(options)
+ {
+ if (options.maximumAge) {
+ params.maximumAge = options.maximumAge;
+ }
+ if (options.enableHighAccuracy) {
+ params.enableHighAccuracy = options.enableHighAccuracy;
+ }
+ if (options.timeout) {
+ params.timeout = options.timeout;
+ }
+ }
+
+ var that = this;
+ var lastPos = that.lastPosition? that.lastPosition.clone() : null;
+
+ var intervalFunction = function() {
+
+ var filterFun = function(position) {
+ if (lastPos == null || !position.equals(lastPos)) {
+ // only call the success callback when there is a change in position, per W3C
+ successCallback(position);
+ }
+
+ // clone the new position, save it as our last position (internal var)
+ lastPos = position.clone();
+ };
+
+ that.getCurrentPosition(filterFun, errorCallback, params);
+ };
+
+ // Retrieve location immediately and schedule next retrieval afterwards
+ intervalFunction();
+
+ return setInterval(intervalFunction, params.timeout);
+};
+
+
+/**
+ * Clears the specified position watch.
+ * @param {String} watchId The ID of the watch returned from #watchPosition.
+ */
+Geolocation.prototype.clearWatch = function(watchId) {
+ clearInterval(watchId);
+};
+
+/**
+ * Called by the geolocation framework when the current location is found.
+ * @param {PositionOptions} position The current position.
+ */
+Geolocation.prototype.setLocation = function(position)
+{
+ var _position = new Position(position.coords, position.timestamp);
+
+ if(this.timeoutTimerId)
+ {
+ clearTimeout(this.timeoutTimerId);
+ this.timeoutTimerId = 0;
+ }
+
+ this.lastError = null;
+ this.lastPosition = _position;
+
+ if(this.listener && typeof(this.listener.success) == 'function')
+ {
+ this.listener.success(_position);
+ }
+
+ this.listener = null;
+};
+
+/**
+ * Called by the geolocation framework when an error occurs while looking up the current position.
+ * @param {String} message The text of the error message.
+ */
+Geolocation.prototype.setError = function(error)
+{
+ var _error = new PositionError(error.code, error.message);
+
+ this.locationRunning = false
+
+ if(this.timeoutTimerId)
+ {
+ clearTimeout(this.timeoutTimerId);
+ this.timeoutTimerId = 0;
+ }
+
+ this.lastError = _error;
+ // call error handlers directly
+ if(this.listener && typeof(this.listener.fail) == 'function')
+ {
+ this.listener.fail(_error);
+ }
+ this.listener = null;
+
+};
+
+Geolocation.prototype.start = function(positionOptions)
+{
+ Cordova.exec(null, null, "org.apache.cordova.geolocation", "startLocation", [positionOptions]);
+ this.locationRunning = true
+
+};
+
+Geolocation.prototype.stop = function()
+{
+ Cordova.exec(null, null, "org.apache.cordova.geolocation", "stopLocation", []);
+ this.locationRunning = false
+};
+
+
+Cordova.addConstructor(function()
+{
+ if (typeof navigator._geo == "undefined")
+ {
+ // replace origObj's functions ( listed in funkList ) with the same method name on proxyObj
+ // this is a workaround to prevent UIWebView/MobileSafari default implementation of GeoLocation
+ // because it includes the full page path as the title of the alert prompt
+ var __proxyObj = function (origObj,proxyObj,funkList)
+ {
+ var replaceFunk = function(org,proxy,fName)
+ {
+ org[fName] = function()
+ {
+ return proxy[fName].apply(proxy,arguments);
+ };
+ };
+
+ for(var v in funkList) { replaceFunk(origObj,proxyObj,funkList[v]);}
+ }
+ navigator._geo = new Geolocation();
+ __proxyObj(navigator.geolocation, navigator._geo,
+ ["setLocation","getCurrentPosition","watchPosition",
+ "clearWatch","setError","start","stop"]);
+
+ }
+
+});
+};
http://git-wip-us.apache.org/repos/asf/incubator-cordova-ios/blob/bcff9559/CordovaLib/javascripts/core/license.js
----------------------------------------------------------------------
diff --git a/CordovaLib/javascripts/core/license.js b/CordovaLib/javascripts/core/license.js
new file mode 100644
index 0000000..b7535ad
--- /dev/null
+++ b/CordovaLib/javascripts/core/license.js
@@ -0,0 +1,21 @@
+/* Cordova v{VERSION} */
+/*
+ Licensed to the Apache Software Foundation (ASF) under one
+ or more contributor license agreements. See the NOTICE file
+ distributed with this work for additional information
+ regarding copyright ownership. The ASF licenses this file
+ to you under the Apache License, Version 2.0 (the
+ "License"); you may not use this file except in compliance
+ with the License. You may obtain a copy of the License at
+
+ http://www.apache.org/licenses/LICENSE-2.0
+
+ Unless required by applicable law or agreed to in writing,
+ software distributed under the License is distributed on an
+ "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ KIND, either express or implied. See the License for the
+ specific language governing permissions and limitations
+ under the License.
+*/
+
+
http://git-wip-us.apache.org/repos/asf/incubator-cordova-ios/blob/bcff9559/CordovaLib/javascripts/core/media.js
----------------------------------------------------------------------
diff --git a/CordovaLib/javascripts/core/media.js b/CordovaLib/javascripts/core/media.js
new file mode 100644
index 0000000..325bd97
--- /dev/null
+++ b/CordovaLib/javascripts/core/media.js
@@ -0,0 +1,217 @@
+
+if (!Cordova.hasResource("media")) {
+ Cordova.addResource("media");
+
+/**
+ * List of media objects.
+ * PRIVATE
+ */
+Cordova.mediaObjects = {};
+
+/**
+ * Object that receives native callbacks.
+ * PRIVATE
+ */
+Cordova.Media = function() {};
+
+
+/**
+ * Get the media object.
+ * PRIVATE
+ *
+ * @param id The media object id (string)
+ */
+Cordova.Media.getMediaObject = function(id) {
+ return Cordova.mediaObjects[id];
+};
+
+/**
+ * Audio has status update.
+ * PRIVATE
+ *
+ * @param id The media object id (string)
+ * @param msg The status message (int)
+ * @param value The status code (int)
+ */
+Cordova.Media.onStatus = function(id, msg, value) {
+ var media = Cordova.mediaObjects[id];
+
+ // If state update
+ if (msg == Media.MEDIA_STATE) {
+ if (value == Media.MEDIA_STOPPED) {
+ if (media.successCallback) {
+ media.successCallback();
+ }
+ }
+ if (media.statusCallback) {
+ media.statusCallback(value);
+ }
+ }
+ else if (msg == Media.MEDIA_DURATION) {
+ media._duration = value;
+ }
+ else if (msg == Media.MEDIA_ERROR) {
+ if (media.errorCallback) {
+ media.errorCallback(value);
+ }
+ }
+ else if (msg == Media.MEDIA_POSITION) {
+ media._position = value;
+ }
+};
+
+/**
+ * This class provides access to the device media, interfaces to both sound and video
+ *
+ * @param src The file name or url to play
+ * @param successCallback The callback to be called when the file is done playing or recording.
+ * successCallback() - OPTIONAL
+ * @param errorCallback The callback to be called if there is an error.
+ * errorCallback(int errorCode) - OPTIONAL
+ * @param statusCallback The callback to be called when media status has changed.
+ * statusCallback(int statusCode) - OPTIONAL
+ * @param positionCallback The callback to be called when media position has changed.
+ * positionCallback(long position) - OPTIONAL
+ */
+Media = function(src, successCallback, errorCallback, statusCallback, positionCallback) {
+
+ // successCallback optional
+ if (successCallback && (typeof successCallback != "function")) {
+ console.log("Media Error: successCallback is not a function");
+ return;
+ }
+
+ // errorCallback optional
+ if (errorCallback && (typeof errorCallback != "function")) {
+ console.log("Media Error: errorCallback is not a function");
+ return;
+ }
+
+ // statusCallback optional
+ if (statusCallback && (typeof statusCallback != "function")) {
+ console.log("Media Error: statusCallback is not a function");
+ return;
+ }
+
+ // positionCallback optional -- NOT SUPPORTED
+ if (positionCallback && (typeof positionCallback != "function")) {
+ console.log("Media Error: positionCallback is not a function");
+ return;
+ }
+
+ this.id = Cordova.createUUID();
+ Cordova.mediaObjects[this.id] = this;
+ this.src = src;
+ this.successCallback = successCallback;
+ this.errorCallback = errorCallback;
+ this.statusCallback = statusCallback;
+ this.positionCallback = positionCallback;
+ this._duration = -1;
+ this._position = -1;
+};
+
+// Media messages
+Media.MEDIA_STATE = 1;
+Media.MEDIA_DURATION = 2;
+Media.MEDIA_POSITION = 3;
+Media.MEDIA_ERROR = 9;
+
+// Media states
+Media.MEDIA_NONE = 0;
+Media.MEDIA_STARTING = 1;
+Media.MEDIA_RUNNING = 2;
+Media.MEDIA_PAUSED = 3;
+Media.MEDIA_STOPPED = 4;
+Media.MEDIA_MSG = ["None", "Starting", "Running", "Paused", "Stopped"];
+
+// TODO: Will MediaError be used?
+/**
+ * This class contains information about any Media errors.
+ * @constructor
+ */
+
+MediaError = function() {
+ this.code = null,
+ this.message = "";
+}
+
+MediaError.MEDIA_ERR_ABORTED = 1;
+MediaError.MEDIA_ERR_NETWORK = 2;
+MediaError.MEDIA_ERR_DECODE = 3;
+MediaError.MEDIA_ERR_NONE_SUPPORTED = 4;
+
+/**
+ * Start or resume playing audio file.
+ */
+Media.prototype.play = function(options) {
+ Cordova.exec(null, null, "org.apache.cordova.media", "play", [this.id, this.src, options]);
+};
+
+/**
+ * Stop playing audio file.
+ */
+Media.prototype.stop = function() {
+ Cordova.exec(null, null, "org.apache.cordova.media","stop", [this.id, this.src]);
+};
+
+/**
+ * Pause playing audio file.
+ */
+Media.prototype.pause = function() {
+ Cordova.exec(null, null, "org.apache.cordova.media","pause", [this.id, this.src]);
+};
+
+/**
+ * Seek or jump to a new time in the track..
+ */
+Media.prototype.seekTo = function(milliseconds) {
+ Cordova.exec(null, null, "org.apache.cordova.media", "seekTo", [this.id, this.src, milliseconds]);
+};
+
+/**
+ * Get duration of an audio file.
+ * The duration is only set for audio that is playing, paused or stopped.
+ *
+ * @return duration or -1 if not known.
+ */
+Media.prototype.getDuration = function() {
+ return this._duration;
+};
+
+/**
+ * Get position of audio.
+ *
+ * @return
+ */
+Media.prototype.getCurrentPosition = function(successCB, errorCB) {
+ var errCallback = (errorCB == undefined || errorCB == null) ? null : errorCB;
+ Cordova.exec(successCB, errorCB, "org.apache.cordova.media", "getCurrentPosition", [this.id, this.src]);
+};
+
+// iOS only. prepare/load the audio in preparation for playing
+Media.prototype.prepare = function(successCB, errorCB) {
+ Cordova.exec(successCB, errorCB, "org.apache.cordova.media", "prepare", [this.id, this.src]);
+}
+
+/**
+ * Start recording audio file.
+ */
+Media.prototype.startRecord = function() {
+ Cordova.exec(null, null, "org.apache.cordova.media","startAudioRecord", [this.id, this.src]);
+};
+
+/**
+ * Stop recording audio file.
+ */
+Media.prototype.stopRecord = function() {
+ Cordova.exec(null, null, "org.apache.cordova.media","stopAudioRecord", [this.id, this.src]);
+};
+
+/**
+ * Release the resources.
+ */
+Media.prototype.release = function() {
+ Cordova.exec(null, null, "org.apache.cordova.media","release", [this.id, this.src]);
+};
+
+};
http://git-wip-us.apache.org/repos/asf/incubator-cordova-ios/blob/bcff9559/CordovaLib/javascripts/core/network.js
----------------------------------------------------------------------
diff --git a/CordovaLib/javascripts/core/network.js b/CordovaLib/javascripts/core/network.js
new file mode 100644
index 0000000..1bd1102
--- /dev/null
+++ b/CordovaLib/javascripts/core/network.js
@@ -0,0 +1,34 @@
+if (!Cordova.hasResource("network")) {
+ Cordova.addResource("network");
+
+// //////////////////////////////////////////////////////////////////
+
+Connection = function() {
+ /*
+ * One of the connection constants below.
+ */
+ this.type = Connection.UNKNOWN;
+
+ /* initialize from the extended DeviceInfo properties */
+ try {
+ this.type = DeviceInfo.connection.type;
+ }
+ catch(e) {
+ }
+};
+
+Connection.UNKNOWN = "unknown"; // Unknown connection type
+Connection.ETHERNET = "ethernet";
+Connection.WIFI = "wifi";
+Connection.CELL_2G = "2g"; // the default for iOS, for any cellular connection
+Connection.CELL_3G = "3g";
+Connection.CELL_4G = "4g";
+Connection.NONE = "none"; // NO connectivity
+
+
+Cordova.addConstructor(function() {
+ if (typeof navigator.network == "undefined") navigator.network = {};
+ if (typeof navigator.network.connection == "undefined") navigator.network.connection = new Connection();
+});
+
+};
\ No newline at end of file
http://git-wip-us.apache.org/repos/asf/incubator-cordova-ios/blob/bcff9559/CordovaLib/javascripts/core/notification.js
----------------------------------------------------------------------
diff --git a/CordovaLib/javascripts/core/notification.js b/CordovaLib/javascripts/core/notification.js
new file mode 100644
index 0000000..0417817
--- /dev/null
+++ b/CordovaLib/javascripts/core/notification.js
@@ -0,0 +1,64 @@
+if (!Cordova.hasResource("notification")) {
+ Cordova.addResource("notification");
+
+/**
+ * This class provides access to notifications on the device.
+ */
+Notification = function() {
+};
+
+/**
+ * Open a native alert dialog, with a customizable title and button text.
+ *
+ * @param {String} message Message to print in the body of the alert
+ * @param {Function} completeCallback The callback that is called when user clicks on a button.
+ * @param {String} title Title of the alert dialog (default: Alert)
+ * @param {String} buttonLabel Label of the close button (default: OK)
+ */
+Notification.prototype.alert = function(message, completeCallback, title, buttonLabel) {
+ var _title = title;
+ if (title == null || typeof title === 'undefined') {
+ _title = "Alert";
+ }
+ var _buttonLabel = (buttonLabel || "OK");
+ Cordova.exec(completeCallback, null, "org.apache.cordova.notification", "alert", [message,{ "title": _title, "buttonLabel": _buttonLabel}]);
+};
+
+/**
+ * Open a native confirm dialog, with a customizable title and button text.
+ * The result that the user selects is returned to the result callback.
+ *
+ * @param {String} message Message to print in the body of the alert
+ * @param {Function} resultCallback The callback that is called when user clicks on a button.
+ * @param {String} title Title of the alert dialog (default: Confirm)
+ * @param {String} buttonLabels Comma separated list of the labels of the buttons (default: 'OK,Cancel')
+ */
+Notification.prototype.confirm = function(message, resultCallback, title, buttonLabels) {
+ var _title = (title || "Confirm");
+ var _buttonLabels = (buttonLabels || "OK,Cancel");
+ this.alert(message, resultCallback, _title, _buttonLabels);
+};
+
+/**
+ * Causes the device to blink a status LED.
+ * @param {Integer} count The number of blinks.
+ * @param {String} colour The colour of the light.
+ */
+Notification.prototype.blink = function(count, colour) {
+// NOT IMPLEMENTED
+};
+
+Notification.prototype.vibrate = function(mills) {
+ Cordova.exec(null, null, "org.apache.cordova.notification", "vibrate", []);
+};
+
+Notification.prototype.beep = function(count, volume) {
+ // No Volume yet for the iphone interface
+ // We can use a canned beep sound and call that
+ new Media('beep.wav').play();
+};
+
+Cordova.addConstructor(function() {
+ if (typeof navigator.notification == "undefined") navigator.notification = new Notification();
+});
+};
http://git-wip-us.apache.org/repos/asf/incubator-cordova-ios/blob/bcff9559/CordovaLib/javascripts/core/orientation.js
----------------------------------------------------------------------
diff --git a/CordovaLib/javascripts/core/orientation.js b/CordovaLib/javascripts/core/orientation.js
new file mode 100644
index 0000000..d00e134
--- /dev/null
+++ b/CordovaLib/javascripts/core/orientation.js
@@ -0,0 +1,125 @@
+if (!Cordova.hasResource("orientation")) {
+ Cordova.addResource("orientation");
+
+/**
+ * This class provides access to the device orientation.
+ * @constructor
+ */
+Orientation = function() {
+ /**
+ * The current orientation, or null if the orientation hasn't changed yet.
+ */
+ this.currentOrientation = null;
+}
+
+/**
+ * Set the current orientation of the phone. This is called from the device automatically.
+ *
+ * When the orientation is changed, the DOMEvent \c orientationChanged is dispatched against
+ * the document element. The event has the property \c orientation which can be used to retrieve
+ * the device's current orientation, in addition to the \c Orientation.currentOrientation class property.
+ *
+ * @param {Number} orientation The orientation to be set
+ */
+Orientation.prototype.setOrientation = function(orientation) {
+ Orientation.currentOrientation = orientation;
+ var e = document.createEvent('Events');
+ e.initEvent('orientationChanged', 'false', 'false');
+ e.orientation = orientation;
+ document.dispatchEvent(e);
+};
+
+/**
+ * Asynchronously aquires the current orientation.
+ * @param {Function} successCallback The function to call when the orientation
+ * is known.
+ * @param {Function} errorCallback The function to call when there is an error
+ * getting the orientation.
+ */
+Orientation.prototype.getCurrentOrientation = function(successCallback, errorCallback) {
+ // If the position is available then call success
+ // If the position is not available then call error
+};
+
+/**
+ * Asynchronously aquires the orientation repeatedly at a given interval.
+ * @param {Function} successCallback The function to call each time the orientation
+ * data is available.
+ * @param {Function} errorCallback The function to call when there is an error
+ * getting the orientation data.
+ */
+Orientation.prototype.watchOrientation = function(successCallback, errorCallback) {
+ // Invoke the appropriate callback with a new Position object every time the implementation
+ // determines that the position of the hosting device has changed.
+ this.getCurrentPosition(successCallback, errorCallback);
+ return setInterval(function() {
+ navigator.orientation.getCurrentOrientation(successCallback, errorCallback);
+ }, 10000);
+};
+
+/**
+ * Clears the specified orientation watch.
+ * @param {String} watchId The ID of the watch returned from #watchOrientation.
+ */
+Orientation.prototype.clearWatch = function(watchId) {
+ clearInterval(watchId);
+};
+
+Orientation.install = function()
+{
+ if (typeof navigator.orientation == "undefined") {
+ navigator.orientation = new Orientation();
+ }
+
+ var windowDispatchAvailable = !(window.dispatchEvent === undefined); // undefined in iOS 3.x
+ if (windowDispatchAvailable) {
+ return;
+ }
+
+ // the code below is to capture window.add/remove eventListener calls on window
+ // this is for iOS 3.x where listening on 'orientationchange' events don't work on document/window (don't know why)
+ // however, window.onorientationchange DOES handle the 'orientationchange' event (sent through document), so...
+ // then we multiplex the window.onorientationchange event (consequently - people shouldn't overwrite this)
+
+ var self = this;
+ var orientationchangeEvent = 'orientationchange';
+ var newOrientationchangeEvent = 'orientationchange_pg';
+
+ // backup original `window.addEventListener`, `window.removeEventListener`
+ var _addEventListener = window.addEventListener;
+ var _removeEventListener = window.removeEventListener;
+
+ window.onorientationchange = function() {
+ Cordova.fireEvent(newOrientationchangeEvent, window);
+ }
+
+ // override `window.addEventListener`
+ window.addEventListener = function() {
+ if (arguments[0] === orientationchangeEvent) {
+ arguments[0] = newOrientationchangeEvent;
+ }
+
+ if (!windowDispatchAvailable) {
+ return document.addEventListener.apply(this, arguments);
+ } else {
+ return _addEventListener.apply(this, arguments);
+ }
+ };
+
+ // override `window.removeEventListener'
+ window.removeEventListener = function() {
+ if (arguments[0] === orientationchangeEvent) {
+ arguments[0] = newOrientationchangeEvent;
+ }
+
+ if (!windowDispatchAvailable) {
+ return document.removeEventListener.apply(this, arguments);
+ } else {
+ return _removeEventListener.apply(this, arguments);
+ }
+ };
+};
+
+Cordova.addConstructor(Orientation.install);
+
+};
http://git-wip-us.apache.org/repos/asf/incubator-cordova-ios/blob/bcff9559/CordovaLib/javascripts/core/position.js
----------------------------------------------------------------------
diff --git a/CordovaLib/javascripts/core/position.js b/CordovaLib/javascripts/core/position.js
new file mode 100644
index 0000000..c154db8
--- /dev/null
+++ b/CordovaLib/javascripts/core/position.js
@@ -0,0 +1,130 @@
+if (!Cordova.hasResource("position")) {
+ Cordova.addResource("position");
+
+/**
+ * This class contains position information.
+ * @param {Object} lat
+ * @param {Object} lng
+ * @param {Object} acc
+ * @param {Object} alt
+ * @param {Object} altAcc
+ * @param {Object} head
+ * @param {Object} vel
+ * @constructor
+ */
+Position = function(coords, timestamp) {
+ this.coords = Coordinates.cloneFrom(coords);
+ this.timestamp = timestamp || new Date().getTime();
+};
+
+Position.prototype.equals = function(other) {
+ return (this.coords && other && other.coords &&
+ this.coords.latitude == other.coords.latitude &&
+ this.coords.longitude == other.coords.longitude);
+};
+
+Position.prototype.clone = function()
+{
+ return new Position(
+ this.coords? this.coords.clone() : null,
+ this.timestamp? this.timestamp : new Date().getTime()
+ );
+}
+
+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 altitude of the position.
+ */
+ this.altitude = alt;
+ /**
+ * The accuracy of the position.
+ */
+ this.accuracy = acc;
+ /**
+ * The direction the device is moving at the position.
+ */
+ this.heading = head;
+ /**
+ * The velocity with which the device is moving at the position.
+ */
+ this.speed = vel;
+ /**
+ * The altitude accuracy of the position.
+ */
+ this.altitudeAccuracy = (altAcc != 'undefined') ? altAcc : null;
+};
+
+Coordinates.prototype.clone = function()
+{
+ return new Coordinates(
+ this.latitude,
+ this.longitude,
+ this.altitude,
+ this.accuracy,
+ this.heading,
+ this.speed,
+ this.altitudeAccuracy
+ );
+};
+
+Coordinates.cloneFrom = function(obj)
+{
+ return new Coordinates(
+ obj.latitude,
+ obj.longitude,
+ obj.altitude,
+ obj.accuracy,
+ obj.heading,
+ obj.speed,
+ obj.altitudeAccuracy
+ );
+};
+
+/**
+ * This class specifies the options for requesting position data.
+ * @constructor
+ */
+PositionOptions = function(enableHighAccuracy, timeout, maximumAge) {
+ /**
+ * Specifies the desired position accuracy.
+ */
+ this.enableHighAccuracy = enableHighAccuracy || false;
+ /**
+ * The timeout after which if position data cannot be obtained the errorCallback
+ * is called.
+ */
+ this.timeout = timeout || 10000;
+ /**
+ * The age of a cached position whose age is no greater than the specified time
+ * in milliseconds.
+ */
+ this.maximumAge = maximumAge || 0;
+
+ if (this.maximumAge < 0) {
+ this.maximumAge = 0;
+ }
+};
+
+/**
+ * This class contains information about any GPS errors.
+ * @constructor
+ */
+PositionError = function(code, message) {
+ this.code = code || 0;
+ this.message = message || "";
+};
+
+PositionError.UNKNOWN_ERROR = 0;
+PositionError.PERMISSION_DENIED = 1;
+PositionError.POSITION_UNAVAILABLE = 2;
+PositionError.TIMEOUT = 3;
+
+};
\ No newline at end of file
http://git-wip-us.apache.org/repos/asf/incubator-cordova-ios/blob/bcff9559/CordovaLib/javascripts/core/sms.js
----------------------------------------------------------------------
diff --git a/CordovaLib/javascripts/core/sms.js b/CordovaLib/javascripts/core/sms.js
new file mode 100644
index 0000000..03e2d4e
--- /dev/null
+++ b/CordovaLib/javascripts/core/sms.js
@@ -0,0 +1,27 @@
+if (!Cordova.hasResource("sms")) {
+ Cordova.addResource("sms");
+
+/**
+ * This class provides access to the device SMS functionality.
+ * @constructor
+ */
+Sms = function() {
+
+}
+
+/**
+ * Sends an SMS message.
+ * @param {Integer} number The phone number to send the message to.
+ * @param {String} message The contents of the SMS message to send.
+ * @param {Function} successCallback The function to call when the SMS message is sent.
+ * @param {Function} errorCallback The function to call when there is an error sending the SMS message.
+ * @param {PositionOptions} options The options for accessing the GPS location such as timeout and accuracy.
+ */
+Sms.prototype.send = function(number, message, successCallback, errorCallback, options) {
+ // not sure why this is here when it does nothing????
+};
+
+Cordova.addConstructor(function() {
+ if (typeof navigator.sms == "undefined") navigator.sms = new Sms();
+});
+};
http://git-wip-us.apache.org/repos/asf/incubator-cordova-ios/blob/bcff9559/CordovaLib/javascripts/core/splashscreen.js
----------------------------------------------------------------------
diff --git a/CordovaLib/javascripts/core/splashscreen.js b/CordovaLib/javascripts/core/splashscreen.js
new file mode 100644
index 0000000..f6f6b73
--- /dev/null
+++ b/CordovaLib/javascripts/core/splashscreen.js
@@ -0,0 +1,22 @@
+if (!Cordova.hasResource("splashscreen")) {
+ Cordova.addResource("splashscreen");
+
+/**
+ * This class provides access to the splashscreen
+ */
+SplashScreen = function() {
+};
+
+SplashScreen.prototype.show = function() {
+ Cordova.exec(null, null, "org.apache.cordova.splashscreen", "show", []);
+};
+
+SplashScreen.prototype.hide = function() {
+ Cordova.exec(null, null, "org.apache.cordova.splashscreen", "hide", []);
+};
+
+Cordova.addConstructor(function() {
+ if (typeof navigator.splashscreen == "undefined") navigator.splashscreen = new SplashScreen();
+});
+
+};
http://git-wip-us.apache.org/repos/asf/incubator-cordova-ios/blob/bcff9559/CordovaLib/javascripts/core/telephony.js
----------------------------------------------------------------------
diff --git a/CordovaLib/javascripts/core/telephony.js b/CordovaLib/javascripts/core/telephony.js
new file mode 100644
index 0000000..9f946a2
--- /dev/null
+++ b/CordovaLib/javascripts/core/telephony.js
@@ -0,0 +1,23 @@
+if (!Cordova.hasResource("telephony")) {
+ Cordova.addResource("telephony");
+
+/**
+ * This class provides access to the telephony features of the device.
+ * @constructor
+ */
+Telephony = function() {
+
+}
+
+/**
+ * Calls the specifed number.
+ * @param {Integer} number The number to be called.
+ */
+Telephony.prototype.call = function(number) {
+ // not sure why this is here when it does nothing????
+};
+
+Cordova.addConstructor(function() {
+ if (typeof navigator.telephony == "undefined") navigator.telephony = new Telephony();
+});
+};
\ No newline at end of file
http://git-wip-us.apache.org/repos/asf/incubator-cordova-ios/blob/bcff9559/CordovaLib/javascripts/plugins/README.md
----------------------------------------------------------------------
diff --git a/CordovaLib/javascripts/plugins/README.md b/CordovaLib/javascripts/plugins/README.md
new file mode 100644
index 0000000..3fe82db
--- /dev/null
+++ b/CordovaLib/javascripts/plugins/README.md
@@ -0,0 +1,3 @@
+Phonegap Javascript Plugins
+=============================================================
+This is where you would put your Javascript plugin code. TBD
\ No newline at end of file
http://git-wip-us.apache.org/repos/asf/incubator-cordova-ios/blob/bcff9559/How to Use Cordova as a Component.md
----------------------------------------------------------------------
diff --git a/How to Use Cordova as a Component.md b/How to Use Cordova as a Component.md
new file mode 100644
index 0000000..82ccb8d
--- /dev/null
+++ b/How to Use Cordova as a Component.md
@@ -0,0 +1,131 @@
+# How to use Cordova as a Component #
+Beginning with Cordova 1.4, you can use Cordova as a component in your iOS applications. This component is code-named "Cleaver".
+
+New Cordova-based applications created using the Xcode template provided in Cordova 1.4 or greater uses Cleaver, and this template is considered the reference implementation for Cleaver.
+
+It is recommended that you follow the Cordova.framework instructions below, the CordovaLib sub-project instructions are for Cordova core developers or users that have custom CordovaLib project code (for ease of debugging the core).
+
+## Pre-requisites ##
+1. **Cordova 1.4** or greater installed
+2. **Xcode 4.2** or greater installed
+3. **Cordova.plist** file
+
+## Adding Cleaver to your Xcode project (Cordova.framework) ##
+
+1. **Copy** the **"Cordova.plist"** file into your project folder on disk
+2. **Drag and drop** the **"Cordova.plist"** file into the Project Navigator of Xcode
+3. **Choose** the radio-button **"Create groups for any added folders"**
+4. Press the key combination **Option-Command-A**, which should drop down a sheet to add files to your project (the **"Add Files..." sheet**). Make sure the **"Created groups for any added folders"** radio-button is selected
+5. Press the key combination **Shift-Command-G**, which should drop down another sheet for you to go to a folder (the **"Go to the folder:" sheet**)
+6. Enter **"/Users/Shared/Cordova/Frameworks/Cordova.framework"** in the **"Go to the folder:" sheet** and then press the **"Go"** button
+7. Press the **"Add"** button in the **"Add Files..." sheet**
+8. **Select "Cordova.framework"** in the Project Navigator
+9. Press the key combination **Option-Command-1** to show the **File Inspector**
+10. Choose **"Absolute Path"** in the **File Inspector** for the drop-down menu for **Location**
+11. Click on the **project icon** in the Project Navigator, select your **Target**, then select the **"Build Phase"** tab
+12. Expand **"Link Binaries with Libraries"**
+13. Click on the **"+" button**, and add these **frameworks** (and optionally in the Project Navigator, **move** them under the Frameworks group):
+
+ AddressBook.framework
+ AddressBookUI.framework
+ AudioToolbox.framework
+ AVFoundation.framework
+ CoreLocation.framework
+ MediaPlayer.framework
+ QuartzCore.framework
+ SystemConfiguration.framework
+ MobileCoreServices.framework
+ CoreMedia.framework
+
+## Adding Cleaver to your Xcode project (CordovaLib sub-project) ##
+
+1. **Copy** the **"Cordova.plist"** file into your project folder on disk
+2. **Drag and drop** the **"Cordova.plist"** file into the Project Navigator of Xcode
+3. **Choose** the radio-button **"Create groups for any added folders"**
+4. Press the key combination **Option-Command-A**, which should drop down a sheet to add files to your project (the **"Add Files..." sheet**). Make sure the **"Created groups for any added folders"** radio-button is selected
+5. Press the key combination **Shift-Command-G**, which should drop down another sheet for you to go to a folder (the **"Go to the folder:" sheet**)
+6. Enter **"~/Documents/CordovaLib/CordovaLib.xcodeproj"** in the **"Go to the folder:" sheet** and then press the **"Go"** button
+7. Press the **"Add"** button in the **"Add Files..." sheet**
+8. **Select "CordovaLib.xcodeproj"** in the Project Navigator
+9. Press the key combination **Option-Command-1** to show the **File Inspector**
+10. Choose **"Relative to CORDOVALIB"** in the **File Inspector** for the drop-down menu for **Location**
+11. Click on the **project icon** in the Project Navigator, select your **Project**, then select the **"Build Settings"** tab
+12. Enter **"Header Search Paths"** in the search field
+13. Enter **"$(CORDOVAPLIB)/Classes"** and check the **Recursive** checkbox - for the **"Header Search Paths"** value
+14. Click on the **project icon** in the Project Navigator, select your **Target**, then select the **"Build Phases"** tab
+15. Expand **"Link Binaries with Libraries"**
+16. Click on the **"+" button**, and add these **frameworks** (and optionally in the Project Navigator, **move** them under the Frameworks group):
+
+ AddressBook.framework
+ AddressBookUI.framework
+ AudioToolbox.framework
+ AVFoundation.framework
+ CoreLocation.framework
+ MediaPlayer.framework
+ QuartzCore.framework
+ SystemConfiguration.framework
+ MobileCoreServices.framework
+ CoreMedia.framework
+17. Expand **"Target Dependencies"**
+18. Click on the **"+" button**, and add the **"CordovaLib"** build product
+19. Expand **"Link Binaries with Libraries"**
+20. Click on the **"+" button**, and add **libCordova.a**
+
+## Using CDVViewController in your code ##
+
+1. Add this **header** if you used the **Cordova.framework**:
+
+ #import <Cordova/CDVViewController.h>
+
+2. Add this **header** if you used the **CordovaLib sub-project**:
+
+ #import "CDVViewController.h"
+
+3. Instantiate a **new** CDVViewController, and retain it somewhere:
+
+ CDVViewController* viewController = [CDVViewController new];
+
+4. (_OPTIONAL_) Set the **wwwFolderName** property (defaults to **"www"**):
+
+ viewController.wwwFolderName = @"myfolder";
+
+5. (_OPTIONAL_) Set the **startPage** property (defaults to **"index.html"**):
+
+ viewController.startPage = @"mystartpage.html";
+
+6. (_OPTIONAL_) Set the **useSplashScreen** property (defaults to **NO**):
+
+ viewController.useSplashScreen = YES;
+
+5. Set the **view frame** (always set this as the last property):
+
+ viewController.view.frame = CGRectMake(0, 0, 320, 480);
+
+6. **Add** Cleaver to your view:
+
+ [myView addSubview:viewController.view];
+
+## Adding your HTML, CSS and JavaScript assets ##
+
+1. Create a **new folder** in your project **on disk**, for example, name it "www"
+2. Put your **HTML, CSS and JavaScript assets** into this folder
+3. **Drag and drop** the folder into the Project Navigator of Xcode
+4. **Choose** the radio-button **"Create folder references for any added folders"**
+5. **Set the appropriate "wwwFolderName" and "startPage" properties** for the folder you created in **(1)** or use the defaults (see previous section) when you instantiate the CDVViewController.
+
+ /*
+ if you created a folder called 'myfolder' and
+ you want the file 'mypage.html' in it to be
+ the startPage
+ */
+ viewController.wwwFolderName = @"myfolder";
+ viewController.startPage = @"mypage.html"
+<br />
+
+## Cordova.plist ##
+
+This file controls various settings of Cordova. This is application wide, and not set per CDVViewController instance.
+
+1. A list of **Plugins** allowed to be used in a CDVViewController (set in the Plugins dictionary - key is the servicename used in JavaScript, and the value is the Objective-C class for the plugin that is a PGPlugin sub-class)
+2. A **white-list** of hosts (with no scheme) that Cordova is allowed to connect to (set in the ExternalHosts array - wildcards allowed)
+3. Various **other** settings (TODO:)