| /* |
| * |
| * 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. |
| * |
| */ |
| |
| /* |
| * No real native code |
| */ |
| |
| /* Needed for File API implementation */ |
| window.webkitFileReader = window.FileReader; |
| |
| window._nativeReady = true; |
| |
| // Platform: tizen |
| // 2.9.0-28-gc01c173 |
| /* |
| 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() { |
| var CORDOVA_JS_BUILD_LABEL = '2.9.0-28-gc01c173'; |
| // file: lib/scripts/require.js |
| |
| var require, |
| define; |
| |
| (function () { |
| var modules = {}, |
| // Stack of moduleIds currently being built. |
| requireStack = [], |
| // Map of module ID -> index into requireStack of modules currently being built. |
| inProgressModules = {}, |
| SEPERATOR = "."; |
| |
| |
| |
| function build(module) { |
| var factory = module.factory, |
| localRequire = function (id) { |
| var resultantId = id; |
| //Its a relative path, so lop off the last portion and add the id (minus "./") |
| if (id.charAt(0) === ".") { |
| resultantId = module.id.slice(0, module.id.lastIndexOf(SEPERATOR)) + SEPERATOR + id.slice(2); |
| } |
| return require(resultantId); |
| }; |
| module.exports = {}; |
| delete module.factory; |
| factory(localRequire, module.exports, module); |
| return module.exports; |
| } |
| |
| require = function (id) { |
| if (!modules[id]) { |
| throw "module " + id + " not found"; |
| } else if (id in inProgressModules) { |
| var cycle = requireStack.slice(inProgressModules[id]).join('->') + '->' + id; |
| throw "Cycle in require graph: " + cycle; |
| } |
| if (modules[id].factory) { |
| try { |
| inProgressModules[id] = requireStack.length; |
| requireStack.push(id); |
| return build(modules[id]); |
| } finally { |
| delete inProgressModules[id]; |
| requireStack.pop(); |
| } |
| } |
| return modules[id].exports; |
| }; |
| |
| define = function (id, factory) { |
| if (modules[id]) { |
| throw "module " + id + " already defined"; |
| } |
| |
| modules[id] = { |
| id: id, |
| factory: factory |
| }; |
| }; |
| |
| define.remove = function (id) { |
| delete modules[id]; |
| }; |
| |
| define.moduleMap = modules; |
| })(); |
| |
| //Export for use in node |
| if (typeof module === "object" && typeof require === "function") { |
| module.exports.require = require; |
| module.exports.define = define; |
| } |
| |
| // file: lib/cordova.js |
| define("cordova", function(require, exports, module) { |
| |
| |
| var channel = require('cordova/channel'); |
| |
| /** |
| * Listen for DOMContentLoaded and notify our channel subscribers. |
| */ |
| document.addEventListener('DOMContentLoaded', function() { |
| channel.onDOMContentLoaded.fire(); |
| }, false); |
| if (document.readyState == 'complete' || document.readyState == 'interactive') { |
| channel.onDOMContentLoaded.fire(); |
| } |
| |
| /** |
| * Intercept calls to addEventListener + removeEventListener and handle deviceready, |
| * resume, and pause events. |
| */ |
| var m_document_addEventListener = document.addEventListener; |
| var m_document_removeEventListener = document.removeEventListener; |
| var m_window_addEventListener = window.addEventListener; |
| var m_window_removeEventListener = window.removeEventListener; |
| |
| /** |
| * Houses custom event handlers to intercept on document + window event listeners. |
| */ |
| var documentEventHandlers = {}, |
| windowEventHandlers = {}; |
| |
| document.addEventListener = function(evt, handler, capture) { |
| var e = evt.toLowerCase(); |
| if (typeof documentEventHandlers[e] != 'undefined') { |
| documentEventHandlers[e].subscribe(handler); |
| } else { |
| m_document_addEventListener.call(document, evt, handler, capture); |
| } |
| }; |
| |
| window.addEventListener = function(evt, handler, capture) { |
| var e = evt.toLowerCase(); |
| if (typeof windowEventHandlers[e] != 'undefined') { |
| windowEventHandlers[e].subscribe(handler); |
| } else { |
| m_window_addEventListener.call(window, evt, handler, capture); |
| } |
| }; |
| |
| document.removeEventListener = function(evt, handler, capture) { |
| var e = evt.toLowerCase(); |
| // If unsubscribing from an event that is handled by a plugin |
| if (typeof documentEventHandlers[e] != "undefined") { |
| documentEventHandlers[e].unsubscribe(handler); |
| } else { |
| m_document_removeEventListener.call(document, evt, handler, capture); |
| } |
| }; |
| |
| window.removeEventListener = function(evt, handler, capture) { |
| var e = evt.toLowerCase(); |
| // If unsubscribing from an event that is handled by a plugin |
| if (typeof windowEventHandlers[e] != "undefined") { |
| windowEventHandlers[e].unsubscribe(handler); |
| } else { |
| m_window_removeEventListener.call(window, evt, handler, capture); |
| } |
| }; |
| |
| function createEvent(type, data) { |
| var event = document.createEvent('Events'); |
| event.initEvent(type, false, false); |
| if (data) { |
| for (var i in data) { |
| if (data.hasOwnProperty(i)) { |
| event[i] = data[i]; |
| } |
| } |
| } |
| return event; |
| } |
| |
| if(typeof window.console === "undefined") { |
| window.console = { |
| log:function(){} |
| }; |
| } |
| |
| var cordova = { |
| define:define, |
| require:require, |
| /** |
| * Methods to add/remove your own addEventListener hijacking on document + window. |
| */ |
| addWindowEventHandler:function(event) { |
| return (windowEventHandlers[event] = channel.create(event)); |
| }, |
| addStickyDocumentEventHandler:function(event) { |
| return (documentEventHandlers[event] = channel.createSticky(event)); |
| }, |
| addDocumentEventHandler:function(event) { |
| return (documentEventHandlers[event] = channel.create(event)); |
| }, |
| removeWindowEventHandler:function(event) { |
| delete windowEventHandlers[event]; |
| }, |
| removeDocumentEventHandler:function(event) { |
| delete documentEventHandlers[event]; |
| }, |
| /** |
| * Retrieve original event handlers that were replaced by Cordova |
| * |
| * @return object |
| */ |
| getOriginalHandlers: function() { |
| return {'document': {'addEventListener': m_document_addEventListener, 'removeEventListener': m_document_removeEventListener}, |
| 'window': {'addEventListener': m_window_addEventListener, 'removeEventListener': m_window_removeEventListener}}; |
| }, |
| /** |
| * Method to fire event from native code |
| * bNoDetach is required for events which cause an exception which needs to be caught in native code |
| */ |
| fireDocumentEvent: function(type, data, bNoDetach) { |
| var evt = createEvent(type, data); |
| if (typeof documentEventHandlers[type] != 'undefined') { |
| if( bNoDetach ) { |
| documentEventHandlers[type].fire(evt); |
| } |
| else { |
| setTimeout(function() { |
| // Fire deviceready on listeners that were registered before cordova.js was loaded. |
| if (type == 'deviceready') { |
| document.dispatchEvent(evt); |
| } |
| 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); |
| } |
| }, |
| |
| /** |
| * Plugin callback mechanism. |
| */ |
| // Randomize the starting callbackId to avoid collisions after refreshing or navigating. |
| // This way, it's very unlikely that any new callback would get the same callbackId as an old callback. |
| callbackId: Math.floor(Math.random() * 2000000000), |
| callbacks: {}, |
| callbackStatus: { |
| NO_RESULT: 0, |
| OK: 1, |
| CLASS_NOT_FOUND_EXCEPTION: 2, |
| ILLEGAL_ACCESS_EXCEPTION: 3, |
| INSTANTIATION_EXCEPTION: 4, |
| MALFORMED_URL_EXCEPTION: 5, |
| IO_EXCEPTION: 6, |
| INVALID_ACTION: 7, |
| JSON_EXCEPTION: 8, |
| ERROR: 9 |
| }, |
| |
| /** |
| * Called by native code when returning successful result from an action. |
| */ |
| callbackSuccess: function(callbackId, args) { |
| try { |
| cordova.callbackFromNative(callbackId, true, args.status, [args.message], args.keepCallback); |
| } catch (e) { |
| console.log("Error in error callback: " + callbackId + " = "+e); |
| } |
| }, |
| |
| /** |
| * Called by native code when returning error result from an action. |
| */ |
| callbackError: function(callbackId, args) { |
| // TODO: Deprecate callbackSuccess and callbackError in favour of callbackFromNative. |
| // Derive success from status. |
| try { |
| cordova.callbackFromNative(callbackId, false, args.status, [args.message], args.keepCallback); |
| } catch (e) { |
| console.log("Error in error callback: " + callbackId + " = "+e); |
| } |
| }, |
| |
| /** |
| * Called by native code when returning the result from an action. |
| */ |
| callbackFromNative: function(callbackId, success, status, args, keepCallback) { |
| var callback = cordova.callbacks[callbackId]; |
| if (callback) { |
| if (success && status == cordova.callbackStatus.OK) { |
| callback.success && callback.success.apply(null, args); |
| } else if (!success) { |
| callback.fail && callback.fail.apply(null, args); |
| } |
| |
| // Clear callback if not expecting any more results |
| if (!keepCallback) { |
| delete cordova.callbacks[callbackId]; |
| } |
| } |
| }, |
| addConstructor: function(func) { |
| channel.onCordovaReady.subscribe(function() { |
| try { |
| func(); |
| } catch(e) { |
| console.log("Failed to run constructor: " + e); |
| } |
| }); |
| } |
| }; |
| |
| // Register pause, resume and deviceready channels as events on document. |
| channel.onPause = cordova.addDocumentEventHandler('pause'); |
| channel.onResume = cordova.addDocumentEventHandler('resume'); |
| channel.onDeviceReady = cordova.addStickyDocumentEventHandler('deviceready'); |
| |
| module.exports = cordova; |
| |
| }); |
| |
| // file: lib/common/argscheck.js |
| define("cordova/argscheck", function(require, exports, module) { |
| |
| var exec = require('cordova/exec'); |
| var utils = require('cordova/utils'); |
| |
| var moduleExports = module.exports; |
| |
| var typeMap = { |
| 'A': 'Array', |
| 'D': 'Date', |
| 'N': 'Number', |
| 'S': 'String', |
| 'F': 'Function', |
| 'O': 'Object' |
| }; |
| |
| function extractParamName(callee, argIndex) { |
| return (/.*?\((.*?)\)/).exec(callee)[1].split(', ')[argIndex]; |
| } |
| |
| function checkArgs(spec, functionName, args, opt_callee) { |
| if (!moduleExports.enableChecks) { |
| return; |
| } |
| var errMsg = null; |
| var typeName; |
| for (var i = 0; i < spec.length; ++i) { |
| var c = spec.charAt(i), |
| cUpper = c.toUpperCase(), |
| arg = args[i]; |
| // Asterix means allow anything. |
| if (c == '*') { |
| continue; |
| } |
| typeName = utils.typeName(arg); |
| if ((arg === null || arg === undefined) && c == cUpper) { |
| continue; |
| } |
| if (typeName != typeMap[cUpper]) { |
| errMsg = 'Expected ' + typeMap[cUpper]; |
| break; |
| } |
| } |
| if (errMsg) { |
| errMsg += ', but got ' + typeName + '.'; |
| errMsg = 'Wrong type for parameter "' + extractParamName(opt_callee || args.callee, i) + '" of ' + functionName + ': ' + errMsg; |
| // Don't log when running unit tests. |
| if (typeof jasmine == 'undefined') { |
| console.error(errMsg); |
| } |
| throw TypeError(errMsg); |
| } |
| } |
| |
| function getValue(value, defaultValue) { |
| return value === undefined ? defaultValue : value; |
| } |
| |
| moduleExports.checkArgs = checkArgs; |
| moduleExports.getValue = getValue; |
| moduleExports.enableChecks = true; |
| |
| |
| }); |
| |
| // 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 clobber(obj, key, value) { |
| exports.replaceHookForTesting(obj, key); |
| obj[key] = value; |
| // Getters can only be overridden by getters. |
| if (obj[key] !== value) { |
| utils.defineGetter(obj, key, function() { |
| return value; |
| }); |
| } |
| } |
| |
| function assignOrWrapInDeprecateGetter(obj, key, value, message) { |
| if (message) { |
| utils.defineGetter(obj, key, function() { |
| console.log(message); |
| delete obj[key]; |
| clobber(obj, key, value); |
| return value; |
| }); |
| } else { |
| clobber(obj, key, value); |
| } |
| } |
| |
| function include(parent, objects, clobber, merge) { |
| each(objects, function (obj, key) { |
| try { |
| var result = obj.path ? require(obj.path) : {}; |
| |
| if (clobber) { |
| // Clobber if it doesn't exist. |
| if (typeof parent[key] === 'undefined') { |
| assignOrWrapInDeprecateGetter(parent, key, result, obj.deprecated); |
| } else if (typeof obj.path !== 'undefined') { |
| // If merging, merge properties onto parent, otherwise, clobber. |
| if (merge) { |
| recursiveMerge(parent[key], result); |
| } else { |
| assignOrWrapInDeprecateGetter(parent, key, result, obj.deprecated); |
| } |
| } |
| result = parent[key]; |
| } else { |
| // Overwrite if not currently defined. |
| if (typeof parent[key] == 'undefined') { |
| assignOrWrapInDeprecateGetter(parent, key, result, obj.deprecated); |
| } else { |
| // 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 (target.prototype && target.prototype.constructor === target) { |
| // If the target object is a constructor override off prototype. |
| clobber(target.prototype, prop, src[prop]); |
| } else { |
| if (typeof src[prop] === 'object' && typeof target[prop] === 'object') { |
| recursiveMerge(target[prop], src[prop]); |
| } else { |
| clobber(target, prop, src[prop]); |
| } |
| } |
| } |
| } |
| } |
| |
| exports.buildIntoButDoNotClobber = function(objects, target) { |
| include(target, objects, false, false); |
| }; |
| exports.buildIntoAndClobber = function(objects, target) { |
| include(target, objects, true, false); |
| }; |
| exports.buildIntoAndMerge = function(objects, target) { |
| include(target, objects, true, true); |
| }; |
| exports.recursiveMerge = recursiveMerge; |
| exports.assignOrWrapInDeprecateGetter = assignOrWrapInDeprecateGetter; |
| exports.replaceHookForTesting = function() {}; |
| |
| }); |
| |
| // file: lib/common/channel.js |
| define("cordova/channel", function(require, exports, module) { |
| |
| var utils = require('cordova/utils'), |
| nextGuid = 1; |
| |
| /** |
| * Custom pub-sub "channel" that can have functions subscribed to it |
| * This object is used to define and control firing of events for |
| * cordova initialization, as well as for custom events thereafter. |
| * |
| * The order of events during page load and Cordova startup is as follows: |
| * |
| * onDOMContentLoaded* Internal event that is received when the web page is loaded and parsed. |
| * onNativeReady* Internal event that indicates the Cordova native side is ready. |
| * onCordovaReady* Internal event fired when all Cordova JavaScript objects have been created. |
| * onCordovaInfoReady* Internal event fired when device properties are available. |
| * onCordovaConnectionReady* Internal event fired when the connection property has been set. |
| * onDeviceReady* User event fired to indicate that Cordova is ready |
| * onResume User event fired to indicate a start/resume lifecycle event |
| * onPause User event fired to indicate a pause lifecycle event |
| * onDestroy* Internal event fired when app is being destroyed (User should use window.onunload event, not this one). |
| * |
| * The events marked with an * are sticky. Once they have fired, they will stay in the fired state. |
| * All listeners that subscribe after the event is fired will be executed right away. |
| * |
| * The only Cordova events that user code should register for are: |
| * deviceready Cordova native code is initialized and Cordova APIs can be called from JavaScript |
| * pause App has moved to background |
| * resume App has returned to foreground |
| * |
| * Listeners can be registered as: |
| * document.addEventListener("deviceready", myDeviceReadyListener, false); |
| * document.addEventListener("resume", myResumeListener, false); |
| * document.addEventListener("pause", myPauseListener, false); |
| * |
| * The DOM lifecycle events should be used for saving and restoring state |
| * window.onload |
| * window.onunload |
| * |
| */ |
| |
| /** |
| * Channel |
| * @constructor |
| * @param type String the channel name |
| */ |
| var Channel = function(type, sticky) { |
| this.type = type; |
| // Map of guid -> function. |
| this.handlers = {}; |
| // 0 = Non-sticky, 1 = Sticky non-fired, 2 = Sticky fired. |
| this.state = sticky ? 1 : 0; |
| // Used in sticky mode to remember args passed to fire(). |
| this.fireArgs = null; |
| // Used by onHasSubscribersChange to know if there are any listeners. |
| this.numHandlers = 0; |
| // Function that is called when the first listener is subscribed, or when |
| // the last listener is unsubscribed. |
| this.onHasSubscribersChange = null; |
| }, |
| channel = { |
| /** |
| * Calls the provided function only after all of the channels specified |
| * have been fired. All channels must be sticky channels. |
| */ |
| join: function(h, c) { |
| var len = c.length, |
| i = len, |
| f = function() { |
| if (!(--i)) h(); |
| }; |
| for (var j=0; j<len; j++) { |
| if (c[j].state === 0) { |
| throw Error('Can only use join with sticky channels.'); |
| } |
| c[j].subscribe(f); |
| } |
| if (!len) h(); |
| }, |
| create: function(type) { |
| return channel[type] = new Channel(type, false); |
| }, |
| createSticky: function(type) { |
| return channel[type] = new Channel(type, true); |
| }, |
| |
| /** |
| * cordova Channels that must fire before "deviceready" is fired. |
| */ |
| deviceReadyChannelsArray: [], |
| deviceReadyChannelsMap: {}, |
| |
| /** |
| * Indicate that a feature needs to be initialized before it is ready to be used. |
| * This holds up Cordova's "deviceready" event until the feature has been initialized |
| * and Cordova.initComplete(feature) is called. |
| * |
| * @param feature {String} The unique feature name |
| */ |
| waitForInitialization: function(feature) { |
| if (feature) { |
| var c = channel[feature] || this.createSticky(feature); |
| this.deviceReadyChannelsMap[feature] = c; |
| this.deviceReadyChannelsArray.push(c); |
| } |
| }, |
| |
| /** |
| * Indicate that initialization code has completed and the feature is ready to be used. |
| * |
| * @param feature {String} The unique feature name |
| */ |
| initializationComplete: function(feature) { |
| var c = this.deviceReadyChannelsMap[feature]; |
| if (c) { |
| c.fire(); |
| } |
| } |
| }; |
| |
| function forceFunction(f) { |
| if (typeof f != 'function') throw "Function required as first argument!"; |
| } |
| |
| /** |
| * Subscribes the given function to the channel. Any time that |
| * Channel.fire is called so too will the function. |
| * Optionally specify an execution context for the function |
| * and a guid that can be used to stop subscribing to the channel. |
| * Returns the guid. |
| */ |
| Channel.prototype.subscribe = function(f, c) { |
| // need a function to call |
| forceFunction(f); |
| if (this.state == 2) { |
| f.apply(c || this, this.fireArgs); |
| return; |
| } |
| |
| var func = f, |
| guid = f.observer_guid; |
| if (typeof c == "object") { func = utils.close(c, f); } |
| |
| if (!guid) { |
| // first time any channel has seen this subscriber |
| guid = '' + nextGuid++; |
| } |
| func.observer_guid = guid; |
| f.observer_guid = guid; |
| |
| // Don't add the same handler more than once. |
| if (!this.handlers[guid]) { |
| this.handlers[guid] = func; |
| this.numHandlers++; |
| if (this.numHandlers == 1) { |
| this.onHasSubscribersChange && this.onHasSubscribersChange(); |
| } |
| } |
| }; |
| |
| /** |
| * Unsubscribes the function with the given guid from the channel. |
| */ |
| Channel.prototype.unsubscribe = function(f) { |
| // need a function to unsubscribe |
| forceFunction(f); |
| |
| var guid = f.observer_guid, |
| handler = this.handlers[guid]; |
| if (handler) { |
| delete this.handlers[guid]; |
| this.numHandlers--; |
| if (this.numHandlers === 0) { |
| this.onHasSubscribersChange && this.onHasSubscribersChange(); |
| } |
| } |
| }; |
| |
| /** |
| * Calls all functions subscribed to this channel. |
| */ |
| Channel.prototype.fire = function(e) { |
| var fail = false, |
| fireArgs = Array.prototype.slice.call(arguments); |
| // Apply stickiness. |
| if (this.state == 1) { |
| this.state = 2; |
| this.fireArgs = fireArgs; |
| } |
| if (this.numHandlers) { |
| // Copy the values first so that it is safe to modify it from within |
| // callbacks. |
| var toCall = []; |
| for (var item in this.handlers) { |
| toCall.push(this.handlers[item]); |
| } |
| for (var i = 0; i < toCall.length; ++i) { |
| toCall[i].apply(this, fireArgs); |
| } |
| if (this.state == 2 && this.numHandlers) { |
| this.numHandlers = 0; |
| this.handlers = {}; |
| this.onHasSubscribersChange && this.onHasSubscribersChange(); |
| } |
| } |
| }; |
| |
| |
| // defining them here so they are ready super fast! |
| // DOM event that is received when the web page is loaded and parsed. |
| channel.createSticky('onDOMContentLoaded'); |
| |
| // Event to indicate the Cordova native side is ready. |
| channel.createSticky('onNativeReady'); |
| |
| // Event to indicate that all Cordova JavaScript objects have been created |
| // and it's time to run plugin constructors. |
| channel.createSticky('onCordovaReady'); |
| |
| // Event to indicate that device properties are available |
| channel.createSticky('onCordovaInfoReady'); |
| |
| // Event to indicate that the connection property has been set. |
| channel.createSticky('onCordovaConnectionReady'); |
| |
| // Event to indicate that all automatically loaded JS plugins are loaded and ready. |
| channel.createSticky('onPluginsReady'); |
| |
| // Event to indicate that Cordova is ready |
| channel.createSticky('onDeviceReady'); |
| |
| // Event to indicate a resume lifecycle event |
| channel.create('onResume'); |
| |
| // Event to indicate a pause lifecycle event |
| channel.create('onPause'); |
| |
| // Event to indicate a destroy lifecycle event |
| channel.createSticky('onDestroy'); |
| |
| // Channels that must fire before "deviceready" is fired. |
| channel.waitForInitialization('onCordovaReady'); |
| channel.waitForInitialization('onCordovaConnectionReady'); |
| channel.waitForInitialization('onDOMContentLoaded'); |
| |
| module.exports = channel; |
| |
| }); |
| |
| // file: lib/common/commandProxy.js |
| define("cordova/commandProxy", function(require, exports, module) { |
| |
| |
| // internal map of proxy function |
| var CommandProxyMap = {}; |
| |
| module.exports = { |
| |
| // example: cordova.commandProxy.add("Accelerometer",{getCurrentAcceleration: function(successCallback, errorCallback, options) {...},...); |
| add:function(id,proxyObj) { |
| console.log("adding proxy for " + id); |
| CommandProxyMap[id] = proxyObj; |
| return proxyObj; |
| }, |
| |
| // cordova.commandProxy.remove("Accelerometer"); |
| remove:function(id) { |
| var proxy = CommandProxyMap[id]; |
| delete CommandProxyMap[id]; |
| CommandProxyMap[id] = null; |
| return proxy; |
| }, |
| |
| get:function(service,action) { |
| return ( CommandProxyMap[service] ? CommandProxyMap[service][action] : null ); |
| } |
| }; |
| }); |
| |
| // file: lib/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 |
| */ |
| /** |
| * 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 |
| */ |
| |
| //console.log("TIZEN EXEC START"); |
| |
| |
| var manager = require('cordova/plugin/tizen/manager'), |
| cordova = require('cordova'), |
| utils = require('cordova/utils'); |
| |
| //console.log("TIZEN EXEC START bis"); |
| |
| module.exports = function(successCB, failCB, service, action, args) { |
| |
| try { |
| var v = manager.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); |
| } |
| }; |
| |
| //console.log("TIZEN EXEC END "); |
| |
| /* |
| var plugins = { |
| "Device": require('cordova/plugin/tizen/Device'), |
| "NetworkStatus": require('cordova/plugin/tizen/NetworkStatus'), |
| "Accelerometer": require('cordova/plugin/tizen/Accelerometer'), |
| "Battery": require('cordova/plugin/tizen/Battery'), |
| "Compass": require('cordova/plugin/tizen/Compass'), |
| //"Capture": require('cordova/plugin/tizen/Capture'), not yet available |
| "Camera": require('cordova/plugin/tizen/Camera'), |
| "FileTransfer": require('cordova/plugin/tizen/FileTransfer'), |
| "Media": require('cordova/plugin/tizen/Media'), |
| "Notification": require('cordova/plugin/tizen/Notification') |
| }; |
| |
| console.log("TIZEN EXEC START"); |
| |
| module.exports = function(success, fail, service, action, args) { |
| try { |
| console.log("exec: " + service + "." + action); |
| plugins[service][action](success, fail, args); |
| } |
| catch(e) { |
| console.log("missing exec: " + service + "." + action); |
| console.log(args); |
| console.log(e); |
| console.log(e.stack); |
| } |
| }; |
| |
| console.log("TIZEN EXEC START"); |
| */ |
| |
| }); |
| |
| // file: lib/common/modulemapper.js |
| define("cordova/modulemapper", function(require, exports, module) { |
| |
| var builder = require('cordova/builder'), |
| moduleMap = define.moduleMap, |
| symbolList, |
| deprecationMap; |
| |
| exports.reset = function() { |
| symbolList = []; |
| deprecationMap = {}; |
| }; |
| |
| function addEntry(strategy, moduleName, symbolPath, opt_deprecationMessage) { |
| if (!(moduleName in moduleMap)) { |
| throw new Error('Module ' + moduleName + ' does not exist.'); |
| } |
| symbolList.push(strategy, moduleName, symbolPath); |
| if (opt_deprecationMessage) { |
| deprecationMap[symbolPath] = opt_deprecationMessage; |
| } |
| } |
| |
| // Note: Android 2.3 does have Function.bind(). |
| exports.clobbers = function(moduleName, symbolPath, opt_deprecationMessage) { |
| addEntry('c', moduleName, symbolPath, opt_deprecationMessage); |
| }; |
| |
| exports.merges = function(moduleName, symbolPath, opt_deprecationMessage) { |
| addEntry('m', moduleName, symbolPath, opt_deprecationMessage); |
| }; |
| |
| exports.defaults = function(moduleName, symbolPath, opt_deprecationMessage) { |
| addEntry('d', moduleName, symbolPath, opt_deprecationMessage); |
| }; |
| |
| function prepareNamespace(symbolPath, context) { |
| if (!symbolPath) { |
| return context; |
| } |
| var parts = symbolPath.split('.'); |
| var cur = context; |
| for (var i = 0, part; part = parts[i]; ++i) { |
| cur = cur[part] = cur[part] || {}; |
| } |
| return cur; |
| } |
| |
| exports.mapModules = function(context) { |
| var origSymbols = {}; |
| context.CDV_origSymbols = origSymbols; |
| for (var i = 0, len = symbolList.length; i < len; i += 3) { |
| var strategy = symbolList[i]; |
| var moduleName = symbolList[i + 1]; |
| var symbolPath = symbolList[i + 2]; |
| var lastDot = symbolPath.lastIndexOf('.'); |
| var namespace = symbolPath.substr(0, lastDot); |
| var lastName = symbolPath.substr(lastDot + 1); |
| |
| var module = require(moduleName); |
| var deprecationMsg = symbolPath in deprecationMap ? 'Access made to deprecated symbol: ' + symbolPath + '. ' + deprecationMsg : null; |
| var parentObj = prepareNamespace(namespace, context); |
| var target = parentObj[lastName]; |
| |
| if (strategy == 'm' && target) { |
| builder.recursiveMerge(target, module); |
| } else if ((strategy == 'd' && !target) || (strategy != 'd')) { |
| if (!(symbolPath in origSymbols)) { |
| origSymbols[symbolPath] = target; |
| } |
| builder.assignOrWrapInDeprecateGetter(parentObj, lastName, module, deprecationMsg); |
| } |
| } |
| }; |
| |
| exports.getOriginalSymbol = function(context, symbolPath) { |
| var origSymbols = context.CDV_origSymbols; |
| if (origSymbols && (symbolPath in origSymbols)) { |
| return origSymbols[symbolPath]; |
| } |
| var parts = symbolPath.split('.'); |
| var obj = context; |
| for (var i = 0; i < parts.length; ++i) { |
| obj = obj && obj[parts[i]]; |
| } |
| return obj; |
| }; |
| |
| exports.loadMatchingModules = function(matchingRegExp) { |
| for (var k in moduleMap) { |
| if (matchingRegExp.exec(k)) { |
| require(k); |
| } |
| } |
| }; |
| |
| exports.reset(); |
| |
| |
| }); |
| |
| // file: lib/tizen/platform.js |
| define("cordova/platform", function(require, exports, module) { |
| |
| //console.log("TIZEN PLATFORM START"); |
| |
| |
| module.exports = { |
| id: "tizen", |
| initialize: function() { |
| |
| //console.log("TIZEN PLATFORM initialize start"); |
| |
| var modulemapper = require('cordova/modulemapper'); |
| |
| //modulemapper.loadMatchingModules(/cordova.*\/plugininit$/); |
| |
| modulemapper.loadMatchingModules(/cordova.*\/symbols$/); |
| |
| modulemapper.mapModules(window); |
| |
| //console.log("TIZEN PLATFORM initialize end"); |
| |
| } |
| }; |
| |
| //console.log("TIZEN PLATFORM START"); |
| |
| |
| }); |
| |
| // 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 argscheck = require('cordova/argscheck'), |
| exec = require('cordova/exec'), |
| Camera = require('cordova/plugin/CameraConstants'), |
| CameraPopoverHandle = require('cordova/plugin/CameraPopoverHandle'); |
| |
| 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) { |
| argscheck.checkArgs('fFO', 'Camera.getPicture', arguments); |
| options = options || {}; |
| var getValue = argscheck.getValue; |
| |
| var quality = getValue(options.quality, 50); |
| var destinationType = getValue(options.destinationType, Camera.DestinationType.FILE_URI); |
| var sourceType = getValue(options.sourceType, Camera.PictureSourceType.CAMERA); |
| var targetWidth = getValue(options.targetWidth, -1); |
| var targetHeight = getValue(options.targetHeight, -1); |
| var encodingType = getValue(options.encodingType, Camera.EncodingType.JPEG); |
| var mediaType = getValue(options.mediaType, Camera.MediaType.PICTURE); |
| var allowEdit = !!options.allowEdit; |
| var correctOrientation = !!options.correctOrientation; |
| var saveToPhotoAlbum = !!options.saveToPhotoAlbum; |
| var popoverOptions = getValue(options.popoverOptions, null); |
| var cameraDirection = getValue(options.cameraDirection, Camera.Direction.BACK); |
| |
| var args = [quality, destinationType, sourceType, targetWidth, targetHeight, encodingType, |
| mediaType, allowEdit, correctOrientation, saveToPhotoAlbum, popoverOptions, cameraDirection]; |
| |
| exec(successCallback, errorCallback, "Camera", "takePicture", args); |
| return new CameraPopoverHandle(); |
| }; |
| |
| 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) |
| NATIVE_URI: 2 // Return native uri (eg. asset-library://... for iOS) |
| }, |
| EncodingType:{ |
| JPEG: 0, // Return JPEG encoded image |
| PNG: 1 // Return PNG encoded image |
| }, |
| MediaType:{ |
| PICTURE: 0, // allow selection of still pictures only. DEFAULT. Will return format specified via DestinationType |
| VIDEO: 1, // allow selection of video only, ONLY RETURNS URL |
| ALLMEDIA : 2 // allow selection from all media types |
| }, |
| PictureSourceType:{ |
| PHOTOLIBRARY : 0, // Choose image from picture library (same as SAVEDPHOTOALBUM for Android) |
| CAMERA : 1, // Take picture from camera |
| SAVEDPHOTOALBUM : 2 // Choose image from picture library (same as PHOTOLIBRARY for Android) |
| }, |
| PopoverArrowDirection:{ |
| ARROW_UP : 1, // matches iOS UIPopoverArrowDirection constants to specify arrow location on popover |
| ARROW_DOWN : 2, |
| ARROW_LEFT : 4, |
| ARROW_RIGHT : 8, |
| ARROW_ANY : 15 |
| }, |
| Direction:{ |
| BACK: 0, |
| FRONT: 1 |
| } |
| }; |
| |
| }); |
| |
| // file: lib/common/plugin/CameraPopoverHandle.js |
| define("cordova/plugin/CameraPopoverHandle", function(require, exports, module) { |
| |
| var exec = require('cordova/exec'); |
| |
| /** |
| * A handle to an image picker popover. |
| */ |
| var CameraPopoverHandle = function() { |
| this.setPosition = function(popoverOptions) { |
| console.log('CameraPopoverHandle.setPosition is only supported on iOS.'); |
| }; |
| }; |
| |
| module.exports = CameraPopoverHandle; |
| |
| }); |
| |
| // 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; |
| }; |
| |
| 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; |
| }; |
| |
| 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; |
| }; |
| |
| module.exports = CaptureVideoOptions; |
| |
| }); |
| |
| // file: lib/common/plugin/CompassError.js |
| define("cordova/plugin/CompassError", function(require, exports, module) { |
| |
| /** |
| * CompassError. |
| * An error code assigned by an implementation when an error has occurred |
| * @constructor |
| */ |
| var CompassError = function(err) { |
| this.code = (err !== undefined ? err : null); |
| }; |
| |
| CompassError.COMPASS_INTERNAL_ERR = 0; |
| CompassError.COMPASS_NOT_SUPPORTED = 20; |
| |
| module.exports = CompassError; |
| |
| }); |
| |
| // file: lib/common/plugin/CompassHeading.js |
| define("cordova/plugin/CompassHeading", function(require, exports, module) { |
| |
| var CompassHeading = function(magneticHeading, trueHeading, headingAccuracy, timestamp) { |
| this.magneticHeading = magneticHeading; |
| this.trueHeading = trueHeading; |
| this.headingAccuracy = headingAccuracy; |
| this.timestamp = 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", |
| CELL:"cellular", |
| NONE: "none" |
| }; |
| |
| }); |
| |
| // file: lib/common/plugin/Contact.js |
| define("cordova/plugin/Contact", function(require, exports, module) { |
| |
| var argscheck = require('cordova/argscheck'), |
| exec = require('cordova/exec'), |
| ContactError = require('cordova/plugin/ContactError'), |
| utils = require('cordova/utils'); |
| |
| /** |
| * Converts primitives into Complex Object |
| * Currently only used for Date fields |
| */ |
| function convertIn(contact) { |
| var value = contact.birthday; |
| try { |
| contact.birthday = new Date(parseFloat(value)); |
| } catch (exception){ |
| console.log("Cordova Contact convertIn error: exception creating date."); |
| } |
| return contact; |
| } |
| |
| /** |
| * 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) { |
| argscheck.checkArgs('FF', 'Contact.remove', arguments); |
| var fail = errorCB && function(code) { |
| errorCB(new ContactError(code)); |
| }; |
| if (this.id === null) { |
| fail(ContactError.UNKNOWN_ERROR); |
| } |
| else { |
| exec(successCB, fail, "Contacts", "remove", [this.id]); |
| } |
| }; |
| |
| /** |
| * Creates a deep copy of this Contact. |
| * With the contact ID set to null. |
| * @return copy of this Contact |
| */ |
| Contact.prototype.clone = function() { |
| var clonedContact = utils.clone(this); |
| clonedContact.id = null; |
| clonedContact.rawId = null; |
| |
| function nullIds(arr) { |
| if (arr) { |
| for (var i = 0; i < arr.length; ++i) { |
| arr[i].id = null; |
| } |
| } |
| } |
| |
| // Loop through and clear out any id's in phones, emails, etc. |
| nullIds(clonedContact.phoneNumbers); |
| nullIds(clonedContact.emails); |
| nullIds(clonedContact.addresses); |
| nullIds(clonedContact.ims); |
| nullIds(clonedContact.organizations); |
| nullIds(clonedContact.categories); |
| nullIds(clonedContact.photos); |
| nullIds(clonedContact.urls); |
| return clonedContact; |
| }; |
| |
| /** |
| * Persists contact to device storage. |
| * @param successCB success callback |
| * @param errorCB error callback |
| */ |
| Contact.prototype.save = function(successCB, errorCB) { |
| argscheck.checkArgs('FFO', 'Contact.save', arguments); |
| var fail = errorCB && function(code) { |
| errorCB(new ContactError(code)); |
| }; |
| var success = function(result) { |
| if (result) { |
| if (successCB) { |
| var fullContact = require('cordova/plugin/contacts').create(result); |
| successCB(convertIn(fullContact)); |
| } |
| } |
| else { |
| // no Entry object returned |
| fail(ContactError.UNKNOWN_ERROR); |
| } |
| }; |
| var dupContact = convertOut(utils.clone(this)); |
| exec(success, fail, "Contacts", "save", [dupContact]); |
| }; |
| |
| |
| module.exports = Contact; |
| |
| }); |
| |
| // file: lib/common/plugin/ContactAddress.js |
| define("cordova/plugin/ContactAddress", function(require, exports, module) { |
| |
| /** |
| * Contact address. |
| * @constructor |
| * @param {DOMString} id unique identifier, should only be set by native code |
| * @param formatted // NOTE: not a W3C standard |
| * @param streetAddress |
| * @param locality |
| * @param region |
| * @param postalCode |
| * @param country |
| */ |
| |
| var ContactAddress = function(pref, type, formatted, streetAddress, locality, region, postalCode, country) { |
| this.id = null; |
| this.pref = (typeof pref != 'undefined' ? pref : false); |
| this.type = type || null; |
| this.formatted = formatted || null; |
| this.streetAddress = streetAddress || null; |
| this.locality = locality || null; |
| this.region = region || null; |
| this.postalCode = postalCode || null; |
| this.country = country || null; |
| }; |
| |
| module.exports = ContactAddress; |
| |
| }); |
| |
| // file: lib/common/plugin/ContactError.js |
| define("cordova/plugin/ContactError", function(require, exports, module) { |
| |
| /** |
| * ContactError. |
| * An error code assigned by an implementation when an error has occurred |
| * @constructor |
| */ |
| var ContactError = function(err) { |
| this.code = (typeof err != 'undefined' ? err : null); |
| }; |
| |
| /** |
| * Error codes |
| */ |
| ContactError.UNKNOWN_ERROR = 0; |
| ContactError.INVALID_ARGUMENT_ERROR = 1; |
| ContactError.TIMEOUT_ERROR = 2; |
| ContactError.PENDING_OPERATION_ERROR = 3; |
| ContactError.IO_ERROR = 4; |
| ContactError.NOT_SUPPORTED_ERROR = 5; |
| ContactError.PERMISSION_DENIED_ERROR = 20; |
| |
| module.exports = ContactError; |
| |
| }); |
| |
| // file: lib/common/plugin/ContactField.js |
| define("cordova/plugin/ContactField", function(require, exports, module) { |
| |
| /** |
| * Generic contact field. |
| * @constructor |
| * @param {DOMString} id unique identifier, should only be set by native code // NOTE: not a W3C standard |
| * @param type |
| * @param value |
| * @param pref |
| */ |
| var ContactField = function(type, value, pref) { |
| this.id = null; |
| this.type = (type && type.toString()) || null; |
| this.value = (value && value.toString()) || null; |
| this.pref = (typeof pref != 'undefined' ? pref : false); |
| }; |
| |
| module.exports = ContactField; |
| |
| }); |
| |
| // file: lib/common/plugin/ContactFindOptions.js |
| define("cordova/plugin/ContactFindOptions", function(require, exports, module) { |
| |
| /** |
| * ContactFindOptions. |
| * @constructor |
| * @param filter used to match contacts against |
| * @param multiple boolean used to determine if more than one contact should be returned |
| */ |
| |
| var ContactFindOptions = function(filter, multiple) { |
| this.filter = filter || ''; |
| this.multiple = (typeof multiple != 'undefined' ? multiple : false); |
| }; |
| |
| module.exports = ContactFindOptions; |
| |
| }); |
| |
| // file: lib/common/plugin/ContactName.js |
| define("cordova/plugin/ContactName", function(require, exports, module) { |
| |
| /** |
| * Contact name. |
| * @constructor |
| * @param formatted // NOTE: not part of W3C standard |
| * @param familyName |
| * @param givenName |
| * @param middle |
| * @param prefix |
| * @param suffix |
| */ |
| var ContactName = function(formatted, familyName, givenName, middle, prefix, suffix) { |
| this.formatted = formatted || null; |
| this.familyName = familyName || null; |
| this.givenName = givenName || null; |
| this.middleName = middle || null; |
| this.honorificPrefix = prefix || null; |
| this.honorificSuffix = suffix || null; |
| }; |
| |
| module.exports = ContactName; |
| |
| }); |
| |
| // file: lib/common/plugin/ContactOrganization.js |
| define("cordova/plugin/ContactOrganization", function(require, exports, module) { |
| |
| /** |
| * Contact organization. |
| * @constructor |
| * @param {DOMString} id unique identifier, should only be set by native code // NOTE: not a W3C standard |
| * @param name |
| * @param dept |
| * @param title |
| * @param startDate |
| * @param endDate |
| * @param location |
| * @param desc |
| */ |
| |
| var ContactOrganization = function(pref, type, name, dept, title) { |
| this.id = null; |
| this.pref = (typeof pref != 'undefined' ? pref : false); |
| this.type = type || null; |
| this.name = name || null; |
| this.department = dept || null; |
| this.title = title || null; |
| }; |
| |
| module.exports = ContactOrganization; |
| |
| }); |
| |
| // file: lib/common/plugin/Coordinates.js |
| define("cordova/plugin/Coordinates", function(require, exports, module) { |
| |
| /** |
| * This class contains position information. |
| * @param {Object} lat |
| * @param {Object} lng |
| * @param {Object} alt |
| * @param {Object} acc |
| * @param {Object} head |
| * @param {Object} vel |
| * @param {Object} altacc |
| * @constructor |
| */ |
| var Coordinates = function(lat, lng, alt, acc, head, vel, altacc) { |
| /** |
| * The latitude of the position. |
| */ |
| this.latitude = lat; |
| /** |
| * The longitude of the position, |
| */ |
| this.longitude = lng; |
| /** |
| * The accuracy of the position. |
| */ |
| this.accuracy = acc; |
| /** |
| * The altitude of the position. |
| */ |
| this.altitude = (alt !== undefined ? alt : null); |
| /** |
| * The direction the device is moving at the position. |
| */ |
| this.heading = (head !== undefined ? head : null); |
| /** |
| * The velocity with which the device is moving at the position. |
| */ |
| this.speed = (vel !== undefined ? vel : null); |
| |
| if (this.speed === 0 || this.speed === null) { |
| this.heading = NaN; |
| } |
| |
| /** |
| * The altitude accuracy of the position. |
| */ |
| this.altitudeAccuracy = (altacc !== undefined) ? altacc : null; |
| }; |
| |
| module.exports = Coordinates; |
| |
| }); |
| |
| // file: lib/common/plugin/DirectoryEntry.js |
| define("cordova/plugin/DirectoryEntry", function(require, exports, module) { |
| |
| var argscheck = require('cordova/argscheck'), |
| utils = require('cordova/utils'), |
| exec = require('cordova/exec'), |
| Entry = require('cordova/plugin/Entry'), |
| FileError = require('cordova/plugin/FileError'), |
| DirectoryReader = require('cordova/plugin/DirectoryReader'); |
| |
| /** |
| * An interface representing a directory on the file system. |
| * |
| * {boolean} isFile always false (readonly) |
| * {boolean} isDirectory always true (readonly) |
| * {DOMString} name of the directory, excluding the path leading to it (readonly) |
| * {DOMString} fullPath the absolute full path to the directory (readonly) |
| * TODO: implement this!!! {FileSystem} filesystem on which the directory resides (readonly) |
| */ |
| var DirectoryEntry = function(name, fullPath) { |
| DirectoryEntry.__super__.constructor.call(this, false, true, name, fullPath); |
| }; |
| |
| utils.extend(DirectoryEntry, Entry); |
| |
| /** |
| * Creates a new DirectoryReader to read entries from this directory |
| */ |
| DirectoryEntry.prototype.createReader = function() { |
| return new DirectoryReader(this.fullPath); |
| }; |
| |
| /** |
| * Creates or looks up a directory |
| * |
| * @param {DOMString} path either a relative or absolute path from this directory in which to look up or create a directory |
| * @param {Flags} options to create or exclusively create the directory |
| * @param {Function} successCallback is called with the new entry |
| * @param {Function} errorCallback is called with a FileError |
| */ |
| DirectoryEntry.prototype.getDirectory = function(path, options, successCallback, errorCallback) { |
| argscheck.checkArgs('sOFF', 'DirectoryEntry.getDirectory', arguments); |
| var win = successCallback && function(result) { |
| var entry = new DirectoryEntry(result.name, result.fullPath); |
| successCallback(entry); |
| }; |
| var fail = errorCallback && function(code) { |
| errorCallback(new FileError(code)); |
| }; |
| exec(win, fail, "File", "getDirectory", [this.fullPath, path, options]); |
| }; |
| |
| /** |
| * Deletes a directory and all of it's contents |
| * |
| * @param {Function} successCallback is called with no parameters |
| * @param {Function} errorCallback is called with a FileError |
| */ |
| DirectoryEntry.prototype.removeRecursively = function(successCallback, errorCallback) { |
| argscheck.checkArgs('FF', 'DirectoryEntry.removeRecursively', arguments); |
| var fail = errorCallback && function(code) { |
| errorCallback(new FileError(code)); |
| }; |
| exec(successCallback, fail, "File", "removeRecursively", [this.fullPath]); |
| }; |
| |
| /** |
| * Creates or looks up a file |
| * |
| * @param {DOMString} path either a relative or absolute path from this directory in which to look up or create a file |
| * @param {Flags} options to create or exclusively create the file |
| * @param {Function} successCallback is called with the new entry |
| * @param {Function} errorCallback is called with a FileError |
| */ |
| DirectoryEntry.prototype.getFile = function(path, options, successCallback, errorCallback) { |
| argscheck.checkArgs('sOFF', 'DirectoryEntry.getFile', arguments); |
| var win = successCallback && function(result) { |
| var FileEntry = require('cordova/plugin/FileEntry'); |
| var entry = new FileEntry(result.name, result.fullPath); |
| successCallback(entry); |
| }; |
| var fail = errorCallback && function(code) { |
| errorCallback(new FileError(code)); |
| }; |
| exec(win, fail, "File", "getFile", [this.fullPath, path, options]); |
| }; |
| |
| module.exports = DirectoryEntry; |
| |
| }); |
| |
| // file: lib/common/plugin/DirectoryReader.js |
| define("cordova/plugin/DirectoryReader", function(require, exports, module) { |
| |
| var exec = require('cordova/exec'), |
| FileError = require('cordova/plugin/FileError') ; |
| |
| /** |
| * An interface that lists the files and directories in a directory. |
| */ |
| function DirectoryReader(path) { |
| this.path = path || null; |
| this.hasReadEntries = false; |
| } |
| |
| /** |
| * Returns a list of entries from a directory. |
| * |
| * @param {Function} successCallback is called with a list of entries |
| * @param {Function} errorCallback is called with a FileError |
| */ |
| DirectoryReader.prototype.readEntries = function(successCallback, errorCallback) { |
| // If we've already read and passed on this directory's entries, return an empty list. |
| if (this.hasReadEntries) { |
| successCallback([]); |
| return; |
| } |
| var reader = this; |
| 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); |
| } |
| reader.hasReadEntries = true; |
| successCallback(retVal); |
| }; |
| var fail = typeof errorCallback !== 'function' ? null : function(code) { |
| errorCallback(new FileError(code)); |
| }; |
| exec(win, fail, "File", "readEntries", [this.path]); |
| }; |
| |
| module.exports = DirectoryReader; |
| |
| }); |
| |
| // file: lib/common/plugin/Entry.js |
| define("cordova/plugin/Entry", function(require, exports, module) { |
| |
| var argscheck = require('cordova/argscheck'), |
| exec = require('cordova/exec'), |
| FileError = require('cordova/plugin/FileError'), |
| Metadata = require('cordova/plugin/Metadata'); |
| |
| /** |
| * Represents a file or directory on the local file system. |
| * |
| * @param isFile |
| * {boolean} true if Entry is a file (readonly) |
| * @param isDirectory |
| * {boolean} true if Entry is a directory (readonly) |
| * @param name |
| * {DOMString} name of the file or directory, excluding the path |
| * leading to it (readonly) |
| * @param fullPath |
| * {DOMString} the absolute full path to the file or directory |
| * (readonly) |
| */ |
| function Entry(isFile, isDirectory, name, fullPath, fileSystem) { |
| this.isFile = !!isFile; |
| this.isDirectory = !!isDirectory; |
| this.name = name || ''; |
| this.fullPath = fullPath || ''; |
| this.filesystem = fileSystem || null; |
| } |
| |
| /** |
| * Look up the metadata of the entry. |
| * |
| * @param successCallback |
| * {Function} is called with a Metadata object |
| * @param errorCallback |
| * {Function} is called with a FileError |
| */ |
| Entry.prototype.getMetadata = function(successCallback, errorCallback) { |
| argscheck.checkArgs('FF', 'Entry.getMetadata', arguments); |
| var success = successCallback && function(lastModified) { |
| var metadata = new Metadata(lastModified); |
| successCallback(metadata); |
| }; |
| var fail = errorCallback && function(code) { |
| errorCallback(new FileError(code)); |
| }; |
| |
| exec(success, fail, "File", "getMetadata", [this.fullPath]); |
| }; |
| |
| /** |
| * Set the metadata of the entry. |
| * |
| * @param successCallback |
| * {Function} is called with a Metadata object |
| * @param errorCallback |
| * {Function} is called with a FileError |
| * @param metadataObject |
| * {Object} keys and values to set |
| */ |
| Entry.prototype.setMetadata = function(successCallback, errorCallback, metadataObject) { |
| argscheck.checkArgs('FFO', 'Entry.setMetadata', arguments); |
| exec(successCallback, errorCallback, "File", "setMetadata", [this.fullPath, metadataObject]); |
| }; |
| |
| /** |
| * Move a file or directory to a new location. |
| * |
| * @param parent |
| * {DirectoryEntry} the directory to which to move this entry |
| * @param newName |
| * {DOMString} new name of the entry, defaults to the current name |
| * @param successCallback |
| * {Function} called with the new DirectoryEntry object |
| * @param errorCallback |
| * {Function} called with a FileError |
| */ |
| Entry.prototype.moveTo = function(parent, newName, successCallback, errorCallback) { |
| argscheck.checkArgs('oSFF', 'Entry.moveTo', arguments); |
| var fail = errorCallback && function(code) { |
| errorCallback(new FileError(code)); |
| }; |
| // source path |
| var srcPath = this.fullPath, |
| // entry name |
| name = newName || this.name, |
| success = function(entry) { |
| if (entry) { |
| if (successCallback) { |
| // create appropriate Entry object |
| var result = (entry.isDirectory) ? new (require('cordova/plugin/DirectoryEntry'))(entry.name, entry.fullPath) : new (require('cordova/plugin/FileEntry'))(entry.name, entry.fullPath); |
| successCallback(result); |
| } |
| } |
| else { |
| // no Entry object returned |
| fail && fail(FileError.NOT_FOUND_ERR); |
| } |
| }; |
| |
| // copy |
| exec(success, fail, "File", "moveTo", [srcPath, parent.fullPath, name]); |
| }; |
| |
| /** |
| * Copy a directory to a different location. |
| * |
| * @param parent |
| * {DirectoryEntry} the directory to which to copy the entry |
| * @param newName |
| * {DOMString} new name of the entry, defaults to the current name |
| * @param successCallback |
| * {Function} called with the new Entry object |
| * @param errorCallback |
| * {Function} called with a FileError |
| */ |
| Entry.prototype.copyTo = function(parent, newName, successCallback, errorCallback) { |
| argscheck.checkArgs('oSFF', 'Entry.copyTo', arguments); |
| var fail = errorCallback && function(code) { |
| errorCallback(new FileError(code)); |
| }; |
| |
| // source path |
| var srcPath = this.fullPath, |
| // entry name |
| name = newName || this.name, |
| // success callback |
| success = function(entry) { |
| if (entry) { |
| if (successCallback) { |
| // create appropriate Entry object |
| var result = (entry.isDirectory) ? new (require('cordova/plugin/DirectoryEntry'))(entry.name, entry.fullPath) : new (require('cordova/plugin/FileEntry'))(entry.name, entry.fullPath); |
| successCallback(result); |
| } |
| } |
| else { |
| // no Entry object returned |
| fail && fail(FileError.NOT_FOUND_ERR); |
| } |
| }; |
| |
| // copy |
| exec(success, fail, "File", "copyTo", [srcPath, parent.fullPath, name]); |
| }; |
| |
| /** |
| * Return a URL that can be used to identify this entry. |
| */ |
| Entry.prototype.toURL = function() { |
| // fullPath attribute contains the full URL |
| return this.fullPath; |
| }; |
| |
| /** |
| * Returns a URI that can be used to identify this entry. |
| * |
| * @param {DOMString} mimeType for a FileEntry, the mime type to be used to interpret the file, when loaded through this URI. |
| * @return uri |
| */ |
| Entry.prototype.toURI = function(mimeType) { |
| console.log("DEPRECATED: Update your code to use 'toURL'"); |
| // fullPath attribute contains the full URI |
| return this.toURL(); |
| }; |
| |
| /** |
| * Remove a file or directory. It is an error to attempt to delete a |
| * directory that is not empty. It is an error to attempt to delete a |
| * root directory of a file system. |
| * |
| * @param successCallback {Function} called with no parameters |
| * @param errorCallback {Function} called with a FileError |
| */ |
| Entry.prototype.remove = function(successCallback, errorCallback) { |
| argscheck.checkArgs('FF', 'Entry.remove', arguments); |
| var fail = errorCallback && function(code) { |
| errorCallback(new FileError(code)); |
| }; |
| exec(successCallback, fail, "File", "remove", [this.fullPath]); |
| }; |
| |
| /** |
| * Look up the parent DirectoryEntry of this entry. |
| * |
| * @param successCallback {Function} called with the parent DirectoryEntry object |
| * @param errorCallback {Function} called with a FileError |
| */ |
| Entry.prototype.getParent = function(successCallback, errorCallback) { |
| argscheck.checkArgs('FF', 'Entry.getParent', arguments); |
| var win = successCallback && function(result) { |
| var DirectoryEntry = require('cordova/plugin/DirectoryEntry'); |
| var entry = new DirectoryEntry(result.name, result.fullPath); |
| successCallback(entry); |
| }; |
| var fail = errorCallback && function(code) { |
| errorCallback(new FileError(code)); |
| }; |
| exec(win, fail, "File", "getParent", [this.fullPath]); |
| }; |
| |
| module.exports = Entry; |
| |
| }); |
| |
| // file: lib/common/plugin/File.js |
| define("cordova/plugin/File", function(require, exports, module) { |
| |
| /** |
| * Constructor. |
| * name {DOMString} name of the file, without path information |
| * fullPath {DOMString} the full path of the file, including the name |
| * type {DOMString} mime type |
| * lastModifiedDate {Date} last modified date |
| * size {Number} size of the file in bytes |
| */ |
| |
| var File = function(name, fullPath, type, lastModifiedDate, size){ |
| this.name = name || ''; |
| this.fullPath = fullPath || null; |
| this.type = type || null; |
| this.lastModifiedDate = lastModifiedDate || null; |
| this.size = size || 0; |
| |
| // These store the absolute start and end for slicing the file. |
| this.start = 0; |
| this.end = this.size; |
| }; |
| |
| /** |
| * Returns a "slice" of the file. Since Cordova Files don't contain the actual |
| * content, this really returns a File with adjusted start and end. |
| * Slices of slices are supported. |
| * start {Number} The index at which to start the slice (inclusive). |
| * end {Number} The index at which to end the slice (exclusive). |
| */ |
| File.prototype.slice = function(start, end) { |
| var size = this.end - this.start; |
| var newStart = 0; |
| var newEnd = size; |
| if (arguments.length) { |
| if (start < 0) { |
| newStart = Math.max(size + start, 0); |
| } else { |
| newStart = Math.min(size, start); |
| } |
| } |
| |
| if (arguments.length >= 2) { |
| if (end < 0) { |
| newEnd = Math.max(size + end, 0); |
| } else { |
| newEnd = Math.min(end, size); |
| } |
| } |
| |
| var newFile = new File(this.name, this.fullPath, this.type, this.lastModifiedData, this.size); |
| newFile.start = this.start + newStart; |
| newFile.end = this.start + newEnd; |
| return newFile; |
| }; |
| |
| |
| module.exports = File; |
| |
| }); |
| |
| // file: lib/common/plugin/FileEntry.js |
| define("cordova/plugin/FileEntry", function(require, exports, module) { |
| |
| var utils = require('cordova/utils'), |
| exec = require('cordova/exec'), |
| Entry = require('cordova/plugin/Entry'), |
| FileWriter = require('cordova/plugin/FileWriter'), |
| File = require('cordova/plugin/File'), |
| FileError = require('cordova/plugin/FileError'); |
| |
| /** |
| * An interface representing a file on the file system. |
| * |
| * {boolean} isFile always true (readonly) |
| * {boolean} isDirectory always false (readonly) |
| * {DOMString} name of the file, excluding the path leading to it (readonly) |
| * {DOMString} fullPath the absolute full path to the file (readonly) |
| * {FileSystem} filesystem on which the file resides (readonly) |
| */ |
| var FileEntry = function(name, fullPath) { |
| FileEntry.__super__.constructor.apply(this, [true, false, name, fullPath]); |
| }; |
| |
| utils.extend(FileEntry, Entry); |
| |
| /** |
| * Creates a new FileWriter associated with the file that this FileEntry represents. |
| * |
| * @param {Function} successCallback is called with the new FileWriter |
| * @param {Function} errorCallback is called with a FileError |
| */ |
| FileEntry.prototype.createWriter = function(successCallback, errorCallback) { |
| this.file(function(filePointer) { |
| var writer = new FileWriter(filePointer); |
| |
| if (writer.fileName === null || writer.fileName === "") { |
| errorCallback && errorCallback(new FileError(FileError.INVALID_STATE_ERR)); |
| } else { |
| successCallback && successCallback(writer); |
| } |
| }, errorCallback); |
| }; |
| |
| /** |
| * Returns a File that represents the current state of the file that this FileEntry represents. |
| * |
| * @param {Function} successCallback is called with the new File object |
| * @param {Function} errorCallback is called with a FileError |
| */ |
| FileEntry.prototype.file = function(successCallback, errorCallback) { |
| var win = successCallback && function(f) { |
| var file = new File(f.name, f.fullPath, f.type, f.lastModifiedDate, f.size); |
| successCallback(file); |
| }; |
| var fail = errorCallback && function(code) { |
| errorCallback(new FileError(code)); |
| }; |
| exec(win, fail, "File", "getFileMetadata", [this.fullPath]); |
| }; |
| |
| |
| module.exports = FileEntry; |
| |
| }); |
| |
| // file: lib/common/plugin/FileError.js |
| define("cordova/plugin/FileError", function(require, exports, module) { |
| |
| /** |
| * FileError |
| */ |
| function FileError(error) { |
| this.code = error || null; |
| } |
| |
| // File error codes |
| // Found in DOMException |
| FileError.NOT_FOUND_ERR = 1; |
| FileError.SECURITY_ERR = 2; |
| FileError.ABORT_ERR = 3; |
| |
| // Added by File API specification |
| FileError.NOT_READABLE_ERR = 4; |
| FileError.ENCODING_ERR = 5; |
| FileError.NO_MODIFICATION_ALLOWED_ERR = 6; |
| FileError.INVALID_STATE_ERR = 7; |
| FileError.SYNTAX_ERR = 8; |
| FileError.INVALID_MODIFICATION_ERR = 9; |
| FileError.QUOTA_EXCEEDED_ERR = 10; |
| FileError.TYPE_MISMATCH_ERR = 11; |
| FileError.PATH_EXISTS_ERR = 12; |
| |
| module.exports = FileError; |
| |
| }); |
| |
| // file: lib/common/plugin/FileReader.js |
| define("cordova/plugin/FileReader", function(require, exports, module) { |
| |
| var exec = require('cordova/exec'), |
| modulemapper = require('cordova/modulemapper'), |
| utils = require('cordova/utils'), |
| File = require('cordova/plugin/File'), |
| FileError = require('cordova/plugin/FileError'), |
| ProgressEvent = require('cordova/plugin/ProgressEvent'), |
| origFileReader = modulemapper.getOriginalSymbol(this, 'FileReader'); |
| |
| /** |
| * This class reads the mobile device file system. |
| * |
| * For Android: |
| * The root directory is the root of the file system. |
| * To read from the SD card, the file name is "sdcard/my_file.txt" |
| * @constructor |
| */ |
| var FileReader = function() { |
| this._readyState = 0; |
| this._error = null; |
| this._result = null; |
| this._fileName = ''; |
| this._realReader = origFileReader ? new origFileReader() : {}; |
| }; |
| |
| // States |
| FileReader.EMPTY = 0; |
| FileReader.LOADING = 1; |
| FileReader.DONE = 2; |
| |
| utils.defineGetter(FileReader.prototype, 'readyState', function() { |
| return this._fileName ? this._readyState : this._realReader.readyState; |
| }); |
| |
| utils.defineGetter(FileReader.prototype, 'error', function() { |
| return this._fileName ? this._error: this._realReader.error; |
| }); |
| |
| utils.defineGetter(FileReader.prototype, 'result', function() { |
| return this._fileName ? this._result: this._realReader.result; |
| }); |
| |
| function defineEvent(eventName) { |
| utils.defineGetterSetter(FileReader.prototype, eventName, function() { |
| return this._realReader[eventName] || null; |
| }, function(value) { |
| this._realReader[eventName] = value; |
| }); |
| } |
| defineEvent('onloadstart'); // When the read starts. |
| defineEvent('onprogress'); // While reading (and decoding) file or fileBlob data, and reporting partial file data (progress.loaded/progress.total) |
| defineEvent('onload'); // When the read has successfully completed. |
| defineEvent('onerror'); // When the read has failed (see errors). |
| defineEvent('onloadend'); // When the request has completed (either in success or failure). |
| defineEvent('onabort'); // When the read has been aborted. For instance, by invoking the abort() method. |
| |
| function initRead(reader, file) { |
| // Already loading something |
| if (reader.readyState == FileReader.LOADING) { |
| throw new FileError(FileError.INVALID_STATE_ERR); |
| } |
| |
| reader._result = null; |
| reader._error = null; |
| reader._readyState = FileReader.LOADING; |
| |
| if (typeof file.fullPath == 'string') { |
| reader._fileName = file.fullPath; |
| } else { |
| reader._fileName = ''; |
| return true; |
| } |
| |
| reader.onloadstart && reader.onloadstart(new ProgressEvent("loadstart", {target:reader})); |
| } |
| |
| /** |
| * Abort reading file. |
| */ |
| FileReader.prototype.abort = function() { |
| if (origFileReader && !this._fileName) { |
| return this._realReader.abort(); |
| } |
| this._result = null; |
| |
| if (this._readyState == FileReader.DONE || this._readyState == FileReader.EMPTY) { |
| return; |
| } |
| |
| this._readyState = FileReader.DONE; |
| |
| // If abort callback |
| if (typeof this.onabort === 'function') { |
| this.onabort(new ProgressEvent('abort', {target:this})); |
| } |
| // If load end callback |
| if (typeof this.onloadend === 'function') { |
| this.onloadend(new ProgressEvent('loadend', {target:this})); |
| } |
| }; |
| |
| /** |
| * Read text file. |
| * |
| * @param file {File} File object containing file properties |
| * @param encoding [Optional] (see http://www.iana.org/assignments/character-sets) |
| */ |
| FileReader.prototype.readAsText = function(file, encoding) { |
| if (initRead(this, file)) { |
| return this._realReader.readAsText(file, encoding); |
| } |
| |
| // Default encoding is UTF-8 |
| var enc = encoding ? encoding : "UTF-8"; |
| var me = this; |
| var execArgs = [this._fileName, enc, file.start, file.end]; |
| |
| // Read file |
| exec( |
| // Success callback |
| function(r) { |
| // If DONE (cancelled), then don't do anything |
| if (me._readyState === FileReader.DONE) { |
| return; |
| } |
| |
| // Save result |
| me._result = r; |
| |
| // If onload callback |
| if (typeof me.onload === "function") { |
| me.onload(new ProgressEvent("load", {target:me})); |
| } |
| |
| // DONE state |
| me._readyState = FileReader.DONE; |
| |
| // If onloadend callback |
| if (typeof me.onloadend === "function") { |
| me.onloadend(new ProgressEvent("loadend", {target:me})); |
| } |
| }, |
| // Error callback |
| function(e) { |
| // If DONE (cancelled), then don't do anything |
| if (me._readyState === FileReader.DONE) { |
| return; |
| } |
| |
| // DONE state |
| me._readyState = FileReader.DONE; |
| |
| // null result |
| me._result = null; |
| |
| // Save error |
| me._error = new FileError(e); |
| |
| // If onerror callback |
| if (typeof me.onerror === "function") { |
| me.onerror(new ProgressEvent("error", {target:me})); |
| } |
| |
| // If onloadend callback |
| if (typeof me.onloadend === "function") { |
| me.onloadend(new ProgressEvent("loadend", {target:me})); |
| } |
| }, "File", "readAsText", execArgs); |
| }; |
| |
| |
| /** |
| * Read file and return data as a base64 encoded data url. |
| * A data url is of the form: |
| * data:[<mediatype>][;base64],<data> |
| * |
| * @param file {File} File object containing file properties |
| */ |
| FileReader.prototype.readAsDataURL = function(file) { |
| if (initRead(this, file)) { |
| return this._realReader.readAsDataURL(file); |
| } |
| |
| var me = this; |
| var execArgs = [this._fileName, file.start, file.end]; |
| |
| // Read file |
| exec( |
| // Success callback |
| function(r) { |
| // If DONE (cancelled), then don't do anything |
| if (me._readyState === FileReader.DONE) { |
| return; |
| } |
| |
| // DONE state |
| me._readyState = FileReader.DONE; |
| |
| // Save result |
| me._result = r; |
| |
| // If onload callback |
| if (typeof me.onload === "function") { |
| me.onload(new ProgressEvent("load", {target:me})); |
| } |
| |
| // If onloadend callback |
| if (typeof me.onloadend === "function") { |
| me.onloadend(new ProgressEvent("loadend", {target:me})); |
| } |
| }, |
| // Error callback |
| function(e) { |
| // If DONE (cancelled), then don't do anything |
| if (me._readyState === FileReader.DONE) { |
| return; |
| } |
| |
| // DONE state |
| me._readyState = FileReader.DONE; |
| |
| me._result = null; |
| |
| // Save error |
| me._error = new FileError(e); |
| |
| // If onerror callback |
| if (typeof me.onerror === "function") { |
| me.onerror(new ProgressEvent("error", {target:me})); |
| } |
| |
| // If onloadend callback |
| if (typeof me.onloadend === "function") { |
| me.onloadend(new ProgressEvent("loadend", {target:me})); |
| } |
| }, "File", "readAsDataURL", execArgs); |
| }; |
| |
| /** |
| * Read file and return data as a binary data. |
| * |
| * @param file {File} File object containing file properties |
| */ |
| FileReader.prototype.readAsBinaryString = function(file) { |
| if (initRead(this, file)) { |
| return this._realReader.readAsBinaryString(file); |
| } |
| |
| var me = this; |
| var execArgs = [this._fileName, file.start, file.end]; |
| |
| // Read file |
| exec( |
| // Success callback |
| function(r) { |
| // If DONE (cancelled), then don't do anything |
| if (me._readyState === FileReader.DONE) { |
| return; |
| } |
| |
| // DONE state |
| me._readyState = FileReader.DONE; |
| |
| me._result = r; |
| |
| // If onload callback |
| if (typeof me.onload === "function") { |
| me.onload(new ProgressEvent("load", {target:me})); |
| } |
| |
| // If onloadend callback |
| if (typeof me.onloadend === "function") { |
| me.onloadend(new ProgressEvent("loadend", {target:me})); |
| } |
| }, |
| // Error callback |
| function(e) { |
| // If DONE (cancelled), then don't do anything |
| if (me._readyState === FileReader.DONE) { |
| return; |
| } |
| |
| // DONE state |
| me._readyState = FileReader.DONE; |
| |
| me._result = null; |
| |
| // Save error |
| me._error = new FileError(e); |
| |
| // If onerror callback |
| if (typeof me.onerror === "function") { |
| me.onerror(new ProgressEvent("error", {target:me})); |
| } |
| |
| // If onloadend callback |
| if (typeof me.onloadend === "function") { |
| me.onloadend(new ProgressEvent("loadend", {target:me})); |
| } |
| }, "File", "readAsBinaryString", execArgs); |
| }; |
| |
| /** |
| * Read file and return data as a binary data. |
| * |
| * @param file {File} File object containing file properties |
| */ |
| FileReader.prototype.readAsArrayBuffer = function(file) { |
| if (initRead(this, file)) { |
| return this._realReader.readAsArrayBuffer(file); |
| } |
| |
| var me = this; |
| var execArgs = [this._fileName, file.start, file.end]; |
| |
| // Read file |
| exec( |
| // Success callback |
| function(r) { |
| // If DONE (cancelled), then don't do anything |
| if (me._readyState === FileReader.DONE) { |
| return; |
| } |
| |
| // DONE state |
| me._readyState = FileReader.DONE; |
| |
| me._result = r; |
| |
| // If onload callback |
| if (typeof me.onload === "function") { |
| me.onload(new ProgressEvent("load", {target:me})); |
| } |
| |
| // If onloadend callback |
| if (typeof me.onloadend === "function") { |
| me.onloadend(new ProgressEvent("loadend", {target:me})); |
| } |
| }, |
| // Error callback |
| function(e) { |
| // If DONE (cancelled), then don't do anything |
| if (me._readyState === FileReader.DONE) { |
| return; |
| } |
| |
| // DONE state |
| me._readyState = FileReader.DONE; |
| |
| me._result = null; |
| |
| // Save error |
| me._error = new FileError(e); |
| |
| // If onerror callback |
| if (typeof me.onerror === "function") { |
| me.onerror(new ProgressEvent("error", {target:me})); |
| } |
| |
| // If onloadend callback |
| if (typeof me.onloadend === "function") { |
| me.onloadend(new ProgressEvent("loadend", {target:me})); |
| } |
| }, "File", "readAsArrayBuffer", execArgs); |
| }; |
| |
| module.exports = FileReader; |
| |
| }); |
| |
| // file: lib/common/plugin/FileSystem.js |
| define("cordova/plugin/FileSystem", function(require, exports, module) { |
| |
| var DirectoryEntry = require('cordova/plugin/DirectoryEntry'); |
| |
| /** |
| * An interface representing a file system |
| * |
| * @constructor |
| * {DOMString} name the unique name of the file system (readonly) |
| * {DirectoryEntry} root directory of the file system (readonly) |
| */ |
| var FileSystem = function(name, root) { |
| this.name = name || null; |
| if (root) { |
| this.root = new DirectoryEntry(root.name, root.fullPath); |
| } |
| }; |
| |
| module.exports = FileSystem; |
| |
| }); |
| |
| // file: lib/common/plugin/FileTransfer.js |
| define("cordova/plugin/FileTransfer", function(require, exports, module) { |
| |
| var argscheck = require('cordova/argscheck'), |
| exec = require('cordova/exec'), |
| FileTransferError = require('cordova/plugin/FileTransferError'), |
| ProgressEvent = require('cordova/plugin/ProgressEvent'); |
| |
| function newProgressEvent(result) { |
| var pe = new ProgressEvent(); |
| pe.lengthComputable = result.lengthComputable; |
| pe.loaded = result.loaded; |
| pe.total = result.total; |
| return pe; |
| } |
| |
| function getBasicAuthHeader(urlString) { |
| var header = null; |
| |
| if (window.btoa) { |
| // parse the url using the Location object |
| var url = document.createElement('a'); |
| url.href = urlString; |
| |
| var credentials = null; |
| var protocol = url.protocol + "//"; |
| var origin = protocol + url.host; |
| |
| // check whether there are the username:password credentials in the url |
| if (url.href.indexOf(origin) !== 0) { // credentials found |
| var atIndex = url.href.indexOf("@"); |
| credentials = url.href.substring(protocol.length, atIndex); |
| } |
| |
| if (credentials) { |
| var authHeader = "Authorization"; |
| var authHeaderValue = "Basic " + window.btoa(credentials); |
| |
| header = { |
| name : authHeader, |
| value : authHeaderValue |
| }; |
| } |
| } |
| |
| return header; |
| } |
| |
| var idCounter = 0; |
| |
| /** |
| * FileTransfer uploads a file to a remote server. |
| * @constructor |
| */ |
| var FileTransfer = function() { |
| this._id = ++idCounter; |
| this.onprogress = null; // optional callback |
| }; |
| |
| /** |
| * Given an absolute file path, uploads a file on the device to a remote server |
| * using a multipart HTTP request. |
| * @param filePath {String} Full path of the file on the device |
| * @param server {String} URL of the server to receive the file |
| * @param successCallback (Function} Callback to be invoked when upload has completed |
| * @param errorCallback {Function} Callback to be invoked upon error |
| * @param options {FileUploadOptions} Optional parameters such as file name and mimetype |
| * @param trustAllHosts {Boolean} Optional trust all hosts (e.g. for self-signed certs), defaults to false |
| */ |
| FileTransfer.prototype.upload = function(filePath, server, successCallback, errorCallback, options, trustAllHosts) { |
| argscheck.checkArgs('ssFFO*', 'FileTransfer.upload', arguments); |
| // check for options |
| var fileKey = null; |
| var fileName = null; |
| var mimeType = null; |
| var params = null; |
| var chunkedMode = true; |
| var headers = null; |
| var httpMethod = null; |
| var basicAuthHeader = getBasicAuthHeader(server); |
| if (basicAuthHeader) { |
| options = options || {}; |
| options.headers = options.headers || {}; |
| options.headers[basicAuthHeader.name] = basicAuthHeader.value; |
| } |
| |
| if (options) { |
| fileKey = options.fileKey; |
| fileName = options.fileName; |
| mimeType = options.mimeType; |
| headers = options.headers; |
| httpMethod = options.httpMethod || "POST"; |
| if (httpMethod.toUpperCase() == "PUT"){ |
| httpMethod = "PUT"; |
| } else { |
| httpMethod = "POST"; |
| } |
| if (options.chunkedMode !== null || typeof options.chunkedMode != "undefined") { |
| chunkedMode = options.chunkedMode; |
| } |
| if (options.params) { |
| params = options.params; |
| } |
| else { |
| params = {}; |
| } |
| } |
| |
| var fail = errorCallback && function(e) { |
| var error = new FileTransferError(e.code, e.source, e.target, e.http_status, e.body); |
| errorCallback(error); |
| }; |
| |
| var self = this; |
| var win = function(result) { |
| if (typeof result.lengthComputable != "undefined") { |
| if (self.onprogress) { |
| self.onprogress(newProgressEvent(result)); |
| } |
| } else { |
| successCallback && successCallback(result); |
| } |
| }; |
| exec(win, fail, 'FileTransfer', 'upload', [filePath, server, fileKey, fileName, mimeType, params, trustAllHosts, chunkedMode, headers, this._id, httpMethod]); |
| }; |
| |
| /** |
| * Downloads a file form a given URL and saves it to the specified directory. |
| * @param source {String} URL of the server to receive the file |
| * @param target {String} Full path of the file on the device |
| * @param successCallback (Function} Callback to be invoked when upload has completed |
| * @param errorCallback {Function} Callback to be invoked upon error |
| * @param trustAllHosts {Boolean} Optional trust all hosts (e.g. for self-signed certs), defaults to false |
| * @param options {FileDownloadOptions} Optional parameters such as headers |
| */ |
| FileTransfer.prototype.download = function(source, target, successCallback, errorCallback, trustAllHosts, options) { |
| argscheck.checkArgs('ssFF*', 'FileTransfer.download', arguments); |
| var self = this; |
| |
| var basicAuthHeader = getBasicAuthHeader(source); |
| if (basicAuthHeader) { |
| options = options || {}; |
| options.headers = options.headers || {}; |
| options.headers[basicAuthHeader.name] = basicAuthHeader.value; |
| } |
| |
| var headers = null; |
| if (options) { |
| headers = options.headers || null; |
| } |
| |
| var win = function(result) { |
| if (typeof result.lengthComputable != "undefined") { |
| if (self.onprogress) { |
| return self.onprogress(newProgressEvent(result)); |
| } |
| } else if (successCallback) { |
| var entry = null; |
| if (result.isDirectory) { |
| entry = new (require('cordova/plugin/DirectoryEntry'))(); |
| } |
| else if (result.isFile) { |
| entry = new (require('cordova/plugin/FileEntry'))(); |
| } |
| entry.isDirectory = result.isDirectory; |
| entry.isFile = result.isFile; |
| entry.name = result.name; |
| entry.fullPath = result.fullPath; |
| successCallback(entry); |
| } |
| }; |
| |
| var fail = errorCallback && function(e) { |
| var error = new FileTransferError(e.code, e.source, e.target, e.http_status, e.body); |
| errorCallback(error); |
| }; |
| |
| exec(win, fail, 'FileTransfer', 'download', [source, target, trustAllHosts, this._id, headers]); |
| }; |
| |
| /** |
| * Aborts the ongoing file transfer on this object. The original error |
| * callback for the file transfer will be called if necessary. |
| */ |
| FileTransfer.prototype.abort = function() { |
| exec(null, null, 'FileTransfer', 'abort', [this._id]); |
| }; |
| |
| module.exports = FileTransfer; |
| |
| }); |
| |
| // file: lib/common/plugin/FileTransferError.js |
| define("cordova/plugin/FileTransferError", function(require, exports, module) { |
| |
| /** |
| * FileTransferError |
| * @constructor |
| */ |
| var FileTransferError = function(code, source, target, status, body) { |
| this.code = code || null; |
| this.source = source || null; |
| this.target = target || null; |
| this.http_status = status || null; |
| this.body = body || null; |
| }; |
| |
| FileTransferError.FILE_NOT_FOUND_ERR = 1; |
| FileTransferError.INVALID_URL_ERR = 2; |
| FileTransferError.CONNECTION_ERR = 3; |
| FileTransferError.ABORT_ERR = 4; |
| |
| module.exports = FileTransferError; |
| |
| }); |
| |
| // file: lib/common/plugin/FileUploadOptions.js |
| define("cordova/plugin/FileUploadOptions", function(require, exports, module) { |
| |
| /** |
| * Options to customize the HTTP request used to upload files. |
| * @constructor |
| * @param fileKey {String} Name of file request parameter. |
| * @param fileName {String} Filename to be used by the server. Defaults to image.jpg. |
| * @param mimeType {String} Mimetype of the uploaded file. Defaults to image/jpeg. |
| * @param params {Object} Object with key: value params to send to the server. |
| * @param headers {Object} Keys are header names, values are header values. Multiple |
| * headers of the same name are not supported. |
| */ |
| var FileUploadOptions = function(fileKey, fileName, mimeType, params, headers, httpMethod) { |
| this.fileKey = fileKey || null; |
| this.fileName = fileName || null; |
| this.mimeType = mimeType || null; |
| this.params = params || null; |
| this.headers = headers || null; |
| this.httpMethod = httpMethod || null; |
| }; |
| |
| module.exports = FileUploadOptions; |
| |
| }); |
| |
| // file: lib/common/plugin/FileUploadResult.js |
| define("cordova/plugin/FileUploadResult", function(require, exports, module) { |
| |
| /** |
| * FileUploadResult |
| * @constructor |
| */ |
| var FileUploadResult = function() { |
| this.bytesSent = 0; |
| this.responseCode = null; |
| this.response = null; |
| }; |
| |
| module.exports = FileUploadResult; |
| |
| }); |
| |
| // file: lib/common/plugin/FileWriter.js |
| define("cordova/plugin/FileWriter", function(require, exports, module) { |
| |
| var exec = require('cordova/exec'), |
| FileError = require('cordova/plugin/FileError'), |
| ProgressEvent = require('cordova/plugin/ProgressEvent'); |
| |
| /** |
| * This class writes to the mobile device file system. |
| * |
| * For Android: |
| * The root directory is the root of the file system. |
| * To write to the SD card, the file name is "sdcard/my_file.txt" |
| * |
| * @constructor |
| * @param file {File} File object containing file properties |
| * @param append if true write to the end of the file, otherwise overwrite the file |
| */ |
| var FileWriter = function(file) { |
| this.fileName = ""; |
| this.length = 0; |
| if (file) { |
| this.fileName = file.fullPath || file; |
| this.length = file.size || 0; |
| } |
| // default is to write at the beginning of the file |
| this.position = 0; |
| |
| this.readyState = 0; // EMPTY |
| |
| this.result = null; |
| |
| // Error |
| this.error = null; |
| |
| // Event handlers |
| this.onwritestart = null; // When writing starts |
| this.onprogress = null; // While writing the file, and reporting partial file data |
| this.onwrite = null; // When the write has successfully completed. |
| this.onwriteend = null; // When the request has completed (either in success or failure). |
| this.onabort = null; // When the write has been aborted. For instance, by invoking the abort() method. |
| this.onerror = null; // When the write has failed (see errors). |
| }; |
| |
| // States |
| FileWriter.INIT = 0; |
| FileWriter.WRITING = 1; |
| FileWriter.DONE = 2; |
| |
| /** |
| * Abort writing file. |
| */ |
| FileWriter.prototype.abort = function() { |
| // check for invalid state |
| if (this.readyState === FileWriter.DONE || this.readyState === FileWriter.INIT) { |
| throw new FileError(FileError.INVALID_STATE_ERR); |
| } |
| |
| // set error |
| this.error = new FileError(FileError.ABORT_ERR); |
| |
| this.readyState = FileWriter.DONE; |
| |
| // If abort callback |
| if (typeof this.onabort === "function") { |
| this.onabort(new ProgressEvent("abort", {"target":this})); |
| } |
| |
| // If write end callback |
| if (typeof this.onwriteend === "function") { |
| this.onwriteend(new ProgressEvent("writeend", {"target":this})); |
| } |
| }; |
| |
| /** |
| * Writes data to the file |
| * |
| * @param data text or blob to be written |
| */ |
| FileWriter.prototype.write = function(data) { |
| |
| var that=this; |
| var supportsBinary = (typeof window.Blob !== 'undefined' && typeof window.ArrayBuffer !== 'undefined'); |
| var isBinary; |
| |
| // Check to see if the incoming data is a blob |
| if (data instanceof File || (supportsBinary && data instanceof Blob)) { |
| var fileReader = new FileReader(); |
| fileReader.onload = function() { |
| // Call this method again, with the arraybuffer as argument |
| FileWriter.prototype.write.call(that, this.result); |
| }; |
| if (supportsBinary) { |
| fileReader.readAsArrayBuffer(data); |
| } else { |
| fileReader.readAsText(data); |
| } |
| return; |
| } |
| |
| // Mark data type for safer transport over the binary bridge |
| isBinary = supportsBinary && (data instanceof ArrayBuffer); |
| |
| // Throw an exception if we are already writing a file |
| if (this.readyState === FileWriter.WRITING) { |
| throw new FileError(FileError.INVALID_STATE_ERR); |
| } |
| |
| // WRITING state |
| this.readyState = FileWriter.WRITING; |
| |
| var me = this; |
| |
| // If onwritestart callback |
| if (typeof me.onwritestart === "function") { |
| me.onwritestart(new ProgressEvent("writestart", {"target":me})); |
| } |
| |
| // Write file |
| exec( |
| // Success callback |
| function(r) { |
| // If DONE (cancelled), then don't do anything |
| if (me.readyState === FileWriter.DONE) { |
| return; |
| } |
| |
| // position always increases by bytes written because file would be extended |
| me.position += r; |
| // The length of the file is now where we are done writing. |
| |
| me.length = me.position; |
| |
| // DONE state |
| me.readyState = FileWriter.DONE; |
| |
| // If onwrite callback |
| if (typeof me.onwrite === "function") { |
| me.onwrite(new ProgressEvent("write", {"target":me})); |
| } |
| |
| // If onwriteend callback |
| if (typeof me.onwriteend === "function") { |
| me.onwriteend(new ProgressEvent("writeend", {"target":me})); |
| } |
| }, |
| // Error callback |
| function(e) { |
| // If DONE (cancelled), then don't do anything |
| if (me.readyState === FileWriter.DONE) { |
| return; |
| } |
| |
| // DONE state |
| me.readyState = FileWriter.DONE; |
| |
| // Save error |
| me.error = new FileError(e); |
| |
| // If onerror callback |
| if (typeof me.onerror === "function") { |
| me.onerror(new ProgressEvent("error", {"target":me})); |
| } |
| |
| // If onwriteend callback |
| if (typeof me.onwriteend === "function") { |
| me.onwriteend(new ProgressEvent("writeend", {"target":me})); |
| } |
| }, "File", "write", [this.fileName, data, this.position, isBinary]); |
| }; |
| |
| /** |
| * Moves the file pointer to the location specified. |
| * |
| * If the offset is a negative number the position of the file |
| * pointer is rewound. If the offset is greater than the file |
| * size the position is set to the end of the file. |
| * |
| * @param offset is the location to move the file pointer to. |
| */ |
| FileWriter.prototype.seek = function(offset) { |
| // Throw an exception if we are already writing a file |
| if (this.readyState === FileWriter.WRITING) { |
| throw new FileError(FileError.INVALID_STATE_ERR); |
| } |
| |
| if (!offset && offset !== 0) { |
| return; |
| } |
| |
| // See back from end of file. |
| if (offset < 0) { |
| this.position = Math.max(offset + this.length, 0); |
| } |
| // Offset is bigger than file size so set position |
| // to the end of the file. |
| else if (offset > this.length) { |
| this.position = this.length; |
| } |
| // Offset is between 0 and file size so set the position |
| // to start writing. |
| else { |
| this.position = offset; |
| } |
| }; |
| |
| /** |
| * Truncates the file to the size specified. |
| * |
| * @param size to chop the file at. |
| */ |
| FileWriter.prototype.truncate = function(size) { |
| // Throw an exception if we are already writing a file |
| if (this.readyState === FileWriter.WRITING) { |
| throw new FileError(FileError.INVALID_STATE_ERR); |
| } |
| |
| // WRITING state |
| this.readyState = FileWriter.WRITING; |
| |
| var me = this; |
| |
| // If onwritestart callback |
| if (typeof me.onwritestart === "function") { |
| me.onwritestart(new ProgressEvent("writestart", {"target":this})); |
| } |
| |
| // Write file |
| exec( |
| // Success callback |
| function(r) { |
| // If DONE (cancelled), then don't do anything |
| if (me.readyState === FileWriter.DONE) { |
| return; |
| } |
| |
| // DONE state |
| me.readyState = FileWriter.DONE; |
| |
| // Update the length of the file |
| me.length = r; |
| me.position = Math.min(me.position, r); |
| |
| // If onwrite callback |
| if (typeof me.onwrite === "function") { |
| me.onwrite(new ProgressEvent("write", {"target":me})); |
| } |
| |
| // If onwriteend callback |
| if (typeof me.onwriteend === "function") { |
| me.onwriteend(new ProgressEvent("writeend", {"target":me})); |
| } |
| }, |
| // Error callback |
| function(e) { |
| // If DONE (cancelled), then don't do anything |
| if (me.readyState === FileWriter.DONE) { |
| return; |
| } |
| |
| // DONE state |
| me.readyState = FileWriter.DONE; |
| |
| // Save error |
| me.error = new FileError(e); |
| |
| // If onerror callback |
| if (typeof me.onerror === "function") { |
| me.onerror(new ProgressEvent("error", {"target":me})); |
| } |
| |
| // If onwriteend callback |
| if (typeof me.onwriteend === "function") { |
| me.onwriteend(new ProgressEvent("writeend", {"target":me})); |
| } |
| }, "File", "truncate", [this.fileName, size]); |
| }; |
| |
| module.exports = FileWriter; |
| |
| }); |
| |
| // file: lib/common/plugin/Flags.js |
| define("cordova/plugin/Flags", function(require, exports, module) { |
| |
| /** |
| * Supplies arguments to methods that lookup or create files and directories. |
| * |
| * @param create |
| * {boolean} file or directory if it doesn't exist |
| * @param exclusive |
| * {boolean} used with create; if true the command will fail if |
| * target path exists |
| */ |
| function Flags(create, exclusive) { |
| this.create = create || false; |
| this.exclusive = exclusive || false; |
| } |
| |
| module.exports = Flags; |
| |
| }); |
| |
| // file: lib/common/plugin/GlobalizationError.js |
| define("cordova/plugin/GlobalizationError", function(require, exports, module) { |
| |
| |
| /** |
| * Globalization error object |
| * |
| * @constructor |
| * @param code |
| * @param message |
| */ |
| var GlobalizationError = function(code, message) { |
| this.code = code || null; |
| this.message = message || ''; |
| }; |
| |
| // Globalization error codes |
| GlobalizationError.UNKNOWN_ERROR = 0; |
| GlobalizationError.FORMATTING_ERROR = 1; |
| GlobalizationError.PARSING_ERROR = 2; |
| GlobalizationError.PATTERN_ERROR = 3; |
| |
| module.exports = GlobalizationError; |
| |
| }); |
| |
| // file: lib/common/plugin/InAppBrowser.js |
| define("cordova/plugin/InAppBrowser", function(require, exports, module) { |
| |
| var exec = require('cordova/exec'); |
| var channel = require('cordova/channel'); |
| var modulemapper = require('cordova/modulemapper'); |
| |
| function InAppBrowser() { |
| this.channels = { |
| 'loadstart': channel.create('loadstart'), |
| 'loadstop' : channel.create('loadstop'), |
| 'loaderror' : channel.create('loaderror'), |
| 'exit' : channel.create('exit') |
| }; |
| } |
| |
| InAppBrowser.prototype = { |
| _eventHandler: function (event) { |
| if (event.type in this.channels) { |
| this.channels[event.type].fire(event); |
| } |
| }, |
| close: function (eventname) { |
| exec(null, null, "InAppBrowser", "close", []); |
| }, |
| show: function (eventname) { |
| exec(null, null, "InAppBrowser", "show", []); |
| }, |
| addEventListener: function (eventname,f) { |
| if (eventname in this.channels) { |
| this.channels[eventname].subscribe(f); |
| } |
| }, |
| removeEventListener: function(eventname, f) { |
| if (eventname in this.channels) { |
| this.channels[eventname].unsubscribe(f); |
| } |
| }, |
| |
| executeScript: function(injectDetails, cb) { |
| if (injectDetails.code) { |
| exec(cb, null, "InAppBrowser", "injectScriptCode", [injectDetails.code, !!cb]); |
| } else if (injectDetails.file) { |
| exec(cb, null, "InAppBrowser", "injectScriptFile", [injectDetails.file, !!cb]); |
| } else { |
| throw new Error('executeScript requires exactly one of code or file to be specified'); |
| } |
| }, |
| |
| insertCSS: function(injectDetails, cb) { |
| if (injectDetails.code) { |
| exec(cb, null, "InAppBrowser", "injectStyleCode", [injectDetails.code, !!cb]); |
| } else if (injectDetails.file) { |
| exec(cb, null, "InAppBrowser", "injectStyleFile", [injectDetails.file, !!cb]); |
| } else { |
| throw new Error('insertCSS requires exactly one of code or file to be specified'); |
| } |
| } |
| }; |
| |
| module.exports = function(strUrl, strWindowName, strWindowFeatures) { |
| var iab = new InAppBrowser(); |
| var cb = function(eventname) { |
| iab._eventHandler(eventname); |
| }; |
| |
| // Don't catch calls that write to existing frames (e.g. named iframes). |
| if (window.frames && window.frames[strWindowName]) { |
| var origOpenFunc = modulemapper.getOriginalSymbol(window, 'open'); |
| return origOpenFunc.apply(window, arguments); |
| } |
| |
| exec(cb, cb, "InAppBrowser", "open", [strUrl, strWindowName, strWindowFeatures]); |
| return iab; |
| }; |
| |
| |
| }); |
| |
| // file: lib/common/plugin/LocalFileSystem.js |
| define("cordova/plugin/LocalFileSystem", function(require, exports, module) { |
| |
| var exec = require('cordova/exec'); |
| |
| /** |
| * Represents a local file system. |
| */ |
| var LocalFileSystem = function() { |
| |
| }; |
| |
| LocalFileSystem.TEMPORARY = 0; //temporary, with no guarantee of persistence |
| LocalFileSystem.PERSISTENT = 1; //persistent |
| |
| module.exports = LocalFileSystem; |
| |
| }); |
| |
| // file: lib/common/plugin/Media.js |
| define("cordova/plugin/Media", function(require, exports, module) { |
| |
| var argscheck = require('cordova/argscheck'), |
| 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) { |
| argscheck.checkArgs('SFFF', 'Media', arguments); |
| 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 msgType The 'type' of update this is |
| * @param value Use of value is determined by the msgType |
| */ |
| Media.onStatus = function(id, msgType, value) { |
| |
| var media = mediaObjects[id]; |
| |
| if(media) { |
| switch(msgType) { |
| case Media.MEDIA_STATE : |
| media.statusCallback && media.statusCallback(value); |
| if(value == Media.MEDIA_STOPPED) { |
| media.successCallback && media.successCallback(); |
| } |
| break; |
| case Media.MEDIA_DURATION : |
| media._duration = value; |
| break; |
| case Media.MEDIA_ERROR : |
| media.errorCallback && media.errorCallback(value); |
| break; |
| case Media.MEDIA_POSITION : |
| media._position = Number(value); |
| break; |
| default : |
| console.error && console.error("Unhandled Media.onStatus :: " + msgType); |
| break; |
| } |
| } |
| else { |
| console.error && console.error("Received Media.onStatus callback for unknown media :: " + id); |
| } |
| |
| }; |
| |
| 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. |
| */ |
| /* |
| According to :: http://dev.w3.org/html5/spec-author-view/video.html#mediaerror |
| We should never be creating these objects, we should just implement the interface |
| which has 1 property for an instance, 'code' |
| |
| instead of doing : |
| errorCallbackFunction( new MediaError(3,'msg') ); |
| we should simply use a literal : |
| errorCallbackFunction( {'code':3} ); |
| */ |
| |
| var _MediaError = window.MediaError; |
| |
| |
| if(!_MediaError) { |
| window.MediaError = _MediaError = function(code, msg) { |
| this.code = (typeof code != 'undefined') ? code : null; |
| this.message = msg || ""; // message is NON-standard! do not use! |
| }; |
| } |
| |
| _MediaError.MEDIA_ERR_NONE_ACTIVE = _MediaError.MEDIA_ERR_NONE_ACTIVE || 0; |
| _MediaError.MEDIA_ERR_ABORTED = _MediaError.MEDIA_ERR_ABORTED || 1; |
| _MediaError.MEDIA_ERR_NETWORK = _MediaError.MEDIA_ERR_NETWORK || 2; |
| _MediaError.MEDIA_ERR_DECODE = _MediaError.MEDIA_ERR_DECODE || 3; |
| _MediaError.MEDIA_ERR_NONE_SUPPORTED = _MediaError.MEDIA_ERR_NONE_SUPPORTED || 4; |
| // TODO: MediaError.MEDIA_ERR_NONE_SUPPORTED is legacy, the W3 spec now defines it as below. |
| // as defined by http://dev.w3.org/html5/spec-author-view/video.html#error-codes |
| _MediaError.MEDIA_ERR_SRC_NOT_SUPPORTED = _MediaError.MEDIA_ERR_SRC_NOT_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 argscheck = require('cordova/argscheck'), |
| 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 acquires 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) { |
| argscheck.checkArgs('fFO', 'accelerometer.getCurrentAcceleration', arguments); |
| |
| var p; |
| var win = function(a) { |
| removeListeners(p); |
| successCallback(a); |
| }; |
| var fail = function(e) { |
| removeListeners(p); |
| errorCallback && errorCallback(e); |
| }; |
| |
| p = createCallbackPair(win, fail); |
| listeners.push(p); |
| |
| if (!running) { |
| start(); |
| } |
| }, |
| |
| /** |
| * Asynchronously acquires 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) { |
| argscheck.checkArgs('fFO', 'accelerometer.watchAcceleration', arguments); |
| // Default interval (10 sec) |
| var frequency = (options && options.frequency && typeof options.frequency == 'number') ? options.frequency : 10000; |
| |
| // 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 && 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/accelerometer/symbols.js |
| define("cordova/plugin/accelerometer/symbols", function(require, exports, module) { |
| |
| |
| var modulemapper = require('cordova/modulemapper'); |
| |
| modulemapper.defaults('cordova/plugin/Acceleration', 'Acceleration'); |
| modulemapper.defaults('cordova/plugin/accelerometer', 'navigator.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) |
| this.channels = { |
| batterystatus:cordova.addWindowEventHandler("batterystatus"), |
| batterylow:cordova.addWindowEventHandler("batterylow"), |
| batterycritical:cordova.addWindowEventHandler("batterycritical") |
| }; |
| for (var key in this.channels) { |
| this.channels[key].onHasSubscribersChange = Battery.onHasSubscribersChange; |
| } |
| }; |
| /** |
| * Event handlers for when callbacks get registered for the battery. |
| * Keep track of how many handlers we have so we can start and stop the native battery listener |
| * appropriately (and hopefully save on battery life!). |
| */ |
| Battery.onHasSubscribersChange = function() { |
| // If we just registered the first handler, make sure native listener is started. |
| if (this.numHandlers === 1 && handlers() === 1) { |
| exec(battery._status, battery._error, "Battery", "start", []); |
| } else if (handlers() === 0) { |
| exec(null, null, "Battery", "stop", []); |
| } |
| }; |
| |
| /** |
| * 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/battery/symbols.js |
| define("cordova/plugin/battery/symbols", function(require, exports, module) { |
| |
| |
| var modulemapper = require('cordova/modulemapper'); |
| |
| modulemapper.defaults('cordova/plugin/battery', 'navigator.battery'); |
| |
| }); |
| |
| // file: lib/common/plugin/camera/symbols.js |
| define("cordova/plugin/camera/symbols", function(require, exports, module) { |
| |
| |
| var modulemapper = require('cordova/modulemapper'); |
| |
| modulemapper.defaults('cordova/plugin/Camera', 'navigator.camera'); |
| modulemapper.defaults('cordova/plugin/CameraConstants', 'Camera'); |
| modulemapper.defaults('cordova/plugin/CameraPopoverOptions', 'CameraPopoverOptions'); |
| |
| }); |
| |
| // 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/capture/symbols.js |
| define("cordova/plugin/capture/symbols", function(require, exports, module) { |
| |
| var modulemapper = require('cordova/modulemapper'); |
| |
| modulemapper.clobbers('cordova/plugin/CaptureError', 'CaptureError'); |
| modulemapper.clobbers('cordova/plugin/CaptureAudioOptions', 'CaptureAudioOptions'); |
| modulemapper.clobbers('cordova/plugin/CaptureImageOptions', 'CaptureImageOptions'); |
| modulemapper.clobbers('cordova/plugin/CaptureVideoOptions', 'CaptureVideoOptions'); |
| modulemapper.clobbers('cordova/plugin/ConfigurationData', 'ConfigurationData'); |
| modulemapper.clobbers('cordova/plugin/MediaFile', 'MediaFile'); |
| modulemapper.clobbers('cordova/plugin/MediaFileData', 'MediaFileData'); |
| modulemapper.clobbers('cordova/plugin/capture', 'navigator.device.capture'); |
| |
| }); |
| |
| // file: lib/common/plugin/compass.js |
| define("cordova/plugin/compass", function(require, exports, module) { |
| |
| var argscheck = require('cordova/argscheck'), |
| 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) { |
| argscheck.checkArgs('fFO', 'compass.getCurrentHeading', arguments); |
| |
| var win = function(result) { |
| var ch = new CompassHeading(result.magneticHeading, result.trueHeading, result.headingAccuracy, result.timestamp); |
| successCallback(ch); |
| }; |
| var fail = errorCallback && 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) { |
| argscheck.checkArgs('fFO', 'compass.watchHeading', arguments); |
| // Default interval (100 msec) |
| var frequency = (options !== undefined && options.frequency !== undefined) ? options.frequency : 100; |
| var filter = (options !== undefined && options.filter !== undefined) ? options.filter : 0; |
| |
| 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/compass/symbols.js |
| define("cordova/plugin/compass/symbols", function(require, exports, module) { |
| |
| |
| var modulemapper = require('cordova/modulemapper'); |
| |
| modulemapper.clobbers('cordova/plugin/CompassHeading', 'CompassHeading'); |
| modulemapper.clobbers('cordova/plugin/CompassError', 'CompassError'); |
| modulemapper.clobbers('cordova/plugin/compass', 'navigator.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 = logger.format.apply(logger.format, [].slice.call(arguments, 1)); |
| 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 wrappedOrigCall(orgFunc, newFunc) { |
| return function() { |
| var args = [].slice.call(arguments); |
| try { orgFunc.apply(WinConsole, args); } catch (e) {} |
| try { newFunc.apply(console, args); } catch (e) {} |
| }; |
| } |
| |
| //------------------------------------------------------------------------------ |
| // For every function that exists in the original console object, that |
| // also exists in the new console object, wrap the new console method |
| // with one that calls both |
| //------------------------------------------------------------------------------ |
| for (var key in console) { |
| if (typeof WinConsole[key] == "function") { |
| console[key] = wrappedOrigCall(WinConsole[key], console[key]); |
| } |
| } |
| |
| }); |
| |
| // file: lib/common/plugin/contacts.js |
| define("cordova/plugin/contacts", function(require, exports, module) { |
| |
| var argscheck = require('cordova/argscheck'), |
| 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) { |
| argscheck.checkArgs('afFO', 'contacts.find', arguments); |
| if (!fields.length) { |
| errorCB && 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) { |
| argscheck.checkArgs('O', 'contacts.create', arguments); |
| var contact = new Contact(); |
| for (var i in properties) { |
| if (typeof contact[i] !== 'undefined' && properties.hasOwnProperty(i)) { |
| contact[i] = properties[i]; |
| } |
| } |
| return contact; |
| } |
| }; |
| |
| module.exports = contacts; |
| |
| }); |
| |
| // file: lib/common/plugin/contacts/symbols.js |
| define("cordova/plugin/contacts/symbols", function(require, exports, module) { |
| |
| |
| var modulemapper = require('cordova/modulemapper'); |
| |
| modulemapper.clobbers('cordova/plugin/contacts', 'navigator.contacts'); |
| modulemapper.clobbers('cordova/plugin/Contact', 'Contact'); |
| modulemapper.clobbers('cordova/plugin/ContactAddress', 'ContactAddress'); |
| modulemapper.clobbers('cordova/plugin/ContactError', 'ContactError'); |
| modulemapper.clobbers('cordova/plugin/ContactField', 'ContactField'); |
| modulemapper.clobbers('cordova/plugin/ContactFindOptions', 'ContactFindOptions'); |
| modulemapper.clobbers('cordova/plugin/ContactName', 'ContactName'); |
| modulemapper.clobbers('cordova/plugin/ContactOrganization', 'ContactOrganization'); |
| |
| }); |
| |
| // file: lib/common/plugin/device.js |
| define("cordova/plugin/device", function(require, exports, module) { |
| |
| var argscheck = require('cordova/argscheck'), |
| 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.uuid = null; |
| this.cordova = null; |
| this.model = null; |
| |
| var me = this; |
| |
| channel.onCordovaReady.subscribe(function() { |
| me.getInfo(function(info) { |
| var buildLabel = info.cordova; |
| if (buildLabel != CORDOVA_JS_BUILD_LABEL) { |
| buildLabel += ' JS=' + CORDOVA_JS_BUILD_LABEL; |
| } |
| me.available = true; |
| me.platform = info.platform; |
| me.version = info.version; |
| me.uuid = info.uuid; |
| me.cordova = buildLabel; |
| me.model = info.model; |
| 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) { |
| argscheck.checkArgs('fF', 'Device.getInfo', arguments); |
| exec(successCallback, errorCallback, "Device", "getDeviceInfo", []); |
| }; |
| |
| module.exports = new Device(); |
| |
| }); |
| |
| // file: lib/tizen/plugin/device/symbols.js |
| define("cordova/plugin/device/symbols", function(require, exports, module) { |
| |
| |
| var modulemapper = require('cordova/modulemapper'); |
| |
| modulemapper.clobbers('cordova/plugin/tizen/Device', 'device'); |
| modulemapper.merges('cordova/plugin/tizen/Device', 'navigator.device'); |
| |
| }); |
| |
| // file: lib/common/plugin/echo.js |
| define("cordova/plugin/echo", function(require, exports, module) { |
| |
| var exec = require('cordova/exec'), |
| utils = require('cordova/utils'); |
| |
| /** |
| * Sends the given message through exec() to the Echo plugin, which sends it back to the successCallback. |
| * @param successCallback invoked with a FileSystem object |
| * @param errorCallback invoked if error occurs retrieving file system |
| * @param message The string to be echoed. |
| * @param forceAsync Whether to force an async return value (for testing native->js bridge). |
| */ |
| module.exports = function(successCallback, errorCallback, message, forceAsync) { |
| var action = 'echo'; |
| var messageIsMultipart = (utils.typeName(message) == "Array"); |
| var args = messageIsMultipart ? message : [message]; |
| |
| if (utils.typeName(message) == 'ArrayBuffer') { |
| if (forceAsync) { |
| console.warn('Cannot echo ArrayBuffer with forced async, falling back to sync.'); |
| } |
| action += 'ArrayBuffer'; |
| } else if (messageIsMultipart) { |
| if (forceAsync) { |
| console.warn('Cannot echo MultiPart Array with forced async, falling back to sync.'); |
| } |
| action += 'MultiPart'; |
| } else if (forceAsync) { |
| action += 'Async'; |
| } |
| |
| exec(successCallback, errorCallback, "Echo", action, args); |
| }; |
| |
| |
| }); |
| |
| // file: lib/tizen/plugin/file/symbols.js |
| define("cordova/plugin/file/symbols", function(require, exports, module) { |
| |
| |
| var modulemapper = require('cordova/modulemapper'), |
| symbolshelper = require('cordova/plugin/file/symbolshelper'); |
| |
| symbolshelper(modulemapper.defaults); |
| modulemapper.clobbers('cordova/plugin/File', 'File'); |
| modulemapper.clobbers('cordova/plugin/FileReader', 'FileReader'); |
| modulemapper.clobbers('cordova/plugin/FileError', 'FileError'); |
| |
| }); |
| |
| // file: lib/common/plugin/file/symbolshelper.js |
| define("cordova/plugin/file/symbolshelper", function(require, exports, module) { |
| |
| module.exports = function(exportFunc) { |
| exportFunc('cordova/plugin/DirectoryEntry', 'DirectoryEntry'); |
| exportFunc('cordova/plugin/DirectoryReader', 'DirectoryReader'); |
| exportFunc('cordova/plugin/Entry', 'Entry'); |
| exportFunc('cordova/plugin/File', 'File'); |
| exportFunc('cordova/plugin/FileEntry', 'FileEntry'); |
| exportFunc('cordova/plugin/FileError', 'FileError'); |
| exportFunc('cordova/plugin/FileReader', 'FileReader'); |
| exportFunc('cordova/plugin/FileSystem', 'FileSystem'); |
| exportFunc('cordova/plugin/FileUploadOptions', 'FileUploadOptions'); |
| exportFunc('cordova/plugin/FileUploadResult', 'FileUploadResult'); |
| exportFunc('cordova/plugin/FileWriter', 'FileWriter'); |
| exportFunc('cordova/plugin/Flags', 'Flags'); |
| exportFunc('cordova/plugin/LocalFileSystem', 'LocalFileSystem'); |
| exportFunc('cordova/plugin/Metadata', 'Metadata'); |
| exportFunc('cordova/plugin/ProgressEvent', 'ProgressEvent'); |
| exportFunc('cordova/plugin/requestFileSystem', 'requestFileSystem'); |
| exportFunc('cordova/plugin/resolveLocalFileSystemURI', 'resolveLocalFileSystemURI'); |
| }; |
| |
| }); |
| |
| // file: lib/common/plugin/filetransfer/symbols.js |
| define("cordova/plugin/filetransfer/symbols", function(require, exports, module) { |
| |
| |
| var modulemapper = require('cordova/modulemapper'); |
| |
| modulemapper.clobbers('cordova/plugin/FileTransfer', 'FileTransfer'); |
| modulemapper.clobbers('cordova/plugin/FileTransferError', 'FileTransferError'); |
| |
| }); |
| |
| // file: lib/common/plugin/geolocation.js |
| define("cordova/plugin/geolocation", function(require, exports, module) { |
| |
| var argscheck = require('cordova/argscheck'), |
| 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 acquires the current position. |
| * |
| * @param {Function} successCallback The function to call when the position data is available |
| * @param {Function} errorCallback The function to call when there is an error getting the heading position. (OPTIONAL) |
| * @param {PositionOptions} options The options for getting the position data. (OPTIONAL) |
| */ |
| getCurrentPosition:function(successCallback, errorCallback, options) { |
| argscheck.checkArgs('fFO', 'geolocation.getCurrentPosition', arguments); |
| options = parseParameters(options); |
| |
| // Timer var that will fire an error callback if no position is retrieved from native |
| // before the "timeout" param provided expires |
| var timeoutTimer = {timer:null}; |
| |
| var win = function(p) { |
| clearTimeout(timeoutTimer.timer); |
| if (!(timeoutTimer.timer)) { |
| // Timeout already happened, or native fired error callback for |
| // this geo request. |
| // Don't continue with success callback. |
| return; |
| } |
| var pos = new Position( |
| { |
| latitude:p.latitude, |
| longitude:p.longitude, |
| altitude:p.altitude, |
| accuracy:p.accuracy, |
| heading:p.heading, |
| velocity:p.velocity, |
| altitudeAccuracy:p.altitudeAccuracy |
| }, |
| (p.timestamp === undefined ? new Date() : ((p.timestamp instanceof Date) ? p.timestamp : new Date(p.timestamp))) |
| ); |
| geolocation.lastPosition = pos; |
| successCallback(pos); |
| }; |
| var fail = function(e) { |
| clearTimeout(timeoutTimer.timer); |
| timeoutTimer.timer = null; |
| var err = new PositionError(e.code, e.message); |
| if (errorCallback) { |
| errorCallback(err); |
| } |
| }; |
| |
| // Check our cached position, if its timestamp difference with current time is less than the maximumAge, then just |
| // fire the success callback with the cached position. |
| if (geolocation.lastPosition && options.maximumAge && (((new Date()).getTime() - geolocation.lastPosition.timestamp.getTime()) <= options.maximumAge)) { |
| successCallback(geolocation.lastPosition); |
| // If the cached position check failed and the timeout was set to 0, error out with a TIMEOUT error object. |
| } else if (options.timeout === 0) { |
| fail({ |
| code:PositionError.TIMEOUT, |
| message:"timeout value in PositionOptions set to 0 and no cached Position object available, or cached Position object's age exceeds provided PositionOptions' maximumAge parameter." |
| }); |
| // Otherwise we have to call into native to retrieve a position. |
| } else { |
| if (options.timeout !== Infinity) { |
| // If the timeout value was not set to Infinity (default), then |
| // set up a timeout function that will fire the error callback |
| // if no successful position was retrieved before timeout expired. |
| timeoutTimer.timer = createTimeout(fail, options.timeout); |
| } else { |
| // This is here so the check in the win function doesn't mess stuff up |
| // may seem weird but this guarantees timeoutTimer is |
| // always truthy before we call into native |
| timeoutTimer.timer = true; |
| } |
| 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) { |
| argscheck.checkArgs('fFO', 'geolocation.getCurrentPosition', arguments); |
| 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].timer); |
| var err = new PositionError(e.code, e.message); |
| if (errorCallback) { |
| errorCallback(err); |
| } |
| }; |
| |
| var win = function(p) { |
| clearTimeout(timers[id].timer); |
| if (options.timeout !== Infinity) { |
| timers[id].timer = 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].timer); |
| timers[id].timer = false; |
| exec(null, null, "Geolocation", "clearWatch", [id]); |
| } |
| } |
| }; |
| |
| module.exports = geolocation; |
| |
| }); |
| |
| // file: lib/common/plugin/geolocation/symbols.js |
| define("cordova/plugin/geolocation/symbols", function(require, exports, module) { |
| |
| |
| var modulemapper = require('cordova/modulemapper'); |
| |
| modulemapper.defaults('cordova/plugin/geolocation', 'navigator.geolocation'); |
| modulemapper.clobbers('cordova/plugin/PositionError', 'PositionError'); |
| modulemapper.clobbers('cordova/plugin/Position', 'Position'); |
| modulemapper.clobbers('cordova/plugin/Coordinates', 'Coordinates'); |
| |
| }); |
| |
| // file: lib/common/plugin/globalization.js |
| define("cordova/plugin/globalization", function(require, exports, module) { |
| |
| var argscheck = require('cordova/argscheck'), |
| exec = require('cordova/exec'), |
| GlobalizationError = require('cordova/plugin/GlobalizationError'); |
| |
| var globalization = { |
| |
| /** |
| * Returns the string identifier for the client's current language. |
| * It returns the language identifier string to the successCB callback with a |
| * properties object as a parameter. If there is an error getting the language, |
| * then the errorCB callback is invoked. |
| * |
| * @param {Function} successCB |
| * @param {Function} errorCB |
| * |
| * @return Object.value {String}: The language identifier |
| * |
| * @error GlobalizationError.UNKNOWN_ERROR |
| * |
| * Example |
| * globalization.getPreferredLanguage(function (language) {alert('language:' + language.value + '\n');}, |
| * function () {}); |
| */ |
| getPreferredLanguage:function(successCB, failureCB) { |
| argscheck.checkArgs('fF', 'Globalization.getPreferredLanguage', arguments); |
| exec(successCB, failureCB, "Globalization","getPreferredLanguage", []); |
| }, |
| |
| /** |
| * Returns the string identifier for the client's current locale setting. |
| * It returns the locale identifier string to the successCB callback with a |
| * properties object as a parameter. If there is an error getting the locale, |
| * then the errorCB callback is invoked. |
| * |
| * @param {Function} successCB |
| * @param {Function} errorCB |
| * |
| * @return Object.value {String}: The locale identifier |
| * |
| * @error GlobalizationError.UNKNOWN_ERROR |
| * |
| * Example |
| * globalization.getLocaleName(function (locale) {alert('locale:' + locale.value + '\n');}, |
| * function () {}); |
| */ |
| getLocaleName:function(successCB, failureCB) { |
| argscheck.checkArgs('fF', 'Globalization.getLocaleName', arguments); |
| exec(successCB, failureCB, "Globalization","getLocaleName", []); |
| }, |
| |
| |
| /** |
| * Returns a date formatted as a string according to the client's user preferences and |
| * calendar using the time zone of the client. It returns the formatted date string to the |
| * successCB callback with a properties object as a parameter. If there is an error |
| * formatting the date, then the errorCB callback is invoked. |
| * |
| * The defaults are: formatLenght="short" and selector="date and time" |
| * |
| * @param {Date} date |
| * @param {Function} successCB |
| * @param {Function} errorCB |
| * @param {Object} options {optional} |
| * formatLength {String}: 'short', 'medium', 'long', or 'full' |
| * selector {String}: 'date', 'time', or 'date and time' |
| * |
| * @return Object.value {String}: The localized date string |
| * |
| * @error GlobalizationError.FORMATTING_ERROR |
| * |
| * Example |
| * globalization.dateToString(new Date(), |
| * function (date) {alert('date:' + date.value + '\n');}, |
| * function (errorCode) {alert(errorCode);}, |
| * {formatLength:'short'}); |
| */ |
| dateToString:function(date, successCB, failureCB, options) { |
| argscheck.checkArgs('dfFO', 'Globalization.dateToString', arguments); |
| var dateValue = date.valueOf(); |
| exec(successCB, failureCB, "Globalization", "dateToString", [{"date": dateValue, "options": options}]); |
| }, |
| |
| |
| /** |
| * Parses a date formatted as a string according to the client's user |
| * preferences and calendar using the time zone of the client and returns |
| * the corresponding date object. It returns the date to the successCB |
| * callback with a properties object as a parameter. If there is an error |
| * parsing the date string, then the errorCB callback is invoked. |
| * |
| * The defaults are: formatLength="short" and selector="date and time" |
| * |
| * @param {String} dateString |
| * @param {Function} successCB |
| * @param {Function} errorCB |
| * @param {Object} options {optional} |
| * formatLength {String}: 'short', 'medium', 'long', or 'full' |
| * selector {String}: 'date', 'time', or 'date and time' |
| * |
| * @return Object.year {Number}: The four digit year |
| * Object.month {Number}: The month from (0 - 11) |
| * Object.day {Number}: The day from (1 - 31) |
| * Object.hour {Number}: The hour from (0 - 23) |
| * Object.minute {Number}: The minute from (0 - 59) |
| * Object.second {Number}: The second from (0 - 59) |
| * Object.millisecond {Number}: The milliseconds (from 0 - 999), |
| * not available on all platforms |
| * |
| * @error GlobalizationError.PARSING_ERROR |
| * |
| * Example |
| * globalization.stringToDate('4/11/2011', |
| * function (date) { alert('Month:' + date.month + '\n' + |
| * 'Day:' + date.day + '\n' + |
| * 'Year:' + date.year + '\n');}, |
| * function (errorCode) {alert(errorCode);}, |
| * {selector:'date'}); |
| */ |
| stringToDate:function(dateString, successCB, failureCB, options) { |
| argscheck.checkArgs('sfFO', 'Globalization.stringToDate', arguments); |
| exec(successCB, failureCB, "Globalization", "stringToDate", [{"dateString": dateString, "options": options}]); |
| }, |
| |
| |
| /** |
| * Returns a pattern string for formatting and parsing dates according to the client's |
| * user preferences. It returns the pattern to the successCB callback with a |
| * properties object as a parameter. If there is an error obtaining the pattern, |
| * then the errorCB callback is invoked. |
| * |
| * The defaults are: formatLength="short" and selector="date and time" |
| * |
| * @param {Function} successCB |
| * @param {Function} errorCB |
| * @param {Object} options {optional} |
| * formatLength {String}: 'short', 'medium', 'long', or 'full' |
| * selector {String}: 'date', 'time', or 'date and time' |
| * |
| * @return Object.pattern {String}: The date and time pattern for formatting and parsing dates. |
| * The patterns follow Unicode Technical Standard #35 |
| * http://unicode.org/reports/tr35/tr35-4.html |
| * Object.timezone {String}: The abbreviated name of the time zone on the client |
| * Object.utc_offset {Number}: The current difference in seconds between the client's |
| * time zone and coordinated universal time. |
| * Object.dst_offset {Number}: The current daylight saving time offset in seconds |
| * between the client's non-daylight saving's time zone |
| * and the client's daylight saving's time zone. |
| * |
| * @error GlobalizationError.PATTERN_ERROR |
| * |
| * Example |
| * globalization.getDatePattern( |
| * function (date) {alert('pattern:' + date.pattern + '\n');}, |
| * function () {}, |
| * {formatLength:'short'}); |
| */ |
| getDatePattern:function(successCB, failureCB, options) { |
| argscheck.checkArgs('fFO', 'Globalization.getDatePattern', arguments); |
| exec(successCB, failureCB, "Globalization", "getDatePattern", [{"options": options}]); |
| }, |
| |
| |
| /** |
| * Returns an array of either the names of the months or days of the week |
| * according to the client's user preferences and calendar. It returns the array of names to the |
| * successCB callback with a properties object as a parameter. If there is an error obtaining the |
| * names, then the errorCB callback is invoked. |
| * |
| * The defaults are: type="wide" and item="months" |
| * |
| * @param {Function} successCB |
| * @param {Function} errorCB |
| * @param {Object} options {optional} |
| * type {String}: 'narrow' or 'wide' |
| * item {String}: 'months', or 'days' |
| * |
| * @return Object.value {Array{String}}: The array of names starting from either |
| * the first month in the year or the |
| * first day of the week. |
| * @error GlobalizationError.UNKNOWN_ERROR |
| * |
| * Example |
| * globalization.getDateNames(function (names) { |
| * for(var i = 0; i < names.value.length; i++) { |
| * alert('Month:' + names.value[i] + '\n');}}, |
| * function () {}); |
| */ |
| getDateNames:function(successCB, failureCB, options) { |
| argscheck.checkArgs('fFO', 'Globalization.getDateNames', arguments); |
| exec(successCB, failureCB, "Globalization", "getDateNames", [{"options": options}]); |
| }, |
| |
| /** |
| * Returns whether daylight savings time is in effect for a given date using the client's |
| * time zone and calendar. It returns whether or not daylight savings time is in effect |
| * to the successCB callback with a properties object as a parameter. If there is an error |
| * reading the date, then the errorCB callback is invoked. |
| * |
| * @param {Date} date |
| * @param {Function} successCB |
| * @param {Function} errorCB |
| * |
| * @return Object.dst {Boolean}: The value "true" indicates that daylight savings time is |
| * in effect for the given date and "false" indicate that it is not. |
| * |
| * @error GlobalizationError.UNKNOWN_ERROR |
| * |
| * Example |
| * globalization.isDayLightSavingsTime(new Date(), |
| * function (date) {alert('dst:' + date.dst + '\n');} |
| * function () {}); |
| */ |
| isDayLightSavingsTime:function(date, successCB, failureCB) { |
| argscheck.checkArgs('dfF', 'Globalization.isDayLightSavingsTime', arguments); |
| var dateValue = date.valueOf(); |
| exec(successCB, failureCB, "Globalization", "isDayLightSavingsTime", [{"date": dateValue}]); |
| }, |
| |
| /** |
| * Returns the first day of the week according to the client's user preferences and calendar. |
| * The days of the week are numbered starting from 1 where 1 is considered to be Sunday. |
| * It returns the day to the successCB callback with a properties object as a parameter. |
| * If there is an error obtaining the pattern, then the errorCB callback is invoked. |
| * |
| * @param {Function} successCB |
| * @param {Function} errorCB |
| * |
| * @return Object.value {Number}: The number of the first day of the week. |
| * |
| * @error GlobalizationError.UNKNOWN_ERROR |
| * |
| * Example |
| * globalization.getFirstDayOfWeek(function (day) |
| * { alert('Day:' + day.value + '\n');}, |
| * function () {}); |
| */ |
| getFirstDayOfWeek:function(successCB, failureCB) { |
| argscheck.checkArgs('fF', 'Globalization.getFirstDayOfWeek', arguments); |
| exec(successCB, failureCB, "Globalization", "getFirstDayOfWeek", []); |
| }, |
| |
| |
| /** |
| * Returns a number formatted as a string according to the client's user preferences. |
| * It returns the formatted number string to the successCB callback with a properties object as a |
| * parameter. If there is an error formatting the number, then the errorCB callback is invoked. |
| * |
| * The defaults are: type="decimal" |
| * |
| * @param {Number} number |
| * @param {Function} successCB |
| * @param {Function} errorCB |
| * @param {Object} options {optional} |
| * type {String}: 'decimal', "percent", or 'currency' |
| * |
| * @return Object.value {String}: The formatted number string. |
| * |
| * @error GlobalizationError.FORMATTING_ERROR |
| * |
| * Example |
| * globalization.numberToString(3.25, |
| * function (number) {alert('number:' + number.value + '\n');}, |
| * function () {}, |
| * {type:'decimal'}); |
| */ |
| numberToString:function(number, successCB, failureCB, options) { |
| argscheck.checkArgs('nfFO', 'Globalization.numberToString', arguments); |
| exec(successCB, failureCB, "Globalization", "numberToString", [{"number": number, "options": options}]); |
| }, |
| |
| /** |
| * Parses a number formatted as a string according to the client's user preferences and |
| * returns the corresponding number. It returns the number to the successCB callback with a |
| * properties object as a parameter. If there is an error parsing the number string, then |
| * the errorCB callback is invoked. |
| * |
| * The defaults are: type="decimal" |
| * |
| * @param {String} numberString |
| * @param {Function} successCB |
| * @param {Function} errorCB |
| * @param {Object} options {optional} |
| * type {String}: 'decimal', "percent", or 'currency' |
| * |
| * @return Object.value {Number}: The parsed number. |
| * |
| * @error GlobalizationError.PARSING_ERROR |
| * |
| * Example |
| * globalization.stringToNumber('1234.56', |
| * function (number) {alert('Number:' + number.value + '\n');}, |
| * function () { alert('Error parsing number');}); |
| */ |
| stringToNumber:function(numberString, successCB, failureCB, options) { |
| argscheck.checkArgs('sfFO', 'Globalization.stringToNumber', arguments); |
| exec(successCB, failureCB, "Globalization", "stringToNumber", [{"numberString": numberString, "options": options}]); |
| }, |
| |
| /** |
| * Returns a pattern string for formatting and parsing numbers according to the client's user |
| * preferences. It returns the pattern to the successCB callback with a properties object as a |
| * parameter. If there is an error obtaining the pattern, then the errorCB callback is invoked. |
| * |
| * The defaults are: type="decimal" |
| * |
| * @param {Function} successCB |
| * @param {Function} errorCB |
| * @param {Object} options {optional} |
| * type {String}: 'decimal', "percent", or 'currency' |
| * |
| * @return Object.pattern {String}: The number pattern for formatting and parsing numbers. |
| * The patterns follow Unicode Technical Standard #35. |
| * http://unicode.org/reports/tr35/tr35-4.html |
| * Object.symbol {String}: The symbol to be used when formatting and parsing |
| * e.g., percent or currency symbol. |
| * Object.fraction {Number}: The number of fractional digits to use when parsing and |
| * formatting numbers. |
| * Object.rounding {Number}: The rounding increment to use when parsing and formatting. |
| * Object.positive {String}: The symbol to use for positive numbers when parsing and formatting. |
| * Object.negative: {String}: The symbol to use for negative numbers when parsing and formatting. |
| * Object.decimal: {String}: The decimal symbol to use for parsing and formatting. |
| * Object.grouping: {String}: The grouping symbol to use for parsing and formatting. |
| * |
| * @error GlobalizationError.PATTERN_ERROR |
| * |
| * Example |
| * globalization.getNumberPattern( |
| * function (pattern) {alert('Pattern:' + pattern.pattern + '\n');}, |
| * function () {}); |
| */ |
| getNumberPattern:function(successCB, failureCB, options) { |
| argscheck.checkArgs('fFO', 'Globalization.getNumberPattern', arguments); |
| exec(successCB, failureCB, "Globalization", "getNumberPattern", [{"options": options}]); |
| }, |
| |
| /** |
| * Returns a pattern string for formatting and parsing currency values according to the client's |
| * user preferences and ISO 4217 currency code. It returns the pattern to the successCB callback with a |
| * properties object as a parameter. If there is an error obtaining the pattern, then the errorCB |
| * callback is invoked. |
| * |
| * @param {String} currencyCode |
| * @param {Function} successCB |
| * @param {Function} errorCB |
| * |
| * @return Object.pattern {String}: The currency pattern for formatting and parsing currency values. |
| * The patterns follow Unicode Technical Standard #35 |
| * http://unicode.org/reports/tr35/tr35-4.html |
| * Object.code {String}: The ISO 4217 currency code for the pattern. |
| * Object.fraction {Number}: The number of fractional digits to use when parsing and |
| * formatting currency. |
| * Object.rounding {Number}: The rounding increment to use when parsing and formatting. |
| * Object.decimal: {String}: The decimal symbol to use for parsing and formatting. |
| * Object.grouping: {String}: The grouping symbol to use for parsing and formatting. |
| * |
| * @error GlobalizationError.FORMATTING_ERROR |
| * |
| * Example |
| * globalization.getCurrencyPattern('EUR', |
| * function (currency) {alert('Pattern:' + currency.pattern + '\n');} |
| * function () {}); |
| */ |
| getCurrencyPattern:function(currencyCode, successCB, failureCB) { |
| argscheck.checkArgs('sfF', 'Globalization.getCurrencyPattern', arguments); |
| exec(successCB, failureCB, "Globalization", "getCurrencyPattern", [{"currencyCode": currencyCode}]); |
| } |
| |
| }; |
| |
| module.exports = globalization; |
| |
| }); |
| |
| // file: lib/tizen/plugin/globalization/symbols.js |
| define("cordova/plugin/globalization/symbols", function(require, exports, module) { |
| |
| |
| var modulemapper = require('cordova/modulemapper'); |
| |
| modulemapper.merges('cordova/plugin/tizen/Globalization', 'navigator.globalization'); |
| |
| }); |
| |
| // 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 UseLogger = true; |
| var Queued = []; |
| var DeviceReady = false; |
| var CurrentLevel; |
| |
| var originalConsole = console; |
| |
| /** |
| * 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. |
| */ |
| 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; |
| }; |
| |
| /** |
| * Getter/Setter for the useLogger functionality |
| * |
| * When useLogger is true, the logger will log via the |
| * native Logger plugin. |
| */ |
| logger.useLogger = function (value) { |
| // Enforce boolean |
| if (arguments.length) UseLogger = !!value; |
| return UseLogger; |
| }; |
| |
| /** |
| * 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 /* , ... */) { |
| // format the message with the parameters |
| var formatArgs = [].slice.call(arguments, 1); |
| var message = logger.format.apply(logger.format, 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; |
| } |
| |
| // Log using the native logger if that is enabled |
| if (UseLogger) { |
| exec(null, null, "Logger", "logLevel", [level, message]); |
| } |
| |
| // Log using the console if that is enabled |
| if (UseConsole) { |
| // 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: originalConsole.log(message); break; |
| case logger.ERROR: originalConsole.log("ERROR: " + message); break; |
| case logger.WARN: originalConsole.log("WARN: " + message); break; |
| case logger.INFO: originalConsole.log("INFO: " + message); break; |
| case logger.DEBUG: originalConsole.log("DEBUG: " + message); break; |
| } |
| } |
| }; |
| |
| |
| /** |
| * Formats a string and arguments following it ala console.log() |
| * |
| * Any remaining arguments will be appended to the formatted string. |
| * |
| * for rationale, see FireBug's Console API: |
| * http://getfirebug.com/wiki/index.php/Console_API |
| */ |
| logger.format = function(formatString, args) { |
| return __format(arguments[0], [].slice.call(arguments,1)).join(' '); |
| }; |
| |
| |
| //------------------------------------------------------------------------------ |
| /** |
| * 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(). |
| * |
| * Returns an array containing the formatted string and any remaining |
| * arguments. |
| */ |
| function __format(formatString, args) { |
| if (formatString === null || formatString === undefined) return [""]; |
| if (arguments.length == 1) return [formatString.toString()]; |
| |
| if (typeof formatString != "string") |
| formatString = formatString.toString(); |
| |
| var pattern = /(.*?)%(.)(.*)/; |
| var rest = formatString; |
| var result = []; |
| |
| while (args.length) { |
| var match = pattern.exec(rest); |
| if (!match) break; |
| |
| var arg = args.shift(); |
| 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); |
| |
| var remainingArgs = [].slice.call(args); |
| remainingArgs.unshift(result.join('')); |
| return remainingArgs; |
| } |
| |
| 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(); |
| } |
| |
| |
| //------------------------------------------------------------------------------ |
| // 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/logger/symbols.js |
| define("cordova/plugin/logger/symbols", function(require, exports, module) { |
| |
| |
| var modulemapper = require('cordova/modulemapper'); |
| |
| modulemapper.clobbers('cordova/plugin/logger', 'cordova.logger'); |
| |
| }); |
| |
| // file: lib/tizen/plugin/media/symbols.js |
| define("cordova/plugin/media/symbols", function(require, exports, module) { |
| |
| |
| var modulemapper = require('cordova/modulemapper'); |
| |
| modulemapper.defaults('cordova/plugin/Media', 'Media'); |
| modulemapper.defaults('cordova/plugin/MediaError', 'MediaError'); |
| modulemapper.merges('cordova/plugin/tizen/MediaError', 'MediaError'); |
| |
| }); |
| |
| // 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'), |
| utils = require('cordova/utils'); |
| |
| // Link the onLine property with the Cordova-supplied network info. |
| // This works because we clobber the naviagtor object with our own |
| // object in bootstrap.js. |
| if (typeof navigator != 'undefined') { |
| utils.defineGetter(navigator, 'onLine', function() { |
| return this.connection.type != 'none'; |
| }); |
| } |
| |
| function NetworkConnection() { |
| this.type = 'unknown'; |
| } |
| |
| /** |
| * 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) { |
| exec(successCallback, errorCallback, "NetworkStatus", "getConnectionInfo", []); |
| }; |
| |
| var me = new NetworkConnection(); |
| var timerId = null; |
| var timeout = 500; |
| |
| channel.onCordovaReady.subscribe(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 |
| timerId = setTimeout(function(){ |
| cordova.fireDocumentEvent("offline"); |
| timerId = null; |
| }, timeout); |
| } else { |
| // If there is a current offline event pending clear it |
| if (timerId !== null) { |
| clearTimeout(timerId); |
| timerId = null; |
| } |
| cordova.fireDocumentEvent("online"); |
| } |
| |
| // should only fire this once |
| if (channel.onCordovaConnectionReady.state !== 2) { |
| channel.onCordovaConnectionReady.fire(); |
| } |
| }, |
| function (e) { |
| // If we can't get the network info we should still tell Cordova |
| // to fire the deviceready event. |
| if (channel.onCordovaConnectionReady.state !== 2) { |
| channel.onCordovaConnectionReady.fire(); |
| } |
| console.log("Error initializing Network Connection: " + e); |
| }); |
| }); |
| |
| module.exports = me; |
| |
| }); |
| |
| // file: lib/common/plugin/networkstatus/symbols.js |
| define("cordova/plugin/networkstatus/symbols", function(require, exports, module) { |
| |
| |
| var modulemapper = require('cordova/modulemapper'); |
| |
| modulemapper.clobbers('cordova/plugin/network', 'navigator.network.connection', 'navigator.network.connection is deprecated. Use navigator.connection instead.'); |
| modulemapper.clobbers('cordova/plugin/network', 'navigator.connection'); |
| modulemapper.defaults('cordova/plugin/Connection', 'Connection'); |
| |
| }); |
| |
| // file: lib/common/plugin/notification.js |
| define("cordova/plugin/notification", function(require, exports, module) { |
| |
| var exec = require('cordova/exec'); |
| var platform = require('cordova/platform'); |
| |
| /** |
| * 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 {Array} buttonLabels Array of the labels of the buttons (default: ['OK', 'Cancel']) |
| */ |
| confirm: function(message, resultCallback, title, buttonLabels) { |
| var _title = (title || "Confirm"); |
| var _buttonLabels = (buttonLabels || ["OK", "Cancel"]); |
| |
| // Strings are deprecated! |
| if (typeof _buttonLabels === 'string') { |
| console.log("Notification.confirm(string, function, string, string) is deprecated. Use Notification.confirm(string, function, string, array)."); |
| } |
| |
| // Some platforms take an array of button label names. |
| // Other platforms take a comma separated list. |
| // For compatibility, we convert to the desired type based on the platform. |
| if (platform.id == "android" || platform.id == "ios" || platform.id == "windowsphone" || platform.id == "blackberry10") { |
| if (typeof _buttonLabels === 'string') { |
| var buttonLabelString = _buttonLabels; |
| _buttonLabels = _buttonLabels.split(","); // not crazy about changing the var type here |
| } |
| } else { |
| if (Array.isArray(_buttonLabels)) { |
| var buttonLabelArray = _buttonLabels; |
| _buttonLabels = buttonLabelArray.toString(); |
| } |
| } |
| exec(resultCallback, null, "Notification", "confirm", [message, _title, _buttonLabels]); |
| }, |
| |
| /** |
| * Open a native prompt dialog, with a customizable title and button text. |
| * The following results are returned to the result callback: |
| * buttonIndex Index number of the button selected. |
| * input1 The text entered in the prompt dialog box. |
| * |
| * @param {String} message Dialog message to display (default: "Prompt message") |
| * @param {Function} resultCallback The callback that is called when user clicks on a button. |
| * @param {String} title Title of the dialog (default: "Prompt") |
| * @param {Array} buttonLabels Array of strings for the button labels (default: ["OK","Cancel"]) |
| * @param {String} defaultText Textbox input value (default: "Default text") |
| */ |
| prompt: function(message, resultCallback, title, buttonLabels, defaultText) { |
| var _message = (message || "Prompt message"); |
| var _title = (title || "Prompt"); |
| var _buttonLabels = (buttonLabels || ["OK","Cancel"]); |
| var _defaultText = (defaultText || "Default text"); |
| exec(resultCallback, null, "Notification", "prompt", [_message, _title, _buttonLabels, _defaultText]); |
| }, |
| |
| /** |
| * 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/tizen/plugin/notification/symbols.js |
| define("cordova/plugin/notification/symbols", function(require, exports, module) { |
| |
| |
| var modulemapper = require('cordova/modulemapper'); |
| |
| modulemapper.defaults('cordova/plugin/notification', 'navigator.notification'); |
| modulemapper.merges('cordova/plugin/tizen/Notification', 'navigator.notification'); |
| |
| }); |
| |
| // file: lib/common/plugin/requestFileSystem.js |
| define("cordova/plugin/requestFileSystem", function(require, exports, module) { |
| |
| var argscheck = require('cordova/argscheck'), |
| 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) { |
| argscheck.checkArgs('nnFF', 'requestFileSystem', arguments); |
| var fail = function(code) { |
| errorCallback && 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 (successCallback) { |
| // 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 argscheck = require('cordova/argscheck'), |
| 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) { |
| argscheck.checkArgs('sFF', 'resolveLocalFileSystemURI', arguments); |
| // error callback |
| var fail = function(error) { |
| errorCallback && 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 (successCallback) { |
| // create appropriate Entry object |
| result = (entry.isDirectory) ? new DirectoryEntry(entry.name, entry.fullPath) : new FileEntry(entry.name, entry.fullPath); |
| successCallback(result); |
| } |
| } |
| 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/splashscreen/symbol.js |
| define("cordova/plugin/splashscreen/symbol", function(require, exports, module) { |
| |
| |
| var modulemapper = require('cordova/modulemapper'); |
| |
| modulemapper.merges('cordova/plugin/tizen/SplashScreen', 'splashscreen'); /// is that correct??? PPL |
| |
| }); |
| |
| // file: lib/common/plugin/splashscreen/symbols.js |
| define("cordova/plugin/splashscreen/symbols", function(require, exports, module) { |
| |
| |
| var modulemapper = require('cordova/modulemapper'); |
| |
| modulemapper.clobbers('cordova/plugin/splashscreen', 'navigator.splashscreen'); |
| |
| }); |
| |
| // file: lib/tizen/plugin/tizen/Accelerometer.js |
| define("cordova/plugin/tizen/Accelerometer", function(require, exports, module) { |
| |
| var accelerometerCallback = null; |
| |
| //console.log("TIZEN ACCELEROMETER START"); |
| |
| module.exports = { |
| |
| start: function (successCallback, errorCallback) { |
| |
| if (accelerometerCallback) { |
| window.removeEventListener("devicemotion", accelerometerCallback, true); |
| } |
| |
| accelerometerCallback = function (motion) { |
| successCallback({ |
| x: motion.accelerationIncludingGravity.x, |
| y: motion.accelerationIncludingGravity.y, |
| z: motion.accelerationIncludingGravity.z, |
| timestamp: new Date().getTime() |
| }); |
| }; |
| window.addEventListener("devicemotion", accelerometerCallback, true); |
| }, |
| |
| stop: function (successCallback, errorCallback) { |
| window.removeEventListener("devicemotion", accelerometerCallback, true); |
| accelerometerCallback = null; |
| } |
| }; |
| |
| //console.log("TIZEN ACCELEROMETER END"); |
| |
| |
| }); |
| |
| // file: lib/tizen/plugin/tizen/Battery.js |
| define("cordova/plugin/tizen/Battery", function(require, exports, module) { |
| |
| /*global tizen:false */ |
| var batteryListenerId = null; |
| |
| //console.log("TIZEN BATTERY START"); |
| |
| module.exports = { |
| start: function(successCallback, errorCallback) { |
| var batterySuccessCallback = function(power) { |
| if (successCallback) { |
| successCallback({level: Math.round(power.level * 100), isPlugged: power.isCharging}); |
| } |
| }; |
| |
| if (batteryListenerId === null) { |
| batteryListenerId = tizen.systeminfo.addPropertyValueChangeListener("BATTERY", batterySuccessCallback); |
| } |
| |
| tizen.systeminfo.getPropertyValue("BATTERY", batterySuccessCallback, errorCallback); |
| }, |
| |
| stop: function(successCallback, errorCallback) { |
| tizen.systeminfo.removePropertyValueChangeListener(batteryListenerId); |
| batteryListenerId = null; |
| } |
| }; |
| |
| //console.log("TIZEN BATTERY END"); |
| |
| }); |
| |
| // 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 |
| * held 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'); |
| |
| |
| //console.log("TIZEN CAMERA START"); |
| |
| |
| function cameraMakeReplyCallback(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/appcontrol/operation/create_content'; |
| } |
| else { |
| serviceId = 'http://tizen.org/appcontrol/operation/pick'; |
| } |
| |
| var serviceControl = new tizen.ApplicationControl( |
| serviceId, |
| null, |
| mimeType, |
| null); |
| |
| tizen.application.launchAppControl( |
| serviceControl, |
| null, |
| null, |
| function(error) { |
| errorCallback(error.message); |
| }, |
| cameraMakeReplyCallback(successCallback, errorCallback) |
| ); |
| } |
| }; |
| |
| //console.log("TIZEN CAMERA END"); |
| |
| }); |
| |
| // file: lib/tizen/plugin/tizen/Compass.js |
| define("cordova/plugin/tizen/Compass", function(require, exports, module) { |
| |
| var CompassError = require('cordova/plugin/CompassError'), |
| CompassHeading = require('cordova/plugin/CompassHeading'); |
| |
| var compassCallback = null, |
| compassReady = false; |
| |
| //console.log("TIZEN COMPASS START"); |
| |
| module.exports = { |
| getHeading: function(successCallback, errorCallback) { |
| |
| if (window.DeviceOrientationEvent !== undefined) { |
| |
| compassCallback = function (orientation) { |
| var heading = 360 - orientation.alpha; |
| |
| if (compassReady) { |
| successCallback( new CompassHeading (heading, heading, 0, 0)); |
| window.removeEventListener("deviceorientation", compassCallback, true); |
| } |
| compassReady = true; |
| }; |
| compassReady = false; // workaround invalid first event value returned by WRT |
| window.addEventListener("deviceorientation", compassCallback, true); |
| } |
| else { |
| errorCallback(CompassError.COMPASS_NOT_SUPPORTED); |
| } |
| } |
| }; |
| |
| //console.log("TIZEN COMPASS END"); |
| |
| |
| }); |
| |
| // 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'); |
| |
| // ------------------ |
| // Utility functions |
| // ------------------ |
| |
| |
| //console.log("TIZEN CONTACT START"); |
| |
| |
| var ContactError = require('cordova/plugin/ContactError'), |
| ContactUtils = require('cordova/plugin/tizen/ContactUtils'), |
| utils = require('cordova/utils'), |
| exec = require('cordova/exec'); |
| |
| |
| |
| /** |
| * 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.personId " + tizenContact.personId); //Tizen 2.0 |
| console.log("cordova/plugin/tizen/Contact/ tizenContact.addressBookId " + tizenContact.addressBookId); //Tizen 2.0 |
| |
| console.log("cordova/plugin/tizen/Contact/ tizenContact.lastUpdated " + tizenContact.lastUpdated); |
| console.log("cordova/plugin/tizen/Contact/ tizenContact.isFavorite " + tizenContact.isFavorite); //Tizen 2.0 |
| |
| console.log("cordova/plugin/tizen/Contact/ tizenContact.name " + tizenContact.name); |
| |
| //console.log("cordova/plugin/tizen/Contact/ tizenContact.account " + tizenContact.account); //Tizen 2.0 |
| |
| 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.anniversaries " + tizenContact.anniversaries); |
| |
| console.log("cordova/plugin/tizen/Contact/ tizenContact.organizations " + tizenContact.organizations); |
| console.log("cordova/plugin/tizen/Contact/ tizenContact.notes " + tizenContact.notes); |
| console.log("cordova/plugin/tizen/Contact/ tizenContact.urls " + tizenContact.urls); |
| console.log("cordova/plugin/tizen/Contact/ tizenContact.ringtonesURI " + tizenContact.ringtonesURI); |
| console.log("cordova/plugin/tizen/Contact/ tizenContact.groupIds " + tizenContact.groupIds); //Tizen 2.0 |
| |
| //console.log("cordova/plugin/tizen/Contact/ tizenContact.categories " + tizenContact.categories); //Tizen 2.0 |
| }; |
| |
| |
| /** |
| * 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; |
| } |
| } |
| |
| //Tizen 2.0 |
| if (contact.name.honorificSuffix) { |
| if (tizenContact.name === null) { |
| tizenContact.name = new tizen.ContactName(); |
| } |
| if (tizenContact.name !== null) { |
| tizenContact.name.suffix = contact.name.honorificSuffix; |
| } |
| } |
| } |
| |
| // 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 = []; |
| } |
| |
| // notes - Tizen 2.0 (was note) |
| if (contact.note !== null) { |
| if (tizenContact.notes === null) { |
| tizenContact.notes = []; |
| } |
| if (tizenContact.notes !== null) { |
| tizenContact.notes[0] = contact.note; |
| } |
| } |
| |
| // photos |
| if (contact.photos && utils.isArray(contact.photos) && contact.photos.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 email 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); |
| |
| emails.push( |
| new tizen.ContactEmailAddress( |
| contact.emails[i].value, |
| emailTypes, |
| contact.emails[i].pref)); //Tizen 2.0 |
| |
| } |
| 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]) { |
| continue; |
| } |
| |
| var phoneTypes = []; |
| phoneTypes.push (contact.phoneNumbers[i].type); |
| |
| |
| phoneNumbers.push( |
| new tizen.ContactPhoneNumber( |
| contact.phoneNumbers[i].value, |
| phoneTypes, |
| contact.phoneNumbers[i].pref) //Tizen 2.0 |
| ); |
| } |
| |
| 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) { |
| continue; |
| } |
| |
| var addressTypes = []; |
| addressTypes.push (address.type); |
| |
| addresses.push( |
| new tizen.ContactAddress({ |
| country: address.country, |
| region : address.region, |
| city: address.locality, |
| streetAddress: address.streetAddress, |
| additionalInformation: "", |
| postalCode: address.postalCode, |
| isDefault: address.pref, //Tizen 2.0 |
| types : addressTypes |
| })); |
| |
| } |
| tizenContact.addresses = addresses.length > 0 ? addresses : []; |
| |
| } |
| else{ |
| tizenContact.addresses = []; |
| } |
| |
| // copy first url found to cordova 'urls' 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 addresses |
| if (update) { |
| } |
| |
| var organizations = [], |
| organization = null; |
| |
| for ( i = 0; i < contact.organizations.length; i += 1) { |
| organization = contact.organizations[i]; |
| |
| if (!organization) { |
| continue; |
| } |
| |
| organizations.push( |
| new tizen.ContactOrganization({ |
| name: organization.name, |
| department: organization.department, |
| title: organization.title, |
| role: "", |
| logoURI: "" |
| })); |
| |
| } |
| tizenContact.organizations = organizations.length > 0 ? organizations : []; |
| |
| } |
| else{ |
| tizenContact.organizations = []; |
| } |
| |
| // 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); |
| |
| tizenAddress.country = address.country || ""; |
| tizenAddress.region = address.region || ""; |
| tizenAddress.city = address.locality || ""; |
| tizenAddress.streetAddress = address.streetAddress || ""; |
| tizenAddress.postalCode = address.postalCode || ""; |
| tizenAddress.isDefault = address.pref || false; //Tizen SDK 2.0 |
| 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) { |
| //var addressBook = tizen.contact.getDefaultAddressBook(); |
| var addressBook = tizen.contact.getAddressBook(tizenContact.addressBookId); //Tizen SDk 2.0 |
| |
| addressBook.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)); |
| } |
| } |
| } |
| }; |
| |
| //console.log("TIZEN CONTACT END"); |
| |
| }); |
| |
| // file: lib/tizen/plugin/tizen/ContactUtils.js |
| define("cordova/plugin/tizen/ContactUtils", function(require, exports, module) { |
| |
| /*global tizen:false */ |
| var Contact = require('cordova/plugin/Contact'), |
| ContactAddress = require('cordova/plugin/ContactAddress'), |
| ContactName = require('cordova/plugin/ContactName'), |
| ContactField = require('cordova/plugin/ContactField'), |
| ContactOrganization = require('cordova/plugin/ContactOrganization'), |
| utils = require('cordova/utils'); |
| |
| |
| |
| /** |
| * 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" : ["organizations.name","organizations.department","organizations.office", "organizations.title"], |
| "birthday" : ["birthday"], |
| "note" : ["notes"], |
| "photos" : ["photoURI"], |
| "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() { |
| for ( var key in fieldMappings) { |
| allFields.push(key); |
| } |
| })(); |
| |
| /** |
| * 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 isDefault = tizenAddress.isDefault; //Tizen 2.0 |
| var streetAddress = tizenAddress.streetAddress; |
| var locality = tizenAddress.city || ""; |
| var region = tizenAddress.region || ""; |
| var postalCode = tizenAddress.postalCode || ""; |
| var country = tizenAddress.country || ""; |
| |
| //TODO improve formatted |
| var formatted = streetAddress + ", " + locality + ", " + region + ", " + postalCode + ", " + country; |
| |
| var contact = new ContactAddress(isDefault, 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); |
| } |
| } |
| } |
| } |
| |
| // fulfill 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 || ""); |
| } |
| |
| //Tizen 2.0 |
| if (tizenContact.name.suffix) { |
| formattedName += ' '; |
| formattedName += (tizenContact.name.suffix || ""); |
| } |
| |
| contact.name = new ContactName( |
| formattedName, |
| tizenContact.name.lastName, |
| tizenContact.name.firstName, |
| tizenContact.name.middleName, |
| tizenContact.name.prefix, |
| tizenContact.name.suffix); |
| } |
| // phoneNumbers - Tizen 2.0 |
| 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].isDefault)); |
| } |
| contact.phoneNumbers = phoneNumbers.length > 0 ? phoneNumbers : null; |
| } |
| |
| // emails - Tizen 2.0 |
| 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].isDefault)); |
| } |
| contact.emails = emails.length > 0 ? emails : null; |
| } |
| |
| // addresses Tizen 2.0 |
| else if (field.indexOf('addresses') === 0) { |
| var addresses = []; |
| |
| for (index = 0 ; index < tizenContact.addresses.length ; ++index) { |
| addresses.push( |
| new ContactAddress( |
| tizenContact.addresses[index].isDefault, |
| 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 -Tizen 2.0 |
| else if (field.indexOf('note') === 0) { |
| if (tizenContact.notes) { |
| contact.note = tizenContact.notes[0]; |
| } |
| } |
| // organizations Tizen 2.0 |
| else if (field.indexOf('organizations') === 0) { |
| var organizations = []; |
| |
| for (index = 0 ; index < tizenContact.organizations.length ; ++index) { |
| organizations.push( |
| new ContactOrganization( |
| (index === 0), |
| 'WORK', |
| tizenContact.organizations.name, |
| tizenContact.organizations.department, |
| tizenContact.organizations.jobTitle)); |
| } |
| contact.organizations = organizations.length > 0 ? organizations : 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'); |
| |
| //console.log("TIZEN DEVICE START"); |
| |
| |
| // Tell cordova channel to wait on the CordovaInfoReady event - PPL is this useful? |
| //channel.waitForInitialization('onCordovaInfoReady'); |
| |
| function Device() { |
| this.version = "2.1.0"; // waiting a working solution of the security error see below |
| this.uuid = null; |
| this.model = null; |
| this.cordova = CORDOVA_JS_BUILD_LABEL; |
| this.platform = "Tizen"; |
| |
| this.getDeviceInfo(); |
| } |
| |
| Device.prototype.getDeviceInfo = function() { |
| |
| var deviceCapabilities = tizen.systeminfo.getCapabilities(); |
| |
| if (deviceCapabilities) { |
| this.version = deviceCapabilities.platformVersion; // requires http://tizen.org/privilege/system (and not "systeminfo") privileges to be added in config.xml |
| this.uuid = deviceCapabilities.duid; |
| this.model = deviceCapabilities.platformName; |
| |
| channel.onCordovaInfoReady.fire(); |
| } |
| else { |
| console.log("error initializing cordova: "); |
| } |
| }; |
| |
| module.exports = new Device(); |
| |
| //console.log("TIZEN DEVICE END"); |
| |
| |
| |
| }); |
| |
| // file: lib/tizen/plugin/tizen/File.js |
| define("cordova/plugin/tizen/File", function(require, exports, module) { |
| |
| |
| //console.log("TIZEN FILE START"); |
| |
| /*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 = { |
| /* common/equestFileSystem.js, args = [type, size] */ |
| 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); |
| } |
| ); |
| }, |
| |
| /* common/resolveLocalFileSystemURI.js, args= [uri] */ |
| resolveLocalFileSystemURI: function(successCallback, errorCallback, args) { |
| var uri = args[0]; |
| |
| nativeResolveLocalFileSystemURI( |
| uri, |
| function(entry) { |
| successCallback(makeEntry(entry)); |
| }, |
| function(error) { |
| errorCallback(error.code); |
| } |
| ); |
| }, |
| |
| /* common/DirectoryReader.js, args = [this.path] */ |
| 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); |
| } |
| ); |
| }, |
| |
| /* common/Entry.js , args = [this.fullPath] */ |
| 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); |
| } |
| ); |
| }, |
| |
| /* args = [this.fullPath, metadataObject] */ |
| /* PPL to be implemented */ |
| setMetadata: function(successCallback, errorCallback, args) { |
| var uri = args[0], |
| metadata = args[1]; |
| |
| if (errorCallback) { |
| errorCallback(FileError.NOT_FOUND_ERR); |
| } |
| }, |
| |
| |
| /* args = [srcPath, parent.fullPath, name] */ |
| 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); |
| } |
| ); |
| }, |
| |
| /* args = [srcPath, parent.fullPath, name] */ |
| 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); |
| } |
| ); |
| }, |
| |
| |
| /* args = [this.fullPath] */ |
| 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); |
| } |
| ); |
| }, |
| |
| /* args = [this.fullPath] */ |
| 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); |
| } |
| ); |
| }, |
| |
| /* common/FileEntry.js, args = [this.fullPath] */ |
| 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); |
| } |
| ); |
| }, |
| |
| /* common/DirectoryEntry.js , args = [this.fullPath, path, options] */ |
| 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); |
| } |
| ); |
| }, |
| |
| /* args = [this.fullPath] */ |
| 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); |
| } |
| ); |
| }, |
| |
| /* args = [this.fullPath, path, options] */ |
| 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); |
| } |
| ); |
| }, |
| |
| /* common/FileReader.js, args = execArgs = [filepath, encoding, file.start, file.end] */ |
| 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); |
| } |
| ); |
| }, |
| |
| /* args = execArgs = [this._fileName, file.start, file.end] */ |
| 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); |
| } |
| ); |
| }, |
| |
| /* args = execArgs = [this._fileName, file.start, file.end] */ |
| /* PPL, to Be implemented , for now it is pasted from readAsText...*/ |
| readAsBinaryString: 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); |
| } |
| ); |
| }, |
| |
| |
| /* args = execArgs = [this._fileName, file.start, file.end] */ |
| /* PPL, to Be implemented , for now it is pasted from readAsText...*/ |
| readAsArrayBuffer: 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); |
| } |
| ); |
| }, |
| |
| /* common/FileWriter.js, args = [this.fileName, text, this.position] */ |
| 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); |
| } |
| ); |
| }, |
| |
| /* args = [this.fileName, size] */ |
| 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); |
| } |
| ); |
| } |
| }; |
| |
| |
| //console.log("TIZEN FILE END"); |
| |
| |
| }); |
| |
| // file: lib/tizen/plugin/tizen/FileTransfer.js |
| define("cordova/plugin/tizen/FileTransfer", function(require, exports, module) { |
| |
| /*global WebKitBlobBuilder:false */ |
| |
| |
| //console.log("TIZEN FILE TRANSFER START"); |
| |
| 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 = { |
| /* common/FileTransfer.js, args = [filePath, server, fileKey, fileName, mimeType, params, trustAllHosts, chunkedMode, headers, this._id, httpMethod] */ |
| 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)); |
| } |
| ); |
| }, |
| |
| /* args = [source, target, trustAllHosts, this._id, headers] */ |
| 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(); |
| }, |
| |
| |
| /* args = [this._id]); */ |
| abort: function(successCallback, errorCallback, args) { |
| errorCallback(FileTransferError.ABORT_ERR); |
| } |
| |
| }; |
| |
| |
| //console.log("TIZEN FILE TRANSFER END"); |
| |
| |
| }); |
| |
| // file: lib/tizen/plugin/tizen/Globalization.js |
| define("cordova/plugin/tizen/Globalization", function(require, exports, module) { |
| |
| |
| /*global tizen:false */ |
| |
| var argscheck = require('cordova/argscheck'), |
| exec = require('cordova/exec'), |
| GlobalizationError = require('cordova/plugin/GlobalizationError'); |
| |
| var globalization = { |
| |
| /** |
| * Returns the string identifier for the client's current language. |
| * It returns the language identifier string to the successCB callback with a |
| * properties object as a parameter. If there is an error getting the language, |
| * then the errorCB callback is invoked. |
| * |
| * @param {Function} successCB |
| * @param {Function} errorCB |
| * |
| * @return Object.value {String}: The language identifier |
| * |
| * @error GlobalizationError.UNKNOWN_ERROR |
| * |
| * Example |
| * globalization.getPreferredLanguage(function (language) {alert('language:' + language.value + '\n');}, |
| * function () {}); |
| */ |
| getPreferredLanguage:function(successCB, failureCB) { |
| console.log('exec(successCB, failureCB, "Globalization","getPreferredLanguage", []);'); |
| |
| tizen.systeminfo.getPropertyValue ( |
| "LOCALE", |
| function (localeInfo) { |
| console.log("Cordova, getLocaleName, language is " + localeInfo.language); |
| successCB( {"value": localeInfo.language}); |
| }, |
| function(error) { |
| console.log("Cordova, getLocaleName, An error occurred " + error.message); |
| failureCB(new GlobalizationError(GlobalizationError.UNKNOWN_ERROR , "cannot retrieve language name")); |
| } |
| ); |
| }, |
| |
| /** |
| * Returns the string identifier for the client's current locale setting. |
| * It returns the locale identifier string to the successCB callback with a |
| * properties object as a parameter. If there is an error getting the locale, |
| * then the errorCB callback is invoked. |
| * |
| * @param {Function} successCB |
| * @param {Function} errorCB |
| * |
| * @return Object.value {String}: The locale identifier |
| * |
| * @error GlobalizationError.UNKNOWN_ERROR |
| * |
| * Example |
| * globalization.getLocaleName(function (locale) {alert('locale:' + locale.value + '\n');}, |
| * function () {}); |
| */ |
| getLocaleName:function(successCB, failureCB) { |
| tizen.systeminfo.getPropertyValue ( |
| "LOCALE", |
| function (localeInfo) { |
| console.log("Cordova, getLocaleName, locale name (country) is " + localeInfo.country); |
| successCB( {"value":localeInfo.language}); |
| }, |
| function(error) { |
| console.log("Cordova, getLocaleName, An error occurred " + error.message); |
| failureCB(new GlobalizationError(GlobalizationError.UNKNOWN_ERROR , "cannot retrieve locale name")); |
| } |
| ); |
| }, |
| |
| |
| /** |
| * Returns a date formatted as a string according to the client's user preferences and |
| * calendar using the time zone of the client. It returns the formatted date string to the |
| * successCB callback with a properties object as a parameter. If there is an error |
| * formatting the date, then the errorCB callback is invoked. |
| * |
| * The defaults are: formatLenght="short" and selector="date and time" |
| * |
| * @param {Date} date |
| * @param {Function} successCB |
| * @param {Function} errorCB |
| * @param {Object} options {optional} |
| * formatLength {String}: 'short', 'medium', 'long', or 'full' |
| * selector {String}: 'date', 'time', or 'date and time' |
| * |
| * @return Object.value {String}: The localized date string |
| * |
| * @error GlobalizationError.FORMATTING_ERROR |
| * |
| * Example |
| * globalization.dateToString(new Date(), |
| * function (date) {alert('date:' + date.value + '\n');}, |
| * function (errorCode) {alert(errorCode);}, |
| * {formatLength:'short'}); |
| */ |
| dateToString:function(date, successCB, failureCB, options) { |
| var dateValue = date.valueOf(); |
| console.log('exec(successCB, failureCB, "Globalization", "dateToString", [{"date": dateValue, "options": options}]);'); |
| |
| var tzdate = null; |
| var format = null; |
| |
| tzdate = new tizen.TZDate(date); |
| |
| if (tzdate) { |
| if (options && (options.formatLength == 'short') ){ |
| format = tzdate.toLocaleDateString(); |
| } |
| else{ |
| format = tzdate.toLocaleString(); |
| } |
| console.log('Cordova, globalization, dateToString ' +format); |
| } |
| |
| if (format) |
| { |
| successCB ({"value": format}); |
| } |
| else { |
| failureCB(new GlobalizationError(GlobalizationError.FORMATTING_ERROR , "cannot format date string")); |
| } |
| }, |
| |
| |
| /** |
| * Parses a date formatted as a string according to the client's user |
| * preferences and calendar using the time zone of the client and returns |
| * the corresponding date object. It returns the date to the successCB |
| * callback with a properties object as a parameter. If there is an error |
| * parsing the date string, then the errorCB callback is invoked. |
| * |
| * The defaults are: formatLength="short" and selector="date and time" |
| * |
| * @param {String} dateString |
| * @param {Function} successCB |
| * @param {Function} errorCB |
| * @param {Object} options {optional} |
| * formatLength {String}: 'short', 'medium', 'long', or 'full' |
| * selector {String}: 'date', 'time', or 'date and time' |
| * |
| * @return Object.year {Number}: The four digit year |
| * Object.month {Number}: The month from (0 - 11) |
| * Object.day {Number}: The day from (1 - 31) |
| * Object.hour {Number}: The hour from (0 - 23) |
| * Object.minute {Number}: The minute from (0 - 59) |
| * Object.second {Number}: The second from (0 - 59) |
| * Object.millisecond {Number}: The milliseconds (from 0 - 999), |
| * not available on all platforms |
| * |
| * @error GlobalizationError.PARSING_ERROR |
| * |
| * Example |
| * globalization.stringToDate('4/11/2011', |
| * function (date) { alert('Month:' + date.month + '\n' + |
| * 'Day:' + date.day + '\n' + |
| * 'Year:' + date.year + '\n');}, |
| * function (errorCode) {alert(errorCode);}, |
| * {selector:'date'}); |
| */ |
| stringToDate:function(dateString, successCB, failureCB, options) { |
| argscheck.checkArgs('sfFO', 'Globalization.stringToDate', arguments); |
| console.log('exec(successCB, failureCB, "Globalization", "stringToDate", [{"dateString": dateString, "options": options}]);'); |
| |
| //not supported |
| failureCB(new GlobalizationError(GlobalizationError.PARSING_ERROR , "unsupported")); |
| }, |
| |
| |
| /** |
| * Returns a pattern string for formatting and parsing dates according to the client's |
| * user preferences. It returns the pattern to the successCB callback with a |
| * properties object as a parameter. If there is an error obtaining the pattern, |
| * then the errorCB callback is invoked. |
| * |
| * The defaults are: formatLength="short" and selector="date and time" |
| * |
| * @param {Function} successCB |
| * @param {Function} errorCB |
| * @param {Object} options {optional} |
| * formatLength {String}: 'short', 'medium', 'long', or 'full' |
| * selector {String}: 'date', 'time', or 'date and time' |
| * |
| * @return Object.pattern {String}: The date and time pattern for formatting and parsing dates. |
| * The patterns follow Unicode Technical Standard #35 |
| * http://unicode.org/reports/tr35/tr35-4.html |
| * Object.timezone {String}: The abbreviated name of the time zone on the client |
| * Object.utc_offset {Number}: The current difference in seconds between the client's |
| * time zone and coordinated universal time. |
| * Object.dst_offset {Number}: The current daylight saving time offset in seconds |
| * between the client's non-daylight saving's time zone |
| * and the client's daylight saving's time zone. |
| * |
| * @error GlobalizationError.PATTERN_ERROR |
| * |
| * Example |
| * globalization.getDatePattern( |
| * function (date) {alert('pattern:' + date.pattern + '\n');}, |
| * function () {}, |
| * {formatLength:'short'}); |
| */ |
| getDatePattern:function(successCB, failureCB, options) { |
| console.log(' exec(successCB, failureCB, "Globalization", "getDatePattern", [{"options": options}]);'); |
| |
| var shortFormat = (options) ? ( options.formatLength === 'short') : true; |
| |
| var formatString = tizen.time.getDateFormat ( shortFormat); |
| |
| |
| var current_datetime = tizen.time.getCurrentDateTime(); |
| |
| // probably will require some control of operation... |
| if (formatString) |
| { |
| successCB( |
| { |
| "pattern": formatString, |
| "timezone": current_datetime.getTimezoneAbbreviation(), |
| "utc_offset": current_datetime.difference(current_datetime.toUTC()).length, |
| "dst_offset": current_datetime.isDST() |
| } |
| ); |
| } |
| else { |
| failureCB(new GlobalizationError(GlobalizationError.PATTERN_ERROR , "cannot get pattern")); |
| } |
| }, |
| |
| |
| /** |
| * Returns an array of either the names of the months or days of the week |
| * according to the client's user preferences and calendar. It returns the array of names to the |
| * successCB callback with a properties object as a parameter. If there is an error obtaining the |
| * names, then the errorCB callback is invoked. |
| * |
| * The defaults are: type="wide" and item="months" |
| * |
| * @param {Function} successCB |
| * @param {Function} errorCB |
| * @param {Object} options {optional} |
| * type {String}: 'narrow' or 'wide' |
| * item {String}: 'months', or 'days' |
| * |
| * @return Object.value {Array{String}}: The array of names starting from either |
| * the first month in the year or the |
| * first day of the week. |
| * @error GlobalizationError.UNKNOWN_ERROR |
| * |
| * Example |
| * globalization.getDateNames(function (names) { |
| * for(var i = 0; i < names.value.length; i++) { |
| * alert('Month:' + names.value[i] + '\n');}}, |
| * function () {}); |
| */ |
| getDateNames:function(successCB, failureCB, options) { |
| argscheck.checkArgs('fFO', 'Globalization.getDateNames', arguments); |
| console.log('exec(successCB, failureCB, "Globalization", "getDateNames", [{"options": options}]);'); |
| |
| failureCB(new GlobalizationError(GlobalizationError.UNKNOWN_ERROR , "unsupported")); |
| }, |
| |
| /** |
| * Returns whether daylight savings time is in effect for a given date using the client's |
| * time zone and calendar. It returns whether or not daylight savings time is in effect |
| * to the successCB callback with a properties object as a parameter. If there is an error |
| * reading the date, then the errorCB callback is invoked. |
| * |
| * @param {Date} date |
| * @param {Function} successCB |
| * @param {Function} errorCB |
| * |
| * @return Object.dst {Boolean}: The value "true" indicates that daylight savings time is |
| * in effect for the given date and "false" indicate that it is not. |
| * |
| * @error GlobalizationError.UNKNOWN_ERROR |
| * |
| * Example |
| * globalization.isDayLightSavingsTime(new Date(), |
| * function (date) {alert('dst:' + date.dst + '\n');} |
| * function () {}); |
| */ |
| isDayLightSavingsTime:function(date, successCB, failureCB) { |
| |
| var tzdate = null, |
| isDLS = false; |
| |
| console.log('exec(successCB, failureCB, "Globalization", "isDayLightSavingsTime", [{"date": dateValue}]);'); |
| console.log("date " + date + " value " + date.valueOf()) ; |
| |
| tzdate = new tizen.TZDate(date); |
| if (tzdate) { |
| isDLS = false | (tzdate && tzdate.isDST()); |
| |
| console.log ("Cordova, globalization, isDayLightSavingsTime, " + isDLS); |
| |
| successCB({"dst":isDLS}); |
| } |
| else { |
| failureCB(new GlobalizationError(GlobalizationError.UNKNOWN_ERROR , "cannot get information")); |
| } |
| }, |
| |
| /** |
| * Returns the first day of the week according to the client's user preferences and calendar. |
| * The days of the week are numbered starting from 1 where 1 is considered to be Sunday. |
| * It returns the day to the successCB callback with a properties object as a parameter. |
| * If there is an error obtaining the pattern, then the errorCB callback is invoked. |
| * |
| * @param {Function} successCB |
| * @param {Function} errorCB |
| * |
| * @return Object.value {Number}: The number of the first day of the week. |
| * |
| * @error GlobalizationError.UNKNOWN_ERROR |
| * |
| * Example |
| * globalization.getFirstDayOfWeek(function (day) |
| * { alert('Day:' + day.value + '\n');}, |
| * function () {}); |
| */ |
| getFirstDayOfWeek:function(successCB, failureCB) { |
| argscheck.checkArgs('fF', 'Globalization.getFirstDayOfWeek', arguments); |
| console.log('exec(successCB, failureCB, "Globalization", "getFirstDayOfWeek", []);'); |
| |
| // there is no API to get the fist day of the week in Tizen Dvice API |
| successCB({value:1}); |
| |
| // first day of week is a settings in the date book app |
| // what about : getting the settings directly or asking the date book ? |
| }, |
| |
| |
| /** |
| * Returns a number formatted as a string according to the client's user preferences. |
| * It returns the formatted number string to the successCB callback with a properties object as a |
| * parameter. If there is an error formatting the number, then the errorCB callback is invoked. |
| * |
| * The defaults are: type="decimal" |
| * |
| * @param {Number} number |
| * @param {Function} successCB |
| * @param {Function} errorCB |
| * @param {Object} options {optional} |
| * type {String}: 'decimal', "percent", or 'currency' |
| * |
| * @return Object.value {String}: The formatted number string. |
| * |
| * @error GlobalizationError.FORMATTING_ERROR |
| * |
| * Example |
| * globalization.numberToString(3.25, |
| * function (number) {alert('number:' + number.value + '\n');}, |
| * function () {}, |
| * {type:'decimal'}); |
| */ |
| numberToString:function(number, successCB, failureCB, options) { |
| argscheck.checkArgs('nfFO', 'Globalization.numberToString', arguments); |
| console.log('exec(successCB, failureCB, "Globalization", "numberToString", [{"number": number, "options": options}]);'); |
| //not supported |
| failureCB(new GlobalizationError(GlobalizationError.UNKNOWN_ERROR , "unsupported")); |
| }, |
| |
| /** |
| * Parses a number formatted as a string according to the client's user preferences and |
| * returns the corresponding number. It returns the number to the successCB callback with a |
| * properties object as a parameter. If there is an error parsing the number string, then |
| * the errorCB callback is invoked. |
| * |
| * The defaults are: type="decimal" |
| * |
| * @param {String} numberString |
| * @param {Function} successCB |
| * @param {Function} errorCB |
| * @param {Object} options {optional} |
| * type {String}: 'decimal', "percent", or 'currency' |
| * |
| * @return Object.value {Number}: The parsed number. |
| * |
| * @error GlobalizationError.PARSING_ERROR |
| * |
| * Example |
| * globalization.stringToNumber('1234.56', |
| * function (number) {alert('Number:' + number.value + '\n');}, |
| * function () { alert('Error parsing number');}); |
| */ |
| stringToNumber:function(numberString, successCB, failureCB, options) { |
| argscheck.checkArgs('sfFO', 'Globalization.stringToNumber', arguments); |
| console.log('exec(successCB, failureCB, "Globalization", "stringToNumber", [{"numberString": numberString, "options": options}]);'); |
| |
| //not supported |
| failureCB(new GlobalizationError(GlobalizationError.UNKNOWN_ERROR , "unsupported")); |
| }, |
| |
| /** |
| * Returns a pattern string for formatting and parsing numbers according to the client's user |
| * preferences. It returns the pattern to the successCB callback with a properties object as a |
| * parameter. If there is an error obtaining the pattern, then the errorCB callback is invoked. |
| * |
| * The defaults are: type="decimal" |
| * |
| * @param {Function} successCB |
| * @param {Function} errorCB |
| * @param {Object} options {optional} |
| * type {String}: 'decimal', "percent", or 'currency' |
| * |
| * @return Object.pattern {String}: The number pattern for formatting and parsing numbers. |
| * The patterns follow Unicode Technical Standard #35. |
| * http://unicode.org/reports/tr35/tr35-4.html |
| * Object.symbol {String}: The symbol to be used when formatting and parsing |
| * e.g., percent or currency symbol. |
| * Object.fraction {Number}: The number of fractional digits to use when parsing and |
| * formatting numbers. |
| * Object.rounding {Number}: The rounding increment to use when parsing and formatting. |
| * Object.positive {String}: The symbol to use for positive numbers when parsing and formatting. |
| * Object.negative: {String}: The symbol to use for negative numbers when parsing and formatting. |
| * Object.decimal: {String}: The decimal symbol to use for parsing and formatting. |
| * Object.grouping: {String}: The grouping symbol to use for parsing and formatting. |
| * |
| * @error GlobalizationError.PATTERN_ERROR |
| * |
| * Example |
| * globalization.getNumberPattern( |
| * function (pattern) {alert('Pattern:' + pattern.pattern + '\n');}, |
| * function () {}); |
| */ |
| getNumberPattern:function(successCB, failureCB, options) { |
| argscheck.checkArgs('fFO', 'Globalization.getNumberPattern', arguments); |
| console.log('exec(successCB, failureCB, "Globalization", "getNumberPattern", [{"options": options}]);'); |
| |
| //not supported |
| failureCB(new GlobalizationError(GlobalizationError.UNKNOWN_ERROR , "unsupported")); |
| }, |
| |
| /** |
| * Returns a pattern string for formatting and parsing currency values according to the client's |
| * user preferences and ISO 4217 currency code. It returns the pattern to the successCB callback with a |
| * properties object as a parameter. If there is an error obtaining the pattern, then the errorCB |
| * callback is invoked. |
| * |
| * @param {String} currencyCode |
| * @param {Function} successCB |
| * @param {Function} errorCB |
| * |
| * @return Object.pattern {String}: The currency pattern for formatting and parsing currency values. |
| * The patterns follow Unicode Technical Standard #35 |
| * http://unicode.org/reports/tr35/tr35-4.html |
| * Object.code {String}: The ISO 4217 currency code for the pattern. |
| * Object.fraction {Number}: The number of fractional digits to use when parsing and |
| * formatting currency. |
| * Object.rounding {Number}: The rounding increment to use when parsing and formatting. |
| * Object.decimal: {String}: The decimal symbol to use for parsing and formatting. |
| * Object.grouping: {String}: The grouping symbol to use for parsing and formatting. |
| * |
| * @error GlobalizationError.FORMATTING_ERROR |
| * |
| * Example |
| * globalization.getCurrencyPattern('EUR', |
| * function (currency) {alert('Pattern:' + currency.pattern + '\n');} |
| * function () {}); |
| */ |
| getCurrencyPattern:function(currencyCode, successCB, failureCB) { |
| argscheck.checkArgs('sfF', 'Globalization.getCurrencyPattern', arguments); |
| console.log('exec(successCB, failureCB, "Globalization", "getCurrencyPattern", [{"currencyCode": currencyCode}]);'); |
| |
| //not supported |
| failureCB(new GlobalizationError(GlobalizationError.UNKNOWN_ERROR , "unsupported")); |
| } |
| |
| }; |
| |
| module.exports = globalization; |
| |
| }); |
| |
| // 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 = {}; |
| |
| //console.log("TIZEN MEDIA START"); |
| |
| 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(); |
| } |
| }; |
| |
| //console.log("TIZEN MEDIA END"); |
| |
| |
| }); |
| |
| // 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'); |
| |
| //console.log("TIZEN CONNECTION AKA NETWORK STATUS START"); |
| |
| module.exports = { |
| getConnectionInfo: function (successCallback, errorCallback) { |
| |
| var cncType = Connection.NONE; |
| var infoCount = 0; |
| var deviceCapabilities = null; |
| var timerId = 0; |
| var timeout = 300; |
| |
| |
| function connectionCB() { |
| |
| if (timerId !== null) { |
| clearTimeout(timerId); |
| timerId = null; |
| } |
| |
| infoCount++; |
| |
| if (infoCount > 1) { |
| if (successCallback) { |
| successCallback(cncType); |
| } |
| } |
| } |
| |
| function errorCB(error) { |
| console.log("Error: " + error.code + "," + error.name + "," + error.message); |
| |
| if (errorCallback) { |
| errorCallback(); |
| } |
| } |
| |
| function wifiSuccessCB(wifi) { |
| if ((wifi.status === "ON") && (wifi.ipAddress.length !== 0)) { |
| cncType = Connection.WIFI; |
| } |
| connectionCB(); |
| } |
| |
| function cellularSuccessCB(cell) { |
| if ((cncType === Connection.NONE) && (cell.status === "ON") && (cell.ipAddress.length !== 0)) { |
| cncType = Connection.CELL_2G; |
| } |
| connectionCB(); |
| } |
| |
| |
| deviceCapabilities = tizen.systeminfo.getCapabilities(); |
| |
| |
| timerId = setTimeout( function(){ |
| timerId = null; |
| infoCount = 1; |
| connectionCB(); |
| }, timeout); |
| |
| |
| if (deviceCapabilities.wifi) { |
| tizen.systeminfo.getPropertyValue("WIFI_NETWORK", wifiSuccessCB, errorCB); |
| } |
| |
| if (deviceCapabilities.telephony) { |
| tizen.systeminfo.getPropertyValue("CELLULAR_NETWORK", cellularSuccessCB, errorCB); |
| } |
| |
| } |
| }; |
| |
| //console.log("TIZEN CONNECTION AKA NETWORK STATUS END"); |
| |
| }); |
| |
| // 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"]); |
| |
| |
| //console.log("TIZEN NOTIFICATION START"); |
| |
| |
| 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); |
| } |
| }, |
| |
| prompt: function (message, promptCallback, title, buttonLabels) { |
| console.log ("message" , message); |
| console.log ("promptCallback" , promptCallback); |
| console.log ("title" , title); |
| console.log ("buttonLabels" , buttonLabels); |
| |
| //a temporary implementation using window.prompt() |
| // note taht buttons are cancel ok (in that order) |
| // gonna to return based on having OK / Cancel |
| // ok is 1, cancel is 2 |
| |
| var result = prompt(message); |
| |
| if (promptCallback && (typeof promptCallback == "function")) { |
| promptCallback((result === null) ? 2 : 1, result); |
| } |
| }, |
| |
| 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); |
| } |
| }; |
| |
| //console.log("TIZEN NOTIFICATION END"); |
| |
| |
| }); |
| |
| // 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/SplashScreen.js |
| define("cordova/plugin/tizen/SplashScreen", function(require, exports, module) { |
| |
| var exec = require('cordova/exec'), |
| InAppBrowser = require('cordova/plugin/InAppBrowser'); |
| |
| var splashscreen = { |
| |
| window: null, |
| |
| |
| show:function() { |
| console.log ("tizen splashscreen show()"); |
| |
| // open a windows in splashscreen.window |
| // add DOM with an Image |
| window = window.open('splashscreen.html'); |
| |
| |
| }, |
| hide:function() { |
| console.log ("tizen splashscreen hide()"); |
| //delete the window splashscreen.window |
| //set to null |
| window.close(); |
| window = null; |
| } |
| }; |
| |
| module.exports = splashscreen; |
| |
| }); |
| |
| // 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/contacts/symbols.js |
| define("cordova/plugin/tizen/contacts/symbols", function(require, exports, module) { |
| |
| require('cordova/plugin/contacts/symbols'); |
| |
| var modulemapper = require('cordova/modulemapper'); |
| |
| modulemapper.merges('cordova/plugin/tizen/contacts', 'navigator.contacts'); |
| modulemapper.merges('cordova/plugin/tizen/Contact', 'Contact'); |
| |
| }); |
| |
| // 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/symbols.js |
| define("cordova/symbols", function(require, exports, module) { |
| |
| var modulemapper = require('cordova/modulemapper'); |
| |
| // Use merges here in case others symbols files depend on this running first, |
| // but fail to declare the dependency with a require(). |
| modulemapper.merges('cordova', 'cordova'); |
| modulemapper.clobbers('cordova/exec', 'cordova.exec'); |
| modulemapper.clobbers('cordova/exec', 'Cordova.exec'); |
| |
| }); |
| |
| // file: lib/common/utils.js |
| define("cordova/utils", function(require, exports, module) { |
| |
| var utils = exports; |
| |
| /** |
| * Defines a property getter / setter for obj[key]. |
| */ |
| utils.defineGetterSetter = function(obj, key, getFunc, opt_setFunc) { |
| if (Object.defineProperty) { |
| var desc = { |
| get: getFunc, |
| configurable: true |
| }; |
| if (opt_setFunc) { |
| desc.set = opt_setFunc; |
| } |
| Object.defineProperty(obj, key, desc); |
| } else { |
| obj.__defineGetter__(key, getFunc); |
| if (opt_setFunc) { |
| obj.__defineSetter__(key, opt_setFunc); |
| } |
| } |
| }; |
| |
| /** |
| * Defines a property getter for obj[key]. |
| */ |
| utils.defineGetter = utils.defineGetterSetter; |
| |
| utils.arrayIndexOf = function(a, item) { |
| if (a.indexOf) { |
| return a.indexOf(item); |
| } |
| var len = a.length; |
| for (var i = 0; i < len; ++i) { |
| if (a[i] == item) { |
| return i; |
| } |
| } |
| return -1; |
| }; |
| |
| /** |
| * Returns whether the item was found in the array. |
| */ |
| utils.arrayRemove = function(a, item) { |
| var index = utils.arrayIndexOf(a, item); |
| if (index != -1) { |
| a.splice(index, 1); |
| } |
| return index != -1; |
| }; |
| |
| utils.typeName = function(val) { |
| return Object.prototype.toString.call(val).slice(8, -1); |
| }; |
| |
| /** |
| * Returns an indication of whether the argument is an array or not |
| */ |
| utils.isArray = function(a) { |
| return utils.typeName(a) == 'Array'; |
| }; |
| |
| /** |
| * Returns an indication of whether the argument is a Date or not |
| */ |
| utils.isDate = function(d) { |
| return utils.typeName(d) == '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 wrapped 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 (window.alert) { |
| window.alert(msg); |
| } else if (console && console.log) { |
| console.log(msg); |
| } |
| }; |
| |
| |
| //------------------------------------------------------------------------------ |
| 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; |
| } |
| |
| |
| }); |
| |
| window.cordova = require('cordova'); |
| // file: lib/scripts/bootstrap.js |
| |
| (function (context) { |
| if (context._cordovaJsLoaded) { |
| throw new Error('cordova.js included multiple times.'); |
| } |
| context._cordovaJsLoaded = true; |
| |
| var channel = require('cordova/channel'); |
| var platformInitChannelsArray = [channel.onNativeReady, channel.onPluginsReady]; |
| |
| function logUnfiredChannels(arr) { |
| for (var i = 0; i < arr.length; ++i) { |
| if (arr[i].state != 2) { |
| console.log('Channel not fired: ' + arr[i].type); |
| } |
| } |
| } |
| |
| window.setTimeout(function() { |
| if (channel.onDeviceReady.state != 2) { |
| console.log('deviceready has not fired after 5 seconds.'); |
| logUnfiredChannels(platformInitChannelsArray); |
| logUnfiredChannels(channel.deviceReadyChannelsArray); |
| } |
| }, 5000); |
| |
| // Replace navigator before any modules are required(), to ensure it happens as soon as possible. |
| // We replace it so that properties that can't be clobbered can instead be overridden. |
| function replaceNavigator(origNavigator) { |
| var CordovaNavigator = function() {}; |
| CordovaNavigator.prototype = origNavigator; |
| var newNavigator = new CordovaNavigator(); |
| // This work-around really only applies to new APIs that are newer than Function.bind. |
| // Without it, APIs such as getGamepads() break. |
| if (CordovaNavigator.bind) { |
| for (var key in origNavigator) { |
| if (typeof origNavigator[key] == 'function') { |
| newNavigator[key] = origNavigator[key].bind(origNavigator); |
| } |
| } |
| } |
| return newNavigator; |
| } |
| if (context.navigator) { |
| context.navigator = replaceNavigator(context.navigator); |
| } |
| |
| // _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(); |
| } |
| |
| /** |
| * Create all cordova objects once native side is ready. |
| */ |
| channel.join(function() { |
| // Call the platform-specific initialization |
| require('cordova/platform').initialize(); |
| |
| // Fire event to notify that all objects are created |
| channel.onCordovaReady.fire(); |
| |
| // Fire onDeviceReady event once page has fully loaded, all |
| // constructors have run and cordova info has been received from native |
| // side. |
| // This join call is deliberately made after platform.initialize() in |
| // order that plugins may manipulate channel.deviceReadyChannelsArray |
| // if necessary. |
| channel.join(function() { |
| require('cordova').fireDocumentEvent('deviceready'); |
| }, channel.deviceReadyChannelsArray); |
| |
| }, platformInitChannelsArray); |
| |
| }(window)); |
| |
| // file: lib/scripts/bootstrap-tizen.js |
| |
| require('cordova/channel').onNativeReady.fire(); |
| |
| // file: lib/scripts/plugin_loader.js |
| |
| // Tries to load all plugins' js-modules. |
| // This is an async process, but onDeviceReady is blocked on onPluginsReady. |
| // onPluginsReady is fired when there are no plugins to load, or they are all done. |
| (function (context) { |
| // To be populated with the handler by handlePluginsObject. |
| var onScriptLoadingComplete; |
| |
| var scriptCounter = 0; |
| function scriptLoadedCallback() { |
| scriptCounter--; |
| if (scriptCounter === 0) { |
| onScriptLoadingComplete && onScriptLoadingComplete(); |
| } |
| } |
| |
| function scriptErrorCallback(err) { |
| // Open Question: If a script path specified in cordova_plugins.js does not exist, do we fail for all? |
| // this is currently just continuing. |
| scriptCounter--; |
| if (scriptCounter === 0) { |
| onScriptLoadingComplete && onScriptLoadingComplete(); |
| } |
| } |
| |
| // Helper function to inject a <script> tag. |
| function injectScript(path) { |
| scriptCounter++; |
| var script = document.createElement("script"); |
| script.onload = scriptLoadedCallback; |
| script.onerror = scriptErrorCallback; |
| script.src = path; |
| document.head.appendChild(script); |
| } |
| |
| // Called when: |
| // * There are plugins defined and all plugins are finished loading. |
| // * There are no plugins to load. |
| function finishPluginLoading() { |
| context.cordova.require('cordova/channel').onPluginsReady.fire(); |
| } |
| |
| // Handler for the cordova_plugins.js content. |
| // See plugman's plugin_loader.js for the details of this object. |
| // This function is only called if the really is a plugins array that isn't empty. |
| // Otherwise the onerror response handler will just call finishPluginLoading(). |
| function handlePluginsObject(modules, path) { |
| // First create the callback for when all plugins are loaded. |
| var mapper = context.cordova.require('cordova/modulemapper'); |
| onScriptLoadingComplete = function() { |
| // Loop through all the plugins and then through their clobbers and merges. |
| for (var i = 0; i < modules.length; i++) { |
| var module = modules[i]; |
| if (module) { |
| try { |
| if (module.clobbers && module.clobbers.length) { |
| for (var j = 0; j < module.clobbers.length; j++) { |
| mapper.clobbers(module.id, module.clobbers[j]); |
| } |
| } |
| |
| if (module.merges && module.merges.length) { |
| for (var k = 0; k < module.merges.length; k++) { |
| mapper.merges(module.id, module.merges[k]); |
| } |
| } |
| |
| // Finally, if runs is truthy we want to simply require() the module. |
| // This can be skipped if it had any merges or clobbers, though, |
| // since the mapper will already have required the module. |
| if (module.runs && !(module.clobbers && module.clobbers.length) && !(module.merges && module.merges.length)) { |
| context.cordova.require(module.id); |
| } |
| } |
| catch(err) { |
| // error with module, most likely clobbers, should we continue? |
| } |
| } |
| } |
| |
| finishPluginLoading(); |
| }; |
| |
| // Now inject the scripts. |
| for (var i = 0; i < modules.length; i++) { |
| injectScript(path + modules[i].file); |
| } |
| } |
| |
| // Find the root of the app |
| var path = ''; |
| var scripts = document.getElementsByTagName('script'); |
| var term = 'cordova.js'; |
| for (var n = scripts.length-1; n>-1; n--) { |
| var src = scripts[n].src; |
| if (src.indexOf(term) == (src.length - term.length)) { |
| path = src.substring(0, src.length - term.length); |
| break; |
| } |
| } |
| |
| var plugins_json = path + 'cordova_plugins.json'; |
| var plugins_js = path + 'cordova_plugins.js'; |
| |
| // One some phones (Windows) this xhr.open throws an Access Denied exception |
| // So lets keep trying, but with a script tag injection technique instead of XHR |
| var injectPluginScript = function injectPluginScript() { |
| try { |
| var script = document.createElement("script"); |
| script.onload = function(){ |
| var list = cordova.require("cordova/plugin_list"); |
| handlePluginsObject(list,path); |
| }; |
| script.onerror = function() { |
| // Error loading cordova_plugins.js, file not found or something |
| // this is an acceptable error, pre-3.0.0, so we just move on. |
| finishPluginLoading(); |
| }; |
| script.src = plugins_js; |
| document.head.appendChild(script); |
| |
| } catch(err){ |
| finishPluginLoading(); |
| } |
| } |
| |
| |
| // Try to XHR the cordova_plugins.json file asynchronously. |
| var xhr = new XMLHttpRequest(); |
| xhr.onload = function() { |
| // If the response is a JSON string which composes an array, call handlePluginsObject. |
| // If the request fails, or the response is not a JSON array, just call finishPluginLoading. |
| var obj; |
| try { |
| obj = (this.status == 0 || this.status == 200) && this.responseText && JSON.parse(this.responseText); |
| } catch (err) { |
| // obj will be undefined. |
| } |
| if (Array.isArray(obj) && obj.length > 0) { |
| handlePluginsObject(obj, path); |
| } else { |
| finishPluginLoading(); |
| } |
| }; |
| xhr.onerror = function() { |
| // In this case, the json file was not present, but XHR was allowed, |
| // so we should still try the script injection technique with the js file |
| // in case that is there. |
| injectPluginScript(); |
| }; |
| try { // we commented we were going to try, so let us actually try and catch |
| xhr.open('GET', plugins_json, true); // Async |
| xhr.send(); |
| } catch(err){ |
| injectPluginScript(); |
| } |
| }(window)); |
| |
| |
| })(); |