DPL::TaskDecl<TaskAceCheck>(this),
m_context(context)
{
+ AddStep(&TaskAceCheck::StartStep);
AddStep(&TaskAceCheck::StepPrepareForAce);
AddStep(&TaskAceCheck::StepAceCheck);
AddStep(&TaskAceCheck::StepProcessAceResponse);
AddStep(&TaskAceCheck::StepCheckAceResponse);
+ AddStep(&TaskAceCheck::EndStep);
}
void TaskAceCheck::StepPrepareForAce()
}
}
LogDebug("Installation continues...");
+}
+
+void TaskAceCheck::StartStep()
+{
+ LogDebug("--------- <TaskAceCheck> : START ----------");
+}
+void TaskAceCheck::EndStep()
+{
m_context.job->UpdateProgress(
InstallerContext::INSTALL_ACE_CHECK,
"Widget Access Control Check Finished");
+
+ LogDebug("--------- <TaskAceCheck> : END ----------");
}
} //namespace WidgetInstall
} //namespace Jobs
void StepProcessAceResponse();
void StepCheckAceResponse();
+ void StartStep();
+ void EndStep();
+
public:
TaskAceCheck(InstallerContext& context);
};
m_context(context),
m_pkgHandle(NULL)
{
+ AddStep(&TaskCertificates::StartStep);
AddStep(&TaskCertificates::StepSetCertiInfo);
+ AddStep(&TaskCertificates::EndStep);
AddAbortStep(&TaskCertificates::StepAbortCertiInfo);
}
if (pkgmgr_installer_destroy_certinfo_set_handle(m_pkgHandle) < 0) {
LogError("pkgmgrInstallerDestroyCertinfoSetHandle fail");
}
-
- m_context.job->UpdateProgress(
- InstallerContext::INSTALL_SET_CERTINFO,
- "Save certinfo to pkgmgr");
}
void TaskCertificates::SetCertiInfo(CertificateSource source)
LogError("pkgmgr_installer_delete_certinfo fail");
}
}
+
+void TaskCertificates::StartStep()
+{
+ LogDebug("--------- <TaskCertificates> : START ----------");
+}
+
+void TaskCertificates::EndStep()
+{
+ m_context.job->UpdateProgress(
+ InstallerContext::INSTALL_SET_CERTINFO,
+ "Save certinfo to pkgmgr");
+
+ LogDebug("--------- <TaskCertificates> : END ----------");
+}
} //namespace WidgetInstall
} //namespace Jobs
void StepAbortCertiInfo();
void SetCertiInfo(CertificateSource source);
+ void StartStep();
+ void EndStep();
+
pkgmgr_instcertinfo_h m_pkgHandle;
public:
DPL::TaskDecl<TaskCertify>(this),
m_contextData(inCont)
{
+ AddStep(&TaskCertify::StartStep);
AddStep(&TaskCertify::stepSignature);
// certi comparison determines whether the update.
if (true == m_contextData.isUpdateMode) {
AddStep(&TaskCertify::stepVerifyUpdate);
}
- AddStep(&TaskCertify::stepFinalize);
+ AddStep(&TaskCertify::EndStep);
}
void TaskCertify::processDistributorSignature(const SignatureData &data)
"Widget Signature checked");
}
-void TaskCertify::stepFinalize()
-{
- LogDebug("Step: <<CERTYFYING DONE>>");
-
- m_contextData.job->UpdateProgress(
- InstallerContext::INSTALL_CERT_CHECK,
- "Widget Certification Check Finished");
-}
-
bool TaskCertify::isTizenWebApp() const
{
bool ret = FALSE;
}
}
}
+
+void TaskCertify::StartStep()
+{
+ LogDebug("--------- <TaskCertify> : START ----------");
+}
+
+void TaskCertify::EndStep()
+{
+ LogDebug("Step: <<CERTYFYING DONE>>");
+
+ m_contextData.job->UpdateProgress(
+ InstallerContext::INSTALL_CERT_CHECK,
+ "Widget Certification Check Finished");
+
+ LogDebug("--------- <TaskCertify> : END ----------");
+}
} //namespace WidgetInstall
} //namespace Jobs
//steps
void stepSignature();
void stepVerifyUpdate();
- void stepFinalize();
+
+ void StartStep();
+ void EndStep();
void processDistributorSignature(const ValidationCore::SignatureData &data);
void processAuthorSignature(const ValidationCore::SignatureData &data);
DPL::TaskDecl<TaskCertifyLevel>(this),
m_contextData(inCont)
{
+ AddStep(&TaskCertifyLevel::StartStep);
AddStep(&TaskCertifyLevel::stepCertifyLevel);
+ AddStep(&TaskCertifyLevel::EndStep);
}
void TaskCertifyLevel::stepCertifyLevel()
ThrowMsg(Exceptions::PrivilegeLevelViolation, "setting level violate");
}
LogDebug("================ Step: <<Certify Level>> DONE ================");
-
- m_contextData.job->UpdateProgress(
- InstallerContext::INSTALL_CERTIFY_LEVEL_CHECK,
- "Application Certificate level check Finished");
}
void TaskCertifyLevel::getSignatureFiles(const std::string& path,
return Level::UNKNOWN;
}
+void TaskCertifyLevel::StartStep()
+{
+ LogDebug("--------- <TaskCertifyLevel> : START ----------");
+}
+
+void TaskCertifyLevel::EndStep()
+{
+ LogDebug("--------- <TaskCertifyLevel> : END ----------");
+
+ m_contextData.job->UpdateProgress(
+ InstallerContext::INSTALL_CERTIFY_LEVEL_CHECK,
+ "Application Certificate level check Finished");
+}
} //namespace WidgetInstall
} //namespace Jobs
//steps
void stepCertifyLevel();
+ void StartStep();
+ void EndStep();
//util
void getSignatureFiles(const std::string& path,
m_handleToRemove(INVALID_WIDGET_HANDLE),
m_handle(INVALID_WIDGET_HANDLE)
{
+ AddStep(&TaskDatabase::StartStep);
AddStep(&TaskDatabase::StepRegisterExternalFiles);
AddStep(&TaskDatabase::StepWrtDBInsert);
AddStep(&TaskDatabase::StepAceDBInsert);
AddStep(&TaskDatabase::StepSecurityOriginDBInsert);
AddStep(&TaskDatabase::StepRemoveExternalFiles);
AddStep(&TaskDatabase::StepLiveboxDBInsert);
+ AddStep(&TaskDatabase::EndStep);
AddAbortStep(&TaskDatabase::StepAbortDBInsert);
AddAbortStep(&TaskDatabase::StepAbortAceDBInsert);
}
}
}
-
- m_context.job->UpdateProgress(
- InstallerContext::INSTALL_NEW_DB_INSERT,
- "New Widget DB UPDATE Finished");
}
void TaskDatabase::StepRegisterExternalFiles()
autoLaunch, mouseEvent, pdFastOpen);
}
}
+
+void TaskDatabase::StartStep()
+{
+ LogDebug("--------- <TaskDatabase> : START ----------");
+}
+
+void TaskDatabase::EndStep()
+{
+ LogDebug("--------- <TaskDatabase> : END ----------");
+}
} //namespace WidgetInstall
} //namespace Jobs
void StepAbortDBInsert();
void StepAbortAceDBInsert();
+ void StartStep();
+ void EndStep();
+
public:
TaskDatabase(InstallerContext& context);
};
DPL::TaskDecl<TaskEncryptResource>(this),
m_context(context)
{
+ AddStep(&TaskEncryptResource::StartStep);
AddStep(&TaskEncryptResource::StepEncryptResource);
+ AddStep(&TaskEncryptResource::EndStep);
}
void TaskEncryptResource::StepEncryptResource()
LogDebug("Step Encrypt resource");
EncryptDirectory(m_context.locations->getTemporaryRootDir());
- m_context.job->UpdateProgress(
- InstallerContext::INSTALL_ECRYPTION_FILES,
- "Ecrypt resource files");
}
void TaskEncryptResource::EncryptDirectory(std::string path)
m_context.widgetConfig.encryptedFiles.insert(fileInfo);
}
+void TaskEncryptResource::StartStep()
+{
+ LogDebug("--------- <TaskEncryptResource> : START ----------");
+}
+
+void TaskEncryptResource::EndStep()
+{
+ m_context.job->UpdateProgress(
+ InstallerContext::INSTALL_ECRYPTION_FILES,
+ "Ecrypt resource files");
+
+ LogDebug("--------- <TaskEncryptResource> : END ----------");
+}
} //namespace WidgetInstall
} //namespace Jobs
void StepEncryptResource();
+ void StartStep();
+ void EndStep();
+
void EncryptDirectory(std::string path);
void EncryptFile(const std::string &fileName);
m_context(context),
m_extHandle(NULL)
{
+ AddStep(&TaskFileManipulation::StartStep);
if (INSTALL_LOCATION_TYPE_EXTERNAL !=
m_context.locationType)
{
AddAbortStep(&TaskFileManipulation::StepAbortCreateExternalDir);
}
+ AddStep(&TaskFileManipulation::EndStep);
}
void TaskFileManipulation::StepCreateDirs()
SHARED_STORAGE_MODE);
}
}
+
+void TaskFileManipulation::StartStep()
+{
+ LogDebug("--------- <TaskFileManipulation> : START ----------");
+}
+
+void TaskFileManipulation::EndStep()
+{
+ LogDebug("--------- <TaskFileManipulation> : END ----------");
+}
} //namespace WidgetInstall
} //namespace Jobs
void StepFinishExternalInstallation();
void StepAbortCreateExternalDir();
+ void StartStep();
+ void EndStep();
+
public:
TaskFileManipulation(InstallerContext& context);
};
DPL::TaskDecl<TaskInstallOspsvc>(this),
m_context(context)
{
+ AddStep(&TaskInstallOspsvc::StartStep);
AddStep(&TaskInstallOspsvc::StepInstallOspService);
AddStep(&TaskInstallOspsvc::StepUpdateManifestFile);
+ AddStep(&TaskInstallOspsvc::EndStep);
}
void TaskInstallOspsvc::StepInstallOspService()
}
pclose(fd);
-
- m_context.job->UpdateProgress(
- InstallerContext::INSTALL_INSTALL_OSPSVC,
- "Installed Osp servcie");
}
void TaskInstallOspsvc::StepUpdateManifestFile()
LogError("Manifest parser error: " << code);
}
}
+
+void TaskInstallOspsvc::StartStep()
+{
+ LogDebug("--------- <TaskInstallOspsvc> : START ----------");
+}
+
+void TaskInstallOspsvc::EndStep()
+{
+ m_context.job->UpdateProgress(
+ InstallerContext::INSTALL_INSTALL_OSPSVC,
+ "Installed Osp servcie");
+
+ LogDebug("--------- <TaskInstallOspsvc> : END ----------");
+}
} //namespace WidgetInstall
} //namespace Jobs
void StepAbortInstall();
+ void StartStep();
+ void EndStep();
+
// return callback
static int StatusCallback(
int req_id, const char *pkg_type, const char *pkg_name,
manifest.addPrivileges(privilege);
}
+void TaskManifestFile::StartStep()
+{
+
+}
+
+void TaskManifestFile::EndStep()
+{
+
+}
} //namespace WidgetInstall
} //namespace Jobs
//For widget update
void stepBackupIconFiles();
-
void stepAbortIconFiles();
+ void StartStep();
+ void EndStep();
+
//private data
std::list<std::string> icon_list; //TODO: this should be registered as
// external files
DPL::TaskDecl<TaskPrepareFiles>(this),
m_installerContext(installerContext)
{
- // Install steps
+ AddStep(&TaskPrepareFiles::StartStep);
AddStep(&TaskPrepareFiles::StepCopyFiles);
+ AddStep(&TaskPrepareFiles::EndStep);
}
void TaskPrepareFiles::CopyFile(const std::string& source)
CopyFile(os.str());
}
}
+
+void TaskPrepareFiles::StartStep()
+{
+ LogDebug("--------- <TaskPrepareFiles> : START ----------");
+}
+
+void TaskPrepareFiles::EndStep()
+{
+ LogDebug("--------- <TaskPrepareFiles> : END ----------");
+}
} // namespace WidgetInstall
} // namespace Jobs
// Steps
void StepCopyFiles();
+ void StartStep();
+ void EndStep();
+
public:
explicit TaskPrepareFiles(InstallerContext &installerContext);
};
DPL::TaskDecl<TaskPrepareReinstall>(this),
m_context(context)
{
+ AddStep(&TaskPrepareReinstall::StartStep);
AddStep(&TaskPrepareReinstall::StepPrepare);
AddStep(&TaskPrepareReinstall::StepParseRDSDelta);
AddStep(&TaskPrepareReinstall::StepVerifyRDSDelta);
AddStep(&TaskPrepareReinstall::StepAddFile);
AddStep(&TaskPrepareReinstall::StepDeleteFile);
AddStep(&TaskPrepareReinstall::StepModifyFile);
+ AddStep(&TaskPrepareReinstall::EndStep);
}
void TaskPrepareReinstall::StepPrepare()
}
LogDebug("Replace " << newfile << " to " << destPath);
}
+}
+
+void TaskPrepareReinstall::StartStep()
+{
+ LogDebug("--------- <TaskPrepareReinstall> : START ----------");
+}
+
+void TaskPrepareReinstall::EndStep()
+{
m_context.job->UpdateProgress(
InstallerContext::INSTALL_RDS_PREPARE,
"RDS prepare finished");
+
+ LogDebug("--------- <TaskPrepareReinstall> : END ----------");
}
} //namespace WidgetInstall
void StepAbortPrepareReinstall();
+ void StartStep();
+ void EndStep();
+
InstallerContext& m_context;
// TODO : replace multimap
std::list<std::string> m_addFileList;
DPL::TaskDecl<TaskRecovery>(this),
m_context(context)
{
+ AddStep(&TaskRecovery::StartStep);
AddStep(&TaskRecovery::StepCreateCheckFile);
+ AddStep(&TaskRecovery::EndStep);
+}
+
+void TaskRecovery::StartStep()
+{
+ LogDebug("--------- <TaskRecovery> : START ----------");
+}
+
+void TaskRecovery::EndStep()
+{
+ m_context.job->UpdateProgress(
+ InstallerContext::INSTALL_CHECK_FILE,
+ "Create information file for recovery");
+
+ LogDebug("--------- <TaskRecovery> : END ----------");
}
void TaskRecovery::StepCreateCheckFile()
} else {
ThrowMsg(Exceptions::FileOperationFailed, "Fail to create file for recovery.");
}
-
- m_context.job->UpdateProgress(
- InstallerContext::INSTALL_CHECK_FILE,
- "Create information file for recovery");
}
} //namespace WidgetInstall
} //namespace Jobs
InstallerContext &m_context;
void StepCreateCheckFile();
+ void StartStep();
+ void EndStep();
public:
explicit TaskRecovery(InstallerContext &installerContext);
DPL::TaskDecl<TaskRemoveBackupFiles>(this),
m_context(context)
{
+ AddStep(&TaskRemoveBackupFiles::StartStep);
if (m_context.mode.extension != InstallMode::ExtensionType::DIR)
{
AddStep(&TaskRemoveBackupFiles::StepRemoveBackupFiles);
}
AddStep(&TaskRemoveBackupFiles::StepDeleteBackupDB);
+ AddStep(&TaskRemoveBackupFiles::EndStep);
}
void TaskRemoveBackupFiles::StepRemoveBackupFiles()
}
}
+void TaskRemoveBackupFiles::StartStep()
+{
+ LogDebug("--------- <TaskRemoveBackupFiles> : START ----------");
+}
+
+void TaskRemoveBackupFiles::EndStep()
+{
+ LogDebug("--------- <TaskRemoveBackupFiles> : END ----------");
+}
} //namespace WidgetInstall
} //namespace Jobs
void StepRemoveBackupFiles();
void StepDeleteBackupDB();
+ void StartStep();
+ void EndStep();
+
public:
TaskRemoveBackupFiles(InstallerContext& context);
};
m_context(context),
m_pkgId(NULL)
{
+ AddStep(&TaskSmack::StartStep);
AddStep(&TaskSmack::StepSetInstall);
AddStep(&TaskSmack::StepSmackFolderLabeling);
AddStep(&TaskSmack::StepSmackPrivilege);
- AddStep(&TaskSmack::StepSetEndofInstallation);
+ AddStep(&TaskSmack::EndStep);
AddAbortStep(&TaskSmack::StepAbortSmack);
}
#endif
}
-void TaskSmack::StepSetEndofInstallation()
-{
- m_context.job->UpdateProgress(
- InstallerContext::INSTALL_END,
- "End installation");
-}
-
bool TaskSmack::setLabelForSharedDir(const char* pkgId)
{
/* /shared directory */
return true;
}
+
+void TaskSmack::StartStep()
+{
+ LogDebug("--------- <TaskSmack> : START ----------");
+}
+
+void TaskSmack::EndStep()
+{
+ m_context.job->UpdateProgress(
+ InstallerContext::INSTALL_END,
+ "End installation");
+
+ LogDebug("--------- <TaskSmack> : END ----------");
+}
} //namespace WidgetInstall
} //namespace Jobs
void StepSmackFolderLabeling();
void StepSmackPrivilege();
void StepRevokeForUpdate();
- void StepSetEndofInstallation();
void StepAbortSmack();
bool setLabelForSharedDir(const char* pkgId);
+ void StartStep();
+ void EndStep();
+
public:
TaskSmack(InstallerContext& context);
};
DPL::TaskDecl<TaskUpdateFiles>(this),
m_context(context)
{
+ AddStep(&TaskUpdateFiles::StartStep);
AddStep(&TaskUpdateFiles::StepBackupDirectory);
+ AddStep(&TaskUpdateFiles::EndStep);
AddAbortStep(&TaskUpdateFiles::StepAbortBackupDirectory);
}
}
WrtUtilMakeDir(pkgPath);
-
- m_context.job->UpdateProgress(
- InstallerContext::INSTALL_CREATE_BACKUP_DIR,
- "Backup directory created for update");
}
void TaskUpdateFiles::StepAbortBackupDirectory()
LogError("Failed to rename " << backPath << " to " << pkgPath);
}
}
+
+void TaskUpdateFiles::StartStep()
+{
+ LogDebug("--------- <TaskUpdateFiles> : START ----------");
+}
+
+void TaskUpdateFiles::EndStep()
+{
+ m_context.job->UpdateProgress(
+ InstallerContext::INSTALL_CREATE_BACKUP_DIR,
+ "Backup directory created for update");
+
+ LogDebug("--------- <TaskUpdateFiles> : END ----------");
+}
} //namespace WidgetInstall
} //namespace Jobs
void StepAbortBackupDirectory();
+ void StartStep();
+ void EndStep();
+
public:
TaskUpdateFiles(InstallerContext& context);
};
DPL::TaskDecl<TaskWidgetConfig>(this),
m_installContext(installContext)
{
+ AddStep(&TaskWidgetConfig::StartStep);
AddStep(&TaskWidgetConfig::StepProcessConfigurationFile);
AddStep(&TaskWidgetConfig::ReadLocaleFolders);
AddStep(&TaskWidgetConfig::ProcessLocalizedStartFiles);
AddStep(&TaskWidgetConfig::ProcessSecurityModel);
AddStep(&TaskWidgetConfig::StepVerifyFeatures);
AddStep(&TaskWidgetConfig::StepCheckMinVersionInfo);
+ AddStep(&TaskWidgetConfig::EndStep);
}
void TaskWidgetConfig::StepProcessConfigurationFile()
ThrowMsg(Exception::ConfigParseFailed, path);
}
}
+
+void TaskWidgetConfig::StartStep()
+{
+ LogDebug("--------- <TaskWidgetConfig> : START ----------");
+}
+
+void TaskWidgetConfig::EndStep()
+{
+ LogDebug("--------- <TaskWidgetConfig> : END ----------");
+}
} //namespace WidgetInstall
} //namespace Jobs
template <typename Ex, const char* Msg>
void StepCancelInstallation();
+ void StartStep();
+ void EndStep();
+
DPL::String createAuthorWidgetInfo() const;
bool isFeatureAllowed(
WrtDB::AppType appType, DPL::String featureName);
DPL::TaskDecl<TaskCheck>(this),
m_context(context)
{
+ AddStep(&TaskCheck::StartStep);
AddStep(&TaskCheck::StepUninstallPreCheck);
+ AddStep(&TaskCheck::EndStep);
}
TaskCheck::~TaskCheck()
{}
+void TaskCheck::StartStep()
+{
+ LogDebug("--------- <TaskCheck> : START ----------");
+}
+
+void TaskCheck::EndStep()
+{
+ m_context.job->UpdateProgress(UninstallerContext::UNINSTALL_PRECHECK,
+ "Uninstall pre-checking Finished");
+ LogDebug("--------- <TaskCheck> : END ----------");
+}
+
void TaskCheck::StepUninstallPreCheck()
{
bool isRunning = false;
}
LogDebug("Widget Can be uninstalled. Pkgname : " << m_context.tzAppid);
- m_context.job->UpdateProgress(UninstallerContext::UNINSTALL_PRECHECK,
- "Uninstall pre-checking Finished");
}
} //namespace WidgetUninstall
} //namespace Jobs
//steps
void StepUninstallPreCheck();
+ void StartStep();
+ void EndStep();
public:
TaskCheck(UninstallerContext& context);
DPL::TaskDecl<TaskDbUpdate>(this),
m_context(context)
{
+ AddStep(&TaskDbUpdate::StartStep);
AddStep(&TaskDbUpdate::StepDbUpdate);
AddStep(&TaskDbUpdate::StepLiveboxDBDelete);
+ AddStep(&TaskDbUpdate::EndStep);
}
TaskDbUpdate::~TaskDbUpdate()
ReThrowMsg(Exceptions::DatabaseFailure,
"Failed to handle StepDbUpdate!");
}
-
- m_context.job->UpdateProgress(
- UninstallerContext::UNINSTALL_DB_UPDATE,
- "Widget DB Update Finished");
}
void TaskDbUpdate::StepLiveboxDBDelete()
LogDebug("delete box info: " << m_context.tzAppid);
}
}
+
+void TaskDbUpdate::StartStep()
+{
+ LogDebug("--------- <TaskDbUpdate> : START ----------");
+}
+
+void TaskDbUpdate::EndStep()
+{
+ m_context.job->UpdateProgress(
+ UninstallerContext::UNINSTALL_DB_UPDATE,
+ "Widget DB Update Finished");
+
+ LogDebug("--------- <TaskDbUpdate> : END ----------");
+}
} //namespace WidgetUninstall
} //namespace Jobs
void StepDbUpdate();
void StepLiveboxDBDelete();
+ void StartStep();
+ void EndStep();
+
public:
TaskDbUpdate(UninstallerContext& context);
virtual ~TaskDbUpdate();
DPL::TaskDecl<TaskDeleteCertificates>(this),
m_context(context)
{
+ AddStep(&TaskDeleteCertificates::StartStep);
AddStep(&TaskDeleteCertificates::StepDeleteCertificates);
+ AddStep(&TaskDeleteCertificates::EndStep);
}
TaskDeleteCertificates::~TaskDeleteCertificates()
LogError("pkgmgr_installer_delete_certinfo fail");
}
}
+
+void TaskDeleteCertificates::StartStep()
+{
+ LogDebug("--------- <TaskDeleteCertificates> : START ----------");
+}
+
+void TaskDeleteCertificates::EndStep()
+{
+ LogDebug("--------- <TaskDeleteCertificates> : END ----------");
+}
} //namespace WidgetUninstall
} //namespace Jobs
private:
void StepDeleteCertificates();
+ void StartStep();
+ void EndStep();
+
public:
TaskDeleteCertificates(UninstallerContext& context);
virtual ~TaskDeleteCertificates();
DPL::TaskDecl<TaskRemoveCustomHandlers>(this),
m_context(context)
{
+ AddStep(&TaskRemoveCustomHandlers::StartStep);
AddStep(&TaskRemoveCustomHandlers::Step);
+ AddStep(&TaskRemoveCustomHandlers::EndStep);
}
void TaskRemoveCustomHandlers::Step()
handlersDao.removeWidgetContentHandlers();
CustomHandlerDB::Interface::detachDatabase();
}
+
+void TaskRemoveCustomHandlers::StartStep()
+{
+ LogDebug("--------- <TaskRemoveCustomHandlers> : START ----------");
+}
+
+void TaskRemoveCustomHandlers::EndStep()
+{
+ LogDebug("--------- <TaskRemoveCustomHandlers> : END ----------");
+}
} //namespace WidgetUninstall
} //namespace Jobs
void Step();
+ void StartStep();
+ void EndStep();
+
public:
TaskRemoveCustomHandlers(UninstallerContext& context);
};
DPL::TaskDecl<TaskRemoveFiles>(this),
m_context(context)
{
+ AddStep(&TaskRemoveFiles::StartStep);
AddStep(&TaskRemoveFiles::StepRemoveInstallationDirectory);
AddStep(&TaskRemoveFiles::StepRemoveManifest);
AddStep(&TaskRemoveFiles::StepRemoveExternalLocations);
AddStep(&TaskRemoveFiles::StepRemoveFinished);
+ AddStep(&TaskRemoveFiles::EndStep);
}
TaskRemoveFiles::~TaskRemoveFiles()
dao.unregisterAllExternalLocations();
}
}
+
+void TaskRemoveFiles::StartStep()
+{
+ LogDebug("--------- <TaskRemoveFiles> : START ----------");
+}
+
+void TaskRemoveFiles::EndStep()
+{
+ LogDebug("--------- <TaskRemoveFiles> : END ----------");
+}
} //namespace WidgetUninstall
} //namespace Jobs
void StepRemoveManifest();
void StepRemoveExternalLocations();
+ void StartStep();
+ void EndStep();
+
public:
explicit TaskRemoveFiles(UninstallerContext& context);
virtual ~TaskRemoveFiles();
DPL::TaskDecl<TaskSmack>(this),
m_context(context)
{
+ AddStep(&TaskSmack::StartStep);
AddStep(&TaskSmack::Step);
+ AddStep(&TaskSmack::EndStep);
}
void TaskSmack::Step()
if (PC_OPERATION_SUCCESS != app_uninstall(pkgId)) {
LogError("failure in removing smack rules file");
}
+#endif
+}
+
+void TaskSmack::StartStep()
+{
+ LogDebug("--------- <TaskSmack> : START ----------");
+}
+void TaskSmack::EndStep()
+{
m_context.job->UpdateProgress(
UninstallerContext::UNINSTALL_SMACK_DISABLE,
"Widget SMACK Disabled");
-#endif
+
+ LogDebug("--------- <TaskSmack> : END ----------");
}
} //namespace WidgetUninstall
} //namespace Jobs
void Step();
+ void StartStep();
+ void EndStep();
+
public:
TaskSmack(UninstallerContext& context);
};
DPL::TaskDecl<TaskUninstallOspsvc>(this),
m_context(context)
{
+ AddStep(&TaskUninstallOspsvc::StartStep);
AddStep(&TaskUninstallOspsvc::StepUninstallOspsvc);
+ AddStep(&TaskUninstallOspsvc::EndStep);
}
TaskUninstallOspsvc::~TaskUninstallOspsvc()
m_context.job->UpdateProgress(UninstallerContext::UNINSTALL_REMOVE_OSPSVC,
"Uninstall OSP service finished");
}
+
+void TaskUninstallOspsvc::StartStep()
+{
+ LogDebug("--------- <TaskUninstallOspsvc> : START ----------");
+}
+
+void TaskUninstallOspsvc::EndStep()
+{
+ LogDebug("--------- <TaskUninstallOspsvc> : END ----------");
+}
} //namespace WidgetUninstall
} //namespace Jobs
//steps
void StepUninstallOspsvc();
+ void StartStep();
+ void EndStep();
+
public:
TaskUninstallOspsvc(UninstallerContext& context);
virtual ~TaskUninstallOspsvc();
projects / platform / framework / web / wrt-installer.git / commitdiff