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..23521ee3af00692ea7ac3022496bbb0523738e32 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..9996a48446547c81630db6d17e4b2002e868d113 100644
--- a/services/utils/include/media_dfx.h
+++ b/services/utils/include/media_dfx.h
@@ -95,6 +95,10 @@ __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"))) int32_t GetMediaInfoInstanceNum(CallType callType, int32_t uid);
+__attribute__((visibility("default"))) void ResetMaxInsNumberMap(CallType callType,
+    std::map<int32_t, int32_t>& infoMap);
+__attribute__((visibility("default"))) void GetMaxInstanceNumber(CallType callType, int32_t uid, uint64_t instanceId);
 
 class __attribute__((visibility("default"))) MediaTrace : public NoCopyable {
 public:
diff --git a/services/utils/media_dfx.cpp b/services/utils/media_dfx.cpp
index 59c51e2149ea9fc0de12c2b0d94b0e97203fec43..f43df5a4fe6291f4462e935a5d726a344e8b4216 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,10 @@ namespace {
         auto currentTime = std::chrono::system_clock::now();
         currentTime_ = currentTime;
         reportMediaInfoMap_.clear();
+        std::lock_guard<std::mutex> lock(maxReportMut_);
+        for (auto &it : mediaMaxInstanceNumberMap_) {
+            ResetMaxInsNumberMap(it.first, it.second);
+        }
         return OHOS::Media::MSERR_OK;
     }
 }
@@ -221,6 +227,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,7 +368,7 @@ 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);
+    MEDIA_LOG_I("CreateMediaInfo uid is: %{public}" PRId32, uid);
     std::lock_guard<std::mutex> lock(collectMut_);
     auto instanceIdMap = idMap_.find(instanceId);
     if (instanceIdMap != idMap_.end()) {
@@ -385,9 +395,33 @@ int32_t CreateMediaInfo(CallType callType, int32_t uid, uint64_t instanceId)
         mediaInfoMap_[callType][uid].push_back(metaAppIdPair);
         MEDIA_LOG_I("CreateMediaInfo: Successfully created new list for callType and uid ");
     }
+    GetMaxInstanceNumber(callType, uid, instanceId);
     return MSERR_OK;
 }
 
+void GetMaxInstanceNumber(CallType callType, int32_t uid, uint64_t instanceId)
+{
+    std::lock_guard<std::mutex> lock(maxReportMut_);
+    int32_t curInsNumber = GetMediaInfoInstanceNum(callType, uid);
+    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 {
+            ctUidToMaxInsNum->second[uid] = curInsNumber;
+            MEDIA_LOG_I("CreateMediaInfo: Successfully created new maxInsNumber for uid.");
+        }
+    } else {
+        mediaMaxInstanceNumberMap_[callType][uid] = curInsNumber;
+        MEDIA_LOG_I("CreateMediaInfo: Successfully created new maxInsNumber for callType and uid ");
+    }
+}
+
 int32_t AppendMediaInfo(const std::shared_ptr<Meta>& meta, uint64_t instanceId)
 {
     MEDIA_LOG_I("AppendMediaInfo.");
@@ -398,7 +432,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;
@@ -430,7 +464,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("Delete media info instanceId");
     if (!CollectReportMediaInfo(instanceId)) {
         MEDIA_LOG_I("Collect media info fail.");
         return MSERR_INVALID_OPERATION;
@@ -451,6 +485,47 @@ int32_t ReportMediaInfo(uint64_t instanceId)
     return MSERR_OK;
 }
 
+void ResetMaxInsNumberMap(CallType callType, std::map<int32_t, int32_t>& infoMap)
+{
+    MEDIA_LOG_I("ResetMaxInsNumberMap start.");
+    auto ctUidToMediaInfo = mediaInfoMap_.find(callType);
+    if (ctUidToMediaInfo == mediaInfoMap_.end()) {
+        infoMap.clear();
+        return;
+    }
+    std::vector<int32_t> keysToRemove;
+    for (auto &info : infoMap) {
+        int32_t uid = info.first;
+        auto& 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("ResetMaxInsNumberMap end.");
+}
+
+int32_t GetMediaInfoInstanceNum(CallType callType, int32_t uid)
+{
+    int32_t mediaInsNum = 0;
+    auto it1 = mediaInfoMap_.find(callType);
+    if (it1 == mediaInfoMap_.end()) {
+        const auto& uidMap = it1->second;
+        auto it2 = uidMap.find(uid);
+        if (it2 != uidMap.end()) {
+            mediaInsNum = it2->second.size();
+        }
+    }
+    MEDIA_LOG_I("MediaInfo now instances Number: %{public}" PRId32, mediaInsNum);
+    return mediaInsNum;
+}
+
 uint64_t GetMediaInfoContainInstanceNum()
 {
     uint64_t mediaInsNum = 0;