diff --git a/services/audio_policy/server/domain/interrupt/include/audio_interrupt_service.h b/services/audio_policy/server/domain/interrupt/include/audio_interrupt_service.h
index 204a1deddec6dfd0c3f1704576b7cb0e639194cb..4dc1d87da87337a1953c95653bb4daea25dc794a 100644
--- a/services/audio_policy/server/domain/interrupt/include/audio_interrupt_service.h
+++ b/services/audio_policy/server/domain/interrupt/include/audio_interrupt_service.h
@@ -66,7 +66,6 @@ public:
     // interfaces for AudioSessionService
     int32_t ActivateAudioSession(const int32_t zoneId, const int32_t callerPid,
         const AudioSessionStrategy &strategy, const bool isStandalone = false);
-    bool IsSessionNeedToFetchOutputDevice(const int32_t callerPid);
     int32_t DeactivateAudioSession(const int32_t zoneId, const int32_t callerPid);
     bool IsAudioSessionActivated(const int32_t callerPid);
 
@@ -111,7 +110,6 @@ public:
     void ClearAudioFocusInfoListOnAccountsChanged(const int32_t &id);
     int32_t ClearAudioFocusInfoList();
     void AudioInterruptZoneDump(std::string &dumpString);
-    void AudioSessionInfoDump(std::string &dumpString);
     AudioScene GetHighestPriorityAudioScene(const int32_t zoneId) const;
     // for audiosessionv2
     int32_t SetAudioSessionScene(int32_t callerPid, AudioSessionScene scene);
@@ -290,8 +288,6 @@ private:
         &audioFocusInfoList);
 
     AudioStreamType GetStreamInFocusInternal(const int32_t uid, const int32_t zoneId);
-    
-    bool CheckAudioSessionExistence(const AudioInterrupt &incomingInterrupt, AudioFocusEntry &focusEntry);
 
     bool SwitchHintType(std::list<std::pair<AudioInterrupt, AudioFocuState>>::iterator &iterActive,
         InterruptEventInternal &interruptEvent, std::list<std::pair<AudioInterrupt, AudioFocuState>> &tmpFocusInfoList);
@@ -315,7 +311,8 @@ private:
     // for audiosessionv2
     int32_t ProcessFocusEntryForAudioSession(const int32_t zoneId, const int32_t callerPid, bool &updateScene);
     bool ShouldBypassAudioSessionFocus(const int32_t zoneId, const AudioInterrupt &incomingInterrupt);
-    void DeactivateAudioSessionFakeInterrupt(
+    void DeactivateAudioSessionFakeInterrupt(const int32_t zoneId, const int32_t callerPid);
+    void DeactivateAudioSessionFakeInterruptInternal(
         const int32_t zoneId, const int32_t callerPid, bool isSessionTimeout = false);
     void DispatchInterruptEventForAudioSession(
         InterruptEventInternal &interruptEvent, const AudioInterrupt &audioInterrupt) override;
@@ -325,11 +322,13 @@ private:
     void TryHandleStreamCallbackInSession(const int32_t zoneId, const AudioInterrupt &incomingInterrupt);
     bool HasAudioSessionFakeInterrupt(const int32_t zoneId, const int32_t callerPid);
     int32_t HandleExistStreamsForSession(const int32_t zoneId, const int32_t callerPid, bool &updateScene);
+    void ReactivateAudioInterrupts(const int32_t zoneId, const int32_t callerPid, bool &updateScene);
     AudioScene GetHighestPriorityAudioSceneFromAudioSession(
         const AudioInterrupt &audioInterrupt, const AudioScene &audioScene) const;
     void DelayToDeactivateStreamsInAudioSession(
         const int32_t zoneId, const int32_t callerPid, const std::vector<AudioInterrupt> &streamsInSession);
-
+    int32_t DeactivateStreamsInAudioSession(
+        const int32_t zoneId, const int32_t callerPid, const std::vector<AudioInterrupt> &streamsInSession);
     int32_t ProcessActiveStreamFocus(std::list<std::pair<AudioInterrupt, AudioFocuState>> &audioFocusInfoList,
         const AudioInterrupt &incomingInterrupt, AudioFocuState &incomingState,
         std::list<std::pair<AudioInterrupt, AudioFocuState>>::iterator &activeInterrupt);
@@ -339,7 +338,7 @@ private:
     // interrupt members
     sptr<AudioPolicyServer> policyServer_;
     std::shared_ptr<AudioPolicyServerHandler> handler_;
-    std::shared_ptr<AudioSessionService> sessionService_;
+    AudioSessionService &sessionService_;
     friend class AudioInterruptZoneManager;
     AudioInterruptZoneManager zoneManager_;
 
diff --git a/services/audio_policy/server/domain/interrupt/src/audio_interrupt_service.cpp b/services/audio_policy/server/domain/interrupt/src/audio_interrupt_service.cpp
index 65ce2b12045558989b762f3bb03c88357c12b4fd..10e366ca7991cf6b1c6526ed801cd735edb0b23d 100644
--- a/services/audio_policy/server/domain/interrupt/src/audio_interrupt_service.cpp
+++ b/services/audio_policy/server/domain/interrupt/src/audio_interrupt_service.cpp
@@ -113,6 +113,7 @@ inline int32_t GetAudioScenePriority(const AudioScene audioScene)
 }
 
 AudioInterruptService::AudioInterruptService()
+    : sessionService_(OHOS::Singleton<AudioSessionService>::GetInstance())
 {
     zoneManager_.InitService(this);
 }
@@ -143,8 +144,7 @@ void AudioInterruptService::Init(sptr<AudioPolicyServer> server)
 
     zoneManager_.CreateAudioInterruptZone(ZONEID_DEFAULT, context, false);
 
-    sessionService_ = AudioSessionService::GetAudioSessionService();
-    sessionService_->SetSessionTimeOutCallback(shared_from_this());
+    sessionService_.SetSessionTimeOutCallback(shared_from_this());
     dfxCollector_ = std::make_unique<AudioInterruptDfxCollector>();
 }
 
@@ -196,9 +196,9 @@ int32_t AudioInterruptService::GetAudioSessionZoneidByPid(const int32_t pid)
 void AudioInterruptService::HandleSessionTimeOutEvent(const int32_t pid)
 {
     int32_t zoneId = GetAudioSessionZoneidByPid(pid);
-    if (sessionService_ != nullptr && zoneId != ZONEID_INVALID) {
+    if (zoneId != ZONEID_INVALID) {
         // If there is a fake interrupt, it needs to be deactivated.
-        DeactivateAudioSessionFakeInterrupt(zoneId, pid, true);
+        DeactivateAudioSessionFakeInterruptInternal(zoneId, pid, true);
         if (handler_ != nullptr) {
             // duckVolume = -1.0f, means timeout stop
             InterruptEventInternal interruptEvent {INTERRUPT_TYPE_BEGIN, INTERRUPT_FORCE, INTERRUPT_HINT_STOP, -1.0f};
@@ -228,12 +228,8 @@ int32_t AudioInterruptService::ActivateAudioSession(const int32_t zoneId, const
             AUDIO_ERR_LOG("ActivateAudioSession timeout");
         }, nullptr, AUDIO_XCOLLIE_FLAG_LOG | AUDIO_XCOLLIE_FLAG_RECOVERY);
     std::unique_lock<std::mutex> lock(mutex_);
-    if (sessionService_ == nullptr) {
-        AUDIO_ERR_LOG("sessionService_ is nullptr!");
-        return ERR_UNKNOWN;
-    }
-    bool isActivated = sessionService_->IsAudioSessionActivated(callerPid);
-    int32_t result = sessionService_->ActivateAudioSession(callerPid, strategy);
+    bool isActivated = sessionService_.IsAudioSessionActivated(callerPid);
+    int32_t result = sessionService_.ActivateAudioSession(callerPid, strategy);
     if (result != SUCCESS) {
         AUDIO_ERR_LOG("Failed to activate audio session for pid %{public}d!", callerPid);
         return result;
@@ -243,15 +239,22 @@ int32_t AudioInterruptService::ActivateAudioSession(const int32_t zoneId, const
         AddActiveInterruptToSession(callerPid);
     }
 
-    if (sessionService_->IsAudioSessionFocusMode(callerPid)) {
-        AUDIO_INFO_LOG("Enter audio session focus mode, pid = %{public}d", callerPid);
+    if (PermissionUtil::VerifySystemPermission()) {
+        sessionService_.MarkSystemApp(callerPid);
+    }
+
+    bool updateScene = false;
+    // audio sesssion v2
+    if (sessionService_.IsAudioSessionFocusMode(callerPid)) {
+        AUDIO_INFO_LOG("Enter audio session v2 focus mode, pid = %{public}d, strategy = %{public}d",
+            callerPid, static_cast<int32_t>(strategy.concurrencyMode));
         if (isStandalone) {
             AUDIO_INFO_LOG("Current audio session focus mode is Standalone and return");
             return SUCCESS;
         }
-        bool updateScene = false;
+
         result = ProcessFocusEntryForAudioSession(zoneId, callerPid, updateScene);
-        if (result != SUCCESS || !updateScene) {
+        if (result != SUCCESS) {
             AUDIO_INFO_LOG(
                 "Process focus for AudioSession, pid: %{public}d, result: %{public}d, updateScene: %{public}d",
                 callerPid,
@@ -259,51 +262,38 @@ int32_t AudioInterruptService::ActivateAudioSession(const int32_t zoneId, const
                 updateScene);
             return result;
         }
+    // audio session v1
+    } else {
+        if (sessionService_.IsSystemApp(callerPid)) {
+            AUDIO_INFO_LOG("Enter audio session v1 mode, pid = %{public}d, strategy = %{public}d",
+                callerPid, static_cast<int32_t>(strategy.concurrencyMode));
+            ReactivateAudioInterrupts(zoneId, callerPid, updateScene);
+        }
+    }
 
+    if (updateScene) {
         AudioScene targetAudioScene = GetHighestPriorityAudioScene(ZONEID_DEFAULT);
         // If there is an event of (interrupt + set scene), ActivateAudioInterrupt and DeactivateAudioInterrupt may
         // experience deadlocks, due to mutex_ and deviceStatusUpdateSharedMutex_ waiting for each other
         lock.unlock();
         UpdateAudioSceneFromInterrupt(targetAudioScene, ACTIVATE_AUDIO_INTERRUPT);
-        return SUCCESS;
     }
 
     return SUCCESS;
 }
 
-bool AudioInterruptService::IsSessionNeedToFetchOutputDevice(const int32_t callerPid)
-{
-    std::lock_guard<std::mutex> lock(mutex_);
-    if (sessionService_ == nullptr) {
-        AUDIO_ERR_LOG("sessionService_ is nullptr!");
-        return false;
-    }
-
-    return sessionService_->IsSessionNeedToFetchOutputDevice(callerPid);
-}
-
 int32_t AudioInterruptService::SetAudioSessionScene(int32_t callerPid, AudioSessionScene scene)
 {
     std::unique_lock<std::mutex> lock(mutex_);
-    if (sessionService_ == nullptr) {
-        AUDIO_ERR_LOG("sessionService_ is nullptr!");
-        return ERR_UNKNOWN;
-    }
-
-    return sessionService_->SetAudioSessionScene(callerPid, scene);
+    return sessionService_.SetAudioSessionScene(callerPid, scene);
 }
 
 void AudioInterruptService::AddActiveInterruptToSession(const int32_t callerPid)
 {
-    if (sessionService_ == nullptr) {
-        AUDIO_ERR_LOG("sessionService_ is nullptr!");
-        return;
-    }
-    if (!sessionService_->IsAudioSessionActivated(callerPid)) {
+    if (!sessionService_.IsAudioSessionActivated(callerPid)) {
         AUDIO_ERR_LOG("The audio session for pid %{public}d is not active!", callerPid);
         return;
     }
-    auto audioSession = sessionService_->GetAudioSessionByPid(callerPid);
 
     int32_t zoneId = zoneManager_.FindZoneByPid(callerPid);
     auto itZone = zonesMap_.find(zoneId);
@@ -313,8 +303,8 @@ void AudioInterruptService::AddActiveInterruptToSession(const int32_t callerPid)
         audioFocusInfoList = itZone->second->audioFocusInfoList;
     }
     for (auto iterActive = audioFocusInfoList.begin(); iterActive != audioFocusInfoList.end(); ++iterActive) {
-        if ((iterActive->first).pid == callerPid && audioSession != nullptr) {
-            audioSession->AddStreamInfo(iterActive->first);
+        if ((iterActive->first).pid == callerPid) {
+            sessionService_.AddStreamInfo(iterActive->first);
         }
     }
 }
@@ -326,24 +316,20 @@ int32_t AudioInterruptService::DeactivateAudioSession(const int32_t zoneId, cons
             AUDIO_ERR_LOG("DeactivateAudioSession timeout");
         }, nullptr, AUDIO_XCOLLIE_FLAG_LOG | AUDIO_XCOLLIE_FLAG_RECOVERY);
     std::unique_lock<std::mutex> lock(mutex_);
-    if (sessionService_ == nullptr) {
-        AUDIO_ERR_LOG("sessionService_ is nullptr!");
-        return ERR_UNKNOWN;
-    }
 
     // audio session v2
     if (HasAudioSessionFakeInterrupt(zoneId, callerPid)) {
-        std::vector<AudioInterrupt> streamsInSession = sessionService_->GetStreams(callerPid);
+        std::vector<AudioInterrupt> streamsInSession = sessionService_.GetStreams(callerPid);
         if (streamsInSession.size() > 0) {
             // Wait for the streams managed by session to stop
             DelayToDeactivateStreamsInAudioSession(zoneId, callerPid, streamsInSession);
         } else {
             // If there is a fake interrupt, it needs to be deactivated.
-            DeactivateAudioSessionFakeInterrupt(zoneId, callerPid);
+            DeactivateAudioSessionFakeInterruptInternal(zoneId, callerPid);
         }
     }
 
-    int32_t result = sessionService_->DeactivateAudioSession(callerPid);
+    int32_t result = sessionService_.DeactivateAudioSession(callerPid);
     if (result != SUCCESS) {
         AUDIO_INFO_LOG("Failed to deactivate audio session for pid %{public}d, result %{public}d", callerPid, result);
         return result;
@@ -357,55 +343,58 @@ int32_t AudioInterruptService::DeactivateAudioSession(const int32_t zoneId, cons
 void AudioInterruptService::DelayToDeactivateStreamsInAudioSession(
     const int32_t zoneId, const int32_t callerPid, const std::vector<AudioInterrupt> &streamsInSession)
 {
-    auto deactivateTask = [this, zoneId, callerPid, streamsInSession] {
-        std::this_thread::sleep_for(std::chrono::seconds(1));
-        std::unique_lock<std::mutex> lock(mutex_);
-        if (sessionService_ == nullptr) {
-            AUDIO_ERR_LOG("sessionService_ is nullptr!");
+    auto audioInterruptService = shared_from_this();
+    auto deactivateTask = [audioInterruptService, zoneId, callerPid, streamsInSession] {
+        if (audioInterruptService == nullptr) {
             return;
         }
-
-        // If the audio session is reactivated, there is no need to clean up the session resources.
-        if (sessionService_->IsAudioSessionActivated(callerPid)) {
-            AUDIO_ERR_LOG("Session is reactivated, no need to deactivate interrupt, pid %{public}d", callerPid);
+        std::this_thread::sleep_for(std::chrono::seconds(1));
+        int32_t ret = audioInterruptService->DeactivateStreamsInAudioSession(zoneId, callerPid, streamsInSession);
+        if (ret != SUCCESS) {
+            AUDIO_ERR_LOG("Deactivate streams in audio session failed, pid %{public}d", callerPid);
             return;
         }
-
-        // If the application deactivates a session, the streams managed by session needs to be stoped.
-        if (handler_ != nullptr) {
-            AUDIO_INFO_LOG("Send InterruptCallbackEvent to all streams for pid %{public}d", callerPid);
-            InterruptEventInternal interruptEvent {INTERRUPT_TYPE_BEGIN, INTERRUPT_FORCE, INTERRUPT_HINT_STOP, 1.0f};
-            for (auto &it : streamsInSession) {
-                handler_->SendInterruptEventWithStreamIdCallback(interruptEvent, it.streamId);
-            }
-        }
-
-        lock.unlock();
-
         // Sleep for 50 milliseconds to allow streams in the session to stop.
         std::this_thread::sleep_for(std::chrono::milliseconds(50));
         // Before deactivating the fake interrupt, all stream interrupts within the session must be stopped.
-        lock.lock();
-        DeactivateAudioSessionFakeInterrupt(zoneId, callerPid);
+        audioInterruptService->DeactivateAudioSessionFakeInterrupt(zoneId, callerPid);
     };
 
     std::thread(deactivateTask).detach();
     AUDIO_INFO_LOG("Started deactivation thread for pid %{public}d with 1s delay", callerPid);
 }
 
-// Deactivate session when fake focus is stopped.
-void AudioInterruptService::DeactivateAudioSessionInFakeFocusMode(const int32_t pid, InterruptHint hintType)
+int32_t AudioInterruptService::DeactivateStreamsInAudioSession(
+    const int32_t zoneId, const int32_t callerPid, const std::vector<AudioInterrupt> &streamsInSession)
 {
-    if (sessionService_ == nullptr) {
-        AUDIO_ERR_LOG("sessionService_ is nullptr!");
-        return;
+    std::lock_guard<std::mutex> lock(mutex_);
+
+    // If the audio session is reactivated, there is no need to clean up the session resources.
+    if (sessionService_.IsAudioSessionActivated(callerPid)) {
+        AUDIO_ERR_LOG("Session is reactivated, no need to deactivate interrupt, pid %{public}d", callerPid);
+        return ERROR;
     }
 
+    // If the application deactivates a session, the streams managed by session needs to be stoped.
+    if (handler_ != nullptr) {
+        AUDIO_INFO_LOG("Send InterruptCallbackEvent to all streams for pid %{public}d", callerPid);
+        InterruptEventInternal interruptEvent {INTERRUPT_TYPE_BEGIN, INTERRUPT_FORCE, INTERRUPT_HINT_STOP, 1.0f};
+        for (auto &it : streamsInSession) {
+            handler_->SendInterruptEventWithStreamIdCallback(interruptEvent, it.streamId);
+        }
+    }
+
+    return SUCCESS;
+}
+
+// Deactivate session when fake focus is stopped.
+void AudioInterruptService::DeactivateAudioSessionInFakeFocusMode(const int32_t pid, InterruptHint hintType)
+{
     /*
     Both stop and resume will delete the fake focus, so, need to deactivate audio session,
     but only stop needs to trigger a callback to the streams managed by audio session.
     */
-    std::vector<AudioInterrupt> streamsInSession = sessionService_->GetStreams(pid);
+    std::vector<AudioInterrupt> streamsInSession = sessionService_.GetStreams(pid);
     if (handler_ != nullptr && hintType == INTERRUPT_HINT_STOP) {
         AUDIO_INFO_LOG("Send InterruptCallbackEvent to all streams for pid %{public}d", pid);
         InterruptEventInternal interruptEvent {INTERRUPT_TYPE_BEGIN, INTERRUPT_FORCE, INTERRUPT_HINT_STOP, 1.0f};
@@ -414,7 +403,7 @@ void AudioInterruptService::DeactivateAudioSessionInFakeFocusMode(const int32_t
         }
     }
 
-    int32_t result = sessionService_->DeactivateAudioSession(pid);
+    int32_t result = sessionService_.DeactivateAudioSession(pid);
     if (result != SUCCESS) {
         AUDIO_INFO_LOG("Failed to deactivate audio session for pid %{public}d, result %{public}d", pid, result);
         return;
@@ -431,7 +420,7 @@ void AudioInterruptService::DeactivateAudioSessionInFakeFocusMode(const int32_t
     }
 }
 
-void AudioInterruptService::DeactivateAudioSessionFakeInterrupt(
+void AudioInterruptService::DeactivateAudioSessionFakeInterruptInternal(
     const int32_t zoneId, const int32_t callerPid, bool isSessionTimeout)
 {
     auto itZone = zonesMap_.find(zoneId);
@@ -450,6 +439,12 @@ void AudioInterruptService::DeactivateAudioSessionFakeInterrupt(
     DeactivateAudioInterruptInternal(zoneId, iter->first, isSessionTimeout);
 }
 
+void AudioInterruptService::DeactivateAudioSessionFakeInterrupt(const int32_t zoneId, const int32_t callerPid)
+{
+    std::lock_guard<std::mutex> lock(mutex_);
+    DeactivateAudioSessionFakeInterruptInternal(zoneId, callerPid, false);
+}
+
 bool AudioInterruptService::HasAudioSessionFakeInterrupt(const int32_t zoneId, const int32_t callerPid)
 {
     auto itZone = zonesMap_.find(zoneId);
@@ -465,11 +460,7 @@ bool AudioInterruptService::HasAudioSessionFakeInterrupt(const int32_t zoneId, c
 
 void AudioInterruptService::RemovePlaceholderInterruptForSession(const int32_t callerPid, bool isSessionTimeout)
 {
-    if (sessionService_ == nullptr) {
-        AUDIO_ERR_LOG("sessionService_ is nullptr!");
-        return;
-    }
-    if (sessionService_->IsAudioSessionActivated(callerPid)) {
+    if (sessionService_.IsAudioSessionActivated(callerPid)) {
         AUDIO_ERR_LOG("The audio session for pid %{public}d is still active!", callerPid);
         return;
     }
@@ -495,16 +486,19 @@ void AudioInterruptService::RemovePlaceholderInterruptForSession(const int32_t c
 bool AudioInterruptService::IsAudioSessionActivated(const int32_t callerPid)
 {
     std::lock_guard<std::mutex> lock(mutex_);
-    if (sessionService_ == nullptr) {
-        AUDIO_ERR_LOG("sessionService_ is nullptr!");
-        return false;
-    }
-    return sessionService_->IsAudioSessionActivated(callerPid);
+    return sessionService_.IsAudioSessionActivated(callerPid);
 }
 
 bool AudioInterruptService::IsCanMixInterrupt(const AudioInterrupt &incomingInterrupt,
     const AudioInterrupt &activeInterrupt)
 {
+    if (sessionService_.IsSystemAppWithMixStrategy(incomingInterrupt.pid) ||
+        sessionService_.IsSystemAppWithMixStrategy(activeInterrupt.pid)) {
+        AUDIO_INFO_LOG("System app can mix with others anyway, incomingPid: %{public}d, activePid: %{public}d",
+            incomingInterrupt.pid, activeInterrupt.pid);
+        return true;
+    }
+
     if (incomingInterrupt.audioFocusType.sourceType != SOURCE_TYPE_INVALID &&
         (activeInterrupt.audioFocusType.streamType == STREAM_VOICE_CALL ||
         activeInterrupt.audioFocusType.streamType == STREAM_VOICE_COMMUNICATION)) {
@@ -528,7 +522,15 @@ bool AudioInterruptService::IsCanMixInterrupt(const AudioInterrupt &incomingInte
 bool AudioInterruptService::CanMixForSession(const AudioInterrupt &incomingInterrupt,
     const AudioInterrupt &activeInterrupt, const AudioFocusEntry &focusEntry)
 {
-    if (focusEntry.isReject && incomingInterrupt.audioFocusType.sourceType != SOURCE_TYPE_INVALID) {
+    if (sessionService_.IsSystemAppWithMixStrategy(incomingInterrupt.pid) ||
+        sessionService_.IsSystemAppWithMixStrategy(activeInterrupt.pid)) {
+        AUDIO_INFO_LOG("System app can mix with others anyway, incomingPid: %{public}d, activePid: %{public}d",
+            incomingInterrupt.pid, activeInterrupt.pid);
+        return true;
+    }
+
+    if (focusEntry.isReject &&
+        incomingInterrupt.audioFocusType.sourceType != SOURCE_TYPE_INVALID) {
         // The incoming stream is a capturer and the default policy is deny incoming.
         AUDIO_INFO_LOG("The incoming audio capturer should be denied!");
         return false;
@@ -565,19 +567,15 @@ bool AudioInterruptService::CanMixForSession(const AudioInterrupt &incomingInter
 bool AudioInterruptService::CanMixForIncomingSession(const AudioInterrupt &incomingInterrupt,
     const AudioInterrupt &activeInterrupt, const AudioFocusEntry &focusEntry)
 {
-    if (sessionService_ != nullptr && sessionService_->IsAudioSessionActivated(incomingInterrupt.pid)) {
+    if (sessionService_.IsAudioSessionActivated(incomingInterrupt.pid)) {
         // The strategy of activated AudioSession is the one with the highest priority.
-        std::shared_ptr<AudioSession> incomingSession = sessionService_->GetAudioSessionByPid(incomingInterrupt.pid);
-        if (incomingSession == nullptr) {
-            AUDIO_ERR_LOG("incomingSession is nullptr!");
-            return false;
-        }
-        AudioConcurrencyMode concurrencyMode = (incomingSession->GetSessionStrategy()).concurrencyMode;
+        AudioConcurrencyMode concurrencyMode = sessionService_.GetSessionStrategy(incomingInterrupt.pid);
         if (concurrencyMode != AudioConcurrencyMode::MIX_WITH_OTHERS) {
             AUDIO_INFO_LOG("The concurrency mode of incoming session is %{public}d",
                 static_cast<int32_t>(concurrencyMode));
             return false;
         }
+
         // The concurrencyMode of incoming session is MIX_WITH_OTHERS. Need to check the priority.
         if (IsIncomingStreamLowPriority(focusEntry)) {
             bool isSameType = AudioSessionService::IsSameTypeForAudioSession(
@@ -603,19 +601,15 @@ bool AudioInterruptService::CanMixForIncomingSession(const AudioInterrupt &incom
 bool AudioInterruptService::CanMixForActiveSession(const AudioInterrupt &incomingInterrupt,
     const AudioInterrupt &activeInterrupt, const AudioFocusEntry &focusEntry)
 {
-    if (sessionService_ != nullptr && sessionService_->IsAudioSessionActivated(activeInterrupt.pid)) {
+    if (sessionService_.IsAudioSessionActivated(activeInterrupt.pid)) {
         // The strategy of activated AudioSession is the one with the highest priority.
-        std::shared_ptr<AudioSession> activeSession = sessionService_->GetAudioSessionByPid(activeInterrupt.pid);
-        if (activeSession == nullptr) {
-            AUDIO_ERR_LOG("activeSession is nullptr!");
-            return false;
-        }
-        AudioConcurrencyMode concurrencyMode = (activeSession->GetSessionStrategy()).concurrencyMode;
+        AudioConcurrencyMode concurrencyMode = sessionService_.GetSessionStrategy(activeInterrupt.pid);
         if (concurrencyMode != AudioConcurrencyMode::MIX_WITH_OTHERS) {
             AUDIO_INFO_LOG("The concurrency mode of active session is %{public}d",
                 static_cast<int32_t>(concurrencyMode));
             return false;
         }
+
         // The concurrencyMode of active session is MIX_WITH_OTHERS. Need to check the priority.
         if (IsActiveStreamLowPriority(focusEntry)) {
             bool isSameType = AudioSessionService::IsSameTypeForAudioSession(
@@ -863,12 +857,6 @@ bool AudioInterruptService::AudioInterruptIsActiveInFocusList(const int32_t zone
 void AudioInterruptService::HandleAppStreamType(const int32_t zoneId, AudioInterrupt &audioInterrupt)
 {
     // In audio session mode, the focus policy is uniformly managed by the session and not handled separately here.
-    if (sessionService_ != nullptr && sessionService_->IsAudioSessionFocusMode(audioInterrupt.pid)) {
-        AUDIO_DEBUG_LOG(
-            "In audio session focus mode, no need to check app stream type. pid = %{public}d", audioInterrupt.pid);
-        return;
-    }
-
     if (HasAudioSessionFakeInterrupt(zoneId, audioInterrupt.pid)) {
         return;
     }
@@ -946,6 +934,7 @@ int32_t AudioInterruptService::ActivateAudioInterruptInternal(const int32_t zone
     if (ShouldBypassAudioSessionFocus(zoneId, audioInterrupt)) {
         TryHandleStreamCallbackInSession(zoneId, audioInterrupt);
         SendActiveVolumeTypeChangeEvent(zoneId);
+        sessionService_.AddStreamInfo(audioInterrupt);
         updateScene = true;
         AUDIO_INFO_LOG("Bypass Audio session focus, pid = %{public}d", audioInterrupt.pid);
         return SUCCESS;
@@ -979,11 +968,8 @@ void AudioInterruptService::PrintLogsOfFocusStrategyBaseMusic(const AudioInterru
     }
     // Update focus strategy by audio session.
     AudioConcurrencyMode concurrencyMode = AudioConcurrencyMode::INVALID;
-    if (sessionService_ != nullptr && sessionService_->IsAudioSessionActivated(audioInterrupt.pid)) {
-        std::shared_ptr<AudioSession> incomingSession = sessionService_->GetAudioSessionByPid(audioInterrupt.pid);
-        if (incomingSession != nullptr) {
-            concurrencyMode = (incomingSession->GetSessionStrategy()).concurrencyMode;
-        }
+    if (sessionService_.IsAudioSessionActivated(audioInterrupt.pid)) {
+        concurrencyMode = sessionService_.GetSessionStrategy(audioInterrupt.pid);
     } else {
         concurrencyMode = audioInterrupt.sessionStrategy.concurrencyMode;
     }
@@ -1229,8 +1215,8 @@ AudioStreamType AudioInterruptService::GetStreamInFocusInternal(const int32_t ui
             !CheckoutSystemAppUtil::CheckoutSystemApp((iter->first).uid)) {
             (iter->first).audioFocusType.streamType = STREAM_MUSIC;
         }
-        if (sessionService_ != nullptr && iter->first.isAudioSessionInterrupt) {
-            std::vector<AudioInterrupt> sessionStreams = sessionService_->GetStreams(iter->first.pid);
+        if (iter->first.isAudioSessionInterrupt) {
+            std::vector<AudioInterrupt> sessionStreams = sessionService_.GetStreams(iter->first.pid);
             for (auto stream : sessionStreams) {
                 int32_t curPriority = GetStreamTypePriority(stream.audioFocusType.streamType);
                 if (curPriority < focusPriority) {
@@ -1333,38 +1319,28 @@ bool AudioInterruptService::IsSameAppInShareMode(const AudioInterrupt incomingIn
     return incomingInterrupt.pid == activeInterrupt.pid;
 }
 
-bool AudioInterruptService::CheckAudioSessionExistence(const AudioInterrupt &incomingInterrupt,
-    AudioFocusEntry &focusEntry)
-{
-    if (sessionService_ == nullptr) {
-        AUDIO_ERR_LOG("sessionService_ is nullptr!");
-        return false;
-    }
-    if (!sessionService_->IsAudioSessionActivated(incomingInterrupt.pid)) {
-        AUDIO_INFO_LOG("No active audio session for the pid of incomming stream");
-        return false;
-    }
-    if (focusEntry.actionOn != CURRENT) {
-        AUDIO_INFO_LOG("The interrupt event is not for the existed stream.");
-        return false;
-    }
-    std::shared_ptr<AudioSession> incomingSession = sessionService_->GetAudioSessionByPid(incomingInterrupt.pid);
-    if (incomingSession == nullptr) {
-        AUDIO_ERR_LOG("incomingSession is nullptr!");
-        return false;
-    }
-    return true;
-}
-
 void AudioInterruptService::UpdateHintTypeForExistingSession(const AudioInterrupt &incomingInterrupt,
     AudioFocusEntry &focusEntry)
 {
-    AudioConcurrencyMode concurrencyMode = incomingInterrupt.sessionStrategy.concurrencyMode;
+    const std::unordered_map<AudioConcurrencyMode, InterruptHint> modeToHintMap = {
+        {AudioConcurrencyMode::DUCK_OTHERS, INTERRUPT_HINT_DUCK},
+        {AudioConcurrencyMode::PAUSE_OTHERS, INTERRUPT_HINT_PAUSE},
+    };
 
-    if (CheckAudioSessionExistence(incomingInterrupt, focusEntry)) {
-        std::shared_ptr<AudioSession> incomingSession = sessionService_->GetAudioSessionByPid(incomingInterrupt.pid);
-        concurrencyMode = (incomingSession->GetSessionStrategy()).concurrencyMode;
+    AudioConcurrencyMode concurrencyMode = incomingInterrupt.sessionStrategy.concurrencyMode;
+    if (focusEntry.actionOn == CURRENT && sessionService_.IsAudioSessionActivated(incomingInterrupt.pid)) {
+        concurrencyMode = sessionService_.GetSessionStrategy(incomingInterrupt.pid);
+        if (sessionService_.IsSystemApp(incomingInterrupt.pid)) {
+            const auto &modeToHint = modeToHintMap.find(concurrencyMode);
+            if (modeToHint != modeToHintMap.end()) {
+                AUDIO_INFO_LOG("Update hint type for system app anyway, pid: %{public}d, strategy: %{public}d",
+                    incomingInterrupt.pid, static_cast<int32_t>(concurrencyMode));
+                focusEntry.hintType = modeToHint->second;
+                return;
+            }
+        }
     }
+
     switch (concurrencyMode) {
         case AudioConcurrencyMode::DUCK_OTHERS:
             if (focusEntry.hintType == INTERRUPT_HINT_DUCK ||
@@ -1497,14 +1473,13 @@ std::set<int32_t> AudioInterruptService::GetStreamIdsForAudioSessionByDeviceType
     std::set<int32_t> streamIds;
 
     std::unique_lock<std::mutex> lock(mutex_);
-    CHECK_AND_RETURN_RET_LOG(sessionService_ != nullptr, streamIds, "sessionService_ is nullptr");
     auto targetZoneIt = zonesMap_.find(zoneId);
     CHECK_AND_RETURN_RET_LOG(targetZoneIt != zonesMap_.end(), streamIds, "can not find zone id");
     auto &tmpFocusInfoList = targetZoneIt->second->audioFocusInfoList;
     for (auto focusIter = tmpFocusInfoList.begin(); focusIter != tmpFocusInfoList.end(); ++focusIter) {
         const auto &audioInterrupt = focusIter->first;
         if (audioInterrupt.isAudioSessionInterrupt &&
-            sessionService_->HasStreamForDeviceType(audioInterrupt.pid, deviceType)) {
+            sessionService_.HasStreamForDeviceType(audioInterrupt.pid, deviceType)) {
                 streamIds.insert(static_cast<int32_t>(audioInterrupt.streamId));
         }
     }
@@ -1534,8 +1509,7 @@ std::vector<int32_t> AudioInterruptService::GetAudioSessionUidList(int32_t zoneI
 StreamUsage AudioInterruptService::GetAudioSessionStreamUsage(int32_t callerPid)
 {
     std::lock_guard<std::mutex> lock(mutex_);
-    CHECK_AND_RETURN_RET_LOG(sessionService_ != nullptr, STREAM_USAGE_INVALID, "sessionService_ is nullptr!");
-    return sessionService_->GetAudioSessionStreamUsage(callerPid);
+    return sessionService_.GetAudioSessionStreamUsage(callerPid);
 }
 
 void AudioInterruptService::ProcessRemoteInterrupt(std::set<int32_t> streamIds, InterruptEventInternal interruptEvent)
@@ -1645,7 +1619,7 @@ void AudioInterruptService::RemoveFocusInfo(std::list<std::pair<AudioInterrupt,
     iterActive = tmpFocusInfoList.erase(iterActive);
     zoneInfo->audioFocusInfoList = tmpFocusInfoList;
     bool isAudioSessionDeactivated = false;
-    if (sessionService_ != nullptr && sessionService_->IsAudioSessionActivated(pidToRemove)) {
+    if (sessionService_.IsAudioSessionActivated(pidToRemove)) {
         isAudioSessionDeactivated = HandleLowPriorityEvent(pidToRemove, streamId);
     }
     if (isAudioSessionDeactivated) {
@@ -1656,20 +1630,10 @@ void AudioInterruptService::RemoveFocusInfo(std::list<std::pair<AudioInterrupt,
 bool AudioInterruptService::HandleLowPriorityEvent(const int32_t pid, const uint32_t streamId)
 {
     // If AudioSession is deactivated, return true, otherwise, return false.
-    if (sessionService_ == nullptr) {
-        AUDIO_ERR_LOG("sessionService_ is nullptr!");
-        return false;
-    }
-    auto audioSession = sessionService_->GetAudioSessionByPid(pid);
-    if (audioSession == nullptr) {
-        AUDIO_ERR_LOG("audioSession is nullptr!");
-        return false;
-    }
-
-    audioSession->RemoveStreamInfo(streamId);
-    if (audioSession->IsAudioSessionEmpty()) {
+    sessionService_.RemoveStreamInfo(pid, streamId);
+    if (sessionService_.IsStreamInfoEmpty(pid)) {
         AUDIO_INFO_LOG("The audio session is empty because the last one stream is interruptted!");
-        sessionService_->DeactivateAudioSession(pid);
+        sessionService_.DeactivateAudioSession(pid);
 
         AudioSessionDeactiveEvent deactiveEvent;
         deactiveEvent.deactiveReason = AudioSessionDeactiveReason::LOW_PRIORITY;
@@ -1721,10 +1685,8 @@ void AudioInterruptService::ProcessAudioScene(const AudioInterrupt &audioInterru
 
         itZone->second->audioFocusInfoList = audioFocusInfoList;
         zonesMap_[zoneId] = itZone->second;
-        if (sessionService_ != nullptr && sessionService_->IsAudioSessionActivated(pid)) {
-            std::shared_ptr<AudioSession> tempSession = sessionService_->GetAudioSessionByPid(pid);
-            CHECK_AND_RETURN_LOG(tempSession != nullptr, "audio session is null");
-            tempSession->RemoveStreamInfo(incomingStreamId);
+        if (sessionService_.IsAudioSessionActivated(pid)) {
+            sessionService_.RemoveStreamInfo(pid, incomingStreamId);
         }
     }
 
@@ -1736,10 +1698,8 @@ void AudioInterruptService::ProcessAudioScene(const AudioInterrupt &audioInterru
             itZone->second->audioFocusInfoList.emplace_back(std::make_pair(audioInterrupt, ACTIVE));
             zonesMap_[zoneId] = itZone->second;
         }
-        if (sessionService_ != nullptr && sessionService_->IsAudioSessionActivated(pid)) {
-            std::shared_ptr<AudioSession> tempAudioSession = sessionService_->GetAudioSessionByPid(pid);
-            CHECK_AND_RETURN_LOG(tempAudioSession != nullptr, "audio session is null");
-            tempAudioSession->AddStreamInfo(audioInterrupt);
+        if (sessionService_.IsAudioSessionActivated(pid)) {
+            sessionService_.AddStreamInfo(audioInterrupt);
         }
         SendFocusChangeEvent(zoneId, AudioPolicyServerHandler::REQUEST_CALLBACK_CATEGORY, audioInterrupt);
         SendActiveVolumeTypeChangeEvent(zoneId);
@@ -1988,11 +1948,6 @@ int32_t AudioInterruptService::ProcessFocusEntry(const int32_t zoneId, const Aud
 int32_t AudioInterruptService::ProcessFocusEntryForAudioSession(
     const int32_t zoneId, const int32_t callerPid, bool &updateScene)
 {
-    if (sessionService_ == nullptr) {
-        AUDIO_ERR_LOG("sessionService_ is nullptr!");
-        return ERR_UNKNOWN;
-    }
-
     auto itZone = zonesMap_.find(zoneId);
     CHECK_AND_RETURN_RET_LOG((itZone != zonesMap_.end()) && (itZone->second != nullptr), ERROR, "can not find zone");
     std::list<std::pair<AudioInterrupt, AudioFocuState>> audioFocusInfoList = itZone->second->audioFocusInfoList;
@@ -2001,7 +1956,7 @@ int32_t AudioInterruptService::ProcessFocusEntryForAudioSession(
         return pair.first.pid == callerPid && pair.first.isAudioSessionInterrupt;
     };
 
-    AudioInterrupt audioInterrupt = sessionService_->GenerateFakeAudioInterrupt(callerPid);
+    AudioInterrupt audioInterrupt = sessionService_.GenerateFakeAudioInterrupt(callerPid);
     auto iter = std::find_if(audioFocusInfoList.begin(), audioFocusInfoList.end(), isAudioSessionFocusPresent);
     // It is possible that the reactivation of the audio session was caused by changing the session scene or strategy.
     bool isFirstTimeActiveAudioSession = true;
@@ -2024,7 +1979,7 @@ int32_t AudioInterruptService::ProcessFocusEntryForAudioSession(
     }
 
     if (isFirstTimeActiveAudioSession) {
-        sessionService_->ClearStreamInfo(callerPid);
+        sessionService_.ClearStreamInfo(callerPid);
         return HandleExistStreamsForSession(zoneId, callerPid, updateScene);
     }
 
@@ -2045,7 +2000,7 @@ int32_t AudioInterruptService::HandleExistStreamsForSession(
     auto isStreamFocusPresent = [&](const std::pair<AudioInterrupt, AudioFocuState> &pair) {
         return pair.first.pid == callerPid &&
             !pair.first.isAudioSessionInterrupt &&
-            !sessionService_->ShouldExcludeStreamType(pair.first);
+            !sessionService_.ShouldExcludeStreamType(pair.first);
     };
 
     bool tempUpdateScene = false;
@@ -2054,7 +2009,7 @@ int32_t AudioInterruptService::HandleExistStreamsForSession(
             updateScene = true;
             int32_t ret = ActivateAudioInterruptCoreProcedure(zoneId, it.first, true, tempUpdateScene);
             if (ret != SUCCESS) {
-                return ret;
+                AUDIO_ERR_LOG("ActivateAudioInterruptCoreProcedure failed for pid = %{public}d", it.first.pid);
             }
         }
     }
@@ -2062,6 +2017,41 @@ int32_t AudioInterruptService::HandleExistStreamsForSession(
     return SUCCESS;
 }
 
+void AudioInterruptService::ReactivateAudioInterrupts(
+    const int32_t zoneId, const int32_t callerPid, bool &updateScene)
+{
+    auto itZone = zonesMap_.find(zoneId);
+    if (itZone == zonesMap_.end() || itZone->second == nullptr) {
+        AUDIO_INFO_LOG("Can not find focus, no need to reactivate audio interrupt for pid: %{public}d", callerPid);
+        return;
+    }
+    std::list<std::pair<AudioInterrupt, AudioFocuState>> audioFocusInfoList = itZone->second->audioFocusInfoList;
+
+    /* The focus of a single stream should be managed by audio session focus.
+    1. This mainly handles streams that already exist before audio session activation.
+    2. and to handle the state transition when the audio session resumes from a paused state.
+    */
+    auto isStreamFocusPresent = [&](const std::pair<AudioInterrupt, AudioFocuState> &pair) {
+        return pair.first.pid == callerPid && pair.second != PLACEHOLDER;
+    };
+
+    bool tempUpdateScene = false;
+    for (const auto &it : audioFocusInfoList) {
+        if (isStreamFocusPresent(it)) {
+            updateScene = true;
+            int32_t ret = ActivateAudioInterruptCoreProcedure(zoneId, it.first, true, tempUpdateScene);
+            if (ret != SUCCESS) {
+                AUDIO_ERR_LOG("ActivateAudioInterruptCoreProcedure failed for pid = %{public}d", callerPid);
+            }
+        }
+    }
+
+    if (updateScene) {
+        // resume if other session was forced paused or ducked
+        ResumeAudioFocusList(zoneId, false);
+    }
+}
+
 bool AudioInterruptService::ShouldBypassAudioSessionFocus(const int32_t zoneId, const AudioInterrupt &incomingInterrupt)
 {
     AUDIO_INFO_LOG("incomingInterrupt info: pid = %{public}d, isAudioSessionInterrupt = %{public}d,"
@@ -2078,7 +2068,7 @@ bool AudioInterruptService::ShouldBypassAudioSessionFocus(const int32_t zoneId,
         return false;
     }
 
-    if (sessionService_ != nullptr && sessionService_->ShouldBypassFocusForStream(incomingInterrupt)) {
+    if (sessionService_.ShouldBypassFocusForStream(incomingInterrupt)) {
         return true;
     }
 
@@ -2175,13 +2165,8 @@ void AudioInterruptService::AddToAudioFocusInfoList(std::shared_ptr<AudioInterru
     zonesMap_[zoneId] = audioInterruptZone;
     SendFocusChangeEvent(zoneId, AudioPolicyServerHandler::REQUEST_CALLBACK_CATEGORY, incomingInterrupt);
     SendActiveVolumeTypeChangeEvent(zoneId);
-    if (sessionService_ != nullptr && sessionService_->IsAudioSessionActivated(incomingInterrupt.pid)) {
-        auto audioSession = sessionService_->GetAudioSessionByPid(incomingInterrupt.pid);
-        if (audioSession == nullptr) {
-            AUDIO_ERR_LOG("audioSession is nullptr!");
-            return;
-        }
-        audioSession->AddStreamInfo(incomingInterrupt);
+    if (sessionService_.IsAudioSessionActivated(incomingInterrupt.pid)) {
+        sessionService_.AddStreamInfo(incomingInterrupt);
     }
 }
 
@@ -2235,16 +2220,12 @@ AudioScene AudioInterruptService::GetHighestPriorityAudioScene(const int32_t zon
 AudioScene AudioInterruptService::GetHighestPriorityAudioSceneFromAudioSession(
     const AudioInterrupt &audioInterrupt, const AudioScene &audioScene) const
 {
-    if (sessionService_ == nullptr) {
-        return audioScene;
-    }
-
     int32_t audioScenePriority = GetAudioScenePriority(audioScene);
     AudioScene finalAudioScene = audioScene;
     bool hasRingtoneInVoip = false;
 
     // Handle streams in audio session
-    const auto &streamsInSession = sessionService_->GetStreams(audioInterrupt.pid);
+    const auto &streamsInSession = sessionService_.GetStreams(audioInterrupt.pid);
     for (auto &it : streamsInSession) {
         AudioScene innerAudioScene = GetAudioSceneFromAudioInterrupt(it);
         int32_t innerAudioScenePriority = GetAudioScenePriority(innerAudioScene);
@@ -2302,16 +2283,15 @@ void AudioInterruptService::DeactivateAudioInterruptInternal(const int32_t zoneI
     std::list<std::pair<AudioInterrupt, AudioFocuState>> audioFocusInfoList = itZone->second->audioFocusInfoList;
 
     bool needPlaceHolder = false;
-    if (sessionService_ != nullptr && sessionService_->IsAudioSessionActivated(audioInterrupt.pid)) {
+    if (sessionService_.IsAudioSessionActivated(audioInterrupt.pid)) {
         // if this stream is the last renderer for audio session, change the state to PLACEHOLDER.
-        auto audioSession = sessionService_->GetAudioSessionByPid(audioInterrupt.pid);
-        if (audioSession != nullptr) {
-            audioSession->RemoveStreamInfo(audioInterrupt.streamId);
-            needPlaceHolder = !audioInterrupt.isAudioSessionInterrupt &&
-                audioInterrupt.audioFocusType.streamType != STREAM_DEFAULT &&
-                audioSession->IsAudioRendererEmpty() &&
-                !HadVoipStatus(audioInterrupt, audioFocusInfoList);
-        }
+        sessionService_.RemoveStreamInfo(audioInterrupt.pid, audioInterrupt.streamId);
+
+        needPlaceHolder = !audioInterrupt.isAudioSessionInterrupt &&
+            audioInterrupt.audioFocusType.streamType != STREAM_DEFAULT &&
+            !sessionService_.ShouldExcludeStreamType(audioInterrupt) &&
+            sessionService_.IsAudioRendererEmpty(audioInterrupt.pid) &&
+            !HadVoipStatus(audioInterrupt, audioFocusInfoList);
     }
 
     WriteStopDfxMsg(audioInterrupt);
@@ -2530,8 +2510,7 @@ void AudioInterruptService::SendInterruptEventToAudioServer(
         "need not send audioInterrupt to audioServer");
     if (audioInterrupt.isAudioSessionInterrupt) {
         AUDIO_INFO_LOG("is audioSession interrupt");
-        CHECK_AND_RETURN_LOG(sessionService_ != nullptr, "sessionService_ is nullptr");
-        const auto &audioInterrupts = sessionService_->GetStreams(audioInterrupt.pid);
+        const auto &audioInterrupts = sessionService_.GetStreams(audioInterrupt.pid);
         for (auto &it : audioInterrupts) {
             AudioServerProxy::GetInstance().SendInterruptEventToAudioServerProxy(
                 interruptEvent, it.streamId);
@@ -2583,13 +2562,8 @@ void AudioInterruptService::SendAudioSessionInterruptEventCallback(
     For audio session focus, the session's callbacks must be processed first,
     then process all stream callbacks managed under that session.
     */
-    if (sessionService_ == nullptr) {
-        AUDIO_ERR_LOG("sessionService_ is nullptr");
-        return;
-    }
-
     // Processes the situation where the audio session fake interrupt is preempted by other applications.
-    if (sessionService_->ShouldAudioSessionProcessHintType(interruptEvent.hintType)) {
+    if (sessionService_.ShouldAudioSessionProcessHintType(interruptEvent.hintType)) {
         handler_->SendInterruptEventCallbackForAudioSession(interruptEvent, audioInterrupt);
         // Simulate the deactivation of the audio session.
         if (interruptEvent.hintType == INTERRUPT_HINT_STOP || interruptEvent.hintType == INTERRUPT_HINT_RESUME) {
@@ -2600,8 +2574,8 @@ void AudioInterruptService::SendAudioSessionInterruptEventCallback(
     Callback for all streams when the audio session's fake interrupt state changes.
     INTERRUPT_HINT_STOP should not be processed here, because the audio session has been deactivated.
     */
-    if (sessionService_->ShouldAudioStreamProcessHintType(interruptEvent.hintType)) {
-        const auto &audioInterrupts = sessionService_->GetStreams(audioInterrupt.pid);
+    if (sessionService_.ShouldAudioStreamProcessHintType(interruptEvent.hintType)) {
+        const auto &audioInterrupts = sessionService_.GetStreams(audioInterrupt.pid);
         for (auto &it : audioInterrupts) {
             handler_->SendInterruptEventWithStreamIdCallback(interruptEvent, it.streamId);
         }
@@ -2818,12 +2792,7 @@ void AudioInterruptService::DispatchInterruptEventForAudioSession(
     InterruptEventInternal &interruptEvent, const AudioInterrupt &audioInterrupt)
 {
     std::lock_guard<std::mutex> lock(mutex_);
-    if (sessionService_ == nullptr) {
-        AUDIO_ERR_LOG("[sessionService_ is null");
-        return;
-    }
-
-    std::vector<AudioInterrupt> sessionStreams = sessionService_->GetStreams(audioInterrupt.pid);
+    std::vector<AudioInterrupt> sessionStreams = sessionService_.GetStreams(audioInterrupt.pid);
     for (auto it : sessionStreams) {
         if (interruptClients_.find(it.streamId) != interruptClients_.end() &&
             interruptClients_[it.streamId] != nullptr) {
@@ -2980,10 +2949,11 @@ void AudioInterruptService::WriteStartDfxMsg(InterruptDfxBuilder &dfxBuilder, co
         INTERRUPT_STAGE_RESTART : INTERRUPT_STAGE_START;
 
     AudioSessionStrategy strategy = audioInterrupt.sessionStrategy;
-    auto audioSession = sessionService_->GetAudioSessionByPid(audioInterrupt.pid);
     InterruptRole interruptType = InterruptRole::INTERRUPT_ROLE_DEFAULT;
-    if (audioSession != nullptr) {
-        strategy = audioSession->GetSessionStrategy();
+    AudioConcurrencyMode concurrencyMode = AudioConcurrencyMode::INVALID;
+    concurrencyMode = sessionService_.GetSessionStrategy(audioInterrupt.pid);
+    if (concurrencyMode != AudioConcurrencyMode::INVALID) {
+        strategy.concurrencyMode = concurrencyMode;
         interruptType = INTERRUPT_ROLE_AUDIO_SESSION;
     }
 
diff --git a/services/audio_policy/server/domain/interrupt/src/audio_interrupt_service_ext.cpp b/services/audio_policy/server/domain/interrupt/src/audio_interrupt_service_ext.cpp
index 2f12472ffd949f3ad9dd3525850d34c4e4bd4508..3ccf17a5647a47fde7078f19355aef76b0807c40 100644
--- a/services/audio_policy/server/domain/interrupt/src/audio_interrupt_service_ext.cpp
+++ b/services/audio_policy/server/domain/interrupt/src/audio_interrupt_service_ext.cpp
@@ -80,16 +80,6 @@ void AudioInterruptService::AudioInterruptZoneDump(std::string &dumpString)
     return;
 }
 
-void AudioInterruptService::AudioSessionInfoDump(std::string &dumpString)
-{
-    AppendFormat(dumpString, "    - The AudioSession as follow:\n");
-    if (sessionService_ == nullptr) {
-        AppendFormat(dumpString, "    - The AudioSessionService is null.\n");
-        return;
-    }
-    sessionService_->AudioSessionInfoDump(dumpString);
-}
-
 // AudioInterruptDeathRecipient impl begin
 AudioInterruptService::AudioInterruptDeathRecipient::AudioInterruptDeathRecipient(
     const std::shared_ptr<AudioInterruptService> &service,
diff --git a/services/audio_policy/server/domain/interrupt/src/audio_interrupt_zone.cpp b/services/audio_policy/server/domain/interrupt/src/audio_interrupt_zone.cpp
index c6863d082b1c76c5a080902891f412a7ddcc0346..425fc2a0e7d8492a2785ac556d7812be612177cf 100644
--- a/services/audio_policy/server/domain/interrupt/src/audio_interrupt_zone.cpp
+++ b/services/audio_policy/server/domain/interrupt/src/audio_interrupt_zone.cpp
@@ -126,16 +126,14 @@ void AudioInterruptZoneManager::ForceStopAudioFocusInZone(int32_t zoneId, const
 {
     AUDIO_DEBUG_LOG("force stop interrupt %{public}d,%{public}d,%{public}d of zone %{public}d",
         interrupt.uid, interrupt.pid, interrupt.streamId, zoneId);
+    CHECK_AND_RETURN_LOG(service_ != nullptr, "interrupt service is nullptr");
 
-    CHECK_AND_RETURN_LOG(service_->sessionService_ != nullptr, "session service is nullptr");
     InterruptEventInternal interruptEvent {INTERRUPT_TYPE_BEGIN, INTERRUPT_FORCE, INTERRUPT_HINT_STOP, 1.0f};
     if (service_->handler_ != nullptr) {
         service_->handler_->SendInterruptEventWithStreamIdCallback(interruptEvent, interrupt.streamId);
     }
 
-    auto audioSession = service_->sessionService_->GetAudioSessionByPid(interrupt.pid);
-    CHECK_AND_RETURN_LOG(audioSession != nullptr, "audio session is nullptr");
-    audioSession->RemoveStreamInfo(interrupt.streamId);
+    service_->sessionService_.RemoveStreamInfo(interrupt.pid, interrupt.streamId);
 }
 
 int32_t AudioInterruptZoneManager::MigrateAudioInterruptZone(const int32_t zoneId, GetZoneIdFunc func)
@@ -288,12 +286,9 @@ AudioFocusIterator AudioInterruptZoneManager::QueryAudioFocusFromZone(int32_t zo
 
 void AudioInterruptZoneManager::RemoveAudioZoneInterrupts(int32_t zoneId, const AudioFocusIterator &focus)
 {
-    CHECK_AND_RETURN_LOG(service_->sessionService_ != nullptr, "session service is nullptr");
+    CHECK_AND_RETURN_LOG(service_ != nullptr, "service is nullptr");
     for (auto &it : focus) {
-        auto audioSession = service_->sessionService_->GetAudioSessionByPid(it->first.pid);
-        if (audioSession != nullptr) {
-            audioSession->RemoveStreamInfo(it->first.streamId);
-        }
+        service_->sessionService_.RemoveStreamInfo(it->first.pid, it->first.streamId);
         AUDIO_DEBUG_LOG("remove interrupt %{public}d from zone %{public}d",
             it->first.streamId, zoneId);
         service_->zonesMap_[zoneId]->audioFocusInfoList.erase(it);
diff --git a/services/audio_policy/server/domain/session/include/audio_session.h b/services/audio_policy/server/domain/session/include/audio_session.h
index 8a103fe0fff41d8058d8c79fe18e319cddad9932..42bc42ef8ba6683eb556a24338bb09c45fd0ac86 100644
--- a/services/audio_policy/server/domain/session/include/audio_session.h
+++ b/services/audio_policy/server/domain/session/include/audio_session.h
@@ -22,7 +22,6 @@
 #include "audio_session_info.h"
 #include "audio_device_info.h"
 #include "audio_device_descriptor.h"
-#include "audio_policy_server_handler.h"
 
 namespace OHOS {
 namespace AudioStandard {
@@ -38,10 +37,14 @@ class AudioSessionStateMonitor;
 class AudioDeviceManager;
 class AudioPipeManager;
 
+/*
+ * AudioSession is an inner class of AudioSessionService, no mutex is added to AudioSession,
+ * and classes other than AudioSessionService are not allowed to directly access AudioSession.
+ */
 class AudioSession {
 public:
     AudioSession(const int32_t callerPid, const AudioSessionStrategy &strategy,
-        const std::shared_ptr<AudioSessionStateMonitor> audioSessionStateMonitor);
+        AudioSessionStateMonitor &audioSessionStateMonitor);
     ~AudioSession();
     bool IsSceneParameterSet();
     int32_t SetAudioSessionScene(AudioSessionScene audioSessionScene);
@@ -53,7 +56,6 @@ public:
     void ClearStreamInfo(void);
     uint32_t GetFakeStreamId();
     void SaveFakeStreamId(uint32_t fakeStreamId);
-    bool ShouldExcludeStreamType(const AudioInterrupt &audioInterrupt);
     void Dump(std::string &dumpString);
     int32_t Activate(const AudioSessionStrategy strategy);
     int32_t Deactivate();
@@ -64,11 +66,14 @@ public:
     void GetSessionDefaultOutputDevice(DeviceType &deviceType);
     bool IsStreamContainedInCurrentSession(const uint32_t &streamId);
     bool GetAndClearNeedToFetchFlag();
-    bool IsRecommendToStopAudio(const std::shared_ptr<AudioPolicyServerHandler::EventContextObj> eventContextObj);
+    bool IsRecommendToStopAudio(AudioStreamDeviceChangeReason changeReason,
+        const std::shared_ptr<AudioDeviceDescriptor> descriptor);
     bool IsSessionOutputDeviceChanged(const std::shared_ptr<AudioDeviceDescriptor> deviceDescriptor);
     bool IsSessionInputDeviceChanged(const std::shared_ptr<AudioDeviceDescriptor> deviceDescriptor);
     StreamUsage GetSessionStreamUsage();
     bool IsBackGroundApp(void);
+    void MarkSystemApp(void);
+    bool IsSystemApp(void) const;
 
 private:
     StreamUsage GetStreamUsageInner();
@@ -84,11 +89,10 @@ private:
     void UpdateSingleVoipStreamDefaultOutputDevice(const AudioInterrupt &interrupt);
     bool IsSessionDefaultDeviceEnabled();
     bool IsOutputDeviceConfigurableByStreamUsage(const StreamUsage &streamUsage);
-    std::mutex sessionMutex_;
     int32_t callerPid_;
     bool needToFetch_ = false;
-    AudioSessionStrategy strategy_;
-    std::weak_ptr<AudioSessionStateMonitor> audioSessionStateMonitor_;
+    AudioSessionStrategy strategy_ {AudioConcurrencyMode::INVALID};
+    AudioSessionStateMonitor &audioSessionStateMonitor_;
     AudioSessionScene audioSessionScene_ {AudioSessionScene::INVALID};
     // These are streams included in audiosession focus.
     std::vector<AudioInterrupt> streamsInSession_;
@@ -99,6 +103,7 @@ private:
     AudioDeviceDescriptor inputDeviceDescriptor_;
     std::shared_ptr<AudioPipeManager> pipeManager_ = nullptr;
     AudioDeviceManager &deviceManager_;
+    bool isSystemApp_ {false};
 };
 } // namespace AudioStandard
 } // namespace OHOS
diff --git a/services/audio_policy/server/domain/session/include/audio_session_service.h b/services/audio_policy/server/domain/session/include/audio_session_service.h
index 8824378ecea072f150cad850b2c7e5c3dd0f5995..6a723874548a7dd6ec68e01f3f4f1ae6211a940c 100644
--- a/services/audio_policy/server/domain/session/include/audio_session_service.h
+++ b/services/audio_policy/server/domain/session/include/audio_session_service.h
@@ -18,9 +18,11 @@
 
 #include <mutex>
 #include <vector>
+#include "singleton.h"
 #include "audio_session.h"
 #include "audio_session_state_monitor.h"
 #include "audio_device_info.h"
+#include "audio_session_device_info.h"
 
 namespace OHOS {
 namespace AudioStandard {
@@ -31,13 +33,10 @@ public:
     virtual void OnSessionTimeout(const int32_t pid) = 0;
 };
 
-class AudioSessionService : public AudioSessionStateMonitor, public std::enable_shared_from_this<AudioSessionService> {
+class AudioSessionService : public AudioSessionStateMonitor {
+    DECLARE_SINGLETON(AudioSessionService)
 public:
-    AudioSessionService();
-    ~AudioSessionService() override;
-
     // Audio session manager interfaces
-    static std::shared_ptr<AudioSessionService> GetAudioSessionService(void);
     int32_t ActivateAudioSession(const int32_t callerPid, const AudioSessionStrategy &strategy);
     int32_t DeactivateAudioSession(const int32_t callerPid);
     bool IsAudioSessionActivated(const int32_t callerPid);
@@ -47,7 +46,6 @@ public:
 
     // other public interfaces
     int32_t SetSessionTimeOutCallback(const std::shared_ptr<SessionTimeOutCallback> &timeOutCallback);
-    std::shared_ptr<AudioSession> GetAudioSessionByPid(const int32_t callerPid);
 
     // Dump AudioSession Info
     void AudioSessionInfoDump(std::string &dumpString);
@@ -63,18 +61,34 @@ public:
     bool ShouldExcludeStreamType(const AudioInterrupt &audioInterrupt);
     std::vector<AudioInterrupt> GetStreams(int32_t callerPid);
     AudioInterrupt GenerateFakeAudioInterrupt(int32_t callerPid);
-    void RemoveStreamInfo(const AudioInterrupt &audioInterrupt);
+    void AddStreamInfo(const AudioInterrupt &audioInterrupt);
+    void RemoveStreamInfo(const int32_t callerPid, const uint32_t streamId);
     void ClearStreamInfo(const int32_t callerPid);
+    bool IsStreamInfoEmpty(const int32_t callerPid);
+    bool IsAudioRendererEmpty(const int32_t callerPid);
+    AudioConcurrencyMode GetSessionStrategy(int32_t callerPid);
     bool ShouldAudioSessionProcessHintType(InterruptHint hintType);
     bool ShouldAudioStreamProcessHintType(InterruptHint hintType);
     static bool IsSameTypeForAudioSession(const AudioStreamType incomingType, const AudioStreamType existedType);
     void NotifyAppStateChange(const int32_t pid, bool isBackState);
     bool HasStreamForDeviceType(int32_t callerPid, DeviceType deviceType);
+    int32_t FillCurrentOutputDeviceChangedEvent(
+        int32_t callerPid,
+        AudioStreamDeviceChangeReason changeReason,
+        const std::shared_ptr<AudioDeviceDescriptor> descriptor,
+        CurrentOutputDeviceChangedEvent &deviceChangedEvent);
+    bool IsSessionInputDeviceChanged(int32_t callerPid, const std::shared_ptr<AudioDeviceDescriptor> desc);
+    void MarkSystemApp(int32_t pid);
+    bool IsSystemApp(int32_t pid);
+    bool IsSystemAppWithMixStrategy(int32_t pid);
 
 private:
     int32_t DeactivateAudioSessionInternal(const int32_t callerPid, bool isSessionTimeout = false);
-    std::shared_ptr<AudioSessionStateMonitor> GetSelfSharedPtr() override;
     void GenerateFakeStreamId(int32_t callerPid);
+    std::shared_ptr<AudioSession> CreateAudioSession(
+        int32_t callerPid, AudioSessionStrategy strategy = {AudioConcurrencyMode::INVALID});
+    bool IsAudioSessionFocusModeInner(int32_t callerPid);
+    bool ShouldExcludeStreamTypeInner(const AudioInterrupt &audioInterrupt);
 
 private:
     std::mutex sessionServiceMutex_;
diff --git a/services/audio_policy/server/domain/session/include/audio_session_state_monitor.h b/services/audio_policy/server/domain/session/include/audio_session_state_monitor.h
index 3d58ff4d399a2aa4deb832f469158542c81524b3..0bce908a0f7263cf980db1b4879036fc52f93fe5 100644
--- a/services/audio_policy/server/domain/session/include/audio_session_state_monitor.h
+++ b/services/audio_policy/server/domain/session/include/audio_session_state_monitor.h
@@ -29,9 +29,6 @@ public:
     void StopMonitor(int32_t pid);
     void RemoveFromMonitorMap(int32_t pid);
 
-private:
-    virtual std::shared_ptr<AudioSessionStateMonitor> GetSelfSharedPtr() = 0;
-
 private:
     std::mutex sessionMonitorMutex_;
     std::unordered_map<int32_t, int32_t> pidCbIdMap_;
diff --git a/services/audio_policy/server/domain/session/src/audio_session.cpp b/services/audio_policy/server/domain/session/src/audio_session.cpp
index fa68bee7b78224d99565739a13474275e0a337ae..a31d848da3177619d08a792627b69a32027afef5 100644
--- a/services/audio_policy/server/domain/session/src/audio_session.cpp
+++ b/services/audio_policy/server/domain/session/src/audio_session.cpp
@@ -34,15 +34,15 @@ static constexpr time_t AUDIO_SESSION_TIME_OUT_DURATION_S = 60; // Audio session
 static constexpr time_t AUDIO_SESSION_SCENE_TIME_OUT_DURATION_S = 10; // Audio sessionV2 timeout duration : 10 seconds
 
 AudioSession::AudioSession(const int32_t callerPid, const AudioSessionStrategy &strategy,
-    const std::shared_ptr<AudioSessionStateMonitor> audioSessionStateMonitor)
-    : deviceManager_(AudioDeviceManager::GetAudioDeviceManager())
+                           AudioSessionStateMonitor &audioSessionStateMonitor)
+    : callerPid_(callerPid),
+      strategy_(strategy),
+      audioSessionStateMonitor_(audioSessionStateMonitor),
+      pipeManager_(AudioPipeManager::GetPipeManager()),
+      deviceManager_(AudioDeviceManager::GetAudioDeviceManager())
 {
     AUDIO_INFO_LOG("AudioSession()");
-    callerPid_ = callerPid;
-    strategy_ = strategy;
-    audioSessionStateMonitor_ = audioSessionStateMonitor;
     state_ = AudioSessionState::SESSION_NEW;
-    pipeManager_ = AudioPipeManager::GetPipeManager();
 }
 
 AudioSession::~AudioSession()
@@ -52,14 +52,11 @@ AudioSession::~AudioSession()
 
 bool AudioSession::IsSceneParameterSet()
 {
-    std::lock_guard<std::mutex> lock(sessionMutex_);
     return audioSessionScene_ != AudioSessionScene::INVALID;
 }
 
 int32_t AudioSession::SetAudioSessionScene(AudioSessionScene scene)
 {
-    std::lock_guard<std::mutex> lock(sessionMutex_);
-
     if (scene != AudioSessionScene::MEDIA &&
         scene != AudioSessionScene::GAME &&
         scene != AudioSessionScene::VOICE_COMMUNICATION) {
@@ -73,13 +70,11 @@ int32_t AudioSession::SetAudioSessionScene(AudioSessionScene scene)
 
 bool AudioSession::IsActivated()
 {
-    std::lock_guard<std::mutex> lock(sessionMutex_);
     return state_ == AudioSessionState::SESSION_ACTIVE;
 }
 
 std::vector<AudioInterrupt> AudioSession::GetStreams()
 {
-    std::lock_guard<std::mutex> lock(sessionMutex_);
     return streamsInSession_;
 }
 
@@ -91,7 +86,6 @@ AudioStreamType AudioSession::GetFakeStreamType()
         {AudioSessionScene::VOICE_COMMUNICATION, AudioStreamType::STREAM_VOICE_COMMUNICATION}
     };
 
-    std::lock_guard<std::mutex> lock(sessionMutex_);
     auto it = mapping.find(audioSessionScene_);
     if (it != mapping.end()) {
         return it->second;
@@ -102,17 +96,6 @@ AudioStreamType AudioSession::GetFakeStreamType()
 
 void AudioSession::AddStreamInfo(const AudioInterrupt &incomingInterrupt)
 {
-    std::lock_guard<std::mutex> lock(sessionMutex_);
-    if (incomingInterrupt.isAudioSessionInterrupt) {
-        return;
-    }
-
-    if (state_ == AudioSessionState::SESSION_ACTIVE &&
-        audioSessionScene_ != AudioSessionScene::INVALID &&
-        ShouldExcludeStreamType(incomingInterrupt)) {
-        return;
-    }
-
     for (const auto &stream : streamsInSession_) {
         if (stream.streamId == incomingInterrupt.streamId) {
             AUDIO_INFO_LOG("stream aready exist.");
@@ -126,10 +109,7 @@ void AudioSession::AddStreamInfo(const AudioInterrupt &incomingInterrupt)
         (void)EnableSingleVoipStreamDefaultOutputDevice(incomingInterrupt);
     }
 
-    auto monitor = audioSessionStateMonitor_.lock();
-    if (monitor != nullptr) {
-        monitor->StopMonitor(callerPid_);
-    }
+    audioSessionStateMonitor_.StopMonitor(callerPid_);
 }
 
 bool AudioSession::IsSessionDefaultDeviceEnabled()
@@ -139,7 +119,6 @@ bool AudioSession::IsSessionDefaultDeviceEnabled()
 
 void AudioSession::RemoveStreamInfo(uint32_t streamId)
 {
-    std::lock_guard<std::mutex> lock(sessionMutex_);
     for (auto it = streamsInSession_.begin(); it != streamsInSession_.end(); ++it) {
         if (it->streamId == streamId) {
             if (IsSessionDefaultDeviceEnabled()) {
@@ -150,41 +129,36 @@ void AudioSession::RemoveStreamInfo(uint32_t streamId)
         }
     }
 
-    auto monitor = audioSessionStateMonitor_.lock();
-    if ((streamsInSession_.size() == 0) && monitor != nullptr) {
+    if (streamsInSession_.size() == 0) {
         // session v1 60s
         if (audioSessionScene_ == AudioSessionScene::INVALID) {
-            monitor->StartMonitor(callerPid_, AUDIO_SESSION_TIME_OUT_DURATION_S);
+            audioSessionStateMonitor_.StartMonitor(callerPid_, AUDIO_SESSION_TIME_OUT_DURATION_S);
         }
 
         // session v2 background 10s
         if ((audioSessionScene_ != AudioSessionScene::INVALID) && IsBackGroundApp()) {
-            monitor->StartMonitor(callerPid_, AUDIO_SESSION_SCENE_TIME_OUT_DURATION_S);
+            audioSessionStateMonitor_.StartMonitor(callerPid_, AUDIO_SESSION_SCENE_TIME_OUT_DURATION_S);
         }
     }
 }
 
 void AudioSession::ClearStreamInfo(void)
 {
-    std::lock_guard<std::mutex> lock(sessionMutex_);
     streamsInSession_.clear();
 }
 
 uint32_t AudioSession::GetFakeStreamId()
 {
-    std::lock_guard<std::mutex> lock(sessionMutex_);
     return fakeStreamId_;
 }
 
 void AudioSession::SaveFakeStreamId(uint32_t fakeStreamId)
 {
-    std::lock_guard<std::mutex> lock(sessionMutex_);
     fakeStreamId_ = fakeStreamId;
 }
 
 void AudioSession::Dump(std::string &dumpString)
 {
-    std::lock_guard<std::mutex> lock(sessionMutex_);
     AppendFormat(dumpString, "    - pid: %d, AudioSession strategy is: %d.\n",
         callerPid_, static_cast<uint32_t>(strategy_.concurrencyMode));
     AppendFormat(dumpString, "    - pid: %d, AudioSession scene is: %d.\n",
@@ -195,6 +169,8 @@ void AudioSession::Dump(std::string &dumpString)
         callerPid_, static_cast<int32_t>(defaultDeviceType_));
     AppendFormat(dumpString, "    - pid: %d, AudioSession state is: %u.\n",
         callerPid_, static_cast<uint32_t>(state_));
+    AppendFormat(dumpString, "    - pid: %d, isSystemApp: %u.\n",
+        callerPid_, static_cast<uint32_t>(isSystemApp_));
     AppendFormat(dumpString, "    - pid: %d, Streams in session are:\n", callerPid_);
     for (auto &it : streamsInSession_) {
         AppendFormat(dumpString, "        - StreamId is: %u, streamType is: %u\n",
@@ -204,7 +180,6 @@ void AudioSession::Dump(std::string &dumpString)
 
 int32_t AudioSession::Activate(const AudioSessionStrategy strategy)
 {
-    std::lock_guard<std::mutex> lock(sessionMutex_);
     strategy_ = strategy;
     state_ = AudioSessionState::SESSION_ACTIVE;
     AUDIO_INFO_LOG("Audio session state change: pid %{public}d, state %{public}d",
@@ -253,7 +228,6 @@ int32_t AudioSession::Deactivate()
 {
     CHECK_AND_RETURN_RET(state_ != AudioSessionState::SESSION_DEACTIVE, SUCCESS);
 
-    std::lock_guard<std::mutex> lock(sessionMutex_);
     state_ = AudioSessionState::SESSION_DEACTIVE;
 
     if (defaultDeviceType_ != DEVICE_TYPE_INVALID) {
@@ -343,7 +317,6 @@ int32_t AudioSession::EnableDefaultDevice()
 
 bool AudioSession::GetAndClearNeedToFetchFlag()
 {
-    std::lock_guard<std::mutex> lock(sessionMutex_);
     bool ret = needToFetch_;
     needToFetch_ = false;
     return ret;
@@ -367,42 +340,18 @@ StreamUsage AudioSession::GetStreamUsageInner()
 
 AudioSessionStrategy AudioSession::GetSessionStrategy()
 {
-    std::lock_guard<std::mutex> lock(sessionMutex_);
     AUDIO_INFO_LOG("GetSessionStrategy: pid %{public}d, strategy_.concurrencyMode %{public}d",
         callerPid_, static_cast<int32_t>(strategy_.concurrencyMode));
     return strategy_;
 }
 
-// For audio session v2
-bool AudioSession::ShouldExcludeStreamType(const AudioInterrupt &audioInterrupt)
-{
-    bool isExcludedStream = audioInterrupt.audioFocusType.streamType == STREAM_NOTIFICATION ||
-                            audioInterrupt.audioFocusType.streamType == STREAM_DTMF ||
-                            audioInterrupt.audioFocusType.streamType == STREAM_ALARM ||
-                            audioInterrupt.audioFocusType.streamType == STREAM_VOICE_CALL_ASSISTANT ||
-                            audioInterrupt.audioFocusType.streamType == STREAM_ULTRASONIC ||
-                            audioInterrupt.audioFocusType.streamType == STREAM_ACCESSIBILITY;
-    if (isExcludedStream) {
-        return true;
-    }
-
-    bool isExcludedStreamType = audioInterrupt.audioFocusType.sourceType != SOURCE_TYPE_INVALID;
-    if (isExcludedStreamType) {
-        return true;
-    }
-
-    return false;
-}
-
 bool AudioSession::IsAudioSessionEmpty()
 {
-    std::lock_guard<std::mutex> lock(sessionMutex_);
     return streamsInSession_.size() == 0;
 }
 
 bool AudioSession::IsAudioRendererEmpty()
 {
-    std::lock_guard<std::mutex> lock(sessionMutex_);
     for (const auto &iter : streamsInSession_) {
         if (iter.audioFocusType.streamType != STREAM_DEFAULT) {
             return false;
@@ -420,7 +369,6 @@ bool AudioSession::IsLegalDevice(const DeviceType deviceType)
 
 int32_t AudioSession::SetSessionDefaultOutputDevice(const DeviceType &deviceType)
 {
-    std::lock_guard<std::mutex> lock(sessionMutex_);
     AUDIO_INFO_LOG("The session default output device is set to %{public}d", deviceType);
     if (!IsLegalDevice(deviceType)) {
         AUDIO_INFO_LOG("The deviceType is illegal, the default device will not be changed.");
@@ -434,13 +382,11 @@ int32_t AudioSession::SetSessionDefaultOutputDevice(const DeviceType &deviceType
 
 void AudioSession::GetSessionDefaultOutputDevice(DeviceType &deviceType)
 {
-    std::lock_guard<std::mutex> lock(sessionMutex_);
     deviceType = defaultDeviceType_;
 }
 
 bool AudioSession::IsStreamContainedInCurrentSession(const uint32_t &streamId)
 {
-    std::lock_guard<std::mutex> lock(sessionMutex_);
     for (const auto &streamInfo : streamsInSession_) {
         if (streamInfo.streamId == streamId) {
             return true;
@@ -463,36 +409,32 @@ bool AudioSession::IsCurrentDevicePrivateDevice(const std::shared_ptr<AudioDevic
 }
 
 bool AudioSession::IsRecommendToStopAudio(
-    const std::shared_ptr<AudioPolicyServerHandler::EventContextObj> eventContextObj)
+    AudioStreamDeviceChangeReason changeReason,
+    const std::shared_ptr<AudioDeviceDescriptor> descriptor)
 {
     bool ret = false;
 
-    if ((eventContextObj == nullptr) || (eventContextObj->reason_ == AudioStreamDeviceChangeReason::OVERRODE) ||
-        (eventContextObj->descriptor == nullptr)) {
+    if ((changeReason == AudioStreamDeviceChangeReason::OVERRODE) || (descriptor == nullptr)) {
         return ret;
     }
 
-    std::lock_guard<std::mutex> lock(sessionMutex_);
-
     if (IsCurrentDevicePrivateDevice(std::make_shared<AudioDeviceDescriptor>(deviceDescriptor_)) &&
-        (!IsCurrentDevicePrivateDevice(eventContextObj->descriptor))) {
+        (!IsCurrentDevicePrivateDevice(descriptor))) {
         ret = true;
     }
 
-    deviceDescriptor_ = AudioDeviceDescriptor(eventContextObj->descriptor);
+    deviceDescriptor_ = AudioDeviceDescriptor(descriptor);
     return ret;
 }
 
 bool AudioSession::IsSessionOutputDeviceChanged(const std::shared_ptr<AudioDeviceDescriptor> desc)
 {
-    std::lock_guard<std::mutex> lock(sessionMutex_);
     CHECK_AND_RETURN_RET_LOG(desc != nullptr, true, "input device desc is nullptr");
     return deviceDescriptor_.IsSameDeviceDescPtr(desc);
 }
 
 bool AudioSession::IsSessionInputDeviceChanged(const std::shared_ptr<AudioDeviceDescriptor> desc)
 {
-    std::lock_guard<std::mutex> lock(sessionMutex_);
     CHECK_AND_RETURN_RET_LOG(desc != nullptr, true, "input device desc is nullptr");
     CHECK_AND_RETURN_RET(!inputDeviceDescriptor_.IsSameDeviceDescPtr(desc), true);
     inputDeviceDescriptor_ = AudioDeviceDescriptor(desc);
@@ -501,7 +443,6 @@ bool AudioSession::IsSessionInputDeviceChanged(const std::shared_ptr<AudioDevice
 
 StreamUsage AudioSession::GetSessionStreamUsage()
 {
-    std::lock_guard<std::mutex> lock(sessionMutex_);
     return GetStreamUsageInner();
 }
 
@@ -521,5 +462,15 @@ bool AudioSession::IsBackGroundApp(void)
     return state == static_cast<uint8_t>(AppExecFwk::AppProcessState::APP_STATE_BACKGROUND);
 }
 
+void AudioSession::MarkSystemApp(void)
+{
+    isSystemApp_ = true;
+}
+
+bool AudioSession::IsSystemApp(void) const
+{
+    return isSystemApp_;
+}
+
 } // namespace AudioStandard
 } // namespace OHOS
\ No newline at end of file
diff --git a/services/audio_policy/server/domain/session/src/audio_session_service.cpp b/services/audio_policy/server/domain/session/src/audio_session_service.cpp
index 62e92ad334ec1c411c8936072b8c07d0683474ac..9c22ff92490a5b5ed46ed35e4e4d4fb175caf330 100644
--- a/services/audio_policy/server/domain/session/src/audio_session_service.cpp
+++ b/services/audio_policy/server/domain/session/src/audio_session_service.cpp
@@ -23,6 +23,7 @@
 #include "audio_stream_id_allocator.h"
 #include "audio_stream_collector.h"
 #include "ipc_skeleton.h"
+#include "audio_session_device_info.h"
 
 namespace OHOS {
 namespace AudioStandard {
@@ -59,12 +60,6 @@ AudioSessionService::~AudioSessionService()
 {
 }
 
-std::shared_ptr<AudioSessionService> AudioSessionService::GetAudioSessionService()
-{
-    static std::shared_ptr<AudioSessionService> audioSessionService = std::make_shared<AudioSessionService>();
-    return audioSessionService;
-}
-
 bool AudioSessionService::IsSameTypeForAudioSession(const AudioStreamType incomingType,
     const AudioStreamType existedType)
 {
@@ -81,33 +76,27 @@ int32_t AudioSessionService::ActivateAudioSession(const int32_t callerPid, const
         callerPid, static_cast<int32_t>(strategy.concurrencyMode));
     std::lock_guard<std::mutex> lock(sessionServiceMutex_);
 
-    if (sessionMap_.count(callerPid) != 0) {
-        // The audio session of the callerPid is already created. The strategy will be updated.
-        AUDIO_INFO_LOG("The audio seesion of pid %{public}d has already been created! Update strategy.", callerPid);
-    } else {
-        sessionMap_[callerPid] = std::make_shared<AudioSession>(callerPid, strategy, shared_from_this());
-    }
-
-    if (sessionMap_[callerPid] == nullptr) {
-        AUDIO_ERR_LOG("Create audio seesion fail, pid: %{public}d!", callerPid);
+    auto audioSession = CreateAudioSession(callerPid, strategy);
+    if (audioSession == nullptr) {
+        AUDIO_ERR_LOG("Create audio session fail, pid: %{public}d!", callerPid);
         return ERROR;
     }
 
-    if (sessionMap_[callerPid]->IsSceneParameterSet()) {
+    if (audioSession->IsSceneParameterSet()) {
         GenerateFakeStreamId(callerPid);
     }
 
-    sessionMap_[callerPid]->Activate(strategy);
+    audioSession->Activate(strategy);
 
     StopMonitor(callerPid);
-    if (sessionMap_[callerPid]->IsAudioSessionEmpty()) {
+    if (audioSession->IsAudioSessionEmpty()) {
         // session v1 60s
-        if (!sessionMap_[callerPid]->IsSceneParameterSet()) {
+        if (!audioSession->IsSceneParameterSet()) {
             StartMonitor(callerPid, AUDIO_SESSION_TIME_OUT_DURATION_S);
         }
 
         // session v2 background 10s
-        if (sessionMap_[callerPid]->IsSceneParameterSet() && sessionMap_[callerPid]->IsBackGroundApp()) {
+        if (audioSession->IsSceneParameterSet() && audioSession->IsBackGroundApp()) {
             StartMonitor(callerPid, AUDIO_SESSION_SCENE_TIME_OUT_DURATION_S);
         }
     }
@@ -125,18 +114,14 @@ int32_t AudioSessionService::DeactivateAudioSession(const int32_t callerPid)
 int32_t AudioSessionService::DeactivateAudioSessionInternal(const int32_t callerPid, bool isSessionTimeout)
 {
     AUDIO_INFO_LOG("DeactivateAudioSessionInternal: callerPid %{public}d", callerPid);
-    if (sessionMap_.count(callerPid) == 0) {
+    auto session = sessionMap_.find(callerPid);
+    if (session == sessionMap_.end()) {
         // The audio session of the callerPid is not existed or has been released.
         AUDIO_ERR_LOG("The audio seesion of pid %{public}d is not found!", callerPid);
         return ERR_ILLEGAL_STATE;
     }
 
-    if (sessionMap_[callerPid] == nullptr) {
-        AUDIO_ERR_LOG("The audio seesion obj of pid %{public}d is nullptr!", callerPid);
-        return ERR_ILLEGAL_STATE;
-    }
-
-    sessionMap_[callerPid]->Deactivate();
+    session->second->Deactivate();
     sessionMap_.erase(callerPid);
 
     if (!isSessionTimeout) {
@@ -149,12 +134,14 @@ int32_t AudioSessionService::DeactivateAudioSessionInternal(const int32_t caller
 bool AudioSessionService::IsAudioSessionActivated(const int32_t callerPid)
 {
     std::lock_guard<std::mutex> lock(sessionServiceMutex_);
-    if (sessionMap_.count(callerPid) == 0 || sessionMap_[callerPid] == nullptr) {
+    auto session = sessionMap_.find(callerPid);
+    if (session == sessionMap_.end()) {
         // The audio session of the callerPid is not existed or has been released.
         AUDIO_WARNING_LOG("The audio seesion of pid %{public}d is not found!", callerPid);
         return false;
     }
-    return sessionMap_[callerPid]->IsActivated();
+
+    return session->second->IsActivated();
 }
 
 int32_t AudioSessionService::SetSessionTimeOutCallback(
@@ -170,17 +157,6 @@ int32_t AudioSessionService::SetSessionTimeOutCallback(
     return SUCCESS;
 }
 
-std::shared_ptr<AudioSession> AudioSessionService::GetAudioSessionByPid(const int32_t callerPid)
-{
-    AUDIO_INFO_LOG("GetAudioSessionByPid: callerPid %{public}d", callerPid);
-    std::lock_guard<std::mutex> lock(sessionServiceMutex_);
-    if (sessionMap_.count(callerPid) == 0) {
-        AUDIO_WARNING_LOG("The audio sesion of pid %{public}d is not found!", callerPid);
-        return nullptr;
-    }
-    return sessionMap_[callerPid];
-}
-
 // Audio session monitor callback
 void AudioSessionService::OnAudioSessionTimeOut(int32_t callerPid)
 {
@@ -197,33 +173,41 @@ void AudioSessionService::OnAudioSessionTimeOut(int32_t callerPid)
     cb->OnSessionTimeout(callerPid);
 }
 
-std::shared_ptr<AudioSessionStateMonitor> AudioSessionService::GetSelfSharedPtr()
+std::shared_ptr<AudioSession> AudioSessionService::CreateAudioSession(
+    int32_t callerPid, AudioSessionStrategy strategy)
 {
-    return shared_from_this();
+    std::shared_ptr<AudioSession> audioSession = nullptr;
+    auto session = sessionMap_.find(callerPid);
+    if (session != sessionMap_.end()) {
+        audioSession = session->second;
+        AUDIO_INFO_LOG("The audio seesion of pid %{public}d has already been created", callerPid);
+    } else {
+        audioSession = std::make_shared<AudioSession>(callerPid, strategy, *this);
+        CHECK_AND_RETURN_RET_LOG(audioSession != nullptr, audioSession, "Create AudioSession fail");
+        sessionMap_[callerPid] = audioSession;
+    }
+
+    return audioSession;
 }
 
 int32_t AudioSessionService::SetAudioSessionScene(int32_t callerPid, AudioSessionScene scene)
 {
     std::lock_guard<std::mutex> lock(sessionServiceMutex_);
-    if (sessionMap_.count(callerPid) != 0 && sessionMap_[callerPid] != nullptr) {
-        // The audio session of the callerPid is already created. The strategy will be updated.
-        AUDIO_INFO_LOG("The audio seesion of pid %{public}d has already been created! Update scene.", callerPid);
-    } else {
-        AudioSessionStrategy strategy;
-        strategy.concurrencyMode = AudioConcurrencyMode::DEFAULT;
-        sessionMap_[callerPid] = std::make_shared<AudioSession>(callerPid, strategy, shared_from_this());
-        CHECK_AND_RETURN_RET_LOG(sessionMap_[callerPid] != nullptr, ERROR, "Create AudioSession fail");
+    auto audioSession = CreateAudioSession(callerPid);
+    if (audioSession == nullptr) {
+        AUDIO_ERR_LOG("Create audio session fail, pid: %{public}d!", callerPid);
+        return ERROR;
     }
 
-    return sessionMap_[callerPid]->SetAudioSessionScene(scene);
+    return audioSession->SetAudioSessionScene(scene);
 }
 
 StreamUsage AudioSessionService::GetAudioSessionStreamUsage(int32_t callerPid)
 {
     std::lock_guard<std::mutex> lock(sessionServiceMutex_);
     auto session = sessionMap_.find(callerPid);
-    if (session != sessionMap_.end() && sessionMap_[callerPid] != nullptr) {
-        return sessionMap_[callerPid]->GetSessionStreamUsage();
+    if (session != sessionMap_.end()) {
+        return session->second->GetSessionStreamUsage();
     }
 
     return STREAM_USAGE_INVALID;
@@ -232,13 +216,29 @@ StreamUsage AudioSessionService::GetAudioSessionStreamUsage(int32_t callerPid)
 bool AudioSessionService::IsAudioSessionFocusMode(int32_t callerPid)
 {
     std::lock_guard<std::mutex> lock(sessionServiceMutex_);
+    return IsAudioSessionFocusModeInner(callerPid);
+}
+
+bool AudioSessionService::IsAudioSessionFocusModeInner(int32_t callerPid)
+{
     auto session = sessionMap_.find(callerPid);
-    return session != sessionMap_.end() && sessionMap_[callerPid] != nullptr &&
-           sessionMap_[callerPid]->IsSceneParameterSet() && sessionMap_[callerPid]->IsActivated();
+    return session != sessionMap_.end() &&
+           session->second->IsSceneParameterSet() &&
+           session->second->IsActivated();
 }
 
-// For audio session v2
 bool AudioSessionService::ShouldExcludeStreamType(const AudioInterrupt &audioInterrupt)
+{
+    std::lock_guard<std::mutex> lock(sessionServiceMutex_);
+    if (!IsAudioSessionFocusModeInner(audioInterrupt.pid)) {
+        return false;
+    }
+
+    return ShouldExcludeStreamTypeInner(audioInterrupt);
+}
+
+// For audio session v2
+bool AudioSessionService::ShouldExcludeStreamTypeInner(const AudioInterrupt &audioInterrupt)
 {
     bool isExcludedStream = audioInterrupt.audioFocusType.streamType == STREAM_NOTIFICATION ||
                             audioInterrupt.audioFocusType.streamType == STREAM_DTMF ||
@@ -258,22 +258,18 @@ bool AudioSessionService::ShouldExcludeStreamType(const AudioInterrupt &audioInt
     return false;
 }
 
+
 bool AudioSessionService::ShouldBypassFocusForStream(const AudioInterrupt &audioInterrupt)
 {
-    if (!IsAudioSessionFocusMode(audioInterrupt.pid)) {
+    std::lock_guard<std::mutex> lock(sessionServiceMutex_);
+    if (!IsAudioSessionFocusModeInner(audioInterrupt.pid)) {
         return false;
     }
 
-    if (ShouldExcludeStreamType(audioInterrupt)) {
+    if (ShouldExcludeStreamTypeInner(audioInterrupt)) {
         return false;
     }
 
-    std::lock_guard<std::mutex> lock(sessionServiceMutex_);
-    auto session = sessionMap_.find(audioInterrupt.pid);
-    if (session != sessionMap_.end() && sessionMap_[audioInterrupt.pid] != nullptr) {
-        sessionMap_[audioInterrupt.pid]->AddStreamInfo(audioInterrupt);
-    }
-
     return true;
 }
 
@@ -312,10 +308,10 @@ AudioInterrupt AudioSessionService::GenerateFakeAudioInterrupt(int32_t callerPid
     fakeAudioInterrupt.uid = IPCSkeleton::GetCallingUid();
     fakeAudioInterrupt.isAudioSessionInterrupt = true;
     auto session = sessionMap_.find(callerPid);
-    if (session != sessionMap_.end() && sessionMap_[callerPid] != nullptr) {
-        fakeAudioInterrupt.streamId = sessionMap_[callerPid]->GetFakeStreamId();
-        fakeAudioInterrupt.audioFocusType.streamType = sessionMap_[callerPid]->GetFakeStreamType();
-        fakeAudioInterrupt.streamUsage = sessionMap_[callerPid]->GetSessionStreamUsage();
+    if (session != sessionMap_.end()) {
+        fakeAudioInterrupt.streamId = session->second->GetFakeStreamId();
+        fakeAudioInterrupt.audioFocusType.streamType = session->second->GetFakeStreamType();
+        fakeAudioInterrupt.streamUsage = session->second->GetSessionStreamUsage();
     } else {
         AUDIO_ERR_LOG("This failure should not have occurred, possibly due to calling the function incorrectly!");
     }
@@ -357,34 +353,82 @@ void AudioSessionService::GenerateFakeStreamId(int32_t callerPid)
     uint32_t fakeStreamId = AudioStreamIdAllocator::GetAudioStreamIdAllocator().GenerateStreamId();
 
     auto session = sessionMap_.find(callerPid);
-    if (session != sessionMap_.end() && sessionMap_[callerPid] != nullptr) {
-        sessionMap_[callerPid]->SaveFakeStreamId(fakeStreamId);
+    if (session != sessionMap_.end()) {
+        session->second->SaveFakeStreamId(fakeStreamId);
     }
 }
 
-void AudioSessionService::RemoveStreamInfo(const AudioInterrupt &audioInterrupt)
+void AudioSessionService::AddStreamInfo(const AudioInterrupt &audioInterrupt)
 {
+    std::lock_guard<std::mutex> lock(sessionServiceMutex_);
     // No need to handle fake focus.
     if (audioInterrupt.isAudioSessionInterrupt) {
         return;
     }
 
-    std::lock_guard<std::mutex> lock(sessionServiceMutex_);
-    auto session = sessionMap_.find(audioInterrupt.pid);
-    if (session == sessionMap_.end()) {
+    if (IsAudioSessionFocusModeInner(audioInterrupt.pid) && ShouldExcludeStreamTypeInner(audioInterrupt)) {
         return;
     }
-    return session->second->RemoveStreamInfo(audioInterrupt.streamId);
+
+    auto session = sessionMap_.find(audioInterrupt.pid);
+    if (session != sessionMap_.end()) {
+        session->second->AddStreamInfo(audioInterrupt);
+    }
+}
+
+void AudioSessionService::RemoveStreamInfo(const int32_t callerPid, const uint32_t streamId)
+{
+    std::lock_guard<std::mutex> lock(sessionServiceMutex_);
+    auto session = sessionMap_.find(callerPid);
+    if (session != sessionMap_.end()) {
+        session->second->RemoveStreamInfo(streamId);
+    }
 }
 
 void AudioSessionService::ClearStreamInfo(const int32_t callerPid)
 {
     std::lock_guard<std::mutex> lock(sessionServiceMutex_);
-    if ((sessionMap_.count(callerPid) == 0) || (sessionMap_[callerPid] == nullptr)) {
-        return;
+    auto session = sessionMap_.find(callerPid);
+    if (session != sessionMap_.end()) {
+        session->second->ClearStreamInfo();
+    }
+}
+
+bool AudioSessionService::IsStreamInfoEmpty(const int32_t callerPid)
+{
+    std::lock_guard<std::mutex> lock(sessionServiceMutex_);
+    auto session = sessionMap_.find(callerPid);
+    if (session == sessionMap_.end()) {
+        return true;
+    }
+
+    return session->second->IsAudioSessionEmpty();
+}
+
+bool AudioSessionService::IsAudioRendererEmpty(const int32_t callerPid)
+{
+    std::lock_guard<std::mutex> lock(sessionServiceMutex_);
+    auto session = sessionMap_.find(callerPid);
+    if (session == sessionMap_.end()) {
+        return true;
+    }
+
+    return session->second->IsAudioRendererEmpty();
+}
+
+AudioConcurrencyMode AudioSessionService::GetSessionStrategy(int32_t callerPid)
+{
+    std::lock_guard<std::mutex> lock(sessionServiceMutex_);
+    auto session = sessionMap_.find(callerPid);
+    if (session == sessionMap_.end()) {
+        return AudioConcurrencyMode::INVALID;
+    }
+
+    if (!session->second->IsActivated()) {
+        return AudioConcurrencyMode::INVALID;
     }
 
-    sessionMap_[callerPid]->ClearStreamInfo();
+    return (session->second->GetSessionStrategy()).concurrencyMode;
 }
 
 void AudioSessionService::AudioSessionInfoDump(std::string &dumpString)
@@ -410,29 +454,28 @@ void AudioSessionService::AudioSessionInfoDump(std::string &dumpString)
 int32_t AudioSessionService::SetSessionDefaultOutputDevice(const int32_t callerPid, const DeviceType &deviceType)
 {
     std::lock_guard<std::mutex> lock(sessionServiceMutex_);
-    if ((sessionMap_.count(callerPid) > 0) && (sessionMap_[callerPid] != nullptr)) {
-        AUDIO_INFO_LOG("SetSessionDefaultOutputDevice: callerPid %{public}d, deviceType %{public}d",
-            callerPid, static_cast<int32_t>(deviceType));
-    } else {
-        AudioSessionStrategy strategy;
-        strategy.concurrencyMode = AudioConcurrencyMode::DEFAULT;
-        sessionMap_[callerPid] = std::make_shared<AudioSession>(callerPid, strategy, shared_from_this());
-        CHECK_AND_RETURN_RET_LOG(sessionMap_[callerPid] != nullptr, ERROR, "Create AudioSession fail");
+    AUDIO_INFO_LOG("SetSessionDefaultOutputDevice: callerPid %{public}d, deviceType %{public}d",
+        callerPid, static_cast<int32_t>(deviceType));
+
+    auto audioSession = CreateAudioSession(callerPid);
+    if (audioSession == nullptr) {
+        AUDIO_ERR_LOG("Create audio session fail, pid: %{public}d!", callerPid);
+        return ERROR;
     }
 
-    return sessionMap_[callerPid]->SetSessionDefaultOutputDevice(deviceType);
+    return audioSession->SetSessionDefaultOutputDevice(deviceType);
 }
 
 DeviceType AudioSessionService::GetSessionDefaultOutputDevice(const int32_t callerPid)
 {
     std::lock_guard<std::mutex> lock(sessionServiceMutex_);
-    if ((sessionMap_.count(callerPid) > 0) && (sessionMap_[callerPid] != nullptr)) {
-        DeviceType deviceType;
-        sessionMap_[callerPid]->GetSessionDefaultOutputDevice(deviceType);
-        return deviceType;
+    DeviceType deviceType = DEVICE_TYPE_INVALID;
+    auto session = sessionMap_.find(callerPid);
+    if (session != sessionMap_.end()) {
+        session->second->GetSessionDefaultOutputDevice(deviceType);
     }
 
-    return DEVICE_TYPE_INVALID;
+    return deviceType;
 }
 
 bool AudioSessionService::IsStreamAllowedToSetDevice(const uint32_t streamId)
@@ -458,8 +501,9 @@ bool AudioSessionService::IsStreamAllowedToSetDevice(const uint32_t streamId)
 bool AudioSessionService::IsSessionNeedToFetchOutputDevice(const int32_t callerPid)
 {
     std::lock_guard<std::mutex> lock(sessionServiceMutex_);
-    if ((sessionMap_.count(callerPid) != 0) && (sessionMap_[callerPid] != nullptr)) {
-        return sessionMap_[callerPid]->GetAndClearNeedToFetchFlag();
+    auto session = sessionMap_.find(callerPid);
+    if (session != sessionMap_.end()) {
+        return session->second->GetAndClearNeedToFetchFlag();
     }
 
     return false;
@@ -468,28 +512,97 @@ bool AudioSessionService::IsSessionNeedToFetchOutputDevice(const int32_t callerP
 void AudioSessionService::NotifyAppStateChange(const int32_t pid, bool isBackState)
 {
     std::lock_guard<std::mutex> lock(sessionServiceMutex_);
-    if (sessionMap_.count(pid) == 0) {
-        return;
-    }
-
-    if (sessionMap_[pid] == nullptr) {
-        AUDIO_WARNING_LOG("audio session is nullptr, pid: %{public}d!", pid);
+    auto session = sessionMap_.find(pid);
+    if (session == sessionMap_.end()) {
         return;
     }
 
     // v2 foreground
-    if (!isBackState && sessionMap_[pid]->IsSceneParameterSet()) {
+    if (!isBackState && session->second->IsSceneParameterSet()) {
         StopMonitor(pid);
         return;
     }
 
     // v2 background
-    if (sessionMap_[pid]->IsActivated() &&
-        sessionMap_[pid]->IsSceneParameterSet() &&
-        sessionMap_[pid]->IsAudioSessionEmpty()) {
+    if (session->second->IsActivated() &&
+        session->second->IsSceneParameterSet() &&
+        session->second->IsAudioSessionEmpty()) {
         StartMonitor(pid, AUDIO_SESSION_SCENE_TIME_OUT_DURATION_S);
     }
 }
 
+int32_t AudioSessionService::FillCurrentOutputDeviceChangedEvent(
+    int32_t callerPid,
+    AudioStreamDeviceChangeReason changeReason,
+    const std::shared_ptr<AudioDeviceDescriptor> descriptor,
+    CurrentOutputDeviceChangedEvent &deviceChangedEvent)
+{
+    std::lock_guard<std::mutex> lock(sessionServiceMutex_);
+    auto session = sessionMap_.find(callerPid);
+    if (session == sessionMap_.end()) {
+        return ERROR;
+    }
+
+    if (deviceChangedEvent.devices.size() == 0) {
+        AUDIO_ERR_LOG("Device info is empty, pid: %{public}d!", callerPid);
+        return ERROR;
+    }
+
+    CHECK_AND_RETURN_RET((!session->second->IsSessionOutputDeviceChanged(deviceChangedEvent.devices[0]) ||
+        (changeReason == AudioStreamDeviceChangeReason::AUDIO_SESSION_ACTIVATE)), ERROR,
+        "device of session %{public}d is not changed", callerPid);
+
+    deviceChangedEvent.changeReason = changeReason;
+    deviceChangedEvent.recommendedAction = session->second->IsRecommendToStopAudio(changeReason, descriptor) ?
+        OutputDeviceChangeRecommendedAction::RECOMMEND_TO_STOP :
+        OutputDeviceChangeRecommendedAction::RECOMMEND_TO_CONTINUE;
+
+    return SUCCESS;
+}
+
+bool AudioSessionService::IsSessionInputDeviceChanged(
+    int32_t callerPid, const std::shared_ptr<AudioDeviceDescriptor> desc)
+{
+    std::lock_guard<std::mutex> lock(sessionServiceMutex_);
+    auto session = sessionMap_.find(callerPid);
+    if (session != sessionMap_.end()) {
+        return session->second->IsSessionInputDeviceChanged(desc);
+    }
+
+    return false;
+}
+
+void AudioSessionService::MarkSystemApp(int32_t pid)
+{
+    std::lock_guard<std::mutex> lock(sessionServiceMutex_);
+    auto session = sessionMap_.find(pid);
+    if (session != sessionMap_.end()) {
+        session->second->MarkSystemApp();
+    }
+}
+
+bool AudioSessionService::IsSystemApp(int32_t pid)
+{
+    std::lock_guard<std::mutex> lock(sessionServiceMutex_);
+    auto session = sessionMap_.find(pid);
+    if (session != sessionMap_.end()) {
+        return session->second->IsActivated() && session->second->IsSystemApp();
+    }
+
+    return false;
+}
+
+bool AudioSessionService::IsSystemAppWithMixStrategy(int32_t pid)
+{
+    std::lock_guard<std::mutex> lock(sessionServiceMutex_);
+    auto session = sessionMap_.find(pid);
+    if (session != sessionMap_.end()) {
+        return session->second->IsActivated() && session->second->IsSystemApp() &&
+               session->second->GetSessionStrategy().concurrencyMode == AudioConcurrencyMode::MIX_WITH_OTHERS;
+    }
+
+    return false;
+}
+
 } // namespace AudioStandard
 } // namespace OHOS
diff --git a/services/audio_policy/server/domain/session/src/audio_session_state_monitor.cpp b/services/audio_policy/server/domain/session/src/audio_session_state_monitor.cpp
index 09904a18a00ebd5a1b361fa6abcef19b0d6d1d7c..5702acea755d6a226d9f56b19c372db66877c38e 100644
--- a/services/audio_policy/server/domain/session/src/audio_session_state_monitor.cpp
+++ b/services/audio_policy/server/domain/session/src/audio_session_state_monitor.cpp
@@ -24,24 +24,19 @@ namespace AudioStandard {
 
 class AudioSessionStateMonitorCallback : public AudioPolicyStateMonitorCallback {
 public:
-    AudioSessionStateMonitorCallback(int32_t pid, const std::shared_ptr<AudioSessionStateMonitor> &stateMonitor)
+    AudioSessionStateMonitorCallback(int32_t pid, AudioSessionStateMonitor &stateMonitor)
         : pid(pid), stateMonitor_(stateMonitor)
     {}
     
     void OnTimeOut() override
     {
-        auto monitor = stateMonitor_.lock();
-        if (monitor == nullptr) {
-            AUDIO_ERR_LOG("stateMonitor_ is nullptr");
-            return;
-        }
-        monitor->OnAudioSessionTimeOut(pid);
-        monitor->RemoveFromMonitorMap(pid);
+        stateMonitor_.OnAudioSessionTimeOut(pid);
+        stateMonitor_.RemoveFromMonitorMap(pid);
     }
 
 private:
     int32_t pid;
-    std::weak_ptr<AudioSessionStateMonitor> stateMonitor_;
+    AudioSessionStateMonitor &stateMonitor_;
 };
 
 void AudioSessionStateMonitor::StartMonitor(int32_t pid, time_t duration)
@@ -53,7 +48,7 @@ void AudioSessionStateMonitor::StartMonitor(int32_t pid, time_t duration)
     }
     lock.unlock();
 
-    auto cb = std::make_shared<AudioSessionStateMonitorCallback>(pid, GetSelfSharedPtr());
+    auto cb = std::make_shared<AudioSessionStateMonitorCallback>(pid, *this);
     int32_t cbId = DelayedSingleton<AudioPolicyStateMonitor>::GetInstance()->RegisterCallback(
         cb, duration, CallbackType::ONE_TIME);
     if (cbId == INVALID_CB_ID) {
diff --git a/services/audio_policy/server/domain/session/test/unittest/audio_session_new_unit_test/include/audio_session_new_unit_test.h b/services/audio_policy/server/domain/session/test/unittest/audio_session_new_unit_test/include/audio_session_new_unit_test.h
index 92a99d2f4c0c9390b4438fe7bda6e7a8ff9a8ef8..7e46c551f6acb9866ead628c6e34bd680318cb0c 100644
--- a/services/audio_policy/server/domain/session/test/unittest/audio_session_new_unit_test/include/audio_session_new_unit_test.h
+++ b/services/audio_policy/server/domain/session/test/unittest/audio_session_new_unit_test/include/audio_session_new_unit_test.h
@@ -30,6 +30,8 @@ public:
     void SetUp(void);
     // TearDown: Called after each test cases
     void TearDown(void);
+private:
+    AudioSessionService &audioSessionService_ {OHOS::Singleton<AudioSessionService>::GetInstance()};
 };
 } // namespace AudioStandard
 } // namespace OHOS
diff --git a/services/audio_policy/server/domain/session/test/unittest/audio_session_new_unit_test/src/audio_session_new_unit_test.cpp b/services/audio_policy/server/domain/session/test/unittest/audio_session_new_unit_test/src/audio_session_new_unit_test.cpp
index d9b697098c28beec99cbbacbbb6ce9ee8b119f83..a97e5e1272a5429157e469bafeb15a50eedc865e 100644
--- a/services/audio_policy/server/domain/session/test/unittest/audio_session_new_unit_test/src/audio_session_new_unit_test.cpp
+++ b/services/audio_policy/server/domain/session/test/unittest/audio_session_new_unit_test/src/audio_session_new_unit_test.cpp
@@ -29,7 +29,11 @@ namespace AudioStandard {
 void AudioSessionNewUnitTest::SetUpTestCase(void) {}
 void AudioSessionNewUnitTest::TearDownTestCase(void) {}
 void AudioSessionNewUnitTest::SetUp(void) {}
-void AudioSessionNewUnitTest::TearDown(void) {}
+void AudioSessionNewUnitTest::TearDown(void)
+{
+    audioSessionService_.sessionMap_.clear();
+    audioSessionService_.timeOutCallback_.reset();
+}
 
 /**
 * @tc.name  : Test SetAudioSessionScene
@@ -40,8 +44,7 @@ HWTEST_F(AudioSessionNewUnitTest, SetAudioSessionScene_001, TestSize.Level4)
 {
     int32_t callerPid = 1;
     AudioSessionStrategy strategy;
-    std::shared_ptr<AudioSessionStateMonitor> audioSessionStateMonitor = std::make_shared<AudioSessionService>();
-    auto audioSession = std::make_shared<AudioSession>(callerPid, strategy, audioSessionStateMonitor);
+    auto audioSession = std::make_shared<AudioSession>(callerPid, strategy, audioSessionService_);
 
     AudioSessionScene scene = AudioSessionScene::GAME;
     int32_t ret = audioSession->SetAudioSessionScene(scene);
@@ -57,8 +60,7 @@ HWTEST_F(AudioSessionNewUnitTest, SetAudioSessionScene_002, TestSize.Level4)
 {
     int32_t callerPid = 1;
     AudioSessionStrategy strategy;
-    std::shared_ptr<AudioSessionStateMonitor> audioSessionStateMonitor = std::make_shared<AudioSessionService>();
-    auto audioSession = std::make_shared<AudioSession>(callerPid, strategy, audioSessionStateMonitor);
+    auto audioSession = std::make_shared<AudioSession>(callerPid, strategy, audioSessionService_);
 
     AudioSessionScene scene = AudioSessionScene::VOICE_COMMUNICATION;
     int32_t ret = audioSession->SetAudioSessionScene(scene);
@@ -74,15 +76,14 @@ HWTEST_F(AudioSessionNewUnitTest, AddStreamInfo_001, TestSize.Level4)
 {
     int32_t callerPid = 1;
     AudioSessionStrategy strategy;
-    std::shared_ptr<AudioSessionStateMonitor> audioSessionStateMonitor = nullptr;
-    auto audioSession = std::make_shared<AudioSession>(callerPid, strategy, audioSessionStateMonitor);
+    auto audioSession = std::make_shared<AudioSession>(callerPid, strategy, audioSessionService_);
 
     AudioInterrupt audioInterrupt = {};
     audioInterrupt.streamId = 1;
     audioSession->state_ = AudioSessionState::SESSION_ACTIVE;
     audioSession->audioSessionScene_ = AudioSessionScene::GAME;
     audioInterrupt.audioFocusType.sourceType = SOURCE_TYPE_MIC;
-    audioSession->AddStreamInfo(audioInterrupt);
+    audioSessionService_.AddStreamInfo(audioInterrupt);
     EXPECT_TRUE(audioSession->IsAudioSessionEmpty());
 }
 
@@ -95,8 +96,7 @@ HWTEST_F(AudioSessionNewUnitTest, AddStreamInfo_002, TestSize.Level4)
 {
     int32_t callerPid = 1;
     AudioSessionStrategy strategy;
-    std::shared_ptr<AudioSessionStateMonitor> audioSessionStateMonitor = nullptr;
-    auto audioSession = std::make_shared<AudioSession>(callerPid, strategy, audioSessionStateMonitor);
+    auto audioSession = std::make_shared<AudioSession>(callerPid, strategy, audioSessionService_);
 
     AudioInterrupt audioInterrupt = {};
     audioInterrupt.streamId = 1;
@@ -117,8 +117,7 @@ HWTEST_F(AudioSessionNewUnitTest, RemoveStreamInfo_001, TestSize.Level4)
 {
     int32_t callerPid = 1;
     AudioSessionStrategy strategy;
-    std::shared_ptr<AudioSessionStateMonitor> audioSessionStateMonitor = nullptr;
-    auto audioSession = std::make_shared<AudioSession>(callerPid, strategy, audioSessionStateMonitor);
+    auto audioSession = std::make_shared<AudioSession>(callerPid, strategy, audioSessionService_);
 
     AudioInterrupt audioInterrupt = {};
     audioInterrupt.streamId = 1;
@@ -138,8 +137,7 @@ HWTEST_F(AudioSessionNewUnitTest, UpdateSingleVoipStreamDefaultOutputDevice_001,
 {
     int32_t callerPid = 1;
     AudioSessionStrategy strategy;
-    std::shared_ptr<AudioSessionStateMonitor> audioSessionStateMonitor = nullptr;
-    auto audioSession = std::make_shared<AudioSession>(callerPid, strategy, audioSessionStateMonitor);
+    auto audioSession = std::make_shared<AudioSession>(callerPid, strategy, audioSessionService_);
 
     AudioInterrupt audioInterrupt = {};
     audioInterrupt.streamId = 1;
@@ -160,8 +158,7 @@ HWTEST_F(AudioSessionNewUnitTest, EnableSingleVoipStreamDefaultOutputDevice_001,
 {
     int32_t callerPid = 1;
     AudioSessionStrategy strategy;
-    std::shared_ptr<AudioSessionStateMonitor> audioSessionStateMonitor = std::make_shared<AudioSessionService>();
-    auto audioSession = std::make_shared<AudioSession>(callerPid, strategy, audioSessionStateMonitor);
+    auto audioSession = std::make_shared<AudioSession>(callerPid, strategy, audioSessionService_);
     EXPECT_EQ(SUCCESS, audioSession->SetAudioSessionScene(AudioSessionScene::MEDIA));
 
     AudioInterrupt interrupt = {};
@@ -182,8 +179,7 @@ HWTEST_F(AudioSessionNewUnitTest, EnableSingleVoipStreamDefaultOutputDevice_002,
 {
     int32_t callerPid = 1;
     AudioSessionStrategy strategy;
-    std::shared_ptr<AudioSessionStateMonitor> audioSessionStateMonitor = std::make_shared<AudioSessionService>();
-    auto audioSession = std::make_shared<AudioSession>(callerPid, strategy, audioSessionStateMonitor);
+    auto audioSession = std::make_shared<AudioSession>(callerPid, strategy, audioSessionService_);
     EXPECT_EQ(SUCCESS, audioSession->SetAudioSessionScene(AudioSessionScene::MEDIA));
 
     AudioInterrupt interrupt = {};
@@ -204,8 +200,7 @@ HWTEST_F(AudioSessionNewUnitTest, EnableSingleVoipStreamDefaultOutputDevice_003,
 {
     int32_t callerPid = 1;
     AudioSessionStrategy strategy;
-    std::shared_ptr<AudioSessionStateMonitor> audioSessionStateMonitor = std::make_shared<AudioSessionService>();
-    auto audioSession = std::make_shared<AudioSession>(callerPid, strategy, audioSessionStateMonitor);
+    auto audioSession = std::make_shared<AudioSession>(callerPid, strategy, audioSessionService_);
     EXPECT_EQ(SUCCESS, audioSession->SetAudioSessionScene(AudioSessionScene::MEDIA));
 
     AudioInterrupt interrupt = {};
@@ -225,8 +220,7 @@ HWTEST_F(AudioSessionNewUnitTest, EnableSingleVoipStreamDefaultOutputDevice_004,
 {
     int32_t callerPid = 1;
     AudioSessionStrategy strategy;
-    std::shared_ptr<AudioSessionStateMonitor> audioSessionStateMonitor = std::make_shared<AudioSessionService>();
-    auto audioSession = std::make_shared<AudioSession>(callerPid, strategy, audioSessionStateMonitor);
+    auto audioSession = std::make_shared<AudioSession>(callerPid, strategy, audioSessionService_);
     EXPECT_EQ(SUCCESS, audioSession->SetAudioSessionScene(AudioSessionScene::MEDIA));
     
     AudioInterrupt interrupt = {};
@@ -263,26 +257,12 @@ HWTEST_F(AudioSessionNewUnitTest, IsRecommendToStopAudio_001, TestSize.Level1)
 {
     int32_t callerPid = 1;
     AudioSessionStrategy strategy;
-    std::shared_ptr<AudioSessionStateMonitor> audioSessionStateMonitor = std::make_shared<AudioSessionService>();
-    auto audioSession = std::make_shared<AudioSession>(callerPid, strategy, audioSessionStateMonitor);
-
+    auto audioSession = std::make_shared<AudioSession>(callerPid, strategy, audioSessionService_);
     auto validDescriptor = std::make_shared<AudioDeviceDescriptor>();
-
-    EXPECT_FALSE(audioSession->IsRecommendToStopAudio(nullptr));
-
-    auto eventContextObj = std::make_shared<AudioPolicyServerHandler::EventContextObj>();
-
-    eventContextObj->reason_ = AudioStreamDeviceChangeReason::OVERRODE;
-    eventContextObj->descriptor = validDescriptor;
-    EXPECT_FALSE(audioSession->IsRecommendToStopAudio(eventContextObj));
-
-    eventContextObj->reason_ = AudioStreamDeviceChangeReason::UNKNOWN;
-    eventContextObj->descriptor = nullptr;
-    EXPECT_FALSE(audioSession->IsRecommendToStopAudio(eventContextObj));
-
-    eventContextObj->reason_ = AudioStreamDeviceChangeReason::NEW_DEVICE_AVAILABLE;
-    eventContextObj->descriptor = validDescriptor;
-    EXPECT_FALSE(audioSession->IsRecommendToStopAudio(eventContextObj));
+    EXPECT_FALSE(audioSession->IsRecommendToStopAudio(AudioStreamDeviceChangeReason::OVERRODE, validDescriptor));
+    EXPECT_FALSE(audioSession->IsRecommendToStopAudio(AudioStreamDeviceChangeReason::UNKNOWN, nullptr));
+    EXPECT_FALSE(audioSession->IsRecommendToStopAudio(
+        AudioStreamDeviceChangeReason::NEW_DEVICE_AVAILABLE, validDescriptor));
 }
 
 } // namespace AudioStandard
diff --git a/services/audio_policy/server/infra/appclient/src/app_state_listener.cpp b/services/audio_policy/server/infra/appclient/src/app_state_listener.cpp
index 51d829601899d50eb1ac1f00dc1fef8a1eaaf7d6..bcd7e850f2e56f094660a5db0dc60dafceb8e8b4 100644
--- a/services/audio_policy/server/infra/appclient/src/app_state_listener.cpp
+++ b/services/audio_policy/server/infra/appclient/src/app_state_listener.cpp
@@ -66,11 +66,8 @@ void AppStateListener::OnAppStateChanged(const AppExecFwk::AppProcessData& appPr
             (appProcessData.appState == AppExecFwk::ApplicationState::APP_STATE_BACKGROUND));
     }
 
-    std::shared_ptr<AudioSessionService> sessionService = AudioSessionService::GetAudioSessionService();
-    if (sessionService != nullptr) {
-        sessionService->NotifyAppStateChange(appProcessData.pid,
-            (appProcessData.appState == AppExecFwk::ApplicationState::APP_STATE_BACKGROUND));
-    }
+    OHOS::Singleton<AudioSessionService>::GetInstance().NotifyAppStateChange(appProcessData.pid,
+        (appProcessData.appState == AppExecFwk::ApplicationState::APP_STATE_BACKGROUND));
 }
 
 void AppStateListener::HandleAppStateChange(int32_t pid, int32_t uid, int32_t state)
diff --git a/services/audio_policy/server/infra/async_action_handler/src/audio_policy_server_handler.cpp b/services/audio_policy/server/infra/async_action_handler/src/audio_policy_server_handler.cpp
index 58e59c4ec5555948a0aa32dcb745c94493c3e9fa..b6bcd11d203bc93dc82e58aef27b4cf2f8061814 100644
--- a/services/audio_policy/server/infra/async_action_handler/src/audio_policy_server_handler.cpp
+++ b/services/audio_policy/server/infra/async_action_handler/src/audio_policy_server_handler.cpp
@@ -1162,7 +1162,6 @@ void AudioPolicyServerHandler::HandleAudioSessionDeviceChangeEvent(const AppExec
         clientCallbacksMap = clientCallbacksMap_;
     }
 
-    std::shared_ptr<AudioSession> audioSession = nullptr;
     for (auto it = audioPolicyClientProxyAPSCbsMap.begin(); it != audioPolicyClientProxyAPSCbsMap.end(); ++it) {
         if ((eventContextObj->callerPid_ != -1) && (it->first != eventContextObj->callerPid_)) {
             AUDIO_INFO_LOG("current callerPid is %{public}d, not %{public}d", it->first, eventContextObj->callerPid_);
@@ -1178,28 +1177,25 @@ void AudioPolicyServerHandler::HandleAudioSessionDeviceChangeEvent(const AppExec
         if ((clientCallbacksMap.count(it->first) > 0) &&
             (clientCallbacksMap[it->first].count(CALLBACK_AUDIO_SESSION_DEVICE) > 0) &&
             (clientCallbacksMap[it->first][CALLBACK_AUDIO_SESSION_DEVICE])) {
-            std::shared_ptr<AudioSessionService> audioSessionService = AudioSessionService::GetAudioSessionService();
-            audioSession = audioSessionService->GetAudioSessionByPid(it->first);
-            if ((audioSession == nullptr) || (!audioSession->IsActivated())) {
+            AudioSessionService &audioSessionService = OHOS::Singleton<AudioSessionService>::GetInstance();
+            if (!audioSessionService.IsAudioSessionActivated(it->first)) {
                 continue;
             }
 
             CurrentOutputDeviceChangedEvent deviceChangedEvent;
             AudioRendererInfo rendererInfo;
-            rendererInfo.streamUsage = audioSession->GetSessionStreamUsage();
+            rendererInfo.streamUsage = audioSessionService.GetAudioSessionStreamUsage(it->first);
             deviceChangedEvent.devices = AudioCoreService::GetCoreService()->GetEventEntry()->
                 GetPreferredOutputDeviceDescriptors(rendererInfo);
 
             CHECK_AND_CONTINUE_LOG((deviceChangedEvent.devices.size() > 0) &&
                 (deviceChangedEvent.devices[0] != nullptr), "get invalid preferred output devices list");
-            CHECK_AND_CONTINUE_LOG((!audioSession->IsSessionOutputDeviceChanged(deviceChangedEvent.devices[0]) ||
-                (eventContextObj->reason_ == AudioStreamDeviceChangeReason::AUDIO_SESSION_ACTIVATE)),
-                "device of session %{public}d is not changed", it->first);
 
-            deviceChangedEvent.changeReason = eventContextObj->reason_;
-            deviceChangedEvent.recommendedAction = audioSession->IsRecommendToStopAudio(eventContextObj) ?
-                OutputDeviceChangeRecommendedAction::RECOMMEND_TO_STOP :
-                OutputDeviceChangeRecommendedAction::RECOMMEND_TO_CONTINUE;
+            int32_t ret = audioSessionService.FillCurrentOutputDeviceChangedEvent(
+                it->first, eventContextObj->reason_, eventContextObj->descriptor, deviceChangedEvent);
+            if (ret != SUCCESS) {
+                continue;
+            }
 
             sessionDeviceChangeCb->OnAudioSessionCurrentDeviceChanged(deviceChangedEvent);
         }
@@ -1219,7 +1215,6 @@ void AudioPolicyServerHandler::HandleAudioSessionInputDeviceChangeEvent(const Ap
         clientCallbacksMap = clientCallbacksMap_;
     }
 
-    std::shared_ptr<AudioSession> audioSession = nullptr;
     for (auto it = audioPolicyClientProxyAPSCbsMap.begin(); it != audioPolicyClientProxyAPSCbsMap.end(); ++it) {
         if ((eventContextObj->callerPid_ != -1) && (it->first != eventContextObj->callerPid_)) {
             AUDIO_INFO_LOG("current callerPid is %{public}d, not %{public}d", it->first, eventContextObj->callerPid_);
@@ -1235,9 +1230,8 @@ void AudioPolicyServerHandler::HandleAudioSessionInputDeviceChangeEvent(const Ap
         if ((clientCallbacksMap.count(it->first) > 0) &&
             (clientCallbacksMap[it->first].count(CALLBACK_AUDIO_SESSION_INPUT_DEVICE) > 0) &&
             (clientCallbacksMap[it->first][CALLBACK_AUDIO_SESSION_INPUT_DEVICE])) {
-            std::shared_ptr<AudioSessionService> audioSessionService = AudioSessionService::GetAudioSessionService();
-            audioSession = audioSessionService->GetAudioSessionByPid(it->first);
-            if ((audioSession == nullptr) || (!audioSession->IsActivated())) {
+            AudioSessionService &audioSessionService = OHOS::Singleton<AudioSessionService>::GetInstance();
+            if (!audioSessionService.IsAudioSessionActivated(it->first)) {
                 continue;
             }
 
@@ -1249,7 +1243,9 @@ void AudioPolicyServerHandler::HandleAudioSessionInputDeviceChangeEvent(const Ap
 
             CHECK_AND_CONTINUE_LOG((deviceChangedEvent.devices.size() > 0) &&
                 (deviceChangedEvent.devices[0] != nullptr), "get invalid preferred output devices list");
-            CHECK_AND_CONTINUE_LOG((!audioSession->IsSessionInputDeviceChanged(deviceChangedEvent.devices[0]) ||
+            bool isSessionInputDeviceChanged =
+                audioSessionService.IsSessionInputDeviceChanged(it->first, deviceChangedEvent.devices[0]);
+            CHECK_AND_CONTINUE_LOG((!isSessionInputDeviceChanged ||
                 (eventContextObj->reason_ == AudioStreamDeviceChangeReason::AUDIO_SESSION_ACTIVATE)),
                 "device of session %{public}d is not changed", it->first);
             deviceChangedEvent.changeReason = eventContextObj->reason_;
diff --git a/services/audio_policy/server/service/service_main/include/audio_core_service.h b/services/audio_policy/server/service/service_main/include/audio_core_service.h
index 031b12a4d364ea769cd0122b1592630e860638e3..0728f7138cffc505a04a8ddf551652d96532516f 100644
--- a/services/audio_policy/server/service/service_main/include/audio_core_service.h
+++ b/services/audio_policy/server/service/service_main/include/audio_core_service.h
@@ -557,7 +557,7 @@ private:
     SleAudioDeviceManager &sleAudioDeviceManager_;
     AudioUsrSelectManager &audioUsrSelectManager_;
     std::shared_ptr<AudioPipeSelector> audioPipeSelector_;
-    std::shared_ptr<AudioSessionService> audioSessionService_ = nullptr;
+    AudioSessionService &audioSessionService_;
 
     std::shared_ptr<AudioA2dpOffloadManager> audioA2dpOffloadManager_ = nullptr;
     std::shared_ptr<DeviceStatusListener> deviceStatusListener_;
diff --git a/services/audio_policy/server/service/service_main/include/audio_policy_server.h b/services/audio_policy/server/service/service_main/include/audio_policy_server.h
index 32313acdbb2b10d4a9adb1b47b93c79874f8bf37..6f77c1c0299eedf0e8ebb3358a487aa094b47923 100644
--- a/services/audio_policy/server/service/service_main/include/audio_policy_server.h
+++ b/services/audio_policy/server/service/service_main/include/audio_policy_server.h
@@ -868,6 +868,7 @@ private:
     AudioActiveDevice &audioActiveDevice_;
 
     std::shared_ptr<AudioInterruptService> interruptService_;
+    AudioSessionService &sessionService_;
     std::shared_ptr<AudioCoreService> coreService_;
     std::shared_ptr<AudioCoreService::EventEntry> eventEntry_;
 
diff --git a/services/audio_policy/server/service/service_main/src/audio_core_service.cpp b/services/audio_policy/server/service/service_main/src/audio_core_service.cpp
index ddeb3bf03694c1c7e7a9d5d956346f65532b4564..6aeee73369a33648c807aa0999fc11380df01d3a 100644
--- a/services/audio_policy/server/service/service_main/src/audio_core_service.cpp
+++ b/services/audio_policy/server/service/service_main/src/audio_core_service.cpp
@@ -82,7 +82,7 @@ AudioCoreService::AudioCoreService()
       sleAudioDeviceManager_(SleAudioDeviceManager::GetInstance()),
       audioUsrSelectManager_(AudioUsrSelectManager::GetAudioUsrSelectManager()),
       audioPipeSelector_(AudioPipeSelector::GetPipeSelector()),
-      audioSessionService_(AudioSessionService::GetAudioSessionService()),
+      audioSessionService_(OHOS::Singleton<AudioSessionService>::GetInstance()),
       pipeManager_(AudioPipeManager::GetPipeManager())
 {
     AUDIO_INFO_LOG("Ctor");
@@ -729,12 +729,7 @@ int32_t AudioCoreService::GetPreferredOutputStreamType(AudioRendererInfo &render
 
 int32_t AudioCoreService::GetSessionDefaultOutputDevice(const int32_t callerPid, DeviceType &deviceType)
 {
-    if (audioSessionService_ == nullptr) {
-        AUDIO_ERR_LOG("GetSessionDefaultOutputDevice audioSessionService_ is nullptr!");
-        return ERR_UNKNOWN;
-    }
-
-    deviceType = audioSessionService_->GetSessionDefaultOutputDevice(callerPid);
+    deviceType = audioSessionService_.GetSessionDefaultOutputDevice(callerPid);
     return SUCCESS;
 }
 
@@ -743,12 +738,7 @@ int32_t AudioCoreService::SetSessionDefaultOutputDevice(const int32_t callerPid,
     CHECK_AND_RETURN_RET_LOG(AudioPolicyConfigManager::GetInstance().GetHasEarpiece(), ERR_NOT_SUPPORTED,
         "the device has no earpiece");
 
-    if (audioSessionService_ == nullptr) {
-        AUDIO_ERR_LOG("SetSessionDefaultOutputDevice audioSessionService_ is nullptr!");
-        return ERR_UNKNOWN;
-    }
-
-    return audioSessionService_->SetSessionDefaultOutputDevice(callerPid, deviceType);
+    return audioSessionService_.SetSessionDefaultOutputDevice(callerPid, deviceType);
 }
 
 int32_t AudioCoreService::GetPreferredInputStreamType(AudioCapturerInfo &capturerInfo)
diff --git a/services/audio_policy/server/service/service_main/src/audio_core_service_private.cpp b/services/audio_policy/server/service/service_main/src/audio_core_service_private.cpp
index 6eb53b4eb9066d44252600a20f6e2b2bba0d298e..08786f30c2a53bc4bdca5a8307cf7e1f01191de4 100644
--- a/services/audio_policy/server/service/service_main/src/audio_core_service_private.cpp
+++ b/services/audio_policy/server/service/service_main/src/audio_core_service_private.cpp
@@ -2144,7 +2144,7 @@ int32_t AudioCoreService::SetDefaultOutputDevice(const DeviceType deviceType, co
     CHECK_AND_RETURN_RET_LOG(pipeManager_->GetStreamDescById(sessionID) != nullptr, ERR_NOT_SUPPORTED,
         "sessionId is not exist");
 
-    if ((audioSessionService_ != nullptr) && (!audioSessionService_->IsStreamAllowedToSetDevice(sessionID))) {
+    if (!audioSessionService_.IsStreamAllowedToSetDevice(sessionID)) {
         AUDIO_ERR_LOG("current stream is contained in a session which had set default output device");
         return ERR_NOT_SUPPORTED;
     }
@@ -2798,9 +2798,7 @@ void AudioCoreService::UpdateStreamDevicesForStart(
     streamDesc->UpdateOldDevice(streamDesc->newDeviceDescs_);
     
     StreamUsage streamUsage = StreamUsage::STREAM_USAGE_INVALID;
-    if (audioSessionService_ != nullptr) {
-        streamUsage = audioSessionService_->GetAudioSessionStreamUsage(GetRealPid(streamDesc));
-    }
+    streamUsage = audioSessionService_.GetAudioSessionStreamUsage(GetRealPid(streamDesc));
     streamUsage = (streamUsage != StreamUsage::STREAM_USAGE_INVALID) ? streamUsage :
     streamDesc->rendererInfo_.streamUsage;
     std::vector<std::shared_ptr<AudioDeviceDescriptor>> devices;
diff --git a/services/audio_policy/server/service/service_main/src/audio_policy_server.cpp b/services/audio_policy/server/service/service_main/src/audio_policy_server.cpp
index 53a31cedae51f7e8c9e023da8c8a907e5ef7e289..72bda55a640d46f5ccbdd86aee5494d255e751bc 100644
--- a/services/audio_policy/server/service/service_main/src/audio_policy_server.cpp
+++ b/services/audio_policy/server/service/service_main/src/audio_policy_server.cpp
@@ -161,7 +161,8 @@ AudioPolicyServer::AudioPolicyServer(int32_t systemAbilityId, bool runOnCreate)
 #ifdef USB_ENABLE
       usbManager_(AudioUsbManager::GetInstance()),
 #endif
-      audioActiveDevice_(AudioActiveDevice::GetInstance())
+      audioActiveDevice_(AudioActiveDevice::GetInstance()),
+      sessionService_(OHOS::Singleton<AudioSessionService>::GetInstance())
 
 {
     volumeStep_ = system::GetIntParameter("const.multimedia.audio.volumestep", 1);
@@ -2730,7 +2731,7 @@ int32_t AudioPolicyServer::ActivateAudioInterrupt(
         ret = AudioZoneService::GetInstance().ActivateAudioInterrupt(zoneId, audioInterrupt,
             isUpdatedAudioStrategy);
     }
-    if ((ret == SUCCESS) && (interruptService_->IsSessionNeedToFetchOutputDevice(IPCSkeleton::GetCallingPid()))) {
+    if ((ret == SUCCESS) && (sessionService_.IsSessionNeedToFetchOutputDevice(IPCSkeleton::GetCallingPid()))) {
         eventEntry_->FetchOutputDeviceAndRoute("ActivateAudioInterrupt",
             AudioStreamDeviceChangeReasonExt::ExtEnum::SET_DEFAULT_OUTPUT_DEVICE);
     }
@@ -2997,7 +2998,7 @@ void AudioPolicyServer::MicrophoneMuteInfoDump(std::string &dumpString)
 
 void AudioPolicyServer::AudioSessionInfoDump(std::string &dumpString)
 {
-    interruptService_->AudioSessionInfoDump(dumpString);
+    sessionService_.AudioSessionInfoDump(dumpString);
 }
 
 void AudioPolicyServer::AudioPipeManagerDump(std::string &dumpString)
@@ -4889,7 +4890,7 @@ int32_t AudioPolicyServer::ActivateAudioSession(int32_t strategyIn)
     bool isStandalone = StandaloneModeManager::GetInstance().CheckAndRecordStandaloneApp(
         IPCSkeleton::GetCallingUid(), true);
     int32_t ret = interruptService_->ActivateAudioSession(zoneId, callerPid, strategy, isStandalone);
-    if ((ret == SUCCESS) && (interruptService_->IsSessionNeedToFetchOutputDevice(callerPid)) &&
+    if ((ret == SUCCESS) && (sessionService_.IsSessionNeedToFetchOutputDevice(callerPid)) &&
         (eventEntry_ != nullptr)) {
         eventEntry_->FetchOutputDeviceAndRoute("ActivateAudioSession",
             AudioStreamDeviceChangeReasonExt::ExtEnum::SET_DEFAULT_OUTPUT_DEVICE);
@@ -4962,7 +4963,7 @@ int32_t AudioPolicyServer::SetDefaultOutputDevice(int32_t deviceType)
 
     int32_t callerPid = IPCSkeleton::GetCallingPid();
     int32_t ret = eventEntry_->SetSessionDefaultOutputDevice(callerPid, static_cast<DeviceType>(deviceType));
-    if ((ret == SUCCESS) && (interruptService_->IsSessionNeedToFetchOutputDevice(callerPid))) {
+    if ((ret == SUCCESS) && (sessionService_.IsSessionNeedToFetchOutputDevice(callerPid))) {
         eventEntry_->FetchOutputDeviceAndRoute("SetDefaultOutputDevice",
             AudioStreamDeviceChangeReasonExt::ExtEnum::SET_DEFAULT_OUTPUT_DEVICE);
     }
diff --git a/services/audio_policy/test/BUILD.gn b/services/audio_policy/test/BUILD.gn
index b2693434ceaa8974878c7ff7892d266c7930aa10..27dd730600b03c177f03a562a37126ff4e5487f4 100644
--- a/services/audio_policy/test/BUILD.gn
+++ b/services/audio_policy/test/BUILD.gn
@@ -497,7 +497,6 @@ ohos_unittest("audio_interrupt_service_unit_test") {
   ]
 
   sources = [
-    "./unittest/audio_interrupt_service_test/src/audio_interrupt_service_unit_test.cpp",
     "./unittest/audio_interrupt_service_test/src/audio_interrupt_unit_test.cpp",
     "./unittest/audio_interrupt_service_test/src/audio_interrupt_zone_unit_test.cpp",
   ]
diff --git a/services/audio_policy/test/unittest/audio_core_service_entry_unit_test/src/audio_core_service_entry_unit_test.cpp b/services/audio_policy/test/unittest/audio_core_service_entry_unit_test/src/audio_core_service_entry_unit_test.cpp
index dd0f12ddda13d9def498cf87f99a79bceeee911a..0ef65e43747ebf42969318507eaad0359ba92763 100644
--- a/services/audio_policy/test/unittest/audio_core_service_entry_unit_test/src/audio_core_service_entry_unit_test.cpp
+++ b/services/audio_policy/test/unittest/audio_core_service_entry_unit_test/src/audio_core_service_entry_unit_test.cpp
@@ -941,7 +941,6 @@ HWTEST(AudioCoreServiceEntryTest, AudioCoreService_044, TestSize.Level1)
     EXPECT_NE(audioStreamDescriptor->newDeviceDescs_.size(), 0);
 
     audioCoreService->isFirstScreenOn_ = true;
-    audioCoreService->audioSessionService_ = nullptr;
     audioCoreService->UpdateStreamDevicesForStart(audioStreamDescriptor, "test");
     EXPECT_NE(audioStreamDescriptor->newDeviceDescs_.size(), 0);
 }
diff --git a/services/audio_policy/test/unittest/audio_interrupt_service_test/include/audio_interrupt_unit_test.h b/services/audio_policy/test/unittest/audio_interrupt_service_test/include/audio_interrupt_unit_test.h
index 26a2e43b50f8ea935e36a15ed1b412868f8eab35..bb4f32efd5cb5f941ad257d4bcbb1e9cd7387a04 100644
--- a/services/audio_policy/test/unittest/audio_interrupt_service_test/include/audio_interrupt_unit_test.h
+++ b/services/audio_policy/test/unittest/audio_interrupt_service_test/include/audio_interrupt_unit_test.h
@@ -18,10 +18,16 @@
 
 #include "gtest/gtest.h"
 #include "audio_interrupt_service.h"
+#include "audio_session_state_monitor.h"
 
 namespace OHOS {
 namespace AudioStandard {
 
+class AudioSessionStateMonitorStub : public AudioSessionStateMonitor {
+public:
+    virtual void OnAudioSessionTimeOut(int32_t pid) override {}
+};
+
 class AudioInterruptUnitTest : public testing::Test {
 public:
     // SetUpTestCase: Called before all test cases
@@ -32,6 +38,8 @@ public:
     void SetUp(void);
     // TearDown: Called after each test cases
     void TearDown(void);
+private:
+    AudioSessionStateMonitorStub audioSessionStateMonitor_;
 };
 
 class AudioInterruptZoneUnitTest : public testing::Test {
@@ -59,6 +67,7 @@ public:
 
 private:
     std::shared_ptr<AudioInterruptService> audioInterruptService_ = nullptr;
+    AudioSessionStateMonitorStub audioSessionStateMonitor_;
 };
 } // namespace AudioStandard
 } // namespace OHOS
diff --git a/services/audio_policy/test/unittest/audio_interrupt_service_test/src/audio_interrupt_service_pro_unit_test.cpp b/services/audio_policy/test/unittest/audio_interrupt_service_test/src/audio_interrupt_service_pro_unit_test.cpp
index e5ad74f8f2762e0e71410ffd1c6e07ea390bba48..07070eac8c2daee6e6d244caefc0d4b879eded1a 100644
--- a/services/audio_policy/test/unittest/audio_interrupt_service_test/src/audio_interrupt_service_pro_unit_test.cpp
+++ b/services/audio_policy/test/unittest/audio_interrupt_service_test/src/audio_interrupt_service_pro_unit_test.cpp
@@ -26,6 +26,8 @@ void AudioInterruptServiceUnitTest::SetUp(void)
 {
     audioInterruptService_ = std::make_shared<AudioInterruptService>();
     ASSERT_NE(audioInterruptService_, nullptr);
+    audioInterruptService_->sessionService_.sessionMap_.clear();
+    audioInterruptService_->sessionService_.timeOutCallback_.reset();
 }
 
 void AudioInterruptServiceUnitTest::TearDown(void)
@@ -333,13 +335,12 @@ HWTEST(AudioInterruptServiceProUnitTest, AudioInterruptService_013, TestSize.Lev
 /**
  * @tc.name  : Test AudioInterruptService
  * @tc.number: IsSessionNeedToFetchOutputDevice_001
- * @tc.desc  : Test IsSessionNeedToFetchOutputDevice sessionService_ != nullptr
+ * @tc.desc  : Test IsSessionNeedToFetchOutputDevice
  */
 HWTEST_F(AudioInterruptServiceUnitTest, IsSessionNeedToFetchOutputDevice_001, TestSize.Level4)
 {
-    audioInterruptService_->sessionService_ = std::make_shared<AudioSessionService>();
     int32_t callerPid = 1001;
-    bool ret = audioInterruptService_->IsSessionNeedToFetchOutputDevice(callerPid);
+    bool ret = audioInterruptService_->sessionService_.IsSessionNeedToFetchOutputDevice(callerPid);
     EXPECT_FALSE(ret);
 }
 
@@ -361,7 +362,7 @@ HWTEST_F(AudioInterruptServiceUnitTest, DeactivateAudioSessionFakeInterrupt_001,
         std::make_pair(audioInterrupt, AudioFocuState::ACTIVE));
     audioInterruptService_->zonesMap_[zoneId] = zone;
     EXPECT_NO_THROW(
-        audioInterruptService_->DeactivateAudioSessionFakeInterrupt(zoneId, callerPid, isSessionTimeout));
+        audioInterruptService_->DeactivateAudioSessionFakeInterruptInternal(zoneId, callerPid, isSessionTimeout));
 }
 
 /**
@@ -432,12 +433,12 @@ HWTEST_F(AudioInterruptServiceUnitTest, CanMixForActiveSession_001, TestSize.Lev
     AudioFocusEntry focusEntry;
     focusEntry.actionOn = CURRENT;
     focusEntry.hintType = INTERRUPT_HINT_PAUSE;
-    audioInterruptService_->sessionService_ = std::make_shared<AudioSessionService>();
     AudioSessionStrategy strategy;
     strategy.concurrencyMode = AudioConcurrencyMode::MIX_WITH_OTHERS;
-    std::shared_ptr<AudioSession> session = std::make_shared<AudioSession>(callerPid, strategy, nullptr);
+    std::shared_ptr<AudioSession> session =
+        std::make_shared<AudioSession>(callerPid, strategy, audioSessionStateMonitor_);
     session->state_ = AudioSessionState::SESSION_ACTIVE;
-    audioInterruptService_->sessionService_->sessionMap_[callerPid] = session;
+    audioInterruptService_->sessionService_.sessionMap_[callerPid] = session;
     EXPECT_FALSE(audioInterruptService_->CanMixForActiveSession(incomingInterrupt, activeInterrupt, focusEntry));
 }
 
@@ -453,7 +454,6 @@ HWTEST_F(AudioInterruptServiceUnitTest, CanMixForActiveSession_002, TestSize.Lev
     AudioInterrupt activeInterrupt;
     activeInterrupt.sessionStrategy.concurrencyMode = AudioConcurrencyMode::SILENT;
     AudioFocusEntry focusEntry;
-    audioInterruptService_->sessionService_.reset();
     EXPECT_TRUE(audioInterruptService_->CanMixForActiveSession(incomingInterrupt, activeInterrupt, focusEntry));
 
     activeInterrupt.sessionStrategy.concurrencyMode = AudioConcurrencyMode::MIX_WITH_OTHERS;
@@ -590,9 +590,6 @@ HWTEST_F(AudioInterruptServiceUnitTest, WriteStartDfxMsg_001, TestSize.Level4)
     audioInterruptService_->dfxCollector_ = std::make_unique<AudioInterruptDfxCollector>();
     ASSERT_NE(audioInterruptService_->dfxCollector_, nullptr);
 
-    audioInterruptService_->sessionService_ = std::make_shared<AudioSessionService>();
-    ASSERT_NE(audioInterruptService_->sessionService_, nullptr);
-
     InterruptDfxBuilder dfxBuilder;
     AudioInterrupt audioInterrupt;
     audioInterrupt.state = State::PREPARED;
@@ -777,5 +774,37 @@ HWTEST_F(AudioInterruptServiceUnitTest, ShouldCallbackToClient_007, TestSize.Lev
 
     EXPECT_EQ(audioInterruptService_->ShouldCallbackToClient(uid, streamId, interruptEvent), false);
 }
+
+/**
+* @tc.name  : Test InterruptStrategy Mute
+* @tc.number: AudioInterruptStrategy_001
+* @tc.desc  : Test InterruptStrategy Mute
+*/
+HWTEST_F(AudioInterruptServiceUnitTest, AudioInterruptStrategy_001, TestSize.Level1)
+{
+    int32_t fakePid = 123;
+    AudioInterrupt incomingInterrupt1;
+    incomingInterrupt1.pid = fakePid;
+    incomingInterrupt1.audioFocusType.sourceType = SOURCE_TYPE_MIC;
+    incomingInterrupt1.streamId = 888; // 888 is a fake stream id.
+
+    int32_t fakePid2 = 124;
+    AudioInterrupt incomingInterrupt2;
+    incomingInterrupt2.pid = fakePid2;
+    incomingInterrupt2.audioFocusType.sourceType = SOURCE_TYPE_UNPROCESSED;
+    incomingInterrupt2.streamId = 889; // 889 is a fake stream id.
+    incomingInterrupt1.strategy = InterruptStrategy::MUTE;
+
+    AudioFocusEntry focusEntry;
+    focusEntry.hintType = INTERRUPT_HINT_PAUSE;
+    audioInterruptService_->UpdateMuteAudioFocusStrategy(incomingInterrupt1, incomingInterrupt2, focusEntry);
+    EXPECT_EQ(focusEntry.hintType, INTERRUPT_HINT_MUTE);
+
+    focusEntry.hintType = INTERRUPT_HINT_PAUSE;
+
+    audioInterruptService_->UpdateMuteAudioFocusStrategy(incomingInterrupt2, incomingInterrupt1, focusEntry);
+    EXPECT_EQ(focusEntry.hintType, INTERRUPT_HINT_MUTE);
+}
+
 } // namespace AudioStandard
 } // namespace OHOS
\ No newline at end of file
diff --git a/services/audio_policy/test/unittest/audio_interrupt_service_test/src/audio_interrupt_service_second_unit_test.cpp b/services/audio_policy/test/unittest/audio_interrupt_service_test/src/audio_interrupt_service_second_unit_test.cpp
index 3e82cff0cc204f81ad6f7228a310a1506541c105..b51463d9bf4e7cc26c422393202184275933641e 100644
--- a/services/audio_policy/test/unittest/audio_interrupt_service_test/src/audio_interrupt_service_second_unit_test.cpp
+++ b/services/audio_policy/test/unittest/audio_interrupt_service_test/src/audio_interrupt_service_second_unit_test.cpp
@@ -113,8 +113,6 @@ HWTEST(AudioInterruptServiceSecondUnitTest, AudioInterruptService_001, TestSize.
     audioInterrupt.isAudioSessionInterrupt = true;
     audioInterruptZone->audioFocusInfoList.push_back({audioInterrupt, STOP});
     audioInterruptService->zonesMap_[0] = audioInterruptZone;
-    std::shared_ptr<AudioSessionService> sessionService = std::make_shared<AudioSessionService>();
-    audioInterruptService->sessionService_ = sessionService;
     audioInterruptService->OnSessionTimeout(pid);
     EXPECT_EQ(nullptr, audioInterruptService->handler_);
 
@@ -139,15 +137,11 @@ HWTEST(AudioInterruptServiceSecondUnitTest, AudioInterruptService_002, TestSize.
     incomingInterrupt.audioFocusType.streamType = STREAM_MUSIC;
     incomingInterrupt.streamId = 888; // 888 is a fake stream id.
 
-    std::shared_ptr<AudioSessionService> sessionService = std::make_shared<AudioSessionService>();
-    sessionService->sessionMap_[fakePid] = nullptr;
-    audioInterruptService->sessionService_ = sessionService;
-    
     AudioSessionStrategy audioSessionStrategy;
     audioSessionStrategy.concurrencyMode = AudioConcurrencyMode::DEFAULT;
     auto ret = audioInterruptService->ActivateAudioSession(AudioInterruptService::ZONEID_DEFAULT,
         fakePid, audioSessionStrategy);
-    EXPECT_EQ(ERROR, ret);
+    EXPECT_EQ(SUCCESS, ret);
 }
 
 /**
@@ -167,10 +161,8 @@ HWTEST(AudioInterruptServiceSecondUnitTest, AudioInterruptService_003, TestSize.
     incomingInterrupt.streamId = 888;
     AudioSessionStrategy audioSessionStrategy;
     audioSessionStrategy.concurrencyMode = AudioConcurrencyMode::DEFAULT;
-    audioInterruptService->sessionService_ = AudioSessionService::GetAudioSessionService();
-    audioInterruptService->sessionService_->sessionMap_[fakePid] = nullptr;
     auto ret = audioInterruptService->ActivateAudioSession(1, fakePid, audioSessionStrategy);
-    EXPECT_EQ(ERROR, ret);
+    EXPECT_EQ(SUCCESS, ret);
 }
 
 /**
@@ -184,17 +176,9 @@ HWTEST(AudioInterruptServiceSecondUnitTest, AudioInterruptService_004, TestSize.
     ASSERT_NE(audioInterruptService, nullptr);
 
     int32_t fakePid = 123;
-    auto ret = audioInterruptService->IsSessionNeedToFetchOutputDevice(fakePid);
-    EXPECT_EQ(false, ret);
-
-    audioInterruptService->sessionService_ = AudioSessionService::GetAudioSessionService();
-    ret = audioInterruptService->IsSessionNeedToFetchOutputDevice(fakePid);
+    auto ret = audioInterruptService->sessionService_.IsSessionNeedToFetchOutputDevice(fakePid);
     EXPECT_EQ(false, ret);
 
-    audioInterruptService->sessionService_ = nullptr;
-    ret = audioInterruptService->SetAudioSessionScene(fakePid, AudioSessionScene::MEDIA);
-    EXPECT_EQ(true, ret);
-
     sptr<AudioPolicyServer> server(new AudioPolicyServer(0));
     audioInterruptService->Init(server);
     ret = audioInterruptService->SetAudioSessionScene(fakePid, AudioSessionScene::MEDIA);
@@ -218,8 +202,6 @@ HWTEST(AudioInterruptServiceSecondUnitTest, AudioInterruptService_005, TestSize.
     audioInterrupt.isAudioSessionInterrupt = true;
     audioInterruptZone->audioFocusInfoList.push_back({audioInterrupt, STOP});
     audioInterruptService->zonesMap_[0] = audioInterruptZone;
-    std::shared_ptr<AudioSessionService> sessionService = std::make_shared<AudioSessionService>();
-    audioInterruptService->sessionService_ = sessionService;
     EXPECT_EQ(nullptr, audioInterruptService->handler_);
     auto ret = audioInterruptService->DeactivateAudioSession(0, pid);
     EXPECT_EQ(ERR_ILLEGAL_STATE, ret);
@@ -240,7 +222,6 @@ HWTEST(AudioInterruptServiceSecondUnitTest, AudioInterruptService_006, TestSize.
 
     auto pid = getpid();
     InterruptHint hintType = INTERRUPT_HINT_PAUSE;
-    EXPECT_EQ(nullptr, audioInterruptService->sessionService_);
     audioInterruptService->DeactivateAudioSessionInFakeFocusMode(pid, hintType);
     auto audioInterruptZone = make_shared<AudioInterruptZone>();
     AudioInterrupt audioInterrupt;
@@ -248,8 +229,6 @@ HWTEST(AudioInterruptServiceSecondUnitTest, AudioInterruptService_006, TestSize.
     audioInterrupt.isAudioSessionInterrupt = true;
     audioInterruptZone->audioFocusInfoList.push_back({audioInterrupt, STOP});
     audioInterruptService->zonesMap_[0] = audioInterruptZone;
-    std::shared_ptr<AudioSessionService> sessionService = std::make_shared<AudioSessionService>();
-    audioInterruptService->sessionService_ = sessionService;
 
     audioInterruptService->handler_ = nullptr;
     audioInterruptService->DeactivateAudioSessionInFakeFocusMode(pid, hintType);
@@ -306,24 +285,11 @@ HWTEST(AudioInterruptServiceSecondUnitTest, AudioInterruptService_009, TestSize.
     AudioSessionStrategy audioSessionStrategy;
     audioSessionStrategy.concurrencyMode = AudioConcurrencyMode::DEFAULT;
 
-    std::shared_ptr<AudioSessionService> sessionService = std::make_shared<AudioSessionService>();
-    int ret = sessionService->SetAudioSessionScene(fakePid, AudioSessionScene::MEDIA);
+    int ret = audioInterruptService->sessionService_.SetAudioSessionScene(fakePid, AudioSessionScene::MEDIA);
     EXPECT_EQ(SUCCESS, ret);
-    sessionService->sessionMap_[fakePid]->audioSessionScene_ = AudioSessionScene::MEDIA;
-    sessionService->sessionMap_[fakePid]->state_ = AudioSessionState::SESSION_ACTIVE;
-    audioInterruptService->sessionService_ = sessionService;
-    audioInterruptService->HandleAppStreamType(zoneId, incomingInterrupt);
-
-    audioInterruptService->sessionService_ = nullptr;
-    auto audioInterruptZone = make_shared<AudioInterruptZone>();
-    AudioInterrupt audioInterrupt;
-    audioInterrupt.pid = fakePid;
-    audioInterrupt.isAudioSessionInterrupt = true;
-    audioInterruptZone->audioFocusInfoList.push_back({audioInterrupt, STOP});
-    audioInterruptService->zonesMap_[0] = audioInterruptZone;
-    audioInterrupt.audioFocusType.streamType = STREAM_MUSIC;
+    audioInterruptService->sessionService_.sessionMap_[fakePid]->audioSessionScene_ = AudioSessionScene::MEDIA;
+    audioInterruptService->sessionService_.sessionMap_[fakePid]->state_ = AudioSessionState::SESSION_ACTIVE;
     audioInterruptService->HandleAppStreamType(zoneId, incomingInterrupt);
-    EXPECT_EQ(nullptr, audioInterruptService->sessionService_);
 }
 
 /**
@@ -345,7 +311,6 @@ HWTEST(AudioInterruptServiceSecondUnitTest, AudioInterruptService_010, TestSize.
     focusEntry.actionOn = INCOMING;
     audioInterruptService->focusCfgMap_[focusPair] = focusEntry;
     audioInterruptService->PrintLogsOfFocusStrategyBaseMusic(audioInterrupt);
-    EXPECT_EQ(nullptr, audioInterruptService->sessionService_);
 }
 
 /**
@@ -368,19 +333,18 @@ HWTEST(AudioInterruptServiceSecondUnitTest, AudioInterruptService_011, TestSize.
     focusEntry.actionOn = CURRENT;
     audioInterruptService->focusCfgMap_[focusPair] = focusEntry;
 
-    std::shared_ptr<AudioSessionService> sessionService = std::make_shared<AudioSessionService>();
-    int ret = sessionService->SetAudioSessionScene(audioInterrupt.pid, AudioSessionScene::MEDIA);
+    int ret =
+        audioInterruptService->sessionService_.SetAudioSessionScene(audioInterrupt.pid, AudioSessionScene::MEDIA);
     EXPECT_EQ(SUCCESS, ret);
-    sessionService->sessionMap_[audioInterrupt.pid]->audioSessionScene_ = AudioSessionScene::MEDIA;
-    sessionService->sessionMap_[audioInterrupt.pid]->state_ = AudioSessionState::SESSION_NEW;
-    audioInterruptService->sessionService_ = sessionService;
+    audioInterruptService->sessionService_.sessionMap_[audioInterrupt.pid]->audioSessionScene_ =
+        AudioSessionScene::MEDIA;
+    audioInterruptService->sessionService_.sessionMap_[audioInterrupt.pid]->state_ =
+        AudioSessionState::SESSION_NEW;
     audioInterruptService->PrintLogsOfFocusStrategyBaseMusic(audioInterrupt);
-    EXPECT_NE(nullptr, audioInterruptService->sessionService_);
 
-    sessionService->sessionMap_[audioInterrupt.pid]->state_ = AudioSessionState::SESSION_ACTIVE;
-    audioInterruptService->sessionService_ = sessionService;
+    audioInterruptService->sessionService_.sessionMap_[audioInterrupt.pid]->state_ =
+        AudioSessionState::SESSION_ACTIVE;
     audioInterruptService->PrintLogsOfFocusStrategyBaseMusic(audioInterrupt);
-    EXPECT_NE(nullptr, audioInterruptService->sessionService_);
 }
 
 /**
@@ -403,7 +367,6 @@ HWTEST(AudioInterruptServiceSecondUnitTest, AudioInterruptService_012, TestSize.
     audioInterruptService->focusCfgMap_[focusPair] = focusEntry;
     audioInterrupt.sessionStrategy.concurrencyMode = AudioConcurrencyMode::MIX_WITH_OTHERS;
     audioInterruptService->PrintLogsOfFocusStrategyBaseMusic(audioInterrupt);
-    EXPECT_EQ(nullptr, audioInterruptService->sessionService_);
 
     focusEntry.hintType = INTERRUPT_HINT_DUCK;
     audioInterruptService->focusCfgMap_[focusPair] = focusEntry;
@@ -450,7 +413,6 @@ HWTEST(AudioInterruptServiceSecondUnitTest, AudioInterruptService_013, TestSize.
     audioInterruptService->focusCfgMap_[focusPair] = focusEntry;
     audioInterrupt.sessionStrategy.concurrencyMode = AudioConcurrencyMode::DUCK_OTHERS;
     audioInterruptService->PrintLogsOfFocusStrategyBaseMusic(audioInterrupt);
-    EXPECT_EQ(nullptr, audioInterruptService->sessionService_);
 
     focusEntry.hintType = INTERRUPT_HINT_DUCK;
     audioInterruptService->focusCfgMap_[focusPair] = focusEntry;
@@ -493,7 +455,6 @@ HWTEST(AudioInterruptServiceSecondUnitTest, AudioInterruptService_014, TestSize.
     audioInterruptService->focusCfgMap_[focusPair] = focusEntry;
     audioInterrupt.sessionStrategy.concurrencyMode = AudioConcurrencyMode::PAUSE_OTHERS;
     audioInterruptService->PrintLogsOfFocusStrategyBaseMusic(audioInterrupt);
-    EXPECT_EQ(nullptr, audioInterruptService->sessionService_);
 
     focusEntry.hintType = INTERRUPT_HINT_PAUSE;
     audioInterruptService->focusCfgMap_[focusPair] = focusEntry;
@@ -639,12 +600,10 @@ HWTEST(AudioInterruptServiceSecondUnitTest, AudioInterruptService_019, TestSize.
     audioInterrupt.isAudioSessionInterrupt = true;
     audioInterruptZone->audioFocusInfoList.push_back({audioInterrupt, ACTIVE});
     audioInterruptService->zonesMap_[0] = audioInterruptZone;
-    std::shared_ptr<AudioSessionService> sessionService = std::make_shared<AudioSessionService>();
-    int ret = sessionService->SetAudioSessionScene(pid, AudioSessionScene::MEDIA);
+    int ret = audioInterruptService->sessionService_.SetAudioSessionScene(pid, AudioSessionScene::MEDIA);
     EXPECT_EQ(SUCCESS, ret);
-    sessionService->sessionMap_[pid]->audioSessionScene_ = AudioSessionScene::MEDIA;
-    sessionService->sessionMap_[pid]->state_ = AudioSessionState::SESSION_ACTIVE;
-    audioInterruptService->sessionService_ = sessionService;
+    audioInterruptService->sessionService_.sessionMap_[pid]->audioSessionScene_ = AudioSessionScene::MEDIA;
+    audioInterruptService->sessionService_.sessionMap_[pid]->state_ = AudioSessionState::SESSION_ACTIVE;
     ret = audioInterruptService->GetStreamInFocusInternal(uid, 0);
     EXPECT_EQ(STREAM_MUSIC, ret);
 }
@@ -700,39 +659,6 @@ HWTEST(AudioInterruptServiceSecondUnitTest, AudioInterruptService_022, TestSize.
     EXPECT_EQ(SUCCESS, ret);
 }
 
-/**
-* @tc.name  : Test AudioInterruptService
-* @tc.number: AudioInterruptService_023
-* @tc.desc  : Test CheckAudioSessionExistence
-*/
-HWTEST(AudioInterruptServiceSecondUnitTest, AudioInterruptService_023, TestSize.Level1)
-{
-    auto audioInterruptService = std::make_shared<AudioInterruptService>();
-    ASSERT_NE(audioInterruptService, nullptr);
-
-    int32_t pid = 123;
-    AudioInterrupt audioInterrupt;
-    AudioFocusEntry audioFocusEntry;
-    audioInterrupt.pid = pid;
-    std::shared_ptr<AudioSessionService> sessionService = std::make_shared<AudioSessionService>();
-    audioInterruptService->sessionService_ = sessionService;
-    auto ret = audioInterruptService->CheckAudioSessionExistence(audioInterrupt, audioFocusEntry);
-    EXPECT_EQ(false, ret);
-
-    ret = sessionService->SetAudioSessionScene(pid, AudioSessionScene::MEDIA);
-    EXPECT_EQ(SUCCESS, ret);
-    sessionService->sessionMap_[pid]->audioSessionScene_ = AudioSessionScene::MEDIA;
-    sessionService->sessionMap_[pid]->state_ = AudioSessionState::SESSION_ACTIVE;
-    audioInterruptService->sessionService_ = sessionService;
-    audioFocusEntry.actionOn = INCOMING;
-    ret = audioInterruptService->CheckAudioSessionExistence(audioInterrupt, audioFocusEntry);
-    EXPECT_EQ(false, ret);
-
-    audioFocusEntry.actionOn = CURRENT;
-    ret = audioInterruptService->CheckAudioSessionExistence(audioInterrupt, audioFocusEntry);
-    EXPECT_EQ(true, ret);
-}
-
 /**
 * @tc.name  : Test AudioInterruptService
 * @tc.number: AudioInterruptService_024
@@ -742,19 +668,30 @@ HWTEST(AudioInterruptServiceSecondUnitTest, AudioInterruptService_024, TestSize.
 {
     auto audioInterruptService = std::make_shared<AudioInterruptService>();
     ASSERT_NE(audioInterruptService, nullptr);
-
+    audioInterruptService->sessionService_.sessionMap_.clear();
     int32_t pid = 123;
     AudioInterrupt audioInterrupt;
     AudioFocusEntry audioFocusEntry;
     audioInterrupt.pid = pid;
-    std::shared_ptr<AudioSessionService> sessionService = std::make_shared<AudioSessionService>();
-    auto ret = sessionService->SetAudioSessionScene(pid, AudioSessionScene::MEDIA);
+    auto ret = audioInterruptService->sessionService_.SetAudioSessionScene(pid, AudioSessionScene::MEDIA);
     EXPECT_EQ(SUCCESS, ret);
-    sessionService->sessionMap_[pid]->audioSessionScene_ = AudioSessionScene::MEDIA;
-    sessionService->sessionMap_[pid]->state_ = AudioSessionState::SESSION_ACTIVE;
-    audioInterruptService->sessionService_ = sessionService;
+    audioInterruptService->sessionService_.sessionMap_[pid]->audioSessionScene_ = AudioSessionScene::MEDIA;
+    audioInterruptService->sessionService_.sessionMap_[pid]->state_ = AudioSessionState::SESSION_ACTIVE;
     audioFocusEntry.actionOn = CURRENT;
     audioInterruptService->UpdateHintTypeForExistingSession(audioInterrupt, audioFocusEntry);
+
+    audioFocusEntry.hintType = INTERRUPT_HINT_DUCK;
+    audioInterruptService->sessionService_.sessionMap_[pid]->strategy_.concurrencyMode =
+        AudioConcurrencyMode::PAUSE_OTHERS;
+    audioInterruptService->UpdateHintTypeForExistingSession(audioInterrupt, audioFocusEntry);
+    EXPECT_EQ(INTERRUPT_HINT_DUCK, audioFocusEntry.hintType);
+
+    audioFocusEntry.hintType = INTERRUPT_HINT_DUCK;
+    audioInterruptService->sessionService_.sessionMap_[pid]->strategy_.concurrencyMode =
+        AudioConcurrencyMode::PAUSE_OTHERS;
+    audioInterruptService->sessionService_.sessionMap_[pid]->isSystemApp_ = true;
+    audioInterruptService->UpdateHintTypeForExistingSession(audioInterrupt, audioFocusEntry);
+    EXPECT_EQ(INTERRUPT_HINT_PAUSE, audioFocusEntry.hintType);
 }
 
 /**
@@ -1115,7 +1052,6 @@ HWTEST(AudioInterruptServiceSecondUnitTest, AudioInterruptService_035, TestSize.
     auto zoneInfo = make_shared<AudioInterruptZone>();
     std::list<int32_t> removeFocusInfoPidList;
     int32_t pid = 12;
-    audioInterruptService->sessionService_ = AudioSessionService::GetAudioSessionService();
     int ret = audioInterruptService->SetAudioSessionScene(pid, AudioSessionScene::MEDIA);
     EXPECT_EQ(SUCCESS, ret);
     audioInterruptService->RemoveFocusInfo(iterActive, tmpFocusInfoList, zoneInfo, removeFocusInfoPidList);
@@ -1134,12 +1070,7 @@ HWTEST(AudioInterruptServiceSecondUnitTest, AudioInterruptService_036, TestSize.
     int32_t pid = 123;
     int32_t streamId = 123;
     auto ret = audioInterruptService->HandleLowPriorityEvent(pid, streamId);
-    EXPECT_EQ(false, ret);
-
-    std::shared_ptr<AudioSessionService> sessionService = std::make_shared<AudioSessionService>();
-    audioInterruptService->sessionService_ = sessionService;
-    ret = audioInterruptService->HandleLowPriorityEvent(pid, streamId);
-    EXPECT_EQ(false, ret);
+    EXPECT_TRUE(ret);
 }
 
 /**
@@ -1349,30 +1280,6 @@ HWTEST(AudioInterruptServiceSecondUnitTest, AudioInterruptService_GetAudioSessio
     EXPECT_EQ(ret.at(0), 1000);
 }
 
-/**
-* @tc.name  : Test AudioInterruptService
-* @tc.number: AudioInterruptService_045
-* @tc.desc  : Test AudioInterruptService_045
-*/
-HWTEST(AudioInterruptServiceSecondUnitTest, AudioInterruptService_045, TestSize.Level1)
-{
-    auto audioInterruptService = std::make_shared<AudioInterruptService>();
-    ASSERT_NE(audioInterruptService, nullptr);
-
-    int32_t fakePid = 123;
-    AudioInterrupt incomingInterrupt;
-    incomingInterrupt.pid = fakePid;
-    incomingInterrupt.audioFocusType.streamType = STREAM_MUSIC;
-    AudioSessionStrategy audioSessionStrategy;
-    InterruptEventInternal interruptEvent;
-    audioSessionStrategy.concurrencyMode = AudioConcurrencyMode::DEFAULT;
-    audioInterruptService->sessionService_ = AudioSessionService::GetAudioSessionService();
-    audioInterruptService->sessionService_->sessionMap_[fakePid] = nullptr;
-    auto ret = audioInterruptService->ActivateAudioSession(1, fakePid, audioSessionStrategy, true);
-    audioInterruptService->ResumeFocusByStreamId(fakePid, interruptEvent);
-    EXPECT_EQ(ERROR, ret);
-}
-
 /**
 * @tc.name  : Test AudioInterruptService
 * @tc.number: AudioInterruptService_046
@@ -1452,14 +1359,12 @@ HWTEST(AudioInterruptServiceSecondUnitTest, AudioInterruptService_048, TestSize.
     AudioInterrupt incomingInterrupt, activeInterrupt;
     AudioFocusEntry focusEntry;
     activeInterrupt.pid = pid;
-    audioInterruptService->sessionService_ = AudioSessionService::GetAudioSessionService();
     audioInterruptService->SetAudioSessionScene(pid, AudioSessionScene::MEDIA);
     focusEntry.actionOn = CURRENT;
     focusEntry.hintType = INTERRUPT_HINT_PAUSE;
     auto ret = audioInterruptService->CanMixForActiveSession(incomingInterrupt, activeInterrupt, focusEntry);
     EXPECT_EQ(false, ret);
 
-    audioInterruptService->sessionService_ = nullptr;
     activeInterrupt.sessionStrategy.concurrencyMode = AudioConcurrencyMode::SILENT;
     ret = audioInterruptService->CanMixForActiveSession(incomingInterrupt, activeInterrupt, focusEntry);
     EXPECT_EQ(true, ret);
@@ -1596,15 +1501,24 @@ HWTEST(AudioInterruptServiceSecondUnitTest, AudioInterruptService_055, TestSize.
     ASSERT_NE(audioInterruptService, nullptr);
     int32_t pid = 123;
     uint32_t streamId = 123;
-    audioInterruptService->sessionService_ = AudioSessionService::GetAudioSessionService();
-    auto ret = audioInterruptService->sessionService_->SetAudioSessionScene(pid, AudioSessionScene::MEDIA);
+    auto ret = audioInterruptService->sessionService_.SetAudioSessionScene(pid, AudioSessionScene::MEDIA);
     EXPECT_EQ(SUCCESS, ret);
-    audioInterruptService->sessionService_->SetAudioSessionScene(pid, AudioSessionScene::MEDIA);
     ret = audioInterruptService->HandleLowPriorityEvent(pid, streamId);
-    EXPECT_EQ(true, ret);
+    EXPECT_TRUE(ret);
     audioInterruptService->handler_ = make_shared<AudioPolicyServerHandler>();
     ret = audioInterruptService->HandleLowPriorityEvent(pid, streamId);
-    EXPECT_EQ(false, ret);
+    EXPECT_TRUE(ret);
+
+    AudioInterrupt audioInterrupt;
+    audioInterrupt.pid = pid;
+    audioInterrupt.streamId = streamId;
+    audioInterrupt.streamUsage = STREAM_USAGE_MUSIC;
+    audioInterrupt.audioFocusType.isPlay = true;
+    audioInterruptService->sessionService_.SetAudioSessionScene(pid, AudioSessionScene::MEDIA);
+    EXPECT_NE(nullptr, audioInterruptService->sessionService_.sessionMap_[pid]);
+    audioInterruptService->sessionService_.sessionMap_[pid]->AddStreamInfo(audioInterrupt);
+    ret = audioInterruptService->HandleLowPriorityEvent(pid, streamId + 1);
+    EXPECT_FALSE(ret);
 }
 
 /**
@@ -1681,7 +1595,6 @@ HWTEST(AudioInterruptServiceSecondUnitTest, AudioInterruptService_059, TestSize.
     audioInterrupt.isAudioSessionInterrupt = false;
     audioInterruptZone->audioFocusInfoList.push_back({audioInterrupt, STOP});
     audioInterruptService->zonesMap_[zoneId] = audioInterruptZone;
-    audioInterruptService->sessionService_ = nullptr;
     auto ret = audioInterruptService->ShouldBypassAudioSessionFocus(zoneId, audioInterrupt);
     EXPECT_EQ(false, ret);
 }
@@ -1702,7 +1615,6 @@ HWTEST(AudioInterruptServiceSecondUnitTest, AudioInterruptService_060, TestSize.
     audioInterruptService->AddToAudioFocusInfoList(audioInterruptZone, zoneId, incomingInterrupt, incomingState);
     EXPECT_EQ(false, incomingInterrupt.isAudioSessionInterrupt);
     incomingState = ACTIVE;
-    audioInterruptService->sessionService_ = nullptr;
     audioInterruptService->AddToAudioFocusInfoList(audioInterruptZone, zoneId, incomingInterrupt, incomingState);
     EXPECT_EQ(false, incomingInterrupt.isAudioSessionInterrupt);
 }
@@ -1869,10 +1781,10 @@ HWTEST(AudioInterruptServiceSecondUnitTest, AudioInterruptService_066, TestSize.
 
 /**
  * @tc.name  : Test AudioInterruptService
- * @tc.number: AudioInterruptService_071
+ * @tc.number: AudioInterruptService_067
  * @tc.desc  : Test AudioInterruptIsActiveInFocusList
 */
-HWTEST(AudioInterruptServiceSecondUnitTest, AudioInterruptService_071, TestSize.Level1)
+HWTEST(AudioInterruptServiceSecondUnitTest, AudioInterruptService_067, TestSize.Level1)
 {
     auto audioInterruptService = std::make_shared<AudioInterruptService>();
     ASSERT_NE(audioInterruptService, nullptr);
@@ -1899,5 +1811,36 @@ HWTEST(AudioInterruptServiceSecondUnitTest, AudioInterruptService_071, TestSize.
     ret = audioInterruptService->AudioInterruptIsActiveInFocusList(zoneId, streamId);
     EXPECT_EQ(ret, false);
 }
+
+/**
+* @tc.name  : Test ReactivateAudioInterrupts
+* @tc.number: AudioInterruptService_068
+* @tc.desc  : Test ReactivateAudioInterrupts
+*/
+HWTEST(AudioInterruptServiceSecondUnitTest, AudioInterruptService_068, TestSize.Level1)
+{
+    auto audioInterruptService = std::make_shared<AudioInterruptService>();
+    ASSERT_NE(nullptr, audioInterruptService);
+    int32_t zoneId = 0;
+    uint32_t streamId = 123;
+    int32_t pid = 0;
+    bool updateScene = false;
+    audioInterruptService->ReactivateAudioInterrupts(zoneId, pid, updateScene);
+    EXPECT_FALSE(updateScene);
+    audioInterruptService->zonesMap_[zoneId] = nullptr;
+    audioInterruptService->ReactivateAudioInterrupts(zoneId, pid, updateScene);
+    EXPECT_FALSE(updateScene);
+    auto audioInterruptZone = make_shared<AudioInterruptZone>();
+    audioInterruptService->zonesMap_[zoneId] = audioInterruptZone;
+    audioInterruptService->ReactivateAudioInterrupts(zoneId, pid, updateScene);
+    EXPECT_FALSE(updateScene);
+    AudioInterrupt audioInterrupt;
+    audioInterrupt.streamId = 0;
+    audioInterrupt.pid = pid;
+    audioInterruptZone->audioFocusInfoList.push_back({audioInterrupt, STOP});
+    audioInterruptService->ReactivateAudioInterrupts(zoneId, pid, updateScene);
+    EXPECT_TRUE(updateScene);
+}
+
 } // namespace AudioStandard
 } // namespace OHOS
diff --git a/services/audio_policy/test/unittest/audio_interrupt_service_test/src/audio_interrupt_service_unit_test.cpp b/services/audio_policy/test/unittest/audio_interrupt_service_test/src/audio_interrupt_service_unit_test.cpp
deleted file mode 100644
index 51bd5d21d9d99aecce1674eff9ab15a42d4ad050..0000000000000000000000000000000000000000
--- a/services/audio_policy/test/unittest/audio_interrupt_service_test/src/audio_interrupt_service_unit_test.cpp
+++ /dev/null
@@ -1,1097 +0,0 @@
-/*
- * Copyright (c) 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
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#include "audio_interrupt_unit_test.h"
-using namespace testing::ext;
-
-namespace OHOS {
-namespace AudioStandard {
-
-void AudioInterruptServiceUnitTest::SetUpTestCase(void) {}
-void AudioInterruptServiceUnitTest::TearDownTestCase(void) {}
-void AudioInterruptServiceUnitTest::SetUp(void) {}
-void AudioInterruptServiceUnitTest::TearDown(void) {}
-
-class RemoteObjectTestStub : public IRemoteObject {
-public:
-    RemoteObjectTestStub() : IRemoteObject(u"IRemoteObject") {}
-    int32_t GetObjectRefCount() { return 0; };
-    int SendRequest(uint32_t code, MessageParcel &data, MessageParcel &reply, MessageOption &option) { return 0; };
-    bool AddDeathRecipient(const sptr<DeathRecipient> &recipient) { return true; };
-    bool RemoveDeathRecipient(const sptr<DeathRecipient> &recipient) { return true; };
-    int Dump(int fd, const std::vector<std::u16string> &args) { return 0; };
-
-    DECLARE_INTERFACE_DESCRIPTOR(u"RemoteObjectTestStub");
-};
-
-class AudioInterruptCallbackTest : public AudioInterruptCallback {
-public:
-    void OnInterrupt(const InterruptEventInternal &interruptEvent) override {};
-};
-
-/**
-* @tc.name  : Test AudioInterruptService
-* @tc.number: AudioInterruptService_001
-* @tc.desc  : Test AudioInterruptService
-*/
-HWTEST(AudioInterruptServiceUnitTest, AudioInterruptService_001, TestSize.Level1)
-{
-    auto audioInterruptService = std::make_shared<AudioInterruptService>();
-    ASSERT_NE(audioInterruptService, nullptr);
-
-    std::list<std::pair<AudioInterrupt, AudioFocuState>> tmpFocusInfoList;
-    AudioInterrupt audioInterrupt;
-    AudioFocuState audioFocuState = AudioFocuState::ACTIVE;
-    tmpFocusInfoList.emplace_back(audioInterrupt, audioFocuState);
-
-    InterruptEventInternal interruptEvent;
-    interruptEvent.hintType = INTERRUPT_HINT_STOP;
-    std::list<std::pair<AudioInterrupt, AudioFocuState>>::iterator iterActive = tmpFocusInfoList.begin();
-
-    audioInterruptService->SwitchHintType(iterActive, interruptEvent, tmpFocusInfoList);
-    EXPECT_EQ(iterActive, tmpFocusInfoList.end());
-}
-
-/**
-* @tc.name  : Test AudioInterruptService
-* @tc.number: AudioInterruptService_002
-* @tc.desc  : Test AudioInterruptService
-*/
-HWTEST(AudioInterruptServiceUnitTest, AudioInterruptService_002, TestSize.Level1)
-{
-    auto audioInterruptService = std::make_shared<AudioInterruptService>();
-    ASSERT_NE(audioInterruptService, nullptr);
-
-    std::list<std::pair<AudioInterrupt, AudioFocuState>> tmpFocusInfoList;
-    AudioInterrupt audioInterrupt;
-    AudioFocuState audioFocuState = AudioFocuState::ACTIVE;
-    tmpFocusInfoList.emplace_back(audioInterrupt, audioFocuState);
-
-    InterruptEventInternal interruptEvent;
-    interruptEvent.hintType = INTERRUPT_HINT_PAUSE;
-    std::list<std::pair<AudioInterrupt, AudioFocuState>>::iterator iterActive = tmpFocusInfoList.begin();
-
-    audioInterruptService->SwitchHintType(iterActive, interruptEvent, tmpFocusInfoList);
-    EXPECT_EQ(iterActive->second, PAUSEDBYREMOTE);
-}
-
-/**
-* @tc.name  : Test AudioInterruptService
-* @tc.number: AudioInterruptService_003
-* @tc.desc  : Test AudioInterruptService
-*/
-HWTEST(AudioInterruptServiceUnitTest, AudioInterruptService_003, TestSize.Level1)
-{
-    auto audioInterruptService = std::make_shared<AudioInterruptService>();
-    ASSERT_NE(audioInterruptService, nullptr);
-
-    std::list<std::pair<AudioInterrupt, AudioFocuState>> tmpFocusInfoList;
-    AudioInterrupt audioInterrupt;
-    AudioFocuState audioFocuState = AudioFocuState::DUCK;
-    tmpFocusInfoList.emplace_back(audioInterrupt, audioFocuState);
-
-    InterruptEventInternal interruptEvent;
-    interruptEvent.hintType = INTERRUPT_HINT_PAUSE;
-    std::list<std::pair<AudioInterrupt, AudioFocuState>>::iterator iterActive = tmpFocusInfoList.begin();
-
-    audioInterruptService->SwitchHintType(iterActive, interruptEvent, tmpFocusInfoList);
-    EXPECT_EQ(iterActive->second, PAUSEDBYREMOTE);
-}
-
-/**
-* @tc.name  : Test AudioInterruptService
-* @tc.number: AudioInterruptService_004
-* @tc.desc  : Test AudioInterruptService
-*/
-HWTEST(AudioInterruptServiceUnitTest, AudioInterruptService_004, TestSize.Level1)
-{
-    auto audioInterruptService = std::make_shared<AudioInterruptService>();
-    ASSERT_NE(audioInterruptService, nullptr);
-
-    std::list<std::pair<AudioInterrupt, AudioFocuState>> tmpFocusInfoList;
-    AudioInterrupt audioInterrupt;
-    AudioFocuState audioFocuState = AudioFocuState::STOP;
-    tmpFocusInfoList.emplace_back(audioInterrupt, audioFocuState);
-
-    InterruptEventInternal interruptEvent;
-    interruptEvent.hintType = INTERRUPT_HINT_PAUSE;
-    std::list<std::pair<AudioInterrupt, AudioFocuState>>::iterator iterActive = tmpFocusInfoList.begin();
-
-    audioInterruptService->SwitchHintType(iterActive, interruptEvent, tmpFocusInfoList);
-    EXPECT_EQ(iterActive->second, STOP);
-}
-
-/**
-* @tc.name  : Test AudioInterruptService
-* @tc.number: AudioInterruptService_005
-* @tc.desc  : Test AudioInterruptService
-*/
-HWTEST(AudioInterruptServiceUnitTest, AudioInterruptService_005, TestSize.Level1)
-{
-    auto audioInterruptService = std::make_shared<AudioInterruptService>();
-    ASSERT_NE(audioInterruptService, nullptr);
-
-    std::list<std::pair<AudioInterrupt, AudioFocuState>> tmpFocusInfoList;
-    AudioInterrupt audioInterrupt;
-    AudioFocuState audioFocuState = AudioFocuState::PAUSEDBYREMOTE;
-    tmpFocusInfoList.emplace_back(audioInterrupt, audioFocuState);
-
-    InterruptEventInternal interruptEvent;
-    interruptEvent.hintType = INTERRUPT_HINT_RESUME;
-    std::list<std::pair<AudioInterrupt, AudioFocuState>>::iterator iterActive = tmpFocusInfoList.begin();
-
-    audioInterruptService->SwitchHintType(iterActive, interruptEvent, tmpFocusInfoList);
-    EXPECT_EQ(iterActive, tmpFocusInfoList.end());
-}
-
-/**
-* @tc.name  : Test AudioInterruptService
-* @tc.number: AudioInterruptService_006
-* @tc.desc  : Test AudioInterruptService
-*/
-HWTEST(AudioInterruptServiceUnitTest, AudioInterruptService_006, TestSize.Level1)
-{
-    auto audioInterruptService = std::make_shared<AudioInterruptService>();
-    ASSERT_NE(audioInterruptService, nullptr);
-
-    std::list<std::pair<AudioInterrupt, AudioFocuState>> tmpFocusInfoList;
-    AudioInterrupt audioInterrupt;
-    AudioFocuState audioFocuState = AudioFocuState::STOP;
-    tmpFocusInfoList.emplace_back(audioInterrupt, audioFocuState);
-
-    InterruptEventInternal interruptEvent;
-    interruptEvent.hintType = INTERRUPT_HINT_RESUME;
-    std::list<std::pair<AudioInterrupt, AudioFocuState>>::iterator iterActive = tmpFocusInfoList.begin();
-
-    audioInterruptService->SwitchHintType(iterActive, interruptEvent, tmpFocusInfoList);
-    EXPECT_EQ(iterActive, tmpFocusInfoList.begin());
-}
-
-/**
-* @tc.name  : Test AudioInterruptService
-* @tc.number: AudioInterruptService_007
-* @tc.desc  : Test AudioInterruptService
-*/
-HWTEST(AudioInterruptServiceUnitTest, AudioInterruptService_007, TestSize.Level1)
-{
-    auto audioInterruptService = std::make_shared<AudioInterruptService>();
-    ASSERT_NE(audioInterruptService, nullptr);
-
-    std::list<std::pair<AudioInterrupt, AudioFocuState>> tmpFocusInfoList;
-    AudioInterrupt audioInterrupt;
-    AudioFocuState audioFocuState = AudioFocuState::STOP;
-    tmpFocusInfoList.emplace_back(audioInterrupt, audioFocuState);
-
-    InterruptEventInternal interruptEvent;
-    interruptEvent.hintType = INTERRUPT_HINT_NONE;
-    std::list<std::pair<AudioInterrupt, AudioFocuState>>::iterator iterActive = tmpFocusInfoList.begin();
-
-    audioInterruptService->SwitchHintType(iterActive, interruptEvent, tmpFocusInfoList);
-    EXPECT_EQ(iterActive, tmpFocusInfoList.begin());
-}
-
-/**
-* @tc.name  : Test AudioInterruptService
-* @tc.number: AudioInterruptService_008
-* @tc.desc  : Test AudioInterruptService
-*/
-HWTEST(AudioInterruptServiceUnitTest, AudioInterruptService_008, TestSize.Level1)
-{
-    auto audioInterruptService = std::make_shared<AudioInterruptService>();
-    ASSERT_NE(audioInterruptService, nullptr);
-
-    audioInterruptService->dfxCollector_ = std::make_unique<AudioInterruptDfxCollector>();
-    ASSERT_NE(audioInterruptService->dfxCollector_, nullptr);
-    std::shared_ptr<AudioInterruptZone> audioInterruptZone = nullptr;
-    audioInterruptService->zonesMap_.insert({0, audioInterruptZone});
-    int32_t pid = 0;
-
-    audioInterruptService->WriteSessionTimeoutDfxEvent(pid);
-    EXPECT_EQ(audioInterruptService->zonesMap_.size(), 1);
-}
-
-/**
-* @tc.name  : Test AudioInterruptService
-* @tc.number: AudioInterruptService_009
-* @tc.desc  : Test AudioInterruptService
-*/
-HWTEST(AudioInterruptServiceUnitTest, AudioInterruptService_009, TestSize.Level1)
-{
-    auto audioInterruptService = std::make_shared<AudioInterruptService>();
-    ASSERT_NE(audioInterruptService, nullptr);
-
-    audioInterruptService->dfxCollector_ = std::make_unique<AudioInterruptDfxCollector>();
-    ASSERT_NE(audioInterruptService->dfxCollector_, nullptr);
-    std::shared_ptr<AudioInterruptZone> audioInterruptZone = std::make_shared<AudioInterruptZone>();
-    AudioInterrupt audioInterrupt;
-    audioInterrupt.pid = 5;
-    AudioFocuState audioFocuState;
-    audioInterruptZone->audioFocusInfoList.emplace_back(audioInterrupt, audioFocuState);
-    audioInterruptService->zonesMap_.insert({0, audioInterruptZone});
-    int32_t pid = 5;
-
-    audioInterruptService->WriteSessionTimeoutDfxEvent(pid);
-    EXPECT_EQ(audioInterruptService->zonesMap_.size(), 1);
-}
-
-/**
-* @tc.name  : Test AudioInterruptService
-* @tc.number: AudioInterruptService_010
-* @tc.desc  : Test AudioInterruptService
-*/
-HWTEST(AudioInterruptServiceUnitTest, AudioInterruptService_010, TestSize.Level1)
-{
-    auto audioInterruptService = std::make_shared<AudioInterruptService>();
-    ASSERT_NE(audioInterruptService, nullptr);
-
-    AudioInterrupt audioInterrupt;
-    audioInterrupt.pid = 5;
-    audioInterrupt.streamId = 1;
-
-    std::list<std::pair<AudioInterrupt, AudioFocuState>> audioFocusInfoList;
-    AudioInterrupt interrupt;
-    interrupt.pid = 5;
-    interrupt.audioFocusType.streamType = STREAM_VOICE_COMMUNICATION;
-    interrupt.streamId = 0;
-
-    AudioFocuState focusState;
-    focusState = PLACEHOLDER;
-    audioFocusInfoList.emplace_back(interrupt, focusState);
-
-    auto ret = audioInterruptService->HadVoipStatus(audioInterrupt, audioFocusInfoList);
-    EXPECT_EQ(ret, true);
-}
-
-/**
-* @tc.name  : Test AudioInterruptService
-* @tc.number: AudioInterruptService_011
-* @tc.desc  : Test AudioInterruptService
-*/
-HWTEST(AudioInterruptServiceUnitTest, AudioInterruptService_011, TestSize.Level1)
-{
-    auto audioInterruptService = std::make_shared<AudioInterruptService>();
-    ASSERT_NE(audioInterruptService, nullptr);
-
-    AudioInterrupt audioInterrupt;
-    audioInterrupt.pid = 5;
-    audioInterrupt.streamId = 1;
-
-    std::list<std::pair<AudioInterrupt, AudioFocuState>> audioFocusInfoList;
-    AudioInterrupt interrupt;
-    interrupt.pid = 5;
-    interrupt.audioFocusType.streamType = STREAM_VOICE_COMMUNICATION;
-    interrupt.streamId = 1;
-
-    AudioFocuState focusState;
-    focusState = PLACEHOLDER;
-    audioFocusInfoList.emplace_back(interrupt, focusState);
-
-    auto ret = audioInterruptService->HadVoipStatus(audioInterrupt, audioFocusInfoList);
-    EXPECT_EQ(ret, false);
-}
-
-/**
-* @tc.name  : Test AudioInterruptService
-* @tc.number: AudioInterruptService_012
-* @tc.desc  : Test AudioInterruptService
-*/
-HWTEST(AudioInterruptServiceUnitTest, AudioInterruptService_012, TestSize.Level1)
-{
-    auto audioInterruptService = std::make_shared<AudioInterruptService>();
-    ASSERT_NE(audioInterruptService, nullptr);
-
-    AudioInterrupt audioInterrupt;
-    audioInterrupt.pid = 5;
-    audioInterrupt.streamId = 1;
-
-    std::list<std::pair<AudioInterrupt, AudioFocuState>> audioFocusInfoList;
-    AudioInterrupt interrupt;
-    interrupt.pid = 5;
-    interrupt.audioFocusType.streamType = STREAM_VOICE_RING;
-    interrupt.streamId = 1;
-
-    AudioFocuState focusState;
-    focusState = PLACEHOLDER;
-    audioFocusInfoList.emplace_back(interrupt, focusState);
-
-    auto ret = audioInterruptService->HadVoipStatus(audioInterrupt, audioFocusInfoList);
-    EXPECT_EQ(ret, false);
-}
-
-/**
-* @tc.name  : Test AudioInterruptService
-* @tc.number: AudioInterruptService_013
-* @tc.desc  : Test AudioInterruptService
-*/
-HWTEST(AudioInterruptServiceUnitTest, AudioInterruptService_013, TestSize.Level1)
-{
-    auto audioInterruptService = std::make_shared<AudioInterruptService>();
-    ASSERT_NE(audioInterruptService, nullptr);
-
-    AudioInterrupt audioInterrupt;
-    audioInterrupt.pid = 5;
-    audioInterrupt.streamId = 1;
-
-    std::list<std::pair<AudioInterrupt, AudioFocuState>> audioFocusInfoList;
-    AudioInterrupt interrupt;
-    interrupt.pid = 5;
-    interrupt.audioFocusType.streamType = STREAM_VOICE_RING;
-    interrupt.streamId = 1;
-
-    AudioFocuState focusState;
-    focusState = STOP;
-    audioFocusInfoList.emplace_back(interrupt, focusState);
-
-    auto ret = audioInterruptService->HadVoipStatus(audioInterrupt, audioFocusInfoList);
-    EXPECT_EQ(ret, false);
-}
-
-/**
-* @tc.name  : Test AudioInterruptService
-* @tc.number: AudioInterruptService_014
-* @tc.desc  : Test AudioInterruptService
-*/
-HWTEST(AudioInterruptServiceUnitTest, AudioInterruptService_014, TestSize.Level1)
-{
-    auto audioInterruptService = std::make_shared<AudioInterruptService>();
-    ASSERT_NE(audioInterruptService, nullptr);
-
-    AudioInterrupt audioInterrupt;
-    audioInterrupt.pid = 5;
-    audioInterrupt.streamId = 1;
-
-    std::list<std::pair<AudioInterrupt, AudioFocuState>> audioFocusInfoList;
-    AudioInterrupt interrupt;
-    interrupt.pid = 0;
-    interrupt.audioFocusType.streamType = STREAM_VOICE_RING;
-    interrupt.streamId = 1;
-
-    AudioFocuState focusState;
-    focusState = STOP;
-    audioFocusInfoList.emplace_back(interrupt, focusState);
-
-    auto ret = audioInterruptService->HadVoipStatus(audioInterrupt, audioFocusInfoList);
-    EXPECT_EQ(ret, false);
-}
-
-/**
-* @tc.name  : Test AudioInterruptService
-* @tc.number: AudioInterruptService_015
-* @tc.desc  : Test AudioInterruptService
-*/
-HWTEST(AudioInterruptServiceUnitTest, AudioInterruptService_015, TestSize.Level1)
-{
-    auto audioInterruptService = std::make_shared<AudioInterruptService>();
-    ASSERT_NE(audioInterruptService, nullptr);
-
-    uint32_t streamId = 100005;
-    InterruptEventInternal interruptEvent;
-
-    audioInterruptService->DispatchInterruptEventWithStreamId(streamId, interruptEvent);
-    ASSERT_NE(audioInterruptService, nullptr);
-}
-
-/**
-* @tc.name  : Test AudioInterruptService
-* @tc.number: AudioInterruptService_016
-* @tc.desc  : Test AudioInterruptService
-*/
-HWTEST(AudioInterruptServiceUnitTest, AudioInterruptService_016, TestSize.Level1)
-{
-    auto audioInterruptService = std::make_shared<AudioInterruptService>();
-    ASSERT_NE(audioInterruptService, nullptr);
-
-    uint32_t uid = 0;
-    int32_t streamId = 0;
-    InterruptEventInternal interruptEvent;
-
-    uint32_t uid2 = 0;
-    ClientType clientType = CLIENT_TYPE_OTHERS;
-    ClientTypeManager::GetInstance()->OnClientTypeQueryCompleted(uid2, clientType);
-    auto ret = audioInterruptService->ShouldCallbackToClient(uid, streamId, interruptEvent);
-    EXPECT_EQ(ret, true);
-}
-
-/**
-* @tc.name  : Test AudioInterruptService
-* @tc.number: AudioInterruptService_017
-* @tc.desc  : Test AudioInterruptService
-*/
-HWTEST(AudioInterruptServiceUnitTest, AudioInterruptService_017, TestSize.Level1)
-{
-    auto audioInterruptService = std::make_shared<AudioInterruptService>();
-    ASSERT_NE(audioInterruptService, nullptr);
-
-    uint32_t uid = 0;
-    int32_t streamId = 0;
-    InterruptEventInternal interruptEvent;
-    interruptEvent.hintType = INTERRUPT_HINT_DUCK;
-
-    uint32_t uid2 = 0;
-    ClientType clientType = CLIENT_TYPE_GAME;
-    ClientTypeManager::GetInstance()->OnClientTypeQueryCompleted(uid2, clientType);
-    auto ret = audioInterruptService->ShouldCallbackToClient(uid, streamId, interruptEvent);
-    EXPECT_EQ(ret, true);
-    EXPECT_EQ(interruptEvent.callbackToApp, false);
-}
-
-/**
-* @tc.name  : Test AudioInterruptService
-* @tc.number: AudioInterruptService_018
-* @tc.desc  : Test AudioInterruptService
-*/
-HWTEST(AudioInterruptServiceUnitTest, AudioInterruptService_018, TestSize.Level1)
-{
-    auto audioInterruptService = std::make_shared<AudioInterruptService>();
-    ASSERT_NE(audioInterruptService, nullptr);
-
-    uint32_t uid = 0;
-    int32_t streamId = 0;
-    InterruptEventInternal interruptEvent;
-    interruptEvent.hintType = INTERRUPT_HINT_UNDUCK;
-
-    uint32_t uid2 = 0;
-    ClientType clientType = CLIENT_TYPE_GAME;
-    ClientTypeManager::GetInstance()->OnClientTypeQueryCompleted(uid2, clientType);
-    auto ret = audioInterruptService->ShouldCallbackToClient(uid, streamId, interruptEvent);
-    EXPECT_EQ(ret, true);
-    EXPECT_EQ(interruptEvent.callbackToApp, false);
-}
-
-/**
-* @tc.name  : Test AudioInterruptService
-* @tc.number: AudioInterruptService_019
-* @tc.desc  : Test AudioInterruptService
-*/
-HWTEST(AudioInterruptServiceUnitTest, AudioInterruptService_019, TestSize.Level1)
-{
-    auto audioInterruptService = std::make_shared<AudioInterruptService>();
-    ASSERT_NE(audioInterruptService, nullptr);
-
-    uint32_t uid = 0;
-    int32_t streamId = 0;
-    InterruptEventInternal interruptEvent;
-    interruptEvent.hintType = INTERRUPT_HINT_NONE;
-
-    uint32_t uid2 = 0;
-    ClientType clientType = CLIENT_TYPE_GAME;
-    ClientTypeManager::GetInstance()->OnClientTypeQueryCompleted(uid2, clientType);
-    audioInterruptService->policyServer_ = new AudioPolicyServer(0);
-    ASSERT_NE(audioInterruptService->policyServer_, nullptr);
-    auto ret = audioInterruptService->ShouldCallbackToClient(uid, streamId, interruptEvent);
-    EXPECT_EQ(ret, false);
-}
-
-/**
-* @tc.name  : Test AudioInterruptService
-* @tc.number: AudioInterruptService_020
-* @tc.desc  : Test SetAudioManagerInterruptCallback
-*/
-HWTEST(AudioInterruptServiceUnitTest, AudioInterruptService_020, TestSize.Level1)
-{
-    auto audioInterruptService = std::make_shared<AudioInterruptService>();
-    ASSERT_NE(audioInterruptService, nullptr);
-
-    const sptr<IRemoteObject> object = new RemoteObjectTestStub();
-    auto ret = audioInterruptService->SetAudioManagerInterruptCallback(object);
-    EXPECT_EQ(ret, SUCCESS);
-
-    audioInterruptService->handler_ = std::make_shared<AudioPolicyServerHandler>();
-    ret = audioInterruptService->SetAudioManagerInterruptCallback(object);
-    EXPECT_EQ(ret, SUCCESS);
-}
-
-/**
-* @tc.name  : Test AudioInterruptService
-* @tc.number: AudioInterruptService_021
-* @tc.desc  : Test AudioInterruptService
-*/
-HWTEST(AudioInterruptServiceUnitTest, AudioInterruptService_021, TestSize.Level1)
-{
-    auto audioInterruptService = std::make_shared<AudioInterruptService>();
-    ASSERT_NE(audioInterruptService, nullptr);
-
-    int32_t zoneId = 0;
-    uint32_t streamId = 5;
-
-    int32_t map = audioInterruptService->ZONEID_DEFAULT;
-    std::shared_ptr<AudioInterruptZone> audioInterruptZone = std::make_shared<AudioInterruptZone>();
-    AudioInterrupt audioInterrupt;
-    audioInterrupt.streamId = 5;
-    AudioFocuState audioFocuState = ACTIVE;
-    audioInterruptZone->audioFocusInfoList.push_back({audioInterrupt, audioFocuState});
-    audioInterruptService->zonesMap_.insert({map, audioInterruptZone});
-
-    audioInterruptService->RemoveClient(zoneId, streamId);
-    EXPECT_EQ(audioInterruptService->zonesMap_.size(), 1);
-}
-
-/**
-* @tc.name  : Test AudioInterruptService
-* @tc.number: AudioInterruptService_022
-* @tc.desc  : Test AudioInterruptService
-*/
-HWTEST(AudioInterruptServiceUnitTest, AudioInterruptService_022, TestSize.Level1)
-{
-    auto audioInterruptService = std::make_shared<AudioInterruptService>();
-    ASSERT_NE(audioInterruptService, nullptr);
-
-    int32_t zoneId = 0;
-    uint32_t streamId = 5;
-
-    int32_t map = audioInterruptService->ZONEID_DEFAULT;
-    std::shared_ptr<AudioInterruptZone> audioInterruptZone = std::make_shared<AudioInterruptZone>();
-    AudioInterrupt audioInterrupt;
-    audioInterrupt.streamId = 0;
-    AudioFocuState audioFocuState = ACTIVE;
-    audioInterruptZone->audioFocusInfoList.push_back({audioInterrupt, audioFocuState});
-
-    uint32_t cb = 5;
-    auto audioInterruptCallbackTest = std::make_shared<AudioInterruptCallbackTest>();
-    audioInterruptZone->interruptCbsMap.insert({cb, audioInterruptCallbackTest});
-
-    audioInterruptService->zonesMap_.insert({map, audioInterruptZone});
-    EXPECT_EQ(audioInterruptService->zonesMap_.find(zoneId)->second->interruptCbsMap.size(), 1);
-
-    audioInterruptService->RemoveClient(zoneId, streamId);
-    EXPECT_EQ(audioInterruptService->zonesMap_.size(), 1);
-    EXPECT_EQ(audioInterruptService->zonesMap_.find(zoneId)->second->interruptCbsMap.size(), 0);
-}
-
-/**
-* @tc.name  : Test AudioInterruptService
-* @tc.number: AudioInterruptService_023
-* @tc.desc  : Test AudioInterruptService
-*/
-HWTEST(AudioInterruptServiceUnitTest, AudioInterruptService_023, TestSize.Level1)
-{
-    auto audioInterruptService = std::make_shared<AudioInterruptService>();
-    ASSERT_NE(audioInterruptService, nullptr);
-
-    int32_t zoneId = 0;
-    uint32_t streamId = 5;
-
-    int32_t map = audioInterruptService->ZONEID_DEFAULT;
-    std::shared_ptr<AudioInterruptZone> audioInterruptZone = std::make_shared<AudioInterruptZone>();
-    AudioInterrupt audioInterrupt;
-    audioInterrupt.streamId = 0;
-    AudioFocuState audioFocuState = ACTIVE;
-    audioInterruptZone->audioFocusInfoList.push_back({audioInterrupt, audioFocuState});
-
-    uint32_t cb = 0;
-    auto audioInterruptCallbackTest = std::make_shared<AudioInterruptCallbackTest>();
-    audioInterruptZone->interruptCbsMap.insert({cb, audioInterruptCallbackTest});
-
-    audioInterruptService->zonesMap_.insert({map, audioInterruptZone});
-    EXPECT_EQ(audioInterruptService->zonesMap_.find(zoneId)->second->interruptCbsMap.size(), 1);
-
-    audioInterruptService->RemoveClient(zoneId, streamId);
-    EXPECT_EQ(audioInterruptService->zonesMap_.size(), 1);
-    EXPECT_EQ(audioInterruptService->zonesMap_.find(zoneId)->second->interruptCbsMap.size(), 1);
-}
-
-/**
-* @tc.name  : Test AudioInterruptService
-* @tc.number: AudioInterruptService_024
-* @tc.desc  : Test AudioInterruptService
-*/
-HWTEST(AudioInterruptServiceUnitTest, AudioInterruptService_024, TestSize.Level1)
-{
-    auto audioInterruptService = std::make_shared<AudioInterruptService>();
-    ASSERT_NE(audioInterruptService, nullptr);
-
-    int32_t zoneId = 1;
-    uint32_t streamId = 5;
-
-    int32_t map = audioInterruptService->ZONEID_DEFAULT;
-    std::shared_ptr<AudioInterruptZone> audioInterruptZone = std::make_shared<AudioInterruptZone>();
-    AudioInterrupt audioInterrupt;
-    audioInterrupt.streamId = 0;
-    AudioFocuState audioFocuState = ACTIVE;
-    audioInterruptZone->audioFocusInfoList.push_back({audioInterrupt, audioFocuState});
-
-    uint32_t cb = 0;
-    auto audioInterruptCallbackTest = std::make_shared<AudioInterruptCallbackTest>();
-    audioInterruptZone->interruptCbsMap.insert({cb, audioInterruptCallbackTest});
-
-    audioInterruptService->zonesMap_.insert({map, audioInterruptZone});
-
-    audioInterruptService->RemoveClient(zoneId, streamId);
-    EXPECT_EQ(audioInterruptService->zonesMap_.size(), 1);
-}
-
-/**
-* @tc.name  : Test AudioInterruptService
-* @tc.number: AudioInterruptService_034
-* @tc.desc  : Test NotifyFocusGranted
-*/
-HWTEST(AudioInterruptServiceUnitTest, AudioInterruptService_034, TestSize.Level1)
-{
-    auto audioInterruptService = std::make_shared<AudioInterruptService>();
-    ASSERT_NE(audioInterruptService, nullptr);
-
-    int32_t clientId = 0;
-    AudioInterrupt audioInterrupt;
-    audioInterruptService->handler_ = std::make_shared<AudioPolicyServerHandler>();
-    ASSERT_TRUE(audioInterruptService->handler_ != nullptr);
-    audioInterruptService->NotifyFocusGranted(clientId, audioInterrupt);
-}
-
-/**
-* @tc.name  : Test AudioInterruptService
-* @tc.number: AudioInterruptService_035
-* @tc.desc  : Test NotifyFocusAbandoned
-*/
-HWTEST(AudioInterruptServiceUnitTest, AudioInterruptService_035, TestSize.Level1)
-{
-    auto audioInterruptService = std::make_shared<AudioInterruptService>();
-    ASSERT_NE(audioInterruptService, nullptr);
-
-    int32_t clientId = 0;
-    AudioInterrupt audioInterrupt;
-    audioInterruptService->handler_ = std::make_shared<AudioPolicyServerHandler>();
-    ASSERT_TRUE(audioInterruptService->handler_ != nullptr);
-    auto ret = audioInterruptService->NotifyFocusAbandoned(clientId, audioInterrupt);
-    EXPECT_EQ(ret, SUCCESS);
-}
-
-/**
-* @tc.name  : Test AudioInterruptService
-* @tc.number: AudioInterruptService_036
-* @tc.desc  : Test AbandonAudioFocusInternal
-*/
-HWTEST(AudioInterruptServiceUnitTest, AudioInterruptService_036, TestSize.Level1)
-{
-    auto audioInterruptService = std::make_shared<AudioInterruptService>();
-    ASSERT_NE(audioInterruptService, nullptr);
-
-    int32_t clientId = 0;
-    AudioInterrupt audioInterrupt;
-    auto ret = audioInterruptService->AbandonAudioFocusInternal(clientId, audioInterrupt);
-    EXPECT_EQ(ret, SUCCESS);
-
-    clientId = 10;
-    audioInterruptService->AbandonAudioFocusInternal(clientId, audioInterrupt);
-    EXPECT_EQ(ret, SUCCESS);
-}
-
-/**
-* @tc.name  : Test AudioInterruptService
-* @tc.number: AudioInterruptService_037
-* @tc.desc  : Test CheckAudioSessionExistence
-*/
-HWTEST(AudioInterruptServiceUnitTest, AudioInterruptService_037, TestSize.Level1)
-{
-    auto audioInterruptService = std::make_shared<AudioInterruptService>();
-    ASSERT_NE(audioInterruptService, nullptr);
-
-    AudioInterrupt incomingInterrupt;
-    incomingInterrupt.pid = 0;
-    AudioFocusEntry focusEntry;
-    focusEntry.actionOn = CURRENT;
-
-    AudioSessionStrategy strategy;
-    std::shared_ptr<AudioSessionStateMonitor> audioSessionStateMonitor = nullptr;
-    auto audioSession = std::make_shared<AudioSession>(incomingInterrupt.pid, strategy, audioSessionStateMonitor);
-    audioInterruptService->sessionService_ = std::make_shared<AudioSessionService>();
-    audioInterruptService->sessionService_->sessionMap_[incomingInterrupt.pid] = audioSession;
-    auto ret = audioInterruptService->CheckAudioSessionExistence(incomingInterrupt, focusEntry);
-    EXPECT_TRUE(ret);
-    audioInterruptService->UpdateHintTypeForExistingSession(incomingInterrupt, focusEntry);
-
-    focusEntry.actionOn = INCOMING;
-    ret = audioInterruptService->CheckAudioSessionExistence(incomingInterrupt, focusEntry);
-    EXPECT_FALSE(ret);
-}
-
-/**
-* @tc.name  : Test AudioInterruptService
-* @tc.number: AudioInterruptService_038
-* @tc.desc  : Test CheckAudioSessionExistence
-*/
-HWTEST(AudioInterruptServiceUnitTest, AudioInterruptService_038, TestSize.Level1)
-{
-    auto audioInterruptService = std::make_shared<AudioInterruptService>();
-    ASSERT_NE(audioInterruptService, nullptr);
-
-    AudioInterrupt incomingInterrupt;
-    incomingInterrupt.pid = 0;
-    AudioFocusEntry focusEntry;
-    focusEntry.actionOn = CURRENT;
-
-    audioInterruptService->sessionService_ = std::make_shared<AudioSessionService>();
-    audioInterruptService->sessionService_->sessionMap_[incomingInterrupt.pid] = nullptr;
-    auto ret = audioInterruptService->CheckAudioSessionExistence(incomingInterrupt, focusEntry);
-    EXPECT_FALSE(ret);
-}
-
-/**
-* @tc.name  : Test AudioInterruptService
-* @tc.number: AudioInterruptService_039
-* @tc.desc  : Test UpdateHintTypeForExistingSession
-*/
-HWTEST(AudioInterruptServiceUnitTest, AudioInterruptService_039, TestSize.Level1)
-{
-    auto audioInterruptService = std::make_shared<AudioInterruptService>();
-    ASSERT_NE(audioInterruptService, nullptr);
-
-    AudioInterrupt incomingInterrupt;
-    AudioFocusEntry focusEntry;
-    focusEntry.hintType = INTERRUPT_HINT_DUCK;
-    incomingInterrupt.sessionStrategy.concurrencyMode = AudioConcurrencyMode::DUCK_OTHERS;
-    audioInterruptService->UpdateHintTypeForExistingSession(incomingInterrupt, focusEntry);
-
-    focusEntry.hintType = INTERRUPT_HINT_PAUSE;
-    audioInterruptService->UpdateHintTypeForExistingSession(incomingInterrupt, focusEntry);
-    EXPECT_EQ(focusEntry.hintType, INTERRUPT_HINT_DUCK);
-
-    focusEntry.hintType = INTERRUPT_HINT_STOP;
-    audioInterruptService->UpdateHintTypeForExistingSession(incomingInterrupt, focusEntry);
-    EXPECT_EQ(focusEntry.hintType, INTERRUPT_HINT_DUCK);
-
-    focusEntry.hintType = INTERRUPT_HINT_NONE;
-    audioInterruptService->UpdateHintTypeForExistingSession(incomingInterrupt, focusEntry);
-}
-
-/**
-* @tc.name  : Test AudioInterruptService
-* @tc.number: AudioInterruptService_040
-* @tc.desc  : Test UpdateHintTypeForExistingSession
-*/
-HWTEST(AudioInterruptServiceUnitTest, AudioInterruptService_040, TestSize.Level1)
-{
-    auto audioInterruptService = std::make_shared<AudioInterruptService>();
-    ASSERT_NE(audioInterruptService, nullptr);
-
-    AudioInterrupt incomingInterrupt;
-    AudioFocusEntry focusEntry;
-    incomingInterrupt.sessionStrategy.concurrencyMode = AudioConcurrencyMode::PAUSE_OTHERS;
-
-    focusEntry.hintType = INTERRUPT_HINT_PAUSE;
-    audioInterruptService->UpdateHintTypeForExistingSession(incomingInterrupt, focusEntry);
-    EXPECT_EQ(focusEntry.hintType, INTERRUPT_HINT_PAUSE);
-
-    focusEntry.hintType = INTERRUPT_HINT_STOP;
-    audioInterruptService->UpdateHintTypeForExistingSession(incomingInterrupt, focusEntry);
-    EXPECT_EQ(focusEntry.hintType, INTERRUPT_HINT_PAUSE);
-
-    focusEntry.hintType = INTERRUPT_HINT_NONE;
-    audioInterruptService->UpdateHintTypeForExistingSession(incomingInterrupt, focusEntry);
-}
-
-/**
-* @tc.name  : Test AudioInterruptService
-* @tc.number: AudioInterruptService_041
-* @tc.desc  : Test ProcessExistInterrupt
-*/
-HWTEST(AudioInterruptServiceUnitTest, AudioInterruptService_041, TestSize.Level1)
-{
-    auto audioInterruptService = std::make_shared<AudioInterruptService>();
-    ASSERT_NE(audioInterruptService, nullptr);
-
-    AudioFocusEntry focusEntry;
-    AudioInterrupt incomingInterrupt;
-    bool removeFocusInfo = true;
-    InterruptEventInternal interruptEvent;
-    std::list<std::pair<AudioInterrupt, AudioFocuState>> audioList;
-    audioList.push_back(std::make_pair(incomingInterrupt, ACTIVE));
-    std::list<std::pair<AudioInterrupt, AudioFocuState>>::iterator iterActive = audioList.begin();
-
-    focusEntry.hintType = INTERRUPT_HINT_PAUSE;
-    audioInterruptService->ProcessExistInterrupt(iterActive, focusEntry, incomingInterrupt,
-        removeFocusInfo, interruptEvent);
-    EXPECT_EQ(interruptEvent.hintType, focusEntry.hintType);
-}
-
-/**
-* @tc.name  : Test AudioInterruptService
-* @tc.number: AudioInterruptService_042
-* @tc.desc  : Test ProcessExistInterrupt
-*/
-HWTEST(AudioInterruptServiceUnitTest, AudioInterruptService_042, TestSize.Level1)
-{
-    auto audioInterruptService = std::make_shared<AudioInterruptService>();
-    ASSERT_NE(audioInterruptService, nullptr);
-
-    AudioFocusEntry focusEntry;
-    AudioInterrupt incomingInterrupt;
-    bool removeFocusInfo = true;
-    InterruptEventInternal interruptEvent;
-    std::list<std::pair<AudioInterrupt, AudioFocuState>> audioList;
-    audioList.push_back(std::make_pair(incomingInterrupt, DUCK));
-    std::list<std::pair<AudioInterrupt, AudioFocuState>>::iterator iterActive = audioList.begin();
-
-    focusEntry.hintType = INTERRUPT_HINT_PAUSE;
-    audioInterruptService->ProcessExistInterrupt(iterActive, focusEntry, incomingInterrupt,
-        removeFocusInfo, interruptEvent);
-    EXPECT_EQ(interruptEvent.hintType, focusEntry.hintType);
-}
-
-/**
-* @tc.name  : Test AudioInterruptService
-* @tc.number: AudioInterruptService_043
-* @tc.desc  : Test ProcessExistInterrupt
-*/
-HWTEST(AudioInterruptServiceUnitTest, AudioInterruptService_043, TestSize.Level1)
-{
-    auto audioInterruptService = std::make_shared<AudioInterruptService>();
-    ASSERT_NE(audioInterruptService, nullptr);
-
-    AudioFocusEntry focusEntry;
-    AudioInterrupt incomingInterrupt;
-    bool removeFocusInfo = true;
-    InterruptEventInternal interruptEvent;
-    std::list<std::pair<AudioInterrupt, AudioFocuState>> audioList;
-    audioList.push_back(std::make_pair(incomingInterrupt, STOP));
-    std::list<std::pair<AudioInterrupt, AudioFocuState>>::iterator iterActive = audioList.begin();
-
-    focusEntry.hintType = INTERRUPT_HINT_PAUSE;
-    audioInterruptService->ProcessExistInterrupt(iterActive, focusEntry, incomingInterrupt,
-        removeFocusInfo, interruptEvent);
-}
-
-/**
-* @tc.name  : Test AudioInterruptService
-* @tc.number: AudioInterruptService_044
-* @tc.desc  : Test ProcessExistInterrupt
-*/
-HWTEST(AudioInterruptServiceUnitTest, AudioInterruptService_044, TestSize.Level1)
-{
-    auto audioInterruptService = std::make_shared<AudioInterruptService>();
-    ASSERT_NE(audioInterruptService, nullptr);
-
-    AudioFocusEntry focusEntry;
-    AudioInterrupt incomingInterrupt;
-    bool removeFocusInfo = true;
-    InterruptEventInternal interruptEvent;
-    std::list<std::pair<AudioInterrupt, AudioFocuState>> audioList;
-    audioList.push_back(std::make_pair(incomingInterrupt, ACTIVE));
-    std::list<std::pair<AudioInterrupt, AudioFocuState>>::iterator iterActive = audioList.begin();
-
-    focusEntry.hintType = INTERRUPT_HINT_DUCK;
-    audioInterruptService->ProcessExistInterrupt(iterActive, focusEntry, incomingInterrupt,
-        removeFocusInfo, interruptEvent);
-    EXPECT_EQ(interruptEvent.hintType, focusEntry.hintType);
-}
-
-/**
-* @tc.name  : Test AudioInterruptService
-* @tc.number: AudioInterruptService_045
-* @tc.desc  : Test ProcessExistInterrupt
-*/
-HWTEST(AudioInterruptServiceUnitTest, AudioInterruptService_045, TestSize.Level1)
-{
-    auto audioInterruptService = std::make_shared<AudioInterruptService>();
-    ASSERT_NE(audioInterruptService, nullptr);
-
-    AudioFocusEntry focusEntry;
-    AudioInterrupt incomingInterrupt;
-    bool removeFocusInfo = true;
-    InterruptEventInternal interruptEvent;
-    std::list<std::pair<AudioInterrupt, AudioFocuState>> audioList;
-    audioList.push_back(std::make_pair(incomingInterrupt, DUCK));
-    std::list<std::pair<AudioInterrupt, AudioFocuState>>::iterator iterActive = audioList.begin();
-
-    focusEntry.hintType = INTERRUPT_HINT_DUCK;
-    audioInterruptService->ProcessExistInterrupt(iterActive, focusEntry, incomingInterrupt,
-        removeFocusInfo, interruptEvent);
-}
-
-/**
-* @tc.name  : Test AudioInterruptService
-* @tc.number: AudioInterruptService_046
-* @tc.desc  : Test ProcessExistInterrupt
-*/
-HWTEST(AudioInterruptServiceUnitTest, AudioInterruptService_046, TestSize.Level1)
-{
-    auto audioInterruptService = std::make_shared<AudioInterruptService>();
-    ASSERT_NE(audioInterruptService, nullptr);
-
-    AudioFocusEntry focusEntry;
-    AudioInterrupt incomingInterrupt;
-    bool removeFocusInfo = true;
-    InterruptEventInternal interruptEvent;
-    std::list<std::pair<AudioInterrupt, AudioFocuState>> audioList;
-    audioList.push_back(std::make_pair(incomingInterrupt, DUCK));
-    std::list<std::pair<AudioInterrupt, AudioFocuState>>::iterator iterActive = audioList.begin();
-
-    focusEntry.hintType = INTERRUPT_HINT_UNDUCK;
-    audioInterruptService->ProcessExistInterrupt(iterActive, focusEntry, incomingInterrupt,
-        removeFocusInfo, interruptEvent);
-}
-
-/**
-* @tc.name  : Test AudioInterruptService
-* @tc.number: AudioInterruptService_047
-* @tc.desc  : Test ProcessExistInterrupt
-*/
-HWTEST(AudioInterruptServiceUnitTest, AudioInterruptService_047, TestSize.Level1)
-{
-    auto audioInterruptService = std::make_shared<AudioInterruptService>();
-    ASSERT_NE(audioInterruptService, nullptr);
-
-    AudioInterrupt audioInterrupt;
-    InterruptEventInternal interruptEvent;
-    std::list<std::pair<AudioInterrupt, AudioFocuState>>::iterator iterActive;
-    std::list<std::pair<AudioInterrupt, AudioFocuState>> tmpFocusInfoList;
-
-    tmpFocusInfoList.push_back(std::make_pair<>(audioInterrupt, ACTIVE));
-    iterActive = tmpFocusInfoList.begin();
-
-    interruptEvent.hintType = INTERRUPT_HINT_STOP;
-    audioInterruptService->SwitchHintType(iterActive, interruptEvent, tmpFocusInfoList);
-}
-
-/**
-* @tc.name  : Test AudioInterruptService
-* @tc.number: AudioInterruptService_048
-* @tc.desc  : Test ProcessExistInterrupt
-*/
-HWTEST(AudioInterruptServiceUnitTest, AudioInterruptService_048, TestSize.Level1)
-{
-    auto audioInterruptService = std::make_shared<AudioInterruptService>();
-    ASSERT_NE(audioInterruptService, nullptr);
-
-    AudioInterrupt audioInterrupt;
-    InterruptEventInternal interruptEvent;
-    std::list<std::pair<AudioInterrupt, AudioFocuState>>::iterator iterActive;
-    std::list<std::pair<AudioInterrupt, AudioFocuState>> tmpFocusInfoList;
-
-    tmpFocusInfoList.push_back(std::make_pair<>(audioInterrupt, ACTIVE));
-    iterActive = tmpFocusInfoList.begin();
-
-    interruptEvent.hintType = INTERRUPT_HINT_PAUSE;
-    audioInterruptService->SwitchHintType(iterActive, interruptEvent, tmpFocusInfoList);
-    EXPECT_EQ(iterActive->second, PAUSEDBYREMOTE);
-}
-
-/**
-* @tc.name  : Test AudioInterruptService
-* @tc.number: AudioInterruptService_049
-* @tc.desc  : Test ProcessExistInterrupt
-*/
-HWTEST(AudioInterruptServiceUnitTest, AudioInterruptService_049, TestSize.Level1)
-{
-    auto audioInterruptService = std::make_shared<AudioInterruptService>();
-    ASSERT_NE(audioInterruptService, nullptr);
-
-    AudioInterrupt audioInterrupt;
-    InterruptEventInternal interruptEvent;
-    std::list<std::pair<AudioInterrupt, AudioFocuState>>::iterator iterActive;
-    std::list<std::pair<AudioInterrupt, AudioFocuState>> tmpFocusInfoList;
-
-    tmpFocusInfoList.push_back(std::make_pair<>(audioInterrupt, DUCK));
-    iterActive = tmpFocusInfoList.begin();
-
-    interruptEvent.hintType = INTERRUPT_HINT_PAUSE;
-    audioInterruptService->SwitchHintType(iterActive, interruptEvent, tmpFocusInfoList);
-    EXPECT_EQ(iterActive->second, PAUSEDBYREMOTE);
-}
-
-/**
-* @tc.name  : Test AudioInterruptService
-* @tc.number: AudioInterruptService_050
-* @tc.desc  : Test ProcessExistInterrupt
-*/
-HWTEST(AudioInterruptServiceUnitTest, AudioInterruptService_050, TestSize.Level1)
-{
-    auto audioInterruptService = std::make_shared<AudioInterruptService>();
-    ASSERT_NE(audioInterruptService, nullptr);
-
-    AudioInterrupt audioInterrupt;
-    InterruptEventInternal interruptEvent;
-    std::list<std::pair<AudioInterrupt, AudioFocuState>>::iterator iterActive;
-    std::list<std::pair<AudioInterrupt, AudioFocuState>> tmpFocusInfoList;
-
-    tmpFocusInfoList.push_back(std::make_pair<>(audioInterrupt, PLACEHOLDER));
-    iterActive = tmpFocusInfoList.begin();
-
-    interruptEvent.hintType = INTERRUPT_HINT_PAUSE;
-    audioInterruptService->SwitchHintType(iterActive, interruptEvent, tmpFocusInfoList);
-}
-
-/**
-* @tc.name  : Test AudioInterruptService
-* @tc.number: AudioInterruptService_051
-* @tc.desc  : Test ReportRecordGetFocusFail
-*/
-HWTEST(AudioInterruptServiceUnitTest, AudioInterruptService_051, TestSize.Level1)
-{
-    auto audioInterruptService = std::make_shared<AudioInterruptService>();
-    ASSERT_NE(audioInterruptService, nullptr);
-
-    AudioInterrupt incomingInterrupt = {};
-    incomingInterrupt.audioFocusType.sourceType = SOURCE_TYPE_MIC;
-    AudioInterrupt activeInterrupt = {};
-    activeInterrupt.audioFocusType.sourceType = SOURCE_TYPE_MIC;
-    audioInterruptService->ReportRecordGetFocusFail(incomingInterrupt, activeInterrupt, RECORD_ERROR_GET_FOCUS_FAIL);
-}
-
-/**
-* @tc.name  : Test AudioInterruptService
-* @tc.number: AudioInterruptService_052
-* @tc.desc  : Test UpdateMicFocusStrategy
-*/
-HWTEST(AudioInterruptServiceUnitTest, AudioInterruptService_052, TestSize.Level1)
-{
-    auto audioInterruptService = std::make_shared<AudioInterruptService>();
-    ASSERT_NE(audioInterruptService, nullptr);
-
-    SourceType existSourceType;
-    SourceType incomingSourceType;
-    AudioStreamType existStreamType = STREAM_ALARM;
-    AudioStreamType incomingStreamType = STREAM_ALARM;
-    std::string bundleName = "";
-    std::string currentBundleName = "";
-    AudioFocusEntry focusEntry;
-
-    existSourceType = SOURCE_TYPE_INVALID;
-    incomingSourceType = SOURCE_TYPE_MIC;
-    focusEntry.hintType = INTERRUPT_HINT_PAUSE;
-    audioInterruptService->UpdateMicFocusStrategy(existSourceType, incomingSourceType,
-        existStreamType, incomingStreamType, currentBundleName, bundleName, focusEntry);
-    EXPECT_NE(focusEntry.hintType, INTERRUPT_HINT_NONE);
-}
-
-/**
-* @tc.name  : Test AudioSessionFocusMode
-* @tc.number: AudioInterruptService_053
-* @tc.desc  : Test AudioSessionFocusMode
-*/
-HWTEST(AudioInterruptServiceUnitTest, AudioInterruptService_053, TestSize.Level1)
-{
-    auto audioInterruptService = std::make_shared<AudioInterruptService>();
-    ASSERT_NE(audioInterruptService, nullptr);
-
-    int32_t fakePid = 123;
-    AudioInterrupt incomingInterrupt;
-    incomingInterrupt.pid = fakePid;
-    incomingInterrupt.audioFocusType.streamType = STREAM_MUSIC;
-    incomingInterrupt.streamId = 888; // 888 is a fake stream id.
-
-    std::shared_ptr<AudioSessionService> sessionService = std::make_shared<AudioSessionService>();
-    audioInterruptService->sessionService_ = sessionService;
-    int ret = sessionService->SetAudioSessionScene(fakePid, AudioSessionScene::MEDIA);
-    EXPECT_EQ(SUCCESS, ret);
-    AudioSessionStrategy audioSessionStrategy;
-    audioSessionStrategy.concurrencyMode = AudioConcurrencyMode::DEFAULT;
-    ret = sessionService->ActivateAudioSession(fakePid, audioSessionStrategy);
-    EXPECT_EQ(SUCCESS, ret);
-    ret = audioInterruptService->ActivateAudioInterrupt(0, incomingInterrupt, false);
-    EXPECT_EQ(SUCCESS, ret);
-}
-
-} // namespace AudioStandard
-} // namespace OHOS
\ No newline at end of file
diff --git a/services/audio_policy/test/unittest/audio_interrupt_service_test/src/audio_interrupt_unit_test.cpp b/services/audio_policy/test/unittest/audio_interrupt_service_test/src/audio_interrupt_unit_test.cpp
index dbe83517c0244ec070c28facf7aad76791027797..b3eb60be8fec5793145f5402efd2440c1f2816e4 100644
--- a/services/audio_policy/test/unittest/audio_interrupt_service_test/src/audio_interrupt_unit_test.cpp
+++ b/services/audio_policy/test/unittest/audio_interrupt_service_test/src/audio_interrupt_unit_test.cpp
@@ -68,7 +68,12 @@ void AudioInterruptUnitTest::TearDownTestCase(void)
     serverTest = nullptr;
 }
 void AudioInterruptUnitTest::SetUp(void) {}
-void AudioInterruptUnitTest::TearDown(void) {}
+void AudioInterruptUnitTest::TearDown(void)
+{
+    auto &audioSessionService = OHOS::Singleton<AudioSessionService>::GetInstance();
+    audioSessionService.sessionMap_.clear();
+    audioSessionService.timeOutCallback_.reset();
+}
 
 std::shared_ptr<AudioInterruptService> GetTnterruptServiceTest()
 {
@@ -109,7 +114,7 @@ sptr<AudioPolicyServer> GetPolicyServerTest()
 * @tc.number: AudioInterruptService_004
 * @tc.desc  : Test AddDumpInfo.
 */
-HWTEST(AudioInterruptUnitTest, AudioInterruptService_004, TestSize.Level1)
+HWTEST_F(AudioInterruptUnitTest, AudioInterruptService_004, TestSize.Level1)
 {
     std::string dumpString;
     auto interruptServiceTest = GetTnterruptServiceTest();
@@ -128,7 +133,7 @@ HWTEST(AudioInterruptUnitTest, AudioInterruptService_004, TestSize.Level1)
 * @tc.number: AudioInterruptService_005
 * @tc.desc  : Test AbandonAudioFocus.
 */
-HWTEST(AudioInterruptUnitTest, AudioInterruptService_005, TestSize.Level1)
+HWTEST_F(AudioInterruptUnitTest, AudioInterruptService_005, TestSize.Level1)
 {
     auto interruptServiceTest = GetTnterruptServiceTest();
     AudioInterrupt incomingInterrupt;
@@ -154,7 +159,7 @@ public:
 * @tc.number: AudioInterruptService_006
 * @tc.desc  : Test SetAudioInterruptCallback and UnsetAudioInterruptCallback.
 */
-HWTEST(AudioInterruptUnitTest, AudioInterruptService_006, TestSize.Level1)
+HWTEST_F(AudioInterruptUnitTest, AudioInterruptService_006, TestSize.Level1)
 {
     auto interruptServiceTest = GetTnterruptServiceTest();
     auto retStatus = interruptServiceTest->SetAudioInterruptCallback(0, 0, nullptr, 0);
@@ -197,7 +202,7 @@ HWTEST(AudioInterruptUnitTest, AudioInterruptService_006, TestSize.Level1)
 * @tc.number: AudioInterruptService_008
 * @tc.desc  : Test ResumeAudioFocusList and SimulateFocusEntry.
 */
-HWTEST(AudioInterruptUnitTest, AudioInterruptService_008, TestSize.Level1)
+HWTEST_F(AudioInterruptUnitTest, AudioInterruptService_008, TestSize.Level1)
 {
     auto interruptServiceTest = GetTnterruptServiceTest();
     interruptServiceTest->Init(GetPolicyServerTest());
@@ -230,7 +235,7 @@ HWTEST(AudioInterruptUnitTest, AudioInterruptService_008, TestSize.Level1)
 * @tc.number: AudioInterruptService_010
 * @tc.desc  : Test ResumeAudioFocusList and SimulateFocusEntry.
 */
-HWTEST(AudioInterruptUnitTest, AudioInterruptService_010, TestSize.Level1)
+HWTEST_F(AudioInterruptUnitTest, AudioInterruptService_010, TestSize.Level1)
 {
     auto interruptServiceTest = GetTnterruptServiceTest();
     interruptServiceTest->Init(GetPolicyServerTest());
@@ -273,7 +278,7 @@ HWTEST(AudioInterruptUnitTest, AudioInterruptService_010, TestSize.Level1)
 * @tc.number: AudioInterruptService_012
 * @tc.desc  : Test ResumeAudioFocusList and SimulateFocusEntry.
 */
-HWTEST(AudioInterruptUnitTest, AudioInterruptService_012, TestSize.Level1)
+HWTEST_F(AudioInterruptUnitTest, AudioInterruptService_012, TestSize.Level1)
 {
     auto interruptServiceTest = GetTnterruptServiceTest();
     interruptServiceTest->Init(GetPolicyServerTest());
@@ -296,7 +301,7 @@ HWTEST(AudioInterruptUnitTest, AudioInterruptService_012, TestSize.Level1)
 * @tc.number: AudioInterruptService_013
 * @tc.desc  : Test ResumeAudioFocusList and SimulateFocusEntry.
 */
-HWTEST(AudioInterruptUnitTest, AudioInterruptService_013, TestSize.Level1)
+HWTEST_F(AudioInterruptUnitTest, AudioInterruptService_013, TestSize.Level1)
 {
     auto interruptServiceTest = GetTnterruptServiceTest();
     interruptServiceTest->Init(GetPolicyServerTest());
@@ -319,7 +324,7 @@ HWTEST(AudioInterruptUnitTest, AudioInterruptService_013, TestSize.Level1)
 * @tc.number: AudioInterruptService_015
 * @tc.desc  : Test SendInterruptEvent.
 */
-HWTEST(AudioInterruptUnitTest, AudioInterruptService_015, TestSize.Level1)
+HWTEST_F(AudioInterruptUnitTest, AudioInterruptService_015, TestSize.Level1)
 {
     auto interruptServiceTest = GetTnterruptServiceTest();
     std::list<std::pair<AudioInterrupt, AudioFocuState>> pairList;
@@ -349,7 +354,7 @@ HWTEST(AudioInterruptUnitTest, AudioInterruptService_015, TestSize.Level1)
 * @tc.number: AudioInterruptService_017
 * @tc.desc  : Test IsActiveStreamLowPriority and IsIncomingStreamLowPriority.
 */
-HWTEST(AudioInterruptUnitTest, AudioInterruptService_017, TestSize.Level1)
+HWTEST_F(AudioInterruptUnitTest, AudioInterruptService_017, TestSize.Level1)
 {
     auto interruptServiceTest = GetTnterruptServiceTest();
     AudioFocusEntry entry;
@@ -399,7 +404,7 @@ HWTEST(AudioInterruptUnitTest, AudioInterruptService_017, TestSize.Level1)
 * @tc.number: AudioInterruptService_018
 * @tc.desc  : Test WriteServiceStartupError.
 */
-HWTEST(AudioInterruptUnitTest, AudioInterruptService_018, TestSize.Level1)
+HWTEST_F(AudioInterruptUnitTest, AudioInterruptService_018, TestSize.Level1)
 {
     auto interruptServiceTest = GetTnterruptServiceTest();
     EXPECT_NO_THROW(
@@ -412,7 +417,7 @@ HWTEST(AudioInterruptUnitTest, AudioInterruptService_018, TestSize.Level1)
 * @tc.number: AudioInterruptService_019
 * @tc.desc  : Test SendFocusChangeEvent.
 */
-HWTEST(AudioInterruptUnitTest, AudioInterruptService_019, TestSize.Level1)
+HWTEST_F(AudioInterruptUnitTest, AudioInterruptService_019, TestSize.Level1)
 {
     auto interruptServiceTest = GetTnterruptServiceTest();
     AudioInterrupt audioInterrupt = {};
@@ -436,7 +441,7 @@ HWTEST(AudioInterruptUnitTest, AudioInterruptService_019, TestSize.Level1)
 * @tc.number: AudioInterruptService_021
 * @tc.desc  : Test ClearAudioFocusInfoListOnAccountsChanged.
 */
-HWTEST(AudioInterruptUnitTest, AudioInterruptService_021, TestSize.Level1)
+HWTEST_F(AudioInterruptUnitTest, AudioInterruptService_021, TestSize.Level1)
 {
     auto interruptServiceTest = GetTnterruptServiceTest();
     sptr<AudioPolicyServer> server = nullptr;
@@ -467,7 +472,7 @@ HWTEST(AudioInterruptUnitTest, AudioInterruptService_021, TestSize.Level1)
 * @tc.number: AudioInterruptService_022
 * @tc.desc  : Test ResetNonInterruptControl.
 */
-HWTEST(AudioInterruptUnitTest, AudioInterruptService_022, TestSize.Level1)
+HWTEST_F(AudioInterruptUnitTest, AudioInterruptService_022, TestSize.Level1)
 {
     uint32_t sessionId = CLIENT_TYPE_OTHERS;
     auto interruptServiceTest = GetTnterruptServiceTest();
@@ -494,7 +499,7 @@ HWTEST(AudioInterruptUnitTest, AudioInterruptService_022, TestSize.Level1)
 * @tc.number: AudioInterruptService_023
 * @tc.desc  : Test CreateAudioInterruptZone.
 */
-HWTEST(AudioInterruptUnitTest, AudioInterruptService_023, TestSize.Level1)
+HWTEST_F(AudioInterruptUnitTest, AudioInterruptService_023, TestSize.Level1)
 {
     MessageParcel data;
     auto interruptServiceTest = GetTnterruptServiceTest();
@@ -510,11 +515,11 @@ HWTEST(AudioInterruptUnitTest, AudioInterruptService_023, TestSize.Level1)
     AudioZoneContext context;
 
     int32_t ret = interruptServiceTest->CreateAudioInterruptZone(zoneId, context);
-    EXPECT_EQ(ret, VALUE_ERROR);
+    EXPECT_EQ(VALUE_ERROR, ret);
 
     zoneId = 0;
     ret = interruptServiceTest->CreateAudioInterruptZone(zoneId, context);
-    EXPECT_EQ(ret, VALUE_ERROR);
+    EXPECT_EQ(VALUE_ERROR, ret);
 }
 
 /**
@@ -522,7 +527,7 @@ HWTEST(AudioInterruptUnitTest, AudioInterruptService_023, TestSize.Level1)
 * @tc.number: AudioInterruptService_024
 * @tc.desc  : Test ReleaseAudioInterruptZone.
 */
-HWTEST(AudioInterruptUnitTest, AudioInterruptService_024, TestSize.Level1)
+HWTEST_F(AudioInterruptUnitTest, AudioInterruptService_024, TestSize.Level1)
 {
     auto interruptServiceTest = GetTnterruptServiceTest();
     int32_t zoneId = 1;
@@ -551,7 +556,7 @@ HWTEST(AudioInterruptUnitTest, AudioInterruptService_024, TestSize.Level1)
 * @tc.number: AudioInterruptService_025
 * @tc.desc  : Test ReleaseAudioInterruptZone.
 */
-HWTEST(AudioInterruptUnitTest, AudioInterruptService_025, TestSize.Level1)
+HWTEST_F(AudioInterruptUnitTest, AudioInterruptService_025, TestSize.Level1)
 {
     auto interruptServiceTest = GetTnterruptServiceTest();
     int32_t zoneId = 0;
@@ -583,7 +588,7 @@ HWTEST(AudioInterruptUnitTest, AudioInterruptService_025, TestSize.Level1)
 * @tc.number: AudioInterruptService_027
 * @tc.desc  : Test GetAudioFocusInfoList.
 */
-HWTEST(AudioInterruptUnitTest, AudioInterruptService_027, TestSize.Level1)
+HWTEST_F(AudioInterruptUnitTest, AudioInterruptService_027, TestSize.Level1)
 {
     auto interruptServiceTest = GetTnterruptServiceTest();
     int32_t zoneId = 0;
@@ -609,7 +614,7 @@ HWTEST(AudioInterruptUnitTest, AudioInterruptService_027, TestSize.Level1)
 * @tc.number: AudioInterruptService_028
 * @tc.desc  : Test GetStreamInFocus.
 */
-HWTEST(AudioInterruptUnitTest, AudioInterruptService_028, TestSize.Level1)
+HWTEST_F(AudioInterruptUnitTest, AudioInterruptService_028, TestSize.Level1)
 {
     auto interruptServiceTest = GetTnterruptServiceTest();
     int32_t zoneId = 0;
@@ -633,7 +638,7 @@ HWTEST(AudioInterruptUnitTest, AudioInterruptService_028, TestSize.Level1)
 * @tc.number: AudioInterruptService_029
 * @tc.desc  : Test GetAudioServerProxy.
 */
-HWTEST(AudioInterruptUnitTest, AudioInterruptService_029, TestSize.Level1)
+HWTEST_F(AudioInterruptUnitTest, AudioInterruptService_029, TestSize.Level1)
 {
     auto interruptServiceTest = GetTnterruptServiceTest();
     const sptr<IStandardAudioService> result = interruptServiceTest->GetAudioServerProxy();
@@ -645,7 +650,7 @@ HWTEST(AudioInterruptUnitTest, AudioInterruptService_029, TestSize.Level1)
 * @tc.number: AudioInterruptService_030
 * @tc.desc  : Test OnSessionTimeout.
 */
-HWTEST(AudioInterruptUnitTest, AudioInterruptService_030, TestSize.Level1)
+HWTEST_F(AudioInterruptUnitTest, AudioInterruptService_030, TestSize.Level1)
 {
     auto interruptServiceTest = GetTnterruptServiceTest();
     AudioInterrupt audioInterrupt = {};
@@ -659,17 +664,13 @@ HWTEST(AudioInterruptUnitTest, AudioInterruptService_030, TestSize.Level1)
 * @tc.number: AudioInterruptService_031
 * @tc.desc  : Test ActivateAudioSession.
 */
-HWTEST(AudioInterruptUnitTest, AudioInterruptService_031, TestSize.Level1)
+HWTEST_F(AudioInterruptUnitTest, AudioInterruptService_031, TestSize.Level1)
 {
     auto interruptServiceTest = GetTnterruptServiceTest();
     int32_t CALLER_PID = IPCSkeleton::GetCallingPid();
     AudioSessionStrategy strategy;
-    interruptServiceTest->ActivateAudioSession(0, CALLER_PID, strategy);
-    EXPECT_NE(interruptServiceTest, nullptr);
-
-    interruptServiceTest->sessionService_ = nullptr;
     int32_t result = interruptServiceTest->ActivateAudioSession(0, CALLER_PID, strategy);
-    EXPECT_EQ(result, ERR_UNKNOWN);
+    EXPECT_EQ(SUCCESS, result);
 }
 
 /**
@@ -677,16 +678,12 @@ HWTEST(AudioInterruptUnitTest, AudioInterruptService_031, TestSize.Level1)
 * @tc.number: AudioInterruptService_032
 * @tc.desc  : Test AddActiveInterruptToSession.
 */
-HWTEST(AudioInterruptUnitTest, AudioInterruptService_032, TestSize.Level1)
+HWTEST_F(AudioInterruptUnitTest, AudioInterruptService_032, TestSize.Level1)
 {
     auto interruptServiceTest = std::make_shared<AudioInterruptService>();
     int32_t CALLER_PID = IPCSkeleton::GetCallingPid();
     interruptServiceTest->AddActiveInterruptToSession(CALLER_PID);
     EXPECT_NE(interruptServiceTest, nullptr);
-
-    interruptServiceTest->sessionService_ = nullptr;
-    interruptServiceTest->AddActiveInterruptToSession(CALLER_PID);
-    EXPECT_NE(interruptServiceTest, nullptr);
 }
 
 /**
@@ -694,16 +691,12 @@ HWTEST(AudioInterruptUnitTest, AudioInterruptService_032, TestSize.Level1)
 * @tc.number: AudioInterruptService_033
 * @tc.desc  : Test DeactivateAudioSession.
 */
-HWTEST(AudioInterruptUnitTest, AudioInterruptService_033, TestSize.Level1)
+HWTEST_F(AudioInterruptUnitTest, AudioInterruptService_033, TestSize.Level1)
 {
     auto interruptServiceTest = GetTnterruptServiceTest();
     int32_t CALLER_PID = IPCSkeleton::GetCallingPid();
     int32_t result = interruptServiceTest->DeactivateAudioSession(0, CALLER_PID);
-    EXPECT_NE(interruptServiceTest, nullptr);
-
-    interruptServiceTest->sessionService_ = nullptr;
-    result = interruptServiceTest->DeactivateAudioSession(0, CALLER_PID);
-    EXPECT_EQ(result, ERR_UNKNOWN);
+    EXPECT_EQ(ERR_ILLEGAL_STATE, result);
 }
 
 /**
@@ -711,7 +704,7 @@ HWTEST(AudioInterruptUnitTest, AudioInterruptService_033, TestSize.Level1)
 * @tc.number: AudioInterruptService_034
 * @tc.desc  : Test CanMixForSession.
 */
-HWTEST(AudioInterruptUnitTest, AudioInterruptService_034, TestSize.Level1)
+HWTEST_F(AudioInterruptUnitTest, AudioInterruptService_034, TestSize.Level1)
 {
     auto interruptServiceTest = std::make_shared<AudioInterruptService>();
     AudioInterrupt incomingInterrupt;
@@ -731,18 +724,14 @@ HWTEST(AudioInterruptUnitTest, AudioInterruptService_034, TestSize.Level1)
 * @tc.number: AudioInterruptService_035
 * @tc.desc  : Test CanMixForIncomingSession.
 */
-HWTEST(AudioInterruptUnitTest, AudioInterruptService_035, TestSize.Level1)
+HWTEST_F(AudioInterruptUnitTest, AudioInterruptService_035, TestSize.Level1)
 {
     auto interruptServiceTest = std::make_shared<AudioInterruptService>();
     AudioInterrupt incomingInterrupt;
     AudioInterrupt activeInterrupt;
     AudioFocusEntry focusEntry;
-    interruptServiceTest->CanMixForIncomingSession(incomingInterrupt, activeInterrupt, focusEntry);
-    EXPECT_NE(interruptServiceTest, nullptr);
-
-    interruptServiceTest->sessionService_ = nullptr;
     bool result = interruptServiceTest->CanMixForIncomingSession(incomingInterrupt, activeInterrupt, focusEntry);
-    EXPECT_EQ(result, false);
+    EXPECT_FALSE(result);
 }
 
 /**
@@ -750,18 +739,14 @@ HWTEST(AudioInterruptUnitTest, AudioInterruptService_035, TestSize.Level1)
 * @tc.number: AudioInterruptService_036
 * @tc.desc  : Test CanMixForActiveSession.
 */
-HWTEST(AudioInterruptUnitTest, AudioInterruptService_036, TestSize.Level1)
+HWTEST_F(AudioInterruptUnitTest, AudioInterruptService_036, TestSize.Level1)
 {
     auto interruptServiceTest = std::make_shared<AudioInterruptService>();
     AudioInterrupt incomingInterrupt;
     AudioInterrupt activeInterrupt;
     AudioFocusEntry focusEntry;
-    interruptServiceTest->CanMixForActiveSession(incomingInterrupt, activeInterrupt, focusEntry);
-    EXPECT_NE(interruptServiceTest, nullptr);
-
-    interruptServiceTest->sessionService_ = nullptr;
     bool result = interruptServiceTest->CanMixForActiveSession(incomingInterrupt, activeInterrupt, focusEntry);
-    EXPECT_EQ(result, false);
+    EXPECT_FALSE(result);
 }
 
 /**
@@ -769,7 +754,7 @@ HWTEST(AudioInterruptUnitTest, AudioInterruptService_036, TestSize.Level1)
 * @tc.number: AudioInterruptService_037
 * @tc.desc  : Test RequestAudioFocus.
 */
-HWTEST(AudioInterruptUnitTest, AudioInterruptService_037, TestSize.Level1)
+HWTEST_F(AudioInterruptUnitTest, AudioInterruptService_037, TestSize.Level1)
 {
     auto interruptServiceTest = GetTnterruptServiceTest();
     int32_t clientId = interruptServiceTest->clientOnFocus_;
@@ -786,7 +771,7 @@ HWTEST(AudioInterruptUnitTest, AudioInterruptService_037, TestSize.Level1)
 * @tc.number: AudioInterruptService_038
 * @tc.desc  : Test AbandonAudioFocus.
 */
-HWTEST(AudioInterruptUnitTest, AudioInterruptService_038, TestSize.Level1)
+HWTEST_F(AudioInterruptUnitTest, AudioInterruptService_038, TestSize.Level1)
 {
     auto interruptServiceTest = GetTnterruptServiceTest();
     int32_t clientId = interruptServiceTest->clientOnFocus_;
@@ -803,7 +788,7 @@ HWTEST(AudioInterruptUnitTest, AudioInterruptService_038, TestSize.Level1)
 * @tc.number: AudioInterruptService_039
 * @tc.desc  : Test AudioInterruptIsActiveInFocusList.
 */
-HWTEST(AudioInterruptUnitTest, AudioInterruptService_039, TestSize.Level1)
+HWTEST_F(AudioInterruptUnitTest, AudioInterruptService_039, TestSize.Level1)
 {
     auto interruptServiceTest = GetTnterruptServiceTest();
     int32_t zoneId = 0;
@@ -825,7 +810,7 @@ HWTEST(AudioInterruptUnitTest, AudioInterruptService_039, TestSize.Level1)
 * @tc.number: AudioInterruptService_040
 * @tc.desc  : Test ClearAudioFocusBySessionID.
 */
-HWTEST(AudioInterruptUnitTest, AudioInterruptService_040, TestSize.Level1)
+HWTEST_F(AudioInterruptUnitTest, AudioInterruptService_040, TestSize.Level1)
 {
     auto interruptServiceTest = GetTnterruptServiceTest();
     sptr<AudioPolicyServer> server = nullptr;
@@ -850,28 +835,12 @@ HWTEST(AudioInterruptUnitTest, AudioInterruptService_040, TestSize.Level1)
     EXPECT_EQ(interruptServiceTest->zonesMap_[0]->audioFocusInfoList.size(), 0);
 }
 
-/**
-* @tc.name  : Test AudioInterruptService.
-* @tc.number: AudioInterruptServiceCanMixForIncomingSession_001
-* @tc.desc  : Test CanMixForIncomingSession. sessionService_ is nullptr.
-*/
-HWTEST(AudioInterruptUnitTest, AudioInterruptServiceCanMixForIncomingSession_001, TestSize.Level1)
-{
-    auto interruptService = GetTnterruptServiceTest();
-    interruptService->sessionService_ = nullptr;
-    AudioInterrupt incomingInterrupt;
-    AudioInterrupt activeInterrupt;
-    AudioFocusEntry focusEntry;
-    auto ret = interruptService->CanMixForIncomingSession(incomingInterrupt, activeInterrupt, focusEntry);
-    EXPECT_FALSE(ret);
-}
-
 /**
 * @tc.name  : Test AudioInterruptService.
 * @tc.number: AudioInterruptServiceCanMixForIncomingSession_002
 * @tc.desc  : Test CanMixForIncomingSession. incomingInterrupt.pid is -1
 */
-HWTEST(AudioInterruptUnitTest, AudioInterruptServiceCanMixForIncomingSession_002, TestSize.Level1)
+HWTEST_F(AudioInterruptUnitTest, AudioInterruptServiceCanMixForIncomingSession_002, TestSize.Level1)
 {
     auto interruptService = GetTnterruptServiceTest();
     auto server = GetPolicyServerTest();
@@ -888,7 +857,7 @@ HWTEST(AudioInterruptUnitTest, AudioInterruptServiceCanMixForIncomingSession_002
 * @tc.number: AudioInterruptServiceCanMixForIncomingSession_003
 * @tc.desc  : Test CanMixForIncomingSession. incomingSession is nullptr.
 */
-HWTEST(AudioInterruptUnitTest, AudioInterruptServiceCanMixForIncomingSession_003, TestSize.Level1)
+HWTEST_F(AudioInterruptUnitTest, AudioInterruptServiceCanMixForIncomingSession_003, TestSize.Level1)
 {
     auto interruptService = GetTnterruptServiceTest();
     auto server = GetPolicyServerTest();
@@ -907,19 +876,27 @@ HWTEST(AudioInterruptUnitTest, AudioInterruptServiceCanMixForIncomingSession_003
 * @tc.number: AudioInterruptServiceCanMixForIncomingSession_004
 * @tc.desc  : Test CanMixForIncomingSession. IsIncomingStreamLowPriority(focusEntry) is true.
 */
-HWTEST(AudioInterruptUnitTest, AudioInterruptServiceCanMixForIncomingSession_004, TestSize.Level1)
+HWTEST_F(AudioInterruptUnitTest, AudioInterruptServiceCanMixForIncomingSession_004, TestSize.Level1)
 {
     auto interruptService = GetTnterruptServiceTest();
     auto server = GetPolicyServerTest();
     interruptService->Init(server);
+    int32_t pid = 1;
     AudioInterrupt incomingInterrupt;
+    incomingInterrupt.pid = pid;
     AudioInterrupt activeInterrupt;
     AudioFocusEntry focusEntry;
     strategyTest.concurrencyMode = AudioConcurrencyMode::MIX_WITH_OTHERS;
-    int32_t ret = interruptService->ActivateAudioSession(0, incomingInterrupt.pid, strategyTest);
+    int32_t ret = interruptService->ActivateAudioSession(0, pid, strategyTest);
     EXPECT_EQ(SUCCESS, ret);
 
     focusEntry.isReject = true;
+    auto session = interruptService->sessionService_.sessionMap_.find(pid);
+    ASSERT_TRUE(session != interruptService->sessionService_.sessionMap_.end());
+    ASSERT_NE(nullptr, session->second);
+    session->second->isSystemApp_ = true;
+    EXPECT_TRUE(interruptService->CanMixForIncomingSession(incomingInterrupt, activeInterrupt, focusEntry));
+    session->second->isSystemApp_ = false;
     EXPECT_FALSE(interruptService->CanMixForIncomingSession(incomingInterrupt, activeInterrupt, focusEntry));
 }
 
@@ -928,7 +905,7 @@ HWTEST(AudioInterruptUnitTest, AudioInterruptServiceCanMixForIncomingSession_004
 * @tc.number: AudioInterruptServiceCanMixForIncomingSession_005
 * @tc.desc  : Test CanMixForIncomingSession. IsIncomingStreamLowPriority(focusEntry) is false.
 */
-HWTEST(AudioInterruptUnitTest, AudioInterruptServiceCanMixForIncomingSession_005, TestSize.Level1)
+HWTEST_F(AudioInterruptUnitTest, AudioInterruptServiceCanMixForIncomingSession_005, TestSize.Level1)
 {
     auto interruptService = GetTnterruptServiceTest();
     auto server = GetPolicyServerTest();
@@ -950,7 +927,7 @@ HWTEST(AudioInterruptUnitTest, AudioInterruptServiceCanMixForIncomingSession_005
 * @tc.number: AudioInterruptServiceCanMixForSession_001
 * @tc.desc  : Test CanMixForSession.
 */
-HWTEST(AudioInterruptUnitTest, AudioInterruptServiceCanMixForSession_001, TestSize.Level1)
+HWTEST_F(AudioInterruptUnitTest, AudioInterruptServiceCanMixForSession_001, TestSize.Level1)
 {
     auto interruptService = GetTnterruptServiceTest();
     auto server = GetPolicyServerTest();
@@ -970,7 +947,7 @@ HWTEST(AudioInterruptUnitTest, AudioInterruptServiceCanMixForSession_001, TestSi
  * @tc.number: AudioInterruptService_RemoveExistingFocus_001
  * @tc.desc  : Test RemoveExistingFocus.
  */
-HWTEST(AudioInterruptUnitTest, AudioInterruptService_RemoveExistingFocus_001, TestSize.Level1)
+HWTEST_F(AudioInterruptUnitTest, AudioInterruptService_RemoveExistingFocus_001, TestSize.Level1)
 {
     auto interruptServiceTest = GetTnterruptServiceTest();
     interruptServiceTest->zonesMap_.clear();
@@ -994,7 +971,7 @@ HWTEST(AudioInterruptUnitTest, AudioInterruptService_RemoveExistingFocus_001, Te
  * @tc.number: AudioInterruptService_ResumeFocusByStreamId_001
  * @tc.desc  : Test ResumeFocusByStreamId.
  */
-HWTEST(AudioInterruptUnitTest, AudioInterruptService_ResumeFocusByStreamId_001, TestSize.Level1)
+HWTEST_F(AudioInterruptUnitTest, AudioInterruptService_ResumeFocusByStreamId_001, TestSize.Level1)
 {
     auto interruptServiceTest = GetTnterruptServiceTest();
     InterruptEventInternal interruptEvent;
@@ -1011,7 +988,7 @@ HWTEST(AudioInterruptUnitTest, AudioInterruptService_ResumeFocusByStreamId_001,
 * @tc.number: AudioInterruptServiceCanMixForSession_002
 * @tc.desc  : Test CanMixForSession.
 */
-HWTEST(AudioInterruptUnitTest, AudioInterruptServiceCanMixForSession_002, TestSize.Level1)
+HWTEST_F(AudioInterruptUnitTest, AudioInterruptServiceCanMixForSession_002, TestSize.Level1)
 {
     auto interruptService = GetTnterruptServiceTest();
     auto server = GetPolicyServerTest();
@@ -1037,7 +1014,7 @@ HWTEST(AudioInterruptUnitTest, AudioInterruptServiceCanMixForSession_002, TestSi
 * @tc.number: AudioInterruptServiceCanMixForSession_003
 * @tc.desc  : Test CanMixForSession.
 */
-HWTEST(AudioInterruptUnitTest, AudioInterruptServiceCanMixForSession_003, TestSize.Level1)
+HWTEST_F(AudioInterruptUnitTest, AudioInterruptServiceCanMixForSession_003, TestSize.Level1)
 {
     auto interruptService = GetTnterruptServiceTest();
     auto server = GetPolicyServerTest();
@@ -1064,7 +1041,7 @@ HWTEST(AudioInterruptUnitTest, AudioInterruptServiceCanMixForSession_003, TestSi
  * @tc.number: SetAppConcurrencyMode_001
  * @tc.desc  : Test SetAppConcurrencyMode.
  */
-HWTEST(AudioInterruptUnitTest, SetAppConcurrencyMode_001, TestSize.Level1)
+HWTEST_F(AudioInterruptUnitTest, SetAppConcurrencyMode_001, TestSize.Level1)
 {
     sptr<AudioPolicyServer> server = GetPolicyServerTest();
     ASSERT_TRUE(server != nullptr);
@@ -1083,7 +1060,7 @@ HWTEST(AudioInterruptUnitTest, SetAppConcurrencyMode_001, TestSize.Level1)
  * @tc.number: SetAppSilentOnDisplay_001
  * @tc.desc  : Test SetAppSilentOnDisplay.
  */
-HWTEST(AudioInterruptUnitTest, SetAppSilentOnDisplay_001, TestSize.Level1)
+HWTEST_F(AudioInterruptUnitTest, SetAppSilentOnDisplay_001, TestSize.Level1)
 {
     sptr<AudioPolicyServer> server = GetPolicyServerTest();
     ASSERT_TRUE(server != nullptr);
@@ -1101,7 +1078,7 @@ HWTEST(AudioInterruptUnitTest, SetAppSilentOnDisplay_001, TestSize.Level1)
 * @tc.number: AudioPolicyServer_009
 * @tc.desc  : Test DeactivateAudioInterrupt.
 */
-HWTEST(AudioInterruptUnitTest, AudioPolicyServer_001, TestSize.Level1)
+HWTEST_F(AudioInterruptUnitTest, AudioPolicyServer_001, TestSize.Level1)
 {
     auto policyServerTest = GetPolicyServerTest();
     int32_t systemAbilityId = 3009;
@@ -1116,8 +1093,7 @@ HWTEST(AudioInterruptUnitTest, AudioPolicyServer_001, TestSize.Level1)
     server->interruptService_ = std::make_shared<AudioInterruptService>();
     int32_t result = server->DeactivateAudioInterrupt(audioInterrupt, zoneID);
     EXPECT_EQ(result, SUCCESS);
-    EXPECT_EQ(policyServerTest->ActivateAudioSession(strategy), ERR_UNKNOWN);
-    server->RegisteredStreamListenerClientDied(pid, uid);
+    EXPECT_EQ(SUCCESS, policyServerTest->ActivateAudioSession(strategy));
 }
 
 /**
@@ -1125,7 +1101,7 @@ HWTEST(AudioInterruptUnitTest, AudioPolicyServer_001, TestSize.Level1)
 * @tc.number: AudioInterruptServiceCanMixForSession_004
 * @tc.desc  : Test CanMixForSession.
 */
-HWTEST(AudioInterruptUnitTest, AudioInterruptServiceCanMixForSession_004, TestSize.Level1)
+HWTEST_F(AudioInterruptUnitTest, AudioInterruptServiceCanMixForSession_004, TestSize.Level1)
 {
     auto interruptService = GetTnterruptServiceTest();
     interruptService->SetCallbackHandler(GetServerHandlerTest());
@@ -1140,28 +1116,7 @@ HWTEST(AudioInterruptUnitTest, AudioInterruptServiceCanMixForSession_004, TestSi
     incomingInterrupt.audioFocusType.sourceType = SOURCE_TYPE_INVALID;
 
     auto ret = interruptService->CanMixForSession(incomingInterrupt, activeInterrupt, focusEntry);
-    EXPECT_TRUE(ret);
-}
-
-/**
-* @tc.name  : Test AudioInterruptService.
-* @tc.number: AudioInterruptServiceRemovePlaceholderInterruptForSession_001
-* @tc.desc  : Test RemovePlaceholderInterruptForSession. sessionService_ is nullptr.
-*/
-HWTEST(AudioInterruptUnitTest, AudioInterruptServiceRemovePlaceholderInterruptForSession_001, TestSize.Level1)
-{
-    auto interruptService = GetTnterruptServiceTest();
-    interruptService->sessionService_ = nullptr;
-    int32_t pid = CALLER_PID;
-    bool timeOut = IS_SESSION_TIMEOUT;
-    interruptService->RemovePlaceholderInterruptForSession(pid, timeOut);
-
-    auto server = GetPolicyServerTest();
-    interruptService->Init(server);
-    int32_t ret = interruptService->ActivateAudioSession(0, pid, strategyTest);
-    EXPECT_EQ(SUCCESS, ret);
-    interruptService->RemovePlaceholderInterruptForSession(pid, timeOut);
-    EXPECT_TRUE(interruptService->sessionService_->IsAudioSessionActivated(pid));
+    EXPECT_FALSE(ret);
 }
 
 /**
@@ -1169,7 +1124,7 @@ HWTEST(AudioInterruptUnitTest, AudioInterruptServiceRemovePlaceholderInterruptFo
 * @tc.number: AudioInterruptServiceRemovePlaceholderInterruptForSession_002
 * @tc.desc  : Test RemovePlaceholderInterruptForSession. About itZone.
 */
-HWTEST(AudioInterruptUnitTest, AudioInterruptServiceRemovePlaceholderInterruptForSession_002, TestSize.Level1)
+HWTEST_F(AudioInterruptUnitTest, AudioInterruptServiceRemovePlaceholderInterruptForSession_002, TestSize.Level1)
 {
     auto interruptService = GetTnterruptServiceTest();
     auto server = GetPolicyServerTest();
@@ -1193,7 +1148,7 @@ HWTEST(AudioInterruptUnitTest, AudioInterruptServiceRemovePlaceholderInterruptFo
 * @tc.number: AudioInterruptServiceRemovePlaceholderInterruptForSession_003
 * @tc.desc  : Test RemovePlaceholderInterruptForSession. About itZone.
 */
-HWTEST(AudioInterruptUnitTest, AudioInterruptServiceRemovePlaceholderInterruptForSession_003, TestSize.Level1)
+HWTEST_F(AudioInterruptUnitTest, AudioInterruptServiceRemovePlaceholderInterruptForSession_003, TestSize.Level1)
 {
     auto interruptService = GetTnterruptServiceTest();
     auto server = GetPolicyServerTest();
@@ -1215,18 +1170,14 @@ HWTEST(AudioInterruptUnitTest, AudioInterruptServiceRemovePlaceholderInterruptFo
 * @tc.number: AudioInterruptServiceDeactivateAudioSession_001
 * @tc.desc  : Test DeactivateAudioSession.
 */
-HWTEST(AudioInterruptUnitTest, AudioInterruptServiceDeactivateAudioSession_001, TestSize.Level1)
+HWTEST_F(AudioInterruptUnitTest, AudioInterruptServiceDeactivateAudioSession_001, TestSize.Level1)
 {
     auto interruptService = GetTnterruptServiceTest();
-    interruptService->sessionService_ = nullptr;
     int32_t pid = CALLER_PID;
-    int32_t ret = interruptService->DeactivateAudioSession(0, pid);
-    EXPECT_EQ(ERR_UNKNOWN, ret);
-
     auto server = GetPolicyServerTest();
     interruptService->Init(server);
-    ret = interruptService->DeactivateAudioSession(0, pid);
-    EXPECT_EQ(SUCCESS, ret);
+    int32_t ret = interruptService->DeactivateAudioSession(0, pid);
+    EXPECT_EQ(ERR_ILLEGAL_STATE, ret);
 
     strategyTest.concurrencyMode = AudioConcurrencyMode::MIX_WITH_OTHERS;
     ret = interruptService->ActivateAudioSession(0, pid, strategyTest);
@@ -1238,19 +1189,16 @@ HWTEST(AudioInterruptUnitTest, AudioInterruptServiceDeactivateAudioSession_001,
 /**
 * @tc.name  : Test AudioInterruptService.
 * @tc.number: AudioInterruptServiceAddActiveInterruptToSession_001
-* @tc.desc  : Test AddActiveInterruptToSession. sessionService_ is nullptr.
+* @tc.desc  : Test AddActiveInterruptToSession.
 */
-HWTEST(AudioInterruptUnitTest, AudioInterruptServiceAddActiveInterruptToSession_001, TestSize.Level1)
+HWTEST_F(AudioInterruptUnitTest, AudioInterruptServiceAddActiveInterruptToSession_001, TestSize.Level1)
 {
     auto interruptService = GetTnterruptServiceTest();
-    interruptService->sessionService_ = nullptr;
     int32_t pid = CALLER_PID;
-    interruptService->AddActiveInterruptToSession(pid);
-
     auto server = GetPolicyServerTest();
     interruptService->Init(server);
     interruptService->AddActiveInterruptToSession(pid);
-    EXPECT_FALSE(interruptService->sessionService_->IsAudioSessionActivated(pid));
+    EXPECT_FALSE(interruptService->sessionService_.IsAudioSessionActivated(pid));
 }
 
 /**
@@ -1258,7 +1206,7 @@ HWTEST(AudioInterruptUnitTest, AudioInterruptServiceAddActiveInterruptToSession_
 * @tc.number: AudioInterruptServiceAddActiveInterruptToSession_002
 * @tc.desc  : Test AddActiveInterruptToSession. About itZone.
 */
-HWTEST(AudioInterruptUnitTest, AudioInterruptServiceAddActiveInterruptToSession_002, TestSize.Level1)
+HWTEST_F(AudioInterruptUnitTest, AudioInterruptServiceAddActiveInterruptToSession_002, TestSize.Level1)
 {
     auto interruptService = GetTnterruptServiceTest();
     auto server = GetPolicyServerTest();
@@ -1283,7 +1231,7 @@ HWTEST(AudioInterruptUnitTest, AudioInterruptServiceAddActiveInterruptToSession_
 * @tc.number: AudioInterruptServiceAddActiveInterruptToSession_003
 * @tc.desc  : Test AddActiveInterruptToSession. About itZone.
 */
-HWTEST(AudioInterruptUnitTest, AudioInterruptServiceAddActiveInterruptToSession_003, TestSize.Level1)
+HWTEST_F(AudioInterruptUnitTest, AudioInterruptServiceAddActiveInterruptToSession_003, TestSize.Level1)
 {
     auto interruptService = GetTnterruptServiceTest();
     auto server = GetPolicyServerTest();
@@ -1306,7 +1254,7 @@ HWTEST(AudioInterruptUnitTest, AudioInterruptServiceAddActiveInterruptToSession_
 * @tc.number: AudioInterruptServiceAddActiveInterruptToSession_004
 * @tc.desc  : Test AddActiveInterruptToSession. About itZone.
 */
-HWTEST(AudioInterruptUnitTest, AudioInterruptServiceAddActiveInterruptToSession_004, TestSize.Level1)
+HWTEST_F(AudioInterruptUnitTest, AudioInterruptServiceAddActiveInterruptToSession_004, TestSize.Level1)
 {
     auto interruptService = GetTnterruptServiceTest();
     auto server = GetPolicyServerTest();
@@ -1330,7 +1278,7 @@ HWTEST(AudioInterruptUnitTest, AudioInterruptServiceAddActiveInterruptToSession_
 * @tc.number: AudioInterruptServiceAddActiveInterruptToSession_005
 * @tc.desc  : Test AddActiveInterruptToSession. About itZone. itZone->second != nullptr.
 */
-HWTEST(AudioInterruptUnitTest, AudioInterruptServiceAddActiveInterruptToSession_005, TestSize.Level1)
+HWTEST_F(AudioInterruptUnitTest, AudioInterruptServiceAddActiveInterruptToSession_005, TestSize.Level1)
 {
     auto interruptService = GetTnterruptServiceTest();
     auto server = GetPolicyServerTest();
@@ -1355,7 +1303,7 @@ HWTEST(AudioInterruptUnitTest, AudioInterruptServiceAddActiveInterruptToSession_
  * @tc.number: AudioInterruptServiceGetAudioServerProxy_001
  * @tc.desc  : Test OnSessionTimeout when g_adProxy is nullptr.
  */
-HWTEST(AudioInterruptUnitTest, AudioInterruptServiceGetAudioServerProxy_001, TestSize.Level1)
+HWTEST_F(AudioInterruptUnitTest, AudioInterruptServiceGetAudioServerProxy_001, TestSize.Level1)
 {
     audioInterruptService = GetTnterruptServiceTest();
     audioInterruptService->SetCallbackHandler(GetServerHandlerTest());
@@ -1370,7 +1318,7 @@ HWTEST(AudioInterruptUnitTest, AudioInterruptServiceGetAudioServerProxy_001, Tes
  * @tc.number: AudioInterruptServiceGetAudioServerProxy_002
  * @tc.desc  : Test OnSessionTimeout when g_adProxy is not nullptr.
  */
-HWTEST(AudioInterruptUnitTest, AudioInterruptServiceGetAudioServerProxy_002, TestSize.Level1)
+HWTEST_F(AudioInterruptUnitTest, AudioInterruptServiceGetAudioServerProxy_002, TestSize.Level1)
 {
     audioInterruptService = GetTnterruptServiceTest();
     audioInterruptService->SetCallbackHandler(GetServerHandlerTest());
@@ -1387,7 +1335,7 @@ HWTEST(AudioInterruptUnitTest, AudioInterruptServiceGetAudioServerProxy_002, Tes
  * @tc.desc  : Test normal OnSessionTimeout.
  *             Test normal HandleSessionTimeOutEvent.
  */
-HWTEST(AudioInterruptUnitTest, AudioInterruptServiceOnSessionTimeout_001, TestSize.Level1)
+HWTEST_F(AudioInterruptUnitTest, AudioInterruptServiceOnSessionTimeout_001, TestSize.Level1)
 {
     audioInterruptService = GetTnterruptServiceTest();
     audioInterruptService->SetCallbackHandler(GetServerHandlerTest());
@@ -1404,7 +1352,7 @@ HWTEST(AudioInterruptUnitTest, AudioInterruptServiceOnSessionTimeout_001, TestSi
  * @tc.desc  : Test normal OnSessionTimeout.
  *             Test normal HandleSessionTimeOutEvent.
  */
-HWTEST(AudioInterruptUnitTest, AudioInterruptServiceOnSessionTimeout_002, TestSize.Level1)
+HWTEST_F(AudioInterruptUnitTest, AudioInterruptServiceOnSessionTimeout_002, TestSize.Level1)
 {
     audioInterruptService = GetTnterruptServiceTest();
     audioInterruptService->SetCallbackHandler(GetServerHandlerTest());
@@ -1416,29 +1364,12 @@ HWTEST(AudioInterruptUnitTest, AudioInterruptServiceOnSessionTimeout_002, TestSi
     EXPECT_EQ(nullptr, audioInterruptService->handler_);
 }
 
-/**
- * @tc.name  : Test ActivateAudioSession API.
- * @tc.number: AudioInterruptServiceActivateAudioSession_001
- * @tc.desc  : Test ActivateAudioSession when sessionService_ is nullptr.
- */
-HWTEST(AudioInterruptUnitTest, AudioInterruptServiceActivateAudioSession_001, TestSize.Level1)
-{
-    audioInterruptService = GetTnterruptServiceTest();
-    audioInterruptService->SetCallbackHandler(GetServerHandlerTest());
-    EXPECT_NE(nullptr, audioInterruptService);
-
-    audioInterruptService->Init(serverTest);
-    audioInterruptService->sessionService_ = nullptr;
-    int32_t ret =  audioInterruptService->ActivateAudioSession(0, CALLER_PID_TEST, strategyTest);
-    EXPECT_EQ(ERR_UNKNOWN, ret);
-}
-
 /**
  * @tc.name  : Test ActivateAudioSession API.
  * @tc.number: AudioInterruptServiceActivateAudioSession_002
  * @tc.desc  : Test normal ActivateAudioSession.
  */
-HWTEST(AudioInterruptUnitTest, AudioInterruptServiceActivateAudioSession_002, TestSize.Level1)
+HWTEST_F(AudioInterruptUnitTest, AudioInterruptServiceActivateAudioSession_002, TestSize.Level1)
 {
     audioInterruptService = GetTnterruptServiceTest();
     audioInterruptService->SetCallbackHandler(GetServerHandlerTest());
@@ -1454,7 +1385,7 @@ HWTEST(AudioInterruptUnitTest, AudioInterruptServiceActivateAudioSession_002, Te
 * @tc.number: AudioInterruptServiceUnsetAudioManagerInterruptCallback_001
 * @tc.desc  : Test UnsetAudioManagerInterruptCallback.
 */
-HWTEST(AudioInterruptUnitTest, AudioInterruptServiceUnsetAudioManagerInterruptCallback_001, TestSize.Level1)
+HWTEST_F(AudioInterruptUnitTest, AudioInterruptServiceUnsetAudioManagerInterruptCallback_001, TestSize.Level1)
 {
     sptr<AudioPolicyServer> server = nullptr;
     auto interruptServiceTest = GetTnterruptServiceTest();
@@ -1471,34 +1402,15 @@ HWTEST(AudioInterruptUnitTest, AudioInterruptServiceUnsetAudioManagerInterruptCa
 /**
  * @tc.name  : Test IsAudioSessionActivated API.
  * @tc.number: AudioInterruptServiceIsAudioSessionActivated_001
- * @tc.desc  : Test IsAudioSessionActivated when sessionService_ is not nullptr.
+ * @tc.desc  : Test IsAudioSessionActivated.
  */
-HWTEST(AudioInterruptUnitTest, AudioInterruptServiceIsAudioSessionActivated_001, TestSize.Level1)
+HWTEST_F(AudioInterruptUnitTest, AudioInterruptServiceIsAudioSessionActivated_001, TestSize.Level1)
 {
     audioInterruptService = GetTnterruptServiceTest();
     audioInterruptService->SetCallbackHandler(GetServerHandlerTest());
     EXPECT_NE(nullptr, audioInterruptService);
 
     audioInterruptService->Init(serverTest);
-    EXPECT_NE(nullptr, audioInterruptService->sessionService_);
-    int32_t PIT_TEST { -1 };
-    bool ret = audioInterruptService->IsAudioSessionActivated(PIT_TEST);
-    EXPECT_TRUE(ret);
-}
-
-/**
- * @tc.name  : Test IsAudioSessionActivated API.
- * @tc.number: AudioInterruptServiceIsAudioSessionActivated_002
- * @tc.desc  : Test IsAudioSessionActivated when sessionService_ is nullptr.
- */
-HWTEST(AudioInterruptUnitTest, AudioInterruptServiceIsAudioSessionActivated_002, TestSize.Level1)
-{
-    audioInterruptService = GetTnterruptServiceTest();
-    audioInterruptService->SetCallbackHandler(GetServerHandlerTest());
-    EXPECT_NE(nullptr, audioInterruptService);
-
-    audioInterruptService->Init(serverTest);
-    audioInterruptService->sessionService_ = nullptr;
     int32_t PIT_TEST { -1 };
     bool ret = audioInterruptService->IsAudioSessionActivated(PIT_TEST);
     EXPECT_FALSE(ret);
@@ -1509,7 +1421,7 @@ HWTEST(AudioInterruptUnitTest, AudioInterruptServiceIsAudioSessionActivated_002,
  * @tc.number: AudioInterruptServiceCanMixForActiveSession_001
  * @tc.desc  : Test CanMixForActiveSession when return true.
  */
-HWTEST(AudioInterruptUnitTest, AudioInterruptServiceCanMixForActiveSession_001, TestSize.Level1)
+HWTEST_F(AudioInterruptUnitTest, AudioInterruptServiceCanMixForActiveSession_001, TestSize.Level1)
 {
     audioInterruptService = GetTnterruptServiceTest();
     audioInterruptService->SetCallbackHandler(GetServerHandlerTest());
@@ -1522,41 +1434,19 @@ HWTEST(AudioInterruptUnitTest, AudioInterruptServiceCanMixForActiveSession_001,
     AudioFocusEntry focusEntry;
     AudioSessionStrategy strategy;
     strategy.concurrencyMode = AudioConcurrencyMode::MIX_WITH_OTHERS;
-    std::shared_ptr<AudioSession> audioSession = std::make_shared<AudioSession>(0, strategy, nullptr);
+    audioInterruptService->sessionService_.ActivateAudioSession(0, strategy);
     activeInterrupt.pid = { 0 };
-    audioInterruptService->sessionService_->sessionMap_.insert({0, audioSession});
     focusEntry.actionOn = INCOMING;
     bool ret = audioInterruptService->CanMixForActiveSession(incomingInterrupt, activeInterrupt, focusEntry);
     EXPECT_TRUE(ret);
 }
 
-/**
- * @tc.name  : Test CanMixForActiveSession API.
- * @tc.number: AudioInterruptServiceCanMixForActiveSession_002
- * @tc.desc  : Test CanMixForActiveSession when sessionService_ is nullptr.
- */
-HWTEST(AudioInterruptUnitTest, AudioInterruptServiceCanMixForActiveSession_002, TestSize.Level1)
-{
-    audioInterruptService = GetTnterruptServiceTest();
-    audioInterruptService->SetCallbackHandler(GetServerHandlerTest());
-    EXPECT_NE(nullptr, audioInterruptService);
-
-    audioInterruptService->Init(serverTest);
-    AudioFocusType audioFocusTypeTest;
-    AudioInterrupt incomingInterrupt(STREAM_USAGE_UNKNOWN, CONTENT_TYPE_UNKNOWN, audioFocusTypeTest, SESSION_ID_TEST);
-    AudioInterrupt activeInterrupt(STREAM_USAGE_UNKNOWN, CONTENT_TYPE_UNKNOWN, audioFocusTypeTest, SESSION_ID_TEST);
-    AudioFocusEntry focusEntry;
-    audioInterruptService->sessionService_ = nullptr;
-    bool ret = audioInterruptService->CanMixForActiveSession(incomingInterrupt, activeInterrupt, focusEntry);
-    EXPECT_FALSE(ret);
-}
-
 /**
  * @tc.name  : Test CanMixForActiveSession API.
  * @tc.number: AudioInterruptServiceCanMixForActiveSession_003
  * @tc.desc  : Test CanMixForActiveSession when IsAudioSessionActivated is true.
  */
-HWTEST(AudioInterruptUnitTest, AudioInterruptServiceCanMixForActiveSession_003, TestSize.Level1)
+HWTEST_F(AudioInterruptUnitTest, AudioInterruptServiceCanMixForActiveSession_003, TestSize.Level1)
 {
     audioInterruptService = GetTnterruptServiceTest();
     audioInterruptService->SetCallbackHandler(GetServerHandlerTest());
@@ -1569,7 +1459,7 @@ HWTEST(AudioInterruptUnitTest, AudioInterruptServiceCanMixForActiveSession_003,
     activeInterrupt.pid = { -1 };
     AudioFocusEntry focusEntry;
     bool ret = audioInterruptService->CanMixForActiveSession(incomingInterrupt, activeInterrupt, focusEntry);
-    EXPECT_TRUE(ret);
+    EXPECT_FALSE(ret);
 }
 
 /**
@@ -1577,7 +1467,7 @@ HWTEST(AudioInterruptUnitTest, AudioInterruptServiceCanMixForActiveSession_003,
  * @tc.number: AudioInterruptServiceCanMixForActiveSession_004
  * @tc.desc  : Test CanMixForActiveSession when concurrencyMode is not MIX_WITH_OTHERS.
  */
-HWTEST(AudioInterruptUnitTest, AudioInterruptServiceCanMixForActiveSession_004, TestSize.Level1)
+HWTEST_F(AudioInterruptUnitTest, AudioInterruptServiceCanMixForActiveSession_004, TestSize.Level1)
 {
     audioInterruptService = GetTnterruptServiceTest();
     audioInterruptService->SetCallbackHandler(GetServerHandlerTest());
@@ -1589,11 +1479,11 @@ HWTEST(AudioInterruptUnitTest, AudioInterruptServiceCanMixForActiveSession_004,
     AudioInterrupt activeInterrupt(STREAM_USAGE_UNKNOWN, CONTENT_TYPE_UNKNOWN, audioFocusTypeTest, SESSION_ID_TEST);
     AudioFocusEntry focusEntry;
     AudioSessionStrategy strategy;
-    std::shared_ptr<AudioSession> audioSession = std::make_shared<AudioSession>(0, strategy, nullptr);
+    std::shared_ptr<AudioSession> audioSession = std::make_shared<AudioSession>(0, strategy, audioSessionStateMonitor_);
     activeInterrupt.pid = { 0 };
-    audioInterruptService->sessionService_->sessionMap_.insert({0, audioSession});
+    audioInterruptService->sessionService_.sessionMap_.insert({0, audioSession});
     std::shared_ptr<AudioSession> activeSession =
-        audioInterruptService->sessionService_->sessionMap_[activeInterrupt.pid];
+        audioInterruptService->sessionService_.sessionMap_[activeInterrupt.pid];
     activeSession->strategy_.concurrencyMode = AudioConcurrencyMode::DEFAULT;
     bool ret = audioInterruptService->CanMixForActiveSession(incomingInterrupt, activeInterrupt, focusEntry);
     EXPECT_FALSE(ret);
@@ -1604,7 +1494,7 @@ HWTEST(AudioInterruptUnitTest, AudioInterruptServiceCanMixForActiveSession_004,
  * @tc.number: AudioInterruptServiceCanMixForActiveSession_005
  * @tc.desc  : Test CanMixForActiveSession when IsActiveStreamLowPriority is true and return false.
  */
-HWTEST(AudioInterruptUnitTest, AudioInterruptServiceCanMixForActiveSession_005, TestSize.Level1)
+HWTEST_F(AudioInterruptUnitTest, AudioInterruptServiceCanMixForActiveSession_005, TestSize.Level1)
 {
     audioInterruptService = GetTnterruptServiceTest();
     audioInterruptService->SetCallbackHandler(GetServerHandlerTest());
@@ -1619,9 +1509,9 @@ HWTEST(AudioInterruptUnitTest, AudioInterruptServiceCanMixForActiveSession_005,
     focusEntry.hintType = INTERRUPT_HINT_PAUSE;
     AudioSessionStrategy strategy;
     strategy.concurrencyMode = AudioConcurrencyMode::MIX_WITH_OTHERS;
-    std::shared_ptr<AudioSession> audioSession = std::make_shared<AudioSession>(0, strategy, nullptr);
+    std::shared_ptr<AudioSession> audioSession = std::make_shared<AudioSession>(0, strategy, audioSessionStateMonitor_);
     activeInterrupt.pid = { 0 };
-    audioInterruptService->sessionService_->sessionMap_.insert({0, audioSession});
+    audioInterruptService->sessionService_.sessionMap_.insert({0, audioSession});
     incomingInterrupt.audioFocusType.streamType = STREAM_VOICE_CALL;
     activeInterrupt.audioFocusType.streamType = STREAM_MUSIC;
     bool ret = audioInterruptService->CanMixForActiveSession(incomingInterrupt, activeInterrupt, focusEntry);
@@ -1633,7 +1523,7 @@ HWTEST(AudioInterruptUnitTest, AudioInterruptServiceCanMixForActiveSession_005,
  * @tc.number: AudioInterruptServiceCanMixForActiveSession_006
  * @tc.desc  : Test CanMixForActiveSession when IsActiveStreamLowPriority is true and return true.
  */
-HWTEST(AudioInterruptUnitTest, AudioInterruptServiceCanMixForActiveSession_006, TestSize.Level1)
+HWTEST_F(AudioInterruptUnitTest, AudioInterruptServiceCanMixForActiveSession_006, TestSize.Level1)
 {
     audioInterruptService = GetTnterruptServiceTest();
     audioInterruptService->SetCallbackHandler(GetServerHandlerTest());
@@ -1648,13 +1538,19 @@ HWTEST(AudioInterruptUnitTest, AudioInterruptServiceCanMixForActiveSession_006,
     focusEntry.hintType = INTERRUPT_HINT_PAUSE;
     AudioSessionStrategy strategy;
     strategy.concurrencyMode = AudioConcurrencyMode::MIX_WITH_OTHERS;
-    std::shared_ptr<AudioSession> audioSession = std::make_shared<AudioSession>(0, strategy, nullptr);
+    std::shared_ptr<AudioSession> audioSession =
+        std::make_shared<AudioSession>(0, strategy, audioSessionStateMonitor_);
+    ASSERT_NE(nullptr, audioSession);
     activeInterrupt.pid = { 0 };
-    audioInterruptService->sessionService_->sessionMap_.insert({0, audioSession});
+    audioInterruptService->sessionService_.sessionMap_.insert({0, audioSession});
     incomingInterrupt.audioFocusType.streamType = STREAM_VOICE_CALL;
     activeInterrupt.audioFocusType.streamType = STREAM_VOICE_CALL;
     bool ret = audioInterruptService->CanMixForActiveSession(incomingInterrupt, activeInterrupt, focusEntry);
     EXPECT_FALSE(ret);
+    audioInterruptService->sessionService_.sessionMap_[0]->isSystemApp_ = true;
+    audioInterruptService->sessionService_.sessionMap_[0]->state_ = AudioSessionState::SESSION_ACTIVE;
+    ret = audioInterruptService->CanMixForActiveSession(incomingInterrupt, activeInterrupt, focusEntry);
+    EXPECT_TRUE(ret);
 }
 
 /**
@@ -1662,7 +1558,7 @@ HWTEST(AudioInterruptUnitTest, AudioInterruptServiceCanMixForActiveSession_006,
 * @tc.number: SendSessionTimeOutStopEvent_001
 * @tc.desc  : Test SendSessionTimeOutStopEvent
 */
-HWTEST(AudioInterruptUnitTest, SendSessionTimeOutStopEvent_001, TestSize.Level1)
+HWTEST_F(AudioInterruptUnitTest, SendSessionTimeOutStopEvent_001, TestSize.Level1)
 {
     auto interruptServiceTest = GetTnterruptServiceTest();
 
@@ -1682,7 +1578,7 @@ HWTEST(AudioInterruptUnitTest, SendSessionTimeOutStopEvent_001, TestSize.Level1)
 * @tc.number: SendSessionTimeOutStopEvent_002
 * @tc.desc  : Test SendSessionTimeOutStopEvent
 */
-HWTEST(AudioInterruptUnitTest, SendSessionTimeOutStopEvent_002, TestSize.Level1)
+HWTEST_F(AudioInterruptUnitTest, SendSessionTimeOutStopEvent_002, TestSize.Level1)
 {
     auto interruptServiceTest = GetTnterruptServiceTest();
 
@@ -1699,7 +1595,7 @@ HWTEST(AudioInterruptUnitTest, SendSessionTimeOutStopEvent_002, TestSize.Level1)
 * @tc.number: SendSessionTimeOutStopEvent_003
 * @tc.desc  : Test SendSessionTimeOutStopEvent
 */
-HWTEST(AudioInterruptUnitTest, SendSessionTimeOutStopEvent_003, TestSize.Level1)
+HWTEST_F(AudioInterruptUnitTest, SendSessionTimeOutStopEvent_003, TestSize.Level1)
 {
     auto interruptServiceTest = GetTnterruptServiceTest();
 
@@ -1720,7 +1616,7 @@ HWTEST(AudioInterruptUnitTest, SendSessionTimeOutStopEvent_003, TestSize.Level1)
 * @tc.number: SendSessionTimeOutStopEvent_004
 * @tc.desc  : Test SendSessionTimeOutStopEvent
 */
-HWTEST(AudioInterruptUnitTest, SendSessionTimeOutStopEvent_004, TestSize.Level1)
+HWTEST_F(AudioInterruptUnitTest, SendSessionTimeOutStopEvent_004, TestSize.Level1)
 {
     auto interruptServiceTest = GetTnterruptServiceTest();
     std::set<int32_t> pids = {100, 200, 300};
@@ -1743,7 +1639,7 @@ HWTEST(AudioInterruptUnitTest, SendSessionTimeOutStopEvent_004, TestSize.Level1)
 * @tc.number: SendSessionTimeOutStopEvent_005
 * @tc.desc  : Test SendSessionTimeOutStopEvent
 */
-HWTEST(AudioInterruptUnitTest, SendSessionTimeOutStopEvent_005, TestSize.Level1)
+HWTEST_F(AudioInterruptUnitTest, SendSessionTimeOutStopEvent_005, TestSize.Level1)
 {
     auto interruptServiceTest = GetTnterruptServiceTest();
 
@@ -1766,12 +1662,11 @@ HWTEST(AudioInterruptUnitTest, SendSessionTimeOutStopEvent_005, TestSize.Level1)
  * @tc.number: AudioInterruptService_DeactivateAudioInterruptInternal_001
  * @tc.desc  : Test DeactivateAudioInterruptInternal.
  */
-HWTEST(AudioInterruptUnitTest, AudioInterruptService_DeactivateAudioInterruptInternal_001, TestSize.Level1)
+HWTEST_F(AudioInterruptUnitTest, AudioInterruptService_DeactivateAudioInterruptInternal_001, TestSize.Level1)
 {
     auto interruptServiceTest = GetTnterruptServiceTest();
     interruptServiceTest->zonesMap_.clear();
     AudioInterrupt audioInterrupt = {};
-    AudioSessionService audioSessionService;
     AudioInterruptService audioInterruptService;
     AudioSessionStrategy strategy;
 
@@ -1784,9 +1679,6 @@ HWTEST(AudioInterruptUnitTest, AudioInterruptService_DeactivateAudioInterruptInt
     EXPECT_NE(interruptServiceTest->zonesMap_.find(0), interruptServiceTest->zonesMap_.end());
 
     bool IS_SESSION_TIMEOUT = true;
-    interruptServiceTest->sessionService_ = nullptr;
-    interruptServiceTest->DeactivateAudioInterruptInternal(0, audioInterrupt, IS_SESSION_TIMEOUT);
-
     interruptServiceTest->Init(GetPolicyServerTest());
     int32_t ret = interruptServiceTest->ActivateAudioSession(0, 0, strategy);
     EXPECT_EQ(SUCCESS, ret);
@@ -1811,7 +1703,7 @@ HWTEST(AudioInterruptUnitTest, AudioInterruptService_DeactivateAudioInterruptInt
  * @tc.number: AudioInterruptService_DeactivateAudioInterruptInternal_002
  * @tc.desc  : Test DeactivateAudioInterruptInternal.
  */
-HWTEST(AudioInterruptUnitTest, AudioInterruptService_DeactivateAudioInterruptInternal_002, TestSize.Level1)
+HWTEST_F(AudioInterruptUnitTest, AudioInterruptService_DeactivateAudioInterruptInternal_002, TestSize.Level1)
 {
     auto interruptServiceTest = GetTnterruptServiceTest();
     interruptServiceTest->zonesMap_.clear();
@@ -1822,7 +1714,6 @@ HWTEST(AudioInterruptUnitTest, AudioInterruptService_DeactivateAudioInterruptInt
     audioInterrupt.streamId = 0;
     interruptServiceTest->Init(GetPolicyServerTest());
     interruptServiceTest->ActivateAudioSession(0, 0, strategy);
-    interruptServiceTest->sessionService_ = nullptr;
     interruptServiceTest->zonesMap_[0] = std::make_shared<AudioInterruptZone>();
     std::pair<AudioInterrupt, AudioFocuState> pairTest = std::make_pair(audioInterrupt, ACTIVE);
     interruptServiceTest->zonesMap_.find(0)->second->audioFocusInfoList.push_back(pairTest);
@@ -1844,7 +1735,7 @@ HWTEST(AudioInterruptUnitTest, AudioInterruptService_DeactivateAudioInterruptInt
  * @tc.number: AudioInterruptService_UpdateAudioSceneFromInterrupt_002
  * @tc.desc  : Test UpdateAudioSceneFromInterrupt.
  */
-HWTEST(AudioInterruptUnitTest, AudioInterruptService_UpdateAudioSceneFromInterrupt_002, TestSize.Level1)
+HWTEST_F(AudioInterruptUnitTest, AudioInterruptService_UpdateAudioSceneFromInterrupt_002, TestSize.Level1)
 {
     auto interruptServiceTest = GetTnterruptServiceTest();
     ASSERT_TRUE(interruptServiceTest != nullptr);
@@ -1861,7 +1752,7 @@ HWTEST(AudioInterruptUnitTest, AudioInterruptService_UpdateAudioSceneFromInterru
  * @tc.number: AudioInterruptService_SendInterruptEvent_001
  * @tc.desc  : Test SendInterruptEvent.
  */
-HWTEST(AudioInterruptUnitTest, AudioInterruptService_SendInterruptEvent_001, TestSize.Level1)
+HWTEST_F(AudioInterruptUnitTest, AudioInterruptService_SendInterruptEvent_001, TestSize.Level1)
 {
     auto interruptServiceTest = GetTnterruptServiceTest();
     interruptServiceTest->zonesMap_.clear();
@@ -1882,7 +1773,7 @@ HWTEST(AudioInterruptUnitTest, AudioInterruptService_SendInterruptEvent_001, Tes
 * @tc.number: SendFocusChangeEvent_001
 * @tc.desc  : Test SendFocusChangeEvent
 */
-HWTEST(AudioInterruptUnitTest, SendFocusChangeEvent_001, TestSize.Level1)
+HWTEST_F(AudioInterruptUnitTest, SendFocusChangeEvent_001, TestSize.Level1)
 {
     auto interruptServiceTest = GetTnterruptServiceTest();
     AudioFocusType audioFocusTypeTest;
@@ -1899,7 +1790,7 @@ HWTEST(AudioInterruptUnitTest, SendFocusChangeEvent_001, TestSize.Level1)
 * @tc.number: SendFocusChangeEvent_002
 * @tc.desc  : Test SendFocusChangeEvent
 */
-HWTEST(AudioInterruptUnitTest, SendFocusChangeEvent_002, TestSize.Level1)
+HWTEST_F(AudioInterruptUnitTest, SendFocusChangeEvent_002, TestSize.Level1)
 {
     auto interruptServiceTest = GetTnterruptServiceTest();
     AudioFocusType audioFocusTypeTest;
@@ -1921,7 +1812,7 @@ HWTEST(AudioInterruptUnitTest, SendFocusChangeEvent_002, TestSize.Level1)
 * @tc.number: SendActiveVolumeTypeChangeEvent_001
 * @tc.desc  : Test SendActiveVolumeTypeChangeEvent
 */
-HWTEST(AudioInterruptUnitTest, SendActiveVolumeTypeChangeEvent_001, TestSize.Level1)
+HWTEST_F(AudioInterruptUnitTest, SendActiveVolumeTypeChangeEvent_001, TestSize.Level1)
 {
     auto interruptServiceTest = GetTnterruptServiceTest();
     interruptServiceTest->SetCallbackHandler(GetServerHandlerTest());
@@ -1938,7 +1829,7 @@ HWTEST(AudioInterruptUnitTest, SendActiveVolumeTypeChangeEvent_001, TestSize.Lev
 * @tc.number: AudioInterruptServiceReleaseAudioInterruptZone_001
 * @tc.desc  : Test ReleaseAudioInterruptZone
 */
-HWTEST(AudioInterruptUnitTest, AudioInterruptServiceReleaseAudioInterruptZone_001, TestSize.Level1)
+HWTEST_F(AudioInterruptUnitTest, AudioInterruptServiceReleaseAudioInterruptZone_001, TestSize.Level1)
 {
     sptr<AudioPolicyServer> server = new (std::nothrow) AudioPolicyServer(SYSTEM_ABILITY_ID, RUN_ON_CREATE);
     server->interruptService_ = std::make_shared<AudioInterruptService>();
@@ -1962,7 +1853,7 @@ HWTEST(AudioInterruptUnitTest, AudioInterruptServiceReleaseAudioInterruptZone_00
 
     SetUid1041();
     retStatus = interruptServiceTest->ReleaseAudioInterruptZone(0, getZoneFunc);
-    EXPECT_EQ(retStatus, ERR_INVALID_PARAM);
+    EXPECT_EQ(ERR_INVALID_PARAM, retStatus);
 
     SetUid1041();
     interruptServiceTest->zonesMap_.clear();
@@ -1970,7 +1861,7 @@ HWTEST(AudioInterruptUnitTest, AudioInterruptServiceReleaseAudioInterruptZone_00
 
     interruptServiceTest->zonesMap_[1] = std::make_shared<AudioInterruptZone>();
     retStatus = interruptServiceTest->ReleaseAudioInterruptZone(1, getZoneFunc);
-    EXPECT_EQ(retStatus, ERR_INVALID_PARAM);
+    EXPECT_EQ(ERR_INVALID_PARAM, retStatus);
 }
 
 /**
@@ -1978,7 +1869,7 @@ HWTEST(AudioInterruptUnitTest, AudioInterruptServiceReleaseAudioInterruptZone_00
 * @tc.number: AudioInterruptServiceCreateAudioInterruptZone_001
 * @tc.desc  : Test RCreateAudioInterruptZone.
 */
-HWTEST(AudioInterruptUnitTest, AudioInterruptServiceCreateAudioInterruptZone_001, TestSize.Level1)
+HWTEST_F(AudioInterruptUnitTest, AudioInterruptServiceCreateAudioInterruptZone_001, TestSize.Level1)
 {
     sptr<AudioPolicyServer> server = nullptr;
     auto interruptServiceTest = GetTnterruptServiceTest();
@@ -1991,11 +1882,11 @@ HWTEST(AudioInterruptUnitTest, AudioInterruptServiceCreateAudioInterruptZone_001
 
     SetUid1041();
     retStatus = interruptServiceTest->CreateAudioInterruptZone(0, context);
-    EXPECT_EQ(retStatus, ERR_INVALID_PARAM);
+    EXPECT_EQ(ERR_INVALID_PARAM, retStatus);
 
     SetUid1041();
     retStatus = interruptServiceTest->CreateAudioInterruptZone(2, context);
-    EXPECT_EQ(retStatus, ERR_INVALID_PARAM);
+    EXPECT_EQ(ERR_INVALID_PARAM, retStatus);
 }
 
 /**
@@ -2003,7 +1894,7 @@ HWTEST(AudioInterruptUnitTest, AudioInterruptServiceCreateAudioInterruptZone_001
 * @tc.number: MigrateAudioInterruptZone_001
 * @tc.desc  : Test MigrateAudioInterruptZone
 */
-HWTEST(AudioInterruptUnitTest, MigrateAudioInterruptZone_001, TestSize.Level1)
+HWTEST_F(AudioInterruptUnitTest, MigrateAudioInterruptZone_001, TestSize.Level1)
 {
     sptr<AudioPolicyServer> server = new (std::nothrow) AudioPolicyServer(SYSTEM_ABILITY_ID, RUN_ON_CREATE);
     server->interruptService_ = std::make_shared<AudioInterruptService>();
@@ -2028,7 +1919,7 @@ HWTEST(AudioInterruptUnitTest, MigrateAudioInterruptZone_001, TestSize.Level1)
 * @tc.number: MigrateAudioInterruptZone_002
 * @tc.desc  : Test MigrateAudioInterruptZone
 */
-HWTEST(AudioInterruptUnitTest, MigrateAudioInterruptZone_002, TestSize.Level1)
+HWTEST_F(AudioInterruptUnitTest, MigrateAudioInterruptZone_002, TestSize.Level1)
 {
     sptr<AudioPolicyServer> server = new (std::nothrow) AudioPolicyServer(SYSTEM_ABILITY_ID, RUN_ON_CREATE);
     server->interruptService_ = std::make_shared<AudioInterruptService>();
@@ -2060,7 +1951,7 @@ HWTEST(AudioInterruptUnitTest, MigrateAudioInterruptZone_002, TestSize.Level1)
 * @tc.number: MigrateAudioInterruptZone_003
 * @tc.desc  : Test MigrateAudioInterruptZone
 */
-HWTEST(AudioInterruptUnitTest, MigrateAudioInterruptZone_003, TestSize.Level1)
+HWTEST_F(AudioInterruptUnitTest, MigrateAudioInterruptZone_003, TestSize.Level1)
 {
     auto interruptServiceTest = GetTnterruptServiceTest();
 
@@ -2084,7 +1975,7 @@ HWTEST(AudioInterruptUnitTest, MigrateAudioInterruptZone_003, TestSize.Level1)
 * @tc.number: MigrateAudioInterruptZone_004
 * @tc.desc  : Test MigrateAudioInterruptZone
 */
-HWTEST(AudioInterruptUnitTest, MigrateAudioInterruptZone_004, TestSize.Level1)
+HWTEST_F(AudioInterruptUnitTest, MigrateAudioInterruptZone_004, TestSize.Level1)
 {
     sptr<AudioPolicyServer> server = new (std::nothrow) AudioPolicyServer(SYSTEM_ABILITY_ID, RUN_ON_CREATE);
     server->interruptService_ = std::make_shared<AudioInterruptService>();
@@ -2113,7 +2004,7 @@ HWTEST(AudioInterruptUnitTest, MigrateAudioInterruptZone_004, TestSize.Level1)
 * @tc.number: MigrateAudioInterruptZone_005
 * @tc.desc  : Test MigrateAudioInterruptZone
 */
-HWTEST(AudioInterruptUnitTest, MigrateAudioInterruptZone_005, TestSize.Level1)
+HWTEST_F(AudioInterruptUnitTest, MigrateAudioInterruptZone_005, TestSize.Level1)
 {
     sptr<AudioPolicyServer> server = new (std::nothrow) AudioPolicyServer(SYSTEM_ABILITY_ID, RUN_ON_CREATE);
     server->interruptService_ = std::make_shared<AudioInterruptService>();
@@ -2179,7 +2070,7 @@ static void AddVoipInterruptToList(AudioFocusList &list, int32_t streamId, int32
 * @tc.number: MigrateAudioInterruptZone_006
 * @tc.desc  : Test MigrateAudioInterruptZone
 */
-HWTEST(AudioInterruptUnitTest, MigrateAudioInterruptZone_006, TestSize.Level1)
+HWTEST_F(AudioInterruptUnitTest, MigrateAudioInterruptZone_006, TestSize.Level1)
 {
     sptr<AudioPolicyServer> server = new (std::nothrow) AudioPolicyServer(SYSTEM_ABILITY_ID, RUN_ON_CREATE);
     server->coreService_ = AudioCoreService::GetCoreService();
@@ -2222,7 +2113,7 @@ HWTEST(AudioInterruptUnitTest, MigrateAudioInterruptZone_006, TestSize.Level1)
 * @tc.number: InjectInterruptToAudioZone_001
 * @tc.desc  : Test InjectInterruptToAudioZone
 */
-HWTEST(AudioInterruptUnitTest, InjectInterruptToAudioZone_001, TestSize.Level1)
+HWTEST_F(AudioInterruptUnitTest, InjectInterruptToAudioZone_001, TestSize.Level1)
 {
     auto interruptServiceTest = GetTnterruptServiceTest();
     AudioFocusList interrupts;
@@ -2236,7 +2127,7 @@ HWTEST(AudioInterruptUnitTest, InjectInterruptToAudioZone_001, TestSize.Level1)
 * @tc.number: InjectInterruptToAudioZone_002
 * @tc.desc  : Test InjectInterruptToAudioZone
 */
-HWTEST(AudioInterruptUnitTest, InjectInterruptToAudioZone_002, TestSize.Level1)
+HWTEST_F(AudioInterruptUnitTest, InjectInterruptToAudioZone_002, TestSize.Level1)
 {
     auto interruptServiceTest = GetTnterruptServiceTest();
     AudioFocusList interrupts;
@@ -2258,7 +2149,7 @@ HWTEST(AudioInterruptUnitTest, InjectInterruptToAudioZone_002, TestSize.Level1)
 * @tc.number: InjectInterruptToAudioZone_003
 * @tc.desc  : Test InjectInterruptToAudioZone
 */
-HWTEST(AudioInterruptUnitTest, InjectInterruptToAudioZone_003, TestSize.Level1)
+HWTEST_F(AudioInterruptUnitTest, InjectInterruptToAudioZone_003, TestSize.Level1)
 {
     auto interruptServiceTest = GetTnterruptServiceTest();
     AudioFocusList interrupts;
@@ -2278,7 +2169,7 @@ HWTEST(AudioInterruptUnitTest, InjectInterruptToAudioZone_003, TestSize.Level1)
 * @tc.number: InjectInterruptToAudioZone_004
 * @tc.desc  : Test InjectInterruptToAudioZone
 */
-HWTEST(AudioInterruptUnitTest, InjectInterruptToAudioZone_004, TestSize.Level1)
+HWTEST_F(AudioInterruptUnitTest, InjectInterruptToAudioZone_004, TestSize.Level1)
 {
     auto interruptServiceTest = GetTnterruptServiceTest();
     AudioFocusList interrupts;
@@ -2292,7 +2183,7 @@ HWTEST(AudioInterruptUnitTest, InjectInterruptToAudioZone_004, TestSize.Level1)
 * @tc.number: InjectInterruptToAudioZone_005
 * @tc.desc  : Test InjectInterruptToAudioZone
 */
-HWTEST(AudioInterruptUnitTest, InjectInterruptToAudioZone_005, TestSize.Level1)
+HWTEST_F(AudioInterruptUnitTest, InjectInterruptToAudioZone_005, TestSize.Level1)
 {
     auto interruptServiceTest = GetTnterruptServiceTest();
     AudioFocusList interrupts;
@@ -2314,7 +2205,7 @@ HWTEST(AudioInterruptUnitTest, InjectInterruptToAudioZone_005, TestSize.Level1)
 * @tc.number: InjectInterruptToAudioZone_006
 * @tc.desc  : Test InjectInterruptToAudioZone
 */
-HWTEST(AudioInterruptUnitTest, InjectInterruptToAudioZone_006, TestSize.Level1)
+HWTEST_F(AudioInterruptUnitTest, InjectInterruptToAudioZone_006, TestSize.Level1)
 {
     auto interruptServiceTest = GetTnterruptServiceTest();
     AudioFocusList interrupts;
@@ -2333,7 +2224,7 @@ HWTEST(AudioInterruptUnitTest, InjectInterruptToAudioZone_006, TestSize.Level1)
 * @tc.number: InjectInterruptToAudioZone_007
 * @tc.desc  : Test InjectInterruptToAudioZone
 */
-HWTEST(AudioInterruptUnitTest, InjectInterruptToAudioZone_007, TestSize.Level1)
+HWTEST_F(AudioInterruptUnitTest, InjectInterruptToAudioZone_007, TestSize.Level1)
 {
     sptr<AudioPolicyServer> server = new (std::nothrow) AudioPolicyServer(SYSTEM_ABILITY_ID, RUN_ON_CREATE);
     server->coreService_ = AudioCoreService::GetCoreService();
@@ -2362,7 +2253,7 @@ HWTEST(AudioInterruptUnitTest, InjectInterruptToAudioZone_007, TestSize.Level1)
 * @tc.number: InjectInterruptToAudioZone_008
 * @tc.desc  : Test InjectInterruptToAudioZone
 */
-HWTEST(AudioInterruptUnitTest, InjectInterruptToAudioZone_008, TestSize.Level1)
+HWTEST_F(AudioInterruptUnitTest, InjectInterruptToAudioZone_008, TestSize.Level1)
 {
     sptr<AudioPolicyServer> server = new (std::nothrow) AudioPolicyServer(SYSTEM_ABILITY_ID, RUN_ON_CREATE);
     server->interruptService_ = std::make_shared<AudioInterruptService>();
@@ -2395,7 +2286,7 @@ HWTEST(AudioInterruptUnitTest, InjectInterruptToAudioZone_008, TestSize.Level1)
 * @tc.number: InjectInterruptToAudioZone_009
 * @tc.desc  : Test InjectInterruptToAudioZone
 */
-HWTEST(AudioInterruptUnitTest, InjectInterruptToAudioZone_009, TestSize.Level1)
+HWTEST_F(AudioInterruptUnitTest, InjectInterruptToAudioZone_009, TestSize.Level1)
 {
     sptr<AudioPolicyServer> server = new (std::nothrow) AudioPolicyServer(SYSTEM_ABILITY_ID, RUN_ON_CREATE);
     server->interruptService_ = std::make_shared<AudioInterruptService>();
@@ -2427,7 +2318,7 @@ HWTEST(AudioInterruptUnitTest, InjectInterruptToAudioZone_009, TestSize.Level1)
 * @tc.number: InjectInterruptToAudioZone_010
 * @tc.desc  : Test InjectInterruptToAudioZone
 */
-HWTEST(AudioInterruptUnitTest, InjectInterruptToAudioZone_010, TestSize.Level1)
+HWTEST_F(AudioInterruptUnitTest, InjectInterruptToAudioZone_010, TestSize.Level1)
 {
     sptr<AudioPolicyServer> server = new (std::nothrow) AudioPolicyServer(SYSTEM_ABILITY_ID, RUN_ON_CREATE);
     server->interruptService_ = std::make_shared<AudioInterruptService>();
@@ -2460,7 +2351,7 @@ HWTEST(AudioInterruptUnitTest, InjectInterruptToAudioZone_010, TestSize.Level1)
  * @tc.number: AudioInterruptService_SimulateFocusEntry_001
  * @tc.desc  : Test SimulateFocusEntry.
  */
-HWTEST(AudioInterruptUnitTest, AudioInterruptService_SimulateFocusEntry_001, TestSize.Level1)
+HWTEST_F(AudioInterruptUnitTest, AudioInterruptService_SimulateFocusEntry_001, TestSize.Level1)
 {
     auto interruptServiceTest = GetTnterruptServiceTest();
     interruptServiceTest->zonesMap_.clear();
@@ -2492,7 +2383,7 @@ HWTEST(AudioInterruptUnitTest, AudioInterruptService_SimulateFocusEntry_001, Tes
  * @tc.number: AudioInterruptService_SimulateFocusEntry_002
  * @tc.desc  : Test SimulateFocusEntry.
  */
-HWTEST(AudioInterruptUnitTest, AudioInterruptService_SimulateFocusEntry_002, TestSize.Level1)
+HWTEST_F(AudioInterruptUnitTest, AudioInterruptService_SimulateFocusEntry_002, TestSize.Level1)
 {
     auto interruptServiceTest = GetTnterruptServiceTest();
     interruptServiceTest->zonesMap_.clear();
@@ -2513,7 +2404,7 @@ HWTEST(AudioInterruptUnitTest, AudioInterruptService_SimulateFocusEntry_002, Tes
  * @tc.number: AudioInterruptService_SimulateFocusEntry_003
  * @tc.desc  : Test SimulateFocusEntry.
  */
-HWTEST(AudioInterruptUnitTest, AudioInterruptService_SimulateFocusEntry_003, TestSize.Level1)
+HWTEST_F(AudioInterruptUnitTest, AudioInterruptService_SimulateFocusEntry_003, TestSize.Level1)
 {
     auto interruptServiceTest = GetTnterruptServiceTest();
     interruptServiceTest->zonesMap_.clear();
@@ -2534,7 +2425,7 @@ HWTEST(AudioInterruptUnitTest, AudioInterruptService_SimulateFocusEntry_003, Tes
  * @tc.number: AudioInterruptService_SimulateFocusEntry_004
  * @tc.desc  : Test SimulateFocusEntry.
  */
-HWTEST(AudioInterruptUnitTest, AudioInterruptService_SimulateFocusEntry_004, TestSize.Level1)
+HWTEST_F(AudioInterruptUnitTest, AudioInterruptService_SimulateFocusEntry_004, TestSize.Level1)
 {
     auto interruptServiceTest = GetTnterruptServiceTest();
     interruptServiceTest->zonesMap_.clear();
@@ -2562,7 +2453,7 @@ HWTEST(AudioInterruptUnitTest, AudioInterruptService_SimulateFocusEntry_004, Tes
  * @tc.number: AudioInterruptService_SimulateFocusEntry_005
  * @tc.desc  : Test SimulateFocusEntry.
  */
-HWTEST(AudioInterruptUnitTest, AudioInterruptService_SimulateFocusEntry_005, TestSize.Level1)
+HWTEST_F(AudioInterruptUnitTest, AudioInterruptService_SimulateFocusEntry_005, TestSize.Level1)
 {
     auto interruptServiceTest = GetTnterruptServiceTest();
     interruptServiceTest->zonesMap_.clear();
@@ -2589,7 +2480,7 @@ HWTEST(AudioInterruptUnitTest, AudioInterruptService_SimulateFocusEntry_005, Tes
  * @tc.number: AudioInterruptService_SimulateFocusEntry_006
  * @tc.desc  : Test SimulateFocusEntry.
  */
-HWTEST(AudioInterruptUnitTest, AudioInterruptService_SimulateFocusEntry_006, TestSize.Level1)
+HWTEST_F(AudioInterruptUnitTest, AudioInterruptService_SimulateFocusEntry_006, TestSize.Level1)
 {
     auto interruptServiceTest = GetTnterruptServiceTest();
     interruptServiceTest->zonesMap_.clear();
@@ -2613,7 +2504,7 @@ HWTEST(AudioInterruptUnitTest, AudioInterruptService_SimulateFocusEntry_006, Tes
  * @tc.number: AudioInterruptService_SimulateFocusEntry_007
  * @tc.desc  : Test SimulateFocusEntry and IsSameAppInShareMode is true.
  */
-HWTEST(AudioInterruptUnitTest, AudioInterruptService_SimulateFocusEntry_007, TestSize.Level1)
+HWTEST_F(AudioInterruptUnitTest, AudioInterruptService_SimulateFocusEntry_007, TestSize.Level1)
 {
     auto interruptServiceTest = GetTnterruptServiceTest();
     interruptServiceTest->zonesMap_.clear();
@@ -2642,7 +2533,7 @@ HWTEST(AudioInterruptUnitTest, AudioInterruptService_SimulateFocusEntry_007, Tes
  * @tc.number: AudioInterruptService_SimulateFocusEntry_008
  * @tc.desc  : Test SimulateFocusEntry and IsSameAppInShareMode is true.
  */
-HWTEST(AudioInterruptUnitTest, AudioInterruptService_SimulateFocusEntry_008, TestSize.Level1)
+HWTEST_F(AudioInterruptUnitTest, AudioInterruptService_SimulateFocusEntry_008, TestSize.Level1)
 {
     auto interruptServiceTest = GetTnterruptServiceTest();
     interruptServiceTest->zonesMap_.clear();
@@ -2670,7 +2561,7 @@ HWTEST(AudioInterruptUnitTest, AudioInterruptService_SimulateFocusEntry_008, Tes
  * @tc.number: AudioInterruptService_SimulateFocusEntry_009
  * @tc.desc  : Test SimulateFocusEntry and IsSameAppInShareMode is false.
  */
-HWTEST(AudioInterruptUnitTest, AudioInterruptService_SimulateFocusEntry_009, TestSize.Level1)
+HWTEST_F(AudioInterruptUnitTest, AudioInterruptService_SimulateFocusEntry_009, TestSize.Level1)
 {
     auto interruptServiceTest = GetTnterruptServiceTest();
     interruptServiceTest->zonesMap_.clear();
@@ -2698,7 +2589,7 @@ HWTEST(AudioInterruptUnitTest, AudioInterruptService_SimulateFocusEntry_009, Tes
  * @tc.number: AudioInterruptService_SimulateFocusEntry_010
  * @tc.desc  : Test SimulateFocusEntry and IsSameAppInShareMode is false.
  */
-HWTEST(AudioInterruptUnitTest, AudioInterruptService_SimulateFocusEntry_010, TestSize.Level1)
+HWTEST_F(AudioInterruptUnitTest, AudioInterruptService_SimulateFocusEntry_010, TestSize.Level1)
 {
     auto interruptServiceTest = GetTnterruptServiceTest();
     interruptServiceTest->zonesMap_.clear();
@@ -2726,7 +2617,7 @@ HWTEST(AudioInterruptUnitTest, AudioInterruptService_SimulateFocusEntry_010, Tes
  * @tc.number: AudioInterruptService_SimulateFocusEntry_011
  * @tc.desc  : Test SimulateFocusEntry and IsSameAppInShareMode is false.
  */
-HWTEST(AudioInterruptUnitTest, AudioInterruptService_SimulateFocusEntry_011, TestSize.Level1)
+HWTEST_F(AudioInterruptUnitTest, AudioInterruptService_SimulateFocusEntry_011, TestSize.Level1)
 {
     auto interruptServiceTest = GetTnterruptServiceTest();
     interruptServiceTest->zonesMap_.clear();
@@ -2754,7 +2645,7 @@ HWTEST(AudioInterruptUnitTest, AudioInterruptService_SimulateFocusEntry_011, Tes
  * @tc.number: AudioInterruptService_SimulateFocusEntry_012
  * @tc.desc  : Test SimulateFocusEntry and IsSameAppInShareMode is false.
  */
-HWTEST(AudioInterruptUnitTest, AudioInterruptService_SimulateFocusEntry_012, TestSize.Level1)
+HWTEST_F(AudioInterruptUnitTest, AudioInterruptService_SimulateFocusEntry_012, TestSize.Level1)
 {
     auto interruptServiceTest = GetTnterruptServiceTest();
     interruptServiceTest->zonesMap_.clear();
@@ -2782,7 +2673,7 @@ HWTEST(AudioInterruptUnitTest, AudioInterruptService_SimulateFocusEntry_012, Tes
  * @tc.number: AudioInterruptService_SimulateFocusEntry_013
  * @tc.desc  : Test SimulateFocusEntry and IsSameAppInShareMode is false.
  */
-HWTEST(AudioInterruptUnitTest, AudioInterruptService_SimulateFocusEntry_013, TestSize.Level1)
+HWTEST_F(AudioInterruptUnitTest, AudioInterruptService_SimulateFocusEntry_013, TestSize.Level1)
 {
     auto interruptServiceTest = GetTnterruptServiceTest();
     interruptServiceTest->zonesMap_.clear();
@@ -2810,7 +2701,7 @@ HWTEST(AudioInterruptUnitTest, AudioInterruptService_SimulateFocusEntry_013, Tes
  * @tc.number: AudioInterruptService_SimulateFocusEntry_014
  * @tc.desc  : Test SimulateFocusEntry and IsSameAppInShareMode is false.
  */
-HWTEST(AudioInterruptUnitTest, AudioInterruptService_SimulateFocusEntry_014, TestSize.Level1)
+HWTEST_F(AudioInterruptUnitTest, AudioInterruptService_SimulateFocusEntry_014, TestSize.Level1)
 {
     auto interruptServiceTest = GetTnterruptServiceTest();
     interruptServiceTest->zonesMap_.clear();
@@ -2838,7 +2729,7 @@ HWTEST(AudioInterruptUnitTest, AudioInterruptService_SimulateFocusEntry_014, Tes
  * @tc.number: AudioInterruptService_SimulateFocusEntry_015
  * @tc.desc  : Test SimulateFocusEntry and IsSameAppInShareMode is false.
  */
-HWTEST(AudioInterruptUnitTest, AudioInterruptService_SimulateFocusEntry_015, TestSize.Level1)
+HWTEST_F(AudioInterruptUnitTest, AudioInterruptService_SimulateFocusEntry_015, TestSize.Level1)
 {
     auto interruptServiceTest = GetTnterruptServiceTest();
     interruptServiceTest->zonesMap_.clear();
@@ -2866,7 +2757,7 @@ HWTEST(AudioInterruptUnitTest, AudioInterruptService_SimulateFocusEntry_015, Tes
  * @tc.number: AudioInterruptService_SimulateFocusEntry_016
  * @tc.desc  : Test SimulateFocusEntry and IsSameAppInShareMode is false.
  */
-HWTEST(AudioInterruptUnitTest, AudioInterruptService_SimulateFocusEntry_016, TestSize.Level1)
+HWTEST_F(AudioInterruptUnitTest, AudioInterruptService_SimulateFocusEntry_016, TestSize.Level1)
 {
     auto interruptServiceTest = GetTnterruptServiceTest();
     interruptServiceTest->zonesMap_.clear();
@@ -2894,7 +2785,7 @@ HWTEST(AudioInterruptUnitTest, AudioInterruptService_SimulateFocusEntry_016, Tes
  * @tc.number: AudioInterruptService_SimulateFocusEntry_017
  * @tc.desc  : Test SimulateFocusEntry and IsSameAppInShareMode is false.
  */
-HWTEST(AudioInterruptUnitTest, AudioInterruptService_SimulateFocusEntry_017, TestSize.Level1)
+HWTEST_F(AudioInterruptUnitTest, AudioInterruptService_SimulateFocusEntry_017, TestSize.Level1)
 {
     auto interruptServiceTest = GetTnterruptServiceTest();
     interruptServiceTest->zonesMap_.clear();
@@ -2922,7 +2813,7 @@ HWTEST(AudioInterruptUnitTest, AudioInterruptService_SimulateFocusEntry_017, Tes
  * @tc.number: AudioInterruptService_SimulateFocusEntry_018
  * @tc.desc  : Test SimulateFocusEntry and IsSameAppInShareMode is false.
  */
-HWTEST(AudioInterruptUnitTest, AudioInterruptService_SimulateFocusEntry_018, TestSize.Level1)
+HWTEST_F(AudioInterruptUnitTest, AudioInterruptService_SimulateFocusEntry_018, TestSize.Level1)
 {
     auto interruptServiceTest = GetTnterruptServiceTest();
     interruptServiceTest->zonesMap_.clear();
@@ -2950,7 +2841,7 @@ HWTEST(AudioInterruptUnitTest, AudioInterruptService_SimulateFocusEntry_018, Tes
  * @tc.number: AudioInterruptService_SimulateFocusEntry_019
  * @tc.desc  : Test SimulateFocusEntry.
  */
-HWTEST(AudioInterruptUnitTest, AudioInterruptService_SimulateFocusEntry_019, TestSize.Level1)
+HWTEST_F(AudioInterruptUnitTest, AudioInterruptService_SimulateFocusEntry_019, TestSize.Level1)
 {
     auto interruptServiceTest = GetTnterruptServiceTest();
     interruptServiceTest->zonesMap_.clear();
@@ -2978,7 +2869,7 @@ HWTEST(AudioInterruptUnitTest, AudioInterruptService_SimulateFocusEntry_019, Tes
 * @tc.number: AudioInterruptService_SimulateFocusEntry_020
 * @tc.desc  : Test SimulateFocusEntry
 */
-HWTEST(AudioInterruptUnitTest, AudioInterruptService_SimulateFocusEntry_020, TestSize.Level1)
+HWTEST_F(AudioInterruptUnitTest, AudioInterruptService_SimulateFocusEntry_020, TestSize.Level1)
 {
     auto interruptServiceTest = GetTnterruptServiceTest();
     interruptServiceTest->zonesMap_.clear();
@@ -3002,7 +2893,7 @@ HWTEST(AudioInterruptUnitTest, AudioInterruptService_SimulateFocusEntry_020, Tes
 * @tc.number: AudioInterruptService_SimulateFocusEntry_021
 * @tc.desc  : Test SimulateFocusEntry
 */
-HWTEST(AudioInterruptUnitTest, AudioInterruptService_SimulateFocusEntry_021, TestSize.Level1)
+HWTEST_F(AudioInterruptUnitTest, AudioInterruptService_SimulateFocusEntry_021, TestSize.Level1)
 {
     auto interruptServiceTest = GetTnterruptServiceTest();
     interruptServiceTest->zonesMap_.clear();
@@ -3032,7 +2923,7 @@ HWTEST(AudioInterruptUnitTest, AudioInterruptService_SimulateFocusEntry_021, Tes
 * @tc.number: AudioInterruptService_SimulateFocusEntry_022
 * @tc.desc  : Test SimulateFocusEntry
 */
-HWTEST(AudioInterruptUnitTest, AudioInterruptService_SimulateFocusEntry_022, TestSize.Level1)
+HWTEST_F(AudioInterruptUnitTest, AudioInterruptService_SimulateFocusEntry_022, TestSize.Level1)
 {
     auto interruptServiceTest = GetTnterruptServiceTest();
     interruptServiceTest->zonesMap_.clear();
@@ -3075,7 +2966,7 @@ HWTEST(AudioInterruptUnitTest, AudioInterruptService_SimulateFocusEntry_022, Tes
 * @tc.number: AudioInterruptService_SimulateFocusEntry_023
 * @tc.desc  : Test SimulateFocusEntry
 */
-HWTEST(AudioInterruptUnitTest, AudioInterruptService_SimulateFocusEntry_023, TestSize.Level1)
+HWTEST_F(AudioInterruptUnitTest, AudioInterruptService_SimulateFocusEntry_023, TestSize.Level1)
 {
     auto interruptServiceTest = GetTnterruptServiceTest();
     interruptServiceTest->zonesMap_.clear();
@@ -3119,7 +3010,7 @@ HWTEST(AudioInterruptUnitTest, AudioInterruptService_SimulateFocusEntry_023, Tes
 * @tc.number: AudioInterruptService_SimulateFocusEntry_024
 * @tc.desc  : Test SimulateFocusEntry
 */
-HWTEST(AudioInterruptUnitTest, AudioInterruptService_SimulateFocusEntry_024, TestSize.Level1)
+HWTEST_F(AudioInterruptUnitTest, AudioInterruptService_SimulateFocusEntry_024, TestSize.Level1)
 {
     auto interruptServiceTest = GetTnterruptServiceTest();
     interruptServiceTest->zonesMap_.clear();
@@ -3165,11 +3056,10 @@ HWTEST(AudioInterruptUnitTest, AudioInterruptService_SimulateFocusEntry_024, Tes
 * @tc.number: AudioInterruptServiceRequestAudioFocus_001
 * @tc.desc  : Test RequestAudioFocus.
 */
-HWTEST(AudioInterruptUnitTest, AudioInterruptServiceRequestAudioFocus_001, TestSize.Level1)
+HWTEST_F(AudioInterruptUnitTest, AudioInterruptServiceRequestAudioFocus_001, TestSize.Level1)
 {
     sptr<AudioPolicyServer> server = nullptr;
     auto interruptServiceTest = GetTnterruptServiceTest();
-    EXPECT_EQ(interruptServiceTest->sessionService_, nullptr);
     interruptServiceTest->Init(server);
     AudioInterrupt incomingInterrupt;
 
@@ -3192,12 +3082,11 @@ HWTEST(AudioInterruptUnitTest, AudioInterruptServiceRequestAudioFocus_001, TestS
  * @tc.number: AudioInterruptService_DeactivateAudioInterruptInternal_004
  * @tc.desc  : Test DeactivateAudioInterruptInternal.
  */
-HWTEST(AudioInterruptUnitTest, AudioInterruptService_DeactivateAudioInterruptInternal_004, TestSize.Level1)
+HWTEST_F(AudioInterruptUnitTest, AudioInterruptService_DeactivateAudioInterruptInternal_004, TestSize.Level1)
 {
     auto interruptServiceTest = GetTnterruptServiceTest();
     interruptServiceTest->zonesMap_.clear();
     AudioInterrupt audioInterrupt = {};
-    AudioSessionService audioSessionService;
     AudioInterruptService audioInterruptService;
 
     interruptServiceTest->DeactivateAudioInterruptInternal(0, audioInterrupt, true);
@@ -3215,7 +3104,7 @@ HWTEST(AudioInterruptUnitTest, AudioInterruptService_DeactivateAudioInterruptInt
 * @tc.number: AudioInterruptService_GetAppState_001
 * @tc.desc  : Test GetAppState
 */
-HWTEST(AudioInterruptUnitTest, AudioInterruptService_GetAppState_001, TestSize.Level1)
+HWTEST_F(AudioInterruptUnitTest, AudioInterruptService_GetAppState_001, TestSize.Level1)
 {
     auto server = GetPolicyServerTest();
     auto interruptServiceTest = GetTnterruptServiceTest();
@@ -3231,7 +3120,7 @@ HWTEST(AudioInterruptUnitTest, AudioInterruptService_GetAppState_001, TestSize.L
 * @tc.number: AudioInterruptService_WriteStartDfxMsg_001
 * @tc.desc  : Test WriteStartDfxMsg
 */
-HWTEST(AudioInterruptUnitTest, AudioInterruptService_WriteStartDfxMsg_001, TestSize.Level1)
+HWTEST_F(AudioInterruptUnitTest, AudioInterruptService_WriteStartDfxMsg_001, TestSize.Level1)
 {
     auto server = GetPolicyServerTest();
     auto interruptServiceTest = GetTnterruptServiceTest();
@@ -3254,7 +3143,7 @@ HWTEST(AudioInterruptUnitTest, AudioInterruptService_WriteStartDfxMsg_001, TestS
 * @tc.number: AudioInterruptService_WriteSessionTimeoutDfxEvent_001
 * @tc.desc  : Test WriteSessionTimeoutDfxEvent
 */
-HWTEST(AudioInterruptUnitTest, AudioInterruptService_WriteSessionTimeoutDfxEvent_001, TestSize.Level1)
+HWTEST_F(AudioInterruptUnitTest, AudioInterruptService_WriteSessionTimeoutDfxEvent_001, TestSize.Level1)
 {
     auto server = GetPolicyServerTest();
     auto interruptServiceTest = GetTnterruptServiceTest();
@@ -3280,7 +3169,7 @@ HWTEST(AudioInterruptUnitTest, AudioInterruptService_WriteSessionTimeoutDfxEvent
 * @tc.number: AudioInterruptService_WriteStopDfxMsg_001
 * @tc.desc  : Test WriteStopDfxMsg
 */
-HWTEST(AudioInterruptUnitTest, AudioInterruptService_WriteStopDfxMsg_001, TestSize.Level1)
+HWTEST_F(AudioInterruptUnitTest, AudioInterruptService_WriteStopDfxMsg_001, TestSize.Level1)
 {
     auto server = GetPolicyServerTest();
     auto interruptServiceTest = GetTnterruptServiceTest();
@@ -3307,19 +3196,14 @@ HWTEST(AudioInterruptUnitTest, AudioInterruptService_WriteStopDfxMsg_001, TestSi
 * @tc.number: AudioInterruptService_AudioSessionInfoDump_001
 * @tc.desc  : Test AudioSessionInfoDump
 */
-HWTEST(AudioInterruptUnitTest, AudioInterruptService_AudioSessionInfoDump_001, TestSize.Level1)
+HWTEST_F(AudioInterruptUnitTest, AudioInterruptService_AudioSessionInfoDump_001, TestSize.Level1)
 {
     auto server = GetPolicyServerTest();
     auto interruptServiceTest = GetTnterruptServiceTest();
     interruptServiceTest->zonesMap_.clear();
     std::string dumpString = "test dump string";
-
-    interruptServiceTest->AudioSessionInfoDump(dumpString);
-    EXPECT_EQ(interruptServiceTest->sessionService_, nullptr);
-
     interruptServiceTest->Init(server);
-    interruptServiceTest->AudioSessionInfoDump(dumpString);
-    EXPECT_NE(interruptServiceTest->sessionService_, nullptr);
+    interruptServiceTest->sessionService_.AudioSessionInfoDump(dumpString);
 }
 
 /**
@@ -3327,7 +3211,7 @@ HWTEST(AudioInterruptUnitTest, AudioInterruptService_AudioSessionInfoDump_001, T
 * @tc.number: AudioInterruptService_101
 * @tc.desc  : Test AudioInterruptService
 */
-HWTEST(AudioInterruptUnitTest, AudioInterruptService_101, TestSize.Level1)
+HWTEST_F(AudioInterruptUnitTest, AudioInterruptService_101, TestSize.Level1)
 {
     auto audioInterruptService = std::make_shared<AudioInterruptService>();
     EXPECT_NE(audioInterruptService, nullptr);
@@ -3346,7 +3230,7 @@ HWTEST(AudioInterruptUnitTest, AudioInterruptService_101, TestSize.Level1)
 * @tc.number: AudioInterruptService_102
 * @tc.desc  : Test AudioInterruptService
 */
-HWTEST(AudioInterruptUnitTest, AudioInterruptService_102, TestSize.Level1)
+HWTEST_F(AudioInterruptUnitTest, AudioInterruptService_102, TestSize.Level1)
 {
     auto audioInterruptService = std::make_shared<AudioInterruptService>();
     EXPECT_NE(audioInterruptService, nullptr);
@@ -3365,7 +3249,7 @@ HWTEST(AudioInterruptUnitTest, AudioInterruptService_102, TestSize.Level1)
 * @tc.number: AudioInterruptService_103
 * @tc.desc  : Test AudioInterruptService
 */
-HWTEST(AudioInterruptUnitTest, AudioInterruptService_103, TestSize.Level1)
+HWTEST_F(AudioInterruptUnitTest, AudioInterruptService_103, TestSize.Level1)
 {
     auto audioInterruptService = std::make_shared<AudioInterruptService>();
     EXPECT_NE(audioInterruptService, nullptr);
@@ -3384,7 +3268,7 @@ HWTEST(AudioInterruptUnitTest, AudioInterruptService_103, TestSize.Level1)
 * @tc.number: AudioInterruptService_104
 * @tc.desc  : Test AudioInterruptService
 */
-HWTEST(AudioInterruptUnitTest, AudioInterruptService_104, TestSize.Level1)
+HWTEST_F(AudioInterruptUnitTest, AudioInterruptService_104, TestSize.Level1)
 {
     auto audioInterruptService = std::make_shared<AudioInterruptService>();
     EXPECT_NE(audioInterruptService, nullptr);
@@ -3405,7 +3289,7 @@ HWTEST(AudioInterruptUnitTest, AudioInterruptService_104, TestSize.Level1)
 * @tc.number: AudioInterruptService_105
 * @tc.desc  : Test AudioInterruptService
 */
-HWTEST(AudioInterruptUnitTest, AudioInterruptService_105, TestSize.Level1)
+HWTEST_F(AudioInterruptUnitTest, AudioInterruptService_105, TestSize.Level1)
 {
     auto audioInterruptService = std::make_shared<AudioInterruptService>();
     EXPECT_NE(audioInterruptService, nullptr);
@@ -3426,7 +3310,7 @@ HWTEST(AudioInterruptUnitTest, AudioInterruptService_105, TestSize.Level1)
 * @tc.number: AudioInterruptService_106
 * @tc.desc  : Test AudioInterruptService
 */
-HWTEST(AudioInterruptUnitTest, AudioInterruptService_106, TestSize.Level1)
+HWTEST_F(AudioInterruptUnitTest, AudioInterruptService_106, TestSize.Level1)
 {
     auto audioInterruptService = std::make_shared<AudioInterruptService>();
     EXPECT_NE(audioInterruptService, nullptr);
@@ -3447,7 +3331,7 @@ HWTEST(AudioInterruptUnitTest, AudioInterruptService_106, TestSize.Level1)
 * @tc.number: AudioInterruptService_107
 * @tc.desc  : Test AudioInterruptService
 */
-HWTEST(AudioInterruptUnitTest, AudioInterruptService_107, TestSize.Level1)
+HWTEST_F(AudioInterruptUnitTest, AudioInterruptService_107, TestSize.Level1)
 {
     auto audioInterruptService = std::make_shared<AudioInterruptService>();
     EXPECT_NE(audioInterruptService, nullptr);
@@ -3468,7 +3352,7 @@ HWTEST(AudioInterruptUnitTest, AudioInterruptService_107, TestSize.Level1)
 * @tc.number: AudioInterruptService_108
 * @tc.desc  : Test AudioInterruptService
 */
-HWTEST(AudioInterruptUnitTest, AudioInterruptService_108, TestSize.Level1)
+HWTEST_F(AudioInterruptUnitTest, AudioInterruptService_108, TestSize.Level1)
 {
     auto audioInterruptService = std::make_shared<AudioInterruptService>();
     EXPECT_NE(audioInterruptService, nullptr);
@@ -3490,7 +3374,7 @@ HWTEST(AudioInterruptUnitTest, AudioInterruptService_108, TestSize.Level1)
 * @tc.number: AudioInterruptService_109
 * @tc.desc  : Test AudioInterruptService
 */
-HWTEST(AudioInterruptUnitTest, AudioInterruptService_109, TestSize.Level1)
+HWTEST_F(AudioInterruptUnitTest, AudioInterruptService_109, TestSize.Level1)
 {
     auto audioInterruptService = std::make_shared<AudioInterruptService>();
     EXPECT_NE(audioInterruptService, nullptr);
@@ -3515,7 +3399,7 @@ HWTEST(AudioInterruptUnitTest, AudioInterruptService_109, TestSize.Level1)
 * @tc.number: AudioInterruptService_110
 * @tc.desc  : Test AudioInterruptService
 */
-HWTEST(AudioInterruptUnitTest, AudioInterruptService_110, TestSize.Level1)
+HWTEST_F(AudioInterruptUnitTest, AudioInterruptService_110, TestSize.Level1)
 {
     auto audioInterruptService = std::make_shared<AudioInterruptService>();
     EXPECT_NE(audioInterruptService, nullptr);
@@ -3540,7 +3424,7 @@ HWTEST(AudioInterruptUnitTest, AudioInterruptService_110, TestSize.Level1)
 * @tc.number: AudioInterruptService_111
 * @tc.desc  : Test AudioInterruptService
 */
-HWTEST(AudioInterruptUnitTest, AudioInterruptService_111, TestSize.Level1)
+HWTEST_F(AudioInterruptUnitTest, AudioInterruptService_111, TestSize.Level1)
 {
     auto audioInterruptService = std::make_shared<AudioInterruptService>();
     EXPECT_NE(audioInterruptService, nullptr);
@@ -3564,7 +3448,7 @@ HWTEST(AudioInterruptUnitTest, AudioInterruptService_111, TestSize.Level1)
 * @tc.number: AudioInterruptService_112
 * @tc.desc  : Test AudioInterruptService
 */
-HWTEST(AudioInterruptUnitTest, AudioInterruptService_112, TestSize.Level1)
+HWTEST_F(AudioInterruptUnitTest, AudioInterruptService_112, TestSize.Level1)
 {
     auto audioInterruptService = std::make_shared<AudioInterruptService>();
     EXPECT_NE(audioInterruptService, nullptr);
@@ -3584,7 +3468,7 @@ HWTEST(AudioInterruptUnitTest, AudioInterruptService_112, TestSize.Level1)
 * @tc.number: AudioInterruptService_113
 * @tc.desc  : Test AudioInterruptService
 */
-HWTEST(AudioInterruptUnitTest, AudioInterruptService_113, TestSize.Level1)
+HWTEST_F(AudioInterruptUnitTest, AudioInterruptService_113, TestSize.Level1)
 {
     auto audioInterruptService = std::make_shared<AudioInterruptService>();
     EXPECT_NE(audioInterruptService, nullptr);
@@ -3604,7 +3488,7 @@ HWTEST(AudioInterruptUnitTest, AudioInterruptService_113, TestSize.Level1)
 * @tc.number: AudioInterruptService_114
 * @tc.desc  : Test AudioInterruptService
 */
-HWTEST(AudioInterruptUnitTest, AudioInterruptService_114, TestSize.Level1)
+HWTEST_F(AudioInterruptUnitTest, AudioInterruptService_114, TestSize.Level1)
 {
     auto audioInterruptService = std::make_shared<AudioInterruptService>();
     EXPECT_NE(audioInterruptService, nullptr);
@@ -3624,7 +3508,7 @@ HWTEST(AudioInterruptUnitTest, AudioInterruptService_114, TestSize.Level1)
 * @tc.number: AudioInterruptService_115
 * @tc.desc  : Test AudioInterruptService
 */
-HWTEST(AudioInterruptUnitTest, AudioInterruptService_115, TestSize.Level1)
+HWTEST_F(AudioInterruptUnitTest, AudioInterruptService_115, TestSize.Level1)
 {
     auto audioInterruptService = std::make_shared<AudioInterruptService>();
     EXPECT_NE(audioInterruptService, nullptr);
@@ -3646,7 +3530,7 @@ HWTEST(AudioInterruptUnitTest, AudioInterruptService_115, TestSize.Level1)
 * @tc.number: AudioInterruptService_116
 * @tc.desc  : Test AudioInterruptService
 */
-HWTEST(AudioInterruptUnitTest, AudioInterruptService_116, TestSize.Level1)
+HWTEST_F(AudioInterruptUnitTest, AudioInterruptService_116, TestSize.Level1)
 {
     auto audioInterruptService = std::make_shared<AudioInterruptService>();
     EXPECT_NE(audioInterruptService, nullptr);
@@ -3667,7 +3551,7 @@ HWTEST(AudioInterruptUnitTest, AudioInterruptService_116, TestSize.Level1)
 * @tc.number: AudioInterruptService_117
 * @tc.desc  : Test AudioInterruptService
 */
-HWTEST(AudioInterruptUnitTest, AudioInterruptService_117, TestSize.Level1)
+HWTEST_F(AudioInterruptUnitTest, AudioInterruptService_117, TestSize.Level1)
 {
     auto audioInterruptService = std::make_shared<AudioInterruptService>();
     EXPECT_NE(audioInterruptService, nullptr);
@@ -3691,7 +3575,7 @@ HWTEST(AudioInterruptUnitTest, AudioInterruptService_117, TestSize.Level1)
 * @tc.number: AudioInterruptService_118
 * @tc.desc  : Test AudioInterruptService
 */
-HWTEST(AudioInterruptUnitTest, AudioInterruptService_118, TestSize.Level1)
+HWTEST_F(AudioInterruptUnitTest, AudioInterruptService_118, TestSize.Level1)
 {
     auto audioInterruptService = std::make_shared<AudioInterruptService>();
     EXPECT_NE(audioInterruptService, nullptr);
@@ -3715,7 +3599,7 @@ HWTEST(AudioInterruptUnitTest, AudioInterruptService_118, TestSize.Level1)
  * @tc.number: AudioInterruptService_119
  * @tc.desc  : Test AudioInterruptService
  */
-HWTEST(AudioInterruptUnitTest, AudioInterruptService_119, TestSize.Level1)
+HWTEST_F(AudioInterruptUnitTest, AudioInterruptService_119, TestSize.Level1)
 {
     auto interruptServiceTest = GetTnterruptServiceTest();
     ASSERT_NE(interruptServiceTest, nullptr);
@@ -3755,7 +3639,7 @@ HWTEST(AudioInterruptUnitTest, AudioInterruptService_119, TestSize.Level1)
 * @tc.number: AudioInterruptService_120
 * @tc.desc  : Test GetAudioInterruptBundleName_01
 */
-HWTEST(AudioInterruptUnitTest, AudioInterruptService_120, TestSize.Level1)
+HWTEST_F(AudioInterruptUnitTest, AudioInterruptService_120, TestSize.Level1)
 {
     auto audioInterruptService = std::make_shared<AudioInterruptService>();
     ASSERT_NE(audioInterruptService, nullptr);
@@ -3772,7 +3656,7 @@ HWTEST(AudioInterruptUnitTest, AudioInterruptService_120, TestSize.Level1)
 * @tc.number: AudioInterruptService_121
 * @tc.desc  : Test GetAudioInterruptBundleName_02
 */
-HWTEST(AudioInterruptUnitTest, AudioInterruptService_121, TestSize.Level1)
+HWTEST_F(AudioInterruptUnitTest, AudioInterruptService_121, TestSize.Level1)
 {
     auto audioInterruptService = std::make_shared<AudioInterruptService>();
     ASSERT_NE(audioInterruptService, nullptr);
@@ -3789,7 +3673,7 @@ HWTEST(AudioInterruptUnitTest, AudioInterruptService_121, TestSize.Level1)
 * @tc.number: RegisterDefaultVolumeTypeListenerTest
 * @tc.desc  : Test RegisterDefaultVolumeTypeListener
 */
-HWTEST(AudioInterruptUnitTest, RegisterDefaultVolumeTypeListenerTest, TestSize.Level1)
+HWTEST_F(AudioInterruptUnitTest, RegisterDefaultVolumeTypeListenerTest, TestSize.Level1)
 {
     AudioSettingProvider &settingProvider = AudioSettingProvider::GetInstance(AUDIO_POLICY_SERVICE_ID);
     bool isDataShareReady = settingProvider.isDataShareReady_.load();
@@ -3807,7 +3691,7 @@ HWTEST(AudioInterruptUnitTest, RegisterDefaultVolumeTypeListenerTest, TestSize.L
  * @tc.number: AudioSessionFocusMode_001
  * @tc.desc  : Test AudioSessionFocusMode
  */
-HWTEST(AudioInterruptUnitTest, AudioSessionFocusMode_001, TestSize.Level1)
+HWTEST_F(AudioInterruptUnitTest, AudioSessionFocusMode_001, TestSize.Level1)
 {
     int32_t CALLER_PID = IPCSkeleton::GetCallingPid();
     auto audioInterruptService = std::make_shared<AudioInterruptService>();
@@ -3824,9 +3708,6 @@ HWTEST(AudioInterruptUnitTest, AudioSessionFocusMode_001, TestSize.Level1)
     int32_t ret = audioInterruptService->ActivateAudioInterrupt(DEFAULT_ZONE_ID, movieInterrupt, false);
     EXPECT_EQ(SUCCESS, ret);
 
-    std::shared_ptr<AudioSessionService> sessionService = std::make_shared<AudioSessionService>();
-    ASSERT_NE(nullptr, sessionService);
-    audioInterruptService->sessionService_ = sessionService;
     ret = audioInterruptService->SetAudioSessionScene(CALLER_PID, AudioSessionScene::MEDIA);
     EXPECT_EQ(SUCCESS, ret);
     AudioSessionStrategy audioSessionStrategy;
@@ -3847,7 +3728,7 @@ HWTEST(AudioInterruptUnitTest, AudioSessionFocusMode_001, TestSize.Level1)
  * @tc.number: AudioSessionFocusMode_002
  * @tc.desc  : Test ActivateAudioSession interrupt other focus
  */
-HWTEST(AudioInterruptUnitTest, AudioSessionFocusMode_002, TestSize.Level1)
+HWTEST_F(AudioInterruptUnitTest, AudioSessionFocusMode_002, TestSize.Level1)
 {
     int32_t CALLER_PID = IPCSkeleton::GetCallingPid();
     auto audioInterruptService = std::make_shared<AudioInterruptService>();
@@ -3863,10 +3744,7 @@ HWTEST(AudioInterruptUnitTest, AudioSessionFocusMode_002, TestSize.Level1)
     audioInterruptZone->audioFocusInfoList.emplace_back(movieInterrupt, AudioFocuState{ACTIVE});
     audioInterruptService->zonesMap_[DEFAULT_ZONE_ID] = audioInterruptZone;
 
-    std::shared_ptr<AudioSessionService> sessionService = std::make_shared<AudioSessionService>();
-    ASSERT_NE(nullptr, sessionService);
-    audioInterruptService->sessionService_ = sessionService;
-    int32_t ret = sessionService->SetAudioSessionScene(CALLER_PID, AudioSessionScene::MEDIA);
+    int32_t ret = audioInterruptService->sessionService_.SetAudioSessionScene(CALLER_PID, AudioSessionScene::MEDIA);
     EXPECT_EQ(SUCCESS, ret);
     AudioSessionStrategy audioSessionStrategy;
     audioSessionStrategy.concurrencyMode = AudioConcurrencyMode::DEFAULT;
@@ -3885,20 +3763,13 @@ HWTEST(AudioInterruptUnitTest, AudioSessionFocusMode_002, TestSize.Level1)
  * @tc.number: AudioSessionFocusMode_003
  * @tc.desc  : Test AudioSessionAbnormalCase
  */
-HWTEST(AudioInterruptUnitTest, AudioSessionFocusMode_003, TestSize.Level1)
+HWTEST_F(AudioInterruptUnitTest, AudioSessionFocusMode_003, TestSize.Level1)
 {
     int32_t CALLER_PID = IPCSkeleton::GetCallingPid();
     auto audioInterruptService = std::make_shared<AudioInterruptService>();
     ASSERT_NE(audioInterruptService, nullptr);
     audioInterruptService->Init(GetPolicyServerTest());
 
-    audioInterruptService->sessionService_ = nullptr;
-    int32_t ret = audioInterruptService->SetAudioSessionScene(CALLER_PID, AudioSessionScene::MEDIA);
-    EXPECT_EQ(ERR_UNKNOWN, ret);
-    bool updateScene = false;
-    ret = audioInterruptService->ProcessFocusEntryForAudioSession(DEFAULT_ZONE_ID, CALLER_PID, updateScene);
-    EXPECT_EQ(ERR_UNKNOWN, ret);
-
     AudioInterrupt movieInterrupt;
     movieInterrupt.audioFocusType.streamType = STREAM_MUSIC;
     movieInterrupt.audioFocusType.isPlay = true;
@@ -3924,7 +3795,7 @@ HWTEST(AudioInterruptUnitTest, AudioSessionFocusMode_003, TestSize.Level1)
  * @tc.number: AudioSessionFocusMode_004
  * @tc.desc  : Test ShouldBypassAudioSessionFocus
  */
-HWTEST(AudioInterruptUnitTest, AudioSessionFocusMode_004, TestSize.Level1)
+HWTEST_F(AudioInterruptUnitTest, AudioSessionFocusMode_004, TestSize.Level1)
 {
     int32_t CALLER_PID = IPCSkeleton::GetCallingPid();
     auto audioInterruptService = std::make_shared<AudioInterruptService>();
@@ -3932,9 +3803,6 @@ HWTEST(AudioInterruptUnitTest, AudioSessionFocusMode_004, TestSize.Level1)
     audioInterruptService->Init(GetPolicyServerTest());
     audioInterruptService->SetCallbackHandler(GetServerHandlerTest());
 
-    std::shared_ptr<AudioSessionService> sessionService = std::make_shared<AudioSessionService>();
-    ASSERT_NE(nullptr, sessionService);
-    audioInterruptService->sessionService_ = sessionService;
     int32_t ret = audioInterruptService->SetAudioSessionScene(CALLER_PID, AudioSessionScene::MEDIA);
     EXPECT_EQ(SUCCESS, ret);
 
@@ -3961,11 +3829,6 @@ HWTEST(AudioInterruptUnitTest, AudioSessionFocusMode_004, TestSize.Level1)
     result = audioInterruptService->ShouldBypassAudioSessionFocus(zoneId, movieInterrupt);
     EXPECT_FALSE(result);
 
-    audioInterruptService->sessionService_ = nullptr;
-    result = audioInterruptService->ShouldBypassAudioSessionFocus(zoneId, movieInterrupt);
-    EXPECT_FALSE(result);
-
-    audioInterruptService->sessionService_ = sessionService;
     AudioSessionStrategy audioSessionStrategy;
     audioSessionStrategy.concurrencyMode = AudioConcurrencyMode::DEFAULT;
     ret = audioInterruptService->ActivateAudioSession(DEFAULT_ZONE_ID, CALLER_PID, audioSessionStrategy);
@@ -3981,7 +3844,7 @@ HWTEST(AudioInterruptUnitTest, AudioSessionFocusMode_004, TestSize.Level1)
  * @tc.number: AudioSessionFocusMode_005
  * @tc.desc  : Test AudioSessionTimeOut
  */
-HWTEST(AudioInterruptUnitTest, AudioSessionFocusMode_005, TestSize.Level1)
+HWTEST_F(AudioInterruptUnitTest, AudioSessionFocusMode_005, TestSize.Level1)
 {
     int32_t CALLER_PID = IPCSkeleton::GetCallingPid();
     auto audioInterruptService = std::make_shared<AudioInterruptService>();
@@ -3989,9 +3852,6 @@ HWTEST(AudioInterruptUnitTest, AudioSessionFocusMode_005, TestSize.Level1)
     audioInterruptService->Init(GetPolicyServerTest());
     audioInterruptService->SetCallbackHandler(GetServerHandlerTest());
 
-    std::shared_ptr<AudioSessionService> sessionService = std::make_shared<AudioSessionService>();
-    ASSERT_NE(nullptr, sessionService);
-    audioInterruptService->sessionService_ = sessionService;
     int32_t ret = audioInterruptService->SetAudioSessionScene(CALLER_PID, AudioSessionScene::MEDIA);
     EXPECT_EQ(SUCCESS, ret);
 
@@ -4003,7 +3863,7 @@ HWTEST(AudioInterruptUnitTest, AudioSessionFocusMode_005, TestSize.Level1)
     bool result = audioInterruptService->IsAudioSessionActivated(CALLER_PID);
     EXPECT_TRUE(result);
 
-    ret = sessionService->DeactivateAudioSession(CALLER_PID);
+    ret = audioInterruptService->sessionService_.DeactivateAudioSession(CALLER_PID);
     EXPECT_EQ(SUCCESS, ret);
 
     audioInterruptService->HandleSessionTimeOutEvent(CALLER_PID);
@@ -4016,7 +3876,7 @@ HWTEST(AudioInterruptUnitTest, AudioSessionFocusMode_005, TestSize.Level1)
  * @tc.number: AudioSessionFocusMode_006
  * @tc.desc  : Test AudioSessionCallbackEvent
  */
-HWTEST(AudioInterruptUnitTest, AudioSessionFocusMode_006, TestSize.Level1)
+HWTEST_F(AudioInterruptUnitTest, AudioSessionFocusMode_006, TestSize.Level1)
 {
     int32_t CALLER_PID = IPCSkeleton::GetCallingPid();
     AudioInterrupt movieInterrupt;
@@ -4042,9 +3902,6 @@ HWTEST(AudioInterruptUnitTest, AudioSessionFocusMode_006, TestSize.Level1)
     audioInterruptService->SendAudioSessionInterruptEventCallback(duckInterruptEvent, movieInterrupt);
     audioInterruptService->SendAudioSessionInterruptEventCallback(stopInterruptEvent, movieInterrupt);
 
-    std::shared_ptr<AudioSessionService> sessionService = std::make_shared<AudioSessionService>();
-    ASSERT_NE(nullptr, sessionService);
-    audioInterruptService->sessionService_ = sessionService;
     int32_t ret = audioInterruptService->SetAudioSessionScene(CALLER_PID, AudioSessionScene::MEDIA);
     EXPECT_EQ(SUCCESS, ret);
 
@@ -4063,9 +3920,9 @@ HWTEST(AudioInterruptUnitTest, AudioSessionFocusMode_006, TestSize.Level1)
 
     AudioSessionStrategy audioSessionStrategy;
     audioSessionStrategy.concurrencyMode = AudioConcurrencyMode::DEFAULT;
-    ret = sessionService->ActivateAudioSession(CALLER_PID, audioSessionStrategy);
+    ret = audioInterruptService->sessionService_.ActivateAudioSession(CALLER_PID, audioSessionStrategy);
     EXPECT_EQ(SUCCESS, ret);
-    ret = sessionService->DeactivateAudioSession(CALLER_PID);
+    ret = audioInterruptService->sessionService_.DeactivateAudioSession(CALLER_PID);
     EXPECT_EQ(SUCCESS, ret);
 }
 
@@ -4074,16 +3931,13 @@ HWTEST(AudioInterruptUnitTest, AudioSessionFocusMode_006, TestSize.Level1)
  * @tc.number: AudioSessionFocusMode_007
  * @tc.desc  : Test ProcessFocusEntryForAudioSession
  */
-HWTEST(AudioInterruptUnitTest, AudioSessionFocusMode_007, TestSize.Level1)
+HWTEST_F(AudioInterruptUnitTest, AudioSessionFocusMode_007, TestSize.Level1)
 {
     int32_t CALLER_PID = IPCSkeleton::GetCallingPid();
     auto audioInterruptService = std::make_shared<AudioInterruptService>();
     ASSERT_NE(audioInterruptService, nullptr);
     audioInterruptService->Init(GetPolicyServerTest());
 
-    std::shared_ptr<AudioSessionService> sessionService = std::make_shared<AudioSessionService>();
-    ASSERT_NE(nullptr, sessionService);
-    audioInterruptService->sessionService_ = sessionService;
     int32_t ret = audioInterruptService->SetAudioSessionScene(CALLER_PID, AudioSessionScene::MEDIA);
     EXPECT_EQ(SUCCESS, ret);
     bool updateScene = false;
@@ -4113,7 +3967,7 @@ HWTEST(AudioInterruptUnitTest, AudioSessionFocusMode_007, TestSize.Level1)
  * @tc.number: AudioSessionFocusMode_008
  * @tc.desc  : Test GetHighestPriorityAudioScene
  */
-HWTEST(AudioInterruptUnitTest, AudioSessionFocusMode_008, TestSize.Level1)
+HWTEST_F(AudioInterruptUnitTest, AudioSessionFocusMode_008, TestSize.Level1)
 {
     int32_t CALLER_PID = IPCSkeleton::GetCallingPid();
     auto audioInterruptService = std::make_shared<AudioInterruptService>();
@@ -4131,41 +3985,38 @@ HWTEST(AudioInterruptUnitTest, AudioSessionFocusMode_008, TestSize.Level1)
     audioInterruptService->zonesMap_[DEFAULT_ZONE_ID] = audioInterruptZone;
 
     AudioScene audioScene = audioInterruptService->GetHighestPriorityAudioScene(DEFAULT_ZONE_ID);
-    EXPECT_EQ(AUDIO_SCENE_DEFAULT, audioScene);
+    EXPECT_EQ(AUDIO_SCENE_PHONE_CHAT, audioScene);
 
     audioScene = audioInterruptService->RefreshAudioSceneFromAudioInterrupt(fakeAudioInterrupt, audioScene);
-    EXPECT_EQ(AUDIO_SCENE_DEFAULT, audioScene);
+    EXPECT_EQ(AUDIO_SCENE_PHONE_CHAT, audioScene);
 
     audioScene = audioInterruptService->GetHighestPriorityAudioSceneFromAudioSession(fakeAudioInterrupt, audioScene);
-    EXPECT_EQ(AUDIO_SCENE_DEFAULT, audioScene);
+    EXPECT_EQ(AUDIO_SCENE_PHONE_CHAT, audioScene);
 
-    std::shared_ptr<AudioSessionService> sessionService = std::make_shared<AudioSessionService>();
-    ASSERT_NE(nullptr, sessionService);
-    audioInterruptService->sessionService_ = sessionService;
     AudioSessionStrategy audioSessionStrategy;
     audioSessionStrategy.concurrencyMode = AudioConcurrencyMode::DEFAULT;
-    int32_t ret = sessionService->ActivateAudioSession(CALLER_PID, audioSessionStrategy);
+    int32_t ret = audioInterruptService->sessionService_.ActivateAudioSession(CALLER_PID, audioSessionStrategy);
     EXPECT_EQ(SUCCESS, ret);
-    ASSERT_NE(nullptr, sessionService->sessionMap_[CALLER_PID]);
+    ASSERT_NE(nullptr, audioInterruptService->sessionService_.sessionMap_[CALLER_PID]);
     AudioInterrupt audioInterrupt = {};
     audioInterrupt.pid = CALLER_PID;
     audioInterrupt.streamId = SESSION_ID_TEST + 1;
     audioInterrupt.audioFocusType.streamType = STREAM_MUSIC;
     audioInterrupt.audioFocusType.isPlay = true;
     audioInterrupt.callbackType = INTERRUPT_EVENT_CALLBACK_DEFAULT;
-    sessionService->sessionMap_[CALLER_PID]->AddStreamInfo(audioInterrupt);
+    audioInterruptService->sessionService_.sessionMap_[CALLER_PID]->AddStreamInfo(audioInterrupt);
 
     audioScene = audioInterruptService->GetHighestPriorityAudioSceneFromAudioSession(fakeAudioInterrupt, audioScene);
     EXPECT_EQ(AUDIO_SCENE_PHONE_CHAT, audioScene);
 
     audioInterrupt.streamId++;
     audioInterrupt.audioFocusType.streamType = STREAM_RING;
-    sessionService->sessionMap_[CALLER_PID]->AddStreamInfo(audioInterrupt);
+    audioInterruptService->sessionService_.sessionMap_[CALLER_PID]->AddStreamInfo(audioInterrupt);
     audioScene = AUDIO_SCENE_DEFAULT;
     audioScene = audioInterruptService->GetHighestPriorityAudioSceneFromAudioSession(fakeAudioInterrupt, audioScene);
     EXPECT_EQ(AUDIO_SCENE_RINGING, audioScene);
 
-    ret = sessionService->DeactivateAudioSession(CALLER_PID);
+    ret = audioInterruptService->sessionService_.DeactivateAudioSession(CALLER_PID);
     EXPECT_EQ(SUCCESS, ret);
 }
 
@@ -4174,7 +4025,7 @@ HWTEST(AudioInterruptUnitTest, AudioSessionFocusMode_008, TestSize.Level1)
  * @tc.number: AudioSessionFocusMode_009
  * @tc.desc  : Test DeactivatAudioSession v2
  */
-HWTEST(AudioInterruptUnitTest, AudioSessionFocusMode_009, TestSize.Level2)
+HWTEST_F(AudioInterruptUnitTest, AudioSessionFocusMode_009, TestSize.Level2)
 {
     int32_t CALLER_PID = IPCSkeleton::GetCallingPid();
     auto audioInterruptService = std::make_shared<AudioInterruptService>();
@@ -4193,10 +4044,7 @@ HWTEST(AudioInterruptUnitTest, AudioSessionFocusMode_009, TestSize.Level2)
     audioInterruptZone->audioFocusInfoList.emplace_back(fakeAudioInterrupt, AudioFocuState{ACTIVE});
     audioInterruptService->zonesMap_[DEFAULT_ZONE_ID] = audioInterruptZone;
 
-    std::shared_ptr<AudioSessionService> sessionService = std::make_shared<AudioSessionService>();
-    ASSERT_NE(nullptr, sessionService);
-    audioInterruptService->sessionService_ = sessionService;
-    int32_t ret = sessionService->SetAudioSessionScene(CALLER_PID, AudioSessionScene::MEDIA);
+    int32_t ret = audioInterruptService->sessionService_.SetAudioSessionScene(CALLER_PID, AudioSessionScene::MEDIA);
     EXPECT_EQ(SUCCESS, ret);
     AudioSessionStrategy audioSessionStrategy;
     audioSessionStrategy.concurrencyMode = AudioConcurrencyMode::DEFAULT;
@@ -4214,20 +4062,19 @@ HWTEST(AudioInterruptUnitTest, AudioSessionFocusMode_009, TestSize.Level2)
     ret = audioInterruptService->DeactivateAudioSession(DEFAULT_ZONE_ID, CALLER_PID);
     EXPECT_EQ(SUCCESS, ret);
 
-    ret = sessionService->SetAudioSessionScene(CALLER_PID, AudioSessionScene::MEDIA);
-    EXPECT_EQ(SUCCESS, ret);
-    ret = audioInterruptService->ActivateAudioSession(DEFAULT_ZONE_ID, CALLER_PID, audioSessionStrategy);
-    EXPECT_EQ(SUCCESS, ret);
+    AudioSessionStrategy strategy;
+    strategy.concurrencyMode = AudioConcurrencyMode::DEFAULT;
+    audioInterruptService->sessionService_.sessionMap_[CALLER_PID] =
+        std::make_shared<AudioSession>(CALLER_PID, strategy, audioSessionStateMonitor_);
 
-    ASSERT_NE(nullptr, sessionService->sessionMap_[CALLER_PID]);
+    ASSERT_NE(nullptr, audioInterruptService->sessionService_.sessionMap_[CALLER_PID]);
     AudioInterrupt audioInterrupt = {};
     audioInterrupt.pid = CALLER_PID;
     audioInterrupt.streamId = SESSION_ID_TEST + 1;
     audioInterrupt.audioFocusType.streamType = STREAM_MUSIC;
     audioInterrupt.audioFocusType.isPlay = true;
     audioInterrupt.callbackType = INTERRUPT_EVENT_CALLBACK_DEFAULT;
-    sessionService->sessionMap_[CALLER_PID]->AddStreamInfo(audioInterrupt);
-    audioInterruptService->sessionService_ = sessionService;
+    audioInterruptService->sessionService_.sessionMap_[CALLER_PID]->AddStreamInfo(audioInterrupt);
 
     ret = audioInterruptService->DeactivateAudioSession(DEFAULT_ZONE_ID, CALLER_PID);
     EXPECT_EQ(SUCCESS, ret);
@@ -4239,12 +4086,11 @@ HWTEST(AudioInterruptUnitTest, AudioSessionFocusMode_009, TestSize.Level2)
  * @tc.number: AudioSessionFocusMode_010
  * @tc.desc  : Test DelayToDeactivateStreamsInAudioSession
  */
-HWTEST(AudioInterruptUnitTest, AudioSessionFocusMode_010, TestSize.Level2)
+HWTEST_F(AudioInterruptUnitTest, AudioSessionFocusMode_010, TestSize.Level2)
 {
     int32_t CALLER_PID = IPCSkeleton::GetCallingPid();
     auto audioInterruptService = std::make_shared<AudioInterruptService>();
     ASSERT_NE(audioInterruptService, nullptr);
-    audioInterruptService->sessionService_ = nullptr;
     const std::vector<AudioInterrupt> streamsInSession;
     audioInterruptService->DelayToDeactivateStreamsInAudioSession(DEFAULT_ZONE_ID, CALLER_PID, streamsInSession);
 
@@ -4252,32 +4098,31 @@ HWTEST(AudioInterruptUnitTest, AudioSessionFocusMode_010, TestSize.Level2)
     audioInterruptServiceWithSession->SetCallbackHandler(GetServerHandlerTest());
     AudioSessionStrategy strategy;
     strategy.concurrencyMode = AudioConcurrencyMode::DEFAULT;
-    auto sessionService = std::make_shared<AudioSessionService>();
-    sessionService->sessionMap_[CALLER_PID] = std::make_shared<AudioSession>(CALLER_PID, strategy, sessionService);
+    audioInterruptServiceWithSession->sessionService_.sessionMap_[CALLER_PID] =
+        std::make_shared<AudioSession>(CALLER_PID, strategy, audioSessionStateMonitor_);
     AudioInterrupt audioInterrupt;
     audioInterrupt.pid = CALLER_PID;
     audioInterrupt.streamId = SESSION_ID_TEST + 1;
     audioInterrupt.audioFocusType.streamType = STREAM_MUSIC;
     audioInterrupt.audioFocusType.isPlay = true;
     audioInterrupt.callbackType = INTERRUPT_EVENT_CALLBACK_DEFAULT;
-    sessionService->sessionMap_[CALLER_PID]->AddStreamInfo(audioInterrupt);
+    audioInterruptServiceWithSession->sessionService_.sessionMap_[CALLER_PID]->AddStreamInfo(audioInterrupt);
 
-    audioInterruptServiceWithSession->sessionService_ = sessionService;
-    sessionService->sessionMap_[CALLER_PID]->state_ = AudioSessionState::SESSION_ACTIVE;
+    audioInterruptServiceWithSession->sessionService_.sessionMap_[CALLER_PID]->state_ =
+        AudioSessionState::SESSION_ACTIVE;
     audioInterruptServiceWithSession->DelayToDeactivateStreamsInAudioSession(
-        DEFAULT_ZONE_ID, CALLER_PID, sessionService->GetStreams(CALLER_PID));
+        DEFAULT_ZONE_ID, CALLER_PID, audioInterruptServiceWithSession->sessionService_.GetStreams(CALLER_PID));
 
     auto audioInterruptServiceWithoutHandler = std::make_shared<AudioInterruptService>();
     audioInterruptServiceWithoutHandler->SetCallbackHandler(nullptr);
-    auto sessionServiceWithoutHandler = std::make_shared<AudioSessionService>();
-    sessionServiceWithoutHandler->sessionMap_[CALLER_PID] =
-        std::make_shared<AudioSession>(CALLER_PID, strategy, sessionServiceWithoutHandler);
-    sessionServiceWithoutHandler->sessionMap_[CALLER_PID]->AddStreamInfo(audioInterrupt);
+    audioInterruptServiceWithoutHandler->sessionService_.sessionMap_[CALLER_PID] =
+        std::make_shared<AudioSession>(CALLER_PID, strategy, audioSessionStateMonitor_);
+    audioInterruptServiceWithoutHandler->sessionService_.sessionMap_[CALLER_PID]->AddStreamInfo(audioInterrupt);
 
-    audioInterruptServiceWithoutHandler->sessionService_ = sessionServiceWithoutHandler;
-    sessionServiceWithoutHandler->sessionMap_[CALLER_PID]->state_ = AudioSessionState::SESSION_NEW;
+    audioInterruptServiceWithoutHandler->sessionService_.sessionMap_[CALLER_PID]->state_
+        = AudioSessionState::SESSION_NEW;
     audioInterruptServiceWithoutHandler->DelayToDeactivateStreamsInAudioSession(
-        DEFAULT_ZONE_ID, CALLER_PID, sessionServiceWithoutHandler->GetStreams(CALLER_PID));
+        DEFAULT_ZONE_ID, CALLER_PID, audioInterruptServiceWithoutHandler->sessionService_.GetStreams(CALLER_PID));
 
     std::this_thread::sleep_for(std::chrono::seconds(2));
 }
@@ -4287,20 +4132,18 @@ HWTEST(AudioInterruptUnitTest, AudioSessionFocusMode_010, TestSize.Level2)
  * @tc.number: AudioSessionFocusMode_011
  * @tc.desc  : Test HasStreamForDeviceType
  */
-HWTEST(AudioInterruptUnitTest, AudioSessionFocusMode_011, TestSize.Level1)
+HWTEST_F(AudioInterruptUnitTest, AudioSessionFocusMode_011, TestSize.Level1)
 {
     int32_t CALLER_PID = IPCSkeleton::GetCallingPid();
-
-    std::shared_ptr<AudioSessionService> sessionService = std::make_shared<AudioSessionService>();
-    ASSERT_NE(nullptr, sessionService);
-    EXPECT_FALSE(sessionService->HasStreamForDeviceType(CALLER_PID, DEVICE_TYPE_REMOTE_CAST));
+    auto &sessionService = OHOS::Singleton<AudioSessionService>::GetInstance();
+    EXPECT_FALSE(sessionService.HasStreamForDeviceType(CALLER_PID, DEVICE_TYPE_REMOTE_CAST));
 
     AudioSessionStrategy audioSessionStrategy;
     audioSessionStrategy.concurrencyMode = AudioConcurrencyMode::DEFAULT;
-    int32_t ret = sessionService->ActivateAudioSession(CALLER_PID, audioSessionStrategy);
+    int32_t ret = sessionService.ActivateAudioSession(CALLER_PID, audioSessionStrategy);
     EXPECT_EQ(SUCCESS, ret);
-    ASSERT_NE(nullptr, sessionService->sessionMap_[CALLER_PID]);
-    EXPECT_FALSE(sessionService->HasStreamForDeviceType(CALLER_PID, DEVICE_TYPE_REMOTE_CAST));
+    ASSERT_NE(nullptr, sessionService.sessionMap_[CALLER_PID]);
+    EXPECT_FALSE(sessionService.HasStreamForDeviceType(CALLER_PID, DEVICE_TYPE_REMOTE_CAST));
     AudioInterrupt audioInterrupt = {};
     audioInterrupt.pid = CALLER_PID;
     audioInterrupt.streamId = SESSION_ID_TEST + 1;
@@ -4308,7 +4151,7 @@ HWTEST(AudioInterruptUnitTest, AudioSessionFocusMode_011, TestSize.Level1)
     audioInterrupt.audioFocusType.streamType = STREAM_MUSIC;
     audioInterrupt.audioFocusType.isPlay = true;
     audioInterrupt.callbackType = INTERRUPT_EVENT_CALLBACK_DEFAULT;
-    sessionService->sessionMap_[CALLER_PID]->AddStreamInfo(audioInterrupt);
+    sessionService.sessionMap_[CALLER_PID]->AddStreamInfo(audioInterrupt);
 
     AudioStreamCollector &audioStreamCollector = AudioStreamCollector::GetAudioStreamCollector();
     AudioDeviceDescriptor outputDeviceInfo(DEVICE_TYPE_REMOTE_CAST, OUTPUT_DEVICE, 0, 0, "RemoteDevice");
@@ -4319,10 +4162,11 @@ HWTEST(AudioInterruptUnitTest, AudioSessionFocusMode_011, TestSize.Level1)
     rendererChangeInfo->outputDeviceInfo = outputDeviceInfo;
     rendererChangeInfo->rendererInfo.streamUsage = STREAM_USAGE_MUSIC;
     audioStreamCollector.audioRendererChangeInfos_.push_back(rendererChangeInfo);
-    EXPECT_TRUE(sessionService->HasStreamForDeviceType(CALLER_PID, DEVICE_TYPE_REMOTE_CAST));
+    EXPECT_TRUE(sessionService.HasStreamForDeviceType(CALLER_PID, DEVICE_TYPE_REMOTE_CAST));
 
-    ret = sessionService->DeactivateAudioSession(CALLER_PID);
+    ret = sessionService.DeactivateAudioSession(CALLER_PID);
     EXPECT_EQ(SUCCESS, ret);
+    audioStreamCollector.audioRendererChangeInfos_.clear();
 }
 
 /**
@@ -4330,7 +4174,7 @@ HWTEST(AudioInterruptUnitTest, AudioSessionFocusMode_011, TestSize.Level1)
  * @tc.number: AudioSessionFocusMode_012
  * @tc.desc  : Test GetStreamIdsForAudioSessionByStreamUsage
  */
-HWTEST(AudioInterruptUnitTest, AudioSessionFocusMode_012, TestSize.Level1)
+HWTEST_F(AudioInterruptUnitTest, AudioSessionFocusMode_012, TestSize.Level1)
 {
     int32_t CALLER_PID = IPCSkeleton::GetCallingPid();
     auto audioInterruptService = std::make_shared<AudioInterruptService>();
@@ -4385,7 +4229,7 @@ HWTEST(AudioInterruptUnitTest, AudioSessionFocusMode_012, TestSize.Level1)
  * @tc.number: AudioSessionFocusMode_013
  * @tc.desc  : Test GetStreamIdsForAudioSessionByDeviceType
  */
-HWTEST(AudioInterruptUnitTest, AudioSessionFocusMode_013, TestSize.Level1)
+HWTEST_F(AudioInterruptUnitTest, AudioSessionFocusMode_013, TestSize.Level1)
 {
     int32_t CALLER_PID = IPCSkeleton::GetCallingPid();
     auto interruptService = std::make_shared<AudioInterruptService>();
@@ -4412,18 +4256,16 @@ HWTEST(AudioInterruptUnitTest, AudioSessionFocusMode_013, TestSize.Level1)
     streamIds = interruptService->GetStreamIdsForAudioSessionByDeviceType(DEFAULT_ZONE_ID, DEVICE_TYPE_REMOTE_CAST);
     EXPECT_TRUE(streamIds.empty());
 
-    std::shared_ptr<AudioSessionService> sessionService = std::make_shared<AudioSessionService>();
-    ASSERT_NE(nullptr, sessionService);
     AudioSessionStrategy audioSessionStrategy;
     audioSessionStrategy.concurrencyMode = AudioConcurrencyMode::DEFAULT;
-    sessionService->ActivateAudioSession(CALLER_PID, audioSessionStrategy);
-    ASSERT_NE(nullptr, sessionService->sessionMap_[CALLER_PID]);
+    interruptService->sessionService_.ActivateAudioSession(CALLER_PID, audioSessionStrategy);
+    ASSERT_NE(nullptr, interruptService->sessionService_.sessionMap_[CALLER_PID]);
     AudioInterrupt audioInterrupt = {};
     audioInterrupt.pid = CALLER_PID;
     audioInterrupt.streamId = SESSION_ID_TEST + 1;
     audioInterrupt.streamUsage = STREAM_USAGE_MUSIC;
     audioInterrupt.audioFocusType.isPlay = true;
-    sessionService->sessionMap_[CALLER_PID]->AddStreamInfo(audioInterrupt);
+    interruptService->sessionService_.sessionMap_[CALLER_PID]->AddStreamInfo(audioInterrupt);
 
     streamIds = interruptService->GetStreamIdsForAudioSessionByDeviceType(DEFAULT_ZONE_ID, DEVICE_TYPE_REMOTE_CAST);
     EXPECT_TRUE(streamIds.empty());
@@ -4437,47 +4279,13 @@ HWTEST(AudioInterruptUnitTest, AudioSessionFocusMode_013, TestSize.Level1)
     rendererChangeInfo->rendererInfo.streamUsage = STREAM_USAGE_MUSIC;
     AudioStreamCollector::GetAudioStreamCollector().audioRendererChangeInfos_.push_back(rendererChangeInfo);
 
-    interruptService->sessionService_ = sessionService;
     streamIds = interruptService->GetStreamIdsForAudioSessionByDeviceType(DEFAULT_ZONE_ID, DEVICE_TYPE_REMOTE_CAST);
     EXPECT_EQ(1, streamIds.size());
     EXPECT_EQ(fakeAudioInterrupt.streamId, *streamIds.begin());
 
-    sessionService->DeactivateAudioSession(CALLER_PID);
+    interruptService->sessionService_.DeactivateAudioSession(CALLER_PID);
     AudioStreamCollector::GetAudioStreamCollector().audioRendererChangeInfos_.clear();
 }
 
-/**
-* @tc.name  : Test InterruptStrategy Mute
-* @tc.number: AudioInterruptStrategy_001
-* @tc.desc  : Test InterruptStrategy Mute
-*/
-HWTEST(AudioInterruptServiceUnitTest, AudioInterruptStrategy_001, TestSize.Level1)
-{
-    auto audioInterruptService = std::make_shared<AudioInterruptService>();
-    EXPECT_NE(audioInterruptService, nullptr);
-
-    int32_t fakePid = 123;
-    AudioInterrupt incomingInterrupt1;
-    incomingInterrupt1.pid = fakePid;
-    incomingInterrupt1.audioFocusType.sourceType = SOURCE_TYPE_MIC;
-    incomingInterrupt1.streamId = 888; // 888 is a fake stream id.
-
-    int32_t fakePid2 = 124;
-    AudioInterrupt incomingInterrupt2;
-    incomingInterrupt2.pid = fakePid2;
-    incomingInterrupt2.audioFocusType.sourceType = SOURCE_TYPE_UNPROCESSED;
-    incomingInterrupt2.streamId = 889; // 889 is a fake stream id.
-    incomingInterrupt1.strategy = InterruptStrategy::MUTE;
-
-    AudioFocusEntry focusEntry;
-    focusEntry.hintType = INTERRUPT_HINT_PAUSE;
-    audioInterruptService->UpdateMuteAudioFocusStrategy(incomingInterrupt1, incomingInterrupt2, focusEntry);
-    EXPECT_EQ(focusEntry.hintType, INTERRUPT_HINT_MUTE);
-
-    focusEntry.hintType = INTERRUPT_HINT_PAUSE;
-    audioInterruptService->UpdateMuteAudioFocusStrategy(incomingInterrupt2, incomingInterrupt1, focusEntry);
-    EXPECT_EQ(focusEntry.hintType, INTERRUPT_HINT_MUTE);
-}
-
 } // namespace AudioStandard
 } // namespace OHOS
diff --git a/services/audio_policy/test/unittest/audio_session_service_unit_test/include/audio_session_service_unit_test.h b/services/audio_policy/test/unittest/audio_session_service_unit_test/include/audio_session_service_unit_test.h
index 008650aaac52438107ea45a317fbd523a992fab2..9c223aafde1a7d8dfc9724a3056e26377928e533 100644
--- a/services/audio_policy/test/unittest/audio_session_service_unit_test/include/audio_session_service_unit_test.h
+++ b/services/audio_policy/test/unittest/audio_session_service_unit_test/include/audio_session_service_unit_test.h
@@ -18,10 +18,16 @@
 
 #include "gtest/gtest.h"
 #include "gmock/gmock.h"
+#include "audio_session_state_monitor.h"
 
 namespace OHOS {
 namespace AudioStandard {
 
+class AudioSessionStateMonitorStub : public AudioSessionStateMonitor {
+public:
+    virtual void OnAudioSessionTimeOut(int32_t pid) override {}
+};
+
 class AudioSessionServiceUnitTest : public testing::Test {
 public:
     // SetUpTestCase: Called before all test cases
@@ -32,6 +38,9 @@ public:
     void SetUp(void);
     // TearDown: Called after each test cases
     void TearDown(void);
+private:
+    AudioSessionStateMonitorStub audioSessionStateMonitor_;
+    AudioSessionService &audioSessionService_ {OHOS::Singleton<AudioSessionService>::GetInstance()};
 };
 } // namespace AudioStandard
 } // namespace OHOS
diff --git a/services/audio_policy/test/unittest/audio_session_service_unit_test/src/audio_session_service_unit_test.cpp b/services/audio_policy/test/unittest/audio_session_service_unit_test/src/audio_session_service_unit_test.cpp
index 1dd49ef8428622dd20d040486b951d0d60c55537..8e1491ce01c81f83a7836ee2e76f7af3a3bab095 100644
--- a/services/audio_policy/test/unittest/audio_session_service_unit_test/src/audio_session_service_unit_test.cpp
+++ b/services/audio_policy/test/unittest/audio_session_service_unit_test/src/audio_session_service_unit_test.cpp
@@ -35,7 +35,11 @@ public:
 void AudioSessionServiceUnitTest::SetUpTestCase(void) {}
 void AudioSessionServiceUnitTest::TearDownTestCase(void) {}
 void AudioSessionServiceUnitTest::SetUp(void) {}
-void AudioSessionServiceUnitTest::TearDown(void) {}
+void AudioSessionServiceUnitTest::TearDown(void)
+{
+    audioSessionService_.sessionMap_.clear();
+    audioSessionService_.timeOutCallback_.reset();
+}
 
 /**
 * @tc.name  : Test AudioSessionService.
@@ -44,8 +48,7 @@ void AudioSessionServiceUnitTest::TearDown(void) {}
 */
 HWTEST_F(AudioSessionServiceUnitTest, AudioSessionServiceUnitTest_001, TestSize.Level1)
 {
-    auto audioSessionService = std::make_shared<AudioSessionService>();
-    auto ret = audioSessionService->IsSameTypeForAudioSession(AudioStreamType::STREAM_MUSIC,
+    auto ret = audioSessionService_.IsSameTypeForAudioSession(AudioStreamType::STREAM_MUSIC,
         AudioStreamType::STREAM_MUSIC);
     EXPECT_TRUE(ret);
 }
@@ -58,18 +61,16 @@ HWTEST_F(AudioSessionServiceUnitTest, AudioSessionServiceUnitTest_001, TestSize.
 HWTEST_F(AudioSessionServiceUnitTest, AudioSessionServiceUnitTest_002, TestSize.Level1)
 {
     int32_t callerPid = 0;
-    auto audioSessionService = std::make_shared<AudioSessionService>();
 
     AudioSessionStrategy strategy;
-    std::shared_ptr<AudioSessionStateMonitor> audioSessionStateMonitor = nullptr;
-    auto audioSession = std::make_shared<AudioSession>(callerPid, strategy, audioSessionStateMonitor);
+    auto audioSession = std::make_shared<AudioSession>(callerPid, strategy, audioSessionStateMonitor_);
 
-    audioSessionService->sessionMap_[callerPid] = audioSession;
-    auto ret = audioSessionService->DeactivateAudioSessionInternal(callerPid, true);
+    audioSessionService_.sessionMap_[callerPid] = audioSession;
+    auto ret = audioSessionService_.DeactivateAudioSessionInternal(callerPid, true);
     EXPECT_EQ(ret, SUCCESS);
 
-    audioSessionService->sessionMap_[callerPid] = audioSession;
-    ret = audioSessionService->DeactivateAudioSessionInternal(callerPid, false);
+    audioSessionService_.sessionMap_[callerPid] = audioSession;
+    ret = audioSessionService_.DeactivateAudioSessionInternal(callerPid, false);
     EXPECT_EQ(ret, SUCCESS);
 }
 
@@ -81,29 +82,11 @@ HWTEST_F(AudioSessionServiceUnitTest, AudioSessionServiceUnitTest_002, TestSize.
 HWTEST_F(AudioSessionServiceUnitTest, AudioSessionServiceUnitTest_003, TestSize.Level1)
 {
     int32_t callerPid = 0;
-    auto audioSessionService = std::make_shared<AudioSessionService>();
-    ASSERT_TRUE(audioSessionService != nullptr);
-
     std::shared_ptr<SessionTimeOutCallback> timeOutCallback = nullptr;
-    auto ret = audioSessionService->SetSessionTimeOutCallback(timeOutCallback);
+    auto ret = audioSessionService_.SetSessionTimeOutCallback(timeOutCallback);
     EXPECT_EQ(ret, -1);
 }
 
-/**
-* @tc.name  : Test AudioSessionService.
-* @tc.number: AudioSessionServiceUnitTest_004.
-* @tc.desc  : Test GetAudioSessionByPid.
-*/
-HWTEST_F(AudioSessionServiceUnitTest, AudioSessionServiceUnitTest_004, TestSize.Level1)
-{
-    int32_t callerPid = 10;
-    auto audioSessionService = std::make_shared<AudioSessionService>();
-    ASSERT_TRUE(audioSessionService != nullptr);
-
-    auto ret = audioSessionService->GetAudioSessionByPid(callerPid);
-    EXPECT_TRUE(ret == nullptr);
-}
-
 /**
 * @tc.name  : Test AudioSessionService.
 * @tc.number: AudioSessionServiceUnitTest_005.
@@ -112,10 +95,7 @@ HWTEST_F(AudioSessionServiceUnitTest, AudioSessionServiceUnitTest_004, TestSize.
 HWTEST_F(AudioSessionServiceUnitTest, AudioSessionServiceUnitTest_005, TestSize.Level1)
 {
     int32_t callerPid = 0;
-    auto audioSessionService = std::make_shared<AudioSessionService>();
-    ASSERT_TRUE(audioSessionService != nullptr);
-
-    audioSessionService->OnAudioSessionTimeOut(callerPid);
+    audioSessionService_.OnAudioSessionTimeOut(callerPid);
 }
 
 /**
@@ -126,10 +106,7 @@ HWTEST_F(AudioSessionServiceUnitTest, AudioSessionServiceUnitTest_005, TestSize.
 HWTEST_F(AudioSessionServiceUnitTest, AudioSessionServiceUnitTest_006, TestSize.Level1)
 {
     std::string dumpString = "test";
-    auto audioSessionService = std::make_shared<AudioSessionService>();
-    ASSERT_TRUE(audioSessionService != nullptr);
-
-    audioSessionService->AudioSessionInfoDump(dumpString);
+    audioSessionService_.AudioSessionInfoDump(dumpString);
 }
 
 /**
@@ -141,17 +118,14 @@ HWTEST_F(AudioSessionServiceUnitTest, AudioSessionServiceUnitTest_007, TestSize.
 {
     int32_t callerPid = 0;
     std::string dumpString = "test";
-    auto audioSessionService = std::make_shared<AudioSessionService>();
-    ASSERT_TRUE(audioSessionService != nullptr);
 
     AudioSessionStrategy strategy;
-    std::shared_ptr<AudioSessionStateMonitor> audioSessionStateMonitor = nullptr;
-    auto audioSession = std::make_shared<AudioSession>(callerPid, strategy, audioSessionStateMonitor);
+    auto audioSession = std::make_shared<AudioSession>(callerPid, strategy, audioSessionStateMonitor_);
     AudioInterrupt audioInterrupt = {};
     auto interruptPair = std::pair<AudioInterrupt, AudioFocuState>(audioInterrupt, AudioFocuState::DUCK);
 
-    audioSessionService->sessionMap_[callerPid] = audioSession;
-    audioSessionService->AudioSessionInfoDump(dumpString);
+    audioSessionService_.sessionMap_[callerPid] = audioSession;
+    audioSessionService_.AudioSessionInfoDump(dumpString);
 }
 
 /**
@@ -163,34 +137,15 @@ HWTEST_F(AudioSessionServiceUnitTest, AudioSessionServiceUnitTest_008, TestSize.
 {
     int32_t callerPid = 0;
     std::string dumpString = "test";
-    auto audioSessionService = std::make_shared<AudioSessionService>();
-    ASSERT_TRUE(audioSessionService != nullptr);
 
     AudioSessionStrategy strategy;
-    std::shared_ptr<AudioSessionStateMonitor> audioSessionStateMonitor = nullptr;
-    auto audioSession = std::make_shared<AudioSession>(callerPid, strategy, audioSessionStateMonitor);
+    auto audioSession = std::make_shared<AudioSession>(callerPid, strategy, audioSessionStateMonitor_);
     AudioInterrupt audioInterrupt = {};
     audioInterrupt.streamId = 0;
     audioSession->streamsInSession_.push_back(audioInterrupt);
 
-    audioSessionService->sessionMap_[callerPid] = audioSession;
-    audioSessionService->AudioSessionInfoDump(dumpString);
-}
-
-/**
-* @tc.name  : Test AudioSessionService.
-* @tc.number: AudioSessionServiceUnitTest_009.
-* @tc.desc  : Test AudioSessionInfoDump.
-*/
-HWTEST_F(AudioSessionServiceUnitTest, AudioSessionServiceUnitTest_009, TestSize.Level1)
-{
-    int32_t callerPid = 0;
-    std::string dumpString = "test";
-    auto audioSessionService = std::make_shared<AudioSessionService>();
-    ASSERT_TRUE(audioSessionService != nullptr);
-
-    audioSessionService->sessionMap_[callerPid] = nullptr;
-    audioSessionService->AudioSessionInfoDump(dumpString);
+    audioSessionService_.sessionMap_[callerPid] = audioSession;
+    audioSessionService_.AudioSessionInfoDump(dumpString);
 }
 
 /**
@@ -201,16 +156,14 @@ HWTEST_F(AudioSessionServiceUnitTest, AudioSessionServiceUnitTest_009, TestSize.
 HWTEST_F(AudioSessionServiceUnitTest, SetAudioSessionSceneTest, TestSize.Level1)
 {
     int32_t fakePid = 123;
-    std::shared_ptr<AudioSessionService> sessionService = std::make_shared<AudioSessionService>();
-    ASSERT_TRUE(sessionService != nullptr);
-    int ret = sessionService->SetAudioSessionScene(fakePid, AudioSessionScene::MEDIA);
+    int ret = audioSessionService_.SetAudioSessionScene(fakePid, AudioSessionScene::MEDIA);
     EXPECT_EQ(SUCCESS, ret);
     AudioSessionStrategy audioSessionStrategy;
     audioSessionStrategy.concurrencyMode = AudioConcurrencyMode::DEFAULT;
-    ret = sessionService->ActivateAudioSession(fakePid, audioSessionStrategy);
+    ret = audioSessionService_.ActivateAudioSession(fakePid, audioSessionStrategy);
     EXPECT_EQ(SUCCESS, ret);
-    EXPECT_TRUE(sessionService->IsAudioSessionActivated(fakePid));
-    EXPECT_TRUE(sessionService->IsAudioSessionFocusMode(fakePid));
+    EXPECT_TRUE(audioSessionService_.IsAudioSessionActivated(fakePid));
+    EXPECT_TRUE(audioSessionService_.IsAudioSessionFocusMode(fakePid));
 }
 
 /**
@@ -221,9 +174,7 @@ HWTEST_F(AudioSessionServiceUnitTest, SetAudioSessionSceneTest, TestSize.Level1)
 HWTEST_F(AudioSessionServiceUnitTest, GetAudioSessionStreamUsage, TestSize.Level1)
 {
     int32_t fakePid = 123;
-    std::shared_ptr<AudioSessionService> sessionService = std::make_shared<AudioSessionService>();
-    ASSERT_TRUE(sessionService != nullptr);
-    StreamUsage usage = sessionService->GetAudioSessionStreamUsage(fakePid);
+    StreamUsage usage = audioSessionService_.GetAudioSessionStreamUsage(fakePid);
     EXPECT_EQ(STREAM_USAGE_INVALID, usage);
 }
 
@@ -235,11 +186,9 @@ HWTEST_F(AudioSessionServiceUnitTest, GetAudioSessionStreamUsage, TestSize.Level
 HWTEST_F(AudioSessionServiceUnitTest, GetAudioSessionStreamUsage_001, TestSize.Level1)
 {
     int32_t fakePid = 123;
-    std::shared_ptr<AudioSessionService> sessionService = std::make_shared<AudioSessionService>();
-    ASSERT_TRUE(sessionService != nullptr);
-    int ret = sessionService->SetAudioSessionScene(fakePid, AudioSessionScene::MEDIA);
+    int ret = audioSessionService_.SetAudioSessionScene(fakePid, AudioSessionScene::MEDIA);
     EXPECT_EQ(SUCCESS, ret);
-    StreamUsage usage = sessionService->GetAudioSessionStreamUsage(fakePid);
+    StreamUsage usage = audioSessionService_.GetAudioSessionStreamUsage(fakePid);
     EXPECT_EQ(STREAM_USAGE_MEDIA, usage);
 }
 
@@ -250,11 +199,10 @@ HWTEST_F(AudioSessionServiceUnitTest, GetAudioSessionStreamUsage_001, TestSize.L
 */
 HWTEST_F(AudioSessionServiceUnitTest, AudioSessionServiceUnitTest_010, TestSize.Level1)
 {
-    auto sessionService = std::make_shared<AudioSessionService>();
     int32_t callerPid = 1;
     AudioSessionStrategy strategy;
-    sessionService->sessionMap_.emplace(callerPid, nullptr);
-    EXPECT_EQ(sessionService->ActivateAudioSession(callerPid, strategy), ERROR);
+    audioSessionService_.sessionMap_.emplace(callerPid, nullptr);
+    EXPECT_EQ(audioSessionService_.ActivateAudioSession(callerPid, strategy), ERROR);
 }
 
 /**
@@ -264,18 +212,17 @@ HWTEST_F(AudioSessionServiceUnitTest, AudioSessionServiceUnitTest_010, TestSize.
 */
 HWTEST_F(AudioSessionServiceUnitTest, AudioSessionServiceUnitTest_011, TestSize.Level1)
 {
-    auto sessionService = std::make_shared<AudioSessionService>();
     int32_t callerPid = 1;
     bool isSessionTimeout = false;
-    sessionService->sessionMap_.insert(std::pair<int32_t, std::shared_ptr<AudioSession>>(callerPid, nullptr));
-    EXPECT_EQ(sessionService->DeactivateAudioSessionInternal(callerPid, isSessionTimeout), ERR_ILLEGAL_STATE);
+    EXPECT_EQ(audioSessionService_.DeactivateAudioSessionInternal(callerPid, isSessionTimeout), ERR_ILLEGAL_STATE);
 
     AudioSessionStrategy strategy;
-    std::shared_ptr<AudioSession> audioSession = std::make_shared<AudioSession>(callerPid, strategy, nullptr);
+    std::shared_ptr<AudioSession> audioSession =
+        std::make_shared<AudioSession>(callerPid, strategy, audioSessionStateMonitor_);
     uint32_t fakeStreamId = 1000;
     audioSession->SaveFakeStreamId(fakeStreamId);
-    sessionService->sessionMap_[callerPid] = audioSession;
-    EXPECT_EQ(sessionService->DeactivateAudioSessionInternal(callerPid, isSessionTimeout), SUCCESS);
+    audioSessionService_.sessionMap_[callerPid] = audioSession;
+    EXPECT_EQ(audioSessionService_.DeactivateAudioSessionInternal(callerPid, isSessionTimeout), SUCCESS);
 }
 
 /**
@@ -285,14 +232,15 @@ HWTEST_F(AudioSessionServiceUnitTest, AudioSessionServiceUnitTest_011, TestSize.
 */
 HWTEST_F(AudioSessionServiceUnitTest, AudioSessionServiceUnitTest_012, TestSize.Level1)
 {
-    auto sessionService = std::make_shared<AudioSessionService>();
     int32_t callerPid = 1;
     AudioSessionStrategy strategy;
-    std::shared_ptr<AudioSession> audioSession = std::make_shared<AudioSession>(callerPid, strategy, nullptr);
-    sessionService->sessionMap_.insert(std::pair<int32_t, std::shared_ptr<AudioSession>>(callerPid, audioSession));
+    std::shared_ptr<AudioSession> audioSession =
+        std::make_shared<AudioSession>(callerPid, strategy, audioSessionStateMonitor_);
+    audioSessionService_.sessionMap_.insert(
+        std::pair<int32_t, std::shared_ptr<AudioSession>>(callerPid, audioSession));
     auto mockTimeOutCallback = std::make_shared<MockSessionTimeOutCallback>();
-    sessionService->SetSessionTimeOutCallback(mockTimeOutCallback);
-    EXPECT_NO_THROW(sessionService->OnAudioSessionTimeOut(callerPid));
+    audioSessionService_.SetSessionTimeOutCallback(mockTimeOutCallback);
+    EXPECT_NO_THROW(audioSessionService_.OnAudioSessionTimeOut(callerPid));
 }
 
 /**
@@ -302,20 +250,14 @@ HWTEST_F(AudioSessionServiceUnitTest, AudioSessionServiceUnitTest_012, TestSize.
 */
 HWTEST_F(AudioSessionServiceUnitTest, AudioSessionServiceUnitTest_013, TestSize.Level1)
 {
-    auto sessionService = std::make_shared<AudioSessionService>();
     int32_t callerPid = 1;
     AudioSessionScene scene = AudioSessionScene::MEDIA;
-    sessionService->sessionMap_.insert(std::pair<int32_t, std::shared_ptr<AudioSession>>(callerPid, nullptr));
-    EXPECT_EQ(sessionService->SetAudioSessionScene(callerPid, scene), SUCCESS);
-
-    sessionService->sessionMap_.clear();
-    AudioSessionStrategy strategy;
-    std::shared_ptr<AudioSession> audioSession = std::make_shared<AudioSession>(callerPid, strategy, nullptr);
-    sessionService->sessionMap_.insert(std::pair<int32_t, std::shared_ptr<AudioSession>>(callerPid, audioSession));
-    EXPECT_EQ(sessionService->SetAudioSessionScene(callerPid, scene), SUCCESS);
+    audioSessionService_.sessionMap_.insert(
+        std::pair<int32_t, std::shared_ptr<AudioSession>>(callerPid, nullptr));
+    EXPECT_EQ(ERROR, audioSessionService_.SetAudioSessionScene(callerPid, scene));
 
     callerPid = 2;
-    EXPECT_EQ(sessionService->SetAudioSessionScene(callerPid, scene), SUCCESS);
+    EXPECT_EQ(SUCCESS, audioSessionService_.SetAudioSessionScene(callerPid, scene));
 };
 
 /**
@@ -325,14 +267,29 @@ HWTEST_F(AudioSessionServiceUnitTest, AudioSessionServiceUnitTest_013, TestSize.
 */
 HWTEST_F(AudioSessionServiceUnitTest, AudioSessionServiceUnitTest_014, TestSize.Level1)
 {
-    auto sessionService = std::make_shared<AudioSessionService>();
     AudioInterrupt audioInterrupt = {};
     audioInterrupt.audioFocusType.streamType = STREAM_NOTIFICATION;
-    EXPECT_TRUE(sessionService->ShouldExcludeStreamType(audioInterrupt));
+    EXPECT_TRUE(audioSessionService_.ShouldExcludeStreamType(audioInterrupt));
+
+    audioInterrupt.audioFocusType.streamType = STREAM_MUSIC;
+    audioInterrupt.audioFocusType.sourceType = SOURCE_TYPE_PLAYBACK_CAPTURE;
+    EXPECT_TRUE(audioSessionService_.ShouldExcludeStreamType(audioInterrupt));
+}
+
+/**
+* @tc.name  : Test ShouldExcludeStreamTypeInner.
+* @tc.number: ShouldExcludeStreamTypeInnerTest.
+* @tc.desc  : Test ShouldExcludeStreamTypeInner.
+*/
+HWTEST_F(AudioSessionServiceUnitTest, ShouldExcludeStreamTypeInnerTest, TestSize.Level1)
+{
+    AudioInterrupt audioInterrupt = {};
+    audioInterrupt.audioFocusType.streamType = STREAM_NOTIFICATION;
+    EXPECT_TRUE(audioSessionService_.ShouldExcludeStreamTypeInner(audioInterrupt));
 
     audioInterrupt.audioFocusType.streamType = STREAM_MUSIC;
     audioInterrupt.audioFocusType.sourceType = SOURCE_TYPE_PLAYBACK_CAPTURE;
-    EXPECT_TRUE(sessionService->ShouldExcludeStreamType(audioInterrupt));
+    EXPECT_TRUE(audioSessionService_.ShouldExcludeStreamTypeInner(audioInterrupt));
 }
 
 /**
@@ -342,18 +299,19 @@ HWTEST_F(AudioSessionServiceUnitTest, AudioSessionServiceUnitTest_014, TestSize.
 */
 HWTEST_F(AudioSessionServiceUnitTest, AudioSessionServiceUnitTest_015, TestSize.Level1)
 {
-    auto sessionService = std::make_shared<AudioSessionService>();
     int32_t callerPid = 1;
     AudioSessionStrategy strategy;
-    std::shared_ptr<AudioSession> audioSession = std::make_shared<AudioSession>(callerPid, strategy, nullptr);
+    std::shared_ptr<AudioSession> audioSession =
+        std::make_shared<AudioSession>(callerPid, strategy, audioSessionStateMonitor_);
     audioSession->audioSessionScene_ = AudioSessionScene::MEDIA;
     audioSession->state_ = AudioSessionState::SESSION_ACTIVE;
-    sessionService->sessionMap_.insert(std::pair<int32_t, std::shared_ptr<AudioSession>>(callerPid, audioSession));
+    audioSessionService_.sessionMap_.insert(
+        std::pair<int32_t, std::shared_ptr<AudioSession>>(callerPid, audioSession));
 
     AudioInterrupt audioInterrupt = {};
     audioInterrupt.pid = callerPid;
     audioInterrupt.audioFocusType.streamType = STREAM_NOTIFICATION;
-    EXPECT_FALSE(sessionService->ShouldBypassFocusForStream(audioInterrupt));
+    EXPECT_FALSE(audioSessionService_.ShouldBypassFocusForStream(audioInterrupt));
 }
 
 /**
@@ -363,24 +321,22 @@ HWTEST_F(AudioSessionServiceUnitTest, AudioSessionServiceUnitTest_015, TestSize.
 */
 HWTEST_F(AudioSessionServiceUnitTest, AudioSessionServiceUnitTest_016, TestSize.Level1)
 {
-    auto sessionService = std::make_shared<AudioSessionService>();
     int32_t callerPid = 1;
-    sessionService->sessionMap_.insert(std::pair<int32_t, std::shared_ptr<AudioSession>>(callerPid, nullptr));
-
-    sessionService->GenerateFakeStreamId(callerPid);
-    AudioInterrupt fakeAudioInterrupt = sessionService->GenerateFakeAudioInterrupt(callerPid);
+    audioSessionService_.GenerateFakeStreamId(callerPid);
+    AudioInterrupt fakeAudioInterrupt = audioSessionService_.GenerateFakeAudioInterrupt(callerPid);
     EXPECT_EQ(fakeAudioInterrupt.streamId, 0);
 
     AudioSessionStrategy strategy;
-    std::shared_ptr<AudioSession> audioSession = std::make_shared<AudioSession>(callerPid, strategy, nullptr);
+    std::shared_ptr<AudioSession> audioSession =
+        std::make_shared<AudioSession>(callerPid, strategy, audioSessionStateMonitor_);
     audioSession->fakeStreamId_ = 1;
-    sessionService->sessionMap_[callerPid] = audioSession;
-    fakeAudioInterrupt = sessionService->GenerateFakeAudioInterrupt(callerPid);
+    audioSessionService_.sessionMap_[callerPid] = audioSession;
+    fakeAudioInterrupt = audioSessionService_.GenerateFakeAudioInterrupt(callerPid);
     EXPECT_EQ(fakeAudioInterrupt.streamId, 1);
 
     callerPid = 2;
-    sessionService->GenerateFakeStreamId(callerPid);
-    fakeAudioInterrupt = sessionService->GenerateFakeAudioInterrupt(callerPid);
+    audioSessionService_.GenerateFakeStreamId(callerPid);
+    fakeAudioInterrupt = audioSessionService_.GenerateFakeAudioInterrupt(callerPid);
     EXPECT_EQ(fakeAudioInterrupt.streamId, 0);
 }
 
@@ -391,21 +347,22 @@ HWTEST_F(AudioSessionServiceUnitTest, AudioSessionServiceUnitTest_016, TestSize.
 */
 HWTEST_F(AudioSessionServiceUnitTest, AudioSessionServiceUnitTest_017, TestSize.Level1)
 {
-    auto sessionService = std::make_shared<AudioSessionService>();
     int32_t callerPid = 1;
     AudioInterrupt audioInterrupt = {};
     audioInterrupt.pid = callerPid;
     audioInterrupt.isAudioSessionInterrupt = true;
-    EXPECT_NO_THROW(sessionService->RemoveStreamInfo(audioInterrupt));
+    EXPECT_NO_THROW(audioSessionService_.RemoveStreamInfo(audioInterrupt.pid, audioInterrupt.streamId));
 
     audioInterrupt.isAudioSessionInterrupt = false;
     AudioSessionStrategy strategy;
-    std::shared_ptr<AudioSession> audioSession = std::make_shared<AudioSession>(callerPid, strategy, nullptr);
-    sessionService->sessionMap_.insert(std::pair<int32_t, std::shared_ptr<AudioSession>>(callerPid, audioSession));
-    EXPECT_NO_THROW(sessionService->RemoveStreamInfo(audioInterrupt));
+    std::shared_ptr<AudioSession> audioSession =
+        std::make_shared<AudioSession>(callerPid, strategy, audioSessionStateMonitor_);
+    audioSessionService_.sessionMap_.insert(
+        std::pair<int32_t, std::shared_ptr<AudioSession>>(callerPid, audioSession));
+    EXPECT_NO_THROW(audioSessionService_.RemoveStreamInfo(audioInterrupt.pid, audioInterrupt.streamId));
 
     callerPid = 2;
-    EXPECT_NO_THROW(sessionService->RemoveStreamInfo(audioInterrupt));
+    EXPECT_NO_THROW(audioSessionService_.RemoveStreamInfo(audioInterrupt.pid, audioInterrupt.streamId));
 }
 
 /**
@@ -415,12 +372,13 @@ HWTEST_F(AudioSessionServiceUnitTest, AudioSessionServiceUnitTest_017, TestSize.
 */
 HWTEST_F(AudioSessionServiceUnitTest, AudioSessionServiceUnitTest_018, TestSize.Level1)
 {
-    auto sessionService = std::make_shared<AudioSessionService>();
     int32_t callerPid = 1;
-    EXPECT_NO_THROW(sessionService->ClearStreamInfo(callerPid));
-
-    sessionService->sessionMap_.insert(std::pair<int32_t, std::shared_ptr<AudioSession>>(callerPid, nullptr));
-    EXPECT_NO_THROW(sessionService->ClearStreamInfo(callerPid));
+    AudioSessionStrategy strategy;
+    std::shared_ptr<AudioSession> audioSession =
+        std::make_shared<AudioSession>(callerPid, strategy, audioSessionStateMonitor_);
+    audioSessionService_.sessionMap_.insert(
+        std::pair<int32_t, std::shared_ptr<AudioSession>>(callerPid, audioSession));
+    EXPECT_NO_THROW(audioSessionService_.ClearStreamInfo(callerPid));
 }
 
 /**
@@ -430,19 +388,17 @@ HWTEST_F(AudioSessionServiceUnitTest, AudioSessionServiceUnitTest_018, TestSize.
 */
 HWTEST_F(AudioSessionServiceUnitTest, AudioSessionServiceUnitTest_019, TestSize.Level1)
 {
-    auto sessionService = std::make_shared<AudioSessionService>();
     int32_t callerPid = 1;
     DeviceType deviceType = DeviceType::DEVICE_TYPE_DEFAULT;
-    EXPECT_EQ(sessionService->SetSessionDefaultOutputDevice(callerPid, deviceType), SUCCESS);
+    EXPECT_EQ(audioSessionService_.SetSessionDefaultOutputDevice(callerPid, deviceType), SUCCESS);
 
     callerPid = 2;
     AudioSessionStrategy strategy;
-    std::shared_ptr<AudioSession> audioSession = std::make_shared<AudioSession>(callerPid, strategy, nullptr);
-    sessionService->sessionMap_.insert(std::pair<int32_t, std::shared_ptr<AudioSession>>(callerPid, audioSession));
-    EXPECT_EQ(sessionService->SetSessionDefaultOutputDevice(callerPid, deviceType), SUCCESS);
-
-    sessionService->sessionMap_[callerPid].reset();
-    EXPECT_EQ(sessionService->SetSessionDefaultOutputDevice(callerPid, deviceType), SUCCESS);
+    std::shared_ptr<AudioSession> audioSession =
+        std::make_shared<AudioSession>(callerPid, strategy, audioSessionStateMonitor_);
+    audioSessionService_.sessionMap_.insert(
+        std::pair<int32_t, std::shared_ptr<AudioSession>>(callerPid, audioSession));
+    EXPECT_EQ(audioSessionService_.SetSessionDefaultOutputDevice(callerPid, deviceType), SUCCESS);
 }
 
 /**
@@ -452,18 +408,17 @@ HWTEST_F(AudioSessionServiceUnitTest, AudioSessionServiceUnitTest_019, TestSize.
 */
 HWTEST_F(AudioSessionServiceUnitTest, AudioSessionServiceUnitTest_020, TestSize.Level1)
 {
-    auto sessionService = std::make_shared<AudioSessionService>();
     int32_t callerPid = 1;
-    EXPECT_EQ(sessionService->GetSessionDefaultOutputDevice(callerPid), DEVICE_TYPE_INVALID);
 
     AudioSessionStrategy strategy;
-    std::shared_ptr<AudioSession> audioSession = std::make_shared<AudioSession>(callerPid, strategy, nullptr);
-    audioSession->defaultDeviceType_ = DEVICE_TYPE_DEFAULT;
-    sessionService->sessionMap_.insert(std::pair<int32_t, std::shared_ptr<AudioSession>>(callerPid, audioSession));
-    EXPECT_EQ(sessionService->GetSessionDefaultOutputDevice(callerPid), DEVICE_TYPE_DEFAULT);
+    std::shared_ptr<AudioSession> audioSession =
+        std::make_shared<AudioSession>(callerPid, strategy, audioSessionStateMonitor_);
+    audioSessionService_.sessionMap_.insert(
+        std::pair<int32_t, std::shared_ptr<AudioSession>>(callerPid, audioSession));
+    EXPECT_EQ(audioSessionService_.GetSessionDefaultOutputDevice(callerPid), DEVICE_TYPE_INVALID);
 
-    sessionService->sessionMap_[callerPid].reset();
-    EXPECT_EQ(sessionService->GetSessionDefaultOutputDevice(callerPid), DEVICE_TYPE_INVALID);
+    callerPid = 2;
+    EXPECT_EQ(audioSessionService_.GetSessionDefaultOutputDevice(callerPid), DEVICE_TYPE_INVALID);
 }
 
 /**
@@ -473,29 +428,34 @@ HWTEST_F(AudioSessionServiceUnitTest, AudioSessionServiceUnitTest_020, TestSize.
 */
 HWTEST_F(AudioSessionServiceUnitTest, AudioSessionServiceUnitTest_021, TestSize.Level1)
 {
-    auto sessionService = std::make_shared<AudioSessionService>();
     uint32_t streamId = 1001;
     int32_t callerPid = 1;
     AudioSessionStrategy strategy;
     AudioInterrupt audioInterrupt = {};
     audioInterrupt.streamId = streamId;
 
-    std::shared_ptr<AudioSession> audioSession1 = std::make_shared<AudioSession>(callerPid, strategy, nullptr);
+    std::shared_ptr<AudioSession> audioSession1 =
+        std::make_shared<AudioSession>(callerPid, strategy, audioSessionStateMonitor_);
     audioSession1->streamsInSession_.push_back(audioInterrupt);
     audioSession1->state_ == AudioSessionState::SESSION_ACTIVE;
-    sessionService->sessionMap_.insert(std::pair<int32_t, std::shared_ptr<AudioSession>>(callerPid, audioSession1));
+    audioSessionService_.sessionMap_.insert(
+        std::pair<int32_t, std::shared_ptr<AudioSession>>(callerPid, audioSession1));
     callerPid = 2;
-    std::shared_ptr<AudioSession> audioSession2 = std::make_shared<AudioSession>(callerPid, strategy, nullptr);
+    std::shared_ptr<AudioSession> audioSession2 =
+        std::make_shared<AudioSession>(callerPid, strategy, audioSessionStateMonitor_);
     audioSession2->streamsInSession_.push_back(audioInterrupt);
     audioSession2->state_ == AudioSessionState::SESSION_NEW;
-    sessionService->sessionMap_.insert(std::pair<int32_t, std::shared_ptr<AudioSession>>(callerPid, audioSession2));
+    audioSessionService_.sessionMap_.insert(
+        std::pair<int32_t, std::shared_ptr<AudioSession>>(callerPid, audioSession2));
     callerPid = 3;
-    std::shared_ptr<AudioSession> audioSession3 = std::make_shared<AudioSession>(callerPid, strategy, nullptr);
-    sessionService->sessionMap_.insert(std::pair<int32_t, std::shared_ptr<AudioSession>>(callerPid, audioSession3));
+    std::shared_ptr<AudioSession> audioSession3 =
+        std::make_shared<AudioSession>(callerPid, strategy, audioSessionStateMonitor_);
+    audioSessionService_.sessionMap_.insert(
+        std::pair<int32_t, std::shared_ptr<AudioSession>>(callerPid, audioSession3));
     callerPid = 4;
-    sessionService->sessionMap_.insert(std::pair<int32_t, std::shared_ptr<AudioSession>>(callerPid, nullptr));
+    audioSessionService_.sessionMap_.insert(std::pair<int32_t, std::shared_ptr<AudioSession>>(callerPid, nullptr));
 
-    EXPECT_TRUE(sessionService->IsStreamAllowedToSetDevice(streamId));
+    EXPECT_TRUE(audioSessionService_.IsStreamAllowedToSetDevice(streamId));
 }
 
 /**
@@ -505,19 +465,17 @@ HWTEST_F(AudioSessionServiceUnitTest, AudioSessionServiceUnitTest_021, TestSize.
 */
 HWTEST_F(AudioSessionServiceUnitTest, AudioSessionServiceUnitTest_022, TestSize.Level1)
 {
-    auto sessionService = std::make_shared<AudioSessionService>();
     int32_t callerPid = 1;
-    sessionService->sessionMap_.insert(std::pair<int32_t, std::shared_ptr<AudioSession>>(callerPid, nullptr));
-    EXPECT_FALSE(sessionService->IsSessionNeedToFetchOutputDevice(callerPid));
 
     AudioSessionStrategy strategy;
-    std::shared_ptr<AudioSession> audioSession = std::make_shared<AudioSession>(callerPid, strategy, nullptr);
+    std::shared_ptr<AudioSession> audioSession =
+        std::make_shared<AudioSession>(callerPid, strategy, audioSessionStateMonitor_);
     audioSession->needToFetch_ = true;
-    sessionService->sessionMap_[callerPid] = audioSession;
-    EXPECT_TRUE(sessionService->IsSessionNeedToFetchOutputDevice(callerPid));
+    audioSessionService_.sessionMap_[callerPid] = audioSession;
+    EXPECT_TRUE(audioSessionService_.IsSessionNeedToFetchOutputDevice(callerPid));
 
     callerPid = 2;
-    EXPECT_FALSE(sessionService->IsSessionNeedToFetchOutputDevice(callerPid));
+    EXPECT_FALSE(audioSessionService_.IsSessionNeedToFetchOutputDevice(callerPid));
 }
 
 /**
@@ -527,24 +485,21 @@ HWTEST_F(AudioSessionServiceUnitTest, AudioSessionServiceUnitTest_022, TestSize.
 */
 HWTEST_F(AudioSessionServiceUnitTest, AudioSessionServiceUnitTest_023, TestSize.Level1)
 {
-    auto sessionService = std::make_shared<AudioSessionService>();
     int32_t pid = 1;
     bool isBackState = false;
-    EXPECT_NO_THROW(sessionService->NotifyAppStateChange(pid, isBackState));
-
-    sessionService->sessionMap_.insert(std::pair<int32_t, std::shared_ptr<AudioSession>>(pid, nullptr));
-    EXPECT_NO_THROW(sessionService->NotifyAppStateChange(pid, isBackState));
+    EXPECT_NO_THROW(audioSessionService_.NotifyAppStateChange(pid, isBackState));
 
     AudioSessionStrategy strategy;
-    std::shared_ptr<AudioSession> audioSession = std::make_shared<AudioSession>(pid, strategy, nullptr);
+    std::shared_ptr<AudioSession> audioSession =
+        std::make_shared<AudioSession>(pid, strategy, audioSessionStateMonitor_);
     audioSession->audioSessionScene_ = AudioSessionScene::INVALID;
-    sessionService->sessionMap_[pid] = audioSession;
-    EXPECT_NO_THROW(sessionService->NotifyAppStateChange(pid, false));
-    EXPECT_NO_THROW(sessionService->NotifyAppStateChange(pid, true));
+    audioSessionService_.sessionMap_[pid] = audioSession;
+    EXPECT_NO_THROW(audioSessionService_.NotifyAppStateChange(pid, false));
+    EXPECT_NO_THROW(audioSessionService_.NotifyAppStateChange(pid, true));
 
     audioSession->audioSessionScene_ = AudioSessionScene::MEDIA;
-    EXPECT_NO_THROW(sessionService->NotifyAppStateChange(pid, false));
-    EXPECT_NO_THROW(sessionService->NotifyAppStateChange(pid, true));
+    EXPECT_NO_THROW(audioSessionService_.NotifyAppStateChange(pid, false));
+    EXPECT_NO_THROW(audioSessionService_.NotifyAppStateChange(pid, true));
 }
 
 /**
@@ -554,31 +509,31 @@ HWTEST_F(AudioSessionServiceUnitTest, AudioSessionServiceUnitTest_023, TestSize.
 */
 HWTEST_F(AudioSessionServiceUnitTest, AudioSessionServiceUnitTest_024, TestSize.Level1)
 {
-    auto sessionService = std::make_shared<AudioSessionService>();
     int32_t pid = 1;
     AudioSessionStrategy strategy;
     AudioInterrupt audioInterrupt = {};
-    std::shared_ptr<AudioSession> audioSession = std::make_shared<AudioSession>(pid, strategy, nullptr);
+    std::shared_ptr<AudioSession> audioSession =
+        std::make_shared<AudioSession>(pid, strategy, audioSessionStateMonitor_);
     audioSession->state_ = AudioSessionState::SESSION_ACTIVE;
     audioSession->audioSessionScene_ = AudioSessionScene::MEDIA;
     audioSession->streamsInSession_.clear();
-    sessionService->sessionMap_.insert(std::pair<int32_t, std::shared_ptr<AudioSession>>(pid, audioSession));
-    EXPECT_NO_THROW(sessionService->NotifyAppStateChange(pid, true));
+    audioSessionService_.sessionMap_.insert(std::pair<int32_t, std::shared_ptr<AudioSession>>(pid, audioSession));
+    EXPECT_NO_THROW(audioSessionService_.NotifyAppStateChange(pid, true));
 
     audioSession->streamsInSession_.push_back(audioInterrupt);
-    EXPECT_NO_THROW(sessionService->NotifyAppStateChange(pid, true));
+    EXPECT_NO_THROW(audioSessionService_.NotifyAppStateChange(pid, true));
 
     audioSession->audioSessionScene_ = AudioSessionScene::INVALID;
-    EXPECT_NO_THROW(sessionService->NotifyAppStateChange(pid, true));
+    EXPECT_NO_THROW(audioSessionService_.NotifyAppStateChange(pid, true));
 
     audioSession->state_ = AudioSessionState::SESSION_NEW;
-    EXPECT_NO_THROW(sessionService->NotifyAppStateChange(pid, true));
+    EXPECT_NO_THROW(audioSessionService_.NotifyAppStateChange(pid, true));
 
     audioSession->streamsInSession_.clear();
-    EXPECT_NO_THROW(sessionService->NotifyAppStateChange(pid, true));
+    EXPECT_NO_THROW(audioSessionService_.NotifyAppStateChange(pid, true));
 
     audioSession->audioSessionScene_ = AudioSessionScene::MEDIA;
-    EXPECT_NO_THROW(sessionService->NotifyAppStateChange(pid, true));
+    EXPECT_NO_THROW(audioSessionService_.NotifyAppStateChange(pid, true));
 }
 
 /*
@@ -589,23 +544,20 @@ HWTEST_F(AudioSessionServiceUnitTest, AudioSessionServiceUnitTest_024, TestSize.
 HWTEST_F(AudioSessionServiceUnitTest, RemoveStreamInfoTest, TestSize.Level1)
 {
     int32_t fakePid = 123;
-    std::shared_ptr<AudioSessionService> sessionService = std::make_shared<AudioSessionService>();
-    ASSERT_TRUE(sessionService != nullptr);
-    sessionService->sessionMap_.clear();
-    int ret = sessionService->SetAudioSessionScene(fakePid, AudioSessionScene::MEDIA);
+    int ret = audioSessionService_.SetAudioSessionScene(fakePid, AudioSessionScene::MEDIA);
     EXPECT_EQ(SUCCESS, ret);
 
     AudioInterrupt audioInterrupt = {};
     audioInterrupt.pid = 0;
     audioInterrupt.isAudioSessionInterrupt = true;
     audioInterrupt.streamId = 0;
-    sessionService->RemoveStreamInfo(audioInterrupt);
+    audioSessionService_.RemoveStreamInfo(audioInterrupt.pid, audioInterrupt.streamId);
 
     audioInterrupt.isAudioSessionInterrupt = false;
-    sessionService->RemoveStreamInfo(audioInterrupt);
+    audioSessionService_.RemoveStreamInfo(audioInterrupt.pid, audioInterrupt.streamId);
 
     audioInterrupt.pid = fakePid;
-    sessionService->RemoveStreamInfo(audioInterrupt);
+    audioSessionService_.RemoveStreamInfo(audioInterrupt.pid, audioInterrupt.streamId);
 }
 
 /**
@@ -616,18 +568,11 @@ HWTEST_F(AudioSessionServiceUnitTest, RemoveStreamInfoTest, TestSize.Level1)
 HWTEST_F(AudioSessionServiceUnitTest, ClearStreamInfoTest, TestSize.Level1)
 {
     int32_t fakePid = 123;
-    std::shared_ptr<AudioSessionService> sessionService = std::make_shared<AudioSessionService>();
-    ASSERT_TRUE(sessionService != nullptr);
-    sessionService->sessionMap_.clear();
-    int ret = sessionService->SetAudioSessionScene(fakePid, AudioSessionScene::MEDIA);
+    int ret = audioSessionService_.SetAudioSessionScene(fakePid, AudioSessionScene::MEDIA);
     EXPECT_EQ(SUCCESS, ret);
 
-    sessionService->ClearStreamInfo(0);
-
-    sessionService->sessionMap_[0] = nullptr;
-    sessionService->ClearStreamInfo(0);
-
-    sessionService->ClearStreamInfo(fakePid);
+    audioSessionService_.ClearStreamInfo(0);
+    audioSessionService_.ClearStreamInfo(fakePid);
 }
 
 /**
@@ -638,18 +583,11 @@ HWTEST_F(AudioSessionServiceUnitTest, ClearStreamInfoTest, TestSize.Level1)
 HWTEST_F(AudioSessionServiceUnitTest, SetSessionDefaultOutputDeviceTest, TestSize.Level1)
 {
     int32_t fakePid = 123;
-    std::shared_ptr<AudioSessionService> sessionService = std::make_shared<AudioSessionService>();
-    ASSERT_TRUE(sessionService != nullptr);
-    sessionService->sessionMap_.clear();
-    int ret = sessionService->SetAudioSessionScene(fakePid, AudioSessionScene::MEDIA);
+    int ret = audioSessionService_.SetAudioSessionScene(fakePid, AudioSessionScene::MEDIA);
     EXPECT_EQ(SUCCESS, ret);
 
-    EXPECT_EQ(sessionService->SetSessionDefaultOutputDevice(0, DEVICE_TYPE_INVALID), ERROR_INVALID_PARAM);
-
-    sessionService->sessionMap_[1] = nullptr;
-    EXPECT_EQ(sessionService->SetSessionDefaultOutputDevice(1, DEVICE_TYPE_INVALID), ERROR_INVALID_PARAM);
-
-    EXPECT_EQ(sessionService->SetSessionDefaultOutputDevice(fakePid, DEVICE_TYPE_INVALID), ERROR_INVALID_PARAM);
+    EXPECT_EQ(audioSessionService_.SetSessionDefaultOutputDevice(0, DEVICE_TYPE_INVALID), ERROR_INVALID_PARAM);
+    EXPECT_EQ(audioSessionService_.SetSessionDefaultOutputDevice(fakePid, DEVICE_TYPE_INVALID), ERROR_INVALID_PARAM);
 }
 
 /**
@@ -660,18 +598,11 @@ HWTEST_F(AudioSessionServiceUnitTest, SetSessionDefaultOutputDeviceTest, TestSiz
 HWTEST_F(AudioSessionServiceUnitTest, GetSessionDefaultOutputDeviceTest, TestSize.Level1)
 {
     int32_t fakePid = 100;
-    std::shared_ptr<AudioSessionService> sessionService = std::make_shared<AudioSessionService>();
-    ASSERT_TRUE(sessionService != nullptr);
-    sessionService->sessionMap_.clear();
-    int ret = sessionService->SetAudioSessionScene(fakePid, AudioSessionScene::MEDIA);
+    int ret = audioSessionService_.SetAudioSessionScene(fakePid, AudioSessionScene::MEDIA);
     EXPECT_EQ(SUCCESS, ret);
 
-    EXPECT_EQ(sessionService->GetSessionDefaultOutputDevice(0), DEVICE_TYPE_INVALID);
-
-    sessionService->sessionMap_[1] = nullptr;
-    EXPECT_EQ(sessionService->GetSessionDefaultOutputDevice(1), DEVICE_TYPE_INVALID);
-
-    EXPECT_EQ(sessionService->GetSessionDefaultOutputDevice(fakePid), DEVICE_TYPE_INVALID);
+    EXPECT_EQ(audioSessionService_.GetSessionDefaultOutputDevice(0), DEVICE_TYPE_INVALID);
+    EXPECT_EQ(audioSessionService_.GetSessionDefaultOutputDevice(fakePid), DEVICE_TYPE_INVALID);
 }
 
 /**
@@ -683,24 +614,18 @@ HWTEST_F(AudioSessionServiceUnitTest, IsStreamAllowedToSetDeviceTest, TestSize.L
 {
     int32_t fakePid = 100;
     int32_t fakeSessionId = 100;
-    std::shared_ptr<AudioSessionService> sessionService = std::make_shared<AudioSessionService>();
-    ASSERT_TRUE(sessionService != nullptr);
-    sessionService->sessionMap_.clear();
-    int ret = sessionService->SetAudioSessionScene(fakePid, AudioSessionScene::MEDIA);
+    int ret = audioSessionService_.SetAudioSessionScene(fakePid, AudioSessionScene::MEDIA);
     EXPECT_EQ(SUCCESS, ret);
 
-    EXPECT_TRUE(sessionService->IsStreamAllowedToSetDevice(0));
-
-    sessionService->sessionMap_[1] = nullptr;
-    EXPECT_TRUE(sessionService->IsStreamAllowedToSetDevice(1));
+    EXPECT_TRUE(audioSessionService_.IsStreamAllowedToSetDevice(0));
 
     AudioInterrupt incomingInterrupt = {};
     incomingInterrupt.streamId = fakeSessionId;
-    sessionService->sessionMap_[fakePid]->streamsInSession_.push_back(incomingInterrupt);
-    EXPECT_TRUE(sessionService->IsStreamAllowedToSetDevice(fakeSessionId));
+    audioSessionService_.sessionMap_[fakePid]->streamsInSession_.push_back(incomingInterrupt);
+    EXPECT_TRUE(audioSessionService_.IsStreamAllowedToSetDevice(fakeSessionId));
 
-    sessionService->sessionMap_[fakePid]->state_ = AudioSessionState::SESSION_ACTIVE;
-    EXPECT_TRUE(sessionService->IsStreamAllowedToSetDevice(fakeSessionId));
+    audioSessionService_.sessionMap_[fakePid]->state_ = AudioSessionState::SESSION_ACTIVE;
+    EXPECT_TRUE(audioSessionService_.IsStreamAllowedToSetDevice(fakeSessionId));
 }
 
 /**
@@ -711,18 +636,11 @@ HWTEST_F(AudioSessionServiceUnitTest, IsStreamAllowedToSetDeviceTest, TestSize.L
 HWTEST_F(AudioSessionServiceUnitTest, IsSessionNeedToFetchOutputDeviceTest, TestSize.Level1)
 {
     int32_t fakePid = 100;
-    std::shared_ptr<AudioSessionService> sessionService = std::make_shared<AudioSessionService>();
-    ASSERT_TRUE(sessionService != nullptr);
-    sessionService->sessionMap_.clear();
-    int ret = sessionService->SetAudioSessionScene(fakePid, AudioSessionScene::MEDIA);
+    int ret = audioSessionService_.SetAudioSessionScene(fakePid, AudioSessionScene::MEDIA);
     EXPECT_EQ(SUCCESS, ret);
 
-    EXPECT_FALSE(sessionService->IsSessionNeedToFetchOutputDevice(0));
-
-    sessionService->sessionMap_[1] = nullptr;
-    EXPECT_FALSE(sessionService->IsSessionNeedToFetchOutputDevice(1));
-
-    EXPECT_FALSE(sessionService->IsSessionNeedToFetchOutputDevice(fakePid));
+    EXPECT_FALSE(audioSessionService_.IsSessionNeedToFetchOutputDevice(0));
+    EXPECT_FALSE(audioSessionService_.IsSessionNeedToFetchOutputDevice(fakePid));
 }
 
 /**
@@ -734,36 +652,52 @@ HWTEST_F(AudioSessionServiceUnitTest, NotifyAppStateChangeTest, TestSize.Level1)
 {
     int32_t fakePid = 100;
     int32_t fakeSessionId = 100;
-    std::shared_ptr<AudioSessionService> sessionService = std::make_shared<AudioSessionService>();
-    ASSERT_TRUE(sessionService != nullptr);
-    sessionService->sessionMap_.clear();
-    int ret = sessionService->SetAudioSessionScene(fakePid, AudioSessionScene::MEDIA);
+    int ret = audioSessionService_.SetAudioSessionScene(fakePid, AudioSessionScene::MEDIA);
     EXPECT_EQ(SUCCESS, ret);
 
-    sessionService->NotifyAppStateChange(0, true);
+    audioSessionService_.NotifyAppStateChange(0, true);
+    audioSessionService_.NotifyAppStateChange(fakePid, false);
 
-    sessionService->sessionMap_[1] = nullptr;
-    sessionService->NotifyAppStateChange(1, true);
+    audioSessionService_.sessionMap_[fakePid]->audioSessionScene_ = AudioSessionScene::MEDIA;
+    audioSessionService_.NotifyAppStateChange(fakePid, false);
 
-    sessionService->NotifyAppStateChange(fakePid, false);
+    audioSessionService_.sessionMap_[fakePid]->audioSessionScene_ = AudioSessionScene::INVALID;
+    audioSessionService_.NotifyAppStateChange(fakePid, true);
 
-    sessionService->sessionMap_[fakePid]->audioSessionScene_ = AudioSessionScene::MEDIA;
-    sessionService->NotifyAppStateChange(fakePid, false);
+    audioSessionService_.sessionMap_[fakePid]->state_ = AudioSessionState::SESSION_ACTIVE;
+    audioSessionService_.NotifyAppStateChange(fakePid, true);
 
-    sessionService->sessionMap_[fakePid]->audioSessionScene_ = AudioSessionScene::INVALID;
-    sessionService->NotifyAppStateChange(fakePid, true);
-
-    sessionService->sessionMap_[fakePid]->state_ = AudioSessionState::SESSION_ACTIVE;
-    sessionService->NotifyAppStateChange(fakePid, true);
-
-    sessionService->sessionMap_[fakePid]->audioSessionScene_ = AudioSessionScene::MEDIA;
+    audioSessionService_.sessionMap_[fakePid]->audioSessionScene_ = AudioSessionScene::MEDIA;
     AudioInterrupt incomingInterrupt = {};
     incomingInterrupt.streamId = fakeSessionId;
-    sessionService->sessionMap_[fakePid]->streamsInSession_.push_back(incomingInterrupt);
-    sessionService->NotifyAppStateChange(fakeSessionId, false);
+    audioSessionService_.sessionMap_[fakePid]->streamsInSession_.push_back(incomingInterrupt);
+    audioSessionService_.NotifyAppStateChange(fakeSessionId, false);
+
+    audioSessionService_.sessionMap_[fakePid]->streamsInSession_.clear();
+    audioSessionService_.NotifyAppStateChange(fakeSessionId, false);
+}
 
-    sessionService->sessionMap_[fakePid]->streamsInSession_.clear();
-    sessionService->NotifyAppStateChange(fakeSessionId, false);
+/**
+* @tc.name  : Test IsSystemApp
+* @tc.number: IsSystemAppTest
+* @tc.desc  : Test IsSystemApp
+*/
+HWTEST_F(AudioSessionServiceUnitTest, IsSystemAppTest, TestSize.Level1)
+{
+    int32_t callerPid = 1;
+    audioSessionService_.MarkSystemApp(callerPid);
+    EXPECT_FALSE(audioSessionService_.IsSystemApp(callerPid));
+
+    AudioSessionStrategy strategy;
+    strategy.concurrencyMode = AudioConcurrencyMode::MIX_WITH_OTHERS;
+    auto audioSession = std::make_shared<AudioSession>(callerPid, strategy, audioSessionStateMonitor_);
+    ASSERT_NE(nullptr, audioSession);
+    audioSession->state_ = AudioSessionState::SESSION_ACTIVE;
+    audioSessionService_.sessionMap_[callerPid] = audioSession;
+    EXPECT_FALSE(audioSessionService_.IsSystemApp(callerPid));
+    audioSessionService_.MarkSystemApp(callerPid);
+    EXPECT_TRUE(audioSessionService_.IsSystemApp(callerPid));
+    EXPECT_TRUE(audioSessionService_.IsSystemAppWithMixStrategy(callerPid));
 }
 
 } // namespace AudioStandard
diff --git a/services/audio_policy/test/unittest/audio_session_unit_test/include/audio_session_unit_test.h b/services/audio_policy/test/unittest/audio_session_unit_test/include/audio_session_unit_test.h
index 259cf221f3bf37aa3e72cd49ae552f2db2afa2da..0f71398002389d0ac38ad22be0c0c26f705085e1 100644
--- a/services/audio_policy/test/unittest/audio_session_unit_test/include/audio_session_unit_test.h
+++ b/services/audio_policy/test/unittest/audio_session_unit_test/include/audio_session_unit_test.h
@@ -17,10 +17,16 @@
 #define AUDIO_SESSION_UNIT_TEST_H
 #include "gtest/gtest.h"
 #include "gmock/gmock.h"
+#include "audio_session_state_monitor.h"
 
 namespace OHOS {
 namespace AudioStandard {
 
+class AudioSessionStateMonitorStub : public AudioSessionStateMonitor {
+public:
+    virtual void OnAudioSessionTimeOut(int32_t pid) override {}
+};
+
 class AudioSessionUnitTest : public testing::Test {
 public:
     // SetUpTestCase: Called before all test cases
@@ -31,7 +37,10 @@ public:
     void SetUp(void);
     // TearDown: Called after each test cases
     void TearDown(void);
+private:
+    AudioSessionStateMonitorStub audioSessionStateMonitor_;
 };
+
 } // namespace AudioStandard
 } // namespace OHOS
 #endif //AUDIO_SESSION_UNIT_TEST_H
diff --git a/services/audio_policy/test/unittest/audio_session_unit_test/src/audio_session_unit_test.cpp b/services/audio_policy/test/unittest/audio_session_unit_test/src/audio_session_unit_test.cpp
index 0aa8dda3c86374d315767275360eccb94ed69a67..e83ab585db1025df82ad37a34f4070b34a3e67a2 100644
--- a/services/audio_policy/test/unittest/audio_session_unit_test/src/audio_session_unit_test.cpp
+++ b/services/audio_policy/test/unittest/audio_session_unit_test/src/audio_session_unit_test.cpp
@@ -38,8 +38,7 @@ HWTEST_F(AudioSessionUnitTest, AudioSessionUnitTest_001, TestSize.Level1)
 {
     int32_t callerPid = 1;
     AudioSessionStrategy strategy;
-    std::shared_ptr<AudioSessionStateMonitor> audioSessionStateMonitor = nullptr;
-    auto audioSession = std::make_shared<AudioSession>(callerPid, strategy, audioSessionStateMonitor);
+    auto audioSession = std::make_shared<AudioSession>(callerPid, strategy, audioSessionStateMonitor_);
 
     AudioInterrupt audioInterrupt = {};
     audioInterrupt.streamId = 1;
@@ -58,8 +57,7 @@ HWTEST_F(AudioSessionUnitTest, AudioSessionUnitTest_002, TestSize.Level1)
 {
     int32_t callerPid = 1;
     AudioSessionStrategy strategy;
-    std::shared_ptr<AudioSessionStateMonitor> audioSessionStateMonitor = nullptr;
-    auto audioSession = std::make_shared<AudioSession>(callerPid, strategy, audioSessionStateMonitor);
+    auto audioSession = std::make_shared<AudioSession>(callerPid, strategy, audioSessionStateMonitor_);
 
     AudioInterrupt audioInterrupt = {};
     audioInterrupt.streamId = 1;
@@ -78,8 +76,7 @@ HWTEST_F(AudioSessionUnitTest, AudioSessionUnitTest_003, TestSize.Level1)
 {
     int32_t callerPid = 1;
     AudioSessionStrategy strategy;
-    std::shared_ptr<AudioSessionStateMonitor> audioSessionStateMonitor = std::make_shared<AudioSessionService>();
-    auto audioSession = std::make_shared<AudioSession>(callerPid, strategy, audioSessionStateMonitor);
+    auto audioSession = std::make_shared<AudioSession>(callerPid, strategy, audioSessionStateMonitor_);
 
     AudioInterrupt audioInterrupt = {};
     audioInterrupt.streamId = 10;
@@ -97,8 +94,7 @@ HWTEST_F(AudioSessionUnitTest, AudioSessionUnitTest_004, TestSize.Level1)
 {
     int32_t callerPid = 1;
     AudioSessionStrategy strategy;
-    std::shared_ptr<AudioSessionStateMonitor> audioSessionStateMonitor = nullptr;
-    auto audioSession = std::make_shared<AudioSession>(callerPid, strategy, audioSessionStateMonitor);
+    auto audioSession = std::make_shared<AudioSession>(callerPid, strategy, audioSessionStateMonitor_);
 
     AudioInterrupt audioInterrupt = {};
     audioInterrupt.streamId = 0;
@@ -116,8 +112,7 @@ HWTEST_F(AudioSessionUnitTest, AudioSessionUnitTest_005, TestSize.Level1)
 {
     int32_t callerPid = 1;
     AudioSessionStrategy strategy;
-    std::shared_ptr<AudioSessionStateMonitor> audioSessionStateMonitor = nullptr;
-    auto audioSession = std::make_shared<AudioSession>(callerPid, strategy, audioSessionStateMonitor);
+    auto audioSession = std::make_shared<AudioSession>(callerPid, strategy, audioSessionStateMonitor_);
 
     uint32_t i = 1;
     AudioInterrupt audioInterrupt = {};
@@ -142,8 +137,7 @@ HWTEST_F(AudioSessionUnitTest, AudioSessionUnitTest_006, TestSize.Level1)
 {
     int32_t callerPid = 1;
     AudioSessionStrategy strategy;
-    std::shared_ptr<AudioSessionStateMonitor> audioSessionStateMonitor = std::make_shared<AudioSessionService>();
-    auto audioSession = std::make_shared<AudioSession>(callerPid, strategy, audioSessionStateMonitor);
+    auto audioSession = std::make_shared<AudioSession>(callerPid, strategy, audioSessionStateMonitor_);
 
     uint32_t i = 1;
     AudioInterrupt audioInterrupt = {};
@@ -163,8 +157,7 @@ HWTEST_F(AudioSessionUnitTest, AudioSessionUnitTest_007, TestSize.Level1)
 {
     int32_t callerPid = 1;
     AudioSessionStrategy strategy;
-    std::shared_ptr<AudioSessionStateMonitor> audioSessionStateMonitor = std::make_shared<AudioSessionService>();
-    auto audioSession = std::make_shared<AudioSession>(callerPid, strategy, audioSessionStateMonitor);
+    auto audioSession = std::make_shared<AudioSession>(callerPid, strategy, audioSessionStateMonitor_);
 
     uint32_t streamId = 1;
     AudioInterrupt audioInterrupt = {};
@@ -185,8 +178,7 @@ HWTEST_F(AudioSessionUnitTest, AudioSessionUnitTest_008, TestSize.Level1)
 {
     int32_t callerPid = 1;
     AudioSessionStrategy strategy;
-    std::shared_ptr<AudioSessionStateMonitor> audioSessionStateMonitor = std::make_shared<AudioSessionService>();
-    auto audioSession = std::make_shared<AudioSession>(callerPid, strategy, audioSessionStateMonitor);
+    auto audioSession = std::make_shared<AudioSession>(callerPid, strategy, audioSessionStateMonitor_);
 
     uint32_t streamId = 1;
     AudioInterrupt audioInterrupt = {};
@@ -206,8 +198,7 @@ HWTEST_F(AudioSessionUnitTest, AudioSessionUnitTest_009, TestSize.Level1)
 {
     int32_t callerPid = 1;
     AudioSessionStrategy strategy;
-    std::shared_ptr<AudioSessionStateMonitor> audioSessionStateMonitor = std::make_shared<AudioSessionService>();
-    auto audioSession = std::make_shared<AudioSession>(callerPid, strategy, audioSessionStateMonitor);
+    auto audioSession = std::make_shared<AudioSession>(callerPid, strategy, audioSessionStateMonitor_);
 
     audioSession->fakeStreamId_ = 0;
     audioSession->state_ = AudioSessionState::SESSION_RELEASED;
@@ -218,31 +209,6 @@ HWTEST_F(AudioSessionUnitTest, AudioSessionUnitTest_009, TestSize.Level1)
     EXPECT_EQ(audioSession->EnableDefaultDevice(), 0);
 }
 
-/**
-* @tc.name  : Test ShouldExcludeStreamType.
-* @tc.number: AudioSessionUnitTest_010.
-* @tc.desc  : Test ShouldExcludeStreamType function.
-*/
-HWTEST_F(AudioSessionUnitTest, AudioSessionUnitTest_010, TestSize.Level1)
-{
-    int32_t callerPid = 1;
-    AudioSessionStrategy strategy;
-    std::shared_ptr<AudioSessionStateMonitor> audioSessionStateMonitor = std::make_shared<AudioSessionService>();
-    auto audioSession = std::make_shared<AudioSession>(callerPid, strategy, audioSessionStateMonitor);
-
-    AudioInterrupt audioInterrupt = {};
-    audioInterrupt.audioFocusType.streamType = STREAM_NOTIFICATION;
-    EXPECT_TRUE(audioSession->ShouldExcludeStreamType(audioInterrupt));
-
-
-    audioInterrupt.audioFocusType.streamType = STREAM_MUSIC;
-    audioInterrupt.audioFocusType.sourceType = SOURCE_TYPE_INVALID;
-    EXPECT_FALSE(audioSession->ShouldExcludeStreamType(audioInterrupt));
-
-    audioInterrupt.audioFocusType.sourceType = SOURCE_TYPE_MIC;
-    EXPECT_TRUE(audioSession->ShouldExcludeStreamType(audioInterrupt));
-}
-
 /**
 * @tc.name  : Test SetSessionDefaultOutputDevice
 * @tc.number: AudioSessionUnitTest_011
@@ -252,8 +218,7 @@ HWTEST_F(AudioSessionUnitTest, AudioSessionUnitTest_011, TestSize.Level1)
 {
     int32_t callerPid = 1;
     AudioSessionStrategy strategy;
-    std::shared_ptr<AudioSessionStateMonitor> audioSessionStateMonitor = std::make_shared<AudioSessionService>();
-    auto audioSession = std::make_shared<AudioSession>(callerPid, strategy, audioSessionStateMonitor);
+    auto audioSession = std::make_shared<AudioSession>(callerPid, strategy, audioSessionStateMonitor_);
 
     EXPECT_EQ(audioSession->SetSessionDefaultOutputDevice(DEVICE_TYPE_INVALID), ERROR_INVALID_PARAM);
  
@@ -277,8 +242,7 @@ HWTEST_F(AudioSessionUnitTest, AudioSessionUnitTest_012, TestSize.Level1)
 {
     int32_t callerPid = 1;
     AudioSessionStrategy strategy;
-    std::shared_ptr<AudioSessionStateMonitor> audioSessionStateMonitor = std::make_shared<AudioSessionService>();
-    auto audioSession = std::make_shared<AudioSession>(callerPid, strategy, audioSessionStateMonitor);
+    auto audioSession = std::make_shared<AudioSession>(callerPid, strategy, audioSessionStateMonitor_);
 
     audioSession->streamsInSession_.clear();
     EXPECT_FALSE(audioSession->IsStreamContainedInCurrentSession(0));
@@ -298,17 +262,8 @@ HWTEST_F(AudioSessionUnitTest, AudioSessionUnitTest_013, TestSize.Level1)
 {
     int32_t callerPid = 1;
     AudioSessionStrategy strategy;
-    std::shared_ptr<AudioSessionStateMonitor> audioSessionStateMonitor = std::make_shared<AudioSessionService>();
-    auto audioSession = std::make_shared<AudioSession>(callerPid, strategy, audioSessionStateMonitor);
-
-    EXPECT_FALSE(audioSession->IsRecommendToStopAudio(nullptr));
-
-    std::shared_ptr<AudioPolicyServerHandler::EventContextObj> eventContextObj =
-        std::make_shared<AudioPolicyServerHandler::EventContextObj>();
-    eventContextObj->reason_ = AudioStreamDeviceChangeReason::OVERRODE;
-    eventContextObj->reason_ = AudioStreamDeviceChangeReason::UNKNOWN;
-    eventContextObj->descriptor = nullptr;
-    EXPECT_FALSE(audioSession->IsRecommendToStopAudio(eventContextObj));
+    auto audioSession = std::make_shared<AudioSession>(callerPid, strategy, audioSessionStateMonitor_);
+    EXPECT_FALSE(audioSession->IsRecommendToStopAudio(AudioStreamDeviceChangeReason::UNKNOWN, nullptr));
 }
 
 /**
@@ -320,8 +275,7 @@ HWTEST_F(AudioSessionUnitTest, AudioSessionUnitTest_014, TestSize.Level1)
 {
     int32_t callerPid = 1;
     AudioSessionStrategy strategy;
-    std::shared_ptr<AudioSessionStateMonitor> audioSessionStateMonitor = nullptr;
-    auto audioSession = std::make_shared<AudioSession>(callerPid, strategy, audioSessionStateMonitor);
+    auto audioSession = std::make_shared<AudioSession>(callerPid, strategy, audioSessionStateMonitor_);
 
     AudioInterrupt audioInterrupt = {};
     audioInterrupt.streamId = 1;
@@ -345,8 +299,7 @@ HWTEST_F(AudioSessionUnitTest, AudioSessionUnitTest_015, TestSize.Level1)
 {
     int32_t callerPid = 1;
     AudioSessionStrategy strategy;
-    std::shared_ptr<AudioSessionStateMonitor> audioSessionStateMonitor = std::make_shared<AudioSessionService>();
-    auto audioSession = std::make_shared<AudioSession>(callerPid, strategy, audioSessionStateMonitor);
+    auto audioSession = std::make_shared<AudioSession>(callerPid, strategy, audioSessionStateMonitor_);
 
     AudioSessionScene scene = AudioSessionScene::INVALID;
     int32_t ret = audioSession->SetAudioSessionScene(scene);
@@ -362,15 +315,12 @@ HWTEST_F(AudioSessionUnitTest, AudioSessionUnitTest_016, TestSize.Level1)
 {
     int32_t callerPid = 1;
     AudioSessionStrategy strategy;
-    std::shared_ptr<AudioSessionStateMonitor> audioSessionStateMonitor = std::make_shared<AudioSessionService>();
-    auto audioSession = std::make_shared<AudioSession>(callerPid, strategy, audioSessionStateMonitor);
+    auto audioSession = std::make_shared<AudioSession>(callerPid, strategy, audioSessionStateMonitor_);
     audioSession->IsActivated();
     audioSession->IsSceneParameterSet();
     AudioInterrupt incomingInterrupt;
 
     incomingInterrupt.audioFocusType.streamType = STREAM_NOTIFICATION;
-    EXPECT_TRUE(audioSession->ShouldExcludeStreamType(incomingInterrupt));
-    
     EXPECT_NO_THROW(
         audioSession->AddStreamInfo(incomingInterrupt);
     );
@@ -390,8 +340,7 @@ HWTEST_F(AudioSessionUnitTest, AudioSessionUnitTest_017, TestSize.Level1)
 {
     int32_t callerPid = 1;
     AudioSessionStrategy strategy;
-    std::shared_ptr<AudioSessionStateMonitor> audioSessionStateMonitor = std::make_shared<AudioSessionService>();
-    auto audioSession = std::make_shared<AudioSession>(callerPid, strategy, audioSessionStateMonitor);
+    auto audioSession = std::make_shared<AudioSession>(callerPid, strategy, audioSessionStateMonitor_);
     
     EXPECT_EQ(SUCCESS, audioSession->SetAudioSessionScene(AudioSessionScene::MEDIA));
 
@@ -411,8 +360,7 @@ HWTEST_F(AudioSessionUnitTest, AudioSessionUnitTest_018, TestSize.Level1)
 {
     int32_t callerPid = 1;
     AudioSessionStrategy strategy;
-    std::shared_ptr<AudioSessionStateMonitor> audioSessionStateMonitor = std::make_shared<AudioSessionService>();
-    auto audioSession = std::make_shared<AudioSession>(callerPid, strategy, audioSessionStateMonitor);
+    auto audioSession = std::make_shared<AudioSession>(callerPid, strategy, audioSessionStateMonitor_);
     
     EXPECT_EQ(SUCCESS, audioSession->SetAudioSessionScene(AudioSessionScene::MEDIA));
 
diff --git a/services/audio_policy/test/unittest/audio_zone_service_unit_test/audio_zone_unit_test.cpp b/services/audio_policy/test/unittest/audio_zone_service_unit_test/audio_zone_unit_test.cpp
index 3721e26018cbdf5640b765b9f6f456f8bfd65784..8ca46e5dbb271d9631d76537b0c2d73277b03851 100644
--- a/services/audio_policy/test/unittest/audio_zone_service_unit_test/audio_zone_unit_test.cpp
+++ b/services/audio_policy/test/unittest/audio_zone_service_unit_test/audio_zone_unit_test.cpp
@@ -220,12 +220,13 @@ HWTEST_F(AudioZoneUnitTest, AudioZone_007, TestSize.Level1)
     AudioZoneContext context;
     auto zoneId = AudioZoneService::GetInstance().CreateAudioZone("TestZone1", context, 0);
     AudioZoneService::GetInstance().AddUidToAudioZone(zoneId, 20);
-    std::shared_ptr<AudioSessionService> sessionService = AudioSessionService::GetAudioSessionService();
-    int ret = sessionService->SetAudioSessionScene(fakePid, AudioSessionScene::MEDIA);
+    AudioSessionService &audioSessionService = OHOS::Singleton<AudioSessionService>::GetInstance();
+    int ret = audioSessionService.SetAudioSessionScene(fakePid, AudioSessionScene::MEDIA);
     EXPECT_EQ(SUCCESS, ret);
     ret = AudioZoneService::GetInstance().FindAudioSessionZoneid(fakeUid, fakePid, false);
     EXPECT_EQ(ret, 0);
     AudioZoneService::GetInstance().ReleaseAudioZone(zoneId);
+    audioSessionService.sessionMap_.clear();
 }
 } // namespace AudioStandard
 } // namespace OHOS
\ No newline at end of file
diff --git a/test/fuzztest/audiointerruptservice_fuzzer/audio_interrupt_service_fuzzer.cpp b/test/fuzztest/audiointerruptservice_fuzzer/audio_interrupt_service_fuzzer.cpp
index b000cc2b3352b722ad615739ea4f4280f3d633a0..74c9cdcd03370f8257b6474226b5976bd20a1db8 100644
--- a/test/fuzztest/audiointerruptservice_fuzzer/audio_interrupt_service_fuzzer.cpp
+++ b/test/fuzztest/audiointerruptservice_fuzzer/audio_interrupt_service_fuzzer.cpp
@@ -39,23 +39,26 @@ public:
     void OnInterrupt(const InterruptEventInternal &interruptEvent) override {};
 };
 
-static void CreateAudioSessionService(shared_ptr<AudioInterruptService> &interruptService, bool isNull, int32_t id)
-{
-    if (interruptService == nullptr) {
-        return;
-    }
-    interruptService->sessionService_ = std::make_shared<AudioSessionService>();
-    if (isNull) {
-        interruptService->sessionService_ = nullptr;
-        return;
-    }
-    if (interruptService->sessionService_ == nullptr) {
-        return;
-    }
-    AudioSessionStrategy strategy;
-    interruptService->sessionService_->sessionMap_.insert(
-        std::make_pair(id, std::make_shared<AudioSession>(id, strategy, make_shared<AudioSessionService>())));
-}
+class AudioSessionServiceBuilder {
+public:
+    AudioSessionServiceBuilder(shared_ptr<AudioInterruptService> &interruptService, int32_t id)
+    {
+        if (interruptService == nullptr) {
+            return;
+        }
+        AudioSessionStrategy strategy;
+        interruptService->sessionService_.sessionMap_.insert(
+            std::make_pair(id, std::make_shared<AudioSession>(id, strategy, audioSessionService_)));
+    }
+
+    ~AudioSessionServiceBuilder()
+    {
+        audioSessionService_.sessionMap_.clear();
+        audioSessionService_.timeOutCallback_.reset();
+    }
+private:
+    AudioSessionService &audioSessionService_ {OHOS::Singleton<AudioSessionService>::GetInstance()};
+};
 
 void InitFuzzTest(const uint8_t *rawData, size_t size)
 {
@@ -375,7 +378,7 @@ void AudioInterruptServiceActivateAudioSessionFuzzTest(const uint8_t *rawData, s
     int32_t zoneId = *reinterpret_cast<const int32_t *>(rawData);
     int32_t callerPid = *reinterpret_cast<const int32_t *>(rawData);
     AudioSessionStrategy strategy;
-    CreateAudioSessionService(interruptService, false, callerPid);
+    AudioSessionServiceBuilder(interruptService, callerPid);
 
     interruptService->ActivateAudioSession(zoneId, callerPid, strategy);
 }
@@ -390,10 +393,10 @@ void AudioInterruptServiceIsSessionNeedToFetchOutputDeviceFuzzTest(const uint8_t
     if (interruptService == nullptr) {
         return;
     }
-    bool isNullptr = (*reinterpret_cast<const uint32_t *>(rawData)) % BOOL_MODULO;
+
     int32_t callerPid = *reinterpret_cast<const int32_t *>(rawData);
-    CreateAudioSessionService(interruptService, !isNullptr, callerPid);
-    interruptService->IsSessionNeedToFetchOutputDevice(callerPid);
+    AudioSessionServiceBuilder(interruptService, callerPid);
+    interruptService->sessionService_.IsSessionNeedToFetchOutputDevice(callerPid);
 }
 
 void AudioInterruptServiceSetAudioSessionSceneFuzzTest(const uint8_t *rawData, size_t size)
@@ -406,9 +409,9 @@ void AudioInterruptServiceSetAudioSessionSceneFuzzTest(const uint8_t *rawData, s
     if (interruptService == nullptr) {
         return;
     }
-    bool isNullptr = (*reinterpret_cast<const uint32_t *>(rawData)) % BOOL_MODULO;
+
     int32_t callerPid = *reinterpret_cast<const int32_t *>(rawData);
-    CreateAudioSessionService(interruptService, !isNullptr, callerPid);
+    AudioSessionServiceBuilder(interruptService, callerPid);
     AudioSessionScene scene = AudioSessionScene::INVALID;
     interruptService->SetAudioSessionScene(callerPid, scene);
 }
@@ -423,9 +426,9 @@ void AudioInterruptServiceAddActiveInterruptToSessionFuzzTest(const uint8_t *raw
     if (interruptService == nullptr) {
         return;
     }
-    bool isNullptr = (*reinterpret_cast<const uint32_t *>(rawData)) % BOOL_MODULO;
+
     int32_t callerPid = *reinterpret_cast<const int32_t *>(rawData);
-    CreateAudioSessionService(interruptService, !isNullptr, callerPid);
+    AudioSessionServiceBuilder(interruptService, callerPid);
     interruptService->AddActiveInterruptToSession(callerPid);
 }
 
@@ -439,10 +442,10 @@ void AudioInterruptServiceDeactivateAudioSessionFuzzTest(const uint8_t *rawData,
     if (interruptService == nullptr) {
         return;
     }
-    bool isNullptr = (*reinterpret_cast<const uint32_t *>(rawData)) % BOOL_MODULO;
+
     int32_t zoneId = *reinterpret_cast<const int32_t *>(rawData);
     int32_t callerPid = *reinterpret_cast<const int32_t *>(rawData);
-    CreateAudioSessionService(interruptService, !isNullptr, callerPid);
+    AudioSessionServiceBuilder(interruptService, callerPid);
     interruptService->zonesMap_.insert(std::make_pair(zoneId, std::make_shared<AudioInterruptZone>()));
     interruptService->DeactivateAudioSession(zoneId, callerPid);
 }
@@ -458,7 +461,7 @@ void AudioInterruptServiceRemovePlaceholderInterruptForSessionFuzzTest(const uin
         return;
     }
     int32_t callerPid = *reinterpret_cast<const int32_t *>(rawData);
-    CreateAudioSessionService(interruptService, false, callerPid);
+    AudioSessionServiceBuilder(interruptService, callerPid);
     bool isSessionTimeout = (*reinterpret_cast<const uint32_t *>(rawData)) % BOOL_MODULO;
     interruptService->RemovePlaceholderInterruptForSession(callerPid, isSessionTimeout);
 }
@@ -473,10 +476,9 @@ void AudioInterruptServiceIsAudioSessionActivatedFuzzTest(const uint8_t *rawData
     if (interruptService == nullptr) {
         return;
     }
-    bool isNullptr = (*reinterpret_cast<const uint32_t *>(rawData)) % BOOL_MODULO;
 
     int32_t callerPid = *reinterpret_cast<const int32_t *>(rawData);
-    CreateAudioSessionService(interruptService, !isNullptr, callerPid);
+    AudioSessionServiceBuilder(interruptService, callerPid);
     interruptService->IsAudioSessionActivated(callerPid);
 }
 
@@ -545,7 +547,7 @@ void AudioInterruptServiceCanMixForIncomingSessionFuzzTest(const uint8_t *rawDat
     AudioInterrupt activeInterrupt;
     incomingInterrupt.pid = *reinterpret_cast<const int32_t *>(rawData);
     AudioFocusEntry focusEntry;
-    CreateAudioSessionService(interruptService, false, incomingInterrupt.pid);
+    AudioSessionServiceBuilder(interruptService, incomingInterrupt.pid);
     interruptService->CanMixForIncomingSession(incomingInterrupt, activeInterrupt, focusEntry);
 }
 
@@ -703,8 +705,8 @@ void AudioInterruptServiceHandleAppStreamTypeFuzzTest(const uint8_t *rawData, si
     }
     AudioInterrupt audioInterrupt;
     audioInterrupt.pid = *reinterpret_cast<const int32_t *>(rawData);
-    bool isNull = (*reinterpret_cast<const uint32_t *>(rawData)) % BOOL_MODULO;
-    CreateAudioSessionService(interruptService, !isNull, audioInterrupt.pid);
+
+    AudioSessionServiceBuilder(interruptService, audioInterrupt.pid);
     interruptService->HandleAppStreamType(0, audioInterrupt);
 }
 
@@ -720,7 +722,7 @@ void AudioInterruptServiceActivateAudioInterruptFuzzTest(const uint8_t *rawData,
     }
     int32_t zoneId = *reinterpret_cast<const int32_t *>(rawData);
     AudioInterrupt audioInterrupt;
-    CreateAudioSessionService(interruptService, false, zoneId);
+    AudioSessionServiceBuilder(interruptService, zoneId);
     bool isUpdatedAudioStrategy = (*reinterpret_cast<const uint32_t *>(rawData)) % BOOL_MODULO;
     interruptService->isPreemptMode_ = !((*reinterpret_cast<const uint32_t *>(rawData)) % BOOL_MODULO);
     interruptService->ActivateAudioInterrupt(zoneId, audioInterrupt, isUpdatedAudioStrategy);
@@ -746,7 +748,7 @@ void AudioInterruptServicePrintLogsOfFocusStrategyBaseMusicFuzzTest(const uint8_
     }
 
     AudioInterrupt audioInterrupt;
-    CreateAudioSessionService(interruptService, true, 0);
+    AudioSessionServiceBuilder(interruptService, 0);
     AudioFocusType audioFocusType;
     audioFocusType.streamType = AudioStreamType::STREAM_MUSIC;
     std::pair<AudioFocusType, AudioFocusType> focusPair = std::make_pair(audioFocusType, audioInterrupt.audioFocusType);
@@ -909,26 +911,6 @@ void AudioInterruptServiceIsSameAppInShareModeFuzzTest(const uint8_t *rawData, s
     interruptService->IsSameAppInShareMode(incomingInterrupt, activeInterrupt);
 }
 
-void AudioInterruptServiceCheckAudioSessionExistenceFuzzTest(const uint8_t *rawData, size_t size)
-{
-    if (rawData == nullptr || size < LIMITSIZE) {
-        return;
-    }
-
-    std::shared_ptr<AudioInterruptService> interruptService = std::make_shared<AudioInterruptService>();
-    if (interruptService == nullptr) {
-        return;
-    }
-    AudioInterrupt incomingInterrupt;
-    incomingInterrupt.mode = INDEPENDENT_MODE;
-    incomingInterrupt.pid = *reinterpret_cast<const int32_t *>(rawData);
-    AudioFocusEntry focusEntry;
-    focusEntry.isReject = (*reinterpret_cast<const uint32_t *>(rawData)) % BOOL_MODULO;
-    CreateAudioSessionService(interruptService, !focusEntry.isReject, incomingInterrupt.pid);
-
-    interruptService->CheckAudioSessionExistence(incomingInterrupt, focusEntry);
-}
-
 void AudioInterruptServiceUpdateHintTypeForExistingSessionFuzzTest(const uint8_t *rawData, size_t size)
 {
     if (rawData == nullptr || size < LIMITSIZE) {
@@ -1006,24 +988,19 @@ void AudioInterruptServiceHandleLowPriorityEventFuzzTest(const uint8_t *rawData,
     }
 
     std::shared_ptr<AudioInterruptService> interruptService = std::make_shared<AudioInterruptService>();
-    std::shared_ptr<AudioSessionService> sessionService = std::make_shared<AudioSessionService>();
-    if (interruptService == nullptr || sessionService == nullptr) {
+    if (interruptService == nullptr) {
         return;
     }
     int32_t pid = *reinterpret_cast<const int32_t *>(rawData);
     int32_t streamId = *reinterpret_cast<const int32_t *>(rawData);
-    sessionService->SetAudioSessionScene(pid, *reinterpret_cast<const AudioSessionScene *>(rawData));
-    if (sessionService->sessionMap_[pid] == nullptr) {
+    interruptService->SetAudioSessionScene(pid, *reinterpret_cast<const AudioSessionScene *>(rawData));
+    if (interruptService->sessionService_.sessionMap_[pid] == nullptr) {
         return;
     }
-    sessionService->sessionMap_[pid]->audioSessionScene_ = *reinterpret_cast<const AudioSessionScene *>(rawData);
-    sessionService->sessionMap_[pid]->state_ = *reinterpret_cast<const AudioSessionState *>(rawData);
-    interruptService->sessionService_ = sessionService;
+    interruptService->sessionService_.sessionMap_[pid]->audioSessionScene_ =
+        *reinterpret_cast<const AudioSessionScene *>(rawData);
+    interruptService->sessionService_.sessionMap_[pid]->state_ = *reinterpret_cast<const AudioSessionState *>(rawData);
     interruptService->handler_ = make_shared<AudioPolicyServerHandler>();
-    bool isNull = (*reinterpret_cast<const uint32_t *>(rawData)) % BOOL_MODULO;
-    if (isNull) {
-        interruptService->sessionService_ = nullptr;
-    }
     interruptService->HandleLowPriorityEvent(pid, streamId);
 }
 
@@ -1264,23 +1241,7 @@ void DeactivateAudioSessionFakeInterruptFuzzTest(const uint8_t *rawData, size_t
     int32_t zoneId = *reinterpret_cast<const int32_t *>(rawData);
     int32_t callerPid = *reinterpret_cast<const int32_t *>(rawData);
     bool isSessionTimeout = (*reinterpret_cast<const uint32_t *>(rawData)) % BOOL_MODULO;
-    interruptService->DeactivateAudioSessionFakeInterrupt(zoneId, callerPid, isSessionTimeout);
-}
- 
-void AudioSessionInfoDumpFuzzTest(const uint8_t *rawData, size_t size)
-{
-    if (rawData == nullptr || size < LIMITSIZE) {
-        return;
-    }
-    std::shared_ptr<AudioInterruptService> interruptService = std::make_shared<AudioInterruptService>();
-    if (interruptService == nullptr) {
-        return;
-    }
-    std::string dumpString = "";
-    if (interruptService == nullptr) {
-        return;
-    }
-    interruptService->AudioSessionInfoDump(dumpString);
+    interruptService->DeactivateAudioSessionFakeInterrupt(zoneId, callerPid);
 }
  
 void SetSessionMuteStateFuzzTest(const uint8_t *rawData, size_t size)
@@ -1392,7 +1353,7 @@ void CanMixForActiveSessionFuzzTest(const uint8_t *rawData, size_t size)
     AudioInterrupt activeInterrupt;
     incomingInterrupt.pid = *reinterpret_cast<const int32_t *>(rawData);
     AudioFocusEntry focusEntry;
-    CreateAudioSessionService(interruptService, false, incomingInterrupt.pid);
+    AudioSessionServiceBuilder(interruptService, incomingInterrupt.pid);
     interruptService->CanMixForActiveSession(incomingInterrupt, activeInterrupt, focusEntry);
 }
 } // namespace AudioStandard
@@ -1444,7 +1405,6 @@ OHOS::AudioStandard::TestPtr g_testPtrs[] = {
     OHOS::AudioStandard::AudioInterruptServiceGetStreamInFocusByUidFuzzTest,
     OHOS::AudioStandard::AudioInterruptServiceGetSessionInfoInFocusFuzzTest,
     OHOS::AudioStandard::AudioInterruptServiceIsSameAppInShareModeFuzzTest,
-    OHOS::AudioStandard::AudioInterruptServiceCheckAudioSessionExistenceFuzzTest,
     OHOS::AudioStandard::AudioInterruptServiceUpdateHintTypeForExistingSessionFuzzTest,
     OHOS::AudioStandard::AudioInterruptServiceProcessRemoteInterruptFuzzTest,
     OHOS::AudioStandard::AudioInterruptServiceProcessActiveInterruptFuzzTest,
@@ -1463,7 +1423,6 @@ OHOS::AudioStandard::TestPtr g_testPtrs[] = {
     OHOS::AudioStandard::ClearAudioFocusBySessionIDFuzzTest,
     OHOS::AudioStandard::DeactivateAudioSessionInFakeFocusModeFuzzTest,
     OHOS::AudioStandard::DeactivateAudioSessionFakeInterruptFuzzTest,
-    OHOS::AudioStandard::AudioSessionInfoDumpFuzzTest,
     OHOS::AudioStandard::SetSessionMuteStateFuzzTest,
     OHOS::AudioStandard::SetLatestMuteStateFuzzTest,
     OHOS::AudioStandard::UpdateMuteAudioFocusStrategyFuzzTest,
diff --git a/test/fuzztest/audiointerruptzone_fuzzer/audio_interrupt_zone_fuzzer.cpp b/test/fuzztest/audiointerruptzone_fuzzer/audio_interrupt_zone_fuzzer.cpp
index d4bb36147853786198a3917008542ae54e1cf916..16798880867bc732326fd89b4b95276f782937e8 100644
--- a/test/fuzztest/audiointerruptzone_fuzzer/audio_interrupt_zone_fuzzer.cpp
+++ b/test/fuzztest/audiointerruptzone_fuzzer/audio_interrupt_zone_fuzzer.cpp
@@ -81,7 +81,7 @@ void AudioInterruptZoneManagerForceStopAudioFocusInZoneFuzzTest()
     if (audioInterruptZoneManager->service_ == nullptr) {
         return;
     }
-    audioInterruptZoneManager->service_->sessionService_ = std::make_shared<AudioSessionService>();
+
     audioInterruptZoneManager->service_->handler_ = std::make_shared<AudioPolicyServerHandler>();
     int32_t zoneId = g_fuzzUtils.GetData<int32_t>();
     AudioInterrupt interrupt;
diff --git a/test/fuzztest/audiosession_fuzzer/audio_session_fuzzer.cpp b/test/fuzztest/audiosession_fuzzer/audio_session_fuzzer.cpp
index c92b92edb4195b5ce9a9987a0df05c0ba40c2856..e2b073243cd2f7aba88111e9c3e4c905bfe290f6 100644
--- a/test/fuzztest/audiosession_fuzzer/audio_session_fuzzer.cpp
+++ b/test/fuzztest/audiosession_fuzzer/audio_session_fuzzer.cpp
@@ -30,12 +30,8 @@ typedef void (*TestFuncs)();
 std::shared_ptr<AudioSession> CreateAudioSession()
 {
     AudioSessionStrategy strategy;
-    std::shared_ptr<AudioSessionStateMonitor> audioSessionStateMonitor = nullptr;
-    if (g_fuzzUtils.GetData<bool>()) {
-        auto audioSessionService = std::make_shared<AudioSessionService>();
-        audioSessionStateMonitor = std::static_pointer_cast<AudioSessionStateMonitor>(audioSessionService);
-    }
-    return std::make_shared<AudioSession>(g_fuzzUtils.GetData<int32_t>(), strategy, audioSessionStateMonitor);
+    auto &audioSessionService = OHOS::Singleton<AudioSessionService>::GetInstance();
+    return std::make_shared<AudioSession>(g_fuzzUtils.GetData<int32_t>(), strategy, audioSessionService);
 }
 
 void SetAudioSessionSceneFuzzTest()
@@ -210,15 +206,6 @@ void GetSessionStrategyFuzzTest()
     audioSession->GetSessionStrategy();
 }
 
-void ShouldExcludeStreamTypeFuzzTest()
-{
-    auto audioSession = CreateAudioSession();
-    CHECK_AND_RETURN(audioSession != nullptr);
-    AudioInterrupt audioInterrupt;
-    audioInterrupt.audioFocusType.streamType = g_fuzzUtils.GetData<AudioStreamType>();
-    audioSession->ShouldExcludeStreamType(audioInterrupt);
-}
-
 void IsAudioRendererEmptyFuzzTest()
 {
     auto audioSession = CreateAudioSession();
@@ -260,7 +247,8 @@ void IsRecommendToStopAudioFuzzTest()
 {
     auto audioSession = CreateAudioSession();
     CHECK_AND_RETURN(audioSession != nullptr);
-    audioSession->IsRecommendToStopAudio(std::make_shared<AudioPolicyServerHandler::EventContextObj>());
+    audioSession->IsRecommendToStopAudio(
+        AudioStreamDeviceChangeReason::OVERRODE, std::make_shared<AudioDeviceDescriptor>());
 }
 
 void IsSessionOutputDeviceChangedFuzzTest()
@@ -304,7 +292,6 @@ vector<TestFuncs> g_testFuncs = {
     EnableDefaultDeviceFuzzTest,
     GetStreamUsageInnerFuzzTest,
     GetSessionStrategyFuzzTest,
-    ShouldExcludeStreamTypeFuzzTest,
     IsAudioRendererEmptyFuzzTest,
     GetSessionDefaultOutputDeviceFuzzTest,
     IsStreamContainedInCurrentSessionFuzzTest,
diff --git a/test/fuzztest/audiosessionservice_fuzzer/audio_session_service_fuzzer.cpp b/test/fuzztest/audiosessionservice_fuzzer/audio_session_service_fuzzer.cpp
index d80687c526e5e234bc508a823c04004e1a5b3eef..3f0d5527433c3624559122b1e7376ac9b9f0aa0c 100644
--- a/test/fuzztest/audiosessionservice_fuzzer/audio_session_service_fuzzer.cpp
+++ b/test/fuzztest/audiosessionservice_fuzzer/audio_session_service_fuzzer.cpp
@@ -91,126 +91,99 @@ T GetData()
     return object;
 }
 
+class AudioSessionServiceBuilder {
+public:
+    AudioSessionService& GetAudioSessionService()
+    {
+        return audioSessionService_;
+    }
+
+    AudioSessionServiceBuilder()
+    {
+    }
+
+    ~AudioSessionServiceBuilder()
+    {
+        audioSessionService_.sessionMap_.clear();
+        audioSessionService_.timeOutCallback_.reset();
+    }
+private:
+    AudioSessionService &audioSessionService_ {OHOS::Singleton<AudioSessionService>::GetInstance()};
+};
+
+
 void AudioSessionServiceIsSameTypeForAudioSessionFuzzTest()
 {
-    auto audioSessionService = std::make_shared<AudioSessionService>();
-    if (g_testAudioStreamTypes.size() == 0 || audioSessionService == nullptr) {
+    auto &audioSessionService = AudioSessionServiceBuilder().GetAudioSessionService();
+    if (g_testAudioStreamTypes.size() == 0) {
         return;
     }
     AudioStreamType incomingType = g_testAudioStreamTypes[GetData<uint32_t>() % g_testAudioStreamTypes.size()];
     AudioStreamType existedType = g_testAudioStreamTypes[GetData<uint32_t>() % g_testAudioStreamTypes.size()];
-    audioSessionService->IsSameTypeForAudioSession(incomingType, existedType);
+    audioSessionService.IsSameTypeForAudioSession(incomingType, existedType);
 }
 
 void AudioSessionServiceActivateAudioSessionFuzzTest()
 {
-    auto audioSessionService = std::make_shared<AudioSessionService>();
-    if (audioSessionService == nullptr) {
-        return;
-    }
+    auto &audioSessionService = AudioSessionServiceBuilder().GetAudioSessionService();
     int32_t callerPid = GetData<int32_t>();
     AudioSessionStrategy strategy;
-    std::shared_ptr<AudioSessionStateMonitor> audioSessionStateMonitor = nullptr;
-    auto audioSession = std::make_shared<AudioSession>(callerPid, strategy, audioSessionStateMonitor);
-    bool ifNull = GetData<bool>();
-    if (ifNull) {
-        audioSession = nullptr;
-    }
-    audioSessionService->sessionMap_.insert(make_pair(callerPid, audioSession));
-    audioSessionService->ActivateAudioSession(callerPid, strategy);
+    auto audioSession = std::make_shared<AudioSession>(callerPid, strategy, audioSessionService);
+    audioSessionService.sessionMap_.insert(make_pair(callerPid, audioSession));
+    audioSessionService.ActivateAudioSession(callerPid, strategy);
 }
 
 void AudioSessionServiceDeactivateAudioSessionFuzzTest()
 {
-    auto audioSessionService = std::make_shared<AudioSessionService>();
-    if (audioSessionService == nullptr) {
-        return;
-    }
+    auto &audioSessionService = AudioSessionServiceBuilder().GetAudioSessionService();
     int32_t callerPid = GetData<int32_t>();
     AudioSessionStrategy strategy;
-    std::shared_ptr<AudioSessionStateMonitor> audioSessionStateMonitor = nullptr;
-    auto audioSession = std::make_shared<AudioSession>(callerPid, strategy, audioSessionStateMonitor);
+    auto audioSession = std::make_shared<AudioSession>(callerPid, strategy, audioSessionService);
     bool isAddMap = GetData<bool>();
     if (isAddMap) {
-        audioSessionService->sessionMap_.insert(make_pair(callerPid, audioSession));
+        audioSessionService.sessionMap_.insert(make_pair(callerPid, audioSession));
     }
-    audioSessionService->DeactivateAudioSession(callerPid);
+    audioSessionService.DeactivateAudioSession(callerPid);
 }
 
 void AudioSessionServiceIsAudioSessionActivatedFuzzTest()
 {
-    auto audioSessionService = std::make_shared<AudioSessionService>();
-    if (audioSessionService == nullptr) {
-        return;
-    }
+    auto &audioSessionService = AudioSessionServiceBuilder().GetAudioSessionService();
     int32_t callerPid = GetData<int32_t>();
     AudioSessionStrategy strategy;
-    std::shared_ptr<AudioSessionStateMonitor> audioSessionStateMonitor = nullptr;
-    auto audioSession = std::make_shared<AudioSession>(callerPid, strategy, audioSessionStateMonitor);
+    auto audioSession = std::make_shared<AudioSession>(callerPid, strategy, audioSessionService);
     bool isAddMap = GetData<bool>();
     if (isAddMap) {
-        audioSessionService->sessionMap_.insert(make_pair(callerPid, audioSession));
+        audioSessionService.sessionMap_.insert(make_pair(callerPid, audioSession));
     }
-    audioSessionService->IsAudioSessionActivated(callerPid);
+    audioSessionService.IsAudioSessionActivated(callerPid);
 }
 
 void AudioSessionServiceSetSessionTimeOutCallbackFuzzTest()
 {
-    auto audioSessionService = std::make_shared<AudioSessionService>();
-    if (audioSessionService == nullptr) {
-        return;
-    }
+    auto &audioSessionService = AudioSessionServiceBuilder().GetAudioSessionService();
 
     std::shared_ptr<SessionTimeOutCallback> timeOutCallback = nullptr;
-    audioSessionService->SetSessionTimeOutCallback(timeOutCallback);
-}
-
-void AudioSessionServiceGetAudioSessionByPidFuzzTest()
-{
-    auto audioSessionService = std::make_shared<AudioSessionService>();
-    if (audioSessionService == nullptr) {
-        return;
-    }
-    int32_t callerPid = GetData<int32_t>();
-    AudioSessionStrategy strategy;
-    std::shared_ptr<AudioSessionStateMonitor> audioSessionStateMonitor = nullptr;
-    auto audioSession = std::make_shared<AudioSession>(callerPid, strategy, audioSessionStateMonitor);
-    bool isAddMap = GetData<bool>();
-    if (isAddMap) {
-        audioSessionService->sessionMap_.insert(make_pair(callerPid, audioSession));
-    }
-
-    audioSessionService->GetAudioSessionByPid(callerPid);
+    audioSessionService.SetSessionTimeOutCallback(timeOutCallback);
 }
 
 void AudioSessionServiceOnAudioSessionTimeOutFuzzTest()
 {
-    auto audioSessionService = std::make_shared<AudioSessionService>();
-    if (audioSessionService == nullptr) {
-        return;
-    }
+    auto &audioSessionService = AudioSessionServiceBuilder().GetAudioSessionService();
     int32_t callerPid = GetData<int32_t>();
 
-    audioSessionService->OnAudioSessionTimeOut(callerPid);
+    audioSessionService.OnAudioSessionTimeOut(callerPid);
 }
 
 void AudioSessionServiceAudioSessionInfoDumpFuzzTest()
 {
-    auto audioSessionService = std::make_shared<AudioSessionService>();
-    if (audioSessionService == nullptr) {
-        return;
-    }
+    auto &audioSessionService = AudioSessionServiceBuilder().GetAudioSessionService();
     int32_t callerPid = GetData<int32_t>();
     std::string dumpString = "test";
     AudioSessionStrategy strategy;
-    std::shared_ptr<AudioSessionStateMonitor> audioSessionStateMonitor = nullptr;
-    auto audioSession = std::make_shared<AudioSession>(callerPid, strategy, audioSessionStateMonitor);
-    bool isNull = GetData<bool>();
-    if (isNull) {
-        audioSession = nullptr;
-    }
-    audioSessionService->sessionMap_.insert(make_pair(callerPid, audioSession));
-    audioSessionService->AudioSessionInfoDump(dumpString);
+    auto audioSession = std::make_shared<AudioSession>(callerPid, strategy, audioSessionService);
+    audioSessionService.sessionMap_.insert(make_pair(callerPid, audioSession));
+    audioSessionService.AudioSessionInfoDump(dumpString);
 }
 
 TestPtr g_testPtrs[] = {
@@ -219,7 +192,6 @@ TestPtr g_testPtrs[] = {
     AudioSessionServiceDeactivateAudioSessionFuzzTest,
     AudioSessionServiceIsAudioSessionActivatedFuzzTest,
     AudioSessionServiceSetSessionTimeOutCallbackFuzzTest,
-    AudioSessionServiceGetAudioSessionByPidFuzzTest,
     AudioSessionServiceOnAudioSessionTimeOutFuzzTest,
     AudioSessionServiceAudioSessionInfoDumpFuzzTest,
 };