From e7cc093b7f539cfcdfc41c5361d9d19ae10924d0 Mon Sep 17 00:00:00 2001 From: zhuzhihui7 Date: Mon, 26 May 2025 09:46:54 +0800 Subject: [PATCH] =?UTF-8?q?hdf=E9=A9=B1=E5=8A=A8=E5=8A=A0=E8=BD=BD?= =?UTF-8?q?=E5=85=BC=E5=AE=B9=E5=8D=95=E6=A1=86=E6=9E=B6=E5=92=8C=E5=8F=8C?= =?UTF-8?q?=E6=A1=86=E6=9E=B6=EF=BC=9B?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: zhuzhihui7 --- bundle.json | 5 + .../include/dhardware_ipc_interface_code.h | 2 + .../include/distributed_hardware_errno.h | 5 + common/utils/include/idistributed_hardware.h | 2 + .../include/distributed_hardware_fwk_kit.h | 16 ++ .../include/ipc/distributed_hardware_proxy.h | 2 + .../src/distributed_hardware_fwk_kit.cpp | 42 ++- .../src/ipc/distributed_hardware_proxy.cpp | 72 +++++ .../distributedhardwarefwkkit_fuzzer.cpp | 26 ++ .../src/distributed_hardware_fwk_kit_test.cpp | 26 ++ .../include/dhfwk_sa_manager_test.h | 12 + .../include/distributed_hardware_proxy_test.h | 2 + .../src/distributed_hardware_proxy_test.cpp | 86 ++++++ .../distributedhardwarefwkservice/BUILD.gn | 8 + .../componentmanager/component_manager.h | 1 + .../include/distributed_hardware_service.h | 2 + .../include/distributed_hardware_stub.h | 2 + .../include/hdfoperate/daudio_hdf_operate.h | 93 +++++++ .../include/hdfoperate/dcamera_hdf_operate.h | 91 ++++++ .../componentmanager/component_manager.cpp | 19 ++ .../src/distributed_hardware_service.cpp | 28 ++ .../src/distributed_hardware_stub.cpp | 36 +++ .../src/hdfoperate/daudio_hdf_operate.cpp | 258 +++++++++++++++++ .../src/hdfoperate/dcamera_hdf_operate.cpp | 259 ++++++++++++++++++ .../test/unittest/BUILD.gn | 1 + .../src/component_manager_test.cpp | 5 +- .../src/distributed_hardware_service_test.cpp | 15 + .../include/distributed_hardware_stub_test.h | 12 + .../src/distributed_hardware_stub_test.cpp | 32 +++ .../test/unittest/common/hdfoperate/BUILD.gn | 128 +++++++++ .../hdfoperate/daudio_hdf_operate_test.cpp | 213 ++++++++++++++ .../hdfoperate/dcamera_hdf_operate_test.cpp | 180 ++++++++++++ .../mock_hdfoperate_device_manager.cpp | 48 ++++ .../mock_hdfoperate_device_manager.h | 39 +++ .../utils/dh_modem_context_ext_test.cpp | 9 +- 35 files changed, 1756 insertions(+), 21 deletions(-) create mode 100644 services/distributedhardwarefwkservice/include/hdfoperate/daudio_hdf_operate.h create mode 100644 services/distributedhardwarefwkservice/include/hdfoperate/dcamera_hdf_operate.h create mode 100644 services/distributedhardwarefwkservice/src/hdfoperate/daudio_hdf_operate.cpp create mode 100644 services/distributedhardwarefwkservice/src/hdfoperate/dcamera_hdf_operate.cpp create mode 100644 services/distributedhardwarefwkservice/test/unittest/common/hdfoperate/BUILD.gn create mode 100644 services/distributedhardwarefwkservice/test/unittest/common/hdfoperate/daudio_hdf_operate_test.cpp create mode 100644 services/distributedhardwarefwkservice/test/unittest/common/hdfoperate/dcamera_hdf_operate_test.cpp create mode 100644 services/distributedhardwarefwkservice/test/unittest/common/hdfoperate/mock_hdfoperate_device_manager.cpp create mode 100644 services/distributedhardwarefwkservice/test/unittest/common/hdfoperate/mock_hdfoperate_device_manager.h diff --git a/bundle.json b/bundle.json index 5b6bfe3d..fdc2cc19 100644 --- a/bundle.json +++ b/bundle.json @@ -37,9 +37,12 @@ "bundle_framework", "napi", "dsoftbus", + "drivers_interface_distributed_audio", + "drivers_interface_distributed_camera", "eventhandler", "hitrace", "c_utils", + "hdf_core", "hilog", "cJSON", "samgr", @@ -135,6 +138,7 @@ "header_files": [ "constants.h", "device_type.h", + "dhardware_descriptor.h", "dhardware_ipc_interface_code.h", "distributed_hardware_errno.h", "iav_trans_control_center_callback.h", @@ -143,6 +147,7 @@ "idistributed_hardware_source.h", "idistributed_hardware.h", "ihardware_handler.h", + "ihardware_status_listener.h", "ipublisher_listener.h", "single_instance.h" ], diff --git a/common/utils/include/dhardware_ipc_interface_code.h b/common/utils/include/dhardware_ipc_interface_code.h index 902c02a0..67a54efc 100644 --- a/common/utils/include/dhardware_ipc_interface_code.h +++ b/common/utils/include/dhardware_ipc_interface_code.h @@ -43,6 +43,8 @@ enum class DHMsgInterfaceCode : uint32_t { DISABLE_SINK = 480019, ENABLE_SOURCE = 480020, DISABLE_SOURCE = 480021, + LOAD_HDF = 480022, + UNLOAD_HDF = 480023, NOTIFY_SOURCE_DEVICE_REMOTE_DMSDP_STARTED = 1, }; } // namespace DistributedHardware diff --git a/common/utils/include/distributed_hardware_errno.h b/common/utils/include/distributed_hardware_errno.h index 530bb79b..cdc4f080 100644 --- a/common/utils/include/distributed_hardware_errno.h +++ b/common/utils/include/distributed_hardware_errno.h @@ -105,6 +105,11 @@ namespace DistributedHardware { constexpr int32_t ERR_DH_FWK_SERVICE_MSG_INVALID = -10809; constexpr int32_t ERR_DH_FWK_AVTRANS_CALLBACK_IS_NULL = -10810; constexpr int32_t ERR_DH_FWK_GETDISTRIBUTEDHARDWARE_TIMEOUT = -10811; + constexpr int32_t ERR_DH_FWK_STATUS_LISTENER_IS_NULL = -10812; + constexpr int32_t ERR_DH_FWK_REGISTER_HDF_LISTENER_FAIL = -10813; + constexpr int32_t ERR_DH_FWK_LOAD_HDF_FAIL = -10814; + constexpr int32_t ERR_DH_FWK_LOAD_HDF_TIMEOUT = -10815; + constexpr int32_t ERR_DH_FWK_NO_HDF_SUPPORT = -10816; /* AccessManager errno, range: [-10900, -10999] */ constexpr int32_t ERR_DH_FWK_ACCESS_INIT_DM_FAILED = -10900; diff --git a/common/utils/include/idistributed_hardware.h b/common/utils/include/idistributed_hardware.h index e17488b9..c46f6431 100644 --- a/common/utils/include/idistributed_hardware.h +++ b/common/utils/include/idistributed_hardware.h @@ -63,6 +63,8 @@ public: virtual int32_t DisableSink(const std::vector &descriptors) = 0; virtual int32_t EnableSource(const std::string &networkId, const std::vector &descriptors) = 0; virtual int32_t DisableSource(const std::string &networkId, const std::vector &descriptors) = 0; + virtual int32_t LoadDistributedHDF(const DHType dhType) = 0; + virtual int32_t UnLoadDistributedHDF(const DHType dhType) = 0; }; } // namespace DistributedHardware } // namespace OHOS diff --git a/interfaces/inner_kits/include/distributed_hardware_fwk_kit.h b/interfaces/inner_kits/include/distributed_hardware_fwk_kit.h index d2744e90..bb7d6678 100644 --- a/interfaces/inner_kits/include/distributed_hardware_fwk_kit.h +++ b/interfaces/inner_kits/include/distributed_hardware_fwk_kit.h @@ -238,6 +238,22 @@ public: */ API_EXPORT int32_t DisableSource(const std::string &networkId, const std::vector &descriptors); + /** + * @brief Load distributed HDF. + * + * @param dhType distributed hardware type. + * @return Returns 0 if success. + */ + API_EXPORT int32_t LoadDistributedHDF(const DHType dhType); + + /** + * @brief Unload distributed HDF. + * + * @param dhType distributed hardware type. + * @return Returns 0 if success. + */ + API_EXPORT int32_t UnLoadDistributedHDF(const DHType dhType); + private: /** * @brief Determine whether the topic is valid. diff --git a/interfaces/inner_kits/include/ipc/distributed_hardware_proxy.h b/interfaces/inner_kits/include/ipc/distributed_hardware_proxy.h index 90937e86..7fba9350 100644 --- a/interfaces/inner_kits/include/ipc/distributed_hardware_proxy.h +++ b/interfaces/inner_kits/include/ipc/distributed_hardware_proxy.h @@ -57,6 +57,8 @@ public: int32_t DisableSink(const std::vector &descriptors) override; int32_t EnableSource(const std::string &networkId, const std::vector &descriptors) override; int32_t DisableSource(const std::string &networkId, const std::vector &descriptors) override; + int32_t LoadDistributedHDF(const DHType dhType) override; + int32_t UnLoadDistributedHDF(const DHType dhType) override; private: int32_t ReadDescriptors(MessageParcel &data, std::vector &descriptors); diff --git a/interfaces/inner_kits/src/distributed_hardware_fwk_kit.cpp b/interfaces/inner_kits/src/distributed_hardware_fwk_kit.cpp index 91ea88ca..4e388005 100644 --- a/interfaces/inner_kits/src/distributed_hardware_fwk_kit.cpp +++ b/interfaces/inner_kits/src/distributed_hardware_fwk_kit.cpp @@ -227,7 +227,7 @@ int32_t DistributedHardwareFwkKit::PauseDistributedHardware(DHType dhType, const GetAnonyString(networkId).c_str()); if (DHFWKSAManager::GetInstance().GetDHFWKProxy() == nullptr) { - DHLOGI("DHFWK not online or get proxy failed, can not register av control center callback."); + DHLOGI("DHFWK not online or get proxy failed, can not pause distributed hardware."); return ERR_DH_FWK_POINTER_IS_NULL; } HiSysEventWriteMsg(DHFWK_INIT_END, OHOS::HiviewDFX::HiSysEvent::EventType::BEHAVIOR, @@ -244,7 +244,7 @@ int32_t DistributedHardwareFwkKit::ResumeDistributedHardware(DHType dhType, cons GetAnonyString(networkId).c_str()); if (DHFWKSAManager::GetInstance().GetDHFWKProxy() == nullptr) { - DHLOGI("DHFWK not online or get proxy failed, can not register av control center callback."); + DHLOGI("DHFWK not online or get proxy failed, can not resume distributed hardware."); return ERR_DH_FWK_POINTER_IS_NULL; } HiSysEventWriteMsg(DHFWK_INIT_BEGIN, OHOS::HiviewDFX::HiSysEvent::EventType::BEHAVIOR, @@ -261,7 +261,7 @@ int32_t DistributedHardwareFwkKit::StopDistributedHardware(DHType dhType, const GetAnonyString(networkId).c_str()); if (DHFWKSAManager::GetInstance().GetDHFWKProxy() == nullptr) { - DHLOGI("DHFWK not online or get proxy failed, can not register av control center callback."); + DHLOGI("DHFWK not online or get proxy failed, can not stop distributed hardware."); return ERR_DH_FWK_POINTER_IS_NULL; } HiSysEventWriteMsg(DHFWK_EXIT_END, OHOS::HiviewDFX::HiSysEvent::EventType::BEHAVIOR, @@ -287,7 +287,7 @@ int32_t DistributedHardwareFwkKit::RegisterDHStatusListener(sptrRegisterDHStatusListener(listener); @@ -297,7 +297,7 @@ int32_t DistributedHardwareFwkKit::UnregisterDHStatusListener(sptrUnregisterDHStatusListener(listener); @@ -311,7 +311,7 @@ int32_t DistributedHardwareFwkKit::RegisterDHStatusListener( } DHLOGI("Register distributed hardware status source listener %{public}s.", GetAnonyString(networkId).c_str()); if (DHFWKSAManager::GetInstance().GetDHFWKProxy() == nullptr) { - DHLOGI("DHFWK not online or get proxy failed, can not register av control center callback."); + DHLOGI("DHFWK not online or get proxy failed, can not register distributed hardware status listener."); return ERR_DH_FWK_POINTER_IS_NULL; } return DHFWKSAManager::GetInstance().GetDHFWKProxy()->RegisterDHStatusListener(networkId, listener); @@ -325,7 +325,7 @@ int32_t DistributedHardwareFwkKit::UnregisterDHStatusListener( } DHLOGI("Unregister distributed hardware status source listener %{public}s.", GetAnonyString(networkId).c_str()); if (DHFWKSAManager::GetInstance().GetDHFWKProxy() == nullptr) { - DHLOGI("DHFWK not online or get proxy failed, can not register av control center callback."); + DHLOGI("DHFWK not online or get proxy failed, can not unregister distributed hardware status listener."); return ERR_DH_FWK_POINTER_IS_NULL; } return DHFWKSAManager::GetInstance().GetDHFWKProxy()->UnregisterDHStatusListener(networkId, listener); @@ -335,7 +335,7 @@ int32_t DistributedHardwareFwkKit::EnableSink(const std::vector &d { DHLOGI("Enable distributed hardware sink descriptors %{public}s.", DumpDescriptors(descriptors).c_str()); if (DHFWKSAManager::GetInstance().GetDHFWKProxy() == nullptr) { - DHLOGI("DHFWK not online or get proxy failed, can not register av control center callback."); + DHLOGI("DHFWK not online or get proxy failed, can not enable sink."); return ERR_DH_FWK_POINTER_IS_NULL; } return DHFWKSAManager::GetInstance().GetDHFWKProxy()->EnableSink(descriptors); @@ -345,7 +345,7 @@ int32_t DistributedHardwareFwkKit::DisableSink(const std::vector & { DHLOGI("Disable distributed hardware sink descriptors %{public}s.", DumpDescriptors(descriptors).c_str()); if (DHFWKSAManager::GetInstance().GetDHFWKProxy() == nullptr) { - DHLOGI("DHFWK not online or get proxy failed, can not register av control center callback."); + DHLOGI("DHFWK not online or get proxy failed, can not disable sink."); return ERR_DH_FWK_POINTER_IS_NULL; } return DHFWKSAManager::GetInstance().GetDHFWKProxy()->DisableSink(descriptors); @@ -360,7 +360,7 @@ int32_t DistributedHardwareFwkKit::EnableSource( DHLOGI("Enable distributed hardware source networkId %{public}s, descriptors %{public}s.", GetAnonyString(networkId).c_str(), DumpDescriptors(descriptors).c_str()); if (DHFWKSAManager::GetInstance().GetDHFWKProxy() == nullptr) { - DHLOGI("DHFWK not online or get proxy failed, can not register av control center callback."); + DHLOGI("DHFWK not online or get proxy failed, can not enable source."); return ERR_DH_FWK_POINTER_IS_NULL; } return DHFWKSAManager::GetInstance().GetDHFWKProxy()->EnableSource(networkId, descriptors); @@ -375,10 +375,30 @@ int32_t DistributedHardwareFwkKit::DisableSource( DHLOGI("Disable distributed hardware source networkId %{public}s, descriptors %{public}s.", GetAnonyString(networkId).c_str(), DumpDescriptors(descriptors).c_str()); if (DHFWKSAManager::GetInstance().GetDHFWKProxy() == nullptr) { - DHLOGI("DHFWK not online or get proxy failed, can not register av control center callback."); + DHLOGI("DHFWK not online or get proxy failed, can not disable source."); return ERR_DH_FWK_POINTER_IS_NULL; } return DHFWKSAManager::GetInstance().GetDHFWKProxy()->DisableSource(networkId, descriptors); } + +int32_t DistributedHardwareFwkKit::LoadDistributedHDF(const DHType dhType) +{ + DHLOGI("Load distributed HDF, dhType: %{public}u.", dhType); + if (DHFWKSAManager::GetInstance().GetDHFWKProxy() == nullptr) { + DHLOGI("DHFWK not online or get proxy failed, can not load distributed HDF."); + return ERR_DH_FWK_POINTER_IS_NULL; + } + return DHFWKSAManager::GetInstance().GetDHFWKProxy()->LoadDistributedHDF(dhType); +} + +int32_t DistributedHardwareFwkKit::UnLoadDistributedHDF(const DHType dhType) +{ + DHLOGI("UnLoad distributed HDF, dhType: %{public}u.", dhType); + if (DHFWKSAManager::GetInstance().GetDHFWKProxy() == nullptr) { + DHLOGI("DHFWK not online or get proxy failed, can not unload distributed HDF."); + return ERR_DH_FWK_POINTER_IS_NULL; + } + return DHFWKSAManager::GetInstance().GetDHFWKProxy()->UnLoadDistributedHDF(dhType); +} } // DistributedHardware } // OHOS \ No newline at end of file diff --git a/interfaces/inner_kits/src/ipc/distributed_hardware_proxy.cpp b/interfaces/inner_kits/src/ipc/distributed_hardware_proxy.cpp index 47ee352d..d3f104ce 100644 --- a/interfaces/inner_kits/src/ipc/distributed_hardware_proxy.cpp +++ b/interfaces/inner_kits/src/ipc/distributed_hardware_proxy.cpp @@ -578,6 +578,10 @@ int32_t DistributedHardwareProxy::GetDistributedHardware(const std::string &netw int32_t DistributedHardwareProxy::RegisterDHStatusListener(sptr listener) { DHLOGI("DistributedHardwareProxy RegisterDHStatusListener."); + if (listener == nullptr) { + DHLOGE("status listener is null"); + return ERR_DH_FWK_STATUS_LISTENER_IS_NULL; + } sptr remote = Remote(); if (remote == nullptr) { DHLOGE("remote service is null!"); @@ -606,6 +610,10 @@ int32_t DistributedHardwareProxy::RegisterDHStatusListener(sptr listener) { DHLOGI("DistributedHardwareProxy UnregisterDHStatusListener."); + if (listener == nullptr) { + DHLOGE("status listener is null"); + return ERR_DH_FWK_STATUS_LISTENER_IS_NULL; + } sptr remote = Remote(); if (remote == nullptr) { DHLOGE("remote service is null!"); @@ -635,6 +643,10 @@ int32_t DistributedHardwareProxy::RegisterDHStatusListener( const std::string &networkId, sptr listener) { DHLOGI("DistributedHardwareProxy RegisterDHStatusListener."); + if (listener == nullptr) { + DHLOGE("status listener is null"); + return ERR_DH_FWK_STATUS_LISTENER_IS_NULL; + } if (!IsIdLengthValid(networkId)) { return ERR_DH_FWK_PARA_INVALID; } @@ -671,6 +683,10 @@ int32_t DistributedHardwareProxy::UnregisterDHStatusListener( const std::string &networkId, sptr listener) { DHLOGI("DistributedHardwareProxy UnregisterDHStatusListener."); + if (listener == nullptr) { + DHLOGE("status listener is null"); + return ERR_DH_FWK_STATUS_LISTENER_IS_NULL; + } if (!IsIdLengthValid(networkId)) { return ERR_DH_FWK_PARA_INVALID; } @@ -827,6 +843,62 @@ int32_t DistributedHardwareProxy::DisableSource( return reply.ReadInt32(); } +int32_t DistributedHardwareProxy::LoadDistributedHDF(const DHType dhType) +{ + sptr remote = Remote(); + if (remote == nullptr) { + DHLOGE("remote service is null"); + return ERR_DH_AVT_SERVICE_REMOTE_IS_NULL; + } + MessageParcel data; + MessageParcel reply; + MessageOption option; + if (!data.WriteInterfaceToken(GetDescriptor())) { + DHLOGE("WriteInterfaceToken fail!"); + return ERR_DH_AVT_SERVICE_WRITE_TOKEN_FAIL; + } + uint32_t type = static_cast(dhType); + if (!data.WriteUint32(type)) { + DHLOGE("Write type failed"); + return ERR_DH_AVT_SERVICE_WRITE_INFO_FAIL; + } + int32_t ret = remote->SendRequest(static_cast(DHMsgInterfaceCode::LOAD_HDF), + data, reply, option); + if (ret != NO_ERROR) { + DHLOGE("Send Request failed, ret: %{public}d", ret); + return ERR_DH_AVT_SERVICE_IPC_SEND_REQUEST_FAIL; + } + return reply.ReadInt32(); +} + +int32_t DistributedHardwareProxy::UnLoadDistributedHDF(const DHType dhType) +{ + sptr remote = Remote(); + if (remote == nullptr) { + DHLOGE("remote service is null"); + return ERR_DH_AVT_SERVICE_REMOTE_IS_NULL; + } + MessageParcel data; + MessageParcel reply; + MessageOption option; + if (!data.WriteInterfaceToken(GetDescriptor())) { + DHLOGE("WriteInterfaceToken fail!"); + return ERR_DH_AVT_SERVICE_WRITE_TOKEN_FAIL; + } + uint32_t type = static_cast(dhType); + if (!data.WriteUint32(type)) { + DHLOGE("Write type failed"); + return ERR_DH_AVT_SERVICE_WRITE_INFO_FAIL; + } + int32_t ret = remote->SendRequest(static_cast(DHMsgInterfaceCode::UNLOAD_HDF), + data, reply, option); + if (ret != NO_ERROR) { + DHLOGE("Send Request failed, ret: %{public}d", ret); + return ERR_DH_AVT_SERVICE_IPC_SEND_REQUEST_FAIL; + } + return reply.ReadInt32(); +} + int32_t DistributedHardwareProxy::ReadDescriptors(MessageParcel &data, std::vector &descriptors) { int32_t size = data.ReadInt32(); diff --git a/interfaces/inner_kits/test/fuzztest/distributedhardwarefwkkit_fuzzer/distributedhardwarefwkkit_fuzzer.cpp b/interfaces/inner_kits/test/fuzztest/distributedhardwarefwkkit_fuzzer/distributedhardwarefwkkit_fuzzer.cpp index afd2c4a6..ec0f7234 100644 --- a/interfaces/inner_kits/test/fuzztest/distributedhardwarefwkkit_fuzzer/distributedhardwarefwkkit_fuzzer.cpp +++ b/interfaces/inner_kits/test/fuzztest/distributedhardwarefwkkit_fuzzer/distributedhardwarefwkkit_fuzzer.cpp @@ -304,6 +304,30 @@ void DisableSinkFuzzTest(const uint8_t *data, size_t size) descriptors.push_back(dhDescriptor); dhfwkKit.DisableSink(descriptors); } + +void LoadDistributedHDFFuzzTest(const uint8_t *data, size_t size) +{ + if ((data == nullptr) || (size < sizeof(uint32_t))) { + return; + } + + DHType dhType = static_cast(*(reinterpret_cast(data))); + + DistributedHardwareFwkKit dhfwkKit; + dhfwkKit.LoadDistributedHDF(dhType); +} + +void UnLoadDistributedHDFFuzzTest(const uint8_t *data, size_t size) +{ + if ((data == nullptr) || (size < sizeof(uint32_t))) { + return; + } + + DHType dhType = static_cast(*(reinterpret_cast(data))); + + DistributedHardwareFwkKit dhfwkKit; + dhfwkKit.UnLoadDistributedHDF(dhType); +} } // namespace DistributedHardware } // namespace OHOS @@ -328,5 +352,7 @@ extern "C" int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) OHOS::DistributedHardware::DisableSourceFuzzTest(data, size); OHOS::DistributedHardware::EnableSinkFuzzTest(data, size); OHOS::DistributedHardware::DisableSinkFuzzTest(data, size); + OHOS::DistributedHardware::LoadDistributedHDFFuzzTest(data, size); + OHOS::DistributedHardware::UnLoadDistributedHDFFuzzTest(data, size); return 0; } \ No newline at end of file diff --git a/interfaces/inner_kits/test/unittest/common/distributedhardwarefwkkit/src/distributed_hardware_fwk_kit_test.cpp b/interfaces/inner_kits/test/unittest/common/distributedhardwarefwkkit/src/distributed_hardware_fwk_kit_test.cpp index eb599495..27ecfe95 100644 --- a/interfaces/inner_kits/test/unittest/common/distributedhardwarefwkkit/src/distributed_hardware_fwk_kit_test.cpp +++ b/interfaces/inner_kits/test/unittest/common/distributedhardwarefwkkit/src/distributed_hardware_fwk_kit_test.cpp @@ -603,5 +603,31 @@ HWTEST_F(DistributedHardwareFwkKitTest, DisableSource_001, testing::ext::TestSiz ret = dhfwkPtr_->DisableSource(networkId, descriptors); EXPECT_EQ(ERR_DH_FWK_POINTER_IS_NULL, ret); } + +/** + * @tc.name: LoadDistributedHDF_001 + * @tc.desc: Verify the LoadDistributedHDF function + * @tc.type: FUNC + * @tc.require: AR000GHSJM + */ +HWTEST_F(DistributedHardwareFwkKitTest, LoadDistributedHDF_001, testing::ext::TestSize.Level0) +{ + ASSERT_TRUE(dhfwkPtr_ != nullptr); + int32_t ret = dhfwkPtr_->LoadDistributedHDF(DHType::CAMERA); + EXPECT_EQ(ERR_DH_FWK_POINTER_IS_NULL, ret); +} + +/** + * @tc.name: UnLoadDistributedHDF_001 + * @tc.desc: Verify the UnLoadDistributedHDF function + * @tc.type: FUNC + * @tc.require: AR000GHSJM + */ +HWTEST_F(DistributedHardwareFwkKitTest, UnLoadDistributedHDF_001, testing::ext::TestSize.Level0) +{ + ASSERT_TRUE(dhfwkPtr_ != nullptr); + int32_t ret = dhfwkPtr_->UnLoadDistributedHDF(DHType::CAMERA); + EXPECT_EQ(ERR_DH_FWK_POINTER_IS_NULL, ret); +} } // namespace DistributedHardware } // namespace OHOS \ No newline at end of file diff --git a/interfaces/inner_kits/test/unittest/common/ipc/dhfwk_sa_manager/include/dhfwk_sa_manager_test.h b/interfaces/inner_kits/test/unittest/common/ipc/dhfwk_sa_manager/include/dhfwk_sa_manager_test.h index 7639175f..0f5f633f 100644 --- a/interfaces/inner_kits/test/unittest/common/ipc/dhfwk_sa_manager/include/dhfwk_sa_manager_test.h +++ b/interfaces/inner_kits/test/unittest/common/ipc/dhfwk_sa_manager/include/dhfwk_sa_manager_test.h @@ -191,6 +191,18 @@ int32_t DisableSource(const std::string &networkId, const std::vector &descriptors); int32_t EnableSource(const std::string &networkId, const std::vector &descriptors); int32_t DisableSource(const std::string &networkId, const std::vector &descriptors); + int32_t LoadDistributedHDF(const DHType dhType); + int32_t UnLoadDistributedHDF(const DHType dhType); }; class TestDistributedHardwareStub2 : public TestDistributedHardwareStub { diff --git a/interfaces/inner_kits/test/unittest/common/ipc/distributed_hardware_proxy/src/distributed_hardware_proxy_test.cpp b/interfaces/inner_kits/test/unittest/common/ipc/distributed_hardware_proxy/src/distributed_hardware_proxy_test.cpp index 0195307b..a318789c 100644 --- a/interfaces/inner_kits/test/unittest/common/ipc/distributed_hardware_proxy/src/distributed_hardware_proxy_test.cpp +++ b/interfaces/inner_kits/test/unittest/common/ipc/distributed_hardware_proxy/src/distributed_hardware_proxy_test.cpp @@ -208,6 +208,18 @@ int32_t DistributedHardwareProxyTest::TestDistributedHardwareStub::DisableSource return DH_FWK_SUCCESS; } +int32_t DistributedHardwareProxyTest::TestDistributedHardwareStub::LoadDistributedHDF(const DHType dhType) +{ + (void)dhType; + return DH_FWK_SUCCESS; +} + +int32_t DistributedHardwareProxyTest::TestDistributedHardwareStub::UnLoadDistributedHDF(const DHType dhType) +{ + (void)dhType; + return DH_FWK_SUCCESS; +} + void DistributedHardwareProxyTest::TestGetDistributedHardwareCallback::OnSuccess( const std::string &networkId, const std::vector &descriptors, EnableStep enableStep) { @@ -586,6 +598,16 @@ HWTEST_F(DistributedHardwareProxyTest, RegisterDHStatusListener_Source_001, Test EXPECT_EQ(ERR_DH_FWK_PARA_INVALID, ret); } +HWTEST_F(DistributedHardwareProxyTest, RegisterDHStatusListener_Source_002, TestSize.Level1) +{ + sptr dhStubPtr(new TestDistributedHardwareStub()); + ASSERT_TRUE(dhStubPtr != nullptr); + DistributedHardwareProxy dhProxy(dhStubPtr); + sptr listener(new MockHDSourceStatusListenerStub()); + auto ret = dhProxy.RegisterDHStatusListener(std::string(), nullptr); + EXPECT_EQ(ERR_DH_FWK_STATUS_LISTENER_IS_NULL, ret); +} + HWTEST_F(DistributedHardwareProxyTest, UnregisterDHStatusListener_Source_001, TestSize.Level1) { std::string networkId = "123456"; @@ -599,6 +621,16 @@ HWTEST_F(DistributedHardwareProxyTest, UnregisterDHStatusListener_Source_001, Te EXPECT_EQ(ERR_DH_FWK_PARA_INVALID, ret); } +HWTEST_F(DistributedHardwareProxyTest, UnregisterDHStatusListener_Source_002, TestSize.Level1) +{ + sptr dhStubPtr(new TestDistributedHardwareStub()); + ASSERT_TRUE(dhStubPtr != nullptr); + DistributedHardwareProxy dhProxy(dhStubPtr); + sptr listener(new MockHDSourceStatusListenerStub()); + auto ret = dhProxy.UnregisterDHStatusListener(std::string(), nullptr); + EXPECT_EQ(ERR_DH_FWK_STATUS_LISTENER_IS_NULL, ret); +} + HWTEST_F(DistributedHardwareProxyTest, RegisterDHStatusListener_Sink_001, TestSize.Level1) { sptr dhStubPtr(new TestDistributedHardwareStub()); @@ -609,6 +641,16 @@ HWTEST_F(DistributedHardwareProxyTest, RegisterDHStatusListener_Sink_001, TestSi EXPECT_EQ(ERR_DH_AVT_SERVICE_IPC_SEND_REQUEST_FAIL, ret); } +HWTEST_F(DistributedHardwareProxyTest, RegisterDHStatusListener_Sink_002, TestSize.Level1) +{ + sptr dhStubPtr(new TestDistributedHardwareStub()); + ASSERT_TRUE(dhStubPtr != nullptr); + DistributedHardwareProxy dhProxy(dhStubPtr); + sptr listener(new MockHDSinkStatusListenerStub()); + auto ret = dhProxy.RegisterDHStatusListener(nullptr); + EXPECT_EQ(ERR_DH_FWK_STATUS_LISTENER_IS_NULL, ret); +} + HWTEST_F(DistributedHardwareProxyTest, UnregisterDHStatusListener_Sink_001, TestSize.Level1) { sptr dhStubPtr(new TestDistributedHardwareStub()); @@ -619,6 +661,16 @@ HWTEST_F(DistributedHardwareProxyTest, UnregisterDHStatusListener_Sink_001, Test EXPECT_EQ(ERR_DH_AVT_SERVICE_IPC_SEND_REQUEST_FAIL, ret); } +HWTEST_F(DistributedHardwareProxyTest, UnregisterDHStatusListener_Sink_002, TestSize.Level1) +{ + sptr dhStubPtr(new TestDistributedHardwareStub()); + ASSERT_TRUE(dhStubPtr != nullptr); + DistributedHardwareProxy dhProxy(dhStubPtr); + sptr listener(new MockHDSinkStatusListenerStub()); + auto ret = dhProxy.UnregisterDHStatusListener(nullptr); + EXPECT_EQ(ERR_DH_FWK_STATUS_LISTENER_IS_NULL, ret); +} + HWTEST_F(DistributedHardwareProxyTest, EnableSink_001, TestSize.Level1) { sptr dhStubPtr(new TestDistributedHardwareStub()); @@ -664,5 +716,39 @@ HWTEST_F(DistributedHardwareProxyTest, DisableSource_001, TestSize.Level1) auto ret = dhProxy.DisableSource(networkId, descriptors); EXPECT_EQ(ERR_DH_AVT_SERVICE_IPC_SEND_REQUEST_FAIL, ret); } + +HWTEST_F(DistributedHardwareProxyTest, LoadDistributedHDF_001, TestSize.Level1) +{ + sptr dhStubPtr(new TestDistributedHardwareStub()); + ASSERT_TRUE(dhStubPtr != nullptr); + DistributedHardwareProxy dhProxy(dhStubPtr); + + auto ret = dhProxy.LoadDistributedHDF(DHType::CAMERA); + EXPECT_EQ(ERR_DH_AVT_SERVICE_IPC_SEND_REQUEST_FAIL, ret); +} + +HWTEST_F(DistributedHardwareProxyTest, LoadDistributedHDF_002, TestSize.Level1) +{ + DistributedHardwareProxy dhProxy(nullptr); + auto ret = dhProxy.LoadDistributedHDF(DHType::CAMERA); + EXPECT_EQ(ERR_DH_AVT_SERVICE_REMOTE_IS_NULL, ret); +} + +HWTEST_F(DistributedHardwareProxyTest, UnLoadDistributedHDF_001, TestSize.Level1) +{ + sptr dhStubPtr(new TestDistributedHardwareStub()); + ASSERT_TRUE(dhStubPtr != nullptr); + DistributedHardwareProxy dhProxy(dhStubPtr); + + auto ret = dhProxy.UnLoadDistributedHDF(DHType::CAMERA); + EXPECT_EQ(ERR_DH_AVT_SERVICE_IPC_SEND_REQUEST_FAIL, ret); +} + +HWTEST_F(DistributedHardwareProxyTest, UnLoadDistributedHDF_002, TestSize.Level1) +{ + DistributedHardwareProxy dhProxy(nullptr); + auto ret = dhProxy.UnLoadDistributedHDF(DHType::CAMERA); + EXPECT_EQ(ERR_DH_AVT_SERVICE_REMOTE_IS_NULL, ret); +} } // namespace DistributedHardware } // namespace OHOS diff --git a/services/distributedhardwarefwkservice/BUILD.gn b/services/distributedhardwarefwkservice/BUILD.gn index a5ffe399..24531cb2 100644 --- a/services/distributedhardwarefwkservice/BUILD.gn +++ b/services/distributedhardwarefwkservice/BUILD.gn @@ -50,6 +50,7 @@ ohos_shared_library("distributedhardwarefwksvr") { "include/hidumphelper", "include/ipc", "include/lowlatency", + "include/hdfoperate", ] sources = [ @@ -72,6 +73,8 @@ ohos_shared_library("distributedhardwarefwksvr") { "src/distributed_hardware_manager_factory.cpp", "src/distributed_hardware_service.cpp", "src/distributed_hardware_stub.cpp", + "src/hdfoperate/daudio_hdf_operate.cpp", + "src/hdfoperate/dcamera_hdf_operate.cpp", "src/hidumphelper/enabled_comps_dump.cpp", "src/hidumphelper/hidump_helper.cpp", "src/ipc/get_dh_descriptors_callback_proxy.cpp", @@ -155,9 +158,14 @@ ohos_shared_library("distributedhardwarefwksvr") { "c_utils:utils", "config_policy:configpolicy_util", "device_manager:devicemanagersdk", + "drivers_interface_distributed_audio:libdaudioext_proxy_2.0", + "drivers_interface_distributed_camera:libdistributed_camera_provider_proxy_1.1", "dsoftbus:softbus_client", "eventhandler:libeventhandler", "ffrt:libffrt", + "hdf_core:libhdf_ipc_adapter", + "hdf_core:libhdi", + "hdf_core:libpub_utils", "hilog:libhilog", "hisysevent:libhisysevent", "hitrace:hitrace_meter", diff --git a/services/distributedhardwarefwkservice/include/componentmanager/component_manager.h b/services/distributedhardwarefwkservice/include/componentmanager/component_manager.h index d49d33a3..6f0de7ca 100644 --- a/services/distributedhardwarefwkservice/include/componentmanager/component_manager.h +++ b/services/distributedhardwarefwkservice/include/componentmanager/component_manager.h @@ -259,6 +259,7 @@ private: void RecoverAutoEnableSource(DHType dhType); void RecoverActiveEnableSink(DHType dhType); void RecoverActiveEnableSource(DHType dhType); + void ResetHdfLoadRefCount(DHType dhType); private: std::map compSource_; std::shared_mutex compSourceMutex_; diff --git a/services/distributedhardwarefwkservice/include/distributed_hardware_service.h b/services/distributedhardwarefwkservice/include/distributed_hardware_service.h index c5352615..840a09fe 100644 --- a/services/distributedhardwarefwkservice/include/distributed_hardware_service.h +++ b/services/distributedhardwarefwkservice/include/distributed_hardware_service.h @@ -62,6 +62,8 @@ public: int32_t DisableSink(const std::vector &descriptors) override; int32_t EnableSource(const std::string &networkId, const std::vector &descriptors) override; int32_t DisableSource(const std::string &networkId, const std::vector &descriptors) override; + int32_t LoadDistributedHDF(const DHType dhType) override; + int32_t UnLoadDistributedHDF(const DHType dhType) override; protected: void OnStart() override; diff --git a/services/distributedhardwarefwkservice/include/distributed_hardware_stub.h b/services/distributedhardwarefwkservice/include/distributed_hardware_stub.h index 4f3641d0..21a325bc 100644 --- a/services/distributedhardwarefwkservice/include/distributed_hardware_stub.h +++ b/services/distributedhardwarefwkservice/include/distributed_hardware_stub.h @@ -50,6 +50,8 @@ private: int32_t DisableSinkInner(MessageParcel &data, MessageParcel &reply); int32_t EnableSourceInner(MessageParcel &data, MessageParcel &reply); int32_t DisableSourceInner(MessageParcel &data, MessageParcel &reply); + int32_t LoadDistributedHDFInner(MessageParcel &data, MessageParcel &reply); + int32_t UnLoadDistributedHDFInner(MessageParcel &data, MessageParcel &reply); int32_t ReadDescriptors(MessageParcel &data, std::vector &descriptors); int32_t WriteDescriptors(MessageParcel &data, const std::vector &descriptors); diff --git a/services/distributedhardwarefwkservice/include/hdfoperate/daudio_hdf_operate.h b/services/distributedhardwarefwkservice/include/hdfoperate/daudio_hdf_operate.h new file mode 100644 index 00000000..fa51ef27 --- /dev/null +++ b/services/distributedhardwarefwkservice/include/hdfoperate/daudio_hdf_operate.h @@ -0,0 +1,93 @@ +/* + * 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. + */ + +#ifndef OHOS_DAUDIO_HDF_OPERATE_H +#define OHOS_DAUDIO_HDF_OPERATE_H + +#include +#include +#include + +#include "iservstat_listener_hdi.h" +#include "idevmgr_hdi.h" +#include "iservmgr_hdi.h" +#include "single_instance.h" +#include + +namespace OHOS { +namespace DistributedHardware { +const std::string AUDIO_SERVICE_NAME = "daudio_primary_service"; +const std::string AUDIOEXT_SERVICE_NAME = "daudio_ext_service"; +constexpr uint16_t AUDIO_INVALID_VALUE = 0xffff; +constexpr int32_t AUDIO_WAIT_TIME = 5000; +using OHOS::HDI::DeviceManager::V1_0::IDeviceManager; +using OHOS::HDI::ServiceManager::V1_0::IServiceManager; +using OHOS::HDI::ServiceManager::V1_0::IServStatListener; +using OHOS::HDI::ServiceManager::V1_0::ServiceStatus; +using OHOS::HDI::ServiceManager::V1_0::ServStatListenerStub; +using OHOS::HDI::DistributedAudio::Audioext::V2_0::IDAudioManager; +using OHOS::HDI::DistributedAudio::Audioext::V2_0::IDAudioHdfCallback; +using OHOS::HDI::DistributedAudio::Audioext::V2_0::DAudioEvent; + +class FwkDAudioHdfCallback; +class DaudioHdfOperate { +DECLARE_SINGLE_INSTANCE(DaudioHdfOperate); + +public: + int32_t LoadDaudioHDFImpl(); + int32_t UnLoadDaudioHDFImpl(); + void ResetRefCount(); + +private: + int32_t WaitLoadService(const std::string& servName); + OHOS::sptr MakeServStatListener(); + int32_t LoadDevice(); + int32_t UnLoadDevice(); + int32_t RegisterHdfListener(); + int32_t UnRegisterHdfListener(); + +private: + OHOS::sptr devmgr_; + OHOS::sptr servMgr_; + OHOS::sptr audioSrvHdf_; + 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_; +}; + +class DAudioHdfServStatListener : public OHOS::HDI::ServiceManager::V1_0::ServStatListenerStub { +public: + using StatusCallback = std::function; + explicit DAudioHdfServStatListener(StatusCallback callback) : callback_(std::move(callback)) + { + } + ~DAudioHdfServStatListener() override = default; + void OnReceive(const ServiceStatus& status) override; + +private: + StatusCallback callback_; +}; + +class FwkDAudioHdfCallback : public IDAudioHdfCallback { +protected: + int32_t NotifyEvent(int32_t devId, const DAudioEvent& event) override; +}; +} // namespace DistributedHardware +} // namespace OHOS +#endif // OHOS_DAUDIO_HDF_OPERATE_H \ No newline at end of file diff --git a/services/distributedhardwarefwkservice/include/hdfoperate/dcamera_hdf_operate.h b/services/distributedhardwarefwkservice/include/hdfoperate/dcamera_hdf_operate.h new file mode 100644 index 00000000..f7cf7099 --- /dev/null +++ b/services/distributedhardwarefwkservice/include/hdfoperate/dcamera_hdf_operate.h @@ -0,0 +1,91 @@ +/* + * 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. + */ + +#ifndef OHOS_DCAMERA_HDF_OPERATE_H +#define OHOS_DCAMERA_HDF_OPERATE_H + +#include +#include +#include + +#include "iservstat_listener_hdi.h" +#include "idevmgr_hdi.h" +#include "iservmgr_hdi.h" +#include "single_instance.h" +#include "v1_1/id_camera_provider.h" + +namespace OHOS { +namespace DistributedHardware { +using OHOS::HDI::DeviceManager::V1_0::IDeviceManager; +using OHOS::HDI::ServiceManager::V1_0::IServiceManager; +using OHOS::HDI::ServiceManager::V1_0::IServStatListener; +using OHOS::HDI::ServiceManager::V1_0::ServiceStatus; +using OHOS::HDI::ServiceManager::V1_0::ServStatListenerStub; +using OHOS::HDI::DistributedCamera::V1_1::IDCameraProvider; +using OHOS::HDI::DistributedCamera::V1_1::IDCameraHdfCallback; +using OHOS::HDI::DistributedCamera::V1_1::DCameraHDFEvent; +const std::string CAMERA_SERVICE_NAME = "distributed_camera_service"; +const std::string PROVIDER_SERVICE_NAME = "distributed_camera_provider_service"; +constexpr uint16_t CAMERA_INVALID_VALUE = 0xffff; +constexpr int32_t CAMERA_WAIT_TIME = 2000; + +class FwkDCameraHdfCallback; +class DCameraHdfOperate { +DECLARE_SINGLE_INSTANCE(DCameraHdfOperate); + +public: + int32_t LoadDcameraHDFImpl(); + int32_t UnLoadDcameraHDFImpl(); + void ResetRefCount(); + +private: + int32_t WaitLoadCameraService(); + int32_t WaitLoadProviderService(); + OHOS::sptr MakeServStatListener(); + int32_t LoadDevice(); + int32_t UnLoadDevice(); + int32_t RegisterHdfListener(); + int32_t UnRegisterHdfListener(); + +private: + OHOS::sptr fwkDCameraHdfCallback_; + std::atomic cameraServStatus_ = CAMERA_INVALID_VALUE; + std::atomic providerServStatus_ = CAMERA_INVALID_VALUE; + std::condition_variable hdfOperateCon_; + std::mutex hdfOperateMutex_; + int32_t hdfLoadRef_ = 0; + std::mutex hdfLoadRefMutex_; +}; + +class DCameraHdfServStatListener : public OHOS::HDI::ServiceManager::V1_0::ServStatListenerStub { +public: + using StatusCallback = std::function; + explicit DCameraHdfServStatListener(StatusCallback callback) : callback_(std::move(callback)) + { + } + ~DCameraHdfServStatListener() override = default; + void OnReceive(const ServiceStatus& status) override; + +private: + StatusCallback callback_; +}; + +class FwkDCameraHdfCallback : public IDCameraHdfCallback { +protected: + int32_t NotifyEvent(int32_t devId, const DCameraHDFEvent& event) override; +}; +} // namespace DistributedHardware +} // namespace OHOS +#endif // OHOS_DCAMERA_HDF_OPERATE_H \ No newline at end of file diff --git a/services/distributedhardwarefwkservice/src/componentmanager/component_manager.cpp b/services/distributedhardwarefwkservice/src/componentmanager/component_manager.cpp index 35b43d0a..bd3c139b 100644 --- a/services/distributedhardwarefwkservice/src/componentmanager/component_manager.cpp +++ b/services/distributedhardwarefwkservice/src/componentmanager/component_manager.cpp @@ -32,6 +32,8 @@ #include "component_enable.h" #include "component_loader.h" #include "constants.h" +#include "daudio_hdf_operate.h" +#include "dcamera_hdf_operate.h" #include "device_manager.h" #include "dh_context.h" #include "dh_data_sync_trigger_listener.h" @@ -620,6 +622,9 @@ void ComponentManager::DoRecover(DHType dhType) if (ret != DH_FWK_SUCCESS) { DHLOGE("DoRecover setname failed."); } + // reset hdf load status + DHLOGI("Reset HDF load ref for DHType %{public}" PRIu32, (uint32_t)dhType); + ResetHdfLoadRefCount(dhType); // reset enable status DHLOGI("Reset enable status for DHType %{public}" PRIu32, (uint32_t)dhType); ResetSinkEnableStatus(dhType); @@ -1681,6 +1686,20 @@ void ComponentManager::RecoverActiveEnableSource(DHType dhType) DHLOGI("RecoverActiveEnableSource end, dhType = %{public}#X.", dhType); } +void ComponentManager::ResetHdfLoadRefCount(DHType dhType) +{ + switch (dhType) { + case DHType::AUDIO: + DaudioHdfOperate::GetInstance().ResetRefCount(); + break; + case DHType::CAMERA: + DCameraHdfOperate::GetInstance().ResetRefCount(); + break; + default: + break; + } +} + int32_t ComponentManager::InitCompSource(DHType dhType) { std::unique_lock lock(compSourceMutex_); diff --git a/services/distributedhardwarefwkservice/src/distributed_hardware_service.cpp b/services/distributedhardwarefwkservice/src/distributed_hardware_service.cpp index bc63bfd3..afaa96bc 100644 --- a/services/distributedhardwarefwkservice/src/distributed_hardware_service.cpp +++ b/services/distributedhardwarefwkservice/src/distributed_hardware_service.cpp @@ -32,6 +32,8 @@ #include "capability_info_manager.h" #include "meta_info_manager.h" #include "component_manager.h" +#include "daudio_hdf_operate.h" +#include "dcamera_hdf_operate.h" #include "dh_context.h" #include "dh_utils_tool.h" #include "dh_utils_hisysevent.h" @@ -550,5 +552,31 @@ int32_t DistributedHardwareService::DisableSource( } return DH_FWK_SUCCESS; } + +int32_t DistributedHardwareService::LoadDistributedHDF(const DHType dhType) +{ + switch (dhType) { + case DHType::AUDIO: + return DaudioHdfOperate::GetInstance().LoadDaudioHDFImpl(); + case DHType::CAMERA: + return DCameraHdfOperate::GetInstance().LoadDcameraHDFImpl(); + default: + break; + } + return ERR_DH_FWK_NO_HDF_SUPPORT; +} + +int32_t DistributedHardwareService::UnLoadDistributedHDF(const DHType dhType) +{ + switch (dhType) { + case DHType::AUDIO: + return DaudioHdfOperate::GetInstance().UnLoadDaudioHDFImpl(); + case DHType::CAMERA: + return DCameraHdfOperate::GetInstance().UnLoadDcameraHDFImpl(); + default: + break; + } + return ERR_DH_FWK_NO_HDF_SUPPORT; +} } // namespace DistributedHardware } // namespace OHOS diff --git a/services/distributedhardwarefwkservice/src/distributed_hardware_stub.cpp b/services/distributedhardwarefwkservice/src/distributed_hardware_stub.cpp index 19c8d505..0aeed945 100644 --- a/services/distributedhardwarefwkservice/src/distributed_hardware_stub.cpp +++ b/services/distributedhardwarefwkservice/src/distributed_hardware_stub.cpp @@ -553,6 +553,36 @@ int32_t DistributedHardwareStub::DisableSourceInner(MessageParcel &data, Message return DH_FWK_SUCCESS; } +int32_t DistributedHardwareStub::LoadDistributedHDFInner(MessageParcel &data, MessageParcel &reply) +{ + if (!HasAccessDHPermission()) { + DHLOGE("The caller has no ACCESS_DISTRIBUTED_HARDWARE permission."); + return ERR_DH_FWK_ACCESS_PERMISSION_CHECK_FAIL; + } + DHType dhType = static_cast(data.ReadUint32()); + int32_t ret = LoadDistributedHDF(dhType); + if (!reply.WriteInt32(ret)) { + DHLOGE("Write ret code failed!"); + return ERR_DH_FWK_SERVICE_WRITE_INFO_FAIL; + } + return DH_FWK_SUCCESS; +} + +int32_t DistributedHardwareStub::UnLoadDistributedHDFInner(MessageParcel &data, MessageParcel &reply) +{ + if (!HasAccessDHPermission()) { + DHLOGE("The caller has no ACCESS_DISTRIBUTED_HARDWARE permission."); + return ERR_DH_FWK_ACCESS_PERMISSION_CHECK_FAIL; + } + DHType dhType = static_cast(data.ReadUint32()); + int32_t ret = UnLoadDistributedHDF(dhType); + if (!reply.WriteInt32(ret)) { + DHLOGE("Write ret code failed!"); + return ERR_DH_FWK_SERVICE_WRITE_INFO_FAIL; + } + return DH_FWK_SUCCESS; +} + int32_t DistributedHardwareStub::ReadDescriptors(MessageParcel &data, std::vector &descriptors) { int32_t size = data.ReadInt32(); @@ -635,6 +665,12 @@ int32_t DistributedHardwareStub::OnRemoteRequestEx(uint32_t code, MessageParcel case static_cast(DHMsgInterfaceCode::DISABLE_SOURCE): { return DisableSourceInner(data, reply); } + case static_cast(DHMsgInterfaceCode::LOAD_HDF): { + return LoadDistributedHDFInner(data, reply); + } + case static_cast(DHMsgInterfaceCode::UNLOAD_HDF): { + return UnLoadDistributedHDFInner(data, reply); + } default: return IPCObjectStub::OnRemoteRequest(code, data, reply, option); } diff --git a/services/distributedhardwarefwkservice/src/hdfoperate/daudio_hdf_operate.cpp b/services/distributedhardwarefwkservice/src/hdfoperate/daudio_hdf_operate.cpp new file mode 100644 index 00000000..3131d0f3 --- /dev/null +++ b/services/distributedhardwarefwkservice/src/hdfoperate/daudio_hdf_operate.cpp @@ -0,0 +1,258 @@ +/* + * 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 "daudio_hdf_operate.h" + +#include +#include + +#include "distributed_hardware_errno.h" +#include "distributed_hardware_log.h" + +#undef DH_LOG_TAG +#define DH_LOG_TAG "DaudioHdfOperate" + +namespace OHOS { +namespace DistributedHardware { +IMPLEMENT_SINGLE_INSTANCE(DaudioHdfOperate); +int32_t DaudioHdfOperate::LoadDaudioHDFImpl() +{ + 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_FWK_SUCCESS; + } + int32_t ret = LoadDevice(); + if (ret != DH_FWK_SUCCESS) { + DHLOGE("LoadDevice failed, ret: %{public}d.", ret); + return ret; + } + ret = RegisterHdfListener(); + if (ret != DH_FWK_SUCCESS) { + DHLOGE("RegisterHdfListener failed, ret: %{public}d.", ret); + UnLoadDevice(); + return ret; + } + hdfLoadRef_++; + DHLOGI("Load daudio hdf impl end!"); + return DH_FWK_SUCCESS; +} + +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_FWK_SUCCESS; + } + if (hdfLoadRef_ > 1) { + hdfLoadRef_--; + DHLOGI("The daudio hdf impl has been loaded, just dec ref!"); + return DH_FWK_SUCCESS; + } + int32_t ret = UnRegisterHdfListener(); + if (ret != DH_FWK_SUCCESS) { + DHLOGE("UnRegisterHdfListener failed, ret: %{public}d.", ret); + } + ret = UnLoadDevice(); + if (ret != DH_FWK_SUCCESS) { + DHLOGE("UnLoadDevice failed, ret: %{public}d.", ret); + } + hdfLoadRef_--; + DHLOGI("UnLoad daudio hdf impl end!"); + return DH_FWK_SUCCESS; +} + +void DaudioHdfOperate::ResetRefCount() +{ + DHLOGI("Reset reference count for daudio."); + std::unique_lock loadRefLocker(hdfLoadRefMutex_); + hdfLoadRef_ = 0; +} + +int32_t DaudioHdfOperate::WaitLoadService(const std::string& servName) +{ + std::unique_lock lock(hdfOperateMutex_); + if (servName == AUDIO_SERVICE_NAME) { + DHLOGD("WaitLoadService start service %s, status %hu", servName.c_str(), this->audioServStatus_.load()); + hdfOperateCon_.wait_for(lock, std::chrono::milliseconds(AUDIO_WAIT_TIME), [this] { + return (this->audioServStatus_.load() == OHOS::HDI::ServiceManager::V1_0::SERVIE_STATUS_START); + }); + + if (this->audioServStatus_.load() != OHOS::HDI::ServiceManager::V1_0::SERVIE_STATUS_START) { + DHLOGE("Wait load service %{public}s failed, status %{public}hu", servName.c_str(), + this->audioServStatus_.load()); + return ERR_DH_FWK_LOAD_HDF_TIMEOUT; + } + } + + if (servName == AUDIOEXT_SERVICE_NAME) { + DHLOGD("WaitLoadService start service %s, status %hu", servName.c_str(), this->audioextServStatus_.load()); + hdfOperateCon_.wait_for(lock, std::chrono::milliseconds(AUDIO_WAIT_TIME), [this] { + return (this->audioextServStatus_.load() == OHOS::HDI::ServiceManager::V1_0::SERVIE_STATUS_START); + }); + + if (this->audioextServStatus_.load() != OHOS::HDI::ServiceManager::V1_0::SERVIE_STATUS_START) { + DHLOGE("Wait load service %{public}s failed, status %{public}hu", servName.c_str(), + this->audioextServStatus_.load()); + return ERR_DH_FWK_LOAD_HDF_TIMEOUT; + } + } + return DH_FWK_SUCCESS; +} + +OHOS::sptr DaudioHdfOperate::MakeServStatListener() +{ + return OHOS::sptr( + new DAudioHdfServStatListener(DAudioHdfServStatListener::StatusCallback([&](const ServiceStatus& status) { + DHLOGI("Load audio service status callback, serviceName: %{public}s, status: %{public}d", + status.serviceName.c_str(), status.status); + std::unique_lock lock(hdfOperateMutex_); + if (status.serviceName == AUDIO_SERVICE_NAME) { + audioServStatus_.store(status.status); + hdfOperateCon_.notify_one(); + } else if (status.serviceName == AUDIOEXT_SERVICE_NAME) { + audioextServStatus_.store(status.status); + hdfOperateCon_.notify_one(); + } + })) + ); +} + +int32_t DaudioHdfOperate::LoadDevice() +{ + DHLOGI("LoadDevice for daudio begin!"); + servMgr_ = IServiceManager::Get(); + devmgr_ = IDeviceManager::Get(); + if (servMgr_ == nullptr || devmgr_ == nullptr) { + DHLOGE("get hdi service manager or device manager failed!"); + return ERR_DH_FWK_POINTER_IS_NULL; + } + OHOS::sptr listener = MakeServStatListener(); + if (servMgr_->RegisterServiceStatusListener(listener, DEVICE_CLASS_AUDIO) != HDF_SUCCESS) { + DHLOGE("Failed to register the service status listener."); + return ERR_DH_FWK_REGISTER_HDF_LISTENER_FAIL; + } + int32_t ret = devmgr_->LoadDevice(AUDIO_SERVICE_NAME); + if (ret != HDF_SUCCESS && ret != HDF_ERR_DEVICE_BUSY) { + DHLOGE("Load audio service failed!"); + servMgr_->UnregisterServiceStatusListener(listener); + return ERR_DH_FWK_LOAD_HDF_FAIL; + } + if (WaitLoadService(AUDIO_SERVICE_NAME) != DH_FWK_SUCCESS) { + DHLOGE("Wait load audio service failed!"); + servMgr_->UnregisterServiceStatusListener(listener); + return ERR_DH_FWK_LOAD_HDF_TIMEOUT; + } + ret = devmgr_->LoadDevice(AUDIOEXT_SERVICE_NAME); + if (ret != HDF_SUCCESS && ret != HDF_ERR_DEVICE_BUSY) { + DHLOGE("Load audio provider service failed!"); + devmgr_->UnloadDevice(AUDIO_SERVICE_NAME); + servMgr_->UnregisterServiceStatusListener(listener); + return ERR_DH_FWK_LOAD_HDF_FAIL; + } + if (WaitLoadService(AUDIOEXT_SERVICE_NAME) != DH_FWK_SUCCESS) { + DHLOGE("Wait load audio provider service failed!"); + devmgr_->UnloadDevice(AUDIO_SERVICE_NAME); + servMgr_->UnregisterServiceStatusListener(listener); + return ERR_DH_FWK_LOAD_HDF_TIMEOUT; + } + if (servMgr_->UnregisterServiceStatusListener(listener) != HDF_SUCCESS) { + DHLOGE("Failed to unregister the service status listener."); + } + DHLOGI("LoadDevice for daudio end!"); + return DH_FWK_SUCCESS; +} + +int32_t DaudioHdfOperate::UnLoadDevice() +{ + DHLOGI("UnLoadDevice for daudio begin!"); + if (devmgr_ == nullptr) { + DHLOGE("hdi device manager is nullptr!"); + return ERR_DH_FWK_POINTER_IS_NULL; + } + int32_t ret = devmgr_->UnloadDevice(AUDIO_SERVICE_NAME); + if (ret != HDF_SUCCESS) { + DHLOGE("Unload audio service failed, ret: %{public}d", ret); + } + ret = devmgr_->UnloadDevice(AUDIOEXT_SERVICE_NAME); + if (ret != HDF_SUCCESS) { + DHLOGE("Unload device failed, ret: %{public}d", ret); + } + audioServStatus_.store(AUDIO_INVALID_VALUE); + audioextServStatus_.store(AUDIO_INVALID_VALUE); + DHLOGI("UnLoadDevice for daudio end!"); + return DH_FWK_SUCCESS; +} + +int32_t DaudioHdfOperate::RegisterHdfListener() +{ + DHLOGI("RegisterHdfListener for daudio begin!"); + audioSrvHdf_ = IDAudioManager::Get(AUDIOEXT_SERVICE_NAME.c_str(), false); + if (audioSrvHdf_ == nullptr) { + DHLOGE("Get hdi daudio manager failed."); + return ERR_DH_FWK_POINTER_IS_NULL; + } + if (fwkDAudioHdfCallback_ == nullptr) { + fwkDAudioHdfCallback_ = new FwkDAudioHdfCallback(); + if (fwkDAudioHdfCallback_ == nullptr) { + DHLOGE("Create FwkDAudioHdfCallback failed."); + return ERR_DH_FWK_POINTER_IS_NULL; + } + } + int32_t ret = audioSrvHdf_->RegisterAudioHdfListener("DHFWK", fwkDAudioHdfCallback_); + if (ret != DH_FWK_SUCCESS) { + DHLOGE("Call hdf proxy RegisterAudioHdfListener failed, ret: %{public}d.", ret); + return ret; + } + DHLOGI("RegisterHdfListener for daudio end!"); + return DH_FWK_SUCCESS; +} + +int32_t DaudioHdfOperate::UnRegisterHdfListener() +{ + DHLOGI("UnRegisterHdfListener for daudio begin!"); + if (audioSrvHdf_ == nullptr) { + DHLOGE("hdi daudio manager is nullptr!"); + return ERR_DH_FWK_POINTER_IS_NULL; + } + int32_t ret = audioSrvHdf_->UnRegisterAudioHdfListener("DHFWK"); + if (ret != DH_FWK_SUCCESS) { + DHLOGE("Call hdf proxy UnRegisterAudioHdfListener failed, ret: %{public}d.", ret); + return ret; + } + DHLOGI("UnRegisterHdfListener for daudio end!"); + return DH_FWK_SUCCESS; +} + +void DAudioHdfServStatListener::OnReceive(const ServiceStatus& status) +{ + DHLOGI("Service status on receive."); + if (status.serviceName == AUDIO_SERVICE_NAME || status.serviceName == AUDIOEXT_SERVICE_NAME) { + callback_(status); + } +} + +int32_t FwkDAudioHdfCallback::NotifyEvent(int32_t devId, const DAudioEvent& event) +{ + (void)devId; + (void)event; + return DH_FWK_SUCCESS; +} +} // namespace DistributedHardware +} // namespace OHOS \ No newline at end of file diff --git a/services/distributedhardwarefwkservice/src/hdfoperate/dcamera_hdf_operate.cpp b/services/distributedhardwarefwkservice/src/hdfoperate/dcamera_hdf_operate.cpp new file mode 100644 index 00000000..fc190e65 --- /dev/null +++ b/services/distributedhardwarefwkservice/src/hdfoperate/dcamera_hdf_operate.cpp @@ -0,0 +1,259 @@ +/* + * 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 "dcamera_hdf_operate.h" + +#include +#include + +#include "anonymous_string.h" +#include "distributed_hardware_errno.h" +#include "distributed_hardware_log.h" + +#undef DH_LOG_TAG +#define DH_LOG_TAG "DCameraHdfOperate" + +namespace OHOS { +namespace DistributedHardware { +IMPLEMENT_SINGLE_INSTANCE(DCameraHdfOperate); +int32_t DCameraHdfOperate::LoadDcameraHDFImpl() +{ + DHLOGI("Load camera hdf impl begin!"); + std::unique_lock loadRefLocker(hdfLoadRefMutex_); + if (hdfLoadRef_ > 0) { + hdfLoadRef_++; + DHLOGI("The camera hdf impl has been loaded, just inc ref!"); + return DH_FWK_SUCCESS; + } + int32_t ret = LoadDevice(); + if (ret != DH_FWK_SUCCESS) { + DHLOGE("LoadDevice failed, ret: %{public}d.", ret); + return ret; + } + ret = RegisterHdfListener(); + if (ret != DH_FWK_SUCCESS) { + DHLOGE("RegisterHdfListener failed, ret: %{public}d.", ret); + UnLoadDevice(); + return ret; + } + hdfLoadRef_++; + DHLOGI("Load camera hdf impl end!"); + return DH_FWK_SUCCESS; +} + +int32_t DCameraHdfOperate::UnLoadDcameraHDFImpl() +{ + DHLOGI("UnLoad camera hdf impl begin!"); + std::unique_lock loadRefLocker(hdfLoadRefMutex_); + if (hdfLoadRef_ == 0) { + DHLOGI("The camera hdf impl has been unloaded!"); + return DH_FWK_SUCCESS; + } + if (hdfLoadRef_ > 1) { + hdfLoadRef_--; + DHLOGI("The camera hdf impl has been loaded, just dec ref!"); + return DH_FWK_SUCCESS; + } + int32_t ret = UnRegisterHdfListener(); + if (ret != DH_FWK_SUCCESS) { + DHLOGE("UnRegisterHdfListener failed, ret: %{public}d.", ret); + } + ret = UnLoadDevice(); + if (ret != DH_FWK_SUCCESS) { + DHLOGE("UnLoadDevice failed, ret: %{public}d.", ret); + } + hdfLoadRef_--; + DHLOGI("UnLoad camera hdf impl end!"); + return DH_FWK_SUCCESS; +} + +void DCameraHdfOperate::ResetRefCount() +{ + DHLOGI("Reset reference count for dcamera."); + std::unique_lock loadRefLocker(hdfLoadRefMutex_); + hdfLoadRef_ = 0; +} + +int32_t DCameraHdfOperate::WaitLoadCameraService() +{ + DHLOGI("wait Load camera service."); + std::unique_lock lock(hdfOperateMutex_); + hdfOperateCon_.wait_for(lock, std::chrono::milliseconds(CAMERA_WAIT_TIME), [this] { + return (this->cameraServStatus_.load() == OHOS::HDI::ServiceManager::V1_0::SERVIE_STATUS_START); + }); + if (cameraServStatus_.load() != OHOS::HDI::ServiceManager::V1_0::SERVIE_STATUS_START) { + DHLOGE("wait load cameraService failed, status %{public}d", cameraServStatus_.load()); + return ERR_DH_FWK_LOAD_HDF_TIMEOUT; + } + return DH_FWK_SUCCESS; +} + +int32_t DCameraHdfOperate::WaitLoadProviderService() +{ + DHLOGI("wait Load provider service."); + std::unique_lock lock(hdfOperateMutex_); + hdfOperateCon_.wait_for(lock, std::chrono::milliseconds(CAMERA_WAIT_TIME), [this] { + return (this->providerServStatus_.load() == OHOS::HDI::ServiceManager::V1_0::SERVIE_STATUS_START); + }); + if (providerServStatus_.load() != OHOS::HDI::ServiceManager::V1_0::SERVIE_STATUS_START) { + DHLOGE("wait load providerService failed, status %{public}d", providerServStatus_.load()); + return ERR_DH_FWK_LOAD_HDF_TIMEOUT; + } + return DH_FWK_SUCCESS; +} + +OHOS::sptr DCameraHdfOperate::MakeServStatListener() +{ + return OHOS::sptr( + new DCameraHdfServStatListener(DCameraHdfServStatListener::StatusCallback([&](const ServiceStatus& status) { + DHLOGI("LoadCameraService service status callback, serviceName: %{public}s, status: %{public}d", + status.serviceName.c_str(), status.status); + std::unique_lock lock(hdfOperateMutex_); + if (status.serviceName == CAMERA_SERVICE_NAME) { + cameraServStatus_.store(status.status); + hdfOperateCon_.notify_one(); + } else if (status.serviceName == PROVIDER_SERVICE_NAME) { + providerServStatus_.store(status.status); + hdfOperateCon_.notify_one(); + } + })) + ); +} + +int32_t DCameraHdfOperate::LoadDevice() +{ + DHLOGI("LoadDevice for camera begin!"); + OHOS::sptr servMgr = IServiceManager::Get(); + OHOS::sptr devmgr = IDeviceManager::Get(); + if (servMgr == nullptr || devmgr == nullptr) { + DHLOGE("get hdi service manager or device manager failed!"); + return ERR_DH_FWK_POINTER_IS_NULL; + } + OHOS::sptr listener = MakeServStatListener(); + if (servMgr->RegisterServiceStatusListener(listener, DEVICE_CLASS_CAMERA) != 0) { + DHLOGE("RegisterServiceStatusListener failed!"); + return ERR_DH_FWK_REGISTER_HDF_LISTENER_FAIL; + } + DHLOGI("Load camera service."); + int32_t ret = devmgr->LoadDevice(CAMERA_SERVICE_NAME); + if (ret != HDF_SUCCESS && ret != HDF_ERR_DEVICE_BUSY) { + DHLOGE("Load camera service failed!"); + servMgr->UnregisterServiceStatusListener(listener); + return ERR_DH_FWK_LOAD_HDF_FAIL; + } + if (WaitLoadCameraService() != DH_FWK_SUCCESS) { + DHLOGE("Wait load camera service failed!"); + servMgr->UnregisterServiceStatusListener(listener); + return ERR_DH_FWK_LOAD_HDF_TIMEOUT; + } + ret = devmgr->LoadDevice(PROVIDER_SERVICE_NAME); + if (ret != HDF_SUCCESS && ret != HDF_ERR_DEVICE_BUSY) { + DHLOGE("Load camera provider service failed!"); + devmgr->UnloadDevice(CAMERA_SERVICE_NAME); + servMgr->UnregisterServiceStatusListener(listener); + return ERR_DH_FWK_LOAD_HDF_FAIL; + } + if (WaitLoadProviderService() != DH_FWK_SUCCESS) { + DHLOGE("Wait load camera provider service failed!"); + devmgr->UnloadDevice(CAMERA_SERVICE_NAME); + servMgr->UnregisterServiceStatusListener(listener); + return ERR_DH_FWK_LOAD_HDF_TIMEOUT; + } + if (servMgr->UnregisterServiceStatusListener(listener) != 0) { + DHLOGE("UnregisterServiceStatusListener failed!"); + } + DHLOGI("LoadDevice for camera end!"); + return DH_FWK_SUCCESS; +} + +int32_t DCameraHdfOperate::UnLoadDevice() +{ + DHLOGI("UnLoadDevice for camera begin!"); + OHOS::sptr devmgr = IDeviceManager::Get(); + if (devmgr == nullptr) { + DHLOGE("get hdi device manager failed!"); + return ERR_DH_FWK_POINTER_IS_NULL; + } + int32_t ret = devmgr->UnloadDevice(CAMERA_SERVICE_NAME); + if (ret != 0) { + DHLOGE("Unload camera service failed, ret: %{public}d", ret); + } + ret = devmgr->UnloadDevice(PROVIDER_SERVICE_NAME); + if (ret != 0) { + DHLOGE("Unload provider service failed, ret: %d", ret); + } + cameraServStatus_.store(CAMERA_INVALID_VALUE); + providerServStatus_.store(CAMERA_INVALID_VALUE); + DHLOGI("UnLoadDevice for camera end!"); + return DH_FWK_SUCCESS; +} + +int32_t DCameraHdfOperate::RegisterHdfListener() +{ + DHLOGI("RegisterHdfListener for camera begin!"); + sptr camHdiProvider = IDCameraProvider::Get(PROVIDER_SERVICE_NAME); + if (camHdiProvider == nullptr) { + DHLOGE("Get hdi camera provider failed."); + return ERR_DH_FWK_POINTER_IS_NULL; + } + if (fwkDCameraHdfCallback_ == nullptr) { + fwkDCameraHdfCallback_ = new FwkDCameraHdfCallback(); + if (fwkDCameraHdfCallback_ == nullptr) { + DHLOGE("Create FwkDCameraHdfCallback failed."); + return ERR_DH_FWK_POINTER_IS_NULL; + } + } + int32_t ret = camHdiProvider->RegisterCameraHdfListener("DHFWK", fwkDCameraHdfCallback_); + if (ret != DH_FWK_SUCCESS) { + DHLOGE("Call hdf proxy RegisterCameraHdfListener failed, ret: %{public}d.", ret); + return ret; + } + DHLOGI("RegisterHdfListener for camera end!"); + return DH_FWK_SUCCESS; +} + +int32_t DCameraHdfOperate::UnRegisterHdfListener() +{ + DHLOGI("UnRegisterHdfListener for camera begin!"); + sptr camHdiProvider = IDCameraProvider::Get(PROVIDER_SERVICE_NAME); + if (camHdiProvider == nullptr) { + DHLOGE("Get hdi camera provider failed."); + return ERR_DH_FWK_POINTER_IS_NULL; + } + int32_t ret = camHdiProvider->UnRegisterCameraHdfListener("DHFWK"); + if (ret != DH_FWK_SUCCESS) { + DHLOGE("Call hdf proxy UnRegisterCameraHdfListener failed, ret: %{public}d.", ret); + return ret; + } + DHLOGI("UnRegisterHdfListener for camera end!"); + return DH_FWK_SUCCESS; +} + +void DCameraHdfServStatListener::OnReceive(const ServiceStatus& status) +{ + DHLOGI("service status on receive"); + if (status.serviceName == CAMERA_SERVICE_NAME || status.serviceName == PROVIDER_SERVICE_NAME) { + callback_(status); + } +} + +int32_t FwkDCameraHdfCallback::NotifyEvent(int32_t devId, const DCameraHDFEvent& event) +{ + (void)devId; + (void)event; + return DH_FWK_SUCCESS; +} +} // namespace DistributedHardware +} // namespace OHOS diff --git a/services/distributedhardwarefwkservice/test/unittest/BUILD.gn b/services/distributedhardwarefwkservice/test/unittest/BUILD.gn index d179b82b..0f9c8e04 100644 --- a/services/distributedhardwarefwkservice/test/unittest/BUILD.gn +++ b/services/distributedhardwarefwkservice/test/unittest/BUILD.gn @@ -25,6 +25,7 @@ group("test") { "common/distributedhardwaremanager:distributed_hardware_manager_test", "common/distributedhardwareservice:distributed_hardware_service_test", "common/distributedhardwarestub:distributed_hardware_stub_test", + "common/hdfoperate:hdf_operate_test", "common/hidumphelper/enabledcompsdump:enabled_comps_dump_test", "common/hidumphelper/hidumphelper:hidump_helper_test", "common/ipc:publisher_listener_proxy_test", diff --git a/services/distributedhardwarefwkservice/test/unittest/common/componentmanager/component_manager/src/component_manager_test.cpp b/services/distributedhardwarefwkservice/test/unittest/common/componentmanager/component_manager/src/component_manager_test.cpp index ff606ed9..b3b29513 100644 --- a/services/distributedhardwarefwkservice/test/unittest/common/componentmanager/component_manager/src/component_manager_test.cpp +++ b/services/distributedhardwarefwkservice/test/unittest/common/componentmanager/component_manager/src/component_manager_test.cpp @@ -922,8 +922,9 @@ HWTEST_F(ComponentManagerTest, Recover_001, TestSize.Level1) */ HWTEST_F(ComponentManagerTest, DoRecover_001, TestSize.Level1) { - DHType dhType = DHType::CAMERA; - ComponentManager::GetInstance().DoRecover(dhType); + ComponentManager::GetInstance().DoRecover(DHType::UNKNOWN); + ComponentManager::GetInstance().DoRecover(DHType::AUDIO); + ComponentManager::GetInstance().DoRecover(DHType::CAMERA); EXPECT_EQ(true, ComponentManager::GetInstance().compSource_.empty()); } diff --git a/services/distributedhardwarefwkservice/test/unittest/common/distributedhardwareservice/src/distributed_hardware_service_test.cpp b/services/distributedhardwarefwkservice/test/unittest/common/distributedhardwareservice/src/distributed_hardware_service_test.cpp index 1e67bb28..21f69838 100644 --- a/services/distributedhardwarefwkservice/test/unittest/common/distributedhardwareservice/src/distributed_hardware_service_test.cpp +++ b/services/distributedhardwarefwkservice/test/unittest/common/distributedhardwareservice/src/distributed_hardware_service_test.cpp @@ -531,5 +531,20 @@ HWTEST_F(DistributedHardwareServiceTest, QueryDhSysSpec_002, TestSize.Level1) cJSON_free(cjson1); cJSON_Delete(attrJson1); } + +HWTEST_F(DistributedHardwareServiceTest, LoadDistributedHDF_001, TestSize.Level1) +{ + DistributedHardwareService service(ASID, true); + EXPECT_EQ(DH_FWK_SUCCESS, service.LoadDistributedHDF(DHType::AUDIO)); + EXPECT_EQ(DH_FWK_SUCCESS, service.LoadDistributedHDF(DHType::AUDIO)); + EXPECT_EQ(DH_FWK_SUCCESS, service.LoadDistributedHDF(DHType::CAMERA)); + EXPECT_EQ(DH_FWK_SUCCESS, service.LoadDistributedHDF(DHType::CAMERA)); + EXPECT_EQ(ERR_DH_FWK_NO_HDF_SUPPORT, service.LoadDistributedHDF(DHType::UNKNOWN)); + EXPECT_EQ(DH_FWK_SUCCESS, service.UnLoadDistributedHDF(DHType::AUDIO)); + EXPECT_EQ(DH_FWK_SUCCESS, service.UnLoadDistributedHDF(DHType::AUDIO)); + EXPECT_EQ(DH_FWK_SUCCESS, service.UnLoadDistributedHDF(DHType::CAMERA)); + EXPECT_EQ(DH_FWK_SUCCESS, service.UnLoadDistributedHDF(DHType::CAMERA)); + EXPECT_EQ(ERR_DH_FWK_NO_HDF_SUPPORT, service.UnLoadDistributedHDF(DHType::UNKNOWN)); +} } // namespace DistributedHardware } // namespace OHOS diff --git a/services/distributedhardwarefwkservice/test/unittest/common/distributedhardwarestub/include/distributed_hardware_stub_test.h b/services/distributedhardwarefwkservice/test/unittest/common/distributedhardwarestub/include/distributed_hardware_stub_test.h index 9e6d4975..0f84636a 100644 --- a/services/distributedhardwarefwkservice/test/unittest/common/distributedhardwarestub/include/distributed_hardware_stub_test.h +++ b/services/distributedhardwarefwkservice/test/unittest/common/distributedhardwarestub/include/distributed_hardware_stub_test.h @@ -185,6 +185,18 @@ int32_t DisableSource(const std::string &networkId, const std::vector { diff --git a/services/distributedhardwarefwkservice/test/unittest/common/distributedhardwarestub/src/distributed_hardware_stub_test.cpp b/services/distributedhardwarefwkservice/test/unittest/common/distributedhardwarestub/src/distributed_hardware_stub_test.cpp index 4e39062c..e8096830 100644 --- a/services/distributedhardwarefwkservice/test/unittest/common/distributedhardwarestub/src/distributed_hardware_stub_test.cpp +++ b/services/distributedhardwarefwkservice/test/unittest/common/distributedhardwarestub/src/distributed_hardware_stub_test.cpp @@ -690,5 +690,37 @@ HWTEST_F(DistributedHardwareStubTest, ValidQueryLocalSpec_002, TestSize.Level1) spec = 5; EXPECT_EQ(false, stubTest_->ValidQueryLocalSpec(spec)); } + +/** + * @tc.name: LoadDistributedHDFInner_001 + * @tc.desc: Verify the LoadDistributedHDFInner function + * @tc.type: FUNC + * @tc.require: AR000GHSJM + */ +HWTEST_F(DistributedHardwareStubTest, LoadDistributedHDFInner_001, TestSize.Level1) +{ + ASSERT_TRUE(stubTest_ != nullptr); + ASSERT_TRUE(token_ != nullptr); + EXPECT_CALL(*token_, VerifyAccessToken(_, _)).WillRepeatedly(Return(PERMISSION_GRANTED)); + MessageParcel data; + MessageParcel reply; + EXPECT_EQ(DH_FWK_SUCCESS, stubTest_->LoadDistributedHDFInner(data, reply)); +} + +/** + * @tc.name: UnLoadDistributedHDFInner_001 + * @tc.desc: Verify the UnLoadDistributedHDFInner function + * @tc.type: FUNC + * @tc.require: AR000GHSJM + */ +HWTEST_F(DistributedHardwareStubTest, UnLoadDistributedHDFInner_001, TestSize.Level1) +{ + ASSERT_TRUE(stubTest_ != nullptr); + ASSERT_TRUE(token_ != nullptr); + EXPECT_CALL(*token_, VerifyAccessToken(_, _)).WillRepeatedly(Return(PERMISSION_GRANTED)); + MessageParcel data; + MessageParcel reply; + EXPECT_EQ(DH_FWK_SUCCESS, stubTest_->UnLoadDistributedHDFInner(data, reply)); +} } // namespace DistributedHardware } // namespace OHOS diff --git a/services/distributedhardwarefwkservice/test/unittest/common/hdfoperate/BUILD.gn b/services/distributedhardwarefwkservice/test/unittest/common/hdfoperate/BUILD.gn new file mode 100644 index 00000000..9c6564d8 --- /dev/null +++ b/services/distributedhardwarefwkservice/test/unittest/common/hdfoperate/BUILD.gn @@ -0,0 +1,128 @@ +# 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. + +import("//build/test.gni") +import("../../../../../../distributedhardwarefwk.gni") + +module_out_path = unittest_output_path + +config("module_private_config") { + visibility = [ ":*" ] + include_dirs = [ + "${av_trans_path}/common/include", + "${innerkits_path}/include", + "${utils_path}/include", + "${utils_path}/include/log", + "${utils_path}/include/eventbus", + "${common_path}/log/include", + "${common_path}/utils/include", + "${services_path}/distributedhardwarefwkservice/include", + "${services_path}/distributedhardwarefwkservice/include/hdfoperate", + ] +} + +ohos_unittest("DaudioHdfOperateTest") { + module_out_path = module_out_path + + sources = [ + "daudio_hdf_operate_test.cpp", + "mock_hdfoperate_device_manager.cpp" + ] + + configs = [ ":module_private_config" ] + + deps = [ + "${services_path}/distributedhardwarefwkservice:distributedhardwarefwksvr", + ] + + cflags = [ + "-Wall", + "-Werror", + "-g3", + "-Dprivate=public", + ] + + defines = [ + "HI_LOG_ENABLE", + "DH_LOG_TAG=\"DaudioHdfOperateTest\"", + "LOG_DOMAIN=0xD004100", + ] + + external_deps = [ + "cJSON:cjson", + "c_utils:utils", + "device_manager:devicemanagersdk", + "drivers_interface_distributed_audio:libdaudioext_proxy_2.0", + "eventhandler:libeventhandler", + "googletest:gmock", + "googletest:gmock_main", + "hdf_core:libhdf_ipc_adapter", + "hdf_core:libhdi", + "hdf_core:libpub_utils", + "hilog:libhilog", + "ipc:ipc_core", + "safwk:system_ability_fwk", + ] +} + +ohos_unittest("DcameraHdfOperateTest") { + module_out_path = module_out_path + + sources = [ + "dcamera_hdf_operate_test.cpp", + "mock_hdfoperate_device_manager.cpp" + ] + + configs = [ ":module_private_config" ] + + deps = [ + "${services_path}/distributedhardwarefwkservice:distributedhardwarefwksvr", + ] + + cflags = [ + "-Wall", + "-Werror", + "-g3", + "-Dprivate=public", + ] + + defines = [ + "HI_LOG_ENABLE", + "DH_LOG_TAG=\"DcameraHdfOperateTest\"", + "LOG_DOMAIN=0xD004100", + ] + + external_deps = [ + "cJSON:cjson", + "c_utils:utils", + "device_manager:devicemanagersdk", + "drivers_interface_distributed_camera:libdistributed_camera_provider_proxy_1.1", + "eventhandler:libeventhandler", + "googletest:gmock", + "googletest:gmock_main", + "hdf_core:libhdf_ipc_adapter", + "hdf_core:libhdi", + "hdf_core:libpub_utils", + "hilog:libhilog", + "ipc:ipc_core", + "safwk:system_ability_fwk", + ] +} + +group("hdf_operate_test") { + testonly = true + deps = [ + ":DaudioHdfOperateTest", + ":DcameraHdfOperateTest", + ] +} diff --git a/services/distributedhardwarefwkservice/test/unittest/common/hdfoperate/daudio_hdf_operate_test.cpp b/services/distributedhardwarefwkservice/test/unittest/common/hdfoperate/daudio_hdf_operate_test.cpp new file mode 100644 index 00000000..f76f6610 --- /dev/null +++ b/services/distributedhardwarefwkservice/test/unittest/common/hdfoperate/daudio_hdf_operate_test.cpp @@ -0,0 +1,213 @@ +/* + * 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_hdf_operate.h" +#include "distributed_hardware_errno.h" +#include "distributed_hardware_log.h" +#include "mock_hdfoperate_device_manager.h" + +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::GetOrCtreateInstance(); +} + +void DAudioHdfOperateTest::TearDown(void) +{ + DHLOGI("DAudioHdfOperateTest::TearDown"); + deviceManager_ = nullptr; +} + +/** + * @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_FWK_SUCCESS, ret); +} + +/** + * @tc.name: ResetRefCount_001 + * @tc.desc: Verify ResetRefCount func + * @tc.type: FUNC + * @tc.require: AR000GHSJM + */ +HWTEST_F(DAudioHdfOperateTest, ResetRefCount_001, TestSize.Level1) +{ + DHLOGI("DAudioHdfOperateTest::ResetRefCount_001"); + DaudioHdfOperate::GetInstance().hdfLoadRef_ = 1; + DaudioHdfOperate::GetInstance().ResetRefCount(); + EXPECT_EQ(DaudioHdfOperate::GetInstance().hdfLoadRef_, 0); +} + +/** + * @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_STOP); + int32_t ret = DaudioHdfOperate::GetInstance().WaitLoadService(AUDIO_SERVICE_NAME); + EXPECT_EQ(ERR_DH_FWK_LOAD_HDF_TIMEOUT, 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_STOP); + int32_t ret = DaudioHdfOperate::GetInstance().WaitLoadService(AUDIOEXT_SERVICE_NAME); + EXPECT_EQ(ERR_DH_FWK_LOAD_HDF_TIMEOUT, 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_FWK_LOAD_HDF_TIMEOUT, ret); + EXPECT_CALL(*deviceManager_, LoadDevice(_)).WillRepeatedly(testing::Return(ERR_DH_FWK_LOAD_HDF_FAIL)); + ret = DaudioHdfOperate::GetInstance().LoadDevice(); + EXPECT_EQ(ERR_DH_FWK_LOAD_HDF_FAIL, 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_ = OHOS::HDI::ServiceManager::V1_0::SERVIE_STATUS_START; + int32_t ret = DaudioHdfOperate::GetInstance().LoadDevice(); + EXPECT_EQ(ERR_DH_FWK_LOAD_HDF_TIMEOUT, ret); + isFirstTime = true; + EXPECT_CALL(*deviceManager_, LoadDevice(_)).WillRepeatedly([&]()->int32_t { + if (isFirstTime) { + isFirstTime = false; + return HDF_SUCCESS; + } else { + return ERR_DH_FWK_LOAD_HDF_FAIL; + } + }); + ret = DaudioHdfOperate::GetInstance().LoadDevice(); + EXPECT_EQ(ERR_DH_FWK_LOAD_HDF_FAIL, 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_FWK_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_FWK_POINTER_IS_NULL, 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_FWK_POINTER_IS_NULL, ret); +} +} // namespace DistributedHardware +} // namespace OHOS diff --git a/services/distributedhardwarefwkservice/test/unittest/common/hdfoperate/dcamera_hdf_operate_test.cpp b/services/distributedhardwarefwkservice/test/unittest/common/hdfoperate/dcamera_hdf_operate_test.cpp new file mode 100644 index 00000000..4c18dc64 --- /dev/null +++ b/services/distributedhardwarefwkservice/test/unittest/common/hdfoperate/dcamera_hdf_operate_test.cpp @@ -0,0 +1,180 @@ +/* + * 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 "dcamera_hdf_operate.h" +#include "distributed_hardware_errno.h" +#include "distributed_hardware_log.h" +#include "mock_hdfoperate_device_manager.h" + +using namespace testing; +using namespace testing::ext; + +namespace OHOS { +namespace DistributedHardware { +class DCameraHdfOperateTest : public testing::Test { +public: + static void SetUpTestCase(void); + static void TearDownTestCase(void); + void SetUp(); + void TearDown(); +private: + sptr deviceManager_; +}; + +void DCameraHdfOperateTest::SetUpTestCase(void) +{ + DHLOGI("DCameraHdfOperateTest::SetUpTestCase"); +} + +void DCameraHdfOperateTest::TearDownTestCase(void) +{ + DHLOGI("DCameraHdfOperateTest::TearDownTestCase"); +} + +void DCameraHdfOperateTest::SetUp(void) +{ + DHLOGI("DCameraHdfOperateTest::SetUp"); + deviceManager_ = MockDeviceManager::GetOrCtreateInstance(); +} + +void DCameraHdfOperateTest::TearDown(void) +{ + DHLOGI("DCameraHdfOperateTest::TearDown"); + deviceManager_ = nullptr; +} + +/** + * @tc.name: UnLoadDcameraHDFImpl_001 + * @tc.desc: Verify UnLoadDcameraHDFImpl func + * @tc.type: FUNC + * @tc.require: AR000GHSJM + */ +HWTEST_F(DCameraHdfOperateTest, UnLoadDcameraHDFImpl_001, TestSize.Level1) +{ + DHLOGI("DCameraHdfOperateTest::UnLoadDcameraHDFImpl_001"); + int32_t ret = DCameraHdfOperate::GetInstance().UnLoadDcameraHDFImpl(); + EXPECT_EQ(DH_FWK_SUCCESS, ret); +} + +/** + * @tc.name: ResetRefCount_001 + * @tc.desc: Verify ResetRefCount func + * @tc.type: FUNC + * @tc.require: AR000GHSJM + */ +HWTEST_F(DCameraHdfOperateTest, ResetRefCount_001, TestSize.Level1) +{ + DHLOGI("DCameraHdfOperateTest::ResetRefCount_001"); + DCameraHdfOperate::GetInstance().hdfLoadRef_ = 1; + DCameraHdfOperate::GetInstance().ResetRefCount(); + EXPECT_EQ(DCameraHdfOperate::GetInstance().hdfLoadRef_, 0); +} + +/** + * @tc.name: WaitLoadCameraService_001 + * @tc.desc: Verify WaitLoadCameraService func. + * @tc.type: FUNC + * @tc.require: AR000GHSJM + */ +HWTEST_F(DCameraHdfOperateTest, WaitLoadCameraService_001, TestSize.Level1) +{ + DHLOGI("DCameraHdfOperateTest::WaitLoadCameraService_001"); + DCameraHdfOperate::GetInstance().cameraServStatus_.store(OHOS::HDI::ServiceManager::V1_0::SERVIE_STATUS_STOP); + int32_t ret = DCameraHdfOperate::GetInstance().WaitLoadCameraService(); + EXPECT_EQ(ERR_DH_FWK_LOAD_HDF_TIMEOUT, ret); +} + +/** + * @tc.name: WaitLoadProviderService_001 + * @tc.desc: Verify WaitLoadProviderService func. + * @tc.type: FUNC + * @tc.require: AR000GHSJM + */ +HWTEST_F(DCameraHdfOperateTest, WaitLoadProviderService_001, TestSize.Level1) +{ + DHLOGI("DCameraHdfOperateTest::WaitLoadProviderService_001"); + DCameraHdfOperate::GetInstance().providerServStatus_.store(OHOS::HDI::ServiceManager::V1_0::SERVIE_STATUS_STOP); + int32_t ret = DCameraHdfOperate::GetInstance().WaitLoadProviderService(); + EXPECT_EQ(ERR_DH_FWK_LOAD_HDF_TIMEOUT, ret); +} + +/** + * @tc.name: LoadDevice_001 + * @tc.desc: Verify LoadDevice func. + * @tc.type: FUNC + * @tc.require: AR000GHSJM + */ +HWTEST_F(DCameraHdfOperateTest, LoadDevice_001, TestSize.Level1) +{ + DHLOGI("DCameraHdfOperateTest::LoadDevice_001"); + EXPECT_CALL(*deviceManager_, LoadDevice(_)).WillRepeatedly(testing::Return(HDF_ERR_DEVICE_BUSY)); + int32_t ret = DCameraHdfOperate::GetInstance().LoadDevice(); + EXPECT_EQ(ERR_DH_FWK_LOAD_HDF_TIMEOUT, ret); + EXPECT_CALL(*deviceManager_, LoadDevice(_)).WillRepeatedly(testing::Return(ERR_DH_FWK_LOAD_HDF_FAIL)); + ret = DCameraHdfOperate::GetInstance().LoadDevice(); + EXPECT_EQ(ERR_DH_FWK_LOAD_HDF_FAIL, ret); +} + +/** + * @tc.name: LoadDevice_002 + * @tc.desc: Verify LoadDevice func. + * @tc.type: FUNC + * @tc.require: AR000GHSJM + */ +HWTEST_F(DCameraHdfOperateTest, LoadDevice_002, TestSize.Level1) +{ + DHLOGI("DCameraHdfOperateTest::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; + } + }); + DCameraHdfOperate::GetInstance().cameraServStatus_ = OHOS::HDI::ServiceManager::V1_0::SERVIE_STATUS_START; + int32_t ret = DCameraHdfOperate::GetInstance().LoadDevice(); + EXPECT_EQ(ERR_DH_FWK_LOAD_HDF_TIMEOUT, ret); + isFirstTime = true; + EXPECT_CALL(*deviceManager_, LoadDevice(_)).WillRepeatedly([&]()->int32_t { + if (isFirstTime) { + isFirstTime = false; + return HDF_SUCCESS; + } else { + return ERR_DH_FWK_LOAD_HDF_FAIL; + } + }); + ret = DCameraHdfOperate::GetInstance().LoadDevice(); + EXPECT_EQ(ERR_DH_FWK_LOAD_HDF_FAIL, ret); +} + +/** + * @tc.name: UnLoadDevice_001 + * @tc.desc: Verify UnLoadDevice func. + * @tc.type: FUNC + * @tc.require: AR000GHSJM + */ +HWTEST_F(DCameraHdfOperateTest, UnloadDevice_001, TestSize.Level1) +{ + DHLOGI("DCameraHdfOperateTest::UnloadDevice_001"); + EXPECT_CALL(*deviceManager_, UnloadDevice(_)).WillRepeatedly(testing::Return(HDF_ERR_DEVICE_BUSY)); + int32_t ret = DCameraHdfOperate::GetInstance().UnLoadDevice(); + EXPECT_EQ(DH_FWK_SUCCESS, ret); +} +} // namespace DistributedHardware +} // namespace OHOS diff --git a/services/distributedhardwarefwkservice/test/unittest/common/hdfoperate/mock_hdfoperate_device_manager.cpp b/services/distributedhardwarefwkservice/test/unittest/common/hdfoperate/mock_hdfoperate_device_manager.cpp new file mode 100644 index 00000000..9856b298 --- /dev/null +++ b/services/distributedhardwarefwkservice/test/unittest/common/hdfoperate/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::GetOrCtreateInstance() +{ + 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::GetOrCtreateInstance(); +} +} +} +} +} // namespace OHOS \ No newline at end of file diff --git a/services/distributedhardwarefwkservice/test/unittest/common/hdfoperate/mock_hdfoperate_device_manager.h b/services/distributedhardwarefwkservice/test/unittest/common/hdfoperate/mock_hdfoperate_device_manager.h new file mode 100644 index 00000000..06b5d2b1 --- /dev/null +++ b/services/distributedhardwarefwkservice/test/unittest/common/hdfoperate/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 GetOrCtreateInstance(); + 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/services/distributedhardwarefwkservice/test/unittest/common/utils/dh_modem_context_ext_test.cpp b/services/distributedhardwarefwkservice/test/unittest/common/utils/dh_modem_context_ext_test.cpp index db748356..87394518 100644 --- a/services/distributedhardwarefwkservice/test/unittest/common/utils/dh_modem_context_ext_test.cpp +++ b/services/distributedhardwarefwkservice/test/unittest/common/utils/dh_modem_context_ext_test.cpp @@ -1,5 +1,5 @@ /* - * Copyright (c) 2024 Huawei Device Co., Ltd. + * Copyright (c) 2024-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 @@ -47,13 +47,6 @@ void DHModemContextExtTest::TearDownTestCase() {} EXPECT_EQ(ret, DH_FWK_SUCCESS); } - HWTEST_F(DHModemContextExtTest, GetModemExtInstance_001, TestSize.Level1) - { - DHModemContextExt::GetInstance().soHandle_ = nullptr; - DHModemContextExt::GetInstance().GetModemExtInstance(); - EXPECT_NE(DHModemContextExt::GetInstance().distributedModemExt_, nullptr); - } - HWTEST_F(DHModemContextExtTest, GetModemExtInstance_002, TestSize.Level1) { int32_t ret = DHModemContextExt::GetInstance().GetHandler(); -- Gitee