src/xwalk/runtime/android/core_internal/src/org/xwalk/core/internal/extension/api/messaging/messaging_api.js

   1 // Copyright (c) 2013 Intel Corporation. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 var g_next_async_call_id = 0;
   6 var g_async_calls = [];
   7 var g_listeners = [];
   8
   9 // Preserve 6 spaces to hold onreceived, onsent, ondeliverysuccess,
  10 // ondeliveryerror, onserviceadded and onserviceremoved's
  11 // callback functions.
  12 var g_next_async_call_id = 6;
  13
  14 function AsyncCall(resolve, reject) {
  15   this.resolve = resolve;
  16   this.reject = reject;
  17 }
  18
  19 function createPromise(msg) {
  20   var promise = new Promise(function(resolve, reject) {
  21     g_async_calls[g_next_async_call_id] = new AsyncCall(resolve, reject);
  22   });
  23   msg.asyncCallId = g_next_async_call_id;
  24   extension.postMessage(JSON.stringify(msg));
  25   ++g_next_async_call_id;
  26   return promise;
  27 }
  28
  29 function _isFunction(fn) {
  30   return !!fn && !fn.nodeName && fn.constructor != String
  31     && fn.constructor != RegExp && fn.constructor != Array
  32     && /function/i.test( fn + "" );
  33 }
  34
  35 function SmsManager() {}
  36
  37 SmsManager.prototype.type = "sms";
  38
  39 Object.defineProperty(SmsManager.prototype, 'serviceIDs', {
  40   get: function() {
  41     var _msg = {
  42       cmd: "msg_smsServiceId",
  43     }
  44     return JSON.parse(extension.internal.sendSyncMessage(JSON.stringify(_msg)));
  45   }
  46 });
  47
  48 SmsManager.prototype.send = function(to, text, serviceID) {
  49   var _msg = {
  50     cmd: "msg_smsSend",
  51     data: {
  52       phone: to,
  53       message: text,
  54       serviceID: serviceID
  55     }
  56   }
  57   return postMessage(_msg);
  58 }
  59
  60 SmsManager.prototype.clear = function(serviceID) {
  61   var _msg = {
  62     cmd: "msg_smsClear",
  63     data: {
  64       serviceID: serviceID
  65     }
  66   }
  67   return postMessage(_msg);
  68 }
  69
  70 SmsManager.prototype.segmentInfo = function(text, serviceID) {
  71   var _msg = {
  72     cmd: "msg_smsSegmentInfo",
  73     data: {
  74       text: text,
  75       serviceID: serviceID
  76     }
  77   }
  78   return postMessage(_msg);
  79 }
  80
  81 var sms = new SmsManager();
  82 exports.sms = sms;
  83
  84 Object.defineProperty(exports.sms, 'onreceived', {
  85   set: function(callback) {
  86     _addEventListener(true, 'received', callback);
  87   }
  88 });
  89
  90 Object.defineProperty(exports.sms, 'onsent', {
  91   set: function(callback) {
  92     _addEventListener(true, 'sent', callback);
  93   }
  94 });
  95
  96 Object.defineProperty(exports.sms, 'ondeliverysuccess', {
  97   set: function(callback) {
  98     _addEventListener(true, 'deliverysuccess', callback);
  99   }
 100 });
 101
 102 Object.defineProperty(exports.sms, 'ondeliveryerror', {
 103   set: function(callback) {
 104     _addEventListener(true, 'deliveryerror', callback);
 105   }
 106 });
 107
 108 Object.defineProperty(exports.sms, 'onserviceadded', {
 109   set: function(callback) {
 110     _addEventListener(true, 'serviceadded', callback);
 111   }
 112 });
 113
 114 Object.defineProperty(exports.sms, 'onserviceremoved', {
 115   set: function(callback) {
 116     _addEventListener(true, 'serviceremoved', callback);
 117   }
 118 });
 119
 120 function _addEventListener(isOn, eventName, callback) {
 121   if (typeof eventName !== 'string') {
 122     console.log("Invalid parameters of eventName!");
 123     return -1;
 124   }
 125
 126   if (!isOn && (typeof callback !== 'function')) {
 127     console.log("Invalid parameters of callback!");
 128     return -1;
 129   }
 130
 131   if (isOn && (typeof callback !== null) && (typeof callback !== 'function')) {
 132     console.log("Invalid parameters of callback!");
 133     return -1;
 134   }
 135
 136   var listener = {
 137     'eventName': eventName,
 138     'callback': callback
 139   };
 140
 141   var listener_id;
 142
 143   if (isOn) {
 144     switch(listener.eventName) {
 145       case 'received':
 146         g_listeners[0] = listener;
 147         listener_id = 0;
 148         break;
 149       case 'sent':
 150         g_listeners[1] = listener;
 151         listener_id = 1;
 152         break;
 153       case 'deliverysuccess':
 154         g_listeners[2] = listener;
 155         listener_id = 2;
 156         break;
 157       case 'deliveryerror':
 158         g_listeners[3] = listener;
 159         listener_id = 3;
 160         break;
 161       case 'serviceadded':
 162         g_listeners[4] = listener;
 163         listener_id = 4;
 164         break;
 165       case 'serviceremoved':
 166         g_listeners[5] = listener;
 167         listener_id = 5;
 168         break;
 169       default:
 170         console.log("Invalid event name!");
 171         break;
 172       }
 173     } else {
 174       listener_id = g_next_async_call_id;
 175       g_next_async_call_id += 1;
 176       g_listeners[listener_id] = listener;
 177     }
 178
 179   return listener_id;
 180 }
 181
 182 exports.sms.addEventListener = function(eventName, callback) {
 183   return _addEventListener(false, eventName, callback);
 184 }
 185
 186 function handleEvent(msg) {
 187   for (var id in g_listeners) {
 188     if (g_listeners[id]['eventName'] === msg.cmd && g_listeners[id]['callback']) {
 189       g_listeners[id]['callback'](msg.data);
 190     }
 191   }
 192 }
 193
 194 function MessagingCursor(element) {
 195   this.messageIndex = 0;
 196   this.element = element;
 197 }
 198
 199 MessagingCursor.prototype.next = function() {
 200   var ret = null;
 201   if (this.messageIndex > this.element.length) {
 202     this.messageIndex = this.element.length;
 203   } else {
 204     if (this.element) {
 205       ret = this.element[this.messageIndex];
 206       this.messageIndex++;
 207     }
 208   }
 209   return ret;
 210 }
 211
 212 MessagingCursor.prototype.previous = function() {
 213   var ret = null;
 214   if (this.messageIndex < 0) {
 215     this.messageIndex = 0;
 216   } else {
 217     if (this.element) {
 218       ret = this.element[this.messageIndex];
 219       this.messageIndex--;
 220     }
 221   }
 222   return ret;
 223 }
 224
 225 function handleFindMessages(msgObj) {
 226   if (msgObj.data.error) {
 227     if (_isFunction(g_promises[msgObj.asyncCallId].reject)) {
 228       g_promises[msgObj.asyncCallId].reject(msgObj.data.body);
 229     }
 230   } else {
 231     if (_isFunction(g_promises[msgObj.asyncCallId].resolve)) {
 232       var cursor = new MessagingCursor(msgObj.data.body.results);
 233       g_promises[msgObj.asyncCallId].resolve(cursor);
 234     }
 235   }
 236
 237   delete g_promises[msgObj.asyncCallId];
 238 }
 239
 240 function handlePromise(msgObj) {
 241   if (msgObj.data.error) {
 242     if (_isFunction(g_promises[msgObj.asyncCallId].reject)) {
 243       g_promises[msgObj.asyncCallId].reject(msgObj.data.body);
 244     }
 245   } else {
 246     if (_isFunction(g_promises[msgObj.asyncCallId].resolve)) {
 247       g_promises[msgObj.asyncCallId].resolve(msgObj.data.body);
 248     }
 249   }
 250
 251   delete g_promises[msgObj.asyncCallId];
 252 }
 253
 254 extension.setMessageListener(function(json) {
 255   var _msg = JSON.parse(json);
 256
 257   switch (_msg.cmd) {
 258     case "sent":
 259     case "received":
 260     case "deliverysuccess":
 261     case "deliveryerror":
 262     case "serviceadded":
 263     case "serviceadded": {
 264       handleEvent(_msg);
 265       break;
 266     }
 267     case "msg_findMessages_ret": {
 268       handleFindMessages(_msg);
 269       break;
 270     }
 271     case "msg_smsSend_ret":
 272     case "msg_smsClear_ret":
 273     case "msg_smsSegmentInfo_ret":
 274     case "msg_getMessage_ret":
 275     case "msg_deleteMessage_ret":
 276     case "msg_deleteConversation_ret":
 277     case "msg_markMessageRead_ret":
 278     case "msg_markConversationRead_ret": {
 279       handlePromise(_msg);
 280       break;
 281     }
 282     default:
 283       break;
 284   }
 285 });
 286
 287 exports.findMessages = function(filter, options) {
 288   var _msg = {
 289     cmd: "msg_findMessages",
 290     data: {
 291       filter: filter,
 292       options: options
 293     }
 294   }
 295   return postMessage(_msg);
 296 }
 297
 298 exports.findConversations = function(groupBy, filter, options) {
 299   // TODO:(shawn) Spec is not ready for this part.
 300 }
 301
 302 exports.getMessage = function(type, messageID) {
 303   var _msg = {
 304     cmd: "msg_getMessage",
 305     data: {
 306       type: type,
 307       messageID: messageID
 308     }
 309   }
 310   return postMessage(_msg);
 311 }
 312
 313 exports.deleteMessage = function(type, messageID) {
 314   var _msg = {
 315     cmd: "msg_deleteMessage",
 316     data: {
 317       type: type,
 318       messageID: messageID
 319     }
 320   }
 321   return postMessage(_msg);
 322 }
 323
 324 exports.deleteConversation = function(type, conversationID) {
 325   var _msg = {
 326     cmd: "msg_deleteConversation",
 327     data: {
 328       type: type,
 329       conversationID: conversationID
 330     }
 331   }
 332   return postMessage(_msg);
 333 }
 334
 335 exports.markMessageRead = function(type, messageID, value) {
 336   value = (typeof value === 'undefined') ? true : value;
 337   var _msg = {
 338     cmd: "msg_markMessageRead",
 339     data: {
 340       type: type,
 341       messageID: messageID,
 342       value: value
 343     }
 344   }
 345   return postMessage(_msg);
 346 }
 347
 348 exports.markConversationRead = function(type, conversationID, value) {
 349   value = (typeof value === 'undefined') ? true : value;
 350   var _msg = {
 351     cmd: "msg_markConversationRead",
 352     data: {
 353       type: type,
 354       conversationID: conversationID,
 355       value: value
 356     }
 357   }
 358   return postMessage(_msg);
 359 }