From 2747ad701d3d6392c51aaaa730d8f23ff53dec62 Mon Sep 17 00:00:00 2001 From: yuhaoqiang <690364942@qq.com> Date: Fri, 27 Oct 2023 16:01:26 +0800 Subject: [PATCH 1/2] =?UTF-8?q?=E8=93=9D=E5=8C=BA=E9=80=89=E7=BD=91?= =?UTF-8?q?=E6=A1=86=E6=9E=B6?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: yuhaoqiang <690364942@qq.com> --- .../native/interfaces/i_wifi_device.h | 56 +++ .../native/interfaces/network_selection_msg.h | 46 +++ .../wifi_manager_service_ipc_interface_code.h | 2 + .../native/src/wifi_device_impl.cpp | 45 +++ wifi/frameworks/native/src/wifi_device_impl.h | 54 +++ .../native/src/wifi_device_proxy.cpp | 79 ++++ .../frameworks/native/src/wifi_device_proxy.h | 54 +++ wifi/interfaces/inner_api/wifi_device.h | 55 +++ wifi/interfaces/inner_api/wifi_msg.h | 8 + .../wifi_manage/wifi_device_service_impl.cpp | 88 +++++ .../wifi_manage/wifi_device_service_impl.h | 14 + .../wifi_manage/wifi_device_stub.cpp | 22 ++ .../wifi_manage/wifi_device_stub.h | 2 + .../wifi_manage/wifi_sta/BUILD.gn | 10 + .../wifi_manage/wifi_sta/ista_service.h | 56 +++ .../network_filter_builder_manager.cpp | 63 ++++ .../network_filter_builder_manager.h | 56 +++ .../network_selection_manager.cpp | 117 ++++++ .../network_selection_manager.h | 80 ++++ .../network_selection_utils.cpp | 177 +++++++++ .../network_select/network_selection_utils.h | 176 +++++++++ .../network_select/network_selector.cpp | 357 ++++++++++++++++++ .../network_select/network_selector.h | 194 ++++++++++ .../network_selector_comparator.cpp | 143 +++++++ .../network_selector_comparator.h | 71 ++++ .../network_selector_factory.cpp | 47 +++ .../network_select/network_selector_factory.h | 49 +++ .../network_selector_filter.cpp | 104 +++++ .../network_select/network_selector_filter.h | 104 +++++ .../network_selector_scorer.cpp | 257 +++++++++++++ .../network_select/network_selector_scorer.h | 187 +++++++++ .../network_status_history_manager.cpp | 130 +++++++ .../wifi_sta/network_status_history_manager.h | 136 +++++++ .../wifi_sta/sta_auto_connect_service.cpp | 88 ++++- .../wifi_sta/sta_auto_connect_service.h | 46 +++ .../wifi_manage/wifi_sta/sta_interface.cpp | 50 +++ .../wifi_manage/wifi_sta/sta_interface.h | 54 +++ .../wifi_manage/wifi_sta/sta_service.cpp | 46 +++ .../wifi_manage/wifi_sta/sta_service.h | 54 +++ .../wifi_sta/sta_state_machine.cpp | 55 ++- .../wifi_manage/wifi_sta/sta_state_machine.h | 7 +- .../config/wifi_config_file_spec.cpp | 16 + .../wifi_toolkit/include/inter_scan_info.h | 125 ++++++ .../wifi_toolkit/include/wifi_internal_msg.h | 109 +----- wifi/test/wifi_client/BUILD.gn | 1 + .../wifi_manage/wifi_sta/BUILD.gn | 10 + 46 files changed, 3577 insertions(+), 123 deletions(-) create mode 100644 wifi/frameworks/native/interfaces/network_selection_msg.h create mode 100644 wifi/services/wifi_standard/wifi_framework/wifi_manage/wifi_sta/network_select/network_filter_builder_manager.cpp create mode 100644 wifi/services/wifi_standard/wifi_framework/wifi_manage/wifi_sta/network_select/network_filter_builder_manager.h create mode 100644 wifi/services/wifi_standard/wifi_framework/wifi_manage/wifi_sta/network_select/network_selection_manager.cpp create mode 100644 wifi/services/wifi_standard/wifi_framework/wifi_manage/wifi_sta/network_select/network_selection_manager.h create mode 100644 wifi/services/wifi_standard/wifi_framework/wifi_manage/wifi_sta/network_select/network_selection_utils.cpp create mode 100644 wifi/services/wifi_standard/wifi_framework/wifi_manage/wifi_sta/network_select/network_selection_utils.h create mode 100644 wifi/services/wifi_standard/wifi_framework/wifi_manage/wifi_sta/network_select/network_selector.cpp create mode 100644 wifi/services/wifi_standard/wifi_framework/wifi_manage/wifi_sta/network_select/network_selector.h create mode 100644 wifi/services/wifi_standard/wifi_framework/wifi_manage/wifi_sta/network_select/network_selector_comparator.cpp create mode 100644 wifi/services/wifi_standard/wifi_framework/wifi_manage/wifi_sta/network_select/network_selector_comparator.h create mode 100644 wifi/services/wifi_standard/wifi_framework/wifi_manage/wifi_sta/network_select/network_selector_factory.cpp create mode 100644 wifi/services/wifi_standard/wifi_framework/wifi_manage/wifi_sta/network_select/network_selector_factory.h create mode 100644 wifi/services/wifi_standard/wifi_framework/wifi_manage/wifi_sta/network_select/network_selector_filter.cpp create mode 100644 wifi/services/wifi_standard/wifi_framework/wifi_manage/wifi_sta/network_select/network_selector_filter.h create mode 100644 wifi/services/wifi_standard/wifi_framework/wifi_manage/wifi_sta/network_select/network_selector_scorer.cpp create mode 100644 wifi/services/wifi_standard/wifi_framework/wifi_manage/wifi_sta/network_select/network_selector_scorer.h create mode 100644 wifi/services/wifi_standard/wifi_framework/wifi_manage/wifi_sta/network_status_history_manager.cpp create mode 100644 wifi/services/wifi_standard/wifi_framework/wifi_manage/wifi_sta/network_status_history_manager.h create mode 100644 wifi/services/wifi_standard/wifi_framework/wifi_toolkit/include/inter_scan_info.h diff --git a/wifi/frameworks/native/interfaces/i_wifi_device.h b/wifi/frameworks/native/interfaces/i_wifi_device.h index 0b16f9426..34b575292 100644 --- a/wifi/frameworks/native/interfaces/i_wifi_device.h +++ b/wifi/frameworks/native/interfaces/i_wifi_device.h @@ -23,6 +23,7 @@ #endif #include "i_wifi_device_callback.h" #include "wifi_errcode.h" +#include "network_selection_msg.h" namespace OHOS { namespace Wifi { @@ -379,6 +380,61 @@ public: * @return ErrCode - operation result */ virtual ErrCode ResetAllFrozenApp() = 0; + + /** + * @Description disable auto join. + * + * @param conditionName autoJoinDisabled condition. + * @return WifiErrorNo + */ + virtual ErrCode DisableAutoJoin(const std::string &conditionName) = 0; + + /** + * @Description enable auto join. + * + * @param conditionName autoJoinDisabled condition. + * @return WifiErrorNo + */ + virtual ErrCode EnableAutoJoin(const std::string &conditionName) = 0; + + /** + * @Description register auto join condition. + * + * @param conditionName the name of condition. + * @param autoJoinCondition condition. + * @return WifiErrorNo + */ + virtual ErrCode RegisterAutoJoinCondition(const std::string &conditionName, + const std::function &autoJoinCondition) = 0; + + /** + * @Description deregister auto join condition. + * + * @param conditionName the name of condition. + * @return WifiErrorNo + */ + virtual ErrCode DeregisterAutoJoinCondition(const std::string &conditionName) = 0; + + /** + * @Description register external filter builder. + * + * @param filterTag filterTag which define where the filter should be inserted. + * @param filterName the name of the filter to build. + * @param filterBuilder filter builder. + * @return WifiErrorNo + */ + virtual ErrCode RegisterFilterBuilder(const FilterTag &filterTag, const std::string &filterName, + const filter_builder &filterBuilder) = 0; + + /** + * @Description deregister external filter builder. + * + * @param filterTag filterTag which define where the filter should be inserted. + * @param filterName the name of the filter to build. + * @return WifiErrorNo + */ + virtual ErrCode DeregisterFilterBuilder(const FilterTag &filterTag, const std::string &filterName) = 0; + /** * @Description start portal certification * diff --git a/wifi/frameworks/native/interfaces/network_selection_msg.h b/wifi/frameworks/native/interfaces/network_selection_msg.h new file mode 100644 index 000000000..388837150 --- /dev/null +++ b/wifi/frameworks/native/interfaces/network_selection_msg.h @@ -0,0 +1,46 @@ +/* + * Copyright (C) 2021-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. + */ + +#ifndef OHOS_WIFI_NETWORK_SELECTION_MSG_H_ +#define OHOS_WIFI_NETWORK_SELECTION_MSG_H_ + +#include "wifi_msg.h" +#include "inter_scan_info.h" +#include +#include + +namespace OHOS { +namespace Wifi { +struct NetworkCandidate +{ + const InterScanInfo &interScanInfo; + WifiDeviceConfig wifiDeviceConfig; + std::vector filteredMsg; + std::vector nominateMsg; +}; + +enum class FilterTag +{ + SAVED_NETWORK_SELECTOR_FILTER_TAG, + HAS_INTERNET_NETWORK_SELECTOR_FILTER_TAG, + RECOVERY_NETWORK_SELECTOR_FILTER_TAG, + PORTAL_NETWORK_SELECTOR_FILTER_TAG +}; + +using filter_func = std::function; +using filter_builder = std::function; +} +} +#endif diff --git a/wifi/frameworks/native/interfaces/wifi_manager_service_ipc_interface_code.h b/wifi/frameworks/native/interfaces/wifi_manager_service_ipc_interface_code.h index e4127ee51..d2b8030d2 100644 --- a/wifi/frameworks/native/interfaces/wifi_manager_service_ipc_interface_code.h +++ b/wifi/frameworks/native/interfaces/wifi_manager_service_ipc_interface_code.h @@ -62,6 +62,8 @@ enum class DevInterfaceCode { WIFI_SVR_CMD_IS_HELD_WIFI_PROTECT = 0x1036, /* is held the Wi-Fi protect. */ WIFI_SVR_CMD_IS_SET_FACTORY_RESET = 0x1037, /* factory reset */ WIFI_SVR_CMD_IS_METERED_HOTSPOT = 0x1038, /* whether current link is metered hotspot */ + WIFI_SVR_CMD_DISABLE_AUTO_JOIN = 0x1039, /* disable auto join */ + WIFI_SVR_CMD_ENABLE_AUTO_JOIN = 0x103A, /* enable auto join */ /* 新增WIFI_SVR_CMD_类code，请在此下方添加 */ /* 以下CALL BACK类code，不需要进行权限校验 */ diff --git a/wifi/frameworks/native/src/wifi_device_impl.cpp b/wifi/frameworks/native/src/wifi_device_impl.cpp index 36367dc78..c42e2d2c4 100644 --- a/wifi/frameworks/native/src/wifi_device_impl.cpp +++ b/wifi/frameworks/native/src/wifi_device_impl.cpp @@ -451,6 +451,51 @@ ErrCode WifiDeviceImpl::ResetAllFrozenApp() return client_->ResetAllFrozenApp(); } +ErrCode WifiDeviceImpl::DisableAutoJoin(const std::string &conditionName) +{ + std::lock_guard lock(mutex_); + RETURN_IF_FAIL(GetWifiDeviceProxy()); + return client_->DisableAutoJoin(conditionName); +} + +ErrCode WifiDeviceImpl::EnableAutoJoin(const std::string &conditionName) +{ + std::lock_guard lock(mutex_); + RETURN_IF_FAIL(GetWifiDeviceProxy()); + return client_->EnableAutoJoin(conditionName); +} + +ErrCode WifiDeviceImpl::RegisterAutoJoinCondition(const std::string &conditionName, + const std::function &autoJoinCondition) +{ + std::lock_guard lock(mutex_); + RETURN_IF_FAIL(GetWifiDeviceProxy()); + return client_->RegisterAutoJoinCondition(conditionName, autoJoinCondition); +} + +ErrCode WifiDeviceImpl::DeregisterAutoJoinCondition(const std::string &conditionName) +{ + std::lock_guard lock(mutex_); + RETURN_IF_FAIL(GetWifiDeviceProxy()); + return client_->DeregisterAutoJoinCondition(conditionName); +} + +ErrCode WifiDeviceImpl::RegisterFilterBuilder(const FilterTag &filterTag, + const std::string &filterName, + const filter_builder &filterBuilder) +{ + std::lock_guard lock(mutex_); + RETURN_IF_FAIL(GetWifiDeviceProxy()); + return client_->RegisterFilterBuilder(filterTag, filterName, filterBuilder); +} + +ErrCode WifiDeviceImpl::DeregisterFilterBuilder(const FilterTag &filterTag, const std::string &filterName) +{ + std::lock_guard lock(mutex_); + RETURN_IF_FAIL(GetWifiDeviceProxy()); + return client_->DeregisterFilterBuilder(filterTag, filterName); +} + bool WifiDeviceImpl::IsRemoteDied(void) { return (client_ == nullptr) ? true : client_->IsRemoteDied(); diff --git a/wifi/frameworks/native/src/wifi_device_impl.h b/wifi/frameworks/native/src/wifi_device_impl.h index 75036144b..da17e09d6 100644 --- a/wifi/frameworks/native/src/wifi_device_impl.h +++ b/wifi/frameworks/native/src/wifi_device_impl.h @@ -402,6 +402,60 @@ public: */ ErrCode ResetAllFrozenApp() override; + /** + * @Description disable auto join. + * + * @param conditionName autoJoinDisabled condition. + * @return WifiErrorNo + */ + ErrCode DisableAutoJoin(const std::string &conditionName) override; + + /** + * @Description enable auto join. + * + * @param conditionName autoJoinDisabled condition. + * @return WifiErrorNo + */ + ErrCode EnableAutoJoin(const std::string &conditionName) override; + + /** + * @Description register auto join condition. + * + * @param conditionName the name of condition. + * @param autoJoinCondition condition. + * @return WifiErrorNo + */ + ErrCode RegisterAutoJoinCondition(const std::string &conditionName, + const std::function &autoJoinCondition) override; + + /** + * @Description deregister auto join condition. + * + * @param conditionName the name of condition. + * @return WifiErrorNo + */ + ErrCode DeregisterAutoJoinCondition(const std::string &conditionName) override; + + /** + * @Description register external filter builder. + * + * @param filterTag filterTag which define where the filter should be inserted. + * @param filterName the name of the filter to build. + * @param filterBuilder filter builder. + * @return WifiErrorNo + */ + ErrCode RegisterFilterBuilder(const FilterTag &filterTag, const std::string &filterName, + const filter_builder &filterBuilder) override; + + /** + * @Description deregister external filter builder. + * + * @param filterTag filterTag which define where the filter should be inserted. + * @param filterName the name of the filter to build. + * @return WifiErrorNo + */ + ErrCode DeregisterFilterBuilder(const FilterTag &filterTag, const std::string &filterName) override; + /** * @Description Check whether service is died. * diff --git a/wifi/frameworks/native/src/wifi_device_proxy.cpp b/wifi/frameworks/native/src/wifi_device_proxy.cpp index 0cda7de00..8a4f4e8b2 100644 --- a/wifi/frameworks/native/src/wifi_device_proxy.cpp +++ b/wifi/frameworks/native/src/wifi_device_proxy.cpp @@ -1607,6 +1607,85 @@ ErrCode WifiDeviceProxy::ResetAllFrozenApp() return WIFI_OPT_SUCCESS; } +ErrCode WifiDeviceProxy::DisableAutoJoin(const std::string &conditionName) +{ + if (mRemoteDied) { + WIFI_LOGE("failed to `%{public}s`,remote service is died!", __func__); + return WIFI_OPT_FAILED; + } + MessageOption option; + MessageParcel data, reply; + if (!data.WriteInterfaceToken(GetDescriptor())) { + WIFI_LOGE("Write interface token error: %{public}s", __func__); + return WIFI_OPT_FAILED; + } + data.WriteInt32(0); + data.WriteString(conditionName); + int error = Remote()->SendRequest(static_cast(DevInterfaceCode::WIFI_SVR_CMD_DISABLE_AUTO_JOIN), data, + reply, option); + if (error != ERR_NONE) { + WIFI_LOGE("DisableAutoJoin (%{public}d) failed,error code is %{public}d", + static_cast(DevInterfaceCode::WIFI_SVR_CMD_DISABLE_AUTO_JOIN), error); + return WIFI_OPT_FAILED; + } + int exception = reply.ReadInt32(); + if (exception) { + return WIFI_OPT_FAILED; + } + return WIFI_OPT_SUCCESS; +} + +ErrCode WifiDeviceProxy::EnableAutoJoin(const std::string &conditionName) +{ + if (mRemoteDied) { + WIFI_LOGE("failed to `%{public}s`,remote service is died!", __func__); + return WIFI_OPT_FAILED; + } + MessageOption option; + MessageParcel data, reply; + if (!data.WriteInterfaceToken(GetDescriptor())) { + WIFI_LOGE("Write interface token error: %{public}s", __func__); + return WIFI_OPT_FAILED; + } + data.WriteInt32(0); + data.WriteString(conditionName); + int error = Remote()->SendRequest(static_cast(DevInterfaceCode::WIFI_SVR_CMD_ENABLE_AUTO_JOIN), data, + reply, option); + if (error != ERR_NONE) { + WIFI_LOGE("EnableAutoJoin(%{public}d) failed,error code is %{public}d", + static_cast(DevInterfaceCode::WIFI_SVR_CMD_DISABLE_AUTO_JOIN), error); + return WIFI_OPT_FAILED; + } + int exception = reply.ReadInt32(); + if (exception) { + return WIFI_OPT_FAILED; + } + return WIFI_OPT_SUCCESS; +} + +ErrCode WifiDeviceProxy::RegisterAutoJoinCondition(const std::string &conditionName, + const std::function &autoJoinCondition) +{ + return WIFI_OPT_FAILED; +} + +ErrCode WifiDeviceProxy::DeregisterAutoJoinCondition(const std::string &conditionName) +{ + return WIFI_OPT_FAILED; +} + +ErrCode WifiDeviceProxy::RegisterFilterBuilder(const FilterTag &filterTag, + const std::string &filterName, + const filter_builder &filterBuilder) +{ + return WIFI_OPT_FAILED; +} + +ErrCode WifiDeviceProxy::DeregisterFilterBuilder(const FilterTag &filterTag, const std::string &filterName) +{ + return WIFI_OPT_FAILED; +} + ErrCode WifiDeviceProxy::StartPortalCertification() { if (mRemoteDied) { diff --git a/wifi/frameworks/native/src/wifi_device_proxy.h b/wifi/frameworks/native/src/wifi_device_proxy.h index 1ed7bfaf7..d50ced597 100644 --- a/wifi/frameworks/native/src/wifi_device_proxy.h +++ b/wifi/frameworks/native/src/wifi_device_proxy.h @@ -391,6 +391,60 @@ public: */ ErrCode StartPortalCertification() override; + /** + * @Description disable auto join. + * + * @param conditionName autoJoinDisabled condition. + * @return WifiErrorNo + */ + ErrCode DisableAutoJoin(const std::string &conditionName) override; + + /** + * @Description enable auto join. + * + * @param conditionName autoJoinDisabled condition. + * @return WifiErrorNo + */ + ErrCode EnableAutoJoin(const std::string &conditionName) override; + + /** + * @Description register auto join condition. + * + * @param conditionName the name of condition. + * @param autoJoinCondition condition. + * @return WifiErrorNo + */ + ErrCode RegisterAutoJoinCondition(const std::string &conditionName, + const std::function &autoJoinCondition) override; + + /** + * @Description deregister auto join condition. + * + * @param conditionName the name of condition. + * @return WifiErrorNo + */ + ErrCode DeregisterAutoJoinCondition(const std::string &conditionName) override; + + /** + * @Description register external filter builder. + * + * @param filterTag filterTag which define where the filter should be inserted. + * @param filterName the name of the filter to build. + * @param filterBuilder filter builder. + * @return WifiErrorNo + */ + ErrCode RegisterFilterBuilder(const FilterTag &filterTag, const std::string &filterName, + const filter_builder &filterBuilder) override; + + /** + * @Description deregister external filter builder. + * + * @param filterTag filterTag which define where the filter should be inserted. + * @param filterName the name of the filter to build. + * @return WifiErrorNo + */ + ErrCode DeregisterFilterBuilder(const FilterTag &filterTag, const std::string &filterName) override; + ErrCode GetChangeDeviceConfig(ConfigChange& value, WifiDeviceConfig &config) override; /** * @Description reset factory diff --git a/wifi/interfaces/inner_api/wifi_device.h b/wifi/interfaces/inner_api/wifi_device.h index edf9a6bc9..e52f8c63e 100644 --- a/wifi/interfaces/inner_api/wifi_device.h +++ b/wifi/interfaces/inner_api/wifi_device.h @@ -18,6 +18,7 @@ #include "i_wifi_device_callback.h" #include "wifi_errcode.h" #include "wifi_msg.h" +#include "network_selection_msg.h" namespace OHOS { namespace Wifi { @@ -384,6 +385,60 @@ public: */ virtual ErrCode ResetAllFrozenApp() = 0; + /** + * @Description disable auto join. + * + * @param conditionName autoJoinDisabled condition. + * @return WifiErrorNo + */ + virtual ErrCode DisableAutoJoin(const std::string &conditionName) = 0; + + /** + * @Description enable auto join. + * + * @param conditionName autoJoinDisabled condition. + * @return WifiErrorNo + */ + virtual ErrCode EnableAutoJoin(const std::string &conditionName) = 0; + + /** + * @Description register auto join condition. + * + * @param conditionName the name of condition. + * @param autoJoinCondition condition. + * @return WifiErrorNo + */ + virtual ErrCode RegisterAutoJoinCondition(const std::string &conditionName, + const std::function &autoJoinCondition) = 0; + + /** + * @Description deregister auto join condition. + * + * @param conditionName the name of condition. + * @return WifiErrorNo + */ + virtual ErrCode DeregisterAutoJoinCondition(const std::string &conditionName) = 0; + + /** + * @Description register external filter builder. + * + * @param filterTag filterTag which define where the filter should be inserted. + * @param filterName the name of the filter to build. + * @param filterBuilder filter builder. + * @return WifiErrorNo + */ + virtual ErrCode RegisterFilterBuilder(const FilterTag &filterTag, const std::string &filterName, + const filter_builder &filterBuilder) = 0; + + /** + * @Description deregister external filter builder. + * + * @param filterTag filterTag which define where the filter should be inserted. + * @param filterName the name of the filter to build. + * @return WifiErrorNo + */ + virtual ErrCode DeregisterFilterBuilder(const FilterTag &filterTag, const std::string &filterName) = 0; + virtual ErrCode GetChangeDeviceConfig(ConfigChange& value, WifiDeviceConfig &config) = 0; /** diff --git a/wifi/interfaces/inner_api/wifi_msg.h b/wifi/interfaces/inner_api/wifi_msg.h index 660fd2386..13f06d135 100644 --- a/wifi/interfaces/inner_api/wifi_msg.h +++ b/wifi/interfaces/inner_api/wifi_msg.h @@ -476,6 +476,10 @@ struct WifiDeviceConfig { int numRebootsSinceLastUse; int numAssociation; int connFailedCount; + unsigned int networkStatusHistory; + bool isPortal; + time_t lastHasInternetTime; + bool noInternetAccess; /* save select mac address */ std::string userSelectBssid; WifiIpConfig wifiIpConfig; @@ -506,6 +510,10 @@ struct WifiDeviceConfig { numRebootsSinceLastUse = 0; numAssociation = 0; connFailedCount = 0; + networkStatusHistory = 0; + isPortal = false; + lastHasInternetTime = -1; + noInternetAccess = false; callProcessName = ""; ancoCallProcessName = ""; } diff --git a/wifi/services/wifi_standard/wifi_framework/wifi_manage/wifi_device_service_impl.cpp b/wifi/services/wifi_standard/wifi_framework/wifi_manage/wifi_device_service_impl.cpp index 73e6caa24..e591f4098 100644 --- a/wifi/services/wifi_standard/wifi_framework/wifi_manage/wifi_device_service_impl.cpp +++ b/wifi/services/wifi_standard/wifi_framework/wifi_manage/wifi_device_service_impl.cpp @@ -1718,6 +1718,94 @@ ErrCode WifiDeviceServiceImpl::ResetAllFrozenApp() return WIFI_OPT_SUCCESS; } +ErrCode WifiDeviceServiceImpl::DisableAutoJoin(const std::string &conditionName) +{ + if (!WifiAuthCenter::IsNativeProcess()) { + WIFI_LOGE("DisableAutoJoin:NOT NATIVE PROCESS, PERMISSION_DENIED!"); + return WIFI_OPT_PERMISSION_DENIED; + } + IStaService *pService = WifiServiceManager::GetInstance().GetStaServiceInst(m_instId); + if (pService == nullptr) { + WIFI_LOGE("pService is nullptr!"); + return WIFI_OPT_STA_NOT_OPENED; + } + return pService->DisableAutoJoin(conditionName); +} + +ErrCode WifiDeviceServiceImpl::EnableAutoJoin(const std::string &conditionName) +{ + if (!WifiAuthCenter::IsNativeProcess()) { + WIFI_LOGE("EnableAutoJoin:NOT NATIVE PROCESS, PERMISSION_DENIED!"); + return WIFI_OPT_PERMISSION_DENIED; + } + IStaService *pService = WifiServiceManager::GetInstance().GetStaServiceInst(m_instId); + if (pService == nullptr) { + WIFI_LOGE("pService is nullptr!"); + return WIFI_OPT_STA_NOT_OPENED; + } + return pService->EnableAutoJoin(conditionName); +} + +ErrCode WifiDeviceServiceImpl::RegisterAutoJoinCondition(const std::string &conditionName, + const std::function &autoJoinCondition) +{ + if (!WifiAuthCenter::IsNativeProcess()) { + WIFI_LOGE("RegisterAutoJoinCondition:NOT NATIVE PROCESS, PERMISSION_DENIED!"); + return WIFI_OPT_PERMISSION_DENIED; + } + IStaService *pService = WifiServiceManager::GetInstance().GetStaServiceInst(m_instId); + if (pService == nullptr) { + WIFI_LOGE("pService is nullptr!"); + return WIFI_OPT_STA_NOT_OPENED; + } + return pService->RegisterAutoJoinCondition(conditionName, autoJoinCondition); +} + +ErrCode WifiDeviceServiceImpl::DeregisterAutoJoinCondition(const std::string &conditionName) +{ + if (!WifiAuthCenter::IsNativeProcess()) { + WIFI_LOGE("DeregisterAutoJoinCondition:NOT NATIVE PROCESS, PERMISSION_DENIED!"); + return WIFI_OPT_PERMISSION_DENIED; + } + IStaService *pService = WifiServiceManager::GetInstance().GetStaServiceInst(m_instId); + if (pService == nullptr) { + WIFI_LOGE("pService is nullptr!"); + return WIFI_OPT_STA_NOT_OPENED; + } + return pService->DeregisterAutoJoinCondition(conditionName); +} + +ErrCode WifiDeviceServiceImpl::RegisterFilterBuilder(const FilterTag &filterTag, + const std::string &builderName, + const filter_builder &filterBuilder) +{ + if (!WifiAuthCenter::IsNativeProcess()) { + WIFI_LOGE("RegisterFilterBuilder:NOT NATIVE PROCESS, PERMISSION_DENIED!"); + return WIFI_OPT_PERMISSION_DENIED; + } + IStaService *pService = WifiServiceManager::GetInstance().GetStaServiceInst(m_instId); + if (pService == nullptr) { + WIFI_LOGE("pService is nullptr!"); + return WIFI_OPT_STA_NOT_OPENED; + } + return pService->RegisterFilterBuilder(filterTag, builderName, filterBuilder); +} + +ErrCode WifiDeviceServiceImpl::DeregisterFilterBuilder(const FilterTag &filterTag, + const std::string &builderName) +{ + if (!WifiAuthCenter::IsNativeProcess()) { + WIFI_LOGE("DeregisterFilterBuilder:NOT NATIVE PROCESS, PERMISSION_DENIED!"); + return WIFI_OPT_PERMISSION_DENIED; + } + IStaService *pService = WifiServiceManager::GetInstance().GetStaServiceInst(m_instId); + if (pService == nullptr) { + WIFI_LOGE("pService is nullptr!"); + return WIFI_OPT_STA_NOT_OPENED; + } + return pService->DeregisterFilterBuilder(filterTag, builderName); +} + AppEventSubscriber::AppEventSubscriber(const OHOS::EventFwk::CommonEventSubscribeInfo &subscriberInfo) : CommonEventSubscriber(subscriberInfo) { diff --git a/wifi/services/wifi_standard/wifi_framework/wifi_manage/wifi_device_service_impl.h b/wifi/services/wifi_standard/wifi_framework/wifi_manage/wifi_device_service_impl.h index a1a68fd8c..54522b107 100644 --- a/wifi/services/wifi_standard/wifi_framework/wifi_manage/wifi_device_service_impl.h +++ b/wifi/services/wifi_standard/wifi_framework/wifi_manage/wifi_device_service_impl.h @@ -129,6 +129,20 @@ public: ErrCode ResetAllFrozenApp() override; + ErrCode DisableAutoJoin(const std::string &conditionName) override; + + ErrCode EnableAutoJoin(const std::string &conditionName) override; + + ErrCode RegisterAutoJoinCondition(const std::string &conditionName, + const std::function &autoJoinCondition) override; + + ErrCode DeregisterAutoJoinCondition(const std::string &conditionName) override; + + ErrCode RegisterFilterBuilder(const FilterTag &filterTag, const std::string &builderName, + const filter_builder &filterBuilder) override; + + ErrCode DeregisterFilterBuilder(const FilterTag &filterTag, const std::string &builderName) override; + #ifdef OHOS_ARCH_LITE ErrCode RegisterCallBack(const std::shared_ptr &callback, const std::vector &event) override; diff --git a/wifi/services/wifi_standard/wifi_framework/wifi_manage/wifi_device_stub.cpp b/wifi/services/wifi_standard/wifi_framework/wifi_manage/wifi_device_stub.cpp index ad7e92da3..b8bd192e4 100644 --- a/wifi/services/wifi_standard/wifi_framework/wifi_manage/wifi_device_stub.cpp +++ b/wifi/services/wifi_standard/wifi_framework/wifi_manage/wifi_device_stub.cpp @@ -68,6 +68,10 @@ void WifiDeviceStub::InitHandleMapEx() &WifiDeviceStub::OnSetFrozenApp; handleFuncMap[static_cast(DevInterfaceCode::WIFI_SVR_CMD_RESET_ALL_FROZEN_APP)] = &WifiDeviceStub::OnResetAllFrozenApp; + handleFuncMap[static_cast(DevInterfaceCode::WIFI_SVR_CMD_DISABLE_AUTO_JOIN)] = + &WifiDeviceStub::OnDisableAutoJoin; + handleFuncMap[static_cast(DevInterfaceCode::WIFI_SVR_CMD_ENABLE_AUTO_JOIN)] = + &WifiDeviceStub::OnEnableAutoJoin; handleFuncMap[static_cast(DevInterfaceCode::WIFI_SVR_CMD_START_PORTAL_CERTIF)] = &WifiDeviceStub::OnStartPortalCertification; handleFuncMap[static_cast(DevInterfaceCode::WIFI_SVR_CMD_GET_DEVICE_CONFIG_CHANGE)] = @@ -978,6 +982,24 @@ void WifiDeviceStub::OnResetAllFrozenApp(uint32_t code, MessageParcel& data, Mes return; } +void WifiDeviceStub::OnDisableAutoJoin(uint32_t code, MessageParcel& data, MessageParcel& reply) +{ + WIFI_LOGD("run %{public}s code %{public}u, datasize %{public}zu", __func__, code, data.GetRawDataSize()); + ErrCode ret = DisableAutoJoin(data.ReadString()); + reply.WriteInt32(0); + reply.WriteInt32(ret); + return; +} + +void WifiDeviceStub::OnEnableAutoJoin(uint32_t code, MessageParcel& data, MessageParcel& reply) +{ + WIFI_LOGD("run %{public}s code %{public}u, datasize %{public}zu", __func__, code, data.GetRawDataSize()); + ErrCode ret = EnableAutoJoin(data.ReadString()); + reply.WriteInt32(0); + reply.WriteInt32(ret); + return; +} + void WifiDeviceStub::OnFactoryReset(uint32_t code, MessageParcel &data, MessageParcel &reply) { WIFI_LOGD("run %{public}s code %{public}u, datasize %{public}zu", __func__, code, data.GetRawDataSize()); diff --git a/wifi/services/wifi_standard/wifi_framework/wifi_manage/wifi_device_stub.h b/wifi/services/wifi_standard/wifi_framework/wifi_manage/wifi_device_stub.h index 70cdf6118..9e17d1d7a 100644 --- a/wifi/services/wifi_standard/wifi_framework/wifi_manage/wifi_device_stub.h +++ b/wifi/services/wifi_standard/wifi_framework/wifi_manage/wifi_device_stub.h @@ -81,6 +81,8 @@ private: void OnGetDisconnectedReason(uint32_t code, MessageParcel &data, MessageParcel &reply); void OnSetFrozenApp(uint32_t code, MessageParcel& data, MessageParcel& reply); void OnResetAllFrozenApp(uint32_t code, MessageParcel& data, MessageParcel& reply); + void OnDisableAutoJoin(uint32_t code, MessageParcel& data, MessageParcel& reply); + void OnEnableAutoJoin(uint32_t code, MessageParcel& data, MessageParcel& reply); void OnFactoryReset(uint32_t code, MessageParcel &data, MessageParcel &reply); private: diff --git a/wifi/services/wifi_standard/wifi_framework/wifi_manage/wifi_sta/BUILD.gn b/wifi/services/wifi_standard/wifi_framework/wifi_manage/wifi_sta/BUILD.gn index edcf1f20e..42b4a65c3 100644 --- a/wifi/services/wifi_standard/wifi_framework/wifi_manage/wifi_sta/BUILD.gn +++ b/wifi/services/wifi_standard/wifi_framework/wifi_manage/wifi_sta/BUILD.gn @@ -25,6 +25,15 @@ local_base_sources = [ "../common/message_queue.cpp", "../common/state.cpp", "../common/state_machine.cpp", + "network_select/network_filter_builder_manager.cpp", + "network_select/network_selection_manager.cpp", + "network_select/network_selection_utils.cpp", + "network_select/network_selector.cpp", + "network_select/network_selector_comparator.cpp", + "network_select/network_selector_factory.cpp", + "network_select/network_selector_filter.cpp", + "network_select/network_selector_scorer.cpp", + "network_status_history_manager.cpp", "sta_auto_connect_service.cpp", "sta_interface.cpp", "sta_monitor.cpp", @@ -58,6 +67,7 @@ local_base_include_dirs = [ "$WIFI_ROOT_DIR/services/wifi_standard/wifi_framework/wifi_manage/wifi_common", "$WIFI_ROOT_DIR/services/wifi_standard/include", "$WIFI_ROOT_DIR/services/wifi_standard/wifi_framework/wifi_manage/wifi_country_code", + "$WIFI_ROOT_DIR/services/wifi_standard/wifi_framework/wifi_manage/wifi_sta/network_select", ] if (defined(ohos_lite)) { diff --git a/wifi/services/wifi_standard/wifi_framework/wifi_manage/wifi_sta/ista_service.h b/wifi/services/wifi_standard/wifi_framework/wifi_manage/wifi_sta/ista_service.h index 2c9228aa9..61f406a35 100644 --- a/wifi/services/wifi_standard/wifi_framework/wifi_manage/wifi_sta/ista_service.h +++ b/wifi/services/wifi_standard/wifi_framework/wifi_manage/wifi_sta/ista_service.h @@ -19,6 +19,7 @@ #include "wifi_errcode.h" #include "wifi_msg.h" #include "sta_service_callback.h" +#include "network_selection_msg.h" namespace OHOS { namespace Wifi { @@ -228,6 +229,61 @@ public: * @return success: WIFI_OPT_SUCCESS, failed: WIFI_OPT_FAILED */ virtual ErrCode OnScreenStateChanged(int screenState) = 0; + + /** + * @Description disable auto join. + * + * @param conditionName autoJoinDisabled condition. + * @return WifiErrorNo + */ + virtual ErrCode DisableAutoJoin(const std::string &conditionName) = 0; + + /** + * @Description enable auto join. + * + * @param conditionName autoJoinDisabled condition. + * @return WifiErrorNo + */ + virtual ErrCode EnableAutoJoin(const std::string &conditionName) = 0; + + /** + * @Description register auto join condition. + * + * @param conditionName the name of condition. + * @param autoJoinCondition condition. + * @return WifiErrorNo + */ + virtual ErrCode RegisterAutoJoinCondition(const std::string &conditionName, + const std::function &autoJoinCondition) = 0; + + /** + * @Description deregister auto join condition. + * + * @param conditionName the name of condition. + * @return WifiErrorNo + */ + virtual ErrCode DeregisterAutoJoinCondition(const std::string &conditionName) = 0; + + /** + * @Description register external filter builder. + * + * @param filterTag filterTag which define where the filter should be inserted. + * @param filterName the name of the filter to build. + * @param filterBuilder filter builder. + * @return WifiErrorNo + */ + virtual ErrCode RegisterFilterBuilder(const FilterTag &filterTag, const std::string &filterName, + const filter_builder &filterBuilder) = 0; + + /** + * @Description deregister external filter builder. + * + * @param filterTag filterTag which define where the filter should be inserted. + * @param filterName the name of the filter to build. + * @return WifiErrorNo + */ + virtual ErrCode DeregisterFilterBuilder(const FilterTag &filterTag, const std::string &filterName) = 0; + /** * @Description start portal certification. * diff --git a/wifi/services/wifi_standard/wifi_framework/wifi_manage/wifi_sta/network_select/network_filter_builder_manager.cpp b/wifi/services/wifi_standard/wifi_framework/wifi_manage/wifi_sta/network_select/network_filter_builder_manager.cpp new file mode 100644 index 000000000..86be54146 --- /dev/null +++ b/wifi/services/wifi_standard/wifi_framework/wifi_manage/wifi_sta/network_select/network_filter_builder_manager.cpp @@ -0,0 +1,63 @@ +/* + * Copyright (C) 2021-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 "network_filter_builder_manager.h" +#include "wifi_logger.h" + +namespace OHOS { +namespace Wifi { +DEFINE_WIFILOG_LABEL("EXTERNAL_WIFI_FILTER_BUILD_MANAGER") + +ExternalWifiFilterBuildManager &ExternalWifiFilterBuildManager::GetInstance() +{ + static ExternalWifiFilterBuildManager gNetworkSelectorFilterBuilderManager; + return gNetworkSelectorFilterBuilderManager; +} + +void ExternalWifiFilterBuildManager::RegisterFilterBuilder(const FilterTag &filterTag, + const std::string &filterName, + const filter_builder &filterBuilder) +{ + std::lock_guard lock(mutex); + WIFI_LOGI("RegisterFilterBuilder for filterTag: %{public}d, filterName: %{public}s", + static_cast(filterTag), + filterName.c_str()); + filterBuilders.insert({{filterTag, filterName}, filterBuilder}); +} + +void ExternalWifiFilterBuildManager::DeregisterFilterBuilder(const FilterTag &filterTag, const std::string &filterName) +{ + std::lock_guard lock(mutex); + WIFI_LOGI("DeregisterFilterBuilder for filterTag: %{public}d, filterName: %{public}s", + static_cast(filterTag), + filterName.c_str()); + filterBuilders.erase({filterTag, filterName}); +} + +void ExternalWifiFilterBuildManager::BuildFilter(const FilterTag &filterTag, CompositeWifiFilter &filter) +{ + std::lock_guard lock(mutex); + for (const auto &filterBuilderPair : filterBuilders) { + if (filterBuilderPair.first.first == filterTag) { + filter_func filter_func; + if (filterBuilderPair.second.operator()(filter_func)) { + filter.AddFilter(std::make_shared( + filter_func, filterBuilderPair.first.second)); + } + } + } +} +} +} \ No newline at end of file diff --git a/wifi/services/wifi_standard/wifi_framework/wifi_manage/wifi_sta/network_select/network_filter_builder_manager.h b/wifi/services/wifi_standard/wifi_framework/wifi_manage/wifi_sta/network_select/network_filter_builder_manager.h new file mode 100644 index 000000000..b70b9c607 --- /dev/null +++ b/wifi/services/wifi_standard/wifi_framework/wifi_manage/wifi_sta/network_select/network_filter_builder_manager.h @@ -0,0 +1,56 @@ +/* + * Copyright (C) 2021-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. + */ + +#ifndef OHOS_WIFI_NETWORK_SELECT_NETWORK_FILTER_BUILDER_MANAGER_H_ +#define OHOS_WIFI_NETWORK_SELECT_NETWORK_FILTER_BUILDER_MANAGER_H_ +#include "network_selector_filter.h" +#include +namespace OHOS { +namespace Wifi { +class ExternalWifiFilterBuildManager { +public: + static ExternalWifiFilterBuildManager &GetInstance(); + + /** + * Register the filter builder function + * + * @param filterTag filterTag which define where the filter should be inserted. + * @param filterName the filter name. + * @param filterBuilder filterBuilder function. + */ + void RegisterFilterBuilder(const FilterTag &filterTag, const std::string &filterName, + const filter_builder &filterBuilder); + /** + * Deregister the filter builder function + * + * @param filterTag filterTag which define where the filter should be inserted. + * @param filterName the filter name. + */ + void DeregisterFilterBuilder(const FilterTag &filterTag, const std::string &filterName); + + /** + * build the filter + * + * @param filterTag filterTag which define where the filter should be inserted. + * @param filter the target Filter to build. + */ + void BuildFilter(const FilterTag &filterTag, CompositeWifiFilter &filter); +private: + std::map, filter_builder> filterBuilders; + std::mutex mutex; +}; +} +} +#endif \ No newline at end of file diff --git a/wifi/services/wifi_standard/wifi_framework/wifi_manage/wifi_sta/network_select/network_selection_manager.cpp b/wifi/services/wifi_standard/wifi_framework/wifi_manage/wifi_sta/network_select/network_selection_manager.cpp new file mode 100644 index 000000000..9fbd5a398 --- /dev/null +++ b/wifi/services/wifi_standard/wifi_framework/wifi_manage/wifi_sta/network_select/network_selection_manager.cpp @@ -0,0 +1,117 @@ +/* + * Copyright (C) 2021-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 "network_selection_manager.h" +#include "wifi_settings.h" +#include "wifi_logger.h" +#include "network_selection_utils.h" +#include + +namespace OHOS { +namespace Wifi { +DEFINE_WIFILOG_LABEL("NETWORK_SELECTION_MANAGER") +NetworkSelectionManager::NetworkSelectionManager() : pNetworkSelectorFactory(nullptr) {} + +NetworkSelectionManager::~NetworkSelectionManager() +{ + if (pNetworkSelectorFactory != nullptr) { + delete pNetworkSelectorFactory; + pNetworkSelectorFactory = nullptr; + } +} + +ErrCode NetworkSelectionManager::InitNetworkSelectionService() +{ + pNetworkSelectorFactory = new (std::nothrow) NetworkSelectorFactory(); + if (pNetworkSelectorFactory == nullptr) { + WIFI_LOGE("pNetworkSelectorFactory is null\n"); + return WIFI_OPT_FAILED; + } + if (pNetworkSelectorFactory->InitNetworkSelectorFactory() != WIFI_OPT_SUCCESS) { + WIFI_LOGE("InitAutoConnectService failed.\n"); + return WIFI_OPT_FAILED; + } + return WIFI_OPT_SUCCESS; +} + +bool NetworkSelectionManager::SelectNetwork(NetworkSelectionResult &networkSelectionResult, + NetworkSelectType type, + const std::vector &scanInfos) +{ + auto networkSelector = pNetworkSelectorFactory->GetNetworkSelector(type); + if (!networkSelector) { + WIFI_LOGE("Get NetworkSelector failed for type %{public}d", static_cast(type)); + return false; + } + WIFI_LOGI("NetworkSelector: %{public}s", networkSelector->GetNetworkSelectorMsg().c_str()); + std::vector networkCandidates; + GetAllDeviceConfigs(networkCandidates, scanInfos); + TryNominator(networkCandidates, networkSelector); + std::vector bestNetworkCandidates; + networkSelector->GetBestCandidates(bestNetworkCandidates); + if (bestNetworkCandidates.empty()) { + return false; + } + networkSelectionResult.wifiDeviceConfig = bestNetworkCandidates.at(0)->wifiDeviceConfig; + networkSelectionResult.interScanInfo = bestNetworkCandidates.at(0)->interScanInfo; + return true; +} + +void NetworkSelectionManager::GetAllDeviceConfigs(std::vector &networkCandidates, + const std::vector &scanInfos) +{ + for (auto &scanInfo : scanInfos) { + NetworkCandidate networkCandidate = {scanInfo}; + std::string deviceKeyMgmt; + scanInfo.GetDeviceMgmt(deviceKeyMgmt); + WifiSettings::GetInstance().GetDeviceConfig(scanInfo.ssid, + deviceKeyMgmt, + networkCandidate.wifiDeviceConfig); + networkCandidates.emplace_back(networkCandidate); + } +} + +void NetworkSelectionManager::TryNominator(std::vector &networkCandidates, + const std::unique_ptr &networkSelector) +{ + std::for_each(networkCandidates.begin(), networkCandidates.end(), [&networkSelector](auto &networkCandidate) { + networkSelector->TryNominate(networkCandidate); + LogNominateResult(networkCandidate); + }); +} + +std::string NetworkSelectionManager::VectorToJson(std::vector &strings) +{ + std::stringstream ss; + ss << "["; + for (int i = 0; i < strings.size(); ++i) { + ss << strings[i]; + if (i < strings.size() - 1) { + ss << " ,"; + } + } + ss << "]"; + return ss.str(); +} + +void NetworkSelectionManager::LogNominateResult(NetworkCandidate &networkCandidate) +{ + WIFI_LOGD("NetworkCandidate %{public}s is filtered by %{public}s, is nominated by %{public}s", + NetworkSelectionUtils::GetNetworkCandidateInfo(networkCandidate).c_str(), + VectorToJson(networkCandidate.filteredMsg).c_str(), + VectorToJson(networkCandidate.nominateMsg).c_str()); +} +} +} \ No newline at end of file diff --git a/wifi/services/wifi_standard/wifi_framework/wifi_manage/wifi_sta/network_select/network_selection_manager.h b/wifi/services/wifi_standard/wifi_framework/wifi_manage/wifi_sta/network_select/network_selection_manager.h new file mode 100644 index 000000000..c9c5fb14c --- /dev/null +++ b/wifi/services/wifi_standard/wifi_framework/wifi_manage/wifi_sta/network_select/network_selection_manager.h @@ -0,0 +1,80 @@ +/* + * Copyright (C) 2021-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. + */ + + +#ifndef OHOS_WIFI_NETWORK_SELECTION_MANAGER_H +#define OHOS_WIFI_NETWORK_SELECTION_MANAGER_H + +#include "network_selection_msg.h" +#include "network_selector.h" +#include "network_selector_factory.h" + +namespace OHOS { +namespace Wifi { +struct NetworkSelectionResult { + InterScanInfo interScanInfo; + WifiDeviceConfig wifiDeviceConfig; +}; + +class NetworkSelectionManager { +public: + NetworkSelectionManager(); + ~NetworkSelectionManager(); + ErrCode InitNetworkSelectionService(); + /** + * the function to select network. + * + * @param networkSelectionResult Network selection result + * @param type the type of networkSelection + * @param scanInfos scanInfos + * @return whether network selection is successful. + */ + bool SelectNetwork(NetworkSelectionResult &networkSelectionResult, + NetworkSelectType type, + const std::vector &scanInfos); +private: + NetworkSelectorFactory *pNetworkSelectorFactory; + + /** + * get the saved deviceConfig associated with scanInfo + * + * @param networkCandidates Candidate network + * @param scanInfos scanInfos + */ + static void GetAllDeviceConfigs(std::vector &networkCandidates, + const std::vector &scanInfos); + + /** + * Try nominator the candidate network. + * + * @param networkCandidates candidate networks + * @param networkSelector networkSelector + */ + static void TryNominator(std::vector &networkCandidates, + const std::unique_ptr &networkSelector); + + /** + * the function to log the networkSelection nominate result. + * + * @param networkCandidate candidate network + */ + static void LogNominateResult(NetworkCandidate &networkCandidate); + + static std::string VectorToJson(std::vector &strings); +}; +} +} + +#endif diff --git a/wifi/services/wifi_standard/wifi_framework/wifi_manage/wifi_sta/network_select/network_selection_utils.cpp b/wifi/services/wifi_standard/wifi_framework/wifi_manage/wifi_sta/network_select/network_selection_utils.cpp new file mode 100644 index 000000000..3593fc912 --- /dev/null +++ b/wifi/services/wifi_standard/wifi_framework/wifi_manage/wifi_sta/network_select/network_selection_utils.cpp @@ -0,0 +1,177 @@ +/* + * Copyright (C) 2021-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 "network_selection_utils.h" +#include "network_status_history_manager.h" +#include "wifi_settings.h" +#include "wifi_common_util.h" + +namespace OHOS { +namespace Wifi { +namespace { +constexpr int RECHECK_DELAYED_SECONDS = 1 * 60 * 60; +constexpr int MAX_RETRY_COUNT = 3; +constexpr int MIN_5GHZ_BAND_FREQUENCY = 5000; +constexpr int MIN_RSSI_VALUE_24G = -77; +constexpr int MIN_RSSI_VALUE_5G = -80; +constexpr int SIGNAL_LEVEL_TWO = 2; +constexpr int POOR_PORTAL_RECHECK_DELAYED_SECONDS = 2 * RECHECK_DELAYED_SECONDS; +constexpr int SCORE_PRECISION = 2; +} +bool NetworkSelectionUtils::isOpenNetwork(NetworkCandidate &networkCandidate) +{ + return networkCandidate.wifiDeviceConfig.keyMgmt == KEY_MGMT_NONE; +}; + +bool NetworkSelectionUtils::isOpenAndMaybePortal(NetworkCandidate &networkCandidate) +{ + auto &wifiDeviceConfig = networkCandidate.wifiDeviceConfig; + return isOpenNetwork(networkCandidate) && !wifiDeviceConfig.noInternetAccess + && NetworkStatusHistoryManager::IsEmptyNetworkHistoryByNumCheck(wifiDeviceConfig.networkStatusHistory); +} + +bool NetworkSelectionUtils::isScanResultForOweNetwork(NetworkCandidate &networkCandidate) +{ + return networkCandidate.interScanInfo.capabilities.find("OWE") != std::string::npos; +} + +bool NetworkSelectionUtils::IsRecoveryNetwork(NetworkCandidate &networkCandidate) +{ + auto &wifiDeviceConfig = networkCandidate.wifiDeviceConfig; + return wifiDeviceConfig.noInternetAccess && !wifiDeviceConfig.isPortal + && NetworkStatusHistoryManager::IsRecoveryByNumCheck(wifiDeviceConfig.networkStatusHistory); +} + +bool NetworkSelectionUtils::IsHasInternetNetwork(NetworkCandidate &networkCandidate) +{ + auto &wifiDeviceConfig = networkCandidate.wifiDeviceConfig; + if (wifiDeviceConfig.noInternetAccess || wifiDeviceConfig.isPortal) { + return false; + } + if (NetworkStatusHistoryManager::IsInternetAccessByNumCheck(wifiDeviceConfig.networkStatusHistory)) { + return true; + } + if (NetworkSelectionUtils::isOpenNetwork(networkCandidate)) { + return false; + } + return NetworkStatusHistoryManager::IsEmptyNetworkHistoryByNumCheck(wifiDeviceConfig.networkStatusHistory); +} + +bool NetworkSelectionUtils::IsBlackListNetwork(NetworkCandidate &networkCandidate) +{ + return networkCandidate.wifiDeviceConfig.connFailedCount >= MAX_RETRY_COUNT; +} + +bool NetworkSelectionUtils::MayBePortalNetwork(NetworkCandidate &networkCandidate) +{ + return !NetworkSelectionUtils::isScanResultForOweNetwork(networkCandidate) + && NetworkSelectionUtils::isOpenAndMaybePortal(networkCandidate); +} + +bool NetworkSelectionUtils::IsPortalNetwork(NetworkCandidate &networkCandidate) +{ + return networkCandidate.wifiDeviceConfig.isPortal; +} + +bool NetworkSelectionUtils::IsNoInternetNetwork(NetworkCandidate &networkCandidate) +{ + auto &wifiDeviceConfig = networkCandidate.wifiDeviceConfig; + return wifiDeviceConfig.noInternetAccess + && !NetworkStatusHistoryManager::IsRecoveryByNumCheck(wifiDeviceConfig.networkStatusHistory); +} + +bool NetworkSelectionUtils::IsSavedNetwork(NetworkCandidate &networkCandidate) +{ + return networkCandidate.wifiDeviceConfig.networkId != INVALID_NETWORK_ID; +} + +bool NetworkSelectionUtils::IsNetworkEnabled(NetworkCandidate &networkCandidate) +{ + return networkCandidate.wifiDeviceConfig.status == static_cast(WifiDeviceConfigStatus::ENABLED); +} + +bool NetworkSelectionUtils::IsEphemeralNetwork(NetworkCandidate &networkCandidate) +{ + return networkCandidate.wifiDeviceConfig.isEphemeral; +} + +bool NetworkSelectionUtils::IsHiddenNetwork(NetworkCandidate &networkCandidate) +{ + return networkCandidate.interScanInfo.ssid.empty(); +} + +bool NetworkSelectionUtils::IsSignalTooWeak(NetworkCandidate &networkCandidate) +{ + auto &scanInfo = networkCandidate.interScanInfo; + auto rssiThreshold = scanInfo.frequency < MIN_5GHZ_BAND_FREQUENCY ? MIN_RSSI_VALUE_24G : MIN_RSSI_VALUE_5G; + return scanInfo.rssi < rssiThreshold; +} + +bool NetworkSelectionUtils::IsPoorPortalNetwork(NetworkCandidate &networkCandidate) +{ + auto &interScanInfo = networkCandidate.interScanInfo; + int currentSignalLevel = WifiSettings::GetInstance().GetSignalLevel(interScanInfo.rssi, interScanInfo.band); + if (currentSignalLevel > SIGNAL_LEVEL_TWO) { + return false; + } + if (currentSignalLevel < SIGNAL_LEVEL_TWO) { + return true; + } + auto lastHasInternetTime = networkCandidate.wifiDeviceConfig.lastHasInternetTime; + return time(0) - lastHasInternetTime > POOR_PORTAL_RECHECK_DELAYED_SECONDS; +} + +bool NetworkSelectionUtils::IsMatchUserSelected(NetworkCandidate &networkCandidate) +{ + if (networkCandidate.wifiDeviceConfig.userSelectBssid.empty()) { + return true; + } + return networkCandidate.interScanInfo.bssid == networkCandidate.wifiDeviceConfig.userSelectBssid; +} + +bool NetworkSelectionUtils::IsPassPointNetwork(NetworkCandidate &networkCandidate) +{ + return networkCandidate.wifiDeviceConfig.isPasspoint; +} + +std::string NetworkSelectionUtils::GetNetworkCandidateInfo(NetworkCandidate &networkCandidate) +{ + std::stringstream networkCandidateInfo; + networkCandidateInfo << R"({ "ssid" : ")" << SsidAnonymize(networkCandidate.interScanInfo.ssid) + << R"(", "bssid" : ")" + << MacAnonymize(networkCandidate.interScanInfo.bssid) << R"(" })"; + return networkCandidateInfo.str(); +} + +std::string NetworkSelectionUtils::GetScoreMsg(ScoreResult &scoreResult) +{ + std::stringstream scoreMsg; + scoreMsg << scoreResult.scorerName << " : " << std::fixed << std::setprecision(SCORE_PRECISION) + << scoreResult.score; + if (scoreResult.scoreDetails.empty()) { + return scoreMsg.str(); + } + scoreMsg << "{ "; + for (auto i = 0; i < scoreResult.scoreDetails.size(); i++) { + scoreMsg << NetworkSelectionUtils::GetScoreMsg(scoreResult.scoreDetails.at(i)); + if (i < scoreResult.scoreDetails.size() - 1) { + scoreMsg << ", "; + } + } + scoreMsg << " }"; + return scoreMsg.str(); +} +} +} \ No newline at end of file diff --git a/wifi/services/wifi_standard/wifi_framework/wifi_manage/wifi_sta/network_select/network_selection_utils.h b/wifi/services/wifi_standard/wifi_framework/wifi_manage/wifi_sta/network_select/network_selection_utils.h new file mode 100644 index 000000000..a368e5791 --- /dev/null +++ b/wifi/services/wifi_standard/wifi_framework/wifi_manage/wifi_sta/network_select/network_selection_utils.h @@ -0,0 +1,176 @@ +/* + * Copyright (C) 2021-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. + */ + +#ifndef OHOS_WIFI_NETWORK_SELECTION_UTILS_H_ +#define OHOS_WIFI_NETWORK_SELECTION_UTILS_H_ + +#include "network_selection_msg.h" +#include "network_selector_scorer.h" +namespace OHOS { +namespace Wifi { +class NetworkSelectionUtils { +public: + + /** + * the function to determine whether the network is Open + * + * @param networkCandidate candidate network. + * @return return ture if the candidate network is Open + */ + static bool isOpenNetwork(NetworkCandidate &networkCandidate); + + /** + * the function to determine whether the network is Open and maybe portal. + * + * @param networkCandidate candidate network. + * @return return ture if the candidate network is Open and maybe portal. + */ + static bool isOpenAndMaybePortal(NetworkCandidate &networkCandidate); + + /** + * the function to determine whether the network is owe network. + * + * @param networkCandidate candidate network. + * @return return ture if the candidate network is owe network. + */ + static bool isScanResultForOweNetwork(NetworkCandidate &networkCandidate); + + /** + * the function to determine whether the network is recovery. + * + * @param networkCandidate + * @return return ture if the candidate network is recovery. + */ + static bool IsRecoveryNetwork(NetworkCandidate &networkCandidate); + + /** + * the function to determine whether the network has internet. + * + * @param networkCandidate candidate network. + * @return return ture if the candidate network has internet. + */ + static bool IsHasInternetNetwork(NetworkCandidate &networkCandidate); + + /** + * the function to determine whether the network is low-priority . + * + * @param networkCandidate candidate network. + * @return return ture if the candidate network is low-priority . + */ + static bool IsBlackListNetwork(NetworkCandidate &networkCandidate); + + /** + * the function to determine whether the network may be portal. + * + * @param networkCandidate candidate network. + * @return return ture if the candidate network may be portal. + */ + static bool MayBePortalNetwork(NetworkCandidate &networkCandidate); + /** + * the function to determine whether the network is portal. + * + * @param networkCandidate candidate network. + * @return return ture if the candidate network is portal. + */ + static bool IsPortalNetwork(NetworkCandidate &networkCandidate); + + /** + * the function to determine whether the network is no internet. + * + * @param networkCandidate candidate network. + * @return return ture if the candidate network is no internet. + */ + static bool IsNoInternetNetwork(NetworkCandidate &networkCandidate); + + /** + * the function to determine whether the network is saved. + * + * @param networkCandidate candidate network. + * @return return ture if the candidate network is saved. + */ + static bool IsSavedNetwork(NetworkCandidate &networkCandidate); + + /** + * the function to determine whether the signal strength of candidate network is too weak. + * + * @param networkCandidate candidate network. + * @return return ture if the signal strength of candidate network is too weak. + */ + static bool IsSignalTooWeak(NetworkCandidate &networkCandidate); + + /** + * the function to determine whether the network is hidden. + * + * @param networkCandidate candidate network. + * @return return ture if the candidate network is hidden. + */ + static bool IsHiddenNetwork(NetworkCandidate &networkCandidate); + + /** + * the function to determine whether the network is passPoint. + * + * @param networkCandidate candidate network. + * @return return ture if the candidate network is passPoint. + */ + static bool IsPassPointNetwork(NetworkCandidate &networkCandidate); + + /** + * the function to determine whether the network is ephemeral. + * + * @param networkCandidate candidate network. + * @return return ture if the candidate network is ephemeral. + */ + static bool IsEphemeralNetwork(NetworkCandidate &networkCandidate); + + /** + * the function to determine whether the network is enabled. + * + * @param networkCandidate candidate network + * @return return ture if the candidate network is enabled. + */ + static bool IsNetworkEnabled(NetworkCandidate &networkCandidate); + + /** + * the function to determine whether the network match user selected. + * + * @param networkCandidate candidate network + * @return return ture if the candidate network match user selected + */ + static bool IsMatchUserSelected(NetworkCandidate &networkCandidate); + + /** + * the function to determine whether the portal network is poor. + * @param networkCandidate candidate portal network + * @return return ture if the candidate portal network is poor + */ + static bool IsPoorPortalNetwork(NetworkCandidate &networkCandidate); + + /** + * transfer the info of candidate network to json format string. + * @param networkCandidate candidate network + * @return json format string + */ + static std::string GetNetworkCandidateInfo(NetworkCandidate &networkCandidate); + + /** + * transfer the info of score result to json format string. + * @param scoreResult scoreResult + * @return json format string + */ + static std::string GetScoreMsg(ScoreResult &scoreResult); +}; +} +} +#endif diff --git a/wifi/services/wifi_standard/wifi_framework/wifi_manage/wifi_sta/network_select/network_selector.cpp b/wifi/services/wifi_standard/wifi_framework/wifi_manage/wifi_sta/network_select/network_selector.cpp new file mode 100644 index 000000000..ab09d6a28 --- /dev/null +++ b/wifi/services/wifi_standard/wifi_framework/wifi_manage/wifi_sta/network_select/network_selector.cpp @@ -0,0 +1,357 @@ +/* + * Copyright (C) 2021-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 "network_selector.h" +#include "network_selection_utils.h" +#include "network_filter_builder_manager.h" +#include + +using namespace std; +namespace OHOS { +namespace Wifi { +void NetworkSelector::SetWifiComparator(const std::shared_ptr &networkSelectorComparator) +{ + comparator = networkSelectorComparator; +} + +void NetworkSelector::SetWifiFilter(const std::shared_ptr &networkSelectorFilter) +{ + filter = networkSelectorFilter; +} + +bool NetworkSelector::TryNominate(OHOS::Wifi::NetworkCandidate &networkCandidate) +{ + bool ret = false; + if (DoFilter(networkCandidate)) { + ret = Nominate(networkCandidate); + AfterNominate(networkCandidate, ret); + } + return ret; +} + +bool NetworkSelector::DoFilter(OHOS::Wifi::NetworkCandidate &networkCandidate) +{ + return !filter || filter->DoFilter(networkCandidate); +} + +void NetworkSelector::AfterNominate(OHOS::Wifi::NetworkCandidate &networkCandidate, bool nominateResult) {} + +void NetworkSelector::GetBestCandidatesByComparator(std::vector &selectedNetworkCandidates) +{ + if (comparator) { + comparator->GetBestCandidates(networkCandidates, selectedNetworkCandidates); + } else { + selectedNetworkCandidates.insert(selectedNetworkCandidates.end(), + networkCandidates.begin(), + networkCandidates.end()); + } +} + +void SimpleNetworkSelector::GetBestCandidates(std::vector &selectedNetworkCandidates) +{ + GetBestCandidatesByComparator(selectedNetworkCandidates); +} + +SimpleNetworkSelector::SimpleNetworkSelector(const std::string &networkSelectorName) + : m_networkSelectorName(networkSelectorName) {} + +void SimpleNetworkSelector::AfterNominate(OHOS::Wifi::NetworkCandidate &networkCandidate, bool nominateResult) +{ + if (nominateResult) { + networkCandidate.nominateMsg.emplace_back(m_networkSelectorName); + } +} + +CompositeNetworkSelector::CompositeNetworkSelector(const std::string &networkSelectorName) : m_networkSelectorName( + networkSelectorName) {} + + + +void CompositeNetworkSelector::AddSubNetworkSelector(const shared_ptr &subNetworkSelector) +{ + subNetworkSelectors.emplace_back(subNetworkSelector); +} + +void CompositeNetworkSelector::GetBestCandidates(std::vector &selectedNetworkCandidates) +{ + GetCandidatesFromSubNetworkSelector(); + GetBestCandidatesByComparator(selectedNetworkCandidates); +} + +void AutoConnectNetworkSelector::GetCandidatesFromSubNetworkSelector() +{ + for (const auto &subNetworkSelector : subNetworkSelectors) { + subNetworkSelector->GetBestCandidates(networkCandidates); + } +} + +std::string CompositeNetworkSelector::GetNetworkSelectorMsg() +{ + std::stringstream networkSelectorMsg; + networkSelectorMsg << R"({ "name": ")" << m_networkSelectorName << "\" "; + if (filter) { + networkSelectorMsg << R"(,"filter": ")" << filter->GetFilterMsg() << "\""; + } + if (!subNetworkSelectors.empty()) { + networkSelectorMsg << R"(,"subNetworkSelectors": [)"; + for (auto i = 0; i < subNetworkSelectors.size(); i++) { + networkSelectorMsg << subNetworkSelectors.at(i)->GetNetworkSelectorMsg(); + if (i < subNetworkSelectors.size() - 1) { + networkSelectorMsg << ","; + } + } + networkSelectorMsg << "]"; + } + networkSelectorMsg << "}"; + return networkSelectorMsg.str(); +} + +AutoConnectNetworkSelector::AutoConnectNetworkSelector() : CompositeNetworkSelector( + "autoConnectedNetworkSelectorManager") +{ + using namespace std; + auto filters = make_shared(); + filters->AddFilter(make_shared(NetworkSelectionUtils::IsHiddenNetwork, + "notHiddenNetwork", + true)); + filters->AddFilter(make_shared(NetworkSelectionUtils::IsSignalTooWeak, + "notSignalTooWeak", + true)); + SetWifiFilter(filters); + auto savedNetworkSelector = std::make_shared(); + AddSubNetworkSelector(savedNetworkSelector); + auto comparator = std::make_shared(m_networkSelectorName); + comparator->AddScorer(std::make_shared()); + SetWifiComparator(comparator); +} + +bool AutoConnectNetworkSelector::Nominate(OHOS::Wifi::NetworkCandidate &networkCandidate) +{ + for (auto &networkSelector : subNetworkSelectors) { + networkSelector->TryNominate(networkCandidate); + } + return false; +} + +SavedNetworkSelector::SavedNetworkSelector() : CompositeNetworkSelector("savedNetworkSelector") +{ + using namespace std; + auto filters = make_shared(); + filters->AddFilter(make_shared(NetworkSelectionUtils::IsSavedNetwork, "savedNetwork")); + filters->AddFilter(make_shared(NetworkSelectionUtils::IsPassPointNetwork, + "notPassPoint", + true)); + filters->AddFilter(make_shared(NetworkSelectionUtils::IsEphemeralNetwork, + "notEphemeral", + true)); + filters->AddFilter(make_shared(NetworkSelectionUtils::IsNetworkEnabled, "enableNetwork")); + filters->AddFilter(make_shared(NetworkSelectionUtils::IsMatchUserSelected, + "matchUserSelected")); + ExternalWifiFilterBuildManager::GetInstance().BuildFilter(FilterTag::SAVED_NETWORK_SELECTOR_FILTER_TAG, *filters); + auto blackListNetworkSelector = std::make_shared(); + auto hasInternetNetworkSelector = make_shared(); + auto recoveryNetworkSelector = make_shared(); + auto portalNetworkSelector = make_shared(); + portalNetworkSelector->InitFilter(); + auto noInternetNetworkSelector = make_shared(); + filters->AddFilter(blackListNetworkSelector); + filters->AddFilter(hasInternetNetworkSelector); + filters->AddFilter(recoveryNetworkSelector); + filters->AddFilter(portalNetworkSelector); + filters->AddFilter(noInternetNetworkSelector); + SetWifiFilter(filters); + AddSubNetworkSelector(hasInternetNetworkSelector); + AddSubNetworkSelector(recoveryNetworkSelector); + AddSubNetworkSelector(portalNetworkSelector); + AddSubNetworkSelector(noInternetNetworkSelector); + AddSubNetworkSelector(blackListNetworkSelector); +} + +bool SavedNetworkSelector::Nominate(OHOS::Wifi::NetworkCandidate &networkCandidate) +{ + return false; +} + +void SavedNetworkSelector::GetCandidatesFromSubNetworkSelector() +{ + for (const auto &subNetworkSelector : subNetworkSelectors) { + subNetworkSelector->GetBestCandidates(networkCandidates); + if (!networkCandidates.empty()) { + return; + } + } +} + +bool SimpleNetworkSelector::Nominate(OHOS::Wifi::NetworkCandidate &networkCandidate) +{ + networkCandidates.emplace_back(&networkCandidate); + return true; +} + +std::string SimpleNetworkSelector::GetNetworkSelectorMsg() +{ + std::stringstream networkSelectorMsg; + networkSelectorMsg << R"({ "name": ")" << m_networkSelectorName << "\" "; + if (filter) { + networkSelectorMsg << R"(,"filter": ")" << filter->GetFilterMsg() << "\""; + } + networkSelectorMsg << "}"; + return networkSelectorMsg.str(); +} + +BlackListNetworkSelector::BlackListNetworkSelector() : SimpleNetworkSelector("blackListNetworkSelector"), + SimpleWifiFilter("blackListNetworkSelector") +{ + SetWifiFilter(std::make_shared(NetworkSelectionUtils::IsBlackListNetwork, + "inBlackList")); +} + +bool BlackListNetworkSelector::Nominate(OHOS::Wifi::NetworkCandidate &networkCandidate) +{ + if (!networkCandidates.empty()) { + networkCandidates.at(0) = &networkCandidate; + } else { + networkCandidates.emplace_back(&networkCandidate); + } + return true; +} + +bool BlackListNetworkSelector::Filter(NetworkCandidate &networkCandidate) +{ + return !TryNominate(networkCandidate); +} + +HasInternetNetworkSelector::HasInternetNetworkSelector() : SimpleNetworkSelector("hasInternetNetworkSelector"), + SimpleWifiFilter( + "hasInternetNetworkSelector") +{ + auto filters = std::make_shared(); + ExternalWifiFilterBuildManager::GetInstance().BuildFilter(FilterTag::HAS_INTERNET_NETWORK_SELECTOR_FILTER_TAG, + *filters); + filters->AddFilter(std::make_shared(NetworkSelectionUtils::IsHasInternetNetwork, + "hasInternet")); + SetWifiFilter(filters); + auto networkScoreComparator = std::make_shared(m_networkSelectorName); + networkScoreComparator->AddScorer(std::make_shared()); + networkScoreComparator->AddScorer(std::make_shared("hasInternetNetworkScorer")); + networkScoreComparator->AddScorer(std::make_shared()); + SetWifiComparator(networkScoreComparator); +} + +bool HasInternetNetworkSelector::Filter(NetworkCandidate &networkCandidate) +{ + TryNominate(networkCandidate); + return networkCandidates.empty(); +} + +RecoveryNetworkSelector::RecoveryNetworkSelector() : SimpleNetworkSelector("recoveryNetworkSelector"), + SimpleWifiFilter("recoveryNetworkSelector") +{ + auto filters = std::make_shared(); + ExternalWifiFilterBuildManager::GetInstance().BuildFilter(FilterTag::RECOVERY_NETWORK_SELECTOR_FILTER_TAG, + *filters); + filters->AddFilter(std::make_shared(NetworkSelectionUtils::IsRecoveryNetwork, + "recovery")); + SetWifiFilter(filters); + auto networkScorerComparator = std::make_shared(m_networkSelectorName); + networkScorerComparator->AddScorer(std::make_shared("recoveryNetworkScorer")); + networkScorerComparator->AddScorer(std::make_shared()); + SetWifiComparator(networkScorerComparator); +} + +bool RecoveryNetworkSelector::Filter(NetworkCandidate &networkCandidate) +{ + TryNominate(networkCandidate); + return networkCandidates.empty(); +} + +PortalNetworkSelector::PortalNetworkSelector() : SimpleNetworkSelector("portalNetworkSelector"), + OrWifiFilter() +{ + using namespace std; + SetWifiFilter(make_shared(NetworkSelectionUtils::IsPoorPortalNetwork, + "notPoorPortal", true)); + auto networkScorerComparator = make_shared(m_networkSelectorName); + networkScorerComparator->AddScorer(std::make_shared()); + networkScorerComparator->AddScorer(std::make_shared("portalNetworkScorer")); + networkScorerComparator->AddScorer(std::make_shared()); + SetWifiComparator(networkScorerComparator); +} + +void PortalNetworkSelector::InitFilter() +{ + using namespace std; + AddFilter(make_shared(NetworkSelectionUtils::IsPortalNetwork, "portal")); + AddFilter(make_shared(NetworkSelectionUtils::MayBePortalNetwork, "maybePortal")); + ExternalWifiFilterBuildManager::GetInstance().BuildFilter(FilterTag::PORTAL_NETWORK_SELECTOR_FILTER_TAG, *this); +} + +bool PortalNetworkSelector::Filter(NetworkCandidate &networkCandidate) +{ + if (OrWifiFilter::Filter(networkCandidate)) { + TryNominate(networkCandidate); + return false; + } + if (networkCandidates.empty()) { + return true; + } + networkCandidate.filteredMsg.emplace_back(m_networkSelectorName); + return false; +} + +std::string PortalNetworkSelector::GetNetworkSelectorMsg() +{ + std::stringstream networkSelectorMsg; + networkSelectorMsg << R"({ "name": ")" << m_networkSelectorName << "\" "; + std::string filterMsg; + if (!filters.empty()) { + filterMsg += OrWifiFilter::GetFilterMsg(); + } + if (filter) { + if (!filterMsg.empty()) { + filterMsg += "&&"; + } + filterMsg += filter->GetFilterMsg(); + } + if (!filterMsg.empty()) { + networkSelectorMsg << R"(,"filter": ")" << filterMsg << "\""; + } + networkSelectorMsg << "}"; + return networkSelectorMsg.str(); +} + +std::string PortalNetworkSelector::GetFilterMsg() +{ + return m_networkSelectorName; +} + +NoInternetNetworkSelector::NoInternetNetworkSelector() : SimpleNetworkSelector("noInternetNetworkSelector"), + SimpleWifiFilter("noInternetNetworkSelector") +{ + using namespace std; + SetWifiFilter(make_shared(NetworkSelectionUtils::IsNoInternetNetwork, "noInternet")); + auto networkScorerComparator = make_shared(m_networkSelectorName); + networkScorerComparator->AddScorer(make_shared("noInternetNetworkScorer")); + networkScorerComparator->AddScorer(make_shared()); + SetWifiComparator(networkScorerComparator); +} + +bool NoInternetNetworkSelector::Filter(NetworkCandidate &networkCandidate) +{ + TryNominate(networkCandidate); + return false; +} +} +} \ No newline at end of file diff --git a/wifi/services/wifi_standard/wifi_framework/wifi_manage/wifi_sta/network_select/network_selector.h b/wifi/services/wifi_standard/wifi_framework/wifi_manage/wifi_sta/network_select/network_selector.h new file mode 100644 index 000000000..a9b1e48b5 --- /dev/null +++ b/wifi/services/wifi_standard/wifi_framework/wifi_manage/wifi_sta/network_select/network_selector.h @@ -0,0 +1,194 @@ +/* + * Copyright (C) 2021-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. + */ + +#ifndef OHOS_WIFI_NETWORK_SELECTOR_H_ +#define OHOS_WIFI_NETWORK_SELECTOR_H_ +#include "network_selector_comparator.h" +#include "network_selector_filter.h" +#include "network_selection_msg.h" +#include + +namespace OHOS { +namespace Wifi { +class INetworkSelector { +public: + virtual ~INetworkSelector() = default; + + /** + * the function to try nominator the candidate network. + * + * @param networkCandidate candidate network + * @return return true if the candidate network is nominated. + */ + virtual bool TryNominate(NetworkCandidate &networkCandidate) = 0; + + /** + * the function to get best candidate networks. + * @param selectedNetworkCandidates the best candidate networks. + */ + virtual void GetBestCandidates(std::vector &selectedNetworkCandidates) = 0; + + /** + * transfer the info of network selector to json format string. + * @return + */ + virtual std::string GetNetworkSelectorMsg() = 0; +}; + +class NetworkSelector : public INetworkSelector { +public: + + /** + * the function to set comparator。 + * + * @param networkSelectorComparator comparator + */ + void SetWifiComparator(const std::shared_ptr &networkSelectorComparator); + + /** + * the function to set filter. + * + * @param networkSelectorFilter filter + */ + void SetWifiFilter(const std::shared_ptr &networkSelectorFilter); + bool TryNominate(NetworkCandidate &networkCandidate) final; +protected: + + /** + * filter the candidate network + * + * @param networkCandidate candidate network + * @return true if the candidate network pass. + */ + virtual bool DoFilter(NetworkCandidate &networkCandidate) final; + + /** + * get best candidate network by comparator. + * + * @param selectedNetworkCandidates the best candidate networks; + */ + virtual void GetBestCandidatesByComparator(std::vector &selectedNetworkCandidates) final; + + /** + * deal with the candidate network filtered. + * + * @param networkCandidate candidate network + * @return true if the candidate network is added to networkCandidates. + */ + virtual bool Nominate(NetworkCandidate &networkCandidate) = 0; + + /** + * deal with the candidate network after nominate. + * + * @param networkCandidate candidate network + * @param nominateResult whether the candidate network is added to networkCandidates + */ + virtual void AfterNominate(NetworkCandidate &networkCandidate, bool nominateResult); + + std::vector networkCandidates; + std::shared_ptr comparator; + std::shared_ptr filter; +}; + +class SimpleNetworkSelector : public NetworkSelector { +public: + explicit SimpleNetworkSelector(const std::string &networkSelectorName); + std::string GetNetworkSelectorMsg() override; + void GetBestCandidates(std::vector &selectedNetworkCandidates) final; +protected: + void AfterNominate(NetworkCandidate &networkCandidate, bool nominateResult) override; + bool Nominate(NetworkCandidate &networkCandidate) override; + const std::string m_networkSelectorName; +}; + +class CompositeNetworkSelector : public NetworkSelector { +public: + explicit CompositeNetworkSelector(const std::string &networkSelectorName); + + /** + * Add subnetworkSelector for compositeNetworkSelector + * + * @param subNetworkSelector subNetworkSelector + */ + void AddSubNetworkSelector(const std::shared_ptr &subNetworkSelector); + void GetBestCandidates(std::vector &selectedNetworkCandidates) final; + std::string GetNetworkSelectorMsg() override; +protected: + /** + * deal with the candidate network before compare. + */ + virtual void GetCandidatesFromSubNetworkSelector() = 0; + const std::string m_networkSelectorName; + std::vector> subNetworkSelectors; +}; + +class AutoConnectNetworkSelector : public CompositeNetworkSelector { +public: + AutoConnectNetworkSelector(); +protected: + bool Nominate(NetworkCandidate &networkCandidate) override; + void GetCandidatesFromSubNetworkSelector() override; +}; + +class SavedNetworkSelector : public CompositeNetworkSelector { +public: + SavedNetworkSelector(); +protected: + bool Nominate(NetworkCandidate &networkCandidate) override; + void GetCandidatesFromSubNetworkSelector() override; +}; + +class BlackListNetworkSelector : public SimpleNetworkSelector, public SimpleWifiFilter { +public: + BlackListNetworkSelector(); +protected: + bool Nominate(NetworkCandidate &networkCandidate) override; + bool Filter(NetworkCandidate &networkCandidate) override; +}; + +class HasInternetNetworkSelector : public SimpleNetworkSelector, public SimpleWifiFilter { +public: + HasInternetNetworkSelector(); +protected: + bool Filter(NetworkCandidate &networkCandidate) override; +}; + +class RecoveryNetworkSelector : public SimpleNetworkSelector, public SimpleWifiFilter { +public: + RecoveryNetworkSelector(); +protected: + bool Filter(NetworkCandidate &networkCandidate) override; +}; + +class PortalNetworkSelector final : public SimpleNetworkSelector, public OrWifiFilter { +public: + PortalNetworkSelector(); + void InitFilter(); + std::string GetFilterMsg() override; + std::string GetNetworkSelectorMsg() override; +protected: + bool Filter(NetworkCandidate &networkCandidate) override; +}; + +class NoInternetNetworkSelector final : public SimpleNetworkSelector, public SimpleWifiFilter { +public: + explicit NoInternetNetworkSelector(); +protected: + bool Filter(NetworkCandidate &networkCandidate) override; +}; +} +} + +#endif diff --git a/wifi/services/wifi_standard/wifi_framework/wifi_manage/wifi_sta/network_select/network_selector_comparator.cpp b/wifi/services/wifi_standard/wifi_framework/wifi_manage/wifi_sta/network_select/network_selector_comparator.cpp new file mode 100644 index 000000000..631d6b772 --- /dev/null +++ b/wifi/services/wifi_standard/wifi_framework/wifi_manage/wifi_sta/network_select/network_selector_comparator.cpp @@ -0,0 +1,143 @@ +/* + * Copyright (C) 2021-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 "network_selector_comparator.h" +#include "network_selection_utils.h" +#include "wifi_logger.h" +#include + +#define LAST_SELECTION_SCORE_DECAY_S 100 +#define MAX(A, B) (((A) >= (B)) ? (A) : (B)) + +namespace OHOS { +namespace Wifi { +DEFINE_WIFILOG_LABEL("NETWORK_SELECTOR_COMPARATOR") +WifiScorerComparator::WifiScorerComparator(const std::string &comparatorName) + : comparatorName(comparatorName) {} + +void WifiScorerComparator::AddScorer(const std::shared_ptr &scorer) +{ + if (scorer) { + scorers.emplace_back(scorer); + } +} + +void WifiScorerComparator::GetBestCandidates(const std::vector &candidates, + std::vector &selectedCandidates) +{ + if (candidates.empty()) { + return; + } + std::vector bestNetworkCandidates; + std::vector worseNetworkCandidates; + std::vector bestNetworkScoreResults; + bestNetworkCandidates.emplace_back(candidates.at(0)); + for (int i = 1; i < candidates.size(); ++i) { + bool isWorseNetworkCandidate = false; + auto networkCandidate = candidates.at(i); + for (int j = 0; j < scorers.size(); j++) { + auto scorer = scorers.at(j); + ScoreResult scoreResult; + if (bestNetworkScoreResults.size() <= j) { + bestNetworkScoreResults.emplace_back(scoreResult); + scorer->DoScore(*bestNetworkCandidates.front(), bestNetworkScoreResults.at(j)); + } + scorer->DoScore(*networkCandidate, scoreResult); + if (scoreResult.score > bestNetworkScoreResults.at(j).score) { + LogWorseSelectedCandidates(bestNetworkCandidates, *networkCandidate, bestNetworkScoreResults); + bestNetworkScoreResults.erase(bestNetworkScoreResults.begin() + j, bestNetworkScoreResults.end()); + bestNetworkScoreResults.emplace_back(scoreResult); + worseNetworkCandidates.insert(worseNetworkCandidates.end(), + bestNetworkCandidates.begin(), + bestNetworkCandidates.end()); + bestNetworkCandidates.clear(); + break; + } else if (scoreResult.score < bestNetworkScoreResults.at(j).score) { + LogWorseCandidate(*networkCandidate, *bestNetworkCandidates.front(), scoreResult); + worseNetworkCandidates.emplace_back(networkCandidate); + isWorseNetworkCandidate = true; + break; + } + } + if (!isWorseNetworkCandidate) { + bestNetworkCandidates.emplace_back(networkCandidate); + } + } + LogSelectedCandidates(bestNetworkCandidates, bestNetworkScoreResults); + selectedCandidates.insert(selectedCandidates.end(), bestNetworkCandidates.begin(), bestNetworkCandidates.end()); +} + +void WifiScorerComparator::LogSelectedCandidates(std::vector &selectedCandidates, + std::vector &scoreResults) +{ + WIFI_LOGD("%{public}s get best candidates %{public}s which get scores %{public}s", + comparatorName.c_str(), + getAllNetworkCandidateMsg(selectedCandidates).c_str(), + getAllScoreMsg(scoreResults).c_str()); +} + +void WifiScorerComparator::LogWorseSelectedCandidates(std::vector &worseNetworkCandidates, + NetworkCandidate &betterNetworkCandidate, + std::vector &scoreResults) +{ + WIFI_LOGD("%{public}s find a better candidate %{public}s, " + "abandon candidates %{public}s which get scores %{public}s", + comparatorName.c_str(), + NetworkSelectionUtils::GetNetworkCandidateInfo(betterNetworkCandidate).c_str(), + getAllNetworkCandidateMsg(worseNetworkCandidates).c_str(), + getAllScoreMsg(scoreResults).c_str()); +} + +void WifiScorerComparator::LogWorseCandidate(NetworkCandidate &worseNetworkCandidates, + NetworkCandidate &selectedNetworkCandidate, + ScoreResult &scoreResult) +{ + WIFI_LOGD("%{public}s find a worse candidate %{public}s which getScore %{public}s" + ",and current best candidate is %{public}s", + comparatorName.c_str(), + NetworkSelectionUtils::GetNetworkCandidateInfo(worseNetworkCandidates).c_str(), + NetworkSelectionUtils::GetScoreMsg(scoreResult).c_str(), + NetworkSelectionUtils::GetNetworkCandidateInfo(selectedNetworkCandidate).c_str()); +} + +std::string WifiScorerComparator::getAllNetworkCandidateMsg(std::vector &networkCandidates) +{ + std::stringstream scoreMsg; + scoreMsg << "["; + for (auto i = 0; i < networkCandidates.size(); i++) { + scoreMsg << NetworkSelectionUtils::GetNetworkCandidateInfo(*networkCandidates.at(i)); + if (i < networkCandidates.size() - 1) { + scoreMsg << ", "; + } + } + scoreMsg << "]"; + return scoreMsg.str(); +} + +std::string WifiScorerComparator::getAllScoreMsg(std::vector &scoreResults) +{ + std::stringstream scoreMsg; + scoreMsg << "["; + for (auto i = 0; i < scoreResults.size(); i++) { + scoreMsg << NetworkSelectionUtils::GetScoreMsg(scoreResults.at(i)); + if (i < scoreResults.size() - 1) { + scoreMsg << ", "; + } + } + scoreMsg << "]"; + return scoreMsg.str(); +} +} +} // namespace OHOS::Wifi diff --git a/wifi/services/wifi_standard/wifi_framework/wifi_manage/wifi_sta/network_select/network_selector_comparator.h b/wifi/services/wifi_standard/wifi_framework/wifi_manage/wifi_sta/network_select/network_selector_comparator.h new file mode 100644 index 000000000..ee9e7600d --- /dev/null +++ b/wifi/services/wifi_standard/wifi_framework/wifi_manage/wifi_sta/network_select/network_selector_comparator.h @@ -0,0 +1,71 @@ +/* + * Copyright (C) 2021-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. + */ + +#ifndef OHOS_WIFI_NETWORK_SELECT_SCORER_H +#define OHOS_WIFI_NETWORK_SELECT_SCORER_H + +#include +#include +#include "network_selector_scorer.h" + +namespace OHOS { +namespace Wifi { + +class IWifiComparator { +public: + virtual ~IWifiComparator() = default; + + /** + * GetBestCandidates + * + * @param candidates the candidate network before compare. + * @param selectedCandidates the best candidate network after compare. + */ + virtual void GetBestCandidates(const std::vector &candidates, + std::vector &selectedCandidates) = 0; +}; + +class WifiScorerComparator : public IWifiComparator { +public: + explicit WifiScorerComparator(const std::string &comparatorName); + /** + * AddScorer + * + * @param scorer the score for candidate network. + */ + void AddScorer(const std::shared_ptr &scorer); + + void GetBestCandidates(const std::vector &candidates, + std::vector &selectedCandidates) override; +private: + void LogSelectedCandidates(std::vector &selectedCandidates, + std::vector &scoreResults); + void LogWorseSelectedCandidates(std::vector &worseNetworkCandidates, + NetworkCandidate &betterNetworkCandidate, + std::vector &scoreResults); + void LogWorseCandidate(NetworkCandidate &worseNetworkCandidates, + NetworkCandidate &selectedNetworkCandidate, + ScoreResult &scoreResults); + + std::string getAllNetworkCandidateMsg(std::vector &networkCandidates); + std::string getAllScoreMsg(std::vector &scoreResults); + std::vector> scorers; + std::string comparatorName; +}; + +} +} // namespace OHOS::Wifi + +#endif diff --git a/wifi/services/wifi_standard/wifi_framework/wifi_manage/wifi_sta/network_select/network_selector_factory.cpp b/wifi/services/wifi_standard/wifi_framework/wifi_manage/wifi_sta/network_select/network_selector_factory.cpp new file mode 100644 index 000000000..25f2fa944 --- /dev/null +++ b/wifi/services/wifi_standard/wifi_framework/wifi_manage/wifi_sta/network_select/network_selector_factory.cpp @@ -0,0 +1,47 @@ +/* + * Copyright (C) 2021-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 "network_selector_factory.h" +#include "wifi_logger.h" + +#include + +namespace OHOS { +namespace Wifi { +DEFINE_WIFILOG_LABEL("NETWORK_SELECTOR_FACTORY") + +ErrCode NetworkSelectorFactory::InitNetworkSelectorFactory() +{ + handleFuncMap[static_cast(NetworkSelectType::AUTO_CONNECT)] = + &NetworkSelectorFactory::CreateAutoConnectNetworkSelector; + return WIFI_OPT_SUCCESS; +} + +std::unique_ptr NetworkSelectorFactory::GetNetworkSelector(NetworkSelectType networkSelectType) +{ + auto iter = handleFuncMap.find(static_cast(networkSelectType)); + if (iter != handleFuncMap.end()) { + return (this->*(iter->second))(); + } + WIFI_LOGE("not find function to deal, code %{public}u", static_cast(networkSelectType)); + return nullptr; +} + +std::unique_ptr NetworkSelectorFactory::CreateAutoConnectNetworkSelector() +{ + return std::make_unique(); +} +} +} // namespace OHOS::Wifi diff --git a/wifi/services/wifi_standard/wifi_framework/wifi_manage/wifi_sta/network_select/network_selector_factory.h b/wifi/services/wifi_standard/wifi_framework/wifi_manage/wifi_sta/network_select/network_selector_factory.h new file mode 100644 index 000000000..eb924295b --- /dev/null +++ b/wifi/services/wifi_standard/wifi_framework/wifi_manage/wifi_sta/network_select/network_selector_factory.h @@ -0,0 +1,49 @@ +/* + * Copyright (C) 2021-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. + */ + +#ifndef OHOS_WIFI_NETWORK_SELECTOR_FACTORY_H +#define OHOS_WIFI_NETWORK_SELECTOR_FACTORY_H +#include +#include "network_selector.h" +#include "wifi_errcode.h" + +namespace OHOS { +namespace Wifi { +enum class NetworkSelectType { AUTO_CONNECT }; +class NetworkSelectorFactory { +public: + ErrCode InitNetworkSelectorFactory(); + using handleFunc = std::unique_ptr (NetworkSelectorFactory::*)(); + using HandleFuncMap = std::map; + + /** + * get network selector by type + * @param networkSelectType + * @return the network selector + */ + std::unique_ptr GetNetworkSelector(NetworkSelectType networkSelectType); + + /** + * the function to create autoConnect networkSelector + * @return the network selector + */ + std::unique_ptr CreateAutoConnectNetworkSelector(); +private: + HandleFuncMap handleFuncMap; +}; +} +} // namespace OHOS::Wifi + +#endif diff --git a/wifi/services/wifi_standard/wifi_framework/wifi_manage/wifi_sta/network_select/network_selector_filter.cpp b/wifi/services/wifi_standard/wifi_framework/wifi_manage/wifi_sta/network_select/network_selector_filter.cpp new file mode 100644 index 000000000..df09966b0 --- /dev/null +++ b/wifi/services/wifi_standard/wifi_framework/wifi_manage/wifi_sta/network_select/network_selector_filter.cpp @@ -0,0 +1,104 @@ +/* + * Copyright (C) 2021-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 "network_selector_filter.h" +namespace OHOS { +namespace Wifi { + +bool IWifiFilter::DoFilter(OHOS::Wifi::NetworkCandidate &networkCandidate) +{ + bool filterResult = Filter(networkCandidate); + AfterFilter(networkCandidate, filterResult); + return filterResult; +} + +void IWifiFilter::AfterFilter(OHOS::Wifi::NetworkCandidate &networkCandidate, + bool filterResult) {} + +SimpleWifiFilter::SimpleWifiFilter(const std::string &networkSelectorFilterName) + : IWifiFilter(), filterName(networkSelectorFilterName) {} + +void SimpleWifiFilter::AfterFilter(OHOS::Wifi::NetworkCandidate &networkCandidate, bool filterResult) +{ + if (!filterResult) { + networkCandidate.filteredMsg.emplace_back(filterName); + } +} + +std::string SimpleWifiFilter::GetFilterMsg() +{ + return filterName; +} + +WifiFunctionFilter::WifiFunctionFilter(const std::function &filter, + const std::string &networkSelectorFilterName, + bool reverse) + : SimpleWifiFilter(networkSelectorFilterName), filterFunction(filter), iSReverse(reverse) {} + +bool WifiFunctionFilter::Filter(NetworkCandidate &networkCandidate) +{ + return iSReverse != filterFunction.operator()(networkCandidate); +} + +void CompositeWifiFilter::AddFilter(const std::shared_ptr &filter) +{ + if (filter) { + filters.emplace_back(filter); + } +} + +bool AndWifiFilter::Filter(NetworkCandidate &networkCandidate) +{ + return std::all_of(filters.begin(), filters.end(), [&networkCandidate](auto filter) { + return filter->DoFilter(networkCandidate); + }); +} + +std::string AndWifiFilter::GetFilterMsg() +{ + std::stringstream filterMsg; + filterMsg << "("; + for (auto i = 0; i < filters.size(); i++) { + filterMsg << filters.at(i)->GetFilterMsg(); + if (i < filters.size() - 1) { + filterMsg << "&&"; + } + } + filterMsg << ")"; + return filterMsg.str(); +} + +bool OrWifiFilter::Filter(NetworkCandidate &networkCandidate) +{ + return std::any_of(filters.begin(), filters.end(), [&networkCandidate](auto filter) { + return filter->DoFilter(networkCandidate); + }); +} + +std::string OrWifiFilter::GetFilterMsg() +{ + std::stringstream filterMsg; + filterMsg << "("; + for (auto i = 0; i < filters.size(); i++) { + filterMsg << filters.at(i)->GetFilterMsg(); + if (i < filters.size() - 1) { + filterMsg << "||"; + } + } + filterMsg << ")"; + return filterMsg.str(); +} +} +} \ No newline at end of file diff --git a/wifi/services/wifi_standard/wifi_framework/wifi_manage/wifi_sta/network_select/network_selector_filter.h b/wifi/services/wifi_standard/wifi_framework/wifi_manage/wifi_sta/network_select/network_selector_filter.h new file mode 100644 index 000000000..068f29771 --- /dev/null +++ b/wifi/services/wifi_standard/wifi_framework/wifi_manage/wifi_sta/network_select/network_selector_filter.h @@ -0,0 +1,104 @@ +/* + * Copyright (C) 2021-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. + */ + +#ifndef OHOS_WIFI_NETWORK_SELECTOR_FILTER_H_ +#define OHOS_WIFI_NETWORK_SELECTOR_FILTER_H_ +#include "network_selection_msg.h" + +namespace OHOS { +namespace Wifi { +class IWifiFilter { +public: + virtual ~IWifiFilter() = default; + + /** + * filter the candidate network + * @param networkCandidate candidate network. + * @return true if the candidate network satisfy the condition + */ + virtual bool DoFilter(NetworkCandidate &networkCandidate) final; + virtual std::string GetFilterMsg() = 0; +protected: + + /** + * filter the candidate network + * @param networkCandidate candidate network. + * @return true if the candidate network satisfy the condition + */ + virtual bool Filter(NetworkCandidate &networkCandidate) = 0; + + /** + * deal with the candidate network after filter + * @param networkCandidate candidate network. + * @param filterResult if the candidate network satisfy the condition + */ + virtual void AfterFilter(NetworkCandidate &networkCandidate, bool filterResult); +}; + +class SimpleWifiFilter : public IWifiFilter { +public: + explicit SimpleWifiFilter(const std::string &networkSelectorFilterName); + std::string GetFilterMsg() final; +protected: + void AfterFilter(NetworkCandidate &networkCandidate, bool filterResult) override; + std::string filterName; +}; + +class WifiFunctionFilter : public SimpleWifiFilter { +public: + + /** + * + * @param filter the point to filterFunction + * @param networkSelectorFilterName the filterName + * @param reverse for default it should be filtered when the function return true, And it can be modified; + */ + WifiFunctionFilter(const std::function &filter, + const std::string &networkSelectorFilterName, + bool reverse = false); +protected: + bool Filter(NetworkCandidate &networkCandidate) override; + std::function filterFunction; + bool iSReverse; +}; + +class CompositeWifiFilter : public IWifiFilter { +public: + CompositeWifiFilter() = default; + /** + * Add Filter for composite network selector filter + * @param filter filter + */ + virtual void AddFilter(const std::shared_ptr &filter); +protected: + std::vector> filters; +}; + +class AndWifiFilter : public CompositeWifiFilter { +public: + AndWifiFilter() = default; + bool Filter(NetworkCandidate &networkCandidate) override; + std::string GetFilterMsg() override; +}; + +class OrWifiFilter : public CompositeWifiFilter { +public: + OrWifiFilter() = default; + bool Filter(NetworkCandidate &networkCandidate) override; + std::string GetFilterMsg() override; +}; +} +} +#endif diff --git a/wifi/services/wifi_standard/wifi_framework/wifi_manage/wifi_sta/network_select/network_selector_scorer.cpp b/wifi/services/wifi_standard/wifi_framework/wifi_manage/wifi_sta/network_select/network_selector_scorer.cpp new file mode 100644 index 000000000..7a5564c55 --- /dev/null +++ b/wifi/services/wifi_standard/wifi_framework/wifi_manage/wifi_sta/network_select/network_selector_scorer.cpp @@ -0,0 +1,257 @@ +/* + * Copyright (C) 2021-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 "network_selector_scorer.h" +#include "wifi_settings.h" +#include "network_status_history_manager.h" +#include + +namespace OHOS { +namespace Wifi { +namespace { +constexpr int SUFFICIENT_RSSI_5G = -70; +constexpr int SUFFICIENT_RSSI_2G = -73; +constexpr int RSSI_SCORE_OFFSET = 85; +constexpr int RSSI_SCORE_SLOPE_IS_4 = 4; +constexpr int TOP_TIME_BASE_SCORE = 1000000; +constexpr int MAX_RECENT_SELECTION_SECONDS = 8 * 60 * 60; +constexpr int MIN_5G_FREQUENCY = 5160; +constexpr int MAX_5G_FREQUENCY = 5865; +constexpr int WIFI_5G_BAND_SCORE = 50; +constexpr int WIFI_2G_BAND_SCORE = 20; +constexpr int SECURITY_BONUS_SCORE = 5; +constexpr int RSSI_LEVEL_FOUR_SCORE = 80; +constexpr int RSSI_LEVEL_THREE_SCORE = 60; +constexpr int RSSI_LEVEL_TWO_SCORE = 20; +constexpr int SIGNAL_LEVEL_TWO = 2; +constexpr int SIGNAL_LEVEL_THREE = 3; +constexpr int SIGNAL_LEVEL_FOUR = 4; +constexpr int MIN_RSSI = -128; +constexpr int INTERNET_ACCESS_AWARD = 2; +constexpr int EMPTY_NETWORK_STATUS_HISTORY_AWARD = 1; +} + +SimpleWifiScorer::SimpleWifiScorer(const std::string &scorerName) + : IWifiScorer(), m_scoreName(scorerName) {} + +void SimpleWifiScorer::DoScore(NetworkCandidate &networkCandidate, + ScoreResult &scoreResult) +{ + scoreResult.scorerName = m_scoreName; + scoreResult.score = Score(networkCandidate); +} + +CompositeWifiScorer::CompositeWifiScorer(const std::string &scorerName) + : IWifiScorer(), m_scoreName(scorerName) {} + +void CompositeWifiScorer::AddScorer(const std::shared_ptr &scorer) +{ + scorers.emplace_back(scorer); +} + +void CompositeWifiScorer::DoScore(NetworkCandidate &networkCandidate, + ScoreResult &scoreResult) +{ + scoreResult.scorerName = m_scoreName; + for (auto &score : scorers) { + if (score) { + ScoreResult score_result; + score->DoScore(networkCandidate, score_result); + scoreResult.scoreDetails.emplace_back(score_result); + scoreResult.score += score_result.score; + } + } +} + +RssiScorer::RssiScorer() : SimpleWifiScorer("rssiScorer") {} + +double RssiScorer::Score(NetworkCandidate &networkCandidate) +{ + if (networkCandidate.interScanInfo.rssi < MIN_RSSI) { + return 0; + } else if (networkCandidate.interScanInfo.rssi > 0) { + return 0 - MIN_RSSI; + } + return networkCandidate.interScanInfo.rssi - MIN_RSSI; +} + +LastHaveInternetTimeScorer::LastHaveInternetTimeScorer() : SimpleWifiScorer( + "lastHaveInternetTimeScorer") {} + +double LastHaveInternetTimeScorer::Score(NetworkCandidate &networkCandidate) +{ + if (networkCandidate.wifiDeviceConfig.lastHasInternetTime > 0) { + return networkCandidate.wifiDeviceConfig.lastHasInternetTime; + } + return 0; +} + +NetworkStatusHistoryScorer::NetworkStatusHistoryScorer() + : SimpleWifiScorer("networkStatusHistoryScorer") {} + +double NetworkStatusHistoryScorer::Score(NetworkCandidate &networkCandidate) +{ + auto networkStatusHistory = networkCandidate.wifiDeviceConfig.networkStatusHistory; + if (NetworkStatusHistoryManager::IsInternetAccessByNumCheck(networkStatusHistory)) { + return INTERNET_ACCESS_AWARD; + } else if (NetworkStatusHistoryManager::IsEmptyNetworkHistoryByNumCheck(networkStatusHistory)) { + return EMPTY_NETWORK_STATUS_HISTORY_AWARD; + } + return 0; +} + +double ThroughputScorer::GetRssiBaseScore(NetworkCandidate &networkCandidate) +{ + int rssi = networkCandidate.interScanInfo.rssi; + if (networkCandidate.interScanInfo.band == static_cast(BandType::BAND_2GHZ)) { + rssi = rssi > SUFFICIENT_RSSI_2G ? SUFFICIENT_RSSI_2G : rssi; + } else { + rssi = rssi > SUFFICIENT_RSSI_5G ? SUFFICIENT_RSSI_5G : rssi; + } + return (rssi + RSSI_SCORE_OFFSET) * RSSI_SCORE_SLOPE_IS_4; +} + +double ThroughputScorer::GetSavedNetworkAward(NetworkCandidate &networkCandidate) +{ + return networkCandidate.wifiDeviceConfig.isEphemeral ? 0 : SAVED_NETWORK_AWARD_SCORE; +} + +bool ThroughputScorer::IsRecentUserSelected(NetworkCandidate &networkCandidate) const +{ + auto userLastSelectedNetworkId = WifiSettings::GetInstance().GetUserLastSelectedNetworkId(); + if (userLastSelectedNetworkId != INVALID_NETWORK_ID + && userLastSelectedNetworkId == networkCandidate.wifiDeviceConfig.networkId) { + time_t userLastSelectedNetworkTimeVal = + WifiSettings::GetInstance().GetUserLastSelectedNetworkTimeVal(); + return time(nullptr) - userLastSelectedNetworkTimeVal < MAX_RECENT_SELECTION_SECONDS; + } + return false; +} + +bool ThroughputScorer::IsSecurityNetwork(NetworkCandidate &networkCandidate) const +{ + return networkCandidate.wifiDeviceConfig.keyMgmt == KEY_MGMT_WEP + || networkCandidate.wifiDeviceConfig.keyMgmt == KEY_MGMT_WPA_PSK + || networkCandidate.wifiDeviceConfig.keyMgmt == KEY_MGMT_SAE + || networkCandidate.wifiDeviceConfig.keyMgmt == KEY_MGMT_EAP; +} + +void ThroughputScorer::DoScore(NetworkCandidate &networkCandidate, + ScoreResult &scoreResult) +{ + double rssiBaseScore = GetRssiBaseScore(networkCandidate); + double savedNetworkAward = GetSavedNetworkAward(networkCandidate); + scoreResult.scorerName = "ThroughputScorer"; + if (IsRecentUserSelected(networkCandidate)) { + scoreResult.score = TOP_TIME_BASE_SCORE + rssiBaseScore + savedNetworkAward; + return; + } + scoreResult.score = rssiBaseScore + savedNetworkAward; + if (IsSecurityNetwork(networkCandidate)) { + scoreResult.score += SECURITY_AWARD_SCORE; + } +} + +SecurityBonusScorer::SecurityBonusScorer() : SimpleWifiScorer("securityScore") {} + +bool SecurityBonusScorer::IsHigherSecurityTypeFromScanResult(const OHOS::Wifi::InterScanInfo &interScanInfo) +{ + return IsEncryptionSae(interScanInfo) || IsEncryptionPskSaeTransition(interScanInfo) + || IsEncryptionOwe(interScanInfo) || IsEncryptionOweTransition(interScanInfo) + || IsWpa3EnterpriseOnlyNetwork(interScanInfo) || IsWpa3EnterpriseTransitionNetwork(interScanInfo); +} + +bool SecurityBonusScorer::IsEncryptionSae(const OHOS::Wifi::InterScanInfo &interScanInfo) +{ + return ExistSecurityType(interScanInfo, "SAE"); +} + +bool SecurityBonusScorer::IsEncryptionPskSaeTransition(const OHOS::Wifi::InterScanInfo &interScanInfo) +{ + return ExistSecurityType(interScanInfo, "PSK") && ExistSecurityType(interScanInfo, "SAE"); +} + +bool SecurityBonusScorer::IsEncryptionOwe(const OHOS::Wifi::InterScanInfo &interScanInfo) +{ + return ExistSecurityType(interScanInfo, "OWE"); +} + +bool SecurityBonusScorer::IsEncryptionOweTransition(const InterScanInfo &interScanInfo) +{ + return ExistSecurityType(interScanInfo, "OWE_TRANSITION"); +} + +bool SecurityBonusScorer::IsWpa3EnterpriseOnlyNetwork(const OHOS::Wifi::InterScanInfo &interScanInfo) +{ + return ExistSecurityType(interScanInfo, "EAP/SHA256") && !ExistSecurityType(interScanInfo, "EAP/SHA1") + && ExistSecurityType(interScanInfo, "RSN") && !ExistSecurityType(interScanInfo, "WEP") + && !ExistSecurityType(interScanInfo, "TKIP") + && (ExistSecurityType(interScanInfo, "[MFPR]") || ExistSecurityType(interScanInfo, "[PMFR]")) + && (ExistSecurityType(interScanInfo, "[MFPC]") || ExistSecurityType(interScanInfo, "[PMFC]")); +} + +bool SecurityBonusScorer::IsWpa3EnterpriseTransitionNetwork(const OHOS::Wifi::InterScanInfo &interScanInfo) +{ + return ExistSecurityType(interScanInfo, "EAP/SHA1") && ExistSecurityType(interScanInfo, "EAP/SHA256") + && ExistSecurityType(interScanInfo, "RSN") && !ExistSecurityType(interScanInfo, "WEP") + && !ExistSecurityType(interScanInfo, "TKIP") + && !(ExistSecurityType(interScanInfo, "[MFPR]") || ExistSecurityType(interScanInfo, "[PMFR]")) + && (ExistSecurityType(interScanInfo, "[MFPC]") || ExistSecurityType(interScanInfo, "[PMFC]")); +} + +bool SecurityBonusScorer::ExistSecurityType(const InterScanInfo &interScanInfo, std::string securityType) +{ + return interScanInfo.capabilities.find(securityType) != std::string::npos; +} + +double SecurityBonusScorer::Score(NetworkCandidate &networkCandidate) +{ + return IsHigherSecurityTypeFromScanResult(networkCandidate.interScanInfo) ? SECURITY_BONUS_SCORE : 0; +} + +RssiLevelBonusScorer::RssiLevelBonusScorer() : SimpleWifiScorer("rssiLevelScore") {} + +double RssiLevelBonusScorer::Score(NetworkCandidate &networkCandidate) +{ + auto &scanInfo = networkCandidate.interScanInfo; + int currentSignalLevel = WifiSettings::GetInstance().GetSignalLevel(scanInfo.rssi, scanInfo.band); + if (currentSignalLevel == SIGNAL_LEVEL_FOUR) { + return RSSI_LEVEL_FOUR_SCORE; + } + if (currentSignalLevel == SIGNAL_LEVEL_THREE) { + return RSSI_LEVEL_THREE_SCORE; + } + if (currentSignalLevel == SIGNAL_LEVEL_TWO) { + return RSSI_LEVEL_TWO_SCORE; + } + return 0; +} + +Network5gBonusScorer::Network5gBonusScorer() : SimpleWifiScorer("5gBonusScore") {} + +double Network5gBonusScorer::Score(NetworkCandidate &networkCandidate) +{ + int frequency = networkCandidate.interScanInfo.frequency; + return frequency >= MIN_5G_FREQUENCY && frequency <= MAX_5G_FREQUENCY ? WIFI_5G_BAND_SCORE : WIFI_2G_BAND_SCORE; +} + +SavedNetworkScorer::SavedNetworkScorer(const std::string &scorerName) : CompositeWifiScorer(scorerName) +{ + AddScorer(std::make_shared()); + AddScorer(std::make_shared()); + AddScorer(std::make_shared()); +} +} +} \ No newline at end of file diff --git a/wifi/services/wifi_standard/wifi_framework/wifi_manage/wifi_sta/network_select/network_selector_scorer.h b/wifi/services/wifi_standard/wifi_framework/wifi_manage/wifi_sta/network_select/network_selector_scorer.h new file mode 100644 index 000000000..9a6e45846 --- /dev/null +++ b/wifi/services/wifi_standard/wifi_framework/wifi_manage/wifi_sta/network_select/network_selector_scorer.h @@ -0,0 +1,187 @@ +/* + * Copyright (C) 2021-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. + */ + +#ifndef OHOS_WIFI_NETWORK_SELECTOR_SCORER_H_ +#define OHOS_WIFI_NETWORK_SELECTOR_SCORER_H_ +#include +#include +#include +#include +#include +#include "network_selection_msg.h" + +namespace OHOS { +namespace Wifi { + +struct ScoreResult { + double score; + std::string scorerName; + std::vector scoreDetails; + ScoreResult() + { + score = 0; + } +}; + +class IWifiScorer { +public: + virtual ~IWifiScorer() = default; + virtual void DoScore(NetworkCandidate &networkCandidate, ScoreResult &scoreResult) = 0; +}; + +class SimpleWifiScorer : public IWifiScorer { +public: + explicit SimpleWifiScorer(const std::string &scorerName); + void DoScore(NetworkCandidate &networkCandidate, ScoreResult &scoreResult) final; +protected: + virtual double Score(NetworkCandidate &networkCandidate) = 0; + std::string m_scoreName; +}; + +class CompositeWifiScorer : public IWifiScorer { +public: + explicit CompositeWifiScorer(const std::string &scorerName); + void DoScore(NetworkCandidate &networkCandidate, ScoreResult &scoreResult) final; + void AddScorer(const std::shared_ptr &scorer); +protected: + std::vector> scorers; + std::string m_scoreName; +}; + +class RssiScorer : public SimpleWifiScorer { +public: + RssiScorer(); + double Score(NetworkCandidate &networkCandidate) override; +}; + +class LastHaveInternetTimeScorer : public SimpleWifiScorer { +public: + LastHaveInternetTimeScorer(); + double Score(NetworkCandidate &networkCandidate) override; +}; + +class NetworkStatusHistoryScorer : public SimpleWifiScorer { +public: + NetworkStatusHistoryScorer(); + double Score(NetworkCandidate &networkCandidate) override; +}; + +class ThroughputScorer : public IWifiScorer { +public: + void DoScore(NetworkCandidate &networkCandidate, ScoreResult &scoreResult) override; + +private: + static double GetRssiBaseScore(NetworkCandidate &networkCandidate); + + static double GetSavedNetworkAward(NetworkCandidate &networkCandidate); + + bool IsRecentUserSelected(NetworkCandidate &networkCandidate) const; + + bool IsSecurityNetwork(NetworkCandidate &networkCandidate) const; + static constexpr int SECURITY_AWARD_SCORE = 40; + static constexpr int SAVED_NETWORK_AWARD_SCORE = 40; +}; + +class SecurityBonusScorer : public SimpleWifiScorer { +public: + SecurityBonusScorer(); + double Score(NetworkCandidate &networkCandidate) override; +private: + /** + * Function to determine whether the security type of the scanInfo is more secure. + * + * @param interScanInfo scanInfo + * @return true if the security of the scanInfo is more secure. + */ + bool IsHigherSecurityTypeFromScanResult(const InterScanInfo &interScanInfo); + + /** + * Function to determine whether the security type of the scanInfo is Sae. + * + * @param interScanInfo scanInfo + * @return true if the security of the scanInfo is Sae. + */ + bool IsEncryptionSae(const InterScanInfo &interScanInfo); + + /** + * Function to determine whether the security type of the scanInfo is PskSae. + * + * @param interScanInfo scanInfo + * @return true if the security of the scanInfo is PskSae. + */ + bool IsEncryptionPskSaeTransition(const InterScanInfo &interScanInfo); + + /** + * Function to determine whether the security type of the scanInfo is Owe. + * + * @param interScanInfo scanInfo + * @return true if the security of the scanInfo is Owe. + */ + bool IsEncryptionOwe(const InterScanInfo &interScanInfo); + + /** + * Function to determine whether the security type of the scanInfo is OweTransition. + * + * @param interScanInfo scanInfo + * @return true if the security of the scanInfo is OweTransition. + */ + bool IsEncryptionOweTransition(const InterScanInfo &interScanInfo); + + /** + * Function to determine whether the security type of the scanInfo is Wpa3EnterpriseOnly. + * + * @param interScanInfo scanInfo + * @return true if the security of the scanInfo is Wpa3EnterpriseOnly. + */ + bool IsWpa3EnterpriseOnlyNetwork(const InterScanInfo &interScanInfo); + + /** + * Function to determine whether the security type of the scanInfo is Wpa3EnterpriseTransition. + * + * @param interScanInfo scanInfo + * @return true if the security of the scanInfo is Wpa3EnterpriseTransition. + */ + bool IsWpa3EnterpriseTransitionNetwork(const InterScanInfo &interScanInfo); + + /** + * Function to determine whether the security type is existed in the scanInfo. + * + * @param interScanInfo scanInfo + * @param securityType target security type + * @return true if the security type existed + */ + bool ExistSecurityType(const InterScanInfo &interScanInfo, std::string securityType); +}; + +class RssiLevelBonusScorer : public SimpleWifiScorer { +public: + RssiLevelBonusScorer(); + double Score(NetworkCandidate &networkCandidate) override; +}; + +class Network5gBonusScorer : public SimpleWifiScorer { +public: + Network5gBonusScorer(); + double Score(NetworkCandidate &networkCandidate) override; +}; + +class SavedNetworkScorer : public CompositeWifiScorer { +public: + explicit SavedNetworkScorer(const std::string &scorerName); +}; +} +} + +#endif diff --git a/wifi/services/wifi_standard/wifi_framework/wifi_manage/wifi_sta/network_status_history_manager.cpp b/wifi/services/wifi_standard/wifi_framework/wifi_manage/wifi_sta/network_status_history_manager.cpp new file mode 100644 index 000000000..727713881 --- /dev/null +++ b/wifi/services/wifi_standard/wifi_framework/wifi_manage/wifi_sta/network_status_history_manager.cpp @@ -0,0 +1,130 @@ +/* + * Copyright (C) 2021-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 "network_status_history_manager.h" + +namespace OHOS { +namespace Wifi { + +namespace { +constexpr int THRESHOLD_CHECKED_NUM = 2; +constexpr int THIRD_FROM_LAST = 1; +constexpr int SECOND_FORM_LAST = 2; +} + +void NetworkStatusHistoryManager::Insert(uint32_t &networkStatusHistory, NetworkStatus networkStatus) +{ + networkStatusHistory = + (networkStatusHistory << ITEM_BIT_NUM | static_cast(networkStatus)) & NETWORK_STATUS_HISTORY_MAX_MASK; +} + +void NetworkStatusHistoryManager::Update(uint32_t &networkStatusHistory, NetworkStatus networkStatus) +{ + networkStatusHistory = networkStatusHistory >> ITEM_BIT_NUM; + Insert(networkStatusHistory, networkStatus); +} + +NetworkStatus NetworkStatusHistoryManager::GetLastNetworkStatus(const uint32_t &networkHistory) +{ + return static_cast(networkHistory & NETWORK_STATUS_MASK); +} + +void NetworkStatusHistoryManager::CountNetworkStatus(const uint32_t &networkStatusHistory, int counts[4]) +{ + auto history = networkStatusHistory; + while (history) { + NetworkStatus networkStatus = GetLastNetworkStatus(history); + counts[static_cast(networkStatus)]++; + history = history >> ITEM_BIT_NUM; + } +} + +bool NetworkStatusHistoryManager::IsInternetAccessByNumCheck(const uint32_t &networkStatusHistory) +{ + int counts[4] = {0}; + CountNetworkStatus(networkStatusHistory, counts); + int checkedNum = counts[static_cast(NetworkStatus::HAS_INTERNET)] + + counts[static_cast(NetworkStatus::PORTAL)] + + counts[static_cast(NetworkStatus::NO_INTERNET)]; + if (checkedNum == 0) { + return false; + } + if (GetLastNetworkStatus(networkStatusHistory) == NetworkStatus::HAS_INTERNET) { + return true; + } + if (checkedNum == THRESHOLD_CHECKED_NUM) { + return GetLastNetworkStatus(networkStatusHistory >> ITEM_BIT_NUM) == NetworkStatus::HAS_INTERNET; + } + return counts[static_cast(NetworkStatus::HAS_INTERNET)] >= checkedNum * RECOVERY_PERCENTAGE; +} + +bool NetworkStatusHistoryManager::IsRecoveryByNumCheck(const uint32_t &networkStatusHistory) +{ + int counts[4] = {0}; + CountNetworkStatus(networkStatusHistory, counts); + int checkedNum = counts[static_cast(NetworkStatus::HAS_INTERNET)] + + counts[static_cast(NetworkStatus::PORTAL)] + + counts[static_cast(NetworkStatus::NO_INTERNET)]; + if (checkedNum < THRESHOLD_CHECKED_NUM) { + return false; + } + if (checkedNum == THRESHOLD_CHECKED_NUM) { + return GetLastNetworkStatus(networkStatusHistory >> SECOND_FORM_LAST * ITEM_BIT_NUM) + == NetworkStatus::HAS_INTERNET; + } + if (GetLastNetworkStatus(networkStatusHistory) != NetworkStatus::HAS_INTERNET && + GetLastNetworkStatus(networkStatusHistory >> SECOND_FORM_LAST * ITEM_BIT_NUM) != NetworkStatus::HAS_INTERNET) { + return false; + } + if (GetLastNetworkStatus(networkStatusHistory >> SECOND_FORM_LAST * ITEM_BIT_NUM) == NetworkStatus::HAS_INTERNET && + GetLastNetworkStatus(networkStatusHistory >> THIRD_FROM_LAST * ITEM_BIT_NUM) == NetworkStatus::HAS_INTERNET) { + return true; + } + return counts[static_cast(NetworkStatus::HAS_INTERNET)] >= checkedNum * RECOVERY_PERCENTAGE; +} + +bool NetworkStatusHistoryManager::IsPortalByNumCheck(const uint32_t &networkStatusHistory) +{ + int counts[4] = {0}; + CountNetworkStatus(networkStatusHistory, counts); + return counts[static_cast(NetworkStatus::PORTAL)] > 0; +} + +bool NetworkStatusHistoryManager::HasInternetEverByNumCheck(const uint32_t &networkStatusHistory) +{ + int counts[4] = {0}; + CountNetworkStatus(networkStatusHistory, counts); + return counts[static_cast(NetworkStatus::HAS_INTERNET)] > 0; +} + +bool NetworkStatusHistoryManager::IsEmptyNetworkHistoryByNumCheck(const uint32_t &networkStatusHistory) +{ + return !networkStatusHistory; +} + +std::string NetworkStatusHistoryManager::ToString(const uint32_t &networkStatusHistory) +{ + std::stringstream networkStatusString; + auto history = networkStatusHistory; + while (history) { + NetworkStatus networkStatus = GetLastNetworkStatus(history); + networkStatusString << static_cast(networkStatus) << "/"; + history = history >> ITEM_BIT_NUM; + } + return networkStatusString.str(); +} +} +} \ No newline at end of file diff --git a/wifi/services/wifi_standard/wifi_framework/wifi_manage/wifi_sta/network_status_history_manager.h b/wifi/services/wifi_standard/wifi_framework/wifi_manage/wifi_sta/network_status_history_manager.h new file mode 100644 index 000000000..cdfbac524 --- /dev/null +++ b/wifi/services/wifi_standard/wifi_framework/wifi_manage/wifi_sta/network_status_history_manager.h @@ -0,0 +1,136 @@ +/* + * Copyright (C) 2021-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. + */ + +#ifndef COMMUNICATION_WIFI_NETWORK_STATUS_HISTORY_MANAGER_H +#define COMMUNICATION_WIFI_NETWORK_STATUS_HISTORY_MANAGER_H + +#include +#include +namespace OHOS { +namespace Wifi { +enum class NetworkStatus { + UNKNOWN, + HAS_INTERNET, + PORTAL, + NO_INTERNET +}; + +class NetworkStatusHistoryManager { +public: + + /** + * Insert the network status records + * @param networkStatusHistory historical network status records + * @param networkStatus target network status; + */ + static void Insert(uint32_t &networkStatusHistory, NetworkStatus networkStatus); + + /** + * Update the network status records + * + * @param networkStatusHistory historical network status records + * @param networkStatus target status; + */ + static void Update(uint32_t &networkStatusHistory, NetworkStatus networkStatus); + + /** + * determine whether to access the internet based on historical network records; + * + * @param networkStatusHistory historical network status records + * @return whether to access the internet + */ + static bool IsInternetAccessByNumCheck(const uint32_t &networkStatusHistory); + + /** + * determine whether the access to internet recovery based on historical network records + * + * @param networkStatusHistory historical network status records + * @return whether the access to internet recovery + */ + static bool IsRecoveryByNumCheck(const uint32_t &networkStatusHistory); + + /** + * determine whether the network is portal based on historical network records + * + * @param networkStatusHistory + * @return + */ + static bool IsPortalByNumCheck(const uint32_t &networkStatusHistory); + + /** + * determine whether the network has internet ever on historical network records + * + * @param networkStatusHistory + * @return + */ + static bool HasInternetEverByNumCheck(const uint32_t &networkStatusHistory); + + /** + * determine whether the network has no networkStatus history on historical network records + * + * @param networkStatusHistory + * @return + */ + static bool IsEmptyNetworkHistoryByNumCheck(const uint32_t &networkStatusHistory); + + /** + * to Display the networkStatus History; + * + * @param networkStatusHistory + * @return + */ + static std::string ToString(const uint32_t &networkStatusHistory); +private: + + /** + * get the last network status of the network status records given. + * + * @param networkHistory historical network status records + * @return the last network status + */ + static NetworkStatus GetLastNetworkStatus(const uint32_t &networkHistory); + + /*! + * count different network Status records. + * + * @param networkStatusHistory historical network status records + * @param counts 0: UNKNOWN,1:HAS_INTERNET,2:PORTAL,3:NO_INTERNET + */ + static void CountNetworkStatus(const uint32_t &networkStatusHistory, int counts[4]); + + /*! + * the mask to get the network status from network status history. + */ + constexpr static const unsigned int NETWORK_STATUS_MASK = 0b11; + + /*! + * the mask to limit the num of network status records. + */ + constexpr static const int NETWORK_STATUS_HISTORY_MAX_MASK = 0xfffff; + + /*! + * wifi recovery percentage + */ + constexpr static const double RECOVERY_PERCENTAGE = 0.8; + + /** + * number of bits occupied by each record + */ + constexpr static const int ITEM_BIT_NUM = 2; +}; +} +} + +#endif //COMMUNICATION_WIFI_NETWORK_STATUS_HISTORY_MANAGER_H diff --git a/wifi/services/wifi_standard/wifi_framework/wifi_manage/wifi_sta/sta_auto_connect_service.cpp b/wifi/services/wifi_standard/wifi_framework/wifi_manage/wifi_sta/sta_auto_connect_service.cpp index 280f39d22..30278f798 100644 --- a/wifi/services/wifi_standard/wifi_framework/wifi_manage/wifi_sta/sta_auto_connect_service.cpp +++ b/wifi/services/wifi_standard/wifi_framework/wifi_manage/wifi_sta/sta_auto_connect_service.cpp @@ -25,6 +25,7 @@ namespace Wifi { StaAutoConnectService::StaAutoConnectService(StaStateMachine *staStateMachine, int instId) : pStaStateMachine(staStateMachine), pSavedDeviceAppraisal(nullptr), + pNetworkSelectionManager(nullptr), firmwareRoamFlag(true), maxBlockedBssidNum(BLOCKLIST_INVALID_SIZE), selectDeviceLastTime(0), @@ -39,6 +40,10 @@ StaAutoConnectService::~StaAutoConnectService() delete pSavedDeviceAppraisal; pSavedDeviceAppraisal = nullptr; } + if (pNetworkSelectionManager != nullptr) { + delete pNetworkSelectionManager; + pNetworkSelectionManager = nullptr; + } } ErrCode StaAutoConnectService::InitAutoConnectService() @@ -55,7 +60,15 @@ ErrCode StaAutoConnectService::InitAutoConnectService() WIFI_LOGE("savedDeviceAppraisal is null\n"); return WIFI_OPT_FAILED; } - + pNetworkSelectionManager = new (std::nothrow) NetworkSelectionManager(); + if (pNetworkSelectionManager == nullptr) { + WIFI_LOGE("pNetworkSelectionManager is null\n"); + return WIFI_OPT_FAILED; + } + if (pNetworkSelectionManager->InitNetworkSelectionService() != WIFI_OPT_SUCCESS) { + WIFI_LOGE("InitAutoConnectService failed.\n"); + return WIFI_OPT_FAILED; + } int savedPriority = WifiSettings::GetInstance().GetSavedDeviceAppraisalPriority(m_instId); if (RegisterDeviceAppraisal(pSavedDeviceAppraisal, savedPriority)) { WIFI_LOGI("RegisterSavedDeviceAppraisal succeeded.\n"); @@ -83,14 +96,21 @@ void StaAutoConnectService::OnScanInfosReadyHandler(const std::vector blockedBssids; GetBlockedBssids(blockedBssids); - - WifiDeviceConfig electedDevice; - if (AutoSelectDevice(electedDevice, scanInfos, blockedBssids, info) == WIFI_OPT_SUCCESS) { - WIFI_LOGI("AutoSelectDevice succeed: " - "[networkId:%{public}d, ssid:%{public}s, bssid:%{public}s, psk len:%{public}d].", - electedDevice.networkId, SsidAnonymize(electedDevice.ssid).c_str(), - MacAnonymize(electedDevice.bssid).c_str(), (int)electedDevice.preSharedKey.length()); - ConnectElectedDevice(electedDevice); + if (!AllowAutoSelectDevice(info) || !IsAllowAutoJoin()) { + return; + } + NetworkSelectionResult networkSelectionResult; + if (pNetworkSelectionManager->SelectNetwork(networkSelectionResult, NetworkSelectType::AUTO_CONNECT, scanInfos)) { + int networkId = networkSelectionResult.wifiDeviceConfig.networkId; + std::string &bssid = networkSelectionResult.interScanInfo.bssid; + std::string &ssid = networkSelectionResult.interScanInfo.ssid; + WIFI_LOGI("AutoSelectDevice networkId: %{public}d, ssid: %{public}s, bssid: %{public}s.", networkId, + SsidAnonymize(ssid).c_str(), MacAnonymize(bssid).c_str()); + auto message = pStaStateMachine->CreateMessage(WIFI_SVR_CMD_STA_CONNECT_SAVED_NETWORK); + message->SetParam1(networkId); + message->SetParam2(NETWORK_SELECTED_BY_AUTO); + message->AddStringMessageBody(bssid); + pStaStateMachine->SendMessage(message); } else { WIFI_LOGI("AutoSelectDevice return fail."); return; @@ -421,6 +441,15 @@ bool StaAutoConnectService::RoamingEncryptionModeCheck( return false; } +bool StaAutoConnectService::AllowAutoSelectDevice(OHOS::Wifi::WifiLinkedInfo &info) +{ + if (info.connState == DISCONNECTED || info.connState == UNKNOWN) { + return true; + } + WIFI_LOGI("Current linkInfo is not in DISCONNECTED state, skip network selection.\n"); + return false; +} + bool StaAutoConnectService::AllowAutoSelectDevice(const std::vector &scanInfos, WifiLinkedInfo &info) { WIFI_LOGI("Allow auto select device, connState=%{public}d, detailedState=%{public}d\n", @@ -614,5 +643,46 @@ void StaAutoConnectService::GetAvailableScanInfos(std::vector &av } return; } + +void StaAutoConnectService::DisableAutoJoin(const std::string &conditionName) +{ + std::lock_guard lock(autoJoinMutex); + WIFI_LOGI("Auto Join is disabled by %{public}s.\n", conditionName.c_str()); + autoJoinConditionsMap.insert({conditionName, []() { return false; }}); +} + +void StaAutoConnectService::EnableAutoJoin(const std::string &conditionName) +{ + std::lock_guard lock(autoJoinMutex); + WIFI_LOGI("Auto Join disabled by %{public}s is released.\n", conditionName.c_str()); + autoJoinConditionsMap.erase(conditionName); +} + +void StaAutoConnectService::RegisterAutoJoinCondition(const std::string &conditionName, + const std::function &autoJoinCondition) +{ + std::lock_guard lock(autoJoinMutex); + WIFI_LOGI("Auto Join condition of %{public}s is registered.\n", conditionName.c_str()); + autoJoinConditionsMap.insert({conditionName, autoJoinCondition}); +} + +void StaAutoConnectService::DeregisterAutoJoinCondition(const std::string &conditionName) +{ + std::lock_guard lock(autoJoinMutex); + WIFI_LOGI("Auto Join condition of %{public}s is deregistered.\n", conditionName.c_str()); + autoJoinConditionsMap.erase(conditionName); +} + +bool StaAutoConnectService::IsAllowAutoJoin() +{ + std::lock_guard lock(autoJoinMutex); + for (auto condition = autoJoinConditionsMap.rbegin(); condition != autoJoinConditionsMap.rend(); ++condition) { + if (!condition->second.operator()()) { + WIFI_LOGI("Auto Join is not allowed because of %{public}s.\n", condition->first.c_str()); + return false; + } + } + return true; +} } // namespace Wifi } // namespace OHOS diff --git a/wifi/services/wifi_standard/wifi_framework/wifi_manage/wifi_sta/sta_auto_connect_service.h b/wifi/services/wifi_standard/wifi_framework/wifi_manage/wifi_sta/sta_auto_connect_service.h index a5f4c2652..7650044cf 100644 --- a/wifi/services/wifi_standard/wifi_framework/wifi_manage/wifi_sta/sta_auto_connect_service.h +++ b/wifi/services/wifi_standard/wifi_framework/wifi_manage/wifi_sta/sta_auto_connect_service.h @@ -27,6 +27,7 @@ #include "sta_define.h" #include "sta_state_machine.h" #include "sta_saved_device_appraisal.h" +#include "network_selection_manager.h" namespace OHOS { namespace Wifi { @@ -89,14 +90,46 @@ public: */ virtual bool RegisterDeviceAppraisal(StaDeviceAppraisal *appraisal, int priority); + /** + * @Description disable auto join. + * + * @param conditionName autoJoinDisabled condition. + */ + virtual void DisableAutoJoin(const std::string &conditionName); + + /** + * @Description enable auto join. + * + * @param conditionName autoJoinDisabled condition. + */ + virtual void EnableAutoJoin(const std::string &conditionName); + + /** + * @Description register auto join condition. + * + * @param conditionName the name of condition. + * @param autoJoinCondition condition. + */ + virtual void RegisterAutoJoinCondition(const std::string &conditionName, + const std::function &autoJoinCondition); + + /** + * @Description deregister auto join condition. + * + * @param conditionName the name of condition. + */ + virtual void DeregisterAutoJoinCondition(const std::string &conditionName); private: StaStateMachine *pStaStateMachine; StaDeviceAppraisal *pSavedDeviceAppraisal; + NetworkSelectionManager *pNetworkSelectionManager; bool firmwareRoamFlag; int maxBlockedBssidNum; int selectDeviceLastTime; StaDeviceAppraisal *pAppraisals[MAX_APPRAISAL_NUM]; int m_instId; + std::map> autoJoinConditionsMap{}; + std::mutex autoJoinMutex; struct BlockedBssidInfo { int count; /* Number of times the BSSID is rejected. */ bool blockedFlag; @@ -172,6 +205,13 @@ private: */ void GetAvailableScanInfos(std::vector &availableScanInfos, const std::vector &scanInfos, std::vector &blockedBssids, WifiLinkedInfo &info); + /** + * @Description Whether the device needs to be switched. + * + * @param info - Current Connected Device(in) + * @Return success : true failed : false + */ + bool AllowAutoSelectDevice(WifiLinkedInfo &info); /** * @Description Whether the device needs to be switched. * @@ -222,6 +262,12 @@ private: * @Return success : true failed : false */ bool Whether24GDevice(int frequency); + /** + * @Description Whether allow auto join. + * + * @return true if allow autoJoin. + */ + bool IsAllowAutoJoin(); /** * @Description Whether the device is a 5G device. * diff --git a/wifi/services/wifi_standard/wifi_framework/wifi_manage/wifi_sta/sta_interface.cpp b/wifi/services/wifi_standard/wifi_framework/wifi_manage/wifi_sta/sta_interface.cpp index 934289c68..5ec64953f 100644 --- a/wifi/services/wifi_standard/wifi_framework/wifi_manage/wifi_sta/sta_interface.cpp +++ b/wifi/services/wifi_standard/wifi_framework/wifi_manage/wifi_sta/sta_interface.cpp @@ -16,6 +16,7 @@ #include "sta_interface.h" #include "sta_service.h" #include "wifi_logger.h" +#include "network_filter_builder_manager.h" DEFINE_WIFILOG_LABEL("StaInterface"); @@ -340,6 +341,55 @@ ErrCode StaInterface::OnScreenStateChanged(int screenState) return WIFI_OPT_SUCCESS; } +ErrCode StaInterface::DisableAutoJoin(const std::string &conditionName) +{ + std::lock_guard lock(mutex); + CHECK_NULL_AND_RETURN(pStaService, WIFI_OPT_FAILED); + pStaService->DisableAutoJoin(conditionName); + return WIFI_OPT_SUCCESS; +} + +ErrCode StaInterface::EnableAutoJoin(const std::string &conditionName) +{ + std::lock_guard lock(mutex); + CHECK_NULL_AND_RETURN(pStaService, WIFI_OPT_FAILED); + pStaService->EnableAutoJoin(conditionName); + return WIFI_OPT_SUCCESS; +} + +ErrCode StaInterface::RegisterAutoJoinCondition(const std::string &conditionName, + const std::function &autoJoinCondition) +{ + std::lock_guard lock(mutex); + CHECK_NULL_AND_RETURN(pStaService, WIFI_OPT_FAILED); + pStaService->RegisterAutoJoinCondition(conditionName, autoJoinCondition); + return WIFI_OPT_SUCCESS; +} + +ErrCode StaInterface::DeregisterAutoJoinCondition(const std::string &conditionName) +{ + std::lock_guard lock(mutex); + CHECK_NULL_AND_RETURN(pStaService, WIFI_OPT_FAILED); + pStaService->DeregisterAutoJoinCondition(conditionName); + return WIFI_OPT_SUCCESS; +} + +ErrCode StaInterface::RegisterFilterBuilder(const FilterTag &filterTag, + const std::string &filterName, + const filter_builder &filterBuilder) +{ + std::lock_guard lock(mutex); + CHECK_NULL_AND_RETURN(pStaService, WIFI_OPT_FAILED); + return pStaService->RegisterFilterBuilder(filterTag, filterName, filterBuilder); +} + +ErrCode StaInterface::DeregisterFilterBuilder(const FilterTag &filterTag, const std::string &filterName) +{ + std::lock_guard lock(mutex); + CHECK_NULL_AND_RETURN(pStaService, WIFI_OPT_FAILED); + return pStaService->DeregisterFilterBuilder(filterTag, filterName); +} + ErrCode StaInterface::StartPortalCertification() { WIFI_LOGI("Enter StaInterface::StartPortalCertification"); diff --git a/wifi/services/wifi_standard/wifi_framework/wifi_manage/wifi_sta/sta_interface.h b/wifi/services/wifi_standard/wifi_framework/wifi_manage/wifi_sta/sta_interface.h index 074025bf6..0d943ce19 100644 --- a/wifi/services/wifi_standard/wifi_framework/wifi_manage/wifi_sta/sta_interface.h +++ b/wifi/services/wifi_standard/wifi_framework/wifi_manage/wifi_sta/sta_interface.h @@ -227,6 +227,60 @@ public: * @return success: WIFI_OPT_SUCCESS, failed: WIFI_OPT_FAILED */ virtual ErrCode OnScreenStateChanged(int screenState) override; + + /** + * @Description disable auto join. + * + * @param conditionName autoJoinDisabled condition. + * @return WifiErrorNo + */ + ErrCode DisableAutoJoin(const std::string &conditionName) override; + + /** + * @Description enable auto join. + * + * @param conditionName autoJoinDisabled condition. + * @return WifiErrorNo + */ + ErrCode EnableAutoJoin(const std::string &conditionName) override; + + /** + * @Description register auto join condition. + * + * @param conditionName the name of condition. + * @param autoJoinCondition condition. + * @return WifiErrorNo + */ + ErrCode RegisterAutoJoinCondition(const std::string &conditionName, + const std::function &autoJoinCondition) override; + + /** + * @Description deregister auto join condition. + * + * @param conditionName the name of condition. + * @return WifiErrorNo + */ + ErrCode DeregisterAutoJoinCondition(const std::string &conditionName) override; + + /** + * @Description register external filter builder. + * + * @param filterTag filterTag which define where the filter should be inserted. + * @param filterName the name of the filter to build. + * @param filterBuilder filter builder. + * @return WifiErrorNo + */ + ErrCode RegisterFilterBuilder(const FilterTag &filterTag, const std::string &filterName, + const filter_builder &filterBuilder) override; + + /** + * @Description deregister external filter builder. + * + * @param filterTag filterTag which define where the filter should be inserted. + * @param filterName the name of the filter to build. + * @return WifiErrorNo + */ + ErrCode DeregisterFilterBuilder(const FilterTag &filterTag, const std::string &filterName) override; /** * @Description start portal certification. * diff --git a/wifi/services/wifi_standard/wifi_framework/wifi_manage/wifi_sta/sta_service.cpp b/wifi/services/wifi_standard/wifi_framework/wifi_manage/wifi_sta/sta_service.cpp index cb1bad9de..1df3e63d9 100644 --- a/wifi/services/wifi_standard/wifi_framework/wifi_manage/wifi_sta/sta_service.cpp +++ b/wifi/services/wifi_standard/wifi_framework/wifi_manage/wifi_sta/sta_service.cpp @@ -26,8 +26,10 @@ #include "wifi_supplicant_hal_interface.h" #include "wifi_cert_utils.h" #include "wifi_common_util.h" +#include "network_selection_manager.h" #include "wifi_config_center.h" #include "wifi_manager.h" +#include "network_filter_builder_manager.h" DEFINE_WIFILOG_LABEL("StaService"); @@ -629,6 +631,50 @@ void StaService::HandleScreenStatusChanged(int screenState) #endif return; } + +ErrCode StaService::DisableAutoJoin(const std::string &conditionName) +{ + CHECK_NULL_AND_RETURN(pStaAutoConnectService, WIFI_OPT_FAILED); + pStaAutoConnectService->DisableAutoJoin(conditionName); + return WIFI_OPT_SUCCESS; +} + +ErrCode StaService::EnableAutoJoin(const std::string &conditionName) +{ + CHECK_NULL_AND_RETURN(pStaAutoConnectService, WIFI_OPT_FAILED); + pStaAutoConnectService->EnableAutoJoin(conditionName); + return WIFI_OPT_SUCCESS; +} + +ErrCode StaService::RegisterAutoJoinCondition(const std::string &conditionName, + const std::function &autoJoinCondition) +{ + CHECK_NULL_AND_RETURN(pStaAutoConnectService, WIFI_OPT_FAILED); + pStaAutoConnectService->RegisterAutoJoinCondition(conditionName, autoJoinCondition); + return WIFI_OPT_SUCCESS; +} + +ErrCode StaService::DeregisterAutoJoinCondition(const std::string &conditionName) +{ + CHECK_NULL_AND_RETURN(pStaAutoConnectService, WIFI_OPT_FAILED); + pStaAutoConnectService->DeregisterAutoJoinCondition(conditionName); + return WIFI_OPT_SUCCESS; +} + +ErrCode StaService::RegisterFilterBuilder(const OHOS::Wifi::FilterTag &filterTag, + const std::string &filterName, + const OHOS::Wifi::filter_builder &filterBuilder) +{ + ExternalWifiFilterBuildManager::GetInstance().RegisterFilterBuilder(filterTag, filterName, filterBuilder); + return WIFI_OPT_SUCCESS; +} + +ErrCode StaService::DeregisterFilterBuilder(const OHOS::Wifi::FilterTag &filterTag, const std::string &filterName) +{ + ExternalWifiFilterBuildManager::GetInstance().DeregisterFilterBuilder(filterTag, filterName); + return WIFI_OPT_SUCCESS; +} + ErrCode StaService::StartPortalCertification() { if (pStaStateMachine == nullptr) { diff --git a/wifi/services/wifi_standard/wifi_framework/wifi_manage/wifi_sta/sta_service.h b/wifi/services/wifi_standard/wifi_framework/wifi_manage/wifi_sta/sta_service.h index a918ce6fe..12995fee3 100644 --- a/wifi/services/wifi_standard/wifi_framework/wifi_manage/wifi_sta/sta_service.h +++ b/wifi/services/wifi_standard/wifi_framework/wifi_manage/wifi_sta/sta_service.h @@ -20,6 +20,7 @@ #include "sta_auto_connect_service.h" #include "sta_monitor.h" #include "sta_state_machine.h" +#include "network_selection_msg.h" #ifndef OHOS_ARCH_LITE #include "i_wifi_country_code_change_listener.h" #endif @@ -237,6 +238,59 @@ public: * */ virtual void HandleScreenStatusChanged(int screenState); + + /** + * @Description disable auto join. + * + * @param conditionName autoJoinDisabled condition. + * @return WifiErrorNo + */ + virtual ErrCode DisableAutoJoin(const std::string &conditionName); + + /** + * @Description enable auto join. + * + * @param conditionName autoJoinDisabled condition. + * @return WifiErrorNo + */ + virtual ErrCode EnableAutoJoin(const std::string &conditionName); + + /** + * @Description register auto join condition. + * + * @param conditionName the name of condition. + * @param autoJoinCondition condition. + * @return WifiErrorNo + */ + virtual ErrCode RegisterAutoJoinCondition(const std::string &conditionName, + const std::function &autoJoinCondition); + /** + * @Description deregister auto join condition. + * + * @param conditionName the name of condition. + * @return WifiErrorNo + */ + virtual ErrCode DeregisterAutoJoinCondition(const std::string &conditionName); + + /** + * @Description register external filter builder. + * + * @param filterTag filterTag which define where the filter should be inserted. + * @param filterName the name of the filter to build. + * @param filterBuilder filter builder. + * @return WifiErrorNo + */ + virtual ErrCode RegisterFilterBuilder(const FilterTag &filterTag, const std::string &filterName, + const filter_builder &filterBuilder); + /** + * @Description deregister external filter builder. + * + * @param filterTag filterTag which define where the filter should be inserted. + * @param filterName the name of the filter to build. + * @return WifiErrorNo + */ + virtual ErrCode DeregisterFilterBuilder(const FilterTag &filterTag, const std::string &filterName); + /** * @Description start portal certification. * diff --git a/wifi/services/wifi_standard/wifi_framework/wifi_manage/wifi_sta/sta_state_machine.cpp b/wifi/services/wifi_standard/wifi_framework/wifi_manage/wifi_sta/sta_state_machine.cpp index 698106957..27066cb39 100644 --- a/wifi/services/wifi_standard/wifi_framework/wifi_manage/wifi_sta/sta_state_machine.cpp +++ b/wifi/services/wifi_standard/wifi_framework/wifi_manage/wifi_sta/sta_state_machine.cpp @@ -69,6 +69,7 @@ StaStateMachine::StaStateMachine(int instId) enableSignalPoll(true), isRoam(false), netNoWorkNum(0), + networkStatusHistoryInserted(false), pDhcpResultNotify(nullptr), pNetcheck(nullptr), pRootState(nullptr), @@ -707,7 +708,7 @@ void StaStateMachine::StopWifiProcess() /* Callback result to InterfaceService. */ InvokeOnStaConnChanged(OperateResState::DISCONNECT_DISCONNECTED, linkedInfo); } - + if ((WifiOprMidState::RUNNING == WifiConfigCenter::GetInstance().GetWifiScanOnlyMidState(m_instId) && WifiStaHalInterface::GetInstance().Disconnect() == WIFI_IDL_OPT_OK) || WifiStaHalInterface::GetInstance().StopWifi() == WIFI_IDL_OPT_OK) { @@ -975,6 +976,7 @@ void StaStateMachine::DealConnectToUserSelectedNetwork(InternalMessage *msg) int networkId = msg->GetParam1(); int connTriggerMode = msg->GetParam2(); + auto bssid = msg->GetStringFromMessage(); if (connTriggerMode != NETWORK_SELECTED_BY_RETRY) { linkedInfo.retryedConnCount = 0; } @@ -995,10 +997,11 @@ void StaStateMachine::DealConnectToUserSelectedNetwork(InternalMessage *msg) /* Save connection information. */ SaveDiscReason(DisconnectedReason::DISC_REASON_DEFAULT); SaveLinkstate(ConnState::CONNECTING, DetailedState::CONNECTING); + networkStatusHistoryInserted = false; /* Callback result to InterfaceService. */ InvokeOnStaConnChanged(OperateResState::CONNECT_CONNECTING, linkedInfo); - if (StartConnectToNetwork(networkId) != WIFI_OPT_SUCCESS) { + if (StartConnectToNetwork(networkId, bssid) != WIFI_OPT_SUCCESS) { OnConnectFailed(networkId); return; } @@ -1458,7 +1461,7 @@ void StaStateMachine::DealStartRoamCmd(InternalMessage *msg) SwitchState(pApRoamingState); } -ErrCode StaStateMachine::StartConnectToNetwork(int networkId) +ErrCode StaStateMachine::StartConnectToNetwork(int networkId, const std::string & bssid) { targetNetworkId = networkId; SetRandomMac(targetNetworkId); @@ -1469,7 +1472,11 @@ ErrCode StaStateMachine::StartConnectToNetwork(int networkId) return WIFI_OPT_FAILED; } SyncDeviceConfigToWpa(); - WifiStaHalInterface::GetInstance().SetBssid(networkId, deviceConfig.userSelectBssid.c_str()); + if (bssid.empty()) { + WifiStaHalInterface::GetInstance().SetBssid(networkId, deviceConfig.userSelectBssid); + } else { + WifiStaHalInterface::GetInstance().SetBssid(networkId, bssid); + } if (WifiStaHalInterface::GetInstance().EnableNetwork(targetNetworkId) != WIFI_IDL_OPT_OK) { LOGE("EnableNetwork() failed!"); @@ -2373,6 +2380,7 @@ void StaStateMachine::HandleNetCheckResult(StaNetState netState, const std::stri WIFI_LOGD("portal network normal working need redetect for expired!"); StartTimer(static_cast(CMD_START_NETCHECK), PORTAL_CHECK_TIME * PORTAL_MILLSECOND); } + InsertOrUpdateNetworkStatusHistory(NetworkStatus::HAS_INTERNET); } else if (netState == StaNetState::NETWORK_CHECK_PORTAL) { WifiLinkedInfo linkedInfo; GetLinkedInfo(linkedInfo); @@ -2383,6 +2391,7 @@ void StaStateMachine::HandleNetCheckResult(StaNetState netState, const std::stri StartTimer(static_cast(CMD_START_NETCHECK), PORTAL_CHECK_TIME * PORTAL_MILLSECOND); SaveLinkstate(ConnState::CONNECTED, DetailedState::CAPTIVE_PORTAL_CHECK); InvokeOnStaConnChanged(OperateResState::CONNECT_CHECK_PORTAL, linkedInfo); + InsertOrUpdateNetworkStatusHistory(NetworkStatus::PORTAL); } else { WIFI_LOGI("HandleNetCheckResult network state is notworking.\n"); SaveLinkstate(ConnState::CONNECTED, DetailedState::NOTWORKING); @@ -2391,6 +2400,7 @@ void StaStateMachine::HandleNetCheckResult(StaNetState netState, const std::stri delay = delay > PORTAL_CHECK_TIME ? PORTAL_CHECK_TIME : delay; netNoWorkNum++; StartTimer(static_cast(CMD_START_NETCHECK), delay * PORTAL_MILLSECOND); + InsertOrUpdateNetworkStatusHistory(NetworkStatus::NO_INTERNET); } } @@ -2880,7 +2890,7 @@ void StaStateMachine::DhcpResultNotify::OnFailed(int status, const char *ifname, } LOGI("Enter DhcpResultNotify::OnFailed. ifname=%{public}s, status=%{public}d, reason=%{public}s, state=%{public}d", ifname, status, reason, static_cast(pStaStateMachine->linkedInfo.detailedState)); - + LOGI("StopTimer CMD_START_GET_DHCP_IP_TIMEOUT OnFailed"); pStaStateMachine->StopTimer(static_cast(CMD_START_GET_DHCP_IP_TIMEOUT)); if ((pStaStateMachine->linkedInfo.detailedState == DetailedState::DISCONNECTING) || @@ -3028,6 +3038,41 @@ void StaStateMachine::StartDhcpRenewal() } } +WifiDeviceConfig StaStateMachine::getCurrentWifiDeviceConfig() +{ + WifiDeviceConfig wifiDeviceConfig; + WifiSettings::GetInstance().GetDeviceConfig(linkedInfo.networkId, wifiDeviceConfig); + return wifiDeviceConfig; +} + +void StaStateMachine::InsertOrUpdateNetworkStatusHistory(const NetworkStatus &networkStatus) +{ + WifiDeviceConfig &&wifiDeviceConfig = getCurrentWifiDeviceConfig(); + if (networkStatusHistoryInserted) { + NetworkStatusHistoryManager::Update(wifiDeviceConfig.networkStatusHistory, networkStatus); + WIFI_LOGI("After updated, current network status history is %{public}s.", + NetworkStatusHistoryManager::ToString(wifiDeviceConfig.networkStatusHistory).c_str()); + } else { + NetworkStatusHistoryManager::Insert(wifiDeviceConfig.networkStatusHistory, networkStatus); + networkStatusHistoryInserted = true; + WIFI_LOGI("After inserted, current network status history is %{public}s.", + NetworkStatusHistoryManager::ToString(wifiDeviceConfig.networkStatusHistory).c_str()); + } + if (networkStatus == NetworkStatus::PORTAL) { + wifiDeviceConfig.isPortal = true; + wifiDeviceConfig.noInternetAccess = true; + } + if (networkStatus == NetworkStatus::HAS_INTERNET) { + wifiDeviceConfig.lastHasInternetTime = time(0); + wifiDeviceConfig.noInternetAccess = false; + } + if (networkStatus == NetworkStatus::NO_INTERNET) { + wifiDeviceConfig.noInternetAccess = true; + } + WifiSettings::GetInstance().AddDeviceConfig(wifiDeviceConfig); + WifiSettings::GetInstance().SyncDeviceConfig(); +} + int StaStateMachine::GetInstanceId() { return m_instId; diff --git a/wifi/services/wifi_standard/wifi_framework/wifi_manage/wifi_sta/sta_state_machine.h b/wifi/services/wifi_standard/wifi_framework/wifi_manage/wifi_sta/sta_state_machine.h index 410489cee..11f86e575 100644 --- a/wifi/services/wifi_standard/wifi_framework/wifi_manage/wifi_sta/sta_state_machine.h +++ b/wifi/services/wifi_standard/wifi_framework/wifi_manage/wifi_sta/sta_state_machine.h @@ -29,6 +29,7 @@ #include "sta_service_callback.h" #include "dhcp_c_api.h" #include "sta_define.h" +#include "network_status_history_manager.h" #ifndef OHOS_ARCH_LITE #include "wifi_net_agent.h" #endif @@ -557,9 +558,10 @@ private: * @Description Start to connect to network. * * @param networkId - the networkId of network which is going to be connected.(in) + * @param bssid - the bssid of network which is going to be connected. * @Return success: WIFI_OPT_SUCCESS fail: WIFI_OPT_FAILED */ - ErrCode StartConnectToNetwork(int networkId); + ErrCode StartConnectToNetwork(int networkId, const std::string &bssid); /** * @Description Disable network * @@ -870,6 +872,7 @@ private: bool isRoam; int netNoWorkNum; bool portalFlag; + bool networkStatusHistoryInserted; WifiLinkedInfo linkedInfo; WifiLinkedInfo lastLinkedInfo; DhcpResultNotify *pDhcpResultNotify; @@ -903,6 +906,8 @@ private: void InvokeOnWpsChanged(WpsStartState state, const int code); void InvokeOnStaStreamChanged(StreamDirection direction); void InvokeOnStaRssiLevelChanged(int level); + WifiDeviceConfig getCurrentWifiDeviceConfig(); + void InsertOrUpdateNetworkStatusHistory(const NetworkStatus &networkStatus); }; } // namespace Wifi } // namespace OHOS diff --git a/wifi/services/wifi_standard/wifi_framework/wifi_toolkit/config/wifi_config_file_spec.cpp b/wifi/services/wifi_standard/wifi_framework/wifi_toolkit/config/wifi_config_file_spec.cpp index 922339b1e..6ceca5464 100644 --- a/wifi/services/wifi_standard/wifi_framework/wifi_toolkit/config/wifi_config_file_spec.cpp +++ b/wifi/services/wifi_standard/wifi_framework/wifi_toolkit/config/wifi_config_file_spec.cpp @@ -44,6 +44,10 @@ static void ClearWifiDeviceConfig(WifiDeviceConfig &item) item.lastConnectTime = -1; item.numRebootsSinceLastUse = 0; item.numAssociation = 0; + item.networkStatusHistory = 0; + item.isPortal = false; + item.lastHasInternetTime = -1; + item.noInternetAccess = false; return; } @@ -170,6 +174,14 @@ static int SetWifiDeviceConfigFirst(WifiDeviceConfig &item, const std::string &k item.numRebootsSinceLastUse = std::stoi(value); } else if (key == "numAssociation") { item.numAssociation = std::stoi(value); + } else if (key == "networkStatusHistory") { + item.networkStatusHistory = std::stoi(value); + } else if (key == "isPortal") { + item.isPortal = std::stoi(value); + } else if (key == "lastHasInternetTime") { + item.lastHasInternetTime = std::stol(value); + } else if (key == "noInternetAccess") { + item.noInternetAccess = std::stoi(value); } else { return -1; } @@ -455,6 +467,10 @@ static std::string OutPutWifiDeviceConfig(WifiDeviceConfig &item) ss << " " <<"lastConnectTime=" << item.lastConnectTime << std::endl; ss << " " <<"numRebootsSinceLastUse=" << item.numRebootsSinceLastUse << std::endl; ss << " " <<"numAssociation=" << item.numAssociation << std::endl; + ss << " " <<"networkStatusHistory=" << item.networkStatusHistory << std::endl; + ss << " " <<"isPortal=" << item.isPortal << std::endl; + ss << " " <<"lastHasInternetTime=" << item.lastHasInternetTime << std::endl; + ss << " " <<"noInternetAccess=" << item.noInternetAccess << std::endl; #ifdef FEATURE_ENCRYPTION_SUPPORT ss < infoElems; + int64_t features; + int64_t timestamp; + Ant ant; + int wifiMode; + bool isVhtInfoExist; + bool isHtInfoExist; + bool isHeInfoExist; + bool isErpExist; + int maxRates; + + InterScanInfo() + : frequency(0), + band(0), + channelWidth(WifiChannelWidth::WIDTH_INVALID), + centerFrequency0(0), + centerFrequency1(0), + rssi(0), + securityType(WifiSecurity::INVALID), + features(0), + timestamp(0), + ant(Ant::NETWORK_ANT_INVALID), + wifiMode(WIFI_MODE_UNDEFINED), + isVhtInfoExist(false), + isHtInfoExist(false), + isHeInfoExist(false), + isErpExist(false), + maxRates(0) {} + + ~InterScanInfo() {} + + void GetDeviceMgmt(std::string &mgmt) const + { + switch (securityType) { + case WifiSecurity::PSK:mgmt = "WPA-PSK"; + break; + case WifiSecurity::EAP:mgmt = "WPA-EAP"; + break; + case WifiSecurity::SAE:mgmt = "SAE"; + break; + case WifiSecurity::OWE:mgmt = "OWE"; + break; + default:mgmt = "NONE"; + break; + } + } + + void GetWifiStandard(int &standard) const + { + standard = wifiMode; + } + + bool IsWifi11bMode() const + { + return wifiMode == WIFI_802_11B; + } +}; +} +} +#endif diff --git a/wifi/services/wifi_standard/wifi_framework/wifi_toolkit/include/wifi_internal_msg.h b/wifi/services/wifi_standard/wifi_framework/wifi_toolkit/include/wifi_internal_msg.h index c109710bb..0cfd15836 100644 --- a/wifi/services/wifi_standard/wifi_framework/wifi_toolkit/include/wifi_internal_msg.h +++ b/wifi/services/wifi_standard/wifi_framework/wifi_toolkit/include/wifi_internal_msg.h @@ -22,6 +22,7 @@ #include "wifi_msg.h" #include "wifi_p2p_msg.h" #include "wifi_scan_msg.h" +#include "inter_scan_info.h" namespace OHOS { namespace Wifi { @@ -49,13 +50,6 @@ constexpr int RSSI_LEVEL_1_5G = -85; constexpr int RSSI_LEVEL_2_5G = -79; constexpr int RSSI_LEVEL_3_5G = -72; constexpr int RSSI_LEVEL_4_5G = -65; -constexpr int WIFI_MODE_UNDEFINED = 0; -constexpr int WIFI_802_11A = 1; -constexpr int WIFI_802_11B = 2; -constexpr int WIFI_802_11G = 3; -constexpr int WIFI_802_11N = 4; -constexpr int WIFI_802_11AC = 5; -constexpr int WIFI_802_11AX = 6; enum class WifiOprMidState { CLOSED = 0, OPENING = 1, RUNNING = 2, CLOSING = 3, UNKNOWN }; @@ -118,26 +112,6 @@ enum class IsWpsConnected { WPS_INVALID = -1, }; -enum class Ant { - NETWORK_PRIVATE = 0, - NETWORK_PRIVATEWITHGUEST = 1, - NETWORK_CHARGEABLEPUBLIC = 2, - NETWORK_FREEPUBLIC = 3, - NETWORK_PERSONAL = 4, - NETWORK_EMERGENCYONLY = 5, - NETWORK_RESVD6 = 6, - NETWORK_RESVD7 = 7, - NETWORK_RESVD8 = 8, - NETWORK_RESVD9 = 9, - NETWORK_RESVD10 = 10, - NETWORK_RESVD11 = 11, - NETWORK_RESVD12 = 12, - NETWORK_RESVD13 = 13, - NETWORK_TESTOREXPERIMENTAL = 14, - NETWORK_WILDCARD = 15, - NETWORK_ANT_INVALID = 16 -}; - enum class AutoStartOrStopServiceReason { AUTO_START_UPON_STARTUP = 0, /* auto-start upon startup */ AIRPLANE_MODE, /* airplane mode */ @@ -145,87 +119,6 @@ enum class AutoStartOrStopServiceReason { TRYTO_OPERATE_P2P_WHEN_STA_STATE_CHANGE, /* Try to operate p2p service again, when the sta state change */ }; -struct InterScanInfo { - std::string bssid; - std::string ssid; - /** - * Network performance, including authentication, - * key management, and encryption mechanisms - * supported by the access point - */ - std::string capabilities; - int frequency; - int band; /* ap band, 1: 2.4G, 2: 5G */ - WifiChannelWidth channelWidth; - int centerFrequency0; - int centerFrequency1; - int rssi; /* signal level */ - WifiSecurity securityType; - std::vector infoElems; - int64_t features; - int64_t timestamp; - Ant ant; - int wifiMode; - bool isVhtInfoExist; - bool isHtInfoExist; - bool isHeInfoExist; - bool isErpExist; - int maxRates; - - InterScanInfo() - : frequency(0), - band(0), - channelWidth(WifiChannelWidth::WIDTH_INVALID), - centerFrequency0(0), - centerFrequency1(0), - rssi(0), - securityType(WifiSecurity::INVALID), - features(0), - timestamp(0), - ant(Ant::NETWORK_ANT_INVALID), - wifiMode(WIFI_MODE_UNDEFINED), - isVhtInfoExist(false), - isHtInfoExist(false), - isHeInfoExist(false), - isErpExist(false), - maxRates(0) - {} - - ~InterScanInfo() - {} - - void GetDeviceMgmt(std::string &mgmt) - { - switch (securityType) { - case WifiSecurity::PSK: - mgmt = "WPA-PSK"; - break; - case WifiSecurity::EAP: - mgmt = "WPA-EAP"; - break; - case WifiSecurity::SAE: - mgmt = "SAE"; - break; - case WifiSecurity::OWE: - mgmt = "OWE"; - break; - default: - mgmt = "NONE"; - break; - } - } - - void GetWifiStandard(int &standard) const - { - standard = wifiMode; - } - - bool IsWifi11bMode() const - { - return wifiMode == WIFI_802_11B; - } -}; - struct WifiCallingInfo { int callingUid; int callingPid; diff --git a/wifi/test/wifi_client/BUILD.gn b/wifi/test/wifi_client/BUILD.gn index 32ee4d093..126248356 100644 --- a/wifi/test/wifi_client/BUILD.gn +++ b/wifi/test/wifi_client/BUILD.gn @@ -25,6 +25,7 @@ local_base_include_dirs = [ "$WIFI_ROOT_DIR/interfaces/inner_api", "$WIFI_ROOT_DIR/frameworks/native/include", "$WIFI_ROOT_DIR/frameworks/native/interfaces", + "$WIFI_ROOT_DIR/services/wifi_standard/wifi_framework/wifi_toolkit/include", "$WIFI_ROOT_DIR/services/wifi_standard/wifi_framework/wifi_toolkit/net_helper", ] diff --git a/wifi/test/wifi_standard/wifi_framework/wifi_manage/wifi_sta/BUILD.gn b/wifi/test/wifi_standard/wifi_framework/wifi_manage/wifi_sta/BUILD.gn index b6880c029..51b9a0834 100644 --- a/wifi/test/wifi_standard/wifi_framework/wifi_manage/wifi_sta/BUILD.gn +++ b/wifi/test/wifi_standard/wifi_framework/wifi_manage/wifi_sta/BUILD.gn @@ -34,6 +34,15 @@ ohos_unittest("wifi_sta_unittest") { "$WIFI_ROOT_DIR/services/wifi_standard/wifi_framework/wifi_manage/common/message_queue.cpp", "$WIFI_ROOT_DIR/services/wifi_standard/wifi_framework/wifi_manage/common/state.cpp", "$WIFI_ROOT_DIR/services/wifi_standard/wifi_framework/wifi_manage/common/state_machine.cpp", + "$WIFI_ROOT_DIR/services/wifi_standard/wifi_framework/wifi_manage/wifi_sta/network_select/network_filter_builder_manager.cpp", + "$WIFI_ROOT_DIR/services/wifi_standard/wifi_framework/wifi_manage/wifi_sta/network_select/network_selection_manager.cpp", + "$WIFI_ROOT_DIR/services/wifi_standard/wifi_framework/wifi_manage/wifi_sta/network_select/network_selection_utils.cpp", + "$WIFI_ROOT_DIR/services/wifi_standard/wifi_framework/wifi_manage/wifi_sta/network_select/network_selector.cpp", + "$WIFI_ROOT_DIR/services/wifi_standard/wifi_framework/wifi_manage/wifi_sta/network_select/network_selector_comparator.cpp", + "$WIFI_ROOT_DIR/services/wifi_standard/wifi_framework/wifi_manage/wifi_sta/network_select/network_selector_factory.cpp", + "$WIFI_ROOT_DIR/services/wifi_standard/wifi_framework/wifi_manage/wifi_sta/network_select/network_selector_filter.cpp", + "$WIFI_ROOT_DIR/services/wifi_standard/wifi_framework/wifi_manage/wifi_sta/network_select/network_selector_scorer.cpp", + "$WIFI_ROOT_DIR/services/wifi_standard/wifi_framework/wifi_manage/wifi_sta/network_status_history_manager.cpp", "$WIFI_ROOT_DIR/services/wifi_standard/wifi_framework/wifi_manage/wifi_sta/sta_auto_connect_service.cpp", "$WIFI_ROOT_DIR/services/wifi_standard/wifi_framework/wifi_manage/wifi_sta/sta_interface.cpp", "$WIFI_ROOT_DIR/services/wifi_standard/wifi_framework/wifi_manage/wifi_sta/sta_monitor.cpp", @@ -86,6 +95,7 @@ ohos_unittest("wifi_sta_unittest") { "$WIFI_ROOT_DIR/services/wifi_standard/wifi_framework/wifi_manage/wifi_p2p", "$WIFI_ROOT_DIR/services/wifi_standard/wifi_framework/wifi_manage/wifi_scan", "$WIFI_ROOT_DIR/services/wifi_standard/wifi_framework/wifi_manage/wifi_sta", + "$WIFI_ROOT_DIR/services/wifi_standard/wifi_framework/wifi_manage/wifi_sta/network_select", "$WIFI_ROOT_DIR/services/wifi_standard/ipc_framework/cRPC/include", "//third_party/googletest/googlemock/include", "//third_party/googletest/googletest/include", -- Gitee From b2c216a902cc4ce6645a33b4d2e0ba28ec4329c6 Mon Sep 17 00:00:00 2001 From: yuhaoqiang <690364942@qq.com> Date: Fri, 15 Dec 2023 15:02:27 +0800 Subject: [PATCH 2/2] =?UTF-8?q?=E8=93=9D=E5=8C=BA=E9=80=89=E7=BD=91?= =?UTF-8?q?=E6=A1=86=E6=9E=B6?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: yuhaoqiang <690364942@qq.com> --- wifi/frameworks/native/interfaces/i_wifi_device.h | 2 +- .../native/interfaces/network_selection_msg.h | 10 ++++------ wifi/frameworks/native/src/wifi_device_impl.cpp | 2 +- wifi/frameworks/native/src/wifi_device_impl.h | 2 +- wifi/frameworks/native/src/wifi_device_proxy.cpp | 2 +- wifi/frameworks/native/src/wifi_device_proxy.h | 2 +- wifi/interfaces/inner_api/wifi_device.h | 2 +- .../wifi_manage/wifi_device_service_impl.cpp | 2 +- .../wifi_manage/wifi_device_service_impl.h | 2 +- .../wifi_manage/wifi_sta/ista_service.h | 2 +- .../network_filter_builder_manager.cpp | 12 ++++++------ .../network_select/network_filter_builder_manager.h | 4 ++-- .../network_select/network_selection_utils.cpp | 4 ++-- .../wifi_sta/network_select/network_selector.cpp | 2 -- .../wifi_sta/network_status_history_manager.cpp | 12 ++++++------ .../wifi_manage/wifi_sta/sta_interface.cpp | 2 +- .../wifi_manage/wifi_sta/sta_interface.h | 2 +- .../wifi_manage/wifi_sta/sta_service.cpp | 2 +- .../wifi_manage/wifi_sta/sta_service.h | 2 +- 19 files changed, 33 insertions(+), 37 deletions(-) diff --git a/wifi/frameworks/native/interfaces/i_wifi_device.h b/wifi/frameworks/native/interfaces/i_wifi_device.h index 34b575292..5338d8d81 100644 --- a/wifi/frameworks/native/interfaces/i_wifi_device.h +++ b/wifi/frameworks/native/interfaces/i_wifi_device.h @@ -424,7 +424,7 @@ public: * @return WifiErrorNo */ virtual ErrCode RegisterFilterBuilder(const FilterTag &filterTag, const std::string &filterName, - const filter_builder &filterBuilder) = 0; + const FilterBuilder &filterBuilder) = 0; /** * @Description deregister external filter builder. diff --git a/wifi/frameworks/native/interfaces/network_selection_msg.h b/wifi/frameworks/native/interfaces/network_selection_msg.h index 388837150..244b4803e 100644 --- a/wifi/frameworks/native/interfaces/network_selection_msg.h +++ b/wifi/frameworks/native/interfaces/network_selection_msg.h @@ -23,24 +23,22 @@ namespace OHOS { namespace Wifi { -struct NetworkCandidate -{ +struct NetworkCandidate { const InterScanInfo &interScanInfo; WifiDeviceConfig wifiDeviceConfig; std::vector filteredMsg; std::vector nominateMsg; }; -enum class FilterTag -{ +enum class FilterTag { SAVED_NETWORK_SELECTOR_FILTER_TAG, HAS_INTERNET_NETWORK_SELECTOR_FILTER_TAG, RECOVERY_NETWORK_SELECTOR_FILTER_TAG, PORTAL_NETWORK_SELECTOR_FILTER_TAG }; -using filter_func = std::function; -using filter_builder = std::function; +using FilterFunc = std::function; +using FilterBuilder = std::function; } } #endif diff --git a/wifi/frameworks/native/src/wifi_device_impl.cpp b/wifi/frameworks/native/src/wifi_device_impl.cpp index c42e2d2c4..7d3a53ae9 100644 --- a/wifi/frameworks/native/src/wifi_device_impl.cpp +++ b/wifi/frameworks/native/src/wifi_device_impl.cpp @@ -482,7 +482,7 @@ ErrCode WifiDeviceImpl::DeregisterAutoJoinCondition(const std::string &condition ErrCode WifiDeviceImpl::RegisterFilterBuilder(const FilterTag &filterTag, const std::string &filterName, - const filter_builder &filterBuilder) + const FilterBuilder &filterBuilder) { std::lock_guard lock(mutex_); RETURN_IF_FAIL(GetWifiDeviceProxy()); diff --git a/wifi/frameworks/native/src/wifi_device_impl.h b/wifi/frameworks/native/src/wifi_device_impl.h index da17e09d6..444582b39 100644 --- a/wifi/frameworks/native/src/wifi_device_impl.h +++ b/wifi/frameworks/native/src/wifi_device_impl.h @@ -445,7 +445,7 @@ public: * @return WifiErrorNo */ ErrCode RegisterFilterBuilder(const FilterTag &filterTag, const std::string &filterName, - const filter_builder &filterBuilder) override; + const FilterBuilder &filterBuilder) override; /** * @Description deregister external filter builder. diff --git a/wifi/frameworks/native/src/wifi_device_proxy.cpp b/wifi/frameworks/native/src/wifi_device_proxy.cpp index 8a4f4e8b2..4a6751e26 100644 --- a/wifi/frameworks/native/src/wifi_device_proxy.cpp +++ b/wifi/frameworks/native/src/wifi_device_proxy.cpp @@ -1676,7 +1676,7 @@ ErrCode WifiDeviceProxy::DeregisterAutoJoinCondition(const std::string &conditio ErrCode WifiDeviceProxy::RegisterFilterBuilder(const FilterTag &filterTag, const std::string &filterName, - const filter_builder &filterBuilder) + const FilterBuilder &filterBuilder) { return WIFI_OPT_FAILED; } diff --git a/wifi/frameworks/native/src/wifi_device_proxy.h b/wifi/frameworks/native/src/wifi_device_proxy.h index d50ced597..2d177dd70 100644 --- a/wifi/frameworks/native/src/wifi_device_proxy.h +++ b/wifi/frameworks/native/src/wifi_device_proxy.h @@ -434,7 +434,7 @@ public: * @return WifiErrorNo */ ErrCode RegisterFilterBuilder(const FilterTag &filterTag, const std::string &filterName, - const filter_builder &filterBuilder) override; + const FilterBuilder &filterBuilder) override; /** * @Description deregister external filter builder. diff --git a/wifi/interfaces/inner_api/wifi_device.h b/wifi/interfaces/inner_api/wifi_device.h index e52f8c63e..355a3dd7b 100644 --- a/wifi/interfaces/inner_api/wifi_device.h +++ b/wifi/interfaces/inner_api/wifi_device.h @@ -428,7 +428,7 @@ public: * @return WifiErrorNo */ virtual ErrCode RegisterFilterBuilder(const FilterTag &filterTag, const std::string &filterName, - const filter_builder &filterBuilder) = 0; + const FilterBuilder &filterBuilder) = 0; /** * @Description deregister external filter builder. diff --git a/wifi/services/wifi_standard/wifi_framework/wifi_manage/wifi_device_service_impl.cpp b/wifi/services/wifi_standard/wifi_framework/wifi_manage/wifi_device_service_impl.cpp index e591f4098..de83c4543 100644 --- a/wifi/services/wifi_standard/wifi_framework/wifi_manage/wifi_device_service_impl.cpp +++ b/wifi/services/wifi_standard/wifi_framework/wifi_manage/wifi_device_service_impl.cpp @@ -1777,7 +1777,7 @@ ErrCode WifiDeviceServiceImpl::DeregisterAutoJoinCondition(const std::string &co ErrCode WifiDeviceServiceImpl::RegisterFilterBuilder(const FilterTag &filterTag, const std::string &builderName, - const filter_builder &filterBuilder) + const FilterBuilder &filterBuilder) { if (!WifiAuthCenter::IsNativeProcess()) { WIFI_LOGE("RegisterFilterBuilder:NOT NATIVE PROCESS, PERMISSION_DENIED!"); diff --git a/wifi/services/wifi_standard/wifi_framework/wifi_manage/wifi_device_service_impl.h b/wifi/services/wifi_standard/wifi_framework/wifi_manage/wifi_device_service_impl.h index 54522b107..e9e1a4483 100644 --- a/wifi/services/wifi_standard/wifi_framework/wifi_manage/wifi_device_service_impl.h +++ b/wifi/services/wifi_standard/wifi_framework/wifi_manage/wifi_device_service_impl.h @@ -139,7 +139,7 @@ public: ErrCode DeregisterAutoJoinCondition(const std::string &conditionName) override; ErrCode RegisterFilterBuilder(const FilterTag &filterTag, const std::string &builderName, - const filter_builder &filterBuilder) override; + const FilterBuilder &filterBuilder) override; ErrCode DeregisterFilterBuilder(const FilterTag &filterTag, const std::string &builderName) override; diff --git a/wifi/services/wifi_standard/wifi_framework/wifi_manage/wifi_sta/ista_service.h b/wifi/services/wifi_standard/wifi_framework/wifi_manage/wifi_sta/ista_service.h index 61f406a35..4874f5498 100644 --- a/wifi/services/wifi_standard/wifi_framework/wifi_manage/wifi_sta/ista_service.h +++ b/wifi/services/wifi_standard/wifi_framework/wifi_manage/wifi_sta/ista_service.h @@ -273,7 +273,7 @@ public: * @return WifiErrorNo */ virtual ErrCode RegisterFilterBuilder(const FilterTag &filterTag, const std::string &filterName, - const filter_builder &filterBuilder) = 0; + const FilterBuilder &filterBuilder) = 0; /** * @Description deregister external filter builder. diff --git a/wifi/services/wifi_standard/wifi_framework/wifi_manage/wifi_sta/network_select/network_filter_builder_manager.cpp b/wifi/services/wifi_standard/wifi_framework/wifi_manage/wifi_sta/network_select/network_filter_builder_manager.cpp index 86be54146..164cd4c13 100644 --- a/wifi/services/wifi_standard/wifi_framework/wifi_manage/wifi_sta/network_select/network_filter_builder_manager.cpp +++ b/wifi/services/wifi_standard/wifi_framework/wifi_manage/wifi_sta/network_select/network_filter_builder_manager.cpp @@ -22,13 +22,13 @@ DEFINE_WIFILOG_LABEL("EXTERNAL_WIFI_FILTER_BUILD_MANAGER") ExternalWifiFilterBuildManager &ExternalWifiFilterBuildManager::GetInstance() { - static ExternalWifiFilterBuildManager gNetworkSelectorFilterBuilderManager; - return gNetworkSelectorFilterBuilderManager; + static ExternalWifiFilterBuildManager g_NetworkSelectorFilterBuilderManager; + return g_NetworkSelectorFilterBuilderManager; } void ExternalWifiFilterBuildManager::RegisterFilterBuilder(const FilterTag &filterTag, const std::string &filterName, - const filter_builder &filterBuilder) + const FilterBuilder &filterBuilder) { std::lock_guard lock(mutex); WIFI_LOGI("RegisterFilterBuilder for filterTag: %{public}d, filterName: %{public}s", @@ -51,10 +51,10 @@ void ExternalWifiFilterBuildManager::BuildFilter(const FilterTag &filterTag, Com std::lock_guard lock(mutex); for (const auto &filterBuilderPair : filterBuilders) { if (filterBuilderPair.first.first == filterTag) { - filter_func filter_func; - if (filterBuilderPair.second.operator()(filter_func)) { + FilterFunc filterFunc; + if (filterBuilderPair.second.operator()(filterFunc)) { filter.AddFilter(std::make_shared( - filter_func, filterBuilderPair.first.second)); + filterFunc, filterBuilderPair.first.second)); } } } diff --git a/wifi/services/wifi_standard/wifi_framework/wifi_manage/wifi_sta/network_select/network_filter_builder_manager.h b/wifi/services/wifi_standard/wifi_framework/wifi_manage/wifi_sta/network_select/network_filter_builder_manager.h index b70b9c607..77f763473 100644 --- a/wifi/services/wifi_standard/wifi_framework/wifi_manage/wifi_sta/network_select/network_filter_builder_manager.h +++ b/wifi/services/wifi_standard/wifi_framework/wifi_manage/wifi_sta/network_select/network_filter_builder_manager.h @@ -31,7 +31,7 @@ public: * @param filterBuilder filterBuilder function. */ void RegisterFilterBuilder(const FilterTag &filterTag, const std::string &filterName, - const filter_builder &filterBuilder); + const FilterBuilder &filterBuilder); /** * Deregister the filter builder function * @@ -48,7 +48,7 @@ public: */ void BuildFilter(const FilterTag &filterTag, CompositeWifiFilter &filter); private: - std::map, filter_builder> filterBuilders; + std::map, FilterBuilder> filterBuilders; std::mutex mutex; }; } diff --git a/wifi/services/wifi_standard/wifi_framework/wifi_manage/wifi_sta/network_select/network_selection_utils.cpp b/wifi/services/wifi_standard/wifi_framework/wifi_manage/wifi_sta/network_select/network_selection_utils.cpp index 3593fc912..b963962ee 100644 --- a/wifi/services/wifi_standard/wifi_framework/wifi_manage/wifi_sta/network_select/network_selection_utils.cpp +++ b/wifi/services/wifi_standard/wifi_framework/wifi_manage/wifi_sta/network_select/network_selection_utils.cpp @@ -158,8 +158,8 @@ std::string NetworkSelectionUtils::GetNetworkCandidateInfo(NetworkCandidate &net std::string NetworkSelectionUtils::GetScoreMsg(ScoreResult &scoreResult) { std::stringstream scoreMsg; - scoreMsg << scoreResult.scorerName << " : " << std::fixed << std::setprecision(SCORE_PRECISION) - << scoreResult.score; + scoreMsg << scoreResult.scorerName << " : " << std::fixed << std::setprecision(SCORE_PRECISION) << + scoreResult.score; if (scoreResult.scoreDetails.empty()) { return scoreMsg.str(); } diff --git a/wifi/services/wifi_standard/wifi_framework/wifi_manage/wifi_sta/network_select/network_selector.cpp b/wifi/services/wifi_standard/wifi_framework/wifi_manage/wifi_sta/network_select/network_selector.cpp index ab09d6a28..d01657561 100644 --- a/wifi/services/wifi_standard/wifi_framework/wifi_manage/wifi_sta/network_select/network_selector.cpp +++ b/wifi/services/wifi_standard/wifi_framework/wifi_manage/wifi_sta/network_select/network_selector.cpp @@ -77,8 +77,6 @@ void SimpleNetworkSelector::AfterNominate(OHOS::Wifi::NetworkCandidate &networkC CompositeNetworkSelector::CompositeNetworkSelector(const std::string &networkSelectorName) : m_networkSelectorName( networkSelectorName) {} - - void CompositeNetworkSelector::AddSubNetworkSelector(const shared_ptr &subNetworkSelector) { subNetworkSelectors.emplace_back(subNetworkSelector); diff --git a/wifi/services/wifi_standard/wifi_framework/wifi_manage/wifi_sta/network_status_history_manager.cpp b/wifi/services/wifi_standard/wifi_framework/wifi_manage/wifi_sta/network_status_history_manager.cpp index 727713881..022a97a3d 100644 --- a/wifi/services/wifi_standard/wifi_framework/wifi_manage/wifi_sta/network_status_history_manager.cpp +++ b/wifi/services/wifi_standard/wifi_framework/wifi_manage/wifi_sta/network_status_history_manager.cpp @@ -21,8 +21,8 @@ namespace Wifi { namespace { constexpr int THRESHOLD_CHECKED_NUM = 2; -constexpr int THIRD_FROM_LAST = 1; -constexpr int SECOND_FORM_LAST = 2; +constexpr int SECOND_FROM_LAST = 1; +constexpr int THIRD_FROM_LAST = 2; } void NetworkStatusHistoryManager::Insert(uint32_t &networkStatusHistory, NetworkStatus networkStatus) @@ -82,14 +82,14 @@ bool NetworkStatusHistoryManager::IsRecoveryByNumCheck(const uint32_t &networkSt return false; } if (checkedNum == THRESHOLD_CHECKED_NUM) { - return GetLastNetworkStatus(networkStatusHistory >> SECOND_FORM_LAST * ITEM_BIT_NUM) - == NetworkStatus::HAS_INTERNET; + return GetLastNetworkStatus(networkStatusHistory >> SECOND_FROM_LAST * ITEM_BIT_NUM) == + NetworkStatus::HAS_INTERNET; } if (GetLastNetworkStatus(networkStatusHistory) != NetworkStatus::HAS_INTERNET && - GetLastNetworkStatus(networkStatusHistory >> SECOND_FORM_LAST * ITEM_BIT_NUM) != NetworkStatus::HAS_INTERNET) { + GetLastNetworkStatus(networkStatusHistory >> SECOND_FROM_LAST * ITEM_BIT_NUM) != NetworkStatus::HAS_INTERNET) { return false; } - if (GetLastNetworkStatus(networkStatusHistory >> SECOND_FORM_LAST * ITEM_BIT_NUM) == NetworkStatus::HAS_INTERNET && + if (GetLastNetworkStatus(networkStatusHistory >> SECOND_FROM_LAST * ITEM_BIT_NUM) == NetworkStatus::HAS_INTERNET && GetLastNetworkStatus(networkStatusHistory >> THIRD_FROM_LAST * ITEM_BIT_NUM) == NetworkStatus::HAS_INTERNET) { return true; } diff --git a/wifi/services/wifi_standard/wifi_framework/wifi_manage/wifi_sta/sta_interface.cpp b/wifi/services/wifi_standard/wifi_framework/wifi_manage/wifi_sta/sta_interface.cpp index 5ec64953f..d567b59fe 100644 --- a/wifi/services/wifi_standard/wifi_framework/wifi_manage/wifi_sta/sta_interface.cpp +++ b/wifi/services/wifi_standard/wifi_framework/wifi_manage/wifi_sta/sta_interface.cpp @@ -376,7 +376,7 @@ ErrCode StaInterface::DeregisterAutoJoinCondition(const std::string &conditionNa ErrCode StaInterface::RegisterFilterBuilder(const FilterTag &filterTag, const std::string &filterName, - const filter_builder &filterBuilder) + const FilterBuilder &filterBuilder) { std::lock_guard lock(mutex); CHECK_NULL_AND_RETURN(pStaService, WIFI_OPT_FAILED); diff --git a/wifi/services/wifi_standard/wifi_framework/wifi_manage/wifi_sta/sta_interface.h b/wifi/services/wifi_standard/wifi_framework/wifi_manage/wifi_sta/sta_interface.h index 0d943ce19..52d0b946d 100644 --- a/wifi/services/wifi_standard/wifi_framework/wifi_manage/wifi_sta/sta_interface.h +++ b/wifi/services/wifi_standard/wifi_framework/wifi_manage/wifi_sta/sta_interface.h @@ -271,7 +271,7 @@ public: * @return WifiErrorNo */ ErrCode RegisterFilterBuilder(const FilterTag &filterTag, const std::string &filterName, - const filter_builder &filterBuilder) override; + const FilterBuilder &filterBuilder) override; /** * @Description deregister external filter builder. diff --git a/wifi/services/wifi_standard/wifi_framework/wifi_manage/wifi_sta/sta_service.cpp b/wifi/services/wifi_standard/wifi_framework/wifi_manage/wifi_sta/sta_service.cpp index 1df3e63d9..6a29bcc5f 100644 --- a/wifi/services/wifi_standard/wifi_framework/wifi_manage/wifi_sta/sta_service.cpp +++ b/wifi/services/wifi_standard/wifi_framework/wifi_manage/wifi_sta/sta_service.cpp @@ -663,7 +663,7 @@ ErrCode StaService::DeregisterAutoJoinCondition(const std::string &conditionName ErrCode StaService::RegisterFilterBuilder(const OHOS::Wifi::FilterTag &filterTag, const std::string &filterName, - const OHOS::Wifi::filter_builder &filterBuilder) + const OHOS::Wifi::FilterBuilder &filterBuilder) { ExternalWifiFilterBuildManager::GetInstance().RegisterFilterBuilder(filterTag, filterName, filterBuilder); return WIFI_OPT_SUCCESS; diff --git a/wifi/services/wifi_standard/wifi_framework/wifi_manage/wifi_sta/sta_service.h b/wifi/services/wifi_standard/wifi_framework/wifi_manage/wifi_sta/sta_service.h index 12995fee3..3b9761a6c 100644 --- a/wifi/services/wifi_standard/wifi_framework/wifi_manage/wifi_sta/sta_service.h +++ b/wifi/services/wifi_standard/wifi_framework/wifi_manage/wifi_sta/sta_service.h @@ -281,7 +281,7 @@ public: * @return WifiErrorNo */ virtual ErrCode RegisterFilterBuilder(const FilterTag &filterTag, const std::string &filterName, - const filter_builder &filterBuilder); + const FilterBuilder &filterBuilder); /** * @Description deregister external filter builder. * -- Gitee