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