diff --git a/interfaces/inner_kits/native_cpp/BUILD.gn b/interfaces/inner_kits/native_cpp/BUILD.gn
index 188e23efb7bf066c2cdba2acf7199b910e99d038..eb86d886ff8b79e827623f64058bd80ae8dcf776 100644
--- a/interfaces/inner_kits/native_cpp/BUILD.gn
+++ b/interfaces/inner_kits/native_cpp/BUILD.gn
@@ -82,6 +82,7 @@ if (defined(ohos_lite)) {
         "${samgr_lite_path}/kits/samgr",
         "${samgr_lite_path}/kits/registry",
         "${utils_lite_path}/include",
+        "${utils_path}/include",
         "//third_party/bounds_checking_function/include",
         "//third_party/json/include",
         "${interfaces_path}/c/ipc/include",
@@ -97,6 +98,7 @@ if (defined(ohos_lite)) {
         "${common_path}/src/dm_constants.cpp",
         "${common_path}/src/json_object.cpp",
         "${devicemanager_path}/radar/src/lite/dm_radar_helper.cpp",
+        "${utils_path}/src/dm_random.cpp",
         "src/device_manager.cpp",
         "src/device_manager_impl.cpp",
         "src/dm_device_info.cpp",
@@ -142,6 +144,7 @@ if (defined(ohos_lite)) {
       "${common_path}/include/dfx",
       "${common_path}/include/dfx/standard",
       "${devicemanager_path}/radar/include",
+      "${utils_path}/include",
     ]
   }
 
@@ -174,6 +177,7 @@ if (defined(ohos_lite)) {
       "${common_path}/src/ipc/standard/ipc_model_codec.cpp",
       "${common_path}/src/json_object.cpp",
       "${devicemanager_path}/radar/src/dm_radar_helper.cpp",
+      "${utils_path}/src/dm_random.cpp",
       "src/device_manager.cpp",
       "src/device_manager_impl.cpp",
       "src/dm_device_info.cpp",
diff --git a/interfaces/inner_kits/native_cpp/include/device_manager_impl.h b/interfaces/inner_kits/native_cpp/include/device_manager_impl.h
index ef690405b82081b75c27c19ae3ecee974c7abaf6..510c9a54fd7c07a3a690a01738c85ce88a9f7f6e 100644
--- a/interfaces/inner_kits/native_cpp/include/device_manager_impl.h
+++ b/interfaces/inner_kits/native_cpp/include/device_manager_impl.h
@@ -464,6 +464,9 @@ private:
     std::map<std::string, uint16_t> pkgName2PubIdMap_;
 
     std::string anonyLocalUdid_;
+
+    std::set<uint16_t> randSubIdSet_;
+    std::set<uint16_t> randPubIdSet_;
 };
 } // namespace DistributedHardware
 } // namespace OHOS
diff --git a/interfaces/inner_kits/native_cpp/src/device_manager_impl.cpp b/interfaces/inner_kits/native_cpp/src/device_manager_impl.cpp
index 2b7920aa62c234da3c1aeb35f1578bb118bfd968..ce5e27635958705a87c8955412bb276b38eda51f 100644
--- a/interfaces/inner_kits/native_cpp/src/device_manager_impl.cpp
+++ b/interfaces/inner_kits/native_cpp/src/device_manager_impl.cpp
@@ -24,6 +24,7 @@
 #include "dm_hitrace.h"
 #include "dm_log.h"
 #include "dm_radar_helper.h"
+#include "dm_random.h"
 #include "ipc_acl_profile_req.h"
 #include "ipc_authenticate_device_req.h"
 #include "ipc_bind_device_req.h"
@@ -98,8 +99,6 @@ constexpr const char* DM_HITRACE_GET_LOCAL_DEVICE_INFO = "DM_HITRACE_GET_LOCAL_D
 constexpr const char* DM_HITRACE_AUTH_TO_CONSULT = "DM_HITRACE_AUTH_TO_CONSULT";
 constexpr const char* DM_HITRACE_INIT = "DM_HITRACE_INIT";
 
-const uint16_t DM_MIN_RANDOM = 1;
-const uint16_t DM_MAX_RANDOM = 65535;
 const uint16_t DM_INVALID_FLAG_ID = 0;
 const uint16_t DM_IMPORT_AUTH_CODE_MIN_LENGTH = 6;
 const uint16_t DM_IMPORT_AUTH_CODE_MAX_LENGTH = 1024;
@@ -110,14 +109,6 @@ const int32_t USLEEP_TIME_US_100000 = 100000; // 100ms
 constexpr int32_t SERVICE_INIT_MAX_NUM = 20;
 constexpr int32_t DM_STRING_LENGTH_MAX = 1024;
 
