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 WriteString(parcel, package->locale);
205 WriteIcon(parcel, package->icon);
206 WriteLabel(parcel, package->label);
207 WriteAuthor(parcel, package->author);
208 WriteDescription(parcel, package->description);
209 //WriteLicense(parcel, package->license);
210 WritePrivileges(parcel, package->privileges);
211 WriteAppdefinedPrivileges(parcel, package->appdefined_privileges);
212 WriteProvidesAppdefinedPrivileges(parcel, package->provides_appdefined_privileges);
213 WriteApplication(parcel, package->application);
214 //WriteCompatibility(parcel, package->compatibility);
215 WriteDeviceprofile(parcel, package->deviceprofile);
216 WriteDependencies(parcel, package->dependencies);
217 WritePlugin(parcel, package->plugin);
220 void PkgInfoParcelable::ReadIcon(tizen_base::Parcel* parcel, GList** list) {
222 ReadInt(parcel, &size);
224 for (int i = 0; i < size; ++i) {
225 icon_x* icon = reinterpret_cast<icon_x*>(calloc(1, sizeof(icon_x)));
226 ReadString(parcel, &icon->text);
227 ReadString(parcel, &icon->lang);
228 ReadString(parcel, &icon->section);
229 ReadString(parcel, &icon->size);
230 ReadString(parcel, &icon->resolution);
231 ReadString(parcel, &icon->dpi);
233 *list = g_list_append(*list, icon);
237 void PkgInfoParcelable::ReadLabel(tizen_base::Parcel* parcel, GList** list) {
239 ReadInt(parcel, &size);
241 for (int i = 0; i < size; ++i) {
242 label_x* label = reinterpret_cast<label_x*>(calloc(1, sizeof(label_x)));
243 ReadString(parcel, &label->lang);
244 ReadString(parcel, &label->name);
245 ReadString(parcel, &label->text);
247 *list = g_list_append(*list, label);
251 void PkgInfoParcelable::ReadAuthor(tizen_base::Parcel* parcel, GList** list) {
253 ReadInt(parcel, &size);
255 for (int i = 0; i < size; ++i) {
256 author_x* author = reinterpret_cast<author_x*>(calloc(1, sizeof(author_x)));
257 ReadString(parcel, &author->email);
258 ReadString(parcel, &author->href);
259 ReadString(parcel, &author->text);
260 ReadString(parcel, &author->lang);
262 *list = g_list_append(*list, author);
266 void PkgInfoParcelable::ReadDescription(tizen_base::Parcel* parcel, GList** list) {
268 ReadInt(parcel, &size);
270 for (int i = 0; i < size; ++i) {
271 description_x* description =
272 reinterpret_cast<description_x*>(calloc(1, sizeof(description_x)));
273 ReadString(parcel, &description->name);
274 ReadString(parcel, &description->text);
275 ReadString(parcel, &description->lang);
277 *list = g_list_append(*list, description);
281 void PkgInfoParcelable::ReadLicense(tizen_base::Parcel* parcel, GList** list) {
285 void PkgInfoParcelable::ReadPrivileges(tizen_base::Parcel* parcel, GList** list) {
287 ReadInt(parcel, &size);
289 for (int i = 0; i < size; ++i) {
290 privilege_x* privilege =
291 reinterpret_cast<privilege_x*>(calloc(1, sizeof(privilege_x)));
292 ReadString(parcel, &privilege->type);
293 ReadString(parcel, &privilege->value);
295 *list = g_list_append(*list, privilege);
299 void PkgInfoParcelable::ReadAppdefinedPrivileges(tizen_base::Parcel* parcel, GList** list) {
301 ReadInt(parcel, &size);
303 for (int i = 0; i < size; ++i) {
304 appdefined_privilege_x* appdefined_privilege =
305 reinterpret_cast<appdefined_privilege_x*>(
306 calloc(1, sizeof(appdefined_privilege_x)));
307 ReadString(parcel, &appdefined_privilege->type);
308 ReadString(parcel, &appdefined_privilege->value);
309 ReadString(parcel, &appdefined_privilege->license);
311 *list = g_list_append(*list, appdefined_privilege);
315 void PkgInfoParcelable::ReadProvidesAppdefinedPrivileges(tizen_base::Parcel* parcel,
318 ReadInt(parcel, &size);
320 for (int i = 0; i < size; ++i) {
321 appdefined_privilege_x* appdefined_privilege =
322 reinterpret_cast<appdefined_privilege_x*>(
323 calloc(1, sizeof(appdefined_privilege_x)));
324 ReadString(parcel, &appdefined_privilege->type);
325 ReadString(parcel, &appdefined_privilege->value);
326 ReadString(parcel, &appdefined_privilege->license);
328 *list = g_list_append(*list, appdefined_privilege);
332 void PkgInfoParcelable::ReadApplication(tizen_base::Parcel* parcel, GList** list) {
333 // const unsigned char *buf = nullptr;
334 // unsigned int size = 0;
335 // ReadParcelRaw(&buf, &size);
336 // auto appinfo_parcel = AppInfoParcelable::Create(buf, size);
337 // auto appinfo_list = appinfo_parcel->GetAppInfo();
339 // for (const auto& application : appinfo_list)
340 // *list = g_list_append(*list, application);
343 void PkgInfoParcelable::ReadCompatibility(tizen_base::Parcel* parcel, GList** list) {
347 void PkgInfoParcelable::ReadDeviceprofile(tizen_base::Parcel* parcel, GList** list) {
349 ReadInt(parcel, &size);
351 for (int i = 0; i < size; ++i) {
352 char *device_profile = nullptr;
353 ReadString(parcel, &device_profile);
354 *list = g_list_append(*list, device_profile);
358 void PkgInfoParcelable::ReadDependencies(tizen_base::Parcel* parcel, GList** list) {
360 ReadInt(parcel, &size);
362 for (int i = 0; i < size; ++i) {
363 dependency_x* dependendy =
364 reinterpret_cast<dependency_x*>(calloc(1, sizeof(dependency_x)));
365 ReadString(parcel, &dependendy->depends_on);
366 ReadString(parcel, &dependendy->type);
367 ReadString(parcel, &dependendy->required_version);
369 *list = g_list_append(*list, dependendy);
373 void PkgInfoParcelable::ReadPlugin(tizen_base::Parcel* parcel, GList** list) {
375 ReadInt(parcel, &size);
377 for (int i = 0; i < size; ++i) {
378 plugin_x* plugin = reinterpret_cast<plugin_x*>(calloc(1, sizeof(plugin_x)));
379 ReadString(parcel, &plugin->pkgid);
380 ReadString(parcel, &plugin->appid);
381 ReadString(parcel, &plugin->plugin_type);
382 ReadString(parcel, &plugin->plugin_name);
384 *list = g_list_append(*list, plugin);
388 package_x *PkgInfoParcelable::ReadPackage(tizen_base::Parcel* parcel) {
390 reinterpret_cast<package_x*>(calloc(1, sizeof(package_x)));
392 ReadString(parcel, &package->for_all_users);
393 ReadString(parcel, &package->package);
394 ReadString(parcel, &package->version);
395 ReadString(parcel, &package->installlocation);
396 ReadString(parcel, &package->ns);
397 ReadString(parcel, &package->removable);
398 ReadString(parcel, &package->preload);
399 ReadString(parcel, &package->readonly);
400 ReadString(parcel, &package->update);
401 ReadString(parcel, &package->appsetting);
402 ReadString(parcel, &package->system);
403 ReadString(parcel, &package->type);
404 ReadString(parcel, &package->package_size);
405 ReadString(parcel, &package->installed_time);
406 ReadString(parcel, &package->installed_storage);
407 ReadString(parcel, &package->storeclient_id);
408 ReadString(parcel, &package->mainapp_id);
409 ReadString(parcel, &package->package_url);
410 ReadString(parcel, &package->root_path);
411 ReadString(parcel, &package->csc_path);
412 ReadString(parcel, &package->nodisplay_setting);
413 ReadString(parcel, &package->support_mode);
414 ReadString(parcel, &package->support_disable);
415 ReadString(parcel, &package->api_version);
416 ReadString(parcel, &package->tep_name);
417 ReadString(parcel, &package->zip_mount_file);
418 ReadString(parcel, &package->backend_installer);
419 ReadString(parcel, &package->external_path);
420 ReadString(parcel, &package->use_system_certs);
421 ReadString(parcel, &package->locale);
422 ReadIcon(parcel, &package->icon);
423 ReadLabel(parcel, &package->label);
424 ReadAuthor(parcel, &package->author);
425 ReadDescription(parcel, &package->description);
426 //ReadLicense(parcel, &package->license);
427 ReadPrivileges(parcel, &package->privileges);
428 ReadAppdefinedPrivileges(parcel, &package->appdefined_privileges);
429 ReadProvidesAppdefinedPrivileges(parcel, &package->provides_appdefined_privileges);
430 ReadApplication(parcel, &package->application);
431 //ReadCompatibility(parcel, &package->compatibility);
432 ReadDeviceprofile(parcel, &package->deviceprofile);
433 ReadDependencies(parcel, &package->dependencies);
434 ReadPlugin(parcel, &package->plugin);
439 PkgInfoParcelable::PkgInfoParcelable()
440 : AbstractParcelable(0, ParcelableType::PkgInfo), write_type_(WriteType::None) {}
442 PkgInfoParcelable::PkgInfoParcelable(uid_t uid, std::vector<package_x *>&& pkg_list, WriteType write_type)
443 : AbstractParcelable(uid, ParcelableType::PkgInfo), pkg_list_(std::move(pkg_list)), write_type_(write_type) {}
445 const std::vector<package_x *>& PkgInfoParcelable::GetPkgInfo() {
449 WriteType PkgInfoParcelable::GetWriteType() {
453 void PkgInfoParcelable::WriteToParcel(tizen_base::Parcel* parcel) const {
454 AbstractParcelable::WriteToParcel(parcel);
455 WriteInt(parcel, write_type_);
457 WriteInt(parcel, pkg_list_.size());
459 for (auto pkg : pkg_list_) {
460 WritePackage(parcel, pkg);
464 void PkgInfoParcelable::ReadFromParcel(tizen_base::Parcel* parcel) {
468 AbstractParcelable::ReadFromParcel(parcel);
470 ReadInt(parcel, &write_type);
471 write_type_ = static_cast<WriteType>(write_type);
473 ReadInt(parcel, &len);
475 for (int i = 0; i < len ; ++i) {
476 pkg_list_.emplace_back(ReadPackage(parcel));
480 std::unique_ptr<AbstractParcelable> PkgInfoParcelable::Factory::CreateParcel() {
484 } // namespace parcel
485 } // namespace pkgmgr_common