* 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);
}
}
-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);
}
}
-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);
}
}
-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);
}
}
-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);
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 =
}
}
-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 =
}
}
-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,
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);
}
}
-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);
}
}
-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);
WriteString(parcel, package->backend_installer);
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) {
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);
}
}
-void PkgInfoParcelable::ReadDescription(tizen_base::Parcel* parcel, GList** list) {
+void PkgInfoParcelable::ReadDescription(
+ tizen_base::Parcel* parcel, GList** list) {
int size = 0;
ReadInt(parcel, &size);
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);
}
}
-void PkgInfoParcelable::ReadAppdefinedPrivileges(tizen_base::Parcel* parcel, GList** list) {
+void PkgInfoParcelable::ReadAppdefinedPrivileges(
+ tizen_base::Parcel* parcel, GList** list) {
int size = 0;
ReadInt(parcel, &size);
}
}
-void PkgInfoParcelable::ReadProvidesAppdefinedPrivileges(tizen_base::Parcel* parcel,
- GList** list) {
+void PkgInfoParcelable::ReadProvidesAppdefinedPrivileges(
+ tizen_base::Parcel* parcel, GList** list) {
int size = 0;
ReadInt(parcel, &size);
}
}
-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);
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);
}
}
-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)));
ReadString(parcel, &package->backend_installer);
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) {}
-
-PkgInfoParcelable::PkgInfoParcelable(std::vector<package_x *>&& pkg_list)
- : pkg_list_(std::move(pkg_list)) {}
+ : 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(
+ 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) {}
PkgInfoParcelable::~PkgInfoParcelable() {
- 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<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, 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) {
int len = 0;
+ int write_type = 0;
AbstractParcelable::ReadFromParcel(parcel);
- ReadInt(parcel, &len);
- for (int i = 0; i < len ; ++i) {
- pkg_list_.emplace_back(ReadPackage(parcel));
- }
-}
+ ReadInt(parcel, &write_type);
+ write_type_ = static_cast<PkgWriteType>(write_type);
+
+ ReadInt(parcel, &len);
-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