diff --git a/frameworks/bundle_lite/include/bundlems_slite_client.h b/frameworks/bundle_lite/include/bundlems_slite_client.h
index 8e5d9ecf0bc8931cad6c93c661172b36737d58a3..a96f37d3d38b3d9ad17df03ae3b679bb529a44c1 100755
--- a/frameworks/bundle_lite/include/bundlems_slite_client.h
+++ b/frameworks/bundle_lite/include/bundlems_slite_client.h
@@ -47,7 +47,7 @@ public:
 
     bool GetInstallState(const char *bundleName, InstallState *installState, uint8_t *installProcess) const;
 
-    bool GetUninstallState(const char *bundleName, UninstallState *uninstallState) const;
+    uint32_t GetBundleSize(const char *bundleName) const;
 
 private:
     BundleMsClient() = default;
diff --git a/frameworks/bundle_lite/src/slite/bundle_manager_inner.cpp b/frameworks/bundle_lite/src/slite/bundle_manager_inner.cpp
index 853b04e503672acdb2eda87ef398e38682944d36..04c4e1b0827cf76e1f66b4da4ee1092a6d455f73 100755
--- a/frameworks/bundle_lite/src/slite/bundle_manager_inner.cpp
+++ b/frameworks/bundle_lite/src/slite/bundle_manager_inner.cpp
@@ -24,8 +24,8 @@ bool GetInstallState(const char *bundleName, InstallState *installState, uint8_t
     return OHOS::BundleMsClient::GetInstance().GetInstallState(bundleName, installState, installProcess);
 }
 
-bool GetUninstallState(const char *bundleName, UninstallState *uninstallState)
+uint32_t GetBundleSize(const char *bundleName)
 {
-    return OHOS::BundleMsClient::GetInstance().GetUninstallState(bundleName, uninstallState);
+    return OHOS::BundleMsClient::GetInstance().GetBundleSize(bundleName);
 }
 }
diff --git a/frameworks/bundle_lite/src/slite/bundlems_slite_client.cpp b/frameworks/bundle_lite/src/slite/bundlems_slite_client.cpp
index 60a7185aa4458a8d773629cecb637dcee4393ea0..ba326bc2bc3ad77dd1d9df58ecee398a6cc92a89 100755
--- a/frameworks/bundle_lite/src/slite/bundlems_slite_client.cpp
+++ b/frameworks/bundle_lite/src/slite/bundlems_slite_client.cpp
@@ -158,11 +158,11 @@ bool BundleMsClient::GetInstallState (const char *bundleName, InstallState *inst
     return bmsProxy_->GetInstallState(bundleName, installState, installProcess);
 }
 
-bool BundleMsClient::GetUninstallState (const char *bundleName, UninstallState *uninstallState) const
+uint32_t BundleMsClient::GetBundleSize (const char *bundleName) const
 {
     if (!Initialize()) {
-        return false;
+        return -1;
     }
-    return bmsProxy_->GetUninstallState(bundleName, uninstallState);
+    return bmsProxy_->GetBundleSize(bundleName);
 }
 } //  namespace OHOS
diff --git a/interfaces/innerkits/bundlemgr_lite/bundle_service_interface.h b/interfaces/innerkits/bundlemgr_lite/bundle_service_interface.h
index 271375a9dfaa4c4fc7c7d997c98e0c9e2cae900e..fec629bfa11cbc4daef9d6414ca084cf1599bda1 100755
--- a/interfaces/innerkits/bundlemgr_lite/bundle_service_interface.h
+++ b/interfaces/innerkits/bundlemgr_lite/bundle_service_interface.h
@@ -50,7 +50,7 @@ struct BmsSliteInterface {
     uint8_t (*GetBundleInfo)(const char *bundleName, int32_t flags, BundleInfo *bundleInfo);
     uint8_t (*GetBundleInfos)(int32_t flags, BundleInfo **bundleInfos, int32_t *len);
     bool (*GetInstallState)(const char *bundleName, InstallState *installState, uint8_t *installProcess);
-    bool (*GetUninstallState)(const char *bundleName, UninstallState *uninstallState);
+    uint32_t (*GetBundleSize)(const char *bundleName);
 };
 #ifdef __cplusplus
 #if __cplusplus
