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 #ifdef HDI_CHIP_INTERFACE_SUPPORT
17 
18 #include <unistd.h>
19 #include <net/if.h>
20 #include <sys/ioctl.h>
21 #include <sys/socket.h>
22 #include "hal_device_manage.h"
23 #include "wifi_log.h"
24 #include "wifi_sta_hal_interface.h"
25 #include "wifi_p2p_hal_interface.h"
26 #include "wifi_ap_hal_interface.h"
27 #include "wifi_supplicant_hal_interface.h"
28 #include "servmgr_hdi.h"
29 #include "hdf_remote_service.h"
30 #include "wifi_config_center.h"
31 
32 #undef LOG_TAG
33 #define LOG_TAG "HalDeviceManager"
34 
35 namespace OHOS {
36 namespace Wifi {
37 constexpr const char *CHIP_SERVICE_NAME = "chip_interface_service";
38 std::atomic_bool HalDeviceManager::g_chipHdiServiceDied = false;
39 std::mutex HalDeviceManager::mMutex;
40 static HdfRemoteService *g_chipHdiService = nullptr;
41 static RssiReportCallback g_rssiReportCallback = nullptr;
42 
HalDeviceManager()43 HalDeviceManager::HalDeviceManager()
44 {
45     LOGI("HalDeviceManager::HalDeviceManager");
46     mInterfaceInfoCache.clear();
47     mIWifiStaIfaces.clear();
48     mIWifiApIfaces.clear();
49     mIWifiP2pIfaces.clear();
50 }
51 
~HalDeviceManager()52 HalDeviceManager::~HalDeviceManager()
53 {
54     LOGI("HalDeviceManager::~HalDeviceManager");
55     StopChipHdi();
56     ResetHalDeviceManagerInfo();
57 }
58 
StartChipHdi()59 bool HalDeviceManager::StartChipHdi()
60 {
61     std::lock_guard<std::mutex> lock(mMutex);
62     LOGI("StartChipHdi start...");
63     if (g_IWifi != nullptr) {
64         bool isInit = false;
65         g_IWifi->IsInit(isInit);
66         if (isInit) {
67             LOGI("has start");
68             return true;
69         }
70     }
71     g_IWifi = IChipController::Get(CHIP_SERVICE_NAME, false);
72     CHECK_NULL_AND_RETURN(g_IWifi, false);
73 
74     if (g_chipControllerCallback == nullptr) {
75         g_chipControllerCallback = new (std::nothrow) ChipControllerCallback();
76     }
77     CHECK_NULL_AND_RETURN(g_chipControllerCallback, false);
78     int32_t ret = g_IWifi->RegisterWifiEventCallback(g_chipControllerCallback);
79     if (ret != HDF_SUCCESS) {
80         LOGE("StartChipHdi, call RegisterWifiEventCallback failed! ret:%{public}d", ret);
81         return false;
82     }
83 
84     if (g_chipIfaceCallback == nullptr) {
85         g_chipIfaceCallback = new (std::nothrow) ChipIfaceCallback();
86     }
87 
88     AddChipHdiDeathRecipient();
89 
90     ret = g_IWifi->Init();
91     if (ret != HDF_SUCCESS) {
92         LOGE("StartChipHdi, call Init failed! ret:%{public}d", ret);
93         return false;
94     }
95     LOGI("StartChipHdi success...");
96     return true;
97 }
98 
StopChipHdi()99 void HalDeviceManager::StopChipHdi()
100 {
101     std::lock_guard<std::mutex> lock(mMutex);
102     LOGI("StopChipHdi start...");
103     CHECK_NULL_AND_RETURN_NULL(g_IWifi);
104     int32_t ret = g_IWifi->Release();
105     if (ret != HDF_SUCCESS) {
106         LOGE("StopChipHdi, call Release failed! ret:%{public}d", ret);
107         return;
108     }
109     LOGI("StopChipHdi success...");
110     return;
111 }
112 
CreateStaIface(const IfaceDestoryCallback & ifaceDestoryCallback,const RssiReportCallback & rssiReportCallback,std::string & ifaceName,int instId)113 bool HalDeviceManager::CreateStaIface(const IfaceDestoryCallback &ifaceDestoryCallback,
114                                       const RssiReportCallback &rssiReportCallback, std::string &ifaceName, int instId)
115 {
116     LOGI("CreateStaIface, ifaceName: %{public}s, instId = %{public}d", ifaceName.c_str(), instId);
117     if (!CheckReloadChipHdiService()) {
118         LOGE("CreateStaIface CheckReloadChipHdiService failed");
119         return false;
120     }
121 
122     std::lock_guard<std::mutex> lock(mMutex);
123     sptr<IChipIface> iface = nullptr;
124     if (!CreateIface(IfaceType::STA, ifaceDestoryCallback, ifaceName, iface)) {
125         LOGE("CreateStaIface failed");
126         return false;
127     }
128 
129     CHECK_NULL_AND_RETURN(iface, false);
130     CHECK_NULL_AND_RETURN(g_chipIfaceCallback, false);
131     if (instId == INSTID_WLAN0) {
132         int32_t ret = iface->RegisterChipIfaceCallBack(g_chipIfaceCallback);
133         if (ret != HDF_SUCCESS) {
134             LOGE("CreateStaIface, call RegisterChipIfaceCallBack failed! ret:%{public}d", ret);
135             return false;
136         }
137         g_rssiReportCallback = rssiReportCallback;
138     } else {
139         LOGE("CreateStaIface wlan1 skip scan callback instId = %{public}d", instId);
140     }
141 
142     mIWifiStaIfaces[ifaceName] = iface;
143     LOGI("CreateStaIface success! ifaceName:%{public}s", ifaceName.c_str());
144     return true;
145 }
146 
CreateApIface(const IfaceDestoryCallback & ifaceDestoryCallback,std::string & ifaceName)147 bool HalDeviceManager::CreateApIface(const IfaceDestoryCallback &ifaceDestoryCallback, std::string &ifaceName)
148 {
149     if (!CheckReloadChipHdiService()) {
150         return false;
151     }
152 
153     std::lock_guard<std::mutex> lock(mMutex);
154     sptr<IChipIface> iface = nullptr;
155     if (!CreateIface(IfaceType::AP, ifaceDestoryCallback, ifaceName, iface)) {
156         LOGE("CreateApIface failed");
157         return false;
158     }
159 
160     mIWifiApIfaces[ifaceName] = iface;
161     LOGI("CreateApIface success! ifaceName:%{public}s", ifaceName.c_str());
162     return true;
163 }
164 
CreateP2pIface(const IfaceDestoryCallback & ifaceDestoryCallback,std::string & ifaceName)165 bool HalDeviceManager::CreateP2pIface(const IfaceDestoryCallback &ifaceDestoryCallback, std::string &ifaceName)
166 {
167     if (!CheckReloadChipHdiService()) {
168         return false;
169     }
170 
171     std::lock_guard<std::mutex> lock(mMutex);
172     sptr<IChipIface> iface = nullptr;
173     if (!CreateIface(IfaceType::P2P, ifaceDestoryCallback, ifaceName, iface)) {
174         LOGE("CreateP2pIface failed");
175         return false;
176     }
177 
178     mIWifiP2pIfaces[ifaceName] = iface;
179     LOGI("CreateP2pIface success! ifaceName:%{public}s", ifaceName.c_str());
180     return true;
181 }
182 
RemoveStaIface(const std::string & ifaceName)183 bool HalDeviceManager::RemoveStaIface(const std::string &ifaceName)
184 {
185     if (!CheckReloadChipHdiService()) {
186         return false;
187     }
188 
189     std::lock_guard<std::mutex> lock(mMutex);
190     LOGI("RemoveStaIface, ifaceName:%{public}s", ifaceName.c_str());
191     auto iter = mIWifiStaIfaces.find(ifaceName);
192     if (iter == mIWifiStaIfaces.end()) {
193         LOGE("RemoveStaIface, not find iface info");
194         return false;
195     }
196 
197     if (!RemoveIface(iter->second, false, IfaceType::STA)) {
198         LOGE("RemoveStaIface, remove iface failed");
199         return false;
200     }
201 
202     LOGI("RemoveStaIface success");
203     return true;
204 }
205 
RemoveApIface(const std::string & ifaceName)206 bool HalDeviceManager::RemoveApIface(const std::string &ifaceName)
207 {
208     if (!CheckReloadChipHdiService()) {
209         return false;
210     }
211 
212     std::lock_guard<std::mutex> lock(mMutex);
213     LOGI("RemoveApIface, ifaceName:%{public}s", ifaceName.c_str());
214     auto iter = mIWifiApIfaces.find(ifaceName);
215     if (iter == mIWifiApIfaces.end()) {
216         LOGE("RemoveApIface, not find iface info");
217         return false;
218     }
219 
220     if (!RemoveIface(iter->second, false, IfaceType::AP)) {
221         LOGE("RemoveApIface, remove iface failed");
222         return false;
223     }
224 
225     LOGI("RemoveApIface success");
226     return true;
227 }
228 
RemoveP2pIface(const std::string & ifaceName)229 bool HalDeviceManager::RemoveP2pIface(const std::string &ifaceName)
230 {
231     if (!CheckReloadChipHdiService()) {
232         return false;
233     }
234 
235     std::lock_guard<std::mutex> lock(mMutex);
236     LOGI("RemoveP2pIface, ifaceName:%{public}s", ifaceName.c_str());
237     auto iter = mIWifiP2pIfaces.find(ifaceName);
238     if (iter == mIWifiP2pIfaces.end()) {
239         LOGE("RemoveP2pIface, not find iface info");
240         return false;
241     }
242 
243     if (!RemoveIface(iter->second, false, IfaceType::P2P)) {
244         LOGE("RemoveP2pIface, remove iface failed");
245         return false;
246     }
247 
248     LOGI("RemoveP2pIface success");
249     return true;
250 }
251 
Scan(const std::string & ifaceName,const ScanParams & scanParams)252 bool HalDeviceManager::Scan(const std::string &ifaceName, const ScanParams &scanParams)
253 {
254     if (!CheckReloadChipHdiService()) {
255         return false;
256     }
257 
258     std::lock_guard<std::mutex> lock(mMutex);
259     LOGI("Scan, ifaceName:%{public}s", ifaceName.c_str());
260     auto iter = mIWifiStaIfaces.find(ifaceName);
261     if (iter == mIWifiStaIfaces.end()) {
262         LOGE("Scan, not find iface info");
263         return false;
264     }
265 
266     sptr<IChipIface> &iface = iter->second;
267     CHECK_NULL_AND_RETURN(iface, false);
268     int32_t ret = iface->StartScan(scanParams);
269     if (ret != HDF_SUCCESS) {
270         LOGE("Scan, call StartScan failed! ret:%{public}d", ret);
271         return false;
272     }
273 
274     LOGI("Scan success");
275     return true;
276 }
277 
StartPnoScan(const std::string & ifaceName,const PnoScanParams & scanParams)278 bool HalDeviceManager::StartPnoScan(const std::string &ifaceName, const PnoScanParams &scanParams)
279 {
280     if (!CheckReloadChipHdiService()) {
281         return false;
282     }
283 
284     std::lock_guard<std::mutex> lock(mMutex);
285     LOGI("StartPnoScan, ifaceName:%{public}s", ifaceName.c_str());
286     auto iter = mIWifiStaIfaces.find(ifaceName);
287     if (iter == mIWifiStaIfaces.end()) {
288         LOGE("StartPnoScan, not find iface info");
289         return false;
290     }
291 
292     sptr<IChipIface> &iface = iter->second;
293     CHECK_NULL_AND_RETURN(iface, false);
294     int32_t ret = iface->StartPnoScan(scanParams);
295     if (ret != HDF_SUCCESS) {
296         LOGE("StartPnoScan, call StartPnoScan failed! ret:%{public}d", ret);
297         return false;
298     }
299 
300     LOGI("StartPnoScan success");
301     return true;
302 }
303 
StopPnoScan(const std::string & ifaceName)304 bool HalDeviceManager::StopPnoScan(const std::string &ifaceName)
305 {
306     if (!CheckReloadChipHdiService()) {
307         return false;
308     }
309 
310     std::lock_guard<std::mutex> lock(mMutex);
311     LOGI("StopPnoScan, ifaceName:%{public}s", ifaceName.c_str());
312     auto iter = mIWifiStaIfaces.find(ifaceName);
313     if (iter == mIWifiStaIfaces.end()) {
314         LOGE("StopPnoScan, not find iface info");
315         return false;
316     }
317 
318     sptr<IChipIface> &iface = iter->second;
319     CHECK_NULL_AND_RETURN(iface, false);
320     int32_t ret = iface->StopPnoScan();
321     if (ret != HDF_SUCCESS) {
322         LOGE("StopPnoScan, call StopPnoScan failed! ret:%{public}d", ret);
323         return false;
324     }
325 
326     LOGI("StopPnoScan success");
327     return true;
328 }
329 
GetScanInfos(const std::string & ifaceName,std::vector<ScanResultsInfo> & scanResultsInfo)330 bool HalDeviceManager::GetScanInfos(const std::string &ifaceName, std::vector<ScanResultsInfo> &scanResultsInfo)
331 {
332     if (!CheckReloadChipHdiService()) {
333         return false;
334     }
335 
336     std::lock_guard<std::mutex> lock(mMutex);
337     LOGI("GetScanInfos, ifaceName:%{public}s", ifaceName.c_str());
338     auto iter = mIWifiStaIfaces.find(ifaceName);
339     if (iter == mIWifiStaIfaces.end()) {
340         LOGE("GetScanInfos, not find iface info");
341         return false;
342     }
343 
344     sptr<IChipIface> &iface = iter->second;
345     CHECK_NULL_AND_RETURN(iface, false);
346     int32_t ret = iface->GetScanInfos(scanResultsInfo);
347     if (ret != HDF_SUCCESS) {
348         LOGE("GetScanInfos, call GetScanInfos failed! ret:%{public}d", ret);
349         return false;
350     }
351 
352     LOGI("GetScanInfos success, scan info size:%{public}d", static_cast<int>(scanResultsInfo.size()));
353     return true;
354 }
355 
GetConnectSignalInfo(const std::string & ifaceName,SignalPollResult & signalPollResult)356 bool HalDeviceManager::GetConnectSignalInfo(const std::string &ifaceName, SignalPollResult &signalPollResult)
357 {
358     if (!CheckReloadChipHdiService()) {
359         return false;
360     }
361 
362     std::lock_guard<std::mutex> lock(mMutex);
363     LOGD("GetConnectSignalInfo, ifaceName:%{public}s", ifaceName.c_str());
364     auto iter = mIWifiStaIfaces.find(ifaceName);
365     if (iter == mIWifiStaIfaces.end()) {
366         LOGE("GetConnectSignalInfo, not find iface info");
367         return false;
368     }
369 
370     sptr<IChipIface> &iface = iter->second;
371     CHECK_NULL_AND_RETURN(iface, false);
372     int32_t ret = iface->GetSignalPollInfo(signalPollResult);
373     if (ret != HDF_SUCCESS) {
374         LOGE("GetConnectSignalInfo, call GetSignalPollInfo failed! ret:%{public}d", ret);
375         return false;
376     }
377 
378     LOGD("GetConnectSignalInfo success");
379     return true;
380 }
381 
SetPmMode(const std::string & ifaceName,int mode)382 bool HalDeviceManager::SetPmMode(const std::string &ifaceName, int mode)
383 {
384     if (!CheckReloadChipHdiService()) {
385         return false;
386     }
387 
388     std::lock_guard<std::mutex> lock(mMutex);
389     LOGI("SetPmMode, ifaceName:%{public}s, mode:%{public}d", ifaceName.c_str(), mode);
390     auto iter = mIWifiStaIfaces.find(ifaceName);
391     if (iter == mIWifiStaIfaces.end()) {
392         LOGE("SetPmMode, not find iface info");
393         return false;
394     }
395 
396     sptr<IChipIface> &iface = iter->second;
397     CHECK_NULL_AND_RETURN(iface, false);
398     int32_t ret = iface->EnablePowerMode(mode);
399     if (ret != HDF_SUCCESS) {
400         LOGE("SetPmMode, call EnablePowerMode failed! ret:%{public}d", ret);
401         return false;
402     }
403 
404     LOGI("SetPmMode success");
405     return true;
406 }
407 
SetDpiMarkRule(const std::string & ifaceName,int uid,int protocol,int enable)408 bool HalDeviceManager::SetDpiMarkRule(const std::string &ifaceName, int uid, int protocol, int enable)
409 {
410     if (!CheckReloadChipHdiService()) {
411         return false;
412     }
413 
414     std::lock_guard<std::mutex> lock(mMutex);
415     LOGI("SetDpiMarkRule, ifaceName:%{public}s, uid:%{public}d, protocol:%{public}d, enable:%{public}d",
416         ifaceName.c_str(), uid, protocol, enable);
417     auto iter = mIWifiStaIfaces.find(ifaceName);
418     if (iter == mIWifiStaIfaces.end()) {
419         LOGE("SetDpiMarkRule, not find iface info");
420         return false;
421     }
422 
423     sptr<IChipIface> &iface = iter->second;
424     CHECK_NULL_AND_RETURN(iface, false);
425     int32_t ret = iface->SetDpiMarkRule(uid, protocol, enable);
426     if (ret != HDF_SUCCESS) {
427         LOGE("SetDpiMarkRule, call SetDpiMarkRule failed! ret:%{public}d", ret);
428         return false;
429     }
430 
431     LOGI("SetDpiMarkRule success");
432     return true;
433 }
434 
SetStaMacAddress(const std::string & ifaceName,const std::string & mac)435 bool HalDeviceManager::SetStaMacAddress(const std::string &ifaceName, const std::string &mac)
436 {
437     if (!CheckReloadChipHdiService()) {
438         return false;
439     }
440 
441     std::lock_guard<std::mutex> lock(mMutex);
442     LOGI("SetStaMacAddress, ifaceName:%{public}s", ifaceName.c_str());
443     auto iter = mIWifiStaIfaces.find(ifaceName);
444     if (iter == mIWifiStaIfaces.end()) {
445         LOGE("SetStaMacAddress, not find iface info");
446         return false;
447     }
448 
449     sptr<IChipIface> &iface = iter->second;
450     CHECK_NULL_AND_RETURN(iface, false);
451     if (!SetNetworkUpDown(ifaceName, false)) {
452         LOGE("SetStaMacAddress, set network down fail");
453         return false;
454     }
455     int32_t ret = iface->SetMacAddress(mac);
456     if (ret != HDF_SUCCESS) {
457         LOGE("SetStaMacAddress, call SetMacAddress failed! ret:%{public}d", ret);
458     }
459     if (!SetNetworkUpDown(ifaceName, true)) {
460         LOGE("SetStaMacAddress, set network up fail");
461         return false;
462     }
463 
464     LOGI("SetStaMacAddress success");
465     return true;
466 }
467 
FindIface(const std::string & ifaceName)468 IChipIface *HalDeviceManager::FindIface(const std::string &ifaceName)
469 {
470     auto iter = mIWifiStaIfaces.find(ifaceName);
471     if (iter != mIWifiStaIfaces.end()) {
472         LOGE("find sta iface info");
473         return iter->second;
474     }
475     iter = mIWifiApIfaces.find(ifaceName);
476     if (iter != mIWifiApIfaces.end()) {
477         LOGE("find ap iface info");
478         return iter->second;
479     }
480     return nullptr;
481 }
482 
SetNetworkUpDown(const std::string & ifaceName,bool upDown)483 bool HalDeviceManager::SetNetworkUpDown(const std::string &ifaceName, bool upDown)
484 {
485     IChipIface *iface = FindIface(ifaceName);
486     if (iface == nullptr) {
487         return false;
488     }
489     if (iface->SetIfaceState(upDown) != HDF_SUCCESS) {
490         return false;
491     }
492     return true;
493 }
494 
GetChipsetCategory(const std::string & ifaceName,uint32_t & chipsetCategory)495 bool HalDeviceManager::GetChipsetCategory(const std::string &ifaceName, uint32_t &chipsetCategory)
496 {
497     if (!CheckReloadChipHdiService()) {
498         return false;
499     }
500 
501     std::lock_guard<std::mutex> lock(mMutex);
502     LOGI("GetChipsetCategory, ifaceName:%{public}s", ifaceName.c_str());
503     sptr<IConcreteChip> chip = nullptr;
504     if (!GetChip(ifaceName, IfaceType::STA, chip)) {
505         LOGE("GetChipsetCategory, get chip failed");
506         return false;
507     }
508 
509     CHECK_NULL_AND_RETURN(chip, false);
510     int32_t ret = chip->GetChipCaps(chipsetCategory);
511     if (ret != HDF_SUCCESS) {
512         LOGE("GetChipsetCategory, call GetChipCaps failed! ret:%{public}d", ret);
513         return false;
514     }
515     LOGI("GetChipsetCategory success");
516     return true;
517 }
518 
GetChipsetWifiFeatrureCapability(const std::string & ifaceName,int & chipsetFeatrureCapability)519 bool HalDeviceManager::GetChipsetWifiFeatrureCapability(const std::string &ifaceName, int &chipsetFeatrureCapability)
520 {
521     if (!CheckReloadChipHdiService()) {
522         return false;
523     }
524 
525     std::lock_guard<std::mutex> lock(mMutex);
526     LOGI("GetChipsetWifiFeatrureCapability, ifaceName:%{public}s", ifaceName.c_str());
527     auto iter = mIWifiStaIfaces.find(ifaceName);
528     if (iter == mIWifiStaIfaces.end()) {
529         LOGE("GetChipsetWifiFeatrureCapability, not find iface info");
530         return false;
531     }
532 
533     sptr<IChipIface> &iface = iter->second;
534     CHECK_NULL_AND_RETURN(iface, false);
535     uint32_t capabilities = 0;
536     int32_t ret = iface->GetIfaceCap(capabilities);
537     if (ret != HDF_SUCCESS) {
538         LOGE("GetChipsetWifiFeatrureCapability, call GetIfaceCap failed! ret:%{public}d", ret);
539         return false;
540     }
541     chipsetFeatrureCapability = capabilities;
542     LOGI("GetChipsetWifiFeatrureCapability success");
543     return true;
544 }
545 
GetFrequenciesByBand(const std::string & ifaceName,int32_t band,std::vector<int> & frequencies)546 bool HalDeviceManager::GetFrequenciesByBand(const std::string &ifaceName, int32_t band, std::vector<int> &frequencies)
547 {
548     if (!CheckReloadChipHdiService()) {
549         return false;
550     }
551 
552     std::lock_guard<std::mutex> lock(mMutex);
553     LOGI("GetFrequenciesByBand, ifaceName:%{public}s, band:%{public}d", ifaceName.c_str(), band);
554     auto staIter = mIWifiStaIfaces.find(ifaceName);
555     if (staIter != mIWifiStaIfaces.end()) {
556         sptr<IChipIface> &iface = staIter->second;
557         CHECK_NULL_AND_RETURN(iface, false);
558         std::vector<uint32_t> uifrequenciesSta;
559         int32_t ret = iface->GetSupportFreqs(band, uifrequenciesSta);
560         if (ret != HDF_SUCCESS) {
561             LOGE("GetFrequenciesByBand, call GetSupportFreqs failed! ret:%{public}d", ret);
562             return false;
563         }
564         for (auto item : uifrequenciesSta) {
565             frequencies.emplace_back(item);
566         }
567         LOGI("Sta getFrequenciesByBand success");
568         return true;
569     }
570 
571     auto apIter = mIWifiApIfaces.find(ifaceName);
572     if (apIter != mIWifiApIfaces.end()) {
573         sptr<IChipIface> &iface = apIter->second;
574         CHECK_NULL_AND_RETURN(iface, false);
575         std::vector<uint32_t> uifrequenciesAp;
576         int32_t ret = iface->GetSupportFreqs(band, uifrequenciesAp);
577         if (ret != HDF_SUCCESS) {
578             LOGE("GetFrequenciesByBand, call GetSupportFreqs failed! ret:%{public}d", ret);
579             return false;
580         }
581         for (auto item : uifrequenciesAp) {
582             frequencies.emplace_back(item);
583         }
584         LOGI("Ap getFrequenciesByBand success");
585         return true;
586     }
587     LOGI("GetFrequenciesByBand failed");
588     return false;
589 }
590 
SetPowerModel(const std::string & ifaceName,int model)591 bool HalDeviceManager::SetPowerModel(const std::string &ifaceName, int model)
592 {
593     if (!CheckReloadChipHdiService()) {
594         return false;
595     }
596 
597     std::lock_guard<std::mutex> lock(mMutex);
598     LOGI("SetPowerModel, ifaceName:%{public}s, model:%{public}d", ifaceName.c_str(), model);
599     auto iter = mIWifiApIfaces.find(ifaceName);
600     if (iter == mIWifiApIfaces.end()) {
601         LOGE("SetPowerModel, not find iface info");
602         return false;
603     }
604 
605     sptr<IChipIface> &iface = iter->second;
606     CHECK_NULL_AND_RETURN(iface, false);
607     int32_t ret = iface->SetPowerMode(model);
608     if (ret != HDF_SUCCESS) {
609         LOGE("SetPowerModel, call SetPowerMode failed! ret:%{public}d", ret);
610         return false;
611     }
612 
613     LOGI("SetPowerModel success");
614     return true;
615 }
616 
SetTxPower(int power)617 bool HalDeviceManager::SetTxPower(int power)
618 {
619     if (!CheckReloadChipHdiService()) {
620         return false;
621     }
622 
623     std::lock_guard<std::mutex> lock(mMutex);
624     int32_t staResult = IfaceSetTxPower(WifiConfigCenter::GetInstance().GetStaIfaceName(),
625                                         mIWifiStaIfaces, power);
626     int32_t p2pResult = IfaceSetTxPower(WifiConfigCenter::GetInstance().GetP2pIfaceName(),
627                                         mIWifiP2pIfaces, power);
628     int32_t apResult = IfaceSetTxPower(WifiConfigCenter::GetInstance().GetApIfaceName(),
629                                        mIWifiApIfaces, power);
630     LOGI("SetTxPower, result:sta:%{public}d, p2p:%{public}d, ap:%{public}d",
631         staResult, p2pResult, apResult);
632     if (staResult == HDF_SUCCESS || p2pResult == HDF_SUCCESS || apResult == HDF_SUCCESS) {
633         LOGE("SetTxPower success");
634         return true;
635     }
636     return false;
637 }
638 
IfaceSetTxPower(const std::string & ifaceName,const std::map<std::string,sptr<IChipIface>> & mWifiIfaces,int power)639 int32_t HalDeviceManager::IfaceSetTxPower(
640     const std::string &ifaceName, const std::map<std::string, sptr<IChipIface>> &mWifiIfaces, int power)
641 {
642     int32_t result = HDF_FAILURE;
643     auto iter = mWifiIfaces.find(ifaceName);
644     if (iter != mWifiIfaces.end()) {
645         const sptr<IChipIface> &iface = iter->second;
646         CHECK_NULL_AND_RETURN(iface, false);
647         int32_t result = iface->SetTxPower(power);
648         if (result != HDF_SUCCESS) {
649             LOGE("SetTxPower, call SetTxPower failed! Result:%{public}d", result);
650         }
651         return result;
652     }
653     LOGI("can not find iface:%{public}s", ifaceName.c_str());
654     return result;
655 }
GetPowerModel(const std::string & ifaceName,int & model)656 bool HalDeviceManager::GetPowerModel(const std::string &ifaceName, int &model)
657 {
658     if (!CheckReloadChipHdiService()) {
659         return false;
660     }
661 
662     std::lock_guard<std::mutex> lock(mMutex);
663     LOGI("GetPowerModel, ifaceName:%{public}s", ifaceName.c_str());
664     auto iter = mIWifiApIfaces.find(ifaceName);
665     if (iter == mIWifiApIfaces.end()) {
666         LOGE("GetPowerModel, not find iface info");
667         return false;
668     }
669 
670     sptr<IChipIface> &iface = iter->second;
671     CHECK_NULL_AND_RETURN(iface, false);
672     int32_t ret = iface->GetPowerMode(model);
673     if (ret != HDF_SUCCESS) {
674         LOGE("GetPowerModel, call GetPowerMode failed! ret:%{public}d", ret);
675         return false;
676     }
677 
678     LOGI("GetPowerModel success");
679     return true;
680 }
681 
SetWifiCountryCode(const std::string & ifaceName,const std::string & code)682 bool HalDeviceManager::SetWifiCountryCode(const std::string &ifaceName, const std::string &code)
683 {
684     if (!CheckReloadChipHdiService()) {
685         return false;
686     }
687 
688     std::lock_guard<std::mutex> lock(mMutex);
689     LOGI("SetWifiCountryCode, ifaceName:%{public}s", ifaceName.c_str());
690     auto staIter = mIWifiStaIfaces.find(ifaceName);
691     if (staIter != mIWifiStaIfaces.end()) {
692         sptr<IChipIface> &iface = staIter->second;
693         CHECK_NULL_AND_RETURN(iface, false);
694         int32_t ret = iface->SetCountryCode(code);
695         if (ret != HDF_SUCCESS) {
696             LOGE("SetWifiCountryCode, call SetCountryCode failed! ret:%{public}d", ret);
697             return false;
698         }
699         LOGI("Sta setWifiCountryCode success");
700         return true;
701     }
702 
703     auto apIter = mIWifiApIfaces.find(ifaceName);
704     if (apIter != mIWifiApIfaces.end()) {
705         sptr<IChipIface> &iface = apIter->second;
706         CHECK_NULL_AND_RETURN(iface, false);
707         int32_t ret = iface->SetCountryCode(code);
708         if (ret != HDF_SUCCESS) {
709             LOGE("SetWifiCountryCode, call SetCountryCode failed! ret:%{public}d", ret);
710             return false;
711         }
712         LOGI("Ap setWifiCountryCode success");
713         return true;
714     }
715     LOGE("SetWifiCountryCode, not find iface info");
716     return false;
717 }
718 
SetApMacAddress(const std::string & ifaceName,const std::string & mac)719 bool HalDeviceManager::SetApMacAddress(const std::string &ifaceName, const std::string &mac)
720 {
721     if (!CheckReloadChipHdiService()) {
722         return false;
723     }
724 
725     std::lock_guard<std::mutex> lock(mMutex);
726     LOGI("SetApMacAddress, ifaceName:%{public}s", ifaceName.c_str());
727     auto iter = mIWifiApIfaces.find(ifaceName);
728     if (iter == mIWifiApIfaces.end()) {
729         LOGE("SetApMacAddress, not find iface info");
730         return false;
731     }
732 
733     sptr<IChipIface> &iface = iter->second;
734     CHECK_NULL_AND_RETURN(iface, false);
735     if (!SetNetworkUpDown(ifaceName, false)) {
736         LOGE("SetStaMacAddress, set network down fail");
737         return false;
738     }
739     int32_t ret = iface->SetMacAddress(mac);
740     if (ret != HDF_SUCCESS) {
741         LOGE("SetApMacAddress, call SetMacAddress failed! ret:%{public}d", ret);
742     }
743     if (!SetNetworkUpDown(ifaceName, true)) {
744         LOGE("SetStaMacAddress, set network up fail");
745         return false;
746     }
747     LOGI("SetApMacAddress success");
748     return true;
749 }
750 
ResetHalDeviceManagerInfo()751 void HalDeviceManager::ResetHalDeviceManagerInfo()
752 {
753     std::lock_guard<std::mutex> lock(mMutex);
754     g_chipControllerCallback = nullptr;
755     g_chipIfaceCallback = nullptr;
756     g_IWifi = nullptr;
757     mInterfaceInfoCache.clear();
758     mIWifiStaIfaces.clear();
759     mIWifiApIfaces.clear();
760     mIWifiP2pIfaces.clear();
761     return;
762 }
763 
CheckReloadChipHdiService()764 bool HalDeviceManager::CheckReloadChipHdiService()
765 {
766     if (!g_chipHdiServiceDied) {
767         if (!CheckChipHdiStarted()) {
768             LOGE("chip hdi is not started");
769             return false;
770         }
771         return true;
772     }
773 
774     ResetHalDeviceManagerInfo();
775     if (!StartChipHdi()) {
776         LOGE("reload chip hdi service failed");
777         return false;
778     }
779 
780     g_chipHdiServiceDied = false;
781     LOGI("reload chip hdi service success");
782     return true;
783 }
784 
CheckChipHdiStarted()785 bool HalDeviceManager::CheckChipHdiStarted()
786 {
787     std::lock_guard<std::mutex> lock(mMutex);
788     bool isStarted = false;
789     CHECK_NULL_AND_RETURN(g_IWifi, false);
790     int32_t ret = g_IWifi->IsInit(isStarted);
791     if (ret != HDF_SUCCESS) {
792         LOGE("CheckChipHdiStarted, call IsInit failed! ret:%{public}d", ret);
793         return false;
794     }
795 
796     LOGD("CheckChipHdiStarted, isStarted:%{public}d", isStarted);
797     if (!isStarted) {
798         ret = g_IWifi->Init();
799         if (ret != HDF_SUCCESS) {
800             LOGE("CheckChipHdiStarted, call Init failed! ret:%{public}d", ret);
801             return false;
802         }
803     }
804     return true;
805 }
806 
GetIfaceName(sptr<IChipIface> & iface,std::string & ifaceName)807 bool HalDeviceManager::GetIfaceName(sptr<IChipIface> &iface, std::string &ifaceName)
808 {
809     CHECK_NULL_AND_RETURN(iface, false);
810     int32_t ret = iface->GetIfaceName(ifaceName);
811     if (ret != HDF_SUCCESS) {
812         LOGE("GetIfaceName, call GetIfaceName failed! ret:%{public}d", ret);
813         return false;
814     }
815 
816     LOGI("GetIfaceName, ifaceName:%{public}s", ifaceName.c_str());
817     return true;
818 }
819 
GetIfaceType(sptr<IChipIface> & iface,IfaceType & ifaceType)820 bool HalDeviceManager::GetIfaceType(sptr<IChipIface> &iface, IfaceType &ifaceType)
821 {
822     CHECK_NULL_AND_RETURN(iface, false);
823     int32_t ret = iface->GetIfaceType(ifaceType);
824     if (ret != HDF_SUCCESS) {
825         LOGE("GetIfaceType, call GetIfaceType failed! ret:%{public}d", ret);
826         return false;
827     }
828 
829     LOGI("GetIfaceType, ifaceType:%{public}d", static_cast<int>(ifaceType));
830     return true;
831 }
832 
GetP2pIfaceInfo(WifiChipInfo & wifiChipInfo)833 void HalDeviceManager::GetP2pIfaceInfo(WifiChipInfo &wifiChipInfo)
834 {
835     CHECK_NULL_AND_RETURN_NULL(wifiChipInfo.chip);
836     WifiIfaceInfo wifiIfaceInfo;
837     std::vector<std::string> ifnames;
838     std::vector<WifiIfaceInfo> ifaceInfo;
839 
840     int32_t ret = wifiChipInfo.chip->GetP2pServiceIfNames(ifnames);
841     if (ret == HDF_SUCCESS) {
842         for (uint32_t i = 0; i < ifnames.size(); ++i) {
843             wifiIfaceInfo.Clear();
844             ret = wifiChipInfo.chip->GetP2pService(ifnames[i], wifiIfaceInfo.iface);
845             if (ret != HDF_SUCCESS) {
846                 LOGE("GetIfaceType, call GetP2pService failed! ret:%{public}d", ret);
847                 break;
848             }
849             wifiIfaceInfo.name = ifnames[i];
850             ifaceInfo.emplace_back(wifiIfaceInfo);
851         }
852     } else {
853         LOGE("GetIfaceType, call GetP2pServiceIfNames failed! ret:%{public}d", ret);
854     }
855     wifiChipInfo.ifaces[IfaceType::P2P] = ifaceInfo;
856     return;
857 }
858 
GetApIfaceInfo(WifiChipInfo & wifiChipInfo)859 void HalDeviceManager::GetApIfaceInfo(WifiChipInfo &wifiChipInfo)
860 {
861     CHECK_NULL_AND_RETURN_NULL(wifiChipInfo.chip);
862     WifiIfaceInfo wifiIfaceInfo;
863     std::vector<std::string> ifnames;
864     std::vector<WifiIfaceInfo> ifaceInfo;
865 
866     int32_t ret = wifiChipInfo.chip->GetApServiceIfNames(ifnames);
867     if (ret == HDF_SUCCESS) {
868         for (uint32_t i = 0; i < ifnames.size(); ++i) {
869             wifiIfaceInfo.Clear();
870             ret = wifiChipInfo.chip->GetApService(ifnames[i], wifiIfaceInfo.iface);
871             if (ret != HDF_SUCCESS) {
872                 LOGE("GetApIfaceInfo, call GetApService failed! ret:%{public}d", ret);
873                 break;
874             }
875             wifiIfaceInfo.name = ifnames[i];
876             ifaceInfo.emplace_back(wifiIfaceInfo);
877         }
878     } else {
879         LOGE("GetApIfaceInfo, call GetApServiceIfNames failed! ret:%{public}d", ret);
880     }
881     wifiChipInfo.ifaces[IfaceType::AP] = ifaceInfo;
882     return;
883 }
884 
GetStaIfaceInfo(WifiChipInfo & wifiChipInfo)885 void HalDeviceManager::GetStaIfaceInfo(WifiChipInfo &wifiChipInfo)
886 {
887     CHECK_NULL_AND_RETURN_NULL(wifiChipInfo.chip);
888     WifiIfaceInfo wifiIfaceInfo;
889     std::vector<std::string> ifnames;
890     std::vector<WifiIfaceInfo> ifaceInfo;
891 
892     int32_t ret = wifiChipInfo.chip->GetStaServiceIfNames(ifnames);
893     if (ret == HDF_SUCCESS) {
894         for (uint32_t i = 0; i < ifnames.size(); ++i) {
895             wifiIfaceInfo.Clear();
896             ret = wifiChipInfo.chip->GetStaService(ifnames[i], wifiIfaceInfo.iface);
897             if (ret != HDF_SUCCESS) {
898                 LOGE("GetStaIfaceInfo, call GetStaService failed! ret:%{public}d", ret);
899                 break;
900             }
901             wifiIfaceInfo.name = ifnames[i];
902             ifaceInfo.emplace_back(wifiIfaceInfo);
903         }
904     } else {
905         LOGE("GetStaIfaceInfo, call GetStaServiceIfNames failed! ret:%{public}d", ret);
906     }
907     wifiChipInfo.ifaces[IfaceType::STA] = ifaceInfo;
908     return;
909 }
910 
GetIfaceInfo(WifiChipInfo & wifiChipInfo)911 bool HalDeviceManager::GetIfaceInfo(WifiChipInfo &wifiChipInfo)
912 {
913     GetStaIfaceInfo(wifiChipInfo);
914     GetApIfaceInfo(wifiChipInfo);
915     GetP2pIfaceInfo(wifiChipInfo);
916     return true;
917 }
918 
GetChipInfo(uint32_t chipId,WifiChipInfo & wifiChipInfo)919 bool HalDeviceManager::GetChipInfo(uint32_t chipId, WifiChipInfo &wifiChipInfo)
920 {
921     CHECK_NULL_AND_RETURN(g_IWifi, false);
922     int32_t ret = g_IWifi->GetChipService(chipId, wifiChipInfo.chip);
923     if (ret != HDF_SUCCESS) {
924         LOGE("GetChipInfo, call GetChipService failed! ret:%{public}d", ret);
925         return false;
926     }
927 
928     CHECK_NULL_AND_RETURN(wifiChipInfo.chip, false);
929     ret = wifiChipInfo.chip->GetChipModes(wifiChipInfo.availableModes);
930     if (ret != HDF_SUCCESS) {
931         LOGE("GetChipInfo, call GetChipModes failed! ret:%{public}d", ret);
932         return false;
933     }
934 
935     ret = wifiChipInfo.chip->GetCurrentMode(wifiChipInfo.currentModeId);
936     if (ret == HDF_SUCCESS) {
937         LOGI("GetChipInfo, GetCurrentMode:%{public}d", wifiChipInfo.currentModeId);
938         wifiChipInfo.currentModeIdValid = true;
939     } else if (ret == HDF_ERR_INVALID_PARAM) {
940         LOGI("GetChipInfo, currentModeId not available");
941     } else {
942         LOGE("GetChipInfo, call GetCurrentMode failed! ret:%{public}d", ret);
943         return false;
944     }
945 
946     if (!GetIfaceInfo(wifiChipInfo)) {
947         LOGE("GetChipInfo, GetIfaceInfo failed!");
948         return false;
949     }
950 
951     return true;
952 }
953 
GetAllChipInfo(std::vector<WifiChipInfo> & wifiChipInfos)954 bool HalDeviceManager::GetAllChipInfo(std::vector<WifiChipInfo> &wifiChipInfos)
955 {
956     LOGI("GetAllChipInfo start");
957     std::vector<uint32_t> chipIds;
958     CHECK_NULL_AND_RETURN(g_IWifi, false);
959     int32_t ret = g_IWifi->GetAvailableChips(chipIds);
960     if (ret != HDF_SUCCESS) {
961         LOGE("GetAllChipInfo, call GetAvailableChips failed! ret:%{public}d", ret);
962         return false;
963     }
964 
965     if (chipIds.empty()) {
966         LOGE("GetAllChipInfo, chipIds is empty!");
967         return false;
968     }
969 
970     for (uint32_t i = 0; i < chipIds.size(); ++i) {
971         WifiChipInfo wifiChipInfo;
972         if (GetChipInfo(chipIds[i], wifiChipInfo)) {
973             wifiChipInfo.chipId = chipIds[i];
974             wifiChipInfos.emplace_back(wifiChipInfo);
975         }
976     }
977 
978     LOGI("GetAllChipInfo end");
979     return true;
980 }
981 
ValidateInterfaceCache(std::vector<WifiChipInfo> & wifiChipInfos)982 bool HalDeviceManager::ValidateInterfaceCache(std::vector<WifiChipInfo> &wifiChipInfos)
983 {
984     if (mInterfaceInfoCache.empty()) {
985         LOGI("ValidateInterfaceCache, mInterfaceInfoCache is empty!");
986         return true;
987     }
988 
989     for (auto &interfaceInfo : mInterfaceInfoCache) {
990         WifiChipInfo matchingChipInfo;
991         for (auto &chipInfo : wifiChipInfos) {
992             if (chipInfo.chipId == interfaceInfo.second.chipId) {
993                 matchingChipInfo = chipInfo;
994                 break;
995             }
996         }
997 
998         if (matchingChipInfo.chip == nullptr) {
999             LOGE("ValidateInterfaceCache, chipInfo not found!");
1000             return false;
1001         }
1002 
1003         std::vector<WifiIfaceInfo> &ifaceInfos = matchingChipInfo.ifaces[interfaceInfo.second.type];
1004         if (ifaceInfos.empty()) {
1005             LOGE("ValidateInterfaceCache, invalid type!");
1006             return false;
1007         }
1008 
1009         bool matchFound = false;
1010         for (auto &ifaceInfo : ifaceInfos) {
1011             if (ifaceInfo.name == interfaceInfo.second.name) {
1012                 matchFound = true;
1013                 break;
1014             }
1015         }
1016 
1017         if (!matchFound) {
1018             LOGE("ValidateInterfaceCache, ifaceInfo not found!");
1019             return false;
1020         }
1021     }
1022 
1023     LOGI("ValidateInterfaceCache, verify ok!");
1024     return true;
1025 }
1026 
SelectInterfacesToDelete(int excessInterfaces,IfaceType requestedIfaceType,IfaceType existingIfaceType,std::vector<WifiIfaceInfo> & existingIface,std::vector<WifiIfaceInfo> & interfacesToBeRemovedFirst)1027 void HalDeviceManager::SelectInterfacesToDelete(int excessInterfaces, IfaceType requestedIfaceType,
1028     IfaceType existingIfaceType, std::vector<WifiIfaceInfo> &existingIface,
1029     std::vector<WifiIfaceInfo> &interfacesToBeRemovedFirst)
1030 {
1031     bool lookupError = false;
1032     std::vector<WifiIfaceInfo> ifacesToDelete;
1033     for (int i = existingIface.size() - 1; i >= 0; i--) {
1034         WifiIfaceInfo info = existingIface[i];
1035         IfaceType ifaceType = IFACE_TYPE_DEFAULT;
1036         GetIfaceType(info.iface, ifaceType);
1037         auto iter = mInterfaceInfoCache.find(std::pair<std::string, IfaceType>(info.name, ifaceType));
1038         if (iter == mInterfaceInfoCache.end()) {
1039             LOGE("SelectInterfacesToDelete, can't find cache interface info! info name:%{public}s", info.name.c_str());
1040             lookupError = true;
1041             break;
1042         }
1043 
1044         if (AllowedToBeDeleteIfaceTypeForRequestedType(requestedIfaceType, existingIfaceType)) {
1045             ifacesToDelete.emplace_back(info);
1046         }
1047     }
1048 
1049     if (lookupError) {
1050         LOGE("SelectInterfacesToDelete, falling back to arbitrary selection");
1051         for (int i = 0; i < excessInterfaces; ++i) {
1052             interfacesToBeRemovedFirst.emplace_back(existingIface[i]);
1053         }
1054     } else {
1055         int numIfacesToDelete = std::min(excessInterfaces, static_cast<int>(ifacesToDelete.size()));
1056         for (int i = 0; i < numIfacesToDelete; ++i) {
1057             interfacesToBeRemovedFirst.emplace_back(ifacesToDelete[i]);
1058         }
1059     }
1060 
1061     return;
1062 }
1063 
AllowedToBeDeleteIfaceTypeForRequestedType(IfaceType requestedIfaceType,IfaceType existingIfaceType)1064 bool HalDeviceManager::AllowedToBeDeleteIfaceTypeForRequestedType(IfaceType requestedIfaceType,
1065     IfaceType existingIfaceType)
1066 {
1067     LOGI("AllowedToBeDeleteIfaceTypeForRequestedType, requestedIfaceType:%{public}d, existingIfaceType:%{public}d",
1068         requestedIfaceType, existingIfaceType);
1069     if (requestedIfaceType == existingIfaceType) {
1070         LOGI("AllowedToBeDeleteIfaceTypeForRequestedType, not allowed to delete");
1071         return false;
1072     }
1073 
1074     LOGI("AllowedToBeDeleteIfaceTypeForRequestedType, allowed to delete");
1075     return true;
1076 }
1077 
CreateTheNeedChangeChipModeIfaceData(WifiChipInfo & wifiChipInfo,IfaceType createIfaceType,UsableMode & chipMode,IfaceCreationData & ifaceCreationData)1078 bool HalDeviceManager::CreateTheNeedChangeChipModeIfaceData(WifiChipInfo &wifiChipInfo, IfaceType createIfaceType,
1079     UsableMode &chipMode, IfaceCreationData &ifaceCreationData)
1080 {
1081     for (auto type : IFACE_TYPES_BY_PRIORITY) {
1082         if (!wifiChipInfo.ifaces[type].empty()) {
1083             if (!AllowedToBeDeleteIfaceTypeForRequestedType(createIfaceType, type)) {
1084                 LOGE("CreateTheNeedChangeChipModeIfaceData, chip mode need change, not allowed to delete");
1085                 return false;
1086             }
1087         }
1088     }
1089 
1090     ifaceCreationData.chipInfo = wifiChipInfo;
1091     ifaceCreationData.chipModeId = chipMode.modeId;
1092     LOGI("CreateTheNeedChangeChipModeIfaceData, chip mode need change, create a new iface data");
1093     return true;
1094 }
1095 
CanIfaceComboSupportRequest(WifiChipInfo & wifiChipInfo,UsableMode & chipMode,std::vector<int> & chipIfaceCombo,IfaceType createIfaceType,IfaceCreationData & ifaceCreationData)1096 bool HalDeviceManager::CanIfaceComboSupportRequest(WifiChipInfo &wifiChipInfo, UsableMode &chipMode,
1097     std::vector<int> &chipIfaceCombo, IfaceType createIfaceType, IfaceCreationData &ifaceCreationData)
1098 {
1099     if (chipIfaceCombo[createIfaceType] == 0) {
1100         LOGE("CanIfaceComboSupportRequest, request type not support by combo");
1101         return false;
1102     }
1103 
1104     bool isChipModeChangeProposed = wifiChipInfo.currentModeIdValid && wifiChipInfo.currentModeId != chipMode.modeId;
1105     if (isChipModeChangeProposed) {
1106         return CreateTheNeedChangeChipModeIfaceData(wifiChipInfo, createIfaceType, chipMode, ifaceCreationData);
1107     }
1108 
1109     for (auto type : IFACE_TYPES_BY_PRIORITY) {
1110         int tooManyInterfaces = static_cast<int>(wifiChipInfo.ifaces[type].size()) - chipIfaceCombo[type];
1111         if (createIfaceType == type) {
1112             tooManyInterfaces += 1;
1113         }
1114 
1115         if (tooManyInterfaces > 0) {
1116             if (wifiChipInfo.ifaces[type].empty()) {
1117                 LOGE("CanIfaceComboSupportRequest, existing ifaces is empty");
1118                 return false;
1119             }
1120 
1121             if (!AllowedToBeDeleteIfaceTypeForRequestedType(createIfaceType, type)) {
1122                 LOGE("CanIfaceComboSupportRequest, not allowed to delete");
1123                 return false;
1124             }
1125 
1126             SelectInterfacesToDelete(tooManyInterfaces, createIfaceType, type, wifiChipInfo.ifaces[type],
1127                 ifaceCreationData.interfacesToBeRemovedFirst);
1128         }
1129     }
1130 
1131     ifaceCreationData.chipInfo = wifiChipInfo;
1132     ifaceCreationData.chipModeId = chipMode.modeId;
1133     LOGI("CanIfaceComboSupportRequest, create a new iface data");
1134     return true;
1135 }
1136 
ExpandIfaceCombos(ComboIface & chipIfaceCombo,std::vector<std::vector<int>> & expandedIfaceCombos)1137 void HalDeviceManager::ExpandIfaceCombos(ComboIface &chipIfaceCombo,
1138     std::vector<std::vector<int>> &expandedIfaceCombos)
1139 {
1140     int numOfCombos = 1;
1141     for (auto &limit : chipIfaceCombo.limits) {
1142         for (uint32_t i = 0; i < limit.ifaceNum; ++i) {
1143             numOfCombos *= limit.types.size();
1144         }
1145     }
1146 
1147     expandedIfaceCombos.resize(numOfCombos);
1148     for (uint32_t i = 0; i < expandedIfaceCombos.size(); ++i) {
1149         expandedIfaceCombos[i].resize(IFACE_TYPES_BY_PRIORITY.size(), 0);
1150     }
1151 
1152     int span = numOfCombos;
1153     for (auto &limit : chipIfaceCombo.limits) {
1154         for (uint32_t i = 0; i < limit.ifaceNum; ++i) {
1155             span /= limit.types.size();
1156             for (int k = 0; k < numOfCombos; ++k) {
1157                 int ifaceType = limit.types.at((k / span) % limit.types.size());
1158                 expandedIfaceCombos[k][ifaceType]++;
1159             }
1160         }
1161     }
1162 
1163     return;
1164 }
1165 
CompareIfaceCreationData(IfaceCreationData & data1,IfaceCreationData & data2)1166 bool HalDeviceManager::CompareIfaceCreationData(IfaceCreationData &data1, IfaceCreationData &data2)
1167 {
1168     if (data1.isEmpty()) {
1169         return false;
1170     } else if (data2.isEmpty()) {
1171         return true;
1172     }
1173 
1174     for (auto type : IFACE_TYPES_BY_PRIORITY) {
1175         int numIfacesToDelete1 = 0;
1176         if (data1.chipInfo.currentModeIdValid && data1.chipInfo.currentModeId != data1.chipModeId) {
1177             numIfacesToDelete1 = data1.chipInfo.ifaces[type].size();
1178         } else {
1179             numIfacesToDelete1 = data1.interfacesToBeRemovedFirst.size();
1180         }
1181 
1182         int numIfacesToDelete2 = 0;
1183         if (data2.chipInfo.currentModeIdValid && data2.chipInfo.currentModeId != data2.chipModeId) {
1184             numIfacesToDelete2 = data2.chipInfo.ifaces[type].size();
1185         } else {
1186             numIfacesToDelete2 = data2.interfacesToBeRemovedFirst.size();
1187         }
1188 
1189         if (numIfacesToDelete1 < numIfacesToDelete2) {
1190             LOGI("CompareIfaceCreationData, data1 < data2");
1191             return true;
1192         }
1193     }
1194 
1195     return false;
1196 }
1197 
ExecuteChipReconfiguration(IfaceCreationData & ifaceCreationData,IfaceType createIfaceType,sptr<IChipIface> & iface)1198 bool HalDeviceManager::ExecuteChipReconfiguration(IfaceCreationData &ifaceCreationData,
1199     IfaceType createIfaceType, sptr<IChipIface> &iface)
1200 {
1201     if (ifaceCreationData.chipInfo.chip == nullptr) {
1202         LOGE("ExecuteChipReconfiguration, chip is nullptr");
1203         return false;
1204     }
1205 
1206     bool isModeConfigNeeded = !ifaceCreationData.chipInfo.currentModeIdValid
1207         || ifaceCreationData.chipInfo.currentModeId != ifaceCreationData.chipModeId;
1208     if (isModeConfigNeeded) {
1209         for (auto &ifaceInfos : ifaceCreationData.chipInfo.ifaces) {
1210             for (auto &ifaceInfo : ifaceInfos.second) {
1211                 RemoveIface(ifaceInfo.iface, true, createIfaceType);
1212             }
1213         }
1214 
1215         int32_t ret = ifaceCreationData.chipInfo.chip->SetChipMode(ifaceCreationData.chipModeId);
1216         if (ret != HDF_SUCCESS) {
1217             LOGE("ExecuteChipReconfiguration, call SetChipMode failed! ret:%{public}d", ret);
1218             return false;
1219         }
1220     } else {
1221         for (auto &ifaceInfo : ifaceCreationData.interfacesToBeRemovedFirst) {
1222             RemoveIface(ifaceInfo.iface, true, createIfaceType);
1223         }
1224     }
1225 
1226     int32_t ret = HDF_FAILURE;
1227     switch (createIfaceType) {
1228         case IfaceType::STA :
1229             ret = ifaceCreationData.chipInfo.chip->CreateStaService(iface);
1230             break;
1231         case IfaceType::AP :
1232             ret = ifaceCreationData.chipInfo.chip->CreateApService(iface);
1233             break;
1234         case IfaceType::P2P :
1235             ret = ifaceCreationData.chipInfo.chip->CreateP2pService(iface);
1236             break;
1237         default:
1238             LOGE("ExecuteChipReconfiguration, invalid createIfaceType:%{public}d", static_cast<int>(createIfaceType));
1239             break;
1240     }
1241 
1242     if (ret != HDF_SUCCESS) {
1243         LOGE("ExecuteChipReconfiguration, create iface failed! ret:%{public}d, createIfaceType:%{public}d",
1244             ret, static_cast<int>(createIfaceType));
1245         return false;
1246     }
1247 
1248     return true;
1249 }
1250 
FindBestIfaceCreationProposal(std::vector<std::vector<int>> & expandedIfaceCombos,WifiChipInfo & chipInfo,UsableMode & chipMode,IfaceType createIfaceType,IfaceCreationData & bestIfaceCreationProposal)1251 void HalDeviceManager::FindBestIfaceCreationProposal(std::vector<std::vector<int>> &expandedIfaceCombos,
1252     WifiChipInfo &chipInfo, UsableMode &chipMode, IfaceType createIfaceType,
1253     IfaceCreationData &bestIfaceCreationProposal)
1254 {
1255     for (auto &expandedIfaceCombo : expandedIfaceCombos) {
1256         IfaceCreationData currentProposal;
1257         CanIfaceComboSupportRequest(chipInfo, chipMode, expandedIfaceCombo, createIfaceType, currentProposal);
1258         if (CompareIfaceCreationData(currentProposal, bestIfaceCreationProposal)) {
1259             bestIfaceCreationProposal = currentProposal;
1260         }
1261     }
1262     return;
1263 }
1264 
CreateIfaceIfPossible(std::vector<WifiChipInfo> & wifiChipInfos,IfaceType createIfaceType,const IfaceDestoryCallback & ifaceDestoryCallback,std::string & ifaceName,sptr<IChipIface> & iface)1265 bool HalDeviceManager::CreateIfaceIfPossible(std::vector<WifiChipInfo> &wifiChipInfos, IfaceType createIfaceType,
1266     const IfaceDestoryCallback &ifaceDestoryCallback, std::string &ifaceName, sptr<IChipIface> &iface)
1267 {
1268     IfaceCreationData bestIfaceCreationProposal;
1269     for (auto &chipInfo : wifiChipInfos) {
1270         for (auto &chipMode : chipInfo.availableModes) {
1271             for (auto &chipIfaceCombo : chipMode.usableCombo) {
1272                 std::vector<std::vector<int>> expandedIfaceCombos;
1273                 ExpandIfaceCombos(chipIfaceCombo, expandedIfaceCombos);
1274                 FindBestIfaceCreationProposal(expandedIfaceCombos, chipInfo, chipMode, createIfaceType,
1275                     bestIfaceCreationProposal);
1276             }
1277         }
1278     }
1279 
1280     if (bestIfaceCreationProposal.isEmpty()) {
1281         LOGE("CreateIfaceIfPossible, best iface creation data is empty");
1282         return false;
1283     }
1284 
1285     if (!ExecuteChipReconfiguration(bestIfaceCreationProposal, createIfaceType, iface)) {
1286         LOGE("CreateIfaceIfPossible, excute chip reconfiguration failed");
1287         return false;
1288     }
1289 
1290     if (!GetIfaceName(iface, ifaceName)) {
1291         LOGE("CreateIfaceIfPossible, get iface name failed");
1292         return false;
1293     }
1294 
1295     InterfaceCacheEntry cacheEntry;
1296     cacheEntry.chip = bestIfaceCreationProposal.chipInfo.chip;
1297     cacheEntry.chipId = bestIfaceCreationProposal.chipInfo.chipId;
1298     cacheEntry.name = ifaceName;
1299     cacheEntry.type = createIfaceType;
1300     cacheEntry.ifaceDestoryCallback.emplace_back(ifaceDestoryCallback);
1301     mInterfaceInfoCache[std::pair<std::string, IfaceType>(cacheEntry.name, cacheEntry.type)] = cacheEntry;
1302     return true;
1303 }
1304 
CreateIface(IfaceType createIfaceType,const IfaceDestoryCallback & ifaceDestoryCallback,std::string & ifaceName,sptr<IChipIface> & iface)1305 bool HalDeviceManager::CreateIface(IfaceType createIfaceType, const IfaceDestoryCallback &ifaceDestoryCallback,
1306     std::string &ifaceName, sptr<IChipIface> &iface)
1307 {
1308     std::vector<WifiChipInfo> wifiChipInfos;
1309     if (!GetAllChipInfo(wifiChipInfos)) {
1310         LOGE("CreateIface, get all chip info failed");
1311         return false;
1312     }
1313 
1314     if (!ValidateInterfaceCache(wifiChipInfos)) {
1315         LOGE("CreateIface, verify interface cache failed");
1316         return false;
1317     }
1318 
1319     if (!CreateIfaceIfPossible(wifiChipInfos, createIfaceType, ifaceDestoryCallback, ifaceName, iface)) {
1320         LOGE("CreateIface, create iface failed");
1321         return false;
1322     }
1323 
1324     LOGI("CreateIface, create iface success, ifaceName:%{public}s", ifaceName.c_str());
1325     return true;
1326 }
1327 
DispatchIfaceDestoryCallback(std::string & removeIfaceName,IfaceType removeIfaceType,bool isCallback,IfaceType createIfaceType)1328 void HalDeviceManager::DispatchIfaceDestoryCallback(std::string &removeIfaceName, IfaceType removeIfaceType,
1329     bool isCallback, IfaceType createIfaceType)
1330 {
1331     LOGI("DispatchIfaceDestoryCallback, removeIfaceName:%{public}s, removeIfaceType:%{public}d, isCallback:%{public}d,"
1332         " createIfaceType:%{public}d", removeIfaceName.c_str(), removeIfaceType, isCallback, createIfaceType);
1333     switch (removeIfaceType) {
1334         case IfaceType::STA :
1335             if (mIWifiStaIfaces.find(removeIfaceName) != mIWifiStaIfaces.end()) {
1336                 mIWifiStaIfaces.erase(removeIfaceName);
1337             }
1338             if (isCallback) {
1339                 WifiP2PHalInterface::GetInstance().StopP2p();
1340                 WifiStaHalInterface::GetInstance().StopWifi();
1341             }
1342             break;
1343         case IfaceType::AP :
1344             if (mIWifiApIfaces.find(removeIfaceName) != mIWifiApIfaces.end()) {
1345                 mIWifiApIfaces.erase(removeIfaceName);
1346             }
1347             if (isCallback) {
1348                 WifiApHalInterface::GetInstance().StopAp();
1349             }
1350             break;
1351         case IfaceType::P2P :
1352             if (mIWifiP2pIfaces.find(removeIfaceName) != mIWifiP2pIfaces.end()) {
1353                 mIWifiP2pIfaces.erase(removeIfaceName);
1354             }
1355             break;
1356         default:
1357             LOGE("DispatchIfaceDestoryCallback, invalid removeIfaceType:%{public}d", static_cast<int>(removeIfaceType));
1358             break;
1359     }
1360 
1361     auto iter = mInterfaceInfoCache.find(std::pair<std::string, IfaceType>(removeIfaceName, removeIfaceType));
1362     if (iter != mInterfaceInfoCache.end()) {
1363         for (auto &callback : iter->second.ifaceDestoryCallback) {
1364             if (isCallback && callback) {
1365                 callback(removeIfaceName, static_cast<int>(createIfaceType));
1366             }
1367         }
1368         mInterfaceInfoCache.erase(iter);
1369     }
1370 
1371     return;
1372 }
1373 
GetChip(const std::string & removeIfaceName,IfaceType removeIfaceType,sptr<IConcreteChip> & chip)1374 bool HalDeviceManager::GetChip(const std::string &removeIfaceName, IfaceType removeIfaceType, sptr<IConcreteChip> &chip)
1375 {
1376     auto iter = mInterfaceInfoCache.find(std::pair<std::string, IfaceType>(removeIfaceName, removeIfaceType));
1377     if (iter == mInterfaceInfoCache.end()) {
1378         LOGE("GetChip, not find interface cache info");
1379         return false;
1380     }
1381 
1382     chip = iter->second.chip;
1383     return true;
1384 }
1385 
RemoveIface(sptr<IChipIface> & iface,bool isCallback,IfaceType createIfaceType)1386 bool HalDeviceManager::RemoveIface(sptr<IChipIface> &iface, bool isCallback, IfaceType createIfaceType)
1387 {
1388     std::string ifaceName;
1389     if (!GetIfaceName(iface, ifaceName)) {
1390         LOGE("RemoveIface, get iface name failed");
1391         return false;
1392     }
1393 
1394     IfaceType ifaceType = IFACE_TYPE_DEFAULT;
1395     if (!GetIfaceType(iface, ifaceType)) {
1396         LOGI("RemoveIface, get iface type failed");
1397         return false;
1398     }
1399 
1400     sptr<IConcreteChip> chip = nullptr;
1401     if (!GetChip(ifaceName, ifaceType, chip)) {
1402         LOGE("RemoveIface, get chip failed");
1403         return false;
1404     }
1405 
1406     CHECK_NULL_AND_RETURN(chip, false);
1407     int32_t ret = HDF_FAILURE;
1408     switch (ifaceType) {
1409         case IfaceType::STA:
1410             if (ifaceName == "wlan0") {
1411                 LOGE("RemoveIface, IfaceType::STA wlan0");
1412                 if (iface && g_chipIfaceCallback) {
1413                     iface->UnRegisterChipIfaceCallBack(g_chipIfaceCallback);
1414                 }
1415                 g_rssiReportCallback = nullptr;
1416             }
1417             ret = chip->RemoveStaService(ifaceName);
1418             break;
1419         case IfaceType::AP :
1420             ret = chip->RemoveApService(ifaceName);
1421             break;
1422         case IfaceType::P2P :
1423             ret = chip->RemoveP2pService(ifaceName);
1424             break;
1425         default:
1426             LOGE("RemoveIface, invalid ifaceType:%{public}d", static_cast<int>(ifaceType));
1427             break;
1428     }
1429 
1430     if (ret != HDF_SUCCESS) {
1431         LOGE("RemoveIface, remove iface failed ret:%{public}d, ifaceType:%{public}d", ret, static_cast<int>(ifaceType));
1432         return false;
1433     }
1434 
1435     DispatchIfaceDestoryCallback(ifaceName, ifaceType, isCallback, createIfaceType);
1436     LOGI("RemoveIface success");
1437     return true;
1438 }
1439 
AddChipHdiDeathRecipient()1440 void HalDeviceManager::AddChipHdiDeathRecipient()
1441 {
1442     struct HDIServiceManager *serviceMgr = HDIServiceManagerGet();
1443     if (serviceMgr == nullptr) {
1444         LOGE("%{public}s: failed to get HDIServiceManager", __func__);
1445         return;
1446     }
1447 
1448     g_chipHdiService = serviceMgr->GetService(serviceMgr, CHIP_SERVICE_NAME);
1449     HDIServiceManagerRelease(serviceMgr);
1450     if (g_chipHdiService == nullptr) {
1451         LOGE("%{public}s: failed to get HdfRemoteService", __func__);
1452         return;
1453     }
1454 
1455     static HdfDeathRecipient recipient = {
1456         .OnRemoteDied = [](HdfDeathRecipient *recipient, HdfRemoteService *service) {
1457             LOGI("Chip Hdi service died!");
1458             g_chipHdiServiceDied = true;
1459             RemoveChipHdiDeathRecipient();
1460             return;
1461         }
1462     };
1463 
1464     HdfRemoteServiceAddDeathRecipient(g_chipHdiService, &recipient);
1465     LOGI("Chip Hdi service add death recipient success");
1466     return;
1467 }
1468 
RemoveChipHdiDeathRecipient()1469 void HalDeviceManager::RemoveChipHdiDeathRecipient()
1470 {
1471     std::lock_guard<std::mutex> lock(mMutex);
1472     if (g_chipHdiService) {
1473         HdfRemoteServiceRemoveDeathRecipient(g_chipHdiService, nullptr);
1474         g_chipHdiService = nullptr;
1475     }
1476     return;
1477 }
1478 
OnScanResultsCallback(uint32_t event)1479 int32_t ChipIfaceCallback::OnScanResultsCallback(uint32_t event)
1480 {
1481     LOGI("OnScanResultsCallback, event:%{public}d", event);
1482     OHOS::Wifi::WifiSupplicantHalInterface::GetInstance().NotifyScanResultEvent();
1483     return 0;
1484 }
1485 
OnRssiReport(int32_t index,int32_t c0Rssi,int32_t c1Rssi)1486 int32_t ChipIfaceCallback::OnRssiReport(int32_t index, int32_t c0Rssi, int32_t c1Rssi)
1487 {
1488     LOGI("OnRssiReport, index:%{public}d c0Rssi:%{public}d c1Rssi:%{public}d", index, c0Rssi, c1Rssi);
1489 
1490     if (g_rssiReportCallback) {
1491         g_rssiReportCallback(index, c0Rssi);
1492     }
1493     return 0;
1494 }
1495 
1496 }  // namespace Wifi
1497 }  // namespace OHOS
1498 #endif