#include <dpl/localization/w3c_file_localization.h>
#include <libiriwrapper.h>
-#include <pkg-manager/pkgmgr_signal.h>
#include <app_manager.h>
#include "root_parser.h"
m_context(context)
{
AddStep(&TaskConfiguration::StartStep);
- AddStep(&TaskConfiguration::PrepareInstallationStep);
+
+ AddStep(&TaskConfiguration::SetupTempDirStep);
+ AddStep(&TaskConfiguration::CheckPackageTypeStep);
+
+ AddStep(&TaskConfiguration::ParseXMLConfigStep);
+
+ AddStep(&TaskConfiguration::TizenIdStep);
+ AddStep(&TaskConfiguration::ApplicationTypeStep);
+ AddStep(&TaskConfiguration::ResourceEncryptionStep);
+ AddStep(&TaskConfiguration::InstallationFSLocationStep);
+
+ AddStep(&TaskConfiguration::DetectUpdateInstallationStep);
+ AddStep(&TaskConfiguration::CheckRDSSupportStep);
+ AddStep(&TaskConfiguration::ConfigureWidgetLocationStep);
+ AddStep(&TaskConfiguration::PkgmgrStartStep);
+
AddStep(&TaskConfiguration::AppendTasklistStep);
+
AddStep(&TaskConfiguration::EndStep);
}
_D("--------- <TaskConfiguration> : END ----------");
}
+void TaskConfiguration::PkgmgrStartStep()
+{
+ pkgMgrInterface()->sendSignal(
+ PKGMGR_PROGRESS_KEY,
+ PKGMGR_START_VALUE);
+}
+
void TaskConfiguration::AppendTasklistStep()
{
if (!m_context.isUpdateMode) {
}
}
-void TaskConfiguration::PrepareInstallationStep()
+std::shared_ptr<PackageManager::IPkgmgrSignal> TaskConfiguration::pkgMgrInterface()
{
- // TODO: (job_install_refactoring) clean up this task
- std::string widgetPath = m_context.requestedPath;
- bool result;
- m_context.needEncryption = false;
- std::string tempDir;
+ return m_context.job->GetInstallerStruct().pkgmgrInterface;
+}
+
+void TaskConfiguration::SetupTempDirStep()
+{
+ _D("widgetPath: %s", m_context.requestedPath.c_str());
+ _D("tempPath: %s", m_tempDir.c_str());
if (m_context.mode.extension == InstallMode::ExtensionType::DIR) {
if (m_context.mode.command ==
InstallMode::Command::REINSTALL) {
tempPathBuilder << WrtDB::GlobalConfig::GetUserInstalledWidgetPath();
tempPathBuilder << WrtDB::GlobalConfig::GetTmpDirPath();
tempPathBuilder << "/";
- tempPathBuilder << widgetPath;
- tempDir = tempPathBuilder.str();
+ tempPathBuilder << m_context.requestedPath;
+ m_tempDir = tempPathBuilder.str();
} else {
- tempDir = widgetPath;
+ m_tempDir = m_context.requestedPath;
}
} else {
- tempDir =
+ m_tempDir =
Jobs::WidgetInstall::createTempPath(
m_context.mode.rootPath ==
InstallMode::RootPath::RO);
- WidgetUnzip wgtUnzip;
- wgtUnzip.unzipWgtFile(widgetPath, tempDir);
+ if(!hasExtension(m_context.requestedPath, XML_EXTENSION)) //unzip everything except xml files
+ {
+ WidgetUnzip wgtUnzip;
+ wgtUnzip.unzipWgtFile(m_context.requestedPath, m_tempDir);
+ }
+ else
+ {
+ _D("From browser installation - unzip is not done");
+ }
}
+}
- _D("widgetPath: %s", widgetPath.c_str());
- _D("tempPath: %s", tempDir.c_str());
-
- m_context.widgetConfig.packagingType =
- checkPackageType(widgetPath, tempDir);
- ConfigParserData configData = getWidgetDataFromXML(
- widgetPath,
- tempDir,
+void TaskConfiguration::ParseXMLConfigStep()
+{
+ m_widgetConfig = getWidgetDataFromXML( //TODO: make one parsing of config.xml
+ m_context.requestedPath, m_tempDir,
m_context.widgetConfig.packagingType,
m_context.mode.command == InstallMode::Command::REINSTALL);
_D("widget packaging type : %d", static_cast<WrtDB::PkgType>(m_context.widgetConfig.packagingType.pkgType));
-
- setTizenId(configData);
- setApplicationType(configData);
- m_context.needEncryption = detectResourceEncryption(configData);
- setInstallLocationType(configData);
- // TODO: (job_install_refactoring) hide this call
- m_context.callerPkgId =
- DPL::FromUTF8String(m_context.job->GetInstallerStruct().pkgmgrInterface->getCallerId());
- _D("Caller Package Id : %s", DPL::ToUTF8String(m_context.callerPkgId).c_str());
-
- // Configure installation
- result = ConfigureInstallation(widgetPath, configData, tempDir);
- // TODO: (job_install_refactoring) hide this call
- m_context.job->GetInstallerStruct().pkgmgrInterface->sendSignal(
- PKGMGR_PROGRESS_KEY,
- PKGMGR_START_VALUE);
-
- m_context.isUpdateMode = result;
}
-void TaskConfiguration::setTizenId(
- const WrtDB::ConfigParserData &configInfo)
+void TaskConfiguration::TizenIdStep()
{
bool shouldMakeAppid = false;
using namespace PackageManager;
- if (!!configInfo.tizenAppId) {
- _D("Setting tizenAppId provided in config.xml: %ls", (*configInfo.tizenAppId).c_str());
- m_context.widgetConfig.tzAppid = *configInfo.tizenAppId;
+
+ if (!!m_widgetConfig.tizenAppId) {
+ _D("Setting tizenAppId provided in config.xml: %s", DPL::ToUTF8String(*m_widgetConfig.tizenAppId).c_str());
+
+ m_context.widgetConfig.tzAppid = *m_widgetConfig.tizenAppId;
//check package id.
- if (!!configInfo.tizenPkgId) {
- _D("Setting tizenPkgId provided in config.xml: %ls", (*configInfo.tizenPkgId).c_str());
- m_context.widgetConfig.tzPkgid = *configInfo.tizenPkgId;
+ if (!!m_widgetConfig.tizenPkgId) {
+ _D("Setting tizenPkgId provided in config.xml: %s", DPL::ToUTF8String(*m_widgetConfig.tizenPkgId).c_str());
+
+ m_context.widgetConfig.tzPkgid = *m_widgetConfig.tizenPkgId;
} else {
- DPL::String appid = *configInfo.tizenAppId;
+ DPL::String appid = *m_widgetConfig.tizenAppId;
if (appid.length() > PACKAGE_ID_LENGTH) {
m_context.widgetConfig.tzPkgid =
appid.substr(0, PACKAGE_ID_LENGTH);
//old version appid only has 10byte random character is able to install for a while.
//this case appid equal pkgid.
m_context.widgetConfig.tzPkgid =
- *configInfo.tizenAppId;
+ *m_widgetConfig.tizenAppId;
shouldMakeAppid = true;
}
}
if (shouldMakeAppid == true) {
DPL::OptionalString name;
- DPL::OptionalString defaultLocale = configInfo.defaultlocale;
+ DPL::OptionalString defaultLocale = m_widgetConfig.defaultlocale;
- FOREACH(localizedData, configInfo.localizedDataSet)
+ FOREACH(localizedData, m_widgetConfig.localizedDataSet)
{
Locale i = localizedData->first;
if (!!defaultLocale) {
if (!name || (regexec(®x, DPL::ToUTF8String(*name).c_str(),
static_cast<size_t>(0), NULL, 0) != REG_NOERROR))
{
- // TODO : (job_install_refactoring) generate name move to wrt-commons
- std::string allowedString("ABCDEFGHIJKLMNOPQRSTUVWXYZ");
+ const std::string allowedString("ABCDEFGHIJKLMNOPQRSTUVWXYZ");
std::ostringstream genName;
struct timeval tv;
gettimeofday(&tv, NULL);
}
// send start signal of pkgmgr
- // TODO: (job_install_refactoring) hide this call
- m_context.job->GetInstallerStruct().pkgmgrInterface->setPkgname(DPL::ToUTF8String(
- m_context.
- widgetConfig.
- tzPkgid));
- _D("Tizen App Id : %ls", m_context.widgetConfig.tzAppid.c_str());
- _D("Tizen Pkg Id : %ls", m_context.widgetConfig.tzPkgid.c_str());
+ pkgMgrInterface()->setPkgname(DPL::ToUTF8String(m_context.widgetConfig.tzPkgid));
+
+ _D("Tizen App Id : %ls", (m_context.widgetConfig.tzAppid).c_str());
+ _D("Tizen Pkg Id : %ls", (m_context.widgetConfig.tzPkgid).c_str());
}
-void TaskConfiguration::configureWidgetLocation(const std::string & widgetPath,
- const std::string& tempPath)
+void TaskConfiguration::ConfigureWidgetLocationStep()
{
m_context.locations =
- WidgetLocation(DPL::ToUTF8String(m_context.widgetConfig.
- tzPkgid),
- widgetPath, tempPath,
+ WidgetLocation(DPL::ToUTF8String(m_context.widgetConfig.tzPkgid),
+ m_context.requestedPath, m_tempDir,
m_context.widgetConfig.packagingType,
m_context.mode.rootPath ==
InstallMode::RootPath::RO,
m_context.locations->registerAppid(
DPL::ToUTF8String(m_context.widgetConfig.tzAppid));
- _D("widgetSource %s", widgetPath.c_str());
+ _D("widgetSource %s", m_context.requestedPath.c_str());
}
-bool TaskConfiguration::ConfigureInstallation(
- const std::string &widgetSource,
- const WrtDB::ConfigParserData &configData,
- const std::string &tempPath)
+void TaskConfiguration::DetectUpdateInstallationStep()
{
- bool result;
-
WidgetUpdateInfo update;
-
// checking installed web application
Try {
// no excpetion means, it isn't update mode
- // TODO: (job_install_refactoring) hide this call/
- m_context.job->GetInstallerStruct().pkgmgrInterface->sendSignal(
- PKGMGR_START_KEY,
- PKGMGR_START_UPDATE);
-
- update = detectWidgetUpdate(configData,
+ update = detectWidgetUpdate(m_widgetConfig,
m_context.widgetConfig.tzAppid);
- result = checkWidgetUpdate(update);
- if (!result) {
- // Already installed TizenAppId. return failed
- ThrowMsg(Jobs::WidgetInstall::Exceptions::PackageAlreadyInstalled,
- "package is already installed");
- }
- if (!checkSupportRDSUpdate(configData)) {
- ThrowMsg(Jobs::WidgetInstall::Exceptions::NotSupportRDSUpdate,
- "RDS update failed");
- }
- result = true;
+ checkWidgetUpdate(update);
+
+ m_context.isUpdateMode = true;
+
+ //if update, notify pkgmgr that this is update
+ pkgMgrInterface()->sendSignal( PKGMGR_START_KEY, PKGMGR_START_UPDATE);
}
Catch(WidgetDAOReadOnly::Exception::WidgetNotExist) {
- // TODO: (job_install_refactoring) hide this call
- m_context.job->GetInstallerStruct().pkgmgrInterface->sendSignal(
- PKGMGR_START_KEY,
- PKGMGR_START_INSTALL);
- result = false;
+ pkgMgrInterface()->sendSignal(PKGMGR_START_KEY, PKGMGR_START_INSTALL);
+
+ m_context.isUpdateMode = false;
if (!validateTizenApplicationID(
m_context.widgetConfig.tzAppid))
"package is already installed");
}
}
+}
- configureWidgetLocation(widgetSource, tempPath);
-
- return result;
+void TaskConfiguration::CheckRDSSupportStep()
+{
+ //update needs RDS support to go ahead
+ if(m_context.isUpdateMode)
+ {
+ if (!checkSupportRDSUpdate(m_widgetConfig)) {
+ ThrowMsg(Jobs::WidgetInstall::Exceptions::NotSupportRDSUpdate,
+ "RDS update failed");
+ }
+ }
}
bool TaskConfiguration::validateTizenApplicationID(
_D("incoming version = '%ls", update.incomingVersion->Raw().c_str());
_D("Tizen AppID = %ls", update.tzAppId.c_str());
- // Check running state
+ // TODO: step Check running state
bool isRunning = false;
int ret =
app_manager_is_running(DPL::ToUTF8String(update.tzAppId).c_str(),
if (APP_MANAGER_ERROR_NONE != ret) {
_E("Fail to get running state");
ThrowMsg(Jobs::WidgetInstall::Exceptions::WidgetRunningError,
- "widget is running");
+ "widget is running");
}
if (true == isRunning) {
if (APP_MANAGER_ERROR_NONE != ret) {
_E("Fail to get app_context");
ThrowMsg(Jobs::WidgetInstall::Exceptions::WidgetRunningError,
- "widget is running");
+ "widget is running");
}
// terminate app_context_h
_E("Fail to terminate running application");
app_context_destroy(appCtx);
ThrowMsg(Jobs::WidgetInstall::Exceptions::WidgetRunningError,
- "widget is running");
+ "widget is running");
} else {
app_context_destroy(appCtx);
// app_manager_terminate_app isn't sync API
if (APP_MANAGER_ERROR_NONE != ret) {
_E("Fail to get running state");
ThrowMsg(Jobs::WidgetInstall::Exceptions::WidgetRunningError,
- "widget is running");
+ "widget is running");
}
if (!isStillRunning) {
break;
if (isStillRunning) {
_E("Fail to terminate running application");
ThrowMsg(Jobs::WidgetInstall::Exceptions::WidgetRunningError,
- "widget is running");
+ "widget is running");
}
_D("terminate application");
}
}
+ //...
m_context.widgetConfig.tzAppid = update.tzAppId;
ThrowMsg(Exceptions::MissingConfig, "Config file not exists");
}
+#ifdef SCHEMA_VALIDATION_ENABLED
+ if(!parser.Validate(configFilePath, WRT_WIDGETS_XML_SCHEMA))
+ {
+ _E("Invalid configuration file - schema validation failed");
+ ThrowMsg(Exceptions::WidgetConfigFileInvalid, "Failed to parse config.xml file");
+ }
+#endif
parser.Parse(configFile,
ElementParserPtr(
new RootParser<WidgetParser>(configInfo,
incomingVersion);
}
-
-WrtDB::PackagingType TaskConfiguration::checkPackageType(
- const std::string &widgetSource,
- const std::string &tempPath)
+void TaskConfiguration::CheckPackageTypeStep()
{
- if (hasExtension(widgetSource, XML_EXTENSION)) {
+ if (hasExtension(m_context.requestedPath, XML_EXTENSION)) {
_D("Hosted app installation");
- return PKG_TYPE_HOSTED_WEB_APP;
+ m_context.widgetConfig.packagingType = PKG_TYPE_HOSTED_WEB_APP;
+ return;
}
- std::string configFile = tempPath + "/" + OSP_MANIFEST_XML;
+ std::string configFile = m_tempDir + "/" + OSP_MANIFEST_XML;
if (WrtUtilFileExists(configFile)) {
- return PKG_TYPE_HYBRID_WEB_APP;
+ m_context.widgetConfig.packagingType = PKG_TYPE_HYBRID_WEB_APP;
+ return;
}
- return PKG_TYPE_NOMAL_WEB_APP;
+ m_context.widgetConfig.packagingType = PKG_TYPE_NOMAL_WEB_APP;
}
-void TaskConfiguration::setApplicationType(
- const WrtDB::ConfigParserData &configInfo)
+void TaskConfiguration::ApplicationTypeStep() //TODO: is this really needed as WAC is not supported?
{
AppType widgetAppType = APP_TYPE_UNKNOWN;
- FOREACH(iterator, configInfo.nameSpaces) {
+ FOREACH(iterator, m_widgetConfig.nameSpaces) {
_D("namespace = [%ls]", (*iterator).c_str());
if (*iterator == ConfigurationNamespace::TizenWebAppNamespaceName) {
_D("type = [%s]", m_context.widgetConfig.webAppType.getApptypeToString().c_str());
}
-bool TaskConfiguration::detectResourceEncryption(
- const WrtDB::ConfigParserData &configData)
-{
- FOREACH(it, configData.settingsList)
+void TaskConfiguration::ResourceEncryptionStep()
+{
+ m_context.needEncryption = false;
+ FOREACH(it, m_widgetConfig.settingsList)
{
if (it->m_name == SETTING_VALUE_ENCRYPTION &&
it->m_value == SETTING_VALUE_ENCRYPTION_ENABLE)
{
_D("resource need encryption");
- return true;
+ m_context.needEncryption = true;
}
}
- return false;
}
-void TaskConfiguration::setInstallLocationType(
- const WrtDB::ConfigParserData & configData)
+void TaskConfiguration::InstallationFSLocationStep()
{
m_context.locationType = INSTALL_LOCATION_TYPE_NOMAL;
if (m_context.mode.installTime != InstallMode::InstallTime::PRELOAD) {
- FOREACH(it, configData.settingsList) {
+ FOREACH(it, m_widgetConfig.settingsList) {
if (it->m_name == SETTING_VALUE_INSTALLTOEXT_NAME &&
it->m_value ==
SETTING_VALUE_INSTALLTOEXT_PREPER_EXT)
* limitations under the License.
*/
/*
- * @file task_widget_config.cpp
+ * @file task_process_config.cpp
* @author Przemyslaw Dobrowolski (p.dobrowolsk@samsung.com)
* @version 1.0
* @brief Implementation file for installer task widget config
#include <root_parser.h>
#include <widget_install/job_widget_install.h>
-#include <widget_install/task_widget_config.h>
+#include <widget_install/task_process_config.h>
#include <widget_install/widget_install_context.h>
#include <widget_install/widget_install_errors.h>
#include <widget_parser.h>
const DPL::String BR = DPL::FromUTF8String("<br>");
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";
namespace Jobs {
namespace WidgetInstall {
-TaskWidgetConfig::TaskWidgetConfig(InstallerContext& installContext) :
- DPL::TaskDecl<TaskWidgetConfig>(this),
+TaskProcessConfig::TaskProcessConfig(InstallerContext& installContext) :
+ DPL::TaskDecl<TaskProcessConfig>(this),
m_installContext(installContext)
{
- AddStep(&TaskWidgetConfig::StartStep);
- AddStep(&TaskWidgetConfig::StepProcessConfigurationFile);
- AddStep(&TaskWidgetConfig::ReadLocaleFolders);
- AddStep(&TaskWidgetConfig::ProcessLocalizedStartFiles);
- AddStep(&TaskWidgetConfig::ProcessBackgroundPageFile);
- AddStep(&TaskWidgetConfig::ProcessLocalizedIcons);
- AddStep(&TaskWidgetConfig::ProcessWidgetInstalledPath);
- AddStep(&TaskWidgetConfig::ProcessAppControlInfo);
- AddStep(&TaskWidgetConfig::ProcessSecurityModel);
- AddStep(&TaskWidgetConfig::StepVerifyFeatures);
- AddStep(&TaskWidgetConfig::StepVerifyLivebox);
- AddStep(&TaskWidgetConfig::StepCheckMinVersionInfo);
- AddStep(&TaskWidgetConfig::EndStep);
+ AddStep(&TaskProcessConfig::StartStep);
+ AddStep(&TaskProcessConfig::ReadLocaleFolders);
+ AddStep(&TaskProcessConfig::StepProcessConfigurationFile);
+ AddStep(&TaskProcessConfig::ProcessLocalizedStartFiles);
+ AddStep(&TaskProcessConfig::ProcessBackgroundPageFile);
+ AddStep(&TaskProcessConfig::ProcessLocalizedIcons);
+ AddStep(&TaskProcessConfig::ProcessWidgetInstalledPath);
+ AddStep(&TaskProcessConfig::ProcessAppControlInfo);
+ AddStep(&TaskProcessConfig::ProcessSecurityModel);
+ AddStep(&TaskProcessConfig::StepVerifyFeatures);
+ AddStep(&TaskProcessConfig::StepVerifyLivebox);
+ AddStep(&TaskProcessConfig::StepCheckMinVersionInfo);
+ AddStep(&TaskProcessConfig::EndStep);
}
-void TaskWidgetConfig::StepProcessConfigurationFile()
+void TaskProcessConfig::StepProcessConfigurationFile()
{
Try
{
"Parse elements of configuration file and save them");
}
-void TaskWidgetConfig::ReadLocaleFolders()
+void TaskProcessConfig::ReadLocaleFolders()
{
_D("Reading locale");
//Adding default locale
}
}
-void TaskWidgetConfig::ProcessLocalizedStartFiles()
+void TaskProcessConfig::ProcessLocalizedStartFiles()
{
typedef DPL::String S;
ProcessStartFile(
"The Widget has no valid start file");
}
-void TaskWidgetConfig::ProcessStartFile(const DPL::OptionalString& path,
+void TaskProcessConfig::ProcessStartFile(const DPL::OptionalString& path,
const DPL::OptionalString& type,
const DPL::OptionalString& encoding,
bool typeForcedInConfig)
}
}
-void TaskWidgetConfig::ProcessBackgroundPageFile()
+void TaskProcessConfig::ProcessBackgroundPageFile()
{
if (!!m_installContext.widgetConfig.configInfo.backgroundPage) {
// check whether file exists
}
}
-void TaskWidgetConfig::ProcessLocalizedIcons()
+void TaskProcessConfig::ProcessLocalizedIcons()
{
using namespace WrtDB;
FOREACH(i, m_installContext.widgetConfig.configInfo.iconsList)
ProcessIcon(ConfigParserData::Icon(L"icon.jpg"));
}
-void TaskWidgetConfig::ProcessIcon(const WrtDB::ConfigParserData::Icon& icon)
+void TaskProcessConfig::ProcessIcon(const WrtDB::ConfigParserData::Icon& icon)
{
_D("enter");
bool isAnyIconValid = false;
}
}
-void TaskWidgetConfig::ProcessWidgetInstalledPath()
+void TaskProcessConfig::ProcessWidgetInstalledPath()
{
_D("ProcessWidgetInstalledPath");
m_installContext.widgetConfig.widgetInstalledPath =
m_installContext.locations->getPackageInstallationDir());
}
-void TaskWidgetConfig::ProcessAppControlInfo()
+void TaskProcessConfig::ProcessAppControlInfo()
{
_D("ProcessAppControlInfo");
using namespace WrtDB;
}
}
-void TaskWidgetConfig::ProcessSecurityModel()
+void TaskProcessConfig::ProcessSecurityModel()
{
// 0104. If the "required_version" specified in the Web Application's
// configuration is 2.2 or higher and if the Web Application's
"Finished process security model");
}
-void TaskWidgetConfig::StepCheckMinVersionInfo()
+void TaskProcessConfig::StepCheckMinVersionInfo()
{
if (!isMinVersionCompatible(
m_installContext.widgetConfig.webAppType.appType,
"Check MinVersion Finished");
}
-void TaskWidgetConfig::StepVerifyFeatures()
+void TaskProcessConfig::StepVerifyFeatures()
{
using namespace WrtDB;
ConfigParserData &data = m_installContext.widgetConfig.configInfo;
"Widget Config step2 Finished");
}
-void TaskWidgetConfig::StepVerifyLivebox()
+void TaskProcessConfig::StepVerifyLivebox()
{
using namespace WrtDB;
ConfigParserData &data = m_installContext.widgetConfig.configInfo;
}
}
-bool TaskWidgetConfig::isFeatureAllowed(WrtDB::AppType appType,
+bool TaskProcessConfig::isFeatureAllowed(WrtDB::AppType appType,
DPL::String featureName)
{
using namespace WrtDB;
return false;
}
-bool TaskWidgetConfig::parseVersionString(const std::string &version,
+bool TaskProcessConfig::parseVersionString(const std::string &version,
long &majorVersion,
long &minorVersion,
long µVersion) const
return true;
}
-bool TaskWidgetConfig::isMinVersionCompatible(
+bool TaskProcessConfig::isMinVersionCompatible(
WrtDB::AppType appType,
const DPL::OptionalString &
widgetVersion) const
return true;
}
-bool TaskWidgetConfig::isTizenWebApp() const
+bool TaskProcessConfig::isTizenWebApp() const
{
bool ret = FALSE;
if (m_installContext.widgetConfig.webAppType.appType
return ret;
}
-bool TaskWidgetConfig::parseConfigurationFileBrowser(
+bool TaskProcessConfig::parseConfigurationFileBrowser(
WrtDB::ConfigParserData& configInfo,
const std::string& _currentPath)
{
return true;
}
-bool TaskWidgetConfig::parseConfigurationFileWidget(
+bool TaskProcessConfig::parseConfigurationFileWidget(
WrtDB::ConfigParserData& configInfo,
const std::string& _currentPath)
{
}
}
-bool TaskWidgetConfig::locateAndParseConfigurationFile(
+bool TaskProcessConfig::locateAndParseConfigurationFile(
const std::string& _currentPath,
WrtDB::WidgetRegisterInfo& pWidgetConfigInfo,
const std::string& baseFolder)
return true;
}
-bool TaskWidgetConfig::fillWidgetConfig(
+bool TaskProcessConfig::fillWidgetConfig(
WrtDB::WidgetRegisterInfo& pWidgetConfigInfo,
WrtDB::ConfigParserData& configInfo)
{
return true;
}
-void TaskWidgetConfig::processFile(
+void TaskProcessConfig::processFile(
const std::string& path,
WrtDB::WidgetRegisterInfo &
widgetConfiguration)
}
}
-void TaskWidgetConfig::StartStep()
+void TaskProcessConfig::StartStep()
{
- _D("---------- <TaskWidgetConfig> : START ----------");
+ _D("--------- <TaskProcessConfig> : START ----------");
}
-void TaskWidgetConfig::EndStep()
+void TaskProcessConfig::EndStep()
{
- _D("---------- <TaskWidgetConfig> : END ----------");
+ _D("--------- <TaskProcessConfig> : END ----------");
}
+
} //namespace WidgetInstall
} //namespace Jobs
projects / framework / web / wrt-installer.git / commitdiff