src/widgetservice/widgetservice_api.js

   1 /*
   2  * Copyright (c) 2016 Samsung Electronics Co., Ltd All Rights Reserved
   3  *
   4  *    Licensed under the Apache License, Version 2.0 (the "License");
   5  *    you may not use this file except in compliance with the License.
   6  *    You may obtain a copy of the License at
   7  *
   8  *        http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  *    Unless required by applicable law or agreed to in writing, software
  11  *    distributed under the License is distributed on an "AS IS" BASIS,
  12  *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  *    See the License for the specific language governing permissions and
  14  *    limitations under the License.
  15  */
  16
  17 var validator = xwalk.utils.validator;
  18 var converter = xwalk.utils.converter;
  19 var types = validator.Types;
  20 var T = xwalk.utils.type;
  21 var native = new xwalk.utils.NativeManager(extension);
  22
  23 var WidgetSizeType = {
  24   S_1x1 : '1x1',
  25   S_2x1 : '2x1',
  26   S_2x2 : '2x2',
  27   S_4x1 : '4x1',
  28   S_4x2 : '4x2',
  29   S_4x3 : '4x3',
  30   S_4x4 : '4x4',
  31   S_4x5 : '4x5',
  32   S_4x6 : '4x6',
  33   EASY_1x1 : 'EASY_1x1',
  34   EASY_3x1 : 'EASY_3x1',
  35   EASY_3x3 : 'EASY_3x3',
  36   FULL : 'FULL',
  37 };
  38
  39 function createObjects(data, func, widget) {
  40   var array = [];
  41   var objects = native.getResultObject(data);
  42
  43   objects.forEach(function (d) {
  44     array.push(new func(d, widget));
  45   });
  46
  47   return array;
  48 };
  49
  50 function WidgetSize(data) {
  51   Object.defineProperties(this, {
  52     width: {
  53       value: data.width,
  54       writable: false,
  55       enumerable: true
  56     },
  57     height: {
  58       value: data.height,
  59       writable: false,
  60       enumerable: true
  61     },
  62   });
  63 };
  64
  65 function WidgetVariant(data) {
  66   Object.defineProperties(this, {
  67     sizeType: {
  68       value: data.sizeType,
  69       writable: false,
  70       enumerable: true
  71     },
  72     width: {
  73       value: data.width,
  74       writable: false,
  75       enumerable: true
  76     },
  77     height: {
  78       value: data.height,
  79       writable: false,
  80       enumerable: true
  81     },
  82     previewImagePath: {
  83       value: data.previewImagePath,
  84       writable: false,
  85       enumerable: true
  86     },
  87     needsMouseEvents: {
  88       value: data.needsMouseEvents,
  89       writable: false,
  90       enumerable: true
  91     },
  92     needsTouchEffect: {
  93       value: data.needsTouchEffect,
  94       writable: false,
  95       enumerable: true
  96     },
  97     needsFrame: {
  98       value: data.needsFrame,
  99       writable: false,
 100       enumerable: true
 101     },
 102   });
 103 };
 104
 105 function WidgetInstance(data, widget) {
 106   Object.defineProperties(this, {
 107     widget: {
 108       value: widget,
 109       writable: false,
 110       enumerable: true
 111     },
 112     id: {
 113       value: data.id,
 114       writable: false,
 115       enumerable: true
 116     },
 117   });
 118 };
 119
 120 WidgetInstance.prototype.changeUpdatePeriod = function() {
 121   var args = validator.validateMethod(arguments, [{
 122     name : 'seconds',
 123     type : types.DOUBLE,
 124   }]);
 125
 126   var callArgs = {};
 127   callArgs.widgetId = this.widget.id;
 128   callArgs.instanceId = this.id;
 129   callArgs.seconds = args.seconds;
 130
 131   var ret = native.callSync('WidgetInstance_changeUpdatePeriod', callArgs);
 132
 133   if (native.isFailure(ret)) {
 134     throw native.getErrorObject(ret);
 135   }
 136 };
 137
 138 WidgetInstance.prototype.sendContent = function() {
 139   var args = validator.validateMethod(arguments, [{
 140     name : 'data',
 141     type: types.DICTIONARY,
 142   }, {
 143     name : 'updateIfPaused',
 144     type : types.BOOLEAN,
 145   }]);
 146
 147   var callArgs = {};
 148   callArgs.widgetId = this.widget.id;
 149   callArgs.instanceId = this.id;
 150   callArgs.data = args.data;
 151   callArgs.updateIfPaused = args.updateIfPaused;
 152
 153   var ret = native.callSync('WidgetInstance_sendContent', callArgs);
 154
 155   if (native.isFailure(ret)) {
 156     throw native.getErrorObject(ret);
 157   }
 158 };
 159
 160 WidgetInstance.prototype.getContent = function() {
 161   var args = validator.validateMethod(arguments, [{
 162     name : 'successCallback',
 163     type : types.FUNCTION,
 164   }, {
 165     name : 'errorCallback',
 166     type : types.FUNCTION,
 167   }]);
 168
 169   var callArgs = {};
 170   callArgs.widgetId = this.widget.id;
 171   callArgs.instanceId = this.id;
 172
 173   var callback = function(result) {
 174     if (native.isFailure(result)) {
 175       args.errorCallback(native.getErrorObject(result));
 176     } else {
 177       args.successCallback(native.getResultObject(result));
 178     }
 179   };
 180
 181   var result = native.call('WidgetInstance_getContent', callArgs, callback);
 182   if (native.isFailure(result)) {
 183     throw native.getErrorObject(result);
 184   }
 185 };
 186
 187 function Widget(data) {
 188   Object.defineProperties(this, {
 189     id: {
 190       value: data.id,
 191       writable: false,
 192       enumerable: true
 193     },
 194     applicationId: {
 195       value: data.applicationId,
 196       writable: false,
 197       enumerable: true
 198     },
 199     setupApplicationId: {
 200       value: data.setupApplicationId ? data.setupApplicationId : null,
 201       writable: false,
 202       enumerable: true
 203     },
 204     packageId: {
 205       value: data.packageId,
 206       writable: false,
 207       enumerable: true
 208     },
 209     noDisplay: {
 210       value: data.noDisplay,
 211       writable: false,
 212       enumerable: true
 213     },
 214   });
 215 };
 216
 217 Widget.prototype.getName = function() {
 218   var args = validator.validateMethod(arguments, [{
 219     name : 'locale',
 220     type : types.STRING,
 221     optional : true,
 222     nullable : true
 223   }]);
 224
 225   var callArgs = {};
 226   callArgs.widgetId = this.id;
 227
 228   if (args.locale) {
 229     callArgs.locale = args.locale;
 230   }
 231
 232   var ret = native.callSync('Widget_getName', callArgs);
 233
 234   if (native.isFailure(ret)) {
 235     throw native.getErrorObject(ret);
 236   } else {
 237     return native.getResultObject(ret);
 238   }
 239 };
 240
 241 Widget.prototype.getInstances = function() {
 242   var args = validator.validateMethod(arguments, [{
 243     name : 'successCallback',
 244     type : types.FUNCTION,
 245   }, {
 246     name : 'errorCallback',
 247     type : types.FUNCTION,
 248     optional : true,
 249     nullable : true
 250   }]);
 251
 252   var callback = function(result) {
 253     if (native.isFailure(result)) {
 254       native.callIfPossible(args.errorCallback, native.getErrorObject(result));
 255     } else {
 256       var instances = createObjects(result, WidgetInstance, this);
 257       args.successCallback(instances);
 258     }
 259   }.bind(this);
 260
 261   var callArgs = {};
 262   callArgs.widgetId = this.id;
 263
 264   var result = native.call('Widget_getInstances', callArgs, callback);
 265   if (native.isFailure(result)) {
 266     throw native.getErrorObject(result);
 267   }
 268 };
 269
 270 Widget.prototype.getVariant = function() {
 271   var args = validator.validateMethod(arguments, [{
 272     name : 'sizeType',
 273     type: types.ENUM,
 274     values: T.getValues(WidgetSizeType)
 275   }]);
 276
 277   var callArgs = {};
 278   callArgs.widgetId = this.id;
 279   callArgs.sizeType = args.sizeType;
 280
 281   var ret = native.callSync('Widget_getVariant', callArgs);
 282
 283   if (native.isFailure(ret)) {
 284     throw native.getErrorObject(ret);
 285   } else {
 286     return new WidgetVariant(native.getResultObject(ret));
 287   }
 288 };
 289
 290 Widget.prototype.getVariants = function() {
 291   var args = validator.validateMethod(arguments, [{
 292     name : 'successCallback',
 293     type : types.FUNCTION,
 294   }, {
 295     name : 'errorCallback',
 296     type : types.FUNCTION,
 297     optional : true,
 298     nullable : true
 299   }]);
 300
 301   var callback = function(result) {
 302     if (native.isFailure(result)) {
 303       native.callIfPossible(args.errorCallback, native.getErrorObject(result));
 304     } else {
 305       var variants = createObjects(result, WidgetVariant);
 306       args.successCallback(variants);
 307     }
 308   };
 309
 310   var callArgs = {};
 311   callArgs.widgetId = this.id;
 312
 313   var result = native.call('Widget_getVariants', callArgs, callback);
 314   if (native.isFailure(result)) {
 315     throw native.getErrorObject(result);
 316   }
 317 };
 318
 319 function ListenerManager(native, listenerName) {
 320   this.listeners = {};
 321   this.nextId = 1;
 322   this.nativeSet = false;
 323   this.native = native;
 324   this.listenerName = listenerName;
 325 };
 326
 327 ListenerManager.prototype.onListenerCalled = function(msg) {
 328   for (var watchId in this.listeners) {
 329     if (this.listeners.hasOwnProperty(watchId) ) {
 330       this.listeners[watchId](this.native.getResultObject(msg));
 331     }
 332   }
 333 };
 334
 335 ListenerManager.prototype.addListener = function(callback) {
 336   var id = this.nextId;
 337   if (!this.nativeSet) {
 338     this.native.addListener(this.listenerName, this.onListenerCalled.bind(this));
 339     this.nativeSet = true;
 340   }
 341   this.listeners[id] = callback;
 342   ++this.nextId;
 343   return id;
 344 };
 345
 346 ListenerManager.prototype.removeListener = function(watchId) {
 347   if (this.listeners.hasOwnProperty(watchId)) {
 348     delete this.listeners[watchId];
 349   }
 350 };
 351
 352 var WIDGET_STATE_CHANGE_LISTENER = 'WidgetStateChangeCallback';
 353 var widgetStateChangeListener = new ListenerManager(native, WIDGET_STATE_CHANGE_LISTENER);
 354
 355 Widget.prototype.addStateChangeListener = function() {
 356   var args = validator.validateMethod(arguments, [{
 357     name : 'eventCallback',
 358     type : types.FUNCTION,
 359   }]);
 360
 361   var result = native.callSync('Widget_addStateChangeListener', {widgetId : this.id});
 362   if (native.isFailure(result)) {
 363     throw native.getErrorObject(result);
 364   }
 365
 366   var func = function(msg) {
 367     if (msg.widgetId === this.id) {
 368       args.eventCallback(new WidgetInstance(msg, this), msg.event);
 369     }
 370   }.bind(this);
 371
 372   return widgetStateChangeListener.addListener(func);
 373 };
 374
 375 Widget.prototype.removeStateChangeListener = function() {
 376   var args = validator.validateMethod(arguments, [{
 377     name : 'watchId',
 378     type : types.LONG,
 379   }]);
 380
 381   widgetStateChangeListener.removeListener(args.watchId);
 382
 383   var result = native.callSync('Widget_removeStateChangeListener', {widgetId : this.id});
 384   if (native.isFailure(result)) {
 385     throw native.getErrorObject(result);
 386   }
 387 };
 388
 389 function WidgetServiceManager() {
 390 };
 391
 392 WidgetServiceManager.prototype.getWidget = function() {
 393   var args = validator.validateMethod(arguments, [{
 394     name : 'widgetId',
 395     type : types.STRING,
 396   }]);
 397
 398   var callArgs = {};
 399   callArgs.widgetId = args.widgetId;
 400
 401   var ret = native.callSync('WidgetServiceManager_getWidget', callArgs);
 402
 403   if (native.isFailure(ret)) {
 404     throw native.getErrorObject(ret);
 405   } else {
 406     return new Widget(native.getResultObject(ret));
 407   }
 408 };
 409
 410 WidgetServiceManager.prototype.getWidgets = function() {
 411   var args = validator.validateMethod(arguments, [{
 412     name : 'successCallback',
 413     type : types.FUNCTION,
 414   }, {
 415     name : 'errorCallback',
 416     type : types.FUNCTION,
 417     optional : true,
 418     nullable : true
 419   }, {
 420     name : 'packageId',
 421     type : types.STRING,
 422     optional : true,
 423     nullable : true
 424   }]);
 425
 426   var callback = function(result) {
 427     if (native.isFailure(result)) {
 428       native.callIfPossible(args.errorCallback, native.getErrorObject(result));
 429     } else {
 430       var widgets = createObjects(result, Widget);
 431       args.successCallback(widgets);
 432     }
 433   };
 434
 435   var callArgs = {};
 436   if (args.packageId) {
 437     callArgs.packageId = args.packageId;
 438   }
 439
 440   var result = native.call('WidgetServiceManager_getWidgets', callArgs, callback);
 441   if (native.isFailure(result)) {
 442     throw native.getErrorObject(result);
 443   }
 444 };
 445
 446 WidgetServiceManager.prototype.getPrimaryWidgetId = function() {
 447   var args = validator.validateMethod(arguments, [{
 448     name : 'id',
 449     type : types.STRING,
 450   }]);
 451
 452   var callArgs = {};
 453   callArgs.id = args.id;
 454
 455   var ret = native.callSync('WidgetServiceManager_getPrimaryWidgetId', callArgs);
 456
 457   if (native.isFailure(ret)) {
 458     throw native.getErrorObject(ret);
 459   } else {
 460     return native.getResultObject(ret);
 461   }
 462 };
 463
 464 WidgetServiceManager.prototype.getSize = function() {
 465   var args = validator.validateMethod(arguments, [{
 466     name : 'sizeType',
 467     type: types.ENUM,
 468     values: T.getValues(WidgetSizeType)
 469   }]);
 470
 471   var callArgs = {};
 472   callArgs.sizeType = args.sizeType;
 473
 474   var ret = native.callSync('WidgetServiceManager_getSize', callArgs);
 475
 476   if (native.isFailure(ret)) {
 477     throw native.getErrorObject(ret);
 478   } else {
 479     return new WidgetSize(native.getResultObject(ret));
 480   }
 481 };
 482
 483 //Exports
 484 exports = new WidgetServiceManager();