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 application->api_version = strdup(manifest->api_version);
416 for (auto& icon : GListRange<icon_x*>(manifest->icon)) {
417 icon_x* app_icon = reinterpret_cast<icon_x*>(calloc(1, sizeof(icon_x)));
419 LOG(ERROR) << "Out of memory";
420 pkgmgrinfo_basic_free_application(application);
423 app_icon->text = strdup(icon->text);
424 app_icon->lang = strdup(icon->lang);
425 application->icon = g_list_append(application->icon, app_icon);
427 // guarantees that the main app will be at the begining of the list
428 manifest->application = g_list_insert(manifest->application, application, 0);
430 manifest->package = strdup(app_info->package().c_str());
431 manifest->mainapp_id = strdup(app_info->id().c_str());
435 bool StepParse::FillServiceApplicationInfo(manifest_x* manifest) {
437 GetManifestDataForKey<const wgt::parse::ServiceList>(
438 app_keys::kTizenServiceKey);
441 for (auto& service_info : service_list->services) {
442 application_x* application = reinterpret_cast<application_x*>
443 (calloc(1, sizeof(application_x)));
445 LOG(ERROR) << "Out of memory";
448 application->component_type = strdup("svcapp");
449 application->mainapp = strdup("false");
450 application->appid = strdup(service_info.id().c_str());
452 strdup((context_->root_application_path.get() / manifest->package
453 / "bin" / application->appid).c_str());
454 application->type = strdup("webapp");
455 application->onboot =
456 service_info.on_boot() ? strdup("true") : strdup("false");
457 application->autorestart =
458 service_info.auto_restart() ? strdup("true") : strdup("false");
459 application->nodisplay = strdup("false");
460 application->taskmanage = strdup("true");
461 SetApplicationXDefaults(application);
462 application->support_ambient = strdup("false");
463 application->package = strdup(manifest->package);
464 application->api_version = strdup(manifest->api_version);
465 for (auto& pair : service_info.names()) {
466 AppendLabel(application, pair.second, pair.first);
469 if (!service_info.icon().empty()) {
470 bf::path icon_path = context_->root_application_path.get()
471 / manifest->package / "res" / "wgt" / service_info.icon();
472 icon_x* icon = reinterpret_cast<icon_x*>(calloc(1, sizeof(icon_x)));
474 LOG(ERROR) << "Out of memory";
475 pkgmgrinfo_basic_free_application(application);
478 icon->text = strdup(icon_path.c_str());
479 icon->lang = strdup(DEFAULT_LOCALE);
480 application->icon = g_list_append(application->icon, icon);
483 for (auto& category : service_info.categories()) {
484 application->category = g_list_append(application->category,
485 strdup(category.c_str()));
488 for (auto& pair : service_info.metadata_set()) {
489 metadata_x* item = reinterpret_cast<metadata_x*>(
490 calloc(1, sizeof(metadata_x)));
492 LOG(ERROR) << "Out of memory";
495 item->key = strdup(pair.first.c_str());
496 if (!pair.second.empty())
497 item->value = strdup(pair.second.c_str());
498 application->metadata = g_list_append(application->metadata, item);
501 manifest->application = g_list_append(manifest->application, application);
506 bool StepParse::FillWidgetApplicationInfo(manifest_x* manifest) {
507 auto appwidget_info =
508 GetManifestDataForKey<const wgt::parse::AppWidgetInfo>(
509 wgt::application_widget_keys::kTizenAppWidgetFullKey);
512 for (auto& app_widget : appwidget_info->app_widgets()) {
513 application_x* application = reinterpret_cast<application_x*>
514 (calloc(1, sizeof(application_x)));
516 LOG(ERROR) << "Out of memory";
519 application->component_type = strdup("widgetapp");
520 application->mainapp = strdup("false");
521 application->appid = strdup(app_widget.id.c_str());
523 strdup((context_->root_application_path.get() / manifest->package
524 / "bin" / application->appid).c_str());
525 application->type = strdup("webapp");
526 application->nodisplay = strdup("true");
527 application->taskmanage = strdup("false");
528 SetApplicationXDefaults(application);
529 application->support_ambient = strdup("false");
530 application->package = strdup(manifest->package);
531 application->api_version = strdup(manifest->api_version);
532 if (!app_widget.label.default_value.empty()) {
533 AppendLabel(application, app_widget.label.default_value, std::string());
536 for (auto& pair : app_widget.label.lang_value_map) {
537 AppendLabel(application, pair.second, pair.first);
540 if (!app_widget.icon_src.empty()) {
541 icon_x* icon = reinterpret_cast<icon_x*>(calloc(1, sizeof(icon_x)));
543 LOG(ERROR) << "Out of memory";
544 pkgmgrinfo_basic_free_application(application);
547 icon->text = strdup(app_widget.icon_src.c_str());
548 icon->lang = strdup(DEFAULT_LOCALE);
549 application->icon = g_list_append(application->icon, icon);
552 if (!app_widget.metadata.empty())
553 AppendWidgetMetadata(&application->metadata, app_widget.metadata);
555 manifest->application = g_list_append(manifest->application, application);
561 bool StepParse::FillBackgroundCategoryInfo(manifest_x* manifest) {
562 auto manifest_data = parser_->GetManifestData(
563 app_keys::kTizenBackgroundCategoryKey);
564 std::shared_ptr<const wgt::parse::BackgroundCategoryInfoList> bc_list =
565 std::static_pointer_cast<const wgt::parse::BackgroundCategoryInfoList>(
572 reinterpret_cast<application_x*>(manifest->application->data);
574 for (auto& background_category : bc_list->background_categories) {
575 app->background_category = g_list_append(
576 app->background_category, strdup(background_category.value().c_str()));
582 bool StepParse::FillTrustAnchorInfo(manifest_x* manifest) {
583 auto trust_anchor_info = parser_->GetManifestData(
584 app_keys::kTizenTrustAnchorKey);
586 if (!trust_anchor_info)
589 std::shared_ptr<const parse::TrustAnchorInfo> trust_anchor =
590 std::static_pointer_cast<const parse::TrustAnchorInfo>
596 std::string use_system_certs = trust_anchor->get_use_system_certs();
597 if (!use_system_certs.empty())
598 manifest->use_system_certs = strdup(use_system_certs.c_str());
603 bool StepParse::FillAppControl(manifest_x* manifest) {
605 GetManifestDataForKey<const wgt::parse::AppControlInfoList>(
606 app_keys::kTizenApplicationAppControlsKey);
609 reinterpret_cast<application_x*>(manifest->application->data);
611 for (const auto& control : app_info_list->controls) {
612 appcontrol_x* app_control =
613 static_cast<appcontrol_x*>(calloc(1, sizeof(appcontrol_x)));
615 LOG(ERROR) << "Out of memory";
618 app_control->operation = strdup(control.operation().c_str());
619 app_control->mime = strdup(control.mime().c_str());
620 app_control->uri = strdup(control.uri().c_str());
621 app->appcontrol = g_list_append(app->appcontrol, app_control);
627 bool StepParse::FillPrivileges(manifest_x* manifest) {
629 GetManifestDataForKey<const wgt::parse::PermissionsInfo>(
630 app_keys::kTizenPermissionsKey);
631 std::set<std::string> privileges;
633 privileges = ExtractPrivileges(perm_info);
635 for (auto& priv : privileges) {
636 privilege_x* privilege =
637 reinterpret_cast<privilege_x*>(calloc(1, sizeof(privilege_x)));
639 LOG(ERROR) << "Out of memory";
642 privilege->type = strdup(common_installer::kWebPrivilegeType);
643 privilege->value = strdup(priv.c_str());
644 manifest->privileges = g_list_append(manifest->privileges, privilege);
649 bool StepParse::FillAppDefinedPrivileges(manifest_x* manifest) {
650 auto priv_info_list =
651 GetManifestDataForKey<const wgt::parse::AppDefinedPrivilegeInfoList>(
652 app_keys::kTizenAppDefinedPrivilegeKey);
656 for (auto& priv : priv_info_list->appdefined_privileges) {
657 appdefined_privilege_x* privilege =
658 reinterpret_cast<appdefined_privilege_x*>(calloc(1,
659 sizeof(appdefined_privilege_x)));
660 if (privilege == nullptr) {
661 LOG(ERROR) << "Memory alloc failure";
664 privilege->value = strdup(priv.name().c_str());
665 privilege->type = strdup(common_installer::kWebPrivilegeType);
666 if (!priv.license().empty()) {
667 if (bf::path(priv.license()).is_absolute())
668 privilege->license = strdup(priv.license().c_str());
670 privilege->license = strdup((context_->root_application_path.get()
671 / manifest->package / priv.license()).c_str());
673 manifest->appdefined_privileges =
674 g_list_append(manifest->appdefined_privileges, privilege);
679 bool StepParse::FillProvidesAppDefinedPrivileges(manifest_x* manifest) {
680 auto priv_info_list =
681 GetManifestDataForKey<const wgt::parse::AppDefinedPrivilegeInfoList>(
682 app_keys::kTizenProvidesAppDefinedPrivilegeKey);
686 for (auto& priv : priv_info_list->appdefined_privileges) {
687 appdefined_privilege_x* privilege =
688 reinterpret_cast<appdefined_privilege_x*>(calloc(1,
689 sizeof(appdefined_privilege_x)));
690 if (privilege == nullptr) {
691 LOG(ERROR) << "Memory alloc failure";
694 privilege->value = strdup(priv.name().c_str());
695 privilege->type = strdup(common_installer::kWebPrivilegeType);
696 if (!priv.license().empty()) {
697 if (bf::path(priv.license()).is_absolute())
698 privilege->license = strdup(priv.license().c_str());
700 privilege->license = strdup((context_->root_application_path.get()
701 / manifest->package / priv.license()).c_str());
703 manifest->provides_appdefined_privileges =
704 g_list_append(manifest->provides_appdefined_privileges, privilege);
709 bool StepParse::FillCategories(manifest_x* manifest) {
711 GetManifestDataForKey<const wgt::parse::CategoryInfoList>(
712 app_keys::kTizenCategoryKey);
717 reinterpret_cast<application_x*>(manifest->application->data);
718 // there is one app atm
719 for (auto& category : category_info->categories) {
720 app->category = g_list_append(app->category, strdup(category.c_str()));
725 bool StepParse::FillMetadata(manifest_x* manifest) {
727 GetManifestDataForKey<const wgt::parse::MetaDataInfo>(
728 app_keys::kTizenMetaDataKey);
732 for (application_x* app : GListRange<application_x*>(manifest->application)) {
733 app->metadata = GenerateMetadataListX(*meta_info);
738 bool StepParse::FillAppWidget() {
739 // This is needed to store preview icons which are not saved into manifest_x
740 WgtBackendData* backend_data =
741 static_cast<WgtBackendData*>(context_->backend_data.get());
743 auto appwidget_info =
744 GetManifestDataForKey<const wgt::parse::AppWidgetInfo>(
745 wgt::application_widget_keys::kTizenAppWidgetFullKey);
747 backend_data->appwidgets.set(*appwidget_info);
751 bool StepParse::FillAccounts(manifest_x* manifest) {
753 GetManifestDataForKey<const wgt::parse::AccountInfo>(
754 app_keys::kAccountKey);
757 common_installer::AccountInfo info;
758 for (auto& account : account_info->accounts()) {
759 common_installer::SingleAccountInfo single_info;
760 single_info.capabilities = account.capabilities;
761 single_info.icon_paths = account.icon_paths;
762 single_info.multiple_account_support = account.multiple_account_support;
763 single_info.names = account.names;
764 // wgt can contain only one app so this assumes mainapp_id is valid here
765 single_info.appid = manifest->mainapp_id;
766 info.set_account(single_info);
768 context_->manifest_plugins_data.get().account_info.set(info);
772 bool StepParse::FillImeInfo() {
774 GetManifestDataForKey<const wgt::parse::ImeInfo>(
775 app_keys::kTizenImeKey);
779 common_installer::ImeInfo info;
780 info.setUuid(ime_info->uuid());
782 const auto &languages = ime_info->languages();
783 for (const auto &language : languages)
784 info.AddLanguage(language);
786 context_->manifest_plugins_data.get().ime_info.set(std::move(info));
790 bool StepParse::FillExtraManifestInfo(manifest_x* manifest) {
791 return FillAccounts(manifest) && FillImeInfo() && FillAppWidget();
794 bool StepParse::FillManifestX(manifest_x* manifest) {
795 // Fill data for main application
796 if (!FillIconPaths(manifest))
798 if (!FillMainApplicationInfo(manifest))
800 if (!FillWidgetInfo(manifest))
802 if (!FillInstallationInfo(manifest))
804 if (!FillPrivileges(manifest))
806 if (!FillAppDefinedPrivileges(manifest))
808 if (!FillProvidesAppDefinedPrivileges(manifest))
810 if (!FillAppControl(manifest))
812 if (!FillCategories(manifest))
814 if (!FillMetadata(manifest))
816 if (!FillBackgroundCategoryInfo(manifest))
818 if (!FillTrustAnchorInfo(manifest))
821 // Fill data for other applications
822 if (!FillAdditionalApplications(manifest))
825 // Fill extra data, other than manifest_x structure
826 if (!FillExtraManifestInfo(manifest))
833 bool StepParse::FillAdditionalApplications(manifest_x* manifest) {
834 if (!FillServiceApplicationInfo(manifest))
836 if (!FillWidgetApplicationInfo(manifest))
841 bool StepParse::LocateConfigFile() {
842 switch (config_location_) {
843 case ConfigLocation::PACKAGE:
844 return StepParse::Check(context_->unpacked_dir_path.get());
845 case ConfigLocation::INSTALLED:
846 return StepParse::Check(context_->pkg_path.get() / kResWgt);
847 case ConfigLocation::RECOVERY:
848 if (StepParse::Check(common_installer::GetBackupPathForPackagePath(
849 context_->root_application_path.get()
850 / context_->pkgid.get()) / kResWgt))
852 if (StepParse::Check(
853 context_->root_application_path.get()
854 / context_->pkgid.get() / kResWgt))
857 case ConfigLocation::RESOURCE_WGT:
858 return StepParse::Check(context_->unpacked_dir_path.get() / kResWgt);
860 LOG(ERROR) << "Unknown config location";
865 common_installer::Step::Status StepParse::process() {
866 if (!LocateConfigFile()) {
867 LOG(ERROR) << "No config.xml";
868 return common_installer::Step::Status::MANIFEST_NOT_FOUND;
871 parser_.reset(new(std::nothrow) wgt::parse::WidgetConfigParser());
873 LOG(ERROR) << "Out of memory";
874 return common_installer::Step::Status::CONFIG_ERROR;
876 if (!parser_->ParseManifest(widget_path_ / kConfigFileName)) {
877 LOG(ERROR) << "[Parse] Parse failed. " << parser_->GetErrorMessage();
878 return common_installer::Step::Status::PARSE_ERROR;
881 WgtBackendData* backend_data =
882 static_cast<WgtBackendData*>(context_->backend_data.get());
884 if (check_start_file_) {
885 if (!parser_->CheckValidStartFile()) {
886 LOG(ERROR) << parser_->GetErrorMessage();
887 return common_installer::Step::Status::PARSE_ERROR;
889 if (!parser_->CheckValidServicesStartFiles()) {
890 LOG(ERROR) << parser_->GetErrorMessage();
891 return common_installer::Step::Status::PARSE_ERROR;
894 // making backup of content data and services content data
896 GetManifestDataForKey<const wgt::parse::ContentInfo>(
897 wgt::application_widget_keys::kTizenContentKey);
899 GetManifestDataForKey<const wgt::parse::ServiceList>(
900 wgt::application_widget_keys::kTizenServiceKey);
902 backend_data->content.set(*content_info);
904 backend_data->service_list.set(*service_list);
907 // Copy data from ManifestData to InstallerContext
909 GetManifestDataForKey<const wgt::parse::TizenApplicationInfo>(
910 wgt::application_widget_keys::kTizenApplicationKey);
912 GetManifestDataForKey<const wgt::parse::WidgetInfo>(
913 wgt::application_widget_keys::kTizenWidgetKey);
916 const auto& name_set = wgt_info->name_set();
917 if (name_set.find("") != name_set.end())
918 name = name_set.find("")->second;
919 if (name_set.begin() != name_set.end())
920 name = name_set.begin()->second;
922 std::string short_name;
923 const auto& short_name_set = wgt_info->short_name_set();
924 if (short_name_set.find("") != short_name_set.end())
925 short_name = short_name_set.find("")->second;
926 if (short_name_set.begin() != short_name_set.end())
927 short_name = short_name_set.begin()->second;
929 const std::string& package_version = wgt_info->version();
930 const std::string& required_api_version = info->required_version();
932 manifest_x* manifest =
933 static_cast<manifest_x*>(calloc(1, sizeof(manifest_x)));
935 LOG(ERROR) << "Out of memory";
936 return common_installer::Step::Status::ERROR;
938 manifest->api_version = strdup(required_api_version.c_str());
940 if (!FillManifestX(manifest)) {
941 LOG(ERROR) << "[Parse] Storing manifest_x failed. "
942 << parser_->GetErrorMessage();
943 return common_installer::Step::Status::PARSE_ERROR;
946 context_->pkgid.set(manifest->package);
948 // write pkgid for recovery file
949 if (context_->recovery_info.get().recovery_file) {
950 context_->recovery_info.get().recovery_file->set_pkgid(manifest->package);
951 context_->recovery_info.get().recovery_file->WriteAndCommitFileContent();
955 GetManifestDataForKey<const wgt::parse::PermissionsInfo>(
956 wgt::application_widget_keys::kTizenPermissionsKey);
957 parser::PermissionSet permissions;
959 permissions = perm_info->GetAPIPermissions();
962 GetManifestDataForKey<const wgt::parse::SettingInfo>(
963 wgt::application_widget_keys::kTizenSettingKey);
965 backend_data->settings.set(*settings_info);
967 LOG(DEBUG) << " Read data -[ ";
968 LOG(DEBUG) << "App id: " << info->id();
969 LOG(DEBUG) << " package = " << info->package();
970 LOG(DEBUG) << " id = " << info->id();
971 LOG(DEBUG) << " name = " << name;
972 LOG(DEBUG) << " short_name = " << short_name;
973 LOG(DEBUG) << " aplication version = " << package_version;
974 LOG(DEBUG) << " api_version = " << info->required_version();
975 LOG(DEBUG) << " launch_mode = " << info->launch_mode();
976 LOG(DEBUG) << " privileges -[";
977 for (const auto& p : permissions) {
978 LOG(DEBUG) << " " << p;
983 if (context_->manifest_data.get())
984 pkgmgr_parser_free_manifest_xml(context_->manifest_data.get());
986 context_->manifest_data.set(manifest);
987 return common_installer::Step::Status::OK;
990 bool StepParse::Check(const boost::filesystem::path& widget_path) {
991 LOG(DEBUG) << "unpacked widget path: " << widget_path;
993 widget_path_ = widget_path;
995 boost::filesystem::path config = widget_path / kConfigFileName;
996 LOG(DEBUG) << "config.xml path: " << config;
997 if (!boost::filesystem::exists(config))
1002 } // namespace configuration