#include <dpl/assert.h>
#include <dirent.h>
#include <fstream>
-#include <ail.h>
//WRT INCLUDES
#include <widget_install/task_manifest_file.h>
-#include <widget_install/job_widget_install.h>
#include <widget_install/widget_install_errors.h>
#include <widget_install/widget_install_context.h>
-#ifdef DBOX_ENABLED
-#include <web_provider_livebox_info.h>
+#if USE(WEB_PROVIDER)
+#include <web_provider_widget_info.h>
#include <web_provider_plugin_info.h>
#endif
#include <dpl/wrt-dao-ro/global_config.h>
#include <dpl/foreach.h>
#include <dpl/sstream.h>
#include <dpl/string.h>
-#include <dpl/utils/wrt_utility.h>
+#include <dpl/platform.h>
#include <map>
#include <libxml_utils.h>
#include <pkgmgr/pkgmgr_parser.h>
#include <dpl/localization/LanguageTagsProvider.h>
-#include <dpl/utils/path.h>
-
-#include <installer_log.h>
+#include <boost/filesystem.hpp>
+#include <dpl/log/secure_log.h>
#define DEFAULT_ICON_NAME "icon.png"
#define DEFAULT_PREVIEW_NAME "preview.png"
using namespace WrtDB;
+namespace bf = boost::filesystem;
namespace {
typedef std::map<DPL::String, DPL::String> LanguageTagMap;
const char* const STR_TRUE = "true";
const char* const STR_FALSE = "false";
+const char* const STR_ENABLE = "enable";
const char* const STR_NODISPLAY = "nodisplay";
+const char* const STR_BACKGROUND_SUPPORT = "background-support";
+
+#ifdef DEVICE_PROFILE_WEARABLE
+const char* const STR_CATEGORY_WEARABLE_CLOCK = "http://tizen.org/category/wearable_clock";
const char* const STR_CATEGORY_WATCH_CLOCK = "com.samsung.wmanager.WATCH_CLOCK";
const char* const STR_CATEGORY_WATCH_APP = "com.samsung.wmanager.WATCH_APP";
-
-#ifdef IME_ENABLED
-const char* const STR_CATEGORY_IME = "http://tizen.org/category/ime";
#endif
#ifdef SERVICE_ENABLED
const char* const STR_CATEGORY_SERVICE = "http://tizen.org/category/service";
#endif
+#ifdef IME_ENABLED
+const char* const STR_CATEGORY_IME = "http://tizen.org/category/ime";
+#endif
+
+const char* const STR_CATEGORY_TTS = "http://tizen.org/category/tts";
+const char* const STR_CATEGORY_FONT = "http://tizen.org/category/downloadable_font";
+
LanguageTagMap getLanguageTagMap()
{
LanguageTagMap map;
namespace WidgetInstall {
const char * TaskManifestFile::encoding = "UTF-8";
-TaskManifestFile::TaskManifestFile(InstallerContext &inCont) :
+TaskManifestFile::TaskManifestFile(JobWidgetInstall * const &jobContext) :
DPL::TaskDecl<TaskManifestFile>(this),
- m_context(inCont),
+ m_jobContext(jobContext),
writer(NULL)
{
- if (InstallMode::Command::RECOVERY == m_context.mode.command) {
+ if (InstallMode::Command::RECOVERY == m_jobContext->m_installerContext.mode.command) {
AddStep(&TaskManifestFile::stepGenerateManifest);
} else {
AddStep(&TaskManifestFile::stepCopyIconFiles);
-#ifdef DBOX_ENABLED
+#if USE(WEB_PROVIDER)
AddStep(&TaskManifestFile::stepCopyLiveboxFiles);
#endif
#ifdef SERVICE_ENABLED
void TaskManifestFile::stepCreateExecFile()
{
- std::string exec = m_context.locations->getExecFile();
- std::string clientExeStr = GlobalConfig::GetWrtClientExec();
+ std::string exec = m_jobContext->m_installerContext.locations->getExecFile();
+#if ENABLE(ONE_UI_PROCESS_MODEL)
+ std::string target = GlobalConfig::GetWebProcessExec();
+#else // ENABLE(ONE_UI_PROCESS_MODEL)
+ std::string target = GlobalConfig::GetWrtClientExec();
+#endif // ENABLE(ONE_UI_PROCESS_MODEL)
#ifdef MULTIPROCESS_SERVICE_SUPPORT
//default widget
controlExec.append(postfix.str());
errno = 0;
- if (symlink(clientExeStr.c_str(), controlExec.c_str()) != 0)
+ if (symlink(target.c_str(), controlExec.c_str()) != 0)
{
int error = errno;
if (error)
// app-control widgets
unsigned int indexMax = 0;
- FOREACH(it, m_context.widgetConfig.configInfo.appControlList) {
+ FOREACH(it, m_jobContext->m_installerContext.widgetConfig.configInfo.appControlList) {
if (it->m_index > indexMax) {
indexMax = it->m_index;
}
std::string controlExec = exec;
controlExec.append(postfix.str());
errno = 0;
- if (symlink(clientExeStr.c_str(), controlExec.c_str()) != 0) {
+ if (symlink(target.c_str(), controlExec.c_str()) != 0) {
int error = errno;
if (error) {
_E("Failed to make a symbolic name for a file [%s]", DPL::GetErrnoString(error).c_str());
}
#else
//default widget
- _D("link -s %s %s", clientExeStr.c_str(), exec.c_str());
+ _D("link -s %s %s", target.c_str(), exec.c_str());
errno = 0;
- if (symlink(clientExeStr.c_str(), exec.c_str()) != 0)
+ if (symlink(target.c_str(), exec.c_str()) != 0)
{
int error = errno;
if (error)
#ifdef SERVICE_ENABLED
std::string serviceExeStr = GlobalConfig::GetWrtServiceExec();
- FOREACH(it, m_context.widgetConfig.configInfo.serviceAppInfoList) {
- std::string serviceExec = m_context.locations->getBinaryDir() + "/" + DPL::ToUTF8String(it->serviceId);
+ FOREACH(it, m_jobContext->m_installerContext.widgetConfig.configInfo.serviceAppInfoList) {
+ std::string serviceExec = m_jobContext->m_installerContext.locations->getBinaryDir() + "/" + DPL::ToUTF8String(it->serviceId);
errno = 0;
_D("link -s %s %s", serviceExeStr.c_str(), serviceExec.c_str());
if (symlink(serviceExeStr.c_str(), serviceExec.c_str()) != 0)
}
#endif
#endif
+#if USE(WEB_PROVIDER)
// creation of box symlink
ConfigParserData::LiveboxList& liveboxList =
- m_context.widgetConfig.configInfo.m_livebox;
+ m_jobContext->m_installerContext.widgetConfig.configInfo.m_livebox;
if (!liveboxList.empty()) {
- std::string boxExec = "/usr/bin/WebProcess";
- std::string boxSymlink = m_context.locations->getExecFile();
+ std::string boxExec = GlobalConfig::GetWebProcessExec();
+ std::string boxSymlink = m_jobContext->m_installerContext.locations->getExecFile();
boxSymlink += ".d-box";
errno = 0;
}
}
}
-
- m_context.job->UpdateProgress(
+#endif
+ m_jobContext->UpdateProgress(
InstallerContext::INSTALL_CREATE_EXECFILE,
"Widget execfile creation Finished");
}
void TaskManifestFile::stepCreateLinkNPPluginsFile()
{
_D("stepCreateLinkNPPluginsFile");
- if (0 == access(m_context.locations->getNPPluginsDir().c_str(), F_OK)) {
+ if (0 == access(m_jobContext->m_installerContext.locations->getNPPluginsDir().c_str(), F_OK)) {
_D("This webapp has NPPlugins");
std::string pluginsExec = "/usr/bin/PluginProcess";
errno = 0;
if (symlink(pluginsExec.c_str(),
- m_context.locations->getNPPluginsExecFile().c_str()) != 0) {
+ m_jobContext->m_installerContext.locations->getNPPluginsExecFile().c_str()) != 0) {
int error = errno;
if (error) {
- _E("Failed to create symbolic link for npplugins : %ls",
+ _E("Failed to create symbolic link for npplugins : %s",
DPL::GetErrnoString(error).c_str());
}
}
std::vector<Locale> generatedLocales;
WrtDB::WidgetRegisterInfo::LocalizedIconList & icons =
- m_context.widgetConfig.localizationData.icons;
+ m_jobContext->m_installerContext.widgetConfig.localizationData.icons;
for (WrtDB::WidgetRegisterInfo::LocalizedIconList::const_iterator
icon = icons.begin();
DPL::String tmp = (icon->isSmall ? L"small_" : L"") + (*locale);
_D("Icon for locale: %ls is: %ls", tmp.c_str(), src.c_str());
- if (std::find(generatedLocales.begin(), generatedLocales.end(),
- tmp) != generatedLocales.end())
+ if (std::find(generatedLocales.begin(), generatedLocales.end(), tmp) != generatedLocales.end())
{
_D("Skipping - has that locale");
continue;
generatedLocales.push_back(tmp);
}
- DPL::Utils::Path sourceFile(m_context.locations->getSourceDir());
- if (!locale->empty()) {
- sourceFile /= "locales";
- sourceFile /= *locale;
+ bf::path sourceFile(m_jobContext->m_installerContext.locations->getSourceDir());
+ try {
+ if (!locale->empty()) {
+ sourceFile /= bf::path("locales");
+ sourceFile /= (*locale);
+ }
+ sourceFile /= src;
+ } catch (const bf::filesystem_error& ex) {
+ _E("boost::filesystem::error: %s", ex.what());
}
- sourceFile /= src;
- DPL::Utils::Path
- targetFile(m_context.locations->getSharedResourceDir());
- targetFile /= (icon->isSmall ? L"small_" : L"")
- + getIconTargetFilename(*locale, sourceFile.Extension());
+ bf::path targetFile(m_jobContext->m_installerContext.locations->getSharedResourceDir());
+ bf::path extension = bf::extension(sourceFile);
+ try {
+ if (icon->isSmall) {
+ targetFile /= bf::path("small_");
+ }
+ targetFile /= getIconTargetFilename(*locale, extension.native());
+ } catch (const bf::filesystem_error& ex) {
+ _E("boost::filesystem::error: %s", ex.what());
+ }
- if (m_context.widgetConfig.packagingType ==
+ if (m_jobContext->m_installerContext.widgetConfig.packagingType ==
WrtDB::PKG_TYPE_HOSTED_WEB_APP)
{
- m_context.locations->setIconTargetFilenameForLocale(
- targetFile.Fullpath());
+ m_jobContext->m_installerContext.locations->setIconTargetFilenameForLocale(
+ targetFile.native());
}
- _D("Copying icon: %s -> %s", sourceFile.Filename().c_str(), targetFile.Filename().c_str());
+ _D("Copying icon: %s -> %s", sourceFile.c_str(), targetFile.c_str());
- icon_list.push_back(targetFile.Fullpath());
+ icon_list.push_back(targetFile.native());
Try
{
- DPL::FileInput input(sourceFile.Fullpath());
- DPL::FileOutput output(targetFile.Fullpath());
+ DPL::FileInput input(sourceFile.native());
+ DPL::FileOutput output(targetFile.native());
DPL::Copy(&input, &output);
}
-
Catch(DPL::FileInput::Exception::Base)
{
// Error while opening or closing source file
}
}
- m_context.job->UpdateProgress(
+ m_jobContext->UpdateProgress(
InstallerContext::INSTALL_COPY_ICONFILE,
"Widget iconfile copy Finished");
}
{
_D("Copy Service icon files");
- WrtDB::ConfigParserData::ServiceAppInfoList service = m_context.widgetConfig.configInfo.serviceAppInfoList;
+ WrtDB::ConfigParserData::ServiceAppInfoList service = m_jobContext->m_installerContext.widgetConfig.configInfo.serviceAppInfoList;
if (service.size() <= 0) {
return;
ConfigParserData::IconsList iconsList = it->m_iconsList;
FOREACH(iconIt, iconsList) {
- std::string sourceFile = m_context.locations->getSourceDir() +
+ std::string sourceFile = m_jobContext->m_installerContext.locations->getSourceDir() +
'/' +
DPL::ToUTF8String(iconIt->src);
- std::string targetFile = m_context.locations->getSharedResourceDir() +
+ std::string targetFile = m_jobContext->m_installerContext.locations->getSharedResourceDir() +
'/' +
DPL::ToUTF8String(it->serviceId) +
".png";
}
#endif
-#ifdef DBOX_ENABLED
+#if USE(WEB_PROVIDER)
void TaskManifestFile::stepCopyLiveboxFiles()
{
_D("Copy Livebox Files");
using namespace WrtDB;
- ConfigParserData &data = m_context.widgetConfig.configInfo;
+ ConfigParserData &data = m_jobContext->m_installerContext.widgetConfig.configInfo;
ConfigParserData::LiveboxList liveBoxList = data.m_livebox;
if (liveBoxList.size() <= 0) {
if (preview.empty()) {
continue;
}
- sourceFile << m_context.locations->getSourceDir() << "/";
+ sourceFile << m_jobContext->m_installerContext.locations->getSourceDir() << "/";
sourceFile << preview;
- targetFile << m_context.locations->getSharedDataDir() << "/";
+ targetFile << m_jobContext->m_installerContext.locations->getSharedDataDir() << "/";
targetFile << (**boxIt).m_liveboxId << ".";
targetFile << DPL::ToUTF8String((*sizeIt).m_size) << "." << DEFAULT_PREVIEW_NAME;
if (icon.empty()) {
continue;
}
- sourceFile << m_context.locations->getSourceDir() << "/";
+ sourceFile << m_jobContext->m_installerContext.locations->getSourceDir() << "/";
sourceFile << icon;
- targetFile << m_context.locations->getSharedDataDir() << "/";
+ targetFile << m_jobContext->m_installerContext.locations->getSharedDataDir() << "/";
targetFile << (**boxIt).m_liveboxId << "." << DEFAULT_ICON_NAME;
copyFile(sourceFile.str(), targetFile.str());
sourceFile.str("");
targetFile.str("");
}
- m_context.job->UpdateProgress(
+ m_jobContext->UpdateProgress(
InstallerContext::INSTALL_COPY_LIVEBOX_FILES,
"Livebox files copy Finished");
}
{
_D("Copy Account icon files");
WrtDB::ConfigParserData::AccountProvider account =
- m_context.widgetConfig.configInfo.accountProvider;
+ m_jobContext->m_installerContext.widgetConfig.configInfo.accountProvider;
if (account.m_iconSet.empty()) {
_D("Widget doesn't contain Account");
}
FOREACH(it, account.m_iconSet) {
- std::string sourceFile = m_context.locations->getSourceDir() +
- '/' +
- DPL::ToUTF8String(it->second);
- std::string targetFile = m_context.locations->getSharedResourceDir() +
- '/' +
- DPL::ToUTF8String(it->second);
+ std::string baseSourcePath = m_jobContext->m_installerContext.locations->getSourceDir();
+ std::string baseSharedPath = m_jobContext->m_installerContext.locations->getSharedResourceDir();
+ std::string iconPath = DPL::ToUTF8String(it->second);
+
+ std::string sourceFile = baseSourcePath + '/' + iconPath;
+ std::string targetFile = baseSharedPath + '/' + iconPath;
+
+ size_t lastDirCharNumber = iconPath.rfind('/');
+ size_t basePathLength = baseSourcePath.size();
+
+ if (lastDirCharNumber != std::string::npos) {
+ std::string dirName = iconPath.substr(0, lastDirCharNumber);
+ std::string dirTomake = baseSharedPath + '/' + dirName;
+ try {
+ bf::path iconTestPath(sourceFile);
+ const bf::path iconAbsoluteTestPath = bf::canonical(iconTestPath);
+ std::string pathToCompare = iconAbsoluteTestPath.native().substr(0, basePathLength);
+ if (pathToCompare != baseSourcePath) {
+ throw bf::filesystem_error(std::string("icon path is not correct"), boost::system::error_code());
+ }
+ bf::path iconCopyPath(dirTomake);
+ if (!bf::exists(iconCopyPath)) {
+ bf::create_directories(iconCopyPath);
+ bf::permissions(iconCopyPath, bf::owner_all|bf::group_read|bf::group_exe|
+ bf::others_read|bf::others_exe);
+ }
+ } catch (const bf::filesystem_error& ex) {
+ _E("boost::filesystem::error %s", ex.what());
+ ThrowMsg(Exceptions::CopyIconFailed, "Error during file copy."); //until new exceptions usage of new exceptions is implemented
+ }
+ }
copyFile(sourceFile, targetFile);
}
}
}
}
-#ifdef DBOX_ENABLED
+#if USE(WEB_PROVIDER)
bool TaskManifestFile::addBoxUiApplication(Manifest& manifest)
{
UiApplication uiApp;
const DPL::String& languageTag, const std::string & ext) const
{
DPL::OStringStream filename;
- TizenAppId appid = m_context.widgetConfig.tzAppid;
+ TizenAppId appid = m_jobContext->m_installerContext.widgetConfig.tzAppid;
filename << DPL::ToUTF8String(appid).c_str();
if(!ext.empty())
{
- filename << L"." + DPL::FromUTF8String(ext);
+ filename << DPL::FromUTF8String(ext);
}
return filename.str();
}
void TaskManifestFile::stepGenerateManifest()
{
- TizenPkgId pkgid = m_context.widgetConfig.tzPkgid;
+ TizenPkgId pkgid = m_jobContext->m_installerContext.widgetConfig.tzPkgid;
manifest_name = pkgid + L".xml";
// In FOTA environment, Use temporary directory created by pkgmgr.
// Becuase /tmp can be read-only filesystem.
- if (m_context.mode.installTime == InstallMode::InstallTime::FOTA) {
+ if (m_jobContext->m_installerContext.mode.installTime == InstallMode::InstallTime::FOTA) {
manifest_file += L"/opt/share/packages/.recovery/wgt/" + manifest_name;
} else {
manifest_file += L"/tmp/" + manifest_name;
writeManifest(manifest_file);
std::ostringstream destFile;
- if (m_context.mode.rootPath == InstallMode::RootPath::RO) {
+ if (m_jobContext->m_installerContext.mode.rootPath == InstallMode::RootPath::RO) {
destFile << WrtDB::GlobalConfig::GetPreloadManifestPath() << "/";
} else {
destFile << WrtDB::GlobalConfig::GetManifestPath() << "/";
commitManifest();
- m_context.job->UpdateProgress(
+ m_jobContext->UpdateProgress(
InstallerContext::INSTALL_CREATE_MANIFEST,
"Widget Manifest Creation Finished");
}
void TaskManifestFile::commitManifest()
{
- if (!(m_context.mode.rootPath == InstallMode::RootPath::RO &&
- (m_context.mode.installTime == InstallMode::InstallTime::PRELOAD
- || m_context.mode.installTime == InstallMode::InstallTime::FOTA)
- && m_context.mode.extension == InstallMode::ExtensionType::DIR)) {
+ if (!(m_jobContext->m_installerContext.mode.rootPath == InstallMode::RootPath::RO &&
+ (m_jobContext->m_installerContext.mode.installTime == InstallMode::InstallTime::PRELOAD
+ || m_jobContext->m_installerContext.mode.installTime == InstallMode::InstallTime::FOTA)
+ && m_jobContext->m_installerContext.mode.extension == InstallMode::ExtensionType::DIRECTORY)) {
_D("cp %ls %s", manifest_file.c_str(), commit_manifest.c_str());
- DPL::FileInput input(DPL::ToUTF8String(manifest_file));
- DPL::FileOutput output(commit_manifest);
- DPL::Copy(&input, &output);
+ Try
+ {
+ DPL::FileInput input(DPL::ToUTF8String(manifest_file));
+ DPL::FileOutput output(commit_manifest);
+ DPL::Copy(&input, &output);
+ }
+ Catch(DPL::CopyFailed)
+ {
+ _E("File copy failed. %ls to %s", manifest_file.c_str(), commit_manifest.c_str());
+ ReThrowMsg(Exceptions::ManifestCreateFailed, "Error during file copy.");
+ }
_D("Manifest writen to: %s", commit_manifest.c_str());
//removing temp file
//app-control content
ConfigParserData::AppControlInfoList appControlList =
- m_context.widgetConfig.configInfo.appControlList;
+ m_jobContext->m_installerContext.widgetConfig.configInfo.appControlList;
FOREACH(it, appControlList) {
UiApplication uiApp;
uiApp.setTaskmanage(true);
uiApp.setNodisplay(true);
-#ifdef MULTIPROCESS_SERVICE_SUPPORT_INLINE
- uiApp.setTaskmanage(ConfigParserData::AppControlInfo::Disposition::INLINE != it->m_disposition);
- uiApp.setMultiple(ConfigParserData::AppControlInfo::Disposition::INLINE == it->m_disposition);
-#endif
std::stringstream postfix;
postfix << AppControlPrefix::PROCESS_PREFIX << it->m_index;
setWidgetExecPath(uiApp, postfix.str());
WrtDB::ConfigParserData::ServiceAppInfoList service = m_context.widgetConfig.configInfo.serviceAppInfoList;
if (service.size() > 0) {
- ConfigParserData &data = m_context.widgetConfig.configInfo;
-
FOREACH(it, service) {
ServiceApplication serviceApp;
setServiceInfo(serviceApp, *it);
}
#endif
-#ifdef DBOX_ENABLED
+#if USE(WEB_PROVIDER)
setLiveBoxInfo(manifest);
#endif
#else
// when there are multiple uiapps in mainfest
#ifdef SERVICE_ENABLED
- WrtDB::ConfigParserData::ServiceAppInfoList service = m_context.widgetConfig.configInfo.serviceAppInfoList;
+ WrtDB::ConfigParserData::ServiceAppInfoList service = m_jobContext->m_installerContext.widgetConfig.configInfo.serviceAppInfoList;
if (service.size() > 0) {
- ConfigParserData &data = m_context.widgetConfig.configInfo;
-
FOREACH(it, service) {
ServiceApplication serviceApp;
setServiceInfo(serviceApp, *it);
#ifdef IME_ENABLED
ImeApplication imeApp;
- WrtDB::ConfigParserData::ImeAppInfoList ime = m_context.widgetConfig.configInfo.imeAppInfoList;
+ WrtDB::ConfigParserData::ImeAppInfoList ime = m_jobContext->m_installerContext.widgetConfig.configInfo.imeAppInfoList;
if (ime.size() > 0) {
extractImeInfo(imeApp);
manifest.addImeApplication(imeApp);
} else {
- _D("Widget doesn't contain ime");
+ _D("Widget doesn't contain ime");
}
#endif
-#ifdef DBOX_ENABLED
+#if USE(WEB_PROVIDER)
setLiveBoxInfo(manifest);
#endif
#endif
setWidgetIdsService(serviceApp, service);
setWidgetNameService(serviceApp, service);
setWidgetIconService(serviceApp, service);
- setAppControlsInfoService(serviceApp);
setWidgetOtherInfoService(serviceApp);
setWidgetComponentService(serviceApp);
setWidgetAutoRestartService(serviceApp, service);
setWidgetOnBootService(serviceApp, service);
+ setAppCategoryService(serviceApp, service);
+ setMetadataService(serviceApp, service);
}
void TaskManifestFile::setWidgetComponentService(ServiceApplication &serviceApp)
return;
}
- std::string serviceExec = m_context.locations->getBinaryDir() + "/" + DPL::ToUTF8String(service.serviceId);
+ std::string serviceExec = m_jobContext->m_installerContext.locations->getBinaryDir() + "/" + DPL::ToUTF8String(service.serviceId);
serviceApp.setExec(DPL::FromUTF8String(serviceExec));
}
serviceApp.setAppid(service.serviceId);
//extraid
- TizenAppId appid = m_context.widgetConfig.tzAppid;
- if (!!m_context.widgetConfig.guid) {
- serviceApp.setExtraid(*m_context.widgetConfig.guid);
+ TizenAppId appid = m_jobContext->m_installerContext.widgetConfig.tzAppid;
+ if (!!m_jobContext->m_installerContext.widgetConfig.guid) {
+ serviceApp.setExtraid(*m_jobContext->m_installerContext.widgetConfig.guid);
} else {
if (!appid.empty()) {
serviceApp.setExtraid(DPL::String(L"http://") + appid);
}
//type
- serviceApp.setType(DPL::FromASCIIString("capp"));
+ serviceApp.setType(DPL::FromASCIIString("webapp"));
}
void TaskManifestFile::setWidgetNameService(ServiceApplication &serviceApp, WrtDB::ConfigParserData::ServiceAppInfo & service)
FOREACH(localizedData, localizedDataSet) {
Locale i = localizedData->first;
DPL::OptionalString localeTag = getLangTag(i);
- if (localeTag.IsNull()) {
+ if (!localeTag) {
localeTag = i;
}
DPL::OptionalString name = localizedData->second.name;
}
DPL::String icon =
- DPL::FromUTF8String(m_context.locations->getSharedResourceDir()) +
+ DPL::FromUTF8String(m_jobContext->m_installerContext.locations->getSharedResourceDir()) +
DPL::String(L"/") +
DPL::String(service.serviceId) + DPL::String(L".png");
serviceApp.addIcon(icon);
}
-void TaskManifestFile::setAppControlsInfoService(ServiceApplication & serviceApp)
-{
- WrtDB::ConfigParserData::AppControlInfoList appControlList =
- m_context.widgetConfig.configInfo.appControlList;
-
- if (appControlList.empty()) {
- _D("Widget doesn't contain app control");
- return;
- }
-
- // x-tizen-svc=http://tizen.org/appcontrol/operation/pick|NULL|image;
- FOREACH(it, appControlList) {
- setAppControlInfoService(serviceApp, *it);
- }
-}
-
-void TaskManifestFile::setAppControlInfoService(ServiceApplication & serviceApp,
- const WrtDB::ConfigParserData::AppControlInfo & service)
-{
- // x-tizen-svc=http://tizen.org/appcontrol/operation/pick|NULL|image;
- AppControl appControl;
- if (!service.m_operation.empty()) {
- appControl.addOperation(service.m_operation); //TODO: encapsulation?
- }
- if (!service.m_uriList.empty()) {
- FOREACH(uri, service.m_uriList) {
- appControl.addUri(*uri);
- }
- }
- if (!service.m_mimeList.empty()) {
- FOREACH(mime, service.m_mimeList) {
- appControl.addMime(*mime);
- }
- }
- serviceApp.addAppControl(appControl);
-}
-
void TaskManifestFile::setWidgetOtherInfoService(ServiceApplication &serviceApp)
{
serviceApp.setNodisplay(true);
serviceApp.setTaskmanage(false);
serviceApp.setMultiple(false);
- FOREACH(it, m_context.widgetConfig.configInfo.settingsList)
+ FOREACH(it, m_jobContext->m_installerContext.widgetConfig.configInfo.settingsList)
{
if (!strcmp(DPL::ToUTF8String(it->m_name).c_str(), STR_NODISPLAY)) {
if (!strcmp(DPL::ToUTF8String(it->m_value).c_str(), STR_TRUE)) {
}
}
}
+
+void TaskManifestFile::setAppCategoryService(ServiceApplication & serviceApp, const WrtDB::ConfigParserData::ServiceAppInfo & service)
+{
+ if (service.m_categoryList.empty()) {
+ _D("Widget doesn't contain service category");
+ return;
+ }
+
+ FOREACH(it, service.m_categoryList) {
+ serviceApp.addAppCategory(*it);
+ }
+}
+
+void TaskManifestFile::setMetadataService(ServiceApplication & serviceApp, const WrtDB::ConfigParserData::ServiceAppInfo & service)
+{
+ if (service.m_metadataList.empty()) {
+ _D("Widget doesn't contain service metadata");
+ return;
+ }
+
+ FOREACH(it, service.m_metadataList) {
+ MetadataType metadataType(it->key, it->value);
+ serviceApp.addMetadata(metadataType);
+ }
+}
#endif
#ifdef IME_ENABLED
void TaskManifestFile::setWidgetUuidIME(ImeApplication &imeApp)
{
- WrtDB::ConfigParserData::ImeAppInfoList ime = m_context.widgetConfig.configInfo.imeAppInfoList;
+ WrtDB::ConfigParserData::ImeAppInfoList ime = m_jobContext->m_installerContext.widgetConfig.configInfo.imeAppInfoList;
FOREACH(it, ime)
{
void TaskManifestFile::setWidgetLanguageIME(ImeApplication &imeApp)
{
- WrtDB::ConfigParserData::ImeAppInfoList ime = m_context.widgetConfig.configInfo.imeAppInfoList;
+ WrtDB::ConfigParserData::ImeAppInfoList ime = m_jobContext->m_installerContext.widgetConfig.configInfo.imeAppInfoList;
FOREACH(it, ime)
{
void TaskManifestFile::setWidgetIdsIME(ImeApplication & imeApp, const std::string &postfix)
{
//appid
- TizenAppId appid = m_context.widgetConfig.tzAppid;
+ TizenAppId appid = m_jobContext->m_installerContext.widgetConfig.tzAppid;
if (!postfix.empty()) {
appid = DPL::FromUTF8String(DPL::ToUTF8String(appid).append(postfix));
}
bool defaultNameSaved = false;
DPL::OptionalString defaultLocale =
- m_context.widgetConfig.configInfo.defaultlocale;
+ m_jobContext->m_installerContext.widgetConfig.configInfo.defaultlocale;
std::pair<DPL::String,
WrtDB::ConfigParserData::LocalizedData> defaultLocalizedData;
//labels
- FOREACH(localizedData, m_context.widgetConfig.configInfo.localizedDataSet)
+ FOREACH(localizedData, m_jobContext->m_installerContext.widgetConfig.configInfo.localizedDataSet)
{
Locale i = localizedData->first;
DPL::OptionalString tag = getLangTag(i); // translate en -> en_US etc
void TaskManifestFile::setWidgetExecPath(UiApplication & uiApp,
const std::string &postfix)
{
- std::string exec = m_context.locations->getExecFile();
+ std::string exec = m_jobContext->m_installerContext.locations->getExecFile();
if (!postfix.empty()) {
exec.append(postfix);
}
bool defaultNameSaved = false;
DPL::OptionalString defaultLocale =
- m_context.widgetConfig.configInfo.defaultlocale;
+ m_jobContext->m_installerContext.widgetConfig.configInfo.defaultlocale;
std::pair<DPL::String,
WrtDB::ConfigParserData::LocalizedData> defaultLocalizedData;
//labels
- FOREACH(localizedData, m_context.widgetConfig.configInfo.localizedDataSet)
+ FOREACH(localizedData, m_jobContext->m_installerContext.widgetConfig.configInfo.localizedDataSet)
{
Locale i = localizedData->first;
DPL::OptionalString tag = getLangTag(i); // translate en -> en_US etc
const std::string &postfix)
{
//appid
- TizenAppId appid = m_context.widgetConfig.tzAppid;
+ TizenAppId appid = m_jobContext->m_installerContext.widgetConfig.tzAppid;
if (!postfix.empty()) {
appid = DPL::FromUTF8String(DPL::ToUTF8String(appid).append(postfix));
}
uiApp.setAppid(appid);
+ //launch_mode
+ if (!!m_jobContext->m_installerContext.widgetConfig.configInfo.launchMode) {
+ uiApp.addLaunchMode(*m_jobContext->m_installerContext.widgetConfig.configInfo.launchMode);
+ }
+
+#ifdef AMBIENT_ENABLED
+ //ambient_support
+ WrtDB::ConfigParserData::CategoryList categoryList = m_jobContext->m_installerContext.widgetConfig.configInfo.categoryList;
+
+ if (!categoryList.empty()) {
+ FOREACH(it, categoryList) {
+ if ((DPL::ToUTF8String(*it) == STR_CATEGORY_WEARABLE_CLOCK) ||
+ (DPL::ToUTF8String(*it) == STR_CATEGORY_WATCH_CLOCK)) {
+ if (!!m_jobContext->m_installerContext.widgetConfig.configInfo.ambient) {
+ uiApp.setAmbientSupport(*m_jobContext->m_installerContext.widgetConfig.configInfo.ambient);
+ }
+ }
+ }
+ }
+#endif
+
//extraid
- if (!!m_context.widgetConfig.guid) {
- uiApp.setExtraid(*m_context.widgetConfig.guid);
+ if (!!m_jobContext->m_installerContext.widgetConfig.guid) {
+ uiApp.setExtraid(*m_jobContext->m_installerContext.widgetConfig.guid);
} else {
if (!appid.empty()) {
uiApp.setExtraid(DPL::String(L"http://") + appid);
//type
uiApp.setType(DPL::FromASCIIString("webapp"));
manifest.setType(L"wgt");
+
+ //mainapp
+ uiApp.setMainapp(true);
}
void TaskManifestFile::generateWidgetName(Manifest & manifest,
bool defaultIconSaved = false;
DPL::OptionalString defaultLocale =
- m_context.widgetConfig.configInfo.defaultlocale;
+ m_jobContext->m_installerContext.widgetConfig.configInfo.defaultlocale;
std::vector<Locale> generatedLocales;
WrtDB::WidgetRegisterInfo::LocalizedIconList & icons =
- m_context.widgetConfig.localizationData.icons;
+ m_jobContext->m_installerContext.widgetConfig.localizationData.icons;
for (WrtDB::WidgetRegisterInfo::LocalizedIconList::const_iterator
icon = icons.begin();
FOREACH(locale, icon->availableLocales)
{
DPL::String tmp = (icon->isSmall ? L"small_" : L"") + (*locale);
- if (std::find(generatedLocales.begin(), generatedLocales.end(),
- tmp) != generatedLocales.end())
+ if (std::find(generatedLocales.begin(), generatedLocales.end(), tmp) != generatedLocales.end())
{
_D("Skipping - has that locale - already in manifest");
continue;
} else {
generatedLocales.push_back(tmp);
}
+
DPL::OptionalString tag = getLangTag(*locale); // translate en ->
// en_US etc
if (!tag) {
tag = *locale;
}
- generateWidgetIcon(uiApp, tag, *locale, DPL::Utils::Path(icon->src).Extension(), icon->isSmall, defaultIconSaved);
+ bf::path extension = bf::extension(icon->src);
+ generateWidgetIcon(uiApp, tag, *locale, extension.native(), icon->isSmall, defaultIconSaved);
}
}
if (!!defaultLocale && !defaultIconSaved) {
defaultIconSaved = true;
}
- DPL::Utils::Path
- iconText(m_context.locations->getSharedResourceDir());
- iconText /= (isSmall ? L"small_" : L"") + getIconTargetFilename(language, extension);
+ bf::path iconText(m_jobContext->m_installerContext.locations->getSharedResourceDir());
+ if (bf::exists(iconText)) {
+ if (isSmall) {
+ iconText /= bf::path("small_");
+ }
+ iconText /= getIconTargetFilename(language, extension);
- if (!locale.empty()) {
- uiApp.addIcon(IconType(DPL::FromUTF8String(iconText.Fullpath()), locale, isSmall));
+ if (!locale.empty()) {
+ uiApp.addIcon(IconType(DPL::FromUTF8String(iconText.native()), locale, isSmall));
+ } else {
+ uiApp.addIcon(IconType(DPL::FromUTF8String(iconText.native()), isSmall));
+ }
+ _D("Icon file : %s", iconText.c_str());
+ m_jobContext->SendProgressIconPath(iconText.native());
} else {
- uiApp.addIcon(IconType(DPL::FromUTF8String(iconText.Fullpath()), isSmall));
+ _E("%s path does not exist!",iconText.c_str());
}
-
- _D("Icon file : %s", iconText.Fullpath().c_str());
- m_context.job->SendProgressIconPath(iconText.Fullpath());
}
void TaskManifestFile::setWidgetDescription(Manifest & manifest)
{
- FOREACH(localizedData, m_context.widgetConfig.configInfo.localizedDataSet)
+ FOREACH(localizedData, m_jobContext->m_installerContext.widgetConfig.configInfo.localizedDataSet)
{
Locale i = localizedData->first;
DPL::OptionalString tag = getLangTag(i); // translate en -> en_US etc
void TaskManifestFile::setWidgetManifest(Manifest & manifest)
{
- manifest.setPackage(m_context.widgetConfig.tzPkgid);
+ manifest.setPackage(m_jobContext->m_installerContext.widgetConfig.tzPkgid);
- if (!!m_context.widgetConfig.version) {
- manifest.setVersion(*m_context.widgetConfig.version);
+ if (!!m_jobContext->m_installerContext.widgetConfig.version) {
+ manifest.setVersion(*(m_jobContext->m_installerContext).widgetConfig.version);
}
- DPL::String email = (!!m_context.widgetConfig.configInfo.authorEmail ?
- *m_context.widgetConfig.configInfo.authorEmail : L"");
- DPL::String href = (!!m_context.widgetConfig.configInfo.authorHref ?
- *m_context.widgetConfig.configInfo.authorHref : L"");
- DPL::String name = (!!m_context.widgetConfig.configInfo.authorName ?
- *m_context.widgetConfig.configInfo.authorName : L"");
+ DPL::String email = (!!m_jobContext->m_installerContext.widgetConfig.configInfo.authorEmail ?
+ *(m_jobContext->m_installerContext).widgetConfig.configInfo.authorEmail : L"");
+ DPL::String href = (!!m_jobContext->m_installerContext.widgetConfig.configInfo.authorHref ?
+ *(m_jobContext->m_installerContext).widgetConfig.configInfo.authorHref : L"");
+ DPL::String name = (!!m_jobContext->m_installerContext.widgetConfig.configInfo.authorName ?
+ *(m_jobContext->m_installerContext).widgetConfig.configInfo.authorName : L"");
manifest.addAuthor(Author(email, href, L"", name));
- if (!m_context.callerPkgId.empty()) {
- manifest.setStoreClientId(m_context.callerPkgId);
+ if (!m_jobContext->m_installerContext.callerPkgId.empty()) {
+ manifest.setStoreClientId(m_jobContext->m_installerContext.callerPkgId);
}
// set csc path
- if (!m_context.mode.cscPath.empty()) {
- manifest.setCscPath(DPL::FromUTF8String(m_context.mode.cscPath));
+ if (!m_jobContext->m_installerContext.mode.cscPath.empty()) {
+ manifest.setCscPath(DPL::FromUTF8String(m_jobContext->m_installerContext.mode.cscPath));
}
+
+ // set api-version(required_version)
+ if (!!m_jobContext->m_installerContext.widgetConfig.configInfo.tizenMinVersionRequired) {
+ manifest.setApiVersion(*m_jobContext->m_installerContext.widgetConfig.configInfo.tizenMinVersionRequired);
+ }
+
+ manifest.setSupportDisable(m_jobContext->m_installerContext.mode.disable);
+
+#if ENABLE(INSTALL_LOCATION)
+ InstallLocationType location;
+ switch(m_jobContext->m_installerContext.mode.location) {
+ case InstallMode::Location::INTERNAL:
+ location = L"internal-only";
+ break;
+ case InstallMode::Location::EXTERNAL:
+ location = L"prefer-external";
+ break;
+ default:
+ location = L"auto";
+ break;
+ }
+ manifest.setInstallLocation(location);
+#endif
}
void TaskManifestFile::setWidgetOtherInfo(UiApplication & uiApp)
{
- FOREACH(it, m_context.widgetConfig.configInfo.settingsList)
+ FOREACH(it, m_jobContext->m_installerContext.widgetConfig.configInfo.settingsList)
{
if (!strcmp(DPL::ToUTF8String(it->m_name).c_str(), STR_NODISPLAY)) {
if (!strcmp(DPL::ToUTF8String(it->m_value).c_str(), STR_TRUE)) {
}
}
}
+
+ WrtDB::ConfigParserData::BackgroundCategoryList backgroundCategoryList =
+ m_jobContext->m_installerContext.widgetConfig.configInfo.backgroundCategoryList;
+ if (!backgroundCategoryList.empty()) {
+ FOREACH(it, backgroundCategoryList) {
+ uiApp.addBackgroundCategory(*it);
+ }
+ }
+
//TODO
//There is no "X-TIZEN-PackageType=wgt"
//There is no X-TIZEN-PackageID in manifest "X-TIZEN-PackageID=" <<
void TaskManifestFile::setAppControlsInfo(UiApplication & uiApp)
{
WrtDB::ConfigParserData::AppControlInfoList appControlList =
- m_context.widgetConfig.configInfo.appControlList;
+ m_jobContext->m_installerContext.widgetConfig.configInfo.appControlList;
if (appControlList.empty()) {
_D("Widget doesn't contain app control");
void TaskManifestFile::setAppCategory(UiApplication &uiApp)
{
WrtDB::ConfigParserData::CategoryList categoryList =
- m_context.widgetConfig.configInfo.categoryList;
+ m_jobContext->m_installerContext.widgetConfig.configInfo.categoryList;
+#ifdef DEVICE_PROFILE_WEARABLE
bool hasPredefinedCategory = false;
FOREACH(it, categoryList) {
if (!(*it).empty()) {
uiApp.addAppCategory(*it);
- if (DPL::ToUTF8String(*it) == STR_CATEGORY_WATCH_CLOCK) {
+ if ((DPL::ToUTF8String(*it) == STR_CATEGORY_WEARABLE_CLOCK) ||
+ (DPL::ToUTF8String(*it) == STR_CATEGORY_WATCH_CLOCK)) {
// in case of idle clock,
// nodisplay should be set to true
uiApp.setNodisplay(true);
uiApp.setTaskmanage(false);
hasPredefinedCategory = true;
}
-#ifdef IME_ENABLED
- else if (DPL::ToUTF8String(*it) == STR_CATEGORY_IME) {
- uiApp.setNodisplay(true);
- uiApp.setTaskmanage(false);
- hasPredefinedCategory = true;
- }
-#endif
-#ifdef SERVICE_ENABLED
- else if (DPL::ToUTF8String(*it) == STR_CATEGORY_SERVICE) {
- //uiApp.setNodisplay(true);
- //uiApp.setTaskmanage(false);
- hasPredefinedCategory = true;
- }
-#endif
- else if (DPL::ToUTF8String(*it) == STR_CATEGORY_WATCH_APP) {
+ if (DPL::ToUTF8String(*it) == STR_CATEGORY_WATCH_APP) {
hasPredefinedCategory = true;
}
}
}
-
// Tizen W feature
// Add default app category (watch_app) except for watch_clock
if(!hasPredefinedCategory) {
uiApp.addAppCategory(DPL::FromASCIIString(STR_CATEGORY_WATCH_APP));
}
}
+#else
+ if (categoryList.empty()) {
+ _D("Widget doesn't contain application category");
+ return;
+ }
+#endif
+
+ FOREACH(it, categoryList) {
+ if (!(*it).empty()) {
+#ifndef DEVICE_PROFILE_WEARABLE
+ uiApp.addAppCategory(*it);
+#endif
+ if (DPL::ToUTF8String(*it) == STR_CATEGORY_FONT) {
+ uiApp.setNodisplay(true);
+ uiApp.setTaskmanage(false);
+ }
+ if (DPL::ToUTF8String(*it) == STR_CATEGORY_TTS) {
+ uiApp.setNodisplay(true);
+ uiApp.setTaskmanage(false);
+ }
+#ifdef IME_ENABLED
+ if (DPL::ToUTF8String(*it) == STR_CATEGORY_IME) {
+ uiApp.setNodisplay(true);
+ uiApp.setTaskmanage(false);
+ }
+#endif
+ }
+ }
}
void TaskManifestFile::setMetadata(UiApplication &uiApp)
{
WrtDB::ConfigParserData::MetadataList metadataList =
- m_context.widgetConfig.configInfo.metadataList;
+ m_jobContext->m_installerContext.widgetConfig.configInfo.metadataList;
if (metadataList.empty()) {
_D("Web application doesn't contain metadata");
}
}
-#ifdef DBOX_ENABLED
+#if USE(WEB_PROVIDER)
void TaskManifestFile::setLiveBoxInfo(Manifest& manifest)
{
ConfigParserData::LiveboxList& liveboxList =
- m_context.widgetConfig.configInfo.m_livebox;
+ m_jobContext->m_installerContext.widgetConfig.configInfo.m_livebox;
if (liveboxList.empty()) {
_D("no livebox");
_D("setLiveBoxInfo");
LiveBoxInfo liveBox;
WrtDB::ConfigParserData::OptionalLiveboxInfo ConfigInfo = *it;
- DPL::String appid = m_context.widgetConfig.tzAppid;
+ DPL::String appid = m_jobContext->m_installerContext.widgetConfig.tzAppid;
if (ConfigInfo->m_liveboxId != L"") {
liveBox.setLiveboxId(ConfigInfo->m_liveboxId);
}
DPL::String defaultLocale =
- DPL::FromUTF8String(m_context.locations->getPackageInstallationDir()) +
+ DPL::FromUTF8String(m_jobContext->m_installerContext.locations->getPackageInstallationDir()) +
DPL::String(L"/res/wgt/");
if (ConfigInfo->m_icon != L"") {
DPL::String icon =
- DPL::FromUTF8String(m_context.locations->getSharedDataDir()) +
+ DPL::FromUTF8String(m_jobContext->m_installerContext.locations->getSharedDataDir()) +
DPL::String(L"/") +
ConfigInfo->m_liveboxId + DPL::String(L".icon.png");
liveBox.setIcon(icon);
std::string boxType;
if (ConfigInfo->m_type == L"") {
// in case of default livebox
- boxType = web_provider_livebox_get_default_type();
+ boxType = web_provider_widget_get_default_type();
} else {
boxType = DPL::ToUTF8String(ConfigInfo->m_type);
}
FOREACH(it, boxSizeList) {
if (!(*it).m_preview.empty()) {
(*it).m_preview =
- DPL::FromUTF8String(m_context.locations->getSharedDataDir()) +
+ DPL::FromUTF8String(m_jobContext->m_installerContext.locations->getSharedDataDir()) +
DPL::String(L"/") +
ConfigInfo->m_liveboxId + DPL::String(L".") +
(*it).m_size + DPL::String(L".preview.png");
void TaskManifestFile::setAccount(Manifest& manifest)
{
WrtDB::ConfigParserData::AccountProvider account =
- m_context.widgetConfig.configInfo.accountProvider;
+ m_jobContext->m_installerContext.widgetConfig.configInfo.accountProvider;
AccountProviderType provider;
} else {
provider.multiAccount = L"false";
}
- provider.appid = m_context.widgetConfig.tzAppid;
+ provider.appid = m_jobContext->m_installerContext.widgetConfig.tzAppid;
FOREACH(it, account.m_iconSet) {
std::pair<DPL::String, DPL::String> icon;
icon.first = L"account-small";
}
- // account manifest requires absolute path for icon
- // /opt/apps/[package]/shared/res/[icon_path]
- icon.second = DPL::FromUTF8String(m_context.locations->getSharedResourceDir()) +
- DPL::String(L"/") +
- it->second;
+ // account manifest requires icon file name
+ icon.second = it->second;
provider.icon.push_back(icon);
}
void TaskManifestFile::setPrivilege(Manifest& manifest)
{
WrtDB::ConfigParserData::PrivilegeList privileges =
- m_context.widgetConfig.configInfo.privilegeList;
+ m_jobContext->m_installerContext.widgetConfig.configInfo.privilegeList;
PrivilegeType privilege;
void TaskManifestFile::StartStep()
{
- LOGD("--------- <TaskManifestFile> : START ----------");
+ LOGI("--------- <TaskManifestFile> : START ----------");
}
void TaskManifestFile::EndStep()
{
- LOGD("--------- <TaskManifestFile> : END ----------");
+ LOGI("--------- <TaskManifestFile> : END ----------");
}
} //namespace WidgetInstall
projects / framework / web / wrt-installer.git / blobdiff