#include "iotcon/iotcon_instance.h"
+#include <thread>
+
#include "common/logger.h"
-#include "common/task-queue.h"
-#include "common/tools.h"
#include "iotcon/iotcon_utils.h"
-using common::PlatformResult;
-using common::ErrorCode;
-using common::TypeMismatchException;
-using common::tools::ReportError;
-using common::tools::ReportSuccess;
-using common::Instance;
-using common::TaskQueue;
-
namespace extension {
namespace iotcon {
namespace {
-#define CHECK_EXIST(args, name, out) \
- if (!args.contains(name)) {\
- std::string message = std::string(name) + " is required argument";\
- common::tools::ReportError(\
- common::PlatformResult(common::ErrorCode::TYPE_MISMATCH_ERR, message), &out);\
- return;\
+
+#define CHECK_EXIST(args, name) \
+ if (args.end() == args.find(name)) { \
+ return common::TypeMismatchError(std::string(name) + " is required argument"); \
}
-}
+
+} // namespace
IotconInstance::IotconInstance() : manager_(this) {
- LoggerD("Enter");
+ ScopeLogger();
+
using std::placeholders::_1;
using std::placeholders::_2;
- #define REGISTER_ASYNC(c, func) \
- RegisterSyncHandler(c, func);
- #define REGISTER_SYNC(c, func) \
- RegisterSyncHandler(c, func);
-
- REGISTER_SYNC("IotconResource_getObserverIds",
- std::bind(&IotconInstance::IotconResourceGetObserverIds, this, _1, _2));
- REGISTER_ASYNC("IotconResource_notify",
- std::bind(&IotconInstance::IotconResourceNotify, this, _1, _2));
- REGISTER_ASYNC("IotconResource_addResourceTypes",
- std::bind(&IotconInstance::IotconResourceAddResourceTypes, this, _1, _2));
- REGISTER_ASYNC("IotconResource_addResourceInterfaces",
- std::bind(&IotconInstance::IotconResourceAddResourceInterfaces, this, _1, _2));
- REGISTER_ASYNC("IotconResource_addChildResource",
- std::bind(&IotconInstance::IotconResourceAddChildResource, this, _1, _2));
- REGISTER_ASYNC("IotconResource_removeChildResource",
- std::bind(&IotconInstance::IotconResourceRemoveChildResource, this, _1, _2));
- REGISTER_SYNC("IotconResource_setRequestListener",
- std::bind(&IotconInstance::IotconResourceSetRequestListener, this, _1, _2));
- REGISTER_SYNC("IotconRemoteResource_unsetRequestListener",
- std::bind(&IotconInstance::IotconRemoteResourceUnsetRequestListener, this, _1, _2));
- REGISTER_SYNC("IotconResponse_send",
- std::bind(&IotconInstance::IotconResponseSend, this, _1, _2));
- REGISTER_SYNC("IotconRemoteResource_getCachedRepresentation",
- std::bind(&IotconInstance::IotconRemoteResourceGetCachedRepresentation, this, _1, _2));
- REGISTER_ASYNC("IotconRemoteResource_methodGet",
- std::bind(&IotconInstance::IotconRemoteResourceMethodGet, this, _1, _2));
- REGISTER_ASYNC("IotconRemoteResource_methodPut",
- std::bind(&IotconInstance::IotconRemoteResourceMethodPut, this, _1, _2));
- REGISTER_ASYNC("IotconRemoteResource_methodPost",
- std::bind(&IotconInstance::IotconRemoteResourceMethodPost, this, _1, _2));
- REGISTER_ASYNC("IotconRemoteResource_methodDelete",
- std::bind(&IotconInstance::IotconRemoteResourceMethodDelete, this, _1, _2));
- REGISTER_SYNC("IotconRemoteResource_setStateChangeListener",
- std::bind(&IotconInstance::IotconRemoteResourceSetStateChangeListener, this, _1, _2));
- REGISTER_SYNC("IotconRemoteResource_unsetStateChangeListener",
- std::bind(&IotconInstance::IotconRemoteResourceUnsetStateChangeListener, this, _1, _2));
- REGISTER_SYNC("IotconRemoteResource_startCaching",
- std::bind(&IotconInstance::IotconRemoteResourceStartCaching, this, _1, _2));
- REGISTER_SYNC("IotconRemoteResource_stopCaching",
- std::bind(&IotconInstance::IotconRemoteResourceStopCaching, this, _1, _2));
- REGISTER_SYNC("IotconRemoteResource_setConnectionChangeListener",
- std::bind(&IotconInstance::IotconRemoteResourceSetConnectionChangeListener, this, _1, _2));
- REGISTER_SYNC("IotconRemoteResource_unsetConnectionChangeListener",
- std::bind(&IotconInstance::IotconRemoteResourceUnsetConnectionChangeListener, this, _1, _2));
- REGISTER_ASYNC("IotconClient_findResource",
- std::bind(&IotconInstance::IotconClientFindResource, this, _1, _2));
- REGISTER_SYNC("IotconClient_addPresenceEventListener",
- std::bind(&IotconInstance::IotconClientAddPresenceEventListener, this, _1, _2));
- REGISTER_SYNC("IotconClient_removePresenceEventListener",
- std::bind(&IotconInstance::IotconClientRemovePresenceEventListener, this, _1, _2));
- REGISTER_ASYNC("IotconClient_getDeviceInfo",
- std::bind(&IotconInstance::IotconClientGetDeviceInfo, this, _1, _2));
- REGISTER_ASYNC("IotconClient_getPlatformInfo",
- std::bind(&IotconInstance::IotconClientGetPlatformInfo, this, _1, _2));
- REGISTER_ASYNC("IotconServer_createResource",
- std::bind(&IotconInstance::IotconServerCreateResource, this, _1, _2));
- REGISTER_ASYNC("IotconServer_removeResource",
- std::bind(&IotconInstance::IotconServerRemoveResource, this, _1, _2));
- REGISTER_ASYNC("IotconServer_updateResource",
- std::bind(&IotconInstance::IotconServerUpdateResource, this, _1, _2));
- REGISTER_SYNC("Iotcon_getTimeout",
- std::bind(&IotconInstance::IotconGetTimeout, this, _1, _2));
- REGISTER_SYNC("Iotcon_setTimeout",
- std::bind(&IotconInstance::IotconSetTimeout, this, _1, _2));
- #undef REGISTER_ASYNC
- #undef REGISTER_SYNC
+#define REGISTER_SYNC(c, x) \
+ RegisterSyncHandler(c, std::bind(&IotconInstance::x, this, _1))
+
+ REGISTER_SYNC("IotconResource_getObserverIds", ResourceGetObserverIds);
+ REGISTER_SYNC("IotconResource_setRequestListener", ResourceSetRequestListener);
+ REGISTER_SYNC("IotconRemoteResource_unsetRequestListener", RemoteResourceUnsetRequestListener);
+ REGISTER_SYNC("IotconResponse_send", ResponseSend);
+ REGISTER_SYNC("IotconRemoteResource_getCachedRepresentation", RemoteResourceGetCachedRepresentation);
+ REGISTER_SYNC("IotconRemoteResource_setStateChangeListener", RemoteResourceSetStateChangeListener);
+ REGISTER_SYNC("IotconRemoteResource_unsetStateChangeListener", RemoteResourceUnsetStateChangeListener);
+ REGISTER_SYNC("IotconRemoteResource_startCaching", RemoteResourceStartCaching);
+ REGISTER_SYNC("IotconRemoteResource_stopCaching", RemoteResourceStopCaching);
+ REGISTER_SYNC("IotconRemoteResource_setConnectionChangeListener", RemoteResourceSetConnectionChangeListener);
+ REGISTER_SYNC("IotconRemoteResource_unsetConnectionChangeListener", RemoteResourceUnsetConnectionChangeListener);
+ REGISTER_SYNC("IotconClient_addPresenceEventListener", ClientAddPresenceEventListener);
+ REGISTER_SYNC("IotconClient_removePresenceEventListener", ClientRemovePresenceEventListener);
+ REGISTER_SYNC("Iotcon_getTimeout", GetTimeout);
+ REGISTER_SYNC("Iotcon_setTimeout", SetTimeout);
+
+#undef REGISTER_SYNC
+
+#define REGISTER_ASYNC(c, x) \
+ RegisterHandler(c, std::bind(&IotconInstance::x, this, _1, _2));
+
+ REGISTER_ASYNC("IotconResource_notify", ResourceNotify);
+ REGISTER_ASYNC("IotconResource_addResourceTypes", ResourceAddResourceTypes);
+ REGISTER_ASYNC("IotconResource_addResourceInterfaces", ResourceAddResourceInterfaces);
+ REGISTER_ASYNC("IotconResource_addChildResource", ResourceAddChildResource);
+ REGISTER_ASYNC("IotconResource_removeChildResource", ResourceRemoveChildResource);
+ REGISTER_ASYNC("IotconRemoteResource_methodGet", RemoteResourceMethodGet);
+ REGISTER_ASYNC("IotconRemoteResource_methodPut", RemoteResourceMethodPut);
+ REGISTER_ASYNC("IotconRemoteResource_methodPost", RemoteResourceMethodPost);
+ REGISTER_ASYNC("IotconRemoteResource_methodDelete", RemoteResourceMethodDelete);
+ REGISTER_ASYNC("IotconClient_findResource", ClientFindResource);
+ REGISTER_ASYNC("IotconClient_getDeviceInfo", ClientGetDeviceInfo);
+ REGISTER_ASYNC("IotconClient_getPlatformInfo", ClientGetPlatformInfo);
+ REGISTER_ASYNC("IotconServer_createResource", ServerCreateResource);
+ REGISTER_ASYNC("IotconServer_removeResource", ServerRemoveResource);
+ REGISTER_ASYNC("IotconServer_updateResource", ServerUpdateResource);
+
+#undef REGISTER_ASYNC
// initialize connection to iotcon service
int ret = iotcon_connect();
}
void IotconInstance::ConnectionChangedCallback(bool is_connected, void* user_data) {
- LoggerD("Enter");
+ ScopeLogger();
+
if (!is_connected) {
LoggerD("Connection lost, need to wait for connection recovery");
} else {
}
LoggerD("Connection recovered, restoring handles");
- PlatformResult ret = instance->manager_.RestoreHandles();
- if (ret.IsError()) {
+ auto ret = instance->manager_.RestoreHandles();
+ if (!ret) {
LoggerD("Connection recovered, but restoring handles failed");
}
}
}
IotconInstance::~IotconInstance() {
- LoggerD("Enter");
+ ScopeLogger();
iotcon_remove_connection_changed_cb(ConnectionChangedCallback, this);
iotcon_disconnect();
}
-void IotconInstance::IotconResourceGetObserverIds(const picojson::value& args,
- picojson::object& out) {
- LoggerD("Enter");
-
+common::TizenResult IotconInstance::ResourceGetObserverIds(const picojson::object& args) {
+ ScopeLogger();
+ return common::UnknownError("Not implemented");
}
-void IotconInstance::IotconResourceNotify(const picojson::value& args,
- picojson::object& out) {
- LoggerD("Enter");
-
+common::TizenResult IotconInstance::ResourceNotify(const picojson::object& args,
+ const common::AsyncToken& token) {
+ ScopeLogger();
+ return common::UnknownError("Not implemented");
}
-void IotconInstance::IotconResourceAddResourceTypes(const picojson::value& args,
- picojson::object& out) {
- LoggerD("Enter");
-
+common::TizenResult IotconInstance::ResourceAddResourceTypes(const picojson::object& args,
+ const common::AsyncToken& token) {
+ ScopeLogger();
+ return common::UnknownError("Not implemented");
}
-void IotconInstance::IotconResourceAddResourceInterfaces(const picojson::value& args,
- picojson::object& out) {
- LoggerD("Enter");
-
+common::TizenResult IotconInstance::ResourceAddResourceInterfaces(const picojson::object& args,
+ const common::AsyncToken& token) {
+ ScopeLogger();
+ return common::UnknownError("Not implemented");
}
-void IotconInstance::IotconResourceAddChildResource(const picojson::value& args,
- picojson::object& out) {
- LoggerD("Enter");
-
+common::TizenResult IotconInstance::ResourceAddChildResource(const picojson::object& args,
+ const common::AsyncToken& token) {
+ ScopeLogger();
+ return common::UnknownError("Not implemented");
}
-void IotconInstance::IotconResourceRemoveChildResource(const picojson::value& args,
- picojson::object& out) {
- LoggerD("Enter");
-
+common::TizenResult IotconInstance::ResourceRemoveChildResource(const picojson::object& args,
+ const common::AsyncToken& token) {
+ ScopeLogger();
+ return common::UnknownError("Not implemented");
}
-void IotconInstance::IotconResourceSetRequestListener(const picojson::value& args,
- picojson::object& out) {
- LoggerD("Enter");
-
+common::TizenResult IotconInstance::ResourceSetRequestListener(const picojson::object& args) {
+ ScopeLogger();
+ return common::UnknownError("Not implemented");
}
-void IotconInstance::IotconRemoteResourceUnsetRequestListener(const picojson::value& args,
- picojson::object& out) {
- LoggerD("Enter");
-
+common::TizenResult IotconInstance::RemoteResourceUnsetRequestListener(const picojson::object& args) {
+ ScopeLogger();
+ return common::UnknownError("Not implemented");
}
-void IotconInstance::IotconResponseSend(const picojson::value& args,
- picojson::object& out) {
- LoggerD("Enter");
-
+common::TizenResult IotconInstance::ResponseSend(const picojson::object& args) {
+ ScopeLogger();
+ return common::UnknownError("Not implemented");
}
-void IotconInstance::IotconRemoteResourceGetCachedRepresentation(const picojson::value& args,
- picojson::object& out) {
- LoggerD("Enter");
-
+common::TizenResult IotconInstance::RemoteResourceGetCachedRepresentation(const picojson::object& args) {
+ ScopeLogger();
+ return common::UnknownError("Not implemented");
}
-void IotconInstance::IotconRemoteResourceMethodGet(const picojson::value& args,
- picojson::object& out) {
- LoggerD("Enter");
-
+common::TizenResult IotconInstance::RemoteResourceMethodGet(const picojson::object& args,
+ const common::AsyncToken& token) {
+ ScopeLogger();
+ return common::UnknownError("Not implemented");
}
-void IotconInstance::IotconRemoteResourceMethodPut(const picojson::value& args,
- picojson::object& out) {
- LoggerD("Enter");
-
+common::TizenResult IotconInstance::RemoteResourceMethodPut(const picojson::object& args,
+ const common::AsyncToken& token) {
+ ScopeLogger();
+ return common::UnknownError("Not implemented");
}
-void IotconInstance::IotconRemoteResourceMethodPost(const picojson::value& args,
- picojson::object& out) {
- LoggerD("Enter");
-
+common::TizenResult IotconInstance::RemoteResourceMethodPost(const picojson::object& args,
+ const common::AsyncToken& token) {
+ ScopeLogger();
+ return common::UnknownError("Not implemented");
}
-void IotconInstance::IotconRemoteResourceMethodDelete(const picojson::value& args,
- picojson::object& out) {
- LoggerD("Enter");
-
+common::TizenResult IotconInstance::RemoteResourceMethodDelete(const picojson::object& args,
+ const common::AsyncToken& token) {
+ ScopeLogger();
+ return common::UnknownError("Not implemented");
}
-void IotconInstance::IotconRemoteResourceSetStateChangeListener(const picojson::value& args,
- picojson::object& out) {
- LoggerD("Enter");
-
+common::TizenResult IotconInstance::RemoteResourceSetStateChangeListener(const picojson::object& args) {
+ ScopeLogger();
+ return common::UnknownError("Not implemented");
}
-void IotconInstance::IotconRemoteResourceUnsetStateChangeListener(const picojson::value& args,
- picojson::object& out) {
- LoggerD("Enter");
-
+common::TizenResult IotconInstance::RemoteResourceUnsetStateChangeListener(const picojson::object& args) {
+ ScopeLogger();
+ return common::UnknownError("Not implemented");
}
-void IotconInstance::IotconRemoteResourceStartCaching(const picojson::value& args,
- picojson::object& out) {
- LoggerD("Enter");
-
+common::TizenResult IotconInstance::RemoteResourceStartCaching(const picojson::object& args) {
+ ScopeLogger();
+ return common::UnknownError("Not implemented");
}
-void IotconInstance::IotconRemoteResourceStopCaching(const picojson::value& args,
- picojson::object& out) {
- LoggerD("Enter");
-
+common::TizenResult IotconInstance::RemoteResourceStopCaching(const picojson::object& args) {
+ ScopeLogger();
+ return common::UnknownError("Not implemented");
}
-void IotconInstance::IotconRemoteResourceSetConnectionChangeListener(const picojson::value& args,
- picojson::object& out) {
- LoggerD("Enter");
-
+common::TizenResult IotconInstance::RemoteResourceSetConnectionChangeListener(const picojson::object& args) {
+ ScopeLogger();
+ return common::UnknownError("Not implemented");
}
-void IotconInstance::IotconRemoteResourceUnsetConnectionChangeListener(const picojson::value& args,
- picojson::object& out) {
- LoggerD("Enter");
-
+common::TizenResult IotconInstance::RemoteResourceUnsetConnectionChangeListener(const picojson::object& args) {
+ ScopeLogger();
+ return common::UnknownError("Not implemented");
}
-void IotconInstance::IotconClientFindResource(const picojson::value& args,
- picojson::object& out) {
- LoggerD("Enter");
-
+common::TizenResult IotconInstance::ClientFindResource(const picojson::object& args,
+ const common::AsyncToken& token) {
+ ScopeLogger();
+ return common::UnknownError("Not implemented");
}
-void IotconInstance::IotconClientAddPresenceEventListener(const picojson::value& args,
- picojson::object& out) {
- LoggerD("Enter");
-
+common::TizenResult IotconInstance::ClientAddPresenceEventListener(const picojson::object& args) {
+ ScopeLogger();
+ return common::UnknownError("Not implemented");
}
-void IotconInstance::IotconClientRemovePresenceEventListener(const picojson::value& args,
- picojson::object& out) {
- LoggerD("Enter");
-
+common::TizenResult IotconInstance::ClientRemovePresenceEventListener(const picojson::object& args) {
+ ScopeLogger();
+ return common::UnknownError("Not implemented");
}
-void IotconInstance::IotconClientGetDeviceInfo(const picojson::value& args,
- picojson::object& out) {
- LoggerD("Enter");
-
+common::TizenResult IotconInstance::ClientGetDeviceInfo(const picojson::object& args,
+ const common::AsyncToken& token) {
+ ScopeLogger();
+ return common::UnknownError("Not implemented");
}
-void IotconInstance::IotconClientGetPlatformInfo(const picojson::value& args,
- picojson::object& out) {
- LoggerD("Enter");
-
+common::TizenResult IotconInstance::ClientGetPlatformInfo(const picojson::object& args,
+ const common::AsyncToken& token) {
+ ScopeLogger();
+ return common::UnknownError("Not implemented");
}
-void IotconInstance::IotconServerCreateResource(const picojson::value& args,
- picojson::object& out) {
- LoggerD("Enter");
- LoggerD("args: %s", args.serialize().c_str());
- CHECK_EXIST(args, kCallbackId, out)
- CHECK_EXIST(args, kIsDiscoverable, out)
- CHECK_EXIST(args, kIsObservable, out)
- CHECK_EXIST(args, kResourceTypes, out)
- CHECK_EXIST(args, kResourceInterfaces, out)
- CHECK_EXIST(args, kUriPath, out)
+common::TizenResult IotconInstance::ServerCreateResource(const picojson::object& args,
+ const common::AsyncToken& token) {
+ ScopeLogger();
- const double callback_id = args.get(kCallbackId).get<double>();
- // TODO consider support other properties
- const bool is_discoverable = args.get(kIsDiscoverable).get<bool>();
- const bool is_observable = args.get(kIsObservable).get<bool>();
- const auto& resource_types = args.get(kResourceTypes).get<picojson::array>();
- const auto& resource_interfaces = args.get(kResourceInterfaces).get<picojson::array>();
- const std::string& uri_path = args.get(kUriPath).get<std::string>();
+ CHECK_EXIST(args, kIsDiscoverable);
+ CHECK_EXIST(args, kIsObservable);
+ CHECK_EXIST(args, kResourceTypes);
+ CHECK_EXIST(args, kResourceInterfaces);
+ CHECK_EXIST(args, kUriPath);
- auto create = [this, callback_id, is_discoverable, is_observable,
- resource_types, uri_path, resource_interfaces]
- (const std::shared_ptr<picojson::value>& response) -> void {
- LoggerD("Create resource");
+ // TODO: consider support other properties
+ const bool is_discoverable = args.find(kIsDiscoverable)->second.get<bool>();
+ const bool is_observable = args.find(kIsObservable)->second.get<bool>();
+ const auto& resource_types = args.find(kResourceTypes)->second.get<picojson::array>();
+ const auto& resource_interfaces = args.find(kResourceInterfaces)->second.get<picojson::array>();
+ const std::string& uri_path = args.find(kUriPath)->second.get<std::string>();
+
+ auto create = [this, is_discoverable, is_observable,
+ resource_types, uri_path, resource_interfaces, token]() {
+ ScopeLogger("Create resource");
picojson::value result = picojson::value(picojson::object());
ResourceInfoPtr resource{new ResourceInfo()};
- PlatformResult ret = manager_.CreateResource(uri_path, resource_interfaces, resource_types,
- is_discoverable, is_observable, resource);
- if (ret.IsError()) {
- LogAndReportError(ret,&(response->get<picojson::object>()));
+ auto ret = manager_.CreateResource(uri_path, resource_interfaces, resource_types,
+ is_discoverable, is_observable, resource);
+ if (!ret) {
+ Post(token, ret);
return;
}
LoggerD("RESOURCE\nid: %lld\nhandle: %p", resource->id, resource->handle);
ret = IotconUtils::ResourceToJson(resource, manager_, &(result.get<picojson::object>()));
- if (ret.IsError()) {
- LogAndReportError(ret,&(response->get<picojson::object>()));
+ if (!ret) {
+ Post(token, ret);
return;
}
- ReportSuccess(result, response->get<picojson::object>());
- };
- auto create_response = [this, callback_id](const std::shared_ptr<picojson::value>& response) -> void {
- LoggerD("Response");
- picojson::object& obj = response->get<picojson::object>();
- obj.insert(std::make_pair("callbackId", picojson::value{static_cast<double>(callback_id)}));
- LoggerD("message: %s", response->serialize().c_str());
- Instance::PostMessage(this, response->serialize().c_str());
+ Post(token, common::TizenSuccess{result});
};
- auto data = std::shared_ptr<picojson::value>(new picojson::value(picojson::object()));
+ std::thread{create}.detach();
- TaskQueue::GetInstance().Queue<picojson::value>(create, create_response, data);
+ return common::TizenSuccess();
}
-void IotconInstance::IotconServerRemoveResource(const picojson::value& args,
- picojson::object& out) {
- LoggerD("Enter");
+common::TizenResult IotconInstance::ServerRemoveResource(const picojson::object& args,
+ const common::AsyncToken& token) {
+ ScopeLogger();
+ return common::UnknownError("Not implemented");
}
-void IotconInstance::IotconServerUpdateResource(const picojson::value& args,
- picojson::object& out) {
- LoggerD("Enter");
+common::TizenResult IotconInstance::ServerUpdateResource(const picojson::object& args,
+ const common::AsyncToken& token) {
+ ScopeLogger();
+ return common::UnknownError("Not implemented");
}
-void IotconInstance::IotconGetTimeout(const picojson::value& args,
- picojson::object& out) {
- LoggerD("Enter");
-
- picojson::value result = picojson::value(picojson::object());
- picojson::object& result_obj = result.get<picojson::object>();
+common::TizenResult IotconInstance::GetTimeout(const picojson::object& args) {
+ ScopeLogger();
int timeout = 0;
int ret = iotcon_get_timeout(&timeout);
if (IOTCON_ERROR_NONE != ret) {
- LogAndReportError(PlatformResult(ErrorCode::UNKNOWN_ERR, "Platform unknown error."), &out);
- return;
+ return LogAndCreateTizenError(UnknownError, ret);
}
- result_obj.insert(std::make_pair("timeout", picojson::value(static_cast<double>(timeout))));
- ReportSuccess(result, out);
+ return common::TizenSuccess{picojson::value{static_cast<double>(timeout)}};
}
-void IotconInstance::IotconSetTimeout(const picojson::value& args,
- picojson::object& out) {
- LoggerD("Enter");
- CHECK_EXIST(args, "timeout", out);
+common::TizenResult IotconInstance::SetTimeout(const picojson::object& args) {
+ ScopeLogger();
+
+ CHECK_EXIST(args, "timeout");
- int timeout = static_cast<int>(args.get("timeout").get<double>());
+ int timeout = static_cast<int>(args.find("timeout")->second.get<double>());
int ret = iotcon_set_timeout(timeout);
if (IOTCON_ERROR_NONE != ret) {
- LogAndReportError(PlatformResult(ErrorCode::UNKNOWN_ERR, "Platform unknown error."), &out);
- return;
+ return LogAndCreateTizenError(UnknownError, ret);
}
- ReportSuccess(out);
+ return common::TizenSuccess();
}
} // namespace iotcon
#ifndef IOTCON_IOTCON_INSTANCE_H_
#define IOTCON_IOTCON_INSTANCE_H_
-#include "common/picojson.h"
-#include "common/extension.h"
+#include "common/tizen_instance.h"
+
#include "iotcon/iotcon_server_manager.h"
namespace extension {
namespace iotcon {
-class IotconInstance : public common::ParsedInstance {
+class IotconInstance : public common::TizenInstance {
public:
IotconInstance();
virtual ~IotconInstance();
private:
static void ConnectionChangedCallback(bool is_connected, void* user_data);
- void IotconResourceGetObserverIds(const picojson::value& args,
- picojson::object& out);
- void IotconResourceNotify(const picojson::value& args,
- picojson::object& out);
- void IotconResourceAddResourceTypes(const picojson::value& args,
- picojson::object& out);
- void IotconResourceAddResourceInterfaces(const picojson::value& args,
- picojson::object& out);
- void IotconResourceAddChildResource(const picojson::value& args,
- picojson::object& out);
- void IotconResourceRemoveChildResource(const picojson::value& args,
- picojson::object& out);
- void IotconResourceSetRequestListener(const picojson::value& args,
- picojson::object& out);
- void IotconRemoteResourceUnsetRequestListener(const picojson::value& args,
- picojson::object& out);
- void IotconResponseSend(const picojson::value& args,
- picojson::object& out);
- void IotconRemoteResourceGetCachedRepresentation(const picojson::value& args,
- picojson::object& out);
- void IotconRemoteResourceMethodGet(const picojson::value& args,
- picojson::object& out);
- void IotconRemoteResourceMethodPut(const picojson::value& args,
- picojson::object& out);
- void IotconRemoteResourceMethodPost(const picojson::value& args,
- picojson::object& out);
- void IotconRemoteResourceMethodDelete(const picojson::value& args,
- picojson::object& out);
- void IotconRemoteResourceSetStateChangeListener(const picojson::value& args,
- picojson::object& out);
- void IotconRemoteResourceUnsetStateChangeListener(const picojson::value& args,
- picojson::object& out);
- void IotconRemoteResourceStartCaching(const picojson::value& args,
- picojson::object& out);
- void IotconRemoteResourceStopCaching(const picojson::value& args,
- picojson::object& out);
- void IotconRemoteResourceSetConnectionChangeListener(const picojson::value& args,
- picojson::object& out);
- void IotconRemoteResourceUnsetConnectionChangeListener(const picojson::value& args,
- picojson::object& out);
- void IotconClientFindResource(const picojson::value& args,
- picojson::object& out);
- void IotconClientAddPresenceEventListener(const picojson::value& args,
- picojson::object& out);
- void IotconClientRemovePresenceEventListener(const picojson::value& args,
- picojson::object& out);
- void IotconClientGetDeviceInfo(const picojson::value& args,
- picojson::object& out);
- void IotconClientGetPlatformInfo(const picojson::value& args,
- picojson::object& out);
- void IotconServerCreateResource(const picojson::value& args,
- picojson::object& out);
- void IotconServerRemoveResource(const picojson::value& args,
- picojson::object& out);
- void IotconServerUpdateResource(const picojson::value& args,
- picojson::object& out);
- void IotconGetTimeout(const picojson::value& args,
- picojson::object& out);
- void IotconSetTimeout(const picojson::value& args,
- picojson::object& out);
+ common::TizenResult ResourceGetObserverIds(const picojson::object& args);
+ common::TizenResult ResourceNotify(const picojson::object& args,
+ const common::AsyncToken& token);
+ common::TizenResult ResourceAddResourceTypes(const picojson::object& args,
+ const common::AsyncToken& token);
+ common::TizenResult ResourceAddResourceInterfaces(const picojson::object& args,
+ const common::AsyncToken& token);
+ common::TizenResult ResourceAddChildResource(const picojson::object& args,
+ const common::AsyncToken& token);
+ common::TizenResult ResourceRemoveChildResource(const picojson::object& args,
+ const common::AsyncToken& token);
+ common::TizenResult ResourceSetRequestListener(const picojson::object& args);
+ common::TizenResult RemoteResourceUnsetRequestListener(const picojson::object& args);
+ common::TizenResult ResponseSend(const picojson::object& args);
+ common::TizenResult RemoteResourceGetCachedRepresentation(const picojson::object& args);
+ common::TizenResult RemoteResourceMethodGet(const picojson::object& args,
+ const common::AsyncToken& token);
+ common::TizenResult RemoteResourceMethodPut(const picojson::object& args,
+ const common::AsyncToken& token);
+ common::TizenResult RemoteResourceMethodPost(const picojson::object& args,
+ 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 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 ClientFindResource(const picojson::object& args,
+ const common::AsyncToken& token);
+ 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 ServerCreateResource(const picojson::object& args,
+ const common::AsyncToken& token);
+ common::TizenResult ServerRemoveResource(const picojson::object& args,
+ const common::AsyncToken& token);
+ common::TizenResult ServerUpdateResource(const picojson::object& args,
+ const common::AsyncToken& token);
+ common::TizenResult GetTimeout(const picojson::object& args);
+ common::TizenResult SetTimeout(const picojson::object& args);
IotconServerManager manager_;
};
namespace extension {
namespace iotcon {
-const std::string kCallbackId = "callbackId";
const std::string kIsDiscoverable = "isDiscoverable";
const std::string kIsObservable = "isObservable";
const std::string kResourceTypes = "resourceTypes";
const std::string kInterfaceBatch = "BATCH";
const std::string kInterfaceGroup = "GROUP";
-using common::PlatformResult;
-using common::ErrorCode;
+using common::TizenResult;
+using common::TizenSuccess;
+
+TizenResult IotconUtils::StringToInterface(const std::string& interface, iotcon_interface_e* res) {
+ ScopeLogger();
-PlatformResult IotconUtils::StringToInterface(const std::string& interface, iotcon_interface_e* res) {
- LoggerD("Entered");
if (kInterfaceDefault == interface) {
*res = IOTCON_INTERFACE_DEFAULT;
} else if (kInterfaceLink == interface) {
} else if (kInterfaceGroup == interface) {
*res = IOTCON_INTERFACE_GROUP;
} else {
- return LogAndCreateResult(ErrorCode::INVALID_VALUES_ERR, "Not supported interface name");
+ return LogAndCreateTizenError(InvalidValuesError, "Not supported interface name");
}
- return PlatformResult(ErrorCode::NO_ERROR);
+ return TizenSuccess();
}
-PlatformResult IotconUtils::ArrayToInterfaces(const picojson::array& interfaces, int* res) {
- LoggerD("Entered");
+TizenResult IotconUtils::ArrayToInterfaces(const picojson::array& interfaces, int* res) {
+ ScopeLogger();
+
int result_value = IOTCON_INTERFACE_NONE;
for (auto iter = interfaces.begin(); iter != interfaces.end(); ++iter) {
if (!iter->is<std::string>()) {
- LoggerE("Array holds incorrect interface names");
- return LogAndCreateResult(ErrorCode::INVALID_VALUES_ERR, "Array holds incorrect interface names");
+ return LogAndCreateTizenError(InvalidValuesError, "Array holds incorrect interface names");
} else {
iotcon_interface_e interface = IOTCON_INTERFACE_NONE;
- PlatformResult ret = StringToInterface(iter->get<std::string>(), &interface);
- if (ret.IsError()) {
+ auto ret = StringToInterface(iter->get<std::string>(), &interface);
+ if (!ret) {
return ret;
}
result_value |= interface;
}
}
*res = result_value;
- return PlatformResult(ErrorCode::NO_ERROR);
+ return TizenSuccess();
}
picojson::array IotconUtils::InterfacesToArray(int interfaces) {
- LoggerD("Entered");
+ ScopeLogger();
+
picojson::array res;
if (interfaces & IOTCON_INTERFACE_DEFAULT) {
res.push_back(picojson::value(kInterfaceDefault));
return res;
}
-PlatformResult IotconUtils::ArrayToTypes(const picojson::array& types, iotcon_resource_types_h* res) {
- LoggerD("Entered");
+TizenResult IotconUtils::ArrayToTypes(const picojson::array& types, iotcon_resource_types_h* res) {
+ ScopeLogger();
iotcon_resource_types_h resource_types = nullptr;
int ret = iotcon_resource_types_create(&resource_types);
if (IOTCON_ERROR_NONE != ret) {
- return LogAndCreateResult(ErrorCode::UNKNOWN_ERR, "Unknown error occurred.",
- ("iotcon_resource_types_create failed: %d (%s)",
+ return LogAndCreateTizenError(UnknownError, "Unknown error occurred.",
+ ("iotcon_resource_types_create failed: %d (%s)",
ret, get_error_message(ret)));
}
for (auto iter = types.begin(); iter != types.end(); ++iter) {
if (!iter->is<std::string>()) {
- LoggerE("Array holds incorrect types");
- return LogAndCreateResult(ErrorCode::INVALID_VALUES_ERR, "Array holds incorrect types");
+ return LogAndCreateTizenError(InvalidValuesError, "Array holds incorrect types");
} else {
ret = iotcon_resource_types_add(resource_types, iter->get<std::string>().c_str());
if (IOTCON_ERROR_NONE != ret) {
iotcon_resource_types_destroy(resource_types);
- return LogAndCreateResult(ErrorCode::UNKNOWN_ERR, "Unknown error occurred.",
- ("iotcon_resource_types_add failed: %d (%s)",
+ return LogAndCreateTizenError(UnknownError, "Unknown error occurred.",
+ ("iotcon_resource_types_add failed: %d (%s)",
ret, get_error_message(ret)));
}
}
}
*res = resource_types;
- return PlatformResult(ErrorCode::NO_ERROR);
+ return TizenSuccess();
}
static bool ResourceTypeIterator(const char *type, void *user_data) {
- LoggerD("Enter");
+ ScopeLogger();
picojson::array* array_data = static_cast<picojson::array*>(user_data);
if (!array_data) {
return true;
}
-PlatformResult IotconUtils::ExtractFromResource(const ResourceInfoPtr& pointer,
- char** uri_path,
- iotcon_resource_types_h* res_types,
- int* ifaces,
- int* properties) {
- LoggerD("Entered");
+TizenResult IotconUtils::ExtractFromResource(const ResourceInfoPtr& pointer,
+ char** uri_path,
+ iotcon_resource_types_h* res_types,
+ int* ifaces,
+ int* properties) {
+ ScopeLogger();
+
int ret = iotcon_resource_get_uri_path (pointer->handle, uri_path);
if (IOTCON_ERROR_NONE != ret) {
LoggerD("Error %s", get_error_message(ret));
- return LogAndCreateResult(ErrorCode::UNKNOWN_ERR, "Gathering resource uri path failed");
+ return LogAndCreateTizenError(UnknownError, "Gathering resource uri path failed");
}
ret = iotcon_resource_get_types (pointer->handle, res_types);
if (IOTCON_ERROR_NONE != ret) {
LoggerD("Error %s", get_error_message(ret));
- return LogAndCreateResult(ErrorCode::UNKNOWN_ERR, "Gathering resource types failed");
+ return LogAndCreateTizenError(UnknownError, "Gathering resource types failed");
}
ret = iotcon_resource_get_interfaces (pointer->handle, ifaces);
if (IOTCON_ERROR_NONE != ret) {
LoggerD("Error %s", get_error_message(ret));
- return LogAndCreateResult(ErrorCode::UNKNOWN_ERR, "Gathering resource interfaces failed");
+ return LogAndCreateTizenError(UnknownError, "Gathering resource interfaces failed");
}
ret = iotcon_resource_get_properties (pointer->handle, properties);
if (IOTCON_ERROR_NONE != ret) {
LoggerD("Error %s", get_error_message(ret));
- return LogAndCreateResult(ErrorCode::UNKNOWN_ERR, "Gathering resource properties failed");
+ return LogAndCreateTizenError(UnknownError, "Gathering resource properties failed");
}
- return PlatformResult(ErrorCode::NO_ERROR);
+ return TizenSuccess();
}
-PlatformResult IotconUtils::ResourceToJson(ResourceInfoPtr pointer,
- const IotconServerManager& manager,
- picojson::object* res) {
- LoggerD("Entered");
+TizenResult IotconUtils::ResourceToJson(ResourceInfoPtr pointer,
+ const IotconServerManager& manager,
+ picojson::object* res) {
+ ScopeLogger();
char* uri_path = nullptr;
iotcon_resource_types_h res_types = nullptr;
int ifaces = 0;
int properties = 0;
- PlatformResult ret = ExtractFromResource(pointer, &uri_path, &res_types, &ifaces, &properties);
- if (ret.IsError()){
+ auto ret = ExtractFromResource(pointer, &uri_path, &res_types, &ifaces, &properties);
+ if (!ret){
return ret;
}
res->insert(std::make_pair(kResourceId, picojson::value(static_cast<double>(pointer->id))));
res->insert(std::make_pair(kResourceChildren, picojson::value(children)));
// observerIds would be done on demand from JS
- return PlatformResult(ErrorCode::NO_ERROR);
+ return TizenSuccess();
}
} // namespace iotcon
projects / platform / core / api / webapi-plugins.git / commitdiff