Uninstall updates for csc preloaded app

Change-Id: Ie9eccb2baeeca3fa0e0b1f295fb7e9340d1942a7
Signed-off-by: Duyoung Jang <duyoung.jang@samsung.com>

diff --git a/inc/InstallerDefs.h b/inc/InstallerDefs.h
index c5ee8e7..1a6b11d 100755 (executable)
--- a/inc/InstallerDefs.h
+++ b/inc/InstallerDefs.h
@@ -23,7 +23,7 @@
 
 #include "InstallerUtil.h"
 
-#define OSP_INSTALLER_VERSION "version=[20130612.2]"
+#define OSP_INSTALLER_VERSION "version=[20130613.1]"
 
 #define DIR_BIN                                L"/bin"
 #define DIR_INFO                       L"/info"

diff --git a/src/Context/InstallationContext.h b/src/Context/InstallationContext.h
index d6f939d..16ab280 100755 (executable)
--- a/src/Context/InstallationContext.h
+++ b/src/Context/InstallationContext.h
@@ -144,6 +144,7 @@ public:
        Tizen::Base::String __description;
        Tizen::App::PackageId __storeClientId;
        Tizen::Base::String __additionalErrorString;
+       Tizen::Base::String __cscInfo;
 
        int __certType;
        void* __pPkgmgrInstaller;

diff --git a/src/Manager/InstallerManager.cpp b/src/Manager/InstallerManager.cpp
index 1c42b91..6083af7 100755 (executable)
--- a/src/Manager/InstallerManager.cpp
+++ b/src/Manager/InstallerManager.cpp
@@ -185,6 +185,7 @@ InstallerManager::Construct(const String& path, InstallerOperation operation, In
                        {
                                AppLog("INSTALLER_OPTION_CSC is detected.");
                                __pContext->__isCsc = true;
+                               __pContext->__cscInfo = *pOptionalData;
                        }
 
                        installerType = INSTALLER_TYPE_PACKAGE;
@@ -479,6 +480,7 @@ InstallerManager::ParseOptionalData(const String* pOptionalData)
 
                String storeClientId;
                String removable;
+               String path;
 
                while (pEnum->MoveNext() == E_SUCCESS)
                {
@@ -499,6 +501,11 @@ InstallerManager::ParseOptionalData(const String* pOptionalData)
                        {
                                removable = (*pValue);
                        }
+
+                       if (pKey->Equals(L"path", false) == true)
+                       {
+                               path = (*pValue);
+                       }
                }
 
                if (storeClientId.IsEmpty() == false)
@@ -512,6 +519,18 @@ InstallerManager::ParseOptionalData(const String* pOptionalData)
                        __pContext->__isUninstallable = true;
                        AppLog(" # removable = [true]");
                }
+
+               if (__pContext->__isCsc == true)
+               {
+                       if (path.IsEmpty() == false)
+                       {
+                               std::unique_ptr< PackageInfo > pPackageInfo(_PackageManagerImpl::GetInstance()->GetPackageInfoFromFileN(path));
+                               TryReturn(pPackageInfo, false, "GetPackageInfoFromFileN() failed. [%s]", GetErrorMessage(GetLastResult()));
+
+                               __pContext->__packageId = pPackageInfo->GetId();
+                               AppLog(" # packageId = [%ls]", __pContext->__packageId.GetPointer());
+                       }
+               }
        }
 
        return true;
@@ -940,16 +959,20 @@ InstallerManager::SendEvent(InstallationContext* pContext, const PackageId& pack
 }
 
 bool
