From b0564254090331bed780c0cd4c15049fb4d1e6d7 Mon Sep 17 00:00:00 2001 From: Bobie Date: Wed, 2 Aug 2023 21:01:13 +0800 Subject: [PATCH 1/2] handler handler 2 eventhandler 3 Signed-off-by: Bobie --- bundle.json | 1 + .../managersink/include/daudio_sink_dev.h | 36 +++ .../managersink/src/daudio_sink_dev.cpp | 276 +++++++++++++++++- services/audiomanager/servicesink/BUILD.gn | 1 + 4 files changed, 308 insertions(+), 6 deletions(-) diff --git a/bundle.json b/bundle.json index f909afb4..e963b311 100755 --- a/bundle.json +++ b/bundle.json @@ -33,6 +33,7 @@ "distributed_hardware_fwk", "drivers_interface_audio", "dsoftbus", + "eventhandler", "hdf_core", "hisysevent", "hitrace", diff --git a/services/audiomanager/managersink/include/daudio_sink_dev.h b/services/audiomanager/managersink/include/daudio_sink_dev.h index 79183916..891c148d 100644 --- a/services/audiomanager/managersink/include/daudio_sink_dev.h +++ b/services/audiomanager/managersink/include/daudio_sink_dev.h @@ -25,6 +25,7 @@ #include "daudio_sink_dev_ctrl_manager.h" #include "dmic_client.h" #include "dspeaker_client.h" +#include "event_handler.h" #include "iaudio_event_callback.h" #include "imic_client.h" #include "ispk_client.h" @@ -62,6 +63,7 @@ private: int32_t TaskCloseCtrlChannel(const std::string &args); int32_t TaskOpenDSpeaker(const std::string &args); int32_t TaskCloseDSpeaker(const std::string &args); + int32_t TaskStartRender(); int32_t TaskOpenDMic(const std::string &args); int32_t TaskCloseDMic(const std::string &args); int32_t TaskSetParameter(const std::string &args); @@ -114,6 +116,40 @@ private: std::map memberFuncMap_; std::atomic isSpkInUse_ = false; std::atomic isMicInUse_ = false; + + class SinkEventHandler : public AppExecFwk::EventHandler { + public: + SinkEventHandler(const std::shared_ptr &runner, const std::shared_ptr &dev); + ~SinkEventHandler() override; + void ProcessEvent(const AppExecFwk::InnerEvent::Pointer &event) override; + + private: + void NotifyOpenCtrlChannel(const AppExecFwk::InnerEvent::Pointer &event); + void NotifyCloseCtrlChannel(const AppExecFwk::InnerEvent::Pointer &event); + void NotifyCtrlOpened(const AppExecFwk::InnerEvent::Pointer &event); + void NotifyCtrlClosed(const AppExecFwk::InnerEvent::Pointer &event); + void NotifyOpenSpeaker(const AppExecFwk::InnerEvent::Pointer &event); + void NotifyCloseSpeaker(const AppExecFwk::InnerEvent::Pointer &event); + void NotifySpeakerOpened(const AppExecFwk::InnerEvent::Pointer &event); + void NotifySpeakerClosed(const AppExecFwk::InnerEvent::Pointer &event); + void NotifyOpenMic(const AppExecFwk::InnerEvent::Pointer &event); + void NotifyCloseMic(const AppExecFwk::InnerEvent::Pointer &event); + void NotifyMicOpened(const AppExecFwk::InnerEvent::Pointer &event); + void NotifyMicClosed(const AppExecFwk::InnerEvent::Pointer &event); + void NotifySetVolume(const AppExecFwk::InnerEvent::Pointer &event); + void NotifyVolumeChange(const AppExecFwk::InnerEvent::Pointer &event); + void NotifySetParam(const AppExecFwk::InnerEvent::Pointer &event); + void NotifySetMute(const AppExecFwk::InnerEvent::Pointer &event); + void NotifyFocusChange(const AppExecFwk::InnerEvent::Pointer &event); + void NotifyRenderStateChange(const AppExecFwk::InnerEvent::Pointer &event); + void NotifyPlayStatusChange(const AppExecFwk::InnerEvent::Pointer &event); + + private: + using SinkEventFunc = void (SinkEventHandler::*)(const AppExecFwk::InnerEvent::Pointer &event); + std::map mapEventFuncs_; + std::shared_ptr sinkDev_; + }; + std::shared_ptr handler_; }; } // DistributedHardware } // OHOS diff --git a/services/audiomanager/managersink/src/daudio_sink_dev.cpp b/services/audiomanager/managersink/src/daudio_sink_dev.cpp index 0ee55fa9..43a68f03 100644 --- a/services/audiomanager/managersink/src/daudio_sink_dev.cpp +++ b/services/audiomanager/managersink/src/daudio_sink_dev.cpp @@ -64,6 +64,12 @@ int32_t DAudioSinkDev::AwakeAudioDev() constexpr size_t capacity = 20; taskQueue_ = std::make_shared(capacity); taskQueue_->Start(); + auto runner = AppExecFwk::EventRunner::Create(true); + if (runner == nullptr) { + DHLOGE("Create runner failed."); + return ERR_DH_AUDIO_NULLPTR; + } + handler_ = std::make_shared(runner, shared_from_this()); return DH_SUCCESS; } @@ -75,6 +81,14 @@ void DAudioSinkDev::SleepAudioDev() } taskQueue_->Stop(); taskQueue_ = nullptr; + + if (handler_ == nullptr) { + DHLOGI("Event handler is already stoped."); + return; + } + while (!handler_->IsIdle()) { + DHLOGD("Event handler is proccesing."); + } } int32_t DAudioSinkDev::InitAVTransEngines(const ChannelState channelState, IAVEngineProvider *providerPtr) @@ -101,13 +115,12 @@ void DAudioSinkDev::NotifyEvent(const AudioEvent &audioEvent) { DHLOGD("Notify event, eventType: %d.", (int32_t)audioEvent.type); - std::map::iterator iter = memberFuncMap_.find(audioEvent.type); - if (iter == memberFuncMap_.end()) { - DHLOGE("Invalid eventType."); - return; + auto eventParam = std::make_shared(audioEvent); + auto msgEvent = AppExecFwk::InnerEvent::Get(static_cast(audioEvent.type), eventParam, 0); + if (handler_ != nullptr) { + handler_->SendEvent(msgEvent, 0, AppExecFwk::EventQueue::Priority::IMMEDIATE); + DHLOGD("Send event success."); } - DAudioSinkDevFunc &func = iter->second; - (this->*func)(audioEvent); } int32_t DAudioSinkDev::NotifyOpenCtrlChannel(const AudioEvent &audioEvent) @@ -415,6 +428,21 @@ int32_t DAudioSinkDev::TaskCloseDSpeaker(const std::string &args) return DH_SUCCESS; } +int32_t DAudioSinkDev::TaskStartRender() +{ + if (speakerClient_ == nullptr) { + DHLOGE("Speaker client is null."); + return ERR_DH_AUDIO_NULLPTR; + } + int32_t ret = speakerClient_->StartRender(); + if (ret != DH_SUCCESS) { + DHLOGE("Start render failed. ret: %d.", ret); + return ret; + } + DHLOGI("Start render success."); + return DH_SUCCESS; +} + int32_t DAudioSinkDev::TaskOpenDMic(const std::string &args) { DHLOGI("Open mic device."); @@ -638,5 +666,241 @@ int32_t DAudioSinkDev::HandleEngineMessage(uint32_t type, std::string content, s DHLOGI("HandleEngineMessage enter."); return DAudioSinkManager::GetInstance().HandleDAudioNotify(devId, devId, static_cast(type), content); } + +DAudioSinkDev::SinkEventHandler::SinkEventHandler(const std::shared_ptr &runner, + const std::shared_ptr &dev) : AppExecFwk::EventHandler(runner), sinkDev_(dev) +{ + DHLOGD("Event handler is constructing."); + mapEventFuncs_[static_cast(OPEN_CTRL)] = &DAudioSinkDev::SinkEventHandler::NotifyOpenCtrlChannel; + mapEventFuncs_[static_cast(CLOSE_CTRL)] = &DAudioSinkDev::SinkEventHandler::NotifyCloseCtrlChannel; + mapEventFuncs_[static_cast(CTRL_OPENED)] = &DAudioSinkDev::SinkEventHandler::NotifyCtrlOpened; + mapEventFuncs_[static_cast(CTRL_CLOSED)] = &DAudioSinkDev::SinkEventHandler::NotifyCtrlClosed; + mapEventFuncs_[static_cast(OPEN_SPEAKER)] = &DAudioSinkDev::SinkEventHandler::NotifyOpenSpeaker; + mapEventFuncs_[static_cast(CLOSE_SPEAKER)] = &DAudioSinkDev::SinkEventHandler::NotifyCloseSpeaker; + mapEventFuncs_[static_cast(SPEAKER_OPENED)] = &DAudioSinkDev::SinkEventHandler::NotifySpeakerOpened; + mapEventFuncs_[static_cast(SPEAKER_CLOSED)] = &DAudioSinkDev::SinkEventHandler::NotifySpeakerClosed; + mapEventFuncs_[static_cast(OPEN_MIC)] = &DAudioSinkDev::SinkEventHandler::NotifyOpenMic; + mapEventFuncs_[static_cast(CLOSE_MIC)] = &DAudioSinkDev::SinkEventHandler::NotifyCloseMic; + mapEventFuncs_[static_cast(MIC_OPENED)] = &DAudioSinkDev::SinkEventHandler::NotifyMicOpened; + mapEventFuncs_[static_cast(MIC_CLOSED)] = &DAudioSinkDev::SinkEventHandler::NotifyMicClosed; + mapEventFuncs_[static_cast(VOLUME_SET)] = &DAudioSinkDev::SinkEventHandler::NotifySetVolume; + mapEventFuncs_[static_cast(VOLUME_CHANGE)] = &DAudioSinkDev::SinkEventHandler::NotifyVolumeChange; + mapEventFuncs_[static_cast(SET_PARAM)] = &DAudioSinkDev::SinkEventHandler::NotifySetParam; + mapEventFuncs_[static_cast(VOLUME_MUTE_SET)] = &DAudioSinkDev::SinkEventHandler::NotifySetMute; + mapEventFuncs_[static_cast(AUDIO_FOCUS_CHANGE)] = &DAudioSinkDev::SinkEventHandler::NotifyFocusChange; + mapEventFuncs_[static_cast(AUDIO_RENDER_STATE_CHANGE)] = &DAudioSinkDev::SinkEventHandler::NotifyRenderStateChange; + mapEventFuncs_[static_cast(CHANGE_PLAY_STATUS)] = &DAudioSinkDev::SinkEventHandler::NotifyPlayStatusChange; + +} + +DAudioSinkDev::SinkEventHandler::~SinkEventHandler() {} + +void DAudioSinkDev::SinkEventHandler::ProcessEvent(const AppExecFwk::InnerEvent::Pointer &event) +{ + auto iter = mapEventFuncs_.find(event->GetInnerEventId()); + if (iter == mapEventFuncs_.end()) { + DHLOGE("Event Id is invaild.", event->GetInnerEventId()); + return; + } + SinkEventFunc &func = iter->second; + (this->*func)(event); +} + +void DAudioSinkDev::SinkEventHandler::NotifyOpenCtrlChannel(const AppExecFwk::InnerEvent::Pointer &event) +{ + DHLOGI("Notify open ctrl channel."); + std::shared_ptr audioEvent = event->GetSharedObject(); + if (sinkDev_->TaskOpenCtrlChannel(audioEvent->content) != DH_SUCCESS) { + // TODO: + DHLOGD("bobie"); + } +} + +void DAudioSinkDev::SinkEventHandler::NotifyCloseCtrlChannel(const AppExecFwk::InnerEvent::Pointer &event) +{ + DHLOGI("Notify close ctrl channel."); + std::shared_ptr audioEvent = event->GetSharedObject(); + if (sinkDev_->TaskCloseCtrlChannel(audioEvent->content) != DH_SUCCESS) { + // TODO: + DHLOGD("bobie"); + } +} + +void DAudioSinkDev::SinkEventHandler::NotifyCtrlOpened(const AppExecFwk::InnerEvent::Pointer &event) +{ +} + +void DAudioSinkDev::SinkEventHandler::NotifyCtrlClosed(const AppExecFwk::InnerEvent::Pointer &event) +{ + DHLOGI("Notify ctrl closed."); + std::shared_ptr audioEvent = event->GetSharedObject(); + if (sinkDev_->TaskCloseCtrlChannel(audioEvent->content) != DH_SUCCESS) { + // TODO: + DHLOGD("bobie"); + } + if (sinkDev_->TaskCloseDSpeaker(audioEvent->content) != DH_SUCCESS) { + // TODO: + DHLOGD("bobie"); + } + if (sinkDev_->TaskCloseDMic(audioEvent->content) != DH_SUCCESS) { + // TODO: + DHLOGD("bobie"); + } +} + +void DAudioSinkDev::SinkEventHandler::NotifyOpenSpeaker(const AppExecFwk::InnerEvent::Pointer &event) +{ + std::shared_ptr audioEvent = event->GetSharedObject(); + if (sinkDev_->TaskOpenDSpeaker(audioEvent->content) != DH_SUCCESS) { + // TODO: + DHLOGD("bobie"); + } + +} + +void DAudioSinkDev::SinkEventHandler::NotifyCloseSpeaker(const AppExecFwk::InnerEvent::Pointer &event) +{ + + std::shared_ptr audioEvent = event->GetSharedObject(); + if (sinkDev_->TaskOpenDSpeaker(audioEvent->content) != DH_SUCCESS) { + // TODO: + DHLOGD("bobie"); + } + +} + +void DAudioSinkDev::SinkEventHandler::NotifySpeakerOpened(const AppExecFwk::InnerEvent::Pointer &event) +{ + DHLOGD("Starting render."); + if (event == nullptr || sinkDev_ == nullptr) { + DHLOGE("The input event or sink dev is null."); + return; + } + std::shared_ptr audioEvent = event->GetSharedObject(); + if (sinkDev_->TaskStartRender() != DH_SUCCESS) { + DHLOGE("Speaker client start failed."); + return; + } + if (sinkDev_->TaskVolumeChange(audioEvent->content) != DH_SUCCESS) { + DHLOGE("Notify pimary volume to source device failed."); + return; + } +} + +void DAudioSinkDev::SinkEventHandler::NotifySpeakerClosed(const AppExecFwk::InnerEvent::Pointer &event) +{ + std::shared_ptr audioEvent = event->GetSharedObject(); + if (sinkDev_->TaskCloseDSpeaker(audioEvent->content) != DH_SUCCESS) { + // TODO: + DHLOGD("bobie"); + } + +} + +void DAudioSinkDev::SinkEventHandler::NotifyOpenMic(const AppExecFwk::InnerEvent::Pointer &event) +{ + std::shared_ptr audioEvent = event->GetSharedObject(); + if (sinkDev_->TaskOpenDMic(audioEvent->content) != DH_SUCCESS) { + // TODO: + DHLOGD("bobie"); + } + +} + +void DAudioSinkDev::SinkEventHandler::NotifyCloseMic(const AppExecFwk::InnerEvent::Pointer &event) +{ + std::shared_ptr audioEvent = event->GetSharedObject(); + if (sinkDev_->TaskCloseDMic(audioEvent->content) != DH_SUCCESS) { + // TODO: + DHLOGD("bobie"); + } + +} + +void DAudioSinkDev::SinkEventHandler::NotifyMicOpened(const AppExecFwk::InnerEvent::Pointer &event) +{ + // TODO: TaskCloseDMic + +} + +void DAudioSinkDev::SinkEventHandler::NotifyMicClosed(const AppExecFwk::InnerEvent::Pointer &event) +{ + std::shared_ptr audioEvent = event->GetSharedObject(); + if (sinkDev_->TaskCloseDMic(audioEvent->content) != DH_SUCCESS) { + // TODO: + DHLOGD("bobie"); + } + +} + +void DAudioSinkDev::SinkEventHandler::NotifySetVolume(const AppExecFwk::InnerEvent::Pointer &event) +{ + std::shared_ptr audioEvent = event->GetSharedObject(); + if (sinkDev_->TaskCloseDMic(audioEvent->content) != DH_SUCCESS) { + // TODO: + DHLOGD("bobie"); + } + +} + +void DAudioSinkDev::SinkEventHandler::NotifyVolumeChange(const AppExecFwk::InnerEvent::Pointer &event) +{ + std::shared_ptr audioEvent = event->GetSharedObject(); + if (sinkDev_->TaskVolumeChange(audioEvent->content) != DH_SUCCESS) { + // TODO: + DHLOGD("bobie"); + } + +} + +void DAudioSinkDev::SinkEventHandler::NotifySetParam(const AppExecFwk::InnerEvent::Pointer &event) +{ + std::shared_ptr audioEvent = event->GetSharedObject(); + if (sinkDev_->TaskSetParameter(audioEvent->content) != DH_SUCCESS) { + // TODO: + DHLOGD("bobie"); + } + +} + +void DAudioSinkDev::SinkEventHandler::NotifySetMute(const AppExecFwk::InnerEvent::Pointer &event) +{ + std::shared_ptr audioEvent = event->GetSharedObject(); + if (sinkDev_->TaskSetMute(audioEvent->content) != DH_SUCCESS) { + // TODO: + DHLOGD("bobie"); + } + +} + +void DAudioSinkDev::SinkEventHandler::NotifyFocusChange(const AppExecFwk::InnerEvent::Pointer &event) +{ + std::shared_ptr audioEvent = event->GetSharedObject(); + if (sinkDev_->TaskFocusChange(audioEvent->content) != DH_SUCCESS) { + // TODO: + DHLOGD("bobie"); + } + +} + +void DAudioSinkDev::SinkEventHandler::NotifyRenderStateChange(const AppExecFwk::InnerEvent::Pointer &event) +{ + std::shared_ptr audioEvent = event->GetSharedObject(); + if (sinkDev_->TaskRenderStateChange(audioEvent->content) != DH_SUCCESS) { + // TODO: + DHLOGD("bobie"); + } + +} + +void DAudioSinkDev::SinkEventHandler::NotifyPlayStatusChange(const AppExecFwk::InnerEvent::Pointer &event) +{ + std::shared_ptr audioEvent = event->GetSharedObject(); + if (sinkDev_->TaskPlayStatusChange(audioEvent->content) != DH_SUCCESS) { + // TODO: + DHLOGD("bobie"); + } + +} } // namespace DistributedHardware } // namespace OHOS diff --git a/services/audiomanager/servicesink/BUILD.gn b/services/audiomanager/servicesink/BUILD.gn index 835f8816..2a605183 100755 --- a/services/audiomanager/servicesink/BUILD.gn +++ b/services/audiomanager/servicesink/BUILD.gn @@ -98,6 +98,7 @@ ohos_shared_library("distributed_audio_sink") { "distributed_hardware_fwk:libdhfwk_sdk", "drivers_interface_audio:libaudio_proxy_1.0", "dsoftbus:softbus_client", + "eventhandler:libeventhandler", "hdf_core:libhdf_ipc_adapter", "hdf_core:libhdi", "hisysevent:libhisysevent", -- Gitee From a215811b665a65476918b861dc83ef44abf4f278 Mon Sep 17 00:00:00 2001 From: Bobie Date: Thu, 3 Aug 2023 22:16:17 +0800 Subject: [PATCH 2/2] handler 4 Signed-off-by: Bobie --- .../managersink/include/daudio_sink_dev.h | 35 +- .../managersink/src/daudio_sink_dev.cpp | 545 +++++++----------- .../managersink/src/daudio_sink_dev_test.cpp | 473 +-------------- 3 files changed, 220 insertions(+), 833 deletions(-) diff --git a/services/audiomanager/managersink/include/daudio_sink_dev.h b/services/audiomanager/managersink/include/daudio_sink_dev.h index 891c148d..58fb5fc9 100644 --- a/services/audiomanager/managersink/include/daudio_sink_dev.h +++ b/services/audiomanager/managersink/include/daudio_sink_dev.h @@ -21,17 +21,17 @@ #include #include +#include "event_handler.h" #include "nlohmann/json.hpp" + #include "daudio_sink_dev_ctrl_manager.h" #include "dmic_client.h" #include "dspeaker_client.h" -#include "event_handler.h" #include "iaudio_event_callback.h" #include "imic_client.h" #include "ispk_client.h" #include "i_av_engine_provider.h" #include "i_av_receiver_engine_callback.h" -#include "task_queue.h" #ifdef DAUDIO_SUPPORT_DIRECT #include "direct_dmic_client.h" @@ -73,27 +73,7 @@ private: int32_t TaskSetVolume(const std::string &args); int32_t TaskSetMute(const std::string &args); int32_t TaskPlayStatusChange(const std::string &args); - void OnTaskResult(int32_t resultCode, const std::string &result, const std::string &funcName); - - int32_t NotifyOpenCtrlChannel(const AudioEvent &audioEvent); - int32_t NotifyCloseCtrlChannel(const AudioEvent &audioEvent); - int32_t NotifyCtrlOpened(const AudioEvent &audioEvent); - int32_t NotifyCtrlClosed(const AudioEvent &audioEvent); - int32_t NotifyOpenSpeaker(const AudioEvent &audioEvent); - int32_t NotifyCloseSpeaker(const AudioEvent &audioEvent); - int32_t NotifySpeakerOpened(const AudioEvent &audioEvent); - int32_t NotifySpeakerClosed(const AudioEvent &audioEvent); - int32_t NotifyOpenMic(const AudioEvent &audioEvent); - int32_t NotifyCloseMic(const AudioEvent &audioEvent); - int32_t NotifyMicOpened(const AudioEvent &audioEvent); - int32_t NotifyMicClosed(const AudioEvent &audioEvent); - int32_t NotifySetVolume(const AudioEvent &audioEvent); - int32_t NotifyVolumeChange(const AudioEvent &audioEvent); - int32_t NotifySetParam(const AudioEvent &audioEvent); - int32_t NotifySetMute(const AudioEvent &audioEvent); - int32_t NotifyFocusChange(const AudioEvent &audioEvent); - int32_t NotifyRenderStateChange(const AudioEvent &audioEvent); - int32_t NotifyPlayStatusChange(const AudioEvent &audioEvent); + void NotifySourceDev(const AudioEventType type, const std::string dhId, const int32_t result); int32_t from_json(const json &j, AudioParam &audioParam); int32_t HandleEngineMessage(uint32_t type, std::string content, std::string devId); @@ -101,25 +81,22 @@ private: void JudgeDeviceStatus(); private: - std::mutex taskQueueMutex_; std::mutex rpcWaitMutex_; std::condition_variable rpcWaitCond_; std::string devId_; std::string spkDhId_; std::string micDhId_; - std::shared_ptr taskQueue_ = nullptr; std::shared_ptr speakerClient_ = nullptr; std::shared_ptr micClient_ = nullptr; std::shared_ptr audioCtrlMgr_ = nullptr; - using DAudioSinkDevFunc = int32_t (DAudioSinkDev::*)(const AudioEvent &audioEvent); - std::map memberFuncMap_; std::atomic isSpkInUse_ = false; std::atomic isMicInUse_ = false; class SinkEventHandler : public AppExecFwk::EventHandler { public: - SinkEventHandler(const std::shared_ptr &runner, const std::shared_ptr &dev); + SinkEventHandler(const std::shared_ptr &runner, + const std::shared_ptr &dev); ~SinkEventHandler() override; void ProcessEvent(const AppExecFwk::InnerEvent::Pointer &event) override; @@ -147,7 +124,7 @@ private: private: using SinkEventFunc = void (SinkEventHandler::*)(const AppExecFwk::InnerEvent::Pointer &event); std::map mapEventFuncs_; - std::shared_ptr sinkDev_; + std::weak_ptr sinkDev_; }; std::shared_ptr handler_; }; diff --git a/services/audiomanager/managersink/src/daudio_sink_dev.cpp b/services/audiomanager/managersink/src/daudio_sink_dev.cpp index 43a68f03..ff347463 100644 --- a/services/audiomanager/managersink/src/daudio_sink_dev.cpp +++ b/services/audiomanager/managersink/src/daudio_sink_dev.cpp @@ -33,25 +33,6 @@ namespace DistributedHardware { DAudioSinkDev::DAudioSinkDev(const std::string &devId) : devId_(devId) { DHLOGD("Distributed audio sink device constructed, devId: %s.", GetAnonyString(devId).c_str()); - memberFuncMap_[OPEN_CTRL] = &DAudioSinkDev::NotifyOpenCtrlChannel; - memberFuncMap_[CLOSE_CTRL] = &DAudioSinkDev::NotifyCloseCtrlChannel; - memberFuncMap_[CTRL_OPENED] = &DAudioSinkDev::NotifyCtrlOpened; - memberFuncMap_[CTRL_CLOSED] = &DAudioSinkDev::NotifyCtrlClosed; - memberFuncMap_[SET_PARAM] = &DAudioSinkDev::NotifySetParam; - memberFuncMap_[AUDIO_FOCUS_CHANGE] = &DAudioSinkDev::NotifyFocusChange; - memberFuncMap_[AUDIO_RENDER_STATE_CHANGE] = &DAudioSinkDev::NotifyRenderStateChange; - memberFuncMap_[OPEN_SPEAKER] = &DAudioSinkDev::NotifyOpenSpeaker; - memberFuncMap_[CLOSE_SPEAKER] = &DAudioSinkDev::NotifyCloseSpeaker; - memberFuncMap_[SPEAKER_OPENED] = &DAudioSinkDev::NotifySpeakerOpened; - memberFuncMap_[SPEAKER_CLOSED] = &DAudioSinkDev::NotifySpeakerClosed; - memberFuncMap_[OPEN_MIC] = &DAudioSinkDev::NotifyOpenMic; - memberFuncMap_[CLOSE_MIC] = &DAudioSinkDev::NotifyCloseMic; - memberFuncMap_[MIC_OPENED] = &DAudioSinkDev::NotifyMicOpened; - memberFuncMap_[MIC_CLOSED] = &DAudioSinkDev::NotifyMicClosed; - memberFuncMap_[VOLUME_SET] = &DAudioSinkDev::NotifySetVolume; - memberFuncMap_[VOLUME_MUTE_SET] = &DAudioSinkDev::NotifySetMute; - memberFuncMap_[VOLUME_CHANGE] = &DAudioSinkDev::NotifyVolumeChange; - memberFuncMap_[CHANGE_PLAY_STATUS] = &DAudioSinkDev::NotifyPlayStatusChange; } DAudioSinkDev::~DAudioSinkDev() @@ -61,12 +42,9 @@ DAudioSinkDev::~DAudioSinkDev() int32_t DAudioSinkDev::AwakeAudioDev() { - constexpr size_t capacity = 20; - taskQueue_ = std::make_shared(capacity); - taskQueue_->Start(); auto runner = AppExecFwk::EventRunner::Create(true); if (runner == nullptr) { - DHLOGE("Create runner failed."); + DHLOGE("Create runner failed."); return ERR_DH_AUDIO_NULLPTR; } handler_ = std::make_shared(runner, shared_from_this()); @@ -75,13 +53,6 @@ int32_t DAudioSinkDev::AwakeAudioDev() void DAudioSinkDev::SleepAudioDev() { - if (taskQueue_ == nullptr) { - DHLOGI("Task queue already stop."); - return; - } - taskQueue_->Stop(); - taskQueue_ = nullptr; - if (handler_ == nullptr) { DHLOGI("Event handler is already stoped."); return; @@ -114,7 +85,6 @@ int32_t DAudioSinkDev::InitAVTransEngines(const ChannelState channelState, IAVEn void DAudioSinkDev::NotifyEvent(const AudioEvent &audioEvent) { DHLOGD("Notify event, eventType: %d.", (int32_t)audioEvent.type); - auto eventParam = std::make_shared(audioEvent); auto msgEvent = AppExecFwk::InnerEvent::Get(static_cast(audioEvent.type), eventParam, 0); if (handler_ != nullptr) { @@ -123,237 +93,6 @@ void DAudioSinkDev::NotifyEvent(const AudioEvent &audioEvent) } } -int32_t DAudioSinkDev::NotifyOpenCtrlChannel(const AudioEvent &audioEvent) -{ - DHLOGI("Notify open ctrl channel."); - if (taskQueue_ == nullptr) { - DHLOGE("Task queue is null."); - return ERR_DH_AUDIO_NULLPTR; - } - auto task = GenerateTask(this, &DAudioSinkDev::TaskOpenCtrlChannel, audioEvent.content, "Sink Open Ctrl", - &DAudioSinkDev::OnTaskResult); - return taskQueue_->Produce(task); -} - -int32_t DAudioSinkDev::NotifyCloseCtrlChannel(const AudioEvent &audioEvent) -{ - DHLOGI("Notify close ctrl channel."); - if (taskQueue_ == nullptr) { - DHLOGE("Task queue is null."); - return ERR_DH_AUDIO_NULLPTR; - } - auto task = GenerateTask(this, &DAudioSinkDev::TaskCloseCtrlChannel, audioEvent.content, "Sink Close Ctrl", - &DAudioSinkDev::OnTaskResult); - return taskQueue_->Produce(task); -} - -int32_t DAudioSinkDev::NotifyCtrlOpened(const AudioEvent &audioEvent) -{ - DHLOGI("Notify ctrl opened."); - (void)audioEvent; - return DH_SUCCESS; -} - -int32_t DAudioSinkDev::NotifyCtrlClosed(const AudioEvent &audioEvent) -{ - DHLOGI("Notify ctrl closed."); - if (taskQueue_ == nullptr) { - DHLOGE("Task queue is null."); - return ERR_DH_AUDIO_NULLPTR; - } - auto task = GenerateTask(this, &DAudioSinkDev::TaskCloseCtrlChannel, "", "Sink Close Ctrl", - &DAudioSinkDev::OnTaskResult); - taskQueue_->Produce(task); - task = GenerateTask(this, &DAudioSinkDev::TaskCloseDSpeaker, "", "Sink Close Speaker", - &DAudioSinkDev::OnTaskResult); - taskQueue_->Produce(task); - task = GenerateTask(this, &DAudioSinkDev::TaskCloseDMic, "", "Sink Close Mic", &DAudioSinkDev::OnTaskResult); - taskQueue_->Produce(task); - DAudioSinkManager::GetInstance().OnSinkDevReleased(devId_); - return DH_SUCCESS; -} - -int32_t DAudioSinkDev::NotifyOpenSpeaker(const AudioEvent &audioEvent) -{ - DHLOGI("Notify open speaker."); - if (taskQueue_ == nullptr) { - DHLOGE("Task queue is null."); - return ERR_DH_AUDIO_NULLPTR; - } - auto task = GenerateTask(this, &DAudioSinkDev::TaskOpenDSpeaker, audioEvent.content, - "Sink Open Speaker", &DAudioSinkDev::OnTaskResult); - return taskQueue_->Produce(task); -} - -int32_t DAudioSinkDev::NotifyCloseSpeaker(const AudioEvent &audioEvent) -{ - DHLOGI("Notify close speaker."); - if (taskQueue_ == nullptr) { - DHLOGE("Task queue is null."); - return ERR_DH_AUDIO_NULLPTR; - } - auto task = GenerateTask(this, &DAudioSinkDev::TaskCloseDSpeaker, audioEvent.content, - "Sink Close Speaker", &DAudioSinkDev::OnTaskResult); - return taskQueue_->Produce(task); -} - -int32_t DAudioSinkDev::NotifySpeakerOpened(const AudioEvent &audioEvent) -{ - DHLOGI("Notify speaker opened."); - if (speakerClient_ == nullptr || taskQueue_ == nullptr) { - DHLOGE("Speaker client or task queue is null."); - return ERR_DH_AUDIO_NULLPTR; - } - int32_t ret = speakerClient_->StartRender(); - if (ret != DH_SUCCESS) { - DHLOGE("Start render failed. ret: %d.", ret); - return ret; - } - DHLOGI("Notify primary volume."); - auto task = GenerateTask(this, &DAudioSinkDev::TaskVolumeChange, audioEvent.content, - "Sink Notify Vol Change", &DAudioSinkDev::OnTaskResult); - return taskQueue_->Produce(task); -} - -int32_t DAudioSinkDev::NotifySpeakerClosed(const AudioEvent &audioEvent) -{ - (void)audioEvent; - DHLOGI("Notify speaker closed."); - if (taskQueue_ == nullptr) { - DHLOGE("Task queue is null."); - return ERR_DH_AUDIO_NULLPTR; - } - auto task = GenerateTask(this, &DAudioSinkDev::TaskCloseDSpeaker, "", "Sink Close Speaker", - &DAudioSinkDev::OnTaskResult); - return taskQueue_->Produce(task); -} - -int32_t DAudioSinkDev::NotifyMicOpened(const AudioEvent &audioEvent) -{ - (void)audioEvent; - DHLOGI("Notify mic opened."); - return DH_SUCCESS; -} - -int32_t DAudioSinkDev::NotifyMicClosed(const AudioEvent &audioEvent) -{ - DHLOGI("Notify mic closed."); - if (taskQueue_ == nullptr) { - DHLOGE("Task queue is null."); - return ERR_DH_AUDIO_NULLPTR; - } - auto task = GenerateTask(this, &DAudioSinkDev::TaskCloseDMic, "", "Sink Close Mic", &DAudioSinkDev::OnTaskResult); - return taskQueue_->Produce(task); -} - -int32_t DAudioSinkDev::NotifyOpenMic(const AudioEvent &audioEvent) -{ - DHLOGI("Notify open dMic."); - if (taskQueue_ == nullptr) { - DHLOGE("Task queue is null."); - return ERR_DH_AUDIO_NULLPTR; - } - auto task = GenerateTask(this, &DAudioSinkDev::TaskOpenDMic, audioEvent.content, "Sink Open Mic", - &DAudioSinkDev::OnTaskResult); - return taskQueue_->Produce(task); -} - -int32_t DAudioSinkDev::NotifyCloseMic(const AudioEvent &audioEvent) -{ - DHLOGI("Notify close dMic."); - if (taskQueue_ == nullptr) { - DHLOGE("Task queue is null."); - return ERR_DH_AUDIO_NULLPTR; - } - auto task = GenerateTask(this, &DAudioSinkDev::TaskCloseDMic, audioEvent.content, "Sink Close Mic", - &DAudioSinkDev::OnTaskResult); - return taskQueue_->Produce(task); -} - -int32_t DAudioSinkDev::NotifySetParam(const AudioEvent &audioEvent) -{ - DHLOGD("Notify set param."); - if (taskQueue_ == nullptr) { - DHLOGE("Task queue is null."); - return ERR_DH_AUDIO_NULLPTR; - } - auto task = GenerateTask(this, &DAudioSinkDev::TaskSetParameter, audioEvent.content, "Sink Set Param", - &DAudioSinkDev::OnTaskResult); - return taskQueue_->Produce(task); -} - -int32_t DAudioSinkDev::NotifySetVolume(const AudioEvent &audioEvent) -{ - DHLOGD("Notify set volume."); - if (taskQueue_ == nullptr) { - DHLOGE("Task queue is null."); - return ERR_DH_AUDIO_NULLPTR; - } - auto task = GenerateTask(this, &DAudioSinkDev::TaskSetVolume, audioEvent.content, - "Sink Notify SetVolume", &DAudioSinkDev::OnTaskResult); - return taskQueue_->Produce(task); -} - -int32_t DAudioSinkDev::NotifySetMute(const AudioEvent &audioEvent) -{ - DHLOGD("Notify set mute."); - if (taskQueue_ == nullptr) { - DHLOGE("Task queue is null."); - return ERR_DH_AUDIO_NULLPTR; - } - auto task = GenerateTask(this, &DAudioSinkDev::TaskSetMute, audioEvent.content, - "Sink NotifySetMute", &DAudioSinkDev::OnTaskResult); - return taskQueue_->Produce(task); -} - -int32_t DAudioSinkDev::NotifyVolumeChange(const AudioEvent &audioEvent) -{ - DHLOGD("Notify volume change."); - if (taskQueue_ == nullptr) { - DHLOGE("Task queue is null."); - return ERR_DH_AUDIO_NULLPTR; - } - auto task = GenerateTask(this, &DAudioSinkDev::TaskVolumeChange, audioEvent.content, - "Sink Notify Volume Change", &DAudioSinkDev::OnTaskResult); - return taskQueue_->Produce(task); -} - -int32_t DAudioSinkDev::NotifyFocusChange(const AudioEvent &audioEvent) -{ - DHLOGD("Notify focus change."); - if (taskQueue_ == nullptr) { - DHLOGE("Task queue is null."); - return ERR_DH_AUDIO_NULLPTR; - } - auto task = GenerateTask(this, &DAudioSinkDev::TaskFocusChange, audioEvent.content, - "Sink Notify Focus Change", &DAudioSinkDev::OnTaskResult); - return taskQueue_->Produce(task); -} - -int32_t DAudioSinkDev::NotifyRenderStateChange(const AudioEvent &audioEvent) -{ - DHLOGD("Notify render state change."); - if (taskQueue_ == nullptr) { - DHLOGE("Task queue is null."); - return ERR_DH_AUDIO_NULLPTR; - } - auto task = GenerateTask(this, &DAudioSinkDev::TaskRenderStateChange, audioEvent.content, - "Sink Notify Render State Change", &DAudioSinkDev::OnTaskResult); - return taskQueue_->Produce(task); -} - -int32_t DAudioSinkDev::NotifyPlayStatusChange(const AudioEvent &audioEvent) -{ - DHLOGD("Notify play status change, content: %s.", audioEvent.content.c_str()); - if (taskQueue_ == nullptr) { - DHLOGE("Task queue is null."); - return ERR_DH_AUDIO_NULLPTR; - } - auto task = GenerateTask(this, &DAudioSinkDev::TaskPlayStatusChange, audioEvent.content, - "Sink Notify Play Status Change", &DAudioSinkDev::OnTaskResult); - return taskQueue_->Produce(task); -} - int32_t DAudioSinkDev::TaskOpenCtrlChannel(const std::string &args) { DHLOGI("Open ctrl channel."); @@ -612,14 +351,6 @@ void DAudioSinkDev::JudgeDeviceStatus() DAudioSinkManager::GetInstance().OnSinkDevReleased(devId_); } -void DAudioSinkDev::OnTaskResult(int32_t resultCode, const std::string &result, const std::string &funcName) -{ - (void)resultCode; - (void)result; - (void)funcName; - DHLOGD("On task result. resultCode: %d, funcName: %s", resultCode, funcName.c_str()); -} - void DAudioSinkDev::NotifySourceDev(const AudioEventType type, const std::string dhId, const int32_t result) { std::random_device rd; @@ -688,9 +419,10 @@ DAudioSinkDev::SinkEventHandler::SinkEventHandler(const std::shared_ptr(SET_PARAM)] = &DAudioSinkDev::SinkEventHandler::NotifySetParam; mapEventFuncs_[static_cast(VOLUME_MUTE_SET)] = &DAudioSinkDev::SinkEventHandler::NotifySetMute; mapEventFuncs_[static_cast(AUDIO_FOCUS_CHANGE)] = &DAudioSinkDev::SinkEventHandler::NotifyFocusChange; - mapEventFuncs_[static_cast(AUDIO_RENDER_STATE_CHANGE)] = &DAudioSinkDev::SinkEventHandler::NotifyRenderStateChange; - mapEventFuncs_[static_cast(CHANGE_PLAY_STATUS)] = &DAudioSinkDev::SinkEventHandler::NotifyPlayStatusChange; - + mapEventFuncs_[static_cast(AUDIO_RENDER_STATE_CHANGE)] = + &DAudioSinkDev::SinkEventHandler::NotifyRenderStateChange; + mapEventFuncs_[static_cast(CHANGE_PLAY_STATUS)] = + &DAudioSinkDev::SinkEventHandler::NotifyPlayStatusChange; } DAudioSinkDev::SinkEventHandler::~SinkEventHandler() {} @@ -709,79 +441,123 @@ void DAudioSinkDev::SinkEventHandler::ProcessEvent(const AppExecFwk::InnerEvent: void DAudioSinkDev::SinkEventHandler::NotifyOpenCtrlChannel(const AppExecFwk::InnerEvent::Pointer &event) { DHLOGI("Notify open ctrl channel."); + if (event == nullptr || sinkDev_.expired()) { + DHLOGE("The input event or sink dev is null."); + return; + } std::shared_ptr audioEvent = event->GetSharedObject(); - if (sinkDev_->TaskOpenCtrlChannel(audioEvent->content) != DH_SUCCESS) { - // TODO: - DHLOGD("bobie"); + if (audioEvent == nullptr) { + DHLOGE("The audio event is nullptr."); + return; + } + if (sinkDev_.lock()->TaskOpenCtrlChannel(audioEvent->content) != DH_SUCCESS) { + DHLOGE("Open ctrl channel failed."); + return; } } void DAudioSinkDev::SinkEventHandler::NotifyCloseCtrlChannel(const AppExecFwk::InnerEvent::Pointer &event) { DHLOGI("Notify close ctrl channel."); + if (event == nullptr || sinkDev_.expired()) { + DHLOGE("The input event or sink dev is null."); + return; + } std::shared_ptr audioEvent = event->GetSharedObject(); - if (sinkDev_->TaskCloseCtrlChannel(audioEvent->content) != DH_SUCCESS) { - // TODO: - DHLOGD("bobie"); + if (audioEvent == nullptr) { + DHLOGE("The audio event is nullptr."); + return; + } + if (sinkDev_.lock()->TaskCloseCtrlChannel(audioEvent->content) != DH_SUCCESS) { + DHLOGE("Close ctrl channel falied."); + return; } } void DAudioSinkDev::SinkEventHandler::NotifyCtrlOpened(const AppExecFwk::InnerEvent::Pointer &event) { + DHLOGI("Ctrl channel is opened."); + (void)event; } void DAudioSinkDev::SinkEventHandler::NotifyCtrlClosed(const AppExecFwk::InnerEvent::Pointer &event) { DHLOGI("Notify ctrl closed."); + if (event == nullptr || sinkDev_.expired()) { + DHLOGE("The input event or sink dev is null."); + return; + } std::shared_ptr audioEvent = event->GetSharedObject(); - if (sinkDev_->TaskCloseCtrlChannel(audioEvent->content) != DH_SUCCESS) { - // TODO: - DHLOGD("bobie"); + if (audioEvent == nullptr) { + DHLOGE("The audio event is nullptr."); + return; } - if (sinkDev_->TaskCloseDSpeaker(audioEvent->content) != DH_SUCCESS) { - // TODO: - DHLOGD("bobie"); + if (sinkDev_.lock()->TaskCloseCtrlChannel(audioEvent->content) != DH_SUCCESS) { + DHLOGE("Close ctrl channel failed."); + return; + } + if (sinkDev_.lock()->TaskCloseDSpeaker(audioEvent->content) != DH_SUCCESS) { + DHLOGE("Close speaker failed."); + return; } - if (sinkDev_->TaskCloseDMic(audioEvent->content) != DH_SUCCESS) { - // TODO: - DHLOGD("bobie"); + if (sinkDev_.lock()->TaskCloseDMic(audioEvent->content) != DH_SUCCESS) { + DHLOGE("Close mic failed."); + return; } + sinkDev_.lock()->JudgeDeviceStatus(); } void DAudioSinkDev::SinkEventHandler::NotifyOpenSpeaker(const AppExecFwk::InnerEvent::Pointer &event) { + if (event == nullptr || sinkDev_.expired()) { + DHLOGE("The input event or sink dev is null."); + return; + } std::shared_ptr audioEvent = event->GetSharedObject(); - if (sinkDev_->TaskOpenDSpeaker(audioEvent->content) != DH_SUCCESS) { - // TODO: - DHLOGD("bobie"); + if (audioEvent == nullptr) { + DHLOGE("The audio event is nullptr."); + return; + } + if (sinkDev_.lock()->TaskOpenDSpeaker(audioEvent->content) != DH_SUCCESS) { + DHLOGE("Open speaker failed."); + return; } - } void DAudioSinkDev::SinkEventHandler::NotifyCloseSpeaker(const AppExecFwk::InnerEvent::Pointer &event) { - + if (event == nullptr || sinkDev_.expired()) { + DHLOGE("The input event or sink dev is null."); + return; + } std::shared_ptr audioEvent = event->GetSharedObject(); - if (sinkDev_->TaskOpenDSpeaker(audioEvent->content) != DH_SUCCESS) { - // TODO: - DHLOGD("bobie"); + if (audioEvent == nullptr) { + DHLOGE("The audio event is nullptr."); + return; + } + if (sinkDev_.lock()->TaskOpenDSpeaker(audioEvent->content) != DH_SUCCESS) { + DHLOGE("Open speaker failed."); + return; } - } void DAudioSinkDev::SinkEventHandler::NotifySpeakerOpened(const AppExecFwk::InnerEvent::Pointer &event) { DHLOGD("Starting render."); - if (event == nullptr || sinkDev_ == nullptr) { + if (event == nullptr || sinkDev_.expired()) { DHLOGE("The input event or sink dev is null."); return; } std::shared_ptr audioEvent = event->GetSharedObject(); - if (sinkDev_->TaskStartRender() != DH_SUCCESS) { + if (audioEvent == nullptr) { + DHLOGE("The audio event is nullptr."); + return; + } + if (sinkDev_.lock()->TaskStartRender() != DH_SUCCESS) { DHLOGE("Speaker client start failed."); return; } - if (sinkDev_->TaskVolumeChange(audioEvent->content) != DH_SUCCESS) { + if (sinkDev_.lock()->TaskVolumeChange(audioEvent->content) != DH_SUCCESS) { DHLOGE("Notify pimary volume to source device failed."); return; } @@ -789,118 +565,195 @@ void DAudioSinkDev::SinkEventHandler::NotifySpeakerOpened(const AppExecFwk::Inne void DAudioSinkDev::SinkEventHandler::NotifySpeakerClosed(const AppExecFwk::InnerEvent::Pointer &event) { + if (event == nullptr || sinkDev_.expired()) { + DHLOGE("The input event or sink dev is null."); + return; + } std::shared_ptr audioEvent = event->GetSharedObject(); - if (sinkDev_->TaskCloseDSpeaker(audioEvent->content) != DH_SUCCESS) { - // TODO: - DHLOGD("bobie"); + if (audioEvent == nullptr) { + DHLOGE("The audio event is nullptr."); + return; + } + if (sinkDev_.lock()->TaskCloseDSpeaker(audioEvent->content) != DH_SUCCESS) { + DHLOGE("Close speaker failed."); + return; } - } void DAudioSinkDev::SinkEventHandler::NotifyOpenMic(const AppExecFwk::InnerEvent::Pointer &event) { + if (event == nullptr || sinkDev_.expired()) { + DHLOGE("The input event or sink dev is null."); + return; + } std::shared_ptr audioEvent = event->GetSharedObject(); - if (sinkDev_->TaskOpenDMic(audioEvent->content) != DH_SUCCESS) { - // TODO: - DHLOGD("bobie"); + if (audioEvent == nullptr) { + DHLOGE("The audio event is nullptr."); + return; + } + if (sinkDev_.lock()->TaskOpenDMic(audioEvent->content) != DH_SUCCESS) { + DHLOGE("Open mic failed."); + return; } - } void DAudioSinkDev::SinkEventHandler::NotifyCloseMic(const AppExecFwk::InnerEvent::Pointer &event) { + if (event == nullptr || sinkDev_.expired()) { + DHLOGE("The input event or sink dev is null."); + return; + } std::shared_ptr audioEvent = event->GetSharedObject(); - if (sinkDev_->TaskCloseDMic(audioEvent->content) != DH_SUCCESS) { - // TODO: - DHLOGD("bobie"); + if (audioEvent == nullptr) { + DHLOGE("The audio event is nullptr."); + return; + } + if (sinkDev_.lock()->TaskCloseDMic(audioEvent->content) != DH_SUCCESS) { + DHLOGE("Close mic failed."); + return; } - } void DAudioSinkDev::SinkEventHandler::NotifyMicOpened(const AppExecFwk::InnerEvent::Pointer &event) { - // TODO: TaskCloseDMic - + DHLOGI("Notify mic is opened."); + (void)event; } void DAudioSinkDev::SinkEventHandler::NotifyMicClosed(const AppExecFwk::InnerEvent::Pointer &event) { + if (event == nullptr || sinkDev_.expired()) { + DHLOGE("The input event or sink dev is null."); + return; + } std::shared_ptr audioEvent = event->GetSharedObject(); - if (sinkDev_->TaskCloseDMic(audioEvent->content) != DH_SUCCESS) { - // TODO: - DHLOGD("bobie"); + if (audioEvent == nullptr) { + DHLOGE("The audio event is nullptr."); + return; + } + if (sinkDev_.lock()->TaskCloseDMic(audioEvent->content) != DH_SUCCESS) { + DHLOGE("Close mic failed."); + return; } - } void DAudioSinkDev::SinkEventHandler::NotifySetVolume(const AppExecFwk::InnerEvent::Pointer &event) { + if (event == nullptr || sinkDev_.expired()) { + DHLOGE("The input event or sink dev is null."); + return; + } std::shared_ptr audioEvent = event->GetSharedObject(); - if (sinkDev_->TaskCloseDMic(audioEvent->content) != DH_SUCCESS) { - // TODO: - DHLOGD("bobie"); + if (audioEvent == nullptr) { + DHLOGE("The audio event is nullptr."); + return; + } + if (sinkDev_.lock()->TaskCloseDMic(audioEvent->content) != DH_SUCCESS) { + DHLOGE("Close mic failed."); + return; } - } void DAudioSinkDev::SinkEventHandler::NotifyVolumeChange(const AppExecFwk::InnerEvent::Pointer &event) { + if (event == nullptr || sinkDev_.expired()) { + DHLOGE("The input event or sink dev is null."); + return; + } std::shared_ptr audioEvent = event->GetSharedObject(); - if (sinkDev_->TaskVolumeChange(audioEvent->content) != DH_SUCCESS) { - // TODO: - DHLOGD("bobie"); + if (audioEvent == nullptr) { + DHLOGE("The audio event is nullptr."); + return; + } + if (sinkDev_.lock()->TaskVolumeChange(audioEvent->content) != DH_SUCCESS) { + DHLOGE("Notify volume change status to source device failed."); + return; } - } void DAudioSinkDev::SinkEventHandler::NotifySetParam(const AppExecFwk::InnerEvent::Pointer &event) { + if (event == nullptr || sinkDev_.expired()) { + DHLOGE("The input event or sink dev is null."); + return; + } std::shared_ptr audioEvent = event->GetSharedObject(); - if (sinkDev_->TaskSetParameter(audioEvent->content) != DH_SUCCESS) { - // TODO: - DHLOGD("bobie"); + if (audioEvent == nullptr) { + DHLOGE("The audio event is nullptr."); + return; + } + if (sinkDev_.lock()->TaskSetParameter(audioEvent->content) != DH_SUCCESS) { + DHLOGE("Set parameters failed."); + return; } - } void DAudioSinkDev::SinkEventHandler::NotifySetMute(const AppExecFwk::InnerEvent::Pointer &event) { + if (event == nullptr || sinkDev_.expired()) { + DHLOGE("The input event or sink dev is null."); + return; + } std::shared_ptr audioEvent = event->GetSharedObject(); - if (sinkDev_->TaskSetMute(audioEvent->content) != DH_SUCCESS) { - // TODO: - DHLOGD("bobie"); + if (audioEvent == nullptr) { + DHLOGE("The audio event is nullptr."); + return; + } + if (sinkDev_.lock()->TaskSetMute(audioEvent->content) != DH_SUCCESS) { + DHLOGE("Set mute failed."); + return; } - } void DAudioSinkDev::SinkEventHandler::NotifyFocusChange(const AppExecFwk::InnerEvent::Pointer &event) { + if (event == nullptr || sinkDev_.expired()) { + DHLOGE("The input event or sink dev is null."); + return; + } std::shared_ptr audioEvent = event->GetSharedObject(); - if (sinkDev_->TaskFocusChange(audioEvent->content) != DH_SUCCESS) { - // TODO: - DHLOGD("bobie"); + if (audioEvent == nullptr) { + DHLOGE("The audio event is nullptr."); + return; + } + if (sinkDev_.lock()->TaskFocusChange(audioEvent->content) != DH_SUCCESS) { + DHLOGE("Handle focus change event failed."); + return; } - } void DAudioSinkDev::SinkEventHandler::NotifyRenderStateChange(const AppExecFwk::InnerEvent::Pointer &event) { + if (event == nullptr || sinkDev_.expired()) { + DHLOGE("The input event or sink dev is null."); + return; + } std::shared_ptr audioEvent = event->GetSharedObject(); - if (sinkDev_->TaskRenderStateChange(audioEvent->content) != DH_SUCCESS) { - // TODO: - DHLOGD("bobie"); + if (audioEvent == nullptr) { + DHLOGE("The audio event is nullptr."); + return; + } + if (sinkDev_.lock()->TaskRenderStateChange(audioEvent->content) != DH_SUCCESS) { + DHLOGE("Handle render state change failed."); + return; } - } void DAudioSinkDev::SinkEventHandler::NotifyPlayStatusChange(const AppExecFwk::InnerEvent::Pointer &event) { + if (event == nullptr || sinkDev_.expired()) { + DHLOGE("The input event or sink dev is null."); + return; + } std::shared_ptr audioEvent = event->GetSharedObject(); - if (sinkDev_->TaskPlayStatusChange(audioEvent->content) != DH_SUCCESS) { - // TODO: - DHLOGD("bobie"); + if (audioEvent == nullptr) { + DHLOGE("The audio event is nullptr."); + return; + } + if (sinkDev_.lock()->TaskPlayStatusChange(audioEvent->content) != DH_SUCCESS) { + DHLOGE("Handle play status change event failed."); + return; } - } } // namespace DistributedHardware } // namespace OHOS 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 03552f43..c61c680d 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 @@ -57,464 +57,6 @@ HWTEST_F(DAudioSinkDevTest, InitAVTransEngines_001, TestSize.Level1) EXPECT_EQ(DH_SUCCESS, sinkDev_->InitAVTransEngines(type, receiverPtr.get())); } -/** - * @tc.name: NotifyOpenCtrlChannel_001 - * @tc.desc: Verify the NotifyOpenCtrlChannel function. - * @tc.type: FUNC - * @tc.require: AR000H0E5F - */ -HWTEST_F(DAudioSinkDevTest, NotifyOpenCtrlChannel_001, TestSize.Level1) -{ - constexpr size_t capacity = 20; - AudioEvent event; - EXPECT_EQ(ERR_DH_AUDIO_NULLPTR, sinkDev_->NotifyOpenCtrlChannel(event)); - sinkDev_->taskQueue_ = std::make_shared(capacity); - EXPECT_EQ(DH_SUCCESS, sinkDev_->NotifyOpenCtrlChannel(event)); - event.type = OPEN_CTRL; - sinkDev_->NotifyEvent(event); - - event.type = EVENT_UNKNOWN; - sinkDev_->NotifyEvent(event); -} - -/** - * @tc.name: NotifyCloseCtrlChannel_001 - * @tc.desc: Verify the NotifyCloseCtrlChannel function. - * @tc.type: FUNC - * @tc.require: AR000H0E5F - */ -HWTEST_F(DAudioSinkDevTest, NotifyCloseCtrlChannel_001, TestSize.Level1) -{ - constexpr size_t capacity = 20; - sinkDev_->taskQueue_ = std::make_shared(capacity); - AudioEvent event; - EXPECT_EQ(DH_SUCCESS, sinkDev_->NotifyCloseCtrlChannel(event)); - sinkDev_->NotifyEvent(event); -} - -/** - * @tc.name: NotifyCtrlOpened_001 - * @tc.desc: Verify the NotifyCtrlOpened function. - * @tc.type: FUNC - * @tc.require: AR000H0E5F - */ -HWTEST_F(DAudioSinkDevTest, NotifyCtrlOpened_001, TestSize.Level1) -{ - AudioEvent event; - EXPECT_EQ(DH_SUCCESS, sinkDev_->NotifyCtrlOpened(event)); - sinkDev_->NotifyEvent(event); -} - -/** - * @tc.name: NotifyCtrlClosed_001 - * @tc.desc: Verify the NotifyCtrlClosed function. - * @tc.type: FUNC - * @tc.require: AR000H0E5F - */ -HWTEST_F(DAudioSinkDevTest, NotifyCtrlClosed_001, TestSize.Level1) -{ - AudioEvent event; - EXPECT_EQ(ERR_DH_AUDIO_NULLPTR, sinkDev_->NotifyCtrlClosed(event)); -} - -/** - * @tc.name: NotifyCtrlClosed_002 - * @tc.desc: Verify the NotifyCtrlClosed function. - * @tc.type: FUNC - * @tc.require: AR000H0E5F - */ -HWTEST_F(DAudioSinkDevTest, NotifyCtrlClosed_002, TestSize.Level1) -{ - AudioEvent event; - uint32_t maxSize = 10; - sinkDev_->taskQueue_ = std::make_shared(maxSize); - EXPECT_EQ(DH_SUCCESS, sinkDev_->NotifyCtrlClosed(event)); -} - -/** - * @tc.name: NotifySpeakerOpened_001 - * @tc.desc: Verify the NotifySpeakerOpened function. - * @tc.type: FUNC - * @tc.require: AR000H0E5F - */ -HWTEST_F(DAudioSinkDevTest, NotifySpeakerOpened_001, TestSize.Level1) -{ - AudioEvent event; - EXPECT_NE(DH_SUCCESS, sinkDev_->NotifySpeakerOpened(event)); -} - -/** - * @tc.name: NotifyOpenSpeaker_001 - * @tc.desc: Verify the NotifyOpenSpeaker function. - * @tc.type: FUNC - * @tc.require: AR000H0E5F - */ -HWTEST_F(DAudioSinkDevTest, NotifyOpenSpeaker_001, TestSize.Level1) -{ - AudioEvent event; - EXPECT_EQ(ERR_DH_AUDIO_NULLPTR, sinkDev_->NotifyOpenSpeaker(event)); -} - -/** - * @tc.name: NotifyOpenSpeaker_002 - * @tc.desc: Verify the NotifyOpenSpeaker function. - * @tc.type: FUNC - * @tc.require: AR000H0E5F - */ -HWTEST_F(DAudioSinkDevTest, NotifyOpenSpeaker_002, TestSize.Level1) -{ - AudioEvent event; - uint32_t maxSize = 10; - sinkDev_->taskQueue_ = std::make_shared(maxSize); - EXPECT_EQ(DH_SUCCESS, sinkDev_->NotifyOpenSpeaker(event)); -} - -/** - * @tc.name: NotifyCloseSpeaker_001 - * @tc.desc: Verify the NotifyCloseSpeaker function. - * @tc.type: FUNC - * @tc.require: AR000H0E5F - */ -HWTEST_F(DAudioSinkDevTest, NotifyCloseSpeaker_001, TestSize.Level1) -{ - AudioEvent event; - EXPECT_EQ(ERR_DH_AUDIO_NULLPTR, sinkDev_->NotifyCloseSpeaker(event)); -} - -/** - * @tc.name: NotifyCloseSpeaker_002 - * @tc.desc: Verify the NotifyCloseSpeaker function. - * @tc.type: FUNC - * @tc.require: AR000H0E5F - */ -HWTEST_F(DAudioSinkDevTest, NotifyCloseSpeaker_002, TestSize.Level1) -{ - AudioEvent event; - uint32_t maxSize = 10; - sinkDev_->taskQueue_ = std::make_shared(maxSize); - EXPECT_EQ(DH_SUCCESS, sinkDev_->NotifyCloseSpeaker(event)); -} - -/** - * @tc.name: NotifySpeakerOpened_002 - * @tc.desc: Verify the NotifySpeakerOpened function. - * @tc.type: FUNC - * @tc.require: AR000H0E5F - */ -HWTEST_F(DAudioSinkDevTest, NotifySpeakerOpened_002, TestSize.Level1) -{ - AudioEvent event; - std::string devId = "devid"; - sinkDev_->speakerClient_ = std::make_shared(devId, sinkDev_); - EXPECT_NE(DH_SUCCESS, sinkDev_->NotifySpeakerOpened(event)); -} - -/** - * @tc.name: NotifySpeakerOpened_003 - * @tc.desc: Verify the NotifySpeakerOpened function. - * @tc.type: FUNC - * @tc.require: AR000H0E5F - */ -HWTEST_F(DAudioSinkDevTest, NotifySpeakerOpened_003, TestSize.Level1) -{ - constexpr size_t capacity = 20; - sinkDev_->taskQueue_ = std::make_shared(capacity); - AudioEvent event; - std::string devId = "devid"; - sinkDev_->speakerClient_ = std::make_shared(devId, sinkDev_); - EXPECT_NE(DH_SUCCESS, sinkDev_->NotifySpeakerOpened(event)); -} - -/** - * @tc.name: NotifySpeakerClosed_001 - * @tc.desc: Verify the NotifySpeakerClosed function. - * @tc.type: FUNC - * @tc.require: AR000H0E5F - */ -HWTEST_F(DAudioSinkDevTest, NotifySpeakerClosed_001, TestSize.Level1) -{ - AudioEvent event; - EXPECT_EQ(ERR_DH_AUDIO_NULLPTR, sinkDev_->NotifySpeakerClosed(event)); -} - -/** - * @tc.name: NotifySpeakerClosed_002 - * @tc.desc: Verify the NotifySpeakerClosed function. - * @tc.type: FUNC - * @tc.require: AR000H0E5F - */ -HWTEST_F(DAudioSinkDevTest, NotifySpeakerClosed_002, TestSize.Level1) -{ - AudioEvent event; - uint32_t maxSize = 10; - sinkDev_->taskQueue_ = std::make_shared(maxSize); - EXPECT_EQ(DH_SUCCESS, sinkDev_->NotifySpeakerClosed(event)); -} - -/** - * @tc.name: NotifyMicOpened_001 - * @tc.desc: Verify the NotifyMicOpened function. - * @tc.type: FUNC - * @tc.require: AR000H0E5F - */ -HWTEST_F(DAudioSinkDevTest, NotifyMicOpened_001, TestSize.Level1) -{ - AudioEvent event; - EXPECT_EQ(DH_SUCCESS, sinkDev_->NotifyMicOpened(event)); -} - -/** - * @tc.name: NotifyMicClosed_001 - * @tc.desc: Verify the NotifyMicClosed function. - * @tc.type: FUNC - * @tc.require: AR000H0E5F - */ -HWTEST_F(DAudioSinkDevTest, NotifyMicClosed_001, TestSize.Level1) -{ - AudioEvent event; - EXPECT_EQ(ERR_DH_AUDIO_NULLPTR, sinkDev_->NotifyMicClosed(event)); -} - -/** - * @tc.name: NotifyMicClosed_002 - * @tc.desc: Verify the NotifyMicClosed function. - * @tc.type: FUNC - * @tc.require: AR000H0E5F - */ -HWTEST_F(DAudioSinkDevTest, NotifyMicClosed_002, TestSize.Level1) -{ - constexpr size_t capacity = 20; - sinkDev_->taskQueue_ = std::make_shared(capacity); - AudioEvent event; - EXPECT_NE(ERR_DH_AUDIO_NULLPTR, sinkDev_->NotifyMicClosed(event)); -} - -/** - * @tc.name: NotifyOpenMic_001 - * @tc.desc: Verify the NotifyOpenMic function. - * @tc.type: FUNC - * @tc.require: AR000H0E5F - */ -HWTEST_F(DAudioSinkDevTest, NotifyOpenMic_001, TestSize.Level1) -{ - AudioEvent event; - EXPECT_EQ(ERR_DH_AUDIO_NULLPTR, sinkDev_->NotifyOpenMic(event)); -} - -/** - * @tc.name: NotifyOpenMic_002 - * @tc.desc: Verify the NotifyOpenMic function. - * @tc.type: FUNC - * @tc.require: AR000H0E5F - */ -HWTEST_F(DAudioSinkDevTest, NotifyOpenMic_002, TestSize.Level1) -{ - constexpr size_t capacity = 20; - sinkDev_->taskQueue_ = std::make_shared(capacity); - AudioEvent event; - EXPECT_NE(ERR_DH_AUDIO_NULLPTR, sinkDev_->NotifyOpenMic(event)); -} - -/** - * @tc.name: NotifyCloseMic_001 - * @tc.desc: Verify the NotifyCloseMic function. - * @tc.type: FUNC - * @tc.require: AR000H0E5F - */ -HWTEST_F(DAudioSinkDevTest, NotifyCloseMic_001, TestSize.Level1) -{ - AudioEvent event; - EXPECT_EQ(ERR_DH_AUDIO_NULLPTR, sinkDev_->NotifyCloseMic(event)); -} - -/** - * @tc.name: NotifyCloseMic_002 - * @tc.desc: Verify the NotifyCloseMic function. - * @tc.type: FUNC - * @tc.require: AR000H0E5F - */ -HWTEST_F(DAudioSinkDevTest, NotifyCloseMic_002, TestSize.Level1) -{ - constexpr size_t capacity = 20; - sinkDev_->taskQueue_ = std::make_shared(capacity); - AudioEvent event; - EXPECT_NE(ERR_DH_AUDIO_NULLPTR, sinkDev_->NotifyCloseMic(event)); -} - -/** - * @tc.name: NotifySetParam_001 - * @tc.desc: Verify the NotifySetParam function. - * @tc.type: FUNC - * @tc.require: AR000H0E5F - */ -HWTEST_F(DAudioSinkDevTest, NotifySetParam_001, TestSize.Level1) -{ - AudioEvent event; - EXPECT_EQ(ERR_DH_AUDIO_NULLPTR, sinkDev_->NotifySetParam(event)); -} - -/** - * @tc.name: NotifySetParam_002 - * @tc.desc: Verify the NotifySetParam function. - * @tc.type: FUNC - * @tc.require: AR000H0E5F - */ -HWTEST_F(DAudioSinkDevTest, NotifySetParam_002, TestSize.Level1) -{ - constexpr size_t capacity = 20; - sinkDev_->taskQueue_ = std::make_shared(capacity); - AudioEvent event; - EXPECT_NE(ERR_DH_AUDIO_NULLPTR, sinkDev_->NotifySetParam(event)); -} - -/** - * @tc.name: NotifySetVolume_001 - * @tc.desc: Verify the NotifySetVolume function. - * @tc.type: FUNC - * @tc.require: AR000H0E5F - */ -HWTEST_F(DAudioSinkDevTest, NotifySetVolume_001, TestSize.Level1) -{ - AudioEvent event; - EXPECT_EQ(ERR_DH_AUDIO_NULLPTR, sinkDev_->NotifySetVolume(event)); -} - -/** - * @tc.name: NotifySetVolume_002 - * @tc.desc: Verify the NotifySetVolume function. - * @tc.type: FUNC - * @tc.require: AR000H0E5F - */ -HWTEST_F(DAudioSinkDevTest, NotifySetVolume_002, TestSize.Level1) -{ - constexpr size_t capacity = 20; - sinkDev_->taskQueue_ = std::make_shared(capacity); - AudioEvent event; - EXPECT_NE(ERR_DH_AUDIO_NULLPTR, sinkDev_->NotifySetVolume(event)); -} - -/** - * @tc.name: NotifySetMute_001 - * @tc.desc: Verify the NotifySetMute function. - * @tc.type: FUNC - * @tc.require: AR000H0E5F - */ -HWTEST_F(DAudioSinkDevTest, NotifySetMute_001, TestSize.Level1) -{ - AudioEvent event; - EXPECT_EQ(ERR_DH_AUDIO_NULLPTR, sinkDev_->NotifySetMute(event)); -} - -/** - * @tc.name: NotifySetMute_002 - * @tc.desc: Verify the NotifySetMute function. - * @tc.type: FUNC - * @tc.require: AR000H0E5F - */ -HWTEST_F(DAudioSinkDevTest, NotifySetMute_002, TestSize.Level1) -{ - constexpr size_t capacity = 20; - sinkDev_->taskQueue_ = std::make_shared(capacity); - AudioEvent event; - EXPECT_NE(ERR_DH_AUDIO_NULLPTR, sinkDev_->NotifySetMute(event)); -} - -/** - * @tc.name: NotifyVolumeChange_001 - * @tc.desc: Verify the NotifyVolumeChange function. - * @tc.type: FUNC - * @tc.require: AR000H0E5F - */ -HWTEST_F(DAudioSinkDevTest, NotifyVolumeChange_001, TestSize.Level1) -{ - AudioEvent event; - EXPECT_EQ(ERR_DH_AUDIO_NULLPTR, sinkDev_->NotifyVolumeChange(event)); -} - -/** - * @tc.name: NotifyVolumeChange_002 - * @tc.desc: Verify the NotifyVolumeChange function. - * @tc.type: FUNC - * @tc.require: AR000H0E5F - */ -HWTEST_F(DAudioSinkDevTest, NotifyVolumeChange_002, TestSize.Level1) -{ - constexpr size_t capacity = 20; - sinkDev_->taskQueue_ = std::make_shared(capacity); - AudioEvent event; - EXPECT_NE(ERR_DH_AUDIO_NULLPTR, sinkDev_->NotifyVolumeChange(event)); -} - -/** - * @tc.name: NotifyFocusChange_001 - * @tc.desc: Verify the NotifyFocusChange function. - * @tc.type: FUNC - * @tc.require: AR000H0E5F - */ -HWTEST_F(DAudioSinkDevTest, NotifyFocusChange_001, TestSize.Level1) -{ - AudioEvent event; - EXPECT_EQ(ERR_DH_AUDIO_NULLPTR, sinkDev_->NotifyFocusChange(event)); -} - -/** - * @tc.name: NotifyFocusChange_002 - * @tc.desc: Verify the NotifyFocusChange function. - * @tc.type: FUNC - * @tc.require: AR000H0E5F - */ -HWTEST_F(DAudioSinkDevTest, NotifyFocusChange_002, TestSize.Level1) -{ - constexpr size_t capacity = 20; - sinkDev_->taskQueue_ = std::make_shared(capacity); - AudioEvent event; - EXPECT_NE(ERR_DH_AUDIO_NULLPTR, sinkDev_->NotifyFocusChange(event)); -} - -/** - * @tc.name: NotifyRenderStateChange_001 - * @tc.desc: Verify the NotifyRenderStateChange function. - * @tc.type: FUNC - * @tc.require: AR000H0E5F - */ -HWTEST_F(DAudioSinkDevTest, NotifyRenderStateChange_001, TestSize.Level1) -{ - AudioEvent event; - EXPECT_EQ(ERR_DH_AUDIO_NULLPTR, sinkDev_->NotifyRenderStateChange(event)); -} - -/** - * @tc.name: NotifyRenderStateChange_002 - * @tc.desc: Verify the NotifyRenderStateChange function. - * @tc.type: FUNC - * @tc.require: AR000H0E5F - */ -HWTEST_F(DAudioSinkDevTest, NotifyRenderStateChange_002, TestSize.Level1) -{ - sinkDev_->SleepAudioDev(); - - constexpr size_t capacity = 20; - sinkDev_->taskQueue_ = std::make_shared(capacity); - AudioEvent event; - EXPECT_NE(ERR_DH_AUDIO_NULLPTR, sinkDev_->NotifyRenderStateChange(event)); -} - -/** - * @tc.name: NotifyPlayStatusChange_001 - * @tc.desc: Verify the NotifyPlayStatusChange function. - * @tc.type: FUNC - * @tc.require: AR000H0E5F - */ -HWTEST_F(DAudioSinkDevTest, NotifyPlayStatusChange_001, TestSize.Level1) -{ - AudioEvent event; - EXPECT_EQ(ERR_DH_AUDIO_NULLPTR, sinkDev_->NotifyPlayStatusChange(event)); - - EXPECT_EQ(DH_SUCCESS, sinkDev_->AwakeAudioDev()); - EXPECT_EQ(DH_SUCCESS, sinkDev_->NotifyPlayStatusChange(event)); - sinkDev_->SleepAudioDev(); -} - /** * @tc.name: TaskPlayStatusChange_001 * @tc.desc: Verify the TaskPlayStatusChange function. @@ -636,6 +178,21 @@ HWTEST_F(DAudioSinkDevTest, TaskCloseDSpeaker_002, TestSize.Level1) EXPECT_EQ(DH_SUCCESS, sinkDev_->TaskCloseDSpeaker(args)); } +/** + * @tc.name: TaskStartRender_001 + * @tc.desc: Verify the TaskStartRender function. + * @tc.type: FUNC + * @tc.require: AR000H0E5F + */ +HWTEST_F(DAudioSinkDevTest, TaskStartRender_001, TestSize.Level1) +{ + std::string devId = "devId"; + sinkDev_->speakerClient_ = nullptr; + EXPECT_EQ(ERR_DH_AUDIO_NULLPTR, sinkDev_->TaskStartRender()); + sinkDev_->speakerClient_ = std::make_shared(devId, sinkDev_); + EXPECT_NE(DH_SUCCESS, sinkDev_->TaskStartRender()); +} + /** * @tc.name: TaskOpenDMic_001 * @tc.desc: Verify the TaskOpenDMic function. -- Gitee