1 /*
2 * Copyright (C) 2021-2023 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15
16 #include <sstream>
17 #include "network_selector_impl.h"
18 #include "wifi_comparator_impl.h"
19 #include "wifi_scorer_impl.h"
20 #include "network_selection_utils.h"
21 #include "external_wifi_common_builder_manager.h"
22 #include "external_wifi_filter_builder_manager.h"
23 #include "wifi_filter_impl.h"
24 #include "wifi_logger.h"
25 #include "parameters.h"
26 #include "wifi_global_func.h"
27
28 using namespace std;
29
30 namespace OHOS::Wifi::NetworkSelection {
31
32 DEFINE_WIFILOG_LABEL("NetworkSelector")
33
GetCandidatesFromSubNetworkSelector()34 void AutoConnectIntegrator::GetCandidatesFromSubNetworkSelector()
35 {
36 for (const auto &subNetworkSelector : subNetworkSelectors) {
37 subNetworkSelector->GetBestCandidates(networkCandidates);
38 }
39 }
40
AutoConnectIntegrator()41 AutoConnectIntegrator::AutoConnectIntegrator() : CompositeNetworkSelector(
42 "autoConnectIntegrator")
43 {
44 auto filters = make_shared<AndWifiFilter>();
45 filters->AddFilter(make_shared<HiddenWifiFilter>());
46 filters->AddFilter(make_shared<SignalStrengthWifiFilter>());
47 if (OHOS::system::GetParameter("ohos.boot.advsecmode.state", "0") != "0") {
48 filters->AddFilter(make_shared<WeakAlgorithmWifiFilter>());
49 }
50 SetWifiFilter(filters);
51 AddSubNetworkSelector(make_shared<SavedNetworkTracker>());
52 AddSubNetworkSelector(make_shared<SuggestionNetworkTracker>());
53 auto comparator = make_shared<WifiScorerComparator>(m_networkSelectorName);
54 comparator->AddScorer(make_shared<ThroughputScorer>());
55 SetWifiComparator(comparator);
56 }
57
Nominate(NetworkCandidate & networkCandidate)58 bool AutoConnectIntegrator::Nominate(NetworkCandidate &networkCandidate)
59 {
60 for (auto &networkSelector : subNetworkSelectors) {
61 networkSelector->TryNominate(networkCandidate);
62 }
63 return false;
64 }
65
GetCandidatesFromSubNetworkSelector()66 void Wifi2WifiIntegrator::GetCandidatesFromSubNetworkSelector()
67 {
68 for (const auto &subNetworkSelector : subNetworkSelectors) {
69 subNetworkSelector->GetBestCandidates(networkCandidates);
70 }
71 }
72
Wifi2WifiIntegrator()73 Wifi2WifiIntegrator::Wifi2WifiIntegrator() : CompositeNetworkSelector("Wifi2WifiIntegrator")
74 {
75 auto andFilters = make_shared<AndWifiFilter>();
76 andFilters->AddFilter(make_shared<ValidNetworkIdFilter>());
77 andFilters->AddFilter(make_shared<NotCurrentNetworkFilter>());
78 andFilters->AddFilter(make_shared<NotNetworkBlackListFilter>());
79 ExternalWifiCommonBuildManager::GetInstance().BuildFilter(TagType::NOT_P2P_ENHANCE_FREQ_AT_5G_FILTER_TAG,
80 *andFilters);
81 andFilters->AddFilter(make_shared<NotP2pFreqAt5gFilter>());
82 andFilters->AddFilter(make_shared<SignalLevelFilter>());
83 andFilters->AddFilter(make_shared<WifiSwitchThresholdFilter>());
84 andFilters->AddFilter(make_shared<ValidConfigNetworkFilter>());
85 SetWifiFilter(andFilters);
86
87 AddSubNetworkSelector(make_shared<PreferredApSelector>());
88 }
89
Nominate(NetworkCandidate & networkCandidate)90 bool Wifi2WifiIntegrator::Nominate(NetworkCandidate &networkCandidate)
91 {
92 for (auto &networkSelector : subNetworkSelectors) {
93 networkSelector->TryNominate(networkCandidate);
94 }
95 return false;
96 }
97
Nominate(NetworkCandidate & networkCandidate)98 bool Wifi2WifiNoNetIntegrator::Nominate(NetworkCandidate &networkCandidate)
99 {
100 for (auto &networkSelector : subNetworkSelectors) {
101 networkSelector->TryNominate(networkCandidate);
102 }
103 return false;
104 }
105
GetCandidatesFromSubNetworkSelector()106 void Wifi2WifiNoNetIntegrator::GetCandidatesFromSubNetworkSelector()
107 {
108 for (const auto &subNetworkSelector : subNetworkSelectors) {
109 subNetworkSelector->GetBestCandidates(networkCandidates);
110 }
111 }
112
Wifi2WifiNoNetIntegrator()113 Wifi2WifiNoNetIntegrator::Wifi2WifiNoNetIntegrator() : CompositeNetworkSelector("Wifi2WifiNoNetIntegrator")
114 {
115 auto andFilters = make_shared<AndWifiFilter>();
116 andFilters->AddFilter(make_shared<ValidNetworkIdFilter>());
117 andFilters->AddFilter(make_shared<NotCurrentNetworkFilter>());
118 andFilters->AddFilter(make_shared<NotNetworkBlackListFilter>());
119 ExternalWifiCommonBuildManager::GetInstance().BuildFilter(TagType::NOT_P2P_ENHANCE_FREQ_AT_5G_FILTER_TAG,
120 *andFilters);
121 andFilters->AddFilter(make_shared<NotP2pFreqAt5gFilter>());
122 andFilters->AddFilter(make_shared<SignalLevelFilter>());
123 andFilters->AddFilter(make_shared<ValidConfigNetworkFilter>());
124 SetWifiFilter(andFilters);
125
126 AddSubNetworkSelector(make_shared<PreferredApSelector>());
127 }
128
Nominate(NetworkCandidate & networkCandidate)129 bool Wifi2WifiQoeSlowIntegrator::Nominate(NetworkCandidate &networkCandidate)
130 {
131 for (auto &networkSelector : subNetworkSelectors) {
132 networkSelector->TryNominate(networkCandidate);
133 }
134 return false;
135 }
136
GetCandidatesFromSubNetworkSelector()137 void Wifi2WifiQoeSlowIntegrator::GetCandidatesFromSubNetworkSelector()
138 {
139 for (const auto &subNetworkSelector : subNetworkSelectors) {
140 subNetworkSelector->GetBestCandidates(networkCandidates);
141 }
142 }
143
Wifi2WifiQoeSlowIntegrator()144 Wifi2WifiQoeSlowIntegrator::Wifi2WifiQoeSlowIntegrator() : CompositeNetworkSelector("Wifi2WifiQoeSlowIntegrator")
145 {
146 auto andFilters = make_shared<AndWifiFilter>();
147 andFilters->AddFilter(make_shared<ValidNetworkIdFilter>());
148 andFilters->AddFilter(make_shared<NotCurrentNetworkFilter>());
149 andFilters->AddFilter(make_shared<NotNetworkBlackListFilter>());
150 ExternalWifiCommonBuildManager::GetInstance().BuildFilter(TagType::NOT_P2P_ENHANCE_FREQ_AT_5G_FILTER_TAG,
151 *andFilters);
152 andFilters->AddFilter(make_shared<NotP2pFreqAt5gFilter>());
153 andFilters->AddFilter(make_shared<SignalLevelFilter>());
154 andFilters->AddFilter(make_shared<WifiSwitchThresholdQoeFilter>());
155 andFilters->AddFilter(make_shared<ValidConfigNetworkFilter>());
156 SetWifiFilter(andFilters);
157
158 AddSubNetworkSelector(make_shared<PreferredApSelector>());
159 }
160
SavedNetworkTracker()161 SavedNetworkTracker::SavedNetworkTracker() : CompositeNetworkSelector("savedNetworkTracker")
162 {
163 auto andFilter = make_shared<AndWifiFilter>();
164 andFilter->AddFilter(make_shared<SavedWifiFilter>());
165 andFilter->AddFilter(make_shared<PassPointWifiFilter>());
166 andFilter->AddFilter(make_shared<EphemeralWifiFilter>());
167 andFilter->AddFilter(make_shared<DisableWifiFilter>());
168 andFilter->AddFilter(make_shared<MatchedUserSelectBssidWifiFilter>());
169 ExternalWifiFilterBuildManager::GetInstance().BuildFilter(FilterTag::SAVED_NETWORK_TRACKER_FILTER_TAG, *andFilter);
170 #ifdef FEATURE_ITNETWORK_PREFERRED_SUPPORT
171 shared_ptr<CustNetPreferredNetworkSelector> custNetPreferredNetworkSelector = nullptr;
172 if (CheckDeviceTypeByVendorCountry()) {
173 custNetPreferredNetworkSelector = make_shared<CustNetPreferredNetworkSelector>();
174 }
175 #endif
176 auto blackListNetworkSelector = make_shared<BlackListNetworkSelector>();
177 auto hasInternetNetworkSelector = make_shared<HasInternetNetworkSelector>();
178 auto recoveryNetworkSelector = make_shared<RecoveryNetworkSelector>();
179 auto portalNetworkSelector = make_shared<PortalNetworkSelector>();
180 portalNetworkSelector->InitFilter();
181 auto noInternetNetworkSelector = make_shared<NoInternetNetworkSelector>();
182
183 #ifdef FEATURE_ITNETWORK_PREFERRED_SUPPORT
184 andFilter->AddFilter(custNetPreferredNetworkSelector);
185 #endif
186 andFilter->AddFilter(blackListNetworkSelector);
187 andFilter->AddFilter(hasInternetNetworkSelector);
188 andFilter->AddFilter(recoveryNetworkSelector);
189 andFilter->AddFilter(portalNetworkSelector);
190 andFilter->AddFilter(noInternetNetworkSelector);
191 SetWifiFilter(andFilter);
192 /*
193 * current networkSelector only obtains one non-empty network selection result of subNetworkSelector, which is
194 * depends on the sequence of the subNetworkSelectors, When the network selection result of one of the
195 * subNetworkSelectors is not empty, the network selection result of other subNetworkSelectors inserted later will
196 * be abandoned.
197 */
198 #ifdef FEATURE_ITNETWORK_PREFERRED_SUPPORT
199 AddSubNetworkSelector(custNetPreferredNetworkSelector);
200 #endif
201 AddSubNetworkSelector(hasInternetNetworkSelector);
202 AddSubNetworkSelector(recoveryNetworkSelector);
203 AddSubNetworkSelector(portalNetworkSelector);
204 AddSubNetworkSelector(noInternetNetworkSelector);
205 AddSubNetworkSelector(blackListNetworkSelector);
206 }
207
Nominate(NetworkCandidate & networkCandidate)208 bool SavedNetworkTracker::Nominate(NetworkCandidate &networkCandidate)
209 {
210 return false;
211 }
212
GetCandidatesFromSubNetworkSelector()213 void SavedNetworkTracker::GetCandidatesFromSubNetworkSelector()
214 {
215 for (const auto &subNetworkSelector : subNetworkSelectors) {
216 subNetworkSelector->GetBestCandidates(networkCandidates);
217 if (!networkCandidates.empty()) {
218 /* abandon networkCandidates from other low-priority networkSelectors */
219 return;
220 }
221 }
222 }
223
SuggestionNetworkTracker()224 SuggestionNetworkTracker::SuggestionNetworkTracker() : SimpleNetworkSelector("suggestionNetworkTracker")
225 {
226 auto andFilter = make_shared<AndWifiFilter>();
227 andFilter->AddFilter(make_shared<SuggestionNetworkWifiFilter>());
228 andFilter->AddFilter(make_shared<DisableWifiFilter>());
229 andFilter->AddFilter(make_shared<EphemeralWifiFilter>());
230 SetWifiFilter(andFilter);
231 }
232
SimpleFilterNetworkSelector(const std::string & networkSelectorName)233 SimpleFilterNetworkSelector::SimpleFilterNetworkSelector(const std::string &networkSelectorName)
234 : SimpleNetworkSelector(networkSelectorName), SimpleWifiFilter(networkSelectorName) {}
235
~SimpleFilterNetworkSelector()236 SimpleFilterNetworkSelector::~SimpleFilterNetworkSelector()
237 {
238 if (!networkCandidates.empty()) {
239 WIFI_LOGI("networkCandidates in %{public}s: %{public}s",
240 m_networkSelectorName.c_str(),
241 NetworkSelectionUtils::GetNetworkCandidatesInfo(networkCandidates).c_str());
242 }
243 if (!filteredNetworkCandidates.empty()) {
244 WIFI_LOGI("filteredNetworkCandidates in %{public}s: %{public}s",
245 m_networkSelectorName.c_str(),
246 NetworkSelectionUtils::GetNetworkCandidatesInfo(filteredNetworkCandidates).c_str());
247 }
248 }
249
BlackListNetworkSelector()250 BlackListNetworkSelector::BlackListNetworkSelector() : SimpleFilterNetworkSelector("blackListNetworkSelector")
251 {
252 SetWifiFilter(make_shared<WifiFunctionFilterAdapter>(NetworkSelectionUtils::IsBlackListNetwork, "isBlackList"));
253 }
254
Nominate(NetworkCandidate & networkCandidate)255 bool BlackListNetworkSelector::Nominate(NetworkCandidate &networkCandidate)
256 {
257 if (!networkCandidates.empty()) {
258 networkCandidates.at(0) = &networkCandidate;
259 } else {
260 networkCandidates.emplace_back(&networkCandidate);
261 }
262 return true;
263 }
264
Filter(NetworkCandidate & networkCandidate)265 bool BlackListNetworkSelector::Filter(NetworkCandidate &networkCandidate)
266 {
267 return !TryNominate(networkCandidate);
268 }
269
HasInternetNetworkSelector()270 HasInternetNetworkSelector::HasInternetNetworkSelector() : SimpleFilterNetworkSelector("hasInternetNetworkSelector")
271 {
272 auto filters = make_shared<AndWifiFilter>();
273 ExternalWifiFilterBuildManager::GetInstance().BuildFilter(FilterTag::HAS_INTERNET_NETWORK_SELECTOR_FILTER_TAG,
274 *filters);
275 filters->AddFilter(make_shared<HasInternetWifiFilter>());
276 SetWifiFilter(filters);
277 auto networkScoreComparator = make_shared<WifiScorerComparator>(m_networkSelectorName);
278 networkScoreComparator->AddScorer(make_shared<NetworkStatusHistoryScorer>());
279 networkScoreComparator->AddScorer(make_shared<SavedNetworkScorer>("hasInternetNetworkScorer"));
280 networkScoreComparator->AddScorer(make_shared<RssiScorer>());
281 SetWifiComparator(networkScoreComparator);
282 }
283
Filter(NetworkCandidate & networkCandidate)284 bool HasInternetNetworkSelector::Filter(NetworkCandidate &networkCandidate)
285 {
286 TryNominate(networkCandidate);
287 return networkCandidates.empty();
288 }
289
290 #ifdef FEATURE_ITNETWORK_PREFERRED_SUPPORT
CustNetPreferredNetworkSelector()291 CustNetPreferredNetworkSelector::CustNetPreferredNetworkSelector()
292 : SimpleFilterNetworkSelector("custNetPreferredNetworkSelector")
293 {
294 auto filters = make_shared<OrWifiFilter>();
295 ExternalWifiFilterBuildManager::GetInstance().BuildFilter(FilterTag::IT_NETWORK_SELECTOR_FILTER_TAG,
296 *filters);
297 SetWifiFilter(filters);
298 auto networkScoreComparator = make_shared<WifiScorerComparator>(m_networkSelectorName);
299 networkScoreComparator->AddScorer(make_shared<SavedNetworkScorer>("custNetPreferredNetworkScorer"));
300 networkScoreComparator->AddScorer(make_shared<RssiScorer>());
301 SetWifiComparator(networkScoreComparator);
302 }
303
Filter(NetworkCandidate & networkCandidate)304 bool CustNetPreferredNetworkSelector::Filter(NetworkCandidate &networkCandidate)
305 {
306 return !NetworkSelector::TryNominate(networkCandidate);
307 }
308 #endif
309
RecoveryNetworkSelector()310 RecoveryNetworkSelector::RecoveryNetworkSelector() : SimpleFilterNetworkSelector("recoveryNetworkSelector")
311 {
312 auto filters = make_shared<AndWifiFilter>();
313 ExternalWifiFilterBuildManager::GetInstance().BuildFilter(FilterTag::RECOVERY_NETWORK_SELECTOR_FILTER_TAG,
314 *filters);
315 filters->AddFilter(make_shared<RecoveryWifiFilter>());
316 SetWifiFilter(filters);
317 auto networkScorerComparator = make_shared<WifiScorerComparator>(m_networkSelectorName);
318 networkScorerComparator->AddScorer(make_shared<SavedNetworkScorer>("recoveryNetworkScorer"));
319 networkScorerComparator->AddScorer(make_shared<RssiScorer>());
320 SetWifiComparator(networkScorerComparator);
321 }
322
Filter(NetworkCandidate & networkCandidate)323 bool RecoveryNetworkSelector::Filter(NetworkCandidate &networkCandidate)
324 {
325 TryNominate(networkCandidate);
326 return networkCandidates.empty();
327 }
328
PortalNetworkSelector()329 PortalNetworkSelector::PortalNetworkSelector() : SimpleNetworkSelector("portalNetworkSelector"), OrWifiFilter()
330 {
331 SetWifiFilter(make_shared<PoorPortalWifiFilter>());
332 auto networkScorerComparator = make_shared<WifiScorerComparator>(m_networkSelectorName);
333 networkScorerComparator->AddScorer(make_shared<LastHaveInternetTimeScorer>());
334 networkScorerComparator->AddScorer(make_shared<SavedNetworkScorer>("portalNetworkScorer"));
335 networkScorerComparator->AddScorer(make_shared<RssiScorer>());
336 SetWifiComparator(networkScorerComparator);
337 }
338
~PortalNetworkSelector()339 PortalNetworkSelector::~PortalNetworkSelector()
340 {
341 if (!filteredNetworkCandidates.empty()) {
342 WIFI_LOGI("filteredNetworkCandidates in %{public}s: %{public}s",
343 m_networkSelectorName.c_str(),
344 NetworkSelectionUtils::GetNetworkCandidatesInfo(filteredNetworkCandidates).c_str());
345 }
346 }
347
InitFilter()348 void PortalNetworkSelector::InitFilter()
349 {
350 AddFilter(make_shared<PortalWifiFilter>());
351 AddFilter(make_shared<MaybePortalWifiFilter>());
352 ExternalWifiFilterBuildManager::GetInstance().BuildFilter(FilterTag::PORTAL_NETWORK_SELECTOR_FILTER_TAG, *this);
353 }
354
Filter(NetworkCandidate & networkCandidate)355 bool PortalNetworkSelector::Filter(NetworkCandidate &networkCandidate)
356 {
357 if (OrWifiFilter::Filter(networkCandidate)) {
358 TryNominate(networkCandidate);
359 }
360 if (networkCandidates.empty()) {
361 return true;
362 }
363 filteredNetworkCandidates.emplace_back(&networkCandidate);
364 return false;
365 }
366
GetNetworkSelectorMsg()367 string PortalNetworkSelector::GetNetworkSelectorMsg()
368 {
369 stringstream networkSelectorMsg;
370 networkSelectorMsg << R"({ "name": ")" << m_networkSelectorName << "\" ";
371 string filterMsg;
372 if (!filters.empty()) {
373 filterMsg += OrWifiFilter::GetFilterMsg();
374 }
375 if (filter) {
376 if (!filterMsg.empty()) {
377 filterMsg += "&&";
378 }
379 filterMsg += filter->GetFilterMsg();
380 }
381 if (!filterMsg.empty()) {
382 networkSelectorMsg << R"(,"filter": ")" << filterMsg << "\"";
383 }
384 networkSelectorMsg << "}";
385 return networkSelectorMsg.str();
386 }
387
NoInternetNetworkSelector()388 NoInternetNetworkSelector::NoInternetNetworkSelector() : SimpleFilterNetworkSelector("noInternetNetworkSelector")
389 {
390 SetWifiFilter(make_shared<NoInternetWifiFilter>());
391 auto networkScorerComparator = make_shared<WifiScorerComparator>(m_networkSelectorName);
392 auto noInternetNetworkScorer = make_shared<SavedNetworkScorer>("noInternetNetworkScorer");
393 noInternetNetworkScorer->AddScorer(make_shared<NoInternetNetworkStatusHistoryScorer>());
394 networkScorerComparator->AddScorer(noInternetNetworkScorer);
395 networkScorerComparator->AddScorer(make_shared<RssiScorer>());
396 SetWifiComparator(networkScorerComparator);
397 }
398
Filter(NetworkCandidate & networkCandidate)399 bool NoInternetNetworkSelector::Filter(NetworkCandidate &networkCandidate)
400 {
401 TryNominate(networkCandidate);
402 return false;
403 }
404
PreferredApSelector()405 PreferredApSelector::PreferredApSelector() : SimpleFilterNetworkSelector("PreferredApSelector")
406 {
407 // The filtering conditions have already been done outside, so no further filtering is needed here.
408 auto networkScoreComparator = make_shared<WifiScorerComparator>(m_networkSelectorName);
409 networkScoreComparator->AddScorer(make_shared<ApQualityScorer>("ApQualityScorer"));
410 networkScoreComparator->AddScorer(make_shared<RssiScorer>());
411 SetWifiComparator(networkScoreComparator);
412 }
413
Filter(NetworkCandidate & networkCandidate)414 bool PreferredApSelector::Filter(NetworkCandidate &networkCandidate)
415 {
416 TryNominate(networkCandidate);
417 return false;
418 }
419 }
420