diff --git a/services/audio_service/common/include/audio_stream_checker.h b/services/audio_service/common/include/audio_stream_checker.h
index 3bdf0c24ba19ba898966e527942defb0cf4de634..da072d63223799367b351200c27314244a398cf4 100644
--- a/services/audio_service/common/include/audio_stream_checker.h
+++ b/services/audio_service/common/include/audio_stream_checker.h
@@ -48,7 +48,7 @@ public:
     void MonitorCheckFrame();
     void CleanRecordData(CheckerParam &para);
     void MonitorOnCallback(DataTransferStateChangeType type, bool isNeedCallback, CheckerParam &para);
-    void MonitorOnAllCallback(DataTransferStateChangeType type);
+    void MonitorOnAllCallback(DataTransferStateChangeType type, bool isStandby);
     int32_t GetAppUid();
     void InitChecker(DataTransferMonitorParam para, const int32_t pid, const int32_t callbackId);
     void RecordMuteFrame();
@@ -56,11 +56,13 @@ public:
     void RecordNormalFrame();
     void DeleteCheckerPara(const int32_t pid, const int32_t callbackId);
     void StopCheckStreamThread();
+    void OnRemoteAppDied(const int32_t pid);
 private:
     bool IsMonitorMuteFrame(const CheckerParam &para);
     bool IsMonitorNoDataFrame(const CheckerParam &para);
     void InitCallbackInfo(DataTransferStateChangeType type, AudioRendererDataTransferStateChangeInfo &callbackInfo);
     void CheckStreamThread();
+    void MonitorCheckFrameAction(CheckerParam &para, int64_t abnormalFrameNum, float badFrameRatio);
     std::vector<CheckerParam> checkParaVector_;
     bool monitorSwitch_ = false;
     std::recursive_mutex checkLock_;
diff --git a/services/audio_service/common/include/audio_stream_monitor.h b/services/audio_service/common/include/audio_stream_monitor.h
index f0d8d39baa2b83106d29d22b4809008f401b6b59..63e1f2fca3a4197e7ff7aee60ba8b3ca3413e32b 100644
--- a/services/audio_service/common/include/audio_stream_monitor.h
+++ b/services/audio_service/common/include/audio_stream_monitor.h
@@ -42,6 +42,7 @@ public:
     void AddCheckForMonitor(uint32_t sessionId, std::shared_ptr<AudioStreamChecker> &checker);
     void DeleteCheckForMonitor(uint32_t sessionId);
     void SetAudioServerPtr(DataTransferStateChangeCallbackForMonitor *ptr);
+    void OnCallbackAppDied(const int32_t pid);
 private:
     AudioStreamMonitor() {}
     ~AudioStreamMonitor() {}
diff --git a/services/audio_service/common/src/audio_stream_checker.cpp b/services/audio_service/common/src/audio_stream_checker.cpp
index cc352a9ea30894e398a5c077e2737645d1bbec44..36556c57abbf8af9206f0c0da49e7928ea6db192 100644
--- a/services/audio_service/common/src/audio_stream_checker.cpp
+++ b/services/audio_service/common/src/audio_stream_checker.cpp
@@ -95,6 +95,25 @@ void AudioStreamChecker::DeleteCheckerPara(const int32_t pid, const int32_t call
     AUDIO_INFO_LOG("Delete check para end, pid = %{public}d, callbackId = %{public}d", pid, callbackId);
 }
 
+void AudioStreamChecker::OnRemoteAppDied(const int32_t pid)
+{
+    std::lock_guard<std::recursive_mutex> lock(checkLock_);
+    for (auto iter = checkParaVector_.begin(); iter != checkParaVector_.end();) {
+        if (iter->pid == pid) {
+            iter = checkParaVector_.erase(iter);
+            AUDIO_INFO_LOG("Delete check para success when remote app died, pid = %{public}d", pid);
+        } else {
+            iter++;
+        }
+    }
+    if (checkParaVector_.size() == 0) {
+        isNeedCreateThread_.store(true);
+        isKeepCheck_.store(false);
+        AUDIO_INFO_LOG("Stream has no callback when remote app died, stop check thread");
+    }
+    AUDIO_INFO_LOG("Delete check para end when remote app died, pid = %{public}d", pid);
+}
+
 void AudioStreamChecker::StopCheckStreamThread()
 {
     AUDIO_INFO_LOG("Stop check stream thread");
@@ -123,6 +142,39 @@ void AudioStreamChecker::MonitorCheckFrame()
     }
 }
 
