[Iotcon] Stubs of JS interface (RemoteResource).

Change-Id: I0de1aa18347cf224f21a891baaf1cb85d0e50756
Signed-off-by: Pawel Andruszkiewicz <p.andruszkie@samsung.com>

diff --git a/src/iotcon/iotcon_api.js b/src/iotcon/iotcon_api.js
index c050efc4de718e694b439507183ac75e7e8c5cb6..4311a413a72023674e84b3102ae5f0c682de53f4 100644 (file)
--- a/src/iotcon/iotcon_api.js
+++ b/src/iotcon/iotcon_api.js
@@ -19,6 +19,97 @@ var validator = xwalk.utils.validator;
 var types = validator.Types;
 var T = xwalk.utils.type;
 
+function createListener(name, c) {
+  var listenerName = name;
+  var callback = c || function(response) {
+    return response;
+  };
+  var listeners = {};
+  var jsListenerRegistered = false;
+
+  function internalCallback(response) {
+    if (listeners[response.id]) {
+      listeners[response.id](callback(response));
+    }
+  }
+
+  function addListener(id, func) {
+    if (!jsListenerRegistered) {
+      native.addListener(listenerName, internalCallback);
+      jsListenerRegistered = true;
+    }
+
+    listeners[id] = func;
+  }
+
+  function removeListener(id) {
+    if (listeners[id]) {
+      delete listeners[id];
+    }
+
+    if (jsListenerRegistered && T.isEmptyObject(listeners)) {
+      native.removeListener(listenerName, internalCallback);
+      jsListenerRegistered = false;
+    }
+  }
+
+  return {
+    addListener: addListener,
+    removeListener: removeListener
+  };
+}
+
+function InternalData(d) {
+  for (var prop in d) {
+    if (d.hasOwnProperty(prop)) {
+      this[prop] = d[prop];
+    }
+  }
+}
+
+InternalData.prototype.update = function(dst) {
+  for (var prop in this) {
+    if (this.hasOwnProperty(prop) && dst.hasOwnProperty(prop)) {
+      dst[prop] = this;
+    }
+  }
+};
+
+InternalData.prototype.decorate = function(dst) {
+  var that = this;
+  function getBuilder(prop) {
+    if (T.isArray(that[prop])) {
+      return function() {
+        return that[prop].slice();
+      };
+    } else {
+      return function() {
+        return that[prop];
+      };
+    }
+  }
+  function setBuilder(prop) {
+    return function(d) {
+      if (d instanceof InternalData) {
+        that[prop] = d[prop];
+      }
+    };
+  }
+  for (var prop in this) {
+    if (this.hasOwnProperty(prop)) {
+      Object.defineProperty(dst, prop, {
+        get: getBuilder(prop),
+        set: setBuilder(prop),
+        enumerable: true
+      });
+    }
+  }
+};
+
+function updateWithInternalData(src, dst) {
+  new InternalData(src).update(dst);
+}
+
 var ResponseResult = {
   SUCCESS: 'SUCCESS',
   ERROR: 'ERROR',
@@ -65,24 +156,83 @@ var PresenceTriggerType = {
   DEREGISTER: 'DEREGISTER'
 };
 
-function Client() {
+function Query() {
 }
 
-Client.prototype.findResource = function() {
+function Representation() {
+}
+
+function RemoteResource(data) {
+  Object.defineProperties(this, {
+    _id: {
+      value: data.id,
+      writable: false,
+      enumerable: false
+    },
+    cachedRepresentation: {
+      get: function() {
+        var callArgs = {};
+        callArgs.id = data.id;
+        var result = native.callSync('IotconRemoteResource_getCachedRepresentation', callArgs);
+        // TODO: implement
+      },
+      set: function() {},
+      enumerable: true
+    }
+  });
+
+  delete data.id;
+
+  var internal = new InternalData(data);
+  internal.decorate(this);
+}
+
+RemoteResource.prototype.methodGet = function() {
   var args = validator.validateMethod(arguments, [{
-    name: 'hostAddress',
-    type: types.STRING,
-    nullable: true
+    name: 'query',
+    type: types.PLATFORM_OBJECT,
+    values: Query
   }, {
-    name: 'resourceType',
-    type: types.STRING,
+    name: 'responseCallback',
+    type: types.FUNCTION
+  }, {
+    name: 'errorCallback',
+    type: types.FUNCTION,
+    optional: true,
     nullable: true
+  }]);
+
+  var callArgs = {};
+  callArgs.id = this._id;
+  callArgs.query = args.query;
+
+  var callback = function(result) {
+    if (native.isFailure(result)) {
+      native.callIfPossible(args.errorCallback, native.getErrorObject(result));
+    } else {
+      // TODO: implement
+      args.responseCallback();
+    }
+  };
+
+  var result = native.call('IotconRemoteResource_methodGet', callArgs, callback);
+
+  if (native.isFailure(result)) {
+    throw native.getErrorObject(result);
+  }
+};
+
+RemoteResource.prototype.methodPut = function() {
+  var args = validator.validateMethod(arguments, [{
+    name: 'representation',
+    type: types.PLATFORM_OBJECT,
+    values: Representation
   }, {
-    name: 'connectivityType',
-    type: types.ENUM,
-    values: T.getValues(ConnectivityType)
+    name: 'query',
+    type: types.PLATFORM_OBJECT,
+    values: Query
   }, {
-    name: 'successCallback',
+    name: 'responseCallback',
     type: types.FUNCTION
   }, {
     name: 'errorCallback',
@@ -92,63 +242,272 @@ Client.prototype.findResource = function() {
   }]);
 
   var callArgs = {};
-  callArgs.hostAddress = args.hostAddress;
-  callArgs.resourceType = args.resourceType;
-  callArgs.connectivityType = args.connectivityType;
+  callArgs.id = this._id;
+  callArgs.representation = args.representation;
+  callArgs.query = args.query;
 
   var callback = function(result) {
     if (native.isFailure(result)) {
       native.callIfPossible(args.errorCallback, native.getErrorObject(result));
     } else {
       // TODO: implement
-      args.successCallback();
+      args.responseCallback();
     }
   };
 
-  var result = native.call('IotconClient_findResource', callArgs, callback);
+  var result = native.call('IotconRemoteResource_methodPut', callArgs, callback);
 
   if (native.isFailure(result)) {
     throw native.getErrorObject(result);
   }
 };
 
-var presenceEventListener = (function() {
-  var listenerName = 'PresenceEventListener';
-  var listeners = {};
-  var jsListenerRegistered = false;
+RemoteResource.prototype.methodPost = function() {
+  var args = validator.validateMethod(arguments, [{
+    name: 'representation',
+    type: types.PLATFORM_OBJECT,
+    values: Representation
+  }, {
+    name: 'query',
+    type: types.PLATFORM_OBJECT,
+    values: Query
+  }, {
+    name: 'responseCallback',
+    type: types.FUNCTION
+  }, {
+    name: 'errorCallback',
+    type: types.FUNCTION,
+    optional: true,
+    nullable: true
+  }]);
 
-  function callback(response) {
-    if (listeners[response.id]) {
+  var callArgs = {};
+  callArgs.id = this._id;
+  callArgs.representation = args.representation;
+  callArgs.query = args.query;
+
+  var callback = function(result) {
+    if (native.isFailure(result)) {
+      native.callIfPossible(args.errorCallback, native.getErrorObject(result));
+    } else {
       // TODO: implement
-      listeners[response.id]();
+      args.responseCallback();
     }
+  };
+
+  var result = native.call('IotconRemoteResource_methodPost', callArgs, callback);
+
+  if (native.isFailure(result)) {
+    throw native.getErrorObject(result);
   }
+};
 
-  function addListener(id, func) {
-    if (!jsListenerRegistered) {
-      native.addListener(listenerName, callback);
-      jsListenerRegistered = true;
+RemoteResource.prototype.methodDelete = function() {
+  var args = validator.validateMethod(arguments, [{
+    name: 'responseCallback',
+    type: types.FUNCTION
+  }, {
+    name: 'errorCallback',
+    type: types.FUNCTION,
+    optional: true,
+    nullable: true
+  }]);
+
+  var callArgs = {};
+  callArgs.id = this._id;
+
+  var callback = function(result) {
+    if (native.isFailure(result)) {
+      native.callIfPossible(args.errorCallback, native.getErrorObject(result));
+    } else {
+      // TODO: implement
+      args.responseCallback();
     }
+  };
 
-    listeners[id] = func;
+  var result = native.call('IotconRemoteResource_methodDelete', callArgs, callback);
+
+  if (native.isFailure(result)) {
+    throw native.getErrorObject(result);
   }
+};
 
-  function removeListener(id) {
-    if (listeners[id]) {
-      delete listeners[id];
+var stateChangeListener = createListener('RemoteResourceStateChangeListener');
+
+RemoteResource.prototype.setStateChangeListener = function() {
+  var args = validator.validateMethod(arguments, [{
+    name: 'query',
+    type: types.PLATFORM_OBJECT,
+    values: Query
+  }, {
+    name: 'observePolicy',
+    type: types.ENUM,
+    values: T.getValues(ObservePolicy)
+  }, {
+    name: 'successCallback',
+    type: types.FUNCTION
+  }, {
+    name: 'errorCallback',
+    type: types.FUNCTION,
+    optional: true,
+    nullable: true
+  }]);
+
+  var callArgs = {};
+  callArgs.id = this._id;
+  callArgs.query = args.query;
+  callArgs.observePolicy = args.observePolicy;
+  var that = this;
+
+  var listener = function(result) {
+    if (native.isFailure(result)) {
+      native.callIfPossible(args.errorCallback, native.getErrorObject(result));
+    } else {
+      updateWithInternalData(native.getResultObject(result), that);
+      args.successCallback(that);
     }
+  };
 
-    if (jsListenerRegistered && T.isEmptyObject(listeners)) {
-      native.removeListener(listenerName, callback);
-      jsListenerRegistered = false;
+  var result = native.callSync('IotconRemoteResource_setStateChangeListener', callArgs);
+
+  if (native.isFailure(result)) {
+    throw native.getErrorObject(result);
+  } else {
+    stateChangeListener.addListener(this._id, listener);
+  }
+};
+
+RemoteResource.prototype.unsetStateChangeListener = function() {
+  var callArgs = {};
+  callArgs.id = this._id;
+
+  var result = native.callSync('IotconRemoteResource_unsetStateChangeListener', callArgs);
+
+  if (native.isFailure(result)) {
+    throw native.getErrorObject(result);
+  } else {
+    stateChangeListener.removeListener(this._id);
+  }
+};
+
+RemoteResource.prototype.startCaching = function() {
+  var callArgs = {};
+  callArgs.id = this._id;
+
+  var result = native.callSync('IotconRemoteResource_startCaching', callArgs);
+
+  if (native.isFailure(result)) {
+    throw native.getErrorObject(result);
+  }
+};
+
+RemoteResource.prototype.stopCaching = function() {
+  var callArgs = {};
+  callArgs.id = this._id;
+
+  var result = native.callSync('IotconRemoteResource_stopCaching', callArgs);
+
+  if (native.isFailure(result)) {
+    throw native.getErrorObject(result);
+  }
+};
+
+var connectionChangeListener = createListener('RemoteResourceConnectionChangeListener');
+
+RemoteResource.prototype.setConnectionChangeListener = function() {
+  var args = validator.validateMethod(arguments, [{
+    name: 'successCallback',
+    type: types.FUNCTION
+  }, {
+    name: 'errorCallback',
+    type: types.FUNCTION,
+    optional: true,
+    nullable: true
+  }]);
+
+  var callArgs = {};
+  callArgs.id = this._id;
+
+  var listener = function(result) {
+    if (native.isFailure(result)) {
+      native.callIfPossible(args.errorCallback, native.getErrorObject(result));
+    } else {
+      args.successCallback(native.getResultObject(result));
     }
+  };
+
+  var result = native.callSync('IotconRemoteResource_setConnectionChangeListener', callArgs);
+
+  if (native.isFailure(result)) {
+    throw native.getErrorObject(result);
+  } else {
+    connectionChangeListener.addListener(this._id, listener);
   }
+};
 
-  return {
-    addListener: addListener,
-    removeListener: removeListener
+RemoteResource.prototype.unsetConnectionChangeListener = function() {
+  var callArgs = {};
+  callArgs.id = this._id;
+
+  var result = native.callSync('IotconRemoteResource_unsetConnectionChangeListener', callArgs);
+
+  if (native.isFailure(result)) {
+    throw native.getErrorObject(result);
+  } else {
+    connectionChangeListener.removeListener(this._id);
+  }
+};
+
+function Client() {
+}
+
+Client.prototype.findResource = function() {
+  var args = validator.validateMethod(arguments, [{
+    name: 'hostAddress',
+    type: types.STRING,
+    nullable: true
+  }, {
+    name: 'resourceType',
+    type: types.STRING,
+    nullable: true
+  }, {
+    name: 'connectivityType',
+    type: types.ENUM,
+    values: T.getValues(ConnectivityType)
+  }, {
+    name: 'successCallback',
+    type: types.FUNCTION
+  }, {
+    name: 'errorCallback',
+    type: types.FUNCTION,
+    optional: true,
+    nullable: true
+  }]);
+
+  var callArgs = {};
+  callArgs.hostAddress = args.hostAddress;
+  callArgs.resourceType = args.resourceType;
+  callArgs.connectivityType = args.connectivityType;
+
+  var callback = function(result) {
+    if (native.isFailure(result)) {
+      native.callIfPossible(args.errorCallback, native.getErrorObject(result));
+    } else {
+      var rr = new RemoteResource(native.getResultObject(result));
+      args.successCallback(rr);
+    }
   };
-})();
+
+  var result = native.call('IotconClient_findResource', callArgs, callback);
+
+  if (native.isFailure(result)) {
+    throw native.getErrorObject(result);
+  }
+};
+
+var presenceEventListener = createListener('PresenceEventListener', function(response) {
+  // TODO: implement
+});
 
 Client.prototype.addPresenceEventListener = function() {
   var args = validator.validateMethod(arguments, [{