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 #include "pkginfo_parcelable.hh"
  17
  18 #include <vector>
  19
  20 #include "pkgmgrinfo_private.h"
  21
  22 #include "appinfo_parcelable.hh"
  23
  24 namespace pkgmgr_common {
  25 namespace parcel {
  26
  27 void PkgInfoParcelable::WriteIcon(tizen_base::Parcel* parcel, GList* icon) const {
  28   int size = g_list_length(icon);
  29   WriteInt(parcel, size);
  30
  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);
  39   }
  40 }
  41
  42 void PkgInfoParcelable::WriteLabel(tizen_base::Parcel* parcel, GList* label) const {
  43   int size = g_list_length(label);
  44   WriteInt(parcel, size);
  45
  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);
  51   }
  52 }
  53
  54 void PkgInfoParcelable::WriteAuthor(tizen_base::Parcel* parcel, GList* author) const {
  55   int size = g_list_length(author);
  56   WriteInt(parcel, size);
  57
  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);
  64   }
  65 }
  66
  67 void PkgInfoParcelable::WriteDescription(tizen_base::Parcel* parcel, GList* description) const {
  68   int size = g_list_length(description);
  69   WriteInt(parcel, size);
  70
  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);
  76   }
  77 }
  78
  79 void PkgInfoParcelable::WriteLicense(tizen_base::Parcel* parcel, GList* license) const {
  80   return;
  81 }
  82
  83 void PkgInfoParcelable::WritePrivileges(tizen_base::Parcel* parcel, GList* privileges) const {
  84   int size = g_list_length(privileges);
  85   WriteInt(parcel, size);
  86
  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);
  91   }
  92 }
  93
  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);
  98
  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);
 105   }
 106 }
 107
 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);
 112
 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);
 119   }
 120 }
 121
 122 void PkgInfoParcelable::WriteApplication(tizen_base::Parcel* parcel, GList* application) const {
 123   std::vector<application_x *> app_vt;
 124
 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);
 128   }
 129
 130   AppInfoParcelable apps(0, std::move(app_vt));
 131
 132   parcel->WriteParcelable(apps);
 133 }
 134
 135 void PkgInfoParcelable::WriteCompatibility(tizen_base::Parcel* parcel,
 136     GList* compatibility) const {
 137   return;
 138 }
 139
 140 void PkgInfoParcelable::WriteDeviceprofile(tizen_base::Parcel* parcel,
 141     GList* deviceprofile) const {
 142   int size = g_list_length(deviceprofile);
 143   WriteInt(parcel, size);
 144
 145   for (GList* tmp = deviceprofile; tmp; tmp = tmp->next)
 146     WriteString(parcel, reinterpret_cast<char *>(tmp->data));
 147 }
 148
 149 void PkgInfoParcelable::WriteDependencies(tizen_base::Parcel* parcel, GList* dependencies) const {
 150   int size = g_list_length(dependencies);
 151   WriteInt(parcel, size);
 152
 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);
 158   }
 159 }
 160
 161 void PkgInfoParcelable::WritePlugin(tizen_base::Parcel* parcel, GList* plugin) const {
 162   int size = g_list_length(plugin);
 163   WriteInt(parcel, size);
 164
 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);
 171   }
 172 }
 173
 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);
 218 }
 219
 220 void PkgInfoParcelable::ReadIcon(tizen_base::Parcel* parcel, GList** list) {
 221   int size = 0;
 222   ReadInt(parcel, &size);
 223
 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);
 232
 233     *list = g_list_append(*list, icon);
 234   }
 235 }
 236
 237 void PkgInfoParcelable::ReadLabel(tizen_base::Parcel* parcel, GList** list) {
 238   int size = 0;
 239   ReadInt(parcel, &size);
 240
 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);
 246
 247     *list = g_list_append(*list, label);
 248   }
 249 }
 250
 251 void PkgInfoParcelable::ReadAuthor(tizen_base::Parcel* parcel, GList** list) {
 252   int size = 0;
 253   ReadInt(parcel, &size);
 254
 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);
 261
 262     *list = g_list_append(*list, author);
 263   }
 264 }
 265
 266 void PkgInfoParcelable::ReadDescription(tizen_base::Parcel* parcel, GList** list) {
 267   int size = 0;
 268   ReadInt(parcel, &size);
 269
 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);
 276
 277     *list = g_list_append(*list, description);
 278   }
 279 }
 280
 281 void PkgInfoParcelable::ReadLicense(tizen_base::Parcel* parcel, GList** list) {
 282   return;
 283 }
 284
 285 void PkgInfoParcelable::ReadPrivileges(tizen_base::Parcel* parcel, GList** list) {
 286   int size = 0;
 287   ReadInt(parcel, &size);
 288
 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);
 294
 295     *list = g_list_append(*list, privilege);
 296   }
 297 }
 298
 299 void PkgInfoParcelable::ReadAppdefinedPrivileges(tizen_base::Parcel* parcel, GList** list) {
 300   int size = 0;
 301   ReadInt(parcel, &size);
 302
 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);
 310
 311     *list = g_list_append(*list, appdefined_privilege);
 312   }
 313 }
 314
 315 void PkgInfoParcelable::ReadProvidesAppdefinedPrivileges(tizen_base::Parcel* parcel,
 316     GList** list) {
 317   int size = 0;
 318   ReadInt(parcel, &size);
 319
 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);
 327
 328     *list = g_list_append(*list, appdefined_privilege);
 329   }
 330 }
 331
 332 void PkgInfoParcelable::ReadApplication(tizen_base::Parcel* parcel, GList** list) {
 333   AppInfoParcelable apps;
 334   parcel->ReadParcelable(&apps);
 335
 336   for (const auto& application : apps.GetAppInfo())
 337     *list = g_list_append(*list, application);
 338 }
 339
 340 void PkgInfoParcelable::ReadCompatibility(tizen_base::Parcel* parcel, GList** list) {
 341   return;
 342 }
 343
 344 void PkgInfoParcelable::ReadDeviceprofile(tizen_base::Parcel* parcel, GList** list) {
 345   int size = 0;
 346   ReadInt(parcel, &size);
 347
 348   for (int i = 0; i < size; ++i) {
 349     char *device_profile = nullptr;
 350     ReadString(parcel, &device_profile);
 351     *list = g_list_append(*list, device_profile);
 352   }
 353 }
 354
 355 void PkgInfoParcelable::ReadDependencies(tizen_base::Parcel* parcel, GList** list) {
 356   int size = 0;
 357   ReadInt(parcel, &size);
 358
 359   for (int i = 0; i < size; ++i) {
 360     dependency_x* dependendy =
 361         reinterpret_cast<dependency_x*>(calloc(1, sizeof(dependency_x)));
 362     ReadString(parcel, &dependendy->depends_on);
 363     ReadString(parcel, &dependendy->type);
 364     ReadString(parcel, &dependendy->required_version);
 365
 366     *list = g_list_append(*list, dependendy);
 367   }
 368 }
 369
 370 void PkgInfoParcelable::ReadPlugin(tizen_base::Parcel* parcel, GList** list) {
 371   int size = 0;
 372   ReadInt(parcel, &size);
 373
 374   for (int i = 0; i < size; ++i) {
 375     plugin_x* plugin = reinterpret_cast<plugin_x*>(calloc(1, sizeof(plugin_x)));
 376     ReadString(parcel, &plugin->pkgid);
 377     ReadString(parcel, &plugin->appid);
 378     ReadString(parcel, &plugin->plugin_type);
 379     ReadString(parcel, &plugin->plugin_name);
 380
 381     *list = g_list_append(*list, plugin);
 382   }
 383 }
 384
 385 package_x *PkgInfoParcelable::ReadPackage(tizen_base::Parcel* parcel) {
 386   package_x* package =
 387       reinterpret_cast<package_x*>(calloc(1, sizeof(package_x)));
 388
 389   ReadString(parcel, &package->for_all_users);
 390   ReadString(parcel, &package->package);
 391   ReadString(parcel, &package->version);
 392   ReadString(parcel, &package->installlocation);
 393   ReadString(parcel, &package->ns);
 394   ReadString(parcel, &package->removable);
 395   ReadString(parcel, &package->preload);
 396   ReadString(parcel, &package->readonly);
 397   ReadString(parcel, &package->update);
 398   ReadString(parcel, &package->appsetting);
 399   ReadString(parcel, &package->system);
 400   ReadString(parcel, &package->type);
 401   ReadString(parcel, &package->package_size);
 402   ReadString(parcel, &package->installed_time);
 403   ReadString(parcel, &package->installed_storage);
 404   ReadString(parcel, &package->storeclient_id);
 405   ReadString(parcel, &package->mainapp_id);
 406   ReadString(parcel, &package->package_url);
 407   ReadString(parcel, &package->root_path);
 408   ReadString(parcel, &package->csc_path);
 409   ReadString(parcel, &package->nodisplay_setting);
 410   ReadString(parcel, &package->support_mode);
 411   ReadString(parcel, &package->support_disable);
 412   ReadString(parcel, &package->api_version);
 413   ReadString(parcel, &package->tep_name);
 414   ReadString(parcel, &package->zip_mount_file);
 415   ReadString(parcel, &package->backend_installer);
 416   ReadString(parcel, &package->external_path);
 417   ReadString(parcel, &package->use_system_certs);
 418   ReadString(parcel, &package->locale);
 419   ReadIcon(parcel, &package->icon);
 420   ReadLabel(parcel, &package->label);
 421   ReadAuthor(parcel, &package->author);
 422   ReadDescription(parcel, &package->description);
 423   //ReadLicense(parcel, &package->license);
 424   ReadPrivileges(parcel, &package->privileges);
 425   ReadAppdefinedPrivileges(parcel, &package->appdefined_privileges);
 426   ReadProvidesAppdefinedPrivileges(parcel, &package->provides_appdefined_privileges);
 427   ReadApplication(parcel, &package->application);
 428   //ReadCompatibility(parcel, &package->compatibility);
 429   ReadDeviceprofile(parcel, &package->deviceprofile);
 430   ReadDependencies(parcel, &package->dependencies);
 431   ReadPlugin(parcel, &package->plugin);
 432
 433   return package;
 434 }
 435
 436 PkgInfoParcelable::PkgInfoParcelable()
 437     : AbstractParcelable(0, ParcelableType::PkgInfo), write_type_(WriteType::None) {}
 438
 439 PkgInfoParcelable::PkgInfoParcelable(uid_t uid, std::vector<package_x *>&& pkg_list, WriteType write_type)
 440     : AbstractParcelable(uid, ParcelableType::PkgInfo), pkg_list_(std::move(pkg_list)), write_type_(write_type) {}
 441
 442 PkgInfoParcelable::PkgInfoParcelable(int ret, std::vector<package_x *>&& pkg_list)
 443     : AbstractParcelable(0, ParcelableType::PkgInfo, ret), pkg_list_(std::move(pkg_list)), write_type_(WriteType::None) {}
 444
 445 const std::vector<package_x *>& PkgInfoParcelable::GetPkgInfo() {
 446   return pkg_list_;
 447 }
 448
 449 WriteType PkgInfoParcelable::GetWriteType() {
 450   return write_type_;
 451 }
 452
 453 void PkgInfoParcelable::WriteToParcel(tizen_base::Parcel* parcel) const {
 454   AbstractParcelable::WriteToParcel(parcel);
 455   WriteInt(parcel, write_type_);
 456
 457   WriteInt(parcel, pkg_list_.size());
 458
 459   for (auto pkg : pkg_list_) {
 460     WritePackage(parcel, pkg);
 461   }
 462 }
 463
 464 void PkgInfoParcelable::ReadFromParcel(tizen_base::Parcel* parcel) {
 465   int len = 0;
 466   int write_type = 0;
 467
 468   AbstractParcelable::ReadFromParcel(parcel);
 469
 470   ReadInt(parcel, &write_type);
 471   write_type_ = static_cast<WriteType>(write_type);
 472
 473   ReadInt(parcel, &len);
 474
 475   for (int i = 0; i < len ; ++i) {
 476     pkg_list_.emplace_back(ReadPackage(parcel));
 477   }
 478 }
 479
 480 }  // namespace parcel
 481 }  // namespace pkgmgr_common