-uint16_t GenRandUint(uint16_t randMin, uint16_t randMax)
-{
-    std::random_device randDevice;
-    std::mt19937 genRand(randDevice());
-    std::uniform_int_distribution<int> disRand(randMin, randMax);
-    return disRand(genRand);
-}
-
 DeviceManagerImpl &DeviceManagerImpl::GetInstance()
 {
     static DeviceManagerImpl instance;
@@ -1796,6 +1787,7 @@ int32_t DeviceManagerImpl::StartAdvertising(const std::string &pkgName,
         advertiseParam[PARAM_KEY_PUBLISH_ID] = std::to_string(publishId);
     } else {
         publishId = std::atoi((advertiseParam.find(PARAM_KEY_PUBLISH_ID)->second).c_str());
+        randPubIdSet_.emplace(publishId);
     }
     std::string adverParaStr = ConvertMapToJsonString(advertiseParam);
 
@@ -1970,13 +1962,14 @@ uint16_t DeviceManagerImpl::AddDiscoveryCallback(const std::string &pkgName,
     uint16_t subscribeId = DM_INVALID_FLAG_ID;
     if (discoverParam.find(PARAM_KEY_SUBSCRIBE_ID) != discoverParam.end()) {
         subscribeId = std::atoi((discoverParam.find(PARAM_KEY_SUBSCRIBE_ID)->second).c_str());
+        randSubIdSet_.emplace(subscribeId);
     }
     std::string pkgNameTemp = ComposeStr(pkgName, subscribeId);
     {
         std::lock_guard<std::mutex> autoLock(subMapLock);
         auto item = pkgName2SubIdMap_.find(pkgNameTemp);
         if (item == pkgName2SubIdMap_.end() && subscribeId == DM_INVALID_FLAG_ID) {
-            subscribeId = GenRandUint(DM_MIN_RANDOM, DM_MAX_RANDOM);
+            subscribeId = GenUniqueRandUint(randSubIdSet_);
             pkgName2SubIdMap_[pkgNameTemp] = subscribeId;
         } else if (item == pkgName2SubIdMap_.end() && subscribeId != DM_INVALID_FLAG_ID) {
             pkgName2SubIdMap_[pkgNameTemp] = subscribeId;
@@ -1998,6 +1991,7 @@ uint16_t DeviceManagerImpl::RemoveDiscoveryCallback(const std::string &pkgName)
         std::lock_guard<std::mutex> autoLock(subMapLock);
         if (pkgName2SubIdMap_.find(pkgName) != pkgName2SubIdMap_.end()) {
             subscribeId = pkgName2SubIdMap_[pkgName];
+            randSubIdSet_.erase(subscribeId);
             pkgName2SubIdMap_.erase(pkgName);
         }
     }
@@ -2014,7 +2008,7 @@ int32_t DeviceManagerImpl::AddPublishCallback(const std::string &pkgName)
         if (pkgName2PubIdMap_.find(pkgName) != pkgName2PubIdMap_.end()) {
             publishId = pkgName2PubIdMap_[pkgName];
         } else {
-            publishId = GenRandUint(DM_MIN_RANDOM, DM_MAX_RANDOM);
+            publishId = GenUniqueRandUint(randPubIdSet_);
             pkgName2PubIdMap_[pkgName] = publishId;
         }
     }
@@ -2029,6 +2023,7 @@ int32_t DeviceManagerImpl::RemovePublishCallback(const std::string &pkgName)
         std::lock_guard<std::mutex> autoLock(subMapLock);
         if (pkgName2PubIdMap_.find(pkgName) != pkgName2PubIdMap_.end()) {
             publishId = pkgName2PubIdMap_[pkgName];
+            randPubIdSet_.erase(publishId);
             pkgName2PubIdMap_.erase(pkgName);
         }
     }
diff --git a/services/service/include/advertise/advertise_manager.h b/services/service/include/advertise/advertise_manager.h
index 2007807e64f3603456ec9122fc403891d1fe38a3..92b680c136516dfb302d6bf78461aaf4f546c305 100644
--- a/services/service/include/advertise/advertise_manager.h
+++ b/services/service/include/advertise/advertise_manager.h
@@ -28,7 +28,7 @@ public:
 
     int32_t StartAdvertising(const std::string &pkgName, const std::map<std::string, std::string> &advertiseParam);
     int32_t StopAdvertising(const std::string &pkgName, int32_t publishId);
-    void ClearPulishIdCache(const std::string &pkgName);
+    void ClearPublishIdCache(const std::string &pkgName);
 
 private:
     void HandleAutoStopAdvertise(const std::string &timerName, const std::string &pkgName, int32_t publishId);
diff --git a/services/service/include/device_manager_service.h b/services/service/include/device_manager_service.h
index 88805515b3c8a87e7f3be4e81555fb2fb9232051..a78a2152c9017520061b8ccc003ed17176ff24b6 100644
--- a/services/service/include/device_manager_service.h
+++ b/services/service/include/device_manager_service.h
@@ -232,7 +232,7 @@ public:
     int32_t UpdateLocalServiceInfo(const DMLocalServiceInfo &serviceInfo);
     int32_t GetLocalServiceInfoByBundleNameAndPinExchangeType(const std::string &bundleName, int32_t pinExchangeType,
         DMLocalServiceInfo &serviceInfo);
-    void ClearPulishIdCache(const std::string &pkgName);
+    void ClearPublishIdCache(const std::string &pkgName);
     bool IsPC();
     int32_t GetDeviceNetworkIdList(const std::string &pkgName, const NetworkIdQueryFilter &queryFilter,
         std::vector<std::string> &networkIds);
diff --git a/services/service/include/discovery/discovery_manager.h b/services/service/include/discovery/discovery_manager.h
index 7839fd1b9038d7d954e7b45f20a1e0ebd3b4d1a1..a4c6ebc4cc789ee2bdadd7bbf07035a0989df96f 100644
--- a/services/service/include/discovery/discovery_manager.h
+++ b/services/service/include/discovery/discovery_manager.h
@@ -100,12 +100,17 @@ private:
     std::string AddMultiUserIdentify(const std::string &pkgName);
     std::string RemoveMultiUserIdentify(const std::string &pkgName);
     void GetPkgNameAndUserId(const std::string &pkgName, std::string &callerPkgName, int32_t &userId);
+    int32_t GenInnerSubId(const std::string &pkgName, uint16_t subId);
+    int32_t GetAndRemoveInnerSubId(const std::string &pkgName, uint16_t subId);
+    int32_t StopDiscoveringByInnerSubId(const std::string &pkgName, uint16_t subscribeId);
 
 private:
     std::mutex locks_;
     std::mutex subIdMapLocks_;
     std::shared_ptr<DmTimer> timer_;
-    std::map<std::string, uint16_t> pkgName2SubIdMap_;
+    // Caller subId to inner subId. The key is the caller pkgName, the value is
+    // a list of externals subId to inner subId.
+    std::map<std::string, std::map<uint16_t, uint16_t>> pkgName2SubIdMap_;
     std::shared_ptr<SoftbusListener> softbusListener_;
     std::shared_ptr<MineSoftbusListener> mineSoftbusListener_;
     std::shared_ptr<IDeviceManagerServiceListener> listener_;
@@ -122,6 +127,8 @@ private:
     static IDeviceProfileConnector *dpConnector_;
     static void *dpConnectorHandle_;
 #endif
+
+    std::set<uint16_t> randSubIdSet_;
 };
 } // namespace DistributedHardware
 } // namespace OHOS