+void AudioStreamChecker::MonitorCheckFrameAction(CheckerParam &para, int64_t abnormalFrameNum,
+    float badFrameRatio)
+{
+    if (abnormalFrameNum >= static_cast<int64_t>(para.sumFrameCount * badFrameRatio)) {
+        if (para.lastStatus == DATA_TRANS_STOP) {
+            AUDIO_DEBUG_LOG("sessionId = %{public}u, status still in DATA_TRANS_STOP",
+                streamConfig_.originalSessionId);
+            MonitorOnCallback(DATA_TRANS_STOP, false, para);
+        } else if (para.lastStatus == AUDIO_STREAM_PAUSE) {
+            AUDIO_DEBUG_LOG("Last status is AUDIO_STREAM_PAUSE, no need callback");
+            CleanRecordData(para);
+        } else {
+            AUDIO_DEBUG_LOG("sessionId = %{public}u, status change in DATA_TRANS_STOP",
+                streamConfig_.originalSessionId);
+            MonitorOnCallback(DATA_TRANS_STOP, true, para);
+        }
+    } else {
+        if (para.lastStatus == DATA_TRANS_RESUME) {
+            AUDIO_DEBUG_LOG("sessionId = %{public}u, status still in DATA_TRANS_RESUME",
+                streamConfig_.originalSessionId);
+            MonitorOnCallback(DATA_TRANS_RESUME, false, para);
+        } else if (para.lastStatus == AUDIO_STREAM_START || para.lastStatus == AUDIO_STREAM_PAUSE) {
+            AUDIO_DEBUG_LOG("Last status is %{public}d, no need callback", para.lastStatus);
+            para.lastStatus = para.lastStatus == AUDIO_STREAM_START ? DATA_TRANS_RESUME : AUDIO_STREAM_PAUSE;
+            CleanRecordData(para);
+        } else {
+            AUDIO_DEBUG_LOG("sessionId = %{public}u, status change in DATA_TRANS_RESUME",
+                streamConfig_.originalSessionId);
+            MonitorOnCallback(DATA_TRANS_RESUME, true, para);
+        }
+    }
+}
+
 void AudioStreamChecker::MonitorCheckFrameSub(CheckerParam &para)
 {
     if (!para.hasInitCheck) {
@@ -148,23 +200,7 @@ void AudioStreamChecker::MonitorCheckFrameSub(CheckerParam &para)
     AUDIO_DEBUG_LOG("Check frame sum = %{public}" PRId64", abnormal = %{public}" PRId64", badRatio = %{public}f",
         para.sumFrameCount, abnormalFrameNum, badFrameRatio);
     AUDIO_DEBUG_LOG("Last check status = %{public}d", para.lastStatus);
-    if (abnormalFrameNum >= static_cast<int64_t>(para.sumFrameCount * badFrameRatio)) {
-        if (para.lastStatus == DATA_TRANS_STOP) {
-            AUDIO_DEBUG_LOG("sessionId = %{public}u, status still in DATA_TRANS_STOP", streamConfig_.originalSessionId);
-            MonitorOnCallback(DATA_TRANS_STOP, false, para);
-        } else {
-            AUDIO_DEBUG_LOG("sessionId = %{public}u, status change in DATA_TRANS_STOP", streamConfig_.originalSessionId);
-            MonitorOnCallback(DATA_TRANS_STOP, true, para);
-        }
-    } else {
-        if (para.lastStatus == DATA_TRANS_RESUME) {
-            AUDIO_DEBUG_LOG("sessionId = %{public}u, status still in DATA_TRANS_RESUME", streamConfig_.originalSessionId);
-            MonitorOnCallback(DATA_TRANS_RESUME, false, para);
-        } else {
-            AUDIO_DEBUG_LOG("sessionId = %{public}u, status change in DATA_TRANS_RESUME", streamConfig_.originalSessionId);
-            MonitorOnCallback(DATA_TRANS_RESUME, true, para);
-        }
-    }
+    MonitorCheckFrameAction(para, abnormalFrameNum, badFrameRatio);
 }
 
 void AudioStreamChecker::CleanRecordData(CheckerParam &para)
@@ -176,7 +212,7 @@ void AudioStreamChecker::CleanRecordData(CheckerParam &para)
     AUDIO_DEBUG_LOG("Clean check para end...");
 }
 
