From 031c743c461689d2990ae4be2b4f49e8e45d08ca Mon Sep 17 00:00:00 2001 From: Andrzej Popowski Date: Fri, 26 Aug 2016 09:57:35 +0200 Subject: [PATCH] [Iotcon] - Changing implementation according to widl changed Change-Id: I28eba53023e7cba1c429454c9871d23e9c842df0 Signed-off-by: Andrzej Popowski --- src/iotcon/iotcon_api.js | 330 +++++++++++++++----- src/iotcon/iotcon_instance.cc | 467 ++++++++++++++++++++++------ src/iotcon/iotcon_instance.h | 26 +- src/iotcon/iotcon_server_manager.cc | 26 +- src/iotcon/iotcon_utils.cc | 67 ++-- src/iotcon/iotcon_utils.h | 15 +- 6 files changed, 693 insertions(+), 238 deletions(-) diff --git a/src/iotcon/iotcon_api.js b/src/iotcon/iotcon_api.js index 2f05b701..10f5a54a 100644 --- a/src/iotcon/iotcon_api.js +++ b/src/iotcon/iotcon_api.js @@ -19,6 +19,7 @@ var validator = xwalk.utils.validator; var types = validator.Types; var T = xwalk.utils.type; var kIdKey = Symbol(); +var converter = xwalk.converter; function createListener(name, c) { var listenerName = name; @@ -131,6 +132,7 @@ var ResponseResult = { ERROR: 'ERROR', RESOURCE_CREATED: 'RESOURCE_CREATED', RESOURCE_DELETED: 'RESOURCE_DELETED', + RESOURCE_CHANGED: 'RESOURCE_CHANGED', SLOW: 'SLOW', FORBIDDEN: 'FORBIDDEN', }; @@ -171,6 +173,20 @@ var QosLevel = { HIGH: 'HIGH' }; +var RequestType = { + UNKNOWN: 'UNKNOWN', + GET: 'GET', + PUT: 'PUT', + POST: 'POST', + DELETE: 'DELETE' +}; + +var ObserveType = { + NO_TYPE: 'NO_TYPE', + REGISTER: 'REGISTER', + DEREGISTER: 'DEREGISTER' +}; + function DeviceInfo(data) { decorateWithData(data, this); } @@ -237,12 +253,12 @@ function Representation(uriPath) { writable: true, enumerable: true }, - states: { + attributes: { value: null, writable: true, enumerable: true }, - representations: { + children: { value: null, writable: true, enumerable: true @@ -252,7 +268,7 @@ function Representation(uriPath) { function createRepresentation(data) { var r = new tizen.Representation(data.uriPath); - var props = ['resourceTypes', 'resourceInterfaces', 'states']; + var props = ['resourceTypes', 'resourceInterfaces', 'attributes']; for (var p = 0; p < props.length; ++p) { if (data[props[p]]) { @@ -260,10 +276,10 @@ function createRepresentation(data) { } } - if (data.representations) { - r.representations = []; - for (var i = 0; i < data.representations.length; ++i) { - r.representations.push(createRepresentation(data.representations[i])); + if (data.children) { + r.children = []; + for (var i = 0; i < data.children.length; ++i) { + r.children.push(createRepresentation(data.children[i])); } } @@ -313,7 +329,7 @@ function Resource(data) { var internal = new InternalData(data); internal.decorate(this); - this.states = null; + this.attributes = null; } Resource.prototype.notify = function() { @@ -329,20 +345,20 @@ Resource.prototype.notify = function() { nullable: true }]); - var states = {}; - function getStates(r) { - states[r[kIdKey]] = r.states; + var attributes = {}; + function getAttributes(r) { + attributes[r[kIdKey]] = r.attributes; for (var i = 0; i < r.resources.length; ++i) { - getStates(r.resources[i]); + getAttributes(r.resources[i]); } } - getStates(this); + getAttributes(this); var callArgs = {}; callArgs.id = this[kIdKey]; callArgs.qos = args.qos; callArgs.observerIds = args.observerIds; - callArgs.states = states; + callArgs.attributes = attributes; var result = native.callSync('IotconResource_notify', callArgs); @@ -441,21 +457,37 @@ Resource.prototype.removeChildResource = function() { } }; -var resourceRequestListener = createListener('ResourceRequestListener', function(response) { - return new Request(response.data); -}); - -Resource.prototype.setRequestListener = function() { - var args = validator.validateMethod(arguments, [{ - name: 'successCallback', - type: types.FUNCTION - }]); +var resourceRequestListener = createListener('ResourceRequestListener'); +var _setRequestListener = function(id, listener) { var callArgs = {}; - callArgs.id = this[kIdKey]; + callArgs.id = id; var listener = function(result) { - args.successCallback(result); + var request = new Request(result.data.request); + switch (converter.toString(result.data.type, false)) { + case RequestType.GET: + native.callIfPossible(listener.onget, request); + break; + + case RequestType.PUT: + native.callIfPossible(listener.onput, request); + break; + + case RequestType.POST: + native.callIfPossible(listener.onpost, request); + break; + + case RequestType.DELETE: + native.callIfPossible(listener.ondelete, request); + break; + } + + var observeType = converter.toString(result.data.observeType, false); + var observerId = converter.toUnsignedLong(result.data.observerId, false); + if (observeType !== ObserveType.NO_TYPE && observerId) { + native.callIfPossible(listener.onobserving(request, observeType, observerId)); + } }; var result = native.callSync('IotconResource_setRequestListener', callArgs); @@ -463,10 +495,20 @@ Resource.prototype.setRequestListener = function() { if (native.isFailure(result)) { throw native.getErrorObject(result); } else { - resourceRequestListener.addListener(this[kIdKey], listener); + resourceRequestListener.addListener(id, listener); } }; +Resource.prototype.setRequestListener = function() { + var args = validator.validateMethod(arguments, [{ + name: 'listener', + type: types.LISTENER, + values: ['onget', 'onput', 'onpost', 'ondelete', 'onobserving'] + }]); + + _setRequestListener(this[kIdKey], args.listener); +}; + Resource.prototype.unsetRequestListener = function() { var callArgs = {}; callArgs.id = this[kIdKey]; @@ -480,7 +522,6 @@ Resource.prototype.unsetRequestListener = function() { } }; - function Response(request) { validator.isConstructorCall(this, tizen.Response); @@ -509,17 +550,11 @@ function Response(request) { } Response.prototype.send = function() { - var args = validator.validateMethod(arguments, [{ - name: 'iface', - type: types.STRING - }]); - var callArgs = {}; callArgs.id = this.request[kIdKey]; callArgs.result = this.result; callArgs.representation = this.representation; callArgs.options = this.options; - callArgs.iface = args.iface; var result = native.callSync('IotconResponse_send', callArgs); @@ -646,12 +681,39 @@ function RemoteResource(data) { var callArgs = prepareResourceInfo(this, true); callArgs['options'] = val; + var result = native.callSync('IotconRemoteResource_setOptions', callArgs); if (native.isSuccess(result)) { manageId(this, native.getResultObject(result)); } }.bind(this), enumerable: true + }, + timeInterval: { + get: function() { + /* TODO Uncomment when the interface of the function iotcon_remote_resource_get_time_interval is changed + var callArgs = prepareResourceInfo(this, true); + */ + var callArgs = {}; + + var result = native.callSync('IotconRemoteResource_getTimeInterval', callArgs); + if (native.isSuccess(result)) { + return native.getResultObject(result); + } + return null; + }.bind(this), + set: function(val) { + /* TODO Uncomment when the interface of the function iotcon_remote_resource_set_time_interval is changed + var callArgs = prepareResourceInfo(this, true); + callArgs[timeInterval] = converter.toLong(val); + */ + var callArgs = { + timeInterval: converter.toLong(val) + }; + + native.callSync('IotconRemoteResource_setTimeInterval', callArgs); + }.bind(this), + enumerable: true } }); @@ -665,11 +727,13 @@ function RemoteResource(data) { RemoteResource.prototype.methodGet = function() { var args = validator.validateMethod(arguments, [{ - name: 'query', - type: types.DICTIONARY - }, { name: 'responseCallback', type: types.FUNCTION + }, { + name: 'query', + type: types.DICTIONARY, + optional: true, + nullable: true }, { name: 'errorCallback', type: types.FUNCTION, @@ -678,7 +742,9 @@ RemoteResource.prototype.methodGet = function() { }]); var callArgs = prepareResourceInfo(this); - callArgs.query = args.query; + if (args.query) { + callArgs.query = args.query; + } var callback = function(result) { result = native.getResultObject(result); @@ -704,12 +770,14 @@ RemoteResource.prototype.methodPut = function() { name: 'representation', type: types.PLATFORM_OBJECT, values: Representation - }, { - name: 'query', - type: types.DICTIONARY }, { name: 'responseCallback', type: types.FUNCTION + }, { + name: 'query', + type: types.DICTIONARY, + optional: true, + nullable: true }, { name: 'errorCallback', type: types.FUNCTION, @@ -719,7 +787,9 @@ RemoteResource.prototype.methodPut = function() { var callArgs = prepareResourceInfo(this); callArgs.representation = args.representation; - callArgs.query = args.query; + if (args.query) { + callArgs.query = args.query; + } var callback = function(result) { result = native.getResultObject(result); @@ -745,12 +815,14 @@ RemoteResource.prototype.methodPost = function() { name: 'representation', type: types.PLATFORM_OBJECT, values: Representation - }, { - name: 'query', - type: types.DICTIONARY }, { name: 'responseCallback', type: types.FUNCTION + }, { + name: 'query', + type: types.DICTIONARY, + optional: true, + nullable: true }, { name: 'errorCallback', type: types.FUNCTION, @@ -760,7 +832,9 @@ RemoteResource.prototype.methodPost = function() { var callArgs = prepareResourceInfo(this); callArgs.representation = args.representation; - callArgs.query = args.query; + if (args.query) { + callArgs.query = args.query; + } var callback = function(result) { result = native.getResultObject(result); @@ -813,24 +887,28 @@ RemoteResource.prototype.methodDelete = function() { } }; -var stateChangeListener = createListener('RemoteResourceStateChangeListener'); +var resourceChangeListener = createListener('RemoteResourceChangeListener'); -RemoteResource.prototype.setStateChangeListener = function() { +RemoteResource.prototype.startObserving = function() { var args = validator.validateMethod(arguments, [{ - name: 'query', - type: types.DICTIONARY - }, { name: 'observePolicy', type: types.ENUM, values: T.getValues(ObservePolicy) }, { name: 'successCallback', type: types.FUNCTION + }, { + name: 'query', + type: types.DICTIONARY, + optional: true, + nullable: true }]); var callArgs = prepareResourceInfo(this); - callArgs.query = args.query; callArgs.observePolicy = args.observePolicy; + if (args.query) { + callArgs.query = args.query; + } var that = this; var listener = function(result) { @@ -839,38 +917,52 @@ RemoteResource.prototype.setStateChangeListener = function() { args.successCallback(new RemoteResponse(result.data)); }; - var result = native.callSync('IotconRemoteResource_setStateChangeListener', callArgs); + var result = native.callSync('IotconRemoteResource_startObserving', callArgs); if (native.isFailure(result)) { throw native.getErrorObject(result); } else { manageId(this, native.getResultObject(result)); - stateChangeListener.addListener(this[kIdKey], listener); + resourceChangeListener.addListener(this[kIdKey], listener); } }; -RemoteResource.prototype.unsetStateChangeListener = function() { +RemoteResource.prototype.stopObserving = function() { var callArgs = prepareResourceInfo(this); - var result = native.callSync('IotconRemoteResource_unsetStateChangeListener', callArgs); + var result = native.callSync('IotconRemoteResource_stopObserving', callArgs); if (native.isFailure(result)) { throw native.getErrorObject(result); } else { manageId(this, native.getResultObject(result)); - stateChangeListener.removeListener(this[kIdKey]); + resourceChangeListener.removeListener(this[kIdKey]); } }; +var cacheChangeListener = createListener('RemoteResourceCacheChangeListener'); + RemoteResource.prototype.startCaching = function() { + var args = validator.validateMethod(arguments, [{ + name: 'successCallback', + type: types.FUNCTION, + optional: true, + nullable: true + }]); + var callArgs = prepareResourceInfo(this); + var listener = function(result) { + native.callIfPossible(args.successCallback(createRepresentation(native.getResultObject(result.data)))); + } + var result = native.callSync('IotconRemoteResource_startCaching', callArgs); if (native.isFailure(result)) { throw native.getErrorObject(result); } else { manageId(this, native.getResultObject(result)); + cacheChangeListener.addListener(this[kIdKey], listener); } }; @@ -883,12 +975,13 @@ RemoteResource.prototype.stopCaching = function() { throw native.getErrorObject(result); } else { manageId(this, native.getResultObject(result)); + cacheChangeListener.removeListener(this[kIdKey]); } }; -var connectionChangeListener = createListener('RemoteResourceConnectionChangeListener'); +var resourceStateChangeListener = createListener('RemoteResourceStateChangeListener'); -RemoteResource.prototype.setConnectionChangeListener = function() { +RemoteResource.prototype.setResourceStateChangeListener = function() { var args = validator.validateMethod(arguments, [{ name: 'successCallback', type: types.FUNCTION @@ -900,26 +993,26 @@ RemoteResource.prototype.setConnectionChangeListener = function() { args.successCallback(result.data); }; - var result = native.callSync('IotconRemoteResource_setConnectionChangeListener', callArgs); + var result = native.callSync('IotconRemoteResource_setResourceStateChangeListener', callArgs); if (native.isFailure(result)) { throw native.getErrorObject(result); } else { manageId(this, native.getResultObject(result)); - connectionChangeListener.addListener(this[kIdKey], listener); + resourceStateChangeListener.addListener(this[kIdKey], listener); } }; -RemoteResource.prototype.unsetConnectionChangeListener = function() { +RemoteResource.prototype.unsetResourceStateChangeListener = function() { var callArgs = prepareResourceInfo(this); - var result = native.callSync('IotconRemoteResource_unsetConnectionChangeListener', callArgs); + var result = native.callSync('IotconRemoteResource_unsetResourceStateChangeListener', callArgs); if (native.isFailure(result)) { throw native.getErrorObject(result); } else { manageId(this, native.getResultObject(result)); - connectionChangeListener.removeListener(this[kIdKey]); + resourceStateChangeListener.removeListener(this[kIdKey]); } }; @@ -935,8 +1028,8 @@ Client.prototype.findResource = function() { type: types.STRING, nullable: true }, { - name: 'resourceType', - type: types.STRING, + name: 'query', + type: types.DICTIONARY, nullable: true }, { name: 'connectivityType', @@ -950,17 +1043,13 @@ Client.prototype.findResource = function() { type: types.FUNCTION, optional: true, nullable: true - }, { - name: 'isSecure', - type: types.BOOLEAN }]); var callArgs = {}; callArgs.id = ++globalFindResourceId; callArgs.hostAddress = args.hostAddress; - callArgs.resourceType = args.resourceType; + callArgs.query = args.query; callArgs.connectivityType = args.connectivityType; - callArgs.isSecure = args.isSecure; var callback = function(result) { if (native.isFailure(result)) { @@ -1035,10 +1124,15 @@ Client.prototype.removePresenceEventListener = function() { } }; -Client.prototype.getDeviceInfo = function() { +Client.prototype.findDeviceInfo = function() { var args = validator.validateMethod(arguments, [{ name: 'hostAddress', - type: types.STRING + type: types.STRING, + nullable: true + }, { + name: 'query', + type: types.DICTIONARY, + nullable: true }, { name: 'connectivityType', type: types.ENUM, @@ -1054,7 +1148,9 @@ Client.prototype.getDeviceInfo = function() { }]); var callArgs = {}; + callArgs.hostAddress = args.hostAddress; + callArgs.query = args.query; callArgs.connectivityType = args.connectivityType; var callback = function(result) { @@ -1065,17 +1161,22 @@ Client.prototype.getDeviceInfo = function() { } }; - var result = native.call('IotconClient_getDeviceInfo', callArgs, callback); + var result = native.call('IotconClient_findDeviceInfo', callArgs, callback); if (native.isFailure(result)) { throw native.getErrorObject(result); } }; -Client.prototype.getPlatformInfo = function() { +Client.prototype.findPlatformInfo = function() { var args = validator.validateMethod(arguments, [{ name: 'hostAddress', - type: types.STRING + type: types.STRING, + nullable: true + }, { + name: 'query', + type: types.DICTIONARY, + nullable: true }, { name: 'connectivityType', type: types.ENUM, @@ -1092,6 +1193,7 @@ Client.prototype.getPlatformInfo = function() { var callArgs = {}; callArgs.hostAddress = args.hostAddress; + callArgs.query = args.query; callArgs.connectivityType = args.connectivityType; var callback = function(result) { @@ -1102,7 +1204,7 @@ Client.prototype.getPlatformInfo = function() { } }; - var result = native.call('IotconClient_getPlatformInfo', callArgs, callback); + var result = native.call('IotconClient_findPlatformInfo', callArgs, callback); if (native.isFailure(result)) { throw native.getErrorObject(result); @@ -1110,6 +1212,31 @@ Client.prototype.getPlatformInfo = function() { }; function Server() { + // TODO The variable _deviceName will be removed when the native function for getting device name is ready + var _deviceName = ''; + + Object.defineProperties(this, { + deviceName: { + get: function() { + return _deviceName; + }, + set: function(v) { + if (v) { + var deviceName = converter.toString(v); + + var callArgs = { + deviceName: deviceName + }; + + var result = native.callSync('IotconServer_setDeviceName', callArgs); + if (native.isSuccess(result)) { + _deviceName = deviceName; + } + } + }, + enumerable: true + } + }); } var serverResources = {}; @@ -1127,13 +1254,17 @@ Server.prototype.createResource = function() { type: types.ARRAY, values: types.STRING }, { - name: 'dictionary', + name: 'listener', + type: types.LISTENER, + values: ['onget', 'onput', 'onpost', 'ondelete', 'onobserving'] + }, { + name: 'policy', type: types.DICTIONARY, optional: true, nullable: false }]); - var callArgs = args.dictionary || {}; + var callArgs = args.policy || {}; callArgs.uriPath = args.uriPath; callArgs.resourceTypes = args.resourceTypes; callArgs.resourceInterfaces = args.resourceInterfaces; @@ -1145,6 +1276,9 @@ Server.prototype.createResource = function() { } else { var resource = new Resource(native.getResultObject(result)); serverResources[resource[kIdKey]] = resource; + + _setRequestListener(resource[kIdKey], args.listener); + return resource; } }; @@ -1180,12 +1314,52 @@ Server.prototype.getResources = function() { return result; }; +Server.prototype.startPresence = function() { + var args = validator.validateMethod(arguments, [{ + name: 'timeToLive', + type: types.UNSIGNED_LONG + }]); + + var callArgs = { + timeToLive: args.timeToLive + }; + + var result = native.callSync('IotconServer_startPresence', callArgs); + if (native.isFailure(result)) { + throw native.getErrorObject(result); + } +}; + +Server.prototype.stopPresence = function() { + var result = native.callSync('IotconServer_stopPresence', {}); + if (native.isFailure(result)) { + throw native.getErrorObject(result); + } +}; + var client = new Client(); var server = new Server(); function Iotcon() { } +Iotcon.prototype.initialize = function() { + var args = validator.validateMethod(arguments, [{ + name: 'filePath', + type: types.STRING + }]); + + var data = { + filePath: args.filePath + }; + + var result = native.callSync('Iotcon_initialize', data); + + if (native.isFailure(result)) { + throw native.getErrorObject(result); + } +}; + Iotcon.prototype.getClient = function() { return client; }; diff --git a/src/iotcon/iotcon_instance.cc b/src/iotcon/iotcon_instance.cc index 46b5f4d3..3572ca75 100644 --- a/src/iotcon/iotcon_instance.cc +++ b/src/iotcon/iotcon_instance.cc @@ -30,7 +30,7 @@ namespace extension { namespace iotcon { namespace { -const std::string kPrivilegeIotcon = "http://tizen.org/privilege/d2d.datasharing"; +const std::string kPrivilegeIotcon = "http://tizen.org/privilege/internet"; struct CallbackData { common::PostCallback fun; @@ -71,10 +71,12 @@ void RemoteResourceResponseCallback(iotcon_remote_resource_h resource, const common::ListenerToken kResourceRequestListenerToken{"ResourceRequestListener"}; const common::ListenerToken kFindResourceListenerToken{"FindResourceListener"}; const common::ListenerToken kPresenceEventListenerToken{"PresenceEventListener"}; -const common::ListenerToken kRemoteResourceConnectionChangeListener - {"RemoteResourceConnectionChangeListener"}; const common::ListenerToken kRemoteResourceStateChangeListener {"RemoteResourceStateChangeListener"}; +const common::ListenerToken kRemoteResourceChangeListener + {"RemoteResourceChangeListener"}; +const common::ListenerToken kRemoteResourceCacheChangeListener + {"RemoteResourceCacheChangeListener"}; const std::string kObserverIds = "observerIds"; const std::string kQos = "qos"; @@ -84,12 +86,16 @@ const std::string kInterface = "iface"; const std::string kResult = "result"; const std::string kTimeout = "timeout"; const std::string kData = "data"; +const std::string kFilePath = "filePath"; +const std::string kTimeToLive = "timeToLive"; + +const std::string kTimeInterval = "timeInterval"; const std::string kVirtualResourcesHandlingPath = "/home/owner/share/tmp_file_iotcon.dat"; } // namespace -IotconInstance::IotconInstance() { +IotconInstance::IotconInstance() : initialized_(false), presence_started_(false) { ScopeLogger(); using std::placeholders::_1; @@ -110,18 +116,24 @@ IotconInstance::IotconInstance() { REGISTER_SYNC("IotconRemoteResource_getCachedRepresentation", RemoteResourceGetCachedRepresentation); REGISTER_SYNC("IotconRemoteResource_getOptions", RemoteResourceGetOptions); REGISTER_SYNC("IotconRemoteResource_setOptions", RemoteResourceSetOptions); - REGISTER_SYNC("IotconRemoteResource_setStateChangeListener", RemoteResourceSetStateChangeListener); - REGISTER_SYNC("IotconRemoteResource_unsetStateChangeListener", RemoteResourceUnsetStateChangeListener); + REGISTER_SYNC("IotconRemoteResource_startObserving", RemoteResourceStartObserving); + REGISTER_SYNC("IotconRemoteResource_stopObserving", RemoteResourceStopObserving); REGISTER_SYNC("IotconRemoteResource_startCaching", RemoteResourceStartCaching); REGISTER_SYNC("IotconRemoteResource_stopCaching", RemoteResourceStopCaching); - REGISTER_SYNC("IotconRemoteResource_setConnectionChangeListener", RemoteResourceSetConnectionChangeListener); - REGISTER_SYNC("IotconRemoteResource_unsetConnectionChangeListener", RemoteResourceUnsetConnectionChangeListener); + REGISTER_SYNC("IotconRemoteResource_setResourceStateChangeListener", RemoteResourceSetResourceStateChangeListener); + REGISTER_SYNC("IotconRemoteResource_unsetResourceStateChangeListener", RemoteResourceUnsetResourceStateChangeListener); + REGISTER_SYNC("IotconRemoteResource_getTimeInterval", RemoteResourceGetTimeInterval); + REGISTER_SYNC("IotconRemoteResource_setTimeInterval", RemoteResourceSetTimeInterval); REGISTER_SYNC("IotconClient_addPresenceEventListener", ClientAddPresenceEventListener); REGISTER_SYNC("IotconClient_removePresenceEventListener", ClientRemovePresenceEventListener); + REGISTER_SYNC("Iotcon_initialize", Initialize); REGISTER_SYNC("Iotcon_getTimeout", GetTimeout); REGISTER_SYNC("Iotcon_setTimeout", SetTimeout); REGISTER_SYNC("IotconServer_createResource", ServerCreateResource); REGISTER_SYNC("IotconServer_removeResource", ServerRemoveResource); + REGISTER_SYNC("IotconServer_startPresence", ServerStartPresence); + REGISTER_SYNC("IotconServer_stopPresence", ServerStopPresence); + REGISTER_SYNC("IotconServer_setDeviceName", ServerSetDeviceName); REGISTER_SYNC("IotconClient_findResource", ClientFindResource); #undef REGISTER_SYNC @@ -133,33 +145,26 @@ IotconInstance::IotconInstance() { REGISTER_ASYNC("IotconRemoteResource_methodPut", RemoteResourceMethodPut); REGISTER_ASYNC("IotconRemoteResource_methodPost", RemoteResourceMethodPost); REGISTER_ASYNC("IotconRemoteResource_methodDelete", RemoteResourceMethodDelete); - REGISTER_ASYNC("IotconClient_getDeviceInfo", ClientGetDeviceInfo); - REGISTER_ASYNC("IotconClient_getPlatformInfo", ClientGetPlatformInfo); + REGISTER_ASYNC("IotconClient_findDeviceInfo", ClientFindDeviceInfo); + REGISTER_ASYNC("IotconClient_findPlatformInfo", ClientFindPlatformInfo); #undef REGISTER_ASYNC - - // initialize connection to iotcon service - int ret = iotcon_initialize(kVirtualResourcesHandlingPath.c_str()); - if (IOTCON_ERROR_NONE != ret) { - LoggerE("Could not connnect to iotcon service: %s", get_error_message(ret)); - } else { - LoggerD("Iotcon service connected"); - - ret = iotcon_start_presence(0); - if (IOTCON_ERROR_NONE != ret) { - LoggerE("Could not start presence: %s", - get_error_message(ret)); - } else { - LoggerD("Iotcon iotcon_start_presence"); - } - } } IotconInstance::~IotconInstance() { ScopeLogger(); - iotcon_stop_presence(); - iotcon_deinitialize(); + if (presence_started_) { + iotcon_stop_presence(); + presence_started_ = false; + LoggerD("Iotcon service presence stopped"); + } + + if (initialized_) { + iotcon_deinitialize(); + initialized_ = false; + LoggerD("Iotcon service deinitialized"); + } } common::TizenResult IotconInstance::ResourceGetObserverIds(const picojson::object& args) { @@ -191,7 +196,7 @@ common::TizenResult IotconInstance::ResourceNotify(const picojson::object& args) CHECK_EXIST(args, kId); CHECK_EXIST(args, kQos); - CHECK_EXIST(args, kStates); + CHECK_EXIST(args, kAttributes); ResourceInfoPtr resource; long long id = GetId(args); @@ -244,10 +249,10 @@ common::TizenResult IotconInstance::ResourceNotify(const picojson::object& args) } } - // create representation from resource and states + // create representation from resource and attributes iotcon_representation_h representation = nullptr; - result = IotconUtils::RepresentationFromResource(resource, IotconUtils::GetArg(args, kStates), &representation); + result = IotconUtils::RepresentationFromResource(resource, IotconUtils::GetArg(args, kAttributes), &representation); if (!result) { LogAndReturnTizenError(result, ("RepresentationFromResource() failed")); } @@ -392,7 +397,8 @@ common::TizenResult IotconInstance::ResourceSetRequestListener(const picojson::o } if (!resource->request_listener) { - resource->request_listener = [this, id](const common::TizenResult&, const picojson::value& v) { + resource->request_listener = [this, id](const common::TizenResult&, + const picojson::value& v) { picojson::value response{picojson::object{}}; auto& obj = response.get(); @@ -430,7 +436,6 @@ common::TizenResult IotconInstance::ResponseSend(const picojson::object& args) { CHECK_EXIST(args, kResult); CHECK_EXIST(args, kRepresentation); CHECK_EXIST(args, kOptions); - CHECK_EXIST(args, kInterface); ResponsePtr response = nullptr; auto result = IotconServerManager::GetInstance().GetResponseById(GetId(args), &response); @@ -592,8 +597,6 @@ common::TizenResult IotconInstance::RemoteResourceMethodGet(const picojson::obje CHECK_PRIVILEGE(kPrivilegeIotcon); - CHECK_EXIST(args, kQuery); - FoundRemoteInfoPtr resource; auto result = IotconUtils::RemoteResourceFromJson(args, &resource); if (!result) { @@ -601,12 +604,17 @@ common::TizenResult IotconInstance::RemoteResourceMethodGet(const picojson::obje } iotcon_query_h query = nullptr; - result = IotconUtils::QueryFromJson(IotconUtils::GetArg(args, kQuery).get(), &query); - if (!result) { - LogAndReturnTizenError(result, ("QueryFromJson() failed")); + const auto& query_it = args.find(kQuery); + if (args.end() != query_it) { + result = IotconUtils::QueryFromJson(query_it->second.get(), &query); + if (!result) { + LogAndReturnTizenError(result, ("QueryFromJson() failed")); + } } SCOPE_EXIT { - iotcon_query_destroy(query); + if (query) { + iotcon_query_destroy(query); + } }; std::unique_ptr data{new CallbackData{PostForMethodCall(token, resource)}}; @@ -649,7 +657,6 @@ common::TizenResult IotconInstance::RemoteResourceMethodPut(const picojson::obje CHECK_PRIVILEGE(kPrivilegeIotcon); CHECK_EXIST(args, kRepresentation); - CHECK_EXIST(args, kQuery); FoundRemoteInfoPtr resource; auto result = IotconUtils::RemoteResourceFromJson(args, &resource); @@ -667,12 +674,17 @@ common::TizenResult IotconInstance::RemoteResourceMethodPut(const picojson::obje }; iotcon_query_h query = nullptr; - result = IotconUtils::QueryFromJson(IotconUtils::GetArg(args, kQuery).get(), &query); - if (!result) { - LogAndReturnTizenError(result, ("QueryFromJson() failed")); + const auto& query_it = args.find(kQuery); + if (args.end() != query_it) { + result = IotconUtils::QueryFromJson(query_it->second.get(), &query); + if (!result) { + LogAndReturnTizenError(result, ("QueryFromJson() failed")); + } } SCOPE_EXIT { - iotcon_query_destroy(query); + if (query) { + iotcon_query_destroy(query); + } }; std::unique_ptr data{new CallbackData{PostForMethodCall(token, resource)}}; @@ -715,7 +727,6 @@ common::TizenResult IotconInstance::RemoteResourceMethodPost(const picojson::obj CHECK_PRIVILEGE(kPrivilegeIotcon); CHECK_EXIST(args, kRepresentation); - CHECK_EXIST(args, kQuery); FoundRemoteInfoPtr resource; auto result = IotconUtils::RemoteResourceFromJson(args, &resource); @@ -733,12 +744,17 @@ common::TizenResult IotconInstance::RemoteResourceMethodPost(const picojson::obj }; iotcon_query_h query = nullptr; - result = IotconUtils::QueryFromJson(IotconUtils::GetArg(args, kQuery).get(), &query); - if (!result) { - LogAndReturnTizenError(result, ("QueryFromJson() failed")); + const auto& query_it = args.find(kQuery); + if (args.end() != query_it) { + result = IotconUtils::QueryFromJson(query_it->second.get(), &query); + if (!result) { + LogAndReturnTizenError(result, ("QueryFromJson() failed")); + } } SCOPE_EXIT { - iotcon_query_destroy(query); + if (query) { + iotcon_query_destroy(query); + } }; std::unique_ptr data{new CallbackData{PostForMethodCall(token, resource)}}; @@ -823,6 +839,11 @@ static void ObserveCallback(iotcon_remote_resource_h resource, iotcon_error_e er int sequence_number, iotcon_response_h response, void *user_data) { ScopeLogger(); FoundRemoteInfo* ptr = static_cast(user_data); + if (nullptr == ptr) { + LoggerE("ObserveCallback() failed. Ignoring callback"); + return; + } + if (ptr->observe_listener) { picojson::value json_result = picojson::value(picojson::object()); @@ -835,12 +856,11 @@ static void ObserveCallback(iotcon_remote_resource_h resource, iotcon_error_e er } } -common::TizenResult IotconInstance::RemoteResourceSetStateChangeListener(const picojson::object& args) { +common::TizenResult IotconInstance::RemoteResourceStartObserving(const picojson::object& args) { ScopeLogger(); CHECK_PRIVILEGE(kPrivilegeIotcon); - CHECK_EXIST(args, kQuery); CHECK_EXIST(args, kObservePolicy); FoundRemoteInfoPtr ptr; auto result = IotconUtils::RemoteResourceFromJson(args, &ptr); @@ -849,13 +869,17 @@ common::TizenResult IotconInstance::RemoteResourceSetStateChangeListener(const p } iotcon_query_h query = nullptr; - auto query_obj = args.find(kQuery)->second.get(); - result = IotconUtils::QueryFromJson(query_obj, &query); - if (!result){ - return result; + const auto& query_it = args.find(kQuery); + if (args.end() != query_it) { + result = IotconUtils::QueryFromJson(query_it->second.get(), &query); + if (!result){ + return result; + } } SCOPE_EXIT { - iotcon_query_destroy(query); + if (query) { + iotcon_query_destroy(query); + } }; iotcon_observe_policy_e observe_policy = IotconUtils::ToObservePolicy( @@ -868,7 +892,7 @@ common::TizenResult IotconInstance::RemoteResourceSetStateChangeListener(const p obj.insert(std::make_pair(kId, picojson::value{static_cast(ptr->id)})); obj.insert(std::make_pair(kData, v)); - Post(kRemoteResourceStateChangeListener, common::TizenSuccess{response}); + Post(kRemoteResourceChangeListener, common::TizenSuccess{response}); }; // set options to the remote resource @@ -900,7 +924,7 @@ common::TizenResult IotconInstance::RemoteResourceSetStateChangeListener(const p return common::TizenSuccess{IotconClientManager::GetInstance().StoreRemoteResource(ptr)}; } -common::TizenResult IotconInstance::RemoteResourceUnsetStateChangeListener(const picojson::object& args) { +common::TizenResult IotconInstance::RemoteResourceStopObserving(const picojson::object& args) { ScopeLogger(); CHECK_PRIVILEGE(kPrivilegeIotcon); @@ -942,8 +966,24 @@ common::TizenResult IotconInstance::RemoteResourceUnsetStateChangeListener(const static void RepresentationChangedCallback(iotcon_remote_resource_h resource, iotcon_representation_h representation, void *user_data) { - LoggerD("Entered"); - //TODO probably should be handled + ScopeLogger(); + FoundRemoteInfo* ptr = static_cast(user_data); + if (nullptr == ptr) { + LoggerE("RepresentationChangeCallback() failed. Ignoring callback"); + return; + } + + if (ptr->cache_change_listener) { + picojson::value json_result = picojson::value(picojson::object()); + + auto result = IotconUtils::RepresentationToJson(representation, &json_result.get()); + if (result) { + ptr->cache_change_listener(common::TizenSuccess(), json_result); + } else { + LoggerE("RepresentationToJson() failed. Ignoring callback"); + return; + } + } } common::TizenResult IotconInstance::RemoteResourceStartCaching(const picojson::object& args) { @@ -956,11 +996,23 @@ common::TizenResult IotconInstance::RemoteResourceStartCaching(const picojson::o if (!result) { LogAndReturnTizenError(result, ("Failed to create remote resource handle")); } + + ptr->cache_change_listener = [this, ptr](const common::TizenResult& res, const picojson::value& v) { + picojson::value response{picojson::object{}}; + auto& obj = response.get(); + + obj.insert(std::make_pair(kId, picojson::value{static_cast(ptr->id)})); + obj.insert(std::make_pair(kData, v)); + + Post(kRemoteResourceCacheChangeListener, common::TizenSuccess{response}); + }; + result = IotconUtils::ConvertIotconError( - iotcon_remote_resource_start_caching(ptr->handle, RepresentationChangedCallback, nullptr)); + iotcon_remote_resource_start_caching(ptr->handle, RepresentationChangedCallback, ptr.get())); if (!result) { return result; } + return common::TizenSuccess{IotconClientManager::GetInstance().StoreRemoteResource(ptr)}; } @@ -974,11 +1026,13 @@ common::TizenResult IotconInstance::RemoteResourceStopCaching(const picojson::ob if (!result) { LogAndReturnTizenError(result, ("Failed to create remote resource handle")); } + result = IotconUtils::ConvertIotconError( iotcon_remote_resource_stop_caching(ptr->handle)); if (!result) { return result; } + ptr->cache_change_listener = nullptr; return common::TizenSuccess{IotconClientManager::GetInstance().RemoveRemoteResource(ptr)}; } @@ -986,43 +1040,50 @@ static void MonitoringCallback(iotcon_remote_resource_h resource, iotcon_remote_resource_state_e state, void *user_data) { ScopeLogger(); FoundRemoteInfo* ptr = static_cast(user_data); - if (ptr->connection_listener) { + if (nullptr == ptr) { + LoggerE("MonitoringCallback() failed. Ignoring callback"); + return; + } + + if (ptr->state_listener) { picojson::value json_result = picojson::value(IOTCON_REMOTE_RESOURCE_ALIVE == state); - ptr->connection_listener(common::TizenSuccess(), json_result); + ptr->state_listener(common::TizenSuccess(), json_result); } else { LoggerD("Post function not present, just ignoring"); } } -common::TizenResult IotconInstance::RemoteResourceSetConnectionChangeListener(const picojson::object& args) { +common::TizenResult IotconInstance::RemoteResourceSetResourceStateChangeListener(const picojson::object& args) { ScopeLogger(); CHECK_PRIVILEGE(kPrivilegeIotcon); + FoundRemoteInfoPtr ptr; auto result = IotconUtils::RemoteResourceFromJson(args, &ptr); if (!result) { LogAndReturnTizenError(result, ("Failed to create remote resource handle")); } - result = IotconUtils::ConvertIotconError( - iotcon_remote_resource_start_monitoring(ptr->handle, MonitoringCallback, ptr.get())); - if (!result) { - return result; - } - ptr->connection_listener = [this, ptr](const common::TizenResult& res, const picojson::value& v) { + + ptr->state_listener = [this, ptr](const common::TizenResult& res, const picojson::value& v) { picojson::value response{picojson::object{}}; auto& obj = response.get(); obj.insert(std::make_pair(kId, picojson::value{static_cast(ptr->id)})); obj.insert(std::make_pair(kData, v)); - Post(kRemoteResourceConnectionChangeListener, common::TizenSuccess{response}); + Post(kRemoteResourceStateChangeListener, common::TizenSuccess{response}); }; + result = IotconUtils::ConvertIotconError( + iotcon_remote_resource_start_monitoring(ptr->handle, MonitoringCallback, ptr.get())); + if (!result) { + return result; + } return common::TizenSuccess{IotconClientManager::GetInstance().StoreRemoteResource(ptr)}; } -common::TizenResult IotconInstance::RemoteResourceUnsetConnectionChangeListener(const picojson::object& args) { +common::TizenResult IotconInstance::RemoteResourceUnsetResourceStateChangeListener(const picojson::object& args) { ScopeLogger(); CHECK_PRIVILEGE(kPrivilegeIotcon); @@ -1036,14 +1097,68 @@ common::TizenResult IotconInstance::RemoteResourceUnsetConnectionChangeListener( if (!result) { return result; } - ptr->connection_listener = nullptr; + ptr->state_listener = nullptr; return common::TizenSuccess{IotconClientManager::GetInstance().RemoveRemoteResource(ptr)}; } +common::TizenResult IotconInstance::RemoteResourceGetTimeInterval(const picojson::object& args) { + ScopeLogger(); + + CHECK_PRIVILEGE(kPrivilegeIotcon); + +/* TODO Uncomment when the interface of the function iotcon_remote_resource_get_time_interval is changed + FoundRemoteInfoPtr ptr; + auto res = IotconUtils::RemoteResourceFromJson(args, &ptr); + if (!res) { + LogAndReturnTizenError(res, ("Failed to build resource using json data")); + } +*/ + int time_interval = 0; + + auto res = IotconUtils::ConvertIotconError(iotcon_remote_resource_get_time_interval(&time_interval)); + if (!res) { + LogAndReturnTizenError(res, ("iotcon_remote_resource_set_time_interval() failed")); + } + + return common::TizenSuccess{picojson::value(static_cast(time_interval))}; +} + +common::TizenResult IotconInstance::RemoteResourceSetTimeInterval(const picojson::object& args) { + ScopeLogger(); + + CHECK_PRIVILEGE(kPrivilegeIotcon); + CHECK_EXIST(args, kTimeInterval); + + int time_interval = static_cast(IotconUtils::GetArg(args, kTimeInterval).get()); + +/* TODO Uncomment when the interface of the function iotcon_remote_resource_set_time_interval is changed + FoundRemoteInfoPtr ptr; + auto res = IotconUtils::RemoteResourceFromJson(args, &ptr); + if (!res) { + LogAndReturnTizenError(res, ("Failed to build resource using json data")); + } +*/ + + auto res = IotconUtils::ConvertIotconError(iotcon_remote_resource_set_time_interval(time_interval)); + if (!res) { + LogAndReturnTizenError(res, ("iotcon_remote_resource_set_time_interval() failed")); + } + + // TODO Uncomment when the interface of the function iotcon_remote_resource_set_time_interval is changed + // return common::TizenSuccess{IotconClientManager::GetInstance().StoreRemoteResource(ptr)}; + + return common::TizenSuccess{}; +} + bool IotconInstance::ResourceFoundCallback(iotcon_remote_resource_h resource, iotcon_error_e result, void *user_data) { ScopeLogger(); CallbackData* data = static_cast(user_data); + if (nullptr == data) { + LoggerE("ResourceFoundCallback() failed. Ignoring callback"); + return IOTCON_FUNC_STOP; + } + auto ret = IotconUtils::ConvertIotconError(result); if (!ret) { data->fun(ret, picojson::value{}); @@ -1059,7 +1174,7 @@ bool IotconInstance::ResourceFoundCallback(iotcon_remote_resource_h resource, } data->fun(ret, json_result); - return IOTCON_FUNC_STOP; + return IOTCON_FUNC_CONTINUE; } common::TizenResult IotconInstance::ClientFindResource(const picojson::object& args) { @@ -1071,19 +1186,28 @@ common::TizenResult IotconInstance::ClientFindResource(const picojson::object& a char* host_address = nullptr; if (args.find(kHostAddress)->second.is()) { host_address = const_cast(args.find(kHostAddress)->second.get().c_str()); + } else { + host_address = IOTCON_MULTICAST_ADDRESS; } - CHECK_EXIST(args, kResourceType); - char* resource_type = nullptr; - if (args.find(kResourceType)->second.is()) { - resource_type = const_cast(args.find(kResourceType)->second.get().c_str()); + CHECK_EXIST(args, kQuery); + iotcon_query_h query = nullptr; + const auto& query_obj = args.find(kQuery)->second; + if (query_obj.is()) { + auto result = IotconUtils::QueryFromJson(query_obj.get(), &query); + if (!result) { + LogAndReturnTizenError(result, ("QueryFromJson() failed")); + } } + SCOPE_EXIT { + if (query) { + iotcon_query_destroy(query); + } + }; CHECK_EXIST(args, kConnectivityType); iotcon_connectivity_type_e connectivity_type = IotconUtils::ToConnectivityType( args.find(kConnectivityType)->second.get()); - CHECK_EXIST(args, kIsSecure); - bool is_secure = args.find(kIsSecure)->second.get(); long long id = GetId(args); auto response = [this, id](const common::TizenResult& res, const picojson::value& v) { @@ -1101,11 +1225,11 @@ common::TizenResult IotconInstance::ClientFindResource(const picojson::object& a }; CallbackData* data = new CallbackData{response}; - LoggerD("Running find with:\nhost_address: %s,\nconnectivity_type: %d,\nresource_type: %s,\nis_secure: %d", - host_address, connectivity_type, resource_type, is_secure); + LoggerD("Running find with:\nhost_address: %s,\nconnectivity_type: %d", + host_address, connectivity_type); auto result = IotconUtils::ConvertIotconError( - iotcon_find_resource(host_address, connectivity_type, resource_type, - is_secure, ResourceFoundCallback, data)); + iotcon_find_resource(host_address, connectivity_type, query, + ResourceFoundCallback, data)); if (!result) { delete data; LogAndReturnTizenError(result); @@ -1197,6 +1321,11 @@ bool IotconDeviceInfoCb(iotcon_device_info_h device_info, ScopeLogger(); CallbackData* data = static_cast(user_data); + if (nullptr == data) { + LoggerE("IotconDeviceInfoCb() failed. Ignoring callback"); + return IOTCON_FUNC_STOP; + } + picojson::value v{picojson::object{}}; common::TizenResult ret = common::TizenSuccess(); @@ -1209,27 +1338,46 @@ bool IotconDeviceInfoCb(iotcon_device_info_h device_info, data->fun(ret, v); delete data; - return IOTCON_FUNC_STOP; + return IOTCON_FUNC_CONTINUE; } -common::TizenResult IotconInstance::ClientGetDeviceInfo(const picojson::object& args, - const common::AsyncToken& token) { +common::TizenResult IotconInstance::ClientFindDeviceInfo(const picojson::object& args, + const common::AsyncToken& token) { ScopeLogger(); CHECK_PRIVILEGE(kPrivilegeIotcon); CHECK_EXIST(args, kHostAddress); - CHECK_EXIST(args, kConnectivityType); + char* host_address = nullptr; + if (args.find(kHostAddress)->second.is()) { + host_address = const_cast(args.find(kHostAddress)->second.get().c_str()); + } else { + host_address = IOTCON_MULTICAST_ADDRESS; + } - std::string host = args.find(kHostAddress)->second.get(); + CHECK_EXIST(args, kQuery); + iotcon_query_h query = nullptr; + const auto& query_obj = args.find(kQuery)->second; + if (query_obj.is()) { + auto result = IotconUtils::QueryFromJson(query_obj.get(), &query); + if (!result) { + LogAndReturnTizenError(result, ("QueryFromJson() failed")); + } + } + SCOPE_EXIT { + if (query) { + iotcon_query_destroy(query); + } + }; + + CHECK_EXIST(args, kConnectivityType); std::string con_type = args.find(kConnectivityType)->second.get(); iotcon_connectivity_type_e con_type_e = IotconUtils::ToConnectivityType(con_type); CallbackData* data = new CallbackData{SimplePost(token)}; auto result = IotconUtils::ConvertIotconError( - iotcon_find_device_info(host.c_str(), con_type_e, IotconDeviceInfoCb, - data)); + iotcon_find_device_info(host_address, con_type_e, query, IotconDeviceInfoCb, data)); if (!result) { delete data; @@ -1244,6 +1392,11 @@ bool IotconPlatformInfoCb(iotcon_platform_info_h platform_info, ScopeLogger(); CallbackData* data = static_cast(user_data); + if (nullptr == data) { + LoggerE("IotconPlatformInfoCb() failed. Ignoring callback"); + return IOTCON_FUNC_STOP; + } + picojson::value v{picojson::object{}}; common::TizenResult ret = common::TizenSuccess(); @@ -1256,27 +1409,46 @@ bool IotconPlatformInfoCb(iotcon_platform_info_h platform_info, data->fun(ret, v); delete data; - return IOTCON_FUNC_STOP; + return IOTCON_FUNC_CONTINUE; } -common::TizenResult IotconInstance::ClientGetPlatformInfo(const picojson::object& args, - const common::AsyncToken& token) { +common::TizenResult IotconInstance::ClientFindPlatformInfo(const picojson::object& args, + const common::AsyncToken& token) { ScopeLogger(); CHECK_PRIVILEGE(kPrivilegeIotcon); CHECK_EXIST(args, kHostAddress); - CHECK_EXIST(args, kConnectivityType); + char* host_address = nullptr; + if (args.find(kHostAddress)->second.is()) { + host_address = const_cast(args.find(kHostAddress)->second.get().c_str()); + } else { + host_address = IOTCON_MULTICAST_ADDRESS; + } - std::string host = args.find(kHostAddress)->second.get(); + CHECK_EXIST(args, kQuery); + iotcon_query_h query = nullptr; + const auto& query_obj = args.find(kQuery)->second; + if (query_obj.is()) { + auto result = IotconUtils::QueryFromJson(query_obj.get(), &query); + if (!result) { + LogAndReturnTizenError(result, ("QueryFromJson() failed")); + } + } + SCOPE_EXIT { + if (query) { + iotcon_query_destroy(query); + } + }; + + CHECK_EXIST(args, kConnectivityType); std::string con_type = args.find(kConnectivityType)->second.get(); iotcon_connectivity_type_e con_type_e = IotconUtils::ToConnectivityType(con_type); CallbackData* data = new CallbackData{SimplePost(token)}; auto result = IotconUtils::ConvertIotconError( - iotcon_find_platform_info(host.c_str(), con_type_e, IotconPlatformInfoCb, - data)); + iotcon_find_platform_info(host_address, con_type_e, query, IotconPlatformInfoCb, data)); if (!result) { delete data; @@ -1292,15 +1464,17 @@ common::TizenResult IotconInstance::ServerCreateResource(const picojson::object& CHECK_PRIVILEGE(kPrivilegeIotcon); CHECK_EXIST(args, kUriPath); + CHECK_EXIST(args, kResourceTypes); + CHECK_EXIST(args, kResourceInterfaces); const std::string& uri_path = args.find(kUriPath)->second.get(); - const auto& interfaces = IotconUtils::GetArg(args, kResourceInterfaces); - const auto& resource_interfaces = interfaces.is() ? interfaces.get() : picojson::array(); - const auto& types = IotconUtils::GetArg(args, kResourceTypes); const auto& resource_types = types.is() ? types.get() : picojson::array(); + const auto& interfaces = IotconUtils::GetArg(args, kResourceInterfaces); + const auto& resource_interfaces = interfaces.is() ? interfaces.get() : picojson::array(); + int properties = IotconUtils::GetProperties(args); ResourceInfoPtr resource{new ResourceInfo()}; @@ -1331,6 +1505,97 @@ common::TizenResult IotconInstance::ServerRemoveResource(const picojson::object& return IotconServerManager::GetInstance().DestroyResource(GetId(args)); } +common::TizenResult IotconInstance::ServerStartPresence(const picojson::object& args) { + ScopeLogger(); + + CHECK_PRIVILEGE(kPrivilegeIotcon); + CHECK_EXIST(args, kTimeToLive); + + if (!initialized_) { + return LogAndCreateTizenError(AbortError, "Iotcon service not initialized"); + } + + if (presence_started_) { + LoggerD("Iotcon service presence has been already started"); + return common::TizenSuccess(); + } + + unsigned int timeToLive = static_cast(IotconUtils::GetArg(args, kTimeToLive).get()); + + auto result = IotconUtils::ConvertIotconError(iotcon_start_presence(timeToLive)); + if (!result) { + LogAndReturnTizenError(result); + } + + presence_started_ = true; + LoggerD("Iotcon service presence started"); + + return result; +} + +common::TizenResult IotconInstance::ServerStopPresence(const picojson::object& args) { + ScopeLogger(); + + CHECK_PRIVILEGE(kPrivilegeIotcon); + + if (!presence_started_) { + LoggerD("Iotcon service presence not started before"); + return common::TizenSuccess(); + } + + auto result = IotconUtils::ConvertIotconError(iotcon_stop_presence()); + if (!result) { + LogAndReturnTizenError(result); + } + + presence_started_ = false; + LoggerD("Iotcon service presence stopped"); + + return result; +} + +common::TizenResult IotconInstance::ServerSetDeviceName(const picojson::object& args) { + ScopeLogger(); + + CHECK_PRIVILEGE(kPrivilegeIotcon); + CHECK_EXIST(args, kDeviceName); + + if (!initialized_) { + return LogAndCreateTizenError(AbortError, "Iotcon service not initialized"); + } + + const std::string& name = IotconUtils::GetArg(args, kDeviceName).get(); + + auto result = IotconUtils::ConvertIotconError(iotcon_set_device_name(name.c_str())); + if (!result) { + LogAndReturnTizenError(result); + } + + LoggerD("Iotcon service device name set"); + + return result; +} + +common::TizenResult IotconInstance::Initialize(const picojson::object& args) { + ScopeLogger(); + + CHECK_PRIVILEGE(kPrivilegeIotcon); + + CHECK_EXIST(args, kFilePath); + const auto& filePath = IotconUtils::GetArg(args, kFilePath); + + auto result = IotconUtils::ConvertIotconError( + iotcon_initialize(filePath.get().c_str())); + if (!result) { + LogAndReturnTizenError(result); + } + + initialized_ = true; + LoggerD("Iotcon service initialized"); + + return result; +} + common::TizenResult IotconInstance::GetTimeout(const picojson::object& args) { ScopeLogger(); diff --git a/src/iotcon/iotcon_instance.h b/src/iotcon/iotcon_instance.h index 48340edf..7e2070c0 100644 --- a/src/iotcon/iotcon_instance.h +++ b/src/iotcon/iotcon_instance.h @@ -55,25 +55,35 @@ class IotconInstance : public common::TizenInstance { const common::AsyncToken& token); common::TizenResult RemoteResourceMethodDelete(const picojson::object& args, const common::AsyncToken& token); - common::TizenResult RemoteResourceSetStateChangeListener(const picojson::object& args); - common::TizenResult RemoteResourceUnsetStateChangeListener(const picojson::object& args); + common::TizenResult RemoteResourceStartObserving(const picojson::object& args); + common::TizenResult RemoteResourceStopObserving(const picojson::object& args); common::TizenResult RemoteResourceStartCaching(const picojson::object& args); common::TizenResult RemoteResourceStopCaching(const picojson::object& args); - common::TizenResult RemoteResourceSetConnectionChangeListener(const picojson::object& args); - common::TizenResult RemoteResourceUnsetConnectionChangeListener(const picojson::object& args); + common::TizenResult RemoteResourceSetResourceStateChangeListener(const picojson::object& args); + common::TizenResult RemoteResourceUnsetResourceStateChangeListener(const picojson::object& args); + common::TizenResult RemoteResourceGetTimeInterval(const picojson::object& args); + common::TizenResult RemoteResourceSetTimeInterval(const picojson::object& args); common::TizenResult ClientFindResource(const picojson::object& args); common::TizenResult ClientAddPresenceEventListener(const picojson::object& args); common::TizenResult ClientRemovePresenceEventListener(const picojson::object& args); - common::TizenResult ClientGetDeviceInfo(const picojson::object& args, - const common::AsyncToken& token); - common::TizenResult ClientGetPlatformInfo(const picojson::object& args, - const common::AsyncToken& token); + common::TizenResult ClientFindDeviceInfo(const picojson::object& args, + const common::AsyncToken& token); + common::TizenResult ClientFindPlatformInfo(const picojson::object& args, + const common::AsyncToken& token); common::TizenResult ServerCreateResource(const picojson::object& args); common::TizenResult ServerRemoveResource(const picojson::object& args); + common::TizenResult ServerStartPresence(const picojson::object& args); + common::TizenResult ServerStopPresence(const picojson::object& args); + common::TizenResult ServerSetDeviceName(const picojson::object& args); + common::TizenResult Initialize(const picojson::object& args); common::TizenResult GetTimeout(const picojson::object& args); common::TizenResult SetTimeout(const picojson::object& args); common::PostCallback PostForMethodCall(const common::AsyncToken& token, const FoundRemoteInfoPtr& resource); + + private: + bool initialized_; + bool presence_started_; }; } // namespace iotcon diff --git a/src/iotcon/iotcon_server_manager.cc b/src/iotcon/iotcon_server_manager.cc index 277e52ec..be41a71a 100644 --- a/src/iotcon/iotcon_server_manager.cc +++ b/src/iotcon/iotcon_server_manager.cc @@ -55,8 +55,8 @@ void IotconServerManager::RequestHandler(iotcon_resource_h resource, } // handle observer changes - iotcon_observe_type_e type = IOTCON_OBSERVE_NO_TYPE; - result = IotconUtils::ConvertIotconError(iotcon_request_get_observe_type(request, &type)); + iotcon_observe_type_e observe_type = IOTCON_OBSERVE_NO_TYPE; + result = IotconUtils::ConvertIotconError(iotcon_request_get_observe_type(request, &observe_type)); if (!result) { LoggerE("iotcon_request_get_observe_type() failed"); @@ -71,7 +71,7 @@ void IotconServerManager::RequestHandler(iotcon_resource_h resource, return; } - switch (type) { + switch (observe_type) { case IOTCON_OBSERVE_NO_TYPE: LoggerD("observer did not change"); break; @@ -92,13 +92,29 @@ void IotconServerManager::RequestHandler(iotcon_resource_h resource, picojson::value value{picojson::object{}}; auto& obj = value.get(); - result = IotconUtils::RequestToJson(request, &obj); - + iotcon_request_type_e request_type = IOTCON_REQUEST_UNKNOWN; + auto result = IotconUtils::ConvertIotconError(iotcon_request_get_request_type(request, &request_type)); + if (!result) { + LoggerE("iotcon_request_get_request_type() failed"); + return; + } + picojson::value request_type_val{IotconUtils::FromRequestType(request_type)}; + obj.insert(std::make_pair(kRequestType, request_type_val)); + picojson::value observe_type_val{IotconUtils::FromObserveType(observe_type)}; + obj.insert(std::make_pair(kObserveType, observe_type_val)); + picojson::value observe_id_val{static_cast(observer_id)}; + obj.insert(std::make_pair(kObserverId, observe_id_val)); + + picojson::value request_val{picojson::object{}}; + auto& request_obj = request_val.get(); + result = IotconUtils::RequestToJson(request, &request_obj); if (!result) { LoggerE("RequestToJson() failed"); return; } + obj.insert(std::make_pair(kRequest, request_val)); + // create response iotcon_response_h response = nullptr; result = IotconUtils::ConvertIotconError(iotcon_response_create(request, &response)); diff --git a/src/iotcon/iotcon_utils.cc b/src/iotcon/iotcon_utils.cc index 15fc29f6..89e425c4 100644 --- a/src/iotcon/iotcon_utils.cc +++ b/src/iotcon/iotcon_utils.cc @@ -71,6 +71,7 @@ namespace { X(IOTCON_RESPONSE_ERROR, "ERROR") \ X(IOTCON_RESPONSE_RESOURCE_CREATED, "RESOURCE_CREATED") \ X(IOTCON_RESPONSE_RESOURCE_DELETED, "RESOURCE_DELETED") \ + X(IOTCON_RESPONSE_RESOURCE_CHANGED, "RESOURCE_CHANGED") \ X(IOTCON_RESPONSE_SLOW, "SLOW") \ X(IOTCON_RESPONSE_FORBIDDEN, "FORBIDDEN") \ XD(IOTCON_RESPONSE_ERROR, "unknown") @@ -92,17 +93,19 @@ const std::string kResourceTypes = "resourceTypes"; const std::string kResourceInterfaces = "resourceInterfaces"; const std::string kResourceChildren = "resources"; const std::string kUriPath = "uriPath"; -const std::string kStates = "states"; +const std::string kAttributes = "attributes"; const std::string kId = "id"; const std::string kKeepId = "keepId"; const std::string kDeviceId = "deviceId"; +const std::string kDeviceName = "deviceName"; const std::string kHostAddress = "hostAddress"; const std::string kConnectivityType = "connectivityType"; const std::string kObservePolicy = "observePolicy"; const std::string kRepresentation = "representation"; -const std::string kRepresentations = "representations"; +const std::string kChildren = "children"; const std::string kRequestType = "type"; +const std::string kRequest = "request"; const std::string kOptions = "options"; const std::string kQuery = "query"; const std::string kObserverId = "observerId"; @@ -129,7 +132,6 @@ const std::string kFirmwareVersion = "firmwareVersion"; const std::string kSupportUrl = "supportUrl"; const std::string kSystemTime = "systemTime"; -const std::string kDeviceName = "deviceName"; const std::string kSpecVersion = "specVersion"; const std::string kOicDeviceId = "oicDeviceId"; const std::string kDataModelVersion = "dataModelVersion"; @@ -139,6 +141,8 @@ const std::string kTriggerType = "triggerType"; const std::string kResult = "result"; +const int defRemoteResTimeInterval = 10; + using common::TizenResult; using common::TizenSuccess; @@ -377,7 +381,13 @@ TizenResult IotconUtils::ExtractFromRemoteResource(RemoteResourceInfo* resource) result = ConvertIotconError( iotcon_remote_resource_get_device_id(resource->resource, &resource->device_id)); if (!result) { - LogAndReturnTizenError(result, ("Gathering host address failed")); + LogAndReturnTizenError(result, ("Gathering device id failed")); + } + + result = ConvertIotconError( + iotcon_remote_resource_get_device_name(resource->resource, &resource->device_name)); + if (!result) { + LogAndReturnTizenError(result, ("Gathering device name failed")); } result = ConvertIotconError( @@ -430,6 +440,7 @@ TizenResult IotconUtils::RemoteResourceToJson(iotcon_remote_resource_h handle, FromConnectivityType(remote_res.connectivity_type)))); res->insert(std::make_pair(kHostAddress, picojson::value(remote_res.host_address))); res->insert(std::make_pair(kDeviceId, picojson::value(remote_res.device_id))); + res->insert(std::make_pair(kDeviceName, picojson::value(remote_res.device_name))); if (remote_res.types) { picojson::array types; @@ -594,16 +605,6 @@ common::TizenResult IotconUtils::RequestToJson(iotcon_request_h request, } } - { - // requestType - iotcon_request_type_e request_type = IOTCON_REQUEST_UNKNOWN; - auto result = ConvertIotconError(iotcon_request_get_request_type(request, &request_type)); - if (!result) { - LogAndReturnTizenError(result, ("iotcon_request_get_request_type() failed")); - } - out->insert(std::make_pair(kRequestType, picojson::value{FromRequestType(request_type)})); - } - { // options iotcon_options_h options = nullptr; @@ -633,26 +634,6 @@ common::TizenResult IotconUtils::RequestToJson(iotcon_request_h request, } out->insert(std::make_pair(kQuery, v)); } - - { - // observerId - int observer_id = -1; - auto result = ConvertIotconError(iotcon_request_get_observe_id(request, &observer_id)); - if (!result) { - LogAndReturnTizenError(result, ("iotcon_request_get_observe_id() failed")); - } - out->insert(std::make_pair(kObserverId, picojson::value{static_cast(observer_id)})); - } - - { - // observeType - iotcon_observe_type_e observe_type = IOTCON_OBSERVE_NO_TYPE; - auto result = ConvertIotconError(iotcon_request_get_observe_type(request, &observe_type)); - if (!result) { - LogAndReturnTizenError(result, ("iotcon_request_get_observe_type() failed")); - } - out->insert(std::make_pair(kObserveType, picojson::value{FromObserveType(observe_type)})); - } } else { LoggerW("Request handle is null, ignoring"); } @@ -702,7 +683,7 @@ common::TizenResult IotconUtils::RepresentationToJson(iotcon_representation_h re } { - // states + // attributes iotcon_attributes_h attributes = nullptr; auto result = ConvertIotconError(iotcon_representation_get_attributes(representation, &attributes)); if (!result) { @@ -713,11 +694,11 @@ common::TizenResult IotconUtils::RepresentationToJson(iotcon_representation_h re if (!result) { LogAndReturnTizenError(result, ("AttributesToJson() failed")); } - out->insert(std::make_pair(kStates, v)); + out->insert(std::make_pair(kAttributes, v)); } { - // representations + // children picojson::value v{picojson::array{}}; auto result = ConvertIotconError(iotcon_representation_foreach_children(representation, [](iotcon_representation_h child, void* user_data) -> bool { auto arr = static_cast(user_data); @@ -732,7 +713,7 @@ common::TizenResult IotconUtils::RepresentationToJson(iotcon_representation_h re if (!result) { LogAndReturnTizenError(result, ("iotcon_representation_foreach_children() failed")); } - out->insert(std::make_pair(kRepresentations, v)); + out->insert(std::make_pair(kChildren, v)); } } else { LoggerW("Representation handle is null, ignoring"); @@ -1738,7 +1719,7 @@ common::TizenResult IotconUtils::RepresentationFromJson(const picojson::object& } { - const auto& states = r.find(kStates); + const auto& states = r.find(kAttributes); if (r.end() != states && states->second.is()) { iotcon_attributes_h s = nullptr; @@ -1758,9 +1739,9 @@ common::TizenResult IotconUtils::RepresentationFromJson(const picojson::object& } { - const auto& representations = r.find(kRepresentations); - if (r.end() != representations && representations->second.is()) { - for (const auto& js_child : representations->second.get()) { + const auto& children = r.find(kChildren); + if (r.end() != children && children->second.is()) { + for (const auto& js_child : children->second.get()) { if (js_child.is()) { iotcon_representation_h child = nullptr; @@ -1777,7 +1758,7 @@ common::TizenResult IotconUtils::RepresentationFromJson(const picojson::object& LogAndReturnTizenError(result, ("iotcon_representation_add_child() failed")); } } else { - return LogAndCreateTizenError(TypeMismatchError, "The Representation.representations attribute needs to be an array of Representation objects."); + return LogAndCreateTizenError(TypeMismatchError, "The Representation.children attribute needs to be an array of Representation objects."); } } } diff --git a/src/iotcon/iotcon_utils.h b/src/iotcon/iotcon_utils.h index f9464191..e6a1505d 100644 --- a/src/iotcon/iotcon_utils.h +++ b/src/iotcon/iotcon_utils.h @@ -49,10 +49,11 @@ extern const std::string kResourceType; extern const std::string kResourceInterfaces; extern const std::string kResourceChildren; extern const std::string kUriPath; -extern const std::string kStates; +extern const std::string kAttributes; extern const std::string kId; extern const std::string kKeepId; extern const std::string kDeviceId; +extern const std::string kDeviceName; extern const std::string kHostAddress; extern const std::string kConnectivityType; extern const std::string kResourceType; @@ -60,6 +61,12 @@ extern const std::string kRepresentation; extern const std::string kOptions; extern const std::string kQuery; extern const std::string kObservePolicy; +extern const std::string kRequestType; +extern const std::string kRequest; +extern const std::string kObserveType; +extern const std::string kObserverId; + +extern const int defRemoteResTimeInterval; class ResourceInfo; class PresenceEvent; @@ -96,6 +103,7 @@ struct RemoteResourceInfo { iotcon_connectivity_type_e connectivity_type; char* host_address; char* device_id; + char* device_name; iotcon_resource_types_h types; iotcon_resource_interfaces_h ifaces; uint8_t properties; // to check if observable @@ -104,7 +112,7 @@ struct RemoteResourceInfo { RemoteResourceInfo() : resource(nullptr), uri_path(nullptr), connectivity_type(IOTCON_CONNECTIVITY_ALL), host_address(nullptr), - device_id(nullptr), types(nullptr), ifaces(0), + device_id(nullptr), device_name(nullptr), types(nullptr), ifaces(0), properties(0), options(nullptr), representation(nullptr) {} ~RemoteResourceInfo() { //according to native description, must not release any handles @@ -116,8 +124,9 @@ struct FoundRemoteInfo { iotcon_remote_resource_h handle; short ref_count; // counter for registered listeners for this handle //TODO add listeners for each type - common::PostCallback connection_listener; + common::PostCallback state_listener; common::PostCallback observe_listener; + common::PostCallback cache_change_listener; FoundRemoteInfo() : id(0), handle(nullptr), ref_count(1) {} //initialize with 1 (struct is created, so it //mean that some listener would be created) -- 2.34.1