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         {
 123             name: 'seconds',
 124             type: types.DOUBLE
 125         }
 126     ]);
 127
 128     var callArgs = {};
 129     callArgs.widgetId = this.widget.id;
 130     callArgs.instanceId = this.id;
 131     callArgs.seconds = args.seconds;
 132
 133     var ret = native.callSync('WidgetInstance_changeUpdatePeriod', callArgs);
 134
 135     if (native.isFailure(ret)) {
 136         throw native.getErrorObject(ret);
 137     }
 138 };
 139
 140 WidgetInstance.prototype.sendContent = function() {
 141     var args = validator.validateMethod(arguments, [
 142         {
 143             name: 'data',
 144             type: types.DICTIONARY
 145         },
 146         {
 147             name: 'updateIfPaused',
 148             type: types.BOOLEAN
 149         }
 150     ]);
 151
 152     var callArgs = {};
 153     callArgs.widgetId = this.widget.id;
 154     callArgs.instanceId = this.id;
 155     callArgs.data = args.data;
 156     callArgs.updateIfPaused = args.updateIfPaused;
 157
 158     var ret = native.callSync('WidgetInstance_sendContent', callArgs);
 159
 160     if (native.isFailure(ret)) {
 161         throw native.getErrorObject(ret);
 162     }
 163 };
 164
 165 WidgetInstance.prototype.getContent = function() {
 166     var args = validator.validateMethod(arguments, [
 167         {
 168             name: 'successCallback',
 169             type: types.FUNCTION
 170         },
 171         {
 172             name: 'errorCallback',
 173             type: types.FUNCTION
 174         }
 175     ]);
 176
 177     var callArgs = {};
 178     callArgs.widgetId = this.widget.id;
 179     callArgs.instanceId = this.id;
 180
 181     var callback = function(result) {
 182         if (native.isFailure(result)) {
 183             args.errorCallback(native.getErrorObject(result));
 184         } else {
 185             args.successCallback(native.getResultObject(result));
 186         }
 187     };
 188
 189     var result = native.call('WidgetInstance_getContent', callArgs, callback);
 190     if (native.isFailure(result)) {
 191         throw native.getErrorObject(result);
 192     }
 193 };
 194
 195 function Widget(data) {
 196     Object.defineProperties(this, {
 197         id: {
 198             value: data.id,
 199             writable: false,
 200             enumerable: true
 201         },
 202         applicationId: {
 203             value: data.applicationId,
 204             writable: false,
 205             enumerable: true
 206         },
 207         setupApplicationId: {
 208             value: data.setupApplicationId ? data.setupApplicationId : null,
 209             writable: false,
 210             enumerable: true
 211         },
 212         packageId: {
 213             value: data.packageId,
 214             writable: false,
 215             enumerable: true
 216         },
 217         noDisplay: {
 218             value: data.noDisplay,
 219             writable: false,
 220             enumerable: true
 221         }
 222     });
 223 }
 224
 225 Widget.prototype.getName = function() {
 226     var args = validator.validateMethod(arguments, [
 227         {
 228             name: 'locale',
 229             type: types.STRING,
 230             optional: true,
 231             nullable: true
 232         }
 233     ]);
 234
 235     var callArgs = {};
 236     callArgs.widgetId = this.id;
 237
 238     if (args.locale) {
 239         callArgs.locale = args.locale;
 240     }
 241
 242     var ret = native.callSync('Widget_getName', callArgs);
 243
 244     if (native.isFailure(ret)) {
 245         throw native.getErrorObject(ret);
 246     } else {
 247         return native.getResultObject(ret);
 248     }
 249 };
 250
 251 Widget.prototype.getInstances = function() {
 252     var args = validator.validateMethod(arguments, [
 253         {
 254             name: 'successCallback',
 255             type: types.FUNCTION
 256         },
 257         {
 258             name: 'errorCallback',
 259             type: types.FUNCTION,
 260             optional: true,
 261             nullable: true
 262         }
 263     ]);
 264
 265     var callback = function(result) {
 266         if (native.isFailure(result)) {
 267             native.callIfPossible(args.errorCallback, native.getErrorObject(result));
 268         } else {
 269             var instances = createObjects(result, WidgetInstance, this);
 270             args.successCallback(instances);
 271         }
 272     }.bind(this);
 273
 274     var callArgs = {};
 275     callArgs.widgetId = this.id;
 276
 277     var result = native.call('Widget_getInstances', callArgs, callback);
 278     if (native.isFailure(result)) {
 279         throw native.getErrorObject(result);
 280     }
 281 };
 282
 283 Widget.prototype.getVariant = function() {
 284     var args = validator.validateMethod(arguments, [
 285         {
 286             name: 'sizeType',
 287             type: types.ENUM,
 288             values: T.getValues(WidgetSizeType)
 289         }
 290     ]);
 291
 292     var callArgs = {};
 293     callArgs.widgetId = this.id;
 294     callArgs.sizeType = args.sizeType;
 295
 296     var ret = native.callSync('Widget_getVariant', callArgs);
 297
 298     if (native.isFailure(ret)) {
 299         throw native.getErrorObject(ret);
 300     } else {
 301         return new WidgetVariant(native.getResultObject(ret));
 302     }
 303 };
 304
 305 Widget.prototype.getVariants = function() {
 306     var args = validator.validateMethod(arguments, [
 307         {
 308             name: 'successCallback',
 309             type: types.FUNCTION
 310         },
 311         {
 312             name: 'errorCallback',
 313             type: types.FUNCTION,
 314             optional: true,
 315             nullable: true
 316         }
 317     ]);
 318
 319     var callback = function(result) {
 320         if (native.isFailure(result)) {
 321             native.callIfPossible(args.errorCallback, native.getErrorObject(result));
 322         } else {
 323             var variants = createObjects(result, WidgetVariant);
 324             args.successCallback(variants);
 325         }
 326     };
 327
 328     var callArgs = {};
 329     callArgs.widgetId = this.id;
 330
 331     var result = native.call('Widget_getVariants', callArgs, callback);
 332     if (native.isFailure(result)) {
 333         throw native.getErrorObject(result);
 334     }
 335 };
 336
 337 function ListenerManager(native, listenerName) {
 338     this.listeners = {};
 339     this.nextId = 1;
 340     this.nativeSet = false;
 341     this.native = native;
 342     this.listenerName = listenerName;
 343 }
 344
 345 ListenerManager.prototype.onListenerCalled = function(msg) {
 346     for (var watchId in this.listeners) {
 347         if (this.listeners.hasOwnProperty(watchId)) {
 348             this.listeners[watchId](this.native.getResultObject(msg));
 349         }
 350     }
 351 };
 352
 353 ListenerManager.prototype.addListener = function(callback) {
 354     var id = this.nextId;
 355     if (!this.nativeSet) {
 356         this.native.addListener(this.listenerName, this.onListenerCalled.bind(this));
 357         this.nativeSet = true;
 358     }
 359     this.listeners[id] = callback;
 360     ++this.nextId;
 361     return id;
 362 };
 363
 364 ListenerManager.prototype.removeListener = function(watchId) {
 365     if (this.listeners.hasOwnProperty(watchId)) {
 366         delete this.listeners[watchId];
 367     }
 368 };
 369
 370 var WIDGET_STATE_CHANGE_LISTENER = 'WidgetStateChangeCallback';
 371 var widgetStateChangeListener = new ListenerManager(native, WIDGET_STATE_CHANGE_LISTENER);
 372
 373 Widget.prototype.addStateChangeListener = function() {
 374     var args = validator.validateMethod(arguments, [
 375         {
 376             name: 'eventCallback',
 377             type: types.FUNCTION
 378         }
 379     ]);
 380
 381     var result = native.callSync('Widget_addStateChangeListener', { widgetId: this.id });
 382     if (native.isFailure(result)) {
 383         throw native.getErrorObject(result);
 384     }
 385
 386     var func = function(msg) {
 387         if (msg.widgetId === this.id) {
 388             args.eventCallback(new WidgetInstance(msg, this), msg.event);
 389         }
 390     }.bind(this);
 391
 392     return widgetStateChangeListener.addListener(func);
 393 };
 394
 395 Widget.prototype.removeStateChangeListener = function() {
 396     var args = validator.validateMethod(arguments, [
 397         {
 398             name: 'watchId',
 399             type: types.LONG
 400         }
 401     ]);
 402
 403     widgetStateChangeListener.removeListener(args.watchId);
 404
 405     var result = native.callSync('Widget_removeStateChangeListener', {
 406         widgetId: this.id
 407     });
 408     if (native.isFailure(result)) {
 409         throw native.getErrorObject(result);
 410     }
 411 };
 412
 413 function WidgetServiceManager() {}
 414
 415 WidgetServiceManager.prototype.getWidget = function() {
 416     var args = validator.validateMethod(arguments, [
 417         {
 418             name: 'widgetId',
 419             type: types.STRING
 420         }
 421     ]);
 422
 423     var callArgs = {};
 424     callArgs.widgetId = args.widgetId;
 425
 426     var ret = native.callSync('WidgetServiceManager_getWidget', callArgs);
 427
 428     if (native.isFailure(ret)) {
 429         throw native.getErrorObject(ret);
 430     } else {
 431         return new Widget(native.getResultObject(ret));
 432     }
 433 };
 434
 435 WidgetServiceManager.prototype.getWidgets = function() {
 436     var args = validator.validateMethod(arguments, [
 437         {
 438             name: 'successCallback',
 439             type: types.FUNCTION
 440         },
 441         {
 442             name: 'errorCallback',
 443             type: types.FUNCTION,
 444             optional: true,
 445             nullable: true
 446         },
 447         {
 448             name: 'packageId',
 449             type: types.STRING,
 450             optional: true,
 451             nullable: true
 452         }
 453     ]);
 454
 455     var callback = function(result) {
 456         if (native.isFailure(result)) {
 457             native.callIfPossible(args.errorCallback, native.getErrorObject(result));
 458         } else {
 459             var widgets = createObjects(result, Widget);
 460             args.successCallback(widgets);
 461         }
 462     };
 463
 464     var callArgs = {};
 465     if (args.packageId) {
 466         callArgs.packageId = args.packageId;
 467     }
 468
 469     var result = native.call('WidgetServiceManager_getWidgets', callArgs, callback);
 470     if (native.isFailure(result)) {
 471         throw native.getErrorObject(result);
 472     }
 473 };
 474
 475 WidgetServiceManager.prototype.getPrimaryWidgetId = function() {
 476     var args = validator.validateMethod(arguments, [
 477         {
 478             name: 'id',
 479             type: types.STRING
 480         }
 481     ]);
 482
 483     var callArgs = {};
 484     callArgs.id = args.id;
 485
 486     var ret = native.callSync('WidgetServiceManager_getPrimaryWidgetId', callArgs);
 487
 488     if (native.isFailure(ret)) {
 489         throw native.getErrorObject(ret);
 490     } else {
 491         return native.getResultObject(ret);
 492     }
 493 };
 494
 495 WidgetServiceManager.prototype.getSize = function() {
 496     var args = validator.validateMethod(arguments, [
 497         {
 498             name: 'sizeType',
 499             type: types.ENUM,
 500             values: T.getValues(WidgetSizeType)
 501         }
 502     ]);
 503
 504     var callArgs = {};
 505     callArgs.sizeType = args.sizeType;
 506
 507     var ret = native.callSync('WidgetServiceManager_getSize', callArgs);
 508
 509     if (native.isFailure(ret)) {
 510         throw native.getErrorObject(ret);
 511     } else {
 512         return new WidgetSize(native.getResultObject(ret));
 513     }
 514 };
 515
 516 //Exports
 517 exports = new WidgetServiceManager();