diff --git a/services/BUILD.gn b/services/BUILD.gn index c486da12c5064d273afadce82385246a218c856f..2519186f18a5c035ae48300dfbabf858284024f4 100644 --- a/services/BUILD.gn +++ b/services/BUILD.gn @@ -38,23 +38,6 @@ ohos_shared_library("driver_extension_manager") { part_name = "external_device_manager" } -ohos_shared_library("bus_extension_core") { - install_enable = true - sources = [ - "native/driver_extension_manager/src/device_manager/etx_device_mgr.cpp", - ] - - include_dirs = [ "${ext_mgr_path}/services/native/driver_extension_manager/include/device_manager" ] - configs = [ "${utils_path}:utils_config" ] - external_deps = [ - "bundle_framework:appexecfwk_base", - "c_utils:utils", - ] - - subsystem_name = "hdf" - part_name = "external_device_manager" -} - config("drvext_manager_public_config") { include_dirs = [ "native/driver_extension_manager/include/bus_extension/usb" ] } diff --git a/services/native/driver_extension_manager/include/device_manager/etx_device_mgr.h b/services/native/driver_extension_manager/include/device_manager/etx_device_mgr.h index f85686e8aab118d87661cba9d41c89c9fc16e513..eb42ca8fbe586ebecdd38fed3ded0811738fe94c 100644 --- a/services/native/driver_extension_manager/include/device_manager/etx_device_mgr.h +++ b/services/native/driver_extension_manager/include/device_manager/etx_device_mgr.h @@ -14,9 +14,10 @@ */ #ifndef DEVICE_MANAGER_ETX_DEVICE_MGR_H #define DEVICE_MANAGER_ETX_DEVICE_MGR_H -#include #include #include +#include +#include #include "ext_object.h" namespace OHOS { @@ -26,6 +27,10 @@ public: Device(std::shared_ptr info) : info_(info) {}; bool HasDriver() const; + std::shared_ptr GetDeviceInfo() const + { + return info_; + } private: std::shared_ptr driver_; @@ -33,16 +38,15 @@ private: }; class ExtDeviceManager final { -public: DECLARE_DELAYED_SINGLETON(ExtDeviceManager) - +public: int32_t Init(); - Device &RegisterDevice(const DeviceInfo &devInfo); - void UnRegisterDevice(const DeviceInfo &devInfo); + int32_t RegisterDevice(std::shared_ptr devInfo); + void UnRegisterDevice(const std::shared_ptr devInfo); private: - std::forward_list deviceList_; - std::mutex deviceListMutex_; + std::unordered_map>> deviceMap_; + std::mutex deviceMapMutex_; }; } // namespace ExternalDeviceManager } // namespace OHOS diff --git a/services/native/driver_extension_manager/src/bus_extension/BUILD.gn b/services/native/driver_extension_manager/src/bus_extension/BUILD.gn index b9984dee315ded281ee2ea905257c6cd59dc8e97..603e0960b8e71deb1dc83b8802706d1de0a6d874 100644 --- a/services/native/driver_extension_manager/src/bus_extension/BUILD.gn +++ b/services/native/driver_extension_manager/src/bus_extension/BUILD.gn @@ -28,7 +28,7 @@ ohos_shared_library("bus_extension") { "${utils_path}:utils_config", ] deps = [ - "${ext_mgr_path}/services:bus_extension_core", + "${ext_mgr_path}/services/native/driver_extension_manager/src/device_manager:bus_extension_core", "//third_party/jsoncpp:jsoncpp", ] external_deps = [ diff --git a/services/native/driver_extension_manager/src/device_manager/BUILD.gn b/services/native/driver_extension_manager/src/device_manager/BUILD.gn new file mode 100644 index 0000000000000000000000000000000000000000..e9d87fa4d217c10be9092d495443b8324372ae87 --- /dev/null +++ b/services/native/driver_extension_manager/src/device_manager/BUILD.gn @@ -0,0 +1,30 @@ +# Copyright (c) 2023 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("../../../../../extdevmgr.gni") + +ohos_shared_library("bus_extension_core") { + install_enable = true + sources = [ "etx_device_mgr.cpp" ] + + include_dirs = [ "${ext_mgr_path}/services/native/driver_extension_manager/include/device_manager" ] + configs = [ "${utils_path}:utils_config" ] + external_deps = [ + "bundle_framework:appexecfwk_base", + "c_utils:utils", + "hiviewdfx_hilog_native:libhilog", + ] + + subsystem_name = "hdf" + part_name = "external_device_manager" +} diff --git a/services/native/driver_extension_manager/src/device_manager/etx_device_mgr.cpp b/services/native/driver_extension_manager/src/device_manager/etx_device_mgr.cpp index 17edd020a62a0e764cb300853100e03e670e29d4..505475bf46bfbfcb4c005998d22618d6af6a64b4 100644 --- a/services/native/driver_extension_manager/src/device_manager/etx_device_mgr.cpp +++ b/services/native/driver_extension_manager/src/device_manager/etx_device_mgr.cpp @@ -14,6 +14,9 @@ */ #include "etx_device_mgr.h" +#include "edm_errors.h" +#include "hilog_wrapper.h" +#include "ibus_extension.h" namespace OHOS { namespace ExternalDeviceManager { @@ -21,19 +24,113 @@ BusExtensionCore::BusExtensionCore() { return; } + BusExtensionCore::~BusExtensionCore() { return; } +ExtDeviceManager::~ExtDeviceManager() +{ + return; +} + +ExtDeviceManager::ExtDeviceManager() +{ + return; +} + int32_t BusExtensionCore::Init() { - return 0; + int ret = EDM_OK; + for (auto &iter : busExtensions_) { + std::shared_ptr callback = + std::make_shared(iter.first, DelayedSingleton::GetInstance()); + if (iter.second->SetDevChangeCallback(callback) != EDM_OK) { + ret = EDM_NOK; + EDM_LOGE(MODULE_DEV_MGR, "busExtension init failed, busType is %{public}d", iter.first); + } + } + return ret; +} + +int32_t BusExtensionCore::Register(BusType busType, std::shared_ptr busExtension) +{ + if (busExtensions_.size() == MAX_BUS_EXTENSIONS) { + EDM_LOGE(MODULE_DEV_MGR, "the maximum number of busextension registrations has been reached"); + return EDM_NOK; + } + if (busExtensions_.count(busType) > 0) { + EDM_LOGI(MODULE_DEV_MGR, "busType %{public}d has been registered", busType); + return EDM_OK; + } + busExtensions_.insert(std::make_pair(busType, busExtension)); + EDM_LOGI(MODULE_DEV_MGR, "busType %{public}d register successfully", busType); + return EDM_OK; } -int32_t BusExtensionCore::Register( - BusType busType, std::shared_ptr busExtension) + +int32_t ExtDeviceManager::Init() +{ + EDM_LOGI(MODULE_DEV_MGR, "ExtDeviceManager Init start"); + return EDM_OK; +} + +int32_t ExtDeviceManager::RegisterDevice(std::shared_ptr devInfo) +{ + BusType type = devInfo->GetBusType(); + uint64_t deviceId = devInfo->GetDeviceId(); + std::lock_guard lock(deviceMapMutex_); + if (deviceMap_.count(type) > 0) { + std::list> &list = deviceMap_[type]; + std::list>::iterator iter; + for (iter = list.begin(); iter != list.end(); iter++) { + std::shared_ptr device = *iter; + if (device->GetDeviceInfo()->GetDeviceId() == deviceId) { + EDM_LOGI(MODULE_DEV_MGR, "device has been registered, deviceId is %{public}llu", deviceId); + return EDM_OK; + } + } + } + std::shared_ptr device = std::make_shared(devInfo); + deviceMap_[type].push_back(device); + EDM_LOGI(MODULE_DEV_MGR, "successfully registered device, deviceId is %{public}llu", deviceId); + // driver match + return EDM_OK; +} + +void ExtDeviceManager::UnRegisterDevice(const std::shared_ptr devInfo) +{ + BusType type = devInfo->GetBusType(); + uint64_t deviceId = devInfo->GetDeviceId(); + std::lock_guard lock(deviceMapMutex_); + if (deviceMap_.count(type) > 0) { + std::list> &list = deviceMap_[type]; + std::list>::iterator iter; + for (iter = list.begin(); iter != list.end(); iter++) { + std::shared_ptr device = *iter; + if (device->GetDeviceInfo()->GetDeviceId() == deviceId) { + iter = list.erase(iter); + EDM_LOGI(MODULE_DEV_MGR, "successfully unregistered device, deviceId is %{public}llu", deviceId); + return; + } + } + } + EDM_LOGI(MODULE_DEV_MGR, "device has been unregistered, deviceId is %{public}llu", deviceId); +} + +int32_t DevChangeCallback::OnDeviceAdd(std::shared_ptr device) +{ + EDM_LOGI(MODULE_DEV_MGR, "OnDeviceAdd start"); + device->devInfo_.devBusInfo.busType = this->busType_; + return this->extDevMgr_->RegisterDevice(device); +} + +int32_t DevChangeCallback::OnDeviceRemove(std::shared_ptr device) { - return 0; + EDM_LOGI(MODULE_DEV_MGR, "OnDeviceRemove start"); + device->devInfo_.devBusInfo.busType = this->busType_; + this->extDevMgr_->UnRegisterDevice(device); + return EDM_OK; } } // namespace ExternalDeviceManager } // namespace OHOS \ No newline at end of file diff --git a/test/unittest/BUILD.gn b/test/unittest/BUILD.gn index c2849598b5b8fea87ec08705083139827a4b3dce..276e56742fdc0884d5a6bc32cb3cda8955b761b1 100644 --- a/test/unittest/BUILD.gn +++ b/test/unittest/BUILD.gn @@ -103,5 +103,6 @@ group("external_device_manager_test") { ":bus_extension_test", ":driver_extension_controller_test", ":drivers_pkg_manager_test", + "device_manager_test:device_manager_test", ] } diff --git a/test/unittest/device_manager_test/BUILD.gn b/test/unittest/device_manager_test/BUILD.gn new file mode 100644 index 0000000000000000000000000000000000000000..435eec79b7ddd1f0aa4c25cdf19c6d31bf6a0050 --- /dev/null +++ b/test/unittest/device_manager_test/BUILD.gn @@ -0,0 +1,39 @@ +# Copyright (c) 2023 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("//drivers/external_device_manager/extdevmgr.gni") +module_output_path = "external_device_manager/unittest" +device_manager_include_path = "${ext_mgr_path}/services/native/driver_extension_manager/include/device_manager" +bus_extension_include_path = "${ext_mgr_path}/services/native/driver_extension_manager/include/bus_extension/usb" +utils_include_path = "${ext_mgr_path}/utils/include" + +ohos_unittest("device_manager_test") { + module_out_path = "${module_output_path}" + sources = [ "device_manager_test.cpp" ] + include_dirs = [ + "${device_manager_include_path}", + "${bus_extension_include_path}", + "${utils_include_path}", + ] + deps = [ + "${ext_mgr_path}/services/native/driver_extension_manager/src/bus_extension:bus_extension", + "${ext_mgr_path}/services/native/driver_extension_manager/src/device_manager:bus_extension_core", + ] + external_deps = [ + "c_utils:utils", + "drivers_interface_usb:libusb_proxy_1.0", + "hiviewdfx_hilog_native:libhilog", + ] + configs = [ "${utils_path}:utils_config" ] +} diff --git a/test/unittest/device_manager_test/device_manager_test.cpp b/test/unittest/device_manager_test/device_manager_test.cpp new file mode 100644 index 0000000000000000000000000000000000000000..f6fd468c50496e67cd5fa5d2be645371c506b096 --- /dev/null +++ b/test/unittest/device_manager_test/device_manager_test.cpp @@ -0,0 +1,118 @@ +/* + * Copyright (c) 2023 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 "edm_errors.h" +#include "hilog_wrapper.h" +#define private public +#include "etx_device_mgr.h" +#include "ibus_extension.h" +#include "usb_bus_extension.h" +#undef private + +namespace OHOS { +namespace ExternalDeviceManager { +using namespace std; +using namespace testing::ext; + +class DeviceManagerTest : public testing::Test { +public: + void SetUp() override + { + EDM_LOGD(MODULE_DEV_MGR, "DeviceManagerTest SetUp"); + } + void TearDown() override + { + EDM_LOGD(MODULE_DEV_MGR, "DeviceManagerTest TearDown"); + } +}; + +HWTEST_F(DeviceManagerTest, BusExtensionRegisterTest, TestSize.Level1) +{ + std::shared_ptr core = DelayedSingleton::GetInstance(); + int32_t ret = core->Register(BusType::BUS_TYPE_USB, std::make_shared()); + ASSERT_EQ(ret, EDM_OK); + ASSERT_NE(core->busExtensions_[BusType::BUS_TYPE_USB], nullptr); +} + +HWTEST_F(DeviceManagerTest, InitTest, TestSize.Level1) +{ + int32_t ret = DelayedSingleton::GetInstance()->Init(); + ASSERT_EQ(ret, EDM_OK); +} + +// test OnDeviceAdd and OnDeviceRemove +HWTEST_F(DeviceManagerTest, OnDeviceAddRemoveTest001, TestSize.Level1) +{ + std::shared_ptr callback = + std::make_shared(BusType::BUS_TYPE_TEST, DelayedSingleton::GetInstance()); + std::shared_ptr device = std::make_shared(0); + device->devInfo_.devBusInfo.busType = BusType::BUS_TYPE_TEST; + device->devInfo_.devBusInfo.busDeviceId = 1; + int32_t ret = callback->OnDeviceAdd(device); + ASSERT_EQ(ret, EDM_OK); + std::shared_ptr extMgr = DelayedSingleton::GetInstance(); + ASSERT_EQ(extMgr->deviceMap_[BusType::BUS_TYPE_TEST].size(), 1); + ret = callback->OnDeviceRemove(device); + ASSERT_EQ(ret, EDM_OK); + ASSERT_EQ(extMgr->deviceMap_[BusType::BUS_TYPE_TEST].size(), 0); +} + +// test adding device repeatedly +HWTEST_F(DeviceManagerTest, OnDeviceAddRemoveTest002, TestSize.Level1) +{ + std::shared_ptr callback = + std::make_shared(BusType::BUS_TYPE_TEST, DelayedSingleton::GetInstance()); + std::shared_ptr device = std::make_shared(0); + device->devInfo_.devBusInfo.busType = BusType::BUS_TYPE_TEST; + device->devInfo_.devBusInfo.busDeviceId = 1; + int32_t ret = callback->OnDeviceAdd(device); + ASSERT_EQ(ret, EDM_OK); + ret = callback->OnDeviceAdd(device); + ASSERT_EQ(ret, EDM_OK); + std::shared_ptr extMgr = DelayedSingleton::GetInstance(); + ASSERT_EQ(extMgr->deviceMap_[BusType::BUS_TYPE_TEST].size(), 1); + ret = callback->OnDeviceRemove(device); + ASSERT_EQ(ret, EDM_OK); + ASSERT_EQ(extMgr->deviceMap_[BusType::BUS_TYPE_TEST].size(), 0); + ret = callback->OnDeviceRemove(device); + ASSERT_EQ(ret, EDM_OK); +} + +HWTEST_F(DeviceManagerTest, OnDeviceAddRemoveTest003, TestSize.Level1) +{ + std::shared_ptr callback = + std::make_shared(BusType::BUS_TYPE_TEST, DelayedSingleton::GetInstance()); + std::shared_ptr device0 = std::make_shared(0); + device0->devInfo_.devBusInfo.busType = BusType::BUS_TYPE_TEST; + device0->devInfo_.devBusInfo.busDeviceId = 1; + int32_t ret = callback->OnDeviceAdd(device0); + ASSERT_EQ(ret, EDM_OK); + std::shared_ptr device1 = std::make_shared(0); + device1->devInfo_.devBusInfo.busType = BusType::BUS_TYPE_TEST; + device1->devInfo_.devBusInfo.busDeviceId = 2; + ret = callback->OnDeviceAdd(device1); + ASSERT_EQ(ret, EDM_OK); + std::shared_ptr extMgr = DelayedSingleton::GetInstance(); + ASSERT_EQ(extMgr->deviceMap_[BusType::BUS_TYPE_TEST].size(), 2); + ret = callback->OnDeviceRemove(device1); + ASSERT_EQ(ret, EDM_OK); + ASSERT_EQ(extMgr->deviceMap_[BusType::BUS_TYPE_TEST].size(), 1); + ret = callback->OnDeviceRemove(device0); + ASSERT_EQ(ret, EDM_OK); + ASSERT_EQ(extMgr->deviceMap_[BusType::BUS_TYPE_TEST].size(), 0); +} +} // namespace ExternalDeviceManager +} // namespace OHOS diff --git a/utils/include/ext_object.h b/utils/include/ext_object.h index 12acd1feb11a043c641dfd177ceece85411a89d8..94d852518df80a502f3e27782887ff7595beff2c 100644 --- a/utils/include/ext_object.h +++ b/utils/include/ext_object.h @@ -23,6 +23,7 @@ namespace ExternalDeviceManager { enum BusType : uint32_t { BUS_TYPE_INVALID = 0, BUS_TYPE_USB = 1, + BUS_TYPE_TEST, }; class IBusExtension; class DrvBundleStateCallback;