diff --git a/wifi/bundle.json b/wifi/bundle.json index 0049628c4..6dfd1a87d 100644 --- a/wifi/bundle.json +++ b/wifi/bundle.json @@ -65,7 +65,8 @@ "wifi_feature_network_selection", "wifi_feature_with_hdi_chip_supported", "wifi_feature_with_vap_manager", - "wifi_feature_with_sta_asset" + "wifi_feature_with_sta_asset", + "wifi_feature_wifi_pro_ctrl" ], "adapted_system_type": [ "small", diff --git a/wifi/frameworks/native/interfaces/define.h b/wifi/frameworks/native/interfaces/define.h index 5699495de..f39ac0e1a 100644 --- a/wifi/frameworks/native/interfaces/define.h +++ b/wifi/frameworks/native/interfaces/define.h @@ -78,6 +78,7 @@ /* -----------Feature service name-------------- */ #define WIFI_SERVICE_STA "StaService" /* STA */ #define WIFI_SERVICE_SELFCURE "SelfCureService" /* SELFCURE */ +#define WIFI_SERVICE_WIFIPRO "WifiProService" /* WIFIPRO */ #define WIFI_SERVICE_AP "ApService" /* AP */ #define WIFI_SERVICE_P2P "P2pService" /* P2P */ #define WIFI_SERVICE_SCAN "ScanService" /* SCAN */ diff --git a/wifi/frameworks/native/interfaces/network_selection.h b/wifi/frameworks/native/interfaces/network_selection.h index a36c1c2bc..075adb86c 100644 --- a/wifi/frameworks/native/interfaces/network_selection.h +++ b/wifi/frameworks/native/interfaces/network_selection.h @@ -292,7 +292,8 @@ enum class FilterTag { HAS_INTERNET_NETWORK_SELECTOR_FILTER_TAG, RECOVERY_NETWORK_SELECTOR_FILTER_TAG, PORTAL_NETWORK_SELECTOR_FILTER_TAG, - IT_NETWORK_SELECTOR_FILTER_TAG + IT_NETWORK_SELECTOR_FILTER_TAG, + NOT_P2P_ENHANCE_FREQ_AT_5G_FILTER_TAG, }; enum class TagType { diff --git a/wifi/interfaces/inner_api/wifi_msg.h b/wifi/interfaces/inner_api/wifi_msg.h index 6e263ec10..dd5f4d03f 100644 --- a/wifi/interfaces/inner_api/wifi_msg.h +++ b/wifi/interfaces/inner_api/wifi_msg.h @@ -659,6 +659,7 @@ struct WifiDeviceConfig { WifiWapiConfig wifiWapiConfig; IpInfo lastDhcpResult; bool isShared; + int64_t lastTrySwitchWifiTimestamp { -1 }; WifiDeviceConfig() { diff --git a/wifi/services/wifi_standard/wifi_framework/BUILD.gn b/wifi/services/wifi_standard/wifi_framework/BUILD.gn index 76389f26b..cba473bfa 100644 --- a/wifi/services/wifi_standard/wifi_framework/BUILD.gn +++ b/wifi/services/wifi_standard/wifi_framework/BUILD.gn @@ -49,6 +49,7 @@ group("wifi_manage") { deps += [ "$WIFI_ROOT_DIR/services/wifi_standard/wifi_framework/wifi_manage/wifi_ap:wifi_ap_service", "$WIFI_ROOT_DIR/services/wifi_standard/wifi_framework/wifi_manage/wifi_common:wifi_common_service", + "$WIFI_ROOT_DIR/services/wifi_standard/wifi_framework/wifi_manage/wifi_pro:wifi_pro", "$WIFI_ROOT_DIR/services/wifi_standard/wifi_framework/wifi_manage/wifi_self_cure:wifi_self_cure", ] if (wifi_feature_with_p2p) { diff --git a/wifi/services/wifi_standard/wifi_framework/wifi_manage/BUILD.gn b/wifi/services/wifi_standard/wifi_framework/wifi_manage/BUILD.gn index 9577290c8..838a86d58 100644 --- a/wifi/services/wifi_standard/wifi_framework/wifi_manage/BUILD.gn +++ b/wifi/services/wifi_standard/wifi_framework/wifi_manage/BUILD.gn @@ -189,6 +189,7 @@ if (defined(ohos_lite)) { "$WIFI_ROOT_DIR/services/wifi_standard/wifi_framework/wifi_manage/wifi_scan", "$WIFI_ROOT_DIR/services/wifi_standard/wifi_framework/wifi_manage/wifi_scan_sa", "$WIFI_ROOT_DIR/services/wifi_standard/wifi_framework/wifi_manage/wifi_self_cure", + "$WIFI_ROOT_DIR/services/wifi_standard/wifi_framework/wifi_manage/wifi_pro", "$WIFI_ROOT_DIR/services/wifi_standard/wifi_framework/wifi_manage/wifi_sub_manage", "$WIFI_ROOT_DIR/services/wifi_standard/wifi_framework/wifi_manage/wifi_ap", "$WIFI_ROOT_DIR/services/wifi_standard/wifi_framework/wifi_manage/wifi_ap_sa", @@ -499,6 +500,7 @@ if (defined(ohos_lite)) { "$WIFI_ROOT_DIR/services/wifi_standard/wifi_framework/wifi_manage/wifi_common:wifi_common_service", "$WIFI_ROOT_DIR/services/wifi_standard/wifi_framework/wifi_manage/wifi_native:wifi_native", "$WIFI_ROOT_DIR/services/wifi_standard/wifi_framework/wifi_manage/wifi_p2p:wifi_p2p_service", + "$WIFI_ROOT_DIR/services/wifi_standard/wifi_framework/wifi_manage/wifi_pro:wifi_pro", "$WIFI_ROOT_DIR/services/wifi_standard/wifi_framework/wifi_manage/wifi_scan:wifi_scan_service", "$WIFI_ROOT_DIR/services/wifi_standard/wifi_framework/wifi_manage/wifi_self_cure:wifi_self_cure", "$WIFI_ROOT_DIR/services/wifi_standard/wifi_framework/wifi_manage/wifi_sta:wifi_sta_service", @@ -557,6 +559,10 @@ if (defined(ohos_lite)) { defines += [ "SUPPORT_ClOUD_WIFI_ASSET" ] } + if (wifi_feature_wifi_pro_ctrl) { + defines += [ "FEATURE_WIFI_PRO_SUPPORT" ] + } + if (defined(global_parts_info) && defined(global_parts_info.telephony_core_service)) { external_deps += [ "core_service:tel_core_service_api" ] diff --git a/wifi/services/wifi_standard/wifi_framework/wifi_manage/wifi_common/BUILD.gn b/wifi/services/wifi_standard/wifi_framework/wifi_manage/wifi_common/BUILD.gn index 3385d9b40..c2ba389a4 100644 --- a/wifi/services/wifi_standard/wifi_framework/wifi_manage/wifi_common/BUILD.gn +++ b/wifi/services/wifi_standard/wifi_framework/wifi_manage/wifi_common/BUILD.gn @@ -109,6 +109,7 @@ if (defined(ohos_lite)) { } install_enable = true include_dirs = [ + "network_black_list", "$WIFI_ROOT_DIR/base/utils", "$WIFI_ROOT_DIR/interfaces/inner_api", "$WIFI_ROOT_DIR/frameworks/native/interfaces", @@ -132,6 +133,7 @@ if (defined(ohos_lite)) { "$WIFI_ROOT_DIR/services/wifi_standard/wifi_framework/wifi_manage/wifi_scan", "$WIFI_ROOT_DIR/services/wifi_standard/wifi_framework/wifi_manage/wifi_scan_sa", "$WIFI_ROOT_DIR/services/wifi_standard/wifi_framework/wifi_manage/wifi_self_cure", + "$WIFI_ROOT_DIR/services/wifi_standard/wifi_framework/wifi_manage/wifi_pro", "$WIFI_ROOT_DIR/services/wifi_standard/wifi_framework/wifi_manage/wifi_sub_manage", "$WIFI_ROOT_DIR/services/wifi_standard/wifi_framework/wifi_manage/wifi_ap", "$WIFI_ROOT_DIR/services/wifi_standard/wifi_framework/wifi_manage/wifi_ap_sa", @@ -146,6 +148,7 @@ if (defined(ohos_lite)) { "app_network_speed_limit/app_network_speed_limit_service.cpp", "app_network_speed_limit/speed_limit_configs_writer.cpp", "block_connect_service.cpp", + "network_black_list/network_black_list_manager.cpp", "wifi_app_state_aware.cpp", "wifi_auth_center.cpp", "wifi_channel_helper.cpp", @@ -215,6 +218,10 @@ if (defined(ohos_lite)) { "FEATURE_SELF_CURE_SUPPORT", ] + if (wifi_feature_wifi_pro_ctrl) { + defines += [ "FEATURE_WIFI_PRO_SUPPORT" ] + } + if (is_asan) { defines += [ "DTFUZZ_TEST" ] } diff --git a/wifi/services/wifi_standard/wifi_framework/wifi_manage/wifi_common/network_black_list/network_black_list_manager.cpp b/wifi/services/wifi_standard/wifi_framework/wifi_manage/wifi_common/network_black_list/network_black_list_manager.cpp new file mode 100644 index 000000000..361a4bf31 --- /dev/null +++ b/wifi/services/wifi_standard/wifi_framework/wifi_manage/wifi_common/network_black_list/network_black_list_manager.cpp @@ -0,0 +1,147 @@ +/* + * Copyright (C) 2024-2024 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 +#include "wifi_timer.h" +#include "network_black_list_manager.h" +#include "wifi_logger.h" +#include "wifi_common_util.h" + +namespace OHOS { +namespace Wifi { +DEFINE_WIFILOG_LABEL("NetworkBlockListManager"); +namespace { +constexpr int32_t MAX_CONNECT_FAILED_TIMES = 2; +} + +NetworkBlockListManager::NetworkBlockListManager() +{} + +NetworkBlockListManager::~NetworkBlockListManager() +{} + +NetworkBlockListManager &NetworkBlockListManager::GetInstance() +{ + static NetworkBlockListManager gNetworkBlockListManager; + return gNetworkBlockListManager; +} + +void NetworkBlockListManager::AddWifiBlocklist(const std::string &bssid) +{ + if (bssid.empty()) { + WIFI_LOGI("AddWifiBlocklist, bssid is invalid"); + return; + } + + WIFI_LOGI("AddWifiBlocklist, bssid:%{public}s", MacAnonymize(bssid).c_str()); + std::lock_guard lock(mutex_); + wifiBlockSet_.insert(bssid); +} + +void NetworkBlockListManager::RemoveWifiBlocklist(const std::string &bssid) +{ + WIFI_LOGI("Enter RemoveWifiBlocklist"); + std::lock_guard lock(mutex_); + if (wifiBlockSet_.empty()) { + WIFI_LOGI("RemoveWifiBlocklist, wifiBlockSet is empty"); + return; + } + + if (wifiBlockSet_.find(bssid) != wifiBlockSet_.end()) { + WIFI_LOGI("RemoveWifiBlocklist, bssid:%{public}s", MacAnonymize(bssid).c_str()); + wifiBlockSet_.erase(bssid); + } +} + +bool NetworkBlockListManager::IsInWifiBlocklist(const std::string &bssid) +{ + if (bssid.empty()) { + return false; + } + + std::lock_guard lock(mutex_); + if (wifiBlockSet_.empty()) { + return false; + } + + auto iter = wifiBlockSet_.find(bssid); + return iter != wifiBlockSet_.end(); +} + +void NetworkBlockListManager::AddAbnormalWifiBlocklist(const std::string &bssid) +{ + if (bssid.empty()) { + WIFI_LOGI("AddAbnormalWifiBlocklist, bssid is invalid"); + return; + } + std::lock_guard lock(mutex_); + abnormalWifiBlockSet_.insert(bssid); +} + +void NetworkBlockListManager::CleanAbnormalWifiBlocklist() +{ + std::lock_guard lock(mutex_); + abnormalWifiBlockSet_.clear(); +} + +bool NetworkBlockListManager::IsInAbnormalWifiBlocklist(const std::string &bssid) +{ + if (abnormalWifiBlockSet_.empty()) { + return false; + } + + std::lock_guard lock(mutex_); + return abnormalWifiBlockSet_.find(bssid) != abnormalWifiBlockSet_.end(); +} + +void NetworkBlockListManager::CleanTempWifiBlockList() +{ + std::lock_guard lock(mutex_); + std::map tempMap; + tempWifiBlockMap_.swap(tempMap); +} + +bool NetworkBlockListManager::IsInTempWifiBlockList(const std::string &bssid) +{ + if (tempWifiBlockMap_.empty()) { + return false; + } + + std::lock_guard lock(mutex_); + return tempWifiBlockMap_.find(bssid) != tempWifiBlockMap_.end(); +} + +bool NetworkBlockListManager::IsFailedMultiTimes(const std::string &bssid) +{ + if (bssid.empty()) { + return false; + } + + std::lock_guard lock(mutex_); + int32_t counter = 1; + auto iter = tempWifiBlockMap_.find(bssid); + if (iter != tempWifiBlockMap_.end()) { + counter++; + iter->second = counter; + } else { + tempWifiBlockMap_[bssid] = counter; + } + + return counter >= MAX_CONNECT_FAILED_TIMES; +} + +} // namespace Wifi +} // namespace OHOS \ No newline at end of file diff --git a/wifi/services/wifi_standard/wifi_framework/wifi_manage/wifi_common/network_black_list/network_black_list_manager.h b/wifi/services/wifi_standard/wifi_framework/wifi_manage/wifi_common/network_black_list/network_black_list_manager.h new file mode 100644 index 000000000..29e848ea9 --- /dev/null +++ b/wifi/services/wifi_standard/wifi_framework/wifi_manage/wifi_common/network_black_list/network_black_list_manager.h @@ -0,0 +1,49 @@ +/* + * Copyright (C) 2024-2024 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_BLACK_LIST_MANAGER_H +#define OHOS_WIFI_NETWORK_BLACK_LIST_MANAGER_H + +#include +#include +#include "wifi_log.h" + +namespace OHOS { +namespace Wifi { +class NetworkBlockListManager { +public: + NetworkBlockListManager(); + ~NetworkBlockListManager(); + static NetworkBlockListManager &GetInstance(); + void AddWifiBlocklist(const std::string &bssid); + bool IsInWifiBlocklist(const std::string &bssid); + void AddAbnormalWifiBlocklist(const std::string &bssid); + void CleanAbnormalWifiBlocklist(); + void CleanTempWifiBlockList(); + bool IsInAbnormalWifiBlocklist(const std::string &bssid); + bool IsInTempWifiBlockList(const std::string &bssid); + bool IsFailedMultiTimes(const std::string &bssid); + void RemoveWifiBlocklist(const std::string &bssid); + +private: + std::mutex mutex_; + std::set wifiBlockSet_; + std::set abnormalWifiBlockSet_; + std::map tempWifiBlockMap_; +}; + +} // namespace Wifi +} // namespace OHOS +#endif \ No newline at end of file diff --git a/wifi/services/wifi_standard/wifi_framework/wifi_manage/wifi_controller/concrete_manager_state_machine.cpp b/wifi/services/wifi_standard/wifi_framework/wifi_manage/wifi_controller/concrete_manager_state_machine.cpp index 166752248..e0fd22f73 100644 --- a/wifi/services/wifi_standard/wifi_framework/wifi_manage/wifi_controller/concrete_manager_state_machine.cpp +++ b/wifi/services/wifi_standard/wifi_framework/wifi_manage/wifi_controller/concrete_manager_state_machine.cpp @@ -599,6 +599,9 @@ ErrCode ConcreteMangerMachine::SwitchSemiFromEnable() WIFI_LOGE("SwitchSemiFromEnable, Instance get sta service is null!"); WifiConfigCenter::GetInstance().SetWifiMidState(WifiOprMidState::CLOSED, mid); WifiServiceManager::GetInstance().UnloadService(WIFI_SERVICE_STA, mid); +#ifdef FEATURE_WIFI_PRO_SUPPORT + WifiServiceManager::GetInstance().UnloadService(WIFI_SERVICE_WIFIPRO, mid); +#endif #ifdef FEATURE_SELF_CURE_SUPPORT WifiServiceManager::GetInstance().UnloadService(WIFI_SERVICE_SELFCURE, mid); #endif diff --git a/wifi/services/wifi_standard/wifi_framework/wifi_manage/wifi_controller/wifi_service_scheduler.cpp b/wifi/services/wifi_standard/wifi_framework/wifi_manage/wifi_controller/wifi_service_scheduler.cpp index b6d639534..85eacdf1d 100644 --- a/wifi/services/wifi_standard/wifi_framework/wifi_manage/wifi_controller/wifi_service_scheduler.cpp +++ b/wifi/services/wifi_standard/wifi_framework/wifi_manage/wifi_controller/wifi_service_scheduler.cpp @@ -173,11 +173,7 @@ ErrCode WifiServiceScheduler::AutoStopStaService(int instId) IStaService *pService = WifiServiceManager::GetInstance().GetStaServiceInst(instId); if (pService == nullptr) { WIFI_LOGE("AutoStopStaService, Instance get sta service is null!"); - WifiConfigCenter::GetInstance().SetWifiMidState(WifiOprMidState::CLOSED, instId); - WifiServiceManager::GetInstance().UnloadService(WIFI_SERVICE_STA, instId); -#ifdef FEATURE_SELF_CURE_SUPPORT - WifiServiceManager::GetInstance().UnloadService(WIFI_SERVICE_SELFCURE, instId); -#endif + HandleGetStaFailed(instId); return WIFI_OPT_SUCCESS; } DispatchWifiCloseRes(OperateResState::CLOSE_WIFI_CLOSING, instId); @@ -247,6 +243,18 @@ ErrCode WifiServiceScheduler::AutoStopWifi2Service(int instId) return WIFI_OPT_SUCCESS; } +void WifiServiceScheduler::HandleGetStaFailed(int instId) +{ + WifiConfigCenter::GetInstance().SetWifiMidState(WifiOprMidState::CLOSED, instId); + WifiServiceManager::GetInstance().UnloadService(WIFI_SERVICE_STA, instId); +#ifdef FEATURE_WIFI_PRO_SUPPORT + WifiServiceManager::GetInstance().UnloadService(WIFI_SERVICE_WIFIPRO, instId); +#endif +#ifdef FEATURE_SELF_CURE_SUPPORT + WifiServiceManager::GetInstance().UnloadService(WIFI_SERVICE_SELFCURE, instId); +#endif +} + ErrCode WifiServiceScheduler::AutoStartScanOnly(int instId, std::string &staIfName) { WifiOprMidState curState = WifiConfigCenter::GetInstance().GetWifiScanOnlyMidState(instId); @@ -389,6 +397,7 @@ ErrCode WifiServiceScheduler::PostStartWifi(int instId) ErrCode errCode = WifiManager::GetInstance().GetWifiP2pManager()->AutoStartP2pService(); if (errCode != WIFI_OPT_SUCCESS && errCode != WIFI_OPT_OPEN_SUCC_WHEN_OPENED) { WIFI_LOGE("AutoStartStaService, AutoStartP2pService failed!"); + return WIFI_OPT_FAILED; } #endif return WIFI_OPT_SUCCESS; @@ -407,18 +416,16 @@ ErrCode WifiServiceScheduler::StartWifiStaService(int instId) return WIFI_OPT_FAILED; } WIFI_LOGD("StartWifiStaService GetStaServiceInst instId:%{public}d", instId); -#ifdef FEATURE_SELF_CURE_SUPPORT - if (instId == INSTID_WLAN0) { - if (StartSelfCureService(instId) != WIFI_OPT_SUCCESS) { - WIFI_LOGE("StartSelfCureService failed!"); - } - } -#endif IStaService *pService = WifiServiceManager::GetInstance().GetStaServiceInst(instId); if (pService == nullptr) { WIFI_LOGE("StartWifiStaService Create %{public}s service failed!", WIFI_SERVICE_STA); return WIFI_OPT_FAILED; } + + if (StartDependentService(instId) != WIFI_OPT_SUCCESS) { + return WIFI_OPT_FAILED; + } + WIFI_LOGD("StartWifiStaService InitStaService instId:%{public}d", instId); if (InitStaService(pService, instId) != WIFI_OPT_SUCCESS) { WIFI_LOGE("StartWifiStaService InitStaService failed!"); @@ -446,6 +453,28 @@ ErrCode WifiServiceScheduler::StartWifiStaService(int instId) return WIFI_OPT_SUCCESS; } +ErrCode WifiServiceScheduler::StartDependentService(int instId) +{ + if (instId != INSTID_WLAN0) { + return WIFI_OPT_SUCCESS; + } + +#ifdef FEATURE_WIFI_PRO_SUPPORT + if (StartWifiProService(instId) != WIFI_OPT_SUCCESS) { + WIFI_LOGE("StartWifiProService failed!"); + return WIFI_OPT_FAILED; + } +#endif +#ifdef FEATURE_SELF_CURE_SUPPORT + if (StartSelfCureService(instId) != WIFI_OPT_SUCCESS) { + WIFI_LOGE("StartSelfCureService failed!"); + return WIFI_OPT_FAILED; + } +#endif + + return WIFI_OPT_SUCCESS; +} + ErrCode WifiServiceScheduler::InitStaService(IStaService *pService, int instId) { if (pService == nullptr) { @@ -498,6 +527,41 @@ ErrCode WifiServiceScheduler::InitStaService(IStaService *pService, int instId) return WIFI_OPT_SUCCESS; } +#ifdef FEATURE_WIFI_PRO_SUPPORT +ErrCode WifiServiceScheduler::StartWifiProService(int instId) +{ + if (WifiServiceManager::GetInstance().CheckAndEnforceService(WIFI_SERVICE_WIFIPRO) < 0) { + WIFI_LOGE("Load %{public}s service failed!", WIFI_SERVICE_WIFIPRO); + return WIFI_OPT_FAILED; + } + + IWifiProService *pWifiProService = WifiServiceManager::GetInstance().GetWifiProServiceInst(instId); + if (pWifiProService == nullptr) { + WIFI_LOGE("Create %{public}s service failed!", WIFI_SERVICE_WIFIPRO); + return WIFI_OPT_FAILED; + } + ErrCode errCode = pWifiProService->InitWifiProService(); + if (errCode != WIFI_OPT_SUCCESS) { + WIFI_LOGE("Service enable wifi pro failed, ret %{public}d!", static_cast(errCode)); + return WIFI_OPT_FAILED; + } + + IStaService *pService = WifiServiceManager::GetInstance().GetStaServiceInst(instId); + if (pService == nullptr) { + WIFI_LOGE("Get %{public}s service failed!", WIFI_SERVICE_STA); + return WIFI_OPT_FAILED; + } + + errCode = pService->RegisterStaServiceCallback(pWifiProService->GetStaCallback()); + if (errCode != WIFI_OPT_SUCCESS) { + WIFI_LOGE("WifiPro register sta service callback failed!"); + return WIFI_OPT_FAILED; + } + + return WIFI_OPT_SUCCESS; +} +#endif + #ifdef FEATURE_SELF_CURE_SUPPORT ErrCode WifiServiceScheduler::StartSelfCureService(int instId) { diff --git a/wifi/services/wifi_standard/wifi_framework/wifi_manage/wifi_controller/wifi_service_scheduler.h b/wifi/services/wifi_standard/wifi_framework/wifi_manage/wifi_controller/wifi_service_scheduler.h index 7d8c20830..f8a4aba8f 100644 --- a/wifi/services/wifi_standard/wifi_framework/wifi_manage/wifi_controller/wifi_service_scheduler.h +++ b/wifi/services/wifi_standard/wifi_framework/wifi_manage/wifi_controller/wifi_service_scheduler.h @@ -62,6 +62,11 @@ private: ErrCode PostStartWifi2(int instId); ErrCode InitStaService(IStaService *pService, int instId); ErrCode StartWifiStaService(int instId); + ErrCode StartDependentService(int instId); + void HandleGetStaFailed(int instId); +#ifdef FEATURE_WIFI_PRO_SUPPORT + ErrCode StartWifiProService(int instId); +#endif #ifdef FEATURE_SELF_CURE_SUPPORT ErrCode StartSelfCureService(int instId); #endif diff --git a/wifi/services/wifi_standard/wifi_framework/wifi_manage/wifi_pro/BUILD.gn b/wifi/services/wifi_standard/wifi_framework/wifi_manage/wifi_pro/BUILD.gn new file mode 100644 index 000000000..de64262e9 --- /dev/null +++ b/wifi/services/wifi_standard/wifi_framework/wifi_manage/wifi_pro/BUILD.gn @@ -0,0 +1,99 @@ +# Copyright (C) 2023-2023 Huawei Device Co., Ltd. +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +import("//build/ohos.gni") +import("//foundation/communication/wifi/wifi/wifi.gni") + +ohos_static_library("wifi_pro") { + branch_protector_ret = "pac_ret" + + sanitize = { + cfi = true # Enable/disable control flow integrity detection + boundary_sanitize = true # Enable boundary san detection + cfi_cross_dso = true # Cross-SO CFI Checks + integer_overflow = true # Enable integer overflow detection + ubsan = true # Enable some Ubsan options + debug = false + } + include_dirs = [ + "$WIFI_ROOT_DIR/frameworks/native/interfaces", + "$WIFI_ROOT_DIR/services/wifi_standard/wifi_framework/wifi_toolkit/config", + "$WIFI_ROOT_DIR/services/wifi_standard/wifi_framework/wifi_manage", + "$WIFI_ROOT_DIR/services/wifi_standard/wifi_framework/wifi_manage/wifi_common", + "$WIFI_ROOT_DIR/services/wifi_standard/wifi_framework/wifi_manage/wifi_sta", + "$WIFI_ROOT_DIR/services/wifi_standard/wifi_framework/wifi_manage/wifi_scan", + "$WIFI_ROOT_DIR/services/wifi_standard/wifi_framework/wifi_manage/wifi_self_cure", + "$WIFI_ROOT_DIR/services/wifi_standard/wifi_framework/wifi_manage/wifi_p2p", + "$WIFI_ROOT_DIR/services/wifi_standard/wifi_framework/wifi_manage/wifi_pro", + "$WIFI_ROOT_DIR/services/wifi_standard/wifi_framework/wifi_manage/wifi_native/common", + "$WIFI_ROOT_DIR/services/wifi_standard/wifi_framework/wifi_manage/wifi_native/wifi_hal_interface", + "$WIFI_ROOT_DIR/services/wifi_standard/wifi_framework/wifi_pro", + "$WIFI_ROOT_DIR/services/wifi_standard/wifi_framework/wifi_manage/wifi_sta/network_select", + "$WIFI_ROOT_DIR/services/wifi_standard/wifi_framework/wifi_manage/wifi_common/network_black_list", + ] + + sources = [ + "$WIFI_ROOT_DIR/frameworks/native/src/network_selection.cpp", + "$WIFI_ROOT_DIR/services/wifi_standard/wifi_framework/wifi_manage/wifi_sta/network_select/external_wifi_common_builder_manager.cpp", + "$WIFI_ROOT_DIR/services/wifi_standard/wifi_framework/wifi_manage/wifi_sta/network_select/external_wifi_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_factory.cpp", + "$WIFI_ROOT_DIR/services/wifi_standard/wifi_framework/wifi_manage/wifi_sta/network_select/network_selector_impl.cpp", + "$WIFI_ROOT_DIR/services/wifi_standard/wifi_framework/wifi_manage/wifi_sta/network_select/wifi_comparator_impl.cpp", + "$WIFI_ROOT_DIR/services/wifi_standard/wifi_framework/wifi_manage/wifi_sta/network_select/wifi_filter_impl.cpp", + "$WIFI_ROOT_DIR/services/wifi_standard/wifi_framework/wifi_manage/wifi_sta/network_select/wifi_scorer_impl.cpp", + "wifi_pro_interface.cpp", + "wifi_pro_service.cpp", + "wifi_pro_state_machine.cpp", + "wifi_pro_utils.cpp", + ] + + deps = [ + "$WIFI_ROOT_DIR/base:wifi_base", + "$WIFI_ROOT_DIR/services/wifi_standard/wifi_framework/wifi_manage/wifi_common:wifi_common_service", + "$WIFI_ROOT_DIR/services/wifi_standard/wifi_framework/wifi_toolkit:wifi_toolkit", + "$WIFI_ROOT_DIR/utils:wifi_utils", + ] + + external_deps = [ + "ability_runtime:app_manager", + "c_utils:utils", + "hilog:libhilog", + "init:libbegetutil", + "netmanager_base:net_conn_manager_if", + ] + + defines = [] + + if (wifi_feature_wifi_pro_ctrl) { + defines += [ "FEATURE_WIFI_PRO_SUPPORT" ] + } + + defines += [ "FEATURE_SELF_CURE_SUPPORT" ] + + cflags = memory_optimization_cflags + cflags_cc = memory_optimization_cflags_cc + cflags_cc += [ + "-std=c++17", + "-Wall", + ] + + ldflags = [ + "-fPIC", + "-Wl,-E", + ] + + part_name = "wifi" + subsystem_name = "communication" +} diff --git a/wifi/services/wifi_standard/wifi_framework/wifi_manage/wifi_pro/iwifi_pro_service.h b/wifi/services/wifi_standard/wifi_framework/wifi_manage/wifi_pro/iwifi_pro_service.h new file mode 100644 index 000000000..ef737883a --- /dev/null +++ b/wifi/services/wifi_standard/wifi_framework/wifi_manage/wifi_pro/iwifi_pro_service.h @@ -0,0 +1,51 @@ +/* + * Copyright (C) 2024-2024 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_IWIFI_PRO_SERVICE_H +#define OHOS_WIFI_IWIFI_PRO_SERVICE_H + +#include "wifi_errcode.h" +#include "wifi_msg.h" +#include "sta_service_callback.h" + +namespace OHOS { +namespace Wifi { +class IWifiProService { +public: + virtual ~IWifiProService() = default; + /** + * @Description wifiPro service initialization function. + * + * @return ErrCode - success: WIFI_OPT_SUCCESS, failed: WIFI_OPT_FAILED + */ + virtual ErrCode InitWifiProService() = 0; + + /** + * @Description Get register sta callback + * + * @return StaServiceCallback - sta callback + */ + virtual StaServiceCallback GetStaCallback() const = 0; + + /** + * @Description deal scan results + * + * @return results - scan results + */ + virtual void DealScanResult(const std::vector &results) = 0; +}; +} // namespace Wifi +} // namespace OHOS +#endif \ No newline at end of file diff --git a/wifi/services/wifi_standard/wifi_framework/wifi_manage/wifi_pro/wifi_pro_common.h b/wifi/services/wifi_standard/wifi_framework/wifi_manage/wifi_pro/wifi_pro_common.h new file mode 100644 index 000000000..0c40980f9 --- /dev/null +++ b/wifi/services/wifi_standard/wifi_framework/wifi_manage/wifi_pro/wifi_pro_common.h @@ -0,0 +1,69 @@ +/* + * Copyright (C) 2024-2024 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_PRO_COMMON_H +#define OHOS_WIFI_PRO_COMMON_H + +namespace OHOS { +namespace Wifi { +#define FRIEND_GTEST(test_typename) friend class test_typename##Test + +constexpr int32_t ROAM_SCENE = 1; +constexpr int64_t WIFI_SWITCH_RECORD_MAX_TIME = 1000 * 60 * 60 * 24 * 14; // 14天,单位:ms + +enum WifiProCommond { + EVENT_NOTIFY_WIFI_PRO_SWITCH_CHANGED = 0, + EVENT_WIFI_CONNECT_STATE_CHANGED = 1, + EVENT_DISCONNECT_DISCONNECTED = 2, + EVENT_HANDLE_SCAN_RESULT = 3, + EVENT_WIFI2WIFI_SELECT_NETWORK_RESULT = 4, + EVENT_WIFI2WIFI_FAILED = 5, + EVENT_WIFI_RSSI_CHANGED = 6, + EVENT_CHECK_WIFI_INTERNET_RESULT = 7, + EVENT_HTTP_REACHABLE_RESULT = 8, + EVENT_REQUEST_SCAN_DELAY = 9, + EVENT_REMOVE_BLOCK_LIST = 10, +}; + +enum SigLevel { + SIG_LEVEL_0 = 0, + SIG_LEVEL_1 = 1, + SIG_LEVEL_2 = 2, + SIG_LEVEL_3 = 3, + SIG_LEVEL_4 = 4, + SIG_LEVEL_MAX = 4, +}; + +inline const int32_t QUICK_SCAN_INTERVAL[SIG_LEVEL_MAX] = { 10000, 10000, 15000, 30000 }; +inline const int32_t NORMAL_SCAN_INTERVAL[SIG_LEVEL_MAX] = { 15000, 15000, 30000, 60000 }; +inline const int32_t QUICK_SCAN_MAX_COUNTER[SIG_LEVEL_MAX] = { 20, 20, 10, 10 }; +inline const int32_t NORMAL_SCAN_MAX_COUNTER[SIG_LEVEL_MAX] = { 4, 4, 2, 2 }; + +enum WifiSwitchReason { + // current ap triggers wifi switch because of no internet + WIFI_SWITCH_REASON_NO_INTERNET = 1, + // current ap triggers wifi switch because of rssi poor + WIFI_SWITCH_REASON_POOR_RSSI = 2, + // current ap triggers wifi switch because of internet block under poor rssi + WIFI_SWITCH_REASON_STRONG_RSSI_INTERNET_SLOW = 3, + // current ap triggers wifi switch because of internet block under strong rssi + WIFI_SWITCH_REASON_POOR_RSSI_INTERNET_SLOW = 4, + // current ap triggers wifi switch because of checking wifi in background + WIFI_SWITCH_REASON_BACKGROUND_CHECK_AVAILABLE_WIFI = 5, +}; + +} // namespace Wifi +} // namespace OHOS +#endif \ No newline at end of file diff --git a/wifi/services/wifi_standard/wifi_framework/wifi_manage/wifi_pro/wifi_pro_interface.cpp b/wifi/services/wifi_standard/wifi_framework/wifi_manage/wifi_pro/wifi_pro_interface.cpp new file mode 100644 index 000000000..130ee769b --- /dev/null +++ b/wifi/services/wifi_standard/wifi_framework/wifi_manage/wifi_pro/wifi_pro_interface.cpp @@ -0,0 +1,106 @@ +/* + * Copyright (C) 2024-2024 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 "define.h" +#include "wifi_logger.h" +#include "wifi_pro_interface.h" +#include "wifi_pro_service.h" + +namespace OHOS { +namespace Wifi { +DEFINE_WIFILOG_LABEL("WifiProInterface"); + +WifiProInterface::WifiProInterface(int32_t instId) : instId_(instId) +{ + WIFI_LOGI("Enter WifiProInterface"); +} + +WifiProInterface::~WifiProInterface() +{ + WIFI_LOGI("Enter ~WifiProInterface"); +} + +ErrCode WifiProInterface::InitWifiProService() +{ + WIFI_LOGI("Enter WifiProInterface::InitWifiProService"); + std::lock_guard lock(mutex_); + if (pWifiProService_ == nullptr) { + pWifiProService_ = std::make_shared(instId_); + if (pWifiProService_ == nullptr) { + WIFI_LOGE("Alloc pWifiProService failed."); + return WIFI_OPT_FAILED; + } + InitCallback(); + if (pWifiProService_->InitWifiProService() != WIFI_OPT_SUCCESS) { + WIFI_LOGE("InitWifiProService failed."); + return WIFI_OPT_FAILED; + } + } + return WIFI_OPT_SUCCESS; +} + +void WifiProInterface::InitCallback() +{ + using namespace std::placeholders; + WIFI_LOGI("Enter WifiProInterface::InitCallback"); + staCallback_.callbackModuleName = "WifiProService"; + staCallback_.OnStaConnChanged = [this](OperateResState state, const WifiLinkedInfo &linkedInfo, int32_t instId) { + this->DealStaConnChanged(state, linkedInfo, instId); + }; + staCallback_.OnStaRssiLevelChanged = [this](int32_t rssi, int32_t instId) { + this->DealRssiLevelChanged(rssi, instId); + }; +} + +void WifiProInterface::DealStaConnChanged(OperateResState state, const WifiLinkedInfo &linkedInfo, int32_t instId) +{ + WIFI_LOGI("Enter WifiProInterface::DealStaConnChanged"); + std::lock_guard lock(mutex_); + if (pWifiProService_ == nullptr) { + WIFI_LOGI("pWifiProService is null"); + return; + } + pWifiProService_->HandleStaConnChanged(state, linkedInfo); +} + +void WifiProInterface::DealRssiLevelChanged(int32_t rssi, int32_t instId) +{ + WIFI_LOGI("Enter WifiProInterface::DealRssiLevelChanged"); + std::lock_guard lock(mutex_); + if (pWifiProService_ == nullptr) { + WIFI_LOGI("pWifiProService is null"); + return; + } + pWifiProService_->HandleRssiLevelChanged(rssi); +} + +void WifiProInterface::DealScanResult(const std::vector &results) +{ + WIFI_LOGI("Enter WifiProInterface::DealScanResult"); + std::lock_guard lock(mutex_); + if (pWifiProService_ == nullptr) { + WIFI_LOGI("pWifiProService is null"); + return; + } + pWifiProService_->HandleScanResult(results); +} + +StaServiceCallback WifiProInterface::GetStaCallback() const +{ + return staCallback_; +} + +} // namespace Wifi +} // namespace OHOS diff --git a/wifi/services/wifi_standard/wifi_framework/wifi_manage/wifi_pro/wifi_pro_interface.h b/wifi/services/wifi_standard/wifi_framework/wifi_manage/wifi_pro/wifi_pro_interface.h new file mode 100644 index 000000000..52993fb48 --- /dev/null +++ b/wifi/services/wifi_standard/wifi_framework/wifi_manage/wifi_pro/wifi_pro_interface.h @@ -0,0 +1,77 @@ +/* + * Copyright (C) 2024-2024 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_WIFI_PRO_INTERFACE_H +#define OHOS_WIFI_WIFI_PRO_INTERFACE_H + +#include "iwifi_pro_service.h" +#include "define.h" +#include "wifi_pro_common.h" + +namespace OHOS { +namespace Wifi { +class WifiProService; +class WifiProInterface : public IWifiProService { + FRIEND_GTEST(WifiProInterface); +public: + explicit WifiProInterface(int32_t instId = 0); + ~WifiProInterface() override; + + /** + * @Description self cure service initialization function. + * + * @return success: WIFI_OPT_SUCCESS, failed: WIFI_OPT_FAILED + */ + ErrCode InitWifiProService() override; + + /** + * @Description Get register sta callback + * + * @return StaServiceCallback - sta callback + */ + StaServiceCallback GetStaCallback() const override; + + /** + * @Description deal scan results + * + * @return results - scan results + */ + void DealScanResult(const std::vector &results) override; + +private: + /** + * @Description deal sta connection change + * + * @param state - OperateResState + * @param info - const WifiLinkedInfo + */ + void DealStaConnChanged(OperateResState state, const WifiLinkedInfo &linkedInfo, int32_t instId = 0); + + /** + * @Description rssi level changed + * + * @param rssi + */ + void DealRssiLevelChanged(int32_t rssi, int32_t instId = 0); +private: + std::mutex mutex_; + std::shared_ptr pWifiProService_ { nullptr }; + int32_t instId_ { 0 }; + StaServiceCallback staCallback_; + void InitCallback(); +}; +} // namespace Wifi +} // namespace OHOS +#endif \ No newline at end of file diff --git a/wifi/services/wifi_standard/wifi_framework/wifi_manage/wifi_pro/wifi_pro_service.cpp b/wifi/services/wifi_standard/wifi_framework/wifi_manage/wifi_pro/wifi_pro_service.cpp new file mode 100644 index 000000000..8654bd87d --- /dev/null +++ b/wifi/services/wifi_standard/wifi_framework/wifi_manage/wifi_pro/wifi_pro_service.cpp @@ -0,0 +1,138 @@ +/* + * Copyright (C) 2024-2024 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 "wifi_logger.h" +#include "wifi_msg.h" +#include "wifi_pro_service.h" +#include "wifi_pro_utils.h" +#include "wifi_common_util.h" + +#ifndef FALLTHROUGH_INTENDED +#define FALLTHROUGH_INTENDED [[clang::fallthrough]] // NOLINT +#endif + +namespace OHOS { +namespace Wifi { +DEFINE_WIFILOG_LABEL("WifiProService"); + +WifiProService::WifiProService(int32_t instId) + : instId_(instId) +{ + WIFI_LOGI("Enter WifiProService"); +} + +WifiProService::~WifiProService() +{ + WIFI_LOGI("Enter ~WifiProService"); +} + +ErrCode WifiProService::InitWifiProService() +{ + WIFI_LOGI("Enter InitSelfCureService."); + pWifiProStateMachine_ = std::make_shared(instId_); + if (pWifiProStateMachine_ == nullptr) { + WIFI_LOGE("Alloc WifiProStateMachine failed."); + return WIFI_OPT_FAILED; + } + if (pWifiProStateMachine_->Initialize() != WIFI_OPT_SUCCESS) { + WIFI_LOGE("Init WifiProStateMachine failed."); + return WIFI_OPT_FAILED; + } + return WIFI_OPT_SUCCESS; +} + +void WifiProService::HandleStaConnChanged(OperateResState state, const WifiLinkedInfo &linkedInfo) +{ + WIFI_LOGI("WifiProService wifi connection state change, state:%{public}d,connState:%{public}d," + "supplicantState:%{public}d.", state, linkedInfo.connState, static_cast(linkedInfo.supplicantState)); + if (pWifiProStateMachine_ == nullptr) { + WIFI_LOGE("%{public}s pWifiProStateMachine_ is null.", __FUNCTION__); + return; + } + + switch (state) { + case OperateResState::CONNECT_AP_CONNECTED: + FALLTHROUGH_INTENDED; + case OperateResState::DISCONNECT_DISCONNECTED: + NotifyWifiConnectStateChanged(state, linkedInfo); + break; + case OperateResState::CONNECT_CHECK_PORTAL: + FALLTHROUGH_INTENDED; + case OperateResState::CONNECT_NETWORK_DISABLED: + FALLTHROUGH_INTENDED; + case OperateResState::CONNECT_ENABLE_NETWORK_FAILED: + FALLTHROUGH_INTENDED; + case OperateResState::CONNECT_CONNECTING_TIMEOUT: + FALLTHROUGH_INTENDED; + case OperateResState::CONNECT_NETWORK_ENABLED: + NotifyCheckWifiInternetResult(state); + break; + case OperateResState::CONNECT_CONNECTION_REJECT: + FALLTHROUGH_INTENDED; + case OperateResState::CONNECT_PASSWORD_WRONG: + FALLTHROUGH_INTENDED; + case OperateResState::CONNECT_OBTAINING_IP_FAILED: + NotifyWifi2WifiFailed(); + break; + default: + break; + } +} + +void WifiProService::NotifyWifi2WifiFailed() +{ + WIFI_LOGI("NotifyWifi2WifiFailed: wifi2wifi failed"); + pWifiProStateMachine_->SendMessage(EVENT_WIFI2WIFI_FAILED); +} + +void WifiProService::NotifyWifiConnectStateChanged(OperateResState state, const WifiLinkedInfo &linkedInfo) +{ + WIFI_LOGI("NotifyWifiConnectStateChanged:networkId:%{public}d, ssid:%{public}s," + "bssid:%{public}s", linkedInfo.networkId, MacAnonymize(linkedInfo.ssid).c_str(), + MacAnonymize(linkedInfo.bssid).c_str()); + pWifiProStateMachine_->SendMessage(EVENT_WIFI_CONNECT_STATE_CHANGED, static_cast(state), + linkedInfo.networkId, linkedInfo.bssid); +} + +void WifiProService::NotifyCheckWifiInternetResult(OperateResState state) +{ + WIFI_LOGI("NotifyCheckWifiInternetResult: wifi internet result:%{public}d", static_cast(state)); + pWifiProStateMachine_->SendMessage(EVENT_CHECK_WIFI_INTERNET_RESULT, static_cast(state)); +} + +void WifiProService::HandleRssiLevelChanged(int32_t rssi) +{ + WIFI_LOGI("WifiProService::HandleRssiLevelChanged, %{public}d.", rssi); + if (pWifiProStateMachine_ == nullptr) { + WIFI_LOGE("%{public}s pWifiProStateMachine_ is null.", __FUNCTION__); + return; + } + + pWifiProStateMachine_->SendMessage(EVENT_WIFI_RSSI_CHANGED, rssi); +} + +void WifiProService::HandleScanResult(const std::vector &scanInfos) +{ + WIFI_LOGI("Enter WifiProService::HandleScanResult."); + if (pWifiProStateMachine_ == nullptr) { + WIFI_LOGE("%{public}s pWifiProStateMachine_ is null.", __FUNCTION__); + return; + } + + pWifiProStateMachine_->SendMessage(EVENT_HANDLE_SCAN_RESULT, scanInfos); +} +} // namespace Wifi +} // namespace OHOS \ No newline at end of file diff --git a/wifi/services/wifi_standard/wifi_framework/wifi_manage/wifi_pro/wifi_pro_service.h b/wifi/services/wifi_standard/wifi_framework/wifi_manage/wifi_pro/wifi_pro_service.h new file mode 100644 index 000000000..8b72416b1 --- /dev/null +++ b/wifi/services/wifi_standard/wifi_framework/wifi_manage/wifi_pro/wifi_pro_service.h @@ -0,0 +1,46 @@ +/* + * Copyright (C) 2024-2024 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_PRO_SERVICE_H +#define OHOS_WIFI_PRO_SERVICE_H + +#include "define.h" +#include "wifi_log.h" +#include "wifi_errcode.h" +#include "wifi_internal_msg.h" +#include "wifi_pro_state_machine.h" + +namespace OHOS { +namespace Wifi { +class WifiProService { + FRIEND_GTEST(WifiProService); +public: + explicit WifiProService(int32_t instId = 0); + ~WifiProService(); + ErrCode InitWifiProService(); + void HandleStaConnChanged(OperateResState state, const WifiLinkedInfo &linkedInfo); + void HandleRssiLevelChanged(int32_t rssi); + void HandleScanResult(const std::vector &scanInfos); +private: + std::shared_ptr pWifiProStateMachine_ { nullptr }; + int32_t instId_ { 0 }; + void NotifyWifi2WifiFailed(); + void NotifyWifiConnectStateChanged(OperateResState state, const WifiLinkedInfo &linkedInfo); + void NotifyCheckWifiInternetResult(OperateResState state); +}; + +} // namespace Wifi +} // namespace OHOS +#endif \ No newline at end of file diff --git a/wifi/services/wifi_standard/wifi_framework/wifi_manage/wifi_pro/wifi_pro_state_machine.cpp b/wifi/services/wifi_standard/wifi_framework/wifi_manage/wifi_pro/wifi_pro_state_machine.cpp new file mode 100644 index 000000000..2aeaa3531 --- /dev/null +++ b/wifi/services/wifi_standard/wifi_framework/wifi_manage/wifi_pro/wifi_pro_state_machine.cpp @@ -0,0 +1,961 @@ +/* + * Copyright (C) 2024-2024 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 +#include "iscan_service.h" +#include "wifi_config_center.h" +#include "wifi_logger.h" +#include "wifi_msg.h" +#include "wifi_pro_state_machine.h" +#include "wifi_service_manager.h" +#include "wifi_pro_utils.h" +#include "network_black_list_manager.h" + +namespace OHOS { +namespace Wifi { +namespace { +const std::string WIFI_PRO_STATE_MACHINE = "WifiProStateMachine"; +constexpr int32_t DEFAULT_RSSI = -200; +constexpr int32_t DEFAULT_SCAN_INTERVAL = 10 * 1000; // ms +constexpr int64_t BLOCKLIST_VALID_TIME = 120 * 1000; // ms +} + +DEFINE_WIFILOG_LABEL("WifiProStateMachine"); + +WifiProStateMachine::WifiProStateMachine(int32_t instId) + : StateMachine(WIFI_PRO_STATE_MACHINE), + instId_(instId) +{ + WIFI_LOGI("Enter WifiProStateMachine"); +} + +WifiProStateMachine::~WifiProStateMachine() +{ + WIFI_LOGI("Enter ~WifiProStateMachine"); + StopHandlerThread(); + ParsePointer(pDefaultState_); + ParsePointer(pWifiProEnableState_); + ParsePointer(pWifiProDisabledState_); + ParsePointer(pWifiConnectedState_); + ParsePointer(pWifiDisConnectedState_); + ParsePointer(pWifiLinkMonitorState_); +} + +void WifiProStateMachine::BuildStateTree() +{ + StatePlus(pDefaultState_, nullptr); + StatePlus(pWifiProEnableState_, pDefaultState_); + StatePlus(pWifiProDisabledState_, pDefaultState_); + StatePlus(pWifiConnectedState_, pWifiProEnableState_); + StatePlus(pWifiDisConnectedState_, pWifiProEnableState_); + StatePlus(pWifiLinkMonitorState_, pWifiProEnableState_); +} + +ErrCode WifiProStateMachine::InitWifiProStates() +{ + WIFI_LOGI("Enter InitWifiProStates"); + int32_t tmpErrNumber; + pDefaultState_ = new (std::nothrow)DefaultState(this); + tmpErrNumber = JudgmentEmpty(pDefaultState_); + pWifiProEnableState_ = new (std::nothrow)WifiProEnableState(this); + tmpErrNumber += JudgmentEmpty(pWifiProEnableState_); + pWifiProDisabledState_ = new (std::nothrow)WifiProDisabledState(this); + tmpErrNumber += JudgmentEmpty(pWifiProDisabledState_); + pWifiConnectedState_ = new (std::nothrow)WifiConnectedState(this); + tmpErrNumber += JudgmentEmpty(pWifiConnectedState_); + pWifiDisConnectedState_ = new (std::nothrow)WifiDisConnectedState(this); + tmpErrNumber += JudgmentEmpty(pWifiDisConnectedState_); + pWifiLinkMonitorState_ = new (std::nothrow)WifiLinkMonitorState(this); + tmpErrNumber += JudgmentEmpty(pWifiLinkMonitorState_); + if (tmpErrNumber != 0) { + WIFI_LOGE("InitWifiProStates someone state is null"); + return WIFI_OPT_FAILED; + } + return WIFI_OPT_SUCCESS; +} + +ErrCode WifiProStateMachine::Initialize() +{ + if (!InitialStateMachine(WIFI_PRO_STATE_MACHINE)) { + WIFI_LOGE("Initial WifiProStateMachine failed."); + return WIFI_OPT_FAILED; + } + if (InitWifiProStates() == WIFI_OPT_FAILED) { + return WIFI_OPT_FAILED; + } + BuildStateTree(); + SetFirstState(pWifiProEnableState_); + StartStateMachine(); + return WIFI_OPT_SUCCESS; +} + +bool WifiProStateMachine::IsKeepCurrWifiConnected() +{ + if (WifiProUtils::IsUserSelectNetwork() && (!isWifiNoInternet_)) { + WIFI_LOGI("IsKeepCurrWifiConnected, user select network."); + return true; + } + + if (WifiProUtils::IsAppInWhiteLists()) { + WIFI_LOGI("IsKeepCurrWifiConnected, in app white lists."); + return true; + } + + // AP+STA scene, do not switch + WifiOprMidState curState = WifiConfigCenter::GetInstance().GetApMidState(instId_); + if (curState == WifiOprMidState::RUNNING) { + WIFI_LOGI("IsKeepCurrWifiConnected, ap is running, do not switch"); + return true; + } + + return false; +} + +bool WifiProStateMachine::HasWifiSwitchRecord() +{ + RefreshConnectedNetWork(); + if (pCurrWifiInfo_ == nullptr) { + return false; + } + + if (pCurrWifiDeviceConfig_ != nullptr && pCurrWifiDeviceConfig_->lastTrySwitchWifiTimestamp > 0) { + int64_t now = WifiProUtils::GetCurrentTimeMs(); + // less than 14 days + if (now - pCurrWifiDeviceConfig_->lastTrySwitchWifiTimestamp < WIFI_SWITCH_RECORD_MAX_TIME) { + WIFI_LOGI("HasWifiSwitchRecord, has switch record in 14 days"); + return true; + } + } + return false; +} + +void WifiProStateMachine::RefreshConnectedNetWork() +{ + WifiLinkedInfo linkedInfo; + WifiConfigCenter::GetInstance().GetLinkedInfo(linkedInfo); + WIFI_LOGI("RefreshConnectedNetWork, connState:%{public}d," + "supplicantState:%{public}d.", linkedInfo.connState, static_cast(linkedInfo.supplicantState)); + if (!WifiProUtils::IsSupplicantConnecting(linkedInfo.supplicantState)) { + currentBssid_ = ""; + currentSsid_ = ""; + currentRssi_ = DEFAULT_RSSI; + return; + } + + pCurrWifiInfo_ = std::make_shared(linkedInfo); + currentBssid_ = linkedInfo.bssid; + currentSsid_ = linkedInfo.ssid; + currentRssi_ = linkedInfo.rssi; + std::vector configs; + WifiSettings::GetInstance().GetDeviceConfig(configs); + if (configs.empty()) { + WIFI_LOGI("RefreshConnectedNetWork, config is empty"); + return; + } + for (auto &wifiDeviceConfig : configs) { + if (wifiDeviceConfig.networkId == linkedInfo.networkId) { + WIFI_LOGI("RefreshConnectedNetWork, find device config,connState:%{public}d," + "networkId:%{public}d.", linkedInfo.connState, linkedInfo.networkId); + pCurrWifiDeviceConfig_ = std::make_shared(wifiDeviceConfig); + } + } +} + +bool WifiProStateMachine::IsReachWifiScanThreshold(int32_t signalLevel) +{ + WIFI_LOGI("IsReachWifiScanThreshold, rssiLevel:%{public}d.", signalLevel); + if (signalLevel == SIG_LEVEL_4) { + return false; + } + + if (signalLevel < SIG_LEVEL_3) { + return true; + } + + if (HasWifiSwitchRecord()) { + WIFI_LOGI("IsReachWifiScanThreshold, ap is not strong enough, and has switch record."); + return true; + } + + if (HasAvailableSsidToSwitch()) { + WIFI_LOGI("IsReachWifiScanThreshold, ap is not strong enough, and has available ap."); + return true; + } + + WIFI_LOGI("IsReachWifiScanThreshold, ap is not strong enough, no need to switch."); + return false; +} + +bool WifiProStateMachine::HasAvailableSsidToSwitch() +{ + return false; +} +/* --------------------------- state machine default state ------------------------------ */ +WifiProStateMachine::DefaultState::DefaultState(WifiProStateMachine *pWifiProStateMachine) + : State("DefaultState"), + pWifiProStateMachine_(pWifiProStateMachine) +{ + WIFI_LOGD("DefaultState construct success."); +} + +WifiProStateMachine::DefaultState::~DefaultState() {} + +void WifiProStateMachine::DefaultState::GoInState() +{ + WIFI_LOGI("Enter DefaultState GoInState function."); +} + +void WifiProStateMachine::DefaultState::GoOutState() +{ + WIFI_LOGI("Enter DefaultState GoOutState function."); +} + +bool WifiProStateMachine::DefaultState::ExecuteStateMsg(InternalMessagePtr msg) +{ + if (msg == nullptr) { + return false; + } + WIFI_LOGD("DefaultState-msgCode=%{public}d is received.", msg->GetMessageName()); + switch (msg->GetMessageName()) { + case EVENT_NOTIFY_WIFI_PRO_SWITCH_CHANGED: + HandleWifiProSwitchChanged(msg); + break; + case EVENT_REMOVE_BLOCK_LIST: + HandleRemoveBlockList(msg); + break; + default: + return false; + } + return true; +} + +void WifiProStateMachine::DefaultState::HandleRemoveBlockList(const InternalMessagePtr msg) +{ + if (msg == nullptr) { + WIFI_LOGE("HandleRemoveBlockList: msg is nullptr."); + return; + } + + std::string bssid; + msg->GetMessageObj(bssid); + NetworkBlockListManager::GetInstance().RemoveWifiBlocklist(bssid); +} + +void WifiProStateMachine::DefaultState::HandleWifiProSwitchChanged(const InternalMessagePtr msg) +{ + // the wifiPro switch is on by default + pWifiProStateMachine_->isWifiProEnabled_ = true; + WIFI_LOGI("state transition: DefaultState -> WifiProEnableState."); + pWifiProStateMachine_->SwitchState(pWifiProStateMachine_->pWifiProEnableState_); +} + +/* --------------------------- state machine enbale state ------------------------------ */ +WifiProStateMachine::WifiProEnableState::WifiProEnableState(WifiProStateMachine *pWifiProStateMachine) + : State("WifiProEnableState"), + pWifiProStateMachine_(pWifiProStateMachine) +{ + WIFI_LOGD("Enter WifiProEnableState."); +} + +WifiProStateMachine::WifiProEnableState::~WifiProEnableState() +{ + WIFI_LOGD("Enter ~WifiProEnableState."); +} + +void WifiProStateMachine::WifiProEnableState::GoInState() +{ + WIFI_LOGI("WifiProEnableState GoInState function."); + pWifiProStateMachine_->isWifiNoInternet_ = false; + TransitionNetState(); +} + +void WifiProStateMachine::WifiProEnableState::GoOutState() +{ + WIFI_LOGI("WifiProEnableState GoOutState function."); +} + +bool WifiProStateMachine::WifiProEnableState::ExecuteStateMsg(InternalMessagePtr msg) +{ + if (msg == nullptr) { + return false; + } + + WIFI_LOGD("WifiProEnableState-msgCode=%{public}d is received.", msg->GetMessageName()); + switch (msg->GetMessageName()) { + case EVENT_WIFI_CONNECT_STATE_CHANGED: + HandleWifiConnectStateChangedInEnableState(msg); + break; + default: + return false; + } + return true; +} + +void WifiProStateMachine::WifiProEnableState::TransitionNetState() +{ + if (WifiProUtils::IsWifiConnected(pWifiProStateMachine_->instId_)) { + WIFI_LOGI("state transition: WifiProEnableState -> WifiConnectedState."); + pWifiProStateMachine_->SwitchState(pWifiProStateMachine_->pWifiConnectedState_); + } else { + WIFI_LOGI("state transition: WifiProEnableState -> WifiDisConnectedStat."); + pWifiProStateMachine_->SwitchState(pWifiProStateMachine_->pWifiDisConnectedState_); + } +} + +void WifiProStateMachine::WifiProEnableState::HandleWifiConnectStateChangedInEnableState(const InternalMessagePtr msg) +{ + int32_t state = msg->GetParam1(); + if (state == static_cast(OperateResState::CONNECT_AP_CONNECTED)) { + WIFI_LOGI("state transition: WifiProEnableState -> WifiConnectedState."); + pWifiProStateMachine_->SwitchState(pWifiProStateMachine_->pWifiConnectedState_); + } else if (state == static_cast(OperateResState::DISCONNECT_DISCONNECTED)) { + WIFI_LOGI("state transition: WifiProEnableState -> WifiDisConnectedStat."); + pWifiProStateMachine_->SwitchState(pWifiProStateMachine_->pWifiDisConnectedState_); + } else { + return; + } +} + +/* --------------------------- state machine disbaled state ------------------------------ */ +WifiProStateMachine::WifiProDisabledState::WifiProDisabledState(WifiProStateMachine *pWifiProStateMachine) + : State("WifiProDisabledState"), + pWifiProStateMachine_(pWifiProStateMachine) +{ + WIFI_LOGD("WifiProDisabledState construct success."); +} + +WifiProStateMachine::WifiProDisabledState::~WifiProDisabledState() {} + +void WifiProStateMachine::WifiProDisabledState::GoInState() +{ + WIFI_LOGI("WifiProDisabledState GoInState function."); +} + +void WifiProStateMachine::WifiProDisabledState::GoOutState() +{ + WIFI_LOGI("WifiProDisabledState GoOutState function."); +} + +bool WifiProStateMachine::WifiProDisabledState::ExecuteStateMsg(InternalMessagePtr msg) +{ + if (msg == nullptr) { + return false; + } + WIFI_LOGD("WifiProDisabledState-msgCode=%{public}d is received.", msg->GetMessageName()); + switch (msg->GetMessageName()) { + case EVENT_NOTIFY_WIFI_PRO_SWITCH_CHANGED: + HandleWifiProSwitchChanged(msg); + break; + default: + return false; + } + return true; +} + +void WifiProStateMachine::WifiProDisabledState::HandleWifiProSwitchChanged(const InternalMessagePtr msg) +{ + pWifiProStateMachine_->isWifiProEnabled_ = static_cast(msg->GetParam1()); + if (pWifiProStateMachine_->isWifiProEnabled_) { + WIFI_LOGI("state transition: WifiProDisabledState -> WifiProEnableState."); + pWifiProStateMachine_->SwitchState(pWifiProStateMachine_->pWifiProEnableState_); + } +} + +/* --------------------------- state machine connected state ------------------------------ */ +WifiProStateMachine::WifiConnectedState::WifiConnectedState(WifiProStateMachine *pWifiProStateMachine) + : State("WifiConnectedState"), + pWifiProStateMachine_(pWifiProStateMachine) +{ + WIFI_LOGD("WifiConnectedState construct success."); +} + +WifiProStateMachine::WifiConnectedState::~WifiConnectedState() {} + +void WifiProStateMachine::WifiConnectedState::GoInState() +{ + WIFI_LOGI("WifiConnectedState GoInState function."); + pWifiProStateMachine_->RefreshConnectedNetWork(); + WifiLinkedInfo linkedInfo; + WifiConfigCenter::GetInstance().GetLinkedInfo(linkedInfo); + auto &networkBlackListManager = NetworkBlockListManager::GetInstance(); + if (networkBlackListManager.IsInTempWifiBlockList(linkedInfo.bssid)) { + networkBlackListManager.CleanTempWifiBlockList(); + } + InitConnectedState(); +} + +void WifiProStateMachine::WifiConnectedState::GoOutState() +{ + WIFI_LOGI("WifiConnectedState GoOutState function."); + return; +} + +bool WifiProStateMachine::WifiConnectedState::ExecuteStateMsg(InternalMessagePtr msg) +{ + if (msg == nullptr) { + return false; + } + WIFI_LOGD("WifiConnectedState-msgCode=%{public}d is received.", msg->GetMessageName()); + switch (msg->GetMessageName()) { + case EVENT_CHECK_WIFI_INTERNET_RESULT: + HandleCheckWifiInternetResultWithConnected(msg); + break; + default: + return false; + } + return true; +} + +void WifiProStateMachine::WifiConnectedState::InitConnectedState() +{ + if (pWifiProStateMachine_->duanBandHandoverType_ == ROAM_SCENE) { + pWifiProStateMachine_->duanBandHandoverType_ = 0; + } else { + pWifiProStateMachine_->isWifiNoInternet_ = false; + } +} + +void WifiProStateMachine::WifiConnectedState::HandleCheckWifiInternetResultWithConnected(const InternalMessagePtr msg) +{ + int32_t state = msg->GetParam1(); + WIFI_LOGI("Enter HandleCheckWifiInternetResultWithConnected, state:%{public}d.", state); + if (state == static_cast(OperateResState::CONNECT_NETWORK_DISABLED)) { + HandleWifiInternetResultWithNoInet(state); + } else if (state == static_cast(OperateResState::CONNECT_CHECK_PORTAL)) { + HandleWifiInternetResultWithPortal(state); + } else { + HandleWifiInternetResultWithInet(state); + } +} + +void WifiProStateMachine::WifiConnectedState::HandleWifiInternetResultWithInet(int32_t state) +{ + pWifiProStateMachine_->isWifiNoInternet_ = false; + UpdateWifiAgentScore(state); +} + +void WifiProStateMachine::WifiConnectedState::UpdateWifiAgentScore(int32_t state) +{ + if (!pWifiProStateMachine_->disconnectToConnectedState_) { + if (state == static_cast(OperateResState::CONNECT_NETWORK_DISABLED)) { + WIFI_LOGI("UpdateWifiAgentScore, wifi network has no internet."); + } else if (state == static_cast(OperateResState::CONNECT_CHECK_PORTAL)) { + WIFI_LOGI("UpdateWifiAgentScore, wifi network is portal."); + } else { + WIFI_LOGI("state transition: WifiConnectedState -> WifiLinkMonitorState."); + pWifiProStateMachine_->SwitchState(pWifiProStateMachine_->pWifiLinkMonitorState_); + } + return; + } + + pWifiProStateMachine_->disconnectToConnectedState_ = false; +} + +void WifiProStateMachine::WifiConnectedState::HandleWifiInternetResultWithPortal(int32_t state) +{ + // portal scene + WIFI_LOGI("Enter HandleWifiInternetResultWithPortal."); +} + +void WifiProStateMachine::WifiConnectedState::HandleWifiInternetResultWithNoInet(int32_t state) +{ + // no internet scene + WIFI_LOGI("Enter HandleWifiInternetResultWithNoInet."); + pWifiProStateMachine_->isWifiNoInternet_ = true; + UpdateWifiAgentScore(state); +} + +/* --------------------------- state machine disconnected state ------------------------------ */ +WifiProStateMachine::WifiDisConnectedState::WifiDisConnectedState(WifiProStateMachine *pWifiProStateMachine) + : State("WifiDisConnectedState"), + pWifiProStateMachine_(pWifiProStateMachine) +{ + WIFI_LOGD("WifiDisConnectedState construct success."); +} + +WifiProStateMachine::WifiDisConnectedState::~WifiDisConnectedState() {} + +void WifiProStateMachine::WifiDisConnectedState::GoInState() +{ + WIFI_LOGI("WifiDisConnectedState GoInState function."); +} + +void WifiProStateMachine::WifiDisConnectedState::GoOutState() +{ + WIFI_LOGI("WifiDisConnectedState GoOutState function."); +} + +bool WifiProStateMachine::WifiDisConnectedState::ExecuteStateMsg(InternalMessagePtr msg) +{ + if (msg == nullptr) { + return false; + } + WIFI_LOGD("WifiDisConnectedState-msgCode=%{public}d is received.", msg->GetMessageName()); + switch (msg->GetMessageName()) { + case EVENT_WIFI_CONNECT_STATE_CHANGED: + HandleWifiConnectStateChangedInDisConnectedState(msg); + break; + default: + return false; + } + return true; +} + +void WifiProStateMachine::WifiDisConnectedState::HandleWifiConnectStateChangedInDisConnectedState( + const InternalMessagePtr msg) +{ + WIFI_LOGD("Enter HandleWifiConnectStateChangedInDisConnectedState."); + int32_t state = msg->GetParam1(); + if (state == static_cast(OperateResState::CONNECT_AP_CONNECTED)) { + WIFI_LOGI("state transition: WifiDisConnectedState -> WifiConnectedState."); + pWifiProStateMachine_->SwitchState(pWifiProStateMachine_->pWifiConnectedState_); + } +} + +/* --------------------------- state machine link monitor state ------------------------------ */ +WifiProStateMachine::WifiLinkMonitorState::WifiLinkMonitorState(WifiProStateMachine *pWifiProStateMachine) + : State("WifiLinkMonitorState"), + pWifiProStateMachine_(pWifiProStateMachine) +{ + WIFI_LOGD("WifiLinkMonitorState construct success."); +} + +WifiProStateMachine::WifiLinkMonitorState::~WifiLinkMonitorState() {} + +void WifiProStateMachine::WifiLinkMonitorState::GoInState() +{ + WIFI_LOGI("WifiLinkMonitorState GoInState function."); + WifiLinkMonitorStateInit(); +} + +void WifiProStateMachine::WifiLinkMonitorState::WifiLinkMonitorStateInit() +{ + rssiLevel0Or1ScanedCounter_ = 0; + rssiLevel2Or3ScanedCounter_ = 0; + isScanTriggered_ = false; + isWifi2WifiSwitching_ = false; + targetBssid_ = ""; +} + +void WifiProStateMachine::WifiLinkMonitorState::GoOutState() +{ + WIFI_LOGI("WifiLinkMonitorState GoOutState function."); + return; +} + +bool WifiProStateMachine::WifiLinkMonitorState::ExecuteStateMsg(InternalMessagePtr msg) +{ + if (msg == nullptr) { + return false; + } + WIFI_LOGD("WifiLinkMonitorState-msgCode=%{public}d is received.", msg->GetMessageName()); + switch (msg->GetMessageName()) { + case EVENT_WIFI_RSSI_CHANGED: + HandleRssiChangedInMonitor(msg); + break; + case EVENT_WIFI_CONNECT_STATE_CHANGED: + HandleConnectStateChangedInMonitor(msg); + break; + case EVENT_REQUEST_SCAN_DELAY: + HandleReuqestScanInMonitor(msg); + break; + case EVENT_HANDLE_SCAN_RESULT: + HandleScanResultInMonitor(msg); + break; + case EVENT_CHECK_WIFI_INTERNET_RESULT: + HandleHttpResultInLinkMonitorState(msg); + break; + case EVENT_WIFI2WIFI_FAILED: + HandleWifi2WifiFailed(false); + break; + default: + return false; + } + return true; +} + +void WifiProStateMachine::WifiLinkMonitorState::HandleHttpResultInLinkMonitorState(const InternalMessagePtr msg) +{ + int32_t operateResState = msg->GetParam1(); + bool isWifiNoInternet = (operateResState != static_cast(OperateResState::CONNECT_NETWORK_ENABLED)); + if (isWifiNoInternet) { + pWifiProStateMachine_->isWifiNoInternet_ = true; + } else { + pWifiProStateMachine_->isWifiNoInternet_ = false; + } +} + +void WifiProStateMachine::WifiLinkMonitorState::HandleRssiChangedInMonitor(const InternalMessagePtr msg) +{ + pWifiProStateMachine_->currentRssi_ = msg->GetParam1(); + if ((isWifi2WifiSwitching_) || (pWifiProStateMachine_->isWifiNoInternet_)) { + WIFI_LOGI("MonitorState, isWifi2WifiSwitching:%{public}d,isWifiNoInternet:%{public}d.", + isWifi2WifiSwitching_, pWifiProStateMachine_->isWifiNoInternet_); + return; + } + + int32_t signalLevel = WifiProUtils::GetSignalLevel(pWifiProStateMachine_->instId_); + WIFI_LOGI("MonitorState, signalLevel:%{public}d.", signalLevel); + bool hasSwitchRecord = pWifiProStateMachine_->HasWifiSwitchRecord(); + if (signalLevel == SIG_LEVEL_4 && hasSwitchRecord) { + rssiLevel2Or3ScanedCounter_ = 0; + rssiLevel0Or1ScanedCounter_ = 0; + } + + if (!pWifiProStateMachine_->IsReachWifiScanThreshold(signalLevel)) { + WIFI_LOGI("HandleRssiChangedInMonitor, StopTimer EVENT_REQUEST_SCAN_DELAY."); + pWifiProStateMachine_->StopTimer(EVENT_REQUEST_SCAN_DELAY); + return; + } + + if (!IsSatisfiedWifiOperationCondition()) { + return; + } + + pWifiProStateMachine_->StopTimer(EVENT_REQUEST_SCAN_DELAY); + pWifiProStateMachine_->SendMessage(EVENT_REQUEST_SCAN_DELAY, static_cast(hasSwitchRecord)); +} + +void WifiProStateMachine::WifiLinkMonitorState::HandleReuqestScanInMonitor(const InternalMessagePtr msg) +{ + if (msg == nullptr) { + WIFI_LOGI("HandleReuqestScanInMonitor, msg is nullptr."); + return; + } + + // selfcure onging, pending scan for 10s + ISelfCureService *pSelfCureService = + WifiServiceManager::GetInstance().GetSelfCureServiceInst(pWifiProStateMachine_->instId_); + bool hasSwitchRecord = static_cast(msg->GetParam1()); + if (pSelfCureService != nullptr && pSelfCureService->IsSelfCureOnGoing()) { + WIFI_LOGI("HandleReuqestScanInMonitor: self cure is ongoing."); + pWifiProStateMachine_->StopTimer(EVENT_REQUEST_SCAN_DELAY); + pWifiProStateMachine_->MessageExecutedLater(EVENT_REQUEST_SCAN_DELAY, hasSwitchRecord, DEFAULT_SCAN_INTERVAL); + return; + } + + int32_t signalLevel = WifiProUtils::GetSignalLevel(pWifiProStateMachine_->instId_); + if (!pWifiProStateMachine_->IsReachWifiScanThreshold(signalLevel)) { + return; + } + + if (WifiProUtils::IsUserSelectNetwork() && signalLevel == SIG_LEVEL_2) { + WIFI_LOGI("HandleReuqestScanInMonitor, user select network and signal = 2."); + return; + } + + TryStartScan(hasSwitchRecord, signalLevel); +} + +void WifiProStateMachine::WifiLinkMonitorState::TryStartScan(bool hasSwitchRecord, int32_t signalLevel) +{ + // calculate the interval and the max scan counter. + IScanService *pScanService = WifiServiceManager::GetInstance().GetScanServiceInst(pWifiProStateMachine_->instId_); + if (pScanService == nullptr) { + WIFI_LOGI("TryStartScan, pService is nullptr."); + return; + } + + int32_t scanInterval = WifiProUtils::GetScanInterval(hasSwitchRecord, signalLevel); + int32_t scanMaxCounter = WifiProUtils::GetMaxCounter(hasSwitchRecord, signalLevel); + if ((signalLevel == SIG_LEVEL_2 || signalLevel == SIG_LEVEL_3) && + rssiLevel2Or3ScanedCounter_ < scanMaxCounter) { + WIFI_LOGI("TryStartScan, start scan, signalLevel:%{public}d," + "rssiLevel2Or3ScanedCounter:%{public}d.", signalLevel, rssiLevel2Or3ScanedCounter_); + rssiLevel2Or3ScanedCounter_++; + pScanService->Scan(true); + isScanTriggered_ = true; + pWifiProStateMachine_->MessageExecutedLater(EVENT_REQUEST_SCAN_DELAY, hasSwitchRecord, scanInterval); + } else if ((signalLevel < SIG_LEVEL_2) && (rssiLevel0Or1ScanedCounter_ < scanMaxCounter)) { + WIFI_LOGI("TryStartScan, start scan, signalLevel:%{public}d," + "rssiLevel0Or1ScanedCounter:%{public}d.", signalLevel, rssiLevel0Or1ScanedCounter_); + rssiLevel0Or1ScanedCounter_++; + pScanService->Scan(true); + isScanTriggered_ = true; + pWifiProStateMachine_->MessageExecutedLater(EVENT_REQUEST_SCAN_DELAY, hasSwitchRecord, scanInterval); + } else { + WIFI_LOGI("TryStartScan, do not scan, signalLevel:%{public}d,scanMaxCounter:%{public}d.", + signalLevel, scanMaxCounter); + } +} + +void WifiProStateMachine::WifiLinkMonitorState::HandleScanResultInMonitor(const InternalMessagePtr msg) +{ + if (msg == nullptr) { + WIFI_LOGI("HandleScanResultInMonitor, msg is nullptr."); + return; + } + + std::vector scanInfos; + msg->GetMessageObj(scanInfos); + + if (!isScanTriggered_) { + WIFI_LOGI("HandleScanResultInMonitor, scan is not triggered, skip network selection."); + return; + } + + WIFI_LOGI("start to wifi2wifi select network."); + std::unique_ptr pNetworkSelectionManager = std::make_unique(); + NetworkSelectionResult networkSelectionResult; + if (pNetworkSelectionManager->SelectNetwork(networkSelectionResult, NetworkSelectType::WIFI2WIFI, scanInfos)) { + int32_t networkId = networkSelectionResult.wifiDeviceConfig.networkId; + std::string &bssid = networkSelectionResult.interScanInfo.bssid; + std::string &ssid = networkSelectionResult.interScanInfo.ssid; + WIFI_LOGI("Wifi2Wifi select network result networkId: %{public}d, ssid: %{public}s, bssid: %{public}s.", + networkId, SsidAnonymize(ssid).c_str(), MacAnonymize(bssid).c_str()); + targetBssid_ = networkSelectionResult.interScanInfo.bssid; + isScanTriggered_ = false; + HandleCheckResultInMonitor(networkSelectionResult); + } else { + WIFI_LOGI("wifi to wifi step X: Wifi2Wifi select network fail."); + Wifi2WifiFailed(); + } +} + +bool WifiProStateMachine::WifiLinkMonitorState::IsSatisfiedWifiOperationCondition() +{ + if (pWifiProStateMachine_->isWifiNoInternet_) { + WIFI_LOGI("IsSatisfiedWifiOperationCondition, wifi no internet."); + return false; + } + + if (isWifi2WifiSwitching_) { + WIFI_LOGI("IsSatisfiedWifiOperationCondition, wifi2Wifi is processing."); + return false; + } + + ISelfCureService *pSelfCureService = + WifiServiceManager::GetInstance().GetSelfCureServiceInst(pWifiProStateMachine_->instId_); + if (pSelfCureService != nullptr && pSelfCureService->IsSelfCureOnGoing()) { + WIFI_LOGI("IsSatisfiedWifiOperationCondition, self cure ongoing."); + return false; + } + + return true; +} + +void WifiProStateMachine::WifiLinkMonitorState::HandleConnectStateChangedInMonitor( + const InternalMessagePtr msg) +{ + if (msg == nullptr) { + WIFI_LOGI("HandleConnectStateChangedInMonitor, msg is nullptr."); + return; + } + + WIFI_LOGI("receive wifi2wifi Result,isWifi2WifiSwitching = %{public}d.", isWifi2WifiSwitching_); + int32_t state = msg->GetParam1(); + std::string bssid; + msg->GetMessageObj(bssid); + if (state == static_cast(OperateResState::CONNECT_AP_CONNECTED)) { + if (!isWifi2WifiSwitching_) { + return; + } + + if (targetBssid_ != bssid) { + WIFI_LOGI("selected bssid and switched bssid are not same:selected bssid:%{public}s," + "switched bssid:%{public}s,", + MacAnonymize(targetBssid_).c_str(), MacAnonymize(bssid).c_str()); + NetworkBlockListManager::GetInstance().AddWifiBlocklist(bssid); + pWifiProStateMachine_->MessageExecutedLater(EVENT_REMOVE_BLOCK_LIST, bssid, BLOCKLIST_VALID_TIME); + HandleWifi2WifiFailed(true); + } else { + HandleWifi2WifiSucsess(); + } + } else if (state == static_cast(OperateResState::DISCONNECT_DISCONNECTED)) { + WIFI_LOGI("Monitor State, network disconnected"); + if (!isWifi2WifiSwitching_) { + pWifiProStateMachine_->SwitchState(pWifiProStateMachine_->pWifiDisConnectedState_); + } + } else { + return; + } +} + +void WifiProStateMachine::WifiLinkMonitorState::HandleWifi2WifiSucsess() +{ + WIFI_LOGI("Enter HandleWifi2WifiSucsess"); + auto &networkBlackListManager = NetworkBlockListManager::GetInstance(); + networkBlackListManager.AddWifiBlocklist(pWifiProStateMachine_->badBssid_); + pWifiProStateMachine_->MessageExecutedLater(EVENT_REMOVE_BLOCK_LIST, pWifiProStateMachine_->badBssid_, + BLOCKLIST_VALID_TIME); + networkBlackListManager.CleanTempWifiBlockList(); + pWifiProStateMachine_->RefreshConnectedNetWork(); + isWifi2WifiSwitching_ = false; + WIFI_LOGI("state transition: WifiLinkMonitorState -> WifiConnectedState."); + pWifiProStateMachine_->SwitchState(pWifiProStateMachine_->pWifiConnectedState_); +} + +void WifiProStateMachine::WifiLinkMonitorState::HandleWifi2WifiFailed(bool isConnected) +{ + WIFI_LOGI("wifi to wifi step X: wifi to Wifi Failed Finally."); + auto &networkBlackListManager = NetworkBlockListManager::GetInstance(); + if (networkBlackListManager.IsFailedMultiTimes(targetBssid_)) { + WIFI_LOGI("HandleWifi2WifiFailed, add to abnormal black list:%{public}s.", + MacAnonymize(targetBssid_).c_str()); + networkBlackListManager.AddAbnormalWifiBlocklist(targetBssid_); + networkBlackListManager.CleanTempWifiBlockList(); + } + isWifi2WifiSwitching_ = false; + isScanTriggered_ = false; + pWifiProStateMachine_->badBssid_ = ""; + targetBssid_ = ""; + if (isConnected) { + pWifiProStateMachine_->SwitchState(pWifiProStateMachine_->pWifiConnectedState_); + } else { + pWifiProStateMachine_->SwitchState(pWifiProStateMachine_->pWifiDisConnectedState_); + } +} + +void WifiProStateMachine::WifiLinkMonitorState::HandleCheckResultInMonitor( + const NetworkSelectionResult &networkSelectionResult) +{ + WIFI_LOGI("wifi to wifi step 2: receive good ap in monitor state."); + if (!IsSatisfiedWifiOperationCondition()) { + WIFI_LOGI("wifi to wifi step 3: target AP is not reach handover threshold."); + return; + } + + // rssi conditions and Wifi2WifiThreshold conditions have been considered when selecting a network. + WIFI_LOGI("wifi to wifi step 3: target AP reach handover threshold."); + // User preference is not considered for now + TryWifiHandoverPreferentially(networkSelectionResult); +} + +void WifiProStateMachine::WifiLinkMonitorState::TryWifiHandoverPreferentially( + const NetworkSelectionResult &networkSelectionResult) +{ + int32_t signalLevel = WifiProUtils::GetSignalLevel(pWifiProStateMachine_->instId_); + if (!pWifiProStateMachine_->IsReachWifiScanThreshold(signalLevel)) { + WIFI_LOGI("TryWifiHandoverPreferentially, do not reach wifi scan threshold."); + return; + } + + // Non-default network does not switch + if (!WifiProUtils::IsDefaultNet()) { + WIFI_LOGI("TryWifiHandoverPreferentially, not default network, do not switch wifi."); + return; + } + + WIFI_LOGW("try wifi --> wifi only, current rssi:%{public}d.", signalLevel); + TryWifiRoveOut(networkSelectionResult); +} + +void WifiProStateMachine::WifiLinkMonitorState::TryWifiRoveOut(const NetworkSelectionResult &networkSelectionResult) +{ + WIFI_LOGI("wifi to wifi step 4: try wifi Rove Out."); + if (pWifiProStateMachine_->IsKeepCurrWifiConnected()) { + return; + } + + HandleWifiRoveOut(networkSelectionResult); +} + +void WifiProStateMachine::WifiLinkMonitorState::HandleWifiRoveOut(const NetworkSelectionResult &networkSelectionResult) +{ + bool isCallingInCs = IsCallingInCs(); + if ((isDisableWifiAutoSwitch_) || isCallingInCs) { + WIFI_LOGW("isDisableWifiAutoSwitch:%{public}d, isCallingInCs:%{public}d.", + isDisableWifiAutoSwitch_, isCallingInCs); + return; + } + + TryWifi2Wifi(networkSelectionResult); +} + +void WifiProStateMachine::WifiLinkMonitorState::TryWifi2Wifi(const NetworkSelectionResult &networkSelectionResult) +{ + pWifiProStateMachine_->badBssid_ = pWifiProStateMachine_->currentBssid_; + pWifiProStateMachine_->badSsid_ = pWifiProStateMachine_->currentSsid_; + pWifiProStateMachine_->StopTimer(EVENT_REQUEST_SCAN_DELAY); + + if (pWifiProStateMachine_->isWifiNoInternet_) { + pWifiProStateMachine_->wifiSwitchReason_ = WIFI_SWITCH_REASON_NO_INTERNET; + } else { + pWifiProStateMachine_->wifiSwitchReason_ = WIFI_SWITCH_REASON_POOR_RSSI; + } + + if (!HandleWifiToWifi(pWifiProStateMachine_->wifiSwitchReason_, networkSelectionResult)) { + WIFI_LOGI("wifi to wifi step X: HandleWifiToWifi Failed."); + Wifi2WifiFailed(); + } +} + +void WifiProStateMachine::WifiLinkMonitorState::Wifi2WifiFailed() +{ + isWifi2WifiSwitching_ = false; + isScanTriggered_ = false; + pWifiProStateMachine_->badBssid_ = ""; + targetBssid_ = ""; +} + +bool WifiProStateMachine::WifiLinkMonitorState::HandleWifiToWifi(int32_t switchReason, + const NetworkSelectionResult &networkSelectionResult) +{ + WIFI_LOGI("wifi to wifi step 5: handle wifi2wifi command."); + if (switchReason == WIFI_SWITCH_REASON_POOR_RSSI) { + WIFI_LOGI("wifi to wifi step 5.5: direct wifi 2 wifi handover."); + UpdateWifiSwitchTimeStamp(); + return TrySwitchWifiNetwork(networkSelectionResult); + } + + return true; +} + +void WifiProStateMachine::WifiLinkMonitorState::UpdateWifiSwitchTimeStamp() +{ + int64_t now = WifiProUtils::GetCurrentTimeMs(); + WifiLinkedInfo linkedInfo; + WifiDeviceConfig config; + WifiConfigCenter::GetInstance().GetLinkedInfo(linkedInfo); + if (WifiSettings::GetInstance().GetDeviceConfig(linkedInfo.networkId, config) == 0) { + config.lastTrySwitchWifiTimestamp = now; + WifiSettings::GetInstance().AddDeviceConfig(config); + WifiSettings::GetInstance().SyncDeviceConfig(); + } else { + WIFI_LOGI("UpdateWifiSwitchTimeStamp, get device config failed"); + } +} + +bool WifiProStateMachine::WifiLinkMonitorState::TrySwitchWifiNetwork( + const NetworkSelectionResult &networkSelectionResult) +{ + int32_t networkId = networkSelectionResult.wifiDeviceConfig.networkId; + WIFI_LOGI("wifi to wifi step 7: start to connect to new wifi. networkId:%{public}d", networkId); + IStaService *pStaService = WifiServiceManager::GetInstance().GetStaServiceInst(pWifiProStateMachine_->instId_); + if (pStaService == nullptr) { + WIFI_LOGE("TrySwitchWifiNetwork, pStaService is invalid"); + return false; + } + isWifi2WifiSwitching_ = true; + if (pStaService->ConnectToNetwork(networkId, NETWORK_SELECTED_BY_AUTO) != WIFI_OPT_SUCCESS) { + WIFI_LOGE("TrySwitchWifiNetwork, ConnectToNetwork failed."); + return false; + } + + return true; +} + +bool WifiProStateMachine::WifiLinkMonitorState::IsCallingInCs() +{ + return false; +} + +bool WifiProStateMachine::WifiLinkMonitorState::IsFullscreen() +{ + return false; +} +} // namespace Wifi +} // namespace OHOS \ No newline at end of file diff --git a/wifi/services/wifi_standard/wifi_framework/wifi_manage/wifi_pro/wifi_pro_state_machine.h b/wifi/services/wifi_standard/wifi_framework/wifi_manage/wifi_pro/wifi_pro_state_machine.h new file mode 100644 index 000000000..127de7677 --- /dev/null +++ b/wifi/services/wifi_standard/wifi_framework/wifi_manage/wifi_pro/wifi_pro_state_machine.h @@ -0,0 +1,230 @@ +/* + * Copyright (C) 2024-2024 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_PRO_STATE_MACHINE_H +#define OHOS_WIFI_PRO_STATE_MACHINE_H + +#include "define.h" +#include "wifi_log.h" +#include "wifi_errcode.h" +#include "state_machine.h" +#include "wifi_pro_common.h" +#include "network_selection_manager.h" + +namespace OHOS { +namespace Wifi { +class WifiProStateMachine : public StateMachine { + FRIEND_GTEST(WifiProStateMachine); + +public: + explicit WifiProStateMachine(int32_t instId = 0); + ~WifiProStateMachine(); + + /** + * @Description Definition of DefaultState class in WifiProStateMachine. + * + */ + class DefaultState : public State { + public: + explicit DefaultState(WifiProStateMachine *pWifiProStateMachine); + ~DefaultState() override; + void GoInState() override; + void GoOutState() override; + bool ExecuteStateMsg(InternalMessagePtr msg) override; + private: + WifiProStateMachine *pWifiProStateMachine_ { nullptr }; + void HandleWifiProSwitchChanged(const InternalMessagePtr msg); + void HandleRemoveBlockList(const InternalMessagePtr msg); + }; + + /** + * @Description Definition of WifiProEnableState class in WifiProStateMachine. + * + */ + class WifiProEnableState : public State { + public: + explicit WifiProEnableState(WifiProStateMachine *pWifiProStateMachine); + ~WifiProEnableState() override; + void GoInState() override; + void GoOutState() override; + bool ExecuteStateMsg(InternalMessagePtr msg) override; + private: + WifiProStateMachine *pWifiProStateMachine_ { nullptr }; + void TransitionNetState(); + void HandleWifiConnectStateChangedInEnableState(const InternalMessagePtr msg); + }; + + /** + * @Description Definition of WifiProDisabledState class in WifiProStateMachine. + * + */ + class WifiProDisabledState : public State { + public: + explicit WifiProDisabledState(WifiProStateMachine *pWifiProStateMachine); + ~WifiProDisabledState() override; + void GoInState() override; + void GoOutState() override; + bool ExecuteStateMsg(InternalMessagePtr msg) override; + private: + WifiProStateMachine *pWifiProStateMachine_ { nullptr}; + void HandleWifiProSwitchChanged(const InternalMessagePtr msg); + }; + + /** + * @Description Definition of WifiConnectedState class in WifiProStateMachine. + * + */ + class WifiConnectedState : public State { + public: + explicit WifiConnectedState(WifiProStateMachine *pWifiProStateMachine); + ~WifiConnectedState() override; + void GoInState() override; + void GoOutState() override; + bool ExecuteStateMsg(InternalMessagePtr msg) override; + private: + WifiProStateMachine *pWifiProStateMachine_ { nullptr }; + int32_t internetFailureDetectedCount_ { 0 }; + void InitConnectedState(); + void HandleCheckWifiInternetResultWithConnected(const InternalMessagePtr msg); + void HandleWifiInternetResultInLinkMonitorState(); + void HandleWifiInternetResultWithNoInet(int32_t state); + void HandleWifiInternetResultWithPortal(int32_t state); + void HandleWifiInternetResultWithInet(int32_t state); + void UpdateWifiAgentScore(int32_t state); + }; + + /** + * @Description Definition of WifiDisConnectedState class in WifiProStateMachine. + * + */ + class WifiDisConnectedState : public State { + public: + explicit WifiDisConnectedState(WifiProStateMachine *pWifiProStateMachine); + ~WifiDisConnectedState() override; + void GoInState() override; + void GoOutState() override; + bool ExecuteStateMsg(InternalMessagePtr msg) override; + private: + WifiProStateMachine *pWifiProStateMachine_ { nullptr }; + void HandleWifiConnectStateChangedInDisConnectedState(const InternalMessagePtr msg); + }; + + /** + * @Description Definition of WifiLinkMonitorState class in WifiProStateMachine. + * + */ + class WifiLinkMonitorState : public State { + public: + explicit WifiLinkMonitorState(WifiProStateMachine *pWifiProStateMachine); + ~WifiLinkMonitorState() override; + void GoInState() override; + void GoOutState() override; + bool ExecuteStateMsg(InternalMessagePtr msg) override; + private: + WifiProStateMachine *pWifiProStateMachine_ { nullptr}; + bool isScanTriggered_ { false }; + bool isWifi2WifiSwitching_ { false }; + bool isDisableWifiAutoSwitch_ { false }; + int32_t rssiLevel2Or3ScanedCounter_ { 0 }; + int32_t rssiLevel0Or1ScanedCounter_ { 0 }; + std::string targetBssid_; + NetworkSelectionResult networkSelectionResult_; + void WifiLinkMonitorStateInit(); + void HandleCheckResultInMonitor(const NetworkSelectionResult &networkSelectionResult); + bool IsSatisfiedWifiOperationCondition(); + bool IsFullscreen(); + void TryWifiHandoverPreferentially(const NetworkSelectionResult &networkSelectionResult); + void TryWifiRoveOut(const NetworkSelectionResult &networkSelectionResult); + void HandleWifiRoveOut(const NetworkSelectionResult &networkSelectionResult); + bool IsCallingInCs(); + void TryWifi2Wifi(const NetworkSelectionResult &networkSelectionResult); + void HandleConnectStateChangedInMonitor(const InternalMessagePtr msg); + void HandleRssiChangedInMonitor(const InternalMessagePtr msg); + void HandleReuqestScanInMonitor(const InternalMessagePtr msg); + void HandleScanResultInMonitor(const InternalMessagePtr msg); + void TryStartScan(bool hasSwitchRecord, int32_t signalLevel); + void HandleHttpResultInLinkMonitorState(const InternalMessagePtr msg); + void HandleWifi2WifiSucsess(); + void HandleWifi2WifiFailed(bool isConnected); + void Wifi2WifiFailed(); + bool HandleWifiToWifi(int32_t switchReason, const NetworkSelectionResult &networkSelectionResult); + void UpdateWifiSwitchTimeStamp(); + bool TrySwitchWifiNetwork(const NetworkSelectionResult &networkSelectionResult); + }; + + ErrCode Initialize(); + +private: + /** + * @Description Destruct state. + * + */ + template + inline void ParsePointer(T *&pointer) + { + if (pointer != nullptr) { + delete pointer; + pointer = nullptr; + } + } + + template + inline ErrCode JudgmentEmpty(T *&pointer) + { + if (pointer == nullptr) { + return WIFI_OPT_FAILED; + } + return WIFI_OPT_SUCCESS; + } + + /** + * @Description Build state tree + * + */ + void BuildStateTree(); + + ErrCode InitWifiProStates(); + +private: + int32_t instId_ { 0 }; + DefaultState *pDefaultState_ { nullptr }; + WifiProEnableState *pWifiProEnableState_ { nullptr }; + WifiProDisabledState *pWifiProDisabledState_ { nullptr }; + WifiConnectedState *pWifiConnectedState_ { nullptr }; + WifiDisConnectedState *pWifiDisConnectedState_ { nullptr }; + WifiLinkMonitorState *pWifiLinkMonitorState_ { nullptr }; + /* 0:unknow 1:singleAP 2:Mixed Type */ + int32_t duanBandHandoverType_ { 0 }; + int32_t wiFiNoInternetReason_ { 0 }; + bool disconnectToConnectedState_ { false }; + bool isWifiProEnabled_ { true }; // enabled by default, it should be assigned according to the settings. + bool isWifiNoInternet_ { false }; + std::string badBssid_ { 0 }; + std::string badSsid_ { 0 }; + int32_t wifiSwitchReason_ { 0 }; + int32_t currentRssi_ { 0 }; + std::string currentBssid_; + std::string currentSsid_; + std::shared_ptr pCurrWifiInfo_ { nullptr }; + std::shared_ptr pCurrWifiDeviceConfig_ { nullptr }; + bool IsKeepCurrWifiConnected(); + bool IsReachWifiScanThreshold(int32_t signalLevel); + bool HasWifiSwitchRecord(); + void RefreshConnectedNetWork(); + bool HasAvailableSsidToSwitch(); +}; +} // namespace Wifi +} // namespace OHOS +#endif \ No newline at end of file diff --git a/wifi/services/wifi_standard/wifi_framework/wifi_manage/wifi_pro/wifi_pro_utils.cpp b/wifi/services/wifi_standard/wifi_framework/wifi_manage/wifi_pro/wifi_pro_utils.cpp new file mode 100644 index 000000000..b8393f96a --- /dev/null +++ b/wifi/services/wifi_standard/wifi_framework/wifi_manage/wifi_pro/wifi_pro_utils.cpp @@ -0,0 +1,98 @@ +/* + * Copyright (C) 2024-2024 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 "net_conn_client.h" +#include "wifi_net_observer.h" +#include "parameters.h" +#include "wifi_config_center.h" +#include "wifi_logger.h" +#include "wifi_msg.h" +#include "wifi_pro_utils.h" + +namespace OHOS { +namespace Wifi { +DEFINE_WIFILOG_LABEL("WifiProUtils"); +int32_t WifiProUtils::GetSignalLevel(int32_t instId) +{ + WifiLinkedInfo linkedInfo; + WifiConfigCenter::GetInstance().GetLinkedInfo(linkedInfo); + return WifiSettings::GetInstance().GetSignalLevel(linkedInfo.rssi, linkedInfo.band, instId); +} + +bool WifiProUtils::IsWifiConnected(int32_t instId) +{ + WifiLinkedInfo linkedInfo; + WifiConfigCenter::GetInstance().GetLinkedInfo(linkedInfo, instId); + return linkedInfo.connState == ConnState::CONNECTED; +} + +int32_t WifiProUtils::GetScanInterval(bool hasWifiSwitchRecord, int32_t rssiLevel) +{ + if (rssiLevel >= SIG_LEVEL_MAX) { + WIFI_LOGI("GetScanInterval, invalid rssiLevel:%{public}d.", rssiLevel); + return 0; + } + + return hasWifiSwitchRecord ? QUICK_SCAN_INTERVAL[rssiLevel] : NORMAL_SCAN_INTERVAL[rssiLevel]; +} + +int32_t WifiProUtils::GetMaxCounter(bool hasWifiSwitchRecord, int32_t rssiLevel) +{ + if (rssiLevel >= SIG_LEVEL_MAX) { + WIFI_LOGI("GetMaxCounter, invalid rssiLevel:%{public}d.", rssiLevel); + return 0; + } + + return hasWifiSwitchRecord ? QUICK_SCAN_MAX_COUNTER[rssiLevel] : NORMAL_SCAN_MAX_COUNTER[rssiLevel]; +} + +int64_t WifiProUtils::GetCurrentTimeMs() +{ + auto timePoint = std::chrono::system_clock::now().time_since_epoch(); + return std::chrono::duration_cast(timePoint).count(); +} + +bool WifiProUtils::IsUserSelectNetwork() +{ + return system::GetParameter("persist.wifi.is_connect_from_user", "") == "1"; +} + +bool WifiProUtils::IsSupplicantConnecting(SupplicantState supplicantState) +{ + return supplicantState == SupplicantState::AUTHENTICATING || + supplicantState == SupplicantState::ASSOCIATING || + supplicantState == SupplicantState::ASSOCIATED || + supplicantState == SupplicantState::FOUR_WAY_HANDSHAKE || + supplicantState == SupplicantState::GROUP_HANDSHAKE || + supplicantState == SupplicantState::COMPLETED; +} + +bool WifiProUtils::IsDefaultNet() +{ + NetManagerStandard::NetHandle defaultNet; + NetManagerStandard::NetConnClient::GetInstance().GetDefaultNet(defaultNet); + NetStateObserver netStateObserver; + int32_t wifiNetId = netStateObserver.GetWifiNetId(); + WIFI_LOGI("IsDefaultNet, default netId:%{public}d, wifiNetId:%{public}d.", defaultNet.GetNetId(), wifiNetId); + return defaultNet.GetNetId() == wifiNetId; +} + +bool WifiProUtils::IsAppInWhiteLists() +{ + return false; +} +} // namespace Wifi +} // namespace OHOS diff --git a/wifi/services/wifi_standard/wifi_framework/wifi_manage/wifi_pro/wifi_pro_utils.h b/wifi/services/wifi_standard/wifi_framework/wifi_manage/wifi_pro/wifi_pro_utils.h new file mode 100644 index 000000000..6ef91a494 --- /dev/null +++ b/wifi/services/wifi_standard/wifi_framework/wifi_manage/wifi_pro/wifi_pro_utils.h @@ -0,0 +1,42 @@ +/* + * Copyright (C) 2024-2024 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_PRO_UTILS_H +#define OHOS_WIFI_PRO_UTILS_H + +#include "wifi_log.h" +#include "wifi_pro_common.h" + +namespace OHOS { +namespace Wifi { +class WifiProUtils { + FRIEND_GTEST(WifiProUtils); +public: + WifiProUtils() = default; + ~WifiProUtils() = default; + static int32_t GetSignalLevel(int32_t instId); + static bool IsWifiConnected(int32_t instId); + static int32_t GetScanInterval(bool hasWifiSwitchRecord, int32_t rssiLevel); + static int32_t GetMaxCounter(bool hasWifiSwitchRecord, int32_t rssiLevel); + static int64_t GetCurrentTimeMs(); + static bool IsUserSelectNetwork(); + static bool IsSupplicantConnecting(SupplicantState supplicantState); + static bool IsDefaultNet(); + static bool IsAppInWhiteLists(); +}; + +} // namespace Wifi +} // namespace OHOS +#endif \ No newline at end of file diff --git a/wifi/services/wifi_standard/wifi_framework/wifi_manage/wifi_self_cure/BUILD.gn b/wifi/services/wifi_standard/wifi_framework/wifi_manage/wifi_self_cure/BUILD.gn index e2b0f00a4..b71a20609 100644 --- a/wifi/services/wifi_standard/wifi_framework/wifi_manage/wifi_self_cure/BUILD.gn +++ b/wifi/services/wifi_standard/wifi_framework/wifi_manage/wifi_self_cure/BUILD.gn @@ -38,6 +38,7 @@ ohos_static_library("wifi_self_cure") { "$WIFI_ROOT_DIR/services/wifi_standard/wifi_framework/wifi_toolkit/config", "$WIFI_ROOT_DIR/services/wifi_standard/wifi_framework/wifi_toolkit/log", "$WIFI_ROOT_DIR/services/wifi_standard/wifi_framework/wifi_manage", + "$WIFI_ROOT_DIR/services/wifi_standard/wifi_framework/wifi_manage/wifi_pro", "$WIFI_ROOT_DIR/services/wifi_standard/wifi_framework/wifi_manage/wifi_sta", "$WIFI_ROOT_DIR/services/wifi_standard/wifi_framework/wifi_manage/wifi_scan", "$WIFI_ROOT_DIR/services/wifi_standard/wifi_framework/wifi_manage/wifi_self_cure", diff --git a/wifi/services/wifi_standard/wifi_framework/wifi_manage/wifi_service_manager.cpp b/wifi/services/wifi_standard/wifi_framework/wifi_manage/wifi_service_manager.cpp index c61465d6d..39ada56cd 100644 --- a/wifi/services/wifi_standard/wifi_framework/wifi_manage/wifi_service_manager.cpp +++ b/wifi/services/wifi_standard/wifi_framework/wifi_manage/wifi_service_manager.cpp @@ -25,6 +25,9 @@ #endif #include "scan_interface.h" #include "sta_interface.h" +#ifdef FEATURE_WIFI_PRO_SUPPORT +#include "wifi_pro_interface.h" +#endif #ifdef FEATURE_SELF_CURE_SUPPORT #include "self_cure_interface.h" #endif @@ -54,6 +57,9 @@ int WifiServiceManager::Init() #ifdef FEATURE_AP_SUPPORT mApServiceHandle.Clear(); #endif +#ifdef FEATURE_WIFI_PRO_SUPPORT + mWifiProServiceHandle.Clear(); +#endif #ifdef FEATURE_SELF_CURE_SUPPORT mSelfCureServiceHandle.Clear(); #endif @@ -128,6 +134,22 @@ int WifiServiceManager::LoadStaService(const std::string &dlname, int instId, bo return 0; } +#ifdef FEATURE_WIFI_PRO_SUPPORT +int32_t WifiServiceManager::LoadWifiProService(bool bCreate, int32_t instId) +{ + WIFI_LOGI("WifiServiceManager::LoadWifiProService"); + std::unique_lock lock(mWifiProMutex); + if (mWifiProServiceHandle.pService[instId]) { + WIFI_LOGI("WifiServiceManager::LoadWifiProService pService is not NULL"); + return 0; + } + IWifiProService *service = new WifiProInterface(); + WIFI_LOGI("WifiServiceManager::LoadWifiProService new pService %{public}d", instId); + mWifiProServiceHandle.pService[instId] = service; + return 0; +} +#endif + #ifdef FEATURE_SELF_CURE_SUPPORT int WifiServiceManager::LoadSelfCureService(const std::string &dlname, bool bCreate) { @@ -214,6 +236,12 @@ int WifiServiceManager::LoadEnhanceService(const std::string &dlname, bool bCrea int WifiServiceManager::CheckAndEnforceService(const std::string &name, int instId, bool bCreate) { WIFI_LOGD("WifiServiceManager::CheckAndEnforceService name: %{public}s", name.c_str()); +#ifdef FEATURE_WIFI_PRO_SUPPORT + if (name == WIFI_SERVICE_WIFIPRO) { + return LoadWifiProService(bCreate, instId); + } +#endif + std::string dlname; if (GetServiceDll(name, dlname) < 0) { WIFI_LOGE("%{public}s does not support", name.c_str()); @@ -260,6 +288,21 @@ IStaService *WifiServiceManager::GetStaServiceInst(int instId) return nullptr; } +#ifdef FEATURE_WIFI_PRO_SUPPORT +IWifiProService *WifiServiceManager::GetWifiProServiceInst(int32_t instId) +{ + WIFI_LOGD("WifiServiceManager::GetWifiProServiceInst, instId: %{public}d", instId); + std::unique_lock lock(mWifiProMutex); + + auto iter = mWifiProServiceHandle.pService.find(instId); + if (iter != mWifiProServiceHandle.pService.end()) { + WIFI_LOGD("find a new WifiPro service instance, instId: %{public}d", instId); + return iter->second; + } + return nullptr; +} +#endif + #ifdef FEATURE_SELF_CURE_SUPPORT ISelfCureService *WifiServiceManager::GetSelfCureServiceInst(int instId) { @@ -343,6 +386,28 @@ IEnhanceService *WifiServiceManager::GetEnhanceServiceInst() #endif } +#ifdef FEATURE_WIFI_PRO_SUPPORT +NO_SANITIZE("cfi") int32_t WifiServiceManager::UnloadWifiProService(bool bPreLoad, int32_t instId) +{ + WIFI_LOGI("WifiServiceManager::UnloadWifiProService, instId: %{public}d", instId); + std::unique_lock lock(mWifiProMutex); + + auto iter = mWifiProServiceHandle.pService.find(instId); + if (iter != mWifiProServiceHandle.pService.end()) { + if (iter->second != nullptr) { + delete iter->second; + iter->second = nullptr; + } + mWifiProServiceHandle.pService.erase(iter); + } + + if (!bPreLoad && mWifiProServiceHandle.pService.empty()) { + mWifiProServiceHandle.Clear(); + } + return 0; +} +#endif + #ifdef FEATURE_SELF_CURE_SUPPORT NO_SANITIZE("cfi") int WifiServiceManager::UnloadSelfCureService(bool bPreLoad, int instId) { @@ -468,6 +533,11 @@ int WifiServiceManager::UnloadService(const std::string &name, int id) if (name == WIFI_SERVICE_STA) { return UnloadStaService(bPreLoad, id); } +#ifdef FEATURE_WIFI_PRO_SUPPORT + if (name == WIFI_SERVICE_WIFIPRO) { + return UnloadWifiProService(bPreLoad, id); + } +#endif #ifdef FEATURE_SELF_CURE_SUPPORT if (name == WIFI_SERVICE_SELFCURE) { return UnloadSelfCureService(bPreLoad, id); @@ -509,6 +579,9 @@ void WifiServiceManager::UninstallAllService() #endif #ifdef FEATURE_SELF_CURE_SUPPORT UnloadSelfCureService(false); +#endif +#ifdef FEATURE_WIFI_PRO_SUPPORT + UnloadWifiProService(false); #endif return; } diff --git a/wifi/services/wifi_standard/wifi_framework/wifi_manage/wifi_service_manager.h b/wifi/services/wifi_standard/wifi_framework/wifi_manage/wifi_service_manager.h index ede21efe6..320b0da2c 100644 --- a/wifi/services/wifi_standard/wifi_framework/wifi_manage/wifi_service_manager.h +++ b/wifi/services/wifi_standard/wifi_framework/wifi_manage/wifi_service_manager.h @@ -32,6 +32,9 @@ #ifdef FEATURE_SELF_CURE_SUPPORT #include "iself_cure_service.h" #endif +#ifdef FEATURE_WIFI_PRO_SUPPORT +#include "iwifi_pro_service.h" +#endif namespace OHOS { namespace Wifi { @@ -47,6 +50,20 @@ struct StaServiceHandle { } }; +#ifdef FEATURE_WIFI_PRO_SUPPORT +struct WifiProServiceHandle { + std::map pService; + WifiProServiceHandle() + {} + ~WifiProServiceHandle() + {} + void Clear() + { + pService.clear(); + } +}; +#endif + #ifdef FEATURE_SELF_CURE_SUPPORT struct SelfCureServiceHandle { std::map pService; @@ -161,6 +178,15 @@ public: ISelfCureService *GetSelfCureServiceInst(int instId = 0); #endif +#ifdef FEATURE_WIFI_PRO_SUPPORT + /** + * @Description Get the WifiPro Service Inst object + * + * @return IWifiProService* - wifi pro service pointer, if wifi pro not supported, nullptr is returned + */ + IWifiProService *GetWifiProServiceInst(int32_t instId); +#endif + /** * @Description Get the Scan Service Inst object * @@ -216,6 +242,10 @@ private: int GetServiceDll(const std::string &name, std::string &dlname); int LoadStaService(const std::string &dlname, int insId, bool bCreate); int UnloadStaService(bool bPreLoad, int instId = 0); +#ifdef FEATURE_WIFI_PRO_SUPPORT + int32_t LoadWifiProService(bool bCreate, int32_t instId = 0); + int32_t UnloadWifiProService(bool bPreLoad, int32_t instId = 0); +#endif #ifdef FEATURE_SELF_CURE_SUPPORT int LoadSelfCureService(const std::string &dlname, bool bCreate); int UnloadSelfCureService(bool bPreLoad, int instId = 0); @@ -235,12 +265,16 @@ private: private: std::mutex mStaMutex; std::mutex mSelfCureMutex; + std::mutex mWifiProMutex; std::mutex mScanMutex; std::mutex mP2pMutex; std::mutex mApMutex; std::mutex mEnhanceMutex; std::unordered_map mServiceDllMap; StaServiceHandle mStaServiceHandle; +#ifdef FEATURE_WIFI_PRO_SUPPORT + WifiProServiceHandle mWifiProServiceHandle; +#endif #ifdef FEATURE_SELF_CURE_SUPPORT SelfCureServiceHandle mSelfCureServiceHandle; #endif 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 8baa97c89..c2d6a97d1 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 @@ -66,6 +66,7 @@ local_base_include_dirs = [ "$WIFI_ROOT_DIR/services/wifi_standard/include", "$WIFI_ROOT_DIR/services/wifi_standard/wifi_framework/wifi_manage/wifi_common/wifi_country_code", "$WIFI_ROOT_DIR/services/wifi_standard/wifi_framework/wifi_manage/wifi_common/wifi_network_stats", + "$WIFI_ROOT_DIR/services/wifi_standard/wifi_framework/wifi_manage/wifi_common/network_black_list", "$WIFI_ROOT_DIR/services/wifi_standard/wifi_framework/wifi_manage/wifi_sta/network_select", ] 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 3b9a15f31..14982a982 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 @@ -16,6 +16,7 @@ #ifndef OHOS_WIFI_STA_SERVICE_H #define OHOS_WIFI_STA_SERVICE_H +#include "sta_define.h" #include "wifi_errcode.h" #ifndef OHOS_ARCH_LITE #include "app_state_data.h" @@ -62,12 +63,13 @@ public: * @Description Connecting to a specified network. * * @param networkId - interior saved network index.(in) + * @param type - select network type: SelectedType * @Output: Return operating results to Interface Service after enable wifi successfully through callback function instead of returning result immediately. * @Return success: WIFI_OPT_SUCCESS fail: WIFI_OPT_FAILED */ - virtual ErrCode ConnectToNetwork(int networkId) = 0; + virtual ErrCode ConnectToNetwork(int networkId, int type = NETWORK_SELECTED_BY_USER) = 0; /** * @Description roam to target bssid 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 5ac87d800..81aee6171 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 @@ -16,17 +16,19 @@ #include "network_selection_utils.h" #include "network_status_history_manager.h" #include "wifi_common_util.h" - -#ifdef FEATURE_ITNETWORK_PREFERRED_SUPPORT +#include "wifi_config_center.h" +#include "wifi_p2p_msg.h" #include "wifi_logger.h" +#ifdef FEATURE_ITNETWORK_PREFERRED_SUPPORT #include "parameter.h" #endif namespace OHOS::Wifi::NetworkSelection { +namespace { +constexpr int32_t SCAN_5GHZ_BAND = 2; +} -#ifdef FEATURE_ITNETWORK_PREFERRED_SUPPORT DEFINE_WIFILOG_LABEL("NetworkSelectionUtils") -#endif bool NetworkSelectionUtils::IsOpenNetwork(const NetworkCandidate &networkCandidate) { @@ -82,6 +84,50 @@ std::string NetworkSelectionUtils::GetScoreResultsInfo(const std::vector &scoreResults); + /** + * check if wifi is open. + * + * @param networkCandidate candidate network. + * @return return ture if the candidate network is Open, else false. + */ + static bool IsConfigOpenType(const NetworkCandidate &networkCandidate); + + /** + * check if wifi is Is enterprise. + * + * @param networkCandidate candidate network. + * @return return ture if the candidate network is enterprise, else false. + */ + static bool IsEnterprise(const NetworkCandidate &networkCandidate); + + /** + * check if wifi is open or enterprise. + * + * @param networkCandidate candidate network. + * @return return ture if the candidate network is enterprise, else false. + */ + static bool IsConfigOpenOrEapType(const NetworkCandidate &networkCandidate); + + /** + * check if wifi has web keys. + * + * @param networkCandidate candidate network. + * @return return ture if wifi device config has web keys, else false. + */ + static bool HasWepKeys(const WifiDeviceConfig &wifiConfig); + + static bool IsSameFreqAsP2p(const NetworkCandidate &networkCandidate); + #ifdef FEATURE_ITNETWORK_PREFERRED_SUPPORT /** * Get vendor country from param to determine it is ItDevice. 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 index 117f73cca..a01f18811 100644 --- 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 @@ -24,6 +24,8 @@ NetworkSelectorFactory::NetworkSelectorFactory() { handleFuncMap[static_cast(NetworkSelectType::AUTO_CONNECT)] = &NetworkSelectorFactory::CreateAutoConnectNetworkSelector; + handleFuncMap[static_cast(NetworkSelectType::WIFI2WIFI)] = + &NetworkSelectorFactory::CreateWifi2WifiNetworkSelector; } std::optional> NetworkSelectorFactory::GetNetworkSelector( @@ -41,4 +43,9 @@ std::unique_ptr NetworkSelectorFactory::Crea { return std::make_unique(); } + +std::unique_ptr NetworkSelectorFactory::CreateWifi2WifiNetworkSelector() +{ + 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 index d9ef333dd..0d1469b6f 100644 --- 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 @@ -22,7 +22,11 @@ #include "wifi_errcode.h" namespace OHOS::Wifi { -enum class NetworkSelectType { AUTO_CONNECT }; +enum class NetworkSelectType { + AUTO_CONNECT, + WIFI2WIFI +}; + class NetworkSelectorFactory { public: NetworkSelectorFactory(); @@ -42,6 +46,12 @@ public: * @return the network selector */ std::unique_ptr CreateAutoConnectNetworkSelector(); + + /** + * the function to create wifi2wifi networkSelector + * @return the network selector + */ + std::unique_ptr CreateWifi2WifiNetworkSelector(); private: HandleFuncMap handleFuncMap; }; diff --git a/wifi/services/wifi_standard/wifi_framework/wifi_manage/wifi_sta/network_select/network_selector_impl.cpp b/wifi/services/wifi_standard/wifi_framework/wifi_manage/wifi_sta/network_select/network_selector_impl.cpp index 1804f58b2..0b83e4a30 100644 --- a/wifi/services/wifi_standard/wifi_framework/wifi_manage/wifi_sta/network_select/network_selector_impl.cpp +++ b/wifi/services/wifi_standard/wifi_framework/wifi_manage/wifi_sta/network_select/network_selector_impl.cpp @@ -60,6 +60,37 @@ bool AutoConnectIntegrator::Nominate(NetworkCandidate &networkCandidate) return false; } +void Wifi2WifiIntegrator::GetCandidatesFromSubNetworkSelector() +{ + for (const auto &subNetworkSelector : subNetworkSelectors) { + subNetworkSelector->GetBestCandidates(networkCandidates); + } +} + +Wifi2WifiIntegrator::Wifi2WifiIntegrator() : CompositeNetworkSelector("Wifi2WifiIntegrator") +{ + auto andFilters = make_shared(); + andFilters->AddFilter(make_shared()); + andFilters->AddFilter(make_shared()); + ExternalWifiFilterBuildManager::GetInstance().BuildFilter(FilterTag::NOT_P2P_ENHANCE_FREQ_AT_5G_FILTER_TAG, + *andFilters); + andFilters->AddFilter(make_shared()); + andFilters->AddFilter(make_shared()); + andFilters->AddFilter(make_shared()); + andFilters->AddFilter(make_shared()); + SetWifiFilter(andFilters); + + AddSubNetworkSelector(make_shared()); +} + +bool Wifi2WifiIntegrator::Nominate(NetworkCandidate &networkCandidate) +{ + for (auto &networkSelector : subNetworkSelectors) { + networkSelector->TryNominate(networkCandidate); + } + return false; +} + SavedNetworkTracker::SavedNetworkTracker() : CompositeNetworkSelector("savedNetworkTracker") { auto andFilter = make_shared(); @@ -294,4 +325,19 @@ bool NoInternetNetworkSelector::Filter(NetworkCandidate &networkCandidate) TryNominate(networkCandidate); return false; } + +PreferredApSelector::PreferredApSelector() : SimpleFilterNetworkSelector("PreferredApSelector") +{ + // The filtering conditions have already been done outside, so no further filtering is needed here. + auto networkScoreComparator = make_shared(m_networkSelectorName); + networkScoreComparator->AddScorer(make_shared("ApQualityScorer")); + networkScoreComparator->AddScorer(make_shared()); + SetWifiComparator(networkScoreComparator); +} + +bool PreferredApSelector::Filter(NetworkCandidate &networkCandidate) +{ + TryNominate(networkCandidate); + return false; +} } diff --git a/wifi/services/wifi_standard/wifi_framework/wifi_manage/wifi_sta/network_select/network_selector_impl.h b/wifi/services/wifi_standard/wifi_framework/wifi_manage/wifi_sta/network_select/network_selector_impl.h index dad84afb7..558d9b518 100644 --- a/wifi/services/wifi_standard/wifi_framework/wifi_manage/wifi_sta/network_select/network_selector_impl.h +++ b/wifi/services/wifi_standard/wifi_framework/wifi_manage/wifi_sta/network_select/network_selector_impl.h @@ -28,6 +28,15 @@ protected: void GetCandidatesFromSubNetworkSelector() override; }; +class Wifi2WifiIntegrator : public CompositeNetworkSelector { +public: + Wifi2WifiIntegrator(); + ~Wifi2WifiIntegrator() = default; +protected: + bool Nominate(NetworkCandidate &networkCandidate) override; + void GetCandidatesFromSubNetworkSelector() override; +}; + class SavedNetworkTracker final: public CompositeNetworkSelector { public: SavedNetworkTracker(); @@ -90,5 +99,12 @@ public: protected: bool Filter(NetworkCandidate &networkCandidate) override; }; + +class PreferredApSelector final: public SimpleFilterNetworkSelector { +public: + PreferredApSelector(); +protected: + bool Filter(NetworkCandidate &networkCandidate) override; +}; } #endif diff --git a/wifi/services/wifi_standard/wifi_framework/wifi_manage/wifi_sta/network_select/wifi_filter_impl.cpp b/wifi/services/wifi_standard/wifi_framework/wifi_manage/wifi_sta/network_select/wifi_filter_impl.cpp index db99463ec..b034d4a80 100644 --- a/wifi/services/wifi_standard/wifi_framework/wifi_manage/wifi_sta/network_select/wifi_filter_impl.cpp +++ b/wifi/services/wifi_standard/wifi_framework/wifi_manage/wifi_sta/network_select/wifi_filter_impl.cpp @@ -16,20 +16,28 @@ #include "wifi_filter_impl.h" #include "network_selection_utils.h" #include "network_status_history_manager.h" +#include "wifi_config_center.h" #include "wifi_logger.h" #include "wifi_settings.h" +#include "network_black_list_manager.h" +#include "wifi_ap_msg.h" #ifndef OHOS_ARCH_LITE #include "wifi_app_state_aware.h" #endif namespace OHOS::Wifi::NetworkSelection { DEFINE_WIFILOG_LABEL("WifiFilter") - +namespace { constexpr int RECHECK_DELAYED_SECONDS = 1 * 60 * 60; 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 int32_t MIN_SIGNAL_LEVEL_INTERVAL = 2; +constexpr int32_t SIGNAL_LEVEL_THREE = 3; +constexpr int32_t SIGNAL_LEVEL_FOUR = 4; +constexpr int32_t MIN_RSSI_INTERVAL = 8; +} HiddenWifiFilter::HiddenWifiFilter() : SimpleWifiFilter("notHidden") {} @@ -253,7 +261,6 @@ bool PortalWifiFilter::Filter(NetworkCandidate &networkCandidate) return networkCandidate.wifiDeviceConfig.isPortal; } - MaybePortalWifiFilter::MaybePortalWifiFilter() : SimpleWifiFilter("maybePortal") {} MaybePortalWifiFilter::~MaybePortalWifiFilter() @@ -292,7 +299,6 @@ bool NoInternetWifiFilter::Filter(NetworkCandidate &networkCandidate) return NetworkStatusHistoryManager::HasInternetEverByHistory(wifiDeviceConfig.networkStatusHistory); } - WeakAlgorithmWifiFilter::WeakAlgorithmWifiFilter() : SimpleWifiFilter("noWeakAlgorithm") {} WeakAlgorithmWifiFilter::~WeakAlgorithmWifiFilter() @@ -320,4 +326,221 @@ bool WeakAlgorithmWifiFilter::Filter(NetworkCandidate &networkCandidate) } return true; } + +NotCurrentNetworkFilter::NotCurrentNetworkFilter() : SimpleWifiFilter("NotCurrentNetwork") {} + +NotCurrentNetworkFilter::~NotCurrentNetworkFilter() +{ + if (!filteredNetworkCandidates.empty()) { + WIFI_LOGI("filteredNetworkCandidates in %{public}s: %{public}s", + filterName.c_str(), + NetworkSelectionUtils::GetNetworkCandidatesInfo(filteredNetworkCandidates).c_str()); + } } + +bool NotCurrentNetworkFilter::Filter(NetworkCandidate &networkCandidate) +{ + WifiLinkedInfo linkedInfo; + WifiConfigCenter::GetInstance().GetLinkedInfo(linkedInfo); + if (networkCandidate.interScanInfo.bssid == linkedInfo.bssid) { + WIFI_LOGI("NotCurrentNetworkFilter, same bssid:%{public}s", + networkCandidate.ToString().c_str()); + return false; + } + + if ((networkCandidate.interScanInfo.ssid == linkedInfo.ssid) && + NetworkSelectionUtils::IsConfigOpenOrEapType(networkCandidate)) { + WIFI_LOGI("NotCurrentNetworkFilter, same ssid and open or eap type:%{public}s", + networkCandidate.ToString().c_str()); + return false; + } + return true; +} + +SignalLevelFilter::SignalLevelFilter() : SimpleWifiFilter("SignalLevel") {} + +SignalLevelFilter::~SignalLevelFilter() +{ + if (!filteredNetworkCandidates.empty()) { + WIFI_LOGI("filteredNetworkCandidates in %{public}s: %{public}s", + filterName.c_str(), + NetworkSelectionUtils::GetNetworkCandidatesInfo(filteredNetworkCandidates).c_str()); + } +} + +bool SignalLevelFilter::Filter(NetworkCandidate &networkCandidate) +{ + auto &interScanInfo = networkCandidate.interScanInfo; + int32_t signalLevel = WifiSettings::GetInstance().GetSignalLevel(interScanInfo.rssi, interScanInfo.band); + return signalLevel > SIGNAL_LEVEL_TWO; +} + +NotNetworkBlackListFilter::NotNetworkBlackListFilter() : SimpleWifiFilter("NotNetworkBlackList") {} + +NotNetworkBlackListFilter::~NotNetworkBlackListFilter() +{ + if (!filteredNetworkCandidates.empty()) { + WIFI_LOGI("filteredNetworkCandidates in %{public}s: %{public}s", + filterName.c_str(), + NetworkSelectionUtils::GetNetworkCandidatesInfo(filteredNetworkCandidates).c_str()); + } +} + +bool NotNetworkBlackListFilter::Filter(NetworkCandidate &networkCandidate) +{ + if (NetworkBlockListManager::GetInstance().IsInAbnormalWifiBlocklist(networkCandidate.interScanInfo.bssid)) { + WIFI_LOGI("NotNetworkBlockListFilter, in abnormal wifi blocklist, skip candidate:%{public}s", + networkCandidate.ToString().c_str()); + return false; + } + + WifiLinkedInfo linkedInfo; + WifiConfigCenter::GetInstance().GetLinkedInfo(linkedInfo); + int32_t curSignalLevel = WifiSettings::GetInstance().GetSignalLevel(linkedInfo.rssi, linkedInfo.band); + auto scanInfo = networkCandidate.interScanInfo; + int32_t targetSignalLevel = WifiSettings::GetInstance().GetSignalLevel(scanInfo.rssi, scanInfo.band); + if (NetworkBlockListManager::GetInstance().IsInWifiBlocklist(networkCandidate.interScanInfo.bssid) && + (targetSignalLevel <= SIGNAL_LEVEL_THREE || targetSignalLevel - curSignalLevel < MIN_SIGNAL_LEVEL_INTERVAL)) { + WIFI_LOGI("NotNetworkBlackListFilter, in wifi blocklist and level interval is not enough," + "skip candidate:%{public}s", networkCandidate.ToString().c_str()); + return false; + } + return true; +} + +NotP2pFreqAt5gFilter::NotP2pFreqAt5gFilter() : SimpleWifiFilter("NotP2pFreqAt5g") {} + +NotP2pFreqAt5gFilter::~NotP2pFreqAt5gFilter() +{ + if (!filteredNetworkCandidates.empty()) { + WIFI_LOGI("filteredNetworkCandidates in %{public}s: %{public}s", + filterName.c_str(), + NetworkSelectionUtils::GetNetworkCandidatesInfo(filteredNetworkCandidates).c_str()); + } +} + +bool NotP2pFreqAt5gFilter::Filter(NetworkCandidate &networkCandidate) +{ + if (networkCandidate.interScanInfo.band == static_cast(BandType::BAND_2GHZ)) { + return true; + } + + Hid2dUpperScene softbusScene; + Hid2dUpperScene castScene; + Hid2dUpperScene shareScene; + Hid2dUpperScene mouseCrossScene; + Hid2dUpperScene miracastScene; + WifiP2pLinkedInfo linkedInfo; + WifiConfigCenter::GetInstance().GetHid2dUpperScene(SOFT_BUS_SERVICE_UID, softbusScene); + WifiConfigCenter::GetInstance().GetHid2dUpperScene(CAST_ENGINE_SERVICE_UID, castScene); + WifiConfigCenter::GetInstance().GetHid2dUpperScene(MIRACAST_SERVICE_UID, miracastScene); + WifiConfigCenter::GetInstance().GetHid2dUpperScene(SHARE_SERVICE_UID, shareScene); + WifiConfigCenter::GetInstance().GetHid2dUpperScene(MOUSE_CROSS_SERVICE_UID, mouseCrossScene); + WifiConfigCenter::GetInstance().GetP2pInfo(linkedInfo); + if (linkedInfo.GetConnectState() == P2pConnectedState::P2P_DISCONNECTED + && WifiConfigCenter::GetInstance().GetP2pEnhanceState() == 0) { + return true; + } + // scene bit 0-2 is valid, 0x01: video, 0x02: audio, 0x04: file, + // scene & 0x07 > 0 means one of them takes effect. + bool isCastScene = false; + if ((softbusScene.scene & 0x07) > 0 || (castScene.scene & 0x07) > 0 || (shareScene.scene & 0x07) > 0 || + (mouseCrossScene.scene & 0x07) > 0 || (miracastScene.scene & 0x07) > 0) { + isCastScene = true; + } + + if (!isCastScene) { + return true; + } + + return NetworkSelectionUtils::IsSameFreqAsP2p(networkCandidate); +} + +ValidConfigNetworkFilter::ValidConfigNetworkFilter() : SimpleWifiFilter("ValidConfigNetwork") {} + +ValidConfigNetworkFilter::~ValidConfigNetworkFilter() +{ + if (!filteredNetworkCandidates.empty()) { + WIFI_LOGI("filteredNetworkCandidates in %{public}s: %{public}s", + filterName.c_str(), + NetworkSelectionUtils::GetNetworkCandidatesInfo(filteredNetworkCandidates).c_str()); + } +} + +bool ValidConfigNetworkFilter::Filter(NetworkCandidate &networkCandidate) +{ + // no internet filtering + auto &wifiDeviceConfig = networkCandidate.wifiDeviceConfig; + if (wifiDeviceConfig.noInternetAccess) { + WIFI_LOGI("ValidConfigNetworkFilter, no internet access, skip candidate:%{public}s", + networkCandidate.ToString().c_str()); + return false; + } + + // portal network filtering + if (networkCandidate.wifiDeviceConfig.isPortal) { + WIFI_LOGI("ValidConfigNetworkFilter, portal network, skip candidate:%{public}s", + networkCandidate.ToString().c_str()); + return false; + } + + // disable network filtering + auto &networkSelectionStatus = networkCandidate.wifiDeviceConfig.networkSelectionStatus; + if (networkSelectionStatus.networkSelectionDisableReason != DisabledReason::DISABLED_NONE) { + WIFI_LOGI("ValidConfigNetworkFilter, disable network, skip candidate:%{public}s", + networkCandidate.ToString().c_str()); + return false; + } + + // empty network status history + if (NetworkStatusHistoryManager::IsEmptyNetworkStatusHistory(wifiDeviceConfig.networkStatusHistory)) { + WIFI_LOGI("ValidConfigNetworkFilter, no network status history, skip candidate:%{public}s", + networkCandidate.ToString().c_str()); + return false; + } + + // maybe portal network filtering + if (NetworkSelectionUtils::IsScanResultForOweNetwork(networkCandidate) && + NetworkSelectionUtils::IsOpenAndMaybePortal(networkCandidate)) { + WIFI_LOGI("ValidConfigNetworkFilter, maybe portal network, skip candidate:%{public}s", + networkCandidate.ToString().c_str()); + return false; + } + + return true; +} + +WifiSwitchThresholdFilter::WifiSwitchThresholdFilter() : SimpleWifiFilter("WifiSwitchThreshold") {} + +WifiSwitchThresholdFilter::~WifiSwitchThresholdFilter() +{ + if (!filteredNetworkCandidates.empty()) { + WIFI_LOGI("filteredNetworkCandidates in %{public}s: %{public}s", + filterName.c_str(), + NetworkSelectionUtils::GetNetworkCandidatesInfo(filteredNetworkCandidates).c_str()); + } +} + +bool WifiSwitchThresholdFilter::Filter(NetworkCandidate &networkCandidate) +{ + WifiLinkedInfo linkedInfo; + WifiConfigCenter::GetInstance().GetLinkedInfo(linkedInfo); + int32_t curSignalLevel = WifiSettings::GetInstance().GetSignalLevel(linkedInfo.rssi, linkedInfo.band); + auto &interScanInfo = networkCandidate.interScanInfo; + if (linkedInfo.band == static_cast(BandType::BAND_5GHZ) && curSignalLevel == SIGNAL_LEVEL_THREE && + interScanInfo.band == static_cast(BandType::BAND_2GHZ)) { + WIFI_LOGI("WifiSwitchThresholdFilter, current network is 5G and level is three and target network is 2G, " + "skip candidate:%{public}s", networkCandidate.ToString().c_str()); + return false; + } + + if (curSignalLevel == SIGNAL_LEVEL_FOUR || (interScanInfo.rssi - linkedInfo.rssi < MIN_RSSI_INTERVAL)) { + WIFI_LOGI("WifiSwitchThresholdFilter, curSignalLevel:%{public}d, scan info rssi:%{public}d," + "cur rssi:%{public}d, skip candidate:%{public}s", + curSignalLevel, interScanInfo.rssi, linkedInfo.rssi, networkCandidate.ToString().c_str()); + return false; + } + + return true; +} +} \ No newline at end of file diff --git a/wifi/services/wifi_standard/wifi_framework/wifi_manage/wifi_sta/network_select/wifi_filter_impl.h b/wifi/services/wifi_standard/wifi_framework/wifi_manage/wifi_sta/network_select/wifi_filter_impl.h index 0dbd5062c..4f3c1b047 100644 --- a/wifi/services/wifi_standard/wifi_framework/wifi_manage/wifi_sta/network_select/wifi_filter_impl.h +++ b/wifi/services/wifi_standard/wifi_framework/wifi_manage/wifi_sta/network_select/wifi_filter_impl.h @@ -26,6 +26,54 @@ protected: bool Filter(NetworkCandidate &networkCandidate) override; }; +class NotCurrentNetworkFilter final : public SimpleWifiFilter { +public: + NotCurrentNetworkFilter(); + ~NotCurrentNetworkFilter() override; +protected: + bool Filter(NetworkCandidate &networkCandidate) override; +}; + +class SignalLevelFilter final : public SimpleWifiFilter { +public: + SignalLevelFilter(); + ~SignalLevelFilter() override; +protected: + bool Filter(NetworkCandidate &networkCandidate) override; +}; + +class NotNetworkBlackListFilter final : public SimpleWifiFilter { +public: + NotNetworkBlackListFilter(); + ~NotNetworkBlackListFilter() override; +protected: + bool Filter(NetworkCandidate &networkCandidate) override; +}; + +class NotP2pFreqAt5gFilter final : public SimpleWifiFilter { +public: + NotP2pFreqAt5gFilter(); + ~NotP2pFreqAt5gFilter() override; +protected: + bool Filter(NetworkCandidate &networkCandidate) override; +}; + +class ValidConfigNetworkFilter final : public SimpleWifiFilter { +public: + ValidConfigNetworkFilter(); + ~ValidConfigNetworkFilter() override; +protected: + bool Filter(NetworkCandidate &networkCandidate) override; +}; + +class WifiSwitchThresholdFilter final : public SimpleWifiFilter { +public: + WifiSwitchThresholdFilter(); + ~WifiSwitchThresholdFilter() override; +protected: + bool Filter(NetworkCandidate &networkCandidate) override; +}; + class SignalStrengthWifiFilter final : public SimpleWifiFilter { public: SignalStrengthWifiFilter(); diff --git a/wifi/services/wifi_standard/wifi_framework/wifi_manage/wifi_sta/network_select/wifi_scorer_impl.cpp b/wifi/services/wifi_standard/wifi_framework/wifi_manage/wifi_sta/network_select/wifi_scorer_impl.cpp index b49660d1e..2d235667b 100644 --- a/wifi/services/wifi_standard/wifi_framework/wifi_manage/wifi_sta/network_select/wifi_scorer_impl.cpp +++ b/wifi/services/wifi_standard/wifi_framework/wifi_manage/wifi_sta/network_select/wifi_scorer_impl.cpp @@ -22,7 +22,7 @@ namespace OHOS::Wifi::NetworkSelection { DEFINE_WIFILOG_LABEL("WifiScorerImpl") - +namespace { constexpr int SUFFICIENT_RSSI_5G = -70; constexpr int SUFFICIENT_RSSI_2G = -73; constexpr int RSSI_SCORE_OFFSET = 85; @@ -36,6 +36,8 @@ 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 WIFI_DEFAULT_SCORE = -1; constexpr int RSSI_LEVEL_TWO_SCORE_5G = 40; constexpr int RSSI_LEVEL_TWO_SCORE_2G = 20; constexpr int SIGNAL_LEVEL_TWO = 2; @@ -47,6 +49,7 @@ constexpr int EMPTY_NETWORK_STATUS_HISTORY_AWARD = 1; constexpr int MAX_HISTORY_NETWORK_STATUS_NUM = 10; constexpr int HISTORY_NETWORK_STATUS_WEIGHTED_SCORE[MAX_HISTORY_NETWORK_STATUS_NUM] = { 0, 40960, 20480, 10240, 5120, 2560, 1280, 640, 320, 160}; +} RssiScorer::RssiScorer() : SimpleWifiScorer("rssiScorer") {} @@ -218,6 +221,31 @@ double RssiLevelBonusScorer::Score(NetworkCandidate &networkCandidate) return 0; } +SignalLevelScorer::SignalLevelScorer() : SimpleWifiScorer("SignalLevelScorer") {} + +double SignalLevelScorer::Score(NetworkCandidate &networkCandidate) +{ + auto &scanInfo = networkCandidate.interScanInfo; + int signalLevel = WifiSettings::GetInstance().GetSignalLevel(scanInfo.rssi, scanInfo.band); + int32_t levelScore = 0; + switch (signalLevel) { + case SIGNAL_LEVEL_FOUR: + levelScore = RSSI_LEVEL_FOUR_SCORE; + break; + case SIGNAL_LEVEL_THREE: + levelScore = RSSI_LEVEL_THREE_SCORE; + break; + case SIGNAL_LEVEL_TWO: + levelScore = RSSI_LEVEL_TWO_SCORE; + break; + default: + levelScore = WIFI_DEFAULT_SCORE; + break; + } + + return levelScore; +} + Network5gBonusScorer::Network5gBonusScorer() : SimpleWifiScorer("5gBonusScore") {} double Network5gBonusScorer::Score(NetworkCandidate &networkCandidate) @@ -254,4 +282,13 @@ double NoInternetNetworkStatusHistoryScorer::Score(NetworkCandidate &networkCand } return score; } + +ApQualityScorer::ApQualityScorer(const std::string &scorerName) : CompositeWifiScorer(scorerName) +{ + AddScorer(std::make_shared()); + AddScorer(std::make_shared()); + ExternalWifiCommonBuildManager::GetInstance().BuildScore( + TagType::HAS_INTERNET_NETWORK_SELECTOR_SCORE_WIFI_CATEGORY_TAG, *this); + AddScorer(std::make_shared()); +} } diff --git a/wifi/services/wifi_standard/wifi_framework/wifi_manage/wifi_sta/network_select/wifi_scorer_impl.h b/wifi/services/wifi_standard/wifi_framework/wifi_manage/wifi_sta/network_select/wifi_scorer_impl.h index 4c41f4964..5136c9f93 100644 --- a/wifi/services/wifi_standard/wifi_framework/wifi_manage/wifi_sta/network_select/wifi_scorer_impl.h +++ b/wifi/services/wifi_standard/wifi_framework/wifi_manage/wifi_sta/network_select/wifi_scorer_impl.h @@ -137,6 +137,12 @@ public: double Score(NetworkCandidate &networkCandidate) override; }; +class SignalLevelScorer : public SimpleWifiScorer { +public: + SignalLevelScorer(); + double Score(NetworkCandidate &networkCandidate) override; +}; + class Network5gBonusScorer : public SimpleWifiScorer { public: Network5gBonusScorer(); @@ -153,6 +159,12 @@ public: NoInternetNetworkStatusHistoryScorer(); double Score(NetworkCandidate &networkCandidate) override; }; + +class ApQualityScorer : public CompositeWifiScorer { +public: + explicit ApQualityScorer(const std::string &scorerName); +}; + } #endif 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 a0207b6d3..a76b179fe 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 @@ -17,7 +17,6 @@ #include "wifi_sta_hal_interface.h" #include "wifi_config_center.h" #include "wifi_common_util.h" -#include "wifi_service_manager.h" #include "block_connect_service.h" DEFINE_WIFILOG_LABEL("StaAutoConnectService"); diff --git a/wifi/services/wifi_standard/wifi_framework/wifi_manage/wifi_sta/sta_define.h b/wifi/services/wifi_standard/wifi_framework/wifi_manage/wifi_sta/sta_define.h index 7426bb5a2..53a2a0e34 100644 --- a/wifi/services/wifi_standard/wifi_framework/wifi_manage/wifi_sta/sta_define.h +++ b/wifi/services/wifi_standard/wifi_framework/wifi_manage/wifi_sta/sta_define.h @@ -82,10 +82,12 @@ namespace Wifi { #define VALUE_LIMIT_MIN_RSSI (-100) #define VALUE_LIMIT_MAX_RSSI (-55) -#define NETWORK_SELECTED_BY_UNKNOWN (-1) -#define NETWORK_SELECTED_BY_AUTO 0 -#define NETWORK_SELECTED_BY_USER 1 -#define NETWORK_SELECTED_BY_RETRY 2 +enum SelectedType { + NETWORK_SELECTED_BY_UNKNOWN = -1, + NETWORK_SELECTED_BY_AUTO = 0, + NETWORK_SELECTED_BY_USER = 1, + NETWORK_SELECTED_BY_RETRY = 2 +}; #define WIFI_SIM_GSM_AUTH_MIN_PARAM_COUNT 3 #define WIFI_SIM_GSM_AUTH_MAX_PARAM_COUNT 4 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 b29bd5010..935d7ad47 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 @@ -76,12 +76,12 @@ ErrCode StaInterface::DisableStaService() return WIFI_OPT_SUCCESS; } -ErrCode StaInterface::ConnectToNetwork(int networkId) +ErrCode StaInterface::ConnectToNetwork(int networkId, int type) { LOGI("Enter Connect.\n"); std::lock_guard lock(mutex); CHECK_NULL_AND_RETURN(pStaService, WIFI_OPT_FAILED); - if (pStaService->ConnectToNetwork(networkId) != WIFI_OPT_SUCCESS) { + if (pStaService->ConnectToNetwork(networkId, type) != WIFI_OPT_SUCCESS) { LOGE("ConnectTo failed.\n"); return 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 0a9db6367..d2a99430d 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 @@ -50,17 +50,18 @@ public: /** * @Description Connect to a new network * - * @param config - the configuration of network which is going to connect.(in) + * @param networkId - interior saved network index.(in) + * @param type - select network type: SelectedType * @Output: Return operating results to Interface Service after enable wifi successfully through callback function instead of returning result immediately. * @Return success: WIFI_OPT_SUCCESS fail: WIFI_OPT_FAILED */ - virtual ErrCode ConnectToNetwork(int networkId) override; + virtual ErrCode ConnectToNetwork(int networkId, int type = NETWORK_SELECTED_BY_USER) override; /** * @Description Connecting to a specified network. * - * @param networkId - interior saved network index.(in) + * @param config - the configuration of network which is going to connect.(in) * @Output: Return operating results to Interface Service after enable wifi successfully through callback function instead of returning result immediately. 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 09197eae3..f478b8fcd 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 @@ -557,7 +557,7 @@ ErrCode StaService::ConnectToDevice(const WifiDeviceConfig &config) const return WIFI_OPT_SUCCESS; } -ErrCode StaService::ConnectToNetwork(int networkId) const +ErrCode StaService::ConnectToNetwork(int networkId, int type) const { LOGI("Enter ConnectToNetwork, networkId is %{public}d.", networkId); WifiDeviceConfig config; @@ -570,7 +570,7 @@ ErrCode StaService::ConnectToNetwork(int networkId) const LOGI("ConnectToNetwork, ssid = %{public}s.", SsidAnonymize(config.ssid).c_str()); pStaAutoConnectService->EnableOrDisableBssid(config.bssid, true, 0); pStaStateMachine->SetPortalBrowserFlag(false); - pStaStateMachine->SendMessage(WIFI_SVR_CMD_STA_CONNECT_SAVED_NETWORK, networkId, NETWORK_SELECTED_BY_USER); + pStaStateMachine->SendMessage(WIFI_SVR_CMD_STA_CONNECT_SAVED_NETWORK, networkId, type); 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 1a6c53a3d..19d93af54 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 @@ -73,12 +73,13 @@ public: * @Description Connecting to a specified network. * * @param networkId - interior saved network index.(in) + * @param type - select network type: SelectedType * @Output: Return operating results to Interface Service after enable wifi successfully through callback function instead of returning result immediately. * @Return success: WIFI_OPT_SUCCESS fail: WIFI_OPT_FAILED */ - virtual ErrCode ConnectToNetwork(int networkId) const; + virtual ErrCode ConnectToNetwork(int networkId, int type = NETWORK_SELECTED_BY_USER) const; /** * @Description roam to target bssid diff --git a/wifi/services/wifi_standard/wifi_framework/wifi_manage/wifi_sta/sta_service_callback.h b/wifi/services/wifi_standard/wifi_framework/wifi_manage/wifi_sta/sta_service_callback.h index fb6947dce..3dc27859d 100644 --- a/wifi/services/wifi_standard/wifi_framework/wifi_manage/wifi_sta/sta_service_callback.h +++ b/wifi/services/wifi_standard/wifi_framework/wifi_manage/wifi_sta/sta_service_callback.h @@ -25,15 +25,15 @@ namespace OHOS { namespace Wifi { struct StaServiceCallback { std::string callbackModuleName; - std::function OnStaOpenRes; - std::function OnStaCloseRes; - std::function OnStaConnChanged; - std::function OnWpsChanged; - std::function OnStaStreamChanged; - std::function OnStaRssiLevelChanged; - std::function OnStaSemiActiveRes; - std::function OnDhcpOfferReport; - std::function OnAutoSelectNetworkRes; + std::function OnStaOpenRes { nullptr }; + std::function OnStaCloseRes { nullptr }; + std::function OnStaConnChanged { nullptr }; + std::function OnWpsChanged { nullptr }; + std::function OnStaStreamChanged { nullptr }; + std::function OnStaRssiLevelChanged { nullptr }; + std::function OnStaSemiActiveRes { nullptr }; + std::function OnDhcpOfferReport { nullptr }; + std::function OnAutoSelectNetworkRes { nullptr }; }; } // namespace Wifi } // namespace OHOS diff --git a/wifi/services/wifi_standard/wifi_framework/wifi_manage/wifi_sub_manage/wifi_scan_manager.cpp b/wifi/services/wifi_standard/wifi_framework/wifi_manage/wifi_sub_manage/wifi_scan_manager.cpp index f7bfd7afc..940bfc60b 100644 --- a/wifi/services/wifi_standard/wifi_framework/wifi_manage/wifi_sub_manage/wifi_scan_manager.cpp +++ b/wifi/services/wifi_standard/wifi_framework/wifi_manage/wifi_sub_manage/wifi_scan_manager.cpp @@ -243,6 +243,13 @@ void WifiScanManager::DealScanInfoNotify(std::vector &results, in if (pService != nullptr) { pService->ConnectivityManager(results); } + +#ifdef FEATURE_WIFI_PRO_SUPPORT + IWifiProService *pWifiProService = WifiServiceManager::GetInstance().GetWifiProServiceInst(instId); + if (pWifiProService != nullptr) { + pWifiProService->DealScanResult(results); + } +#endif } } diff --git a/wifi/test/BUILD.gn b/wifi/test/BUILD.gn index 15bd2d483..472f119d5 100644 --- a/wifi/test/BUILD.gn +++ b/wifi/test/BUILD.gn @@ -27,6 +27,7 @@ group("unittest") { "wifi_standard/wifi_framework/wifi_manage/wifi_ap:WifiApServiceTest", "wifi_standard/wifi_framework/wifi_manage/wifi_native:wifi_native_test", "wifi_standard/wifi_framework/wifi_manage/wifi_p2p/test:wifi_p2p_test", + "wifi_standard/wifi_framework/wifi_manage/wifi_pro:wifi_pro_unittest", "wifi_standard/wifi_framework/wifi_manage/wifi_scan:wifi_scan_unittest", "wifi_standard/wifi_framework/wifi_manage/wifi_sta:wifi_selfcure_unittest", "wifi_standard/wifi_framework/wifi_manage/wifi_sta:wifi_sta_unittest", diff --git a/wifi/test/fuzztest/wifi_sta/wifidevicestub_fuzzer/BUILD.gn b/wifi/test/fuzztest/wifi_sta/wifidevicestub_fuzzer/BUILD.gn index 022728ea8..a1c88d7fc 100644 --- a/wifi/test/fuzztest/wifi_sta/wifidevicestub_fuzzer/BUILD.gn +++ b/wifi/test/fuzztest/wifi_sta/wifidevicestub_fuzzer/BUILD.gn @@ -45,6 +45,7 @@ ohos_fuzztest("WifiDeviceStubFuzzTest") { "$WIFI_ROOT_DIR/services/wifi_standard/wifi_framework/wifi_manage/wifi_scan", "$WIFI_ROOT_DIR/services/wifi_standard/wifi_framework/wifi_manage/wifi_scan_sa", "$WIFI_ROOT_DIR/services/wifi_standard/wifi_framework/wifi_manage/wifi_self_cure", + "$WIFI_ROOT_DIR/services/wifi_standard/wifi_framework/wifi_manage/wifi_pro", "$WIFI_ROOT_DIR/services/wifi_standard/wifi_framework/wifi_manage/wifi_sub_manage", "$WIFI_ROOT_DIR/services/wifi_standard/wifi_framework/wifi_manage/wifi_ap", "$WIFI_ROOT_DIR/services/wifi_standard/wifi_framework/wifi_manage/wifi_ap_sa", diff --git a/wifi/test/fuzztest/wifi_sta/wifihotspotimpl_fuzzer/BUILD.gn b/wifi/test/fuzztest/wifi_sta/wifihotspotimpl_fuzzer/BUILD.gn index d446be6b0..eda07b049 100644 --- a/wifi/test/fuzztest/wifi_sta/wifihotspotimpl_fuzzer/BUILD.gn +++ b/wifi/test/fuzztest/wifi_sta/wifihotspotimpl_fuzzer/BUILD.gn @@ -45,6 +45,7 @@ ohos_fuzztest("WifiHotspotImplFuzzTest") { "$WIFI_ROOT_DIR/services/wifi_standard/wifi_framework/wifi_manage/wifi_scan", "$WIFI_ROOT_DIR/services/wifi_standard/wifi_framework/wifi_manage/wifi_scan_sa", "$WIFI_ROOT_DIR/services/wifi_standard/wifi_framework/wifi_manage/wifi_self_cure", + "$WIFI_ROOT_DIR/services/wifi_standard/wifi_framework/wifi_manage/wifi_pro", "$WIFI_ROOT_DIR/services/wifi_standard/wifi_framework/wifi_manage/wifi_sub_manage", "$WIFI_ROOT_DIR/services/wifi_standard/wifi_framework/wifi_manage/wifi_ap", "$WIFI_ROOT_DIR/services/wifi_standard/wifi_framework/wifi_manage/wifi_ap_sa", diff --git a/wifi/test/fuzztest/wifi_sta/wifihotspotstub_fuzzer/BUILD.gn b/wifi/test/fuzztest/wifi_sta/wifihotspotstub_fuzzer/BUILD.gn index 07762706e..50e191f1e 100644 --- a/wifi/test/fuzztest/wifi_sta/wifihotspotstub_fuzzer/BUILD.gn +++ b/wifi/test/fuzztest/wifi_sta/wifihotspotstub_fuzzer/BUILD.gn @@ -45,6 +45,7 @@ ohos_fuzztest("WifiHotSpotStubFuzzTest") { "$WIFI_ROOT_DIR/services/wifi_standard/wifi_framework/wifi_manage/wifi_scan", "$WIFI_ROOT_DIR/services/wifi_standard/wifi_framework/wifi_manage/wifi_scan_sa", "$WIFI_ROOT_DIR/services/wifi_standard/wifi_framework/wifi_manage/wifi_self_cure", + "$WIFI_ROOT_DIR/services/wifi_standard/wifi_framework/wifi_manage/wifi_pro", "$WIFI_ROOT_DIR/services/wifi_standard/wifi_framework/wifi_manage/wifi_sub_manage", "$WIFI_ROOT_DIR/services/wifi_standard/wifi_framework/wifi_manage/wifi_ap", "$WIFI_ROOT_DIR/services/wifi_standard/wifi_framework/wifi_manage/wifi_ap_sa", diff --git a/wifi/test/fuzztest/wifi_sta/wifip2pstub_fuzzer/BUILD.gn b/wifi/test/fuzztest/wifi_sta/wifip2pstub_fuzzer/BUILD.gn index a6d2f52a6..3333215a3 100644 --- a/wifi/test/fuzztest/wifi_sta/wifip2pstub_fuzzer/BUILD.gn +++ b/wifi/test/fuzztest/wifi_sta/wifip2pstub_fuzzer/BUILD.gn @@ -44,6 +44,7 @@ ohos_fuzztest("WifiP2pStubFuzzTest") { "$WIFI_ROOT_DIR/services/wifi_standard/wifi_framework/wifi_manage/wifi_scan", "$WIFI_ROOT_DIR/services/wifi_standard/wifi_framework/wifi_manage/wifi_scan_sa", "$WIFI_ROOT_DIR/services/wifi_standard/wifi_framework/wifi_manage/wifi_self_cure", + "$WIFI_ROOT_DIR/services/wifi_standard/wifi_framework/wifi_manage/wifi_pro", "$WIFI_ROOT_DIR/services/wifi_standard/wifi_framework/wifi_manage/wifi_sub_manage", "$WIFI_ROOT_DIR/services/wifi_standard/wifi_framework/wifi_manage/wifi_ap", "$WIFI_ROOT_DIR/services/wifi_standard/wifi_framework/wifi_manage/wifi_ap_sa", diff --git a/wifi/test/fuzztest/wifi_sta/wifiscansa_fuzzer/BUILD.gn b/wifi/test/fuzztest/wifi_sta/wifiscansa_fuzzer/BUILD.gn index a88ec9be7..a3c23766b 100644 --- a/wifi/test/fuzztest/wifi_sta/wifiscansa_fuzzer/BUILD.gn +++ b/wifi/test/fuzztest/wifi_sta/wifiscansa_fuzzer/BUILD.gn @@ -44,6 +44,7 @@ ohos_fuzztest("WifiScansaFuzzTest") { "$WIFI_ROOT_DIR/services/wifi_standard/wifi_framework/wifi_manage/wifi_scan", "$WIFI_ROOT_DIR/services/wifi_standard/wifi_framework/wifi_manage/wifi_scan_sa", "$WIFI_ROOT_DIR/services/wifi_standard/wifi_framework/wifi_manage/wifi_self_cure", + "$WIFI_ROOT_DIR/services/wifi_standard/wifi_framework/wifi_manage/wifi_pro", "$WIFI_ROOT_DIR/services/wifi_standard/wifi_framework/wifi_manage/wifi_sub_manage", "$WIFI_ROOT_DIR/services/wifi_standard/wifi_framework/wifi_manage/wifi_ap", "$WIFI_ROOT_DIR/services/wifi_standard/wifi_framework/wifi_manage/wifi_ap_sa", diff --git a/wifi/test/fuzztest/wifi_sta/wifiscanserver_fuzzer/BUILD.gn b/wifi/test/fuzztest/wifi_sta/wifiscanserver_fuzzer/BUILD.gn index 5ae0c4678..b9ed4b19b 100644 --- a/wifi/test/fuzztest/wifi_sta/wifiscanserver_fuzzer/BUILD.gn +++ b/wifi/test/fuzztest/wifi_sta/wifiscanserver_fuzzer/BUILD.gn @@ -45,6 +45,7 @@ ohos_fuzztest("WifiScanServerFuzzTest") { "$WIFI_ROOT_DIR/services/wifi_standard/wifi_framework/wifi_manage/wifi_scan", "$WIFI_ROOT_DIR/services/wifi_standard/wifi_framework/wifi_manage/wifi_scan_sa", "$WIFI_ROOT_DIR/services/wifi_standard/wifi_framework/wifi_manage/wifi_self_cure", + "$WIFI_ROOT_DIR/services/wifi_standard/wifi_framework/wifi_manage/wifi_pro", "$WIFI_ROOT_DIR/services/wifi_standard/wifi_framework/wifi_manage/wifi_sub_manage", "$WIFI_ROOT_DIR/services/wifi_standard/wifi_framework/wifi_manage/wifi_ap", "$WIFI_ROOT_DIR/services/wifi_standard/wifi_framework/wifi_manage/wifi_ap_sa", diff --git a/wifi/test/fuzztest/wifi_sta/wifiscanstub_fuzzer/BUILD.gn b/wifi/test/fuzztest/wifi_sta/wifiscanstub_fuzzer/BUILD.gn index bcc436022..f2701978d 100644 --- a/wifi/test/fuzztest/wifi_sta/wifiscanstub_fuzzer/BUILD.gn +++ b/wifi/test/fuzztest/wifi_sta/wifiscanstub_fuzzer/BUILD.gn @@ -44,6 +44,7 @@ ohos_fuzztest("WifiScanStubFuzzTest") { "$WIFI_ROOT_DIR/services/wifi_standard/wifi_framework/wifi_manage/wifi_scan", "$WIFI_ROOT_DIR/services/wifi_standard/wifi_framework/wifi_manage/wifi_scan_sa", "$WIFI_ROOT_DIR/services/wifi_standard/wifi_framework/wifi_manage/wifi_self_cure", + "$WIFI_ROOT_DIR/services/wifi_standard/wifi_framework/wifi_manage/wifi_pro", "$WIFI_ROOT_DIR/services/wifi_standard/wifi_framework/wifi_manage/wifi_sub_manage", "$WIFI_ROOT_DIR/services/wifi_standard/wifi_framework/wifi_manage/wifi_ap", "$WIFI_ROOT_DIR/services/wifi_standard/wifi_framework/wifi_manage/wifi_ap_sa", diff --git a/wifi/test/fuzztest/wifi_sta/wifistaserver_fuzzer/BUILD.gn b/wifi/test/fuzztest/wifi_sta/wifistaserver_fuzzer/BUILD.gn index a13acfce4..53cec8d02 100644 --- a/wifi/test/fuzztest/wifi_sta/wifistaserver_fuzzer/BUILD.gn +++ b/wifi/test/fuzztest/wifi_sta/wifistaserver_fuzzer/BUILD.gn @@ -46,6 +46,7 @@ ohos_fuzztest("WifiStaServerFuzzTest") { "$WIFI_ROOT_DIR/services/wifi_standard/wifi_framework/wifi_manage/wifi_scan", "$WIFI_ROOT_DIR/services/wifi_standard/wifi_framework/wifi_manage/wifi_scan_sa", "$WIFI_ROOT_DIR/services/wifi_standard/wifi_framework/wifi_manage/wifi_self_cure", + "$WIFI_ROOT_DIR/services/wifi_standard/wifi_framework/wifi_manage/wifi_pro", "$WIFI_ROOT_DIR/services/wifi_standard/wifi_framework/wifi_manage/wifi_sub_manage", "$WIFI_ROOT_DIR/services/wifi_standard/wifi_framework/wifi_manage/wifi_ap", "$WIFI_ROOT_DIR/services/wifi_standard/wifi_framework/wifi_manage/wifi_ap_sa", @@ -56,6 +57,7 @@ ohos_fuzztest("WifiStaServerFuzzTest") { "$WIFI_ROOT_DIR/services/wifi_standard/include", "$WIFI_ROOT_DIR/services/wifi_standard/wifi_framework/wifi_manage/wifi_common/wifi_country_code", "$WIFI_ROOT_DIR/services/wifi_standard/wifi_framework/wifi_manage/wifi_sta/network_select", + "$WIFI_ROOT_DIR/services/wifi_standard/wifi_framework/wifi_manage/wifi_common/network_black_list", "$WIFI_ROOT_DIR/test/fuzztest/fuzz_common_func", ] diff --git a/wifi/test/wifi_standard/non_mock/BUILD.gn b/wifi/test/wifi_standard/non_mock/BUILD.gn index 6450ec335..35c6dbf3c 100644 --- a/wifi/test/wifi_standard/non_mock/BUILD.gn +++ b/wifi/test/wifi_standard/non_mock/BUILD.gn @@ -53,6 +53,7 @@ ohos_unittest("wifi_non_mock_unittest") { "$WIFI_ROOT_DIR/services/wifi_standard/wifi_framework/wifi_manage/wifi_p2p", "$WIFI_ROOT_DIR/services/wifi_standard/wifi_framework/wifi_manage/wifi_p2p/hid2d", "$WIFI_ROOT_DIR/services/wifi_standard/wifi_framework/wifi_manage/wifi_self_cure", + "$WIFI_ROOT_DIR/services/wifi_standard/wifi_framework/wifi_manage/wifi_pro", "$WIFI_ROOT_DIR/interfaces/inner_api", "$WIFI_ROOT_DIR/frameworks/native/interfaces", "$WIFI_ROOT_DIR/services/wifi_standard/wifi_framework/wifi_manage/wifi_common/app_network_speed_limit", diff --git a/wifi/test/wifi_standard/precompiled_macro/BUILD.gn b/wifi/test/wifi_standard/precompiled_macro/BUILD.gn index a08966c17..48fbf43c6 100644 --- a/wifi/test/wifi_standard/precompiled_macro/BUILD.gn +++ b/wifi/test/wifi_standard/precompiled_macro/BUILD.gn @@ -88,6 +88,7 @@ ohos_unittest("precompiled_macro_unittest") { "$WIFI_ROOT_DIR/services/wifi_standard/wifi_framework/wifi_manage/wifi_sta/net_conf", "$WIFI_ROOT_DIR/services/wifi_standard/wifi_framework/wifi_manage/wifi_sta", "$WIFI_ROOT_DIR/services/wifi_standard/wifi_framework/wifi_manage/wifi_self_cure", + "$WIFI_ROOT_DIR/services/wifi_standard/wifi_framework/wifi_manage/wifi_pro", "$WIFI_ROOT_DIR/services/wifi_standard/wifi_framework/wifi_manage/wifi_p2p", "$WIFI_ROOT_DIR/services/wifi_standard/depends/include/hardware/libhardware/include", "$WIFI_ROOT_DIR/services/wifi_standard/depends/include/system/core/include", diff --git a/wifi/test/wifi_standard/wifi_framework/wifi_manage/unittest/BUILD.gn b/wifi/test/wifi_standard/wifi_framework/wifi_manage/unittest/BUILD.gn index 6def8415a..077ed956d 100644 --- a/wifi/test/wifi_standard/wifi_framework/wifi_manage/unittest/BUILD.gn +++ b/wifi/test/wifi_standard/wifi_framework/wifi_manage/unittest/BUILD.gn @@ -87,6 +87,7 @@ ohos_unittest("manager_unittest") { "$WIFI_ROOT_DIR/test/wifi_standard/wifi_framework/wifi_manage/wifi_ap/Mock/mock_wifi_ap_hal_interface.cpp", "$WIFI_ROOT_DIR/test/wifi_standard/wifi_framework/wifi_manage/wifi_p2p/test/Mock/mock_p2p_interface.cpp", "$WIFI_ROOT_DIR/test/wifi_standard/wifi_framework/wifi_manage/wifi_p2p/test/Mock/mock_wifi_p2p_hal_interface.cpp", + "$WIFI_ROOT_DIR/test/wifi_standard/wifi_framework/wifi_manage/wifi_pro/mock/mock_wifi_pro_interface.cpp", "$WIFI_ROOT_DIR/test/wifi_standard/wifi_framework/wifi_manage/wifi_scan/Mock/mock_scan_interface.cpp", "$WIFI_ROOT_DIR/test/wifi_standard/wifi_framework/wifi_manage/wifi_scan/Mock/mock_scan_service.cpp", "$WIFI_ROOT_DIR/test/wifi_standard/wifi_framework/wifi_manage/wifi_sta/Mock/mock_sta_interface.cpp", @@ -146,6 +147,7 @@ ohos_unittest("manager_unittest") { "$WIFI_ROOT_DIR/services/wifi_standard/wifi_framework/wifi_manage/wifi_p2p", "$WIFI_ROOT_DIR/services/wifi_standard/wifi_framework/wifi_manage/wifi_p2p/hid2d", "$WIFI_ROOT_DIR/services/wifi_standard/wifi_framework/wifi_manage/wifi_self_cure", + "$WIFI_ROOT_DIR/services/wifi_standard/wifi_framework/wifi_manage/wifi_pro", "$WIFI_ROOT_DIR/interfaces/inner_api", "$WIFI_ROOT_DIR/frameworks/native/interfaces", "$WIFI_ROOT_DIR/services/wifi_standard/wifi_framework/wifi_manage/wifi_common/app_network_speed_limit", @@ -236,6 +238,10 @@ ohos_unittest("manager_unittest") { "UT_TEST", ] + if (wifi_feature_wifi_pro_ctrl) { + defines += [ "FEATURE_WIFI_PRO_SUPPORT" ] + } + if (is_asan) { sources += [ "$WIFI_ROOT_DIR/test/wifi_standard/wifi_framework/wifi_manage/wifi_scan/Mock/mock_scan_service_new.cpp" ] } diff --git a/wifi/test/wifi_standard/wifi_framework/wifi_manage/wifi_controller/BUILD.gn b/wifi/test/wifi_standard/wifi_framework/wifi_manage/wifi_controller/BUILD.gn index 82c454b39..4479fbeb3 100644 --- a/wifi/test/wifi_standard/wifi_framework/wifi_manage/wifi_controller/BUILD.gn +++ b/wifi/test/wifi_standard/wifi_framework/wifi_manage/wifi_controller/BUILD.gn @@ -82,6 +82,7 @@ ohos_unittest("wifi_controller_unittest") { "$WIFI_ROOT_DIR/services/wifi_standard/wifi_framework/wifi_manage/wifi_p2p/hid2d", "$WIFI_ROOT_DIR/services/wifi_standard/wifi_framework/wifi_manage/wifi_scan", "$WIFI_ROOT_DIR/services/wifi_standard/wifi_framework/wifi_manage/wifi_self_cure", + "$WIFI_ROOT_DIR/services/wifi_standard/wifi_framework/wifi_manage/wifi_pro", "$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/wifi_framework/wifi_manage/wifi_sub_manage", @@ -97,7 +98,7 @@ ohos_unittest("wifi_controller_unittest") { "--coverage", ] deps = [ - "$WIFI_ROOT_DIR/base:wifi_base_without_crpc", + "$WIFI_ROOT_DIR/base:wifi_base", "$WIFI_ROOT_DIR/services/wifi_standard/wifi_framework/wifi_manage/wifi_common:wifi_common_service", "$WIFI_ROOT_DIR/services/wifi_standard/wifi_framework/wifi_manage/wifi_native:wifi_native", "$WIFI_ROOT_DIR/services/wifi_standard/wifi_framework/wifi_toolkit:wifi_toolkit", @@ -141,11 +142,14 @@ ohos_unittest("wifi_controller_unittest") { ] defines += [ "FEATURE_AP_SUPPORT", - "FEATURE_SELF_CURE_SUPPORT", "FEATURE_STA_SUPPORT", "FEATURE_P2P_SUPPORT", "STA_INSTANCE_MAX_NUM=$wifi_feature_with_sta_num", ] + + if (wifi_feature_wifi_pro_ctrl) { + defines += [ "FEATURE_WIFI_PRO_SUPPORT" ] + } part_name = "wifi" subsystem_name = "communication" } diff --git a/wifi/test/wifi_standard/wifi_framework/wifi_manage/wifi_pro/BUILD.gn b/wifi/test/wifi_standard/wifi_framework/wifi_manage/wifi_pro/BUILD.gn new file mode 100644 index 000000000..da68a9945 --- /dev/null +++ b/wifi/test/wifi_standard/wifi_framework/wifi_manage/wifi_pro/BUILD.gn @@ -0,0 +1,142 @@ +# Copyright (C) 2024-2024 Huawei Device Co., Ltd. +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +import("//build/test.gni") +import("//foundation/communication/wifi/wifi/wifi.gni") +module_output_path = "wifi/wifi_pro_unittest" +defines = [] + +config("module_private_config") { + visibility = [ ":*" ] + include_dirs = [ + "$WIFI_ROOT_DIR/test/wifi_standard/wifi_framework/wifi_manage/wifi_pro", + ] +} + +ohos_unittest("wifi_pro_unittest") { + module_out_path = module_output_path + sources = [ + "$WIFI_ROOT_DIR/frameworks/native/src/network_selection.cpp", + "$WIFI_ROOT_DIR/services/wifi_standard/wifi_framework/wifi_manage/wifi_pro/wifi_pro_service.cpp", + "$WIFI_ROOT_DIR/services/wifi_standard/wifi_framework/wifi_manage/wifi_pro/wifi_pro_state_machine.cpp", + "$WIFI_ROOT_DIR/services/wifi_standard/wifi_framework/wifi_manage/wifi_pro/wifi_pro_utils.cpp", + "$WIFI_ROOT_DIR/services/wifi_standard/wifi_framework/wifi_manage/wifi_sta/network_select/external_wifi_common_builder_manager.cpp", + "$WIFI_ROOT_DIR/services/wifi_standard/wifi_framework/wifi_manage/wifi_sta/network_select/external_wifi_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_factory.cpp", + "$WIFI_ROOT_DIR/services/wifi_standard/wifi_framework/wifi_manage/wifi_sta/network_select/network_selector_impl.cpp", + "$WIFI_ROOT_DIR/services/wifi_standard/wifi_framework/wifi_manage/wifi_sta/network_select/wifi_comparator_impl.cpp", + "$WIFI_ROOT_DIR/services/wifi_standard/wifi_framework/wifi_manage/wifi_sta/network_select/wifi_filter_impl.cpp", + "$WIFI_ROOT_DIR/services/wifi_standard/wifi_framework/wifi_manage/wifi_sta/network_select/wifi_scorer_impl.cpp", + "$WIFI_ROOT_DIR/services/wifi_standard/wifi_framework/wifi_manage/wifi_sta/network_status_history_manager.cpp", + "$WIFI_ROOT_DIR/test/wifi_standard/wifi_framework/wifi_manage/wifi_scan/Mock/mock_scan_interface.cpp", + "$WIFI_ROOT_DIR/test/wifi_standard/wifi_framework/wifi_manage/wifi_sta/Mock/mock_sta_interface.cpp", + "$WIFI_ROOT_DIR/test/wifi_standard/wifi_framework/wifi_manage/wifi_sta_sa/mock/mock_wifi_service_manager.cpp", + "$WIFI_ROOT_DIR/test/wifi_standard/wifi_framework/wifi_toolkit/unittest/Mock/mock_wifi_config_center.cpp", + "mock/mock_wifi_pro_interface.cpp", + "wifi_pro_state_machine_test.cpp", + ] + + include_dirs = [ + "//third_party/googletest/googlemock/include", + "//third_party/googletest/googletest/include", + "$WIFI_ROOT_DIR/interfaces/inner_api", + "$WIFI_ROOT_DIR/frameworks/native/include", + "$WIFI_ROOT_DIR/frameworks/native/interfaces", + "$WIFI_ROOT_DIR/services/wifi_standard/interface", + "$WIFI_ROOT_DIR/base/cRPC/include", + "$WIFI_ROOT_DIR/base/utils", + "$WIFI_ROOT_DIR/base/state_machine/include", + "$WIFI_ROOT_DIR/utils/inc", + "$WIFI_ROOT_DIR/services/wifi_standard/include", + "$WIFI_ROOT_DIR/services/wifi_standard/wifi_framework/wifi_toolkit/include", + "$WIFI_ROOT_DIR/services/wifi_standard/wifi_framework/wifi_toolkit/net_helper", + "$WIFI_ROOT_DIR/services/wifi_standard/wifi_framework/wifi_toolkit/log", + "$WIFI_ROOT_DIR/services/wifi_standard/wifi_framework/wifi_toolkit/config", + "$WIFI_ROOT_DIR/services/wifi_standard/wifi_framework/wifi_toolkit/utils", + "$WIFI_ROOT_DIR/services/wifi_standard/wifi_framework/wifi_manage", + "$WIFI_ROOT_DIR/services/wifi_standard/wifi_framework/wifi_manage/wifi_common", + "$WIFI_ROOT_DIR/services/wifi_standard/wifi_framework/wifi_manage/wifi_sta", + "$WIFI_ROOT_DIR/services/wifi_standard/wifi_framework/wifi_manage/wifi_scan", + "$WIFI_ROOT_DIR/services/wifi_standard/wifi_framework/wifi_manage/wifi_self_cure", + "$WIFI_ROOT_DIR/services/wifi_standard/wifi_framework/wifi_manage/wifi_ap", + "$WIFI_ROOT_DIR/services/wifi_standard/wifi_framework/wifi_manage/wifi_common/wifi_country_code", + "$WIFI_ROOT_DIR/services/wifi_standard/wifi_framework/wifi_manage/wifi_p2p", + "$WIFI_ROOT_DIR/services/wifi_standard/wifi_framework/wifi_manage/wifi_sta/network_select", + "$WIFI_ROOT_DIR/services/wifi_standard/wifi_framework/wifi_manage/wifi_controller", + "$WIFI_ROOT_DIR/services/wifi_standard/wifi_framework/wifi_manage/wifi_sub_manage", + "$WIFI_ROOT_DIR/services/wifi_standard/wifi_framework/wifi_manage/wifi_pro", + "$WIFI_ROOT_DIR/services/wifi_standard/wifi_framework/wifi_manage/wifi_common/network_black_list", + "$WIFI_ROOT_DIR/services/wifi_standard/wifi_framework/wifi_manage/wifi_native/common", + "$WIFI_ROOT_DIR/services/wifi_standard/wifi_framework/wifi_manage/wifi_native/wifi_hal_interface", + "$WIFI_ROOT_DIR/test/wifi_standard/wifi_framework/wifi_toolkit/unittest/Mock", + ] + + deps = [ + "$WIFI_ROOT_DIR/base:wifi_base", + "$WIFI_ROOT_DIR/services/wifi_standard/wifi_framework/wifi_manage/wifi_common:wifi_common_service", + "$WIFI_ROOT_DIR/services/wifi_standard/wifi_framework/wifi_manage/wifi_native:wifi_native", + "$WIFI_ROOT_DIR/services/wifi_standard/wifi_framework/wifi_toolkit:wifi_toolkit", + "$WIFI_ROOT_DIR/utils:wifi_utils", + "//third_party/googletest:gmock_main", + "//third_party/googletest:gtest_main", + ] + + external_deps = [ + "ability_base:want", + "ability_base:zuri", + "ability_runtime:ability_manager", + "ability_runtime:app_manager", + "ability_runtime:extension_manager", + "ability_runtime:wantagent_innerkits", + "access_token:libaccesstoken_sdk", + "access_token:libtokenid_sdk", + "bundle_framework:appexecfwk_base", + "bundle_framework:appexecfwk_core", + "c_utils:utils", + "cellular_data:tel_cellular_data_api", + "core_service:tel_core_service_api", + "data_share:datashare_consumer", + "dhcp:dhcp_sdk", + "hilog:libhilog", + "init:libbegetutil", + "ipc:ipc_single", + "jsoncpp:jsoncpp", + "libxml2:libxml2", + "netmanager_base:net_conn_manager_if", + "netmanager_base:net_native_manager_if", + "netmanager_base:net_stats_manager_if", + "netstack:http_client", + "samgr:samgr_proxy", + "time_service:time_client", + ] + + if (wifi_ffrt_enable) { + external_deps += [ "ffrt:libffrt" ] + defines += [ "WIFI_FFRT_ENABLE" ] + } + + defines += [ + "AP_INSTANCE_MAX_NUM=$wifi_feature_with_ap_num", + "private=public", + "SUPPORT_RANDOM_MAC_ADDR", + "FEATURE_SELF_CURE_SUPPORT", + ] + + if (wifi_feature_wifi_pro_ctrl) { + defines += [ "FEATURE_WIFI_PRO_SUPPORT" ] + } + part_name = "wifi" + subsystem_name = "communication" +} diff --git a/wifi/test/wifi_standard/wifi_framework/wifi_manage/wifi_pro/mock/mock_wifi_pro_interface.cpp b/wifi/test/wifi_standard/wifi_framework/wifi_manage/wifi_pro/mock/mock_wifi_pro_interface.cpp new file mode 100644 index 000000000..cb8029c94 --- /dev/null +++ b/wifi/test/wifi_standard/wifi_framework/wifi_manage/wifi_pro/mock/mock_wifi_pro_interface.cpp @@ -0,0 +1,72 @@ +/* + * Copyright (C) 2024-2024 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 "wifi_logger.h" +#include "wifi_pro_interface.h" + +namespace OHOS { +namespace Wifi { +DEFINE_WIFILOG_LABEL("WifiPrWifiProInterfaceoService"); + +WifiProInterface::WifiProInterface(int32_t instId) : instId_(instId) +{ + WIFI_LOGI("Enter WifiProInterface"); +} + +WifiProInterface::~WifiProInterface() +{ + WIFI_LOGI("Enter ~WifiProInterface"); +} + +ErrCode WifiProInterface::InitWifiProService() +{ + WIFI_LOGI("Enter WifiProInterface::InitWifiProService"); + return WIFI_OPT_SUCCESS; +} + +void WifiProInterface::InitCallback() +{ + using namespace std::placeholders; + staCallback_.callbackModuleName = "WifiProService"; + staCallback_.OnStaConnChanged = [this](OperateResState state, const WifiLinkedInfo &linkedInfo, int32_t instId) { + this->DealStaConnChanged(state, linkedInfo, instId); + }; + staCallback_.OnStaRssiLevelChanged = [this](int32_t rssi, int32_t instId) { + this->DealRssiLevelChanged(rssi, instId); + }; +} + +void WifiProInterface::DealStaConnChanged(OperateResState state, const WifiLinkedInfo &info, int32_t instId) +{ + WIFI_LOGI("Enter WifiProInterface::DealStaConnChanged"); +} + +void WifiProInterface::DealRssiLevelChanged(int32_t rssi, int32_t instId) +{ + WIFI_LOGI("Enter WifiProInterface::DealRssiLevelChanged"); +} + +void WifiProInterface::DealScanResult(const std::vector &results) +{ + WIFI_LOGI("Enter WifiProInterface::DealScanResult"); +} + +StaServiceCallback WifiProInterface::GetStaCallback() const +{ + return staCallback_; +} + +} // namespace Wifi +} // namespace OHOS diff --git a/wifi/test/wifi_standard/wifi_framework/wifi_manage/wifi_pro/wifi_pro_state_machine_test.cpp b/wifi/test/wifi_standard/wifi_framework/wifi_manage/wifi_pro/wifi_pro_state_machine_test.cpp new file mode 100644 index 000000000..4cb626e0a --- /dev/null +++ b/wifi/test/wifi_standard/wifi_framework/wifi_manage/wifi_pro/wifi_pro_state_machine_test.cpp @@ -0,0 +1,134 @@ +/* + * Copyright (C) 2024 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 +#include +#include +#include "define.h" +#include "wifi_log.h" +#include "wifi_errcode.h" +#include "state_machine.h" +#include "wifi_pro_common.h" +#include "iscan_service.h" +#include "wifi_logger.h" +#include "wifi_msg.h" +#include "wifi_pro_state_machine.h" +#include "wifi_service_manager.h" +#include "wifi_pro_utils.h" +#include "net_conn_client.h" +#include "mock_wifi_config_center.h" + +using ::testing::_; +using ::testing::AtLeast; +using ::testing::DoAll; +using ::testing::Eq; +using ::testing::Return; +using ::testing::SetArgReferee; +using ::testing::StrEq; +using ::testing::TypedEq; +using ::testing::ext::TestSize; + +namespace OHOS { +namespace Wifi { + +class WifiProStateMachineTest : public testing::Test { +public: + static void SetUpTestCase() {} + static void TearDownTestCase() {} + virtual void SetUp() + { + pWifiProStateMachine_ = std::make_unique(); + pWifiProStateMachine_->Initialize(); + } + + virtual void TearDown() + { + if (pWifiProStateMachine_->pCurrWifiInfo_ != nullptr) { + pWifiProStateMachine_->pCurrWifiInfo_.reset(); + } + + if (pWifiProStateMachine_->pCurrWifiDeviceConfig_ != nullptr) { + pWifiProStateMachine_->pCurrWifiDeviceConfig_.reset(); + } + + pWifiProStateMachine_.reset(); + } + + std::unique_ptr pWifiProStateMachine_; +}; + +HWTEST_F(WifiProStateMachineTest, HandleRssiChangedInLinkMonitorStateTest, TestSize.Level1) +{ + InternalMessagePtr msg = std::make_shared(); + msg->SetMessageName(EVENT_WIFI_RSSI_CHANGED); + msg->SetParam1(-30); + auto pWiFiLinkMonitorState = pWifiProStateMachine_->pWifiLinkMonitorState_; + pWiFiLinkMonitorState->rssiLevel2Or3ScanedCounter_ = 1; + pWiFiLinkMonitorState->HandleRssiChangedInMonitor(msg); + EXPECT_EQ(pWiFiLinkMonitorState->rssiLevel2Or3ScanedCounter_, 1); +} + +HWTEST_F(WifiProStateMachineTest, IsReachWifiScanThresholdTest01, TestSize.Level1) +{ + // wifi signal 4 bars + int32_t signalLevel = SIG_LEVEL_4; + int32_t ret = pWifiProStateMachine_->IsReachWifiScanThreshold(signalLevel); + EXPECT_EQ(ret, false); +} + +HWTEST_F(WifiProStateMachineTest, IsReachWifiScanThresholdTest02, TestSize.Level1) +{ + // The wifi signal is lower than 3 bars + int32_t signalLevel = SIG_LEVEL_2; + int32_t ret = pWifiProStateMachine_->IsReachWifiScanThreshold(signalLevel); + EXPECT_EQ(ret, true); +} + +HWTEST_F(WifiProStateMachineTest, IsReachWifiScanThresholdTest03, TestSize.Level1) +{ + // The wifi signal is equal to 3 bars, and there are switching records within 14 days + int32_t signalLevel = SIG_LEVEL_3; + WifiLinkedInfo wifiLinkedInfo; + wifiLinkedInfo.supplicantState = SupplicantState::INVALID; + EXPECT_CALL(WifiConfigCenter::GetInstance(), GetLinkedInfo(_, _)) + .WillRepeatedly(DoAll(SetArgReferee<0>(wifiLinkedInfo), Return(0))); + pWifiProStateMachine_->pCurrWifiInfo_ = std::make_shared(wifiLinkedInfo); + + WifiDeviceConfig wifiDeviceConfig; + wifiDeviceConfig.lastTrySwitchWifiTimestamp = WifiProUtils::GetCurrentTimeMs(); + pWifiProStateMachine_->pCurrWifiDeviceConfig_ = std::make_shared(wifiDeviceConfig); + bool ret = pWifiProStateMachine_->IsReachWifiScanThreshold(signalLevel); + EXPECT_EQ(ret, true); +} + +HWTEST_F(WifiProStateMachineTest, IsReachWifiScanThresholdTest04, TestSize.Level1) +{ + // The wifi signal is equal to 3 bars, and there is no connection record within 14 days. + int32_t signalLevel = SIG_LEVEL_3; + WifiLinkedInfo wifiLinkedInfo; + wifiLinkedInfo.supplicantState = SupplicantState::INVALID; + EXPECT_CALL(WifiConfigCenter::GetInstance(), GetLinkedInfo(_, _)) + .WillRepeatedly(DoAll(SetArgReferee<0>(wifiLinkedInfo), Return(0))); + pWifiProStateMachine_->pCurrWifiInfo_ = std::make_shared(wifiLinkedInfo); + + WifiDeviceConfig wifiDeviceConfig; + wifiDeviceConfig.lastTrySwitchWifiTimestamp = 0; + pWifiProStateMachine_->pCurrWifiDeviceConfig_ = std::make_shared(wifiDeviceConfig); + bool ret = pWifiProStateMachine_->IsReachWifiScanThreshold(signalLevel); + EXPECT_EQ(ret, false); +} +} // namespace Wifi +} // namespace OHOS \ No newline at end of file diff --git a/wifi/test/wifi_standard/wifi_framework/wifi_manage/wifi_scan/BUILD.gn b/wifi/test/wifi_standard/wifi_framework/wifi_manage/wifi_scan/BUILD.gn index b2c5a1721..03f0f9369 100644 --- a/wifi/test/wifi_standard/wifi_framework/wifi_manage/wifi_scan/BUILD.gn +++ b/wifi/test/wifi_standard/wifi_framework/wifi_manage/wifi_scan/BUILD.gn @@ -72,6 +72,7 @@ ohos_unittest("wifi_scan_unittest") { "$WIFI_ROOT_DIR/services/wifi_standard/wifi_framework/wifi_manage/wifi_sta/net_conf", "$WIFI_ROOT_DIR/services/wifi_standard/wifi_framework/wifi_manage/wifi_sta", "$WIFI_ROOT_DIR/services/wifi_standard/wifi_framework/wifi_manage/wifi_self_cure", + "$WIFI_ROOT_DIR/services/wifi_standard/wifi_framework/wifi_manage/wifi_pro", "$WIFI_ROOT_DIR/services/wifi_standard/wifi_framework/wifi_manage/wifi_p2p", "$WIFI_ROOT_DIR/services/wifi_standard/wifi_framework/wifi_manage/wifi_sub_manage", "//base/hiviewdfx/hilog/interfaces/native/innerkits/include", 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 c6f00e29a..e5e568811 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 @@ -21,7 +21,6 @@ defines += [ "OHOS_WIFI_STA_TEST" ] config("module_private_config") { visibility = [ ":*" ] include_dirs = [ - "//commonlibrary/c_utils/base/include", "$WIFI_ROOT_DIR/test/wifi_standard/wifi_framework/wifi_manage/wifi_sta", ] } @@ -35,6 +34,7 @@ local_base_sources = [ "$WIFI_ROOT_DIR/services/wifi_standard/wifi_framework/wifi_manage/wifi_common/app_network_speed_limit/app_network_speed_limit_service.cpp", "$WIFI_ROOT_DIR/services/wifi_standard/wifi_framework/wifi_manage/wifi_common/app_network_speed_limit/speed_limit_configs_writer.cpp", "$WIFI_ROOT_DIR/services/wifi_standard/wifi_framework/wifi_manage/wifi_common/block_connect_service.cpp", + "$WIFI_ROOT_DIR/services/wifi_standard/wifi_framework/wifi_manage/wifi_common/network_black_list/network_black_list_manager.cpp", "$WIFI_ROOT_DIR/services/wifi_standard/wifi_framework/wifi_manage/wifi_common/wifi_app_state_aware.cpp", "$WIFI_ROOT_DIR/services/wifi_standard/wifi_framework/wifi_manage/wifi_common/wifi_auth_center.cpp", "$WIFI_ROOT_DIR/services/wifi_standard/wifi_framework/wifi_manage/wifi_common/wifi_channel_helper.cpp", @@ -105,9 +105,11 @@ local_base_include_dirs = [ "$WIFI_ROOT_DIR/services/wifi_standard/wifi_framework/wifi_manage/wifi_native/client/idl_client/idl_interface", "$WIFI_ROOT_DIR/services/wifi_standard/wifi_framework/wifi_manage/wifi_ap", "$WIFI_ROOT_DIR/services/wifi_standard/wifi_framework/wifi_manage/wifi_common/wifi_country_code", + "$WIFI_ROOT_DIR/services/wifi_standard/wifi_framework/wifi_manage/wifi_common/network_black_list", "$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_self_cure", + "$WIFI_ROOT_DIR/services/wifi_standard/wifi_framework/wifi_manage/wifi_pro", "$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/wifi_framework/wifi_manage/wifi_controller", @@ -289,6 +291,10 @@ ohos_unittest("wifi_selfcure_unittest") { "FEATURE_AP_SUPPORT", "FEATURE_STA_SUPPORT", ] + + if (wifi_feature_wifi_pro_ctrl) { + defines += [ "FEATURE_WIFI_PRO_SUPPORT" ] + } part_name = "wifi" subsystem_name = "communication" } diff --git a/wifi/test/wifi_standard/wifi_framework/wifi_manage/wifi_sta/Mock/mock_sta_interface.cpp b/wifi/test/wifi_standard/wifi_framework/wifi_manage/wifi_sta/Mock/mock_sta_interface.cpp index cb5e92615..a80f07ca0 100644 --- a/wifi/test/wifi_standard/wifi_framework/wifi_manage/wifi_sta/Mock/mock_sta_interface.cpp +++ b/wifi/test/wifi_standard/wifi_framework/wifi_manage/wifi_sta/Mock/mock_sta_interface.cpp @@ -41,7 +41,7 @@ ErrCode StaInterface::DisableStaService() return WIFI_OPT_SUCCESS; } -ErrCode StaInterface::ConnectToNetwork(int networkId) +ErrCode StaInterface::ConnectToNetwork(int networkId, int type) { LOGI("Enter Connect.\n"); return WIFI_OPT_SUCCESS; diff --git a/wifi/test/wifi_standard/wifi_framework/wifi_manage/wifi_sta/Mock/mock_sta_service.h b/wifi/test/wifi_standard/wifi_framework/wifi_manage/wifi_sta/Mock/mock_sta_service.h index d88638bd6..417ffbe0a 100644 --- a/wifi/test/wifi_standard/wifi_framework/wifi_manage/wifi_sta/Mock/mock_sta_service.h +++ b/wifi/test/wifi_standard/wifi_framework/wifi_manage/wifi_sta/Mock/mock_sta_service.h @@ -28,7 +28,7 @@ public: MOCK_METHOD0(EnableStaService, ErrCode()); MOCK_CONST_METHOD0(DisableStaService, ErrCode()); MOCK_CONST_METHOD1(ConnectToDevice, ErrCode(const WifiDeviceConfig &config)); - MOCK_CONST_METHOD1(ConnectToNetwork, ErrCode(int networkId)); + MOCK_CONST_METHOD2(ConnectToNetwork, ErrCode(int networkId, int type)); MOCK_CONST_METHOD0(ReConnect, ErrCode()); MOCK_CONST_METHOD0(Disconnect, ErrCode()); MOCK_CONST_METHOD0(ReAssociate, ErrCode()); diff --git a/wifi/test/wifi_standard/wifi_framework/wifi_manage/wifi_sta/self_cure_state_machine_test.cpp b/wifi/test/wifi_standard/wifi_framework/wifi_manage/wifi_sta/self_cure_state_machine_test.cpp index 14dde287a..81db28703 100644 --- a/wifi/test/wifi_standard/wifi_framework/wifi_manage/wifi_sta/self_cure_state_machine_test.cpp +++ b/wifi/test/wifi_standard/wifi_framework/wifi_manage/wifi_sta/self_cure_state_machine_test.cpp @@ -883,10 +883,10 @@ public: pSelfCureStateMachine->pInternetSelfCureState->currentRssi = MIN_VAL_LEVEL_4; pSelfCureStateMachine->pInternetSelfCureState->SelfCureForRandMacReassoc(requestCureLevel); - EXPECT_CALL(*pMockStaService, ConnectToNetwork(_)).WillRepeatedly(Return(WIFI_OPT_FAILED)); + EXPECT_CALL(*pMockStaService, ConnectToNetwork(_, _)).WillRepeatedly(Return(WIFI_OPT_FAILED)); pSelfCureStateMachine->pInternetSelfCureState->SelfCureForRandMacReassoc(requestCureLevel); - EXPECT_CALL(*pMockStaService, ConnectToNetwork(_)).WillRepeatedly(Return(WIFI_OPT_SUCCESS)); + EXPECT_CALL(*pMockStaService, ConnectToNetwork(_, _)).WillRepeatedly(Return(WIFI_OPT_SUCCESS)); pSelfCureStateMachine->pInternetSelfCureState->SelfCureForRandMacReassoc(requestCureLevel); } @@ -1049,10 +1049,10 @@ public: pSelfCureStateMachine->useWithRandMacAddress = FAC_MAC_REASSOC; pSelfCureStateMachine->pInternetSelfCureState->HandleSelfCureFailedForRandMacReassoc(); - EXPECT_CALL(*pMockStaService, ConnectToNetwork(_)).WillRepeatedly(Return(WIFI_OPT_FAILED)); + EXPECT_CALL(*pMockStaService, ConnectToNetwork(_, _)).WillRepeatedly(Return(WIFI_OPT_FAILED)); pSelfCureStateMachine->pInternetSelfCureState->HandleSelfCureFailedForRandMacReassoc(); - EXPECT_CALL(*pMockStaService, ConnectToNetwork(_)).WillRepeatedly(Return(WIFI_OPT_SUCCESS)); + EXPECT_CALL(*pMockStaService, ConnectToNetwork(_, _)).WillRepeatedly(Return(WIFI_OPT_SUCCESS)); pSelfCureStateMachine->pInternetSelfCureState->HandleSelfCureFailedForRandMacReassoc(); pSelfCureStateMachine->useWithRandMacAddress = RAND_MAC_REASSOC; @@ -1529,10 +1529,10 @@ public: Return(MODE_STATE_CLOSE)); pSelfCureStateMachine->pDisconnectedMonitorState->HandleResetConnectNetwork(msg); - EXPECT_CALL(*pMockStaService, ConnectToNetwork(_)).WillRepeatedly(Return(WIFI_OPT_FAILED)); + EXPECT_CALL(*pMockStaService, ConnectToNetwork(_, _)).WillRepeatedly(Return(WIFI_OPT_FAILED)); pSelfCureStateMachine->pDisconnectedMonitorState->HandleResetConnectNetwork(msg); - EXPECT_CALL(*pMockStaService, ConnectToNetwork(_)).WillRepeatedly(Return(WIFI_OPT_SUCCESS)); + EXPECT_CALL(*pMockStaService, ConnectToNetwork(_, _)).WillRepeatedly(Return(WIFI_OPT_SUCCESS)); pSelfCureStateMachine->pDisconnectedMonitorState->HandleResetConnectNetwork(msg); } diff --git a/wifi/test/wifi_standard/wifi_framework/wifi_manage/wifi_sta/sta_interface_test.cpp b/wifi/test/wifi_standard/wifi_framework/wifi_manage/wifi_sta/sta_interface_test.cpp index 4227886ec..fd64f2af5 100644 --- a/wifi/test/wifi_standard/wifi_framework/wifi_manage/wifi_sta/sta_interface_test.cpp +++ b/wifi/test/wifi_standard/wifi_framework/wifi_manage/wifi_sta/sta_interface_test.cpp @@ -93,14 +93,14 @@ public: void ConnectToNetworkIdSuceess() { int networkId = 0; - EXPECT_CALL(*pMockStaService, ConnectToNetwork(networkId)).WillRepeatedly(Return(WIFI_OPT_SUCCESS)); + EXPECT_CALL(*pMockStaService, ConnectToNetwork(networkId, _)).WillRepeatedly(Return(WIFI_OPT_SUCCESS)); EXPECT_TRUE(pStaInterface->ConnectToNetwork(0) == WIFI_OPT_SUCCESS); } void ConnectToNetworkIdFail1() { int networkId = 0; - EXPECT_CALL(*pMockStaService, ConnectToNetwork(networkId)).WillRepeatedly(Return(WIFI_OPT_FAILED)); + EXPECT_CALL(*pMockStaService, ConnectToNetwork(networkId, _)).WillRepeatedly(Return(WIFI_OPT_FAILED)); EXPECT_TRUE(pStaInterface->ConnectToNetwork(0) == WIFI_OPT_FAILED); } diff --git a/wifi/test/wifi_standard/wifi_framework/wifi_manage/wifi_sta_new/BUILD.gn b/wifi/test/wifi_standard/wifi_framework/wifi_manage/wifi_sta_new/BUILD.gn index 4f1c0061c..aad1fd8e1 100644 --- a/wifi/test/wifi_standard/wifi_framework/wifi_manage/wifi_sta_new/BUILD.gn +++ b/wifi/test/wifi_standard/wifi_framework/wifi_manage/wifi_sta_new/BUILD.gn @@ -1,158 +1,160 @@ -# 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. - -import("//build/test.gni") -import("//foundation/communication/wifi/wifi/wifi.gni") - -################################################################################ - -module_output_path = "wifi/wifi_sta_new_test" - -config("module_private_config") { - visibility = [ ":*" ] - include_dirs = [] -} - -ohos_unittest("wifi_sta_new_unittest") { - module_out_path = module_output_path - sources = [ - "$WIFI_ROOT_DIR/frameworks/native/src/network_selection.cpp", - "$WIFI_ROOT_DIR/services/wifi_standard/wifi_framework/wifi_manage/wifi_sta/network_select/external_wifi_common_builder_manager.cpp", - "$WIFI_ROOT_DIR/services/wifi_standard/wifi_framework/wifi_manage/wifi_sta/network_select/external_wifi_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_factory.cpp", - "$WIFI_ROOT_DIR/services/wifi_standard/wifi_framework/wifi_manage/wifi_sta/network_select/network_selector_impl.cpp", - "$WIFI_ROOT_DIR/services/wifi_standard/wifi_framework/wifi_manage/wifi_sta/network_select/wifi_comparator_impl.cpp", - "$WIFI_ROOT_DIR/services/wifi_standard/wifi_framework/wifi_manage/wifi_sta/network_select/wifi_filter_impl.cpp", - "$WIFI_ROOT_DIR/services/wifi_standard/wifi_framework/wifi_manage/wifi_sta/network_select/wifi_scorer_impl.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_app_acceleration.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", - "$WIFI_ROOT_DIR/services/wifi_standard/wifi_framework/wifi_manage/wifi_sta/sta_saved_device_appraisal.cpp", - "$WIFI_ROOT_DIR/services/wifi_standard/wifi_framework/wifi_manage/wifi_sta/sta_service.cpp", - "$WIFI_ROOT_DIR/services/wifi_standard/wifi_framework/wifi_manage/wifi_sta/sta_state_machine.cpp", - "$WIFI_ROOT_DIR/test/wifi_standard/wifi_framework/wifi_manage/wifi_native/Mock/mock_wifi_sta_hal_interface.cpp", - "$WIFI_ROOT_DIR/test/wifi_standard/wifi_framework/wifi_manage/wifi_native/Mock/mock_wifi_supplicant_hal_interface.cpp", - "$WIFI_ROOT_DIR/test/wifi_standard/wifi_framework/wifi_manage/wifi_sta/Mock/mock_if_config.cpp", - "$WIFI_ROOT_DIR/test/wifi_standard/wifi_framework/wifi_manage/wifi_sta/Mock/mock_wifi_settings.cpp", - "$WIFI_ROOT_DIR/test/wifi_standard/wifi_framework/wifi_toolkit/unittest/Mock/mock_wifi_config_center.cpp", - "network_status_history_manager_test.cpp", - "sta_app_acceleration_test.cpp", - "sta_auto_connect_service_test.cpp", - "sta_interface_test.cpp", - "sta_monitor_test.cpp", - "wifi_scorer_impl_test.cpp", - ] - - include_dirs = [ - "$WIFI_ROOT_DIR/interfaces/inner_api", - "$WIFI_ROOT_DIR/frameworks/native/interfaces", - "$WIFI_ROOT_DIR/services/wifi_standard/sdk/include", - "$WIFI_ROOT_DIR/base/cRPC/include", - "$WIFI_ROOT_DIR/services/wifi_standard/wifi_framework/wifi_toolkit/include", - "$WIFI_ROOT_DIR/services/wifi_standard/wifi_framework/wifi_toolkit/net_helper", - "$WIFI_ROOT_DIR/services/wifi_standard/wifi_framework/wifi_toolkit/log", - "$WIFI_ROOT_DIR/services/wifi_standard/wifi_framework/wifi_toolkit/config", - "$WIFI_ROOT_DIR/services/wifi_standard/wifi_framework/wifi_toolkit/utils", - "$WIFI_ROOT_DIR/services/wifi_standard/wifi_framework/wifi_manage/wifi_common", - "$WIFI_ROOT_DIR/services/wifi_standard/wifi_framework/wifi_manage/wifi_scan", - "$WIFI_ROOT_DIR/test/wifi_standard/wifi_framework/wifi_manage/wifi_scan", - "$WIFI_ROOT_DIR/test/wifi_standard/wifi_framework/wifi_manage/wifi_sta/Mock", - "$WIFI_ROOT_DIR/test/wifi_standard/wifi_framework/wifi_toolkit/unittest/Mock", - "$WIFI_ROOT_DIR/services/wifi_standard/wifi_framework/wifi_manage/", - "$WIFI_ROOT_DIR/services/wifi_standard/wifi_framework/wifi_manage/wifi_native/common", - "$WIFI_ROOT_DIR/services/wifi_standard/wifi_framework/wifi_manage/wifi_native/wifi_hal_interface", - "$WIFI_ROOT_DIR/services/wifi_standard/wifi_framework/wifi_manage/wifi_native/client/idl_client", - "$WIFI_ROOT_DIR/services/wifi_standard/wifi_framework/wifi_manage/wifi_native/client/idl_client/idl_interface", - "$WIFI_ROOT_DIR/services/wifi_standard/wifi_framework/wifi_manage/wifi_sta/net_conf", - "$WIFI_ROOT_DIR/services/wifi_standard/wifi_framework/wifi_manage/wifi_sta", - "$WIFI_ROOT_DIR/services/wifi_standard/wifi_framework/wifi_manage/wifi_self_cure", - "$WIFI_ROOT_DIR/services/wifi_standard/wifi_framework/wifi_manage/wifi_p2p", - "$WIFI_ROOT_DIR/services/wifi_standard/depends/include/hardware/libhardware/include", - "$WIFI_ROOT_DIR/services/wifi_standard/depends/include/system/core/include", - "$WIFI_ROOT_DIR/services/wifi_standard/depends/include/frameworks/native/include", - "$WIFI_ROOT_DIR/services/wifi_standard/depends/include/system/core/libutils/include", - "$WIFI_ROOT_DIR/services/wifi_standard/depends/include/system/core/base/include", - "$WIFI_ROOT_DIR/services/wifi_standard/depends/include/system/libbase/include", - "$WIFI_ROOT_DIR/services/wifi_standard/depends/include/system/core/libnetutils/include/netutils", - "$WIFI_ROOT_DIR/services/wifi_standard/wifi_framework/wifi_manage/wifi_sta/network_select", - "$WIFI_ROOT_DIR/services/wifi_standard/wifi_framework/wifi_manage/wifi_ap", - "$WIFI_ROOT_DIR/services/wifi_standard/wifi_framework/wifi_manage/wifi_common/wifi_country_code", - "$WIFI_ROOT_DIR/services/wifi_standard/wifi_framework/wifi_manage/wifi_common/wifi_network_stats", - "//third_party/googletest/googlemock/include", - "//third_party/googletest/googletest/include", - "$WIFI_ROOT_DIR/services/wifi_standard/include", - "$WIFI_ROOT_DIR/utils/inc", - "$WIFI_ROOT_DIR/test/wifi_standard/wifi_framework/wifi_manage/unittest/Mock", - "$WIFI_ROOT_DIR/base/utils", - "$WIFI_ROOT_DIR/services/wifi_standard/wifi_framework/wifi_manage/wifi_common/app_network_speed_limit", - "$WIFI_ROOT_DIR/test/wifi_standard/wifi_framework/wifi_manage/wifi_native/Mock", - ] - - deps = [ - "$WIFI_ROOT_DIR/base:wifi_base", - "$WIFI_ROOT_DIR/services/wifi_standard/wifi_framework/wifi_manage:wifi_manager_service", - "$WIFI_ROOT_DIR/services/wifi_standard/wifi_framework/wifi_manage/wifi_common:wifi_common_service", - "$WIFI_ROOT_DIR/services/wifi_standard/wifi_framework/wifi_toolkit:wifi_toolkit", - "$WIFI_ROOT_DIR/utils:wifi_utils", - "//third_party/googletest:gmock_main", - "//third_party/googletest:gtest_main", - ] - - deps += [ - "$WIFI_ROOT_DIR/services/wifi_standard/wifi_framework/wifi_manage:wifi_device_ability", - "$WIFI_ROOT_DIR/services/wifi_standard/wifi_framework/wifi_manage:wifi_hotspot_ability", - "$WIFI_ROOT_DIR/services/wifi_standard/wifi_framework/wifi_manage:wifi_scan_ability", - "$WIFI_ROOT_DIR/services/wifi_standard/wifi_framework/wifi_manage/wifi_native:wifi_native", - "$WIFI_ROOT_DIR/services/wifi_standard/wifi_framework/wifi_manage/wifi_sta:wifi_sta_service", - ] - - ldflags = [ - "-fPIC", - "--coverage", - "-Wl,-E", - ] - - external_deps = [ - "ability_base:want", - "ability_base:zuri", - "ability_runtime:ability_manager", - "ability_runtime:app_manager", - "ability_runtime:wantagent_innerkits", - "bundle_framework:appexecfwk_base", - "bundle_framework:appexecfwk_core", - "c_utils:utils", - "cellular_data:tel_cellular_data_api", - "core_service:tel_core_service_api", - "dhcp:dhcp_sdk", - "hilog:libhilog", - "init:libbegetutil", - "ipc:ipc_single", - "netmanager_base:net_conn_manager_if", - "time_service:time_client", - ] - - defines = [ - "private = public", - "protected = public", - "SUPPORT_SCAN_CONTROL", - "SUPPORT_LOCAL_RANDOM_MAC", - ] - - part_name = "wifi" - subsystem_name = "communication" - testonly = true -} +# 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. + +import("//build/test.gni") +import("//foundation/communication/wifi/wifi/wifi.gni") + +################################################################################ + +module_output_path = "wifi/wifi_sta_new_test" + +config("module_private_config") { + visibility = [ ":*" ] + include_dirs = [] +} + +ohos_unittest("wifi_sta_new_unittest") { + module_out_path = module_output_path + sources = [ + "$WIFI_ROOT_DIR/frameworks/native/src/network_selection.cpp", + "$WIFI_ROOT_DIR/services/wifi_standard/wifi_framework/wifi_manage/wifi_sta/network_select/external_wifi_common_builder_manager.cpp", + "$WIFI_ROOT_DIR/services/wifi_standard/wifi_framework/wifi_manage/wifi_sta/network_select/external_wifi_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_factory.cpp", + "$WIFI_ROOT_DIR/services/wifi_standard/wifi_framework/wifi_manage/wifi_sta/network_select/network_selector_impl.cpp", + "$WIFI_ROOT_DIR/services/wifi_standard/wifi_framework/wifi_manage/wifi_sta/network_select/wifi_comparator_impl.cpp", + "$WIFI_ROOT_DIR/services/wifi_standard/wifi_framework/wifi_manage/wifi_sta/network_select/wifi_filter_impl.cpp", + "$WIFI_ROOT_DIR/services/wifi_standard/wifi_framework/wifi_manage/wifi_sta/network_select/wifi_scorer_impl.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_app_acceleration.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", + "$WIFI_ROOT_DIR/services/wifi_standard/wifi_framework/wifi_manage/wifi_sta/sta_saved_device_appraisal.cpp", + "$WIFI_ROOT_DIR/services/wifi_standard/wifi_framework/wifi_manage/wifi_sta/sta_service.cpp", + "$WIFI_ROOT_DIR/services/wifi_standard/wifi_framework/wifi_manage/wifi_sta/sta_state_machine.cpp", + "$WIFI_ROOT_DIR/test/wifi_standard/wifi_framework/wifi_manage/wifi_native/Mock/mock_wifi_sta_hal_interface.cpp", + "$WIFI_ROOT_DIR/test/wifi_standard/wifi_framework/wifi_manage/wifi_native/Mock/mock_wifi_supplicant_hal_interface.cpp", + "$WIFI_ROOT_DIR/test/wifi_standard/wifi_framework/wifi_manage/wifi_sta/Mock/mock_if_config.cpp", + "$WIFI_ROOT_DIR/test/wifi_standard/wifi_framework/wifi_manage/wifi_sta/Mock/mock_wifi_settings.cpp", + "$WIFI_ROOT_DIR/test/wifi_standard/wifi_framework/wifi_toolkit/unittest/Mock/mock_wifi_config_center.cpp", + "network_status_history_manager_test.cpp", + "sta_app_acceleration_test.cpp", + "sta_auto_connect_service_test.cpp", + "sta_interface_test.cpp", + "sta_monitor_test.cpp", + "wifi_scorer_impl_test.cpp", + ] + + include_dirs = [ + "$WIFI_ROOT_DIR/interfaces/inner_api", + "$WIFI_ROOT_DIR/frameworks/native/interfaces", + "$WIFI_ROOT_DIR/services/wifi_standard/sdk/include", + "$WIFI_ROOT_DIR/base/cRPC/include", + "$WIFI_ROOT_DIR/services/wifi_standard/wifi_framework/wifi_toolkit/include", + "$WIFI_ROOT_DIR/services/wifi_standard/wifi_framework/wifi_toolkit/net_helper", + "$WIFI_ROOT_DIR/services/wifi_standard/wifi_framework/wifi_toolkit/log", + "$WIFI_ROOT_DIR/services/wifi_standard/wifi_framework/wifi_toolkit/config", + "$WIFI_ROOT_DIR/services/wifi_standard/wifi_framework/wifi_toolkit/utils", + "$WIFI_ROOT_DIR/services/wifi_standard/wifi_framework/wifi_manage/wifi_common", + "$WIFI_ROOT_DIR/services/wifi_standard/wifi_framework/wifi_manage/wifi_scan", + "$WIFI_ROOT_DIR/test/wifi_standard/wifi_framework/wifi_manage/wifi_scan", + "$WIFI_ROOT_DIR/test/wifi_standard/wifi_framework/wifi_manage/wifi_sta/Mock", + "$WIFI_ROOT_DIR/test/wifi_standard/wifi_framework/wifi_toolkit/unittest/Mock", + "$WIFI_ROOT_DIR/services/wifi_standard/wifi_framework/wifi_manage/", + "$WIFI_ROOT_DIR/services/wifi_standard/wifi_framework/wifi_manage/wifi_native/common", + "$WIFI_ROOT_DIR/services/wifi_standard/wifi_framework/wifi_manage/wifi_native/wifi_hal_interface", + "$WIFI_ROOT_DIR/services/wifi_standard/wifi_framework/wifi_manage/wifi_native/client/idl_client", + "$WIFI_ROOT_DIR/services/wifi_standard/wifi_framework/wifi_manage/wifi_native/client/idl_client/idl_interface", + "$WIFI_ROOT_DIR/services/wifi_standard/wifi_framework/wifi_manage/wifi_sta/net_conf", + "$WIFI_ROOT_DIR/services/wifi_standard/wifi_framework/wifi_manage/wifi_sta", + "$WIFI_ROOT_DIR/services/wifi_standard/wifi_framework/wifi_manage/wifi_self_cure", + "$WIFI_ROOT_DIR/services/wifi_standard/wifi_framework/wifi_manage/wifi_pro", + "$WIFI_ROOT_DIR/services/wifi_standard/wifi_framework/wifi_manage/wifi_p2p", + "$WIFI_ROOT_DIR/services/wifi_standard/depends/include/hardware/libhardware/include", + "$WIFI_ROOT_DIR/services/wifi_standard/depends/include/system/core/include", + "$WIFI_ROOT_DIR/services/wifi_standard/depends/include/frameworks/native/include", + "$WIFI_ROOT_DIR/services/wifi_standard/depends/include/system/core/libutils/include", + "$WIFI_ROOT_DIR/services/wifi_standard/depends/include/system/core/base/include", + "$WIFI_ROOT_DIR/services/wifi_standard/depends/include/system/libbase/include", + "$WIFI_ROOT_DIR/services/wifi_standard/depends/include/system/core/libnetutils/include/netutils", + "$WIFI_ROOT_DIR/services/wifi_standard/wifi_framework/wifi_manage/wifi_sta/network_select", + "$WIFI_ROOT_DIR/services/wifi_standard/wifi_framework/wifi_manage/wifi_ap", + "$WIFI_ROOT_DIR/services/wifi_standard/wifi_framework/wifi_manage/wifi_common/wifi_country_code", + "$WIFI_ROOT_DIR/services/wifi_standard/wifi_framework/wifi_manage/wifi_common/network_black_list", + "$WIFI_ROOT_DIR/services/wifi_standard/wifi_framework/wifi_manage/wifi_common/wifi_network_stats", + "//third_party/googletest/googlemock/include", + "//third_party/googletest/googletest/include", + "$WIFI_ROOT_DIR/services/wifi_standard/include", + "$WIFI_ROOT_DIR/utils/inc", + "$WIFI_ROOT_DIR/test/wifi_standard/wifi_framework/wifi_manage/unittest/Mock", + "$WIFI_ROOT_DIR/base/utils", + "$WIFI_ROOT_DIR/services/wifi_standard/wifi_framework/wifi_manage/wifi_common/app_network_speed_limit", + "$WIFI_ROOT_DIR/test/wifi_standard/wifi_framework/wifi_manage/wifi_native/Mock", + ] + + deps = [ + "$WIFI_ROOT_DIR/base:wifi_base", + "$WIFI_ROOT_DIR/services/wifi_standard/wifi_framework/wifi_manage:wifi_manager_service", + "$WIFI_ROOT_DIR/services/wifi_standard/wifi_framework/wifi_manage/wifi_common:wifi_common_service", + "$WIFI_ROOT_DIR/services/wifi_standard/wifi_framework/wifi_toolkit:wifi_toolkit", + "$WIFI_ROOT_DIR/utils:wifi_utils", + "//third_party/googletest:gmock_main", + "//third_party/googletest:gtest_main", + ] + + deps += [ + "$WIFI_ROOT_DIR/services/wifi_standard/wifi_framework/wifi_manage:wifi_device_ability", + "$WIFI_ROOT_DIR/services/wifi_standard/wifi_framework/wifi_manage:wifi_hotspot_ability", + "$WIFI_ROOT_DIR/services/wifi_standard/wifi_framework/wifi_manage:wifi_scan_ability", + "$WIFI_ROOT_DIR/services/wifi_standard/wifi_framework/wifi_manage/wifi_native:wifi_native", + "$WIFI_ROOT_DIR/services/wifi_standard/wifi_framework/wifi_manage/wifi_sta:wifi_sta_service", + ] + + ldflags = [ + "-fPIC", + "--coverage", + "-Wl,-E", + ] + + external_deps = [ + "ability_base:want", + "ability_base:zuri", + "ability_runtime:ability_manager", + "ability_runtime:app_manager", + "ability_runtime:wantagent_innerkits", + "bundle_framework:appexecfwk_base", + "bundle_framework:appexecfwk_core", + "c_utils:utils", + "cellular_data:tel_cellular_data_api", + "core_service:tel_core_service_api", + "dhcp:dhcp_sdk", + "hilog:libhilog", + "init:libbegetutil", + "ipc:ipc_single", + "netmanager_base:net_conn_manager_if", + "time_service:time_client", + ] + + defines = [ + "private = public", + "protected = public", + "SUPPORT_SCAN_CONTROL", + "SUPPORT_LOCAL_RANDOM_MAC", + ] + + part_name = "wifi" + subsystem_name = "communication" + testonly = true +} diff --git a/wifi/test/wifi_standard/wifi_framework/wifi_manage/wifi_sta_sa/mock/mock_wifi_service_manager.cpp b/wifi/test/wifi_standard/wifi_framework/wifi_manage/wifi_sta_sa/mock/mock_wifi_service_manager.cpp index ddbc1460e..f63bfa2b0 100644 --- a/wifi/test/wifi_standard/wifi_framework/wifi_manage/wifi_sta_sa/mock/mock_wifi_service_manager.cpp +++ b/wifi/test/wifi_standard/wifi_framework/wifi_manage/wifi_sta_sa/mock/mock_wifi_service_manager.cpp @@ -25,6 +25,7 @@ #endif #include "scan_interface.h" #include "sta_interface.h" +#include "wifi_pro_interface.h" #ifdef FEATURE_SELF_CURE_SUPPORT #include "self_cure_interface.h" #endif @@ -67,6 +68,14 @@ int WifiServiceManager::LoadStaService(const std::string &dlname, int instId, bo return 0; } +#ifdef FEATURE_WIFI_PRO_SUPPORT +int32_t WifiServiceManager::LoadWifiProService(bool bCreate, int32_t instId) +{ + WIFI_LOGI("WifiServiceManager::LoadWifiProService"); + return 0; +} +#endif + #ifdef FEATURE_SELF_CURE_SUPPORT int WifiServiceManager::LoadSelfCureService(const std::string &dlname, bool bCreate) { @@ -115,6 +124,14 @@ IStaService *WifiServiceManager::GetStaServiceInst(int instId) return nullptr; } +#ifdef FEATURE_WIFI_PRO_SUPPORT +IWifiProService *WifiServiceManager::GetWifiProServiceInst(int32_t instId) +{ + WIFI_LOGD("WifiServiceManager::GetWifiProServiceInst, instId: %{public}d", instId); + return nullptr; +} +#endif + #ifdef FEATURE_SELF_CURE_SUPPORT ISelfCureService *WifiServiceManager::GetSelfCureServiceInst(int instId) { @@ -154,6 +171,14 @@ IEnhanceService *WifiServiceManager::GetEnhanceServiceInst() return nullptr; } +#ifdef FEATURE_WIFI_PRO_SUPPORT +NO_SANITIZE("cfi") int32_t WifiServiceManager::UnloadWifiProService(bool bPreLoad, int32_t instId) +{ + WIFI_LOGI("WifiServiceManager::UnloadWifiProService, instId: %{public}d", instId); + return 0; +} +#endif + #ifdef FEATURE_SELF_CURE_SUPPORT NO_SANITIZE("cfi") int WifiServiceManager::UnloadSelfCureService(bool bPreLoad, int instId) { diff --git a/wifi/utils/inc/wifi_event_handler.h b/wifi/utils/inc/wifi_event_handler.h index a6aecb0d9..474311f74 100644 --- a/wifi/utils/inc/wifi_event_handler.h +++ b/wifi/utils/inc/wifi_event_handler.h @@ -29,35 +29,39 @@ public: explicit WifiEventHandler(const std::string &threadName, const Callback &timeOutFunc = nullptr); ~WifiEventHandler(); -/** - * @submit sync task to Handler - * - * @param Callback - Input task - * @return bool - true: submit success, false: submit failed - */ + + /** + * @submit sync task to Handler + * + * @param Callback - Input task + * @return bool - true: submit success, false: submit failed + */ bool PostSyncTask(const Callback &callback); -/** - * @submit Async task to Handler - * - * @param Callback - Input task - * @param delayTime - Wait delayTime ms excute task - * @return bool - true: submit success, false: submit failed - */ + + /** + * @submit Async task to Handler + * + * @param Callback - Input task + * @param delayTime - Wait delayTime ms excute task + * @return bool - true: submit success, false: submit failed + */ bool PostAsyncTask(const Callback &callback, int64_t delayTime = 0); -/** - * @submit Async task to Handler - * - * @param Callback - Input task - * @param name - Describer of task - * @param delayTime - Wait delayTime ms excute task - * @return bool - true: submit success, false: submit failed - */ + + /** + * @submit Async task to Handler + * + * @param Callback - Input task + * @param name - Describer of task + * @param delayTime - Wait delayTime ms excute task + * @return bool - true: submit success, false: submit failed + */ bool PostAsyncTask(const Callback &callback, const std::string &name, int64_t delayTime = 0); -/** - * @Remove Async task - * - * @param name - Describer of task - */ + + /** + * @Remove Async task + * + * @param name - Describer of task + */ void RemoveAsyncTask(const std::string &name); /** diff --git a/wifi/wifi.gni b/wifi/wifi.gni index 09eea8ca9..fb4576cd2 100644 --- a/wifi/wifi.gni +++ b/wifi/wifi.gni @@ -31,6 +31,7 @@ declare_args() { wifi_feature_non_seperate_p2p = false wifi_feature_non_hdf_driver = false wifi_feature_with_local_random_mac = true + wifi_feature_wifi_pro_ctrl = true if (defined(global_parts_info) && defined(global_parts_info.resourceschedule_efficiency_manager)) { wifi_feature_with_app_frozen = true diff --git a/wifi/wifi_lite.gni b/wifi/wifi_lite.gni index abc221b4a..ee7851a4f 100644 --- a/wifi/wifi_lite.gni +++ b/wifi/wifi_lite.gni @@ -29,6 +29,7 @@ declare_args() { wifi_feature_with_hpf_supported = false wifi_feature_with_hdi_wpa_supported = false wifi_feature_with_vap_manager = false + wifi_feature_wifi_pro_ctrl = true } memory_optimization_cflags = [