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 //  auto app_list = std::make_unique<AppInfoParcelable>(std::move(app_vt));
 131 //
 132 //  WriteParcel(std::move(app_list));
 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   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);
 217 }
 218
 219 void PkgInfoParcelable::ReadIcon(tizen_base::Parcel* parcel, GList** list) {
 220   int size = 0;
 221   ReadInt(parcel, &size);
 222
 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);
 231
 232     *list = g_list_append(*list, icon);
 233   }
 234 }
 235
 236 void PkgInfoParcelable::ReadLabel(tizen_base::Parcel* parcel, GList** list) {
 237   int size = 0;
 238   ReadInt(parcel, &size);
 239
 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);
 245
 246     *list = g_list_append(*list, label);
 247   }
 248 }
 249
 250 void PkgInfoParcelable::ReadAuthor(tizen_base::Parcel* parcel, GList** list) {
 251   int size = 0;
 252   ReadInt(parcel, &size);
 253
 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);
 260
 261     *list = g_list_append(*list, author);
 262   }
 263 }
 264
 265 void PkgInfoParcelable::ReadDescription(tizen_base::Parcel* parcel, GList** list) {
 266   int size = 0;
 267   ReadInt(parcel, &size);
 268
 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);
 275
 276     *list = g_list_append(*list, description);
 277   }
 278 }
 279
 280 void PkgInfoParcelable::ReadLicense(tizen_base::Parcel* parcel, GList** list) {
 281   return;
 282 }
 283
 284 void PkgInfoParcelable::ReadPrivileges(tizen_base::Parcel* parcel, GList** list) {
 285   int size = 0;
 286   ReadInt(parcel, &size);
 287
 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);
 293
 294     *list = g_list_append(*list, privilege);
 295   }
 296 }
 297
 298 void PkgInfoParcelable::ReadAppdefinedPrivileges(tizen_base::Parcel* parcel, GList** list) {
 299   int size = 0;
 300   ReadInt(parcel, &size);
 301
 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);
 309
 310     *list = g_list_append(*list, appdefined_privilege);
 311   }
 312 }
 313
 314 void PkgInfoParcelable::ReadProvidesAppdefinedPrivileges(tizen_base::Parcel* parcel,
 315     GList** list) {
 316   int size = 0;
 317   ReadInt(parcel, &size);
 318
 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);
 326
 327     *list = g_list_append(*list, appdefined_privilege);
 328   }
 329 }
 330
 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();
 337 //
 338 //  for (const auto& application : appinfo_list)
 339 //    *list = g_list_append(*list, application);
 340 }
 341
 342 void PkgInfoParcelable::ReadCompatibility(tizen_base::Parcel* parcel, GList** list) {
 343   return;
 344 }
 345
 346 void PkgInfoParcelable::ReadDeviceprofile(tizen_base::Parcel* parcel, GList** list) {
 347   int size = 0;
 348   ReadInt(parcel, &size);
 349
 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);
 354   }
 355 }
 356
 357 void PkgInfoParcelable::ReadDependencies(tizen_base::Parcel* parcel, GList** list) {
 358   int size = 0;
 359   ReadInt(parcel, &size);
 360
 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);
 367
 368     *list = g_list_append(*list, dependendy);
 369   }
 370 }
 371
 372 void PkgInfoParcelable::ReadPlugin(tizen_base::Parcel* parcel, GList** list) {
 373   int size = 0;
 374   ReadInt(parcel, &size);
 375
 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);
 382
 383     *list = g_list_append(*list, plugin);
 384   }
 385 }
 386
 387 package_x *PkgInfoParcelable::ReadPackage(tizen_base::Parcel* parcel) {
 388   package_x* package =
 389       reinterpret_cast<package_x*>(calloc(1, sizeof(package_x)));
 390
 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);
 433
 434   return package;
 435 }
 436
 437 PkgInfoParcelable::PkgInfoParcelable(std::vector<package_x *>&& pkg_list)
 438     : pkg_list_(std::move(pkg_list)) {}
 439
 440 const std::vector<package_x *> PkgInfoParcelable::GetPkgInfo() {
 441   return pkg_list_;
 442 }
 443
 444 void PkgInfoParcelable::WriteToParcel(tizen_base::Parcel* parcel) const {
 445   WriteInt(parcel, pkg_list_.size());
 446
 447   for (auto pkg : pkg_list_) {
 448     WritePackage(parcel, pkg);
 449   }
 450 }
 451
 452 void PkgInfoParcelable::ReadFromParcel(tizen_base::Parcel* parcel) {
 453   int len = 0;
 454   ReadInt(parcel, &len);
 455
 456   for (int i = 0; i < len ; ++i) {
 457     pkg_list_.emplace_back(ReadPackage(parcel));
 458   }
 459 }
 460
 461 std::unique_ptr<AbstractParcelable> PkgInfoParcelable::Factory::CreateParcel() {
 462   return nullptr;
 463 }
 464
 465 }  // namespace parcel
 466 }  // namespace pkgmgr_common