diff --git a/common/src/daudio_util.cpp b/common/src/daudio_util.cpp
index 78f50ed52b4a19894b415bacfe537906a5297912..28659a3554d4be8081c8139dc665d5e639ec2c41 100644
--- a/common/src/daudio_util.cpp
+++ b/common/src/daudio_util.cpp
@@ -129,10 +129,8 @@ int32_t GetLocalDeviceNetworkId(std::string &networkId)
 {
     NodeBasicInfo basicInfo = { { 0 } };
     int32_t ret = GetLocalNodeDeviceInfo(PKG_NAME.c_str(), &basicInfo);
-    if (ret != DH_SUCCESS) {
-        DHLOGE("Failed to obtain the network ID of the local device. ret: %d", ret);
-        return ret;
-    }
+    CHECK_AND_RETURN_RET_LOG(ret != DH_SUCCESS, ret,
+        "Failed to get the local device info. ret: %d", ret);
 
     networkId = std::string(basicInfo.networkId);
     return DH_SUCCESS;
@@ -199,9 +197,7 @@ int32_t GetDevTypeByDHId(int32_t dhId)
 void GetCurrentTime(int64_t &tvSec, int64_t &tvNSec)
 {
     struct timespec time;
-    if (clock_gettime(CLOCK_MONOTONIC, &time) < 0) {
-        DHLOGE("Get current time failed");
-    }
+    CHECK_AND_RETURN_LOG(clock_gettime(CLOCK_MONOTONIC, &time) < 0, "Get current time failed");
     tvSec = time.tv_sec;
     tvNSec = time.tv_nsec;
 }
@@ -253,10 +249,8 @@ int32_t GetAudioParamInt(const std::string &params, const std::string &key, int3
         DHLOGE("Get audio param string fail, error code %d.", ret);
         return ret;
     }
-    if (!CheckIsNum(val)) {
-        DHLOGE("String is not number. str:%s.", val.c_str());
-        return ERR_DH_AUDIO_NOT_SUPPORT;
-    }
+    CHECK_AND_RETURN_RET_LOG(!CheckIsNum(val), ERR_DH_AUDIO_NOT_SUPPORT,
+        "The input parameter is not number type. str:%s.", val.c_str());
     value = std::stoi(val);
     return DH_SUCCESS;
 }
@@ -281,25 +275,18 @@ bool JsonParamCheck(const json &jsonObj, const std::initializer_list<std::string
         }
         JsonTypeCheckFunc &func = iter->second;
         bool res = (*func)(jsonObj, *it);
-        if (!res) {
-            DHLOGE("The key %s value format in json is illegal.", (*it).c_str());
-            return false;
-        }
+        CHECK_AND_RETURN_RET_LOG(!res, false,
+            "The key %s value format in json is illegal.", (*it).c_str());
     }
     return true;
 }
 
 static bool IsString(const cJSON *jsonObj, const std::string &key)
 {
-    if (jsonObj == nullptr || !cJSON_IsObject(jsonObj)) {
-        DHLOGE("JSON parameter is invalid.");
-        return false;
-    }
+    CHECK_AND_RETURN_RET_LOG(jsonObj == nullptr || !cJSON_IsObject(jsonObj),
+        false, "The input jsonObj invalid.");
     cJSON *paramValue = cJSON_GetObjectItemCaseSensitive(jsonObj, key.c_str());
-    if (paramValue == nullptr) {
-        DHLOGE("paramValue is null");
-        return false;
-    }
+    CHECK_AND_RETURN_RET_LOG(paramValue == nullptr, false, "The cJSON object paramValue is null");
 
     if (cJSON_IsString(paramValue)) {
         return true;
@@ -309,10 +296,8 @@ static bool IsString(const cJSON *jsonObj, const std::string &key)
 
 bool CJsonParamCheck(const cJSON *jsonObj, const std::initializer_list<std::string> &keys)
 {
-    if (jsonObj == nullptr || !cJSON_IsObject(jsonObj)) {
-        DHLOGE("JSON parameter is invalid.");
-        return false;
-    }
+    CHECK_AND_RETURN_RET_LOG(jsonObj == nullptr || !cJSON_IsObject(jsonObj),
+        false, "The input jsonObj invalid.");
 
     for (auto it = keys.begin(); it != keys.end(); it++) {
         cJSON *paramValue = cJSON_GetObjectItemCaseSensitive(jsonObj, (*it).c_str());
@@ -321,10 +306,8 @@ bool CJsonParamCheck(const cJSON *jsonObj, const std::initializer_list<std::stri
             return false;
         }
         bool res = IsString(jsonObj, *it);
-        if (!res) {
-            DHLOGE("The key %s value format in JSON is illegal.", (*it).c_str());
-            return false;
-        }
+        CHECK_AND_RETURN_RET_LOG(!res, false,
+            "The key %s value format in JSON is illegal.", (*it).c_str());
     }
     return true;
 }
@@ -356,10 +339,7 @@ int64_t GetCurNano()
     struct timespec time;
     clockid_t clockId = CLOCK_MONOTONIC;
     int ret = clock_gettime(clockId, &time);
-    if (ret < 0) {
-        DHLOGE("GetCurNanoTime fail, ret: %d", ret);
-        return result;
-    }
+    CHECK_AND_RETURN_RET_LOG(ret < 0, result, "GetCurNanoTime fail, ret: %d", ret);
     result = (time.tv_sec * AUDIO_NS_PER_SECOND) + time.tv_nsec;
     return result;
 }
@@ -367,10 +347,7 @@ int64_t GetCurNano()
 int32_t AbsoluteSleep(int64_t nanoTime)
 {
     int32_t ret = -1;
-    if (nanoTime <= 0) {
-        DHLOGE("AbsoluteSleep invalid sleep time : %d ns", nanoTime);
-        return ret;
-    }
+    CHECK_AND_RETURN_RET_LOG(nanoTime <= 0, ret, "AbsoluteSleep invalid sleep time : %d ns", nanoTime);
     struct timespec time;
     time.tv_sec = nanoTime / AUDIO_NS_PER_SECOND;
     time.tv_nsec = nanoTime - (time.tv_sec * AUDIO_NS_PER_SECOND);
@@ -380,6 +357,7 @@ int32_t AbsoluteSleep(int64_t nanoTime)
     if (ret != 0) {
         DHLOGE("AbsoluteSleep may failed, ret is : %d", ret);
     }
+    CHECK_AND_LOG(ret != 0, "AbsoluteSleep may failed, ret is : %d", ret);
     return ret;
 }
 
@@ -486,16 +464,10 @@ std::string ParseStringFromArgs(std::string args, const char *key)
 template <typename T>
 bool GetSysPara(const char *key, T &value)
 {
-    if (key == nullptr) {
-        DHLOGE("GetSysPara: key is nullptr");
-        return false;
-    }
+    CHECK_AND_RETURN_RET_LOG(key == nullptr, false, "GetSysPara: key is nullptr");
     char paraValue[20] = {0}; // 20 for system parameter
     auto res = GetParameter(key, "-1", paraValue, sizeof(paraValue));
-    if (res <= 0) {
-        DHLOGD("GetSysPara fail, key:%{public}s res:%{public}d", key, res);
-        return false;
-    }
+    CHECK_AND_RETURN_RET_LOG(res <= 0, false, "GetSysPara fail, key:%{public}s res:%{public}d", key, res);
     DHLOGI("GetSysPara: key:%{public}s value:%{public}s", key, paraValue);
     std::stringstream valueStr;
     valueStr << paraValue;
diff --git a/common/test/unittest/src/daudio_utils_test.cpp b/common/test/unittest/src/daudio_utils_test.cpp
index 0945e4a52636a6b5c1e1b2b67e7265d87ab41473..e6976b22868c8b8adbac05e138a75ae96197bcb6 100644
--- a/common/test/unittest/src/daudio_utils_test.cpp
+++ b/common/test/unittest/src/daudio_utils_test.cpp
@@ -156,13 +156,21 @@ HWTEST_F(DAudioUtilsTest, DAudioUtilTest_001, TestSize.Level1)
  */
 HWTEST_F(DAudioUtilsTest, DAudioUtilTest_002, TestSize.Level1)
 {
+    int32_t eventType = 200;
+    GetEventNameByType(eventType);
+    cJSON * jsonObj = nullptr;
+    std::initializer_list<std::string> keys = { "one", "two" };
+    CJsonParamCheck(jsonObj, keys);
+    jsonObj = cJSON_CreateObject();
+    cJSON_AddStringToObject(jsonObj, "one", "one");
+    cJSON_AddNumberToObject(jsonObj, "two", 2);
+    CJsonParamCheck(jsonObj, keys);
+
     int64_t tvSec;
     int64_t tvNSec;
     GetCurrentTime(tvSec, tvNSec);
-
     int64_t curNano = GetCurNano();
     EXPECT_NE(0, curNano);
-
     int32_t ret = AbsoluteSleep(curNano);
     EXPECT_EQ(0, ret);
 }
@@ -300,24 +308,5 @@ HWTEST_F(DAudioUtilsTest, DAudioUtilTest_007, TestSize.Level1)
     tempDevIdStr = "Test1";
     EXPECT_EQ(true, CheckDevIdIsLegal(tempDevIdStr));
 }
-
-/**
- * @tc.name: DAudioLogTest_008
- * @tc.desc: Verify the GetEventNameByType function.
- * @tc.type: FUNC
- * @tc.require: AR000H0E5U
- */
-HWTEST_F(DAudioUtilsTest, DAudioUtilTest_008, TestSize.Level1)
-{
-    int32_t eventType = 200;
-    GetEventNameByType(eventType);
-    cJSON * jsonObj = nullptr;
-    std::initializer_list<std::string> keys = { "one", "two" };
-    CJsonParamCheck(jsonObj, keys);
-    jsonObj = cJSON_CreateObject();
-    cJSON_AddStringToObject(jsonObj, "one", "one");
-    cJSON_AddNumberToObject(jsonObj, "two", 2);
-    CJsonParamCheck(jsonObj, keys);
-}
 } // namespace DistributedHardware
 } // namespace OHOS
