From 984156fbea6373e76d50c37cb3980525d357d761 Mon Sep 17 00:00:00 2001 From: zhuzhihui7 Date: Fri, 20 Jun 2025 20:47:19 +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/camera_source/BUILD.gn | 5 + .../include}/dcamera_hdf_operate.h | 21 +- .../include/dcamera_source_handler.h | 4 +- .../src}/dcamera_hdf_operate.cpp | 213 ++++++++----- .../src/dcamera_source_handler.cpp | 13 +- .../unittest/common/camera_source/BUILD.gn | 5 +- .../dcamera_hdf_operate_test/BUILD.gn | 74 +++++ .../dcamera_hdf_operate_test.cpp | 300 ++++++++++++++++++ .../mock_hdfoperate_device_manager.cpp | 48 +++ .../mock_hdfoperate_device_manager.h | 39 +++ .../distributed_camera_source_service.cpp | 10 +- .../common/distributedcamera/BUILD.gn | 2 +- .../mock_distributed_hardware_fwk_kit.cpp | 2 +- 13 files changed, 640 insertions(+), 96 deletions(-) rename {services/cameraservice/sourceservice/test/unittest/common/distributedcamera => interfaces/inner_kits/native_cpp/camera_source/include}/dcamera_hdf_operate.h (79%) rename {services/cameraservice/sourceservice/test/unittest/common/distributedcamera => interfaces/inner_kits/native_cpp/camera_source/src}/dcamera_hdf_operate.cpp (55%) create mode 100644 interfaces/inner_kits/native_cpp/test/unittest/common/camera_source/dcamera_hdf_operate_test/BUILD.gn create mode 100644 interfaces/inner_kits/native_cpp/test/unittest/common/camera_source/dcamera_hdf_operate_test/dcamera_hdf_operate_test.cpp create mode 100644 interfaces/inner_kits/native_cpp/test/unittest/common/camera_source/dcamera_hdf_operate_test/mock_hdfoperate_device_manager.cpp create mode 100644 interfaces/inner_kits/native_cpp/test/unittest/common/camera_source/dcamera_hdf_operate_test/mock_hdfoperate_device_manager.h diff --git a/interfaces/inner_kits/native_cpp/camera_source/BUILD.gn b/interfaces/inner_kits/native_cpp/camera_source/BUILD.gn index f597d91f..c17a047f 100644 --- a/interfaces/inner_kits/native_cpp/camera_source/BUILD.gn +++ b/interfaces/inner_kits/native_cpp/camera_source/BUILD.gn @@ -37,6 +37,7 @@ ohos_shared_library("distributed_camera_source_sdk") { sources = [ "src/callback/dcamera_source_callback.cpp", "src/callback/dcamera_source_callback_stub.cpp", + "src/dcamera_hdf_operate.cpp", "src/dcamera_source_handler.cpp", "src/dcamera_source_handler_ipc.cpp", "src/dcamera_source_load_callback.cpp", @@ -60,6 +61,10 @@ ohos_shared_library("distributed_camera_source_sdk") { external_deps = [ "c_utils:utils", "distributed_hardware_fwk:distributedhardwareutils", + "drivers_interface_distributed_camera:libdistributed_camera_provider_proxy_1.1", + "hdf_core:libhdf_ipc_adapter", + "hdf_core:libhdi", + "hdf_core:libpub_utils", "hilog:libhilog", "ipc:ipc_core", "samgr:samgr_proxy", diff --git a/services/cameraservice/sourceservice/test/unittest/common/distributedcamera/dcamera_hdf_operate.h b/interfaces/inner_kits/native_cpp/camera_source/include/dcamera_hdf_operate.h similarity index 79% rename from services/cameraservice/sourceservice/test/unittest/common/distributedcamera/dcamera_hdf_operate.h rename to interfaces/inner_kits/native_cpp/camera_source/include/dcamera_hdf_operate.h index f7cf7099..88d93548 100644 --- a/services/cameraservice/sourceservice/test/unittest/common/distributedcamera/dcamera_hdf_operate.h +++ b/interfaces/inner_kits/native_cpp/camera_source/include/dcamera_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" @@ -38,17 +39,22 @@ 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"; +const std::string HDF_LISTENER_SERVICE_NAME = "DHFWK"; constexpr uint16_t CAMERA_INVALID_VALUE = 0xffff; constexpr int32_t CAMERA_WAIT_TIME = 2000; class FwkDCameraHdfCallback; +class HdfDeathRecipient : public IRemoteObject::DeathRecipient { +public: + void OnRemoteDied(const wptr &remote) override; +}; class DCameraHdfOperate { DECLARE_SINGLE_INSTANCE(DCameraHdfOperate); public: - int32_t LoadDcameraHDFImpl(); + int32_t LoadDcameraHDFImpl(std::shared_ptr callback); int32_t UnLoadDcameraHDFImpl(); - void ResetRefCount(); + void OnHdfHostDied(); private: int32_t WaitLoadCameraService(); @@ -58,15 +64,22 @@ private: int32_t UnLoadDevice(); int32_t RegisterHdfListener(); int32_t UnRegisterHdfListener(); + int32_t AddHdfDeathBind(); + int32_t RemoveHdfDeathBind(); + int32_t MakeFwkDCameraHdfCallback(); private: + OHOS::sptr devmgr_; + OHOS::sptr servMgr_; + sptr camHdiProvider_; + std::mutex fwkDCameraHdfCallbackMutex_; 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_; + std::shared_ptr hdfDeathCallback_; + sptr hdfDeathRecipient_ = sptr(new HdfDeathRecipient()); }; class DCameraHdfServStatListener : public OHOS::HDI::ServiceManager::V1_0::ServStatListenerStub { diff --git a/interfaces/inner_kits/native_cpp/camera_source/include/dcamera_source_handler.h b/interfaces/inner_kits/native_cpp/camera_source/include/dcamera_source_handler.h index cbd81b44..99bd109d 100644 --- a/interfaces/inner_kits/native_cpp/camera_source/include/dcamera_source_handler.h +++ b/interfaces/inner_kits/native_cpp/camera_source/include/dcamera_source_handler.h @@ -1,5 +1,5 @@ /* - * Copyright (c) 2021 Huawei Device Co., Ltd. + * Copyright (c) 2021-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 @@ -44,6 +44,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 SetSAState(); private: typedef enum { diff --git a/services/cameraservice/sourceservice/test/unittest/common/distributedcamera/dcamera_hdf_operate.cpp b/interfaces/inner_kits/native_cpp/camera_source/src/dcamera_hdf_operate.cpp similarity index 55% rename from services/cameraservice/sourceservice/test/unittest/common/distributedcamera/dcamera_hdf_operate.cpp rename to interfaces/inner_kits/native_cpp/camera_source/src/dcamera_hdf_operate.cpp index 95d814f0..ed47e2ba 100644 --- a/services/cameraservice/sourceservice/test/unittest/common/distributedcamera/dcamera_hdf_operate.cpp +++ b/interfaces/inner_kits/native_cpp/camera_source/src/dcamera_hdf_operate.cpp @@ -19,8 +19,9 @@ #include #include "anonymous_string.h" -#include "distributed_hardware_errno.h" +#include "distributed_camera_errno.h" #include "distributed_hardware_log.h" +#include "iproxy_broker.h" #undef DH_LOG_TAG #define DH_LOG_TAG "DCameraHdfOperate" @@ -28,62 +29,59 @@ namespace OHOS { namespace DistributedHardware { IMPLEMENT_SINGLE_INSTANCE(DCameraHdfOperate); -int32_t DCameraHdfOperate::LoadDcameraHDFImpl() +int32_t DCameraHdfOperate::LoadDcameraHDFImpl(std::shared_ptr callback) { 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) { + if (ret != DCAMERA_OK) { DHLOGE("LoadDevice failed, ret: %{public}d.", ret); return ret; } ret = RegisterHdfListener(); - if (ret != DH_FWK_SUCCESS) { + if (ret != DCAMERA_OK) { DHLOGE("RegisterHdfListener failed, ret: %{public}d.", ret); UnLoadDevice(); return ret; } - hdfLoadRef_++; + hdfDeathCallback_ = callback; + ret = AddHdfDeathBind(); + if (ret != DCAMERA_OK) { + DHLOGE("AddHdfDeathBind failed, ret: %{public}d.", ret); + UnRegisterHdfListener(); + UnLoadDevice(); + return ret; + } DHLOGI("Load camera hdf impl end!"); - return DH_FWK_SUCCESS; + return DCAMERA_OK; } 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) { + int32_t ret = RemoveHdfDeathBind(); + if (ret != DCAMERA_OK) { + DHLOGE("RemoveHdfDeathBind failed, ret: %{public}d.", ret); + } + ret = UnRegisterHdfListener(); + if (ret != DCAMERA_OK) { DHLOGE("UnRegisterHdfListener failed, ret: %{public}d.", ret); } ret = UnLoadDevice(); - if (ret != DH_FWK_SUCCESS) { + if (ret != DCAMERA_OK) { DHLOGE("UnLoadDevice failed, ret: %{public}d.", ret); } - hdfLoadRef_--; DHLOGI("UnLoad camera hdf impl end!"); - return DH_FWK_SUCCESS; + return DCAMERA_OK; } -void DCameraHdfOperate::ResetRefCount() +void DCameraHdfOperate::OnHdfHostDied() { - DHLOGI("Reset reference count for dcamera."); - 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 DCameraHdfOperate::WaitLoadCameraService() @@ -95,9 +93,9 @@ int32_t DCameraHdfOperate::WaitLoadCameraService() }); 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 DCAMERA_BAD_OPERATE; } - return DH_FWK_SUCCESS; + return DCAMERA_OK; } int32_t DCameraHdfOperate::WaitLoadProviderService() @@ -109,9 +107,9 @@ int32_t DCameraHdfOperate::WaitLoadProviderService() }); 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 DCAMERA_BAD_OPERATE; } - return DH_FWK_SUCCESS; + return DCAMERA_OK; } OHOS::sptr DCameraHdfOperate::MakeServStatListener() @@ -135,108 +133,159 @@ OHOS::sptr DCameraHdfOperate::MakeServStatListener() int32_t DCameraHdfOperate::LoadDevice() { DHLOGI("LoadDevice for camera begin!"); - OHOS::sptr servMgr = IServiceManager::Get(); - OHOS::sptr devmgr = IDeviceManager::Get(); - if (servMgr == nullptr || devmgr == nullptr) { + 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; + return DCAMERA_BAD_VALUE; } OHOS::sptr listener = MakeServStatListener(); - if (servMgr->RegisterServiceStatusListener(listener, DEVICE_CLASS_CAMERA) != 0) { + if (servMgr_->RegisterServiceStatusListener(listener, DEVICE_CLASS_CAMERA) != 0) { DHLOGE("RegisterServiceStatusListener failed!"); - return ERR_DH_FWK_REGISTER_HDF_LISTENER_FAIL; + return DCAMERA_BAD_OPERATE; } DHLOGI("Load camera service."); - int32_t ret = devmgr->LoadDevice(CAMERA_SERVICE_NAME); + 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; + servMgr_->UnregisterServiceStatusListener(listener); + return DCAMERA_BAD_OPERATE; } - if (WaitLoadCameraService() != DH_FWK_SUCCESS) { + if (WaitLoadCameraService() != DCAMERA_OK) { DHLOGE("Wait load camera service failed!"); - servMgr->UnregisterServiceStatusListener(listener); - return ERR_DH_FWK_LOAD_HDF_TIMEOUT; + servMgr_->UnregisterServiceStatusListener(listener); + return DCAMERA_BAD_OPERATE; } - ret = devmgr->LoadDevice(PROVIDER_SERVICE_NAME); + ret = devmgr_->LoadDevice(PROVIDER_SERVICE_NAME); if (ret != HDF_SUCCESS && ret != HDF_ERR_DEVICE_BUSY) { DHLOGE("Load camera provider service failed!"); - servMgr->UnregisterServiceStatusListener(listener); - return ERR_DH_FWK_LOAD_HDF_FAIL; + devmgr_->UnloadDevice(CAMERA_SERVICE_NAME); + servMgr_->UnregisterServiceStatusListener(listener); + return DCAMERA_BAD_OPERATE; } - if (WaitLoadProviderService() != DH_FWK_SUCCESS) { + if (WaitLoadProviderService() != DCAMERA_OK) { DHLOGE("Wait load camera provider service failed!"); - servMgr->UnregisterServiceStatusListener(listener); - return ERR_DH_FWK_LOAD_HDF_TIMEOUT; + devmgr_->UnloadDevice(CAMERA_SERVICE_NAME); + servMgr_->UnregisterServiceStatusListener(listener); + return DCAMERA_BAD_OPERATE; } - if (servMgr->UnregisterServiceStatusListener(listener) != 0) { + if (servMgr_->UnregisterServiceStatusListener(listener) != 0) { DHLOGE("UnregisterServiceStatusListener failed!"); } DHLOGI("LoadDevice for camera end!"); - return DH_FWK_SUCCESS; + return DCAMERA_OK; } 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; + if (devmgr_ == nullptr) { + DHLOGE("hdi device manager is nullptr!"); + return DCAMERA_BAD_VALUE; } - int32_t ret = devmgr->UnloadDevice(CAMERA_SERVICE_NAME); + 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); + 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; + return DCAMERA_OK; } int32_t DCameraHdfOperate::RegisterHdfListener() { DHLOGI("RegisterHdfListener for camera begin!"); - sptr camHdiProvider = IDCameraProvider::Get(PROVIDER_SERVICE_NAME); - if (camHdiProvider == nullptr) { + camHdiProvider_ = IDCameraProvider::Get(PROVIDER_SERVICE_NAME); + if (camHdiProvider_ == nullptr) { DHLOGE("Get hdi camera provider failed."); - return ERR_DH_FWK_POINTER_IS_NULL; + return DCAMERA_BAD_VALUE; } if (fwkDCameraHdfCallback_ == nullptr) { - fwkDCameraHdfCallback_ = new FwkDCameraHdfCallback(); - if (fwkDCameraHdfCallback_ == nullptr) { + if (MakeFwkDCameraHdfCallback() != DCAMERA_OK) { DHLOGE("Create FwkDCameraHdfCallback failed."); - return ERR_DH_FWK_POINTER_IS_NULL; + return DCAMERA_BAD_VALUE; } } - int32_t ret = camHdiProvider->RegisterCameraHdfListener("DHFWK", fwkDCameraHdfCallback_); - if (ret != DH_FWK_SUCCESS) { + int32_t ret = camHdiProvider_->RegisterCameraHdfListener(HDF_LISTENER_SERVICE_NAME, fwkDCameraHdfCallback_); + if (ret != DCAMERA_OK) { DHLOGE("Call hdf proxy RegisterCameraHdfListener failed, ret: %{public}d.", ret); return ret; } DHLOGI("RegisterHdfListener for camera end!"); - return DH_FWK_SUCCESS; + return DCAMERA_OK; } 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; + if (camHdiProvider_ == nullptr) { + DHLOGE("hdi camera provider is nullptr."); + return DCAMERA_BAD_VALUE; } - int32_t ret = camHdiProvider->UnRegisterCameraHdfListener("DHFWK"); - if (ret != DH_FWK_SUCCESS) { + int32_t ret = camHdiProvider_->UnRegisterCameraHdfListener(HDF_LISTENER_SERVICE_NAME); + if (ret != DCAMERA_OK) { DHLOGE("Call hdf proxy UnRegisterCameraHdfListener failed, ret: %{public}d.", ret); return ret; } DHLOGI("UnRegisterHdfListener for camera end!"); - return DH_FWK_SUCCESS; + return DCAMERA_OK; +} + +int32_t DCameraHdfOperate::AddHdfDeathBind() +{ + DHLOGI("AddHdfDeathBind for dcamera begin!"); + if (camHdiProvider_ == nullptr) { + DHLOGE("hdi dcamera manager is nullptr!"); + return DCAMERA_BAD_VALUE; + } + sptr remote = OHOS::HDI::hdi_objcast(camHdiProvider_); + if (remote == nullptr) { + DHLOGE("Get remote from hdi dcamera manager failed!"); + return DCAMERA_BAD_VALUE; + } + if (remote->AddDeathRecipient(hdfDeathRecipient_) == false) { + DHLOGE("Call AddDeathRecipient failed!"); + return DCAMERA_BAD_VALUE; + } + DHLOGI("AddHdfDeathBind for dcamera end!"); + return DCAMERA_OK; +} + +int32_t DCameraHdfOperate::RemoveHdfDeathBind() +{ + DHLOGI("RemoveHdfDeathBind for dcamera begin!"); + if (camHdiProvider_ == nullptr) { + DHLOGE("hdi dcamera manager is nullptr!"); + return DCAMERA_BAD_VALUE; + } + sptr remote = OHOS::HDI::hdi_objcast(camHdiProvider_); + if (remote == nullptr) { + DHLOGE("Get remote from hdi dcamera manager failed!"); + return DCAMERA_BAD_VALUE; + } + if (remote->RemoveDeathRecipient(hdfDeathRecipient_) == false) { + DHLOGE("Call RemoveDeathRecipient failed!"); + return DCAMERA_BAD_OPERATE; + } + DHLOGI("RemoveHdfDeathBind for dcamera end!"); + return DCAMERA_OK; +} + +int32_t DCameraHdfOperate::MakeFwkDCameraHdfCallback() +{ + std::lock_guard locker(fwkDCameraHdfCallbackMutex_); + if (fwkDCameraHdfCallback_ == nullptr) { + fwkDCameraHdfCallback_ = new FwkDCameraHdfCallback(); + if (fwkDCameraHdfCallback_ == nullptr) { + return DCAMERA_BAD_VALUE; + } + } + return DCAMERA_OK; } void DCameraHdfServStatListener::OnReceive(const ServiceStatus& status) @@ -251,7 +300,13 @@ int32_t FwkDCameraHdfCallback::NotifyEvent(int32_t devId, const DCameraHDFEvent& { (void)devId; (void)event; - return DH_FWK_SUCCESS; + return DCAMERA_OK; +} + +void HdfDeathRecipient::OnRemoteDied(const wptr &remote) +{ + DHLOGI("On remote died!"); + DCameraHdfOperate::GetInstance().OnHdfHostDied(); } } // namespace DistributedHardware } // namespace OHOS diff --git a/interfaces/inner_kits/native_cpp/camera_source/src/dcamera_source_handler.cpp b/interfaces/inner_kits/native_cpp/camera_source/src/dcamera_source_handler.cpp index 8051b277..732c5817 100644 --- a/interfaces/inner_kits/native_cpp/camera_source/src/dcamera_source_handler.cpp +++ b/interfaces/inner_kits/native_cpp/camera_source/src/dcamera_source_handler.cpp @@ -1,5 +1,5 @@ /* - * Copyright (c) 2021-2023 Huawei Device Co., Ltd. + * Copyright (c) 2021-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 @@ -16,6 +16,7 @@ #include "dcamera_source_handler.h" #include "anonymous_string.h" +#include "dcamera_hdf_operate.h" #include "dcamera_hisysevent_adapter.h" #include "dcamera_radar.h" #include "dcamera_source_callback.h" @@ -211,6 +212,16 @@ void DCameraSourceHandler::UnregisterDataSyncTriggerListener() callback_->UnRegisterTriggerListener(); } +int32_t DCameraSourceHandler::LoadDistributedHDF(std::shared_ptr callback) +{ + return DCameraHdfOperate::GetInstance().LoadDcameraHDFImpl(callback); +} + +int32_t DCameraSourceHandler::UnLoadDistributedHDF() +{ + return DCameraHdfOperate::GetInstance().UnLoadDcameraHDFImpl(); +} + void DCameraSourceHandler::SetSAState() { std::unique_lock lock(producerMutex_); diff --git a/interfaces/inner_kits/native_cpp/test/unittest/common/camera_source/BUILD.gn b/interfaces/inner_kits/native_cpp/test/unittest/common/camera_source/BUILD.gn index 25954866..4baa5292 100644 --- a/interfaces/inner_kits/native_cpp/test/unittest/common/camera_source/BUILD.gn +++ b/interfaces/inner_kits/native_cpp/test/unittest/common/camera_source/BUILD.gn @@ -64,5 +64,8 @@ ohos_unittest("DCameraSourceHandlerTest") { group("dcamera_source_handler_test") { testonly = true - deps = [ ":DCameraSourceHandlerTest" ] + deps = [ + ":DCameraSourceHandlerTest", + "dcamera_hdf_operate_test:DCameraHdfOperateTest", + ] } diff --git a/interfaces/inner_kits/native_cpp/test/unittest/common/camera_source/dcamera_hdf_operate_test/BUILD.gn b/interfaces/inner_kits/native_cpp/test/unittest/common/camera_source/dcamera_hdf_operate_test/BUILD.gn new file mode 100644 index 00000000..dc9e4967 --- /dev/null +++ b/interfaces/inner_kits/native_cpp/test/unittest/common/camera_source/dcamera_hdf_operate_test/BUILD.gn @@ -0,0 +1,74 @@ +# 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. + +import("//build/test.gni") +import( + "//foundation/distributedhardware/distributed_camera/distributedcamera.gni") + +module_out_path = "${unittest_output_path}/dcamera_hdf_operate_test" + +config("module_private_config") { + visibility = [ ":*" ] + include_dirs = [ + "include", + "include/callback", + "${common_path}/include", + "${common_path}/include/constants", + "${common_path}/include/utils", + "${innerkits_path}/native_cpp/camera_source/include", + "${innerkits_path}/native_cpp/camera_source/include/callback", + "${innerkits_path}/native_cpp/test/include", + ] +} + +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 = [ + "${common_path}:distributed_camera_utils", + "${innerkits_path}/native_cpp/camera_source:distributed_camera_source_sdk", + ] + + cflags = [ "-Dprivate=public" ] + + external_deps = [ + "c_utils:utils", + "distributed_hardware_fwk:distributedhardwareutils", + "drivers_interface_distributed_camera:libdistributed_camera_provider_proxy_1.1", + "googletest:gmock", + "hdf_core:libhdf_ipc_adapter", + "hdf_core:libhdi", + "hdf_core:libpub_utils", + "hilog:libhilog", + "ipc:ipc_core", + "samgr:samgr_proxy", + ] + + defines = [ + "HI_LOG_ENABLE", + "DH_LOG_TAG=\"DCameraHdfOperateTest\"", + "LOG_DOMAIN=0xD004150", + ] +} + +group("dcamera_hdf_operate_test") { + testonly = true + deps = [ ":DCameraHdfOperateTest" ] +} diff --git a/interfaces/inner_kits/native_cpp/test/unittest/common/camera_source/dcamera_hdf_operate_test/dcamera_hdf_operate_test.cpp b/interfaces/inner_kits/native_cpp/test/unittest/common/camera_source/dcamera_hdf_operate_test/dcamera_hdf_operate_test.cpp new file mode 100644 index 00000000..a947ce69 --- /dev/null +++ b/interfaces/inner_kits/native_cpp/test/unittest/common/camera_source/dcamera_hdf_operate_test/dcamera_hdf_operate_test.cpp @@ -0,0 +1,300 @@ +/* + * 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_camera_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::GetOrCreateInstance(); +} + +void DCameraHdfOperateTest::TearDown(void) +{ + DHLOGI("DCameraHdfOperateTest::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: LoadDcameraHDFImpl_001 + * @tc.desc: Verify LoadDcameraHDFImpl func + * @tc.type: FUNC + * @tc.require: AR000GHSJM + */ +HWTEST_F(DCameraHdfOperateTest, LoadDcameraHDFImpl_001, TestSize.Level1) +{ + DHLOGI("DCameraHdfOperateTest::LoadDcameraHDFImpl_001"); + int32_t ret = DCameraHdfOperate::GetInstance().LoadDcameraHDFImpl(nullptr); + EXPECT_EQ(DCAMERA_BAD_OPERATE, ret); +} + +/** + * @tc.name: LoadDcameraHDFImpl_002 + * @tc.desc: Verify LoadDcameraHDFImpl func + * @tc.type: FUNC + * @tc.require: AR000GHSJM + */ +HWTEST_F(DCameraHdfOperateTest, LoadDcameraHDFImpl_002, TestSize.Level1) +{ + DHLOGI("DCameraHdfOperateTest::LoadDaudioHDFImpl_002"); + EXPECT_CALL(*deviceManager_, LoadDevice(_)).WillRepeatedly(testing::Return(DCAMERA_OK)); + DCameraHdfOperate::GetInstance().cameraServStatus_.store(OHOS::HDI::ServiceManager::V1_0::SERVIE_STATUS_START); + DCameraHdfOperate::GetInstance().providerServStatus_.store(OHOS::HDI::ServiceManager::V1_0::SERVIE_STATUS_START); + int32_t ret = DCameraHdfOperate::GetInstance().LoadDcameraHDFImpl(nullptr); + DCameraHdfOperate::GetInstance().cameraServStatus_.store(OHOS::HDI::ServiceManager::V1_0::SERVIE_STATUS_STOP); + DCameraHdfOperate::GetInstance().providerServStatus_.store(OHOS::HDI::ServiceManager::V1_0::SERVIE_STATUS_STOP); + EXPECT_EQ(DCAMERA_BAD_VALUE, ret); +} + +/** + * @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(DCAMERA_OK, ret); +} + +/** + * @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_START); + int32_t ret = DCameraHdfOperate::GetInstance().WaitLoadCameraService(); + EXPECT_EQ(DCAMERA_OK, ret); + DCameraHdfOperate::GetInstance().cameraServStatus_.store(OHOS::HDI::ServiceManager::V1_0::SERVIE_STATUS_STOP); + ret = DCameraHdfOperate::GetInstance().WaitLoadCameraService(); + EXPECT_EQ(DCAMERA_BAD_OPERATE, 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_START); + int32_t ret = DCameraHdfOperate::GetInstance().WaitLoadProviderService(); + EXPECT_EQ(DCAMERA_OK, ret); + DCameraHdfOperate::GetInstance().providerServStatus_.store(OHOS::HDI::ServiceManager::V1_0::SERVIE_STATUS_STOP); + ret = DCameraHdfOperate::GetInstance().WaitLoadProviderService(); + EXPECT_EQ(DCAMERA_BAD_OPERATE, 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(DCAMERA_BAD_OPERATE, ret); + EXPECT_CALL(*deviceManager_, LoadDevice(_)).WillRepeatedly(testing::Return(DCAMERA_BAD_OPERATE)); + ret = DCameraHdfOperate::GetInstance().LoadDevice(); + EXPECT_EQ(DCAMERA_BAD_OPERATE, 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(DCAMERA_BAD_OPERATE, ret); + isFirstTime = true; + EXPECT_CALL(*deviceManager_, LoadDevice(_)).WillRepeatedly([&]()->int32_t { + if (isFirstTime) { + isFirstTime = false; + return HDF_SUCCESS; + } else { + return DCAMERA_BAD_OPERATE; + } + }); + ret = DCameraHdfOperate::GetInstance().LoadDevice(); + EXPECT_EQ(DCAMERA_BAD_OPERATE, 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(DCAMERA_OK, ret); +} + +/** + * @tc.name: UnLoadDevice_002 + * @tc.desc: Verify UnLoadDevice func. + * @tc.type: FUNC + * @tc.require: AR000GHSJM + */ +HWTEST_F(DCameraHdfOperateTest, UnloadDevice_002, TestSize.Level1) +{ + DHLOGI("DCameraHdfOperateTest::UnloadDevice_002"); + auto devmgr = DCameraHdfOperate::GetInstance().devmgr_; + DCameraHdfOperate::GetInstance().devmgr_ = nullptr; + int32_t ret = DCameraHdfOperate::GetInstance().UnLoadDevice(); + DCameraHdfOperate::GetInstance().devmgr_ = devmgr; + EXPECT_EQ(DCAMERA_BAD_VALUE, ret); +} + +/** + * @tc.name: UnRegisterHdfListener_001 + * @tc.desc: Verify UnRegisterHdfListener func. + * @tc.type: FUNC + * @tc.require: AR000GHSJM + */ +HWTEST_F(DCameraHdfOperateTest, UnRegisterHdfListener_001, TestSize.Level1) +{ + DHLOGI("DCameraHdfOperateTest::UnRegisterHdfListener_001"); + auto camHdiProvider = DCameraHdfOperate::GetInstance().camHdiProvider_; + DCameraHdfOperate::GetInstance().camHdiProvider_ = nullptr; + int32_t ret = DCameraHdfOperate::GetInstance().UnRegisterHdfListener(); + DCameraHdfOperate::GetInstance().camHdiProvider_ = camHdiProvider; + EXPECT_EQ(DCAMERA_BAD_VALUE, ret); +} + +/** + * @tc.name: OnHdfHostDied_001 + * @tc.desc: Verify OnHdfHostDied func. + * @tc.type: FUNC + * @tc.require: AR000GHSJM + */ +HWTEST_F(DCameraHdfOperateTest, OnHdfHostDied_001, TestSize.Level1) +{ + auto hdfDeathCallback = std::make_shared(); + DCameraHdfOperate::GetInstance().hdfDeathCallback_ = nullptr; + DCameraHdfOperate::GetInstance().OnHdfHostDied(); + EXPECT_EQ(hdfDeathCallback->IsCalled(), false); + DCameraHdfOperate::GetInstance().hdfDeathCallback_ = hdfDeathCallback; + DCameraHdfOperate::GetInstance().OnHdfHostDied(); + EXPECT_EQ(hdfDeathCallback->IsCalled(), true); +} + +/** + * @tc.name: AddHdfDeathBind_001 + * @tc.desc: Verify AddHdfDeathBind func. + * @tc.type: FUNC + * @tc.require: AR000GHSJM + */ +HWTEST_F(DCameraHdfOperateTest, AddHdfDeathBind_001, TestSize.Level1) +{ + DHLOGI("DCameraHdfOperateTest::AddHdfDeathBind_001"); + auto camHdiProvider = DCameraHdfOperate::GetInstance().camHdiProvider_; + DCameraHdfOperate::GetInstance().camHdiProvider_ = nullptr; + int32_t ret = DCameraHdfOperate::GetInstance().AddHdfDeathBind(); + DCameraHdfOperate::GetInstance().camHdiProvider_ = camHdiProvider; + EXPECT_EQ(DCAMERA_BAD_VALUE, ret); +} + +/** + * @tc.name: RemoveHdfDeathBind_001 + * @tc.desc: Verify RemoveHdfDeathBind func. + * @tc.type: FUNC + * @tc.require: AR000GHSJM + */ +HWTEST_F(DCameraHdfOperateTest, RemoveHdfDeathBind_001, TestSize.Level1) +{ + DHLOGI("DCameraHdfOperateTest::RemoveHdfDeathBind_001"); + auto camHdiProvider = DCameraHdfOperate::GetInstance().camHdiProvider_; + DCameraHdfOperate::GetInstance().camHdiProvider_ = nullptr; + int32_t ret = DCameraHdfOperate::GetInstance().RemoveHdfDeathBind(); + DCameraHdfOperate::GetInstance().camHdiProvider_ = camHdiProvider; + EXPECT_EQ(DCAMERA_BAD_VALUE, ret); +} +} // namespace DistributedHardware +} // namespace OHOS diff --git a/interfaces/inner_kits/native_cpp/test/unittest/common/camera_source/dcamera_hdf_operate_test/mock_hdfoperate_device_manager.cpp b/interfaces/inner_kits/native_cpp/test/unittest/common/camera_source/dcamera_hdf_operate_test/mock_hdfoperate_device_manager.cpp new file mode 100644 index 00000000..d31e349f --- /dev/null +++ b/interfaces/inner_kits/native_cpp/test/unittest/common/camera_source/dcamera_hdf_operate_test/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/interfaces/inner_kits/native_cpp/test/unittest/common/camera_source/dcamera_hdf_operate_test/mock_hdfoperate_device_manager.h b/interfaces/inner_kits/native_cpp/test/unittest/common/camera_source/dcamera_hdf_operate_test/mock_hdfoperate_device_manager.h new file mode 100644 index 00000000..3357bf57 --- /dev/null +++ b/interfaces/inner_kits/native_cpp/test/unittest/common/camera_source/dcamera_hdf_operate_test/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/services/cameraservice/sourceservice/src/distributedcamera/distributed_camera_source_service.cpp b/services/cameraservice/sourceservice/src/distributedcamera/distributed_camera_source_service.cpp index 63638fff..3cd92815 100644 --- a/services/cameraservice/sourceservice/src/distributedcamera/distributed_camera_source_service.cpp +++ b/services/cameraservice/sourceservice/src/distributedcamera/distributed_camera_source_service.cpp @@ -310,10 +310,7 @@ int32_t DistributedCameraSourceService::LoadDCameraHDF() DCAMERA_SYNC_TRACE(DCAMERA_LOAD_HDF); DHLOGI("load hdf driver start"); auto dHFwkKit = GetDHFwkKit(); - if (dHFwkKit == nullptr) { - DHLOGE("Get dHFwkKit is null when load hdf driver."); - return DCAMERA_BAD_VALUE; - } + CHECK_NULL_RETURN((dHFwkKit == nullptr), DCAMERA_BAD_VALUE); int32_t ret = dHFwkKit->LoadDistributedHDF(DHType::CAMERA); if (ret != DCAMERA_OK) { DHLOGE("load hdf driver failed, ret %{public}d", ret); @@ -328,10 +325,7 @@ int32_t DistributedCameraSourceService::UnLoadCameraHDF() { DHLOGI("unload hdf driver start"); auto dHFwkKit = GetDHFwkKit(); - if (dHFwkKit == nullptr) { - DHLOGE("Get dHFwkKit is null when unload hdf driver."); - return DCAMERA_BAD_VALUE; - } + CHECK_NULL_RETURN((dHFwkKit == nullptr), DCAMERA_BAD_VALUE); int32_t ret = dHFwkKit->UnLoadDistributedHDF(DHType::CAMERA); if (ret != DCAMERA_OK) { DHLOGE("unload hdf driver failed, ret %{public}d", ret); diff --git a/services/cameraservice/sourceservice/test/unittest/common/distributedcamera/BUILD.gn b/services/cameraservice/sourceservice/test/unittest/common/distributedcamera/BUILD.gn index dff8a374..0e8e2442 100644 --- a/services/cameraservice/sourceservice/test/unittest/common/distributedcamera/BUILD.gn +++ b/services/cameraservice/sourceservice/test/unittest/common/distributedcamera/BUILD.gn @@ -52,13 +52,13 @@ ohos_unittest("DCameraSourceTest") { module_out_path = module_out_path sources = [ - "dcamera_hdf_operate.cpp", "dcamera_service_state_listener_test.cpp", "dcamera_source_callback_proxy_test.cpp", "dcamera_source_hidumper_test.cpp", "distributed_camera_source_service_test.cpp", "distributed_camera_source_stub_test.cpp", "mock_distributed_hardware_fwk_kit.cpp", + "${innerkits_path}/native_cpp/camera_source/src/dcamera_hdf_operate.cpp", ] cflags = [ diff --git a/services/cameraservice/sourceservice/test/unittest/common/distributedcamera/mock_distributed_hardware_fwk_kit.cpp b/services/cameraservice/sourceservice/test/unittest/common/distributedcamera/mock_distributed_hardware_fwk_kit.cpp index fe1bbf34..616a54a2 100644 --- a/services/cameraservice/sourceservice/test/unittest/common/distributedcamera/mock_distributed_hardware_fwk_kit.cpp +++ b/services/cameraservice/sourceservice/test/unittest/common/distributedcamera/mock_distributed_hardware_fwk_kit.cpp @@ -24,7 +24,7 @@ namespace OHOS { namespace DistributedHardware { int32_t DistributedHardwareFwkKit::LoadDistributedHDF(const DHType dhType) { - return DCameraHdfOperate::GetInstance().LoadDcameraHDFImpl(); + return DCameraHdfOperate::GetInstance().LoadDcameraHDFImpl(nullptr); } int32_t DistributedHardwareFwkKit::UnLoadDistributedHDF(const DHType dhType) -- Gitee