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   WriteInt(parcel, g_list_length(icon));
  31
  32   for (GList* tmp = icon; tmp; tmp = tmp->next) {
  33     icon_x* ptr = reinterpret_cast<icon_x*>(tmp->data);
  34     WriteString(parcel, ptr->text);
  35     WriteString(parcel, ptr->lang);
  36     WriteString(parcel, ptr->section);
  37     WriteString(parcel, ptr->size);
  38     WriteString(parcel, ptr->resolution);
  39     WriteString(parcel, ptr->dpi);
  40   }
  41 }
  42
  43 void PkgInfoParcelable::WriteLabel(tizen_base::Parcel* parcel,
  44     GList* label) const {
  45   WriteInt(parcel, g_list_length(label));
  46
  47   for (GList* tmp = label; tmp; tmp = tmp->next) {
  48     label_x* ptr = reinterpret_cast<label_x*>(tmp->data);
  49     WriteString(parcel, ptr->lang);
  50     WriteString(parcel, ptr->name);
  51     WriteString(parcel, ptr->text);
  52   }
  53 }
  54
  55 void PkgInfoParcelable::WriteAuthor(tizen_base::Parcel* parcel,
  56     GList* author) const {
  57   WriteInt(parcel, g_list_length(author));
  58
  59   for (GList* tmp = author; tmp; tmp = tmp->next) {
  60     author_x* ptr = reinterpret_cast<author_x*>(tmp->data);
  61     WriteString(parcel, ptr->email);
  62     WriteString(parcel, ptr->href);
  63     WriteString(parcel, ptr->text);
  64     WriteString(parcel, ptr->lang);
  65   }
  66 }
  67
  68 void PkgInfoParcelable::WriteDescription(tizen_base::Parcel* parcel,
  69     GList* description) const {
  70   WriteInt(parcel, g_list_length(description));
  71
  72   for (GList* tmp = description; tmp; tmp = tmp->next) {
  73     description_x* ptr = reinterpret_cast<description_x*>(tmp->data);
  74     WriteString(parcel, ptr->name);
  75     WriteString(parcel, ptr->text);
  76     WriteString(parcel, ptr->lang);
  77   }
  78 }
  79
  80 void PkgInfoParcelable::WriteLicense(tizen_base::Parcel* parcel,
  81     GList* license) const {
  82   return;
  83 }
  84
  85 void PkgInfoParcelable::WritePrivileges(tizen_base::Parcel* parcel,
  86     GList* privileges) const {
  87   WriteInt(parcel, g_list_length(privileges));
  88
  89   for (GList* tmp = privileges; tmp; tmp = tmp->next) {
  90     privilege_x* ptr = reinterpret_cast<privilege_x*>(tmp->data);
  91     WriteString(parcel, ptr->type);
  92     WriteString(parcel, ptr->value);
  93   }
  94 }
  95
  96 void PkgInfoParcelable::WriteAppdefinedPrivileges(tizen_base::Parcel* parcel,
  97     GList* appdefined_privileges) const {
  98   WriteInt(parcel, g_list_length(appdefined_privileges));
  99
 100   for (GList* tmp = appdefined_privileges; tmp; tmp = tmp->next) {
 101     appdefined_privilege_x* ptr =
 102         reinterpret_cast<appdefined_privilege_x*>(tmp->data);
 103     WriteString(parcel, ptr->type);
 104     WriteString(parcel, ptr->value);
 105     WriteString(parcel, ptr->license);
 106   }
 107 }
 108
 109 void PkgInfoParcelable::WriteProvidesAppdefinedPrivileges(
 110     tizen_base::Parcel* parcel, GList* provides_appdefined_privileges) const {
 111   WriteInt(parcel, g_list_length(provides_appdefined_privileges));
 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,
 123     GList* application) const {
 124   std::vector<std::shared_ptr<application_x>> app_vt;
 125
 126   for (GList* tmp = application; tmp; tmp = tmp->next) {
 127     application_x* ptr = reinterpret_cast<application_x*>(tmp->data);
 128     app_vt.emplace_back(ptr, [] (application_x*) -> void {});
 129   }
 130
 131   AppInfoParcelable apps(0, std::move(app_vt), false);
 132
 133   parcel->WriteParcelable(apps);
 134 }
 135
 136 void PkgInfoParcelable::WriteCompatibility(tizen_base::Parcel* parcel,
 137     GList* compatibility) const {
 138   return;
 139 }
 140
 141 void PkgInfoParcelable::WriteDeviceprofile(tizen_base::Parcel* parcel,
 142     GList* deviceprofile) const {
 143   WriteInt(parcel, g_list_length(deviceprofile));
 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,
 150     GList* dependencies) const {
 151   WriteInt(parcel, g_list_length(dependencies));
 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,
 162     GList* plugin) const {
 163   WriteInt(parcel, g_list_length(plugin));
 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::WriteResAllowedPackages(tizen_base::Parcel* parcel,
 175     GList* res_allowed_packages) const {
 176   WriteInt(parcel, g_list_length(res_allowed_packages));
 177
 178   for (GList* tmp = res_allowed_packages; tmp; tmp = tmp->next) {
 179     res_allowed_package_x* ptr =
 180         reinterpret_cast<res_allowed_package_x*>(tmp->data);
 181     WriteString(parcel, ptr->allowed_package);
 182
 183     WriteInt(parcel, g_list_length(ptr->required_privileges));
 184     for (GList* priv = ptr->required_privileges; priv; priv = priv->next)
 185       WriteString(parcel, reinterpret_cast<char*>(priv->data));
 186   }
 187 }
 188
 189 void PkgInfoParcelable::WriteMetadata(tizen_base::Parcel* parcel,
 190     GList* metadata) const {
 191   WriteInt(parcel, g_list_length(metadata));
 192
 193   for (GList* tmp = metadata; tmp; tmp = tmp->next) {
 194     metadata_x* ptr = reinterpret_cast<metadata_x*>(tmp->data);
 195     WriteString(parcel, ptr->key);
 196     WriteString(parcel, ptr->value);
 197   }
 198 }
 199
 200 void PkgInfoParcelable::WritePackage(tizen_base::Parcel* parcel,
 201     package_x* package) const {
 202   WriteString(parcel, package->for_all_users);
 203   WriteString(parcel, package->package);
 204   WriteString(parcel, package->version);
 205   WriteString(parcel, package->installlocation);
 206   WriteString(parcel, package->ns);
 207   WriteString(parcel, package->removable);
 208   WriteString(parcel, package->preload);
 209   WriteString(parcel, package->readonly);
 210   WriteString(parcel, package->update);
 211   WriteString(parcel, package->appsetting);
 212   WriteString(parcel, package->system);
 213   WriteString(parcel, package->type);
 214   WriteString(parcel, package->package_size);
 215   WriteString(parcel, package->installed_time);
 216   WriteString(parcel, package->installed_storage);
 217   WriteString(parcel, package->storeclient_id);
 218   WriteString(parcel, package->mainapp_id);
 219   WriteString(parcel, package->package_url);
 220   WriteString(parcel, package->root_path);
 221   WriteString(parcel, package->csc_path);
 222   WriteString(parcel, package->nodisplay_setting);
 223   WriteString(parcel, package->support_mode);
 224   WriteString(parcel, package->support_disable);
 225   WriteString(parcel, package->api_version);
 226   WriteString(parcel, package->tep_name);
 227   WriteString(parcel, package->zip_mount_file);
 228   WriteString(parcel, package->backend_installer);
 229   WriteString(parcel, package->external_path);
 230   WriteString(parcel, package->use_system_certs);
 231   WriteString(parcel, package->locale);
 232   WriteString(parcel, package->res_type);
 233   WriteString(parcel, package->res_version);
 234   WriteString(parcel, package->lib);
 235   WriteString(parcel, package->is_disabled);
 236   WriteString(parcel, package->light_user_switch_mode);
 237   WriteIcon(parcel, package->icon);
 238   WriteLabel(parcel, package->label);
 239   WriteAuthor(parcel, package->author);
 240   WriteDescription(parcel, package->description);
 241   WritePrivileges(parcel, package->privileges);
 242   WriteAppdefinedPrivileges(parcel, package->appdefined_privileges);
 243   WriteProvidesAppdefinedPrivileges(parcel,
 244       package->provides_appdefined_privileges);
 245   WriteApplication(parcel, package->application);
 246   WriteDeviceprofile(parcel, package->deviceprofile);
 247   WriteDependencies(parcel, package->dependencies);
 248   WritePlugin(parcel, package->plugin);
 249   WriteResAllowedPackages(parcel, package->res_allowed_packages);
 250   WriteMetadata(parcel, package->metadata);
 251 }
 252
 253 void PkgInfoParcelable::ReadIcon(tizen_base::Parcel* parcel, GList** list) {
 254   int size = 0;
 255   ReadInt(parcel, &size);
 256
 257   for (int i = 0; i < size; ++i) {
 258     icon_x* icon = reinterpret_cast<icon_x*>(calloc(1, sizeof(icon_x)));
 259     ReadString(parcel, &icon->text);
 260     ReadString(parcel, &icon->lang);
 261     ReadString(parcel, &icon->section);
 262     ReadString(parcel, &icon->size);
 263     ReadString(parcel, &icon->resolution);
 264     ReadString(parcel, &icon->dpi);
 265
 266     *list = g_list_append(*list, icon);
 267   }
 268 }
 269
 270 void PkgInfoParcelable::ReadLabel(tizen_base::Parcel* parcel, GList** list) {
 271   int size = 0;
 272   ReadInt(parcel, &size);
 273
 274   for (int i = 0; i < size; ++i) {
 275     label_x* label = reinterpret_cast<label_x*>(calloc(1, sizeof(label_x)));
 276     ReadString(parcel, &label->lang);
 277     ReadString(parcel, &label->name);
 278     ReadString(parcel, &label->text);
 279
 280     *list = g_list_append(*list, label);
 281   }
 282 }
 283
 284 void PkgInfoParcelable::ReadAuthor(tizen_base::Parcel* parcel, GList** list) {
 285   int size = 0;
 286   ReadInt(parcel, &size);
 287
 288   for (int i = 0; i < size; ++i) {
 289     author_x* author = reinterpret_cast<author_x*>(
 290         calloc(1, sizeof(author_x)));
 291     ReadString(parcel, &author->email);
 292     ReadString(parcel, &author->href);
 293     ReadString(parcel, &author->text);
 294     ReadString(parcel, &author->lang);
 295
 296     *list = g_list_append(*list, author);
 297   }
 298 }
 299
 300 void PkgInfoParcelable::ReadDescription(
 301     tizen_base::Parcel* parcel, GList** list) {
 302   int size = 0;
 303   ReadInt(parcel, &size);
 304
 305   for (int i = 0; i < size; ++i) {
 306     description_x* description =
 307         reinterpret_cast<description_x*>(calloc(1, sizeof(description_x)));
 308     ReadString(parcel, &description->name);
 309     ReadString(parcel, &description->text);
 310     ReadString(parcel, &description->lang);
 311
 312     *list = g_list_append(*list, description);
 313   }
 314 }
 315
 316 void PkgInfoParcelable::ReadLicense(tizen_base::Parcel* parcel, GList** list) {
 317   return;
 318 }
 319
 320 void PkgInfoParcelable::ReadPrivileges(
 321     tizen_base::Parcel* parcel, GList** list) {
 322   int size = 0;
 323   ReadInt(parcel, &size);
 324
 325   for (int i = 0; i < size; ++i) {
 326     privilege_x* privilege =
 327         reinterpret_cast<privilege_x*>(calloc(1, sizeof(privilege_x)));
 328     ReadString(parcel, &privilege->type);
 329     ReadString(parcel, &privilege->value);
 330
 331     *list = g_list_append(*list, privilege);
 332   }
 333 }
 334
 335 void PkgInfoParcelable::ReadAppdefinedPrivileges(
 336     tizen_base::Parcel* parcel, GList** list) {
 337   int size = 0;
 338   ReadInt(parcel, &size);
 339
 340   for (int i = 0; i < size; ++i) {
 341     appdefined_privilege_x* appdefined_privilege =
 342         reinterpret_cast<appdefined_privilege_x*>(
 343             calloc(1, sizeof(appdefined_privilege_x)));
 344     ReadString(parcel, &appdefined_privilege->type);
 345     ReadString(parcel, &appdefined_privilege->value);
 346     ReadString(parcel, &appdefined_privilege->license);
 347
 348     *list = g_list_append(*list, appdefined_privilege);
 349   }
 350 }
 351
 352 void PkgInfoParcelable::ReadProvidesAppdefinedPrivileges(
 353     tizen_base::Parcel* parcel, GList** list) {
 354   int size = 0;
 355   ReadInt(parcel, &size);
 356
 357   for (int i = 0; i < size; ++i) {
 358     appdefined_privilege_x* appdefined_privilege =
 359         reinterpret_cast<appdefined_privilege_x*>(
 360             calloc(1, sizeof(appdefined_privilege_x)));
 361     ReadString(parcel, &appdefined_privilege->type);
 362     ReadString(parcel, &appdefined_privilege->value);
 363     ReadString(parcel, &appdefined_privilege->license);
 364
 365     *list = g_list_append(*list, appdefined_privilege);
 366   }
 367 }
 368
 369 void PkgInfoParcelable::ReadApplication(
 370     tizen_base::Parcel* parcel, GList** list) {
 371   AppInfoParcelable apps;
 372   parcel->ReadParcelable(&apps);
 373
 374   std::vector<std::shared_ptr<application_x>> vt = apps.ExtractAppInfo();
 375
 376   for (auto& application : vt)
 377     *list = g_list_append(*list, application.get());
 378 }
 379
 380 void PkgInfoParcelable::ReadCompatibility(
 381     tizen_base::Parcel* parcel, GList** list) {
 382   return;
 383 }
 384
 385 void PkgInfoParcelable::ReadDeviceprofile(
 386     tizen_base::Parcel* parcel, GList** list) {
 387   int size = 0;
 388   ReadInt(parcel, &size);
 389
 390   for (int i = 0; i < size; ++i) {
 391     char* device_profile = nullptr;
 392     ReadString(parcel, &device_profile);
 393     *list = g_list_append(*list, device_profile);
 394   }
 395 }
 396
 397 void PkgInfoParcelable::ReadDependencies(
 398     tizen_base::Parcel* parcel, GList** list) {
 399   int size = 0;
 400   ReadInt(parcel, &size);
 401
 402   for (int i = 0; i < size; ++i) {
 403     dependency_x* dependendy =
 404         reinterpret_cast<dependency_x*>(calloc(1, sizeof(dependency_x)));
 405     ReadString(parcel, &dependendy->depends_on);
 406     ReadString(parcel, &dependendy->type);
 407     ReadString(parcel, &dependendy->required_version);
 408
 409     *list = g_list_append(*list, dependendy);
 410   }
 411 }
 412
 413 void PkgInfoParcelable::ReadPlugin(tizen_base::Parcel* parcel, GList** list) {
 414   int size = 0;
 415   ReadInt(parcel, &size);
 416
 417   for (int i = 0; i < size; ++i) {
 418     plugin_x* plugin = reinterpret_cast<plugin_x*>(
 419         calloc(1, sizeof(plugin_x)));
 420     ReadString(parcel, &plugin->pkgid);
 421     ReadString(parcel, &plugin->appid);
 422     ReadString(parcel, &plugin->plugin_type);
 423     ReadString(parcel, &plugin->plugin_name);
 424
 425     *list = g_list_append(*list, plugin);
 426   }
 427 }
 428
 429 void PkgInfoParcelable::ReadResAllowedPackages(tizen_base::Parcel* parcel,
 430     GList** list) {
 431   int size = 0;
 432   ReadInt(parcel, &size);
 433
 434   for (int i = 0; i < size; ++i) {
 435     res_allowed_package_x* res_allowed_package =
 436         reinterpret_cast<res_allowed_package_x*>(
 437             calloc(1, sizeof(res_allowed_package_x)));
 438     ReadString(parcel, &res_allowed_package->allowed_package);
 439
 440     int priv_len;
 441     GList* priv_list = nullptr;
 442     ReadInt(parcel, &priv_len);
 443     for (int i = 0; i < priv_len; ++i) {
 444       char* priv = nullptr;
 445       ReadString(parcel, &priv);
 446       priv_list = g_list_prepend(priv_list, priv);
 447     }
 448     res_allowed_package->required_privileges = priv_list;
 449
 450     *list = g_list_prepend(*list, res_allowed_package);
 451   }
 452 }
 453
 454 void PkgInfoParcelable::ReadMetadata(tizen_base::Parcel* parcel, GList** list) {
 455   int size = 0;
 456   ReadInt(parcel, &size);
 457
 458   for (int i = 0; i < size; ++i) {
 459     metadata_x* metadata =
 460         reinterpret_cast<metadata_x*>(calloc(1, sizeof(metadata_x)));
 461     ReadString(parcel, &metadata->key);
 462     ReadString(parcel, &metadata->value);
 463
 464     *list = g_list_append(*list, metadata);
 465   }
 466 }
 467
 468 package_x* PkgInfoParcelable::ReadPackage(tizen_base::Parcel* parcel) {
 469   package_x* package =
 470       reinterpret_cast<package_x*>(calloc(1, sizeof(package_x)));
 471
 472   ReadString(parcel, &package->for_all_users);
 473   ReadString(parcel, &package->package);
 474   ReadString(parcel, &package->version);
 475   ReadString(parcel, &package->installlocation);
 476   ReadString(parcel, &package->ns);
 477   ReadString(parcel, &package->removable);
 478   ReadString(parcel, &package->preload);
 479   ReadString(parcel, &package->readonly);
 480   ReadString(parcel, &package->update);
 481   ReadString(parcel, &package->appsetting);
 482   ReadString(parcel, &package->system);
 483   ReadString(parcel, &package->type);
 484   ReadString(parcel, &package->package_size);
 485   ReadString(parcel, &package->installed_time);
 486   ReadString(parcel, &package->installed_storage);
 487   ReadString(parcel, &package->storeclient_id);
 488   ReadString(parcel, &package->mainapp_id);
 489   ReadString(parcel, &package->package_url);
 490   ReadString(parcel, &package->root_path);
 491   ReadString(parcel, &package->csc_path);
 492   ReadString(parcel, &package->nodisplay_setting);
 493   ReadString(parcel, &package->support_mode);
 494   ReadString(parcel, &package->support_disable);
 495   ReadString(parcel, &package->api_version);
 496   ReadString(parcel, &package->tep_name);
 497   ReadString(parcel, &package->zip_mount_file);
 498   ReadString(parcel, &package->backend_installer);
 499   ReadString(parcel, &package->external_path);
 500   ReadString(parcel, &package->use_system_certs);
 501   ReadString(parcel, &package->locale);
 502   ReadString(parcel, &package->res_type);
 503   ReadString(parcel, &package->res_version);
 504   ReadString(parcel, &package->lib);
 505   ReadString(parcel, &package->is_disabled);
 506   ReadString(parcel, &package->light_user_switch_mode);
 507   ReadIcon(parcel, &package->icon);
 508   ReadLabel(parcel, &package->label);
 509   ReadAuthor(parcel, &package->author);
 510   ReadDescription(parcel, &package->description);
 511   ReadPrivileges(parcel, &package->privileges);
 512   ReadAppdefinedPrivileges(parcel, &package->appdefined_privileges);
 513   ReadProvidesAppdefinedPrivileges(parcel,
 514       &package->provides_appdefined_privileges);
 515   ReadApplication(parcel, &package->application);
 516   ReadDeviceprofile(parcel, &package->deviceprofile);
 517   ReadDependencies(parcel, &package->dependencies);
 518   ReadPlugin(parcel, &package->plugin);
 519   ReadResAllowedPackages(parcel, &package->res_allowed_packages);
 520   ReadMetadata(parcel, &package->metadata);
 521
 522   return package;
 523 }
 524
 525 PkgInfoParcelable::PkgInfoParcelable()
 526     : AbstractParcelable(0, ParcelableType::PkgInfo),
 527     write_type_(PkgWriteType::None), auto_release_(true) {}
 528
 529 PkgInfoParcelable::PkgInfoParcelable(
 530     uid_t uid, std::vector<std::shared_ptr<package_x>>&& pkg_list,
 531     PkgWriteType write_type, bool auto_release)
 532     : AbstractParcelable(uid, ParcelableType::PkgInfo),
 533     pkg_list_(std::move(pkg_list)), write_type_(write_type),
 534     auto_release_(auto_release) {}
 535
 536 PkgInfoParcelable::PkgInfoParcelable(
 537     int ret, std::vector<std::shared_ptr<package_x>>&& pkg_list,
 538     bool auto_release)
 539     : AbstractParcelable(0, ParcelableType::PkgInfo, ret),
 540     pkg_list_(std::move(pkg_list)), write_type_(PkgWriteType::None),
 541     auto_release_(auto_release) {}
 542
 543 PkgInfoParcelable::~PkgInfoParcelable() {
 544 }
 545
 546 const std::vector<std::shared_ptr<package_x>>& PkgInfoParcelable::GetPkgInfo() {
 547   return pkg_list_;
 548 }
 549
 550 std::vector<std::shared_ptr<package_x>> PkgInfoParcelable::ExtractPkgInfo() {
 551   return std::move(pkg_list_);
 552 }
 553
 554 PkgWriteType PkgInfoParcelable::GetWriteType() {
 555   return write_type_;
 556 }
 557
 558 void PkgInfoParcelable::WriteToParcel(tizen_base::Parcel* parcel) const {
 559   AbstractParcelable::WriteToParcel(parcel);
 560   WriteInt(parcel, static_cast<int>(write_type_));
 561
 562   WriteInt(parcel, pkg_list_.size());
 563
 564   for (auto& pkg : pkg_list_)
 565     WritePackage(parcel, pkg.get());
 566 }
 567
 568 void PkgInfoParcelable::ReadFromParcel(tizen_base::Parcel* parcel) {
 569   int len = 0;
 570   int write_type = 0;
 571
 572   AbstractParcelable::ReadFromParcel(parcel);
 573
 574   ReadInt(parcel, &write_type);
 575   write_type_ = static_cast<PkgWriteType>(write_type);
 576
 577   ReadInt(parcel, &len);
 578
 579   for (int i = 0; i < len ; ++i)
 580     pkg_list_.emplace_back(ReadPackage(parcel), [] (package_x*) -> void {});
 581 }
 582
 583 }  // namespace parcel
 584 }  // namespace pkgmgr_common