* @version 1.0
* @brief Implementation file for installer task widget config
*/
-#include <string>
+
#include <sstream>
-#include <dpl/foreach.h>
+#include <string>
+#include <sys/stat.h>
+#include <dirent.h>
+
#include <dpl/errno_string.h>
-#include <dpl/wrt-dao-rw/feature_dao.h>
-#include <dpl/wrt-dao-ro/global_config.h>
+#include <dpl/foreach.h>
+#include <dpl/localization/w3c_file_localization.h>
+#include <dpl/singleton_impl.h>
+#include <dpl/utils/mime_type_utils.h>
+#include <dpl/utils/wrt_global_settings.h>
#include <dpl/utils/wrt_utility.h>
-#include <root_parser.h>
-#include <widget_parser.h>
-#include <parser_runner.h>
+#include <dpl/wrt-dao-ro/global_config.h>
+#include <dpl/wrt-dao-rw/feature_dao.h>
+
#include <libiriwrapper.h>
-#include <widget_install/task_widget_config.h>
+#include <parser_runner.h>
+#include <root_parser.h>
+
#include <widget_install/job_widget_install.h>
-#include <widget_install/widget_install_errors.h>
+#include <widget_install/task_widget_config.h>
#include <widget_install/widget_install_context.h>
-#include <dpl/utils/file_utils.h>
-#include <dpl/utils/mime_type_utils.h>
-#include <sys/stat.h>
-#include <dpl/utils/wrt_global_settings.h>
+#include <widget_install/widget_install_errors.h>
+#include <widget_parser.h>
namespace { // anonymous
-const WidgetHandle WIDGET_HANDLE_START_VALUE = 1000;
-const DPL::String WIDGET_HEAD = DPL::FromUTF8String("Widget information");
-const std::string OK_BUTTON_LABEL = "OK";
-const std::string CANCEL_BUTTON_LABEL = "Cancel";
const DPL::String BR = DPL::FromUTF8String("<br>");
-const DPL::String DOUBLE_BR = DPL::FromUTF8String("<br><br>");
-const DPL::String FEATURE_HEAD = DPL::FromUTF8String("Feature information");
-const DPL::String WIDGET_NOT_COMPATIBLE = DPL::FromUTF8String("This widget is "
- "not compatible with WRT. Do you want install it anyway?");
-} // namespace anonymous
+const std::string WIDGET_NOT_COMPATIBLE = "This widget is "
+ "not compatible with WRT.<br><br>";
+const std::string QUESTION = "Do you want to install it anyway?";
+
+const char *const DEFAULT_LANGUAGE = "default";
+
+const char *const WRT_WIDGET_CONFIG_FILE_NAME = "config.xml";
+
+const std::string WINDGET_INSTALL_NETWORK_ACCESS = "network access";
+}
namespace Jobs {
namespace WidgetInstall {
void InstallerTaskWidgetPopupData::PopupData::addWidgetInfo(
- const DPL::String &head,
- const DPL::String &info)
+ const DPL::String &info)
{
- widgetInfo += head;
- widgetInfo += DOUBLE_BR;
- widgetInfo += info;
- widgetInfo += BR;
+ widgetInfo = info;
}
TaskWidgetConfig::TaskWidgetConfig(InstallerContext& installContext) :
DPL::TaskDecl<TaskWidgetConfig>(this),
- m_installContext(installContext),
- m_installCancel(false)
+ WidgetInstallPopup(installContext),
+ m_installContext(installContext)
{
AddStep(&TaskWidgetConfig::StepProcessConfigurationFile);
AddStep(&TaskWidgetConfig::ReadLocaleFolders);
AddStep(&TaskWidgetConfig::ProcessLocalizedStartFiles);
+ AddStep(&TaskWidgetConfig::ProcessBackgroundPageFile);
AddStep(&TaskWidgetConfig::ProcessLocalizedIcons);
+ AddStep(&TaskWidgetConfig::ProcessWidgetInstalledPath);
AddStep(&TaskWidgetConfig::StepVerifyFeatures);
+ AddStep(&TaskWidgetConfig::StepCheckMinVersionInfo);
- //in case of tests, no popups are shown
- if (GlobalSettings::GetPopupsEnabledFlag()) {
+ if (!GlobalSettings::TestModeEnabled() && !m_installContext.m_quiet) {
+ AddStep(
+ &TaskWidgetConfig::
+ StepCancelWidgetInstallationAfterVerifyFeatures);
AddStep(&TaskWidgetConfig::StepShowWidgetInfo);
AddStep(&TaskWidgetConfig::StepCancelWidgetInstallation);
- AddStep(&TaskWidgetConfig::StepCheckMinVersionInfo);
AddStep(&TaskWidgetConfig::StepCancelWidgetInstallationAfterMinVersion);
+ AddStep(&TaskWidgetConfig::StepDeletePopupWin);
}
}
{
Try
{
- WidgetConfigurationManagerSingleton::Instance().processFile(
- m_installContext.tempWidgetPath,
- m_installContext.widgetConfig);
+ std::string path = m_installContext.locations->getConfigurationDir();
+ LogInfo("path: " << path);
+
+ processFile(path, m_installContext.widgetConfig);
}
- Catch(WidgetConfigurationManager::Exception::ProcessFailed)
+ Catch(Exception::ConfigParseFailed)
{
LogError("Parsing failed.");
ReThrow(Exceptions::WidgetConfigFileInvalid);
}
- Try
- {
- // To get widget type for distribute WAC, TIZEN WebApp
- setApplicationType();
- }
- Catch(WidgetConfigurationManager::Exception::ProcessFailed)
- {
- LogError("Config.xml has more than one namespace");
- ReThrow(Exceptions::WidgetConfigFileInvalid);
- }
- m_installContext.job->SetProgressFlag(true);
m_installContext.job->UpdateProgress(
InstallerContext::INSTALL_WIDGET_CONFIG1,
- "Parsing was suscessfull");
+ "Parse elements of configuration file and save them");
}
void TaskWidgetConfig::ReadLocaleFolders()
//Adding default locale
m_localeFolders.insert(L"");
- std::string localePath = m_installContext.tempWidgetPath + "/locales";
+ std::string localePath =
+ m_installContext.locations->getConfigurationDir() + "/locales";
DIR* localeDir = opendir(localePath.c_str());
if (!localeDir) {
LogDebug("No /locales directory in the widget package.");
return;
}
- struct dirent* dirent;
+
+
struct stat statStruct;
- do {
- errno = 0;
- if ((dirent = readdir(localeDir))) {
- DPL::String dirName = DPL::FromUTF8String(dirent->d_name);
- std::string absoluteDirName = localePath + "/";
- absoluteDirName += dirent->d_name;
-
- if (stat(absoluteDirName.c_str(), &statStruct) != 0) {
- LogError("stat() failed with " << DPL::GetErrnoString());
- continue;
- }
+ struct dirent dirent;
+ struct dirent *result;
+ int return_code;
+ errno = 0;
+ for (return_code = readdir_r(localeDir, &dirent, &result);
+ result != NULL && return_code == 0;
+ return_code = readdir_r(localeDir, &dirent, &result))
+ {
+ DPL::String dirName = DPL::FromUTF8String(dirent.d_name);
+ std::string absoluteDirName = localePath + "/";
+ absoluteDirName += dirent.d_name;
- if (S_ISDIR(statStruct.st_mode)) {
- //Yes, we ignore current, parent & hidden directories
- if (dirName[0] != L'.') {
- LogDebug("Adding locale directory \"" << dirName << "\"");
- m_localeFolders.insert(dirName);
- }
+ if (stat(absoluteDirName.c_str(), &statStruct) != 0) {
+ LogError("stat() failed with " << DPL::GetErrnoString());
+ continue;
+ }
+
+ if (S_ISDIR(statStruct.st_mode)) {
+ //Yes, we ignore current, parent & hidden directories
+ if (dirName[0] != L'.') {
+ LogDebug("Adding locale directory \"" << dirName << "\"");
+ m_localeFolders.insert(dirName);
}
}
}
- while (dirent);
- if (errno != 0) {
- LogError("readdir() failed with " << DPL::GetErrnoString());
+ if (return_code != 0 || errno != 0) {
+ LogError("readdir_r() failed with " << DPL::GetErrnoString());
}
- if (closedir(localeDir)) {
- LogError("closedir() failed with " << DPL::GetErrnoString());
+ if (-1 == TEMP_FAILURE_RETRY(closedir(localeDir))) {
+ LogError("Failed to close dir: " << localePath << " with error: "
+ << DPL::GetErrnoString());
}
}
ProcessStartFile(S(L"index.svg"), S(L"image/svg+xml"));
ProcessStartFile(S(L"index.xhtml"), S(L"application/xhtml+xml"));
ProcessStartFile(S(L"index.xht"), S(L"application/xhtml+xml"));
- // TODO: (l.wrzosek) we need better check if in current locales widget is valid.
+ // TODO: (l.wrzosek) we need better check if in current locales widget is
+ // valid.
FOREACH(it, m_installContext.widgetConfig.localizationData.startFiles) {
if (it->propertiesForLocales.size() > 0) {
return;
}
void TaskWidgetConfig::ProcessStartFile(const DPL::OptionalString& path,
- const DPL::OptionalString& type,
- const DPL::OptionalString& encoding,
- bool typeForcedInConfig)
+ const DPL::OptionalString& type,
+ const DPL::OptionalString& encoding,
+ bool typeForcedInConfig)
{
using namespace WrtDB;
DPL::String relativePath = pathPrefix + *path;
DPL::String absolutePath = DPL::FromUTF8String(
- m_installContext.tempWidgetPath) + L"/" + relativePath;
+ m_installContext.locations->getConfigurationDir()) + L"/" +
+ relativePath;
// get property data from packaged app
- if (FileUtils::FileExists(absolutePath)) {
+ if (WrtUtilFileExists(DPL::ToUTF8String(absolutePath))) {
WidgetRegisterInfo::StartFileProperties startFileProperties;
if (!!type) {
startFileProperties.type = *type;
} else {
MimeTypeUtils::MimeAttributes attributes =
MimeTypeUtils::getMimeAttributes(
- startFileProperties.type);
+ startFileProperties.type);
if (attributes.count(L"charset") > 0) {
startFileProperties.encoding =
attributes[L"charset"];
} else {
// set property data for hosted start url
// Hosted start url only support TIZEN WebApp
- if (m_installContext.widgetConfig.type ==
- APP_TYPE_TIZENWEBAPP)
+ if (m_installContext.widgetConfig.webAppType ==
+ APP_TYPE_TIZENWEBAPP)
{
- const char *startPath =
- DPL::ToUTF8String(startFileData.path).c_str();
- if (strstr(startPath, "http") == startPath) {
+ std::string startPath = DPL::ToUTF8String(
+ startFileData.path);
+
+ if (strstr(startPath.c_str(),
+ "http") == startPath.c_str())
+ {
WidgetRegisterInfo::StartFileProperties
startFileProperties;
if (!!type) {
}
}
+void TaskWidgetConfig::ProcessBackgroundPageFile()
+{
+ if (!!m_installContext.widgetConfig.configInfo.backgroundPage) {
+ // check whether file exists
+ DPL::String backgroundPagePath = DPL::FromUTF8String(
+ m_installContext.locations->getConfigurationDir()) + L"/" +
+ *m_installContext.widgetConfig.configInfo.backgroundPage;
+ //if no then cancel installation
+ if (!WrtUtilFileExists(DPL::ToUTF8String(backgroundPagePath))) {
+ ThrowMsg(Exceptions::WidgetConfigFileInvalid,
+ L"Given background page file not found in archive");
+ }
+ }
+}
+
void TaskWidgetConfig::ProcessLocalizedIcons()
{
using namespace WrtDB;
ProcessIcon(ConfigParserData::Icon(L"icon.png"));
ProcessIcon(ConfigParserData::Icon(L"icon.gif"));
ProcessIcon(ConfigParserData::Icon(L"icon.jpg"));
- ProcessIcon(ConfigParserData::Icon(
- DPL::FromUTF8String(m_installContext.iconPath)));
FOREACH(i, m_installContext.widgetConfig.configInfo.iconsList)
{
void TaskWidgetConfig::ProcessIcon(const WrtDB::ConfigParserData::Icon& icon)
{
- bool isAnyIconExisted = false;
+ LogInfo("enter");
+ bool isAnyIconValid = false;
//In case a default filename is passed as custom filename in config.xml, we
- //need to keep a set of already processed filenames to avoid icon duplication
+ //need to keep a set of already processed filenames to avoid icon
+ // duplication
//in database.
using namespace WrtDB;
DPL::String relativePath = pathPrefix + icon.src;
DPL::String absolutePath = DPL::FromUTF8String(
- m_installContext.tempWidgetPath) + L"/" + relativePath;
+ m_installContext.locations->getConfigurationDir()) + L"/" +
+ relativePath;
- if (FileUtils::FileExists(absolutePath)) {
- isAnyIconExisted = true;
+ if (WrtUtilFileExists(DPL::ToUTF8String(absolutePath))) {
DPL::String type = MimeTypeUtils::identifyFileMimeType(absolutePath);
if (MimeTypeUtils::isMimeTypeSupportedForIcon(type)) {
+ isAnyIconValid = true;
localesAvailableForIcon.insert(*i);
+ LogInfo("Icon absolutePath :" << absolutePath <<
+ ", assigned locale :" << *i << ", type: " << type);
}
- LogInfo("Icon absolutePath :" << absolutePath <<
- ", assigned locale :" << *i);
}
}
- if(isAnyIconExisted)
- {
+ if (isAnyIconValid) {
WidgetRegisterInfo::LocalizedIcon localizedIcon(icon,
localesAvailableForIcon);
m_installContext.widgetConfig.localizationData.icons.push_back(
}
}
-void TaskWidgetConfig::AnswerCallback(const DPL::Popup::AnswerCallbackData &answer)
+void TaskWidgetConfig::ProcessWidgetInstalledPath()
+{
+ LogDebug("ProcessWidgetInstalledPath");
+ m_installContext.widgetConfig.widgetInstalledPath =
+ DPL::FromUTF8String(
+ m_installContext.locations->getPackageInstallationDir());
+}
+
+void TaskWidgetConfig::StepCancelWidgetInstallationAfterVerifyFeatures()
{
- LogInfo("Callback called");
- if (WRT_POPUP_BUTTON_CANCEL == answer.buttonAnswer) {
- m_installCancel = WRT_POPUP_BUTTON_CANCEL;
+ LogDebug("StepCancelWidgetInstallationAfterVerifyFeatures");
+ if (InfoPopupButton::WRT_POPUP_BUTTON_CANCEL == m_installCancel) {
+ m_installCancel = WRT_POPUP_BUTTON;
+ destroyPopup();
+ ThrowMsg(Exceptions::WidgetConfigFileInvalid, "Widget not allowed");
}
- m_installContext.job->Resume();
}
void TaskWidgetConfig::StepCancelWidgetInstallation()
{
- if (WRT_POPUP_BUTTON_CANCEL == m_installCancel) {
+ if (InfoPopupButton::WRT_POPUP_BUTTON_CANCEL == m_installCancel) {
+ m_installCancel = WRT_POPUP_BUTTON;
+ destroyPopup();
ThrowMsg(Exceptions::NotAllowed, "Widget not allowed");
}
}
void TaskWidgetConfig::StepCancelWidgetInstallationAfterMinVersion()
{
- if (WRT_POPUP_BUTTON_CANCEL == m_installCancel) {
+ if (InfoPopupButton::WRT_POPUP_BUTTON_CANCEL == m_installCancel) {
+ m_installCancel = WRT_POPUP_BUTTON;
+ destroyPopup();
ThrowMsg(Exceptions::NotAllowed, "WRT version incompatible.");
}
}
-void TaskWidgetConfig::PopupCreate()
+void TaskWidgetConfig::createInstallPopup(PopupType type,
+ const std::string &label)
{
m_installContext.job->Pause();
- using namespace DPL::Popup;
- CtrlPopupPtr popup = PopupControllerSingleton::Instance().CreatePopup();
- popup->SetTitle(DPL::ToUTF8String(WIDGET_HEAD));
- popup->Append(new PopupObject::Label(
- DPL::ToUTF8String(m_popupData.widgetInfo)));
- m_popupData.widgetInfo.clear();
- popup->Append(new PopupObject::Button(OK_BUTTON_LABEL,
- WRT_POPUP_BUTTON_OK));
- popup->Append(new PopupObject::Button(CANCEL_BUTTON_LABEL,
- WRT_POPUP_BUTTON_CANCEL));
- ListenForAnswer(popup);
- ShowPopupEvent event(popup, MakeAnswerCallback(
- this,
- &TaskWidgetConfig::
- AnswerCallback), DPL::Event::UNDEFINED_LOOP_HANDLE);
- CONTROLLER_POST_EVENT(PopupController, event);
+ if (m_popup) {
+ destroyPopup();
+ }
+
+ bool ret = createPopup();
+ if (ret) {
+ loadPopup(type, label);
+ showPopup();
+ }
}
-void TaskWidgetConfig::PopupMinVersionConfirmationCreate()
+void TaskWidgetConfig::StepDeletePopupWin()
{
- m_installContext.job->Pause();
- LogDebug("Creating minVersion confirmation popup.");
- using namespace DPL::Popup;
- CtrlPopupPtr popup = PopupControllerSingleton::Instance().CreatePopup();
- popup->SetTitle(DPL::ToUTF8String(WIDGET_HEAD));
- popup->Append(new PopupObject::Label(
- DPL::ToUTF8String(WIDGET_NOT_COMPATIBLE)));
- popup->Append(new PopupObject::Button(OK_BUTTON_LABEL,
- WRT_POPUP_BUTTON_OK));
- popup->Append(new PopupObject::Button(CANCEL_BUTTON_LABEL,
- WRT_POPUP_BUTTON_CANCEL));
- ListenForAnswer(popup);
- ShowPopupEvent event(popup,
- MakeAnswerCallback(this, &TaskWidgetConfig::AnswerCallback),
- DPL::Event::UNDEFINED_LOOP_HANDLE);
- CONTROLLER_POST_EVENT(PopupController, event);
+ destroyPopup();
}
void TaskWidgetConfig::StepShowWidgetInfo()
{
if (!m_popupData.widgetInfo.empty()) {
- PopupCreate();
+ std::string label = DPL::ToUTF8String(m_popupData.widgetInfo);
+ createInstallPopup(PopupType::WIDGET_FEATURE_INFO, label);
m_installContext.job->UpdateProgress(
InstallerContext::INSTALL_WIDGET_CONFIG2,
"Show Widget Info Finished");
void TaskWidgetConfig::StepCheckMinVersionInfo()
{
- if (!isWACVersionCompatible(m_installContext.widgetConfig.minVersion)) {
- PopupMinVersionConfirmationCreate();
- m_installContext.job->UpdateProgress(
- InstallerContext::INSTALL_WIDGET_CONFIG2,
- "Show MinVersion Info Finished");
+ if (!isMinVersionCompatible(
+ m_installContext.widgetConfig.webAppType.appType,
+ m_installContext.widgetConfig.minVersion))
+ {
+ if (!GlobalSettings::TestModeEnabled() && !m_installContext.m_quiet) {
+ LogDebug("Platform version to low - launching");
+ std::string label = WIDGET_NOT_COMPATIBLE + QUESTION;
+ createInstallPopup(PopupType::WIDGET_MIN_VERSION, label);
+ } else {
+ LogError(
+ "Platform version lower than required -> cancelling installation");
+ ThrowMsg(Exceptions::NotAllowed,
+ "Platform version does not meet requirements");
+ }
}
+
+ m_installContext.job->UpdateProgress(
+ InstallerContext::INSTALL_WIDGET_CONFIG2,
+ "Check MinVersion Finished");
}
void TaskWidgetConfig::StepVerifyFeatures()
{
// check feature vender for permission
// WAC, TIZEN WebApp cannot use other feature
- if (!isFeatureAllowed(m_installContext.widgetConfig.type.appType,
+
+ if (!isFeatureAllowed(m_installContext.widgetConfig.webAppType.appType,
it->name))
{
LogInfo("This application type not allowed to use this feature");
ThrowMsg(
Exceptions::WidgetConfigFileInvalid,
"This app type [" <<
- m_installContext.widgetConfig.type.getApptypeToString() <<
+ m_installContext.widgetConfig.webAppType.getApptypeToString()
+ <<
"] cannot be allowed to use [" <<
DPL::ToUTF8String(it->name) + "] feature");
}
if (!WrtDB::FeatureDAOReadOnly::isFeatureInstalled(
- DPL::ToUTF8String(it->name))) {
+ DPL::ToUTF8String(it->name)))
+ {
LogWarning("Feature not found. Checking if required :[" <<
DPL::ToUTF8String(it->name) << "]");
if (it->required) {
- LogWarning(
- "Required Features missing, Installation topped: [" <<
- DPL::ToUTF8String(it->name) << "]");
-
- ThrowMsg(
- Exceptions::WidgetConfigFileInvalid,
- "Widget cannot be installed, required feature is missing:["
- +
- DPL::ToUTF8String(it->name) + "]");
+ /**
+ * WL-3210 The WRT MUST inform the user if a widget cannot be
+ * installed because one or more required features are not
+ * supported.
+ */
+ std::ostringstream os;
+ os <<
+ "Widget cannot be installed, required feature is missing:["
+ << DPL::ToUTF8String(it->name) << "]";
+ if (!GlobalSettings::TestModeEnabled() && !isTizenWebApp()) {
+ std::string label = os.str();
+ createInstallPopup(PopupType::WIDGET_WRONG_FEATURE_INFO,
+ label);
+ }
+ ThrowMsg(Exceptions::WidgetConfigFileInvalid, os.str());
}
} else {
newList.insert(*it);
featureInfo += DPL::ToUTF8String(BR);
}
}
+ if (!data.accessInfoSet.empty()) {
+ featureInfo += WINDGET_INSTALL_NETWORK_ACCESS;
+ featureInfo += DPL::ToUTF8String(BR);
+ }
data.featuresList = newList;
if (!featureInfo.empty()) {
- m_popupData.addWidgetInfo(FEATURE_HEAD,
- DPL::FromUTF8String(featureInfo));
+ m_popupData.addWidgetInfo(DPL::FromUTF8String(featureInfo));
}
m_installContext.job->UpdateProgress(
"Widget Config step2 Finished");
}
-void TaskWidgetConfig::setApplicationType()
-{
- using namespace WrtDB;
- WidgetRegisterInfo* widgetInfo = &(m_installContext.widgetConfig);
- ConfigParserData* configInfo = &(widgetInfo->configInfo);
-
- FOREACH(iterator, configInfo->nameSpaces) {
- LogInfo("namespace = [" << *iterator << "]");
- AppType currentAppType = APP_TYPE_UNKNOWN;
-
- if (*iterator == ConfigurationNamespace::W3CWidgetNamespaceName) {
- continue;
- } else if (*iterator ==
- ConfigurationNamespace::JilWidgetNamespaceName) {
- currentAppType = APP_TYPE_WAC10;
- } else if (
- *iterator ==
- ConfigurationNamespace::WacWidgetNamespaceNameForLinkElement ||
- *iterator ==
- ConfigurationNamespace::WacWidgetNamespaceName)
- {
- currentAppType = APP_TYPE_WAC20;
- } else if (*iterator == ConfigurationNamespace::TizenWebAppNamespaceName) {
- currentAppType = APP_TYPE_TIZENWEBAPP;
- }
-
- if (widgetInfo->type == APP_TYPE_UNKNOWN) {
- widgetInfo->type = currentAppType;
- } else if (widgetInfo->type == currentAppType) {
- continue;
- } else {
- ThrowMsg(Exceptions::WidgetConfigFileInvalid,
- "Config.xml has more than one namespace");
- }
- }
-
- // If there is no define, type set to WAC 2.0
- if (widgetInfo->type == APP_TYPE_UNKNOWN) {
- widgetInfo->type = APP_TYPE_WAC20;
- }
-
- LogInfo("type = [" << widgetInfo->type.getApptypeToString() << "]");
-}
-
bool TaskWidgetConfig::isFeatureAllowed(WrtDB::AppType appType,
DPL::String featureName)
{
LogInfo("FetureName = [" << featureName << "]");
AppType featureType = APP_TYPE_UNKNOWN;
- const char* feature = DPL::ToUTF8String(featureName).c_str();
+ std::string featureStr = DPL::ToUTF8String(featureName);
+ const char* feature = featureStr.c_str();
+
// check prefix of feature name
if (strstr(feature, PluginsPrefix::TIZENPluginsPrefix) == feature) {
// Tizen WebApp feature
}
bool TaskWidgetConfig::parseVersionString(const std::string &version,
- long &majorVersion, long &minorVersion, long µVersion) const
+ long &majorVersion,
+ long &minorVersion,
+ long µVersion) const
{
std::istringstream inputString(version);
inputString >> majorVersion;
return true;
}
-bool TaskWidgetConfig::isWACVersionCompatible(const DPL::OptionalString
- &widgetVersion) const
+bool TaskWidgetConfig::isMinVersionCompatible(
+ WrtDB::AppType appType,
+ const DPL::OptionalString &
+ widgetVersion) const
{
- if (widgetVersion.IsNull() || (*widgetVersion).empty())
- {
+ if (widgetVersion.IsNull() || (*widgetVersion).empty()) {
LogWarning("minVersion attribute is empty. WRT assumes platform "
- "supports this widget.");
- return true;
+ "supports this widget.");
+ return false;
}
//Parse widget version
long majorWidget = 0, minorWidget = 0, microWidget = 0;
if (!parseVersionString(DPL::ToUTF8String(*widgetVersion), majorWidget,
- minorWidget, microWidget)) {
+ minorWidget, microWidget))
+ {
LogWarning("Invalid format of widget version string.");
- return true;
+ return false;
}
//Parse supported version
long majorSupported = 0, minorSupported = 0, microSupported = 0;
- if (!parseVersionString(WrtDB::GlobalConfig::GetWACVersion(),
- majorSupported, minorSupported, microSupported)) {
- LogWarning("Invalid format of WAC version string.");
+ std::string version;
+ if (appType == WrtDB::AppType::APP_TYPE_TIZENWEBAPP) {
+ version = WrtDB::GlobalConfig::GetTizenVersion();
+ } else if (appType == WrtDB::AppType::APP_TYPE_WAC20) {
+ version = WrtDB::GlobalConfig::GetWACVersion();
+ } else {
+ LogWarning("Invaild AppType");
+ return false;
+ }
+
+ if (!parseVersionString(version,
+ majorSupported, minorSupported, microSupported))
+ {
+ LogWarning("Invalid format of platform version string.");
return true;
}
if (majorWidget > majorSupported ||
- minorWidget > minorSupported ||
- microWidget > microSupported) {
+ (majorWidget == majorSupported && minorWidget > minorSupported) ||
+ (majorWidget == majorSupported && minorWidget == minorSupported
+ && microWidget > microSupported))
+ {
LogInfo("Platform doesn't support this widget.");
return false;
}
return true;
}
+bool TaskWidgetConfig::isTizenWebApp() const
+{
+ bool ret = FALSE;
+ if (m_installContext.widgetConfig.webAppType.appType
+ == WrtDB::AppType::APP_TYPE_TIZENWEBAPP)
+ {
+ ret = TRUE;
+ }
+
+ return ret;
+}
+
+bool TaskWidgetConfig::parseConfigurationFileBrowser(
+ WrtDB::ConfigParserData& configInfo,
+ const std::string& _currentPath)
+{
+ ParserRunner parser;
+ Try
+ {
+ parser.Parse(_currentPath, ElementParserPtr(new
+ RootParser<
+ WidgetParser>(
+ configInfo,
+ DPL::FromUTF32String(
+ L"widget"))));
+ }
+ Catch(ElementParser::Exception::Base)
+ {
+ LogError("Invalid widget configuration file!");
+ return false;
+ }
+ return true;
+}
+
+bool TaskWidgetConfig::parseConfigurationFileWidget(
+ WrtDB::ConfigParserData& configInfo,
+ const std::string& _currentPath)
+{
+ ParserRunner parser;
+
+ //TODO: rewrite this madness
+ std::string cfgAbsPath;
+ DIR* dir = NULL;
+
+ dir = opendir(_currentPath.c_str());
+ if (dir == NULL) {
+ return false;
+ }
+ bool has_config_xml = false;
+ struct dirent ptr;
+ struct dirent *result;
+ int return_code;
+ errno = 0;
+
+ //Find configuration file, based on its name
+ for (return_code = readdir_r(dir, &ptr, &result);
+ result != NULL && return_code == 0;
+ return_code = readdir_r(dir, &ptr, &result))
+ {
+ if (ptr.d_type == DT_REG) {
+ if (!strcmp(ptr.d_name, WRT_WIDGET_CONFIG_FILE_NAME)) {
+ std::string dName(ptr.d_name);
+ WrtUtilJoinPaths(cfgAbsPath, _currentPath, dName);
+
+ //Parse widget configuration file
+ LogDebug("Found config: " << cfgAbsPath);
+
+ Try
+ {
+ parser.Parse(cfgAbsPath, ElementParserPtr(new
+ RootParser<
+ WidgetParser>(
+ configInfo,
+ DPL
+ ::
+ FromUTF32String(
+ L"widget"))));
+ }
+ Catch(ElementParser::Exception::Base)
+ {
+ LogError("Invalid widget configuration file!");
+ if (-1 == TEMP_FAILURE_RETRY(closedir(dir))) {
+ LogError(
+ "Failed to close dir: " << _currentPath <<
+ " with error: "
+ << DPL::GetErrnoString());
+ }
+ return false;
+ }
+
+ has_config_xml = true;
+ break;
+ }
+ }
+ }
+ if (errno != 0) {
+ LogError("readdir_r() failed with " << DPL::GetErrnoString());
+ }
+ errno = 0;
+ if (-1 == TEMP_FAILURE_RETRY(closedir(dir))) {
+ LogError("Failed to close dir: " << _currentPath << " with error: "
+ << DPL::GetErrnoString());
+ }
+
+ //We must have config.xml so leaveing if we doesn't
+ if (!has_config_xml) {
+ LogError("Invalid archive");
+ return false;
+ }
+ return true;
+}
+
+bool TaskWidgetConfig::locateAndParseConfigurationFile(
+ const std::string& _currentPath,
+ WrtDB::WidgetRegisterInfo& pWidgetConfigInfo,
+ const std::string& baseFolder)
+{
+ using namespace WrtDB;
+
+ ConfigParserData& configInfo = pWidgetConfigInfo.configInfo;
+
+ // check if this installation from browser, or not.
+ size_t pos = _currentPath.rfind("/");
+ std::ostringstream infoPath;
+ infoPath << _currentPath.substr(pos + 1);
+
+ if (infoPath.str() != WRT_WIDGET_CONFIG_FILE_NAME) {
+ if (_currentPath.empty() || baseFolder.empty()) {
+ return false;
+ }
+ // in case of general installation using wgt archive
+ if (!parseConfigurationFileWidget(configInfo, _currentPath))
+ {
+ return false;
+ }
+ } else {
+ // in case of browser installation
+ if (!parseConfigurationFileBrowser(configInfo, _currentPath))
+ {
+ return false;
+ }
+ }
+
+ if (!fillWidgetConfig(pWidgetConfigInfo, configInfo)) {
+ return false;
+ }
+ return true;
+}
+
+bool TaskWidgetConfig::fillWidgetConfig(
+ WrtDB::WidgetRegisterInfo& pWidgetConfigInfo,
+ WrtDB::ConfigParserData& configInfo)
+{
+ if (!!configInfo.widget_id) {
+ if (!pWidgetConfigInfo.guid) {
+ pWidgetConfigInfo.guid = configInfo.widget_id;
+ } else {
+ if (pWidgetConfigInfo.guid != configInfo.widget_id) {
+ LogError("Invalid archive");
+ return false;
+ }
+ }
+ }
+ if (!!configInfo.tizenAppId) {
+ if (DPL::ToUTF8String(pWidgetConfigInfo.tzAppid).compare(
+ DPL::ToUTF8String(*configInfo.tizenAppId)) < 0)
+ {
+ LogError("Invalid archive - Tizen App ID not same error");
+ return false;
+ }
+ }
+ if (!!configInfo.tizenPkgId) {
+ if (pWidgetConfigInfo.tzPkgid != *configInfo.tizenPkgId) {
+ LogError("Invalid archive - Tizen Pkg ID not same error");
+ return false;
+ }
+ }
+ if (!!configInfo.version) {
+ if (!pWidgetConfigInfo.version) {
+ pWidgetConfigInfo.version = configInfo.version;
+ } else {
+ if (pWidgetConfigInfo.version != configInfo.version) {
+ LogError("Invalid archive");
+ return false;
+ }
+ }
+ }
+ if (!!configInfo.minVersionRequired) {
+ pWidgetConfigInfo.minVersion = configInfo.minVersionRequired;
+ } else if (!!configInfo.tizenMinVersionRequired) {
+ pWidgetConfigInfo.minVersion = configInfo.tizenMinVersionRequired;
+ }
+ return true;
+}
+
+void TaskWidgetConfig::processFile(
+ const std::string& path,
+ WrtDB::WidgetRegisterInfo &
+ widgetConfiguration)
+{
+ if (!locateAndParseConfigurationFile(path, widgetConfiguration,
+ DEFAULT_LANGUAGE))
+ {
+ LogWarning("Widget archive: Failed while parsing config file");
+ ThrowMsg(Exception::ConfigParseFailed, path);
+ }
+}
} //namespace WidgetInstall
} //namespace Jobs