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.
6 #include "wgt/step/configuration/step_parse.h"
8 #include <boost/filesystem/path.hpp>
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>
31 #include <pkgmgr/pkgmgr_parser.h>
43 #include "wgt/wgt_backend_data.h"
45 namespace bf = boost::filesystem;
49 const char kCategoryWearableClock[] =
50 "http://tizen.org/category/wearable_clock";
51 const char kCategoryWatchClock[] = "com.samsung.wmanager.WATCH_CLOCK";
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";
57 const char kResWgt[] = "res/wgt";
59 GList* GenerateMetadataListX(const wgt::parse::MetaDataInfo& meta_info) {
60 GList* list = nullptr;
61 for (auto& meta : meta_info.metadata()) {
62 metadata_x* new_meta =
63 static_cast<metadata_x*>(calloc(1, sizeof(metadata_x)));
64 new_meta->key = strdup(meta.first.c_str());
65 if (!meta.second.empty())
66 new_meta->value = strdup(meta.second.c_str());
67 list = g_list_append(list, new_meta);
72 void SetApplicationXDefaults(application_x* application) {
73 application->effectimage_type = strdup("image");
74 application->enabled = strdup("true");
75 application->guestmode_visibility = strdup("true");
76 application->hwacceleration = strdup("default");
77 application->indicatordisplay = strdup("true");
78 application->launchcondition = strdup("false");
79 application->permission_type = strdup("normal");
80 application->process_pool = strdup("false");
81 application->recentimage = strdup("false");
82 application->screenreader = strdup("use-system-setting");
83 application->submode = strdup("false");
84 application->support_disable = strdup("false");
85 application->ui_gadget = strdup("false");
86 application->multiple = strdup("false");
90 void AppendLabel(T* root, const std::string& label,
91 const std::string& locale) {
92 label_x* label_item = reinterpret_cast<label_x*>(calloc(1, sizeof(label_x)));
93 label_item->name = strdup(label.c_str());
94 label_item->text = strdup(label.c_str());
95 label_item->lang = !locale.empty() ?
96 strdup(locale.c_str()) : strdup(DEFAULT_LOCALE);
97 root->label = g_list_append(root->label, label_item);
102 namespace configuration {
104 namespace app_keys = wgt::application_widget_keys;
105 namespace sc = std::chrono;
107 StepParse::StepParse(common_installer::InstallerContext* context,
108 ConfigLocation config_location,
109 bool check_start_file)
111 config_location_(config_location),
112 check_start_file_(check_start_file) {
115 std::set<std::string> StepParse::ExtractPrivileges(
116 std::shared_ptr<const wgt::parse::PermissionsInfo> perm_info) const {
117 return perm_info->GetAPIPermissions();
120 std::string StepParse::GetPackageVersion(
121 const std::string& manifest_version) {
122 if (manifest_version.empty()) {
123 return kManifestVersion;
125 std::string version = manifest_version.substr(0,
126 manifest_version.find_first_not_of("1234567890."));
128 utils::VersionNumber version_number(version);
130 if (!version_number.IsValidTizenPackageVersion()) {
131 LOG(WARNING) << "Version number: " << manifest_version
132 << " is not valid version number for tizen package. "
133 << "Default value will be used.";
134 return kManifestVersion;
137 return version_number.ToString();
140 bool StepParse::FillInstallationInfo(manifest_x* manifest) {
141 manifest->root_path = strdup(
142 (context_->root_application_path.get() / manifest->package).c_str());
143 manifest->installed_time =
144 strdup(std::to_string(sc::system_clock::to_time_t(
145 sc::system_clock::now())).c_str());
149 bool StepParse::FillIconPaths(manifest_x* manifest) {
151 GetManifestDataForKey<const wgt::parse::TizenApplicationInfo>(
152 app_keys::kTizenApplicationKey);
154 LOG(ERROR) << "Application info manifest data has not been found.";
158 GetManifestDataForKey<const wgt::parse::ApplicationIconsInfo>(
159 app_keys::kIconsKey);
161 icons_info.reset(new wgt::parse::ApplicationIconsInfo());
163 wgt::parse::LocalizedApplicationIconsInfo localized_list =
164 wgt::parse::GetLocalizedIconList(*icons_info,
165 context_->unpacked_dir_path.get());
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())
175 found_locales.insert(locale);
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());
182 icon->lang = strdup(locale.c_str());
184 icon->lang = strdup(DEFAULT_LOCALE);
185 manifest->icon = g_list_append(manifest->icon, icon);
190 bool StepParse::FillWidgetInfo(manifest_x* manifest) {
192 GetManifestDataForKey<const wgt::parse::WidgetInfo>(
193 app_keys::kWidgetKey);
195 if (!wgt_info.get()) {
196 LOG(ERROR) << "Widget info manifest data has not been found.";
200 const std::string& version = wgt_info->version();
202 manifest->ns = strdup(kTizenPackageXmlNamespace);
203 manifest->version = strdup(GetPackageVersion(version).c_str());
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);
214 for (auto& item : wgt_info->name_set()) {
215 AppendLabel(manifest, item.second, item.first);
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");
224 manifest->preload = strdup("false");
225 manifest->installed_storage = strdup("installed_internal");
227 // For wgt package use the long name
229 reinterpret_cast<application_x*>(manifest->application->data);
230 for (auto& item : wgt_info->name_set()) {
231 AppendLabel(app, item.second, item.first);
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);
245 GetManifestDataForKey<const wgt::parse::SettingInfo>(
246 wgt::application_widget_keys::kTizenSettingKey);
248 switch (settings_info->install_location()) {
249 case wgt::parse::SettingInfo::InstallLocation::AUTO: {
250 manifest->installlocation = strdup("auto");
253 case wgt::parse::SettingInfo::InstallLocation::INTERNAL: {
254 manifest->installlocation = strdup("internal-only");
257 case wgt::parse::SettingInfo::InstallLocation::EXTERNAL: {
258 manifest->installlocation = strdup("prefer-external");
263 manifest->installlocation = strdup("auto");
269 bool StepParse::FillMainApplicationInfo(manifest_x* manifest) {
271 GetManifestDataForKey<const wgt::parse::TizenApplicationInfo>(
272 app_keys::kTizenApplicationKey);
274 LOG(ERROR) << "Application info manifest data has not been found.";
277 bool has_watch_catergory = false;
278 bool has_ime = false;
280 GetManifestDataForKey<const wgt::parse::CategoryInfoList>(
281 app_keys::kTizenCategoryKey);
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(),
293 != category_info->categories.end();
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");
310 application->ambient_support = strdup("false");
311 application->package = strdup(app_info->package().c_str());
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");
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);
327 // guarantees that the main app will be at the begining of the list
328 manifest->application = g_list_insert(manifest->application, application, 0);
330 manifest->package = strdup(app_info->package().c_str());
331 manifest->mainapp_id = strdup(app_info->id().c_str());
335 bool StepParse::FillServiceApplicationInfo(manifest_x* manifest) {
337 GetManifestDataForKey<const wgt::parse::ServiceList>(
338 app_keys::kTizenServiceKey);
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());
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);
361 for (auto& pair : service_info.names()) {
362 AppendLabel(application, pair.second, pair.first);
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);
374 for (auto& category : service_info.categories()) {
375 application->category = g_list_append(application->category,
376 strdup(category.c_str()));
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);
388 manifest->application = g_list_append(manifest->application, application);
393 bool StepParse::FillWidgetApplicationInfo(manifest_x* manifest) {
394 auto appwidget_info =
395 GetManifestDataForKey<const wgt::parse::AppWidgetInfo>(
396 wgt::application_widget_keys::kTizenAppWidgetFullKey);
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());
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);
415 if (!app_widget.label.default_value.empty()) {
416 AppendLabel(application, app_widget.label.default_value, std::string());
419 for (auto& pair : app_widget.label.lang_value_map) {
420 AppendLabel(application, pair.second, pair.first);
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);
430 manifest->application = g_list_append(manifest->application, application);
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>(
447 reinterpret_cast<application_x*>(manifest->application->data);
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()));
457 bool StepParse::FillAppControl(manifest_x* manifest) {
459 GetManifestDataForKey<const wgt::parse::AppControlInfoList>(
460 app_keys::kTizenApplicationAppControlsKey);
463 reinterpret_cast<application_x*>(manifest->application->data);
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);
477 bool StepParse::FillPrivileges(manifest_x* manifest) {
479 GetManifestDataForKey<const wgt::parse::PermissionsInfo>(
480 app_keys::kTizenPermissionsKey);
481 std::set<std::string> privileges;
483 privileges = ExtractPrivileges(perm_info);
485 for (auto& priv : privileges) {
486 manifest->privileges =
487 g_list_append(manifest->privileges, strdup(priv.c_str()));
492 bool StepParse::FillCategories(manifest_x* manifest) {
494 GetManifestDataForKey<const wgt::parse::CategoryInfoList>(
495 app_keys::kTizenCategoryKey);
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()));
508 bool StepParse::FillMetadata(manifest_x* manifest) {
510 GetManifestDataForKey<const wgt::parse::MetaDataInfo>(
511 app_keys::kTizenMetaDataKey);
515 for (application_x* app : GListRange<application_x*>(manifest->application)) {
516 app->metadata = GenerateMetadataListX(*meta_info);
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());
526 auto appwidget_info =
527 GetManifestDataForKey<const wgt::parse::AppWidgetInfo>(
528 wgt::application_widget_keys::kTizenAppWidgetFullKey);
530 backend_data->appwidgets.set(*appwidget_info);
534 bool StepParse::FillAccounts(manifest_x* manifest) {
536 GetManifestDataForKey<const wgt::parse::AccountInfo>(
537 app_keys::kAccountKey);
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);
551 context_->manifest_plugins_data.get().account_info.set(info);
555 bool StepParse::FillImeInfo() {
557 GetManifestDataForKey<const wgt::parse::ImeInfo>(
558 app_keys::kTizenImeKey);
562 common_installer::ImeInfo info;
563 info.setUuid(ime_info->uuid());
565 const auto &languages = ime_info->languages();
566 for (const auto &language : languages)
567 info.AddLanguage(language);
569 context_->manifest_plugins_data.get().ime_info.set(std::move(info));
573 bool StepParse::FillExtraManifestInfo(manifest_x* manifest) {
574 return FillAccounts(manifest) && FillImeInfo() && FillAppWidget();
577 bool StepParse::FillManifestX(manifest_x* manifest) {
578 // Fill data for main application
579 if (!FillIconPaths(manifest))
581 if (!FillMainApplicationInfo(manifest))
583 if (!FillWidgetInfo(manifest))
585 if (!FillInstallationInfo(manifest))
587 if (!FillPrivileges(manifest))
589 if (!FillAppControl(manifest))
591 if (!FillCategories(manifest))
593 if (!FillMetadata(manifest))
595 if (!FillBackgroundCategoryInfo(manifest))
598 // Fill data for other applications
599 if (!FillAdditionalApplications(manifest))
602 // Fill extra data, other than manifest_x structure
603 if (!FillExtraManifestInfo(manifest))
610 bool StepParse::FillAdditionalApplications(manifest_x* manifest) {
611 if (!FillServiceApplicationInfo(manifest))
613 if (!FillWidgetApplicationInfo(manifest))
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))
629 if (StepParse::Check(
630 context_->root_application_path.get()
631 / context_->pkgid.get() / kResWgt))
634 case ConfigLocation::RESOURCE_WGT:
635 return StepParse::Check(context_->unpacked_dir_path.get() / kResWgt);
637 LOG(ERROR) << "Unknown config location";
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;
648 parser_.reset(new wgt::parse::WidgetConfigParser());
649 if (!parser_->ParseManifest(config_)) {
650 LOG(ERROR) << "[Parse] Parse failed. " << parser_->GetErrorMessage();
651 return common_installer::Step::Status::PARSE_ERROR;
654 WgtBackendData* backend_data =
655 static_cast<WgtBackendData*>(context_->backend_data.get());
657 if (check_start_file_) {
658 if (!parser_->CheckValidStartFile()) {
659 LOG(ERROR) << parser_->GetErrorMessage();
660 return common_installer::Step::Status::PARSE_ERROR;
662 if (!parser_->CheckValidServicesStartFiles()) {
663 LOG(ERROR) << parser_->GetErrorMessage();
664 return common_installer::Step::Status::PARSE_ERROR;
667 // making backup of content data and services content data
669 GetManifestDataForKey<const wgt::parse::ContentInfo>(
670 wgt::application_widget_keys::kTizenContentKey);
672 GetManifestDataForKey<const wgt::parse::ServiceList>(
673 wgt::application_widget_keys::kTizenServiceKey);
675 backend_data->content.set(*content_info);
677 backend_data->service_list.set(*service_list);
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;
688 // Copy data from ManifestData to InstallerContext
690 GetManifestDataForKey<const wgt::parse::TizenApplicationInfo>(
691 wgt::application_widget_keys::kTizenApplicationKey);
693 GetManifestDataForKey<const wgt::parse::WidgetInfo>(
694 wgt::application_widget_keys::kTizenWidgetKey);
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;
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;
710 const std::string& package_version = wgt_info->version();
711 const std::string& required_api_version = info->required_version();
713 manifest->api_version = strdup(required_api_version.c_str());
715 context_->pkgid.set(manifest->package);
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();
724 GetManifestDataForKey<const wgt::parse::PermissionsInfo>(
725 wgt::application_widget_keys::kTizenPermissionsKey);
726 parser::PermissionSet permissions;
728 permissions = perm_info->GetAPIPermissions();
731 GetManifestDataForKey<const wgt::parse::SettingInfo>(
732 wgt::application_widget_keys::kTizenSettingKey);
734 backend_data->settings.set(*settings_info);
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;
752 if (context_->manifest_data.get())
753 pkgmgr_parser_free_manifest_xml(context_->manifest_data.get());
755 context_->manifest_data.set(manifest);
756 return common_installer::Step::Status::OK;
759 bool StepParse::Check(const boost::filesystem::path& widget_path) {
760 boost::filesystem::path config = widget_path / "config.xml";
762 LOG(DEBUG) << "config.xml path: " << config;
764 if (!boost::filesystem::exists(config))
771 } // namespace configuration