var types = validator.Types;
var T = xwalk.utils.type;
var kIdKey = Symbol();
+var converter = xwalk.converter;
function createListener(name, c) {
var listenerName = name;
ERROR: 'ERROR',
RESOURCE_CREATED: 'RESOURCE_CREATED',
RESOURCE_DELETED: 'RESOURCE_DELETED',
+ RESOURCE_CHANGED: 'RESOURCE_CHANGED',
SLOW: 'SLOW',
FORBIDDEN: 'FORBIDDEN',
};
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);
}
writable: true,
enumerable: true
},
- states: {
+ attributes: {
value: null,
writable: true,
enumerable: true
},
- representations: {
+ children: {
value: null,
writable: true,
enumerable: true
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]]) {
}
}
- 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]));
}
}
var internal = new InternalData(data);
internal.decorate(this);
- this.states = null;
+ this.attributes = null;
}
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);
}
};
-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);
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];
}
};
-
function Response(request) {
validator.isConstructorCall(this, tizen.Response);
}
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);
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
}
});
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,
optional: true,
}]);
var callArgs = prepareResourceInfo(this);
- callArgs.query = args.query;
+ if (args.query) {
+ callArgs.query = args.query;
+ }
var callback = function(result) {
result = native.getResultObject(result);
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,
optional: true,
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);
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,
optional: true,
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);
}
};
-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) {
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);
}
};
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
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]);
}
};
type: types.STRING,
nullable: true
}, {
- name: 'resourceType',
- type: types.STRING,
+ name: 'query',
+ type: types.DICTIONARY,
nullable: true
}, {
name: 'connectivityType',
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)) {
}
};
-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,
}]);
var callArgs = {};
+
callArgs.hostAddress = args.hostAddress;
+ callArgs.query = args.query;
callArgs.connectivityType = args.connectivityType;
var callback = function(result) {
}
};
- 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,
var callArgs = {};
callArgs.hostAddress = args.hostAddress;
+ callArgs.query = args.query;
callArgs.connectivityType = args.connectivityType;
var callback = function(result) {
}
};
- var result = native.call('IotconClient_getPlatformInfo', callArgs, callback);
+ var result = native.call('IotconClient_findPlatformInfo', callArgs, callback);
if (native.isFailure(result)) {
throw native.getErrorObject(result);
};
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 = {};
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;
} else {
var resource = new Resource(native.getResultObject(result));
serverResources[resource[kIdKey]] = resource;
+
+ _setRequestListener(resource[kIdKey], args.listener);
+
return resource;
}
};
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;
};
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;
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";
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;
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
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) {
CHECK_EXIST(args, kId);
CHECK_EXIST(args, kQos);
- CHECK_EXIST(args, kStates);
+ CHECK_EXIST(args, kAttributes);
ResourceInfoPtr resource;
long long id = GetId(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"));
}
}
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<picojson::object>();
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);
CHECK_PRIVILEGE(kPrivilegeIotcon);
- CHECK_EXIST(args, kQuery);
-
FoundRemoteInfoPtr resource;
auto result = IotconUtils::RemoteResourceFromJson(args, &resource);
if (!result) {
}
iotcon_query_h query = nullptr;
- result = IotconUtils::QueryFromJson(IotconUtils::GetArg(args, kQuery).get<picojson::object>(), &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<picojson::object>(), &query);
+ if (!result) {
+ LogAndReturnTizenError(result, ("QueryFromJson() failed"));
+ }
}
SCOPE_EXIT {
- iotcon_query_destroy(query);
+ if (query) {
+ iotcon_query_destroy(query);
+ }
};
std::unique_ptr<CallbackData> data{new CallbackData{PostForMethodCall(token, resource)}};
CHECK_PRIVILEGE(kPrivilegeIotcon);
CHECK_EXIST(args, kRepresentation);
- CHECK_EXIST(args, kQuery);
FoundRemoteInfoPtr resource;
auto result = IotconUtils::RemoteResourceFromJson(args, &resource);
};
iotcon_query_h query = nullptr;
- result = IotconUtils::QueryFromJson(IotconUtils::GetArg(args, kQuery).get<picojson::object>(), &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<picojson::object>(), &query);
+ if (!result) {
+ LogAndReturnTizenError(result, ("QueryFromJson() failed"));
+ }
}
SCOPE_EXIT {
- iotcon_query_destroy(query);
+ if (query) {
+ iotcon_query_destroy(query);
+ }
};
std::unique_ptr<CallbackData> data{new CallbackData{PostForMethodCall(token, resource)}};
CHECK_PRIVILEGE(kPrivilegeIotcon);
CHECK_EXIST(args, kRepresentation);
- CHECK_EXIST(args, kQuery);
FoundRemoteInfoPtr resource;
auto result = IotconUtils::RemoteResourceFromJson(args, &resource);
};
iotcon_query_h query = nullptr;
- result = IotconUtils::QueryFromJson(IotconUtils::GetArg(args, kQuery).get<picojson::object>(), &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<picojson::object>(), &query);
+ if (!result) {
+ LogAndReturnTizenError(result, ("QueryFromJson() failed"));
+ }
}
SCOPE_EXIT {
- iotcon_query_destroy(query);
+ if (query) {
+ iotcon_query_destroy(query);
+ }
};
std::unique_ptr<CallbackData> data{new CallbackData{PostForMethodCall(token, resource)}};
int sequence_number, iotcon_response_h response, void *user_data) {
ScopeLogger();
FoundRemoteInfo* ptr = static_cast<FoundRemoteInfo*>(user_data);
+ if (nullptr == ptr) {
+ LoggerE("ObserveCallback() failed. Ignoring callback");
+ return;
+ }
+
if (ptr->observe_listener) {
picojson::value json_result = picojson::value(picojson::object());
}
}
-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);
}
iotcon_query_h query = nullptr;
- auto query_obj = args.find(kQuery)->second.get<picojson::object>();
- 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<picojson::object>(), &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(
obj.insert(std::make_pair(kId, picojson::value{static_cast<double>(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
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);
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<FoundRemoteInfo*>(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<picojson::object>());
+ 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) {
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<picojson::object>();
+
+ obj.insert(std::make_pair(kId, picojson::value{static_cast<double>(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)};
}
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)};
}
iotcon_remote_resource_state_e state, void *user_data) {
ScopeLogger();
FoundRemoteInfo* ptr = static_cast<FoundRemoteInfo*>(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<picojson::object>();
obj.insert(std::make_pair(kId, picojson::value{static_cast<double>(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);
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<double>(time_interval))};
+}
+
+common::TizenResult IotconInstance::RemoteResourceSetTimeInterval(const picojson::object& args) {
+ ScopeLogger();
+
+ CHECK_PRIVILEGE(kPrivilegeIotcon);
+ CHECK_EXIST(args, kTimeInterval);
+
+ int time_interval = static_cast<int>(IotconUtils::GetArg(args, kTimeInterval).get<double>());
+
+/* 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<CallbackData*>(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{});
}
data->fun(ret, json_result);
- return IOTCON_FUNC_STOP;
+ return IOTCON_FUNC_CONTINUE;
}
common::TizenResult IotconInstance::ClientFindResource(const picojson::object& args) {
char* host_address = nullptr;
if (args.find(kHostAddress)->second.is<std::string>()) {
host_address = const_cast<char*>(args.find(kHostAddress)->second.get<std::string>().c_str());
+ } else {
+ host_address = IOTCON_MULTICAST_ADDRESS;
}
- CHECK_EXIST(args, kResourceType);
- char* resource_type = nullptr;
- if (args.find(kResourceType)->second.is<std::string>()) {
- resource_type = const_cast<char*>(args.find(kResourceType)->second.get<std::string>().c_str());
+ CHECK_EXIST(args, kQuery);
+ iotcon_query_h query = nullptr;
+ const auto& query_obj = args.find(kQuery)->second;
+ if (query_obj.is<picojson::object>()) {
+ auto result = IotconUtils::QueryFromJson(query_obj.get<picojson::object>(), &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<std::string>());
- CHECK_EXIST(args, kIsSecure);
- bool is_secure = args.find(kIsSecure)->second.get<bool>();
long long id = GetId(args);
auto response = [this, id](const common::TizenResult& res, const picojson::value& v) {
};
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);
ScopeLogger();
CallbackData* data = static_cast<CallbackData*>(user_data);
+ if (nullptr == data) {
+ LoggerE("IotconDeviceInfoCb() failed. Ignoring callback");
+ return IOTCON_FUNC_STOP;
+ }
+
picojson::value v{picojson::object{}};
common::TizenResult ret = common::TizenSuccess();
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<std::string>()) {
+ host_address = const_cast<char*>(args.find(kHostAddress)->second.get<std::string>().c_str());
+ } else {
+ host_address = IOTCON_MULTICAST_ADDRESS;
+ }
- std::string host = args.find(kHostAddress)->second.get<std::string>();
+ CHECK_EXIST(args, kQuery);
+ iotcon_query_h query = nullptr;
+ const auto& query_obj = args.find(kQuery)->second;
+ if (query_obj.is<picojson::object>()) {
+ auto result = IotconUtils::QueryFromJson(query_obj.get<picojson::object>(), &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<std::string>();
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;
ScopeLogger();
CallbackData* data = static_cast<CallbackData*>(user_data);
+ if (nullptr == data) {
+ LoggerE("IotconPlatformInfoCb() failed. Ignoring callback");
+ return IOTCON_FUNC_STOP;
+ }
+
picojson::value v{picojson::object{}};
common::TizenResult ret = common::TizenSuccess();
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<std::string>()) {
+ host_address = const_cast<char*>(args.find(kHostAddress)->second.get<std::string>().c_str());
+ } else {
+ host_address = IOTCON_MULTICAST_ADDRESS;
+ }
- std::string host = args.find(kHostAddress)->second.get<std::string>();
+ CHECK_EXIST(args, kQuery);
+ iotcon_query_h query = nullptr;
+ const auto& query_obj = args.find(kQuery)->second;
+ if (query_obj.is<picojson::object>()) {
+ auto result = IotconUtils::QueryFromJson(query_obj.get<picojson::object>(), &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<std::string>();
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;
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<std::string>();
- const auto& interfaces = IotconUtils::GetArg(args, kResourceInterfaces);
- const auto& resource_interfaces = interfaces.is<picojson::array>() ? interfaces.get<picojson::array>() : picojson::array();
-
const auto& types = IotconUtils::GetArg(args, kResourceTypes);
const auto& resource_types = types.is<picojson::array>() ? types.get<picojson::array>() : picojson::array();
+ const auto& interfaces = IotconUtils::GetArg(args, kResourceInterfaces);
+ const auto& resource_interfaces = interfaces.is<picojson::array>() ? interfaces.get<picojson::array>() : picojson::array();
+
int properties = IotconUtils::GetProperties(args);
ResourceInfoPtr resource{new ResourceInfo()};
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<unsigned int>(IotconUtils::GetArg(args, kTimeToLive).get<double>());
+
+ 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<std::string>();
+
+ 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<std::string>().c_str()));
+ if (!result) {
+ LogAndReturnTizenError(result);
+ }
+
+ initialized_ = true;
+ LoggerD("Iotcon service initialized");
+
+ return result;
+}
+
common::TizenResult IotconInstance::GetTimeout(const picojson::object& args) {
ScopeLogger();
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
}
// 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");
return;
}
- switch (type) {
+ switch (observe_type) {
case IOTCON_OBSERVE_NO_TYPE:
LoggerD("observer did not change");
break;
picojson::value value{picojson::object{}};
auto& obj = value.get<picojson::object>();
- 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<double>(observer_id)};
+ obj.insert(std::make_pair(kObserverId, observe_id_val));
+
+ picojson::value request_val{picojson::object{}};
+ auto& request_obj = request_val.get<picojson::object>();
+ 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));
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")
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";
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";
const std::string kResult = "result";
+const int defRemoteResTimeInterval = 10;
+
using common::TizenResult;
using common::TizenSuccess;
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(
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;
}
{
- // 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;
auto result = ConvertIotconError(iotcon_request_get_options(request, &options));
}
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<double>(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");
}
}
{
- // states
+ // attributes
iotcon_attributes_h attributes = nullptr;
auto result = ConvertIotconError(iotcon_representation_get_attributes(representation, &attributes));
if (!result) {
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<picojson::array*>(user_data);
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");
}
{
- const auto& states = r.find(kStates);
+ const auto& states = r.find(kAttributes);
if (r.end() != states && states->second.is<picojson::object>()) {
iotcon_attributes_h s = nullptr;
}
{
- const auto& representations = r.find(kRepresentations);
- if (r.end() !=
representations && representations->second.is<picojson::array>()) {
- for (const auto& js_child :
representations->second.get<picojson::array>()) {
+ const auto& children = r.find(kChildren);
+ if (r.end() !=
children && children->second.is<picojson::array>()) {
+ for (const auto& js_child :
children->second.get<picojson::array>()) {
if (js_child.is<picojson::object>()) {
iotcon_representation_h child = nullptr;
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.");
}
}
}
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;
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;
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
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
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)
projects / platform / core / api / webapi-plugins.git / commitdiff