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 9b7e03f..5cbc049 100644 (file)
--- a/src/common/parcel/pkginfo_parcelable.cc
+++ b/src/common/parcel/pkginfo_parcelable.cc
@@ -13,20 +13,21 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
+
 #include "pkginfo_parcelable.hh"
 
 #include <vector>
 
-#include "pkgmgrinfo_private.h"
-
 #include "appinfo_parcelable.hh"
 
+#include "pkgmgrinfo_private.h"
+
 namespace pkgmgr_common {
 namespace parcel {
 
-void PkgInfoParcelable::WriteIcon(tizen_base::Parcel* parcel, GList* icon) const {
-  int size = g_list_length(icon);
-  WriteInt(parcel, size);
+void PkgInfoParcelable::WriteIcon(tizen_base::Parcel* parcel,
+    GList* icon) const {
+  WriteInt(parcel, g_list_length(icon));
 
   for (GList* tmp = icon; tmp; tmp = tmp->next) {
     icon_x* ptr = reinterpret_cast<icon_x*>(tmp->data);
@@ -39,9 +40,9 @@ void PkgInfoParcelable::WriteIcon(tizen_base::Parcel* parcel, GList* icon) const
   }
 }
 
-void PkgInfoParcelable::WriteLabel(tizen_base::Parcel* parcel, GList* label) const {
-  int size = g_list_length(label);
-  WriteInt(parcel, size);
+void PkgInfoParcelable::WriteLabel(tizen_base::Parcel* parcel,
+    GList* label) const {
+  WriteInt(parcel, g_list_length(label));
 
   for (GList* tmp = label; tmp; tmp = tmp->next) {
     label_x* ptr = reinterpret_cast<label_x*>(tmp->data);
@@ -51,9 +52,9 @@ void PkgInfoParcelable::WriteLabel(tizen_base::Parcel* parcel, GList* label) con
   }
 }
 
-void PkgInfoParcelable::WriteAuthor(tizen_base::Parcel* parcel, GList* author) const {
-  int size = g_list_length(author);
-  WriteInt(parcel, size);
+void PkgInfoParcelable::WriteAuthor(tizen_base::Parcel* parcel,
+    GList* author) const {
+  WriteInt(parcel, g_list_length(author));
 
   for (GList* tmp = author; tmp; tmp = tmp->next) {
     author_x* ptr = reinterpret_cast<author_x*>(tmp->data);
@@ -64,9 +65,9 @@ void PkgInfoParcelable::WriteAuthor(tizen_base::Parcel* parcel, GList* author) c
   }
 }
 
-void PkgInfoParcelable::WriteDescription(tizen_base::Parcel* parcel, GList* description) const {
-  int size = g_list_length(description);
-  WriteInt(parcel, size);
+void PkgInfoParcelable::WriteDescription(tizen_base::Parcel* parcel,
+    GList* description) const {
+  WriteInt(parcel, g_list_length(description));
 
   for (GList* tmp = description; tmp; tmp = tmp->next) {
     description_x* ptr = reinterpret_cast<description_x*>(tmp->data);
@@ -76,13 +77,14 @@ void PkgInfoParcelable::WriteDescription(tizen_base::Parcel* parcel, GList* desc
   }
 }
 
-void PkgInfoParcelable::WriteLicense(tizen_base::Parcel* parcel, GList* license) const {
+void PkgInfoParcelable::WriteLicense(tizen_base::Parcel* parcel,
+    GList* license) const {
   return;
 }
 
-void PkgInfoParcelable::WritePrivileges(tizen_base::Parcel* parcel, GList* privileges) const {
-  int size = g_list_length(privileges);
-  WriteInt(parcel, size);
+void PkgInfoParcelable::WritePrivileges(tizen_base::Parcel* parcel,
+    GList* privileges) const {
+  WriteInt(parcel, g_list_length(privileges));
 
   for (GList* tmp = privileges; tmp; tmp = tmp->next) {
     privilege_x* ptr = reinterpret_cast<privilege_x*>(tmp->data);
@@ -93,8 +95,7 @@ void PkgInfoParcelable::WritePrivileges(tizen_base::Parcel* parcel, GList* privi
 
 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 =
@@ -105,10 +106,9 @@ 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);
+void PkgInfoParcelable::WriteProvidesAppdefinedPrivileges(
+    tizen_base::Parcel* parcel, GList* provides_appdefined_privileges) const {
+  WriteInt(parcel, g_list_length(provides_appdefined_privileges));
 
   for (GList* tmp = provides_appdefined_privileges; tmp; tmp = tmp->next) {
     appdefined_privilege_x* ptr =
@@ -119,17 +119,18 @@ void PkgInfoParcelable::WriteProvidesAppdefinedPrivileges(tizen_base::Parcel* pa
   }
 }
 
-void PkgInfoParcelable::WriteApplication(tizen_base::Parcel* parcel, GList* application) const {
-//  std::vector<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);
-//  }
-//
-//  auto app_list = std::make_unique<AppInfoParcelable>(std::move(app_vt));
-//
-//  WriteParcel(std::move(app_list));
+void PkgInfoParcelable::WriteApplication(tizen_base::Parcel* parcel,
+    GList* application) const {
+  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.emplace_back(ptr, [] (application_x*) -> void {});
+  }
+
+  AppInfoParcelable apps(0, std::move(app_vt), false);
+
+  parcel->WriteParcelable(apps);
 }
 
 void PkgInfoParcelable::WriteCompatibility(tizen_base::Parcel* parcel,
@@ -139,16 +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);
+void PkgInfoParcelable::WriteDependencies(tizen_base::Parcel* parcel,
+    GList* dependencies) const {
+  WriteInt(parcel, g_list_length(dependencies));
 
   for (GList* tmp = dependencies; tmp; tmp = tmp->next) {
     dependency_x* ptr = reinterpret_cast<dependency_x*>(tmp->data);
@@ -158,9 +158,9 @@ void PkgInfoParcelable::WriteDependencies(tizen_base::Parcel* parcel, GList* dep
   }
 }
 
-void PkgInfoParcelable::WritePlugin(tizen_base::Parcel* parcel, GList* plugin) const {
-  int size = g_list_length(plugin);
-  WriteInt(parcel, size);
+void PkgInfoParcelable::WritePlugin(tizen_base::Parcel* parcel,
+    GList* plugin) const {
+  WriteInt(parcel, g_list_length(plugin));
 
   for (GList* tmp = plugin; tmp; tmp = tmp->next) {
     plugin_x* ptr = reinterpret_cast<plugin_x*>(tmp->data);
@@ -171,7 +171,23 @@ void PkgInfoParcelable::WritePlugin(tizen_base::Parcel* parcel, GList* plugin) c
   }
 }
 
-void PkgInfoParcelable::WritePackage(tizen_base::Parcel* parcel, package_x *package) const {
+void PkgInfoParcelable::WriteResAllowedPackages(tizen_base::Parcel* parcel,
+    GList* res_allowed_packages) const {
+  WriteInt(parcel, g_list_length(res_allowed_packages));
+
+  for (GList* tmp = res_allowed_packages; tmp; tmp = tmp->next) {
+    res_allowed_package_x* ptr =
+        reinterpret_cast<res_allowed_package_x*>(tmp->data);
+    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));
+  }
+}
+
+void PkgInfoParcelable::WritePackage(tizen_base::Parcel* parcel,
+    package_x* package) const {
   WriteString(parcel, package->for_all_users);
   WriteString(parcel, package->package);
   WriteString(parcel, package->version);
@@ -202,19 +218,23 @@ void PkgInfoParcelable::WritePackage(tizen_base::Parcel* parcel, package_x *pack
   WriteString(parcel, package->external_path);
   WriteString(parcel, package->use_system_certs);
   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);
   WriteDescription(parcel, package->description);
-  //WriteLicense(parcel, package->license);
   WritePrivileges(parcel, package->privileges);
   WriteAppdefinedPrivileges(parcel, package->appdefined_privileges);
-  WriteProvidesAppdefinedPrivileges(parcel, package->provides_appdefined_privileges);
+  WriteProvidesAppdefinedPrivileges(parcel,
+      package->provides_appdefined_privileges);
   WriteApplication(parcel, package->application);
-  //WriteCompatibility(parcel, package->compatibility);
   WriteDeviceprofile(parcel, package->deviceprofile);
   WriteDependencies(parcel, package->dependencies);
   WritePlugin(parcel, package->plugin);
+  WriteResAllowedPackages(parcel, package->res_allowed_packages);
 }
 
 void PkgInfoParcelable::ReadIcon(tizen_base::Parcel* parcel, GList** list) {
@@ -253,7 +273,8 @@ void PkgInfoParcelable::ReadAuthor(tizen_base::Parcel* parcel, GList** list) {
   ReadInt(parcel, &size);
 
   for (int i = 0; i < size; ++i) {
-    author_x* author = reinterpret_cast<author_x*>(calloc(1, sizeof(author_x)));
+    author_x* author = reinterpret_cast<author_x*>(
+        calloc(1, sizeof(author_x)));
     ReadString(parcel, &author->email);
     ReadString(parcel, &author->href);
     ReadString(parcel, &author->text);
@@ -263,7 +284,8 @@ void PkgInfoParcelable::ReadAuthor(tizen_base::Parcel* parcel, GList** list) {
   }
 }
 
-void PkgInfoParcelable::ReadDescription(tizen_base::Parcel* parcel, GList** list) {
+void PkgInfoParcelable::ReadDescription(
+    tizen_base::Parcel* parcel, GList** list) {
   int size = 0;
   ReadInt(parcel, &size);
 
@@ -282,7 +304,8 @@ void PkgInfoParcelable::ReadLicense(tizen_base::Parcel* parcel, GList** list) {
   return;
 }
 
-void PkgInfoParcelable::ReadPrivileges(tizen_base::Parcel* parcel, GList** list) {
+void PkgInfoParcelable::ReadPrivileges(
+    tizen_base::Parcel* parcel, GList** list) {
   int size = 0;
   ReadInt(parcel, &size);
 
@@ -296,7 +319,8 @@ void PkgInfoParcelable::ReadPrivileges(tizen_base::Parcel* parcel, GList** list)
   }
 }
 
-void PkgInfoParcelable::ReadAppdefinedPrivileges(tizen_base::Parcel* parcel, GList** list) {
+void PkgInfoParcelable::ReadAppdefinedPrivileges(
+    tizen_base::Parcel* parcel, GList** list) {
   int size = 0;
   ReadInt(parcel, &size);
 
@@ -312,8 +336,8 @@ void PkgInfoParcelable::ReadAppdefinedPrivileges(tizen_base::Parcel* parcel, GLi
   }
 }
 
-void PkgInfoParcelable::ReadProvidesAppdefinedPrivileges(tizen_base::Parcel* parcel,
-    GList** list) {
+void PkgInfoParcelable::ReadProvidesAppdefinedPrivileges(
+    tizen_base::Parcel* parcel, GList** list) {
   int size = 0;
   ReadInt(parcel, &size);
 
@@ -329,33 +353,36 @@ void PkgInfoParcelable::ReadProvidesAppdefinedPrivileges(tizen_base::Parcel* par
   }
 }
 
-void PkgInfoParcelable::ReadApplication(tizen_base::Parcel* parcel, GList** list) {
-//  const unsigned char *buf = nullptr;
-//  unsigned int size = 0;
-//  ReadParcelRaw(&buf, &size);
-//  auto appinfo_parcel = AppInfoParcelable::Create(buf, size);
-//  auto appinfo_list = appinfo_parcel->GetAppInfo();
-//
-//  for (const auto& application : appinfo_list)
-//    *list = g_list_append(*list, application);
+void PkgInfoParcelable::ReadApplication(
+    tizen_base::Parcel* parcel, GList** list) {
+  AppInfoParcelable apps;
+  parcel->ReadParcelable(&apps);
+
+  std::vector<std::shared_ptr<application_x>> vt = apps.ExtractAppInfo();
+
+  for (auto& application : vt)
+    *list = g_list_append(*list, application.get());
 }
 
-void PkgInfoParcelable::ReadCompatibility(tizen_base::Parcel* parcel, GList** list) {
+void PkgInfoParcelable::ReadCompatibility(
+    tizen_base::Parcel* parcel, GList** list) {
   return;
 }
 
-void PkgInfoParcelable::ReadDeviceprofile(tizen_base::Parcel* parcel, GList** list) {
+void PkgInfoParcelable::ReadDeviceprofile(
+    tizen_base::Parcel* parcel, GList** list) {
   int size = 0;
   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);
   }
 }
 
-void PkgInfoParcelable::ReadDependencies(tizen_base::Parcel* parcel, GList** list) {
+void PkgInfoParcelable::ReadDependencies(
+    tizen_base::Parcel* parcel, GList** list) {
   int size = 0;
   ReadInt(parcel, &size);
 
@@ -375,7 +402,8 @@ void PkgInfoParcelable::ReadPlugin(tizen_base::Parcel* parcel, GList** list) {
   ReadInt(parcel, &size);
 
   for (int i = 0; i < size; ++i) {
-    plugin_x* plugin = reinterpret_cast<plugin_x*>(calloc(1, sizeof(plugin_x)));
+    plugin_x* plugin = reinterpret_cast<plugin_x*>(
+        calloc(1, sizeof(plugin_x)));
     ReadString(parcel, &plugin->pkgid);
     ReadString(parcel, &plugin->appid);
     ReadString(parcel, &plugin->plugin_type);
@@ -385,7 +413,32 @@ void PkgInfoParcelable::ReadPlugin(tizen_base::Parcel* parcel, GList** list) {
   }
 }
 
-package_x *PkgInfoParcelable::ReadPackage(tizen_base::Parcel* parcel) {
+void PkgInfoParcelable::ReadResAllowedPackages(tizen_base::Parcel* parcel,
+    GList** list) {
+  int size = 0;
+  ReadInt(parcel, &size);
+
+  for (int i = 0; i < size; ++i) {
+    res_allowed_package_x* res_allowed_package =
+        reinterpret_cast<res_allowed_package_x*>(
+            calloc(1, sizeof(res_allowed_package_x)));
+    ReadString(parcel, &res_allowed_package->allowed_package);
+
+    int priv_len;
+    GList* priv_list = nullptr;
+    ReadInt(parcel, &priv_len);
+    for (int i = 0; i < priv_len; ++i) {
+      char* priv = nullptr;
+      ReadString(parcel, &priv);
+      priv_list = g_list_prepend(priv_list, priv);
+    }
+    res_allowed_package->required_privileges = priv_list;
+
+    *list = g_list_prepend(*list, res_allowed_package);
+  }
+}
+
+package_x* PkgInfoParcelable::ReadPackage(tizen_base::Parcel* parcel) {
   package_x* package =
       reinterpret_cast<package_x*>(calloc(1, sizeof(package_x)));
 
@@ -419,46 +472,68 @@ package_x *PkgInfoParcelable::ReadPackage(tizen_base::Parcel* parcel) {
   ReadString(parcel, &package->external_path);
   ReadString(parcel, &package->use_system_certs);
   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);
   ReadDescription(parcel, &package->description);
-  //ReadLicense(parcel, &package->license);
   ReadPrivileges(parcel, &package->privileges);
   ReadAppdefinedPrivileges(parcel, &package->appdefined_privileges);
-  ReadProvidesAppdefinedPrivileges(parcel, &package->provides_appdefined_privileges);
+  ReadProvidesAppdefinedPrivileges(parcel,
+      &package->provides_appdefined_privileges);
   ReadApplication(parcel, &package->application);
-  //ReadCompatibility(parcel, &package->compatibility);
   ReadDeviceprofile(parcel, &package->deviceprofile);
   ReadDependencies(parcel, &package->dependencies);
   ReadPlugin(parcel, &package->plugin);
+  ReadResAllowedPackages(parcel, &package->res_allowed_packages);
 
   return package;
 }
 
 PkgInfoParcelable::PkgInfoParcelable()
-    : AbstractParcelable(0, ParcelableType::PkgInfo) {}
+    : AbstractParcelable(0, ParcelableType::PkgInfo),
+    write_type_(PkgWriteType::None), auto_release_(true) {}
+
+PkgInfoParcelable::PkgInfoParcelable(
+    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(uid_t uid, std::vector<package_x *>&& pkg_list, WriteType write_type)
-    : AbstractParcelable(uid, ParcelableType::PkgInfo), pkg_list_(std::move(pkg_list)), write_type_(write_type) {}
+PkgInfoParcelable::PkgInfoParcelable(
+    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_(PkgWriteType::None),
+    auto_release_(auto_release) {}
 
-const std::vector<package_x *>& PkgInfoParcelable::GetPkgInfo() {
+PkgInfoParcelable::~PkgInfoParcelable() {
+}
+
+const std::vector<std::shared_ptr<package_x>>& PkgInfoParcelable::GetPkgInfo() {
   return pkg_list_;
 }
 
-WriteType PkgInfoParcelable::GetWriteType() {
+std::vector<std::shared_ptr<package_x>> PkgInfoParcelable::ExtractPkgInfo() {
+  return std::move(pkg_list_);
+}
+
+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) {
@@ -468,17 +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));
-  }
-}
-
-std::unique_ptr<AbstractParcelable> PkgInfoParcelable::Factory::CreateParcel() {
-  return nullptr;
+  for (int i = 0; i < len ; ++i)
+    pkg_list_.emplace_back(ReadPackage(parcel), [] (package_x*) -> void {});
 }
 
 }  // namespace parcel