diff --git a/services/audioclient/micclient/src/dmic_client.cpp b/services/audioclient/micclient/src/dmic_client.cpp
index 394a389b5cc9d7893d6dc8d9f08473239ca9bfe3..c1b941592de55e2159fee1d15963946d2a776456 100644
--- a/services/audioclient/micclient/src/dmic_client.cpp
+++ b/services/audioclient/micclient/src/dmic_client.cpp
@@ -131,10 +131,8 @@ int32_t DMicClient::AudioFwkClientSetUp()
     CHECK_NULL_RETURN(audioCapturer_, ERR_DH_AUDIO_CLIENT_CAPTURER_CREATE_FAILED);
     if (audioParam_.captureOpts.capturerFlags == MMAP_MODE) {
         int32_t ret = audioCapturer_->SetCapturerReadCallback(shared_from_this());
-        if (ret != DH_SUCCESS) {
-            DHLOGE("Client save read callback failed.");
-            return ERR_DH_AUDIO_CLIENT_CAPTURER_CREATE_FAILED;
-        }
+        CHECK_AND_RETURN_RET_LOG(ret != DH_SUCCESS, ERR_DH_AUDIO_CLIENT_CAPTURER_CREATE_FAILED,
+            "Client save read callback failed.");
     }
     return TransSetUp();
 }
@@ -251,16 +249,12 @@ void DMicClient::AudioFwkCaptureData()
             break;
         }
         int64_t endTime = GetNowTimeUs();
-        if (IsOutDurationRange(startTime, endTime, lastCaptureStartTime_)) {
-            DHLOGE("This time capture spend: %lld us, The interval of capture this time and the last time: %lld us",
-                endTime - startTime, startTime - lastCaptureStartTime_);
-        }
+        CHECK_AND_LOG(IsOutDurationRange(startTime, endTime, lastCaptureStartTime_),
+            "This time capture spend: %lld us, The interval of capture this time and the last time: %lld us",
+            endTime - startTime, startTime - lastCaptureStartTime_);
         lastCaptureStartTime_ = startTime;
     }
-    if (errorFlag) {
-        DHLOGE("Bytes read failed.");
-        return;
-    }
+    CHECK_AND_RETURN_LOG(errorFlag, "Bytes read failed.");
     if (isPauseStatus_.load()) {
         memset_s(audioData->Data(), audioData->Size(), 0, audioData->Size());
     }
@@ -271,23 +265,19 @@ void DMicClient::AudioFwkCaptureData()
 #endif
     int64_t startTransTime = GetNowTimeUs();
     int32_t ret = micTrans_->FeedAudioData(audioData);
-    if (ret != DH_SUCCESS) {
-        DHLOGE("Failed to send data.");
-    }
+    CHECK_AND_LOG(ret != DH_SUCCESS, "Failed to send data.");
     int64_t endTransTime = GetNowTimeUs();
-    if (IsOutDurationRange(startTransTime, endTransTime, lastTransStartTime_)) {
-        DHLOGE("This time send data spend: %lld us, The interval of send data this time and the last time: %lld us",
-            endTransTime - startTransTime, startTransTime - lastTransStartTime_);
-    }
+    CHECK_AND_LOG(IsOutDurationRange(startTransTime, endTransTime, lastTransStartTime_),
+        "This time send data spend: %lld us, The interval of send data this time and the last time: %lld us",
+        endTransTime - startTransTime, startTransTime - lastTransStartTime_);
     lastTransStartTime_ = startTransTime;
 }
 
 void DMicClient::CaptureThreadRunning()
 {
     DHLOGD("Start the capturer thread.");
-    if (pthread_setname_np(pthread_self(), CAPTURETHREAD) != DH_SUCCESS) {
-        DHLOGE("Capture data thread setname failed.");
-    }
+    CHECK_AND_LOG(pthread_setname_np(pthread_self(), CAPTURETHREAD) != DH_SUCCESS,
+        "Capture data thread setname failed.");
     while (isCaptureReady_.load()) {
         AudioFwkCaptureData();
     }
@@ -303,27 +293,21 @@ void DMicClient::OnReadData(size_t length)
 {
     AudioStandard::BufferDesc bufDesc;
     CHECK_NULL_VOID(audioCapturer_);
-    
-    if (audioCapturer_->GetBufferDesc(bufDesc) != DH_SUCCESS || bufDesc.bufLength == 0) {
-        DHLOGE("Get buffer desc failed.");
-        return;
-    }
+
+    CHECK_AND_RETURN_LOG(audioCapturer_->GetBufferDesc(bufDesc) != DH_SUCCESS || bufDesc.bufLength == 0,
+        "Get buffer desc failed.");
     CHECK_NULL_VOID(bufDesc.buffer);
 
     std::shared_ptr<AudioData> audioData = std::make_shared<AudioData>(audioParam_.comParam.frameSize);
-    if (audioData->Capacity() != bufDesc.bufLength) {
-        DHLOGE("Audio data length is not equal to buflength. datalength: %d, bufLength: %d",
-            audioData->Capacity(), bufDesc.bufLength);
-    }
-    if (memcpy_s(audioData->Data(), audioData->Capacity(), bufDesc.buffer, bufDesc.bufLength) != EOK) {
-        DHLOGE("Copy audio data failed.");
-    }
+    CHECK_AND_LOG(audioData->Capacity() != bufDesc.bufLength,
+        "Audio data length is not equal to buflength. datalength: %d, bufLength: %d",
+        audioData->Capacity(), bufDesc.bufLength);
+    CHECK_AND_LOG(memcpy_s(audioData->Data(), audioData->Capacity(), bufDesc.buffer, bufDesc.bufLength) != EOK,
+        "Copy audio data failed.");
     audioCapturer_->Enqueue(bufDesc);
 
     CHECK_NULL_VOID(micTrans_);
-    if (micTrans_->FeedAudioData(audioData) != DH_SUCCESS) {
-        DHLOGE("Failed to send data.");
-    }
+    CHECK_AND_LOG(micTrans_->FeedAudioData(audioData) != DH_SUCCESS, "Failed to send data.");
 }
 
 int32_t DMicClient::StopCapture()
diff --git a/services/audioclient/spkclient/src/dspeaker_client.cpp b/services/audioclient/spkclient/src/dspeaker_client.cpp
index 5a800462adb957621948ce4f981f387f968a8778..c02318378cfb1d46707280cd842d6410b98e5be8 100644
--- a/services/audioclient/spkclient/src/dspeaker_client.cpp
+++ b/services/audioclient/spkclient/src/dspeaker_client.cpp
@@ -101,21 +101,17 @@ int32_t DSpeakerClient::CreateAudioRenderer(const AudioParam &param)
         return DH_SUCCESS;
     }
     int32_t ret = audioRenderer_->SetRendererWriteCallback(shared_from_this());
