src/common/parcel/pkginfo_parcelable.cc

   1 /*
   2  * Copyright (c) 2021 Samsung Electronics Co., Ltd All Rights Reserved
   3  *
   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
   7  *
   8  * http://www.apache.org/licenses/LICENSE-2.0
   9  *
  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.
  15  */
  16
  17 #include "pkginfo_parcelable.hh"
  18
  19 #include <vector>
  20
  21 #include "appinfo_parcelable.hh"
  22
  23 #include "pkgmgrinfo_private.h"
  24
  25 namespace pkgmgr_common {
  26 namespace parcel {
  27
  28 void PkgInfoParcelable::WriteIcon(tizen_base::Parcel* parcel,
  29     GList* icon) const {
  30   int size = g_list_length(icon);
  31   WriteInt(parcel, size);
  32
  33   for (GList* tmp = icon; tmp; tmp = tmp->next) {
  34     icon_x* ptr = reinterpret_cast<icon_x*>(tmp->data);
  35     WriteString(parcel, ptr->text);
  36     WriteString(parcel, ptr->lang);
  37     WriteString(parcel, ptr->section);
  38     WriteString(parcel, ptr->size);
  39     WriteString(parcel, ptr->resolution);
  40     WriteString(parcel, ptr->dpi);
  41   }
  42 }
  43
  44 void PkgInfoParcelable::WriteLabel(tizen_base::Parcel* parcel,
  45     GList* label) const {
  46   int size = g_list_length(label);
  47   WriteInt(parcel, size);
  48
  49   for (GList* tmp = label; tmp; tmp = tmp->next) {
  50     label_x* ptr = reinterpret_cast<label_x*>(tmp->data);
  51     WriteString(parcel, ptr->lang);
  52     WriteString(parcel, ptr->name);
  53     WriteString(parcel, ptr->text);
  54   }
  55 }
  56
  57 void PkgInfoParcelable::WriteAuthor(tizen_base::Parcel* parcel,
  58     GList* author) const {
  59   int size = g_list_length(author);
  60   WriteInt(parcel, size);
  61
  62   for (GList* tmp = author; tmp; tmp = tmp->next) {
  63     author_x* ptr = reinterpret_cast<author_x*>(tmp->data);
  64     WriteString(parcel, ptr->email);
  65     WriteString(parcel, ptr->href);
  66     WriteString(parcel, ptr->text);
  67     WriteString(parcel, ptr->lang);
  68   }
  69 }
  70
  71 void PkgInfoParcelable::WriteDescription(tizen_base::Parcel* parcel,
  72     GList* description) const {
  73   int size = g_list_length(description);
  74   WriteInt(parcel, size);
  75
  76   for (GList* tmp = description; tmp; tmp = tmp->next) {
  77     description_x* ptr = reinterpret_cast<description_x*>(tmp->data);
  78     WriteString(parcel, ptr->name);
  79     WriteString(parcel, ptr->text);
  80     WriteString(parcel, ptr->lang);
  81   }
  82 }
  83
  84 void PkgInfoParcelable::WriteLicense(tizen_base::Parcel* parcel,
  85     GList* license) const {
  86   return;
  87 }
  88
  89 void PkgInfoParcelable::WritePrivileges(tizen_base::Parcel* parcel,
  90     GList* privileges) const {
  91   int size = g_list_length(privileges);
  92   WriteInt(parcel, size);
  93
  94   for (GList* tmp = privileges; tmp; tmp = tmp->next) {
  95     privilege_x* ptr = reinterpret_cast<privilege_x*>(tmp->data);
  96     WriteString(parcel, ptr->type);
  97     WriteString(parcel, ptr->value);
  98   }
  99 }
 100
 101 void PkgInfoParcelable::WriteAppdefinedPrivileges(tizen_base::Parcel* parcel,
 102     GList* appdefined_privileges) const {
 103   int size = g_list_length(appdefined_privileges);
 104   WriteInt(parcel, size);
 105
 106   for (GList* tmp = appdefined_privileges; tmp; tmp = tmp->next) {
 107     appdefined_privilege_x* ptr =
 108         reinterpret_cast<appdefined_privilege_x*>(tmp->data);
 109     WriteString(parcel, ptr->type);
 110     WriteString(parcel, ptr->value);
 111     WriteString(parcel, ptr->license);
 112   }
 113 }
 114
 115 void PkgInfoParcelable::WriteProvidesAppdefinedPrivileges(
 116     tizen_base::Parcel* parcel, GList* provides_appdefined_privileges) const {
 117   int size = g_list_length(provides_appdefined_privileges);
 118   WriteInt(parcel, size);
 119
 120   for (GList* tmp = provides_appdefined_privileges; tmp; tmp = tmp->next) {
 121     appdefined_privilege_x* ptr =
 122         reinterpret_cast<appdefined_privilege_x*>(tmp->data);
 123     WriteString(parcel, ptr->type);
 124     WriteString(parcel, ptr->value);
 125     WriteString(parcel, ptr->license);
 126   }
 127 }
 128
 129 void PkgInfoParcelable::WriteApplication(tizen_base::Parcel* parcel,
 130     GList* application) const {
 131   std::vector<application_x *> app_vt;
 132
 133   for (GList* tmp = application; tmp; tmp = tmp->next) {
 134     application_x* ptr = reinterpret_cast<application_x*>(tmp->data);
 135     app_vt.push_back(ptr);
 136   }
 137
 138   AppInfoParcelable apps(0, std::move(app_vt), false);
 139
 140   parcel->WriteParcelable(apps);
 141 }
 142
 143 void PkgInfoParcelable::WriteCompatibility(tizen_base::Parcel* parcel,
 144     GList* compatibility) const {
 145   return;
 146 }
 147
 148 void PkgInfoParcelable::WriteDeviceprofile(tizen_base::Parcel* parcel,
 149     GList* deviceprofile) const {
 150   int size = g_list_length(deviceprofile);
 151   WriteInt(parcel, size);
 152
 153   for (GList* tmp = deviceprofile; tmp; tmp = tmp->next)
 154     WriteString(parcel, reinterpret_cast<char *>(tmp->data));
 155 }
 156
 157 void PkgInfoParcelable::WriteDependencies(tizen_base::Parcel* parcel,
 158     GList* dependencies) const {
 159   int size = g_list_length(dependencies);
 160   WriteInt(parcel, size);
 161
 162   for (GList* tmp = dependencies; tmp; tmp = tmp->next) {
 163     dependency_x* ptr = reinterpret_cast<dependency_x*>(tmp->data);
 164     WriteString(parcel, ptr->depends_on);
 165     WriteString(parcel, ptr->type);
 166     WriteString(parcel, ptr->required_version);
 167   }
 168 }
 169
 170 void PkgInfoParcelable::WritePlugin(tizen_base::Parcel* parcel,
 171     GList* plugin) const {
 172   int size = g_list_length(plugin);
 173   WriteInt(parcel, size);
 174
 175   for (GList* tmp = plugin; tmp; tmp = tmp->next) {
 176     plugin_x* ptr = reinterpret_cast<plugin_x*>(tmp->data);
 177     WriteString(parcel, ptr->pkgid);
 178     WriteString(parcel, ptr->appid);
 179     WriteString(parcel, ptr->plugin_type);
 180     WriteString(parcel, ptr->plugin_name);
 181   }
 182 }
 183
 184 void PkgInfoParcelable::WritePackage(tizen_base::Parcel* parcel,
 185     package_x *package) const {
 186   WriteString(parcel, package->for_all_users);
 187   WriteString(parcel, package->package);
 188   WriteString(parcel, package->version);
 189   WriteString(parcel, package->installlocation);
 190   WriteString(parcel, package->ns);
 191   WriteString(parcel, package->removable);
 192   WriteString(parcel, package->preload);
 193   WriteString(parcel, package->readonly);
 194   WriteString(parcel, package->update);
 195   WriteString(parcel, package->appsetting);
 196   WriteString(parcel, package->system);
 197   WriteString(parcel, package->type);
 198   WriteString(parcel, package->package_size);
 199   WriteString(parcel, package->installed_time);
 200   WriteString(parcel, package->installed_storage);
 201   WriteString(parcel, package->storeclient_id);
 202   WriteString(parcel, package->mainapp_id);
 203   WriteString(parcel, package->package_url);
 204   WriteString(parcel, package->root_path);
 205   WriteString(parcel, package->csc_path);
 206   WriteString(parcel, package->nodisplay_setting);
 207   WriteString(parcel, package->support_mode);
 208   WriteString(parcel, package->support_disable);
 209   WriteString(parcel, package->api_version);
 210   WriteString(parcel, package->tep_name);
 211   WriteString(parcel, package->zip_mount_file);
 212   WriteString(parcel, package->backend_installer);
 213   WriteString(parcel, package->external_path);
 214   WriteString(parcel, package->use_system_certs);
 215   WriteString(parcel, package->locale);
 216   WriteIcon(parcel, package->icon);
 217   WriteLabel(parcel, package->label);
 218   WriteAuthor(parcel, package->author);
 219   WriteDescription(parcel, package->description);
 220   WritePrivileges(parcel, package->privileges);
 221   WriteAppdefinedPrivileges(parcel, package->appdefined_privileges);
 222   WriteProvidesAppdefinedPrivileges(parcel,
 223       package->provides_appdefined_privileges);
 224   WriteApplication(parcel, package->application);
 225   WriteDeviceprofile(parcel, package->deviceprofile);
 226   WriteDependencies(parcel, package->dependencies);
 227   WritePlugin(parcel, package->plugin);
 228 }
 229
 230 void PkgInfoParcelable::ReadIcon(tizen_base::Parcel* parcel, GList** list) {
 231   int size = 0;
 232   ReadInt(parcel, &size);
 233
 234   for (int i = 0; i < size; ++i) {
 235     icon_x* icon = reinterpret_cast<icon_x*>(calloc(1, sizeof(icon_x)));
 236     ReadString(parcel, &icon->text);
 237     ReadString(parcel, &icon->lang);
 238     ReadString(parcel, &icon->section);
 239     ReadString(parcel, &icon->size);
 240     ReadString(parcel, &icon->resolution);
 241     ReadString(parcel, &icon->dpi);
 242
 243     *list = g_list_append(*list, icon);
 244   }
 245 }
 246
 247 void PkgInfoParcelable::ReadLabel(tizen_base::Parcel* parcel, GList** list) {
 248   int size = 0;
 249   ReadInt(parcel, &size);
 250
 251   for (int i = 0; i < size; ++i) {
 252     label_x* label = reinterpret_cast<label_x*>(calloc(1, sizeof(label_x)));
 253     ReadString(parcel, &label->lang);
 254     ReadString(parcel, &label->name);
 255     ReadString(parcel, &label->text);
 256
 257     *list = g_list_append(*list, label);
 258   }
 259 }
 260
 261 void PkgInfoParcelable::ReadAuthor(tizen_base::Parcel* parcel, GList** list) {
 262   int size = 0;
 263   ReadInt(parcel, &size);
 264
 265   for (int i = 0; i < size; ++i) {
 266     author_x* author = reinterpret_cast<author_x*>(
 267         calloc(1, sizeof(author_x)));
 268     ReadString(parcel, &author->email);
 269     ReadString(parcel, &author->href);
 270     ReadString(parcel, &author->text);
 271     ReadString(parcel, &author->lang);
 272
 273     *list = g_list_append(*list, author);
 274   }
 275 }
 276
 277 void PkgInfoParcelable::ReadDescription(
 278     tizen_base::Parcel* parcel, GList** list) {
 279   int size = 0;
 280   ReadInt(parcel, &size);
 281
 282   for (int i = 0; i < size; ++i) {
 283     description_x* description =
 284         reinterpret_cast<description_x*>(calloc(1, sizeof(description_x)));
 285     ReadString(parcel, &description->name);
 286     ReadString(parcel, &description->text);
 287     ReadString(parcel, &description->lang);
 288
 289     *list = g_list_append(*list, description);
 290   }
 291 }
 292
 293 void PkgInfoParcelable::ReadLicense(tizen_base::Parcel* parcel, GList** list) {
 294   return;
 295 }
 296
 297 void PkgInfoParcelable::ReadPrivileges(
 298     tizen_base::Parcel* parcel, GList** list) {
 299   int size = 0;
 300   ReadInt(parcel, &size);
 301
 302   for (int i = 0; i < size; ++i) {
 303     privilege_x* privilege =
 304         reinterpret_cast<privilege_x*>(calloc(1, sizeof(privilege_x)));
 305     ReadString(parcel, &privilege->type);
 306     ReadString(parcel, &privilege->value);
 307
 308     *list = g_list_append(*list, privilege);
 309   }
 310 }
 311
 312 void PkgInfoParcelable::ReadAppdefinedPrivileges(
 313     tizen_base::Parcel* parcel, GList** list) {
 314   int size = 0;
 315   ReadInt(parcel, &size);
 316
 317   for (int i = 0; i < size; ++i) {
 318     appdefined_privilege_x* appdefined_privilege =
 319         reinterpret_cast<appdefined_privilege_x*>(
 320             calloc(1, sizeof(appdefined_privilege_x)));
 321     ReadString(parcel, &appdefined_privilege->type);
 322     ReadString(parcel, &appdefined_privilege->value);
 323     ReadString(parcel, &appdefined_privilege->license);
 324
 325     *list = g_list_append(*list, appdefined_privilege);
 326   }
 327 }
 328
 329 void PkgInfoParcelable::ReadProvidesAppdefinedPrivileges(
 330     tizen_base::Parcel* parcel, GList** list) {
 331   int size = 0;
 332   ReadInt(parcel, &size);
 333
 334   for (int i = 0; i < size; ++i) {
 335     appdefined_privilege_x* appdefined_privilege =
 336         reinterpret_cast<appdefined_privilege_x*>(
 337             calloc(1, sizeof(appdefined_privilege_x)));
 338     ReadString(parcel, &appdefined_privilege->type);
 339     ReadString(parcel, &appdefined_privilege->value);
 340     ReadString(parcel, &appdefined_privilege->license);
 341
 342     *list = g_list_append(*list, appdefined_privilege);
 343   }
 344 }
 345
 346 void PkgInfoParcelable::ReadApplication(
 347     tizen_base::Parcel* parcel, GList** list) {
 348   AppInfoParcelable apps;
 349   parcel->ReadParcelable(&apps);
 350
 351   std::vector<application_x *> vt = apps.ExtractAppInfo();
 352
 353   for (application_x *application : vt)
 354     *list = g_list_append(*list, application);
 355 }
 356
 357 void PkgInfoParcelable::ReadCompatibility(
 358     tizen_base::Parcel* parcel, GList** list) {
 359   return;
 360 }
 361
 362 void PkgInfoParcelable::ReadDeviceprofile(
 363     tizen_base::Parcel* parcel, GList** list) {
 364   int size = 0;
 365   ReadInt(parcel, &size);
 366
 367   for (int i = 0; i < size; ++i) {
 368     char *device_profile = nullptr;
 369     ReadString(parcel, &device_profile);
 370     *list = g_list_append(*list, device_profile);
 371   }
 372 }
 373
 374 void PkgInfoParcelable::ReadDependencies(
 375     tizen_base::Parcel* parcel, GList** list) {
 376   int size = 0;
 377   ReadInt(parcel, &size);
 378
 379   for (int i = 0; i < size; ++i) {
 380     dependency_x* dependendy =
 381         reinterpret_cast<dependency_x*>(calloc(1, sizeof(dependency_x)));
 382     ReadString(parcel, &dependendy->depends_on);
 383     ReadString(parcel, &dependendy->type);
 384     ReadString(parcel, &dependendy->required_version);
 385
 386     *list = g_list_append(*list, dependendy);
 387   }
 388 }
 389
 390 void PkgInfoParcelable::ReadPlugin(tizen_base::Parcel* parcel, GList** list) {
 391   int size = 0;
 392   ReadInt(parcel, &size);
 393
 394   for (int i = 0; i < size; ++i) {
 395     plugin_x* plugin = reinterpret_cast<plugin_x*>(
 396         calloc(1, sizeof(plugin_x)));
 397     ReadString(parcel, &plugin->pkgid);
 398     ReadString(parcel, &plugin->appid);
 399     ReadString(parcel, &plugin->plugin_type);
 400     ReadString(parcel, &plugin->plugin_name);
 401
 402     *list = g_list_append(*list, plugin);
 403   }
 404 }
 405
 406 package_x *PkgInfoParcelable::ReadPackage(tizen_base::Parcel* parcel) {
 407   package_x* package =
 408       reinterpret_cast<package_x*>(calloc(1, sizeof(package_x)));
 409
 410   ReadString(parcel, &package->for_all_users);
 411   ReadString(parcel, &package->package);
 412   ReadString(parcel, &package->version);
 413   ReadString(parcel, &package->installlocation);
 414   ReadString(parcel, &package->ns);
 415   ReadString(parcel, &package->removable);
 416   ReadString(parcel, &package->preload);
 417   ReadString(parcel, &package->readonly);
 418   ReadString(parcel, &package->update);
 419   ReadString(parcel, &package->appsetting);
 420   ReadString(parcel, &package->system);
 421   ReadString(parcel, &package->type);
 422   ReadString(parcel, &package->package_size);
 423   ReadString(parcel, &package->installed_time);
 424   ReadString(parcel, &package->installed_storage);
 425   ReadString(parcel, &package->storeclient_id);
 426   ReadString(parcel, &package->mainapp_id);
 427   ReadString(parcel, &package->package_url);
 428   ReadString(parcel, &package->root_path);
 429   ReadString(parcel, &package->csc_path);
 430   ReadString(parcel, &package->nodisplay_setting);
 431   ReadString(parcel, &package->support_mode);
 432   ReadString(parcel, &package->support_disable);
 433   ReadString(parcel, &package->api_version);
 434   ReadString(parcel, &package->tep_name);
 435   ReadString(parcel, &package->zip_mount_file);
 436   ReadString(parcel, &package->backend_installer);
 437   ReadString(parcel, &package->external_path);
 438   ReadString(parcel, &package->use_system_certs);
 439   ReadString(parcel, &package->locale);
 440   ReadIcon(parcel, &package->icon);
 441   ReadLabel(parcel, &package->label);
 442   ReadAuthor(parcel, &package->author);
 443   ReadDescription(parcel, &package->description);
 444   ReadPrivileges(parcel, &package->privileges);
 445   ReadAppdefinedPrivileges(parcel, &package->appdefined_privileges);
 446   ReadProvidesAppdefinedPrivileges(parcel,
 447       &package->provides_appdefined_privileges);
 448   ReadApplication(parcel, &package->application);
 449   ReadDeviceprofile(parcel, &package->deviceprofile);
 450   ReadDependencies(parcel, &package->dependencies);
 451   ReadPlugin(parcel, &package->plugin);
 452
 453   return package;
 454 }
 455
 456 PkgInfoParcelable::PkgInfoParcelable()
 457     : AbstractParcelable(0, ParcelableType::PkgInfo),
 458     write_type_(WriteType::None), auto_release_(true) {}
 459
 460 PkgInfoParcelable::PkgInfoParcelable(
 461     uid_t uid, std::vector<package_x *>&& pkg_list,
 462     WriteType write_type, bool auto_release)
 463     : AbstractParcelable(uid, ParcelableType::PkgInfo),
 464     pkg_list_(std::move(pkg_list)), write_type_(write_type),
 465     auto_release_(auto_release) {}
 466
 467 PkgInfoParcelable::PkgInfoParcelable(
 468     int ret, std::vector<package_x *>&& pkg_list, bool auto_release)
 469     : AbstractParcelable(0, ParcelableType::PkgInfo, ret),
 470     pkg_list_(std::move(pkg_list)), write_type_(WriteType::None),
 471     auto_release_(auto_release) {}
 472
 473 PkgInfoParcelable::~PkgInfoParcelable() {
 474   if (!auto_release_)
 475     return;
 476
 477   for (auto pkg : pkg_list_) {
 478     pkgmgrinfo_basic_free_package(pkg);
 479   }
 480 }
 481
 482 const std::vector<package_x *>& PkgInfoParcelable::GetPkgInfo() {
 483   return pkg_list_;
 484 }
 485
 486 std::vector<package_x *> PkgInfoParcelable::ExtractPkgInfo() {
 487   return std::move(pkg_list_);
 488 }
 489
 490 WriteType PkgInfoParcelable::GetWriteType() {
 491   return write_type_;
 492 }
 493
 494 void PkgInfoParcelable::WriteToParcel(tizen_base::Parcel* parcel) const {
 495   AbstractParcelable::WriteToParcel(parcel);
 496   WriteInt(parcel, write_type_);
 497
 498   WriteInt(parcel, pkg_list_.size());
 499
 500   for (auto pkg : pkg_list_) {
 501     WritePackage(parcel, pkg);
 502   }
 503 }
 504
 505 void PkgInfoParcelable::ReadFromParcel(tizen_base::Parcel* parcel) {
 506   int len = 0;
 507   int write_type = 0;
 508
 509   AbstractParcelable::ReadFromParcel(parcel);
 510
 511   ReadInt(parcel, &write_type);
 512   write_type_ = static_cast<WriteType>(write_type);
 513
 514   ReadInt(parcel, &len);
 515
 516   for (int i = 0; i < len ; ++i) {
 517     pkg_list_.emplace_back(ReadPackage(parcel));
 518   }
 519 }
 520
 521 }  // namespace parcel
 522 }  // namespace pkgmgr_common