adding js and rdeleting irrelevant image files
diff --git a/samples/hello-cordova/js/cordova.js b/samples/hello-cordova/js/cordova.js
new file mode 100644
index 0000000..fda2690
--- /dev/null
+++ b/samples/hello-cordova/js/cordova.js
@@ -0,0 +1,7065 @@
+// commit 2aa46aa0eef2ba641cf91793735152d7fb5b6998
+
+// File generated at :: Mon Sep 03 2012 19:33:13 GMT-0700 (PDT)
+
+/*
+ Licensed to the Apache Software Foundation (ASF) under one
+ or more contributor license agreements. See the NOTICE file
+ distributed with this work for additional information
+ regarding copyright ownership. The ASF licenses this file
+ to you under the Apache License, Version 2.0 (the
+ "License"); you may not use this file except in compliance
+ with the License. You may obtain a copy of the License at
+
+ http://www.apache.org/licenses/LICENSE-2.0
+
+ Unless required by applicable law or agreed to in writing,
+ software distributed under the License is distributed on an
+ "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ KIND, either express or implied. See the License for the
+ specific language governing permissions and limitations
+ under the License.
+*/
+
+;(function() {
+
+// file: lib/scripts/require.js
+var require,
+ define;
+
+(function () {
+ var modules = {};
+
+ function build(module) {
+ var factory = module.factory;
+ module.exports = {};
+ delete module.factory;
+ factory(require, module.exports, module);
+ return module.exports;
+ }
+
+ require = function (id) {
+ if (!modules[id]) {
+ throw "module " + id + " not found";
+ }
+ return modules[id].factory ? build(modules[id]) : modules[id].exports;
+ };
+
+ define = function (id, factory) {
+ if (modules[id]) {
+ throw "module " + id + " already defined";
+ }
+
+ modules[id] = {
+ id: id,
+ factory: factory
+ };
+ };
+
+ define.remove = function (id) {
+ delete modules[id];
+ };
+
+})();
+
+//Export for use in node
+if (typeof module === "object" && typeof require === "function") {
+ module.exports.require = require;
+ module.exports.define = define;
+}
+// file: lib/cordova.js
+define("cordova", function(require, exports, module) {
+var channel = require('cordova/channel');
+
+/**
+ * Listen for DOMContentLoaded and notify our channel subscribers.
+ */
+document.addEventListener('DOMContentLoaded', function() {
+ channel.onDOMContentLoaded.fire();
+}, false);
+if (document.readyState == 'complete' || document.readyState == 'interactive') {
+ channel.onDOMContentLoaded.fire();
+}
+
+/**
+ * Intercept calls to addEventListener + removeEventListener and handle deviceready,
+ * resume, and pause events.
+ */
+var m_document_addEventListener = document.addEventListener;
+var m_document_removeEventListener = document.removeEventListener;
+var m_window_addEventListener = window.addEventListener;
+var m_window_removeEventListener = window.removeEventListener;
+
+/**
+ * Houses custom event handlers to intercept on document + window event listeners.
+ */
+var documentEventHandlers = {},
+ windowEventHandlers = {};
+
+document.addEventListener = function(evt, handler, capture) {
+ var e = evt.toLowerCase();
+ if (typeof documentEventHandlers[e] != 'undefined') {
+ if (evt === 'deviceready') {
+ documentEventHandlers[e].subscribeOnce(handler);
+ } else {
+ documentEventHandlers[e].subscribe(handler);
+ }
+ } else {
+ m_document_addEventListener.call(document, evt, handler, capture);
+ }
+};
+
+window.addEventListener = function(evt, handler, capture) {
+ var e = evt.toLowerCase();
+ if (typeof windowEventHandlers[e] != 'undefined') {
+ windowEventHandlers[e].subscribe(handler);
+ } else {
+ m_window_addEventListener.call(window, evt, handler, capture);
+ }
+};
+
+document.removeEventListener = function(evt, handler, capture) {
+ var e = evt.toLowerCase();
+ // If unsubcribing from an event that is handled by a plugin
+ if (typeof documentEventHandlers[e] != "undefined") {
+ documentEventHandlers[e].unsubscribe(handler);
+ } else {
+ m_document_removeEventListener.call(document, evt, handler, capture);
+ }
+};
+
+window.removeEventListener = function(evt, handler, capture) {
+ var e = evt.toLowerCase();
+ // If unsubcribing from an event that is handled by a plugin
+ if (typeof windowEventHandlers[e] != "undefined") {
+ windowEventHandlers[e].unsubscribe(handler);
+ } else {
+ m_window_removeEventListener.call(window, evt, handler, capture);
+ }
+};
+
+function createEvent(type, data) {
+ var event = document.createEvent('Events');
+ event.initEvent(type, false, false);
+ if (data) {
+ for (var i in data) {
+ if (data.hasOwnProperty(i)) {
+ event[i] = data[i];
+ }
+ }
+ }
+ return event;
+}
+
+if(typeof window.console === "undefined") {
+ window.console = {
+ log:function(){}
+ };
+}
+
+var cordova = {
+ define:define,
+ require:require,
+ /**
+ * Methods to add/remove your own addEventListener hijacking on document + window.
+ */
+ addWindowEventHandler:function(event, opts) {
+ return (windowEventHandlers[event] = channel.create(event, opts));
+ },
+ addDocumentEventHandler:function(event, opts) {
+ return (documentEventHandlers[event] = channel.create(event, opts));
+ },
+ removeWindowEventHandler:function(event) {
+ delete windowEventHandlers[event];
+ },
+ removeDocumentEventHandler:function(event) {
+ delete documentEventHandlers[event];
+ },
+ /**
+ * Retreive original event handlers that were replaced by Cordova
+ *
+ * @return object
+ */
+ getOriginalHandlers: function() {
+ return {'document': {'addEventListener': m_document_addEventListener, 'removeEventListener': m_document_removeEventListener},
+ 'window': {'addEventListener': m_window_addEventListener, 'removeEventListener': m_window_removeEventListener}};
+ },
+ /**
+ * Method to fire event from native code
+ */
+ fireDocumentEvent: function(type, data) {
+ var evt = createEvent(type, data);
+ if (typeof documentEventHandlers[type] != 'undefined') {
+ setTimeout(function() {
+ documentEventHandlers[type].fire(evt);
+ }, 0);
+ } else {
+ document.dispatchEvent(evt);
+ }
+ },
+ fireWindowEvent: function(type, data) {
+ var evt = createEvent(type,data);
+ if (typeof windowEventHandlers[type] != 'undefined') {
+ setTimeout(function() {
+ windowEventHandlers[type].fire(evt);
+ }, 0);
+ } else {
+ window.dispatchEvent(evt);
+ }
+ },
+
+ // TODO: iOS only
+ // This queue holds the currently executing command and all pending
+ // commands executed with cordova.exec().
+ commandQueue:[],
+ // Indicates if we're currently in the middle of flushing the command
+ // queue on the native side.
+ commandQueueFlushing:false,
+ // END TODO
+ /**
+ * Plugin callback mechanism.
+ */
+ callbackId: 0,
+ callbacks: {},
+ callbackStatus: {
+ NO_RESULT: 0,
+ OK: 1,
+ CLASS_NOT_FOUND_EXCEPTION: 2,
+ ILLEGAL_ACCESS_EXCEPTION: 3,
+ INSTANTIATION_EXCEPTION: 4,
+ MALFORMED_URL_EXCEPTION: 5,
+ IO_EXCEPTION: 6,
+ INVALID_ACTION: 7,
+ JSON_EXCEPTION: 8,
+ ERROR: 9
+ },
+
+ /**
+ * Called by native code when returning successful result from an action.
+ *
+ * @param callbackId
+ * @param args
+ */
+ callbackSuccess: function(callbackId, args) {
+ if (cordova.callbacks[callbackId]) {
+
+ // If result is to be sent to callback
+ if (args.status == cordova.callbackStatus.OK) {
+ try {
+ if (cordova.callbacks[callbackId].success) {
+ cordova.callbacks[callbackId].success(args.message);
+ }
+ }
+ catch (e) {
+ console.log("Error in success callback: "+callbackId+" = "+e);
+ }
+ }
+
+ // Clear callback if not expecting any more results
+ if (!args.keepCallback) {
+ delete cordova.callbacks[callbackId];
+ }
+ }
+ },
+
+ /**
+ * Called by native code when returning error result from an action.
+ *
+ * @param callbackId
+ * @param args
+ */
+ callbackError: function(callbackId, args) {
+ if (cordova.callbacks[callbackId]) {
+ try {
+ if (cordova.callbacks[callbackId].fail) {
+ cordova.callbacks[callbackId].fail(args.message);
+ }
+ }
+ catch (e) {
+ console.log("Error in error callback: "+callbackId+" = "+e);
+ }
+
+ // Clear callback if not expecting any more results
+ if (!args.keepCallback) {
+ delete cordova.callbacks[callbackId];
+ }
+ }
+ },
+ addConstructor: function(func) {
+ channel.onCordovaReady.subscribeOnce(function() {
+ try {
+ func();
+ } catch(e) {
+ console.log("Failed to run constructor: " + e);
+ }
+ });
+ }
+};
+
+// Register pause, resume and deviceready channels as events on document.
+channel.onPause = cordova.addDocumentEventHandler('pause');
+channel.onResume = cordova.addDocumentEventHandler('resume');
+channel.onDeviceReady = cordova.addDocumentEventHandler('deviceready');
+
+module.exports = cordova;
+
+});
+
+// file: lib/common/builder.js
+define("cordova/builder", function(require, exports, module) {
+var utils = require('cordova/utils');
+
+function each(objects, func, context) {
+ for (var prop in objects) {
+ if (objects.hasOwnProperty(prop)) {
+ func.apply(context, [objects[prop], prop]);
+ }
+ }
+}
+
+function include(parent, objects, clobber, merge) {
+ each(objects, function (obj, key) {
+ try {
+ var result = obj.path ? require(obj.path) : {};
+
+ if (clobber) {
+ // Clobber if it doesn't exist.
+ if (typeof parent[key] === 'undefined') {
+ parent[key] = result;
+ } else if (typeof obj.path !== 'undefined') {
+ // If merging, merge properties onto parent, otherwise, clobber.
+ if (merge) {
+ recursiveMerge(parent[key], result);
+ } else {
+ parent[key] = result;
+ }
+ }
+ result = parent[key];
+ } else {
+ // Overwrite if not currently defined.
+ if (typeof parent[key] == 'undefined') {
+ parent[key] = result;
+ } else if (merge && typeof obj.path !== 'undefined') {
+ // If merging, merge parent onto result
+ recursiveMerge(result, parent[key]);
+ parent[key] = result;
+ } else {
+ // Set result to what already exists, so we can build children into it if they exist.
+ result = parent[key];
+ }
+ }
+
+ if (obj.children) {
+ include(result, obj.children, clobber, merge);
+ }
+ } catch(e) {
+ utils.alert('Exception building cordova JS globals: ' + e + ' for key "' + key + '"');
+ }
+ });
+}
+
+/**
+ * Merge properties from one object onto another recursively. Properties from
+ * the src object will overwrite existing target property.
+ *
+ * @param target Object to merge properties into.
+ * @param src Object to merge properties from.
+ */
+function recursiveMerge(target, src) {
+ for (var prop in src) {
+ if (src.hasOwnProperty(prop)) {
+ if (typeof target.prototype !== 'undefined' && target.prototype.constructor === target) {
+ // If the target object is a constructor override off prototype.
+ target.prototype[prop] = src[prop];
+ } else {
+ target[prop] = typeof src[prop] === 'object' ? recursiveMerge(
+ target[prop], src[prop]) : src[prop];
+ }
+ }
+ }
+ return target;
+}
+
+module.exports = {
+ build: function (objects) {
+ return {
+ intoButDontClobber: function (target) {
+ include(target, objects, false, false);
+ },
+ intoAndClobber: function(target) {
+ include(target, objects, true, false);
+ },
+ intoAndMerge: function(target) {
+ include(target, objects, true, true);
+ }
+ };
+ }
+};
+
+});
+
+// file: lib/common/channel.js
+define("cordova/channel", function(require, exports, module) {
+var utils = require('cordova/utils'),
+ nextGuid = 1;
+
+/**
+ * Custom pub-sub "channel" that can have functions subscribed to it
+ * This object is used to define and control firing of events for
+ * cordova initialization.
+ *
+ * The order of events during page load and Cordova startup is as follows:
+ *
+ * onDOMContentLoaded Internal event that is received when the web page is loaded and parsed.
+ * onNativeReady Internal event that indicates the Cordova native side is ready.
+ * onCordovaReady Internal event fired when all Cordova JavaScript objects have been created.
+ * onCordovaInfoReady Internal event fired when device properties are available.
+ * onCordovaConnectionReady Internal event fired when the connection property has been set.
+ * onDeviceReady User event fired to indicate that Cordova is ready
+ * onResume User event fired to indicate a start/resume lifecycle event
+ * onPause User event fired to indicate a pause lifecycle event
+ * onDestroy Internal event fired when app is being destroyed (User should use window.onunload event, not this one).
+ *
+ * The only Cordova events that user code should register for are:
+ * deviceready Cordova native code is initialized and Cordova APIs can be called from JavaScript
+ * pause App has moved to background
+ * resume App has returned to foreground
+ *
+ * Listeners can be registered as:
+ * document.addEventListener("deviceready", myDeviceReadyListener, false);
+ * document.addEventListener("resume", myResumeListener, false);
+ * document.addEventListener("pause", myPauseListener, false);
+ *
+ * The DOM lifecycle events should be used for saving and restoring state
+ * window.onload
+ * window.onunload
+ *
+ */
+
+/**
+ * Channel
+ * @constructor
+ * @param type String the channel name
+ * @param opts Object options to pass into the channel, currently
+ * supports:
+ * onSubscribe: callback that fires when
+ * something subscribes to the Channel. Sets
+ * context to the Channel.
+ * onUnsubscribe: callback that fires when
+ * something unsubscribes to the Channel. Sets
+ * context to the Channel.
+ */
+var Channel = function(type, opts) {
+ this.type = type;
+ this.handlers = {};
+ this.numHandlers = 0;
+ this.fired = false;
+ this.enabled = true;
+ this.events = {
+ onSubscribe:null,
+ onUnsubscribe:null
+ };
+ if (opts) {
+ if (opts.onSubscribe) this.events.onSubscribe = opts.onSubscribe;
+ if (opts.onUnsubscribe) this.events.onUnsubscribe = opts.onUnsubscribe;
+ }
+},
+ channel = {
+ /**
+ * Calls the provided function only after all of the channels specified
+ * have been fired.
+ */
+ join: function (h, c) {
+ var i = c.length;
+ var len = i;
+ var f = function() {
+ if (!(--i)) h();
+ };
+ for (var j=0; j<len; j++) {
+ !c[j].fired?c[j].subscribeOnce(f):i--;
+ }
+ if (!i) h();
+ },
+ create: function (type, opts) {
+ channel[type] = new Channel(type, opts);
+ return channel[type];
+ },
+
+ /**
+ * cordova Channels that must fire before "deviceready" is fired.
+ */
+ deviceReadyChannelsArray: [],
+ deviceReadyChannelsMap: {},
+
+ /**
+ * Indicate that a feature needs to be initialized before it is ready to be used.
+ * This holds up Cordova's "deviceready" event until the feature has been initialized
+ * and Cordova.initComplete(feature) is called.
+ *
+ * @param feature {String} The unique feature name
+ */
+ waitForInitialization: function(feature) {
+ if (feature) {
+ var c = null;
+ if (this[feature]) {
+ c = this[feature];
+ }
+ else {
+ c = this.create(feature);
+ }
+ this.deviceReadyChannelsMap[feature] = c;
+ this.deviceReadyChannelsArray.push(c);
+ }
+ },
+
+ /**
+ * Indicate that initialization code has completed and the feature is ready to be used.
+ *
+ * @param feature {String} The unique feature name
+ */
+ initializationComplete: function(feature) {
+ var c = this.deviceReadyChannelsMap[feature];
+ if (c) {
+ c.fire();
+ }
+ }
+ };
+
+function forceFunction(f) {
+ if (f === null || f === undefined || typeof f != 'function') throw "Function required as first argument!";
+}
+
+/**
+ * Subscribes the given function to the channel. Any time that
+ * Channel.fire is called so too will the function.
+ * Optionally specify an execution context for the function
+ * and a guid that can be used to stop subscribing to the channel.
+ * Returns the guid.
+ */
+Channel.prototype.subscribe = function(f, c, g) {
+ // need a function to call
+ forceFunction(f);
+
+ var func = f;
+ if (typeof c == "object") { func = utils.close(c, f); }
+
+ g = g || func.observer_guid || f.observer_guid;
+ if (!g) {
+ // first time any channel has seen this subscriber
+ g = nextGuid++;
+ }
+ func.observer_guid = g;
+ f.observer_guid = g;
+
+ // Don't add the same handler more than once.
+ if (!this.handlers[g]) {
+ this.handlers[g] = func;
+ this.numHandlers++;
+ if (this.events.onSubscribe) this.events.onSubscribe.call(this);
+ if (this.fired) func.apply(this, this.fireArgs);
+ }
+ return g;
+};
+
+/**
+ * Like subscribe but the function is only called once and then it
+ * auto-unsubscribes itself.
+ */
+Channel.prototype.subscribeOnce = function(f, c) {
+ // need a function to call
+ forceFunction(f);
+
+ var g = null;
+ var _this = this;
+ if (this.fired) {
+ f.apply(c || null, this.fireArgs);
+ } else {
+ g = this.subscribe(function() {
+ _this.unsubscribe(g);
+ f.apply(c || null, arguments);
+ });
+ f.observer_guid = g;
+ }
+ return g;
+};
+
+/**
+ * Unsubscribes the function with the given guid from the channel.
+ */
+Channel.prototype.unsubscribe = function(g) {
+ // need a function to unsubscribe
+ if (g === null || g === undefined) { throw "You must pass _something_ into Channel.unsubscribe"; }
+
+ if (typeof g == 'function') { g = g.observer_guid; }
+ var handler = this.handlers[g];
+ if (handler) {
+ if (handler.observer_guid) handler.observer_guid=null;
+ delete this.handlers[g];
+ this.numHandlers--;
+ if (this.events.onUnsubscribe) this.events.onUnsubscribe.call(this);
+ }
+};
+
+/**
+ * Calls all functions subscribed to this channel.
+ */
+Channel.prototype.fire = function(e) {
+ if (this.enabled) {
+ var fail = false;
+ this.fired = true;
+ this.fireArgs = arguments;
+ // Copy the values first so that it is safe to modify it from within
+ // callbacks.
+ var toCall = [];
+ for (var item in this.handlers) {
+ toCall.push(this.handlers[item]);
+ }
+ for (var i = 0; i < toCall.length; ++i) {
+ var rv = (toCall[i].apply(this, arguments)===false);
+ fail = fail || rv;
+ }
+ return !fail;
+ }
+ return true;
+};
+
+// defining them here so they are ready super fast!
+// DOM event that is received when the web page is loaded and parsed.
+channel.create('onDOMContentLoaded');
+
+// Event to indicate the Cordova native side is ready.
+channel.create('onNativeReady');
+
+// Event to indicate that all Cordova JavaScript objects have been created
+// and it's time to run plugin constructors.
+channel.create('onCordovaReady');
+
+// Event to indicate that device properties are available
+channel.create('onCordovaInfoReady');
+
+// Event to indicate that the connection property has been set.
+channel.create('onCordovaConnectionReady');
+
+// Event to indicate that Cordova is ready
+channel.create('onDeviceReady');
+
+// Event to indicate a resume lifecycle event
+channel.create('onResume');
+
+// Event to indicate a pause lifecycle event
+channel.create('onPause');
+
+// Event to indicate a destroy lifecycle event
+channel.create('onDestroy');
+
+// Channels that must fire before "deviceready" is fired.
+channel.waitForInitialization('onCordovaReady');
+channel.waitForInitialization('onCordovaConnectionReady');
+
+module.exports = channel;
+
+});
+
+// file: lib/common/common.js
+define("cordova/common", function(require, exports, module) {
+module.exports = {
+ objects: {
+ cordova: {
+ path: 'cordova',
+ children: {
+ exec: {
+ path: 'cordova/exec'
+ },
+ logger: {
+ path: 'cordova/plugin/logger'
+ }
+ }
+ },
+ Cordova: {
+ children: {
+ exec: {
+ path: 'cordova/exec'
+ }
+ }
+ },
+ PhoneGap:{
+ children: {
+ exec: {
+ path: 'cordova/exec'
+ }
+ }
+ },
+ navigator: {
+ children: {
+ notification: {
+ path: 'cordova/plugin/notification'
+ },
+ accelerometer: {
+ path: 'cordova/plugin/accelerometer'
+ },
+ battery: {
+ path: 'cordova/plugin/battery'
+ },
+ camera:{
+ path: 'cordova/plugin/Camera'
+ },
+ compass:{
+ path: 'cordova/plugin/compass'
+ },
+ contacts: {
+ path: 'cordova/plugin/contacts'
+ },
+ device:{
+ children:{
+ capture: {
+ path: 'cordova/plugin/capture'
+ }
+ }
+ },
+ geolocation: {
+ path: 'cordova/plugin/geolocation'
+ },
+ network: {
+ children: {
+ connection: {
+ path: 'cordova/plugin/network'
+ }
+ }
+ },
+ splashscreen: {
+ path: 'cordova/plugin/splashscreen'
+ }
+ }
+ },
+ Acceleration: {
+ path: 'cordova/plugin/Acceleration'
+ },
+ Camera:{
+ path: 'cordova/plugin/CameraConstants'
+ },
+ CameraPopoverOptions: {
+ path: 'cordova/plugin/CameraPopoverOptions'
+ },
+ CaptureError: {
+ path: 'cordova/plugin/CaptureError'
+ },
+ CaptureAudioOptions:{
+ path: 'cordova/plugin/CaptureAudioOptions'
+ },
+ CaptureImageOptions: {
+ path: 'cordova/plugin/CaptureImageOptions'
+ },
+ CaptureVideoOptions: {
+ path: 'cordova/plugin/CaptureVideoOptions'
+ },
+ CompassHeading:{
+ path: 'cordova/plugin/CompassHeading'
+ },
+ CompassError:{
+ path: 'cordova/plugin/CompassError'
+ },
+ ConfigurationData: {
+ path: 'cordova/plugin/ConfigurationData'
+ },
+ Connection: {
+ path: 'cordova/plugin/Connection'
+ },
+ Contact: {
+ path: 'cordova/plugin/Contact'
+ },
+ ContactAddress: {
+ path: 'cordova/plugin/ContactAddress'
+ },
+ ContactError: {
+ path: 'cordova/plugin/ContactError'
+ },
+ ContactField: {
+ path: 'cordova/plugin/ContactField'
+ },
+ ContactFindOptions: {
+ path: 'cordova/plugin/ContactFindOptions'
+ },
+ ContactName: {
+ path: 'cordova/plugin/ContactName'
+ },
+ ContactOrganization: {
+ path: 'cordova/plugin/ContactOrganization'
+ },
+ Coordinates: {
+ path: 'cordova/plugin/Coordinates'
+ },
+ device: {
+ path: 'cordova/plugin/device'
+ },
+ DirectoryEntry: {
+ path: 'cordova/plugin/DirectoryEntry'
+ },
+ DirectoryReader: {
+ path: 'cordova/plugin/DirectoryReader'
+ },
+ Entry: {
+ path: 'cordova/plugin/Entry'
+ },
+ File: {
+ path: 'cordova/plugin/File'
+ },
+ FileEntry: {
+ path: 'cordova/plugin/FileEntry'
+ },
+ FileError: {
+ path: 'cordova/plugin/FileError'
+ },
+ FileReader: {
+ path: 'cordova/plugin/FileReader'
+ },
+ FileSystem: {
+ path: 'cordova/plugin/FileSystem'
+ },
+ FileTransfer: {
+ path: 'cordova/plugin/FileTransfer'
+ },
+ FileTransferError: {
+ path: 'cordova/plugin/FileTransferError'
+ },
+ FileUploadOptions: {
+ path: 'cordova/plugin/FileUploadOptions'
+ },
+ FileUploadResult: {
+ path: 'cordova/plugin/FileUploadResult'
+ },
+ FileWriter: {
+ path: 'cordova/plugin/FileWriter'
+ },
+ Flags: {
+ path: 'cordova/plugin/Flags'
+ },
+ LocalFileSystem: {
+ path: 'cordova/plugin/LocalFileSystem'
+ },
+ Media: {
+ path: 'cordova/plugin/Media'
+ },
+ MediaError: {
+ path: 'cordova/plugin/MediaError'
+ },
+ MediaFile: {
+ path: 'cordova/plugin/MediaFile'
+ },
+ MediaFileData:{
+ path: 'cordova/plugin/MediaFileData'
+ },
+ Metadata:{
+ path: 'cordova/plugin/Metadata'
+ },
+ Position: {
+ path: 'cordova/plugin/Position'
+ },
+ PositionError: {
+ path: 'cordova/plugin/PositionError'
+ },
+ ProgressEvent: {
+ path: 'cordova/plugin/ProgressEvent'
+ },
+ requestFileSystem:{
+ path: 'cordova/plugin/requestFileSystem'
+ },
+ resolveLocalFileSystemURI:{
+ path: 'cordova/plugin/resolveLocalFileSystemURI'
+ }
+ }
+};
+
+});
+
+// file: lib/tizen/exec.js
+define("cordova/exec", function(require, exports, module) {
+/**
+ * Execute a cordova command. It is up to the native side whether this action
+ * is synchronous or asynchronous. The native side can return:
+ * Synchronous: PluginResult object as a JSON string
+ * Asynchronous: Empty string ""
+ * If async, the native side will cordova.callbackSuccess or cordova.callbackError,
+ * depending upon the result of the action.
+ *
+ * @param {Function} successCB The success callback
+ * @param {Function} failCB The fail callback
+ * @param {String} service The name of the service to use
+ * @param {String} action Action to be run in cordova
+ * @param {String[]} [args] Zero or more arguments to pass to the method
+ */
+
+var tizen = require('cordova/plugin/tizen/manager'),
+ cordova = require('cordova'),
+ utils = require('cordova/utils');
+
+module.exports = function(successCB, failCB, service, action, args) {
+
+ try {
+ var v = tizen.exec(successCB, failCB, service, action, args);
+
+ // If status is OK, then return value back to caller
+ if (v.status == cordova.callbackStatus.OK) {
+
+ // If there is a success callback, then call it now with returned value
+ if (successCB) {
+ try {
+ successCB(v.message);
+ }
+ catch (e) {
+ console.log("Error in success callback: "+ service + "." + action + " = " + e);
+ }
+
+ }
+ return v.message;
+ } else if (v.status == cordova.callbackStatus.NO_RESULT) {
+ // Nothing to do here
+ } else {
+ // If error, then display error
+ console.log("Error: " + service + "." + action + " Status=" + v.status + " Message=" + v.message);
+
+ // If there is a fail callback, then call it now with returned value
+ if (failCB) {
+ try {
+ failCB(v.message);
+ }
+ catch (e) {
+ console.log("Error in error callback: " + service + "." + action + " = "+e);
+ }
+ }
+ return null;
+ }
+ } catch (e) {
+ utils.alert("Error: " + e);
+ }
+};
+
+});
+
+// file: lib/tizen/platform.js
+define("cordova/platform", function(require, exports, module) {
+module.exports = {
+ id: "tizen",
+ initialize: function() {},
+ objects: {
+ device: {
+ path: "cordova/plugin/tizen/Device"
+ },
+ File: { // exists natively, override
+ path: "cordova/plugin/File"
+ },
+ FileReader: { // exists natively, override
+ path: "cordova/plugin/FileReader"
+ },
+ FileError: { //exists natively, override
+ path: "cordova/plugin/FileError"
+ }
+ },
+ merges: {
+ MediaError: { // exists natively
+ path: "cordova/plugin/tizen/MediaError"
+ },
+ navigator: {
+ children: {
+ device: {
+ path: "cordova/plugin/tizen/Device"
+ },
+ contacts: {
+ path: "cordova/plugin/tizen/contacts"
+ },
+ notification: {
+ path: "cordova/plugin/tizen/Notification"
+ }
+ }
+ },
+ Contact: {
+ path: "cordova/plugin/tizen/Contact"
+ }
+ }
+};
+
+});
+
+// file: lib/common/plugin/Acceleration.js
+define("cordova/plugin/Acceleration", function(require, exports, module) {
+var Acceleration = function(x, y, z, timestamp) {
+ this.x = x;
+ this.y = y;
+ this.z = z;
+ this.timestamp = timestamp || (new Date()).getTime();
+};
+
+module.exports = Acceleration;
+
+});
+
+// file: lib/common/plugin/Camera.js
+define("cordova/plugin/Camera", function(require, exports, module) {
+var exec = require('cordova/exec'),
+ Camera = require('cordova/plugin/CameraConstants');
+
+var cameraExport = {};
+
+// Tack on the Camera Constants to the base camera plugin.
+for (var key in Camera) {
+ cameraExport[key] = Camera[key];
+}
+
+/**
+ * Gets a picture from source defined by "options.sourceType", and returns the
+ * image as defined by the "options.destinationType" option.
+
+ * The defaults are sourceType=CAMERA and destinationType=FILE_URI.
+ *
+ * @param {Function} successCallback
+ * @param {Function} errorCallback
+ * @param {Object} options
+ */
+cameraExport.getPicture = function(successCallback, errorCallback, options) {
+ // successCallback required
+ if (typeof successCallback != "function") {
+ console.log("Camera Error: successCallback is not a function");
+ return;
+ }
+
+ // errorCallback optional
+ if (errorCallback && (typeof errorCallback != "function")) {
+ console.log("Camera Error: errorCallback is not a function");
+ return;
+ }
+
+ var quality = 50;
+ if (options && typeof options.quality == "number") {
+ quality = options.quality;
+ } else if (options && typeof options.quality == "string") {
+ var qlity = parseInt(options.quality, 10);
+ if (isNaN(qlity) === false) {
+ quality = qlity.valueOf();
+ }
+ }
+
+ var destinationType = Camera.DestinationType.FILE_URI;
+ if (typeof options.destinationType == "number") {
+ destinationType = options.destinationType;
+ }
+
+ var sourceType = Camera.PictureSourceType.CAMERA;
+ if (typeof options.sourceType == "number") {
+ sourceType = options.sourceType;
+ }
+
+ var targetWidth = -1;
+ if (typeof options.targetWidth == "number") {
+ targetWidth = options.targetWidth;
+ } else if (typeof options.targetWidth == "string") {
+ var width = parseInt(options.targetWidth, 10);
+ if (isNaN(width) === false) {
+ targetWidth = width.valueOf();
+ }
+ }
+
+ var targetHeight = -1;
+ if (typeof options.targetHeight == "number") {
+ targetHeight = options.targetHeight;
+ } else if (typeof options.targetHeight == "string") {
+ var height = parseInt(options.targetHeight, 10);
+ if (isNaN(height) === false) {
+ targetHeight = height.valueOf();
+ }
+ }
+
+ var encodingType = Camera.EncodingType.JPEG;
+ if (typeof options.encodingType == "number") {
+ encodingType = options.encodingType;
+ }
+
+ var mediaType = Camera.MediaType.PICTURE;
+ if (typeof options.mediaType == "number") {
+ mediaType = options.mediaType;
+ }
+ var allowEdit = false;
+ if (typeof options.allowEdit == "boolean") {
+ allowEdit = options.allowEdit;
+ } else if (typeof options.allowEdit == "number") {
+ allowEdit = options.allowEdit <= 0 ? false : true;
+ }
+ var correctOrientation = false;
+ if (typeof options.correctOrientation == "boolean") {
+ correctOrientation = options.correctOrientation;
+ } else if (typeof options.correctOrientation == "number") {
+ correctOrientation = options.correctOrientation <=0 ? false : true;
+ }
+ var saveToPhotoAlbum = false;
+ if (typeof options.saveToPhotoAlbum == "boolean") {
+ saveToPhotoAlbum = options.saveToPhotoAlbum;
+ } else if (typeof options.saveToPhotoAlbum == "number") {
+ saveToPhotoAlbum = options.saveToPhotoAlbum <=0 ? false : true;
+ }
+ var popoverOptions = null;
+ if (typeof options.popoverOptions == "object") {
+ popoverOptions = options.popoverOptions;
+ }
+
+ var args = [quality, destinationType, sourceType, targetWidth, targetHeight, encodingType,
+ mediaType, allowEdit, correctOrientation, saveToPhotoAlbum, popoverOptions];
+
+ exec(successCallback, errorCallback, "Camera", "takePicture", args);
+};
+
+cameraExport.cleanup = function(successCallback, errorCallback) {
+ exec(successCallback, errorCallback, "Camera", "cleanup", []);
+};
+
+module.exports = cameraExport;
+});
+
+// file: lib/common/plugin/CameraConstants.js
+define("cordova/plugin/CameraConstants", function(require, exports, module) {
+module.exports = {
+ DestinationType:{
+ DATA_URL: 0, // Return base64 encoded string
+ FILE_URI: 1 // Return file uri (content://media/external/images/media/2 for Android)
+ },
+ EncodingType:{
+ JPEG: 0, // Return JPEG encoded image
+ PNG: 1 // Return PNG encoded image
+ },
+ MediaType:{
+ PICTURE: 0, // allow selection of still pictures only. DEFAULT. Will return format specified via DestinationType
+ VIDEO: 1, // allow selection of video only, ONLY RETURNS URL
+ ALLMEDIA : 2 // allow selection from all media types
+ },
+ PictureSourceType:{
+ PHOTOLIBRARY : 0, // Choose image from picture library (same as SAVEDPHOTOALBUM for Android)
+ CAMERA : 1, // Take picture from camera
+ SAVEDPHOTOALBUM : 2 // Choose image from picture library (same as PHOTOLIBRARY for Android)
+ },
+ PopoverArrowDirection:{
+ ARROW_UP : 1, // matches iOS UIPopoverArrowDirection constants to specify arrow location on popover
+ ARROW_DOWN : 2,
+ ARROW_LEFT : 4,
+ ARROW_RIGHT : 8,
+ ARROW_ANY : 15
+ }
+};
+});
+
+// file: lib/common/plugin/CameraPopoverOptions.js
+define("cordova/plugin/CameraPopoverOptions", function(require, exports, module) {
+var Camera = require('cordova/plugin/CameraConstants');
+
+/**
+ * Encapsulates options for iOS Popover image picker
+ */
+var CameraPopoverOptions = function(x,y,width,height,arrowDir){
+ // information of rectangle that popover should be anchored to
+ this.x = x || 0;
+ this.y = y || 32;
+ this.width = width || 320;
+ this.height = height || 480;
+ // The direction of the popover arrow
+ this.arrowDir = arrowDir || Camera.PopoverArrowDirection.ARROW_ANY;
+};
+
+module.exports = CameraPopoverOptions;
+});
+
+// file: lib/common/plugin/CaptureAudioOptions.js
+define("cordova/plugin/CaptureAudioOptions", function(require, exports, module) {
+/**
+ * Encapsulates all audio capture operation configuration options.
+ */
+var CaptureAudioOptions = function(){
+ // Upper limit of sound clips user can record. Value must be equal or greater than 1.
+ this.limit = 1;
+ // Maximum duration of a single sound clip in seconds.
+ this.duration = 0;
+ // The selected audio mode. Must match with one of the elements in supportedAudioModes array.
+ this.mode = null;
+};
+
+module.exports = CaptureAudioOptions;
+});
+
+// file: lib/common/plugin/CaptureError.js
+define("cordova/plugin/CaptureError", function(require, exports, module) {
+/**
+ * The CaptureError interface encapsulates all errors in the Capture API.
+ */
+var CaptureError = function(c) {
+ this.code = c || null;
+};
+
+// Camera or microphone failed to capture image or sound.
+CaptureError.CAPTURE_INTERNAL_ERR = 0;
+// Camera application or audio capture application is currently serving other capture request.
+CaptureError.CAPTURE_APPLICATION_BUSY = 1;
+// Invalid use of the API (e.g. limit parameter has value less than one).
+CaptureError.CAPTURE_INVALID_ARGUMENT = 2;
+// User exited camera application or audio capture application before capturing anything.
+CaptureError.CAPTURE_NO_MEDIA_FILES = 3;
+// The requested capture operation is not supported.
+CaptureError.CAPTURE_NOT_SUPPORTED = 20;
+
+module.exports = CaptureError;
+});
+
+// file: lib/common/plugin/CaptureImageOptions.js
+define("cordova/plugin/CaptureImageOptions", function(require, exports, module) {
+/**
+ * Encapsulates all image capture operation configuration options.
+ */
+var CaptureImageOptions = function(){
+ // Upper limit of images user can take. Value must be equal or greater than 1.
+ this.limit = 1;
+ // The selected image mode. Must match with one of the elements in supportedImageModes array.
+ this.mode = null;
+};
+
+module.exports = CaptureImageOptions;
+});
+
+// file: lib/common/plugin/CaptureVideoOptions.js
+define("cordova/plugin/CaptureVideoOptions", function(require, exports, module) {
+/**
+ * Encapsulates all video capture operation configuration options.
+ */
+var CaptureVideoOptions = function(){
+ // Upper limit of videos user can record. Value must be equal or greater than 1.
+ this.limit = 1;
+ // Maximum duration of a single video clip in seconds.
+ this.duration = 0;
+ // The selected video mode. Must match with one of the elements in supportedVideoModes array.
+ this.mode = null;
+};
+
+module.exports = CaptureVideoOptions;
+});
+
+// file: lib/common/plugin/CompassError.js
+define("cordova/plugin/CompassError", function(require, exports, module) {
+/**
+ * CompassError.
+ * An error code assigned by an implementation when an error has occured
+ * @constructor
+ */
+var CompassError = function(err) {
+ this.code = (err !== undefined ? err : null);
+};
+
+CompassError.COMPASS_INTERNAL_ERR = 0;
+CompassError.COMPASS_NOT_SUPPORTED = 20;
+
+module.exports = CompassError;
+});
+
+// file: lib/common/plugin/CompassHeading.js
+define("cordova/plugin/CompassHeading", function(require, exports, module) {
+var CompassHeading = function(magneticHeading, trueHeading, headingAccuracy, timestamp) {
+ this.magneticHeading = (magneticHeading !== undefined ? magneticHeading : null);
+ this.trueHeading = (trueHeading !== undefined ? trueHeading : null);
+ this.headingAccuracy = (headingAccuracy !== undefined ? headingAccuracy : null);
+ this.timestamp = (timestamp !== undefined ? timestamp : new Date().getTime());
+};
+
+module.exports = CompassHeading;
+});
+
+// file: lib/common/plugin/ConfigurationData.js
+define("cordova/plugin/ConfigurationData", function(require, exports, module) {
+/**
+ * Encapsulates a set of parameters that the capture device supports.
+ */
+function ConfigurationData() {
+ // The ASCII-encoded string in lower case representing the media type.
+ this.type = null;
+ // The height attribute represents height of the image or video in pixels.
+ // In the case of a sound clip this attribute has value 0.
+ this.height = 0;
+ // The width attribute represents width of the image or video in pixels.
+ // In the case of a sound clip this attribute has value 0
+ this.width = 0;
+}
+
+module.exports = ConfigurationData;
+});
+
+// file: lib/common/plugin/Connection.js
+define("cordova/plugin/Connection", function(require, exports, module) {
+/**
+ * Network status
+ */
+module.exports = {
+ UNKNOWN: "unknown",
+ ETHERNET: "ethernet",
+ WIFI: "wifi",
+ CELL_2G: "2g",
+ CELL_3G: "3g",
+ CELL_4G: "4g",
+ NONE: "none"
+};
+});
+
+// file: lib/common/plugin/Contact.js
+define("cordova/plugin/Contact", function(require, exports, module) {
+var exec = require('cordova/exec'),
+ ContactError = require('cordova/plugin/ContactError'),
+ utils = require('cordova/utils');
+
+/**
+* Converts primitives into Complex Object
+* Currently only used for Date fields
+*/
+function convertIn(contact) {
+ var value = contact.birthday;
+ try {
+ contact.birthday = new Date(parseFloat(value));
+ } catch (exception){
+ console.log("Cordova Contact convertIn error: exception creating date.");
+ }
+ return contact;
+}
+
+/**
+* Converts Complex objects into primitives
+* Only conversion at present is for Dates.
+**/
+
+function convertOut(contact) {
+ var value = contact.birthday;
+ if (value !== null) {
+ // try to make it a Date object if it is not already
+ if (!utils.isDate(value)){
+ try {
+ value = new Date(value);
+ } catch(exception){
+ value = null;
+ }
+ }
+ if (utils.isDate(value)){
+ value = value.valueOf(); // convert to milliseconds
+ }
+ contact.birthday = value;
+ }
+ return contact;
+}
+
+/**
+* Contains information about a single contact.
+* @constructor
+* @param {DOMString} id unique identifier
+* @param {DOMString} displayName
+* @param {ContactName} name
+* @param {DOMString} nickname
+* @param {Array.<ContactField>} phoneNumbers array of phone numbers
+* @param {Array.<ContactField>} emails array of email addresses
+* @param {Array.<ContactAddress>} addresses array of addresses
+* @param {Array.<ContactField>} ims instant messaging user ids
+* @param {Array.<ContactOrganization>} organizations
+* @param {DOMString} birthday contact's birthday
+* @param {DOMString} note user notes about contact
+* @param {Array.<ContactField>} photos
+* @param {Array.<ContactField>} categories
+* @param {Array.<ContactField>} urls contact's web sites
+*/
+var Contact = function (id, displayName, name, nickname, phoneNumbers, emails, addresses,
+ ims, organizations, birthday, note, photos, categories, urls) {
+ this.id = id || null;
+ this.rawId = null;
+ this.displayName = displayName || null;
+ this.name = name || null; // ContactName
+ this.nickname = nickname || null;
+ this.phoneNumbers = phoneNumbers || null; // ContactField[]
+ this.emails = emails || null; // ContactField[]
+ this.addresses = addresses || null; // ContactAddress[]
+ this.ims = ims || null; // ContactField[]
+ this.organizations = organizations || null; // ContactOrganization[]
+ this.birthday = birthday || null;
+ this.note = note || null;
+ this.photos = photos || null; // ContactField[]
+ this.categories = categories || null; // ContactField[]
+ this.urls = urls || null; // ContactField[]
+};
+
+/**
+* Removes contact from device storage.
+* @param successCB success callback
+* @param errorCB error callback
+*/
+Contact.prototype.remove = function(successCB, errorCB) {
+ var fail = function(code) {
+ errorCB(new ContactError(code));
+ };
+ if (this.id === null) {
+ fail(ContactError.UNKNOWN_ERROR);
+ }
+ else {
+ exec(successCB, fail, "Contacts", "remove", [this.id]);
+ }
+};
+
+/**
+* Creates a deep copy of this Contact.
+* With the contact ID set to null.
+* @return copy of this Contact
+*/
+Contact.prototype.clone = function() {
+ var clonedContact = utils.clone(this);
+ var i;
+ clonedContact.id = null;
+ clonedContact.rawId = null;
+ // Loop through and clear out any id's in phones, emails, etc.
+ if (clonedContact.phoneNumbers) {
+ for (i = 0; i < clonedContact.phoneNumbers.length; i++) {
+ clonedContact.phoneNumbers[i].id = null;
+ }
+ }
+ if (clonedContact.emails) {
+ for (i = 0; i < clonedContact.emails.length; i++) {
+ clonedContact.emails[i].id = null;
+ }
+ }
+ if (clonedContact.addresses) {
+ for (i = 0; i < clonedContact.addresses.length; i++) {
+ clonedContact.addresses[i].id = null;
+ }
+ }
+ if (clonedContact.ims) {
+ for (i = 0; i < clonedContact.ims.length; i++) {
+ clonedContact.ims[i].id = null;
+ }
+ }
+ if (clonedContact.organizations) {
+ for (i = 0; i < clonedContact.organizations.length; i++) {
+ clonedContact.organizations[i].id = null;
+ }
+ }
+ if (clonedContact.categories) {
+ for (i = 0; i < clonedContact.categories.length; i++) {
+ clonedContact.categories[i].id = null;
+ }
+ }
+ if (clonedContact.photos) {
+ for (i = 0; i < clonedContact.photos.length; i++) {
+ clonedContact.photos[i].id = null;
+ }
+ }
+ if (clonedContact.urls) {
+ for (i = 0; i < clonedContact.urls.length; i++) {
+ clonedContact.urls[i].id = null;
+ }
+ }
+ return clonedContact;
+};
+
+/**
+* Persists contact to device storage.
+* @param successCB success callback
+* @param errorCB error callback
+*/
+Contact.prototype.save = function(successCB, errorCB) {
+ var fail = function(code) {
+ errorCB(new ContactError(code));
+ };
+ var success = function(result) {
+ if (result) {
+ if (typeof successCB === 'function') {
+ var fullContact = require('cordova/plugin/contacts').create(result);
+ successCB(convertIn(fullContact));
+ }
+ }
+ else {
+ // no Entry object returned
+ fail(ContactError.UNKNOWN_ERROR);
+ }
+ };
+ var dupContact = convertOut(utils.clone(this));
+ exec(success, fail, "Contacts", "save", [dupContact]);
+};
+
+
+module.exports = Contact;
+
+});
+
+// file: lib/common/plugin/ContactAddress.js
+define("cordova/plugin/ContactAddress", function(require, exports, module) {
+/**
+* Contact address.
+* @constructor
+* @param {DOMString} id unique identifier, should only be set by native code
+* @param formatted // NOTE: not a W3C standard
+* @param streetAddress
+* @param locality
+* @param region
+* @param postalCode
+* @param country
+*/
+
+var ContactAddress = function(pref, type, formatted, streetAddress, locality, region, postalCode, country) {
+ this.id = null;
+ this.pref = (typeof pref != 'undefined' ? pref : false);
+ this.type = type || null;
+ this.formatted = formatted || null;
+ this.streetAddress = streetAddress || null;
+ this.locality = locality || null;
+ this.region = region || null;
+ this.postalCode = postalCode || null;
+ this.country = country || null;
+};
+
+module.exports = ContactAddress;
+});
+
+// file: lib/common/plugin/ContactError.js
+define("cordova/plugin/ContactError", function(require, exports, module) {
+/**
+ * ContactError.
+ * An error code assigned by an implementation when an error has occured
+ * @constructor
+ */
+var ContactError = function(err) {
+ this.code = (typeof err != 'undefined' ? err : null);
+};
+
+/**
+ * Error codes
+ */
+ContactError.UNKNOWN_ERROR = 0;
+ContactError.INVALID_ARGUMENT_ERROR = 1;
+ContactError.TIMEOUT_ERROR = 2;
+ContactError.PENDING_OPERATION_ERROR = 3;
+ContactError.IO_ERROR = 4;
+ContactError.NOT_SUPPORTED_ERROR = 5;
+ContactError.PERMISSION_DENIED_ERROR = 20;
+
+module.exports = ContactError;
+});
+
+// file: lib/common/plugin/ContactField.js
+define("cordova/plugin/ContactField", function(require, exports, module) {
+/**
+* Generic contact field.
+* @constructor
+* @param {DOMString} id unique identifier, should only be set by native code // NOTE: not a W3C standard
+* @param type
+* @param value
+* @param pref
+*/
+var ContactField = function(type, value, pref) {
+ this.id = null;
+ this.type = (type && type.toString()) || null;
+ this.value = (value && value.toString()) || null;
+ this.pref = (typeof pref != 'undefined' ? pref : false);
+};
+
+module.exports = ContactField;
+});
+
+// file: lib/common/plugin/ContactFindOptions.js
+define("cordova/plugin/ContactFindOptions", function(require, exports, module) {
+/**
+ * ContactFindOptions.
+ * @constructor
+ * @param filter used to match contacts against
+ * @param multiple boolean used to determine if more than one contact should be returned
+ */
+
+var ContactFindOptions = function(filter, multiple) {
+ this.filter = filter || '';
+ this.multiple = (typeof multiple != 'undefined' ? multiple : false);
+};
+
+module.exports = ContactFindOptions;
+});
+
+// file: lib/common/plugin/ContactName.js
+define("cordova/plugin/ContactName", function(require, exports, module) {
+/**
+* Contact name.
+* @constructor
+* @param formatted // NOTE: not part of W3C standard
+* @param familyName
+* @param givenName
+* @param middle
+* @param prefix
+* @param suffix
+*/
+var ContactName = function(formatted, familyName, givenName, middle, prefix, suffix) {
+ this.formatted = formatted || null;
+ this.familyName = familyName || null;
+ this.givenName = givenName || null;
+ this.middleName = middle || null;
+ this.honorificPrefix = prefix || null;
+ this.honorificSuffix = suffix || null;
+};
+
+module.exports = ContactName;
+});
+
+// file: lib/common/plugin/ContactOrganization.js
+define("cordova/plugin/ContactOrganization", function(require, exports, module) {
+/**
+* Contact organization.
+* @constructor
+* @param {DOMString} id unique identifier, should only be set by native code // NOTE: not a W3C standard
+* @param name
+* @param dept
+* @param title
+* @param startDate
+* @param endDate
+* @param location
+* @param desc
+*/
+
+var ContactOrganization = function(pref, type, name, dept, title) {
+ this.id = null;
+ this.pref = (typeof pref != 'undefined' ? pref : false);
+ this.type = type || null;
+ this.name = name || null;
+ this.department = dept || null;
+ this.title = title || null;
+};
+
+module.exports = ContactOrganization;
+});
+
+// file: lib/common/plugin/Coordinates.js
+define("cordova/plugin/Coordinates", function(require, exports, module) {
+/**
+ * This class contains position information.
+ * @param {Object} lat
+ * @param {Object} lng
+ * @param {Object} alt
+ * @param {Object} acc
+ * @param {Object} head
+ * @param {Object} vel
+ * @param {Object} altacc
+ * @constructor
+ */
+var Coordinates = function(lat, lng, alt, acc, head, vel, altacc) {
+ /**
+ * The latitude of the position.
+ */
+ this.latitude = lat;
+ /**
+ * The longitude of the position,
+ */
+ this.longitude = lng;
+ /**
+ * The accuracy of the position.
+ */
+ this.accuracy = acc;
+ /**
+ * The altitude of the position.
+ */
+ this.altitude = (alt !== undefined ? alt : null);
+ /**
+ * The direction the device is moving at the position.
+ */
+ this.heading = (head !== undefined ? head : null);
+ /**
+ * The velocity with which the device is moving at the position.
+ */
+ this.speed = (vel !== undefined ? vel : null);
+
+ if (this.speed === 0 || this.speed === null) {
+ this.heading = NaN;
+ }
+
+ /**
+ * The altitude accuracy of the position.
+ */
+ this.altitudeAccuracy = (altacc !== undefined) ? altacc : null;
+};
+
+module.exports = Coordinates;
+
+});
+
+// file: lib/common/plugin/DirectoryEntry.js
+define("cordova/plugin/DirectoryEntry", function(require, exports, module) {
+var utils = require('cordova/utils'),
+ exec = require('cordova/exec'),
+ Entry = require('cordova/plugin/Entry'),
+ FileError = require('cordova/plugin/FileError'),
+ DirectoryReader = require('cordova/plugin/DirectoryReader');
+
+/**
+ * An interface representing a directory on the file system.
+ *
+ * {boolean} isFile always false (readonly)
+ * {boolean} isDirectory always true (readonly)
+ * {DOMString} name of the directory, excluding the path leading to it (readonly)
+ * {DOMString} fullPath the absolute full path to the directory (readonly)
+ * TODO: implement this!!! {FileSystem} filesystem on which the directory resides (readonly)
+ */
+var DirectoryEntry = function(name, fullPath) {
+ DirectoryEntry.__super__.constructor.apply(this, [false, true, name, fullPath]);
+};
+
+utils.extend(DirectoryEntry, Entry);
+
+/**
+ * Creates a new DirectoryReader to read entries from this directory
+ */
+DirectoryEntry.prototype.createReader = function() {
+ return new DirectoryReader(this.fullPath);
+};
+
+/**
+ * Creates or looks up a directory
+ *
+ * @param {DOMString} path either a relative or absolute path from this directory in which to look up or create a directory
+ * @param {Flags} options to create or 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) {
+ var win = typeof successCallback !== 'function' ? null : function(result) {
+ var entry = new DirectoryEntry(result.name, result.fullPath);
+ successCallback(entry);
+ };
+ var fail = typeof errorCallback !== 'function' ? null : function(code) {
+ errorCallback(new FileError(code));
+ };
+ exec(win, fail, "File", "getDirectory", [this.fullPath, path, options]);
+};
+
+/**
+ * Deletes a directory and all of it's contents
+ *
+ * @param {Function} successCallback is called with no parameters
+ * @param {Function} errorCallback is called with a FileError
+ */
+DirectoryEntry.prototype.removeRecursively = function(successCallback, errorCallback) {
+ var fail = typeof errorCallback !== 'function' ? null : function(code) {
+ errorCallback(new FileError(code));
+ };
+ exec(successCallback, fail, "File", "removeRecursively", [this.fullPath]);
+};
+
+/**
+ * Creates or looks up a file
+ *
+ * @param {DOMString} path either a relative or absolute path from this directory in which to look up or create a file
+ * @param {Flags} options to create or 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) {
+ var win = typeof successCallback !== 'function' ? null : function(result) {
+ var FileEntry = require('cordova/plugin/FileEntry');
+ var entry = new FileEntry(result.name, result.fullPath);
+ successCallback(entry);
+ };
+ var fail = typeof errorCallback !== 'function' ? null : function(code) {
+ errorCallback(new FileError(code));
+ };
+ exec(win, fail, "File", "getFile", [this.fullPath, path, options]);
+};
+
+module.exports = DirectoryEntry;
+
+});
+
+// file: lib/common/plugin/DirectoryReader.js
+define("cordova/plugin/DirectoryReader", function(require, exports, module) {
+var exec = require('cordova/exec'),
+ FileError = require('cordova/plugin/FileError') ;
+
+/**
+ * An interface that lists the files and directories in a directory.
+ */
+function DirectoryReader(path) {
+ this.path = path || null;
+}
+
+/**
+ * Returns a list of entries from a directory.
+ *
+ * @param {Function} successCallback is called with a list of entries
+ * @param {Function} errorCallback is called with a FileError
+ */
+DirectoryReader.prototype.readEntries = function(successCallback, errorCallback) {
+ var win = typeof successCallback !== 'function' ? null : function(result) {
+ var retVal = [];
+ for (var i=0; i<result.length; i++) {
+ var entry = null;
+ if (result[i].isDirectory) {
+ entry = new (require('cordova/plugin/DirectoryEntry'))();
+ }
+ else if (result[i].isFile) {
+ entry = new (require('cordova/plugin/FileEntry'))();
+ }
+ entry.isDirectory = result[i].isDirectory;
+ entry.isFile = result[i].isFile;
+ entry.name = result[i].name;
+ entry.fullPath = result[i].fullPath;
+ retVal.push(entry);
+ }
+ successCallback(retVal);
+ };
+ var fail = typeof errorCallback !== 'function' ? null : function(code) {
+ errorCallback(new FileError(code));
+ };
+ exec(win, fail, "File", "readEntries", [this.path]);
+};
+
+module.exports = DirectoryReader;
+
+});
+
+// file: lib/common/plugin/Entry.js
+define("cordova/plugin/Entry", function(require, exports, module) {
+var exec = require('cordova/exec'),
+ FileError = require('cordova/plugin/FileError'),
+ Metadata = require('cordova/plugin/Metadata');
+
+/**
+ * Represents a file or directory on the local file system.
+ *
+ * @param isFile
+ * {boolean} true if Entry is a file (readonly)
+ * @param isDirectory
+ * {boolean} true if Entry is a directory (readonly)
+ * @param name
+ * {DOMString} name of the file or directory, excluding the path
+ * leading to it (readonly)
+ * @param fullPath
+ * {DOMString} the absolute full path to the file or directory
+ * (readonly)
+ */
+function Entry(isFile, isDirectory, name, fullPath, fileSystem) {
+ this.isFile = (typeof isFile != 'undefined'?isFile:false);
+ this.isDirectory = (typeof isDirectory != 'undefined'?isDirectory:false);
+ this.name = name || '';
+ this.fullPath = fullPath || '';
+ this.filesystem = fileSystem || null;
+}
+
+/**
+ * Look up the metadata of the entry.
+ *
+ * @param successCallback
+ * {Function} is called with a Metadata object
+ * @param errorCallback
+ * {Function} is called with a FileError
+ */
+Entry.prototype.getMetadata = function(successCallback, errorCallback) {
+ var success = typeof successCallback !== 'function' ? null : function(lastModified) {
+ var metadata = new Metadata(lastModified);
+ successCallback(metadata);
+ };
+ var fail = typeof errorCallback !== 'function' ? null : function(code) {
+ errorCallback(new FileError(code));
+ };
+
+ exec(success, fail, "File", "getMetadata", [this.fullPath]);
+};
+
+/**
+ * Set the metadata of the entry.
+ *
+ * @param successCallback
+ * {Function} is called with a Metadata object
+ * @param errorCallback
+ * {Function} is called with a FileError
+ * @param metadataObject
+ * {Object} keys and values to set
+ */
+Entry.prototype.setMetadata = function(successCallback, errorCallback, metadataObject) {
+
+ exec(successCallback, errorCallback, "File", "setMetadata", [this.fullPath, metadataObject]);
+};
+
+/**
+ * Move a file or directory to a new location.
+ *
+ * @param parent
+ * {DirectoryEntry} the directory to which to move this entry
+ * @param newName
+ * {DOMString} new name of the entry, defaults to the current name
+ * @param successCallback
+ * {Function} called with the new DirectoryEntry object
+ * @param errorCallback
+ * {Function} called with a FileError
+ */
+Entry.prototype.moveTo = function(parent, newName, successCallback, errorCallback) {
+ var fail = function(code) {
+ if (typeof errorCallback === 'function') {
+ errorCallback(new FileError(code));
+ }
+ };
+ // user must specify parent Entry
+ if (!parent) {
+ fail(FileError.NOT_FOUND_ERR);
+ return;
+ }
+ // source path
+ var srcPath = this.fullPath,
+ // entry name
+ name = newName || this.name,
+ success = function(entry) {
+ if (entry) {
+ if (typeof successCallback === 'function') {
+ // create appropriate Entry object
+ var result = (entry.isDirectory) ? new (require('cordova/plugin/DirectoryEntry'))(entry.name, entry.fullPath) : new (require('cordova/plugin/FileEntry'))(entry.name, entry.fullPath);
+ try {
+ successCallback(result);
+ }
+ catch (e) {
+ console.log('Error invoking callback: ' + e);
+ }
+ }
+ }
+ else {
+ // no Entry object returned
+ fail(FileError.NOT_FOUND_ERR);
+ }
+ };
+
+ // copy
+ exec(success, fail, "File", "moveTo", [srcPath, parent.fullPath, name]);
+};
+
+/**
+ * Copy a directory to a different location.
+ *
+ * @param parent
+ * {DirectoryEntry} the directory to which to copy the entry
+ * @param newName
+ * {DOMString} new name of the entry, defaults to the current name
+ * @param successCallback
+ * {Function} called with the new Entry object
+ * @param errorCallback
+ * {Function} called with a FileError
+ */
+Entry.prototype.copyTo = function(parent, newName, successCallback, errorCallback) {
+ var fail = function(code) {
+ if (typeof errorCallback === 'function') {
+ errorCallback(new FileError(code));
+ }
+ };
+
+ // user must specify parent Entry
+ if (!parent) {
+ fail(FileError.NOT_FOUND_ERR);
+ return;
+ }
+
+ // source path
+ var srcPath = this.fullPath,
+ // entry name
+ name = newName || this.name,
+ // success callback
+ success = function(entry) {
+ if (entry) {
+ if (typeof successCallback === 'function') {
+ // create appropriate Entry object
+ var result = (entry.isDirectory) ? new (require('cordova/plugin/DirectoryEntry'))(entry.name, entry.fullPath) : new (require('cordova/plugin/FileEntry'))(entry.name, entry.fullPath);
+ try {
+ successCallback(result);
+ }
+ catch (e) {
+ console.log('Error invoking callback: ' + e);
+ }
+ }
+ }
+ else {
+ // no Entry object returned
+ fail(FileError.NOT_FOUND_ERR);
+ }
+ };
+
+ // copy
+ exec(success, fail, "File", "copyTo", [srcPath, parent.fullPath, name]);
+};
+
+/**
+ * Return a URL that can be used to identify this entry.
+ */
+Entry.prototype.toURL = function() {
+ // fullPath attribute contains the full URL
+ return this.fullPath;
+};
+
+/**
+ * Returns a URI that can be used to identify this entry.
+ *
+ * @param {DOMString} mimeType for a FileEntry, the mime type to be used to interpret the file, when loaded through this URI.
+ * @return uri
+ */
+Entry.prototype.toURI = function(mimeType) {
+ console.log("DEPRECATED: Update your code to use 'toURL'");
+ // fullPath attribute contains the full URI
+ return this.toURL();
+};
+
+/**
+ * Remove a file or directory. It is an error to attempt to delete a
+ * directory that is not empty. It is an error to attempt to delete a
+ * root directory of a file system.
+ *
+ * @param successCallback {Function} called with no parameters
+ * @param errorCallback {Function} called with a FileError
+ */
+Entry.prototype.remove = function(successCallback, errorCallback) {
+ var fail = typeof errorCallback !== 'function' ? null : function(code) {
+ errorCallback(new FileError(code));
+ };
+ exec(successCallback, fail, "File", "remove", [this.fullPath]);
+};
+
+/**
+ * Look up the parent DirectoryEntry of this entry.
+ *
+ * @param successCallback {Function} called with the parent DirectoryEntry object
+ * @param errorCallback {Function} called with a FileError
+ */
+Entry.prototype.getParent = function(successCallback, errorCallback) {
+ var win = typeof successCallback !== 'function' ? null : function(result) {
+ var DirectoryEntry = require('cordova/plugin/DirectoryEntry');
+ var entry = new DirectoryEntry(result.name, result.fullPath);
+ successCallback(entry);
+ };
+ var fail = typeof errorCallback !== 'function' ? null : function(code) {
+ errorCallback(new FileError(code));
+ };
+ exec(win, fail, "File", "getParent", [this.fullPath]);
+};
+
+module.exports = Entry;
+});
+
+// file: lib/common/plugin/File.js
+define("cordova/plugin/File", function(require, exports, module) {
+/**
+ * Constructor.
+ * name {DOMString} name of the file, without path information
+ * fullPath {DOMString} the full path of the file, including the name
+ * type {DOMString} mime type
+ * lastModifiedDate {Date} last modified date
+ * size {Number} size of the file in bytes
+ */
+
+var File = function(name, fullPath, type, lastModifiedDate, size){
+ this.name = name || '';
+ this.fullPath = fullPath || null;
+ this.type = type || null;
+ this.lastModifiedDate = lastModifiedDate || null;
+ this.size = size || 0;
+};
+
+module.exports = File;
+});
+
+// file: lib/common/plugin/FileEntry.js
+define("cordova/plugin/FileEntry", function(require, exports, module) {
+var utils = require('cordova/utils'),
+ exec = require('cordova/exec'),
+ Entry = require('cordova/plugin/Entry'),
+ FileWriter = require('cordova/plugin/FileWriter'),
+ File = require('cordova/plugin/File'),
+ FileError = require('cordova/plugin/FileError');
+
+/**
+ * An interface representing a file on the file system.
+ *
+ * {boolean} isFile always true (readonly)
+ * {boolean} isDirectory always false (readonly)
+ * {DOMString} name of the file, excluding the path leading to it (readonly)
+ * {DOMString} fullPath the absolute full path to the file (readonly)
+ * {FileSystem} filesystem on which the file resides (readonly)
+ */
+var FileEntry = function(name, fullPath) {
+ FileEntry.__super__.constructor.apply(this, [true, false, name, fullPath]);
+};
+
+utils.extend(FileEntry, Entry);
+
+/**
+ * Creates a new FileWriter associated with the file that this FileEntry represents.
+ *
+ * @param {Function} successCallback is called with the new FileWriter
+ * @param {Function} errorCallback is called with a FileError
+ */
+FileEntry.prototype.createWriter = function(successCallback, errorCallback) {
+ this.file(function(filePointer) {
+ var writer = new FileWriter(filePointer);
+
+ if (writer.fileName === null || writer.fileName === "") {
+ if (typeof errorCallback === "function") {
+ errorCallback(new FileError(FileError.INVALID_STATE_ERR));
+ }
+ } else {
+ if (typeof successCallback === "function") {
+ successCallback(writer);
+ }
+ }
+ }, errorCallback);
+};
+
+/**
+ * Returns a File that represents the current state of the file that this FileEntry represents.
+ *
+ * @param {Function} successCallback is called with the new File object
+ * @param {Function} errorCallback is called with a FileError
+ */
+FileEntry.prototype.file = function(successCallback, errorCallback) {
+ var win = typeof successCallback !== 'function' ? null : function(f) {
+ var file = new File(f.name, f.fullPath, f.type, f.lastModifiedDate, f.size);
+ successCallback(file);
+ };
+ var fail = typeof errorCallback !== 'function' ? null : function(code) {
+ errorCallback(new FileError(code));
+ };
+ exec(win, fail, "File", "getFileMetadata", [this.fullPath]);
+};
+
+
+module.exports = FileEntry;
+});
+
+// file: lib/common/plugin/FileError.js
+define("cordova/plugin/FileError", function(require, exports, module) {
+/**
+ * FileError
+ */
+function FileError(error) {
+ this.code = error || null;
+}
+
+// File error codes
+// Found in DOMException
+FileError.NOT_FOUND_ERR = 1;
+FileError.SECURITY_ERR = 2;
+FileError.ABORT_ERR = 3;
+
+// Added by File API specification
+FileError.NOT_READABLE_ERR = 4;
+FileError.ENCODING_ERR = 5;
+FileError.NO_MODIFICATION_ALLOWED_ERR = 6;
+FileError.INVALID_STATE_ERR = 7;
+FileError.SYNTAX_ERR = 8;
+FileError.INVALID_MODIFICATION_ERR = 9;
+FileError.QUOTA_EXCEEDED_ERR = 10;
+FileError.TYPE_MISMATCH_ERR = 11;
+FileError.PATH_EXISTS_ERR = 12;
+
+module.exports = FileError;
+});
+
+// file: lib/common/plugin/FileReader.js
+define("cordova/plugin/FileReader", function(require, exports, module) {
+var exec = require('cordova/exec'),
+ FileError = require('cordova/plugin/FileError'),
+ ProgressEvent = require('cordova/plugin/ProgressEvent');
+
+/**
+ * This class reads the mobile device file system.
+ *
+ * For Android:
+ * The root directory is the root of the file system.
+ * To read from the SD card, the file name is "sdcard/my_file.txt"
+ * @constructor
+ */
+var FileReader = function() {
+ this.fileName = "";
+
+ this.readyState = 0; // FileReader.EMPTY
+
+ // File data
+ this.result = null;
+
+ // Error
+ this.error = null;
+
+ // Event handlers
+ this.onloadstart = null; // When the read starts.
+ this.onprogress = null; // While reading (and decoding) file or fileBlob data, and reporting partial file data (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() {
+ this.result = null;
+
+ if (this.readyState == FileReader.DONE || this.readyState == FileReader.EMPTY) {
+ return;
+ }
+
+ this.readyState = FileReader.DONE;
+
+ // If abort callback
+ if (typeof this.onabort === 'function') {
+ this.onabort(new ProgressEvent('abort', {target:this}));
+ }
+ // If load end callback
+ if (typeof this.onloadend === 'function') {
+ this.onloadend(new ProgressEvent('loadend', {target:this}));
+ }
+};
+
+/**
+ * Read text file.
+ *
+ * @param file {File} File object containing file properties
+ * @param encoding [Optional] (see http://www.iana.org/assignments/character-sets)
+ */
+FileReader.prototype.readAsText = function(file, encoding) {
+ // Figure out pathing
+ this.fileName = '';
+ if (typeof file.fullPath === 'undefined') {
+ this.fileName = file;
+ } else {
+ this.fileName = file.fullPath;
+ }
+
+ // Already loading something
+ if (this.readyState == FileReader.LOADING) {
+ throw new FileError(FileError.INVALID_STATE_ERR);
+ }
+
+ // LOADING state
+ this.readyState = FileReader.LOADING;
+
+ // If loadstart callback
+ if (typeof this.onloadstart === "function") {
+ this.onloadstart(new ProgressEvent("loadstart", {target:this}));
+ }
+
+ // Default encoding is UTF-8
+ var enc = encoding ? encoding : "UTF-8";
+
+ var me = this;
+
+ // Read file
+ exec(
+ // Success callback
+ function(r) {
+ // If DONE (cancelled), then don't do anything
+ if (me.readyState === FileReader.DONE) {
+ return;
+ }
+
+ // Save result
+ me.result = r;
+
+ // If onload callback
+ if (typeof me.onload === "function") {
+ me.onload(new ProgressEvent("load", {target:me}));
+ }
+
+ // DONE state
+ me.readyState = FileReader.DONE;
+
+ // If onloadend callback
+ if (typeof me.onloadend === "function") {
+ me.onloadend(new ProgressEvent("loadend", {target:me}));
+ }
+ },
+ // Error callback
+ function(e) {
+ // If DONE (cancelled), then don't do anything
+ if (me.readyState === FileReader.DONE) {
+ return;
+ }
+
+ // DONE state
+ me.readyState = FileReader.DONE;
+
+ // null result
+ me.result = null;
+
+ // Save error
+ me.error = new FileError(e);
+
+ // If onerror callback
+ if (typeof me.onerror === "function") {
+ me.onerror(new ProgressEvent("error", {target:me}));
+ }
+
+ // If onloadend callback
+ if (typeof me.onloadend === "function") {
+ me.onloadend(new ProgressEvent("loadend", {target:me}));
+ }
+ }, "File", "readAsText", [this.fileName, enc]);
+};
+
+
+/**
+ * Read file and return data as a base64 encoded data url.
+ * A data url is of the form:
+ * data:[<mediatype>][;base64],<data>
+ *
+ * @param file {File} File object containing file properties
+ */
+FileReader.prototype.readAsDataURL = function(file) {
+ this.fileName = "";
+ if (typeof file.fullPath === "undefined") {
+ this.fileName = file;
+ } else {
+ this.fileName = file.fullPath;
+ }
+
+ // Already loading something
+ if (this.readyState == FileReader.LOADING) {
+ throw new FileError(FileError.INVALID_STATE_ERR);
+ }
+
+ // LOADING state
+ this.readyState = FileReader.LOADING;
+
+ // If loadstart callback
+ if (typeof this.onloadstart === "function") {
+ this.onloadstart(new ProgressEvent("loadstart", {target:this}));
+ }
+
+ var me = this;
+
+ // Read file
+ exec(
+ // Success callback
+ function(r) {
+ // If DONE (cancelled), then don't do anything
+ if (me.readyState === FileReader.DONE) {
+ return;
+ }
+
+ // DONE state
+ me.readyState = FileReader.DONE;
+
+ // Save result
+ me.result = r;
+
+ // If onload callback
+ if (typeof me.onload === "function") {
+ me.onload(new ProgressEvent("load", {target:me}));
+ }
+
+ // If onloadend callback
+ if (typeof me.onloadend === "function") {
+ me.onloadend(new ProgressEvent("loadend", {target:me}));
+ }
+ },
+ // Error callback
+ function(e) {
+ // If DONE (cancelled), then don't do anything
+ if (me.readyState === FileReader.DONE) {
+ return;
+ }
+
+ // DONE state
+ me.readyState = FileReader.DONE;
+
+ me.result = null;
+
+ // Save error
+ me.error = new FileError(e);
+
+ // If onerror callback
+ if (typeof me.onerror === "function") {
+ me.onerror(new ProgressEvent("error", {target:me}));
+ }
+
+ // If onloadend callback
+ if (typeof me.onloadend === "function") {
+ me.onloadend(new ProgressEvent("loadend", {target:me}));
+ }
+ }, "File", "readAsDataURL", [this.fileName]);
+};
+
+/**
+ * Read file and return data as a binary data.
+ *
+ * @param file {File} File object containing file properties
+ */
+FileReader.prototype.readAsBinaryString = function(file) {
+ // TODO - Can't return binary data to browser.
+ console.log('method "readAsBinaryString" is not supported at this time.');
+};
+
+/**
+ * Read file and return data as a binary data.
+ *
+ * @param file {File} File object containing file properties
+ */
+FileReader.prototype.readAsArrayBuffer = function(file) {
+ // TODO - Can't return binary data to browser.
+ console.log('This method is not supported at this time.');
+};
+
+module.exports = FileReader;
+});
+
+// file: lib/common/plugin/FileSystem.js
+define("cordova/plugin/FileSystem", function(require, exports, module) {
+var DirectoryEntry = require('cordova/plugin/DirectoryEntry');
+
+/**
+ * An interface representing a file system
+ *
+ * @constructor
+ * {DOMString} name the unique name of the file system (readonly)
+ * {DirectoryEntry} root directory of the file system (readonly)
+ */
+var FileSystem = function(name, root) {
+ this.name = name || null;
+ if (root) {
+ this.root = new DirectoryEntry(root.name, root.fullPath);
+ }
+};
+
+module.exports = FileSystem;
+
+});
+
+// file: lib/common/plugin/FileTransfer.js
+define("cordova/plugin/FileTransfer", function(require, exports, module) {
+var exec = require('cordova/exec'),
+ FileTransferError = require('cordova/plugin/FileTransferError');
+
+/**
+ * FileTransfer uploads a file to a remote server.
+ * @constructor
+ */
+var FileTransfer = function() {};
+
+/**
+* Given an absolute file path, uploads a file on the device to a remote server
+* using a multipart HTTP request.
+* @param filePath {String} Full path of the file on the device
+* @param server {String} URL of the server to receive the file
+* @param successCallback (Function} Callback to be invoked when upload has completed
+* @param errorCallback {Function} Callback to be invoked upon error
+* @param options {FileUploadOptions} Optional parameters such as file name and mimetype
+* @param trustAllHosts {Boolean} Optional trust all hosts (e.g. for self-signed certs), defaults to false
+*/
+FileTransfer.prototype.upload = function(filePath, server, successCallback, errorCallback, options, trustAllHosts) {
+ // sanity parameter checking
+ if (!filePath || !server) throw new Error("FileTransfer.upload requires filePath and server URL parameters at the minimum.");
+ // check for options
+ var fileKey = null;
+ var fileName = null;
+ var mimeType = null;
+ var params = null;
+ var chunkedMode = true;
+ var headers = null;
+ if (options) {
+ fileKey = options.fileKey;
+ fileName = options.fileName;
+ mimeType = options.mimeType;
+ headers = options.headers;
+ if (options.chunkedMode !== null || typeof options.chunkedMode != "undefined") {
+ chunkedMode = options.chunkedMode;
+ }
+ if (options.params) {
+ params = options.params;
+ }
+ else {
+ params = {};
+ }
+ }
+
+ var fail = function(e) {
+ var error = new FileTransferError(e.code, e.source, e.target, e.http_status);
+ errorCallback(error);
+ };
+
+ exec(successCallback, fail, 'FileTransfer', 'upload', [filePath, server, fileKey, fileName, mimeType, params, trustAllHosts, chunkedMode, headers]);
+};
+
+/**
+ * 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) {
+ // sanity parameter checking
+ if (!source || !target) throw new Error("FileTransfer.download requires source URI and target URI parameters at the minimum.");
+ var win = function(result) {
+ var entry = null;
+ if (result.isDirectory) {
+ entry = new (require('cordova/plugin/DirectoryEntry'))();
+ }
+ else if (result.isFile) {
+ entry = new (require('cordova/plugin/FileEntry'))();
+ }
+ entry.isDirectory = result.isDirectory;
+ entry.isFile = result.isFile;
+ entry.name = result.name;
+ entry.fullPath = result.fullPath;
+ successCallback(entry);
+ };
+
+ var fail = function(e) {
+ var error = new FileTransferError(e.code, e.source, e.target, e.http_status);
+ errorCallback(error);
+ };
+
+ exec(win, errorCallback, 'FileTransfer', 'download', [source, target]);
+};
+
+module.exports = FileTransfer;
+
+});
+
+// file: lib/common/plugin/FileTransferError.js
+define("cordova/plugin/FileTransferError", function(require, exports, module) {
+/**
+ * FileTransferError
+ * @constructor
+ */
+var FileTransferError = function(code, source, target, status) {
+ this.code = code || null;
+ this.source = source || null;
+ this.target = target || null;
+ this.http_status = status || null;
+};
+
+FileTransferError.FILE_NOT_FOUND_ERR = 1;
+FileTransferError.INVALID_URL_ERR = 2;
+FileTransferError.CONNECTION_ERR = 3;
+
+module.exports = FileTransferError;
+
+});
+
+// file: lib/common/plugin/FileUploadOptions.js
+define("cordova/plugin/FileUploadOptions", function(require, exports, module) {
+/**
+ * Options to customize the HTTP request used to upload files.
+ * @constructor
+ * @param fileKey {String} Name of file request parameter.
+ * @param fileName {String} Filename to be used by the server. Defaults to image.jpg.
+ * @param mimeType {String} Mimetype of the uploaded file. Defaults to image/jpeg.
+ * @param params {Object} Object with key: value params to send to the server.
+ * @param headers {Object} Keys are header names, values are header values. Multiple
+ * headers of the same name are not supported.
+ */
+var FileUploadOptions = function(fileKey, fileName, mimeType, params, headers) {
+ this.fileKey = fileKey || null;
+ this.fileName = fileName || null;
+ this.mimeType = mimeType || null;
+ this.params = params || null;
+ this.headers = headers || null;
+};
+
+module.exports = FileUploadOptions;
+
+});
+
+// file: lib/common/plugin/FileUploadResult.js
+define("cordova/plugin/FileUploadResult", function(require, exports, module) {
+/**
+ * FileUploadResult
+ * @constructor
+ */
+var FileUploadResult = function() {
+ this.bytesSent = 0;
+ this.responseCode = null;
+ this.response = null;
+};
+
+module.exports = FileUploadResult;
+});
+
+// file: lib/common/plugin/FileWriter.js
+define("cordova/plugin/FileWriter", function(require, exports, module) {
+var exec = require('cordova/exec'),
+ FileError = require('cordova/plugin/FileError'),
+ ProgressEvent = require('cordova/plugin/ProgressEvent');
+
+/**
+ * This class writes to the mobile device file system.
+ *
+ * For Android:
+ * The root directory is the root of the file system.
+ * To write to the SD card, the file name is "sdcard/my_file.txt"
+ *
+ * @constructor
+ * @param file {File} File object containing file properties
+ * @param append if true write to the end of the file, otherwise overwrite the file
+ */
+var FileWriter = function(file) {
+ this.fileName = "";
+ this.length = 0;
+ if (file) {
+ this.fileName = file.fullPath || file;
+ this.length = file.size || 0;
+ }
+ // default is to write at the beginning of the file
+ this.position = 0;
+
+ this.readyState = 0; // EMPTY
+
+ this.result = null;
+
+ // Error
+ this.error = null;
+
+ // Event handlers
+ this.onwritestart = null; // When writing starts
+ this.onprogress = null; // While writing the file, and reporting partial file data
+ this.onwrite = null; // When the write has successfully completed.
+ this.onwriteend = null; // When the request has completed (either in success or failure).
+ this.onabort = null; // When the write has been aborted. For instance, by invoking the abort() method.
+ this.onerror = null; // When the write has failed (see errors).
+};
+
+// States
+FileWriter.INIT = 0;
+FileWriter.WRITING = 1;
+FileWriter.DONE = 2;
+
+/**
+ * Abort writing file.
+ */
+FileWriter.prototype.abort = function() {
+ // check for invalid state
+ if (this.readyState === FileWriter.DONE || this.readyState === FileWriter.INIT) {
+ throw new FileError(FileError.INVALID_STATE_ERR);
+ }
+
+ // set error
+ this.error = new FileError(FileError.ABORT_ERR);
+
+ this.readyState = FileWriter.DONE;
+
+ // If abort callback
+ if (typeof this.onabort === "function") {
+ this.onabort(new ProgressEvent("abort", {"target":this}));
+ }
+
+ // If write end callback
+ if (typeof this.onwriteend === "function") {
+ this.onwriteend(new ProgressEvent("writeend", {"target":this}));
+ }
+};
+
+/**
+ * Writes data to the file
+ *
+ * @param 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;
+
+ var me = this;
+
+ // If onwritestart callback
+ if (typeof me.onwritestart === "function") {
+ me.onwritestart(new ProgressEvent("writestart", {"target":me}));
+ }
+
+ // Write file
+ exec(
+ // Success callback
+ function(r) {
+ // If DONE (cancelled), then don't do anything
+ if (me.readyState === FileWriter.DONE) {
+ return;
+ }
+
+ // position always increases by bytes written because file would be extended
+ me.position += r;
+ // The length of the file is now where we are done writing.
+
+ me.length = me.position;
+
+ // DONE state
+ me.readyState = FileWriter.DONE;
+
+ // If onwrite callback
+ if (typeof me.onwrite === "function") {
+ me.onwrite(new ProgressEvent("write", {"target":me}));
+ }
+
+ // If onwriteend callback
+ if (typeof me.onwriteend === "function") {
+ me.onwriteend(new ProgressEvent("writeend", {"target":me}));
+ }
+ },
+ // Error callback
+ function(e) {
+ // If DONE (cancelled), then don't do anything
+ if (me.readyState === FileWriter.DONE) {
+ return;
+ }
+
+ // DONE state
+ me.readyState = FileWriter.DONE;
+
+ // Save error
+ me.error = new FileError(e);
+
+ // If onerror callback
+ if (typeof me.onerror === "function") {
+ me.onerror(new ProgressEvent("error", {"target":me}));
+ }
+
+ // If onwriteend callback
+ if (typeof me.onwriteend === "function") {
+ me.onwriteend(new ProgressEvent("writeend", {"target":me}));
+ }
+ }, "File", "write", [this.fileName, text, this.position]);
+};
+
+/**
+ * Moves the file pointer to the location specified.
+ *
+ * If the offset is a negative number the position of the file
+ * pointer is rewound. If the offset is greater than the file
+ * size the position is set to the end of the file.
+ *
+ * @param offset is the location to move the file pointer to.
+ */
+FileWriter.prototype.seek = function(offset) {
+ // Throw an exception if we are already writing a file
+ if (this.readyState === FileWriter.WRITING) {
+ throw new FileError(FileError.INVALID_STATE_ERR);
+ }
+
+ if (!offset && offset !== 0) {
+ return;
+ }
+
+ // See back from end of file.
+ if (offset < 0) {
+ this.position = Math.max(offset + this.length, 0);
+ }
+ // Offset is bigger than file size so set position
+ // to the end of the file.
+ else if (offset > this.length) {
+ this.position = this.length;
+ }
+ // Offset is between 0 and file size so set the position
+ // to start writing.
+ else {
+ this.position = offset;
+ }
+};
+
+/**
+ * Truncates the file to the size specified.
+ *
+ * @param size to chop the file at.
+ */
+FileWriter.prototype.truncate = function(size) {
+ // Throw an exception if we are already writing a file
+ if (this.readyState === FileWriter.WRITING) {
+ throw new FileError(FileError.INVALID_STATE_ERR);
+ }
+
+ // WRITING state
+ this.readyState = FileWriter.WRITING;
+
+ var me = this;
+
+ // If onwritestart callback
+ if (typeof me.onwritestart === "function") {
+ me.onwritestart(new ProgressEvent("writestart", {"target":this}));
+ }
+
+ // Write file
+ exec(
+ // Success callback
+ function(r) {
+ // If DONE (cancelled), then don't do anything
+ if (me.readyState === FileWriter.DONE) {
+ return;
+ }
+
+ // DONE state
+ me.readyState = FileWriter.DONE;
+
+ // Update the length of the file
+ me.length = r;
+ me.position = Math.min(me.position, r);
+
+ // If onwrite callback
+ if (typeof me.onwrite === "function") {
+ me.onwrite(new ProgressEvent("write", {"target":me}));
+ }
+
+ // If onwriteend callback
+ if (typeof me.onwriteend === "function") {
+ me.onwriteend(new ProgressEvent("writeend", {"target":me}));
+ }
+ },
+ // Error callback
+ function(e) {
+ // If DONE (cancelled), then don't do anything
+ if (me.readyState === FileWriter.DONE) {
+ return;
+ }
+
+ // DONE state
+ me.readyState = FileWriter.DONE;
+
+ // Save error
+ me.error = new FileError(e);
+
+ // If onerror callback
+ if (typeof me.onerror === "function") {
+ me.onerror(new ProgressEvent("error", {"target":me}));
+ }
+
+ // If onwriteend callback
+ if (typeof me.onwriteend === "function") {
+ me.onwriteend(new ProgressEvent("writeend", {"target":me}));
+ }
+ }, "File", "truncate", [this.fileName, size]);
+};
+
+module.exports = FileWriter;
+
+});
+
+// file: lib/common/plugin/Flags.js
+define("cordova/plugin/Flags", function(require, exports, module) {
+/**
+ * Supplies arguments to methods that lookup or create files and directories.
+ *
+ * @param create
+ * {boolean} file or directory if it doesn't exist
+ * @param exclusive
+ * {boolean} used with create; if true the command will fail if
+ * target path exists
+ */
+function Flags(create, exclusive) {
+ this.create = create || false;
+ this.exclusive = exclusive || false;
+}
+
+module.exports = Flags;
+});
+
+// file: lib/common/plugin/LocalFileSystem.js
+define("cordova/plugin/LocalFileSystem", function(require, exports, module) {
+var exec = require('cordova/exec');
+
+/**
+ * Represents a local file system.
+ */
+var LocalFileSystem = function() {
+
+};
+
+LocalFileSystem.TEMPORARY = 0; //temporary, with no guarantee of persistence
+LocalFileSystem.PERSISTENT = 1; //persistent
+
+module.exports = LocalFileSystem;
+});
+
+// file: lib/common/plugin/Media.js
+define("cordova/plugin/Media", function(require, exports, module) {
+var utils = require('cordova/utils'),
+ exec = require('cordova/exec');
+
+var mediaObjects = {};
+
+/**
+ * This class provides access to the device media, interfaces to both sound and video
+ *
+ * @constructor
+ * @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()
+ * @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
+ */
+var Media = function(src, successCallback, errorCallback, statusCallback) {
+
+ // 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;
+ }
+
+ this.id = utils.createUUID();
+ mediaObjects[this.id] = this;
+ this.src = src;
+ this.successCallback = successCallback;
+ this.errorCallback = errorCallback;
+ this.statusCallback = statusCallback;
+ this._duration = -1;
+ this._position = -1;
+ exec(null, this.errorCallback, "Media", "create", [this.id, this.src]);
+};
+
+// 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"];
+
+// "static" function to return existing objs.
+Media.get = function(id) {
+ return mediaObjects[id];
+};
+
+/**
+ * Start or resume playing audio file.
+ */
+Media.prototype.play = function(options) {
+ exec(null, null, "Media", "startPlayingAudio", [this.id, this.src, options]);
+};
+
+/**
+ * Stop playing audio file.
+ */
+Media.prototype.stop = function() {
+ var me = this;
+ exec(function() {
+ me._position = 0;
+ }, this.errorCallback, "Media", "stopPlayingAudio", [this.id]);
+};
+
+/**
+ * Seek or jump to a new time in the track..
+ */
+Media.prototype.seekTo = function(milliseconds) {
+ var me = this;
+ exec(function(p) {
+ me._position = p;
+ }, this.errorCallback, "Media", "seekToAudio", [this.id, milliseconds]);
+};
+
+/**
+ * Pause playing audio file.
+ */
+Media.prototype.pause = function() {
+ exec(null, this.errorCallback, "Media", "pausePlayingAudio", [this.id]);
+};
+
+/**
+ * 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.
+ */
+Media.prototype.getCurrentPosition = function(success, fail) {
+ var me = this;
+ exec(function(p) {
+ me._position = p;
+ success(p);
+ }, fail, "Media", "getCurrentPositionAudio", [this.id]);
+};
+
+/**
+ * Start recording audio file.
+ */
+Media.prototype.startRecord = function() {
+ exec(null, this.errorCallback, "Media", "startRecordingAudio", [this.id, this.src]);
+};
+
+/**
+ * Stop recording audio file.
+ */
+Media.prototype.stopRecord = function() {
+ exec(null, this.errorCallback, "Media", "stopRecordingAudio", [this.id]);
+};
+
+/**
+ * Release the resources.
+ */
+Media.prototype.release = function() {
+ exec(null, this.errorCallback, "Media", "release", [this.id]);
+};
+
+/**
+ * Adjust the volume.
+ */
+Media.prototype.setVolume = function(volume) {
+ exec(null, null, "Media", "setVolume", [this.id, volume]);
+};
+
+/**
+ * Audio has status update.
+ * PRIVATE
+ *
+ * @param id The media object id (string)
+ * @param status The status code (int)
+ * @param msg The status message (string)
+ */
+Media.onStatus = function(id, msg, value) {
+ var media = mediaObjects[id];
+ // If state update
+ if (msg === Media.MEDIA_STATE) {
+ if (media.statusCallback) {
+ media.statusCallback(value);
+ }
+ if (value === Media.MEDIA_STOPPED) {
+ if (media.successCallback) {
+ media.successCallback();
+ }
+ }
+ }
+ else if (msg === Media.MEDIA_DURATION) {
+ media._duration = value;
+ }
+ else if (msg === Media.MEDIA_ERROR) {
+ if (media.errorCallback) {
+ // value should be a MediaError object when msg == MEDIA_ERROR
+ media.errorCallback(value);
+ }
+ }
+ else if (msg === Media.MEDIA_POSITION) {
+ media._position = value;
+ }
+};
+
+module.exports = Media;
+});
+
+// file: lib/common/plugin/MediaError.js
+define("cordova/plugin/MediaError", function(require, exports, module) {
+/**
+ * This class contains information about any Media errors.
+ * @constructor
+ */
+var MediaError = function(code, msg) {
+ this.code = (code !== undefined ? code : null);
+ this.message = msg || "";
+};
+
+MediaError.MEDIA_ERR_NONE_ACTIVE = 0;
+MediaError.MEDIA_ERR_ABORTED = 1;
+MediaError.MEDIA_ERR_NETWORK = 2;
+MediaError.MEDIA_ERR_DECODE = 3;
+MediaError.MEDIA_ERR_NONE_SUPPORTED = 4;
+
+module.exports = MediaError;
+});
+
+// file: lib/common/plugin/MediaFile.js
+define("cordova/plugin/MediaFile", function(require, exports, module) {
+var utils = require('cordova/utils'),
+ exec = require('cordova/exec'),
+ File = require('cordova/plugin/File'),
+ CaptureError = require('cordova/plugin/CaptureError');
+/**
+ * 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
+ */
+var MediaFile = function(name, fullPath, type, lastModifiedDate, size){
+ MediaFile.__super__.constructor.apply(this, arguments);
+};
+
+utils.extend(MediaFile, File);
+
+/**
+ * Request capture format data for a specific file and type
+ *
+ * @param {Function} successCB
+ * @param {Function} errorCB
+ */
+MediaFile.prototype.getFormatData = function(successCallback, errorCallback) {
+ if (typeof this.fullPath === "undefined" || this.fullPath === null) {
+ errorCallback(new CaptureError(CaptureError.CAPTURE_INVALID_ARGUMENT));
+ } else {
+ exec(successCallback, errorCallback, "Capture", "getFormatData", [this.fullPath, this.type]);
+ }
+};
+
+module.exports = MediaFile;
+
+});
+
+// file: lib/common/plugin/MediaFileData.js
+define("cordova/plugin/MediaFileData", function(require, exports, module) {
+/**
+ * MediaFileData encapsulates format information of a media file.
+ *
+ * @param {DOMString} codecs
+ * @param {long} bitrate
+ * @param {long} height
+ * @param {long} width
+ * @param {float} duration
+ */
+var MediaFileData = function(codecs, bitrate, height, width, duration){
+ this.codecs = codecs || null;
+ this.bitrate = bitrate || 0;
+ this.height = height || 0;
+ this.width = width || 0;
+ this.duration = duration || 0;
+};
+
+module.exports = MediaFileData;
+});
+
+// file: lib/common/plugin/Metadata.js
+define("cordova/plugin/Metadata", function(require, exports, module) {
+/**
+ * Information about the state of the file or directory
+ *
+ * {Date} modificationTime (readonly)
+ */
+var Metadata = function(time) {
+ this.modificationTime = (typeof time != 'undefined'?new Date(time):null);
+};
+
+module.exports = Metadata;
+});
+
+// file: lib/common/plugin/Position.js
+define("cordova/plugin/Position", function(require, exports, module) {
+var Coordinates = require('cordova/plugin/Coordinates');
+
+var Position = function(coords, timestamp) {
+ if (coords) {
+ this.coords = new Coordinates(coords.latitude, coords.longitude, coords.altitude, coords.accuracy, coords.heading, coords.velocity, coords.altitudeAccuracy);
+ } else {
+ this.coords = new Coordinates();
+ }
+ this.timestamp = (timestamp !== undefined) ? timestamp : new Date();
+};
+
+module.exports = Position;
+
+});
+
+// file: lib/common/plugin/PositionError.js
+define("cordova/plugin/PositionError", function(require, exports, module) {
+/**
+ * Position error object
+ *
+ * @constructor
+ * @param code
+ * @param message
+ */
+var PositionError = function(code, message) {
+ this.code = code || null;
+ this.message = message || '';
+};
+
+PositionError.PERMISSION_DENIED = 1;
+PositionError.POSITION_UNAVAILABLE = 2;
+PositionError.TIMEOUT = 3;
+
+module.exports = PositionError;
+});
+
+// file: lib/common/plugin/ProgressEvent.js
+define("cordova/plugin/ProgressEvent", function(require, exports, module) {
+// If ProgressEvent exists in global context, use it already, otherwise use our own polyfill
+// Feature test: See if we can instantiate a native ProgressEvent;
+// if so, use that approach,
+// otherwise fill-in with our own implementation.
+//
+// NOTE: right now we always fill in with our own. Down the road would be nice if we can use whatever is native in the webview.
+var ProgressEvent = (function() {
+ /*
+ var createEvent = function(data) {
+ var event = document.createEvent('Events');
+ event.initEvent('ProgressEvent', false, false);
+ if (data) {
+ for (var i in data) {
+ if (data.hasOwnProperty(i)) {
+ event[i] = data[i];
+ }
+ }
+ if (data.target) {
+ // TODO: cannot call <some_custom_object>.dispatchEvent
+ // need to first figure out how to implement EventTarget
+ }
+ }
+ return event;
+ };
+ try {
+ var ev = createEvent({type:"abort",target:document});
+ return function ProgressEvent(type, data) {
+ data.type = type;
+ return createEvent(data);
+ };
+ } catch(e){
+ */
+ return function ProgressEvent(type, dict) {
+ this.type = type;
+ this.bubbles = false;
+ this.cancelBubble = false;
+ this.cancelable = false;
+ this.lengthComputable = false;
+ this.loaded = dict && dict.loaded ? dict.loaded : 0;
+ this.total = dict && dict.total ? dict.total : 0;
+ this.target = dict && dict.target ? dict.target : null;
+ };
+ //}
+})();
+
+module.exports = ProgressEvent;
+});
+
+// file: lib/common/plugin/accelerometer.js
+define("cordova/plugin/accelerometer", function(require, exports, module) {
+/**
+ * This class provides access to device accelerometer data.
+ * @constructor
+ */
+var utils = require("cordova/utils"),
+ exec = require("cordova/exec"),
+ Acceleration = require('cordova/plugin/Acceleration');
+
+// Is the accel sensor running?
+var running = false;
+
+// Keeps reference to watchAcceleration calls.
+var timers = {};
+
+// Array of listeners; used to keep track of when we should call start and stop.
+var listeners = [];
+
+// Last returned acceleration object from native
+var accel = null;
+
+// Tells native to start.
+function start() {
+ exec(function(a) {
+ var tempListeners = listeners.slice(0);
+ accel = new Acceleration(a.x, a.y, a.z, a.timestamp);
+ for (var i = 0, l = tempListeners.length; i < l; i++) {
+ tempListeners[i].win(accel);
+ }
+ }, function(e) {
+ var tempListeners = listeners.slice(0);
+ for (var i = 0, l = tempListeners.length; i < l; i++) {
+ tempListeners[i].fail(e);
+ }
+ }, "Accelerometer", "start", []);
+ running = true;
+}
+
+// Tells native to stop.
+function stop() {
+ exec(null, null, "Accelerometer", "stop", []);
+ running = false;
+}
+
+// Adds a callback pair to the listeners array
+function createCallbackPair(win, fail) {
+ return {win:win, fail:fail};
+}
+
+// Removes a win/fail listener pair from the listeners array
+function removeListeners(l) {
+ var idx = listeners.indexOf(l);
+ if (idx > -1) {
+ listeners.splice(idx, 1);
+ if (listeners.length === 0) {
+ stop();
+ }
+ }
+}
+
+var accelerometer = {
+ /**
+ * Asynchronously aquires the current acceleration.
+ *
+ * @param {Function} successCallback The function to call when the acceleration data is available
+ * @param {Function} errorCallback The function to call when there is an error getting the acceleration data. (OPTIONAL)
+ * @param {AccelerationOptions} options The options for getting the accelerometer data such as timeout. (OPTIONAL)
+ */
+ getCurrentAcceleration: function(successCallback, errorCallback, options) {
+ // successCallback required
+ if (typeof successCallback !== "function") {
+ throw "getCurrentAcceleration must be called with at least a success callback function as first parameter.";
+ }
+
+ var p;
+ var win = function(a) {
+ removeListeners(p);
+ successCallback(a);
+ };
+ var fail = function(e) {
+ removeListeners(p);
+ errorCallback(e);
+ };
+
+ p = createCallbackPair(win, fail);
+ listeners.push(p);
+
+ if (!running) {
+ start();
+ }
+ },
+
+ /**
+ * Asynchronously aquires the acceleration repeatedly at a given interval.
+ *
+ * @param {Function} successCallback The function to call each time the acceleration data is available
+ * @param {Function} errorCallback The function to call when there is an error getting the acceleration data. (OPTIONAL)
+ * @param {AccelerationOptions} options The options for getting the accelerometer data such as timeout. (OPTIONAL)
+ * @return String The watch id that must be passed to #clearWatch to stop watching.
+ */
+ watchAcceleration: function(successCallback, errorCallback, options) {
+ // Default interval (10 sec)
+ var frequency = (options && options.frequency && typeof options.frequency == 'number') ? options.frequency : 10000;
+
+ // successCallback required
+ if (typeof successCallback !== "function") {
+ throw "watchAcceleration must be called with at least a success callback function as first parameter.";
+ }
+
+ // Keep reference to watch id, and report accel readings as often as defined in frequency
+ var id = utils.createUUID();
+
+ var p = createCallbackPair(function(){}, function(e) {
+ removeListeners(p);
+ errorCallback(e);
+ });
+ listeners.push(p);
+
+ timers[id] = {
+ timer:window.setInterval(function() {
+ if (accel) {
+ successCallback(accel);
+ }
+ }, frequency),
+ listeners:p
+ };
+
+ if (running) {
+ // If we're already running then immediately invoke the success callback
+ // but only if we have retrieved a value, sample code does not check for null ...
+ if(accel) {
+ successCallback(accel);
+ }
+ } else {
+ start();
+ }
+
+ return id;
+ },
+
+ /**
+ * Clears the specified accelerometer watch.
+ *
+ * @param {String} id The id of the watch returned from #watchAcceleration.
+ */
+ clearWatch: function(id) {
+ // Stop javascript timer & remove from timer list
+ if (id && timers[id]) {
+ window.clearInterval(timers[id].timer);
+ removeListeners(timers[id].listeners);
+ delete timers[id];
+ }
+ }
+};
+
+module.exports = accelerometer;
+
+});
+
+// file: lib/common/plugin/battery.js
+define("cordova/plugin/battery", function(require, exports, module) {
+/**
+ * This class contains information about the current battery status.
+ * @constructor
+ */
+var cordova = require('cordova'),
+ exec = require('cordova/exec');
+
+function handlers() {
+ return battery.channels.batterystatus.numHandlers +
+ battery.channels.batterylow.numHandlers +
+ battery.channels.batterycritical.numHandlers;
+}
+
+var Battery = function() {
+ this._level = null;
+ this._isPlugged = null;
+ // Create new event handlers on the window (returns a channel instance)
+ var subscriptionEvents = {
+ onSubscribe:this.onSubscribe,
+ onUnsubscribe:this.onUnsubscribe
+ };
+ this.channels = {
+ batterystatus:cordova.addWindowEventHandler("batterystatus", subscriptionEvents),
+ batterylow:cordova.addWindowEventHandler("batterylow", subscriptionEvents),
+ batterycritical:cordova.addWindowEventHandler("batterycritical", subscriptionEvents)
+ };
+};
+/**
+ * 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.prototype.onSubscribe = function() {
+ var me = battery;
+ // If we just registered the first handler, make sure native listener is started.
+ if (handlers() === 1) {
+ exec(me._status, me._error, "Battery", "start", []);
+ }
+};
+
+Battery.prototype.onUnsubscribe = function() {
+ var me = battery;
+
+ // If we just unregistered the last handler, make sure native listener is stopped.
+ if (handlers() === 0) {
+ exec(null, null, "Battery", "stop", []);
+ }
+};
+
+/**
+ * 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);
+
+ // Fire low battery event
+ if (level === 20 || level === 5) {
+ if (level === 20) {
+ cordova.fireWindowEvent("batterylow", info);
+ }
+ else {
+ cordova.fireWindowEvent("batterycritical", info);
+ }
+ }
+ }
+ 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) {
+var exec = require('cordova/exec'),
+ MediaFile = require('cordova/plugin/MediaFile');
+
+/**
+ * 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);
+ }
+ 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);
+};
+
+/**
+ * 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);
+};
+
+
+module.exports = new Capture();
+
+});
+
+// file: lib/common/plugin/compass.js
+define("cordova/plugin/compass", function(require, exports, module) {
+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;
+ }
+
+ // errorCallback optional
+ if (errorCallback && (typeof errorCallback !== "function")) {
+ console.log("Compass Error: errorCallback is not a function");
+ return;
+ }
+
+ 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;
+ }
+
+ // errorCallback optional
+ if (errorCallback && (typeof errorCallback !== "function")) {
+ console.log("Compass Error: errorCallback is not a function");
+ return;
+ }
+
+ 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);
+ }
+
+ 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", []);
+ }
+ delete timers[id];
+ }
+ }
+ };
+
+module.exports = compass;
+});
+
+// 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");
+
+//------------------------------------------------------------------------------
+// object that we're exporting
+//------------------------------------------------------------------------------
+var console = module.exports;
+
+//------------------------------------------------------------------------------
+// copy of the original console object
+//------------------------------------------------------------------------------
+var WinConsole = window.console;
+
+//------------------------------------------------------------------------------
+// whether to use the logger
+//------------------------------------------------------------------------------
+var UseLogger = false;
+
+//------------------------------------------------------------------------------
+// Timers
+//------------------------------------------------------------------------------
+var Timers = {};
+
+//------------------------------------------------------------------------------
+// used for unimplemented methods
+//------------------------------------------------------------------------------
+function noop() {}
+
+//------------------------------------------------------------------------------
+// used for unimplemented methods
+//------------------------------------------------------------------------------
+console.useLogger = function (value) {
+ if (arguments.length) UseLogger = !!value;
+
+ if (UseLogger) {
+ if (logger.useConsole()) {
+ throw new Error("console and logger are too intertwingly");
+ }
+ }
+
+ 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));
+};
+
+//------------------------------------------------------------------------------
+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));
+};
+
+//------------------------------------------------------------------------------
+console.debug = function() {
+ if (logger.useConsole()) return;
+ logger.debug.apply(logger, [].slice.call(arguments));
+};
+
+//------------------------------------------------------------------------------
+console.assert = function(expression) {
+ if (expression) return;
+
+ var message = utils.vformat(arguments[1], [].slice.call(arguments, 2));
+ console.log("ASSERT: " + message);
+};
+
+//------------------------------------------------------------------------------
+console.clear = function() {};
+
+//------------------------------------------------------------------------------
+console.dir = function(object) {
+ console.log("%o", object);
+};
+
+//------------------------------------------------------------------------------
+console.dirxml = function(node) {
+ console.log(node.innerHTML);
+};
+
+//------------------------------------------------------------------------------
+console.trace = noop;
+
+//------------------------------------------------------------------------------
+console.group = console.log;
+
+//------------------------------------------------------------------------------
+console.groupCollapsed = console.log;
+
+//------------------------------------------------------------------------------
+console.groupEnd = noop;
+
+//------------------------------------------------------------------------------
+console.time = function(name) {
+ Timers[name] = new Date().valueOf();
+};
+
+//------------------------------------------------------------------------------
+console.timeEnd = function(name) {
+ var timeStart = Timers[name];
+ if (!timeStart) {
+ console.warn("unknown timer: " + name);
+ return;
+ }
+
+ var timeElapsed = new Date().valueOf() - timeStart;
+ console.log(name + ": " + timeElapsed + "ms");
+};
+
+//------------------------------------------------------------------------------
+console.timeStamp = noop;
+
+//------------------------------------------------------------------------------
+console.profile = noop;
+
+//------------------------------------------------------------------------------
+console.profileEnd = noop;
+
+//------------------------------------------------------------------------------
+console.count = noop;
+
+//------------------------------------------------------------------------------
+console.exception = console.log;
+
+//------------------------------------------------------------------------------
+console.table = function(data, columns) {
+ console.log("%o", data);
+};
+
+//------------------------------------------------------------------------------
+// return a new function that calls both functions passed as args
+//------------------------------------------------------------------------------
+function wrapperedOrigCall(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] = wrapperedOrigCall(WinConsole[key], console[key]);
+ }
+}
+
+});
+
+// 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');
+
+/**
+* Represents a group of Contacts.
+* @constructor
+*/
+var contacts = {
+ /**
+ * 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
+ */
+ 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]));
+ }
+ successCB(cs);
+ };
+ exec(win, errorCB, "Contacts", "search", [fields, options]);
+ }
+ },
+
+ /**
+ * 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
+ */
+ 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];
+ }
+ }
+ return contact;
+ }
+};
+
+module.exports = contacts;
+
+});
+
+// file: lib/common/plugin/device.js
+define("cordova/plugin/device", 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');
+
+/**
+ * This represents the mobile device, and provides properties for inspecting the model, version, UUID of the
+ * phone, etc.
+ * @constructor
+ */
+function Device() {
+ this.available = false;
+ this.platform = null;
+ this.version = null;
+ this.name = null;
+ this.uuid = null;
+ this.cordova = null;
+
+ var me = this;
+
+ channel.onCordovaReady.subscribeOnce(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);
+ });
+ });
+}
+
+/**
+ * Get device info
+ *
+ * @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)
+ */
+Device.prototype.getInfo = function(successCallback, errorCallback) {
+
+ // successCallback required
+ if (typeof successCallback !== "function") {
+ console.log("Device Error: successCallback is not a function");
+ return;
+ }
+
+ // errorCallback optional
+ if (errorCallback && (typeof errorCallback !== "function")) {
+ console.log("Device Error: errorCallback is not a function");
+ return;
+ }
+
+ // Get info
+ exec(successCallback, errorCallback, "Device", "getDeviceInfo", []);
+};
+
+module.exports = new Device();
+
+});
+
+// file: lib/common/plugin/echo.js
+define("cordova/plugin/echo", function(require, exports, module) {
+var exec = require('cordova/exec');
+
+/**
+ * Sends the given message through exec() to the Echo plugink, 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).
+ */
+module.exports = function(successCallback, errorCallback, message, forceAsync) {
+ var action = forceAsync ? 'echoAsync' : 'echo';
+ exec(successCallback, errorCallback, "Echo", action, [message]);
+};
+
+
+});
+
+// file: lib/common/plugin/geolocation.js
+define("cordova/plugin/geolocation", function(require, exports, module) {
+var utils = require('cordova/utils'),
+ exec = require('cordova/exec'),
+ PositionError = require('cordova/plugin/PositionError'),
+ Position = require('cordova/plugin/Position');
+
+var timers = {}; // list of timers in use
+
+// Returns default params, overrides if provided with values
+function parseParameters(options) {
+ var opt = {
+ maximumAge: 0,
+ enableHighAccuracy: false,
+ timeout: Infinity
+ };
+
+ if (options) {
+ if (options.maximumAge !== undefined && !isNaN(options.maximumAge) && options.maximumAge > 0) {
+ opt.maximumAge = options.maximumAge;
+ }
+ if (options.enableHighAccuracy !== undefined) {
+ opt.enableHighAccuracy = options.enableHighAccuracy;
+ }
+ if (options.timeout !== undefined && !isNaN(options.timeout)) {
+ if (options.timeout < 0) {
+ opt.timeout = 0;
+ } else {
+ opt.timeout = options.timeout;
+ }
+ }
+ }
+
+ return opt;
+}
+
+// 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;
+}
+
+var geolocation = {
+ lastPosition:null, // reference to last known (cached) position returned
+ /**
+ * 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 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.");
+ }
+ 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 = null;
+
+ var win = function(p) {
+ clearTimeout(timeoutTimer);
+ if (!timeoutTimer) {
+ // 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);
+ timeoutTimer = null;
+ var err = new PositionError(e.code, e.message);
+ if (errorCallback) {
+ errorCallback(err);
+ }
+ };
+
+ // 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 = 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 = true;
+ }
+ exec(win, fail, "Geolocation", "getLocation", [options.enableHighAccuracy, options.maximumAge]);
+ }
+ return timeoutTimer;
+ },
+ /**
+ * 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.");
+ }
+ options = parseParameters(options);
+
+ var id = utils.createUUID();
+
+ // 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);
+
+ var fail = function(e) {
+ clearTimeout(timers[id]);
+ var err = new PositionError(e.code, e.message);
+ if (errorCallback) {
+ errorCallback(err);
+ }
+ };
+
+ var win = function(p) {
+ clearTimeout(timers[id]);
+ if (options.timeout !== Infinity) {
+ timers[id] = createTimeout(fail, options.timeout);
+ }
+ 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]);
+
+ 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]);
+ delete timers[id];
+ exec(null, null, "Geolocation", "clearWatch", [id]);
+ }
+ }
+};
+
+module.exports = geolocation;
+
+});
+
+// file: lib/common/plugin/logger.js
+define("cordova/plugin/logger", function(require, exports, module) {
+//------------------------------------------------------------------------------
+// The logger module exports the following properties/functions:
+//
+// LOG - constant for the level LOG
+// ERROR - constant for the level ERROR
+// WARN - constant for the level WARN
+// INFO - constant for the level INFO
+// DEBUG - constant for the level DEBUG
+// logLevel() - returns current log level
+// logLevel(value) - sets and returns a new log level
+// useConsole() - returns whether logger is using console
+// useConsole(value) - sets and returns whether logger is using console
+// log(message,...) - logs a message at level LOG
+// error(message,...) - logs a message at level ERROR
+// warn(message,...) - logs a message at level WARN
+// info(message,...) - logs a message at level INFO
+// debug(message,...) - logs a message at level DEBUG
+// logLevel(level,message,...) - logs a message specified level
+//
+//------------------------------------------------------------------------------
+
+var logger = exports;
+
+var exec = require('cordova/exec');
+var utils = require('cordova/utils');
+
+var UseConsole = true;
+var Queued = [];
+var DeviceReady = false;
+var CurrentLevel;
+
+/**
+ * Logging levels
+ */
+
+var Levels = [
+ "LOG",
+ "ERROR",
+ "WARN",
+ "INFO",
+ "DEBUG"
+];
+
+/*
+ * add the logging levels to the logger object and
+ * to a separate levelsMap object for testing
+ */
+
+var LevelsMap = {};
+for (var i=0; i<Levels.length; i++) {
+ var level = Levels[i];
+ LevelsMap[level] = i;
+ logger[level] = level;
+}
+
+CurrentLevel = LevelsMap.WARN;
+
+/**
+ * Getter/Setter for the logging level
+ *
+ * Returns the current logging level.
+ *
+ * When a value is passed, sets the logging level to that value.
+ * The values should be one of the following constants:
+ * logger.LOG
+ * logger.ERROR
+ * logger.WARN
+ * logger.INFO
+ * logger.DEBUG
+ *
+ * The value used determines which messages get printed. The logging
+ * values above are in order, and only messages logged at the logging
+ * level or above will actually be displayed to the user. E.g., the
+ * default level is WARN, so only messages logged with LOG, ERROR, or
+ * WARN will be displayed; INFO and DEBUG messages will be ignored.
+ */
+logger.level = function (value) {
+ if (arguments.length) {
+ if (LevelsMap[value] === null) {
+ throw new Error("invalid logging level: " + value);
+ }
+ CurrentLevel = LevelsMap[value];
+ }
+
+ return Levels[CurrentLevel];
+};
+
+/**
+ * Getter/Setter for the useConsole functionality
+ *
+ * When useConsole is true, the logger will log via the
+ * browser 'console' object. Otherwise, it will use the
+ * native Logger plugin.
+ */
+logger.useConsole = function (value) {
+ if (arguments.length) UseConsole = !!value;
+
+ if (UseConsole) {
+ if (typeof console == "undefined") {
+ throw new Error("global console object is not defined");
+ }
+
+ if (typeof console.log != "function") {
+ throw new Error("global console object does not have a log function");
+ }
+
+ if (typeof console.useLogger == "function") {
+ if (console.useLogger()) {
+ throw new Error("console and logger are too intertwingly");
+ }
+ }
+ }
+
+ return UseConsole;
+};
+
+/**
+ * Logs a message at the LOG level.
+ *
+ * Parameters passed after message are used applied to
+ * the message with utils.format()
+ */
+logger.log = function(message) { logWithArgs("LOG", arguments); };
+
+/**
+ * Logs a message at the ERROR level.
+ *
+ * Parameters passed after message are used applied to
+ * the message with utils.format()
+ */
+logger.error = function(message) { logWithArgs("ERROR", arguments); };
+
+/**
+ * Logs a message at the WARN level.
+ *
+ * Parameters passed after message are used applied to
+ * the message with utils.format()
+ */
+logger.warn = function(message) { logWithArgs("WARN", arguments); };
+
+/**
+ * Logs a message at the INFO level.
+ *
+ * Parameters passed after message are used applied to
+ * the message with utils.format()
+ */
+logger.info = function(message) { logWithArgs("INFO", arguments); };
+
+/**
+ * Logs a message at the DEBUG level.
+ *
+ * Parameters passed after message are used applied to
+ * the message with utils.format()
+ */
+logger.debug = function(message) { logWithArgs("DEBUG", arguments); };
+
+// log at the specified level with args
+function logWithArgs(level, args) {
+ args = [level].concat([].slice.call(args));
+ logger.logLevel.apply(logger, args);
+}
+
+/**
+ * Logs a message at the specified level.
+ *
+ * Parameters passed after message are used applied to
+ * the message with utils.format()
+ */
+logger.logLevel = function(level, message /* , ... */) {
+ // format the message with the parameters
+ var formatArgs = [].slice.call(arguments, 2);
+ message = utils.vformat(message, formatArgs);
+
+ if (LevelsMap[level] === null) {
+ throw new Error("invalid logging level: " + level);
+ }
+
+ if (LevelsMap[level] > CurrentLevel) return;
+
+ // queue the message if not yet at deviceready
+ if (!DeviceReady && !UseConsole) {
+ Queued.push([level, message]);
+ return;
+ }
+
+ // if not using the console, use the native logger
+ if (!UseConsole) {
+ exec(null, null, "Logger", "logLevel", [level, message]);
+ return;
+ }
+
+ // make sure console is not using logger
+ if (console.__usingCordovaLogger) {
+ throw new Error("console and logger are too intertwingly");
+ }
+
+ // log to the console
+ switch (level) {
+ case logger.LOG: console.log(message); break;
+ case logger.ERROR: console.log("ERROR: " + message); break;
+ case logger.WARN: console.log("WARN: " + message); break;
+ case logger.INFO: console.log("INFO: " + message); break;
+ case logger.DEBUG: console.log("DEBUG: " + message); break;
+ }
+};
+
+// when deviceready fires, log queued messages
+logger.__onDeviceReady = function() {
+ if (DeviceReady) return;
+
+ DeviceReady = true;
+
+ for (var i=0; i<Queued.length; i++) {
+ var messageArgs = Queued[i];
+ logger.logLevel(messageArgs[0], messageArgs[1]);
+ }
+
+ Queued = null;
+};
+
+// add a deviceready event to log queued messages
+document.addEventListener("deviceready", logger.__onDeviceReady, false);
+
+});
+
+// file: lib/common/plugin/network.js
+define("cordova/plugin/network", function(require, exports, module) {
+var exec = require('cordova/exec'),
+ cordova = require('cordova'),
+ channel = require('cordova/channel');
+
+var NetworkConnection = function () {
+ this.type = null;
+ this._firstRun = true;
+ this._timer = null;
+ this.timeout = 500;
+
+ var me = this;
+
+ channel.onCordovaReady.subscribeOnce(function() {
+ me.getInfo(function (info) {
+ me.type = info;
+ if (info === "none") {
+ // set a timer if still offline at the end of timer send the offline event
+ me._timer = setTimeout(function(){
+ cordova.fireDocumentEvent("offline");
+ me._timer = null;
+ }, me.timeout);
+ } else {
+ // If there is a current offline event pending clear it
+ if (me._timer !== null) {
+ clearTimeout(me._timer);
+ me._timer = null;
+ }
+ cordova.fireDocumentEvent("online");
+ }
+
+ // should only fire this once
+ if (me._firstRun) {
+ me._firstRun = false;
+ channel.onCordovaConnectionReady.fire();
+ }
+ },
+ function (e) {
+ // If we can't get the network info we should still tell Cordova
+ // to fire the deviceready event.
+ if (me._firstRun) {
+ me._firstRun = false;
+ channel.onCordovaConnectionReady.fire();
+ }
+ console.log("Error initializing Network Connection: " + e);
+ });
+ });
+};
+
+/**
+ * Get connection info
+ *
+ * @param {Function} successCallback The function to call when the Connection data is available
+ * @param {Function} errorCallback The function to call when there is an error getting the Connection data. (OPTIONAL)
+ */
+NetworkConnection.prototype.getInfo = function (successCallback, errorCallback) {
+ // Get info
+ exec(successCallback, errorCallback, "NetworkStatus", "getConnectionInfo", []);
+};
+
+module.exports = new NetworkConnection();
+});
+
+// file: lib/common/plugin/notification.js
+define("cordova/plugin/notification", function(require, exports, module) {
+var exec = require('cordova/exec');
+
+/**
+ * Provides access to notifications on the device.
+ */
+
+module.exports = {
+
+ /**
+ * 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)
+ */
+ alert: function(message, completeCallback, title, buttonLabel) {
+ var _title = (title || "Alert");
+ var _buttonLabel = (buttonLabel || "OK");
+ exec(completeCallback, null, "Notification", "alert", [message, _title, _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')
+ */
+ confirm: function(message, resultCallback, title, buttonLabels) {
+ var _title = (title || "Confirm");
+ var _buttonLabels = (buttonLabels || "OK,Cancel");
+ exec(resultCallback, null, "Notification", "confirm", [message, _title, _buttonLabels]);
+ },
+
+ /**
+ * Causes the device to vibrate.
+ *
+ * @param {Integer} mills The number of milliseconds to vibrate for.
+ */
+ vibrate: function(mills) {
+ exec(null, null, "Notification", "vibrate", [mills]);
+ },
+
+ /**
+ * Causes the device to beep.
+ * On Android, the default notification ringtone is played "count" times.
+ *
+ * @param {Integer} count The number of beeps.
+ */
+ beep: function(count) {
+ exec(null, null, "Notification", "beep", [count]);
+ }
+};
+});
+
+// file: lib/common/plugin/requestFileSystem.js
+define("cordova/plugin/requestFileSystem", function(require, exports, module) {
+var FileError = require('cordova/plugin/FileError'),
+ FileSystem = require('cordova/plugin/FileSystem'),
+ exec = require('cordova/exec');
+
+/**
+ * Request a file system in which to store application data.
+ * @param type local file system type
+ * @param size indicates how much storage space, in bytes, the application expects to need
+ * @param successCallback invoked with a FileSystem object
+ * @param errorCallback invoked if error occurs retrieving file system
+ */
+var requestFileSystem = function(type, size, successCallback, errorCallback) {
+ var fail = function(code) {
+ if (typeof errorCallback === 'function') {
+ errorCallback(new FileError(code));
+ }
+ };
+
+ if (type < 0 || type > 3) {
+ fail(FileError.SYNTAX_ERR);
+ } else {
+ // if successful, return a FileSystem object
+ var success = function(file_system) {
+ if (file_system) {
+ if (typeof successCallback === 'function') {
+ // grab the name and root from the file system object
+ var result = new FileSystem(file_system.name, file_system.root);
+ successCallback(result);
+ }
+ }
+ else {
+ // no FileSystem object returned
+ fail(FileError.NOT_FOUND_ERR);
+ }
+ };
+ exec(success, fail, "File", "requestFileSystem", [type, size]);
+ }
+};
+
+module.exports = requestFileSystem;
+});
+
+// file: lib/common/plugin/resolveLocalFileSystemURI.js
+define("cordova/plugin/resolveLocalFileSystemURI", function(require, exports, module) {
+var DirectoryEntry = require('cordova/plugin/DirectoryEntry'),
+ FileEntry = require('cordova/plugin/FileEntry'),
+ FileError = require('cordova/plugin/FileError'),
+ exec = require('cordova/exec');
+
+/**
+ * Look up file system Entry referred to by local URI.
+ * @param {DOMString} uri URI referring to a local file or directory
+ * @param successCallback invoked with Entry object corresponding to URI
+ * @param errorCallback invoked if error occurs retrieving file system entry
+ */
+module.exports = function(uri, successCallback, errorCallback) {
+ // error callback
+ var fail = function(error) {
+ if (typeof errorCallback === 'function') {
+ errorCallback(new FileError(error));
+ }
+ };
+ // sanity check for 'not:valid:filename'
+ if(!uri || uri.split(":").length > 2) {
+ setTimeout( function() {
+ fail(FileError.ENCODING_ERR);
+ },0);
+ return;
+ }
+ // if successful, return either a file or directory entry
+ var success = function(entry) {
+ var result;
+ if (entry) {
+ if (typeof successCallback === 'function') {
+ // create appropriate Entry object
+ 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);
+ }
+ };
+
+ exec(success, fail, "File", "resolveLocalFileSystemURI", [uri]);
+};
+
+});
+
+// file: lib/common/plugin/splashscreen.js
+define("cordova/plugin/splashscreen", function(require, exports, module) {
+var exec = require('cordova/exec');
+
+var splashscreen = {
+ show:function() {
+ exec(null, null, "SplashScreen", "show", []);
+ },
+ hide:function() {
+ exec(null, null, "SplashScreen", "hide", []);
+ }
+};
+
+module.exports = splashscreen;
+});
+
+// file: lib/tizen/plugin/tizen/Accelerometer.js
+define("cordova/plugin/tizen/Accelerometer", function(require, exports, module) {
+var callback = null;
+
+module.exports = {
+ start: function (successCallback, errorCallback) {
+ window.removeEventListener("devicemotion", callback);
+ callback = function (motion) {
+ successCallback({
+ x: motion.accelerationIncludingGravity.x,
+ y: motion.accelerationIncludingGravity.y,
+ z: motion.accelerationIncludingGravity.z,
+ timestamp: motion.timeStamp
+ });
+ };
+ window.addEventListener("devicemotion", callback);
+ },
+ stop: function (successCallback, errorCallback) {
+ window.removeEventListener("devicemotion", callback);
+ }
+};
+});
+
+// file: lib/tizen/plugin/tizen/Battery.js
+define("cordova/plugin/tizen/Battery", function(require, exports, module) {
+/*global tizen:false */
+var id = null;
+
+module.exports = {
+ start: function(successCallback, errorCallback) {
+ var tizenSuccessCallback = function(power) {
+ if (successCallback) {
+ successCallback({level: Math.round(power.level * 100), isPlugged: power.isCharging});
+ }
+ };
+
+ if (id === null) {
+ id = tizen.systeminfo.addPropertyValueChangeListener("Power", tizenSuccessCallback);
+ }
+ tizen.systeminfo.getPropertyValue("Power", tizenSuccessCallback, errorCallback);
+ },
+
+ stop: function(successCallback, errorCallback) {
+ tizen.systeminfo.removePropertyValueChangeListener(id);
+ id = null;
+ }
+};
+
+});
+
+// file: lib/tizen/plugin/tizen/BufferLoader.js
+define("cordova/plugin/tizen/BufferLoader", function(require, exports, module) {
+/*
+ * Buffer Loader Object
+ * This class provides a sound buffer for one or more sounds
+ * holded in a local file located by an url
+ *
+ * uses W3C Web Audio API
+ *
+ * @constructor
+ *
+ * @param {AudioContext} audio context object
+ * @param {Array} urlList, array of url for sound to load
+ * @param {function} callback , called after buffer was loaded
+ *
+ */
+
+function BufferLoader(context, urlList, callback) {
+ this.context = context;
+ this.urlList = urlList;
+ this.onload = callback;
+ this.bufferList = [];
+ this.loadCount = 0;
+}
+
+/*
+ * This method loads a sound into a buffer
+ * @param {Array} urlList, array of url for sound to load
+ * @param {Number} index, buffer index in the array where to load the url sound
+ *
+ */
+
+BufferLoader.prototype.loadBuffer = function(url, index) {
+ // Load buffer asynchronously
+ var request = null,
+ loader = null;
+
+ request = new XMLHttpRequest();
+
+ if (request === null) {
+ console.log ("BufferLoader.prototype.loadBuffer, cannot allocate XML http request");
+ return;
+ }
+
+ request.open("GET", url, true);
+ request.responseType = "arraybuffer";
+
+ loader = this;
+
+ request.onload = function() {
+ // Asynchronously decode the audio file data in request.response
+ loader.context.decodeAudioData(
+ request.response,
+ function(buffer) {
+ if (!buffer) {
+ console.log ("BufferLoader.prototype.loadBuffer,error decoding file data: " + url);
+ return;
+ }
+
+ loader.bufferList[index] = buffer;
+
+ if (++loader.loadCount == loader.urlList.length) {
+ loader.onload(loader.bufferList);
+ }
+ }
+ );
+ };
+
+ request.onerror = function() {
+ console.log ("BufferLoader.prototype.loadBuffer, XHR error");
+ };
+
+ request.send();
+};
+
+/*
+ * This method loads all sounds identified by their url
+ * and that where given to the object constructor
+ *
+ */
+
+BufferLoader.prototype.load = function() {
+ for (var i = 0; i < this.urlList.length; ++i) {
+ this.loadBuffer(this.urlList[i], i);
+ }
+};
+
+module.exports = BufferLoader;
+
+});
+
+// file: lib/tizen/plugin/tizen/Camera.js
+define("cordova/plugin/tizen/Camera", function(require, exports, module) {
+/*global tizen:false */
+var Camera = require('cordova/plugin/CameraConstants');
+
+function makeReplyCallback(successCallback, errorCallback) {
+ return {
+ onsuccess: function(reply) {
+ if (reply.length > 0) {
+ successCallback(reply[0].value);
+ } else {
+ errorCallback('Picture selection aborted');
+ }
+ },
+ onfail: function() {
+ console.log('The service launch failed');
+ }
+ };
+}
+
+module.exports = {
+ takePicture: function(successCallback, errorCallback, args) {
+ var destinationType = args[1],
+ sourceType = args[2],
+ encodingType = args[5],
+ mediaType = args[6];
+ // Not supported
+ /*
+ quality = args[0]
+ targetWidth = args[3]
+ targetHeight = args[4]
+ allowEdit = args[7]
+ correctOrientation = args[8]
+ saveToPhotoAlbum = args[9]
+ */
+
+ if (destinationType !== Camera.DestinationType.FILE_URI) {
+ errorCallback('DestinationType not supported');
+ return;
+ }
+ if (mediaType !== Camera.MediaType.PICTURE) {
+ errorCallback('MediaType not supported');
+ return;
+ }
+
+ var mimeType;
+ if (encodingType === Camera.EncodingType.JPEG) {
+ mimeType = 'image/jpeg';
+ } else if (encodingType === Camera.EncodingType.PNG) {
+ mimeType = 'image/png';
+ } else {
+ mimeType = 'image/*';
+ }
+
+ var serviceId;
+ if (sourceType === Camera.PictureSourceType.CAMERA) {
+ serviceId = 'http://tizen.org/appsvc/operation/create_content';
+ } else {
+ serviceId = 'http://tizen.org/appsvc/operation/pick';
+ }
+
+ var service = new tizen.ApplicationService(serviceId, null, mimeType, null);
+ tizen.application.launchService(service, null, null,
+ function(error) { errorCallback(error.message); },
+ makeReplyCallback(successCallback, errorCallback));
+ }
+};
+
+});
+
+// file: lib/tizen/plugin/tizen/Compass.js
+define("cordova/plugin/tizen/Compass", function(require, exports, module) {
+var CompassError = require('cordova/plugin/CompassError'),
+ callback = null, ready = false;
+
+module.exports = {
+ getHeading: function(successCallback, errorCallback) {
+ if (window.DeviceOrientationEvent !== undefined) {
+ callback = function (orientation) {
+ var heading = 360 - orientation.alpha;
+ if (ready) {
+ successCallback({
+ magneticHeading: heading,
+ trueHeading: heading,
+ headingAccuracy: 0,
+ timestamp: orientation.timeStamp
+ });
+ window.removeEventListener("deviceorientation", callback);
+ }
+ ready = true;
+ };
+ ready = false; // workaround invalid first event value returned by WRT
+ window.addEventListener("deviceorientation", callback);
+ }
+ else {
+ errorCallback(CompassError.COMPASS_NOT_SUPPORTED);
+ }
+ }
+};
+
+});
+
+// file: lib/tizen/plugin/tizen/Contact.js
+define("cordova/plugin/tizen/Contact", function(require, exports, module) {
+/*global tizen:false */
+var ContactError = require('cordova/plugin/ContactError'),
+ ContactUtils = require('cordova/plugin/tizen/ContactUtils'),
+ utils = require('cordova/utils'),
+ exec = require('cordova/exec');
+
+// ------------------
+// Utility functions
+// ------------------
+
+
+/**
+ * Retrieves a Tizen Contact object from the device by its unique id.
+ *
+ * @param uid
+ * Unique id of the contact on the device
+ * @return {tizen.Contact} Tizen Contact object or null if contact with
+ * specified id is not found
+ */
+var findByUniqueId = function(id) {
+
+ if (!id) {
+ return null;
+ }
+
+ var tizenContact = null;
+
+ tizen.contact.getDefaultAddressBook().find(
+ function _successCallback(contacts){
+ tizenContact = contacts[0];
+ },
+ function _errorCallback(error){
+ console.log("tizen find error " + error);
+ },
+ new tizen.AttributeFilter('id', 'CONTAINS', id),
+ new tizen.SortMode('id', 'ASC'));
+
+ return tizenContact || null;
+};
+
+
+var traceTizenContact = function (tizenContact) {
+ console.log("cordova/plugin/tizen/Contact/ tizenContact.id " + tizenContact.id);
+ console.log("cordova/plugin/tizen/Contact/ tizenContact.lastUpdated " + tizenContact.lastUpdated);
+ console.log("cordova/plugin/tizen/Contact/ tizenContact.name " + tizenContact.name);
+ console.log("cordova/plugin/tizen/Contact/ tizenContact.account " + tizenContact.account);
+ console.log("cordova/plugin/tizen/Contact/ tizenContact.addresses " + tizenContact.addresses);
+ console.log("cordova/plugin/tizen/Contact/ tizenContact.photoURI " + tizenContact.photoURI);
+ console.log("cordova/plugin/tizen/Contact/ tizenContact.phoneNumbers " + tizenContact.phoneNumbers);
+ console.log("cordova/plugin/tizen/Contact/ tizenContact.emails " + tizenContact.emails);
+ console.log("cordova/plugin/tizen/Contact/ tizenContact.birthday " + tizenContact.birthday);
+ console.log("cordova/plugin/tizen/Contact/ tizenContact.organization " + tizenContact.organization);
+ console.log("cordova/plugin/tizen/Contact/ tizenContact.notes " + tizenContact.notes);
+ console.log("cordova/plugin/tizen/Contact/ tizenContact.urls " + tizenContact.isFavorite);
+ console.log("cordova/plugin/tizen/Contact/ tizenContact.isFavorite " + tizenContact.isFavorite);
+ console.log("cordova/plugin/tizen/Contact/ tizenContact.ringtonesURI " + tizenContact.ringtonesURI);
+ console.log("cordova/plugin/tizen/Contact/ tizenContact.categories " + tizenContact.categories);
+};
+
+
+/**
+ * Creates a Tizen contact object from the W3C Contact object and persists
+ * it to device storage.
+ *
+ * @param {Contact}
+ * contact The contact to save
+ * @return a new contact object with all properties set
+ */
+var saveToDevice = function(contact) {
+
+ if (!contact) {
+ return;
+ }
+
+ var tizenContact = null;
+ var update = false;
+ var i = 0;
+
+ // if the underlying Tizen Contact object already exists, retrieve it for
+ // update
+ if (contact.id) {
+ // we must attempt to retrieve the BlackBerry contact from the device
+ // because this may be an update operation
+ tizenContact = findByUniqueId(contact.id);
+ }
+
+ // contact not found on device, create a new one
+ if (!tizenContact) {
+ tizenContact = new tizen.Contact();
+ }
+ // update the existing contact
+ else {
+ update = true;
+ }
+
+ // NOTE: The user may be working with a partial Contact object, because only
+ // user-specified Contact fields are returned from a find operation (blame
+ // the W3C spec). If this is an update to an existing Contact, we don't
+ // want to clear an attribute from the contact database simply because the
+ // Contact object that the user passed in contains a null value for that
+ // attribute. So we only copy the non-null Contact attributes to the
+ // Tizen Contact object before saving.
+ //
+ // This means that a user must explicitly set a Contact attribute to a
+ // non-null value in order to update it in the contact database.
+ //
+ traceTizenContact (tizenContact);
+
+ // display name
+ if (contact.displayName !== null) {
+ if (tizenContact.name === null) {
+ tizenContact.name = new tizen.ContactName();
+ }
+ if (tizenContact.name !== null) {
+ tizenContact.name.displayName = contact.displayName;
+ }
+ }
+
+ // name
+ if (contact.name !== null) {
+ if (contact.name.givenName) {
+ if (tizenContact.name === null) {
+ tizenContact.name = new tizen.ContactName();
+ }
+ if (tizenContact.name !== null) {
+ tizenContact.name.firstName = contact.name.givenName;
+ }
+ }
+
+ if (contact.name.middleName) {
+ if (tizenContact.name === null) {
+ tizenContact.name = new tizen.ContactName();
+ }
+ if (tizenContact.name !== null) {
+ tizenContact.name.middleName = contact.name.middleName;
+ }
+ }
+
+ if (contact.name.familyName) {
+ if (tizenContact.name === null) {
+ tizenContact.name = new tizen.ContactName();
+ }
+ if (tizenContact.name !== null) {
+ tizenContact.name.lastName = contact.name.familyName;
+ }
+ }
+
+ if (contact.name.honorificPrefix) {
+ if (tizenContact.name === null) {
+ tizenContact.name = new tizen.ContactName();
+ }
+ if (tizenContact.name !== null) {
+ tizenContact.name.prefix = contact.name.honorificPrefix;
+ }
+ }
+ }
+
+ // nickname
+ if (contact.nickname !== null) {
+ if (tizenContact.name === null) {
+ tizenContact.name = new tizen.ContactName();
+ }
+ if (tizenContact.name !== null) {
+ if (!utils.isArray(tizenContact.name.nicknames))
+ {
+ tizenContact.name.nicknames = [];
+ }
+ tizenContact.name.nicknames[0] = contact.nickname;
+ }
+ }
+ else {
+ tizenContact.name.nicknames = [];
+ }
+
+ // note
+ if (contact.note !== null) {
+ if (tizenContact.note === null) {
+ tizenContact.note = [];
+ }
+ if (tizenContact.note !== null) {
+ tizenContact.note[0] = contact.note;
+ }
+ }
+
+ // photos
+ if (contact.photos && utils.isArray(contact.emails) && contact.emails.length > 0) {
+ tizenContact.photoURI = contact.photos[0];
+ }
+
+ if (utils.isDate(contact.birthday)) {
+ if (!utils.isDate(tizenContact.birthday)) {
+ tizenContact.birthday = new Date();
+ }
+ if (utils.isDate(tizenContact.birthday)) {
+ tizenContact.birthday.setDate(contact.birthday.getDate());
+ }
+ }
+
+ // Tizen supports many addresses
+ if (utils.isArray(contact.emails)) {
+
+ // if this is an update, re initialize email addresses
+ if (update) {
+ // doit on effacer sur un update??????
+ }
+
+ // copy the first three email addresses found
+ var emails = [];
+ for (i = 0; i < contact.emails.length; i += 1) {
+ var emailTypes = [];
+
+ emailTypes.push (contact.emails[i].type);
+
+ if (contact.emails[i].pref) {
+ emailTypes.push ("PREF");
+ }
+
+ emails.push(
+ new tizen.ContactEmailAddress(
+ contact.emails[i].value,
+ emailTypes)
+ );
+ }
+ tizenContact.emails = emails.length > 0 ? emails : [];
+ }
+ else {
+ tizenContact.emails = [];
+ }
+
+ // Tizen supports many phone numbers
+ // copy into appropriate fields based on type
+ if (utils.isArray(contact.phoneNumbers)) {
+ // if this is an update, re-initialize phone numbers
+ if (update) {
+ }
+
+ var phoneNumbers = [];
+
+ for (i = 0; i < contact.phoneNumbers.length; i += 1) {
+
+ if (!contact.phoneNumbers[i] || !contact.phoneNumbers[i].value) {
+ continue;
+ }
+
+ var phoneTypes = [];
+ phoneTypes.push (contact.phoneNumbers[i].type);
+
+ if (contact.phoneNumbers[i].pref) {
+ phoneTypes.push ("PREF");
+ }
+
+ phoneNumbers.push(
+ new tizen.ContactPhoneNumber(
+ contact.phoneNumbers[i].value,
+ phoneTypes)
+ );
+ }
+
+ tizenContact.phoneNumbers = phoneNumbers.length > 0 ? phoneNumbers : [];
+ } else {
+ tizenContact.phoneNumbers = [];
+ }
+
+ if (utils.isArray(contact.addresses)) {
+ // if this is an update, re-initialize addresses
+ if (update) {
+ }
+
+ var addresses = [],
+ address = null;
+
+ for ( i = 0; i < contact.addresses.length; i += 1) {
+ address = contact.addresses[i];
+
+ if (!address || address.id === undefined || address.pref === undefined || address.type === undefined || address.formatted === undefined) {
+ continue;
+ }
+
+ var addressTypes = [];
+ addressTypes.push (address.type);
+
+ if (address.pref) {
+ addressTypes.push ("PREF");
+ }
+
+ addresses.push(
+ new tizen.ContactAddress({
+ country: address.country,
+ region : address.region,
+ city: address.locality,
+ streetAddress: address.streetAddress,
+ additionalInformation: "",
+ postalCode: address.postalCode,
+ types : addressTypes
+ }));
+
+ }
+ tizenContact.addresses = addresses.length > 0 ? addresses : [];
+
+ } else{
+ tizenContact.addresses = [];
+ }
+
+ // copy first url found to BlackBerry 'webpage' field
+ if (utils.isArray(contact.urls)) {
+ // if this is an update, re-initialize web page
+ if (update) {
+ }
+
+ var url = null,
+ urls = [];
+
+ for ( i = 0; i< contact.urls.length; i+= 1) {
+ url = contact.urls[i];
+
+ if (!url || !url.value) {
+ continue;
+ }
+
+ urls.push( new tizen.ContactWebSite(url.value, url.type));
+ }
+ tizenContact.urls = urls.length > 0 ? urls : [];
+ } else{
+ tizenContact.urls = [];
+ }
+
+ if (utils.isArray(contact.organizations && contact.organizations.length > 0) ) {
+ // if this is an update, re-initialize org attributes
+ var organization = contact.organizations[0];
+
+ tizenContact.organization = new tizen.ContacOrganization({
+ name: organization.name,
+ department: organization.department,
+ office: "",
+ title: organization.title,
+ role: "",
+ logoURI: ""
+ });
+ }
+
+ // categories
+ if (utils.isArray(contact.categories)) {
+ tizenContact.categories = [];
+
+ var category = null;
+
+ for (i = 0; i < contact.categories.length; i += 1) {
+ category = contact.categories[i];
+
+ if (typeof category === "string") {
+ tizenContact.categories.push(category);
+ }
+ }
+ }
+ else {
+ tizenContact.categories = [];
+ }
+
+ // save to device
+ // in tizen contact mean update or add
+ // later we might use addBatch and updateBatch
+ if (update){
+ tizen.contact.getDefaultAddressBook().update(tizenContact);
+ }
+ else {
+ tizen.contact.getDefaultAddressBook().add(tizenContact);
+ }
+
+ // Use the fully populated Tizen contact object to create a
+ // corresponding W3C contact object.
+ return ContactUtils.createContact(tizenContact, [ "*" ]);
+};
+
+
+/**
+ * Creates a Tizen ContactAddress object from a W3C ContactAddress.
+ *
+ * @return {tizen.ContactAddress} a Tizen ContactAddress object
+ */
+var createTizenAddress = function(address) {
+
+ var type = null,
+ pref = null,
+ typesAr = [];
+
+ if (address === null) {
+ return null;
+ }
+
+
+ var tizenAddress = new tizen.ContactAddress();
+
+ if (tizenAddress === null) {
+ return null;
+ }
+
+ typesAr.push(address.type);
+
+ if (address.pref) {
+ typesAr.push("PREF");
+ }
+
+ tizenAddress.country = address.country || "";
+ tizenAddress.region = address.region || "";
+ tizenAddress.city = address.locality || "";
+ tizenAddress.streetAddress = address.streetAddress || "";
+ tizenAddress.postalCode = address.postalCode || "";
+ tizenAddress.types = typesAr || "";
+
+ return tizenAddress;
+};
+
+module.exports = {
+ /**
+ * Persists contact to device storage.
+ */
+
+ save : function(successCB, failCB) {
+
+ try {
+ // save the contact and store it's unique id
+ var fullContact = saveToDevice(this);
+
+ this.id = fullContact.id;
+
+ // This contact object may only have a subset of properties
+ // if the save was an update of an existing contact. This is
+ // because the existing contact was likely retrieved using a
+ // subset of properties, so only those properties were set in the
+ // object. For this reason, invoke success with the contact object
+ // returned by saveToDevice since it is fully populated.
+
+ if (typeof successCB === 'function') {
+ successCB(fullContact);
+ }
+ }
+ catch (error) {
+ console.log('Error saving contact: ' + error);
+
+ if (typeof failCB === 'function') {
+ failCB (new ContactError(ContactError.UNKNOWN_ERROR));
+ }
+ }
+ },
+
+ /**
+ * Removes contact from device storage.
+ *
+ * @param successCB
+ * successCB callback
+ * @param failCB
+ * error callback
+ */
+ remove : function (successCB, failCB) {
+
+ try {
+ // retrieve contact from device by id
+ var tizenContact = null;
+
+ if (this.id) {
+ tizenContact = findByUniqueId(this.id);
+ }
+
+
+ // if contact was found, remove it
+ if (tizenContact) {
+
+ tizen.contact.getDefaultAddressBook().remove(tizenContact.id);
+
+ if (typeof success === 'function') {
+ successCB(this);
+ }
+ }
+ // attempting to remove a contact that hasn't been saved
+ else if (typeof failCB === 'function') {
+ failCB(new ContactError(ContactError.UNKNOWN_ERROR));
+ }
+ }
+ catch (error) {
+ console.log('Error removing contact ' + this.id + ": " + error);
+ if (typeof failCB === 'function') {
+ failCB(new ContactError(ContactError.UNKNOWN_ERROR));
+ }
+ }
+ }
+};
+
+});
+
+// file: lib/tizen/plugin/tizen/ContactUtils.js
+define("cordova/plugin/tizen/ContactUtils", function(require, exports, module) {
+/*global tizen:false */
+var ContactAddress = require('cordova/plugin/ContactAddress'),
+ ContactName = require('cordova/plugin/ContactName'),
+ ContactField = require('cordova/plugin/ContactField'),
+ ContactOrganization = require('cordova/plugin/ContactOrganization'),
+ utils = require('cordova/utils'),
+ Contact = require('cordova/plugin/Contact');
+
+/**
+ * Mappings for each Contact field that may be used in a find operation. Maps
+ * W3C Contact fields to one or more fields in a Tizen contact object.
+ *
+ * Example: user searches with a filter on the Contact 'name' field:
+ *
+ * <code>Contacts.find(['name'], onSuccess, onFail, {filter:'Bob'});</code>
+ *
+ * The 'name' field does not exist in a Tizen contact. Instead, a filter
+ * expression will be built to search the Tizen contacts using the
+ * Tizen 'title', 'firstName' and 'lastName' fields.
+ */
+var fieldMappings = {
+ "id" : ["id"],
+ "displayName" : ["name.displayName"],
+ "nickname": ["name.nicknames"],
+ "name" : [ "name.prefix", "name.firstName", "name.lastName" ],
+ "phoneNumbers" : ["phoneNumbers.number","phoneNumbers.types"],
+ "emails" : ["emails.types", "emails.email"],
+ "addresses" : ["addresses.country","addresses.region","addresses.city","addresses.streetAddress","addresses.postalCode","addresses.country","addresses.types"],
+ "organizations" : ["organization.name","organization.department","organization.office", "organization.title"],
+ "birthday" : ["birthday"],
+ "note" : ["notes"],
+ "photos" : ["photoURI"],
+ "categories" : ["categories"],
+ "urls" : ["urls.url", "urls.type"]
+};
+
+/*
+ * Build an array of all of the valid W3C Contact fields. This is used to
+ * substitute all the fields when ["*"] is specified.
+ */
+var allFields = [];
+
+(function initializeAllFieldsMapping() {
+
+ for ( var key in fieldMappings) {
+ allFields.push(key);
+ }
+ // as we want it to be executed once
+ function initializeAllFieldsMapping() {
+ }
+
+})();
+
+/**
+ * Create a W3C ContactAddress object from a Tizen Address object
+ *
+ * @param {String}
+ * type the type of address (e.g. work, home)
+ * @param {tizen.ContactAddress}
+ * tizenAddress a Tizen Address object
+ * @return {ContactAddress} a contact address object or null if the specified
+ * address is null
+ */
+var createContactAddress = function(type, tizenAddress) {
+ if (!tizenAddress) {
+ return null;
+ }
+
+ var streetAddress = tizenAddress.streetAddress;
+ var locality = tizenAddress.city || "";
+ var region = tizenAddress.region || "";
+ var postalCode = tizenAddress.postalCode || "";
+ var country = tizenAddress.country || "";
+ var formatted = streetAddress + ", " + locality + ", " + region + ", " + postalCode + ", " + country;
+
+ var contact = new ContactAddress(null, type, formatted, streetAddress, locality, region, postalCode, country);
+
+ return contact;
+};
+
+module.exports = {
+ /**
+ * Builds Tizen filter expressions for contact search using the
+ * contact fields and search filter provided.
+ *
+ * @param {String[]}
+ * fields Array of Contact fields to search
+ * @param {String}
+ * filter Filter, or search string
+ * @param {Boolean}
+ * multiple, one contacts or more wanted as result
+ * @return filter expression or null if fields is empty or filter is null or
+ * empty
+ */
+
+ buildFilterExpression: function(fields, filter) {
+ // ensure filter exists
+ if (!filter || filter === "") {
+ return null;
+ }
+
+ if ((fields.length === 1) && (fields[0] === "*")) {
+ // Cordova enhancement to allow fields value of ["*"] to indicate
+ // all supported fields.
+ fields = allFields;
+ }
+
+ // build a filter expression using all Contact fields provided
+ var compositeFilter = null,
+ attributeFilter = null,
+ filterExpression = null,
+ matchFlag = "CONTAINS",
+ matchValue = filter,
+ attributesArray = [];
+
+ if (fields && utils.isArray(fields)) {
+
+ for ( var field in fields) {
+
+ if (!fields[field]) {
+ continue;
+ }
+
+ // retrieve Tizen contact fields that map Cordova fields specified
+ // (tizenFields is a string or an array of strings)
+ var tizenFields = fieldMappings[fields[field]];
+
+ if (!tizenFields) {
+ // does something maps
+ continue;
+ }
+
+ // construct the filter expression using the Tizen fields
+ for ( var index in tizenFields) {
+ attributeFilter = new tizen.AttributeFilter(tizenFields[index], matchFlag, matchValue);
+ if (attributeFilter !== null) {
+ attributesArray.push(attributeFilter);
+ }
+ }
+ }
+ }
+
+ // fullfil tizen find attribute as a single or a composite attribute
+ if (attributesArray.length == 1 ) {
+ filterExpression = attributeFilter[0];
+ } else if (attributesArray.length > 1) {
+ // combine the filters as a Union
+ filterExpression = new tizen.CompositeFilter("UNION", attributesArray);
+ } else {
+ filterExpression = null;
+ }
+
+ return filterExpression;
+ },
+
+
+
+ /**
+ * Creates a Contact object from a Tizen Contact object, copying only
+ * the fields specified.
+ *
+ * This is intended as a privately used function but it is made globally
+ * available so that a Contact.save can convert a BlackBerry contact object
+ * into its W3C equivalent.
+ *
+ * @param {tizen.Contact}
+ * tizenContact Tizen Contact object
+ * @param {String[]}
+ * fields array of contact fields that should be copied
+ * @return {Contact} a contact object containing the specified fields or
+ * null if the specified contact is null
+ */
+ createContact: function(tizenContact, fields) {
+
+ if (!tizenContact) {
+ return null;
+ }
+
+ // construct a new contact object
+ // always copy the contact id and displayName fields
+ var contact = new Contact(tizenContact.id, tizenContact.name.displayName);
+
+
+ // nothing to do
+ if (!fields || !(utils.isArray(fields)) || fields.length === 0) {
+ return contact;
+ } else if (fields.length === 1 && fields[0] === "*") {
+ // Cordova enhancement to allow fields value of ["*"] to indicate
+ // all supported fields.
+ fields = allFields;
+ }
+
+ // add the fields specified
+ for ( var key in fields) {
+
+ var field = fields[key],
+ index = 0;
+
+ if (!field) {
+ continue;
+ }
+
+ // name
+ if (field.indexOf('name') === 0) {
+
+ var formattedName = (tizenContact.name.prefix || "");
+
+ if (tizenContact.name.firstName) {
+ formattedName += ' ';
+ formattedName += (tizenContact.name.firstName || "");
+ }
+
+ if (tizenContact.name.middleName) {
+ formattedName += ' ';
+ formattedName += (tizenContact.name.middleName || "");
+ }
+
+ if (tizenContact.name.lastName) {
+ formattedName += ' ';
+ formattedName += (tizenContact.name.lastName || "");
+ }
+
+ contact.name = new ContactName(
+ formattedName,
+ tizenContact.name.lastName,
+ tizenContact.name.firstName,
+ tizenContact.name.middleName,
+ tizenContact.name.prefix,
+ null);
+ }
+
+ // phoneNumbers
+ else if (field.indexOf('phoneNumbers') === 0) {
+
+ var phoneNumbers = [];
+
+ for (index = 0 ; index < tizenContact.phoneNumbers.length ; ++index) {
+
+ phoneNumbers.push(
+ new ContactField(
+ 'PHONE',
+ tizenContact.phoneNumbers[index].number,
+ ((tizenContact.phoneNumbers[index].types[1]) && (tizenContact.emails[index].types[1] === "PREF") ) ? true : false));
+ }
+
+
+ contact.phoneNumbers = phoneNumbers.length > 0 ? phoneNumbers : null;
+ }
+
+ // emails
+ else if (field.indexOf('emails') === 0) {
+
+ var emails = [];
+
+ for (index = 0 ; index < tizenContact.emails.length ; ++index) {
+
+ emails.push(
+ new ContactField(
+ 'EMAILS',
+ tizenContact.emails[index].email,
+ ((tizenContact.emails[index].types[1]) && (tizenContact.emails[index].types[1] === "PREF") ) ? true : false));
+ }
+ contact.emails = emails.length > 0 ? emails : null;
+ }
+
+ // addresses
+ else if (field.indexOf('addresses') === 0) {
+
+ var addresses = [];
+ for (index = 0 ; index < tizenContact.addresses.length ; ++index) {
+
+ addresses.push(
+ new ContactAddress(
+ ((tizenContact.addresses[index].types[1] && tizenContact.addresses[index].types[1] === "PREF") ? true : false),
+ tizenContact.addresses[index].types[0] ? tizenContact.addresses[index].types[0] : "HOME",
+ null,
+ tizenContact.addresses[index].streetAddress,
+ tizenContact.addresses[index].city,
+ tizenContact.addresses[index].region,
+ tizenContact.addresses[index].postalCode,
+ tizenContact.addresses[index].country ));
+ }
+
+ contact.addresses = addresses.length > 0 ? addresses : null;
+ }
+
+ // birthday
+ else if (field.indexOf('birthday') === 0) {
+ if (utils.isDate(tizenContact.birthday)) {
+ contact.birthday = tizenContact.birthday;
+ }
+ }
+
+ // note only one in Tizen Contact
+ else if (field.indexOf('note') === 0) {
+ if (tizenContact.note) {
+ contact.note = tizenContact.note[0];
+ }
+ }
+
+ // organizations
+ else if (field.indexOf('organizations') === 0) {
+
+ var organizations = [];
+
+ // there's only one organization in a Tizen Address
+
+ if (tizenContact.organization) {
+ organizations.push(
+ new ContactOrganization(
+ true,
+ 'WORK',
+ tizenContact.organization.name,
+ tizenContact.organization.department,
+ tizenContact.organization.jobTitle));
+ }
+
+ contact.organizations = organizations.length > 0 ? organizations : null;
+ }
+
+ // categories
+ else if (field.indexOf('categories') === 0) {
+
+ var categories = [];
+
+ if (tizenContact.categories) {
+
+ for (index = 0 ; index < tizenContact.categories.length ; ++index) {
+ categories.push(
+ new ContactField(
+ 'MAIN',
+ tizenContact.categories,
+ (index === 0) ));
+ }
+
+ contact.categories = categories.length > 0 ? categories : null;
+ }
+ }
+
+ // urls
+ else if (field.indexOf('urls') === 0) {
+ var urls = [];
+
+ if (tizenContact.urls) {
+ for (index = 0 ; index <tizenContact.urls.length ; ++index) {
+ urls.push(
+ new ContactField(
+ tizenContact.urls[index].type,
+ tizenContact.urls[index].url,
+ (index === 0)));
+ }
+ }
+
+ contact.urls = urls.length > 0 ? urls : null;
+ }
+
+ // photos
+ else if (field.indexOf('photos') === 0) {
+ var photos = [];
+
+ if (tizenContact.photoURI) {
+ photos.push(new ContactField('URI', tizenContact.photoURI, true));
+ }
+
+ contact.photos = photos.length > 0 ? photos : null;
+ }
+ }
+
+ return contact;
+ }
+};
+
+});
+
+// file: lib/tizen/plugin/tizen/Device.js
+define("cordova/plugin/tizen/Device", function(require, exports, module) {
+/*global tizen:false */
+var channel = require('cordova/channel');
+
+// Tell cordova channel to wait on the CordovaInfoReady event
+channel.waitForInitialization('onCordovaInfoReady');
+
+function Device() {
+ this.version = null;
+ this.uuid = null;
+ this.name = null;
+ this.cordova = "2.1.0rc2";
+ this.platform = "Tizen";
+
+ var me = this;
+
+ function onSuccessCallback(sysInfoProp) {
+ me.name = sysInfoProp.model;
+ me.uuid = sysInfoProp.imei;
+ me.version = sysInfoProp.version;
+ channel.onCordovaInfoReady.fire();
+ }
+
+ function onErrorCallback(error) {
+ console.log("error initializing cordova: " + error);
+ }
+
+ channel.onCordovaReady.subscribeOnce(function() {
+ me.getDeviceInfo(onSuccessCallback, onErrorCallback);
+ });
+}
+
+Device.prototype.getDeviceInfo = function(success, fail, args) {
+ tizen.systeminfo.getPropertyValue("Device", success, fail);
+};
+
+module.exports = new Device();
+
+});
+
+// file: lib/tizen/plugin/tizen/File.js
+define("cordova/plugin/tizen/File", function(require, exports, module) {
+/*global WebKitBlobBuilder:false */
+var FileError = require('cordova/plugin/FileError'),
+ DirectoryEntry = require('cordova/plugin/DirectoryEntry'),
+ FileEntry = require('cordova/plugin/FileEntry'),
+ File = require('cordova/plugin/File'),
+ FileSystem = require('cordova/plugin/FileSystem');
+
+var nativeRequestFileSystem = window.webkitRequestFileSystem,
+ nativeResolveLocalFileSystemURI = window.webkitResolveLocalFileSystemURL,
+ NativeFileReader = window.FileReader;
+
+function getFileSystemName(nativeFs) {
+ return (nativeFs.name.indexOf("Persistent") != -1) ? "persistent" : "temporary";
+}
+
+function makeEntry(entry) {
+ if (entry.isDirectory) {
+ return new DirectoryEntry(entry.name, decodeURI(entry.toURL()));
+ }
+ else {
+ return new FileEntry(entry.name, decodeURI(entry.toURL()));
+ }
+}
+
+module.exports = {
+ /* requestFileSystem */
+ requestFileSystem: function(successCallback, errorCallback, args) {
+ var type = args[0],
+ size = args[1];
+
+ nativeRequestFileSystem(type, size, function(nativeFs) {
+ successCallback(new FileSystem(getFileSystemName(nativeFs), makeEntry(nativeFs.root)));
+ }, function(error) {
+ errorCallback(error.code);
+ });
+ },
+
+ /* resolveLocalFileSystemURI */
+ resolveLocalFileSystemURI: function(successCallback, errorCallback, args) {
+ var uri = args[0];
+
+ nativeResolveLocalFileSystemURI(uri, function(entry) {
+ successCallback(makeEntry(entry));
+ }, function(error) {
+ errorCallback(error.code);
+ });
+ },
+
+ /* DirectoryReader */
+ readEntries: function(successCallback, errorCallback, args) {
+ var uri = args[0];
+
+ nativeResolveLocalFileSystemURI(uri, function(dirEntry) {
+ var reader = dirEntry.createReader();
+ reader.readEntries(function(entries) {
+ var retVal = [];
+ for (var i = 0; i < entries.length; i++) {
+ retVal.push(makeEntry(entries[i]));
+ }
+ successCallback(retVal);
+ }, function(error) {
+ errorCallback(error.code);
+ });
+ }, function(error) {
+ errorCallback(error.code);
+ });
+ },
+
+ /* Entry */
+ getMetadata: function(successCallback, errorCallback, args) {
+ var uri = args[0];
+
+ nativeResolveLocalFileSystemURI(uri, function(entry) {
+ entry.getMetadata(function(metaData) {
+ successCallback(metaData.modificationTime);
+ }, function(error) {
+ errorCallback(error.code);
+ });
+ }, function(error) {
+ errorCallback(error.code);
+ });
+ },
+
+ moveTo: function(successCallback, errorCallback, args) {
+ var srcUri = args[0],
+ parentUri = args[1],
+ name = args[2];
+
+ nativeResolveLocalFileSystemURI(srcUri, function(source) {
+ nativeResolveLocalFileSystemURI(parentUri, function(parent) {
+ source.moveTo(parent, name, function(entry) {
+ successCallback(makeEntry(entry));
+ }, function(error) {
+ errorCallback(error.code);
+ });
+ }, function(error) {
+ errorCallback(error.code);
+ });
+ }, function(error) {
+ errorCallback(error.code);
+ });
+ },
+
+ copyTo: function(successCallback, errorCallback, args) {
+ var srcUri = args[0],
+ parentUri = args[1],
+ name = args[2];
+
+ nativeResolveLocalFileSystemURI(srcUri, function(source) {
+ nativeResolveLocalFileSystemURI(parentUri, function(parent) {
+ source.copyTo(parent, name, function(entry) {
+ successCallback(makeEntry(entry));
+ }, function(error) {
+ errorCallback(error.code);
+ });
+ }, function(error) {
+ errorCallback(error.code);
+ });
+ }, function(error) {
+ errorCallback(error.code);
+ });
+ },
+
+ remove: function(successCallback, errorCallback, args) {
+ var uri = args[0];
+
+ nativeResolveLocalFileSystemURI(uri, function(entry) {
+ if (entry.fullPath === "/") {
+ errorCallback(FileError.NO_MODIFICATION_ALLOWED_ERR);
+ } else {
+ entry.remove(successCallback, function(error) {
+ errorCallback(error.code);
+ });
+ }
+ }, function(error) {
+ errorCallback(error.code);
+ });
+ },
+
+ getParent: function(successCallback, errorCallback, args) {
+ var uri = args[0];
+
+ nativeResolveLocalFileSystemURI(uri, function(entry) {
+ entry.getParent(function(entry) {
+ successCallback(makeEntry(entry));
+ }, function(error) {
+ errorCallback(error.code);
+ });
+ }, function(error) {
+ errorCallback(error.code);
+ });
+ },
+
+ /* FileEntry */
+ getFileMetadata: function(successCallback, errorCallback, args) {
+ var uri = args[0];
+
+ nativeResolveLocalFileSystemURI(uri, function(entry) {
+ entry.file(function(file) {
+ var retVal = new File(file.name, decodeURI(entry.toURL()), file.type, file.lastModifiedDate, file.size);
+ successCallback(retVal);
+ }, function(error) {
+ errorCallback(error.code);
+ });
+ }, function(error) {
+ errorCallback(error.code);
+ });
+ },
+
+ /* DirectoryEntry */
+ getDirectory: function(successCallback, errorCallback, args) {
+ var uri = args[0],
+ path = args[1],
+ options = args[2];
+
+ nativeResolveLocalFileSystemURI(uri, function(entry) {
+ entry.getDirectory(path, options, function(entry) {
+ successCallback(makeEntry(entry));
+ }, function(error) {
+ if (error.code === FileError.INVALID_MODIFICATION_ERR) {
+ if (options.create) {
+ errorCallback(FileError.PATH_EXISTS_ERR);
+ } else {
+ errorCallback(FileError.ENCODING_ERR);
+ }
+ } else {
+ errorCallback(error.code);
+ }
+ });
+ }, function(error) {
+ errorCallback(error.code);
+ });
+ },
+
+ removeRecursively: function(successCallback, errorCallback, args) {
+ var uri = args[0];
+
+ nativeResolveLocalFileSystemURI(uri, function(entry) {
+ if (entry.fullPath === "/") {
+ errorCallback(FileError.NO_MODIFICATION_ALLOWED_ERR);
+ } else {
+ entry.removeRecursively(successCallback, function(error) {
+ errorCallback(error.code);
+ });
+ }
+ }, function(error) {
+ errorCallback(error.code);
+ });
+ },
+
+ getFile: function(successCallback, errorCallback, args) {
+ var uri = args[0],
+ path = args[1],
+ options = args[2];
+
+ nativeResolveLocalFileSystemURI(uri, function(entry) {
+ entry.getFile(path, options, function(entry) {
+ successCallback(makeEntry(entry));
+ }, function(error) {
+ if (error.code === FileError.INVALID_MODIFICATION_ERR) {
+ if (options.create) {
+ errorCallback(FileError.PATH_EXISTS_ERR);
+ } else {
+ errorCallback(FileError.ENCODING_ERR);
+ }
+ } else {
+ errorCallback(error.code);
+ }
+ });
+ }, function(error) {
+ errorCallback(error.code);
+ });
+ },
+
+ /* FileReader */
+ readAsText: function(successCallback, errorCallback, args) {
+ var uri = args[0],
+ encoding = args[1];
+
+ nativeResolveLocalFileSystemURI(uri, function(entry) {
+ var onLoadEnd = function(evt) {
+ if (!evt.target.error) {
+ successCallback(evt.target.result);
+ }
+ },
+ onError = function(evt) {
+ errorCallback(evt.target.error.code);
+ };
+
+ var reader = new NativeFileReader();
+
+ reader.onloadend = onLoadEnd;
+ reader.onerror = onError;
+ entry.file(function(file) {
+ reader.readAsText(file, encoding);
+ }, function(error) {
+ errorCallback(error.code);
+ });
+ }, function(error) {
+ errorCallback(error.code);
+ });
+ },
+
+ readAsDataURL: function(successCallback, errorCallback, args) {
+ var uri = args[0];
+
+ nativeResolveLocalFileSystemURI(uri, function(entry) {
+ var onLoadEnd = function(evt) {
+ if (!evt.target.error) {
+ successCallback(evt.target.result);
+ }
+ },
+ onError = function(evt) {
+ errorCallback(evt.target.error.code);
+ };
+
+ var reader = new NativeFileReader();
+
+ reader.onloadend = onLoadEnd;
+ reader.onerror = onError;
+ entry.file(function(file) {
+ reader.readAsDataURL(file);
+ }, function(error) {
+ errorCallback(error.code);
+ });
+ }, function(error) {
+ errorCallback(error.code);
+ });
+ },
+
+ /* FileWriter */
+ write: function(successCallback, errorCallback, args) {
+ var uri = args[0],
+ text = args[1],
+ position = args[2];
+
+ nativeResolveLocalFileSystemURI(uri, function(entry) {
+ var onWriteEnd = function(evt) {
+ if(!evt.target.error) {
+ successCallback(evt.target.position - position);
+ } else {
+ errorCallback(evt.target.error.code);
+ }
+ },
+ onError = function(evt) {
+ errorCallback(evt.target.error.code);
+ };
+
+ entry.createWriter(function(writer) {
+ var blob = new WebKitBlobBuilder();
+ blob.append(text);
+
+ writer.onwriteend = onWriteEnd;
+ writer.onerror = onError;
+
+ writer.seek(position);
+ writer.write(blob.getBlob('text/plain'));
+ }, function(error) {
+ errorCallback(error.code);
+ });
+ }, function(error) {
+ errorCallback(error.code);
+ });
+ },
+
+ truncate: function(successCallback, errorCallback, args) {
+ var uri = args[0],
+ size = args[1];
+
+ nativeResolveLocalFileSystemURI(uri, function(entry) {
+ var onWriteEnd = function(evt) {
+ if(!evt.target.error) {
+ successCallback(evt.target.length);
+ } else {
+ errorCallback(evt.target.error.code);
+ }
+ },
+ onError = function(evt) {
+ errorCallback(evt.target.error.code);
+ };
+
+ entry.createWriter(function(writer) {
+ writer.onwriteend = onWriteEnd;
+ writer.onerror = onError;
+
+ writer.truncate(size);
+ }, function(error) {
+ errorCallback(error.code);
+ });
+ }, function(error) {
+ errorCallback(error.code);
+ });
+ }
+};
+
+});
+
+// file: lib/tizen/plugin/tizen/FileTransfer.js
+define("cordova/plugin/tizen/FileTransfer", function(require, exports, module) {
+/*global WebKitBlobBuilder:false */
+var FileEntry = require('cordova/plugin/FileEntry'),
+ FileTransferError = require('cordova/plugin/FileTransferError'),
+ FileUploadResult = require('cordova/plugin/FileUploadResult');
+
+var nativeResolveLocalFileSystemURI = window.webkitResolveLocalFileSystemURL;
+
+function getParentPath(filePath) {
+ var pos = filePath.lastIndexOf('/');
+ return filePath.substring(0, pos + 1);
+}
+
+function getFileName(filePath) {
+ var pos = filePath.lastIndexOf('/');
+ return filePath.substring(pos + 1);
+}
+
+module.exports = {
+ upload: function(successCallback, errorCallback, args) {
+ 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];
+
+ nativeResolveLocalFileSystemURI(filePath, function(entry) {
+ entry.file(function(file) {
+ function uploadFile(blobFile) {
+ var fd = new FormData();
+
+ fd.append(fileKey, blobFile, fileName);
+ for (var prop in params) {
+ if(params.hasOwnProperty(prop)) {
+ fd.append(prop, params[prop]);
+ }
+ }
+
+ var xhr = new XMLHttpRequest();
+ xhr.open("POST", server);
+ xhr.onload = function(evt) {
+ if (xhr.status == 200) {
+ var result = new FileUploadResult();
+ result.bytesSent = file.size;
+ result.responseCode = xhr.status;
+ result.response = xhr.response;
+ successCallback(result);
+ } else if (xhr.status == 404) {
+ errorCallback(new FileTransferError(FileTransferError.INVALID_URL_ERR));
+ } else {
+ errorCallback(new FileTransferError(FileTransferError.CONNECTION_ERR));
+ }
+ };
+ xhr.ontimeout = function(evt) {
+ errorCallback(new FileTransferError(FileTransferError.CONNECTION_ERR));
+ };
+
+ xhr.send(fd);
+ }
+
+ var bytesPerChunk;
+ if (chunkedMode === true) {
+ bytesPerChunk = 1024 * 1024; // 1MB chunk sizes.
+ } else {
+ bytesPerChunk = file.size;
+ }
+ var start = 0;
+ var end = bytesPerChunk;
+ while (start < file.size) {
+ var chunk = file.webkitSlice(start, end, mimeType);
+ uploadFile(chunk);
+ start = end;
+ end = start + bytesPerChunk;
+ }
+ },
+ function(error) {
+ errorCallback(new FileTransferError(FileTransferError.FILE_NOT_FOUND_ERR));
+ }
+ );
+ },
+ function(error) {
+ errorCallback(new FileTransferError(FileTransferError.FILE_NOT_FOUND_ERR));
+ }
+ );
+ },
+
+ download: function(successCallback, errorCallback, args) {
+ var url = args[0],
+ filePath = args[1];
+
+ var xhr = new XMLHttpRequest();
+
+ function writeFile(fileEntry) {
+ fileEntry.createWriter(function(writer) {
+ writer.onwriteend = function(evt) {
+ if (!evt.target.error) {
+ successCallback(new FileEntry(fileEntry.name, fileEntry.toURL()));
+ } else {
+ errorCallback(new FileTransferError(FileTransferError.FILE_NOT_FOUND_ERR));
+ }
+ };
+
+ writer.onerror = function(evt) {
+ errorCallback(new FileTransferError(FileTransferError.FILE_NOT_FOUND_ERR));
+ };
+
+ var builder = new WebKitBlobBuilder();
+ builder.append(xhr.response);
+ var blob = builder.getBlob();
+ writer.write(blob);
+ },
+ function(error) {
+ errorCallback(new FileTransferError(FileTransferError.FILE_NOT_FOUND_ERR));
+ });
+ }
+
+ xhr.onreadystatechange = function () {
+ if (xhr.readyState == xhr.DONE) {
+ if (xhr.status == 200 && xhr.response) {
+ nativeResolveLocalFileSystemURI(getParentPath(filePath), function(dir) {
+ dir.getFile(getFileName(filePath), {create: true}, writeFile, function(error) {
+ errorCallback(new FileTransferError(FileTransferError.FILE_NOT_FOUND_ERR));
+ });
+ }, function(error) {
+ errorCallback(new FileTransferError(FileTransferError.FILE_NOT_FOUND_ERR));
+ });
+ } else if (xhr.status == 404) {
+ errorCallback(new FileTransferError(FileTransferError.INVALID_URL_ERR));
+ } else {
+ errorCallback(new FileTransferError(FileTransferError.CONNECTION_ERR));
+ }
+ }
+ };
+
+ xhr.open("GET", url, true);
+ xhr.responseType = "arraybuffer";
+ xhr.send();
+ }
+};
+
+});
+
+// file: lib/tizen/plugin/tizen/Media.js
+define("cordova/plugin/tizen/Media", function(require, exports, module) {
+/*global Media:false, webkitURL:false */
+var MediaError = require('cordova/plugin/MediaError'),
+ audioObjects = {};
+
+module.exports = {
+ create: function (successCallback, errorCallback, args) {
+ var id = args[0], src = args[1];
+ console.log("media::create() - id =" + id + ", src =" + src);
+ audioObjects[id] = new Audio(src);
+ audioObjects[id].onStalledCB = function () {
+ console.log("media::onStalled()");
+ audioObjects[id].timer = window.setTimeout(function () {
+ audioObjects[id].pause();
+ if (audioObjects[id].currentTime !== 0)
+ audioObjects[id].currentTime = 0;
+ console.log("media::onStalled() - MEDIA_ERROR -> " + MediaError.MEDIA_ERR_ABORTED);
+ var err = new MediaError(MediaError.MEDIA_ERR_ABORTED, "Stalled");
+ Media.onStatus(id, Media.MEDIA_ERROR, err);
+ }, 2000);
+ };
+ audioObjects[id].onEndedCB = function () {
+ console.log("media::onEndedCB() - MEDIA_STATE -> MEDIA_STOPPED");
+ Media.onStatus(id, Media.MEDIA_STATE, Media.MEDIA_STOPPED);
+ };
+ audioObjects[id].onErrorCB = function () {
+ console.log("media::onErrorCB() - MEDIA_ERROR -> " + event.srcElement.error);
+ Media.onStatus(id, Media.MEDIA_ERROR, event.srcElement.error);
+ };
+ audioObjects[id].onPlayCB = function () {
+ console.log("media::onPlayCB() - MEDIA_STATE -> MEDIA_STARTING");
+ Media.onStatus(id, Media.MEDIA_STATE, Media.MEDIA_STARTING);
+ };
+ audioObjects[id].onPlayingCB = function () {
+ console.log("media::onPlayingCB() - MEDIA_STATE -> MEDIA_RUNNING");
+ Media.onStatus(id, Media.MEDIA_STATE, Media.MEDIA_RUNNING);
+ };
+ audioObjects[id].onDurationChangeCB = function () {
+ console.log("media::onDurationChangeCB() - MEDIA_DURATION -> " + audioObjects[id].duration);
+ Media.onStatus(id, Media.MEDIA_DURATION, audioObjects[id].duration);
+ };
+ audioObjects[id].onTimeUpdateCB = function () {
+ console.log("media::onTimeUpdateCB() - MEDIA_POSITION -> " + audioObjects[id].currentTime);
+ Media.onStatus(id, Media.MEDIA_POSITION, audioObjects[id].currentTime);
+ };
+ audioObjects[id].onCanPlayCB = function () {
+ console.log("media::onCanPlayCB()");
+ window.clearTimeout(audioObjects[id].timer);
+ audioObjects[id].play();
+ };
+ },
+ startPlayingAudio: function (successCallback, errorCallback, args) {
+ var id = args[0], src = args[1], options = args[2];
+ console.log("media::startPlayingAudio() - id =" + id + ", src =" + src + ", options =" + options);
+ audioObjects[id].addEventListener('canplay', audioObjects[id].onCanPlayCB);
+ audioObjects[id].addEventListener('ended', audioObjects[id].onEndedCB);
+ audioObjects[id].addEventListener('timeupdate', audioObjects[id].onTimeUpdateCB);
+ audioObjects[id].addEventListener('durationchange', audioObjects[id].onDurationChangeCB);
+ audioObjects[id].addEventListener('playing', audioObjects[id].onPlayingCB);
+ audioObjects[id].addEventListener('play', audioObjects[id].onPlayCB);
+ audioObjects[id].addEventListener('error', audioObjects[id].onErrorCB);
+ audioObjects[id].addEventListener('stalled', audioObjects[id].onStalledCB);
+ audioObjects[id].play();
+ },
+ stopPlayingAudio: function (successCallback, errorCallback, args) {
+ var id = args[0];
+ window.clearTimeout(audioObjects[id].timer);
+ audioObjects[id].pause();
+ if (audioObjects[id].currentTime !== 0)
+ audioObjects[id].currentTime = 0;
+ console.log("media::stopPlayingAudio() - MEDIA_STATE -> MEDIA_STOPPED");
+ Media.onStatus(id, Media.MEDIA_STATE, Media.MEDIA_STOPPED);
+ audioObjects[id].removeEventListener('canplay', audioObjects[id].onCanPlayCB);
+ audioObjects[id].removeEventListener('ended', audioObjects[id].onEndedCB);
+ audioObjects[id].removeEventListener('timeupdate', audioObjects[id].onTimeUpdateCB);
+ audioObjects[id].removeEventListener('durationchange', audioObjects[id].onDurationChangeCB);
+ audioObjects[id].removeEventListener('playing', audioObjects[id].onPlayingCB);
+ audioObjects[id].removeEventListener('play', audioObjects[id].onPlayCB);
+ audioObjects[id].removeEventListener('error', audioObjects[id].onErrorCB);
+ audioObjects[id].removeEventListener('error', audioObjects[id].onStalledCB);
+ },
+ seekToAudio: function (successCallback, errorCallback, args) {
+ var id = args[0], milliseconds = args[1];
+ console.log("media::seekToAudio()");
+ audioObjects[id].currentTime = milliseconds;
+ successCallback( audioObjects[id].currentTime);
+ },
+ pausePlayingAudio: function (successCallback, errorCallback, args) {
+ var id = args[0];
+ console.log("media::pausePlayingAudio() - MEDIA_STATE -> MEDIA_PAUSED");
+ audioObjects[id].pause();
+ Media.onStatus(id, Media.MEDIA_STATE, Media.MEDIA_PAUSED);
+ },
+ getCurrentPositionAudio: function (successCallback, errorCallback, args) {
+ var id = args[0];
+ console.log("media::getCurrentPositionAudio()");
+ successCallback(audioObjects[id].currentTime);
+ },
+ release: function (successCallback, errorCallback, args) {
+ var id = args[0];
+ window.clearTimeout(audioObjects[id].timer);
+ console.log("media::release()");
+ },
+ setVolume: function (successCallback, errorCallback, args) {
+ var id = args[0], volume = args[1];
+ console.log("media::setVolume()");
+ audioObjects[id].volume = volume;
+ },
+ startRecordingAudio: function (successCallback, errorCallback, args) {
+ var id = args[0], src = args[1];
+ console.log("media::startRecordingAudio() - id =" + id + ", src =" + src);
+
+ function gotStreamCB(stream) {
+ audioObjects[id].src = webkitURL.createObjectURL(stream);
+ console.log("media::startRecordingAudio() - stream CB");
+ }
+
+ function gotStreamFailedCB(error) {
+ console.log("media::startRecordingAudio() - error CB:" + error.toString());
+ }
+
+ if (navigator.webkitGetUserMedia) {
+ audioObjects[id] = new Audio();
+ navigator.webkitGetUserMedia('audio', gotStreamCB, gotStreamFailedCB);
+ } else {
+ console.log("webkitGetUserMedia not supported");
+ }
+ successCallback();
+ },
+ stopRecordingAudio: function (successCallback, errorCallback, args) {
+ var id = args[0];
+ console.log("media::stopRecordingAudio() - id =" + id);
+ audioObjects[id].pause();
+ successCallback();
+ }
+};
+
+});
+
+// file: lib/tizen/plugin/tizen/MediaError.js
+define("cordova/plugin/tizen/MediaError", function(require, exports, module) {
+
+// The MediaError object already exists on Tizen. This prevents the Cordova
+// version from being defined. This object is used to merge in differences
+// between Tizen and Cordova MediaError objects.
+module.exports = {
+ MEDIA_ERR_NONE_ACTIVE : 0,
+ MEDIA_ERR_NONE_SUPPORTED : 4
+};
+});
+
+// file: lib/tizen/plugin/tizen/NetworkStatus.js
+define("cordova/plugin/tizen/NetworkStatus", function(require, exports, module) {
+/*global tizen:false */
+var Connection = require('cordova/plugin/Connection');
+
+module.exports = {
+ getConnectionInfo: function (successCallback, errorCallback) {
+ var cncType = Connection.NONE;
+ var infoCount = 0;
+
+ function infoCB() {
+ infoCount++;
+ if (infoCount > 1)
+ successCallback(cncType);
+ }
+
+ function errorCB(error) {
+ console.log("Error: " + error.code + "," + error.name + "," + error.message);
+ infoCB();
+ }
+
+ function wifiSuccessCB(wifi) {
+ if ((wifi.status === "ON") && (wifi.ipAddress.length !== 0))
+ cncType = Connection.WIFI;
+ infoCB();
+ }
+
+ function cellularSuccessCB(cell) {
+ if ((cncType === Connection.NONE) && (cell.status === "ON") && (cell.ipAddress.length !== 0))
+ cncType = Connection.CELL_2G;
+ infoCB();
+ }
+
+ if (tizen.systeminfo.isSupported('WifiNetwork')) {
+ tizen.systeminfo.getPropertyValue('WifiNetwork', wifiSuccessCB, errorCB);
+ }
+
+ if (tizen.systeminfo.isSupported('CellularNetwork')) {
+ tizen.systeminfo.getPropertyValue('CellularNetwork', cellularSuccessCB, errorCB);
+ }
+ }
+};
+
+});
+
+// file: lib/tizen/plugin/tizen/Notification.js
+define("cordova/plugin/tizen/Notification", function(require, exports, module) {
+var SoundBeat = require('cordova/plugin/tizen/SoundBeat');
+
+/* TODO: get resource path from app environment? */
+var soundBeat = new SoundBeat(["./sounds/beep.wav"]);
+
+module.exports = {
+
+ alert: function(message, alertCallback, title, buttonName) {
+ return this.confirm(message, alertCallback, title, buttonName);
+ },
+
+ confirm: function(message, confirmCallback, title, buttonLabels) {
+ var index = null,
+ overlayElement = null,
+ popup = null,
+ element = null,
+ titleString = null,
+ messageString = null,
+ buttonString = null,
+ buttonsArray = null;
+
+
+ console.log ("message" , message);
+ console.log ("confirmCallback" , confirmCallback);
+ console.log ("title" , title);
+ console.log ("buttonLabels" , buttonLabels);
+
+ titleString = '<div class="popup-title"><p>' + title + '</p></div>';
+ messageString = '<div class="popup-text"><p>' + message + '</p></div>';
+ buttonString = '<div class="popup-button-bg"><ul>';
+
+ switch(typeof(buttonLabels))
+ {
+ case "string":
+ buttonsArray = buttonLabels.split(",");
+
+ if (buttonsArray === null) {
+ buttonsArray = buttonLabels;
+ }
+
+ for (index in buttonsArray) {
+ buttonString += '<li><input id="popup-button-' + buttonsArray[index]+
+ '" type="button" value="' + buttonsArray[index] + '" /></li>';
+ console.log ("index: ", index,"");
+ console.log ("buttonsArray[index]: ", buttonsArray[index]);
+ console.log ("buttonString: ", buttonString);
+ }
+ break;
+
+ case "array":
+ if (buttonsArray === null) {
+ buttonsArray = buttonLabels;
+ }
+
+ for (index in buttonsArray) {
+ buttonString += '<li><input id="popup-button-' + buttonsArray[index]+
+ '" type="button" value="' + buttonsArray[index] + '" /></li>';
+ console.log ("index: ", index,"");
+ console.log ("buttonsArray[index]: ", buttonsArray[index]);
+ console.log ("buttonString: ", buttonString);
+ }
+ break;
+ default:
+ console.log ("cordova/plugin/tizen/Notification, default, buttonLabels: ", buttonLabels);
+ break;
+ }
+
+ buttonString += '</ul></div>';
+
+ overlayElement = document.createElement("div");
+ overlayElement.className = 'ui-popupwindow-screen';
+
+ overlayElement.style.zIndex = 1001;
+ overlayElement.style.width = "100%";
+ overlayElement.style.height = "100%";
+ overlayElement.style.top = 0;
+ overlayElement.style.left = 0;
+ overlayElement.style.margin = 0;
+ overlayElement.style.padding = 0;
+ overlayElement.style.position = "absolute";
+
+ popup = document.createElement("div");
+ popup.className = "ui-popupwindow";
+ popup.style.position = "fixed";
+ popup.style.zIndex = 1002;
+ popup.innerHTML = titleString + messageString + buttonString;
+
+ document.body.appendChild(overlayElement);
+ document.body.appendChild(popup);
+
+ function createListener(button) {
+ return function() {
+ document.body.removeChild(overlayElement);
+ document.body.removeChild(popup);
+ confirmCallback(button.value);
+ };
+ }
+
+ for (index in buttonsArray) {
+ console.log ("index: ", index);
+
+ element = document.getElementById("popup-button-" + buttonsArray[index]);
+ element.addEventListener("click", createListener(element), false);
+ }
+ },
+
+ vibrate: function(milliseconds) {
+ console.log ("milliseconds" , milliseconds);
+
+ if (navigator.vibrate) {
+ navigator.vibrate(milliseconds);
+ }
+ else {
+ console.log ("cordova/plugin/tizen/Notification, vibrate API does not exist");
+ }
+ },
+
+ beep: function(count) {
+ console.log ("count" , count);
+ soundBeat.play(count);
+ }
+};
+
+
+
+});
+
+// file: lib/tizen/plugin/tizen/SoundBeat.js
+define("cordova/plugin/tizen/SoundBeat", function(require, exports, module) {
+/*global webkitAudioContext:false */
+/*
+ * SoundBeat
+ * used by Notification Manager beep method
+ *
+ * This class provides sounds play
+ *
+ * uses W3C Web Audio API
+ * uses BufferLoader object
+ *
+ * NOTE: the W3C Web Audio doc tells we do not need to recreate the audio
+ * context to play a sound but only the audiosourcenode (createBufferSource)
+ * in the webkit implementation we have to.
+ *
+ */
+
+var BufferLoader = require('cordova/plugin/tizen/BufferLoader');
+
+function SoundBeat(urlList) {
+ this.context = null;
+ this.urlList = urlList || null;
+ this.buffers = null;
+}
+
+/*
+ * This method play a loaded sounds on the Device
+ * @param {Number} times Number of times to play loaded sounds.
+ *
+ */
+SoundBeat.prototype.play = function(times) {
+
+ var i = 0, sources = [], that = this;
+
+ function finishedLoading (bufferList) {
+ that.buffers = bufferList;
+
+ for (i = 0; i < that.buffers.length ; i +=1) {
+ if (that.context) {
+ sources[i] = that.context.createBufferSource();
+
+ sources[i].buffer = that.buffers[i];
+ sources[i].connect (that.context.destination);
+
+ sources[i].loop = true;
+ sources[i].noteOn (0);
+ sources[i].noteOff(sources[i].buffer.duration * times);
+ }
+ }
+ }
+
+ if (webkitAudioContext !== null) {
+ this.context = new webkitAudioContext();
+ }
+ else {
+ console.log ("SoundBeat.prototype.play, w3c web audio api not supported");
+ this.context = null;
+ }
+
+ if (this.context === null) {
+ console.log ("SoundBeat.prototype.play, cannot create audio context object");
+ return;
+ }
+
+ this.bufferLoader = new BufferLoader (this.context, this.urlList, finishedLoading);
+ if (this.bufferLoader === null) {
+ console.log ("SoundBeat.prototype.play, cannot create buffer loader object");
+ return;
+ }
+
+ this.bufferLoader.load();
+};
+
+module.exports = SoundBeat;
+
+});
+
+// file: lib/tizen/plugin/tizen/contacts.js
+define("cordova/plugin/tizen/contacts", function(require, exports, module) {
+/*global tizen:false */
+var ContactError = require('cordova/plugin/ContactError'),
+ utils = require('cordova/utils'),
+ ContactUtils = require('cordova/plugin/tizen/ContactUtils');
+
+module.exports = {
+ /**
+ * Returns an array of Contacts matching the search criteria.
+ *
+ * @return array of Contacts matching search criteria
+ */
+ find : function(fields, successCB, failCB, options) {
+
+ // Success callback is required. Throw exception if not specified.
+ if (typeof successCB !== 'function') {
+ throw new TypeError("You must specify a success callback for the find command.");
+ }
+
+ // Search qualifier is required and cannot be empty.
+ if (!fields || !(utils.isArray(fields)) || fields.length === 0) {
+ if (typeof failCB === 'function') {
+ failCB(new ContactError(ContactError.INVALID_ARGUMENT_ERROR));
+ }
+ return;
+ }
+
+ // options are optional
+ var filter ="",
+ multiple = false,
+ contacts = [],
+ tizenFilter = null;
+
+ if (options) {
+ filter = options.filter || "";
+ multiple = options.multiple || false;
+ }
+
+ if (filter){
+ tizenFilter = ContactUtils.buildFilterExpression(fields, filter);
+ }
+
+ tizen.contact.getDefaultAddressBook().find(
+ function(tizenContacts) {
+ if (multiple) {
+ for (var index in tizenContacts) {
+ contacts.push(ContactUtils.createContact(tizenContacts[index], fields));
+ }
+ }
+ else {
+ contacts.push(ContactUtils.createContact(tizenContacts[0], fields));
+ }
+
+ // return results
+ successCB(contacts);
+ },
+ function(error) {
+ if (typeof failCB === 'function') {
+ failCB(ContactError.UNKNOWN_ERROR);
+ }
+ },
+ tizenFilter,
+ null);
+ }
+};
+
+});
+
+// file: lib/tizen/plugin/tizen/manager.js
+define("cordova/plugin/tizen/manager", function(require, exports, module) {
+var cordova = require('cordova');
+
+module.exports = {
+ exec: function (successCallback, errorCallback, clazz, action, args) {
+ var plugin = require('cordova/plugin/tizen/' + clazz);
+
+ if (plugin && typeof plugin[action] === 'function') {
+ var result = plugin[action](successCallback, errorCallback, args);
+ return result || {status: cordova.callbackStatus.NO_RESULT};
+ }
+
+ return {"status" : cordova.callbackStatus.CLASS_NOT_FOUND_EXCEPTION, "message" : "Function " + clazz + "::" + action + " cannot be found"};
+ },
+ resume: function () {},
+ pause: function () {},
+ destroy: function () {}
+};
+
+});
+
+// file: lib/common/utils.js
+define("cordova/utils", function(require, exports, module) {
+var utils = exports;
+
+/**
+ * Returns an indication of whether the argument is an array or not
+ */
+utils.isArray = function(a) {
+ return Object.prototype.toString.call(a) == '[object Array]';
+};
+
+/**
+ * Returns an indication of whether the argument is a Date or not
+ */
+utils.isDate = function(d) {
+ return Object.prototype.toString.call(d) == '[object Date]';
+};
+
+/**
+ * Does a deep clone of the object.
+ */
+utils.clone = function(obj) {
+ if(!obj || typeof obj == 'function' || utils.isDate(obj) || typeof obj != 'object') {
+ return obj;
+ }
+
+ var retVal, i;
+
+ if(utils.isArray(obj)){
+ retVal = [];
+ for(i = 0; i < obj.length; ++i){
+ retVal.push(utils.clone(obj[i]));
+ }
+ return retVal;
+ }
+
+ retVal = {};
+ for(i in obj){
+ if(!(i in retVal) || retVal[i] != obj[i]) {
+ retVal[i] = utils.clone(obj[i]);
+ }
+ }
+ return retVal;
+};
+
+/**
+ * Returns a wrappered version of the function
+ */
+utils.close = function(context, func, params) {
+ if (typeof params == 'undefined') {
+ return function() {
+ return func.apply(context, arguments);
+ };
+ } else {
+ return function() {
+ return func.apply(context, params);
+ };
+ }
+};
+
+/**
+ * Create a UUID
+ */
+utils.createUUID = function() {
+ return UUIDcreatePart(4) + '-' +
+ UUIDcreatePart(2) + '-' +
+ UUIDcreatePart(2) + '-' +
+ UUIDcreatePart(2) + '-' +
+ UUIDcreatePart(6);
+};
+
+/**
+ * Extends a child object from a parent object using classical inheritance
+ * pattern.
+ */
+utils.extend = (function() {
+ // proxy used to establish prototype chain
+ var F = function() {};
+ // extend Child from Parent
+ return function(Child, Parent) {
+ F.prototype = Parent.prototype;
+ Child.prototype = new F();
+ Child.__super__ = Parent.prototype;
+ Child.prototype.constructor = Child;
+ };
+}());
+
+/**
+ * Alerts a message in any available way: alert or console.log.
+ */
+utils.alert = function(msg) {
+ if (alert) {
+ alert(msg);
+ } else if (console && console.log) {
+ console.log(msg);
+ }
+};
+
+/**
+ * Formats a string and arguments following it ala sprintf()
+ *
+ * see utils.vformat() for more information
+ */
+utils.format = function(formatString /* ,... */) {
+ var args = [].slice.call(arguments, 1);
+ return utils.vformat(formatString, args);
+};
+
+/**
+ * Formats a string and arguments following it ala vsprintf()
+ *
+ * format chars:
+ * %j - format arg as JSON
+ * %o - format arg as JSON
+ * %c - format arg as ''
+ * %% - replace with '%'
+ * any other char following % will format it's
+ * arg via toString().
+ *
+ * for rationale, see FireBug's Console API:
+ * http://getfirebug.com/wiki/index.php/Console_API
+ */
+utils.vformat = function(formatString, args) {
+ if (formatString === null || formatString === undefined) return "";
+ if (arguments.length == 1) return formatString.toString();
+ if (typeof formatString != "string") return formatString.toString();
+
+ var pattern = /(.*?)%(.)(.*)/;
+ var rest = formatString;
+ var result = [];
+
+ while (args.length) {
+ var arg = args.shift();
+ var match = pattern.exec(rest);
+
+ if (!match) break;
+
+ rest = match[3];
+
+ result.push(match[1]);
+
+ if (match[2] == '%') {
+ result.push('%');
+ args.unshift(arg);
+ continue;
+ }
+
+ result.push(formatted(arg, match[2]));
+ }
+
+ result.push(rest);
+
+ return result.join('');
+};
+
+//------------------------------------------------------------------------------
+function UUIDcreatePart(length) {
+ var uuidpart = "";
+ for (var i=0; i<length; i++) {
+ var uuidchar = parseInt((Math.random() * 256), 10).toString(16);
+ if (uuidchar.length == 1) {
+ uuidchar = "0" + uuidchar;
+ }
+ uuidpart += uuidchar;
+ }
+ return uuidpart;
+}
+
+//------------------------------------------------------------------------------
+function formatted(object, formatChar) {
+
+ try {
+ switch(formatChar) {
+ case 'j':
+ case 'o': return JSON.stringify(object);
+ case 'c': return '';
+ }
+ }
+ catch (e) {
+ return "error JSON.stringify()ing argument: " + e;
+ }
+
+ if ((object === null) || (object === undefined)) {
+ return Object.prototype.toString.call(object);
+ }
+
+ return object.toString();
+}
+
+});
+
+
+window.cordova = require('cordova');
+
+// file: lib/scripts/bootstrap.js
+(function (context) {
+ var channel = require("cordova/channel"),
+ _self = {
+ boot: function () {
+ /**
+ * Create all cordova objects once page has fully loaded and native side is ready.
+ */
+ channel.join(function() {
+ var builder = require('cordova/builder'),
+ base = require('cordova/common'),
+ platform = require('cordova/platform');
+
+ // Drop the common globals into the window object, but be nice and don't overwrite anything.
+ builder.build(base.objects).intoButDontClobber(window);
+
+ // Drop the platform-specific globals into the window object
+ // and clobber any existing object.
+ builder.build(platform.objects).intoAndClobber(window);
+
+ // Merge the platform-specific overrides/enhancements into
+ // the window object.
+ if (typeof platform.merges !== 'undefined') {
+ builder.build(platform.merges).intoAndMerge(window);
+ }
+
+ // Call the platform-specific initialization
+ platform.initialize();
+
+ // Fire event to notify that all objects are created
+ channel.onCordovaReady.fire();
+
+ // Fire onDeviceReady event once all constructors have run and
+ // cordova info has been received from native side.
+ channel.join(function() {
+ require('cordova').fireDocumentEvent('deviceready');
+ }, channel.deviceReadyChannelsArray);
+
+ }, [ channel.onDOMContentLoaded, channel.onNativeReady ]);
+ }
+ };
+
+ // boot up once native side is ready
+ channel.onNativeReady.subscribeOnce(_self.boot);
+
+ // _nativeReady is global variable that the native side can set
+ // to signify that the native code is ready. It is a global since
+ // it may be called before any cordova JS is ready.
+ if (window._nativeReady) {
+ channel.onNativeReady.fire();
+ }
+
+}(window));
+
+// file: lib/scripts/bootstrap-tizen.js
+require('cordova/channel').onNativeReady.fire();
+
+
+})();
\ No newline at end of file
diff --git a/samples/hello-cordova/res/icon/android/icon-36-ldpi.png b/samples/hello-cordova/res/icon/android/icon-36-ldpi.png
deleted file mode 100644
index cd5032a..0000000
--- a/samples/hello-cordova/res/icon/android/icon-36-ldpi.png
+++ /dev/null
Binary files differ
diff --git a/samples/hello-cordova/res/icon/android/icon-48-mdpi.png b/samples/hello-cordova/res/icon/android/icon-48-mdpi.png
deleted file mode 100644
index e79c606..0000000
--- a/samples/hello-cordova/res/icon/android/icon-48-mdpi.png
+++ /dev/null
Binary files differ
diff --git a/samples/hello-cordova/res/icon/android/icon-72-hdpi.png b/samples/hello-cordova/res/icon/android/icon-72-hdpi.png
deleted file mode 100644
index 4d27634..0000000
--- a/samples/hello-cordova/res/icon/android/icon-72-hdpi.png
+++ /dev/null
Binary files differ
diff --git a/samples/hello-cordova/res/icon/android/icon-96-xhdpi.png b/samples/hello-cordova/res/icon/android/icon-96-xhdpi.png
deleted file mode 100644
index ec7ffbf..0000000
--- a/samples/hello-cordova/res/icon/android/icon-96-xhdpi.png
+++ /dev/null
Binary files differ
diff --git a/samples/hello-cordova/res/icon/bada-wac/icon-48-type5.png b/samples/hello-cordova/res/icon/bada-wac/icon-48-type5.png
deleted file mode 100644
index 8ad8bac..0000000
--- a/samples/hello-cordova/res/icon/bada-wac/icon-48-type5.png
+++ /dev/null
Binary files differ
diff --git a/samples/hello-cordova/res/icon/bada-wac/icon-50-type3.png b/samples/hello-cordova/res/icon/bada-wac/icon-50-type3.png
deleted file mode 100644
index c6ddf84..0000000
--- a/samples/hello-cordova/res/icon/bada-wac/icon-50-type3.png
+++ /dev/null
Binary files differ
diff --git a/samples/hello-cordova/res/icon/bada-wac/icon-80-type4.png b/samples/hello-cordova/res/icon/bada-wac/icon-80-type4.png
deleted file mode 100644
index f86a27a..0000000
--- a/samples/hello-cordova/res/icon/bada-wac/icon-80-type4.png
+++ /dev/null
Binary files differ
diff --git a/samples/hello-cordova/res/icon/bada/icon-128.png b/samples/hello-cordova/res/icon/bada/icon-128.png
deleted file mode 100644
index 3516df3..0000000
--- a/samples/hello-cordova/res/icon/bada/icon-128.png
+++ /dev/null
Binary files differ
diff --git a/samples/hello-cordova/res/icon/blackberry/icon-80.png b/samples/hello-cordova/res/icon/blackberry/icon-80.png
deleted file mode 100644
index f86a27a..0000000
--- a/samples/hello-cordova/res/icon/blackberry/icon-80.png
+++ /dev/null
Binary files differ
diff --git a/samples/hello-cordova/res/icon/ios/icon-57-2x.png b/samples/hello-cordova/res/icon/ios/icon-57-2x.png
deleted file mode 100644
index efd9c37..0000000
--- a/samples/hello-cordova/res/icon/ios/icon-57-2x.png
+++ /dev/null
Binary files differ
diff --git a/samples/hello-cordova/res/icon/ios/icon-57.png b/samples/hello-cordova/res/icon/ios/icon-57.png
deleted file mode 100644
index c795fc4..0000000
--- a/samples/hello-cordova/res/icon/ios/icon-57.png
+++ /dev/null
Binary files differ
diff --git a/samples/hello-cordova/res/icon/ios/icon-72-2x.png b/samples/hello-cordova/res/icon/ios/icon-72-2x.png
deleted file mode 100644
index dd819da..0000000
--- a/samples/hello-cordova/res/icon/ios/icon-72-2x.png
+++ /dev/null
Binary files differ
diff --git a/samples/hello-cordova/res/icon/ios/icon-72.png b/samples/hello-cordova/res/icon/ios/icon-72.png
deleted file mode 100644
index b1cfde7..0000000
--- a/samples/hello-cordova/res/icon/ios/icon-72.png
+++ /dev/null
Binary files differ
diff --git a/samples/hello-cordova/res/icon/webos/icon-64.png b/samples/hello-cordova/res/icon/webos/icon-64.png
deleted file mode 100644
index 03b3849..0000000
--- a/samples/hello-cordova/res/icon/webos/icon-64.png
+++ /dev/null
Binary files differ
diff --git a/samples/hello-cordova/res/icon/windows-phone/icon-173-tile.png b/samples/hello-cordova/res/icon/windows-phone/icon-173-tile.png
deleted file mode 100644
index 4f15e20..0000000
--- a/samples/hello-cordova/res/icon/windows-phone/icon-173-tile.png
+++ /dev/null
Binary files differ
diff --git a/samples/hello-cordova/res/icon/windows-phone/icon-48.png b/samples/hello-cordova/res/icon/windows-phone/icon-48.png
deleted file mode 100644
index 8ad8bac..0000000
--- a/samples/hello-cordova/res/icon/windows-phone/icon-48.png
+++ /dev/null
Binary files differ
diff --git a/samples/hello-cordova/res/icon/windows-phone/icon-62-tile.png b/samples/hello-cordova/res/icon/windows-phone/icon-62-tile.png
deleted file mode 100644
index aab6061..0000000
--- a/samples/hello-cordova/res/icon/windows-phone/icon-62-tile.png
+++ /dev/null
Binary files differ
diff --git a/samples/hello-cordova/res/screen/android/screen-hdpi-landscape.png b/samples/hello-cordova/res/screen/android/screen-hdpi-landscape.png
deleted file mode 100644
index a61e2b1..0000000
--- a/samples/hello-cordova/res/screen/android/screen-hdpi-landscape.png
+++ /dev/null
Binary files differ
diff --git a/samples/hello-cordova/res/screen/android/screen-hdpi-portrait.png b/samples/hello-cordova/res/screen/android/screen-hdpi-portrait.png
deleted file mode 100644
index 5d6a28a..0000000
--- a/samples/hello-cordova/res/screen/android/screen-hdpi-portrait.png
+++ /dev/null
Binary files differ
diff --git a/samples/hello-cordova/res/screen/android/screen-ldpi-landscape.png b/samples/hello-cordova/res/screen/android/screen-ldpi-landscape.png
deleted file mode 100644
index f3934cd..0000000
--- a/samples/hello-cordova/res/screen/android/screen-ldpi-landscape.png
+++ /dev/null
Binary files differ
diff --git a/samples/hello-cordova/res/screen/android/screen-ldpi-portrait.png b/samples/hello-cordova/res/screen/android/screen-ldpi-portrait.png
deleted file mode 100644
index 65ad163..0000000
--- a/samples/hello-cordova/res/screen/android/screen-ldpi-portrait.png
+++ /dev/null
Binary files differ
diff --git a/samples/hello-cordova/res/screen/android/screen-mdpi-landscape.png b/samples/hello-cordova/res/screen/android/screen-mdpi-landscape.png
deleted file mode 100644
index a1b697c..0000000
--- a/samples/hello-cordova/res/screen/android/screen-mdpi-landscape.png
+++ /dev/null
Binary files differ
diff --git a/samples/hello-cordova/res/screen/android/screen-mdpi-portrait.png b/samples/hello-cordova/res/screen/android/screen-mdpi-portrait.png
deleted file mode 100644
index ea15693..0000000
--- a/samples/hello-cordova/res/screen/android/screen-mdpi-portrait.png
+++ /dev/null
Binary files differ
diff --git a/samples/hello-cordova/res/screen/android/screen-xhdpi-landscape.png b/samples/hello-cordova/res/screen/android/screen-xhdpi-landscape.png
deleted file mode 100644
index 79f2f09..0000000
--- a/samples/hello-cordova/res/screen/android/screen-xhdpi-landscape.png
+++ /dev/null
Binary files differ
diff --git a/samples/hello-cordova/res/screen/android/screen-xhdpi-portrait.png b/samples/hello-cordova/res/screen/android/screen-xhdpi-portrait.png
deleted file mode 100644
index c2e8042..0000000
--- a/samples/hello-cordova/res/screen/android/screen-xhdpi-portrait.png
+++ /dev/null
Binary files differ
diff --git a/samples/hello-cordova/res/screen/bada-wac/screen-type3.png b/samples/hello-cordova/res/screen/bada-wac/screen-type3.png
deleted file mode 100755
index ea15693..0000000
--- a/samples/hello-cordova/res/screen/bada-wac/screen-type3.png
+++ /dev/null
Binary files differ
diff --git a/samples/hello-cordova/res/screen/bada-wac/screen-type4.png b/samples/hello-cordova/res/screen/bada-wac/screen-type4.png
deleted file mode 100755
index 5d6a28a..0000000
--- a/samples/hello-cordova/res/screen/bada-wac/screen-type4.png
+++ /dev/null
Binary files differ
diff --git a/samples/hello-cordova/res/screen/bada-wac/screen-type5.png b/samples/hello-cordova/res/screen/bada-wac/screen-type5.png
deleted file mode 100755
index bd64f76..0000000
--- a/samples/hello-cordova/res/screen/bada-wac/screen-type5.png
+++ /dev/null
Binary files differ
diff --git a/samples/hello-cordova/res/screen/bada/screen-portrait.png b/samples/hello-cordova/res/screen/bada/screen-portrait.png
deleted file mode 100644
index 5d6a28a..0000000
--- a/samples/hello-cordova/res/screen/bada/screen-portrait.png
+++ /dev/null
Binary files differ
diff --git a/samples/hello-cordova/res/screen/blackberry/screen-225.png b/samples/hello-cordova/res/screen/blackberry/screen-225.png
deleted file mode 100644
index 29873e9..0000000
--- a/samples/hello-cordova/res/screen/blackberry/screen-225.png
+++ /dev/null
Binary files differ
diff --git a/samples/hello-cordova/res/screen/ios/screen-ipad-landscape-2x.png b/samples/hello-cordova/res/screen/ios/screen-ipad-landscape-2x.png
deleted file mode 100644
index 95c542d..0000000
--- a/samples/hello-cordova/res/screen/ios/screen-ipad-landscape-2x.png
+++ /dev/null
Binary files differ
diff --git a/samples/hello-cordova/res/screen/ios/screen-ipad-landscape.png b/samples/hello-cordova/res/screen/ios/screen-ipad-landscape.png
deleted file mode 100644
index 04be5ac..0000000
--- a/samples/hello-cordova/res/screen/ios/screen-ipad-landscape.png
+++ /dev/null
Binary files differ
diff --git a/samples/hello-cordova/res/screen/ios/screen-ipad-portrait-2x.png b/samples/hello-cordova/res/screen/ios/screen-ipad-portrait-2x.png
deleted file mode 100644
index aae1862..0000000
--- a/samples/hello-cordova/res/screen/ios/screen-ipad-portrait-2x.png
+++ /dev/null
Binary files differ
diff --git a/samples/hello-cordova/res/screen/ios/screen-ipad-portrait.png b/samples/hello-cordova/res/screen/ios/screen-ipad-portrait.png
deleted file mode 100644
index 41e839d..0000000
--- a/samples/hello-cordova/res/screen/ios/screen-ipad-portrait.png
+++ /dev/null
Binary files differ
diff --git a/samples/hello-cordova/res/screen/ios/screen-iphone-landscape-2x.png b/samples/hello-cordova/res/screen/ios/screen-iphone-landscape-2x.png
deleted file mode 100644
index 0165669..0000000
--- a/samples/hello-cordova/res/screen/ios/screen-iphone-landscape-2x.png
+++ /dev/null
Binary files differ
diff --git a/samples/hello-cordova/res/screen/ios/screen-iphone-landscape.png b/samples/hello-cordova/res/screen/ios/screen-iphone-landscape.png
deleted file mode 100644
index d154883..0000000
--- a/samples/hello-cordova/res/screen/ios/screen-iphone-landscape.png
+++ /dev/null
Binary files differ
diff --git a/samples/hello-cordova/res/screen/ios/screen-iphone-portrait-2x.png b/samples/hello-cordova/res/screen/ios/screen-iphone-portrait-2x.png
deleted file mode 100644
index bd24886..0000000
--- a/samples/hello-cordova/res/screen/ios/screen-iphone-portrait-2x.png
+++ /dev/null
Binary files differ
diff --git a/samples/hello-cordova/res/screen/ios/screen-iphone-portrait.png b/samples/hello-cordova/res/screen/ios/screen-iphone-portrait.png
deleted file mode 100644
index 6fcba56..0000000
--- a/samples/hello-cordova/res/screen/ios/screen-iphone-portrait.png
+++ /dev/null
Binary files differ
diff --git a/samples/hello-cordova/res/screen/webos/screen-64.png b/samples/hello-cordova/res/screen/webos/screen-64.png
deleted file mode 100644
index 03b3849..0000000
--- a/samples/hello-cordova/res/screen/webos/screen-64.png
+++ /dev/null
Binary files differ
diff --git a/samples/hello-cordova/res/screen/windows-phone/screen-portrait.jpg b/samples/hello-cordova/res/screen/windows-phone/screen-portrait.jpg
deleted file mode 100644
index 479d3e4..0000000
--- a/samples/hello-cordova/res/screen/windows-phone/screen-portrait.jpg
+++ /dev/null
Binary files differ