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_control->id = strdup("no-name-app-control");
630 app->appcontrol = g_list_append(app->appcontrol, app_control);
636 bool StepParse::FillPrivileges(manifest_x* manifest) {
638 GetManifestDataForKey<const wgt::parse::PermissionsInfo>(
639 app_keys::kTizenPermissionsKey);
640 std::set<std::string> privileges;
642 privileges = ExtractPrivileges(perm_info);
644 for (auto& priv : privileges) {
645 privilege_x* privilege =
646 reinterpret_cast<privilege_x*>(calloc(1, sizeof(privilege_x)));
648 LOG(ERROR) << "Out of memory";
651 privilege->type = strdup(common_installer::kWebPrivilegeType);
652 privilege->value = strdup(priv.c_str());
653 manifest->privileges = g_list_append(manifest->privileges, privilege);
658 bool StepParse::FillAppDefinedPrivileges(manifest_x* manifest) {
659 auto priv_info_list =
660 GetManifestDataForKey<const wgt::parse::AppDefinedPrivilegeInfoList>(
661 app_keys::kTizenAppDefinedPrivilegeKey);
665 for (auto& priv : priv_info_list->appdefined_privileges) {
666 appdefined_privilege_x* privilege =
667 reinterpret_cast<appdefined_privilege_x*>(calloc(1,
668 sizeof(appdefined_privilege_x)));
669 if (privilege == nullptr) {
670 LOG(ERROR) << "Memory alloc failure";
673 privilege->value = strdup(priv.name().c_str());
674 privilege->type = strdup(common_installer::kWebPrivilegeType);
675 if (!priv.license().empty()) {
676 if (bf::path(priv.license()).is_absolute())
677 privilege->license = strdup(priv.license().c_str());
679 privilege->license = strdup((context_->root_application_path.get()
680 / manifest->package / priv.license()).c_str());
682 manifest->appdefined_privileges =
683 g_list_append(manifest->appdefined_privileges, privilege);
688 bool StepParse::FillProvidesAppDefinedPrivileges(manifest_x* manifest) {
689 auto priv_info_list =
690 GetManifestDataForKey<const wgt::parse::AppDefinedPrivilegeInfoList>(
691 app_keys::kTizenProvidesAppDefinedPrivilegeKey);
695 for (auto& priv : priv_info_list->appdefined_privileges) {
696 appdefined_privilege_x* privilege =
697 reinterpret_cast<appdefined_privilege_x*>(calloc(1,
698 sizeof(appdefined_privilege_x)));
699 if (privilege == nullptr) {
700 LOG(ERROR) << "Memory alloc failure";
703 privilege->value = strdup(priv.name().c_str());
704 privilege->type = strdup(common_installer::kWebPrivilegeType);
705 if (!priv.license().empty()) {
706 if (bf::path(priv.license()).is_absolute())
707 privilege->license = strdup(priv.license().c_str());
709 privilege->license = strdup((context_->root_application_path.get()
710 / manifest->package / priv.license()).c_str());
712 manifest->provides_appdefined_privileges =
713 g_list_append(manifest->provides_appdefined_privileges, privilege);
718 bool StepParse::FillCategories(manifest_x* manifest) {
720 GetManifestDataForKey<const wgt::parse::CategoryInfoList>(
721 app_keys::kTizenCategoryKey);
726 reinterpret_cast<application_x*>(manifest->application->data);
727 // there is one app atm
728 for (auto& category : category_info->categories) {
729 app->category = g_list_append(app->category, strdup(category.c_str()));
734 bool StepParse::FillMetadata(manifest_x* manifest) {
736 GetManifestDataForKey<const wgt::parse::MetaDataInfo>(
737 app_keys::kTizenMetaDataKey);
741 for (application_x* app : GListRange<application_x*>(manifest->application)) {
742 app->metadata = GenerateMetadataListX(*meta_info);
747 bool StepParse::FillAppWidget() {
748 // This is needed to store preview icons which are not saved into manifest_x
749 WgtBackendData* backend_data =
750 static_cast<WgtBackendData*>(context_->backend_data.get());
752 auto appwidget_info =
753 GetManifestDataForKey<const wgt::parse::AppWidgetInfo>(
754 wgt::application_widget_keys::kTizenAppWidgetFullKey);
756 backend_data->appwidgets.set(*appwidget_info);
760 bool StepParse::FillAccounts(manifest_x* manifest) {
762 GetManifestDataForKey<const wgt::parse::AccountInfo>(
763 app_keys::kAccountKey);
766 common_installer::AccountInfo info;
767 for (auto& account : account_info->accounts()) {
768 common_installer::SingleAccountInfo single_info;
769 single_info.capabilities = account.capabilities;
770 single_info.icon_paths = account.icon_paths;
771 single_info.multiple_account_support = account.multiple_account_support;
772 single_info.names = account.names;
773 // wgt can contain only one app so this assumes mainapp_id is valid here
774 single_info.appid = manifest->mainapp_id;
775 info.set_account(single_info);
777 context_->manifest_plugins_data.get().account_info.set(info);
781 bool StepParse::FillImeInfo() {
783 GetManifestDataForKey<const wgt::parse::ImeInfo>(
784 app_keys::kTizenImeKey);
788 common_installer::ImeInfo info;
789 info.setUuid(ime_info->uuid());
791 const auto &languages = ime_info->languages();
792 for (const auto &language : languages)
793 info.AddLanguage(language);
795 context_->manifest_plugins_data.get().ime_info.set(std::move(info));
799 bool StepParse::FillExtraManifestInfo(manifest_x* manifest) {
800 return FillAccounts(manifest) && FillImeInfo() && FillAppWidget();
803 bool StepParse::FillManifestX(manifest_x* manifest) {
804 // Fill data for main application
805 if (!FillIconPaths(manifest))
807 if (!FillMainApplicationInfo(manifest))
809 if (!FillWidgetInfo(manifest))
811 if (!FillInstallationInfo(manifest))
813 if (!FillPrivileges(manifest))
815 if (!FillAppDefinedPrivileges(manifest))
817 if (!FillProvidesAppDefinedPrivileges(manifest))
819 if (!FillAppControl(manifest))
821 if (!FillCategories(manifest))
823 if (!FillMetadata(manifest))
825 if (!FillBackgroundCategoryInfo(manifest))
827 if (!FillTrustAnchorInfo(manifest))
830 // Fill data for other applications
831 if (!FillAdditionalApplications(manifest))
834 // Fill extra data, other than manifest_x structure
835 if (!FillExtraManifestInfo(manifest))
842 bool StepParse::FillAdditionalApplications(manifest_x* manifest) {
843 if (!FillServiceApplicationInfo(manifest))
845 if (!FillWidgetApplicationInfo(manifest))
850 bool StepParse::LocateConfigFile() {
851 switch (config_location_) {
852 case ConfigLocation::PACKAGE:
853 return StepParse::Check(context_->unpacked_dir_path.get());
854 case ConfigLocation::INSTALLED:
855 return StepParse::Check(context_->GetPkgPath() / kResWgt);
856 case ConfigLocation::RECOVERY:
857 if (StepParse::Check(common_installer::GetBackupPathForPackagePath(
858 context_->GetPkgPath()) / kResWgt))
860 if (StepParse::Check(context_->GetPkgPath() / kResWgt))
863 case ConfigLocation::RESOURCE_WGT:
864 return StepParse::Check(context_->unpacked_dir_path.get() / kResWgt);
866 LOG(ERROR) << "Unknown config location";
871 common_installer::Step::Status StepParse::process() {
872 if (!LocateConfigFile()) {
873 LOG(ERROR) << "No config.xml";
874 return common_installer::Step::Status::MANIFEST_NOT_FOUND;
877 parser_.reset(new(std::nothrow) wgt::parse::WidgetConfigParser());
879 LOG(ERROR) << "Out of memory";
880 return common_installer::Step::Status::CONFIG_ERROR;
882 if (!parser_->ParseManifest(widget_path_ / kConfigFileName)) {
883 LOG(ERROR) << "[Parse] Parse failed. " << parser_->GetErrorMessage();
884 return common_installer::Step::Status::PARSE_ERROR;
887 WgtBackendData* backend_data =
888 static_cast<WgtBackendData*>(context_->backend_data.get());
890 if (check_start_file_) {
891 if (!parser_->CheckValidStartFile()) {
892 LOG(ERROR) << parser_->GetErrorMessage();
893 return common_installer::Step::Status::PARSE_ERROR;
895 if (!parser_->CheckValidServicesStartFiles()) {
896 LOG(ERROR) << parser_->GetErrorMessage();
897 return common_installer::Step::Status::PARSE_ERROR;
900 // making backup of content data and services content data
902 GetManifestDataForKey<const wgt::parse::ContentInfo>(
903 wgt::application_widget_keys::kTizenContentKey);
905 GetManifestDataForKey<const wgt::parse::ServiceList>(
906 wgt::application_widget_keys::kTizenServiceKey);
908 backend_data->content.set(*content_info);
910 backend_data->service_list.set(*service_list);
913 // Copy data from ManifestData to InstallerContext
915 GetManifestDataForKey<const wgt::parse::TizenApplicationInfo>(
916 wgt::application_widget_keys::kTizenApplicationKey);
918 GetManifestDataForKey<const wgt::parse::WidgetInfo>(
919 wgt::application_widget_keys::kTizenWidgetKey);
922 const auto& name_set = wgt_info->name_set();
923 if (name_set.find("") != name_set.end())
924 name = name_set.find("")->second;
925 if (name_set.begin() != name_set.end())
926 name = name_set.begin()->second;
928 std::string short_name;
929 const auto& short_name_set = wgt_info->short_name_set();
930 if (short_name_set.find("") != short_name_set.end())
931 short_name = short_name_set.find("")->second;
932 if (short_name_set.begin() != short_name_set.end())
933 short_name = short_name_set.begin()->second;
935 const std::string& package_version = wgt_info->version();
936 const std::string& required_api_version = info->required_version();
938 manifest_x* manifest =
939 static_cast<manifest_x*>(calloc(1, sizeof(manifest_x)));
941 LOG(ERROR) << "Out of memory";
942 return common_installer::Step::Status::ERROR;
944 manifest->api_version = strdup(required_api_version.c_str());
946 if (!FillManifestX(manifest)) {
947 LOG(ERROR) << "[Parse] Storing manifest_x failed. "
948 << parser_->GetErrorMessage();
949 pkgmgr_parser_free_manifest_xml(manifest);
950 return common_installer::Step::Status::PARSE_ERROR;
953 context_->pkgid.set(manifest->package);
955 // write pkgid for recovery file
956 if (context_->recovery_info.get().recovery_file) {
957 context_->recovery_info.get().recovery_file->set_pkgid(manifest->package);
958 context_->recovery_info.get().recovery_file->WriteAndCommitFileContent();
962 GetManifestDataForKey<const wgt::parse::PermissionsInfo>(
963 wgt::application_widget_keys::kTizenPermissionsKey);
964 parser::PermissionSet permissions;
966 permissions = perm_info->GetAPIPermissions();
969 GetManifestDataForKey<const wgt::parse::SettingInfo>(
970 wgt::application_widget_keys::kTizenSettingKey);
972 backend_data->settings.set(*settings_info);
974 LOG(DEBUG) << " Read data -[ ";
975 LOG(DEBUG) << "App id: " << info->id();
976 LOG(DEBUG) << " package = " << info->package();
977 LOG(DEBUG) << " id = " << info->id();
978 LOG(DEBUG) << " name = " << name;
979 LOG(DEBUG) << " short_name = " << short_name;
980 LOG(DEBUG) << " aplication version = " << package_version;
981 LOG(DEBUG) << " api_version = " << info->required_version();
982 LOG(DEBUG) << " launch_mode = " << info->launch_mode();
983 LOG(DEBUG) << " privileges -[";
984 for (const auto& p : permissions) {
985 LOG(DEBUG) << " " << p;
990 if (context_->manifest_data.get())
991 pkgmgr_parser_free_manifest_xml(context_->manifest_data.get());
993 context_->manifest_data.set(manifest);
994 return common_installer::Step::Status::OK;
997 bool StepParse::Check(const boost::filesystem::path& widget_path) {
998 LOG(DEBUG) << "unpacked widget path: " << widget_path;
1000 widget_path_ = widget_path;
1002 boost::filesystem::path config = widget_path / kConfigFileName;
1003 LOG(DEBUG) << "config.xml path: " << config;
1004 if (!boost::filesystem::exists(config))
1009 } // namespace configuration