src/iotcon/iotcon_instance.cc

   1 /*
   2  * Copyright (c) 2016 Samsung Electronics Co., Ltd All Rights Reserved
   3  *
   4  *    Licensed under the Apache License, Version 2.0 (the "License");
   5  *    you may not use this file except in compliance with the License.
   6  *    You may obtain a copy of the License at
   7  *
   8  *        http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  *    Unless required by applicable law or agreed to in writing, software
  11  *    distributed under the License is distributed on an "AS IS" BASIS,
  12  *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  *    See the License for the specific language governing permissions and
  14  *    limitations under the License.
  15  */
  16
  17 #include "iotcon/iotcon_instance.h"
  18
  19 #include <algorithm>
  20 #include <mutex>
  21 #include <thread>
  22 #include <vector>
  23
  24 #include "common/logger.h"
  25 #include "common/scope_exit.h"
  26 #include "common/tools.h"
  27
  28 #include "iotcon/iotcon_client_manager.h"
  29 #include "iotcon/iotcon_manager.h"
  30 #include "iotcon/iotcon_server_manager.h"
  31 #include "iotcon/iotcon_utils.h"
  32
  33 #include "common/filesystem/filesystem_provider.h"
  34
  35 namespace extension {
  36 namespace iotcon {
  37
  38 namespace {
  39 const std::string kPrivilegeIotcon = "http://tizen.org/privilege/internet";
  40
  41 struct CallbackData {
  42   common::PostCallback fun;
  43   CallbackData(common::PostCallback f) {
  44     fun = f;
  45   }
  46 };
  47
  48 long long GetId(const picojson::object& args) {
  49   return static_cast<long long>(args.find(kId)->second.get<double>());
  50 }
  51
  52 // CallbackDataManager was created to prevent crash that may occur when
  53 // the same callback will be called twice in RemoteResourceResponseCallback
  54 // (The native api allow that same callback will be called more than once)
  55 class CallbackDataManager {
  56  public:
  57   static CallbackDataManager* GetInstance();
  58   void Add(CallbackData* data);
  59   bool IfExists(CallbackData* data);
  60
  61  private:
  62   CallbackDataManager(){};
  63   CallbackDataManager(const CallbackDataManager&) = delete;
  64   CallbackDataManager(const CallbackDataManager&&) = delete;
  65   CallbackDataManager& operator=(const CallbackDataManager&) = delete;
  66   CallbackDataManager& operator=(const CallbackDataManager&&) = delete;
  67   ~CallbackDataManager(){};
  68   std::vector<CallbackData*> callback_;
  69   std::mutex callback_mtx_;
  70 };
  71
  72 CallbackDataManager* CallbackDataManager::GetInstance() {
  73   ScopeLogger();
  74   static CallbackDataManager instance;
  75   return &instance;
  76 }
  77
  78 void CallbackDataManager::Add(CallbackData* data) {
  79   ScopeLogger();
  80   std::lock_guard<std::mutex> lock(callback_mtx_);
  81   callback_.push_back(data);
  82 }
  83
  84 bool CallbackDataManager::IfExists(CallbackData* data) {
  85   ScopeLogger();
  86   std::lock_guard<std::mutex> lock(callback_mtx_);
  87   std::vector<CallbackData*>::iterator it;
  88   it = find(callback_.begin(), callback_.end(), data);
  89   return (it != callback_.end());
  90 }
  91
  92 void RemoteResourceResponseCallback(iotcon_remote_resource_h resource, iotcon_error_e err,
  93                                     iotcon_request_type_e request_type, iotcon_response_h response,
  94                                     void* user_data) {
  95   ScopeLogger();
  96
  97   std::unique_ptr<CallbackData> data{static_cast<CallbackData*>(user_data)};
  98
  99   if (data) {
 100     picojson::value value{picojson::object{}};
 101     common::TizenResult ret = common::TizenSuccess();
 102
 103     switch (err) {
 104       case IOTCON_ERROR_NONE:
 105         ret = IotconUtils::ResponseToJson(response, &value.get<picojson::object>());
 106         if (CallbackDataManager::GetInstance()->IfExists(data.get())) {
 107           LoggerD("user_data was called earlier, so ignore.");
 108           return;
 109         }
 110         break;
 111       case IOTCON_ERROR_TIMEOUT:
 112         LoggerD("IOTCON_TIMEOUT");
 113         ret = IotconUtils::ConvertIotconError(err);
 114         if (CallbackDataManager::GetInstance()->IfExists(data.get())) {
 115           LoggerD("user_data was called earlier, so ignore.");
 116           return;
 117         }
 118         break;
 119       default:
 120         ret = IotconUtils::ConvertIotconError(err);
 121         if (CallbackDataManager::GetInstance()->IfExists(data.get())) {
 122           LoggerD("user_data was called earlier, so ignore.");
 123           return;
 124         }
 125         break;
 126     }
 127     CallbackDataManager::GetInstance()->Add(data.get());
 128     data->fun(ret, value);
 129     data.release();
 130   } else {
 131     LoggerE("Native callback data is null");
 132   }
 133 }
 134
 135 const common::ListenerToken kGeneratedPinToken{"GeneratedPinListener"};
 136 const common::ListenerToken kResourceRequestListenerToken{"ResourceRequestListener"};
 137 const common::ListenerToken kFindResourceListenerToken{"FindResourceListener"};
 138 const common::ListenerToken kFindDeviceInfoListenerToken{"FindDeviceInfoListener"};
 139 const common::ListenerToken kFindPlatformInfoListenerToken{"FindPlatformInfoListener"};
 140 const common::ListenerToken kPresenceEventListenerToken{"PresenceEventListener"};
 141 const common::ListenerToken kRemoteResourceStateChangeListener{"RemoteResourceStateChangeListener"};
 142 const common::ListenerToken kRemoteResourceChangeListener{"RemoteResourceChangeListener"};
 143 const common::ListenerToken kRemoteResourceCacheChangeListener{"RemoteResourceCacheChangeListener"};
 144
 145 const std::string kObserverIds = "observerIds";
 146 const std::string kQos = "qos";
 147 const std::string kChildId = "childId";
 148 const std::string kTypes = "types";
 149 const std::string kInterface = "iface";
 150 const std::string kResult = "result";
 151 const std::string kTimeout = "timeout";
 152 const std::string kData = "data";
 153 const std::string kFilePath = "filePath";
 154 const std::string kTimeToLive = "timeToLive";
 155
 156 const std::string kTimeInterval = "timeInterval";
 157
 158 const std::string kVirtualResourcesHandlingPath = "/home/owner/share/tmp_file_iotcon.dat";
 159
 160 }  // namespace
 161
 162 IotconInstance::IotconInstance()
 163     : initialized_(false),
 164       presence_started_(false),
 165       observing_started_(false),
 166       caching_started_(false),
 167       monitoring_started_(false) {
 168   ScopeLogger();
 169
 170   using std::placeholders::_1;
 171   using std::placeholders::_2;
 172
 173 #define REGISTER_SYNC(c, x) RegisterSyncHandler(c, std::bind(&IotconInstance::x, this, _1))
 174
 175   REGISTER_SYNC("IotconResource_getObserverIds", ResourceGetObserverIds);
 176   REGISTER_SYNC("IotconResource_notify", ResourceNotify);
 177   REGISTER_SYNC("IotconResource_addResourceTypes", ResourceAddResourceTypes);
 178   REGISTER_SYNC("IotconResource_addResourceInterface", ResourceAddResourceInterface);
 179   REGISTER_SYNC("IotconResource_addChildResource", ResourceAddChildResource);
 180   REGISTER_SYNC("IotconResource_removeChildResource", ResourceRemoveChildResource);
 181   REGISTER_SYNC("IotconResource_setRequestListener", ResourceSetRequestListener);
 182   REGISTER_SYNC("IotconResource_unsetRequestListener", ResourceUnsetRequestListener);
 183   REGISTER_SYNC("IotconResponse_send", ResponseSend);
 184   REGISTER_SYNC("IotconRemoteResource_getCachedRepresentation",
 185                 RemoteResourceGetCachedRepresentation);
 186   REGISTER_SYNC("IotconRemoteResource_getOptions", RemoteResourceGetOptions);
 187   REGISTER_SYNC("IotconRemoteResource_setOptions", RemoteResourceSetOptions);
 188   REGISTER_SYNC("IotconRemoteResource_startObserving", RemoteResourceStartObserving);
 189   REGISTER_SYNC("IotconRemoteResource_stopObserving", RemoteResourceStopObserving);
 190   REGISTER_SYNC("IotconRemoteResource_startCaching", RemoteResourceStartCaching);
 191   REGISTER_SYNC("IotconRemoteResource_stopCaching", RemoteResourceStopCaching);
 192   REGISTER_SYNC("IotconRemoteResource_setResourceStateChangeListener",
 193                 RemoteResourceSetResourceStateChangeListener);
 194   REGISTER_SYNC("IotconRemoteResource_unsetResourceStateChangeListener",
 195                 RemoteResourceUnsetResourceStateChangeListener);
 196   REGISTER_SYNC("IotconRemoteResource_getTimeInterval", RemoteResourceGetTimeInterval);
 197   REGISTER_SYNC("IotconRemoteResource_setTimeInterval", RemoteResourceSetTimeInterval);
 198   REGISTER_SYNC("IotconClient_addPresenceEventListener", ClientAddPresenceEventListener);
 199   REGISTER_SYNC("IotconClient_removePresenceEventListener", ClientRemovePresenceEventListener);
 200   REGISTER_SYNC("Iotcon_initialize", Initialize);
 201   REGISTER_SYNC("Iotcon_getTimeout", GetTimeout);
 202   REGISTER_SYNC("Iotcon_setTimeout", SetTimeout);
 203   REGISTER_SYNC("Iotcon_addGeneratedPinListener", AddGeneratedPinListener);
 204   REGISTER_SYNC("Iotcon_removeGeneratedPinListener", RemoveGeneratedPinListener);
 205   REGISTER_SYNC("IotconServer_createResource", ServerCreateResource);
 206   REGISTER_SYNC("IotconServer_removeResource", ServerRemoveResource);
 207   REGISTER_SYNC("IotconServer_startPresence", ServerStartPresence);
 208   REGISTER_SYNC("IotconServer_stopPresence", ServerStopPresence);
 209   REGISTER_SYNC("Iotcon_setDeviceName", SetDeviceName);
 210   REGISTER_SYNC("IotconClient_findResource", ClientFindResource);
 211   REGISTER_SYNC("IotconClient_findDeviceInfo", ClientFindDeviceInfo);
 212   REGISTER_SYNC("IotconClient_findPlatformInfo", ClientFindPlatformInfo);
 213 #undef REGISTER_SYNC
 214
 215 #define REGISTER_ASYNC(c, x) RegisterHandler(c, std::bind(&IotconInstance::x, this, _1, _2));
 216
 217   REGISTER_ASYNC("IotconRemoteResource_methodGet", RemoteResourceMethodGet);
 218   REGISTER_ASYNC("IotconRemoteResource_methodPut", RemoteResourceMethodPut);
 219   REGISTER_ASYNC("IotconRemoteResource_methodPost", RemoteResourceMethodPost);
 220   REGISTER_ASYNC("IotconRemoteResource_methodDelete", RemoteResourceMethodDelete);
 221
 222 #undef REGISTER_ASYNC
 223 }
 224
 225 IotconInstance::~IotconInstance() {
 226   ScopeLogger();
 227
 228   if (presence_started_) {
 229     iotcon_stop_presence();
 230     presence_started_ = false;
 231     LoggerD("Iotcon service presence stopped");
 232   }
 233
 234   if (initialized_) {
 235     iotcon_deinitialize();
 236     initialized_ = false;
 237     LoggerD("Iotcon service deinitialized");
 238   }
 239 }
 240
 241 common::TizenResult IotconInstance::ResourceGetObserverIds(const picojson::object& args) {
 242   ScopeLogger();
 243
 244   CHECK_EXIST(args, kId);
 245
 246   ResourceInfoPtr resource;
 247   auto result = IotconServerManager::GetInstance().GetResourceById(GetId(args), &resource);
 248
 249   if (!result) {
 250     LogAndReturnTizenError(result, ("GetResourceById() failed"));
 251   }
 252
 253   picojson::value value{picojson::array{}};
 254   auto& arr = value.get<picojson::array>();
 255
 256   for (auto id : resource->observers) {
 257     arr.push_back(picojson::value{static_cast<double>(id)});
 258   }
 259
 260   return common::TizenSuccess(value);
 261 }
 262
 263 common::TizenResult IotconInstance::ResourceNotify(const picojson::object& args) {
 264   ScopeLogger();
 265
 266   CHECK_PRIVILEGE(kPrivilegeIotcon);
 267
 268   CHECK_EXIST(args, kId);
 269   CHECK_EXIST(args, kQos);
 270   CHECK_EXIST(args, kAttributes);
 271
 272   ResourceInfoPtr resource;
 273   long long id = GetId(args);
 274   auto result = IotconServerManager::GetInstance().GetResourceById(id, &resource);
 275
 276   if (!result) {
 277     LogAndReturnTizenError(result, ("GetResourceById() failed"));
 278   }
 279
 280   auto& qos = IotconUtils::GetArg(args, kQos);
 281   if (!qos.is<std::string>()) {
 282     return common::TypeMismatchError("QOS needs to be a string");
 283   }
 284
 285   // create observers to notify
 286   auto& observer_ids = IotconUtils::GetArg(args, kObserverIds);
 287
 288   std::vector<int> observers;
 289
 290   if (observer_ids.is<picojson::array>()) {
 291     // use provided list, make sure that observer exists
 292     for (auto& id : observer_ids.get<picojson::array>()) {
 293       if (id.is<double>()) {
 294         auto v = static_cast<int>(id.get<double>());
 295         if (resource->observers.end() != resource->observers.find(v)) {
 296           observers.push_back(v);
 297         }
 298       }
 299     }
 300   } else {
 301     // use own list
 302     observers.assign(resource->observers.begin(), resource->observers.end());
 303   }
 304
 305   // create & initialize platform object
 306   iotcon_observers_h observers_handle = nullptr;
 307   result = IotconUtils::ConvertIotconError(iotcon_observers_create(&observers_handle));
 308   if (!result) {
 309     LogAndReturnTizenError(result, ("iotcon_observers_create() failed"));
 310   }
 311
 312   SCOPE_EXIT {
 313     iotcon_observers_destroy(observers_handle);
 314   };
 315
 316   for (auto& id : observers) {
 317     result = IotconUtils::ConvertIotconError(iotcon_observers_add(observers_handle, id));
 318     if (!result) {
 319       LogAndReturnTizenError(result, ("iotcon_observers_add() failed"));
 320     }
 321   }
 322
 323   // create representation from resource and attributes
 324   iotcon_representation_h representation = nullptr;
 325
 326   result = IotconUtils::RepresentationFromResource(resource, IotconUtils::GetArg(args, kAttributes),
 327                                                    &representation);
 328   if (!result) {
 329     LogAndReturnTizenError(result, ("RepresentationFromResource() failed"));
 330   }
 331
 332   SCOPE_EXIT {
 333     iotcon_representation_destroy(representation);
 334   };
 335
 336   result = IotconUtils::ConvertIotconError(
 337       iotcon_resource_notify(resource->handle, representation, observers_handle,
 338                              IotconUtils::ToQos(qos.get<std::string>())));
 339   if (!result) {
 340     LogAndReturnTizenError(result, ("iotcon_resource_notify() failed"));
 341   }
 342
 343   return common::TizenSuccess();
 344 }
 345
 346 common::TizenResult IotconInstance::ResourceAddResourceTypes(const picojson::object& args) {
 347   ScopeLogger();
 348
 349   CHECK_PRIVILEGE(kPrivilegeIotcon);
 350
 351   CHECK_EXIST(args, kId);
 352   CHECK_EXIST(args, kTypes);
 353
 354   ResourceInfoPtr resource;
 355   auto result = IotconServerManager::GetInstance().GetResourceById(GetId(args), &resource);
 356   if (!result) {
 357     LogAndReturnTizenError(result, ("GetResourceById() failed"));
 358   }
 359
 360   const auto& types = IotconUtils::GetArg(args, kTypes).get<picojson::array>();
 361
 362   for (const auto& type : types) {
 363     int ret = iotcon_resource_bind_type(resource->handle, type.get<std::string>().c_str());
 364     if (IOTCON_ERROR_NONE != ret && IOTCON_ERROR_ALREADY != ret) {
 365       LogAndReturnTizenError(IotconUtils::ConvertIotconError(ret),
 366                              ("iotcon_resource_bind_type() failed"));
 367     }
 368   }
 369
 370   return common::TizenSuccess();
 371 }
 372
 373 common::TizenResult IotconInstance::ResourceAddResourceInterface(const picojson::object& args) {
 374   ScopeLogger();
 375
 376   CHECK_PRIVILEGE(kPrivilegeIotcon);
 377
 378   CHECK_EXIST(args, kId);
 379   CHECK_EXIST(args, kInterface);
 380
 381   ResourceInfoPtr resource;
 382   auto result = IotconServerManager::GetInstance().GetResourceById(GetId(args), &resource);
 383   if (!result) {
 384     LogAndReturnTizenError(result, ("GetResourceById() failed"));
 385   }
 386
 387   int ret = iotcon_resource_bind_interface(
 388       resource->handle, IotconUtils::GetArg(args, kInterface).get<std::string>().c_str());
 389   if (IOTCON_ERROR_NONE != ret && IOTCON_ERROR_ALREADY != ret) {
 390     LogAndReturnTizenError(IotconUtils::ConvertIotconError(ret),
 391                            ("iotcon_resource_bind_interface() failed"));
 392   }
 393
 394   return common::TizenSuccess();
 395 }
 396
 397 common::TizenResult IotconInstance::ResourceAddChildResource(const picojson::object& args) {
 398   ScopeLogger();
 399
 400   CHECK_PRIVILEGE(kPrivilegeIotcon);
 401
 402   CHECK_EXIST(args, kId);
 403   CHECK_EXIST(args, kChildId);
 404
 405   ResourceInfoPtr parent;
 406   auto result = IotconServerManager::GetInstance().GetResourceById(GetId(args), &parent);
 407   if (!result) {
 408     LogAndReturnTizenError(result, ("GetResourceById() parent failed"));
 409   }
 410
 411   long long child_id = static_cast<long long>(IotconUtils::GetArg(args, kChildId).get<double>());
 412   ResourceInfoPtr child;
 413
 414   result = IotconServerManager::GetInstance().GetResourceById(child_id, &child);
 415   if (!result) {
 416     LogAndReturnTizenError(result, ("GetResourceById() failed"));
 417   }
 418
 419   int ret = iotcon_resource_bind_child_resource(parent->handle, child->handle);
 420   if (IOTCON_ERROR_NONE != ret && IOTCON_ERROR_ALREADY != ret) {
 421     LogAndReturnTizenError(IotconUtils::ConvertIotconError(ret),
 422                            ("iotcon_resource_bind_child_resource() failed"));
 423   }
 424
 425   parent->children.insert(child);
 426   child->parents.insert(parent);
 427
 428   return common::TizenSuccess();
 429 }
 430
 431 common::TizenResult IotconInstance::ResourceRemoveChildResource(const picojson::object& args) {
 432   ScopeLogger();
 433
 434   CHECK_PRIVILEGE(kPrivilegeIotcon);
 435
 436   CHECK_EXIST(args, kId);
 437   CHECK_EXIST(args, kChildId);
 438
 439   ResourceInfoPtr parent;
 440   auto result = IotconServerManager::GetInstance().GetResourceById(GetId(args), &parent);
 441   if (!result) {
 442     LogAndReturnTizenError(result, ("GetResourceById() parent failed"));
 443   }
 444
 445   long long child_id = static_cast<long long>(IotconUtils::GetArg(args, kChildId).get<double>());
 446   ResourceInfoPtr child;
 447
 448   result = IotconServerManager::GetInstance().GetResourceById(child_id, &child);
 449   if (!result) {
 450     LogAndReturnTizenError(result, ("GetResourceById() failed"));
 451   }
 452
 453   result = IotconUtils::ConvertIotconError(
 454       iotcon_resource_unbind_child_resource(parent->handle, child->handle));
 455   if (!result) {
 456     LogAndReturnTizenError(result, ("iotcon_resource_unbind_child_resource() failed"));
 457   }
 458
 459   parent->children.erase(child);
 460   child->parents.erase(parent);
 461
 462   return common::TizenSuccess();
 463 }
 464
 465 common::TizenResult IotconInstance::ResourceSetRequestListener(const picojson::object& args) {
 466   ScopeLogger();
 467
 468   CHECK_EXIST(args, kId);
 469
 470   ResourceInfoPtr resource;
 471   long long id = GetId(args);
 472   auto result = IotconServerManager::GetInstance().GetResourceById(id, &resource);
 473
 474   if (!result) {
 475     return result;
 476   }
 477
 478   if (!resource->request_listener) {
 479     resource->request_listener = [this, id](const common::TizenResult&, const picojson::value& v) {
 480       ScopeLogger("Entered into asynchronous function, resource->request_listener");
 481       picojson::value request{picojson::object{}};
 482       auto& obj = request.get<picojson::object>();
 483
 484       obj.insert(std::make_pair(kId, picojson::value{static_cast<double>(id)}));
 485       obj.insert(std::make_pair(kData, v));
 486
 487       Post(kResourceRequestListenerToken, common::TizenSuccess{request});
 488     };
 489   }
 490
 491   return common::TizenSuccess();
 492 }
 493
 494 common::TizenResult IotconInstance::ResourceUnsetRequestListener(const picojson::object& args) {
 495   ScopeLogger();
 496
 497   CHECK_EXIST(args, kId);
 498
 499   ResourceInfoPtr resource;
 500   auto result = IotconServerManager::GetInstance().GetResourceById(GetId(args), &resource);
 501
 502   if (!result) {
 503     return result;
 504   }
 505
 506   resource->request_listener = nullptr;
 507
 508   return common::TizenSuccess();
 509 }
 510
 511 common::TizenResult IotconInstance::ResponseSend(const picojson::object& args) {
 512   ScopeLogger();
 513
 514   CHECK_EXIST(args, kId);
 515   CHECK_EXIST(args, kResult);
 516   CHECK_EXIST(args, kRepresentation);
 517   CHECK_EXIST(args, kOptions);
 518
 519   ResponsePtr response = nullptr;
 520   auto result = IotconServerManager::GetInstance().GetResponseById(GetId(args), &response);
 521   if (!result) {
 522     LogAndReturnTizenError(result, ("GetResponseById() failed"));
 523   }
 524
 525   {
 526     const auto& js_response_result = IotconUtils::GetArg(args, kResult);
 527     if (!js_response_result.is<std::string>()) {
 528       return LogAndCreateTizenError(TypeMismatchError, "ResponseResult should be a string");
 529     }
 530     iotcon_response_result_e response_result =
 531         IotconUtils::ToResponseResult(js_response_result.get<std::string>());
 532
 533     result = IotconUtils::ConvertIotconError(
 534         iotcon_response_set_result(response.get(), response_result));
 535     if (!result) {
 536       LogAndReturnTizenError(result, ("iotcon_response_set_result() failed"));
 537     }
 538   }
 539
 540   {
 541     const auto& js_representation = IotconUtils::GetArg(args, kRepresentation);
 542     if (!js_representation.is<picojson::object>()) {
 543       return LogAndCreateTizenError(TypeMismatchError, "Representation should be an object");
 544     }
 545     iotcon_representation_h representation = nullptr;
 546     result = IotconUtils::RepresentationFromJson(js_representation.get<picojson::object>(),
 547                                                  &representation);
 548     if (!result) {
 549       LogAndReturnTizenError(result, ("RepresentationFromJson() failed"));
 550     }
 551     SCOPE_EXIT {
 552       iotcon_representation_destroy(representation);
 553     };
 554
 555     result = IotconUtils::ConvertIotconError(
 556         iotcon_response_set_representation(response.get(), representation));
 557     if (!result) {
 558       LogAndReturnTizenError(result, ("iotcon_response_set_representation() failed"));
 559     }
 560   }
 561
 562   {
 563     const auto& js_options = IotconUtils::GetArg(args, kOptions);
 564
 565     if (js_options.is<picojson::array>()) {
 566       iotcon_options_h options = nullptr;
 567
 568       result = IotconUtils::OptionsFromJson(js_options.get<picojson::array>(), &options);
 569       if (!result) {
 570         LogAndReturnTizenError(result, ("OptionsFromJson() failed"));
 571       }
 572       SCOPE_EXIT {
 573         iotcon_options_destroy(options);
 574       };
 575
 576       result =
 577           IotconUtils::ConvertIotconError(iotcon_response_set_options(response.get(), options));
 578       if (!result) {
 579         LogAndReturnTizenError(result, ("iotcon_response_set_options() failed"));
 580       }
 581     }
 582   }
 583
 584   result = IotconUtils::ConvertIotconError(iotcon_response_send(response.get()));
 585   if (!result) {
 586     LogAndReturnTizenError(result, ("iotcon_response_send() failed"));
 587   }
 588
 589   return common::TizenSuccess();
 590 }
 591
 592 common::TizenResult IotconInstance::RemoteResourceGetCachedRepresentation(
 593     const picojson::object& args) {
 594   ScopeLogger();
 595
 596   FoundRemoteInfoPtr ptr;
 597   auto res = IotconUtils::RemoteResourceFromJson(args, &ptr);
 598   if (!res) {
 599     LogAndReturnTizenError(res, ("Failed to build resource using json data"));
 600   }
 601   iotcon_representation_h representation = nullptr;
 602   res = IotconUtils::ConvertIotconError(
 603       iotcon_remote_resource_get_cached_representation(ptr->handle, &representation));
 604   if (!res) {
 605     LogAndReturnTizenError(res, ("Gathering cached representation failed"));
 606   }
 607   if (representation) {
 608     picojson::value repr_json{picojson::object{}};
 609     res = IotconUtils::RepresentationToJson(representation, &repr_json.get<picojson::object>());
 610     if (!res) {
 611       LogAndReturnTizenError(res, ("RepresentationToJson() failed"));
 612     }
 613     return common::TizenSuccess{repr_json};
 614   }
 615   return common::AbortError("Failed to gather cached representation");
 616 }
 617
 618 common::TizenResult IotconInstance::RemoteResourceGetOptions(const picojson::object& args) {
 619   ScopeLogger();
 620
 621   FoundRemoteInfoPtr ptr;
 622   auto res = IotconUtils::RemoteResourceFromJson(args, &ptr);
 623   if (!res) {
 624     LogAndReturnTizenError(res, ("Failed to build resource using json data"));
 625   }
 626
 627   iotcon_options_h options = nullptr;
 628   res = IotconUtils::ConvertIotconError(iotcon_remote_resource_get_options(ptr->handle, &options));
 629   if (!res) {
 630     LogAndReturnTizenError(res, ("Gathering options failed"));
 631   }
 632
 633   if (options) {
 634     picojson::array options_array;
 635     res = IotconUtils::OptionsToJson(options, &options_array);
 636     if (!res) {
 637       LogAndReturnTizenError(res, ("OptionsToJson() failed"));
 638     }
 639     return common::TizenSuccess{picojson::value(options_array)};
 640   }
 641
 642   return common::AbortError("Failed to gather options");
 643 }
 644
 645 common::TizenResult IotconInstance::RemoteResourceSetOptions(const picojson::object& args) {
 646   ScopeLogger();
 647   CHECK_EXIST(args, kOptions);
 648
 649   FoundRemoteInfoPtr ptr;
 650   auto res = IotconUtils::RemoteResourceFromJson(args, &ptr);
 651   if (!res) {
 652     LogAndReturnTizenError(res, ("Failed to build resource using json data"));
 653   }
 654
 655   // default value would be null (if provided value is not an array)
 656   iotcon_options_h options = nullptr;
 657   const auto& options_it = args.find(kOptions);
 658   if (options_it->second.is<picojson::array>()) {
 659     // if it is an array use provided values
 660     const auto& options_array = options_it->second.get<picojson::array>();
 661     res = IotconUtils::OptionsFromJson(options_array, &options);
 662     if (!res) {
 663       return res;
 664     }
 665   }
 666
 667   res = IotconUtils::ConvertIotconError(iotcon_remote_resource_set_options(ptr->handle, options));
 668   if (!res) {
 669     LogAndReturnTizenError(res, ("iotcon_response_set_options() failed"));
 670   }
 671
 672   return common::TizenSuccess{IotconClientManager::GetInstance().StoreRemoteResource(ptr)};
 673 }
 674
 675 common::TizenResult IotconInstance::RemoteResourceMethodGet(const picojson::object& args,
 676                                                             const common::AsyncToken& token) {
 677   ScopeLogger();
 678
 679   CHECK_PRIVILEGE(kPrivilegeIotcon);
 680
 681   FoundRemoteInfoPtr resource;
 682   auto result = IotconUtils::RemoteResourceFromJson(args, &resource);
 683   if (!result) {
 684     LogAndReturnTizenError(result, ("RemoteResourceFromJson() failed"));
 685   }
 686
 687   iotcon_query_h query = nullptr;
 688   const auto& query_it = args.find(kQuery);
 689   if (args.end() != query_it) {
 690     result = IotconUtils::QueryFromJson(query_it->second.get<picojson::object>(), &query);
 691     if (!result) {
 692       LogAndReturnTizenError(result, ("QueryFromJson() failed"));
 693     }
 694   }
 695   SCOPE_EXIT {
 696     if (query) {
 697       iotcon_query_destroy(query);
 698     }
 699   };
 700
 701   std::unique_ptr<CallbackData> data{new CallbackData{PostForMethodCall(token, resource)}};
 702
 703   // set options to the remote resource
 704   const auto& js_options = IotconUtils::GetArg(args, kOptions);
 705
 706   if (js_options.is<picojson::array>()) {
 707     iotcon_options_h options = nullptr;
 708
 709     result = IotconUtils::OptionsFromJson(js_options.get<picojson::array>(), &options);
 710     if (!result) {
 711       LogAndReturnTizenError(result, ("OptionsFromJson() failed"));
 712     }
 713     SCOPE_EXIT {
 714       iotcon_options_destroy(options);
 715     };
 716
 717     result = IotconUtils::ConvertIotconError(
 718         iotcon_remote_resource_set_options(resource->handle, options));
 719     if (!result) {
 720       LogAndReturnTizenError(result, ("iotcon_response_set_options() failed"));
 721     }
 722   }
 723
 724   result = IotconUtils::ConvertIotconError(iotcon_remote_resource_get(
 725       resource->handle, query, RemoteResourceResponseCallback, data.get()));
 726   if (!result) {
 727     LogAndReturnTizenError(result, ("iotcon_remote_resource_get() failed"));
 728   }
 729
 730   // release memory ownership
 731   data.release();
 732
 733   return common::TizenSuccess{IotconClientManager::GetInstance().StoreRemoteResource(resource)};
 734 }
 735
 736 common::TizenResult IotconInstance::RemoteResourceMethodPut(const picojson::object& args,
 737                                                             const common::AsyncToken& token) {
 738   ScopeLogger();
 739
 740   CHECK_PRIVILEGE(kPrivilegeIotcon);
 741
 742   CHECK_EXIST(args, kRepresentation);
 743
 744   FoundRemoteInfoPtr resource;
 745   auto result = IotconUtils::RemoteResourceFromJson(args, &resource);
 746   if (!result) {
 747     LogAndReturnTizenError(result, ("RemoteResourceFromJson() failed"));
 748   }
 749
 750   iotcon_representation_h representation = nullptr;
 751   result = IotconUtils::RepresentationFromJson(
 752       IotconUtils::GetArg(args, kRepresentation).get<picojson::object>(), &representation);
 753   if (!result) {
 754     LogAndReturnTizenError(result, ("RepresentationFromJson() failed"));
 755   }
 756   SCOPE_EXIT {
 757     iotcon_representation_destroy(representation);
 758   };
 759
 760   iotcon_query_h query = nullptr;
 761   const auto& query_it = args.find(kQuery);
 762   if (args.end() != query_it) {
 763     result = IotconUtils::QueryFromJson(query_it->second.get<picojson::object>(), &query);
 764     if (!result) {
 765       LogAndReturnTizenError(result, ("QueryFromJson() failed"));
 766     }
 767   }
 768   SCOPE_EXIT {
 769     if (query) {
 770       iotcon_query_destroy(query);
 771     }
 772   };
 773
 774   std::unique_ptr<CallbackData> data{new CallbackData{PostForMethodCall(token, resource)}};
 775
 776   // set options to the remote resource
 777   const auto& js_options = IotconUtils::GetArg(args, kOptions);
 778
 779   if (js_options.is<picojson::array>()) {
 780     iotcon_options_h options = nullptr;
 781
 782     result = IotconUtils::OptionsFromJson(js_options.get<picojson::array>(), &options);
 783     if (!result) {
 784       LogAndReturnTizenError(result, ("OptionsFromJson() failed"));
 785     }
 786     SCOPE_EXIT {
 787       iotcon_options_destroy(options);
 788     };
 789
 790     result = IotconUtils::ConvertIotconError(
 791         iotcon_remote_resource_set_options(resource->handle, options));
 792     if (!result) {
 793       LogAndReturnTizenError(result, ("iotcon_response_set_options() failed"));
 794     }
 795   }
 796
 797   result = IotconUtils::ConvertIotconError(iotcon_remote_resource_put(
 798       resource->handle, representation, query, RemoteResourceResponseCallback, data.get()));
 799   if (!result) {
 800     LogAndReturnTizenError(result, ("iotcon_remote_resource_put() failed"));
 801   }
 802
 803   // release memory ownership
 804   data.release();
 805
 806   return common::TizenSuccess{IotconClientManager::GetInstance().StoreRemoteResource(resource)};
 807 }
 808
 809 common::TizenResult IotconInstance::RemoteResourceMethodPost(const picojson::object& args,
 810                                                              const common::AsyncToken& token) {
 811   ScopeLogger();
 812
 813   CHECK_PRIVILEGE(kPrivilegeIotcon);
 814
 815   CHECK_EXIST(args, kRepresentation);
 816
 817   FoundRemoteInfoPtr resource;
 818   auto result = IotconUtils::RemoteResourceFromJson(args, &resource);
 819   if (!result) {
 820     LogAndReturnTizenError(result, ("RemoteResourceFromJson() failed"));
 821   }
 822
 823   iotcon_representation_h representation = nullptr;
 824   result = IotconUtils::RepresentationFromJson(
 825       IotconUtils::GetArg(args, kRepresentation).get<picojson::object>(), &representation);
 826   if (!result) {
 827     LogAndReturnTizenError(result, ("RepresentationFromJson() failed"));
 828   }
 829   SCOPE_EXIT {
 830     iotcon_representation_destroy(representation);
 831   };
 832
 833   iotcon_query_h query = nullptr;
 834   const auto& query_it = args.find(kQuery);
 835   if (args.end() != query_it) {
 836     result = IotconUtils::QueryFromJson(query_it->second.get<picojson::object>(), &query);
 837     if (!result) {
 838       LogAndReturnTizenError(result, ("QueryFromJson() failed"));
 839     }
 840   }
 841   SCOPE_EXIT {
 842     if (query) {
 843       iotcon_query_destroy(query);
 844     }
 845   };
 846
 847   std::unique_ptr<CallbackData> data{new CallbackData{PostForMethodCall(token, resource)}};
 848
 849   // set options to the remote resource
 850   const auto& js_options = IotconUtils::GetArg(args, kOptions);
 851
 852   if (js_options.is<picojson::array>()) {
 853     iotcon_options_h options = nullptr;
 854
 855     result = IotconUtils::OptionsFromJson(js_options.get<picojson::array>(), &options);
 856     if (!result) {
 857       LogAndReturnTizenError(result, ("OptionsFromJson() failed"));
 858     }
 859     SCOPE_EXIT {
 860       iotcon_options_destroy(options);
 861     };
 862
 863     result = IotconUtils::ConvertIotconError(
 864         iotcon_remote_resource_set_options(resource->handle, options));
 865     if (!result) {
 866       LogAndReturnTizenError(result, ("iotcon_response_set_options() failed"));
 867     }
 868   }
 869
 870   result = IotconUtils::ConvertIotconError(iotcon_remote_resource_post(
 871       resource->handle, representation, query, RemoteResourceResponseCallback, data.get()));
 872   if (!result) {
 873     LogAndReturnTizenError(result, ("iotcon_remote_resource_post() failed"));
 874   }
 875
 876   // release memory ownership
 877   data.release();
 878
 879   return common::TizenSuccess{IotconClientManager::GetInstance().StoreRemoteResource(resource)};
 880 }
 881
 882 common::TizenResult IotconInstance::RemoteResourceMethodDelete(const picojson::object& args,
 883                                                                const common::AsyncToken& token) {
 884   ScopeLogger();
 885
 886   CHECK_PRIVILEGE(kPrivilegeIotcon);
 887
 888   FoundRemoteInfoPtr resource;
 889   auto result = IotconUtils::RemoteResourceFromJson(args, &resource);
 890   if (!result) {
 891     LogAndReturnTizenError(result, ("RemoteResourceFromJson() failed"));
 892   }
 893
 894   std::unique_ptr<CallbackData> data{new CallbackData{PostForMethodCall(token, resource)}};
 895
 896   // set options to the remote resource
 897   const auto& js_options = IotconUtils::GetArg(args, kOptions);
 898
 899   if (js_options.is<picojson::array>()) {
 900     iotcon_options_h options = nullptr;
 901
 902     result = IotconUtils::OptionsFromJson(js_options.get<picojson::array>(), &options);
 903     if (!result) {
 904       LogAndReturnTizenError(result, ("OptionsFromJson() failed"));
 905     }
 906     SCOPE_EXIT {
 907       iotcon_options_destroy(options);
 908     };
 909
 910     result = IotconUtils::ConvertIotconError(
 911         iotcon_remote_resource_set_options(resource->handle, options));
 912     if (!result) {
 913       LogAndReturnTizenError(result, ("iotcon_response_set_options() failed"));
 914     }
 915   }
 916
 917   result = IotconUtils::ConvertIotconError(
 918       iotcon_remote_resource_delete(resource->handle, RemoteResourceResponseCallback, data.get()));
 919   if (!result) {
 920     LogAndReturnTizenError(result, ("iotcon_remote_resource_delete() failed"));
 921   }
 922
 923   // release memory ownership
 924   data.release();
 925
 926   return common::TizenSuccess{IotconClientManager::GetInstance().StoreRemoteResource(resource)};
 927 }
 928
 929 static void ObserveCallback(iotcon_remote_resource_h resource, iotcon_error_e err,
 930                             int sequence_number, iotcon_response_h response, void* user_data) {
 931   ScopeLogger();
 932   long long* id = static_cast<long long*>(user_data);
 933
 934   FoundRemoteInfoPtr ptr = IotconClientManager::GetInstance().GetFoundRemoteInfoPtr(*id);
 935
 936   if (nullptr == ptr) {
 937     LoggerE("ObserveCallback() failed. Ignoring callback");
 938     return;
 939   }
 940
 941   if (ptr->observe_listener) {
 942     picojson::value json_result = picojson::value(picojson::object());
 943
 944     auto result = IotconUtils::ResponseToJson(response, &json_result.get<picojson::object>());
 945     if (result) {
 946       ptr->observe_listener(common::TizenSuccess(), json_result);
 947     } else {
 948       LoggerD("Ignoring callback");
 949     }
 950   }
 951 }
 952
 953 common::TizenResult IotconInstance::RemoteResourceStartObserving(const picojson::object& args) {
 954   ScopeLogger();
 955
 956   CHECK_PRIVILEGE(kPrivilegeIotcon);
 957
 958   CHECK_EXIST(args, kObservePolicy);
 959   FoundRemoteInfoPtr ptr;
 960   auto result = IotconUtils::RemoteResourceFromJson(args, &ptr);
 961   if (!result) {
 962     LogAndReturnTizenError(result, ("Failed to create remote resource handle"));
 963   }
 964
 965   iotcon_query_h query = nullptr;
 966   const auto& query_it = args.find(kQuery);
 967   if (args.end() != query_it) {
 968     result = IotconUtils::QueryFromJson(query_it->second.get<picojson::object>(), &query);
 969     if (!result) {
 970       return result;
 971     }
 972   }
 973   SCOPE_EXIT {
 974     if (query) {
 975       iotcon_query_destroy(query);
 976     }
 977   };
 978
 979   iotcon_observe_policy_e observe_policy =
 980       IotconUtils::ToObservePolicy(args.find(kObservePolicy)->second.get<std::string>().c_str());
 981
 982   ptr->observe_listener = [this, ptr](const common::TizenResult& res, const picojson::value& v) {
 983     ScopeLogger("Entered into asynchronous function, ptr->observe_listener");
 984     picojson::value response{picojson::object{}};
 985     auto& obj = response.get<picojson::object>();
 986
 987     obj.insert(std::make_pair(kId, picojson::value{static_cast<double>(ptr->id)}));
 988     obj.insert(std::make_pair(kData, v));
 989
 990     Post(kRemoteResourceChangeListener, common::TizenSuccess{response});
 991   };
 992
 993   // set options to the remote resource
 994   const auto& js_options = IotconUtils::GetArg(args, kOptions);
 995
 996   if (js_options.is<picojson::array>()) {
 997     iotcon_options_h options = nullptr;
 998
 999     result = IotconUtils::OptionsFromJson(js_options.get<picojson::array>(), &options);
1000     if (!result) {
1001       LogAndReturnTizenError(result, ("OptionsFromJson() failed"));
1002     }
1003     SCOPE_EXIT {
1004       iotcon_options_destroy(options);
1005     };
1006
1007     result =
1008         IotconUtils::ConvertIotconError(iotcon_remote_resource_set_options(ptr->handle, options));
1009     if (!result) {
1010       LogAndReturnTizenError(result, ("iotcon_response_set_options() failed"));
1011     }
1012   }
1013
1014   picojson::value ret = IotconClientManager::GetInstance().StoreRemoteResource(ptr);
1015   result = IotconUtils::ConvertIotconError(
1016       iotcon_remote_resource_observe_register(ptr->handle, observe_policy, query, ObserveCallback,
1017                                               IotconClientManager::GetInstance().Add(ptr->id)));
1018   if (!result) {
1019     IotconClientManager::GetInstance().RemoveRemoteResource(ptr);
1020     return result;
1021   }
1022
1023   observing_started_ = true;
1024   return common::TizenSuccess{ret};
1025 }
1026
1027 common::TizenResult IotconInstance::RemoteResourceStopObserving(const picojson::object& args) {
1028   ScopeLogger();
1029
1030   CHECK_PRIVILEGE(kPrivilegeIotcon);
1031
1032   if (!observing_started_) {
1033     LoggerD("Observing is not started. ignore stop observing");
1034     long long id = 0;
1035     if (args.find(kId)->second.is<double>()) {
1036       id = static_cast<long long>(args.find(kId)->second.get<double>());
1037     }
1038     return common::TizenSuccess{IotconClientManager::GetInstance().PrepareManageIdAnswer(true, id)};
1039   }
1040
1041   FoundRemoteInfoPtr ptr;
1042   auto result = IotconUtils::RemoteResourceFromJson(args, &ptr);
1043   if (!result) {
1044     LogAndReturnTizenError(result, ("Failed to create remote resource handle"));
1045   }
1046
1047   // set options to the remote resource
1048   const auto& js_options = IotconUtils::GetArg(args, kOptions);
1049
1050   if (js_options.is<picojson::array>()) {
1051     iotcon_options_h options = nullptr;
1052
1053     result = IotconUtils::OptionsFromJson(js_options.get<picojson::array>(), &options);
1054     if (!result) {
1055       LogAndReturnTizenError(result, ("OptionsFromJson() failed"));
1056     }
1057     SCOPE_EXIT {
1058       iotcon_options_destroy(options);
1059     };
1060
1061     result =
1062         IotconUtils::ConvertIotconError(iotcon_remote_resource_set_options(ptr->handle, options));
1063     if (!result) {
1064       LogAndReturnTizenError(result, ("iotcon_response_set_options() failed"));
1065     }
1066   }
1067
1068   result = IotconUtils::ConvertIotconError(iotcon_remote_resource_observe_deregister(ptr->handle));
1069   if (!result) {
1070     return result;
1071   }
1072   observing_started_ = false;
1073   ptr->observe_listener = nullptr;
1074   return common::TizenSuccess{IotconClientManager::GetInstance().RemoveRemoteResource(ptr)};
1075 }
1076
1077 static void RepresentationChangedCallback(iotcon_remote_resource_h resource,
1078                                           iotcon_representation_h representation, void* user_data) {
1079   ScopeLogger();
1080   long long* id = static_cast<long long*>(user_data);
1081
1082   FoundRemoteInfoPtr ptr = IotconClientManager::GetInstance().GetFoundRemoteInfoPtr(*id);
1083
1084   if (nullptr == ptr) {
1085     LoggerE("RepresentationChangeCallback() failed. Ignoring callback");
1086     return;
1087   }
1088
1089   if (ptr->cache_change_listener) {
1090     picojson::value json_result = picojson::value(picojson::object());
1091
1092     auto result =
1093         IotconUtils::RepresentationToJson(representation, &json_result.get<picojson::object>());
1094     if (result) {
1095       ptr->cache_change_listener(common::TizenSuccess(), json_result);
1096     } else {
1097       LoggerE("RepresentationToJson() failed.  Ignoring callback");
1098       return;
1099     }
1100   }
1101 }
1102
1103 common::TizenResult IotconInstance::RemoteResourceStartCaching(const picojson::object& args) {
1104   ScopeLogger();
1105
1106   CHECK_PRIVILEGE(kPrivilegeIotcon);
1107
1108   FoundRemoteInfoPtr ptr;
1109   auto result = IotconUtils::RemoteResourceFromJson(args, &ptr);
1110   if (!result) {
1111     LogAndReturnTizenError(result, ("Failed to create remote resource handle"));
1112   }
1113
1114   ptr->cache_change_listener = [this, ptr](const common::TizenResult& res,
1115                                            const picojson::value& v) {
1116     ScopeLogger("Entered into asynchronous function, ptr->cache_change_listener");
1117     picojson::value response{picojson::object{}};
1118     auto& obj = response.get<picojson::object>();
1119
1120     obj.insert(std::make_pair(kId, picojson::value{static_cast<double>(ptr->id)}));
1121     obj.insert(std::make_pair(kData, v));
1122
1123     Post(kRemoteResourceCacheChangeListener, common::TizenSuccess{response});
1124   };
1125
1126   picojson::value ret = IotconClientManager::GetInstance().StoreRemoteResource(ptr);
1127   result = IotconUtils::ConvertIotconError(iotcon_remote_resource_start_caching(
1128       ptr->handle, RepresentationChangedCallback, IotconClientManager::GetInstance().Add(ptr->id)));
1129   if (!result) {
1130     IotconClientManager::GetInstance().RemoveRemoteResource(ptr);
1131     return result;
1132   }
1133
1134   caching_started_ = true;
1135   return common::TizenSuccess{ret};
1136 }
1137
1138 common::TizenResult IotconInstance::RemoteResourceStopCaching(const picojson::object& args) {
1139   ScopeLogger();
1140
1141   CHECK_PRIVILEGE(kPrivilegeIotcon);
1142
1143   if (!caching_started_) {
1144     LoggerD("Caching is not started. ignore stop caching");
1145     long long id = 0;
1146     if (args.find(kId)->second.is<double>()) {
1147       id = static_cast<long long>(args.find(kId)->second.get<double>());
1148     }
1149     return common::TizenSuccess{IotconClientManager::GetInstance().PrepareManageIdAnswer(true, id)};
1150   }
1151
1152   FoundRemoteInfoPtr ptr;
1153   auto result = IotconUtils::RemoteResourceFromJson(args, &ptr);
1154   if (!result) {
1155     LogAndReturnTizenError(result, ("Failed to create remote resource handle"));
1156   }
1157
1158   result = IotconUtils::ConvertIotconError(iotcon_remote_resource_stop_caching(ptr->handle));
1159   if (!result) {
1160     return result;
1161   }
1162
1163   caching_started_ = false;
1164   ptr->cache_change_listener = nullptr;
1165   return common::TizenSuccess{IotconClientManager::GetInstance().RemoveRemoteResource(ptr)};
1166 }
1167
1168 static void MonitoringCallback(iotcon_remote_resource_h resource,
1169                                iotcon_remote_resource_state_e state, void* user_data) {
1170   ScopeLogger();
1171   long long* id = static_cast<long long*>(user_data);
1172
1173   FoundRemoteInfoPtr ptr = IotconClientManager::GetInstance().GetFoundRemoteInfoPtr(*id);
1174
1175   if (nullptr == ptr) {
1176     LoggerE("MonitoringCallback() failed. Ignoring callback");
1177     return;
1178   }
1179
1180   if (ptr->state_listener) {
1181     picojson::value json_result = picojson::value(IOTCON_REMOTE_RESOURCE_ALIVE == state);
1182     ptr->state_listener(common::TizenSuccess(), json_result);
1183   } else {
1184     LoggerD("Post function not present, just ignoring");
1185   }
1186 }
1187
1188 common::TizenResult IotconInstance::RemoteResourceSetResourceStateChangeListener(
1189     const picojson::object& args) {
1190   ScopeLogger();
1191
1192   CHECK_PRIVILEGE(kPrivilegeIotcon);
1193
1194   FoundRemoteInfoPtr ptr;
1195   auto result = IotconUtils::RemoteResourceFromJson(args, &ptr);
1196   if (!result) {
1197     LogAndReturnTizenError(result, ("Failed to create remote resource handle"));
1198   }
1199
1200   ptr->state_listener = [this, ptr](const common::TizenResult& res, const picojson::value& v) {
1201     ScopeLogger("Entered into asynchronous function, ptr->state_listener");
1202     picojson::value response{picojson::object{}};
1203     auto& obj = response.get<picojson::object>();
1204
1205     obj.insert(std::make_pair(kId, picojson::value{static_cast<double>(ptr->id)}));
1206     obj.insert(std::make_pair(kData, v));
1207
1208     Post(kRemoteResourceStateChangeListener, common::TizenSuccess{response});
1209   };
1210
1211   picojson::value ret = IotconClientManager::GetInstance().StoreRemoteResource(ptr);
1212   result = IotconUtils::ConvertIotconError(iotcon_remote_resource_start_monitoring(
1213       ptr->handle, MonitoringCallback, IotconClientManager::GetInstance().Add(ptr->id)));
1214   if (!result) {
1215     IotconClientManager::GetInstance().RemoveRemoteResource(ptr);
1216     return result;
1217   }
1218   monitoring_started_ = true;
1219   return common::TizenSuccess{ret};
1220 }
1221
1222 common::TizenResult IotconInstance::RemoteResourceUnsetResourceStateChangeListener(
1223     const picojson::object& args) {
1224   ScopeLogger();
1225
1226   CHECK_PRIVILEGE(kPrivilegeIotcon);
1227
1228   if (!monitoring_started_) {
1229     LoggerD("Monitoring is not started. ignore stop monitoring");
1230     long long id = 0;
1231     if (args.find(kId)->second.is<double>()) {
1232       id = static_cast<long long>(args.find(kId)->second.get<double>());
1233     }
1234     return common::TizenSuccess{IotconClientManager::GetInstance().PrepareManageIdAnswer(true, id)};
1235   }
1236
1237   FoundRemoteInfoPtr ptr;
1238   auto result = IotconUtils::RemoteResourceFromJson(args, &ptr);
1239   if (!result) {
1240     LogAndReturnTizenError(result, ("Failed to create remote resource handle"));
1241   }
1242   result = IotconUtils::ConvertIotconError(iotcon_remote_resource_stop_monitoring(ptr->handle));
1243   if (!result) {
1244     return result;
1245   }
1246   monitoring_started_ = false;
1247   ptr->state_listener = nullptr;
1248   return common::TizenSuccess{IotconClientManager::GetInstance().RemoveRemoteResource(ptr)};
1249 }
1250
1251 common::TizenResult IotconInstance::RemoteResourceGetTimeInterval(const picojson::object& args) {
1252   ScopeLogger();
1253
1254   CHECK_PRIVILEGE(kPrivilegeIotcon);
1255
1256   FoundRemoteInfoPtr ptr;
1257   auto res = IotconUtils::RemoteResourceFromJson(args, &ptr);
1258   if (!res) {
1259     LogAndReturnTizenError(res, ("Failed to build resource using json data"));
1260   }
1261
1262   int time_interval = 0;
1263
1264   res = IotconUtils::ConvertIotconError(
1265       iotcon_remote_resource_get_checking_interval(ptr->handle, &time_interval));
1266   if (!res) {
1267     LogAndReturnTizenError(res, ("iotcon_remote_resource_get_checking_interval() failed"));
1268   }
1269   return common::TizenSuccess{picojson::value(static_cast<double>(time_interval))};
1270 }
1271
1272 common::TizenResult IotconInstance::RemoteResourceSetTimeInterval(const picojson::object& args) {
1273   ScopeLogger();
1274
1275   CHECK_PRIVILEGE(kPrivilegeIotcon);
1276   CHECK_EXIST(args, kTimeInterval);
1277
1278   int time_interval = static_cast<int>(IotconUtils::GetArg(args, kTimeInterval).get<double>());
1279
1280   FoundRemoteInfoPtr ptr;
1281   auto res = IotconUtils::RemoteResourceFromJson(args, &ptr);
1282   if (!res) {
1283     LogAndReturnTizenError(res, ("Failed to build resource using json data"));
1284   }
1285
1286   res = IotconUtils::ConvertIotconError(
1287       iotcon_remote_resource_set_checking_interval(ptr->handle, time_interval));
1288   if (!res) {
1289     LogAndReturnTizenError(res, ("iotcon_remote_resource_set_checking_interval() failed"));
1290   }
1291
1292   return common::TizenSuccess{IotconClientManager::GetInstance().StoreRemoteResource(ptr)};
1293 }
1294
1295 bool IotconInstance::ResourceFoundCallback(iotcon_remote_resource_h resource, iotcon_error_e result,
1296                                            void* user_data) {
1297   ScopeLogger();
1298   CallbackData* data = static_cast<CallbackData*>(user_data);
1299   if (nullptr == data) {
1300     LoggerE("ResourceFoundCallback() failed.  Ignoring callback");
1301     return IOTCON_FUNC_STOP;
1302   }
1303
1304   picojson::value v{picojson::object{}};
1305   common::TizenResult ret = common::TizenSuccess();
1306   switch (result) {
1307     case IOTCON_ERROR_NONE:
1308       ret = IotconUtils::RemoteResourceToJson(resource, &v.get<picojson::object>());
1309       break;
1310     case IOTCON_ERROR_TIMEOUT:
1311       LoggerD("IOTCON_TIMEOUT");
1312     default:
1313       ret = IotconUtils::ConvertIotconError(result);
1314   }
1315
1316   data->fun(ret, v);
1317   if (!ret) {
1318     return IOTCON_FUNC_STOP;
1319   }
1320
1321   return IOTCON_FUNC_CONTINUE;
1322 }
1323
1324 common::TizenResult IotconInstance::ClientFindResource(const picojson::object& args) {
1325   ScopeLogger();
1326
1327   CHECK_PRIVILEGE(kPrivilegeIotcon);
1328
1329   CHECK_EXIST(args, kHostAddress);
1330   char* host_address = nullptr;
1331   if (args.find(kHostAddress)->second.is<std::string>()) {
1332     host_address = const_cast<char*>(args.find(kHostAddress)->second.get<std::string>().c_str());
1333   } else {
1334     host_address = IOTCON_MULTICAST_ADDRESS;
1335   }
1336
1337   CHECK_EXIST(args, kQuery);
1338   iotcon_query_h query = nullptr;
1339   const auto& query_obj = args.find(kQuery)->second;
1340   if (query_obj.is<picojson::object>()) {
1341     auto result = IotconUtils::QueryFromJson(query_obj.get<picojson::object>(), &query);
1342     if (!result) {
1343       LogAndReturnTizenError(result, ("QueryFromJson() failed"));
1344     }
1345   }
1346   SCOPE_EXIT {
1347     if (query) {
1348       iotcon_query_destroy(query);
1349     }
1350   };
1351
1352   CHECK_EXIST(args, kConnectivityType);
1353   int connectivity_type =
1354       IotconUtils::ToConnectivityType2(args.find(kConnectivityType)->second.get<std::string>());
1355
1356   long long id = GetId(args);
1357   auto response = [this, id](const common::TizenResult& res, const picojson::value& v) {
1358     ScopeLogger("Entered into asynchronous function, response");
1359     picojson::value response{picojson::object{}};
1360     auto& obj = response.get<picojson::object>();
1361
1362     obj.insert(std::make_pair(kId, picojson::value{static_cast<double>(id)}));
1363     if (res) {
1364       common::tools::ReportSuccess(v, obj);
1365     } else {
1366       common::tools::ReportError(res, &obj);
1367     }
1368
1369     Post(kFindResourceListenerToken, common::TizenSuccess{response});
1370   };
1371
1372   CallbackData* data = new CallbackData{response};
1373
1374   LoggerD("Running find with:\nhost_address: %s,\nconnectivity_type: %d", host_address,
1375           connectivity_type);
1376   auto result = IotconUtils::ConvertIotconError(
1377       iotcon_find_resource(host_address, connectivity_type, query, ResourceFoundCallback, data));
1378   if (!result) {
1379     delete data;
1380     LogAndReturnTizenError(result);
1381   } else {
1382     int timeout = 60;  // default value set much bigger than default value for iotcon = 30s
1383     auto result = IotconUtils::ConvertIotconError(iotcon_get_timeout(&timeout));
1384     if (!result) {
1385       LoggerE("iotcon_get_timeout - function call failed, using default value %d", timeout);
1386     } else {
1387       timeout = timeout + 10;  // add 10 extra second to prevent too fast delete
1388     }
1389     // adding listener to delete data, when find would be finished
1390     std::thread([data, timeout]() {
1391       std::this_thread::sleep_for(std::chrono::seconds(timeout));
1392       LoggerD("Deleting resource find data: %p", data);
1393       delete data;
1394     }).detach();
1395   }
1396
1397   return common::TizenSuccess();
1398 }
1399
1400 common::TizenResult IotconInstance::ClientAddPresenceEventListener(const picojson::object& args) {
1401   ScopeLogger();
1402
1403   CHECK_PRIVILEGE(kPrivilegeIotcon);
1404
1405   CHECK_EXIST(args, kHostAddress);
1406   CHECK_EXIST(args, kResourceType);
1407   CHECK_EXIST(args, kConnectivityType);
1408
1409   char* host = nullptr;
1410   if (args.find(kHostAddress)->second.is<std::string>()) {
1411     host = const_cast<char*>(args.find(kHostAddress)->second.get<std::string>().c_str());
1412   }
1413
1414   char* resource_type = nullptr;
1415   if (args.find(kResourceType)->second.is<std::string>()) {
1416     resource_type = const_cast<char*>(args.find(kResourceType)->second.get<std::string>().c_str());
1417   }
1418
1419   auto& con_type = IotconUtils::GetArg(args, kConnectivityType);
1420   if (!con_type.is<std::string>()) {
1421     return common::TypeMismatchError("connectivityType needs to be a string");
1422   }
1423   iotcon_connectivity_type_e con_type_e =
1424       IotconUtils::ToConnectivityType(con_type.get<std::string>());
1425
1426   PresenceEventPtr presence{new PresenceEvent()};
1427   auto ret = IotconClientManager::GetInstance().AddPresenceEventListener(host, con_type_e,
1428                                                                          resource_type, presence);
1429   if (!ret) {
1430     return ret;
1431   }
1432
1433   long long id = presence->id;
1434
1435   presence->presence_listener = [this, id](const common::TizenResult&, const picojson::value& v) {
1436     ScopeLogger("Entered into asynchronous function, presence->presence_listener");
1437     picojson::value response{picojson::object{}};
1438     auto& obj = response.get<picojson::object>();
1439
1440     obj.insert(std::make_pair(kId, picojson::value{static_cast<double>(id)}));
1441     obj.insert(std::make_pair(kData, v));
1442
1443     Post(kPresenceEventListenerToken, common::TizenSuccess{response});
1444   };
1445
1446   return common::TizenSuccess(picojson::value{static_cast<double>(id)});
1447 }
1448
1449 common::TizenResult IotconInstance::ClientRemovePresenceEventListener(
1450     const picojson::object& args) {
1451   ScopeLogger();
1452
1453   CHECK_PRIVILEGE(kPrivilegeIotcon);
1454
1455   CHECK_EXIST(args, kId);
1456
1457   auto ret = IotconClientManager::GetInstance().RemovePresenceEventListener(GetId(args));
1458
1459   if (!ret) {
1460     return ret;
1461   }
1462
1463   return common::TizenSuccess();
1464 }
1465
1466 bool IotconDeviceInfoCb(iotcon_device_info_h device_info, iotcon_error_e result, void* user_data) {
1467   ScopeLogger();
1468
1469   CallbackData* data = static_cast<CallbackData*>(user_data);
1470   if (nullptr == data) {
1471     LoggerE("IotconDeviceInfoCb() failed.  Ignoring callback");
1472     return IOTCON_FUNC_STOP;
1473   }
1474
1475   picojson::value v{picojson::object{}};
1476   common::TizenResult ret = common::TizenSuccess();
1477
1478   switch (result) {
1479     case IOTCON_ERROR_NONE:
1480       ret = IotconUtils::DeviceInfoToJson(device_info, &v.get<picojson::object>());
1481       break;
1482     case IOTCON_ERROR_TIMEOUT:
1483       LoggerD("IOTCON_TIMEOUT");
1484     default:
1485       ret = IotconUtils::ConvertIotconError(result);
1486   }
1487
1488   data->fun(ret, v);
1489   if (!ret) {
1490     return IOTCON_FUNC_STOP;
1491   }
1492
1493   return IOTCON_FUNC_CONTINUE;
1494 }
1495
1496 common::TizenResult IotconInstance::ClientFindDeviceInfo(const picojson::object& args) {
1497   ScopeLogger();
1498
1499   CHECK_PRIVILEGE(kPrivilegeIotcon);
1500
1501   CHECK_EXIST(args, kHostAddress);
1502   char* host_address = nullptr;
1503   if (args.find(kHostAddress)->second.is<std::string>()) {
1504     host_address = const_cast<char*>(args.find(kHostAddress)->second.get<std::string>().c_str());
1505   } else {
1506     host_address = IOTCON_MULTICAST_ADDRESS;
1507   }
1508
1509   CHECK_EXIST(args, kQuery);
1510   iotcon_query_h query = nullptr;
1511   const auto& query_obj = args.find(kQuery)->second;
1512   if (query_obj.is<picojson::object>()) {
1513     auto result = IotconUtils::QueryFromJson(query_obj.get<picojson::object>(), &query);
1514     if (!result) {
1515       LogAndReturnTizenError(result, ("QueryFromJson() failed"));
1516     }
1517   }
1518   SCOPE_EXIT {
1519     if (query) {
1520       iotcon_query_destroy(query);
1521     }
1522   };
1523
1524   CHECK_EXIST(args, kConnectivityType);
1525   std::string con_type = args.find(kConnectivityType)->second.get<std::string>();
1526   int con_type_e = IotconUtils::ToConnectivityType2(con_type);
1527
1528   long long id = GetId(args);
1529   auto response = [this, id](const common::TizenResult& res, const picojson::value& v) {
1530     ScopeLogger("Entered into asynchronous function, response");
1531     picojson::value response{picojson::object{}};
1532     auto& obj = response.get<picojson::object>();
1533
1534     obj.insert(std::make_pair(kId, picojson::value{static_cast<double>(id)}));
1535     if (res) {
1536       common::tools::ReportSuccess(v, obj);
1537     } else {
1538       common::tools::ReportError(res, &obj);
1539     }
1540
1541     Post(kFindDeviceInfoListenerToken, common::TizenSuccess{response});
1542   };
1543
1544   CallbackData* data = new CallbackData{response};
1545
1546   auto result = IotconUtils::ConvertIotconError(
1547       iotcon_find_device_info(host_address, con_type_e, query, IotconDeviceInfoCb, data));
1548
1549   if (!result) {
1550     delete data;
1551     LogAndReturnTizenError(result);
1552   } else {
1553     int timeout = 60;  // default value set much bigger than default value for iotcon = 30s
1554     auto result = IotconUtils::ConvertIotconError(iotcon_get_timeout(&timeout));
1555     if (!result) {
1556       LoggerE("iotcon_get_timeout - function call failed, using default value %d", timeout);
1557     } else {
1558       timeout = timeout + 10;  // add 10 extra second to prevent too fast delete
1559     }
1560     // adding listener to delete data, when find would be finished
1561     std::thread([data, timeout]() {
1562       std::this_thread::sleep_for(std::chrono::seconds(timeout));
1563       LoggerD("Deleting resource find data: %p", data);
1564       delete data;
1565     }).detach();
1566   }
1567
1568   return common::TizenSuccess();
1569 }
1570
1571 bool IotconPlatformInfoCb(iotcon_platform_info_h platform_info, iotcon_error_e result,
1572                           void* user_data) {
1573   ScopeLogger();
1574
1575   CallbackData* data = static_cast<CallbackData*>(user_data);
1576   if (nullptr == data) {
1577     LoggerE("IotconPlatformInfoCb() failed.  Ignoring callback");
1578     return IOTCON_FUNC_STOP;
1579   }
1580
1581   picojson::value v{picojson::object{}};
1582   common::TizenResult ret = common::TizenSuccess();
1583
1584   switch (result) {
1585     case IOTCON_ERROR_NONE:
1586       ret = IotconUtils::PlatformInfoToJson(platform_info, &v.get<picojson::object>());
1587       break;
1588     case IOTCON_ERROR_TIMEOUT:
1589       LoggerD("IOTCON_TIMEOUT");
1590     default:
1591       ret = IotconUtils::ConvertIotconError(result);
1592   }
1593
1594   data->fun(ret, v);
1595   if (!ret) {
1596     return IOTCON_FUNC_STOP;
1597   }
1598
1599   return IOTCON_FUNC_CONTINUE;
1600 }
1601
1602 common::TizenResult IotconInstance::ClientFindPlatformInfo(const picojson::object& args) {
1603   ScopeLogger();
1604
1605   CHECK_PRIVILEGE(kPrivilegeIotcon);
1606
1607   CHECK_EXIST(args, kHostAddress);
1608   char* host_address = nullptr;
1609   if (args.find(kHostAddress)->second.is<std::string>()) {
1610     host_address = const_cast<char*>(args.find(kHostAddress)->second.get<std::string>().c_str());
1611   } else {
1612     host_address = IOTCON_MULTICAST_ADDRESS;
1613   }
1614
1615   CHECK_EXIST(args, kQuery);
1616   iotcon_query_h query = nullptr;
1617   const auto& query_obj = args.find(kQuery)->second;
1618   if (query_obj.is<picojson::object>()) {
1619     auto result = IotconUtils::QueryFromJson(query_obj.get<picojson::object>(), &query);
1620     if (!result) {
1621       LogAndReturnTizenError(result, ("QueryFromJson() failed"));
1622     }
1623   }
1624   SCOPE_EXIT {
1625     if (query) {
1626       iotcon_query_destroy(query);
1627     }
1628   };
1629
1630   CHECK_EXIST(args, kConnectivityType);
1631   std::string con_type = args.find(kConnectivityType)->second.get<std::string>();
1632   int con_type_e = IotconUtils::ToConnectivityType2(con_type);
1633
1634   long long id = GetId(args);
1635   auto response = [this, id](const common::TizenResult& res, const picojson::value& v) {
1636     ScopeLogger("Entered into asynchronous function, response");
1637     picojson::value response{picojson::object{}};
1638     auto& obj = response.get<picojson::object>();
1639
1640     obj.insert(std::make_pair(kId, picojson::value{static_cast<double>(id)}));
1641     if (res) {
1642       common::tools::ReportSuccess(v, obj);
1643     } else {
1644       common::tools::ReportError(res, &obj);
1645     }
1646
1647     Post(kFindPlatformInfoListenerToken, common::TizenSuccess{response});
1648   };
1649
1650   CallbackData* data = new CallbackData{response};
1651
1652   auto result = IotconUtils::ConvertIotconError(
1653       iotcon_find_platform_info(host_address, con_type_e, query, IotconPlatformInfoCb, data));
1654
1655   if (!result) {
1656     delete data;
1657     LogAndReturnTizenError(result);
1658   } else {
1659     int timeout = 60;  // default value set much bigger than default value for iotcon = 30s
1660     auto result = IotconUtils::ConvertIotconError(iotcon_get_timeout(&timeout));
1661     if (!result) {
1662       LoggerE("iotcon_get_timeout - function call failed, using default value %d", timeout);
1663     } else {
1664       timeout = timeout + 10;  // add 10 extra second to prevent too fast delete
1665     }
1666     // adding listener to delete data, when find would be finished
1667     std::thread([data, timeout]() {
1668       std::this_thread::sleep_for(std::chrono::seconds(timeout));
1669       LoggerD("Deleting resource find data: %p", data);
1670       delete data;
1671     }).detach();
1672   }
1673
1674   return common::TizenSuccess();
1675 }
1676
1677 common::TizenResult IotconInstance::ServerCreateResource(const picojson::object& args) {
1678   ScopeLogger();
1679
1680   CHECK_PRIVILEGE(kPrivilegeIotcon);
1681
1682   CHECK_EXIST(args, kUriPath);
1683   CHECK_EXIST(args, kResourceTypes);
1684   CHECK_EXIST(args, kResourceInterfaces);
1685
1686   const std::string& uri_path = args.find(kUriPath)->second.get<std::string>();
1687
1688   const auto& types = IotconUtils::GetArg(args, kResourceTypes);
1689   const auto& resource_types =
1690       types.is<picojson::array>() ? types.get<picojson::array>() : picojson::array();
1691
1692   const auto& interfaces = IotconUtils::GetArg(args, kResourceInterfaces);
1693   const auto& resource_interfaces =
1694       interfaces.is<picojson::array>() ? interfaces.get<picojson::array>() : picojson::array();
1695
1696   int properties = IotconUtils::GetProperties(args);
1697
1698   ResourceInfoPtr resource{new ResourceInfo()};
1699   auto ret = IotconServerManager::GetInstance().CreateResource(
1700       uri_path, resource_interfaces, resource_types, properties, resource);
1701   if (!ret) {
1702     return ret;
1703   }
1704
1705   LoggerD("RESOURCE\nid: %lld\nhandle: %p", resource->id, resource->handle);
1706
1707   picojson::value result = picojson::value(picojson::object());
1708   ret = IotconUtils::ResourceToJson(resource, &(result.get<picojson::object>()));
1709   if (!ret) {
1710     return ret;
1711   }
1712
1713   return common::TizenSuccess{result};
1714 }
1715
1716 common::TizenResult IotconInstance::ServerRemoveResource(const picojson::object& args) {
1717   ScopeLogger();
1718
1719   CHECK_PRIVILEGE(kPrivilegeIotcon);
1720
1721   CHECK_EXIST(args, kId);
1722
1723   return IotconServerManager::GetInstance().DestroyResource(GetId(args));
1724 }
1725
1726 common::TizenResult IotconInstance::ServerStartPresence(const picojson::object& args) {
1727   ScopeLogger();
1728
1729   CHECK_PRIVILEGE(kPrivilegeIotcon);
1730   CHECK_EXIST(args, kTimeToLive);
1731
1732   if (!initialized_) {
1733     return LogAndCreateTizenError(AbortError, "Iotcon service not initialized");
1734   }
1735
1736   if (presence_started_) {
1737     LoggerD("Iotcon service presence has been already started");
1738     return common::TizenSuccess();
1739   }
1740
1741   unsigned int timeToLive =
1742       static_cast<unsigned int>(IotconUtils::GetArg(args, kTimeToLive).get<double>());
1743
1744   auto result = IotconUtils::ConvertIotconError(iotcon_start_presence(timeToLive));
1745   if (!result) {
1746     LogAndReturnTizenError(result);
1747   }
1748
1749   presence_started_ = true;
1750   LoggerD("Iotcon service presence started");
1751
1752   return result;
1753 }
1754
1755 common::TizenResult IotconInstance::ServerStopPresence(const picojson::object& args) {
1756   ScopeLogger();
1757
1758   CHECK_PRIVILEGE(kPrivilegeIotcon);
1759
1760   if (!presence_started_) {
1761     LoggerD("Iotcon service presence not started before");
1762     return common::TizenSuccess();
1763   }
1764
1765   auto result = IotconUtils::ConvertIotconError(iotcon_stop_presence());
1766   if (!result) {
1767     LogAndReturnTizenError(result);
1768   }
1769
1770   presence_started_ = false;
1771   LoggerD("Iotcon service presence stopped");
1772
1773   return result;
1774 }
1775
1776 common::TizenResult IotconInstance::SetDeviceName(const picojson::object& args) {
1777   ScopeLogger();
1778
1779   CHECK_PRIVILEGE(kPrivilegeIotcon);
1780   CHECK_EXIST(args, kDeviceName);
1781
1782   if (!initialized_) {
1783     return LogAndCreateTizenError(AbortError, "Iotcon service not initialized");
1784   }
1785
1786   const std::string& name = IotconUtils::GetArg(args, kDeviceName).get<std::string>();
1787
1788   auto result = IotconUtils::ConvertIotconError(iotcon_set_device_name(name.c_str()));
1789   if (!result) {
1790     LogAndReturnTizenError(result);
1791   }
1792
1793   LoggerD("Iotcon service device name set");
1794
1795   return result;
1796 }
1797
1798 common::TizenResult IotconInstance::Initialize(const picojson::object& args) {
1799   ScopeLogger();
1800
1801   CHECK_PRIVILEGE(kPrivilegeIotcon);
1802
1803   CHECK_EXIST(args, kFilePath);
1804   const auto& filePath = IotconUtils::GetArg(args, kFilePath);
1805   // convert virtual root (if present in path) for native iotcon_initialize function
1806   std::string realPath =
1807       common::FilesystemProvider::Create().GetRealPath(filePath.get<std::string>());
1808
1809   auto result = IotconUtils::ConvertIotconError(iotcon_initialize(realPath.c_str()));
1810   if (!result) {
1811     LogAndReturnTizenError(result);
1812   }
1813
1814   initialized_ = true;
1815   LoggerD("Iotcon service initialized");
1816
1817   return result;
1818 }
1819
1820 common::TizenResult IotconInstance::GetTimeout(const picojson::object& args) {
1821   ScopeLogger();
1822
1823   int timeout = 0;
1824   auto result = IotconUtils::ConvertIotconError(iotcon_get_timeout(&timeout));
1825
1826   if (!result) {
1827     LogAndReturnTizenError(result);
1828   }
1829
1830   return common::TizenSuccess{picojson::value{static_cast<double>(timeout)}};
1831 }
1832
1833 common::TizenResult IotconInstance::SetTimeout(const picojson::object& args) {
1834   ScopeLogger();
1835
1836   CHECK_EXIST(args, kTimeout);
1837
1838   int timeout = static_cast<int>(args.find(kTimeout)->second.get<double>());
1839   auto result = IotconUtils::ConvertIotconError(iotcon_set_timeout(timeout));
1840
1841   if (!result) {
1842     LogAndReturnTizenError(result);
1843   }
1844
1845   return common::TizenSuccess();
1846 }
1847
1848 common::TizenResult IotconInstance::AddGeneratedPinListener(const picojson::object& args) {
1849   ScopeLogger();
1850
1851   auto listener = [this](const char* pin, long watchId) {
1852     ScopeLogger("Entered into asynchronous function, listener");
1853     picojson::object obj;
1854     obj[kId] = picojson::value{(double)watchId};
1855     obj["pin"] = picojson::value{pin};
1856     this->Post(kGeneratedPinToken, common::TizenSuccess{picojson::value{obj}});
1857   };
1858
1859   return IotconManager::GetInstance().addGeneratedPinListener(listener);
1860 }
1861
1862 common::TizenResult IotconInstance::RemoveGeneratedPinListener(const picojson::object& args) {
1863   ScopeLogger();
1864
1865   CHECK_EXIST(args, "watchId");
1866   long watchId = args.find("watchId")->second.get<double>();
1867
1868   return IotconManager::GetInstance().removeGeneratedPinListener(watchId);
1869 }
1870
1871 common::PostCallback IotconInstance::PostForMethodCall(const common::AsyncToken& token,
1872                                                        const FoundRemoteInfoPtr& resource) {
1873   ScopeLogger();
1874
1875   return [this, token, resource](const common::TizenResult& result, const picojson::value& v) {
1876     ScopeLogger("Entered into asynchronous function, returned value");
1877     auto value = IotconClientManager::GetInstance().RemoveRemoteResource(resource);
1878     auto& obj = value.get<picojson::object>();
1879
1880     if (result) {
1881       obj.insert(std::make_pair(kData, v));
1882     } else {
1883       result.ToJson(&obj);
1884     }
1885
1886     Post(token, common::TizenSuccess{value});
1887   };
1888 }
1889
1890 }  // namespace iotcon
1891 }  // namespace extension