diff --git a/bundle.json b/bundle.json index 190949305c688aba02fdbf94876775ca873e7fdc..4da514723215400e3e682388292c5396857181c6 100644 --- a/bundle.json +++ b/bundle.json @@ -37,12 +37,9 @@ "bundle_framework", "napi", "dsoftbus", - "drivers_interface_distributed_audio", - "drivers_interface_distributed_camera", "eventhandler", "hitrace", "c_utils", - "hdf_core", "hilog", "cJSON", "samgr", diff --git a/common/utils/include/distributed_hardware_errno.h b/common/utils/include/distributed_hardware_errno.h index f235ec62d3a16a2ff7c48c1ae6b7724d812e15f6..194d54486583806c2ed2ff73b37116f73caa18ad 100644 --- a/common/utils/include/distributed_hardware_errno.h +++ b/common/utils/include/distributed_hardware_errno.h @@ -100,6 +100,8 @@ namespace DistributedHardware { 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; + constexpr int32_t ERR_DH_FWK_ADD_DEATH_FAIL = -10817; + constexpr int32_t ERR_DH_FWK_REMOVE_DEATH_FAIL = -10818; /* AccessManager errno, range: [-10900, -10999] */ constexpr int32_t ERR_DH_FWK_ACCESS_INIT_DM_FAILED = -10900; diff --git a/common/utils/include/idistributed_hardware_source.h b/common/utils/include/idistributed_hardware_source.h index db75a4794d87b00c556a9ba533f5992b4b883ddf..23c50f69aa04a35b08be6e49aeeed1fb80487583 100644 --- a/common/utils/include/idistributed_hardware_source.h +++ b/common/utils/include/idistributed_hardware_source.h @@ -72,6 +72,16 @@ public: virtual void OnDataSyncTrigger(const std::string &networkId) = 0; }; +class HdfDeathCallback { +public: + /** + * @brief Trigger callback when HDF driver exits abnormally + * + */ + virtual void OnHdfHostDied() = 0; +}; + + class IDistributedHardwareSource { public: virtual int32_t InitSource(const std::string ¶ms) = 0; @@ -87,6 +97,15 @@ public: virtual void UnregisterDistributedHardwareStateListener() = 0; virtual void RegisterDataSyncTriggerListener(std::shared_ptr listener) = 0; virtual void UnregisterDataSyncTriggerListener() = 0; + virtual int32_t LoadDistributedHDF(std::shared_ptr callback) + { + (void)callback; + return 0; + } + virtual int32_t UnLoadDistributedHDF() + { + return 0; + } }; extern "C" __attribute__((visibility("default"))) IDistributedHardwareSource* GetSourceHardwareHandler(); } // namespace DistributedHardware diff --git a/interfaces/inner_kits/include/ipc/distributed_hardware_proxy.h b/interfaces/inner_kits/include/ipc/distributed_hardware_proxy.h index 7fba9350aa2e6e319acf3783f4afe9e547aeda88..211d4f674db5acd5df3cbd5284939d4d09d0a4ec 100644 --- a/interfaces/inner_kits/include/ipc/distributed_hardware_proxy.h +++ b/interfaces/inner_kits/include/ipc/distributed_hardware_proxy.h @@ -22,14 +22,23 @@ #include "iremote_proxy.h" #include "refbase.h" #include "idistributed_hardware.h" +#include "publisher_listener_stub.h" namespace OHOS { namespace DistributedHardware { +class IHdfDeathListener : public IRemoteBroker { +public: + DECLARE_INTERFACE_DESCRIPTOR(u"ohos.DistributedHardware.DistributedHardwareFwk.IHdfDeathListener"); +}; +class HdfDeathListenerStub : public IRemoteStub { +public: +}; class DistributedHardwareProxy : public IRemoteProxy { public: explicit DistributedHardwareProxy(const sptr impl) : IRemoteProxy(impl) { + hdfDeathListenerStub_ = sptr(new HdfDeathListenerStub()); } virtual ~DistributedHardwareProxy() {} @@ -66,6 +75,7 @@ private: private: static inline BrokerDelegator delegator_; + sptr hdfDeathListenerStub_; }; } // namespace DistributedHardware } // namespace OHOS diff --git a/interfaces/inner_kits/src/ipc/distributed_hardware_proxy.cpp b/interfaces/inner_kits/src/ipc/distributed_hardware_proxy.cpp index d3f104ce5d6d649f2dff14cdb8856ba7d067d14c..d4a2cbd8e6fd4bde5185cb22edce9e8d77f43b1f 100644 --- a/interfaces/inner_kits/src/ipc/distributed_hardware_proxy.cpp +++ b/interfaces/inner_kits/src/ipc/distributed_hardware_proxy.cpp @@ -862,6 +862,10 @@ int32_t DistributedHardwareProxy::LoadDistributedHDF(const DHType dhType) DHLOGE("Write type failed"); return ERR_DH_AVT_SERVICE_WRITE_INFO_FAIL; } + if (!data.WriteRemoteObject(hdfDeathListenerStub_->AsObject())) { + DHLOGE("Write publisher listener 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) { @@ -890,6 +894,10 @@ int32_t DistributedHardwareProxy::UnLoadDistributedHDF(const DHType dhType) DHLOGE("Write type failed"); return ERR_DH_AVT_SERVICE_WRITE_INFO_FAIL; } + if (!data.WriteRemoteObject(hdfDeathListenerStub_->AsObject())) { + DHLOGE("Write publisher listener 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) { diff --git a/interfaces/inner_kits/test/unittest/common/ipc/distributed_hardware_proxy/BUILD.gn b/interfaces/inner_kits/test/unittest/common/ipc/distributed_hardware_proxy/BUILD.gn index c9bdd2c4a6b843cff5a701293e00bb337009fa5f..ece35c56a1a985faccae4a8bd5cb36ad2db9d805 100644 --- a/interfaces/inner_kits/test/unittest/common/ipc/distributed_hardware_proxy/BUILD.gn +++ b/interfaces/inner_kits/test/unittest/common/ipc/distributed_hardware_proxy/BUILD.gn @@ -28,6 +28,7 @@ config("module_private_config") { "${innerkits_path}/include", "${innerkits_path}/include/ipc", "${services_path}/distributedhardwarefwkservice/include", + "${services_path}/distributedhardwarefwkservice/include/hdfoperate", "${services_path}/distributedhardwarefwkservice/include/utils", "${services_path}/distributedhardwarefwkservice/include/ipc", ] diff --git a/services/distributedhardwarefwkservice/BUILD.gn b/services/distributedhardwarefwkservice/BUILD.gn index 0f2914ecb88ab1f55de0ff1626570edd14aa48a8..d1464005a109fc1b18dc1e395fce50c2e66d0cd4 100644 --- a/services/distributedhardwarefwkservice/BUILD.gn +++ b/services/distributedhardwarefwkservice/BUILD.gn @@ -73,8 +73,7 @@ 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/hdfoperate/hdf_operate.cpp", "src/hidumphelper/enabled_comps_dump.cpp", "src/hidumphelper/hidump_helper.cpp", "src/ipc/get_dh_descriptors_callback_proxy.cpp", @@ -159,14 +158,9 @@ 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 50559348202a69d32c1eb87ab1093c707513eeea..624c00e18506e9773c76ed065bdb58436fb1439d 100644 --- a/services/distributedhardwarefwkservice/include/componentmanager/component_manager.h +++ b/services/distributedhardwarefwkservice/include/componentmanager/component_manager.h @@ -262,7 +262,6 @@ 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/hdfoperate/daudio_hdf_operate.h b/services/distributedhardwarefwkservice/include/hdfoperate/daudio_hdf_operate.h deleted file mode 100644 index fa51ef279d6d624f6eadaf19555bf9c7e051361a..0000000000000000000000000000000000000000 --- a/services/distributedhardwarefwkservice/include/hdfoperate/daudio_hdf_operate.h +++ /dev/null @@ -1,93 +0,0 @@ -/* - * 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/hdf_operate.h similarity index 30% rename from services/distributedhardwarefwkservice/include/hdfoperate/dcamera_hdf_operate.h rename to services/distributedhardwarefwkservice/include/hdfoperate/hdf_operate.h index f7cf7099081b68713d42667ef789facb5b8f114a..c6b6a3b3a043be74a9cf4b73ec7f27b1d65b85dc 100644 --- a/services/distributedhardwarefwkservice/include/hdfoperate/dcamera_hdf_operate.h +++ b/services/distributedhardwarefwkservice/include/hdfoperate/hdf_operate.h @@ -13,79 +13,70 @@ * limitations under the License. */ -#ifndef OHOS_DCAMERA_HDF_OPERATE_H -#define OHOS_DCAMERA_HDF_OPERATE_H +#ifndef OHOS_HDF_OPERATE_H +#define OHOS_HDF_OPERATE_H #include #include +#include #include -#include "iservstat_listener_hdi.h" -#include "idevmgr_hdi.h" -#include "iservmgr_hdi.h" +#include "idistributed_hardware.h" +#include "idistributed_hardware_source.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); - +class HdfLoadRefRecipient : public IRemoteObject::DeathRecipient { public: - int32_t LoadDcameraHDFImpl(); - int32_t UnLoadDcameraHDFImpl(); - void ResetRefCount(); - + explicit HdfLoadRefRecipient(DHType dhType) : dhType_(dhType) {} + void OnRemoteDied(const wptr &remote) override; private: - int32_t WaitLoadCameraService(); - int32_t WaitLoadProviderService(); - OHOS::sptr MakeServStatListener(); - int32_t LoadDevice(); - int32_t UnLoadDevice(); - int32_t RegisterHdfListener(); - int32_t UnRegisterHdfListener(); + DHType dhType_; +}; +class HdfDeathCallbackImpl : public HdfDeathCallback { +public: + explicit HdfDeathCallbackImpl(DHType dhType) : dhType_(dhType) {} + virtual ~HdfDeathCallbackImpl() = default; +protected: + void OnHdfHostDied(); 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_; + DHType dhType_; }; - -class DCameraHdfServStatListener : public OHOS::HDI::ServiceManager::V1_0::ServStatListenerStub { +class HdfOperator { public: - using StatusCallback = std::function; - explicit DCameraHdfServStatListener(StatusCallback callback) : callback_(std::move(callback)) + explicit HdfOperator(DHType dhType, IDistributedHardwareSource *sourcePtr) + : dhType_(dhType), sourcePtr_(sourcePtr) { + hdfDeathCallback_ = std::make_shared(dhType); } - ~DCameraHdfServStatListener() override = default; - void OnReceive(const ServiceStatus& status) override; - + int32_t LoadDistributedHDF(); + int32_t UnLoadDistributedHDF(); + void ResetRefCount(); private: - StatusCallback callback_; + DHType dhType_ = DHType::UNKNOWN; + int32_t hdfLoadRef_ = 0; + std::mutex hdfLoadRefMutex_; + IDistributedHardwareSource *sourcePtr_ = nullptr; + std::shared_ptr hdfDeathCallback_ = nullptr; }; -class FwkDCameraHdfCallback : public IDCameraHdfCallback { -protected: - int32_t NotifyEvent(int32_t devId, const DCameraHDFEvent& event) override; +class HdfOperateManager { +DECLARE_SINGLE_INSTANCE(HdfOperateManager); +public: + int32_t LoadDistributedHDF(DHType dhType); + int32_t UnLoadDistributedHDF(DHType dhType); + int32_t AddDeathRecipient(DHType dhType, sptr &remote); + int32_t RemoveDeathRecipient(DHType dhType, sptr &remote); + void ResetRefCount(DHType dhType); + +private: + std::mutex hdfOperateMapMutex_; + std::map> hdfOperateMap_; + sptr audioHdfLoadRefRecipient_ = sptr(new HdfLoadRefRecipient(DHType::AUDIO)); + sptr cameraHdfLoadRefRecipient_ = sptr(new HdfLoadRefRecipient(DHType::CAMERA)); }; } // namespace DistributedHardware } // namespace OHOS -#endif // OHOS_DCAMERA_HDF_OPERATE_H \ No newline at end of file +#endif // OHOS_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 b05961a4b1202c0de3eaba8d8f25c9c4df8b8989..5eaf2b6bb448b6e222ebd118bb9ebf71dd23f28c 100644 --- a/services/distributedhardwarefwkservice/src/componentmanager/component_manager.cpp +++ b/services/distributedhardwarefwkservice/src/componentmanager/component_manager.cpp @@ -32,8 +32,7 @@ #include "component_enable.h" #include "component_loader.h" #include "constants.h" -#include "daudio_hdf_operate.h" -#include "dcamera_hdf_operate.h" +#include "hdf_operate.h" #include "device_manager.h" #include "dh_context.h" #include "dh_data_sync_trigger_listener.h" @@ -641,9 +640,6 @@ 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); @@ -1747,20 +1743,6 @@ 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 afaa96bc872ca81cd437410ee4286c6fa5c8cdc5..bba3c2785c01014042e42363dbf1b6484295a3a1 100644 --- a/services/distributedhardwarefwkservice/src/distributed_hardware_service.cpp +++ b/services/distributedhardwarefwkservice/src/distributed_hardware_service.cpp @@ -32,8 +32,7 @@ #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 "hdf_operate.h" #include "dh_context.h" #include "dh_utils_tool.h" #include "dh_utils_hisysevent.h" @@ -557,9 +556,8 @@ int32_t DistributedHardwareService::LoadDistributedHDF(const DHType dhType) { switch (dhType) { case DHType::AUDIO: - return DaudioHdfOperate::GetInstance().LoadDaudioHDFImpl(); case DHType::CAMERA: - return DCameraHdfOperate::GetInstance().LoadDcameraHDFImpl(); + return HdfOperateManager::GetInstance().LoadDistributedHDF(dhType); default: break; } @@ -570,9 +568,8 @@ int32_t DistributedHardwareService::UnLoadDistributedHDF(const DHType dhType) { switch (dhType) { case DHType::AUDIO: - return DaudioHdfOperate::GetInstance().UnLoadDaudioHDFImpl(); case DHType::CAMERA: - return DCameraHdfOperate::GetInstance().UnLoadDcameraHDFImpl(); + return HdfOperateManager::GetInstance().UnLoadDistributedHDF(dhType); default: break; } diff --git a/services/distributedhardwarefwkservice/src/distributed_hardware_stub.cpp b/services/distributedhardwarefwkservice/src/distributed_hardware_stub.cpp index 7d87f5e8be84a5a2129d95320050f9edb8930c83..e80494529835500383a130b0bf96ce87289e7d1f 100644 --- a/services/distributedhardwarefwkservice/src/distributed_hardware_stub.cpp +++ b/services/distributedhardwarefwkservice/src/distributed_hardware_stub.cpp @@ -30,6 +30,7 @@ #include "dh_utils_tool.h" #include "distributed_hardware_errno.h" #include "distributed_hardware_log.h" +#include "hdf_operate.h" #include "publisher_listener_proxy.h" namespace OHOS { @@ -553,6 +554,16 @@ int32_t DistributedHardwareStub::LoadDistributedHDFInner(MessageParcel &data, Me } DHType dhType = static_cast(data.ReadUint32()); int32_t ret = LoadDistributedHDF(dhType); + if (ret == DH_FWK_SUCCESS) { + sptr remoteObj = data.ReadRemoteObject(); + if (remoteObj != nullptr) { + ret = HdfOperateManager::GetInstance().AddDeathRecipient(dhType, remoteObj); + if (ret != DH_FWK_SUCCESS) { + DHLOGE("AddDeathRecipient failed!"); + UnLoadDistributedHDF(dhType); + } + } + } if (!reply.WriteInt32(ret)) { DHLOGE("Write ret code failed!"); return ERR_DH_FWK_SERVICE_WRITE_INFO_FAIL; @@ -568,6 +579,15 @@ int32_t DistributedHardwareStub::UnLoadDistributedHDFInner(MessageParcel &data, } DHType dhType = static_cast(data.ReadUint32()); int32_t ret = UnLoadDistributedHDF(dhType); + if (ret == DH_FWK_SUCCESS) { + sptr remoteObj = data.ReadRemoteObject(); + if (remoteObj != nullptr) { + ret = HdfOperateManager::GetInstance().RemoveDeathRecipient(dhType, remoteObj); + if (ret != DH_FWK_SUCCESS) { + DHLOGE("RemoveDeathRecipient failed!"); + } + } + } if (!reply.WriteInt32(ret)) { DHLOGE("Write ret code failed!"); return ERR_DH_FWK_SERVICE_WRITE_INFO_FAIL; diff --git a/services/distributedhardwarefwkservice/src/hdfoperate/daudio_hdf_operate.cpp b/services/distributedhardwarefwkservice/src/hdfoperate/daudio_hdf_operate.cpp deleted file mode 100644 index 3131d0f339cd978baf69e5721184b3b4e46ec1d1..0000000000000000000000000000000000000000 --- a/services/distributedhardwarefwkservice/src/hdfoperate/daudio_hdf_operate.cpp +++ /dev/null @@ -1,258 +0,0 @@ -/* - * 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 deleted file mode 100644 index fc190e65ec3af32c67256d57d462827cf9670ef1..0000000000000000000000000000000000000000 --- a/services/distributedhardwarefwkservice/src/hdfoperate/dcamera_hdf_operate.cpp +++ /dev/null @@ -1,259 +0,0 @@ -/* - * 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/src/hdfoperate/hdf_operate.cpp b/services/distributedhardwarefwkservice/src/hdfoperate/hdf_operate.cpp new file mode 100644 index 0000000000000000000000000000000000000000..6e5e57423c37c137786268aa512ca8b8ac298528 --- /dev/null +++ b/services/distributedhardwarefwkservice/src/hdfoperate/hdf_operate.cpp @@ -0,0 +1,184 @@ +/* + * 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 "hdf_operate.h" + +#include "component_loader.h" +#include "distributed_hardware_errno.h" +#include "distributed_hardware_log.h" + +#undef DH_LOG_TAG +#define DH_LOG_TAG "HdfOperator" + +namespace OHOS { +namespace DistributedHardware { +int32_t HdfOperator::LoadDistributedHDF() +{ + DHLOGI("Load hdf impl begin, dhType = %{public}#X!", dhType_); + std::unique_lock loadRefLocker(hdfLoadRefMutex_); + if (hdfLoadRef_ > 0) { + hdfLoadRef_++; + DHLOGI("The hdf impl has been loaded, just inc ref, dhType = %{public}#X!", dhType_); + return DH_FWK_SUCCESS; + } + auto ret = sourcePtr_->LoadDistributedHDF(hdfDeathCallback_); + if (ret != DH_FWK_SUCCESS) { + DHLOGE("Source handler load hdf failed, dhType = %{public}#X, ret = %{public}d.", dhType_, ret); + return ret; + } + hdfLoadRef_++; + DHLOGI("Load hdf impl end, dhType = %{public}#X!", dhType_); + return DH_FWK_SUCCESS; +} + +int32_t HdfOperator::UnLoadDistributedHDF() +{ + DHLOGI("UnLoad hdf impl begin, dhType = %{public}#X!", dhType_); + std::unique_lock loadRefLocker(hdfLoadRefMutex_); + if (hdfLoadRef_ <= 0) { + DHLOGI("The hdf impl has been unloaded, dhType = %{public}#X!", dhType_); + return DH_FWK_SUCCESS; + } + if (hdfLoadRef_ > 1) { + hdfLoadRef_--; + DHLOGI("The hdf impl has been loaded, just dec ref, dhType = %{public}#X!", dhType_); + return DH_FWK_SUCCESS; + } + auto ret = sourcePtr_->UnLoadDistributedHDF(); + if (ret != DH_FWK_SUCCESS) { + DHLOGE("Source handler unload hdf failed, dhType = %{public}#X, ret = %{public}d.", dhType_, ret); + return ret; + } + hdfLoadRef_--; + DHLOGI("UnLoad hdf impl end, dhType = %{public}#X!", dhType_); + return DH_FWK_SUCCESS; +} + +void HdfOperator::ResetRefCount() +{ + DHLOGI("Reset reference count, dhType = %{public}#X!", dhType_); + std::unique_lock loadRefLocker(hdfLoadRefMutex_); + hdfLoadRef_ = 0; +} + +IMPLEMENT_SINGLE_INSTANCE(HdfOperateManager); + +int32_t HdfOperateManager::LoadDistributedHDF(DHType dhType) +{ + DHLOGI("HdfOperateManager load hdf, dhType = %{public}#X!", dhType); + std::unique_lock hdfOperateMapLocker(hdfOperateMapMutex_); + auto itHdfOperate = hdfOperateMap_.find(dhType); + if (itHdfOperate == hdfOperateMap_.end()) { + IDistributedHardwareSource *sourcePtr = nullptr; + auto ret = ComponentLoader::GetInstance().GetSource(dhType, sourcePtr); + if (ret != DH_FWK_SUCCESS) { + DHLOGE("GetSource failed, compType = %{public}#X, ret = %{public}d.", dhType, ret); + return ret; + } + auto result = hdfOperateMap_.insert( + std::pair>( + dhType, std::make_shared(dhType, sourcePtr))); + itHdfOperate = result.first; + } + auto hdfOperate = itHdfOperate->second; + return hdfOperate->LoadDistributedHDF(); +} + +int32_t HdfOperateManager::UnLoadDistributedHDF(DHType dhType) +{ + DHLOGI("HdfOperateManager unload hdf, dhType = %{public}#X!", dhType); + std::unique_lock hdfOperateMapLocker(hdfOperateMapMutex_); + auto itHdfOperate = hdfOperateMap_.find(dhType); + if (itHdfOperate == hdfOperateMap_.end()) { + DHLOGI("The hdf operate has not been created yet, dhType = %{public}#X!", dhType); + return DH_FWK_SUCCESS; + } + auto hdfOperate = itHdfOperate->second; + return hdfOperate->UnLoadDistributedHDF(); +} + +int32_t HdfOperateManager::AddDeathRecipient(DHType dhType, sptr &remote) +{ + DHLOGI("Add death recipient begin, dhType = %{public}#X!", dhType); + bool ret = false; + switch (dhType) { + case DHType::AUDIO: + ret = remote->AddDeathRecipient(audioHdfLoadRefRecipient_); + break; + case DHType::CAMERA: + ret = remote->AddDeathRecipient(cameraHdfLoadRefRecipient_); + break; + default: + DHLOGE("No hdf support, dhType = %{public}#X.", dhType); + return ERR_DH_FWK_NO_HDF_SUPPORT; + } + if (ret == false) { + DHLOGE("call AddDeathRecipient failed, dhType = %{public}#X.", dhType); + return ERR_DH_FWK_ADD_DEATH_FAIL; + } + DHLOGI("Add death recipient end, dhType = %{public}#X!", dhType); + return DH_FWK_SUCCESS; +} + +int32_t HdfOperateManager::RemoveDeathRecipient(DHType dhType, sptr &remote) +{ + DHLOGI("Remove death recipient begin, dhType = %{public}#X!", dhType); + bool ret = false; + switch (dhType) { + case DHType::AUDIO: + ret = remote->RemoveDeathRecipient(audioHdfLoadRefRecipient_); + break; + case DHType::CAMERA: + ret = remote->RemoveDeathRecipient(cameraHdfLoadRefRecipient_); + break; + default: + DHLOGE("No hdf support, dhType = %{public}#X.", dhType); + return ERR_DH_FWK_NO_HDF_SUPPORT; + } + if (ret == false) { + DHLOGE("call RemoveDeathRecipient failed, dhType = %{public}#X.", dhType); + return ERR_DH_FWK_REMOVE_DEATH_FAIL; + } + DHLOGI("Remove death recipient end, dhType = %{public}#X!", dhType); + return DH_FWK_SUCCESS; +} + +void HdfOperateManager::ResetRefCount(DHType dhType) +{ + DHLOGI("Reset ref count begin, dhType = %{public}#X!", dhType); + std::unique_lock hdfOperateMapLocker(hdfOperateMapMutex_); + auto itHdfOperate = hdfOperateMap_.find(dhType); + if (itHdfOperate == hdfOperateMap_.end()) { + DHLOGI("The hdf operate has not been created yet, dhType = %{public}#X!", dhType); + return; + } + auto hdfOperate = itHdfOperate->second; + hdfOperate->ResetRefCount(); + DHLOGI("reset ref count end, dhType = %{public}#X!", dhType); +} + +void HdfLoadRefRecipient::OnRemoteDied(const wptr &remote) +{ + DHLOGI("On remote died, dhType = %{public}#X!", dhType_); + HdfOperateManager::GetInstance().UnLoadDistributedHDF(dhType_); +} + +void HdfDeathCallbackImpl::OnHdfHostDied() +{ + DHLOGI("On hdf died, dhType = %{public}#X!", dhType_); + HdfOperateManager::GetInstance().ResetRefCount(dhType_); +} +} // namespace DistributedHardware +} // namespace OHOS \ No newline at end of file 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 21f6983850e917ff441fe7c72555d1c349c8a79a..8aa627b431af6450c57ad7a8a19f369febeba365 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 @@ -535,15 +535,11 @@ HWTEST_F(DistributedHardwareServiceTest, QueryDhSysSpec_002, TestSize.Level1) 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)); + service.LoadDistributedHDF(DHType::AUDIO); + 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)); + service.UnLoadDistributedHDF(DHType::AUDIO); + service.UnLoadDistributedHDF(DHType::CAMERA); EXPECT_EQ(ERR_DH_FWK_NO_HDF_SUPPORT, service.UnLoadDistributedHDF(DHType::UNKNOWN)); } } // namespace DistributedHardware 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 a29e6b59ec15dde673509d782b4b314ed317daf6..3f28c25c5658dbd91f425de397df50e3092d867f 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 @@ -707,6 +707,44 @@ HWTEST_F(DistributedHardwareStubTest, LoadDistributedHDFInner_001, TestSize.Leve EXPECT_EQ(DH_FWK_SUCCESS, stubTest_->LoadDistributedHDFInner(data, reply)); } +/** + * @tc.name: LoadDistributedHDFInner_002 + * @tc.desc: Verify the LoadDistributedHDFInner function + * @tc.type: FUNC + * @tc.require: AR000GHSJM + */ +HWTEST_F(DistributedHardwareStubTest, LoadDistributedHDFInner_002, TestSize.Level1) +{ + ASSERT_TRUE(stubTest_ != nullptr); + ASSERT_TRUE(token_ != nullptr); + EXPECT_CALL(*token_, VerifyAccessToken(_, _)).WillRepeatedly(Return(PERMISSION_GRANTED)); + MessageParcel data; + MessageParcel reply; + auto listener = sptr(new MockIPublisherListener()); + data.WriteUint32(static_cast(DHType::AUDIO)); + data.WriteRemoteObject(listener->AsObject()); + EXPECT_EQ(DH_FWK_SUCCESS, stubTest_->LoadDistributedHDFInner(data, reply)); +} + +/** + * @tc.name: LoadDistributedHDFInner_003 + * @tc.desc: Verify the LoadDistributedHDFInner function + * @tc.type: FUNC + * @tc.require: AR000GHSJM + */ +HWTEST_F(DistributedHardwareStubTest, LoadDistributedHDFInner_003, TestSize.Level1) +{ + ASSERT_TRUE(stubTest_ != nullptr); + ASSERT_TRUE(token_ != nullptr); + EXPECT_CALL(*token_, VerifyAccessToken(_, _)).WillRepeatedly(Return(PERMISSION_GRANTED)); + MessageParcel data; + MessageParcel reply; + auto listener = sptr(new MockIPublisherListener()); + data.WriteUint32(static_cast(DHType::CAMERA)); + data.WriteRemoteObject(listener->AsObject()); + EXPECT_EQ(DH_FWK_SUCCESS, stubTest_->LoadDistributedHDFInner(data, reply)); +} + /** * @tc.name: UnLoadDistributedHDFInner_001 * @tc.desc: Verify the UnLoadDistributedHDFInner function @@ -722,5 +760,43 @@ HWTEST_F(DistributedHardwareStubTest, UnLoadDistributedHDFInner_001, TestSize.Le MessageParcel reply; EXPECT_EQ(DH_FWK_SUCCESS, stubTest_->UnLoadDistributedHDFInner(data, reply)); } + +/** + * @tc.name: UnLoadDistributedHDFInner_002 + * @tc.desc: Verify the UnLoadDistributedHDFInner function + * @tc.type: FUNC + * @tc.require: AR000GHSJM + */ +HWTEST_F(DistributedHardwareStubTest, UnLoadDistributedHDFInner_002, TestSize.Level1) +{ + ASSERT_TRUE(stubTest_ != nullptr); + ASSERT_TRUE(token_ != nullptr); + EXPECT_CALL(*token_, VerifyAccessToken(_, _)).WillRepeatedly(Return(PERMISSION_GRANTED)); + MessageParcel data; + MessageParcel reply; + auto listener = sptr(new MockIPublisherListener()); + data.WriteUint32(static_cast(DHType::AUDIO)); + data.WriteRemoteObject(listener->AsObject()); + EXPECT_EQ(DH_FWK_SUCCESS, stubTest_->UnLoadDistributedHDFInner(data, reply)); +} + +/** + * @tc.name: UnLoadDistributedHDFInner_003 + * @tc.desc: Verify the UnLoadDistributedHDFInner function + * @tc.type: FUNC + * @tc.require: AR000GHSJM + */ +HWTEST_F(DistributedHardwareStubTest, UnLoadDistributedHDFInner_003, TestSize.Level1) +{ + ASSERT_TRUE(stubTest_ != nullptr); + ASSERT_TRUE(token_ != nullptr); + EXPECT_CALL(*token_, VerifyAccessToken(_, _)).WillRepeatedly(Return(PERMISSION_GRANTED)); + MessageParcel data; + MessageParcel reply; + auto listener = sptr(new MockIPublisherListener()); + data.WriteUint32(static_cast(DHType::CAMERA)); + data.WriteRemoteObject(listener->AsObject()); + 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 index 9c6564d8f00a7ae9b06e2e511c23468ab4dcc64d..de452ff4ce5a6debfcad57c111a4d6806b034704 100644 --- a/services/distributedhardwarefwkservice/test/unittest/common/hdfoperate/BUILD.gn +++ b/services/distributedhardwarefwkservice/test/unittest/common/hdfoperate/BUILD.gn @@ -27,17 +27,15 @@ config("module_private_config") { "${common_path}/log/include", "${common_path}/utils/include", "${services_path}/distributedhardwarefwkservice/include", + "${services_path}/distributedhardwarefwkservice/include/componentloader", "${services_path}/distributedhardwarefwkservice/include/hdfoperate", ] } -ohos_unittest("DaudioHdfOperateTest") { +ohos_unittest("HdfOperateTest") { module_out_path = module_out_path - sources = [ - "daudio_hdf_operate_test.cpp", - "mock_hdfoperate_device_manager.cpp" - ] + sources = [ "hdf_operate_test.cpp" ] configs = [ ":module_private_config" ] @@ -54,65 +52,14 @@ ohos_unittest("DaudioHdfOperateTest") { defines = [ "HI_LOG_ENABLE", - "DH_LOG_TAG=\"DaudioHdfOperateTest\"", + "DH_LOG_TAG=\"HdfOperateTest\"", "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", @@ -121,8 +68,5 @@ ohos_unittest("DcameraHdfOperateTest") { group("hdf_operate_test") { testonly = true - deps = [ - ":DaudioHdfOperateTest", - ":DcameraHdfOperateTest", - ] + deps = [ ":HdfOperateTest" ] } 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 deleted file mode 100644 index f76f66109854dd15edc4f66ffc18844e46dd0402..0000000000000000000000000000000000000000 --- a/services/distributedhardwarefwkservice/test/unittest/common/hdfoperate/daudio_hdf_operate_test.cpp +++ /dev/null @@ -1,213 +0,0 @@ -/* - * 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 deleted file mode 100644 index 4c18dc64d69fa025f9244d6a76c9c6ceb91fe423..0000000000000000000000000000000000000000 --- a/services/distributedhardwarefwkservice/test/unittest/common/hdfoperate/dcamera_hdf_operate_test.cpp +++ /dev/null @@ -1,180 +0,0 @@ -/* - * 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/hdf_operate_test.cpp b/services/distributedhardwarefwkservice/test/unittest/common/hdfoperate/hdf_operate_test.cpp new file mode 100644 index 0000000000000000000000000000000000000000..363013d3496031510c61aa67ddb549519229edff --- /dev/null +++ b/services/distributedhardwarefwkservice/test/unittest/common/hdfoperate/hdf_operate_test.cpp @@ -0,0 +1,149 @@ +/* + * 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 "component_loader.h" +#include "distributed_hardware_errno.h" +#include "distributed_hardware_log.h" +#include "hdf_operate.h" + +using namespace testing; +using namespace testing::ext; + +namespace OHOS { +namespace DistributedHardware { +class HdfOperateTest : public testing::Test { +public: + static void SetUpTestCase(void); + static void TearDownTestCase(void); + void SetUp(); + void TearDown(); +}; + +constexpr int32_t TEST_COMP_SINK_SA_ID = 4804; +constexpr int32_t TEST_SINK_SA_ID = 12345; +constexpr int32_t TEST_SOURCE_SA_ID = 12345; + +void HdfOperateTest::SetUpTestCase(void) +{ + DHLOGI("HdfOperateTest::SetUpTestCase"); +} + +void HdfOperateTest::TearDownTestCase(void) +{ + DHLOGI("HdfOperateTest::TearDownTestCase"); +} + +void HdfOperateTest::SetUp(void) +{ + DHLOGI("HdfOperateTest::SetUp"); +} + +void HdfOperateTest::TearDown(void) +{ + DHLOGI("HdfOperateTest::TearDown"); +} + +static void SetUpComponentLoaderConfig() +{ + if (ComponentLoader::GetInstance().compHandlerMap_.find(DHType::AUDIO) + == ComponentLoader::GetInstance().compHandlerMap_.end()) { + CompHandler handler; + handler.compConfig.name = "distributed_audio"; + handler.compConfig.type = DHType::AUDIO; + handler.compConfig.compHandlerLoc = "libdistributed_camera_handler.z.so"; + handler.compConfig.compHandlerVersion = "1.0"; + handler.compConfig.compSourceLoc = "libdistributed_camera_source_sdk.z.so"; + handler.compConfig.compSourceVersion = "1.0"; + handler.compConfig.compSinkLoc = "libdistributed_camera_sink_sdk.z.so"; + handler.compConfig.compSinkVersion = "2.0"; + handler.compConfig.compSinkSaId = TEST_COMP_SINK_SA_ID; + handler.compConfig.haveFeature = false; + handler.hardwareHandler = nullptr; + handler.sourceHandler = nullptr; + handler.sinkHandler = nullptr; + handler.type = DHType::AUDIO; + handler.sinkSaId = TEST_SINK_SA_ID; + handler.sourceSaId = TEST_SOURCE_SA_ID; + ComponentLoader::GetInstance().compHandlerMap_[DHType::AUDIO] = handler; + } +} + +static void SetDownComponentLoaderConfig() +{ + auto itHandler = ComponentLoader::GetInstance().compHandlerMap_.find(DHType::AUDIO); + if (itHandler != ComponentLoader::GetInstance().compHandlerMap_.end()) { + CompHandler &handler = itHandler->second; + if (handler.sinkSaId == TEST_SINK_SA_ID && handler.sourceSaId == TEST_SOURCE_SA_ID) { + ComponentLoader::GetInstance().compHandlerMap_.erase(itHandler); + } + } +} + +/** + * @tc.name: LoadDistributedHDF_001 + * @tc.desc: Verify LoadDistributedHDF func + * @tc.type: FUNC + * @tc.require: AR000GHSJM + */ +HWTEST_F(HdfOperateTest, LoadDistributedHDF_001, TestSize.Level1) +{ + DHLOGI("HdfOperateTest::LoadDistributedHDF_001"); + SetUpComponentLoaderConfig(); + EXPECT_EQ(DH_FWK_SUCCESS, HdfOperateManager::GetInstance().LoadDistributedHDF(DHType::AUDIO)); + EXPECT_EQ(DH_FWK_SUCCESS, HdfOperateManager::GetInstance().LoadDistributedHDF(DHType::AUDIO)); + EXPECT_EQ(DH_FWK_SUCCESS, HdfOperateManager::GetInstance().UnLoadDistributedHDF(DHType::AUDIO)); + EXPECT_EQ(DH_FWK_SUCCESS, HdfOperateManager::GetInstance().UnLoadDistributedHDF(DHType::AUDIO)); + SetDownComponentLoaderConfig(); +} + +/** + * @tc.name: UnLoadDistributedHDF_001 + * @tc.desc: Verify UnLoadDistributedHDF func + * @tc.type: FUNC + * @tc.require: AR000GHSJM + */ +HWTEST_F(HdfOperateTest, UnLoadDistributedHDF_001, TestSize.Level1) +{ + DHLOGI("HdfOperateTest::UnLoadDistributedHDF_001"); + HdfOperateManager::GetInstance().ResetRefCount(DHType::AUDIO); + int32_t ret = HdfOperateManager::GetInstance().UnLoadDistributedHDF(DHType::AUDIO); + EXPECT_EQ(DH_FWK_SUCCESS, ret); +} + +/** + * @tc.name: ResetRefCount_001 + * @tc.desc: Verify ResetRefCount func + * @tc.type: FUNC + * @tc.require: AR000GHSJM + */ +HWTEST_F(HdfOperateTest, ResetRefCount_001, TestSize.Level1) +{ + DHLOGI("HdfOperateTest::ResetRefCount_001"); + SetUpComponentLoaderConfig(); + HdfOperateManager::GetInstance().hdfOperateMap_.clear(); + HdfOperateManager::GetInstance().ResetRefCount(DHType::AUDIO); + int32_t ret = HdfOperateManager::GetInstance().LoadDistributedHDF(DHType::AUDIO); + EXPECT_EQ(DH_FWK_SUCCESS, ret); + HdfOperateManager::GetInstance().ResetRefCount(DHType::AUDIO); + ret = HdfOperateManager::GetInstance().LoadDistributedHDF(DHType::AUDIO); + EXPECT_EQ(DH_FWK_SUCCESS, ret); + ret = HdfOperateManager::GetInstance().UnLoadDistributedHDF(DHType::AUDIO); + SetDownComponentLoaderConfig(); + 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 deleted file mode 100644 index 9856b298965d0611c8d890694772ed96a465d84e..0000000000000000000000000000000000000000 --- a/services/distributedhardwarefwkservice/test/unittest/common/hdfoperate/mock_hdfoperate_device_manager.cpp +++ /dev/null @@ -1,48 +0,0 @@ -/* - * 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 deleted file mode 100644 index 06b5d2b10b160b0aa5c82d9dc215566d1300f390..0000000000000000000000000000000000000000 --- a/services/distributedhardwarefwkservice/test/unittest/common/hdfoperate/mock_hdfoperate_device_manager.h +++ /dev/null @@ -1,39 +0,0 @@ -/* - * 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