From 4d2717ee5ab3c8cbbf75873353c2687b1ec7b253 Mon Sep 17 00:00:00 2001 From: zhuzhihui7 Date: Fri, 20 Jun 2025 20:46:08 +0800 Subject: [PATCH] =?UTF-8?q?=E9=A9=B1=E5=8A=A8=E5=8A=A0=E8=BD=BD=E6=94=AF?= =?UTF-8?q?=E6=8C=81=E5=86=B2=E7=AA=81=E7=AE=A1=E7=90=86-=E5=AE=8C?= =?UTF-8?q?=E5=96=84=E6=AD=BB=E4=BA=A1=E7=BB=91=E5=AE=9A?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: zhuzhihui7 --- .../native_cpp/audio_source/BUILD.gn | 5 + .../include/daudio_hdf_operate.h | 18 +- .../include/daudio_source_handler.h | 2 + .../audio_source}/src/daudio_hdf_operate.cpp | 109 +++++-- .../src/daudio_source_handler.cpp | 11 + .../test/unittest/audiosourcetest/BUILD.gn | 10 + .../include/mock_hdfoperate_device_manager.h | 39 +++ .../src/daudio_hdf_operate_test.cpp | 304 ++++++++++++++++++ .../src/mock_hdfoperate_device_manager.cpp | 48 +++ .../audiohdiproxy/src/daudio_hdi_handler.cpp | 10 +- .../test/unittest/daudio_hdi_handler/BUILD.gn | 3 +- .../src/mock_distributed_hardware_fwk_kit.cpp | 2 +- .../test/unittest/sourcemanager/BUILD.gn | 4 +- 13 files changed, 522 insertions(+), 43 deletions(-) rename {services/audiohdiproxy/test/unittest/daudio_hdi_handler => interfaces/inner_kits/native_cpp/audio_source}/include/daudio_hdf_operate.h (82%) rename {services/audiohdiproxy/test/unittest/daudio_hdi_handler => interfaces/inner_kits/native_cpp/audio_source}/src/daudio_hdf_operate.cpp (75%) create mode 100644 interfaces/inner_kits/native_cpp/test/unittest/audiosourcetest/include/mock_hdfoperate_device_manager.h create mode 100644 interfaces/inner_kits/native_cpp/test/unittest/audiosourcetest/src/daudio_hdf_operate_test.cpp create mode 100644 interfaces/inner_kits/native_cpp/test/unittest/audiosourcetest/src/mock_hdfoperate_device_manager.cpp diff --git a/interfaces/inner_kits/native_cpp/audio_source/BUILD.gn b/interfaces/inner_kits/native_cpp/audio_source/BUILD.gn index 750e93a6..66b75e0c 100755 --- a/interfaces/inner_kits/native_cpp/audio_source/BUILD.gn +++ b/interfaces/inner_kits/native_cpp/audio_source/BUILD.gn @@ -34,6 +34,7 @@ ohos_shared_library("distributed_audio_source_sdk") { ] sources = [ + "src/daudio_hdf_operate.cpp", "src/daudio_ipc_callback.cpp", "src/daudio_ipc_callback_stub.cpp", "src/daudio_source_handler.cpp", @@ -53,6 +54,10 @@ ohos_shared_library("distributed_audio_source_sdk") { "cJSON:cjson", "c_utils:utils", "distributed_hardware_fwk:distributedhardwareutils", + "drivers_interface_distributed_audio:libdaudioext_proxy_2.0", + "hdf_core:libhdf_ipc_adapter", + "hdf_core:libhdi", + "hdf_core:libpub_utils", "hilog:libhilog", "hisysevent:libhisysevent", "hitrace:hitrace_meter", diff --git a/services/audiohdiproxy/test/unittest/daudio_hdi_handler/include/daudio_hdf_operate.h b/interfaces/inner_kits/native_cpp/audio_source/include/daudio_hdf_operate.h similarity index 82% rename from services/audiohdiproxy/test/unittest/daudio_hdi_handler/include/daudio_hdf_operate.h rename to interfaces/inner_kits/native_cpp/audio_source/include/daudio_hdf_operate.h index fa51ef27..c3946fa2 100644 --- a/services/audiohdiproxy/test/unittest/daudio_hdi_handler/include/daudio_hdf_operate.h +++ b/interfaces/inner_kits/native_cpp/audio_source/include/daudio_hdf_operate.h @@ -20,6 +20,7 @@ #include #include +#include "idistributed_hardware_source.h" #include "iservstat_listener_hdi.h" #include "idevmgr_hdi.h" #include "iservmgr_hdi.h" @@ -30,6 +31,7 @@ namespace OHOS { namespace DistributedHardware { const std::string AUDIO_SERVICE_NAME = "daudio_primary_service"; const std::string AUDIOEXT_SERVICE_NAME = "daudio_ext_service"; +const std::string HDF_LISTENER_SERVICE_NAME = "DHFWK"; constexpr uint16_t AUDIO_INVALID_VALUE = 0xffff; constexpr int32_t AUDIO_WAIT_TIME = 5000; using OHOS::HDI::DeviceManager::V1_0::IDeviceManager; @@ -42,13 +44,17 @@ using OHOS::HDI::DistributedAudio::Audioext::V2_0::IDAudioHdfCallback; using OHOS::HDI::DistributedAudio::Audioext::V2_0::DAudioEvent; class FwkDAudioHdfCallback; +class HdfDeathRecipient : public IRemoteObject::DeathRecipient { +public: + void OnRemoteDied(const wptr &remote) override; +}; class DaudioHdfOperate { DECLARE_SINGLE_INSTANCE(DaudioHdfOperate); public: - int32_t LoadDaudioHDFImpl(); + int32_t LoadDaudioHDFImpl(std::shared_ptr callback); int32_t UnLoadDaudioHDFImpl(); - void ResetRefCount(); + void OnHdfHostDied(); private: int32_t WaitLoadService(const std::string& servName); @@ -57,18 +63,22 @@ private: int32_t UnLoadDevice(); int32_t RegisterHdfListener(); int32_t UnRegisterHdfListener(); + int32_t AddHdfDeathBind(); + int32_t RemoveHdfDeathBind(); + int32_t MakeFwkDAudioHdfCallback(); private: OHOS::sptr devmgr_; OHOS::sptr servMgr_; OHOS::sptr audioSrvHdf_; + std::mutex fwkDAudioHdfCallbackMutex_; OHOS::sptr fwkDAudioHdfCallback_; std::atomic audioServStatus_ = AUDIO_INVALID_VALUE; std::atomic audioextServStatus_ = AUDIO_INVALID_VALUE; std::condition_variable hdfOperateCon_; std::mutex hdfOperateMutex_; - int32_t hdfLoadRef_ = 0; - std::mutex hdfLoadRefMutex_; + std::shared_ptr hdfDeathCallback_; + sptr hdfDeathRecipient_ = sptr(new HdfDeathRecipient()); }; class DAudioHdfServStatListener : public OHOS::HDI::ServiceManager::V1_0::ServStatListenerStub { diff --git a/interfaces/inner_kits/native_cpp/audio_source/include/daudio_source_handler.h b/interfaces/inner_kits/native_cpp/audio_source/include/daudio_source_handler.h index b04f3ad9..ca187db3 100644 --- a/interfaces/inner_kits/native_cpp/audio_source/include/daudio_source_handler.h +++ b/interfaces/inner_kits/native_cpp/audio_source/include/daudio_source_handler.h @@ -39,6 +39,8 @@ public: void UnregisterDistributedHardwareStateListener() override; void RegisterDataSyncTriggerListener(std::shared_ptr listener) override; void UnregisterDataSyncTriggerListener() override; + int32_t LoadDistributedHDF(std::shared_ptr callback) override; + int32_t UnLoadDistributedHDF() override; void OnRemoteSourceSvrDied(const wptr &remote); void FinishStartSA(const std::string ¶m, const sptr &remoteObject); diff --git a/services/audiohdiproxy/test/unittest/daudio_hdi_handler/src/daudio_hdf_operate.cpp b/interfaces/inner_kits/native_cpp/audio_source/src/daudio_hdf_operate.cpp similarity index 75% rename from services/audiohdiproxy/test/unittest/daudio_hdi_handler/src/daudio_hdf_operate.cpp rename to interfaces/inner_kits/native_cpp/audio_source/src/daudio_hdf_operate.cpp index bae93dbd..61a78108 100644 --- a/services/audiohdiproxy/test/unittest/daudio_hdi_handler/src/daudio_hdf_operate.cpp +++ b/interfaces/inner_kits/native_cpp/audio_source/src/daudio_hdf_operate.cpp @@ -20,6 +20,7 @@ #include "daudio_errorcode.h" #include "daudio_log.h" +#include "iproxy_broker.h" #undef DH_LOG_TAG #define DH_LOG_TAG "DaudioHdfOperate" @@ -27,15 +28,9 @@ namespace OHOS { namespace DistributedHardware { IMPLEMENT_SINGLE_INSTANCE(DaudioHdfOperate); -int32_t DaudioHdfOperate::LoadDaudioHDFImpl() +int32_t DaudioHdfOperate::LoadDaudioHDFImpl(std::shared_ptr callback) { DHLOGI("Load daudio hdf impl begin!"); - std::unique_lock loadRefLocker(hdfLoadRefMutex_); - if (hdfLoadRef_ > 0) { - hdfLoadRef_++; - DHLOGI("The daudio hdf impl has been loaded, just inc ref!"); - return DH_SUCCESS; - } int32_t ret = LoadDevice(); if (ret != DH_SUCCESS) { DHLOGE("LoadDevice failed, ret: %{public}d.", ret); @@ -47,7 +42,14 @@ int32_t DaudioHdfOperate::LoadDaudioHDFImpl() UnLoadDevice(); return ret; } - hdfLoadRef_++; + hdfDeathCallback_ = callback; + ret = AddHdfDeathBind(); + if (ret != DH_SUCCESS) { + DHLOGE("AddHdfDeathBind failed, ret: %{public}d.", ret); + UnRegisterHdfListener(); + UnLoadDevice(); + return ret; + } DHLOGI("Load daudio hdf impl end!"); return DH_SUCCESS; } @@ -55,17 +57,11 @@ int32_t DaudioHdfOperate::LoadDaudioHDFImpl() int32_t DaudioHdfOperate::UnLoadDaudioHDFImpl() { DHLOGI("UnLoad daudio hdf impl begin!"); - std::unique_lock loadRefLocker(hdfLoadRefMutex_); - if (hdfLoadRef_ == 0) { - DHLOGI("The daudio hdf impl has been unloaded!"); - return DH_SUCCESS; - } - if (hdfLoadRef_ > 1) { - hdfLoadRef_--; - DHLOGI("The daudio hdf impl has been loaded, just dec ref!"); - return DH_SUCCESS; + int32_t ret = RemoveHdfDeathBind(); + if (ret != DH_SUCCESS) { + DHLOGE("RemoveHdfDeathBind failed, ret: %{public}d.", ret); } - int32_t ret = UnRegisterHdfListener(); + ret = UnRegisterHdfListener(); if (ret != DH_SUCCESS) { DHLOGE("UnRegisterHdfListener failed, ret: %{public}d.", ret); } @@ -73,16 +69,18 @@ int32_t DaudioHdfOperate::UnLoadDaudioHDFImpl() if (ret != DH_SUCCESS) { DHLOGE("UnLoadDevice failed, ret: %{public}d.", ret); } - hdfLoadRef_--; DHLOGI("UnLoad daudio hdf impl end!"); return DH_SUCCESS; } -void DaudioHdfOperate::ResetRefCount() +void DaudioHdfOperate::OnHdfHostDied() { - DHLOGI("Reset reference count for daudio."); - std::unique_lock loadRefLocker(hdfLoadRefMutex_); - hdfLoadRef_ = 0; + DHLOGI("On hdf host died begin!"); + if (hdfDeathCallback_) { + DHLOGI("Call hdf host died callback!"); + hdfDeathCallback_->OnHdfHostDied(); + } + DHLOGI("On hdf host died end!"); } int32_t DaudioHdfOperate::WaitLoadService(const std::string& servName) @@ -209,13 +207,12 @@ int32_t DaudioHdfOperate::RegisterHdfListener() return ERR_DH_AUDIO_NULLPTR; } if (fwkDAudioHdfCallback_ == nullptr) { - fwkDAudioHdfCallback_ = new FwkDAudioHdfCallback(); - if (fwkDAudioHdfCallback_ == nullptr) { + if (MakeFwkDAudioHdfCallback() != DH_SUCCESS) { DHLOGE("Create FwkDAudioHdfCallback failed."); return ERR_DH_AUDIO_NULLPTR; } } - int32_t ret = audioSrvHdf_->RegisterAudioHdfListener("DHFWK", fwkDAudioHdfCallback_); + int32_t ret = audioSrvHdf_->RegisterAudioHdfListener(HDF_LISTENER_SERVICE_NAME, fwkDAudioHdfCallback_); if (ret != DH_SUCCESS) { DHLOGE("Call hdf proxy RegisterAudioHdfListener failed, ret: %{public}d.", ret); return ret; @@ -231,7 +228,7 @@ int32_t DaudioHdfOperate::UnRegisterHdfListener() DHLOGE("hdi daudio manager is nullptr!"); return ERR_DH_AUDIO_NULLPTR; } - int32_t ret = audioSrvHdf_->UnRegisterAudioHdfListener("DHFWK"); + int32_t ret = audioSrvHdf_->UnRegisterAudioHdfListener(HDF_LISTENER_SERVICE_NAME); if (ret != DH_SUCCESS) { DHLOGE("Call hdf proxy UnRegisterAudioHdfListener failed, ret: %{public}d.", ret); return ret; @@ -240,6 +237,58 @@ int32_t DaudioHdfOperate::UnRegisterHdfListener() return DH_SUCCESS; } +int32_t DaudioHdfOperate::AddHdfDeathBind() +{ + DHLOGI("AddHdfDeathBind for daudio begin!"); + if (audioSrvHdf_ == nullptr) { + DHLOGE("hdi daudio manager is nullptr!"); + return ERR_DH_AUDIO_NULLPTR; + } + sptr remote = OHOS::HDI::hdi_objcast(audioSrvHdf_); + if (remote == nullptr) { + DHLOGE("Get remote from hdi daudio manager failed!"); + return ERR_DH_AUDIO_NULLPTR; + } + if (remote->AddDeathRecipient(hdfDeathRecipient_) == false) { + DHLOGE("Call AddDeathRecipient failed!"); + return ERR_DH_AUDIO_FAILED; + } + DHLOGI("AddHdfDeathBind for daudio end!"); + return DH_SUCCESS; +} + +int32_t DaudioHdfOperate::RemoveHdfDeathBind() +{ + DHLOGI("RemoveHdfDeathBind for daudio begin!"); + if (audioSrvHdf_ == nullptr) { + DHLOGE("hdi daudio manager is nullptr!"); + return ERR_DH_AUDIO_NULLPTR; + } + sptr remote = OHOS::HDI::hdi_objcast(audioSrvHdf_); + if (remote == nullptr) { + DHLOGE("Get remote from hdi daudio manager failed!"); + return ERR_DH_AUDIO_NULLPTR; + } + if (remote->RemoveDeathRecipient(hdfDeathRecipient_) == false) { + DHLOGE("Call RemoveDeathRecipient failed!"); + return ERR_DH_AUDIO_FAILED; + } + DHLOGI("RemoveHdfDeathBind for daudio end!"); + return DH_SUCCESS; +} + +int32_t DaudioHdfOperate::MakeFwkDAudioHdfCallback() +{ + std::lock_guard locker(fwkDAudioHdfCallbackMutex_); + if (fwkDAudioHdfCallback_ == nullptr) { + fwkDAudioHdfCallback_ = new FwkDAudioHdfCallback(); + if (fwkDAudioHdfCallback_ == nullptr) { + return ERR_DH_AUDIO_NULLPTR; + } + } + return DH_SUCCESS; +} + void DAudioHdfServStatListener::OnReceive(const ServiceStatus& status) { DHLOGI("Service status on receive."); @@ -254,5 +303,11 @@ int32_t FwkDAudioHdfCallback::NotifyEvent(int32_t devId, const DAudioEvent& even (void)event; return DH_SUCCESS; } + +void HdfDeathRecipient::OnRemoteDied(const wptr &remote) +{ + DHLOGI("On remote died!"); + DaudioHdfOperate::GetInstance().OnHdfHostDied(); +} } // namespace DistributedHardware } // namespace OHOS \ No newline at end of file diff --git a/interfaces/inner_kits/native_cpp/audio_source/src/daudio_source_handler.cpp b/interfaces/inner_kits/native_cpp/audio_source/src/daudio_source_handler.cpp index 159284aa..f5a1b94f 100644 --- a/interfaces/inner_kits/native_cpp/audio_source/src/daudio_source_handler.cpp +++ b/interfaces/inner_kits/native_cpp/audio_source/src/daudio_source_handler.cpp @@ -20,6 +20,7 @@ #include "daudio_constants.h" #include "daudio_errorcode.h" +#include "daudio_hdf_operate.h" #include "daudio_hisysevent.h" #include "daudio_hitrace.h" #include "daudio_log.h" @@ -173,6 +174,16 @@ void DAudioSourceHandler::UnregisterDataSyncTriggerListener() dAudioIpcCallback_->UnRegisterTriggerListener(); } +int32_t DAudioSourceHandler::LoadDistributedHDF(std::shared_ptr callback) +{ + return DaudioHdfOperate::GetInstance().LoadDaudioHDFImpl(callback); +} + +int32_t DAudioSourceHandler::UnLoadDistributedHDF() +{ + return DaudioHdfOperate::GetInstance().UnLoadDaudioHDFImpl(); +} + void DAudioSourceHandler::OnRemoteSourceSvrDied(const wptr &remote) { DHLOGI("The daudio source service died."); diff --git a/interfaces/inner_kits/native_cpp/test/unittest/audiosourcetest/BUILD.gn b/interfaces/inner_kits/native_cpp/test/unittest/audiosourcetest/BUILD.gn index 2249a1c1..f32ade6d 100755 --- a/interfaces/inner_kits/native_cpp/test/unittest/audiosourcetest/BUILD.gn +++ b/interfaces/inner_kits/native_cpp/test/unittest/audiosourcetest/BUILD.gn @@ -36,19 +36,29 @@ ohos_unittest("AudioSourceTest") { module_out_path = module_out_path sources = [ + "${interfaces_path}/inner_kits/native_cpp/test/unittest/audiosourcetest/src/daudio_hdf_operate_test.cpp", "${interfaces_path}/inner_kits/native_cpp/test/unittest/audiosourcetest/src/daudio_ipc_callback_test.cpp", "${interfaces_path}/inner_kits/native_cpp/test/unittest/audiosourcetest/src/daudio_source_handler_test.cpp", "${interfaces_path}/inner_kits/native_cpp/test/unittest/audiosourcetest/src/daudio_source_proxy_test.cpp", + "${interfaces_path}/inner_kits/native_cpp/test/unittest/audiosourcetest/src/mock_hdfoperate_device_manager.cpp", ] configs = [ ":module_private_config" ] deps = [ "${interfaces_path}/inner_kits/native_cpp/audio_source:distributed_audio_source_sdk" ] + cflags = [ "-Dprivate=public" ] + external_deps = [ + "cJSON:cjson", "c_utils:utils", "distributed_hardware_fwk:distributedhardwareutils", + "drivers_interface_distributed_audio:libdaudioext_proxy_2.0", "googletest:gmock", + "hdf_core:libhdf_ipc_adapter", + "hdf_core:libhdi", + "hdf_core:libpub_utils", + "hilog:libhilog", "ipc:ipc_core", "samgr:samgr_proxy", ] diff --git a/interfaces/inner_kits/native_cpp/test/unittest/audiosourcetest/include/mock_hdfoperate_device_manager.h b/interfaces/inner_kits/native_cpp/test/unittest/audiosourcetest/include/mock_hdfoperate_device_manager.h new file mode 100644 index 00000000..3357bf57 --- /dev/null +++ b/interfaces/inner_kits/native_cpp/test/unittest/audiosourcetest/include/mock_hdfoperate_device_manager.h @@ -0,0 +1,39 @@ +/* + * Copyright (c) 2025 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_DISTRIBUTED_HARDWARE_MOCK_HDFOPRATE_DEVICE_MANAGER_H +#define OHOS_DISTRIBUTED_HARDWARE_MOCK_HDFOPRATE_DEVICE_MANAGER_H + +#include + +#include "idevmgr_hdi.h" + +namespace OHOS { +namespace DistributedHardware { +using namespace HDI::DeviceManager::V1_0; +class MockDeviceManager : public IDeviceManager { +public: + MOCK_METHOD(int32_t, LoadDevice, (const std::string &)); + MOCK_METHOD(int32_t, UnloadDevice, (const std::string &)); + MOCK_METHOD(int32_t, ListAllDevice, (std::vector &)); + MOCK_METHOD(int32_t, ListAllHost, (std::vector &)); + static sptr GetOrCreateInstance(); + static void ReleaseInstance(); +private: + static sptr deviceManagerInstance_; +}; +} // namespace DistributedHardware +} // namespace OHOS +#endif // OHOS_DISTRIBUTED_HARDWARE_MOCK_DEVICE_MANAGER_H \ No newline at end of file diff --git a/interfaces/inner_kits/native_cpp/test/unittest/audiosourcetest/src/daudio_hdf_operate_test.cpp b/interfaces/inner_kits/native_cpp/test/unittest/audiosourcetest/src/daudio_hdf_operate_test.cpp new file mode 100644 index 00000000..d5d87c9f --- /dev/null +++ b/interfaces/inner_kits/native_cpp/test/unittest/audiosourcetest/src/daudio_hdf_operate_test.cpp @@ -0,0 +1,304 @@ +/* + * Copyright (c) 2022-2025 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 + +#include "daudio_errorcode.h" +#include "daudio_hdf_operate.h" +#include "daudio_log.h" +#include "mock_hdfoperate_device_manager.h" + +#undef DH_LOG_TAG +#define DH_LOG_TAG "DAudioHdfOperateTest" + +using namespace testing; +using namespace testing::ext; + +namespace OHOS { +namespace DistributedHardware { +class DAudioHdfOperateTest : public testing::Test { +public: + static void SetUpTestCase(void); + static void TearDownTestCase(void); + void SetUp(); + void TearDown(); + +private: + sptr deviceManager_; +}; + +void DAudioHdfOperateTest::SetUpTestCase(void) +{ + DHLOGI("DAudioHdfOperateTest::SetUpTestCase"); +} + +void DAudioHdfOperateTest::TearDownTestCase(void) +{ + DHLOGI("DAudioHdfOperateTest::TearDownTestCase"); +} + +void DAudioHdfOperateTest::SetUp(void) +{ + DHLOGI("DAudioHdfOperateTest::SetUp"); + deviceManager_ = MockDeviceManager::GetOrCreateInstance(); +} + +void DAudioHdfOperateTest::TearDown(void) +{ + DHLOGI("DAudioHdfOperateTest::TearDown"); + deviceManager_ = nullptr; +} + +class MockHdfDeathCallback : public HdfDeathCallback { +public: + virtual ~MockHdfDeathCallback() {} + bool IsCalled() + { + return isCalled_; + } +protected: + void OnHdfHostDied() + { + isCalled_ = true; + } +private: + bool isCalled_ = false; +}; + +/** + * @tc.name: LoadDaudioHDFImpl_001 + * @tc.desc: Verify LoadDaudioHDFImpl func + * @tc.type: FUNC + * @tc.require: AR000GHSJM + */ +HWTEST_F(DAudioHdfOperateTest, LoadDaudioHDFImpl_001, TestSize.Level1) +{ + DHLOGI("DAudioHdfOperateTest::LoadDaudioHDFImpl_001"); + int32_t ret = DaudioHdfOperate::GetInstance().LoadDaudioHDFImpl(nullptr); + EXPECT_EQ(ERR_DH_AUDIO_FAILED, ret); +} + +/** + * @tc.name: LoadDaudioHDFImpl_002 + * @tc.desc: Verify LoadDaudioHDFImpl func + * @tc.type: FUNC + * @tc.require: AR000GHSJM + */ +HWTEST_F(DAudioHdfOperateTest, LoadDaudioHDFImpl_002, TestSize.Level1) +{ + DHLOGI("DAudioHdfOperateTest::LoadDaudioHDFImpl_002"); + EXPECT_CALL(*deviceManager_, LoadDevice(_)).WillRepeatedly(testing::Return(HDF_SUCCESS)); + DaudioHdfOperate::GetInstance().audioServStatus_.store(OHOS::HDI::ServiceManager::V1_0::SERVIE_STATUS_START); + DaudioHdfOperate::GetInstance().audioextServStatus_.store(OHOS::HDI::ServiceManager::V1_0::SERVIE_STATUS_START); + int32_t ret = DaudioHdfOperate::GetInstance().LoadDaudioHDFImpl(nullptr); + DaudioHdfOperate::GetInstance().audioServStatus_.store(OHOS::HDI::ServiceManager::V1_0::SERVIE_STATUS_STOP); + DaudioHdfOperate::GetInstance().audioextServStatus_.store(OHOS::HDI::ServiceManager::V1_0::SERVIE_STATUS_STOP); + EXPECT_EQ(ERR_DH_AUDIO_NULLPTR, ret); +} + +/** + * @tc.name: UnLoadDaudioHDFImpl_001 + * @tc.desc: Verify UnLoadDaudioHDFImpl func + * @tc.type: FUNC + * @tc.require: AR000GHSJM + */ +HWTEST_F(DAudioHdfOperateTest, UnLoadDaudioHDFImpl_001, TestSize.Level1) +{ + DHLOGI("DAudioHdfOperateTest::UnLoadDaudioHDFImpl_001"); + int32_t ret = DaudioHdfOperate::GetInstance().UnLoadDaudioHDFImpl(); + EXPECT_EQ(DH_SUCCESS, ret); +} + +/** + * @tc.name: WaitLoadService_001 + * @tc.desc: Verify WaitLoadService func. + * @tc.type: FUNC + * @tc.require: AR000GHSJM + */ +HWTEST_F(DAudioHdfOperateTest, WaitLoadService_001, TestSize.Level1) +{ + DHLOGI("DAudioHdfOperateTest::WaitLoadService_001"); + DaudioHdfOperate::GetInstance().audioServStatus_.store(OHOS::HDI::ServiceManager::V1_0::SERVIE_STATUS_START); + int32_t ret = DaudioHdfOperate::GetInstance().WaitLoadService(AUDIO_SERVICE_NAME); + EXPECT_EQ(DH_SUCCESS, ret); + DaudioHdfOperate::GetInstance().audioServStatus_.store(OHOS::HDI::ServiceManager::V1_0::SERVIE_STATUS_STOP); + ret = DaudioHdfOperate::GetInstance().WaitLoadService(AUDIO_SERVICE_NAME); + EXPECT_EQ(ERR_DH_AUDIO_FAILED, ret); +} + +/** + * @tc.name: WaitLoadService_002 + * @tc.desc: Verify WaitLoadService func. + * @tc.type: FUNC + * @tc.require: AR000GHSJM + */ +HWTEST_F(DAudioHdfOperateTest, WaitLoadService_002, TestSize.Level1) +{ + DHLOGI("DAudioHdfOperateTest::WaitLoadService_002"); + DaudioHdfOperate::GetInstance().audioextServStatus_.store(OHOS::HDI::ServiceManager::V1_0::SERVIE_STATUS_START); + int32_t ret = DaudioHdfOperate::GetInstance().WaitLoadService(AUDIOEXT_SERVICE_NAME); + EXPECT_EQ(DH_SUCCESS, ret); + DaudioHdfOperate::GetInstance().audioextServStatus_.store(OHOS::HDI::ServiceManager::V1_0::SERVIE_STATUS_STOP); + ret = DaudioHdfOperate::GetInstance().WaitLoadService(AUDIOEXT_SERVICE_NAME); + EXPECT_EQ(ERR_DH_AUDIO_FAILED, ret); +} + +/** + * @tc.name: LoadDevice_001 + * @tc.desc: Verify LoadDevice func. + * @tc.type: FUNC + * @tc.require: AR000GHSJM + */ +HWTEST_F(DAudioHdfOperateTest, LoadDevice_001, TestSize.Level1) +{ + DHLOGI("DAudioHdfOperateTest::LoadDevice_001"); + EXPECT_CALL(*deviceManager_, LoadDevice(_)).WillRepeatedly(testing::Return(HDF_ERR_DEVICE_BUSY)); + int32_t ret = DaudioHdfOperate::GetInstance().LoadDevice(); + EXPECT_EQ(ERR_DH_AUDIO_FAILED, ret); + EXPECT_CALL(*deviceManager_, LoadDevice(_)).WillRepeatedly(testing::Return(ERR_DH_AUDIO_FAILED)); + ret = DaudioHdfOperate::GetInstance().LoadDevice(); + EXPECT_EQ(ERR_DH_AUDIO_FAILED, ret); +} + +/** + * @tc.name: LoadDevice_002 + * @tc.desc: Verify LoadDevice func. + * @tc.type: FUNC + * @tc.require: AR000GHSJM + */ +HWTEST_F(DAudioHdfOperateTest, LoadDevice_002, TestSize.Level1) +{ + DHLOGI("DAudioHdfOperateTest::LoadDevice_002"); + bool isFirstTime = true; + EXPECT_CALL(*deviceManager_, LoadDevice(_)).WillRepeatedly([&]()->int32_t { + if (isFirstTime) { + isFirstTime = false; + return HDF_SUCCESS; + } else { + return HDF_ERR_DEVICE_BUSY; + } + }); + DaudioHdfOperate::GetInstance().audioServStatus_.store(OHOS::HDI::ServiceManager::V1_0::SERVIE_STATUS_START); + int32_t ret = DaudioHdfOperate::GetInstance().LoadDevice(); + EXPECT_EQ(ERR_DH_AUDIO_FAILED, ret); + isFirstTime = true; + EXPECT_CALL(*deviceManager_, LoadDevice(_)).WillRepeatedly([&]()->int32_t { + if (isFirstTime) { + isFirstTime = false; + return HDF_SUCCESS; + } else { + return ERR_DH_AUDIO_FAILED; + } + }); + ret = DaudioHdfOperate::GetInstance().LoadDevice(); + EXPECT_EQ(ERR_DH_AUDIO_FAILED, ret); +} + +/** + * @tc.name: UnLoadDevice_001 + * @tc.desc: Verify UnLoadDevice func. + * @tc.type: FUNC + * @tc.require: AR000GHSJM + */ +HWTEST_F(DAudioHdfOperateTest, UnloadDevice_001, TestSize.Level1) +{ + DHLOGI("DAudioHdfOperateTest::UnloadDevice_001"); + EXPECT_CALL(*deviceManager_, UnloadDevice(_)).WillRepeatedly(testing::Return(HDF_ERR_DEVICE_BUSY)); + int32_t ret = DaudioHdfOperate::GetInstance().UnLoadDevice(); + EXPECT_EQ(DH_SUCCESS, ret); +} + +/** + * @tc.name: UnLoadDevice_002 + * @tc.desc: Verify UnLoadDevice func. + * @tc.type: FUNC + * @tc.require: AR000GHSJM + */ +HWTEST_F(DAudioHdfOperateTest, UnloadDevice_002, TestSize.Level1) +{ + DHLOGI("DAudioHdfOperateTest::UnloadDevice_002"); + auto devmgr = DaudioHdfOperate::GetInstance().devmgr_; + DaudioHdfOperate::GetInstance().devmgr_ = nullptr; + int32_t ret = DaudioHdfOperate::GetInstance().UnLoadDevice(); + DaudioHdfOperate::GetInstance().devmgr_ = devmgr; + EXPECT_EQ(ERR_DH_AUDIO_NULLPTR, ret); +} + +/** + * @tc.name: UnRegisterHdfListener_001 + * @tc.desc: Verify UnRegisterHdfListener func. + * @tc.type: FUNC + * @tc.require: AR000GHSJM + */ +HWTEST_F(DAudioHdfOperateTest, UnRegisterHdfListener_001, TestSize.Level1) +{ + DHLOGI("DAudioHdfOperateTest::UnRegisterHdfListener_001"); + auto audioSrvHdf = DaudioHdfOperate::GetInstance().audioSrvHdf_; + DaudioHdfOperate::GetInstance().audioSrvHdf_ = nullptr; + int32_t ret = DaudioHdfOperate::GetInstance().UnRegisterHdfListener(); + DaudioHdfOperate::GetInstance().audioSrvHdf_ = audioSrvHdf; + EXPECT_EQ(ERR_DH_AUDIO_NULLPTR, ret); +} + +/** + * @tc.name: OnHdfHostDied_001 + * @tc.desc: Verify OnHdfHostDied func. + * @tc.type: FUNC + * @tc.require: AR000GHSJM + */ +HWTEST_F(DAudioHdfOperateTest, OnHdfHostDied_001, TestSize.Level1) +{ + auto hdfDeathCallback = std::make_shared(); + DaudioHdfOperate::GetInstance().hdfDeathCallback_ = nullptr; + DaudioHdfOperate::GetInstance().OnHdfHostDied(); + EXPECT_EQ(hdfDeathCallback->IsCalled(), false); + DaudioHdfOperate::GetInstance().hdfDeathCallback_ = hdfDeathCallback; + DaudioHdfOperate::GetInstance().OnHdfHostDied(); + EXPECT_EQ(hdfDeathCallback->IsCalled(), true); +} + +/** + * @tc.name: AddHdfDeathBind_001 + * @tc.desc: Verify AddHdfDeathBind func. + * @tc.type: FUNC + * @tc.require: AR000GHSJM + */ +HWTEST_F(DAudioHdfOperateTest, AddHdfDeathBind_001, TestSize.Level1) +{ + DHLOGI("DAudioHdfOperateTest::AddHdfDeathBind_001"); + auto audioSrvHdf = DaudioHdfOperate::GetInstance().audioSrvHdf_; + DaudioHdfOperate::GetInstance().audioSrvHdf_ = nullptr; + int32_t ret = DaudioHdfOperate::GetInstance().AddHdfDeathBind(); + DaudioHdfOperate::GetInstance().audioSrvHdf_ = audioSrvHdf; + EXPECT_EQ(ERR_DH_AUDIO_NULLPTR, ret); +} + +/** + * @tc.name: RemoveHdfDeathBind_001 + * @tc.desc: Verify RemoveHdfDeathBind func. + * @tc.type: FUNC + * @tc.require: AR000GHSJM + */ +HWTEST_F(DAudioHdfOperateTest, RemoveHdfDeathBind_001, TestSize.Level1) +{ + DHLOGI("DAudioHdfOperateTest::RemoveHdfDeathBind_001"); + auto audioSrvHdf = DaudioHdfOperate::GetInstance().audioSrvHdf_; + DaudioHdfOperate::GetInstance().audioSrvHdf_ = nullptr; + int32_t ret = DaudioHdfOperate::GetInstance().RemoveHdfDeathBind(); + DaudioHdfOperate::GetInstance().audioSrvHdf_ = audioSrvHdf; + EXPECT_EQ(ERR_DH_AUDIO_NULLPTR, ret); +} +} // namespace DistributedHardware +} // namespace OHOS diff --git a/interfaces/inner_kits/native_cpp/test/unittest/audiosourcetest/src/mock_hdfoperate_device_manager.cpp b/interfaces/inner_kits/native_cpp/test/unittest/audiosourcetest/src/mock_hdfoperate_device_manager.cpp new file mode 100644 index 00000000..d31e349f --- /dev/null +++ b/interfaces/inner_kits/native_cpp/test/unittest/audiosourcetest/src/mock_hdfoperate_device_manager.cpp @@ -0,0 +1,48 @@ +/* + * Copyright (c) 2025 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 "mock_hdfoperate_device_manager.h" + +namespace OHOS { +namespace DistributedHardware { +sptr MockDeviceManager::deviceManagerInstance_; + +sptr MockDeviceManager::GetOrCreateInstance() +{ + if (deviceManagerInstance_ == nullptr) { + deviceManagerInstance_ = sptr(new MockDeviceManager()); + } + return deviceManagerInstance_; +} + +void MockDeviceManager::ReleaseInstance() +{ + deviceManagerInstance_ = nullptr; +} +} // namespace DistributedHardware + +namespace HDI { +namespace DeviceManager { +namespace V1_0 { +using namespace OHOS::DistributedHardware; + +sptr IDeviceManager::Get() +{ + return MockDeviceManager::GetOrCreateInstance(); +} +} +} +} +} // namespace OHOS \ No newline at end of file diff --git a/services/audiohdiproxy/src/daudio_hdi_handler.cpp b/services/audiohdiproxy/src/daudio_hdi_handler.cpp index 8dfe00df..50cd997f 100644 --- a/services/audiohdiproxy/src/daudio_hdi_handler.cpp +++ b/services/audiohdiproxy/src/daudio_hdi_handler.cpp @@ -57,10 +57,7 @@ int32_t DAudioHdiHandler::InitHdiHandler() DHLOGD("Load hdf driver start."); auto dHFwkKit = GetDHFwkKit(); - if (dHFwkKit == nullptr) { - DHLOGE("Get dHFwkKit is null when load hdf driver."); - return ERR_DH_AUDIO_NULLPTR; - } + CHECK_NULL_RETURN(dHFwkKit, ERR_DH_AUDIO_NULLPTR); int32_t ret = dHFwkKit->LoadDistributedHDF(DHType::AUDIO); DaudioRadar::GetInstance().ReportDaudioInit("LoadDaudioHDFImpl", AudioInit::LOAD_HDF_DRIVER, BizState::BIZ_STATE_END, ret); @@ -87,10 +84,7 @@ int32_t DAudioHdiHandler::UninitHdiHandler() CHECK_NULL_RETURN(audioSrvHdf_, DH_SUCCESS); auto dHFwkKit = GetDHFwkKit(); - if (dHFwkKit == nullptr) { - DHLOGE("Get dHFwkKit is null when unload hdf driver."); - return ERR_DH_AUDIO_NULLPTR; - } + CHECK_NULL_RETURN(dHFwkKit, ERR_DH_AUDIO_NULLPTR); int32_t ret = dHFwkKit->UnLoadDistributedHDF(DHType::AUDIO); if (ret != DH_SUCCESS) { DHLOGE("Unload hdf driver failed, ret: %{public}d", ret); diff --git a/services/audiohdiproxy/test/unittest/daudio_hdi_handler/BUILD.gn b/services/audiohdiproxy/test/unittest/daudio_hdi_handler/BUILD.gn index fc175489..06ad4522 100644 --- a/services/audiohdiproxy/test/unittest/daudio_hdi_handler/BUILD.gn +++ b/services/audiohdiproxy/test/unittest/daudio_hdi_handler/BUILD.gn @@ -24,6 +24,7 @@ config("module_private_config") { include_dirs = [ "include", "${common_path}/include", + "${interfaces_path}/inner_kits/native_cpp/audio_source/include", "${services_path}/common/audiodata/include", "${services_path}/common/audioparam", "${services_path}/common/audiodata/include", @@ -36,9 +37,9 @@ ohos_unittest("DAudioHdiHandlerTest") { module_out_path = module_out_path sources = [ - "src/daudio_hdf_operate.cpp", "src/daudio_hdi_handler_test.cpp", "src/mock_distributed_hardware_fwk_kit.cpp", + "${interfaces_path}/inner_kits/native_cpp/audio_source/src/daudio_hdf_operate.cpp", ] configs = [ ":module_private_config" ] diff --git a/services/audiohdiproxy/test/unittest/daudio_hdi_handler/src/mock_distributed_hardware_fwk_kit.cpp b/services/audiohdiproxy/test/unittest/daudio_hdi_handler/src/mock_distributed_hardware_fwk_kit.cpp index 53a79248..09469048 100644 --- a/services/audiohdiproxy/test/unittest/daudio_hdi_handler/src/mock_distributed_hardware_fwk_kit.cpp +++ b/services/audiohdiproxy/test/unittest/daudio_hdi_handler/src/mock_distributed_hardware_fwk_kit.cpp @@ -22,7 +22,7 @@ namespace OHOS { namespace DistributedHardware { int32_t DistributedHardwareFwkKit::LoadDistributedHDF(const DHType dhType) { - return DaudioHdfOperate::GetInstance().LoadDaudioHDFImpl(); + return DaudioHdfOperate::GetInstance().LoadDaudioHDFImpl(nullptr); } int32_t DistributedHardwareFwkKit::UnLoadDistributedHDF(const DHType dhType) diff --git a/services/audiomanager/test/unittest/sourcemanager/BUILD.gn b/services/audiomanager/test/unittest/sourcemanager/BUILD.gn index 02dbf8bd..fb08599b 100644 --- a/services/audiomanager/test/unittest/sourcemanager/BUILD.gn +++ b/services/audiomanager/test/unittest/sourcemanager/BUILD.gn @@ -54,8 +54,8 @@ ohos_unittest("DaudioSourceMgrTest") { sources = [ "src/daudio_source_mgr_test.cpp", - "../../../../audiohdiproxy/test/unittest/daudio_hdi_handler/src/daudio_hdf_operate.cpp", - "../../../../audiohdiproxy/test/unittest/daudio_hdi_handler/src/mock_distributed_hardware_fwk_kit.cpp", + "${interfaces_path}/inner_kits/native_cpp/audio_source/src/daudio_hdf_operate.cpp", + "${services_path}/audiohdiproxy/test/unittest/daudio_hdi_handler/src/mock_distributed_hardware_fwk_kit.cpp", ] configs = [ ":module_private_config" ] -- Gitee