-    if (ret != DH_SUCCESS) {
-        DHLOGE("Client save write callback failed.");
-        return ERR_DH_AUDIO_CLIENT_RENDER_CREATE_FAILED;
-    }
+    CHECK_AND_RETURN_RET_LOG(ret != DH_SUCCESS,
+        ERR_DH_AUDIO_CLIENT_RENDER_CREATE_FAILED, "Client save write callback failed.");
     return DH_SUCCESS;
 }
 
 void DSpeakerClient::OnWriteData(size_t length)
 {
-    AudioStandard::BufferDesc bufDesc;
     CHECK_NULL_VOID(audioRenderer_);
-    if (audioRenderer_->GetBufferDesc(bufDesc) != DH_SUCCESS || bufDesc.bufLength == 0) {
-        DHLOGE("Get buffer desc failed.");
-        return;
-    }
+    AudioStandard::BufferDesc bufDesc;
+    CHECK_AND_RETURN_LOG(audioRenderer_->GetBufferDesc(bufDesc) != DH_SUCCESS || bufDesc.bufLength == 0,
+        "Get buffer desc failed.");
     CHECK_NULL_VOID(bufDesc.buffer);
 
     std::shared_ptr<AudioData> audioData = nullptr;
@@ -134,19 +130,15 @@ void DSpeakerClient::OnWriteData(size_t length)
         DHLOGE("Audio data length is not equal to buflength. datalength: %d, bufLength: %d",
             audioData->Capacity(), bufDesc.bufLength);
     }
-    if (memcpy_s(bufDesc.buffer, bufDesc.bufLength, audioData->Data(), audioData->Capacity()) != EOK) {
-        DHLOGE("Copy audio data failed.");
-    }
+    CHECK_AND_LOG(memcpy_s(bufDesc.buffer, bufDesc.bufLength, audioData->Data(), audioData->Capacity()) != EOK,
+        "Copy audio data failed.");
     audioRenderer_->Enqueue(bufDesc);
 }
 
 int32_t DSpeakerClient::SetUp(const AudioParam &param)
 {
     int32_t ret = CreateAudioRenderer(param);
-    if (ret != DH_SUCCESS) {
-        DHLOGE("Set up failed, Create Audio renderer failed.");
-        return ret;
-    }
+    CHECK_AND_RETURN_RET_LOG(ret != DH_SUCCESS, ret, "Set up failed, Create Audio renderer failed.");
     CHECK_NULL_RETURN(speakerTrans_, ERR_DH_AUDIO_NULLPTR);
 
     ret = speakerTrans_->SetUp(audioParam_, audioParam_, shared_from_this(), CAP_SPK);
@@ -155,10 +147,7 @@ int32_t DSpeakerClient::SetUp(const AudioParam &param)
         return ret;
     }
     ret = speakerTrans_->Start();
-    if (ret != DH_SUCCESS) {
-        DHLOGE("Speaker trans start failed.");
-        return ret;
-    }
+    CHECK_AND_RETURN_RET_LOG(ret != DH_SUCCESS, ret, "Speaker trans start failed.");
     auto pid = getpid();
     ret = AudioStandard::AudioSystemManager::GetInstance()->RegisterVolumeKeyEventCallback(pid, shared_from_this());
     if (ret != DH_SUCCESS) {
@@ -529,10 +518,7 @@ int32_t DSpeakerClient::SetAudioParameters(const AudioEvent &event)
     }
     DHLOGD("volume level = %d.", audioVolumeLevel);
     ret = AudioStandard::AudioSystemManager::GetInstance()->SetVolume(volumeType, audioVolumeLevel);
-    if (ret != DH_SUCCESS) {
-        DHLOGE("Voloume set failed.");
-        return ERR_DH_AUDIO_CLIENT_SET_VOLUME_FAILED;
-    }
+    CHECK_AND_RETURN_RET_LOG(ret != DH_SUCCESS, ERR_DH_AUDIO_CLIENT_SET_VOLUME_FAILED, "Voloume set failed.");
     return DH_SUCCESS;
 }
 
@@ -560,10 +546,7 @@ int32_t DSpeakerClient::SetMute(const AudioEvent &event)
         return ERR_DH_AUDIO_CLIENT_PARAM_ERROR;
     }
     ret = AudioStandard::AudioSystemManager::GetInstance()->SetMute(volumeType, muteStatus);
-    if (ret != DH_SUCCESS) {
-        DHLOGE("Mute set failed.");
-        return ERR_DH_AUDIO_CLIENT_SET_MUTE_FAILED;
-    }
+    CHECK_AND_RETURN_RET_LOG(ret != DH_SUCCESS, ERR_DH_AUDIO_CLIENT_SET_MUTE_FAILED, "Mute set failed.");
     return DH_SUCCESS;
 }
 
diff --git a/services/audioclient/test/unittest/micclient/src/dmic_client_test.cpp b/services/audioclient/test/unittest/micclient/src/dmic_client_test.cpp
index 3be1d2607accda3346d27d66534ca80d3df53584..03d94600e8a4568ce587ca202d57f18ef25fd9f2 100644
--- a/services/audioclient/test/unittest/micclient/src/dmic_client_test.cpp
+++ b/services/audioclient/test/unittest/micclient/src/dmic_client_test.cpp
@@ -55,7 +55,9 @@ void DMicClientTest::TearDown()
 HWTEST_F(DMicClientTest, InitSenderEngine_001, TestSize.Level1)
 {
     IAVEngineProvider *providerPtr = nullptr;
-    auto message = std::make_shared<AVTransMessage>();
+    std::shared_ptr<AVTransMessage> message = nullptr;
+    micClient_->OnEngineTransMessage(message);
+    message = std::make_shared<AVTransMessage>();
     micClient_->OnEngineTransMessage(message);
     EXPECT_EQ(DH_SUCCESS, micClient_->InitSenderEngine(providerPtr));
 }
diff --git a/services/audioclient/test/unittest/spkclient/src/dspeaker_client_test.cpp b/services/audioclient/test/unittest/spkclient/src/dspeaker_client_test.cpp
index cfbd8d54c5a18482a4db16369ad001317de4c7dc..14249655c122115698a60cf68a805ee35048f090 100644
--- a/services/audioclient/test/unittest/spkclient/src/dspeaker_client_test.cpp
+++ b/services/audioclient/test/unittest/spkclient/src/dspeaker_client_test.cpp
@@ -157,6 +157,14 @@ HWTEST_F(DSpeakerClientTest, StopRender001, TestSize.Level1)
     event.content = "AUDIO_VOLUME_TYPE=2;";
     auto ret = speakerClient_->SetAudioParameters(event);
     EXPECT_NE(DH_SUCCESS, ret);
