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 use_system_certs = trust_anchor->get_use_system_certs();
596 if (!use_system_certs.empty())
597 manifest->use_system_certs = strdup(use_system_certs.c_str());
602 bool StepParse::FillAppControl(manifest_x* manifest) {
604 GetManifestDataForKey<const wgt::parse::AppControlInfoList>(
605 app_keys::kTizenApplicationAppControlsKey);
608 reinterpret_cast<application_x*>(manifest->application->data);
610 for (const auto& control : app_info_list->controls) {
611 appcontrol_x* app_control =
612 static_cast<appcontrol_x*>(calloc(1, sizeof(appcontrol_x)));
614 LOG(ERROR) << "Out of memory";
617 app_control->operation = strdup(control.operation().c_str());
618 app_control->mime = strdup(control.mime().c_str());
619 app_control->uri = strdup(control.uri().c_str());
620 app->appcontrol = g_list_append(app->appcontrol, app_control);
626 bool StepParse::FillPrivileges(manifest_x* manifest) {
628 GetManifestDataForKey<const wgt::parse::PermissionsInfo>(
629 app_keys::kTizenPermissionsKey);
630 std::set<std::string> privileges;
632 privileges = ExtractPrivileges(perm_info);
634 for (auto& priv : privileges) {
635 privilege_x* privilege =
636 reinterpret_cast<privilege_x*>(calloc(1, sizeof(privilege_x)));
638 LOG(ERROR) << "Out of memory";
641 privilege->type = strdup(common_installer::kWebPrivilegeType);
642 privilege->value = strdup(priv.c_str());
643 manifest->privileges = g_list_append(manifest->privileges, privilege);
648 bool StepParse::FillAppDefinedPrivileges(manifest_x* manifest) {
649 auto priv_info_list =
650 GetManifestDataForKey<const wgt::parse::AppDefinedPrivilegeInfoList>(
651 app_keys::kTizenAppDefinedPrivilegeKey);
655 for (auto& priv : priv_info_list->appdefined_privileges) {
656 appdefined_privilege_x* privilege =
657 reinterpret_cast<appdefined_privilege_x*>(calloc(1,
658 sizeof(appdefined_privilege_x)));
659 if (privilege == nullptr) {
660 LOG(ERROR) << "Memory alloc failure";
663 privilege->value = strdup(priv.name().c_str());
664 privilege->type = strdup(common_installer::kWebPrivilegeType);
665 if (!priv.license().empty()) {
666 if (bf::path(priv.license()).is_absolute())
667 privilege->license = strdup(priv.license().c_str());
669 privilege->license = strdup((context_->root_application_path.get()
670 / manifest->package / priv.license()).c_str());
672 manifest->appdefined_privileges =
673 g_list_append(manifest->appdefined_privileges, privilege);
678 bool StepParse::FillProvidesAppDefinedPrivileges(manifest_x* manifest) {
679 auto priv_info_list =
680 GetManifestDataForKey<const wgt::parse::AppDefinedPrivilegeInfoList>(
681 app_keys::kTizenProvidesAppDefinedPrivilegeKey);
685 for (auto& priv : priv_info_list->appdefined_privileges) {
686 appdefined_privilege_x* privilege =
687 reinterpret_cast<appdefined_privilege_x*>(calloc(1,
688 sizeof(appdefined_privilege_x)));
689 if (privilege == nullptr) {
690 LOG(ERROR) << "Memory alloc failure";
693 privilege->value = strdup(priv.name().c_str());
694 privilege->type = strdup(common_installer::kWebPrivilegeType);
695 if (!priv.license().empty()) {
696 if (bf::path(priv.license()).is_absolute())
697 privilege->license = strdup(priv.license().c_str());
699 privilege->license = strdup((context_->root_application_path.get()
700 / manifest->package / priv.license()).c_str());
702 manifest->provides_appdefined_privileges =
703 g_list_append(manifest->provides_appdefined_privileges, privilege);
708 bool StepParse::FillCategories(manifest_x* manifest) {
710 GetManifestDataForKey<const wgt::parse::CategoryInfoList>(
711 app_keys::kTizenCategoryKey);
716 reinterpret_cast<application_x*>(manifest->application->data);
717 // there is one app atm
718 for (auto& category : category_info->categories) {
719 app->category = g_list_append(app->category, strdup(category.c_str()));
724 bool StepParse::FillMetadata(manifest_x* manifest) {
726 GetManifestDataForKey<const wgt::parse::MetaDataInfo>(
727 app_keys::kTizenMetaDataKey);
731 for (application_x* app : GListRange<application_x*>(manifest->application)) {
732 app->metadata = GenerateMetadataListX(*meta_info);
737 bool StepParse::FillAppWidget() {
738 // This is needed to store preview icons which are not saved into manifest_x
739 WgtBackendData* backend_data =
740 static_cast<WgtBackendData*>(context_->backend_data.get());
742 auto appwidget_info =
743 GetManifestDataForKey<const wgt::parse::AppWidgetInfo>(
744 wgt::application_widget_keys::kTizenAppWidgetFullKey);
746 backend_data->appwidgets.set(*appwidget_info);
750 bool StepParse::FillAccounts(manifest_x* manifest) {
752 GetManifestDataForKey<const wgt::parse::AccountInfo>(
753 app_keys::kAccountKey);
756 common_installer::AccountInfo info;
757 for (auto& account : account_info->accounts()) {
758 common_installer::SingleAccountInfo single_info;
759 single_info.capabilities = account.capabilities;
760 single_info.icon_paths = account.icon_paths;
761 single_info.multiple_account_support = account.multiple_account_support;
762 single_info.names = account.names;
763 // wgt can contain only one app so this assumes mainapp_id is valid here
764 single_info.appid = manifest->mainapp_id;
765 info.set_account(single_info);
767 context_->manifest_plugins_data.get().account_info.set(info);
771 bool StepParse::FillImeInfo() {
773 GetManifestDataForKey<const wgt::parse::ImeInfo>(
774 app_keys::kTizenImeKey);
778 common_installer::ImeInfo info;
779 info.setUuid(ime_info->uuid());
781 const auto &languages = ime_info->languages();
782 for (const auto &language : languages)
783 info.AddLanguage(language);
785 context_->manifest_plugins_data.get().ime_info.set(std::move(info));
789 bool StepParse::FillExtraManifestInfo(manifest_x* manifest) {
790 return FillAccounts(manifest) && FillImeInfo() && FillAppWidget();
793 bool StepParse::FillManifestX(manifest_x* manifest) {
794 // Fill data for main application
795 if (!FillIconPaths(manifest))
797 if (!FillMainApplicationInfo(manifest))
799 if (!FillWidgetInfo(manifest))
801 if (!FillInstallationInfo(manifest))
803 if (!FillPrivileges(manifest))
805 if (!FillAppDefinedPrivileges(manifest))
807 if (!FillProvidesAppDefinedPrivileges(manifest))
809 if (!FillAppControl(manifest))
811 if (!FillCategories(manifest))
813 if (!FillMetadata(manifest))
815 if (!FillBackgroundCategoryInfo(manifest))
817 if (!FillTrustAnchorInfo(manifest))
820 // Fill data for other applications
821 if (!FillAdditionalApplications(manifest))
824 // Fill extra data, other than manifest_x structure
825 if (!FillExtraManifestInfo(manifest))
832 bool StepParse::FillAdditionalApplications(manifest_x* manifest) {
833 if (!FillServiceApplicationInfo(manifest))
835 if (!FillWidgetApplicationInfo(manifest))
840 bool StepParse::LocateConfigFile() {
841 switch (config_location_) {
842 case ConfigLocation::PACKAGE:
843 return StepParse::Check(context_->unpacked_dir_path.get());
844 case ConfigLocation::INSTALLED:
845 return StepParse::Check(context_->pkg_path.get() / kResWgt);
846 case ConfigLocation::RECOVERY:
847 if (StepParse::Check(common_installer::GetBackupPathForPackagePath(
848 context_->root_application_path.get()
849 / context_->pkgid.get()) / kResWgt))
851 if (StepParse::Check(
852 context_->root_application_path.get()
853 / context_->pkgid.get() / kResWgt))
856 case ConfigLocation::RESOURCE_WGT:
857 return StepParse::Check(context_->unpacked_dir_path.get() / kResWgt);
859 LOG(ERROR) << "Unknown config location";
864 common_installer::Step::Status StepParse::process() {
865 if (!LocateConfigFile()) {
866 LOG(ERROR) << "No config.xml";
867 return common_installer::Step::Status::MANIFEST_NOT_FOUND;
870 parser_.reset(new(std::nothrow) wgt::parse::WidgetConfigParser());
872 LOG(ERROR) << "Out of memory";
873 return common_installer::Step::Status::CONFIG_ERROR;
875 if (!parser_->ParseManifest(widget_path_ / kConfigFileName)) {
876 LOG(ERROR) << "[Parse] Parse failed. " << parser_->GetErrorMessage();
877 return common_installer::Step::Status::PARSE_ERROR;
880 WgtBackendData* backend_data =
881 static_cast<WgtBackendData*>(context_->backend_data.get());
883 if (check_start_file_) {
884 if (!parser_->CheckValidStartFile()) {
885 LOG(ERROR) << parser_->GetErrorMessage();
886 return common_installer::Step::Status::PARSE_ERROR;
888 if (!parser_->CheckValidServicesStartFiles()) {
889 LOG(ERROR) << parser_->GetErrorMessage();
890 return common_installer::Step::Status::PARSE_ERROR;
893 // making backup of content data and services content data
895 GetManifestDataForKey<const wgt::parse::ContentInfo>(
896 wgt::application_widget_keys::kTizenContentKey);
898 GetManifestDataForKey<const wgt::parse::ServiceList>(
899 wgt::application_widget_keys::kTizenServiceKey);
901 backend_data->content.set(*content_info);
903 backend_data->service_list.set(*service_list);
906 manifest_x* manifest =
907 static_cast<manifest_x*>(calloc(1, sizeof(manifest_x)));
909 LOG(ERROR) << "Out of memory";
910 return common_installer::Step::Status::ERROR;
912 if (!FillManifestX(manifest)) {
913 LOG(ERROR) << "[Parse] Storing manifest_x failed. "
914 << parser_->GetErrorMessage();
915 return common_installer::Step::Status::PARSE_ERROR;
918 // Copy data from ManifestData to InstallerContext
920 GetManifestDataForKey<const wgt::parse::TizenApplicationInfo>(
921 wgt::application_widget_keys::kTizenApplicationKey);
923 GetManifestDataForKey<const wgt::parse::WidgetInfo>(
924 wgt::application_widget_keys::kTizenWidgetKey);
927 const auto& name_set = wgt_info->name_set();
928 if (name_set.find("") != name_set.end())
929 name = name_set.find("")->second;
930 if (name_set.begin() != name_set.end())
931 name = name_set.begin()->second;
933 std::string short_name;
934 const auto& short_name_set = wgt_info->short_name_set();
935 if (short_name_set.find("") != short_name_set.end())
936 short_name = short_name_set.find("")->second;
937 if (short_name_set.begin() != short_name_set.end())
938 short_name = short_name_set.begin()->second;
940 const std::string& package_version = wgt_info->version();
941 const std::string& required_api_version = info->required_version();
943 manifest->api_version = strdup(required_api_version.c_str());
945 context_->pkgid.set(manifest->package);
947 // write pkgid for recovery file
948 if (context_->recovery_info.get().recovery_file) {
949 context_->recovery_info.get().recovery_file->set_pkgid(manifest->package);
950 context_->recovery_info.get().recovery_file->WriteAndCommitFileContent();
954 GetManifestDataForKey<const wgt::parse::PermissionsInfo>(
955 wgt::application_widget_keys::kTizenPermissionsKey);
956 parser::PermissionSet permissions;
958 permissions = perm_info->GetAPIPermissions();
961 GetManifestDataForKey<const wgt::parse::SettingInfo>(
962 wgt::application_widget_keys::kTizenSettingKey);
964 backend_data->settings.set(*settings_info);
966 LOG(DEBUG) << " Read data -[ ";
967 LOG(DEBUG) << "App id: " << info->id();
968 LOG(DEBUG) << " package = " << info->package();
969 LOG(DEBUG) << " id = " << info->id();
970 LOG(DEBUG) << " name = " << name;
971 LOG(DEBUG) << " short_name = " << short_name;
972 LOG(DEBUG) << " aplication version = " << package_version;
973 LOG(DEBUG) << " api_version = " << info->required_version();
974 LOG(DEBUG) << " launch_mode = " << info->launch_mode();
975 LOG(DEBUG) << " privileges -[";
976 for (const auto& p : permissions) {
977 LOG(DEBUG) << " " << p;
982 if (context_->manifest_data.get())
983 pkgmgr_parser_free_manifest_xml(context_->manifest_data.get());
985 context_->manifest_data.set(manifest);
986 return common_installer::Step::Status::OK;
989 bool StepParse::Check(const boost::filesystem::path& widget_path) {
990 LOG(DEBUG) << "unpacked widget path: " << widget_path;
992 widget_path_ = widget_path;
994 boost::filesystem::path config = widget_path / kConfigFileName;
995 LOG(DEBUG) << "config.xml path: " << config;
996 if (!boost::filesystem::exists(config))
1001 } // namespace configuration