diff --git a/services/service/src/advertise/advertise_manager.cpp b/services/service/src/advertise/advertise_manager.cpp
index b18cd17134bfe96e9bec2629565d8dad7dada22d..5a852f18adb047af3a5521b06d68ad603321c5bd 100644
--- a/services/service/src/advertise/advertise_manager.cpp
+++ b/services/service/src/advertise/advertise_manager.cpp
@@ -19,6 +19,7 @@
 #include "dm_log.h"
 #include "dm_publish_info.h"
 #include "dm_random.h"
+#include "system_ability_definition.h"
 
 namespace OHOS {
 namespace DistributedHardware {
@@ -154,8 +155,7 @@ int32_t AdvertiseManager::GenInnerPublishId(const std::string &pkgName, int32_t
     {
         std::lock_guard<std::mutex> autoLock(pubMapLock_);
         if (pkgName2PubIdMap_[pkgName].find(publishId) != pkgName2PubIdMap_[pkgName].end()) {
-            softbusListener_->StopPublishSoftbusLNN(pkgName2PubIdMap_[pkgName][publishId]);
-            publishIdSet_.erase(pkgName2PubIdMap_[pkgName][publishId]);
+            return pkgName2PubIdMap_[pkgName][publishId];
         }
         if (pkgName2PubIdMap_.find(pkgName) == pkgName2PubIdMap_.end()) {
             pkgName2PubIdMap_[pkgName] = std::map<int32_t, int32_t>();
@@ -163,7 +163,8 @@ int32_t AdvertiseManager::GenInnerPublishId(const std::string &pkgName, int32_t
         bool isExist = false;
         do {
             tempPublishId = GenRandInt(DM_MIN_RANDOM, DM_MAX_RANDOM);
-            if (publishIdSet_.find(tempPublishId) != publishIdSet_.end()) {
+            if (publishIdSet_.find(tempPublishId) != publishIdSet_.end() ||
+                tempPublishId == DISTRIBUTED_HARDWARE_DEVICEMANAGER_SA_ID) {
                 LOGE("The tempPublishId: %{public}d is exist.", tempPublishId);
                 isExist = true;
             } else {
@@ -194,7 +195,7 @@ int32_t AdvertiseManager::GetAndRemoveInnerPublishId(const std::string &pkgName,
     return tempPublishId;
 }
 
-void AdvertiseManager::ClearPulishIdCache(const std::string &pkgName)
+void AdvertiseManager::ClearPublishIdCache(const std::string &pkgName)
 {
     LOGI("Begin for pkgName = %{public}s.", pkgName.c_str());
     if (pkgName.empty()) {
diff --git a/services/service/src/device_manager_service.cpp b/services/service/src/device_manager_service.cpp
index a747606cb72d6d169f8fd57902005cb81cdf1c2e..96db581d52cc4b84a55b2409a223621d46221388 100644
--- a/services/service/src/device_manager_service.cpp
+++ b/services/service/src/device_manager_service.cpp
@@ -3283,10 +3283,10 @@ void DeviceManagerService::AddHmlInfoToBindParam(int32_t actionId, std::string &
     cJSON_Delete(bindParamObj);
 }
 
-void DeviceManagerService::ClearPulishIdCache(const std::string &pkgName)
+void DeviceManagerService::ClearPublishIdCache(const std::string &pkgName)
 {
     CHECK_NULL_VOID(advertiseMgr_);
-    advertiseMgr_->ClearPulishIdCache(pkgName);
+    advertiseMgr_->ClearPublishIdCache(pkgName);
 }
 
 bool DeviceManagerService::IsPC()
diff --git a/services/service/src/discovery/discovery_manager.cpp b/services/service/src/discovery/discovery_manager.cpp
index 0dd6b5ebf87179fe27f1aee767cea6d25b996b65..23caf709295e6d90fc73b7805017b5172b8be7e7 100644
--- a/services/service/src/discovery/discovery_manager.cpp
+++ b/services/service/src/discovery/discovery_manager.cpp
@@ -20,6 +20,7 @@
 
 #include "dm_anonymous.h"
 #include "dm_constants.h"
+#include "dm_random.h"
 #include "parameter.h"
 #if !(defined(__LITEOS_M__) || defined(LITE_DEVICE))
 #include "multiple_user_connector.h"
@@ -79,12 +80,10 @@ int32_t DiscoveryManager::EnableDiscoveryListener(const std::string &pkgName,
         std::string metaType = discoverParam.find(PARAM_KEY_META_TYPE)->second;
         LOGI("EnableDiscoveryListener, input MetaType = %{public}s in discoverParam map.", metaType.c_str());
     }
-    if (discoverParam.find(PARAM_KEY_SUBSCRIBE_ID) != discoverParam.end()) {
-        dmSubInfo.subscribeId = std::atoi((discoverParam.find(PARAM_KEY_SUBSCRIBE_ID)->second).c_str());
-        {
-            std::lock_guard<std::mutex> autoLock(subIdMapLocks_);
-            pkgName2SubIdMap_[pkgNameTemp] = dmSubInfo.subscribeId;
-        }
+    if (discoverParam.find(PARAM_KEY_SUBSCRIBE_ID) != discoverParam.end() &&
+        IsNumberString((discoverParam.find(PARAM_KEY_SUBSCRIBE_ID)->second))) {
+            uint16_t externalSubId = std::atoi((discoverParam.find(PARAM_KEY_SUBSCRIBE_ID)->second).c_str());
+            dmSubInfo.subscribeId = GenInnerSubId(pkgNameTemp, externalSubId);
     }
     if (discoverParam.find(PARAM_KEY_DISC_CAPABILITY) != discoverParam.end()) {
         std::string capability = discoverParam.find(PARAM_KEY_DISC_CAPABILITY)->second;
@@ -121,13 +120,11 @@ int32_t DiscoveryManager::DisableDiscoveryListener(const std::string &pkgName,
         LOGI("DisableDiscoveryListener, input MetaType = %{public}s",
             (extraParam.find(PARAM_KEY_META_TYPE)->second).c_str());
     }
-    uint16_t subscribeId = DM_INVALID_FLAG_ID;
-    if (extraParam.find(PARAM_KEY_SUBSCRIBE_ID) != extraParam.end()) {
-        subscribeId = std::atoi((extraParam.find(PARAM_KEY_SUBSCRIBE_ID)->second).c_str());
-        {
-            std::lock_guard<std::mutex> autoLock(subIdMapLocks_);
-            pkgName2SubIdMap_.erase(pkgNameTemp);
-        }
+    uint16_t innerSubId = DM_INVALID_FLAG_ID;
+    if (extraParam.find(PARAM_KEY_SUBSCRIBE_ID) != extraParam.end() &&
+        IsNumberString(extraParam.find(PARAM_KEY_SUBSCRIBE_ID)->second)) {
+        uint16_t externalSubId = std::atoi((extraParam.find(PARAM_KEY_SUBSCRIBE_ID)->second).c_str());
+        innerSubId = GetAndRemoveInnerSubId(pkgNameTemp, externalSubId);
     }
     {
         std::lock_guard<std::mutex> capLock(capabilityMapLocks_);
@@ -136,7 +133,11 @@ int32_t DiscoveryManager::DisableDiscoveryListener(const std::string &pkgName,
         }
     }
     softbusListener_->UnRegisterSoftbusLnnOpsCbk(pkgNameTemp);
-    return softbusListener_->StopRefreshSoftbusLNN(subscribeId);
+    if (innerSubId == DM_INVALID_FLAG_ID) {
+        LOGE("Invalid parameter, cannot find subscribeId in cache map.");
+        return ERR_DM_INPUT_PARA_INVALID;
+    }
+    return softbusListener_->StopRefreshSoftbusLNN(innerSubId);
 }
 
 int32_t DiscoveryManager::StartDiscovering(const std::string &pkgName,
@@ -153,6 +154,7 @@ int32_t DiscoveryManager::StartDiscovering(const std::string &pkgName,
     if (HandleDiscoveryQueue(pkgNameTemp, dmSubInfo.subscribeId, filterOptions) != DM_OK) {
         return ERR_DM_DISCOVERY_REPEATED;
     }
+    dmSubInfo.subscribeId = GenInnerSubId(pkgNameTemp, dmSubInfo.subscribeId);
 
     bool isStandardMetaNode = true;
     if (discoverParam.find(PARAM_KEY_META_TYPE) != discoverParam.end()) {
@@ -320,30 +322,45 @@ int32_t DiscoveryManager::StopDiscovering(const std::string &pkgName, uint16_t s
         return ERR_DM_INPUT_PARA_INVALID;
     }
     std::string pkgNameTemp = RemoveMultiUserIdentify(pkgName);
+    return StopDiscoveringByInnerSubId(pkgNameTemp, subscribeId);
+}
+
+int32_t DiscoveryManager::StopDiscoveringByInnerSubId(const std::string &pkgName, uint16_t subscribeId)
+{
+    LOGI("DiscoveryManager::StopDiscovering begin for pkgName = %{public}s.", pkgName.c_str());
+    if (pkgName.empty()) {
+        LOGE("Invalid parameter, pkgName is empty.");
+        return ERR_DM_INPUT_PARA_INVALID;
+    }
+    uint16_t innerSubId = GetAndRemoveInnerSubId(pkgName, subscribeId);
+    if (innerSubId == DM_INVALID_FLAG_ID) {
+        LOGE("Invalid parameter, cannot find subscribeId in cache map.");
+        return ERR_DM_INPUT_PARA_INVALID;
+    }
     {
         std::lock_guard<std::mutex> autoLock(locks_);
-        if (pkgNameSet_.find(pkgNameTemp) != pkgNameSet_.end()) {
-            pkgNameSet_.erase(pkgNameTemp);
+        if (pkgNameSet_.find(pkgName) != pkgNameSet_.end()) {
+            pkgNameSet_.erase(pkgName);
         }
 
-        if (discoveryContextMap_.find(pkgNameTemp) != discoveryContextMap_.end()) {
-            discoveryContextMap_.erase(pkgNameTemp);
+        if (discoveryContextMap_.find(pkgName) != discoveryContextMap_.end()) {
+            discoveryContextMap_.erase(pkgName);
             if (timer_ != nullptr) {
-                timer_->DeleteTimer(pkgNameTemp);
+                timer_->DeleteTimer(pkgName);
             }
         }
     }
     {
         std::lock_guard<std::mutex> capLock(capabilityMapLocks_);
-        if (capabilityMap_.find(pkgNameTemp) != capabilityMap_.end()) {
-            capabilityMap_.erase(pkgNameTemp);
+        if (capabilityMap_.find(pkgName) != capabilityMap_.end()) {
+            capabilityMap_.erase(pkgName);
         }
     }
-    softbusListener_->UnRegisterSoftbusLnnOpsCbk(pkgNameTemp);
+    softbusListener_->UnRegisterSoftbusLnnOpsCbk(pkgName);
 #if (defined(MINE_HARMONY))
-    return mineSoftbusListener_->StopRefreshSoftbusLNN(subscribeId);
+    return mineSoftbusListener_->StopRefreshSoftbusLNN(innerSubId);
 #else
-    return softbusListener_->StopRefreshSoftbusLNN(subscribeId);
+    return softbusListener_->StopRefreshSoftbusLNN(innerSubId);
 #endif
 }
 
@@ -393,6 +410,14 @@ void DiscoveryManager::OnDeviceFound(const std::string &pkgName, const uint32_t
             discoveryContext = iter->second;
         }
     }
+    uint16_t externalSubId = DM_INVALID_FLAG_ID;
+    {
+        std::lock_guard<std::mutex> autoLock(subIdMapLocks_);
+        for (auto iter : pkgName2SubIdMap_[pkgName]) {
+            externalSubId = iter.first;
+            break;
+        }
+    }
     if (!isIndiscoveryContextMap) {
         {
             std::lock_guard<std::mutex> capLock(capabilityMapLocks_);
@@ -401,13 +426,8 @@ void DiscoveryManager::OnDeviceFound(const std::string &pkgName, const uint32_t
                 return;
             }
         }
-        uint16_t subscribeId = 0;
-        {
-            std::lock_guard<std::mutex> autoLock(subIdMapLocks_);
-            subscribeId = pkgName2SubIdMap_[pkgName];
-        }
         LOGD("OnDeviceFound, pkgName = %{public}s, cabability = %{public}d", pkgName.c_str(), capabilityType);
-        listener_->OnDeviceFound(processInfo, subscribeId, info);
+        listener_->OnDeviceFound(processInfo, externalSubId, info);
         return;
     }
     DiscoveryFilter filter;
@@ -420,7 +440,7 @@ void DiscoveryManager::OnDeviceFound(const std::string &pkgName, const uint32_t
             }
         }
         LOGD("OnDeviceFound, pkgName = %{public}s, cabability = %{public}d", pkgName.c_str(), capabilityType);
-        listener_->OnDeviceFound(processInfo, discoveryContext.subscribeId, info);
+        listener_->OnDeviceFound(processInfo, externalSubId, info);
     }
 }
 
@@ -448,10 +468,20 @@ void DiscoveryManager::OnDiscoveringResult(const std::string &pkgName, int32_t s
         LOGE("DiscoveryManager::OnDiscoveringResult failed, IDeviceManagerServiceListener is null.");
         return;
     }
+    uint16_t externalSubId = DM_INVALID_FLAG_ID;
+    {
+        std::lock_guard<std::mutex> autoLock(subIdMapLocks_);
+        for (auto iter : pkgName2SubIdMap_[pkgName]) {
+            if (iter.second == subscribeId) {
+                externalSubId = iter.first;
+                break;
+            }
+        }
+    }
     if (result == 0) {
         std::lock_guard<std::mutex> autoLock(locks_);
-        discoveryContextMap_[pkgName].subscribeId = (uint32_t)subscribeId;
-        listener_->OnDiscoverySuccess(processInfo, subscribeId);
+        discoveryContextMap_[pkgName].subscribeId = (uint32_t)externalSubId;
+        listener_->OnDiscoverySuccess(processInfo, externalSubId);
         return;
     }
     {
@@ -472,7 +502,7 @@ void DiscoveryManager::OnDiscoveringResult(const std::string &pkgName, int32_t s
             capabilityMap_.erase(pkgName);
         }
     }
-    listener_->OnDiscoveryFailed(processInfo, (uint32_t)subscribeId, result);
+    listener_->OnDiscoveryFailed(processInfo, (uint32_t)externalSubId, result);
     softbusListener_->StopRefreshSoftbusLNN(subscribeId);
 }
 
@@ -514,7 +544,7 @@ int32_t DiscoveryManager::HandleDiscoveryQueue(const std::string &pkgName, uint1
 
 void DiscoveryManager::HandleDiscoveryTimeout(const std::string &pkgName)
 {
-    LOGI("DiscoveryManager::HandleDiscoveryTimeout");
+    LOGI("DiscoveryManager::HandleDiscoveryTimeout, pkgName: %{public}s.", pkgName.c_str());
     uint16_t subscribeId = 0;
     {
         std::lock_guard<std::mutex> autoLock(locks_);
@@ -530,7 +560,11 @@ void DiscoveryManager::HandleDiscoveryTimeout(const std::string &pkgName)
         }
         subscribeId = discoveryContextMap_[pkgName].subscribeId;
     }
-    StopDiscovering(pkgName, subscribeId);
+    StopDiscoveringByInnerSubId(pkgName, subscribeId);
+    {
+        std::lock_guard<std::mutex> autoLock(multiUserDiscLocks_);
+        multiUserDiscMap_.erase(pkgName);
+    }
 }
 
 void DiscoveryManager::UpdateInfoFreq(
@@ -642,7 +676,14 @@ void DiscoveryManager::ClearDiscoveryCache(const ProcessInfo &processInfo)
     for (auto it : subscribeIdSet) {
         std::string pkgNameTemp = (ComposeStr(ComposeStr(processInfo.pkgName, it), processInfo.userId));
         softbusListener_->UnRegisterSoftbusLnnOpsCbk(pkgNameTemp);
-        softbusListener_->StopRefreshSoftbusLNN(it);
+        uint16_t innerSubId = DM_INVALID_FLAG_ID;
+        {
+            std::lock_guard<std::mutex> autoLock(subIdMapLocks_);
+            innerSubId = pkgName2SubIdMap_[pkgNameTemp][it];
+            randSubIdSet_.erase(innerSubId);
+            pkgName2SubIdMap_.erase(pkgNameTemp);
+        }
+        softbusListener_->StopRefreshSoftbusLNN(innerSubId);
     }
 
     CHECK_NULL_VOID(timer_);
@@ -688,13 +729,12 @@ std::set<uint16_t> DiscoveryManager::ClearDiscoveryPkgName(const std::string &pk
     }
     {
         std::lock_guard<std::mutex> autoLock(subIdMapLocks_);
-        for (auto it = pkgName2SubIdMap_.begin(); it != pkgName2SubIdMap_.end();) {
+        for (auto it = pkgName2SubIdMap_.begin(); it != pkgName2SubIdMap_.end(); ++it) {
             if (it->first.find(pkgName) != std::string::npos) {
                 LOGI("Erase pkgname %{public}s from pkgName2SubIdMap_.", it->first.c_str());
-                subscribeIdSet.insert(it->second);
-                it = pkgName2SubIdMap_.erase(it);
-            } else {
-                ++it;
+                for (auto iter : it->second) {
+                    subscribeIdSet.insert(iter.first);
+                }
             }
         }
     }
@@ -755,5 +795,40 @@ void DiscoveryManager::GetPkgNameAndUserId(const std::string &pkgName, std::stri
     }
     LOGE("find failed PkgName %{public}s.", pkgName.c_str());
 }
+
+int32_t DiscoveryManager::GenInnerSubId(const std::string &pkgName, uint16_t subId)
+{
+    uint16_t tempSubId = DM_INVALID_FLAG_ID;
+    {
+        std::lock_guard<std::mutex> autoLock(subIdMapLocks_);
+        if (pkgName2SubIdMap_[pkgName].find(subId) != pkgName2SubIdMap_[pkgName].end()) {
+            return pkgName2SubIdMap_[pkgName][subId];
+        }
+        if (pkgName2SubIdMap_.find(pkgName) == pkgName2SubIdMap_.end()) {
+            pkgName2SubIdMap_[pkgName] = std::map<uint16_t, uint16_t>();
+        }
+        tempSubId = GenUniqueRandUint(randSubIdSet_);
+        randSubIdSet_.emplace(tempSubId);
+        pkgName2SubIdMap_[pkgName][subId] = tempSubId;
+    }
+    return tempSubId;
+}
+
+int32_t DiscoveryManager::GetAndRemoveInnerSubId(const std::string &pkgName, uint16_t subId)
+{
+    uint16_t tempSubId = DM_INVALID_FLAG_ID;
+    {
+        std::lock_guard<std::mutex> autoLock(subIdMapLocks_);
+        if (pkgName2SubIdMap_[pkgName].find(subId) != pkgName2SubIdMap_[pkgName].end()) {
+            tempSubId = pkgName2SubIdMap_[pkgName][subId];
+            pkgName2SubIdMap_[pkgName].erase(subId);
+            randSubIdSet_.erase(tempSubId);
+        }
+        if (pkgName2SubIdMap_[pkgName].empty()) {
+            pkgName2SubIdMap_.erase(pkgName);
+        }
+    }
+    return tempSubId;
+}
 } // namespace DistributedHardware
 } // namespace OHOS
diff --git a/services/service/src/ipc/standard/ipc_server_stub.cpp b/services/service/src/ipc/standard/ipc_server_stub.cpp
index 882758434ef69a3651e015aa0d54ba5fe40a382b..d185bf7745543e836ac28708702b608c515bc3bf 100644
--- a/services/service/src/ipc/standard/ipc_server_stub.cpp
+++ b/services/service/src/ipc/standard/ipc_server_stub.cpp
@@ -412,7 +412,7 @@ void AppDeathRecipient::OnRemoteDied(const wptr<IRemoteObject> &remote)
     IpcServerStub::GetInstance().UnRegisterDeviceManagerListener(processInfo);
     DeviceManagerService::GetInstance().ClearDiscoveryCache(processInfo);
     DeviceManagerServiceNotify::GetInstance().ClearDiedProcessCallback(processInfo);
-    DeviceManagerService::GetInstance().ClearPulishIdCache(processInfo.pkgName);
+    DeviceManagerService::GetInstance().ClearPublishIdCache(processInfo.pkgName);
 }
 
 void IpcServerStub::AddSystemSA(const std::string &pkgName)
diff --git a/test/commonunittest/UTTest_discovery_manager.cpp b/test/commonunittest/UTTest_discovery_manager.cpp
index 95f3f90eb8d8cdaebfd9c26dcc8022486b8a4430..6568eace64228c7448eb97b3740629293688d340 100644
--- a/test/commonunittest/UTTest_discovery_manager.cpp
+++ b/test/commonunittest/UTTest_discovery_manager.cpp
@@ -99,7 +99,7 @@ HWTEST_F(DiscoveryManagerTest, DisableDiscoveryListener_002, testing::ext::TestS
     extraParam.insert(std::pair<std::string, std::string>("META_TYPE", "ohos.test"));
     extraParam.insert(std::pair<std::string, std::string>("SUBSCRIBE_ID", "ohos.test"));
     int32_t ret = manager->DisableDiscoveryListener(pkgName, extraParam);
-    EXPECT_EQ(true, checkSoftbusRes(ret));
+    EXPECT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
 }
 
 HWTEST_F(DiscoveryManagerTest, DisableDiscoveryListener_003, testing::ext::TestSize.Level0)
@@ -107,7 +107,7 @@ HWTEST_F(DiscoveryManagerTest, DisableDiscoveryListener_003, testing::ext::TestS
     std::string pkgName = "pkgName";
     std::map<std::string, std::string> extraParam;
     int32_t ret = manager->DisableDiscoveryListener(pkgName, extraParam);
-    EXPECT_EQ(true, checkSoftbusRes(ret));
+    EXPECT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
 }
 
 HWTEST_F(DiscoveryManagerTest, StartDiscovering_001, testing::ext::TestSize.Level0)
diff --git a/test/unittest/UTTest_device_manager_service.cpp b/test/unittest/UTTest_device_manager_service.cpp
index 431d7e72b25aab6dc6290051d25d1ef57eadc4c3..08e5dd4e5eb2624908288ca937c5161086ae8fe0 100644
--- a/test/unittest/UTTest_device_manager_service.cpp
+++ b/test/unittest/UTTest_device_manager_service.cpp
@@ -1736,7 +1736,7 @@ HWTEST_F(DeviceManagerServiceTest, StartDiscovering_003, testing::ext::TestSize.
     int32_t ret = DeviceManagerService::GetInstance().StartDiscovering(pkgName, discoverParam, filterOptions);
     EXPECT_TRUE(ret == SOFTBUS_IPC_ERR || ret == DM_OK || ret == SOFTBUS_DISCOVER_MANAGER_INNERFUNCTION_FAIL);
     ret = DeviceManagerService::GetInstance().StopDiscovering(pkgName, discoverParam);
-    EXPECT_EQ(ret, SOFTBUS_NETWORK_NOT_INIT);
+    EXPECT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
     DeviceManagerService::GetInstance().UninitDMServiceListener();
 }
 
@@ -1783,7 +1783,7 @@ HWTEST_F(DeviceManagerServiceTest, StopDiscovering_003, testing::ext::TestSize.L
     EXPECT_CALL(*softbusListenerMock_, StopRefreshSoftbusLNN(_)).Times(::testing::AtLeast(1))
         .WillOnce(Return(SOFTBUS_NETWORK_NOT_INIT));
     int32_t ret = DeviceManagerService::GetInstance().StopDiscovering(pkgName, discoverParam);
-    EXPECT_EQ(ret, SOFTBUS_NETWORK_NOT_INIT);
+    EXPECT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
     DeviceManagerService::GetInstance().UninitDMServiceListener();
 }
 
@@ -1858,7 +1858,7 @@ HWTEST_F(DeviceManagerServiceTest, DisableDiscoveryListener_004, testing::ext::T
     DeviceManagerService::GetInstance().InitDMServiceListener();
     EXPECT_CALL(*softbusListenerMock_, StopRefreshSoftbusLNN(_)).WillOnce(Return(SOFTBUS_NETWORK_NOT_INIT));
     int32_t ret = DeviceManagerService::GetInstance().DisableDiscoveryListener(pkgName, extraParam);
-    EXPECT_EQ(ret, SOFTBUS_NETWORK_NOT_INIT);
+    EXPECT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
     DeviceManagerService::GetInstance().UninitDMServiceListener();
 }
 
diff --git a/test/unittest/UTTest_device_manager_service_two.cpp b/test/unittest/UTTest_device_manager_service_two.cpp
index 61b869072fa00507012d93871be1b58792e13dfd..03669d05e485487428012d90db91980540ea6bb5 100644
--- a/test/unittest/UTTest_device_manager_service_two.cpp
+++ b/test/unittest/UTTest_device_manager_service_two.cpp
@@ -1491,7 +1491,7 @@ HWTEST_F(DeviceManagerServiceTest, RegisterLocalServiceInfo_201, testing::ext::T
         foregroundUserIds, backgroundUserIds);
     
     std::string pkgName = "pkgName";
-    DeviceManagerService::GetInstance().ClearPulishIdCache(pkgName);
+    DeviceManagerService::GetInstance().ClearPublishIdCache(pkgName);
     DeviceManagerService::GetInstance().hichainListener_ = nullptr;
 }
 
diff --git a/utils/include/dm_random.h b/utils/include/dm_random.h
index 7b88bb4b5f59f420143135b99790daa38d232c49..901cfab0b885c104b7c6f0bedf2e51cb33108e6c 100644
--- a/utils/include/dm_random.h
+++ b/utils/include/dm_random.h
@@ -17,11 +17,14 @@
 #define OHOS_DM_RANDOM_H
 
 #include <cstdint>
+#include <set>
 
 namespace OHOS {
 namespace DistributedHardware {
 int32_t GenRandInt(int32_t randMin, int32_t randMax);
 int64_t GenRandLongLong(int64_t randMin, int64_t randMax);
+uint16_t GenRandUint(uint16_t randMin, uint16_t randMax);
+uint16_t GenUniqueRandUint(std::set<uint16_t> &randUint16Set);
 } // namespace DistributedHardware
 } // namespace OHOS
 
diff --git a/utils/src/dm_random.cpp b/utils/src/dm_random.cpp
index 6649c2102078641f66c61599a5e22085e06f35a0..0d5955f40d4d609bc5b5d481a15efd38eac2f3b8 100644
--- a/utils/src/dm_random.cpp
+++ b/utils/src/dm_random.cpp
@@ -17,12 +17,20 @@
 
 #include <random>
 
+#include "dm_log.h"
+
 #if defined(__LITEOS_M__)
 #include <time.h>
 #endif
 
 namespace OHOS {
 namespace DistributedHardware {
+namespace {
+const int32_t DM_MIN_RANDOM = 1;
+const int32_t DM_MAX_RANDOM_UINT16 = INT16_MAX;
+const int32_t DM_INVALID_FLAG_ID = 0;
+}
+
 int32_t GenRandInt(int32_t randMin, int32_t randMax)
 {
 #if defined(__LITEOS_M__)
@@ -43,5 +51,30 @@ int64_t GenRandLongLong(int64_t randMin, int64_t randMax)
     std::uniform_int_distribution<long long> disRand(randMin, randMax);
     return disRand(genRand);
 }
+
+uint16_t GenRandUint(uint16_t randMin, uint16_t randMax)
+{
+    std::random_device randDevice;
+    std::mt19937 genRand(randDevice());
+    std::uniform_int_distribution<int> disRand(randMin, randMax);
+    return disRand(genRand);
+}
+
+uint16_t GenUniqueRandUint(std::set<uint16_t> &randUint16Set)
+{
+    uint16_t randUint = DM_INVALID_FLAG_ID;
+    bool isExist = false;
+    do {
+        randUint = GenRandInt(DM_MIN_RANDOM, DM_MAX_RANDOM_UINT16);
+        if (randUint16Set.find(randUint) != randUint16Set.end()) {
+            LOGE("The randUint: %{public}d is exist.", randUint);
+            isExist = true;
+        } else {
+            isExist = false;
+        }
+    } while (isExist);
+    randUint16Set.emplace(randUint);
+    return randUint;
+}
 } // namespace DistributedHardware
 } // namespace OHOS