+    speakerClient_->SetMute(event);
+    event.type = VOLUME_SET;
+    ret = speakerClient_->SetAudioParameters(event);
+    EXPECT_EQ(ERR_DH_AUDIO_NOT_FOUND_KEY, ret);
+    event.content = "AUDIO_VOLUME_TYPE=2;STREAM_MUTE_STATUS=1;";
+    speakerClient_->SetMute(event);
+    event.type = VOLUME_MUTE_SET;
+    EXPECT_EQ(DH_SUCCESS, speakerClient_->SetMute(event));
 }
 
 /**
@@ -169,7 +177,7 @@ HWTEST_F(DSpeakerClientTest, OnDecodeTransDataDone001, TestSize.Level1)
 {
     std::shared_ptr<AudioData> audioData = nullptr;
     EXPECT_EQ(ERR_DH_AUDIO_NULLPTR, speakerClient_->OnDecodeTransDataDone(audioData));
-    for (size_t i = 0; i < 11; i++) {
+    for (size_t i = 0; i < 15; i++) {
         std::shared_ptr<AudioData> data = std::make_shared<AudioData>(4096);
         speakerClient_->dataQueue_.push(data);
     }
@@ -220,6 +228,8 @@ HWTEST_F(DSpeakerClientTest, SendMessage_001, TestSize.Level1)
 {
     std::string content = "content";
     std::string dstDevId = "dstDevId";
+    speakerClient_->Pause();
+    speakerClient_->ReStart();
     audioParam_.renderOpts.renderFlags = MMAP_MODE;
     speakerClient_->speakerTrans_ = std::make_shared<MockIAudioDataTransport>();
     speakerClient_->Pause();
diff --git a/services/audiomanager/managersink/src/daudio_sink_dev.cpp b/services/audiomanager/managersink/src/daudio_sink_dev.cpp
index 5a62185885ee6b9aeac7b8321b4705c1ff5f1d5f..e2f24ab817f113bbd4e421ba921005cc7383787c 100644
--- a/services/audiomanager/managersink/src/daudio_sink_dev.cpp
+++ b/services/audiomanager/managersink/src/daudio_sink_dev.cpp
@@ -127,8 +127,7 @@ int32_t DAudioSinkDev::TaskOpenDSpeaker(const std::string &args)
         return ERR_DH_AUDIO_FAILED;
     }
     int32_t dhId = ConvertString2Int(std::string(jParam[KEY_DH_ID]));
-    CHECK_AND_RETURN_RET_LOG(dhId == -1, ERR_DH_AUDIO_NULLPTR,
-        "%s", "Parse dhId error.");
+    CHECK_AND_RETURN_RET_LOG(dhId == -1, ERR_DH_AUDIO_NULLPTR, "Parse dhId error.");
     std::shared_ptr<ISpkClient> speakerClient = nullptr;
     {
         std::lock_guard<std::mutex> devLck(spkClientMutex_);
@@ -231,8 +230,7 @@ int32_t DAudioSinkDev::TaskOpenDMic(const std::string &args)
         "Get audio param from json failed, error code %d.", ret);
     micDhId_ = std::string(jParam[KEY_DH_ID]);
     int32_t dhId = ConvertString2Int(std::string(jParam[KEY_DH_ID]));
-    CHECK_AND_RETURN_RET_LOG(dhId == -1, ERR_DH_AUDIO_NULLPTR,
-        "%s", "Parse dhId error.");
+    CHECK_AND_RETURN_RET_LOG(dhId == -1, ERR_DH_AUDIO_NULLPTR, "Parse dhId error.");
     std::shared_ptr<DMicClient> micClient = nullptr;
     {
         std::lock_guard<std::mutex> devLck(micClientMutex_);
@@ -400,8 +398,7 @@ int32_t DAudioSinkDev::SendAudioEventToRemote(const AudioEvent &event)
 
     int32_t ret = speakerClient->SendMessage(static_cast<uint32_t>(event.type),
         event.content, devId_);
-    CHECK_AND_RETURN_RET_LOG(ret != DH_SUCCESS, ERR_DH_AUDIO_NULLPTR,
-        "%s", "Task send message to remote failed.");
+    CHECK_AND_RETURN_RET_LOG(ret != DH_SUCCESS, ERR_DH_AUDIO_NULLPTR, "Task send message to remote failed.");
     return DH_SUCCESS;
 }
 
@@ -579,7 +576,7 @@ void DAudioSinkDev::SinkEventHandler::NotifyOpenSpeaker(const AppExecFwk::InnerE
     int32_t ret = sinkDevObj->TaskOpenDSpeaker(eventParam);
     sinkDevObj->NotifySourceDev(NOTIFY_OPEN_SPEAKER_RESULT, jParam[KEY_DH_ID], ret);
     DHLOGI("Open speaker device task end, notify source ret %d.", ret);
-    CHECK_AND_RETURN_LOG(ret != DH_SUCCESS, "%s", "Open speaker failed.");
+    CHECK_AND_RETURN_LOG(ret != DH_SUCCESS, "Open speaker failed.");
 }
 
 void DAudioSinkDev::SinkEventHandler::NotifyCloseSpeaker(const AppExecFwk::InnerEvent::Pointer &event)
@@ -591,8 +588,7 @@ void DAudioSinkDev::SinkEventHandler::NotifyCloseSpeaker(const AppExecFwk::Inner
     }
     auto sinkDevObj = sinkDev_.lock();
     CHECK_NULL_VOID(sinkDevObj);
-    CHECK_AND_RETURN_LOG(sinkDevObj->TaskCloseDSpeaker(eventParam) != DH_SUCCESS,
-        "%s", "close speaker failed.");
+    CHECK_AND_RETURN_LOG(sinkDevObj->TaskCloseDSpeaker(eventParam) != DH_SUCCESS, "close speaker failed.");
 }
 
 void DAudioSinkDev::SinkEventHandler::NotifySpeakerOpened(const AppExecFwk::InnerEvent::Pointer &event)
@@ -605,10 +601,9 @@ void DAudioSinkDev::SinkEventHandler::NotifySpeakerOpened(const AppExecFwk::Inne
     }
     auto sinkDevObj = sinkDev_.lock();
     CHECK_NULL_VOID(sinkDevObj);
-    CHECK_AND_RETURN_LOG(sinkDevObj->TaskStartRender(eventParam) != DH_SUCCESS,
-        "%s", "Speaker client start failed.");
+    CHECK_AND_RETURN_LOG(sinkDevObj->TaskStartRender(eventParam) != DH_SUCCESS, "Speaker client start failed.");
     CHECK_AND_RETURN_LOG(sinkDevObj->TaskVolumeChange(eventParam) != DH_SUCCESS,
-        "%s", "Notify pimary volume to source device failed.");
+        "Notify pimary volume to source device failed.");
 }
 
 void DAudioSinkDev::SinkEventHandler::NotifySpeakerClosed(const AppExecFwk::InnerEvent::Pointer &event)
@@ -620,8 +615,7 @@ void DAudioSinkDev::SinkEventHandler::NotifySpeakerClosed(const AppExecFwk::Inne
     }
     auto sinkDevObj = sinkDev_.lock();
     CHECK_NULL_VOID(sinkDevObj);
-    CHECK_AND_RETURN_LOG(sinkDevObj->TaskCloseDSpeaker(eventParam) != DH_SUCCESS,
-        "%s", "Close speaker failed.");
+    CHECK_AND_RETURN_LOG(sinkDevObj->TaskCloseDSpeaker(eventParam) != DH_SUCCESS, "Close speaker failed.");
 }
 
 void DAudioSinkDev::SinkEventHandler::NotifyOpenMic(const AppExecFwk::InnerEvent::Pointer &event)
@@ -642,7 +636,7 @@ void DAudioSinkDev::SinkEventHandler::NotifyOpenMic(const AppExecFwk::InnerEvent
     int32_t ret = sinkDevObj->TaskOpenDMic(eventParam);
     sinkDevObj->NotifySourceDev(NOTIFY_OPEN_MIC_RESULT, jParam[KEY_DH_ID], ret);
     DHLOGI("Open mic device task end, notify source ret %d.", ret);
-    CHECK_AND_RETURN_LOG(ret != DH_SUCCESS, "%s", "Open mic failed.");
+    CHECK_AND_RETURN_LOG(ret != DH_SUCCESS, "Open mic failed.");
 }
 
 void DAudioSinkDev::SinkEventHandler::NotifyCloseMic(const AppExecFwk::InnerEvent::Pointer &event)
@@ -654,8 +648,7 @@ void DAudioSinkDev::SinkEventHandler::NotifyCloseMic(const AppExecFwk::InnerEven
     }
     auto sinkDevObj = sinkDev_.lock();
     CHECK_NULL_VOID(sinkDevObj);
-    CHECK_AND_RETURN_LOG(sinkDevObj->TaskCloseDMic(eventParam) != DH_SUCCESS,
-        "%s", "Close mic failed.");
+    CHECK_AND_RETURN_LOG(sinkDevObj->TaskCloseDMic(eventParam) != DH_SUCCESS, "Close mic failed.");
 }
 
 void DAudioSinkDev::SinkEventHandler::NotifyMicOpened(const AppExecFwk::InnerEvent::Pointer &event)
@@ -673,8 +666,7 @@ void DAudioSinkDev::SinkEventHandler::NotifyMicClosed(const AppExecFwk::InnerEve
     }
     auto sinkDevObj = sinkDev_.lock();
     CHECK_NULL_VOID(sinkDevObj);
-    CHECK_AND_RETURN_LOG(sinkDevObj->TaskCloseDMic(eventParam) != DH_SUCCESS,
-        "%s", "Close mic failed.");
+    CHECK_AND_RETURN_LOG(sinkDevObj->TaskCloseDMic(eventParam) != DH_SUCCESS, "Close mic failed.");
 }
 
 void DAudioSinkDev::SinkEventHandler::NotifySetVolume(const AppExecFwk::InnerEvent::Pointer &event)
@@ -686,8 +678,7 @@ void DAudioSinkDev::SinkEventHandler::NotifySetVolume(const AppExecFwk::InnerEve
     }
     auto sinkDevObj = sinkDev_.lock();
     CHECK_NULL_VOID(sinkDevObj);
-    CHECK_AND_RETURN_LOG(sinkDevObj->TaskSetVolume(eventParam) != DH_SUCCESS,
-        "%s", "Set volume failed.");
+    CHECK_AND_RETURN_LOG(sinkDevObj->TaskSetVolume(eventParam) != DH_SUCCESS, "Set volume failed.");
 }
 
 void DAudioSinkDev::SinkEventHandler::NotifyVolumeChange(const AppExecFwk::InnerEvent::Pointer &event)
@@ -700,7 +691,7 @@ void DAudioSinkDev::SinkEventHandler::NotifyVolumeChange(const AppExecFwk::Inner
     auto sinkDevObj = sinkDev_.lock();
     CHECK_NULL_VOID(sinkDevObj);
     CHECK_AND_RETURN_LOG(sinkDevObj->TaskVolumeChange(eventParam) != DH_SUCCESS,
-        "%s", "Notify volume change status to source device failed.");
+        "Notify volume change status to source device failed.");
 }
 
 void DAudioSinkDev::SinkEventHandler::NotifySetParam(const AppExecFwk::InnerEvent::Pointer &event)
@@ -712,8 +703,7 @@ void DAudioSinkDev::SinkEventHandler::NotifySetParam(const AppExecFwk::InnerEven
     }
     auto sinkDevObj = sinkDev_.lock();
     CHECK_NULL_VOID(sinkDevObj);
-    CHECK_AND_RETURN_LOG(sinkDevObj->TaskSetParameter(eventParam) != DH_SUCCESS,
-        "%s", "Set parameters failed.");
+    CHECK_AND_RETURN_LOG(sinkDevObj->TaskSetParameter(eventParam) != DH_SUCCESS, "Set parameters failed.");
 }
 
 void DAudioSinkDev::SinkEventHandler::NotifySetMute(const AppExecFwk::InnerEvent::Pointer &event)
@@ -726,7 +716,7 @@ void DAudioSinkDev::SinkEventHandler::NotifySetMute(const AppExecFwk::InnerEvent
     auto sinkDevObj = sinkDev_.lock();
     CHECK_NULL_VOID(sinkDevObj);
     CHECK_AND_RETURN_LOG(sinkDevObj->TaskSetMute(eventParam) != DH_SUCCESS,
-        "%s", "Set mute failed.");
+        "Set mute failed.");
 }
 
 void DAudioSinkDev::SinkEventHandler::NotifyFocusChange(const AppExecFwk::InnerEvent::Pointer &event)
@@ -739,7 +729,7 @@ void DAudioSinkDev::SinkEventHandler::NotifyFocusChange(const AppExecFwk::InnerE
     auto sinkDevObj = sinkDev_.lock();
     CHECK_NULL_VOID(sinkDevObj);
     CHECK_AND_RETURN_LOG(sinkDevObj->TaskFocusChange(eventParam) != DH_SUCCESS,
-        "%s", "Handle focus change event failed.");
+        "Handle focus change event failed.");
 }
 
 void DAudioSinkDev::SinkEventHandler::NotifyRenderStateChange(const AppExecFwk::InnerEvent::Pointer &event)
@@ -752,7 +742,7 @@ void DAudioSinkDev::SinkEventHandler::NotifyRenderStateChange(const AppExecFwk::
     auto sinkDevObj = sinkDev_.lock();
     CHECK_NULL_VOID(sinkDevObj);
     CHECK_AND_RETURN_LOG(sinkDevObj->TaskRenderStateChange(eventParam) != DH_SUCCESS,
-        "%s", "Handle render state change failed.");
+        "Handle render state change failed.");
 }
 
 void DAudioSinkDev::SinkEventHandler::NotifyPlayStatusChange(const AppExecFwk::InnerEvent::Pointer &event)
@@ -765,7 +755,7 @@ void DAudioSinkDev::SinkEventHandler::NotifyPlayStatusChange(const AppExecFwk::I
     auto sinkDevObj = sinkDev_.lock();
     CHECK_NULL_VOID(sinkDevObj);
     CHECK_AND_RETURN_LOG(sinkDevObj->TaskPlayStatusChange(eventParam) != DH_SUCCESS,
-        "%s", "Handle play status change event failed.");
+        "Handle play status change event failed.");
 }
 
 int32_t DAudioSinkDev::SinkEventHandler::GetEventParam(const AppExecFwk::InnerEvent::Pointer &event,
diff --git a/services/audiomanager/managersink/src/daudio_sink_manager.cpp b/services/audiomanager/managersink/src/daudio_sink_manager.cpp
index 5d172c50f6cbad9df8041ee1c2bb847678530480..6ff7f0a925a54237e95a344c83c555fb9d0795a2 100644
--- a/services/audiomanager/managersink/src/daudio_sink_manager.cpp
+++ b/services/audiomanager/managersink/src/daudio_sink_manager.cpp
@@ -66,15 +66,13 @@ int32_t DAudioSinkManager::Init(const sptr<IDAudioSinkIpcCallback> &sinkCallback
     initCallback_ = std::make_shared<DeviceInitCallback>();
     ipcSinkCallback_ = sinkCallback;
     CHECK_AND_RETURN_RET_LOG(GetLocalDeviceNetworkId(localNetworkId_) != DH_SUCCESS,
-        ERR_DH_AUDIO_FAILED, "%s", "Get local network id failed.");
+        ERR_DH_AUDIO_FAILED, "Get local network id failed.");
     CHECK_AND_RETURN_RET_LOG(LoadAVReceiverEngineProvider() != DH_SUCCESS,
-        ERR_DH_AUDIO_FAILED, "%s", "Load av receiver engine failed.");
+        ERR_DH_AUDIO_FAILED, "Load av receiver engine failed.");
     CHECK_NULL_RETURN(rcvProviderPtr_, ERR_DH_AUDIO_FAILED);
     providerListener_ = std::make_shared<EngineProviderListener>();
-    if (rcvProviderPtr_->RegisterProviderCallback(providerListener_) != DH_SUCCESS) {
-        DHLOGE("Register av receiver engine callback failed.");
-        return ERR_DH_AUDIO_FAILED;
-    }
+    CHECK_AND_RETURN_RET_LOG(rcvProviderPtr_->RegisterProviderCallback(providerListener_) != DH_SUCCESS,
+        ERR_DH_AUDIO_FAILED, "Register av receiver engine callback failed.");
     DHLOGI("Load av receiver engine success.");
 
     if (LoadAVSenderEngineProvider() != DH_SUCCESS) {
@@ -82,12 +80,8 @@ int32_t DAudioSinkManager::Init(const sptr<IDAudioSinkIpcCallback> &sinkCallback
         return ERR_DH_AUDIO_FAILED;
     }
     CHECK_NULL_RETURN(sendProviderPtr_, ERR_DH_AUDIO_FAILED);
-    if (sendProviderPtr_->RegisterProviderCallback(providerListener_) != DH_SUCCESS) {
-        DHLOGE("Register av sender engine callback failed.");
-        return ERR_DH_AUDIO_FAILED;
-    }
     CHECK_AND_RETURN_RET_LOG(sendProviderPtr_->RegisterProviderCallback(providerListener_) != DH_SUCCESS,
-        ERR_DH_AUDIO_FAILED, "%s", "Register av sender engine callback failed.");
+        ERR_DH_AUDIO_FAILED, "Register av sender engine callback failed.");
     DHLOGI("Load av sender engine success.");
     return DH_SUCCESS;
 }
@@ -124,9 +118,8 @@ void DAudioSinkManager::OnSinkDevReleased(const std::string &devId)
         devClearThread_.join();
     }
     devClearThread_ = std::thread(&DAudioSinkManager::ClearAudioDev, this, devId);
-    if (pthread_setname_np(devClearThread_.native_handle(), DEVCLEAR_THREAD) != DH_SUCCESS) {
-        DHLOGE("Dev clear thread setname failed.");
-    }
+    CHECK_AND_LOG(pthread_setname_np(devClearThread_.native_handle(), DEVCLEAR_THREAD) != DH_SUCCESS,
+        "Dev clear thread setname failed.");
 }
 
 int32_t DAudioSinkManager::HandleDAudioNotify(const std::string &devId, const std::string &dhId,
@@ -171,10 +164,8 @@ int32_t DAudioSinkManager::CreateAudioDevice(const std::string &devId)
             dev = audioDevMap_[devId];
         } else {
             dev = std::make_shared<DAudioSinkDev>(devId, ipcSinkCallback_);
-            if (dev->AwakeAudioDev() != DH_SUCCESS) {
-                DHLOGE("Awake audio dev failed.");
-                return ERR_DH_AUDIO_FAILED;
-            }
+            CHECK_AND_RETURN_RET_LOG(dev->AwakeAudioDev() != DH_SUCCESS,
+                ERR_DH_AUDIO_FAILED, "Awake audio dev failed.");
             audioDevMap_.emplace(devId, dev);
         }
     }
@@ -236,7 +227,7 @@ void DAudioSinkManager::NotifyEvent(const std::string &devId, const int32_t even
     std::lock_guard<std::mutex> lock(devMapMutex_);
     DHLOGI("Notify event, devId: %s.", GetAnonyString(devId).c_str());
     CHECK_AND_RETURN_LOG(audioDevMap_.find(devId) == audioDevMap_.end(),
-        "%s", "Notify event error, dev not exist.");
+        "Notify event error, dev not exist.");
     CHECK_NULL_VOID(audioDevMap_[devId]);
     audioDevMap_[devId]->NotifyEvent(audioEvent);
 }
@@ -258,11 +249,9 @@ int32_t DAudioSinkManager::LoadAVReceiverEngineProvider()
 {
     DHLOGI("LoadAVReceiverEngineProvider enter");
     char path[PATH_MAX + 1] = {0x00};
-    if ((LIB_LOAD_PATH.length() + RECEIVER_SO_NAME.length()) > PATH_MAX ||
-        realpath((LIB_LOAD_PATH + RECEIVER_SO_NAME).c_str(), path) == nullptr) {
-        DHLOGE("File open failed");
-        return ERR_DH_AUDIO_NULLPTR;
-    }
+    CHECK_AND_RETURN_RET_LOG((LIB_LOAD_PATH.length() + RECEIVER_SO_NAME.length()) > PATH_MAX ||
+        realpath((LIB_LOAD_PATH + RECEIVER_SO_NAME).c_str(), path) == nullptr,
+        ERR_DH_AUDIO_NULLPTR, "File open failed");
     pRHandler_ = dlopen(path, RTLD_LAZY | RTLD_NODELETE);
     CHECK_NULL_RETURN(pRHandler_, ERR_DH_AUDIO_NULLPTR);
 
@@ -293,11 +282,9 @@ int32_t DAudioSinkManager::LoadAVSenderEngineProvider()
 {
     DHLOGI("LoadAVSenderEngineProvider enter");
     char path[PATH_MAX + 1] = {0x00};
-    if ((LIB_LOAD_PATH.length() + SENDER_SO_NAME.length()) > PATH_MAX ||
-        realpath((LIB_LOAD_PATH + SENDER_SO_NAME).c_str(), path) == nullptr) {
-        DHLOGE("File open failed");
-        return ERR_DH_AUDIO_NULLPTR;
-    }
+    CHECK_AND_RETURN_RET_LOG((LIB_LOAD_PATH.length() + SENDER_SO_NAME.length()) > PATH_MAX ||
+        realpath((LIB_LOAD_PATH + SENDER_SO_NAME).c_str(), path) == nullptr,
+        ERR_DH_AUDIO_NULLPTR, "File open failed");
     pSHandler_ = dlopen(path, RTLD_LAZY | RTLD_NODELETE);
     CHECK_NULL_RETURN(pSHandler_, ERR_DH_AUDIO_NULLPTR);
 
@@ -386,25 +373,17 @@ bool DAudioSinkManager::CheckDeviceSecurityLevel(const std::string &srcDeviceId,
 {
     DHLOGI("CheckDeviceSecurityLevel srcDeviceId %s, dstDeviceId %s.", srcDeviceId.c_str(), dstDeviceId.c_str());
     std::string srcUdid = GetUdidByNetworkId(srcDeviceId);
-    if (srcUdid.empty()) {
-        DHLOGE("src udid is empty");
-        return false;
-    }
+    CHECK_AND_RETURN_RET_LOG(srcUdid.empty(), false, "src udid is empty");
     std::string dstUdid = GetUdidByNetworkId(dstDeviceId);
-    if (dstUdid.empty()) {
-        DHLOGE("dst udid is empty");
-        return false;
-    }
+    CHECK_AND_RETURN_RET_LOG(dstUdid.empty(), false, "dst udid is empty");
     DHLOGI("CheckDeviceSecurityLevel srcUdid %s, dstUdid %s.", srcUdid.c_str(), dstUdid.c_str());
     int32_t srcDeviceSecurityLevel = GetDeviceSecurityLevel(srcUdid);
     int32_t dstDeviceSecurityLevel = GetDeviceSecurityLevel(dstUdid);
     DHLOGI("SrcDeviceSecurityLevel, level is %d", srcDeviceSecurityLevel);
     DHLOGI("dstDeviceSecurityLevel, level is %d", dstDeviceSecurityLevel);
-    if (srcDeviceSecurityLevel == DEFAULT_DEVICE_SECURITY_LEVEL ||
-        srcDeviceSecurityLevel < dstDeviceSecurityLevel) {
-        DHLOGE("The device security of source device is lower.");
-        return false;
-    }
+    CHECK_AND_RETURN_RET_LOG(srcDeviceSecurityLevel == DEFAULT_DEVICE_SECURITY_LEVEL ||
+        srcDeviceSecurityLevel < dstDeviceSecurityLevel, false,
+        "The device security of source device is lower.");
     return true;
 }
 
@@ -413,10 +392,8 @@ int32_t DAudioSinkManager::GetDeviceSecurityLevel(const std::string &udid)
     DeviceIdentify devIdentify;
     devIdentify.length = DEVICE_ID_MAX_LEN;
     int32_t ret = memcpy_s(devIdentify.identity, DEVICE_ID_MAX_LEN, udid.c_str(), DEVICE_ID_MAX_LEN);
-    if (ret != DH_SUCCESS) {
-        DHLOGE("Str copy failed %d", ret);
-        return DEFAULT_DEVICE_SECURITY_LEVEL;
-    }
+    CHECK_AND_RETURN_RET_LOG(ret != DH_SUCCESS, DEFAULT_DEVICE_SECURITY_LEVEL,
+        "Str copy failed %d", ret);
     DeviceSecurityInfo *info = nullptr;
     ret = RequestDeviceSecurityInfo(&devIdentify, nullptr, &info);
     if (ret != DH_SUCCESS) {
@@ -430,29 +407,19 @@ int32_t DAudioSinkManager::GetDeviceSecurityLevel(const std::string &udid)
     DHLOGE("Get device security level, level is %d", level);
     FreeDeviceSecurityInfo(info);
     info = nullptr;
-    if (ret != DH_SUCCESS) {
-        DHLOGE("Get device security level failed %d", ret);
-        return DEFAULT_DEVICE_SECURITY_LEVEL;
-    }
+    CHECK_AND_RETURN_RET_LOG(ret != DH_SUCCESS, DEFAULT_DEVICE_SECURITY_LEVEL,
+        "Get device security level failed %d", ret);
     return level;
 }
 
 std::string DAudioSinkManager::GetUdidByNetworkId(const std::string &networkId)
 {
-    if (networkId.empty()) {
-        DHLOGE("networkId is empty!");
-        return "";
-    }
+    CHECK_AND_RETURN_RET_LOG(networkId.empty(), "", "networkId is empty!");
     int32_t ret = DeviceManager::GetInstance().InitDeviceManager(PKG_NAME, initCallback_);
-    if (ret != ERR_OK) {
-        DHLOGE("InitDeviceManager failed ret = %d", ret);
-    }
+    CHECK_AND_LOG(ret != ERR_OK, "InitDeviceManager failed ret = %d", ret);
     std::string udid = "";
     ret = DeviceManager::GetInstance().GetUdidByNetworkId(PKG_NAME, networkId, udid);
-    if (ret != ERR_OK) {
-        DHLOGE("GetUdidByNetworkId failed ret = %d", ret);
-        return "";
-    }
+    CHECK_AND_RETURN_RET_LOG(ret != ERR_OK, "", "GetUdidByNetworkId failed ret = %d", ret);
     return udid;
 }
 
@@ -461,26 +428,15 @@ int32_t DAudioSinkManager::VerifySecurityLevel(const std::string &devId)
     std::string subType = "mic";
     int32_t ret = ipcSinkCallback_->OnNotifyResourceInfo(ResourceEventType::EVENT_TYPE_QUERY_RESOURCE, subType, devId,
         isSensitive_, isSameAccount_);
-    if (ret != DH_SUCCESS) {
-        DHLOGE("Query resource failed, ret: %d", ret);
-        return ret;
-    }
+    CHECK_AND_RETURN_RET_LOG(ret != DH_SUCCESS, ret, "Query resource failed, ret: %d", ret);
     DHLOGI("VerifySecurityLevel isSensitive: %d, isSameAccount: %d", isSensitive_, isSameAccount_);
-    if (isSensitive_ && !isSameAccount_) {
-        DHLOGE("Privacy resource must be logged in with same account.");
-        return ERR_DH_AUDIO_FAILED;
-    }
-
+    CHECK_AND_RETURN_RET_LOG(isSensitive_ && !isSameAccount_, ERR_DH_AUDIO_FAILED,
+        "Privacy resource must be logged in with same account.");
     std::string sinkDevId = "";
     ret = GetLocalDeviceNetworkId(sinkDevId);
-    if (ret != DH_SUCCESS) {
-        DHLOGE("GetLocalDeviceNetworkId failed, ret: %d", ret);
-        return ret;
-    }
-    if (isSensitive_ && !CheckDeviceSecurityLevel(devId, sinkDevId)) {
-        DHLOGE("Check device security level failed!");
-        return ERR_DH_AUDIO_FAILED;
-    }
+    CHECK_AND_RETURN_RET_LOG(ret != DH_SUCCESS, ret, "GetLocalDeviceNetworkId failed, ret: %d", ret);
+    CHECK_AND_RETURN_RET_LOG(isSensitive_ && !CheckDeviceSecurityLevel(devId, sinkDevId),
+        ERR_DH_AUDIO_FAILED, "Check device security level failed!");
     return DH_SUCCESS;
 }
 
diff --git a/services/audiomanager/test/unittest/managersink/src/daudio_sink_dev_test.cpp b/services/audiomanager/test/unittest/managersink/src/daudio_sink_dev_test.cpp
index 2023f6ef5af8bfb7b388d2a71f62184a000a848b..2c781db8b42d6c0b77fa8b035b9e3d750d2e69d9 100644
--- a/services/audiomanager/test/unittest/managersink/src/daudio_sink_dev_test.cpp
+++ b/services/audiomanager/test/unittest/managersink/src/daudio_sink_dev_test.cpp
@@ -395,7 +395,7 @@ HWTEST_F(DAudioSinkDevTest, TaskFocusChange_002, TestSize.Level1)
 HWTEST_F(DAudioSinkDevTest, TaskRenderStateChange_001, TestSize.Level1)
 {
     int32_t dhIdSpk = 1;
-    int32_t dhIdMic = 1 << 27 | 1 << 0;
+    int32_t dhIdMic = 134217729;
     std::string args = "{\"dhId\":\"123\"}";
     std::string dhId = "123";
     std::string devId = "devId";
diff --git a/services/audiomanager/test/unittest/managersink/src/daudio_sink_manager_test.cpp b/services/audiomanager/test/unittest/managersink/src/daudio_sink_manager_test.cpp
index b161adfa6f13449b5f8f61fe7aa103591992006e..35200e077c5c2ed8f01d0122ef0c3353f8338a4c 100644
--- a/services/audiomanager/test/unittest/managersink/src/daudio_sink_manager_test.cpp
+++ b/services/audiomanager/test/unittest/managersink/src/daudio_sink_manager_test.cpp
@@ -57,19 +57,6 @@ HWTEST_F(DAudioSinkManagerTest, Init_001, TestSize.Level1)
     EXPECT_EQ(DH_SUCCESS, daudioSinkManager.UnInit());
 }
 
-/**
- * @tc.name: OnSinkDevReleased_001
- * @tc.desc: Verify the OnSinkDevReleased function.
- * @tc.type: FUNC
- * @tc.require: AR000H0E5F
- */
-HWTEST_F(DAudioSinkManagerTest, OnSinkDevReleased_001, TestSize.Level1)
-{
-    std::string devId = "1";
-    daudioSinkManager.devClearThread_ = std::thread(&DAudioSinkManager::ClearAudioDev, &daudioSinkManager, devId);
-    daudioSinkManager.OnSinkDevReleased(devId);
-}
-
 /**
  * @tc.name: HandleDAudioNotify_001
  * @tc.desc: Verify the HandleDAudioNotify function.
@@ -227,6 +214,12 @@ HWTEST_F(DAudioSinkManagerTest, GetDeviceSecurityLevel_001, TestSize.Level1)
  */
 HWTEST_F(DAudioSinkManagerTest, CheckDeviceSecurityLevel_001, TestSize.Level1)
 {
+    std::string devId = "1";
+    daudioSinkManager.devClearThread_ = std::thread(&DAudioSinkManager::ClearAudioDev, &daudioSinkManager, devId);
+    daudioSinkManager.OnSinkDevReleased(devId);
+    if (daudioSinkManager.devClearThread_.joinable()) {
+        daudioSinkManager.devClearThread_.join();
+    }
     std::string srcDeviceId = "srcDeviceId";
     std::string dstDeviceId = "dstDeviceId";
     EXPECT_EQ(false, daudioSinkManager.CheckDeviceSecurityLevel(srcDeviceId, dstDeviceId));
diff --git a/services/audiotransport/receiverengine/src/av_receiver_engine_transport.cpp b/services/audiotransport/receiverengine/src/av_receiver_engine_transport.cpp
index a311d5f1edfc4ee7ad79c177c4a28da6366de7ff..e15e2e8bfe96525ca26b18d034828dfb0150a5df 100644
--- a/services/audiotransport/receiverengine/src/av_receiver_engine_transport.cpp
+++ b/services/audiotransport/receiverengine/src/av_receiver_engine_transport.cpp
@@ -119,15 +119,16 @@ void AVTransReceiverTransport::OnEngineEvent(const AVTransEvent &event)
 
 void AVTransReceiverTransport::OnEngineMessage(const std::shared_ptr<AVTransMessage> &message)
 {
-    CHECK_NULL_VOID(message);
-    CHECK_NULL_VOID(transCallback_);
+    CHECK_AND_RETURN_LOG(message == nullptr || transCallback_ == nullptr,
+        "message or transCallback_ is nullptr");
     transCallback_->OnEngineTransMessage(message);
 }
 
 void AVTransReceiverTransport::OnEngineDataAvailable(const std::shared_ptr<AVTransBuffer> &buffer)
 {
     DHLOGI("On data availabled.");
-    CHECK_NULL_VOID(buffer);
+    CHECK_AND_RETURN_LOG(buffer == nullptr || transCallback_ == nullptr,
+        "buffer or transCallback_ is nullptr");
     auto bufferData = buffer->GetBufferData(0);
     std::shared_ptr<AudioData> audioData = std::make_shared<AudioData>(bufferData->GetSize());
     int32_t ret = memcpy_s(audioData->Data(), audioData->Capacity(), bufferData->GetAddress(), bufferData->GetSize());
@@ -135,7 +136,6 @@ void AVTransReceiverTransport::OnEngineDataAvailable(const std::shared_ptr<AVTra
         DHLOGE("Copy audio data failed, error code %d.", ret);
         return;
     }
-    CHECK_NULL_VOID(transCallback_);
     transCallback_->OnEngineTransDataAvailable(audioData);
 }
 
diff --git a/services/audiotransport/senderengine/src/av_sender_engine_transport.cpp b/services/audiotransport/senderengine/src/av_sender_engine_transport.cpp
index 8493465a1aa732871f75896ab34fedbedb27b853..4712f38a0033dd021db1193aee348e3767bc5a98 100644
--- a/services/audiotransport/senderengine/src/av_sender_engine_transport.cpp
+++ b/services/audiotransport/senderengine/src/av_sender_engine_transport.cpp
@@ -118,8 +118,8 @@ void AVTransSenderTransport::OnEngineEvent(const AVTransEvent &event)
 
 void AVTransSenderTransport::OnEngineMessage(const std::shared_ptr<AVTransMessage> &message)
 {
-    CHECK_NULL_VOID(message);
-    CHECK_NULL_VOID(transCallback_);
+    CHECK_AND_RETURN_LOG(message == nullptr || transCallback_ == nullptr,
+        "message or transCallback_ is nullptr");
     transCallback_->OnEngineTransMessage(message);
 }
 
diff --git a/services/audiotransport/test/unittest/receiverengine/src/av_receiver_engine_transport_test.cpp b/services/audiotransport/test/unittest/receiverengine/src/av_receiver_engine_transport_test.cpp
index e6872444b2dd02eea95c3bcbe7c9a31597330222..50b45ae785a300a5ffc5ec821f97e065f24c95a8 100644
--- a/services/audiotransport/test/unittest/receiverengine/src/av_receiver_engine_transport_test.cpp
+++ b/services/audiotransport/test/unittest/receiverengine/src/av_receiver_engine_transport_test.cpp
@@ -167,6 +167,12 @@ HWTEST_F(AVReceiverEngineTransportTest, SetParameter_001, TestSize.Level1)
     receiverTrans_->OnEngineEvent(event);
     receiverTrans_->OnEngineMessage(message);
     receiverTrans_->OnEngineDataAvailable(buffer);
+    message = std::make_shared<AVTransMessage>();
+    buffer = std::make_shared<AVTransBuffer>();
+    receiverTrans_->transCallback_ = nullptr;
+    receiverTrans_->OnEngineMessage(message);
+    receiverTrans_->OnEngineDataAvailable(buffer);
+    receiverTrans_->transCallback_ = std::make_shared<MockAVReceiverTransportCallback>();
     AudioParam audioParam;
     EXPECT_EQ(ERR_DH_AUDIO_NULLPTR, receiverTrans_->SetParameter(audioParam));
     receiverTrans_->receiverAdapter_ = std::make_shared<AVTransReceiverAdapter>();
diff --git a/services/audiotransport/test/unittest/senderengine/src/av_sender_engine_transport_test.cpp b/services/audiotransport/test/unittest/senderengine/src/av_sender_engine_transport_test.cpp
index 57b919a2f36f1f68fbfadc525515d9883f75b0c1..1dc8bb17fea80a722ab1c9e69d26e00b257d21d9 100644
--- a/services/audiotransport/test/unittest/senderengine/src/av_sender_engine_transport_test.cpp
+++ b/services/audiotransport/test/unittest/senderengine/src/av_sender_engine_transport_test.cpp
@@ -183,29 +183,12 @@ HWTEST_F(AVSenderEngineTransportTest, SetParameter_001, TestSize.Level1)
     std::shared_ptr<AVTransMessage> message = nullptr;
     senderTrans_->OnEngineEvent(event);
     senderTrans_->OnEngineMessage(message);
+    message = std::make_shared<AVTransMessage>();
+    senderTrans_->OnEngineMessage(message);
     AudioParam audioParam;
     EXPECT_EQ(ERR_DH_AUDIO_NULLPTR, senderTrans_->SetParameter(audioParam));
     senderTrans_->senderAdapter_ = std::make_shared<AVTransSenderAdapter>();
     EXPECT_EQ(DH_SUCCESS, senderTrans_->SetParameter(audioParam));
-    message = std::make_shared<AVTransMessage>();
-    senderTrans_->OnEngineMessage(message);
-    senderTrans_->transCallback_ = nullptr;
-}
-
-/**
- * @tc.name: OnEngineMessage_001
- * @tc.desc: Verify the OnEngineMessage function.
- * @tc.type: FUNC
- * @tc.require: AR000HTAPM
- */
-HWTEST_F(AVSenderEngineTransportTest, OnEngineMessage_001, TestSize.Level1)
-{
-    std::shared_ptr<AVTransMessage> message = nullptr;
-    senderTrans_->OnEngineMessage(message);
-    message = std::make_shared<AVTransMessage>();
-    senderTrans_->OnEngineMessage(message);
-    senderTrans_->transCallback_ = nullptr;
-    senderTrans_->OnEngineMessage(message);
 }
 } // namespace DistributedHardware
 } // namespace OHOS