diff --git a/frameworks/native/audioloopback/include/audio_loopback_private.h b/frameworks/native/audioloopback/include/audio_loopback_private.h
index 672478d0d264a31ae967f5971dfe91d6a9136e56..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_;
diff --git a/frameworks/native/audioloopback/src/audio_loopback.cpp b/frameworks/native/audioloopback/src/audio_loopback.cpp
index 2bd29865da0cd0930639e623424b7b5722e6f65a..cfabd92d0eb45e632f943c3ad75e5137aefe4a8b 100644
--- a/frameworks/native/audioloopback/src/audio_loopback.cpp
+++ b/frameworks/native/audioloopback/src/audio_loopback.cpp
@@ -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 %{public}f", 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,7 +477,7 @@ 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();
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..1c72321c5b99b2eedcdf1eddca0f775279ae30c8
--- /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..ba9c38d40287c25bfe4d635053b10b7cd31e6d54
--- /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 28746a574f6c63df37d4baa5f4c3840054c974f3..dad7d50ee1191ef185505eee06322649dc2d401e 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), true);
     EXPECT_EQ(audioLoopback->Enable(false), 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/hdiadapter_new/source/audio_capture_source.cpp b/frameworks/native/hdiadapter_new/source/audio_capture_source.cpp
index 4cf9082123cd65956224d4b17dec706804152bae..c32ed4c20d65a572116ed85f0efacb57e8fed714 100644
--- a/frameworks/native/hdiadapter_new/source/audio_capture_source.cpp
+++ b/frameworks/native/hdiadapter_new/source/audio_capture_source.cpp
@@ -749,7 +749,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/services/audio_engine/manager/src/hpae_capturer_manager.cpp b/services/audio_engine/manager/src/hpae_capturer_manager.cpp
index 4aa8d2f2303ca8be3721b9fe19def9507fd3852c..0289cb212b976448a3c53ce828dfab1c30e6fad9 100644
--- a/services/audio_engine/manager/src/hpae_capturer_manager.cpp
+++ b/services/audio_engine/manager/src/hpae_capturer_manager.cpp
@@ -852,7 +852,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();
@@ -916,7 +916,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);
     if (moveType == MOVE_ALL) {
         TriggerSyncCallback(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 8188d99650525f394a18926819afca9e37d6acb3..c90ac6aecbebac1eb8a22fd7465e51903ebf2d5f 100644
--- a/services/audio_engine/manager/src/hpae_inner_capturer_manager.cpp
+++ b/services/audio_engine/manager/src/hpae_inner_capturer_manager.cpp
@@ -76,7 +76,7 @@ void HpaeInnerCapturerManager::AddSingleNodeToSinkInner(const std::shared_ptr<Hp
     }
 
     if (node->GetState() == HPAE_SESSION_RUNNING) {
-        AUDIO_INFO_LOG("[FinishMove] session:%{public}u connect to sink:%{public}s",
+        HILOG_COMM_INFO("[FinishMove] session:%{public}u connect to sink:%{public}s",
             sessionId, sinkInfo_.deviceClass.c_str());
         ConnectRendererInputSessionInner(sessionId);
     }
@@ -118,7 +118,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);
     if (moveType == MOVE_ALL) {
         TriggerSyncCallback(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 af46cffa3299c1efc9e229c2b82c45316d1634bf..c0af502aa99a14d1c887c3e6ed05d0913029dcce 100644
--- a/services/audio_engine/manager/src/hpae_manager.cpp
+++ b/services/audio_engine/manager/src/hpae_manager.cpp
@@ -738,7 +738,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]);
@@ -778,8 +778,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);
             }
@@ -798,7 +797,7 @@ int32_t HpaeManager::MoveSourceOutputByIndexOrName(
 bool HpaeManager::CheckMoveSourceOutput(uint32_t sourceOutputId, const std::string &sourceName)
 {
     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);
         HpaeStreamMoveMonitor::ReportStreamMoveException(0, sourceOutputId, HPAE_STREAM_CLASS_TYPE_RECORD,
             "", sourceName, "can not find session");
         return false;
@@ -806,27 +805,27 @@ bool HpaeManager::CheckMoveSourceOutput(uint32_t sourceOutputId, const std::stri
     std::shared_ptr<IHpaeCapturerManager> oldCaptureManager = GetCapturerManagerById(sourceOutputId);
     HpaeStreamInfo stream = capturerIdStreamInfoMap_[sourceOutputId].streamInfo;
     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);
         HpaeStreamMoveMonitor::ReportStreamMoveException(stream.uid, sourceOutputId,
             HPAE_STREAM_CLASS_TYPE_RECORD, "", sourceName, "can not find source");
         return false;
     }
     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);
         HpaeStreamMoveMonitor::ReportStreamMoveException(stream.uid, sourceOutputId,
             HPAE_STREAM_CLASS_TYPE_RECORD, capturerIdSourceNameMap_[sourceOutputId], "", "source name is empty");
         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());
         HpaeStreamMoveMonitor::ReportStreamMoveException(stream.uid, sourceOutputId,
             HPAE_STREAM_CLASS_TYPE_RECORD, capturerIdSourceNameMap_[sourceOutputId], sourceName, "source is not open");
         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);
         HpaeStreamMoveMonitor::ReportStreamMoveException(stream.uid, sourceOutputId, HPAE_STREAM_CLASS_TYPE_RECORD,
             capturerIdSourceNameMap_[sourceOutputId], sourceName, "session is not moveable");
         return false;
