[Iotcon] getPlatformInfo implemented

Change-Id: Idcb18badedb3d7b6f04004cbc3ac583be5f38bf7
Signed-off-by: Lukasz Bardeli <l.bardeli@samsung.com>

diff --git a/src/iotcon/iotcon_instance.cc b/src/iotcon/iotcon_instance.cc
index 7dfec2bc8c7393de8b1851552f9bb19930f57635..ae48cf213743148fd714cc262157ab2f5c024d6d 100644 (file)
--- a/src/iotcon/iotcon_instance.cc
+++ b/src/iotcon/iotcon_instance.cc
@@ -28,6 +28,12 @@ namespace iotcon {
 
 namespace {
 
+typedef struct {
+  common::PostCallback fun;
+} CallbackData;
+
+const std::string kTimeout = "timeout";
+
 #define CHECK_EXIST(args, name) \
   if (args.end() == args.find(name)) { \
     return common::TypeMismatchError(std::string(name) + " is required argument"); \
@@ -383,10 +389,47 @@ common::TizenResult IotconInstance::ClientGetDeviceInfo(const picojson::object&
   return common::UnknownError("Not implemented");
 }
 
+void IotconPlatformInfoCb(iotcon_platform_info_h platform_info,
+                          iotcon_error_e result, void *user_data) {
+  ScopeLogger();
+
+  CallbackData* data = static_cast<CallbackData*>(user_data);
+  picojson::value v{picojson::object{}};
+  common::TizenResult ret = common::TizenSuccess();
+
+  if (IOTCON_ERROR_NONE != result) {
+    ret = IotconUtils::ConvertIotconError(result);
+  } else {
+    ret = IotconUtils::PlatformInfoToJson(platform_info,&v.get<picojson::object>());
+  }
+
+  data->fun(ret, v);
+  delete data;
+}
+
 common::TizenResult IotconInstance::ClientGetPlatformInfo(const picojson::object& args,
                                                           const common::AsyncToken& token) {
   ScopeLogger();
-  return common::UnknownError("Not implemented");
+
+  CHECK_EXIST(args, kHostAddress);
+  CHECK_EXIST(args, kConnectivityType);
+
+  std::string host = args.find(kHostAddress)->second.get<std::string>();
+  std::string con_type = args.find(kConnectivityType)->second.get<std::string>();
+  iotcon_connectivity_type_e con_type_e = IotconUtils::ToConnectivityType(con_type);
+
+  CallbackData* data = new CallbackData{SimplePost(token)};
+
+  auto result = IotconUtils::ConvertIotconError(
+       iotcon_get_platform_info(host.c_str(), con_type_e, IotconPlatformInfoCb,
+                                data));
+
+  if (!result) {
+    delete data;
+    LogAndReturnTizenError(result);
+  }
+
+  return common::TizenSuccess();
 }
 
 common::TizenResult IotconInstance::ServerCreateResource(const picojson::object& args) {
@@ -464,9 +507,9 @@ common::TizenResult IotconInstance::GetTimeout(const picojson::object& args) {
 common::TizenResult IotconInstance::SetTimeout(const picojson::object& args) {
   ScopeLogger();
 
-  CHECK_EXIST(args, "timeout");
+  CHECK_EXIST(args, kTimeout);
 
-  int timeout = static_cast<int>(args.find("timeout")->second.get<double>());
+  int timeout = static_cast<int>(args.find(kTimeout)->second.get<double>());
   auto result = IotconUtils::ConvertIotconError(iotcon_set_timeout(timeout));
 
   if (!result) {

diff --git a/src/iotcon/iotcon_utils.cc b/src/iotcon/iotcon_utils.cc
index bfca55c142f6954d412a0db681cd37137a806a04..a22704a3923f4deaab6e201a6e63d348a075c6f8 100644 (file)
--- a/src/iotcon/iotcon_utils.cc
+++ b/src/iotcon/iotcon_utils.cc
@@ -100,6 +100,18 @@ const std::string kFilter = "filter";
 
 const std::string kHexPrefix = "0x";
 
+const std::string kPlatformId = "platformId";
+const std::string kManufacturerName = "manufacturerName";
+const std::string kManufacturerUrl = "manufacturerUrl";
+const std::string kModelNumber = "modelNumber";
+const std::string kManufactureDate = "manufactureDate";
+const std::string kPlatformVersion = "platformVersion";
+const std::string kOperatingSystemVersion = "operatingSystemVersion";
+const std::string kHardwareVersion = "hardwareVersion";
+const std::string kFirmwareVersion = "firmwareVersion";
+const std::string kSupportUrl = "supportUrl";
+const std::string kSystemTime = "systemTime";
+
 using common::TizenResult;
 using common::TizenSuccess;
 
@@ -1101,6 +1113,129 @@ common::TizenResult IotconUtils::StateListFromJson(const picojson::array& l,
   return TizenSuccess();
 }
 
+common::TizenResult IotconUtils::PlatformInfoGetProperty(iotcon_platform_info_h platform,
+                                                         iotcon_platform_info_e property_e,
+                                                         const std::string& name,
+                                                         picojson::object* out) {
+  ScopeLogger();
+
+  char* property = nullptr;
+  auto result = ConvertIotconError(iotcon_platform_info_get_property(platform,
+                                                                     property_e,
+                                                                     &property));
+  if (!result || !property) {
+    LogAndReturnTizenError(result, ("iotcon_platform_info_get_property() failed"));
+  }
+  out->insert(std::make_pair(name, picojson::value{property}));
+
+  return TizenSuccess();
+}
+
+common::TizenResult IotconUtils::PlatformInfoToJson(iotcon_platform_info_h platform,
+                                                    picojson::object* out) {
+  ScopeLogger();
+
+  {
+    // platformId
+    auto result = PlatformInfoGetProperty(platform, IOTCON_PLATFORM_INFO_ID,
+                                          kPlatformId, out);
+    if (!result) {
+      return result;
+    }
+  }
+
+  {
+    // manufacturerName
+    auto result = PlatformInfoGetProperty(platform, IOTCON_PLATFORM_INFO_MANUF_NAME,
+                                          kManufacturerName, out);
+    if (!result) {
+      return result;
+    }
+  }
+
+  {
+    // manufacturerUrl
+    auto result = PlatformInfoGetProperty(platform, IOTCON_PLATFORM_INFO_MANUF_URL,
+                                          kManufacturerUrl, out);
+    if (!result) {
+      return result;
+    }
+  }
+
+  {
+    // modelNumber
+    auto result = PlatformInfoGetProperty(platform, IOTCON_PLATFORM_INFO_MODEL_NUMBER,
+                                          kModelNumber, out);
+    if (!result) {
+      return result;
+    }
+  }
+
+  {
+    // manufactureDate
+    auto result = PlatformInfoGetProperty(platform, IOTCON_PLATFORM_INFO_DATE_OF_MANUF,
+                                          kManufactureDate, out);
+    if (!result) {
+      return result;
+    }
+  }
+
+  {
+    // platformVersion
+    auto result = PlatformInfoGetProperty(platform, IOTCON_PLATFORM_INFO_PLATFORM_VER,
+                                          kPlatformVersion, out);
+    if (!result) {
+      return result;
+    }
+  }
+
+  {
+    // operatingSystemVersion
+    auto result = PlatformInfoGetProperty(platform, IOTCON_PLATFORM_INFO_OS_VER,
+                                          kOperatingSystemVersion, out);
+    if (!result) {
+      return result;
+    }
+  }
+
+  {
+    // hardwareVersion
+    auto result = PlatformInfoGetProperty(platform, IOTCON_PLATFORM_INFO_HARDWARE_VER,
+                                          kHardwareVersion, out);
+    if (!result) {
+      return result;
+    }
+  }
+
+  {
+    // firmwareVersion
+    auto result = PlatformInfoGetProperty(platform, IOTCON_PLATFORM_INFO_FIRMWARE_VER,
+                                          kFirmwareVersion, out);
+    if (!result) {
+      return result;
+    }
+  }
+
+  {
+    // supportUrl
+    auto result = PlatformInfoGetProperty(platform, IOTCON_PLATFORM_INFO_SUPPORT_URL,
+                                          kSupportUrl, out);
+    if (!result) {
+      return result;
+    }
+  }
+
+  {
+    // systemTime
+    auto result = PlatformInfoGetProperty(platform, IOTCON_PLATFORM_INFO_SYSTEM_TIME,
+                                          kSystemTime, out);
+    if (!result) {
+      return result;
+    }
+  }
+  return TizenSuccess();
+}
+
 common::TizenResult IotconUtils::ConvertIotconError(int error) {
   switch (error) {
     case IOTCON_ERROR_NONE:
@@ -1198,6 +1333,12 @@ iotcon_qos_e IotconUtils::ToQos(const std::string& e) {
   IOTCON_QOS_E
 }
 
+iotcon_connectivity_type_e IotconUtils::ToConnectivityType(const std::string& e) {
+  ScopeLogger();
+
+  IOTCON_CONNECTIVITY_TYPE_E
+}
+
 #undef X
 #undef XD
 

diff --git a/src/iotcon/iotcon_utils.h b/src/iotcon/iotcon_utils.h
index 3351d34fd6feef034131d0a2cd2350a4701e92ee..780bfe5cecaacfdeadaa7bff2a8c0e10c6c5844e 100644 (file)
--- a/src/iotcon/iotcon_utils.h
+++ b/src/iotcon/iotcon_utils.h
@@ -45,6 +45,8 @@ extern const std::string kResourceChildren;
 extern const std::string kUriPath;
 extern const std::string kStates;
 extern const std::string kId;
+extern const std::string kHostAddress;
+extern const std::string kConnectivityType;
 
 struct ResourceInfo {
   long long id;
@@ -91,6 +93,12 @@ class IotconUtils {
                                            picojson::array* out);
   static common::TizenResult QueryToJson(iotcon_query_h query,
                                          picojson::object* out);
+  static common::TizenResult PlatformInfoToJson(iotcon_platform_info_h platform,
+                                                picojson::object* out);
+  static common::TizenResult PlatformInfoGetProperty(iotcon_platform_info_h platform,
+                                                     iotcon_platform_info_e property,
+                                                     const std::string& name,
+                                                     picojson::object* out);
 
   static common::TizenResult RepresentationFromResource(const ResourceInfoPtr& resource,
                                                         const picojson::value& states,
@@ -108,6 +116,7 @@ class IotconUtils {
   static std::string FromInterface(iotcon_interface_e e);
 
   static iotcon_interface_e ToInterface(const std::string& e);
+  static iotcon_connectivity_type_e ToConnectivityType(const std::string& e);
   static iotcon_qos_e ToQos(const std::string& e);
 };