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 "p2p_idle_state.h"
17 #include "wifi_p2p_hal_interface.h"
18 #include "p2p_state_machine.h"
19 #include "wifi_p2p_temp_disc_event.h"
20 #include "wifi_logger.h"
21 #include "wifi_config_center.h"
22 
23 DEFINE_WIFILOG_P2P_LABEL("P2pIdleState");
24 
25 namespace OHOS {
26 namespace Wifi {
27 int P2pIdleState::retryConnectCnt{0};
28 bool P2pIdleState::hasConnect{false};
P2pIdleState(P2pStateMachine & stateMachine,WifiP2pGroupManager & groupMgr,WifiP2pDeviceManager & deviceMgr)29 P2pIdleState::P2pIdleState(
30     P2pStateMachine &stateMachine, WifiP2pGroupManager &groupMgr, WifiP2pDeviceManager &deviceMgr)
31     : State("P2pIdleState"), p2pStateMachine(stateMachine), groupManager(groupMgr), deviceManager(deviceMgr)
32 {}
GoInState()33 void P2pIdleState::GoInState()
34 {
35     hasConnect = false;
36     Init();
37     WIFI_LOGI("             GoInState");
38     p2pStateMachine.StopP2pDhcpClient();
39     p2pStateMachine.ClearGroup();
40     p2pStateMachine.StopTimer(static_cast<int>(P2P_STATE_MACHINE_CMD::EXCEPTION_TIMED_OUT));
41     p2pStateMachine.StartTimer(static_cast<int>(P2P_STATE_MACHINE_CMD::P2P_REMOVE_DEVICE), P2P_REMOVE_DEVICE_TIMEOUT);
42     p2pStateMachine.SetIsNeedDhcp(DHCPTYPE::DHCP_INVALID);
43     SharedLinkManager::ClearSharedLinkCount();
44 }
45 
GoOutState()46 void P2pIdleState::GoOutState()
47 {
48     WIFI_LOGI("             GoOutState");
49     p2pStateMachine.StopTimer(static_cast<int>(P2P_STATE_MACHINE_CMD::P2P_REMOVE_DEVICE));
50     const int exceptionTimeOut = 120000;
51     p2pStateMachine.MessageExecutedLater(
52         static_cast<int>(P2P_STATE_MACHINE_CMD::EXCEPTION_TIMED_OUT), exceptionTimeOut);
53     hasConnect = false;
54 }
55 
Init()56 void P2pIdleState::Init()
57 {
58     mProcessFunMap.insert(
59         std::make_pair(P2P_STATE_MACHINE_CMD::CMD_STOP_DEVICE_DISCOVERS, &P2pIdleState::ProcessCmdStopDiscPeer));
60     mProcessFunMap.insert(std::make_pair(P2P_STATE_MACHINE_CMD::CMD_CONNECT, &P2pIdleState::ProcessCmdConnect));
61     mProcessFunMap.insert(
62         std::make_pair(P2P_STATE_MACHINE_CMD::P2P_EVENT_PROV_DISC_PBC_REQ, &P2pIdleState::ProcessProvDiscPbcReqEvt));
63     mProcessFunMap.insert(std::make_pair(
64         P2P_STATE_MACHINE_CMD::P2P_EVENT_PROV_DISC_ENTER_PIN, &P2pIdleState::ProcessProvDiscEnterPinEvt));
65     mProcessFunMap.insert(
66         std::make_pair(P2P_STATE_MACHINE_CMD::P2P_EVENT_GO_NEG_REQUEST, &P2pIdleState::ProcessNegotReqEvt));
67     mProcessFunMap.insert(
68         std::make_pair(P2P_STATE_MACHINE_CMD::P2P_EVENT_PROV_DISC_SHOW_PIN, &P2pIdleState::ProcessProvDiscShowPinEvt));
69     mProcessFunMap.insert(
70         std::make_pair(P2P_STATE_MACHINE_CMD::CMD_FORM_GROUP, &P2pIdleState::ProcessCmdCreateGroup));
71     mProcessFunMap.insert(
72         std::make_pair(P2P_STATE_MACHINE_CMD::CMD_REMOVE_GROUP, &P2pIdleState::ProcessCmdRemoveGroup));
73     mProcessFunMap.insert(
74         std::make_pair(P2P_STATE_MACHINE_CMD::CMD_DELETE_GROUP, &P2pIdleState::ProcessCmdDeleteGroup));
75     mProcessFunMap.insert(
76         std::make_pair(P2P_STATE_MACHINE_CMD::P2P_EVENT_GROUP_STARTED, &P2pIdleState::ProcessGroupStartedEvt));
77     mProcessFunMap.insert(std::make_pair(
78         P2P_STATE_MACHINE_CMD::P2P_EVENT_INVITATION_RECEIVED, &P2pIdleState::ProcessInvitationReceivedEvt));
79     mProcessFunMap.insert(std::make_pair(P2P_STATE_MACHINE_CMD::CMD_HID2D_CREATE_GROUP,
80         &P2pIdleState::ProcessCmdHid2dCreateGroup));
81     mProcessFunMap.insert(
82         std::make_pair(P2P_STATE_MACHINE_CMD::CMD_HID2D_CONNECT, &P2pIdleState::ProcessCmdHid2dConnect));
83     mProcessFunMap.insert(
84         std::make_pair(P2P_STATE_MACHINE_CMD::P2P_EVENT_IFACE_CREATED, &P2pIdleState::ProcessP2pIfaceCreatedEvt));
85     mProcessFunMap.insert(
86         std::make_pair(P2P_STATE_MACHINE_CMD::P2P_REMOVE_DEVICE, &P2pIdleState::ProcessRemoveDevice));
87     mProcessFunMap.insert(
88         std::make_pair(P2P_STATE_MACHINE_CMD::P2P_RETRY_CONNECT, &P2pIdleState::RetryConnect));
89     mProcessFunMap.insert(
90         std::make_pair(P2P_STATE_MACHINE_CMD::CMD_DISABLE_RANDOM_MAC, &P2pIdleState::ProcessCmdDisableRandomMac));
91 }
92 
ProcessCmdStopDiscPeer(InternalMessagePtr msg) const93 bool P2pIdleState::ProcessCmdStopDiscPeer(InternalMessagePtr msg) const
94 {
95     WIFI_LOGI("recv CMD: %{public}d", msg->GetMessageName());
96     WifiErrorNo retCode = WifiP2PHalInterface::GetInstance().P2pStopFind();
97     if (retCode == WifiErrorNo::WIFI_HAL_OPT_OK) {
98         retCode = WifiP2PHalInterface::GetInstance().P2pFlush();
99         if (retCode != WifiErrorNo::WIFI_HAL_OPT_OK) {
100             WIFI_LOGE("call P2pFlush() failed, ErrCode: %{public}d", static_cast<int>(retCode));
101         }
102         p2pStateMachine.serviceManager.SetQueryId(std::string(""));
103         p2pStateMachine.BroadcastActionResult(P2pActionCallback::StopDiscoverDevices, ErrCode::WIFI_OPT_SUCCESS);
104     } else {
105         p2pStateMachine.BroadcastActionResult(P2pActionCallback::StopDiscoverDevices, ErrCode::WIFI_OPT_FAILED);
106     }
107     return EXECUTED;
108 }
109 
ProcessRemoveDevice(InternalMessagePtr msg) const110 bool P2pIdleState::ProcessRemoveDevice(InternalMessagePtr msg) const
111 {
112     WIFI_LOGI("recv CMD: %{public}d", msg->GetMessageName());
113 #ifdef SUPPORT_RANDOM_MAC_ADDR
114     LOGI("remove all device");
115     WifiConfigCenter::GetInstance().ClearMacAddrPairs(WifiMacAddrInfoType::P2P_DEVICE_MACADDR_INFO);
116 #endif
117     return EXECUTED;
118 }
119 
RetryConnect(InternalMessagePtr msg) const120 bool P2pIdleState::RetryConnect(InternalMessagePtr msg) const
121 {
122     WIFI_LOGI("recv CMD: %{public}d",  msg->GetMessageName());
123     P2pConfigErrCode ret = p2pStateMachine.IsConfigUnusable(p2pStateMachine.savedP2pConfig);
124     if (ret != P2pConfigErrCode::SUCCESS) {
125         WIFI_LOGW("Invalid device information.");
126         if (ret == P2pConfigErrCode::MAC_NOT_FOUND) {
127             if (retryConnectCnt == RETRY_MAX_NUM) {
128                 retryConnectCnt = 0;
129                 p2pStateMachine.BroadcastActionResult(
130                     P2pActionCallback::P2pConnect, ErrCode::WIFI_OPT_P2P_MAC_NOT_FOUND);
131                 return EXECUTED;
132             }
133             p2pStateMachine.StartTimer(static_cast<int>(P2P_STATE_MACHINE_CMD::P2P_RETRY_CONNECT), RETRY_INTERVAL);
134             retryConnectCnt++;
135         }
136         return EXECUTED;
137     } else {
138         retryConnectCnt = 0;
139         if (WifiErrorNo::WIFI_HAL_OPT_OK != WifiP2PHalInterface::GetInstance().P2pStopFind()) {
140             WIFI_LOGE("Attempt to connect but cannot stop find");
141             p2pStateMachine.BroadcastActionResult(P2pActionCallback::P2pConnect, ErrCode::WIFI_OPT_FAILED);
142             return EXECUTED;
143         }
144 
145         if (p2pStateMachine.ReawakenPersistentGroup(p2pStateMachine.savedP2pConfig)) {
146             p2pStateMachine.SwitchState(&p2pStateMachine.p2pGroupNegotiationState);
147         } else {
148             p2pStateMachine.SwitchState(&p2pStateMachine.p2pProvisionDiscoveryState);
149         }
150 
151         deviceManager.UpdateDeviceStatus(
152             p2pStateMachine.savedP2pConfig.GetDeviceAddress(), P2pDeviceStatus::PDS_INVITED);
153         p2pStateMachine.BroadcastP2pPeersChanged();
154         p2pStateMachine.BroadcastActionResult(P2pActionCallback::P2pConnect, ErrCode::WIFI_OPT_SUCCESS);
155     }
156     return EXECUTED;
157 }
158 
ProcessCmdConnect(InternalMessagePtr msg) const159 bool P2pIdleState::ProcessCmdConnect(InternalMessagePtr msg) const
160 {
161     WifiP2pConfigInternal config;
162     retryConnectCnt = 0;
163     p2pStateMachine.StopTimer(static_cast<int>(P2P_STATE_MACHINE_CMD::P2P_RETRY_CONNECT));
164     if (!msg->GetMessageObj(config)) {
165         WIFI_LOGW("p2p connect Parameter error.");
166         p2pStateMachine.BroadcastActionResult(P2pActionCallback::P2pConnect, ErrCode::WIFI_OPT_INVALID_PARAM);
167         return EXECUTED;
168     }
169     p2pStateMachine.savedP2pConfig = config;
170 
171     P2pConfigErrCode ret = p2pStateMachine.IsConfigUnusable(p2pStateMachine.savedP2pConfig);
172     if (ret != P2pConfigErrCode::SUCCESS) {
173         WIFI_LOGW("Invalid device information.");
174         if (ret == P2pConfigErrCode::MAC_EMPTY) {
175             p2pStateMachine.BroadcastActionResult(P2pActionCallback::P2pConnect, ErrCode::WIFI_OPT_INVALID_PARAM);
176         } else if (ret == P2pConfigErrCode::MAC_NOT_FOUND) {
177             retryConnectCnt = 1;
178             p2pStateMachine.StartTimer(static_cast<int>(P2P_STATE_MACHINE_CMD::P2P_RETRY_CONNECT), RETRY_INTERVAL);
179         } else if (ret == P2pConfigErrCode::ERR_MAC_FORMAT) {
180             p2pStateMachine.BroadcastActionResult(P2pActionCallback::P2pConnect, ErrCode::WIFI_OPT_P2P_ERR_MAC_FORMAT);
181         } else if (ret == P2pConfigErrCode::ERR_INTENT) {
182             p2pStateMachine.BroadcastActionResult(P2pActionCallback::P2pConnect, ErrCode::WIFI_OPT_P2P_ERR_INTENT);
183         } else if (ret == P2pConfigErrCode::ERR_SIZE_NW_NAME) {
184             p2pStateMachine.BroadcastActionResult(
185                 P2pActionCallback::P2pConnect, ErrCode::WIFI_OPT_P2P_ERR_SIZE_NW_NAME);
186         }
187         return EXECUTED;
188     }
189 
190     p2pStateMachine.StopTimer(static_cast<int>(P2P_STATE_MACHINE_CMD::P2P_REMOVE_DEVICE));
191     if (WifiErrorNo::WIFI_HAL_OPT_OK != WifiP2PHalInterface::GetInstance().P2pStopFind()) {
192         WIFI_LOGE("Attempt to connect but cannot stop find");
193         p2pStateMachine.BroadcastActionResult(P2pActionCallback::P2pConnect, ErrCode::WIFI_OPT_FAILED);
194         return EXECUTED;
195     }
196     int callingUid = msg->GetParam1();
197     SharedLinkManager::SetGroupUid(callingUid);
198     if (p2pStateMachine.ReawakenPersistentGroup(p2pStateMachine.savedP2pConfig)) {
199         p2pStateMachine.SwitchState(&p2pStateMachine.p2pGroupNegotiationState);
200     } else {
201         p2pStateMachine.SwitchState(&p2pStateMachine.p2pProvisionDiscoveryState);
202     }
203     deviceManager.UpdateDeviceStatus(
204         p2pStateMachine.savedP2pConfig.GetDeviceAddress(), P2pDeviceStatus::PDS_INVITED);
205     p2pStateMachine.BroadcastP2pPeersChanged();
206     p2pStateMachine.BroadcastActionResult(P2pActionCallback::P2pConnect, ErrCode::WIFI_OPT_SUCCESS);
207 
208     return EXECUTED;
209 }
210 
ProcessCmdHid2dConnect(InternalMessagePtr msg) const211 bool P2pIdleState::ProcessCmdHid2dConnect(InternalMessagePtr msg) const
212 {
213     WIFI_LOGI("Idle state hid2d connect recv CMD: %{public}d", msg->GetMessageName());
214 
215     Hid2dConnectConfig config;
216     p2pStateMachine.StopTimer(static_cast<int>(P2P_STATE_MACHINE_CMD::P2P_REMOVE_DEVICE));
217     if (!msg->GetMessageObj(config)) {
218         WIFI_LOGE("Hid2d connect:Failed to obtain config info.");
219         return EXECUTED;
220     }
221 
222     if (!p2pStateMachine.p2pDevIface.empty()) {
223         WIFI_LOGE("Hid2d connect:exists dev iface %{public}s", p2pStateMachine.p2pDevIface.c_str());
224     }
225     if (WifiErrorNo::WIFI_HAL_OPT_OK !=
226         WifiP2PHalInterface::GetInstance().Hid2dConnect(config)) {
227         WIFI_LOGE("Hid2d Connection failed.");
228         p2pStateMachine.BroadcastActionResult(P2pActionCallback::Hid2dConnect, ErrCode::WIFI_OPT_FAILED);
229     }
230     int callingUid = msg->GetParam1();
231     SharedLinkManager::SetGroupUid(callingUid);
232     hasConnect = true;
233     return EXECUTED;
234 }
235 
ProcessProvDiscPbcReqEvt(InternalMessagePtr msg) const236 bool P2pIdleState::ProcessProvDiscPbcReqEvt(InternalMessagePtr msg) const
237 {
238     WIFI_LOGI("recv CMD: %{public}d", msg->GetMessageName());
239     return EXECUTED;
240 }
241 
ProcessProvDiscEnterPinEvt(InternalMessagePtr msg) const242 bool P2pIdleState::ProcessProvDiscEnterPinEvt(InternalMessagePtr msg) const
243 {
244     WIFI_LOGI("recv CMD: %{public}d", msg->GetMessageName());
245     return EXECUTED;
246 }
247 
ProcessNegotReqEvt(InternalMessagePtr msg) const248 bool P2pIdleState::ProcessNegotReqEvt(InternalMessagePtr msg) const
249 {
250     WifiP2pConfigInternal conf;
251     if (!msg->GetMessageObj(conf)) {
252         WIFI_LOGW("Failed to obtain conf.");
253         return EXECUTED;
254     }
255     p2pStateMachine.savedP2pConfig = conf;
256     p2pStateMachine.SwitchState(&p2pStateMachine.p2pAuthorizingNegotiationRequestState);
257     return EXECUTED;
258 }
259 
ProcessProvDiscShowPinEvt(InternalMessagePtr msg) const260 bool P2pIdleState::ProcessProvDiscShowPinEvt(InternalMessagePtr msg) const
261 {
262     WifiP2pTempDiscEvent provDisc;
263     if (!msg->GetMessageObj(provDisc)) {
264         WIFI_LOGW("Failed to obtain provDisc.");
265         return EXECUTED;
266     }
267     WifiP2pConfigInternal config;
268     WpsInfo wps;
269     wps.SetWpsMethod(WpsMethod::WPS_METHOD_KEYPAD);
270     wps.SetPin(provDisc.GetPin());
271     config.SetWpsInfo(wps);
272     config.SetDeviceAddress(provDisc.GetDevice().GetDeviceAddress());
273     p2pStateMachine.savedP2pConfig = config;
274 
275     p2pStateMachine.NotifyUserProvDiscShowPinRequestMessage(provDisc.GetPin(), config.GetDeviceAddress());
276     deviceManager.UpdateDeviceStatus(config.GetDeviceAddress(), P2pDeviceStatus::PDS_INVITED);
277     p2pStateMachine.BroadcastP2pPeersChanged();
278     p2pStateMachine.SwitchState(&p2pStateMachine.p2pAuthorizingNegotiationRequestState);
279     return EXECUTED;
280 }
281 
ProcessCmdCreateGroup(InternalMessagePtr msg) const282 bool P2pIdleState::ProcessCmdCreateGroup(InternalMessagePtr msg) const
283 {
284     p2pStateMachine.DelayMessage(msg);
285     p2pStateMachine.SwitchState(&p2pStateMachine.p2pGroupOperatingState);
286     return EXECUTED;
287 }
288 
ProcessCmdRemoveGroup(InternalMessagePtr msg) const289 bool P2pIdleState::ProcessCmdRemoveGroup(InternalMessagePtr msg) const
290 {
291     if (hasConnect == true) {
292         hasConnect = false;
293         p2pStateMachine.DelayMessage(msg);
294         p2pStateMachine.SwitchState(&p2pStateMachine.p2pGroupOperatingState);
295         return EXECUTED;
296     }
297     WIFI_LOGI("p2p ildeState no processing remove group! CMD: %{public}d", msg->GetMessageName());
298     return EXECUTED;
299 }
300 
ProcessCmdDeleteGroup(InternalMessagePtr msg) const301 bool P2pIdleState::ProcessCmdDeleteGroup(InternalMessagePtr msg) const
302 {
303     p2pStateMachine.DelayMessage(msg);
304     p2pStateMachine.SwitchState(&p2pStateMachine.p2pGroupOperatingState);
305     return EXECUTED;
306 }
307 
ProcessGroupStartedEvt(InternalMessagePtr msg) const308 bool P2pIdleState::ProcessGroupStartedEvt(InternalMessagePtr msg) const
309 {
310     hasConnect = false;
311     WifiP2pGroupInfo group;
312     msg->GetMessageObj(group);
313     WIFI_LOGI("P2P_EVENT_GROUP_STARTED create group interface name : %{private}s, network name : %{private}s, owner "
314               "address : %{private}s",
315         group.GetInterface().c_str(), group.GetGroupName().c_str(), group.GetOwner().GetDeviceAddress().c_str());
316     if (group.IsPersistent()) {
317         /**
318          * Update groups.
319          */
320         p2pStateMachine.UpdateGroupManager();
321         group.SetNetworkId(groupManager.GetGroupNetworkId(group.GetOwner(), group.GetGroupName()));
322         WIFI_LOGI("the group network id is %{public}d set id is %{public}d",
323             group.GetNetworkId(), groupManager.GetGroupNetworkId(group.GetOwner(), group.GetGroupName()));
324         p2pStateMachine.UpdatePersistentGroups();
325     }
326     group.SetP2pGroupStatus(P2pGroupStatus::GS_STARTED);
327     group.SetCreatorUid(WifiConfigCenter::GetInstance().GetP2pCreatorUid());
328     WifiConfigCenter::GetInstance().SaveP2pCreatorUid(-1);
329     p2pStateMachine.groupManager.SetCurrentGroup(WifiMacAddrInfoType::P2P_CURRENT_GROUP_MACADDR_INFO, group);
330     if (!p2pStateMachine.groupManager.GetCurrentGroup().IsGroupOwner()) {
331         p2pStateMachine.StartDhcpClientInterface();
332 
333         const WifiP2pDevice &owner = groupManager.GetCurrentGroup().GetOwner();
334         WifiP2pDevice device = deviceManager.GetDevices(owner.GetDeviceAddress());
335         if (device.IsValid()) {
336             device.SetP2pDeviceStatus(owner.GetP2pDeviceStatus());
337             WifiP2pGroupInfo copy = groupManager.GetCurrentGroup();
338             copy.SetOwner(device);
339             groupManager.SetCurrentGroup(WifiMacAddrInfoType::P2P_CURRENT_GROUP_MACADDR_INFO, copy);
340 
341             deviceManager.UpdateDeviceStatus(owner.GetDeviceAddress(), P2pDeviceStatus::PDS_CONNECTED);
342 
343             p2pStateMachine.BroadcastP2pPeersChanged();
344         } else {
345             WIFI_LOGW("fail:No GO device information is found.");
346         }
347     } else {
348         WifiP2pGroupInfo currGrp = p2pStateMachine.groupManager.GetCurrentGroup();
349         WifiP2pDevice owner = currGrp.GetOwner();
350         owner.SetDeviceName(deviceManager.GetThisDevice().GetDeviceName());
351         currGrp.SetOwner(owner);
352         p2pStateMachine.groupManager.SetCurrentGroup(WifiMacAddrInfoType::P2P_CURRENT_GROUP_MACADDR_INFO, currGrp);
353         if (!p2pStateMachine.StartDhcpServer()) {
354             WIFI_LOGE("Failed to start dhcp server.");
355             p2pStateMachine.SendMessage(static_cast<int>(P2P_STATE_MACHINE_CMD::CMD_REMOVE_GROUP));
356             return EXECUTED;
357         }
358     }
359     SharedLinkManager::IncreaseSharedLink();
360     if (WifiP2PHalInterface::GetInstance().SetP2pPowerSave(group.GetInterface(), true) != WIFI_HAL_OPT_OK) {
361         WIFI_LOGE("SetP2pPowerSave() failed!");
362     }
363 
364     p2pStateMachine.ChangeConnectedStatus(P2pConnectedState::P2P_CONNECTED);
365     p2pStateMachine.SwitchState(&p2pStateMachine.p2pGroupFormedState);
366     return EXECUTED;
367 }
368 
ProcessInvitationReceivedEvt(InternalMessagePtr msg) const369 bool P2pIdleState::ProcessInvitationReceivedEvt(InternalMessagePtr msg) const
370 {
371     WifiP2pGroupInfo group;
372     if (!msg->GetMessageObj(group)) {
373         WIFI_LOGW("p2p invitation received: Parameter error.");
374         return EXECUTED;
375     }
376     const WifiP2pDevice &owner = group.GetOwner();
377     if (!owner.IsValid()) {
378         int networkId = group.GetNetworkId();
379         if (networkId < 0) {
380             WIFI_LOGE("Ignore Invalid Invitation");
381             return EXECUTED;
382         }
383         const std::string &ownerAddress = groupManager.GetGroupOwnerAddr(networkId);
384         if (ownerAddress.empty()) {
385             WIFI_LOGE("Ignore Invalid Invitation");
386             return EXECUTED;
387         } else {
388             WifiP2pDevice device;
389             device.SetDeviceAddress(ownerAddress);
390             group.SetOwner(device);
391         }
392     }
393 
394     WifiP2pDevice device;
395     if (WifiErrorNo::WIFI_HAL_OPT_OK !=
396         WifiP2PHalInterface::GetInstance().GetP2pPeer(owner.GetDeviceAddress(), device)) {
397         WIFI_LOGW("Failed to get the peer information.");
398     } else {
399         deviceManager.UpdateDeviceSupplicantInf(device);
400     }
401 
402     const WifiP2pDevice peer = deviceManager.GetDevices(owner.GetDeviceAddress());
403     if (!peer.IsValid()) {
404         WIFI_LOGE("Failed to obtain valid device information.");
405         return EXECUTED;
406     }
407     // update the group capabilitys.
408     deviceManager.UpdateDeviceGroupCap(peer.GetDeviceAddress(), static_cast<size_t>(peer.GetGroupCapabilitys()) | 0x01);
409 
410     WpsInfo wps;
411     if (peer.WpsPbcSupported()) {
412         wps.SetWpsMethod(WpsMethod::WPS_METHOD_PBC);
413     } else if (peer.WpsDisplaySupported()) {
414         wps.SetWpsMethod(WpsMethod::WPS_METHOD_DISPLAY);
415     } else if (peer.WpKeypadSupported()) {
416         wps.SetWpsMethod(WpsMethod::WPS_METHOD_KEYPAD);
417     }
418 
419     WifiP2pConfigInternal config;
420     config.SetDeviceAddress(owner.GetDeviceAddress());
421     config.SetWpsInfo(wps);
422     config.SetNetId(group.GetNetworkId());
423     groupManager.AddOrUpdateGroup(group);
424     p2pStateMachine.savedP2pConfig = config;
425 
426     p2pStateMachine.SwitchState(&p2pStateMachine.p2pInvitationReceivedState);
427     return EXECUTED;
428 }
429 
ProcessCmdHid2dCreateGroup(InternalMessagePtr msg) const430 bool P2pIdleState::ProcessCmdHid2dCreateGroup(InternalMessagePtr msg) const
431 {
432     p2pStateMachine.DelayMessage(msg);
433     p2pStateMachine.SwitchState(&p2pStateMachine.p2pGroupOperatingState);
434     return EXECUTED;
435 }
436 
ProcessP2pIfaceCreatedEvt(InternalMessagePtr msg) const437 bool P2pIdleState::ProcessP2pIfaceCreatedEvt(InternalMessagePtr msg) const
438 {
439     if (msg->GetParam1() != 0) {
440         WIFI_LOGE("p2p interface created event receive: type error.");
441         return EXECUTED;
442     }
443 
444     std::string ifName;
445     if (!msg->GetMessageObj(ifName)) {
446         WIFI_LOGE("p2p interface created event receive: Parameter error.");
447         return EXECUTED;
448     }
449     p2pStateMachine.p2pDevIface = ifName;
450     p2pStateMachine.SwitchState(&p2pStateMachine.p2pGroupNegotiationState);
451     return EXECUTED;
452 }
453 
ExecuteStateMsg(InternalMessagePtr msg)454 bool P2pIdleState::ExecuteStateMsg(InternalMessagePtr msg)
455 {
456     if (msg == nullptr) {
457         WIFI_LOGE("fatal error!");
458         return NOT_EXECUTED;
459     }
460     int msgName = msg->GetMessageName();
461     auto iter = mProcessFunMap.find(static_cast<P2P_STATE_MACHINE_CMD>(msgName));
462     if (iter == mProcessFunMap.end()) {
463         return NOT_EXECUTED;
464     }
465     if ((this->*(iter->second))(msg)) {
466         return EXECUTED;
467     } else {
468         return NOT_EXECUTED;
469     }
470 }
471 
ProcessCmdDisableRandomMac(InternalMessagePtr msg) const472 bool P2pIdleState::ProcessCmdDisableRandomMac(InternalMessagePtr msg) const
473 {
474     const int setmode = msg->GetParam1();
475     p2pStateMachine.HandlerDisableRandomMac(setmode);
476     return EXECUTED;
477 }
478 }  // namespace Wifi
479 }  // namespace OHOS
480