X-Git-Url: http://review.tizen.org/git/?a=blobdiff_plain;f=src%2Fjobs%2Fwidget_install%2Fjob_widget_install.cpp;h=e2b20865955ed468c741055b3c2e65cf385ecd47;hb=80392791b3b7919b59596326dd9fdd9b25a1be1e;hp=059a9573f2496d05cb270013fd0a3fb7c54f2838;hpb=5ed3165dbb0d38b93fdfd6791d35815b02b9d365;p=framework%2Fweb%2Fwrt-installer.git diff --git a/src/jobs/widget_install/job_widget_install.cpp b/src/jobs/widget_install/job_widget_install.cpp old mode 100755 new mode 100644 index 059a957..e2b2086 --- a/src/jobs/widget_install/job_widget_install.cpp +++ b/src/jobs/widget_install/job_widget_install.cpp @@ -20,577 +20,808 @@ * @version 1.0 * @brief Implementation file for main installer task */ +#include +#include +#include +#include +#include +#include +#include + #include #include #include #include -#include #include #include #include #include +#include +#include #include -#include +#include +#include +#include +#include // TODO remove +#include + +#include +#include +#include + #include "root_parser.h" #include "widget_parser.h" #include "parser_runner.h" #include -#include #include #include -#include #include #include #include #include -#include #include #include #include #include -#include +#include #include #include +#include +#include +#include +#include + #include #include -#include -#include -#include -#include -#include -#include -#include -#include -#include // TODO remove -#include -#include -#include -#include +#include using namespace WrtDB; +using namespace Jobs::Exceptions; namespace // anonymous { const char * const CONFIG_XML = "config.xml"; const char * const WITH_OSP_XML = "res/wgt/config.xml"; -//allowed: a-z, A-Z, 0-9, '.', '-', '_', ' ' -const char* REG_TIZENID_PATTERN = "^[-. a-zA-Z0-9_@+=]*$"; -const int RESERVED_COUNT = 20; //number of chars reserved in name (e.g. for '.desktop') -const int MAX_TIZENID_LENTH = 255 - RESERVED_COUNT; +//allowed: a-z, A-Z, 0-9 +const char* REG_TIZENID_PATTERN = "^[a-zA-Z0-9]{10}.{1,}$"; +const char* REG_NAME_PATTERN = "^[a-zA-Z0-9._-]{1,}$"; +const size_t PACKAGE_ID_LENGTH = 10; static const DPL::String SETTING_VALUE_ENCRYPTION = L"encryption"; static const DPL::String SETTING_VALUE_ENCRYPTION_ENABLE = L"enable"; +const DPL::String SETTING_VALUE_INSTALLTOEXT_NAME = + L"install-location"; +const DPL::String SETTING_VALUE_INSTALLTOEXT_PREPER_EXT = + L"prefer-external"; + +const std::string XML_EXTENSION = ".xml"; + +bool hasExtension(const std::string& filename, const std::string& extension) +{ + LogDebug("Looking for extension " << extension << " in: " << filename); + size_t fileLen = filename.length(); + size_t extLen = extension.length(); + if (fileLen < extLen) { + LogError("Filename " << filename << " is shorter than extension " + << extension); + return false; + } + return (0 == filename.compare(fileLen - extLen, extLen, extension)); +} +} // namespace anonymous +namespace Jobs { +namespace WidgetInstall { class InstallerTaskFail : public DPL::TaskDecl { private: - bool m_deferred; + ConfigureResult m_result; void StepFail() { - if (m_deferred) { + if (m_result == ConfigureResult::Deferred) { ThrowMsg(Jobs::WidgetInstall::Exceptions::Deferred, - "Widget installation or update deferred!"); + "widget installation or update deferred!"); + } else if (m_result == ConfigureResult::Failed_InvalidConfig) { + ThrowMsg(Jobs::WidgetInstall::Exceptions::WidgetConfigFileInvalid, + "invalid config"); + } else if (m_result == ConfigureResult::Failed_LowerVersion) { + ThrowMsg(Jobs::WidgetInstall::Exceptions::PackageLowerVersion, + "package version is lower than installed version"); + } else if (m_result == ConfigureResult::Failed_AlreadyInstalled) { + ThrowMsg(Jobs::WidgetInstall::Exceptions::PackageAlreadyInstalled, + "package is already installed"); + } else if (m_result == ConfigureResult::Failed_WidgetRunning) { + ThrowMsg(Jobs::WidgetInstall::Exceptions::WidgetRunningError, + "widget is running"); + } else if (m_result == ConfigureResult::Failed_DrmError) { + ThrowMsg(Jobs::WidgetInstall::Exceptions::DRMFailed, + "drm failed"); } else { ThrowMsg(Jobs::WidgetInstall::Exceptions::NotAllowed, - "Widget installation or update not allowed!"); + "widget installation or update not allowed!"); } } public: - InstallerTaskFail(bool deferred) : + InstallerTaskFail(ConfigureResult result) : DPL::TaskDecl(this), - m_deferred(deferred) + m_result(result) { AddStep(&InstallerTaskFail::StepFail); } }; -const std::string XML_EXTENSION = ".xml"; - -bool hasExtension(const std::string& filename, const std::string& extension) { - LogDebug("Looking for extension " << extension << " in: " << filename); - size_t fileLen = filename.length(); - size_t extLen = extension.length(); - if (fileLen < extLen) { - LogError("Filename " << filename << " is shorter than extension " - << extension); - return false; - } - return (0 == filename.compare(fileLen-extLen, extLen, extension)); -} -} // namespace anonymous - -namespace Jobs { -namespace WidgetInstall { -JobWidgetInstall::JobWidgetInstall(std::string const &widgetPath, - const WidgetInstallationStruct &installerStruct) : +JobWidgetInstall::JobWidgetInstall( + std::string const &widgetPath, + const WidgetInstallationStruct & + installerStruct) : Job(Installation), JobContextBase(installerStruct), - m_exceptionCaught(Exceptions::Success) + m_exceptionCaught(Jobs::Exceptions::Success) { - // Check installation type (config.xml or widget.wgt) - bool browserRequest = hasExtension(widgetPath, XML_EXTENSION); - - LogInfo("Hosted app installation: " << browserRequest); - - struct timeval tv; - gettimeofday(&tv, NULL); - srand(time(NULL) + tv.tv_usec); - WrtDB::DbWidgetHandle handle; - do { - handle = rand() % INT_MAX + 1; - LogInfo("Random widget handle: " << handle); - } while (WidgetDAOReadOnly::isWidgetInstalled(handle)); - - m_installerContext.widgetHandle = handle; m_installerContext.m_quiet = m_jobStruct.m_quiet; - if(!browserRequest) - { - m_installerContext.widgetConfig.pType = checkPackageType(widgetPath); - } - else - { - m_installerContext.widgetConfig.pType = WrtDB::PKG_TYPE_TIZEN_WEBAPP; - } - LogDebug("widgetPath:" << widgetPath); - - ConfigParserData configData = getWidgetDataFromXML(widgetPath, browserRequest, - m_installerContext.widgetConfig.pType); - WidgetUpdateInfo update = detectWidgetUpdate(configData); - - bool needEncryption = detectResourceEncryption(configData); - - - // Configure installation - ConfigureResult result = ConfigureInstallation(widgetPath, update); - if (!setTizenId(configData)) { - result = ConfigureResult::Failed; - } else { - using namespace PackageManager; - LogInfo("WidgetHandle: " << m_installerContext.widgetHandle); - LogInfo("Tizen Id: " << m_installerContext.widgetConfig.pkgname); - - configureWidgetLocation(widgetPath, browserRequest); + ConfigureResult result = PrePareInstallation(widgetPath); - // send start signal of pkgmgr - PkgmgrSignalSingleton::Instance().setPkgname( - DPL::ToUTF8String( - *m_installerContext.widgetConfig.pkgname)); - PkgmgrSignalSingleton::Instance().sendSignal( - PKGMGR_START_KEY, - PKGMGR_START_INSTALL); - } if (result == ConfigureResult::Ok) { LogInfo("Configure installation succeeded"); + m_installerContext.job->SetProgressFlag(true); AddTask(new TaskRecovery(m_installerContext)); // Create installation tasks - if (!m_installerContext.locations->browserRequest()) { + if (m_installerContext.widgetConfig.packagingType != + WrtDB::PKG_TYPE_DIRECTORY_WEB_APP && + m_installerContext.widgetConfig.packagingType != + WrtDB::PKG_TYPE_HOSTED_WEB_APP && + !m_isDRM) + { AddTask(new TaskUnzip(m_installerContext)); } + AddTask(new TaskWidgetConfig(m_installerContext)); - if (m_installerContext.locations->browserRequest()) { + if (m_installerContext.widgetConfig.packagingType == + WrtDB::PKG_TYPE_HOSTED_WEB_APP) + { AddTask(new TaskPrepareFiles(m_installerContext)); } AddTask(new TaskCertify(m_installerContext)); - if (needEncryption) { + if (m_needEncryption) { AddTask(new TaskEncryptResource(m_installerContext)); } - AddTask(new TaskDbUpdate(m_installerContext)); - AddTask(new TaskFileManipulation(m_installerContext)); - // TODO: Update progress information for this task - AddTask(new TaskPrivateStorage(m_installerContext)); - AddTask(new TaskAceCheck(m_installerContext)); - //This is sort of quick solution, because ACE verdicts are based upon - //data from DAO (DB). So AceCheck for now has to be AFTER DbUpdate - //task. - AddTask(new TaskSmack(m_installerContext)); + AddTask(new TaskFileManipulation(m_installerContext)); AddTask(new TaskManifestFile(m_installerContext)); - if (m_installerContext.widgetConfig.pType == - PKG_TYPE_TIZEN_WITHSVCAPP) { + if (m_installerContext.widgetConfig.packagingType == + PKG_TYPE_HYBRID_WEB_APP) + { AddTask(new TaskInstallOspsvc(m_installerContext)); } + AddTask(new TaskCertificates(m_installerContext)); + AddTask(new TaskDatabase(m_installerContext)); + AddTask(new TaskAceCheck(m_installerContext)); + AddTask(new TaskSmack(m_installerContext)); } else if (result == ConfigureResult::Updated) { LogInfo("Configure installation updated"); LogInfo("Widget Update"); + m_installerContext.job->SetProgressFlag(true); - if (!m_installerContext.locations->browserRequest()) { + if (m_jobStruct.m_installMode == + InstallMode::REINSTALL_MODE_DIRECTORY) + { + AddTask(new TaskPrepareReinstall(m_installerContext)); + } + + if (m_installerContext.widgetConfig.packagingType != + WrtDB::PKG_TYPE_HOSTED_WEB_APP && + m_installerContext.widgetConfig.packagingType != + WrtDB::PKG_TYPE_DIRECTORY_WEB_APP && + !m_isDRM) + { AddTask(new TaskUnzip(m_installerContext)); } + AddTask(new TaskWidgetConfig(m_installerContext)); - if (m_installerContext.locations->browserRequest()) { + + if (m_installerContext.widgetConfig.packagingType == + WrtDB::PKG_TYPE_HOSTED_WEB_APP) + { AddTask(new TaskPrepareFiles(m_installerContext)); } AddTask(new TaskCertify(m_installerContext)); - AddTask(new TaskUpdateFiles(m_installerContext)); - AddTask(new TaskNewDbInsert(m_installerContext)); + if (m_needEncryption) { + AddTask(new TaskEncryptResource(m_installerContext)); + } - /* TODO : To backup file, save md5 values */ - AddTask(new TaskAceCheck(m_installerContext)); - AddTask(new TaskSmack(m_installerContext)); + if (m_installerContext.widgetConfig.packagingType != + WrtDB::PKG_TYPE_DIRECTORY_WEB_APP) + { + AddTask(new TaskUpdateFiles(m_installerContext)); + } AddTask(new TaskManifestFile(m_installerContext)); - AddTask(new TaskRemoveBackupFiles(m_installerContext)); - if (m_installerContext.widgetConfig.pType == - PKG_TYPE_TIZEN_WITHSVCAPP) { + if (m_installerContext.widgetConfig.packagingType == + PKG_TYPE_HYBRID_WEB_APP) + { AddTask(new TaskInstallOspsvc(m_installerContext)); } + if (m_installerContext.widgetConfig.packagingType != + WrtDB::PKG_TYPE_DIRECTORY_WEB_APP) + { + AddTask(new TaskRemoveBackupFiles(m_installerContext)); + } + AddTask(new TaskDatabase(m_installerContext)); + AddTask(new TaskAceCheck(m_installerContext)); + //TODO: remove widgetHandle from this task and move before database task + // by now widget handle is needed in ace check + // Any error in acecheck while update will break widget + AddTask(new TaskSmack(m_installerContext)); } else if (result == ConfigureResult::Deferred) { // Installation is deferred LogInfo("Configure installation deferred"); - AddTask(new InstallerTaskFail(true)); - } else if (result == ConfigureResult::Failed) { + AddTask(new InstallerTaskFail(result)); + } else if (result >= ConfigureResult::Failed && + result <= ConfigureResult::Failed_DrmError) { // Installation is not allowed to proceed due to widget update policy LogWarning("Configure installation failed!"); - AddTask(new InstallerTaskFail(false)); + AddTask(new InstallerTaskFail(result)); } else { Assert(false && "Invalid configure result!"); } } -bool JobWidgetInstall::setTizenId( - const WrtDB::ConfigParserData &configInfo) +ConfigureResult JobWidgetInstall::PrePareInstallation( + const std::string &widgetPath) { - Assert(!!m_installerContext.widgetHandle - && "Widget Handle should be initialized"); + ConfigureResult result; + m_needEncryption = false; - regex_t reg; - regcomp(®, REG_TIZENID_PATTERN, REG_NOSUB); - struct stat dirStat; - if(!!configInfo.tizenId) { - LogDebug("Setting tizenId provided in config.xml"); - if ((regexec(®, DPL::ToUTF8String(*(configInfo.tizenId)).c_str(), - static_cast(0), NULL, 0) != 0) || - (DPL::ToUTF8String(*(configInfo.tizenId)).size() > MAX_TIZENID_LENTH) || - (stat((std::string(GlobalConfig::GetUserInstalledWidgetPath()) + "/" - + DPL::ToUTF8String(*(configInfo.tizenId))).c_str(), &dirStat) == 0)) + Try + { + std::string tempDir; + if (m_jobStruct.m_installMode == + InstallMode::REINSTALL_MODE_DIRECTORY) { - //it is true when tizenId does not fit REG_TIZENID_PATTERN - LogError("pkgName provided but not proper."); - regfree(®); - return false; + std::ostringstream tempPathBuilder; + tempPathBuilder << WrtDB::GlobalConfig::GetUserInstalledWidgetPath(); + tempPathBuilder << WrtDB::GlobalConfig::GetTmpDirPath(); + tempPathBuilder << "/"; + tempPathBuilder << widgetPath; + tempDir = tempPathBuilder.str();; + } else { + tempDir = + Jobs::WidgetInstall::createTempPath( + m_jobStruct.m_installMode == + InstallMode::INSTALL_MODE_PRELOAD); } - m_installerContext.widgetConfig.pkgname = configInfo.tizenId; - } else { - LogInfo("package name is generated by WRT"); - // tizen id should be generated by secure random algorithm - std::string pkgName = WrtDB::GlobalConfig::GetPkgnamePrefix(); - - bool named = false; - FOREACH(it, configInfo.localizedDataSet) - { - if (!!((it->second).name)) { - //there is a name provided - std::string name = DPL::ToUTF8String(*(it->second).name); - //cut very long widget's name - name = name.substr(0, MAX_TIZENID_LENTH - strlen( - WrtDB::GlobalConfig::GetPkgnamePrefix())); - //check name if all characters are supported by filesystem - if (regexec(®, name.c_str(), static_cast(0), NULL, 0) - == 0) - { - //WidgetName is ok and can be used as package name - //replace all spaces with '_' - size_t pos = 0; - while((pos = name.find(" ", pos)) != std::string::npos) { - name.replace(pos, 1, "_"); - ++pos; - } - pkgName += name; - named = true; - } - break; + m_isDRM = isDRMWidget(widgetPath); + if (true == m_isDRM) { + LogDebug("decrypt DRM widget"); + if (DecryptDRMWidget(widgetPath, tempDir)) { + LogDebug("Failed decrypt DRM widget"); + return ConfigureResult::Failed_DrmError; } } - if (!named) // there is no widget name provided, use widgetHandle - { - pkgName += std::to_string(*(m_installerContext.widgetHandle)); - } + LogDebug("widgetPath:" << widgetPath); + + m_installerContext.widgetConfig.packagingType = + checkPackageType(widgetPath, tempDir); + ConfigParserData configData = getWidgetDataFromXML( + widgetPath, + tempDir, + m_installerContext.widgetConfig.packagingType, + m_isDRM, + m_jobStruct.m_installMode == + InstallMode::REINSTALL_MODE_DIRECTORY); + LogDebug("widget packaging type : " << + m_installerContext.widgetConfig.packagingType.pkgType); + + setTizenId(configData); + setApplicationType(configData); + m_needEncryption = detectResourceEncryption(configData); + setInstallLocationType(configData); + + // Configure installation + result = ConfigureInstallation(widgetPath, configData, tempDir); + } + Catch(Exceptions::ExtractFileFailed) + { + LogError("Failed to create temporary path for widget"); + result = ConfigureResult::Failed_InvalidConfig; + } + + return result; +} - //check if there is package with same name and if generate different name - std::string path = GlobalConfig::GetUserInstalledWidgetPath(); - path += "/"; +void JobWidgetInstall::setTizenId( + const WrtDB::ConfigParserData &configInfo) +{ + bool shouldMakeAppid = false; + using namespace PackageManager; + if (!!configInfo.tizenAppId) { + LogDebug("Setting tizenAppId provided in config.xml: " << + configInfo.tizenAppId); - std::ostringstream newPath; - newPath << path << pkgName; + m_installerContext.widgetConfig.tzAppid = *configInfo.tizenAppId; + //check package id. + if (!!configInfo.tizenPkgId) { + LogDebug("Setting tizenPkgId provided in config.xml: " << + configInfo.tizenPkgId); - std::string suffix; - for (int i = 0;; ++i) { - if (stat(newPath.str().c_str(), &dirStat) == 0) { - //path exist, chose another one, eg. widgetName1 - suffix = std::to_string(i + 1); - pkgName = pkgName.substr( - 0, MAX_TIZENID_LENTH - suffix.size()); - newPath.str(""); - newPath << path << pkgName << suffix; + m_installerContext.widgetConfig.tzPkgid = *configInfo.tizenPkgId; + } else { + DPL::String appid = *configInfo.tizenAppId; + if (appid.length() > PACKAGE_ID_LENGTH) { + m_installerContext.widgetConfig.tzPkgid = + appid.substr(0, PACKAGE_ID_LENGTH); + } else { + //old version appid only has 10byte random character is able to install for a while. + //this case appid equal pkgid. + m_installerContext.widgetConfig.tzPkgid = + *configInfo.tizenAppId; + shouldMakeAppid = true; + } + } + } else { + shouldMakeAppid = true; + TizenPkgId pkgId = WidgetDAOReadOnly::generatePkgId(); + LogDebug("Checking if pkg id is unique"); + while (true) { + if (!validateTizenPackageID(pkgId)) { + //path exist, chose another one + pkgId = WidgetDAOReadOnly::generatePkgId(); continue; } - pkgName += suffix; break; } + m_installerContext.widgetConfig.tzPkgid = pkgId; + LogInfo("tizen_id name was generated by WRT: " << + m_installerContext.widgetConfig.tzPkgid); + } + + if (shouldMakeAppid == true) { + DPL::OptionalString name; + DPL::OptionalString defaultLocale = configInfo.defaultlocale; - m_installerContext.widgetConfig.pkgname = - DPL::FromUTF8String(pkgName); + FOREACH(localizedData, configInfo.localizedDataSet) + { + Locale i = localizedData->first; + if (!!defaultLocale) { + if (defaultLocale == i) { + name = localizedData->second.name; + break; + } + } else { + name = localizedData->second.name; + break; + } + } + regex_t regx; + if (regcomp(®x, REG_NAME_PATTERN, REG_NOSUB | REG_EXTENDED) != 0) { + LogDebug("Regcomp failed"); + } + LogDebug("Name : " << name); + if (!name || (regexec(®x, DPL::ToUTF8String(*name).c_str(), + static_cast(0), NULL, 0) != REG_NOERROR)) + { + // TODO : generate name move to wrt-commons + std::string allowedString("ABCDEFGHIJKLMNOPQRSTUVWXYZ"); + std::ostringstream genName; + struct timeval tv; + gettimeofday(&tv, NULL); + unsigned int seed = time(NULL) + tv.tv_usec; + + genName << "_" << allowedString[rand_r(&seed) % allowedString.length()]; + name = DPL::FromUTF8String(genName.str()); + LogDebug("name was generated by WRT"); + } + regfree(®x); + LogDebug("Name : " << name); + std::ostringstream genid; + genid << m_installerContext.widgetConfig.tzPkgid << "." << name; + LogDebug("tizen appid was generated by WRT : " << genid.str()); + + DPL::OptionalString appid = DPL::FromUTF8String(genid.str()); + NormalizeAndTrimSpaceString(appid); + m_installerContext.widgetConfig.tzAppid = *appid; } - regfree(®); - LogInfo("Tizen Id : " << m_installerContext.widgetConfig.pkgname); + // send start signal of pkgmgr + getInstallerStruct().pkgmgrInterface->setPkgname(DPL::ToUTF8String( + m_installerContext. + widgetConfig. + tzPkgid)); + LogInfo("Tizen App Id : " << m_installerContext.widgetConfig.tzAppid); + LogInfo("Tizen Pkg Id : " << m_installerContext.widgetConfig.tzPkgid); LogInfo("W3C Widget GUID : " << m_installerContext.widgetConfig.guid); - return true; } -DPL::Optional JobWidgetInstall::getNewWidgetHandle() const +void JobWidgetInstall::configureWidgetLocation(const std::string & widgetPath, + const std::string& tempPath) { - return m_installerContext.widgetHandle; + if (m_jobStruct.m_installMode == + InstallMode::REINSTALL_MODE_DIRECTORY) + { + // replace widget path to installed path + m_installerContext.locations = + WidgetLocation(DPL::ToUTF8String(m_installerContext.widgetConfig. + tzPkgid), + widgetPath, tempPath, + m_installerContext.widgetConfig.packagingType, + m_installerContext.locationType); + } else { + m_installerContext.locations = + WidgetLocation(DPL::ToUTF8String(m_installerContext.widgetConfig. + tzPkgid), + widgetPath, tempPath, + m_installerContext.widgetConfig.packagingType, + m_installerContext.locationType); + } + m_installerContext.locations->registerAppid( + DPL::ToUTF8String(m_installerContext.widgetConfig.tzAppid)); + + LogInfo("widgetSource " << widgetPath); } -void JobWidgetInstall::configureWidgetLocation(const std::string & widgetPath, bool browserRequest) +ConfigureResult JobWidgetInstall::ConfigureInstallation( + const std::string &widgetSource, + const WrtDB::ConfigParserData &configData, + const std::string &tempPath) { - Try - { - m_installerContext.locations = WidgetLocation(DPL::ToUTF8String(*m_installerContext.widgetConfig.pkgname), - widgetPath, browserRequest, m_installerContext.widgetConfig.pType); + ConfigureResult result = ConfigureResult::Failed; + WidgetUpdateInfo update; + + // checking installed web application + Try { + // checking existing application is installed + WidgetDAOReadOnly dao(m_installerContext.widgetConfig.tzAppid); + // no excpetion means, it isn't update mode + getInstallerStruct().pkgmgrInterface->sendSignal( + PKGMGR_START_KEY, + PKGMGR_START_UPDATE); + + update = detectWidgetUpdate(configData, + m_installerContext.widgetConfig.tzAppid); + result = checkWidgetUpdate(update); + if (result != ConfigureResult::Updated) { + // Already installed TizenAppId. return failed + return ConfigureResult::Failed_AlreadyInstalled; + } + m_installerContext.isUpdateMode = true; } - Catch(FileUtils::CreateDirectoryException) - { - LogError("Failed to create temporary path for widget"); - ReThrowMsg(FileUtils::CreateDirectoryException, "Failed to create temporary path for widget"); + Catch(WidgetDAOReadOnly::Exception::WidgetNotExist) { + result = ConfigureResult::Ok; + getInstallerStruct().pkgmgrInterface->sendSignal( + PKGMGR_START_KEY, + PKGMGR_START_INSTALL); + m_installerContext.isUpdateMode = false; + + if (!validateTizenApplicationID( + m_installerContext.widgetConfig.tzAppid)) + { + LogError("tizen application ID is already used"); + return ConfigureResult::Failed_InvalidConfig; + } + if (!validateTizenPackageID(m_installerContext.widgetConfig.tzPkgid)) { + LogError("tizen package ID is already used"); + return ConfigureResult::Failed_AlreadyInstalled; + } } - LogInfo("widgetSource " << widgetPath); + configureWidgetLocation(widgetSource, tempPath); + + // Init installer context + m_installerContext.installStep = InstallerContext::INSTALL_START; + m_installerContext.job = this; + m_installerContext.widgetConfig.shareHref = std::string(); + + return result; } -JobWidgetInstall::ConfigureResult JobWidgetInstall::ConfigureInstallation( - const std::string &widgetSource, - const WidgetUpdateInfo &update) +bool JobWidgetInstall::validateTizenApplicationID( + const WrtDB::TizenAppId &tizenAppId) { - LogInfo( - "Widget install/update: incoming guid = '" << - update.incomingGUID << "'"); - LogInfo( - "Widget install/update: incoming version = '" << - update.incomingVersion << "'"); - - // Check policy - WidgetUpdateMode::Type updateTypeCheckBit; - - if (update.existingWidgetInfo.isExist == false) { - LogInfo("Widget info does not exist"); - updateTypeCheckBit = WidgetUpdateMode::NotInstalled; - } else { - LogInfo("Widget info exists. Handle: " << - update.existingWidgetInfo.existingHandle); + LogInfo("tizen application ID = [" << tizenAppId << "]"); - DPL::OptionalString pkgname = - WidgetDAOReadOnly(update.existingWidgetInfo.existingHandle).getPkgname(); + regex_t reg; + if (regcomp(®, REG_TIZENID_PATTERN, REG_NOSUB | REG_EXTENDED) != 0) { + LogDebug("Regcomp failed"); + } - if(pkgname.IsNull()) { - LogInfo("But package name doesn't exist"); - return ConfigureResult::Failed; - } + if (regexec(®, DPL::ToUTF8String(tizenAppId).c_str(), 0, NULL, 0) + == REG_NOMATCH) + { + regfree(®); + return false; + } + regfree(®); + return true; +} + +bool JobWidgetInstall::validateTizenPackageID( + const WrtDB::TizenPkgId &tizenPkgId) +{ + std::string pkgId = DPL::ToUTF8String(tizenPkgId); - LogInfo("Widget model exists. package name: " << pkgname); - if (aul_app_is_running(DPL::ToUTF8String(*pkgname).c_str())) { - // Must be deferred when update in progress - if (m_jobStruct.updateMode == WidgetUpdateMode::PolicyWac) { - LogInfo( - "Widget is already running. Policy is update according to WAC"); + std::string installPath = + std::string(GlobalConfig::GetUserInstalledWidgetPath()) + + "/" + pkgId; + std::string preinstallPath = + std::string(GlobalConfig::GetUserPreloadedWidgetPath()) + + "/" + pkgId; - return ConfigureResult::Deferred; - } else { - LogInfo( - "Widget is already running. Policy is not update according to WAC"); - LogInfo("Installation aborted: " << widgetSource); + struct stat dirStat; + if ((stat(installPath.c_str(), &dirStat) == 0) || + (stat(preinstallPath.c_str(), &dirStat) == 0)) + { + return false; + } + return true; +} - return ConfigureResult::Failed; - } - } +ConfigureResult JobWidgetInstall::checkWidgetUpdate( + const WidgetUpdateInfo &update) +{ + LogInfo("incoming version = '" << update.incomingVersion); + LogInfo("Tizen AppID = " << update.tzAppId); - m_installerContext.widgetConfig.pkgname = pkgname; - OptionalWidgetVersion existingVersion; - existingVersion = update.existingWidgetInfo.existingVersion; - OptionalWidgetVersion incomingVersion = update.incomingVersion; + if (update.existingVersion.IsNull() || update.incomingVersion.IsNull()) { + return ConfigureResult::Failed; + } - updateTypeCheckBit = CalcWidgetUpdatePolicy(existingVersion, - incomingVersion); + // Check running state + bool isRunning = false; + int ret = + app_manager_is_running(DPL::ToUTF8String(update.tzAppId).c_str(), + &isRunning); + if (APP_MANAGER_ERROR_NONE != ret) { + LogError("Fail to get running state"); + return ConfigureResult::Failed_WidgetRunning; } - // Calc proceed flag - bool canProceed = (m_jobStruct.updateMode & updateTypeCheckBit) > 0; + if (true == isRunning) { + // get app_context for running application + // app_context must be released with app_context_destroy + app_context_h appCtx = NULL; + ret = + app_manager_get_app_context( + DPL::ToUTF8String(update.tzAppId).c_str(), + &appCtx); + if (APP_MANAGER_ERROR_NONE != ret) { + LogError("Fail to get app_context"); + return ConfigureResult::Failed_WidgetRunning; + } - LogInfo("Whether widget policy allow proceed: " << canProceed); + // terminate app_context_h + ret = app_manager_terminate_app(appCtx); + if (APP_MANAGER_ERROR_NONE != ret) { + LogError("Fail to terminate running application"); + app_context_destroy(appCtx); + return ConfigureResult::Failed_WidgetRunning; + } else { + app_context_destroy(appCtx); + // app_manager_terminate_app isn't sync API + // wait until application isn't running (50ms * 100) + bool isStillRunning = true; + int checkingloop = 100; + struct timespec duration = { 0, 50 * 1000 * 1000 }; + while (--checkingloop >= 0) { + nanosleep(&duration, NULL); + int ret = + app_manager_is_running( + DPL::ToUTF8String(update.tzAppId).c_str(), + &isStillRunning); + if (APP_MANAGER_ERROR_NONE != ret) { + LogError("Fail to get running state"); + return ConfigureResult::Failed_WidgetRunning; + } + if (!isStillRunning) { + break; + } + } + if (isStillRunning) { + LogError("Fail to terminate running application"); + return ConfigureResult::Failed_WidgetRunning; + } + LogInfo("terminate application"); + } + } - // Init installer context - m_installerContext.installStep = InstallerContext::INSTALL_START; - m_installerContext.job = this; - m_installerContext.existingWidgetInfo = update.existingWidgetInfo; - m_installerContext.widgetConfig.shareHref = std::string(); + m_installerContext.widgetConfig.tzAppid = update.tzAppId; - if (m_installerContext.existingWidgetInfo.isExist) { - return canProceed ? ConfigureResult::Updated : ConfigureResult::Failed; + if (isUpperVersion(update.existingVersion, update.incomingVersion) || + (m_jobStruct.m_installMode == InstallMode::INSTALL_MODE_DIRECTORY) || + (m_jobStruct.m_installMode == InstallMode::REINSTALL_MODE_DIRECTORY)) + { + LogInfo("Whether widget policy allow proceed ok"); + return ConfigureResult::Updated; + } else { + return ConfigureResult::Failed_LowerVersion; } - // Return result - return canProceed ? ConfigureResult::Ok : ConfigureResult::Failed; + return ConfigureResult::Failed; } -WidgetUpdateMode::Type JobWidgetInstall::CalcWidgetUpdatePolicy( - const OptionalWidgetVersion &existingVersion, - const OptionalWidgetVersion &incomingVersion) const +bool JobWidgetInstall::isUpperVersion( + const OptionalWidgetVersion &existingVersion, + const OptionalWidgetVersion &incomingVersion) { - // Widget is installed, check versions + LogInfo("Existing version = '" << *existingVersion); + LogInfo("Incoming version = '" << *incomingVersion); + if (!existingVersion && !incomingVersion) { - return WidgetUpdateMode::ExistingVersionEqual; + return false; } else if (!existingVersion && !!incomingVersion) { - return WidgetUpdateMode::ExistingVersionNewer; + return false; } else if (!!existingVersion && !incomingVersion) { - return WidgetUpdateMode::ExistingVersionOlder; + return true; } else { - LogInfo("Existing widget: version = '" << *existingVersion << "'"); - - if (!existingVersion->IsWac() && !incomingVersion->IsWac()) { - return WidgetUpdateMode::BothVersionsNotStd; - } else if (!existingVersion->IsWac()) { - return WidgetUpdateMode::ExistingVersionNotStd; - } else if (!incomingVersion->IsWac()) { - return WidgetUpdateMode::IncomingVersionNotStd; + if (!existingVersion->IsWac() || !incomingVersion->IsWac()) { + return false; } else { - // Both versions are WAC-comparable. Do compare. if (*incomingVersion == *existingVersion) { - return WidgetUpdateMode::ExistingVersionEqual; + return false; } else if (*incomingVersion > *existingVersion) { - return WidgetUpdateMode::ExistingVersionOlder; + return true; } else { - return WidgetUpdateMode::ExistingVersionNewer; + return false; } } } } ConfigParserData JobWidgetInstall::getWidgetDataFromXML( - const std::string &widgetSource, - bool fromBrowser, WrtDB::PkgType isOspsvc) + const std::string &widgetSource, + const std::string &tempPath, + WrtDB::PackagingType pkgType, + bool isDRM, + bool isReinstall) { + // Parse config + ParserRunner parser; + ConfigParserData configInfo; + Try { - // Parse config - ParserRunner parser; - ConfigParserData configInfo; - - if (fromBrowser) { + if (pkgType == PKG_TYPE_HOSTED_WEB_APP) { parser.Parse(widgetSource, ElementParserPtr( new RootParser(configInfo, DPL::FromUTF32String( L"widget")))); - } - else { - // Open zip file - DPL::ScopedPtr zipFile( - new DPL::ZipInput(widgetSource)); + } else if (pkgType == PKG_TYPE_DIRECTORY_WEB_APP) { + std::string configPath; + configPath = tempPath; + configPath += "/"; + configPath += WITH_OSP_XML; + + if (isReinstall) { + // checking RDS data directory + if (access(configPath.c_str(), F_OK) != 0) { + std::string tzAppId = + widgetSource.substr(widgetSource.find_last_of("/")+1); + WidgetDAOReadOnly dao(WidgetDAOReadOnly::getTzAppId(DPL::FromUTF8String(tzAppId))); + configPath = DPL::ToUTF8String(*dao.getWidgetInstalledPath()); + configPath += "/"; + configPath += WITH_OSP_XML; + } + } + parser.Parse(configPath, + ElementParserPtr( + new RootParser( + configInfo, + DPL::FromUTF32String(L"widget")))); + } else { + if (!isDRM) { + std::unique_ptr zipFile( + new DPL::ZipInput(widgetSource)); - DPL::ScopedPtr configFile; + std::unique_ptr configFile; + + // Open config.xml file + if (pkgType == PKG_TYPE_HYBRID_WEB_APP) { + configFile.reset(zipFile->OpenFile(WITH_OSP_XML)); + } else { + configFile.reset(zipFile->OpenFile(CONFIG_XML)); + } - // Open config.xml file - if (isOspsvc == PKG_TYPE_TIZEN_WITHSVCAPP) { - configFile.Reset(zipFile->OpenFile(WITH_OSP_XML)); + // Extract config + DPL::BinaryQueue buffer; + DPL::AbstractWaitableInputAdapter inputAdapter(configFile.get()); + DPL::AbstractWaitableOutputAdapter outputAdapter(&buffer); + DPL::Copy(&inputAdapter, &outputAdapter); + parser.Parse(&buffer, + ElementParserPtr( + new RootParser(configInfo, + DPL:: + FromUTF32String( + L"widget")))); } else { - configFile.Reset(zipFile->OpenFile(CONFIG_XML)); - } + // DRM widget + std::string configFile; + if (pkgType == PKG_TYPE_HYBRID_WEB_APP) { + configFile = tempPath + "/" + WITH_OSP_XML; + } else { + configFile = tempPath + "/" + CONFIG_XML; + } - // Extract config - DPL::BinaryQueue buffer; - DPL::AbstractWaitableInputAdapter inputAdapter(configFile.Get()); - DPL::AbstractWaitableOutputAdapter outputAdapter(&buffer); - DPL::Copy(&inputAdapter, &outputAdapter); - parser.Parse(&buffer, - ElementParserPtr( - new RootParser(configInfo, - DPL::FromUTF32String( - L"widget")))); + parser.Parse(configFile, + ElementParserPtr( + new RootParser(configInfo, + DPL:: + FromUTF32String( + L"widget")))); + } } - - return configInfo; } Catch(DPL::ZipInput::Exception::OpenFailed) { - LogDebug("Failed to open widget package"); + LogError("Failed to open widget package"); return ConfigParserData(); } Catch(DPL::ZipInput::Exception::OpenFileFailed) { - LogDebug("Failed to open config.xml file"); + LogError("Failed to open config.xml file"); return ConfigParserData(); } Catch(DPL::CopyFailed) { - LogDebug("Failed to extract config.xml file"); + LogError("Failed to extract config.xml file"); + return ConfigParserData(); + } + Catch(DPL::FileInput::Exception::OpenFailed) + { + LogError("Failed to open config.xml file"); return ConfigParserData(); } Catch(ElementParser::Exception::ParseError) { - LogDebug("Failed to parse config.xml file"); + LogError("Failed to parse config.xml file"); return ConfigParserData(); } + Catch(DPL::ZipInput::Exception::SeekFileFailed) + { + LogError("Failed to seek widget archive - corrupted package?"); + return ConfigParserData(); + } + return configInfo; } WidgetUpdateInfo JobWidgetInstall::detectWidgetUpdate( - const ConfigParserData &configInfo) + const ConfigParserData &configInfo, + const WrtDB::TizenAppId &tizenId) { LogInfo("Checking up widget package for config.xml..."); + OptionalWidgetVersion incomingVersion; - DPL::OptionalString widgetGUID; - OptionalWidgetVersion widgetVersion; - - // Check widget id - widgetGUID = configInfo.widget_id; - - if (widgetGUID.IsNull()) { - LogDebug("Installed widget has no GUID"); - return WidgetUpdateInfo(); - } - - LogDebug("Installed widget GUID: " << *widgetGUID); - - // Locate widget ID with this GUID - // Incoming widget version if (!configInfo.version.IsNull()) { - widgetVersion = + incomingVersion = DPL::Optional( WidgetVersion(*configInfo.version)); } - Try - { - // Search widget handle by GUID - WidgetDAOReadOnly dao(widgetGUID); - return WidgetUpdateInfo( - widgetGUID, - widgetVersion, - WidgetUpdateInfo::ExistingWidgetInfo( - dao.getHandle(), dao.getVersion())); - } - Catch(WidgetDAOReadOnly::Exception::WidgetNotExist) - { - // GUID isn't installed - return WidgetUpdateInfo( - widgetGUID, - widgetVersion, - WidgetUpdateInfo::ExistingWidgetInfo()); + WidgetDAOReadOnly dao(tizenId); + + OptionalWidgetVersion optVersion; + DPL::OptionalString version = dao.getVersion(); + if (!version.IsNull()) { + optVersion = OptionalWidgetVersion(WidgetVersion(*version)); } + + return WidgetUpdateInfo( + dao.getTzAppId(), + optVersion, + incomingVersion); } void JobWidgetInstall::SendProgress() @@ -601,13 +832,28 @@ void JobWidgetInstall::SendProgress() // send progress signal of pkgmgr std::ostringstream percent; percent << static_cast(GetProgressPercent()); - PkgmgrSignalSingleton::Instance().sendSignal( - PKGMGR_PROGRESS_KEY, - percent.str()); + getInstallerStruct().pkgmgrInterface->sendSignal( + PKGMGR_PROGRESS_KEY, + percent.str()); LogDebug("Call widget install progressCallbak"); - getInstallerStruct().progressCallback(getInstallerStruct().userParam, - GetProgressPercent(),GetProgressDescription()); + getInstallerStruct().progressCallback( + getInstallerStruct().userParam, + GetProgressPercent(), + GetProgressDescription()); + } + } +} + +void JobWidgetInstall::SendProgressIconPath(const std::string &path) +{ + using namespace PackageManager; + if (GetProgressFlag() != false) { + if (getInstallerStruct().progressCallback != NULL) { + // send progress signal of pkgmgr + getInstallerStruct().pkgmgrInterface->sendSignal( + PKGMGR_ICON_PATH, + path); } } } @@ -618,22 +864,32 @@ void JobWidgetInstall::SendFinishedSuccess() // TODO : sync should move to separate task. sync(); + if (INSTALL_LOCATION_TYPE_EXTERNAL == m_installerContext.locationType) { + if (m_installerContext.isUpdateMode) { + WidgetInstallToExtSingleton::Instance().postUpgrade(true); + } else { + WidgetInstallToExtSingleton::Instance().postInstallation(true); + } + WidgetInstallToExtSingleton::Instance().deinitialize(); + } + // remove widget install information file unlink(m_installerContext.installInfo.c_str()); //inform widget info JobWidgetInstall::displayWidgetInfo(); - DPL::Optional handle = getNewWidgetHandle(); + TizenAppId& tizenId = m_installerContext.widgetConfig.tzAppid; // send signal of pkgmgr - PkgmgrSignalSingleton::Instance().sendSignal( - PKGMGR_END_KEY, - PKGMGR_END_SUCCESS); + getInstallerStruct().pkgmgrInterface->sendSignal( + PKGMGR_END_KEY, + PKGMGR_END_SUCCESS); LogDebug("Call widget install successfinishedCallback"); getInstallerStruct().finishedCallback(getInstallerStruct().userParam, - !!handle ? *handle : WrtDB::INVALID_WIDGET_HANDLE, Exceptions::Success); + DPL::ToUTF8String( + tizenId), Jobs::Exceptions::Success); } void JobWidgetInstall::SendFinishedFailure() @@ -642,63 +898,66 @@ void JobWidgetInstall::SendFinishedFailure() // remove widget install information file unlink(m_installerContext.installInfo.c_str()); - LogError("Error in installation step: " << m_exceptionCaught); + LogError("Error number: " << m_exceptionCaught); LogError("Message: " << m_exceptionMessage); - DPL::Optional handle = getNewWidgetHandle(); + TizenAppId & tizenId = m_installerContext.widgetConfig.tzAppid; LogDebug("Call widget install failure finishedCallback"); + std::stringstream errorNum; + errorNum << m_exceptionCaught; // send signal of pkgmgr - PkgmgrSignalSingleton::Instance().sendSignal( - PKGMGR_END_KEY, - PKGMGR_END_FAILURE); + getInstallerStruct().pkgmgrInterface->sendSignal( + PKGMGR_ERROR, + errorNum.str()); + + getInstallerStruct().pkgmgrInterface->sendSignal( + PKGMGR_END_KEY, + PKGMGR_END_FAILURE); getInstallerStruct().finishedCallback(getInstallerStruct().userParam, - !!handle ? *handle : WrtDB::INVALID_WIDGET_HANDLE, m_exceptionCaught); + DPL::ToUTF8String( + tizenId), m_exceptionCaught); } void JobWidgetInstall::SaveExceptionData(const Jobs::JobExceptionBase &e) { - m_exceptionCaught = static_cast(e.getParam()); + m_exceptionCaught = static_cast(e.getParam()); m_exceptionMessage = e.GetMessage(); } void JobWidgetInstall::displayWidgetInfo() { - DPL::Optional handle = getNewWidgetHandle(); - Assert(!!handle); - - WidgetDAOReadOnly dao(*handle); + WidgetDAOReadOnly dao(m_installerContext.widgetConfig.tzAppid); std::ostringstream out; WidgetLocalizedInfo localizedInfo = - W3CFileLocalization::getLocalizedInfo(*handle); + W3CFileLocalization::getLocalizedInfo(dao.getTzAppId()); out << std::endl << - "===================================== INSTALLED WIDGET INFO ========="\ - "============================"; + "===================================== INSTALLED WIDGET INFO =========" \ + "============================"; out << std::endl << "Name: " << localizedInfo.name; - out << std::endl << "PkgName: " << dao.getPkgname(); + out << std::endl << "AppId: " << dao.getTzAppId(); WidgetSize size = dao.getPreferredSize(); out << std::endl << "Width: " << size.width; out << std::endl << "Height: " << size.height; out << std::endl << "Start File: " << - W3CFileLocalization::getStartFile(*handle); + W3CFileLocalization::getStartFile(dao.getTzAppId()); out << std::endl << "Version: " << dao.getVersion(); out << std::endl << "Licence: " << - localizedInfo.license; + localizedInfo.license; out << std::endl << "Licence Href: " << - localizedInfo.licenseHref; + localizedInfo.licenseHref; out << std::endl << "Description: " << - localizedInfo.description; + localizedInfo.description; out << std::endl << "Widget Id: " << dao.getGUID(); out << std::endl << "Widget recognized: " << dao.isRecognized(); - out << std::endl << "Widget wac signed: " << dao.isWacSigned(); out << std::endl << "Widget distributor signed: " << - dao.isDistributorSigned(); + dao.isDistributorSigned(); out << std::endl << "Widget trusted: " << dao.isTrusted(); - OptionalWidgetIcon icon = W3CFileLocalization::getIcon(*handle); + OptionalWidgetIcon icon = W3CFileLocalization::getIcon(dao.getTzAppId()); DPL::OptionalString iconSrc = !!icon ? icon->src : DPL::OptionalString::Null; out << std::endl << "Icon: " << iconSrc; @@ -709,9 +968,9 @@ void JobWidgetInstall::displayWidgetInfo() FOREACH(it, list) { out << std::endl << " Key: " << - it->key_name; + it->key_name; out << std::endl << " Readonly: " << - it->readonly; + it->readonly; } } @@ -721,8 +980,6 @@ void JobWidgetInstall::displayWidgetInfo() FOREACH(it, list) { out << std::endl << " Name: " << it->name; - out << std::endl << " Required: " << it->required; - out << std::endl << " Params:"; } } @@ -732,63 +989,134 @@ void JobWidgetInstall::displayWidgetInfo() } WrtDB::PackagingType JobWidgetInstall::checkPackageType( - const std::string &widgetSource) + const std::string &widgetSource, + const std::string &tempPath) { - using namespace WrtDB; - - PackagingType pType = PKG_TYPE_UNKNOWN; - DPL::ScopedPtr zipFile; - - Try + // Check installation type (direcotory/ or config.xml or widget.wgt) + if (m_jobStruct.m_installMode == InstallMode::INSTALL_MODE_DIRECTORY || + m_jobStruct.m_installMode == InstallMode::REINSTALL_MODE_DIRECTORY) { - // Open zip file - zipFile.Reset(new DPL::ZipInput(widgetSource)); - + LogDebug("Install directly from directory"); + return PKG_TYPE_DIRECTORY_WEB_APP; } - Catch(DPL::ZipInput::Exception::OpenFailed) - { - LogDebug("Failed to open widget package"); - return PKG_TYPE_UNKNOWN; + if (hasExtension(widgetSource, XML_EXTENSION)) { + LogInfo("Hosted app installation"); + return PKG_TYPE_HOSTED_WEB_APP; } - Try - { - // Open config.xml file in package root - DPL::ScopedPtr configFile( + if (m_isDRM) { + std::string configFile = tempPath + "/" + CONFIG_XML; + if (WrtUtilFileExists(configFile)) { + return PKG_TYPE_NOMAL_WEB_APP; + } + + configFile = tempPath + "/" + WITH_OSP_XML; + if (WrtUtilFileExists(configFile)) { + return PKG_TYPE_HYBRID_WEB_APP; + } + } else { + std::unique_ptr zipFile; + + Try + { + // Open zip file + zipFile.reset(new DPL::ZipInput(widgetSource)); + } + Catch(DPL::ZipInput::Exception::OpenFailed) + { + LogDebug("Failed to open widget package"); + return PKG_TYPE_UNKNOWN; + } + Catch(DPL::ZipInput::Exception::SeekFileFailed) + { + LogError("Failed to seek widget package file"); + return PKG_TYPE_UNKNOWN; + } + + Try + { + // Open config.xml file in package root + std::unique_ptr configFile( zipFile->OpenFile(CONFIG_XML)); - pType = PKG_TYPE_TIZEN_WEBAPP; - } - Catch(DPL::ZipInput::Exception::OpenFileFailed) - { - LogDebug("Could not find config.xml"); - } + return PKG_TYPE_NOMAL_WEB_APP; + } + Catch(DPL::ZipInput::Exception::OpenFileFailed) + { + LogDebug("Could not find config.xml"); + } - Try - { - // Open config.xml file in package root - DPL::ScopedPtr configFile( + Try + { + // Open config.xml file in package root + std::unique_ptr configFile( zipFile->OpenFile(WITH_OSP_XML)); - if (pType == PKG_TYPE_TIZEN_WEBAPP) { + + return PKG_TYPE_HYBRID_WEB_APP; + } + Catch(DPL::ZipInput::Exception::OpenFileFailed) + { + LogDebug("Could not find wgt/config.xml"); return PKG_TYPE_UNKNOWN; } + } + + return PKG_TYPE_UNKNOWN; +} + +void JobWidgetInstall::setApplicationType( + const WrtDB::ConfigParserData &configInfo) +{ + FOREACH(iterator, configInfo.nameSpaces) { + LogInfo("namespace = [" << *iterator << "]"); + AppType currentAppType = APP_TYPE_UNKNOWN; + + if (*iterator == ConfigurationNamespace::W3CWidgetNamespaceName) { + continue; + } else if ( + *iterator == + ConfigurationNamespace::WacWidgetNamespaceNameForLinkElement || + *iterator == + ConfigurationNamespace::WacWidgetNamespaceName) + { + currentAppType = APP_TYPE_WAC20; + } else if (*iterator == + ConfigurationNamespace::TizenWebAppNamespaceName) + { + currentAppType = APP_TYPE_TIZENWEBAPP; + } - pType = PKG_TYPE_TIZEN_WITHSVCAPP; + if (m_installerContext.widgetConfig.webAppType == + APP_TYPE_UNKNOWN) + { + m_installerContext.widgetConfig.webAppType = currentAppType; + } else if (m_installerContext.widgetConfig.webAppType == + currentAppType) + { + continue; + } else { + ThrowMsg(Exceptions::WidgetConfigFileInvalid, + "Config.xml has more than one namespace"); + } } - Catch(DPL::ZipInput::Exception::OpenFileFailed) - { - LogDebug("Could not find wgt/config.xml"); - return PKG_TYPE_UNKNOWN; + + // If there is no define, type set to WAC 2.0 + if (m_installerContext.widgetConfig.webAppType == APP_TYPE_UNKNOWN) { + m_installerContext.widgetConfig.webAppType = APP_TYPE_WAC20; } - return pType; + LogInfo("type = [" << + m_installerContext.widgetConfig.webAppType.getApptypeToString() << + "]"); } -bool JobWidgetInstall::detectResourceEncryption(const WrtDB::ConfigParserData &configData) +bool JobWidgetInstall::detectResourceEncryption( + const WrtDB::ConfigParserData &configData) { FOREACH(it, configData.settingsList) { if (it->m_name == SETTING_VALUE_ENCRYPTION && - it->m_value == SETTING_VALUE_ENCRYPTION_ENABLE) { + it->m_value == SETTING_VALUE_ENCRYPTION_ENABLE) + { LogDebug("resource need encryption"); return true; } @@ -796,5 +1124,42 @@ bool JobWidgetInstall::detectResourceEncryption(const WrtDB::ConfigParserData &c return false; } +void JobWidgetInstall::setInstallLocationType( + const + WrtDB::ConfigParserData & + configData) +{ + m_installerContext.locationType = INSTALL_LOCATION_TYPE_NOMAL; + + if (m_jobStruct.m_installMode == InstallMode::INSTALL_MODE_PRELOAD) { + m_installerContext.locationType = + INSTALL_LOCATION_TYPE_PRELOAD; + } else { + FOREACH(it, configData.settingsList) + { + if (it->m_name == SETTING_VALUE_INSTALLTOEXT_NAME && + it->m_value == + SETTING_VALUE_INSTALLTOEXT_PREPER_EXT) + { + LogDebug("This widget will be installed to sd card"); + m_installerContext.locationType = + INSTALL_LOCATION_TYPE_EXTERNAL; + } + } + } +} + +bool JobWidgetInstall::isDRMWidget(std::string /*widgetPath*/) +{ + /* TODO */ + return false; +} + +bool JobWidgetInstall::DecryptDRMWidget(std::string /*widgetPath*/, + std::string /*destPath*/) +{ + /* TODO */ + return false; +} } //namespace WidgetInstall } //namespace Jobs