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/pkgmgr_query.h>
14 #include <common/privileges.h>
15 #include <common/step/step.h>
16 #include <common/utils/glist_range.h>
17 #include <manifest_parser/utils/version_number.h>
18 #include <wgt_manifest_handlers/account_handler.h>
19 #include <wgt_manifest_handlers/app_control_handler.h>
20 #include <wgt_manifest_handlers/appdefined_privilege_handler.h>
21 #include <wgt_manifest_handlers/application_icons_handler.h>
22 #include <wgt_manifest_handlers/application_manifest_constants.h>
23 #include <wgt_manifest_handlers/background_category_handler.h>
24 #include <wgt_manifest_handlers/category_handler.h>
25 #include <wgt_manifest_handlers/content_handler.h>
26 #include <wgt_manifest_handlers/ime_handler.h>
27 #include <wgt_manifest_handlers/metadata_handler.h>
28 #include <wgt_manifest_handlers/provides_appdefined_privilege_handler.h>
29 #include <wgt_manifest_handlers/service_handler.h>
30 #include <wgt_manifest_handlers/setting_handler.h>
31 #include <wgt_manifest_handlers/tizen_application_handler.h>
32 #include <wgt_manifest_handlers/widget_handler.h>
33 #include <wgt_manifest_handlers/w3c_pc_utils.h>
35 #include <pkgmgr/pkgmgr_parser.h>
36 #include <pkgmgrinfo_basic.h>
49 #include "wgt/wgt_backend_data.h"
51 namespace bf = boost::filesystem;
52 namespace ci = common_installer;
56 const char kCategoryWearableClock[] =
57 "http://tizen.org/category/wearable_clock";
58 const char kCategoryWatchClock[] = "com.samsung.wmanager.WATCH_CLOCK";
60 const char kManifestVersion[] = "1.0.0";
61 const char kTizenPackageXmlNamespace[] = "http://tizen.org/ns/packages";
62 const char kImeCategoryName[] = "http://tizen.org/category/ime";
63 const char kDownloadableFontCategoryName[] =
64 "http://tizen.org/category/downloadable_font";
65 const char kTTSCategoryName[] = "http://tizen.org/category/tts";
67 const char kResWgt[] = "res/wgt";
68 const char kConfigFileName[] = "config.xml";
70 void FreeMetadataList(gpointer data) {
71 metadata_x* metadata = reinterpret_cast<metadata_x*>(data);
74 free(const_cast<char*>(metadata->key));
76 free(const_cast<char*>(metadata->value));
81 GList* GenerateMetadataListX(const wgt::parse::MetaDataInfo& meta_info) {
82 GList* list = nullptr;
83 for (auto& meta : meta_info.metadata()) {
84 metadata_x* new_meta =
85 static_cast<metadata_x*>(calloc(1, sizeof(metadata_x)));
87 LOG(ERROR) << "Out of memory";
88 g_list_free_full(list, &FreeMetadataList);
91 new_meta->key = strdup(meta.first.c_str());
92 if (!meta.second.empty())
93 new_meta->value = strdup(meta.second.c_str());
94 list = g_list_append(list, new_meta);
99 void AppendWidgetMetadata(GList** metadatas,
100 const std::vector<std::pair<std::string, std::string>> metadata) {
101 GList* list = *metadatas;
102 for (auto& meta : metadata) {
103 metadata_x* new_meta =
104 static_cast<metadata_x*>(calloc(1, sizeof(metadata_x)));
106 LOG(ERROR) << "Out of memory";
109 new_meta->key = strdup(meta.first.c_str());
110 if (!meta.second.empty())
111 new_meta->value = strdup(meta.second.c_str());
113 list = g_list_append(list, new_meta);
119 void SetApplicationXDefaults(application_x* application) {
120 application->effectimage_type = strdup("image");
121 application->guestmode_visibility = strdup("true");
122 application->hwacceleration = strdup("default");
123 application->indicatordisplay = strdup("true");
124 application->launchcondition = strdup("false");
125 application->permission_type = strdup("normal");
126 application->process_pool = strdup("false");
127 application->recentimage = strdup("false");
128 application->screenreader = strdup("use-system-setting");
129 application->submode = strdup("false");
130 application->support_disable = strdup("false");
131 application->ui_gadget = strdup("false");
132 application->multiple = strdup("false");
136 void AppendLabel(T* root, const std::string& label,
137 const std::string& locale) {
138 label_x* label_item = reinterpret_cast<label_x*>(calloc(1, sizeof(label_x)));
140 LOG(ERROR) << "Out of memory";
143 label_item->name = strdup(label.c_str());
144 label_item->text = strdup(label.c_str());
145 label_item->lang = !locale.empty() ?
146 strdup(locale.c_str()) : strdup(DEFAULT_LOCALE);
147 root->label = g_list_append(root->label, label_item);
153 namespace configuration {
155 namespace app_keys = wgt::application_widget_keys;
156 namespace sc = std::chrono;
158 StepParse::StepParse(common_installer::InstallerContext* context,
159 ConfigLocation config_location,
160 bool check_start_file)
162 config_location_(config_location),
163 check_start_file_(check_start_file) {
166 std::set<std::string> StepParse::ExtractPrivileges(
167 std::shared_ptr<const wgt::parse::PermissionsInfo> perm_info) const {
168 return perm_info->GetAPIPermissions();
171 std::string StepParse::GetPackageVersion(
172 const std::string& manifest_version) {
173 if (manifest_version.empty()) {
174 return kManifestVersion;
176 std::string version = manifest_version.substr(0,
177 manifest_version.find_first_not_of("1234567890."));
182 bool StepParse::FillInstallationInfo(manifest_x* manifest) {
183 manifest->root_path = strdup(
184 (context_->root_application_path.get() / manifest->package).c_str());
185 manifest->installed_time =
186 strdup(std::to_string(sc::system_clock::to_time_t(
187 sc::system_clock::now())).c_str());
191 bool StepParse::FillIconPaths(manifest_x* manifest) {
193 GetManifestDataForKey<const wgt::parse::TizenApplicationInfo>(
194 app_keys::kTizenApplicationKey);
196 LOG(ERROR) << "Application info manifest data has not been found.";
200 GetManifestDataForKey<const wgt::parse::ApplicationIconsInfo>(
201 app_keys::kIconsKey);
203 icons_info.reset(new(std::nothrow) wgt::parse::ApplicationIconsInfo());
205 LOG(ERROR) << "Out of memory";
209 wgt::parse::LocalizedApplicationIconsInfo localized_list =
210 wgt::parse::GetLocalizedIconList(*icons_info, widget_path_);
211 // We need to generate icon for each locale and icons are already set into
212 // lookup order. There isn't said that all icons should be received from
213 // one <icon> tag position so we iterate utils we run out of icons creating
214 // any icon element that are possible for given locale.
215 std::set<std::string> found_locales;
216 for (auto& application_icon : localized_list) {
217 const std::string& locale = application_icon.locale();
218 if (found_locales.find(locale) != found_locales.end())
220 found_locales.insert(locale);
222 icon_x* icon = reinterpret_cast<icon_x*>(calloc(1, sizeof(icon_x)));
224 LOG(ERROR) << "Out of memory";
227 bf::path icon_path = context_->root_application_path.get()
228 / app_info->package() / "res" / "wgt" / application_icon.path();
229 icon->text = strdup(icon_path.c_str());
231 icon->lang = strdup(locale.c_str());
233 icon->lang = strdup(DEFAULT_LOCALE);
234 manifest->icon = g_list_append(manifest->icon, icon);
239 bool StepParse::FillWidgetInfo(manifest_x* manifest) {
241 GetManifestDataForKey<const wgt::parse::WidgetInfo>(
242 app_keys::kWidgetKey);
244 if (!wgt_info.get()) {
245 LOG(ERROR) << "Widget info manifest data has not been found.";
249 const std::string& version = wgt_info->version();
251 manifest->ns = strdup(kTizenPackageXmlNamespace);
252 manifest->version = strdup(GetPackageVersion(version).c_str());
254 for (auto& item : wgt_info->description_set()) {
255 description_x* description = reinterpret_cast<description_x*>
256 (calloc(1, sizeof(description_x)));
258 LOG(ERROR) << "Out of memory";
261 description->text = strdup(item.second.c_str());
262 description->lang = !item.first.empty() ?
263 strdup(item.first.c_str()) : strdup(DEFAULT_LOCALE);
264 manifest->description = g_list_append(manifest->description, description);
267 for (auto& item : wgt_info->name_set()) {
268 AppendLabel(manifest, item.second, item.first);
271 manifest->type = strdup("wgt");
272 manifest->appsetting = strdup("false");
273 manifest->nodisplay_setting = strdup("false");
274 manifest->installed_storage = strdup("installed_internal");
276 // For wgt package use the long name
278 reinterpret_cast<application_x*>(manifest->application->data);
279 for (auto& item : wgt_info->name_set()) {
280 AppendLabel(app, item.second, item.first);
283 author_x* author = reinterpret_cast<author_x*>(calloc(1, sizeof(author_x)));
285 LOG(ERROR) << "Out of memory";
288 if (!wgt_info->author().empty())
289 author->text = strdup(wgt_info->author().c_str());
290 if (!wgt_info->author_email().empty())
291 author->email = strdup(wgt_info->author_email().c_str());
292 if (!wgt_info->author_href().empty())
293 author->href = strdup(wgt_info->author_href().c_str());
294 author->lang = strdup(DEFAULT_LOCALE);
295 manifest->author = g_list_append(manifest->author, author);
298 GetManifestDataForKey<const wgt::parse::SettingInfo>(
299 wgt::application_widget_keys::kTizenSettingKey);
301 switch (settings_info->install_location()) {
302 case wgt::parse::SettingInfo::InstallLocation::AUTO: {
303 manifest->installlocation = strdup("auto");
306 case wgt::parse::SettingInfo::InstallLocation::INTERNAL: {
307 manifest->installlocation = strdup("internal-only");
310 case wgt::parse::SettingInfo::InstallLocation::EXTERNAL: {
311 manifest->installlocation = strdup("prefer-external");
316 manifest->installlocation = strdup("auto");
319 if (!context_->pkgid.get().empty()) {
320 // set update true if package is updated preload package
321 ci::RequestType req_type = context_->request_type.get();
322 ci::PkgQueryInterface pkg_query(manifest->package, context_->uid.get());
323 if (pkg_query.IsUpdatedPackage())
324 manifest->update = strdup("true");
325 else if (pkg_query.IsPreloadPackage() &&
326 (req_type == ci::RequestType::Update ||
327 req_type == ci::RequestType::Delta ||
328 req_type == ci::RequestType::MountUpdate ||
329 req_type == ci::RequestType::ReadonlyUpdateInstall))
330 manifest->update = strdup("true");
332 manifest->update = strdup("false");
338 bool StepParse::FillMainApplicationInfo(manifest_x* manifest) {
340 GetManifestDataForKey<const wgt::parse::TizenApplicationInfo>(
341 app_keys::kTizenApplicationKey);
343 LOG(ERROR) << "Application info manifest data has not been found.";
346 bool has_watch_category = false;
347 bool has_ime = false;
348 bool has_downloadable_font = false;
349 bool has_tts = false;
351 GetManifestDataForKey<const wgt::parse::CategoryInfoList>(
352 app_keys::kTizenCategoryKey);
355 has_watch_category = std::find_if(category_info->categories.begin(),
356 category_info->categories.end(),
357 [](const std::string& category) {
358 return category == kCategoryWearableClock ||
359 category == kCategoryWatchClock;
360 }) != category_info->categories.end();
361 has_ime = std::find(category_info->categories.begin(),
362 category_info->categories.end(),
364 != category_info->categories.end();
365 has_downloadable_font = std::find(category_info->categories.begin(),
366 category_info->categories.end(),
367 kDownloadableFontCategoryName)
368 != category_info->categories.end();
369 has_tts = std::find(category_info->categories.begin(),
370 category_info->categories.end(),
372 != category_info->categories.end();
376 application_x* application = reinterpret_cast<application_x*>(
377 calloc(1, sizeof(application_x)));
379 LOG(ERROR) << "Out of memory";
382 application->component_type =
383 has_watch_category ? strdup("watchapp") : strdup("uiapp");
384 application->mainapp = strdup("true");
385 application->appid = strdup(app_info->id().c_str());
387 GetManifestDataForKey<const wgt::parse::SettingInfo>(
388 wgt::application_widget_keys::kTizenSettingKey);
390 bool no_display = settings_info ? settings_info->no_display() : false;
391 bool has_no_display_category =
392 has_watch_category || has_ime || has_tts || has_downloadable_font;
394 application->nodisplay = (has_no_display_category || no_display) ?
395 strdup("true") : strdup("false");
396 application->taskmanage = has_no_display_category ? strdup("false") :
399 SetApplicationXDefaults(application);
400 if (has_watch_category)
401 application->support_ambient =
402 strdup(app_info->ambient_support() ? "true" : "false");
404 application->support_ambient = strdup("false");
405 application->package = strdup(app_info->package().c_str());
408 strdup((context_->root_application_path.get() / app_info->package()
409 / "bin" / application->appid).c_str());
410 application->type = strdup("webapp");
411 application->onboot = strdup("false");
412 application->autorestart = strdup("false");
414 application->launch_mode = strdup(app_info->launch_mode().c_str());
415 for (auto& icon : GListRange<icon_x*>(manifest->icon)) {
416 icon_x* app_icon = reinterpret_cast<icon_x*>(calloc(1, sizeof(icon_x)));
418 LOG(ERROR) << "Out of memory";
419 pkgmgrinfo_basic_free_application(application);
422 app_icon->text = strdup(icon->text);
423 app_icon->lang = strdup(icon->lang);
424 application->icon = g_list_append(application->icon, app_icon);
426 // guarantees that the main app will be at the begining of the list
427 manifest->application = g_list_insert(manifest->application, application, 0);
429 manifest->package = strdup(app_info->package().c_str());
430 manifest->mainapp_id = strdup(app_info->id().c_str());
434 bool StepParse::FillServiceApplicationInfo(manifest_x* manifest) {
436 GetManifestDataForKey<const wgt::parse::ServiceList>(
437 app_keys::kTizenServiceKey);
440 for (auto& service_info : service_list->services) {
441 application_x* application = reinterpret_cast<application_x*>
442 (calloc(1, sizeof(application_x)));
444 LOG(ERROR) << "Out of memory";
447 application->component_type = strdup("svcapp");
448 application->mainapp = strdup("false");
449 application->appid = strdup(service_info.id().c_str());
451 strdup((context_->root_application_path.get() / manifest->package
452 / "bin" / application->appid).c_str());
453 application->type = strdup("webapp");
454 application->onboot =
455 service_info.on_boot() ? strdup("true") : strdup("false");
456 application->autorestart =
457 service_info.auto_restart() ? strdup("true") : strdup("false");
458 application->nodisplay = strdup("false");
459 application->taskmanage = strdup("true");
460 SetApplicationXDefaults(application);
461 application->support_ambient = strdup("false");
462 application->package = strdup(manifest->package);
464 for (auto& pair : service_info.names()) {
465 AppendLabel(application, pair.second, pair.first);
468 if (!service_info.icon().empty()) {
469 bf::path icon_path = context_->root_application_path.get()
470 / manifest->package / "res" / "wgt" / service_info.icon();
471 icon_x* icon = reinterpret_cast<icon_x*>(calloc(1, sizeof(icon_x)));
473 LOG(ERROR) << "Out of memory";
474 pkgmgrinfo_basic_free_application(application);
477 icon->text = strdup(icon_path.c_str());
478 icon->lang = strdup(DEFAULT_LOCALE);
479 application->icon = g_list_append(application->icon, icon);
482 for (auto& category : service_info.categories()) {
483 application->category = g_list_append(application->category,
484 strdup(category.c_str()));
487 for (auto& pair : service_info.metadata_set()) {
488 metadata_x* item = reinterpret_cast<metadata_x*>(
489 calloc(1, sizeof(metadata_x)));
491 LOG(ERROR) << "Out of memory";
494 item->key = strdup(pair.first.c_str());
495 if (!pair.second.empty())
496 item->value = strdup(pair.second.c_str());
497 application->metadata = g_list_append(application->metadata, item);
500 manifest->application = g_list_append(manifest->application, application);
505 bool StepParse::FillWidgetApplicationInfo(manifest_x* manifest) {
506 auto appwidget_info =
507 GetManifestDataForKey<const wgt::parse::AppWidgetInfo>(
508 wgt::application_widget_keys::kTizenAppWidgetFullKey);
511 for (auto& app_widget : appwidget_info->app_widgets()) {
512 application_x* application = reinterpret_cast<application_x*>
513 (calloc(1, sizeof(application_x)));
515 LOG(ERROR) << "Out of memory";
518 application->component_type = strdup("widgetapp");
519 application->mainapp = strdup("false");
520 application->appid = strdup(app_widget.id.c_str());
522 strdup((context_->root_application_path.get() / manifest->package
523 / "bin" / application->appid).c_str());
524 application->type = strdup("webapp");
525 application->nodisplay = strdup("true");
526 application->taskmanage = strdup("false");
527 SetApplicationXDefaults(application);
528 application->support_ambient = strdup("false");
529 application->package = strdup(manifest->package);
531 if (!app_widget.label.default_value.empty()) {
532 AppendLabel(application, app_widget.label.default_value, std::string());
535 for (auto& pair : app_widget.label.lang_value_map) {
536 AppendLabel(application, pair.second, pair.first);
539 if (!app_widget.icon_src.empty()) {
540 icon_x* icon = reinterpret_cast<icon_x*>(calloc(1, sizeof(icon_x)));
542 LOG(ERROR) << "Out of memory";
543 pkgmgrinfo_basic_free_application(application);
546 icon->text = strdup(app_widget.icon_src.c_str());
547 icon->lang = strdup(DEFAULT_LOCALE);
548 application->icon = g_list_append(application->icon, icon);
551 if (!app_widget.metadata.empty())
552 AppendWidgetMetadata(&application->metadata, app_widget.metadata);
554 manifest->application = g_list_append(manifest->application, application);
560 bool StepParse::FillBackgroundCategoryInfo(manifest_x* manifest) {
561 auto manifest_data = parser_->GetManifestData(
562 app_keys::kTizenBackgroundCategoryKey);
563 std::shared_ptr<const wgt::parse::BackgroundCategoryInfoList> bc_list =
564 std::static_pointer_cast<const wgt::parse::BackgroundCategoryInfoList>(
571 reinterpret_cast<application_x*>(manifest->application->data);
573 for (auto& background_category : bc_list->background_categories) {
574 app->background_category = g_list_append(
575 app->background_category, strdup(background_category.value().c_str()));
581 bool StepParse::FillTrustAnchorInfo(manifest_x* manifest) {
582 auto trust_anchor_info = parser_->GetManifestData(
583 app_keys::kTizenTrustAnchorKey);
585 if (!trust_anchor_info)
588 std::shared_ptr<const parse::TrustAnchorInfo> trust_anchor =
589 std::static_pointer_cast<const parse::TrustAnchorInfo>
595 std::string certs_dir = trust_anchor->get_certs_dir();
596 if (!certs_dir.empty())
597 manifest->pkg_certs_dir = strdup(certs_dir.c_str());
599 std::string use_system_certs = trust_anchor->get_use_system_certs();
600 if (!use_system_certs.empty())
601 manifest->use_system_certs = strdup(use_system_certs.c_str());
606 bool StepParse::FillAppControl(manifest_x* manifest) {
608 GetManifestDataForKey<const wgt::parse::AppControlInfoList>(
609 app_keys::kTizenApplicationAppControlsKey);
612 reinterpret_cast<application_x*>(manifest->application->data);
614 for (const auto& control : app_info_list->controls) {
615 appcontrol_x* app_control =
616 static_cast<appcontrol_x*>(calloc(1, sizeof(appcontrol_x)));
618 LOG(ERROR) << "Out of memory";
621 app_control->operation = strdup(control.operation().c_str());
622 app_control->mime = strdup(control.mime().c_str());
623 app_control->uri = strdup(control.uri().c_str());
624 app->appcontrol = g_list_append(app->appcontrol, app_control);
630 bool StepParse::FillPrivileges(manifest_x* manifest) {
632 GetManifestDataForKey<const wgt::parse::PermissionsInfo>(
633 app_keys::kTizenPermissionsKey);
634 std::set<std::string> privileges;
636 privileges = ExtractPrivileges(perm_info);
638 for (auto& priv : privileges) {
639 privilege_x* privilege =
640 reinterpret_cast<privilege_x*>(calloc(1, sizeof(privilege_x)));
642 LOG(ERROR) << "Out of memory";
645 privilege->type = strdup(common_installer::kWebPrivilegeType);
646 privilege->value = strdup(priv.c_str());
647 manifest->privileges = g_list_append(manifest->privileges, privilege);
652 bool StepParse::FillAppDefinedPrivileges(manifest_x* manifest) {
653 auto priv_info_list =
654 GetManifestDataForKey<const wgt::parse::AppDefinedPrivilegeInfoList>(
655 app_keys::kTizenAppDefinedPrivilegeKey);
659 for (auto& priv : priv_info_list->appdefined_privileges) {
660 appdefined_privilege_x* privilege =
661 reinterpret_cast<appdefined_privilege_x*>(calloc(1,
662 sizeof(appdefined_privilege_x)));
663 if (privilege == nullptr) {
664 LOG(ERROR) << "Memory alloc failure";
667 privilege->value = strdup(priv.name().c_str());
668 privilege->type = strdup(common_installer::kWebPrivilegeType);
669 if (!priv.license().empty()) {
670 if (bf::path(priv.license()).is_absolute())
671 privilege->license = strdup(priv.license().c_str());
673 privilege->license = strdup((context_->root_application_path.get()
674 / manifest->package / priv.license()).c_str());
676 manifest->appdefined_privileges =
677 g_list_append(manifest->appdefined_privileges, privilege);
682 bool StepParse::FillProvidesAppDefinedPrivileges(manifest_x* manifest) {
683 auto priv_info_list =
684 GetManifestDataForKey<const wgt::parse::AppDefinedPrivilegeInfoList>(
685 app_keys::kTizenProvidesAppDefinedPrivilegeKey);
689 for (auto& priv : priv_info_list->appdefined_privileges) {
690 appdefined_privilege_x* privilege =
691 reinterpret_cast<appdefined_privilege_x*>(calloc(1,
692 sizeof(appdefined_privilege_x)));
693 if (privilege == nullptr) {
694 LOG(ERROR) << "Memory alloc failure";
697 privilege->value = strdup(priv.name().c_str());
698 privilege->type = strdup(common_installer::kWebPrivilegeType);
699 if (!priv.license().empty()) {
700 if (bf::path(priv.license()).is_absolute())
701 privilege->license = strdup(priv.license().c_str());
703 privilege->license = strdup((context_->root_application_path.get()
704 / manifest->package / priv.license()).c_str());
706 manifest->provides_appdefined_privileges =
707 g_list_append(manifest->provides_appdefined_privileges, privilege);
712 bool StepParse::FillCategories(manifest_x* manifest) {
714 GetManifestDataForKey<const wgt::parse::CategoryInfoList>(
715 app_keys::kTizenCategoryKey);
720 reinterpret_cast<application_x*>(manifest->application->data);
721 // there is one app atm
722 for (auto& category : category_info->categories) {
723 app->category = g_list_append(app->category, strdup(category.c_str()));
728 bool StepParse::FillMetadata(manifest_x* manifest) {
730 GetManifestDataForKey<const wgt::parse::MetaDataInfo>(
731 app_keys::kTizenMetaDataKey);
735 for (application_x* app : GListRange<application_x*>(manifest->application)) {
736 app->metadata = GenerateMetadataListX(*meta_info);
741 bool StepParse::FillAppWidget() {
742 // This is needed to store preview icons which are not saved into manifest_x
743 WgtBackendData* backend_data =
744 static_cast<WgtBackendData*>(context_->backend_data.get());
746 auto appwidget_info =
747 GetManifestDataForKey<const wgt::parse::AppWidgetInfo>(
748 wgt::application_widget_keys::kTizenAppWidgetFullKey);
750 backend_data->appwidgets.set(*appwidget_info);
754 bool StepParse::FillAccounts(manifest_x* manifest) {
756 GetManifestDataForKey<const wgt::parse::AccountInfo>(
757 app_keys::kAccountKey);
760 common_installer::AccountInfo info;
761 for (auto& account : account_info->accounts()) {
762 common_installer::SingleAccountInfo single_info;
763 single_info.capabilities = account.capabilities;
764 single_info.icon_paths = account.icon_paths;
765 single_info.multiple_account_support = account.multiple_account_support;
766 single_info.names = account.names;
767 // wgt can contain only one app so this assumes mainapp_id is valid here
768 single_info.appid = manifest->mainapp_id;
769 info.set_account(single_info);
771 context_->manifest_plugins_data.get().account_info.set(info);
775 bool StepParse::FillImeInfo() {
777 GetManifestDataForKey<const wgt::parse::ImeInfo>(
778 app_keys::kTizenImeKey);
782 common_installer::ImeInfo info;
783 info.setUuid(ime_info->uuid());
785 const auto &languages = ime_info->languages();
786 for (const auto &language : languages)
787 info.AddLanguage(language);
789 context_->manifest_plugins_data.get().ime_info.set(std::move(info));
793 bool StepParse::FillExtraManifestInfo(manifest_x* manifest) {
794 return FillAccounts(manifest) && FillImeInfo() && FillAppWidget();
797 bool StepParse::FillManifestX(manifest_x* manifest) {
798 // Fill data for main application
799 if (!FillIconPaths(manifest))
801 if (!FillMainApplicationInfo(manifest))
803 if (!FillWidgetInfo(manifest))
805 if (!FillInstallationInfo(manifest))
807 if (!FillPrivileges(manifest))
809 if (!FillAppDefinedPrivileges(manifest))
811 if (!FillProvidesAppDefinedPrivileges(manifest))
813 if (!FillAppControl(manifest))
815 if (!FillCategories(manifest))
817 if (!FillMetadata(manifest))
819 if (!FillBackgroundCategoryInfo(manifest))
821 if (!FillTrustAnchorInfo(manifest))
824 // Fill data for other applications
825 if (!FillAdditionalApplications(manifest))
828 // Fill extra data, other than manifest_x structure
829 if (!FillExtraManifestInfo(manifest))
836 bool StepParse::FillAdditionalApplications(manifest_x* manifest) {
837 if (!FillServiceApplicationInfo(manifest))
839 if (!FillWidgetApplicationInfo(manifest))
844 bool StepParse::LocateConfigFile() {
845 switch (config_location_) {
846 case ConfigLocation::PACKAGE:
847 return StepParse::Check(context_->unpacked_dir_path.get());
848 case ConfigLocation::INSTALLED:
849 return StepParse::Check(context_->pkg_path.get() / kResWgt);
850 case ConfigLocation::RECOVERY:
851 if (StepParse::Check(common_installer::GetBackupPathForPackagePath(
852 context_->root_application_path.get()
853 / context_->pkgid.get()) / kResWgt))
855 if (StepParse::Check(
856 context_->root_application_path.get()
857 / context_->pkgid.get() / kResWgt))
860 case ConfigLocation::RESOURCE_WGT:
861 return StepParse::Check(context_->unpacked_dir_path.get() / kResWgt);
863 LOG(ERROR) << "Unknown config location";
868 common_installer::Step::Status StepParse::process() {
869 if (!LocateConfigFile()) {
870 LOG(ERROR) << "No config.xml";
871 return common_installer::Step::Status::MANIFEST_NOT_FOUND;
874 parser_.reset(new(std::nothrow) wgt::parse::WidgetConfigParser());
876 LOG(ERROR) << "Out of memory";
877 return common_installer::Step::Status::CONFIG_ERROR;
879 if (!parser_->ParseManifest(widget_path_ / kConfigFileName)) {
880 LOG(ERROR) << "[Parse] Parse failed. " << parser_->GetErrorMessage();
881 return common_installer::Step::Status::PARSE_ERROR;
884 WgtBackendData* backend_data =
885 static_cast<WgtBackendData*>(context_->backend_data.get());
887 if (check_start_file_) {
888 if (!parser_->CheckValidStartFile()) {
889 LOG(ERROR) << parser_->GetErrorMessage();
890 return common_installer::Step::Status::PARSE_ERROR;
892 if (!parser_->CheckValidServicesStartFiles()) {
893 LOG(ERROR) << parser_->GetErrorMessage();
894 return common_installer::Step::Status::PARSE_ERROR;
897 // making backup of content data and services content data
899 GetManifestDataForKey<const wgt::parse::ContentInfo>(
900 wgt::application_widget_keys::kTizenContentKey);
902 GetManifestDataForKey<const wgt::parse::ServiceList>(
903 wgt::application_widget_keys::kTizenServiceKey);
905 backend_data->content.set(*content_info);
907 backend_data->service_list.set(*service_list);
910 manifest_x* manifest =
911 static_cast<manifest_x*>(calloc(1, sizeof(manifest_x)));
913 LOG(ERROR) << "Out of memory";
914 return common_installer::Step::Status::ERROR;
916 if (!FillManifestX(manifest)) {
917 LOG(ERROR) << "[Parse] Storing manifest_x failed. "
918 << parser_->GetErrorMessage();
919 return common_installer::Step::Status::PARSE_ERROR;
922 // Copy data from ManifestData to InstallerContext
924 GetManifestDataForKey<const wgt::parse::TizenApplicationInfo>(
925 wgt::application_widget_keys::kTizenApplicationKey);
927 GetManifestDataForKey<const wgt::parse::WidgetInfo>(
928 wgt::application_widget_keys::kTizenWidgetKey);
931 const auto& name_set = wgt_info->name_set();
932 if (name_set.find("") != name_set.end())
933 name = name_set.find("")->second;
934 if (name_set.begin() != name_set.end())
935 name = name_set.begin()->second;
937 std::string short_name;
938 const auto& short_name_set = wgt_info->short_name_set();
939 if (short_name_set.find("") != short_name_set.end())
940 short_name = short_name_set.find("")->second;
941 if (short_name_set.begin() != short_name_set.end())
942 short_name = short_name_set.begin()->second;
944 const std::string& package_version = wgt_info->version();
945 const std::string& required_api_version = info->required_version();
947 manifest->api_version = strdup(required_api_version.c_str());
949 context_->pkgid.set(manifest->package);
951 // write pkgid for recovery file
952 if (context_->recovery_info.get().recovery_file) {
953 context_->recovery_info.get().recovery_file->set_pkgid(manifest->package);
954 context_->recovery_info.get().recovery_file->WriteAndCommitFileContent();
958 GetManifestDataForKey<const wgt::parse::PermissionsInfo>(
959 wgt::application_widget_keys::kTizenPermissionsKey);
960 parser::PermissionSet permissions;
962 permissions = perm_info->GetAPIPermissions();
965 GetManifestDataForKey<const wgt::parse::SettingInfo>(
966 wgt::application_widget_keys::kTizenSettingKey);
968 backend_data->settings.set(*settings_info);
970 LOG(DEBUG) << " Read data -[ ";
971 LOG(DEBUG) << "App id: " << info->id();
972 LOG(DEBUG) << " package = " << info->package();
973 LOG(DEBUG) << " id = " << info->id();
974 LOG(DEBUG) << " name = " << name;
975 LOG(DEBUG) << " short_name = " << short_name;
976 LOG(DEBUG) << " aplication version = " << package_version;
977 LOG(DEBUG) << " api_version = " << info->required_version();
978 LOG(DEBUG) << " launch_mode = " << info->launch_mode();
979 LOG(DEBUG) << " privileges -[";
980 for (const auto& p : permissions) {
981 LOG(DEBUG) << " " << p;
986 if (context_->manifest_data.get())
987 pkgmgr_parser_free_manifest_xml(context_->manifest_data.get());
989 context_->manifest_data.set(manifest);
990 return common_installer::Step::Status::OK;
993 bool StepParse::Check(const boost::filesystem::path& widget_path) {
994 LOG(DEBUG) << "unpacked widget path: " << widget_path;
996 widget_path_ = widget_path;
998 boost::filesystem::path config = widget_path / kConfigFileName;
999 LOG(DEBUG) << "config.xml path: " << config;
1000 if (!boost::filesystem::exists(config))
1005 } // namespace configuration