diff --git a/audiohandler/src/daudio_handler.cpp b/audiohandler/src/daudio_handler.cpp index 06e57b699811dba1cc5532bf1b1b96f8d0a7e04e..fb06fc4eb36624ad8dbcb078e7c698d07b9adc15 100644 --- a/audiohandler/src/daudio_handler.cpp +++ b/audiohandler/src/daudio_handler.cpp @@ -111,6 +111,11 @@ std::vector DAudioHandler::Query() dhItem.attrs = infoJson.dump(); dhItemVec.push_back(dhItem); DHLOGD("Query result: dhId: %d, attrs: %s.", dhId, infoJson.dump().c_str()); + 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.", LOW_LATENCY_RENDER_ID, infoJson.dump().c_str()); + } } ablityForDumpVec_ = dhItemVec; return dhItemVec; diff --git a/bundle.json b/bundle.json index e963b31144610cee38e07f68025ab8fda703eed4..e63c9ce2e456d69c84fb75c5ce5953f342f89a51 100755 --- a/bundle.json +++ b/bundle.json @@ -45,7 +45,8 @@ "samgr" ], "third_party": [ - "json" + "json", + "cJSON" ] }, "build": { diff --git a/common/include/daudio_constants.h b/common/include/daudio_constants.h index 0eee4b2f75c898538ca23ea6df0fb368138697d3..8c9968a77c773ea988b7c6f4329da6f00e227457 100644 --- a/common/include/daudio_constants.h +++ b/common/include/daudio_constants.h @@ -70,6 +70,10 @@ static constexpr int64_t LOW_LATENCY_INTERVAL_NS = 5000000; static constexpr int64_t LOW_LATENCY_CLIENT_INTERVAL_NS = 20000000; static constexpr int64_t MAX_TIME_INTERVAL_US = 23000; +static constexpr int32_t LOW_LATENCY_RENDER_ID = 1 << 1 | 1 << 0; +static constexpr int32_t DEFAULT_RENDER_ID = 1; +static constexpr int32_t DEFAULT_CAPTURE_ID = 1 << 27 | 1 << 0; + const std::string DAUDIO_LOG_TITLE_TAG = "DAUDIO"; const std::string DAUDIO_PREFIX = "DISTRIBUTED_AUDIO"; const std::string AUDIO_PREFIX = "AUDIO"; diff --git a/common/include/daudio_util.h b/common/include/daudio_util.h index 33d4392286dcf7daebc8b92f772b304ba45c229c..791a386fe533b5e4ed0204ce338f1ef6a3cf28ba 100644 --- a/common/include/daudio_util.h +++ b/common/include/daudio_util.h @@ -20,6 +20,7 @@ #include #include #include "nlohmann/json.hpp" +#include "cJSON.h" using json = nlohmann::json; @@ -37,6 +38,7 @@ int32_t GetAudioParamStr(const std::string ¶ms, const std::string &key, std: int32_t GetAudioParamBool(const std::string ¶ms, const std::string &key, bool &value); int32_t GetAudioParamInt(const std::string ¶ms, const std::string &key, int32_t &value); bool JsonParamCheck(const json &jsonObj, const std::initializer_list &key); +bool CJsonParamCheck(const cJSON *jsonObj, const std::initializer_list &keys); bool IsString(const json &jsonObj, const std::string &key); bool IsInt32(const json &jsonObj, const std::string &key); bool IsAudioParam(const json &jsonObj, const std::string &key); diff --git a/common/src/daudio_util.cpp b/common/src/daudio_util.cpp index e1a1fc1f7912ec017a893b77bf9d284f5707ebe2..c0b048a14b30db1828af3f760729b7e1261753fe 100644 --- a/common/src/daudio_util.cpp +++ b/common/src/daudio_util.cpp @@ -221,6 +221,46 @@ bool JsonParamCheck(const json &jsonObj, const std::initializer_list &keys) +{ + if (jsonObj == nullptr || !cJSON_IsObject(jsonObj)) { + DHLOGE("JSON parameter is invalid."); + return false; + } + + for (auto it = keys.begin(); it != keys.end(); it++) { + cJSON *paramValue = cJSON_GetObjectItemCaseSensitive(jsonObj, (*it).c_str()); + if (paramValue == nullptr) { + DHLOGE("JSON parameter does not contain key: %s", (*it).c_str()); + return false; + } + bool res = IsString(jsonObj, *it); + if (!res) { + DHLOGE("The key %s value format in JSON is illegal.", (*it).c_str()); + return false; + } + } + return true; +} + bool IsString(const json &jsonObj, const std::string &key) { return jsonObj[key].is_string(); diff --git a/hdf_service/distributed_audio/bundle.json b/hdf_service/distributed_audio/bundle.json index 080e9e121ab7cee446fee463b605d61c596a96be..b6c6e78f85d88ac14708db84d063d61d990aef64 100644 --- a/hdf_service/distributed_audio/bundle.json +++ b/hdf_service/distributed_audio/bundle.json @@ -22,7 +22,9 @@ "hilog", "ipc" ], - "third_party": [] + "third_party": [ + "cJSON" + ] }, "build": { "sub_component": [ 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..087a405fca5d18dd321014f151dc81523ba23634 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,15 +101,19 @@ 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 OpenCaptureDevice(const AudioDeviceDescriptor &desc, const AudioSampleAttributes &attrs); - int32_t CloseCaptureDevice(const AudioDeviceDescriptor &desc); uint32_t GetVolumeGroup(const uint32_t devId); uint32_t GetInterruptGroup(const uint32_t devId); bool IsPortsNoReg(); private: + int32_t OpenRenderDevice(const AudioDeviceDescriptor &desc, const AudioSampleAttributes &attrs, + const sptr extSpkCallback, const int32_t dhId); + int32_t CloseRenderDevice(const AudioDeviceDescriptor &desc, const sptr extSpkCallback, + const int32_t dhId); + int32_t OpenCaptureDevice(const AudioDeviceDescriptor &desc, const AudioSampleAttributes &attrs, + const sptr extMicCallback, const int32_t dhId); + int32_t CloseCaptureDevice(const AudioDeviceDescriptor &desc, const sptr extMicCallback, + const int32_t dhId); int32_t SetAudioVolume(const std::string& condition, const std::string ¶m); int32_t GetAudioVolume(const std::string& condition, std::string ¶m); int32_t HandleFocusChangeEvent(const DAudioEvent &event); @@ -119,12 +123,17 @@ 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 InsertCapImpl(const sptr &audioCapture, uint32_t &captureId); + int32_t InsertRenderImpl(const sptr &audioRender, const int32_t dhId, + uint32_t &renderId); + int32_t InsertCapImpl(const sptr &audioCapture, const int32_t dhId, + 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); + int32_t GetVolFromEvent(const std::string &content, const std::string &key, int32_t &vol); private: static constexpr uint8_t WAIT_SECONDS = 20; @@ -132,14 +141,14 @@ private: AudioAdapterDescriptor adpDescriptor_; AudioAdapterStatus status_ = STATUS_OFFLINE; - sptr extSpkCallback_ = nullptr; - sptr extMicCallback_ = nullptr; + std::mutex extCallbackMtx_; + std::map> extCallbackMap_; sptr paramCallback_ = nullptr; std::mutex renderDevMtx_; - std::vector> renderDevs_; + std::vector>> renderDevs_; AudioParameter renderParam_; std::mutex capDevMtx_; - std::vector> captureDevs_; + std::vector>> captureDevs_; AudioParameter captureParam_; std::mutex devMapMtx_; 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..c3c94e96a5d816d03f9c1a1edb1584d9b6b644b1 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 @@ -19,6 +19,8 @@ #include #include +#include "cJSON.h" + #include "daudio_constants.h" #include "daudio_errcode.h" #include "daudio_events.h" @@ -39,10 +41,10 @@ static constexpr uint32_t MAX_AUDIO_STREAM_NUM = 10; AudioAdapterInterfaceImpl::AudioAdapterInterfaceImpl(const AudioAdapterDescriptor &desc) : adpDescriptor_(desc) { - renderDevs_ = std::vector>( - MAX_AUDIO_STREAM_NUM, sptr(nullptr)); - captureDevs_ = 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, std::make_pair(0, sptr(nullptr))); renderParam_ = { 0, 0, 0, 0, 0, 0 }; captureParam_ = { 0, 0, 0, 0, 0, 0 }; @@ -54,22 +56,32 @@ 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; + std::lock_guard devLck(extCallbackMtx_); + 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; + std::lock_guard devLck(extCallbackMtx_); + if (extCallbackMap_.find(dhId) != extCallbackMap_.end()) { + DHLOGI("The callback of daudio is already set."); + return; + } + extCallbackMap_[dhId] = micCallback; } int32_t AudioAdapterInterfaceImpl::InitAllPorts() @@ -92,34 +104,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 +145,28 @@ 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; + } + + std::lock_guard devLck(extCallbackMtx_); + 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 +175,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; } + std::lock_guard devLck(extCallbackMtx_); + 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, dhId); 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; } @@ -193,34 +235,40 @@ int32_t AudioAdapterInterfaceImpl::CreateCapture(const AudioDeviceDescriptor &de return HDF_FAILURE; } } + int32_t capPinId = 0; + auto extMicCallback = MatchStreamCallback(attrs, desc, capPinId); + if (extMicCallback == nullptr) { + DHLOGE("Matched callback is null."); + return HDF_FAILURE; + } #ifdef DAUDIO_SUPPORT_EXTENSION if (attrs.type == AUDIO_MMAP_NOIRQ) { DHLOGI("Try to mmap mode."); capturerFlags_ = Audioext::V1_0::MMAP_MODE; audioCapture = new AudioCaptureExtImpl(); - audioCapture->SetAttrs(adpDescriptor_.adapterName, desc, attrs, extMicCallback_); + audioCapture->SetAttrs(adpDescriptor_.adapterName, desc, attrs, extMicCallback); } else { DHLOGI("Try to normal mode."); capturerFlags_ = Audioext::V1_0::NORMAL_MODE; - audioCapture = new AudioCaptureInterfaceImpl(adpDescriptor_.adapterName, desc, attrs, extMicCallback_); + audioCapture = new AudioCaptureInterfaceImpl(adpDescriptor_.adapterName, desc, attrs, extMicCallback); } #else capturerFlags_ = Audioext::V1_0::NORMAL_MODE; - audioCapture = new AudioCaptureInterfaceImpl(adpDescriptor_.adapterName, desc, attrs, extMicCallback_); + audioCapture = new AudioCaptureInterfaceImpl(adpDescriptor_.adapterName, desc, attrs, extMicCallback); #endif if (audioCapture == nullptr) { DHLOGE("Create capture failed."); return HDF_FAILURE; } - int32_t ret = OpenCaptureDevice(desc, attrs); + int32_t ret = OpenCaptureDevice(desc, attrs, extMicCallback, capPinId); if (ret != DH_SUCCESS) { DHLOGE("Open capture device failed."); audioCapture = nullptr; return ret == ERR_DH_AUDIO_HDF_WAIT_TIMEOUT ? HDF_ERR_TIMEOUT : HDF_FAILURE; } capture = audioCapture; - if (InsertCapImpl(audioCapture, captureId) != HDF_SUCCESS) { + if (InsertCapImpl(audioCapture, capPinId, captureId) != HDF_SUCCESS) { DHLOGE("Generrate capture ID and insert capture failed."); return HDF_FAILURE; } @@ -229,7 +277,7 @@ int32_t AudioAdapterInterfaceImpl::CreateCapture(const AudioDeviceDescriptor &de } int32_t AudioAdapterInterfaceImpl::InsertCapImpl(const sptr &audioCapture, - uint32_t &captureId) + const int32_t dhId, uint32_t &captureId) { std::lock_guard devLck(capDevMtx_); if (captureDevs_.size() != MAX_AUDIO_STREAM_NUM) { @@ -238,7 +286,7 @@ int32_t AudioAdapterInterfaceImpl::InsertCapImpl(const sptr audioCapture(nullptr); + int32_t dhId = 0; { std::lock_guard devLck(capDevMtx_); - audioCapture = captureDevs_[captureId]; + audioCapture = captureDevs_[captureId].second; + dhId = captureDevs_[captureId].first; } + std::lock_guard devLck(extCallbackMtx_); + sptr extMicCallback(extCallbackMap_[dhId]); if (audioCapture == nullptr) { DHLOGD("Capture has not been created, do not need destroy."); return HDF_SUCCESS; } - int32_t ret = CloseCaptureDevice(audioCapture->GetCaptureDesc()); + int32_t ret = CloseCaptureDevice(audioCapture->GetCaptureDesc(), extMicCallback, dhId); if (ret != DH_SUCCESS) { DHLOGE("Close capture device failed."); return HDF_FAILURE; } { std::lock_guard devLck(capDevMtx_); - captureDevs_[captureId] = nullptr; + captureDevs_[captureId].first = 0; + captureDevs_[captureId].second = nullptr; } return HDF_SUCCESS; } @@ -505,15 +558,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; renderParam_.format = attrs.format; renderParam_.channelCount = attrs.channelCount; renderParam_.sampleRate = attrs.sampleRate; @@ -522,12 +575,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 +595,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, const int32_t dhId) { - DHLOGI("Close render device, pin: %d.", desc.pins); + DHLOGI("Close render device, pin: %d.", dhId); + 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, dhId); if (ret != HDF_SUCCESS) { DHLOGE("Close audio device failed."); return ERR_DH_AUDIO_HDF_CLOSE_DEVICE_FAIL; @@ -568,15 +626,15 @@ int32_t AudioAdapterInterfaceImpl::CloseRenderDevice(const AudioDeviceDescriptor } int32_t AudioAdapterInterfaceImpl::OpenCaptureDevice(const AudioDeviceDescriptor &desc, - const AudioSampleAttributes &attrs) + const AudioSampleAttributes &attrs, const sptr extMicCallback, const int32_t dhId) { - DHLOGI("Open capture device, pin: %d.", desc.pins); + DHLOGI("Open capture device, pin: %d.", dhId); if (isMicOpened_) { DHLOGI("Capture already opened."); return DH_SUCCESS; } std::lock_guard devLck(captureOptMtx_); - micPinInUse_ = desc.pins; + micPinInUse_ = dhId; captureParam_.format = attrs.format; captureParam_.channelCount = attrs.channelCount; captureParam_.sampleRate = attrs.sampleRate; @@ -585,12 +643,12 @@ int32_t AudioAdapterInterfaceImpl::OpenCaptureDevice(const AudioDeviceDescriptor attrs.format, timeInterval_, capturerFlags_ == Audioext::V1_0::MMAP_MODE); captureParam_.capturerFlags = capturerFlags_; - int32_t ret = extMicCallback_->SetParameters(adpDescriptor_.adapterName, desc.pins, captureParam_); + int32_t ret = extMicCallback->SetParameters(adpDescriptor_.adapterName, dhId, captureParam_); if (ret != HDF_SUCCESS) { DHLOGE("Set audio parameters failed."); return ERR_DH_AUDIO_HDF_SET_PARAM_FAIL; } - ret = extMicCallback_->OpenDevice(adpDescriptor_.adapterName, desc.pins); + ret = extMicCallback->OpenDevice(adpDescriptor_.adapterName, dhId); if (ret != HDF_SUCCESS) { DHLOGE("Open audio device failed."); return ERR_DH_AUDIO_HDF_OPEN_DEVICE_FAIL; @@ -605,16 +663,17 @@ int32_t AudioAdapterInterfaceImpl::OpenCaptureDevice(const AudioDeviceDescriptor return DH_SUCCESS; } -int32_t AudioAdapterInterfaceImpl::CloseCaptureDevice(const AudioDeviceDescriptor &desc) +int32_t AudioAdapterInterfaceImpl::CloseCaptureDevice(const AudioDeviceDescriptor &desc, + const sptr extMicCallback, const int32_t dhId) { - DHLOGI("Close capture device, pin: %d.", desc.pins); + DHLOGI("Close capture device, pin: %d.", dhId); std::lock_guard devLck(captureOptMtx_); if (micPinInUse_ == 0) { DHLOGI("No need close capture device."); return DH_SUCCESS; } captureParam_ = {}; - int32_t ret = extMicCallback_->CloseDevice(adpDescriptor_.adapterName, desc.pins); + int32_t ret = extMicCallback->CloseDevice(adpDescriptor_.adapterName, dhId); if (ret != HDF_SUCCESS) { DHLOGE("Close audio device failed."); return ERR_DH_AUDIO_HDF_CLOSE_DEVICE_FAIL; @@ -666,10 +725,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 +749,16 @@ int32_t AudioAdapterInterfaceImpl::SetAudioVolume(const std::string& condition, { std::lock_guard devLck(renderDevMtx_); - for (auto render : renderDevs_) { - if (render == nullptr) { + for (auto item : renderDevs_) { + std::lock_guard devLck(extCallbackMtx_); + sptr extSpkCallback(extCallbackMap_[item.first]); + SetAudioParamStr(event.content, "dhId", std::to_string(item.first)); + 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 +773,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,14 +816,14 @@ 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."); return ERR_DH_AUDIO_HDF_NULLPTR; } int32_t vol = AUDIO_DEFAULT_MIN_VOLUME_LEVEL; - int32_t ret = GetAudioParamInt(event.content, VOLUME_LEVEL, vol); + int32_t ret = GetVolFromEvent(event.content, VOLUME_LEVEL, vol); if (ret != DH_SUCCESS) { DHLOGE("Get volume value failed."); return ERR_DH_AUDIO_HDF_FAIL; @@ -772,12 +831,12 @@ int32_t AudioAdapterInterfaceImpl::HandleVolumeChangeEvent(const DAudioEvent &ev if (event.content.rfind("FIRST_VOLUME_CHANAGE", 0) == 0) { int32_t maxVol = AUDIO_DEFAULT_MAX_VOLUME_LEVEL; - ret = GetAudioParamInt(event.content, MAX_VOLUME_LEVEL, maxVol); + ret = GetVolFromEvent(event.content, MAX_VOLUME_LEVEL, maxVol); if (ret != DH_SUCCESS) { DHLOGE("Get max volume value failed, use defult max volume."); } int32_t minVol = AUDIO_DEFAULT_MIN_VOLUME_LEVEL; - ret = GetAudioParamInt(event.content, MIN_VOLUME_LEVEL, minVol); + ret = GetVolFromEvent(event.content, MIN_VOLUME_LEVEL, minVol); if (ret != DH_SUCCESS) { DHLOGE("Get min volume value failed, use defult min volume."); } @@ -802,6 +861,19 @@ int32_t AudioAdapterInterfaceImpl::HandleVolumeChangeEvent(const DAudioEvent &ev return DH_SUCCESS; } +int32_t AudioAdapterInterfaceImpl::GetVolFromEvent(const std::string &content, const std::string &key, int32_t &vol) +{ + cJSON *jParam = cJSON_Parse(content.c_str()); + if (jParam == nullptr) { + DHLOGE("Failed to parse JSON: %s", cJSON_GetErrorPtr()); + cJSON_Delete(jParam); + return ERR_DH_AUDIO_HDF_FAIL; + } + vol = std::stoi(std::string(cJSON_GetObjectItem(jParam, key.c_str())->valuestring)); + cJSON_Delete(jParam); + return DH_SUCCESS; +} + int32_t AudioAdapterInterfaceImpl::HandleFocusChangeEvent(const DAudioEvent &event) { DHLOGI("Focus change (%s).", event.content.c_str()); @@ -986,7 +1058,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; } @@ -1000,7 +1072,7 @@ bool AudioAdapterInterfaceImpl::CheckCapsValid() { std::lock_guard devLck(capDevMtx_); for (uint32_t i = 0; i < MAX_AUDIO_STREAM_NUM; i++) { - if (captureDevs_[i] != nullptr) { + if (captureDevs_[i].second != nullptr) { DHLOGI("Containing active capture."); return true; } @@ -1013,7 +1085,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; } @@ -1021,7 +1094,8 @@ void AudioAdapterInterfaceImpl::SetDumpFlag(bool isRender) } } else { std::lock_guard capLck(capDevMtx_); - for (auto capture : captureDevs_) { + for (auto item : captureDevs_) { + auto capture = item.second; if (capture == 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..89962585c9930f5998fa9eca2f35fc71f1888b66 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 @@ -20,6 +20,8 @@ #include "sys/time.h" #include +#include "cJSON.h" + #include "daudio_constants.h" #include "daudio_events.h" #include "daudio_log.h" @@ -36,8 +38,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; @@ -110,7 +111,22 @@ int32_t AudioCaptureInterfaceImpl::CaptureFrame(std::vector &frame, uint int32_t AudioCaptureInterfaceImpl::Start() { DHLOGI("Start capture."); - DAudioEvent event = { HDF_AUDIO_EVENT_START, "" }; + 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()); + char *jsonData = cJSON_PrintUnformatted(jParam); + if (jsonData == nullptr) { + DHLOGE("Failed to create JSON data."); + cJSON_Delete(jParam); + return HDF_FAILURE; + } + std::string content(jsonData); + cJSON_Delete(jParam); + cJSON_free(jsonData); + DAudioEvent event = { HDF_AUDIO_EVENT_START, content }; if (audioExtCallback_ == nullptr) { DHLOGE("Callback is nullptr."); return HDF_FAILURE; @@ -129,7 +145,22 @@ int32_t AudioCaptureInterfaceImpl::Start() int32_t AudioCaptureInterfaceImpl::Stop() { DHLOGI("Stop capture."); - DAudioEvent event = { HDF_AUDIO_EVENT_STOP, "" }; + 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()); + char *jsonData = cJSON_PrintUnformatted(jParam); + if (jsonData == nullptr) { + DHLOGE("Failed to create JSON data."); + cJSON_Delete(jParam); + return HDF_FAILURE; + } + cJSON_Delete(jParam); + cJSON_free(jsonData); + std::string content(jsonData); + DAudioEvent event = { HDF_AUDIO_EVENT_STOP, content }; if (audioExtCallback_ == nullptr) { DHLOGE("Callback is nullptr."); return HDF_FAILURE; 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..01d6afde1ddb3055e9260d6f93706c8d78a3a4a2 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: @@ -234,11 +234,12 @@ int32_t AudioManagerInterfaceImpl::NotifyFwk(const DAudioDevEvent &event) int32_t AudioManagerInterfaceImpl::CreateAdapter(const std::string &adpName, const uint32_t devId, const sptr &callback) { + DHLOGI("Create adapter, pin id: %d.", devId); if (callback == nullptr) { DHLOGE("Adapter callback is null."); return ERR_DH_AUDIO_HDF_NULLPTR; } - if (devId != PIN_OUT_DAUDIO_DEFAULT && devId != PIN_IN_DAUDIO_DEFAULT) { + if (devId != DEFAULT_RENDER_ID && devId != DEFAULT_CAPTURE_ID && devId != LOW_LATENCY_RENDER_ID) { DHLOGE("Pin is not default, can not create audio adapter."); return ERR_DH_AUDIO_HDF_FAIL; } 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..b4747ed0098791244cfe09750c1d9d0f8196a0a8 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,23 @@ 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); + if (jsonData == nullptr) { + DHLOGE("Failed to create JSON data."); + cJSON_Delete(jParam); + return HDF_FAILURE; + } + std::string content(jsonData); + cJSON_Delete(jParam); + cJSON_free(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 +225,23 @@ 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."); + cJSON_Delete(jParam); + return HDF_FAILURE; + } + std::string content(jsonData); + cJSON_Delete(jParam); + cJSON_free(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/audio/v1_0/test/unittest/audio_adapter_interface/src/audio_adapter_interface_impl_test.cpp b/hdf_service/distributed_audio/hdi_service/audio/v1_0/test/unittest/audio_adapter_interface/src/audio_adapter_interface_impl_test.cpp index c5b38b4e33fc36a927ca977db9087faffffe4964..e79d276660c72dfdc1a438bd40135f251214e9b9 100644 --- a/hdf_service/distributed_audio/hdi_service/audio/v1_0/test/unittest/audio_adapter_interface/src/audio_adapter_interface_impl_test.cpp +++ b/hdf_service/distributed_audio/hdi_service/audio/v1_0/test/unittest/audio_adapter_interface/src/audio_adapter_interface_impl_test.cpp @@ -26,6 +26,8 @@ namespace HDI { namespace DistributedAudio { namespace Audio { namespace V1_0 { +static constexpr int32_t DEFAULT_CAPTURE_ID = 1 << 27 | 1 << 0; + void AudioAdapterInterfaceImpTest::SetUpTestCase(void) {} void AudioAdapterInterfaceImpTest::TearDownTestCase(void) {} @@ -50,14 +52,18 @@ void AudioAdapterInterfaceImpTest::TearDown(void) HWTEST_F(AudioAdapterInterfaceImpTest, InitAllPorts_001, TestSize.Level1) { sptr speakerCallback = nullptr; - AdapterTest_->SetSpeakerCallback(speakerCallback); + int32_t dhId = 1; + AdapterTest_->SetSpeakerCallback(dhId, speakerCallback); + AdapterTest_->extCallbackMap_.erase(dhId); speakerCallback = new MockIDAudioCallback(); - AdapterTest_->SetSpeakerCallback(speakerCallback); + AdapterTest_->SetSpeakerCallback(dhId, speakerCallback); + dhId = DEFAULT_CAPTURE_ID; sptr micCallback = nullptr; - AdapterTest_->SetMicCallback(micCallback); + AdapterTest_->SetMicCallback(dhId, micCallback); + AdapterTest_->extCallbackMap_.erase(dhId); micCallback = new MockIDAudioCallback(); - AdapterTest_->SetMicCallback(micCallback); + AdapterTest_->SetMicCallback(dhId, micCallback); EXPECT_EQ(HDF_SUCCESS, AdapterTest_->InitAllPorts()); } @@ -74,7 +80,8 @@ HWTEST_F(AudioAdapterInterfaceImpTest, CreateRender_001, TestSize.Level1) AudioSampleAttributes attrs; sptr render = nullptr; uint32_t renderId = 0; - AdapterTest_->extSpkCallback_ = new MockIDAudioCallback(); + int32_t dhId = 1; + AdapterTest_->extCallbackMap_[dhId] = new MockIDAudioCallback(); EXPECT_NE(HDF_SUCCESS, AdapterTest_->CreateRender(devDesc, attrs, render, renderId)); EXPECT_EQ(HDF_SUCCESS, AdapterTest_->DestroyRender(renderId)); @@ -95,12 +102,14 @@ HWTEST_F(AudioAdapterInterfaceImpTest, DestroyRender_001, TestSize.Level1) AudioDeviceDescriptor devDesc; AudioSampleAttributes attrs; std::string adpterName = "adbcef"; + int32_t dhId = 1; sptr callback = new MockIDAudioCallback(); - AdapterTest_->extSpkCallback_ = new MockRevertIDAudioCallback(); + AdapterTest_->extCallbackMap_[dhId] = new MockRevertIDAudioCallback(); devDesc.pins = PIN_OUT_DAUDIO_DEFAULT; uint32_t renderId = 0; - AdapterTest_->renderDevs_[renderId] = new AudioRenderInterfaceImpl(adpterName, devDesc, attrs, callback); + AdapterTest_->renderDevs_[renderId] = std::make_pair(dhId, + new AudioRenderInterfaceImpl(adpterName, devDesc, attrs, callback)); AdapterTest_->spkPinInUse_ = 0; EXPECT_EQ(HDF_SUCCESS, AdapterTest_->DestroyRender(renderId)); @@ -122,7 +131,8 @@ HWTEST_F(AudioAdapterInterfaceImpTest, CreateCapture_001, TestSize.Level1) AudioSampleAttributes attrs; sptr capture = nullptr; uint32_t capId = 0; - AdapterTest_->extMicCallback_ = new MockIDAudioCallback(); + int32_t dhId = DEFAULT_CAPTURE_ID; + AdapterTest_->extCallbackMap_[dhId] = new MockIDAudioCallback(); EXPECT_NE(HDF_SUCCESS, AdapterTest_->CreateCapture(devDesc, attrs, capture, capId)); EXPECT_EQ(HDF_SUCCESS, AdapterTest_->DestroyCapture(capId)); @@ -144,11 +154,13 @@ HWTEST_F(AudioAdapterInterfaceImpTest, DestroyCapture_001, TestSize.Level1) AudioSampleAttributes attrs; std::string adpterName = "adbcef"; sptr callback = new MockIDAudioCallback(); - AdapterTest_->extMicCallback_ = new MockRevertIDAudioCallback(); + int32_t dhId = DEFAULT_CAPTURE_ID; + AdapterTest_->extCallbackMap_[dhId] = new MockRevertIDAudioCallback(); devDesc.pins = PIN_OUT_DAUDIO_DEFAULT; uint32_t capId = 0; - AdapterTest_->captureDevs_[capId] = new AudioCaptureInterfaceImpl(adpterName, devDesc, attrs, callback); + AdapterTest_->captureDevs_[capId] = std::make_pair(dhId, + new AudioCaptureInterfaceImpl(adpterName, devDesc, attrs, callback)); EXPECT_EQ(HDF_SUCCESS, AdapterTest_->DestroyCapture(capId)); capId = 10; @@ -430,20 +442,28 @@ HWTEST_F(AudioAdapterInterfaceImpTest, AdapterUnload_001, TestSize.Level1) std::string adpterName = "adbcef"; AudioDeviceDescriptor descSpk; AudioSampleAttributes attrsSpk; + int32_t dhId = 1; sptr callbackSpk = new MockIDAudioCallback(); - AdapterTest_->renderDevs_[0] = new AudioRenderInterfaceImpl(adpterName, descSpk, attrsSpk, callbackSpk); + AdapterTest_->SetSpeakerCallback(dhId, callbackSpk); + AdapterTest_->renderDevs_[0] = std::make_pair(dhId, + new AudioRenderInterfaceImpl(adpterName, descSpk, attrsSpk, callbackSpk)); EXPECT_EQ(HDF_ERR_DEVICE_BUSY, AdapterTest_->AdapterUnload()); AudioDeviceDescriptor devDescMic; AudioSampleAttributes attrsMic; + dhId = DEFAULT_CAPTURE_ID; sptr callbackMic = new MockIDAudioCallback(); - AdapterTest_->captureDevs_[0] = new AudioCaptureInterfaceImpl(adpterName, devDescMic, attrsMic, callbackMic); + AdapterTest_->SetMicCallback(dhId, callbackMic); + AdapterTest_->captureDevs_[0] = std::make_pair(dhId, + new AudioCaptureInterfaceImpl(adpterName, devDescMic, attrsMic, callbackMic)); EXPECT_EQ(HDF_ERR_DEVICE_BUSY, AdapterTest_->AdapterUnload()); - AdapterTest_->renderDevs_[0] = nullptr; + AdapterTest_->renderDevs_[0].first = 0; + AdapterTest_->renderDevs_[0].second = nullptr; EXPECT_EQ(HDF_ERR_DEVICE_BUSY, AdapterTest_->AdapterUnload()); - AdapterTest_->captureDevs_[0] = nullptr; + AdapterTest_->captureDevs_[0].first = 0; + AdapterTest_->captureDevs_[0].second = nullptr; EXPECT_EQ(HDF_SUCCESS, AdapterTest_->AdapterUnload()); } @@ -568,10 +588,13 @@ HWTEST_F(AudioAdapterInterfaceImpTest, OpenRenderDevice_001, TestSize.Level1) { AudioDeviceDescriptor devDesc; AudioSampleAttributes attrs; - AdapterTest_->extSpkCallback_ = new MockIDAudioCallback(); - EXPECT_NE(HDF_SUCCESS, AdapterTest_->OpenRenderDevice(devDesc, attrs)); + int32_t dhId = 1; + AdapterTest_->extCallbackMap_[dhId] = new MockIDAudioCallback(); + EXPECT_NE(HDF_SUCCESS, AdapterTest_->OpenRenderDevice(devDesc, attrs, + AdapterTest_->extCallbackMap_[dhId], dhId)); AdapterTest_->isSpkOpened_ = true; - EXPECT_EQ(HDF_SUCCESS, AdapterTest_->OpenRenderDevice(devDesc, attrs)); + EXPECT_EQ(HDF_SUCCESS, AdapterTest_->OpenRenderDevice(devDesc, attrs, + AdapterTest_->extCallbackMap_[dhId], dhId)); } /** * @tc.name: OpenRenderDevice_002 @@ -583,9 +606,11 @@ HWTEST_F(AudioAdapterInterfaceImpTest, OpenRenderDevice_002, TestSize.Level1) { AudioDeviceDescriptor devDesc; AudioSampleAttributes attrs; - AdapterTest_->extSpkCallback_ = new MockRevertIDAudioCallback(); + int32_t dhId = 1; + AdapterTest_->extCallbackMap_[dhId] = new MockRevertIDAudioCallback(); AdapterTest_->isSpkOpened_ = false; - EXPECT_NE(HDF_SUCCESS, AdapterTest_->OpenRenderDevice(devDesc, attrs)); + EXPECT_NE(HDF_SUCCESS, AdapterTest_->OpenRenderDevice(devDesc, attrs, + AdapterTest_->extCallbackMap_[dhId], dhId)); } /** @@ -597,13 +622,15 @@ HWTEST_F(AudioAdapterInterfaceImpTest, OpenRenderDevice_002, TestSize.Level1) HWTEST_F(AudioAdapterInterfaceImpTest, CloseRenderDevice_001, TestSize.Level1) { AudioDeviceDescriptor devDesc; + int32_t dhId = 1; + sptr callback(nullptr); AdapterTest_->spkPinInUse_ = 0; - EXPECT_EQ(HDF_SUCCESS, AdapterTest_->CloseRenderDevice(devDesc)); + EXPECT_EQ(HDF_SUCCESS, AdapterTest_->CloseRenderDevice(devDesc, callback, dhId)); AdapterTest_->spkPinInUse_ = 1; - AdapterTest_->extSpkCallback_ = new MockIDAudioCallback(); - EXPECT_EQ(HDF_SUCCESS, AdapterTest_->CloseRenderDevice(devDesc)); - AdapterTest_->extSpkCallback_ = new MockRevertIDAudioCallback(); - EXPECT_EQ(HDF_SUCCESS, AdapterTest_->CloseRenderDevice(devDesc)); + callback = new MockIDAudioCallback(); + EXPECT_EQ(HDF_SUCCESS, AdapterTest_->CloseRenderDevice(devDesc, callback, dhId)); + callback = new MockRevertIDAudioCallback(); + EXPECT_EQ(HDF_SUCCESS, AdapterTest_->CloseRenderDevice(devDesc, callback, dhId)); } /** @@ -616,10 +643,11 @@ HWTEST_F(AudioAdapterInterfaceImpTest, OpenCaptureDevice_001, TestSize.Level1) { AudioDeviceDescriptor devDesc; AudioSampleAttributes attrs; - AdapterTest_->extMicCallback_ = new MockIDAudioCallback(); - EXPECT_NE(HDF_SUCCESS, AdapterTest_->OpenCaptureDevice(devDesc, attrs)); + int32_t dhId = DEFAULT_CAPTURE_ID; + sptr callback(new MockIDAudioCallback()); + EXPECT_NE(HDF_SUCCESS, AdapterTest_->OpenCaptureDevice(devDesc, attrs, callback, dhId)); AdapterTest_->isMicOpened_ = true; - EXPECT_EQ(HDF_SUCCESS, AdapterTest_->OpenCaptureDevice(devDesc, attrs)); + EXPECT_EQ(HDF_SUCCESS, AdapterTest_->OpenCaptureDevice(devDesc, attrs, callback, dhId)); } /** @@ -631,10 +659,11 @@ HWTEST_F(AudioAdapterInterfaceImpTest, OpenCaptureDevice_001, TestSize.Level1) HWTEST_F(AudioAdapterInterfaceImpTest, CloseCaptureDevice_001, TestSize.Level1) { AudioDeviceDescriptor devDesc; - AdapterTest_->extMicCallback_ = new MockIDAudioCallback(); - EXPECT_EQ(HDF_SUCCESS, AdapterTest_->CloseCaptureDevice(devDesc)); + int32_t dhId = DEFAULT_CAPTURE_ID; + sptr callback(new MockIDAudioCallback()); + EXPECT_EQ(HDF_SUCCESS, AdapterTest_->CloseCaptureDevice(devDesc, callback, dhId)); AdapterTest_->micPinInUse_ = 1; - EXPECT_EQ(HDF_SUCCESS, AdapterTest_->CloseCaptureDevice(devDesc)); + EXPECT_EQ(HDF_SUCCESS, AdapterTest_->CloseCaptureDevice(devDesc, callback, dhId)); } /** @@ -646,8 +675,8 @@ HWTEST_F(AudioAdapterInterfaceImpTest, CloseCaptureDevice_001, TestSize.Level1) HWTEST_F(AudioAdapterInterfaceImpTest, GetVolumeGroup_001, TestSize.Level1) { uint32_t devId = 88; - - AdapterTest_->extMicCallback_ = new MockIDAudioCallback(); + int32_t dhId = DEFAULT_CAPTURE_ID; + AdapterTest_->extCallbackMap_[dhId] = new MockIDAudioCallback(); EXPECT_EQ(0, AdapterTest_->GetVolumeGroup(devId)); } @@ -660,8 +689,9 @@ HWTEST_F(AudioAdapterInterfaceImpTest, GetVolumeGroup_001, TestSize.Level1) HWTEST_F(AudioAdapterInterfaceImpTest, GetInterruptGroup_001, TestSize.Level1) { uint32_t devId = 88; + int32_t dhId = 1; - AdapterTest_->extMicCallback_ = new MockIDAudioCallback(); + AdapterTest_->extCallbackMap_[dhId] = new MockIDAudioCallback(); EXPECT_EQ(0, AdapterTest_->GetInterruptGroup(devId)); } @@ -675,15 +705,17 @@ HWTEST_F(AudioAdapterInterfaceImpTest, SetAudioVolume_001, TestSize.Level1) { std::string condition = "EVENT_TYPE=4;VOLUME_GROUP_ID=2;AUDIO_VOLUME_TYPE=1;"; std::string param = "1"; + int32_t dhId = 1; EXPECT_NE(HDF_SUCCESS, AdapterTest_->SetAudioVolume(condition, param)); - AdapterTest_->extSpkCallback_ = new MockIDAudioCallback(); + AdapterTest_->extCallbackMap_[dhId] = new MockIDAudioCallback(); EXPECT_EQ(HDF_SUCCESS, AdapterTest_->SetAudioVolume(condition, param)); std::string adpterName = "adbcef"; AudioDeviceDescriptor desc; AudioSampleAttributes attrs; sptr callback = new MockIDAudioCallback(); - AdapterTest_->renderDevs_[0] = new AudioRenderInterfaceImpl(adpterName, desc, attrs, callback); + AdapterTest_->renderDevs_[0] = std::make_pair(dhId, + new AudioRenderInterfaceImpl(adpterName, desc, attrs, callback)); EXPECT_EQ(HDF_SUCCESS, AdapterTest_->SetAudioVolume(condition, param)); param = "0"; EXPECT_EQ(HDF_SUCCESS, AdapterTest_->SetAudioVolume(condition, param)); @@ -704,9 +736,11 @@ HWTEST_F(AudioAdapterInterfaceImpTest, GetAudioVolume_001, TestSize.Level1) std::string adpterName = "adbcef"; AudioDeviceDescriptor desc; AudioSampleAttributes attrs; + int32_t dhId = 1; sptr callback = new MockIDAudioCallback(); - AdapterTest_->renderDevs_[0] = new AudioRenderInterfaceImpl(adpterName, desc, attrs, callback); + AdapterTest_->renderDevs_[0] = std::make_pair(dhId, + new AudioRenderInterfaceImpl(adpterName, desc, attrs, callback)); std::string condition = "EVENT_TYPE=1;VOLUME_GROUP_ID=2;AUDIO_VOLUME_TYPE=1;"; std::string param = "1"; @@ -724,9 +758,11 @@ HWTEST_F(AudioAdapterInterfaceImpTest, GetAudioVolume_002, TestSize.Level1) std::string adpterName = "adbcef"; AudioDeviceDescriptor desc; AudioSampleAttributes attrs; + int32_t dhId = 1; sptr callback = new MockIDAudioCallback(); - AdapterTest_->renderDevs_[0] = new AudioRenderInterfaceImpl(adpterName, desc, attrs, callback); + AdapterTest_->renderDevs_[0] = std::make_pair(dhId, + new AudioRenderInterfaceImpl(adpterName, desc, attrs, callback)); std::string condition = "EVENT_TYPE=3;VOLUME_GROUP_ID=2;AUDIO_VOLUME_TYPE=1;"; std::string param = "1"; @@ -744,9 +780,11 @@ HWTEST_F(AudioAdapterInterfaceImpTest, GetAudioVolume_003, TestSize.Level1) std::string adpterName = "adbcef"; AudioDeviceDescriptor desc; AudioSampleAttributes attrs; + int32_t dhId = 1; sptr callback = new MockIDAudioCallback(); - AdapterTest_->renderDevs_[0] = new AudioRenderInterfaceImpl(adpterName, desc, attrs, callback); + AdapterTest_->renderDevs_[0] = std::make_pair(dhId, + new AudioRenderInterfaceImpl(adpterName, desc, attrs, callback)); std::string condition = "EVENT_TYPE=2;VOLUME_GROUP_ID=2;AUDIO_VOLUME_TYPE=1;"; std::string param = "1"; @@ -764,9 +802,11 @@ HWTEST_F(AudioAdapterInterfaceImpTest, GetAudioVolume_004, TestSize.Level1) std::string adpterName = "adbcef"; AudioDeviceDescriptor desc; AudioSampleAttributes attrs; + int32_t dhId = 1; sptr callback = new MockIDAudioCallback(); - AdapterTest_->renderDevs_[0] = new AudioRenderInterfaceImpl(adpterName, desc, attrs, callback); + AdapterTest_->renderDevs_[0] = std::make_pair(dhId, + new AudioRenderInterfaceImpl(adpterName, desc, attrs, callback)); std::string condition = "EVENT_TYPE=4;VOLUME_GROUP_ID=2;AUDIO_VOLUME_TYPE=1;"; std::string param = "1"; @@ -785,9 +825,11 @@ HWTEST_F(AudioAdapterInterfaceImpTest, GetAudioVolume_005, TestSize.Level1) std::string adpterName = "adbcef"; AudioDeviceDescriptor desc; AudioSampleAttributes attrs; + int32_t dhId = 0; sptr callback = new MockIDAudioCallback(); - AdapterTest_->renderDevs_[0] = new AudioRenderInterfaceImpl(adpterName, desc, attrs, callback); + AdapterTest_->renderDevs_[0] = std::make_pair(dhId, + new AudioRenderInterfaceImpl(adpterName, desc, attrs, callback)); std::string condition = "EVENT_TYPE=66;VOLUME_GROUP_ID=2;AUDIO_VOLUME_TYPE=1;"; std::string param = "1"; @@ -803,7 +845,7 @@ HWTEST_F(AudioAdapterInterfaceImpTest, GetAudioVolume_005, TestSize.Level1) */ HWTEST_F(AudioAdapterInterfaceImpTest, GetAudioVolume_006, TestSize.Level1) { - AdapterTest_->renderDevs_[0] = nullptr; + AdapterTest_->renderDevs_[0] = std::make_pair(1, nullptr); std::string condition = "EVENT_TYPE=1;VOLUME_GROUP_ID=2;AUDIO_VOLUME_TYPE=1;"; std::string param = "1"; @@ -850,12 +892,14 @@ HWTEST_F(AudioAdapterInterfaceImpTest, HandleVolumeChangeEvent_001, TestSize.Lev std::string adpterName = "adbcef"; AudioDeviceDescriptor desc; AudioSampleAttributes attrs; + int32_t dhId = 1; sptr callback = new MockIDAudioCallback(); - AdapterTest_->renderDevs_[0] = nullptr; + AdapterTest_->renderDevs_[0] = std::make_pair(dhId, nullptr); EXPECT_NE(HDF_SUCCESS, AdapterTest_->HandleVolumeChangeEvent(event)); - AdapterTest_->renderDevs_[0] = new AudioRenderInterfaceImpl(adpterName, desc, attrs, callback); + AdapterTest_->renderDevs_[0] = std::make_pair(dhId, + new AudioRenderInterfaceImpl(adpterName, desc, attrs, callback)); EXPECT_NE(HDF_SUCCESS, AdapterTest_->HandleVolumeChangeEvent(event)); AdapterTest_->paramCallback_ = new MockIAudioParamCallback(); EXPECT_EQ(HDF_SUCCESS, AdapterTest_->HandleVolumeChangeEvent(event)); @@ -873,9 +917,11 @@ HWTEST_F(AudioAdapterInterfaceImpTest, HandleVolumeChangeEvent_002, TestSize.Lev std::string adpterName = "adbcef"; AudioDeviceDescriptor desc; AudioSampleAttributes attrs; + int32_t dhId = 1; sptr callback = new MockIDAudioCallback(); - AdapterTest_->renderDevs_[0] = new AudioRenderInterfaceImpl(adpterName, desc, attrs, callback); + AdapterTest_->renderDevs_[0] = std::make_pair(dhId, + new AudioRenderInterfaceImpl(adpterName, desc, attrs, callback)); EXPECT_NE(HDF_SUCCESS, AdapterTest_->HandleVolumeChangeEvent(event)); } @@ -891,9 +937,11 @@ HWTEST_F(AudioAdapterInterfaceImpTest, HandleVolumeChangeEvent_003, TestSize.Lev std::string adpterName = "adbcef"; AudioDeviceDescriptor desc; AudioSampleAttributes attrs; + int32_t dhId = 1; sptr callback = new MockIDAudioCallback(); - AdapterTest_->renderDevs_[0] = new AudioRenderInterfaceImpl(adpterName, desc, attrs, callback); + AdapterTest_->renderDevs_[0] = std::make_pair(dhId, + new AudioRenderInterfaceImpl(adpterName, desc, attrs, callback)); EXPECT_NE(HDF_SUCCESS, AdapterTest_->HandleVolumeChangeEvent(event)); } 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..563bfb9e56026ce1305ba8685d691f49b8d67af7 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,11 @@ 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"; +static constexpr int32_t LOW_LATENCY_RENDER_ID = 1 << 1 | 1 << 0; +static constexpr int32_t DEFAULT_RENDER_ID = 1; +static constexpr int32_t DEFAULT_CAPTURE_ID = 1 << 27 | 1 << 0; } // DistributeHardware } // OHOS #endif // OHOS_DAUDIO_CONSTANTS_H diff --git a/services/audioclient/micclient/include/dmic_client.h b/services/audioclient/micclient/include/dmic_client.h index d483980102b49148b062f00b2332ca64d35f3725..6903946f73fe77b9b6f1b64d03605559248f7016 100644 --- a/services/audioclient/micclient/include/dmic_client.h +++ b/services/audioclient/micclient/include/dmic_client.h @@ -50,8 +50,8 @@ class DMicClient : public IAudioDataTransCallback, public IMicClient, public AVSenderTransportCallback, public std::enable_shared_from_this { public: - DMicClient(const std::string &devId, const std::shared_ptr &callback) - : devId_(devId), eventCallback_(callback) {}; + DMicClient(const std::string &devId, const int32_t dhId, const std::shared_ptr &callback) + : devId_(devId), dhId_(dhId), eventCallback_(callback) {}; ~DMicClient() override; int32_t OnStateChange(const AudioEventType type) override; int32_t OnDecodeTransDataDone(const std::shared_ptr &audioData) override; @@ -94,6 +94,7 @@ private: const std::string FILE_NAME = "/data/sink_mic_send.pcm"; std::string devId_; + int32_t dhId_; std::thread captureDataThread_; AudioParam audioParam_; std::atomic isBlocking_ = false; diff --git a/services/audioclient/micclient/src/dmic_client.cpp b/services/audioclient/micclient/src/dmic_client.cpp index 99d89382854ccae115b04067b9bbade19d94f627..4e510b4b23cdb85738fc2e4669f0582a06d8fe6e 100644 --- a/services/audioclient/micclient/src/dmic_client.cpp +++ b/services/audioclient/micclient/src/dmic_client.cpp @@ -17,6 +17,8 @@ #include +#include "cJSON.h" + #include "daudio_constants.h" #include "daudio_hisysevent.h" #include "daudio_sink_hidumper.h" @@ -75,7 +77,21 @@ int32_t DMicClient::OnStateChange(const AudioEventType type) { DHLOGD("On state change type: %d.", type); AudioEvent event; - event.content = ""; + cJSON *jParam = cJSON_CreateObject(); + if (jParam == nullptr) { + DHLOGE("Failed to create cJSON object."); + return ERR_DH_AUDIO_NULLPTR; + } + cJSON_AddStringToObject(jParam, KEY_DH_ID, std::to_string(dhId_).c_str()); + char *jsonData = cJSON_PrintUnformatted(jParam); + if (jsonData == nullptr) { + DHLOGE("Failed to create JSON data."); + cJSON_Delete(jParam); + return ERR_DH_AUDIO_NULLPTR; + } + event.content = std::string(jsonData); + cJSON_Delete(jParam); + cJSON_free(jsonData); switch (type) { case AudioEventType::DATA_OPENED: { isBlocking_.store(true); 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..3ebf9b42eae67ee993e1293faff1a4824ec2da49 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,33 @@ 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); + if (jsonData == nullptr) { + DHLOGE("Failed to create JSON data."); + cJSON_Delete(jParam); + return ""; + } + std::string str(jsonData); + cJSON_Delete(jParam); + cJSON_free(jsonData); DHLOGD("Get the volume level result, event: %s.", str.c_str()); return str; } @@ -424,13 +439,26 @@ 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); + if (jsonData == nullptr) { + DHLOGE("Failed to create JSON data."); + cJSON_Delete(jParam); + return; + } + std::string str(jsonData); + cJSON_Delete(jParam); + cJSON_free(jsonData); DHLOGD("Volume change notification result, event: %s.", str.c_str()); AudioEvent audioEvent(VOLUME_CHANGE, str); @@ -445,12 +473,25 @@ 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); + if (jsonData == nullptr) { + DHLOGE("Failed to create JSON data."); + cJSON_Delete(jParam); + return; + } + std::string str(jsonData); + cJSON_Delete(jParam); + cJSON_free(jsonData); DHLOGD("Audio focus oninterrupt notification result, event: %s.", str.c_str()); AudioEvent audioEvent(AUDIO_FOCUS_CHANGE, str); @@ -466,10 +507,23 @@ 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); + if (jsonData == nullptr) { + DHLOGE("Failed to create JSON data."); + cJSON_Delete(jParam); + return; + } + std::string str(jsonData); + cJSON_Delete(jParam); + cJSON_free(jsonData); DHLOGD("Audio render state changes notification result, event: %s.", str.c_str()); AudioEvent audioEvent(AUDIO_RENDER_STATE_CHANGE, str); diff --git a/services/audioclient/test/unittest/micclient/src/dmic_client_test.cpp b/services/audioclient/test/unittest/micclient/src/dmic_client_test.cpp index 99de93227a82b898e44f13ddc5dbf5c6bd16121b..503f1c2057b33c087a5cfa67a2c69e1a943b6b6a 100644 --- a/services/audioclient/test/unittest/micclient/src/dmic_client_test.cpp +++ b/services/audioclient/test/unittest/micclient/src/dmic_client_test.cpp @@ -28,8 +28,9 @@ void DMicClientTest::TearDownTestCase(void) {} void DMicClientTest::SetUp() { std::string devId = "hello"; + int32_t dhId = DEFAULT_CAPTURE_ID; clientCallback_ = std::make_shared(); - micClient_ = std::make_shared(devId, clientCallback_); + micClient_ = std::make_shared(devId, dhId, clientCallback_); micClient_->micTrans_ = std::make_shared(); audioParam_.comParam.codecType = AudioCodecType::AUDIO_CODEC_AAC; diff --git a/services/audioclient/test/unittest/spkclient/src/dspeaker_client_test.cpp b/services/audioclient/test/unittest/spkclient/src/dspeaker_client_test.cpp index b9747a73cfce679420664ff0dcc93455dc1204bc..2be8ceee0c5d47a82fda92ba3099bc84e0c119ce 100644 --- a/services/audioclient/test/unittest/spkclient/src/dspeaker_client_test.cpp +++ b/services/audioclient/test/unittest/spkclient/src/dspeaker_client_test.cpp @@ -31,8 +31,9 @@ void DSpeakerClientTest::TearDownTestCase(void) {} void DSpeakerClientTest::SetUp() { std::string devId = "hello"; + const int32_t dhId = 1; clientCallback_ = std::make_shared(); - speakerClient_ = std::make_shared(devId, clientCallback_); + speakerClient_ = std::make_shared(devId, dhId, clientCallback_); speakerClient_->speakerTrans_ = std::make_shared(); audioParam_.comParam.codecType = AudioCodecType::AUDIO_CODEC_AAC; 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 905a7b0b5b654db181f7f706fb78e5f531c6129b..bbb1d1ac27b37225a981ff3b3c4b1fd63e6ea682 100644 --- a/services/audiomanager/managersink/include/daudio_sink_dev.h +++ b/services/audiomanager/managersink/include/daudio_sink_dev.h @@ -63,7 +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 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,8 @@ private: int32_t SendAudioEventToRemote(const AudioEvent &event); void JudgeDeviceStatus(); + int32_t ParseDhidFromEvent(std::string args); + private: std::mutex rpcWaitMutex_; std::condition_variable rpcWaitCond_; @@ -87,7 +89,11 @@ private: std::string spkDhId_; std::string micDhId_; std::shared_ptr speakerClient_ = nullptr; + std::mutex spkClientMutex_; + std::map> spkClientMap_; std::shared_ptr micClient_ = nullptr; + std::mutex micClientMutex_; + std::map> micClientMap_; std::shared_ptr audioCtrlMgr_ = nullptr; std::atomic isSpkInUse_ = false; diff --git a/services/audiomanager/managersink/src/daudio_sink_dev.cpp b/services/audiomanager/managersink/src/daudio_sink_dev.cpp index 053b88dbfcf1f9e59bb3b0446872a9a25a6529c0..0b88ce21e5dbb295c6d3571f1c82fa2513e33532 100644 --- a/services/audiomanager/managersink/src/daudio_sink_dev.cpp +++ b/services/audiomanager/managersink/src/daudio_sink_dev.cpp @@ -18,6 +18,8 @@ #include #include +#include "cJSON.h" + #include "daudio_constants.h" #include "daudio_errorcode.h" #include "daudio_log.h" @@ -71,13 +73,19 @@ int32_t DAudioSinkDev::InitAVTransEngines(const ChannelState channelState, IAVEn } if (channelState == ChannelState::MIC_CONTROL_OPENED) { // only supports normal audio channel mode - micClient_ = std::make_shared(devId_, shared_from_this()); - micClient_->InitSenderEngine(providerPtr); + std::lock_guard devLck(micClientMutex_); + micClientMap_[DEFAULT_CAPTURE_ID] = std::make_shared(devId_, DEFAULT_CAPTURE_ID, + shared_from_this()); + micClientMap_[DEFAULT_CAPTURE_ID]->InitSenderEngine(providerPtr); } 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_[LOW_LATENCY_RENDER_ID]->InitReceiverEngine(providerPtr); } return DH_SUCCESS; } @@ -120,7 +128,12 @@ int32_t DAudioSinkDev::TaskOpenDSpeaker(const std::string &args) if (!JsonParamCheck(jParam, { KEY_DH_ID, KEY_AUDIO_PARAM })) { return ERR_DH_AUDIO_FAILED; } - spkDhId_ = jParam[KEY_DH_ID]; + int32_t dhId = std::stoi(std::string(jParam[KEY_DH_ID])); + std::shared_ptr speakerClient = nullptr; + { + std::lock_guard devLck(spkClientMutex_); + speakerClient = spkClientMap_[dhId]; + } AudioParam audioParam; int32_t ret = from_json(jParam[KEY_AUDIO_PARAM], audioParam); if (ret != DH_SUCCESS) { @@ -128,19 +141,19 @@ int32_t DAudioSinkDev::TaskOpenDSpeaker(const std::string &args) return ret; } - if (speakerClient_ == nullptr) { + if (speakerClient == nullptr) { DHLOGE("speaker client should be init by dev."); return ERR_DH_AUDIO_NULLPTR; } - DHLOGI("Open speaker device."); - 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); return ERR_DH_AUDIO_FAILED; } - NotifySourceDev(NOTIFY_OPEN_SPEAKER_RESULT, spkDhId_, ret); + NotifySourceDev(NOTIFY_OPEN_SPEAKER_RESULT, std::to_string(dhId), ret); DHLOGI("Open speaker device task end, notify source ret %d.", ret); isSpkInUse_.store(true); return ret; @@ -148,35 +161,70 @@ 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; + } + std::lock_guard devLck(spkClientMutex_); + 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 (!CJsonParamCheck(jParam, { KEY_DH_ID })) { + DHLOGE("Not found the keys of dhId."); + cJSON_Delete(jParam); + return -1; + } + int32_t dhId = std::stoi(std::string(cJSON_GetObjectItem(jParam, KEY_DH_ID)->valuestring)); + cJSON_Delete(jParam); + DHLOGI("Parsed dhId is: %d.", dhId); + return dhId; +} + +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; + } + std::shared_ptr speakerClient = nullptr; + { + std::lock_guard devLck(spkClientMutex_); + 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; @@ -195,30 +243,33 @@ int32_t DAudioSinkDev::TaskOpenDMic(const std::string &args) if (!JsonParamCheck(jParam, { KEY_DH_ID, KEY_AUDIO_PARAM })) { return ERR_DH_AUDIO_FAILED; } - micDhId_ = jParam[KEY_DH_ID]; AudioParam audioParam; int32_t ret = from_json(jParam[KEY_AUDIO_PARAM], audioParam); if (ret != DH_SUCCESS) { DHLOGE("Get audio param from json failed, error code %d.", ret); return ret; } - if (micClient_ == nullptr) { + int32_t dhId = std::stoi(std::string(jParam[KEY_DH_ID])); + std::shared_ptr micClient = nullptr; + { + std::lock_guard devLck(micClientMutex_); + micClient = micClientMap_[dhId]; + } + if (micClient == nullptr) { DHLOGE("Mic client should be init by dev."); return ERR_DH_AUDIO_NULLPTR; } - do { - ret = micClient_->SetUp(audioParam); - if (ret != DH_SUCCESS) { - DHLOGE("Set up mic failed, ret: %d.", ret); - break; - } - ret = micClient_->StartCapture(); - if (ret != DH_SUCCESS) { - DHLOGE("Start capture failed, ret: %d.", ret); - break; - } - } while (false); - NotifySourceDev(NOTIFY_OPEN_MIC_RESULT, micDhId_, ret); + ret = micClient->SetUp(audioParam); + if (ret != DH_SUCCESS) { + DHLOGE("Set up mic failed, ret: %d.", ret); + return ERR_DH_AUDIO_FAILED; + } + ret = micClient->StartCapture(); + if (ret != DH_SUCCESS) { + DHLOGE("Start capture failed, ret: %d.", ret); + return ERR_DH_AUDIO_FAILED; + } + NotifySourceDev(NOTIFY_OPEN_MIC_RESULT, jParam[KEY_DH_ID], ret); DHLOGI("Open mic device task end, notify source ret %d.", ret); isMicInUse_.store(true); return ret; @@ -226,22 +277,28 @@ int32_t DAudioSinkDev::TaskOpenDMic(const std::string &args) int32_t DAudioSinkDev::TaskCloseDMic(const std::string &args) { - (void)args; DHLOGI("Close mic device."); - if (micClient_ == nullptr) { + int32_t dhId = ParseDhidFromEvent(args); + if (dhId < 0) { + DHLOGE("Failed to parse dhardware id."); + return ERR_DH_AUDIO_FAILED; + } + std::lock_guard devLck(micClientMutex_); + std::shared_ptr micClient = micClientMap_[dhId]; + if (micClient == nullptr) { DHLOGE("Mic client is null or already closed."); return DH_SUCCESS; } - int32_t ret = micClient_->StopCapture(); + int32_t ret = micClient->StopCapture(); if (ret != DH_SUCCESS) { DHLOGE("Stop mic client failed, ret: %d.", ret); } - ret = micClient_->Release(); + ret = micClient->Release(); if (ret != DH_SUCCESS) { DHLOGE("Release mic client failed, ret: %d.", ret); } - micClient_ = nullptr; + micClientMap_.erase(dhId); isMicInUse_.store(false); JudgeDeviceStatus(); DHLOGI("Close mic device task excute success."); @@ -252,22 +309,41 @@ 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; + } + std::shared_ptr speakerClient = nullptr; + { + std::lock_guard devLck(spkClientMutex_); + 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; + } + std::shared_ptr speakerClient = nullptr; + { + std::lock_guard devLck(spkClientMutex_); + speakerClient = spkClientMap_[dhId]; + } + 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; @@ -279,12 +355,22 @@ 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; + } + std::shared_ptr speakerClient = nullptr; + { + std::lock_guard devLck(spkClientMutex_); + 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; @@ -317,11 +403,21 @@ 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; + } + std::shared_ptr speakerClient = nullptr; + { + std::lock_guard devLck(spkClientMutex_); + 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; } @@ -330,11 +426,21 @@ 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; + } + std::shared_ptr speakerClient = nullptr; + { + std::lock_guard devLck(spkClientMutex_); + 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."); @@ -369,18 +475,28 @@ void DAudioSinkDev::NotifySourceDev(const AudioEventType type, const std::string DHLOGE("In new engine mode, ctrl is not allowed."); return; } - if (speakerClient_ != nullptr) { - speakerClient_->SendMessage(static_cast(type), jEvent.dump(), devId_); + std::shared_ptr speakerClient = nullptr; + { + std::lock_guard devLck(spkClientMutex_); + speakerClient = spkClientMap_[std::stoi(dhId)]; + } + if (speakerClient != nullptr) { + speakerClient->SendMessage(static_cast(type), jEvent.dump(), devId_); + } + std::shared_ptr micClient = nullptr; + { + std::lock_guard devLck(micClientMutex_); + micClient = micClientMap_[std::stoi(dhId)]; } - if (micClient_ != nullptr) { - micClient_->SendMessage(static_cast(type), jEvent.dump(), devId_); + if (micClient != nullptr) { + micClient->SendMessage(static_cast(type), jEvent.dump(), devId_); } } int32_t DAudioSinkDev::from_json(const json &j, AudioParam &audioParam) { - if (!JsonParamCheck(j, - { KEY_SAMPLING_RATE, KEY_CHANNELS, KEY_FORMAT, KEY_SOURCE_TYPE, KEY_CONTENT_TYPE, KEY_STREAM_USAGE })) { + if (!JsonParamCheck(j, { KEY_SAMPLING_RATE, KEY_CHANNELS, KEY_FORMAT, + KEY_SOURCE_TYPE, KEY_CONTENT_TYPE, KEY_STREAM_USAGE })) { return ERR_DH_AUDIO_FAILED; } j.at(KEY_SAMPLING_RATE).get_to(audioParam.comParam.sampleRate); @@ -562,7 +678,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..9a2399d96b3a1a7ba54cd1db799cef32b2ef072e --- /dev/null +++ b/services/audiomanager/managersource/include/daudio_io_dev.h @@ -0,0 +1,66 @@ +/* + * 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 "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; + +protected: + const std::string devId_; +}; +} // 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 7e95e46668e6855002191dbef6094134083bd753..3939c1448e70edfe9ee1234b0d38ae824c67b46f 100644 --- a/services/audiomanager/managersource/include/daudio_source_dev.h +++ b/services/audiomanager/managersource/include/daudio_source_dev.h @@ -16,6 +16,7 @@ #ifndef OHOS_DAUDIO_SOURCE_DEV_H #define OHOS_DAUDIO_SOURCE_DEV_H +#include #include #include #include "nlohmann/json.hpp" @@ -23,6 +24,7 @@ #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" @@ -60,6 +62,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(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); @@ -101,7 +104,7 @@ private: int32_t HandleMicMmapStop(const AudioEvent &event); int32_t NotifySinkDev(const AudioEventType type, const json 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); @@ -111,6 +114,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; @@ -124,8 +129,10 @@ 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 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 68d49948b3012b817043f76e1509d11d817c6943..dbfaf776f186bf01bec0ab7f33b46bf95a08c3d1 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" @@ -35,23 +36,24 @@ using json = nlohmann::json; 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; 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); + 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 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; @@ -62,24 +64,26 @@ 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); + + 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; + 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); void EnqueueThread(); void FillJitterQueue(); @@ -93,7 +97,6 @@ private: static constexpr const char* ENQUEUE_THREAD = "micEnqueueTh"; const std::string FILE_NAME = "/data/source_mic_read.pcm"; - 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 0b2f8a5e34f2a0b13d0932288585e87f40f0f217..8b8f88337379cdf7d0b84b23f11a6040f9e55715 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" @@ -34,21 +35,23 @@ using json = nlohmann::json; 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; + 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); + 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 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; @@ -59,34 +62,32 @@ 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 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); void EnqueueThread(); private: static constexpr const char* ENQUEUE_THREAD = "spkEnqueueTh"; const std::string FILE_NAME = "/data/source_spk_write.pcm"; - std::string devId_; std::weak_ptr audioEventCallback_; std::mutex channelWaitMutex_; std::condition_variable channelWaitCond_; diff --git a/services/audiomanager/managersource/src/daudio_source_dev.cpp b/services/audiomanager/managersource/src/daudio_source_dev.cpp index 1ae4cbc03c76c4028c441a9925940a5cb75c3a3c..43349581b72468484a5fb49f21884d5a7fc89002 100644 --- a/services/audiomanager/managersource/src/daudio_source_dev.cpp +++ b/services/audiomanager/managersource/src/daudio_source_dev.cpp @@ -17,6 +17,8 @@ #include +#include "cJSON.h" + #include "daudio_constants.h" #include "daudio_errorcode.h" #include "daudio_hitrace.h" @@ -230,11 +232,32 @@ 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 = ParseDhidFromEvent(event.content); + if (dhId < 0) { + DHLOGE("Failed to parse dhardware id."); + return ERR_DH_AUDIO_FAILED; + } + 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; + } + std::lock_guard devLck(ioDevMtx_); + if (deviceMap_.find(dhId) == deviceMap_.end()) { + DHLOGE("Not find IO device instance."); + return nullptr; } - return speaker_->NotifyHdfAudioEvent(event); + return deviceMap_[dhId]; } int32_t DAudioSourceDev::HandleOpenDMic(const AudioEvent &event) @@ -287,11 +310,17 @@ int32_t DAudioSourceDev::HandleDMicOpened(const AudioEvent &event) int32_t DAudioSourceDev::HandleDMicClosed(const AudioEvent &event) { DHLOGI("Mic device closed."); - if (mic_ == nullptr) { + int32_t dhId = ParseDhidFromEvent(event.content); + if (dhId < 0) { + DHLOGE("Failed to parse dhardware id."); + return ERR_DH_AUDIO_FAILED; + } + auto mic = FindIoDevImpl(event.content); + 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) @@ -343,16 +372,6 @@ int32_t DAudioSourceDev::HandleCloseCtrlTrans(const AudioEvent &event) int32_t DAudioSourceDev::HandleCtrlTransClosed(const AudioEvent &event) { DHLOGI("Control trans closed."); - AudioEvent audioEvent = event; - HandleCloseCtrlTrans(audioEvent); - if (speaker_ != nullptr && speaker_->IsOpened()) { - audioEvent.type = SPEAKER_CLOSED; - HandleDSpeakerClosed(audioEvent); - } - if (mic_ != nullptr && mic_->IsOpened()) { - audioEvent.type = MIC_CLOSED; - HandleDMicClosed(audioEvent); - } return DH_SUCCESS; } @@ -603,22 +622,36 @@ 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) { - if (mic_ == nullptr) { - DHLOGI("Create new mic device."); - mic_ = std::make_shared(devId_, shared_from_this()); + std::lock_guard devLck(ioDevMtx_); + if (deviceMap_.find(dhId) != deviceMap_.end()) { + DHLOGI("The mic device is already enabled."); + return DH_SUCCESS; } DAUDIO_SYNC_TRACE(DAUDIO_ENABLE_MIC); - return mic_->EnableDMic(dhId, attrs); + auto mic = std::make_shared(devId_, shared_from_this()); + if (mic->EnableDevice(dhId, attrs) != DH_SUCCESS) { + DHLOGI("Failed to enable mic device."); + return ERR_DH_AUDIO_FAILED; + } + deviceMap_[dhId] = mic; + return DH_SUCCESS; } void DAudioSourceDev::OnEnableTaskResult(int32_t resultCode, const std::string &result, const std::string &funcName) @@ -665,22 +698,34 @@ 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) { - if (mic_ == nullptr) { + std::lock_guard devLck(ioDevMtx_); + if (deviceMap_.find(dhId) == deviceMap_.end()) { + DHLOGI("The mic device is already disabled."); + return DH_SUCCESS; + } + auto ioDev = deviceMap_[dhId]; + if (ioDev == nullptr) { DHLOGE("Mic device is null."); return ERR_DH_AUDIO_NULLPTR; } DAUDIO_SYNC_TRACE(DAUDIO_DISABLE_MIC); - return mic_->DisableDMic(dhId); + return ioDev->DisableDevice(dhId); } void DAudioSourceDev::OnDisableTaskResult(int32_t resultCode, const std::string &result, const std::string &funcName) @@ -706,9 +751,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; @@ -717,34 +763,66 @@ int32_t DAudioSourceDev::TaskOpenDSpeaker(const std::string &args) if (!JsonParamCheck(jParam, { KEY_DH_ID })) { 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); return ret; } json jAudioParam; - to_json(jAudioParam, speaker_->GetAudioParam()); + to_json(jAudioParam, speaker->GetAudioParam()); ret = NotifySinkDev(OPEN_SPEAKER, jAudioParam, jParam[KEY_DH_ID]); if (ret != DH_SUCCESS) { DHLOGE("Notify sink open speaker failed, error code %d.", ret); return ret; } + int32_t dhId = ParseDhidFromEvent(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); + return ret; + } + return DH_SUCCESS; +} - ret = speaker_->SetUp(); +int32_t DAudioSourceDev::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 (!CJsonParamCheck(jParam, { KEY_DH_ID })) { + DHLOGE("Not found the keys of dhId."); + cJSON_Delete(jParam); + return -1; + } + int32_t dhId = std::stoi(std::string(cJSON_GetObjectItem(jParam, KEY_DH_ID)->valuestring)); + cJSON_Delete(jParam); + DHLOGI("Parsed dhId is: %d.", dhId); + return dhId; +} + +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); return DH_SUCCESS; } @@ -752,17 +830,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()) { json jAudioParam; json jParam = json::parse(args, nullptr, false); if (!JsonParamCheck(jParam, { KEY_DH_ID })) { @@ -787,12 +870,17 @@ int32_t DAudioSourceDev::CloseSpkNew(const std::string &args) } NotifySinkDev(CLOSE_SPEAKER, jAudioParam, jParam[KEY_DH_ID]); 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; @@ -806,9 +894,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()) { @@ -820,18 +914,19 @@ 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; } int32_t DAudioSourceDev::TaskOpenDMic(const std::string &args) { DHLOGI("Task open mic, args: %s.", args.c_str()); - if (mic_ == nullptr) { + auto mic = FindIoDevImpl(args); + if (mic == nullptr) { DHLOGE("Mic device not init"); return ERR_DH_AUDIO_SA_MIC_DEVICE_NOT_INIT; } - int32_t ret = mic_->InitReceiverEngine(DAudioSourceManager::GetInstance().getReceiverProvider()); + int32_t ret = mic->InitReceiverEngine(DAudioSourceManager::GetInstance().getReceiverProvider()); if (ret != DH_SUCCESS) { DHLOGE("Init receiver engine failed."); return ret; @@ -839,7 +934,7 @@ int32_t DAudioSourceDev::TaskOpenDMic(const std::string &args) if (args.length() > DAUDIO_MAX_JSON_LEN || args.empty()) { return ERR_DH_AUDIO_SA_PARAM_INVALID; } - ret = mic_->SetUp(); + ret = mic->SetUp(); if (ret != DH_SUCCESS) { DHLOGE("Mic setup failed."); return ret; @@ -850,40 +945,45 @@ int32_t DAudioSourceDev::TaskOpenDMic(const std::string &args) if (!JsonParamCheck(jParam, { KEY_DH_ID })) { return ERR_DH_AUDIO_FAILED; } - to_json(jAudioParam, mic_->GetAudioParam()); + to_json(jAudioParam, mic->GetAudioParam()); ret = NotifySinkDev(OPEN_MIC, jAudioParam, jParam[KEY_DH_ID]); if (ret != DH_SUCCESS) { DHLOGE("Notify sink open mic failed, error code %d.", ret); - mic_->Release(); + mic->Release(); return ret; } - ret = mic_->Start(); + ret = mic->Start(); if (ret != DH_SUCCESS) { DHLOGE("Mic start failed, error code %d.", ret); - mic_->Stop(); - mic_->Release(); + mic->Stop(); + mic->Release(); return ret; } - NotifyHDF(NOTIFY_OPEN_MIC_RESULT, HDF_EVENT_RESULT_SUCCESS); + NotifyHDF(NOTIFY_OPEN_MIC_RESULT, HDF_EVENT_RESULT_SUCCESS, std::stoi(std::string(jParam[KEY_DH_ID]))); return DH_SUCCESS; } int32_t DAudioSourceDev::CloseMicOld(const std::string &args) { DHLOGI("Close mic old."); + auto mic = FindIoDevImpl(args); + if (mic == nullptr) { + DHLOGE("Mic device not init"); + return DH_SUCCESS; + } bool closeStatus = true; - int32_t ret = mic_->Stop(); + int32_t ret = mic->Stop(); if (ret != DH_SUCCESS) { DHLOGE("Mic stop failed, error code %d", ret); closeStatus = false; } - ret = mic_->Release(); + ret = mic->Release(); if (ret != DH_SUCCESS) { DHLOGE("Mic release failed, error code %d", ret); closeStatus = false; } - if (!mic_->IsOpened()) { + if (!mic->IsOpened()) { json jAudioParam; json jParam = json::parse(args, nullptr, false); if (!JsonParamCheck(jParam, { KEY_DH_ID })) { @@ -909,13 +1009,18 @@ int32_t DAudioSourceDev::CloseMicNew(const std::string &args) } NotifySinkDev(CLOSE_MIC, jAudioParam, jParam[KEY_DH_ID]); + auto mic = FindIoDevImpl(args); + if (mic == nullptr) { + DHLOGE("Mic device not init"); + return DH_SUCCESS; + } bool closeStatus = true; - int32_t ret = mic_->Stop(); + int32_t ret = mic->Stop(); if (ret != DH_SUCCESS) { DHLOGE("Mic stop failed, error code %d", ret); closeStatus = false; } - ret = mic_->Release(); + ret = mic->Release(); if (ret != DH_SUCCESS) { DHLOGE("Mic release failed, error code %d", ret); closeStatus = false; @@ -929,9 +1034,15 @@ 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()); - if (mic_ == nullptr) { + int32_t dhId = ParseDhidFromEvent(args); + if (dhId < 0) { + DHLOGE("Failed to parse dhardware id."); + return ERR_DH_AUDIO_FAILED; + } + auto mic = FindIoDevImpl(args); + 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()) { @@ -942,7 +1053,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; } @@ -970,19 +1081,50 @@ 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 (!CJsonParamCheck(jParam, { KEY_DH_ID })) { + DHLOGE("Not found the keys of dhId."); + cJSON_Delete(jParam); + return ERR_DH_AUDIO_FAILED; + } + int32_t dhId = std::stoi(std::string(cJSON_GetObjectItem(jParam, KEY_DH_ID)->valuestring)); + cJSON_Delete(jParam); + 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 (!CJsonParamCheck(jParam, { KEY_DH_ID })) { + DHLOGE("Not found the keys of dhId."); + cJSON_Delete(jParam); + return ERR_DH_AUDIO_FAILED; + } + int32_t dhId = std::stoi(std::string(cJSON_GetObjectItem(jParam, KEY_DH_ID)->valuestring)); + cJSON_Delete(jParam); + return NotifyHDF(AudioEventType::AUDIO_RENDER_STATE_CHANGE, args, dhId); } int32_t DAudioSourceDev::TaskPlayStatusChange(const std::string &args) @@ -994,15 +1136,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."); } @@ -1016,11 +1162,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."); @@ -1032,11 +1190,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); } @@ -1046,22 +1205,24 @@ 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; } int32_t DAudioSourceDev::TaskMicMmapStart(const std::string &args) { DHLOGI("Task mic mmap start, content: %s.", args.c_str()); - if (mic_ == nullptr) { + auto mic = FindIoDevImpl(args); + if (mic == nullptr) { DHLOGE("Task mic mmap start, mic is nullptr."); return ERR_DH_AUDIO_NULLPTR; } - int32_t ret = mic_->MmapStart(); + int32_t ret = mic->MmapStart(); if (ret != DH_SUCCESS) { DHLOGE("Task mic mmap start fail, error code: %d.", ret); } @@ -1071,11 +1232,12 @@ int32_t DAudioSourceDev::TaskMicMmapStart(const std::string &args) int32_t DAudioSourceDev::TaskMicMmapStop(const std::string &args) { DHLOGI("Task mic mmap stop, content: %s.", args.c_str()); - if (mic_ == nullptr) { + auto mic = FindIoDevImpl(args); + if (mic == nullptr) { DHLOGE("Task mic mmap stop, mic is nullptr."); return ERR_DH_AUDIO_NULLPTR; } - mic_->MmapStop(); + mic->MmapStop(); return DH_SUCCESS; } @@ -1103,16 +1265,18 @@ int32_t DAudioSourceDev::NotifySinkDev(const AudioEventType type, const json Par { KEY_AUDIO_PARAM, Param }, { KEY_RANDOM_TASK_CODE, std::to_string(randomTaskCode) } }; 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(std::stoi(dhId)) == deviceMap_.end()) { DHLOGE("speaker or mic dev is null."); return ERR_DH_AUDIO_NULLPTR; } + auto ioDev = deviceMap_[std::stoi(dhId)]; if (type == OPEN_CTRL || type == CLOSE_CTRL) { DHLOGE("In new engine mode, ctrl is not allowed."); return ERR_DH_AUDIO_NULLPTR; } - speaker_->SendMessage(static_cast(type), jParam.dump(), devId_); - mic_->SendMessage(static_cast(type), jParam.dump(), devId_); + ioDev->SendMessage(static_cast(type), jParam.dump(), devId_); if (type == CLOSE_SPEAKER || type == CLOSE_MIC) { // Close spk || Close mic do not need to wait RPC return DH_SUCCESS; @@ -1120,8 +1284,15 @@ int32_t DAudioSourceDev::NotifySinkDev(const AudioEventType type, const json Par 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) { + DHLOGI("Notify HDF framework the result, event type: %d; result: %s.", type, result.c_str()); + std::lock_guard devLck(ioDevMtx_); + if (deviceMap_.find(dhId) == deviceMap_.end()) { + DHLOGE("Speaker or mic dev is null."); + return ERR_DH_AUDIO_NULLPTR; + } + auto ioDev = deviceMap_[dhId]; AudioEvent event(type, result); switch (type) { case NOTIFY_OPEN_SPEAKER_RESULT: @@ -1129,18 +1300,10 @@ int32_t DAudioSourceDev::NotifyHDF(const AudioEventType type, const std::string case VOLUME_CHANGE: case AUDIO_FOCUS_CHANGE: case AUDIO_RENDER_STATE_CHANGE: - if (speaker_ == nullptr) { - DHLOGE("Speaker device not init"); - return ERR_DH_AUDIO_NULLPTR; - } - return speaker_->NotifyHdfAudioEvent(event); + return ioDev->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 ioDev->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 e2f15d0c667ebec82da32d6549a16ecd9396b40f..9b45d47866d4337627933cab448ff61dfa534143 100644 --- a/services/audiomanager/managersource/src/dmic_dev.cpp +++ b/services/audiomanager/managersource/src/dmic_dev.cpp @@ -83,68 +83,34 @@ 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."); - 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); @@ -267,6 +233,18 @@ int32_t DMicDev::Start() return DH_SUCCESS; } +int32_t DMicDev::Pause() +{ + DHLOGI("Not support."); + return DH_SUCCESS; +} + +int32_t DMicDev::Restart() +{ + DHLOGI("Not surpport."); + return DH_SUCCESS; +} + int32_t DMicDev::Stop() { DHLOGI("Stop mic device."); @@ -347,7 +325,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()); @@ -481,9 +459,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 bc4bda0545820db00f0fefe742397d39a15b5a1e..0ddddebb37650f935b2c8905b36051fd9e8f40bf 100644 --- a/services/audiomanager/managersource/src/dspeaker_dev.cpp +++ b/services/audiomanager/managersource/src/dspeaker_dev.cpp @@ -37,71 +37,40 @@ 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."); + "daudio register 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) { + 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::InitReceiverEngine(IAVEngineProvider *providerPtr) +{ + DHLOGI("InitReceiverEngine enter."); + return DH_SUCCESS; +} + int32_t DSpeakerDev::InitSenderEngine(IAVEngineProvider *providerPtr) { DHLOGI("InitSenderEngine enter"); @@ -350,7 +319,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()); @@ -488,9 +457,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/servicesink/BUILD.gn b/services/audiomanager/servicesink/BUILD.gn index d7ce250dbab1569d8895ea1855eac41ff78e0b17..4b72c5e72c79707581e42f40212c6cbf44089501 100755 --- a/services/audiomanager/servicesink/BUILD.gn +++ b/services/audiomanager/servicesink/BUILD.gn @@ -18,6 +18,7 @@ import("../../../distributedaudio.gni") ohos_shared_library("distributed_audio_sink") { include_dirs = [ "//third_party/json/include", + "//third_party/cJSON", "${fwk_common_path}/utils/include", ] @@ -87,6 +88,7 @@ ohos_shared_library("distributed_audio_sink") { "${audio_transport_path}/decodetransport:distributed_audio_decode_transport", "${audio_transport_path}/encodetransport:distributed_audio_encode_transport", "${services_path}/common:distributed_audio_utils", + "//third_party/cJSON:cjson", ] external_deps = [ diff --git a/services/audiomanager/servicesource/BUILD.gn b/services/audiomanager/servicesource/BUILD.gn index d0a6f69d8406534223f25926e389452270fab35e..220e11b3a3e4f8ba72136e047b7c03f19d9c7aa5 100755 --- a/services/audiomanager/servicesource/BUILD.gn +++ b/services/audiomanager/servicesource/BUILD.gn @@ -18,6 +18,7 @@ import("../../../distributedaudio.gni") ohos_shared_library("distributed_audio_source") { include_dirs = [ "//third_party/json/include", + "//third_party/cJSON", "${driver_audio_path}/include", "${fwk_common_path}/utils/include", "${mediastandardfwk_path}/audiocapturer/include", @@ -89,6 +90,7 @@ ohos_shared_library("distributed_audio_source") { "${hdf_interfaces_path}/audioext/v1_0:libdaudioext_proxy_1.0", "${services_path}/common:distributed_audio_utils", "${services_path}/hdfaudioclient:daudio_client", + "//third_party/cJSON:cjson", ] external_deps = [ 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 08a60b637676776aaeb44dabb13c43a795623f09..720f05a57231d48a02695f868c8045874f29bdcf 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 @@ -69,7 +69,8 @@ HWTEST_F(DAudioSinkDevTest, TaskPlayStatusChange_001, TestSize.Level1) EXPECT_EQ(ERR_DH_AUDIO_NULLPTR, sinkDev_->TaskPlayStatusChange("")); std::string devId = "devid"; - sinkDev_->speakerClient_ = std::make_shared(devId, sinkDev_); + int32_t dhId = 1; + sinkDev_->speakerClient_ = std::make_shared(devId, dhId, sinkDev_); EXPECT_EQ(DH_SUCCESS, sinkDev_->TaskPlayStatusChange(AUDIO_EVENT_PAUSE)); } @@ -174,7 +175,8 @@ HWTEST_F(DAudioSinkDevTest, TaskCloseDSpeaker_002, TestSize.Level1) { std::string args; std::string devId = "devId"; - sinkDev_->speakerClient_ = std::make_shared(devId, sinkDev_); + int32_t dhId = 1; + sinkDev_->speakerClient_ = std::make_shared(devId, dhId, sinkDev_); EXPECT_EQ(DH_SUCCESS, sinkDev_->TaskCloseDSpeaker(args)); } @@ -187,10 +189,12 @@ HWTEST_F(DAudioSinkDevTest, TaskCloseDSpeaker_002, TestSize.Level1) HWTEST_F(DAudioSinkDevTest, TaskStartRender_001, TestSize.Level1) { std::string devId = "devId"; + int32_t dhId = 1; + std::string args = "{\"dhId\":\"1\"}"; sinkDev_->speakerClient_ = nullptr; - EXPECT_EQ(ERR_DH_AUDIO_NULLPTR, sinkDev_->TaskStartRender()); - sinkDev_->speakerClient_ = std::make_shared(devId, sinkDev_); - EXPECT_NE(DH_SUCCESS, sinkDev_->TaskStartRender()); + EXPECT_EQ(ERR_DH_AUDIO_NULLPTR, sinkDev_->TaskStartRender(args)); + sinkDev_->speakerClient_ = std::make_shared(devId, dhId, sinkDev_); + EXPECT_NE(DH_SUCCESS, sinkDev_->TaskStartRender(args)); } /** @@ -239,7 +243,8 @@ HWTEST_F(DAudioSinkDevTest, TaskCloseDMic_002, TestSize.Level1) { std::string args; std::string devId; - sinkDev_->micClient_ = std::make_shared(devId, sinkDev_); + int32_t dhId = 1 << 27 | 1 << 0; + sinkDev_->micClient_ = std::make_shared(devId, dhId, sinkDev_); EXPECT_EQ(DH_SUCCESS, sinkDev_->TaskCloseDMic(args)); } @@ -265,7 +270,8 @@ HWTEST_F(DAudioSinkDevTest, TaskSetParameter_002, TestSize.Level1) { std::string args; std::string devId; - sinkDev_->speakerClient_ = std::make_shared(devId, sinkDev_); + int32_t dhId = 1; + sinkDev_->speakerClient_ = std::make_shared(devId, dhId, sinkDev_); EXPECT_NE(DH_SUCCESS, sinkDev_->TaskSetParameter(args)); } @@ -291,7 +297,8 @@ HWTEST_F(DAudioSinkDevTest, TaskSetVolume_002, TestSize.Level1) { std::string args; std::string devId; - sinkDev_->speakerClient_ = std::make_shared(devId, sinkDev_); + int32_t dhId = 1; + sinkDev_->speakerClient_ = std::make_shared(devId, dhId, sinkDev_); EXPECT_NE(DH_SUCCESS, sinkDev_->TaskSetVolume(args)); } @@ -317,7 +324,8 @@ HWTEST_F(DAudioSinkDevTest, TaskSetMute_002, TestSize.Level1) { std::string args; std::string devId; - sinkDev_->speakerClient_ = std::make_shared(devId, sinkDev_); + int32_t dhId = 1; + sinkDev_->speakerClient_ = std::make_shared(devId, dhId, sinkDev_); EXPECT_NE(DH_SUCCESS, sinkDev_->TaskSetMute(args)); } @@ -415,10 +423,11 @@ HWTEST_F(DAudioSinkDevTest, TaskRenderStateChange_002, TestSize.Level1) HWTEST_F(DAudioSinkDevTest, SendAudioEventToRemote_002, TestSize.Level1) { std::string devId = "devId"; + int32_t dhId = 1; AudioEvent event; sinkDev_->speakerClient_ = nullptr; EXPECT_EQ(ERR_DH_AUDIO_NULLPTR, sinkDev_->SendAudioEventToRemote(event)); - sinkDev_->speakerClient_ = std::make_shared(devId, sinkDev_); + sinkDev_->speakerClient_ = std::make_shared(devId, dhId, sinkDev_); EXPECT_EQ(ERR_DH_AUDIO_NULLPTR, sinkDev_->SendAudioEventToRemote(event)); } } // DistributedHardware diff --git a/services/audiomanager/test/unittest/sourcedevice/src/daudio_source_dev_test.cpp b/services/audiomanager/test/unittest/sourcedevice/src/daudio_source_dev_test.cpp index 55846fed802c19542b8c656fa13f4898c7dc3501..fb851011f0921b4656009a828ba858e7c0ffee45 100644 --- a/services/audiomanager/test/unittest/sourcedevice/src/daudio_source_dev_test.cpp +++ b/services/audiomanager/test/unittest/sourcedevice/src/daudio_source_dev_test.cpp @@ -76,10 +76,14 @@ HWTEST_F(DAudioSourceDevTest, CreatTasks_001, TestSize.Level1) event.type = MIC_CLOSED; EXPECT_EQ(DH_SUCCESS, sourceDev_->HandleDMicClosed(event)); - sourceDev_->speaker_ = std::make_shared(DEV_ID, sourceDev_); - sourceDev_->speaker_->isOpened_ = true; - sourceDev_->mic_ = std::make_shared(DEV_ID, sourceDev_); - sourceDev_->mic_->isOpened_ = true; + int32_t dhId = DEFAULT_RENDER_ID; + auto speaker = std::make_shared(DEV_ID, sourceDev_); + sourceDev_->deviceMap_[dhId] = speaker; + speaker->isOpened_ = true; + dhId = DEFAULT_CAPTURE_ID; + auto mic = std::make_shared(DEV_ID, sourceDev_); + sourceDev_->deviceMap_[dhId] = mic; + mic->isOpened_ = true; event.type = CTRL_CLOSED; EXPECT_EQ(DH_SUCCESS, sourceDev_->HandleCtrlTransClosed(event)); @@ -310,39 +314,6 @@ HWTEST_F(DAudioSourceDevTest, CloseCtrlTrans_001, TestSize.Level1) AudioEvent event; bool isSpk = false; EXPECT_EQ(DH_SUCCESS, sourceDev_->CloseCtrlTrans(event, isSpk)); - sourceDev_->audioCtrlMgr_ = std::make_shared(DEV_ID, sourceDev_); - EXPECT_NE(ERR_DH_AUDIO_NULLPTR, sourceDev_->CloseCtrlTrans(event, isSpk)); - EXPECT_EQ(DH_SUCCESS, sourceDev_->CloseCtrlTrans(event, isSpk)); -} - -/** - * @tc.name: CloseCtrlTrans_002 - * @tc.desc: Verify the CloseCtrlTrans function with task queue run. - * @tc.type: FUNC - * @tc.require: AR000H0E5F - */ -HWTEST_F(DAudioSourceDevTest, CloseCtrlTrans_002, TestSize.Level1) -{ - AudioEvent event; - sourceDev_->AwakeAudioDev(); - - bool isSpk = false; - sourceDev_->mic_ = nullptr; - sourceDev_->speaker_ = std::make_shared(DEV_ID, sourceDev_); - sourceDev_->speaker_->isOpened_ = false; - EXPECT_EQ(DH_SUCCESS, sourceDev_->CloseCtrlTrans(event, isSpk)); - - sourceDev_->speaker_->isOpened_ = true; - EXPECT_EQ(DH_SUCCESS, sourceDev_->CloseCtrlTrans(event, isSpk)); - - isSpk = true; - sourceDev_->speaker_ = nullptr; - sourceDev_->mic_ = std::make_shared(DEV_ID, sourceDev_); - sourceDev_->mic_->isOpened_ = false; - EXPECT_EQ(DH_SUCCESS, sourceDev_->CloseCtrlTrans(event, isSpk)); - - sourceDev_->mic_->isOpened_ = true; - EXPECT_EQ(DH_SUCCESS, sourceDev_->CloseCtrlTrans(event, isSpk)); } /** @@ -386,16 +357,18 @@ HWTEST_F(DAudioSourceDevTest, HandleCtrlTransClosed_001, TestSize.Level1) AudioEvent event = AudioEvent(CTRL_CLOSED, ""); EXPECT_EQ(DH_SUCCESS, sourceDev_->HandleCtrlTransClosed(event)); - sourceDev_->speaker_ = std::make_shared(DEV_ID, sourceDev_); - sourceDev_->speaker_->isOpened_ = false; + auto speaker = std::make_shared(DEV_ID, sourceDev_); + int32_t dhId = DEFAULT_RENDER_ID; + sourceDev_->deviceMap_[dhId] = speaker; + speaker->isOpened_ = false; EXPECT_EQ(DH_SUCCESS, sourceDev_->HandleCtrlTransClosed(event)); - sourceDev_->speaker_->isOpened_ = true; + speaker->isOpened_ = true; EXPECT_EQ(DH_SUCCESS, sourceDev_->HandleCtrlTransClosed(event)); sourceDev_->mic_ = std::make_shared(DEV_ID, sourceDev_); - sourceDev_->speaker_->isOpened_ = false; + speaker->isOpened_ = false; EXPECT_EQ(DH_SUCCESS, sourceDev_->HandleCtrlTransClosed(event)); - sourceDev_->speaker_->isOpened_ = true; + speaker->isOpened_ = true; EXPECT_EQ(DH_SUCCESS, sourceDev_->HandleCtrlTransClosed(event)); } @@ -624,10 +597,11 @@ HWTEST_F(DAudioSourceDevTest, OnDisableTaskResult_001, TestSize.Level1) */ HWTEST_F(DAudioSourceDevTest, EnableDSpeaker_001, TestSize.Level1) { - int32_t dhId = 0; - sourceDev_->speaker_ = std::make_shared(DEV_ID, sourceDev_); + auto speaker = std::make_shared(DEV_ID, sourceDev_); + int32_t dhId = DEFAULT_RENDER_ID; + sourceDev_->deviceMap_[dhId] = speaker; EXPECT_NE(DH_SUCCESS, sourceDev_->EnableDSpeaker(dhId, ATTRS)); - sourceDev_->speaker_ = nullptr; + sourceDev_->deviceMap_[dhId] = nullptr; EXPECT_NE(DH_SUCCESS, sourceDev_->EnableDSpeaker(dhId, ATTRS)); } @@ -720,16 +694,18 @@ HWTEST_F(DAudioSourceDevTest, TaskCloseDSpeaker_001, TestSize.Level1) { EXPECT_EQ(DH_SUCCESS, sourceDev_->TaskCloseDSpeaker(ARGS)); - sourceDev_->speaker_ = std::make_shared(DEV_ID, sourceDev_); + int32_t dhId = DEFAULT_RENDER_ID; + auto speaker = std::make_shared(DEV_ID, sourceDev_); + sourceDev_->deviceMap_[dhId] = speaker; EXPECT_EQ(ERR_DH_AUDIO_SA_PARAM_INVALID, sourceDev_->TaskCloseDSpeaker("")); std::string tempLongStr(DAUDIO_MAX_JSON_LEN + 1, 'a'); EXPECT_EQ(ERR_DH_AUDIO_SA_PARAM_INVALID, sourceDev_->TaskCloseDSpeaker(tempLongStr)); - sourceDev_->speaker_->isOpened_ = true; + speaker->isOpened_ = true; EXPECT_EQ(ERR_DH_AUDIO_FAILED, sourceDev_->TaskCloseDSpeaker(ARGS)); - sourceDev_->speaker_->isOpened_ = false; + speaker->isOpened_ = false; EXPECT_EQ(ERR_DH_AUDIO_FAILED, sourceDev_->TaskCloseDSpeaker(ARGS)); json jParam_spk = { { KEY_DH_ID, DH_ID_SPK } }; @@ -744,8 +720,10 @@ HWTEST_F(DAudioSourceDevTest, TaskCloseDSpeaker_001, TestSize.Level1) */ HWTEST_F(DAudioSourceDevTest, TaskCloseDSpeaker_002, TestSize.Level1) { - sourceDev_->speaker_ = std::make_shared(DEV_ID, sourceDev_); - sourceDev_->speaker_->speakerTrans_ = std::make_shared(DEV_ID); + auto speaker = std::make_shared(DEV_ID, sourceDev_); + int32_t dhId = DEFAULT_RENDER_ID; + sourceDev_->deviceMap_[dhId] = speaker; + speaker->speakerTrans_ = std::make_shared(DEV_ID); json jParam_spk = { { KEY_DH_ID, DH_ID_SPK } }; EXPECT_EQ(ERR_DH_AUDIO_FAILED, sourceDev_->TaskCloseDSpeaker(jParam_spk.dump())); @@ -761,7 +739,9 @@ HWTEST_F(DAudioSourceDevTest, TaskOpenDMic_001, TestSize.Level1) { EXPECT_EQ(ERR_DH_AUDIO_SA_MIC_DEVICE_NOT_INIT, sourceDev_->TaskOpenDMic("")); - sourceDev_->mic_ = std::make_shared(DEV_ID, sourceDev_); + auto mic = std::make_shared(DEV_ID, sourceDev_); + int32_t dhId = DEFAULT_CAPTURE_ID; + sourceDev_->deviceMap_[dhId] = mic; EXPECT_EQ(ERR_DH_AUDIO_TRANS_NULL_VALUE, sourceDev_->TaskOpenDMic("")); EXPECT_EQ(ERR_DH_AUDIO_TRANS_NULL_VALUE, sourceDev_->TaskOpenDMic("")); @@ -785,16 +765,19 @@ HWTEST_F(DAudioSourceDevTest, TaskCloseDMic_001, TestSize.Level1) { EXPECT_EQ(DH_SUCCESS, sourceDev_->TaskCloseDMic(ARGS)); - sourceDev_->mic_ = std::make_shared(DEV_ID, sourceDev_); + auto mic = std::make_shared(DEV_ID, sourceDev_); + int32_t dhId = DEFAULT_CAPTURE_ID; + sourceDev_->deviceMap_[dhId] = mic; + EXPECT_EQ(ERR_DH_AUDIO_SA_PARAM_INVALID, sourceDev_->TaskCloseDMic("")); std::string tempLongStr(DAUDIO_MAX_JSON_LEN + 1, 'a'); EXPECT_EQ(ERR_DH_AUDIO_SA_PARAM_INVALID, sourceDev_->TaskCloseDMic(tempLongStr)); - sourceDev_->mic_->isOpened_ = true; + mic->isOpened_ = true; EXPECT_EQ(ERR_DH_AUDIO_FAILED, sourceDev_->TaskCloseDMic(ARGS)); - sourceDev_->mic_->isOpened_ = false; + mic->isOpened_ = false; EXPECT_EQ(ERR_DH_AUDIO_FAILED, sourceDev_->TaskCloseDMic(ARGS)); json jParam_mic = { { KEY_DH_ID, DH_ID_MIC } }; @@ -809,8 +792,10 @@ HWTEST_F(DAudioSourceDevTest, TaskCloseDMic_001, TestSize.Level1) */ HWTEST_F(DAudioSourceDevTest, TaskCloseDMic_002, TestSize.Level1) { - sourceDev_->mic_ = std::make_shared(DEV_ID, sourceDev_); - sourceDev_->mic_->micTrans_ = std::make_shared(DEV_ID); + auto mic = std::make_shared(DEV_ID, sourceDev_); + int32_t dhId = DEFAULT_CAPTURE_ID; + sourceDev_->deviceMap_[dhId] = mic; + mic->micTrans_ = std::make_shared(DEV_ID); json jParam_mic = { { KEY_DH_ID, DH_ID_MIC } }; EXPECT_EQ(DH_SUCCESS, sourceDev_->TaskCloseDMic(jParam_mic.dump())); @@ -989,13 +974,15 @@ HWTEST_F(DAudioSourceDevTest, TaskMicMmapStart_001, TestSize.Level1) { EXPECT_EQ(ERR_DH_AUDIO_NULLPTR, sourceDev_->TaskMicMmapStart(ARGS)); - sourceDev_->mic_ = std::make_shared(DEV_ID, nullptr); + auto mic = std::make_shared(DEV_ID, nullptr); + int32_t dhId = DEFAULT_CAPTURE_ID; + sourceDev_->deviceMap_[dhId] = mic; EXPECT_EQ(ERR_DH_AUDIO_NULLPTR, sourceDev_->TaskMicMmapStart(ARGS)); std::shared_ptr data = std::make_shared(AUDIO_DATA_CAP); for (size_t i = 0; i < TASK_QUEUE_LEN; i++) { - sourceDev_->mic_->dataQueue_.push(data); + mic->dataQueue_.push(data); } - EXPECT_EQ(DH_SUCCESS, sourceDev_->mic_->MmapStop()); + EXPECT_EQ(DH_SUCCESS, sourceDev_->deviceMap_[dhId]->MmapStop()); } /** @@ -1007,8 +994,10 @@ HWTEST_F(DAudioSourceDevTest, TaskMicMmapStart_001, TestSize.Level1) HWTEST_F(DAudioSourceDevTest, TaskMicMmapStop_001, TestSize.Level1) { EXPECT_EQ(ERR_DH_AUDIO_NULLPTR, sourceDev_->TaskMicMmapStop(ARGS)); + auto mic = std::make_shared(DEV_ID, nullptr); + int32_t dhId = DEFAULT_CAPTURE_ID; + sourceDev_->deviceMap_[dhId] = mic; - sourceDev_->mic_ = std::make_shared(DEV_ID, nullptr); EXPECT_EQ(DH_SUCCESS, sourceDev_->TaskMicMmapStop(ARGS)); } @@ -1023,10 +1012,11 @@ HWTEST_F(DAudioSourceDevTest, NotifyHDF_001, TestSize.Level1) { AudioEventType type = NOTIFY_CLOSE_MIC_RESULT; std::string result = "result"; - EXPECT_NE(DH_SUCCESS, sourceDev_->NotifyHDF(type, result)); + int32_t dhId = 1; + EXPECT_NE(DH_SUCCESS, sourceDev_->NotifyHDF(type, result, dhId)); sourceDev_->mic_ = std::make_shared(DEV_ID, sourceDev_); - EXPECT_EQ(DH_SUCCESS, sourceDev_->NotifyHDF(type, result)); + EXPECT_EQ(DH_SUCCESS, sourceDev_->NotifyHDF(type, result, dhId)); } /** @@ -1039,10 +1029,11 @@ HWTEST_F(DAudioSourceDevTest, NotifyHDF_002, TestSize.Level1) { AudioEventType type = AUDIO_FOCUS_CHANGE; std::string result = "result"; - EXPECT_NE(DH_SUCCESS, sourceDev_->NotifyHDF(type, result)); + int32_t dhId = 1; + EXPECT_NE(DH_SUCCESS, sourceDev_->NotifyHDF(type, result, dhId)); sourceDev_->speaker_ = std::make_shared(DEV_ID, sourceDev_); - EXPECT_EQ(DH_SUCCESS, sourceDev_->NotifyHDF(type, result)); + EXPECT_EQ(DH_SUCCESS, sourceDev_->NotifyHDF(type, result, dhId)); } /** @@ -1055,7 +1046,8 @@ HWTEST_F(DAudioSourceDevTest, NotifyHDF_003, TestSize.Level1) { AudioEventType type = EVENT_UNKNOWN; std::string result = "result"; - EXPECT_EQ(ERR_DH_AUDIO_FAILED, sourceDev_->NotifyHDF(type, result)); + int32_t dhId = 1; + EXPECT_EQ(ERR_DH_AUDIO_FAILED, sourceDev_->NotifyHDF(type, result, dhId)); } /** 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..30af534dc79cbbab864b82d4b79b0b3694f54c47 100644 --- a/services/audiomanager/test/unittest/sourcedevice/src/dmic_dev_test.cpp +++ b/services/audiomanager/test/unittest/sourcedevice/src/dmic_dev_test.cpp @@ -71,11 +71,11 @@ HWTEST_F(DMicDevTest, InitReceiverEngine_001, TestSize.Level1) */ HWTEST_F(DMicDevTest, EnableDMic_001, TestSize.Level1) { - EXPECT_EQ(ERR_DH_AUDIO_FAILED, mic_->EnableDMic(DH_ID, CAP)); + EXPECT_EQ(ERR_DH_AUDIO_FAILED, mic_->EnableDevice(DH_ID, CAP)); EXPECT_EQ(ERR_DH_AUDIO_HDI_PROXY_NOT_INIT, mic_->EnableDevice(DH_ID, CAP)); mic_->enabledPorts_.insert(DH_ID_MIC); - EXPECT_EQ(ERR_DH_AUDIO_HDI_PROXY_NOT_INIT, mic_->EnableDMic(DH_ID_MIC, CAP)); + EXPECT_EQ(ERR_DH_AUDIO_HDI_PROXY_NOT_INIT, mic_->EnableDevice(DH_ID_MIC, CAP)); } /** @@ -89,10 +89,10 @@ HWTEST_F(DMicDevTest, DisableDMic_001, TestSize.Level1) mic_->enabledPorts_.insert(DH_ID); EXPECT_EQ(ERR_DH_AUDIO_HDI_PROXY_NOT_INIT, mic_->DisableDevice(DH_ID)); - EXPECT_EQ(ERR_DH_AUDIO_FAILED, mic_->DisableDMic(DH_ID)); + EXPECT_EQ(ERR_DH_AUDIO_FAILED, mic_->DisableDevice(DH_ID)); mic_->curPort_ = DH_ID_MIC; - EXPECT_EQ(ERR_DH_AUDIO_FAILED, mic_->DisableDMic(DH_ID_MIC)); + EXPECT_EQ(ERR_DH_AUDIO_FAILED, mic_->DisableDevice(DH_ID_MIC)); EXPECT_FALSE(mic_->IsOpened()); } @@ -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..3e52a1cf317c0d55e86a5844dfbec1dd4f0150b9 100644 --- a/services/audiomanager/test/unittest/sourcedevice/src/dspeaker_dev_test.cpp +++ b/services/audiomanager/test/unittest/sourcedevice/src/dspeaker_dev_test.cpp @@ -68,11 +68,11 @@ HWTEST_F(DSpeakerDevTest, InitSenderEngine_001, TestSize.Level1) */ HWTEST_F(DSpeakerDevTest, EnableDSpeaker_001, TestSize.Level1) { - EXPECT_EQ(ERR_DH_AUDIO_FAILED, spk_->EnableDSpeaker(DH_ID, CAP)); + EXPECT_EQ(ERR_DH_AUDIO_FAILED, spk_->EnableDevice(DH_ID, CAP)); EXPECT_EQ(ERR_DH_AUDIO_HDI_PROXY_NOT_INIT, spk_->EnableDevice(DH_ID, CAP)); spk_->enabledPorts_.insert(DH_ID_SPK); - EXPECT_EQ(ERR_DH_AUDIO_HDI_PROXY_NOT_INIT, spk_->EnableDSpeaker(DH_ID_SPK, CAP)); + EXPECT_EQ(ERR_DH_AUDIO_HDI_PROXY_NOT_INIT, spk_->EnableDevice(DH_ID_SPK, CAP)); } /** @@ -86,10 +86,10 @@ HWTEST_F(DSpeakerDevTest, DisableDSpeaker_001, TestSize.Level1) spk_->enabledPorts_.insert(DH_ID); EXPECT_EQ(ERR_DH_AUDIO_HDI_PROXY_NOT_INIT, spk_->DisableDevice(DH_ID)); - EXPECT_EQ(ERR_DH_AUDIO_HDI_PROXY_NOT_INIT, spk_->DisableDSpeaker(DH_ID)); + EXPECT_EQ(ERR_DH_AUDIO_HDI_PROXY_NOT_INIT, spk_->DisableDevice(DH_ID)); spk_->curPort_ = DH_ID_SPK; - EXPECT_EQ(ERR_DH_AUDIO_HDI_PROXY_NOT_INIT, spk_->DisableDSpeaker(DH_ID_SPK)); + EXPECT_EQ(ERR_DH_AUDIO_HDI_PROXY_NOT_INIT, spk_->DisableDevice(DH_ID_SPK)); EXPECT_FALSE(spk_->IsOpened()); } @@ -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)); } /** diff --git a/services/audiotransport/test/unittest/audiodatachannel/BUILD.gn b/services/audiotransport/test/unittest/audiodatachannel/BUILD.gn index f4b60682a5f491e51a840a23ab4b270f50f68530..55297b0286db8bcf050e6c802ea1f992dac81807 100644 --- a/services/audiotransport/test/unittest/audiodatachannel/BUILD.gn +++ b/services/audiotransport/test/unittest/audiodatachannel/BUILD.gn @@ -21,6 +21,7 @@ config("module_private_config") { visibility = [ ":*" ] include_dirs = [ + "//third_party/cJSON", "//third_party/json/include", "${fwk_common_path}/utils/include", "${fwk_utils_path}/include/", diff --git a/services/common/BUILD.gn b/services/common/BUILD.gn index bf4f8493cb7c19bbc82a982ea62ebc471e99ae17..60385f42662b0447f418cd6ef5f3782da509c424 100644 --- a/services/common/BUILD.gn +++ b/services/common/BUILD.gn @@ -22,6 +22,7 @@ config("daudio_common_pub_config") { "audioparam", "${common_path}/dfxutils/include", "${common_path}/include", + "//third_party/cJSON", ] } @@ -51,6 +52,7 @@ ohos_shared_library("distributed_audio_utils") { "taskProcessor/src/task_queue.cpp", ] + deps = [ "//third_party/cJSON:cjson" ] external_deps = [ "c_utils:utils", "dsoftbus:softbus_client", diff --git a/services/softbusadapter/test/unittest/BUILD.gn b/services/softbusadapter/test/unittest/BUILD.gn index 189137bd947939a816b4a1ba5a9a8ecd9ac0003e..aaf8946f5a4a4b0b686ad3b658321410fc4b6ed9 100644 --- a/services/softbusadapter/test/unittest/BUILD.gn +++ b/services/softbusadapter/test/unittest/BUILD.gn @@ -20,6 +20,7 @@ config("module_private_config") { visibility = [ ":*" ] include_dirs = [ + "//third_party/cJSON", "//third_party/json/include", "${fwk_common_path}/utils/include", "${fwk_utils_path}/include/",