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