2 * Copyright (c) 2021 Samsung Electronics Co., Ltd All Rights Reserved
4 * Licensed under the Apache License, Version 2.0 (the License);
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
8 * http://www.apache.org/licenses/LICENSE-2.0
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an AS IS BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
16 #include "pkginfo_parcelable.hh"
20 #include "pkgmgrinfo_private.h"
22 #include "appinfo_parcelable.hh"
24 namespace pkgmgr_common {
27 void PkgInfoParcelable::WriteIcon(tizen_base::Parcel* parcel, GList* icon) const {
28 int size = g_list_length(icon);
29 WriteInt(parcel, size);
31 for (GList* tmp = icon; tmp; tmp = tmp->next) {
32 icon_x* ptr = reinterpret_cast<icon_x*>(tmp->data);
33 WriteString(parcel, ptr->text);
34 WriteString(parcel, ptr->lang);
35 WriteString(parcel, ptr->section);
36 WriteString(parcel, ptr->size);
37 WriteString(parcel, ptr->resolution);
38 WriteString(parcel, ptr->dpi);
42 void PkgInfoParcelable::WriteLabel(tizen_base::Parcel* parcel, GList* label) const {
43 int size = g_list_length(label);
44 WriteInt(parcel, size);
46 for (GList* tmp = label; tmp; tmp = tmp->next) {
47 label_x* ptr = reinterpret_cast<label_x*>(tmp->data);
48 WriteString(parcel, ptr->lang);
49 WriteString(parcel, ptr->name);
50 WriteString(parcel, ptr->text);
54 void PkgInfoParcelable::WriteAuthor(tizen_base::Parcel* parcel, GList* author) const {
55 int size = g_list_length(author);
56 WriteInt(parcel, size);
58 for (GList* tmp = author; tmp; tmp = tmp->next) {
59 author_x* ptr = reinterpret_cast<author_x*>(tmp->data);
60 WriteString(parcel, ptr->email);
61 WriteString(parcel, ptr->href);
62 WriteString(parcel, ptr->text);
63 WriteString(parcel, ptr->lang);
67 void PkgInfoParcelable::WriteDescription(tizen_base::Parcel* parcel, GList* description) const {
68 int size = g_list_length(description);
69 WriteInt(parcel, size);
71 for (GList* tmp = description; tmp; tmp = tmp->next) {
72 description_x* ptr = reinterpret_cast<description_x*>(tmp->data);
73 WriteString(parcel, ptr->name);
74 WriteString(parcel, ptr->text);
75 WriteString(parcel, ptr->lang);
79 void PkgInfoParcelable::WriteLicense(tizen_base::Parcel* parcel, GList* license) const {
83 void PkgInfoParcelable::WritePrivileges(tizen_base::Parcel* parcel, GList* privileges) const {
84 int size = g_list_length(privileges);
85 WriteInt(parcel, size);
87 for (GList* tmp = privileges; tmp; tmp = tmp->next) {
88 privilege_x* ptr = reinterpret_cast<privilege_x*>(tmp->data);
89 WriteString(parcel, ptr->type);
90 WriteString(parcel, ptr->value);
94 void PkgInfoParcelable::WriteAppdefinedPrivileges(tizen_base::Parcel* parcel,
95 GList* appdefined_privileges) const {
96 int size = g_list_length(appdefined_privileges);
97 WriteInt(parcel, size);
99 for (GList* tmp = appdefined_privileges; tmp; tmp = tmp->next) {
100 appdefined_privilege_x* ptr =
101 reinterpret_cast<appdefined_privilege_x*>(tmp->data);
102 WriteString(parcel, ptr->type);
103 WriteString(parcel, ptr->value);
104 WriteString(parcel, ptr->license);
108 void PkgInfoParcelable::WriteProvidesAppdefinedPrivileges(tizen_base::Parcel* parcel,
109 GList* provides_appdefined_privileges) const {
110 int size = g_list_length(provides_appdefined_privileges);
111 WriteInt(parcel, size);
113 for (GList* tmp = provides_appdefined_privileges; tmp; tmp = tmp->next) {
114 appdefined_privilege_x* ptr =
115 reinterpret_cast<appdefined_privilege_x*>(tmp->data);
116 WriteString(parcel, ptr->type);
117 WriteString(parcel, ptr->value);
118 WriteString(parcel, ptr->license);
122 void PkgInfoParcelable::WriteApplication(tizen_base::Parcel* parcel, GList* application) const {
123 // std::vector<application_x *> app_vt;
125 // for (GList* tmp = application; tmp; tmp = tmp->next) {
126 // application_x* ptr = reinterpret_cast<application_x*>(tmp->data);
127 // app_vt.push_back(ptr);
130 // auto app_list = std::make_unique<AppInfoParcelable>(std::move(app_vt));
132 // WriteParcel(std::move(app_list));
135 void PkgInfoParcelable::WriteCompatibility(tizen_base::Parcel* parcel,
136 GList* compatibility) const {
140 void PkgInfoParcelable::WriteDeviceprofile(tizen_base::Parcel* parcel,
141 GList* deviceprofile) const {
142 int size = g_list_length(deviceprofile);
143 WriteInt(parcel, size);
145 for (GList* tmp = deviceprofile; tmp; tmp = tmp->next)
146 WriteString(parcel, reinterpret_cast<char *>(tmp->data));
149 void PkgInfoParcelable::WriteDependencies(tizen_base::Parcel* parcel, GList* dependencies) const {
150 int size = g_list_length(dependencies);
151 WriteInt(parcel, size);
153 for (GList* tmp = dependencies; tmp; tmp = tmp->next) {
154 dependency_x* ptr = reinterpret_cast<dependency_x*>(tmp->data);
155 WriteString(parcel, ptr->depends_on);
156 WriteString(parcel, ptr->type);
157 WriteString(parcel, ptr->required_version);
161 void PkgInfoParcelable::WritePlugin(tizen_base::Parcel* parcel, GList* plugin) const {
162 int size = g_list_length(plugin);
163 WriteInt(parcel, size);
165 for (GList* tmp = plugin; tmp; tmp = tmp->next) {
166 plugin_x* ptr = reinterpret_cast<plugin_x*>(tmp->data);
167 WriteString(parcel, ptr->pkgid);
168 WriteString(parcel, ptr->appid);
169 WriteString(parcel, ptr->plugin_type);
170 WriteString(parcel, ptr->plugin_name);
174 void PkgInfoParcelable::WritePackage(tizen_base::Parcel* parcel, package_x *package) const {
175 WriteString(parcel, package->for_all_users);
176 WriteString(parcel, package->package);
177 WriteString(parcel, package->version);
178 WriteString(parcel, package->installlocation);
179 WriteString(parcel, package->ns);
180 WriteString(parcel, package->removable);
181 WriteString(parcel, package->preload);
182 WriteString(parcel, package->readonly);
183 WriteString(parcel, package->update);
184 WriteString(parcel, package->appsetting);
185 WriteString(parcel, package->system);
186 WriteString(parcel, package->type);
187 WriteString(parcel, package->package_size);
188 WriteString(parcel, package->installed_time);
189 WriteString(parcel, package->installed_storage);
190 WriteString(parcel, package->storeclient_id);
191 WriteString(parcel, package->mainapp_id);
192 WriteString(parcel, package->package_url);
193 WriteString(parcel, package->root_path);
194 WriteString(parcel, package->csc_path);
195 WriteString(parcel, package->nodisplay_setting);
196 WriteString(parcel, package->support_mode);
197 WriteString(parcel, package->support_disable);
198 WriteString(parcel, package->api_version);
199 WriteString(parcel, package->tep_name);
200 WriteString(parcel, package->zip_mount_file);
201 WriteString(parcel, package->backend_installer);
202 WriteString(parcel, package->external_path);
203 WriteString(parcel, package->use_system_certs);
204 WriteIcon(parcel, package->icon);
205 WriteLabel(parcel, package->label);
206 WriteAuthor(parcel, package->author);
207 WriteDescription(parcel, package->description);
208 //WriteLicense(parcel, package->license);
209 WritePrivileges(parcel, package->privileges);
210 WriteAppdefinedPrivileges(parcel, package->appdefined_privileges);
211 WriteProvidesAppdefinedPrivileges(parcel, package->provides_appdefined_privileges);
212 WriteApplication(parcel, package->application);
213 //WriteCompatibility(parcel, package->compatibility);
214 WriteDeviceprofile(parcel, package->deviceprofile);
215 WriteDependencies(parcel, package->dependencies);
216 WritePlugin(parcel, package->plugin);
219 void PkgInfoParcelable::ReadIcon(tizen_base::Parcel* parcel, GList** list) {
221 ReadInt(parcel, &size);
223 for (int i = 0; i < size; ++i) {
224 icon_x* icon = reinterpret_cast<icon_x*>(calloc(1, sizeof(icon_x)));
225 ReadString(parcel, &icon->text);
226 ReadString(parcel, &icon->lang);
227 ReadString(parcel, &icon->section);
228 ReadString(parcel, &icon->size);
229 ReadString(parcel, &icon->resolution);
230 ReadString(parcel, &icon->dpi);
232 *list = g_list_append(*list, icon);
236 void PkgInfoParcelable::ReadLabel(tizen_base::Parcel* parcel, GList** list) {
238 ReadInt(parcel, &size);
240 for (int i = 0; i < size; ++i) {
241 label_x* label = reinterpret_cast<label_x*>(calloc(1, sizeof(label_x)));
242 ReadString(parcel, &label->lang);
243 ReadString(parcel, &label->name);
244 ReadString(parcel, &label->text);
246 *list = g_list_append(*list, label);
250 void PkgInfoParcelable::ReadAuthor(tizen_base::Parcel* parcel, GList** list) {
252 ReadInt(parcel, &size);
254 for (int i = 0; i < size; ++i) {
255 author_x* author = reinterpret_cast<author_x*>(calloc(1, sizeof(author_x)));
256 ReadString(parcel, &author->email);
257 ReadString(parcel, &author->href);
258 ReadString(parcel, &author->text);
259 ReadString(parcel, &author->lang);
261 *list = g_list_append(*list, author);
265 void PkgInfoParcelable::ReadDescription(tizen_base::Parcel* parcel, GList** list) {
267 ReadInt(parcel, &size);
269 for (int i = 0; i < size; ++i) {
270 description_x* description =
271 reinterpret_cast<description_x*>(calloc(1, sizeof(description_x)));
272 ReadString(parcel, &description->name);
273 ReadString(parcel, &description->text);
274 ReadString(parcel, &description->lang);
276 *list = g_list_append(*list, description);
280 void PkgInfoParcelable::ReadLicense(tizen_base::Parcel* parcel, GList** list) {
284 void PkgInfoParcelable::ReadPrivileges(tizen_base::Parcel* parcel, GList** list) {
286 ReadInt(parcel, &size);
288 for (int i = 0; i < size; ++i) {
289 privilege_x* privilege =
290 reinterpret_cast<privilege_x*>(calloc(1, sizeof(privilege_x)));
291 ReadString(parcel, &privilege->type);
292 ReadString(parcel, &privilege->value);
294 *list = g_list_append(*list, privilege);
298 void PkgInfoParcelable::ReadAppdefinedPrivileges(tizen_base::Parcel* parcel, GList** list) {
300 ReadInt(parcel, &size);
302 for (int i = 0; i < size; ++i) {
303 appdefined_privilege_x* appdefined_privilege =
304 reinterpret_cast<appdefined_privilege_x*>(
305 calloc(1, sizeof(appdefined_privilege_x)));
306 ReadString(parcel, &appdefined_privilege->type);
307 ReadString(parcel, &appdefined_privilege->value);
308 ReadString(parcel, &appdefined_privilege->license);
310 *list = g_list_append(*list, appdefined_privilege);
314 void PkgInfoParcelable::ReadProvidesAppdefinedPrivileges(tizen_base::Parcel* parcel,
317 ReadInt(parcel, &size);
319 for (int i = 0; i < size; ++i) {
320 appdefined_privilege_x* appdefined_privilege =
321 reinterpret_cast<appdefined_privilege_x*>(
322 calloc(1, sizeof(appdefined_privilege_x)));
323 ReadString(parcel, &appdefined_privilege->type);
324 ReadString(parcel, &appdefined_privilege->value);
325 ReadString(parcel, &appdefined_privilege->license);
327 *list = g_list_append(*list, appdefined_privilege);
331 void PkgInfoParcelable::ReadApplication(tizen_base::Parcel* parcel, GList** list) {
332 // const unsigned char *buf = nullptr;
333 // unsigned int size = 0;
334 // ReadParcelRaw(&buf, &size);
335 // auto appinfo_parcel = AppInfoParcelable::Create(buf, size);
336 // auto appinfo_list = appinfo_parcel->GetAppInfo();
338 // for (const auto& application : appinfo_list)
339 // *list = g_list_append(*list, application);
342 void PkgInfoParcelable::ReadCompatibility(tizen_base::Parcel* parcel, GList** list) {
346 void PkgInfoParcelable::ReadDeviceprofile(tizen_base::Parcel* parcel, GList** list) {
348 ReadInt(parcel, &size);
350 for (int i = 0; i < size; ++i) {
351 char *device_profile = nullptr;
352 ReadString(parcel, &device_profile);
353 *list = g_list_append(*list, device_profile);
357 void PkgInfoParcelable::ReadDependencies(tizen_base::Parcel* parcel, GList** list) {
359 ReadInt(parcel, &size);
361 for (int i = 0; i < size; ++i) {
362 dependency_x* dependendy =
363 reinterpret_cast<dependency_x*>(calloc(1, sizeof(dependency_x)));
364 ReadString(parcel, &dependendy->depends_on);
365 ReadString(parcel, &dependendy->type);
366 ReadString(parcel, &dependendy->required_version);
368 *list = g_list_append(*list, dependendy);
372 void PkgInfoParcelable::ReadPlugin(tizen_base::Parcel* parcel, GList** list) {
374 ReadInt(parcel, &size);
376 for (int i = 0; i < size; ++i) {
377 plugin_x* plugin = reinterpret_cast<plugin_x*>(calloc(1, sizeof(plugin_x)));
378 ReadString(parcel, &plugin->pkgid);
379 ReadString(parcel, &plugin->appid);
380 ReadString(parcel, &plugin->plugin_type);
381 ReadString(parcel, &plugin->plugin_name);
383 *list = g_list_append(*list, plugin);
387 package_x *PkgInfoParcelable::ReadPackage(tizen_base::Parcel* parcel) {
389 reinterpret_cast<package_x*>(calloc(1, sizeof(package_x)));
391 ReadString(parcel, &package->for_all_users);
392 ReadString(parcel, &package->package);
393 ReadString(parcel, &package->version);
394 ReadString(parcel, &package->installlocation);
395 ReadString(parcel, &package->ns);
396 ReadString(parcel, &package->removable);
397 ReadString(parcel, &package->preload);
398 ReadString(parcel, &package->readonly);
399 ReadString(parcel, &package->update);
400 ReadString(parcel, &package->appsetting);
401 ReadString(parcel, &package->system);
402 ReadString(parcel, &package->type);
403 ReadString(parcel, &package->package_size);
404 ReadString(parcel, &package->installed_time);
405 ReadString(parcel, &package->installed_storage);
406 ReadString(parcel, &package->storeclient_id);
407 ReadString(parcel, &package->mainapp_id);
408 ReadString(parcel, &package->package_url);
409 ReadString(parcel, &package->root_path);
410 ReadString(parcel, &package->csc_path);
411 ReadString(parcel, &package->nodisplay_setting);
412 ReadString(parcel, &package->support_mode);
413 ReadString(parcel, &package->support_disable);
414 ReadString(parcel, &package->api_version);
415 ReadString(parcel, &package->tep_name);
416 ReadString(parcel, &package->zip_mount_file);
417 ReadString(parcel, &package->backend_installer);
418 ReadString(parcel, &package->external_path);
419 ReadString(parcel, &package->use_system_certs);
420 ReadIcon(parcel, &package->icon);
421 ReadLabel(parcel, &package->label);
422 ReadAuthor(parcel, &package->author);
423 ReadDescription(parcel, &package->description);
424 //ReadLicense(parcel, &package->license);
425 ReadPrivileges(parcel, &package->privileges);
426 ReadAppdefinedPrivileges(parcel, &package->appdefined_privileges);
427 ReadProvidesAppdefinedPrivileges(parcel, &package->provides_appdefined_privileges);
428 ReadApplication(parcel, &package->application);
429 //ReadCompatibility(parcel, &package->compatibility);
430 ReadDeviceprofile(parcel, &package->deviceprofile);
431 ReadDependencies(parcel, &package->dependencies);
432 ReadPlugin(parcel, &package->plugin);
437 PkgInfoParcelable::PkgInfoParcelable()
438 : AbstractParcelable(0, ParcelableType::PkgInfo) {}
440 PkgInfoParcelable::PkgInfoParcelable(std::vector<package_x *>&& pkg_list)
441 : pkg_list_(std::move(pkg_list)) {}
443 PkgInfoParcelable::~PkgInfoParcelable() {
444 for (auto pkg : pkg_list_) {
445 pkgmgrinfo_basic_free_package(pkg);
449 const std::vector<package_x *>& PkgInfoParcelable::GetPkgInfo() {
453 void PkgInfoParcelable::WriteToParcel(tizen_base::Parcel* parcel) const {
454 AbstractParcelable::WriteToParcel(parcel);
455 WriteInt(parcel, pkg_list_.size());
457 for (auto pkg : pkg_list_) {
458 WritePackage(parcel, pkg);
462 void PkgInfoParcelable::ReadFromParcel(tizen_base::Parcel* parcel) {
465 AbstractParcelable::ReadFromParcel(parcel);
466 ReadInt(parcel, &len);
468 for (int i = 0; i < len ; ++i) {
469 pkg_list_.emplace_back(ReadPackage(parcel));
473 std::unique_ptr<AbstractParcelable> PkgInfoParcelable::Factory::CreateParcel() {
477 } // namespace parcel
478 } // namespace pkgmgr_common