Fix member variable of Capability, RemoteDevice class

Change-Id: If9a83edf81c75fdff45cd08f9594b6eb74fcd6a4
Signed-off-by: Sangyoon Jang <jeremy.jang@samsung.com>

diff --git a/src/client/client.cc b/src/client/client.cc
index 0b03cd50198119b0c87d272d14fcc75e54e1277e..212aa06e8ff87145dfa62e8036c0098611c7c2a5 100644 (file)
--- a/src/client/client.cc
+++ b/src/client/client.cc
@@ -22,12 +22,13 @@ const char kDBPath[] = "/run/capmgr/capmgr.db";
 }  // namespace
 
 struct capmgr_device_s {
-  std::string name;
-  std::string profile;
+  std::string device_id;
   std::string address;
-  std::string uuid;
-  std::string sw_version;
-  std::string platform_version;
+  std::string model_name;
+  std::string device_name;
+  std::string platform_ver;
+  std::string profile;
+  std::string sw_ver;
 };
 
 struct capmgr_app_control_s {
@@ -48,18 +49,21 @@ API int capmgr_device_foreach_devices(capmgr_device_foreach_cb cb,
       new capmgr::SQLiteConnection(kDBPath, true));
 
   const char kQueryForeachDevices[] =
-      "SELECT name, profile, address, uuid, sw_version, platform_version " \
+      "SELECT device_id, address, model_name, device_name, platform_ver,"
+      "  profile, sw_ver "
       "FROM devices";
   std::shared_ptr<capmgr::SQLStatement> stmt = sql_conn->PrepareStatement(
       kQueryForeachDevices);
   while (stmt->Step() == capmgr::SQLStatement::StepResult::ROW) {
     struct capmgr_device_s dev;
-    dev.name = stmt->GetColumnString(0);
-    dev.profile = stmt->GetColumnString(1);
-    dev.address = stmt->GetColumnString(2);
-    dev.uuid = stmt->GetColumnString(3);
-    dev.sw_version = stmt->GetColumnString(4);
-    dev.platform_version = stmt->GetColumnString(5);
+    int idx = 0;
+    dev.device_id = stmt->GetColumnString(idx++);
+    dev.address = stmt->GetColumnString(idx++);
+    dev.model_name = stmt->GetColumnString(idx++);
+    dev.device_name = stmt->GetColumnString(idx++);
+    dev.platform_ver = stmt->GetColumnString(idx++);
+    dev.profile = stmt->GetColumnString(idx++);
+    dev.sw_ver = stmt->GetColumnString(idx++);
     if (cb(&dev, user_data))
       break;
   }
@@ -75,12 +79,13 @@ API int capmgr_device_clone(const capmgr_device_h device,
   try {
     struct capmgr_device_s* clone = new struct capmgr_device_s;
 
-    clone->name = device->name;
-    clone->profile = device->profile;
+    clone->device_id = device->device_id;
     clone->address = device->address;
-    clone->uuid = device->uuid;
-    clone->sw_version = device->sw_version;
-    clone->platform_version = device->platform_version;
+    clone->model_name = device->model_name;
+    clone->device_name = device->device_name;
+    clone->platform_ver = device->platform_ver;
+    clone->profile = device->profile;
+    clone->sw_ver = device->sw_ver;
 
     *device_clone = clone;
   } catch (const std::bad_alloc& e) {
@@ -100,69 +105,83 @@ API int capmgr_device_destroy(capmgr_device_h device) {
   return CAPMGR_ERROR_NONE;
 }
 
-API int capmgr_device_get_name(capmgr_device_h device, char** name) {
-  if (!device || !name)
+API int capmgr_device_get_device_id(capmgr_device_h device,
+    char** device_id) {
+  if (!device || !device_id)
     return CAPMGR_ERROR_INVALID_PARAMETER;
 
-  *name = strdup(device->name.c_str());
-  if (*name == nullptr)
+  *device_id = strdup(device->device_id.c_str());
+  if (*device_id == nullptr)
     return CAPMGR_ERROR_OUT_OF_MEMORY;
 
   return CAPMGR_ERROR_NONE;
 }
 
-API int capmgr_device_get_profile(capmgr_device_h device, char** profile) {
-  if (!device || !profile)
+API int capmgr_device_get_address(capmgr_device_h device, char** address) {
+  if (!device || !address)
     return CAPMGR_ERROR_INVALID_PARAMETER;
 
-  *profile = strdup(device->profile.c_str());
-  if (*profile == nullptr)
+  *address = strdup(device->address.c_str());
+  if (*address == nullptr)
     return CAPMGR_ERROR_OUT_OF_MEMORY;
 
   return CAPMGR_ERROR_NONE;
 }
 
-API int capmgr_device_get_address(capmgr_device_h device, char** address) {
-  if (!device || !address)
+API int capmgr_device_get_model_name(capmgr_device_h device,
+    char** model_name) {
+  if (!device || !model_name)
     return CAPMGR_ERROR_INVALID_PARAMETER;
 
-  *address = strdup(device->address.c_str());
-  if (*address == nullptr)
+  *model_name = strdup(device->model_name.c_str());
+  if (*model_name == nullptr)
     return CAPMGR_ERROR_OUT_OF_MEMORY;
 
   return CAPMGR_ERROR_NONE;
 }
 
-API int capmgr_device_get_uuid(capmgr_device_h device, char** uuid) {
-  if (!device || !uuid)
+API int capmgr_device_get_device_name(capmgr_device_h device,
+    char** device_name) {
+  if (!device || !device_name)
     return CAPMGR_ERROR_INVALID_PARAMETER;
 
-  *uuid = strdup(device->uuid.c_str());
-  if (*uuid == nullptr)
+  *device_name = strdup(device->device_name.c_str());
+  if (*device_name == nullptr)
     return CAPMGR_ERROR_OUT_OF_MEMORY;
 
   return CAPMGR_ERROR_NONE;
 }
 
-API int capmgr_device_get_sw_version(capmgr_device_h device,
-    char** sw_version) {
-  if (!device || !sw_version)
+API int capmgr_device_get_platform_ver(capmgr_device_h device,
+    char** platform_ver) {
+  if (!device || !platform_ver)
     return CAPMGR_ERROR_INVALID_PARAMETER;
 
-  *sw_version = strdup(device->sw_version.c_str());
-  if (*sw_version == nullptr)
+  *platform_ver = strdup(device->platform_ver.c_str());
+  if (*platform_ver == nullptr)
+    return CAPMGR_ERROR_OUT_OF_MEMORY;
+
+  return CAPMGR_ERROR_NONE;
+}
+
+API int capmgr_device_get_profile(capmgr_device_h device, char** profile) {
+  if (!device || !profile)
+    return CAPMGR_ERROR_INVALID_PARAMETER;
+
+  *profile = strdup(device->profile.c_str());
+  if (*profile == nullptr)
     return CAPMGR_ERROR_OUT_OF_MEMORY;
 
   return CAPMGR_ERROR_NONE;
 }
 
-API int capmgr_device_get_platform_version(capmgr_device_h device,
-    char** platform_version) {
-  if (!device || !platform_version)
+API int capmgr_device_get_sw_ver(capmgr_device_h device,
+    char** sw_ver) {
+  if (!device || !sw_ver)
     return CAPMGR_ERROR_INVALID_PARAMETER;
 
-  *platform_version = strdup(device->platform_version.c_str());
-  if (*platform_version == nullptr)
+  *sw_ver = strdup(device->sw_ver.c_str());
+  if (*sw_ver == nullptr)
     return CAPMGR_ERROR_OUT_OF_MEMORY;
 
   return CAPMGR_ERROR_NONE;
@@ -201,6 +220,7 @@ API int capmgr_app_control_clone(const capmgr_app_control_h app_control,
     clone->uri = app_control->uri;
     clone->mime = app_control->mime;
     clone->appid = app_control->appid;
+    clone->extra_data = app_control->extra_data;
 
     *app_control_clone = clone;
   } catch (const std::bad_alloc& e) {

diff --git a/src/client/include/capmgr.h b/src/client/include/capmgr.h
index 01643e8fb3cadff27ccd9d6e0fd960a8de90e027..09e29a8de521d70902db68a751361fb9221e381a 100644 (file)
--- a/src/client/include/capmgr.h
+++ b/src/client/include/capmgr.h
@@ -55,27 +55,37 @@ int capmgr_device_destroy(capmgr_device_h device);
 /**
  * @brief
  */
-int capmgr_device_get_name(capmgr_device_h device, char** name);
+int capmgr_device_get_device_id(capmgr_device_h device, char** device_id);
 
 /**
  * @brief
  */
-int capmgr_device_get_profile(capmgr_device_h device, char** profile);
+int capmgr_device_get_address(capmgr_device_h device, char** address);
 
 /**
  * @brief
  */
-int capmgr_device_get_address(capmgr_device_h device, char** address);
+int capmgr_device_get_model_name(capmgr_device_h device, char** model_name);
+
+/**
+ * @brief
+ */
+int capmgr_device_get_device_name(capmgr_device_h device, char** device_name);
+
+/**
+ * @brief
+ */
+int capmgr_device_get_platform_ver(capmgr_device_h device, char** platform_ver);
 
 /**
  * @brief
  */
-int capmgr_device_get_uuid(capmgr_device_h device, char** uuid);
+int capmgr_device_get_profile(capmgr_device_h device, char** profile);
 
 /**
  * @brief
  */
-int capmgr_device_get_sw_version(capmgr_device_h device, char** sw_version);
+int capmgr_device_get_sw_ver(capmgr_device_h device, char** sw_ver);
 
 /**
  * @brief

diff --git a/src/common/appcontrol_manager.cc b/src/common/appcontrol_manager.cc
index 48901ee4536d7ca21af663d1d2c50d822d932790..e54ceb5939ba7228e1b91769449cf33e101b511b 100644 (file)
--- a/src/common/appcontrol_manager.cc
+++ b/src/common/appcontrol_manager.cc
@@ -16,7 +16,7 @@ int AppControlManager::LaunchApplication(const Capability& capability) {
   int ret;
   bundle* b = bundle_create();
 
-  aul_svc_set_operation(b, capability.name().c_str());
+  aul_svc_set_operation(b, capability.operation().c_str());
   ret = aul_launch_app(capability.pkgid().c_str(), b);
   if (ret < AUL_R_OK) {
     LOG(ERROR) << "launch failed : " << ret;

diff --git a/src/common/capability.h b/src/common/capability.h
index a6532d916829b03c6b4559bf8b0693011652dea4..cc57b2f698710c6c229195de31e63a2ce54ecaa9 100644 (file)
--- a/src/common/capability.h
+++ b/src/common/capability.h
@@ -14,41 +14,51 @@ namespace capmgr {
 
 class Capability {
  public:
-  explicit Capability(const std::string& name, const std::string& pkgid,
-                      const std::string& appid)
-      : name_(std::move(name)), pkgid_(std::move(pkgid)),
-        appid_(std::move(appid)), valid_(true) {}
+  explicit Capability(const std::string& operation, const std::string& uri,
+                      const std::string& mime, const std::string& appid,
+                      const std::string& pkgid)
+      : operation_(std::move(operation)), uri_(std::move(uri)),
+        mime_(std::move(mime)), appid_(std::move(appid)),
+        pkgid_(std::move(pkgid)), valid_(true) {}
   explicit Capability(const std::string& json_string) {
     Json::Reader reader;
     Json::Value root;
 
     if (reader.parse(json_string, root)) {
-      name_ = root["name"].asString();
-      pkgid_ = root["pkgid"].asString();
+      operation_ = root["operation"].asString();
+      uri_ = root["uri"].asString();
+      mime_ = root["mime"].asString();
       appid_ = root["appid"].asString();
+      pkgid_ = root["pkgid"].asString();
       valid_ = true;
     }
   }
 
   std::string Serialize() const {
     Json::Value root;
-    root["name"] = this->name();
-    root["pkgid"] = this->pkgid();
+    root["operation"] = this->operation();
+    root["uri"] = this->uri();
+    root["mime"] = this->mime();
     root["appid"] = this->appid();
+    root["pkgid"] = this->pkgid();
     Json::FastWriter writer;
     return writer.write(root);
   }
 
   bool IsValid() { return valid_; }
 
-  const std::string& name() const { return name_; }
-  const std::string& pkgid() const { return pkgid_; }
+  const std::string& operation() const { return operation_; }
+  const std::string& uri() const { return uri_; }
+  const std::string& mime() const { return mime_; }
   const std::string& appid() const { return appid_; }
+  const std::string& pkgid() const { return pkgid_; }
 
  private:
-  std::string name_;
-  std::string pkgid_;
+  std::string operation_;
+  std::string uri_;
+  std::string mime_;
   std::string appid_;
+  std::string pkgid_;
   bool valid_;
 };
 

diff --git a/src/common/capability_manager.cc b/src/common/capability_manager.cc
index ecabc5e3cf5bb18271f6113b65e05973d9183ec6..10728f707aff1f80021eb20838cc2dafbcc45561 100644 (file)
--- a/src/common/capability_manager.cc
+++ b/src/common/capability_manager.cc
@@ -28,12 +28,8 @@ int AppControlListCb(const char* operation, const char* uri, const char* mime,
     void* user_data) {
   struct CallbackData* cbdata =
       static_cast<struct CallbackData*>(user_data);
-  // test code
-  std::string capname = std::string(operation) + "|" +
-                        std::string(uri ? uri : "empty_uri") + "|" +
-                        std::string(mime ? mime : "empty_mime");
 
-  cbdata->list->emplace_back(capname,
+  cbdata->list->emplace_back(operation, uri ? uri : "", mime ? mime : "",
                              cbdata->pkgid,
                              cbdata->appid);
   return 0;
@@ -90,10 +86,12 @@ const std::vector<Capability>& CapabilityManager::GetCapabilities() const {
 void CapabilityManager::GetList(GVariant **params) {
   GVariantBuilder* builder;
 
-  builder = g_variant_builder_new(G_VARIANT_TYPE("a(sss)"));
+  builder = g_variant_builder_new(G_VARIANT_TYPE("a(sssss)"));
   for (const auto& cap : list_) {
-    g_variant_builder_add(builder, "(sss)",
-        cap.name().c_str(),
+    g_variant_builder_add(builder, "(sssss)",
+        cap.operation().c_str(),
+        cap.uri().c_str(),
+        cap.mime().c_str(),
         cap.pkgid().c_str(),
         cap.appid().c_str());
   }
@@ -106,15 +104,6 @@ bool CapabilityManager::AddCapability(const Capability& capability) {
   return true;
 }
 
-// debug
-bool CapabilityManager::ListCapabilities() {
-  for (const auto& cap : list_) {
-    LOG(DEBUG) << "1: " << cap.name() << ", 2: " << cap.pkgid()
-               << ", 3: " << cap.appid();
-  }
-  return true;
-}
-
 bool CapabilityManager::LoadCapabilities() {
   struct CallbackData cbdata;
   cbdata.list = &list_;
@@ -187,8 +176,6 @@ void CapabilityManager::HandlePackageEvent(const std::string& pkgid,
       LOG(ERROR) << "Unknown package event";
       break;
   }
-
-  ListCapabilities();
 }
 
 void CapabilityManager::AddCapabilitiesByPkgId(const std::string& pkgid) {

diff --git a/src/common/capability_manager.h b/src/common/capability_manager.h
index 1bf216e7a831afb0777aa77cf989546619bfc0d7..7769ed761b1e9d261f8772feb958d9ca0fb00512 100644 (file)
--- a/src/common/capability_manager.h
+++ b/src/common/capability_manager.h
@@ -22,7 +22,6 @@ class CapabilityManager {
   const std::vector<Capability>& GetCapabilities() const;
   bool AddCapability(const Capability& capability);
   void GetList(GVariant **params);
-  bool ListCapabilities();
   bool LoadCapabilities();
   std::string PackCapabilities();
   std::vector<Capability> UnpackCapabilities(const std::string& caps_str);

diff --git a/src/common/dbus_service.cc b/src/common/dbus_service.cc
index 2deeeb4c75bb77b215dffe78aacb844cc342960d..2cf32b7fbf9469cfdb3fc79fa2cd966adc3d0248 100644 (file)
--- a/src/common/dbus_service.cc
+++ b/src/common/dbus_service.cc
@@ -100,18 +100,20 @@ bool DBusService::HandleExchangeCapabilities(GVariant* params,
 bool DBusService::HandleSendRemoteAppControl(GVariant* params,
     GDBusMethodInvocation* invocation) {
   LOG(INFO) << "HandleGetRemoteCapabilities ";
-  gchar* name;
+  gchar* operation;
+  gchar* uri;
+  gchar* mime;
   gchar* appid;
   gchar* pkgid;
-  g_variant_get(params, "(sss)", &name, &appid, &pkgid);
+  g_variant_get(params, "(sssss)", &operation, &uri, &mime, &appid, &pkgid);
 
-  Capability cap(name, pkgid, appid);
-  LOG(INFO) << "From: " << cap.name();
+  Capability cap(operation, uri, mime, pkgid, appid);
+  LOG(INFO) << "From: " << cap.operation();
 
   EventHandler().send_app_control_event(&cap,
       [=](Capability cap, int ret) {
         LOG(INFO) << "RET: " << ret;
-        LOG(INFO) << "Success launch: " << cap.name();
+        LOG(INFO) << "Success launch: " << cap.operation();
         g_dbus_method_invocation_return_value(invocation,
             g_variant_new("(b)", ret));
       });

diff --git a/src/common/remote_device.h b/src/common/remote_device.h
index c8ff65baa3c5c1d910cc1527ce932fbca1b9df2c..5fc1fc8c838cc41bfb2fd0dcf16c4485fad75be1 100644 (file)
--- a/src/common/remote_device.h
+++ b/src/common/remote_device.h
@@ -12,16 +12,32 @@ namespace capmgr {
 
 class RemoteDevice {
  public:
-  explicit RemoteDevice(const std::string& name, const std::string& profile,
-                        const std::string& address, const std::string& uuid)
-      : name_(std::move(name)), profile_(std::move(profile)),
-        address_(std::move(address)), uuid_(std::move(uuid)) {}
+  explicit RemoteDevice(const std::string& device_id, const std::string address,
+      const std::string& model_name, const std::string& device_name,
+      const std::string& platform_ver, const std::string& profile,
+      const std::string& sw_ver)
+      : device_id_(std::move(device_id)), address_(std::move(address)),
+        model_name_(std::move(model_name)),
+        device_name_(std::move(device_name)),
+        platform_ver_(std::move(platform_ver)), profile_(std::move(profile)),
+        sw_ver_(std::move(sw_ver)) {}
+
+  const std::string& device_id() const { return device_id_; }
+  const std::string& address() const { return address_; }
+  const std::string& model_name() const { return model_name_; }
+  const std::string& device_name() const { return device_name_; }
+  const std::string& platform_ver() const { return platform_ver_; }
+  const std::string& profile() const { return profile_; }
+  const std::string& sw_ver() const { return sw_ver_; }
 
  private:
-  std::string name_;
-  std::string profile_;
+  std::string device_id_;
   std::string address_;
-  std::string uuid_;
+  std::string model_name_;
+  std::string device_name_;
+  std::string platform_ver_;
+  std::string profile_;
+  std::string sw_ver_;
 };
 
 }  // namespace capmgr