src/iotcon/iotcon_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 native = new xwalk.utils.NativeManager(extension);
  18 var validator = xwalk.utils.validator;
  19 var types = validator.Types;
  20 var T = xwalk.utils.type;
  21
  22 function createListener(name, c) {
  23   var listenerName = name;
  24   var callback = c || function(response) {
  25     return response;
  26   };
  27   var listeners = {};
  28   var jsListenerRegistered = false;
  29
  30   function internalCallback(response) {
  31     if (listeners[response.id]) {
  32       listeners[response.id](callback(response));
  33     }
  34   }
  35
  36   function addListener(id, func) {
  37     if (!jsListenerRegistered) {
  38       native.addListener(listenerName, internalCallback);
  39       jsListenerRegistered = true;
  40     }
  41
  42     listeners[id] = func;
  43   }
  44
  45   function removeListener(id) {
  46     if (listeners[id]) {
  47       delete listeners[id];
  48     }
  49
  50     if (jsListenerRegistered && T.isEmptyObject(listeners)) {
  51       native.removeListener(listenerName, internalCallback);
  52       jsListenerRegistered = false;
  53     }
  54   }
  55
  56   return {
  57     addListener: addListener,
  58     removeListener: removeListener
  59   };
  60 }
  61
  62 function InternalData(d) {
  63   for (var prop in d) {
  64     if (d.hasOwnProperty(prop)) {
  65       this[prop] = d[prop];
  66     }
  67   }
  68 }
  69
  70 InternalData.prototype.update = function(dst) {
  71   for (var prop in this) {
  72     if (this.hasOwnProperty(prop) && dst.hasOwnProperty(prop)) {
  73       dst[prop] = this;
  74     }
  75   }
  76 };
  77
  78 InternalData.prototype.decorate = function(dst) {
  79   var that = this;
  80   function getBuilder(prop) {
  81     if (T.isArray(that[prop])) {
  82       return function() {
  83         return that[prop].slice();
  84       };
  85     } else {
  86       return function() {
  87         return that[prop];
  88       };
  89     }
  90   }
  91   function setBuilder(prop) {
  92     return function(d) {
  93       if (d instanceof InternalData) {
  94         that[prop] = d[prop];
  95       }
  96     };
  97   }
  98   for (var prop in this) {
  99     if (this.hasOwnProperty(prop)) {
 100       Object.defineProperty(dst, prop, {
 101         get: getBuilder(prop),
 102         set: setBuilder(prop),
 103         enumerable: true
 104       });
 105     }
 106   }
 107 };
 108
 109 function updateWithInternalData(src, dst) {
 110   new InternalData(src).update(dst);
 111 }
 112
 113 function decorateWithData(data, dst) {
 114   for (var prop in data) {
 115     if (data.hasOwnProperty(prop)) {
 116       Object.defineProperty(dst, prop, {
 117         value: data[prop],
 118         writable: false,
 119         enumerable: true
 120       });
 121     }
 122   }
 123 }
 124
 125 var ResponseResult = {
 126   SUCCESS: 'SUCCESS',
 127   ERROR: 'ERROR',
 128   RESOURCE_CREATED: 'RESOURCE_CREATED',
 129   RESOURCE_DELETED: 'RESOURCE_DELETED',
 130   SLOW: 'SLOW'
 131 };
 132
 133 var PresenceResponseResultType = {
 134   SUCCESS: 'SUCCESS',
 135   STOPPED: 'STOPPED',
 136   TIMEOUT: 'TIMEOUT'
 137 };
 138
 139 var PresenceTriggerType = {
 140   CREATED: 'CREATED',
 141   UPDATED: 'UPDATED',
 142   DESTROYED: 'DESTROYED'
 143 };
 144
 145 var ConnectivityType = {
 146   IPV4: 'IPV4',
 147   IPV6: 'IPV6',
 148   BT_EDR: 'BT_EDR',
 149   BT_LE: 'BT_LE',
 150   ALL: 'ALL'
 151 };
 152
 153 var ResourceInterface = {
 154   DEFAULT: 'DEFAULT',
 155   LINK: 'LINK',
 156   BATCH: 'BATCH',
 157   GROUP: 'GROUP'
 158 };
 159
 160 var ObservePolicy = {
 161   IGNORE_OUT_OF_ORDER: 'IGNORE_OUT_OF_ORDER',
 162   ACCEPT_OUT_OF_ORDER: 'ACCEPT_OUT_OF_ORDER'
 163 };
 164
 165 var PresenceTriggerType = {
 166   NO_TYPE: 'NO_TYPE',
 167   REGISTER: 'REGISTER',
 168   DEREGISTER: 'DEREGISTER'
 169 };
 170
 171 function DeviceInfo(data) {
 172   decorateWithData(data, this);
 173 }
 174
 175 function IotconOption(id, data) {
 176   validator.isConstructorCall(this, tizen.IotconOption);
 177
 178   Object.defineProperties(this, {
 179     id: {
 180       value: id,
 181       writable: false,
 182       enumerable: true
 183     },
 184     data: {
 185       value: data,
 186       writable: false,
 187       enumerable: true
 188     }
 189   });
 190 }
 191
 192 function PlatformInfo(data) {
 193   decorateWithData(data, this);
 194 }
 195
 196 function PresenceResponse(data) {
 197   decorateWithData(data, this);
 198 }
 199
 200 function Query(resourceTypes, resourceInterface, filters) {
 201   validator.isConstructorCall(this, tizen.Query);
 202
 203   Object.defineProperties(this, {
 204     resourceTypes: {
 205       value: resourceTypes || null,
 206       writable: true,
 207       enumerable: true
 208     },
 209     resourceInterface: {
 210       value: resourceInterface || null,
 211       writable: true,
 212       enumerable: true
 213     },
 214     filters: {
 215       value: filters || null,
 216       writable: true,
 217       enumerable: true
 218     }
 219   });
 220 }
 221
 222 function QueryFilter(key, value) {
 223   validator.isConstructorCall(this, tizen.QueryFilter);
 224
 225   Object.defineProperties(this, {
 226     key: {
 227       value: key,
 228       writable: true,
 229       enumerable: true
 230     },
 231     value: {
 232       value: value,
 233       writable: true,
 234       enumerable: true
 235     }
 236   });
 237 }
 238
 239 function Representation(uriPath) {
 240   validator.isConstructorCall(this, tizen.Representation);
 241
 242   Object.defineProperties(this, {
 243     uriPath: {
 244       value: uriPath,
 245       writable: true,
 246       enumerable: true
 247     },
 248     resourceTypes: {
 249       value: [],
 250       writable: true,
 251       enumerable: true
 252     },
 253     resourceInterfaces: {
 254       value: [],
 255       writable: true,
 256       enumerable: true
 257     },
 258     states: {
 259       value: null,
 260       writable: true,
 261       enumerable: true
 262     },
 263     representations: {
 264       value: null,
 265       writable: true,
 266       enumerable: true
 267     }
 268   });
 269 }
 270
 271 function createRepresentation(data) {
 272   var r = new tizen.Representation(data.uriPath);
 273   var props = ['resourceTypes', 'resourceInterfaces', 'states'];
 274
 275   for (var p = 0; p < props.length; ++p) {
 276     if (data[props[p]]) {
 277       r[props[p]] = data[props[p]];
 278     }
 279   }
 280
 281   if (data.representations) {
 282     r.representations = [];
 283     for (var i = 0; i < data.representations.length; ++i) {
 284       r.representations.push(createRepresentation(data.representations[i]));
 285     }
 286   }
 287
 288   return r;
 289 }
 290
 291 function Request(data) {
 292   Object.defineProperty(this, '_id', {
 293     value: data.id,
 294     writable: false,
 295     enumerable: false
 296   });
 297
 298   delete data.id;
 299
 300   decorateWithData(data, this);
 301 }
 302
 303 function Response(request) {
 304   validator.isConstructorCall(this, tizen.Response);
 305
 306   Object.defineProperties(this, {
 307     request: {
 308       value: request,
 309       writable: false,
 310       enumerable: true
 311     },
 312     result: {
 313       value: null,
 314       writable: true,
 315       enumerable: true
 316     },
 317     representation: {
 318       value: null,
 319       writable: true,
 320       enumerable: true
 321     },
 322     options: {
 323       value: null,
 324       writable: true,
 325       enumerable: true
 326     }
 327   });
 328 }
 329
 330 Response.prototype.send = function() {
 331   var callArgs = {};
 332   callArgs.id = this.request._id;
 333   callArgs.result = this.result;
 334   callArgs.representation = this.representation;
 335   callArgs.options = this.options;
 336
 337   var result = native.callSync('IotconResponse_send', callArgs);
 338
 339   if (native.isFailure(result)) {
 340     throw native.getErrorObject(result);
 341   }
 342 };
 343
 344 function State(key, state) {
 345   validator.isConstructorCall(this, tizen.State);
 346
 347   Object.defineProperties(this, {
 348     key: {
 349       value: key,
 350       writable: false,
 351       enumerable: true
 352     },
 353     state: {
 354       value: state,
 355       writable: false,
 356       enumerable: true
 357     }
 358   });
 359 }
 360
 361 function RemoteResource(data) {
 362   Object.defineProperties(this, {
 363     _id: {
 364       value: data.id,
 365       writable: false,
 366       enumerable: false
 367     },
 368     cachedRepresentation: {
 369       get: function() {
 370         var callArgs = {};
 371         callArgs.id = data.id;
 372         var result = native.callSync('IotconRemoteResource_getCachedRepresentation', callArgs);
 373         return createRepresentation(native.getResultObject(result));
 374       },
 375       set: function() {},
 376       enumerable: true
 377     }
 378   });
 379
 380   delete data.id;
 381
 382   var internal = new InternalData(data);
 383   internal.decorate(this);
 384 }
 385
 386 RemoteResource.prototype.methodGet = function() {
 387   var args = validator.validateMethod(arguments, [{
 388     name: 'query',
 389     type: types.PLATFORM_OBJECT,
 390     values: Query
 391   }, {
 392     name: 'responseCallback',
 393     type: types.FUNCTION
 394   }, {
 395     name: 'errorCallback',
 396     type: types.FUNCTION,
 397     optional: true,
 398     nullable: true
 399   }]);
 400
 401   var callArgs = {};
 402   callArgs.id = this._id;
 403   callArgs.query = args.query;
 404
 405   var callback = function(result) {
 406     if (native.isFailure(result)) {
 407       native.callIfPossible(args.errorCallback, native.getErrorObject(result));
 408     } else {
 409       // TODO: implement
 410       args.responseCallback();
 411     }
 412   };
 413
 414   var result = native.call('IotconRemoteResource_methodGet', callArgs, callback);
 415
 416   if (native.isFailure(result)) {
 417     throw native.getErrorObject(result);
 418   }
 419 };
 420
 421 RemoteResource.prototype.methodPut = function() {
 422   var args = validator.validateMethod(arguments, [{
 423     name: 'representation',
 424     type: types.PLATFORM_OBJECT,
 425     values: Representation
 426   }, {
 427     name: 'query',
 428     type: types.PLATFORM_OBJECT,
 429     values: Query
 430   }, {
 431     name: 'responseCallback',
 432     type: types.FUNCTION
 433   }, {
 434     name: 'errorCallback',
 435     type: types.FUNCTION,
 436     optional: true,
 437     nullable: true
 438   }]);
 439
 440   var callArgs = {};
 441   callArgs.id = this._id;
 442   callArgs.representation = args.representation;
 443   callArgs.query = args.query;
 444
 445   var callback = function(result) {
 446     if (native.isFailure(result)) {
 447       native.callIfPossible(args.errorCallback, native.getErrorObject(result));
 448     } else {
 449       // TODO: implement
 450       args.responseCallback();
 451     }
 452   };
 453
 454   var result = native.call('IotconRemoteResource_methodPut', callArgs, callback);
 455
 456   if (native.isFailure(result)) {
 457     throw native.getErrorObject(result);
 458   }
 459 };
 460
 461 RemoteResource.prototype.methodPost = function() {
 462   var args = validator.validateMethod(arguments, [{
 463     name: 'representation',
 464     type: types.PLATFORM_OBJECT,
 465     values: Representation
 466   }, {
 467     name: 'query',
 468     type: types.PLATFORM_OBJECT,
 469     values: Query
 470   }, {
 471     name: 'responseCallback',
 472     type: types.FUNCTION
 473   }, {
 474     name: 'errorCallback',
 475     type: types.FUNCTION,
 476     optional: true,
 477     nullable: true
 478   }]);
 479
 480   var callArgs = {};
 481   callArgs.id = this._id;
 482   callArgs.representation = args.representation;
 483   callArgs.query = args.query;
 484
 485   var callback = function(result) {
 486     if (native.isFailure(result)) {
 487       native.callIfPossible(args.errorCallback, native.getErrorObject(result));
 488     } else {
 489       // TODO: implement
 490       args.responseCallback();
 491     }
 492   };
 493
 494   var result = native.call('IotconRemoteResource_methodPost', callArgs, callback);
 495
 496   if (native.isFailure(result)) {
 497     throw native.getErrorObject(result);
 498   }
 499 };
 500
 501 RemoteResource.prototype.methodDelete = function() {
 502   var args = validator.validateMethod(arguments, [{
 503     name: 'responseCallback',
 504     type: types.FUNCTION
 505   }, {
 506     name: 'errorCallback',
 507     type: types.FUNCTION,
 508     optional: true,
 509     nullable: true
 510   }]);
 511
 512   var callArgs = {};
 513   callArgs.id = this._id;
 514
 515   var callback = function(result) {
 516     if (native.isFailure(result)) {
 517       native.callIfPossible(args.errorCallback, native.getErrorObject(result));
 518     } else {
 519       // TODO: implement
 520       args.responseCallback();
 521     }
 522   };
 523
 524   var result = native.call('IotconRemoteResource_methodDelete', callArgs, callback);
 525
 526   if (native.isFailure(result)) {
 527     throw native.getErrorObject(result);
 528   }
 529 };
 530
 531 var stateChangeListener = createListener('RemoteResourceStateChangeListener');
 532
 533 RemoteResource.prototype.setStateChangeListener = function() {
 534   var args = validator.validateMethod(arguments, [{
 535     name: 'query',
 536     type: types.PLATFORM_OBJECT,
 537     values: Query
 538   }, {
 539     name: 'observePolicy',
 540     type: types.ENUM,
 541     values: T.getValues(ObservePolicy)
 542   }, {
 543     name: 'successCallback',
 544     type: types.FUNCTION
 545   }, {
 546     name: 'errorCallback',
 547     type: types.FUNCTION,
 548     optional: true,
 549     nullable: true
 550   }]);
 551
 552   var callArgs = {};
 553   callArgs.id = this._id;
 554   callArgs.query = args.query;
 555   callArgs.observePolicy = args.observePolicy;
 556   var that = this;
 557
 558   var listener = function(result) {
 559     if (native.isFailure(result)) {
 560       native.callIfPossible(args.errorCallback, native.getErrorObject(result));
 561     } else {
 562       updateWithInternalData(native.getResultObject(result), that);
 563       args.successCallback(that);
 564     }
 565   };
 566
 567   var result = native.callSync('IotconRemoteResource_setStateChangeListener', callArgs);
 568
 569   if (native.isFailure(result)) {
 570     throw native.getErrorObject(result);
 571   } else {
 572     stateChangeListener.addListener(this._id, listener);
 573   }
 574 };
 575
 576 RemoteResource.prototype.unsetStateChangeListener = function() {
 577   var callArgs = {};
 578   callArgs.id = this._id;
 579
 580   var result = native.callSync('IotconRemoteResource_unsetStateChangeListener', callArgs);
 581
 582   if (native.isFailure(result)) {
 583     throw native.getErrorObject(result);
 584   } else {
 585     stateChangeListener.removeListener(this._id);
 586   }
 587 };
 588
 589 RemoteResource.prototype.startCaching = function() {
 590   var callArgs = {};
 591   callArgs.id = this._id;
 592
 593   var result = native.callSync('IotconRemoteResource_startCaching', callArgs);
 594
 595   if (native.isFailure(result)) {
 596     throw native.getErrorObject(result);
 597   }
 598 };
 599
 600 RemoteResource.prototype.stopCaching = function() {
 601   var callArgs = {};
 602   callArgs.id = this._id;
 603
 604   var result = native.callSync('IotconRemoteResource_stopCaching', callArgs);
 605
 606   if (native.isFailure(result)) {
 607     throw native.getErrorObject(result);
 608   }
 609 };
 610
 611 var connectionChangeListener = createListener('RemoteResourceConnectionChangeListener');
 612
 613 RemoteResource.prototype.setConnectionChangeListener = function() {
 614   var args = validator.validateMethod(arguments, [{
 615     name: 'successCallback',
 616     type: types.FUNCTION
 617   }, {
 618     name: 'errorCallback',
 619     type: types.FUNCTION,
 620     optional: true,
 621     nullable: true
 622   }]);
 623
 624   var callArgs = {};
 625   callArgs.id = this._id;
 626
 627   var listener = function(result) {
 628     if (native.isFailure(result)) {
 629       native.callIfPossible(args.errorCallback, native.getErrorObject(result));
 630     } else {
 631       args.successCallback(native.getResultObject(result));
 632     }
 633   };
 634
 635   var result = native.callSync('IotconRemoteResource_setConnectionChangeListener', callArgs);
 636
 637   if (native.isFailure(result)) {
 638     throw native.getErrorObject(result);
 639   } else {
 640     connectionChangeListener.addListener(this._id, listener);
 641   }
 642 };
 643
 644 RemoteResource.prototype.unsetConnectionChangeListener = function() {
 645   var callArgs = {};
 646   callArgs.id = this._id;
 647
 648   var result = native.callSync('IotconRemoteResource_unsetConnectionChangeListener', callArgs);
 649
 650   if (native.isFailure(result)) {
 651     throw native.getErrorObject(result);
 652   } else {
 653     connectionChangeListener.removeListener(this._id);
 654   }
 655 };
 656
 657 function Client() {
 658 }
 659
 660 Client.prototype.findResource = function() {
 661   var args = validator.validateMethod(arguments, [{
 662     name: 'hostAddress',
 663     type: types.STRING,
 664     nullable: true
 665   }, {
 666     name: 'resourceType',
 667     type: types.STRING,
 668     nullable: true
 669   }, {
 670     name: 'connectivityType',
 671     type: types.ENUM,
 672     values: T.getValues(ConnectivityType)
 673   }, {
 674     name: 'successCallback',
 675     type: types.FUNCTION
 676   }, {
 677     name: 'errorCallback',
 678     type: types.FUNCTION,
 679     optional: true,
 680     nullable: true
 681   }]);
 682
 683   var callArgs = {};
 684   callArgs.hostAddress = args.hostAddress;
 685   callArgs.resourceType = args.resourceType;
 686   callArgs.connectivityType = args.connectivityType;
 687
 688   var callback = function(result) {
 689     if (native.isFailure(result)) {
 690       native.callIfPossible(args.errorCallback, native.getErrorObject(result));
 691     } else {
 692       var rr = new RemoteResource(native.getResultObject(result));
 693       args.successCallback(rr);
 694     }
 695   };
 696
 697   var result = native.call('IotconClient_findResource', callArgs, callback);
 698
 699   if (native.isFailure(result)) {
 700     throw native.getErrorObject(result);
 701   }
 702 };
 703
 704 var presenceEventListener = createListener('PresenceEventListener', function(response) {
 705   return new PresenceResponse(native.getResultObject(response));
 706 });
 707
 708 Client.prototype.addPresenceEventListener = function() {
 709   var args = validator.validateMethod(arguments, [{
 710     name: 'hostAddress',
 711     type: types.STRING,
 712     nullable: true
 713   }, {
 714     name: 'resourceType',
 715     type: types.STRING
 716   }, {
 717     name: 'connectivityType',
 718     type: types.ENUM,
 719     values: T.getValues(ConnectivityType)
 720   }, {
 721     name: 'successCallback',
 722     type: types.FUNCTION
 723   }]);
 724
 725   var callArgs = {};
 726   callArgs.hostAddress = args.hostAddress;
 727   callArgs.resourceType = args.resourceType;
 728   callArgs.connectivityType = args.connectivityType;
 729
 730   var result = native.callSync('IotconClient_addPresenceEventListener', callArgs);
 731
 732   if (native.isFailure(result)) {
 733     throw native.getErrorObject(result);
 734   } else {
 735     var id = native.getResultObject(result);
 736     presenceEventListener.addListener(id, args.successCallback);
 737     return id;
 738   }
 739 };
 740
 741 Client.prototype.removePresenceEventListener = function() {
 742   var args = validator.validateMethod(arguments, [{
 743     name: 'watchId',
 744     type: types.LONG
 745   }]);
 746
 747   var callArgs = {};
 748   callArgs.id = args.watchId;
 749
 750   var result = native.callSync('IotconClient_removePresenceEventListener', callArgs);
 751
 752   if (native.isFailure(result)) {
 753     throw native.getErrorObject(result);
 754   } else {
 755     presenceEventListener.removeListener(args.watchId);
 756   }
 757 };
 758
 759 Client.prototype.getDeviceInfo = function() {
 760   var args = validator.validateMethod(arguments, [{
 761     name: 'hostAddress',
 762     type: types.STRING
 763   }, {
 764     name: 'connectivityType',
 765     type: types.ENUM,
 766     values: T.getValues(ConnectivityType)
 767   }, {
 768     name: 'successCallback',
 769     type: types.FUNCTION
 770   }, {
 771     name: 'errorCallback',
 772     type: types.FUNCTION,
 773     optional: true,
 774     nullable: true
 775   }]);
 776
 777   var callArgs = {};
 778   callArgs.hostAddress = args.hostAddress;
 779   callArgs.connectivityType = args.connectivityType;
 780
 781   var callback = function(result) {
 782     if (native.isFailure(result)) {
 783       native.callIfPossible(args.errorCallback, native.getErrorObject(result));
 784     } else {
 785       args.successCallback(new DeviceInfo(native.getResultObject(result)));
 786     }
 787   };
 788
 789   var result = native.call('IotconClient_getDeviceInfo', callArgs, callback);
 790
 791   if (native.isFailure(result)) {
 792     throw native.getErrorObject(result);
 793   }
 794 };
 795
 796 Client.prototype.getPlatformInfo = function() {
 797   var args = validator.validateMethod(arguments, [{
 798     name: 'hostAddress',
 799     type: types.STRING
 800   }, {
 801     name: 'connectivityType',
 802     type: types.ENUM,
 803     values: T.getValues(ConnectivityType)
 804   }, {
 805     name: 'successCallback',
 806     type: types.FUNCTION
 807   }, {
 808     name: 'errorCallback',
 809     type: types.FUNCTION,
 810     optional: true,
 811     nullable: true
 812   }]);
 813
 814   var callArgs = {};
 815   callArgs.hostAddress = args.hostAddress;
 816   callArgs.connectivityType = args.connectivityType;
 817
 818   var callback = function(result) {
 819     if (native.isFailure(result)) {
 820       native.callIfPossible(args.errorCallback, native.getErrorObject(result));
 821     } else {
 822       args.successCallback(new PlatformInfo(native.getResultObject(result)));
 823     }
 824   };
 825
 826   var result = native.call('IotconClient_getPlatformInfo', callArgs, callback);
 827
 828   if (native.isFailure(result)) {
 829     throw native.getErrorObject(result);
 830   }
 831 };
 832
 833 function Resource() {
 834 }
 835
 836 function Server() {
 837 }
 838
 839 Server.prototype.createResource = function() {
 840   var args = validator.validateMethod(arguments, [{
 841     name: 'dictionary',
 842     type: types.DICTIONARY
 843   }, {
 844     name: 'successCallback',
 845     type: types.FUNCTION
 846   }, {
 847     name: 'errorCallback',
 848     type: types.FUNCTION,
 849     optional: true,
 850     nullable: true
 851   }]);
 852
 853   var callArgs = args.dictionary;
 854
 855   var callback = function(result) {
 856     if (native.isFailure(result)) {
 857       native.callIfPossible(args.errorCallback, native.getErrorObject(result));
 858     } else {
 859       // TODO: implement
 860       args.successCallback();
 861     }
 862   };
 863
 864   var result = native.call('IotconServer_createResource', callArgs, callback);
 865
 866   if (native.isFailure(result)) {
 867     throw native.getErrorObject(result);
 868   }
 869 };
 870
 871 Server.prototype.removeResource = function() {
 872   var args = validator.validateMethod(arguments, [{
 873     name: 'resource',
 874     type: types.PLATFORM_OBJECT,
 875     values: Resource
 876   }, {
 877     name: 'successCallback',
 878     type: types.FUNCTION
 879   }, {
 880     name: 'errorCallback',
 881     type: types.FUNCTION,
 882     optional: true,
 883     nullable: true
 884   }]);
 885
 886   var callArgs = {};
 887   callArgs.id = args.resource._id;  // TODO: check if this is correct
 888
 889   var callback = function(result) {
 890     if (native.isFailure(result)) {
 891       native.callIfPossible(args.errorCallback, native.getErrorObject(result));
 892     } else {
 893       args.successCallback();
 894     }
 895   };
 896
 897   var result = native.call('IotconServer_removeResource', callArgs, callback);
 898
 899   if (native.isFailure(result)) {
 900     throw native.getErrorObject(result);
 901   }
 902 };
 903
 904 Server.prototype.updateResource = function() {
 905   var args = validator.validateMethod(arguments, [{
 906     name: 'resource',
 907     type: types.PLATFORM_OBJECT,
 908     values: Resource
 909   }, {
 910     name: 'successCallback',
 911     type: types.FUNCTION
 912   }, {
 913     name: 'errorCallback',
 914     type: types.FUNCTION,
 915     optional: true,
 916     nullable: true
 917   }]);
 918
 919   var callArgs = {};
 920   callArgs.id = args.resource._id;  // TODO: check if this is correct
 921
 922   var callback = function(result) {
 923     if (native.isFailure(result)) {
 924       native.callIfPossible(args.errorCallback, native.getErrorObject(result));
 925     } else {
 926       args.successCallback(args.resource);
 927     }
 928   };
 929
 930   var result = native.call('IotconServer_updateResource', callArgs, callback);
 931
 932   if (native.isFailure(result)) {
 933     throw native.getErrorObject(result);
 934   }
 935 };
 936
 937 var client = new Client();
 938 var server = new Server();
 939
 940 function Iotcon() {
 941 }
 942
 943 Iotcon.prototype.getClient = function() {
 944   return client;
 945 };
 946
 947 Iotcon.prototype.getServer = function() {
 948   return server;
 949 };
 950
 951 Iotcon.prototype.getTimeout = function() {
 952   var result = native.callSync('Iotcon_getTimeout', {});
 953
 954   if (native.isFailure(result)) {
 955     throw native.getErrorObject(result);
 956   } else {
 957     return native.getResultObject(result);
 958   }
 959 };
 960
 961 Iotcon.prototype.setTimeout = function() {
 962   var args = validator.validateMethod(arguments, [{
 963     name: 'timeout',
 964     type: types.LONG
 965   }]);
 966
 967   var callArgs = {};
 968   callArgs.timeout = args.timeout;
 969
 970   var result = native.callSync('Iotcon_setTimeout', callArgs);
 971
 972   if (native.isFailure(result)) {
 973     throw native.getErrorObject(result);
 974   }
 975 };
 976
 977 // Exports
 978 tizen.IotconOption = IotconOption;
 979 tizen.Query = Query;
 980 tizen.QueryFilter = QueryFilter;
 981 tizen.Representation = Representation;
 982 tizen.Response = Response;
 983 tizen.State = State;
 984 exports = new Iotcon();