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 
16 #include <random>
17 #include "wifi_config_center.h"
18 #include "wifi_logger.h"
19 #include "wifi_common_util.h"
20 #include "wifi_global_func.h"
21 #include "wifi_randommac_helper.h"
22 
23 DEFINE_WIFILOG_LABEL("WifiConfigCenter");
24 
25 namespace OHOS {
26 namespace Wifi {
27 #ifdef DTFUZZ_TEST
28 static WifiConfigCenter* gWifiConfigCenter = nullptr;
29 #endif
GetInstance()30 WifiConfigCenter &WifiConfigCenter::GetInstance()
31 {
32 #ifndef DTFUZZ_TEST
33     static WifiConfigCenter gWifiConfigCenter;
34     return gWifiConfigCenter;
35 #else
36     if (gWifiConfigCenter == nullptr) {
37         gWifiConfigCenter = new (std::nothrow) WifiConfigCenter();
38     }
39     return *gWifiConfigCenter;
40 #endif
41 }
42 
WifiConfigCenter()43 WifiConfigCenter::WifiConfigCenter()
44 {
45     mWifiState.emplace(0, static_cast<int>(WifiState::DISABLED));
46     mWifiDetailState.emplace(0, WifiDetailState::STATE_INACTIVE);
47     mStaMidState.emplace(0, WifiOprMidState::CLOSED);
48     mWifiCloseTime.emplace(0, std::chrono::steady_clock::now());
49     mIsAncoConnected.emplace(0, false);
50     mWifiIpInfo.emplace(0, IpInfo());
51     mWifiIpV6Info.emplace(0, IpV6Info());
52     mWifiLinkedInfo.emplace(0, WifiLinkedInfo());
53     mLastSelectedNetworkId.emplace(0, INVALID_NETWORK_ID);
54     mLastSelectedTimeVal.emplace(0, time(NULL));
55     mBssidToTimeoutTime.emplace(0, std::make_pair("", 0));
56     mLastDiscReason.emplace(0, DisconnectedReason::DISC_REASON_DEFAULT);
57     mScanMidState.emplace(0, WifiOprMidState::CLOSED);
58     mScanOnlyMidState.emplace(0, WifiOprMidState::CLOSED);
59     mApMidState.emplace(0, WifiOprMidState::CLOSED);
60     mHotspotState.emplace(0, static_cast<int>(ApState::AP_STATE_CLOSED));
61     powerModel.emplace(0, PowerModel::GENERAL);
62 }
63 
~WifiConfigCenter()64 WifiConfigCenter::~WifiConfigCenter()
65 {}
66 
Init()67 int WifiConfigCenter::Init()
68 {
69     if (WifiSettings::GetInstance().Init() < 0) {
70         WIFI_LOGE("Init wifi settings failed!");
71         return -1;
72     }
73     wifiScanConfig = std::make_unique<WifiScanConfig>();
74     ClearLocalHid2dInfo();
75     mPersistWifiState[INSTID_WLAN0] = WifiSettings::GetInstance().GetOperatorWifiType(INSTID_WLAN0);
76     mAirplaneModeState = WifiSettings::GetInstance().GetLastAirplaneMode();
77     return 0;
78 }
79 
GetWifiScanConfig()80 std::unique_ptr<WifiScanConfig>& WifiConfigCenter::GetWifiScanConfig()
81 {
82     if (wifiScanConfig == nullptr) {
83         wifiScanConfig = std::make_unique<WifiScanConfig>();
84     }
85     return wifiScanConfig;
86 }
87 
SetWifiSelfcureReset(const bool isReset)88 void WifiConfigCenter::SetWifiSelfcureReset(const bool isReset)
89 {
90     mWifiSelfcureReset = isReset;
91 }
92 
GetWifiSelfcureReset() const93 bool WifiConfigCenter::GetWifiSelfcureReset() const
94 {
95     return mWifiSelfcureReset.load();
96 }
97 
SetWifiSelfcureResetEntered(const bool isReset)98 void WifiConfigCenter::SetWifiSelfcureResetEntered(const bool isReset)
99 {
100     mWifiSelfcureResetEntered = isReset;
101 }
102 
GetWifiSelfcureResetEntered() const103 bool WifiConfigCenter::GetWifiSelfcureResetEntered() const
104 {
105     return mWifiSelfcureResetEntered.load();
106 }
107 
SetLastNetworkId(const int networkId)108 void WifiConfigCenter::SetLastNetworkId(const int networkId)
109 {
110     mLastNetworkId = networkId;
111 }
112 
GetLastNetworkId() const113 int WifiConfigCenter::GetLastNetworkId() const
114 {
115     return mLastNetworkId.load();
116 }
117 
SetSelectedCandidateNetworkId(const int networkId)118 void WifiConfigCenter::SetSelectedCandidateNetworkId(const int networkId)
119 {
120     mSelectedCandidateNetworkId = networkId;
121 }
122 
GetSelectedCandidateNetworkId() const123 int WifiConfigCenter::GetSelectedCandidateNetworkId() const
124 {
125     return mSelectedCandidateNetworkId.load();
126 }
127 
SetWifiAllowSemiActive(bool isAllowed)128 void WifiConfigCenter::SetWifiAllowSemiActive(bool isAllowed)
129 {
130     mWifiAllowSemiActive = isAllowed;
131 }
132 
GetWifiAllowSemiActive() const133 bool WifiConfigCenter::GetWifiAllowSemiActive() const
134 {
135     if (IsFactoryMode()) {
136         WIFI_LOGI("factory mode, not allow semi active.");
137         return false;
138     }
139     return mWifiAllowSemiActive.load();
140 }
141 
SetWifiStopState(bool state)142 void WifiConfigCenter::SetWifiStopState(bool state)
143 {
144     mWifiStoping = state;
145 }
146 
GetWifiStopState() const147 bool WifiConfigCenter::GetWifiStopState() const
148 {
149     return mWifiStoping.load();
150 }
151 
SetStaIfaceName(const std::string & ifaceName,int instId)152 void WifiConfigCenter::SetStaIfaceName(const std::string &ifaceName, int instId)
153 {
154     std::unique_lock<std::mutex> lock(mStaMutex);
155     mStaIfaceName[instId] = ifaceName;
156 }
157 
GetStaIfaceName(int instId)158 std::string WifiConfigCenter::GetStaIfaceName(int instId)
159 {
160     std::unique_lock<std::mutex> lock(mStaMutex);
161     WIFI_LOGD("GetStaIfaceName instId:%{public}d mStaIfaceName[instId]:%{public}s ",
162         instId, mStaIfaceName[instId].c_str());
163     return mStaIfaceName[instId];
164 }
165 
GetWifiState(int instId)166 int WifiConfigCenter::GetWifiState(int instId)
167 {
168     std::unique_lock<std::mutex> lock(mStaMutex);
169     auto iter = mWifiState.find(instId);
170     if (iter != mWifiState.end()) {
171         return iter->second.load();
172     }
173     mWifiState[instId] = static_cast<int>(WifiState::DISABLED);
174     return mWifiState[instId].load();
175 }
176 
SetWifiState(int state,int instId)177 int WifiConfigCenter::SetWifiState(int state, int instId)
178 {
179     std::unique_lock<std::mutex> lock(mStaMutex);
180     mWifiState[instId] = state;
181     return 0;
182 }
183 
GetWifiDetailState(int instId)184 WifiDetailState WifiConfigCenter::GetWifiDetailState(int instId)
185 {
186     std::unique_lock<std::mutex> lock(mStaMutex);
187     auto iter = mWifiDetailState.find(instId);
188     if (iter != mWifiDetailState.end()) {
189         return iter->second;
190     }
191     mWifiDetailState[instId] = WifiDetailState::STATE_UNKNOWN;
192     return mWifiDetailState[instId];
193 }
194 
SetWifiDetailState(WifiDetailState state,int instId)195 int WifiConfigCenter::SetWifiDetailState(WifiDetailState state, int instId)
196 {
197     std::unique_lock<std::mutex> lock(mStaMutex);
198     mWifiDetailState[instId] = state;
199     return 0;
200 }
201 
GetWifiMidState(int instId)202 WifiOprMidState WifiConfigCenter::GetWifiMidState(int instId)
203 {
204     std::unique_lock<std::mutex> lock(mStaMutex);
205     auto iter = mStaMidState.find(instId);
206     if (iter != mStaMidState.end()) {
207         return iter->second.load();
208     } else {
209         mStaMidState.emplace(instId, WifiOprMidState::CLOSED);
210         return mStaMidState[instId].load();
211     }
212 }
213 
SetWifiMidState(WifiOprMidState expState,WifiOprMidState state,int instId)214 bool WifiConfigCenter::SetWifiMidState(WifiOprMidState expState, WifiOprMidState state, int instId)
215 {
216     WIFI_LOGI("SetWifiMidState expState:%{public}d,state:%{public}d,instId:%{public}d",
217         (int)expState, (int)state, instId);
218     std::unique_lock<std::mutex> lock(mStaMutex);
219     auto iter = mStaMidState.find(instId);
220     if (iter != mStaMidState.end()) {
221         return iter->second.compare_exchange_strong(expState, state);
222     } else {
223         mStaMidState.emplace(instId, state);
224         return true;
225     }
226     return false;
227 }
228 
SetWifiMidState(WifiOprMidState state,int instId)229 void WifiConfigCenter::SetWifiMidState(WifiOprMidState state, int instId)
230 {
231     WIFI_LOGI("SetWifiMidState ,state:%{public}d,instId:%{public}d", (int)state, instId);
232     std::unique_lock<std::mutex> lock(mStaMutex);
233     auto ret = mStaMidState.emplace(instId, state);
234     if (!ret.second) {
235         mStaMidState[instId] = state;
236     }
237 }
238 
SetWifiStaCloseTime(int instId)239 void WifiConfigCenter::SetWifiStaCloseTime(int instId)
240 {
241     std::unique_lock<std::mutex> lock(mStaMutex);
242     mWifiCloseTime[instId] = std::chrono::steady_clock::now();
243 }
244 
GetWifiStaInterval(int instId)245 double WifiConfigCenter::GetWifiStaInterval(int instId)
246 {
247     std::unique_lock<std::mutex> lock(mStaMutex);
248     auto iter = mWifiCloseTime.find(instId);
249     if (iter != mWifiCloseTime.end()) {
250         std::chrono::steady_clock::time_point curr = std::chrono::steady_clock::now();
251         double drMs = std::chrono::duration<double, std::milli>(curr - iter->second).count();
252         return drMs;
253     }
254 
255     return 0;
256 }
257 
GetWifiConnectedMode(int instId)258 bool WifiConfigCenter::GetWifiConnectedMode(int instId)
259 {
260     std::unique_lock<std::mutex> lock(mStaMutex);
261     return mIsAncoConnected[instId].load();
262 }
263 
SetWifiConnectedMode(bool isAncoConnected,int instId)264 void WifiConfigCenter::SetWifiConnectedMode(bool isAncoConnected, int instId)
265 {
266     std::unique_lock<std::mutex> lock(mStaMutex);
267     mIsAncoConnected[instId] = isAncoConnected;
268 }
269 
270 
SetChangeDeviceConfig(ConfigChange value,const WifiDeviceConfig & config)271 int WifiConfigCenter::SetChangeDeviceConfig(ConfigChange value, const WifiDeviceConfig &config)
272 {
273     std::unique_lock<std::mutex> lock(mStaMutex);
274     mLastRemoveDeviceConfig = std::make_pair((int)value, config);
275     return WIFI_OPT_SUCCESS;
276 }
277 
GetChangeDeviceConfig(ConfigChange & value,WifiDeviceConfig & config)278 bool WifiConfigCenter::GetChangeDeviceConfig(ConfigChange& value, WifiDeviceConfig &config)
279 {
280     std::unique_lock<std::mutex> lock(mStaMutex);
281     value = (ConfigChange)mLastRemoveDeviceConfig.first;
282     config = mLastRemoveDeviceConfig.second;
283     return true;
284 }
285 
GetIpInfo(IpInfo & info,int instId)286 int WifiConfigCenter::GetIpInfo(IpInfo &info, int instId)
287 {
288     std::unique_lock<std::mutex> lock(mStaMutex);
289     auto iter = mWifiIpInfo.find(instId);
290     if (iter != mWifiIpInfo.end()) {
291         info = iter->second;
292     }
293     return 0;
294 }
295 
SaveIpInfo(const IpInfo & info,int instId)296 int WifiConfigCenter::SaveIpInfo(const IpInfo &info, int instId)
297 {
298     std::unique_lock<std::mutex> lock(mStaMutex);
299     mWifiIpInfo[instId] = info;
300     return 0;
301 }
302 
GetIpv6Info(IpV6Info & info,int instId)303 int WifiConfigCenter::GetIpv6Info(IpV6Info &info, int instId)
304 {
305     std::unique_lock<std::mutex> lock(mStaMutex);
306     auto iter = mWifiIpV6Info.find(instId);
307     if (iter != mWifiIpV6Info.end()) {
308         info = iter->second;
309     }
310     return 0;
311 }
312 
SaveIpV6Info(const IpV6Info & info,int instId)313 int WifiConfigCenter::SaveIpV6Info(const IpV6Info &info, int instId)
314 {
315     std::unique_lock<std::mutex> lock(mStaMutex);
316     mWifiIpV6Info[instId] = info;
317     return 0;
318 }
319 
GetAllWifiLinkedInfo()320 std::map<int, WifiLinkedInfo> WifiConfigCenter::GetAllWifiLinkedInfo()
321 {
322     std::unique_lock<std::mutex> lock(mStaMutex);
323     return mWifiLinkedInfo;
324 }
325 
GetLinkedInfo(WifiLinkedInfo & info,int instId)326 int WifiConfigCenter::GetLinkedInfo(WifiLinkedInfo &info, int instId)
327 {
328     std::unique_lock<std::mutex> lock(mStaMutex);
329     auto iter = mWifiLinkedInfo.find(instId);
330     if (iter != mWifiLinkedInfo.end()) {
331         info = iter->second;
332     }
333     return 0;
334 }
335 
SaveLinkedInfo(const WifiLinkedInfo & info,int instId)336 int WifiConfigCenter::SaveLinkedInfo(const WifiLinkedInfo &info, int instId)
337 {
338     std::unique_lock<std::mutex> lock(mStaMutex);
339     auto iter = mWifiLinkedInfo.find(instId);
340     if (iter != mWifiLinkedInfo.end()) {
341         WifiChannelWidth channelWidth = iter->second.channelWidth;
342         std::string bssid = iter->second.bssid;
343         iter->second = info;
344         if (bssid == info.bssid) {
345             iter->second.channelWidth = channelWidth;
346         }
347     } else {
348         mWifiLinkedInfo.emplace(instId, info);
349     }
350 
351     return 0;
352 }
353 
SetMacAddress(const std::string & macAddress,int instId)354 int WifiConfigCenter::SetMacAddress(const std::string &macAddress, int instId)
355 {
356     std::unique_lock<std::mutex> lock(mStaMutex);
357     mMacAddress[instId] = macAddress;
358     return 0;
359 }
360 
GetMacAddress(std::string & macAddress,int instId)361 int WifiConfigCenter::GetMacAddress(std::string &macAddress, int instId)
362 {
363     std::unique_lock<std::mutex> lock(mStaMutex);
364     auto iter = mMacAddress.find(instId);
365     if (iter != mMacAddress.end()) {
366         macAddress = iter->second;
367     }
368     return 0;
369 }
370 
SetUserLastSelectedNetworkId(int networkId,int instId)371 void WifiConfigCenter::SetUserLastSelectedNetworkId(int networkId, int instId)
372 {
373     std::unique_lock<std::mutex> lock(mStaMutex);
374     mLastSelectedNetworkId[instId] = networkId;
375     mLastSelectedTimeVal[instId] = time(NULL);
376 }
377 
GetUserLastSelectedNetworkId(int instId)378 int WifiConfigCenter::GetUserLastSelectedNetworkId(int instId)
379 {
380     std::unique_lock<std::mutex> lock(mStaMutex);
381     auto iter = mLastSelectedNetworkId.find(instId);
382     if (iter != mLastSelectedNetworkId.end()) {
383         return iter->second;
384     }
385     return -1;
386 }
387 
GetUserLastSelectedNetworkTimeVal(int instId)388 time_t WifiConfigCenter::GetUserLastSelectedNetworkTimeVal(int instId)
389 {
390     std::unique_lock<std::mutex> lock(mStaMutex);
391     auto iter = mLastSelectedTimeVal.find(instId);
392     if (iter != mLastSelectedTimeVal.end()) {
393         return iter->second;
394     }
395     return 0;
396 }
397 
GetConnectTimeoutBssid(int instId)398 std::string WifiConfigCenter::GetConnectTimeoutBssid(int instId)
399 {
400     std::unique_lock<std::mutex> lock(mStaMutex);
401     auto iter = mBssidToTimeoutTime.find(instId);
402     if (iter != mBssidToTimeoutTime.end()) {
403         const int timeout = 30; // 30s
404         if (iter->second.second - static_cast<int>(time(NULL)) > timeout) {
405             return "";
406         }
407         return iter->second.first;
408     }
409     return "";
410 }
411 
SetConnectTimeoutBssid(std::string & bssid,int instId)412 int WifiConfigCenter::SetConnectTimeoutBssid(std::string &bssid, int instId)
413 {
414     std::unique_lock<std::mutex> lock(mStaMutex);
415     time_t now = time(nullptr);
416     if (now == static_cast<time_t>(-1)) {
417         LOGE("SetConnectTimeoutBssid: call time failed!");
418         return -1;
419     }
420     mBssidToTimeoutTime[instId] = std::make_pair(bssid, static_cast<int>(now));
421     return 0;
422 }
423 
SaveDisconnectedReason(DisconnectedReason discReason,int instId)424 void WifiConfigCenter::SaveDisconnectedReason(DisconnectedReason discReason, int instId)
425 {
426     std::unique_lock<std::mutex> lock(mStaMutex);
427     mLastDiscReason[instId] = discReason;
428 }
429 
GetDisconnectedReason(DisconnectedReason & discReason,int instId)430 int WifiConfigCenter::GetDisconnectedReason(DisconnectedReason &discReason, int instId)
431 {
432     std::unique_lock<std::mutex> lock(mStaMutex);
433     auto iter = mLastDiscReason.find(instId);
434     if (iter != mLastDiscReason.end()) {
435         discReason = iter->second;
436     }
437     return 0;
438 }
439 
InsertWifiCategoryBlackListCache(int blacklistType,const std::string currentBssid,const WifiCategoryBlackListInfo wifiBlackListInfo)440 void WifiConfigCenter::InsertWifiCategoryBlackListCache(int blacklistType, const std::string currentBssid,
441     const WifiCategoryBlackListInfo wifiBlackListInfo)
442 {
443     std::unique_lock<std::mutex> lock(mStaMutex);
444     std::map<std::string, WifiCategoryBlackListInfo> wifiBlackListCache;
445     if (mWifiCategoryBlackListCache.find(blacklistType) != mWifiCategoryBlackListCache.end()) {
446         wifiBlackListCache = mWifiCategoryBlackListCache[blacklistType];
447     }
448     auto iter = wifiBlackListCache.find(currentBssid);
449     if (iter != wifiBlackListCache.end()) {
450         iter->second = wifiBlackListInfo;
451     } else {
452         wifiBlackListCache.emplace(std::make_pair(currentBssid, wifiBlackListInfo));
453     }
454     mWifiCategoryBlackListCache[blacklistType] = wifiBlackListCache;
455 }
456 
RemoveWifiCategoryBlackListCache(int blacklistType,const std::string bssid)457 void WifiConfigCenter::RemoveWifiCategoryBlackListCache(int blacklistType, const std::string bssid)
458 {
459     std::unique_lock<std::mutex> lock(mStaMutex);
460     if (mWifiCategoryBlackListCache.find(blacklistType) == mWifiCategoryBlackListCache.end()) {
461         LOGE("%{public}s: dont exist wifi bla type", __func__);
462         return;
463     }
464     std::map<std::string, WifiCategoryBlackListInfo> wifiBlackListCache = mWifiCategoryBlackListCache[blacklistType];
465     if (wifiBlackListCache.find(bssid) != wifiBlackListCache.end()) {
466         wifiBlackListCache.erase(bssid);
467         mWifiCategoryBlackListCache[blacklistType] = wifiBlackListCache;
468     } else {
469         LOGE("%{public}s: don't exist wifi bla list, bssid: %{public}s", __func__, MacAnonymize(bssid).c_str());
470         return;
471     }
472 }
473 
GetWifiCategoryBlackListCache(int blacklistType,std::map<std::string,WifiCategoryBlackListInfo> & blackListCache)474 int WifiConfigCenter::GetWifiCategoryBlackListCache(int blacklistType,
475     std::map<std::string, WifiCategoryBlackListInfo> &blackListCache)
476 {
477     std::unique_lock<std::mutex> lock(mStaMutex);
478     if (mWifiCategoryBlackListCache.find(blacklistType) == mWifiCategoryBlackListCache.end()) {
479         LOGE("%{public}s: dont exist wifi bla type", __func__);
480         return -1;
481     }
482     blackListCache = mWifiCategoryBlackListCache[blacklistType];
483     return 0;
484 }
485 
UpdateWifiConnectFailListCache(int blacklistType,const std::string bssid,const WifiCategoryConnectFailInfo wifiConnectFailInfo)486 void WifiConfigCenter::UpdateWifiConnectFailListCache(int blacklistType, const std::string bssid,
487     const WifiCategoryConnectFailInfo wifiConnectFailInfo)
488 {
489     std::unique_lock<std::mutex> lock(mStaMutex);
490     auto iter = mWifiConnectFailCache.find(bssid);
491     if (iter != mWifiConnectFailCache.end()
492         && iter->second.actionType >= wifiConnectFailInfo.actionType) {
493         iter->second.connectFailTimes++;
494     } else {
495         mWifiConnectFailCache[bssid] = wifiConnectFailInfo;
496     }
497 }
498 
RemoveWifiConnectFailListCache(const std::string bssid)499 void WifiConfigCenter::RemoveWifiConnectFailListCache(const std::string bssid)
500 {
501     std::unique_lock<std::mutex> lock(mStaMutex);
502     if (mWifiConnectFailCache.find(bssid) != mWifiConnectFailCache.end()) {
503         mWifiConnectFailCache.erase(bssid);
504     } else {
505         LOGE("%{public}s: don't exist wifi connect fail list, bssid: %{public}s",
506             __func__, MacAnonymize(bssid).c_str());
507         return;
508     }
509 }
510 
GetWifiConnectFailListCache(std::map<std::string,WifiCategoryConnectFailInfo> & connectFailCache)511 int WifiConfigCenter::GetWifiConnectFailListCache(std::map<std::string,
512     WifiCategoryConnectFailInfo> &connectFailCache)
513 {
514     std::unique_lock<std::mutex> lock(mStaMutex);
515     connectFailCache = mWifiConnectFailCache;
516     return 0;
517 }
518 
EnableNetwork(int networkId,bool disableOthers,int instId)519 bool WifiConfigCenter::EnableNetwork(int networkId, bool disableOthers, int instId)
520 {
521     if (disableOthers) {
522         SetUserLastSelectedNetworkId(networkId, instId);
523     }
524     return true;
525 }
526 
GetScanMidState(int instId)527 WifiOprMidState WifiConfigCenter::GetScanMidState(int instId)
528 {
529     std::unique_lock<std::mutex> lock(mScanMutex);
530     auto iter = mScanMidState.find(instId);
531     if (iter != mScanMidState.end()) {
532         return iter->second.load();
533     } else {
534         mScanMidState.emplace(instId, WifiOprMidState::CLOSED);
535         return mScanMidState[instId].load();
536     }
537 }
538 
SetScanMidState(WifiOprMidState expState,WifiOprMidState state,int instId)539 bool WifiConfigCenter::SetScanMidState(WifiOprMidState expState, WifiOprMidState state, int instId)
540 {
541     std::unique_lock<std::mutex> lock(mScanMutex);
542     auto iter = mScanMidState.find(instId);
543     if (iter != mScanMidState.end()) {
544         return iter->second.compare_exchange_strong(expState, state);
545     } else {
546         mScanMidState.emplace(instId, state);
547         return true;
548     }
549     return false;
550 }
551 
SetScanMidState(WifiOprMidState state,int instId)552 void WifiConfigCenter::SetScanMidState(WifiOprMidState state, int instId)
553 {
554     std::unique_lock<std::mutex> lock(mScanMutex);
555     auto ret = mScanMidState.emplace(instId, state);
556     if (!ret.second) {
557         mScanMidState[instId] = state;
558     }
559 }
560 
GetWifiScanOnlyMidState(int instId)561 WifiOprMidState WifiConfigCenter::GetWifiScanOnlyMidState(int instId)
562 {
563     std::unique_lock<std::mutex> lock(mScanMutex);
564     auto iter = mScanOnlyMidState.find(instId);
565     if (iter != mScanOnlyMidState.end()) {
566         return iter->second.load();
567     } else {
568         mScanOnlyMidState.emplace(instId, WifiOprMidState::CLOSED);
569         return mScanOnlyMidState[instId].load();
570     }
571 }
572 
SetWifiScanOnlyMidState(WifiOprMidState expState,WifiOprMidState state,int instId)573 bool WifiConfigCenter::SetWifiScanOnlyMidState(WifiOprMidState expState, WifiOprMidState state, int instId)
574 {
575     std::unique_lock<std::mutex> lock(mScanMutex);
576     auto iter = mScanOnlyMidState.find(instId);
577     if (iter != mScanOnlyMidState.end()) {
578         return iter->second.compare_exchange_strong(expState, state);
579     } else {
580         mScanOnlyMidState.emplace(instId, state);
581         return true;
582     }
583     return false;
584 }
585 
SetWifiScanOnlyMidState(WifiOprMidState state,int instId)586 void WifiConfigCenter::SetWifiScanOnlyMidState(WifiOprMidState state, int instId)
587 {
588     std::unique_lock<std::mutex> lock(mScanMutex);
589     auto ret = mScanOnlyMidState.emplace(instId, state);
590     if (!ret.second) {
591         mScanOnlyMidState[instId] = state;
592     }
593 }
594 
SetWifiLinkedStandardAndMaxSpeed(WifiLinkedInfo & linkInfo)595 int WifiConfigCenter::SetWifiLinkedStandardAndMaxSpeed(WifiLinkedInfo &linkInfo)
596 {
597     std::vector<WifiScanInfo> wifiScanInfoList;
598     wifiScanConfig->GetScanInfoListInner(wifiScanInfoList);
599     for (auto iter = wifiScanInfoList.begin(); iter != wifiScanInfoList.end(); ++iter) {
600         if (iter->bssid == linkInfo.bssid) {
601             linkInfo.wifiStandard = iter->wifiStandard;
602             linkInfo.maxSupportedRxLinkSpeed = iter->maxSupportedRxLinkSpeed;
603             linkInfo.maxSupportedTxLinkSpeed = iter->maxSupportedTxLinkSpeed;
604             break;
605         }
606     }
607     return 0;
608 }
609 
CheckScanOnlyAvailable(int instId)610 bool WifiConfigCenter::CheckScanOnlyAvailable(int instId)
611 {
612     return (WifiSettings::GetInstance().GetScanOnlySwitchState(instId)) && (GetAirplaneModeState() == MODE_STATE_CLOSE);
613 }
614 
GetConnectedBssid(int instId)615 std::string WifiConfigCenter::GetConnectedBssid(int instId)
616 {
617     WifiLinkedInfo linkedInfo;
618     GetLinkedInfo(linkedInfo, instId);
619     if (linkedInfo.connState == ConnState::CONNECTED) {
620         return linkedInfo.bssid;
621     }
622     return "";
623 }
624 
SetSoftapToggledState(bool state)625 void WifiConfigCenter::SetSoftapToggledState(bool state)
626 {
627     mSoftapToggled = state;
628 }
629 
GetSoftapToggledState() const630 bool WifiConfigCenter::GetSoftapToggledState() const
631 {
632     return mSoftapToggled.load();
633 }
634 
635 
SetHotspotIdleTimeout(int time)636 int WifiConfigCenter::SetHotspotIdleTimeout(int time)
637 {
638     mHotspotIdleTimeout = time;
639     return 0;
640 }
641 
GetHotspotIdleTimeout() const642 int WifiConfigCenter::GetHotspotIdleTimeout() const
643 {
644     return mHotspotIdleTimeout.load();
645 }
646 
SetApIfaceName(const std::string & ifaceName)647 void WifiConfigCenter::SetApIfaceName(const std::string &ifaceName)
648 {
649     std::unique_lock<std::mutex> lock(mApMutex);
650     mApIfaceName = ifaceName;
651 }
652 
GetApIfaceName()653 std::string WifiConfigCenter::GetApIfaceName()
654 {
655     std::unique_lock<std::mutex> lock(mApMutex);
656     return mApIfaceName;
657 }
658 
GetApMidState(int id)659 WifiOprMidState WifiConfigCenter::GetApMidState(int id)
660 {
661     std::unique_lock<std::mutex> lock(mApMutex);
662     auto iter = mApMidState.find(id);
663     if (iter != mApMidState.end()) {
664         return iter->second.load();
665     } else {
666         mApMidState.emplace(id, WifiOprMidState::CLOSED);
667         return mApMidState[id].load();
668     }
669 }
670 
SetApMidState(WifiOprMidState expState,WifiOprMidState state,int id)671 bool WifiConfigCenter::SetApMidState(WifiOprMidState expState, WifiOprMidState state, int id)
672 {
673     std::unique_lock<std::mutex> lock(mApMutex);
674     auto iter = mApMidState.find(id);
675     if (iter != mApMidState.end()) {
676         return iter->second.compare_exchange_strong(expState, state);
677     } else {
678         mApMidState.emplace(id, state);
679         return true;
680     }
681     return false;
682 }
683 
SetApMidState(WifiOprMidState state,int id)684 void WifiConfigCenter::SetApMidState(WifiOprMidState state, int id)
685 {
686     std::unique_lock<std::mutex> lock(mApMutex);
687     auto ret = mApMidState.emplace(id, state);
688     if (!ret.second) {
689         mApMidState[id] = state;
690     }
691 }
692 
GetHotspotState(int id)693 int WifiConfigCenter::GetHotspotState(int id)
694 {
695     std::unique_lock<std::mutex> lock(mApMutex);
696     auto iter = mHotspotState.find(id);
697     if (iter != mHotspotState.end()) {
698         return iter->second.load();
699     }
700     mHotspotState[id] = static_cast<int>(ApState::AP_STATE_CLOSED);
701     return mHotspotState[id].load();
702 }
703 
SetHotspotState(int state,int id)704 int WifiConfigCenter::SetHotspotState(int state, int id)
705 {
706     std::unique_lock<std::mutex> lock(mApMutex);
707     mHotspotState[id] = state;
708     return 0;
709 }
710 
SetPowerModel(const PowerModel & model,int id)711 int WifiConfigCenter::SetPowerModel(const PowerModel& model, int id)
712 {
713     std::unique_lock<std::mutex> lock(mApMutex);
714     auto ret = powerModel.emplace(id, model);
715     if (!ret.second) {
716         powerModel[id] = model;
717     }
718     return 0;
719 }
720 
GetPowerModel(PowerModel & model,int id)721 int WifiConfigCenter::GetPowerModel(PowerModel& model, int id)
722 {
723     std::unique_lock<std::mutex> lock(mApMutex);
724     auto iter = powerModel.find(id);
725     if (iter != powerModel.end()) {
726         model = iter->second;
727     } else {
728         powerModel[id] = PowerModel::GENERAL;
729         model = powerModel[id];
730     }
731     return 0;
732 }
733 
GetStationList(std::vector<StationInfo> & results,int id)734 int WifiConfigCenter::GetStationList(std::vector<StationInfo> &results, int id)
735 {
736     std::unique_lock<std::mutex> lock(mApMutex);
737     for (auto iter = mConnectStationInfo.begin(); iter != mConnectStationInfo.end(); iter++) {
738         results.push_back(iter->second);
739     }
740     return 0;
741 }
742 
ManageStation(const StationInfo & info,int mode,int id)743 int WifiConfigCenter::ManageStation(const StationInfo &info, int mode, int id)
744 {
745     std::unique_lock<std::mutex> lock(mApMutex);
746     auto iter = mConnectStationInfo.find(info.bssid);
747     if (mode == MODE_ADD || mode == MODE_UPDATE) {
748         if (iter != mConnectStationInfo.end()) {
749             iter->second = info;
750         } else {
751             mConnectStationInfo.emplace(std::make_pair(info.bssid, info));
752         }
753 #ifdef SUPPORT_RANDOM_MAC_ADDR
754         StoreWifiMacAddrPairInfo(WifiMacAddrInfoType::HOTSPOT_MACADDR_INFO, info.bssid, "");
755 #endif
756     } else if (mode == MODE_DEL) {
757         if (iter != mConnectStationInfo.end()) {
758             mConnectStationInfo.erase(iter);
759         }
760 #ifdef SUPPORT_RANDOM_MAC_ADDR
761         RemoveMacAddrPairInfo(WifiMacAddrInfoType::HOTSPOT_MACADDR_INFO, info.bssid, info.bssidType);
762 #endif
763     } else {
764         return -1;
765     }
766     return 0;
767 }
768 
ClearStationList(int id)769 int WifiConfigCenter::ClearStationList(int id)
770 {
771 #ifdef SUPPORT_RANDOM_MAC_ADDR
772     ClearMacAddrPairs(WifiMacAddrInfoType::HOTSPOT_MACADDR_INFO);
773 #endif
774     std::unique_lock<std::mutex> lock(mApMutex);
775     mConnectStationInfo.clear();
776     return 0;
777 }
778 
SetP2pIfaceName(const std::string & ifaceName)779 void WifiConfigCenter::SetP2pIfaceName(const std::string &ifaceName)
780 {
781     std::unique_lock<std::mutex> lock(mP2pMutex);
782     mP2pIfaceName = ifaceName;
783 }
784 
GetP2pIfaceName()785 std::string WifiConfigCenter::GetP2pIfaceName()
786 {
787     std::unique_lock<std::mutex> lock(mP2pMutex);
788     return mP2pIfaceName;
789 }
790 
SetHid2dUpperScene(int uid,const Hid2dUpperScene & scene)791 int WifiConfigCenter::SetHid2dUpperScene(int uid, const Hid2dUpperScene &scene)
792 {
793     LOGD("SetHid2dUpperScene uid: %{public}d", uid);
794     std::unique_lock<std::mutex> lock(mP2pMutex);
795     mHid2dUpperScenePair.insert_or_assign(uid, scene);
796     return 0;
797 }
798 
GetHid2dUpperScene(int uid,Hid2dUpperScene & scene)799 int WifiConfigCenter::GetHid2dUpperScene(int uid, Hid2dUpperScene &scene)
800 {
801     std::unique_lock<std::mutex> lock(mP2pMutex);
802     auto iter = mHid2dUpperScenePair.find(uid);
803     if (iter != mHid2dUpperScenePair.end()) {
804         scene = iter->second;
805     }
806     return 0;
807 }
808 
ClearLocalHid2dInfo(int uid)809 void WifiConfigCenter::ClearLocalHid2dInfo(int uid)
810 {
811     std::unique_lock<std::mutex> lock(mP2pMutex);
812     Hid2dUpperScene scene;
813     scene.mac = "";
814     scene.scene = 0;
815     scene.fps = 0;
816     scene.bw = 0;
817     if (uid != 0) {
818         mHid2dUpperScenePair.insert_or_assign(uid, scene);
819     } else {
820         mHid2dUpperScenePair.insert_or_assign(SOFT_BUS_SERVICE_UID, scene);
821         mHid2dUpperScenePair.insert_or_assign(CAST_ENGINE_SERVICE_UID, scene);
822         mHid2dUpperScenePair.insert_or_assign(MIRACAST_SERVICE_UID, scene);
823         mHid2dUpperScenePair.insert_or_assign(SHARE_SERVICE_UID, scene);
824         mHid2dUpperScenePair.insert_or_assign(MOUSE_CROSS_SERVICE_UID, scene);
825     }
826 }
827 
SetP2pEnhanceState(int state)828 int WifiConfigCenter::SetP2pEnhanceState(int state)
829 {
830     mP2pEnhanceState = state;
831     return 0;
832 }
833 
GetP2pEnhanceState()834 int WifiConfigCenter::GetP2pEnhanceState()
835 {
836     return mP2pEnhanceState.load();
837 }
838 
GetP2pMidState()839 WifiOprMidState WifiConfigCenter::GetP2pMidState()
840 {
841     return mP2pMidState.load();
842 }
843 
SetP2pMidState(WifiOprMidState expState,WifiOprMidState state)844 bool WifiConfigCenter::SetP2pMidState(WifiOprMidState expState, WifiOprMidState state)
845 {
846     return mP2pMidState.compare_exchange_strong(expState, state);
847 }
848 
SetP2pMidState(WifiOprMidState state)849 void WifiConfigCenter::SetP2pMidState(WifiOprMidState state)
850 {
851     mP2pMidState = state;
852 }
853 
SetP2pState(int state)854 int WifiConfigCenter::SetP2pState(int state)
855 {
856     mP2pState = state;
857     return 0;
858 }
859 
GetP2pState()860 int WifiConfigCenter::GetP2pState()
861 {
862     return mP2pState.load();
863 }
864 
SetP2pDiscoverState(int state)865 int WifiConfigCenter::SetP2pDiscoverState(int state)
866 {
867     mP2pDiscoverState = state;
868     return 0;
869 }
870 
GetP2pDiscoverState()871 int WifiConfigCenter::GetP2pDiscoverState()
872 {
873     return mP2pDiscoverState.load();
874 }
875 
SetP2pBusinessType(const P2pBusinessType & type)876 int WifiConfigCenter::SetP2pBusinessType(const P2pBusinessType &type)
877 {
878     mP2pBusinessType = type;
879     return 0;
880 }
881 
GetP2pBusinessType(P2pBusinessType & type)882 int WifiConfigCenter::GetP2pBusinessType(P2pBusinessType &type)
883 {
884     type = mP2pBusinessType.load();
885     return 0;
886 }
887 
SaveP2pCreatorUid(int uid)888 int WifiConfigCenter::SaveP2pCreatorUid(int uid)
889 {
890     mP2pCreatorUid = uid;
891     return 0;
892 }
893 
GetP2pCreatorUid()894 int WifiConfigCenter::GetP2pCreatorUid()
895 {
896     return mP2pCreatorUid.load();
897 }
898 
SetExplicitGroup(bool isExplicit)899 void WifiConfigCenter::SetExplicitGroup(bool isExplicit)
900 {
901     mExplicitGroup = isExplicit;
902 }
903 
IsExplicitGroup(void)904 bool WifiConfigCenter::IsExplicitGroup(void)
905 {
906     return mExplicitGroup.load();
907 }
908 
GetP2pInfo(WifiP2pLinkedInfo & linkedInfo)909 int WifiConfigCenter::GetP2pInfo(WifiP2pLinkedInfo &linkedInfo)
910 {
911     std::unique_lock<std::mutex> lock(mP2pMutex);
912     linkedInfo = mWifiP2pInfo;
913     return 0;
914 }
915 
SaveP2pInfo(WifiP2pLinkedInfo & linkedInfo)916 int WifiConfigCenter::SaveP2pInfo(WifiP2pLinkedInfo &linkedInfo)
917 {
918     std::unique_lock<std::mutex> lock(mP2pMutex);
919     mWifiP2pInfo = linkedInfo;
920     return 0;
921 }
922 
SetCurrentP2pGroupInfo(const WifiP2pGroupInfo & group)923 void WifiConfigCenter::SetCurrentP2pGroupInfo(const WifiP2pGroupInfo &group)
924 {
925     std::unique_lock<std::mutex> lock(mP2pMutex);
926     m_P2pGroupInfo = group;
927 }
928 
GetCurrentP2pGroupInfo()929 WifiP2pGroupInfo WifiConfigCenter::GetCurrentP2pGroupInfo()
930 {
931     std::unique_lock<std::mutex> lock(mP2pMutex);
932     return m_P2pGroupInfo;
933 }
934 
SetCoexSupport(bool isSupport)935 void WifiConfigCenter::SetCoexSupport(bool isSupport)
936 {
937     mIsSupportCoex = isSupport;
938 }
939 
GetCoexSupport() const940 bool WifiConfigCenter::GetCoexSupport() const
941 {
942     return mIsSupportCoex.load();
943 }
944 
SetScreenState(const int & state)945 void WifiConfigCenter::SetScreenState(const int &state)
946 {
947     mScreenState = state;
948 }
949 
GetScreenState() const950 int WifiConfigCenter::GetScreenState() const
951 {
952     return mScreenState.load();
953 }
954 
SetThermalLevel(const int & level)955 void WifiConfigCenter::SetThermalLevel(const int &level)
956 {
957     mThermalLevel = level;
958 }
959 
GetThermalLevel() const960 int WifiConfigCenter::GetThermalLevel() const
961 {
962     return mThermalLevel.load();
963 }
964 
SetPowerIdelState(const int & state)965 void WifiConfigCenter::SetPowerIdelState(const int &state)
966 {
967     mPowerIdelState = state;
968 }
969 
GetPowerIdelState() const970 int WifiConfigCenter::GetPowerIdelState() const
971 {
972     return mPowerIdelState.load();
973 }
974 
SetGnssFixState(const int & state)975 void WifiConfigCenter::SetGnssFixState(const int &state)
976 {
977     mGnssFixState = state;
978 }
979 
GetGnssFixState() const980 int WifiConfigCenter::GetGnssFixState() const
981 {
982     return mGnssFixState.load();
983 }
984 
SetScanGenieState(const int & state)985 void WifiConfigCenter::SetScanGenieState(const int &state)
986 {
987     mScanGenieState = state;
988 }
989 
GetScanGenieState() const990 int WifiConfigCenter::GetScanGenieState() const
991 {
992     return mScanGenieState.load();
993 }
994 
SetWifiStateOnAirplaneChanged(const int & state)995 bool WifiConfigCenter::SetWifiStateOnAirplaneChanged(const int &state)
996 {
997     mAirplaneModeState = state;
998     WifiSettings::GetInstance().SetLastAirplaneMode(state);
999     if (WifiSettings::GetInstance().GetWifiFlagOnAirplaneMode()) {
1000         if (GetPersistWifiState(INSTID_WLAN0) == WIFI_STATE_DISABLED) {
1001             return true;
1002         }
1003         if (GetPersistWifiState(INSTID_WLAN0) == WIFI_STATE_SEMI_ENABLED && state == MODE_STATE_OPEN) {
1004             SetPersistWifiState(WIFI_STATE_DISABLED, INSTID_WLAN0);
1005             return true;
1006         }
1007         return false;
1008     }
1009     if (state == MODE_STATE_OPEN) {
1010         if (GetPersistWifiState(INSTID_WLAN0) == WIFI_STATE_ENABLED) {
1011             WifiSettings::GetInstance().SetWifiDisabledByAirplane(true);
1012         }
1013         SetPersistWifiState(WIFI_STATE_DISABLED, INSTID_WLAN0);
1014     } else {
1015         if (WifiSettings::GetInstance().GetWifiDisabledByAirplane()) {
1016             SetPersistWifiState(WIFI_STATE_ENABLED, INSTID_WLAN0);
1017             WifiSettings::GetInstance().SetWifiDisabledByAirplane(false);
1018         }
1019     }
1020     return true;
1021 }
1022 
GetAirplaneModeState() const1023 int WifiConfigCenter::GetAirplaneModeState() const
1024 {
1025     return mAirplaneModeState.load();
1026 }
1027 
GetWifiToggledEnable(int id)1028 int WifiConfigCenter::GetWifiToggledEnable(int id)
1029 {
1030     if (GetAirplaneModeState() == MODE_STATE_OPEN) {
1031         if (GetPersistWifiState(id) == WIFI_STATE_ENABLED) {
1032             return WIFI_STATE_ENABLED;
1033         }
1034         return WIFI_STATE_DISABLED;
1035     }
1036     if (GetPersistWifiState(id) != WIFI_STATE_ENABLED && GetWifiAllowSemiActive()) {
1037         return WIFI_STATE_SEMI_ENABLED;
1038     }
1039     return GetPersistWifiState(id);
1040 }
1041 
SetWifiToggledState(int state,int id)1042 void WifiConfigCenter::SetWifiToggledState(int state, int id)
1043 {
1044     if (GetAirplaneModeState() == MODE_STATE_OPEN) {
1045         WifiSettings::GetInstance().SetWifiDisabledByAirplane(false);
1046         if (state == WIFI_STATE_ENABLED) {
1047             WifiSettings::GetInstance().SetWifiFlagOnAirplaneMode(true);
1048         } else {
1049             WifiSettings::GetInstance().SetWifiFlagOnAirplaneMode(false);
1050             state = WIFI_STATE_DISABLED;
1051         }
1052     }
1053     SetPersistWifiState(state, id);
1054 }
1055 
SetPowerSavingModeState(const int & state)1056 void WifiConfigCenter::SetPowerSavingModeState(const int &state)
1057 {
1058     mPowerSavingModeState = state;
1059 }
1060 
GetPowerSavingModeState() const1061 int WifiConfigCenter::GetPowerSavingModeState() const
1062 {
1063     return mPowerSavingModeState.load();
1064 }
1065 
SetFreezeModeState(int state)1066 void WifiConfigCenter::SetFreezeModeState(int state)
1067 {
1068     mFreezeModeState = state;
1069 }
1070 
GetFreezeModeState() const1071 int WifiConfigCenter::GetFreezeModeState() const
1072 {
1073     return mFreezeModeState.load();
1074 }
1075 
SetNoChargerPlugModeState(int state)1076 void WifiConfigCenter::SetNoChargerPlugModeState(int state)
1077 {
1078     mNoChargerPlugModeState = state;
1079 }
1080 
GetNoChargerPlugModeState() const1081 int WifiConfigCenter::GetNoChargerPlugModeState() const
1082 {
1083     return mNoChargerPlugModeState.load();
1084 }
1085 
SetThreadStatusFlag(bool state)1086 void WifiConfigCenter::SetThreadStatusFlag(bool state)
1087 {
1088     if (state) {
1089         mThreadStartTime = std::chrono::duration_cast<std::chrono::milliseconds>(
1090         std::chrono::steady_clock::now().time_since_epoch()).count();
1091     }
1092     mThreadStatusFlag_ = state;
1093 }
1094 
GetThreadStatusFlag(void) const1095 bool WifiConfigCenter::GetThreadStatusFlag(void) const
1096 {
1097     return mThreadStatusFlag_.load();
1098 }
1099 
GetThreadStartTime(void) const1100 uint64_t WifiConfigCenter::GetThreadStartTime(void) const
1101 {
1102     return mThreadStartTime.load();
1103 }
1104 
StoreWifiMacAddrPairInfo(WifiMacAddrInfoType type,const std::string & realMacAddr,const std::string & randomAddr)1105 bool WifiConfigCenter::StoreWifiMacAddrPairInfo(WifiMacAddrInfoType type, const std::string &realMacAddr,
1106     const std::string &randomAddr)
1107 {
1108     if (realMacAddr.empty()) {
1109         return false;
1110     }
1111 
1112     if (type >= WifiMacAddrInfoType::INVALID_MACADDR_INFO) {
1113         return false;
1114     }
1115 
1116     std::string randomMacAddr;
1117     if (randomAddr.empty()) {
1118         WifiRandomMacHelper::GenerateRandomMacAddressByBssid(realMacAddr, randomMacAddr);
1119     } else {
1120         randomMacAddr = randomAddr;
1121     }
1122     LOGD("%{public}s: type:%{public}d, address:%{private}s, randomAddr:%{private}s, randomMacAddr:%{private}s",
1123         __func__, type, realMacAddr.c_str(), randomAddr.c_str(), randomMacAddr.c_str());
1124     WifiMacAddrInfo realMacAddrInfo;
1125     realMacAddrInfo.bssid = realMacAddr;
1126     realMacAddrInfo.bssidType = REAL_DEVICE_ADDRESS;
1127     WifiMacAddrErrCode ret = AddMacAddrPairs(type, realMacAddrInfo, randomMacAddr);
1128     if (ret == WIFI_MACADDR_OPER_SUCCESS) {
1129         WifiMacAddrInfo randomMacAddrInfo;
1130         randomMacAddrInfo.bssid = randomMacAddr;
1131         randomMacAddrInfo.bssidType = RANDOM_DEVICE_ADDRESS;
1132         AddMacAddrPairs(type, randomMacAddrInfo, realMacAddr);
1133     }
1134     return true;
1135 }
1136 
GetRandomMacAddr(WifiMacAddrInfoType type,std::string bssid)1137 std::string WifiConfigCenter::GetRandomMacAddr(WifiMacAddrInfoType type, std::string bssid)
1138 {
1139     LOGD("%{public}s: query a random mac address, type:%{public}d, bssid:%{private}s",
1140         __func__, type, bssid.c_str());
1141     WifiMacAddrInfo realMacAddrInfo;
1142     realMacAddrInfo.bssid = bssid;
1143     realMacAddrInfo.bssidType = REAL_DEVICE_ADDRESS;
1144     std::string randomMacAddr = GetMacAddrPairs(type, realMacAddrInfo);
1145     if (!randomMacAddr.empty()) {
1146         LOGD("%{public}s: find the record, bssid:%{private}s, bssidType:%{public}d, randomMacAddr:%{private}s",
1147             __func__, realMacAddrInfo.bssid.c_str(), realMacAddrInfo.bssidType, randomMacAddr.c_str());
1148         return randomMacAddr;
1149     } else {
1150         WifiMacAddrInfo randomMacAddrInfo;
1151         randomMacAddrInfo.bssid = bssid;
1152         randomMacAddrInfo.bssidType = RANDOM_DEVICE_ADDRESS;
1153         randomMacAddr = GetMacAddrPairs(type, realMacAddrInfo);
1154         if (!randomMacAddr.empty()) {
1155             LOGD("%{public}s: find the record, bssid:%{private}s, bssidType:%{public}d, randomMacAddr:%{private}s",
1156                 __func__, randomMacAddrInfo.bssid.c_str(), randomMacAddrInfo.bssidType, randomMacAddr.c_str());
1157             return randomMacAddr;
1158         }
1159     }
1160     return "";
1161 }
1162 
RemoveMacAddrPairs(WifiMacAddrInfoType type,const WifiMacAddrInfo & macAddrInfo)1163 int WifiConfigCenter::RemoveMacAddrPairs(WifiMacAddrInfoType type, const WifiMacAddrInfo &macAddrInfo)
1164 {
1165     LOGD("remove a mac address pair, type:%{public}d, bssid:%{private}s, bssidType:%{public}d",
1166         type, macAddrInfo.bssid.c_str(), macAddrInfo.bssidType);
1167     std::unique_lock<std::mutex> lock(mMacAddrPairMutex);
1168     switch (type) {
1169         case WifiMacAddrInfoType::WIFI_SCANINFO_MACADDR_INFO:
1170             DelMacAddrPairs(mWifiScanMacAddrPair, macAddrInfo);
1171             break;
1172         case WifiMacAddrInfoType::HOTSPOT_MACADDR_INFO:
1173             DelMacAddrPairs(mHotspotMacAddrPair, macAddrInfo);
1174             break;
1175         case WifiMacAddrInfoType::P2P_DEVICE_MACADDR_INFO:
1176             DelMacAddrPairs(mP2pDeviceMacAddrPair, macAddrInfo);
1177             break;
1178         case WifiMacAddrInfoType::P2P_GROUPSINFO_MACADDR_INFO:
1179             DelMacAddrPairs(mP2pGroupsInfoMacAddrPair, macAddrInfo);
1180             break;
1181         case WifiMacAddrInfoType::P2P_CURRENT_GROUP_MACADDR_INFO:
1182             DelMacAddrPairs(mP2pCurrentgroupMacAddrPair, macAddrInfo);
1183             break;
1184         default:
1185             LOGE("%{public}s: invalid mac address type, type:%{public}d", __func__, type);
1186             return -1;
1187     }
1188     return 0;
1189 }
1190 
GetMacAddrPairs(WifiMacAddrInfoType type,const WifiMacAddrInfo & macAddrInfo)1191 std::string WifiConfigCenter::GetMacAddrPairs(WifiMacAddrInfoType type, const WifiMacAddrInfo &macAddrInfo)
1192 {
1193     LOGD("get a mac address pair, type:%{public}d, bssid:%{private}s, bssidType:%{public}d",
1194         type, macAddrInfo.bssid.c_str(), macAddrInfo.bssidType);
1195     std::unique_lock<std::mutex> lock(mMacAddrPairMutex);
1196     switch (type) {
1197         case WifiMacAddrInfoType::WIFI_SCANINFO_MACADDR_INFO:
1198             return GetPairMacAddress(mWifiScanMacAddrPair, macAddrInfo);
1199         case WifiMacAddrInfoType::HOTSPOT_MACADDR_INFO:
1200             return GetPairMacAddress(mHotspotMacAddrPair, macAddrInfo);
1201         case WifiMacAddrInfoType::P2P_DEVICE_MACADDR_INFO:
1202             return GetPairMacAddress(mP2pDeviceMacAddrPair, macAddrInfo);
1203         case WifiMacAddrInfoType::P2P_GROUPSINFO_MACADDR_INFO:
1204             return GetPairMacAddress(mP2pGroupsInfoMacAddrPair, macAddrInfo);
1205         case WifiMacAddrInfoType::P2P_CURRENT_GROUP_MACADDR_INFO:
1206             return GetPairMacAddress(mP2pCurrentgroupMacAddrPair, macAddrInfo);
1207         default:
1208             LOGE("%{public}s: invalid mac address type, type:%{public}d", __func__, type);
1209             return "";
1210     }
1211     return "";
1212 }
1213 
ClearMacAddrPairs(WifiMacAddrInfoType type)1214 void WifiConfigCenter::ClearMacAddrPairs(WifiMacAddrInfoType type)
1215 {
1216     LOGI("%{public}s type:%{public}d", __func__, type);
1217     std::unique_lock<std::mutex> lock(mMacAddrPairMutex);
1218     switch (type) {
1219         case WifiMacAddrInfoType::WIFI_SCANINFO_MACADDR_INFO:
1220             mWifiScanMacAddrPair.clear();
1221             break;
1222         case WifiMacAddrInfoType::HOTSPOT_MACADDR_INFO:
1223             mHotspotMacAddrPair.clear();
1224             break;
1225         case WifiMacAddrInfoType::P2P_DEVICE_MACADDR_INFO:
1226             mP2pDeviceMacAddrPair.clear();
1227             break;
1228         case WifiMacAddrInfoType::P2P_GROUPSINFO_MACADDR_INFO:
1229             mP2pGroupsInfoMacAddrPair.clear();
1230             break;
1231         case WifiMacAddrInfoType::P2P_CURRENT_GROUP_MACADDR_INFO:
1232             mP2pCurrentgroupMacAddrPair.clear();
1233             break;
1234         default:
1235             LOGE("%{public}s: invalid mac address type, type:%{public}d", __func__, type);
1236     }
1237     return;
1238 }
1239 
HasWifiActive()1240 bool WifiConfigCenter::HasWifiActive()
1241 {
1242     std::unique_lock<std::mutex> lock(mStaMutex);
1243     for (auto &item : mWifiState) {
1244         int state = item.second.load();
1245         if (state == static_cast<int>(WifiState::ENABLING) || state == static_cast<int>(WifiState::ENABLED)) {
1246             LOGD("HasWifiActive: one wifi is active! instId:%{public}d", item.first);
1247             return true;
1248         }
1249     }
1250     LOGD("HasWifiActive: No wifi is active!");
1251     return false;
1252 }
1253 
UpdateLinkedInfo(int instId)1254 void WifiConfigCenter::UpdateLinkedInfo(int instId)
1255 {
1256     std::vector<WifiScanInfo> wifiScanInfoList;
1257     wifiScanConfig->GetScanInfoListInner(wifiScanInfoList);
1258     for (auto iter = wifiScanInfoList.begin(); iter != wifiScanInfoList.end(); ++iter) {
1259         if (iter->bssid == mWifiLinkedInfo[instId].bssid) {
1260             if (mWifiLinkedInfo[instId].channelWidth == WifiChannelWidth::WIDTH_INVALID) {
1261                 mWifiLinkedInfo[instId].channelWidth = iter->channelWidth;
1262             }
1263             mWifiLinkedInfo[instId].isHiLinkNetwork = iter->isHiLinkNetwork;
1264             break;
1265         }
1266     }
1267     WifiCategory category = wifiScanConfig->GetWifiCategoryRecord(mWifiLinkedInfo[instId].bssid);
1268     mWifiLinkedInfo[instId].supportedWifiCategory = category;
1269     LOGD("WifiSettings UpdateLinkedInfo.");
1270 }
1271 
SetPersistWifiState(int state,int instId)1272 void WifiConfigCenter::SetPersistWifiState(int state, int instId)
1273 {
1274     if (instId < 0 || instId >= STA_INSTANCE_MAX_NUM) {
1275         LOGE("SetPersistWifiState invalid instId %{public}d", instId);
1276         return;
1277     }
1278     mPersistWifiState.at(instId) = state;
1279     WifiSettings::GetInstance().SetOperatorWifiType(state, instId);
1280     LOGI("persist wifi state is %{public}d", state);
1281 }
1282 
GetPersistWifiState(int instId)1283 int WifiConfigCenter::GetPersistWifiState(int instId)
1284 {
1285     if (instId < 0 || instId >= STA_INSTANCE_MAX_NUM) {
1286         LOGE("GetPersistWifiState invalid instId %{public}d", instId);
1287         return -1;
1288     }
1289     return mPersistWifiState.at(instId);
1290 }
1291 
GetPairMacAddress(std::map<WifiMacAddrInfo,std::string> & macAddrInfoMap,const WifiMacAddrInfo & macAddrInfo)1292 std::string WifiConfigCenter::GetPairMacAddress(std::map<WifiMacAddrInfo, std::string>& macAddrInfoMap,
1293     const WifiMacAddrInfo &macAddrInfo)
1294 {
1295     auto iter = macAddrInfoMap.find(macAddrInfo);
1296     if (iter != macAddrInfoMap.end()) {
1297         LOGD("%{public}s: find the record, realMacAddr:%{private}s, bssidType:%{public}d, randomMacAddr:%{private}s",
1298             __func__, macAddrInfo.bssid.c_str(), macAddrInfo.bssidType, iter->second.c_str());
1299         return iter->second;
1300     } else {
1301         LOGD("%{public}s: record not found.", __func__);
1302     }
1303     return "";
1304 }
1305 
InsertMacAddrPairs(std::map<WifiMacAddrInfo,std::string> & macAddrInfoMap,const WifiMacAddrInfo & macAddrInfo,std::string & randomMacAddr)1306 WifiMacAddrErrCode WifiConfigCenter::InsertMacAddrPairs(std::map<WifiMacAddrInfo, std::string>& macAddrInfoMap,
1307     const WifiMacAddrInfo &macAddrInfo, std::string& randomMacAddr)
1308 {
1309     auto iter = macAddrInfoMap.find(macAddrInfo);
1310     if (iter != macAddrInfoMap.end()) {
1311         LOGD("%{public}s: the record is existed, macAddr:%{private}s, bssidType:%{public}d, value:%{private}s",
1312             __func__, macAddrInfo.bssid.c_str(), macAddrInfo.bssidType, iter->second.c_str());
1313         return WIFI_MACADDR_HAS_EXISTED;
1314     } else {
1315         macAddrInfoMap.insert(std::make_pair(macAddrInfo, randomMacAddr));
1316         LOGD("%{public}s: add a mac address pair, bssid:%{private}s, bssidType:%{public}d, randomMacAddr:%{private}s",
1317             __func__, macAddrInfo.bssid.c_str(), macAddrInfo.bssidType, randomMacAddr.c_str());
1318         return WIFI_MACADDR_OPER_SUCCESS;
1319     }
1320 }
1321 
DelMacAddrPairs(std::map<WifiMacAddrInfo,std::string> & macAddrInfoMap,const WifiMacAddrInfo & macAddrInfo)1322 void WifiConfigCenter::DelMacAddrPairs(std::map<WifiMacAddrInfo, std::string>& macAddrInfoMap,
1323     const WifiMacAddrInfo &macAddrInfo)
1324 {
1325     auto iter = macAddrInfoMap.find(macAddrInfo);
1326     if (iter != macAddrInfoMap.end()) {
1327         if (iter->second.empty()) {
1328             LOGI("%{public}s: invalid record, bssid:%{private}s, bssidType:%{public}d",
1329                 __func__, iter->first.bssid.c_str(), iter->first.bssidType);
1330         } else {
1331             LOGD("%{public}s:find the record, realMacAddr:%{private}s, bssidType:%{public}d, randomMacAddr:%{private}s",
1332                 __func__, macAddrInfo.bssid.c_str(), macAddrInfo.bssidType, iter->second.c_str());
1333         }
1334         macAddrInfoMap.erase(iter);
1335     }
1336 }
1337 
RemoveMacAddrPairInfo(WifiMacAddrInfoType type,std::string bssid,int bssidType)1338 void WifiConfigCenter::RemoveMacAddrPairInfo(WifiMacAddrInfoType type, std::string bssid, int bssidType)
1339 {
1340     LOGD("%{public}s: remove a mac address pair, type:%{public}d, bssid:%{private}s",
1341         __func__, type, bssid.c_str());
1342     WifiMacAddrInfo randomMacAddrInfo;
1343     randomMacAddrInfo.bssid = GetRandomMacAddr(type, bssid);
1344     randomMacAddrInfo.bssidType = REAL_DEVICE_ADDRESS == bssidType ? RANDOM_DEVICE_ADDRESS : REAL_DEVICE_ADDRESS;
1345     RemoveMacAddrPairs(type, randomMacAddrInfo);
1346 
1347     WifiMacAddrInfo realMacAddrInfo;
1348     realMacAddrInfo.bssid = bssid;
1349     realMacAddrInfo.bssidType = REAL_DEVICE_ADDRESS == bssidType ? REAL_DEVICE_ADDRESS : RANDOM_DEVICE_ADDRESS;
1350     RemoveMacAddrPairs(type, realMacAddrInfo);
1351 }
1352 
AddMacAddrPairs(WifiMacAddrInfoType type,const WifiMacAddrInfo & macAddrInfo,std::string randomMacAddr)1353 WifiMacAddrErrCode WifiConfigCenter::AddMacAddrPairs(WifiMacAddrInfoType type,
1354     const WifiMacAddrInfo &macAddrInfo, std::string randomMacAddr)
1355 {
1356     if ((type >= WifiMacAddrInfoType::INVALID_MACADDR_INFO) || macAddrInfo.bssid.empty()) {
1357         LOGE("%{public}s: invalid parameter, type:%{public}d, bssid:%{private}s",
1358             __func__, type, macAddrInfo.bssid.c_str());
1359         return WIFI_MACADDR_INVALID_PARAM;
1360     }
1361     std::unique_lock<std::mutex> lock(mMacAddrPairMutex);
1362     switch (type) {
1363         case WifiMacAddrInfoType::WIFI_SCANINFO_MACADDR_INFO:
1364             return InsertMacAddrPairs(mWifiScanMacAddrPair, macAddrInfo, randomMacAddr);
1365         case WifiMacAddrInfoType::HOTSPOT_MACADDR_INFO:
1366             return InsertMacAddrPairs(mHotspotMacAddrPair, macAddrInfo, randomMacAddr);
1367         case WifiMacAddrInfoType::P2P_DEVICE_MACADDR_INFO:
1368             return InsertMacAddrPairs(mP2pDeviceMacAddrPair, macAddrInfo, randomMacAddr);
1369         case WifiMacAddrInfoType::P2P_GROUPSINFO_MACADDR_INFO:
1370             return InsertMacAddrPairs(mP2pGroupsInfoMacAddrPair, macAddrInfo, randomMacAddr);
1371         case WifiMacAddrInfoType::P2P_CURRENT_GROUP_MACADDR_INFO:
1372             return InsertMacAddrPairs(mP2pCurrentgroupMacAddrPair, macAddrInfo, randomMacAddr);
1373         default:
1374             LOGE("%{public}s: invalid mac address type, type:%{public}d", __func__, type);
1375             break;
1376     }
1377     return WIFI_MACADDR_INVALID_PARAM;
1378 }
1379 
GetAllWifiLinkedNetworkId()1380 std::set<int> WifiConfigCenter::GetAllWifiLinkedNetworkId()
1381 {
1382     std::unique_lock<std::mutex> lock(mStaMutex);
1383     std::set<int> wifiLinkedNetworkId;
1384     for (auto iter = mWifiLinkedInfo.begin(); iter != mWifiLinkedInfo.end(); iter++) {
1385         wifiLinkedNetworkId.insert(iter->second.networkId);
1386     }
1387     return wifiLinkedNetworkId;
1388 }
1389 
SetHotspotMacConfig(const HotspotMacConfig & config,int id)1390 int WifiConfigCenter::SetHotspotMacConfig(const HotspotMacConfig &config, int id)
1391 {
1392     std::unique_lock<std::mutex> lock(mApMutex);
1393     mHotspotMacConfig[id] = config;
1394     return 0;
1395 }
1396 
GetHotspotMacConfig(HotspotMacConfig & config,int id)1397 int WifiConfigCenter::GetHotspotMacConfig(HotspotMacConfig &config, int id)
1398 {
1399     std::unique_lock<std::mutex> lock(mApMutex);
1400     auto iter = mHotspotMacConfig.find(id);
1401     if (iter != mHotspotMacConfig.end()) {
1402         config = iter->second;
1403     }
1404     return 0;
1405 }
1406 }  // namespace Wifi
1407 }  // namespace OHOS
1408