diff --git a/services/distributedhardwarefwkservice/BUILD.gn b/services/distributedhardwarefwkservice/BUILD.gn index 5af3a4aa4595ffc1fb84309bd73fa8c98a3caa39..0f2914ecb88ab1f55de0ff1626570edd14aa48a8 100644 --- a/services/distributedhardwarefwkservice/BUILD.gn +++ b/services/distributedhardwarefwkservice/BUILD.gn @@ -73,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", diff --git a/services/distributedhardwarefwkservice/src/componentmanager/component_manager.cpp b/services/distributedhardwarefwkservice/src/componentmanager/component_manager.cpp index 0dc1ebc8835584373793fcc0ead2749c30ba10cb..b05961a4b1202c0de3eaba8d8f25c9c4df8b8989 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" @@ -1747,6 +1749,16 @@ void ComponentManager::RecoverActiveEnableSource(DHType 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) diff --git a/services/distributedhardwarefwkservice/src/distributed_hardware_service.cpp b/services/distributedhardwarefwkservice/src/distributed_hardware_service.cpp index 125a00425034253b417b0c74b17a8de9dd4d9773..afaa96bc872ca81cd437410ee4286c6fa5c8cdc5 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" @@ -553,11 +555,27 @@ int32_t DistributedHardwareService::DisableSource( 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 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 0000000000000000000000000000000000000000..3131d0f339cd978baf69e5721184b3b4e46ec1d1 --- /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 0000000000000000000000000000000000000000..fc190e65ec3af32c67256d57d462827cf9670ef1 --- /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 d179b82b3c40544f6b502336aab584691e931efa..0f9c8e04ce838557306beaa47b52613b64f1e50c 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/hdfoperate/BUILD.gn b/services/distributedhardwarefwkservice/test/unittest/common/hdfoperate/BUILD.gn new file mode 100644 index 0000000000000000000000000000000000000000..9c6564d8f00a7ae9b06e2e511c23468ab4dcc64d --- /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 0000000000000000000000000000000000000000..f76f66109854dd15edc4f66ffc18844e46dd0402 --- /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 0000000000000000000000000000000000000000..4c18dc64d69fa025f9244d6a76c9c6ceb91fe423 --- /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 0000000000000000000000000000000000000000..9856b298965d0611c8d890694772ed96a465d84e --- /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 0000000000000000000000000000000000000000..06b5d2b10b160b0aa5c82d9dc215566d1300f390 --- /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