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