diff --git a/services/engine/histreamer/player/hiplayer_impl.cpp b/services/engine/histreamer/player/hiplayer_impl.cpp
index fb3ec08175e3c530e38dc5b6d59aa47f17ad1ec6..6f6b7628e57567c63f19d5d8915791d0bad1108d 100644
--- a/services/engine/histreamer/player/hiplayer_impl.cpp
+++ b/services/engine/histreamer/player/hiplayer_impl.cpp
@@ -1130,8 +1130,6 @@ int32_t HiPlayerImpl::Stop()
         AppendPlayerMediaInfo();
     }
     OnStateChanged(PlayerStateId::STOPPED);
-    ReportMediaInfo(instanceId_);
-    GetMediaInfoContainInstanceNum();
     return TransStatus(ret);
 }
 
diff --git a/services/services/player/server/player_server.cpp b/services/services/player/server/player_server.cpp
index 3627d8e7e8d7368ff8aa24226c6681617402b8ec..c377c3f777ecec54776686acb40e0ca8fa0b6745 100644
--- a/services/services/player/server/player_server.cpp
+++ b/services/services/player/server/player_server.cpp
@@ -74,7 +74,7 @@ std::shared_ptr<IPlayerService> PlayerServer::Create()
 PlayerServer::PlayerServer()
 {
     MEDIA_LOGD("0x%{public}06" PRIXPTR " Instances create", FAKE_POINTER(this));
-    instanceId_ = HiviewDFX::HiTraceChain::GetId().GetChainId();
+    instanceId_ = FAKE_POINTER(this);
 }
 
 PlayerServer::~PlayerServer()
@@ -242,7 +242,7 @@ int32_t PlayerServer::InitPlayEngine(const std::string &url)
     playerEngine_->SetInstancdId(instanceId_);
     playerEngine_->SetApiVersion(apiVersion_.load());
     playerEngine_->SetIsCalledBySystemApp(isCalledBySystemApp_);
