rho-tau-extensions 5.5.17

data/libs/crosswalk/ext/platform/android/adds/res/raw/launch_screen_api.js

@@ -0,0 +1,9 @@
+/**
+ * Copyright (c) 2014 Intel Corporation. All rights reserved.
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+window.screen.show = function() {
+  extension.postMessage("hideLaunchScreen");
+};

data/libs/crosswalk/ext/platform/android/adds/res/raw/messaging_api.js

@@ -0,0 +1,359 @@
+// Copyright (c) 2013 Intel Corporation. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+var g_next_async_call_id = 0;
+var g_async_calls = [];
+var g_listeners = [];
+
+// Preserve 6 spaces to hold onreceived, onsent, ondeliverysuccess,
+// ondeliveryerror, onserviceadded and onserviceremoved's
+// callback functions.
+var g_next_async_call_id = 6;
+
+function AsyncCall(resolve, reject) {
+  this.resolve = resolve;
+  this.reject = reject;
+}
+
+function createPromise(msg) {
+  var promise = new Promise(function(resolve, reject) {
+    g_async_calls[g_next_async_call_id] = new AsyncCall(resolve, reject);
+  });
+  msg.asyncCallId = g_next_async_call_id;
+  extension.postMessage(JSON.stringify(msg));
+  ++g_next_async_call_id;
+  return promise;
+}
+
+function _isFunction(fn) {
+  return !!fn && !fn.nodeName && fn.constructor != String
+    && fn.constructor != RegExp && fn.constructor != Array
+    && /function/i.test( fn + "" );
+}
+
+function SmsManager() {}
+
+SmsManager.prototype.type = "sms";
+
+Object.defineProperty(SmsManager.prototype, 'serviceIDs', {
+  get: function() {
+    var _msg = {
+      cmd: "msg_smsServiceId",
+    }
+    return JSON.parse(extension.internal.sendSyncMessage(JSON.stringify(_msg)));
+  }
+});
+
+SmsManager.prototype.send = function(to, text, serviceID) {
+  var _msg = {
+    cmd: "msg_smsSend",
+    data: {
+      phone: to,
+      message: text,
+      serviceID: serviceID
+    }
+  }
+  return createPromise(_msg);
+}
+
+SmsManager.prototype.clear = function(serviceID) {
+  var _msg = {
+    cmd: "msg_smsClear",
+    data: {
+      serviceID: serviceID
+    }
+  }  
+  return createPromise(_msg);
+}
+
+SmsManager.prototype.segmentInfo = function(text, serviceID) {
+  var _msg = {
+    cmd: "msg_smsSegmentInfo",
+    data: {
+      text: text,
+      serviceID: serviceID
+    }
+  }
+  return createPromise(_msg);
+}
+
+var sms = new SmsManager();
+exports.sms = sms;
+
+Object.defineProperty(exports.sms, 'onreceived', {
+  set: function(callback) {
+    _addEventListener(true, 'received', callback);
+  }
+});
+
+Object.defineProperty(exports.sms, 'onsent', {
+  set: function(callback) {
+    _addEventListener(true, 'sent', callback);
+  }
+});
+
+Object.defineProperty(exports.sms, 'ondeliverysuccess', {
+  set: function(callback) {
+    _addEventListener(true, 'deliverysuccess', callback);
+  }
+});
+
+Object.defineProperty(exports.sms, 'ondeliveryerror', {
+  set: function(callback) {
+    _addEventListener(true, 'deliveryerror', callback);
+  }
+});
+
+Object.defineProperty(exports.sms, 'onserviceadded', {
+  set: function(callback) {
+    _addEventListener(true, 'serviceadded', callback);
+  }
+});
+
+Object.defineProperty(exports.sms, 'onserviceremoved', {
+  set: function(callback) {
+    _addEventListener(true, 'serviceremoved', callback);
+  }
+});
+
+function _addEventListener(isOn, eventName, callback) {
+  if (typeof eventName !== 'string') {
+    console.log("Invalid parameters of eventName!");
+    return -1;
+  }
+
+  if (!isOn && (typeof callback !== 'function')) {
+    console.log("Invalid parameters of callback!");
+    return -1;
+  }
+
+  if (isOn && (typeof callback !== null) && (typeof callback !== 'function')) {
+    console.log("Invalid parameters of callback!");
+    return -1;
+  }
+
+  var listener = {
+    'eventName': eventName,
+    'callback': callback
+  };
+
+  var listener_id;
+
+  if (isOn) {
+    switch(listener.eventName) {
+      case 'received':
+        g_listeners[0] = listener;
+        listener_id = 0;
+        break;
+      case 'sent':
+        g_listeners[1] = listener;
+        listener_id = 1;
+        break;
+      case 'deliverysuccess':
+        g_listeners[2] = listener;
+        listener_id = 2;
+        break;
+      case 'deliveryerror':
+        g_listeners[3] = listener;
+        listener_id = 3;
+        break;
+      case 'serviceadded':
+        g_listeners[4] = listener;
+        listener_id = 4;
+        break;
+      case 'serviceremoved':
+        g_listeners[5] = listener;
+        listener_id = 5;
+        break;
+      default:
+        console.log("Invalid event name!");
+        break;
+      }
+    } else {
+      listener_id = g_next_async_call_id;
+      g_next_async_call_id += 1;
+      g_listeners[listener_id] = listener;
+    }
+
+  return listener_id;
+}
+
+exports.sms.addEventListener = function(eventName, callback) {
+  return _addEventListener(false, eventName, callback);
+}
+
+function handleEvent(msg) {
+  for (var id in g_listeners) {
+    if (g_listeners[id]['eventName'] === msg.cmd && g_listeners[id]['callback']) {
+      g_listeners[id]['callback'](msg.data);
+    }
+  }
+}
+
+function MessagingCursor(element) {
+  this.messageIndex = 0;
+  this.element = element;
+}
+
+MessagingCursor.prototype.next = function() {
+  var ret = null;
+  if (this.messageIndex > this.element.length) { 
+    this.messageIndex = this.element.length;
+  } else {
+    if (this.element) {
+      ret = this.element[this.messageIndex];
+      this.messageIndex++;
+    }
+  }
+  return ret;
+}
+
+MessagingCursor.prototype.previous = function() {
+  var ret = null;
+  if (this.messageIndex < 0) { 
+    this.messageIndex = 0;
+  } else {
+    if (this.element) {
+      ret = this.element[this.messageIndex];
+      this.messageIndex--;
+    }
+  }
+  return ret;
+}
+
+function handleFindMessages(msgObj) {
+  if (msgObj.data.error) {
+    if (_isFunction(g_promises[msgObj.asyncCallId].reject)) {
+      g_promises[msgObj.asyncCallId].reject(msgObj.data.body);
+    }
+  } else {
+    if (_isFunction(g_promises[msgObj.asyncCallId].resolve)) {
+      var cursor = new MessagingCursor(msgObj.data.body.results);
+      g_promises[msgObj.asyncCallId].resolve(cursor);
+    }
+  }
+
+  delete g_promises[msgObj.asyncCallId];
+}
+
+function handlePromise(msgObj) {
+  if (msgObj.data.error) {
+    if (_isFunction(g_promises[msgObj.asyncCallId].reject)) {
+      g_promises[msgObj.asyncCallId].reject(msgObj.data.body);
+    }
+  } else {
+    if (_isFunction(g_promises[msgObj.asyncCallId].resolve)) {
+      g_promises[msgObj.asyncCallId].resolve(msgObj.data.body);
+    }
+  }
+
+  delete g_promises[msgObj.asyncCallId];
+}
+
+extension.setMessageListener(function(json) {
+  var _msg = JSON.parse(json);
+
+  switch (_msg.cmd) {
+    case "sent":
+    case "received":
+    case "deliverysuccess":
+    case "deliveryerror":
+    case "serviceadded":
+    case "serviceadded": {
+      handleEvent(_msg);
+      break;
+    }
+    case "msg_findMessages_ret": {
+      handleFindMessages(_msg);
+      break;
+    }
+    case "msg_smsSend_ret":
+    case "msg_smsClear_ret":
+    case "msg_smsSegmentInfo_ret":
+    case "msg_getMessage_ret":
+    case "msg_deleteMessage_ret":
+    case "msg_deleteConversation_ret":
+    case "msg_markMessageRead_ret":
+    case "msg_markConversationRead_ret": {
+      handlePromise(_msg);
+      break;
+    }
+    default:
+      break;
+  }
+});
+
+exports.findMessages = function(filter, options) {
+  var _msg = {
+    cmd: "msg_findMessages",
+    data: {
+      filter: filter,
+      options: options
+    }
+  }
+  return createPromise(_msg);
+}
+
+exports.findConversations = function(groupBy, filter, options) {
+  // TODO:(shawn) Spec is not ready for this part.
+}
+
+exports.getMessage = function(type, messageID) {
+  var _msg = {
+    cmd: "msg_getMessage",
+    data: {
+      type: type,
+      messageID: messageID
+    }
+  }
+  return createPromise(_msg);
+}
+
+exports.deleteMessage = function(type, messageID) {
+  var _msg = {
+    cmd: "msg_deleteMessage",
+    data: {
+      type: type,
+      messageID: messageID
+    }
+  }
+  return createPromise(_msg);
+}
+
+exports.deleteConversation = function(type, conversationID) {
+  var _msg = {
+    cmd: "msg_deleteConversation",
+    data: {
+      type: type,
+      conversationID: conversationID
+    }
+  }
+  return createPromise(_msg);
+}
+
+exports.markMessageRead = function(type, messageID, value) {
+  value = (typeof value === 'undefined') ? true : value;
+  var _msg = {
+    cmd: "msg_markMessageRead",
+    data: {
+      type: type,
+      messageID: messageID,
+      value: value
+    }
+  }
+  return createPromise(_msg);
+}
+
+exports.markConversationRead = function(type, conversationID, value) {
+  value = (typeof value === 'undefined') ? true : value;
+  var _msg = {
+    cmd: "msg_markConversationRead",
+    data: {
+      type: type,
+      conversationID: conversationID,
+      value: value
+    }
+  }
+  return createPromise(_msg);
+}

data/libs/crosswalk/ext/platform/android/adds/res/raw/presentation_api.js

@@ -0,0 +1,144 @@
+/**
+ * Copyright (c) 2013 Intel Corporation. All rights reserved.
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+var v8toolsNative = requireNative("v8tools");
+
+var DISPLAY_AVAILABLE_CHANGE_EVENT = "displayavailablechange";
+var _listeners = {};
+var _displayAvailable = false;
+var _nextRequestId = 0;
+var _showRequests = {};
+
+function DOMError(msg) {
+  this.name = msg;
+}
+
+function ShowRequest(id, successCallback, errorCallback) {
+  this._requestId = id;
+  this._successCallback = successCallback;
+  this._errorCallback = errorCallback;
+}
+
+/* TODO(hmin): Add Promise support instead of callback approach. */
+function requestShowPresentation(url, successCallback, errorCallback) {
+  if (typeof url !== "string" || typeof successCallback !== "function") {
+    console.error("Invalid parameter for presentation.requestShow!");
+    return;
+  }
+
+  // errorCallback is optional.
+  if (errorCallback && typeof errorCallback != "function") {
+    console.error("Invalid parameter for presentation.requestShow!");
+    return;
+  }
+
+  var requestId = ++_nextRequestId;
+  var request = new ShowRequest(requestId, successCallback, errorCallback);
+  _showRequests[requestId] = request;
+  // Requested url should be absolute.
+  // If the requested url is relative, we need to combine it with baseUrl to make it absolute.
+  var baseUrl = location.href.substring(0, location.href.lastIndexOf("/")+1);
+
+  var message = { "cmd": "RequestShow", "requestId": requestId, "url": url, "baseUrl": baseUrl };
+  extension.postMessage(JSON.stringify(message));
+}
+
+function addEventListener(name, callback, useCapture /* ignored */) {
+  if (typeof name !== "string" || typeof callback !== "function") {
+    console.error("Invalid parameter for presentation.addEventListener!");
+    return;
+  }
+
+  if (!_listeners[name])
+    _listeners[name] = [];
+  _listeners[name].push(callback);
+}
+
+function removeEventListener(name, callback) {
+  if (typeof name !== "string" || typeof callback !== "function") {
+    console.error("Invalid parameter for presentation.removeEventListener!");
+    return;
+  }
+
+  if (_listeners[name]) {
+    var index = _listeners[name].indexOf(callback);
+    if (index != -1)
+      _listeners[name].splice(index, 1);
+  }
+}
+
+function handleDisplayAvailableChange(isAvailable) {
+  if (_displayAvailable == isAvailable)
+    return;
+
+  _displayAvailable = isAvailable;
+  if (!_listeners[DISPLAY_AVAILABLE_CHANGE_EVENT])
+    return;
+
+  var length = _listeners[DISPLAY_AVAILABLE_CHANGE_EVENT].length;
+  for (var i = 0; i < length; ++i) {
+    _listeners[DISPLAY_AVAILABLE_CHANGE_EVENT][i].apply(null, null);
+  }
+}
+
+function handleShowSucceeded(requestId, viewId) {
+  var request = _showRequests[requestId];
+  if (request) {
+    var view = v8toolsNative.getWindowObject(viewId);
+    request._successCallback.apply(null, [view]);
+    delete _showRequests[requestId];
+  }
+}
+
+function handleShowFailed(requestId, errorMessage) {
+  var request = _showRequests[requestId];
+  if (request) {
+    var error = new DOMError(errorMessage);
+    if (request._errorCallback)
+      request._errorCallback.apply(null, [error]);
+    delete _showRequests[requestId];
+  }
+}
+
+extension.setMessageListener(function(json) {
+  var msg = JSON.parse(json);
+  if (msg.cmd == "DisplayAvailableChange") {
+    /* Using setTimeout here to ensure the error in user-defined event handler
+       would be captured in developer tools. */
+    setTimeout(function() {
+      handleDisplayAvailableChange(msg.data);
+    }, 0);
+  } else if (msg.cmd == "ShowSucceeded") {
+    setTimeout(function() {
+      handleShowSucceeded(msg.requestId, parseInt(msg.data) /* view id */);
+    }, 0);
+  } else if (msg.cmd == "ShowFailed") {
+    setTimeout(function() {
+      handleShowFailed(msg.requestId, msg.data /* error message */);
+    }, 0);
+  } else {
+    console.error("Invalid message : " + msg.cmd);
+  }
+})
+
+exports.requestShow = requestShowPresentation;
+exports.addEventListener = addEventListener;
+exports.removeEventListener = removeEventListener;
+exports.__defineSetter__("on" + DISPLAY_AVAILABLE_CHANGE_EVENT,
+  function(callback) {
+    if (callback)
+      addEventListener(DISPLAY_AVAILABLE_CHANGE_EVENT, callback);
+    else
+      removeEventListener(DISPLAY_AVAILABLE_CHANGE_EVENT,
+                          this.ondisplayavailablechange);
+  }
+);
+
+exports.__defineGetter__("displayAvailable", function() {
+  var res = extension.internal.sendSyncMessage("QueryDisplayAvailability");
+  _displayAvailable = (res == "true" ? true : false);
+  return _displayAvailable;
+});