diff --git a/audiohandler/src/daudio_handler.cpp b/audiohandler/src/daudio_handler.cpp index 45b3bf7c9b1ccd1fae44dda8871b461fd36b1acb..ef2a392ca0eb93ebfc1e4aa64c2c5954f96f9c2c 100644 --- a/audiohandler/src/daudio_handler.cpp +++ b/audiohandler/src/daudio_handler.cpp @@ -32,6 +32,8 @@ namespace OHOS { namespace DistributedHardware { +static constexpr int32_t LOW_LATENCY_RENDER_ID = 3; +static constexpr int32_t DEFAULT_RENDER_ID = 1; IMPLEMENT_SINGLE_INSTANCE(DAudioHandler); DAudioHandler::DAudioHandler() @@ -105,6 +107,11 @@ std::vector DAudioHandler::Query() dhItem.attrs = jsonStr; dhItemVec.push_back(dhItem); DHLOGD("Query result: dhId: %d, attrs: %s.", dhId, jsonStr); + if (dhId == DEFAULT_RENDER_ID) { + dhItem.dhId = std::to_string(LOW_LATENCY_RENDER_ID); + dhItemVec.push_back(dhItem); + DHLOGD("Query result: dhId: %d, attrs: %s.", dhId, jsonStr); + } cJSON_Delete(infoJson); cJSON_free(jsonStr); diff --git a/hdf_service/distributed_audio/hdi_service/audio/v1_0/BUILD.gn b/hdf_service/distributed_audio/hdi_service/audio/v1_0/BUILD.gn index 7fdbfe6fe44a5a094dc3142041189d745a609a87..ec6968e92070820d91176a1aaedd334f02c6a3de 100644 --- a/hdf_service/distributed_audio/hdi_service/audio/v1_0/BUILD.gn +++ b/hdf_service/distributed_audio/hdi_service/audio/v1_0/BUILD.gn @@ -17,6 +17,7 @@ import("../../../../../distributedaudio.gni") ohos_shared_library("libaudio_manager_daudio_primary_service_1.0") { include_dirs = [ + "//third_party/cJSON", "${hdf_ser_aud_path}/include", "${hdf_service_path}/hdi_service/common/include", "${hdf_service_path}/hdi_service/common/log/include", @@ -42,6 +43,7 @@ ohos_shared_library("libaudio_manager_daudio_primary_service_1.0") { ] } + deps = [ "//third_party/cJSON:cjson" ] public_deps = [ "${hdf_service_path}/hdi_service/common:libdaudio_hdf_utils" ] external_deps = [ diff --git a/hdf_service/distributed_audio/hdi_service/audio/v1_0/include/audio_adapter_interface_impl.h b/hdf_service/distributed_audio/hdi_service/audio/v1_0/include/audio_adapter_interface_impl.h index 7f02f25faee55f1dbd2798de07316c71f191a343..dbdce5784b6085614a69a8f378381dcc9d08e3d3 100644 --- a/hdf_service/distributed_audio/hdi_service/audio/v1_0/include/audio_adapter_interface_impl.h +++ b/hdf_service/distributed_audio/hdi_service/audio/v1_0/include/audio_adapter_interface_impl.h @@ -92,8 +92,8 @@ public: int32_t RegExtraParamObserver(const sptr &audioCallback, int8_t cookie) override; public: - void SetSpeakerCallback(const sptr &speakerCallback); - void SetMicCallback(const sptr &micCallback); + void SetSpeakerCallback(const int32_t dhId, const sptr &speakerCallback); + void SetMicCallback(const int32_t dhId, const sptr &micCallback); AudioAdapterDescriptor GetAdapterDesc(); std::string GetDeviceCapabilitys(const uint32_t devId); int32_t AdapterLoad(); @@ -101,8 +101,9 @@ public: int32_t Notify(const uint32_t devId, const DAudioEvent &event); int32_t AddAudioDevice(const uint32_t devId, const std::string &caps); int32_t RemoveAudioDevice(const uint32_t devId); - int32_t OpenRenderDevice(const AudioDeviceDescriptor &desc, const AudioSampleAttributes &attrs); - int32_t CloseRenderDevice(const AudioDeviceDescriptor &desc); + int32_t OpenRenderDevice(const AudioDeviceDescriptor &desc, const AudioSampleAttributes &attrs, + const sptr extSpkCallback, int32_t dhId); + int32_t CloseRenderDevice(const AudioDeviceDescriptor &desc, const sptr extSpkCallback); int32_t OpenCaptureDevice(const AudioDeviceDescriptor &desc, const AudioSampleAttributes &attrs); int32_t CloseCaptureDevice(const AudioDeviceDescriptor &desc); uint32_t GetVolumeGroup(const uint32_t devId); @@ -119,12 +120,15 @@ private: int32_t WaitForSANotify(const AudioDeviceEvent &event); int32_t HandleDeviceClosed(const DAudioEvent &event); int32_t getEventTypeFromCondition(const std::string& condition); - int32_t InsertRenderImpl(const sptr &audioRender, uint32_t &renderId); + int32_t InsertRenderImpl(const sptr &audioRender, const int32_t dhId, + uint32_t &renderId); int32_t InsertCapImpl(const sptr &audioCapture, uint32_t &captureId); inline bool IsIdValid(const uint32_t id); bool CheckRendersValid(); bool CheckCapsValid(); void SetDumpFlag(bool isRender); + sptr MatchStreamCallback(const AudioSampleAttributes &attrs, + const AudioDeviceDescriptor &desc, int32_t &dhId); private: static constexpr uint8_t WAIT_SECONDS = 20; @@ -132,11 +136,12 @@ private: AudioAdapterDescriptor adpDescriptor_; AudioAdapterStatus status_ = STATUS_OFFLINE; - sptr extSpkCallback_ = nullptr; + //sptr extSpkCallback_ = nullptr; sptr extMicCallback_ = nullptr; + std::map> extCallbackMap_; sptr paramCallback_ = nullptr; std::mutex renderDevMtx_; - std::vector> renderDevs_; + std::vector>> renderDevs_; AudioParameter renderParam_; std::mutex capDevMtx_; std::vector> captureDevs_; diff --git a/hdf_service/distributed_audio/hdi_service/audio/v1_0/src/audio_adapter_interface_impl.cpp b/hdf_service/distributed_audio/hdi_service/audio/v1_0/src/audio_adapter_interface_impl.cpp index 1be35bacbba9135fef1c9a1333e7a6fcd9360f1c..07ac1e0647241b3f1ca7711ddb7a5202e5641bf0 100644 --- a/hdf_service/distributed_audio/hdi_service/audio/v1_0/src/audio_adapter_interface_impl.cpp +++ b/hdf_service/distributed_audio/hdi_service/audio/v1_0/src/audio_adapter_interface_impl.cpp @@ -35,12 +35,15 @@ namespace DistributedAudio { namespace Audio { namespace V1_0 { static constexpr uint32_t MAX_AUDIO_STREAM_NUM = 10; +static constexpr int32_t LOW_LATENCY_RENDER_ID = 3; +static constexpr int32_t DEFAULT_RENDER_ID = 1; +static constexpr int32_t DEFAULT_CAPTURE_ID = 1 << 27 | 1 << 0; AudioAdapterInterfaceImpl::AudioAdapterInterfaceImpl(const AudioAdapterDescriptor &desc) : adpDescriptor_(desc) { - renderDevs_ = std::vector>( - MAX_AUDIO_STREAM_NUM, sptr(nullptr)); + renderDevs_ = std::vector>>( + MAX_AUDIO_STREAM_NUM, std::make_pair(0, sptr(nullptr))); captureDevs_ = std::vector>( MAX_AUDIO_STREAM_NUM, sptr(nullptr)); renderParam_ = { 0, 0, 0, 0, 0, 0 }; @@ -54,22 +57,30 @@ AudioAdapterInterfaceImpl::~AudioAdapterInterfaceImpl() DHLOGD("Distributed audio adapter destructed, name(%s).", GetAnonyString(adpDescriptor_.adapterName).c_str()); } -void AudioAdapterInterfaceImpl::SetSpeakerCallback(const sptr &spkCallback) +void AudioAdapterInterfaceImpl::SetSpeakerCallback(const int32_t dhId, const sptr &spkCallback) { if (spkCallback == nullptr) { DHLOGE("Callback is nullptr."); return; } - extSpkCallback_ = spkCallback; + if (extCallbackMap_.find(dhId) != extCallbackMap_.end()) { + DHLOGI("The callback of daudio is already set."); + return; + } + extCallbackMap_[dhId] = spkCallback; } -void AudioAdapterInterfaceImpl::SetMicCallback(const sptr &micCallback) +void AudioAdapterInterfaceImpl::SetMicCallback(const int32_t dhId, const sptr &micCallback) { if (micCallback == nullptr) { DHLOGE("Callback is nullptr."); return; } - extMicCallback_ = micCallback; + if (extCallbackMap_.find(dhId) != extCallbackMap_.end()) { + DHLOGI("The callback of daudio is already set."); + return; + } + extCallbackMap_[dhId] = micCallback; } int32_t AudioAdapterInterfaceImpl::InitAllPorts() @@ -92,34 +103,40 @@ int32_t AudioAdapterInterfaceImpl::CreateRender(const AudioDeviceDescriptor &des return HDF_FAILURE; } } + int renderPinId = 0; + auto extSpkCallback = MatchStreamCallback(attrs, desc, renderPinId); + if (extSpkCallback == nullptr) { + DHLOGE("Matched callback is null."); + return HDF_FAILURE; + } #ifdef DAUDIO_SUPPORT_EXTENSION if (attrs.type == AUDIO_MMAP_NOIRQ) { DHLOGI("Try to mmap mode."); renderFlags_ = Audioext::V1_0::MMAP_MODE; audioRender = new AudioRenderExtImpl(); - audioRender->SetAttrs(adpDescriptor_.adapterName, desc, attrs, extSpkCallback_); + audioRender->SetAttrs(adpDescriptor_.adapterName, desc, attrs, extSpkCallback); } else { DHLOGI("Try to normal mode."); renderFlags_ = Audioext::V1_0::NORMAL_MODE; - audioRender = new AudioRenderInterfaceImpl(adpDescriptor_.adapterName, desc, attrs, extSpkCallback_); + audioRender = new AudioRenderInterfaceImpl(adpDescriptor_.adapterName, desc, attrs, extSpkCallback); } #else renderFlags_ = Audioext::V1_0::NORMAL_MODE; - audioRender = new AudioRenderInterfaceImpl(adpDescriptor_.adapterName, desc, attrs, extSpkCallback_); + audioRender = new AudioRenderInterfaceImpl(adpDescriptor_.adapterName, desc, attrs, extSpkCallback); #endif if (audioRender == nullptr) { DHLOGE("Create render failed."); return HDF_FAILURE; } - int32_t ret = OpenRenderDevice(desc, attrs); + int32_t ret = OpenRenderDevice(desc, attrs, extSpkCallback, renderPinId); if (ret != DH_SUCCESS) { DHLOGE("Open render device failed."); audioRender = nullptr; return ret == ERR_DH_AUDIO_HDF_WAIT_TIMEOUT ? HDF_ERR_TIMEOUT : HDF_FAILURE; } render = audioRender; - if (InsertRenderImpl(audioRender, renderId) != HDF_SUCCESS) { + if (InsertRenderImpl(audioRender, renderPinId, renderId) != HDF_SUCCESS) { DHLOGE("Generrate render ID and insert render failed."); return HDF_FAILURE; } @@ -127,8 +144,27 @@ int32_t AudioAdapterInterfaceImpl::CreateRender(const AudioDeviceDescriptor &des return HDF_SUCCESS; } +sptr AudioAdapterInterfaceImpl::MatchStreamCallback(const AudioSampleAttributes &attrs, + const AudioDeviceDescriptor &desc, int32_t &dhId) +{ + dhId = static_cast(desc.pins); + if (desc.pins == DEFAULT_RENDER_ID && attrs.type == AUDIO_MMAP_NOIRQ) { + dhId = LOW_LATENCY_RENDER_ID; + } + if (desc.pins == DEFAULT_CAPTURE_ID && attrs.type == AUDIO_MMAP_NOIRQ) { + dhId = DEFAULT_CAPTURE_ID - 1; + } + + auto iter = extCallbackMap_.find(dhId); + if (iter == extCallbackMap_.end()) { + DHLOGE("Can't find matched callback"); + return nullptr; + } + return iter->second; +} + int32_t AudioAdapterInterfaceImpl::InsertRenderImpl(const sptr &audioRender, - uint32_t &renderId) + const int32_t dhId, uint32_t &renderId) { std::lock_guard devLck(renderDevMtx_); if (renderDevs_.size() != MAX_AUDIO_STREAM_NUM) { @@ -137,7 +173,7 @@ int32_t AudioAdapterInterfaceImpl::InsertRenderImpl(const sptr audioRender(nullptr); + int32_t dhId = 0; { std::lock_guard devLck(renderDevMtx_); - audioRender = renderDevs_[renderId]; + audioRender = renderDevs_[renderId].second; + dhId = renderDevs_[renderId].first; } + sptr extSpkCallback(extCallbackMap_[dhId]); if (audioRender == nullptr) { DHLOGD("Render has not been created, do not need destroy."); return HDF_SUCCESS; } - int32_t ret = CloseRenderDevice(audioRender->GetRenderDesc()); + int32_t ret = CloseRenderDevice(audioRender->GetRenderDesc(), extSpkCallback); if (ret != DH_SUCCESS) { DHLOGE("Close render device failed."); return HDF_FAILURE; } { std::lock_guard devLck(renderDevMtx_); - renderDevs_[renderId] = nullptr; + renderDevs_[renderId] = std::make_pair(0, sptr(nullptr)); } return HDF_SUCCESS; } @@ -505,15 +544,15 @@ int32_t AudioAdapterInterfaceImpl::RemoveAudioDevice(const uint32_t devId) } int32_t AudioAdapterInterfaceImpl::OpenRenderDevice(const AudioDeviceDescriptor &desc, - const AudioSampleAttributes &attrs) + const AudioSampleAttributes &attrs, const sptr extSpkCallback, int32_t dhId) { - DHLOGI("Open render device, pin: %d.", desc.pins); + DHLOGI("Open render device, pin: %d.", dhId); if (isSpkOpened_) { DHLOGI("Render already opened."); return DH_SUCCESS; } std::lock_guard devLck(renderOptMtx_); - spkPinInUse_ = desc.pins; + spkPinInUse_ = dhId; // TODO: pinInUse需判断是否需要 renderParam_.format = attrs.format; renderParam_.channelCount = attrs.channelCount; renderParam_.sampleRate = attrs.sampleRate; @@ -522,12 +561,12 @@ int32_t AudioAdapterInterfaceImpl::OpenRenderDevice(const AudioDeviceDescriptor timeInterval_, renderFlags_ == Audioext::V1_0::MMAP_MODE); renderParam_.renderFlags = renderFlags_; - int32_t ret = extSpkCallback_->SetParameters(adpDescriptor_.adapterName, desc.pins, renderParam_); + int32_t ret = extSpkCallback->SetParameters(adpDescriptor_.adapterName, dhId, renderParam_); if (ret != HDF_SUCCESS) { DHLOGE("Set render parameters failed."); return ERR_DH_AUDIO_HDF_SET_PARAM_FAIL; } - ret = extSpkCallback_->OpenDevice(adpDescriptor_.adapterName, desc.pins); + ret = extSpkCallback->OpenDevice(adpDescriptor_.adapterName, dhId); if (ret != HDF_SUCCESS) { DHLOGE("Open render device failed."); return ERR_DH_AUDIO_HDF_OPEN_DEVICE_FAIL; @@ -542,16 +581,21 @@ int32_t AudioAdapterInterfaceImpl::OpenRenderDevice(const AudioDeviceDescriptor return DH_SUCCESS; } -int32_t AudioAdapterInterfaceImpl::CloseRenderDevice(const AudioDeviceDescriptor &desc) +int32_t AudioAdapterInterfaceImpl::CloseRenderDevice(const AudioDeviceDescriptor &desc, + sptr extSpkCallback) { DHLOGI("Close render device, pin: %d.", desc.pins); + if (extSpkCallback == nullptr) { + DHLOGE("Callback is null."); + return ERR_DH_AUDIO_HDF_NULLPTR; + } std::lock_guard devLck(renderOptMtx_); if (spkPinInUse_ == 0) { DHLOGI("No need close render device."); return DH_SUCCESS; } renderParam_ = {}; - int32_t ret = extSpkCallback_->CloseDevice(adpDescriptor_.adapterName, desc.pins); + int32_t ret = extSpkCallback->CloseDevice(adpDescriptor_.adapterName, desc.pins); if (ret != HDF_SUCCESS) { DHLOGE("Close audio device failed."); return ERR_DH_AUDIO_HDF_CLOSE_DEVICE_FAIL; @@ -666,10 +710,6 @@ uint32_t AudioAdapterInterfaceImpl::GetInterruptGroup(const uint32_t devId) int32_t AudioAdapterInterfaceImpl::SetAudioVolume(const std::string& condition, const std::string ¶m) { - if (extSpkCallback_ == nullptr) { - DHLOGE("Callback is nullptr."); - return ERR_DH_AUDIO_HDF_NULLPTR; - } std::string content = condition; int32_t type = getEventTypeFromCondition(content); EXT_PARAM_EVENT eventType; @@ -694,12 +734,15 @@ int32_t AudioAdapterInterfaceImpl::SetAudioVolume(const std::string& condition, { std::lock_guard devLck(renderDevMtx_); - for (auto render : renderDevs_) { - if (render == nullptr) { + for (auto item : renderDevs_) { + sptr extSpkCallback(extCallbackMap_[item.first]); + SetAudioParamStr(event.content, "dhId", std::to_string(item.first));// TODO:音量设置选择选择全部的render? + auto render = item.second; + if (render == nullptr || extSpkCallback == nullptr) { continue; } - if (extSpkCallback_->NotifyEvent(adpDescriptor_.adapterName, - render->GetRenderDesc().pins, event) != HDF_SUCCESS) { + if (extSpkCallback->NotifyEvent(adpDescriptor_.adapterName, + item.first, event) != HDF_SUCCESS) { DHLOGE("NotifyEvent failed."); return ERR_DH_AUDIO_HDF_FAIL; } @@ -714,7 +757,7 @@ int32_t AudioAdapterInterfaceImpl::GetAudioVolume(const std::string& condition, sptr audioRender(nullptr); { std::lock_guard devLck(renderDevMtx_); - audioRender = renderDevs_[renderId]; + audioRender = renderDevs_[renderId].second; } if (audioRender == nullptr) { DHLOGE("Render has not been created."); @@ -757,7 +800,7 @@ int32_t AudioAdapterInterfaceImpl::HandleVolumeChangeEvent(const DAudioEvent &ev sptr audioRender(nullptr); { std::lock_guard devLck(renderDevMtx_); - audioRender = renderDevs_[renderId]; + audioRender = renderDevs_[renderId].second; } if (audioRender == nullptr) { DHLOGE("Render has not been created."); @@ -986,7 +1029,7 @@ bool AudioAdapterInterfaceImpl::CheckRendersValid() { std::lock_guard devLck(renderDevMtx_); for (uint32_t i = 0; i < MAX_AUDIO_STREAM_NUM; i++) { - if (renderDevs_[i] != nullptr) { + if (renderDevs_[i].second != nullptr) { DHLOGI("Containing active render."); return true; } @@ -1013,7 +1056,8 @@ void AudioAdapterInterfaceImpl::SetDumpFlag(bool isRender) { if (isRender) { std::lock_guard renderLck(renderDevMtx_); - for (auto render : renderDevs_) { + for (auto item : renderDevs_) { + auto render = item.second; if (render == nullptr) { continue; } diff --git a/hdf_service/distributed_audio/hdi_service/audio/v1_0/src/audio_capture_interface_impl.cpp b/hdf_service/distributed_audio/hdi_service/audio/v1_0/src/audio_capture_interface_impl.cpp index 603208fb65874f7076c130396a0668437aceef3e..b8b3dc41a64dc20255ae3c632f93ebf6c6b4739a 100644 --- a/hdf_service/distributed_audio/hdi_service/audio/v1_0/src/audio_capture_interface_impl.cpp +++ b/hdf_service/distributed_audio/hdi_service/audio/v1_0/src/audio_capture_interface_impl.cpp @@ -36,8 +36,7 @@ namespace Audio { namespace V1_0 { AudioCaptureInterfaceImpl::AudioCaptureInterfaceImpl(const std::string &adpName, const AudioDeviceDescriptor &desc, const AudioSampleAttributes &attrs, const sptr &callback) - : adapterName_(adpName), devDesc_(desc), - devAttrs_(attrs), audioExtCallback_(callback) + : adapterName_(adpName), devDesc_(desc), devAttrs_(attrs), audioExtCallback_(callback) { devAttrs_.frameSize = CalculateFrameSize(attrs.sampleRate, attrs.channelCount, attrs.format, timeInterval_, false); const int32_t sizePerSec = static_cast(attrs.sampleRate * attrs.channelCount) *attrs.format; diff --git a/hdf_service/distributed_audio/hdi_service/audio/v1_0/src/audio_manager_interface_impl.cpp b/hdf_service/distributed_audio/hdi_service/audio/v1_0/src/audio_manager_interface_impl.cpp index bbfc489feac53e3d0a3c5a6f4c760fbefae033db..89be6577810e97545a5f0d209b71537bad54fe88 100644 --- a/hdf_service/distributed_audio/hdi_service/audio/v1_0/src/audio_manager_interface_impl.cpp +++ b/hdf_service/distributed_audio/hdi_service/audio/v1_0/src/audio_manager_interface_impl.cpp @@ -131,10 +131,10 @@ int32_t AudioManagerInterfaceImpl::AddAudioDevice(const std::string &adpName, co } switch (GetDevTypeByDHId(dhId)) { case AUDIO_DEVICE_TYPE_SPEAKER: - adp->second->SetSpeakerCallback(callback); + adp->second->SetSpeakerCallback(dhId, callback); break; case AUDIO_DEVICE_TYPE_MIC: - adp->second->SetMicCallback(callback); + adp->second->SetMicCallback(dhId, callback); break; case AUDIO_DEVICE_TYPE_UNKNOWN: default: diff --git a/hdf_service/distributed_audio/hdi_service/audio/v1_0/src/audio_render_interface_impl.cpp b/hdf_service/distributed_audio/hdi_service/audio/v1_0/src/audio_render_interface_impl.cpp index cb4c219f21bf280dfb1a9e8a1763af760ad4c0ac..d80ef34df7fcdec730be8c35c171a3b43db017a3 100644 --- a/hdf_service/distributed_audio/hdi_service/audio/v1_0/src/audio_render_interface_impl.cpp +++ b/hdf_service/distributed_audio/hdi_service/audio/v1_0/src/audio_render_interface_impl.cpp @@ -19,6 +19,7 @@ #include #include "sys/time.h" +#include "cJSON.h" #include "daudio_constants.h" #include "daudio_events.h" #include "daudio_log.h" @@ -192,7 +193,20 @@ int32_t AudioRenderInterfaceImpl::Start() if (firstOpenFlag_) { firstOpenFlag_ = false; } else { - DAudioEvent event = { HDF_AUDIO_EVENT_CHANGE_PLAY_STATUS, HDF_EVENT_RESTART }; + cJSON *jParam = cJSON_CreateObject(); + if (jParam == nullptr) { + DHLOGE("Failed to create cJSON object."); + return HDF_FAILURE; + } + cJSON_AddStringToObject(jParam, KEY_DH_ID, std::to_string(devDesc_.pins).c_str()); + cJSON_AddStringToObject(jParam, "ChangeType", HDF_EVENT_RESTART.c_str()); + char *jsonData = cJSON_PrintUnformatted(jParam); // TODO: 注意内存泄漏 + if (jsonData == nullptr) { + DHLOGE("Failed to create JSON data."); + return HDF_FAILURE; + } + std::string content(jsonData); + DAudioEvent event = { HDF_AUDIO_EVENT_CHANGE_PLAY_STATUS, content}; int32_t ret = audioExtCallback_->NotifyEvent(adapterName_, devDesc_.pins, event); if (ret != HDF_SUCCESS) { DHLOGE("Restart failed."); @@ -208,7 +222,20 @@ int32_t AudioRenderInterfaceImpl::Start() int32_t AudioRenderInterfaceImpl::Stop() { DHLOGI("Stop render."); - DAudioEvent event = { HDF_AUDIO_EVENT_CHANGE_PLAY_STATUS, HDF_EVENT_PAUSE }; + cJSON *jParam = cJSON_CreateObject(); + if (jParam == nullptr) { + DHLOGE("Failed to create cJSON object."); + return HDF_FAILURE; + } + cJSON_AddStringToObject(jParam, KEY_DH_ID, std::to_string(devDesc_.pins).c_str()); + cJSON_AddStringToObject(jParam, "ChangeType", HDF_EVENT_RESTART.c_str()); + char *jsonData = cJSON_PrintUnformatted(jParam); + if (jsonData == nullptr) { + DHLOGE("Failed to create JSON data."); + return HDF_FAILURE; + } + std::string content(jsonData); + DAudioEvent event = { HDF_AUDIO_EVENT_CHANGE_PLAY_STATUS, content}; int32_t ret = audioExtCallback_->NotifyEvent(adapterName_, devDesc_.pins, event); if (ret != HDF_SUCCESS) { DHLOGE("Pause and clear cache streams failed."); diff --git a/hdf_service/distributed_audio/hdi_service/common/include/daudio_constants.h b/hdf_service/distributed_audio/hdi_service/common/include/daudio_constants.h index 4a669ed7a5940528289b7e2da480b36f0c3242b2..5070ec53411c94ec80e5da9f122e0a0384d15a08 100644 --- a/hdf_service/distributed_audio/hdi_service/common/include/daudio_constants.h +++ b/hdf_service/distributed_audio/hdi_service/common/include/daudio_constants.h @@ -74,6 +74,8 @@ constexpr uint32_t AUDIO_DEFAULT_MIN_VOLUME_LEVEL = 0; constexpr int32_t DAUDIO_MAX_ASHMEM_LEN = 100000; constexpr int32_t DAUDIO_MIN_ASHMEM_LEN = 10; + +constexpr const char *KEY_DH_ID = "dhId"; } // DistributeHardware } // OHOS #endif // OHOS_DAUDIO_CONSTANTS_H diff --git a/services/audioclient/spkclient/include/dspeaker_client.h b/services/audioclient/spkclient/include/dspeaker_client.h index f38be3cb6f612a34f34ecee85347bc8c4f47b9ee..b583a158ac255aa4496d02e2eff3f8d49272d448 100644 --- a/services/audioclient/spkclient/include/dspeaker_client.h +++ b/services/audioclient/spkclient/include/dspeaker_client.h @@ -52,8 +52,8 @@ class DSpeakerClient : public IAudioDataTransCallback, public AudioStandard::AudioRendererWriteCallback, public std::enable_shared_from_this { public: - DSpeakerClient(const std::string &devId, const std::shared_ptr &callback) - : devId_(devId), eventCallback_(callback) {}; + DSpeakerClient(const std::string &devId, const int32_t &dhId, const std::shared_ptr &callback) + : devId_(devId), dhId_(dhId), eventCallback_(callback) {}; ~DSpeakerClient() override; int32_t OnStateChange(const AudioEventType type) override; @@ -96,6 +96,7 @@ private: const std::string FILE_NAME = "/data/sink_spk_recv.pcm"; std::string devId_; + const int32_t dhId_; std::thread renderDataThread_; AudioParam audioParam_; std::atomic isRenderReady_ = false; diff --git a/services/audioclient/spkclient/src/dspeaker_client.cpp b/services/audioclient/spkclient/src/dspeaker_client.cpp index ee90de6af78675a430b8ee8f552206cce2f17911..1f85794d77499654a0ac12e2dfaa241bbeb5d008 100644 --- a/services/audioclient/spkclient/src/dspeaker_client.cpp +++ b/services/audioclient/spkclient/src/dspeaker_client.cpp @@ -15,6 +15,8 @@ #include "dspeaker_client.h" +#include "cJSON.h" + #include "daudio_constants.h" #include "daudio_hisysevent.h" #include "daudio_sink_hidumper.h" @@ -398,20 +400,30 @@ int32_t DSpeakerClient::OnStateChange(const AudioEventType type) string DSpeakerClient::GetVolumeLevel() { DHLOGD("Get the volume level."); - std::stringstream ss; AudioStandard::AudioStreamType streamType = AudioStandard::AudioStreamType::STREAM_DEFAULT; auto volumeType = static_cast(1); int32_t volumeLevel = AudioStandard::AudioSystemManager::GetInstance()->GetVolume(volumeType); int32_t maxVolumeLevel = AudioStandard::AudioSystemManager::GetInstance()->GetMaxVolume(volumeType); int32_t minVolumeLevel = AudioStandard::AudioSystemManager::GetInstance()->GetMinVolume(volumeType); bool isUpdateUi = false; - ss << "FIRST_VOLUME_CHANAGE;" - << "AUDIO_STREAM_TYPE=" << streamType << ";" - << "VOLUME_LEVEL=" << volumeLevel << ";" - << "IS_UPDATEUI=" << isUpdateUi << ";" - << "MAX_VOLUME_LEVEL=" << maxVolumeLevel << ";" - << "MIN_VOLUME_LEVEL=" << minVolumeLevel << ";"; - std::string str = ss.str(); + cJSON *jParam = cJSON_CreateObject(); + if (jParam == nullptr) { + DHLOGE("Failed to create cJSON object."); + return ""; + } + cJSON_AddStringToObject(jParam, KEY_DH_ID, std::to_string(dhId_).c_str()); + cJSON_AddStringToObject(jParam, "ChangeType", "FIRST_VOLUME_CHANAGE"); + cJSON_AddStringToObject(jParam, "AUDIO_STREAM_TYPE", std::to_string(streamType).c_str()); + cJSON_AddStringToObject(jParam, "VOLUME_LEVEL", std::to_string(volumeLevel).c_str()); + cJSON_AddStringToObject(jParam, "IS_UPDATEUI", std::to_string(isUpdateUi).c_str()); + cJSON_AddStringToObject(jParam, "MAX_VOLUME_LEVEL", std::to_string(maxVolumeLevel).c_str()); + cJSON_AddStringToObject(jParam, "MIN_VOLUME_LEVEL", std::to_string(minVolumeLevel).c_str()); + char *jsonData = cJSON_PrintUnformatted(jParam); // TODO: 注意内存泄漏 + if (jsonData == nullptr) { + DHLOGE("Failed to create JSON data."); + return ""; + } + std::string str(jsonData); DHLOGD("Get the volume level result, event: %s.", str.c_str()); return str; } @@ -424,13 +436,23 @@ void DSpeakerClient::OnVolumeKeyEvent(AudioStandard::VolumeEvent volumeEvent) DHLOGE("Event callback is nullptr."); return; } - std::stringstream ss; - ss << "VOLUME_CHANAGE;" - << "AUDIO_STREAM_TYPE=" << volumeEvent.volumeType << ";" - << "VOLUME_LEVEL=" << volumeEvent.volume << ";" - << "IS_UPDATEUI=" << volumeEvent.updateUi << ";" - << "VOLUME_GROUP_ID=" << volumeEvent.volumeGroupId << ";"; - std::string str = ss.str(); + cJSON *jParam = cJSON_CreateObject(); + if (jParam == nullptr) { + DHLOGE("Failed to create cJSON object."); + return; + } + cJSON_AddStringToObject(jParam, KEY_DH_ID, std::to_string(dhId_).c_str()); + cJSON_AddStringToObject(jParam, "ChangeType", "VOLUME_CHANAGE"); + cJSON_AddStringToObject(jParam, "AUDIO_STREAM_TYPE", std::to_string(volumeEvent.volumeType).c_str()); + cJSON_AddStringToObject(jParam, "VOLUME_LEVEL", std::to_string(volumeEvent.volume).c_str()); + cJSON_AddStringToObject(jParam, "IS_UPDATEUI", std::to_string(volumeEvent.updateUi).c_str()); + cJSON_AddStringToObject(jParam, "VOLUME_GROUP_ID", std::to_string(volumeEvent.volumeGroupId).c_str()); + char *jsonData = cJSON_PrintUnformatted(jParam); // TODO: 注意内存泄漏 + if (jsonData == nullptr) { + DHLOGE("Failed to create JSON data."); + return; + } + std::string str(jsonData); DHLOGD("Volume change notification result, event: %s.", str.c_str()); AudioEvent audioEvent(VOLUME_CHANGE, str); @@ -445,12 +467,22 @@ void DSpeakerClient::OnInterrupt(const AudioStandard::InterruptEvent &interruptE DHLOGE("Event callback is nullptr."); return; } - std::stringstream ss; - ss << "INTERRUPT_EVENT;" - << "EVENT_TYPE=" << interruptEvent.eventType << ";" - << "FORCE_TYPE=" << interruptEvent.forceType << ";" - << "HINT_TYPE=" << interruptEvent.hintType << ";"; - std::string str = ss.str(); + cJSON *jParam = cJSON_CreateObject(); + if (jParam == nullptr) { + DHLOGE("Failed to create cJSON object."); + return; + } + cJSON_AddStringToObject(jParam, KEY_DH_ID, std::to_string(dhId_).c_str()); + cJSON_AddStringToObject(jParam, "ChangeType", "INTERRUPT_EVENT"); + cJSON_AddStringToObject(jParam, "EVENT_TYPE", std::to_string(interruptEvent.eventType).c_str()); + cJSON_AddStringToObject(jParam, "FORCE_TYPE", std::to_string(interruptEvent.forceType).c_str()); + cJSON_AddStringToObject(jParam, "HINT_TYPE", std::to_string(interruptEvent.hintType).c_str()); + char *jsonData = cJSON_PrintUnformatted(jParam); // TODO: 注意内存泄漏 + if (jsonData == nullptr) { + DHLOGE("Failed to create JSON data."); + return; + } + std::string str(jsonData); DHLOGD("Audio focus oninterrupt notification result, event: %s.", str.c_str()); AudioEvent audioEvent(AUDIO_FOCUS_CHANGE, str); @@ -466,10 +498,20 @@ void DSpeakerClient::OnStateChange(const AudioStandard::RendererState state, DHLOGE("Event callback is nullptr."); return; } - std::stringstream ss; - ss << "RENDER_STATE_CHANGE_EVENT;" - << "STATE=" << state << ";"; - std::string str = ss.str(); + cJSON *jParam = cJSON_CreateObject(); + if (jParam == nullptr) { + DHLOGE("Failed to create cJSON object."); + return; + } + cJSON_AddStringToObject(jParam, KEY_DH_ID, std::to_string(dhId_).c_str()); + cJSON_AddStringToObject(jParam, "ChangeType", "RENDER_STATE_CHANGE_EVENT"); + cJSON_AddStringToObject(jParam, "STATE", std::to_string(state).c_str()); + char *jsonData = cJSON_PrintUnformatted(jParam); // TODO: 注意内存泄漏 + if (jsonData == nullptr) { + DHLOGE("Failed to create JSON data."); + return; + } + std::string str(jsonData); DHLOGD("Audio render state changes notification result, event: %s.", str.c_str()); AudioEvent audioEvent(AUDIO_RENDER_STATE_CHANGE, str); @@ -481,7 +523,7 @@ int32_t DSpeakerClient::SetAudioParameters(const AudioEvent &event) DHLOGD("Set the volume, arg: %s.", event.content.c_str()); int32_t audioVolumeType; - int32_t ret = GetAudioParamInt(event.content, AUDIO_VOLUME_TYPE, audioVolumeType); + int32_t ret = GetAudioParamInt(event.content, AUDIO_VOLUME_TYPE, audioVolumeType); // TODO:reserve if (ret != DH_SUCCESS) { DHLOGE("Get audio volume type failed."); return ret; diff --git a/services/audiohdiproxy/src/daudio_hdi_handler.cpp b/services/audiohdiproxy/src/daudio_hdi_handler.cpp index ba5f08d9845e8850e3f5f7aa003f25376ed30e0e..9ad134dd13301fbd8a32805ff112bc92f9f07ce2 100644 --- a/services/audiohdiproxy/src/daudio_hdi_handler.cpp +++ b/services/audiohdiproxy/src/daudio_hdi_handler.cpp @@ -96,10 +96,10 @@ int32_t DAudioHdiHandler::RegisterAudioDevice(const std::string &devId, const in std::string searchKey; switch (GetDevTypeByDHId(dhId)) { case AUDIO_DEVICE_TYPE_SPEAKER: - searchKey = devId + "Speaker"; + searchKey = devId + "Speaker" + std::to_string(dhId); break; case AUDIO_DEVICE_TYPE_MIC: - searchKey = devId + "Mic"; + searchKey = devId + "Mic" + std::to_string(dhId); break; case AUDIO_DEVICE_TYPE_UNKNOWN: default: diff --git a/services/audiomanager/managersink/include/daudio_sink_dev.h b/services/audiomanager/managersink/include/daudio_sink_dev.h index cdbe97aa66cf0f3df5e477161a425994c4c35830..aeb34c55c866d83f71409f4cd7eff40920b4b8f5 100644 --- a/services/audiomanager/managersink/include/daudio_sink_dev.h +++ b/services/audiomanager/managersink/include/daudio_sink_dev.h @@ -21,8 +21,8 @@ #include #include -#include "event_handler.h" #include "cJSON.h" +#include "event_handler.h" #include "daudio_sink_dev_ctrl_manager.h" #include "dmic_client.h" @@ -61,7 +61,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 TaskStartRender(const std::string &args); int32_t TaskOpenDMic(const std::string &args); int32_t TaskCloseDMic(const std::string &args); int32_t TaskSetParameter(const std::string &args); @@ -80,6 +80,7 @@ private: int32_t GetCJsonObjectItems(const cJSON *jsonObj, AudioParam &audioParam); int32_t GetParamValue(const cJSON *jsonObj, const char* key, int32_t& value); + int32_t ParseDhidFromEvent(std::string args); private: std::mutex rpcWaitMutex_; @@ -88,6 +89,7 @@ private: std::string spkDhId_; std::string micDhId_; std::shared_ptr speakerClient_ = nullptr; + std::map> spkClientMap_; std::shared_ptr micClient_ = nullptr; std::shared_ptr audioCtrlMgr_ = nullptr; diff --git a/services/audiomanager/managersink/src/daudio_sink_dev.cpp b/services/audiomanager/managersink/src/daudio_sink_dev.cpp index 908b945fa7a71abc07d45bf54a5729eb6d7de1e1..77e72769c482b92107bd843d736dd06faa49c9c1 100644 --- a/services/audiomanager/managersink/src/daudio_sink_dev.cpp +++ b/services/audiomanager/managersink/src/daudio_sink_dev.cpp @@ -29,6 +29,9 @@ #define DH_LOG_TAG "DAudioSinkDev" namespace OHOS { +static constexpr int32_t LOW_LATENCY_RENDER_ID = 3; +static constexpr int32_t DEFAULT_RENDER_ID = 1; + namespace DistributedHardware { DAudioSinkDev::DAudioSinkDev(const std::string &devId) : devId_(devId) { @@ -76,8 +79,12 @@ int32_t DAudioSinkDev::InitAVTransEngines(const ChannelState channelState, IAVEn } if (channelState == ChannelState::SPK_CONTROL_OPENED) { - speakerClient_ = std::make_shared(devId_, shared_from_this()); - speakerClient_->InitReceiverEngine(providerPtr); + spkClientMap_[DEFAULT_RENDER_ID] = + std::make_shared(devId_, DEFAULT_RENDER_ID, shared_from_this()); + spkClientMap_[DEFAULT_RENDER_ID]->InitReceiverEngine(providerPtr); + spkClientMap_[LOW_LATENCY_RENDER_ID] = + std::make_shared(devId_, LOW_LATENCY_RENDER_ID, shared_from_this()); + spkClientMap_[DEFAULT_RENDER_ID]->InitReceiverEngine(providerPtr); } return DH_SUCCESS; } @@ -128,7 +135,8 @@ int32_t DAudioSinkDev::TaskOpenDSpeaker(const std::string &args) DHLOGE("Not found the keys."); return ERR_DH_AUDIO_FAILED; } - spkDhId_ = std::string(cJSON_GetObjectItemCaseSensitive(jParam, KEY_DH_ID)->valuestring); + int32_t dhId = cJSON_GetObjectItemCaseSensitive(jParam, KEY_DH_ID)->valueint; + auto speakerClient = spkClientMap_[dhId]; cJSON *audioParamJson = cJSON_GetObjectItemCaseSensitive(jParam, KEY_AUDIO_PARAM); AudioParam audioParam; int32_t ret = from_json(audioParamJson, audioParam); @@ -138,20 +146,20 @@ int32_t DAudioSinkDev::TaskOpenDSpeaker(const std::string &args) return ret; } - if (speakerClient_ == nullptr) { + if (speakerClient == nullptr) { DHLOGE("speaker client should be init by dev."); cJSON_Delete(jParam); return ERR_DH_AUDIO_NULLPTR; } - ret = speakerClient_->SetUp(audioParam); + ret = speakerClient->SetUp(audioParam); if (ret != DH_SUCCESS) { DHLOGE("Setup speaker failed, ret: %d.", ret); NotifySourceDev(NOTIFY_OPEN_SPEAKER_RESULT, spkDhId_, ERR_DH_AUDIO_FAILED); cJSON_Delete(jParam); return ERR_DH_AUDIO_FAILED; } - NotifySourceDev(NOTIFY_OPEN_SPEAKER_RESULT, spkDhId_, ret); + NotifySourceDev(NOTIFY_OPEN_SPEAKER_RESULT, std::to_string(dhId), ret); cJSON_Delete(jParam); DHLOGI("Open speaker device task end, notify source ret %d.", ret); @@ -161,35 +169,62 @@ int32_t DAudioSinkDev::TaskOpenDSpeaker(const std::string &args) int32_t DAudioSinkDev::TaskCloseDSpeaker(const std::string &args) { - (void)args; DHLOGI("Close speaker device."); - if (speakerClient_ == nullptr) { + int32_t dhId = ParseDhidFromEvent(args); + if (dhId < 0) { + DHLOGE("Failed to parse dhardware id."); + return ERR_DH_AUDIO_FAILED; + } + auto speakerClient = spkClientMap_[dhId]; + if (speakerClient == nullptr) { DHLOGE("Speaker client is null or already closed."); return DH_SUCCESS; } - int32_t ret = speakerClient_->StopRender(); + int32_t ret = speakerClient->StopRender(); if (ret != DH_SUCCESS) { DHLOGE("Stop speaker client failed, ret: %d.", ret); } - ret = speakerClient_->Release(); + ret = speakerClient->Release(); if (ret != DH_SUCCESS) { DHLOGE("Release speaker client failed, ret: %d.", ret); } - speakerClient_ = nullptr; + spkClientMap_.erase(dhId); isSpkInUse_.store(false); JudgeDeviceStatus(); DHLOGI("Close speaker device task excute success."); return DH_SUCCESS; } -int32_t DAudioSinkDev::TaskStartRender() +int32_t DAudioSinkDev::ParseDhidFromEvent(std::string args) +{ + cJSON *jParam = cJSON_Parse(args.c_str()); + if (jParam == nullptr) { + DHLOGE("Failed to parse JSON: %s", cJSON_GetErrorPtr()); + cJSON_Delete(jParam); + return -1; + } + if (!JsonParamCheck(jParam, { KEY_DH_ID })) { + DHLOGE("Not found the keys of dhId."); + cJSON_Delete(jParam); + return -1; + } + return cJSON_GetObjectItem(jParam, KEY_DH_ID)->valueint; +} + +int32_t DAudioSinkDev::TaskStartRender(const std::string &args) { - if (speakerClient_ == nullptr) { + int32_t dhId = ParseDhidFromEvent(args); + if (dhId < 0) { + DHLOGE("Failed to parse dhardware id."); + return ERR_DH_AUDIO_FAILED; + } + auto speakerClient = spkClientMap_[dhId]; + if (speakerClient == nullptr) { DHLOGE("Speaker client is null."); return ERR_DH_AUDIO_NULLPTR; } - int32_t ret = speakerClient_->StartRender(); + int32_t ret = speakerClient->StartRender(); if (ret != DH_SUCCESS) { DHLOGE("Start render failed. ret: %d.", ret); return ret; @@ -281,22 +316,33 @@ int32_t DAudioSinkDev::TaskSetParameter(const std::string &args) { DHLOGD("Set audio param."); AudioEvent event(AudioEventType::EVENT_UNKNOWN, args); - - if (speakerClient_ == nullptr) { + int32_t dhId = ParseDhidFromEvent(args); + if (dhId < 0) { + DHLOGE("Failed to parse dhardware id."); + return ERR_DH_AUDIO_FAILED; + } + auto speakerClient = spkClientMap_[dhId]; + if (speakerClient == nullptr) { return ERR_DH_AUDIO_SA_SPEAKER_CLIENT_NOT_INIT; } - return speakerClient_->SetAudioParameters(event); + return speakerClient->SetAudioParameters(event); } int32_t DAudioSinkDev::TaskSetVolume(const std::string &args) { DHLOGD("Set audio volume."); - if (speakerClient_ == nullptr) { + int32_t dhId = 0; + if (GetAudioParamInt(args, "dhId", dhId) != DH_SUCCESS) { + DHLOGE("Get key of dhId failed."); + return ERR_DH_AUDIO_FAILED; + } + auto speakerClient = spkClientMap_[dhId]; // TODO: spkClientMap_锁的问题 + if (speakerClient == nullptr) { DHLOGE("Speaker client already closed."); return ERR_DH_AUDIO_NULLPTR; } AudioEvent event(AudioEventType::VOLUME_SET, args); - int32_t ret = speakerClient_->SetAudioParameters(event); + int32_t ret = speakerClient->SetAudioParameters(event); if (ret != DH_SUCCESS) { DHLOGE("Volume set failed, ret: %d.", ret); return ret; @@ -308,12 +354,18 @@ int32_t DAudioSinkDev::TaskSetVolume(const std::string &args) int32_t DAudioSinkDev::TaskSetMute(const std::string &args) { DHLOGD("Set audio mute."); - if (speakerClient_ == nullptr) { + int dhId = 0; + if (GetAudioParamInt(args, "dhId", dhId) != DH_SUCCESS) { + DHLOGE("Get key of dhId failed."); + return ERR_DH_AUDIO_FAILED; + } + auto speakerClient = spkClientMap_[dhId]; + if (speakerClient == nullptr) { DHLOGE("Speaker client already closed."); return ERR_DH_AUDIO_NULLPTR; } AudioEvent event(AudioEventType::VOLUME_MUTE_SET, args); - int32_t ret = speakerClient_->SetMute(event); + int32_t ret = speakerClient->SetMute(event); if (ret != DH_SUCCESS) { DHLOGE("Set mute failed, ret: %d.", ret); return ret; @@ -346,11 +398,17 @@ int32_t DAudioSinkDev::TaskRenderStateChange(const std::string &args) int32_t DAudioSinkDev::TaskPlayStatusChange(const std::string &args) { DHLOGD("Play status change, content: %s.", args.c_str()); - if (speakerClient_ == nullptr) { + int32_t dhId = ParseDhidFromEvent(args); + if (dhId < 0) { + DHLOGE("Failed to parse dhardware id."); + return ERR_DH_AUDIO_FAILED; + } + auto speakerClient = spkClientMap_[dhId]; + if (speakerClient == nullptr) { DHLOGE("Speaker client already closed."); return ERR_DH_AUDIO_NULLPTR; } - speakerClient_->PlayStatusChange(args); + speakerClient->PlayStatusChange(args); DHLOGD("Play status change success."); return DH_SUCCESS; } @@ -359,11 +417,17 @@ int32_t DAudioSinkDev::SendAudioEventToRemote(const AudioEvent &event) { // because: type: VOLUME_CHANGE / AUDIO_FOCUS_CHANGE / AUDIO_RENDER_STATE_CHANGE // so speakerClient - if (speakerClient_ == nullptr) { + int32_t dhId = ParseDhidFromEvent(event.content); + if (dhId < 0) { + DHLOGE("Failed to parse dhardware id."); + return ERR_DH_AUDIO_FAILED; + } + auto speakerClient = spkClientMap_[dhId]; + if (speakerClient == nullptr) { DHLOGE("Audio ctrl mgr not init."); return ERR_DH_AUDIO_NULLPTR; } - int32_t ret = speakerClient_->SendMessage(static_cast(event.type), + int32_t ret = speakerClient->SendMessage(static_cast(event.type), event.content, devId_); if (ret != DH_SUCCESS) { DHLOGE("Task send message to remote failed."); @@ -412,8 +476,9 @@ void DAudioSinkDev::NotifySourceDev(const AudioEventType type, const std::string } std::string messageStr(message); - if (speakerClient_ != nullptr) { - speakerClient_->SendMessage(static_cast(type), messageStr, devId_); + auto speakerClient = spkClientMap_[stoi(dhId)]; + if (speakerClient != nullptr) { + speakerClient->SendMessage(static_cast(type), messageStr, devId_); } if (micClient_ != nullptr) { micClient_->SendMessage(static_cast(type), messageStr, devId_); @@ -658,7 +723,7 @@ void DAudioSinkDev::SinkEventHandler::NotifySpeakerOpened(const AppExecFwk::Inne DHLOGE("Sink dev is invalid."); return; } - if (sinkDevObj->TaskStartRender() != DH_SUCCESS) { + if (sinkDevObj->TaskStartRender(eventParam) != DH_SUCCESS) { DHLOGE("Speaker client start failed."); return; } diff --git a/services/audiomanager/managersource/include/daudio_io_dev.h b/services/audiomanager/managersource/include/daudio_io_dev.h new file mode 100644 index 0000000000000000000000000000000000000000..cce9946120ab6ba9aa141ef8fb4b8233c6ccfcdf --- /dev/null +++ b/services/audiomanager/managersource/include/daudio_io_dev.h @@ -0,0 +1,73 @@ +/* + * Copyright (c) 2022-2023 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef OHOS_DAUDIO_IO_DEV_H +#define OHOS_DAUDIO_IO_DEV_H + +#include +#include +#include +#include "cJSON.h" + +#include "audio_param.h" +#include "audio_status.h" +#include "av_receiver_engine_transport.h" +#include "ashmem.h" +#include "daudio_hdi_handler.h" +#include "iaudio_data_transport.h" +#include "iaudio_datatrans_callback.h" +#include "iaudio_event_callback.h" +#include "idaudio_hdi_callback.h" + +namespace OHOS { +namespace DistributedHardware { + +class DAudioIoDev : public IDAudioHdiCallback { +public: + DAudioIoDev(const std::string &devId) + : devId_(devId) {}; + ~DAudioIoDev() override = default; + virtual int32_t InitReceiverEngine(IAVEngineProvider *providerPtr) = 0; + virtual int32_t InitSenderEngine(IAVEngineProvider *providerPtr) = 0; + + virtual int32_t EnableDevice(const int32_t dhId, const std::string &capability) = 0; + virtual int32_t DisableDevice(const int32_t dhId) = 0; + + virtual int32_t MmapStart() = 0; + virtual int32_t MmapStop() = 0; + + virtual int32_t SetUp() = 0; + virtual int32_t Start() = 0; + virtual int32_t Pause() = 0; + virtual int32_t Restart() = 0; + virtual int32_t Stop() = 0; + virtual int32_t Release() = 0; + virtual bool IsOpened() = 0; + virtual int32_t SendMessage(uint32_t type, std::string content, std::string dstDevId) = 0; + + virtual AudioParam GetAudioParam() const = 0; + virtual int32_t NotifyHdfAudioEvent(const AudioEvent &event, const int32_t portId) = 0; + +private: + // int32_t EnableDevice(const int32_t dhId, const std::string &capability); + // int32_t DisableDevice(const int32_t dhId); + +protected: + const std::string devId_; + // TODO: 待添加标识device是否为低时延的member variable +}; +} // DistributedHardware +} // OHOS +#endif // OHOS_DAUDIO_IO_DEV_H \ No newline at end of file diff --git a/services/audiomanager/managersource/include/daudio_source_dev.h b/services/audiomanager/managersource/include/daudio_source_dev.h index 1be525e16a2c7ab737a9491879e2d399d3804a9d..2dd91f44ad3ab67b5845c9e0ab6f1ab09fbfc51e 100644 --- a/services/audiomanager/managersource/include/daudio_source_dev.h +++ b/services/audiomanager/managersource/include/daudio_source_dev.h @@ -16,13 +16,15 @@ #ifndef OHOS_DAUDIO_SOURCE_DEV_H #define OHOS_DAUDIO_SOURCE_DEV_H +#include #include #include -#include "cJSON.h" +#include "cJSON.h" #include "event_handler.h" #include "audio_event.h" +#include "daudio_io_dev.h" #include "daudio_source_dev_ctrl_manager.h" #include "daudio_source_mgr_callback.h" #include "dmic_dev.h" @@ -59,7 +61,7 @@ private: int32_t TaskOpenCtrlChannel(const std::string &args); int32_t TaskCloseCtrlChannel(const std::string &args); int32_t TaskOpenDSpeaker(const std::string &args); - int32_t OpenDSpeakerInner(); + int32_t OpenDSpeakerInner(std::shared_ptr &speaker, const int32_t dhId); int32_t TaskCloseDSpeaker(const std::string &args); int32_t TaskOpenDMic(const std::string &args); int32_t TaskCloseDMic(const std::string &args); @@ -105,7 +107,7 @@ private: int32_t HandleMicMmapStop(const AudioEvent &event); int32_t NotifySinkDev(const AudioEventType type, const cJSON *param, const std::string dhId); - int32_t NotifyHDF(const AudioEventType type, const std::string result); + int32_t NotifyHDF(const AudioEventType type, const std::string result, const int32_t dhId); int32_t OpenCtrlTrans(const AudioEvent &event); int32_t CloseCtrlTrans(const AudioEvent &event, bool isSpk); AudioEventType getEventTypeFromArgs(const std::string &args); @@ -115,6 +117,8 @@ private: int32_t CloseSpkNew(const std::string &args); int32_t CloseMicOld(const std::string &args); int32_t CloseMicNew(const std::string &args); + std::shared_ptr FindIoDevImpl(std::string args); + int32_t ParseDhidFromEvent(std::string args); private: static constexpr uint8_t RPC_WAIT_SECONDS = 10; @@ -128,8 +132,12 @@ private: std::string devId_; std::shared_ptr mgrCallback_; - std::shared_ptr speaker_; - std::shared_ptr mic_; + std::mutex ioDevMtx_; + std::map> deviceMap_; + // std::shared_ptr speaker_; + std::shared_ptr speaker_; + // std::shared_ptr mic_; + std::shared_ptr mic_; std::shared_ptr audioCtrlMgr_; std::mutex rpcWaitMutex_; diff --git a/services/audiomanager/managersource/include/dmic_dev.h b/services/audiomanager/managersource/include/dmic_dev.h index 751f91ca14c133ecbccee9fd1e83fb703c3b8f42..72becf2c347b0e570a584bb43bd8869251dbfc8c 100644 --- a/services/audiomanager/managersource/include/dmic_dev.h +++ b/services/audiomanager/managersource/include/dmic_dev.h @@ -26,6 +26,7 @@ #include "av_receiver_engine_transport.h" #include "ashmem.h" #include "daudio_hdi_handler.h" +#include "daudio_io_dev.h" #include "iaudio_data_transport.h" #include "iaudio_datatrans_callback.h" #include "iaudio_event_callback.h" @@ -33,23 +34,31 @@ namespace OHOS { namespace DistributedHardware { -class DMicDev : public IDAudioHdiCallback, +class DMicDev : public DAudioIoDev, public IAudioDataTransCallback, public AVReceiverTransportCallback, public std::enable_shared_from_this { public: DMicDev(const std::string &devId, std::shared_ptr callback) - : devId_(devId), audioEventCallback_(callback) {}; + : DAudioIoDev(devId), audioEventCallback_(callback) {}; ~DMicDev() override = default; + // recv transport callback void OnEngineTransEvent(const AVTransEvent &event) override; void OnEngineTransMessage(const std::shared_ptr &message) override; void OnEngineTransDataAvailable(const std::shared_ptr &audioData) override; - int32_t InitReceiverEngine(IAVEngineProvider *providerPtr); - int32_t EnableDMic(const int32_t dhId, const std::string &capability); - int32_t DisableDMic(const int32_t dhId); + // override + int32_t InitReceiverEngine(IAVEngineProvider *providerPtr) override; + int32_t InitSenderEngine(IAVEngineProvider *providerPtr) override; + int32_t EnableDevice(const int32_t dhId, const std::string &capability) override; + int32_t DisableDevice(const int32_t dhId) override; + + // int32_t EnableDMic(const int32_t dhId, const std::string &capability); + // int32_t DisableDMic(const int32_t dhId); + + // IDAudioHdiCallback int32_t OpenDevice(const std::string &devId, const int32_t dhId) override; int32_t CloseDevice(const std::string &devId, const int32_t dhId) override; int32_t SetParameters(const std::string &devId, const int32_t dhId, const AudioParamHDF ¶m) override; @@ -60,24 +69,30 @@ public: uint64_t &frames, CurrentTimeHDF &time) override; int32_t RefreshAshmemInfo(const std::string &devId, const int32_t dhId, int32_t fd, int32_t ashmemLength, int32_t lengthPerTrans) override; - int32_t MmapStart(); - int32_t MmapStop(); - - int32_t SetUp(); - int32_t Start(); - int32_t Stop(); - int32_t Release(); - bool IsOpened(); - int32_t SendMessage(uint32_t type, std::string content, std::string dstDevId); - - AudioParam GetAudioParam() const; - int32_t NotifyHdfAudioEvent(const AudioEvent &event); + + // override + int32_t MmapStart() override; + int32_t MmapStop() override; + + int32_t SetUp() override; + int32_t Start() override; + int32_t Pause() override; + int32_t Restart() override; + int32_t Stop() override; + int32_t Release() override; + bool IsOpened() override; + int32_t SendMessage(uint32_t type, std::string content, std::string dstDevId) override; + + AudioParam GetAudioParam() const override; + int32_t NotifyHdfAudioEvent(const AudioEvent &event, const int32_t portId) override; + + // IDataTransCallback int32_t OnStateChange(const AudioEventType type) override; int32_t OnDecodeTransDataDone(const std::shared_ptr &audioData) override; private: - int32_t EnableDevice(const int32_t dhId, const std::string &capability); - int32_t DisableDevice(const int32_t dhId); + // int32_t EnableDevice(const int32_t dhId, const std::string &capability); + // int32_t DisableDevice(const int32_t dhId); void EnqueueThread(); void FillJitterQueue(); @@ -91,7 +106,7 @@ private: static constexpr const char* ENQUEUE_THREAD = "micEnqueueTh"; const std::string FILE_NAME = "/data/source_mic_read.pcm"; - std::string devId_; + // std::string devId_; std::weak_ptr audioEventCallback_; std::mutex dataQueueMtx_; std::mutex channelWaitMutex_; diff --git a/services/audiomanager/managersource/include/dspeaker_dev.h b/services/audiomanager/managersource/include/dspeaker_dev.h index 397a15fb7d7d2ba4b5577ff25bc85f13b614bdad..9f860b4d08df9d7ccd34156a07de8272ed84685d 100644 --- a/services/audiomanager/managersource/include/dspeaker_dev.h +++ b/services/audiomanager/managersource/include/dspeaker_dev.h @@ -25,6 +25,7 @@ #include "ashmem.h" #include "av_sender_engine_transport.h" #include "daudio_hdi_handler.h" +#include "daudio_io_dev.h" #include "iaudio_event_callback.h" #include "iaudio_data_transport.h" #include "iaudio_datatrans_callback.h" @@ -32,21 +33,29 @@ namespace OHOS { namespace DistributedHardware { -class DSpeakerDev : public IDAudioHdiCallback, +class DSpeakerDev : public DAudioIoDev, public IAudioDataTransCallback, public AVSenderTransportCallback, public std::enable_shared_from_this { public: DSpeakerDev(const std::string &devId, std::shared_ptr callback) - : devId_(devId), audioEventCallback_(callback) {}; + : DAudioIoDev(devId), audioEventCallback_(callback) {}; ~DSpeakerDev() override = default; + + // AVSenderTransportCallback void OnEngineTransEvent(const AVTransEvent &event) override; void OnEngineTransMessage(const std::shared_ptr &message) override; - int32_t InitSenderEngine(IAVEngineProvider *providerPtr); - int32_t EnableDSpeaker(const int32_t dhId, const std::string& capability); - int32_t DisableDSpeaker(const int32_t dhId); + // override + int32_t InitReceiverEngine(IAVEngineProvider *providerPtr) override; + int32_t InitSenderEngine(IAVEngineProvider *providerPtr) override; + + int32_t EnableDevice(const int32_t dhId, const std::string &capability) override; + int32_t DisableDevice(const int32_t dhId) override; + // int32_t EnableDSpeaker(const int32_t dhId, const std::string& capability); + // int32_t DisableDSpeaker(const int32_t dhId); + // IDAudioHdiCallback int32_t OpenDevice(const std::string &devId, const int32_t dhId) override; int32_t CloseDevice(const std::string &devId, const int32_t dhId) override; int32_t SetParameters(const std::string &devId, const int32_t dhId, const AudioParamHDF ¶m) override; @@ -57,34 +66,36 @@ public: uint64_t &frames, CurrentTimeHDF &time) override; int32_t RefreshAshmemInfo(const std::string &devId, const int32_t dhId, int32_t fd, int32_t ashmemLength, int32_t lengthPerTrans) override; - int32_t MmapStart(); - int32_t MmapStop(); + + // override + int32_t MmapStart() override; + int32_t MmapStop() override; int32_t OnStateChange(const AudioEventType type) override; int32_t OnDecodeTransDataDone(const std::shared_ptr &audioData) override; - int32_t SetUp(); - int32_t Start(); - int32_t Stop(); - int32_t Release(); - bool IsOpened(); - int32_t Pause(); - int32_t Restart(); - int32_t SendMessage(uint32_t type, std::string content, std::string dstDevId); + int32_t SetUp() override; + int32_t Start() override; + int32_t Stop() override; + int32_t Release() override; + bool IsOpened() override; + int32_t Pause() override; + int32_t Restart() override; + int32_t SendMessage(uint32_t type, std::string content, std::string dstDevId) override; - AudioParam GetAudioParam() const; - int32_t NotifyHdfAudioEvent(const AudioEvent &event); + AudioParam GetAudioParam() const override; + int32_t NotifyHdfAudioEvent(const AudioEvent &event, const int32_t portId) override; private: - int32_t EnableDevice(const int32_t dhId, const std::string &capability); - int32_t DisableDevice(const int32_t dhId); + // int32_t EnableDevice(const int32_t dhId, const std::string &capability); + // int32_t DisableDevice(const int32_t dhId); void EnqueueThread(); private: static constexpr const char* ENQUEUE_THREAD = "spkEnqueueTh"; const std::string FILE_NAME = "/data/source_spk_write.pcm"; - std::string devId_; + // std::string devId_; std::weak_ptr audioEventCallback_; std::mutex channelWaitMutex_; std::condition_variable channelWaitCond_; diff --git a/services/audiomanager/managersource/src/daudio_io_dev.cpp b/services/audiomanager/managersource/src/daudio_io_dev.cpp new file mode 100644 index 0000000000000000000000000000000000000000..58e82bc9cdb132c4f7ecb2366b61936f5cc70447 --- /dev/null +++ b/services/audiomanager/managersource/src/daudio_io_dev.cpp @@ -0,0 +1,39 @@ +/* + * Copyright (c) 2022-2023 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include "daudio_io_dev.h" + +#include +#include +#include +#include + +#include "daudio_constants.h" +#include "daudio_errorcode.h" +#include "daudio_hidumper.h" +#include "daudio_hisysevent.h" +#include "daudio_hitrace.h" +#include "daudio_log.h" +#include "daudio_source_manager.h" +#include "daudio_util.h" + +#undef DH_LOG_TAG +#define DH_LOG_TAG "DAudioIoDev" + +namespace OHOS { +namespace DistributedHardware { +// TODO: 若为接口，此文件删除 +} // DistributedHardware +} // OHOS diff --git a/services/audiomanager/managersource/src/daudio_source_dev.cpp b/services/audiomanager/managersource/src/daudio_source_dev.cpp index 915668b42b3551489729d38953132a2a9a472696..a23fe97879dfa521a5ce893192bd0026bd38faf6 100644 --- a/services/audiomanager/managersource/src/daudio_source_dev.cpp +++ b/services/audiomanager/managersource/src/daudio_source_dev.cpp @@ -272,11 +272,28 @@ int32_t DAudioSourceDev::HandleDSpeakerOpened(const AudioEvent &event) int32_t DAudioSourceDev::HandleDSpeakerClosed(const AudioEvent &event) { DHLOGI("Speaker device closed."); - if (speaker_ == nullptr) { - DHLOGE("Speaker already closed."); - return DH_SUCCESS; + int32_t dhId = 0; // TODO: 待查询 + auto speaker = FindIoDevImpl(event.content); + if (speaker == nullptr) { + DHLOGE("The IO device is invaild."); + return ERR_DH_AUDIO_NULLPTR; + } + return speaker->NotifyHdfAudioEvent(event, dhId); +} + +std::shared_ptr DAudioSourceDev::FindIoDevImpl(std::string args) +{ + int32_t dhId = ParseDhidFromEvent(args); + if (dhId < 0) { + DHLOGE("Failed to parse dhardware id."); + return nullptr; } - return speaker_->NotifyHdfAudioEvent(event); + std::lock_guard devLck(ioDevMtx_); + if (deviceMap_.find(dhId) == deviceMap_.end()) { + DHLOGE("Not find IO device instance."); + return nullptr; + } + return deviceMap_[dhId]; } int32_t DAudioSourceDev::HandleOpenDMic(const AudioEvent &event) @@ -329,11 +346,12 @@ int32_t DAudioSourceDev::HandleDMicOpened(const AudioEvent &event) int32_t DAudioSourceDev::HandleDMicClosed(const AudioEvent &event) { DHLOGI("Mic device closed."); + int32_t dhId = 0; if (mic_ == nullptr) { DHLOGE("Mic already closed."); return DH_SUCCESS; } - return mic_->NotifyHdfAudioEvent(event); + return mic_->NotifyHdfAudioEvent(event, dhId); } int32_t DAudioSourceDev::OpenCtrlTrans(const AudioEvent &event) @@ -387,6 +405,7 @@ int32_t DAudioSourceDev::HandleCtrlTransClosed(const AudioEvent &event) DHLOGI("Control trans closed."); AudioEvent audioEvent = event; HandleCloseCtrlTrans(audioEvent); + // TODO: 控制通道关闭事件下来应该所有通道应该关闭 if (speaker_ != nullptr && speaker_->IsOpened()) { audioEvent.type = SPEAKER_CLOSED; HandleDSpeakerClosed(audioEvent); @@ -676,12 +695,19 @@ int32_t DAudioSourceDev::TaskEnableDAudio(const std::string &args) int32_t DAudioSourceDev::EnableDSpeaker(const int32_t dhId, const std::string &attrs) { - if (speaker_ == nullptr) { - DHLOGI("Create new speaker device."); - speaker_ = std::make_shared(devId_, shared_from_this()); + std::lock_guard devLck(ioDevMtx_); + if (deviceMap_.find(dhId) != deviceMap_.end()) { + DHLOGI("The speaker device is already enabled."); + return DH_SUCCESS; } DAUDIO_SYNC_TRACE(DAUDIO_ENABLE_SPK); - return speaker_->EnableDSpeaker(dhId, attrs); + auto speaker = std::make_shared(devId_, shared_from_this()); + if (speaker->EnableDevice(dhId, attrs) != DH_SUCCESS) { + DHLOGI("Failed to enable speaker device."); + return ERR_DH_AUDIO_FAILED; + } + deviceMap_[dhId] = speaker; + return DH_SUCCESS; } int32_t DAudioSourceDev::EnableDMic(const int32_t dhId, const std::string &attrs) @@ -691,7 +717,7 @@ int32_t DAudioSourceDev::EnableDMic(const int32_t dhId, const std::string &attrs mic_ = std::make_shared(devId_, shared_from_this()); } DAUDIO_SYNC_TRACE(DAUDIO_ENABLE_MIC); - return mic_->EnableDMic(dhId, attrs); + return mic_->EnableDevice(dhId, attrs); } void DAudioSourceDev::OnEnableTaskResult(int32_t resultCode, const std::string &result, const std::string &funcName) @@ -774,12 +800,18 @@ int32_t DAudioSourceDev::TaskDisableDAudio(const std::string &args) int32_t DAudioSourceDev::DisableDSpeaker(const int32_t dhId) { - if (speaker_ == nullptr) { + std::lock_guard devLck(ioDevMtx_); + if (deviceMap_.find(dhId) == deviceMap_.end()) { + DHLOGI("The speaker device is already disabled."); + return DH_SUCCESS; + } + auto ioDev = deviceMap_[dhId]; + if (ioDev == nullptr) { DHLOGE("Speaker device is null."); return ERR_DH_AUDIO_NULLPTR; } DAUDIO_SYNC_TRACE(DAUDIO_DISABLE_SPK); - return speaker_->DisableDSpeaker(dhId); + return ioDev->DisableDevice(dhId); } int32_t DAudioSourceDev::DisableDMic(const int32_t dhId) @@ -789,7 +821,7 @@ int32_t DAudioSourceDev::DisableDMic(const int32_t dhId) return ERR_DH_AUDIO_NULLPTR; } DAUDIO_SYNC_TRACE(DAUDIO_DISABLE_MIC); - return mic_->DisableDMic(dhId); + return mic_->DisableDevice(dhId); } void DAudioSourceDev::OnDisableTaskResult(int32_t resultCode, const std::string &result, const std::string &funcName) @@ -832,9 +864,10 @@ void DAudioSourceDev::OnDisableTaskResult(int32_t resultCode, const std::string int32_t DAudioSourceDev::TaskOpenDSpeaker(const std::string &args) { DHLOGI("Task open speaker args: %s.", args.c_str()); - if (speaker_ == nullptr) { - DHLOGE("Speaker device not init"); - return ERR_DH_AUDIO_SA_SPEAKER_DEVICE_NOT_INIT; + auto speaker = FindIoDevImpl(args); + if (speaker == nullptr) { + DHLOGE("The IO device is invaild."); + return ERR_DH_AUDIO_NULLPTR; } if (args.length() > DAUDIO_MAX_JSON_LEN || args.empty()) { return ERR_DH_AUDIO_SA_PARAM_INVALID; @@ -850,7 +883,7 @@ int32_t DAudioSourceDev::TaskOpenDSpeaker(const std::string &args) cJSON_Delete(jParam); return ERR_DH_AUDIO_FAILED; } - int32_t ret = speaker_->InitSenderEngine(DAudioSourceManager::GetInstance().getSenderProvider()); + int32_t ret = speaker->InitSenderEngine(DAudioSourceManager::GetInstance().getSenderProvider()); if (ret != DH_SUCCESS) { DHLOGE("Speaker init sender Engine, error code %d.", ret); cJSON_Delete(jParam); @@ -861,7 +894,7 @@ int32_t DAudioSourceDev::TaskOpenDSpeaker(const std::string &args) DHLOGE("Failed to parse JSON: %s", cJSON_GetErrorPtr()); return ERR_DH_AUDIO_NULLPTR; } - to_json(&jAudioParam, speaker_->GetAudioParam()); + to_json(&jAudioParam, speaker->GetAudioParam()); ret = NotifySinkDev(OPEN_SPEAKER, jAudioParam, std::string(cJSON_GetObjectItem(jParam, KEY_DH_ID)->valuestring)); if (ret != DH_SUCCESS) { DHLOGE("Notify sink open speaker failed, error code %d.", ret); @@ -869,7 +902,12 @@ int32_t DAudioSourceDev::TaskOpenDSpeaker(const std::string &args) cJSON_Delete(jAudioParam); return ret; } - ret = OpenDSpeakerInner(); + int32_t dhId = ParseDhidFromEvent(args); // TODO: shoule get from args; + if (dhId < 0) { + DHLOGE("Failed to parse dhardware id."); + return ERR_DH_AUDIO_FAILED; + } + ret = OpenDSpeakerInner(speaker, dhId); if (ret != DH_SUCCESS) { DHLOGE("Task Open DSpeaker Execute failed, error code %d.", ret); cJSON_Delete(jParam); @@ -881,21 +919,37 @@ int32_t DAudioSourceDev::TaskOpenDSpeaker(const std::string &args) return DH_SUCCESS; } -int32_t DAudioSourceDev::OpenDSpeakerInner() +int32_t DAudioSourceDev::ParseDhidFromEvent(std::string args) { - int32_t ret = speaker_->SetUp(); + cJSON *jParam = cJSON_Parse(args.c_str()); + if (jParam == nullptr) { + DHLOGE("Failed to parse JSON: %s", cJSON_GetErrorPtr()); + cJSON_Delete(jParam); + return -1; + } + if (!JsonParamCheck(jParam, { KEY_DH_ID })) { + DHLOGE("Not found the keys of dhId."); + cJSON_Delete(jParam); + return -1; + } + return cJSON_GetObjectItem(jParam, KEY_DH_ID)->valueint; +} + +int32_t DAudioSourceDev::OpenDSpeakerInner(std::shared_ptr &speaker, const int32_t dhId) +{ + int32_t ret = speaker->SetUp(); if (ret != DH_SUCCESS) { DHLOGE("Speaker setup failed, error code %d.", ret); return ret; } - ret = speaker_->Start(); + ret = speaker->Start(); if (ret != DH_SUCCESS) { DHLOGE("Speaker start failed, error code %d.", ret); - speaker_->Stop(); - speaker_->Release(); + speaker->Stop(); + speaker->Release(); return ret; } - NotifyHDF(NOTIFY_OPEN_SPEAKER_RESULT, HDF_EVENT_RESULT_SUCCESS); + NotifyHDF(NOTIFY_OPEN_SPEAKER_RESULT, HDF_EVENT_RESULT_SUCCESS, dhId); // TODO: 注意A型死锁问题 return DH_SUCCESS; } @@ -903,17 +957,22 @@ int32_t DAudioSourceDev::CloseSpkOld(const std::string &args) { DHLOGI("Close speaker old"); bool closeStatus = true; - int32_t ret = speaker_->Stop(); + auto speaker = FindIoDevImpl(args); + if (speaker == nullptr) { + DHLOGE("The IO device is invaild."); + return ERR_DH_AUDIO_NULLPTR; + } + int32_t ret = speaker->Stop(); if (ret != DH_SUCCESS) { DHLOGE("Speaker stop failed."); closeStatus = false; } - ret = speaker_->Release(); + ret = speaker->Release(); if (ret != DH_SUCCESS) { DHLOGE("Speaker release failed."); closeStatus = false; } - if (!speaker_->IsOpened()) { + if (!speaker->IsOpened()) { cJSON *jAudioParam = cJSON_CreateObject(); if (jAudioParam == nullptr) { DHLOGE("Failed to create JSON object."); @@ -963,12 +1022,17 @@ int32_t DAudioSourceDev::CloseSpkNew(const std::string &args) } NotifySinkDev(CLOSE_SPEAKER, jAudioParam, std::string(cJSON_GetObjectItem(jParam, KEY_DH_ID)->valuestring)); bool closeStatus = true; - int32_t ret = speaker_->Stop(); + auto speaker = FindIoDevImpl(args); + if (speaker == nullptr) { + DHLOGE("The IO device is invaild."); + return ERR_DH_AUDIO_NULLPTR; + } + int32_t ret = speaker->Stop(); if (ret != DH_SUCCESS) { DHLOGE("Speaker stop failed."); closeStatus = false; } - ret = speaker_->Release(); + ret = speaker->Release(); if (ret != DH_SUCCESS) { DHLOGE("Speaker release failed."); closeStatus = false; @@ -986,9 +1050,15 @@ int32_t DAudioSourceDev::CloseSpkNew(const std::string &args) int32_t DAudioSourceDev::TaskCloseDSpeaker(const std::string &args) { DHLOGI("Task close speaker, args: %s.", args.c_str()); - if (speaker_ == nullptr) { + int32_t dhId = ParseDhidFromEvent(args); + if (dhId < 0) { + DHLOGE("Failed to parse dhardware id."); + return ERR_DH_AUDIO_FAILED; + } + auto speaker = FindIoDevImpl(args); + if (speaker == nullptr) { DHLOGD("Speaker already closed."); - NotifyHDF(NOTIFY_CLOSE_SPEAKER_RESULT, HDF_EVENT_RESULT_SUCCESS); + NotifyHDF(NOTIFY_CLOSE_SPEAKER_RESULT, HDF_EVENT_RESULT_SUCCESS, dhId); return DH_SUCCESS; } if (args.length() > DAUDIO_MAX_JSON_LEN || args.empty()) { @@ -1000,7 +1070,7 @@ int32_t DAudioSourceDev::TaskCloseDSpeaker(const std::string &args) DHLOGE("Close spk in old mode failed."); return ret; } - NotifyHDF(NOTIFY_CLOSE_SPEAKER_RESULT, HDF_EVENT_RESULT_SUCCESS); + NotifyHDF(NOTIFY_CLOSE_SPEAKER_RESULT, HDF_EVENT_RESULT_SUCCESS, dhId); return DH_SUCCESS; } @@ -1072,6 +1142,7 @@ int32_t DAudioSourceDev::NotifySinkDevOpenMic(cJSON *jParam) int32_t DAudioSourceDev::OpenDMicInner() { + int32_t dhId = 0; int32_t ret = mic_->Start(); if (ret != DH_SUCCESS) { DHLOGE("Mic start failed, error code %d.", ret); @@ -1079,7 +1150,7 @@ int32_t DAudioSourceDev::OpenDMicInner() mic_->Release(); return ret; } - NotifyHDF(NOTIFY_OPEN_MIC_RESULT, HDF_EVENT_RESULT_SUCCESS); + NotifyHDF(NOTIFY_OPEN_MIC_RESULT, HDF_EVENT_RESULT_SUCCESS, dhId); return DH_SUCCESS; } @@ -1171,9 +1242,10 @@ int32_t DAudioSourceDev::CloseMicNew(const std::string &args) int32_t DAudioSourceDev::TaskCloseDMic(const std::string &args) { DHLOGI("Task close mic, args: %s.", args.c_str()); + int32_t dhId = 0; if (mic_ == nullptr) { DHLOGE("Mic device already closed."); - NotifyHDF(NOTIFY_CLOSE_MIC_RESULT, HDF_EVENT_RESULT_SUCCESS); + NotifyHDF(NOTIFY_CLOSE_MIC_RESULT, HDF_EVENT_RESULT_SUCCESS, dhId); return DH_SUCCESS; } if (args.length() > DAUDIO_MAX_JSON_LEN || args.empty()) { @@ -1184,7 +1256,7 @@ int32_t DAudioSourceDev::TaskCloseDMic(const std::string &args) DHLOGE("Task close mic error."); return ret; } - NotifyHDF(NOTIFY_CLOSE_MIC_RESULT, HDF_EVENT_RESULT_SUCCESS); + NotifyHDF(NOTIFY_CLOSE_MIC_RESULT, HDF_EVENT_RESULT_SUCCESS, dhId); return DH_SUCCESS; } @@ -1212,19 +1284,48 @@ int32_t DAudioSourceDev::TaskSetVolume(const std::string &args) int32_t DAudioSourceDev::TaskChangeVolume(const std::string &args) { DHLOGD("Task change volume, args: %s.", args.c_str()); - return NotifyHDF(AudioEventType::VOLUME_CHANGE, args); + cJSON *jParam = cJSON_Parse(args.c_str()); + if (jParam == nullptr) { + DHLOGE("Failed to parse JSON: %s", cJSON_GetErrorPtr()); + cJSON_Delete(jParam); + return ERR_DH_AUDIO_NULLPTR; + } + if (!JsonParamCheck(jParam, { KEY_DH_ID })) { + DHLOGE("Not found the keys of dhId."); + cJSON_Delete(jParam); + return ERR_DH_AUDIO_FAILED; + } + int32_t dhId = cJSON_GetObjectItem(jParam, KEY_DH_ID)->valueint; + return NotifyHDF(AudioEventType::VOLUME_CHANGE, args, dhId); } int32_t DAudioSourceDev::TaskChangeFocus(const std::string &args) { DHLOGD("Task change focus, args: %s.", args.c_str()); - return NotifyHDF(AudioEventType::AUDIO_FOCUS_CHANGE, args); + int32_t dhId = ParseDhidFromEvent(args); + if (dhId < 0) { + DHLOGE("Failed to parse dhardware id."); + return ERR_DH_AUDIO_FAILED; + } + return NotifyHDF(AudioEventType::AUDIO_FOCUS_CHANGE, args, dhId); } int32_t DAudioSourceDev::TaskChangeRenderState(const std::string &args) { DHLOGD("Task change render state, args: %s.", args.c_str()); - return NotifyHDF(AudioEventType::AUDIO_RENDER_STATE_CHANGE, args); + cJSON *jParam = cJSON_Parse(args.c_str()); + if (jParam == nullptr) { + DHLOGE("Failed to parse JSON: %s", cJSON_GetErrorPtr()); + cJSON_Delete(jParam); + return ERR_DH_AUDIO_NULLPTR; + } + if (!JsonParamCheck(jParam, { KEY_DH_ID })) { + DHLOGE("Not found the keys of dhId."); + cJSON_Delete(jParam); + return ERR_DH_AUDIO_FAILED; + } + int32_t dhId = cJSON_GetObjectItem(jParam, KEY_DH_ID)->valueint; + return NotifyHDF(AudioEventType::AUDIO_RENDER_STATE_CHANGE, args, dhId); } int32_t DAudioSourceDev::TaskPlayStatusChange(const std::string &args) @@ -1236,15 +1337,19 @@ int32_t DAudioSourceDev::TaskPlayStatusChange(const std::string &args) DHLOGE("Task Play status change failed."); return ERR_DH_AUDIO_FAILED; } - + auto speaker = FindIoDevImpl(args); + if (speaker == nullptr) { + DHLOGE("The IO device is invaild."); + return ERR_DH_AUDIO_NULLPTR; + } if (args == AUDIO_EVENT_RESTART) { - ret = speaker_->Restart(); + ret = speaker->Restart(); if (ret != DH_SUCCESS) { DHLOGE("Speaker restart failed."); } return ret; } else if (args == AUDIO_EVENT_PAUSE) { - ret = speaker_->Pause(); + ret = speaker->Pause(); if (ret != DH_SUCCESS) { DHLOGE("Speaker Pause failed."); } @@ -1258,11 +1363,23 @@ int32_t DAudioSourceDev::TaskPlayStatusChange(const std::string &args) int32_t DAudioSourceDev::SendAudioEventToRemote(const AudioEvent &event) { // because: type: CHANGE_PLAY_STATUS / VOLUME_MUTE_SET / VOLUME_SET, so speaker - if (speaker_ == nullptr) { + std::shared_ptr speaker = nullptr; + if (event.type == VOLUME_SET) { + int32_t dhId = 0; + if (GetAudioParamInt(event.content, "dhId", dhId) != DH_SUCCESS) { + DHLOGE("Get key of dhId failed."); + return ERR_DH_AUDIO_FAILED; + } + std::lock_guard devLck(ioDevMtx_); + speaker = deviceMap_[dhId]; + } else { + speaker = FindIoDevImpl(event.content); + } + if (speaker == nullptr) { DHLOGE("Audio ctrl mgr not init."); return ERR_DH_AUDIO_NULLPTR; } - int32_t ret = speaker_->SendMessage(static_cast(event.type), + int32_t ret = speaker->SendMessage(static_cast(event.type), event.content, devId_); if (ret != DH_SUCCESS) { DHLOGE("Task send message to remote failed."); @@ -1274,11 +1391,12 @@ int32_t DAudioSourceDev::SendAudioEventToRemote(const AudioEvent &event) int32_t DAudioSourceDev::TaskSpkMmapStart(const std::string &args) { DHLOGI("Task spk mmap start, content: %s.", args.c_str()); - if (speaker_ == nullptr) { + auto speaker = FindIoDevImpl(args); + if (speaker == nullptr) { DHLOGE("Task spk mmap start, speaker is nullptr."); return ERR_DH_AUDIO_NULLPTR; } - int32_t ret = speaker_->MmapStart(); + int32_t ret = speaker->MmapStart(); if (ret != DH_SUCCESS) { DHLOGE("Task spk mmap start fail, error code: %d.", ret); } @@ -1288,11 +1406,12 @@ int32_t DAudioSourceDev::TaskSpkMmapStart(const std::string &args) int32_t DAudioSourceDev::TaskSpkMmapStop(const std::string &args) { DHLOGI("Task spk mmap stop, content: %s.", args.c_str()); - if (speaker_ == nullptr) { - DHLOGE("Task spk mmap stop, speaker is nullptr."); + auto speaker = FindIoDevImpl(args); + if (speaker == nullptr) { + DHLOGE("Task spk mmap start, speaker is nullptr."); return ERR_DH_AUDIO_NULLPTR; } - speaker_->MmapStop(); + speaker->MmapStop(); return DH_SUCCESS; } @@ -1360,13 +1479,14 @@ int32_t DAudioSourceDev::NotifySinkDev(const AudioEventType type, const cJSON *p DHLOGD("Notify sink dev, new engine, random task code:%s", std::to_string(randomTaskCode).c_str()); - if (speaker_ == nullptr || mic_ == nullptr) { + std::lock_guard devLck(ioDevMtx_); + if (deviceMap_.find(stoi(dhId)) == deviceMap_.end() || mic_ == nullptr) { cJSON_Delete(jParamCopy); cJSON_Delete(jParam); DHLOGE("speaker or mic dev is null."); return ERR_DH_AUDIO_NULLPTR; } - + auto ioDev = deviceMap_[stoi(dhId)]; if (type == OPEN_CTRL || type == CLOSE_CTRL) { cJSON_Delete(jParamCopy); cJSON_Delete(jParam); @@ -1375,7 +1495,7 @@ int32_t DAudioSourceDev::NotifySinkDev(const AudioEventType type, const cJSON *p } char *content = cJSON_PrintUnformatted(jParam); std::string contentStr(content); - speaker_->SendMessage(static_cast(type), contentStr, devId_); + ioDev->SendMessage(static_cast(type), contentStr, devId_); mic_->SendMessage(static_cast(type), contentStr, devId_); if (type == CLOSE_SPEAKER || type == CLOSE_MIC) { @@ -1387,7 +1507,7 @@ int32_t DAudioSourceDev::NotifySinkDev(const AudioEventType type, const cJSON *p return WaitForRPC(static_cast(static_cast(type) + eventOffset)); } -int32_t DAudioSourceDev::NotifyHDF(const AudioEventType type, const std::string result) +int32_t DAudioSourceDev::NotifyHDF(const AudioEventType type, const std::string result, const int32_t dhId) // TODO: 返回result需包含dhid { AudioEvent event(type, result); switch (type) { @@ -1400,14 +1520,14 @@ int32_t DAudioSourceDev::NotifyHDF(const AudioEventType type, const std::string DHLOGE("Speaker device not init"); return ERR_DH_AUDIO_NULLPTR; } - return speaker_->NotifyHdfAudioEvent(event); + return speaker_->NotifyHdfAudioEvent(event, dhId); case NOTIFY_OPEN_MIC_RESULT: case NOTIFY_CLOSE_MIC_RESULT: if (mic_ == nullptr) { DHLOGE("Mic device not init"); return ERR_DH_AUDIO_NULLPTR; } - return mic_->NotifyHdfAudioEvent(event); + return mic_->NotifyHdfAudioEvent(event, dhId); default: DHLOGE("NotifyHDF unknown type."); return ERR_DH_AUDIO_FAILED; diff --git a/services/audiomanager/managersource/src/dmic_dev.cpp b/services/audiomanager/managersource/src/dmic_dev.cpp index 5f2a04f42daeb4151778518b8e0ca2d36d6b00c5..2c0dcf5321dffa9ac915fcb56a7c80247012146d 100644 --- a/services/audiomanager/managersource/src/dmic_dev.cpp +++ b/services/audiomanager/managersource/src/dmic_dev.cpp @@ -83,74 +83,108 @@ int32_t DMicDev::InitReceiverEngine(IAVEngineProvider *providerPtr) return DH_SUCCESS; } -int32_t DMicDev::EnableDMic(const int32_t dhId, const std::string &capability) +int32_t DMicDev::InitSenderEngine(IAVEngineProvider *providerPtr) { - DHLOGI("Enable distributed mic dhId: %d.", dhId); - if (enabledPorts_.empty()) { - if (EnableDevice(PIN_IN_DAUDIO_DEFAULT, capability) != DH_SUCCESS) { - return ERR_DH_AUDIO_FAILED; - } - } - int32_t ret = EnableDevice(dhId, capability); - if (ret != DH_SUCCESS) { - return ret; - } - - DaudioFinishAsyncTrace(DAUDIO_REGISTER_AUDIO, DAUDIO_REGISTER_AUDIO_TASKID); - DAudioHisysevent::GetInstance().SysEventWriteBehavior(DAUIDO_REGISTER, devId_, std::to_string(dhId), - "daudio mic enable success."); + DHLOGI("InitReceiverEngine enter."); return DH_SUCCESS; } int32_t DMicDev::EnableDevice(const int32_t dhId, const std::string &capability) { - DHLOGI("Enable default mic device."); + DHLOGI("Enable IO device, device pin: %d.", dhId); int32_t ret = DAudioHdiHandler::GetInstance().RegisterAudioDevice(devId_, dhId, capability, shared_from_this()); if (ret != DH_SUCCESS) { - DHLOGE("Register mic device failed, ret: %d.", ret); + DHLOGE("Register device failed, ret: %d.", ret); DAudioHisysevent::GetInstance().SysEventWriteFault(DAUDIO_REGISTER_FAIL, devId_, std::to_string(dhId), ret, - "daudio register mic device failed."); + "daudio register device failed."); return ret; } - enabledPorts_.insert(dhId); - return DH_SUCCESS; -} - -int32_t DMicDev::DisableDMic(const int32_t dhId) -{ - DHLOGI("Disable distributed mic."); - if (dhId == curPort_) { - isOpened_.store(false); - } - if (DisableDevice(dhId) != DH_SUCCESS) { - return ERR_DH_AUDIO_FAILED; - } - - if (enabledPorts_.size() == SINGLE_ITEM && enabledPorts_.find(PIN_IN_DAUDIO_DEFAULT) != enabledPorts_.end()) { - if (DisableDevice(PIN_IN_DAUDIO_DEFAULT) != DH_SUCCESS) { - return ERR_DH_AUDIO_FAILED; - } - } - - DaudioFinishAsyncTrace(DAUDIO_UNREGISTER_AUDIO, DAUDIO_UNREGISTER_AUDIO_TASKID); - DAudioHisysevent::GetInstance().SysEventWriteBehavior(DAUDIO_UNREGISTER, devId_, std::to_string(dhId), - "daudio mic disable success."); + enabledPorts_.insert(dhId); //TODO:lock? return DH_SUCCESS; } int32_t DMicDev::DisableDevice(const int32_t dhId) { + DHLOGI("Disable IO device, device pin: %d.", dhId); int32_t ret = DAudioHdiHandler::GetInstance().UnRegisterAudioDevice(devId_, dhId); if (ret != DH_SUCCESS) { - DHLOGE("unregister audio device failed, ret: %d", ret); + DHLOGE("UnRegister failed, ret: %d.", ret); DAudioHisysevent::GetInstance().SysEventWriteFault(DAUDIO_UNREGISTER_FAIL, devId_, std::to_string(dhId), ret, - "daudio unregister audio mic device failed."); + "daudio unregister device failed."); return ret; } enabledPorts_.erase(dhId); return DH_SUCCESS; } +// int32_t DMicDev::EnableDMic(const int32_t dhId, const std::string &capability) +// { +// DHLOGI("Enable distributed mic dhId: %d.", dhId); +// if (enabledPorts_.empty()) { +// if (EnableDevice(PIN_IN_DAUDIO_DEFAULT, capability) != DH_SUCCESS) { +// return ERR_DH_AUDIO_FAILED; +// } +// } +// int32_t ret = EnableDevice(dhId, capability); +// if (ret != DH_SUCCESS) { +// return ret; +// } + +// DaudioFinishAsyncTrace(DAUDIO_REGISTER_AUDIO, DAUDIO_REGISTER_AUDIO_TASKID); +// DAudioHisysevent::GetInstance().SysEventWriteBehavior(DAUIDO_REGISTER, devId_, std::to_string(dhId), +// "daudio mic enable success."); +// return DH_SUCCESS; +// } + +// int32_t DMicDev::EnableDevice(const int32_t dhId, const std::string &capability) +// { +// DHLOGI("Enable default mic device."); +// int32_t ret = DAudioHdiHandler::GetInstance().RegisterAudioDevice(devId_, dhId, capability, shared_from_this()); +// if (ret != DH_SUCCESS) { +// DHLOGE("Register mic device failed, ret: %d.", ret); +// DAudioHisysevent::GetInstance().SysEventWriteFault(DAUDIO_REGISTER_FAIL, devId_, std::to_string(dhId), ret, +// "daudio register mic device failed."); +// return ret; +// } +// enabledPorts_.insert(dhId); +// return DH_SUCCESS; +// } + +// int32_t DMicDev::DisableDMic(const int32_t dhId) +// { +// DHLOGI("Disable distributed mic."); +// if (dhId == curPort_) { +// isOpened_.store(false); +// } +// if (DisableDevice(dhId) != DH_SUCCESS) { +// return ERR_DH_AUDIO_FAILED; +// } + +// if (enabledPorts_.size() == SINGLE_ITEM && enabledPorts_.find(PIN_IN_DAUDIO_DEFAULT) != enabledPorts_.end()) { +// if (DisableDevice(PIN_IN_DAUDIO_DEFAULT) != DH_SUCCESS) { +// return ERR_DH_AUDIO_FAILED; +// } +// } + +// DaudioFinishAsyncTrace(DAUDIO_UNREGISTER_AUDIO, DAUDIO_UNREGISTER_AUDIO_TASKID); +// DAudioHisysevent::GetInstance().SysEventWriteBehavior(DAUDIO_UNREGISTER, devId_, std::to_string(dhId), +// "daudio mic disable success."); +// return DH_SUCCESS; +// } + +// int32_t DMicDev::DisableDevice(const int32_t dhId) +// { +// int32_t ret = DAudioHdiHandler::GetInstance().UnRegisterAudioDevice(devId_, dhId); +// if (ret != DH_SUCCESS) { +// DHLOGE("unregister audio device failed, ret: %d", ret); +// DAudioHisysevent::GetInstance().SysEventWriteFault(DAUDIO_UNREGISTER_FAIL, devId_, std::to_string(dhId), ret, +// "daudio unregister audio mic device failed."); +// return ret; +// } +// enabledPorts_.erase(dhId); +// return DH_SUCCESS; +// } + int32_t DMicDev::OpenDevice(const std::string &devId, const int32_t dhId) { DHLOGI("Open mic device devId: %s, dhId: %d.", GetAnonyString(devId).c_str(), dhId); @@ -301,6 +335,18 @@ int32_t DMicDev::Start() return DH_SUCCESS; } +int32_t DMicDev::Pause() +{ + DHLOGI("Pause success."); + return DH_SUCCESS; +} + +int32_t DMicDev::Restart() +{ + DHLOGI("Restart success."); + return DH_SUCCESS; +} + int32_t DMicDev::Stop() { DHLOGI("Stop mic device."); @@ -381,7 +427,7 @@ int32_t DMicDev::ReadStreamData(const std::string &devId, const int32_t dhId, st if (DaudioHidumper::GetInstance().GetFlagStatus()) { if (!dumpFlag_) { AudioEvent event(NOTIFY_HDF_MIC_DUMP, ""); - NotifyHdfAudioEvent(event); + NotifyHdfAudioEvent(event, dhId); dumpFlag_.store(true); } SaveFile(FILE_NAME, const_cast(data->Data()), data->Size()); @@ -515,9 +561,9 @@ AudioParam DMicDev::GetAudioParam() const return param_; } -int32_t DMicDev::NotifyHdfAudioEvent(const AudioEvent &event) +int32_t DMicDev::NotifyHdfAudioEvent(const AudioEvent &event, const int32_t portId) { - int32_t ret = DAudioHdiHandler::GetInstance().NotifyEvent(devId_, curPort_, event); + int32_t ret = DAudioHdiHandler::GetInstance().NotifyEvent(devId_, portId, event); if (ret != DH_SUCCESS) { DHLOGE("Notify event: %d, result: %s.", event.type, event.content.c_str()); } diff --git a/services/audiomanager/managersource/src/dspeaker_dev.cpp b/services/audiomanager/managersource/src/dspeaker_dev.cpp index 9ada4b8ebd50776901594bd3ed24524997874473..a753f1a353f27be28b0421b8a29a00892e9e2371 100644 --- a/services/audiomanager/managersource/src/dspeaker_dev.cpp +++ b/services/audiomanager/managersource/src/dspeaker_dev.cpp @@ -37,71 +37,105 @@ namespace OHOS { namespace DistributedHardware { -int32_t DSpeakerDev::EnableDSpeaker(const int32_t dhId, const std::string &capability) -{ - DHLOGI("Enable speaker device dhId: %d.", dhId); - if (enabledPorts_.empty()) { - if (EnableDevice(PIN_OUT_DAUDIO_DEFAULT, capability) != DH_SUCCESS) { - return ERR_DH_AUDIO_FAILED; - } - } - int32_t ret = EnableDevice(dhId, capability); - - DaudioFinishAsyncTrace(DAUDIO_REGISTER_AUDIO, DAUDIO_REGISTER_AUDIO_TASKID); - DAudioHisysevent::GetInstance().SysEventWriteBehavior(DAUIDO_REGISTER, devId_, std::to_string(dhId), - "daudio spk enable success."); - return ret; -} - int32_t DSpeakerDev::EnableDevice(const int32_t dhId, const std::string &capability) { + DHLOGI("Enable IO device, device pin: %d.", dhId); int32_t ret = DAudioHdiHandler::GetInstance().RegisterAudioDevice(devId_, dhId, capability, shared_from_this()); if (ret != DH_SUCCESS) { - DHLOGE("Register speaker device failed, ret: %d.", ret); + DHLOGE("Register device failed, ret: %d.", ret); DAudioHisysevent::GetInstance().SysEventWriteFault(DAUDIO_REGISTER_FAIL, devId_, std::to_string(dhId), ret, - "daudio register speaker device failed."); - return ret; - } - enabledPorts_.insert(dhId); - return DH_SUCCESS; -} - -int32_t DSpeakerDev::DisableDSpeaker(const int32_t dhId) -{ - DHLOGI("Disable distributed speaker."); - if (dhId == curPort_) { - isOpened_.store(false); - } - int32_t ret = DisableDevice(dhId); - if (ret != DH_SUCCESS) { + "daudio register device failed."); return ret; } - if (enabledPorts_.size() == SINGLE_ITEM && enabledPorts_.find(PIN_OUT_DAUDIO_DEFAULT) != enabledPorts_.end()) { - ret = DisableDevice(PIN_OUT_DAUDIO_DEFAULT); - if (ret != DH_SUCCESS) { - return ret; - } - } - - DaudioFinishAsyncTrace(DAUDIO_UNREGISTER_AUDIO, DAUDIO_UNREGISTER_AUDIO_TASKID); - DAudioHisysevent::GetInstance().SysEventWriteBehavior(DAUDIO_UNREGISTER, devId_, std::to_string(dhId), - "daudio spk disable success."); + enabledPorts_.insert(dhId); //TODO:lock? return DH_SUCCESS; } int32_t DSpeakerDev::DisableDevice(const int32_t dhId) { + DHLOGI("Disable IO device, device pin: %d.", dhId); int32_t ret = DAudioHdiHandler::GetInstance().UnRegisterAudioDevice(devId_, dhId); if (ret != DH_SUCCESS) { - DHLOGE("UnRegister speaker device failed, ret: %d.", ret); + DHLOGE("UnRegister failed, ret: %d.", ret); DAudioHisysevent::GetInstance().SysEventWriteFault(DAUDIO_UNREGISTER_FAIL, devId_, std::to_string(dhId), ret, - "daudio unregister speaker device failed."); + "daudio unregister device failed."); return ret; } enabledPorts_.erase(dhId); return DH_SUCCESS; } +// int32_t DSpeakerDev::EnableDSpeaker(const int32_t dhId, const std::string &capability) +// { +// DHLOGI("Enable speaker device dhId: %d.", dhId); +// if (enabledPorts_.empty()) { +// if (EnableDevice(PIN_OUT_DAUDIO_DEFAULT, capability) != DH_SUCCESS) { +// return ERR_DH_AUDIO_FAILED; +// } +// } +// int32_t ret = EnableDevice(dhId, capability); + +// DaudioFinishAsyncTrace(DAUDIO_REGISTER_AUDIO, DAUDIO_REGISTER_AUDIO_TASKID); +// DAudioHisysevent::GetInstance().SysEventWriteBehavior(DAUIDO_REGISTER, devId_, std::to_string(dhId), +// "daudio spk enable success."); +// return ret; +// } + +// int32_t DSpeakerDev::EnableDevice(const int32_t dhId, const std::string &capability) +// { +// int32_t ret = DAudioHdiHandler::GetInstance().RegisterAudioDevice(devId_, dhId, capability, shared_from_this()); +// if (ret != DH_SUCCESS) { +// DHLOGE("Register speaker device failed, ret: %d.", ret); +// DAudioHisysevent::GetInstance().SysEventWriteFault(DAUDIO_REGISTER_FAIL, devId_, std::to_string(dhId), ret, +// "daudio register speaker device failed."); +// return ret; +// } +// enabledPorts_.insert(dhId); +// return DH_SUCCESS; +// } + +// int32_t DSpeakerDev::DisableDSpeaker(const int32_t dhId) +// { +// DHLOGI("Disable distributed speaker."); +// if (dhId == curPort_) { +// isOpened_.store(false); +// } +// int32_t ret = DisableDevice(dhId); +// if (ret != DH_SUCCESS) { +// return ret; +// } +// if (enabledPorts_.size() == SINGLE_ITEM && enabledPorts_.find(PIN_OUT_DAUDIO_DEFAULT) != enabledPorts_.end()) { +// ret = DisableDevice(PIN_OUT_DAUDIO_DEFAULT); +// if (ret != DH_SUCCESS) { +// return ret; +// } +// } + +// DaudioFinishAsyncTrace(DAUDIO_UNREGISTER_AUDIO, DAUDIO_UNREGISTER_AUDIO_TASKID); +// DAudioHisysevent::GetInstance().SysEventWriteBehavior(DAUDIO_UNREGISTER, devId_, std::to_string(dhId), +// "daudio spk disable success."); +// return DH_SUCCESS; +// } + +// int32_t DSpeakerDev::DisableDevice(const int32_t dhId) +// { +// int32_t ret = DAudioHdiHandler::GetInstance().UnRegisterAudioDevice(devId_, dhId); +// if (ret != DH_SUCCESS) { +// DHLOGE("UnRegister speaker device failed, ret: %d.", ret); +// DAudioHisysevent::GetInstance().SysEventWriteFault(DAUDIO_UNREGISTER_FAIL, devId_, std::to_string(dhId), ret, +// "daudio unregister speaker device failed."); +// return ret; +// } +// enabledPorts_.erase(dhId); +// return DH_SUCCESS; +// } + +int32_t DSpeakerDev::InitReceiverEngine(IAVEngineProvider *providerPtr) +{ + DHLOGI("InitReceiverEngine enter."); + return DH_SUCCESS; +} + int32_t DSpeakerDev::InitSenderEngine(IAVEngineProvider *providerPtr) { DHLOGI("InitSenderEngine enter"); @@ -382,7 +416,7 @@ int32_t DSpeakerDev::WriteStreamData(const std::string &devId, const int32_t dhI if (DaudioHidumper::GetInstance().GetFlagStatus()) { if (!dumpFlag_) { AudioEvent event(NOTIFY_HDF_SPK_DUMP, ""); - NotifyHdfAudioEvent(event); + NotifyHdfAudioEvent(event, dhId); dumpFlag_.store(true); } SaveFile(FILE_NAME, const_cast(data->Data()), data->Size()); @@ -520,9 +554,9 @@ int32_t DSpeakerDev::SendMessage(uint32_t type, std::string content, std::string return DH_SUCCESS; } -int32_t DSpeakerDev::NotifyHdfAudioEvent(const AudioEvent &event) +int32_t DSpeakerDev::NotifyHdfAudioEvent(const AudioEvent &event, const int32_t portId) { - int32_t ret = DAudioHdiHandler::GetInstance().NotifyEvent(devId_, curPort_, event); + int32_t ret = DAudioHdiHandler::GetInstance().NotifyEvent(devId_, portId, event); if (ret != DH_SUCCESS) { DHLOGE("Notify event: %d, result: %s.", event.type, event.content.c_str()); } diff --git a/services/audiomanager/servicesource/BUILD.gn b/services/audiomanager/servicesource/BUILD.gn index ca27245d4b223db51ba91964c9797c63e8b3d33b..b896bade17a0081ac0f6d9f0ce5dad43cbee6eab 100755 --- a/services/audiomanager/servicesource/BUILD.gn +++ b/services/audiomanager/servicesource/BUILD.gn @@ -71,6 +71,7 @@ ohos_shared_library("distributed_audio_source") { "${common_path}/dfx_utils/src/daudio_hidumper.cpp", "${interfaces_path}/inner_kits/native_cpp/audio_sink/src/daudio_sink_proxy.cpp", "${interfaces_path}/inner_kits/native_cpp/audio_source/src/daudio_source_proxy.cpp", + "${services_path}/audiomanager/managersource/src/daudio_io_dev.cpp", "${services_path}/audiomanager/managersource/src/daudio_source_dev.cpp", "${services_path}/audiomanager/managersource/src/daudio_source_manager.cpp", "${services_path}/audiomanager/managersource/src/daudio_source_mgr_callback.cpp", diff --git a/services/audiomanager/test/unittest/sourcedevice/src/dmic_dev_test.cpp b/services/audiomanager/test/unittest/sourcedevice/src/dmic_dev_test.cpp index 3c06e208e573768670459c657ff3748f972581ac..071d7678f760212c5fbad5b04c3389b0a17cf3bd 100644 --- a/services/audiomanager/test/unittest/sourcedevice/src/dmic_dev_test.cpp +++ b/services/audiomanager/test/unittest/sourcedevice/src/dmic_dev_test.cpp @@ -304,11 +304,12 @@ HWTEST_F(DMicDevTest, ReadStreamData_001, TestSize.Level1) HWTEST_F(DMicDevTest, NotifyHdfAudioEvent_001, TestSize.Level1) { AudioEvent event = AudioEvent(OPEN_MIC, "OPEN_MIC"); - EXPECT_EQ(DH_SUCCESS, mic_->NotifyHdfAudioEvent(event)); + int32_t dhId = 0; + EXPECT_EQ(DH_SUCCESS, mic_->NotifyHdfAudioEvent(event, dhId)); event.type = MIC_OPENED; - mic_->curPort_ = DH_ID_MIC; - EXPECT_EQ(DH_SUCCESS, mic_->NotifyHdfAudioEvent(event)); + dhId = DH_ID_MIC; + EXPECT_EQ(DH_SUCCESS, mic_->NotifyHdfAudioEvent(event, dhId)); } /** diff --git a/services/audiomanager/test/unittest/sourcedevice/src/dspeaker_dev_test.cpp b/services/audiomanager/test/unittest/sourcedevice/src/dspeaker_dev_test.cpp index 1f57e888ba1ae5408480e71a1a6aec7e148e276f..ba2c74c43b308afda4910c8c3df6ca438fcaaf1f 100644 --- a/services/audiomanager/test/unittest/sourcedevice/src/dspeaker_dev_test.cpp +++ b/services/audiomanager/test/unittest/sourcedevice/src/dspeaker_dev_test.cpp @@ -364,11 +364,12 @@ HWTEST_F(DSpeakerDevTest, WriteStreamData_002, TestSize.Level1) HWTEST_F(DSpeakerDevTest, NotifyHdfAudioEvent_001, TestSize.Level1) { AudioEvent event = AudioEvent(OPEN_SPEAKER, "OPEN_SPEAKER"); - EXPECT_EQ(DH_SUCCESS, spk_->NotifyHdfAudioEvent(event)); + int32_t dhId = 0; + EXPECT_EQ(DH_SUCCESS, spk_->NotifyHdfAudioEvent(event, dhId)); event.type = SPEAKER_OPENED; - spk_->curPort_ = DH_ID_SPK; - EXPECT_EQ(DH_SUCCESS, spk_->NotifyHdfAudioEvent(event)); + dhId = DH_ID_SPK; + EXPECT_EQ(DH_SUCCESS, spk_->NotifyHdfAudioEvent(event, dhId)); } /**