-    MEDIA_LOGI("Setted InstanceId %{public}" PRIu64, instanceId_);
+    MEDIA_LOGI("Setted InstanceId");
     if (dataSrc_ != nullptr) {
         ret = playerEngine_->SetSource(dataSrc_);
     } else if (mediaSource_ != nullptr) {
@@ -907,6 +907,8 @@ int32_t PlayerServer::Release()
     if (lastOpStatus_ != PLAYER_IDLE) {
         (void)OnReset();
     }
+    ReportMediaInfo(instanceId_);
+    GetMediaInfoContainInstanceNum();
 #ifdef SUPPORT_VIDEO
     if (surface_ != nullptr) {
         surface_ = nullptr;
@@ -1025,8 +1027,7 @@ int32_t PlayerServer::Seek(int32_t mSeconds, PlayerSeekMode mode)
 
 int32_t PlayerServer::HandleSeek(int32_t mSeconds, PlayerSeekMode mode)
 {
-    MEDIA_LOGI("KPI-TRACE: PlayerServer HandleSeek in, mSeconds: %{public}d, mSeconds: %{public}d, "
-        "instanceId: %{public}" PRIu64 "", mSeconds, mode, instanceId_);
+    MEDIA_LOGI("KPI-TRACE: PlayerServer HandleSeek in, mSeconds: %{public}d, mSeconds: %{public}d", mSeconds, mode);
     ExitSeekContinous(false);
     int32_t ret = playerEngine_->Seek(mSeconds, mode);
     CHECK_AND_RETURN_RET_LOG(ret == MSERR_OK, MSERR_INVALID_OPERATION, "Engine Seek Failed!");
@@ -2264,8 +2265,7 @@ int32_t PlayerServer::SeekContinous(int32_t mSeconds)
 
 int32_t PlayerServer::HandleSeekContinous(int32_t mSeconds, int64_t batchNo)
 {
-    MEDIA_LOGI("KPI-TRACE: PlayerServer HandleSeek in, mSeconds: %{public}d, "
-        "instanceId: %{public}" PRIu64 "", mSeconds, instanceId_);
+    MEDIA_LOGI("KPI-TRACE: PlayerServer HandleSeek in, mSeconds: %{public}d,", mSeconds);
     int32_t ret = playerEngine_->SeekContinous(mSeconds, batchNo);
     CHECK_AND_RETURN_RET_LOG(ret == MSERR_OK, MSERR_INVALID_OPERATION, "Engine Seek Failed!");
     MEDIA_LOGI("PlayerServer HandleSeek end");
diff --git a/services/utils/include/media_dfx.h b/services/utils/include/media_dfx.h
index d84988bb07c57df2b3710d6b7d68300d20fab82a..0b5e23db8d22bed31a7b7cfc2dc1a95db44fa582 100644
--- a/services/utils/include/media_dfx.h
+++ b/services/utils/include/media_dfx.h
@@ -95,6 +95,9 @@ __attribute__((visibility("default"))) int32_t CreateMediaInfo(CallType callType
 __attribute__((visibility("default"))) int32_t AppendMediaInfo(const std::shared_ptr<Meta>& meta, uint64_t instanceId);
 __attribute__((visibility("default"))) int32_t ReportMediaInfo(uint64_t instanceId);
 __attribute__((visibility("default"))) uint64_t GetMediaInfoContainInstanceNum();
+__attribute__((visibility("default"))) void GetMaxInstanceNumber(CallType callType, int32_t uid,
+    uint64_t instanceId, int32_t curInsNumber);
+__attribute__((visibility("default"))) void UpdateMaxInsNumberMap(CallType callType);
 
 class __attribute__((visibility("default"))) MediaTrace : public NoCopyable {
 public:
diff --git a/services/utils/media_dfx.cpp b/services/utils/media_dfx.cpp
index 59c51e2149ea9fc0de12c2b0d94b0e97203fec43..ece7733db79b994d62edf5bc80187e142d859ce6 100644
--- a/services/utils/media_dfx.cpp
+++ b/services/utils/media_dfx.cpp
@@ -38,10 +38,12 @@ namespace {
 
     std::mutex collectMut_;
     std::mutex reportMut_;
+    std::mutex maxReportMut_;
     std::map<OHOS::Media::CallType,
         std::map<int32_t, std::list<std::pair<uint64_t, std::shared_ptr<OHOS::Media::Meta>>>>> mediaInfoMap_;
     std::map<OHOS::Media::CallType,
         std::map<int32_t, std::list<std::pair<uint64_t, std::shared_ptr<OHOS::Media::Meta>>>>> reportMediaInfoMap_;
+    std::map<OHOS::Media::CallType, std::map<int32_t, int32_t>> mediaMaxInstanceNumberMap_;
     std::map<uint64_t, std::pair<OHOS::Media::CallType, int32_t>> idMap_;
     std::chrono::system_clock::time_point currentTime_ = std::chrono::system_clock::now();
     bool g_reachMaxMapSize {false};
@@ -53,10 +55,10 @@ namespace {
         std::pair<uint64_t, std::shared_ptr<OHOS::Media::Meta>> metaAppIdPair;
         {
             std::lock_guard<std::mutex> lock(collectMut_);
-            MEDIA_LOG_I("CollectReportMediaInfo, instanceId is %{public}" PRIu64, instanceId);
+            MEDIA_LOG_I("CollectReportMediaInfo in.");
             auto idMapIt = idMap_.find(instanceId);
             if (idMapIt == idMap_.end()) {
-                MEDIA_LOG_W("Not found instanceId in idMap, instanceId is : %{public}" PRIu64, instanceId);
+                MEDIA_LOG_W("Not found instanceId in idMap");
                 return false;
             }
             ct = idMapIt->second.first;
@@ -111,6 +113,7 @@ namespace {
         auto currentTime = std::chrono::system_clock::now();
         currentTime_ = currentTime;
         reportMediaInfoMap_.clear();
+        UpdateMaxInsNumberMap(OHOS::Media::CallType::AVPLAYER);
         return OHOS::Media::MSERR_OK;
     }
 }
@@ -221,6 +224,10 @@ void MediaEvent::CommonStatisicsEventWrite(CallType callType, OHOS::HiviewDFX::H
         }
         eventInfoJson["appName"] = GetClientBundleName(kv.first);
         eventInfoJson["mediaEvents"] = mediaEvents;
+        {
+            std::lock_guard<std::mutex> lock(maxReportMut_);
+            eventInfoJson["maxInstanceNum"] = mediaMaxInstanceNumberMap_[callType][kv.first];
+        }
         jsonArray.push_back(eventInfoJson);
         infoArr.push_back(jsonArray.dump());
     }
@@ -358,34 +365,63 @@ void FaultScreenCaptureEventWrite(const std::string& appName, uint64_t instanceI
 
 int32_t CreateMediaInfo(CallType callType, int32_t uid, uint64_t instanceId)
 {
-    MEDIA_LOG_I("CreateMediaInfo uid is: %{public}" PRId32 " instanceId is: %{public}" PRIu64, uid, instanceId);
-    std::lock_guard<std::mutex> lock(collectMut_);
-    auto instanceIdMap = idMap_.find(instanceId);
-    if (instanceIdMap != idMap_.end()) {
-        MEDIA_LOG_I("instanceId already exists id idMap_");
-        return MSERR_INVALID_VAL;
-    } else {
-        MEDIA_LOG_I("CreateMediaInfo not found instanceId in idMap_, add the instanceId to idMap_");
-        std::pair<CallType, int32_t> insertToMapPair(callType, uid);
-        idMap_[instanceId] = insertToMapPair;
+    MEDIA_LOG_I("CreateMediaInfo uid is: %{public}" PRId32, uid);
+    int32_t curInsNumber = 0;
+    {
+        std::lock_guard<std::mutex> lock(collectMut_);
+        auto instanceIdMap = idMap_.find(instanceId);
+        if (instanceIdMap != idMap_.end()) {
+            MEDIA_LOG_I("instanceId already exists id idMap_");
+            return MSERR_INVALID_VAL;
+        } else {
+            MEDIA_LOG_I("CreateMediaInfo not found instanceId in idMap_, add the instanceId to idMap_");
+            std::pair<CallType, int32_t> insertToMapPair(callType, uid);
+            idMap_[instanceId] = insertToMapPair;
+        }
+        std::shared_ptr<Meta> meta = std::make_shared<Meta>();
+        std::pair<uint64_t, std::shared_ptr<Meta>> metaAppIdPair(instanceId, meta);
+        auto ctUidToMediaInfo = mediaInfoMap_.find(callType);
+        if (ctUidToMediaInfo != mediaInfoMap_.end()) {
+            auto it = ctUidToMediaInfo->second.find(uid);
+            if (it != ctUidToMediaInfo->second.end()) {
+                it->second.push_back(metaAppIdPair);
+                curInsNumber = it->second.size();
+                MEDIA_LOG_I("CreateMediaInfo: Successfully inserted metaAppIdPair for uid ");
+            } else {
+                ctUidToMediaInfo->second[uid].push_back(metaAppIdPair);
+                curInsNumber = 1;
+                MEDIA_LOG_I("CreateMediaInfo: Successfully created new list for uid and inserted metaAppIdPair.");
+            }
+        } else {
+            mediaInfoMap_[callType][uid].push_back(metaAppIdPair);
+            curInsNumber = 1;
+            MEDIA_LOG_I("CreateMediaInfo: Successfully created new list for callType and uid ");
+        }
     }
-    std::shared_ptr<Meta> meta = std::make_shared<Meta>();
-    std::pair<uint64_t, std::shared_ptr<Meta>> metaAppIdPair(instanceId, meta);
-    auto ctUidToMediaInfo = mediaInfoMap_.find(callType);
-    if (ctUidToMediaInfo != mediaInfoMap_.end()) {
-        auto it = ctUidToMediaInfo->second.find(uid);
-        if (it != ctUidToMediaInfo->second.end()) {
-            it->second.push_back(metaAppIdPair);
-            MEDIA_LOG_I("CreateMediaInfo: Successfully inserted metaAppIdPair for uid ");
+    GetMaxInstanceNumber(callType, uid, instanceId, curInsNumber);
+    return MSERR_OK;
+}
+
+void GetMaxInstanceNumber(CallType callType, int32_t uid, uint64_t instanceId, int32_t curInsNumber)
+{
+    std::lock_guard<std::mutex> lock(maxReportMut_);
+    auto ctUidToMaxInsNum = mediaMaxInstanceNumberMap_.find(callType);
+    if (ctUidToMaxInsNum != mediaMaxInstanceNumberMap_.end()) {
+        auto it = ctUidToMaxInsNum->second.find(uid);
+        if (it != ctUidToMaxInsNum->second.end()) {
+            int32_t curMaxInsNumber = it->second;
+            if (curMaxInsNumber < curInsNumber) {
+                it->second = curInsNumber;
+            }
+            MEDIA_LOG_I("CreateMediaInfo: Successfully update maxInsNumber for uid ");
         } else {
-            ctUidToMediaInfo->second[uid].push_back(metaAppIdPair);
-            MEDIA_LOG_I("CreateMediaInfo: Successfully created new list for uid and inserted metaAppIdPair.");
+            ctUidToMaxInsNum->second[uid] = curInsNumber;
+            MEDIA_LOG_I("CreateMediaInfo: Successfully created new maxInsNumber for uid.");
         }
     } else {
-        mediaInfoMap_[callType][uid].push_back(metaAppIdPair);
-        MEDIA_LOG_I("CreateMediaInfo: Successfully created new list for callType and uid ");
+        mediaMaxInstanceNumberMap_[callType][uid] = curInsNumber;
+        MEDIA_LOG_I("CreateMediaInfo: Successfully created new maxInsNumber for callType and uid ");
     }
-    return MSERR_OK;
 }
 
 int32_t AppendMediaInfo(const std::shared_ptr<Meta>& meta, uint64_t instanceId)
@@ -398,7 +434,7 @@ int32_t AppendMediaInfo(const std::shared_ptr<Meta>& meta, uint64_t instanceId)
     std::lock_guard<std::mutex> lock(collectMut_);
     auto idMapIt = idMap_.find(instanceId);
     if (idMapIt == idMap_.end()) {
-        MEDIA_LOG_I("Not found instanceId when append meta, instanceId is : %{public}" PRIu64, instanceId);
+        MEDIA_LOG_I("Not found instanceId when append meta");
         return MSERR_INVALID_VAL;
     }
     CallType ct = idMapIt->second.first;
@@ -429,8 +465,7 @@ int32_t AppendMediaInfo(const std::shared_ptr<Meta>& meta, uint64_t instanceId)
 
 int32_t ReportMediaInfo(uint64_t instanceId)
 {
-    MEDIA_LOG_I("Report.");
-    MEDIA_LOG_I("Delete media info instanceId is: %{public}" PRIu64, instanceId);
+    MEDIA_LOG_I("Report: Delete media info instanceId.");
     if (!CollectReportMediaInfo(instanceId)) {
         MEDIA_LOG_I("Collect media info fail.");
         return MSERR_INVALID_OPERATION;
@@ -451,6 +486,33 @@ int32_t ReportMediaInfo(uint64_t instanceId)
     return MSERR_OK;
 }
 
+void UpdateMaxInsNumberMap(CallType callType)
+{
+    MEDIA_LOG_I("UpdateMaxInsNumberMap start.");
+    auto ctUidToMediaInfo = mediaInfoMap_.find(callType);
+    if (ctUidToMediaInfo == mediaInfoMap_.end()) {
+        return;
+    }
+
+    auto& infoMap = mediaMaxInstanceNumberMap_.find(callType)->second;
+    std::vector<int32_t> keysToRemove;
+    for (auto &info : infoMap) {
+        int32_t uid = info.first;
+        int32_t& maxNum = info.second;
+        auto it = ctUidToMediaInfo->second.find(uid);
+        if (it != ctUidToMediaInfo->second.end()) {
+            maxNum = it->second.size();
+        } else {
+            maxNum = 0;
+            keysToRemove.push_back(uid);
+        }
+    }
+    for (int32_t uid : keysToRemove) {
+        infoMap.erase(uid);
+    }
+    MEDIA_LOG_I("UpdateMaxInsNumberMap end.");
+}
+
 uint64_t GetMediaInfoContainInstanceNum()
 {
     uint64_t mediaInsNum = 0;