#include <pkgmgr/pkgmgr_parser.h>
#include <pkgmgr-info.h>
-#include <tpk_manifest_handlers/common/appdefined_privilege_handler.h>
+#include <tpk_manifest_handlers/appdefined_privilege_handler.h>
#include <tpk_manifest_handlers/application_manifest_constants.h>
#include <tpk_manifest_handlers/author_handler.h>
#include <tpk_manifest_handlers/component_based_application_handler.h>
#include <tpk_manifest_handlers/dependencies_handler.h>
#include <tpk_manifest_handlers/description_handler.h>
#include <tpk_manifest_handlers/feature_handler.h>
+#include <tpk_manifest_handlers/light_user_handler.h>
#include <tpk_manifest_handlers/package_handler.h>
#include <tpk_manifest_handlers/privileges_handler.h>
#include <tpk_manifest_handlers/profile_handler.h>
#include <tpk_manifest_handlers/watch_application_handler.h>
#include <tpk_manifest_handlers/widget_application_handler.h>
-#include <chrono>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include "common/feature_validator.h"
#include "common/installer_context.h"
-#include "common/paths.h"
+#include "common/utils/paths.h"
#include "common/privileges.h"
#include "common/pkgmgr_registration.h"
-#include "common/pkgmgr_query.h"
+#include "common/utils/pkgmgr_query.h"
#include "common/step/step.h"
#include "common/utils/glist_range.h"
+#include "common/utils/time_util.h"
namespace app_keys = tpk::application_keys;
namespace bf = boost::filesystem;
context_->is_readonly_package.get()))
/ bf::path(context_->pkgid.get());
install_path += ".xml";
- if (bf::exists(backup_path))
+ bf::path backup_install_path =
+ common_installer::GetBackupPathForManifestFile(install_path);
+ if (bf::exists(backup_install_path))
+ manifest = backup_install_path;
+ else if (bf::exists(backup_path))
manifest = backup_path;
- else if (bf::exists(in_package_path))
- manifest = in_package_path;
else if (bf::exists(install_path))
manifest = install_path;
+ else if (bf::exists(in_package_path))
+ manifest = in_package_path;
break;
}
case ManifestLocation::INSTALLED: {
bool StepParseManifest::FillInstallationInfo(manifest_x* manifest) {
manifest->root_path = strdup(
(context_->root_application_path.get() / manifest->package).c_str());
- manifest->installed_time =
- strdup(std::to_string(std::chrono::system_clock::to_time_t(
- std::chrono::system_clock::now())).c_str());
+ manifest->installed_time = strdup(GetCurrentTime().c_str());
return true;
}
return false;
}
- auto ui_application_list =
- std::static_pointer_cast<const tpk::parse::UIApplicationInfoList>(
- parser_->GetManifestData(app_keys::kUIApplicationKey));
- auto service_application_list =
- std::static_pointer_cast<const tpk::parse::ServiceApplicationInfoList>(
- parser_->GetManifestData(app_keys::kServiceApplicationKey));
- auto widget_application_list =
- std::static_pointer_cast<const tpk::parse::WidgetApplicationInfoList>(
- parser_->GetManifestData(app_keys::kWidgetApplicationKey));
- auto watch_application_list =
- std::static_pointer_cast<const tpk::parse::WatchApplicationInfoList>(
- parser_->GetManifestData(app_keys::kWatchApplicationKey));
- auto component_based_application_list =
- std::static_pointer_cast<
- const tpk::parse::ComponentBasedApplicationInfoList>(
- parser_->GetManifestData(
- app_keys::kComponentBasedApplicationKey));
-
- // mandatory check
- if (!ui_application_list && !service_application_list &&
- !widget_application_list && !watch_application_list &&
- !component_based_application_list) {
- LOG(ERROR) << "UI Application or Service Application or Widget Application "
- "or Watch Application or Component-Based Application "
- "are mandatory and has not been found.";
- return false;
- }
-
int support_mode_val = GetSupportModeVal(pkg_info->support_mode());
manifest->ns = strdup(pkg_info->xmlns().c_str());
}
// retrieve and set plugin execution info if exists
- if (manifest_location_ == ManifestLocation::INSTALLED ||
- manifest_location_ == ManifestLocation::RECOVERY) {
+ if (store_location_ == StoreLocation::BACKUP && (
+ manifest_location_ == ManifestLocation::INSTALLED ||
+ manifest_location_ == ManifestLocation::RECOVERY)) {
std::vector<PkgQueryInterface::PluginInfo> plugin_list;
pkg_query.PluginExecutionInfo(&plugin_list);
return false;
if (!FillMetadata(widget_app, application.meta_data))
return false;
+ if (!FillResControl(widget_app, application.res_controls))
+ return false;
}
return true;
}
service_app->type = strdup(application.app_info.type().c_str());
else
service_app->type = strdup("capp");
- service_app->process_pool =
- strdup(application.app_info.process_pool().c_str());
service_app->component_type = strdup("svcapp");
service_app->mainapp = strdup(application.app_info.mainapp().c_str());
service_app->nodisplay = strdup("true");
if (!FillBackgroundCategoryInfo(service_app,
application.background_category))
return false;
+ if (!FillResControl(service_app, application.res_controls))
+ return false;
}
return true;
}
return false;
if (!FillSplashScreen(ui_app, application.app_splashscreens))
return false;
+ if (!FillResControl(ui_app, application.res_controls))
+ return false;
}
return true;
}
if (!watch_application.app_info.setup_appid().empty())
watch_app->setup_appid =
strdup(watch_application.app_info.setup_appid().c_str());
+ manifest->application = g_list_append(manifest->application, watch_app);
if (!FillLabel(watch_app, watch_application.label))
return false;
if (!FillBackgroundCategoryInfo(watch_app,
watch_application.background_category))
return false;
- manifest->application = g_list_append(manifest->application, watch_app);
+ if (!FillResControl(watch_app, watch_application.res_controls))
+ return false;
}
return true;
}
return true;
}
+bool StepParseManifest::FillLightUserInfo(manifest_x* manifest) {
+ std::shared_ptr<const tpk::parse::LightUserInfo> light_user_info =
+ std::static_pointer_cast<const tpk::parse::LightUserInfo>(
+ parser_->GetManifestData(tpk::parse::LightUserInfo::Key()));
+ if (!light_user_info) {
+ manifest->light_user_switch_mode = strdup("default");
+ return true;
+ }
+
+ if (light_user_info->switch_mode().empty()) {
+ LOG(ERROR) << "Invalid switch mode";
+ return false;
+ }
+
+ manifest->light_user_switch_mode =
+ strdup(light_user_info->switch_mode().c_str());
+
+ return true;
+}
+
bool StepParseManifest::CheckFeatures() {
auto feature_info =
std::static_pointer_cast<const tpk::parse::FeatureInfo>(
return true;
}
+template <typename T>
+bool StepParseManifest::FillResControl(application_x* app,
+ const T& res_control_list) {
+ for (auto& res_control : res_control_list) {
+ if (res_control.resource_type().empty())
+ continue;
+
+ res_control_x* rc =
+ static_cast<res_control_x*>(calloc(1, sizeof(res_control_x)));
+ if (!rc) {
+ LOG(ERROR) << "Out of memory";
+ return false;
+ }
+
+ rc->res_type = strdup(res_control.resource_type().c_str());
+ if (!res_control.min_res_version().empty())
+ rc->min_res_version = strdup(res_control.min_res_version().c_str());
+ if (!res_control.max_res_version().empty())
+ rc->max_res_version = strdup(res_control.max_res_version().c_str());
+ if (!res_control.auto_close().empty())
+ rc->auto_close = strdup(res_control.auto_close().c_str());
+
+ app->res_control = g_list_prepend(app->res_control, rc);
+ }
+ return true;
+}
+
void StepParseManifest::GetLegacySplashScreenFromMetadata(application_x* app,
const std::string& key, const std::string& val) {
std::string operation;
manifest->zip_mount_file = strdup(zip_mount_file.c_str());
}
+ if (manifest->application == nullptr)
+ return true;
+
// in case of hybrid package, main app is already set by wgt-backend
application_x* mainapp = nullptr;
if (!context_->cross_app_rules.get()) {
return false;
if (!FillSplashScreen(app, application.app_splashscreens))
return false;
+ if (!FillResControl(app, application.res_controls))
+ return false;
}
return true;
return false;
if (!FillDependencyInfo(manifest))
return false;
+ if (!FillLightUserInfo(manifest))
+ return false;
return true;
}
projects / platform / core / appfw / app-installers.git / blobdiff