/**
* @fileOverview
* Ludei's plugins are multiplatform Javascript APIs, that work in any of the three environments
* of CocoonJS: accelerated Canvas+, webview+ and system webview.
* - Select the specific plugin below to open the relevant documentation section.
The CocoonJS Plugin's library (cocoon.js and cocoon.min.js) can be found at Github.
In addition to all the previously mentioned, in the following link you'll find an overview of all the avaliable features in which each plugin support and availability are detailed.
* We hope you find everything you need to get going here, but if you stumble on any problems with the docs or the plugins,
* just drop us a line at our forum (support.ludei.com) and we'll do our best to help you out.
* Tools
* @version 3.0.4
*/
(function () {
/**
* The "Cocoon" object holds all the CocoonJS Extensions and other stuff needed for the CocoonJS environment.
* @namespace Cocoon
*/
Cocoon = window.Cocoon ? window.Cocoon : {};
/**
* @property {string} version Current version of the CocoonJS Extensions.
* @memberOf Cocoon
* @example
* console.log(Cocoon.version);
*/
Cocoon.version = "3.0.0";
/**
* Is the native environment available? true if so.
* @property {bool} version
* @memberof Cocoon
* @private
* @example
* if(Cocoon.nativeAvailable) { ... do native stuff here ... }
*/
Cocoon.nativeAvailable = (!!window.ext);
/**
* This utility function allows to create an object oriented like hierarchy between two functions using their prototypes.
* This function adds a "superclass" and a "__super" attributes to the subclass and it's functions to reference the super class.
* @memberof Cocoon
* @private
* @static
* @param {function} subc The subclass function.
* @param {function} superc The superclass function.
*/
Cocoon.extend = function(subc, superc) {
var subcp = subc.prototype;
var CocoonJSExtendHierarchyChainClass = function() {};
CocoonJSExtendHierarchyChainClass.prototype = superc.prototype;
subc.prototype = new CocoonJSExtendHierarchyChainClass();
subc.superclass = superc.prototype;
subc.prototype.constructor = subc;
if (superc.prototype.constructor === Object.prototype.constructor) {
superc.prototype.constructor = superc;
}
for (var method in subcp) {
if (subcp.hasOwnProperty(method)) {
subc.prototype[method] = subcp[method];
}
}
}
/**
* This utility function copies the properties from one object to a new object array, the result object array can be used as arguments when calling Cocoon.callNative()
* @memberof Cocoon
* @static
* @private
* @param {function} obj The base object that contains all properties defined.
* @param {function} copy The object that user has defined.
*/
Cocoon.clone = function(obj,copy){
if (null == obj || "object" != typeof obj) return obj;
var arr = [];
for (var attr in obj) {
if ( copy.hasOwnProperty(attr) ) {
arr.push(copy[attr]);
}else{
arr.push(obj[attr]);
}
}
return arr;
}
/**
* IMPORTANT: This function should only be used by Ludei.
* This function allows a call to the native extension object function reusing the same arguments object.
* Why is interesting to use this function instead of calling the native object's function directly?
* As the Cocoon object functions expicitly receive parameters, if they are not present and the native call is direcly mapped,
* undefined arguments are passed to the native side. Some native functions do not check the parameters validation
* correctly (just check the number of parameters passed).
* Another solution instead of using this function call is to correctly check if the parameters are valid (not undefined) to make the
* call, but it takes more work than using this approach.
* @static
* @private
* @param {string} nativeExtensionObjectName The name of the native extension object name. The object that is a member of the 'ext' object.
* @param {string} nativeFunctionName The name of the function to be called inside the native extension object.
* @param {object} arguments The arguments object of the Cocoon extension object function. It contains all the arguments passed to the Cocoon extension object function and these are the ones that will be passed to the native call too.
* @param {boolean} [async] A flag to indicate if the makeCall (false or undefined) or the makeCallAsync function should be used to perform the native call.
* @returns Whatever the native function call returns.
*/
Cocoon.callNative = function(nativeExtensionObjectName, nativeFunctionName, args, async) {
if (Cocoon.nativeAvailable) {
var argumentsArray = Array.prototype.slice.call(args);
argumentsArray.unshift(nativeFunctionName);
var nativeExtensionObject = ext[nativeExtensionObjectName];
var makeCallFunction = async ? nativeExtensionObject.makeCallAsync : nativeExtensionObject.makeCall;
var ret = makeCallFunction.apply(nativeExtensionObject, argumentsArray);
var finalRet = ret;
if (typeof ret === "string") {
try {
finalRet = JSON.parse(ret);
}
catch(error) {
console.log(error);
}
}
return finalRet;
}
};
/**
* Returns an object retrieved from a path specified by a dot specified text path starting from a given base object.
* It could be useful to find the reference of an object from a defined base object. For example the base object could be window and the
* path could be "Cocoon.App" or "document.body".
* @static
* @param {Object} baseObject The object to start from to find the object using the given text path.
* @param {string} objectPath The path in the form of a text using the dot notation. i.e. "document.body"
* @private
* @memberof Cocoon
* For example:
* var body = Cocoon.getObjectFromPath(window, "document.body");
*/
Cocoon.getObjectFromPath = function(baseObject, objectPath) {
var parts = objectPath.split('.');
var obj = baseObject;
for (var i = 0, len = parts.length; i < len; ++i)
{
obj[parts[i]] = obj[parts[i]] || undefined;
obj = obj[parts[i]];
}
return obj;
};
/**
* A class that represents objects to handle events. Event handlers have always the same structure:
* Mainly they provide the addEventListener and removeEventListener functions.
* Both functions receive a callback function that will be added or removed. All the added callback
* functions will be called when the event takes place.
* Additionally they also allow the addEventListenerOnce and notifyEventListeners functions.
* @constructor
* @param {string} nativeExtensionObjectName The name of the native extension object (inside the ext object) to be used.
* @param {string} CocoonExtensionObjectName The name of the sugarized extension object.
* @param {string} nativeEventName The name of the native event inside the ext object.
* @param {number} [chainFunction] An optional function used to preprocess the listener callbacks. This function, if provided,
* will be called before any of the other listeners.
* @memberof Cocoon
* @private
* @static
*/
Cocoon.EventHandler = function(nativeExtensionObjectName, CocoonExtensionObjectName, nativeEventName, chainFunction) {
this.listeners = [];
this.listenersOnce = [];
this.chainFunction = chainFunction;
/**
* Adds a callback function so it can be called when the event takes place.
* @param {function} listener The callback function to be added to the event handler object. See the referenced Listener function documentation for more detail in each event handler object's documentation.
* @memberof Cocoon.EventHandler
* @private
* @static
*/
this.addEventListener = function(listener) {
if (chainFunction) {
var f = function() {
chainFunction.call(this, arguments.callee.sourceListener, Array.prototype.slice.call(arguments));
};
listener.CocoonEventHandlerChainFunction = f;
f.sourceListener = listener;
listener = f;
}
var CocoonExtensionObject = Cocoon.getObjectFromPath(Cocoon, CocoonExtensionObjectName);
if (CocoonExtensionObject && CocoonExtensionObject.nativeAvailable) {
ext[nativeExtensionObjectName].addEventListener(nativeEventName, listener);
}
else {
var indexOfListener = this.listeners.indexOf(listener);
if (indexOfListener < 0) {
this.listeners.push(listener);
}
}
};
/**
* Adds a callback function that will be called only one time.
* @param {function} listener The callback function to be added to the event handler object. See the referenced Listener function documentation for more detail in each event handler object's documentation.
* @memberof Cocoon.EventHandler
* @private
* @static
*/
this.addEventListenerOnce = function(listener)
{
if (chainFunction) {
var f = function() { chainFunction(arguments.callee.sourceListener,Array.prototype.slice.call(arguments)); };
f.sourceListener = listener;
listener = f;
}
var CocoonExtensionObject = Cocoon.getObjectFromPath(Cocoon, CocoonExtensionObjectName);
if (CocoonExtensionObject.nativeAvailable) {
ext[nativeExtensionObjectName].addEventListenerOnce(nativeEventName, listener);
}
else
{
var indexOfListener = this.listeners.indexOf(listener);
if (indexOfListener < 0)
{
this.listenersOnce.push(listener);
}
}
};
/**
* Removes a callback function that was added to the event handler so it won't be called when the event takes place.
* @param {function} listener The callback function to be removed from the event handler object. See the referenced Listener function documentation for more detail in each event handler object's documentation.
* @memberof Cocoon.EventHandler
* @private
* @static
*/
this.removeEventListener = function (listener) {
if (chainFunction) {
listener = listener.CocoonEventHandlerChainFunction;
delete listener.CocoonEventHandlerChainFunction;
}
var CocoonExtensionObject = Cocoon.getObjectFromPath(Cocoon, CocoonExtensionObjectName);
if (CocoonExtensionObject.nativeAvailable) {
ext[nativeExtensionObjectName].removeEventListener(nativeEventName, listener);
}
else {
var indexOfListener = this.listeners.indexOf(listener);
if (indexOfListener >= 0) {
this.listeners.splice(indexOfListener, 1);
}
}
};
this.removeEventListenerOnce = function (listener) {
if (chainFunction) {
listener = listener.CocoonEventHandlerChainFunction;
delete listener.CocoonEventHandlerChainFunction;
}
var CocoonExtensionObject = Cocoon.getObjectFromPath(Cocoon, CocoonExtensionObjectName);
if (CocoonExtensionObject.nativeAvailable) {
ext[nativeExtensionObjectName].removeEventListenerOnce(nativeEventName, listener);
}
else {
var indexOfListener = this.listenersOnce.indexOf(listener);
if (indexOfListener >= 0) {
this.listenersOnce.splice(indexOfListener, 1);
}
}
};
/**
* @memberof Cocoon.EventHandler
* @private
* @static
*/
this.notifyEventListeners = function() {
var CocoonExtensionObject = Cocoon.getObjectFromPath(Cocoon, CocoonExtensionObjectName);
if (CocoonExtensionObject && CocoonExtensionObject.nativeAvailable) {
ext[nativeExtensionObjectName].notifyEventListeners(nativeEventName);
} else {
var argumentsArray= Array.prototype.slice.call(arguments);
var listeners = Array.prototype.slice.call(this.listeners);
var listenersOnce = Array.prototype.slice.call(this.listenersOnce);
var _this = this;
// Notify listeners after a while ;) === do not block this thread.
setTimeout(function() {
for (var i = 0; i < listeners.length; i++) {
listeners[i].apply(_this, argumentsArray);
}
for (var i = 0; i < listenersOnce.length; i++) {
listenersOnce[i].apply(_this, argumentsArray);
}
}, 0);
_this.listenersOnce= [];
}
};
return this;
};
/**
* This function is used to create extensions in the global namespace of the "Cocoon" object.
* @memberof Cocoon
* @private
* @static
* @param {string} namespace The extensions namespace, ex: Cocoon.App.Settings.
* @param {object} callback The callback which holds the declaration of the new extension.
* @example
* Cocoon.define("Cocoon.namespace" , function(extension){
* "use strict";
*
* return extension;
* });
*/
Cocoon.define = function(extName, ext){
var namespace = (extName.substring(0,7) == "Cocoon.") ? extName.substr(7) : extName;
var base = window.Cocoon;
var parts = namespace.split(".");
var object = base;
for(var i = 0; i < parts.length; i++) {
var part = parts[i];
(!object[part]) ? console.log("Created namespace: " + extName) : console.log("Updated namespace: - " + extName);
object = object[part] = (i == (parts.length - 1)) ? ext( (object[part] || {}) ) : {};
if(!object) {
throw "Unable to create class " + extName;
}
}
return true;
}
console.log("Created namespace: Cocoon");
})();;Cocoon.define("Cocoon.Signal" , function(extension){
"use strict";
/**
* This namespace is used to create an Event Emitter/Dispatcher that works together.
* with the Cocoon.EventHandler.
* @namespace Cocoon.Signal
* @private
*/
/**
* This constructor creates a new Signal that holds and emits different events that are specified inside each extension.
* @memberof Cocoon.Signal
* @private
* @constructs createSignal
*/
extension.createSignal = function(){
/** @lends Cocoon.Signal.prototype */
this.handle = null;
this.signals = {};
/**
* Registers a new Signal.
* @param {string} namespace The name of the signal which will be emitted.
* @param {object} handle The Cocoon.EventHandler that will handle the signals.
* @function register
* @private
* @example
* signal.register("banner.ready", new Cocoon.EventHandler);
*/
this.register = function(namespace, handle){
if( (!namespace) && (!handle)) throw new Error("Can't create signal " + (namespace || ""));
if(handle.addEventListener){
this.signals[namespace] = handle;
return true;
}
if(!handle.addEventListener){
this.signals[namespace] = {};
for (var prop in handle) {
if(handle.hasOwnProperty(prop)){
this.signals[namespace][prop] = handle[prop];
}
};
return true;
}
throw new Error("Can't create handler for " + namespace + " signal.");
return false;
},
/**
* Exposes the already defined signals, and can be use to atach a callback to a Cocoon.EventHandler event.
* @param {string} signal The name of the signal which will be emitted.
* @param {object} callback The Cocoon.EventHandler that will handle the signals.
* @param {object} params Optional parameters, example { once : true }
* @function expose
* @private
* @example
* Cocoon.namespace.on("event",function(){});
*/
this.expose = function(){
return function(signal, callback, params){
var once = false;
if(arguments.length === 1){
var that = this;
var fnc = function(signal){
this.signal = signal;
}
fnc.prototype.remove = function(functionListener){
var handle = that.signals[this.signal];
if(handle && handle.removeEventListener) {
handle.removeEventListener.apply(that,[functionListener]);
that.signals[this.signal] = undefined;
}
}
return new fnc(signal);
}
if((params) && (params.once)){
once = true;
}
if(!this.signals[signal]) throw new Error("The signal " + signal + " does not exists.");
var handle = this.signals[signal];
if(handle.addEventListener){
if(once){
handle.addEventListenerOnce(function(){
callback.apply( this || window , arguments);
});
}else{
handle.addEventListener(function(){
callback.apply( this || window , arguments);
});
}
}
if(!this.signals[signal].addEventListener){
for (var prop in this.signals[signal]) {
if(!this.signals[signal].hasOwnProperty(prop)) continue;
var handle = this.signals[signal][prop];
if(once){
handle.addEventListenerOnce(function(){
this.clbk[this.name].apply( this || window , arguments);
}.bind({ name : prop , clbk : callback }));
}else{
handle.addEventListener(function(){
this.clbk[this.name].apply( this || window , arguments);
}.bind({ name : prop , clbk : callback }));
}
}
}
}.bind(this);
}
}
return extension;
});;/**
* This namespace represents different methods to control your application.
*
*
*
Here you will find demos about this namespace:
*
*
*
Here you will find demos about this namespace:
*
*
* Here you will find a demo about this namespace:
Webview demo.
*
success: This callback function allows listening to events called when the Cocoon load has completed successfully.
*
error: This callback function allows listening to events called when the Cocoon load fails.
* @example
* Cocoon.WebView.loadInCocoon("index.html", {
* success : function(){ ... },
* error : function(){ ... }
* });
*/
extension.loadInCocoon = function(path, callbacks, storageType)
{
if (Cocoon.App.nativeAvailable)
{
var javaScriptCodeToForward = "ext.IDTK_APP.makeCall('loadPath'";
if (typeof path !== 'undefined')
{
javaScriptCodeToForward += ", '" + path + "'";
if (typeof storageType !== 'undefined')
{
javaScriptCodeToForward += ", '" + storageType + "'";
}
}
javaScriptCodeToForward += ");";
return Cocoon.App.forwardAsync(javaScriptCodeToForward);
}
else
{
Cocoon.App.forwardAsync("Cocoon.App.load('" + path + "');");
}
};
extension.reloadCocoonJS = function()
{
if (Cocoon.App.nativeAvailable)
{
return Cocoon.App.forwardAsync("ext.IDTK_APP.makeCall('reload');");
}
else if (!navigator.isCocoonJS)
{
window.parent.location.reload();
}
};
window.addEventListener("load", function()
{
// Only if we are completely outside CocoonJS (or CocoonJS' webview),
// setup event forwarding from the webview (iframe) to Cocoon.
if (!Cocoon.App.nativeAvailable && window.name == 'CocoonJS_App_ForCocoonJS_WebViewIFrame') {
Cocoon.App.forwardEventsToCocoonJSEnabled = false;
var EVENT_ATTRIBUTES = [ 'timeStamp', 'button', 'type', 'x', 'y', 'pageX', 'pageY', 'clientX', 'clientY', 'offsetX', 'offsetY'];
var EVENTS = [ "dblclick", "touchmove", "mousemove", "touchend", "touchcancel", "mouseup", "touchstart", "mousedown", "release", "dragleft", "dragright", "swipeleft", "swiperight" ];
function forwardEventToCocoonJS(eventName, event) {
var eventData = {};
var att, i;
for (var att in event) {
i = EVENT_ATTRIBUTES.indexOf(att);
if (i >= 0) {
eventData[att] = event[att];
}
}
var jsCode = "Cocoon && Cocoon.App && Cocoon.App.forwardedEventFromTheWebView && Cocoon.App.forwardedEventFromTheWebView(" + JSON.stringify(eventName) + ", '" + JSON.stringify(eventData) + "');";
Cocoon.App.forward(jsCode);
}
for (i = 0; i < EVENTS.length; i++) {
window.addEventListener(EVENTS[i], (function(eventName) {
return function(event) {
if (Cocoon.App.forwardEventsToCocoonJSEnabled) {
forwardEventToCocoonJS(eventName, event);
}
};
})(EVENTS[i]));
}
}
});
extension.onLoadInCocoonJSSucceed = new Cocoon.EventHandler("IDTK_APP", "App", "forwardpageload");
extension.onLoadInCocoonJSFailed = new Cocoon.EventHandler("IDTK_APP", "App", "forwardpagefail");
return extension;
});;Cocoon.define("Cocoon.Proxify" , function(extension){
"use strict";
/**
* Proxies different functions of the WebView environment, like Audio objects and XHR.
* @namespace Cocoon.Proxify
*/
/**
* @function getKeyForValueInDictionary
* @memberof Cocoon.WebView
* @private
*/
extension.getKeyForValueInDictionary = function(dictionary, value) {
var finalKey = null;
for (var key in dictionary) {
if (dictionary[key] === value){
finalKey = key;
break;
}
}
return finalKey;
}
/**
* Setups a origin proxy for a given typeName. What this means is that after calling this function the environment that makes this call will suddenly
* have a way of creating instances of the given typeName and those instances will act as a transparent proxy to counterpart instances in the destination environment.
* Manipulating attributes, calling funcitions or handling events will all be performed in the destination environment but the developer will think they will be
* happening in the origin environment.
* IMPORTANT NOTE: These proxies only work with types that use attributes and function parameters and return types that are primitive like numbers, strings or arrays.
* @function setupOriginProxyType
* @memberof Cocoon.Proxify
* @private
* @param {string} typeName The name of the type to be proxified.
* @param {array} [attributeNames] A list of the names of the attributes to be proxified.
* @param {array} [functionNames] A list of the names of the functions to be proxified.
* @param {array} [eventHandlerNames] A list of the names of the event handlers to be proxified (onXXXX like attributes that represent callbacks).
* A valid typeName and at least one valid array for attribute, function or event handler names is mandatory.
*/
extension.setupOriginProxyType = function (typeName, attributeNames, functionNames, eventHandlerNames) {
if (Cocoon.nativeAvailable){
// Control the parameters.
if (!typeName) throw "The given typeName must be valid.";
if (!attributeNames && !functionNames && !eventHandlerNames) throw "There is no point on setting up a proxy for no attributes, functions nor eventHandlers.";
attributeNames = attributeNames ? attributeNames : [];
functionNames = functionNames ? functionNames : [];
eventHandlerNames = eventHandlerNames ? eventHandlerNames : [];
// The parent object will be the window. It could be another object but careful, the destination side should know about this.
// TODO: Specify the parentObject as a parameter, obtain it's path from the window object and pass it to the destination environment so it knows about it.
var parentObject = window;
// Setup the destination side too.
var jsCode = "Cocoon.Proxify.setupDestinationProxyType(" + JSON.stringify(typeName) + ", " + JSON.stringify(eventHandlerNames) + ");";
Cocoon.App.forward(jsCode);
var originalType = parentObject[typeName];
// Constructor. This will be the new proxified type in the origin environment. Instances of this type will be created by the developer without knowing that they are
// internally calling to their counterparts in the destination environment.
parentObject[typeName] = function () {
var _this = this;
// Each proxy object will have a origin object inside with all the necessary information to be a proxy to the destination.
this._cocoonjs_proxy_object_data = {};
// The id is obtained calling to the destination side to create an instance of the type.
var jsCode = "Cocoon.Proxify.newDestinationProxyObject(" + JSON.stringify(typeName) + ");";
this._cocoonjs_proxy_object_data.id = Cocoon.App.forward(jsCode);
// The eventHandlers dictionary contains objects of the type { eventHandlerName : string, eventHandler : function } to be able to make the callbacks when the
// webview makes the corresponding calls.
this._cocoonjs_proxy_object_data.eventHandlers = {};
// Also store the typename inside each instance.
this._cocoonjs_proxy_object_data.typeName = typeName;
// A dictionary to store the event handlers
this._cocoonjs_proxy_object_data.eventListeners = {};
// TODO: eventHandlers and eventListeners should be in the same list ;)
// Store all the proxy instances in a list that belongs to the type itself.
parentObject[typeName]._cocoonjs_proxy_type_data.proxyObjects[this._cocoonjs_proxy_object_data.id] = this;
// Create a setter and a getter for all the attribute names that have been specified. When the attributes are accessed (set or get) a call to the destination counterpart will be performed.
for (var i = 0; i < attributeNames.length; i++) {
(function (attributeName) {
_this.__defineSetter__(attributeName, function (value) {
var jsCode = "Cocoon.Proxify.setDestinationProxyObjectAttribute(" + JSON.stringify(typeName) + ", " + _this._cocoonjs_proxy_object_data.id + ", " + JSON.stringify(attributeName) + ", " + JSON.stringify(value) + ");";
return Cocoon.App.forward(jsCode);
});
_this.__defineGetter__(attributeName, function () {
var jsCode = "Cocoon.Proxify.getDestinationProxyObjectAttribute(" + JSON.stringify(typeName) + ", " + _this._cocoonjs_proxy_object_data.id + ", " + JSON.stringify(attributeName) + ");";
return Cocoon.App.forward(jsCode);
});
})(attributeNames[i]);
}
// Create a function that performs a call to the destination environment counterpart for all the function names that have been specified.
for (var i = 0; i < functionNames.length; i++) {
(function (functionName) {
_this[functionName] = function () {
// Get the arguments as an array and add the typeName, the proxy id and the functionName before all the other arguments before making the call to the destination counterpart.
var argumentsArray = Array.prototype.slice.call(arguments);
argumentsArray.unshift(functionName);
argumentsArray.unshift(this._cocoonjs_proxy_object_data.id);
argumentsArray.unshift(typeName);
// Use the array to create the correct function call.
var jsCode = "Cocoon.Proxify.callDestinationProxyObjectFunction(";
for (var i = 0; i < argumentsArray.length; i++) {
// The second argument (the id) should not be stringified
jsCode += (i !== 1 ? JSON.stringify(argumentsArray[i]) : argumentsArray[i]) + (i < argumentsArray.length - 1 ? ", " : "");
}
jsCode += ");";
// TODO: This next call should be synchronous but it seems that some customers are experiencing some crash issues. Making it async solves these crashes.
// Another possible solution could be to be able to specify which calls could be async and which sync in the proxification array.
var ret = Cocoon.App.forwardAsync(jsCode);
return ret;
};
})(functionNames[i]);
}
// Create a setter and getter for all the event handler names that have been specified. When the event handlers are accessed, store them inside the corresponding position on the eventHandlers
// array so they can be called when the destination environment makes the corresponding callback call.
for (var i = 0; i < eventHandlerNames.length; i++) {
(function (eventHandlerName) {
_this.__defineSetter__(eventHandlerName, function (value) {
_this._cocoonjs_proxy_object_data.eventHandlers[eventHandlerName] = value;
});
_this.__defineGetter__(eventHandlerName, function () {
return _this._cocoonjs_proxy_object_data.eventHandlers[eventHandlerName];
});
})(eventHandlerNames[i]);
}
// Setup the add and remove event listeners in the proxy object
_this.addEventListener = function (eventTypeName, eventCallback) {
var addEventCallback = true;
// Check for the eventListeners
var eventListeners = _this._cocoonjs_proxy_object_data.eventListeners[eventTypeName];
if (eventListeners) {
// As the eventListeners were already added, check that the same callback has not been added.
addEventCallback = eventListeners.indexOf(eventCallback) < 0;
}
else {
// There are no event listeners, so add the one and add the listeners array for the specific event type name
eventListeners = [];
_this._cocoonjs_proxy_object_data.eventListeners[eventTypeName] = eventListeners;
// Forward the call so the other end registers a event listener (only one is needed).
var jsCode = "Cocoon.Proxify.addDestinationProxyObjectEventListener(" + JSON.stringify(_this._cocoonjs_proxy_object_data.typeName) + ", " + _this._cocoonjs_proxy_object_data.id + ", " + JSON.stringify(eventTypeName) + ");";
Cocoon.App.forwardAsync(jsCode);
}
// Only if the alforithm above specify so, add the eventcallback and notify the destination environment to do the same
if (addEventCallback) {
eventListeners.push(eventCallback);
}
};
_this.removeEventListener = function (eventTypeName, eventCallback) {
// Check for the eventListeners
var eventListeners = _this._cocoonjs_proxy_object_data.eventListeners[eventTypeName];
if (eventListeners) {
var eventCallbackIndex = eventListeners.indexOf(eventCallback);
if (eventCallbackIndex >= 0) {
eventListeners.splice(eventCallbackIndex, 1);
}
}
};
// Return the proxy instance.
return this;
};
// The type will contain a proxy data structure to store all the instances that are created so they are available when the destination environment calls back.
parentObject[typeName]._cocoonjs_proxy_type_data =
{
originalType:originalType,
proxyObjects:[]
};
/**
* Deletes a proxy instance from both the CocoonJS environment structures and also deleting it's webview environment counterpart.
* This function should be manually called whenever a proxy instance won't be accessed anymore.
* @param {object} object The proxy object to be deleted.
*/
parentObject[typeName]._cocoonjs_proxy_type_data.deleteProxyObject = function (object) {
var proxyObjectKey = extension.getKeyForValueInDictionary(this.proxyObjects, object);
if (proxyObjectKey) {
var jsCode = "Cocoon.Proxify.deleteDestinationProxyObject(" + JSON.stringify(typeName) + ", " + object._cocoonjs_proxy_object_data.id + ");";
Cocoon.App.forwardAsync(jsCode);
object._cocoonjs_proxy_object_data = null;
delete this.proxyObjects[proxyObjectKey];
}
};
/**
* Calls an event handler for the given proxy object id and an eventHandlerName.
* @param {number} id The id to be used to look for the proxy object for which to make the call to it's event handler.
* @param {string} eventHandlerName The name of the handler to be called.
* NOTE: Events are a complex thing in the HTML specification. This function just performs a call but at least provides a
* structure to the event passing the target (the proxy object).
* TODO: The destination should serialize the event object as far as it can so many parameters can be passed to the origin
* side. Using JSON.stringify in the destination side and parse in origin side maybe? Still must add the target to the event structure though.
*/
parentObject[typeName]._cocoonjs_proxy_type_data.callProxyObjectEventHandler = function (id, eventHandlerName) {
var object = this.proxyObjects[id];
var eventHandler = object._cocoonjs_proxy_object_data.eventHandlers[eventHandlerName];
if (eventHandler) {
eventHandler({ target:object });
}
};
parentObject[typeName]._cocoonjs_proxy_type_data.callProxyObjectEventListeners = function (id, eventTypeName) {
var object = this.proxyObjects[id];
var eventListeners = object._cocoonjs_proxy_object_data.eventListeners[eventTypeName].slice();
for (var i = 0; i < eventListeners.length; i++) {
eventListeners[i]({ target:object });
}
};
}
};
/**
* Takes down the proxification of a type and restores it to it's original type. Do not worry if you pass a type name that is not proxified yet. The
* function will handle it correctly for compativility reasons.
* @function takedownOriginProxyType
* @memberof Cocoon.Proxify
* @private
* @param {string} typeName The name of the type to be deproxified (take down the proxification and restore the type to it's original state)
*/
extension.takedownOriginProxyType = function (typeName) {
if (Cocoon.App.nativeAvailable) {
var parentObject = window;
if (parentObject[typeName] && parentObject[typeName]._cocoonjs_proxy_type_data) {
parentObject[typeName] = parentObject[typeName]._cocoonjs_proxy_type_data.originalType;
}
}
};
/**
* Deletes everything related to a proxy object in both environments. Do not worry of you do not pass a proxified object to the
* function. For compatibility reasons, you can still have calls to this function even when no poxification of a type has been done.
* @function deleteOriginProxyObject
* @memberof Cocoon.Proxify
* @private
* @param {object} object The proxified object to be deleted.
*/
extension.deleteOriginProxyObject = function (object) {
if (Cocoon.App.nativeAvailable) {
var parentObject = window;
if (object && object._cocoonjs_proxy_object_data) {
parentObject[object._cocoonjs_proxy_object_data.typeName]._cocoonjs_proxy_type_data.deleteProxyObject(object);
}
}
};
/**
* Calls the origin proxy object when an event handler need to be updated/called from the destination environment.
* @function callOriginProxyObjectEventHandler
* @memberof Cocoon.Proxify
* @private
* @param {string} typeName The type name of the proxified type.
* @param {number} id The id of the proxy object.
* @param {string} eventHandlerName The name of the event handler to be called.
*/
extension.callOriginProxyObjectEventHandler = function (typeName, id, eventHandlerName) {
if (Cocoon.App.nativeAvailable) {
var parentObject = window;
parentObject[typeName]._cocoonjs_proxy_type_data.callProxyObjectEventHandler(id, eventHandlerName);
}
};
/**
* Calls the origin proxy object when all the event listeners related to a specific event need to be updated/called from the destination environment.
* @function callOriginProxyObjectEventListeners
* @memberof Cocoon.Proxify
* @private
* @param {string} typeName The type name of the proxified type.
* @param {number} id The id of the proxy object.
* @param {string} eventTypeName The name of the event type to call the listeners related to it.
*/
extension.callOriginProxyObjectEventListeners = function (typeName, id, eventTypeName) {
if (Cocoon.App.nativeAvailable) {
var parentObject = window;
parentObject[typeName]._cocoonjs_proxy_type_data.callProxyObjectEventListeners(id, eventTypeName);
}
};
/**
* Setups all the structures that are needed to proxify a destination type to an origin type.
* @function setupDestinationProxyType
* @memberof Cocoon.Proxify
* @private
* @param {string} typeName The name of the type to be proxified.
* @param {array} eventHandlerNames An array with al the event handlers to be proxified. Needed in order to be able to create callbacks for all the event handlers
* and call to the CocoonJS counterparts accordingly.
*/
extension.setupDestinationProxyType = function (typeName, eventHandlerNames) {
if (Cocoon.App.nativeAvailable) {
var parentObject = window;
// Add a cocoonjs structure to the destination proxified type to store some useful information like all the proxy instances that are created, plus the id counter
// and the names of all the event handlers and some utility functions.
parentObject[typeName]._cocoonjs_proxy_type_data =
{
nextId:0,
proxyObjects:{},
eventHandlerNames:eventHandlerNames
}
}
};
/**
* Takes down the proxy type at the destination environment. Just removes the data structure related to proxies that was added to the type when proxification tool place.
* @function takedownDestinationProxyType
* @memberof Cocoon.Proxify
* @private
* @param {string} typeName The name of the type to take the proxification down.
*/
extension.takedownDestinationProxyType = function (typeName) {
if (Cocoon.App.nativeAvailable) {
var parentObject = window;
if (parent[typeName] && parentObject[typeName]._cocoonjs_proxy_type_data) {
delete parentObject[typeName]._cocoonjs_proxy_type_data;
}
}
};
/**
* Creates a new destination object instance and generates a id to reference it from the original environment.
* @function newDestinationProxyObject
* @memberof Cocoon.Proxify
* @private
* @param {string} typeName The name of the type to be proxified and to generate an instance.
* @return The id to be used from the original environment to identify the corresponding destination object instance.
*/
extension.newDestinationProxyObject = function (typeName) {
if (Cocoon.App.nativeAvailable) {
var parentObject = window;
var proxyObject = new parentObject[typeName]();
// Also store some additional information in the proxy object
proxyObject._cocoonjs_proxy_object_data = {};
// Like the type name, that could be useful late ;)
proxyObject._cocoonjs_proxy_object_data.typeName = typeName;
// Caculate the id for the object. It will be returned to the origin environment so this object can be referenced later
var proxyObjectId = parentObject[typeName]._cocoonjs_proxy_type_data.nextId;
// Store the created object in the structure defined in the setup of proxification with an id associated to it
parentObject[typeName]._cocoonjs_proxy_type_data.proxyObjects[proxyObjectId] = proxyObject;
// Also store the id inside the proxy object itself
proxyObject._cocoonjs_proxy_object_data.id = proxyObjectId;
// Calculate a new id for the next object.
parentObject[typeName]._cocoonjs_proxy_type_data.nextId++;
// Setup all the event handlers.
for (var i = 0; i < parentObject[typeName]._cocoonjs_proxy_type_data.eventHandlerNames.length; i++) {
(function (eventHandlerName) {
proxyObject[eventHandlerName] = function (event) {
var proxyObject = this; // event.target;
// var eventHandlerName = Cocoon.getKeyForValueInDictionary(proxyObject, this); // Avoid closures ;)
var jsCode = "Cocoon.App.callOriginProxyObjectEventHandler(" + JSON.stringify(proxyObject._cocoonjs_proxy_object_data.typeName) + ", " + proxyObject._cocoonjs_proxy_object_data.id + ", " + JSON.stringify(eventHandlerName) + ");";
Cocoon.App.forwardAsync(jsCode);
};
})(parentObject[typeName]._cocoonjs_proxy_type_data.eventHandlerNames[i]);
}
// Add the dictionary where the event listeners (callbacks) will be added.
proxyObject._cocoonjs_proxy_object_data.eventListeners = {};
return proxyObjectId;
}
};
/**
* Calls a function of a destination object idetified by it's typeName and id.
* @function callDestinationProxyObjectFunction
* @memberof Cocoon.Proxify
* @private
* @param {string} typeName The name of the type of the proxy.
* @param {number} id The id of the proxy object.
* @param {string} functionName The name of the function to be called.
* @return Whatever the function call returns.
*/
extension.callDestinationProxyObjectFunction = function (typeName, id, functionName) {
if (Cocoon.App.nativeAvailable) {
var parentObject = window;
var argumentsArray = Array.prototype.slice.call(arguments);
argumentsArray.splice(0, 3);
var proxyObject = parentObject[typeName]._cocoonjs_proxy_type_data.proxyObjects[id];
var result = proxyObject[functionName].apply(proxyObject, argumentsArray);
return result;
}
};
/**
* Sets a value to the corresponding attributeName of a proxy object represented by it's typeName and id.
* @function setDestinationProxyObjectAttribute
* @memberof Cocoon.Proxify
* @private
* @param {string} typeName The name of the type of the proxy.
* @param {number} id The id of the proxy object.
* @param {string} attributeName The name of the attribute to be set.
* @param {unknown} attributeValue The value to be set to the attribute.
*/
extension.setDestinationProxyObjectAttribute = function (typeName, id, attributeName, attributeValue) {
if (Cocoon.App.nativeAvailable) {
var parentObject = window;
var proxyObject = parentObject[typeName]._cocoonjs_proxy_type_data.proxyObjects[id];
proxyObject[attributeName] = attributeValue;
}
};
/**
* Retrieves the value of the corresponding attributeName of a proxy object represented by it's typeName and id.
* @function getDestinationProxyObjectAttribute
* @memberof Cocoon.Proxify
* @private
* @param {string} typeName The name of the type of the proxy.
* @param {number} id The id of the proxy object.
* @param {string} attributeName The name of the attribute to be retrieved.
*/
extension.getDestinationProxyObjectAttribute = function (typeName, id, attributeName) {
if (Cocoon.App.nativeAvailable) {
var parentObject = window;
var proxyObject = parentObject[typeName]._cocoonjs_proxy_type_data.proxyObjects[id];
return proxyObject[attributeName];
}
};
/**
* Deletes a proxy object identifying it using it's typeName and id. Deleting a proxy object mainly means to remove the instance from the global structure
* that hold all the instances.
* @function deleteDestinationProxyObject
* @memberof Cocoon.Proxify
* @private
* @param {string} typeName The name of the type of the proxy.
* @param {number} id The id of the proxy object.
*/
extension.deleteDestinationProxyObject = function (typeName, id) {
if (Cocoon.App.nativeAvailable) {
var parentObject = window;
delete parentObject[typeName]._cocoonjs_proxy_type_data.proxyObjects[id];
}
};
/**
* @function addDestinationProxyObjectEventListener
* @memberof Cocoon.Proxify
* @private
*/
extension.addDestinationProxyObjectEventListener = function (typeName, id, eventTypeName) {
if (Cocoon.App.nativeAvailable) {
var parentObject = window;
// Look for the proxy object
var proxyObject = parentObject[typeName]._cocoonjs_proxy_type_data.proxyObjects[id];
var callback = function (event) {
var proxyObject = this; // event.target;
// var eventTypeName = Cocoon.getKeyForValueInDictionary(proxyObject._cocoonjs_proxy_object_data.eventListeners, this); // Avoid closures ;)
// TODO: Is there a way to retrieve the callbackId without a closure?
var jsCode = "Cocoon.Proxify.callOriginProxyObjectEventListeners(" + JSON.stringify(proxyObject._cocoonjs_proxy_object_data.typeName) + ", " + proxyObject._cocoonjs_proxy_object_data.id + ", " + JSON.stringify(eventTypeName) + ");";
Cocoon.App.forwardAsync(jsCode);
};
proxyObject._cocoonjs_proxy_object_data.eventListeners[eventTypeName] = callback;
// Finally add the event listener callback to the proxy object
proxyObject.addEventListener(eventTypeName, callback);
}
};
/**
* Proxifies the XMLHttpRequest type for the environment where this call is made. After calling this function, all the new objects
* of XMLHttpRequest that are instantiated, will be proxified objects that will make calls to the counterparts in the other environment (CocoonJS <-> WebView viceversa).
* IMPORTANT NOTE: Remember to take down the proxification once you are done or to delete proxy objects whenever they are not needed anymore or memory leaks may occur.
* @function xhr
* @memberof Cocoon.Proxify
* @example
* Cocoon.Proxify.xhr();
*/
extension.xhr = function () {
var ATTRIBUTE_NAMES =
[
"timeout",
"withCredentials",
"upload",
"status",
"statusText",
"responseType",
"response",
"responseText",
"responseXML",
"readyState"
];
var FUNCTION_NAMES =
[
"open",
"setRequestHeader",
"send",
"abort",
"getResponseHeader",
"getAllResponseHeaders",
"overrideMimeType"
];
var EVENT_HANDLER_NAMES =
[
"onloadstart",
"onprogress",
"onabort",
"onerror",
"onload",
"ontimeout",
"onloadend",
"onreadystatechange"
];
Cocoon.Proxify.setupOriginProxyType("XMLHttpRequest", ATTRIBUTE_NAMES, FUNCTION_NAMES, EVENT_HANDLER_NAMES);
};
/**
* Proxifies the Audio type for the environment where this call is made. After calling this function, all the new objects
* of Audio that are instantiated, will be proxified objects that will make calls to the counterparts in the other environment (CocoonJS <-> WebView viceversa).
* IMPORTANT NOTE: Remember to take down the proxification once you are done or to delete proxy objects whenever they are not needed anymore or memory leaks may occur.
* @function audio
* @memberof Cocoon.Proxify
* @example
* Cocoon.Proxify.audio();
*/
extension.audio = function () {
var ATTRIBUTE_NAMES =
[
"src",
"loop",
"volume",
"preload"
];
var FUNCTION_NAMES =
[
"play",
"pause",
"load",
"canPlayType"
];
var EVENT_HANDLER_NAMES =
[
"onended",
"oncanplay",
"oncanplaythrough",
"onerror"
];
Cocoon.Proxify.setupOriginProxyType("Audio", ATTRIBUTE_NAMES, FUNCTION_NAMES, EVENT_HANDLER_NAMES);
};
/**
* This function allows to forward console messages from the WebView to the CocoonJS
* debug console. What it does is to change the console object for a new one
* with all it's methods (log, error, info, debug and warn) forwarding their
* messages to the CocoonJS environment.
* The original console object is stored in the Cocoon.originalConsole property.
* @function console
* @memberof Cocoon.Proxify
* @example
* Cocoon.Proxify.console();
*/
extension.console = function()
{
if (!Cocoon.nativeAvailable) return;
if (typeof Cocoon.originalConsole === 'undefined')
{
Cocoon.originalConsole = window.console;
}
var functions = ["log", "error", "info", "debug", "warn"];
var newConsole = {};
for (var i = 0; i < functions.length; i++)
{
newConsole[functions[i]] = function(functionName)
{
return function(message)
{
try{
var jsCode = "Proxified log: " + JSON.stringify(message);
Cocoon.originalConsole.log(jsCode);
ext.IDTK_APP.makeCallAsync("forward", jsCode);
}catch(e){
console.log("Proxified log: " + e);
}
};
}(functions[i]);
}
if (!newConsole.assert) {
newConsole.assert = function assert() {
if (arguments.length > 0 && !arguments[0]) {
var str = 'Assertion failed: ' + (arguments.length > 1 ? arguments[1] : '');
newConsole.error(str);
}
}
}
window.console = newConsole;
};
/**
* This function restores the original console object and removes the proxified console object.
* @function deproxifyConsole
* @memberof Cocoon.Proxify
* @example
* Cocoon.Proxify.deproxifyConsole();
*/
extension.deproxifyConsole = function()
{
if (window.navigator.isCocoonJS || !Cocoon.nativeAvailable) return;
if (typeof Cocoon.originalConsole !== 'undefined')
{
window.console = Cocoon.originalConsole;
Cocoon.originalConsole = undefined;
}
};
return extension;
});;Cocoon.define("Cocoon.Device" , function(extension){
"use strict";
/**
* All functions related to the device.
* @namespace Cocoon.Device
*/
/**
* An object that defines the getDeviceInfo returned information.
* @memberof Cocoon.Device
* @name DeviceInfo
* @property {object} Cocoon.Device.DeviceInfo - The object itself
* @property {string} Cocoon.Device.DeviceInfo.os The operating system name (ios, android,...).
* @property {string} Cocoon.Device.DeviceInfo.version The operating system version (4.2.2, 5.0,...).
* @property {string} Cocoon.Device.DeviceInfo.dpi The operating system screen density in dpi.
* @property {string} Cocoon.Device.DeviceInfo.brand The device manufacturer (apple, samsung, lg,...).
* @property {string} Cocoon.Device.DeviceInfo.model The device model (iPhone 4S, SAMSUNG-SGH-I997, SAMSUNG-SGH-I997R, etc).
* @property {string} Cocoon.Device.DeviceInfo.imei The phone IMEI.
*
Android: The phone IMEI is returned or null if the device has not telepohny.
*
iOS: null is returned as we cannot get the IMEI in iOS, no public API available for that yet.
* @property {string} Cocoon.Device.DeviceInfo.platformId The platform Id.
* @property {string} Cocoon.Device.DeviceInfo.odin The Odin generated id: https://code.google.com/p/odinmobile/
* @property {string} Cocoon.Device.DeviceInfo.openudid The OpenUDID generated Id: https://github.com/ylechelle/OpenUDID
*/
extension.DeviceInfo = {
os: null,
version: null,
dpi: null,
brand: null,
model: null,
imei: null,
platformId: null,
odin: null,
openudid: null
};
/**
* Returns the device UUID.
* @function getDeviceId
* @memberof Cocoon.Device
* @return {string} The device UUID
* @example
* console.log(Cocoon.Device.getDeviceId());
*/
extension.getDeviceId = function() {
if (Cocoon.nativeAvailable) {
return window.ext.IDTK_APP.makeCall("getDeviceId");
}
};
/**
* Returns the device Info.
* @function getDeviceInfo
* @memberof Cocoon.Device
* @return {Cocoon.Device.DeviceInfo} The device Info
* @example
* console.log( JSON.stringify(Cocoon.Device.getDeviceInfo()) );
*/
extension.getDeviceInfo = function() {
if (Cocoon.nativeAvailable) {
return window.ext.IDTK_APP.makeCall("getDeviceInfo");
}
};
/**
* Retrieves the preferred orientation that has been set in the system.
* @function getOrientation
* @memberof Cocoon.Device
* @return {number} The preferred orientation in the system as a combination of the possible {@link Cocoon.Device.Orientations}.
* @example
* console.log(Cocoon.Device.getOrientation());
*/
extension.getOrientation = function() {
if (Cocoon.nativeAvailable) {
return window.ext.IDTK_APP.makeCall("getPreferredOrientation");
}
else {
return 0;
}
};
/**
* Sets the preferred orientation in the system.
* @function setOrientation
* @memberof Cocoon.Device
* @param {number} preferredOrientation The preferred orientation to be set. A combination of the possible {@link Cocoon.Device.Orientations}.
* @example
* Cocoon.Device.setOrientation(Cocoon.Device.Orientations.PORTRAIT);
*/
extension.setOrientation = function(preferredOrientation) {
if (Cocoon.nativeAvailable) {
window.ext.IDTK_APP.makeCall("setPreferredOrientation", preferredOrientation);
}
}
/**
* The predefined possible orientations. There can be a bit level combination of them using the OR operator.
* @memberof Cocoon.Device
* @name Cocoon.Device.Orientations
* @property {string} Cocoon.Device.Orientations - The base object
* @property {string} Cocoon.Device.Orientations.PORTRAIT - Portrait
* @property {string} Cocoon.Device.Orientations.PORTRAIT_UPSIDE_DOWN - Portrait upside-down
* @property {string} Cocoon.Device.Orientations.LANDSCAPE_LEFT - Landscape left
* @property {string} Cocoon.Device.Orientations.LANDSCAPE_RIGHT - Landscape right
* @property {string} Cocoon.Device.Orientations.LANDSCAPE - Landscape
* @property {string} Cocoon.Device.Orientations.BOTH - Both
*/
extension.Orientations = {
PORTRAIT : 1,
PORTRAIT_UPSIDE_DOWN : 2,
LANDSCAPE_LEFT : 4,
LANDSCAPE_RIGHT : 8,
LANDSCAPE : 4 | 8,
BOTH : 1 | 2 | 4 | 8
};
/**
* Enables or disables the auto lock to control if the screen keeps on after an inactivity period.
* When the auto lock is enabled and the application has no user input for a short period, the system puts the device into a "sleep” state where the screen dims or turns off.
* When the auto lock is disabled the screen keeps on even when there is no user input for long times.
* @function autoLock
* @name autoLock
* @memberof Cocoon.Device
* @param {Bool} enabled A boolean value that controls whether to enable or disable the auto lock.
* @example
* Cocoon.Device.autoLock(false);
*/
extension.autoLock = function (enabled) {
if (Cocoon.nativeAvailable) {
return Cocoon.callNative("IDTK_APP", "setAutoLockEnabled", arguments);
}
};
return extension;
});;Cocoon.define("Cocoon.Motion" , function(extension){
"use strict";
/**
* All functions related to the Accelerometer and Gyroscope.
* @namespace Cocoon.Motion
*/
extension.nativeAvailable = Cocoon.nativeAvailable;
/**
* Setups the update interval in seconds (1 second / X frames) to receive the accelerometer updates.
* It defines the rate at which the devicemotion events are updated.
* @function setAccelerometerInterval
* @memberOf Cocoon.Motion
* @param {number} seconds The update interval in seconds to be set.
* @example
* Cocoon.Motion.setAccelerometerInterval(2);
*/
extension.setAccelerometerInterval = function (updateIntervalInSeconds) {
if (Cocoon.Motion.nativeAvailable) {
return window.ext.IDTK_APP.makeCall("setAccelerometerUpdateIntervalInSeconds", updateIntervalInSeconds);
}
};
/**
* Returns the update interval in seconds that is currently set for accelerometer related events.
* @function getAccelerometerInterval
* @memberOf Cocoon.Motion
* @return {number} The update interval in seconds that is currently set for accelerometer related events.
* @example
* console.log(Cocoon.Motion.getAccelerometerInterval());
*/
extension.getAccelerometerInterval = function () {
if (Cocoon.Motion.nativeAvailable) {
return window.ext.IDTK_APP.makeCall("getAccelerometerUpdateIntervalInSeconds");
}
};
/**
* Setups the update interval in seconds (1 second / X frames) to receive the gyroscope updates.
* It defines the rate at which the devicemotion and deviceorientation events are updated.
* @function setGyroscopeInterval
* @memberOf Cocoon.Motion
* @param {number} seconds The update interval in seconds to be set.
* @example
* Cocoon.Motion.setGyroscopeInterval(2);
*/
extension.setGyroscopeInterval = function (updateIntervalInSeconds) {
if (Cocoon.Motion.nativeAvailable) {
return window.ext.IDTK_APP.makeCall("setGyroscopeUpdateIntervalInSeconds", updateIntervalInSeconds);
}
};
/**
* Returns the update interval in seconds that is currently set for gyroscope related events.
* @function getGyroscopeInterval
* @memberOf Cocoon.Motion
* @return {number} The update interval in seconds that is currently set for gyroscope related events.
* @example
* console.log(Cocoon.Motion.getGyroscopeInterval());
*/
extension.getGyroscopeInterval = function () {
if (Cocoon.Motion.nativeAvailable) {
window.ext.IDTK_APP.makeCall("getGyroscopeUpdateIntervalInSeconds");
}
};
return extension;
});;/**
* The "Cocoon.Touch" object holds some functions to handle the touch events in both surfaces ( Cocoon & WebView )
* @namespace Cocoon.Touch
*/
Cocoon.define("Cocoon.Touch" , function(extension){
extension.addADivToDisableInput = function() {
var div = document.createElement("div");
div.id = "CocoonJSInputBlockingDiv";
div.style.left = 0;
div.style.top = 0;
div.style.width = "100%";
div.style.height = "100%";
div.style.position = "absolute";
div.style.backgroundColor = 'transparent';
div.style.border = "0px solid #000";
div.style.zIndex = 999999999;
document.body.appendChild(div);
};
extension.removeTheDivToEnableInput = function() {
var div = document.getElementById("CocoonJSInputBlockingDiv");
if (div) document.body.removeChild(div);
};
/**
* Disables the touch events in the Cocoon environment.
* @memberOf Cocoon.Touch
* @function disable
* @example
* Cocoon.Touch.disable();
*/
extension.disable = function () {
if (Cocoon.nativeAvailable) {
window.ext.IDTK_APP.makeCall("disableTouchLayer", "CocoonJSView");
}
else if (!navigator.isCocoonJS) {
if (!Cocoon.App.EmulatedWebViewIFrame) {
Cocoon.App.forwardEventsToCocoonJSEnabled = false;
Cocoon.App.forwardAsync("Cocoon && Cocoon.Touch && Cocoon.Touch.disable();");
}
}
};
/**
* Enables the touch events in the Cocoon environment.
* @memberOf Cocoon.Touch
* @function enable
* @example
* Cocoon.Touch.enable();
*/
extension.enable = function () {
if (Cocoon.nativeAvailable) {
window.ext.IDTK_APP.makeCall("enableTouchLayer", "CocoonJSView");
}
else if (!navigator.isCocoonJS) {
if (!Cocoon.App.EmulatedWebViewIFrame) {
Cocoon.App.forwardEventsToCocoonJSEnabled = true;
Cocoon.App.forwardAsync("Cocoon && Cocoon.Touch && Cocoon.Touch.enable();");
}
}
};
/**
* Disables the touch events in the WebView environment.
* @memberOf Cocoon.Touch
* @function disableInWebView
* @example
* Cocoon.Touch.disableInWebView();
*/
extension.disableInWebView = function () {
if (Cocoon.nativeAvailable) {
window.ext.IDTK_APP.makeCall("disableTouchLayer", "WebView");
}
else if (!navigator.isCocoonJS) {
if (!Cocoon.App.EmulatedWebViewIFrame) {
Cocoon.Touch.addADivToDisableInput();
}
else {
Cocoon.App.forwardAsync("Cocoon && Cocoon.Touch && Cocoon.Touch.disableInWebView();");
}
}
};
/**
* Enables the touch events in the WebView environment.
* @memberOf Cocoon.Touch
* @function enableInWebView
* @example
* Cocoon.Touch.enableInWebView();
*/
extension.enableInWebView = function () {
if (Cocoon.nativeAvailable) {
window.ext.IDTK_APP.makeCall("enableTouchLayer", "WebView");
}
else if (!navigator.isCocoonJS) {
if (!Cocoon.App.EmulatedWebViewIFrame) {
Cocoon.Touch.removeTheDivToEnableInput();
}
else {
Cocoon.Touch.forwardAsync("Cocoon && Cocoon.Touch && Cocoon.Touch.enableInWebView();");
}
}
};
return extension;
});;/**
* This namespace holds the WebDialog widget, which essentially shows a Webview on top of the CocoonJS layer.
* @namespace Cocoon.Widget
*/
Cocoon.define("Cocoon.Widget" , function(extension){
"use strict";
/**
* Creates the WebDialog
* @constructor WebDialog
* @memberOf Cocoon.Widget
* @example var dialog = new Cocoon.Widget.WebDialog();
*/
extension.WebDialog = function() {
if (Cocoon.App.nativeAvailable) {
this.webDialogID = window.ext.IDTK_APP.makeCall("createWebDialog");
}
else {
var iframe = document.createElement("iframe");
iframe.id = "CocoonJSWebDialogIFrame";
iframe.name = "CocoonJSWebDialogIFrame";
iframe.style.cssText = "position:fixed;left:0;top:0;bottom:0;right:0; width:100%; height:100%;margin:0;padding:0;";
var me = this;
iframe.onload = function(){
me.iframeloaded = true;
var js = "Cocoon = {}; Cocoon.Widget = {}; Cocoon.Widget.WebDialog = {} Cocoon.Widget.WebDialog.close = function()" +
"{" +
" window.parent.CocoonJSCloseWebDialog();" +
"};";
me.evalIframe(js);
for (var i = 0; i < me.pendingEvals.length; ++i) {
me.evalIframe(me.pendingEvals[i]);
}
me.pendingEvals = [];
}
iframe.onerror = function(){
me.close();
}
this.iframe = iframe;
this.pendingEvals = [];
window.CocoonJSCloseWebDialog = function() {
me.close();
}
}
}
extension.WebDialog.prototype = {
/**
* Shows the dialog.
* @function show
* @memberOf Cocoon.Widget.WebDialog
* @param {string} url The url to be opened on the Web Dialog.
* @param {function} closeCallback The callback that will be fired when the dialog is closed.
* @example
* var dialog = new Cocoon.Widget.WebDialog();
* dialog.show("http://www.ludei.com", function(){
* console.log("The dialog has been closed!");
* });
*/
show: function(url, callback) {
this.closeCallback = function() {
Cocoon.Touch.enable();
if (callback)
callback();
}
if (Cocoon.App.nativeAvailable) {
Cocoon.Touch.disable();
return window.ext.IDTK_APP.makeCallAsync("showWebDialog", this.webDialogID, url, this.closeCallback);
}
else {
this.iframe.src = url;
document.body.appendChild(this.iframe);
}
},
/**
* Closes the dialog.
* @function close
* @memberOf Cocoon.Widget.WebDialog
* @example
* var dialog = new Cocoon.Widget.WebDialog();
* dialog.show("http://www.ludei.com");
* //This dialog will close after 15 seconds.
* setTimeout(function(){
* dialog.close();
* }, 15000);
*/
close: function() {
if (Cocoon.App.nativeAvailable) {
return window.ext.IDTK_APP.makeCallAsync("closeWebDialog", this.webDialogID);
}
else {
if (this.iframe.parentNode) {
this.iframe.parentNode.removeChild(this.iframe);
}
}
if (this.closeCallback)
this.closeCallback();
},
evalIframe: function(js) {
window.frames["CocoonJSWebDialogIFrame"].eval(js);
},
/**
* Evaluates a javascript string in the WebDialog environment.
* @function eval
* @memberOf Cocoon.Widget.WebDialog
* @example
* var dialog = new Cocoon.Widget.WebDialog();
* dialog.eval("alert('Michael Jackson is the king of pop')");
*/
eval: function(js) {
if (Cocoon.App.nativeAvailable) {
return window.ext.IDTK_APP.makeCallAsync("evalWebDialog", this.webDialogID, js);
}
else {
if (this.iframeloaded)
this.evalIframe(js);
else
this.pendingEvals.push(js);
}
}
};
return extension;
});;Cocoon.define("Cocoon.Camera" , function(extension) {
/**
* This namespace represents the CocoonJS camera extension API.
*
*
*
* @namespace Cocoon.Camera
* @example
* Cocoon.Camera.start({
* success : function(stream){
* ctx.fillRect(0, 0, w, h);
* ctx.drawImage(stream, 0, 0, w, h);
* },
* error : function(){
* console.log("Error", arguments);
* }
* });
*/
navigator.getUserMedia_ = ( navigator.getUserMedia ||
navigator.webkitGetUserMedia ||
navigator.mozGetUserMedia ||
navigator.msGetUserMedia);
/**
*
* @namespace
*/
/**
* The predefined possible camera types.
* @memberof Cocoon.Camera
* @name Cocoon.Camera.CameraType
* @property {object} Cocoon.Camera.CameraType - The object itself
* @property {string} Cocoon.Camera.CameraType.FRONT - Represents the front camera on the device.
* @property {string} Cocoon.Camera.CameraType.BACK - Represents the back camera on the device.
*/
extension.CameraType = {
FRONT : "FRONT",
BACK : "BACK"
};
/**
* The predefined possible camera video capturing image format types.
* @memberof Cocoon.Camera
* @name Cocoon.Camera.CaptureFormatType
* @property {string} Cocoon.Camera.CaptureFormatType - The object itself
* @property {string} Cocoon.Camera.CaptureFormatType.JPEG
* @property {string} Cocoon.Camera.CaptureFormatType.RGB_565
* @property {string} Cocoon.Camera.CaptureFormatType.NV21
* @property {string} Cocoon.Camera.CaptureFormatType.NV16
* @property {string} Cocoon.Camera.CaptureFormatType.YUY2
* @property {string} Cocoon.Camera.CaptureFormatType.YV12
* @property {string} Cocoon.Camera.CaptureFormatType.BGRA32
*/
extension.CaptureFormatType = {
JPEG : "JPEG",
RGB_565 : "RGB_565",
NV21 : "NV21",
NV16 : "NV16",
YUY2 : "YUY2",
YV12 : "YV12",
BGRA32 : "32BGRA"
};
/**
* The object that represents the information of a camera. It includes all the information to be able to setup a camera to capture video or to take pictures.
* @memberof Cocoon.Camera
* @name Cocoon.Camera.CameraInfo
* @property {string} Cocoon.Camera.CameraInfo - The object itself
* @property {string} Cocoon.Camera.CameraInfo.cameraIndex The index of the camera.
* @property {Cocoon.Camera.CameraType} Cocoon.Camera.CameraType The type of the camera among the possible values in {@link Cocoon.Camera.CameraType}.
* @property {string} Cocoon.Camera.CameraInfo.supportedVideoSizes An array of {@link Cocoon.Size} values that represent the supported video sizes for the camera.
* @property {string} Cocoon.Camera.CameraInfo.supportedVideoFrameRates An array of numbers that represent the supported video frame rates for the camera.
* @property {string} Cocoon.Camera.CameraInfo.supportedImageFormats An array of {@link Cocoon.Camera.CaptureFormatType} values that represent the supported video format types for the camera.
*/
extension.CameraInfo = {
cameraIndex : 0,
cameraType : extension.CameraType.BACK,
supportedVideoSizes : [],
supportedVideoFrameRates : [],
supportedVideoCaptureImageFormats : []
};
/**
* Returns the number of available camera in the platform/device.
* @memberof Cocoon.Camera
* @function getNumberOfCameras
* @returns {number} The number of cameras available in the platform/device.
* @example
* console.log(Cocoon.Camera.getNumberOfCameras());
*/
extension.getNumberOfCameras = function()
{
if (Cocoon.nativeAvailable && navigator.isCocoonJS)
{
return Cocoon.callNative("IDTK_SRV_CAMERA", "getNumberOfCameras", arguments);
}else{
return (navigator.getUserMedia_) ? 1 : 0;
}
};
/**
* Returns an array of {@link Cocoon.Camera.CameraInfo} objects representing all the information of all the cameras available in the platform/device.
* @memberof Cocoon.Camera
* @function getAllCamerasInfo
* @returns {Array} An array of {@link Cocoon.Camera.CameraInfo} objects.
* @example
* console.log(JSON.stringify(Cocoon.Camera.getAllCamerasInfo()));
*/
extension.getAllCamerasInfo = function()
{
if (Cocoon.nativeAvailable && navigator.isCocoonJS)
{
return Cocoon.callNative("IDTK_SRV_CAMERA", "getAllCamerasInfo", arguments);
}
};
/**
* Returns the {@link Cocoon.Camera.CameraInfo} object that represents all the information of the specified camera index in the platform/device.
* @memberof Cocoon.Camera
* @function getCameraInfoByIndex
* @param {number} cameraIndex The index of the camera to get the info from. The index should be between 0 and N (Being N the value returned by {@link Cocoon.Camera.getNumberOfCameras}).
* @returns {Cocoon.Camera.CameraInfo} The {@link Cocoon.Camera.CameraInfo} of the given camera index.
* @example
* console.log(JSON.stringify(Cocoon.Camera.getCameraInfoByIndex(0)));
*/
extension.getCameraInfoByIndex = function(cameraIndex)
{
if (Cocoon.nativeAvailable && navigator.isCocoonJS)
{
return Cocoon.callNative("IDTK_SRV_CAMERA", "getCameraInfoByIndex", arguments);
}
};
/**
* Returns the {@link Cocoon.Camera.CameraInfo} object that represents all the information of the first camera of the specified type found in the platform/device.
* @memberof Cocoon.Camera
* @function getCameraInfoByType
* @param {Cocoon.Camera.CameraType} cameraType The type of the camera to get the info from.
* @returns {Cocoon.Camera.CameraInfo} The {@link Cocoon.Camera.CameraInfo} of the first camera of the given camera type that has been found in the platform/device.
*/
extension.getCameraInfoByType = function(cameraType)
{
if (Cocoon.nativeAvailable && navigator.isCocoonJS)
{
return Cocoon.callNative("IDTK_SRV_CAMERA", "getCameraInfoByType", arguments);
}
};
/**
* Starts a camera to capture video. The developer must specify at least the index of the camera to be used. Some other setup parameters can also be passed to control the video capture. An image object
* that will be automatically updated with the captured frames is returned so the developer just need to draw the image in every frame. A null image object is returned if the setup did not work or there is
* no available camera.
* @memberof Cocoon.Camera
* @function start
* @param {object} params - The object itself
* @param {number} params.cameraIndex The index of the camera to start video capture with.
* @param {number} params.captureWidth The hozirontal size of the video capture resolution. If the value does not correspond to any of the sizes supported by the camera, the closest one is used. See {@link Cocoon.Camera.CameraInfo}.
* If no value is given, the maximum size available is used.
* @param {number} params.captureHeight The vertical size of the video capture resolution. If value does not correspond to any of the sizes supported by the camera, the closest one is used. See {@link Cocoon.Camera.CameraInfo}.
* If no value is given, the maximum size available is used.
* @param {number} params.captureFrameRate The frame rate to capture the video at. If the value does not correspond to any of the frame rates supported by the camera, the closest one is used. See {@link Cocoon.Camera.CameraInfo}.
* If no value is given, the maximum frame rate available is used.
* @param {value} params.captureImageFormat A value from the available {@link Cocoon.Camera.CaptureFormatType} formats to specify the format of the images that will be captured. See {@link Cocoon.Camera.CameraInfo}.
* If no value is given, the first available capture image format is used.
* @returns {image} An image object that will automatically update itself with the captured frames or null if the camera capture could not start.
* @example
* Cocoon.Camera.start({
* success : function(stream){
* ctx.fillRect(0, 0, w, h);
* ctx.drawImage(stream, 0, 0, w, h);
* },
* error : function(){
* console.log("Error", arguments);
* }
* });
*/
extension.start = function(params) {
if( !((Boolean(params.success)) && (Boolean(params.error))) ) throw new Error("Missing callbacks for Cocoon.Camera.start();");
if (Cocoon.nativeAvailable)
{
var properties = {
cameraIndex : 0,
width : 50,
height : 50,
frameRate : 25
};
var args = Cocoon.clone(properties,params);
var img = Cocoon.callNative("IDTK_SRV_CAMERA", "startCapturing", args);
if(Boolean(img)) { params.success(img); }else{ params.error(false); }
}else{
navigator.getUserMedia_( {
video:true, audio:false
},
function(stream) {
params.success(stream);
},
function(error) {
params.error(error);
});
}
};
/**
* Stops a camera that is already started capturing video.
* @memberof Cocoon.Camera
* @function stop
* @param cameraIndex The index of the camera to stop capturing video.
*/
extension.stop = function(cameraIndex)
{
if (Cocoon.nativeAvailable && navigator.isCocoonJS)
{
return Cocoon.callNative("IDTK_SRV_CAMERA", "stopCapturing", arguments);
}
};
/**
* Indicates if a camera is capturing video or not.
* @memberof Cocoon.Camera
* @function isCapturing
* @param cameraIndex The index of the camera to check if is capturing video or not.
* @returns {boolean} A flag indicating if the given camera (by index) is capturing video (true) or not (false).
*/
extension.isCapturing = function(cameraIndex)
{
if (Cocoon.nativeAvailable && navigator.isCocoonJS)
{
return Cocoon.callNative("IDTK_SRV_CAMERA", "isCapturing", arguments);
}
};
return extension;
});;Cocoon.define("Cocoon.Ad" , function(extension){
"use strict";
/**
* This namespace represents the Cocoon Advertisement extension API.
*
*
* Here you will find a demo about this namespace:
Ads demo.
*
*
Warning! This JavaScript extension requires some configuration parameters on the
cloud compiler!
*
*
Warning! This JavaScript extension requires some configuration parameters on the
cloud compiler!
*
You will find a complete example about how to use this extension in the Local namespace.
*
*
*
* @namespace Cocoon.Notification
*/
Cocoon.define("Cocoon.Notification" , function(extension){
extension.nativeAvailable = (!!window.ext) && (!!window.ext.IDTK_SRV_NOTIFICATION);
/**
* This namespace represents the Cocoon Notification extension for local notifications.
* @namespace Cocoon.Notification.Local
* @example
* Cocoon.Notification.Local.on("notification", {
* received: function(userData){
* console.log("A local notification has been received: " + JSON.stringify(userData));
* }
* });
*
* var notificationConfig = {
* message : "Hi, I am a notification",
* soundEnabled : true,
* badgeNumber : 0,
* userData : {"key1" : "value1", "key2": "value2"},
* contentBody : "",
* contentTitle : "",
* date : new Date().valueOf() + 1000
* };
*
* var localNotification = Cocoon.Notification.Local.create(notificationConfig);
*
* Cocoon.Notification.Local.send(localNotification);
* Cocoon.Notification.start();
*/
extension.Local = {};
/**
* This namespace represents the Cocoon Notification extension for push notifications.
* @namespace Cocoon.Notification.Push
*/
extension.Push = {};
/**
* Returns an object that represents the information of a local notification.
* @memberOf Cocoon.Notification.Local
* @function create
* @example
* var notificationConfig = {
* message : "Hi, I am a notification",
* soundEnabled : true,
* badgeNumber : 0,
* userData : {"key1" : "value1", "key2": "value2"},
* contentBody : "",
* contentTitle : "",
* date : new Date().valueOf() + 5000 // It will be fired in 5 seconds.
* };
*
* var localNotification = Cocoon.Notification.Local.create(notificationConfig);
* @param {object} params - The object itself
* @param {string} params.message The notification message. By default, it will be empty.
* @param {boolean} params.soundEnabled A flag that indicates if the sound should be enabled for the notification. By default, it will be true.
* @param {number} params.badgeNumber The number that will appear in the badge of the application icon in the home screen. By default, it will be 0.
* @param {object} params.userData The JSON data to attached to the notification. By default, it will be empty.
* @param {string} params.contentBody The body content to be showed in the expanded notification information. By default, it will be empty.
* @param {string} params.contentTitle The title to be showed in the expanded notification information. By default, it will be empty.
* @param {number} params.date Time in millisecs from 1970 when the notification will be fired. By default, it will be 1 second (1000).
*/
extension.Local.create = function(params)
{
var properties = {
message : "",
soundEnabled : true,
badgeNumber : 0,
userData : {},
contentBody : "",
contentTitle : "",
date : new Date().valueOf() + 1000
};
var args = Cocoon.clone(properties,params);
if (Cocoon.Notification.nativeAvailable)
{
return Cocoon.callNative("IDTK_SRV_NOTIFICATION", "createLocalNotification", args);
}
};
/**
* Returns an object structure that represents the information of a push notification.
* @memberOf Cocoon.Notification.Push
* @function create
* @example
* var notificationConfig = {
* message : "Hi, I am a notification",
* soundEnabled : true,
* badgeNumber : 0,
* userData : {"key1" : "value1", "key2": "value2"},
* channels : "",
* expirationTime : new Date().valueOf() + 3600, // The notification will be no longer valid in a hour.
* expirationTimeInterval : 3600 // The notification will be no longer valid in a hour.
* };
*
* var pushNotification = Cocoon.Notification.Push.create(notificationConfig);
* @param {object} params - The object itself
* @param {string} params.message The notification message. By default, it will be empty.
* @param {boolean} params.soundEnabled A flag that indicates if the sound should be enabled for the notification. By default, it will be true.
* @param {number} params.badgeNumber The number that will appear in the badge of the application icon in the home screen.By default, it will be 0.
* @param {object} params.userData The JSON data to attached to the notification. By default, it will be empty.
* @param {array} params.channels An array containing the channels names this notification will be delivered to. By default, it will be empty.
* @param {number} params.expirationTime A time in seconds from 1970 when the notification is no longer valid and will not be delivered in case it has not already been delivered. By default, it will be 0.
* @param {number} params.expirationTimeInterval An incremental ammount of time in from now when the notification is no longer valid and will not be delivered in case it has not already been delivered. By default, it will be 0.
*/
extension.Push.create = function(params)
{
var properties = {
message : "",
soundEnabled : true,
badgeNumber : 0,
userData : {},
channels : [],
expirationTime : 0,
expirationTimeInterval : 0
};
for (var prop in properties) {
if (!params[prop]) {
params[prop] = properties[prop];
}
}
return params;
};
/**
* Starts processing received notifications. The user must call this method when the game is ready to process notifications. Notifications received before being prepared are stored and processed later.
* @memberOf Cocoon.Notification
* @function start
*/
extension.start = function()
{
if (Cocoon.Notification.nativeAvailable)
{
return Cocoon.callNative("IDTK_SRV_NOTIFICATION", "start", arguments);
}
};
/**
* Registers to be able to receive push notifications.
* @memberOf Cocoon.Notification.Push
* @function register
*/
extension.Push.register = function()
{
if (Cocoon.Notification.nativeAvailable)
{
return Cocoon.callNative("IDTK_SRV_NOTIFICATION", "registerForPushNotifications", arguments, true);
}
};
/**
* Unregisters from receiving push notifications.
* @memberOf Cocoon.Notification.Push
* @function unregister
*/
extension.Push.unregister = function()
{
if (Cocoon.Notification.nativeAvailable)
{
return Cocoon.callNative("IDTK_SRV_NOTIFICATION", "unregisterForPushNotifications", arguments, true);
}
};
/**
* Cancels the local notification with Id provided.
* The last sent local notification will be remove from the notifications bar.
* @memberOf Cocoon.Notification.Local
* @function cancel
*/
extension.Local.cancel = function()
{
if (Cocoon.Notification.nativeAvailable)
{
return Cocoon.callNative("IDTK_SRV_NOTIFICATION", "cancelLocalNotification", arguments);
}
};
/**
* Cancels the last sent local notification.
* The last sent local notification will be remove from the notifications bar.
* @memberOf Cocoon.Notification.Local
* @function cancelLast
*/
extension.Local.cancelLast = function()
{
if (Cocoon.Notification.nativeAvailable)
{
return Cocoon.callNative("IDTK_SRV_NOTIFICATION", "cancelLocalNotification", arguments, true);
}
};
/**
* Cancels all sent local notifications.
* All the notifications will ve removed from the notifications bar.
* @memberOf Cocoon.Notification.Local
* @function cancelAllNotifications
*/
extension.Local.cancelAllNotifications = function()
{
if (Cocoon.Notification.nativeAvailable)
{
return Cocoon.callNative("IDTK_SRV_NOTIFICATION", "cancelAllLocalNotifications", arguments);
}
};
/**
* Sends a local notification.
* @memberOf Cocoon.Notification.Local
* @function send
*/
extension.Local.send = function(localNotification)
{
if (Cocoon.Notification.nativeAvailable)
{
return Cocoon.callNative("IDTK_SRV_NOTIFICATION", "sendLocalNotification", arguments, true);
}
};
/**
* Subscribes to a channel in order to receive notifications targeted to that channel.
* @memberOf Cocoon.Notification
* @function subscribe
*/
extension.subscribe = function(channel)
{
if (Cocoon.Notification.nativeAvailable)
{
return Cocoon.callNative("IDTK_SRV_NOTIFICATION", "subscribe", arguments, true);
}
};
/**
* Unsubscribes from a channel in order to stop receiving notifications targeted to it.
* @memberOf Cocoon.Notification
* @function unsubscribe
*/
extension.unsubscribe = function(channel)
{
if (Cocoon.Notification.nativeAvailable)
{
return Cocoon.callNative("IDTK_SRV_NOTIFICATION", "unsubscribe", arguments, true);
}
};
/**
* Sends a push notification.
* @memberOf Cocoon.Notification.Push
* @function send
*/
extension.Push.send = function(pushNotification)
{
if (Cocoon.Notification.nativeAvailable)
{
return Cocoon.callNative("IDTK_SRV_NOTIFICATION", "sendPushNotification", arguments, true);
}
};
/**
* (iOS only) Sets the badge number for this application.
* This is useful if you want to modify the badge number set by a notification.
* @memberOf Cocoon.Notification
* @function setBadgeNumber
*/
extension.setBadgeNumber = function(badgeNumber)
{
if (Cocoon.Notification.nativeAvailable)
{
return Cocoon.callNative("IDTK_SRV_NOTIFICATION", "setBadgeNumber", arguments);
}
};
/**
* (iOS only) Returns the current badge number.
* @memberOf Cocoon.Notification
* @function getBadgeNumber
*/
extension.getBadgeNumber = function()
{
if (Cocoon.Notification.nativeAvailable)
{
return Cocoon.callNative("IDTK_SRV_NOTIFICATION", "getBadgeNumber", arguments);
}
};
/**
* Returns the last received user data from a Local notification.
* @memberOf Cocoon.Notification.Local
* @function getLastNotificationData
*/
extension.Local.getLastNotificationData = function()
{
if (Cocoon.Notification.nativeAvailable)
{
return Cocoon.callNative("IDTK_SRV_NOTIFICATION", "getLastReceivedLocalNotificationData", arguments);
}
};
/**
* Returns the last received user data from a Push notification.
* @memberOf Cocoon.Notification.Push
* @function getLastNotificationData
*/
extension.Push.getLastNotificationData = function()
{
if (Cocoon.Notification.nativeAvailable)
{
return Cocoon.callNative("IDTK_SRV_NOTIFICATION", "getLastReceivedPushNotificationData", arguments);
}
};
extension.onRegisterForPushNotificationsSucceed = new Cocoon.EventHandler("IDTK_SRV_NOTIFICATION", "Notification", "pushNotificationServiceRegistered");
extension.onUnregisterForPushNotificationsSucceed = new Cocoon.EventHandler("IDTK_SRV_NOTIFICATION", "Notification", "pushNotificationServiceUnregistered");
extension.onRegisterForPushNotificationsFailed = new Cocoon.EventHandler("IDTK_SRV_NOTIFICATION", "Notification", "pushNotificationServiceFailedToRegister");
extension.onPushNotificationReceived = new Cocoon.EventHandler("IDTK_SRV_NOTIFICATION", "Notification", "pushNotificationReceived");
extension.onLocalNotificationReceived = new Cocoon.EventHandler("IDTK_SRV_NOTIFICATION", "Notification", "localNotificationReceived");
extension.onPushNotificationDeliverySucceed = new Cocoon.EventHandler("IDTK_SRV_NOTIFICATION", "Notification", "pushNotificationSuccessfullyDelivered");
extension.onPushNotificationDeliveryFailed = new Cocoon.EventHandler("IDTK_SRV_NOTIFICATION", "Notification", "pushNotificationDeliveryError");
var signal = new Cocoon.Signal.createSignal();
/**
* Allows to listen to events called when a local notification is received.
* - The callback 'received' receives a parameter with the userData of the received notification when a local notification is received.
* @event On received for local notifications callback
* @memberof Cocoon.Notification.Local
* @example
* Cocoon.Notification.Local.on("notification", {
* received : function(userData){
* console.log("A local notification has been received: " + JSON.stringify(userData));
* }
* });
*/
signal.register("notification", {
received : extension.onLocalNotificationReceived
});
extension.Local.on = signal.expose();
var signal = new Cocoon.Signal.createSignal();
/**
* Allows to listen to events called about the registration for push notification.
* - The callback 'success' does not receive any parameter when the registration for push notification succeeds.
* - The callback 'unregister' does not receive any parameter when the unregistration for push notifications succeeds.
* - The callback 'error' receives a parameter with error information when the registration for push notifications fails.
* @event On register for push notifications callbacks
* @memberof Cocoon.Notification.Push
* @example
* Cocoon.Notification.Push.on("register", {
* success : function(){ ... }
* unregister : function(){ ... }
* error : function(error){ ... }
* });
*/
signal.register("register", {
success : extension.onRegisterForPushNotificationsSucceed,
unregister : extension.onUnregisterForPushNotificationsSucceed,
error : extension.onRegisterForPushNotificationsFailed
});
/**
* Allows to listen to events called when a push notification is received.
* - The callback 'received' receives a parameter with the userData of the received notification when a push notification is received.
* @event On received for push notifications callback
* @memberof Cocoon.Notification.Push
* @example
* Cocoon.Notification.Push.on("notification",{
* received : function(userData){
* console.log("A push notification has been received: " + JSON.stringify(userData));
* }
* });
*/
signal.register("notification", {
received : extension.onPushNotificationReceived,
});
/**
* Allows to listen to events called about the delivery proccess.
* - The callback 'success' receives a parameter with the notificationId of the delivered notification when a notification is successfully delivered.
* - The callback 'error' receives a parameter with error information when the delivery of a push notification fails.
* @event On deliver for push notifications callbacks
* @memberof Cocoon.Notification.Push
* @example
* Cocoon.Notification.Push.on("deliver", {
* success : function(notificationId){ ... }
* error : function(error){ ... }
* });
*/
signal.register("deliver", {
success : extension.onPushNotificationDeliverySucceed,
error : extension.onPushNotificationDeliveryFailed
});
extension.Push.on = signal.expose();
return extension;
});;/**
* This namespace provides an abstraction API for all the Social Services.
* Each Social service has it's own official API but can also be used within this API interface.
* Note that this javascript extension can be used to manage Leaderboards and Achievements.
* In order to understand how to use the social javascript extension refer to the social service you would like to to use:
* - Facebook
* - Google Play Games
* - Game Center
* @namespace Cocoon.Social
*/
Cocoon.define("Cocoon.Social" , function(extension){
/**
* This interface provides an abstraction API for all the Social Services, this is an interface and never should be call directly.
* Each Social service has it's own official API but can also be used within this API interface. In order to use this
* interface you should call the method getSocialInterface(); that is available in the following classes:
* - Facebook
* - Google Play Games
* - Game Center
* @namespace Cocoon.Social.Interface
* @example
* // You can use one of these 3 services with the same API.
* // In this example we'll use Facebook
* var service = Cocoon.Social.Facebook;
* //var service = Cocoon.Social.GameCenter;
* //var service = Cocoon.Social.GooglePlayGames;
*
* // Each service has it's own init method,
* // Refer to each service API to know how to initialize it.
* service.init({
* appId: "XXXXXXXXXXXXXXXXXXXXX",
* channelUrl: "//connect.facebook.net/en_US/all.js"
* });
*
* var socialService = service.getSocialInterface();
*
* function loginFacebook() {
* if (!socialService.isLoggedIn()) {
* socialService.login(function(loggedIn, error) {
* if (error) {
* console.error("login error: " + error.message);
* }
* else if (loggedIn) {
* var message = new Cocoon.Social.Message(
* "Hello from the CocoonJS Launcher App! Are you a HTML5 game developer? Come and check out CocoonJS!",
* "https://cocoonjsadmin.ludei.com/static/images/cocoon_logo.png",
* "http://ludei.com",
* "Ludei & CocoonJS",
* "We love HTML5 games!");
*
* socialService.publishMessageWithDialog(message, function(error) {
* if (error) {
* console.error("Error publishing message: " + error.message);
* }
* });
* }
* else {
* console.log("login cancelled");
* }
* });
* }
* }
* loginFacebook();
*/
extension.Interface = function() {
this.onLoginStatusChanged = new Cocoon.EventHandler("", "dummy", "onLoginStatusChanged");
var signal = new Cocoon.Signal.createSignal();
signal.register("loginStatusChanged", this.onLoginStatusChanged);
this.on = signal.expose();
return this;
};
extension.Interface.prototype = {
/**
* Checks if the user is logged in.
* @return {boolean} true if the user is still logged in, false otherwise.
* @function isLoggedIn
* @memberOf Cocoon.Social.Interface
*/
isLoggedIn: function() {
return false;
},
/**
* Authenticates the user.
* @function login
* @memberOf Cocoon.Social.Interface
* @param {function} callback The callback function. Response params: loggedIn(boolean) and error
* @example
* var fb = Cocoon.Social.Facebook;
*
* fb.init({
* appId: "XXXXXXXXXXXXXXXXXXXXX",
* channelUrl: "//connect.facebook.net/en_US/all.js"
* });
*
* var socialService = fb.getSocialInterface();
* var loggedIn = socialService.isLoggedIn();
*
* function loginFacebook() {
* if (!socialService.isLoggedIn()) {
* socialService.login(function(loggedIn, error) {
* if (error) {
* console.error("login error: " + error.message);
* }
* else if (loggedIn) {
* console.log("login succeeded");
* }
* else {
* console.log("login cancelled");
* }
* });
* }
* }
* loginFacebook();
*/
login : function(callback) {
if (callback)
callback(false, {message:"Not implemented!"});
},
/**
* Logs the user out of your application.
* @function logout
* @memberOf Cocoon.Social.Interface
* @param {function} [callback] The callback function. Response params: error.
* @example
* var fb = Cocoon.Social.Facebook;
*
* fb.init({
* appId: "XXXXXXXXXXXXXXXXXXXXX",
* channelUrl: "//connect.facebook.net/en_US/all.js"
* });
*
* var socialService = fb.getSocialInterface();
*
* socialService.logout(function(error){
*
* });
*/
logout: function(callback) {
if (callback)
callback({message:"Not implemented!"});
},
/**
* Returns the information of the currently logged in user.
* @function getLoggedInUser
* @memberOf Cocoon.Social.Interface
* @return {@link Cocoon.Social.User}
*/
getLoggedInUser : function() {
return null;
},
/**
* Checks if the current logged in user has publish permissions.
* @function hasPublishPermissions
* @memberOf Cocoon.Social.Interface
* @param callback The callback function. It receives the following parameters: permissions granted and error
*/
hasPublishPermissions: function(callback) {
callback(true);
},
/**
* Requests publish permissions for the current logged in user.
* @function requestPublishPermissions
* @memberOf Cocoon.Social.Interface
* @param callback The callback function. It receives the following parameters: granted and error
*/
requestPublishPermissions: function(callback) {
if (callback)
callback(true, null);
},
/**
* Retrieves user information for a specific user ID.
* @function requestUser
* @memberOf Cocoon.Social.Interface
* @param {function} callback - The callback function. It receives the following parameters:
* - {@link Cocoon.Social.User}.
* - Error.
* @param {string} userID - The id of the user to retrieve the information from. If no userID is specified, the currently logged in user is assumed.
* @example
* var fb = Cocoon.Social.Facebook;
*
* fb.init({
* appId: "XXXXXXXXXXXXXXXXXXXXX",
* channelUrl: "//connect.facebook.net/en_US/all.js"
* });
*
* var socialService = fb.getSocialInterface();
* var loggedIn = socialService.isLoggedIn();
*
* if (loggedIn) {
* socialService.requestUser(function(user, error) {
* if (error) {
* console.error("requestUser error: " + error.message);
* }
* else {
* console.log(user.userName);
* }
* }, userID);
* }
*/
requestUser: function(callback, userID) {
callback(null, {message:"Not implemented!"});
},
/**
* Requests to retrieve the profile image of a user.
* @function requestUserImage
* @memberOf Cocoon.Social.Interface
* @param {function} callback The callback function. It receives the following parameters:
* - ImageURL.
* - Error.
* @param {string} userID The id of the user to get the image for. If no userID is specified, the currently logged user is used.
* @param {Cocoon.Social.ImageSize} imageSize The desired size of the image. Default value: SMALL.
*/
requestUserImage: function(callback, userID, imageSize) {
callback("", {message:"Not implemented!"})
},
/**
* Retrieves user friends for a specific user ID.
* @function requestFriends
* @memberOf Cocoon.Social.Interface
* @param {function} callback - The callback function. It receives the following parameters:
* - Array of {@link Cocoon.Social.User}.
* - Error.
* @param {string} userID - The id of the user to retrieve the information from. If no userID is specified, the currently logged in user is assumed.
* @example
* var fb = Cocoon.Social.Facebook;
*
* fb.init({
* appId: "XXXXXXXXXXXXXXXXXXXXX",
* channelUrl: "//connect.facebook.net/en_US/all.js"
* });
*
* var socialService = fb.getSocialInterface();
*
* var loggedIn = socialService.isLoggedIn();
*
* if (loggedIn) {
* socialService.requestFriends(function(friends, error) {
* if (error) {
* console.error("requestFriends error: " + error.message);
* }
* else {
* console.log("You have " + friends.length + " friends.");
* }
* });
* }
*/
requestFriends: function(callback, userID) {
callback([], {message:"Not implemented!"});
},
/**
* Shares a message without the intervention of the user.
* This action might require publish permissions. If the user has not publish permissions they are automatically requested.
* @function publishMessage
* @memberOf Cocoon.Social.Interface
* @param {Cocoon.Social.Message} message A object representing the information to be published.
* @param {function} [callback] The callback function. It receives the following parameters: error.
* @example
* var fb = Cocoon.Social.Facebook;
*
* fb.init({
* appId: "XXXXXXXXXXXXXXXXXXXXX",
* channelUrl: "//connect.facebook.net/en_US/all.js"
* });
*
* var socialService = fb.getSocialInterface();
* var loggedIn = socialService.isLoggedIn();
*
* if (loggedIn) {
* var message = new Cocoon.Social.Message(
* "Hello from the CocoonJS Launcher App! Are you a HTML5 game developer? Come and check out CocoonJS!",
* "https://cocoonjsadmin.ludei.com/static/images/cocoon_logo.png",
* "http://ludei.com",
* "Ludei & CocoonJS",
* "We love HTML5 games!");
*
* socialService.publishMessage(message, function(error) {
* if (error) {
* console.error("Error publishing message: " + error.message);
* }
* });
* }
*/
publishMessage: function(message, callback) {
callback({message:"Not implemented!"});
},
/**
* Presents a native/web dialog that allows the user to share a message.
* @function publishMessageWithDialog
* @memberOf Cocoon.Social.Interface
* @param {Cocoon.Social.Message} message A object representing the information to be published
* @param {function} callback The callback function. It receives the following parameters: error
* @example
* var fb = Cocoon.Social.Facebook;
*
* fb.init({
* appId: "XXXXXXXXXXXXXXXXXXXXX",
* channelUrl: "//connect.facebook.net/en_US/all.js"
* });
*
* var socialService = fb.getSocialInterface();
* var loggedIn = socialService.isLoggedIn();
*
* if (loggedIn) {
* var message = new Cocoon.Social.Message(
* "Hello from the CocoonJS Launcher App! Are you a HTML5 game developer? Come and check out CocoonJS!",
* "https://cocoonjsadmin.ludei.com/static/images/cocoon_logo.png",
* "http://ludei.com",
* "Ludei & CocoonJS",
* "We love HTML5 games!");
*
* socialService.publishMessageWithDialog(message, function(error) {
* if (error) {
* console.error("Error publishing message: " + error.message);
* }
* });
* }
*/
publishMessageWithDialog: function(message, callback) {
callback({message:"Not implemented!"});
}
}
extension.SocialGamingService = function() {
Cocoon.Social.SocialGamingService.superclass.constructor.call(this);
return this;
}
extension.SocialGamingService.prototype = {
_cachedAchievements: null,
_achievementsMap: null,
_leaderboardsTemplate: null,
_achievementsTemplate: null,
/**
* Retrieves the score for a user from a specific leaderboard
* @function requestScore
* @memberOf Cocoon.Social.Interface
* @param {function} callback The callback function. It receives the following parameters:
* - {@link Cocoon.Social.Score}.
* - Error.
* @param {Cocoon.Social.ScoreParams} [params] The params to retrieve the score. If no params are specified, the currently logged in user and the default leaderboard are assumed.
*/
requestScore: function(callback, params) {
callback(null, {message:"Not implemented!"})
},
/**
* Submits the score for a user to a specific leaderboard
* @function submitScore
* @memberOf Cocoon.Social.Interface
* @param {number} score The score to submit
* @param {function} [callback] The callback function. Response params: error.
* @param {Cocoon.Social.ScoreParams} [params] The params to submit the score. If no params are specified, the currently logged in user and the default leaderboard are assumed.
*/
submitScore: function(score, callback, params ) {
if (callback)
callback({message:"Not implemented!"})
},
/**
* Shows a modal leaderboard view using a platform dependant view.
* @param {Cocoon.Social.ScoreParams} [params] The params to choose the leaderboard and other settings. If no params are specified the default leaderboard id and settings will be assumed.
* @param {function} [callback] The callback function invoked when the modal leaderboard view is closed by the user. Response params: error.
* @function showLeaderboard
* @memberOf Cocoon.Social.Interface
* @example
* var fb = Cocoon.Social.Facebook;
*
* fb.init({
* appId: "XXXXXXXXXXXXXXXXXXXXX",
* channelUrl: "//connect.facebook.net/en_US/all.js"
* });
*
* var socialService = fb.getSocialInterface();
* var loggedIn = socialService.isLoggedIn();
*
* socialService.showLeaderboard(function(error){
* if (error)
* console.error("showLeaderbord error: " + error.message);
* });
*/
showLeaderboard : function(callback, params) {
if (callback)
callback({message:"Not implemented!"})
},
/**
* Retrieves all the achievements of the application.
* @function requestAllAchievements
* @memberOf Cocoon.Social.Interface
* @param {function} callback The callback function. It receives the following parameters:
* - Array of {@link Cocoon.Social.Achievement}
* - Error.
*/
requestAllAchievements : function(callback) {
callback([], {message:"Not implemented!"})
},
/**
* Retrieves the achievements earned by a user.
* @function requestAchievements
* @memberOf Cocoon.Social.Interface
* @param {function} callback The callback function. It receives the following parameters:
* - Array of {@link Cocoon.Social.Achievement}.
* - Error.
* @param {string} [userId] The id of the user to retrieve the information from. If no userID is specified, the currently logged in user is assumed.
*/
requestAchievements : function(callback, userID) {
callback([], {message:"Not implemented!"})
},
/**
* Submits the achievement for the current logged In user
* @function submitAchievements
* @memberOf Cocoon.Social.Interface
* @param achievementID The achievement ID to submit
* @param callback [callback] The callback function. Response params: error.
* @example
* var fb = Cocoon.Social.Facebook;
*
* fb.init({
* appId: "XXXXXXXXXXXXXXXXXXXXX",
* channelUrl: "//connect.facebook.net/en_US/all.js"
* });
*
* var socialService = fb.getSocialInterface();
*
* socialService.submitAchievement( achievementID, function(error){
* if (error)
* console.error("submitAchievement error: " + error.message);
* });
*/
submitAchievement: function(achievementID, callback) {
if (callback)
callback({message:"Not implemented!"})
},
/**
* Resets all the achievements of the current logged in user
* @function resetAchievements
* @memberOf Cocoon.Social.Interface
* @param {function} [callback] The callback function. Response params: error.
* @example
* var fb = Cocoon.Social.Facebook;
*
* fb.init({
* appId: "XXXXXXXXXXXXXXXXXXXXX",
* channelUrl: "//connect.facebook.net/en_US/all.js"
* });
*
* var socialService = fb.getSocialInterface();
*
* socialService.resetAchievements(function(error){
* if (error)
* console.error("resetAchievements error: " + error.message);
* });
*/
resetAchievements : function(callback) {
if (callback)
callback([], {message:"Not implemented!"})
},
/**
* Shows a modal achievements view using a platform dependant view.
* @param {function} [callback] The callback function invoked when the modal achievements view is closed by the user. Response params: error.
* @function showAchievements
* @memberOf Cocoon.Social.Interface
* @example
* var fb = Cocoon.Social.Facebook;
*
* fb.init({
* appId: "XXXXXXXXXXXXXXXXXXXXX",
* channelUrl: "//connect.facebook.net/en_US/all.js"
* });
*
* var socialService = fb.getSocialInterface();
* var loggedIn = socialService.isLoggedIn();
*
* socialService.showAchievements(function(error){
* if (error)
* console.error("showAchievements error: " + error.message);
* });
*/
showAchievements : function(callback) {
if (!this._achievementsTemplate)
throw "Please, provide a html template for achievements with the setTemplates method";
var dialog = new Cocoon.Widget.WebDialog();
var callbackSent = false;
dialog.show(this._achievementsTemplate, function(error) {
dialog.closed = true;
if (!callbackSent && callback)
callback(error);
});
var me = this;
this.requestAchievements(function(achievements, error){
if (dialog.closed)
return;
if (error) {
callbackSent = true;
if (callback)
callback(error);
return;
}
var achs = [];
if (me._cachedAchievements) {
for (var i = 0; i < me._cachedAchievements.length; ++i) {
var ach = me._cachedAchievements[i];
achs.push(ach);
if (achievements && achievements.length) {
for (var j = 0; j< achievements.length; ++j) {
if (achievements[j].achievementID === ach.achievementID) {
ach.achieved = true;
break;
}
}
}
}
}
var js = "addAchievements(" + JSON.stringify(achs) + ");";
dialog.eval(js);
});
},
/**
* Set the map for using custom achievement IDs.
* The map must be a customID to realID map (accessing map.customID must return the real achievement ID).
* Whenever this map is enabled users are able to submit achievements with the real achievement ID or with the custom one.
* @params {object} map The achievements map. A null map disables this feature.
* @function setAchievementsMap
* @memberOf Cocoon.Social.Interface
*/
setAchievementsMap: function(map) {
this._achievementsMap = map;
if (this._cachedAchievements) {
this.syncAchievementsMap(this._cachedAchievements);
}
},
/**
* Provides some templates to be used in the leaderboards and achievements views
* Some social services (like Facebook) don't have a native view to show achievements or leaderboards views, and use html templates instead.
* @param {string} leaderboardsTemplate Relative path to the leaderboards template.
* @param {string} achievementsTemplate Relative path to the achievements template.
* @function setTemplates
* @memberOf Cocoon.Social.Interface
*/
setTemplates: function(leaderboardsTemplate, achievementsTemplate) {
this._leaderboardsTemplate = leaderboardsTemplate;
this._achievementsTemplate = achievementsTemplate;
},
//Internal utility methods
setCachedAchievements: function(achievements) {
this._cachedAchievements = achievements;
if (achievements && this._achievementsMap) {
this.syncAchievementsMap(this._cachedAchievements);
}
},
findAchievement: function(id) {
if (!this._cachedAchievements)
return null;
for (var i = 0; i < this._cachedAchievements.length; ++i) {
if (id === this._cachedAchievements[i].achievementID) {
return this._cachedAchievements[i];
}
}
return null;
},
translateAchievementID: function(id) {
if (this._achievementsMap) {
for (var customID in this._achievementsMap) {
if (customID == id) { //important: compare with double equal, because id can be numeric
return this._achievementsMap[customID];
}
}
}
return id;
},
syncAchievementsMap: function(achievements) {
if (!this._achievementsMap)
return;
for (var i = 0; i< achievements.length; ++i) {
for (var customID in this._achievementsMap) {
if (this._achievementsMap[customID] === achievements[i].achievementID) {
achievements[i].customID = customID;
}
}
}
}
}
Cocoon.extend(extension.SocialGamingService, extension.Interface);
/**
* This object represents the possible images that can be obtained for a user in the social gaming extension.
* @memberof Cocoon.Social
* @name Cocoon.Social.ImageSize
* @property {object} Cocoon.Social.ImageSize - The object itself
* @property {string} Cocoon.Social.ImageSize.THUMB Represent a thumbnail like image size.
* @property {string} Cocoon.Social.ImageSize.SMALL Represents the small image size.
* @property {string} Cocoon.Social.ImageSize.MEDIUM Represents the medium image size.
* @property {string} Cocoon.Social.ImageSize.LARGE Represents the large image size.
*/
extension.ImageSize =
{
THUMB : "thumb",
SMALL : "small",
MEDIUM : "medium",
LARGE : "large"
};
/**
* The object that represents the information of a user inside the social gaming extension.
* @memberof Cocoon.Social
* @name Cocoon.Social.User
* @property {object} Cocoon.Social.User - The object itself
* @property {string} Cocoon.Social.User.userID The id of the user.
* @property {string} Cocoon.Social.User.userName The user name of the user.
* @property {string} Cocoon.Social.User.userImage If the image URL is not provided by default, fetch it using requestUserImage method.
*/
extension.User = function(userID, userName, userImage)
{
this.userID = userID;
this.userName = userName;
this.userImage = userImage;
return this;
};
/**
* This object represents a message to be published.
* @memberof Cocoon.Social
* @name Cocoon.Social.Message
* @property {object} Cocoon.Social.Message - The object itself
* @property {string} Cocoon.Social.Message.message The message to be published.
* @property {string} Cocoon.Social.Message.mediaURL An URL to a media (image, video, ...).
* @property {string} Cocoon.Social.Message.linkURL An URL to add to the message so the user can click on that link to get more information.
* @property {string} Cocoon.Social.Message.linkText The text that will appear in the message link.
* @property {string} Cocoon.Social.Message.linkCaption The text caption that will appear in the message link.
*/
extension.Message = function(message, mediaURL, linkURL, linkText, linkCaption)
{
this.message = message;
this.mediaURL = mediaURL;
this.linkURL = linkURL;
this.linkText = linkText;
this.linkCaption = linkCaption;
return this;
};
/**
* This object that represents the information of the user score in the application.
* @memberof Cocoon.Social
* @name Cocoon.Social.Score
* @property {object} Cocoon.Social.Score - The object itself
* @property {string} Cocoon.Social.Score.userID The user id.
* @property {number} Cocoon.Social.Score.score The score of the user.
* @property {string} Cocoon.Social.Score.userName The name of the user.
* @property {string} Cocoon.Social.Score.imageURL imageURL The url of the user image.
* @property {number} Cocoon.Social.Score.leaderboardID The id of the leaderboard the score belongs to.
*/
extension.Score = function(userID, score, userName, imageURL, leaderboardID)
{
this.userID = userID;
this.score = score || 0;
this.userName = userName;
this.imageURL = imageURL;
this.leaderboardID = leaderboardID;
return this;
};
/**
* The object that represents params to retrieve or submit scores.
* @memberof Cocoon.Social
* @name Cocoon.Social.ScoreParams
* @property {object} Cocoon.Social.ScoreParams - The object itself
* @property {string} Cocoon.Social.ScoreParams.userID The user id. If no userID is specified the current logged in user is assumed.
* @property {number} Cocoon.Social.ScoreParams.leaderboardID The leaderboard ID. If no leaderboard is specified the default leaderboard is assumed.
* @property {boolean} Cocoon.Social.ScoreParams.friends If enabled the query will get only scores from friends in the social network.
* @property {Cocoon.Social.TimeScope} Cocoon.Social.ScoreParams.timeScope The time scope for the scores.
*/
extension.ScoreParams = function(userID, leaderboardID, friends, timeScope) {
this.userID = userID;
this.leaderboardID = leaderboardID;
this.friends = !!friends;
this.timeScope = timeScope || 2;
}
/**
* This object represents the possible Time Scopes for a leaderboard query.
* @memberof Cocoon.Social
* @name Cocoon.Social.TimeScope
* @property {object} Cocoon.Social.TimeScope - The object itself
* @property {string} Cocoon.Social.TimeScope.ALL_TIME All registered time.
* @property {string} Cocoon.Social.TimeScope.WEEK A week.
* @property {string} Cocoon.Social.TimeScope.TODAY Today.
*/
extension.TimeScope =
{
ALL_TIME: 0,
WEEK: 1,
TODAY:2
};
/**
* This object represents the possible Time Scopes for a leaderboard query.
* @memberof Cocoon.Social
* @name Cocoon.Social.Achievement
* @property {object} Cocoon.Social.Achievement - The object itself
* @property {string} Cocoon.Social.Achievement.achievementID The id of the achievement info.
* @property {string} Cocoon.Social.Achievement.customID The optional custom id of the achievement defined by the user.
* @property {string} Cocoon.Social.Achievement.title The title of the achievement.
* @property {string} Cocoon.Social.Achievement.description The description of the achievement.
* @property {string} Cocoon.Social.Achievement.imageURL The url to the image representing the achievement.
* @property {number} Cocoon.Social.Achievement.points The points value of the achievement.
*/
extension.Achievement = function(achievementID, title, description, imageURL, points)
{
this.achievementID = achievementID;
this.customID = achievementID;
this.title = title;
this.description = description;
this.imageURL = imageURL;
this.points = points || 0;
return this;
};
/**
* Opens a given share native window to share some specific text content in
* any system specific social sharing options. For example, Twitter, Facebook, SMS, Mail, ...
* @memberOf Cocoon.Social
* @function Share
* @param textToShare {string} textToShare The text content that will be shared.
* @example
* Cocoon.Social.share("I have scored more points on Flappy Submarine!! Chooo choooo");
*/
extension.share = function(textToShare) {
if (Cocoon.nativeAvailable){
return Cocoon.callNative("IDTK_APP", "share", arguments, true);
}
else {
// TODO: Is there something we could do to share in a browser?
}
};
return extension;
});;/**
*
* @private
* @namespace Cocoon.Social.Manager
*/
Cocoon.define("Cocoon.Social" , function(extension){
extension.ManagerService = function() {
this.services = [];
}
extension.ManagerService.prototype = {
services:null,
registerSocialService : function(service) {
this.services.push(service);
},
submitAchievement : function(achievementID) {
for (var i = 0; i < this.services.length; ++i) {
var service = this.services[i];
if (!service.readOnlyHint && service.isLoggedIn()) {
service.submitAchievement(achievementID, function(error) {
if (error)
console.error("Error submitting achievement: " + error.message);
});
}
}
},
submitScore : function(score, params) {
for (var i = 0; i < this.services.length; ++i) {
var service = this.services[i];
if (!service.readOnlyHint && service.isLoggedIn()) {
service.submitScore(score, function(error) {
if (error)
console.error("Error submitting score: " + error.message);
}, params);
}
}
},
getLoggedInServices : function() {
var result= [];
for (var i = 0; i < this.services.length; ++i) {
var service = this.services[i];
if (!service.fakeSocialService && service.isLoggedIn()) {
result.push(service);
}
}
return result;
},
isLoggedInAnySocialService : function() {
return this.getLoggedInServices().length > 0;
}
}
extension.Manager = new extension.ManagerService();
return extension;
});;/**
* This namespace represents all the basic functionalities available in the CocoonJS extension API.
* @private
* @namespace Cocoon.Social.LocalStorage
*/
Cocoon.define("Cocoon.Social" , function(extension){
extension.LocalStorageService = function() {
Cocoon.Social.LocalStorageService.superclass.constructor.call(this);
this.fakeSocialService = true;
}
extension.LocalStorageService.prototype = {
loggedIn: false,
keys: {
score: "Cocoon.Social.LocalStorageService.score",
earnedAchievements: "Cocoon.Social.LocalStorageService.earned"
},
isLoggedIn: function() {
return this.loggedIn;
},
login : function(callback) {
if (!this.loggedIn)
this.onLoginStatusChanged.notifyEventListeners(true);
this.loggedIn = true;
if (callback)
setTimeout(function(){callback(true)},0);
},
logout: function(callback) {
if (this.loggedIn)
this.onLoginStatusChanged.notifyEventListeners(true);
this.loggedIn = false;
if (callback)
setTimeout(function(){callback()},0);
},
getLoggedInUser : function() {
return new Cocoon.Social.User("me", "LocalStorage");
},
requestUser: function(callback, userID) {
var user = new Cocoon.Social.User(userID || "me", "LocalStorage");
if (callback)
setTimeout(function(){callback(user)},0);
},
requestScore: function(callback, params) {
var scoreItem = localStorage.getItem(this.keys.score);
var score = parseInt(scoreItem) || 0;
setTimeout(function(){callback(new Cocoon.Social.Score("me", score))},0);
},
submitScore: function(score, callback, params ) {
var scoreItem = localStorage.getItem(this.keys.score);
var topScore = parseInt(scoreItem) || 0;
if (score > topScore)
localStorage.setItem(this.keys.score, score);
if (callback)
setTimeout(function(){callback()},0);
},
getLocalStorageEarnedAchievements: function() {
var achievementsItem = localStorage.getItem(this.keys.earnedAchievements);
var earned = [];
if (achievementsItem) {
var array = JSON.stringify(achievementsItem);
if (array && array.length) {
earned = array;
}
}
return earned;
},
requestAchievements : function(callback, userID) {
var earned = this.getLocalStorageEarnedAchievements();
setTimeout(function(){callback(earned)},0);
},
submitAchievement: function(achievementID, callback) {
if (achievementID === null || typeof achievementID === 'undefined')
throw "No achievementID specified";
var earned = this.getLocalStorageEarnedAchievements();
var exists = false;
for (var i = 0; i< earned.length; ++i) {
if (earned[i] === achievementID) {
exists = true;
break;
}
}
if (!exists) {
earned.push(achievementID);
localStorage.setItem(this.keys.earnedAchievements, JSON.stringify(earned));
}
if (callback)
setTimeout(function(){callback()},0);
},
resetAchievements : function(callback) {
localStorage.removeItem(this.keys.earnedAchievements);
if (callback)
setTimeout(function(){callback()},0);
}
};
Cocoon.extend(extension.LocalStorageService, extension.SocialGamingService);
extension.LocalStorage = new extension.LocalStorageService();
return extension;
});;/**
* This namespace represents all the basic functionalities available in the CocoonJS extension API.
*
*
*
*
*
Warning! This JavaScript extension requires some configuration parameters on the
cloud compiler!
*
*
Warning! This JavaScript extension requires some configuration parameters on the
cloud compiler!
*
*
Warning! This JavaScript extension requires some configuration parameters on the
cloud compiler!.
*
* Here you will find a demo about this namespace:
Facebook demo.
*
*
Warning! This JavaScript extension requires some configuration parameters on the
cloud compiler!
*
*
Warning! This JavaScript extension requires some configuration parameters on the
cloud compiler!
*
*
Warning! This JavaScript extension requires some configuration parameters on the
cloud compiler!
*
*
Warning! This JavaScript extension requires some configuration parameters on the
cloud compiler!
*
*
Warning! This JavaScript extension requires some configuration parameters on the
cloud compiler!
*
