1 /*
2  * Copyright (C) 2024 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 #include "wifi_scan_config.h"
16 #include "wifi_config_center.h"
17 #include "wifi_common_util.h"
18 #include "wifi_log.h"
19 
20 namespace OHOS {
21 namespace Wifi {
WifiScanConfig()22 WifiScanConfig::WifiScanConfig()
23 {
24     InitScanControlForbidList();
25     InitScanControlIntervalList();
26 }
27 
~WifiScanConfig()28 WifiScanConfig::~WifiScanConfig()
29 {}
30 
GetScanDeviceInfo(WifiScanDeviceInfo & scanDeviceInfo)31 void WifiScanConfig::GetScanDeviceInfo(WifiScanDeviceInfo &scanDeviceInfo)
32 {
33     WifiP2pLinkedInfo linkedInfo;
34     WifiConfigCenter::GetInstance().GetP2pInfo(linkedInfo);
35     std::unique_lock<std::mutex> lock(mScanDeviceInfoMutex);
36 #ifndef OHOS_ARCH_LITE
37     mScanDeviceInfo.appId = GetCallingUid();
38 #endif
39     mScanDeviceInfo.hid2dInfo.p2pConnectState = linkedInfo.GetConnectState();
40     mScanDeviceInfo.hid2dInfo.p2pEnhanceState = WifiConfigCenter::GetInstance().GetP2pEnhanceState();
41     mScanDeviceInfo.idelState = WifiConfigCenter::GetInstance().GetPowerIdelState();
42     mScanDeviceInfo.thermalLevel = WifiConfigCenter::GetInstance().GetThermalLevel();
43     mScanDeviceInfo.screenState = WifiConfigCenter::GetInstance().GetScreenState();
44     mScanDeviceInfo.noChargerState = WifiConfigCenter::GetInstance().GetNoChargerPlugModeState();
45     mScanDeviceInfo.gnssFixState = WifiConfigCenter::GetInstance().GetGnssFixState();
46     mScanDeviceInfo.freezeState = WifiConfigCenter::GetInstance().GetFreezeModeState();
47 
48     WifiConfigCenter::GetInstance().GetHid2dUpperScene(SOFT_BUS_SERVICE_UID,
49         mScanDeviceInfo.hid2dInfo.softBusScene);
50     WifiConfigCenter::GetInstance().GetHid2dUpperScene(CAST_ENGINE_SERVICE_UID,
51         mScanDeviceInfo.hid2dInfo.castScene);
52     WifiConfigCenter::GetInstance().GetHid2dUpperScene(MIRACAST_SERVICE_UID,
53         mScanDeviceInfo.hid2dInfo.miraCastScene);
54     WifiConfigCenter::GetInstance().GetHid2dUpperScene(SHARE_SERVICE_UID,
55         mScanDeviceInfo.hid2dInfo.shareScene);
56     WifiConfigCenter::GetInstance().GetHid2dUpperScene(MOUSE_CROSS_SERVICE_UID,
57         mScanDeviceInfo.hid2dInfo.mouseCrossScene);
58     scanDeviceInfo = mScanDeviceInfo;
59 }
60 
SaveScanDeviceInfo(WifiScanDeviceInfo & scanDeviceInfo)61 void WifiScanConfig::SaveScanDeviceInfo(WifiScanDeviceInfo &scanDeviceInfo)
62 {
63     std::unique_lock<std::mutex> lock(mScanDeviceInfoMutex);
64     mScanDeviceInfo = scanDeviceInfo;
65 }
66 
SetAppRunningState(ScanMode appRunMode)67 void WifiScanConfig::SetAppRunningState(ScanMode appRunMode)
68 {
69     if (static_cast<int>(appRunMode) < static_cast<int>(ScanMode::APP_FOREGROUND_SCAN) ||
70         static_cast<int>(appRunMode) > static_cast<int>(ScanMode::SYS_BACKGROUND_SCAN)) {
71         return;
72     }
73     std::unique_lock<std::mutex> lock(mScanDeviceInfoMutex);
74     mScanDeviceInfo.scanMode = appRunMode;
75 }
76 
GetAppRunningState()77 ScanMode WifiScanConfig::GetAppRunningState()
78 {
79     std::unique_lock<std::mutex> lock(mScanDeviceInfoMutex);
80     return mScanDeviceInfo.scanMode;
81 }
82 
SetStaScene(const int & scene)83 void WifiScanConfig::SetStaScene(const int &scene)
84 {
85     std::unique_lock<std::mutex> lock(mScanDeviceInfoMutex);
86     mScanDeviceInfo.staScene = scene;
87 }
88 
SetStaSceneForbidCount(int count)89 void WifiScanConfig::SetStaSceneForbidCount(int count)
90 {
91     std::unique_lock<std::mutex> lock(mScanDeviceInfoMutex);
92     mScanDeviceInfo.staSceneForbidCount = count;
93 }
94 
GetStaSceneForbidCount()95 int WifiScanConfig::GetStaSceneForbidCount()
96 {
97     std::unique_lock<std::mutex> lock(mScanDeviceInfoMutex);
98     return mScanDeviceInfo.staSceneForbidCount;
99 }
100 
SetScanControlInfo(const ScanControlInfo & info,int instId)101 void WifiScanConfig::SetScanControlInfo(const ScanControlInfo &info, int instId)
102 {
103     std::unique_lock<std::mutex> lock(mScanDeviceInfoMutex);
104     mScanDeviceInfo.scanControlInfo = info;
105 }
106 
GetScanControlInfo(ScanControlInfo & info,int instId)107 int WifiScanConfig::GetScanControlInfo(ScanControlInfo &info, int instId)
108 {
109     std::unique_lock<std::mutex> lock(mScanDeviceInfoMutex);
110     info = mScanDeviceInfo.scanControlInfo;
111     return 0;
112 }
113 
SetPackageFilter(std::map<std::string,std::vector<std::string>> & filterMap)114 void WifiScanConfig::SetPackageFilter(std::map<std::string, std::vector<std::string>> &filterMap)
115 {
116     std::unique_lock<std::mutex> lock(mScanDeviceInfoMutex);
117     mScanDeviceInfo.scan_thermal_trust_list = filterMap["scan_thermal_filter"];
118     mScanDeviceInfo.scan_frequency_trust_list = filterMap["scan_frequency_filter"];
119     mScanDeviceInfo.scan_screen_off_trust_list = filterMap["scan_screen_off_filter"];
120     mScanDeviceInfo.scan_gps_block_list = filterMap["scan_gps_filter"];
121     mScanDeviceInfo.scan_hid2d_list = filterMap["scan_hid2d_filter"];
122 }
123 
SetMovingFreezeScaned(bool scanned)124 void WifiScanConfig::SetMovingFreezeScaned(bool scanned)
125 {
126     std::unique_lock<std::mutex> lock(mScanDeviceInfoMutex);
127     mScanDeviceInfo.isAbsFreezeScaned = scanned;
128 }
129 
GetMovingFreezeScaned()130 bool WifiScanConfig::GetMovingFreezeScaned()
131 {
132     std::unique_lock<std::mutex> lock(mScanDeviceInfoMutex);
133     return mScanDeviceInfo.isAbsFreezeScaned;
134 }
135 
SetAbnormalApps(const std::vector<std::string> & abnormalAppList)136 void WifiScanConfig::SetAbnormalApps(const std::vector<std::string> &abnormalAppList)
137 {
138     std::unique_lock<std::mutex> lock(mScanDeviceInfoMutex);
139     mScanDeviceInfo.abnormalAppList = abnormalAppList;
140 }
141 
SetAppPackageName(const std::string & appPackageName)142 void WifiScanConfig::SetAppPackageName(const std::string &appPackageName)
143 {
144     std::unique_lock<std::mutex> lock(mScanDeviceInfoMutex);
145     mScanDeviceInfo.packageName = appPackageName;
146 }
147 
GetAppPackageName()148 std::string WifiScanConfig::GetAppPackageName()
149 {
150     std::unique_lock<std::mutex> lock(mScanDeviceInfoMutex);
151     return mScanDeviceInfo.packageName;
152 }
153 
SetStaCurrentTime(time_t time)154 void WifiScanConfig::SetStaCurrentTime(time_t time)
155 {
156     std::unique_lock<std::mutex> lock(mScanDeviceInfoMutex);
157     mScanDeviceInfo.staCurrentTime = time;
158 }
159 
GetStaCurrentTime()160 time_t WifiScanConfig::GetStaCurrentTime()
161 {
162     std::unique_lock<std::mutex> lock(mScanDeviceInfoMutex);
163     return mScanDeviceInfo.staCurrentTime;
164 }
165 
InitScanControlForbidList()166 void WifiScanConfig::InitScanControlForbidList()
167 {
168     std::unique_lock<std::mutex> lock(mScanMutex);
169     /* Disable external scanning during scanning. */
170     ScanForbidMode forbidMode;
171     forbidMode.scanMode = ScanMode::ALL_EXTERN_SCAN;
172     forbidMode.scanScene = SCAN_SCENE_SCANNING;
173     mScanDeviceInfo.scanControlInfo.scanForbidList.push_back(forbidMode);
174 
175     /* Disable external scanning when the screen is shut down. */
176     forbidMode.scanMode = ScanMode::ALL_EXTERN_SCAN;
177     forbidMode.scanScene = SCAN_SCENE_SCREEN_OFF;
178     mScanDeviceInfo.scanControlInfo.scanForbidList.push_back(forbidMode);
179 
180     /* Disable all scans in connection */
181 #ifdef SUPPORT_SCAN_CONTROL
182     forbidMode.scanMode = ScanMode::ALL_EXTERN_SCAN;
183     forbidMode.scanScene = SCAN_SCENE_ASSOCIATING;
184     forbidMode.forbidTime = ASSOCIATING_SCAN_CONTROL_INTERVAL;
185     mScanDeviceInfo.scanControlInfo.scanForbidList.push_back(forbidMode);
186     forbidMode.scanMode = ScanMode::ALL_EXTERN_SCAN;
187     forbidMode.scanScene = SCAN_SCENE_ASSOCIATED;
188     forbidMode.forbidTime = ASSOCIATED_SCAN_CONTROL_INTERVAL;
189     mScanDeviceInfo.scanControlInfo.scanForbidList.push_back(forbidMode);
190     forbidMode.scanMode = ScanMode::ALL_EXTERN_SCAN;
191     forbidMode.scanScene = SCAN_SCENE_OBTAINING_IP;
192     forbidMode.forbidCount = OBTAINING_IP_SCAN_CONTROL_TIMES;
193     forbidMode.forbidTime = OBTAINING_IP_SCAN_CONTROL_INTERVAL;
194     mScanDeviceInfo.scanControlInfo.scanForbidList.push_back(forbidMode);
195 #else
196     forbidMode.scanMode = ScanMode::ALL_EXTERN_SCAN;
197     forbidMode.scanScene = SCAN_SCENE_CONNECTING;
198     mScanDeviceInfo.scanControlInfo.scanForbidList.push_back(forbidMode);
199 #endif
200     forbidMode.scanMode = ScanMode::PNO_SCAN;
201     forbidMode.scanScene = SCAN_SCENE_CONNECTING;
202     mScanDeviceInfo.scanControlInfo.scanForbidList.push_back(forbidMode);
203     forbidMode.scanMode = ScanMode::SYSTEM_TIMER_SCAN;
204     forbidMode.scanScene = SCAN_SCENE_CONNECTING;
205     mScanDeviceInfo.scanControlInfo.scanForbidList.push_back(forbidMode);
206 
207     /* Deep sleep disables all scans. */
208     forbidMode.scanMode = ScanMode::ALL_EXTERN_SCAN;
209     forbidMode.scanScene = SCAN_SCENE_DEEP_SLEEP;
210     mScanDeviceInfo.scanControlInfo.scanForbidList.push_back(forbidMode);
211     forbidMode.scanMode = ScanMode::PNO_SCAN;
212     forbidMode.scanScene = SCAN_SCENE_DEEP_SLEEP;
213     mScanDeviceInfo.scanControlInfo.scanForbidList.push_back(forbidMode);
214     forbidMode.scanMode = ScanMode::SYSTEM_TIMER_SCAN;
215     forbidMode.scanScene = SCAN_SCENE_DEEP_SLEEP;
216     mScanDeviceInfo.scanControlInfo.scanForbidList.push_back(forbidMode);
217 
218     /* PNO scanning disabled */
219     forbidMode.scanMode = ScanMode::PNO_SCAN;
220     forbidMode.scanScene = SCAN_SCENE_CONNECTED;
221     mScanDeviceInfo.scanControlInfo.scanForbidList.push_back(forbidMode);
222     return;
223 }
224 
InitScanControlIntervalList()225 void WifiScanConfig::InitScanControlIntervalList()
226 {
227     std::unique_lock<std::mutex> lock(mScanMutex);
228     /* Foreground app: 4 times in 2 minutes for a single application */
229     ScanIntervalMode scanIntervalMode;
230     scanIntervalMode.scanScene = SCAN_SCENE_FREQUENCY_ORIGIN;
231     scanIntervalMode.scanMode = ScanMode::APP_FOREGROUND_SCAN;
232     scanIntervalMode.isSingle = true;
233     scanIntervalMode.intervalMode = IntervalMode::INTERVAL_FIXED;
234     scanIntervalMode.interval = FOREGROUND_SCAN_CONTROL_INTERVAL;
235     scanIntervalMode.count = FOREGROUND_SCAN_CONTROL_TIMES;
236     mScanDeviceInfo.scanControlInfo.scanIntervalList.push_back(scanIntervalMode);
237 
238     /* Backend apps: once every 30 minutes */
239     scanIntervalMode.scanScene = SCAN_SCENE_FREQUENCY_ORIGIN;
240     scanIntervalMode.scanMode = ScanMode::APP_BACKGROUND_SCAN;
241     scanIntervalMode.isSingle = false;
242     scanIntervalMode.intervalMode = IntervalMode::INTERVAL_FIXED;
243     scanIntervalMode.interval = BACKGROUND_SCAN_CONTROL_INTERVAL;
244     scanIntervalMode.count = BACKGROUND_SCAN_CONTROL_TIMES;
245     mScanDeviceInfo.scanControlInfo.scanIntervalList.push_back(scanIntervalMode);
246 
247     /* no charger plug */
248     /* All app: If the scanning interval is less than 5s for five  */
249     /* consecutive times, the scanning can be performed only after */
250     /* the scanning interval is greater than 5s. */
251     scanIntervalMode.scanScene = SCAN_SCENE_FREQUENCY_CUSTOM;
252     scanIntervalMode.scanMode = ScanMode::ALL_EXTERN_SCAN;
253     scanIntervalMode.isSingle = false;
254     scanIntervalMode.intervalMode = IntervalMode::INTERVAL_CONTINUE;
255     scanIntervalMode.interval = FREQUENCY_CONTINUE_INTERVAL;
256     scanIntervalMode.count = FREQUENCY_CONTINUE_COUNT;
257     mScanDeviceInfo.scanControlInfo.scanIntervalList.push_back(scanIntervalMode);
258 
259     /* no charger plug */
260     /* Single app: If all scanning interval in 10 times is less than */
261     /* the threshold (20s), the app is added to the blocklist and  */
262     /* cannot initiate scanning. */
263     scanIntervalMode.scanScene = SCAN_SCENE_FREQUENCY_CUSTOM;
264     scanIntervalMode.scanMode = ScanMode::ALL_EXTERN_SCAN;
265     scanIntervalMode.isSingle = true;
266     scanIntervalMode.intervalMode = IntervalMode::INTERVAL_BLOCKLIST;
267     scanIntervalMode.interval = FREQUENCY_BLOCKLIST_INTERVAL;
268     scanIntervalMode.count = FREQUENCY_BLOCKLIST_COUNT;
269     mScanDeviceInfo.scanControlInfo.scanIntervalList.push_back(scanIntervalMode);
270 
271     /* PNO scanning every 20 seconds */
272     scanIntervalMode.scanScene = SCAN_SCENE_ALL;
273     scanIntervalMode.scanMode = ScanMode::PNO_SCAN;
274     scanIntervalMode.isSingle = false;
275     scanIntervalMode.intervalMode = IntervalMode::INTERVAL_FIXED;
276     scanIntervalMode.interval = PNO_SCAN_CONTROL_INTERVAL;
277     scanIntervalMode.count = PNO_SCAN_CONTROL_TIMES;
278     mScanDeviceInfo.scanControlInfo.scanIntervalList.push_back(scanIntervalMode);
279 
280     /*
281      * The system scans for 20 seconds, multiplies 2 each time,
282      * and performs scanning every 160 seconds.
283      */
284     scanIntervalMode.scanScene = SCAN_SCENE_ALL;
285     scanIntervalMode.scanMode = ScanMode::SYSTEM_TIMER_SCAN;
286     scanIntervalMode.isSingle = false;
287     scanIntervalMode.intervalMode = IntervalMode::INTERVAL_EXP;
288     scanIntervalMode.interval = SYSTEM_TIMER_SCAN_CONTROL_INTERVAL;
289 #ifdef SUPPORT_SCAN_CONTROL
290     scanIntervalMode.count = 0;
291 #else
292     scanIntervalMode.count = SYSTEM_TIMER_SCAN_CONTROL_TIMES;
293 #endif
294     mScanDeviceInfo.scanControlInfo.scanIntervalList.push_back(scanIntervalMode);
295 }
296 
SaveScanInfoList(const std::vector<WifiScanInfo> & results)297 int WifiScanConfig::SaveScanInfoList(const std::vector<WifiScanInfo> &results)
298 {
299     std::unique_lock<std::mutex> lock(mScanMutex);
300     mWifiScanInfoList.clear();
301     mWifiScanInfoList = results;
302     return 0;
303 }
304 
ClearScanInfoList()305 int WifiScanConfig::ClearScanInfoList()
306 {
307     if (WifiConfigCenter::GetInstance().HasWifiActive()) {
308         return 0;
309     }
310 #ifdef SUPPORT_RANDOM_MAC_ADDR
311     WifiConfigCenter::GetInstance().ClearMacAddrPairs(WifiMacAddrInfoType::WIFI_SCANINFO_MACADDR_INFO);
312 #endif
313     std::unique_lock<std::mutex> lock(mScanMutex);
314     mWifiScanInfoList.clear();
315     return 0;
316 }
317 
GetScanInfoList(std::vector<WifiScanInfo> & results)318 int WifiScanConfig::GetScanInfoList(std::vector<WifiScanInfo> &results)
319 {
320     std::unique_lock<std::mutex> lock(mScanMutex);
321     int64_t currentTime = GetElapsedMicrosecondsSinceBoot();
322     for (auto iter = mWifiScanInfoList.begin(); iter != mWifiScanInfoList.end();) {
323         if (iter->disappearCount >= WIFI_DISAPPEAR_TIMES) {
324 #ifdef SUPPORT_RANDOM_MAC_ADDR
325             WifiConfigCenter::GetInstance().RemoveMacAddrPairInfo(
326                 WifiMacAddrInfoType::WIFI_SCANINFO_MACADDR_INFO, iter->bssid, iter->bssidType);
327 #endif
328             LOGI("ScanInfo remove ssid=%{public}s bssid=%{public}s.\n",
329                 SsidAnonymize(iter->ssid).c_str(), MacAnonymize(iter->bssid).c_str());
330             iter = mWifiScanInfoList.erase(iter);
331             continue;
332         }
333         if (iter->timestamp > currentTime - WIFI_GET_SCAN_INFO_VALID_TIMESTAMP) {
334             results.push_back(*iter);
335         }
336         ++iter;
337     }
338     if (results.empty()) {
339         results.assign(mWifiScanInfoList.begin(), mWifiScanInfoList.end());
340     }
341     LOGI("WifiSettings::GetScanInfoList size = %{public}zu", results.size());
342     return 0;
343 }
344 
GetScanInfoListInner(std::vector<WifiScanInfo> & results)345 void WifiScanConfig::GetScanInfoListInner(std::vector<WifiScanInfo> &results)
346 {
347     std::unique_lock<std::mutex> lock(mScanMutex);
348     results = mWifiScanInfoList;
349 }
350 
RecordWifiCategory(const std::string bssid,WifiCategory category)351 void WifiScanConfig::RecordWifiCategory(const std::string bssid, WifiCategory category)
352 {
353     std::unique_lock<std::mutex> lock(mScanMutex);
354     if (bssid.empty()) {
355         return;
356     }
357     mWifiCategoryRecord.insert_or_assign(bssid, category);
358 }
359 
GetWifiCategoryRecord(const std::string bssid)360 WifiCategory WifiScanConfig::GetWifiCategoryRecord(const std::string bssid)
361 {
362     std::unique_lock<std::mutex> lock(mScanMutex);
363     auto iter = mWifiCategoryRecord.find(bssid);
364     if (iter != mWifiCategoryRecord.end()) {
365         return iter->second;
366     }
367     return WifiCategory::DEFAULT;
368 }
369 
CleanWifiCategoryRecord()370 void WifiScanConfig::CleanWifiCategoryRecord()
371 {
372     std::unique_lock<std::mutex> lock(mScanMutex);
373     mWifiCategoryRecord.clear();
374 }
375 
376 }  // namespace Wifi
377 }  // namespace OHOS
378