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 #ifndef OHOS_WIFI_NETWORK_SELECTION_H 17 #define OHOS_WIFI_NETWORK_SELECTION_H 18 #include <functional> 19 #include <memory> 20 #include <set> 21 #include "wifi_msg.h" 22 #include "inter_scan_info.h" 23 24 namespace OHOS::Wifi { 25 namespace NetworkSelection { 26 enum FiltedReason { 27 UNKNOW = 0, 28 HIDDEN_NETWORK, 29 OPEN_NETWORK, 30 NOT_OPEN_NETWORK, 31 WEAK_ALGORITHM_WEP_SECURITY, 32 WEAK_ALGORITHM_WPA_SECURITY, 33 HAS_NETWORK_HISTORY, 34 PORTAL_NETWORK, 35 NOT_PORTAL_NETWORK, 36 OWE_NETWORK, 37 UNRECOVERABLE_NETWORK, 38 NETWORK_STATUS_DISABLE, 39 UNEXPECTED_NETWORK_BY_USER, 40 NO_INTERNET, 41 HAS_INTERNET, 42 NETWORK_ID_INVALID, 43 NOT_SYSTEM_NETWORK, 44 TIME_INVALID, 45 EPHEMERAL_NETWORK, 46 PASSPOINT_NETWORK, 47 POOR_SIGNAL, 48 TIMEOUT_AND_NEED_RECHECK, 49 NOT_ALLOW_AUTO_CONNECT, 50 SAME_BSSID, 51 SAME_SSID_OPENOREAP, 52 BLOCKLIST_AP, 53 NOT_P2P_FREQ_AT_5G, 54 EMPTY_HISTORY, 55 MAYBE_PORTAL_NETWORK, 56 LESS_THAN_8RSSI, 57 NOT_HML_FREQ_AT_5G, 58 NOT_SECURE_WIFI, 59 }; 60 61 struct FiltedReasonComparator { operatorFiltedReasonComparator62 bool operator()(const FiltedReason& lhs, const FiltedReason& rhs) const 63 { 64 return static_cast<int>(lhs) < static_cast<int>(rhs); 65 } 66 }; 67 68 struct NetworkCandidate { 69 const InterScanInfo &interScanInfo; 70 WifiDeviceConfig wifiDeviceConfig; NetworkCandidateNetworkCandidate71 explicit NetworkCandidate(const InterScanInfo &interScanInfo) : interScanInfo(interScanInfo), wifiDeviceConfig() {} 72 std::map<std::string, std::set<FiltedReason, FiltedReasonComparator, std::allocator<FiltedReason>>> filtedReason; 73 std::string ToString(const std::string &filterName = "") const; 74 }; 75 76 struct ScoreResult { 77 double score; 78 std::string scorerName; 79 std::vector<ScoreResult> scoreDetails; ScoreResultScoreResult80 ScoreResult() : score(0) {} 81 std::string ToString() const; 82 }; 83 84 class IWifiFilter { 85 public: 86 virtual ~IWifiFilter() = default; 87 88 /** 89 * filter the candidate network 90 * @param networkCandidate candidate network. 91 * @return true if the candidate network satisfy the condition 92 */ 93 virtual bool DoFilter(NetworkCandidate &networkCandidate) final; 94 virtual std::string GetFilterMsg() = 0; 95 protected: 96 97 /** 98 * filter the candidate network 99 * @param networkCandidate candidate network. 100 * @return true if the candidate network satisfy the condition 101 */ 102 virtual bool Filter(NetworkCandidate &networkCandidate) = 0; 103 104 /** 105 * deal with the candidate network after filter 106 * @param networkCandidate candidate network. 107 * @param filterResult if the candidate network satisfy the condition 108 */ 109 virtual void AfterFilter(NetworkCandidate &networkCandidate, bool filterResult); 110 }; 111 112 class SimpleWifiFilter : public IWifiFilter { 113 public: 114 explicit SimpleWifiFilter(const std::string &networkSelectorFilterName); 115 ~SimpleWifiFilter() override; 116 std::string GetFilterMsg() final; 117 protected: 118 void AfterFilter(NetworkCandidate &networkCandidate, bool filterResult) final; 119 std::vector<NetworkCandidate *> filteredNetworkCandidates; 120 std::string filterName; 121 }; 122 123 class WifiFunctionFilterAdapter : public IWifiFilter { 124 public: 125 126 /** 127 * 128 * @param filter the point to filterFunction 129 * @param filterName the filterName 130 * @param reverse for default it should be filtered when the function return true, And it can be modified; 131 */ 132 WifiFunctionFilterAdapter(const std::function<bool(NetworkCandidate &)> &filter, 133 const std::string &filterName, 134 bool reverse = false); 135 ~WifiFunctionFilterAdapter() override; 136 std::string GetFilterMsg() override; 137 protected: 138 bool Filter(NetworkCandidate &networkCandidate) override; 139 std::function<bool(NetworkCandidate &)> targetFunction; 140 std::string filterName; 141 bool iSReverse; 142 }; 143 144 class CompositeWifiFilter : public IWifiFilter { 145 public: 146 /** 147 * Add Filter for composite network selector filter 148 * @param filter filter 149 */ 150 virtual void AddFilter(const std::shared_ptr<IWifiFilter> &filter); 151 ~CompositeWifiFilter() override; 152 protected: 153 std::vector<std::shared_ptr<IWifiFilter>> filters; 154 }; 155 156 class AndWifiFilter : public CompositeWifiFilter { 157 public: 158 ~AndWifiFilter() override; 159 bool Filter(NetworkCandidate &networkCandidate) override; 160 std::string GetFilterMsg() override; 161 }; 162 163 class OrWifiFilter : public CompositeWifiFilter { 164 public: 165 bool Filter(NetworkCandidate &networkCandidate) override; 166 ~OrWifiFilter() override; 167 std::string GetFilterMsg() override; 168 }; 169 170 class IWifiScorer { 171 public: 172 virtual ~IWifiScorer() = default; 173 virtual void DoScore(NetworkCandidate &networkCandidate, ScoreResult &scoreResult) = 0; 174 }; 175 176 class SimpleWifiScorer : public IWifiScorer { 177 public: 178 explicit SimpleWifiScorer(const std::string &scorerName); 179 ~SimpleWifiScorer() override; 180 void DoScore(NetworkCandidate &networkCandidate, ScoreResult &scoreResult) final; 181 protected: 182 virtual double Score(NetworkCandidate &networkCandidate) = 0; 183 std::string m_scoreName; 184 }; 185 186 class CompositeWifiScorer : public IWifiScorer { 187 public: 188 explicit CompositeWifiScorer(const std::string &scorerName); 189 ~CompositeWifiScorer() override; 190 void DoScore(NetworkCandidate &networkCandidate, ScoreResult &scoreResult) final; 191 void AddScorer(const std::shared_ptr<IWifiScorer> &scorer); 192 protected: 193 std::vector<std::shared_ptr<IWifiScorer>> scorers; 194 std::string m_scoreName; 195 }; 196 197 class WifiFunctionScorerAdapter : public SimpleWifiScorer { 198 public: 199 200 /** 201 * 202 * @param scorer the point to scorerFunction 203 * @param scorerName the scorerName 204 * @param reverse for default it should be filtered when the function return true, And it can be modified; 205 */ 206 WifiFunctionScorerAdapter(const std::function<double(NetworkCandidate &)> &scorer, 207 const std::string &scorerName); 208 ~WifiFunctionScorerAdapter() override; 209 protected: 210 virtual double Score(NetworkCandidate &networkCandidate) override; 211 std::function<double(NetworkCandidate &)> targetFunction; 212 std::string m_scoreName; 213 }; 214 215 class IWifiComparator { 216 public: 217 virtual ~IWifiComparator() = default; 218 219 /** 220 * GetBestCandidates 221 * 222 * @param candidates the candidate network before compare. 223 * @param selectedCandidates the best candidate network after compare. 224 */ 225 virtual void GetBestCandidates(const std::vector<NetworkCandidate *> &candidates, 226 std::vector<NetworkCandidate *> &selectedCandidates) = 0; 227 }; 228 229 class INetworkSelector { 230 public: 231 virtual ~INetworkSelector() = default; 232 233 /** 234 * the function to try nominator the candidate network. 235 * 236 * @param networkCandidate candidate network 237 * @return return true if the candidate network is nominated. 238 */ 239 virtual bool TryNominate(NetworkCandidate &networkCandidate) = 0; 240 241 /** 242 * the function to get best candidate networks. 243 * @param selectedNetworkCandidates the best candidate networks. 244 */ 245 virtual void GetBestCandidates(std::vector<NetworkCandidate *> &selectedNetworkCandidates) = 0; 246 247 /** 248 * transfer the info of network selector to json format string. 249 * @return 250 */ 251 virtual std::string GetNetworkSelectorMsg() = 0; 252 }; 253 254 class NetworkSelector : public INetworkSelector { 255 public: 256 explicit NetworkSelector(const std::string &networkSelectorName); 257 ~NetworkSelector() override; 258 /** 259 * the function to set comparator。 260 * 261 * @param networkSelectorComparator comparator 262 */ 263 virtual void SetWifiComparator(const std::shared_ptr<IWifiComparator> &networkSelectorComparator) final; 264 265 /** 266 * the function to set filter. 267 * 268 * @param networkSelectorFilter filter 269 */ 270 virtual void SetWifiFilter(const std::shared_ptr<IWifiFilter> &networkSelectorFilter) final; 271 bool TryNominate(NetworkCandidate &networkCandidate) final; 272 protected: 273 274 /** 275 * filter the candidate network 276 * 277 * @param networkCandidate candidate network 278 * @return true if the candidate network pass. 279 */ 280 virtual bool DoFilter(NetworkCandidate &networkCandidate) final; 281 282 /** 283 * get best candidate network by comparator. 284 * 285 * @param selectedNetworkCandidates the best candidate networks; 286 */ 287 virtual void GetBestCandidatesByComparator(std::vector<NetworkCandidate *> &selectedNetworkCandidates) final; 288 289 /** 290 * deal with the candidate network which pass the filter. 291 * 292 * @param networkCandidate candidate network 293 * @return true if the candidate network is added to networkCandidates. 294 */ 295 virtual bool Nominate(NetworkCandidate &networkCandidate) = 0; 296 297 std::vector<NetworkCandidate *> networkCandidates; 298 std::shared_ptr<IWifiComparator> comparator; 299 std::shared_ptr<IWifiFilter> filter; 300 const std::string m_networkSelectorName; 301 }; 302 303 class SimpleNetworkSelector : public NetworkSelector { 304 public: 305 explicit SimpleNetworkSelector(const std::string &networkSelectorName); 306 ~SimpleNetworkSelector() override; 307 std::string GetNetworkSelectorMsg() override; 308 void GetBestCandidates(std::vector<NetworkCandidate *> &selectedNetworkCandidates) final; 309 protected: 310 bool Nominate(NetworkCandidate &networkCandidate) override; 311 }; 312 313 class CompositeNetworkSelector : public NetworkSelector { 314 public: 315 explicit CompositeNetworkSelector(const std::string &networkSelectorName); 316 ~CompositeNetworkSelector() override; 317 /** 318 * Add subnetworkSelector for compositeNetworkSelector 319 * 320 * @param subNetworkSelector subNetworkSelector 321 */ 322 void AddSubNetworkSelector(const std::shared_ptr<INetworkSelector> &subNetworkSelector); 323 void GetBestCandidates(std::vector<NetworkCandidate *> &selectedNetworkCandidates) final; 324 std::string GetNetworkSelectorMsg() override; 325 protected: 326 /** 327 * deal with the candidate network before compare. 328 */ 329 virtual void GetCandidatesFromSubNetworkSelector() = 0; 330 std::vector<std::shared_ptr<INetworkSelector>> subNetworkSelectors; 331 }; 332 } 333 334 enum class FilterTag { 335 SAVED_NETWORK_TRACKER_FILTER_TAG, 336 HAS_INTERNET_NETWORK_SELECTOR_FILTER_TAG, 337 RECOVERY_NETWORK_SELECTOR_FILTER_TAG, 338 PORTAL_NETWORK_SELECTOR_FILTER_TAG, 339 IT_NETWORK_SELECTOR_FILTER_TAG, 340 }; 341 342 enum class TagType { 343 // The following is filter tag 344 NOT_P2P_ENHANCE_FREQ_AT_5G_FILTER_TAG, 345 // The following is the scorer tag 346 HAS_INTERNET_NETWORK_SELECTOR_SCORE_WIFI_CATEGORY_TAG, 347 }; 348 349 enum class CommonBuilderType { 350 FILTER_BUILDER, 351 SCORE_BUILDER, 352 }; 353 354 using FilterBuilder = std::function<void(NetworkSelection::CompositeWifiFilter &)>; 355 using ScoreBuilder = std::function<void(NetworkSelection::CompositeWifiScorer &)>; 356 357 struct CommonBuilder { CommonBuilderCommonBuilder358 CommonBuilder() 359 { 360 commonBuilderType = CommonBuilderType::FILTER_BUILDER; 361 } 362 CommonBuilderCommonBuilder363 CommonBuilder(const CommonBuilder &commonBuilder) 364 { 365 filterBuilder = commonBuilder.filterBuilder; 366 scoreBuilder = commonBuilder.scoreBuilder; 367 } 368 ~CommonBuilderCommonBuilder369 ~CommonBuilder() {} 370 371 const CommonBuilder &operator=(const CommonBuilder &commonBuilder) 372 { 373 filterBuilder = commonBuilder.filterBuilder; 374 scoreBuilder = commonBuilder.scoreBuilder; 375 return *this; 376 } IsEmptyCommonBuilder377 bool IsEmpty() const 378 { 379 if (!filterBuilder && commonBuilderType == CommonBuilderType::FILTER_BUILDER) { 380 return true; 381 } else if (!scoreBuilder && commonBuilderType == CommonBuilderType::SCORE_BUILDER) { 382 return true; 383 } 384 return false; 385 } 386 387 FilterBuilder filterBuilder; 388 ScoreBuilder scoreBuilder; 389 CommonBuilderType commonBuilderType; 390 }; 391 } 392 #endif 393