-InstallerManager::IsUninstallUpdates(const PackageId& packageId, String& originPath)
+InstallerManager::IsUninstallUpdates(const PackageId& packageId, String& originPath, bool& isCscPackage)
 {
+       String cscInfo;
        String roXmlPath;
        roXmlPath.Format(1024, DIR_RO_PACKAGE_SYSTEM_MANIFEST, packageId.GetPointer());
+
        if (File::IsFileExist(roXmlPath) == true)
        {
                String rwXmlPath;
                rwXmlPath.Format(1024, DIR_RW_PACKAGE_SYSTEM_MANIFEST, packageId.GetPointer());
                if (File::IsFileExist(rwXmlPath) == true)
                {
+                       InstallerUtil::Remove(rwXmlPath);
+
                        String preloadedAppPath(PATH_USR_APPS);
                        preloadedAppPath += L"/";
                        preloadedAppPath += packageId;
@@ -960,12 +983,53 @@ InstallerManager::IsUninstallUpdates(const PackageId& packageId, String& originP
                        return true;
                }
        }
-       else
+       else if(InstallerUtil::IsCscPackage(packageId, cscInfo) == true)
        {
-               //if (CSC_preloaded && update)
-               //{
-               //      originPath = cscPackagePath;
-               //}
+               String tokenDelimiter(":");
+
+               std::unique_ptr< IMap > pMap(InstallerUtil::ParseN(cscInfo, tokenDelimiter));
+               TryReturn(pMap, false, "ParseN() failed. [%s]", GetErrorMessage(GetLastResult()));
+
+               std::unique_ptr< IMapEnumerator > pEnum(pMap->GetMapEnumeratorN());
+               TryReturn(pEnum, false, "GetMapEnumeratorN() failed. [%s]", GetErrorMessage(GetLastResult()));
+
+               String removable;
+               String path;
+
+               while (pEnum->MoveNext() == E_SUCCESS)
+               {
+                       String* pKey = static_cast< String* > (pEnum->GetKey());
+                       TryReturn(pEnum, false, "GetKey() failed. [%s]", GetErrorMessage(GetLastResult()));
+
+                       String* pValue = static_cast< String* > (pEnum->GetValue());
+                       TryReturn(pEnum, false, "GetValue() failed. [%s]", GetErrorMessage(GetLastResult()));
+
+                       AppLog("key = [%ls], value = [%ls]", pKey->GetPointer(), pValue->GetPointer());
+
+                       if (pKey->Equals(L"removable", false) == true)
+                       {
+                               removable = (*pValue);
+                       }
+
+                       if (pKey->Equals(L"path", false) == true)
+                       {
+                               path = (*pValue);
+                       }
+               }
+
+               if (removable.Equals(L"false", false) == true)
+               {
+                       isCscPackage = true;
+
+                       AppLog("uninstall updates for csc-preloaded app [%ls]", path.GetPointer());
+                       originPath = cscInfo;
+
+                       return true;
+               }
+               else
+               {
+                       AppLog("uninstall package for csc-preloaded app. [%ls]");
+               }
        }
 
        return false;
@@ -1356,7 +1420,7 @@ CATCH:
 }
 
 int
-InstallerManager::RequestCsc(const String& buffer, InstallerOption option)
+InstallerManager::RequestCsc(const String& buffer, InstallerOption option, void* pPkgmgrInstaller)
 {
        int errorType = 0;
 
@@ -1406,7 +1470,7 @@ InstallerManager::RequestCsc(const String& buffer, InstallerOption option)
 
        if (op.Equals(L"install", false) == true)
        {
-               errorType = InstallerManager::Request(path, INSTALLER_OPERATION_INSTALL, option, null, &buffer);
+               errorType = InstallerManager::Request(path, INSTALLER_OPERATION_INSTALL, option, pPkgmgrInstaller, &buffer);
        }
        else if (op.Equals(L"uninstall", false) == true)
        {

diff --git a/src/Manager/InstallerManager.h b/src/Manager/InstallerManager.h
index 28aff72..530d113 100755 (executable)
--- a/src/Manager/InstallerManager.h
+++ b/src/Manager/InstallerManager.h
@@ -61,14 +61,14 @@ public:
        bool IsHistoryFileLogOn() const;
 
        static bool SendEvent(InstallationContext* pContext, const Tizen::App::PackageId& packageId, const Tizen::Base::String& key, const Tizen::Base::String& val);
-       static bool IsUninstallUpdates(const Tizen::App::PackageId& packageId, Tizen::Base::String& originPath);
+       static bool IsUninstallUpdates(const Tizen::App::PackageId& packageId, Tizen::Base::String& originPath, bool& isCscPackage);
 
        static int Request(const Tizen::Base::String& path, InstallerOperation operation, InstallerOption option, void* pPkgmgrInstaller, const Tizen::Base::String* pOptionalData = null);
        static int RequestRecursiveDirectory(const Tizen::Base::String& path, int& errorType);
        static int RequestByCommand(int argc, char **argv);
        static int ReqeustByTest(void);
        static int RequestMove(const Tizen::App::PackageId& packageId, int moveType);
-       static int RequestCsc(const Tizen::Base::String& buffer, InstallerOption option);
+       static int RequestCsc(const Tizen::Base::String& buffer, InstallerOption option, void* pPkgmgrInstaller = null);
 
 private:
        InstallerManager(const InstallerManager& value);

diff --git a/src/Util/InstallerUtil.cpp b/src/Util/InstallerUtil.cpp
index 73ca8cb..96f2f6d 100755 (executable)
--- a/src/Util/InstallerUtil.cpp
+++ b/src/Util/InstallerUtil.cpp
@@ -1055,6 +1055,7 @@ bool
 InstallerUtil::TerminateApps(const PackageId& packageId)
 {
        std::unique_ptr< PackageInfo > pPackageInfo(_PackageManagerImpl::GetInstance()->GetPackageInfoN(packageId));
+       TryReturn(pPackageInfo, false, "GetPackageInfoN() failed.");
 
        _PackageInfoImpl* pPackageInfoImpl = _PackageInfoImpl::GetInstance(pPackageInfo.get());
        TryReturn(pPackageInfoImpl, false, "GetInstance() failed.");
@@ -1073,3 +1074,56 @@ InstallerUtil::TerminateApps(const PackageId& packageId)
 
        return true;
 }
+
+bool
+InstallerUtil::IsUninstallable(const PackageId& packageId)
+{
+       bool res = false;
+
+       std::unique_ptr< PackageInfo > pPackageInfo(_PackageManagerImpl::GetInstance()->GetPackageInfoN(packageId));
+       TryReturn(pPackageInfo, false, "GetPackageInfoN() failed.");
+
+       _PackageInfoImpl* pPackageInfoImpl = _PackageInfoImpl::GetInstance(pPackageInfo.get());
+       TryReturn(pPackageInfoImpl, false, "GetInstance() failed.");
+
+       res = pPackageInfoImpl->IsUninstallable();
+
+       AppLog("packageId[%ls]: Uninstallable = [%s]", packageId.GetPointer(), res?"true":"false");
+
+       return res;
+}
+
+bool
+InstallerUtil::IsCscPackage(const PackageId& packageId, String& cscInfo)
+{
+       bool res = false;
+       int result = 0;
+       char* pPath = null;
+       pkgmgrinfo_pkginfo_h handle = null;
+
+       std::unique_ptr<char[]> pPackageId(_StringConverter::CopyToCharArrayN(packageId));
+       TryReturn(pPackageId, false, "pPackageId is null.");
+
+       result = pkgmgrinfo_pkginfo_get_pkginfo(pPackageId.get(), &handle);
+       TryReturn(result == PMINFO_R_OK, false, "pkgmgrinfo_pkginfo_get_pkginfo() failed. result=[%d], package=[%s]", result, pPackageId.get());
+
+       result = pkgmgrinfo_pkginfo_get_csc_path(handle, &pPath);
+       TryReturn(result == PMINFO_R_OK, false, "pkgmgrinfo_pkginfo_get_csc_path() failed. result=[%d], package=[%s]", result, pPackageId.get());
+
+       AppLog("csc_path = [%s]", pPath);
+
+       cscInfo = pPath;
+
+       if (cscInfo.IsEmpty() == false)
+       {
+               res = true;
+               AppLog("packageId[%ls]: cscInfo = [%ls]", packageId.GetPointer(), cscInfo.GetPointer());
+       }
+
+       if (handle)
+       {
+               pkgmgrinfo_pkginfo_destroy_pkginfo(handle);
+       }
+
+       return res;
+}

diff --git a/src/Util/InstallerUtil.h b/src/Util/InstallerUtil.h
index 37a35d1..9e17370 100755 (executable)
--- a/src/Util/InstallerUtil.h
+++ b/src/Util/InstallerUtil.h
@@ -89,6 +89,9 @@ public:
        static bool TerminateApp(const Tizen::App::AppId& appId);
        static bool TerminateApps(const Tizen::App::PackageId& packageId);
 
+       static bool IsUninstallable(const Tizen::App::PackageId& packageId);
+       static bool IsCscPackage(const Tizen::App::PackageId& packageId, Tizen::Base::String& cscInfo);
+
 private:
        static char LogChangeHexToStr(int hex);
        InstallerUtil(const InstallerUtil& value);

diff --git a/src/XmlHandler/ManifestGenerator.cpp b/src/XmlHandler/ManifestGenerator.cpp
index d762a00..1c931b0 100755 (executable)
--- a/src/XmlHandler/ManifestGenerator.cpp
+++ b/src/XmlHandler/ManifestGenerator.cpp
@@ -92,6 +92,7 @@ ManifestGenerator::Write()
        __pWriter->WriteAttribute("appsetting", appSetting);
        __pWriter->WriteAttribute("storeclient-id", __pContext->__storeClientId);
        __pWriter->WriteAttribute("url", __pContext->__url);
+       __pWriter->WriteAttribute("csc_path", __pContext->__cscInfo);
 
        __pWriter->StartElement("label");
        __pWriter->WriteString(__pContext->__displayName);

diff --git a/src/backend/backend.cpp b/src/backend/backend.cpp
index 840a412..070f842 100755 (executable)
--- a/src/backend/backend.cpp
+++ b/src/backend/backend.cpp
@@ -172,17 +172,28 @@ main(int argc, char **argv)
 
        case PKGMGR_REQ_UNINSTALL:
                {
+                       bool isCscPackage = false;
                        PackageId reqeustPackageId;
                        path.SubString(0, PACKAGE_ID_LENGTH, reqeustPackageId);
                        AppLog("reqeustPackage = %ls", reqeustPackageId.GetPointer());
 
                        String originPath;
-                       if (InstallerManager::IsUninstallUpdates(reqeustPackageId, originPath) == true)
+                       if (InstallerManager::IsUninstallUpdates(reqeustPackageId, originPath, isCscPackage) == true)
                        {
-                               AppLog("originPath = [%ls]", originPath.GetPointer());
-
+                               AppLog("originPath = [%ls], isCscPackage = [%s]", originPath.GetPointer(), isCscPackage?"true":"false");
                                optionalData = reqeustPackageId;
-                               errorType = InstallerManager::Request(originPath, INSTALLER_OPERATION_INSTALL, INSTALLER_OPTION_RESET_PRELOADED, _pi, &optionalData);
+
+                               if (isCscPackage == false)
+                               {
+                                       errorType = InstallerManager::Request(originPath, INSTALLER_OPERATION_INSTALL, INSTALLER_OPTION_RESET_PRELOADED, _pi, &optionalData);
+                               }
+                               else
+                               {
+                                       InstallerOption option = INSTALLER_OPTION_RESET_PRELOADED;
+                                       option = (InstallerOption)(option | INSTALLER_OPTION_CSC);
+
+                                       errorType = InstallerManager::RequestCsc(originPath, option, _pi);
+                               }
                        }
                        else
                        {