#include <boost/filesystem/path.hpp>
#include <common/app_installer.h>
-#include <common/backup_paths.h>
+#include <common/paths.h>
#include <common/installer_context.h>
+#include <common/pkgmgr_query.h>
+#include <common/privileges.h>
#include <common/step/step.h>
#include <common/utils/glist_range.h>
#include <manifest_parser/utils/version_number.h>
#include <wgt_manifest_handlers/account_handler.h>
#include <wgt_manifest_handlers/app_control_handler.h>
+#include <wgt_manifest_handlers/appdefined_privilege_handler.h>
#include <wgt_manifest_handlers/application_icons_handler.h>
#include <wgt_manifest_handlers/application_manifest_constants.h>
#include <wgt_manifest_handlers/background_category_handler.h>
#include <wgt_manifest_handlers/category_handler.h>
#include <wgt_manifest_handlers/content_handler.h>
+#include <wgt_manifest_handlers/ime_handler.h>
#include <wgt_manifest_handlers/metadata_handler.h>
+#include <wgt_manifest_handlers/provides_appdefined_privilege_handler.h>
#include <wgt_manifest_handlers/service_handler.h>
#include <wgt_manifest_handlers/setting_handler.h>
#include <wgt_manifest_handlers/tizen_application_handler.h>
#include <wgt_manifest_handlers/widget_handler.h>
-#include <wgt_manifest_handlers/ime_handler.h>
+#include <wgt_manifest_handlers/w3c_pc_utils.h>
#include <pkgmgr/pkgmgr_parser.h>
+#include <pkgmgrinfo_basic.h>
#include <string.h>
#include <set>
#include <string>
#include <vector>
+#include <utility>
#include "wgt/wgt_backend_data.h"
namespace bf = boost::filesystem;
+namespace ci = common_installer;
namespace {
"http://tizen.org/category/wearable_clock";
const char kCategoryWatchClock[] = "com.samsung.wmanager.WATCH_CLOCK";
-const std::string kManifestVersion = "1.0.0";
+const char kManifestVersion[] = "1.0.0";
const char kTizenPackageXmlNamespace[] = "http://tizen.org/ns/packages";
const char kImeCategoryName[] = "http://tizen.org/category/ime";
+const char kDownloadableFontCategoryName[] =
+ "http://tizen.org/category/downloadable_font";
+const char kTTSCategoryName[] = "http://tizen.org/category/tts";
const char kResWgt[] = "res/wgt";
+const char kConfigFileName[] = "config.xml";
+
+void FreeMetadataList(gpointer data) {
+ metadata_x* metadata = reinterpret_cast<metadata_x*>(data);
+ if (metadata) {
+ if (metadata->key)
+ free(const_cast<char*>(metadata->key));
+ if (metadata->value)
+ free(const_cast<char*>(metadata->value));
+ free(metadata);
+ }
+}
GList* GenerateMetadataListX(const wgt::parse::MetaDataInfo& meta_info) {
GList* list = nullptr;
for (auto& meta : meta_info.metadata()) {
metadata_x* new_meta =
static_cast<metadata_x*>(calloc(1, sizeof(metadata_x)));
+ if (!new_meta) {
+ LOG(ERROR) << "Out of memory";
+ g_list_free_full(list, &FreeMetadataList);
+ return nullptr;
+ }
new_meta->key = strdup(meta.first.c_str());
if (!meta.second.empty())
new_meta->value = strdup(meta.second.c_str());
return list;
}
+void AppendWidgetMetadata(GList** metadatas,
+ const std::vector<std::pair<std::string, std::string>> metadata) {
+ GList* list = *metadatas;
+ for (auto& meta : metadata) {
+ metadata_x* new_meta =
+ static_cast<metadata_x*>(calloc(1, sizeof(metadata_x)));
+ if (!new_meta) {
+ LOG(ERROR) << "Out of memory";
+ return;
+ }
+ new_meta->key = strdup(meta.first.c_str());
+ if (!meta.second.empty())
+ new_meta->value = strdup(meta.second.c_str());
+
+ list = g_list_append(list, new_meta);
+ }
+
+ *metadatas = list;
+}
+
void SetApplicationXDefaults(application_x* application) {
application->effectimage_type = strdup("image");
- application->enabled = strdup("true");
application->guestmode_visibility = strdup("true");
application->hwacceleration = strdup("default");
application->indicatordisplay = strdup("true");
application->submode = strdup("false");
application->support_disable = strdup("false");
application->ui_gadget = strdup("false");
+ application->multiple = strdup("false");
+}
+
+template<typename T>
+void AppendLabel(T* root, const std::string& label,
+ const std::string& locale) {
+ label_x* label_item = reinterpret_cast<label_x*>(calloc(1, sizeof(label_x)));
+ if (!label_item) {
+ LOG(ERROR) << "Out of memory";
+ return;
+ }
+ label_item->name = strdup(label.c_str());
+ label_item->text = strdup(label.c_str());
+ label_item->lang = !locale.empty() ?
+ strdup(locale.c_str()) : strdup(DEFAULT_LOCALE);
+ root->label = g_list_append(root->label, label_item);
}
} // namespace
std::string version = manifest_version.substr(0,
manifest_version.find_first_not_of("1234567890."));
- utils::VersionNumber version_number(version);
-
- if (!version_number.IsValidTizenPackageVersion()) {
- LOG(WARNING) << "Version number: " << manifest_version
- << " is not valid version number for tizen package. "
- << "Default value will be used.";
- return kManifestVersion;
- }
-
- return version_number.ToString();
+ return version;
}
bool StepParse::FillInstallationInfo(manifest_x* manifest) {
}
bool StepParse::FillIconPaths(manifest_x* manifest) {
- std::shared_ptr<const wgt::parse::TizenApplicationInfo> app_info =
- std::static_pointer_cast<const wgt::parse::TizenApplicationInfo>(
- parser_->GetManifestData(app_keys::kTizenApplicationKey));
+ auto app_info =
+ GetManifestDataForKey<const wgt::parse::TizenApplicationInfo>(
+ app_keys::kTizenApplicationKey);
if (!app_info) {
LOG(ERROR) << "Application info manifest data has not been found.";
return false;
}
- std::shared_ptr<const wgt::parse::ApplicationIconsInfo> icons_info =
- std::static_pointer_cast<const wgt::parse::ApplicationIconsInfo>(
- parser_->GetManifestData(app_keys::kIconsKey));
- if (icons_info.get()) {
- for (auto& application_icon : icons_info->icons()) {
- icon_x* icon = reinterpret_cast<icon_x*> (calloc(1, sizeof(icon_x)));
- bf::path icon_path = context_->root_application_path.get()
- / app_info->package() / "res" / "wgt" / application_icon.path();
- icon->text = strdup(icon_path.c_str());
- icon->lang = strdup(DEFAULT_LOCALE);
- manifest->icon = g_list_append(manifest->icon, icon);
+ auto icons_info =
+ GetManifestDataForKey<const wgt::parse::ApplicationIconsInfo>(
+ app_keys::kIconsKey);
+ if (!icons_info) {
+ icons_info.reset(new(std::nothrow) wgt::parse::ApplicationIconsInfo());
+ if (!icons_info) {
+ LOG(ERROR) << "Out of memory";
+ return false;
}
}
+ wgt::parse::LocalizedApplicationIconsInfo localized_list =
+ wgt::parse::GetLocalizedIconList(*icons_info, widget_path_);
+ // We need to generate icon for each locale and icons are already set into
+ // lookup order. There isn't said that all icons should be received from
+ // one <icon> tag position so we iterate utils we run out of icons creating
+ // any icon element that are possible for given locale.
+ std::set<std::string> found_locales;
+ for (auto& application_icon : localized_list) {
+ const std::string& locale = application_icon.locale();
+ if (found_locales.find(locale) != found_locales.end())
+ continue;
+ found_locales.insert(locale);
+
+ icon_x* icon = reinterpret_cast<icon_x*>(calloc(1, sizeof(icon_x)));
+ if (!icon) {
+ LOG(ERROR) << "Out of memory";
+ return false;
+ }
+ bf::path icon_path = context_->root_application_path.get()
+ / app_info->package() / "res" / "wgt" / application_icon.path();
+ icon->text = strdup(icon_path.c_str());
+ if (!locale.empty())
+ icon->lang = strdup(locale.c_str());
+ else
+ icon->lang = strdup(DEFAULT_LOCALE);
+ manifest->icon = g_list_append(manifest->icon, icon);
+ }
return true;
}
bool StepParse::FillWidgetInfo(manifest_x* manifest) {
- std::shared_ptr<const wgt::parse::WidgetInfo> wgt_info =
- std::static_pointer_cast<const wgt::parse::WidgetInfo>(
- parser_->GetManifestData(app_keys::kWidgetKey));
+ auto wgt_info =
+ GetManifestDataForKey<const wgt::parse::WidgetInfo>(
+ app_keys::kWidgetKey);
+
if (!wgt_info.get()) {
LOG(ERROR) << "Widget info manifest data has not been found.";
return false;
for (auto& item : wgt_info->description_set()) {
description_x* description = reinterpret_cast<description_x*>
(calloc(1, sizeof(description_x)));
+ if (!description) {
+ LOG(ERROR) << "Out of memory";
+ return false;
+ }
description->text = strdup(item.second.c_str());
description->lang = !item.first.empty() ?
strdup(item.first.c_str()) : strdup(DEFAULT_LOCALE);
}
for (auto& item : wgt_info->name_set()) {
- label_x* label = reinterpret_cast<label_x*>(calloc(1, sizeof(label_x)));
- label->name = strdup(item.second.c_str());
- label->text = strdup(item.second.c_str());
- label->lang = !item.first.empty() ?
- strdup(item.first.c_str()) : strdup(DEFAULT_LOCALE);
- manifest->label = g_list_append(manifest->label, label);
+ AppendLabel(manifest, item.second, item.first);
}
manifest->type = strdup("wgt");
manifest->appsetting = strdup("false");
manifest->nodisplay_setting = strdup("false");
- manifest->preload = strdup("false");
+ manifest->installed_storage = strdup("installed_internal");
// For wgt package use the long name
+ application_x* app =
+ reinterpret_cast<application_x*>(manifest->application->data);
for (auto& item : wgt_info->name_set()) {
- application_x* app =
- reinterpret_cast<application_x*>(manifest->application->data);
- label_x* label = reinterpret_cast<label_x*>(calloc(1, sizeof(label_x)));
- label->name = strdup(item.second.c_str());
- label->text = strdup(item.second.c_str());
- label->lang = !item.first.empty() ?
- strdup(item.first.c_str()) : strdup(DEFAULT_LOCALE);
- app->label = g_list_append(app->label, label);
+ AppendLabel(app, item.second, item.first);
}
author_x* author = reinterpret_cast<author_x*>(calloc(1, sizeof(author_x)));
+ if (!author) {
+ LOG(ERROR) << "Out of memory";
+ return false;
+ }
if (!wgt_info->author().empty())
author->text = strdup(wgt_info->author().c_str());
if (!wgt_info->author_email().empty())
author->lang = strdup(DEFAULT_LOCALE);
manifest->author = g_list_append(manifest->author, author);
- std::shared_ptr<const wgt::parse::SettingInfo> settings_info =
- std::static_pointer_cast<const wgt::parse::SettingInfo>(
- parser_->GetManifestData(
- wgt::application_widget_keys::kTizenSettingKey));
+ auto settings_info =
+ GetManifestDataForKey<const wgt::parse::SettingInfo>(
+ wgt::application_widget_keys::kTizenSettingKey);
if (settings_info) {
switch (settings_info->install_location()) {
case wgt::parse::SettingInfo::InstallLocation::AUTO: {
manifest->installlocation = strdup("auto");
}
+ if (!context_->pkgid.get().empty()) {
+ // set update true if package is updated preload package
+ ci::RequestType req_type = context_->request_type.get();
+ ci::PkgQueryInterface pkg_query(manifest->package, context_->uid.get());
+ if (pkg_query.IsUpdatedPackage())
+ manifest->update = strdup("true");
+ else if (pkg_query.IsPreloadPackage() &&
+ (req_type == ci::RequestType::Update ||
+ req_type == ci::RequestType::Delta ||
+ req_type == ci::RequestType::MountUpdate ||
+ req_type == ci::RequestType::ReadonlyUpdateInstall))
+ manifest->update = strdup("true");
+ else
+ manifest->update = strdup("false");
+ }
+
return true;
}
bool StepParse::FillMainApplicationInfo(manifest_x* manifest) {
- std::shared_ptr<const wgt::parse::TizenApplicationInfo> app_info =
- std::static_pointer_cast<const wgt::parse::TizenApplicationInfo>(
- parser_->GetManifestData(app_keys::kTizenApplicationKey));
+ auto app_info =
+ GetManifestDataForKey<const wgt::parse::TizenApplicationInfo>(
+ app_keys::kTizenApplicationKey);
if (!app_info) {
LOG(ERROR) << "Application info manifest data has not been found.";
return false;
}
- bool has_watch_catergory = false;
+ bool has_watch_category = false;
bool has_ime = false;
- std::shared_ptr<const wgt::parse::CategoryInfoList> category_info =
- std::static_pointer_cast<const wgt::parse::CategoryInfoList>(
- parser_->GetManifestData(app_keys::kTizenCategoryKey));
+ bool has_downloadable_font = false;
+ bool has_tts = false;
+ auto category_info =
+ GetManifestDataForKey<const wgt::parse::CategoryInfoList>(
+ app_keys::kTizenCategoryKey);
+
if (category_info) {
- has_watch_catergory = std::find_if(category_info->categories.begin(),
+ has_watch_category = std::find_if(category_info->categories.begin(),
category_info->categories.end(),
[](const std::string& category) {
return category == kCategoryWearableClock ||
}) != category_info->categories.end();
has_ime = std::find(category_info->categories.begin(),
category_info->categories.end(),
- kImeCategoryName
- ) != category_info->categories.end();
+ kImeCategoryName)
+ != category_info->categories.end();
+ has_downloadable_font = std::find(category_info->categories.begin(),
+ category_info->categories.end(),
+ kDownloadableFontCategoryName)
+ != category_info->categories.end();
+ has_tts = std::find(category_info->categories.begin(),
+ category_info->categories.end(),
+ kTTSCategoryName)
+ != category_info->categories.end();
}
// application data
application_x* application = reinterpret_cast<application_x*>(
calloc(1, sizeof(application_x)));
+ if (!application) {
+ LOG(ERROR) << "Out of memory";
+ return false;
+ }
application->component_type =
- has_watch_catergory ? strdup("watchapp") : strdup("uiapp");
+ has_watch_category ? strdup("watchapp") : strdup("uiapp");
application->mainapp = strdup("true");
- application->multiple = strdup("false");
application->appid = strdup(app_info->id().c_str());
- application->nodisplay = has_ime ? strdup("true") : strdup("false");
- application->taskmanage = has_ime ? strdup("false") : strdup("true");
+ auto settings_info =
+ GetManifestDataForKey<const wgt::parse::SettingInfo>(
+ wgt::application_widget_keys::kTizenSettingKey);
+
+ bool no_display = settings_info ? settings_info->no_display() : false;
+ bool has_no_display_category =
+ has_watch_category || has_ime || has_tts || has_downloadable_font;
+
+ application->nodisplay = (has_no_display_category || no_display) ?
+ strdup("true") : strdup("false");
+ application->taskmanage = has_no_display_category ? strdup("false") :
+ strdup("true");
+
SetApplicationXDefaults(application);
- if (has_watch_catergory)
- application->ambient_support =
+ if (has_watch_category)
+ application->support_ambient =
strdup(app_info->ambient_support() ? "true" : "false");
else
- application->ambient_support = strdup("false");
+ application->support_ambient = strdup("false");
application->package = strdup(app_info->package().c_str());
application->exec =
application->autorestart = strdup("false");
application->launch_mode = strdup(app_info->launch_mode().c_str());
- if (manifest->icon) {
- icon_x* icon = reinterpret_cast<icon_x*>(manifest->icon->data);
+ application->api_version = strdup(manifest->api_version);
+ for (auto& icon : GListRange<icon_x*>(manifest->icon)) {
icon_x* app_icon = reinterpret_cast<icon_x*>(calloc(1, sizeof(icon_x)));
+ if (!app_icon) {
+ LOG(ERROR) << "Out of memory";
+ pkgmgrinfo_basic_free_application(application);
+ return false;
+ }
app_icon->text = strdup(icon->text);
app_icon->lang = strdup(icon->lang);
application->icon = g_list_append(application->icon, app_icon);
}
- manifest->application = g_list_append(manifest->application, application);
+ // guarantees that the main app will be at the begining of the list
+ manifest->application = g_list_insert(manifest->application, application, 0);
manifest->package = strdup(app_info->package().c_str());
manifest->mainapp_id = strdup(app_info->id().c_str());
}
bool StepParse::FillServiceApplicationInfo(manifest_x* manifest) {
- std::shared_ptr<const wgt::parse::ServiceList> service_list =
- std::static_pointer_cast<const wgt::parse::ServiceList>(
- parser_->GetManifestData(app_keys::kTizenServiceKey));
+ auto service_list =
+ GetManifestDataForKey<const wgt::parse::ServiceList>(
+ app_keys::kTizenServiceKey);
if (!service_list)
return true;
- bool has_ime = false;
- std::shared_ptr<const wgt::parse::CategoryInfoList> category_info =
- std::static_pointer_cast<const wgt::parse::CategoryInfoList>(
- parser_->GetManifestData(app_keys::kTizenCategoryKey));
- if (category_info) {
- has_ime = std::find(category_info->categories.begin(),
- category_info->categories.end(),
- kImeCategoryName
- ) != category_info->categories.end();
- }
for (auto& service_info : service_list->services) {
application_x* application = reinterpret_cast<application_x*>
(calloc(1, sizeof(application_x)));
+ if (!application) {
+ LOG(ERROR) << "Out of memory";
+ return false;
+ }
application->component_type = strdup("svcapp");
application->mainapp = strdup("false");
- application->multiple = strdup("false");
application->appid = strdup(service_info.id().c_str());
application->exec =
strdup((context_->root_application_path.get() / manifest->package
service_info.on_boot() ? strdup("true") : strdup("false");
application->autorestart =
service_info.auto_restart() ? strdup("true") : strdup("false");
- application->nodisplay = has_ime ? strdup("true") : strdup("false");
- application->taskmanage = has_ime ? strdup("false") : strdup("true");
+ application->nodisplay = strdup("false");
+ application->taskmanage = strdup("true");
SetApplicationXDefaults(application);
- application->ambient_support = strdup("false");
+ application->support_ambient = strdup("false");
application->package = strdup(manifest->package);
-
+ application->api_version = strdup(manifest->api_version);
for (auto& pair : service_info.names()) {
- label_x* label = reinterpret_cast<label_x*>(calloc(1, sizeof(label_x)));
- label->lang = !pair.first.empty() ?
- strdup(pair.first.c_str()) : strdup(DEFAULT_LOCALE);
- label->name = strdup(pair.second.c_str());
- label->text = strdup(pair.second.c_str());
- application->label = g_list_append(application->label, label);
+ AppendLabel(application, pair.second, pair.first);
}
if (!service_info.icon().empty()) {
+ bf::path icon_path = context_->root_application_path.get()
+ / manifest->package / "res" / "wgt" / service_info.icon();
icon_x* icon = reinterpret_cast<icon_x*>(calloc(1, sizeof(icon_x)));
- icon->text = strdup(service_info.icon().c_str());
+ if (!icon) {
+ LOG(ERROR) << "Out of memory";
+ pkgmgrinfo_basic_free_application(application);
+ return false;
+ }
+ icon->text = strdup(icon_path.c_str());
icon->lang = strdup(DEFAULT_LOCALE);
application->icon = g_list_append(application->icon, icon);
}
- // TODO(t.iwanek): what about description, how is it different from name?
-
for (auto& category : service_info.categories()) {
application->category = g_list_append(application->category,
strdup(category.c_str()));
for (auto& pair : service_info.metadata_set()) {
metadata_x* item = reinterpret_cast<metadata_x*>(
calloc(1, sizeof(metadata_x)));
+ if (!item) {
+ LOG(ERROR) << "Out of memory";
+ return false;
+ }
item->key = strdup(pair.first.c_str());
if (!pair.second.empty())
item->value = strdup(pair.second.c_str());
return true;
}
+bool StepParse::FillWidgetApplicationInfo(manifest_x* manifest) {
+ auto appwidget_info =
+ GetManifestDataForKey<const wgt::parse::AppWidgetInfo>(
+ wgt::application_widget_keys::kTizenAppWidgetFullKey);
+ if (!appwidget_info)
+ return true;
+ for (auto& app_widget : appwidget_info->app_widgets()) {
+ application_x* application = reinterpret_cast<application_x*>
+ (calloc(1, sizeof(application_x)));
+ if (!application) {
+ LOG(ERROR) << "Out of memory";
+ return false;
+ }
+ application->component_type = strdup("widgetapp");
+ application->mainapp = strdup("false");
+ application->appid = strdup(app_widget.id.c_str());
+ application->exec =
+ strdup((context_->root_application_path.get() / manifest->package
+ / "bin" / application->appid).c_str());
+ application->type = strdup("webapp");
+ application->nodisplay = strdup("true");
+ application->taskmanage = strdup("false");
+ SetApplicationXDefaults(application);
+ application->support_ambient = strdup("false");
+ application->package = strdup(manifest->package);
+ application->api_version = strdup(manifest->api_version);
+ if (!app_widget.label.default_value.empty()) {
+ AppendLabel(application, app_widget.label.default_value, std::string());
+ }
+
+ for (auto& pair : app_widget.label.lang_value_map) {
+ AppendLabel(application, pair.second, pair.first);
+ }
+
+ if (!app_widget.icon_src.empty()) {
+ icon_x* icon = reinterpret_cast<icon_x*>(calloc(1, sizeof(icon_x)));
+ if (!icon) {
+ LOG(ERROR) << "Out of memory";
+ pkgmgrinfo_basic_free_application(application);
+ return false;
+ }
+ icon->text = strdup(app_widget.icon_src.c_str());
+ icon->lang = strdup(DEFAULT_LOCALE);
+ application->icon = g_list_append(application->icon, icon);
+ }
+
+ if (!app_widget.metadata.empty())
+ AppendWidgetMetadata(&application->metadata, app_widget.metadata);
+
+ manifest->application = g_list_append(manifest->application, application);
+ }
+ return true;
+}
+
+
bool StepParse::FillBackgroundCategoryInfo(manifest_x* manifest) {
auto manifest_data = parser_->GetManifestData(
app_keys::kTizenBackgroundCategoryKey);
return true;
}
+bool StepParse::FillTrustAnchorInfo(manifest_x* manifest) {
+ auto trust_anchor_info = parser_->GetManifestData(
+ app_keys::kTizenTrustAnchorKey);
+
+ if (!trust_anchor_info)
+ return true;
+
+ std::shared_ptr<const parse::TrustAnchorInfo> trust_anchor =
+ std::static_pointer_cast<const parse::TrustAnchorInfo>
+ (trust_anchor_info);
+
+ if (!trust_anchor)
+ return true;
+
+ std::string use_system_certs = trust_anchor->get_use_system_certs();
+ if (!use_system_certs.empty())
+ manifest->use_system_certs = strdup(use_system_certs.c_str());
+
+ return true;
+}
+
bool StepParse::FillAppControl(manifest_x* manifest) {
- std::shared_ptr<const wgt::parse::AppControlInfoList> app_info_list =
- std::static_pointer_cast<const wgt::parse::AppControlInfoList>(
- parser_->GetManifestData(app_keys::kTizenApplicationAppControlsKey));
+ auto app_info_list =
+ GetManifestDataForKey<const wgt::parse::AppControlInfoList>(
+ app_keys::kTizenApplicationAppControlsKey);
application_x* app =
reinterpret_cast<application_x*>(manifest->application->data);
for (const auto& control : app_info_list->controls) {
appcontrol_x* app_control =
static_cast<appcontrol_x*>(calloc(1, sizeof(appcontrol_x)));
+ if (!app_control) {
+ LOG(ERROR) << "Out of memory";
+ return false;
+ }
app_control->operation = strdup(control.operation().c_str());
app_control->mime = strdup(control.mime().c_str());
app_control->uri = strdup(control.uri().c_str());
}
bool StepParse::FillPrivileges(manifest_x* manifest) {
- std::shared_ptr<const wgt::parse::PermissionsInfo> perm_info =
- std::static_pointer_cast<const wgt::parse::PermissionsInfo>(
- parser_->GetManifestData(app_keys::kTizenPermissionsKey));
+ auto perm_info =
+ GetManifestDataForKey<const wgt::parse::PermissionsInfo>(
+ app_keys::kTizenPermissionsKey);
std::set<std::string> privileges;
if (perm_info)
privileges = ExtractPrivileges(perm_info);
for (auto& priv : privileges) {
- manifest->privileges =
- g_list_append(manifest->privileges, strdup(priv.c_str()));
+ privilege_x* privilege =
+ reinterpret_cast<privilege_x*>(calloc(1, sizeof(privilege_x)));
+ if (!privilege) {
+ LOG(ERROR) << "Out of memory";
+ return false;
+ }
+ privilege->type = strdup(common_installer::kWebPrivilegeType);
+ privilege->value = strdup(priv.c_str());
+ manifest->privileges = g_list_append(manifest->privileges, privilege);
+ }
+ return true;
+}
+
+bool StepParse::FillAppDefinedPrivileges(manifest_x* manifest) {
+ auto priv_info_list =
+ GetManifestDataForKey<const wgt::parse::AppDefinedPrivilegeInfoList>(
+ app_keys::kTizenAppDefinedPrivilegeKey);
+ if (!priv_info_list)
+ return true;
+
+ for (auto& priv : priv_info_list->appdefined_privileges) {
+ appdefined_privilege_x* privilege =
+ reinterpret_cast<appdefined_privilege_x*>(calloc(1,
+ sizeof(appdefined_privilege_x)));
+ if (privilege == nullptr) {
+ LOG(ERROR) << "Memory alloc failure";
+ return false;
+ }
+ privilege->value = strdup(priv.name().c_str());
+ privilege->type = strdup(common_installer::kWebPrivilegeType);
+ if (!priv.license().empty()) {
+ if (bf::path(priv.license()).is_absolute())
+ privilege->license = strdup(priv.license().c_str());
+ else
+ privilege->license = strdup((context_->root_application_path.get()
+ / manifest->package / priv.license()).c_str());
+ }
+ manifest->appdefined_privileges =
+ g_list_append(manifest->appdefined_privileges, privilege);
+ }
+ return true;
+}
+
+bool StepParse::FillProvidesAppDefinedPrivileges(manifest_x* manifest) {
+ auto priv_info_list =
+ GetManifestDataForKey<const wgt::parse::AppDefinedPrivilegeInfoList>(
+ app_keys::kTizenProvidesAppDefinedPrivilegeKey);
+ if (!priv_info_list)
+ return true;
+
+ for (auto& priv : priv_info_list->appdefined_privileges) {
+ appdefined_privilege_x* privilege =
+ reinterpret_cast<appdefined_privilege_x*>(calloc(1,
+ sizeof(appdefined_privilege_x)));
+ if (privilege == nullptr) {
+ LOG(ERROR) << "Memory alloc failure";
+ return false;
+ }
+ privilege->value = strdup(priv.name().c_str());
+ privilege->type = strdup(common_installer::kWebPrivilegeType);
+ if (!priv.license().empty()) {
+ if (bf::path(priv.license()).is_absolute())
+ privilege->license = strdup(priv.license().c_str());
+ else
+ privilege->license = strdup((context_->root_application_path.get()
+ / manifest->package / priv.license()).c_str());
+ }
+ manifest->provides_appdefined_privileges =
+ g_list_append(manifest->provides_appdefined_privileges, privilege);
}
return true;
}
bool StepParse::FillCategories(manifest_x* manifest) {
- std::shared_ptr<const wgt::parse::CategoryInfoList> category_info =
- std::static_pointer_cast<const wgt::parse::CategoryInfoList>(
- parser_->GetManifestData(app_keys::kTizenCategoryKey));
+ auto category_info =
+ GetManifestDataForKey<const wgt::parse::CategoryInfoList>(
+ app_keys::kTizenCategoryKey);
if (!category_info)
return true;
}
bool StepParse::FillMetadata(manifest_x* manifest) {
- std::shared_ptr<const wgt::parse::MetaDataInfo> meta_info =
- std::static_pointer_cast<const wgt::parse::MetaDataInfo>(
- parser_->GetManifestData(app_keys::kTizenMetaDataKey));
+ auto meta_info =
+ GetManifestDataForKey<const wgt::parse::MetaDataInfo>(
+ app_keys::kTizenMetaDataKey);
if (!meta_info)
return true;
}
bool StepParse::FillAppWidget() {
+ // This is needed to store preview icons which are not saved into manifest_x
WgtBackendData* backend_data =
static_cast<WgtBackendData*>(context_->backend_data.get());
- std::shared_ptr<const wgt::parse::AppWidgetInfo> appwidget_info =
- std::static_pointer_cast<const wgt::parse::AppWidgetInfo>(
- parser_->GetManifestData(
- wgt::application_widget_keys::kTizenAppWidgetFullKey));
+ auto appwidget_info =
+ GetManifestDataForKey<const wgt::parse::AppWidgetInfo>(
+ wgt::application_widget_keys::kTizenAppWidgetFullKey);
if (appwidget_info)
backend_data->appwidgets.set(*appwidget_info);
return true;
}
bool StepParse::FillAccounts(manifest_x* manifest) {
- std::shared_ptr<const wgt::parse::AccountInfo> account_info =
- std::static_pointer_cast<const wgt::parse::AccountInfo>(
- parser_->GetManifestData(app_keys::kAccountKey));
+ auto account_info =
+ GetManifestDataForKey<const wgt::parse::AccountInfo>(
+ app_keys::kAccountKey);
if (!account_info)
return true;
common_installer::AccountInfo info;
}
bool StepParse::FillImeInfo() {
- const auto ime_info = std::static_pointer_cast<const wgt::parse::ImeInfo>(
- parser_->GetManifestData(app_keys::kTizenImeKey));
+ auto ime_info =
+ GetManifestDataForKey<const wgt::parse::ImeInfo>(
+ app_keys::kTizenImeKey);
if (!ime_info)
return true;
}
bool StepParse::FillManifestX(manifest_x* manifest) {
+ // Fill data for main application
if (!FillIconPaths(manifest))
return false;
if (!FillMainApplicationInfo(manifest))
return false;
if (!FillPrivileges(manifest))
return false;
+ if (!FillAppDefinedPrivileges(manifest))
+ return false;
+ if (!FillProvidesAppDefinedPrivileges(manifest))
+ return false;
if (!FillAppControl(manifest))
return false;
if (!FillCategories(manifest))
return false;
if (!FillMetadata(manifest))
return false;
- // TODO(t.iwanek): fix adding ui application element
- // for now adding application service is added here because rest of code
- // assumes that there is one application at manifest->application
- // so this must execute last
- if (!FillServiceApplicationInfo(manifest))
- return false;
if (!FillBackgroundCategoryInfo(manifest))
return false;
+ if (!FillTrustAnchorInfo(manifest))
+ return false;
+
+ // Fill data for other applications
+ if (!FillAdditionalApplications(manifest))
+ return false;
+
+ // Fill extra data, other than manifest_x structure
if (!FillExtraManifestInfo(manifest))
return false;
+
+ return true;
+}
+
+
+bool StepParse::FillAdditionalApplications(manifest_x* manifest) {
+ if (!FillServiceApplicationInfo(manifest))
+ return false;
+ if (!FillWidgetApplicationInfo(manifest))
+ return false;
return true;
}
return common_installer::Step::Status::MANIFEST_NOT_FOUND;
}
- parser_.reset(new wgt::parse::WidgetConfigParser());
- if (!parser_->ParseManifest(config_)) {
+ parser_.reset(new(std::nothrow) wgt::parse::WidgetConfigParser());
+ if (!parser_) {
+ LOG(ERROR) << "Out of memory";
+ return common_installer::Step::Status::CONFIG_ERROR;
+ }
+ if (!parser_->ParseManifest(widget_path_ / kConfigFileName)) {
LOG(ERROR) << "[Parse] Parse failed. " << parser_->GetErrorMessage();
return common_installer::Step::Status::PARSE_ERROR;
}
+
+ WgtBackendData* backend_data =
+ static_cast<WgtBackendData*>(context_->backend_data.get());
+
if (check_start_file_) {
- if (!parser_->HasValidStartFile()) {
+ if (!parser_->CheckValidStartFile()) {
LOG(ERROR) << parser_->GetErrorMessage();
return common_installer::Step::Status::PARSE_ERROR;
}
- if (!parser_->HasValidServicesStartFiles()) {
+ if (!parser_->CheckValidServicesStartFiles()) {
LOG(ERROR) << parser_->GetErrorMessage();
return common_installer::Step::Status::PARSE_ERROR;
}
- }
-
- manifest_x* manifest =
- static_cast<manifest_x*>(calloc(1, sizeof(manifest_x)));
- if (!FillManifestX(manifest)) {
- LOG(ERROR) << "[Parse] Storing manifest_x failed. "
- << parser_->GetErrorMessage();
- return common_installer::Step::Status::PARSE_ERROR;
+ } else {
+ // making backup of content data and services content data
+ auto content_info =
+ GetManifestDataForKey<const wgt::parse::ContentInfo>(
+ wgt::application_widget_keys::kTizenContentKey);
+ auto service_list =
+ GetManifestDataForKey<const wgt::parse::ServiceList>(
+ wgt::application_widget_keys::kTizenServiceKey);
+ if (content_info)
+ backend_data->content.set(*content_info);
+ if (service_list)
+ backend_data->service_list.set(*service_list);
}
// Copy data from ManifestData to InstallerContext
- std::shared_ptr<const wgt::parse::TizenApplicationInfo> info =
- std::static_pointer_cast<const wgt::parse::TizenApplicationInfo>(
- parser_->GetManifestData(
- wgt::application_widget_keys::kTizenApplicationKey));
- std::shared_ptr<const wgt::parse::WidgetInfo> wgt_info =
- std::static_pointer_cast<const wgt::parse::WidgetInfo>(
- parser_->GetManifestData(
- wgt::application_widget_keys::kTizenWidgetKey));
+ auto info =
+ GetManifestDataForKey<const wgt::parse::TizenApplicationInfo>(
+ wgt::application_widget_keys::kTizenApplicationKey);
+ auto wgt_info =
+ GetManifestDataForKey<const wgt::parse::WidgetInfo>(
+ wgt::application_widget_keys::kTizenWidgetKey);
std::string name;
const auto& name_set = wgt_info->name_set();
const std::string& package_version = wgt_info->version();
const std::string& required_api_version = info->required_version();
+ manifest_x* manifest =
+ static_cast<manifest_x*>(calloc(1, sizeof(manifest_x)));
+ if (!manifest) {
+ LOG(ERROR) << "Out of memory";
+ return common_installer::Step::Status::ERROR;
+ }
manifest->api_version = strdup(required_api_version.c_str());
+ if (!FillManifestX(manifest)) {
+ LOG(ERROR) << "[Parse] Storing manifest_x failed. "
+ << parser_->GetErrorMessage();
+ return common_installer::Step::Status::PARSE_ERROR;
+ }
+
context_->pkgid.set(manifest->package);
// write pkgid for recovery file
context_->recovery_info.get().recovery_file->WriteAndCommitFileContent();
}
- std::shared_ptr<const wgt::parse::PermissionsInfo> perm_info =
- std::static_pointer_cast<const wgt::parse::PermissionsInfo>(
- parser_->GetManifestData(
- wgt::application_widget_keys::kTizenPermissionsKey));
+ auto perm_info =
+ GetManifestDataForKey<const wgt::parse::PermissionsInfo>(
+ wgt::application_widget_keys::kTizenPermissionsKey);
parser::PermissionSet permissions;
if (perm_info)
permissions = perm_info->GetAPIPermissions();
- WgtBackendData* backend_data =
- static_cast<WgtBackendData*>(context_->backend_data.get());
-
- std::shared_ptr<const wgt::parse::SettingInfo> settings_info =
- std::static_pointer_cast<const wgt::parse::SettingInfo>(
- parser_->GetManifestData(
- wgt::application_widget_keys::kTizenSettingKey));
+ auto settings_info =
+ GetManifestDataForKey<const wgt::parse::SettingInfo>(
+ wgt::application_widget_keys::kTizenSettingKey);
if (settings_info)
backend_data->settings.set(*settings_info);
LOG(DEBUG) << " ]-";
LOG(DEBUG) << "]-";
- // TODO(t.iwanek): In delta mode this step is running two times
if (context_->manifest_data.get())
pkgmgr_parser_free_manifest_xml(context_->manifest_data.get());
}
bool StepParse::Check(const boost::filesystem::path& widget_path) {
- boost::filesystem::path config = widget_path / "config.xml";
+ LOG(DEBUG) << "unpacked widget path: " << widget_path;
- LOG(DEBUG) << "config.xml path: " << config;
+ widget_path_ = widget_path;
+ boost::filesystem::path config = widget_path / kConfigFileName;
+ LOG(DEBUG) << "config.xml path: " << config;
if (!boost::filesystem::exists(config))
return false;
-
- config_ = config;
return true;
}
projects / platform / core / appfw / wgt-backend.git / blobdiff