diff --git a/interfaces/innerkits/bundlemgr_lite/slite/bundle_install_msg.h b/interfaces/innerkits/bundlemgr_lite/slite/bundle_install_msg.h
index 552a04ad31e991a95f255a8b1ac2f0b6ffea4fcd..77523d537267542afb783e07fc9514465f0aba6a 100644
--- a/interfaces/innerkits/bundlemgr_lite/slite/bundle_install_msg.h
+++ b/interfaces/innerkits/bundlemgr_lite/slite/bundle_install_msg.h
@@ -27,7 +27,10 @@ extern "C" {
 typedef enum {
     BUNDLE_INSTALL_DOING = 0,
     BUNDLE_INSTALL_OK = 1,
-    BUNDLE_INSTALL_FAIL = 2
+    BUNDLE_INSTALL_FAIL = 2,
+    BUNDLE_UNINSTALL_DOING = 3,
+    BUNDLE_UNINSTALL_OK = 4,
+    BUNDLE_UNINSTALL_FAIL = 5
 } InstallState;
 
 typedef struct {
@@ -39,12 +42,6 @@ typedef struct {
     uint8_t installProcess;
 } BundleInstallMsg;
 
-typedef enum {
-    BUNDLE_UNINSTALL_DOING = 0,
-    BUNDLE_UNINSTALL_OK = 1,
-    BUNDLE_UNINSTALL_FAIL = 2
-} UninstallState;
-
 /**
  * @brief Get the install state and install process of the bundle.
  *
@@ -59,14 +56,13 @@ typedef enum {
 bool GetInstallState(const char *bundleName, InstallState *installState, uint8_t *installProcess);
 
 /**
- * @brief Get the uninstall state and uninstall state of the bundle.
+ * @brief Get the bundle size.
  *
  * @param bundleName Indicates the name of the bundle.
- * @param uninstallState Obtains uninstall state.
- * @return Returns success or not.
+ * @return Returns bundle size or returns 0 if get bundle size failed.
  *
  */
-bool GetUninstallState(const char *bundleName, UninstallState *uninstallState);
+uint32_t GetBundleSize(const char *bundleName);
 
 #ifdef __cplusplus
 #if __cplusplus
diff --git a/services/bundlemgr_lite/include/bundle_mgr_slite_feature.h b/services/bundlemgr_lite/include/bundle_mgr_slite_feature.h
index 6bdfe1b81f88f060fa1bf4549d4fcf8c71af8b00..b81bdf48025f42bc005e1ed61535f4deaf843b91 100755
--- a/services/bundlemgr_lite/include/bundle_mgr_slite_feature.h
+++ b/services/bundlemgr_lite/include/bundle_mgr_slite_feature.h
@@ -36,7 +36,7 @@ public:
     static uint8_t GetBundleInfo(const char *bundleName, int32_t flags, BundleInfo *bundleInfo);
     static uint8_t GetBundleInfos(int32_t flags, BundleInfo **bundleInfos, int32_t *len);
     static bool GetInstallState(const char *bundleName, InstallState *installState, uint8_t *installProcess);
-    static bool GetUninstallState(const char *bundleName, UninstallState *uninstallState);
+    static uint32_t GetBundleSize (const char *bundleName);
 
     static BundleMgrSliteFeature *GetInstance()
     {
diff --git a/services/bundlemgr_lite/include/bundle_util.h b/services/bundlemgr_lite/include/bundle_util.h
index 890c763a47d6467102fdf0f08d04a6c00c51787b..4a2e11c3917f6e655665a915d40d7f9ce453c6a8 100755
--- a/services/bundlemgr_lite/include/bundle_util.h
+++ b/services/bundlemgr_lite/include/bundle_util.h
@@ -36,6 +36,8 @@ public:
     static bool StartWith(const char *str, const char *subStr);
     static cJSON *GetJsonStream(const char *path);
     static uint32_t GetFileSize(const char *filePath);
+    static uint32_t GetFileFolderSize(const char *filePath);
+    static uint32_t GetCurrentFolderSize(const char *dirPath, List<char *>* list);
     static cJSON *ConvertInstallRecordToJson(const InstallRecord &installRecord);
     static char *GetValueFromBundleJson(const char *bundleName, const char *key);
     static int32_t GetValueFromBundleJson(const char *bundleName, const char *key, int32_t defaultValue);
diff --git a/services/bundlemgr_lite/include/gt_bundle_extractor.h b/services/bundlemgr_lite/include/gt_bundle_extractor.h
index abc321b9bdc9b26c84224eda3e52730496b34ce1..037a1565eab8e2bcc612f4919ccab7ab8641b382 100644
--- a/services/bundlemgr_lite/include/gt_bundle_extractor.h
+++ b/services/bundlemgr_lite/include/gt_bundle_extractor.h
@@ -26,7 +26,7 @@ public:
         uint8_t bundleStyle);
     static char *ExtractHapProfile(int32_t fp, uint32_t totalFileSize);
     static uint8_t ExtractBundleParam(const char *path, int32_t &fpStart, char **bundleName);
-    static bool ExtractInstallMsg(const char *path, char **bundleName, char **label, char **smallIconPath,
+    static uint8_t ExtractInstallMsg(const char *path, char **bundleName, char **label, char **smallIconPath,
         char **bigIconPath);
 private:
     static uint8_t ExtractFileDataPos(int32_t fp, uint64_t &filePos);
diff --git a/services/bundlemgr_lite/include/gt_bundle_manager_service.h b/services/bundlemgr_lite/include/gt_bundle_manager_service.h
index 48b7afcc2c529f5703b540a455aca8c35b78a057..4f0564bcce48a2c954372bf0d5449f7e255ab702 100755
--- a/services/bundlemgr_lite/include/gt_bundle_manager_service.h
+++ b/services/bundlemgr_lite/include/gt_bundle_manager_service.h
@@ -49,11 +49,6 @@ typedef enum {
     BUNDLE_UPDATE,
 } BundleState;
 
-typedef struct {
-    char *bundleName;
-    UninstallState uninstallState;
-} BundleUninstallMsg;
-
 class GtManagerService {
 public:
     static GtManagerService &GetInstance()
@@ -79,10 +74,10 @@ public:
     void ReduceNumOfThirdBundles();
     int32_t ReportInstallCallback(uint8_t errCode, uint8_t installState,
         uint8_t process, InstallerCallback installerCallback);
-    int32_t ReportUninstallCallback(uint8_t errCode, char *bundleName,
+    int32_t ReportUninstallCallback(uint8_t errCode, uint8_t installState, char *bundleName,
         uint8_t process, InstallerCallback installerCallback);
     bool GetInstallState(const char *bundleName, InstallState *installState, uint8_t *installProcess);
-    bool GetUninstallState(const char *bundleName, UninstallState *uninstallState);
+    uint32_t GetBundleSize(const char *bundleName);
 
 private:
     GtManagerService();
@@ -112,7 +107,6 @@ private:
     BundleMap *bundleMap_;
     List<BundleRes *> *bundleResList_;
     BundleInstallMsg *bundleInstallMsg_;
-    BundleUninstallMsg *bundleUninstallMsg_;
     char *jsEngineVer_;
     uint32_t installedThirdBundleNum_;
 };
diff --git a/services/bundlemgr_lite/src/bundle_mgr_slite_feature.cpp b/services/bundlemgr_lite/src/bundle_mgr_slite_feature.cpp
index 4a019ee71175d7a389605cbe9775e720b649b7fe..5b12cff9841c1b5405284a983fd7aaaf9596f714 100755
--- a/services/bundlemgr_lite/src/bundle_mgr_slite_feature.cpp
+++ b/services/bundlemgr_lite/src/bundle_mgr_slite_feature.cpp
@@ -33,7 +33,7 @@ BundleMgrSliteFeatureImpl g_bmsSliteImpl = {
     .GetBundleInfo = BundleMgrSliteFeature::GetBundleInfo,
     .GetBundleInfos = BundleMgrSliteFeature::GetBundleInfos,
     .GetInstallState = BundleMgrSliteFeature::GetInstallState,
-    .GetUninstallState = BundleMgrSliteFeature::GetUninstallState,
+    .GetBundleSize = BundleMgrSliteFeature::GetBundleSize,
     DEFAULT_IUNKNOWN_ENTRY_END
 };
 
@@ -128,8 +128,8 @@ bool BundleMgrSliteFeature::GetInstallState(const char *bundleName, InstallState
     return OHOS::GtManagerService::GetInstance().GetInstallState(bundleName, installState, installProcess);
 }
 
-bool BundleMgrSliteFeature::GetUninstallState(const char *bundleName, UninstallState *uninstallState)
+uint32_t BundleMgrSliteFeature::GetBundleSize(const char *bundleName)
 {
-    return OHOS::GtManagerService::GetInstance().GetUninstallState(bundleName, uninstallState);
+    return OHOS::GtManagerService::GetInstance().GetBundleSize(bundleName);
 }
 } // namespace OHOS
diff --git a/services/bundlemgr_lite/src/bundle_util.cpp b/services/bundlemgr_lite/src/bundle_util.cpp
index 745816180b3f29306e264befbd96437a8059a4a2..27813a68fca4df3ec6e03f7999689f39d8e8762d 100755
--- a/services/bundlemgr_lite/src/bundle_util.cpp
+++ b/services/bundlemgr_lite/src/bundle_util.cpp
@@ -182,6 +182,80 @@ uint32_t BundleUtil::GetFileSize(const char *filePath)
     return fileInfo.st_size;
 }
 
+uint32_t BundleUtil::GetFileFolderSize(const char *filePath)
+{
+    if (!CheckRealPath(filePath)) {
+        return 0;
+    }
+    List<char *>* list = new (std::nothrow)List<char *>();
+    if (list == nullptr) {
+#ifdef APP_PLATFORM_WATCHGT
+        HILOG_ERROR(HILOG_MODULE_AAFWK, "[BMS] GetFolderSize failed, list is null");
+#endif
+        return 0;
+    }
+
+    list->PushFront(Utils::Strdup(filePath));
+    uint32_t fileFolderSize = 0;
+    while(!list->IsEmpty()) {
+        char *curPath = list->Front();
+        if (curPath == nullptr) {
+            break;
+        }
+        fileFolderSize += GetCurrentFolderSize(curPath, list);
+        list->PopFront();
+        AdapterFree(curPath);
+    }
+
+    if (!list->IsEmpty()) {
+#ifdef APP_PLATFORM_WATCHGT
+        HILOG_ERROR(HILOG_MODULE_AAFWK, "[BMS] After get folder size, list is still not empty");
+#endif
+        for (auto node = list->Begin(); node != list->End(); node = node->next_) {
+            AdapterFree(node->value_);
+        }
+    }
+    delete list;
+    return fileFolderSize;
+}
+
+uint32_t BundleUtil::GetCurrentFolderSize(const char *dirPath, List<char *>* list)
+{
+    DIR *dir = nullptr;
+    if ((dir = opendir(dirPath)) == nullptr) {
+        return 0;
+    }
+    dirent *dp = nullptr;
+    char filePath[PATH_LENGTH] = { 0 };
+    struct stat buf = { 0 };
+    uint32_t fileSize = 0;
+    while ((dp = readdir(dir)) != nullptr) {
+        if ((strcmp(dp->d_name, ".") == 0) || (strcmp(dp->d_name, "..")) == 0) {
+            continue;
+        }
+
+        if (memset_s(filePath, PATH_LENGTH, 0, PATH_LENGTH) != EOK) {
+            continue;
+        }
+
+        if (sprintf_s(filePath, PATH_LENGTH, "%s/%s", dirPath, dp->d_name) < 0) {
+            continue;
+        }
+
+        if (IsFile(filePath)) {
+            if (stat(filePath, &buf) != 0 || buf.st_size <= 0) {
+                fileSize = 0;
+                break;
+            }
+            fileSize += buf.st_size;
+        } else {
+            list->PushBack(Utils::Strdup(filePath));
+        }
+    }
+    closedir(dir);
+    return fileSize;
+}
+
 void BundleUtil::DeleteJsonFile(const char *bundleName, const char *randStr)
 {
     if (bundleName == nullptr || randStr == nullptr) {
diff --git a/services/bundlemgr_lite/src/gt_bundle_extractor.cpp b/services/bundlemgr_lite/src/gt_bundle_extractor.cpp
index 35280c230f34913f99c0dbe9555c65fed2669426..1750d7712e08f225a2b052f23dcb72e645c04606 100755
--- a/services/bundlemgr_lite/src/gt_bundle_extractor.cpp
+++ b/services/bundlemgr_lite/src/gt_bundle_extractor.cpp
@@ -179,45 +179,45 @@ bool GtBundleExtractor::ExtractResourceFile(const char *path, int32_t fp, uint32
     return true;
 }
 
-bool GtBundleExtractor::ExtractInstallMsg(const char *path, char **bundleName, char **label, char **smallIconPath,
+uint8_t GtBundleExtractor::ExtractInstallMsg(const char *path, char **bundleName, char **label, char **smallIconPath,
     char **bigIconPath)
 {
     if (!BundleUtil::CheckRealPath(path)) {
-        return false;
+        return ERR_APPEXECFWK_INSTALL_FAILED_PARAM_ERROR;
     }
 
     int32_t totalFileSize = APPVERI_GetUnsignedFileLength(path);
     if (totalFileSize == V_ERR) {
-        return false;
+        return ERR_APPEXECFWK_INSTALL_FAILED_INTERNAL_ERROR;
     }
 
     char *emptyJsPathComp[] = {const_cast<char *>(TMP_RESOURCE_DIR), const_cast<char *>(ASSET_JS_PATH)};
     char *emptyJsPath = BundleUtil::Strscat(emptyJsPathComp, sizeof(emptyJsPathComp) / sizeof(char *));
     if (emptyJsPath == nullptr) {
-        return false;
+        return ERR_APPEXECFWK_INSTALL_FAILED_INTERNAL_ERROR;
     }
 
     if (!BundleUtil::MkDirs(emptyJsPath)) {
         AdapterFree(emptyJsPath);
-        return false;
+        return ERR_APPEXECFWK_INSTALL_FAILED_CREATE_DATA_DIR_ERROR;
     }
     AdapterFree(emptyJsPath);
 
     int32_t fp = open(path, O_RDONLY, S_IREAD | S_IWRITE);
     if (fp < 0) {
-        return false;
+        return ERR_APPEXECFWK_INSTALL_FAILED_FILE_NOT_EXISTS;
     }
     // extractor config.json、 resources dir and resources.index in TMP_RESOURCE_DIR
     if (!ExtractResourceFile(TMP_RESOURCE_DIR, fp, static_cast<uint32_t>(totalFileSize))) {
         close(fp);
-        return false;
+        return ERR_APPEXECFWK_INSTALL_FAILED_PARSE_PROFILE_ERROR;
     }
     close(fp);
     // get bundleName、 label、 smallIconPath and bigIconPath from bundleInfo
     BundleRes bundleRes = { 0 };
     BundleInfo *bundleInfo = GtBundleParser::ParseHapProfile(TMP_RESOURCE_DIR, &bundleRes);
     if (bundleInfo == nullptr) {
-        return false;
+        return ERR_APPEXECFWK_INSTALL_FAILED_PARSE_PROFILE_ERROR;
     }
     if (bundleRes.abilityRes != nullptr) {
         AdapterFree(bundleRes.abilityRes);
@@ -228,10 +228,10 @@ bool GtBundleExtractor::ExtractInstallMsg(const char *path, char **bundleName, c
     *bigIconPath = Utils::Strdup(bundleInfo->bigIconPath);
     if (*bundleName == nullptr || *label == nullptr || *smallIconPath == nullptr || *bigIconPath == nullptr) {
         BundleInfoUtils::FreeBundleInfo(bundleInfo);
-        return false;
+        return ERR_APPEXECFWK_INSTALL_FAILED_PARSE_ABILITIES_ERROR;
     }
     BundleInfoUtils::FreeBundleInfo(bundleInfo);
-    return true;
+    return ERR_OK;
 }
 
 uint8_t GtBundleExtractor::ExtractBundleParam(const char *path, int32_t &fpStart, char **bundleName)
diff --git a/services/bundlemgr_lite/src/gt_bundle_installer.cpp b/services/bundlemgr_lite/src/gt_bundle_installer.cpp
index 69eeefcd9b7d94ebcd3e7dbe29b2ff93c20b3a2d..05e5de3eaae94fddc5c9496c43569e9b2c296cf0 100755
--- a/services/bundlemgr_lite/src/gt_bundle_installer.cpp
+++ b/services/bundlemgr_lite/src/gt_bundle_installer.cpp
@@ -234,8 +234,8 @@ uint8_t GtBundleInstaller::ProcessBundleInstall(const char *path, const char *ra
     BundleInfo *bundleInfo = nullptr;
     (void) GtManagerService::GetInstance().ReportInstallCallback(OPERATION_DOING, 0, BMS_FIRST_FINISHED_PROCESS, installerCallback);
     uint8_t errorCode = PreCheckBundle(path, fp, signatureInfo, fileSize, bundleStyle);
-    (void) GtManagerService::GetInstance().ReportInstallCallback(OPERATION_DOING, 0, BMS_SECOND_FINISHED_PROCESS, installerCallback);
     CHECK_PRO_RESULT(errorCode, fp, permissions, bundleInfo, signatureInfo);
+    (void) GtManagerService::GetInstance().ReportInstallCallback(OPERATION_DOING, 0, BMS_SECOND_FINISHED_PROCESS, installerCallback);
     // parse HarmoyProfile.json, get permissions and bundleInfo
     errorCode = GtBundleParser::ParseHapProfile(fp, fileSize, permissions, bundleRes, &bundleInfo);
     CHECK_PRO_RESULT(errorCode, fp, permissions, bundleInfo, signatureInfo);
@@ -285,6 +285,11 @@ uint8_t GtBundleInstaller::ProcessBundleInstall(const char *path, const char *ra
     errorCode = MoveRawFileToDataPath(bundleInfo);
     CHECK_PRO_ROLLBACK(errorCode, permissions, bundleInfo, signatureInfo, randStr);
     (void) GtManagerService::GetInstance().ReportInstallCallback(OPERATION_DOING, 0, BMS_FIFTH_FINISHED_PROCESS, installerCallback);
+    // store permissions
+    errorCode = StorePermissions(installRecord.bundleName, permissions.permissionTrans, permissions.permNum,
+        isUpdate);
+    CHECK_PRO_ROLLBACK(errorCode, permissions, bundleInfo, signatureInfo, randStr);
+    // update bundle Info
     errorCode = UpdateBundleInfo(bundleStyle, labelId, iconId, bundleInfo, isUpdate);
     CHECK_PRO_ROLLBACK(errorCode, permissions, bundleInfo, signatureInfo, randStr);
     // free memory
@@ -572,6 +577,10 @@ uint8_t GtBundleInstaller::Uninstall(const char *bundleName)
         return ERR_APPEXECFWK_UNINSTALL_FAILED_INTERNAL_ERROR;
     }
 
+    if (DeletePermissions(const_cast<char *>(bundleName)) < 0) {
+        return ERR_APPEXECFWK_UNINSTALL_FAILED_DELETE_PERMISSIONS_ERROR;
+    }
+
     bool res = CheckIsThirdSystemBundle(bundleName);
     if (!(BundleUtil::RemoveDir(bundleInfo->codePath) && BundleUtil::RemoveDir(bundleInfo->dataPath))) {
         GtManagerService::GetInstance().RemoveBundleInfo(bundleName);
diff --git a/services/bundlemgr_lite/src/gt_bundle_manager_service.cpp b/services/bundlemgr_lite/src/gt_bundle_manager_service.cpp
index 4d9e53477c7b7138fb5d0ea3696519ccf682a059..3b0a010aab88c714fcbad42c867ade67415f778b 100755
--- a/services/bundlemgr_lite/src/gt_bundle_manager_service.cpp
+++ b/services/bundlemgr_lite/src/gt_bundle_manager_service.cpp
@@ -49,7 +49,6 @@ GtManagerService::GtManagerService()
     bundleResList_ = new List<BundleRes *>();
     bundleMap_ = BundleMap::GetInstance();
     bundleInstallMsg_ = nullptr;
-    bundleUninstallMsg_ = nullptr;
     jsEngineVer_ = nullptr;
     installedThirdBundleNum_ = 0;
 }
@@ -95,20 +94,25 @@ bool GtManagerService::Install(const char *hapPath, const InstallParam *installP
         return false;
     }
     // set bundleName、label、smallIconPath、bigIconPath in bundleInstallMsg_
-    bool isSuccess = GtBundleExtractor::ExtractInstallMsg(path, &(bundleInstallMsg_->bundleName),
+    uint8_t ret = GtBundleExtractor::ExtractInstallMsg(path, &(bundleInstallMsg_->bundleName),
         &(bundleInstallMsg_->label), &(bundleInstallMsg_->smallIconPath),
         &(bundleInstallMsg_->bigIconPath));
-    if (!isSuccess) {
+
+    if (ret != 0) {
+        char *name = strchr(path, '/');
+        bundleInstallMsg_->bundleName = Utils::Strdup(name + 1);
+        (void) ReportInstallCallback(ret, BUNDLE_INSTALL_FAIL, BMS_INSTALLATION_COMPLETED, installerCallback);
         // delete resource temp dir
         (void) BundleUtil::RemoveDir(TMP_RESOURCE_DIR);
         ClearSystemBundleInstallMsg();
+        AdapterFree(path);
         return false;
     }
 
     SetCurrentBundle(bundleInstallMsg_->bundleName);
     (void) ReportInstallCallback(OPERATION_DOING, 0, BMS_INSTALLATION_START, installerCallback);
     DisableServiceWdg();
-    uint8_t ret = installer_->Install(path, installerCallback);
+    ret = installer_->Install(path, installerCallback);
     EnableServiceWdg();
     if (ret == 0) {
         (void) ReportInstallCallback(ret, BUNDLE_INSTALL_OK, BMS_INSTALLATION_COMPLETED, installerCallback);
@@ -145,30 +149,19 @@ bool GtManagerService::Uninstall(const char *bundleName, const InstallParam *ins
     }
     SetCurrentBundle(innerBundleName);
 
-    bundleUninstallMsg_ = reinterpret_cast<BundleUninstallMsg *>(AdapterMalloc(sizeof(BundleUninstallMsg)));
-    if (bundleUninstallMsg_ == nullptr) {
-        return false;
-    }
-    if (memset_s(bundleUninstallMsg_, sizeof(BundleUninstallMsg), 0, sizeof(BundleUninstallMsg)) != EOK) {
-        AdapterFree(bundleUninstallMsg_);
-        return false;
-    }
-    bundleUninstallMsg_->bundleName = innerBundleName;
-    bundleUninstallMsg_->uninstallState = BUNDLE_UNINSTALL_DOING;
-
-    (void) ReportUninstallCallback(OPERATION_DOING, innerBundleName, BMS_UNINSTALLATION_START, installerCallback);
+    (void) ReportUninstallCallback(OPERATION_DOING, BUNDLE_UNINSTALL_DOING, innerBundleName,
+        BMS_UNINSTALLATION_START, installerCallback);
     uint8_t ret = installer_->Uninstall(innerBundleName);
     if (ret == 0) {
-        bundleUninstallMsg_->uninstallState = BUNDLE_UNINSTALL_OK;
+        (void) ReportUninstallCallback(ret, BUNDLE_UNINSTALL_OK, innerBundleName,
+            BMS_INSTALLATION_COMPLETED, installerCallback);
     } else {
-        bundleUninstallMsg_->uninstallState = BUNDLE_UNINSTALL_FAIL;
+        (void) ReportUninstallCallback(ret, BUNDLE_UNINSTALL_FAIL, innerBundleName,
+            BMS_INSTALLATION_COMPLETED, installerCallback);
     }
-    (void) ReportUninstallCallback(ret, innerBundleName, BMS_INSTALLATION_COMPLETED, installerCallback);
 
     SetCurrentBundle(nullptr);
     AdapterFree(innerBundleName);
-    AdapterFree(bundleUninstallMsg_);
-    bundleUninstallMsg_ = nullptr;
     return true;
 }
 
@@ -198,19 +191,25 @@ bool GtManagerService::GetInstallState(const char *bundleName, InstallState *ins
     return true;
 }
 
-bool GtManagerService::GetUninstallState(const char *bundleName, UninstallState *uninstallState)
+uint32_t GtManagerService::GetBundleSize(const char *bundleName)
 {
-    BundleInfo *uninstalledInfo = bundleMap_->Get(bundleName);
-    if (uninstalledInfo == nullptr) {
-        *uninstallState = BUNDLE_UNINSTALL_OK;
-        return true;
+    if (bundleName == nullptr) {
+        return 0;
     }
-    if (strcmp(bundleName, bundleUninstallMsg_->bundleName) == 0) {
-        *uninstallState = bundleUninstallMsg_->uninstallState;
-        return true;
+    BundleInfo *installedInfo = bundleMap_->Get(bundleName);
+    if (installedInfo == nullptr) {
+        HILOG_INFO(HILOG_MODULE_AAFWK, "[BMS] failed to get bundle size because the bundle does not exist!");
+        return 0;
     }
-    *uninstallState = BUNDLE_UNINSTALL_DOING;
-    return true;
+    char *codePath = installedInfo->codePath;
+    uint32_t codeBundleSize = BundleUtil::GetFileFolderSize(codePath);
+    if (codeBundleSize == 0) {
+        HILOG_ERROR(HILOG_MODULE_AAFWK, "[BMS] failed to get code bundle size!");
+        return 0;
+    }
+    char *dataPath = installedInfo->dataPath;
+    uint32_t dataBundleSize = BundleUtil::GetFileFolderSize(dataPath);
+    return codeBundleSize + dataBundleSize;
 }
 
 uint8_t GtManagerService::QueryAbilityInfo(const Want *want, AbilityInfo *abilityInfo)
@@ -290,10 +289,10 @@ void GtManagerService::InstallSystemBundle(const char *systemAppPath)
         return;
     }
     // set bundleName、label、smallIconPath、bigIconPath in bundleInstallMsg_
-    bool ret = GtBundleExtractor::ExtractInstallMsg(systemAppPath, &(bundleInstallMsg_->bundleName),
+    uint8_t ret = GtBundleExtractor::ExtractInstallMsg(systemAppPath, &(bundleInstallMsg_->bundleName),
         &(bundleInstallMsg_->label), &(bundleInstallMsg_->smallIconPath),
         &(bundleInstallMsg_->bigIconPath));
-    if (!ret) {
+    if (ret != 0) {
         // delete resource temp dir
         (void) BundleUtil::RemoveDir(TMP_RESOURCE_DIR);
         ClearSystemBundleInstallMsg();
@@ -883,19 +882,20 @@ int32_t GtManagerService::ReportInstallCallback(uint8_t errCode, uint8_t install
     return 0;
 }
 
-int32_t GtManagerService::ReportUninstallCallback(uint8_t errCode, char *bundleName,
+int32_t GtManagerService::ReportUninstallCallback(uint8_t errCode, uint8_t installState, char *bundleName,
     uint8_t process, InstallerCallback installerCallback)
 {
     if (installerCallback == nullptr) {
         return -1;
     }
-    BundleInstallMsg *bundleUninstallMsg = reinterpret_cast<BundleInstallMsg *>(AdapterMalloc(sizeof(BundleInstallMsg)));
-    if (bundleUninstallMsg == nullptr) {
+    BundleInstallMsg *bundleInstallMsg = reinterpret_cast<BundleInstallMsg *>(AdapterMalloc(sizeof(BundleInstallMsg)));
+    if (bundleInstallMsg == nullptr) {
         return -1;
     }
-    bundleUninstallMsg->bundleName = bundleName;
-    bundleUninstallMsg->installProcess = process;
-    (*installerCallback)(errCode, bundleUninstallMsg);
+    bundleInstallMsg->installState = static_cast<InstallState>(installState);
+    bundleInstallMsg->bundleName = bundleName;
+    bundleInstallMsg->installProcess = process;
+    (*installerCallback)(errCode, bundleInstallMsg);
     return 0;
 }