diff --git a/services/bundlemgr/include/app_control/app_control_manager_db_interface.h b/services/bundlemgr/include/app_control/app_control_manager_db_interface.h
index b98a1c699a91778deb40e9e895146343edf18865..434e616ea03b3f2f5ddfe39ce3eaef9c4a1f312b 100644
--- a/services/bundlemgr/include/app_control/app_control_manager_db_interface.h
+++ b/services/bundlemgr/include/app_control/app_control_manager_db_interface.h
@@ -46,7 +46,7 @@ public:
     virtual ErrCode DeleteAppRunningControlRule(const std::string &callingName, int32_t userId) = 0;
     virtual ErrCode GetAppRunningControlRule(const std::string &callingName,
         int32_t userId, std::vector<std::string> &appIds) = 0;
-    virtual ErrCode GetAppRunningControlRule(const std::string &appId,
+    virtual ErrCode GetAppRunningControlRule(const std::vector<std::string> &appIds,
         int32_t userId, AppRunningControlRuleResult &controlRuleResult) = 0;
 
     virtual ErrCode SetDisposedStatus(const std::string &callingName,
diff --git a/services/bundlemgr/include/app_control/app_control_manager_rdb.h b/services/bundlemgr/include/app_control/app_control_manager_rdb.h
index a054a4573ab8dd9516ba0fa51b633cf0b9ea4b5d..6fb5766dbd1a4e966438bd5879d3d27faa4fc525 100644
--- a/services/bundlemgr/include/app_control/app_control_manager_rdb.h
+++ b/services/bundlemgr/include/app_control/app_control_manager_rdb.h
@@ -43,7 +43,7 @@ public:
     virtual ErrCode DeleteAppRunningControlRule(const std::string &callingName, int32_t userId) override;
     virtual ErrCode GetAppRunningControlRule(const std::string &callingName,
         int32_t userId, std::vector<std::string> &appIds) override;
-    virtual ErrCode GetAppRunningControlRule(const std::string &appId,
+    virtual ErrCode GetAppRunningControlRule(const std::vector<std::string> &appIds,
         int32_t userId, AppRunningControlRuleResult &controlRuleResult) override;
 
     virtual ErrCode SetDisposedStatus(const std::string &callingName,
diff --git a/services/bundlemgr/include/base_bundle_installer.h b/services/bundlemgr/include/base_bundle_installer.h
index 446ee0de21761052bd89fcc00e2962c7b3de7c2d..5a78faf3cda8e3cba8d30134dc9f189745aff7da 100644
--- a/services/bundlemgr/include/base_bundle_installer.h
+++ b/services/bundlemgr/include/base_bundle_installer.h
@@ -547,9 +547,10 @@ private:
     ErrCode CheckInstallationFree(const InnerBundleInfo &innerBundleInfo,
         const std::unordered_map<std::string, InnerBundleInfo> &infos) const;
 
-    bool UninstallAppControl(const std::string &appId, int32_t userId);
+    bool UninstallAppControl(const std::string &appId, const std::string &appIdentifier, int32_t userId);
 
-    ErrCode InstallNormalAppControl(const std::string &installAppId, int32_t userId, bool isPreInstallApp = false);
+    ErrCode InstallNormalAppControl(const std::string &installAppId,
+        const std::string &appIdentifier, int32_t userId, bool isPreInstallApp = false);
 
     ErrCode CreateBundleCodeDir(InnerBundleInfo &info) const;
     ErrCode CreateBundleDataDir(InnerBundleInfo &info) const;
@@ -864,6 +865,10 @@ private:
         const InnerBundleInfo &oldInfo, bool isContainEntry);
     void ProcessUpdateShortcut();
     ErrCode CheckArkTSMode(const std::unordered_map<std::string, InnerBundleInfo> &newInfos);
+#ifdef BUNDLE_FRAMEWORK_APP_CONTROL
+    ErrCode CheckInstallPermission(const std::string &appId, const std::string &appIdentifier,
+        const std::vector<std::string> &allowedAppIds, const std::vector<std::string> &disallowedAppIds);
+#endif
 
     bool isAppExist_ = false;
     bool isContainEntry_ = false;
diff --git a/services/bundlemgr/src/app_control/app_control_manager.cpp b/services/bundlemgr/src/app_control/app_control_manager.cpp
index c4a0fe226d3a76347cabbb8fcb189cd55d4a6152..fc1eb62441856d40c4cbbf175beb5eb545ea96ad 100644
--- a/services/bundlemgr/src/app_control/app_control_manager.cpp
+++ b/services/bundlemgr/src/app_control/app_control_manager.cpp
@@ -96,12 +96,23 @@ ErrCode AppControlManager::AddAppRunningControlRule(const std::string &callingNa
     std::lock_guard<std::mutex> lock(appRunningControlMutex_);
     ErrCode ret = appControlManagerDb_->AddAppRunningControlRule(callingName, controlRules, userId);
     if (ret == ERR_OK) {
+        auto dataMgr = DelayedSingleton<BundleMgrService>::GetInstance()->GetDataMgr();
+        if (dataMgr == nullptr) {
+            LOG_E(BMS_TAG_DEFAULT, "DataMgr is nullptr");
+            return ERR_APPEXECFWK_NULL_PTR;
+        }
         for (const auto &rule : controlRules) {
             std::string key = rule.appId + std::string("_") + std::to_string(userId);
             auto iter = appRunningControlRuleResult_.find(key);
             if (iter != appRunningControlRuleResult_.end()) {
                 appRunningControlRuleResult_.erase(iter);
             }
+            std::string transformedAppId = dataMgr->AppIdAndAppIdentifierTransform(rule.appId);
+            std::string transformedKey = transformedAppId + std::string("_") + std::to_string(userId);
+            iter = appRunningControlRuleResult_.find(transformedKey);
+            if (iter != appRunningControlRuleResult_.end()) {
+                appRunningControlRuleResult_.erase(iter);
+            }
         }
         KillRunningApp(controlRules, userId);
     }
@@ -114,12 +125,23 @@ ErrCode AppControlManager::DeleteAppRunningControlRule(const std::string &callin
     std::lock_guard<std::mutex> lock(appRunningControlMutex_);
     auto ret = appControlManagerDb_->DeleteAppRunningControlRule(callingName, controlRules, userId);
     if (ret == ERR_OK) {
+        auto dataMgr = DelayedSingleton<BundleMgrService>::GetInstance()->GetDataMgr();
+        if (dataMgr == nullptr) {
+            LOG_E(BMS_TAG_DEFAULT, "DataMgr is nullptr");
+            return ERR_APPEXECFWK_NULL_PTR;
+        }
         for (const auto &rule : controlRules) {
             std::string key = rule.appId + std::string("_") + std::to_string(userId);
             auto iter = appRunningControlRuleResult_.find(key);
             if (iter != appRunningControlRuleResult_.end()) {
                 appRunningControlRuleResult_.erase(iter);
             }
+            std::string transformedAppId = dataMgr->AppIdAndAppIdentifierTransform(rule.appId);
+            std::string transformedKey = transformedAppId + std::string("_") + std::to_string(userId);
+            iter = appRunningControlRuleResult_.find(transformedKey);
+            if (iter != appRunningControlRuleResult_.end()) {
+                appRunningControlRuleResult_.erase(iter);
+            }
         }
     }
     return ret;
@@ -265,12 +287,18 @@ ErrCode AppControlManager::GetAppRunningControlRule(
         return ERR_BUNDLE_MANAGER_INTERNAL_ERROR;
     }
     std::string appId;
-    ErrCode ret = dataMgr->GetAppIdByBundleName(bundleName, appId);
+    std::string appIdentifier;
+    ErrCode ret = dataMgr->GetAppIdAndAppIdentifierByBundleName(bundleName, appId, appIdentifier);
     if (ret != ERR_OK) {
         LOG_W(BMS_TAG_DEFAULT, "getAppId failed,-n:%{public}s", bundleName.c_str());
         return ret;
     }
+    std::vector<std::string> appIds = {appId};
+    if (!appIdentifier.empty()) {
+        appIds.emplace_back(appIdentifier);
+    }
     std::string key = appId + std::string("_") + std::to_string(userId);
+    std::string transformedKey = appIdentifier + std::string("_") + std::to_string(userId);
     std::lock_guard<std::mutex> lock(appRunningControlMutex_);
     if (appRunningControlRuleResult_.find(key) != appRunningControlRuleResult_.end()) {
         controlRuleResult = appRunningControlRuleResult_[key];
@@ -280,7 +308,7 @@ ErrCode AppControlManager::GetAppRunningControlRule(
         }
         return ERR_OK;
     }
-    ret = appControlManagerDb_->GetAppRunningControlRule(appId, userId, controlRuleResult);
+    ret = appControlManagerDb_->GetAppRunningControlRule(appIds, userId, controlRuleResult);
     if (ret != ERR_OK) {
         controlRuleResult.controlMessage = INVALID_MESSAGE;
     }
diff --git a/services/bundlemgr/src/app_control/app_control_manager_host_impl.cpp b/services/bundlemgr/src/app_control/app_control_manager_host_impl.cpp
index aca8dfaa5d2c9b96d3abf302cce03cf3fc5cf3a1..217334a68d092a1be50aa20bb35c4293976647bb 100644
--- a/services/bundlemgr/src/app_control/app_control_manager_host_impl.cpp
+++ b/services/bundlemgr/src/app_control/app_control_manager_host_impl.cpp
@@ -68,13 +68,28 @@ ErrCode AppControlManagerHostImpl::AddAppInstallControlRule(const std::vector<st
         LOG_E(BMS_TAG_DEFAULT, "appControlManager_ is nullptr");
         return ERR_APPEXECFWK_NULL_PTR;
     }
-    auto ret = appControlManager_->AddAppInstallControlRule(callingName, appIds, ruleType, userId);
+    std::vector<std::string> modifyAppIds = appIds;
+    modifyAppIds.erase(std::remove_if(modifyAppIds.begin(), modifyAppIds.end(),
+                                      [](const auto& appId) { return appId.empty(); }),
+                       modifyAppIds.end());
+    auto ret = appControlManager_->AddAppInstallControlRule(callingName, modifyAppIds, ruleType, userId);
     if (ret != ERR_OK) {
         LOG_E(BMS_TAG_DEFAULT, "AddAppInstallControlRule failed due to error %{public}d", ret);
         return ret;
     }
     if (ruleType == AppControlConstants::APP_DISALLOWED_UNINSTALL) {
-        UpdateAppControlledInfo(userId, appIds);
+        std::vector<std::string> transformAppIds = modifyAppIds;
+        for (auto &appId : appIds) {
+            if (dataMgr_ == nullptr) {
+                LOG_E(BMS_TAG_DEFAULT, "dataMgr_ is nullptr");
+                return ERR_APPEXECFWK_NULL_PTR;
+            }
+            std::string transformAppId = dataMgr_->AppIdAndAppIdentifierTransform(appId);
+            if (!transformAppId.empty()) {
+                transformAppIds.emplace_back(transformAppId);
+            }
+        }
+        UpdateAppControlledInfo(userId, transformAppIds);
     }
     SendAppControlEvent(ControlActionType::INSTALL, ControlOperationType::ADD_RULE,
         callingName, userId, Constants::MAIN_APP_INDEX, appIds, ruleType);
@@ -99,13 +114,28 @@ ErrCode AppControlManagerHostImpl::DeleteAppInstallControlRule(const AppInstallC
         LOG_E(BMS_TAG_DEFAULT, "appControlManager_ is nullptr");
         return ERR_APPEXECFWK_NULL_PTR;
     }
-    auto ret = appControlManager_->DeleteAppInstallControlRule(callingName, ruleType, appIds, userId);
+    std::vector<std::string> modifyAppIds = appIds;
+    modifyAppIds.erase(std::remove_if(modifyAppIds.begin(), modifyAppIds.end(),
+                                      [](const auto& appId) { return appId.empty(); }),
+                       modifyAppIds.end());
+    auto ret = appControlManager_->DeleteAppInstallControlRule(callingName, ruleType, modifyAppIds, userId);
     if (ret != ERR_OK) {
         LOG_E(BMS_TAG_DEFAULT, "DeleteAppInstallControlRule failed due to error %{public}d", ret);
         return ret;
     }
     if (ruleType == AppControlConstants::APP_DISALLOWED_UNINSTALL) {
-        UpdateAppControlledInfo(userId, appIds);
+        std::vector<std::string> transformAppIds = modifyAppIds;
+        for (auto &appId : appIds) {
+            if (dataMgr_ == nullptr) {
+                LOG_E(BMS_TAG_DEFAULT, "dataMgr_ is nullptr");
+                return ERR_APPEXECFWK_NULL_PTR;
+            }
+            std::string transformAppId = dataMgr_->AppIdAndAppIdentifierTransform(appId);
+            if (!transformAppId.empty()) {
+                transformAppIds.emplace_back(transformAppId);
+            }
+        }
+        UpdateAppControlledInfo(userId, transformAppIds);
     }
     SendAppControlEvent(ControlActionType::INSTALL, ControlOperationType::REMOVE_RULE,
         callingName, userId, Constants::MAIN_APP_INDEX, appIds, ruleType);
@@ -169,7 +199,18 @@ ErrCode AppControlManagerHostImpl::GetAppInstallControlRule(
         LOG_E(BMS_TAG_DEFAULT, "appControlManager_ is nullptr");
         return ERR_APPEXECFWK_NULL_PTR;
     }
-    return appControlManager_->GetAppInstallControlRule(callingName, ruleType, userId, appIds);
+    ErrCode ret = appControlManager_->GetAppInstallControlRule(callingName, ruleType, userId, appIds);
+    std::vector<std::string> transformAppIds = appIds;
+    for (auto &appId : appIds) {
+        if (dataMgr_ == nullptr) {
+            LOG_E(BMS_TAG_DEFAULT, "dataMgr_ is nullptr");
+            return ERR_APPEXECFWK_NULL_PTR;
+        }
+        std::string transformAppId = dataMgr_->AppIdAndAppIdentifierTransform(appId);
+        transformAppIds.emplace_back(transformAppId);
+    }
+    appIds = transformAppIds;
+    return ret;
 }
 
 ErrCode AppControlManagerHostImpl::AddAppRunningControlRule(
@@ -184,10 +225,14 @@ ErrCode AppControlManagerHostImpl::AddAppRunningControlRule(
         LOG_E(BMS_TAG_DEFAULT, "appControlManager_ is nullptr");
         return ERR_APPEXECFWK_NULL_PTR;
     }
-    ErrCode result = appControlManager_->AddAppRunningControlRule(callingName, controlRules, userId);
+    std::vector<AppRunningControlRule> modifyControlRules = controlRules;
+    modifyControlRules.erase(std::remove_if(modifyControlRules.begin(), modifyControlRules.end(),
+                                            [](const auto& controlRule) { return controlRule.appId.empty(); }),
+                             modifyControlRules.end());
+    ErrCode result = appControlManager_->AddAppRunningControlRule(callingName, modifyControlRules, userId);
     std::vector<std::string> appIds;
     std::string rules;
-    for (const auto &rule : controlRules) {
+    for (const auto &rule : modifyControlRules) {
         appIds.emplace_back(rule.appId);
         rules += (rule.controlMessage + " ");
     }
@@ -204,9 +249,13 @@ ErrCode AppControlManagerHostImpl::DeleteAppRunningControlRule(
         LOG_E(BMS_TAG_DEFAULT, "callingName is invalid");
         return ERR_BUNDLE_MANAGER_PERMISSION_DENIED;
     }
-    ErrCode result = appControlManager_->DeleteAppRunningControlRule(callingName, controlRules, userId);
+    std::vector<AppRunningControlRule> modifyControlRules = controlRules;
+    modifyControlRules.erase(std::remove_if(modifyControlRules.begin(), modifyControlRules.end(),
+                                            [](const auto& controlRule) { return controlRule.appId.empty(); }),
+                             modifyControlRules.end());
+    ErrCode result = appControlManager_->DeleteAppRunningControlRule(callingName, modifyControlRules, userId);
     std::vector<std::string> appIds;
-    for (const auto &rule : controlRules) {
+    for (const auto &rule : modifyControlRules) {
         appIds.emplace_back(rule.appId);
     }
     SendAppControlEvent(ControlActionType::RUNUING, ControlOperationType::REMOVE_RULE,
@@ -471,15 +520,22 @@ void AppControlManagerHostImpl::UpdateAppControlledInfo(int32_t userId,
     }
     auto bundleInfos = dataMgr_->GetAllInnerBundleInfos();
     for (const auto &info : bundleInfos) {
-        auto iterator = std::find(appIds.begin(), appIds.end(), info.second.GetAppId());
-        bool isRemovable = (iterator != appIds.end()) ? false : true;
+        bool isRemovable = false;
+        if ((std::find(appIds.begin(), appIds.end(), info.second.GetAppIdentifier()) == appIds.end())
+            && (std::find(appIds.begin(), appIds.end(), info.second.GetAppId()) == appIds.end())) {
+            isRemovable = true;
+        }
         if (!dataMgr_->SetBundleUserInfoRemovable(info.first, userId, isRemovable)) {
             LOG_W(BMS_TAG_DEFAULT, "UpdateAppControlledInfo fail -n %{public}s -u %{public}d removable:%{public}d",
                 info.first.c_str(), userId, isRemovable);
             continue;
         }
-        auto modifyAppIdsIterator = std::find(modifyAppIds.begin(), modifyAppIds.end(), info.second.GetAppId());
-        if (modifyAppIdsIterator != modifyAppIds.end()) {
+        bool needUpdate = true;
+        if ((std::find(modifyAppIds.begin(), modifyAppIds.end(), info.second.GetAppIdentifier()) == modifyAppIds.end())
+            && (std::find(modifyAppIds.begin(), modifyAppIds.end(), info.second.GetAppId()) == modifyAppIds.end())) {
+            needUpdate = false;
+        }
+        if (needUpdate) {
             AbilityInfo mainAbilityInfo;
             info.second.GetMainAbilityInfo(mainAbilityInfo);
             NotifyBundleEvents installRes = {
diff --git a/services/bundlemgr/src/app_control/app_control_manager_rdb.cpp b/services/bundlemgr/src/app_control/app_control_manager_rdb.cpp
index e9a5f12adbef688bf7e5306c68c301fcce2576cd..aec743e44b1daf45a4ea48c0bf66c94bf4119d3f 100644
--- a/services/bundlemgr/src/app_control/app_control_manager_rdb.cpp
+++ b/services/bundlemgr/src/app_control/app_control_manager_rdb.cpp
@@ -18,6 +18,7 @@
 #include "app_control_constants.h"
 #include "app_log_tag_wrapper.h"
 #include "bms_extension_client.h"
+#include "bundle_mgr_service.h"
 #include "bundle_util.h"
 #include "hitrace_meter.h"
 #include "scope_guard.h"
@@ -291,12 +292,12 @@ ErrCode AppControlManagerRdb::GetAppRunningControlRule(const std::string &callin
     return ERR_OK;
 }
 
-ErrCode AppControlManagerRdb::GetAppRunningControlRule(const std::string &appId,
+ErrCode AppControlManagerRdb::GetAppRunningControlRule(const std::vector<std::string> &appIds,
     int32_t userId, AppRunningControlRuleResult &controlRuleResult)
 {
     HITRACE_METER_NAME_EX(HITRACE_LEVEL_INFO, HITRACE_TAG_APP, __PRETTY_FUNCTION__, nullptr);
     NativeRdb::AbsRdbPredicates absRdbPredicates(APP_CONTROL_RDB_TABLE_NAME);
-    absRdbPredicates.EqualTo(APP_ID, appId);
+    absRdbPredicates.In(APP_ID, appIds);
     absRdbPredicates.EqualTo(APP_CONTROL_LIST, RUNNING_CONTROL);
     absRdbPredicates.EqualTo(USER_ID, std::to_string(userId));
     absRdbPredicates.OrderByAsc(PRIORITY); // ascending
diff --git a/services/bundlemgr/src/base_bundle_installer.cpp b/services/bundlemgr/src/base_bundle_installer.cpp
index f9efc5f6aad36c6663f0c9a1be56e8d97c1bc3ba..d66a28b1b119dbf4c5362180d9c6afe77da29144 100644
--- a/services/bundlemgr/src/base_bundle_installer.cpp
+++ b/services/bundlemgr/src/base_bundle_installer.cpp
@@ -609,7 +609,8 @@ ErrCode BaseBundleInstaller::UninstallBundle(
     return result;
 }
 
-bool BaseBundleInstaller::UninstallAppControl(const std::string &appId, int32_t userId)
+bool BaseBundleInstaller::UninstallAppControl(
+    const std::string &appId, const std::string &appIdentifier, int32_t userId)
 {
 #ifdef BUNDLE_FRAMEWORK_APP_CONTROL
     std::vector<std::string> appIds;
@@ -619,19 +620,24 @@ bool BaseBundleInstaller::UninstallAppControl(const std::string &appId, int32_t
         LOG_E(BMS_TAG_INSTALLER, "GetAppInstallControlRule failed code:%{public}d", ret);
         return true;
     }
-    if (std::find(appIds.begin(), appIds.end(), appId) == appIds.end()) {
-        return true;
+    if (!appIdentifier.empty() && std::find(appIds.begin(), appIds.end(), appIdentifier) != appIds.end()) {
+        LOG_W(BMS_TAG_INSTALLER, "appIdentifier :%{public}s is not removable", appIdentifier.c_str());
+        return false;
     }
-    LOG_W(BMS_TAG_INSTALLER, "appId is not removable");
-    return false;
+    if (std::find(appIds.begin(), appIds.end(), appId) != appIds.end()) {
+        LOG_W(BMS_TAG_INSTALLER, "appId :%{public}s is not removable", appId.c_str());
+        return false;
+    }
+    return true;
 #else
-    LOG_W(BMS_TAG_INSTALLER, "app control is disable");
+    LOG_W(BMS_TAG_INSTALLER, "appId is not removable");
     return true;
 #endif
 }
 
 ErrCode BaseBundleInstaller::InstallNormalAppControl(
     const std::string &installAppId,
+    const std::string &appIdentifier,
     int32_t userId,
     bool isPreInstallApp)
 {
@@ -662,10 +668,31 @@ ErrCode BaseBundleInstaller::InstallNormalAppControl(
         return ERR_OK;
     }
 
+    return CheckInstallPermission(installAppId, appIdentifier, allowedAppIds, disallowedAppIds);
+#else
+    LOG_W(BMS_TAG_INSTALLER, "app control is disable");
+    return ERR_OK;
+#endif
+}
+
+#ifdef BUNDLE_FRAMEWORK_APP_CONTROL
+ErrCode BaseBundleInstaller::CheckInstallPermission(
+    const std::string &appId,
+    const std::string &appIdentifier,
+    const std::vector<std::string> &allowedAppIds,
+    const std::vector<std::string> &disallowedAppIds)
+{
+    LOG_D(BMS_TAG_INSTALLER, "CheckInstallPermission start ");
+    std::string targetId = appIdentifier.empty() ? appId : appIdentifier;
     // only allowed list empty.
     if (allowedAppIds.empty()) {
-        if (std::find(disallowedAppIds.begin(), disallowedAppIds.end(), installAppId) != disallowedAppIds.end()) {
-            LOG_E(BMS_TAG_INSTALLER, "disallowedAppIds:%{public}s is disallow install", installAppId.c_str());
+        if (std::find(disallowedAppIds.begin(), disallowedAppIds.end(), targetId) != disallowedAppIds.end()) {
+            LOG_E(BMS_TAG_INSTALLER, "disallowedAppIds:%{public}s is disallow install", targetId.c_str());
+            return ERR_BUNDLE_MANAGER_APP_CONTROL_DISALLOWED_INSTALL;
+        }
+        if (!appIdentifier.empty() &&
+            std::find(disallowedAppIds.begin(), disallowedAppIds.end(), appId) != disallowedAppIds.end()) {
+            LOG_E(BMS_TAG_INSTALLER, "disallowedAppIds:%{public}s is disallow install", appId.c_str());
             return ERR_BUNDLE_MANAGER_APP_CONTROL_DISALLOWED_INSTALL;
         }
         return ERR_OK;
@@ -673,27 +700,36 @@ ErrCode BaseBundleInstaller::InstallNormalAppControl(
 
     // only disallowed list empty.
     if (disallowedAppIds.empty()) {
-        if (std::find(allowedAppIds.begin(), allowedAppIds.end(), installAppId) == allowedAppIds.end()) {
-            LOG_E(BMS_TAG_INSTALLER, "allowedAppIds:%{public}s is disallow install", installAppId.c_str());
-            return ERR_BUNDLE_MANAGER_APP_CONTROL_DISALLOWED_INSTALL;
+        if (std::find(allowedAppIds.begin(), allowedAppIds.end(), targetId) != allowedAppIds.end()) {
+            return ERR_OK;
         }
-        return ERR_OK;
+        if (!appIdentifier.empty() &&
+            std::find(allowedAppIds.begin(), allowedAppIds.end(), appId) != allowedAppIds.end()) {
+            return ERR_OK;
+        }
+        LOG_E(BMS_TAG_INSTALLER, "allowedAppIds:%{public}s is disallow install", targetId.c_str());
+        return ERR_BUNDLE_MANAGER_APP_CONTROL_DISALLOWED_INSTALL;
     }
 
     // disallowed list and allowed list all not empty.
-    if (std::find(allowedAppIds.begin(), allowedAppIds.end(), installAppId) == allowedAppIds.end()) {
-        LOG_E(BMS_TAG_INSTALLER, "allowedAppIds:%{public}s is disallow install", installAppId.c_str());
-        return ERR_BUNDLE_MANAGER_APP_CONTROL_DISALLOWED_INSTALL;
-    } else if (std::find(disallowedAppIds.begin(), disallowedAppIds.end(), installAppId) != disallowedAppIds.end()) {
-        LOG_E(BMS_TAG_INSTALLER, "disallowedAppIds:%{public}s is disallow install", installAppId.c_str());
+    bool inDisallowed = std::find(disallowedAppIds.begin(), disallowedAppIds.end(), targetId) != disallowedAppIds.end();
+    bool inAllowed = std::find(allowedAppIds.begin(), allowedAppIds.end(), targetId) != allowedAppIds.end();
+    if (!appIdentifier.empty()) {
+        if (!inAllowed || inDisallowed) {
+            LOG_E(BMS_TAG_INSTALLER, "%{public}s is disallow install", targetId.c_str());
+            return ERR_BUNDLE_MANAGER_APP_CONTROL_DISALLOWED_INSTALL;
+        }
+        return ERR_OK;
+    }
+    inDisallowed = std::find(disallowedAppIds.begin(), disallowedAppIds.end(), appId) != disallowedAppIds.end();
+    inAllowed = std::find(allowedAppIds.begin(), allowedAppIds.end(), appId) != allowedAppIds.end();
+    if (!inAllowed || inDisallowed) {
+        LOG_E(BMS_TAG_INSTALLER, "%{public}s is disallow install", targetId.c_str());
         return ERR_BUNDLE_MANAGER_APP_CONTROL_DISALLOWED_INSTALL;
     }
     return ERR_OK;
-#else
-    LOG_W(BMS_TAG_INSTALLER, "app control is disable");
-    return ERR_OK;
-#endif
 }
+#endif
 
 void BaseBundleInstaller::UpdateInstallerState(const InstallerState state)
 {
@@ -1388,7 +1424,8 @@ ErrCode BaseBundleInstaller::ProcessBundleInstall(const std::vector<std::string>
     UpdateInstallerState(InstallerState::INSTALL_PROXY_DATA_CHECKED);              // ---- 45%
 
     // check hap is allow install by app control
-    result = InstallNormalAppControl((newInfos.begin()->second).GetAppId(), userId_, installParam.isPreInstallApp);
+    result = InstallNormalAppControl((newInfos.begin()->second).GetAppId(),
+        (newInfos.begin()->second).GetAppIdentifier(), userId_, installParam.isPreInstallApp);
     CHECK_RESULT(result, "install app control failed %{public}d");
 
     auto &mtx = dataMgr_->GetBundleMutex(bundleName_);
@@ -1765,7 +1802,7 @@ ErrCode BaseBundleInstaller::ProcessBundleUninstall(
         }
     }
 
-    if (!UninstallAppControl(oldInfo.GetAppId(), userId_)) {
+    if (!UninstallAppControl(oldInfo.GetAppId(), oldInfo.GetAppIdentifier(), userId_)) {
         if (!isForcedUninstall) {
             LOG_E(BMS_TAG_INSTALLER, "bundleName: %{public}s is not allow uninstall", bundleName.c_str());
             return ERR_BUNDLE_MANAGER_APP_CONTROL_DISALLOWED_UNINSTALL;
@@ -2050,7 +2087,7 @@ ErrCode BaseBundleInstaller::ProcessBundleUninstall(
     }
     isBundleCrossAppSharedConfig_ = oldInfo.IsBundleCrossAppSharedConfig();
 
-    if (!UninstallAppControl(oldInfo.GetAppId(), userId_)) {
+    if (!UninstallAppControl(oldInfo.GetAppId(), oldInfo.GetAppIdentifier(), userId_)) {
         LOG_D(BMS_TAG_INSTALLER, "bundleName: %{public}s is not allow uninstall", bundleName.c_str());
         return ERR_BUNDLE_MANAGER_APP_CONTROL_DISALLOWED_UNINSTALL;
     }
@@ -2270,7 +2307,8 @@ ErrCode BaseBundleInstaller::InnerProcessInstallByPreInstallInfo(
                 return ERR_APPEXECFWK_RECOVER_INVALID_BUNDLE_NAME;
             }
 
-            ErrCode ret = InstallNormalAppControl(oldInfo.GetAppId(), userId_, installParam.isPreInstallApp);
+            ErrCode ret = InstallNormalAppControl(
+                oldInfo.GetAppId(), oldInfo.GetAppIdentifier(), userId_, installParam.isPreInstallApp);
             if (ret != ERR_OK) {
                 LOG_E(BMS_TAG_INSTALLER, "%{private}s check install app control failed", oldInfo.GetAppId().c_str());
                 return ret;
@@ -6338,10 +6376,18 @@ void BaseBundleInstaller::UpdateAppInstallControlled(int32_t userId)
     }
 
     std::string currentAppId = info.GetAppId();
+    std::string currentAppIdentifier = info.GetAppIdentifier();
     std::vector<std::string> appIds;
     ErrCode ret = DelayedSingleton<AppControlManager>::GetInstance()->GetAppInstallControlRule(
         AppControlConstants::EDM_CALLING, AppControlConstants::APP_DISALLOWED_UNINSTALL, userId, appIds);
-    if ((ret == ERR_OK) && (std::find(appIds.begin(), appIds.end(), currentAppId) != appIds.end())) {
+    bool needUpdateInfo = false;
+    if (ret == ERR_OK) {
+        if ((std::find(appIds.begin(), appIds.end(), currentAppId) != appIds.end()) ||
+            (std::find(appIds.begin(), appIds.end(), currentAppIdentifier) != appIds.end())) {
+            needUpdateInfo = true;
+        }
+    }
+    if (needUpdateInfo) {
         LOG_W(BMS_TAG_INSTALLER, "bundle %{public}s cannot be removed", bundleName_.c_str());
         userInfo.isRemovable = false;
         info.AddInnerBundleUserInfo(userInfo);
diff --git a/services/bundlemgr/test/unittest/bms_bundle_app_control_test/bms_bundle_app_control_test.cpp b/services/bundlemgr/test/unittest/bms_bundle_app_control_test/bms_bundle_app_control_test.cpp
index e181c7cd4c2be5a9bd35937ce3cb64fcda8e830e..5619121222abf955a9893bd1f7ed85fdc790e391 100644
--- a/services/bundlemgr/test/unittest/bms_bundle_app_control_test/bms_bundle_app_control_test.cpp
+++ b/services/bundlemgr/test/unittest/bms_bundle_app_control_test/bms_bundle_app_control_test.cpp
@@ -263,7 +263,7 @@ HWTEST_F(BmsBundleAppControlTest, AppInstallControlRule_0100, Function | SmallTe
     res = appControlProxy->
         GetAppInstallControlRule(AppInstallControlRuleType::DISALLOWED_UNINSTALL, USERID, resultAppIds);
     EXPECT_EQ(res, ERR_OK);
-    EXPECT_EQ(appIds.size(), resultAppIds.size());
+    EXPECT_EQ(appIds.size() * 2, resultAppIds.size());
     for (size_t i = 0; i < AppControlConstants::LIST_MAX_SIZE; i++) {
         appIds.emplace_back(APPID);
     }
@@ -545,10 +545,11 @@ HWTEST_F(BmsBundleAppControlTest, AppRunningControlRule_0600, Function | SmallTe
     controlRule.controlMessage = "test control message";
     controlRules.emplace_back(controlRule);
     AppRunningControlRuleResult controlRuleResult;
+    std::vector<std::string> runningAppIds = {APPID};
     auto RunningRes = appControlManagerDb_->AddAppRunningControlRule(
         AppControlConstants::EDM_CALLING, controlRules, 100);
     auto RunningRes1 = appControlManagerDb_->GetAppRunningControlRule(AppControlConstants::EDM_CALLING, 100, appIds);
-    auto RunningRes2 = appControlManagerDb_->GetAppRunningControlRule(APPID, 100, controlRuleResult);
+    auto RunningRes2 = appControlManagerDb_->GetAppRunningControlRule(runningAppIds, 100, controlRuleResult);
     auto RunningRes3 = appControlManagerDb_->DeleteAppRunningControlRule(
         AppControlConstants::EDM_CALLING, controlRules, 100);
     appControlManagerDb_->AddAppRunningControlRule(AppControlConstants::EDM_CALLING, controlRules, 100);
@@ -582,7 +583,8 @@ HWTEST_F(BmsBundleAppControlTest, AppRunningControlRule_0700, Function | SmallTe
     ret = appControlManagerDb_->AddAppRunningControlRule(AppControlConstants::EDM_CALLING, controlRules, 100);
     EXPECT_EQ(ret, ERR_OK);
     AppRunningControlRuleResult controlRuleResult;
-    ret = appControlManagerDb_->GetAppRunningControlRule(APPID, 100, controlRuleResult);
+    std::vector<std::string> runningAppIds = {APPID};
+    ret = appControlManagerDb_->GetAppRunningControlRule(runningAppIds, 100, controlRuleResult);
     EXPECT_EQ(ret, ERR_OK);
     EXPECT_EQ(controlRuleResult.controlMessage, "test message");
     EXPECT_EQ(controlRuleResult.controlWant, nullptr);
@@ -593,7 +595,7 @@ HWTEST_F(BmsBundleAppControlTest, AppRunningControlRule_0700, Function | SmallTe
     controlRules.emplace_back(controlRule);
     ret = appControlManagerDb_->AddAppRunningControlRule(AppControlConstants::EDM_CALLING, controlRules, 100);
     EXPECT_EQ(ret, ERR_OK);
-    ret = appControlManagerDb_->GetAppRunningControlRule(APPID, 100, controlRuleResult);
+    ret = appControlManagerDb_->GetAppRunningControlRule(runningAppIds, 100, controlRuleResult);
     EXPECT_EQ(controlRuleResult.controlMessage, APP_CONTROL_EDM_DEFAULT_MESSAGE);
     EXPECT_EQ(controlRuleResult.controlWant, nullptr);
     ret = appControlManagerDb_->DeleteAppRunningControlRule(AppControlConstants::EDM_CALLING, 100);
@@ -603,7 +605,7 @@ HWTEST_F(BmsBundleAppControlTest, AppRunningControlRule_0700, Function | SmallTe
     ret = appControlManagerDb_->SetDisposedStatus(PERMISSION_DISPOSED_STATUS, APPID, want, 100);
     EXPECT_EQ(ret, ERR_OK);
     AppRunningControlRuleResult ruleResult;
-    ret = appControlManagerDb_->GetAppRunningControlRule(APPID, 100, ruleResult);
+    ret = appControlManagerDb_->GetAppRunningControlRule(runningAppIds, 100, ruleResult);
     EXPECT_EQ(ret, ERR_OK);
     EXPECT_EQ(ruleResult.controlMessage, "");
     EXPECT_NE(ruleResult.controlWant, nullptr);
@@ -620,7 +622,8 @@ HWTEST_F(BmsBundleAppControlTest, AppRunningControlRule_0700, Function | SmallTe
 HWTEST_F(BmsBundleAppControlTest, AppRunningControlRule_0800, Function | SmallTest | Level1)
 {
     AppRunningControlRuleResult controlRuleResult;
-    auto RunningRes = appControlManagerDb_->GetAppRunningControlRule(APPID, USERID, controlRuleResult);
+    std::vector<std::string> runningAppIds = {APPID};
+    auto RunningRes = appControlManagerDb_->GetAppRunningControlRule(runningAppIds, USERID, controlRuleResult);
     EXPECT_EQ(RunningRes, ERR_BUNDLE_MANAGER_BUNDLE_NOT_SET_CONTROL);
 }
 
@@ -3308,4 +3311,170 @@ HWTEST_F(BmsBundleAppControlTest, DisposeRuleCacheOnlyForBms_0100, Function | Me
     ret = appControlManager->GetDisposedRuleOnlyForBms(appId, disposedRules);
     EXPECT_FALSE(ret);
 }
+
+/**
+ * @tc.number: AppControlManagerHostImpl_8100
+ * @tc.name: test DeleteAppInstallControlRule by AppControlManagerHostImpl
+ * @tc.desc: 1.DeleteAppInstallControlRule test
+ */
+HWTEST_F(BmsBundleAppControlTest, AppControlManagerHostImpl_8100, Function | SmallTest | Level1)
+{
+    auto impl = std::make_shared<AppControlManagerHostImpl>();
+    impl->callingNameMap_.insert(pair<int32_t, std::string>(0, AppControlConstants::EDM_CALLING));
+    std::vector<std::string> appIds;
+    appIds.emplace_back(APPID);
+    ErrCode res = impl->DeleteAppInstallControlRule(AppInstallControlRuleType::DISALLOWED_UNINSTALL, appIds, USERID);
+    EXPECT_EQ(res, ERR_OK);
+
+    InnerBundleInfo innerBundleInfo;
+    innerBundleInfo.baseBundleInfo_->appId = APPID;
+    innerBundleInfo.SetAppIdentifier("appIdentifier");
+    impl->dataMgr_->bundleInfos_.emplace(BUNDLE_NAME, innerBundleInfo);
+    res = impl->DeleteAppInstallControlRule(AppInstallControlRuleType::DISALLOWED_UNINSTALL, appIds, USERID);
+    EXPECT_EQ(res, ERR_OK);
+    impl->dataMgr_->bundleInfos_.erase(BUNDLE_NAME);
+
+    impl->dataMgr_ = nullptr;
+    res = impl->DeleteAppInstallControlRule(AppInstallControlRuleType::DISALLOWED_UNINSTALL, appIds, USERID);
+    EXPECT_EQ(res, ERR_APPEXECFWK_NULL_PTR);
+    impl->dataMgr_ = std::make_shared<BundleDataMgr>();
+}
+
+/**
+ * @tc.number: AppControlManagerHostImpl_8200
+ * @tc.name: test AddAppInstallControlRule by AppControlManagerHostImpl
+ * @tc.desc: 1.AddAppInstallControlRule test
+ */
+HWTEST_F(BmsBundleAppControlTest, AppControlManagerHostImpl_8200, Function | SmallTest | Level1)
+{
+    auto impl = std::make_shared<AppControlManagerHostImpl>();
+    std::vector<std::string> appIds;
+    appIds.emplace_back(APPID);
+    impl->callingNameMap_.insert(pair<int32_t, std::string>(0, AppControlConstants::EDM_CALLING));
+    ErrCode res = impl->AddAppInstallControlRule(appIds, AppInstallControlRuleType::DISALLOWED_UNINSTALL, USERID);
+    EXPECT_EQ(res, ERR_OK);
+
+    InnerBundleInfo innerBundleInfo;
+    innerBundleInfo.baseBundleInfo_->appId = APPID;
+    innerBundleInfo.SetAppIdentifier("appIdentifier");
+    impl->dataMgr_->bundleInfos_.emplace(BUNDLE_NAME, innerBundleInfo);
+    res = impl->AddAppInstallControlRule(appIds, AppInstallControlRuleType::DISALLOWED_UNINSTALL, USERID);
+    EXPECT_EQ(res, ERR_OK);
+    impl->dataMgr_->bundleInfos_.erase(BUNDLE_NAME);
+
+    impl->dataMgr_ = nullptr;
+    res = impl->AddAppInstallControlRule(appIds, AppInstallControlRuleType::DISALLOWED_UNINSTALL, USERID);
+    EXPECT_EQ(res, ERR_APPEXECFWK_NULL_PTR);
+    impl->dataMgr_ = std::make_shared<BundleDataMgr>();
+
+    res = impl->DeleteAppInstallControlRule(AppInstallControlRuleType::DISALLOWED_UNINSTALL, appIds, USERID);
+    EXPECT_EQ(res, ERR_OK);
+}
+
+/**
+ * @tc.number: AppControlManagerHostImpl_8300
+ * @tc.name: test AddAppInstallControlRule by AppControlManagerHostImpl
+ * @tc.desc: 1.AddAppInstallControlRule test
+ */
+HWTEST_F(BmsBundleAppControlTest, AppControlManagerHostImpl_8300, Function | SmallTest | Level1)
+{
+    auto impl = std::make_shared<AppControlManagerHostImpl>();
+    std::vector<std::string> appIds;
+    appIds.emplace_back(APPID);
+    impl->callingNameMap_.insert(pair<int32_t, std::string>(0, AppControlConstants::EDM_CALLING));
+    ErrCode res = impl->AddAppInstallControlRule(appIds, AppInstallControlRuleType::DISALLOWED_UNINSTALL, USERID);
+    EXPECT_EQ(res, ERR_OK);
+    std::vector<std::string> modifyAppIds;
+    res = impl->GetAppInstallControlRule(AppInstallControlRuleType::DISALLOWED_UNINSTALL, USERID, modifyAppIds);
+    EXPECT_EQ(res, ERR_OK);
+    EXPECT_EQ(modifyAppIds.size(), 2);
+    impl->dataMgr_ = nullptr;
+    res = impl->GetAppInstallControlRule(AppInstallControlRuleType::DISALLOWED_UNINSTALL, USERID, modifyAppIds);
+    EXPECT_EQ(res, ERR_APPEXECFWK_NULL_PTR);
+    impl->dataMgr_ = std::make_shared<BundleDataMgr>();
+
+    res = impl->DeleteAppInstallControlRule(AppInstallControlRuleType::DISALLOWED_UNINSTALL, appIds, USERID);
+    EXPECT_EQ(res, ERR_OK);
+}
+
+/**
+ * @tc.number: AppControlManagerHostImpl_8400
+ * @tc.name: test AddAppInstallControlRule by AppControlManagerHostImpl
+ * @tc.desc: 1.AddAppInstallControlRule test
+ */
+HWTEST_F(BmsBundleAppControlTest, AppControlManagerHostImpl_8400, Function | SmallTest | Level1)
+{
+    auto impl = std::make_shared<AppControlManagerHostImpl>();
+    std::vector<std::string> appIds;
+    std::string appIdentifier = "appIdentifier";
+    appIds.emplace_back(appIdentifier);
+    impl->callingNameMap_.insert(pair<int32_t, std::string>(0, AppControlConstants::EDM_CALLING));
+
+    InnerBundleInfo innerBundleInfo;
+    innerBundleInfo.baseBundleInfo_->appId = APPID;
+    innerBundleInfo.SetAppIdentifier(appIdentifier);
+    impl->dataMgr_->bundleInfos_.emplace(BUNDLE_NAME, innerBundleInfo);
+    ErrCode res = impl->AddAppInstallControlRule(appIds, AppInstallControlRuleType::DISALLOWED_UNINSTALL, USERID);
+    EXPECT_EQ(res, ERR_OK);
+
+    appIds.emplace_back(APPID);
+    res = impl->AddAppInstallControlRule(appIds, AppInstallControlRuleType::DISALLOWED_UNINSTALL, USERID);
+    EXPECT_EQ(res, ERR_OK);
+
+    res = impl->DeleteAppInstallControlRule(AppInstallControlRuleType::DISALLOWED_UNINSTALL, appIds, USERID);
+    EXPECT_EQ(res, ERR_OK);
+    impl->dataMgr_->bundleInfos_.erase(BUNDLE_NAME);
+}
+
+/**
+ * @tc.number: AppRunningControlRule_0900
+ * @tc.name: test running control rule
+ * @tc.desc: 1.AddAppRunningControlRule test
+ */
+HWTEST_F(BmsBundleAppControlTest, AppRunningControlRule_0900, Function | SmallTest | Level1)
+{
+    AppControlManager appControlManager;
+    std::vector<AppRunningControlRule> controlRules;
+    AppRunningControlRule controlRule;
+    controlRule.appId = APPID;
+    controlRule.controlMessage = CONTROL_MESSAGE;
+    controlRules.emplace_back(controlRule);
+    auto res = appControlManager.AddAppRunningControlRule(CALLER_BUNDLE_NAME, controlRules, USERID);
+    EXPECT_EQ(res, ERR_OK);
+
+    std::string key = "" + std::string("_") + std::to_string(USERID);
+    AppRunningControlRuleResult controlRuleResult;
+    appControlManager.appRunningControlRuleResult_.emplace(key, controlRuleResult);
+    res = appControlManager.AddAppRunningControlRule(CALLER_BUNDLE_NAME, controlRules, USERID);
+    EXPECT_EQ(res, ERR_OK);
+
+    res = appControlManager.DeleteAppRunningControlRule(CALLER_BUNDLE_NAME, controlRules, USERID);
+    EXPECT_EQ(res, ERR_OK);
+    appControlManager.appRunningControlRuleResult_.clear();
+}
+
+/**
+ * @tc.number: AppRunningControlRule_1000
+ * @tc.name: test running control rule
+ * @tc.require: issueI5MZ8K
+ * @tc.desc: 1.AddAppRunningControlRule test
+ */
+HWTEST_F(BmsBundleAppControlTest, AppRunningControlRule_1000, Function | SmallTest | Level1)
+{
+    AppControlManager appControlManager;
+    std::vector<AppRunningControlRule> controlRules;
+    AppRunningControlRule controlRule;
+    controlRule.appId = APPID;
+    controlRule.controlMessage = CONTROL_MESSAGE;
+    controlRules.emplace_back(controlRule);
+    auto res = appControlManager.DeleteAppRunningControlRule(CALLER_BUNDLE_NAME, controlRules, USERID);
+    EXPECT_EQ(res, ERR_OK);
+
+    std::string key = "" + std::string("_") + std::to_string(USERID);
+    AppRunningControlRuleResult controlRuleResult;
+    appControlManager.appRunningControlRuleResult_.emplace(key, controlRuleResult);
+    res = appControlManager.DeleteAppRunningControlRule(CALLER_BUNDLE_NAME, controlRules, USERID);
+    EXPECT_EQ(res, ERR_OK);
+    appControlManager.appRunningControlRuleResult_.clear();
+}
 } // OHOS
\ No newline at end of file
diff --git a/services/bundlemgr/test/unittest/bms_bundle_app_control_test/bms_bundle_mock_app_control.cpp b/services/bundlemgr/test/unittest/bms_bundle_app_control_test/bms_bundle_mock_app_control.cpp
index 1d003957083675b85b86f9b1d85859a01284f014..19200b09d3a52d83f2b36d0ae964c9526972863d 100644
--- a/services/bundlemgr/test/unittest/bms_bundle_app_control_test/bms_bundle_mock_app_control.cpp
+++ b/services/bundlemgr/test/unittest/bms_bundle_app_control_test/bms_bundle_mock_app_control.cpp
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2023-2024 Huawei Device Co., Ltd.
+ * Copyright (c) 2023-2025 Huawei Device Co., Ltd.
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
@@ -180,9 +180,10 @@ HWTEST_F(BmsBundleMockAppControlTest, AppControlManagerRdb_0060, Function | Smal
     AppControlManagerRdb rdb;
     std::vector<AppRunningControlRule> controlRules;
     AppRunningControlRule appRunningControlRule;
+    appRunningControlRule.appId = "test";
     controlRules.push_back(appRunningControlRule);
     ErrCode res = rdb.AddAppRunningControlRule("", controlRules, USERID);
-    EXPECT_EQ(res, ERR_APPEXECFWK_DB_DELETE_ERROR);
+    EXPECT_EQ(res, ERR_APPEXECFWK_DB_BATCH_INSERT_ERROR);
 }
 
 /**
@@ -250,7 +251,7 @@ HWTEST_F(BmsBundleMockAppControlTest, AppControlManagerRdb_0110, Function | Smal
     std::vector<std::string> appIds;
     appIds.push_back("appId");
     AppRunningControlRuleResult controlRuleResult;
-    auto res = rdb.GetAppRunningControlRule("", USERID, controlRuleResult);
+    auto res = rdb.GetAppRunningControlRule(appIds, USERID, controlRuleResult);
     EXPECT_EQ(res, ERR_APPEXECFWK_DB_RESULT_SET_EMPTY);
 }
 
@@ -724,4 +725,53 @@ HWTEST_F(BmsBundleMockAppControlTest, AppControlManagerHostImpl_0140, Function |
     auto ret = impl.DeleteDisposedRuleForCloneApp(APPID, Constants::MAIN_APP_INDEX, Constants::UNSPECIFIED_USERID);
     EXPECT_EQ(ret, ERR_APPEXECFWK_DB_DELETE_ERROR);
 }
+
+/**
+ * @tc.number: AppControlManagerRdb_0180
+ * @tc.name: Test AddAppInstallControlRule with empty appId by AppControlManagerRdb
+ * @tc.desc: 1.AddAppInstallControlRule test
+ */
+HWTEST_F(BmsBundleMockAppControlTest, AppControlManagerRdb_0180, Function | SmallTest | Level1)
+{
+    AppControlManagerRdb rdb;
+    std::vector<std::string> appIds = { "", "appId" };
+    std::string targetBundleName = "bundleName";
+    auto res = rdb.AddAppInstallControlRule(targetBundleName, appIds, "", USERID);
+    EXPECT_EQ(res, ERR_APPEXECFWK_DB_DELETE_ERROR);
+}
+
+/**
+ * @tc.number: AppControlManagerRdb_0190
+ * @tc.name: Test DeleteAppInstallControlRule by AppControlManagerRdb
+ * @tc.desc: 1.AddAppInstallControlRule test
+ */
+HWTEST_F(BmsBundleMockAppControlTest, AppControlManagerRdb_0190, Function | SmallTest | Level1)
+{
+    AppControlManagerRdb rdb;
+    std::vector<std::string> appIds = { "", "appId" };
+    std::string targetBundleName = "bundleName";
+    auto res = rdb.AddAppInstallControlRule(targetBundleName, appIds, "", USERID);
+    EXPECT_EQ(res, ERR_APPEXECFWK_DB_DELETE_ERROR);
+    res = rdb.DeleteAppInstallControlRule(targetBundleName, "", appIds, USERID);
+    EXPECT_EQ(res, ERR_APPEXECFWK_DB_DELETE_ERROR);
+}
+
+/**
+ * @tc.number: AppControlManagerRdb_0210
+ * @tc.name: Test AddAppRunningControlRule with empty appId by AppControlManagerRdb
+ * @tc.desc: 1.AddAppInstallControlRule test
+ */
+HWTEST_F(BmsBundleMockAppControlTest, AppControlManagerRdb_0210, Function | SmallTest | Level1)
+{
+    AppControlManagerRdb rdb;
+    std::vector<AppRunningControlRule> controlRules;
+    AppRunningControlRule appRunningControlRule1;
+    appRunningControlRule1.appId = "";
+    AppRunningControlRule appRunningControlRule2;
+    appRunningControlRule2.appId = "test";
+    controlRules.push_back(appRunningControlRule1);
+    controlRules.push_back(appRunningControlRule2);
+    ErrCode res = rdb.AddAppRunningControlRule("", controlRules, USERID);
+    EXPECT_EQ(res, ERR_APPEXECFWK_DB_DELETE_ERROR);
+}
 } // OHOS
\ No newline at end of file
diff --git a/services/bundlemgr/test/unittest/bms_bundle_installer_test/bms_bundle_installer_test.cpp b/services/bundlemgr/test/unittest/bms_bundle_installer_test/bms_bundle_installer_test.cpp
index c220cd66b3ee4a91305ec6b703bf9fc10ad0957f..9895df4fe28749211eddcb196ded904d54bb3586 100644
--- a/services/bundlemgr/test/unittest/bms_bundle_installer_test/bms_bundle_installer_test.cpp
+++ b/services/bundlemgr/test/unittest/bms_bundle_installer_test/bms_bundle_installer_test.cpp
@@ -2831,8 +2831,9 @@ HWTEST_F(BmsBundleInstallerTest, baseBundleInstaller_3200, Function | SmallTest
 {
     BaseBundleInstaller installer;
     std::string installAppId;
+    std::string appIdentifier;
     int32_t userId = Constants::DEFAULT_USERID;;
-    OHOS::ErrCode ret = installer.InstallNormalAppControl(installAppId, userId);
+    OHOS::ErrCode ret = installer.InstallNormalAppControl(installAppId, appIdentifier, userId);
     EXPECT_EQ(ret, OHOS::ERR_OK);
 }
 
@@ -4452,6 +4453,7 @@ HWTEST_F(BmsBundleInstallerTest, checkAsanEnabled_0200, Function | SmallTest | L
 HWTEST_F(BmsBundleInstallerTest, baseBundleInstaller_4400, Function | SmallTest | Level0)
 {
     std::string installAppId = APPID;
+    std::string appIdentifier;
     BaseBundleInstaller installer;
     int32_t userId = Constants::DEFAULT_USERID;
     std::vector<std::string> appIds;
@@ -4462,7 +4464,7 @@ HWTEST_F(BmsBundleInstallerTest, baseBundleInstaller_4400, Function | SmallTest
         appIds, AppControlConstants::APP_DISALLOWED_INSTALL, userId);
     EXPECT_EQ(resultAddAppInstallAppControlDisallow, OHOS::ERR_OK);
 
-    auto ret = installer.InstallNormalAppControl(installAppId, userId);
+    auto ret = installer.InstallNormalAppControl(installAppId, appIdentifier, userId);
     EXPECT_EQ(ret, OHOS::ERR_BUNDLE_MANAGER_APP_CONTROL_DISALLOWED_INSTALL);
 
     auto resultDeleteAppInstallAppControlDisallow = DelayedSingleton<AppControlManager>::GetInstance()->
@@ -4479,6 +4481,7 @@ HWTEST_F(BmsBundleInstallerTest, baseBundleInstaller_4400, Function | SmallTest
 HWTEST_F(BmsBundleInstallerTest, baseBundleInstaller_4500, Function | SmallTest | Level0)
 {
     std::string installAppId = APPID;
+    std::string appIdentifier;
     BaseBundleInstaller installer;
     int32_t userId = Constants::DEFAULT_USERID;
     std::vector<std::string> appIds;
@@ -4489,7 +4492,7 @@ HWTEST_F(BmsBundleInstallerTest, baseBundleInstaller_4500, Function | SmallTest
         appIds, AppControlConstants::APP_DISALLOWED_INSTALL, userId);
     EXPECT_EQ(resultAddAppInstallAppControlAllow, OHOS::ERR_OK);
 
-    auto ret = installer.InstallNormalAppControl(installAppId, userId);
+    auto ret = installer.InstallNormalAppControl(installAppId, appIdentifier, userId);
     EXPECT_EQ(ret, OHOS::ERR_OK);
 
     auto resultDeleteAppInstallAppControlAllow = DelayedSingleton<AppControlManager>::GetInstance()->
@@ -4506,6 +4509,7 @@ HWTEST_F(BmsBundleInstallerTest, baseBundleInstaller_4500, Function | SmallTest
 HWTEST_F(BmsBundleInstallerTest, baseBundleInstaller_4600, Function | SmallTest | Level0)
 {
     std::string installAppId = APPID;
+    std::string appIdentifier;
     BaseBundleInstaller installer;
     int32_t userId = Constants::DEFAULT_USERID;
     std::vector<std::string> appIds;
@@ -4521,7 +4525,7 @@ HWTEST_F(BmsBundleInstallerTest, baseBundleInstaller_4600, Function | SmallTest
         appIds, AppControlConstants::APP_DISALLOWED_INSTALL, userId);
     EXPECT_EQ(resultAddAppInstallAppControlDisallow, OHOS::ERR_OK);
 
-    auto ret = installer.InstallNormalAppControl(installAppId, userId);
+    auto ret = installer.InstallNormalAppControl(installAppId, appIdentifier, userId);
     EXPECT_EQ(ret, OHOS::ERR_BUNDLE_MANAGER_APP_CONTROL_DISALLOWED_INSTALL);
 
     auto resultDeleteAppInstallAppControlAllow = DelayedSingleton<AppControlManager>::GetInstance()->
@@ -4543,6 +4547,7 @@ HWTEST_F(BmsBundleInstallerTest, baseBundleInstaller_4600, Function | SmallTest
 HWTEST_F(BmsBundleInstallerTest, baseBundleInstaller_4700, Function | SmallTest | Level0)
 {
     std::string installAppId = APPID;
+    std::string appIdentifier;
     BaseBundleInstaller installer;
     int32_t userId = Constants::DEFAULT_USERID;
     std::vector<std::string> appIds;
@@ -4560,7 +4565,7 @@ HWTEST_F(BmsBundleInstallerTest, baseBundleInstaller_4700, Function | SmallTest
         appIds, AppControlConstants::APP_DISALLOWED_INSTALL, userId);
     EXPECT_EQ(resultAddAppInstallAppControlDisallow, OHOS::ERR_OK);
 
-    auto ret = installer.InstallNormalAppControl(installAppId, userId);
+    auto ret = installer.InstallNormalAppControl(installAppId, appIdentifier, userId);
     EXPECT_EQ(ret, OHOS::ERR_BUNDLE_MANAGER_APP_CONTROL_DISALLOWED_INSTALL);
 
     auto resultDeleteAppInstallAppControlAllow = DelayedSingleton<AppControlManager>::GetInstance()->
@@ -4582,6 +4587,7 @@ HWTEST_F(BmsBundleInstallerTest, baseBundleInstaller_4700, Function | SmallTest
 HWTEST_F(BmsBundleInstallerTest, baseBundleInstaller_4800, Function | SmallTest | Level0)
 {
     std::string installAppId = APPID;
+    std::string appIdentifier;
     BaseBundleInstaller installer;
     int32_t userId = Constants::DEFAULT_USERID;
     std::vector<std::string> appIds;
@@ -4599,7 +4605,7 @@ HWTEST_F(BmsBundleInstallerTest, baseBundleInstaller_4800, Function | SmallTest
         appIdsAllow, AppControlConstants::APP_DISALLOWED_INSTALL, userId);
     EXPECT_EQ(resultAddAppInstallAppControlDisallow, OHOS::ERR_OK);
 
-    auto ret = installer.InstallNormalAppControl(installAppId, userId);
+    auto ret = installer.InstallNormalAppControl(installAppId, appIdentifier, userId);
     EXPECT_EQ(ret, OHOS::ERR_OK);
 
     auto resultDeleteAppInstallAppControlAllow = DelayedSingleton<AppControlManager>::GetInstance()->
@@ -4621,6 +4627,7 @@ HWTEST_F(BmsBundleInstallerTest, baseBundleInstaller_4800, Function | SmallTest
 HWTEST_F(BmsBundleInstallerTest, baseBundleInstaller_4900, Function | SmallTest | Level0)
 {
     std::string installAppId = APPID;
+    std::string appIdentifier;
     BaseBundleInstaller installer;
     int32_t userId = Constants::DEFAULT_USERID;
     std::vector<std::string> appIds;
@@ -4637,7 +4644,7 @@ HWTEST_F(BmsBundleInstallerTest, baseBundleInstaller_4900, Function | SmallTest
         appIds, AppControlConstants::APP_DISALLOWED_INSTALL, userId);
     EXPECT_EQ(resultAddAppInstallAppControlDisallow, OHOS::ERR_OK);
 
-    auto ret = installer.InstallNormalAppControl(installAppId, userId);
+    auto ret = installer.InstallNormalAppControl(installAppId, appIdentifier, userId);
     EXPECT_EQ(ret, OHOS::ERR_BUNDLE_MANAGER_APP_CONTROL_DISALLOWED_INSTALL);
 
     auto resultDeleteAppInstallAppControlAllow = DelayedSingleton<AppControlManager>::GetInstance()->
@@ -4753,6 +4760,177 @@ HWTEST_F(BmsBundleInstallerTest, appControlManagerHostImpl_0200, Function | Smal
     auto ret = impl->GetControlRuleType(AppInstallControlRuleType::UNSPECIFIED);
     EXPECT_EQ(ret, EMPTY_STRING);
 }
+
+/**
+ * @tc.number: CheckInstallPermission_0100
+ * @tc.name: test CheckInstallPermission
+ * @tc.desc: allowedAppIds is empty, appIdentifier is empty
+ */
+HWTEST_F(BmsBundleInstallerTest, CheckInstallPermission_0100, Function | SmallTest | Level0)
+{
+    BaseBundleInstaller installer;
+    std::string installAppId = "app1";
+    std::string appIdentifier = "";
+    std::vector<std::string> allowedAppIds = {};
+    std::vector<std::string> disallowedAppIds = {"app2"};
+    ErrCode result = installer.CheckInstallPermission(installAppId, appIdentifier, allowedAppIds, disallowedAppIds);  
+    EXPECT_EQ(result, ERR_OK);
+
+    disallowedAppIds = {"app1"};
+    result = installer.CheckInstallPermission(installAppId, appIdentifier, allowedAppIds, disallowedAppIds);  
+    EXPECT_EQ(result, ERR_BUNDLE_MANAGER_APP_CONTROL_DISALLOWED_INSTALL);
+}
+
+/**
+ * @tc.number: CheckInstallPermission_0200
+ * @tc.name: test CheckInstallPermission
+ * @tc.desc: allowedAppIds is empty, appIdentifier is not empty
+ */
+HWTEST_F(BmsBundleInstallerTest, CheckInstallPermission_0200, Function | SmallTest | Level0)
+{
+    BaseBundleInstaller installer;
+    std::string installAppId = "app1";
+    std::string appIdentifier = "app2";
+    std::vector<std::string> allowedAppIds = {};
+    std::vector<std::string> disallowedAppIds = {"app1"};
+    ErrCode result = installer.CheckInstallPermission(installAppId, appIdentifier, allowedAppIds, disallowedAppIds);  
+    EXPECT_EQ(result, ERR_BUNDLE_MANAGER_APP_CONTROL_DISALLOWED_INSTALL);
+
+    disallowedAppIds = {"app3"};
+    result = installer.CheckInstallPermission(installAppId, appIdentifier, allowedAppIds, disallowedAppIds);  
+    EXPECT_EQ(result, ERR_OK);
+
+    disallowedAppIds = {"app2", "app3"};
+    result = installer.CheckInstallPermission(installAppId, appIdentifier, allowedAppIds, disallowedAppIds);  
+    EXPECT_EQ(result, ERR_BUNDLE_MANAGER_APP_CONTROL_DISALLOWED_INSTALL);
+}
+
+/**
+ * @tc.number: CheckInstallPermission_0300
+ * @tc.name: test CheckInstallPermission
+ * @tc.desc: disallowedAppIds is empty, appIdentifier is empty
+ */
+HWTEST_F(BmsBundleInstallerTest, CheckInstallPermission_0300, Function | SmallTest | Level0)
+{
+    BaseBundleInstaller installer;
+    std::string installAppId = "app1";
+    std::string appIdentifier = "";
+    std::vector<std::string> allowedAppIds = {"app2"};
+    std::vector<std::string> disallowedAppIds = {};
+    ErrCode result = installer.CheckInstallPermission(installAppId, appIdentifier, allowedAppIds, disallowedAppIds);  
+    EXPECT_EQ(result, ERR_BUNDLE_MANAGER_APP_CONTROL_DISALLOWED_INSTALL);
+
+    allowedAppIds = {"app1"};
+    result = installer.CheckInstallPermission(installAppId, appIdentifier, allowedAppIds, disallowedAppIds);  
+    EXPECT_EQ(result, ERR_OK);
+}
+
+/**
+ * @tc.number: CheckInstallPermission_0400
+ * @tc.name: test CheckInstallPermission
+ * @tc.desc: disallowedAppIds is empty, appIdentifier is not empty
+ */
+HWTEST_F(BmsBundleInstallerTest, CheckInstallPermission_0400, Function | SmallTest | Level0)
+{
+    BaseBundleInstaller installer;
+    std::string installAppId = "app1";
+    std::string appIdentifier = "app2";
+    std::vector<std::string> allowedAppIds = {"app1"};
+    std::vector<std::string> disallowedAppIds = {};
+    ErrCode result = installer.CheckInstallPermission(installAppId, appIdentifier, allowedAppIds, disallowedAppIds);  
+    EXPECT_EQ(result, ERR_OK);
+
+    allowedAppIds = {"app3"};
+    result = installer.CheckInstallPermission(installAppId, appIdentifier, allowedAppIds, disallowedAppIds);
+    EXPECT_EQ(result, ERR_BUNDLE_MANAGER_APP_CONTROL_DISALLOWED_INSTALL);
+
+    allowedAppIds = {"app2", "app3"};
+    result = installer.CheckInstallPermission(installAppId, appIdentifier, allowedAppIds, disallowedAppIds);
+    EXPECT_EQ(result, ERR_OK);
+}
+
+/**
+ * @tc.number: CheckInstallPermission_0500
+ * @tc.name: test CheckInstallPermission
+ * @tc.desc: disallowed list and allowed list all not empty, appIdentifier is empty
+ */
+HWTEST_F(BmsBundleInstallerTest, CheckInstallPermission_0500, Function | SmallTest | Level0)
+{
+    BaseBundleInstaller installer;
+    std::string installAppId = "app1";
+    std::string appIdentifier = "";
+    std::vector<std::string> allowedAppIds = {"app1", "app2"};
+    std::vector<std::string> disallowedAppIds = {"app2", "app3"};
+    ErrCode result = installer.CheckInstallPermission(installAppId, appIdentifier, allowedAppIds, disallowedAppIds);  
+    EXPECT_EQ(result, ERR_OK);
+
+    installAppId = "app2";
+    result = installer.CheckInstallPermission(installAppId, appIdentifier, allowedAppIds, disallowedAppIds);
+    EXPECT_EQ(result, ERR_BUNDLE_MANAGER_APP_CONTROL_DISALLOWED_INSTALL);
+
+    installAppId = "app3";
+    result = installer.CheckInstallPermission(installAppId, appIdentifier, allowedAppIds, disallowedAppIds);
+    EXPECT_EQ(result, ERR_BUNDLE_MANAGER_APP_CONTROL_DISALLOWED_INSTALL);
+
+    installAppId = "app4";
+    result = installer.CheckInstallPermission(installAppId, appIdentifier, allowedAppIds, disallowedAppIds);
+    EXPECT_EQ(result, ERR_BUNDLE_MANAGER_APP_CONTROL_DISALLOWED_INSTALL);
+}
+
+/**
+ * @tc.number: CheckInstallPermission_0600
+ * @tc.name: test CheckInstallPermission
+ * @tc.desc: disallowed list and allowed list all not empty, appIdentifier is not empty
+ */
+HWTEST_F(BmsBundleInstallerTest, CheckInstallPermission_0600, Function | SmallTest | Level0)
+{
+    BaseBundleInstaller installer;
+    std::string installAppId = "app1";
+    std::string appIdentifier = "app1";
+    std::vector<std::string> allowedAppIds = {"app1", "app2"};
+    std::vector<std::string> disallowedAppIds = {"app2", "app3"};
+    ErrCode result = installer.CheckInstallPermission(installAppId, appIdentifier, allowedAppIds, disallowedAppIds);  
+    EXPECT_EQ(result, ERR_OK);
+
+    appIdentifier = "app2";
+    result = installer.CheckInstallPermission(installAppId, appIdentifier, allowedAppIds, disallowedAppIds);
+    EXPECT_EQ(result, ERR_BUNDLE_MANAGER_APP_CONTROL_DISALLOWED_INSTALL);
+
+    appIdentifier = "app3";
+    result = installer.CheckInstallPermission(installAppId, appIdentifier, allowedAppIds, disallowedAppIds);
+    EXPECT_EQ(result, ERR_BUNDLE_MANAGER_APP_CONTROL_DISALLOWED_INSTALL);
+
+    appIdentifier = "app4";
+    result = installer.CheckInstallPermission(installAppId, appIdentifier, allowedAppIds, disallowedAppIds);
+    EXPECT_EQ(result, ERR_BUNDLE_MANAGER_APP_CONTROL_DISALLOWED_INSTALL);
+}
+
+/**
+ * @tc.number: UnInstallAppControl_0100
+ * @tc.name: test UnInstallAppControl
+ * @tc.desc: test UnInstallAppControl when set appIdentifier
+ */
+HWTEST_F(BmsBundleInstallerTest, UnInstallAppControl_0100, Function | SmallTest | Level0)
+{
+    BaseBundleInstaller installer;
+    std::string installAppId = APPID;
+    std::string appIdentifier = "app1";
+    int32_t userId = Constants::DEFAULT_USERID;
+    std::vector<std::string> appIds;
+    appIds.emplace_back(APPID);
+
+    ErrCode result = DelayedSingleton<AppControlManager>::GetInstance()->AddAppInstallControlRule(
+        AppControlConstants::EDM_CALLING, appIds, AppControlConstants::APP_DISALLOWED_UNINSTALL, userId);
+    EXPECT_EQ(result, ERR_OK);
+    bool ret = installer.UninstallAppControl(installAppId, appIdentifier, userId);
+    EXPECT_FALSE(ret);
+
+    result = DelayedSingleton<AppControlManager>::GetInstance()->AddAppInstallControlRule(
+        AppControlConstants::EDM_CALLING, {"app1"}, AppControlConstants::APP_DISALLOWED_UNINSTALL, userId);
+    EXPECT_EQ(result, ERR_OK);
+    ret = installer.UninstallAppControl(installAppId, appIdentifier, userId);
+    EXPECT_FALSE(ret);
+}
 #endif
 
 /**