diff --git a/common/include/daudio_log.h b/common/include/daudio_log.h index 3d597a233fbfecff3e3ef978a93e6f0bfa66b7af..25f16cc13507ebe1910a29cfac906947b689ecd7 100644 --- a/common/include/daudio_log.h +++ b/common/include/daudio_log.h @@ -39,7 +39,7 @@ void DHLog(DHLogLevel logLevel, const char *fmt, ...); #define DHLOGE(fmt, ...) DHLog(DH_LOG_ERROR, \ (std::string("[") + DH_LOG_TAG + "][" + __FUNCTION__ + "]:" + fmt).c_str(), ##__VA_ARGS__) -#define CHECK_NULL_VOID(ptr) \ +#define CHECK_NULL_VOID(ptr) \ do { \ if ((ptr) == nullptr) { \ DHLOGE("Address pointer is null"); \ @@ -47,13 +47,36 @@ void DHLog(DHLogLevel logLevel, const char *fmt, ...); } \ } while (0) -#define CHECK_NULL_RETURN(ptr, ret) \ +#define CHECK_NULL_RETURN(ptr, ret) \ do { \ if ((ptr) == nullptr) { \ DHLOGE("Address pointer is null"); \ return (ret); \ } \ } while (0) + +#define CHECK_AND_RETURN_RET_LOG(cond, ret, fmt, ...) \ + do { \ + if ((cond)) { \ + DHLOGE(fmt, ##__VA_ARGS__); \ + return (ret); \ + } \ + } while (0) + +#define CHECK_AND_RETURN_LOG(cond, fmt, ...) \ + do { \ + if ((cond)) { \ + DHLOGE(fmt, ##__VA_ARGS__); \ + return; \ + } \ + } while (0) + +#define CHECK_AND_LOG(cond, fmt, ...) \ + do { \ + if ((cond)) { \ + DHLOGE(fmt, ##__VA_ARGS__); \ + } \ + } while (0) } // namespace DistributedHardware } // namespace OHOS #endif // OHOS_DAUDIO_LOG_H diff --git a/common/test/unittest/BUILD.gn b/common/test/unittest/BUILD.gn index 1d9dfbdcfd9b822612a0bf06c60893ec25793b73..a2f9398b5fa5da0cbca7cdf70c2216669875c99b 100644 --- a/common/test/unittest/BUILD.gn +++ b/common/test/unittest/BUILD.gn @@ -23,6 +23,7 @@ config("module_private_config") { include_dirs = [ "${fwk_common_path}/utils/include", + "//third_party/cJSON", "//third_party/json/include", ] @@ -41,6 +42,7 @@ ohos_unittest("DaudioUtilsTest") { deps = [ "${services_path}/common:distributed_audio_utils", + "//third_party/cJSON:cjson", "//third_party/googletest:gtest_main", ] diff --git a/common/test/unittest/src/daudio_utils_test.cpp b/common/test/unittest/src/daudio_utils_test.cpp index 881318415547323032d607ab9a8270f5dae898db..0945e4a52636a6b5c1e1b2b67e7265d87ab41473 100644 --- a/common/test/unittest/src/daudio_utils_test.cpp +++ b/common/test/unittest/src/daudio_utils_test.cpp @@ -17,6 +17,7 @@ #include +#include "cJSON.h" #include "securec.h" #include "daudio_constants.h" @@ -299,5 +300,24 @@ 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 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/audiomanager/managersink/src/daudio_sink_dev.cpp b/services/audiomanager/managersink/src/daudio_sink_dev.cpp index 5096b4bbccaabec041e03d6baf69d398c2cecc21..5a62185885ee6b9aeac7b8321b4705c1ff5f1d5f 100644 --- a/services/audiomanager/managersink/src/daudio_sink_dev.cpp +++ b/services/audiomanager/managersink/src/daudio_sink_dev.cpp @@ -127,10 +127,8 @@ int32_t DAudioSinkDev::TaskOpenDSpeaker(const std::string &args) return ERR_DH_AUDIO_FAILED; } int32_t dhId = ConvertString2Int(std::string(jParam[KEY_DH_ID])); - if (dhId == -1) { - DHLOGE("Parse dhId error."); - return ERR_DH_AUDIO_NULLPTR; - } + CHECK_AND_RETURN_RET_LOG(dhId == -1, ERR_DH_AUDIO_NULLPTR, + "%s", "Parse dhId error."); std::shared_ptr speakerClient = nullptr; { std::lock_guard devLck(spkClientMutex_); @@ -138,17 +136,12 @@ int32_t DAudioSinkDev::TaskOpenDSpeaker(const std::string &args) } AudioParam audioParam; int32_t ret = from_json(jParam[KEY_AUDIO_PARAM], audioParam); - if (ret != DH_SUCCESS) { - DHLOGE("Get audio param from json failed, error code %d.", ret); - return ret; - } - + CHECK_AND_RETURN_RET_LOG(ret != DH_SUCCESS, ret, + "Get audio param from json failed, error code %d.", ret); CHECK_NULL_RETURN(speakerClient, ERR_DH_AUDIO_NULLPTR); ret = speakerClient->SetUp(audioParam); - if (ret != DH_SUCCESS) { - DHLOGE("Setup speaker failed, ret: %d.", ret); - return ret; - } + CHECK_AND_RETURN_RET_LOG(ret != DH_SUCCESS, ret, + "Setup speaker failed, ret: %d.", ret); isSpkInUse_.store(true); return ret; } @@ -216,10 +209,8 @@ int32_t DAudioSinkDev::TaskStartRender(const std::string &args) CHECK_NULL_RETURN(speakerClient, ERR_DH_AUDIO_NULLPTR); int32_t ret = speakerClient->StartRender(); - if (ret != DH_SUCCESS) { - DHLOGE("Start render failed. ret: %d.", ret); - return ret; - } + CHECK_AND_RETURN_RET_LOG(ret != DH_SUCCESS, ret, + "Start render failed. ret: %d.", ret); DHLOGI("Start render success."); return DH_SUCCESS; } @@ -236,33 +227,24 @@ int32_t DAudioSinkDev::TaskOpenDMic(const std::string &args) } AudioParam audioParam; int32_t ret = from_json(jParam[KEY_AUDIO_PARAM], audioParam); - if (ret != DH_SUCCESS) { - DHLOGE("Get audio param from json failed, error code %d.", ret); - return ret; - } + CHECK_AND_RETURN_RET_LOG(ret != DH_SUCCESS, ret, + "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])); - if (dhId == -1) { - DHLOGE("Parse dhId error."); - return ERR_DH_AUDIO_NULLPTR; - } + CHECK_AND_RETURN_RET_LOG(dhId == -1, ERR_DH_AUDIO_NULLPTR, + "%s", "Parse dhId error."); std::shared_ptr micClient = nullptr; { std::lock_guard devLck(micClientMutex_); micClient = micClientMap_[dhId]; } CHECK_NULL_RETURN(micClient, ERR_DH_AUDIO_NULLPTR); - ret = micClient->SetUp(audioParam); - if (ret != DH_SUCCESS) { - DHLOGE("Set up mic failed, ret: %d.", ret); - return ERR_DH_AUDIO_FAILED; - } + CHECK_AND_RETURN_RET_LOG(ret != DH_SUCCESS, ERR_DH_AUDIO_FAILED, + "Set up mic failed, ret: %d.", ret); ret = micClient->StartCapture(); - if (ret != DH_SUCCESS) { - DHLOGE("Start capture failed, ret: %d.", ret); - return ERR_DH_AUDIO_FAILED; - } + CHECK_AND_RETURN_RET_LOG(ret != DH_SUCCESS, ERR_DH_AUDIO_FAILED, + "Start capture failed, ret: %d.", ret); PullUpPage(); isMicInUse_.store(true); return ret; @@ -281,13 +263,9 @@ int32_t DAudioSinkDev::TaskCloseDMic(const std::string &args) CHECK_NULL_RETURN(micClient, DH_SUCCESS); int32_t ret = micClient->StopCapture(); - if (ret != DH_SUCCESS) { - DHLOGE("Stop mic client failed, ret: %d.", ret); - } + CHECK_AND_LOG(ret != DH_SUCCESS, "Stop mic client failed, ret: %d.", ret); ret = micClient->Release(); - if (ret != DH_SUCCESS) { - DHLOGE("Release mic client failed, ret: %d.", ret); - } + CHECK_AND_LOG(ret != DH_SUCCESS, "Release mic client failed, ret: %d.", ret); micClientMap_.erase(dhId); if (isPageStatus_.load()) { bool isSensitive = false; @@ -335,10 +313,8 @@ int32_t DAudioSinkDev::TaskSetVolume(const std::string &args) AudioEvent event(AudioEventType::VOLUME_SET, args); int32_t ret = speakerClient->SetAudioParameters(event); - if (ret != DH_SUCCESS) { - DHLOGE("Volume set failed, ret: %d.", ret); - return ret; - } + CHECK_AND_RETURN_RET_LOG(ret != DH_SUCCESS, ret, + "Volume set failed, ret: %d.", ret); DHLOGD("Set audio volume success."); return DH_SUCCESS; } @@ -360,10 +336,8 @@ int32_t DAudioSinkDev::TaskSetMute(const std::string &args) AudioEvent event(AudioEventType::VOLUME_MUTE_SET, args); int32_t ret = speakerClient->SetMute(event); - if (ret != DH_SUCCESS) { - DHLOGE("Set mute failed, ret: %d.", ret); - return ret; - } + CHECK_AND_RETURN_RET_LOG(ret != DH_SUCCESS, ret, + "Set mute failed, ret: %d.", ret); DHLOGD("Set mute success."); return DH_SUCCESS; } @@ -426,10 +400,8 @@ int32_t DAudioSinkDev::SendAudioEventToRemote(const AudioEvent &event) int32_t ret = speakerClient->SendMessage(static_cast(event.type), event.content, devId_); - if (ret != DH_SUCCESS) { - DHLOGE("Task send message to remote failed."); - return ERR_DH_AUDIO_NULLPTR; - } + CHECK_AND_RETURN_RET_LOG(ret != DH_SUCCESS, ERR_DH_AUDIO_NULLPTR, + "%s", "Task send message to remote failed."); return DH_SUCCESS; } @@ -607,10 +579,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); - if (ret != DH_SUCCESS) { - DHLOGE("Open speaker failed."); - return; - } + CHECK_AND_RETURN_LOG(ret != DH_SUCCESS, "%s", "Open speaker failed."); } void DAudioSinkDev::SinkEventHandler::NotifyCloseSpeaker(const AppExecFwk::InnerEvent::Pointer &event) @@ -622,10 +591,8 @@ void DAudioSinkDev::SinkEventHandler::NotifyCloseSpeaker(const AppExecFwk::Inner } auto sinkDevObj = sinkDev_.lock(); CHECK_NULL_VOID(sinkDevObj); - if (sinkDevObj->TaskCloseDSpeaker(eventParam) != DH_SUCCESS) { - DHLOGE("Open speaker failed."); - return; - } + CHECK_AND_RETURN_LOG(sinkDevObj->TaskCloseDSpeaker(eventParam) != DH_SUCCESS, + "%s", "close speaker failed."); } void DAudioSinkDev::SinkEventHandler::NotifySpeakerOpened(const AppExecFwk::InnerEvent::Pointer &event) @@ -638,15 +605,10 @@ void DAudioSinkDev::SinkEventHandler::NotifySpeakerOpened(const AppExecFwk::Inne } auto sinkDevObj = sinkDev_.lock(); CHECK_NULL_VOID(sinkDevObj); - - if (sinkDevObj->TaskStartRender(eventParam) != DH_SUCCESS) { - DHLOGE("Speaker client start failed."); - return; - } - if (sinkDevObj->TaskVolumeChange(eventParam) != DH_SUCCESS) { - DHLOGE("Notify pimary volume to source device failed."); - return; - } + CHECK_AND_RETURN_LOG(sinkDevObj->TaskStartRender(eventParam) != DH_SUCCESS, + "%s", "Speaker client start failed."); + CHECK_AND_RETURN_LOG(sinkDevObj->TaskVolumeChange(eventParam) != DH_SUCCESS, + "%s", "Notify pimary volume to source device failed."); } void DAudioSinkDev::SinkEventHandler::NotifySpeakerClosed(const AppExecFwk::InnerEvent::Pointer &event) @@ -658,11 +620,8 @@ void DAudioSinkDev::SinkEventHandler::NotifySpeakerClosed(const AppExecFwk::Inne } auto sinkDevObj = sinkDev_.lock(); CHECK_NULL_VOID(sinkDevObj); - - if (sinkDevObj->TaskCloseDSpeaker(eventParam) != DH_SUCCESS) { - DHLOGE("Close speaker failed."); - return; - } + CHECK_AND_RETURN_LOG(sinkDevObj->TaskCloseDSpeaker(eventParam) != DH_SUCCESS, + "%s", "Close speaker failed."); } void DAudioSinkDev::SinkEventHandler::NotifyOpenMic(const AppExecFwk::InnerEvent::Pointer &event) @@ -683,10 +642,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); - if (ret != DH_SUCCESS) { - DHLOGE("Open mic failed."); - return; - } + CHECK_AND_RETURN_LOG(ret != DH_SUCCESS, "%s", "Open mic failed."); } void DAudioSinkDev::SinkEventHandler::NotifyCloseMic(const AppExecFwk::InnerEvent::Pointer &event) @@ -698,11 +654,8 @@ void DAudioSinkDev::SinkEventHandler::NotifyCloseMic(const AppExecFwk::InnerEven } auto sinkDevObj = sinkDev_.lock(); CHECK_NULL_VOID(sinkDevObj); - - if (sinkDevObj->TaskCloseDMic(eventParam) != DH_SUCCESS) { - DHLOGE("Close mic failed."); - return; - } + CHECK_AND_RETURN_LOG(sinkDevObj->TaskCloseDMic(eventParam) != DH_SUCCESS, + "%s", "Close mic failed."); } void DAudioSinkDev::SinkEventHandler::NotifyMicOpened(const AppExecFwk::InnerEvent::Pointer &event) @@ -720,11 +673,8 @@ void DAudioSinkDev::SinkEventHandler::NotifyMicClosed(const AppExecFwk::InnerEve } auto sinkDevObj = sinkDev_.lock(); CHECK_NULL_VOID(sinkDevObj); - - if (sinkDevObj->TaskCloseDMic(eventParam) != DH_SUCCESS) { - DHLOGE("Close mic failed."); - return; - } + CHECK_AND_RETURN_LOG(sinkDevObj->TaskCloseDMic(eventParam) != DH_SUCCESS, + "%s", "Close mic failed."); } void DAudioSinkDev::SinkEventHandler::NotifySetVolume(const AppExecFwk::InnerEvent::Pointer &event) @@ -736,11 +686,8 @@ void DAudioSinkDev::SinkEventHandler::NotifySetVolume(const AppExecFwk::InnerEve } auto sinkDevObj = sinkDev_.lock(); CHECK_NULL_VOID(sinkDevObj); - - if (sinkDevObj->TaskSetVolume(eventParam) != DH_SUCCESS) { - DHLOGE("Set volume failed."); - return; - } + CHECK_AND_RETURN_LOG(sinkDevObj->TaskSetVolume(eventParam) != DH_SUCCESS, + "%s", "Set volume failed."); } void DAudioSinkDev::SinkEventHandler::NotifyVolumeChange(const AppExecFwk::InnerEvent::Pointer &event) @@ -752,11 +699,8 @@ void DAudioSinkDev::SinkEventHandler::NotifyVolumeChange(const AppExecFwk::Inner } auto sinkDevObj = sinkDev_.lock(); CHECK_NULL_VOID(sinkDevObj); - - if (sinkDevObj->TaskVolumeChange(eventParam) != DH_SUCCESS) { - DHLOGE("Notify volume change status to source device failed."); - return; - } + CHECK_AND_RETURN_LOG(sinkDevObj->TaskVolumeChange(eventParam) != DH_SUCCESS, + "%s", "Notify volume change status to source device failed."); } void DAudioSinkDev::SinkEventHandler::NotifySetParam(const AppExecFwk::InnerEvent::Pointer &event) @@ -768,11 +712,8 @@ void DAudioSinkDev::SinkEventHandler::NotifySetParam(const AppExecFwk::InnerEven } auto sinkDevObj = sinkDev_.lock(); CHECK_NULL_VOID(sinkDevObj); - - if (sinkDevObj->TaskSetParameter(eventParam) != DH_SUCCESS) { - DHLOGE("Set parameters failed."); - return; - } + CHECK_AND_RETURN_LOG(sinkDevObj->TaskSetParameter(eventParam) != DH_SUCCESS, + "%s", "Set parameters failed."); } void DAudioSinkDev::SinkEventHandler::NotifySetMute(const AppExecFwk::InnerEvent::Pointer &event) @@ -784,11 +725,8 @@ void DAudioSinkDev::SinkEventHandler::NotifySetMute(const AppExecFwk::InnerEvent } auto sinkDevObj = sinkDev_.lock(); CHECK_NULL_VOID(sinkDevObj); - - if (sinkDevObj->TaskSetMute(eventParam) != DH_SUCCESS) { - DHLOGE("Set mute failed."); - return; - } + CHECK_AND_RETURN_LOG(sinkDevObj->TaskSetMute(eventParam) != DH_SUCCESS, + "%s", "Set mute failed."); } void DAudioSinkDev::SinkEventHandler::NotifyFocusChange(const AppExecFwk::InnerEvent::Pointer &event) @@ -800,11 +738,8 @@ void DAudioSinkDev::SinkEventHandler::NotifyFocusChange(const AppExecFwk::InnerE } auto sinkDevObj = sinkDev_.lock(); CHECK_NULL_VOID(sinkDevObj); - - if (sinkDevObj->TaskFocusChange(eventParam) != DH_SUCCESS) { - DHLOGE("Handle focus change event failed."); - return; - } + CHECK_AND_RETURN_LOG(sinkDevObj->TaskFocusChange(eventParam) != DH_SUCCESS, + "%s", "Handle focus change event failed."); } void DAudioSinkDev::SinkEventHandler::NotifyRenderStateChange(const AppExecFwk::InnerEvent::Pointer &event) @@ -816,11 +751,8 @@ void DAudioSinkDev::SinkEventHandler::NotifyRenderStateChange(const AppExecFwk:: } auto sinkDevObj = sinkDev_.lock(); CHECK_NULL_VOID(sinkDevObj); - - if (sinkDevObj->TaskRenderStateChange(eventParam) != DH_SUCCESS) { - DHLOGE("Handle render state change failed."); - return; - } + CHECK_AND_RETURN_LOG(sinkDevObj->TaskRenderStateChange(eventParam) != DH_SUCCESS, + "%s", "Handle render state change failed."); } void DAudioSinkDev::SinkEventHandler::NotifyPlayStatusChange(const AppExecFwk::InnerEvent::Pointer &event) @@ -832,11 +764,8 @@ void DAudioSinkDev::SinkEventHandler::NotifyPlayStatusChange(const AppExecFwk::I } auto sinkDevObj = sinkDev_.lock(); CHECK_NULL_VOID(sinkDevObj); - - if (sinkDevObj->TaskPlayStatusChange(eventParam) != DH_SUCCESS) { - DHLOGE("Handle play status change event failed."); - return; - } + CHECK_AND_RETURN_LOG(sinkDevObj->TaskPlayStatusChange(eventParam) != DH_SUCCESS, + "%s", "Handle play status change event failed."); } int32_t DAudioSinkDev::SinkEventHandler::GetEventParam(const AppExecFwk::InnerEvent::Pointer &event, @@ -861,9 +790,7 @@ int32_t DAudioSinkDev::PauseDistributedHardware(const std::string &networkId) CHECK_NULL_RETURN(micClient, ERR_DH_AUDIO_NULLPTR); int32_t ret = micClient->PauseCapture(); - if (ret != DH_SUCCESS) { - DHLOGE("Pause mic client failed, ret: %d.", ret); - } + CHECK_AND_LOG(ret != DH_SUCCESS, "Pause mic client failed, ret: %d.", ret); return ret; } @@ -879,9 +806,7 @@ int32_t DAudioSinkDev::ResumeDistributedHardware(const std::string &networkId) CHECK_NULL_RETURN(micClient, ERR_DH_AUDIO_NULLPTR); int32_t ret = micClient->ResumeCapture(); - if (ret != DH_SUCCESS) { - DHLOGE("Resume mic client failed, ret: %d.", ret); - } + CHECK_AND_LOG(ret != DH_SUCCESS, "Resume mic client failed, ret: %d.", ret); return ret; } diff --git a/services/audiomanager/managersink/src/daudio_sink_manager.cpp b/services/audiomanager/managersink/src/daudio_sink_manager.cpp index c05403b35a161fa158787940b5f1f260e44f8897..5d172c50f6cbad9df8041ee1c2bb847678530480 100644 --- a/services/audiomanager/managersink/src/daudio_sink_manager.cpp +++ b/services/audiomanager/managersink/src/daudio_sink_manager.cpp @@ -65,15 +65,10 @@ int32_t DAudioSinkManager::Init(const sptr &sinkCallback DHLOGI("Init audio sink manager."); initCallback_ = std::make_shared(); ipcSinkCallback_ = sinkCallback; - if (GetLocalDeviceNetworkId(localNetworkId_) != DH_SUCCESS) { - DHLOGE("Get local network id failed."); - return ERR_DH_AUDIO_FAILED; - } - - if (LoadAVReceiverEngineProvider() != DH_SUCCESS) { - DHLOGE("Load av receiver engine failed."); - return ERR_DH_AUDIO_FAILED; - } + CHECK_AND_RETURN_RET_LOG(GetLocalDeviceNetworkId(localNetworkId_) != DH_SUCCESS, + ERR_DH_AUDIO_FAILED, "%s", "Get local network id failed."); + CHECK_AND_RETURN_RET_LOG(LoadAVReceiverEngineProvider() != DH_SUCCESS, + ERR_DH_AUDIO_FAILED, "%s", "Load av receiver engine failed."); CHECK_NULL_RETURN(rcvProviderPtr_, ERR_DH_AUDIO_FAILED); providerListener_ = std::make_shared(); if (rcvProviderPtr_->RegisterProviderCallback(providerListener_) != DH_SUCCESS) { @@ -91,6 +86,8 @@ int32_t DAudioSinkManager::Init(const sptr &sinkCallback 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."); DHLOGI("Load av sender engine success."); return DH_SUCCESS; } @@ -238,10 +235,8 @@ void DAudioSinkManager::NotifyEvent(const std::string &devId, const int32_t even AudioEvent audioEvent(eventType, eventContent); std::lock_guard lock(devMapMutex_); DHLOGI("Notify event, devId: %s.", GetAnonyString(devId).c_str()); - if (audioDevMap_.find(devId) == audioDevMap_.end()) { - DHLOGE("Notify event error, dev not exist."); - return; - } + CHECK_AND_RETURN_LOG(audioDevMap_.find(devId) == audioDevMap_.end(), + "%s", "Notify event error, dev not exist."); CHECK_NULL_VOID(audioDevMap_[devId]); audioDevMap_[devId]->NotifyEvent(audioEvent); } diff --git a/services/audiomanager/test/unittest/managersink/BUILD.gn b/services/audiomanager/test/unittest/managersink/BUILD.gn index aa19c34c7731ef5623566c24635fca5d80191f46..641605c0c62d50c0be73fc629050768c8a254171 100644 --- a/services/audiomanager/test/unittest/managersink/BUILD.gn +++ b/services/audiomanager/test/unittest/managersink/BUILD.gn @@ -77,6 +77,7 @@ ohos_unittest("DaudioSinkDevTest") { "device_security_level:dslm_sdk", "distributed_hardware_fwk:distributed_av_receiver", "distributed_hardware_fwk:distributed_av_sender", + "eventhandler:libeventhandler", "hdf_core:libhdf_ipc_adapter", "hdf_core:libhdf_utils", "hdf_core:libhdi", 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 2a1bfd3ea85cc37aadfba12799bc99c70448cff0..2023f6ef5af8bfb7b388d2a71f62184a000a848b 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 @@ -92,6 +92,18 @@ HWTEST_F(DAudioSinkDevTest, TaskPlayStatusChange_001, TestSize.Level1) EXPECT_EQ(DH_SUCCESS, sinkDev_->TaskPlayStatusChange("{\"dhId\":\"1\"}")); } +/** + * @tc.name: TaskDisableDevice_001 + * @tc.desc: Verify the TaskDisableDevice function. + * @tc.type: FUNC + * @tc.require: AR000H0E5F + */ +HWTEST_F(DAudioSinkDevTest, TaskDisableDevice_001, TestSize.Level1) +{ + std::string spkName = "ohos.dhardware.daudio.dspeaker.ohos.dhardware.daudio.dmic"; + EXPECT_EQ(DH_SUCCESS, sinkDev_->TaskDisableDevice(spkName)); +} + /** * @tc.name: TaskOpenDSpeaker_001 * @tc.desc: Verify the TaskOpenDSpeaker function. @@ -144,6 +156,20 @@ HWTEST_F(DAudioSinkDevTest, TaskCloseDSpeaker_002, TestSize.Level1) EXPECT_EQ(DH_SUCCESS, sinkDev_->TaskCloseDSpeaker(args)); } +/** + * @tc.name: ParseDhidFromEvent_001 + * @tc.desc: Verify the ParseDhidFromEvent function. + * @tc.type: FUNC + * @tc.require: AR000H0E5F + */ +HWTEST_F(DAudioSinkDevTest, ParseDhidFromEvent_001, TestSize.Level1) +{ + std::string args = "{\"devId\":\"1\"}"; + EXPECT_NE(DH_SUCCESS, sinkDev_->ParseDhidFromEvent(args)); + std::string dhIdArgs = "{\"dhId\": 1 }"; + EXPECT_NE(DH_SUCCESS, sinkDev_->ParseDhidFromEvent(dhIdArgs)); +} + /** * @tc.name: TaskStartRender_001 * @tc.desc: Verify the TaskStartRender function. @@ -159,6 +185,8 @@ HWTEST_F(DAudioSinkDevTest, TaskStartRender_001, TestSize.Level1) auto spkClient = std::make_shared(devId, dhId, sinkDev_); sinkDev_->spkClientMap_.insert(std::make_pair(DEFAULT_RENDER_ID, spkClient)); EXPECT_NE(DH_SUCCESS, sinkDev_->TaskStartRender(args)); + std::string devIdArgs = "{\"devId\":\"1\"}"; + EXPECT_EQ(ERR_DH_AUDIO_FAILED, sinkDev_->TaskStartRender(devIdArgs)); } /** @@ -211,6 +239,8 @@ HWTEST_F(DAudioSinkDevTest, TaskCloseDMic_002, TestSize.Level1) auto micClient = std::make_shared(devId, dhId, sinkDev_); sinkDev_->micClientMap_.insert(std::make_pair(DEFAULT_CAPTURE_ID, micClient)); EXPECT_EQ(DH_SUCCESS, sinkDev_->TaskCloseDMic(args)); + std::string dhIdArgs = "{\"dhId\":1}"; + EXPECT_EQ(ERR_DH_AUDIO_FAILED, sinkDev_->TaskCloseDMic(dhIdArgs)); } /** @@ -223,6 +253,13 @@ HWTEST_F(DAudioSinkDevTest, TaskSetParameter_001, TestSize.Level1) { std::string args; EXPECT_NE(DH_SUCCESS, sinkDev_->TaskSetParameter(args)); + int32_t dhId = 1; + std::string devId = "devId"; + args += "{\"dhId\":\"1\"}"; + EXPECT_EQ(ERR_DH_AUDIO_NULLPTR, sinkDev_->TaskSetParameter(args)); + auto spkClient = std::make_shared(devId, dhId, sinkDev_); + sinkDev_->spkClientMap_.insert(std::make_pair(DEFAULT_RENDER_ID, spkClient)); + EXPECT_NE(DH_SUCCESS, sinkDev_->TaskSetParameter(args)); } /** @@ -261,7 +298,7 @@ HWTEST_F(DAudioSinkDevTest, TaskSetVolume_001, TestSize.Level1) */ HWTEST_F(DAudioSinkDevTest, TaskSetVolume_002, TestSize.Level1) { - std::string args; + std::string args = "{\"dhId\":\"1\"}"; std::string devId; int32_t dhId = 1; auto spkClient = std::make_shared(devId, dhId, sinkDev_); @@ -289,8 +326,8 @@ HWTEST_F(DAudioSinkDevTest, TaskSetMute_001, TestSize.Level1) */ HWTEST_F(DAudioSinkDevTest, TaskSetMute_002, TestSize.Level1) { - std::string args; - std::string devId; + std::string args = "{\"dhId\":\"1\", \"eventType\":\"setMute\"}"; + std::string devId = "devId"; int32_t dhId = 1; auto spkClient = std::make_shared(devId, dhId, sinkDev_); sinkDev_->spkClientMap_.insert(std::make_pair(DEFAULT_RENDER_ID, spkClient)); @@ -357,10 +394,19 @@ 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; std::string args = "{\"dhId\":\"123\"}"; std::string dhId = "123"; + std::string devId = "devId"; int32_t result = 0; + auto spkClient = std::make_shared(devId, dhIdSpk, sinkDev_); + sinkDev_->spkClientMap_.insert(std::make_pair(DEFAULT_RENDER_ID, spkClient)); + auto micClient = std::make_shared(devId, dhIdMic, sinkDev_); + sinkDev_->micClientMap_.insert(std::make_pair(DEFAULT_CAPTURE_ID, micClient)); sinkDev_->NotifySourceDev(AUDIO_START, dhId, result); + sinkDev_->NotifySourceDev(NOTIFY_OPEN_CTRL_RESULT, dhId, result); + sinkDev_->NotifySourceDev(AUDIO_START, devId, result); EXPECT_NE(DH_SUCCESS, sinkDev_->TaskRenderStateChange(args)); } @@ -412,5 +458,151 @@ HWTEST_F(DAudioSinkDevTest, PauseDistributedHardware_001, TestSize.Level1) EXPECT_EQ(ERR_DH_AUDIO_NULLPTR, sinkDev_->ResumeDistributedHardware(networkId)); EXPECT_EQ(DH_SUCCESS, sinkDev_->StopDistributedHardware(networkId)); } + +/** + * @tc.name: JudgeDeviceStatus_001 + * @tc.desc: Verify the JudgeDeviceStatus function. + * @tc.type: FUNC + * @tc.require: AR000H0E5F + */ +HWTEST_F(DAudioSinkDevTest, JudgeDeviceStatus_001, TestSize.Level1) +{ + sinkDev_->isSpkInUse_.store(true); + sinkDev_->JudgeDeviceStatus(); + sinkDev_->isSpkInUse_.store(false); + sinkDev_->isMicInUse_.store(false); + sinkDev_->JudgeDeviceStatus(); + std::string args = "one"; + EXPECT_NE(DH_SUCCESS, sinkDev_->ConvertString2Int(args)); +} + +/** + * @tc.name: SinkEventHandler_001 + * @tc.desc: Verify the SinkEventHandler function. + * @tc.type: FUNC + * @tc.require: AR000H0E5F + */ +HWTEST_F(DAudioSinkDevTest, SinkEventHandler_001, TestSize.Level1) +{ + int32_t eventType = 2500; + std::string eventContent = "eventContent"; + AudioEvent audioEvent(eventType, eventContent); + auto eventParam = std::make_shared(audioEvent); + auto msgEvent = AppExecFwk::InnerEvent::Get(static_cast(audioEvent.type), eventParam, 0); + EXPECT_EQ(DH_SUCCESS, sinkDev_->AwakeAudioDev()); + sinkDev_->handler_->ProcessEvent(msgEvent); + eventType = CTRL_OPENED; + std::string content = "content"; + AudioEvent event(eventType, content); + auto Param = std::make_shared(event); + auto msg = AppExecFwk::InnerEvent::Get(static_cast(event.type), Param, 0); + sinkDev_->handler_->ProcessEvent(msg); + sinkDev_->handler_->NotifyCtrlOpened(msg); + std::string networkId = "networkId"; + std::string devId; + int32_t dhId = 134217729; + sinkDev_->micDhId_ = "134217729"; + auto micClient = std::make_shared(devId, dhId, sinkDev_); + sinkDev_->micClientMap_.insert(std::make_pair(DEFAULT_CAPTURE_ID, micClient)); + EXPECT_EQ(DH_SUCCESS, sinkDev_->PauseDistributedHardware(networkId)); +} + +/** + * @tc.name: SinkEventHandler_002 + * @tc.desc: Verify the SinkEventHandler function. + * @tc.type: FUNC + * @tc.require: AR000H0E5F + */ +HWTEST_F(DAudioSinkDevTest, SinkEventHandler_002, TestSize.Level1) +{ + int32_t dhId = 1; + int32_t eventType = CTRL_CLOSED; + std::string eventContent = "{\"dhId\":\"1\"}"; + std::string devId = "devId"; + AudioEvent audioEvent(eventType, eventContent); + auto eventParam = std::make_shared(audioEvent); + auto msgEvent = AppExecFwk::InnerEvent::Get(static_cast(audioEvent.type), eventParam, 0); + EXPECT_EQ(DH_SUCCESS, sinkDev_->AwakeAudioDev()); + sinkDev_->spkClientMap_[dhId] = nullptr; + sinkDev_->micClientMap_[dhId] = nullptr; + sinkDev_->handler_->NotifyCtrlClosed(msgEvent); + auto micClient = std::make_shared(devId, dhId, sinkDev_); + sinkDev_->micClientMap_.insert(std::make_pair(DEFAULT_CAPTURE_ID, micClient)); + micClient->micTrans_ =nullptr; + sinkDev_->handler_->NotifyCtrlClosed(msgEvent); + std::string content = "content"; + AudioEvent event(eventType, content); + auto Param = std::make_shared(event); + auto msg = AppExecFwk::InnerEvent::Get(static_cast(event.type), Param, 0); + sinkDev_->handler_->NotifyCtrlClosed(msg); + std::string networkId = "networkId"; + dhId = 134217729; + sinkDev_->micDhId_ = "134217729"; + micClient = std::make_shared(devId, dhId, sinkDev_); + sinkDev_->micClientMap_.insert(std::make_pair(DEFAULT_CAPTURE_ID, micClient)); + EXPECT_EQ(DH_SUCCESS, sinkDev_->ResumeDistributedHardware(networkId)); +} + +/** + * @tc.name: SinkEventHandler_003 + * @tc.desc: Verify the SinkEventHandler function. + * @tc.type: FUNC + * @tc.require: AR000H0E5F + */ +HWTEST_F(DAudioSinkDevTest, SinkEventHandler_003, TestSize.Level1) +{ + int32_t eventType = OPEN_SPEAKER; + std::string eventContent = "{\"dhId\":\"dhId\",\"audioParam\":\"audioParam\"}"; + std::string devId = "devId"; + std::string networkId = "networkId"; + AudioEvent audioEvent(eventType, devId); + auto eventParam = std::make_shared(audioEvent); + auto msgEvent = AppExecFwk::InnerEvent::Get(static_cast(audioEvent.type), eventParam, 0); + EXPECT_EQ(DH_SUCCESS, sinkDev_->AwakeAudioDev()); + sinkDev_->handler_->NotifyOpenSpeaker(msgEvent); + sinkDev_->handler_->NotifyOpenMic(msgEvent); + AudioEvent event(eventType, eventContent); + auto Param = std::make_shared(event); + auto msg = AppExecFwk::InnerEvent::Get(static_cast(event.type), Param, 0); + sinkDev_->handler_->NotifyOpenSpeaker(msg); + EXPECT_EQ(DH_SUCCESS, sinkDev_->StopDistributedHardware(networkId)); +} + +/** + * @tc.name: SinkEventHandler_004 + * @tc.desc: Verify the SinkEventHandler function. + * @tc.type: FUNC + * @tc.require: AR000H0E5F + */ +HWTEST_F(DAudioSinkDevTest, SinkEventHandler_004, TestSize.Level1) +{ + int32_t eventType = OPEN_SPEAKER; + std::shared_ptr nullForFail = nullptr; + auto msgEvent = AppExecFwk::InnerEvent::Get(static_cast(eventType), nullForFail, 0); + EXPECT_EQ(DH_SUCCESS, sinkDev_->AwakeAudioDev()); + sinkDev_->handler_->NotifyCtrlOpened(msgEvent); + sinkDev_->handler_->NotifyCtrlClosed(msgEvent); + sinkDev_->handler_->NotifyOpenSpeaker(msgEvent); + sinkDev_->handler_->NotifyCloseSpeaker(msgEvent); + sinkDev_->handler_->NotifySpeakerOpened(msgEvent); + sinkDev_->handler_->NotifySpeakerClosed(msgEvent); + sinkDev_->handler_->NotifyOpenMic(msgEvent); + sinkDev_->handler_->NotifyCloseMic(msgEvent); + sinkDev_->handler_->NotifyMicOpened(msgEvent); + sinkDev_->handler_->NotifyMicClosed(msgEvent); + sinkDev_->handler_->NotifySetVolume(msgEvent); + sinkDev_->handler_->NotifyVolumeChange(msgEvent); + sinkDev_->handler_->NotifySetParam(msgEvent); + sinkDev_->handler_->NotifySetMute(msgEvent); + sinkDev_->handler_->NotifyFocusChange(msgEvent); + sinkDev_->handler_->NotifyRenderStateChange(msgEvent); + sinkDev_->handler_->NotifyPlayStatusChange(msgEvent); + std::string eventContent = "{\"dhId\":\"1\"}"; + std::string paramResult; + AudioEvent audioEvent(eventType, eventContent); + auto eventParam = std::make_shared(audioEvent); + auto msg = AppExecFwk::InnerEvent::Get(static_cast(audioEvent.type), eventParam, 0); + EXPECT_EQ(DH_SUCCESS, sinkDev_->handler_->GetEventParam(msg, paramResult)); +} } // DistributedHardware } // OHOS 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 a1715fbcb9c82eb2ca3e4b165c2abea524c53e0d..b161adfa6f13449b5f8f61fe7aa103591992006e 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,6 +57,35 @@ 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. + * @tc.type: FUNC + * @tc.require: AR000H0E5F + */ +HWTEST_F(DAudioSinkManagerTest, HandleDAudioNotify_001, TestSize.Level1) +{ + std::string devId = "1"; + std::string dhId = "1"; + std::string content = "1"; + int32_t type = 1; + daudioSinkManager.audioDevMap_.emplace(devId, nullptr); + EXPECT_EQ(DH_SUCCESS, daudioSinkManager.HandleDAudioNotify(devId, dhId, type, content)); +} + /** * @tc.name: DAudioNotify_001 * @tc.desc: Verify the DAudioNotify function. diff --git a/services/audiotransport/test/unittest/receiverengine/engineutils/include/engine_test_utils.h b/services/audiotransport/test/unittest/receiverengine/engineutils/include/engine_test_utils.h index f4a3b6319e940039ba95ceccb6f1fa9e3246c3a5..781ef4034b54c382ad3cd0002b837666d4f0e548 100644 --- a/services/audiotransport/test/unittest/receiverengine/engineutils/include/engine_test_utils.h +++ b/services/audiotransport/test/unittest/receiverengine/engineutils/include/engine_test_utils.h @@ -198,6 +198,78 @@ public: return false; } }; + +class MockIAVSenderEngineForFail : public IAVSenderEngine { +public: + explicit MockIAVSenderEngineForFail() {} + ~MockIAVSenderEngineForFail() {} + + int32_t Initialize() override + { + return 0; + } + + int32_t Start() override + { + return 0; + } + + int32_t Stop() override + { + return 0; + } + + int32_t Release() override + { + return 1; + } + + int32_t PushData(const std::shared_ptr &buffer) override + { + return 0; + } + + int32_t SetParameter(AVTransTag tag, const std::string &value) override + { + (void) tag; + (void) value; + return 0; + } + + int32_t SendMessage(const std::shared_ptr &message) override + { + return 0; + } + + int32_t CreateControlChannel(const std::vector &dstDevIds, + const ChannelAttribute &attribution) override + { + (void) dstDevIds; + (void) attribution; + return 1; + } + + int32_t RegisterSenderCallback(const std::shared_ptr &callback) + { + (void) callback; + return 0; + } + + bool StartDumpMediaData() override + { + return false; + } + + bool StopDumpMediaData() override + { + return false; + } + + bool ReStartDumpMediaData() override + { + return false; + } +}; } // DistributedHardware } // OHOS #endif // OHOS_ENGINE_TEST_UTILS_H \ No newline at end of file diff --git a/services/audiotransport/test/unittest/senderengine/src/av_sender_engine_adapter_test.cpp b/services/audiotransport/test/unittest/senderengine/src/av_sender_engine_adapter_test.cpp index 5c5d140ef515fa722fa98afb627ec2cf69e9b9c9..54dd04947fb2643381d4b5cd6fc6abdd23383680 100644 --- a/services/audiotransport/test/unittest/senderengine/src/av_sender_engine_adapter_test.cpp +++ b/services/audiotransport/test/unittest/senderengine/src/av_sender_engine_adapter_test.cpp @@ -69,6 +69,18 @@ HWTEST_F(AVSenderEngineAdapterTest, Initialize_002, TestSize.Level1) EXPECT_EQ(DH_SUCCESS, senderAdapter_->Release()); } +/** + * @tc.name: Release_001 + * @tc.desc: Verify the Release function. + * @tc.type: FUNC + * @tc.require: AR000HTAPM + */ +HWTEST_F(AVSenderEngineAdapterTest, Release_001, TestSize.Level1) +{ + senderAdapter_->senderEngine_ = std::make_shared(); + EXPECT_EQ(DH_SUCCESS, senderAdapter_->Release()); +} + /** * @tc.name: Start_001 * @tc.desc: Verify the Start and Stop function. @@ -149,6 +161,20 @@ HWTEST_F(AVSenderEngineAdapterTest, CreateControlChannel_002, TestSize.Level1) EXPECT_EQ(ERR_DH_AV_TRANS_CREATE_CHANNEL_FAILED, senderAdapter_->CreateControlChannel(peerDevId)); } +/** + * @tc.name: WaitForChannelCreated_001 + * @tc.desc: Verify the WaitForChannelCreated function. + * @tc.type: FUNC + * @tc.require: AR000HTAPM + */ +HWTEST_F(AVSenderEngineAdapterTest, WaitForChannelCreated_001, TestSize.Level1) +{ + senderAdapter_->chnCreateSuccess_ = true; + EXPECT_EQ(DH_SUCCESS, senderAdapter_->WaitForChannelCreated()); + senderAdapter_->chnCreateSuccess_ = false; + EXPECT_EQ(ERR_DH_AUDIO_SA_WAIT_TIMEOUT, senderAdapter_->WaitForChannelCreated()); +} + /** * @tc.name: SendMessageToRemote_001 * @tc.desc: Verify the SendMessageToRemote function. @@ -196,5 +222,21 @@ HWTEST_F(AVSenderEngineAdapterTest, OnSenderEvent_001, TestSize.Level1) EXPECT_EQ(DH_SUCCESS, senderAdapter_->OnSenderEvent(event)); EXPECT_EQ(DH_SUCCESS, senderAdapter_->OnMessageReceived(message)); } + +/** + * @tc.name: OnSenderEvent_002 + * @tc.desc: Verify the OnSenderEvent function. + * @tc.type: FUNC + * @tc.require: AR000HTAPM + */ +HWTEST_F(AVSenderEngineAdapterTest, OnSenderEvent_002, TestSize.Level1) +{ + AVTransEvent event; + event.type = EventType::EVENT_ADD_STREAM; + EXPECT_EQ(DH_SUCCESS, senderAdapter_->OnSenderEvent(event)); + senderAdapter_->adapterCallback_ = std::make_shared(); + event.type = EventType::EVENT_START_SUCCESS; + EXPECT_EQ(DH_SUCCESS, senderAdapter_->OnSenderEvent(event)); +} } // namespace DistributedHardware } // namespace OHOS 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 486867b1f35e750d573031d527f86ac37863e172..57b919a2f36f1f68fbfadc525515d9883f75b0c1 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 @@ -187,6 +187,25 @@ HWTEST_F(AVSenderEngineTransportTest, SetParameter_001, TestSize.Level1) EXPECT_EQ(ERR_DH_AUDIO_NULLPTR, senderTrans_->SetParameter(audioParam)); senderTrans_->senderAdapter_ = std::make_shared(); EXPECT_EQ(DH_SUCCESS, senderTrans_->SetParameter(audioParam)); + message = std::make_shared(); + 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 message = nullptr; + senderTrans_->OnEngineMessage(message); + message = std::make_shared(); + senderTrans_->OnEngineMessage(message); + senderTrans_->transCallback_ = nullptr; + senderTrans_->OnEngineMessage(message); } } // namespace DistributedHardware } // namespace OHOS