Add lightuser feature

[platform/core/appfw/pkgmgr-info.git] / src / common / parcel / pkginfo_parcelable.cc

diff --git a/src/common/parcel/pkginfo_parcelable.cc b/src/common/parcel/pkginfo_parcelable.cc
index a8d8a2b..5cbc049 100644 (file)
--- a/src/common/parcel/pkginfo_parcelable.cc
+++ b/src/common/parcel/pkginfo_parcelable.cc
@@ -27,8 +27,7 @@ namespace parcel {
 
 void PkgInfoParcelable::WriteIcon(tizen_base::Parcel* parcel,
     GList* icon) const {
-  int size = g_list_length(icon);
-  WriteInt(parcel, size);
+  WriteInt(parcel, g_list_length(icon));
 
   for (GList* tmp = icon; tmp; tmp = tmp->next) {
     icon_x* ptr = reinterpret_cast<icon_x*>(tmp->data);
@@ -43,8 +42,7 @@ void PkgInfoParcelable::WriteIcon(tizen_base::Parcel* parcel,
 
 void PkgInfoParcelable::WriteLabel(tizen_base::Parcel* parcel,
     GList* label) const {
-  int size = g_list_length(label);
-  WriteInt(parcel, size);
+  WriteInt(parcel, g_list_length(label));
 
   for (GList* tmp = label; tmp; tmp = tmp->next) {
     label_x* ptr = reinterpret_cast<label_x*>(tmp->data);
@@ -56,8 +54,7 @@ void PkgInfoParcelable::WriteLabel(tizen_base::Parcel* parcel,
 
 void PkgInfoParcelable::WriteAuthor(tizen_base::Parcel* parcel,
     GList* author) const {
-  int size = g_list_length(author);
-  WriteInt(parcel, size);
+  WriteInt(parcel, g_list_length(author));
 
   for (GList* tmp = author; tmp; tmp = tmp->next) {
     author_x* ptr = reinterpret_cast<author_x*>(tmp->data);
@@ -70,8 +67,7 @@ void PkgInfoParcelable::WriteAuthor(tizen_base::Parcel* parcel,
 
 void PkgInfoParcelable::WriteDescription(tizen_base::Parcel* parcel,
     GList* description) const {
-  int size = g_list_length(description);
-  WriteInt(parcel, size);
+  WriteInt(parcel, g_list_length(description));
 
   for (GList* tmp = description; tmp; tmp = tmp->next) {
     description_x* ptr = reinterpret_cast<description_x*>(tmp->data);
@@ -88,8 +84,7 @@ void PkgInfoParcelable::WriteLicense(tizen_base::Parcel* parcel,
 
 void PkgInfoParcelable::WritePrivileges(tizen_base::Parcel* parcel,
     GList* privileges) const {
-  int size = g_list_length(privileges);
-  WriteInt(parcel, size);
+  WriteInt(parcel, g_list_length(privileges));
 
   for (GList* tmp = privileges; tmp; tmp = tmp->next) {
     privilege_x* ptr = reinterpret_cast<privilege_x*>(tmp->data);
@@ -100,8 +95,7 @@ void PkgInfoParcelable::WritePrivileges(tizen_base::Parcel* parcel,
 
 void PkgInfoParcelable::WriteAppdefinedPrivileges(tizen_base::Parcel* parcel,
     GList* appdefined_privileges) const {
-  int size = g_list_length(appdefined_privileges);
-  WriteInt(parcel, size);
+  WriteInt(parcel, g_list_length(appdefined_privileges));
 
   for (GList* tmp = appdefined_privileges; tmp; tmp = tmp->next) {
     appdefined_privilege_x* ptr =
@@ -114,8 +108,7 @@ void PkgInfoParcelable::WriteAppdefinedPrivileges(tizen_base::Parcel* parcel,
 
 void PkgInfoParcelable::WriteProvidesAppdefinedPrivileges(
     tizen_base::Parcel* parcel, GList* provides_appdefined_privileges) const {
-  int size = g_list_length(provides_appdefined_privileges);
-  WriteInt(parcel, size);
+  WriteInt(parcel, g_list_length(provides_appdefined_privileges));
 
   for (GList* tmp = provides_appdefined_privileges; tmp; tmp = tmp->next) {
     appdefined_privilege_x* ptr =
@@ -128,11 +121,11 @@ void PkgInfoParcelable::WriteProvidesAppdefinedPrivileges(
 
 void PkgInfoParcelable::WriteApplication(tizen_base::Parcel* parcel,
     GList* application) const {
-  std::vector<application_x *> app_vt;
+  std::vector<std::shared_ptr<application_x>> app_vt;
 
   for (GList* tmp = application; tmp; tmp = tmp->next) {
     application_x* ptr = reinterpret_cast<application_x*>(tmp->data);
-    app_vt.push_back(ptr);
+    app_vt.emplace_back(ptr, [] (application_x*) -> void {});
   }
 
   AppInfoParcelable apps(0, std::move(app_vt), false);
@@ -147,17 +140,15 @@ void PkgInfoParcelable::WriteCompatibility(tizen_base::Parcel* parcel,
 
 void PkgInfoParcelable::WriteDeviceprofile(tizen_base::Parcel* parcel,
     GList* deviceprofile) const {
-  int size = g_list_length(deviceprofile);
-  WriteInt(parcel, size);
+  WriteInt(parcel, g_list_length(deviceprofile));
 
   for (GList* tmp = deviceprofile; tmp; tmp = tmp->next)
-    WriteString(parcel, reinterpret_cast<char *>(tmp->data));
+    WriteString(parcel, reinterpret_cast<char*>(tmp->data));
 }
 
 void PkgInfoParcelable::WriteDependencies(tizen_base::Parcel* parcel,
     GList* dependencies) const {
-  int size = g_list_length(dependencies);
-  WriteInt(parcel, size);
+  WriteInt(parcel, g_list_length(dependencies));
 
   for (GList* tmp = dependencies; tmp; tmp = tmp->next) {
     dependency_x* ptr = reinterpret_cast<dependency_x*>(tmp->data);
@@ -169,8 +160,7 @@ void PkgInfoParcelable::WriteDependencies(tizen_base::Parcel* parcel,
 
 void PkgInfoParcelable::WritePlugin(tizen_base::Parcel* parcel,
     GList* plugin) const {
-  int size = g_list_length(plugin);
-  WriteInt(parcel, size);
+  WriteInt(parcel, g_list_length(plugin));
 
   for (GList* tmp = plugin; tmp; tmp = tmp->next) {
     plugin_x* ptr = reinterpret_cast<plugin_x*>(tmp->data);
@@ -183,8 +173,7 @@ void PkgInfoParcelable::WritePlugin(tizen_base::Parcel* parcel,
 
 void PkgInfoParcelable::WriteResAllowedPackages(tizen_base::Parcel* parcel,
     GList* res_allowed_packages) const {
-  int size = g_list_length(res_allowed_packages);
-  WriteInt(parcel, size);
+  WriteInt(parcel, g_list_length(res_allowed_packages));
 
   for (GList* tmp = res_allowed_packages; tmp; tmp = tmp->next) {
     res_allowed_package_x* ptr =
@@ -192,13 +181,13 @@ void PkgInfoParcelable::WriteResAllowedPackages(tizen_base::Parcel* parcel,
     WriteString(parcel, ptr->allowed_package);
 
     WriteInt(parcel, g_list_length(ptr->required_privileges));
-    for (GList *priv = ptr->required_privileges; priv; priv = priv->next)
-      WriteString(parcel, reinterpret_cast<char *>(priv->data));
+    for (GList* priv = ptr->required_privileges; priv; priv = priv->next)
+      WriteString(parcel, reinterpret_cast<char*>(priv->data));
   }
 }
 
 void PkgInfoParcelable::WritePackage(tizen_base::Parcel* parcel,
-    package_x *package) const {
+    package_x* package) const {
   WriteString(parcel, package->for_all_users);
   WriteString(parcel, package->package);
   WriteString(parcel, package->version);
@@ -231,6 +220,8 @@ void PkgInfoParcelable::WritePackage(tizen_base::Parcel* parcel,
   WriteString(parcel, package->locale);
   WriteString(parcel, package->res_type);
   WriteString(parcel, package->res_version);
+  WriteString(parcel, package->is_disabled);
+  WriteString(parcel, package->light_user_switch_mode);
   WriteIcon(parcel, package->icon);
   WriteLabel(parcel, package->label);
   WriteAuthor(parcel, package->author);
@@ -367,10 +358,10 @@ void PkgInfoParcelable::ReadApplication(
   AppInfoParcelable apps;
   parcel->ReadParcelable(&apps);
 
-  std::vector<application_x *> vt = apps.ExtractAppInfo();
+  std::vector<std::shared_ptr<application_x>> vt = apps.ExtractAppInfo();
 
-  for (application_x *application : vt)
-    *list = g_list_append(*list, application);
+  for (auto& application : vt)
+    *list = g_list_append(*list, application.get());
 }
 
 void PkgInfoParcelable::ReadCompatibility(
@@ -384,7 +375,7 @@ void PkgInfoParcelable::ReadDeviceprofile(
   ReadInt(parcel, &size);
 
   for (int i = 0; i < size; ++i) {
-    char *device_profile = nullptr;
+    char* device_profile = nullptr;
     ReadString(parcel, &device_profile);
     *list = g_list_append(*list, device_profile);
   }
@@ -434,10 +425,10 @@ void PkgInfoParcelable::ReadResAllowedPackages(tizen_base::Parcel* parcel,
     ReadString(parcel, &res_allowed_package->allowed_package);
 
     int priv_len;
-    GList *priv_list = nullptr;
+    GList* priv_list = nullptr;
     ReadInt(parcel, &priv_len);
     for (int i = 0; i < priv_len; ++i) {
-      char *priv = nullptr;
+      char* priv = nullptr;
       ReadString(parcel, &priv);
       priv_list = g_list_prepend(priv_list, priv);
     }
@@ -447,7 +438,7 @@ void PkgInfoParcelable::ReadResAllowedPackages(tizen_base::Parcel* parcel,
   }
 }
 
-package_x *PkgInfoParcelable::ReadPackage(tizen_base::Parcel* parcel) {
+package_x* PkgInfoParcelable::ReadPackage(tizen_base::Parcel* parcel) {
   package_x* package =
       reinterpret_cast<package_x*>(calloc(1, sizeof(package_x)));
 
@@ -483,6 +474,8 @@ package_x *PkgInfoParcelable::ReadPackage(tizen_base::Parcel* parcel) {
   ReadString(parcel, &package->locale);
   ReadString(parcel, &package->res_type);
   ReadString(parcel, &package->res_version);
+  ReadString(parcel, &package->is_disabled);
+  ReadString(parcel, &package->light_user_switch_mode);
   ReadIcon(parcel, &package->icon);
   ReadLabel(parcel, &package->label);
   ReadAuthor(parcel, &package->author);
@@ -502,51 +495,45 @@ package_x *PkgInfoParcelable::ReadPackage(tizen_base::Parcel* parcel) {
 
 PkgInfoParcelable::PkgInfoParcelable()
     : AbstractParcelable(0, ParcelableType::PkgInfo),
-    write_type_(WriteType::None), auto_release_(true) {}
+    write_type_(PkgWriteType::None), auto_release_(true) {}
 
 PkgInfoParcelable::PkgInfoParcelable(
-    uid_t uid, std::vector<package_x *>&& pkg_list,
-    WriteType write_type, bool auto_release)
+    uid_t uid, std::vector<std::shared_ptr<package_x>>&& pkg_list,
+    PkgWriteType write_type, bool auto_release)
     : AbstractParcelable(uid, ParcelableType::PkgInfo),
     pkg_list_(std::move(pkg_list)), write_type_(write_type),
     auto_release_(auto_release) {}
 
 PkgInfoParcelable::PkgInfoParcelable(
-    int ret, std::vector<package_x *>&& pkg_list, bool auto_release)
+    int ret, std::vector<std::shared_ptr<package_x>>&& pkg_list,
+    bool auto_release)
     : AbstractParcelable(0, ParcelableType::PkgInfo, ret),
-    pkg_list_(std::move(pkg_list)), write_type_(WriteType::None),
+    pkg_list_(std::move(pkg_list)), write_type_(PkgWriteType::None),
     auto_release_(auto_release) {}
 
 PkgInfoParcelable::~PkgInfoParcelable() {
-  if (!auto_release_)
-    return;
-
-  for (auto pkg : pkg_list_) {
-    pkgmgrinfo_basic_free_package(pkg);
-  }
 }
 
-const std::vector<package_x *>& PkgInfoParcelable::GetPkgInfo() {
+const std::vector<std::shared_ptr<package_x>>& PkgInfoParcelable::GetPkgInfo() {
   return pkg_list_;
 }
 
-std::vector<package_x *> PkgInfoParcelable::ExtractPkgInfo() {
+std::vector<std::shared_ptr<package_x>> PkgInfoParcelable::ExtractPkgInfo() {
   return std::move(pkg_list_);
 }
 
-WriteType PkgInfoParcelable::GetWriteType() {
+PkgWriteType PkgInfoParcelable::GetWriteType() {
   return write_type_;
 }
 
 void PkgInfoParcelable::WriteToParcel(tizen_base::Parcel* parcel) const {
   AbstractParcelable::WriteToParcel(parcel);
-  WriteInt(parcel, write_type_);
+  WriteInt(parcel, static_cast<int>(write_type_));
 
   WriteInt(parcel, pkg_list_.size());
 
-  for (auto pkg : pkg_list_) {
-    WritePackage(parcel, pkg);
-  }
+  for (auto& pkg : pkg_list_)
+    WritePackage(parcel, pkg.get());
 }
 
 void PkgInfoParcelable::ReadFromParcel(tizen_base::Parcel* parcel) {
@@ -556,13 +543,12 @@ void PkgInfoParcelable::ReadFromParcel(tizen_base::Parcel* parcel) {
   AbstractParcelable::ReadFromParcel(parcel);
 
   ReadInt(parcel, &write_type);
-  write_type_ = static_cast<WriteType>(write_type);
+  write_type_ = static_cast<PkgWriteType>(write_type);
 
   ReadInt(parcel, &len);
 
-  for (int i = 0; i < len ; ++i) {
-    pkg_list_.emplace_back(ReadPackage(parcel));
-  }
+  for (int i = 0; i < len ; ++i)
+    pkg_list_.emplace_back(ReadPackage(parcel), [] (package_x*) -> void {});
 }
 
 }  // namespace parcel