diff --git a/bundle.json b/bundle.json index 61be1745b0ab1aceead64f02146adb16b3e8f235..df8dcbdbc0f64aa16254af9e1da6d86e35841f8d 100755 --- a/bundle.json +++ b/bundle.json @@ -61,7 +61,6 @@ "//foundation/distributedhardware/distributed_audio/services/common:distributed_audio_utils", "//foundation/distributedhardware/distributed_audio/services/hdfaudioclient:daudio_client", - "//foundation/distributedhardware/distributed_audio/services/audioclient:distributed_audio_sink_client", "//foundation/distributedhardware/distributed_audio/services/audiomanager/servicesource:distributed_audio_source", "//foundation/distributedhardware/distributed_audio/services/audiomanager/servicesink:distributed_audio_sink", @@ -94,17 +93,6 @@ ] } }, - { - "type": "so", - "name": "//foundation/distributedhardware/distributed_audio/services/audioclient:distributed_audio_sink_client", - "header": { - "header_base": "//foundation/distributedhardware/distributed_audio/services/audioclient", - "header_files": [ - "interface/imic_client.h", - "interface/ispk_client.h" - ] - } - }, { "type": "so", "name": "//foundation/distributedhardware/distributed_audio/services/audiotransport/decodetransport:distributed_audio_decode_transport", diff --git a/common/dfx_utils/test/unittest/BUILD.gn b/common/dfx_utils/test/unittest/BUILD.gn index cbabb0e2fbde58aa3476cf5e7eacde1ea2290643..e4b81fd5e4564f171b21a4fd0aff961972f587c3 100644 --- a/common/dfx_utils/test/unittest/BUILD.gn +++ b/common/dfx_utils/test/unittest/BUILD.gn @@ -28,15 +28,17 @@ config("module_private_config") { "${audio_processor_path}/interface", "${audio_processor_path}/encodeprocessor/include", "${audio_processor_path}/decodeprocessor/include", - "${audio_transport_path}/interface", - "${audio_transport_path}/encodetransport/include", - "${audio_transport_path}/decodetransport/include", - "${audio_transport_path}/audioctrltransport/include", - "${audio_transport_path}/audioctrltransport/interface", "${audio_transport_path}/audiochannel/interface", "${audio_transport_path}/audiochannel/audiodatachannel/include", + "${audio_transport_path}/audioctrltransport/include", + "${audio_transport_path}/audioctrltransport/interface", "${audio_transport_path}/audiotransportstatus/include", "${audio_transport_path}/audiotransportstatus/interface", + "${audio_transport_path}/decodetransport/include", + "${audio_transport_path}/encodetransport/include", + "${audio_transport_path}/interface", + "${audio_transport_path}/receiverengine/include", + "${audio_transport_path}/senderengine/include", "${common_path}/include", "${common_path}/dfx_utils/include", "${distributedaudio_path}/audiohandler/include", diff --git a/common/include/daudio_constants.h b/common/include/daudio_constants.h index 1b6c86b1520313d26dde502b78a1a482329787aa..3c08ddb1991314f08aa40870624ca18eb45e61bb 100644 --- a/common/include/daudio_constants.h +++ b/common/include/daudio_constants.h @@ -39,6 +39,7 @@ constexpr int32_t LOG_MAX_LEN = 4096; constexpr int32_t DISTRIBUTED_HARDWARE_AUDIO_SOURCE_SA_ID = 4805; constexpr int32_t DISTRIBUTED_HARDWARE_AUDIO_SINK_SA_ID = 4806; constexpr int32_t AUDIO_LOADSA_TIMEOUT_MS = 10000; +constexpr int32_t AUDIO_SET_HISTREAMER_BIT_RATE = 1536000; constexpr int32_t AUDIO_DEVICE_TYPE_UNKNOWN = 0; constexpr int32_t AUDIO_DEVICE_TYPE_SPEAKER = 1; @@ -97,6 +98,8 @@ const std::string VOLUME_LEVEL = "VOLUME_LEVEL"; const std::string AUDIO_EVENT_RESTART = "restart"; const std::string AUDIO_EVENT_PAUSE = "pause"; +const std::string AUDIO_ENGINE_FLAG = "persist.distributedhardware.distributedaudio.engine.enable"; + constexpr const char *KEY_TYPE = "type"; constexpr const char *KEY_EVENT_CONTENT = "content"; constexpr const char *KEY_DH_ID = "dhId"; diff --git a/common/include/daudio_errorcode.h b/common/include/daudio_errorcode.h index b494a128d03f67f40fb602ac59c8b222fe551d24..5a141af887ceb647a447b0656561a3e474576a3d 100644 --- a/common/include/daudio_errorcode.h +++ b/common/include/daudio_errorcode.h @@ -133,6 +133,19 @@ enum DAudioErrorCode { ERR_DH_AUDIO_HDI_NULLPTR = -45005, ERR_DH_AUDIO_CTRL_CHANNEL_SEND_MSG_FAIL = -46001, + + // AV Transport component error code + ERR_DH_AV_TRANS_NULL_VALUE = -47000, + ERR_DH_AV_TRANS_ILLEGAL_PARAM = -47001, + ERR_DH_AV_TRANS_TIMEOUT = -47002, + ERR_DH_AV_TRANS_LOAD_ERROR = -47003, + ERR_DH_AV_TRANS_INIT_FAILED = -47004, + ERR_DH_AV_TRANS_CREATE_CHANNEL_FAILED = -47005, + ERR_DH_AV_TRANS_SETUP_FAILED = -47006, + ERR_DH_AV_TRANS_START_FAILED = -47007, + ERR_DH_AV_TRANS_STOP_FAILED = -47008, + ERR_DH_AV_TRANS_FEED_DATA_FAILED = -47009, + ERR_DH_AV_TRANS_SEND_MSG_FAILED = -47010, }; } // namespace DistributedHardware } // namespace OHOS diff --git a/common/include/daudio_util.h b/common/include/daudio_util.h index 186d8c7187e15d27f72c337ff42e46a3dc1ae02b..93933ee96be8c99779b46f63641e801981869678 100644 --- a/common/include/daudio_util.h +++ b/common/include/daudio_util.h @@ -47,6 +47,10 @@ int64_t UpdateTimeOffset(const int64_t frameIndex, const int64_t framePeriodNs, void GetCurrentTime(int64_t &tvSec, int64_t &tvNSec); bool CheckIsNum(const std::string &jsonString); bool CheckDevIdIsLegal(const std::string &devId); + +template +bool GetSysPara(const char *key, T &value); +bool IsParamEnabled(std::string key, bool &isEnabled); } // namespace DistributedHardware } // namespace OHOS #endif // OHOS_DAUDIO_UTIL_H diff --git a/common/src/daudio_util.cpp b/common/src/daudio_util.cpp index 33cc2dc707cd5e913bac858a9719567ff3a5f103..084dce8e45eb14c682656369567093dee6622ba9 100644 --- a/common/src/daudio_util.cpp +++ b/common/src/daudio_util.cpp @@ -28,6 +28,7 @@ #include "daudio_constants.h" #include "daudio_errorcode.h" #include "daudio_log.h" +#include "parameter.h" #undef DH_LOG_TAG #define DH_LOG_TAG "DAudioUtils" @@ -320,5 +321,42 @@ bool CheckDevIdIsLegal(const std::string &devId) } return true; } + +template +bool GetSysPara(const char *key, T &value) +{ + if (key == nullptr) { + DHLOGE("GetSysPara: key is nullptr"); + return false; + } + char paraValue[20] = {0}; // 20 for system parameter + auto res = GetParameter(key, "-1", paraValue, sizeof(paraValue)); + if (res <= 0) { + DHLOGD("GetSysPara fail, key:%{public}s res:%{public}d", key, res); + return false; + } + DHLOGI("GetSysPara: key:%{public}s value:%{public}s", key, paraValue); + std::stringstream valueStr; + valueStr << paraValue; + valueStr >> value; + return true; +} + +template bool GetSysPara(const char *key, int32_t &value); +template bool GetSysPara(const char *key, uint32_t &value); +template bool GetSysPara(const char *key, int64_t &value); +template bool GetSysPara(const char *key, std::string &value); + +bool IsParamEnabled(std::string key, bool &isEnabled) +{ + // by default: old trans + int32_t policyFlag = 0; + if (GetSysPara(key.c_str(), policyFlag) && policyFlag == 1) { + isEnabled = true; + return true; + } + isEnabled = false; + return false; +} } // namespace DistributedHardware } // namespace OHOS \ No newline at end of file diff --git a/services/audioclient/BUILD.gn b/services/audioclient/BUILD.gn deleted file mode 100644 index 0cdba2722d51aaf7c31cfac06ee8292523babf4e..0000000000000000000000000000000000000000 --- a/services/audioclient/BUILD.gn +++ /dev/null @@ -1,91 +0,0 @@ -# Copyright (c) 2022 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. - -import("//build/ohos.gni") -import("//build/ohos_var.gni") -import("../../distributedaudio.gni") - -config("daudio_client_pub_config") { - include_dirs = [ "interface" ] -} - -ohos_shared_library("distributed_audio_sink_client") { - include_dirs = [ "//third_party/json/include" ] - - include_dirs += [ - "${audio_client_path}/interface", - "${audio_client_path}/micclient/include", - "${audio_client_path}/spkclient/include", - "${audio_processor_path}/encodeprocessor/include", - "${audio_processor_path}/decodeprocessor/include", - "${audio_processor_path}/interface", - "${audio_transport_path}/audiochannel/interface", - "${audio_transport_path}/audiochannel/audiodatachannel/include", - "${audio_transport_path}/decodetransport/include", - "${audio_transport_path}/encodetransport/include", - "${audio_transport_path}/interface", - "${common_path}/dfx_utils/include", - "${common_path}/include", - "${fwk_common_path}/utils/include", - "${services_path}/common/audioeventcallback", - "${services_path}/common/audiodata/include", - "${services_path}/common/audioparam", - ] - - if (distributed_audio_extension) { - include_dirs += [ - "${distributedaudio_ext_path}/services/audioclient/directmicclient/include", - "${distributedaudio_ext_path}/services/audioclient/directspkclient/include", - ] - } - - public_configs = [ ":daudio_client_pub_config" ] - - sources = [ - "${audio_client_path}/micclient/src/dmic_client.cpp", - "${audio_client_path}/spkclient/src/dspeaker_client.cpp", - ] - - if (distributed_audio_extension) { - sources += [ - "${distributedaudio_ext_path}/services/audioclient/directmicclient/src/direct_dmic_client.cpp", - "${distributedaudio_ext_path}/services/audioclient/directspkclient/src/direct_dspeaker_client.cpp", - ] - } - - deps = [ - "${audio_transport_path}/decodetransport:distributed_audio_decode_transport", - "${audio_transport_path}/encodetransport:distributed_audio_encode_transport", - "${services_path}/common:distributed_audio_utils", - ] - - external_deps = [ - "audio_framework:audio_capturer", - "audio_framework:audio_client", - "audio_framework:audio_renderer", - "c_utils:utils", - "drivers_interface_audio:libaudio_proxy_1.0", - "hdf_core:libhdf_ipc_adapter", - "hdf_core:libhdi", - "hisysevent_native:libhisysevent", - "hitrace_native:hitrace_meter", - ] - - defines = [ - "HI_LOG_ENABLE", - "LOG_DOMAIN=0xD004100", - ] - - subsystem_name = "distributedhardware" - part_name = "distributed_audio" -} diff --git a/services/audioclient/interface/imic_client.h b/services/audioclient/interface/imic_client.h index 7546355e7ef1f8dd4bdd8ebe4a47d7314b7b2660..7247a5e75ce6d168bf64373311b7d4c559cb0da5 100644 --- a/services/audioclient/interface/imic_client.h +++ b/services/audioclient/interface/imic_client.h @@ -19,6 +19,7 @@ #include #include "audio_param.h" +#include "i_av_engine_provider.h" namespace OHOS { namespace DistributedHardware { @@ -32,6 +33,8 @@ public: virtual int32_t StartCapture() = 0; virtual int32_t StopCapture() = 0; virtual void SetAttrs(const std::string &devId, const std::shared_ptr &callback) = 0; + virtual int32_t InitSenderEngine(IAVEngineProvider *providerPtr) = 0; + virtual int32_t SendMessage(uint32_t type, std::string content, std::string dstDevId) = 0; }; } // namespace DistributedHardware } // namespace OHOS diff --git a/services/audioclient/interface/ispk_client.h b/services/audioclient/interface/ispk_client.h index f28c313eeb7af47261077af552e664b4a62e2caa..662dcea328a2012b7b776c524ce338167761e9e4 100644 --- a/services/audioclient/interface/ispk_client.h +++ b/services/audioclient/interface/ispk_client.h @@ -19,6 +19,7 @@ #include #include "audio_param.h" +#include "i_av_engine_provider.h" namespace OHOS { namespace DistributedHardware { @@ -35,6 +36,8 @@ public: virtual int32_t SetAudioParameters(const AudioEvent &event) = 0; virtual void PlayStatusChange(const std::string &args) = 0; virtual void SetAttrs(const std::string &devId, const std::shared_ptr &callback) = 0; + virtual int32_t InitReceiverEngine(IAVEngineProvider *providerPtr) = 0; + virtual int32_t SendMessage(uint32_t type, std::string content, std::string dstDevId) = 0; }; } // namespace DistributedHardware } // namespace OHOS diff --git a/services/audioclient/micclient/include/dmic_client.h b/services/audioclient/micclient/include/dmic_client.h index b9f68de4e547bd9912a1e017e4293bb4e7b9e9d6..a6283b03ff9e58f87f6bf4638a318282d587d592 100644 --- a/services/audioclient/micclient/include/dmic_client.h +++ b/services/audioclient/micclient/include/dmic_client.h @@ -32,6 +32,7 @@ #include "audio_event.h" #include "audio_param.h" #include "audio_status.h" +#include "av_sender_engine_transport.h" #include "daudio_errorcode.h" #include "daudio_log.h" #include "iaudio_data_transport.h" @@ -42,7 +43,7 @@ namespace OHOS { namespace DistributedHardware { class DMicClient : public IAudioDataTransCallback, - public IMicClient, + public IMicClient, public AVSenderTransportCallback, public std::enable_shared_from_this { public: DMicClient(const std::string &devId, const std::shared_ptr &callback) @@ -50,11 +51,15 @@ public: ~DMicClient() override; int32_t OnStateChange(const AudioEventType type) override; int32_t OnDecodeTransDataDone(const std::shared_ptr &audioData) override; + void OnEngineTransEvent(const AVTransEvent &event) override; + void OnEngineTransMessage(const std::shared_ptr &message) override; + int32_t InitSenderEngine(IAVEngineProvider *providerPtr) override; int32_t SetUp(const AudioParam ¶m) override; int32_t Release() override; int32_t StartCapture() override; int32_t StopCapture() override; void SetAttrs(const std::string &devId, const std::shared_ptr &callback) override; + int32_t SendMessage(uint32_t type, std::string content, std::string dstDevId) override; private: void CaptureThreadRunning(); @@ -74,6 +79,7 @@ private: std::weak_ptr eventCallback_; std::unique_ptr audioCapturer_ = nullptr; std::shared_ptr micTrans_ = nullptr; + bool engineFlag_ = false; }; } // DistributedHardware } // OHOS diff --git a/services/audioclient/micclient/src/dmic_client.cpp b/services/audioclient/micclient/src/dmic_client.cpp index 010044e0b5c66f216620bfdcea0213a5d0055503..19b7d8c2d2f6b086bd428537e7e86aee918e3e45 100644 --- a/services/audioclient/micclient/src/dmic_client.cpp +++ b/services/audioclient/micclient/src/dmic_client.cpp @@ -19,6 +19,7 @@ #include "daudio_constants.h" #include "daudio_hisysevent.h" +#include "daudio_sink_manager.h" #undef DH_LOG_TAG #define DH_LOG_TAG "DMicClient" @@ -33,6 +34,45 @@ DMicClient::~DMicClient() } } +void DMicClient::OnEngineTransEvent(const AVTransEvent &event) +{ + if (event.type == EventType::EVENT_START_SUCCESS) { + OnStateChange(DATA_OPENED); + } else if ((event.type == EventType::EVENT_STOP_SUCCESS) || + (event.type == EventType::EVENT_CHANNEL_CLOSED) || + (event.type == EventType::EVENT_START_FAIL)) { + OnStateChange(DATA_CLOSED); + } +} + +void DMicClient::OnEngineTransMessage(const std::shared_ptr &message) +{ + DHLOGI("On Engine message"); + if (message == nullptr) { + DHLOGE("The parameter is nullptr"); + return; + } + DAudioSinkManager::GetInstance().HandleDAudioNotify(message->dstDevId_, message->dstDevId_, + static_cast(message->type_), message->content_); +} + +int32_t DMicClient::InitSenderEngine(IAVEngineProvider *providerPtr) +{ + DHLOGI("Init SenderEngine"); + IsParamEnabled(AUDIO_ENGINE_FLAG, engineFlag_); + if (engineFlag_ == true) { + if (micTrans_ == nullptr) { + micTrans_ = std::make_shared(devId_, shared_from_this()); + } + int32_t ret = micTrans_->InitEngine(providerPtr); + if (ret != DH_SUCCESS) { + DHLOGE("Initialize av sender adapter failed. micclient"); + return ERR_DH_AUDIO_TRANS_NULL_VALUE; + } + } + return DH_SUCCESS; +} + int32_t DMicClient::OnStateChange(const AudioEventType type) { DHLOGD("On state change type: %d.", type); @@ -89,8 +129,14 @@ int32_t DMicClient::SetUp(const AudioParam ¶m) DHLOGE("Audio capturer create failed."); return ERR_DH_AUDIO_CLIENT_CREATE_CAPTURER_FAILED; } - - micTrans_ = std::make_shared(devId_); + // old new 方式归一 + if (engineFlag_ == false) { + micTrans_ = std::make_shared(devId_); + } + if (micTrans_ == nullptr) { + DHLOGE("mic trans in engine should be init by dev."); + return ERR_DH_AUDIO_NULLPTR; + } int32_t ret = micTrans_->SetUp(audioParam_, audioParam_, shared_from_this(), CAP_MIC); if (ret != DH_SUCCESS) { DHLOGE("Mic trans setup failed."); @@ -100,6 +146,22 @@ int32_t DMicClient::SetUp(const AudioParam ¶m) return DH_SUCCESS; } +int32_t DMicClient::SendMessage(uint32_t type, std::string content, std::string dstDevId) +{ + DHLOGI("Send message to remote."); + if (type != static_cast(NOTIFY_OPEN_MIC_RESULT) && + type != static_cast(NOTIFY_CLOSE_MIC_RESULT)) { + DHLOGE("event type is not NOTIFY_OPEN_MIC or NOTIFY_CLOSE_MIC. type: %u", type); + return ERR_DH_AUDIO_NULLPTR; + } + if (micTrans_ == nullptr) { + DHLOGE("mic trans is null."); + return ERR_DH_AUDIO_NULLPTR; + } + micTrans_->SendMessage(type, content, dstDevId); + return DH_SUCCESS; +} + int32_t DMicClient::Release() { DHLOGI("Release mic client."); @@ -145,7 +207,6 @@ int32_t DMicClient::StartCapture() "daudio capturer start failed."); return ERR_DH_AUDIO_CLIENT_CAPTURER_START_FAILED; } - int32_t ret = micTrans_->Start(); if (ret != DH_SUCCESS) { DHLOGE("Mic trans start failed."); @@ -181,7 +242,6 @@ void DMicClient::CaptureThreadRunning() DHLOGE("Bytes read failed."); break; } - int32_t ret = micTrans_->FeedAudioData(audioData); if (ret != DH_SUCCESS) { DHLOGE("Failed to send data."); diff --git a/services/audioclient/spkclient/include/dspeaker_client.h b/services/audioclient/spkclient/include/dspeaker_client.h index 5738f18ea68226963d4691fe2ebc7e69c8462b28..deea2bd071af6977a6a9c25f5cfc76e14bd59141 100644 --- a/services/audioclient/spkclient/include/dspeaker_client.h +++ b/services/audioclient/spkclient/include/dspeaker_client.h @@ -34,6 +34,7 @@ #include "audio_status.h" #include "audio_decode_transport.h" #include "audio_event.h" +#include "av_receiver_engine_transport.h" #include "daudio_errorcode.h" #include "daudio_log.h" #include "iaudio_data_transport.h" @@ -44,7 +45,7 @@ namespace OHOS { namespace DistributedHardware { class DSpeakerClient : public IAudioDataTransCallback, - public ISpkClient, + public ISpkClient, public AVReceiverTransportCallback, public AudioStandard::VolumeKeyEventCallback, public AudioStandard::AudioRendererCallback, public std::enable_shared_from_this { @@ -59,6 +60,7 @@ public: int32_t OnDecodeTransDataDone(const std::shared_ptr &audioData) override; void OnVolumeKeyEvent(AudioStandard::VolumeEvent volumeEvent) override; void OnInterrupt(const AudioStandard::InterruptEvent &interruptEvent) override; + int32_t InitReceiverEngine(IAVEngineProvider *providerPtr) override; int32_t SetUp(const AudioParam ¶m) override; int32_t Release() override; int32_t StartRender() override; @@ -67,6 +69,11 @@ public: int32_t SetAudioParameters(const AudioEvent &event) override; void PlayStatusChange(const std::string &args) override; void SetAttrs(const std::string &devId, const std::shared_ptr &callback) override; + int32_t SendMessage(uint32_t type, std::string content, std::string dstDevId) override; + + void OnEngineTransEvent(const AVTransEvent &event) override; + void OnEngineTransMessage(const std::shared_ptr &message) override; + void OnEngineTransDataAvailable(const std::shared_ptr &audioData) override; private: std::string GetVolumeLevel(); @@ -96,6 +103,7 @@ private: std::unique_ptr audioRenderer_ = nullptr; std::shared_ptr speakerTrans_ = nullptr; std::weak_ptr eventCallback_; + bool engineFlag_ = false; }; } // DistributedHardware } // OHOS diff --git a/services/audioclient/spkclient/src/dspeaker_client.cpp b/services/audioclient/spkclient/src/dspeaker_client.cpp index fa1101a174836502c899dc63f20044d97e296d9a..9d085b471bd3e68737850de4700db48b692c3aa0 100644 --- a/services/audioclient/spkclient/src/dspeaker_client.cpp +++ b/services/audioclient/spkclient/src/dspeaker_client.cpp @@ -18,6 +18,7 @@ #include "daudio_constants.h" #include "daudio_hisysevent.h" #include "daudio_util.h" +#include "daudio_sink_manager.h" #undef DH_LOG_TAG #define DH_LOG_TAG "DSpeakerClient" @@ -29,6 +30,50 @@ DSpeakerClient::~DSpeakerClient() DHLOGD("Release speaker client."); } +void DSpeakerClient::OnEngineTransEvent(const AVTransEvent &event) +{ + if (event.type == EventType::EVENT_START_SUCCESS) { + OnStateChange(DATA_OPENED); + } else if ((event.type == EventType::EVENT_STOP_SUCCESS) || + (event.type == EventType::EVENT_CHANNEL_CLOSED) || + (event.type == EventType::EVENT_START_FAIL)) { + OnStateChange(DATA_CLOSED); + } +} + +void DSpeakerClient::OnEngineTransMessage(const std::shared_ptr &message) +{ + if (message == nullptr) { + DHLOGE("The parameter is nullptr"); + return; + } + DAudioSinkManager::GetInstance().HandleDAudioNotify(message->dstDevId_, message->dstDevId_, + static_cast(message->type_), message->content_); +} + +void DSpeakerClient::OnEngineTransDataAvailable(const std::shared_ptr &audioData) +{ + DHLOGE("On Engine Data available"); + OnDecodeTransDataDone(audioData); +} + +int32_t DSpeakerClient::InitReceiverEngine(IAVEngineProvider *providerPtr) +{ + DHLOGI("InitReceiverEngine enter."); + IsParamEnabled(AUDIO_ENGINE_FLAG, engineFlag_); + if (engineFlag_ == true) { + if (speakerTrans_ == nullptr) { + speakerTrans_ = std::make_shared(devId_, shared_from_this()); + } + int32_t ret = speakerTrans_->InitEngine(providerPtr); + if (ret != DH_SUCCESS) { + DHLOGE("Initialize av receiver adapter failed spkclient."); + return ERR_DH_AUDIO_TRANS_NULL_VALUE; + } + } + return DH_SUCCESS; +} + int32_t DSpeakerClient::SetUp(const AudioParam ¶m) { DHLOGD("Set up spk client: {sampleRate: %d, bitFormat: %d, channelMask: %d," + @@ -57,7 +102,13 @@ int32_t DSpeakerClient::SetUp(const AudioParam ¶m) } audioRenderer_ ->SetRendererCallback(shared_from_this()); - speakerTrans_ = std::make_shared(devId_); + if (engineFlag_ == false) { + speakerTrans_ = std::make_shared(devId_); + } + if (speakerTrans_ == nullptr) { + DHLOGE("Speaker trans should be init by dev."); + return ERR_DH_AUDIO_NULLPTR; + } int32_t ret = speakerTrans_->SetUp(audioParam_, audioParam_, shared_from_this(), CAP_SPK); if (ret != DH_SUCCESS) { DHLOGE("Speaker trans setup failed."); @@ -68,7 +119,6 @@ int32_t DSpeakerClient::SetUp(const AudioParam ¶m) DHLOGE("Speaker trans start failed."); return ret; } - auto pid = getpid(); ret = AudioStandard::AudioSystemManager::GetInstance()->RegisterVolumeKeyEventCallback(pid, shared_from_this()); if (ret != DH_SUCCESS) { @@ -429,10 +479,10 @@ void DSpeakerClient::Pause() if (renderDataThread_.joinable()) { renderDataThread_.join(); } + // wuhaobo todo pause engine if (speakerTrans_ == nullptr || speakerTrans_->Pause() != DH_SUCCESS) { DHLOGE("Speaker trans Pause failed."); } - if (audioRenderer_ != nullptr) { audioRenderer_->Flush(); } @@ -443,6 +493,7 @@ void DSpeakerClient::Pause() void DSpeakerClient::ReStart() { DHLOGI("ReStart"); + // wuhaobo todo pause engine if (speakerTrans_ == nullptr || speakerTrans_->Restart(audioParam_, audioParam_) != DH_SUCCESS) { DHLOGE("Speaker trans Restart failed."); } @@ -451,6 +502,22 @@ void DSpeakerClient::ReStart() clientStatus_ = AudioStatus::STATUS_START; } +int32_t DSpeakerClient::SendMessage(uint32_t type, std::string content, std::string dstDevId) +{ + DHLOGI("Send message to remote."); + if (type != static_cast(NOTIFY_OPEN_SPEAKER_RESULT) && + type != static_cast(NOTIFY_CLOSE_SPEAKER_RESULT)) { + DHLOGE("event type is not NOTIFY_OPEN_SPK or NOTIFY_CLOSE_SPK. type:%u", type); + return ERR_DH_AUDIO_NULLPTR; + } + if (speakerTrans_ == nullptr) { + DHLOGE("speaker trans is null."); + return ERR_DH_AUDIO_NULLPTR; + } + speakerTrans_->SendMessage(type, content, dstDevId); + return DH_SUCCESS; +} + void DSpeakerClient::PlayStatusChange(const std::string &args) { DHLOGD("Play status change, args: %s.", args.c_str()); diff --git a/services/audioclient/test/unittest/audioclienttestutils/include/daudio_test_utils.h b/services/audioclient/test/unittest/audioclienttestutils/include/daudio_test_utils.h index b492aecdaf4a62c31319bc3bdc108d947ad1efa0..e172743aee5877f5bfb7b20af8c08d57a2215e13 100644 --- a/services/audioclient/test/unittest/audioclienttestutils/include/daudio_test_utils.h +++ b/services/audioclient/test/unittest/audioclienttestutils/include/daudio_test_utils.h @@ -63,6 +63,21 @@ public: { return 0; } + + int32_t InitEngine(IAVEngineProvider *providerPtr) override + { + return 0; + } + + int32_t SendMessage(uint32_t type, std::string content, std::string dstDevId) override + { + return 0; + } + + int32_t CreateCtrl() override + { + return 0; + } }; } // namespace DistributedHardware } // namespace OHOS diff --git a/services/audioclient/test/unittest/micclient/BUILD.gn b/services/audioclient/test/unittest/micclient/BUILD.gn index 7a247d82d62d89bbe9ad1fe436a2e8fe0e0cd36a..f9c7c4fcc0dec7bef3dded43f8197e9f49722c5a 100644 --- a/services/audioclient/test/unittest/micclient/BUILD.gn +++ b/services/audioclient/test/unittest/micclient/BUILD.gn @@ -36,6 +36,8 @@ config("module_private_config") { "${audio_transport_path}/audiotransportstatus/interface", "${audio_transport_path}/encodetransport/include", "${audio_transport_path}/interface", + "${audio_transport_path}/receiverengine/include", + "${audio_transport_path}/senderengine/include", "${common_path}/include", "${fwk_common_path}/utils/include", "${services_path}/common/audioeventcallback", @@ -56,12 +58,16 @@ ohos_unittest("MicClientTest") { configs = [ ":module_private_config" ] deps = [ - "${services_path}/audioclient:distributed_audio_sink_client", + "${services_path}/audiomanager/servicesink:distributed_audio_sink", "//third_party/googletest:gmock", "//third_party/googletest:gtest_main", ] - external_deps = [ "audio_framework:audio_capturer" ] + external_deps = [ + "audio_framework:audio_capturer", + "distributed_hardware_fwk:distributed_av_receiver", + "distributed_hardware_fwk:distributed_av_sender", + ] } group("mic_client_test") { diff --git a/services/audioclient/test/unittest/spkclient/BUILD.gn b/services/audioclient/test/unittest/spkclient/BUILD.gn index db812ce56e7384876b01aa7eea2f0568a750f608..47575fcf4d564e2b878436a9b9b1be620c6f1f7c 100644 --- a/services/audioclient/test/unittest/spkclient/BUILD.gn +++ b/services/audioclient/test/unittest/spkclient/BUILD.gn @@ -41,6 +41,8 @@ config("module_private_config") { "${audio_transport_path}/audiotransportstatus/interface", "${audio_transport_path}/decodetransport/include", "${audio_transport_path}/interface", + "${audio_transport_path}/receiverengine/include", + "${audio_transport_path}/senderengine/include", "${common_path}/include", "${fwk_common_path}/utils/include", "${services_path}/common/audioeventcallback", @@ -61,13 +63,17 @@ ohos_unittest("SpeakerClientTest") { configs = [ ":module_private_config" ] deps = [ - "${services_path}/audioclient:distributed_audio_sink_client", + "${services_path}/audiomanager/servicesink:distributed_audio_sink", "${services_path}/common:distributed_audio_utils", "//third_party/googletest:gmock", "//third_party/googletest:gtest_main", ] - external_deps = [ "audio_framework:audio_client" ] + external_deps = [ + "audio_framework:audio_client", + "distributed_hardware_fwk:distributed_av_receiver", + "distributed_hardware_fwk:distributed_av_sender", + ] } group("spk_client_test") { diff --git a/services/audiomanager/managersink/include/daudio_sink_dev.h b/services/audiomanager/managersink/include/daudio_sink_dev.h index eac0f37878ee0572fc08f620006452cad2f33b93..ed345afa297afaf3753dd9083f54b62b1bbb418d 100644 --- a/services/audiomanager/managersink/include/daudio_sink_dev.h +++ b/services/audiomanager/managersink/include/daudio_sink_dev.h @@ -21,14 +21,16 @@ #include #include "nlohmann/json.hpp" - #include "daudio_sink_dev_ctrl_manager.h" #include "dmic_client.h" #include "dspeaker_client.h" -#include "task_queue.h" +#include "iaudio_event_callback.h" #include "imic_client.h" #include "ispk_client.h" -#include "iaudio_event_callback.h" +#include "i_av_engine_provider.h" +#include "i_av_receiver_engine_callback.h" +#include "task_queue.h" + #ifdef DAUDIO_SUPPORT_DIRECT #include "direct_dmic_client.h" #include "direct_dspeaker_client.h" @@ -45,8 +47,8 @@ public: int32_t AwakeAudioDev(); void SleepAudioDev(); - void NotifyEvent(const AudioEvent &audioEvent) override; + int32_t InitAVTransEngines(IAVEngineProvider *senderPtr, IAVEngineProvider *receiverPtr); private: int32_t TaskOpenCtrlChannel(const std::string &args); @@ -85,6 +87,8 @@ private: int32_t NotifyPlayStatusChange(const AudioEvent &audioEvent); void NotifySourceDev(const AudioEventType type, const std::string dhId, const int32_t result); int32_t from_json(const json &j, AudioParam &audioParam); + int32_t HandleEngineMessage(uint32_t type, std::string content, std::string devId); + int32_t SendAudioEventToRemote(const AudioEvent &event); private: std::mutex taskQueueMutex_; @@ -100,6 +104,7 @@ private: using DAudioSinkDevFunc = int32_t (DAudioSinkDev::*)(const AudioEvent &audioEvent); std::map memberFuncMap_; + bool engineFlag_ = false; }; } // DistributedHardware } // OHOS diff --git a/services/audiomanager/managersink/include/daudio_sink_manager.h b/services/audiomanager/managersink/include/daudio_sink_manager.h index 6edc7a7222bdea941fd063480e4e1d73a17ec576..799e55e77f42a2baef09a0375bbf257981c87c61 100644 --- a/services/audiomanager/managersink/include/daudio_sink_manager.h +++ b/services/audiomanager/managersink/include/daudio_sink_manager.h @@ -23,9 +23,18 @@ #include "daudio_sink_dev.h" #include "idaudio_source.h" +#include "i_av_engine_provider_callback.h" namespace OHOS { namespace DistributedHardware { +class EngineProviderListener : public IAVEngineProviderCallback { +public: + EngineProviderListener() {}; + ~EngineProviderListener() override {}; + + int32_t OnProviderEvent(const AVTransEvent &event) override; +}; + class DAudioSinkManager { DECLARE_SINGLE_INSTANCE_BASE(DAudioSinkManager); public: @@ -36,22 +45,31 @@ public: int32_t DAudioNotify(const std::string &devId, const std::string &dhId, const int32_t eventType, const std::string &eventContent); void OnSinkDevReleased(const std::string &devId); - void NotifyEvent(const std::string &devId, const int32_t eventType, const std::string &eventContent); - + void ClearAudioDev(const std::string &devId); + int32_t CreateAudioDevice(const std::string &devId); private: - static constexpr const char* DEVCLEAR_THREAD = "sinkClearTh"; - DAudioSinkManager(); ~DAudioSinkManager(); - void ClearAudioDev(const std::string &devId); - int32_t CreateAudioDevice(const std::string &devId); + int32_t LoadAVSenderEngineProvider(); + int32_t UnloadAVSenderEngineProvider(); + int32_t LoadAVReceiverEngineProvider(); + int32_t UnloadAVReceiverEngineProvider(); + +private: + static constexpr const char* DEVCLEAR_THREAD = "sinkClearTh"; std::mutex devMapMutex_; std::unordered_map> audioDevMap_; std::mutex remoteSvrMutex_; std::map> sourceServiceMap_; std::thread devClearThread_; std::string localNetworkId_; + + IAVEngineProvider *sendProviderPtr_ = nullptr; + IAVEngineProvider *rcvProviderPtr_ = nullptr; + void *pSHandler_ = nullptr; + void *pRHandler_ = nullptr; + bool engineFlag_ = false; }; } // DistributedHardware } // OHOS diff --git a/services/audiomanager/managersink/src/daudio_sink_dev.cpp b/services/audiomanager/managersink/src/daudio_sink_dev.cpp index bb0b6cc41cd48475f0eec19d0edc51b6335f4257..1f52767fde98244a51fc164d0967a8748b007857 100644 --- a/services/audiomanager/managersink/src/daudio_sink_dev.cpp +++ b/services/audiomanager/managersink/src/daudio_sink_dev.cpp @@ -52,6 +52,7 @@ DAudioSinkDev::DAudioSinkDev(const std::string &devId) : devId_(devId) memberFuncMap_[VOLUME_MUTE_SET] = &DAudioSinkDev::NotifySetMute; memberFuncMap_[VOLUME_CHANGE] = &DAudioSinkDev::NotifyVolumeChange; memberFuncMap_[CHANGE_PLAY_STATUS] = &DAudioSinkDev::NotifyPlayStatusChange; + IsParamEnabled(AUDIO_ENGINE_FLAG, engineFlag_); } DAudioSinkDev::~DAudioSinkDev() @@ -77,6 +78,22 @@ void DAudioSinkDev::SleepAudioDev() taskQueue_ = nullptr; } +int32_t DAudioSinkDev::InitAVTransEngines(IAVEngineProvider *senderPtr, IAVEngineProvider *receiverPtr) +{ + DHLOGI("Init InitAVTransEngines"); + if (engineFlag_ == true) { + // new 模式下只支持普通通路;后期音频框架支持后，全部支持 + micClient_ = std::make_shared(devId_, shared_from_this()); + micClient_->InitSenderEngine(senderPtr); + } + + if (engineFlag_ == true) { + speakerClient_ = std::make_shared(devId_, shared_from_this()); + speakerClient_->InitReceiverEngine(receiverPtr); + } + return DH_SUCCESS; +} + void DAudioSinkDev::NotifyEvent(const AudioEvent &audioEvent) { DHLOGD("Notify event, eventType: %d.", (int32_t)audioEvent.type); @@ -324,29 +341,31 @@ int32_t DAudioSinkDev::NotifyPlayStatusChange(const AudioEvent &audioEvent) int32_t DAudioSinkDev::TaskOpenCtrlChannel(const std::string &args) { DHLOGI("Open ctrl channel."); - if (args.length() > DAUDIO_MAX_JSON_LEN || args.empty()) { - return ERR_DH_AUDIO_SA_PARAM_INVALID; - } - json jParam = json::parse(args, nullptr, false); - if (!JsonParamCheck(jParam, { KEY_DH_ID })) { - return ERR_DH_AUDIO_FAILED; - } + if (engineFlag_ == false) { + if (args.length() > DAUDIO_MAX_JSON_LEN || args.empty()) { + return ERR_DH_AUDIO_SA_PARAM_INVALID; + } + json jParam = json::parse(args, nullptr, false); + if (!JsonParamCheck(jParam, { KEY_DH_ID })) { + return ERR_DH_AUDIO_FAILED; + } - if (audioCtrlMgr_ != nullptr && audioCtrlMgr_->IsOpened()) { - DHLOGD("Ctrl channel already opened."); - NotifySourceDev(NOTIFY_OPEN_CTRL_RESULT, jParam[KEY_DH_ID], DH_SUCCESS); - return DH_SUCCESS; - } + if (audioCtrlMgr_ != nullptr && audioCtrlMgr_->IsOpened()) { + DHLOGD("Ctrl channel already opened."); + NotifySourceDev(NOTIFY_OPEN_CTRL_RESULT, jParam[KEY_DH_ID], DH_SUCCESS); + return DH_SUCCESS; + } - audioCtrlMgr_ = std::make_shared(devId_, shared_from_this()); - int32_t ret = audioCtrlMgr_->SetUp(); - if (ret != DH_SUCCESS) { - DHLOGE("SetUp ctrl mgr failed, ret: %d.", ret); - NotifySourceDev(NOTIFY_OPEN_CTRL_RESULT, jParam[KEY_DH_ID], ERR_DH_AUDIO_FAILED); - return ret; - } + audioCtrlMgr_ = std::make_shared(devId_, shared_from_this()); + int32_t ret = audioCtrlMgr_->SetUp(); + if (ret != DH_SUCCESS) { + DHLOGE("SetUp ctrl mgr failed, ret: %d.", ret); + NotifySourceDev(NOTIFY_OPEN_CTRL_RESULT, jParam[KEY_DH_ID], ERR_DH_AUDIO_FAILED); + return ret; + } - NotifySourceDev(NOTIFY_OPEN_CTRL_RESULT, jParam[KEY_DH_ID], DH_SUCCESS); + NotifySourceDev(NOTIFY_OPEN_CTRL_RESULT, jParam[KEY_DH_ID], DH_SUCCESS); + } DHLOGI("Open ctrl channel success, notify open ctrl result."); return DH_SUCCESS; } @@ -354,21 +373,23 @@ int32_t DAudioSinkDev::TaskOpenCtrlChannel(const std::string &args) int32_t DAudioSinkDev::TaskCloseCtrlChannel(const std::string &args) { (void)args; - DHLOGD("Close ctrl channel."); - if (audioCtrlMgr_ == nullptr) { - DHLOGD("Ctrl channel already closed."); - return DH_SUCCESS; - } + if (engineFlag_ == false) { + DHLOGD("Close ctrl channel."); + if (audioCtrlMgr_ == nullptr) { + DHLOGD("Ctrl channel already closed."); + return DH_SUCCESS; + } - int32_t ret = audioCtrlMgr_->Stop(); - if (ret != DH_SUCCESS) { - DHLOGE("Stop ctrl mgr failed, ret: %d.", ret); - } - ret = audioCtrlMgr_->Release(); - if (ret != DH_SUCCESS) { - DHLOGE("Release ctrl mgr failed, ret: %d.", ret); + int32_t ret = audioCtrlMgr_->Stop(); + if (ret != DH_SUCCESS) { + DHLOGE("Stop ctrl mgr failed, ret: %d.", ret); + } + ret = audioCtrlMgr_->Release(); + if (ret != DH_SUCCESS) { + DHLOGE("Release ctrl mgr failed, ret: %d.", ret); + } + audioCtrlMgr_ = nullptr; } - audioCtrlMgr_ = nullptr; DHLOGD("Close ctrl channel success."); return DH_SUCCESS; } @@ -390,8 +411,12 @@ int32_t DAudioSinkDev::TaskOpenDSpeaker(const std::string &args) DHLOGE("Get audio param from json failed, error code %d.", ret); return ret; } - - if (speakerClient_ == nullptr) { + // new mode 下 spkclient应该在初始化就做 + if (engineFlag_ == true && speakerClient_ == nullptr) { + DHLOGE("speaker client should be init by dev."); + return ERR_DH_AUDIO_NULLPTR; + } + if (engineFlag_ == false && speakerClient_ == nullptr) { #ifdef DAUDIO_SUPPORT_DIRECT if (audioParam.renderOpts.renderFlags == MMAP_MODE) { DHLOGI("Try to mmap mode."); @@ -405,6 +430,7 @@ int32_t DAudioSinkDev::TaskOpenDSpeaker(const std::string &args) speakerClient_ = std::make_shared(devId_, shared_from_this()); #endif } + DHLOGI("Open speaker device."); ret = speakerClient_->SetUp(audioParam); if (ret != DH_SUCCESS) { DHLOGE("Setup speaker failed, ret: %d.", ret); @@ -439,7 +465,6 @@ int32_t DAudioSinkDev::TaskCloseDSpeaker(const std::string &args) closeStatus = false; } speakerClient_ = nullptr; - closeStatus ? NotifySourceDev(NOTIFY_CLOSE_SPEAKER_RESULT, spkDhId_, DH_SUCCESS) : NotifySourceDev(NOTIFY_CLOSE_SPEAKER_RESULT, spkDhId_, ERR_DH_AUDIO_FAILED); DHLOGI("Close speaker device task excute success."); @@ -463,9 +488,11 @@ int32_t DAudioSinkDev::TaskOpenDMic(const std::string &args) DHLOGE("Get audio param from json failed, error code %d.", ret); return ret; } - - do { - if (micClient_ == nullptr) { + if (engineFlag_ == true && micClient_ == nullptr) { + DHLOGE("Mic client should be init by dev."); + return ERR_DH_AUDIO_NULLPTR; + } + if (engineFlag_ == false && micClient_ == nullptr) { #ifdef DAUDIO_SUPPORT_DIRECT if (audioParam.captureOpts.capturerFlags == MMAP_MODE) { DHLOGI("Try to mmap mode."); @@ -476,9 +503,10 @@ int32_t DAudioSinkDev::TaskOpenDMic(const std::string &args) micClient_ = std::make_shared(devId_, shared_from_this()); } #else - micClient_ = std::make_shared(devId_, shared_from_this()); + micClient_ = std::make_shared(devId_, shared_from_this()); #endif - } + } + do { ret = micClient_->SetUp(audioParam); if (ret != DH_SUCCESS) { DHLOGE("Set up mic failed, ret: %d.", ret); @@ -517,7 +545,6 @@ int32_t DAudioSinkDev::TaskCloseDMic(const std::string &args) closeStatus = false; } micClient_ = nullptr; - closeStatus ? NotifySourceDev(NOTIFY_CLOSE_MIC_RESULT, micDhId_, DH_SUCCESS) : NotifySourceDev(NOTIFY_CLOSE_MIC_RESULT, micDhId_, ERR_DH_AUDIO_FAILED); DHLOGI("Close mic device task excute success."); @@ -573,30 +600,21 @@ int32_t DAudioSinkDev::TaskVolumeChange(const std::string &args) { DHLOGD("Audio volume changed."); AudioEvent event(AudioEventType::VOLUME_CHANGE, args); - if (audioCtrlMgr_ == nullptr) { - return ERR_DH_AUDIO_SA_SINKCTRLMGR_NOT_INIT; - } - return audioCtrlMgr_->SendAudioEvent(event); + return SendAudioEventToRemote(event); } int32_t DAudioSinkDev::TaskFocusChange(const std::string &args) { DHLOGD("Audio focus changed."); AudioEvent event(AudioEventType::AUDIO_FOCUS_CHANGE, args); - if (audioCtrlMgr_ == nullptr) { - return ERR_DH_AUDIO_SA_SINKCTRLMGR_NOT_INIT; - } - return audioCtrlMgr_->SendAudioEvent(event); + return SendAudioEventToRemote(event); } int32_t DAudioSinkDev::TaskRenderStateChange(const std::string &args) { DHLOGD("Audio render state changed."); AudioEvent event(AudioEventType::AUDIO_RENDER_STATE_CHANGE, args); - if (audioCtrlMgr_ == nullptr) { - return ERR_DH_AUDIO_SA_SINKCTRLMGR_NOT_INIT; - } - return audioCtrlMgr_->SendAudioEvent(event); + return SendAudioEventToRemote(event); } int32_t DAudioSinkDev::TaskPlayStatusChange(const std::string &args) @@ -611,6 +629,35 @@ int32_t DAudioSinkDev::TaskPlayStatusChange(const std::string &args) return DH_SUCCESS; } +int32_t DAudioSinkDev::SendAudioEventToRemote(const AudioEvent &event) +{ + if (engineFlag_ == false) { + if (audioCtrlMgr_ == nullptr) { + DHLOGE("Audio ctrl mgr not init."); + return ERR_DH_AUDIO_NULLPTR; + } + int32_t ret = audioCtrlMgr_->SendAudioEvent(event); + if (ret != DH_SUCCESS) { + DHLOGE("Task send audio event to remote failed."); + return ERR_DH_AUDIO_NULLPTR; + } + } else { + // because: type: VOLUME_CHANGE / AUDIO_FOCUS_CHANGE / AUDIO_RENDER_STATE_CHANGE + // so speakerClient + if (speakerClient_ == nullptr) { + DHLOGE("Audio ctrl mgr not init."); + return ERR_DH_AUDIO_NULLPTR; + } + int32_t ret = speakerClient_->SendMessage(static_cast(event.type), + event.content, devId_); + if (ret != DH_SUCCESS) { + DHLOGE("Task send message to remote failed."); + return ERR_DH_AUDIO_NULLPTR; + } + } + return DH_SUCCESS; +} + void DAudioSinkDev::OnTaskResult(int32_t resultCode, const std::string &result, const std::string &funcName) { (void)resultCode; @@ -629,8 +676,22 @@ void DAudioSinkDev::NotifySourceDev(const AudioEventType type, const std::string jEvent[KEY_EVENT_TYPE] = type; jEvent[KEY_RANDOM_TASK_CODE] = std::to_string(randomTaskCode); - DHLOGD("notify source dev, random task code: %s", std::to_string(randomTaskCode).c_str()); - DAudioSinkManager::GetInstance().DAudioNotify(devId_, dhId, type, jEvent.dump()); + if (engineFlag_ == false) { + DHLOGD("notify source dev, random task code: %s", std::to_string(randomTaskCode).c_str()); + DAudioSinkManager::GetInstance().DAudioNotify(devId_, dhId, type, jEvent.dump()); + } else { + DHLOGD("Notify source dev, new engine, random task code:%s", std::to_string(randomTaskCode).c_str()); + if (speakerClient_ == nullptr || micClient_ == nullptr) { + DHLOGE("speaker client or mic client is null."); + return; + } + if (type == NOTIFY_OPEN_CTRL_RESULT || type == NOTIFY_CLOSE_CTRL_RESULT) { + DHLOGE("In new engine mode, ctrl is not allowed."); + return; + } + speakerClient_->SendMessage(static_cast(type), jEvent.dump(), devId_); + micClient_->SendMessage(static_cast(type), jEvent.dump(), devId_); + } } int32_t DAudioSinkDev::from_json(const json &j, AudioParam &audioParam) @@ -650,5 +711,11 @@ int32_t DAudioSinkDev::from_json(const json &j, AudioParam &audioParam) j.at(KEY_CAPTURE_FLAGS).get_to(audioParam.captureOpts.capturerFlags); return DH_SUCCESS; } + +int32_t DAudioSinkDev::HandleEngineMessage(uint32_t type, std::string content, std::string devId) +{ + DHLOGI("HandleEngineMessage enter."); + return DAudioSinkManager::GetInstance().HandleDAudioNotify(devId, devId, static_cast(type), content); +} } // namespace DistributedHardware } // namespace OHOS diff --git a/services/audiomanager/managersink/src/daudio_sink_manager.cpp b/services/audiomanager/managersink/src/daudio_sink_manager.cpp index 1dce0c3b907c46899952c3f914fb4238ba1fbbb1..487785f891680a91aa46fa8c8c637ddbc211e047 100644 --- a/services/audiomanager/managersink/src/daudio_sink_manager.cpp +++ b/services/audiomanager/managersink/src/daudio_sink_manager.cpp @@ -15,6 +15,7 @@ #include "daudio_sink_manager.h" +#include #include "if_system_ability_manager.h" #include "iservice_registry.h" @@ -29,6 +30,17 @@ namespace OHOS { namespace DistributedHardware { IMPLEMENT_SINGLE_INSTANCE(DAudioSinkManager); +using AVTransProviderClass = IAVEngineProvider *(*)(const std::string &); + +const std::string SENDER_SO_NAME = "libdistributed_av_sender.z.so"; +const std::string GET_SENDER_PROVIDER_FUNC = "GetAVSenderEngineProvider"; +const std::string RECEIVER_SO_NAME = "libdistributed_av_receiver.z.so"; +const std::string GET_RECEIVER_PROVIDER_FUNC = "GetAVReceiverEngineProvider"; +#ifdef __LP64__ +const std::string LIB_LOAD_PATH = "/system/lib64/"; +#else +const std::string LIB_LOAD_PATH = "/system/lib/"; +#endif DAudioSinkManager::DAudioSinkManager() { DHLOGD("Distributed audio sink manager constructed."); @@ -50,12 +62,43 @@ int32_t DAudioSinkManager::Init() DHLOGE("Get local network id failed, ret: %d.", ret); return ret; } + // new 方式 + IsParamEnabled(AUDIO_ENGINE_FLAG, engineFlag_); + if (engineFlag_ == true) { + ret = LoadAVReceiverEngineProvider(); + if (ret != DH_SUCCESS || rcvProviderPtr_ == nullptr) { + DHLOGE("Load av transport receiver engine provider failed."); + return ERR_DH_AUDIO_FAILED; + } + ret = rcvProviderPtr_->RegisterProviderCallback(std::make_shared()); + if (ret != DH_SUCCESS) { + DHLOGE("Register av transport receiver Provider Callback failed."); + return ERR_DH_AUDIO_FAILED; + } + DHLOGI("LoadAVReceiverEngineProvider success."); + + ret = LoadAVSenderEngineProvider(); + if (ret != DH_SUCCESS || sendProviderPtr_ == nullptr) { + DHLOGI("Load av transport sender engine provider failed."); + return ERR_DH_AUDIO_FAILED; + } + ret = sendProviderPtr_->RegisterProviderCallback(std::make_shared()); + if (ret != DH_SUCCESS) { + DHLOGE("Register av transport sender Provider Callback failed."); + return ERR_DH_AUDIO_FAILED; + } + DHLOGE("LoadAVSenderEngineProvider success."); + } return DH_SUCCESS; } int32_t DAudioSinkManager::UnInit() { DHLOGI("UnInit audio sink manager."); + if (engineFlag_ == true) { + UnloadAVSenderEngineProvider(); + UnloadAVReceiverEngineProvider(); + } { std::lock_guard remoteSvrLock(remoteSvrMutex_); sourceServiceMap_.clear(); @@ -90,13 +133,15 @@ void DAudioSinkManager::OnSinkDevReleased(const std::string &devId) int32_t DAudioSinkManager::HandleDAudioNotify(const std::string &devId, const std::string &dhId, const int32_t eventType, const std::string &eventContent) { - DHLOGD("Receive audio event from devId: %s, event type: %d.", GetAnonyString(devId).c_str(), eventType); + DHLOGD("Receive audio event from devId: %s, event type: %d. event content: %s.", + GetAnonyString(devId).c_str(), eventType, eventContent.c_str()); - if (eventContent.length() > DAUDIO_MAX_JSON_LEN || eventContent.empty() || !CheckIsNum(dhId) + if (eventContent.length() > DAUDIO_MAX_JSON_LEN || eventContent.empty() || !CheckDevIdIsLegal(devId) || eventType < 0 || eventType > MAX_EVENT_TYPE_NUM) { return ERR_DH_AUDIO_FAILED; } + // now ctrl channel is also goto here, please sure here not crash. json jParam = json::parse(eventContent, nullptr, false); if (JsonParamCheck(jParam, { KEY_RANDOM_TASK_CODE })) { DHLOGD("Receive audio notify from source, random task code: %s", @@ -115,11 +160,21 @@ int32_t DAudioSinkManager::HandleDAudioNotify(const std::string &devId, const st int32_t DAudioSinkManager::CreateAudioDevice(const std::string &devId) { DHLOGI("Create audio sink dev."); + std::lock_guard lock(devMapMutex_); + if (audioDevMap_.find(devId) != audioDevMap_.end()) { + DHLOGI("Audio sink dev in map. devId: %s.", GetAnonyString(devId).c_str()); + return DH_SUCCESS; + } auto dev = std::make_shared(devId); if (dev->AwakeAudioDev() != DH_SUCCESS) { DHLOGE("Awake audio dev failed."); return ERR_DH_AUDIO_FAILED; } + int32_t ret = dev->InitAVTransEngines(sendProviderPtr_, rcvProviderPtr_); + if (ret != DH_SUCCESS) { + DHLOGE("Init av transport sender engine failed."); + return ERR_DH_AUDIO_FAILED; + } audioDevMap_.emplace(devId, dev); return DH_SUCCESS; } @@ -185,5 +240,95 @@ void DAudioSinkManager::ClearAudioDev(const std::string &devId) dev->second->SleepAudioDev(); audioDevMap_.erase(devId); } + +int32_t DAudioSinkManager::LoadAVReceiverEngineProvider() +{ + DHLOGI("LoadAVReceiverEngineProvider enter"); + char path[PATH_MAX + 1] = {0x00}; + if ((LIB_LOAD_PATH.length() + RECEIVER_SO_NAME.length()) > PATH_MAX || + realpath((LIB_LOAD_PATH + RECEIVER_SO_NAME).c_str(), path) == nullptr) { + DHLOGE("File open failed"); + return ERR_DH_AUDIO_TRANS_NULL_VALUE; + } + pRHandler_ = dlopen(path, RTLD_LAZY | RTLD_NODELETE); + if (pRHandler_ == nullptr) { + DHLOGE("%s handler load failed, failed reason : %s", path, dlerror()); + return ERR_DH_AUDIO_TRANS_NULL_VALUE; + } + AVTransProviderClass getEngineFactoryFunc = (AVTransProviderClass)dlsym(pRHandler_, + GET_RECEIVER_PROVIDER_FUNC.c_str()); + if (getEngineFactoryFunc == nullptr) { + DHLOGE("av transport engine factory function handler is null, failed reason : %s", dlerror()); + dlclose(pRHandler_); + pRHandler_ = nullptr; + return ERR_DH_AUDIO_TRANS_NULL_VALUE; + } + rcvProviderPtr_ = getEngineFactoryFunc(OWNER_NAME_D_SPEAKER); + DHLOGE("LoadAVReceiverEngineProvider success"); + return DH_SUCCESS; +} + +int32_t DAudioSinkManager::UnloadAVReceiverEngineProvider() +{ + DHLOGI("UnloadAVReceiverEngineProvider"); + if (pRHandler_ != nullptr) { + dlclose(pRHandler_); + pRHandler_ = nullptr; + } + return DH_SUCCESS; +} + +int32_t DAudioSinkManager::LoadAVSenderEngineProvider() +{ + DHLOGI("LoadAVSenderEngineProvider enter"); + char path[PATH_MAX + 1] = {0x00}; + if ((LIB_LOAD_PATH.length() + SENDER_SO_NAME.length()) > PATH_MAX || + realpath((LIB_LOAD_PATH + SENDER_SO_NAME).c_str(), path) == nullptr) { + DHLOGE("File open failed"); + return ERR_DH_AUDIO_TRANS_NULL_VALUE; + } + pSHandler_ = dlopen(path, RTLD_LAZY | RTLD_NODELETE); + if (pSHandler_ == nullptr) { + DHLOGE("%s handler load failed, failed reason : %s", path, dlerror()); + return ERR_DH_AUDIO_TRANS_NULL_VALUE; + } + AVTransProviderClass getEngineFactoryFunc = (AVTransProviderClass)dlsym(pSHandler_, + GET_SENDER_PROVIDER_FUNC.c_str()); + if (getEngineFactoryFunc == nullptr) { + DHLOGE("av transport engine factory function handler is null, failed reason : %s", dlerror()); + dlclose(pSHandler_); + pSHandler_ = nullptr; + return ERR_DH_AUDIO_TRANS_NULL_VALUE; + } + sendProviderPtr_ = getEngineFactoryFunc(OWNER_NAME_D_MIC); + return DH_SUCCESS; +} + +int32_t DAudioSinkManager::UnloadAVSenderEngineProvider() +{ + DHLOGI("UnloadAVSenderEngineProvider enter"); + if (pSHandler_ != nullptr) { + dlclose(pSHandler_); + pSHandler_ = nullptr; + } + return DH_SUCCESS; +} + +int32_t EngineProviderListener::OnProviderEvent(const AVTransEvent &event) +{ + DHLOGI("On provider event :%d", event.type); + if (event.type == EventType::EVENT_CHANNEL_OPENED) { + DHLOGI("CreateAudioDevice enter"); + DAudioSinkManager::GetInstance().CreateAudioDevice(event.peerDevId); + DHLOGI("CreateAudioDevice end"); + } else if (event.type == EventType::EVENT_CHANNEL_CLOSED) { + DHLOGI("CreateAudioDevice enter"); + DAudioSinkManager::GetInstance().ClearAudioDev(event.peerDevId); + DHLOGI("CreateAudioDevice end"); + } else { + DHLOGE("Invaild event type."); + } + return DH_SUCCESS; +} } // namespace DistributedHardware } // namespace OHOS diff --git a/services/audiomanager/managersource/include/daudio_source_dev.h b/services/audiomanager/managersource/include/daudio_source_dev.h index 632cf843ba95989b21f41cc27d5c64bd615826c0..dcbdd63f6d357ab28544a250de6cfef03b98d49e 100644 --- a/services/audiomanager/managersource/include/daudio_source_dev.h +++ b/services/audiomanager/managersource/include/daudio_source_dev.h @@ -26,8 +26,8 @@ #include "dmic_dev.h" #include "dspeaker_dev.h" #include "iaudio_event_callback.h" -#include "iaudio_datatrans_callback.h" #include "iaudio_data_transport.h" +#include "iaudio_datatrans_callback.h" #include "idaudio_ipc_callback.h" #include "idaudio_hdi_callback.h" #include "task_queue.h" @@ -105,6 +105,7 @@ private: int32_t CloseCtrlTrans(const AudioEvent &event, bool isSpk); AudioEventType getEventTypeFromArgs(const std::string &args); void to_json(json &j, const AudioParam ¶m); + int32_t SendAudioEventToRemote(const AudioEvent &event); private: static constexpr uint8_t RPC_WAIT_SECONDS = 2; @@ -133,6 +134,7 @@ private: using DAudioSourceDevFunc = int32_t (DAudioSourceDev::*)(const AudioEvent &audioEvent); std::map memberFuncMap_; std::map eventNotifyMap_; + bool engineFlag_ = false; }; } // DistributedHardware } // OHOS diff --git a/services/audiomanager/managersource/include/daudio_source_manager.h b/services/audiomanager/managersource/include/daudio_source_manager.h index 74ffe3c40fe30c97c760336ea7be0dca61646bc8..6a5b8c25e18346d5179c36a6b5e0024cab7c51b0 100644 --- a/services/audiomanager/managersource/include/daudio_source_manager.h +++ b/services/audiomanager/managersource/include/daudio_source_manager.h @@ -43,6 +43,12 @@ public: const std::string &eventContent); int32_t OnEnableDAudio(const std::string &devId, const std::string &dhId, const int32_t result); int32_t OnDisableDAudio(const std::string &devId, const std::string &dhId, const int32_t result); + int32_t LoadAVSenderEngineProvider(); + int32_t UnloadAVSenderEngineProvider(); + int32_t LoadAVReceiverEngineProvider(); + int32_t UnloadAVReceiverEngineProvider(); + IAVEngineProvider *getSenderProvider(); + IAVEngineProvider *getReceiverProvider(); private: DAudioSourceManager(); @@ -69,6 +75,11 @@ private: sptr ipcCallback_ = nullptr; std::shared_ptr daudioMgrCallback_ = nullptr; std::thread devClearThread_; + IAVEngineProvider *sendProviderPtr_ = nullptr; + IAVEngineProvider *rcvProviderPtr_ = nullptr; + void *pSHandler_ = nullptr; + void *pRHandler_ = nullptr; + bool engineFlag_ = false; }; } // DistributedHardware } // OHOS diff --git a/services/audiomanager/managersource/include/dmic_dev.h b/services/audiomanager/managersource/include/dmic_dev.h index 45772bd0b4b26e8b843888ff5bc4400b6241172b..7fe002aa29fbcdfd4d086c77e84f22dcb712ee09 100644 --- a/services/audiomanager/managersource/include/dmic_dev.h +++ b/services/audiomanager/managersource/include/dmic_dev.h @@ -23,10 +23,11 @@ #include "audio_param.h" #include "audio_status.h" +#include "av_receiver_engine_transport.h" #include "ashmem.h" #include "daudio_hdi_handler.h" -#include "iaudio_datatrans_callback.h" #include "iaudio_data_transport.h" +#include "iaudio_datatrans_callback.h" #include "iaudio_event_callback.h" #include "idaudio_hdi_callback.h" @@ -36,12 +37,18 @@ namespace OHOS { namespace DistributedHardware { class DMicDev : public IDAudioHdiCallback, public IAudioDataTransCallback, + public AVReceiverTransportCallback, public std::enable_shared_from_this { public: DMicDev(const std::string &devId, std::shared_ptr callback) : devId_(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); @@ -63,6 +70,7 @@ public: 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); @@ -96,7 +104,6 @@ private: std::queue> dataQueue_; std::set enabledPorts_; AudioStatus curStatus_ = AudioStatus::STATUS_IDLE; - // Mic capture parameters AudioParamHDF paramHDF_; AudioParam param_; @@ -118,6 +125,7 @@ private: std::thread enqueueDataThread_; std::mutex writeAshmemMutex_; std::condition_variable dataQueueCond_; + bool engineFlag_ = false; }; } // DistributedHardware } // OHOS diff --git a/services/audiomanager/managersource/include/dspeaker_dev.h b/services/audiomanager/managersource/include/dspeaker_dev.h index a6aa14f0a2be1e253749563af4615456d2d2a4bf..9d0359170dc296db1ad7c184fa091f3dea34f1a2 100644 --- a/services/audiomanager/managersource/include/dspeaker_dev.h +++ b/services/audiomanager/managersource/include/dspeaker_dev.h @@ -23,11 +23,12 @@ #include "audio_param.h" #include "ashmem.h" -#include "idaudio_hdi_callback.h" +#include "av_sender_engine_transport.h" #include "daudio_hdi_handler.h" -#include "iaudio_data_transport.h" #include "iaudio_event_callback.h" +#include "iaudio_data_transport.h" #include "iaudio_datatrans_callback.h" +#include "idaudio_hdi_callback.h" using json = nlohmann::json; @@ -35,11 +36,15 @@ namespace OHOS { namespace DistributedHardware { class DSpeakerDev : public IDAudioHdiCallback, public IAudioDataTransCallback, + public AVSenderTransportCallback, public std::enable_shared_from_this { public: DSpeakerDev(const std::string &devId, std::shared_ptr callback) : devId_(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); @@ -67,6 +72,7 @@ public: bool IsOpened(); int32_t Pause(); int32_t Restart(); + int32_t SendMessage(uint32_t type, std::string content, std::string dstDevId); AudioParam GetAudioParam() const; int32_t NotifyHdfAudioEvent(const AudioEvent &event); @@ -105,6 +111,7 @@ private: int64_t readTvSec_ = 0; int64_t readTvNSec_ = 0; std::thread enqueueDataThread_; + bool engineFlag_ = false; }; } // DistributedHardware } // OHOS diff --git a/services/audiomanager/managersource/src/daudio_source_dev.cpp b/services/audiomanager/managersource/src/daudio_source_dev.cpp index 1d11425558620dd12023e929d9f5017d7d2fc62e..0d32c7df1d80a35f836cc3f704d9bf6adba71fd2 100644 --- a/services/audiomanager/managersource/src/daudio_source_dev.cpp +++ b/services/audiomanager/managersource/src/daudio_source_dev.cpp @@ -65,6 +65,7 @@ DAudioSourceDev::DAudioSourceDev(const std::string &devId, const std::shared_ptr eventNotifyMap_[NOTIFY_CLOSE_MIC_RESULT] = EVENT_NOTIFY_CLOSE_MIC; eventNotifyMap_[NOTIFY_OPEN_CTRL_RESULT] = EVENT_NOTIFY_OPEN_CTRL; eventNotifyMap_[NOTIFY_CLOSE_CTRL_RESULT] = EVENT_NOTIFY_CLOSE_CTRL; + IsParamEnabled(AUDIO_ENGINE_FLAG, engineFlag_); } int32_t DAudioSourceDev::AwakeAudioDev() @@ -138,7 +139,6 @@ int32_t DAudioSourceDev::HandleOpenDSpeaker(const AudioEvent &event) if (ret != DH_SUCCESS) { return ret; } - auto task = GenerateTask(this, &DAudioSourceDev::TaskOpenDSpeaker, event.content, "Open Spk Device", &DAudioSourceDev::OnTaskResult); return taskQueue_->Produce(task); @@ -186,7 +186,6 @@ int32_t DAudioSourceDev::HandleOpenDMic(const AudioEvent &event) if (ret != DH_SUCCESS) { return ret; } - auto task = GenerateTask(this, &DAudioSourceDev::TaskOpenDMic, event.content, "Open Mic Device", &DAudioSourceDev::OnTaskResult); return taskQueue_->Produce(task); @@ -199,7 +198,6 @@ int32_t DAudioSourceDev::HandleCloseDMic(const AudioEvent &event) DHLOGE("Task queue is null."); return ERR_DH_AUDIO_NULLPTR; } - auto task = GenerateTask(this, &DAudioSourceDev::TaskCloseDMic, event.content, "Close Mic Device", &DAudioSourceDev::OnTaskResult); taskQueue_->Produce(task); @@ -225,26 +223,30 @@ int32_t DAudioSourceDev::HandleDMicClosed(const AudioEvent &event) int32_t DAudioSourceDev::OpenCtrlTrans(const AudioEvent &event) { - if (audioCtrlMgr_ == nullptr) { - audioCtrlMgr_ = std::make_shared(devId_, shared_from_this()); - } - if (!audioCtrlMgr_->IsOpened() && (HandleOpenCtrlTrans(event) != DH_SUCCESS)) { - DHLOGE("Open ctrl failed."); - return ERR_DH_AUDIO_SA_OPEN_CTRL_FAILED; + if (engineFlag_ == false) { + if (audioCtrlMgr_ == nullptr) { + audioCtrlMgr_ = std::make_shared(devId_, shared_from_this()); + } + if (!audioCtrlMgr_->IsOpened() && (HandleOpenCtrlTrans(event) != DH_SUCCESS)) { + DHLOGE("Open ctrl failed."); + return ERR_DH_AUDIO_SA_OPEN_CTRL_FAILED; + } } return DH_SUCCESS; } int32_t DAudioSourceDev::CloseCtrlTrans(const AudioEvent &event, bool isSpk) { - if (audioCtrlMgr_ == nullptr) { - DHLOGD("Ctrl already closed."); - return DH_SUCCESS; - } - if ((!isSpk && (speaker_ == nullptr || !speaker_->IsOpened())) || - (isSpk && (mic_ == nullptr || !mic_->IsOpened()))) { - DHLOGD("No distributed audio device used, close ctrl trans."); - return HandleCloseCtrlTrans(event); + if (engineFlag_ == false) { + if (audioCtrlMgr_ == nullptr) { + DHLOGD("Ctrl already closed."); + return DH_SUCCESS; + } + if ((!isSpk && (speaker_ == nullptr || !speaker_->IsOpened())) || + (isSpk && (mic_ == nullptr || !mic_->IsOpened()))) { + DHLOGD("No distributed audio device used, close ctrl trans."); + return HandleCloseCtrlTrans(event); + } } return DH_SUCCESS; } @@ -596,6 +598,14 @@ int32_t DAudioSourceDev::TaskOpenDSpeaker(const std::string &args) return ERR_DH_AUDIO_FAILED; } + if (engineFlag_ == true) { + 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()); int32_t ret = NotifySinkDev(OPEN_SPEAKER, jAudioParam, jParam[KEY_DH_ID]); @@ -603,6 +613,7 @@ int32_t DAudioSourceDev::TaskOpenDSpeaker(const std::string &args) DHLOGE("Notify sink open speaker failed, error code %d.", ret); return ret; } + ret = speaker_->SetUp(); if (ret != DH_SUCCESS) { DHLOGE("Speaker setup failed, error code %d.", ret); @@ -630,7 +641,6 @@ int32_t DAudioSourceDev::TaskCloseDSpeaker(const std::string &args) if (args.length() > DAUDIO_MAX_JSON_LEN || args.empty()) { return ERR_DH_AUDIO_SA_PARAM_INVALID; } - bool closeStatus = true; int32_t ret = speaker_->Stop(); if (ret != DH_SUCCESS) { @@ -665,6 +675,13 @@ int32_t DAudioSourceDev::TaskOpenDMic(const std::string &args) DHLOGE("Mic device not init"); return ERR_DH_AUDIO_SA_MIC_DEVICE_NOT_INIT; } + if (engineFlag_ == true) { + int32_t ret = mic_->InitReceiverEngine(DAudioSourceManager::GetInstance().getReceiverProvider()); + if (ret != DH_SUCCESS) { + DHLOGE("Init receiver engine failed."); + return ret; + } + } if (args.length() > DAUDIO_MAX_JSON_LEN || args.empty()) { return ERR_DH_AUDIO_SA_PARAM_INVALID; } @@ -679,7 +696,6 @@ int32_t DAudioSourceDev::TaskOpenDMic(const std::string &args) if (!JsonParamCheck(jParam, { KEY_DH_ID })) { return ERR_DH_AUDIO_FAILED; } - to_json(jAudioParam, mic_->GetAudioParam()); ret = NotifySinkDev(OPEN_MIC, jAudioParam, jParam[KEY_DH_ID]); if (ret != DH_SUCCESS) { @@ -695,7 +711,6 @@ int32_t DAudioSourceDev::TaskOpenDMic(const std::string &args) mic_->Release(); return ret; } - NotifyHDF(NOTIFY_OPEN_MIC_RESULT, HDF_EVENT_RESULT_SUCCESS); return DH_SUCCESS; } @@ -711,7 +726,6 @@ int32_t DAudioSourceDev::TaskCloseDMic(const std::string &args) if (args.length() > DAUDIO_MAX_JSON_LEN || args.empty()) { return ERR_DH_AUDIO_SA_PARAM_INVALID; } - bool closeStatus = true; int32_t ret = mic_->Stop(); if (ret != DH_SUCCESS) { @@ -742,38 +756,40 @@ int32_t DAudioSourceDev::TaskCloseDMic(const std::string &args) int32_t DAudioSourceDev::TaskOpenCtrlChannel(const std::string &args) { DHLOGI("Task open ctrl channel, args: %s.", args.c_str()); - if (audioCtrlMgr_ == nullptr) { - DHLOGE("Audio source ctrl mgr not init."); - return ERR_DH_AUDIO_NULLPTR; - } - if (args.length() > DAUDIO_MAX_JSON_LEN || args.empty()) { - DHLOGE("Task open ctrl channel, args length is invalid."); - return ERR_DH_AUDIO_SA_PARAM_INVALID; - } + if (engineFlag_ == false) { + if (audioCtrlMgr_ == nullptr) { + DHLOGE("Audio source ctrl mgr not init."); + return ERR_DH_AUDIO_NULLPTR; + } + if (args.length() > DAUDIO_MAX_JSON_LEN || args.empty()) { + DHLOGE("Task open ctrl channel, args length is invalid."); + return ERR_DH_AUDIO_SA_PARAM_INVALID; + } - json jAudioParam; - json jParam = json::parse(args, nullptr, false); - if (!JsonParamCheck(jParam, { KEY_DH_ID })) { - DHLOGE("Task open ctrl channel, json param check error."); - return ERR_DH_AUDIO_FAILED; - } - int32_t ret = NotifySinkDev(OPEN_CTRL, jAudioParam, jParam[KEY_DH_ID]); - if (ret != DH_SUCCESS) { - DHLOGE("Notify sink open ctrl failed."); - return ret; - } + json jAudioParam; + json jParam = json::parse(args, nullptr, false); + if (!JsonParamCheck(jParam, { KEY_DH_ID })) { + DHLOGE("Task open ctrl channel, json param check error."); + return ERR_DH_AUDIO_FAILED; + } + int32_t ret = NotifySinkDev(OPEN_CTRL, jAudioParam, jParam[KEY_DH_ID]); + if (ret != DH_SUCCESS) { + DHLOGE("Notify sink open ctrl failed."); + return ret; + } - ret = audioCtrlMgr_->SetUp(); - if (ret != DH_SUCCESS) { - DHLOGE("Set up audio ctrl failed."); - return ret; - } - ret = audioCtrlMgr_->Start(); - if (ret != DH_SUCCESS) { - DHLOGE("Start audio ctrl failed."); - audioCtrlMgr_->Release(); - audioCtrlMgr_ = nullptr; - return ret; + ret = audioCtrlMgr_->SetUp(); + if (ret != DH_SUCCESS) { + DHLOGE("Set up audio ctrl failed."); + return ret; + } + ret = audioCtrlMgr_->Start(); + if (ret != DH_SUCCESS) { + DHLOGE("Start audio ctrl failed."); + audioCtrlMgr_->Release(); + audioCtrlMgr_ = nullptr; + return ret; + } } DHLOGI("Task open ctrl channel success."); @@ -783,25 +799,27 @@ int32_t DAudioSourceDev::TaskOpenCtrlChannel(const std::string &args) int32_t DAudioSourceDev::TaskCloseCtrlChannel(const std::string &args) { DHLOGI("Task close ctrl channel, args: %s.", args.c_str()); - if (audioCtrlMgr_ == nullptr) { - DHLOGD("Audio source ctrl magr already closed."); - return DH_SUCCESS; - } + if (engineFlag_ == false) { + if (audioCtrlMgr_ == nullptr) { + DHLOGD("Audio source ctrl magr already closed."); + return DH_SUCCESS; + } - bool closeStatus = true; - int32_t ret = audioCtrlMgr_->Stop(); - if (ret != DH_SUCCESS) { - DHLOGE("Stop audio ctrl failed."); - closeStatus = false; - } - ret = audioCtrlMgr_->Release(); - if (ret != DH_SUCCESS) { - DHLOGE("Release audio ctrl failed."); - closeStatus = false; - } - audioCtrlMgr_ = nullptr; - if (!closeStatus) { - return ERR_DH_AUDIO_FAILED; + bool closeStatus = true; + int32_t ret = audioCtrlMgr_->Stop(); + if (ret != DH_SUCCESS) { + DHLOGE("Stop audio ctrl failed."); + closeStatus = false; + } + ret = audioCtrlMgr_->Release(); + if (ret != DH_SUCCESS) { + DHLOGE("Release audio ctrl failed."); + closeStatus = false; + } + audioCtrlMgr_ = nullptr; + if (!closeStatus) { + return ERR_DH_AUDIO_FAILED; + } } DHLOGI("Close audio ctrl channel success."); @@ -811,12 +829,8 @@ int32_t DAudioSourceDev::TaskCloseCtrlChannel(const std::string &args) int32_t DAudioSourceDev::TaskSetVolume(const std::string &args) { DHLOGD("Task set volume, args: %s.", args.c_str()); - if (audioCtrlMgr_ == nullptr) { - DHLOGE("Audio ctrl mgr not init."); - return ERR_DH_AUDIO_NULLPTR; - } AudioEvent event(getEventTypeFromArgs(args), args); - return audioCtrlMgr_->SendAudioEvent(event); + return SendAudioEventToRemote(event); } int32_t DAudioSourceDev::TaskChangeVolume(const std::string &args) @@ -840,12 +854,8 @@ int32_t DAudioSourceDev::TaskChangeRenderState(const std::string &args) int32_t DAudioSourceDev::TaskPlayStatusChange(const std::string &args) { DHLOGD("Task play status change, content: %s.", args.c_str()); - if (audioCtrlMgr_ == nullptr) { - DHLOGE("Audio ctrl mgr not init."); - return ERR_DH_AUDIO_NULLPTR; - } AudioEvent audioEvent(CHANGE_PLAY_STATUS, args); - int32_t ret = audioCtrlMgr_->SendAudioEvent(audioEvent); + int32_t ret = SendAudioEventToRemote(audioEvent); if (ret != DH_SUCCESS) { DHLOGE("Task Play status change failed."); } @@ -868,6 +878,34 @@ int32_t DAudioSourceDev::TaskPlayStatusChange(const std::string &args) } } +int32_t DAudioSourceDev::SendAudioEventToRemote(const AudioEvent &event) +{ + if (engineFlag_ == false) { + if (audioCtrlMgr_ == nullptr) { + DHLOGE("Audio ctrl mgr not init."); + return ERR_DH_AUDIO_NULLPTR; + } + int32_t ret = audioCtrlMgr_->SendAudioEvent(event); + if (ret != DH_SUCCESS) { + DHLOGE("Task send audio event to remote failed."); + return ERR_DH_AUDIO_NULLPTR; + } + } else { + // because: type: CHANGE_PLAY_STATUS / VOLUME_MUTE_SET / VOLUME_SET, so speaker + if (speaker_ == nullptr) { + DHLOGE("Audio ctrl mgr not init."); + return ERR_DH_AUDIO_NULLPTR; + } + int32_t ret = speaker_->SendMessage(static_cast(event.type), + event.content, devId_); + if (ret != DH_SUCCESS) { + DHLOGE("Task send message to remote failed."); + return ERR_DH_AUDIO_NULLPTR; + } + } + return DH_SUCCESS; +} + int32_t DAudioSourceDev::TaskSpkMmapStart(const std::string &args) { DHLOGI("Task spk mmap start, content: %s.", args.c_str()); @@ -937,7 +975,21 @@ 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, random task code: %s", std::to_string(randomTaskCode).c_str()); - DAudioSourceManager::GetInstance().DAudioNotify(devId_, dhId, type, jParam.dump()); + if (engineFlag_ == false) { + DAudioSourceManager::GetInstance().DAudioNotify(devId_, dhId, type, jParam.dump()); + } else { + DHLOGD("Notify sink dev, new engine, random task code:%s", std::to_string(randomTaskCode).c_str()); + if (speaker_ == nullptr || mic_ == nullptr) { + DHLOGE("speaker or mic dev is null."); + return ERR_DH_AUDIO_NULLPTR; + } + 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_); + } return WaitForRPC(static_cast(static_cast(type) + eventOffset)); } diff --git a/services/audiomanager/managersource/src/daudio_source_manager.cpp b/services/audiomanager/managersource/src/daudio_source_manager.cpp index 8eede27205f80210b18a3d7af9efbc93dadf235e..0c074e4b5be4fb5faf47f2e873c3abd2cd35a4de 100644 --- a/services/audiomanager/managersource/src/daudio_source_manager.cpp +++ b/services/audiomanager/managersource/src/daudio_source_manager.cpp @@ -15,6 +15,7 @@ #include "daudio_source_manager.h" +#include #include "if_system_ability_manager.h" #include "iservice_registry.h" @@ -30,10 +31,21 @@ namespace OHOS { namespace DistributedHardware { namespace { constexpr uint32_t MAX_DEVICE_ID_LENGTH = 200; -constexpr uint32_t MAX_DISTRIBUTED_HAREWARE_ID_LENGTH = 100; +constexpr uint32_t MAX_DISTRIBUTED_HARDWARE_ID_LENGTH = 100; } - IMPLEMENT_SINGLE_INSTANCE(DAudioSourceManager); +using AVTransProviderClass = IAVEngineProvider *(*)(const std::string &); + +const std::string SENDER_SO_NAME = "libdistributed_av_sender.z.so"; +const std::string GET_SENDER_PROVIDER_FUNC = "GetAVSenderEngineProvider"; +const std::string RECEIVER_SO_NAME = "libdistributed_av_receiver.z.so"; +const std::string GET_RECEIVER_PROVIDER_FUNC = "GetAVReceiverEngineProvider"; +#ifdef __LP64__ +const std::string LIB_LOAD_PATH = "/system/lib64/"; +#else +const std::string LIB_LOAD_PATH = "/system/lib/"; +#endif + DAudioSourceManager::DAudioSourceManager() { DHLOGD("Distributed audio source manager constructed."); @@ -65,12 +77,29 @@ int32_t DAudioSourceManager::Init(const sptr &callback) ipcCallback_ = callback; daudioMgrCallback_ = std::make_shared(); + IsParamEnabled(AUDIO_ENGINE_FLAG, engineFlag_); + if (engineFlag_ == true) { + int32_t ret = LoadAVSenderEngineProvider(); + if (ret != DH_SUCCESS) { + DHLOGE("load av transport sender engine provider failed"); + return ERR_DH_AUDIO_FAILED; + } + ret = LoadAVReceiverEngineProvider(); + if (ret != DH_SUCCESS) { + DHLOGE("load av transport receiver engine provider failed."); + return ERR_DH_AUDIO_FAILED; + } + } return DH_SUCCESS; } int32_t DAudioSourceManager::UnInit() { DHLOGI("Uninit audio source manager."); + if (engineFlag_ == true) { + UnloadAVReceiverEngineProvider(); + UnloadAVSenderEngineProvider(); + } { std::lock_guard lock(devMapMtx_); for (auto iter = audioDevMap_.begin(); iter != audioDevMap_.end(); iter++) { @@ -96,9 +125,9 @@ int32_t DAudioSourceManager::UnInit() static bool CheckParams(const std::string &devId, const std::string &dhId) { - DHLOGD("Checking oarams of daudio."); + DHLOGD("Checking params of daudio."); if (devId.empty() || dhId.empty() || - devId.size() > MAX_DEVICE_ID_LENGTH || dhId.size() > MAX_DISTRIBUTED_HAREWARE_ID_LENGTH) { + devId.size() > MAX_DEVICE_ID_LENGTH || dhId.size() > MAX_DISTRIBUTED_HARDWARE_ID_LENGTH) { return false; } return true; @@ -149,12 +178,13 @@ int32_t DAudioSourceManager::DisableDAudio(const std::string &devId, const std:: int32_t DAudioSourceManager::HandleDAudioNotify(const std::string &devId, const std::string &dhId, const int32_t eventType, const std::string &eventContent) { - DHLOGD("Handle distributed audio notify, devId: %s, dhId: %s, eventType: %d.", GetAnonyString(devId).c_str(), - dhId.c_str(), eventType); + DHLOGD("Receive audio event from devId: %s, event type: %d. event content: %s.", + GetAnonyString(devId).c_str(), eventType, eventContent.c_str()); if (eventContent.length() > DAUDIO_MAX_JSON_LEN || eventContent.empty()) { return ERR_DH_AUDIO_FAILED; } + // now ctrl channel is also goto here, please sure here not crash. json jParam = json::parse(eventContent, nullptr, false); if (JsonParamCheck(jParam, { KEY_RANDOM_TASK_CODE })) { DHLOGD("Receive audio notify from sink, random task code: %s", @@ -304,5 +334,90 @@ void DAudioSourceManager::ClearAudioDev(const std::string &devId) audioDevMap_.erase(devId); } } + +int32_t DAudioSourceManager::LoadAVSenderEngineProvider() +{ + DHLOGI("LoadAVSenderEngineProvider enter"); + char path[PATH_MAX + 1] = {0x00}; + if ((LIB_LOAD_PATH.length() + SENDER_SO_NAME.length()) > PATH_MAX || + realpath((LIB_LOAD_PATH + SENDER_SO_NAME).c_str(), path) == nullptr) { + DHLOGE("File open failed"); + return ERR_DH_AUDIO_TRANS_NULL_VALUE; + } + pSHandler_ = dlopen(path, RTLD_LAZY | RTLD_NODELETE); + if (pSHandler_ == nullptr) { + DHLOGE("%s handler load failed, failed reason : %s", path, dlerror()); + return ERR_DH_AUDIO_TRANS_NULL_VALUE; + } + AVTransProviderClass getEngineFactoryFunc = (AVTransProviderClass)dlsym(pSHandler_, + GET_SENDER_PROVIDER_FUNC.c_str()); + if (getEngineFactoryFunc == nullptr) { + DHLOGE("av transport engine factory function handler is null, failed reason : %s", dlerror()); + dlclose(pSHandler_); + pSHandler_ = nullptr; + return ERR_DH_AUDIO_TRANS_NULL_VALUE; + } + sendProviderPtr_ = getEngineFactoryFunc(OWNER_NAME_D_SPEAKER); + DHLOGI("LoadAVSenderEngineProvider exit"); + return DH_SUCCESS; +} + +int32_t DAudioSourceManager::UnloadAVSenderEngineProvider() +{ + DHLOGI("UnloadAVSenderEngineProvider enter"); + if (pSHandler_ != nullptr) { + dlclose(pSHandler_); + pSHandler_ = nullptr; + } + sendProviderPtr_ = nullptr; + return DH_SUCCESS; +} + +int32_t DAudioSourceManager::LoadAVReceiverEngineProvider() +{ + DHLOGI("LoadAVReceiverEngineProvider enter"); + char path[PATH_MAX + 1] = {0x00}; + if ((LIB_LOAD_PATH.length() + RECEIVER_SO_NAME.length()) > PATH_MAX || + realpath((LIB_LOAD_PATH + RECEIVER_SO_NAME).c_str(), path) == nullptr) { + DHLOGE("File canonicalization failed"); + return ERR_DH_AUDIO_TRANS_NULL_VALUE; + } + pRHandler_ = dlopen(path, RTLD_LAZY | RTLD_NODELETE); + if (pRHandler_ == nullptr) { + DHLOGE("%s handler load failed, failed reason : %s", path, dlerror()); + return ERR_DH_AUDIO_TRANS_NULL_VALUE; + } + AVTransProviderClass getEngineFactoryFunc = (AVTransProviderClass)dlsym(pRHandler_, + GET_RECEIVER_PROVIDER_FUNC.c_str()); + if (getEngineFactoryFunc == nullptr) { + DHLOGE("av transport engine factory function handler is null, failed reason : %s", dlerror()); + dlclose(pRHandler_); + pRHandler_ = nullptr; + return ERR_DH_AUDIO_TRANS_NULL_VALUE; + } + rcvProviderPtr_ = getEngineFactoryFunc(OWNER_NAME_D_MIC); + DHLOGE("LoadAVReceiverEngineProvider success"); + return DH_SUCCESS; +} + +int32_t DAudioSourceManager::UnloadAVReceiverEngineProvider() +{ + DHLOGI("UnloadAVReceiverEngineProvider"); + if (pRHandler_ != nullptr) { + dlclose(pRHandler_); + pRHandler_ = nullptr; + } + return DH_SUCCESS; +} + +IAVEngineProvider *DAudioSourceManager::getSenderProvider() +{ + return sendProviderPtr_; +} + +IAVEngineProvider *DAudioSourceManager::getReceiverProvider() +{ + return rcvProviderPtr_; +} } // DistributedHardware } // OHOS \ No newline at end of file diff --git a/services/audiomanager/managersource/src/dmic_dev.cpp b/services/audiomanager/managersource/src/dmic_dev.cpp index 484ad1f09fe726b6478c220a0f4f2c633b3411a6..f2f0d4993781286b4dd96ad1ef8845f1c546eabf 100644 --- a/services/audiomanager/managersource/src/dmic_dev.cpp +++ b/services/audiomanager/managersource/src/dmic_dev.cpp @@ -26,6 +26,7 @@ #include "daudio_hisysevent.h" #include "daudio_hitrace.h" #include "daudio_log.h" +#include "daudio_source_manager.h" #include "daudio_util.h" #undef DH_LOG_TAG @@ -34,6 +35,56 @@ namespace OHOS { namespace DistributedHardware { static constexpr size_t DATA_QUEUE_EXT_SIZE = 20; +void DMicDev::OnEngineTransEvent(const AVTransEvent &event) +{ + if (event.type == EventType::EVENT_START_SUCCESS) { + OnStateChange(DATA_OPENED); + } else if ((event.type == EventType::EVENT_STOP_SUCCESS) || + (event.type == EventType::EVENT_CHANNEL_CLOSED) || + (event.type == EventType::EVENT_START_FAIL)) { + OnStateChange(DATA_CLOSED); + } +} + +void DMicDev::OnEngineTransMessage(const std::shared_ptr &message) +{ + DHLOGI("On Engine message"); + if (message == nullptr) { + DHLOGE("The parameter is nullptr"); + return; + } + DAudioSourceManager::GetInstance().HandleDAudioNotify(message->dstDevId_, message->dstDevId_, + message->type_, message->content_); +} + +void DMicDev::OnEngineTransDataAvailable(const std::shared_ptr &audioData) +{ + DHLOGE("On Engine Data available"); + OnDecodeTransDataDone(audioData); +} + +int32_t DMicDev::InitReceiverEngine(IAVEngineProvider *providerPtr) +{ + DHLOGI("InitReceiverEngine enter."); + // new 方式 + IsParamEnabled(AUDIO_ENGINE_FLAG, engineFlag_); + if (engineFlag_ == true) { + if (micTrans_ == nullptr) { + micTrans_ = std::make_shared(devId_, shared_from_this()); + } + int32_t ret = micTrans_->InitEngine(providerPtr); + if (ret != DH_SUCCESS) { + DHLOGE("Initialize av receiver adapter failed. micdev"); + return ERR_DH_AUDIO_TRANS_NULL_VALUE; + } + ret = micTrans_->CreateCtrl(); + if (ret != DH_SUCCESS) { + DHLOGE("Create ctrl channel failed. micdev"); + return ERR_DH_AUDIO_TRANS_NULL_VALUE; + } + } + return DH_SUCCESS; +} int32_t DMicDev::EnableDMic(const int32_t dhId, const std::string &capability) { @@ -183,8 +234,13 @@ int32_t DMicDev::NotifyEvent(const std::string &devId, const int32_t dhId, const int32_t DMicDev::SetUp() { DHLOGI("Set up mic device."); - if (micTrans_ == nullptr) { + if (engineFlag_ == false) { micTrans_ = std::make_shared(devId_); + } else { + if (micTrans_ == nullptr) { + DHLOGE("mic trans should be init by dev."); + return ERR_DH_AUDIO_NULLPTR; + } } int32_t ret = micTrans_->SetUp(param_, param_, shared_from_this(), CAP_MIC); if (ret != DH_SUCCESS) { @@ -206,7 +262,6 @@ int32_t DMicDev::Start() DHLOGE("Mic trans start failed, ret: %d.", ret); return ret; } - std::unique_lock lck(channelWaitMutex_); auto status = channelWaitCond_.wait_for(lck, std::chrono::seconds(CHANNEL_WAIT_SECONDS), [this]() { return isTransReady_.load(); }); @@ -449,6 +504,21 @@ int32_t DMicDev::OnStateChange(const AudioEventType type) return DH_SUCCESS; } +int32_t DMicDev::SendMessage(uint32_t type, std::string content, std::string dstDevId) +{ + DHLOGI("Send message to remote."); + if (type != static_cast(OPEN_MIC) && type != static_cast(CLOSE_MIC)) { + DHLOGE("Send message to remote. not OPEN_MIC or CLOSE_MIC. type: %u", type); + return ERR_DH_AUDIO_NULLPTR; + } + if (micTrans_ == nullptr) { + DHLOGE("mic trans is null."); + return ERR_DH_AUDIO_NULLPTR; + } + micTrans_->SendMessage(type, content, dstDevId); + return DH_SUCCESS; +} + int32_t DMicDev::OnDecodeTransDataDone(const std::shared_ptr &audioData) { if (audioData == nullptr) { diff --git a/services/audiomanager/managersource/src/dspeaker_dev.cpp b/services/audiomanager/managersource/src/dspeaker_dev.cpp index 082f629cde10f86811411c0f66e73319e1789c57..d0adb2548d8181361c9ecc0b1e907a5231545650 100644 --- a/services/audiomanager/managersource/src/dspeaker_dev.cpp +++ b/services/audiomanager/managersource/src/dspeaker_dev.cpp @@ -28,6 +28,7 @@ #include "daudio_hisysevent.h" #include "daudio_hitrace.h" #include "daudio_log.h" +#include "daudio_source_manager.h" #include "daudio_util.h" #undef DH_LOG_TAG @@ -100,6 +101,51 @@ int32_t DSpeakerDev::DisableDevice(const int32_t dhId) return DH_SUCCESS; } +int32_t DSpeakerDev::InitSenderEngine(IAVEngineProvider *providerPtr) +{ + DHLOGI("InitSenderEngine enter"); + // new 方式 + IsParamEnabled(AUDIO_ENGINE_FLAG, engineFlag_); + if (engineFlag_ == true) { + if (speakerTrans_ == nullptr) { + speakerTrans_ = std::make_shared(devId_, shared_from_this()); + } + int32_t ret = speakerTrans_->InitEngine(providerPtr); + if (ret != DH_SUCCESS) { + DHLOGE("Initialize av sender adapter failed."); + return ERR_DH_AUDIO_TRANS_NULL_VALUE; + } + ret = speakerTrans_->CreateCtrl(); + if (ret != DH_SUCCESS) { + DHLOGE("Create ctrl channel failed."); + return ERR_DH_AUDIO_TRANS_NULL_VALUE; + } + } + return DH_SUCCESS; +} + +void DSpeakerDev::OnEngineTransEvent(const AVTransEvent &event) +{ + if (event.type == EventType::EVENT_START_SUCCESS) { + OnStateChange(DATA_OPENED); + } else if ((event.type == EventType::EVENT_STOP_SUCCESS) || + (event.type == EventType::EVENT_CHANNEL_CLOSED) || + (event.type == EventType::EVENT_START_FAIL)) { + OnStateChange(DATA_CLOSED); + } +} + +void DSpeakerDev::OnEngineTransMessage(const std::shared_ptr &message) +{ + DHLOGI("On Engine message, type:%d.", message->type_); + if (message == nullptr) { + DHLOGE("The parameter is nullptr"); + return; + } + DAudioSourceManager::GetInstance().HandleDAudioNotify(message->dstDevId_, message->dstDevId_, + message->type_, message->content_); +} + int32_t DSpeakerDev::OpenDevice(const std::string &devId, const int32_t dhId) { DHLOGI("Open speaker device devId: %s, dhId: %d.", GetAnonyString(devId).c_str(), dhId); @@ -196,7 +242,6 @@ int32_t DSpeakerDev::Start() DHLOGE("Speaker trans start failed, ret: %d.", ret); return ret; } - std::unique_lock lck(channelWaitMutex_); auto status = channelWaitCond_.wait_for(lck, std::chrono::seconds(CHANNEL_WAIT_SECONDS), [this]() { return isTransReady_.load(); }); @@ -299,7 +344,7 @@ int32_t DSpeakerDev::WriteStreamData(const std::string &devId, const int32_t dhI { DHLOGD("Write stream data, dhId:%d", dhId); if (speakerTrans_ == nullptr) { - DHLOGE("Read stream data, speaker trans is null."); + DHLOGE("Write stream data, speaker trans is null."); return ERR_DH_AUDIO_SA_SPEAKER_TRANS_NULL; } int32_t ret = speakerTrans_->FeedAudioData(data); @@ -320,6 +365,7 @@ int32_t DSpeakerDev::ReadMmapPosition(const std::string &devId, const int32_t dh time.tvNSec = readTvNSec_; return DH_SUCCESS; } + int32_t DSpeakerDev::RefreshAshmemInfo(const std::string &devId, const int32_t dhId, int32_t fd, int32_t ashmemLength, int32_t lengthPerTrans) { @@ -410,6 +456,21 @@ AudioParam DSpeakerDev::GetAudioParam() const return param_; } +int32_t DSpeakerDev::SendMessage(uint32_t type, std::string content, std::string dstDevId) +{ + DHLOGI("Send message to remote."); + if (type != static_cast(OPEN_SPEAKER)&& type != static_cast(CLOSE_SPEAKER)) { + DHLOGE("Send message to remote. not OPEN_SPK or CLOSE_SPK. type: %u", type); + return ERR_DH_AUDIO_NULLPTR; + } + if (speakerTrans_ == nullptr) { + DHLOGE("speaker trans is null."); + return ERR_DH_AUDIO_NULLPTR; + } + speakerTrans_->SendMessage(type, content, dstDevId); + return DH_SUCCESS; +} + int32_t DSpeakerDev::NotifyHdfAudioEvent(const AudioEvent &event) { int32_t ret = DAudioHdiHandler::GetInstance().NotifyEvent(devId_, curPort_, event); diff --git a/services/audiomanager/servicesink/BUILD.gn b/services/audiomanager/servicesink/BUILD.gn index b8d9dd431b990b6545e3516dc0995d4bb36d0d9e..e290f3c9fdf6ad6d0f977b84897c833d288c9904 100755 --- a/services/audiomanager/servicesink/BUILD.gn +++ b/services/audiomanager/servicesink/BUILD.gn @@ -23,14 +23,15 @@ ohos_shared_library("distributed_audio_sink") { include_dirs += [ "include", + "${audio_client_path}/interface", "${audio_client_path}/micclient/include", "${audio_client_path}/spkclient/include", "${audio_control_path}/controlsink/include", "${audio_processor_path}/encodeprocessor/include", "${audio_processor_path}/decodeprocessor/include", "${audio_processor_path}/interface", - "${audio_transport_path}/audiochannel/interface", "${audio_transport_path}/audiochannel/audiodatachannel/include", + "${audio_transport_path}/audiochannel/interface", "${audio_transport_path}/audioctrltransport/include", "${audio_transport_path}/audioctrltransport/interface", "${audio_transport_path}/audiotransportstatus/include", @@ -38,17 +39,17 @@ ohos_shared_library("distributed_audio_sink") { "${audio_transport_path}/decodetransport/include", "${audio_transport_path}/encodetransport/include", "${audio_transport_path}/interface", - "${common_path}/include", + "${audio_transport_path}/receiverengine/include", + "${audio_transport_path}/senderengine/include", "${common_path}/dfx_utils/include", - "${fwk_common_path}/utils/include", - "${fwk_utils_path}/include", + "${common_path}/include", "${innerkits_path}/native_cpp/audio_sink/include", "${innerkits_path}/native_cpp/audio_source/include", - "${services_path}/common/taskProcessor/include", - "${services_path}/common/audioparam", + "${services_path}/audiomanager/managersink/include", "${services_path}/common/audioeventcallback", "${services_path}/common/audiodata/include", - "${services_path}/audiomanager/managersink/include", + "${services_path}/common/audioparam", + "${services_path}/common/taskProcessor/include", "${softbusadapter_path}/include", ] @@ -60,6 +61,8 @@ ohos_shared_library("distributed_audio_sink") { } sources = [ + "${audio_client_path}/micclient/src/dmic_client.cpp", + "${audio_client_path}/spkclient/src/dspeaker_client.cpp", "${audio_control_path}/controlsink/src/daudio_sink_dev_ctrl_manager.cpp", "${innerkits_path}/native_cpp/audio_sink/src/daudio_sink_handler.cpp", "${innerkits_path}/native_cpp/audio_sink/src/daudio_sink_load_callback.cpp", @@ -71,11 +74,17 @@ ohos_shared_library("distributed_audio_sink") { "src/daudio_sink_stub.cpp", ] + if (distributed_audio_extension) { + sources += [ + "${distributedaudio_ext_path}/services/audioclient/directmicclient/src/direct_dmic_client.cpp", + "${distributedaudio_ext_path}/services/audioclient/directspkclient/src/direct_dspeaker_client.cpp", + ] + } + deps = [ "${audio_transport_path}/audioctrltransport:distributed_audio_control", "${audio_transport_path}/decodetransport:distributed_audio_decode_transport", "${audio_transport_path}/encodetransport:distributed_audio_encode_transport", - "${services_path}/audioclient:distributed_audio_sink_client", "${services_path}/common:distributed_audio_utils", ] @@ -84,8 +93,13 @@ ohos_shared_library("distributed_audio_sink") { "audio_framework:audio_client", "audio_framework:audio_renderer", "c_utils:utils", + "distributed_hardware_fwk:distributed_av_receiver", + "distributed_hardware_fwk:distributed_av_sender", + "distributed_hardware_fwk:libdhfwk_sdk", "drivers_interface_audio:libaudio_proxy_1.0", "dsoftbus:softbus_client", + "hdf_core:libhdf_ipc_adapter", + "hdf_core:libhdi", "hisysevent_native:libhisysevent", "hitrace_native:hitrace_meter", "ipc:ipc_core", diff --git a/services/audiomanager/servicesource/BUILD.gn b/services/audiomanager/servicesource/BUILD.gn index fcdf147634c62758e48878dc9d219c3608c9ff7c..c6b4da6dea1b22df1126f220e09ca209016cfa81 100755 --- a/services/audiomanager/servicesource/BUILD.gn +++ b/services/audiomanager/servicesource/BUILD.gn @@ -21,40 +21,45 @@ ohos_shared_library("distributed_audio_source") { "${driver_audio_path}/include", "${fwk_common_path}/utils/include", "${mediastandardfwk_path}/audiocapturer/include", - "${mediastandardfwk_path}/audiomanager/include", "${mediastandardfwk_path}/audiocommon/include", + "${mediastandardfwk_path}/audiomanager/include", ] include_dirs += [ "include", + "${audio_client_path}/micclient/include", + "${audio_client_path}/spkclient/include", "${audio_control_path}/controlsource/include", "${audio_hdi_proxy_path}/include", - "${audio_processor_path}/interface", "${audio_processor_path}/encodeprocessor/include", "${audio_processor_path}/decodeprocessor/include", - "${audio_transport_path}/interface", - "${audio_transport_path}/encodetransport/include", - "${audio_transport_path}/decodetransport/include", - "${audio_transport_path}/audioctrltransport/include", - "${audio_transport_path}/audioctrltransport/interface", + "${audio_processor_path}/interface", "${audio_transport_path}/audiochannel/interface", "${audio_transport_path}/audiochannel/audiodatachannel/include", + "${audio_transport_path}/audioctrltransport/include", + "${audio_transport_path}/audioctrltransport/interface", "${audio_transport_path}/audiotransportstatus/include", "${audio_transport_path}/audiotransportstatus/interface", - "${common_path}/include", + "${audio_transport_path}/decodetransport/include", + "${audio_transport_path}/encodetransport/include", + "${audio_transport_path}/interface", + "${audio_transport_path}/receiverengine/include", + "${audio_transport_path}/senderengine/include", "${common_path}/dfx_utils/include", + "${common_path}/include", "${distributedaudio_path}/audiohandler/include", - "${services_path}/hdfaudioclient/include", "${hdf_service_path}/hdi_service/common/include", + "${innerkits_path}/native_cpp/audio_sink/include", + "${innerkits_path}/native_cpp/audio_source/include", "${interfaces_path}/inner_kits/native_cpp/audio_sink/include", "${interfaces_path}/inner_kits/native_cpp/audio_source/include", - "${innerkits_path}/native_cpp/audio_source/include", - "${innerkits_path}/native_cpp/audio_sink/include", - "${services_path}/common/audioparam", - "${services_path}/common/taskProcessor/include", + "${services_path}/audiomanager/managersource/include", "${services_path}/common/audiodata/include", "${services_path}/common/audioeventcallback", - "${services_path}/audiomanager/managersource/include", + "${services_path}/common/audioparam", + "${services_path}/common/taskProcessor/include", + "${services_path}/hdfaudioclient/include", + "${services_path}/audiomanager/common/include", "${softbusadapter_path}/include", ] @@ -88,6 +93,8 @@ ohos_shared_library("distributed_audio_source") { external_deps = [ "c_utils:utils", + "distributed_hardware_fwk:distributed_av_receiver", + "distributed_hardware_fwk:distributed_av_sender", "drivers_interface_audio:libaudio_proxy_1.0", "dsoftbus:softbus_client", "hdf_core:libhdi", diff --git a/services/audiomanager/test/unittest/audiomanagertestutils/include/audio_manager_test_utils.h b/services/audiomanager/test/unittest/audiomanagertestutils/include/audio_manager_test_utils.h index d3b2886390ccc65273528c55f1810cd6e86cc3db..65119d11f2599b62d100c0aa4a3d27944517a05f 100644 --- a/services/audiomanager/test/unittest/audiomanagertestutils/include/audio_manager_test_utils.h +++ b/services/audiomanager/test/unittest/audiomanagertestutils/include/audio_manager_test_utils.h @@ -73,6 +73,21 @@ public: { return DH_SUCCESS; } + + int32_t InitEngine(IAVEngineProvider *providerPtr) override + { + return DH_SUCCESS; + } + + int32_t SendMessage(uint32_t type, std::string content, std::string dstDevId) override + { + return 0; + } + + int32_t CreateCtrl() override + { + return 0; + } }; } // namespace DistributedHardware } // namespace OHOS diff --git a/services/audiomanager/test/unittest/managersink/BUILD.gn b/services/audiomanager/test/unittest/managersink/BUILD.gn index 7b91891bbee6696dae384c9f342aaf3e280d4207..7b96ed36124a1ec1aa1bf575a5916a4d178a2598 100644 --- a/services/audiomanager/test/unittest/managersink/BUILD.gn +++ b/services/audiomanager/test/unittest/managersink/BUILD.gn @@ -50,6 +50,8 @@ config("module_private_config") { "${audio_transport_path}/decodetransport/include", "${audio_transport_path}/encodetransport/include", "${audio_transport_path}/interface", + "${audio_transport_path}/receiverengine/include", + "${audio_transport_path}/senderengine/include", "${common_path}/include", "${innerkits_path}/native_cpp/audio_source/include", "${services_path}/audiomanager/managersink/include", @@ -70,7 +72,6 @@ ohos_unittest("DaudioSinkDevTest") { configs = [ ":module_private_config" ] deps = [ - "${services_path}/audioclient:distributed_audio_sink_client", "${services_path}/audiomanager/servicesink:distributed_audio_sink", "//third_party/googletest:gmock", "//third_party/googletest:gtest_main", @@ -81,6 +82,8 @@ ohos_unittest("DaudioSinkDevTest") { "audio_framework:audio_client", "audio_framework:audio_renderer", "c_utils:utils", + "distributed_hardware_fwk:distributed_av_receiver", + "distributed_hardware_fwk:distributed_av_sender", "drivers_interface_audio:libaudio_proxy_1.0", "hdf_core:libhdf_ipc_adapter", "hdf_core:libhdf_utils", @@ -101,7 +104,6 @@ ohos_unittest("DAudioSinkManagerTest") { configs = [ ":module_private_config" ] deps = [ - "${services_path}/audioclient:distributed_audio_sink_client", "${services_path}/audiomanager/servicesink:distributed_audio_sink", "//third_party/googletest:gmock", "//third_party/googletest:gtest_main", @@ -112,6 +114,8 @@ ohos_unittest("DAudioSinkManagerTest") { "audio_framework:audio_client", "audio_framework:audio_renderer", "c_utils:utils", + "distributed_hardware_fwk:distributed_av_receiver", + "distributed_hardware_fwk:distributed_av_sender", "drivers_interface_audio:libaudio_proxy_1.0", "hdf_core:libhdf_ipc_adapter", "hdf_core:libhdf_utils", diff --git a/services/audiomanager/test/unittest/servicesink/BUILD.gn b/services/audiomanager/test/unittest/servicesink/BUILD.gn index 3adbfa4c7f6574675f3cc1118a06df646669f439..aecb701515d5a10b9804fd266387b5aa650e9526 100644 --- a/services/audiomanager/test/unittest/servicesink/BUILD.gn +++ b/services/audiomanager/test/unittest/servicesink/BUILD.gn @@ -40,15 +40,17 @@ config("module_private_config") { "${audio_processor_path}/interface", "${audio_transport_path}/audiochannel/audiodatachannel/include", "${audio_transport_path}/audiochannel/interface", - "${audio_transport_path}/audio_channel/include", "${audio_transport_path}/audioctrltransport/interface", "${audio_transport_path}/audioctrltransport/include", + "${audio_transport_path}/audio_channel/include", "${audio_transport_path}/audiodatachannel/include", "${audio_transport_path}/audiotransportstatus/include", "${audio_transport_path}/audiotransportstatus/interface", "${audio_transport_path}/decodetransport/include", "${audio_transport_path}/encodetransport/include", "${audio_transport_path}/interface", + "${audio_transport_path}/receiverengine/include", + "${audio_transport_path}/senderengine/include", "${common_path}/include", "${innerkits_path}/native_cpp/audio_sink/include", "${innerkits_path}/native_cpp/audio_source/include", diff --git a/services/audiomanager/test/unittest/servicesource/BUILD.gn b/services/audiomanager/test/unittest/servicesource/BUILD.gn index 42461e9e7940680e4c377e80a8d63609ea29b28b..3cf4493f56bdb9a2a0b188d27a9d1716e93383b1 100644 --- a/services/audiomanager/test/unittest/servicesource/BUILD.gn +++ b/services/audiomanager/test/unittest/servicesource/BUILD.gn @@ -33,25 +33,34 @@ config("module_private_config") { ] include_dirs += [ + "${audio_control_path}/controlsource/include", + "${audio_hdi_proxy_path}/include", "${audio_processor_path}/decodeprocessor/include", "${audio_processor_path}/encodeprocessor/include", "${audio_processor_path}/interface", "${audio_transport_path}/audiochannel/audiodatachannel/include", "${audio_transport_path}/audiochannel/interface", - "${audio_transport_path}/audio_channel/include", "${audio_transport_path}/audioctrltransport/interface", "${audio_transport_path}/audioctrltransport/include", + "${audio_transport_path}/audio_channel/include", "${audio_transport_path}/audiodatachannel/include", "${audio_transport_path}/audiotransportstatus/include", "${audio_transport_path}/audiotransportstatus/interface", "${audio_transport_path}/decodetransport/include", "${audio_transport_path}/encodetransport/include", "${audio_transport_path}/interface", + "${audio_transport_path}/receiverengine/include", + "${audio_transport_path}/senderengine/include", "${common_path}/include", "${common_path}/dfx_utils/include", + "${distributedaudio_path}/audiohandler/include", + "${hdf_service_path}/hdi_service/common/include", "${innerkits_path}/native_cpp/audio_sink/include", "${innerkits_path}/native_cpp/audio_source/include", + "${interfaces_path}/inner_kits/native_cpp/audio_sink/include", + "${interfaces_path}/inner_kits/native_cpp/audio_source/include", "${services_path}/audiomanager/managersink/include", + "${services_path}/audiomanager/managersource/include", "${services_path}/audiomanager/servicesink/include", "${services_path}/audiomanager/servicesource/include", "${services_path}/audiomanager/test/unittest/managersink/include", @@ -61,14 +70,7 @@ config("module_private_config") { "${services_path}/common/audioeventcallback", "${services_path}/common/audioparam", "${services_path}/common/taskProcessor/include", - "${audio_control_path}/controlsource/include", - "${audio_hdi_proxy_path}/include", - "${distributedaudio_path}/audiohandler/include", "${services_path}/hdfaudioclient/include", - "${hdf_service_path}/hdi_service/common/include", - "${interfaces_path}/inner_kits/native_cpp/audio_sink/include", - "${interfaces_path}/inner_kits/native_cpp/audio_source/include", - "${services_path}/audiomanager/managersource/include", "${softbusadapter_path}/include", ] } diff --git a/services/audiomanager/test/unittest/sourcedevice/BUILD.gn b/services/audiomanager/test/unittest/sourcedevice/BUILD.gn index 0307a28c0f74cf98403733a4a7034da8fa3ab8c5..22d6de7c650699795b0437354a3a83741248610d 100644 --- a/services/audiomanager/test/unittest/sourcedevice/BUILD.gn +++ b/services/audiomanager/test/unittest/sourcedevice/BUILD.gn @@ -33,28 +33,30 @@ config("module_private_config") { "${audio_control_path}/controlsource/include", "${audio_hdi_proxy_path}/include", "${audio_processor_path}/interface", - "${audio_transport_path}/interface", "${audio_transport_path}/audioctrltransport/interface", "${audio_transport_path}/audiochannel/interface", "${audio_transport_path}/audiotransportstatus/include", "${audio_transport_path}/audiotransportstatus/interface", "${audio_transport_path}/encodetransport/include", "${audio_transport_path}/decodetransport/include", + "${audio_transport_path}/interface", + "${audio_transport_path}/receiverengine/include", + "${audio_transport_path}/senderengine/include", "${common_path}/include", "${common_path}/dfx_utils/include", "${distributedaudio_path}/audiohandler/include", - "${services_path}/hdfaudioclient/include", "${hdf_service_path}/hdi_service/common/include", - "${interfaces_path}/inner_kits/native_cpp/audio_sink/include", - "${interfaces_path}/inner_kits/native_cpp/audio_source/include", "${innerkits_path}/native_cpp/audio_source/include", "${innerkits_path}/native_cpp/audio_sink/include", + "${interfaces_path}/inner_kits/native_cpp/audio_sink/include", + "${interfaces_path}/inner_kits/native_cpp/audio_source/include", + "${services_path}/audiomanager/managersource/include", + "${services_path}/audiomanager/test/unittest/audiomanagertestutils/include", "${services_path}/common/audioparam", "${services_path}/common/taskProcessor/include", "${services_path}/common/audiodata/include", "${services_path}/common/audioeventcallback", - "${services_path}/audiomanager/managersource/include", - "${services_path}/audiomanager/test/unittest/audiomanagertestutils/include", + "${services_path}/hdfaudioclient/include", "${softbusadapter_path}/include", ] } @@ -79,6 +81,8 @@ ohos_unittest("DaudioSourceDevTest") { external_deps = [ "c_utils:utils", + "distributed_hardware_fwk:distributed_av_receiver", + "distributed_hardware_fwk:distributed_av_sender", "drivers_interface_audio:libaudio_proxy_1.0", "dsoftbus:softbus_client", "ipc:ipc_core", @@ -103,6 +107,8 @@ ohos_unittest("DMicDevTest") { ] external_deps = [ + "distributed_hardware_fwk:distributed_av_receiver", + "distributed_hardware_fwk:distributed_av_sender", "ipc:ipc_core", "samgr:samgr_proxy", ] @@ -125,6 +131,8 @@ ohos_unittest("DSpeakerDevTest") { ] external_deps = [ + "distributed_hardware_fwk:distributed_av_receiver", + "distributed_hardware_fwk:distributed_av_sender", "ipc:ipc_core", "samgr:samgr_proxy", ] diff --git a/services/audiomanager/test/unittest/sourcemanager/BUILD.gn b/services/audiomanager/test/unittest/sourcemanager/BUILD.gn index e7865ea6794ed1e8dfb229c95191df19b80d185d..5bc08fcfc5a73ecf6217bbf423e5fabb0e18ee21 100644 --- a/services/audiomanager/test/unittest/sourcemanager/BUILD.gn +++ b/services/audiomanager/test/unittest/sourcemanager/BUILD.gn @@ -33,25 +33,27 @@ config("module_private_config") { "${audio_control_path}/controlsource/include", "${audio_hdi_proxy_path}/include", "${audio_processor_path}/interface", - "${audio_transport_path}/interface", "${audio_transport_path}/audioctrltransport/interface", "${audio_transport_path}/audiotransportstatus/include", "${audio_transport_path}/audiotransportstatus/interface", + "${audio_transport_path}/interface", + "${audio_transport_path}/receiverengine/include", + "${audio_transport_path}/senderengine/include", "${common_path}/include", "${common_path}/dfx_utils/include", "${distributedaudio_path}/audiohandler/include", - "${services_path}/hdfaudioclient/include", "${hdf_service_path}/hdi_service/common/include", "${interfaces_path}/inner_kits/native_cpp/audio_sink/include", "${interfaces_path}/inner_kits/native_cpp/audio_source/include", "${innerkits_path}/native_cpp/audio_source/include", "${innerkits_path}/native_cpp/audio_sink/include", - "${services_path}/common/audioparam", - "${services_path}/common/taskProcessor/include", - "${services_path}/common/audiodata/include", - "${services_path}/common/audioeventcallback", "${services_path}/audiomanager/managersource/include", "${services_path}/audiomanager/servicesource/include", + "${services_path}/common/audiodata/include", + "${services_path}/common/audioeventcallback", + "${services_path}/common/audioparam", + "${services_path}/common/taskProcessor/include", + "${services_path}/hdfaudioclient/include", "${softbusadapter_path}/include", ] } @@ -75,6 +77,8 @@ ohos_unittest("DaudioSourceMgrTest") { external_deps = [ "c_utils:utils", + "distributed_hardware_fwk:distributed_av_receiver", + "distributed_hardware_fwk:distributed_av_sender", "drivers_interface_audio:libaudio_proxy_1.0", "dsoftbus:softbus_client", "hdf_core:libhdi", diff --git a/services/audiotransport/decodetransport/BUILD.gn b/services/audiotransport/decodetransport/BUILD.gn index 146fe6080f612ea3a0d911d9aecfb0fd39a3a096..1a33f93ebaad0a0698a891e30c4379d9c3e04eec 100644 --- a/services/audiotransport/decodetransport/BUILD.gn +++ b/services/audiotransport/decodetransport/BUILD.gn @@ -18,18 +18,17 @@ import("../../../distributedaudio.gni") config("decode_transport_pub_config") { include_dirs = [ "include", + "../audiochannel/audiodatachannel/include", + "../audiochannel/interface", "../audiotransportstatus/include", "../audiotransportstatus/interface", "../interface", - "../audiochannel/interface", - "../audiochannel/audiodatachannel/include", "../../audioprocessor/interface", ] } ohos_shared_library("distributed_audio_decode_transport") { include_dirs = [ - "${fwk_common_path}/utils/include", "${mediastandard_path}/interfaces/innerkits/native/media/include", "${mediastandardfwk_path}/audiocommon/include", "//third_party/json/include", @@ -37,19 +36,20 @@ ohos_shared_library("distributed_audio_decode_transport") { include_dirs += [ "include", - "${common_path}/include", - "${common_path}/dfx_utils/include", - "${audio_processor_path}/decoder/include", "${audio_processor_path}/decodeprocessor/include", + "${audio_processor_path}/decoder/include", "${audio_processor_path}/directprocessor/include", "${audio_processor_path}/interface", - "${audio_transport_path}/audiochannel/interface", "${audio_transport_path}/audiochannel/audiodatachannel/include", - "${audio_transport_path}/interface", + "${audio_transport_path}/audiochannel/interface", "${audio_transport_path}/audiotransportstatus/include", "${audio_transport_path}/audiotransportstatus/interface", - "${services_path}/common/audioparam", + "${audio_transport_path}/interface", + "${audio_transport_path}/receiverengine/include", + "${common_path}/include", + "${common_path}/dfx_utils/include", "${services_path}/common/audiodata/include", + "${services_path}/common/audioparam", "${softbusadapter_path}/include", ] @@ -60,6 +60,8 @@ ohos_shared_library("distributed_audio_decode_transport") { "${audio_processor_path}/decoder/src/audio_decoder.cpp", "${audio_processor_path}/decoder/src/audio_decoder_callback.cpp", "${audio_processor_path}/directprocessor/src/audio_direct_processor.cpp", + "${audio_transport_path}/receiverengine/src/av_receiver_engine_adapter.cpp", + "${audio_transport_path}/receiverengine/src/av_receiver_engine_transport.cpp", "${services_path}/common/audiodata/src/audio_data.cpp", "src/audio_decode_transport.cpp", ] @@ -72,6 +74,7 @@ ohos_shared_library("distributed_audio_decode_transport") { external_deps = [ "c_utils:utils", + "distributed_hardware_fwk:distributed_av_receiver", "dsoftbus:softbus_client", "hisysevent_native:libhisysevent", "hitrace_native:hitrace_meter", diff --git a/services/audiotransport/decodetransport/include/audio_decode_transport.h b/services/audiotransport/decodetransport/include/audio_decode_transport.h index 1ff3e7795ca60bdf6a68e623df8c93831bd309fb..1b675a1bdb25bcb509ec44d724d5100c17338726 100644 --- a/services/audiotransport/decodetransport/include/audio_decode_transport.h +++ b/services/audiotransport/decodetransport/include/audio_decode_transport.h @@ -52,6 +52,9 @@ public: int32_t Pause() override; int32_t Restart(const AudioParam &localParam, const AudioParam &remoteParam) override; int32_t FeedAudioData(std::shared_ptr &audioData) override; + int32_t CreateCtrl() override; + int32_t InitEngine(IAVEngineProvider *providerPtr) override; + int32_t SendMessage(uint32_t type, std::string content, std::string dstDevId) override; void OnSessionOpened() override; void OnSessionClosed() override; diff --git a/services/audiotransport/decodetransport/src/audio_decode_transport.cpp b/services/audiotransport/decodetransport/src/audio_decode_transport.cpp index c1b4da3d7589a0c73c90ba694a1b173c9a62ebf6..83fd38095f849e7a85e817b767fcad35a93f4170 100644 --- a/services/audiotransport/decodetransport/src/audio_decode_transport.cpp +++ b/services/audiotransport/decodetransport/src/audio_decode_transport.cpp @@ -138,6 +138,27 @@ int32_t AudioDecodeTransport::FeedAudioData(std::shared_ptr &audioDat return DH_SUCCESS; } +int32_t AudioDecodeTransport::CreateCtrl() +{ + DHLOGI("create ctrl not support."); + return DH_SUCCESS; +} + +int32_t AudioDecodeTransport::InitEngine(IAVEngineProvider *providerPtr) +{ + (void)providerPtr; + return DH_SUCCESS; +} + +int32_t AudioDecodeTransport::SendMessage(uint32_t type, std::string content, std::string dstDevId) +{ + (void)type; + (void)content; + (void)dstDevId; + DHLOGI("Send message not support."); + return DH_SUCCESS; +} + void AudioDecodeTransport::OnSessionOpened() { DHLOGI("On channel session opened."); diff --git a/services/audiotransport/encodetransport/BUILD.gn b/services/audiotransport/encodetransport/BUILD.gn index e1e62db6393f6f3efd7e0b3c973f33fb5187dede..a39df417e77257bc79aa7c825abe0bca696d4396 100644 --- a/services/audiotransport/encodetransport/BUILD.gn +++ b/services/audiotransport/encodetransport/BUILD.gn @@ -18,10 +18,10 @@ import("../../../distributedaudio.gni") config("encode_transport_pub_config") { include_dirs = [ "include", - "../audiotransportstatus/include", - "../audiotransportstatus/interface", "../audiochannel/audiodatachannel/include", "../audiochannel/interface", + "../audiotransportstatus/include", + "../audiotransportstatus/interface", "../interface", "../../audioprocessor/interface", ] @@ -29,7 +29,6 @@ config("encode_transport_pub_config") { ohos_shared_library("distributed_audio_encode_transport") { include_dirs = [ - "${fwk_common_path}/utils/include", "${mediastandard_path}/interfaces/innerkits/native/media/include", "${mediastandardfwk_path}/audiocommon/include", "//third_party/json/include", @@ -37,10 +36,8 @@ ohos_shared_library("distributed_audio_encode_transport") { include_dirs += [ "include", - "${common_path}/include", - "${common_path}/dfx_utils/include", - "${audio_processor_path}/encodeprocessor/include", "${audio_processor_path}/directprocessor/include", + "${audio_processor_path}/encodeprocessor/include", "${audio_processor_path}/encoder/include", "${audio_processor_path}/interface", "${audio_transport_path}/audiochannel/interface", @@ -48,8 +45,11 @@ ohos_shared_library("distributed_audio_encode_transport") { "${audio_transport_path}/audiotransportstatus/include", "${audio_transport_path}/audiotransportstatus/interface", "${audio_transport_path}/interface", - "${services_path}/common/audioparam", + "${audio_transport_path}/senderengine/include", + "${common_path}/dfx_utils/include", + "${common_path}/include", "${services_path}/common/audiodata/include", + "${services_path}/common/audioparam", "${softbusadapter_path}/include", ] @@ -60,6 +60,8 @@ ohos_shared_library("distributed_audio_encode_transport") { "${audio_processor_path}/encodeprocessor/src/audio_encoder_processor.cpp", "${audio_processor_path}/encoder/src/audio_encoder.cpp", "${audio_processor_path}/encoder/src/audio_encoder_callback.cpp", + "${audio_transport_path}/senderengine/src/av_sender_engine_adapter.cpp", + "${audio_transport_path}/senderengine/src/av_sender_engine_transport.cpp", "${services_path}/common/audiodata/src/audio_data.cpp", "src/audio_encode_transport.cpp", ] @@ -72,6 +74,7 @@ ohos_shared_library("distributed_audio_encode_transport") { external_deps = [ "c_utils:utils", + "distributed_hardware_fwk:distributed_av_sender", "dsoftbus:softbus_client", "hisysevent_native:libhisysevent", "hitrace_native:hitrace_meter", diff --git a/services/audiotransport/encodetransport/include/audio_encode_transport.h b/services/audiotransport/encodetransport/include/audio_encode_transport.h index 7616081c569e9bffc0512a542ce67b072688f127..3aabe6b807a6293e955179d0da94c40ffda53bc9 100644 --- a/services/audiotransport/encodetransport/include/audio_encode_transport.h +++ b/services/audiotransport/encodetransport/include/audio_encode_transport.h @@ -47,6 +47,9 @@ public: int32_t Pause() override; int32_t Restart(const AudioParam &localParam, const AudioParam &remoteParam) override; int32_t FeedAudioData(std::shared_ptr &audioData) override; + int32_t CreateCtrl() override; + int32_t InitEngine(IAVEngineProvider *providerPtr) override; + int32_t SendMessage(uint32_t type, std::string content, std::string dstDevId) override; void OnSessionOpened() override; void OnSessionClosed() override; diff --git a/services/audiotransport/encodetransport/src/audio_encode_transport.cpp b/services/audiotransport/encodetransport/src/audio_encode_transport.cpp index ec7bd07d9796d7fd352fe92aa3c06ef77b2cc6d3..84256bebe29b6df8754af1ae39886ebf6db57e16 100644 --- a/services/audiotransport/encodetransport/src/audio_encode_transport.cpp +++ b/services/audiotransport/encodetransport/src/audio_encode_transport.cpp @@ -146,6 +146,27 @@ int32_t AudioEncodeTransport::FeedAudioData(std::shared_ptr &audioDat } return DH_SUCCESS; } +int32_t AudioEncodeTransport::CreateCtrl() +{ + DHLOGI("create ctrl not support."); + return DH_SUCCESS; +} + +int32_t AudioEncodeTransport::InitEngine(IAVEngineProvider *providerPtr) +{ + (void)providerPtr; + DHLOGI("Init engine not support."); + return DH_SUCCESS; +} + +int32_t AudioEncodeTransport::SendMessage(uint32_t type, std::string content, std::string dstDevId) +{ + (void)type; + (void)content; + (void)dstDevId; + DHLOGI("Send message not support."); + return DH_SUCCESS; +} int32_t AudioEncodeTransport::InitAudioEncodeTrans(const AudioParam &localParam, const AudioParam &remoteParam, const PortCapType capType) diff --git a/services/audiotransport/interface/iaudio_data_transport.h b/services/audiotransport/interface/iaudio_data_transport.h index 7850e8406812ebac2bcccc3a7664744bb0cf4753..c90ccf1c2734ecfede5d4aca113e8a04f1ede5bb 100644 --- a/services/audiotransport/interface/iaudio_data_transport.h +++ b/services/audiotransport/interface/iaudio_data_transport.h @@ -19,6 +19,7 @@ #include "audio_data.h" #include "audio_param.h" #include "iaudio_datatrans_callback.h" +#include "i_av_engine_provider.h" namespace OHOS { namespace DistributedHardware { @@ -34,6 +35,9 @@ public: virtual int32_t Pause() = 0; virtual int32_t Restart(const AudioParam &localParam, const AudioParam &remoteParam) = 0; virtual int32_t FeedAudioData(std::shared_ptr &audioData) = 0; + virtual int32_t CreateCtrl() = 0; + virtual int32_t InitEngine(IAVEngineProvider *providerPtr) = 0; + virtual int32_t SendMessage(uint32_t type, std::string content, std::string dstDevId) = 0; }; } // namespace DistributedHardware } // namespace OHOS diff --git a/services/audiotransport/receiverengine/include/av_receiver_engine_adapter.h b/services/audiotransport/receiverengine/include/av_receiver_engine_adapter.h new file mode 100644 index 0000000000000000000000000000000000000000..43b34149d63b10e300bc87320448b675938fc3d5 --- /dev/null +++ b/services/audiotransport/receiverengine/include/av_receiver_engine_adapter.h @@ -0,0 +1,70 @@ +/* + * Copyright (c) 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_AV_TRANS_RECEIVER_ADAPTER_H +#define OHOS_AV_TRANS_RECEIVER_ADAPTER_H + +#include +#include +#include +#include + +#include "i_av_receiver_engine_callback.h" +#include "i_av_receiver_engine.h" +#include "i_av_engine_provider.h" + +namespace OHOS { +namespace DistributedHardware { +class AVReceiverAdapterCallback { +public: + AVReceiverAdapterCallback() {}; + virtual ~AVReceiverAdapterCallback() = default; + virtual void OnEngineEvent(const AVTransEvent &event) = 0; + virtual void OnEngineMessage(const std::shared_ptr &message) = 0; + virtual void OnEngineDataAvailable(const std::shared_ptr &buffer) = 0; +}; + +class AVTransReceiverAdapter : public IAVReceiverEngineCallback, + public std::enable_shared_from_this { +public: + AVTransReceiverAdapter() {}; + ~AVTransReceiverAdapter() override {}; + + int32_t Initialize(IAVEngineProvider *providerPtr, const std::string &peerDevId); + int32_t Start(); + int32_t Stop(); + int32_t Release(); + int32_t SetParameter(const AVTransTag &tag, const std::string &value); + int32_t SendMessageToRemote(const std::shared_ptr &message); + int32_t CreateControlChannel(const std::string &peerDevId); + int32_t RegisterAdapterCallback(const std::shared_ptr &callback); + + int32_t OnReceiverEvent(const AVTransEvent &event) override; + int32_t OnMessageReceived(const std::shared_ptr &message) override; + int32_t OnDataAvailable(const std::shared_ptr &buffer) override; + +private: + int32_t WaitForChannelCreated(); +private: + std::atomic initialized_ = false; + std::mutex chnCreatedMtx_; + std::shared_ptr receiverEngine_; + std::shared_ptr adapterCallback_; + std::atomic chnCreateSuccess_ = false; + std::condition_variable chnCreatedCondVar_; +}; +} // namespace DistributedHardware +} // namespace OHOS +#endif \ No newline at end of file diff --git a/services/audiotransport/receiverengine/include/av_receiver_engine_transport.h b/services/audiotransport/receiverengine/include/av_receiver_engine_transport.h new file mode 100644 index 0000000000000000000000000000000000000000..a52c941b84d6462465199ee87bdbbc228a91f60b --- /dev/null +++ b/services/audiotransport/receiverengine/include/av_receiver_engine_transport.h @@ -0,0 +1,79 @@ +/* + * Copyright (c) 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_AV_TRANS_RECEIVER_TRANS_H +#define OHOS_AV_TRANS_RECEIVER_TRANS_H + +#include +#include +#include + +#include "audio_data.h" +#include "audio_param.h" +#include "av_receiver_engine_adapter.h" +#include "iaudio_data_transport.h" +#include "iaudio_datatrans_callback.h" +#include "i_av_receiver_engine_callback.h" +#include "i_av_receiver_engine.h" +#include "i_av_engine_provider.h" + +namespace OHOS { +namespace DistributedHardware { +class AVReceiverTransportCallback { +public: + AVReceiverTransportCallback() {}; + virtual ~AVReceiverTransportCallback() = default; + virtual void OnEngineTransEvent(const AVTransEvent &event) = 0; + virtual void OnEngineTransMessage(const std::shared_ptr &message) = 0; + virtual void OnEngineTransDataAvailable(const std::shared_ptr &audioData) = 0; +}; + +class AVTransReceiverTransport : public IAudioDataTransport, + public AVReceiverAdapterCallback, + public std::enable_shared_from_this { +public: + AVTransReceiverTransport(const std::string &devId, + const std::shared_ptr &callback) + : transCallback_(callback), devId_(devId) {}; + ~AVTransReceiverTransport() override {}; + + int32_t SetUp(const AudioParam &localParam, const AudioParam &remoteParam, + const std::shared_ptr &callback, const PortCapType capType) override; + int32_t Start() override; + int32_t Stop() override; + int32_t Release() override; + int32_t Pause() override; + int32_t Restart(const AudioParam &localParam, const AudioParam &remoteParam) override; + int32_t FeedAudioData(std::shared_ptr &audioData) override; + int32_t CreateCtrl() override; + int32_t InitEngine(IAVEngineProvider *providerPtr) override; + int32_t SendMessage(uint32_t type, std::string content, std::string dstDevId) override; + + void OnEngineEvent(const AVTransEvent &event) override; + void OnEngineMessage(const std::shared_ptr &message) override; + void OnEngineDataAvailable(const std::shared_ptr &buffer) override; + +private: + int32_t SetParameter(const AudioParam &audioParam); + +private: + std::shared_ptr receiverAdapter_; + std::shared_ptr transCallback_; + std::string devId_; + AudioParam param_; +}; +} // namespace DistributedHardware +} // namespace OHOS +#endif \ No newline at end of file diff --git a/services/audiotransport/receiverengine/src/av_receiver_engine_adapter.cpp b/services/audiotransport/receiverengine/src/av_receiver_engine_adapter.cpp new file mode 100644 index 0000000000000000000000000000000000000000..19fe5c1582f61a86f32b4f5eaafb6b404fb14b06 --- /dev/null +++ b/services/audiotransport/receiverengine/src/av_receiver_engine_adapter.cpp @@ -0,0 +1,208 @@ +/* + * Copyright (c) 2023 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include "av_receiver_engine_adapter.h" + +#include + +#include "daudio_constants.h" +#include "daudio_errorcode.h" +#include "daudio_log.h" +#include "daudio_util.h" + +#undef DH_LOG_TAG +#define DH_LOG_TAG "AVTransReceiverAdapter" + +namespace OHOS { +namespace DistributedHardware { +constexpr int32_t WAIT_TIMEOUT_MS = 5000; +int32_t AVTransReceiverAdapter::Initialize(IAVEngineProvider *providerPtr, const std::string &peerDevId) +{ + DHLOGI("Initialize!"); + if (initialized_.load()) { + return DH_SUCCESS; + } + if (providerPtr == nullptr) { + return ERR_DH_AV_TRANS_NULL_VALUE; + } + receiverEngine_ = providerPtr->CreateAVReceiverEngine(peerDevId); + if (receiverEngine_ == nullptr) { + return ERR_DH_AV_TRANS_NULL_VALUE; + } + receiverEngine_->RegisterReceiverCallback(shared_from_this()); + initialized_ = true; + return DH_SUCCESS; +} + +int32_t AVTransReceiverAdapter::Release() +{ + DHLOGI("Release!"); + if (receiverEngine_ != nullptr) { + if (!receiverEngine_->Release()) { + DHLOGE("Release av transport receiver engine failed"); + } + } + initialized_ = false; + receiverEngine_ = nullptr; + return DH_SUCCESS; +} + +int32_t AVTransReceiverAdapter::Start() +{ + DHLOGI("Start enter"); + if (receiverEngine_ == nullptr) { + DHLOGE("Av transport receiver engine is null."); + return ERR_DH_AV_TRANS_NULL_VALUE; + } + return receiverEngine_->Start(); +} + +int32_t AVTransReceiverAdapter::Stop() +{ + DHLOGI("Stop!"); + if (receiverEngine_ == nullptr) { + return ERR_DH_AV_TRANS_NULL_VALUE; + } + int32_t ret = receiverEngine_->Stop(); + if (ret != DH_SUCCESS) { + return ERR_DH_AV_TRANS_STOP_FAILED; + } + DHLOGI("Stop success!"); + return DH_SUCCESS; +} + +int32_t AVTransReceiverAdapter::SetParameter(const AVTransTag &tag, const std::string ¶m) +{ + DHLOGI("SetParameter!"); + if (receiverEngine_ == nullptr) { + DHLOGE("av transport receiver engine is null"); + return ERR_DH_AV_TRANS_NULL_VALUE; + } + int32_t ret = receiverEngine_->SetParameter(tag, param); + if (ret != DH_SUCCESS) { + DHLOGE("Set av transport receiver parameter failed, ret: %d.", ret); + return ERR_DH_AV_TRANS_SETUP_FAILED; + } + return DH_SUCCESS; +} + +int32_t AVTransReceiverAdapter::CreateControlChannel(const std::string &peerDevId) +{ + DHLOGI("CreateControlChannel enter, peerDevId:%s", GetAnonyString(peerDevId).c_str()); + if (chnCreateSuccess_.load()) { + DHLOGI("Av transport receiver channel already created"); + return DH_SUCCESS; + } + + if (receiverEngine_ == nullptr) { + DHLOGE("Av transport receiver engine is null"); + return ERR_DH_AV_TRANS_NULL_VALUE; + } + std::vector dstDevIds = {peerDevId}; + int32_t ret = receiverEngine_->CreateControlChannel(dstDevIds, + ChannelAttribute{TransStrategy::LOW_LATANCY_STRATEGY}); + if (ret != DH_SUCCESS) { + DHLOGE("Create av transport receiver channel failed, ret: %d", ret); + return ERR_DH_AV_TRANS_CREATE_CHANNEL_FAILED; + } + ret = WaitForChannelCreated(); + if (ret != DH_SUCCESS) { + DHLOGE("Wait for create av transport sender channel failed, ret: %d", ret); + return ERR_DH_AV_TRANS_CREATE_CHANNEL_FAILED; + } + return DH_SUCCESS; +} + +int32_t AVTransReceiverAdapter::SendMessageToRemote(const std::shared_ptr &message) +{ + DHLOGI("Send message to remote."); + if (receiverEngine_ == nullptr) { + return ERR_DH_AV_TRANS_NULL_VALUE; + } + int32_t ret = receiverEngine_->SendMessage(message); + if (ret != DH_SUCCESS) { + DHLOGE("Send meassage to remote sender engine failed, ret: %d.", ret); + return ERR_DH_AV_TRANS_SEND_MSG_FAILED; + } + return DH_SUCCESS; +} + +int32_t AVTransReceiverAdapter::RegisterAdapterCallback(const std::shared_ptr &callback) +{ + if (callback == nullptr) { + return ERR_DH_AUDIO_TRANS_NULL_VALUE; + } + adapterCallback_ = callback; + return DH_SUCCESS; +} + +int32_t AVTransReceiverAdapter::WaitForChannelCreated() +{ + std::unique_lock lock(chnCreatedMtx_); + auto status = chnCreatedCondVar_.wait_for(lock, std::chrono::milliseconds(WAIT_TIMEOUT_MS)); + if (status == std::cv_status::timeout) { + DHLOGI("Wait for av transport receiver channel created timeout"); + return ERR_DH_AV_TRANS_TIMEOUT; + } + if (!chnCreateSuccess_.load()) { + DHLOGE("Create av transport receiver channel failed"); + return ERR_DH_AV_TRANS_CREATE_CHANNEL_FAILED; + } + return DH_SUCCESS; +} + +int32_t AVTransReceiverAdapter::OnReceiverEvent(const AVTransEvent &event) +{ + DHLOGI("On Receiver event, type: %d", event.type); + switch (event.type) { + case EventType::EVENT_CHANNEL_OPENED: { + chnCreateSuccess_ = (event.type == EventType::EVENT_CHANNEL_OPENED); + chnCreatedCondVar_.notify_one(); + break; + } + case EventType::EVENT_CHANNEL_CLOSED: + case EventType::EVENT_START_SUCCESS: + case EventType::EVENT_STOP_SUCCESS: + case EventType::EVENT_ENGINE_ERROR: + case EventType::EVENT_REMOTE_ERROR: + if (adapterCallback_ != nullptr) { + DHLOGI("callback on engine event."); + adapterCallback_->OnEngineEvent(event); + } + break; + default: + DHLOGI("Invaild event type"); + break; + } + return DH_SUCCESS; +} + +int32_t AVTransReceiverAdapter::OnMessageReceived(const std::shared_ptr &message) +{ + if (adapterCallback_ != nullptr) { + adapterCallback_->OnEngineMessage(message); + } + return DH_SUCCESS; +} + +int32_t AVTransReceiverAdapter::OnDataAvailable(const std::shared_ptr &buffer) +{ + if (adapterCallback_ != nullptr) { + adapterCallback_->OnEngineDataAvailable(buffer); + } + return DH_SUCCESS; +} +} // namespace DistributedHardware +} // namespace OHOS \ No newline at end of file diff --git a/services/audiotransport/receiverengine/src/av_receiver_engine_transport.cpp b/services/audiotransport/receiverengine/src/av_receiver_engine_transport.cpp new file mode 100644 index 0000000000000000000000000000000000000000..8cfdf66b391f75790c2bd9ef56f6c64bc48f1a18 --- /dev/null +++ b/services/audiotransport/receiverengine/src/av_receiver_engine_transport.cpp @@ -0,0 +1,212 @@ +/* + * Copyright (c) 2023 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include "av_receiver_engine_transport.h" + +#include +#include "daudio_constants.h" +#include "daudio_errorcode.h" +#include "daudio_log.h" +#include "daudio_util.h" + +#undef DH_LOG_TAG +#define DH_LOG_TAG "AVTransReceiverTransport" + +namespace OHOS { +namespace DistributedHardware { +int32_t AVTransReceiverTransport::InitEngine(IAVEngineProvider *providerPtr) +{ + DHLOGI("InitReceiverEngine enter."); + if (receiverAdapter_ == nullptr) { + receiverAdapter_ = std::make_shared(); + } + int32_t ret = receiverAdapter_->Initialize(providerPtr, devId_); + if (ret != DH_SUCCESS) { + DHLOGE("initialize av receiver adapter failed."); + return ERR_DH_AUDIO_TRANS_NULL_VALUE; + } + ret = receiverAdapter_->RegisterAdapterCallback(shared_from_this()); + if (ret != DH_SUCCESS) { + DHLOGE("InitReceiverEngine register callback error."); + } + return ret; +} + +int32_t AVTransReceiverTransport::SetUp(const AudioParam &localParam, const AudioParam &remoteParam, + const std::shared_ptr &callback, const PortCapType capType) +{ + (void)remoteParam; + (void)callback; + (void)capType; + param_ = localParam; + return DH_SUCCESS; +} + +int32_t AVTransReceiverTransport::CreateCtrl() +{ + DHLOGI("Create ctrl enter."); + if (receiverAdapter_ == nullptr) { + DHLOGE("av transport receiver adapter is null"); + return ERR_DH_AUDIO_TRANS_NULL_VALUE; + } + int32_t ret = receiverAdapter_->CreateControlChannel(devId_); + if (ret != DH_SUCCESS) { + DHLOGE("create av receiver control channel failed."); + return ERR_DH_AUDIO_TRANS_NULL_VALUE; + } + return DH_SUCCESS; +} + +int32_t AVTransReceiverTransport::Start() +{ + DHLOGI("StartReceiverEngine enter."); + if (receiverAdapter_ == nullptr) { + DHLOGE("av transport receiver adapter is null"); + return ERR_DH_AUDIO_TRANS_NULL_VALUE; + } + int32_t ret = SetParameter(param_); + if (ret != DH_SUCCESS) { + DHLOGE("Set parameter failed"); + return ERR_DH_AUDIO_TRANS_NULL_VALUE; + } + ret = receiverAdapter_->Start(); + if (ret != DH_SUCCESS) { + DHLOGE("start av receiver engine failed"); + return ERR_DH_AUDIO_TRANS_NULL_VALUE; + } + return DH_SUCCESS; +} + +int32_t AVTransReceiverTransport::Stop() +{ + DHLOGI("StopReceiverEngine enter."); + if (receiverAdapter_ == nullptr) { + DHLOGE("StopReceiverEngine adapter is null"); + return ERR_DH_AUDIO_TRANS_NULL_VALUE; + } + int32_t ret = receiverAdapter_->Stop(); + if (ret != DH_SUCCESS) { + DHLOGE("StopReceiveEngine error."); + return ERR_DH_AUDIO_TRANS_NULL_VALUE; + } + return DH_SUCCESS; +} + +int32_t AVTransReceiverTransport::Release() +{ + DHLOGI("ReleaseReceiverEngine enter."); + if (receiverAdapter_ == nullptr) { + DHLOGE("ReleaseReceiverEngine adapter is null"); + return ERR_DH_AUDIO_TRANS_NULL_VALUE; + } + int32_t ret = receiverAdapter_->Release(); + if (ret != DH_SUCCESS) { + DHLOGE("ReleaseReceiverEngine error."); + return ERR_DH_AUDIO_TRANS_NULL_VALUE; + } + return DH_SUCCESS; +} + +// wuhaobo todo pause +int32_t AVTransReceiverTransport::Pause() +{ + DHLOGI("Pause ReceiverEngine enter."); + return DH_SUCCESS; +} + +// wuhaobo todo restart +int32_t AVTransReceiverTransport::Restart(const AudioParam &localParam, const AudioParam &remoteParam) +{ + DHLOGI("ReStart ReceiverEngine enter."); + return DH_SUCCESS; +} + +int32_t AVTransReceiverTransport::FeedAudioData(std::shared_ptr &audioData) +{ + DHLOGI("ReceiverEngine feed audiodata not support."); + (void)audioData; + return DH_SUCCESS; +} + +int32_t AVTransReceiverTransport::SendMessage(uint32_t type, std::string content, std::string dstDevId) +{ + DHLOGI("Send message to remote. type: %u, content: %s.", type, content.c_str()); + if (receiverAdapter_ == nullptr) { + DHLOGE("FeedAudioData receiver adapter is null."); + return ERR_DH_AUDIO_TRANS_NULL_VALUE; + } + auto message = std::make_shared(type, content, dstDevId); + int32_t ret = receiverAdapter_->SendMessageToRemote(message); + if (ret != DH_SUCCESS) { + DHLOGE("Send message to remote engine failed"); + return ret; + } + return DH_SUCCESS; +} + +void AVTransReceiverTransport::OnEngineEvent(const AVTransEvent &event) +{ + if (transCallback_ == nullptr) { + DHLOGE("Trans callback is nullptr."); + return; + } + transCallback_->OnEngineTransEvent(event); +} + +void AVTransReceiverTransport::OnEngineMessage(const std::shared_ptr &message) +{ + if (message == nullptr) { + DHLOGE("The parameter is nullptr"); + return; + } + if (transCallback_ == nullptr) { + DHLOGE("Event callback is nullptr."); + return; + } + transCallback_->OnEngineTransMessage(message); +} + +void AVTransReceiverTransport::OnEngineDataAvailable(const std::shared_ptr &buffer) +{ + DHLOGE("On Engine Data available"); + if (buffer == nullptr) { + DHLOGE("The parameter is nullptr"); + return; + } + auto bufferData = buffer->GetBufferData(0); + std::shared_ptr audioData = std::make_shared(bufferData->GetSize()); + int32_t ret = memcpy_s(audioData->Data(), audioData->Capacity(), bufferData->GetAddress(), bufferData->GetSize()); + if (ret != EOK) { + DHLOGE("Copy audio data failed, error code %d.", ret); + return; + } + transCallback_->OnEngineTransDataAvailable(audioData); +} + +int32_t AVTransReceiverTransport::SetParameter(const AudioParam &audioParam) +{ + DHLOGI("SetParameter."); + receiverAdapter_->SetParameter(AVTransTag::AUDIO_SAMPLE_RATE, std::to_string(audioParam.comParam.sampleRate)); + receiverAdapter_->SetParameter(AVTransTag::AUDIO_SAMPLE_FORMAT, std::to_string(AudioSampleFormat::SAMPLE_F32LE)); + receiverAdapter_->SetParameter(AVTransTag::AUDIO_CHANNEL_MASK, std::to_string(audioParam.comParam.channelMask)); + receiverAdapter_->SetParameter(AVTransTag::AUDIO_CHANNEL_LAYOUT, std::to_string(audioParam.comParam.channelMask)); + receiverAdapter_->SetParameter(AVTransTag::AUDIO_BIT_RATE, std::to_string(AUDIO_SET_HISTREAMER_BIT_RATE)); + receiverAdapter_->SetParameter(AVTransTag::AUDIO_FRAME_SIZE, std::to_string(audioParam.comParam.frameSize)); + receiverAdapter_->SetParameter(AVTransTag::AUDIO_CODEC_TYPE, std::to_string(audioParam.comParam.codecType)); + receiverAdapter_->SetParameter(AVTransTag::ENGINE_READY, OWNER_NAME_D_SPEAKER); + return DH_SUCCESS; +} +} // namespace DistributedHardware +} // namespace OHOS \ No newline at end of file diff --git a/services/audiotransport/senderengine/include/av_sender_engine_adapter.h b/services/audiotransport/senderengine/include/av_sender_engine_adapter.h new file mode 100644 index 0000000000000000000000000000000000000000..a838688e7f1df90fe4e286ea0e6d011e704b85fa --- /dev/null +++ b/services/audiotransport/senderengine/include/av_sender_engine_adapter.h @@ -0,0 +1,77 @@ +/* + * Copyright (c) 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_AV_SENDER_ENGINE_ADAPTER_H +#define OHOS_AV_SENDER_ENGINE_ADAPTER_H + +#include +#include +#include + +#include + +#include "daudio_constants.h" +#include "daudio_errorcode.h" +#include "daudio_log.h" +#include "audio_param.h" +#include "audio_data.h" + +#include "i_av_sender_engine_callback.h" +#include "i_av_sender_engine.h" +#include "i_av_engine_provider.h" + +namespace OHOS { +namespace DistributedHardware { +class AVSenderAdapterCallback { +public: + AVSenderAdapterCallback() {}; + virtual ~AVSenderAdapterCallback() = default; + virtual void OnEngineEvent(const AVTransEvent &event) = 0; + virtual void OnEngineMessage(const std::shared_ptr &message) = 0; +}; + +class AVTransSenderAdapter : public IAVSenderEngineCallback, + public std::enable_shared_from_this { +public: + AVTransSenderAdapter() = default; + ~AVTransSenderAdapter() = default; + + int32_t Initialize(IAVEngineProvider *providerPtr, const std::string &peerDevId); + int32_t Release(); + int32_t Start(); + int32_t Stop(); + int32_t SetParameter(const AVTransTag &tag, const std::string ¶m); + int32_t PushData(std::shared_ptr &audioData); + int32_t SendMessageToRemote(const std::shared_ptr &message); + int32_t CreateControlChannel(const std::string &peerDevId); + int32_t RegisterAdapterCallback(const std::shared_ptr &back); + + void SaveFile(std::string fileName, uint8_t *lastFrame, int32_t size); + + int32_t OnSenderEvent(const AVTransEvent &event) override; + int32_t OnMessageReceived(const std::shared_ptr &message) override; +private: + int32_t WaitForChannelCreated(); +private: + std::atomic initialized_ = false; + std::mutex chnCreatedMtx_; + std::condition_variable chnCreatedCondVar_; + std::atomic chnCreateSuccess_ = false; + std::shared_ptr senderEngine_; + std::shared_ptr adapterCallback_; +}; +} // DistributedHardware +} // OHOS +#endif // OHOS_AV_SENDER_ENGINE_ADAPTER_H \ No newline at end of file diff --git a/services/audiotransport/senderengine/include/av_sender_engine_transport.h b/services/audiotransport/senderengine/include/av_sender_engine_transport.h new file mode 100644 index 0000000000000000000000000000000000000000..5cc393f1bbebf419c9e63f4f0b814bd386529c40 --- /dev/null +++ b/services/audiotransport/senderengine/include/av_sender_engine_transport.h @@ -0,0 +1,78 @@ +/* + * Copyright (c) 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_AV_TRANS_SENDER_TRANS_H +#define OHOS_AV_TRANS_SENDER_TRANS_H + +#include +#include +#include + +#include "av_sender_engine_adapter.h" +#include "iaudio_data_transport.h" +#include "iaudio_datatrans_callback.h" +#include "iaudio_data_transport.h" +#include "iaudio_datatrans_callback.h" +#include "i_av_sender_engine_callback.h" +#include "i_av_sender_engine.h" +#include "i_av_engine_provider.h" + +namespace OHOS { +namespace DistributedHardware { +class AVSenderTransportCallback { +public: + AVSenderTransportCallback() {}; + virtual ~AVSenderTransportCallback() = default; + virtual void OnEngineTransEvent(const AVTransEvent &event) = 0; + virtual void OnEngineTransMessage(const std::shared_ptr &message) = 0; +}; + +class AVTransSenderTransport : public IAudioDataTransport, + public AVSenderAdapterCallback, + public std::enable_shared_from_this { +public: + explicit AVTransSenderTransport(const std::string &devId, + const std::shared_ptr &callback) + : transCallback_(callback), devId_(devId) {}; + ~AVTransSenderTransport() override {}; + + int32_t SetUp(const AudioParam &localParam, const AudioParam &remoteParam, + const std::shared_ptr &callback, const PortCapType capType) override; + int32_t Start() override; + int32_t Stop() override; + int32_t Release() override; + int32_t Pause() override; + int32_t Restart(const AudioParam &localParam, const AudioParam &remoteParam) override; + int32_t FeedAudioData(std::shared_ptr &audioData) override; + + int32_t CreateCtrl() override; + int32_t InitEngine(IAVEngineProvider *providerPtr) override; + int32_t SendMessage(uint32_t type, std::string content, std::string dstDevId) override; + + void OnEngineEvent(const AVTransEvent &event) override; + void OnEngineMessage(const std::shared_ptr &message) override; + +private: + int32_t SetParameter(const AudioParam &audioParam); + +private: + std::shared_ptr senderAdapter_; + std::shared_ptr transCallback_; + std::string devId_; + AudioParam param_; +}; +} // namespace DistributedHardware +} // namespace OHOS +#endif \ No newline at end of file diff --git a/services/audiotransport/senderengine/src/av_sender_engine_adapter.cpp b/services/audiotransport/senderengine/src/av_sender_engine_adapter.cpp new file mode 100644 index 0000000000000000000000000000000000000000..30860276896d55c7688f8efce25b7fd9dcb5e9cb --- /dev/null +++ b/services/audiotransport/senderengine/src/av_sender_engine_adapter.cpp @@ -0,0 +1,229 @@ +/* + * Copyright (c) 2023 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include "av_sender_engine_adapter.h" +#include + +#include "daudio_constants.h" +#include "daudio_errorcode.h" +#include "daudio_log.h" +#include "daudio_util.h" + +#include "av_trans_types.h" + +#undef DH_LOG_TAG +#define DH_LOG_TAG "AVTransSenderAdapter" + +namespace OHOS { +namespace DistributedHardware { +constexpr int32_t WAIT_TIMEOUT_MS = 5000; + +int32_t AVTransSenderAdapter::Initialize(IAVEngineProvider *providerPtr, const std::string &peerDevId) +{ + DHLOGI("Initialize!"); + if (initialized_.load()) { + return DH_SUCCESS; + } + if (providerPtr == nullptr) { + DHLOGE("Av Transport sender engine provider ptr is null"); + return ERR_DH_AV_TRANS_NULL_VALUE; + } + senderEngine_ = providerPtr->CreateAVSenderEngine(peerDevId); + if (senderEngine_ == nullptr) { + DHLOGE("Create av transport sender engine is null"); + return ERR_DH_AV_TRANS_NULL_VALUE; + } + senderEngine_->RegisterSenderCallback(shared_from_this()); + initialized_ = true; + return DH_SUCCESS; +} + +int32_t AVTransSenderAdapter::Release() +{ + DHLOGI("Release!"); + if (senderEngine_ != nullptr) { + int32_t ret = senderEngine_->Release(); + if (ret != DH_SUCCESS) { + DHLOGE("Release av transport sender engine failed"); + } + } + initialized_ = false; + senderEngine_ = nullptr; + return DH_SUCCESS; +} + +int32_t AVTransSenderAdapter::Start() +{ + DHLOGI("Start!"); + if (senderEngine_ == nullptr) { + DHLOGE("Av transport sender engine is null"); + return ERR_DH_AV_TRANS_NULL_VALUE; + } + return senderEngine_->Start(); +} + +int32_t AVTransSenderAdapter::Stop() +{ + DHLOGI("Stop"); + if (senderEngine_ == nullptr) { + DHLOGE("Av transport sender engine is null"); + return ERR_DH_AV_TRANS_NULL_VALUE; + } + int32_t ret = senderEngine_->Stop(); + if (ret != DH_SUCCESS) { + DHLOGE("Stop av transport sender engine failed"); + return ERR_DH_AV_TRANS_STOP_FAILED; + } + DHLOGI("Stop Success"); + return DH_SUCCESS; +} + +int32_t AVTransSenderAdapter::CreateControlChannel(const std::string &peerDevId) +{ + DHLOGI("createControlChannel enter, peerDevId:%s", GetAnonyString(peerDevId).c_str()); + if (chnCreateSuccess_.load()) { + DHLOGI("Av transport sender channel already created"); + return DH_SUCCESS; + } + + if (senderEngine_ == nullptr) { + DHLOGE("Av transport sender engine is null"); + return ERR_DH_AV_TRANS_NULL_VALUE; + } + std::vector dstDevIds = {peerDevId}; + int32_t ret = senderEngine_->CreateControlChannel(dstDevIds, + ChannelAttribute{TransStrategy::LOW_LATANCY_STRATEGY}); + if (ret != DH_SUCCESS) { + DHLOGI("Create av transport sender channel failed, ret: %d", ret); + return ERR_DH_AV_TRANS_CREATE_CHANNEL_FAILED; + } + ret = WaitForChannelCreated(); + if (ret != DH_SUCCESS) { + DHLOGE("Wait for create av transport sender channel failed ret: %d", ret); + return ERR_DH_AV_TRANS_CREATE_CHANNEL_FAILED; + } + return DH_SUCCESS; +} + +int32_t AVTransSenderAdapter::SetParameter(const AVTransTag &tag, const std::string ¶m) +{ + DHLOGI("SetParameter!"); + if (senderEngine_ == nullptr) { + DHLOGE("av transport sender engine is null"); + return ERR_DH_AV_TRANS_NULL_VALUE; + } + int32_t ret = senderEngine_->SetParameter(tag, param); + if (ret != DH_SUCCESS) { + DHLOGE("Set av transport sender parameter failed, ret: %d", ret); + return ERR_DH_AV_TRANS_SETUP_FAILED; + } + return DH_SUCCESS; +} + +int32_t AVTransSenderAdapter::PushData(std::shared_ptr &audioData) +{ + if (senderEngine_ == nullptr) { + DHLOGE("Av transport sender engine null"); + return ERR_DH_AV_TRANS_NULL_VALUE; + } + auto transBuffer = std::make_shared(MetaType::AUDIO); + auto bufferData = transBuffer->CreateBufferData(audioData->Size()); + bufferData->Write(audioData->Data(), audioData->Size()); + + int32_t ret = senderEngine_->PushData(transBuffer); + if (ret != DH_SUCCESS) { + DHLOGI("Push data to av transport sender failed"); + return ERR_DH_AV_TRANS_FEED_DATA_FAILED; + } + return DH_SUCCESS; +} + +int32_t AVTransSenderAdapter::SendMessageToRemote(const std::shared_ptr &message) +{ + DHLOGI("Send message to remote"); + if (senderEngine_ == nullptr) { + DHLOGE("Av transport sender engine is null"); + return ERR_DH_AV_TRANS_NULL_VALUE; + } + int32_t ret = senderEngine_->SendMessage(message); + if (ret != DH_SUCCESS) { + DHLOGE("Send Message to remote receiver engine failed, ret: %d", ret); + return ERR_DH_AV_TRANS_SEND_MSG_FAILED; + } + return DH_SUCCESS; +} + +int32_t AVTransSenderAdapter::RegisterAdapterCallback(const std::shared_ptr &callback) +{ + DHLOGI("RegisterAdapterCallback"); + if (callback == nullptr) { + return ERR_DH_AV_TRANS_NULL_VALUE; + } + adapterCallback_ = callback; + return DH_SUCCESS; +} + +int32_t AVTransSenderAdapter::WaitForChannelCreated() +{ + std::unique_lock lock(chnCreatedMtx_); + auto status = chnCreatedCondVar_.wait_for(lock, std::chrono::milliseconds(WAIT_TIMEOUT_MS)); + if (status == std::cv_status::timeout) { + DHLOGI("Wait for av transport sender channel created timeout"); + return ERR_DH_AV_TRANS_TIMEOUT; + } + if (!chnCreateSuccess_.load()) { + DHLOGE("Create av transport sender channel failed"); + return ERR_DH_AV_TRANS_CREATE_CHANNEL_FAILED; + } + return DH_SUCCESS; +} + +int32_t AVTransSenderAdapter::OnSenderEvent(const AVTransEvent &event) +{ + DHLOGI("On sender event, type: %d", event.type); + switch (event.type) { + case EventType::EVENT_CHANNEL_OPEN_FAIL: + case EventType::EVENT_CHANNEL_OPENED: { + chnCreateSuccess_ = (event.type == EventType::EVENT_CHANNEL_OPENED); + chnCreatedCondVar_.notify_one(); + break; + } + case EventType::EVENT_CHANNEL_CLOSED: + case EventType::EVENT_START_FAIL: + case EventType::EVENT_START_SUCCESS: + case EventType::EVENT_STOP_SUCCESS: + case EventType::EVENT_ENGINE_ERROR: + case EventType::EVENT_REMOTE_ERROR: + if (adapterCallback_ != nullptr) { + DHLOGI("callback on engine event."); + adapterCallback_->OnEngineEvent(event); + } + break; + default: + DHLOGI("Invaild event type"); + break; + } + return DH_SUCCESS; +} + +int32_t AVTransSenderAdapter::OnMessageReceived(const std::shared_ptr &message) +{ + if (adapterCallback_ != nullptr) { + adapterCallback_->OnEngineMessage(message); + } + return DH_SUCCESS; +} +} // namespace DistributedHardware +} // namespace OHOS \ No newline at end of file diff --git a/services/audiotransport/senderengine/src/av_sender_engine_transport.cpp b/services/audiotransport/senderengine/src/av_sender_engine_transport.cpp new file mode 100644 index 0000000000000000000000000000000000000000..b4561df381b4ab9bf39b320d2288e6a0f2571020 --- /dev/null +++ b/services/audiotransport/senderengine/src/av_sender_engine_transport.cpp @@ -0,0 +1,202 @@ +/* + * Copyright (c) 2023 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include "av_sender_engine_transport.h" + +#include "daudio_constants.h" +#include "daudio_errorcode.h" +#include "daudio_log.h" +#include "daudio_util.h" + +#undef DH_LOG_TAG +#define DH_LOG_TAG "AVTransSenderTransport" + +namespace OHOS { +namespace DistributedHardware { +int32_t AVTransSenderTransport::InitEngine(IAVEngineProvider *providerPtr) +{ + DHLOGI("InitSenderEngine enter"); + if (senderAdapter_ == nullptr) { + DHLOGD("SenderAdapter_ is null, create new."); + senderAdapter_ = std::make_shared(); + } + int32_t ret = senderAdapter_->Initialize(providerPtr, devId_); + if (ret != DH_SUCCESS) { + DHLOGE("initialize av sender adapter failed."); + return ERR_DH_AUDIO_TRANS_NULL_VALUE; + } + DHLOGI("Init SenderEngine success"); + ret = senderAdapter_->RegisterAdapterCallback(shared_from_this()); + if (ret != DH_SUCCESS) { + DHLOGE("InitSenderEngine register callback error."); + } + return ret; +} +int32_t AVTransSenderTransport::SetUp(const AudioParam &localParam, const AudioParam &remoteParam, + const std::shared_ptr &callback, const PortCapType capType) +{ + (void)remoteParam; + (void)callback; + (void)capType; + param_ = localParam; + return DH_SUCCESS; +} + +int32_t AVTransSenderTransport::Start() +{ + DHLOGI("StartSenderEngine enter."); + if (senderAdapter_ == nullptr) { + DHLOGE("av transport sender adapter is null"); + return ERR_DH_AUDIO_TRANS_NULL_VALUE; + } + int32_t ret = SetParameter(param_); + if (ret != DH_SUCCESS) { + DHLOGE("Set parameter failed"); + return ERR_DH_AUDIO_TRANS_NULL_VALUE; + } + ret = senderAdapter_->Start(); + if (ret != DH_SUCCESS) { + DHLOGE("start av sender engine failed"); + return ERR_DH_AUDIO_TRANS_NULL_VALUE; + } + return DH_SUCCESS; +} + +int32_t AVTransSenderTransport::CreateCtrl() +{ + DHLOGI("Create ctrl enter."); + if (senderAdapter_ == nullptr) { + DHLOGE("av transport sender adapter is null"); + return ERR_DH_AUDIO_TRANS_NULL_VALUE; + } + int32_t ret = senderAdapter_->CreateControlChannel(devId_); + if (ret != DH_SUCCESS) { + DHLOGE("create av sender control channel failed."); + return ERR_DH_AUDIO_TRANS_NULL_VALUE; + } + return DH_SUCCESS; +} + +int32_t AVTransSenderTransport::Stop() +{ + DHLOGI("StopSenderEngine enter."); + if (senderAdapter_ == nullptr) { + DHLOGE("av transport sender adapter is null"); + return ERR_DH_AUDIO_TRANS_NULL_VALUE; + } + int32_t ret = senderAdapter_->Stop(); + if (ret != DH_SUCCESS) { + DHLOGE("av transport sender adapter is null"); + return ERR_DH_AUDIO_TRANS_NULL_VALUE; + } + return DH_SUCCESS; +} + +// wuhaobo todo pause +int32_t AVTransSenderTransport::Pause() +{ + DHLOGI("PauseSenderEngine enter."); + return DH_SUCCESS; +} + +// wuhaobo todo restart +int32_t AVTransSenderTransport::Restart(const AudioParam &localParam, const AudioParam &remoteParam) +{ + DHLOGI("RestartSenderEngine enter."); + return DH_SUCCESS; +} + +int32_t AVTransSenderTransport::Release() +{ + DHLOGI("RelaseSenderEngine enter."); + if (senderAdapter_ == nullptr) { + DHLOGE("ReleaseSenderEngine sender adapter is null."); + return ERR_DH_AUDIO_TRANS_NULL_VALUE; + } + int32_t ret = senderAdapter_->Release(); + if (ret != DH_SUCCESS) { + DHLOGE("Release av sender engine failed."); + return ERR_DH_AUDIO_TRANS_NULL_VALUE; + } + return DH_SUCCESS; +} + +int32_t AVTransSenderTransport::FeedAudioData(std::shared_ptr &audioData) +{ + if (senderAdapter_ == nullptr) { + DHLOGE("FeedAudioData sender adapter is null."); + return ERR_DH_AUDIO_TRANS_NULL_VALUE; + } + int32_t ret = senderAdapter_->PushData(audioData); + if (ret != DH_SUCCESS) { + DHLOGE("push data failed."); + return ERR_DH_AUDIO_TRANS_NULL_VALUE; + } + return DH_SUCCESS; +} + +int32_t AVTransSenderTransport::SendMessage(uint32_t type, std::string content, std::string dstDevId) +{ + DHLOGI("Send message to remote. type: %u, content: %s.", type, content.c_str()); + if (senderAdapter_ == nullptr) { + DHLOGE("FeedAudioData sender adapter is null."); + return ERR_DH_AUDIO_TRANS_NULL_VALUE; + } + auto message = std::make_shared(type, content, dstDevId); + int32_t ret = senderAdapter_->SendMessageToRemote(message); + if (ret != DH_SUCCESS) { + DHLOGE("Send message to remote engine failed"); + return ret; + } + return DH_SUCCESS; +} + +void AVTransSenderTransport::OnEngineEvent(const AVTransEvent &event) +{ + if (transCallback_ == nullptr) { + DHLOGE("Trans callback is nullptr."); + return; + } + transCallback_->OnEngineTransEvent(event); +} + +void AVTransSenderTransport::OnEngineMessage(const std::shared_ptr &message) +{ + if (message == nullptr) { + DHLOGE("The parameter is nullptr"); + return; + } + if (transCallback_ == nullptr) { + DHLOGE("Event callback is nullptr."); + return; + } + transCallback_->OnEngineTransMessage(message); +} + +int32_t AVTransSenderTransport::SetParameter(const AudioParam &audioParam) +{ + DHLOGI("SetParameter."); + senderAdapter_->SetParameter(AVTransTag::AUDIO_SAMPLE_RATE, std::to_string(audioParam.comParam.sampleRate)); + senderAdapter_->SetParameter(AVTransTag::AUDIO_SAMPLE_FORMAT, std::to_string(audioParam.comParam.bitFormat)); + senderAdapter_->SetParameter(AVTransTag::AUDIO_CHANNEL_MASK, std::to_string(audioParam.comParam.channelMask)); + senderAdapter_->SetParameter(AVTransTag::AUDIO_CHANNEL_LAYOUT, std::to_string(audioParam.comParam.channelMask)); + senderAdapter_->SetParameter(AVTransTag::AUDIO_BIT_RATE, std::to_string(AUDIO_SET_HISTREAMER_BIT_RATE)); + senderAdapter_->SetParameter(AVTransTag::AUDIO_FRAME_SIZE, std::to_string(audioParam.comParam.frameSize)); + senderAdapter_->SetParameter(AVTransTag::AUDIO_CODEC_TYPE, std::to_string(audioParam.comParam.codecType)); + senderAdapter_->SetParameter(AVTransTag::ENGINE_READY, OWNER_NAME_D_SPEAKER); + return DH_SUCCESS; +} +} // namespace DistributedHardware +} // namespace OHOS \ No newline at end of file diff --git a/services/audiotransport/test/unittest/decodetransport/BUILD.gn b/services/audiotransport/test/unittest/decodetransport/BUILD.gn index ad47021ca3128fa5faf81c8fcd810eef55d218c2..daf584635906a7a722b475487071fa09ee874d60 100644 --- a/services/audiotransport/test/unittest/decodetransport/BUILD.gn +++ b/services/audiotransport/test/unittest/decodetransport/BUILD.gn @@ -29,19 +29,21 @@ config("module_private_config") { include_dirs += [ "include", - "${common_path}/include", - "${softbusadapter_path}/include", - "${services_path}/common/audioparam", - "${services_path}/common/audiodata/include", - "${audio_transport_path}/audiotransportstatus/include", - "${audio_transport_path}/audiotransportstatus/interface", - "${audio_processor_path}/interface", "${audio_processor_path}/decodeprocessor/include", - "${audio_transport_path}/interface", - "${audio_transport_path}/audiochannel/interface", + "${audio_processor_path}/interface", "${audio_transport_path}/audiochannel/audiodatachannel/include", + "${audio_transport_path}/audiochannel/interface", + "${audio_transport_path}/audiotransportstatus/include", + "${audio_transport_path}/audiotransportstatus/interface", "${audio_transport_path}/decodetransport/include", + "${audio_transport_path}/interface", + "${audio_transport_path}/receiverengine/include", + "${audio_transport_path}/senderengine/include", "${audio_transport_path}/test/unittest/audiotranstestutils/include", + "${common_path}/include", + "${services_path}/common/audiodata/include", + "${services_path}/common/audioparam", + "${softbusadapter_path}/include", ] } @@ -58,7 +60,11 @@ ohos_unittest("DecodeTransportTest") { "//third_party/googletest:gtest_main", ] - external_deps = [ "dsoftbus:softbus_client" ] + external_deps = [ + "distributed_hardware_fwk:distributed_av_receiver", + "distributed_hardware_fwk:distributed_av_sender", + "dsoftbus:softbus_client", + ] defines = [ "HI_LOG_ENABLE", diff --git a/services/audiotransport/test/unittest/encodetransport/BUILD.gn b/services/audiotransport/test/unittest/encodetransport/BUILD.gn index c6a38a518f09e9f538fbeae4830009783815b907..c27d5001e6c68602284b93b84aa1db37f4ea408e 100644 --- a/services/audiotransport/test/unittest/encodetransport/BUILD.gn +++ b/services/audiotransport/test/unittest/encodetransport/BUILD.gn @@ -29,19 +29,21 @@ config("module_private_config") { include_dirs += [ "include", - "${common_path}/include", - "${services_path}/common/audioparam", - "${services_path}/common/audiodata/include", + "${audio_processor_path}/interface", + "${audio_processor_path}/encodeprocessor/include", "${audio_transport_path}/audiochannel/interface", "${audio_transport_path}/audiochannel/audiodatachannel/include", "${audio_transport_path}/audiotransportstatus/include", "${audio_transport_path}/audiotransportstatus/interface", "${audio_transport_path}/encodetransport/include", "${audio_transport_path}/interface", - "${audio_processor_path}/encodeprocessor/include", - "${audio_processor_path}/interface", - "${softbusadapter_path}/include", + "${audio_transport_path}/receiverengine/include", + "${audio_transport_path}/senderengine/include", "${audio_transport_path}/test/unittest/audiotranstestutils/include", + "${common_path}/include", + "${services_path}/common/audiodata/include", + "${services_path}/common/audioparam", + "${softbusadapter_path}/include", ] } @@ -59,7 +61,11 @@ ohos_unittest("EncodeTransportTest") { "//third_party/googletest:gtest_main", ] - external_deps = [ "dsoftbus:softbus_client" ] + external_deps = [ + "distributed_hardware_fwk:distributed_av_receiver", + "distributed_hardware_fwk:distributed_av_sender", + "dsoftbus:softbus_client", + ] defines = [ "HI_LOG_ENABLE", diff --git a/services/common/BUILD.gn b/services/common/BUILD.gn index 44f5b89cac8bf20faea752b0f4026eec13e35e1f..6441fc7e66e94b56cdaaf2caba3ca254f820ac2d 100644 --- a/services/common/BUILD.gn +++ b/services/common/BUILD.gn @@ -57,6 +57,7 @@ ohos_shared_library("distributed_audio_utils") { "hilog:libhilog", "hisysevent_native:libhisysevent", "hitrace_native:hitrace_meter", + "init:libbegetutil", ] defines = [