@@ -837,7 +836,7 @@ bool HpaeManager::CheckMoveSourceOutput(uint32_t sourceOutputId, const std::stri
 bool HpaeManager::CheckMoveSinkInput(uint32_t sinkInputId, const std::string &sinkName)
 {
     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);
         HpaeStreamMoveMonitor::ReportStreamMoveException(0, sinkInputId, HPAE_STREAM_CLASS_TYPE_PLAY,
             "", sinkName, "can not find session");
         return false;
@@ -845,27 +844,27 @@ bool HpaeManager::CheckMoveSinkInput(uint32_t sinkInputId, const std::string &si
     std::shared_ptr<IHpaeRendererManager> oldRendererManager = GetRendererManagerById(sinkInputId);
     HpaeStreamInfo stream = rendererIdStreamInfoMap_[sinkInputId].streamInfo;
     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);
         HpaeStreamMoveMonitor::ReportStreamMoveException(stream.uid, sinkInputId, HPAE_STREAM_CLASS_TYPE_PLAY,
             "", sinkName, "src sink is not find");
         return false;
     }
     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);
         HpaeStreamMoveMonitor::ReportStreamMoveException(stream.uid, sinkInputId, HPAE_STREAM_CLASS_TYPE_PLAY,
             rendererIdSinkNameMap_[sinkInputId], sinkName, "sink name is empty");
         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());
         HpaeStreamMoveMonitor::ReportStreamMoveException(stream.uid, sinkInputId, HPAE_STREAM_CLASS_TYPE_PLAY,
             rendererIdSinkNameMap_[sinkInputId], sinkName, "dest sink is not open");
         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);
         HpaeStreamMoveMonitor::ReportStreamMoveException(stream.uid, sinkInputId, HPAE_STREAM_CLASS_TYPE_PLAY,
             rendererIdSinkNameMap_[sinkInputId], sinkName, "session is not moveable");
         return false;
@@ -885,7 +884,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);
@@ -1216,7 +1215,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()) {
@@ -2357,7 +2356,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;
     }
@@ -2369,7 +2368,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");
@@ -2380,7 +2379,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;
@@ -2415,7 +2414,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 cbba12e6759950c205638b8a099c77073f86d698..88f0a67d31ffb42838a2088399fea79a2fcf3a93 100644
--- a/services/audio_engine/manager/src/hpae_offload_renderer_manager.cpp
+++ b/services/audio_engine/manager/src/hpae_offload_renderer_manager.cpp
@@ -83,7 +83,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();
 
@@ -294,7 +294,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 d47d5a968dcc96f00514b6994b62e5b887157f67..0cfa424c6c912d6dd0696119c32e367274447889 100644
--- a/services/audio_engine/manager/src/hpae_renderer_manager.cpp
+++ b/services/audio_engine/manager/src/hpae_renderer_manager.cpp
@@ -120,7 +120,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);
 }
@@ -544,7 +544,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);
     if (moveType == MOVE_ALL) {
         TriggerSyncCallback(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 b4b93fcfda92371d56f4cc8d6ff9f9bac9ef313e..8a93b08a9e321e57a57379e4d6fa7ba1b9cacebd 100644
--- a/services/audio_engine/node/src/hpae_offload_sinkoutput_node.cpp
+++ b/services/audio_engine/node/src/hpae_offload_sinkoutput_node.cpp
@@ -341,7 +341,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 46bc7531410513050730bb7cf14aa16e29c3e315..50a4f00c39d25b0b5d417798df7ab5cde0a8d1ce 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
@@ -364,7 +364,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 fa7b86c1bacbd41df052420e0d2782a4613443b0..002f0dd0011e27f696778a8a172aff49e7f4ab4b 100644
--- a/services/audio_engine/node/src/hpae_sink_input_node.cpp
+++ b/services/audio_engine/node/src/hpae_sink_input_node.cpp
@@ -259,7 +259,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 f71c7878c7107d87b35692bfeaa909e159559bb3..ec62eee05e118326bb8da9c816a881f85ed79798 100644
--- a/services/audio_engine/node/src/hpae_sink_output_node.cpp
+++ b/services/audio_engine/node/src/hpae_sink_output_node.cpp
@@ -335,7 +335,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..073bddfe285f449ca3134d61e77435993e63836b 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;