src/wgt/step/configuration/step_parse.cc

   1 /* 2014, Copyright © Intel Coporation, license APACHE-2.0, see LICENSE file */
   2 // Copyright (c) 2015 Samsung Electronics Co., Ltd All Rights Reserved
   3 // Use of this source code is governed by a apache 2.0 license that can be
   4 // found in the LICENSE file.
   5
   6 #include "wgt/step/configuration/step_parse.h"
   7
   8 #include <boost/filesystem/path.hpp>
   9
  10 #include <common/app_installer.h>
  11 #include <common/paths.h>
  12 #include <common/installer_context.h>
  13 #include <common/step/step.h>
  14 #include <common/utils/glist_range.h>
  15 #include <manifest_parser/utils/version_number.h>
  16 #include <wgt_manifest_handlers/account_handler.h>
  17 #include <wgt_manifest_handlers/app_control_handler.h>
  18 #include <wgt_manifest_handlers/application_icons_handler.h>
  19 #include <wgt_manifest_handlers/application_manifest_constants.h>
  20 #include <wgt_manifest_handlers/background_category_handler.h>
  21 #include <wgt_manifest_handlers/category_handler.h>
  22 #include <wgt_manifest_handlers/content_handler.h>
  23 #include <wgt_manifest_handlers/ime_handler.h>
  24 #include <wgt_manifest_handlers/metadata_handler.h>
  25 #include <wgt_manifest_handlers/service_handler.h>
  26 #include <wgt_manifest_handlers/setting_handler.h>
  27 #include <wgt_manifest_handlers/tizen_application_handler.h>
  28 #include <wgt_manifest_handlers/widget_handler.h>
  29 #include <wgt_manifest_handlers/w3c_pc_utils.h>
  30
  31 #include <pkgmgr/pkgmgr_parser.h>
  32
  33 #include <string.h>
  34
  35 #include <chrono>
  36 #include <cstdio>
  37 #include <cstdlib>
  38 #include <memory>
  39 #include <set>
  40 #include <string>
  41 #include <vector>
  42
  43 #include "wgt/wgt_backend_data.h"
  44
  45 namespace bf = boost::filesystem;
  46
  47 namespace {
  48
  49 const char kCategoryWearableClock[] =
  50     "http://tizen.org/category/wearable_clock";
  51 const char kCategoryWatchClock[] = "com.samsung.wmanager.WATCH_CLOCK";
  52
  53 const std::string kManifestVersion = "1.0.0";
  54 const char kTizenPackageXmlNamespace[] = "http://tizen.org/ns/packages";
  55 const char kImeCategoryName[] = "http://tizen.org/category/ime";
  56
  57 const char kResWgt[] = "res/wgt";
  58 const char kConfigFileName[] = "config.xml";
  59
  60 GList* GenerateMetadataListX(const wgt::parse::MetaDataInfo& meta_info) {
  61   GList* list = nullptr;
  62   for (auto& meta : meta_info.metadata()) {
  63     metadata_x* new_meta =
  64         static_cast<metadata_x*>(calloc(1, sizeof(metadata_x)));
  65     new_meta->key = strdup(meta.first.c_str());
  66     if (!meta.second.empty())
  67       new_meta->value = strdup(meta.second.c_str());
  68     list = g_list_append(list, new_meta);
  69   }
  70   return list;
  71 }
  72
  73 void AppendWidgetMetadata(GList** metadatas,
  74     const std::vector<std::pair<std::string, std::string>> metadata) {
  75   GList* list = *metadatas;
  76   for (auto& meta : metadata) {
  77     metadata_x* new_meta = static_cast<metadata_x*>(calloc(1, sizeof(metadata_x)));
  78     new_meta->key = strdup(meta.first.c_str());
  79     if (!meta.second.empty())
  80       new_meta->value = strdup(meta.second.c_str());
  81
  82     list = g_list_append(list, new_meta);
  83   }
  84
  85   *metadatas = list;
  86 }
  87
  88 void SetApplicationXDefaults(application_x* application) {
  89   application->effectimage_type = strdup("image");
  90   application->enabled = strdup("true");
  91   application->guestmode_visibility = strdup("true");
  92   application->hwacceleration = strdup("default");
  93   application->indicatordisplay = strdup("true");
  94   application->launchcondition = strdup("false");
  95   application->permission_type = strdup("normal");
  96   application->process_pool = strdup("false");
  97   application->recentimage = strdup("false");
  98   application->screenreader = strdup("use-system-setting");
  99   application->submode = strdup("false");
 100   application->support_disable = strdup("false");
 101   application->ui_gadget = strdup("false");
 102   application->multiple = strdup("false");
 103 }
 104
 105 template<typename T>
 106 void AppendLabel(T* root, const std::string& label,
 107                  const std::string& locale) {
 108   label_x* label_item = reinterpret_cast<label_x*>(calloc(1, sizeof(label_x)));
 109   label_item->name = strdup(label.c_str());
 110   label_item->text = strdup(label.c_str());
 111   label_item->lang = !locale.empty() ?
 112       strdup(locale.c_str()) : strdup(DEFAULT_LOCALE);
 113   root->label = g_list_append(root->label, label_item);
 114 }
 115 }  // namespace
 116
 117 namespace wgt {
 118 namespace configuration {
 119
 120 namespace app_keys = wgt::application_widget_keys;
 121 namespace sc = std::chrono;
 122
 123 StepParse::StepParse(common_installer::InstallerContext* context,
 124                      ConfigLocation config_location,
 125                      bool check_start_file)
 126     : Step(context),
 127       config_location_(config_location),
 128       check_start_file_(check_start_file) {
 129 }
 130
 131 std::set<std::string> StepParse::ExtractPrivileges(
 132     std::shared_ptr<const wgt::parse::PermissionsInfo> perm_info) const {
 133   return perm_info->GetAPIPermissions();
 134 }
 135
 136 std::string StepParse::GetPackageVersion(
 137      const std::string& manifest_version) {
 138   if (manifest_version.empty()) {
 139     return kManifestVersion;
 140   }
 141   std::string version = manifest_version.substr(0,
 142       manifest_version.find_first_not_of("1234567890."));
 143
 144   utils::VersionNumber version_number(version);
 145
 146   if (!version_number.IsValidTizenPackageVersion()) {
 147     LOG(WARNING) << "Version number: " << manifest_version
 148                  << " is not valid version number for tizen package. "
 149                  << "Default value will be used.";
 150     return kManifestVersion;
 151   }
 152
 153   return version_number.ToString();
 154 }
 155
 156 bool StepParse::FillInstallationInfo(manifest_x* manifest) {
 157   manifest->root_path = strdup(
 158       (context_->root_application_path.get() / manifest->package).c_str());
 159   manifest->installed_time =
 160       strdup(std::to_string(sc::system_clock::to_time_t(
 161           sc::system_clock::now())).c_str());
 162   return true;
 163 }
 164
 165 bool StepParse::FillIconPaths(manifest_x* manifest) {
 166   auto app_info =
 167       GetManifestDataForKey<const wgt::parse::TizenApplicationInfo>(
 168              app_keys::kTizenApplicationKey);
 169   if (!app_info) {
 170     LOG(ERROR) << "Application info manifest data has not been found.";
 171     return false;
 172   }
 173   auto icons_info =
 174     GetManifestDataForKey<const wgt::parse::ApplicationIconsInfo>(
 175            app_keys::kIconsKey);
 176   if (!icons_info) {
 177     icons_info.reset(new wgt::parse::ApplicationIconsInfo());
 178   }
 179   wgt::parse::LocalizedApplicationIconsInfo localized_list =
 180       wgt::parse::GetLocalizedIconList(*icons_info, widget_path_);
 181   // We need to generate icon for each locale and icons are already set into
 182   // lookup order. There isn't said that all icons should be received from
 183   // one <icon> tag position so we iterate utils we run out of icons creating
 184   // any icon element that are possible for given locale.
 185   std::set<std::string> found_locales;
 186   for (auto& application_icon : localized_list) {
 187     const std::string& locale = application_icon.locale();
 188     if (found_locales.find(locale) != found_locales.end())
 189       continue;
 190     found_locales.insert(locale);
 191
 192     icon_x* icon = reinterpret_cast<icon_x*>(calloc(1, sizeof(icon_x)));
 193     bf::path icon_path = context_->root_application_path.get()
 194         / app_info->package() / "res" / "wgt" / application_icon.path();
 195     icon->text = strdup(icon_path.c_str());
 196     if (!locale.empty())
 197       icon->lang = strdup(locale.c_str());
 198     else
 199       icon->lang = strdup(DEFAULT_LOCALE);
 200     manifest->icon = g_list_append(manifest->icon, icon);
 201   }
 202   return true;
 203 }
 204
 205 bool StepParse::FillWidgetInfo(manifest_x* manifest) {
 206   auto wgt_info =
 207       GetManifestDataForKey<const wgt::parse::WidgetInfo>(
 208              app_keys::kWidgetKey);
 209
 210   if (!wgt_info.get()) {
 211     LOG(ERROR) << "Widget info manifest data has not been found.";
 212     return false;
 213   }
 214
 215   const std::string& version = wgt_info->version();
 216
 217   manifest->ns = strdup(kTizenPackageXmlNamespace);
 218   manifest->version = strdup(GetPackageVersion(version).c_str());
 219
 220   for (auto& item : wgt_info->description_set()) {
 221     description_x* description = reinterpret_cast<description_x*>
 222         (calloc(1, sizeof(description_x)));
 223     description->text = strdup(item.second.c_str());
 224     description->lang = !item.first.empty() ?
 225         strdup(item.first.c_str()) : strdup(DEFAULT_LOCALE);
 226     manifest->description = g_list_append(manifest->description, description);
 227   }
 228
 229   for (auto& item : wgt_info->name_set()) {
 230     AppendLabel(manifest, item.second, item.first);
 231   }
 232
 233   manifest->type = strdup("wgt");
 234   manifest->appsetting = strdup("false");
 235   manifest->nodisplay_setting = strdup("false");
 236   if (context_->is_preload_request.get())
 237     manifest->preload = strdup("true");
 238   else
 239     manifest->preload = strdup("false");
 240   manifest->installed_storage = strdup("installed_internal");
 241
 242   // For wgt package use the long name
 243   application_x* app =
 244       reinterpret_cast<application_x*>(manifest->application->data);
 245   for (auto& item : wgt_info->name_set()) {
 246     AppendLabel(app, item.second, item.first);
 247   }
 248
 249   author_x* author = reinterpret_cast<author_x*>(calloc(1, sizeof(author_x)));
 250   if (!wgt_info->author().empty())
 251     author->text = strdup(wgt_info->author().c_str());
 252   if (!wgt_info->author_email().empty())
 253     author->email = strdup(wgt_info->author_email().c_str());
 254   if (!wgt_info->author_href().empty())
 255     author->href = strdup(wgt_info->author_href().c_str());
 256   author->lang = strdup(DEFAULT_LOCALE);
 257   manifest->author = g_list_append(manifest->author, author);
 258
 259   auto settings_info =
 260       GetManifestDataForKey<const wgt::parse::SettingInfo>(
 261              wgt::application_widget_keys::kTizenSettingKey);
 262   if (settings_info) {
 263     switch (settings_info->install_location()) {
 264     case wgt::parse::SettingInfo::InstallLocation::AUTO: {
 265       manifest->installlocation = strdup("auto");
 266       break;
 267     }
 268     case wgt::parse::SettingInfo::InstallLocation::INTERNAL: {
 269       manifest->installlocation = strdup("internal-only");
 270       break;
 271     }
 272     case wgt::parse::SettingInfo::InstallLocation::EXTERNAL: {
 273       manifest->installlocation = strdup("prefer-external");
 274       break;
 275     }
 276     }
 277   } else {
 278     manifest->installlocation = strdup("auto");
 279   }
 280
 281   return true;
 282 }
 283
 284 bool StepParse::FillMainApplicationInfo(manifest_x* manifest) {
 285   auto app_info =
 286       GetManifestDataForKey<const wgt::parse::TizenApplicationInfo>(
 287              app_keys::kTizenApplicationKey);
 288   if (!app_info) {
 289     LOG(ERROR) << "Application info manifest data has not been found.";
 290     return false;
 291   }
 292   bool has_watch_category = false;
 293   bool has_ime = false;
 294   auto category_info =
 295       GetManifestDataForKey<const wgt::parse::CategoryInfoList>(
 296              app_keys::kTizenCategoryKey);
 297
 298   if (category_info) {
 299     has_watch_category = std::find_if(category_info->categories.begin(),
 300                                        category_info->categories.end(),
 301                                        [](const std::string& category) {
 302       return category == kCategoryWearableClock ||
 303              category == kCategoryWatchClock;
 304     }) != category_info->categories.end();
 305     has_ime = std::find(category_info->categories.begin(),
 306                                        category_info->categories.end(),
 307                                        kImeCategoryName)
 308         != category_info->categories.end();
 309   }
 310
 311   // application data
 312   application_x* application = reinterpret_cast<application_x*>(
 313       calloc(1, sizeof(application_x)));
 314   application->component_type =
 315       has_watch_category ? strdup("watchapp") : strdup("uiapp");
 316   application->mainapp = strdup("true");
 317   application->appid = strdup(app_info->id().c_str());
 318   auto settings_info =
 319       GetManifestDataForKey<const wgt::parse::SettingInfo>(
 320              wgt::application_widget_keys::kTizenSettingKey);
 321   bool no_display = settings_info ? settings_info->no_display() : false;
 322   application->nodisplay = (has_watch_category || has_ime || no_display) ?
 323       strdup("true") : strdup("false");
 324   application->taskmanage = (has_watch_category || has_ime) ? strdup("false") :
 325       strdup("true");
 326   SetApplicationXDefaults(application);
 327   if (has_watch_category)
 328     application->ambient_support =
 329         strdup(app_info->ambient_support() ? "true" : "false");
 330   else
 331     application->ambient_support = strdup("false");
 332   application->package = strdup(app_info->package().c_str());
 333
 334   application->exec =
 335       strdup((context_->root_application_path.get() / app_info->package()
 336               / "bin" / application->appid).c_str());
 337   application->type = strdup("webapp");
 338   application->onboot = strdup("false");
 339   application->autorestart = strdup("false");
 340
 341   application->launch_mode = strdup(app_info->launch_mode().c_str());
 342   for (auto& icon : GListRange<icon_x*>(manifest->icon)) {
 343     icon_x* app_icon = reinterpret_cast<icon_x*>(calloc(1, sizeof(icon_x)));
 344     app_icon->text = strdup(icon->text);
 345     app_icon->lang = strdup(icon->lang);
 346     application->icon = g_list_append(application->icon, app_icon);
 347   }
 348   // guarantees that the main app will be at the begining of the list
 349   manifest->application = g_list_insert(manifest->application, application, 0);
 350
 351   manifest->package = strdup(app_info->package().c_str());
 352   manifest->mainapp_id = strdup(app_info->id().c_str());
 353   return true;
 354 }
 355
 356 bool StepParse::FillServiceApplicationInfo(manifest_x* manifest) {
 357   auto service_list =
 358       GetManifestDataForKey<const wgt::parse::ServiceList>(
 359              app_keys::kTizenServiceKey);
 360   if (!service_list)
 361     return true;
 362   for (auto& service_info : service_list->services) {
 363     application_x* application = reinterpret_cast<application_x*>
 364         (calloc(1, sizeof(application_x)));
 365     application->component_type = strdup("svcapp");
 366     application->mainapp = strdup("false");
 367     application->appid = strdup(service_info.id().c_str());
 368     application->exec =
 369         strdup((context_->root_application_path.get() / manifest->package
 370                 / "bin" / application->appid).c_str());
 371     application->type = strdup("webapp");
 372     application->onboot =
 373         service_info.on_boot() ? strdup("true") : strdup("false");
 374     application->autorestart =
 375         service_info.auto_restart() ? strdup("true") : strdup("false");
 376     application->nodisplay = strdup("false");
 377     application->taskmanage = strdup("true");
 378     SetApplicationXDefaults(application);
 379     application->ambient_support = strdup("false");
 380     application->package = strdup(manifest->package);
 381
 382     for (auto& pair : service_info.names()) {
 383       AppendLabel(application, pair.second, pair.first);
 384     }
 385
 386     if (!service_info.icon().empty()) {
 387       bf::path icon_path = context_->root_application_path.get()
 388           / manifest->package / "res" / "wgt" / service_info.icon();
 389       icon_x* icon = reinterpret_cast<icon_x*>(calloc(1, sizeof(icon_x)));
 390       icon->text = strdup(icon_path.c_str());
 391       icon->lang = strdup(DEFAULT_LOCALE);
 392       application->icon = g_list_append(application->icon, icon);
 393     }
 394
 395     for (auto& category : service_info.categories()) {
 396       application->category = g_list_append(application->category,
 397                                             strdup(category.c_str()));
 398     }
 399
 400     for (auto& pair : service_info.metadata_set()) {
 401       metadata_x* item = reinterpret_cast<metadata_x*>(
 402           calloc(1, sizeof(metadata_x)));
 403       item->key = strdup(pair.first.c_str());
 404       if (!pair.second.empty())
 405         item->value = strdup(pair.second.c_str());
 406       application->metadata = g_list_append(application->metadata, item);
 407     }
 408
 409     manifest->application = g_list_append(manifest->application, application);
 410   }
 411   return true;
 412 }
 413
 414 bool StepParse::FillWidgetApplicationInfo(manifest_x* manifest) {
 415   auto appwidget_info =
 416       GetManifestDataForKey<const wgt::parse::AppWidgetInfo>(
 417              wgt::application_widget_keys::kTizenAppWidgetFullKey);
 418   if (!appwidget_info)
 419     return true;
 420   for (auto& app_widget : appwidget_info->app_widgets()) {
 421     application_x* application = reinterpret_cast<application_x*>
 422         (calloc(1, sizeof(application_x)));
 423     application->component_type = strdup("widgetapp");
 424     application->mainapp = strdup("false");
 425     application->appid = strdup(app_widget.id.c_str());
 426     application->exec =
 427         strdup((context_->root_application_path.get() / manifest->package
 428                 / "bin" / application->appid).c_str());
 429     application->type = strdup("webapp");
 430     application->nodisplay = strdup("true");
 431     application->taskmanage = strdup("false");
 432     SetApplicationXDefaults(application);
 433     application->ambient_support = strdup("false");
 434     application->package = strdup(manifest->package);
 435
 436     if (!app_widget.label.default_value.empty()) {
 437       AppendLabel(application, app_widget.label.default_value, std::string());
 438     }
 439
 440     for (auto& pair : app_widget.label.lang_value_map) {
 441       AppendLabel(application, pair.second, pair.first);
 442     }
 443
 444     if (!app_widget.icon_src.empty()) {
 445       icon_x* icon = reinterpret_cast<icon_x*>(calloc(1, sizeof(icon_x)));
 446       icon->text = strdup(app_widget.icon_src.c_str());
 447       icon->lang = strdup(DEFAULT_LOCALE);
 448       application->icon = g_list_append(application->icon, icon);
 449     }
 450
 451     if (!app_widget.metadata.empty())
 452       AppendWidgetMetadata(&application->metadata, app_widget.metadata);
 453
 454     manifest->application = g_list_append(manifest->application, application);
 455   }
 456   return true;
 457 }
 458
 459
 460 bool StepParse::FillBackgroundCategoryInfo(manifest_x* manifest) {
 461   auto manifest_data = parser_->GetManifestData(
 462       app_keys::kTizenBackgroundCategoryKey);
 463   std::shared_ptr<const wgt::parse::BackgroundCategoryInfoList> bc_list =
 464       std::static_pointer_cast<const wgt::parse::BackgroundCategoryInfoList>(
 465           manifest_data);
 466
 467   if (!bc_list)
 468     return true;
 469
 470   application_x* app =
 471       reinterpret_cast<application_x*>(manifest->application->data);
 472
 473   for (auto& background_category : bc_list->background_categories) {
 474     app->background_category = g_list_append(
 475         app->background_category, strdup(background_category.value().c_str()));
 476   }
 477
 478   return true;
 479 }
 480
 481 bool StepParse::FillAppControl(manifest_x* manifest) {
 482   auto app_info_list =
 483       GetManifestDataForKey<const wgt::parse::AppControlInfoList>(
 484              app_keys::kTizenApplicationAppControlsKey);
 485
 486   application_x* app =
 487       reinterpret_cast<application_x*>(manifest->application->data);
 488   if (app_info_list) {
 489     for (const auto& control : app_info_list->controls) {
 490       appcontrol_x* app_control =
 491           static_cast<appcontrol_x*>(calloc(1, sizeof(appcontrol_x)));
 492       app_control->operation = strdup(control.operation().c_str());
 493       app_control->mime = strdup(control.mime().c_str());
 494       app_control->uri = strdup(control.uri().c_str());
 495       app->appcontrol = g_list_append(app->appcontrol, app_control);
 496     }
 497   }
 498   return true;
 499 }
 500
 501 bool StepParse::FillPrivileges(manifest_x* manifest) {
 502   auto perm_info =
 503       GetManifestDataForKey<const wgt::parse::PermissionsInfo>(
 504              app_keys::kTizenPermissionsKey);
 505   std::set<std::string> privileges;
 506   if (perm_info)
 507     privileges = ExtractPrivileges(perm_info);
 508
 509   for (auto& priv : privileges) {
 510     manifest->privileges =
 511         g_list_append(manifest->privileges, strdup(priv.c_str()));
 512   }
 513   return true;
 514 }
 515
 516 bool StepParse::FillCategories(manifest_x* manifest) {
 517   auto category_info =
 518       GetManifestDataForKey<const wgt::parse::CategoryInfoList>(
 519              app_keys::kTizenCategoryKey);
 520   if (!category_info)
 521     return true;
 522
 523   application_x* app =
 524       reinterpret_cast<application_x*>(manifest->application->data);
 525   // there is one app atm
 526   for (auto& category : category_info->categories) {
 527     app->category = g_list_append(app->category, strdup(category.c_str()));
 528   }
 529   return true;
 530 }
 531
 532 bool StepParse::FillMetadata(manifest_x* manifest) {
 533   auto meta_info =
 534       GetManifestDataForKey<const wgt::parse::MetaDataInfo>(
 535              app_keys::kTizenMetaDataKey);
 536   if (!meta_info)
 537     return true;
 538
 539   for (application_x* app : GListRange<application_x*>(manifest->application)) {
 540     app->metadata = GenerateMetadataListX(*meta_info);
 541   }
 542   return true;
 543 }
 544
 545 bool StepParse::FillAppWidget() {
 546   // This is needed to store preview icons which are not saved into manifest_x
 547   WgtBackendData* backend_data =
 548       static_cast<WgtBackendData*>(context_->backend_data.get());
 549
 550   auto appwidget_info =
 551       GetManifestDataForKey<const wgt::parse::AppWidgetInfo>(
 552              wgt::application_widget_keys::kTizenAppWidgetFullKey);
 553   if (appwidget_info)
 554     backend_data->appwidgets.set(*appwidget_info);
 555   return true;
 556 }
 557
 558 bool StepParse::FillAccounts(manifest_x* manifest) {
 559   auto account_info =
 560       GetManifestDataForKey<const wgt::parse::AccountInfo>(
 561              app_keys::kAccountKey);
 562   if (!account_info)
 563     return true;
 564   common_installer::AccountInfo info;
 565   for (auto& account : account_info->accounts()) {
 566     common_installer::SingleAccountInfo single_info;
 567     single_info.capabilities = account.capabilities;
 568     single_info.icon_paths = account.icon_paths;
 569     single_info.multiple_account_support = account.multiple_account_support;
 570     single_info.names = account.names;
 571     // wgt can contain only one app so this assumes mainapp_id is valid here
 572     single_info.appid = manifest->mainapp_id;
 573     info.set_account(single_info);
 574   }
 575   context_->manifest_plugins_data.get().account_info.set(info);
 576   return true;
 577 }
 578
 579 bool StepParse::FillImeInfo() {
 580   auto ime_info =
 581       GetManifestDataForKey<const wgt::parse::ImeInfo>(
 582              app_keys::kTizenImeKey);
 583   if (!ime_info)
 584     return true;
 585
 586   common_installer::ImeInfo info;
 587   info.setUuid(ime_info->uuid());
 588
 589   const auto &languages = ime_info->languages();
 590   for (const auto &language : languages)
 591     info.AddLanguage(language);
 592
 593   context_->manifest_plugins_data.get().ime_info.set(std::move(info));
 594   return true;
 595 }
 596
 597 bool StepParse::FillExtraManifestInfo(manifest_x* manifest) {
 598   return FillAccounts(manifest) && FillImeInfo() && FillAppWidget();
 599 }
 600
 601 bool StepParse::FillManifestX(manifest_x* manifest) {
 602   // Fill data for main application
 603   if (!FillIconPaths(manifest))
 604     return false;
 605   if (!FillMainApplicationInfo(manifest))
 606     return false;
 607   if (!FillWidgetInfo(manifest))
 608     return false;
 609   if (!FillInstallationInfo(manifest))
 610     return false;
 611   if (!FillPrivileges(manifest))
 612     return false;
 613   if (!FillAppControl(manifest))
 614     return false;
 615   if (!FillCategories(manifest))
 616     return false;
 617   if (!FillMetadata(manifest))
 618     return false;
 619   if (!FillBackgroundCategoryInfo(manifest))
 620     return false;
 621
 622   // Fill data for other applications
 623   if (!FillAdditionalApplications(manifest))
 624     return false;
 625
 626   // Fill extra data, other than manifest_x structure
 627   if (!FillExtraManifestInfo(manifest))
 628     return false;
 629
 630   return true;
 631 }
 632
 633
 634 bool StepParse::FillAdditionalApplications(manifest_x* manifest) {
 635   if (!FillServiceApplicationInfo(manifest))
 636     return false;
 637   if (!FillWidgetApplicationInfo(manifest))
 638     return false;
 639   return true;
 640 }
 641
 642 bool StepParse::LocateConfigFile() {
 643   switch (config_location_) {
 644     case ConfigLocation::PACKAGE:
 645       return StepParse::Check(context_->unpacked_dir_path.get());
 646     case ConfigLocation::INSTALLED:
 647       return StepParse::Check(context_->pkg_path.get() / kResWgt);
 648     case ConfigLocation::RECOVERY:
 649       if (StepParse::Check(common_installer::GetBackupPathForPackagePath(
 650           context_->root_application_path.get()
 651               / context_->pkgid.get()) / kResWgt))
 652         return true;
 653       if (StepParse::Check(
 654           context_->root_application_path.get()
 655               / context_->pkgid.get() / kResWgt))
 656         return true;
 657       return false;
 658     case ConfigLocation::RESOURCE_WGT:
 659       return StepParse::Check(context_->unpacked_dir_path.get() / kResWgt);
 660     default:
 661       LOG(ERROR) << "Unknown config location";
 662       return false;
 663   }
 664 }
 665
 666 common_installer::Step::Status StepParse::process() {
 667   if (!LocateConfigFile()) {
 668     LOG(ERROR) << "No config.xml";
 669     return common_installer::Step::Status::MANIFEST_NOT_FOUND;
 670   }
 671
 672   parser_.reset(new wgt::parse::WidgetConfigParser());
 673   if (!parser_->ParseManifest(widget_path_ / kConfigFileName)) {
 674     LOG(ERROR) << "[Parse] Parse failed. " <<  parser_->GetErrorMessage();
 675     return common_installer::Step::Status::PARSE_ERROR;
 676   }
 677
 678   WgtBackendData* backend_data =
 679     static_cast<WgtBackendData*>(context_->backend_data.get());
 680
 681   if (check_start_file_) {
 682     if (!parser_->CheckValidStartFile()) {
 683       LOG(ERROR) << parser_->GetErrorMessage();
 684       return common_installer::Step::Status::PARSE_ERROR;
 685     }
 686     if (!parser_->CheckValidServicesStartFiles()) {
 687       LOG(ERROR) << parser_->GetErrorMessage();
 688       return common_installer::Step::Status::PARSE_ERROR;
 689     }
 690   } else {
 691     // making backup of content data and services content data
 692     auto content_info =
 693       GetManifestDataForKey<const wgt::parse::ContentInfo>(
 694               wgt::application_widget_keys::kTizenContentKey);
 695     auto service_list =
 696       GetManifestDataForKey<const wgt::parse::ServiceList>(
 697               wgt::application_widget_keys::kTizenServiceKey);
 698     if (content_info)
 699       backend_data->content.set(*content_info);
 700     if (service_list)
 701       backend_data->service_list.set(*service_list);
 702   }
 703
 704   manifest_x* manifest =
 705       static_cast<manifest_x*>(calloc(1, sizeof(manifest_x)));
 706   if (!FillManifestX(manifest)) {
 707     LOG(ERROR) << "[Parse] Storing manifest_x failed. "
 708                <<  parser_->GetErrorMessage();
 709     return common_installer::Step::Status::PARSE_ERROR;
 710   }
 711
 712   // Copy data from ManifestData to InstallerContext
 713   auto info =
 714       GetManifestDataForKey<const wgt::parse::TizenApplicationInfo>(
 715               wgt::application_widget_keys::kTizenApplicationKey);
 716   auto wgt_info =
 717       GetManifestDataForKey<const wgt::parse::WidgetInfo>(
 718               wgt::application_widget_keys::kTizenWidgetKey);
 719
 720   std::string name;
 721   const auto& name_set = wgt_info->name_set();
 722   if (name_set.find("") != name_set.end())
 723     name = name_set.find("")->second;
 724   if (name_set.begin() != name_set.end())
 725     name = name_set.begin()->second;
 726
 727   std::string short_name;
 728   const auto& short_name_set = wgt_info->short_name_set();
 729   if (short_name_set.find("") != short_name_set.end())
 730     short_name = short_name_set.find("")->second;
 731   if (short_name_set.begin() != short_name_set.end())
 732     short_name = short_name_set.begin()->second;
 733
 734   const std::string& package_version = wgt_info->version();
 735   const std::string& required_api_version = info->required_version();
 736
 737   manifest->api_version = strdup(required_api_version.c_str());
 738
 739   context_->pkgid.set(manifest->package);
 740
 741   // write pkgid for recovery file
 742   if (context_->recovery_info.get().recovery_file) {
 743     context_->recovery_info.get().recovery_file->set_pkgid(manifest->package);
 744     context_->recovery_info.get().recovery_file->WriteAndCommitFileContent();
 745   }
 746
 747   auto perm_info =
 748       GetManifestDataForKey<const wgt::parse::PermissionsInfo>(
 749               wgt::application_widget_keys::kTizenPermissionsKey);
 750   parser::PermissionSet permissions;
 751   if (perm_info)
 752      permissions = perm_info->GetAPIPermissions();
 753
 754   auto settings_info =
 755       GetManifestDataForKey<const wgt::parse::SettingInfo>(
 756               wgt::application_widget_keys::kTizenSettingKey);
 757   if (settings_info)
 758     backend_data->settings.set(*settings_info);
 759
 760   LOG(DEBUG) << " Read data -[ ";
 761   LOG(DEBUG) << "App id: " << info->id();
 762   LOG(DEBUG) << "  package     = " <<  info->package();
 763   LOG(DEBUG) << "  id          = " <<  info->id();
 764   LOG(DEBUG) << "  name        = " <<  name;
 765   LOG(DEBUG) << "  short_name  = " <<  short_name;
 766   LOG(DEBUG) << "  aplication version     = " <<  package_version;
 767   LOG(DEBUG) << "  api_version = " <<  info->required_version();
 768   LOG(DEBUG) << "  launch_mode = " <<  info->launch_mode();
 769   LOG(DEBUG) << "  privileges -[";
 770   for (const auto& p : permissions) {
 771     LOG(DEBUG) << "    " << p;
 772   }
 773   LOG(DEBUG) << "  ]-";
 774   LOG(DEBUG) << "]-";
 775
 776   if (context_->manifest_data.get())
 777     pkgmgr_parser_free_manifest_xml(context_->manifest_data.get());
 778
 779   context_->manifest_data.set(manifest);
 780   return common_installer::Step::Status::OK;
 781 }
 782
 783 bool StepParse::Check(const boost::filesystem::path& widget_path) {
 784   LOG(DEBUG) << "unpacked widget path: " << widget_path;
 785
 786   widget_path_ = widget_path;
 787
 788   boost::filesystem::path config = widget_path / kConfigFileName;
 789   LOG(DEBUG) << "config.xml path: " << config;
 790   if (!boost::filesystem::exists(config))
 791     return false;
 792   return true;
 793 }
 794
 795 }  // namespace configuration
 796 }  // namespace wgt