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";
493 pkgmgrinfo_basic_free_application(application);
496 item->key = strdup(pair.first.c_str());
497 if (!pair.second.empty())
498 item->value = strdup(pair.second.c_str());
499 application->metadata = g_list_append(application->metadata, item);
502 manifest->application = g_list_append(manifest->application, application);
507 bool StepParse::FillWidgetApplicationInfo(manifest_x* manifest) {
508 auto appwidget_info =
509 GetManifestDataForKey<const wgt::parse::AppWidgetInfo>(
510 wgt::application_widget_keys::kTizenAppWidgetFullKey);
515 GetManifestDataForKey<const wgt::parse::SettingInfo>(
516 wgt::application_widget_keys::kTizenSettingKey);
517 bool no_display = settings_info ? settings_info->no_display() : false;
519 for (auto& app_widget : appwidget_info->app_widgets()) {
520 application_x* application = reinterpret_cast<application_x*>
521 (calloc(1, sizeof(application_x)));
523 LOG(ERROR) << "Out of memory";
526 application->component_type = strdup("widgetapp");
527 application->mainapp = strdup("false");
528 application->appid = strdup(app_widget.id.c_str());
530 strdup((context_->root_application_path.get() / manifest->package
531 / "bin" / application->appid).c_str());
532 application->type = strdup("webapp");
533 application->nodisplay = no_display ? strdup("true") : strdup("false");
534 application->taskmanage = strdup("false");
535 SetApplicationXDefaults(application);
536 application->support_ambient = strdup("false");
537 application->package = strdup(manifest->package);
538 application->api_version = strdup(manifest->api_version);
539 if (!app_widget.label.default_value.empty()) {
540 AppendLabel(application, app_widget.label.default_value, std::string());
543 for (auto& pair : app_widget.label.lang_value_map) {
544 AppendLabel(application, pair.second, pair.first);
547 if (!app_widget.icon_src.empty()) {
548 icon_x* icon = reinterpret_cast<icon_x*>(calloc(1, sizeof(icon_x)));
550 LOG(ERROR) << "Out of memory";
551 pkgmgrinfo_basic_free_application(application);
554 icon->text = strdup(app_widget.icon_src.c_str());
555 icon->lang = strdup(DEFAULT_LOCALE);
556 application->icon = g_list_append(application->icon, icon);
559 if (!app_widget.metadata.empty())
560 AppendWidgetMetadata(&application->metadata, app_widget.metadata);
562 manifest->application = g_list_append(manifest->application, application);
568 bool StepParse::FillBackgroundCategoryInfo(manifest_x* manifest) {
569 auto manifest_data = parser_->GetManifestData(
570 app_keys::kTizenBackgroundCategoryKey);
571 std::shared_ptr<const wgt::parse::BackgroundCategoryInfoList> bc_list =
572 std::static_pointer_cast<const wgt::parse::BackgroundCategoryInfoList>(
579 reinterpret_cast<application_x*>(manifest->application->data);
581 for (auto& background_category : bc_list->background_categories) {
582 app->background_category = g_list_append(
583 app->background_category, strdup(background_category.value().c_str()));
589 bool StepParse::FillTrustAnchorInfo(manifest_x* manifest) {
590 auto trust_anchor_info = parser_->GetManifestData(
591 app_keys::kTizenTrustAnchorKey);
593 if (!trust_anchor_info)
596 std::shared_ptr<const parse::TrustAnchorInfo> trust_anchor =
597 std::static_pointer_cast<const parse::TrustAnchorInfo>
603 std::string use_system_certs = trust_anchor->get_use_system_certs();
604 if (!use_system_certs.empty())
605 manifest->use_system_certs = strdup(use_system_certs.c_str());
610 bool StepParse::FillAppControl(manifest_x* manifest) {
612 GetManifestDataForKey<const wgt::parse::AppControlInfoList>(
613 app_keys::kTizenApplicationAppControlsKey);
616 reinterpret_cast<application_x*>(manifest->application->data);
618 for (const auto& control : app_info_list->controls) {
619 appcontrol_x* app_control =
620 static_cast<appcontrol_x*>(calloc(1, sizeof(appcontrol_x)));
622 LOG(ERROR) << "Out of memory";
625 app_control->operation = strdup(control.operation().c_str());
626 app_control->mime = strdup(control.mime().c_str());
627 app_control->uri = strdup(control.uri().c_str());
628 app_control->visibility = strdup("local-only");
629 app->appcontrol = g_list_append(app->appcontrol, app_control);
635 bool StepParse::FillPrivileges(manifest_x* manifest) {
637 GetManifestDataForKey<const wgt::parse::PermissionsInfo>(
638 app_keys::kTizenPermissionsKey);
639 std::set<std::string> privileges;
641 privileges = ExtractPrivileges(perm_info);
643 for (auto& priv : privileges) {
644 privilege_x* privilege =
645 reinterpret_cast<privilege_x*>(calloc(1, sizeof(privilege_x)));
647 LOG(ERROR) << "Out of memory";
650 privilege->type = strdup(common_installer::kWebPrivilegeType);
651 privilege->value = strdup(priv.c_str());
652 manifest->privileges = g_list_append(manifest->privileges, privilege);
657 bool StepParse::FillAppDefinedPrivileges(manifest_x* manifest) {
658 auto priv_info_list =
659 GetManifestDataForKey<const wgt::parse::AppDefinedPrivilegeInfoList>(
660 app_keys::kTizenAppDefinedPrivilegeKey);
664 for (auto& priv : priv_info_list->appdefined_privileges) {
665 appdefined_privilege_x* privilege =
666 reinterpret_cast<appdefined_privilege_x*>(calloc(1,
667 sizeof(appdefined_privilege_x)));
668 if (privilege == nullptr) {
669 LOG(ERROR) << "Memory alloc failure";
672 privilege->value = strdup(priv.name().c_str());
673 privilege->type = strdup(common_installer::kWebPrivilegeType);
674 if (!priv.license().empty()) {
675 if (bf::path(priv.license()).is_absolute())
676 privilege->license = strdup(priv.license().c_str());
678 privilege->license = strdup((context_->root_application_path.get()
679 / manifest->package / priv.license()).c_str());
681 manifest->appdefined_privileges =
682 g_list_append(manifest->appdefined_privileges, privilege);
687 bool StepParse::FillProvidesAppDefinedPrivileges(manifest_x* manifest) {
688 auto priv_info_list =
689 GetManifestDataForKey<const wgt::parse::AppDefinedPrivilegeInfoList>(
690 app_keys::kTizenProvidesAppDefinedPrivilegeKey);
694 for (auto& priv : priv_info_list->appdefined_privileges) {
695 appdefined_privilege_x* privilege =
696 reinterpret_cast<appdefined_privilege_x*>(calloc(1,
697 sizeof(appdefined_privilege_x)));
698 if (privilege == nullptr) {
699 LOG(ERROR) << "Memory alloc failure";
702 privilege->value = strdup(priv.name().c_str());
703 privilege->type = strdup(common_installer::kWebPrivilegeType);
704 if (!priv.license().empty()) {
705 if (bf::path(priv.license()).is_absolute())
706 privilege->license = strdup(priv.license().c_str());
708 privilege->license = strdup((context_->root_application_path.get()
709 / manifest->package / priv.license()).c_str());
711 manifest->provides_appdefined_privileges =
712 g_list_append(manifest->provides_appdefined_privileges, privilege);
717 bool StepParse::FillCategories(manifest_x* manifest) {
719 GetManifestDataForKey<const wgt::parse::CategoryInfoList>(
720 app_keys::kTizenCategoryKey);
725 reinterpret_cast<application_x*>(manifest->application->data);
726 // there is one app atm
727 for (auto& category : category_info->categories) {
728 app->category = g_list_append(app->category, strdup(category.c_str()));
733 bool StepParse::FillMetadata(manifest_x* manifest) {
735 GetManifestDataForKey<const wgt::parse::MetaDataInfo>(
736 app_keys::kTizenMetaDataKey);
740 for (application_x* app : GListRange<application_x*>(manifest->application)) {
741 app->metadata = GenerateMetadataListX(*meta_info);
746 bool StepParse::FillAppWidget() {
747 // This is needed to store preview icons which are not saved into manifest_x
748 WgtBackendData* backend_data =
749 static_cast<WgtBackendData*>(context_->backend_data.get());
751 auto appwidget_info =
752 GetManifestDataForKey<const wgt::parse::AppWidgetInfo>(
753 wgt::application_widget_keys::kTizenAppWidgetFullKey);
755 backend_data->appwidgets.set(*appwidget_info);
759 bool StepParse::FillAccounts(manifest_x* manifest) {
761 GetManifestDataForKey<const wgt::parse::AccountInfo>(
762 app_keys::kAccountKey);
765 common_installer::AccountInfo info;
766 for (auto& account : account_info->accounts()) {
767 common_installer::SingleAccountInfo single_info;
768 single_info.capabilities = account.capabilities;
769 single_info.icon_paths = account.icon_paths;
770 single_info.multiple_account_support = account.multiple_account_support;
771 single_info.names = account.names;
772 // wgt can contain only one app so this assumes mainapp_id is valid here
773 single_info.appid = manifest->mainapp_id;
774 info.set_account(single_info);
776 context_->manifest_plugins_data.get().account_info.set(info);
780 bool StepParse::FillImeInfo() {
782 GetManifestDataForKey<const wgt::parse::ImeInfo>(
783 app_keys::kTizenImeKey);
787 common_installer::ImeInfo info;
788 info.setUuid(ime_info->uuid());
790 const auto &languages = ime_info->languages();
791 for (const auto &language : languages)
792 info.AddLanguage(language);
794 context_->manifest_plugins_data.get().ime_info.set(std::move(info));
798 bool StepParse::FillExtraManifestInfo(manifest_x* manifest) {
799 return FillAccounts(manifest) && FillImeInfo() && FillAppWidget();
802 bool StepParse::FillManifestX(manifest_x* manifest) {
803 // Fill data for main application
804 if (!FillIconPaths(manifest))
806 if (!FillMainApplicationInfo(manifest))
808 if (!FillWidgetInfo(manifest))
810 if (!FillInstallationInfo(manifest))
812 if (!FillPrivileges(manifest))
814 if (!FillAppDefinedPrivileges(manifest))
816 if (!FillProvidesAppDefinedPrivileges(manifest))
818 if (!FillAppControl(manifest))
820 if (!FillCategories(manifest))
822 if (!FillMetadata(manifest))
824 if (!FillBackgroundCategoryInfo(manifest))
826 if (!FillTrustAnchorInfo(manifest))
829 // Fill data for other applications
830 if (!FillAdditionalApplications(manifest))
833 // Fill extra data, other than manifest_x structure
834 if (!FillExtraManifestInfo(manifest))
841 bool StepParse::FillAdditionalApplications(manifest_x* manifest) {
842 if (!FillServiceApplicationInfo(manifest))
844 if (!FillWidgetApplicationInfo(manifest))
849 bool StepParse::LocateConfigFile() {
850 switch (config_location_) {
851 case ConfigLocation::PACKAGE:
852 return StepParse::Check(context_->unpacked_dir_path.get());
853 case ConfigLocation::INSTALLED:
854 return StepParse::Check(context_->GetPkgPath() / kResWgt);
855 case ConfigLocation::RECOVERY:
856 if (StepParse::Check(common_installer::GetBackupPathForPackagePath(
857 context_->GetPkgPath()) / kResWgt))
859 if (StepParse::Check(context_->GetPkgPath() / kResWgt))
862 case ConfigLocation::RESOURCE_WGT:
863 return StepParse::Check(context_->unpacked_dir_path.get() / kResWgt);
865 LOG(ERROR) << "Unknown config location";
870 common_installer::Step::Status StepParse::process() {
871 if (!LocateConfigFile()) {
872 LOG(ERROR) << "No config.xml";
873 return common_installer::Step::Status::MANIFEST_NOT_FOUND;
876 parser_.reset(new(std::nothrow) wgt::parse::WidgetConfigParser());
878 LOG(ERROR) << "Out of memory";
879 return common_installer::Step::Status::CONFIG_ERROR;
881 if (!parser_->ParseManifest(widget_path_ / kConfigFileName)) {
882 LOG(ERROR) << "[Parse] Parse failed. " << parser_->GetErrorMessage();
883 return common_installer::Step::Status::PARSE_ERROR;
886 WgtBackendData* backend_data =
887 static_cast<WgtBackendData*>(context_->backend_data.get());
889 if (check_start_file_) {
890 if (!parser_->CheckValidStartFile()) {
891 LOG(ERROR) << parser_->GetErrorMessage();
892 return common_installer::Step::Status::PARSE_ERROR;
894 if (!parser_->CheckValidServicesStartFiles()) {
895 LOG(ERROR) << parser_->GetErrorMessage();
896 return common_installer::Step::Status::PARSE_ERROR;
899 // making backup of content data and services content data
901 GetManifestDataForKey<const wgt::parse::ContentInfo>(
902 wgt::application_widget_keys::kTizenContentKey);
904 GetManifestDataForKey<const wgt::parse::ServiceList>(
905 wgt::application_widget_keys::kTizenServiceKey);
907 backend_data->content.set(*content_info);
909 backend_data->service_list.set(*service_list);
912 // Copy data from ManifestData to InstallerContext
914 GetManifestDataForKey<const wgt::parse::TizenApplicationInfo>(
915 wgt::application_widget_keys::kTizenApplicationKey);
917 GetManifestDataForKey<const wgt::parse::WidgetInfo>(
918 wgt::application_widget_keys::kTizenWidgetKey);
921 const auto& name_set = wgt_info->name_set();
922 if (name_set.find("") != name_set.end())
923 name = name_set.find("")->second;
924 if (name_set.begin() != name_set.end())
925 name = name_set.begin()->second;
927 std::string short_name;
928 const auto& short_name_set = wgt_info->short_name_set();
929 if (short_name_set.find("") != short_name_set.end())
930 short_name = short_name_set.find("")->second;
931 if (short_name_set.begin() != short_name_set.end())
932 short_name = short_name_set.begin()->second;
934 const std::string& package_version = wgt_info->version();
935 const std::string& required_api_version = info->required_version();
937 manifest_x* manifest =
938 static_cast<manifest_x*>(calloc(1, sizeof(manifest_x)));
940 LOG(ERROR) << "Out of memory";
941 return common_installer::Step::Status::ERROR;
943 manifest->api_version = strdup(required_api_version.c_str());
945 if (!FillManifestX(manifest)) {
946 LOG(ERROR) << "[Parse] Storing manifest_x failed. "
947 << parser_->GetErrorMessage();
948 pkgmgr_parser_free_manifest_xml(manifest);
949 return common_installer::Step::Status::PARSE_ERROR;
952 context_->pkgid.set(manifest->package);
954 // write pkgid for recovery file
955 if (context_->recovery_info.get().recovery_file) {
956 context_->recovery_info.get().recovery_file->set_pkgid(manifest->package);
957 context_->recovery_info.get().recovery_file->WriteAndCommitFileContent();
961 GetManifestDataForKey<const wgt::parse::PermissionsInfo>(
962 wgt::application_widget_keys::kTizenPermissionsKey);
963 parser::PermissionSet permissions;
965 permissions = perm_info->GetAPIPermissions();
968 GetManifestDataForKey<const wgt::parse::SettingInfo>(
969 wgt::application_widget_keys::kTizenSettingKey);
971 backend_data->settings.set(*settings_info);
973 LOG(DEBUG) << " Read data -[ ";
974 LOG(DEBUG) << "App id: " << info->id();
975 LOG(DEBUG) << " package = " << info->package();
976 LOG(DEBUG) << " id = " << info->id();
977 LOG(DEBUG) << " name = " << name;
978 LOG(DEBUG) << " short_name = " << short_name;
979 LOG(DEBUG) << " aplication version = " << package_version;
980 LOG(DEBUG) << " api_version = " << info->required_version();
981 LOG(DEBUG) << " launch_mode = " << info->launch_mode();
982 LOG(DEBUG) << " privileges -[";
983 for (const auto& p : permissions) {
984 LOG(DEBUG) << " " << p;
989 if (context_->manifest_data.get())
990 pkgmgr_parser_free_manifest_xml(context_->manifest_data.get());
992 context_->manifest_data.set(manifest);
993 return common_installer::Step::Status::OK;
996 bool StepParse::Check(const boost::filesystem::path& widget_path) {
997 LOG(DEBUG) << "unpacked widget path: " << widget_path;
999 widget_path_ = widget_path;
1001 boost::filesystem::path config = widget_path / kConfigFileName;
1002 LOG(DEBUG) << "config.xml path: " << config;
1003 if (!boost::filesystem::exists(config))
1008 } // namespace configuration