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