-void AudioStreamChecker::MonitorOnAllCallback(DataTransferStateChangeType type)
+void AudioStreamChecker::MonitorOnAllCallback(DataTransferStateChangeType type, bool isStandby)
 {
     std::lock_guard<std::recursive_mutex> lock(checkLock_);
     if (!monitorSwitch_) {
@@ -186,6 +222,10 @@ void AudioStreamChecker::MonitorOnAllCallback(DataTransferStateChangeType type)
     AudioRendererDataTransferStateChangeInfo callbackInfo;
     InitCallbackInfo(type, callbackInfo);
     for (int32_t index = 0; index < checkParaVector_.size(); index++) {
+        if (isStandby && type == DATA_TRANS_RESUME && !checkParaVector_[index].isMonitorNoDataFrame) {
+            AUDIO_INFO_LOG("Start during standby and no monitor nodata frame, no need callback");
+            continue;
+        }
         checkParaVector_[index].lastStatus = type;
         AUDIO_INFO_LOG("MonitorOnAllCallback type = %{public}d", type);
         checkParaVector_[index].lastUpdateTime = ClockTime::GetCurNano();
diff --git a/services/audio_service/common/src/audio_stream_monitor.cpp b/services/audio_service/common/src/audio_stream_monitor.cpp
index b29d5c5661bab4ffe766e069fd5e10874f1d0f7c..12a4f6df3be9e3494b48cf7024cd210a2c457d37 100644
--- a/services/audio_service/common/src/audio_stream_monitor.cpp
+++ b/services/audio_service/common/src/audio_stream_monitor.cpp
@@ -37,12 +37,11 @@ AudioStreamMonitor& AudioStreamMonitor::GetInstance()
 
 bool AudioStreamMonitor::HasRegistered(const int32_t pid, const int32_t callbackId)
 {
-    for (auto item : registerInfo_) {
-        if (item.first.first == pid && item.first.second == callbackId) {
-            AUDIO_INFO_LOG("Monitor has registered, pid = %{public}d, callbackId = %{public}d",
-                pid, callbackId);
-            return true;
-        }
+    auto iter = registerInfo_.find(std::make_pair(pid, callbackId));
+    if (iter != registerInfo_.end()) {
+        AUDIO_INFO_LOG("Monitor has registered, pid = %{public}d, callbackId = %{public}d",
+            pid, callbackId);
+        return true;
     }
     AUDIO_INFO_LOG("Monitor not register, pid = %{public}d, callbackId = %{public}d", pid, callbackId);
     return false;
@@ -88,6 +87,9 @@ int32_t AudioStreamMonitor::UnregisterAudioRendererDataTransferStateListener(
             iter++;
         }
     }
+    for (auto iter = audioStreamCheckers_.begin(); iter != audioStreamCheckers_.end(); iter++) {
+        iter->second->DeleteCheckerPara(pid, callbackId);
+    }
     return SUCCESS;
 }
 
@@ -126,6 +128,23 @@ void AudioStreamMonitor::AddCheckForMonitor(uint32_t sessionId, std::shared_ptr<
     }
 }
 
+void AudioStreamMonitor::OnCallbackAppDied(const int32_t pid)
+{
+    std::lock_guard<std::mutex> lock(regStatusMutex_);
+    AUDIO_INFO_LOG("On callback app died, pid = %{public}d", pid);
+    for (auto iter = registerInfo_.begin(); iter != registerInfo_.end();) {
+        if (iter->first.first == pid) {
+            AUDIO_INFO_LOG("erase registerInfo seccess by pid");
+            iter = registerInfo_.erase(iter);
+        } else {
+            iter++;
+        }
+    }
+    for (auto iter = audioStreamCheckers_.begin(); iter != audioStreamCheckers_.end(); iter++) {
+        iter->second->OnRemoteAppDied(pid);
+    }
+}
+
 void AudioStreamMonitor::DeleteCheckForMonitor(uint32_t sessionId)
 {
     std::lock_guard<std::mutex> lock(regStatusMutex_);
diff --git a/services/audio_service/server/include/renderer_in_server.h b/services/audio_service/server/include/renderer_in_server.h
index 66dfa436c7be053f98a81070aa8ab10d69d56a26..df89baec76f5b5e4fdfa7de570d290c48e1f5bc1 100644
--- a/services/audio_service/server/include/renderer_in_server.h
+++ b/services/audio_service/server/include/renderer_in_server.h
@@ -148,7 +148,7 @@ private:
     int32_t WriteDupBufferInner(const BufferDesc &bufferDesc, int32_t innerCapId);
     void ReConfigDupStreamCallback();
     void HandleOperationStopped(RendererStage stage);
-
+    int32_t StartInnerDuringStandby();
 private:
     std::mutex statusLock_;
     std::condition_variable statusCv_;
diff --git a/services/audio_service/server/src/audio_process_in_server.cpp b/services/audio_service/server/src/audio_process_in_server.cpp
index 3ae72f5c2fd5281325a3ee62a5e2e8e2d2ba591d..113458e7a5ecabc8b379d01aa301d5d76f98004f 100644
--- a/services/audio_service/server/src/audio_process_in_server.cpp
+++ b/services/audio_service/server/src/audio_process_in_server.cpp
@@ -245,7 +245,6 @@ bool AudioProcessInServer::TurnOffMicIndicator(CapturerState capturerState)
 int32_t AudioProcessInServer::Start()
 {
     int32_t ret = StartInner();
-    audioStreamChecker_->MonitorOnAllCallback(AUDIO_STREAM_START);
     if (playerDfx_ && processConfig_.audioMode == AUDIO_MODE_PLAYBACK) {
         RendererStage stage = ret == SUCCESS ? RENDERER_STAGE_START_OK : RENDERER_STAGE_START_FAIL;
         playerDfx_->WriteDfxStartMsg(sessionId_, stage, sourceDuration_, processConfig_);
@@ -293,6 +292,9 @@ int32_t AudioProcessInServer::StartInner()
         WriterRenderStreamStandbySysEvent(sessionId_, 0);
         streamStatus_->store(STREAM_STARTING);
         enterStandbyTime_ = 0;
+        audioStreamChecker_->MonitorOnAllCallback(DATA_TRANS_RESUME, true);
+    } else {
+        audioStreamChecker_->MonitorOnAllCallback(AUDIO_STREAM_START, false);
     }
 
     processBuffer_->SetLastWrittenTime(ClockTime::GetCurNano());
@@ -323,7 +325,7 @@ int32_t AudioProcessInServer::Pause(bool isFlush)
     for (size_t i = 0; i < listenerList_.size(); i++) {
         listenerList_[i]->OnPause(this);
     }
-    audioStreamChecker_->MonitorOnAllCallback(AUDIO_STREAM_PAUSE);
+    audioStreamChecker_->MonitorOnAllCallback(AUDIO_STREAM_PAUSE, false);
     if (playerDfx_ && processConfig_.audioMode == AUDIO_MODE_PLAYBACK) {
         playerDfx_->WriteDfxActionMsg(sessionId_, RENDERER_STAGE_PAUSE_OK);
     } else if (recorderDfx_ && processConfig_.audioMode == AUDIO_MODE_RECORD) {
@@ -389,7 +391,7 @@ int32_t AudioProcessInServer::Stop(AudioProcessStage stage)
     if (processBuffer_ != nullptr) {
         lastWriteFrame_ = static_cast<int64_t>(processBuffer_->GetCurReadFrame()) - lastWriteFrame_;
     }
-    audioStreamChecker_->MonitorOnAllCallback(AUDIO_STREAM_STOP);
+    audioStreamChecker_->MonitorOnAllCallback(AUDIO_STREAM_STOP, false);
     if (playerDfx_ && processConfig_.audioMode == AUDIO_MODE_PLAYBACK) {
         RendererStage rendererStage = stage == AUDIO_PROC_STAGE_STOP_BY_RELEASE ?
             RENDERER_STAGE_STOP_BY_RELEASE : RENDERER_STAGE_STOP_OK;
diff --git a/services/audio_service/server/src/audio_server.cpp b/services/audio_service/server/src/audio_server.cpp
index 64e8e15e9ca0b148127a19bd696e5ede64643474..4265efb56cba20dbc401bf3ac4c0a31da980ac3a 100644
--- a/services/audio_service/server/src/audio_server.cpp
+++ b/services/audio_service/server/src/audio_server.cpp
@@ -245,6 +245,7 @@ void ProxyDeathRecipient::OnRemoteDied(const wptr<IRemoteObject> &remote)
 {
     CHECK_AND_RETURN_LOG(audioServer_ != nullptr, "audioServer is null");
     audioServer_->RemoveRendererDataTransferCallback(pid_);
+    AudioStreamMonitor::GetInstance().OnCallbackAppDied(pid_);
 }
 
 PipeInfoGuard::PipeInfoGuard(uint32_t sessionId)
diff --git a/services/audio_service/server/src/renderer_in_server.cpp b/services/audio_service/server/src/renderer_in_server.cpp
index 9ecf3636a90d006cbe833df6296faa9aee83a030..d7ca63c30d0a39d670a8fea910935fccc22e272f 100644
--- a/services/audio_service/server/src/renderer_in_server.cpp
+++ b/services/audio_service/server/src/renderer_in_server.cpp
@@ -887,22 +887,30 @@ int32_t RendererInServer::Start()
     return ret;
 }
 
+int32_t RendererInServer::StartInnerDuringStandby()
+{
+    int32_t ret = 0;
+    AUDIO_INFO_LOG("sessionId: %{public}u call to exit stand by!", streamIndex_);
+    CHECK_AND_RETURN_RET_LOG(audioServerBuffer_->GetStreamStatus() != nullptr, ERR_OPERATION_FAILED, "null stream");
+    standByCounter_ = 0;
+    startedTime_ = ClockTime::GetCurNano();
+    audioServerBuffer_->GetStreamStatus()->store(STREAM_STARTING);
+    ret = CoreServiceHandler::GetInstance().UpdateSessionOperation(streamIndex_, SESSION_OPERATION_START);
+    CHECK_AND_RETURN_RET_LOG(ret == SUCCESS, ret, "Policy start client failed, reason: %{public}d", ret);
+    ret = (managerType_ == DIRECT_PLAYBACK || managerType_ == VOIP_PLAYBACK) ?
+        IStreamManager::GetPlaybackManager(managerType_).StartRender(streamIndex_) : stream_->Start();
+    audioStreamChecker_->MonitorOnAllCallback(DATA_TRANS_RESUME, true);
+    return ret;
+}
+
 int32_t RendererInServer::StartInner()
 {
     AUDIO_INFO_LOG("sessionId: %{public}u", streamIndex_);
-    audioStreamChecker_->MonitorOnAllCallback(AUDIO_STREAM_START);
     int32_t ret = 0;
     if (standByEnable_) {
-        AUDIO_INFO_LOG("sessionId: %{public}u call to exit stand by!", streamIndex_);
-        CHECK_AND_RETURN_RET_LOG(audioServerBuffer_->GetStreamStatus() != nullptr, ERR_OPERATION_FAILED, "null stream");
-        standByCounter_ = 0;
-        startedTime_ = ClockTime::GetCurNano();
-        audioServerBuffer_->GetStreamStatus()->store(STREAM_STARTING);
-        ret = CoreServiceHandler::GetInstance().UpdateSessionOperation(streamIndex_, SESSION_OPERATION_START);
-        CHECK_AND_RETURN_RET_LOG(ret == SUCCESS, ret, "Policy start client failed, reason: %{public}d", ret);
-        ret = (managerType_ == DIRECT_PLAYBACK || managerType_ == VOIP_PLAYBACK) ?
-            IStreamManager::GetPlaybackManager(managerType_).StartRender(streamIndex_) : stream_->Start();
-        return ret;
+        return StartInnerDuringStandby();
+    } else {
+        audioStreamChecker_->MonitorOnAllCallback(AUDIO_STREAM_START, false);
     }
     needForceWrite_ = 0;
     std::unique_lock<std::mutex> lock(statusLock_);
@@ -963,12 +971,12 @@ int32_t RendererInServer::Pause()
 {
     AUDIO_INFO_LOG("Pause.");
     std::unique_lock<std::mutex> lock(statusLock_);
-    audioStreamChecker_->MonitorOnAllCallback(AUDIO_STREAM_PAUSE);
     if (status_ != I_STATUS_STARTED) {
         AUDIO_ERR_LOG("RendererInServer::Pause failed, Illegal state: %{public}u", status_.load());
         return ERR_ILLEGAL_STATE;
     }
     status_ = I_STATUS_PAUSING;
+    bool isStandbyTmp = false;
     if (standByEnable_) {
         AUDIO_INFO_LOG("sessionId: %{public}u call Pause while stand by", streamIndex_);
         CHECK_AND_RETURN_RET_LOG(audioServerBuffer_->GetStreamStatus() != nullptr,
@@ -979,6 +987,7 @@ int32_t RendererInServer::Pause()
         if (playerDfx_) {
             playerDfx_->WriteDfxActionMsg(streamIndex_, RENDERER_STAGE_STANDBY_END);
         }
+        isStandbyTmp = true;
     }
     standByCounter_ = 0;
     GetEAC3ControlParam();
@@ -1007,6 +1016,8 @@ int32_t RendererInServer::Pause()
     }
     CHECK_AND_RETURN_RET_LOG(ret == SUCCESS, ret, "Pause stream failed, reason: %{public}d", ret);
     CoreServiceHandler::GetInstance().UpdateSessionOperation(streamIndex_, SESSION_OPERATION_PAUSE);
+    DataTransferStateChangeType type = isStandbyTmp ? DATA_TRANS_STOP : AUDIO_STREAM_PAUSE;
+    audioStreamChecker_->MonitorOnAllCallback(type, isStandbyTmp);
     StreamDfxManager::GetInstance().CheckStreamOccupancy(streamIndex_, processConfig_, false);
     return SUCCESS;
 }
@@ -1111,7 +1122,6 @@ int32_t RendererInServer::Stop()
     AUDIO_INFO_LOG("Stop.");
     {
         std::unique_lock<std::mutex> lock(statusLock_);
-        audioStreamChecker_->MonitorOnAllCallback(AUDIO_STREAM_STOP);
         if (status_ != I_STATUS_STARTED && status_ != I_STATUS_PAUSED && status_ != I_STATUS_DRAINING &&
             status_ != I_STATUS_STARTING) {
             AUDIO_ERR_LOG("RendererInServer::Stop failed, Illegal state: %{public}u", status_.load());
@@ -1165,6 +1175,7 @@ int32_t RendererInServer::StopInner()
     }
     CHECK_AND_RETURN_RET_LOG(ret == SUCCESS, ret, "Stop stream failed, reason: %{public}d", ret);
     CoreServiceHandler::GetInstance().UpdateSessionOperation(streamIndex_, SESSION_OPERATION_STOP);
+    audioStreamChecker_->MonitorOnAllCallback(AUDIO_STREAM_STOP, false);
     StreamDfxManager::GetInstance().CheckStreamOccupancy(streamIndex_, processConfig_, false);
     return SUCCESS;
 }
diff --git a/services/audio_service/test/unittest/audio_stream_checker_unit_test.cpp b/services/audio_service/test/unittest/audio_stream_checker_unit_test.cpp
index a29fd11af841e9d1cc27c730fdf20866c7a553c7..4c734976ae9f35c54f67ebe0cf70eb8755bb096c 100644
--- a/services/audio_service/test/unittest/audio_stream_checker_unit_test.cpp
+++ b/services/audio_service/test/unittest/audio_stream_checker_unit_test.cpp
@@ -113,7 +113,7 @@ HWTEST(AudioStreamCheckerTest, DeleteCheckerPara_001, TestSize.Level1)
     std::shared_ptr<AudioStreamChecker> checker = std::make_shared<AudioStreamChecker>(cfg);
     checker->InitChecker(para, 100000, 100000);
     checker->DeleteCheckerPara(100000, 100000);
-    int32_t size = checkParaVector_.size();
+    int32_t size = checker->checkParaVector_.size();
     EXPECT_EQ(size, 0);
 }
 
@@ -134,9 +134,8 @@ HWTEST(AudioStreamCheckerTest, MonitorCheckFrame_001, TestSize.Level1)
     checker->RecordMuteFrame();
     checker->RecordNormalFrame();
     checker->MonitorCheckFrame();
-    checker->MonitorCheckFrame();
-    int32_t num = checker->checkParaVector_[0].sumFrameCount;
-    EXPECT_GT(num, 0);
+    DataTransferStateChangeType status = checker->checkParaVector_[0].lastStatus;
+    EXPECT_EQ(status, DATA_TRANS_STOP);
 }
 
 /**
@@ -153,10 +152,12 @@ HWTEST(AudioStreamCheckerTest, MonitorCheckFrame_002, TestSize.Level1)
     para.badFramesRatio = 50;
     std::shared_ptr<AudioStreamChecker> checker = std::make_shared<AudioStreamChecker>(cfg);
     checker->InitChecker(para, 100000, 100000);
-    checker->RecordNormalFrame();
+    for (int i = 0; i < 4; i++) {
+        checker->RecordNormalFrame();
+    }
     checker->MonitorCheckFrame();
-    int32_t num = checker->checkParaVector_[0].sumFrameCount;
-    EXPECT_GT(num, 0);
+    DataTransferStateChangeType status = checker->checkParaVector_[0].lastStatus;
+    EXPECT_EQ(status, DATA_TRANS_RESUME);
 }
 
 /**
@@ -180,8 +181,8 @@ HWTEST(AudioStreamCheckerTest, MonitorCheckFrame_003, TestSize.Level1)
         checker->RecordNormalFrame();
     }
     checker->MonitorCheckFrame();
-    int32_t num = checker->checkParaVector_[0].sumFrameCount;
-    EXPECT_GT(num, 0);
+    DataTransferStateChangeType status = checker->checkParaVector_[0].lastStatus;
+    EXPECT_EQ(status, DATA_TRANS_RESUME);
 }
 
 /**
@@ -198,10 +199,48 @@ HWTEST(AudioStreamCheckerTest, MonitorOnAllCallback_001, TestSize.Level1)
     para.badFramesRatio = 50;
     std::shared_ptr<AudioStreamChecker> checker = std::make_shared<AudioStreamChecker>(cfg);
     checker->InitChecker(para, 100000, 100000);
-    checker->MonitorOnAllCallback(AUDIO_STREAM_START);
+    checker->MonitorOnAllCallback(AUDIO_STREAM_START, false);
+    int32_t size = checker->checkParaVector_.size();
+    EXPECT_GT(size, 0);
+}
+
+/**
+ * @tc.name  : Test MonitorOnAllCallback API
+ * @tc.type  : FUNC
+ * @tc.number: MonitorOnAllCallback_002
+ */
+HWTEST(AudioStreamCheckerTest, MonitorOnAllCallback_002, TestSize.Level1)
+{
+    AudioProcessConfig cfg;
+    DataTransferMonitorParam para;
+    para.badDataTransferTypeBitMap = 2;
+    para.timeInterval = 2000000000;
+    para.badFramesRatio = 50;
+    std::shared_ptr<AudioStreamChecker> checker = std::make_shared<AudioStreamChecker>(cfg);
+    checker->InitChecker(para, 100000, 100000);
+    checker->MonitorOnAllCallback(DATA_TRANS_RESUME, true);
     int32_t size = checker->checkParaVector_.size();
     EXPECT_GT(size, 0);
 }
 
+/**
+ * @tc.name  : Test OnRemoteAppDied API
+ * @tc.type  : FUNC
+ * @tc.number: OnRemoteAppDied_001
+ */
+HWTEST(AudioStreamCheckerTest, OnRemoteAppDied_001, TestSize.Level1)
+{
+    AudioProcessConfig cfg;
+    DataTransferMonitorParam para;
+    para.badDataTransferTypeBitMap = 3;
+    para.timeInterval = 2000000000;
+    para.badFramesRatio = 50;
+    std::shared_ptr<AudioStreamChecker> checker = std::make_shared<AudioStreamChecker>(cfg);
+    checker->InitChecker(para, 100000, 100000);
+    checker->OnRemoteAppDied(100000);
+    int size = checker->checkParaVector_.size();
+    EXPECT_EQ(size, 0);
+}
+
 }
 }
\ No newline at end of file
diff --git a/services/audio_service/test/unittest/audio_stream_monitor_unit_test.cpp b/services/audio_service/test/unittest/audio_stream_monitor_unit_test.cpp
index f326f2cff6d4703584a7be95787dbde3f1420807..132b1f0bca4b4afd20582530eaf6f373502e4d1a 100644
--- a/services/audio_service/test/unittest/audio_stream_monitor_unit_test.cpp
+++ b/services/audio_service/test/unittest/audio_stream_monitor_unit_test.cpp
@@ -115,8 +115,29 @@ HWTEST(AudioStreamMonitorTest, AddCheckForMonitor_001, TestSize.Level1)
 HWTEST(AudioStreamMonitorTest, DeleteCheckForMonitor_001, TestSize.Level1)
 {
     AudioStreamMonitor::GetInstance().DeleteCheckForMonitor(100001);
-    int32_t size = audioStreamCheckers_.size();
+    int32_t size = AudioStreamMonitor::GetInstance().audioStreamCheckers_.size();
     EXPECT_EQ(size, 0);
 }
+
+/**
+ * @tc.name  : Test OnCallbackAppDied API
+ * @tc.type  : FUNC
+ * @tc.number: OnCallbackAppDied_001
+ */
+HWTEST(AudioStreamMonitorTest, OnCallbackAppDied_001, TestSize.Level1)
+{
+    DataTransferMonitorParam para;
+    para.clientUID = 20002000;
+    AudioStreamMonitor::GetInstance().RegisterAudioRendererDataTransferStateListener(para, 10000, 10000);
+    AudioProcessConfig cfg;
+    cfg.originalSessionId = 100001;
+    cfg.appInfo.appUid = 20002000;
+    std::shared_ptr<AudioStreamChecker> checker = std::make_shared<AudioStreamChecker>(cfg);
+    AudioStreamMonitor::GetInstance().AddCheckForMonitor(cfg.originalSessionId, checker);
+    AudioStreamMonitor::GetInstance().OnCallbackAppDied(10000);
+    int size = AudioStreamMonitor::GetInstance().registerInfo_.size();
+    EXPECT_EQ(size, 0);
+}
+
 }
 }
\ No newline at end of file