src/datacontrol/datacontrol_api.js

   1 /*
   2  * Copyright (c) 2015 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 type_ = xwalk.utils.type;
  21 var native_ = new xwalk.utils.NativeManager(extension);
  22
  23 var DATA_CONTROL_MANAGER_LISTENER_ID = 'DataControlManagerChangeCallback';
  24
  25 var DataType = {
  26   'MAP': 'MAP',
  27   'SQL': 'SQL'
  28 };
  29
  30 var DataControlListenersManager = (function() {
  31
  32   function changeEvent(event) {
  33     var successCallback;
  34
  35     if (DataType.SQL === event.type.substr(0,3)) {
  36       if (type_.isEmptyObject(this._SQLDataControlCbMap)) {
  37         return;
  38       }
  39       for (var listenerId in this._SQLDataControlCbMap) {
  40         if (this._SQLDataControlCbMap.hasOwnProperty(listenerId)) {
  41           if (this._SQLDataControlCbMap[listenerId].providerId === event.providerId &&
  42               this._SQLDataControlCbMap[listenerId].dataId === event.dataId) {
  43             successCallback = this._SQLDataControlCbMap[listenerId].changeCallback;
  44             if (type_.isFunction(successCallback)) {
  45               successCallback(event.type, {columns: event.columns, values: event.values});
  46             }
  47           }
  48         }
  49       }
  50     } else {
  51       if (type_.isEmptyObject(this._MAPDataControlCbMap)) {
  52         return;
  53       }
  54       for (var listenerId in this._MAPDataControlCbMap) {
  55         if (this._MAPDataControlCbMap.hasOwnProperty(listenerId)) {
  56           if (this._MAPDataControlCbMap[listenerId].providerId === event.providerId &&
  57               this._MAPDataControlCbMap[listenerId].dataId === event.dataId) {
  58             successCallback = this._MAPDataControlCbMap[listenerId].changeCallback;
  59             if (type_.isFunction(successCallback)) {
  60               successCallback(event.type, {columns: event.columns, values: event.values});
  61             }
  62           }
  63         }
  64       }
  65     }
  66   }
  67
  68   function _DataControlListenerManager() {
  69     this._SQLDataControlCbMap = {};
  70     this._MAPDataControlCbMap = {};
  71     this.lastListenerId = 0;
  72     this.changeEvent = changeEvent.bind(this);
  73   }
  74
  75   _DataControlListenerManager.prototype.addChangeListener = function(type, providerId, dataId, changeCallback, errorCallback) {
  76     var _realWatchId = 0;
  77     if (DataType.SQL === type) {
  78       for (var i in this._SQLDataControlCbMap) {
  79         if (this._SQLDataControlCbMap.hasOwnProperty(i) &&
  80             this._SQLDataControlCbMap[i].providerId === providerId &&
  81             this._SQLDataControlCbMap[i].dataId === dataId) {
  82           _realWatchId = this._SQLDataControlCbMap[i].realWatchId;
  83         }
  84       }
  85     } else {
  86       for (var i in this._MAPDataControlCbMap) {
  87         if (this._MAPDataControlCbMap.hasOwnProperty(i) &&
  88             this._MAPDataControlCbMap[i].providerId === providerId &&
  89             this._MAPDataControlCbMap[i].dataId === dataId) {
  90           _realWatchId = this._MAPDataControlCbMap[i].realWatchId;
  91         }
  92       }
  93     }
  94
  95     if (!_realWatchId) {
  96       var callback = function(result) {
  97         if (native_.isFailure(result)) {
  98           native_.callIfPossible(errorCallback, native_.getErrorObject(result));
  99           return;
 100         }
 101       };
 102       var result =
 103         native_.call('DataControlConsumerObject_addChangeListener', {
 104           providerId: providerId,
 105           dataId: dataId,
 106           type: type
 107         }, callback);
 108
 109       if (native_.isFailure(result)) {
 110         throw native_.getErrorObject(result);
 111       } else {
 112         result = native_.getResultObject(result);
 113         _realWatchId = converter_.toLong(result.watchId, true);
 114       }
 115       if (type_.isEmptyObject(this._SQLDataControlCbMap) &&
 116           type_.isEmptyObject(this._MAPDataControlCbMap)) {
 117         native_.addListener(DATA_CONTROL_MANAGER_LISTENER_ID, this.changeEvent);
 118       }
 119     }
 120
 121     if (DataType.SQL === type) {
 122       this._SQLDataControlCbMap[++this.lastListenerId] = {'providerId': providerId,
 123         'dataId': dataId,
 124         'changeCallback': changeCallback,
 125         'realWatchId': _realWatchId};
 126     } else {
 127       this._MAPDataControlCbMap[++this.lastListenerId] = {'providerId': providerId,
 128         'dataId': dataId,
 129         'changeCallback': changeCallback,
 130         'realWatchId': _realWatchId};
 131     }
 132
 133     return this.lastListenerId;
 134   };
 135
 136   _DataControlListenerManager.prototype.removeChangeListener = function(type, providerId, dataId, listenerId) {
 137     var _realWatchId = 0;
 138     if (DataType.SQL === type &&
 139         !type_.isUndefined(this._SQLDataControlCbMap[listenerId])) {
 140       _realWatchId = this._SQLDataControlCbMap[listenerId].realWatchId;
 141       delete this._SQLDataControlCbMap[listenerId];
 142       for (var i in this._SQLDataControlCbMap) {
 143         if (this._SQLDataControlCbMap.hasOwnProperty(i) &&
 144             this._SQLDataControlCbMap[i].realWatchId === _realWatchId) {
 145           return;
 146         }
 147       }
 148     } else if (DataType.MAP === type &&
 149         !type_.isUndefined(this._MAPDataControlCbMap[listenerId])) {
 150       _realWatchId = this._MAPDataControlCbMap[listenerId].realWatchId;
 151       delete this._MAPDataControlCbMap[listenerId];
 152       for (var i in this._MAPDataControlCbMap) {
 153         if (this._MAPDataControlCbMap.hasOwnProperty(i) &&
 154             this._MAPDataControlCbMap[i].realWatchId === _realWatchId) {
 155           return;
 156         }
 157       }
 158     } else {
 159       console.log('Type invalid or listener was not added');
 160       return;
 161     }
 162
 163     if (0 != _realWatchId) {
 164       native_.call('DataControlConsumerObject_removeChangeListener',{
 165         watchId: _realWatchId,
 166       });
 167
 168       if (type_.isEmptyObject(this._SQLDataControlCbMap) &&
 169           type_.isEmptyObject(this._MAPDataControlCbMap)) {
 170         native_.removeListener(DATA_CONTROL_MANAGER_LISTENER_ID);
 171       }
 172     }
 173   };
 174
 175   return _DataControlListenerManager;
 176
 177 })();
 178
 179 var listenersManager = new DataControlListenersManager();
 180
 181 function SetReadOnlyProperty(obj, n, v) {
 182   Object.defineProperty(obj, n, {value: v, writable: false});
 183 }
 184
 185 function DataControlManager() {
 186   // constructor of DataControlManager
 187 }
 188
 189 var privUtils_ = xwalk.utils;
 190
 191 var getDataControlConsumer = function(providerId, dataId, type) {
 192   privUtils_.checkPrivilegeAccess(privUtils_.privilege.DATACONTROL_CONSUMER);
 193   var args = validator_.validateArgs(arguments, [
 194     {'name': 'providerId', 'type': types_.STRING},
 195     {'name': 'dataId', 'type': types_.STRING},
 196     {'name': 'type', 'type': types_.ENUM, 'values': [DataType.SQL, DataType.MAP]}
 197   ]);
 198
 199   var returnObject = null;
 200   if (DataType.SQL === type) {
 201     returnObject = new SQLDataControlConsumer();
 202   } else if (DataType.MAP == type) {
 203     returnObject = new MappedDataControlConsumer();
 204   }
 205
 206   SetReadOnlyProperty(returnObject, 'type', args.type); // read only property
 207   SetReadOnlyProperty(returnObject, 'providerId', args.providerId); // read only property
 208   SetReadOnlyProperty(returnObject, 'dataId', args.dataId); // read only property
 209
 210   return returnObject;
 211 };
 212
 213
 214 DataControlManager.prototype.getDataControlConsumer = function(providerId, dataId, type) {
 215   return getDataControlConsumer.apply(null, arguments);
 216 };
 217
 218 function DataControlConsumerObject() {
 219   // constructor of DataControlConsumerObject
 220 }
 221
 222 DataControlConsumerObject.prototype.addChangeListener = function() {
 223   var args = validator_.validateArgs(arguments, [
 224     {'name': 'dataChangeCallback', 'type': types_.FUNCTION, optional: false,
 225       nullable: false},
 226     {'name': 'errorCallback', 'type': types_.FUNCTION, optional: true, nullable: true}
 227   ]);
 228
 229   var type = DataType.SQL;
 230   if (this instanceof MappedDataControlConsumer) {
 231     type = DataType.MAP;
 232   }
 233
 234   return listenersManager.addChangeListener(type, this.providerId, this.dataId,
 235     args.dataChangeCallback, args.errorCallback);
 236 };
 237
 238 DataControlConsumerObject.prototype.removeChangeListener = function() {
 239   var args = validator_.validateArgs(arguments, [
 240     {'name': 'watchId', 'type': types_.LONG}
 241   ]);
 242
 243   var type = DataType.SQL;
 244   if (this instanceof MappedDataControlConsumer) {
 245     type = DataType.MAP;
 246   }
 247
 248   listenersManager.removeChangeListener(type, this.providerId, this.dataId, args.watchId);
 249 };
 250
 251 function SQLDataControlConsumer() {
 252   // constructor of SQLDataControlConsumer
 253 }
 254
 255 SQLDataControlConsumer.prototype = new DataControlConsumerObject();
 256 SQLDataControlConsumer.prototype.constructor = SQLDataControlConsumer;
 257
 258 SQLDataControlConsumer.prototype.insert = function() {
 259   var args = validator_.validateArgs(arguments, [
 260     {'name': 'reqId', 'type': types_.LONG},
 261     {'name': 'insertionData', 'type': types_.DICTIONARY},
 262     {'name': 'successCallback', 'type': types_.FUNCTION, optional: true, nullable: true},
 263     {'name': 'errorCallback', 'type': types_.FUNCTION, optional: true, nullable: true}
 264   ]);
 265
 266   // doing conversion of all elements to string
 267   var ins = validator_.validateArgs([args.insertionData.columns, args.insertionData.values], [
 268     {name : 'columns', type : types_.ARRAY, values : types_.STRING},
 269     {name : 'values', type : types_.ARRAY, values : types_.STRING}
 270   ]);
 271
 272   var nativeParam = {
 273     'providerId': this.providerId,
 274     'dataId': this.dataId,
 275     'reqId': args.reqId,
 276     'insertionData': args.insertionData
 277   };
 278
 279   var syncResult =
 280     native_.call('SQLDataControlConsumer_insert', nativeParam, function(result) {
 281       if (result.status == 'success') {
 282         if (args.successCallback) {
 283           args.successCallback(result['requestId'], result['result']);
 284         }
 285       }
 286       if (result.status == 'error') {
 287         if (args.errorCallback) {
 288           var err = result['result'];
 289           var e = new WebAPIException(err.name, err.message);
 290           args.errorCallback(result['requestId'], e);
 291         }
 292       }
 293     });
 294
 295   if (native_.isFailure(syncResult)) {
 296     throw native_.getErrorObject(syncResult);
 297   }
 298 };
 299
 300 SQLDataControlConsumer.prototype.update = function() {
 301   var args = validator_.validateArgs(arguments, [
 302     {'name': 'reqId', 'type': types_.LONG},
 303     {'name': 'updateData', 'type': types_.DICTIONARY},
 304     {'name': 'where', 'type': types_.STRING},
 305     {'name': 'successCallback', 'type': types_.FUNCTION, optional: true, nullable: true},
 306     {'name': 'errorCallback', 'type': types_.FUNCTION, optional: true, nullable: true}
 307   ]);
 308
 309   var nativeParam = {
 310     'providerId': this.providerId,
 311     'dataId': this.dataId,
 312     'reqId': args.reqId,
 313     'where': args.where,
 314     'updateData': args.updateData
 315   };
 316
 317   var syncResult =
 318     native_.call('SQLDataControlConsumer_update', nativeParam, function(result) {
 319       if (result.status == 'success') {
 320         if (args.successCallback) {
 321           args.successCallback(result['requestId']);
 322         }
 323       }
 324       if (result.status == 'error') {
 325         if (args.errorCallback) {
 326           var err = result['result'];
 327           var e = new WebAPIException(err.name, err.message);
 328           args.errorCallback(result['requestId'], e);
 329         }
 330       }
 331     });
 332
 333   if (native_.isFailure(syncResult)) {
 334     throw native_.getErrorObject(syncResult);
 335   }
 336 };
 337
 338 SQLDataControlConsumer.prototype.remove = function() {
 339   var args = validator_.validateArgs(arguments, [
 340     {'name': 'reqId', 'type': types_.LONG},
 341     {'name': 'where', 'type': types_.STRING},
 342     {'name': 'successCallback', 'type': types_.FUNCTION, optional: true, nullable: true},
 343     {'name': 'errorCallback', 'type': types_.FUNCTION, optional: true, nullable: true}
 344   ]);
 345
 346   var nativeParam = {
 347     'providerId': this.providerId,
 348     'dataId': this.dataId,
 349     'reqId': args.reqId,
 350     'where': args.where
 351   };
 352
 353   var syncResult =
 354     native_.call('SQLDataControlConsumer_remove', nativeParam, function(result) {
 355       if (result.status == 'success') {
 356         if (args.successCallback) {
 357           args.successCallback(result['requestId']);
 358         }
 359       }
 360       if (result.status == 'error') {
 361         if (args.errorCallback) {
 362           var err = result['result'];
 363           var e = new WebAPIException(err.name, err.message);
 364           args.errorCallback(result['requestId'], e);
 365         }
 366       }
 367     });
 368
 369   if (native_.isFailure(syncResult)) {
 370     throw native_.getErrorObject(syncResult);
 371   }
 372
 373 };
 374
 375 SQLDataControlConsumer.prototype.select = function() {
 376   var args = validator_.validateArgs(arguments, [
 377     {'name': 'reqId', 'type': types_.LONG},
 378     {'name': 'columns', 'type': types_.ARRAY},
 379     {'name': 'where', 'type': types_.STRING},
 380     {'name': 'successCallback', 'type': types_.FUNCTION},
 381     {'name': 'errorCallback', 'type': types_.FUNCTION, optional: true, nullable: true},
 382     {'name': 'page', 'type': types_.LONG, optional: true, nullable: true},
 383     {'name': 'maxNumberPerPage', 'type': types_.LONG, optional: true, nullable: true},
 384     {'name': 'order', 'type': types_.STRING, optional: true, nullable: true}
 385   ]);
 386
 387   var nativeParam = {
 388     'providerId': this.providerId,
 389     'dataId': this.dataId,
 390     'reqId': args.reqId,
 391     'columns': args.columns,
 392     'where': args.where
 393   };
 394   if (args['page']) {
 395     nativeParam['page'] = args.page;
 396   }
 397   if (args['maxNumberPerPage']) {
 398     nativeParam['maxNumberPerPage'] = args.maxNumberPerPage;
 399   }
 400   if (args['order']) {
 401     nativeParam['order'] = args.order;
 402   }
 403
 404   var syncResult =
 405     native_.call('SQLDataControlConsumer_select', nativeParam, function(result) {
 406       if (result.status == 'success') {
 407         args.successCallback(result['result'], result['requestId']);
 408       }
 409       if (result.status == 'error') {
 410         if (args.errorCallback) {
 411           var err = result['result'];
 412           var e = new WebAPIException(err.name, err.message);
 413           args.errorCallback(result['requestId'], e);
 414         }
 415       }
 416     });
 417
 418   if (native_.isFailure(syncResult)) {
 419     throw native_.getErrorObject(syncResult);
 420   }
 421 };
 422
 423
 424 function MappedDataControlConsumer() {
 425   // constructor of MappedDataControlConsumer
 426 }
 427
 428 MappedDataControlConsumer.prototype = new DataControlConsumerObject();
 429 MappedDataControlConsumer.prototype.constructor = MappedDataControlConsumer;
 430
 431 MappedDataControlConsumer.prototype.addValue = function() {
 432   var args = validator_.validateArgs(arguments, [
 433     {'name': 'reqId', 'type': types_.LONG},
 434     {'name': 'key', 'type': types_.STRING},
 435     {'name': 'value', 'type': types_.STRING},
 436     {'name': 'successCallback', 'type': types_.FUNCTION, optional: true, nullable: true},
 437     {'name': 'errorCallback', 'type': types_.FUNCTION, optional: true, nullable: true}
 438   ]);
 439
 440   var nativeParam = {
 441     'providerId': this.providerId,
 442     'dataId': this.dataId,
 443     'reqId': args.reqId,
 444     'key': args.key,
 445     'value': args.value
 446   };
 447
 448   var syncResult =
 449     native_.call('MappedDataControlConsumer_addValue', nativeParam, function(result) {
 450       if (result.status == 'success') {
 451         if (args.successCallback) {
 452           args.successCallback(result['requestId']);
 453         }
 454       }
 455       if (result.status == 'error') {
 456         if (args.errorCallback) {
 457           var err = result['result'];
 458           var e = new WebAPIException(err.name, err.message);
 459           args.errorCallback(result['requestId'], e);
 460         }
 461       }
 462     });
 463
 464   if (native_.isFailure(syncResult)) {
 465     throw native_.getErrorObject(syncResult);
 466   }
 467
 468 };
 469
 470 MappedDataControlConsumer.prototype.removeValue = function() {
 471   var args = validator_.validateArgs(arguments, [
 472     {'name': 'reqId', 'type': types_.LONG},
 473     {'name': 'key', 'type': types_.STRING},
 474     {'name': 'value', 'type': types_.STRING},
 475     {'name': 'successCallback', 'type': types_.FUNCTION},
 476     {'name': 'errorCallback', 'type': types_.FUNCTION, optional: true, nullable: true}
 477   ]);
 478
 479   var nativeParam = {
 480     'providerId': this.providerId,
 481     'dataId': this.dataId,
 482     'reqId': args.reqId,
 483     'key': args.key,
 484     'value': args.value
 485   };
 486
 487   var syncResult =
 488     native_.call('MappedDataControlConsumer_removeValue', nativeParam, function(result) {
 489       if (result.status == 'success') {
 490         args.successCallback(result['requestId']);
 491       }
 492       if (result.status == 'error') {
 493         if (args.errorCallback) {
 494           var err = result['result'];
 495           var e = new WebAPIException(err.name, err.message);
 496           args.errorCallback(result['requestId'], e);
 497         }
 498       }
 499     });
 500
 501   if (native_.isFailure(syncResult)) {
 502     throw native_.getErrorObject(syncResult);
 503   }
 504
 505 };
 506
 507 MappedDataControlConsumer.prototype.getValue = function() {
 508   var args = validator_.validateArgs(arguments, [
 509     {'name': 'reqId', 'type': types_.LONG},
 510     {'name': 'key', 'type': types_.STRING},
 511     {'name': 'successCallback', 'type': types_.FUNCTION},
 512     {'name': 'errorCallback', 'type': types_.FUNCTION, optional: true, nullable: true}
 513   ]);
 514
 515   var nativeParam = {
 516     'providerId': this.providerId,
 517     'dataId': this.dataId,
 518     'reqId': args.reqId,
 519     'key': args.key
 520   };
 521
 522   var syncResult =
 523     native_.call('MappedDataControlConsumer_getValue', nativeParam, function(result) {
 524       if (result.status == 'success') {
 525         args.successCallback(result['result'], result['requestId']);
 526       }
 527       if (result.status == 'error') {
 528         if (args.errorCallback) {
 529           var err = result['result'];
 530           var e = new WebAPIException(err.name, err.message);
 531           args.errorCallback(result['requestId'], e);
 532         }
 533       }
 534     });
 535
 536   if (native_.isFailure(syncResult)) {
 537     throw native_.getErrorObject(syncResult);
 538   }
 539
 540 };
 541
 542 MappedDataControlConsumer.prototype.updateValue = function() {
 543   var args = validator_.validateArgs(arguments, [
 544     {'name': 'reqId', 'type': types_.LONG},
 545     {'name': 'key', 'type': types_.STRING},
 546     {'name': 'oldValue', 'type': types_.STRING},
 547     {'name': 'newValue', 'type': types_.STRING},
 548     {'name': 'successCallback', 'type': types_.FUNCTION},
 549     {'name': 'errorCallback', 'type': types_.FUNCTION, optional: true, nullable: true}
 550   ]);
 551
 552   var nativeParam = {
 553     'providerId': this.providerId,
 554     'dataId': this.dataId,
 555     'reqId': args.reqId,
 556     'key': args.key,
 557     'oldValue': args.oldValue,
 558     'newValue': args.newValue
 559   };
 560
 561   var syncResult =
 562     native_.call('MappedDataControlConsumer_updateValue', nativeParam, function(result) {
 563       if (result.status == 'success') {
 564         args.successCallback(result['requestId']);
 565       }
 566       if (result.status == 'error') {
 567         if (args.errorCallback) {
 568           var err = result['result'];
 569           var e = new WebAPIException(err.name, err.message);
 570           args.errorCallback(result['requestId'], e);
 571         }
 572       }
 573     });
 574
 575   if (native_.isFailure(syncResult)) {
 576     throw native_.getErrorObject(syncResult);
 577   }
 578
 579 };
 580
 581 exports = new DataControlManager();
 582