diff --git a/frameworks/js/napi/common/napi_audio_enum.cpp b/frameworks/js/napi/common/napi_audio_enum.cpp
index c5fcfdf3fa84810b312c7297c6967923f68666c7..cb064b138699e2d3767b9106744a99204ded7b2f 100644
--- a/frameworks/js/napi/common/napi_audio_enum.cpp
+++ b/frameworks/js/napi/common/napi_audio_enum.cpp
@@ -514,7 +514,7 @@ const std::map<std::string, int32_t> NapiAudioEnum::audioLoopbackStatusMap = {
 const std::map<std::string, int32_t> NapiAudioEnum::audioLoopbackReverbPresetMap = {
     {"ORIGINAL", REVERB_PRESET_ORIGINAL},
     {"KTV", REVERB_PRESET_KTV},
-    {"THEATRE", REVERB_PRESET_THEATRE},
+    {"THEATER", REVERB_PRESET_THEATER},
     {"CONCERT", REVERB_PRESET_CONCERT},
 };
 
@@ -1868,7 +1868,7 @@ bool NapiAudioEnum::IsLegalInputArgumentAudioLoopbackReverbPreset(int32_t preset
     switch (preset) {
         case AudioLoopbackReverbPreset::REVERB_PRESET_ORIGINAL:
         case AudioLoopbackReverbPreset::REVERB_PRESET_KTV:
-        case AudioLoopbackReverbPreset::REVERB_PRESET_THEATRE:
+        case AudioLoopbackReverbPreset::REVERB_PRESET_THEATER:
         case AudioLoopbackReverbPreset::REVERB_PRESET_CONCERT:
             result = true;
             break;
diff --git a/frameworks/native/audioloopback/include/audio_loopback_private.h b/frameworks/native/audioloopback/include/audio_loopback_private.h
index fa66003cdd888cf6a7d19d6d683e1b2b39e7745d..9a8e79c8e4ceab047736db5d4285bc6b950b977a 100644
--- a/frameworks/native/audioloopback/include/audio_loopback_private.h
+++ b/frameworks/native/audioloopback/include/audio_loopback_private.h
@@ -86,7 +86,9 @@ private:
     bool CheckDeviceSupport();
     bool EnableLoopback();
     void DisableLoopback();
+    void StartAudioLoopback();
     AudioLoopbackStatus StateToStatus(AudioLoopbackState state);
+    bool SetKaraokeParameters(const std::string &parameters);
 
     AudioRendererOptions rendererOptions_;
     AudioCapturerOptions capturerOptions_;
@@ -107,7 +109,7 @@ private:
     std::atomic<CapturerState> capturerState_ = CAPTURER_INVALID;
     std::atomic<bool> isCapturerUsb_ = false;
     std::atomic<FastStatus> capturerFastStatus_ = FASTSTATUS_NORMAL;
-    AudioLoopbackReverbPreset currentReverbPreset_ = REVERB_PRESET_THEATRE;
+    AudioLoopbackReverbPreset currentReverbPreset_ = REVERB_PRESET_THEATER;
     AudioLoopbackEqualizerPreset currentEqualizerPreset_ = EQUALIZER_PRESET_FULL;
 };
 }  // namespace AudioStandard
diff --git a/frameworks/native/audioloopback/src/audio_loopback.cpp b/frameworks/native/audioloopback/src/audio_loopback.cpp
index 47a77b0c28679f14fbd9793c0bdd80b8b252dd1a..4051b33c2f5bc71e8a89ecd1acd3a94ba3921b72 100644
--- a/frameworks/native/audioloopback/src/audio_loopback.cpp
+++ b/frameworks/native/audioloopback/src/audio_loopback.cpp
@@ -33,7 +33,7 @@ namespace {
     const std::map<AudioLoopbackReverbPreset, std::string> audioLoopbackReverbPresetMap = {
         {REVERB_PRESET_ORIGINAL, "disable"},
         {REVERB_PRESET_KTV, "ktv"},
-        {REVERB_PRESET_THEATRE, "theatre"},
+        {REVERB_PRESET_THEATER, "theatre"},
         {REVERB_PRESET_CONCERT, "concert"},
     };
     const std::map<AudioLoopbackEqualizerPreset, std::string> audioLoopbackEqualizerPresetMap = {
@@ -90,16 +90,25 @@ bool AudioLoopbackPrivate::Enable(bool enable)
 {
     Trace trace("AudioLoopbackPrivate::Enable");
     std::lock_guard<std::mutex> lock(loopbackMutex_);
-    CHECK_AND_RETURN_RET_LOG(IsAudioLoopbackSupported(), false, "AudioLoopback not support");
+    if (!IsAudioLoopbackSupported()) {
+        HILOG_COMM_INFO("AudioLoopback not support");
+        return false;
+    }
     AUDIO_INFO_LOG("Enable %{public}d, currentState_ %{public}d", enable, currentState_);
     if (enable) {
         CHECK_AND_RETURN_RET_LOG(GetCurrentState() != LOOPBACK_STATE_RUNNING, true, "AudioLoopback already running");
         InitStatus();
-        CHECK_AND_RETURN_RET_LOG(CheckDeviceSupport(), false, "Device not support");
+        if (!CheckDeviceSupport()) {
+            HILOG_COMM_INFO("Device not support");
+            return false;
+        }
         CreateAudioLoopback();
         currentState_ = LOOPBACK_STATE_PREPARED;
         UpdateStatus();
-        CHECK_AND_RETURN_RET_LOG(GetCurrentState() == LOOPBACK_STATE_RUNNING, false, "AudioLoopback Enable failed");
+        if (GetCurrentState() != LOOPBACK_STATE_RUNNING) {
+            HILOG_COMM_INFO("AudioLoopback Enable failed");
+            return false;
+        }
     } else {
         std::unique_lock<std::mutex> stateLock(stateMutex_);
         CHECK_AND_RETURN_RET_LOG(currentState_ == LOOPBACK_STATE_RUNNING, true, "AudioLoopback not Running");
@@ -154,15 +163,14 @@ int32_t AudioLoopbackPrivate::SetVolume(float volume)
 {
     Trace trace("AudioLoopbackPrivate::SetVolume");
     if (volume < 0.0 || volume > 1.0) {
-        AUDIO_ERR_LOG("SetVolume with invalid volume %{public}f", volume);
+        HILOG_COMM_INFO("SetVolume with invalid volume");
         return ERR_INVALID_PARAM;
     }
     std::unique_lock<std::mutex> stateLock(stateMutex_);
     karaokeParams_["Karaoke_volume"] = std::to_string(static_cast<int>(volume * VALUE_HUNDRED));
     if (currentState_ == LOOPBACK_STATE_RUNNING) {
         std::string parameters = "Karaoke_volume=" + karaokeParams_["Karaoke_volume"];
-        CHECK_AND_RETURN_RET_LOG(AudioPolicyManager::GetInstance().SetKaraokeParameters(parameters), ERROR,
-            "SetVolume failed");
+        CHECK_AND_RETURN_RET_LOG(SetKaraokeParameters(parameters), ERROR, "SetVolume failed");
     }
     return SUCCESS;
 }
@@ -176,8 +184,7 @@ bool AudioLoopbackPrivate::SetReverbPreset(AudioLoopbackReverbPreset preset)
     karaokeParams_["Karaoke_reverb_mode"] = it->second;
     if (currentState_ == LOOPBACK_STATE_RUNNING) {
         std::string parameters = "Karaoke_reverb_mode=" + karaokeParams_["Karaoke_reverb_mode"];
-        CHECK_AND_RETURN_RET_LOG(AudioPolicyManager::GetInstance().SetKaraokeParameters(parameters), false,
-            "SetReverbPreset failed");
+        CHECK_AND_RETURN_RET_LOG(SetKaraokeParameters(parameters), false, "SetReverbPreset failed");
     }
     return true;
 }
@@ -197,8 +204,7 @@ bool AudioLoopbackPrivate::SetEqualizerPreset(AudioLoopbackEqualizerPreset prese
     karaokeParams_["Karaoke_eq_mode"] = it->second;
     if (currentState_ == LOOPBACK_STATE_RUNNING) {
         std::string parameters = "Karaoke_eq_mode=" + karaokeParams_["Karaoke_eq_mode"];
-        CHECK_AND_RETURN_RET_LOG(AudioPolicyManager::GetInstance().SetKaraokeParameters(parameters), false,
-            "SetEqualizerPreset failed");
+        CHECK_AND_RETURN_RET_LOG(SetKaraokeParameters(parameters), false, "SetEqualizerPreset failed");
     }
     return true;
 }
@@ -209,6 +215,15 @@ AudioLoopbackEqualizerPreset AudioLoopbackPrivate::GetEqualizerPreset()
     return currentEqualizerPreset_;
 }
 
+bool AudioLoopbackPrivate::SetKaraokeParameters(const std::string &parameters)
+{
+    bool ret = AudioPolicyManager::GetInstance().SetKaraokeParameters(parameters);
+    if (!ret) {
+        HILOG_COMM_INFO("SetKaraokeParameters failed");
+    }
+    return ret;
+}
+
 int32_t AudioLoopbackPrivate::SetAudioLoopbackCallback(const std::shared_ptr<AudioLoopbackCallback> &callback)
 {
     std::unique_lock<std::mutex> stateLock(stateMutex_);
@@ -227,21 +242,48 @@ void AudioLoopbackPrivate::CreateAudioLoopback()
 {
     Trace trace("AudioLoopbackPrivate::CreateAudioLoopback");
     audioRenderer_ = AudioRenderer::CreateRenderer(rendererOptions_, appInfo_);
-    CHECK_AND_RETURN_LOG(audioRenderer_ != nullptr, "CreateRenderer failed");
-    CHECK_AND_RETURN_LOG(audioRenderer_->IsFastRenderer(), "CreateFastRenderer failed");
+    if (audioRenderer_ == nullptr) {
+        HILOG_COMM_INFO("CreateRenderer failed");
+        return;
+    }
+    if (!audioRenderer_->IsFastRenderer()) {
+        HILOG_COMM_INFO("CreateFastRenderer failed");
+        return;
+    }
+
     audioRenderer_->SetRendererWriteCallback(shared_from_this());
     rendererFastStatus_ = FASTSTATUS_FAST;
     audioCapturer_ = AudioCapturer::CreateCapturer(capturerOptions_, appInfo_);
-    CHECK_AND_RETURN_LOG(audioCapturer_ != nullptr, "CreateCapturer failed");
+    if (audioCapturer_ == nullptr) {
+        HILOG_COMM_INFO("CreateCapturer failed");
+        return;
+    }
+
     AudioCapturerInfo capturerInfo;
     audioCapturer_->GetCapturerInfo(capturerInfo);
-    CHECK_AND_RETURN_LOG(capturerInfo.capturerFlags == STREAM_FLAG_FAST, "CreateFastCapturer failed");
+    if (capturerInfo.capturerFlags != STREAM_FLAG_FAST) {
+        HILOG_COMM_INFO("CreateFastCapturer failed");
+        return;
+    }
+
     audioCapturer_->SetCapturerReadCallback(shared_from_this());
     InitializeCallbacks();
     capturerFastStatus_ = FASTSTATUS_FAST;
-    CHECK_AND_RETURN_LOG(audioRenderer_->Start(), "audioRenderer Start failed");
+
+    StartAudioLoopback();
+}
+
+void AudioLoopbackPrivate::StartAudioLoopback()
+{
+    if (!audioRenderer_->Start()) {
+        HILOG_COMM_INFO("audioRenderer Start failed");
+        return;
+    }
     rendererState_ = RENDERER_RUNNING;
-    CHECK_AND_RETURN_LOG(audioCapturer_->Start(), "audioCapturer Start failed");
+    if (!audioCapturer_->Start()) {
+        HILOG_COMM_INFO("audioCapturer Start failed");
+        return;
+    }
     capturerState_ = CAPTURER_RUNNING;
 }
 
@@ -250,8 +292,7 @@ void AudioLoopbackPrivate::DisableLoopback()
     if (karaokeParams_["Karaoke_enable"] == "enable") {
         karaokeParams_["Karaoke_enable"] = "disable";
         std::string parameters = "Karaoke_enable=" + karaokeParams_["Karaoke_enable"];
-        CHECK_AND_RETURN_LOG(AudioPolicyManager::GetInstance().SetKaraokeParameters(parameters),
-            "DisableLoopback failed");
+        CHECK_AND_RETURN_LOG(SetKaraokeParameters(parameters), "DisableLoopback failed");
     }
 }
 
@@ -331,8 +372,8 @@ bool AudioLoopbackPrivate::EnableLoopback()
     std::string parameters = "";
     for (auto &param : karaokeParams_) {
         parameters = param.first + "=" + param.second + ";";
-        CHECK_AND_RETURN_RET_LOG(AudioPolicyManager::GetInstance().SetKaraokeParameters(parameters), false,
-            "SetKaraokeParameters failed");
+        CHECK_AND_RETURN_RET_LOG(SetKaraokeParameters(parameters), false,
+            "EnableLoopback failed");
     }
     return true;
 }
@@ -436,11 +477,12 @@ void AudioLoopbackPrivate::UpdateStatus()
         newState = EnableLoopback() ? LOOPBACK_STATE_RUNNING : LOOPBACK_STATE_DESTROYED;
     }
     if (newState != oldState) {
-        AUDIO_INFO_LOG("UpdateState: %{public}d -> %{public}d", oldState, newState);
+        HILOG_COMM_WARN("UpdateState: %{public}d -> %{public}d", oldState, newState);
         if (newState == LOOPBACK_STATE_DESTROYED) {
             currentState_ = LOOPBACK_STATE_DESTROYING;
             auto self = shared_from_this();
             std::thread([self] {
+                CHECK_AND_RETURN(self != nullptr);
                 self->DestroyAudioLoopback();
             }).detach();
         }
diff --git a/frameworks/native/audioloopback/test/unittest/BUILD.gn b/frameworks/native/audioloopback/test/unittest/BUILD.gn
index f7fbf3dcf0806bf813c3906757be0d6616b5b4a4..974e0385cbda71aff5dbac894eba8b9fbd1fec06 100644
--- a/frameworks/native/audioloopback/test/unittest/BUILD.gn
+++ b/frameworks/native/audioloopback/test/unittest/BUILD.gn
@@ -37,6 +37,8 @@ ohos_unittest("audio_loopback_unit_test") {
 
   deps = [
     "../../../../../services/audio_service:audio_client",
+    "../../../audiocapturer:audio_capturer",
+    "../../../audiorenderer:audio_renderer",
     "../../../audioloopback:audio_loopback",
   ]
 
@@ -45,6 +47,7 @@ ohos_unittest("audio_loopback_unit_test") {
     "access_token:libnativetoken_shared",
     "access_token:libtokensetproc_shared",
     "c_utils:utils",
+    "googletest:gmock",
     "hilog:libhilog",
     "init:libbegetutil",
     "ipc:ipc_single",
diff --git a/frameworks/native/audioloopback/test/unittest/include/audio_capturer_mock.h b/frameworks/native/audioloopback/test/unittest/include/audio_capturer_mock.h
new file mode 100644
index 0000000000000000000000000000000000000000..24b0fc9b48b4cea0ad1e13d57c3a7c66928973c8
--- /dev/null
+++ b/frameworks/native/audioloopback/test/unittest/include/audio_capturer_mock.h
@@ -0,0 +1,91 @@
+/*
+ * 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.
+ */
+#ifndef AUDIO_CAPTURER_MOCK_H
+#define AUDIO_CAPTURER_MOCK_H
+#include <gmock/gmock.h>
+#include "audio_capturer.h"
+
+namespace OHOS {
+namespace AudioStandard {
+class MockAudioCapturer : public AudioCapturer {
+public:
+    MOCK_METHOD(int32_t, SetParams, (const AudioCapturerParams params), (override));
+    MOCK_METHOD(int32_t, UpdatePlaybackCaptureConfig, (const AudioPlaybackCaptureConfig &config), (override));
+    MOCK_METHOD(int32_t, SetCapturerCallback, (const std::shared_ptr<AudioCapturerCallback> &callback), (override));
+    MOCK_METHOD(void, SetAudioCapturerErrorCallback,
+        (std::shared_ptr<AudioCapturerErrorCallback> errorCallback), (override));
+    MOCK_METHOD(void, SetFastStatusChangeCallback,
+        (const std::shared_ptr<AudioCapturerFastStatusChangeCallback> &callback), (override));
+    MOCK_METHOD(int32_t, GetParams, (AudioCapturerParams &params), (const, override));
+    MOCK_METHOD(int32_t, GetCapturerInfo, (AudioCapturerInfo &capturerInfo), (const, override));
+    MOCK_METHOD(int32_t, GetStreamInfo, (AudioStreamInfo &streamInfo), (const, override));
+    MOCK_METHOD(bool, Start, (), (override));
+    MOCK_METHOD(int32_t, Read, (uint8_t &buffer, size_t userSize, bool isBlockingRead), (override));
+    MOCK_METHOD(CapturerState, GetStatus, (), (const, override));
+    MOCK_METHOD(bool, GetTimeStampInfo, (Timestamp &timestamp, Timestamp::Timestampbase base), (const, override));
+    MOCK_METHOD(bool, GetAudioTime, (Timestamp &timestamp, Timestamp::Timestampbase base), (const, override));
+    MOCK_METHOD(bool, GetFirstPkgTimeStampInfo, (int64_t &firstTs), (const, override));
+    MOCK_METHOD(bool, Pause, (), (const, override));
+    MOCK_METHOD(bool, Stop, (), (const, override));
+    MOCK_METHOD(bool, Flush, (), (const, override));
+    MOCK_METHOD(bool, Release, (), (override));
+    MOCK_METHOD(int32_t, GetBufferSize, (size_t &bufferSize), (const, override));
+    MOCK_METHOD(int32_t, GetAudioStreamId, (uint32_t &sessionID), (const, override));
+    MOCK_METHOD(int32_t, GetFrameCount, (uint32_t &frameCount), (const, override));
+    MOCK_METHOD(int32_t, SetCapturerPositionCallback,
+        (int64_t markPosition, const std::shared_ptr<CapturerPositionCallback> &callback), (override));
+    MOCK_METHOD(void, UnsetCapturerPositionCallback, (), (override));
+    MOCK_METHOD(int32_t, SetCapturerPeriodPositionCallback,
+        (int64_t frameNumber, const std::shared_ptr<CapturerPeriodPositionCallback> &callback), (override));
+    MOCK_METHOD(void, UnsetCapturerPeriodPositionCallback, (), (override));
+    MOCK_METHOD(int32_t, RegisterAudioPolicyServerDiedCb,
+        (const int32_t clientPid, const std::shared_ptr<AudioCapturerPolicyServiceDiedCallback> &callback), (override));
+    MOCK_METHOD(int32_t, SetBufferDuration, (uint64_t bufferDuration), (const, override));
+    MOCK_METHOD(int32_t, SetCaptureMode, (AudioCaptureMode captureMode), (override));
+    MOCK_METHOD(AudioCaptureMode, GetCaptureMode, (), (const, override));
+    MOCK_METHOD(int32_t, SetCapturerReadCallback,
+        (const std::shared_ptr<AudioCapturerReadCallback> &callback), (override));
+    MOCK_METHOD(int32_t, GetBufferDesc, (BufferDesc &bufDesc), (override));
+    MOCK_METHOD(int32_t, Enqueue, (const BufferDesc &bufDesc), (override));
+    MOCK_METHOD(int32_t, Clear, (), (const, override));
+    MOCK_METHOD(int32_t, GetBufQueueState, (BufferQueueState &bufState), (const, override));
+    MOCK_METHOD(void, SetValid, (bool valid), (override));
+    MOCK_METHOD(int64_t, GetFramesRead, (), (const, override));
+    MOCK_METHOD(int32_t, SetAudioCapturerDeviceChangeCallback,
+        (const std::shared_ptr<AudioCapturerDeviceChangeCallback> &callback), (override));
+    MOCK_METHOD(int32_t, RemoveAudioCapturerDeviceChangeCallback,
+        (const std::shared_ptr<AudioCapturerDeviceChangeCallback> &callback), (override));
+    MOCK_METHOD(int32_t, SetAudioCapturerInfoChangeCallback,
+        (const std::shared_ptr<AudioCapturerInfoChangeCallback> &callback), (override));
+    MOCK_METHOD(int32_t, RemoveAudioCapturerInfoChangeCallback,
+        (const std::shared_ptr<AudioCapturerInfoChangeCallback> &callback), (override));
+    MOCK_METHOD(int32_t, RegisterAudioCapturerEventListener, (), (override));
+    MOCK_METHOD(int32_t, UnregisterAudioCapturerEventListener, (), (override));
+    MOCK_METHOD(int32_t, GetCurrentInputDevices, (AudioDeviceDescriptor &deviceInfo), (const, override));
+    MOCK_METHOD(int32_t, GetCurrentCapturerChangeInfo, (AudioCapturerChangeInfo &changeInfo), (const, override));
+    MOCK_METHOD(std::vector<sptr<MicrophoneDescriptor>>, GetCurrentMicrophones, (), (const, override));
+    MOCK_METHOD(int32_t, GetAudioTimestampInfo,
+        (Timestamp &timestamp, Timestamp::Timestampbase base), (const, override));
+    MOCK_METHOD(uint32_t, GetOverflowCount, (), (const, override));
+    MOCK_METHOD(int32_t, SetInputDevice, (DeviceType deviceType), (const, override));
+    MOCK_METHOD(FastStatus, GetFastStatus, (), (override));
+    MOCK_METHOD(int32_t, SetAudioSourceConcurrency, (const std::vector<SourceType> &targetSources), (override));
+    MOCK_METHOD(int32_t, SetInterruptStrategy, (InterruptStrategy strategy), (override));
+    MOCK_METHOD(void, SetInterruptEventCallbackType, (InterruptEventCallbackType callbackType), (override));
+};
+
+} // namespace AudioStandard
+} // namespace OHOS
+#endif // AUDIO_CAPTURER_MOCK_H
\ No newline at end of file
diff --git a/frameworks/native/audioloopback/test/unittest/include/audio_renderer_mock.h b/frameworks/native/audioloopback/test/unittest/include/audio_renderer_mock.h
new file mode 100644
index 0000000000000000000000000000000000000000..f30e903fa0612bad69abc2e2ff649c01e3c65cbc
--- /dev/null
+++ b/frameworks/native/audioloopback/test/unittest/include/audio_renderer_mock.h
@@ -0,0 +1,131 @@
+/*
+ * 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.
+ */
+#ifndef AUDIO_RENDERER_MOCK_H
+#define AUDIO_RENDERER_MOCK_H
+#include <gmock/gmock.h>
+#include "audio_renderer.h"
+
+namespace OHOS {
+namespace AudioStandard {
+class MockAudioRenderer : public AudioRenderer {
+public:
+    MOCK_METHOD(void, SetAudioPrivacyType, (AudioPrivacyType privacyType), (override));
+    MOCK_METHOD(AudioPrivacyType, GetAudioPrivacyType, (), (override));
+    MOCK_METHOD(int32_t, SetParams, (const AudioRendererParams params), (override));
+    MOCK_METHOD(int32_t, SetRendererCallback, (const std::shared_ptr<AudioRendererCallback> &callback), (override));
+    MOCK_METHOD(int32_t, GetParams, (AudioRendererParams &params), (const, override));
+    MOCK_METHOD(int32_t, GetRendererInfo, (AudioRendererInfo &rendererInfo), (const, override));
+    MOCK_METHOD(int32_t, GetStreamInfo, (AudioStreamInfo &streamInfo), (const, override));
+    MOCK_METHOD(bool, Start, (StateChangeCmdType cmdType), (override));
+    MOCK_METHOD(int32_t, Write, (uint8_t *buffer, size_t bufferSize), (override));
+    MOCK_METHOD(int32_t, Write,
+        (uint8_t *pcmBuffer, size_t pcmBufferSize, uint8_t *metaBuffer, size_t metaBufferSize), (override));
+    MOCK_METHOD(RendererState, GetStatus, (), (const, override));
+    MOCK_METHOD(bool, GetAudioTime, (Timestamp &timestamp, Timestamp::Timestampbase base), (const, override));
+    MOCK_METHOD(bool, GetAudioPosition, (Timestamp &timestamp, Timestamp::Timestampbase base), (override));
+    MOCK_METHOD(int32_t, GetLatency, (uint64_t &latency), (const, override));
+    MOCK_METHOD(bool, Drain, (), (const, override));
+    MOCK_METHOD(bool, Flush, (), (const, override));
+    MOCK_METHOD(bool, PauseTransitent, (StateChangeCmdType cmdType), (override));
+    MOCK_METHOD(bool, Pause, (StateChangeCmdType cmdType), (override));
+    MOCK_METHOD(bool, Stop, (), (override));
+    MOCK_METHOD(bool, Release, (), (override));
+    MOCK_METHOD(int32_t, GetBufferSize, (size_t &bufferSize), (const, override));
+    MOCK_METHOD(int32_t, GetAudioStreamId, (uint32_t &sessionID), (const, override));
+    MOCK_METHOD(int32_t, GetFrameCount, (uint32_t &frameCount), (const, override));
+    MOCK_METHOD(int32_t, SetAudioRendererDesc, (AudioRendererDesc audioRendererDesc), (override));
+    MOCK_METHOD(int32_t, SetStreamType, (AudioStreamType audioStreamType), (override));
+    MOCK_METHOD(int32_t, SetVolume, (float volume), (const, override));
+    MOCK_METHOD(int32_t, SetVolumeMode, (int32_t mode), (override));
+    MOCK_METHOD(float, GetVolume, (), (const, override));
+    MOCK_METHOD(int32_t, SetLoudnessGain, (float loudnessGain), (const, override));
+    MOCK_METHOD(float, GetLoudnessGain, (), (const, override));
+    MOCK_METHOD(int32_t, SetRenderRate, (AudioRendererRate renderRate), (const, override));
+    MOCK_METHOD(AudioRendererRate, GetRenderRate, (), (const, override));
+    MOCK_METHOD(int32_t, SetRendererSamplingRate, (uint32_t sampleRate), (const, override));
+    MOCK_METHOD(uint32_t, GetRendererSamplingRate, (), (const, override));
+    MOCK_METHOD(int32_t, SetRendererPositionCallback,
+        (int64_t markPosition, const std::shared_ptr<RendererPositionCallback> &callback), (override));
+    MOCK_METHOD(void, UnsetRendererPositionCallback, (), (override));
+    MOCK_METHOD(int32_t, SetRendererPeriodPositionCallback,
+        (int64_t frameNumber, const std::shared_ptr<RendererPeriodPositionCallback> &callback), (override));
+    MOCK_METHOD(void, SetFastStatusChangeCallback,
+        (const std::shared_ptr<AudioRendererFastStatusChangeCallback> &callback), (override));
+    MOCK_METHOD(void, UnsetRendererPeriodPositionCallback, (), (override));
+    MOCK_METHOD(int32_t, SetBufferDuration, (uint64_t bufferDuration), (const, override));
+    MOCK_METHOD(int32_t, SetRenderMode, (AudioRenderMode renderMode), (override));
+    MOCK_METHOD(AudioRenderMode, GetRenderMode, (), (const, override));
+    MOCK_METHOD(int32_t, SetRendererWriteCallback,
+        (const std::shared_ptr<AudioRendererWriteCallback> &callback), (override));
+    MOCK_METHOD(int32_t, SetRendererFirstFrameWritingCallback,
+        (const std::shared_ptr<AudioRendererFirstFrameWritingCallback> &callback), (override));
+    MOCK_METHOD(int32_t, GetBufferDesc, (BufferDesc &bufDesc), (override));
+    MOCK_METHOD(int32_t, Enqueue, (const BufferDesc &bufDesc), (override));
+    MOCK_METHOD(int32_t, Clear, (), (const, override));
+    MOCK_METHOD(int32_t, GetBufQueueState, (BufferQueueState &bufState), (const, override));
+    MOCK_METHOD(void, SetInterruptMode, (InterruptMode mode), (override));
+    MOCK_METHOD(int32_t, SetParallelPlayFlag, (bool parallelPlayFlag), (override));
+    MOCK_METHOD(int32_t, SetLowPowerVolume, (float volume), (const, override));
+    MOCK_METHOD(float, GetLowPowerVolume, (), (const, override));
+    MOCK_METHOD(int32_t, SetOffloadAllowed, (bool isAllowed), (override));
+    MOCK_METHOD(int32_t, SetOffloadMode, (int32_t state, bool isAppBack), (const, override));
+    MOCK_METHOD(int32_t, UnsetOffloadMode, (), (const, override));
+    MOCK_METHOD(float, GetSingleStreamVolume, (), (const, override));
+    MOCK_METHOD(float, GetMinStreamVolume, (), (const, override));
+    MOCK_METHOD(float, GetMaxStreamVolume, (), (const, override));
+    MOCK_METHOD(uint32_t, GetUnderflowCount, (), (const, override));
+    MOCK_METHOD(int32_t, GetCurrentOutputDevices, (AudioDeviceDescriptor &deviceInfo), (const, override));
+    MOCK_METHOD(AudioEffectMode, GetAudioEffectMode, (), (const, override));
+    MOCK_METHOD(int64_t, GetFramesWritten, (), (const, override));
+    MOCK_METHOD(int32_t, SetAudioEffectMode, (AudioEffectMode effectMode), (const, override));
+    MOCK_METHOD(void, SetAudioRendererErrorCallback,
+        (std::shared_ptr<AudioRendererErrorCallback> errorCallback), (override));
+    MOCK_METHOD(int32_t, RegisterOutputDeviceChangeWithInfoCallback,
+        (const std::shared_ptr<AudioRendererOutputDeviceChangeCallback> &callback), (override));
+    MOCK_METHOD(int32_t, UnregisterOutputDeviceChangeWithInfoCallback, (), (override));
+    MOCK_METHOD(int32_t, UnregisterOutputDeviceChangeWithInfoCallback,
+        (const std::shared_ptr<AudioRendererOutputDeviceChangeCallback> &callback), (override));
+    MOCK_METHOD(int32_t, RegisterAudioPolicyServerDiedCb,
+        (const int32_t clientPid, const std::shared_ptr<AudioRendererPolicyServiceDiedCallback> &callback), (override));
+    MOCK_METHOD(int32_t, UnregisterAudioPolicyServerDiedCb, (const int32_t clientPid), (override));
+    MOCK_METHOD(int32_t, SetChannelBlendMode, (ChannelBlendMode blendMode), (override));
+    MOCK_METHOD(int32_t, SetVolumeWithRamp, (float volume, int32_t duration), (override));
+    MOCK_METHOD(void, SetPreferredFrameSize, (int32_t frameSize), (override));
+    MOCK_METHOD(int32_t, SetSpeed, (float speed), (override));
+    MOCK_METHOD(float, GetSpeed, (), (override));
+    MOCK_METHOD(bool, IsOffloadEnable, (), (override));
+    MOCK_METHOD(bool, IsFastRenderer, (), (override));
+    MOCK_METHOD(void, SetSilentModeAndMixWithOthers, (bool on), (override));
+    MOCK_METHOD(bool, GetSilentModeAndMixWithOthers, (), (override));
+    MOCK_METHOD(void, EnableVoiceModemCommunicationStartStream, (bool enable), (override));
+    MOCK_METHOD(bool, IsNoStreamRenderer, (), (const, override));
+    MOCK_METHOD(int64_t, GetSourceDuration, (), (const, override));
+    MOCK_METHOD(void, SetSourceDuration, (int64_t duration), (override));
+    MOCK_METHOD(int32_t, SetDefaultOutputDevice, (DeviceType deviceType), (override));
+    MOCK_METHOD(FastStatus, GetFastStatus, (), (override));
+    MOCK_METHOD(bool, Mute, (StateChangeCmdType cmdType), (const, override));
+    MOCK_METHOD(bool, Unmute, (StateChangeCmdType cmdType), (const, override));
+    MOCK_METHOD(int32_t, GetAudioTimestampInfo,
+        (Timestamp &timestamp, Timestamp::Timestampbase base), (const, override));
+    MOCK_METHOD(int32_t, StartDataCallback, (), (override));
+    MOCK_METHOD(int32_t, StopDataCallback, (), (override));
+    MOCK_METHOD(void, SetInterruptEventCallbackType, (InterruptEventCallbackType callbackType), (override));
+    MOCK_METHOD(void, SetAudioHapticsSyncId, (int32_t audioHapticsSyncId), (override));
+    MOCK_METHOD(void, ResetFirstFrameState, (), (override));
+};
+
+} // namespace AudioStandard
+} // namespace OHOS
+#endif // AUDIO_RENDERER_MOCK_H
\ No newline at end of file
diff --git a/frameworks/native/audioloopback/test/unittest/src/audio_loopback_unit_test.cpp b/frameworks/native/audioloopback/test/unittest/src/audio_loopback_unit_test.cpp
index 142e1aee5a34a9a82a2188f32e05bf0bafd7a10b..38afbecf977e83643891c19f25fa36a9cd930c72 100644
--- a/frameworks/native/audioloopback/test/unittest/src/audio_loopback_unit_test.cpp
+++ b/frameworks/native/audioloopback/test/unittest/src/audio_loopback_unit_test.cpp
@@ -19,11 +19,16 @@
 #include "accesstoken_kit.h"
 #include "nativetoken_kit.h"
 #include "token_setproc.h"
+#include "audio_renderer_mock.h"
+#include "audio_capturer_mock.h"
 
 using namespace testing::ext;
 using namespace testing;
 namespace OHOS {
 namespace AudioStandard {
+using ::testing::_;
+using ::testing::Return;
+using ::testing::NiceMock;
 bool g_hasPermission = false;
 
 void GetPermission()
@@ -82,6 +87,8 @@ HWTEST_F(AudioLoopbackUnitTest, Audio_Loopback_CreateAudioLoopback_001, TestSize
 HWTEST_F(AudioLoopbackUnitTest, Audio_Loopback_CreateAudioLoopback_002, TestSize.Level0)
 {
     auto audioLoopback = std::make_shared<AudioLoopbackPrivate>(LOOPBACK_HARDWARE, AppInfo());
+    audioLoopback->currentState_ = LOOPBACK_STATE_IDLE;
+    EXPECT_EQ(audioLoopback->Enable(true), false);
     audioLoopback->currentState_ = LOOPBACK_STATE_RUNNING;
     EXPECT_EQ(audioLoopback->Enable(true), false);
     EXPECT_EQ(audioLoopback->Enable(false), false);
@@ -286,14 +293,14 @@ HWTEST_F(AudioLoopbackUnitTest, Audio_Loopback_SetReverbPreset_001, TestSize.Lev
 {
     auto audioLoopback = std::make_shared<AudioLoopbackPrivate>(LOOPBACK_HARDWARE, AppInfo());
     audioLoopback->currentState_ = LOOPBACK_STATE_RUNNING;
-    bool ret = audioLoopback->SetReverbPreset(REVERB_PRESET_THEATRE);
+    bool ret = audioLoopback->SetReverbPreset(REVERB_PRESET_THEATER);
     EXPECT_EQ(ret, true);
 }
 
 HWTEST_F(AudioLoopbackUnitTest, Audio_Loopback_SetReverbPreset_002, TestSize.Level1)
 {
     auto audioLoopback = std::make_shared<AudioLoopbackPrivate>(LOOPBACK_HARDWARE, AppInfo());
-    bool ret = audioLoopback->SetReverbPreset(REVERB_PRESET_THEATRE);
+    bool ret = audioLoopback->SetReverbPreset(REVERB_PRESET_THEATER);
     EXPECT_EQ(ret, true);
 }
 
@@ -311,5 +318,73 @@ HWTEST_F(AudioLoopbackUnitTest, Audio_Loopback_SetEqualizerPreset_002, TestSize.
     bool ret = audioLoopback->SetEqualizerPreset(EQUALIZER_PRESET_FLAT);
     EXPECT_EQ(ret, true);
 }
+
+HWTEST_F(AudioLoopbackUnitTest, Audio_Loopback_StartAudioLoopback_001, TestSize.Level1)
+{
+    std::shared_ptr<MockAudioRenderer> mockRenderer = std::make_shared<NiceMock<MockAudioRenderer>>();
+    std::shared_ptr<MockAudioCapturer> mockCapturer = std::make_shared<NiceMock<MockAudioCapturer>>();
+    auto audioLoopback = std::make_shared<AudioLoopbackPrivate>(LOOPBACK_HARDWARE, AppInfo());
+
+    audioLoopback->audioRenderer_ = mockRenderer;
+    audioLoopback->audioCapturer_ = mockCapturer;
+    EXPECT_CALL(*mockRenderer, Start(_)).WillOnce(Return(true));
+    EXPECT_CALL(*mockCapturer, Start()).WillOnce(Return(true));
+
+    audioLoopback->StartAudioLoopback();
+
+    EXPECT_EQ(audioLoopback->rendererState_, RENDERER_RUNNING);
+    EXPECT_EQ(audioLoopback->capturerState_, CAPTURER_RUNNING);
+}
+
+HWTEST_F(AudioLoopbackUnitTest, Audio_Loopback_StartAudioLoopback_002, TestSize.Level1)
+{
+    std::shared_ptr<MockAudioRenderer> mockRenderer = std::make_shared<NiceMock<MockAudioRenderer>>();
+    std::shared_ptr<MockAudioCapturer> mockCapturer = std::make_shared<NiceMock<MockAudioCapturer>>();
+    auto audioLoopback = std::make_shared<AudioLoopbackPrivate>(LOOPBACK_HARDWARE, AppInfo());
+
+    audioLoopback->audioRenderer_ = mockRenderer;
+    audioLoopback->audioCapturer_ = mockCapturer;
+    EXPECT_CALL(*mockRenderer, Start(_)).WillOnce(Return(false));
+    EXPECT_CALL(*mockCapturer, Start()).Times(0);
+
+    audioLoopback->StartAudioLoopback();
+
+    EXPECT_NE(audioLoopback->rendererState_, RENDERER_RUNNING);
+    EXPECT_NE(audioLoopback->capturerState_, CAPTURER_RUNNING);
+}
+
+HWTEST_F(AudioLoopbackUnitTest, Audio_Loopback_StartAudioLoopback_003, TestSize.Level1)
+{
+    std::shared_ptr<MockAudioRenderer> mockRenderer = std::make_shared<NiceMock<MockAudioRenderer>>();
+    std::shared_ptr<MockAudioCapturer> mockCapturer = std::make_shared<NiceMock<MockAudioCapturer>>();
+    auto audioLoopback = std::make_shared<AudioLoopbackPrivate>(LOOPBACK_HARDWARE, AppInfo());
+
+    audioLoopback->audioRenderer_ = mockRenderer;
+    audioLoopback->audioCapturer_ = mockCapturer;
+    EXPECT_CALL(*mockRenderer, Start(_)).WillOnce(Return(true));
+    EXPECT_CALL(*mockCapturer, Start()).WillOnce(Return(false));
+
+    audioLoopback->StartAudioLoopback();
+
+    EXPECT_EQ(audioLoopback->rendererState_, RENDERER_RUNNING);
+    EXPECT_NE(audioLoopback->capturerState_, CAPTURER_RUNNING);
+}
+
+HWTEST_F(AudioLoopbackUnitTest, Audio_Loopback_DestroyAudioLoopback_002, TestSize.Level1)
+{
+    std::shared_ptr<MockAudioRenderer> mockRenderer = std::make_shared<NiceMock<MockAudioRenderer>>();
+    std::shared_ptr<MockAudioCapturer> mockCapturer = std::make_shared<NiceMock<MockAudioCapturer>>();
+    auto audioLoopback = std::make_shared<AudioLoopbackPrivate>(LOOPBACK_HARDWARE, AppInfo());
+
+    audioLoopback->audioRenderer_ = mockRenderer;
+    audioLoopback->audioCapturer_ = mockCapturer;
+    EXPECT_CALL(*mockCapturer, Stop()).Times(1);
+    EXPECT_CALL(*mockRenderer, Stop()).Times(1);
+
+    audioLoopback->DestroyAudioLoopback();
+
+    EXPECT_EQ(audioLoopback->audioRenderer_, nullptr);
+    EXPECT_EQ(audioLoopback->audioCapturer_, nullptr);
+}
 } // namespace AudioStandard
 } // namespace OHOS
diff --git a/frameworks/native/audioutils/BUILD.gn b/frameworks/native/audioutils/BUILD.gn
index 2c16a5d0b6f3c04e925640a4a449f3ad231a4fde..e2583f1034779bc724acbd6eb1eea6efab83c3ea 100644
--- a/frameworks/native/audioutils/BUILD.gn
+++ b/frameworks/native/audioutils/BUILD.gn
@@ -82,6 +82,10 @@ ohos_shared_library("audio_utils") {
     defines += [ "AUDIO_BUILD_VARIANT_ROOT" ]
   }
 
+  if (!audio_framework_feature_new_engine_flag) {
+    defines += [ "SUPPORT_OLD_ENGINE" ]
+  }
+
   subsystem_name = "multimedia"
   innerapi_tags = [ "platformsdk_indirect" ]
   part_name = "audio_framework"
diff --git a/frameworks/native/audioutils/src/audio_utils.cpp b/frameworks/native/audioutils/src/audio_utils.cpp
index c6f549b05290401c63b4084160c856bbfddad94b..a00253315f3e3b4f31e71c03dc0099f9198d4966 100644
--- a/frameworks/native/audioutils/src/audio_utils.cpp
+++ b/frameworks/native/audioutils/src/audio_utils.cpp
@@ -1189,14 +1189,18 @@ template bool GetSysPara(const char *key, std::string &value);
 
 int32_t GetEngineFlag()
 {
+#ifdef SUPPORT_OLD_ENGINE
     std::string para = "const.multimedia.audio.proaudioEnable";
     static int32_t engineFlag = -1;
     if (engineFlag == -1) {
         bool res = GetSysPara(para.c_str(), engineFlag);
-        AUDIO_DEBUG_LOG("get %{public}s = %{public}d", para.c_str(), engineFlag);
+        AUDIO_INFO_LOG("get %{public}s = %{public}d", para.c_str(), engineFlag);
         CHECK_AND_RETURN_RET_LOG(res, engineFlag, "get %{public}s fail", para.c_str());
     }
     return engineFlag;
+#else
+    return 1;
+#endif
 }
 
 std::map<std::string, std::string> DumpFileUtil::g_lastPara = {};
diff --git a/frameworks/native/hdiadapter_new/source/audio_capture_source.cpp b/frameworks/native/hdiadapter_new/source/audio_capture_source.cpp
index 3fd7f70fe83f7efea84e3f252fc8338948dcabae..573afb81c2ce6abf3b2632835099c2d6b7a79934 100644
--- a/frameworks/native/hdiadapter_new/source/audio_capture_source.cpp
+++ b/frameworks/native/hdiadapter_new/source/audio_capture_source.cpp
@@ -662,7 +662,7 @@ void AudioCaptureSource::CheckAcousticEchoCancelerSupported(int32_t sourceType,
     std::string value = deviceManager->GetAudioParameter("primary", AudioParamKey::PARAM_KEY_STATE,
         "source_type_live_aec_supported");
     if (value != "true") {
-        AUDIO_ERR_LOG("SOURCE_TYPE_LIVE not supported will be changed to SOURCE_TYPE_MIC");
+        HILOG_COMM_INFO("SOURCE_TYPE_LIVE not supported will be changed to SOURCE_TYPE_MIC");
         hdiAudioInputType = AUDIO_INPUT_MIC_TYPE;
     }
 }
diff --git a/interfaces/inner_api/native/audiocommon/include/audio_info.h b/interfaces/inner_api/native/audiocommon/include/audio_info.h
index d984c5f3857342036547b4b8b5e10a04efe41fef..ad6c4e41971c5d7985e5c93bbd8d63e38ba44009 100644
--- a/interfaces/inner_api/native/audiocommon/include/audio_info.h
+++ b/interfaces/inner_api/native/audiocommon/include/audio_info.h
@@ -573,7 +573,7 @@ enum AudioLoopbackReverbPreset {
     /**
      * A preset representing a reverberation effect with theater-like acoustic characteristics.
      */
-    REVERB_PRESET_THEATRE = 3,
+    REVERB_PRESET_THEATER = 3,
     /**
      * A preset representing a reverberation effect with concert-like acoustic characteristics.
      */
diff --git a/services/audio_engine/manager/src/hpae_capturer_manager.cpp b/services/audio_engine/manager/src/hpae_capturer_manager.cpp
index b2b0a8ff6257d458526dce1683840f9bc5202c89..659c6ab8f4f624b9a08356153d17e95c78d7fbf5 100644
--- a/services/audio_engine/manager/src/hpae_capturer_manager.cpp
+++ b/services/audio_engine/manager/src/hpae_capturer_manager.cpp
@@ -843,7 +843,7 @@ int32_t HpaeCapturerManager::AddNodeToSource(const HpaeCaptureMoveInfo &moveInfo
 void HpaeCapturerManager::AddSingleNodeToSource(const HpaeCaptureMoveInfo &moveInfo, bool isConnect)
 {
     uint32_t sessionId = moveInfo.sessionId;
-    AUDIO_INFO_LOG("[FinishMove] session :%{public}u to source:[%{public}s].",
+    HILOG_COMM_INFO("[FinishMove] session :%{public}u to source:[%{public}s]",
         sessionId, sourceInfo_.sourceName.c_str());
     CHECK_AND_RETURN_LOG(moveInfo.sourceOutputNode != nullptr, "move fail, sourceoutputnode is null");
     HpaeNodeInfo nodeInfo = moveInfo.sourceOutputNode->GetNodeInfo();
@@ -907,7 +907,7 @@ void HpaeCapturerManager::MoveAllStreamToNewSource(const std::string &sourceName
     for (const auto &it : moveInfos) {
         DeleteOutputSession(it.sessionId);
     }
-    AUDIO_INFO_LOG("[StartMove] session:%{public}s to source name:%{public}s, move type:%{public}d",
+    HILOG_COMM_INFO("[StartMove] session:%{public}s to source name:%{public}s, move type:%{public}d",
         idStr.c_str(), name.c_str(), moveType);
     TriggerCallback(MOVE_ALL_SOURCE_OUTPUT, moveInfos, name);
 }
diff --git a/services/audio_engine/manager/src/hpae_inner_capturer_manager.cpp b/services/audio_engine/manager/src/hpae_inner_capturer_manager.cpp
index dcacd417638a96f5164c681f7f2c9941bd54b738..41d3219c671cfba074932a36333d5f15b710ab03 100644
--- a/services/audio_engine/manager/src/hpae_inner_capturer_manager.cpp
+++ b/services/audio_engine/manager/src/hpae_inner_capturer_manager.cpp
@@ -53,7 +53,8 @@ void HpaeInnerCapturerManager::AddSingleNodeToSinkInner(const std::shared_ptr<Hp
     HpaeNodeInfo nodeInfo = node->GetNodeInfo();
     uint32_t sessionId = nodeInfo.sessionId;
     Trace trace("[" + std::to_string(sessionId) + "]HpaeInnerCapturerManager::AddSingleNodeToSinkInner");
-    AUDIO_INFO_LOG("[FinishMove] session :%{public}u to sink:%{public}s", sessionId, sinkInfo_.deviceClass.c_str());
+    HILOG_COMM_INFO("[FinishMove] session :%{public}u to sink:%{public}s, sceneType is %{public}d",
+        sessionId, sinkInfo_.deviceClass.c_str(), node->GetSceneType());
     sinkInputNodeMap_[sessionId] = node;
     nodeInfo.deviceClass = sinkInfo_.deviceClass;
     nodeInfo.deviceNetId = sinkInfo_.deviceNetId;
@@ -116,7 +117,7 @@ void HpaeInnerCapturerManager::MoveAllStreamToNewSinkInner(const std::string &si
     for (const auto &it : sessionIds) {
         DeleteRendererInputSessionInner(it);
     }
-    AUDIO_INFO_LOG("[StartMove] session:%{public}s to sink name:%{public}s, move type:%{public}d",
+    HILOG_COMM_INFO("StartMove] session:%{public}s to sink name:%{public}s, move type:%{public}d",
         idStr.c_str(), name.c_str(), moveType);
     TriggerCallback(MOVE_ALL_SINK_INPUT, sinkInputs, name, moveType);
 }
diff --git a/services/audio_engine/manager/src/hpae_manager.cpp b/services/audio_engine/manager/src/hpae_manager.cpp
index 3152ebd13771fc55a057d5f52d1fa46dba9fc742..e1f9f43ae6df00f0a926276e4f03eb7195155a5c 100644
--- a/services/audio_engine/manager/src/hpae_manager.cpp
+++ b/services/audio_engine/manager/src/hpae_manager.cpp
@@ -706,7 +706,7 @@ void HpaeManager::MoveToPreferSink(const std::string &name, std::shared_ptr<Audi
         return;
     }
     auto request = [this, name, sessionIds, serviceCallback]() {
-        AUDIO_INFO_LOG("Move %{public}s To Prefer Sink: %{public}s", defaultSink_.c_str(), name.c_str());
+        HILOG_COMM_INFO("Move %{public}s To Prefer Sink: %{public}s", defaultSink_.c_str(), name.c_str());
         if (!SafeGetMap(rendererManagerMap_, defaultSink_)) {
             AUDIO_ERR_LOG("can not find default sink: %{public}s", defaultSink_.c_str());
             serviceCallback->OnOpenAudioPortCb(sinkNameSinkIdMap_[name]);
@@ -746,8 +746,7 @@ int32_t HpaeManager::MoveSourceOutputByIndexOrName(
         }
         std::string name = capturerIdSourceNameMap_[sourceOutputId];
         if (sourceName == name) {
-            AUDIO_INFO_LOG("move session:%{public}u,source:%{public}s is the same, no need move",
-                sourceOutputId, sourceName.c_str());
+            HILOG_COMM_INFO("source:%{public}s is the same, no need move", sourceName.c_str());
             if (auto serviceCallback = serviceCallback_.lock()) {
                 serviceCallback->OnMoveSourceOutputByIndexOrNameCb(SUCCESS);
             }
@@ -766,26 +765,26 @@ int32_t HpaeManager::MoveSourceOutputByIndexOrName(
 bool HpaeManager::CheckMoveSourceOutput(uint32_t sourceOutputId, const std::string &sourceName)
 {
     if (sourceName.empty()) {
-        AUDIO_ERR_LOG("move session:%{public}u failed,source name is empty.", sourceOutputId);
+        HILOG_COMM_INFO("move session:%{public}u failed,source name is empty.", sourceOutputId);
         return false;
     }
     std::shared_ptr<IHpaeCapturerManager> captureManager = GetCapturerManagerByName(sourceName);
     if (captureManager == nullptr || !captureManager->IsInit()) {
-        AUDIO_ERR_LOG("move session:%{public}u failed, can not find source:%{public}s or source is not open.",
+        HILOG_COMM_INFO("move session:%{public}u failed, can not find source:%{public}s or source is not open.",
             sourceOutputId, sourceName.c_str());
         return false;
     }
     std::shared_ptr<IHpaeCapturerManager> oldCaptureManager = GetCapturerManagerById(sourceOutputId);
     if (oldCaptureManager == nullptr) {
-        AUDIO_ERR_LOG("move session:%{public}u failed,can not find source.", sourceOutputId);
+        HILOG_COMM_INFO("move session:%{public}u failed,can not find source.", sourceOutputId);
         return false;
     }
     if (capturerIdStreamInfoMap_.find(sourceOutputId) == capturerIdStreamInfoMap_.end()) {
-        AUDIO_ERR_LOG("move session:%{public}u failed,can not find session.", sourceOutputId);
+        HILOG_COMM_INFO("move session:%{public}u failed,can not find session", sourceOutputId);
         return false;
     }
     if (!capturerIdStreamInfoMap_[sourceOutputId].streamInfo.isMoveAble) {
-        AUDIO_ERR_LOG("move session:%{public}u failed,session is not moveable.", sourceOutputId);
+        HILOG_COMM_INFO("move session:%{public}u failed,session is not moveable.", sourceOutputId);
         return false;
     }
     return true;
@@ -794,26 +793,26 @@ bool HpaeManager::CheckMoveSourceOutput(uint32_t sourceOutputId, const std::stri
 bool HpaeManager::CheckMoveSinkInput(uint32_t sinkInputId, const std::string &sinkName)
 {
     if (sinkName.empty()) {
-        AUDIO_ERR_LOG("move session:%{public}u failed,sink name is empty.", sinkInputId);
+        HILOG_COMM_INFO("move session:%{public}u failed,sink name is empty.", sinkInputId);
         return false;
     }
     std::shared_ptr<IHpaeRendererManager> rendererManager = GetRendererManagerByName(sinkName);
     if (rendererManager == nullptr || !rendererManager->IsInit()) {
-        AUDIO_ERR_LOG("move session:%{public}u failed, can not find sink:%{public}s or sink is not open.",
+        HILOG_COMM_INFO("move session:%{public}u failed, can not find sink:%{public}s or sink is not open.",
             sinkInputId, sinkName.c_str());
         return false;
     }
     std::shared_ptr<IHpaeRendererManager> oldRendererManager = GetRendererManagerById(sinkInputId);
     if (oldRendererManager == nullptr) {
-        AUDIO_ERR_LOG("move session:%{public}u failed,can not find sink", sinkInputId);
+        HILOG_COMM_INFO("move session:%{public}u failed,can not find sink", sinkInputId);
         return false;
     }
     if (rendererIdStreamInfoMap_.find(sinkInputId) == rendererIdStreamInfoMap_.end()) {
-        AUDIO_ERR_LOG("move session:%{public}u failed,can not find session", sinkInputId);
+        HILOG_COMM_INFO("move session:%{public}u failed,can not find session", sinkInputId);
         return false;
     }
     if (!rendererIdStreamInfoMap_[sinkInputId].streamInfo.isMoveAble) {
-        AUDIO_ERR_LOG("move session:%{public}u failed,session is not moveable.", sinkInputId);
+        HILOG_COMM_INFO("move session:%{public}u failed,session is not moveable.", sinkInputId);
         return false;
     }
     return true;
@@ -831,7 +830,7 @@ int32_t HpaeManager::MoveSinkInputByIndexOrName(uint32_t sinkInputId, uint32_t s
 
         std::string name = rendererIdSinkNameMap_[sinkInputId];
         if (sinkName == name) {
-            AUDIO_INFO_LOG("sink:%{public}s is the same, no need move session:%{public}u", sinkName.c_str(),
+            HILOG_COMM_INFO("sink:%{public}s is the same, no need move session:%{public}u", sinkName.c_str(),
                 sinkInputId);
             if (auto serviceCallback = serviceCallback_.lock()) {
                 serviceCallback->OnMoveSinkInputByIndexOrNameCb(SUCCESS);
@@ -1135,7 +1134,7 @@ void HpaeManager::HandleDumpSourceInfo(std::string deviceName, std::string dumpS
 
 void HpaeManager::HandleReloadDeviceResult(std::string deviceName, int32_t result)
 {
-    AUDIO_INFO_LOG("deviceName:%{public}s result:%{public}d ", deviceName.c_str(), result);
+    HILOG_COMM_INFO("deviceName:%{public}s result:%{public}d", deviceName.c_str(), result);
     auto serviceCallback = serviceCallback_.lock();
     if (serviceCallback && result == SUCCESS) {
         if (sinkNameSinkIdMap_.find(deviceName) != sinkNameSinkIdMap_.end()) {
@@ -2230,7 +2229,7 @@ void HpaeManager::NotifyAccountsChanged()
     }
     std::string value = HpaePolicyManager::GetInstance().GetAudioParameter("primary", AudioParamKey::PARAM_KEY_STATE,
         "source_type_live_aec_supported");
-    AUDIO_INFO_LOG("live_aec_supported: %{public}s", value.c_str());
+    HILOG_COMM_INFO("live_aec_supported: %{public}s", value.c_str());
     if (value == "true") {
         return true;
     }
@@ -2242,7 +2241,7 @@ void HpaeManager::LoadEffectLive()
     AudioSettingProvider &settingProvider = AudioSettingProvider::GetInstance(AUDIO_POLICY_SERVICE_ID);
     ErrCode ret = ERROR;
     if (!settingProvider.CheckOsAccountReady()) {
-        AUDIO_ERR_LOG("OS account not ready");
+        HILOG_COMM_INFO("OS account not ready");
     } else {
         std::string configValue;
         ret = settingProvider.GetStringValue("live_effect_enable", configValue, "system");
@@ -2253,7 +2252,7 @@ void HpaeManager::LoadEffectLive()
     }
     std::string state = HpaePolicyManager::GetInstance().GetAudioParameter(
         "primary", AudioParamKey::PARAM_KEY_STATE, "live_effect_supported");
-    AUDIO_INFO_LOG("EffectLive %{public}s", effectLiveState_.c_str());
+    HILOG_COMM_INFO("EffectLive %{public}s", effectLiveState_.c_str());
     if (state != "true") {
         effectLiveState_ = "NoSupport";
         return;
@@ -2288,7 +2287,7 @@ bool HpaeManager::SetEffectLiveParameter(const std::vector<std::pair<std::string
     effectLiveState_ = paramValue;
     AudioSettingProvider &settingProvider = AudioSettingProvider::GetInstance(AUDIO_POLICY_SERVICE_ID);
     if (!settingProvider.CheckOsAccountReady()) {
-        AUDIO_ERR_LOG("OS account not ready");
+        HILOG_COMM_INFO("OS account not ready");
         return false;
     }
 
diff --git a/services/audio_engine/manager/src/hpae_offload_renderer_manager.cpp b/services/audio_engine/manager/src/hpae_offload_renderer_manager.cpp
index 92c7470cd0dcbcf3e7e24f5493346189549a753d..6044deb328e42c8f34484f6dd7a450a09b7eae9b 100644
--- a/services/audio_engine/manager/src/hpae_offload_renderer_manager.cpp
+++ b/services/audio_engine/manager/src/hpae_offload_renderer_manager.cpp
@@ -80,7 +80,7 @@ void HpaeOffloadRendererManager::AddSingleNodeToSink(const std::shared_ptr<HpaeS
     nodeInfo.statusCallback = weak_from_this();
     node->SetNodeInfo(nodeInfo);
     uint32_t sessionId = nodeInfo.sessionId;
-    AUDIO_INFO_LOG("[FinishMove] session:%{public}u to sink:offload", sessionId);
+    HILOG_COMM_INFO("[FinishMove] session:%{public}u to sink:offload", sessionId);
     sinkInputNode_ = node;
     sessionInfo_.state = node->GetState();
 
@@ -291,7 +291,7 @@ void HpaeOffloadRendererManager::MoveAllStreamToNewSink(const std::string &sinkN
         if (moveType == MOVE_ALL || std::find(moveIds.begin(), moveIds.end(), sessionId) != moveIds.end()) {
             sinkInputs.emplace_back(sinkInputNode_);
             DeleteInputSession();
-            AUDIO_INFO_LOG("[StartMove] session: %{public}u,sink [offload] --> [%{public}s]",
+            HILOG_COMM_INFO("[StartMove] session: %{public}u,sink [offload] --> [%{public}s]",
                 sessionId, sinkName.c_str());
         }
     }
diff --git a/services/audio_engine/manager/src/hpae_renderer_manager.cpp b/services/audio_engine/manager/src/hpae_renderer_manager.cpp
index 2d4654571654459186b44db80746618ac852b3fc..da52b8fe04148f4a36260a379d4dd621d47b34f8 100644
--- a/services/audio_engine/manager/src/hpae_renderer_manager.cpp
+++ b/services/audio_engine/manager/src/hpae_renderer_manager.cpp
@@ -115,7 +115,7 @@ void HpaeRendererManager::AddSingleNodeToSink(const std::shared_ptr<HpaeSinkInpu
     SetSessionState(sessionId, node->GetState());
     sessionNodeMap_[sessionId].sceneType = nodeInfo.sceneType;
 
-    AUDIO_INFO_LOG("[FinishMove] session :%{public}u to sink:%{public}s, sceneType is %{public}d",
+    HILOG_COMM_INFO("[FinishMove] session :%{public}u to sink:%{public}s, sceneType is %{public}d",
         sessionId, sinkInfo_.deviceClass.c_str(), nodeInfo.sceneType);
     CreateEffectAndConnect(nodeInfo, isConnect);
 }
@@ -513,7 +513,7 @@ void HpaeRendererManager::MoveAllStreamToNewSink(const std::string &sinkName,
     for (const auto &it : sessionIds) {
         DeleteInputSessionForMove(it);
     }
-    AUDIO_INFO_LOG("[StartMove] session:%{public}s to sink name:%{public}s, move type:%{public}d",
+    HILOG_COMM_INFO("StartMove] session:%{public}s to sink name:%{public}s, move type:%{public}d",
         idStr.c_str(), name.c_str(), moveType);
     TriggerCallback(MOVE_ALL_SINK_INPUT, sinkInputs, name, moveType);
 }
diff --git a/services/audio_engine/node/src/hpae_offload_sinkoutput_node.cpp b/services/audio_engine/node/src/hpae_offload_sinkoutput_node.cpp
index 48330599df1e1c54b71c4ccfb97fb66312de8708..7be706cf9e1250758e7b846147b44159085ee04e 100644
--- a/services/audio_engine/node/src/hpae_offload_sinkoutput_node.cpp
+++ b/services/audio_engine/node/src/hpae_offload_sinkoutput_node.cpp
@@ -114,7 +114,6 @@ void HpaeOffloadSinkOutputNode::DoProcess()
     int32_t ret = ProcessRenderFrame();
     // if renderframe faild, sleep and return directly
     // if renderframe full, unlock the powerlock
-    retryCount_ = 1;
     if (ret == OFFLOAD_FULL) {
         if (hdiPolicyState_ == OFFLOAD_INACTIVE_BACKGROUND || GetStreamType() == STREAM_MOVIE) {
             RunningLock(false);
@@ -340,7 +339,7 @@ StreamManagerState HpaeOffloadSinkOutputNode::GetSinkState(void)
 
 int32_t HpaeOffloadSinkOutputNode::SetSinkState(StreamManagerState sinkState)
 {
-    AUDIO_INFO_LOG("Sink[%{public}s] state change:[%{public}s]-->[%{public}s]",
+    HILOG_COMM_INFO("Sink[%{public}s] state change:[%{public}s]-->[%{public}s]",
         GetDeviceClass().c_str(), ConvertStreamManagerState2Str(state_).c_str(),
         ConvertStreamManagerState2Str(sinkState).c_str());
     state_ = sinkState;
diff --git a/services/audio_engine/node/src/hpae_remote_sink_output_node.cpp b/services/audio_engine/node/src/hpae_remote_sink_output_node.cpp
index 206a7e2c2f5b23ab38948002270d0015b75cc251..1a06dac8b380edfa59f3a13b62b39282c2e2b405 100644
--- a/services/audio_engine/node/src/hpae_remote_sink_output_node.cpp
+++ b/services/audio_engine/node/src/hpae_remote_sink_output_node.cpp
@@ -362,7 +362,7 @@ StreamManagerState HpaeRemoteSinkOutputNode::GetSinkState(void)
 
 int32_t HpaeRemoteSinkOutputNode::SetSinkState(StreamManagerState sinkState)
 {
-    AUDIO_INFO_LOG("Sink[%{public}s] state change:[%{public}s]-->[%{public}s]",
+    HILOG_COMM_INFO("Sink[%{public}s] state change:[%{public}s]-->[%{public}s]",
         GetDeviceClass().c_str(), ConvertStreamManagerState2Str(state_).c_str(),
         ConvertStreamManagerState2Str(sinkState).c_str());
         state_ = sinkState;
diff --git a/services/audio_engine/node/src/hpae_sink_input_node.cpp b/services/audio_engine/node/src/hpae_sink_input_node.cpp
index 08eb86c9f0d2e44f0018b416122d0f6b63ac26b1..ec048fa666f310e397d5abc835aab29c71a77e87 100644
--- a/services/audio_engine/node/src/hpae_sink_input_node.cpp
+++ b/services/audio_engine/node/src/hpae_sink_input_node.cpp
@@ -240,7 +240,7 @@ bool HpaeSinkInputNode::Drain()
 
 int32_t HpaeSinkInputNode::SetState(HpaeSessionState renderState)
 {
-    AUDIO_INFO_LOG("Sink[%{public}s]->Session[%{public}u - %{public}d] state change:[%{public}s]-->[%{public}s]",
+    HILOG_COMM_INFO("Sink[%{public}s]->Session[%{public}u - %{public}d] state change:[%{public}s]-->[%{public}s]",
         GetDeviceClass().c_str(), GetSessionId(), GetStreamType(), ConvertSessionState2Str(state_).c_str(),
         ConvertSessionState2Str(renderState).c_str());
     state_ = renderState;
diff --git a/services/audio_engine/node/src/hpae_sink_output_node.cpp b/services/audio_engine/node/src/hpae_sink_output_node.cpp
index 8bb79055b4caaa5754ffd2d030fce8f52fe49f8c..973bae5197216ce6bfbc1e4a1c382b46549e992b 100644
--- a/services/audio_engine/node/src/hpae_sink_output_node.cpp
+++ b/services/audio_engine/node/src/hpae_sink_output_node.cpp
@@ -328,7 +328,7 @@ StreamManagerState HpaeSinkOutputNode::GetSinkState(void)
 
 int32_t HpaeSinkOutputNode::SetSinkState(StreamManagerState sinkState)
 {
-    AUDIO_INFO_LOG("Sink[%{public}s] state change:[%{public}s]-->[%{public}s]",
+    HILOG_COMM_INFO("Sink[%{public}s] state change:[%{public}s]-->[%{public}s]",
         GetDeviceClass().c_str(), ConvertStreamManagerState2Str(state_).c_str(),
         ConvertStreamManagerState2Str(sinkState).c_str());
         state_ = sinkState;
diff --git a/services/audio_engine/node/src/hpae_source_input_node.cpp b/services/audio_engine/node/src/hpae_source_input_node.cpp
index c62db3b9aa8e7d1871168333782d9de54f1641af..e51dc7439742496072ed182cda5c73d19870b20e 100644
--- a/services/audio_engine/node/src/hpae_source_input_node.cpp
+++ b/services/audio_engine/node/src/hpae_source_input_node.cpp
@@ -475,7 +475,7 @@ StreamManagerState HpaeSourceInputNode::GetSourceState(void)
 
 int32_t HpaeSourceInputNode::SetSourceState(StreamManagerState sourceState)
 {
-    AUDIO_INFO_LOG("Source[%{public}s] state change:[%{public}s]-->[%{public}s]",
+    HILOG_COMM_INFO("Source[%{public}s] state change:[%{public}s]-->[%{public}s]",
         GetDeviceClass().c_str(), ConvertStreamManagerState2Str(state_).c_str(),
         ConvertStreamManagerState2Str(sourceState).c_str());
     state_ = sourceState;
diff --git a/services/audio_engine/node/src/hpae_source_output_node.cpp b/services/audio_engine/node/src/hpae_source_output_node.cpp
index 083001ed0fea3174ea6e62e000811e5c45309bcb..e1348d74040efa6eb96c482848f0c454d7181ca0 100644
--- a/services/audio_engine/node/src/hpae_source_output_node.cpp
+++ b/services/audio_engine/node/src/hpae_source_output_node.cpp
@@ -184,7 +184,7 @@ void HpaeSourceOutputNode::DisConnectWithInfo(const std::shared_ptr<OutputNode<H
 
 int32_t HpaeSourceOutputNode::SetState(HpaeSessionState captureState)
 {
-    AUDIO_INFO_LOG(" Capturer[%{public}s]->Session[%{public}u - %{public}d] state change:[%{public}s]-->[%{public}s]",
+    HILOG_COMM_INFO("Capturer[%{public}s]->Session[%{public}u - %{public}d] state change:[%{public}s]-->[%{public}s]",
         GetDeviceClass().c_str(), GetSessionId(), GetStreamType(), ConvertSessionState2Str(state_).c_str(),
         ConvertSessionState2Str(captureState).c_str());
     state_ = captureState;