1 /*
2 * Copyright (C) 2021-2022 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 "sta_service.h"
17 #include "sta_define.h"
18 #include "sta_service_callback.h"
19 #ifndef OHOS_ARCH_LITE
20 #include "wifi_internal_event_dispatcher.h"
21 #include "wifi_country_code_manager.h"
22 #include "core_service_client.h"
23 #include "cellular_data_client.h"
24 #include "wifi_notification_util.h"
25 #endif
26 #include "wifi_logger.h"
27 #include "wifi_sta_hal_interface.h"
28 #include "wifi_supplicant_hal_interface.h"
29 #include "wifi_cert_utils.h"
30 #include "wifi_common_util.h"
31 #include "network_selection_manager.h"
32 #include "wifi_config_center.h"
33 #include "external_wifi_filter_builder_manager.h"
34 #include "external_wifi_common_builder_manager.h"
35
36 DEFINE_WIFILOG_LABEL("StaService");
37
38 namespace OHOS {
39 namespace Wifi {
40
41 constexpr const int REMOVE_ALL_DEVICECONFIG = 0x7FFFFFFF;
42
43 #define EAP_AUTH_IMSI_MCC_POS 0
44 #define EAP_AUTH_MAX_MCC_LEN 3
45 #define EAP_AUTH_IMSI_MNC_POS 3
46 #define EAP_AUTH_MIN_MNC_LEN 2
47 #define EAP_AUTH_MAX_MNC_LEN 3
48 #define EAP_AUTH_MIN_PLMN_LEN 5
49 #define EAP_AUTH_MAX_PLMN_LEN 6
50 #define EAP_AUTH_MAX_IMSI_LENGTH 15
51 #define INVALID_SUPPLIER_ID 0
52
53 #define EAP_AKA_PERMANENT_PREFIX "0"
54 #define EAP_SIM_PERMANENT_PREFIX "1"
55 #define EAP_AKA_PRIME_PERMANENT_PREFIX "6"
56
57 #define EAP_AUTH_WLAN_MNC "@wlan.mnc"
58 #define EAP_AUTH_WLAN_MCC ".mcc"
59 #define EAP_AUTH_PERMANENT_SUFFIX ".3gppnetwork.org"
60
StaService(int instId)61 StaService::StaService(int instId)
62 : pStaStateMachine(nullptr),
63 pStaMonitor(nullptr),
64 pStaAutoConnectService(nullptr),
65 #ifndef OHOS_ARCH_LITE
66 pStaAppAcceleration(nullptr),
67 #endif
68 m_instId(instId)
69 {}
70
~StaService()71 StaService::~StaService()
72 {
73 WIFI_LOGI("Enter ~StaService");
74 if (pStaMonitor != nullptr) {
75 pStaMonitor->UnInitStaMonitor();
76 delete pStaMonitor;
77 pStaMonitor = nullptr;
78 }
79
80 if (pStaAutoConnectService != nullptr) {
81 delete pStaAutoConnectService;
82 pStaAutoConnectService = nullptr;
83 }
84
85 if (pStaStateMachine != nullptr) {
86 delete pStaStateMachine;
87 pStaStateMachine = nullptr;
88 }
89
90 #ifndef OHOS_ARCH_LITE
91 if (pStaAppAcceleration != nullptr) {
92 delete pStaAppAcceleration;
93 pStaAppAcceleration = nullptr;
94 }
95 #endif
96 }
97
InitStaService(const std::vector<StaServiceCallback> & callbacks)98 ErrCode StaService::InitStaService(const std::vector<StaServiceCallback> &callbacks)
99 {
100 WIFI_LOGI("Enter InitStaService m_instId:%{public}d\n", m_instId);
101 pStaStateMachine = new (std::nothrow) StaStateMachine(m_instId);
102 if (pStaStateMachine == nullptr) {
103 WIFI_LOGE("Alloc pStaStateMachine failed.\n");
104 return WIFI_OPT_FAILED;
105 }
106
107 if (pStaStateMachine->InitStaStateMachine() != WIFI_OPT_SUCCESS) {
108 WIFI_LOGE("InitStaStateMachine failed.\n");
109 return WIFI_OPT_FAILED;
110 }
111
112 RegisterStaServiceCallback(callbacks);
113
114 pStaMonitor = new (std::nothrow) StaMonitor(m_instId);
115 if (pStaMonitor == nullptr) {
116 WIFI_LOGE("Alloc pStaMonitor failed.\n");
117 return WIFI_OPT_FAILED;
118 }
119
120 if (pStaMonitor->InitStaMonitor() != WIFI_OPT_SUCCESS) {
121 WIFI_LOGE("InitStaMonitor failed.\n");
122 return WIFI_OPT_FAILED;
123 }
124
125 pStaMonitor->SetStateMachine(pStaStateMachine);
126
127 if (m_instId == INSTID_WLAN0) {
128 pStaAutoConnectService = new (std::nothrow) StaAutoConnectService(pStaStateMachine, m_instId);
129 if (pStaAutoConnectService == nullptr) {
130 WIFI_LOGE("Alloc pStaAutoConnectService failed.\n");
131 return WIFI_OPT_FAILED;
132 }
133 if (pStaAutoConnectService->InitAutoConnectService() != WIFI_OPT_SUCCESS) {
134 WIFI_LOGE("InitAutoConnectService failed.\n");
135 return WIFI_OPT_FAILED;
136 }
137 pStaAutoConnectService->SetAutoConnectStateCallback(callbacks);
138 #ifndef OHOS_ARCH_LITE
139 pStaAppAcceleration = new (std::nothrow) StaAppAcceleration(m_instId);
140 if (pStaAppAcceleration == nullptr) {
141 WIFI_LOGE("Alloc pStaAppAcceleration failed.\n");
142 }
143
144 if (pStaAppAcceleration->InitAppAcceleration() != WIFI_OPT_SUCCESS) {
145 WIFI_LOGE("InitAppAcceleration failed.\n");
146 }
147 std::vector<StaServiceCallback> appAccelerationStaCallBacks;
148 appAccelerationStaCallBacks.push_back(pStaAppAcceleration->GetStaCallback());
149 RegisterStaServiceCallback(appAccelerationStaCallBacks);
150 GetStaControlInfo();
151 #endif
152 }
153 WIFI_LOGI("Init staservice successfully.\n");
154 return WIFI_OPT_SUCCESS;
155 }
156
157 #ifndef OHOS_ARCH_LITE
GetStaControlInfo()158 void StaService::GetStaControlInfo()
159 {
160 WIFI_LOGI("Enter GetStaControlInfo.");
161 std::map<std::string, std::vector<std::string>> filterMap;
162 if (WifiSettings::GetInstance().GetPackageFilterMap(filterMap) != 0) {
163 WIFI_LOGE("WifiSettings::GetInstance().GetPackageFilterMap failed");
164 }
165 sta_candidate_trust_list = filterMap["sta_candidate_filter"];
166 return;
167 }
168
IsAppInCandidateFilterList(int uid) const169 bool StaService::IsAppInCandidateFilterList(int uid) const
170 {
171 std::string packageName;
172 GetBundleNameByUid(uid, packageName);
173 if (std::find(sta_candidate_trust_list.begin(), sta_candidate_trust_list.end(), packageName)
174 != sta_candidate_trust_list.end()) {
175 WIFI_LOGI("App is in Candidate filter list.");
176 return true;
177 }
178 return false;
179 }
180 #endif
181
EnableStaService()182 ErrCode StaService::EnableStaService()
183 {
184 WIFI_LOGI("Enter EnableStaService m_instId:%{public}d\n", m_instId);
185 CHECK_NULL_AND_RETURN(pStaStateMachine, WIFI_OPT_FAILED);
186 #ifndef OHOS_ARCH_LITE
187 if (m_instId == INSTID_WLAN0) {
188 // notification of registration country code change
189 std::string moduleName = "StaService_" + std::to_string(m_instId);
190 m_staObserver = std::make_shared<WifiCountryCodeChangeObserver>(moduleName, *pStaStateMachine);
191 if (m_staObserver == nullptr) {
192 WIFI_LOGI("m_staObserver is null\n");
193 return WIFI_OPT_FAILED;
194 }
195 WifiCountryCodeManager::GetInstance().RegisterWifiCountryCodeChangeListener(m_staObserver);
196 }
197 #endif
198 WifiSettings::GetInstance().ReloadDeviceConfig();
199 pStaStateMachine->SendMessage(WIFI_SVR_CMD_STA_ENABLE_STA, STA_CONNECT_MODE);
200 return WIFI_OPT_SUCCESS;
201 }
202
DisableStaService() const203 ErrCode StaService::DisableStaService() const
204 {
205 WIFI_LOGI("Enter DisableStaService.\n");
206 #ifndef OHOS_ARCH_LITE
207 if (m_instId == INSTID_WLAN0) {
208 // deregistration country code change notification
209 WifiCountryCodeManager::GetInstance().UnregisterWifiCountryCodeChangeListener(m_staObserver);
210 }
211 #endif
212 CHECK_NULL_AND_RETURN(pStaStateMachine, WIFI_OPT_FAILED);
213 pStaStateMachine->SendMessage(WIFI_SVR_CMD_STA_DISABLE_STA);
214 return WIFI_OPT_SUCCESS;
215 }
216
AddCandidateConfig(const int uid,const WifiDeviceConfig & config,int & netWorkId) const217 ErrCode StaService::AddCandidateConfig(const int uid, const WifiDeviceConfig &config, int& netWorkId) const
218 {
219 LOGI("Enter AddCandidateConfig.\n");
220
221 netWorkId = INVALID_NETWORK_ID;
222 constexpr int kUidUntrustedConfigLen = 16;
223 std::vector<WifiDeviceConfig> tempConfigs;
224 WifiSettings::GetInstance().GetAllCandidateConfig(uid, tempConfigs);
225 if (tempConfigs.size() >= kUidUntrustedConfigLen) {
226 LOGE("AddCandidateConfig failed, exceed max num: %{public}d\n", kUidUntrustedConfigLen);
227 return WIFI_OPT_FAILED;
228 }
229
230 if (config.keyMgmt == KEY_MGMT_WEP) {
231 #ifndef OHOS_ARCH_LITE
232 std::string wifiBrokerFrameProcessName = "";
233 bool success = WifiSettings::GetInstance().GetConfigValueByName("anco_broker_name", wifiBrokerFrameProcessName);
234 std::string ancoBrokerFrameProcessName = GetBrokerProcessNameByPid(GetCallingUid(), GetCallingPid());
235 if (!success || ancoBrokerFrameProcessName != wifiBrokerFrameProcessName) {
236 LOGE("AddCandidateConfig unsupport wep key!");
237 return WIFI_OPT_NOT_SUPPORTED;
238 }
239 #else
240 LOGE("AddCandidateConfig unsupport wep key!");
241 return WIFI_OPT_NOT_SUPPORTED;
242 #endif
243 }
244 WifiDeviceConfig tempDeviceConfig = config;
245 tempDeviceConfig.uid = uid;
246 #ifndef OHOS_ARCH_LITE
247 if (IsAppInCandidateFilterList(uid)) {
248 tempDeviceConfig.isShared = true;
249 tempDeviceConfig.isEphemeral = false;
250 }
251 #endif
252 netWorkId = AddDeviceConfig(tempDeviceConfig);
253 return (netWorkId == INVALID_NETWORK_ID) ? WIFI_OPT_FAILED : WIFI_OPT_SUCCESS;
254 }
255
RemoveCandidateConfig(const int uid,const int networkId) const256 ErrCode StaService::RemoveCandidateConfig(const int uid, const int networkId) const
257 {
258 LOGD("Enter RemoveCandidateConfig.\n");
259 WifiDeviceConfig config;
260 if (WifiSettings::GetInstance().GetCandidateConfig(uid, networkId, config) == INVALID_NETWORK_ID) {
261 LOGE("RemoveCandidateConfig-GetCandidateConfig no foud failed!");
262 return WIFI_OPT_FAILED;
263 }
264
265 /* Remove network configuration. */
266 return RemoveDevice(config.networkId);
267 }
268
RemoveAllCandidateConfig(const int uid) const269 ErrCode StaService::RemoveAllCandidateConfig(const int uid) const
270 {
271 LOGD("Enter RemoveAllCandidateConfig.\n");
272 std::vector<WifiDeviceConfig> tempConfigs;
273 WifiSettings::GetInstance().GetAllCandidateConfig(uid, tempConfigs);
274 for (const auto &config : tempConfigs) {
275 if (RemoveDevice(config.networkId) != WIFI_OPT_SUCCESS) {
276 LOGE("RemoveAllCandidateConfig-RemoveDevice() failed!");
277 }
278 }
279 return WIFI_OPT_SUCCESS;
280 }
281
ConnectToCandidateConfig(const int uid,const int networkId) const282 ErrCode StaService::ConnectToCandidateConfig(const int uid, const int networkId) const
283 {
284 LOGI("Enter ConnectToCandidateConfig.\n");
285 WifiDeviceConfig config;
286 if (WifiSettings::GetInstance().GetCandidateConfig(uid, networkId, config) == INVALID_NETWORK_ID) {
287 LOGE("ConnectToCandidateConfig:GetCandidateConfig is null!");
288 return WIFI_OPT_FAILED;
289 }
290
291 #ifndef OHOS_ARCH_LITE
292 if (config.lastConnectTime <= 0) {
293 WifiConfigCenter::GetInstance().SetSelectedCandidateNetworkId(networkId);
294 WifiNotificationUtil::GetInstance().ShowDialog(WifiDialogType::CANDIDATE_CONNECT);
295 return WIFI_OPT_SUCCESS;
296 }
297 #endif
298 CHECK_NULL_AND_RETURN(pStaAutoConnectService, WIFI_OPT_FAILED);
299 pStaAutoConnectService->EnableOrDisableBssid(config.bssid, true, 0);
300 pStaStateMachine->SetPortalBrowserFlag(false);
301 pStaStateMachine->SendMessage(WIFI_SVR_CMD_STA_CONNECT_SAVED_NETWORK, networkId, NETWORK_SELECTED_BY_USER);
302 return WIFI_OPT_SUCCESS;
303 }
304
ConvertString(const std::u16string & wideText) const305 std::string StaService::ConvertString(const std::u16string &wideText) const
306 {
307 return std::wstring_convert<std::codecvt_utf8_utf16<char16_t>, char16_t>{}.to_bytes(wideText);
308 }
309
310 #ifndef OHOS_ARCH_LITE
GetDataSlotId(int32_t slotId) const311 int32_t StaService::GetDataSlotId(int32_t slotId) const
312 {
313 int32_t simCount = CoreServiceClient::GetInstance().GetMaxSimCount();
314 if (slotId >= 0 && slotId < simCount) {
315 LOGI("slotId: %{public}d, simCount:%{public}d", slotId, simCount);
316 return slotId;
317 }
318 auto slotDefaultID = CellularDataClient::GetInstance().GetDefaultCellularDataSlotId();
319 if ((slotDefaultID < 0) || (slotDefaultID >= simCount)) {
320 LOGE("failed to get default slotId, slotId:%{public}d, simCount:%{public}d", slotDefaultID, simCount);
321 return -1;
322 }
323 LOGI("slotDefaultID: %{public}d, simCount:%{public}d", slotDefaultID, simCount);
324 return slotDefaultID;
325 }
326
GetImsi(int32_t slotId) const327 std::string StaService::GetImsi(int32_t slotId) const
328 {
329 std::u16string imsi;
330 int32_t errCode = CoreServiceClient::GetInstance().GetIMSI(slotId, imsi);
331 if (errCode != 0) {
332 LOGE("failed to get imsi, errCode: %{public}d", errCode);
333 return "";
334 }
335 return ConvertString(imsi);
336 }
337
GetPlmn(int32_t slotId) const338 std::string StaService::GetPlmn(int32_t slotId) const
339 {
340 std::u16string plmn;
341 int32_t errCode = CoreServiceClient::GetInstance().GetSimOperatorNumeric(slotId, plmn);
342 if (errCode != 0) {
343 LOGE("failed to get plmn, errCode: %{public}d", errCode);
344 return "";
345 }
346 return ConvertString(plmn);
347 }
348 #endif
349
GetMcc(const std::string & imsi) const350 std::string StaService::GetMcc(const std::string &imsi) const
351 {
352 return imsi.substr(EAP_AUTH_IMSI_MCC_POS, EAP_AUTH_MAX_MCC_LEN);
353 }
354
GetMnc(const std::string & imsi,const int mncLen) const355 std::string StaService::GetMnc(const std::string &imsi, const int mncLen) const
356 {
357 return imsi.substr(EAP_AUTH_IMSI_MNC_POS, mncLen);
358 }
359
UpdateEapConfig(const WifiDeviceConfig & config,WifiEapConfig & wifiEapConfig) const360 void StaService::UpdateEapConfig(const WifiDeviceConfig &config, WifiEapConfig &wifiEapConfig) const
361 {
362 std::string eapMethod = config.wifiEapConfig.eap;
363
364 LOGI("Enter StaService::UpdateEapConfig, eapMethod:%{public}s", eapMethod.c_str());
365 std::string prefix;
366 if (eapMethod == EAP_METHOD_SIM) {
367 prefix = EAP_SIM_PERMANENT_PREFIX;
368 } else if (eapMethod == EAP_METHOD_AKA) {
369 prefix = EAP_AKA_PERMANENT_PREFIX;
370 } else if (eapMethod == EAP_METHOD_AKA_PRIME) {
371 prefix = EAP_AKA_PRIME_PERMANENT_PREFIX;
372 } else {
373 return;
374 }
375
376 int32_t slotId = GetDataSlotId(config.wifiEapConfig.eapSubId);
377 if (slotId == -1) {
378 return;
379 }
380
381 std::string imsi = GetImsi(slotId);
382 if (imsi.empty() || imsi.length() > EAP_AUTH_MAX_IMSI_LENGTH) {
383 LOGE("invalid imsi, length: %{public}zu", imsi.length());
384 return;
385 }
386
387 std::string mnc;
388 std::string plmn = GetPlmn(slotId);
389 LOGI("imsi: %{private}s, plmn: %{public}s", imsi.c_str(), plmn.c_str());
390 if (plmn.length() == EAP_AUTH_MIN_PLMN_LEN) {
391 mnc = "0" + GetMnc(imsi, EAP_AUTH_MIN_MNC_LEN);
392 } else if (plmn.length() == EAP_AUTH_MAX_PLMN_LEN) {
393 mnc = GetMnc(imsi, EAP_AUTH_MAX_MNC_LEN);
394 } else {
395 LOGE("invalid plmn, length: %{public}zu", plmn.length());
396 return;
397 }
398
399 // identity: prefix + imsi + "@wlan.mnc" + mnc + ".mcc" + mcc + ".3gppnetwork.org"
400 std::string identity = prefix + imsi + EAP_AUTH_WLAN_MNC + mnc +
401 EAP_AUTH_WLAN_MCC + GetMcc(imsi) + EAP_AUTH_PERMANENT_SUFFIX;
402 LOGI("StaService::UpdateEapConfig, identity: %{public}s", identity.c_str());
403 wifiEapConfig.identity = identity;
404 }
405
AddDeviceConfig(const WifiDeviceConfig & config) const406 int StaService::AddDeviceConfig(const WifiDeviceConfig &config) const
407 {
408 LOGI("Enter AddDeviceConfig, ssid:%{public}s, bssid=%{public}s, keyMgmt: %{public}s\n",
409 SsidAnonymize(config.ssid).c_str(), MacAnonymize(config.bssid).c_str(), config.keyMgmt.c_str());
410 CHECK_NULL_AND_RETURN(pStaStateMachine, WIFI_OPT_FAILED);
411 int netWorkId = INVALID_NETWORK_ID;
412 bool isUpdate = false;
413 std::string bssid;
414 std::string userSelectbssid = config.bssid;
415 int status = config.status;
416 WifiDeviceConfig tempDeviceConfig;
417 tempDeviceConfig.instanceId = config.instanceId;
418 if (FindDeviceConfig(config, tempDeviceConfig) == 0) {
419 netWorkId = tempDeviceConfig.networkId;
420 status = tempDeviceConfig.status;
421 if (m_instId == INSTID_WLAN0) {
422 CHECK_NULL_AND_RETURN(pStaAutoConnectService, WIFI_OPT_FAILED);
423 bssid = config.bssid.empty() ? tempDeviceConfig.bssid : config.bssid;
424 pStaAutoConnectService->EnableOrDisableBssid(bssid, true, 0);
425 }
426 isUpdate = true;
427 } else {
428 netWorkId = WifiSettings::GetInstance().GetNextNetworkId();
429 LOGI("AddDeviceConfig alloc new id[%{public}d] succeed!", netWorkId);
430 }
431 tempDeviceConfig = config;
432 tempDeviceConfig.numAssociation = 0;
433 tempDeviceConfig.instanceId = m_instId;
434 tempDeviceConfig.networkId = netWorkId;
435 tempDeviceConfig.status = status;
436 tempDeviceConfig.userSelectBssid = userSelectbssid;
437 if (!bssid.empty()) {
438 tempDeviceConfig.bssid = bssid;
439 }
440 if (config.wifiEapConfig.eap == EAP_METHOD_TLS && config.wifiEapConfig.certEntry.size() > 0 &&
441 config.wifiEapConfig.clientCert.empty() && config.wifiEapConfig.privateKey.empty()) {
442 std::string uri;
443 std::string formatSsid = config.ssid;
444 for (int i = 0; i < static_cast<int>(formatSsid.size()); i++) {
445 // other char is invalid in certificate manager
446 if (!isalnum(formatSsid[i]) && formatSsid[i] != '_') {
447 formatSsid[i] = '_';
448 }
449 }
450 std::string alias = formatSsid + "_TLS_" + std::to_string(config.uid < 0 ? 0 : config.uid);
451 int ret = WifiCertUtils::InstallCert(config.wifiEapConfig.certEntry,
452 std::string(config.wifiEapConfig.certPassword), alias, uri);
453 if (ret == 0) {
454 tempDeviceConfig.wifiEapConfig.clientCert = uri;
455 tempDeviceConfig.wifiEapConfig.privateKey = uri;
456 LOGI("success to install cert: %{public}s", tempDeviceConfig.wifiEapConfig.clientCert.c_str());
457 } else {
458 LOGE("failed to install cert: %{public}d, alias: %{public}s", ret, alias.c_str());
459 }
460 }
461
462 UpdateEapConfig(config, tempDeviceConfig.wifiEapConfig);
463
464 /* Add the new network to WifiSettings. */
465 if (!WifiSettings::GetInstance().EncryptionDeviceConfig(tempDeviceConfig)) {
466 LOGI("AddDeviceConfig EncryptionDeviceConfig failed");
467 }
468 WifiSettings::GetInstance().AddDeviceConfig(tempDeviceConfig);
469 WifiSettings::GetInstance().SyncDeviceConfig();
470 /* update net link proxy info */
471 pStaStateMachine->ReUpdateNetLinkInfo(tempDeviceConfig);
472 ConfigChange changeType = isUpdate ? ConfigChange::CONFIG_UPDATE : ConfigChange::CONFIG_ADD;
473 NotifyDeviceConfigChange(changeType);
474 return netWorkId;
475 }
476
UpdateDeviceConfig(const WifiDeviceConfig & config) const477 int StaService::UpdateDeviceConfig(const WifiDeviceConfig &config) const
478 {
479 return AddDeviceConfig(config);
480 }
481
RemoveDevice(int networkId) const482 ErrCode StaService::RemoveDevice(int networkId) const
483 {
484 LOGI("Enter RemoveDevice, networkId = %{public}d m_instId:%{public}d\n", networkId, m_instId);
485
486 CHECK_NULL_AND_RETURN(pStaStateMachine, WIFI_OPT_FAILED);
487 pStaStateMachine->SendMessage(WIFI_SVR_COM_STA_NETWORK_REMOVED, networkId);
488 WifiLinkedInfo linkedInfo;
489 WifiConfigCenter::GetInstance().GetLinkedInfo(linkedInfo, m_instId);
490 if (linkedInfo.networkId == networkId) {
491 std::string ifaceName = WifiConfigCenter::GetInstance().GetStaIfaceName(m_instId);
492 WifiStaHalInterface::GetInstance().ClearDeviceConfig(ifaceName);
493 }
494
495 WifiDeviceConfig config;
496 if (WifiSettings::GetInstance().GetDeviceConfig(networkId, config, m_instId) == 0) {
497 CHECK_NULL_AND_RETURN(pStaAutoConnectService, WIFI_OPT_FAILED);
498 pStaAutoConnectService->EnableOrDisableBssid(config.bssid, true, 0);
499 } else {
500 LOGE("RemoveDevice, networkId = %{public}d do not exist.\n", networkId);
501 return WIFI_OPT_FAILED;
502 }
503 /* Remove network configuration directly without notification to InterfaceService. */
504 WifiSettings::GetInstance().RemoveDevice(networkId);
505 WifiSettings::GetInstance().SyncDeviceConfig();
506 NotifyDeviceConfigChange(ConfigChange::CONFIG_REMOVE);
507 #ifndef OHOS_ARCH_LITE
508 std::string wifiBrokerFrameProcessName = "";
509 bool success = WifiSettings::GetInstance().GetConfigValueByName("anco_broker_name", wifiBrokerFrameProcessName);
510 std::string ancoBrokerFrameProcessName = GetBrokerProcessNameByPid(GetCallingUid(), GetCallingPid());
511 if (success && ancoBrokerFrameProcessName == wifiBrokerFrameProcessName) {
512 config.callProcessName = wifiBrokerFrameProcessName;
513 } else {
514 config.callProcessName = "";
515 }
516 WifiConfigCenter::GetInstance().SetChangeDeviceConfig(ConfigChange::CONFIG_REMOVE, config);
517 #endif
518 return WIFI_OPT_SUCCESS;
519 }
520
RemoveAllDevice() const521 ErrCode StaService::RemoveAllDevice() const
522 {
523 LOGI("Enter RemoveAllDevice.\n");
524 std::string ifaceName = WifiConfigCenter::GetInstance().GetStaIfaceName(m_instId);
525 if (WifiStaHalInterface::GetInstance().ClearDeviceConfig(ifaceName) == WIFI_HAL_OPT_OK) {
526 LOGD("Remove all device config successfully!");
527 } else {
528 LOGE("WifiStaHalInterface:RemoveAllDevice failed!");
529 return WIFI_OPT_FAILED;
530 }
531
532 WifiSettings::GetInstance().ClearDeviceConfig();
533 if (WifiSettings::GetInstance().SyncDeviceConfig() != 0) {
534 LOGE("RemoveAllDevice-SyncDeviceConfig() failed!");
535 return WIFI_OPT_FAILED;
536 }
537 NotifyDeviceConfigChange(ConfigChange::CONFIG_REMOVE);
538 #ifndef OHOS_ARCH_LITE
539 WifiDeviceConfig config;
540 config.networkId = REMOVE_ALL_DEVICECONFIG;
541 std::string wifiBrokerFrameProcessName = "";
542 bool success = WifiSettings::GetInstance().GetConfigValueByName("anco_broker_name", wifiBrokerFrameProcessName);
543 std::string ancoBrokerFrameProcessName = GetBrokerProcessNameByPid(GetCallingUid(), GetCallingPid());
544 if (success && ancoBrokerFrameProcessName == wifiBrokerFrameProcessName) {
545 config.callProcessName = wifiBrokerFrameProcessName;
546 } else {
547 config.callProcessName = "";
548 }
549 WifiConfigCenter::GetInstance().SetChangeDeviceConfig(ConfigChange::CONFIG_REMOVE, config);
550 #endif
551 return WIFI_OPT_SUCCESS;
552 }
553
ConnectToDevice(const WifiDeviceConfig & config) const554 ErrCode StaService::ConnectToDevice(const WifiDeviceConfig &config) const
555 {
556 LOGI(
557 "Enter ConnectToDevice, ssid = %{public}s instId:%{public}d. \n", SsidAnonymize(config.ssid).c_str(), m_instId);
558 CHECK_NULL_AND_RETURN(pStaStateMachine, WIFI_OPT_FAILED);
559 int netWorkId = AddDeviceConfig(config);
560 if (netWorkId == INVALID_NETWORK_ID) {
561 LOGD("ConnectToDevice, AddDeviceConfig failed!");
562 return WIFI_OPT_FAILED;
563 }
564 LOGI("ConnectToDevice, netWorkId: %{public}d", netWorkId);
565 pStaStateMachine->SendMessage(WIFI_SVR_CMD_STA_CONNECT_NETWORK, netWorkId, NETWORK_SELECTED_BY_USER);
566 return WIFI_OPT_SUCCESS;
567 }
568
ConnectToNetwork(int networkId,int type) const569 ErrCode StaService::ConnectToNetwork(int networkId, int type) const
570 {
571 LOGI("Enter ConnectToNetwork, networkId is %{public}d.", networkId);
572 WifiDeviceConfig config;
573 if (WifiSettings::GetInstance().GetDeviceConfig(networkId, config, m_instId) != 0) {
574 LOGE("WifiDeviceConfig is null!");
575 return WIFI_OPT_FAILED;
576 }
577 CHECK_NULL_AND_RETURN(pStaAutoConnectService, WIFI_OPT_FAILED);
578 CHECK_NULL_AND_RETURN(pStaStateMachine, WIFI_OPT_FAILED);
579 LOGI("ConnectToNetwork, ssid = %{public}s.", SsidAnonymize(config.ssid).c_str());
580 pStaAutoConnectService->EnableOrDisableBssid(config.bssid, true, 0);
581 pStaStateMachine->SetPortalBrowserFlag(false);
582 pStaStateMachine->SendMessage(WIFI_SVR_CMD_STA_CONNECT_SAVED_NETWORK, networkId, type);
583 return WIFI_OPT_SUCCESS;
584 }
585
StartRoamToNetwork(const int networkId,const std::string bssid) const586 ErrCode StaService::StartRoamToNetwork(const int networkId, const std::string bssid) const
587 {
588 LOGI("Enter StartRoamToNetwork, networkId: %{public}d, bssid: %{public}s", networkId, MacAnonymize(bssid).c_str());
589 WifiDeviceConfig config;
590 if (WifiSettings::GetInstance().GetDeviceConfig(networkId, config, m_instId) != 0) {
591 LOGE("%{public}s WifiDeviceConfig is null!", __FUNCTION__);
592 return WIFI_OPT_FAILED;
593 }
594 CHECK_NULL_AND_RETURN(pStaStateMachine, WIFI_OPT_FAILED);
595
596 WifiLinkedInfo linkedInfo;
597 WifiConfigCenter::GetInstance().GetLinkedInfo(linkedInfo, m_instId);
598 if (networkId == linkedInfo.networkId) {
599 if (bssid == linkedInfo.bssid) {
600 LOGI("%{public}s current linkedBssid equal to target bssid", __FUNCTION__);
601 } else {
602 LOGI("%{public}s current linkedBssid: %{public}s, roam to targetBssid: %{public}s",
603 __FUNCTION__, MacAnonymize(linkedInfo.bssid).c_str(), MacAnonymize(bssid).c_str());
604 pStaStateMachine->StartRoamToNetwork(bssid);
605 }
606 } else {
607 LOGI("%{public}s switch to target network", __FUNCTION__);
608 auto message = pStaStateMachine->CreateMessage(WIFI_SVR_CMD_STA_CONNECT_SAVED_NETWORK);
609 message->SetParam1(networkId);
610 message->SetParam2(NETWORK_SELECTED_BY_USER);
611 message->AddStringMessageBody(bssid);
612 pStaStateMachine->SendMessage(message);
613 }
614 return WIFI_OPT_SUCCESS;
615 }
616
StartConnectToUserSelectNetwork(int networkId,std::string bssid) const617 ErrCode StaService::StartConnectToUserSelectNetwork(int networkId, std::string bssid) const
618 {
619 LOGI("Enter StartConnectToUserSelectNetwork, networkId: %{public}d, bssid: %{public}s",
620 networkId, MacAnonymize(bssid).c_str());
621 WifiDeviceConfig config;
622 if (WifiSettings::GetInstance().GetDeviceConfig(networkId, config, m_instId) != 0) {
623 LOGE("%{public}s WifiDeviceConfig is null!", __FUNCTION__);
624 return WIFI_OPT_FAILED;
625 }
626 CHECK_NULL_AND_RETURN(pStaStateMachine, WIFI_OPT_FAILED);
627 auto message = pStaStateMachine->CreateMessage(WIFI_SVR_CMD_STA_CONNECT_SAVED_NETWORK);
628 message->SetParam1(networkId);
629 message->SetParam2(NETWORK_SELECTED_BY_USER);
630 message->AddStringMessageBody(bssid);
631 pStaStateMachine->SendMessage(message);
632 return WIFI_OPT_SUCCESS;
633 }
634
ReAssociate() const635 ErrCode StaService::ReAssociate() const
636 {
637 WIFI_LOGI("Enter ReAssociate.\n");
638 CHECK_NULL_AND_RETURN(pStaStateMachine, WIFI_OPT_FAILED);
639 pStaStateMachine->SendMessage(WIFI_SVR_CMD_STA_REASSOCIATE_NETWORK);
640 return WIFI_OPT_SUCCESS;
641 }
642
EnableDeviceConfig(int networkId,bool attemptEnable) const643 ErrCode StaService::EnableDeviceConfig(int networkId, bool attemptEnable) const
644 {
645 WIFI_LOGI("Enter EnableDeviceConfig, networkid is %{public}d", networkId);
646
647 /* Update wifi status. */
648 if (WifiSettings::GetInstance().SetDeviceState(networkId, (int)WifiDeviceConfigStatus::ENABLED, attemptEnable) <
649 0) {
650 WIFI_LOGE("Enable device config failed!");
651 return WIFI_OPT_FAILED;
652 }
653 WifiSettings::GetInstance().SyncDeviceConfig();
654 return WIFI_OPT_SUCCESS;
655 }
656
DisableDeviceConfig(int networkId) const657 ErrCode StaService::DisableDeviceConfig(int networkId) const
658 {
659 WIFI_LOGI("Enter DisableDeviceConfig, networkid is %{public}d", networkId);
660
661 if (WifiSettings::GetInstance().SetDeviceState(networkId, (int)WifiDeviceConfigStatus::DISABLED) < 0) {
662 WIFI_LOGE("Disable device config failed!");
663 return WIFI_OPT_FAILED;
664 }
665 WifiSettings::GetInstance().SyncDeviceConfig();
666 return WIFI_OPT_SUCCESS;
667 }
668
Disconnect() const669 ErrCode StaService::Disconnect() const
670 {
671 WIFI_LOGI("Enter Disconnect.\n");
672 if (m_instId == INSTID_WLAN0) {
673 CHECK_NULL_AND_RETURN(pStaAutoConnectService, WIFI_OPT_FAILED);
674 WifiLinkedInfo linkedInfo;
675 WifiConfigCenter::GetInstance().GetLinkedInfo(linkedInfo, m_instId);
676 if (pStaAutoConnectService->EnableOrDisableBssid(linkedInfo.bssid, false, AP_CANNOT_HANDLE_NEW_STA)) {
677 WIFI_LOGI("The blocklist is updated.\n");
678 }
679 }
680 CHECK_NULL_AND_RETURN(pStaStateMachine, WIFI_OPT_FAILED);
681 pStaStateMachine->SendMessage(WIFI_SVR_CMD_STA_DISCONNECT);
682 return WIFI_OPT_SUCCESS;
683 }
684
StartWps(const WpsConfig & config) const685 ErrCode StaService::StartWps(const WpsConfig &config) const
686 {
687 WIFI_LOGI("Enter StartWps.\n");
688 CHECK_NULL_AND_RETURN(pStaStateMachine, WIFI_OPT_FAILED);
689 InternalMessagePtr msg = pStaStateMachine->CreateMessage();
690 msg->SetMessageName(WIFI_SVR_CMD_STA_STARTWPS);
691 msg->SetParam1(static_cast<int>(config.setup));
692 msg->AddStringMessageBody(config.pin);
693 msg->AddStringMessageBody(config.bssid);
694 pStaStateMachine->SendMessage(msg);
695 return WIFI_OPT_SUCCESS;
696 }
697
CancelWps() const698 ErrCode StaService::CancelWps() const
699 {
700 WIFI_LOGI("Enter CanceltWps.\n");
701 CHECK_NULL_AND_RETURN(pStaStateMachine, WIFI_OPT_FAILED);
702 pStaStateMachine->SendMessage(WIFI_SVR_CMD_STA_CANCELWPS);
703 return WIFI_OPT_SUCCESS;
704 }
705
AutoConnectService(const std::vector<InterScanInfo> & scanInfos)706 ErrCode StaService::AutoConnectService(const std::vector<InterScanInfo> &scanInfos)
707 {
708 WIFI_LOGI("Enter AutoConnectService.\n");
709 CHECK_NULL_AND_RETURN(pStaAutoConnectService, WIFI_OPT_FAILED);
710 #ifndef OHOS_ARCH_LITE
711 if (IsOtherVapConnect()) {
712 LOGI("AutoConnectService: p2p or hml connected, and hotspot is enable");
713 return WIFI_OPT_FAILED;
714 }
715 std::string wifiBrokerFrameProcessName = "";
716 bool success = WifiSettings::GetInstance().GetConfigValueByName("anco_broker_name", wifiBrokerFrameProcessName);
717 std::string ancoBrokerFrameProcessName = GetBrokerProcessNameByPid(GetCallingUid(), GetCallingPid());
718 if (success && ancoBrokerFrameProcessName == wifiBrokerFrameProcessName) {
719 WifiConfigCenter::GetInstance().SetWifiConnectedMode(true, m_instId);
720 WIFI_LOGD("StaService %{public}s, anco, %{public}d", __func__, m_instId);
721 } else {
722 WifiConfigCenter::GetInstance().SetWifiConnectedMode(false, m_instId);
723 WIFI_LOGD("StaService %{public}s,not anco, %{public}d", __func__, m_instId);
724 }
725 #endif
726 pStaAutoConnectService->OnScanInfosReadyHandler(scanInfos);
727 return WIFI_OPT_SUCCESS;
728 }
729
RegisterStaServiceCallback(const std::vector<StaServiceCallback> & callbacks) const730 void StaService::RegisterStaServiceCallback(const std::vector<StaServiceCallback> &callbacks) const
731 {
732 LOGI("Enter RegisterStaServiceCallback.");
733 if (pStaStateMachine == nullptr) {
734 LOGE("pStaStateMachine is null.\n");
735 return;
736 }
737 for (StaServiceCallback cb : callbacks) {
738 pStaStateMachine->RegisterStaServiceCallback(cb);
739 }
740 }
741
UnRegisterStaServiceCallback(const StaServiceCallback & callbacks) const742 void StaService::UnRegisterStaServiceCallback(const StaServiceCallback &callbacks) const
743 {
744 LOGI("Enter UnRegisterStaServiceCallback.");
745 if (pStaStateMachine == nullptr) {
746 LOGE("pStaStateMachine is null.\n");
747 return;
748 }
749 pStaStateMachine->UnRegisterStaServiceCallback(callbacks);
750 }
751
ReConnect() const752 ErrCode StaService::ReConnect() const
753 {
754 WIFI_LOGI("Enter ReConnect.\n");
755 CHECK_NULL_AND_RETURN(pStaStateMachine, WIFI_OPT_FAILED);
756 pStaStateMachine->SendMessage(WIFI_SVR_CMD_STA_RECONNECT_NETWORK);
757 return WIFI_OPT_SUCCESS;
758 }
759
SetSuspendMode(bool mode) const760 ErrCode StaService::SetSuspendMode(bool mode) const
761 {
762 LOGI("Enter SetSuspendMode, mode=[%{public}d]!", mode);
763 if (WifiSupplicantHalInterface::GetInstance().WpaSetSuspendMode(mode) != WIFI_HAL_OPT_OK) {
764 LOGE("WpaSetSuspendMode() failed!");
765 return WIFI_OPT_FAILED;
766 }
767 return WIFI_OPT_SUCCESS;
768 }
769
SetPowerMode(bool mode) const770 ErrCode StaService::SetPowerMode(bool mode) const
771 {
772 LOGI("Enter SetPowerMode, mode=[%{public}d]!", mode);
773 if (WifiSupplicantHalInterface::GetInstance().WpaSetPowerMode(mode) != WIFI_HAL_OPT_OK) {
774 LOGE("SetPowerMode() failed!");
775 return WIFI_OPT_FAILED;
776 }
777 return WIFI_OPT_SUCCESS;
778 }
779
NotifyDeviceConfigChange(ConfigChange value) const780 void StaService::NotifyDeviceConfigChange(ConfigChange value) const
781 {
782 WIFI_LOGI("Notify device config change: %{public}d\n", static_cast<int>(value));
783 #ifndef OHOS_ARCH_LITE
784 WifiEventCallbackMsg cbMsg;
785 cbMsg.msgCode = WIFI_CBK_MSG_DEVICE_CONFIG_CHANGE;
786 cbMsg.msgData = static_cast<int>(value);
787 cbMsg.id = m_instId;
788 WifiInternalEventDispatcher::GetInstance().AddBroadCastMsg(cbMsg);
789 #endif
790 }
791
FindDeviceConfig(const WifiDeviceConfig & config,WifiDeviceConfig & outConfig) const792 int StaService::FindDeviceConfig(const WifiDeviceConfig &config, WifiDeviceConfig &outConfig) const
793 {
794 int ret = -1;
795 if (config.uid > WIFI_INVALID_UID) {
796 ret = WifiSettings::GetInstance().GetCandidateConfig(config.uid, config.ssid, config.keyMgmt, outConfig);
797 } else {
798 ret = WifiSettings::GetInstance().GetDeviceConfig(config.ssid, config.keyMgmt, outConfig, m_instId);
799 }
800 LOGI("FindDeviceConfig uid:%{public}d, ssid:%{public}s, ret:%{public}d.", config.uid,
801 SsidAnonymize(outConfig.ssid).c_str(), ret);
802 return (ret < 0) ? WIFI_OPT_FAILED : WIFI_OPT_SUCCESS;
803 }
804
OnSystemAbilityChanged(int systemAbilityid,bool add)805 ErrCode StaService::OnSystemAbilityChanged(int systemAbilityid, bool add)
806 {
807 WIFI_LOGI("Enter OnSystemAbilityChanged.");
808 #ifndef OHOS_ARCH_LITE
809 CHECK_NULL_AND_RETURN(pStaStateMachine, WIFI_OPT_FAILED);
810 if (systemAbilityid == COMM_NET_CONN_MANAGER_SYS_ABILITY_ID) {
811 uint32_t supplierId = WifiNetAgent::GetInstance().GetSupplierId();
812 if ((add && !m_connMangerStatus) || (supplierId == INVALID_SUPPLIER_ID)) {
813 WifiNetAgent::GetInstance().ResetSupplierId();
814 pStaStateMachine->OnNetManagerRestart();
815 }
816 m_connMangerStatus = add;
817 }
818 #endif
819 return WIFI_OPT_SUCCESS;
820 }
821
822 #ifndef OHOS_ARCH_LITE
OnWifiCountryCodeChanged(const std::string & wifiCountryCode)823 ErrCode StaService::WifiCountryCodeChangeObserver::OnWifiCountryCodeChanged(const std::string &wifiCountryCode)
824 {
825 if (strcasecmp(m_lastWifiCountryCode.c_str(), wifiCountryCode.c_str()) == 0) {
826 WIFI_LOGI("wifi country code is same, sta not update, code=%{public}s", wifiCountryCode.c_str());
827 return WIFI_OPT_SUCCESS;
828 }
829 WIFI_LOGI("deal wifi country code changed, code=%{public}s", wifiCountryCode.c_str());
830 InternalMessagePtr msg = m_stateMachineObj.CreateMessage();
831 CHECK_NULL_AND_RETURN(msg, WIFI_OPT_FAILED);
832 msg->SetMessageName(static_cast<int>(WIFI_SVR_CMD_UPDATE_COUNTRY_CODE));
833 msg->AddStringMessageBody(wifiCountryCode);
834 m_stateMachineObj.SendMessage(msg);
835 m_lastWifiCountryCode = wifiCountryCode;
836 return WIFI_OPT_SUCCESS;
837 }
838
GetListenerModuleName()839 std::string StaService::WifiCountryCodeChangeObserver::GetListenerModuleName()
840 {
841 return m_listenerModuleName;
842 }
843 #endif
844
HandleScreenStatusChanged(int screenState)845 void StaService::HandleScreenStatusChanged(int screenState)
846 {
847 WIFI_LOGD("Enter HandleScreenStatusChanged screenState:%{public}d, instId:%{public}d", screenState, m_instId);
848 #ifndef OHOS_ARCH_LITE
849 if (pStaStateMachine == nullptr) {
850 WIFI_LOGE("pStaStateMachine is null!");
851 return;
852 }
853 pStaStateMachine->SendMessage(WIFI_SCREEN_STATE_CHANGED_NOTIFY_EVENT, screenState);
854 if (m_instId == INSTID_WLAN0) {
855 if (screenState == MODE_STATE_OPEN) {
856 pStaStateMachine->StartDetectTimer(DETECT_TYPE_DEFAULT);
857 } else {
858 pStaStateMachine->StopTimer(static_cast<int>(CMD_START_NETCHECK));
859 }
860 }
861 if (pStaAppAcceleration != nullptr) {
862 pStaAppAcceleration->HandleScreenStatusChanged(screenState);
863 }
864 #endif
865 return;
866 }
867
DisableAutoJoin(const std::string & conditionName)868 ErrCode StaService::DisableAutoJoin(const std::string &conditionName)
869 {
870 CHECK_NULL_AND_RETURN(pStaAutoConnectService, WIFI_OPT_FAILED);
871 pStaAutoConnectService->DisableAutoJoin(conditionName);
872 return WIFI_OPT_SUCCESS;
873 }
874
EnableAutoJoin(const std::string & conditionName)875 ErrCode StaService::EnableAutoJoin(const std::string &conditionName)
876 {
877 CHECK_NULL_AND_RETURN(pStaAutoConnectService, WIFI_OPT_FAILED);
878 pStaAutoConnectService->EnableAutoJoin(conditionName);
879 return WIFI_OPT_SUCCESS;
880 }
881
RegisterAutoJoinCondition(const std::string & conditionName,const std::function<bool ()> & autoJoinCondition)882 ErrCode StaService::RegisterAutoJoinCondition(const std::string &conditionName,
883 const std::function<bool()> &autoJoinCondition)
884 {
885 CHECK_NULL_AND_RETURN(pStaAutoConnectService, WIFI_OPT_FAILED);
886 pStaAutoConnectService->RegisterAutoJoinCondition(conditionName, autoJoinCondition);
887 return WIFI_OPT_SUCCESS;
888 }
889
DeregisterAutoJoinCondition(const std::string & conditionName)890 ErrCode StaService::DeregisterAutoJoinCondition(const std::string &conditionName)
891 {
892 CHECK_NULL_AND_RETURN(pStaAutoConnectService, WIFI_OPT_FAILED);
893 pStaAutoConnectService->DeregisterAutoJoinCondition(conditionName);
894 return WIFI_OPT_SUCCESS;
895 }
896
RegisterFilterBuilder(const OHOS::Wifi::FilterTag & filterTag,const std::string & filterName,const OHOS::Wifi::FilterBuilder & filterBuilder)897 ErrCode StaService::RegisterFilterBuilder(const OHOS::Wifi::FilterTag &filterTag,
898 const std::string &filterName,
899 const OHOS::Wifi::FilterBuilder &filterBuilder)
900 {
901 ExternalWifiFilterBuildManager::GetInstance().RegisterFilterBuilder(filterTag, filterName, filterBuilder);
902 return WIFI_OPT_SUCCESS;
903 }
904
DeregisterFilterBuilder(const OHOS::Wifi::FilterTag & filterTag,const std::string & filterName)905 ErrCode StaService::DeregisterFilterBuilder(const OHOS::Wifi::FilterTag &filterTag, const std::string &filterName)
906 {
907 ExternalWifiFilterBuildManager::GetInstance().DeregisterFilterBuilder(filterTag, filterName);
908 return WIFI_OPT_SUCCESS;
909 }
910
RegisterCommonBuilder(const TagType & tagType,const std::string & tagName,const CommonBuilder & commonBuilder)911 ErrCode StaService::RegisterCommonBuilder(const TagType &tagType, const std::string &tagName,
912 const CommonBuilder &commonBuilder)
913 {
914 ExternalWifiCommonBuildManager::GetInstance().RegisterCommonBuilder(tagType, tagName, commonBuilder);
915 return WIFI_OPT_SUCCESS;
916 }
917
DeregisterCommonBuilder(const TagType & tagType,const std::string & tagName)918 ErrCode StaService::DeregisterCommonBuilder(const TagType &tagType, const std::string &tagName)
919 {
920 ExternalWifiCommonBuildManager::GetInstance().DeregisterCommonBuilder(tagType, tagName);
921 return WIFI_OPT_SUCCESS;
922 }
923
StartPortalCertification()924 ErrCode StaService::StartPortalCertification()
925 {
926 if (pStaStateMachine == nullptr) {
927 WIFI_LOGE("pStaStateMachine is null!");
928 return WIFI_OPT_FAILED;
929 }
930 WIFI_LOGI("StartPortalCertification send message!");
931 pStaStateMachine->SendMessage(WIFI_SVR_CMD_STA_PORTAL_BROWSE_NOTIFY_EVENT);
932 return WIFI_OPT_SUCCESS;
933 }
934
935 #ifndef OHOS_ARCH_LITE
HandleForegroundAppChangedAction(const AppExecFwk::AppStateData & appStateData)936 ErrCode StaService::HandleForegroundAppChangedAction(const AppExecFwk::AppStateData &appStateData)
937 {
938 if (pStaAppAcceleration == nullptr) {
939 WIFI_LOGE("pStaAppAcceleration is null");
940 return WIFI_OPT_FAILED;
941 }
942 pStaAppAcceleration->HandleForegroundAppChangedAction(appStateData);
943 return WIFI_OPT_SUCCESS;
944 }
945
SetEnhanceService(IEnhanceService * enhanceService)946 ErrCode StaService::SetEnhanceService(IEnhanceService* enhanceService)
947 {
948 CHECK_NULL_AND_RETURN(pStaStateMachine, WIFI_OPT_FAILED);
949 pStaStateMachine->SetEnhanceService(enhanceService);
950 return WIFI_OPT_SUCCESS;
951 }
952 #endif
953
EnableHiLinkHandshake(const WifiDeviceConfig & config,const std::string & cmd)954 ErrCode StaService::EnableHiLinkHandshake(const WifiDeviceConfig &config, const std::string &cmd)
955 {
956 CHECK_NULL_AND_RETURN(pStaStateMachine, WIFI_OPT_FAILED);
957 InternalMessagePtr msg = pStaStateMachine->CreateMessage();
958 msg->SetMessageName(WIFI_SVR_COM_STA_ENABLE_HILINK);
959 msg->SetParam1(config.bssidType);
960 msg->AddStringMessageBody(config.ssid);
961 msg->AddStringMessageBody(config.bssid);
962 msg->AddStringMessageBody(config.keyMgmt);
963 msg->AddStringMessageBody(cmd);
964 pStaStateMachine->SendMessage(msg);
965
966 return WIFI_OPT_SUCCESS;
967 }
968
DeliverStaIfaceData(const std::string & currentMac)969 ErrCode StaService::DeliverStaIfaceData(const std::string ¤tMac)
970 {
971 CHECK_NULL_AND_RETURN(pStaStateMachine, WIFI_OPT_FAILED);
972 pStaStateMachine->SendMessage(WIFI_SVR_COM_STA_HILINK_DELIVER_MAC, currentMac);
973
974 return WIFI_OPT_SUCCESS;
975 }
976 } // namespace Wifi
977 } // namespace OHOS
978