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 <cinttypes>
17 #include "state_machine.h"
18 #include "wifi_log.h"
19
20 #undef LOG_TAG
21 #define LOG_TAG "OHWIFI_STATE_MACHINE"
22
23 namespace OHOS {
24 namespace Wifi {
25 static const int SM_INIT_CMD = -2;
StateMachine(const std::string & name)26 StateMachine::StateMachine(const std::string &name) : pStateMachineHandler(nullptr), mStateName(name)
27 {}
28
~StateMachine()29 StateMachine::~StateMachine()
30 {
31 LOGD("StateMachine::~StateMachine");
32 if (pStateMachineHandler != nullptr) {
33 delete pStateMachineHandler;
34 pStateMachineHandler = nullptr;
35 }
36 }
37
InitialStateMachine()38 bool StateMachine::InitialStateMachine()
39 {
40 LOGI("InitialStateMachine\n");
41 pStateMachineHandler = new (std::nothrow) StateMachineHandler(this);
42 if (pStateMachineHandler == nullptr) {
43 LOGE("pStateMachineHandler alloc failed.\n");
44 return false;
45 }
46
47 if (!pStateMachineHandler->InitialSmHandler()) {
48 LOGE("InitialStateMachineHandler failed.\n");
49 return false;
50 }
51
52 return true;
53 }
54
StartStateMachine()55 void StateMachine::StartStateMachine()
56 {
57 if (pStateMachineHandler == nullptr) {
58 LOGE("Start StateMachine failed, pStateMachineHandler is nullptr!");
59 return;
60 }
61
62 pStateMachineHandler->BuildTreeComplete();
63 return;
64 }
65
SetHandler(StateMachineHandler * handler)66 void StateMachine::SetHandler(StateMachineHandler *handler)
67 {
68 pStateMachineHandler = handler;
69 }
70
NotExecutedMessage(const InternalMessage * msg)71 void StateMachine::NotExecutedMessage(const InternalMessage *msg)
72 {
73 if (msg == nullptr) {
74 return;
75 }
76 LOGD("msg not handled msg:%{public}d", msg->GetMessageName());
77 }
78
StatePlus(State * state,State * upper)79 void StateMachine::StatePlus(State *state, State *upper)
80 {
81 if (pStateMachineHandler == nullptr) {
82 LOGE("Start StateMachine failed, pStateMachineHandler is nullptr!");
83 return;
84 }
85
86 pStateMachineHandler->StatePlus(state, upper);
87 }
88
StateDelete(State * state)89 void StateMachine::StateDelete(State *state)
90 {
91 if (pStateMachineHandler == nullptr) {
92 LOGE("Start StateMachine failed, pStateMachineHandler is nullptr!");
93 return;
94 }
95
96 pStateMachineHandler->StateDelete(state);
97 }
98
SetFirstState(State * firstState)99 void StateMachine::SetFirstState(State *firstState)
100 {
101 if (pStateMachineHandler == nullptr) {
102 LOGE("Start StateMachine failed, pStateMachineHandler is nullptr!");
103 return;
104 }
105
106 pStateMachineHandler->SetFirstState(firstState);
107 }
108
SwitchState(State * targetState)109 void StateMachine::SwitchState(State *targetState)
110 {
111 if (pStateMachineHandler == nullptr) {
112 LOGE("Start StateMachine failed, pStateMachineHandler is nullptr!");
113 return;
114 }
115
116 pStateMachineHandler->SwitchState(targetState);
117 }
118
DelayMessage(const InternalMessage * msg)119 void StateMachine::DelayMessage(const InternalMessage *msg)
120 {
121 if (pStateMachineHandler == nullptr) {
122 LOGE("Start StateMachine failed, pStateMachineHandler is nullptr!");
123 return;
124 }
125
126 pStateMachineHandler->DelayMessage(msg);
127 }
128
StopHandlerThread()129 void StateMachine::StopHandlerThread()
130 {
131 if (pStateMachineHandler == nullptr) {
132 LOGE("Start StateMachine failed, pStateMachineHandler is nullptr!");
133 return;
134 }
135 pStateMachineHandler->StopHandlerThread();
136 }
137
CreateMessage()138 InternalMessage *StateMachine::CreateMessage()
139 {
140 return MessageManage::GetInstance().CreateMessage();
141 }
142
CreateMessage(const InternalMessage * orig)143 InternalMessage *StateMachine::CreateMessage(const InternalMessage *orig)
144 {
145 if (orig == nullptr) {
146 return nullptr;
147 }
148 return MessageManage::GetInstance().CreateMessage(orig);
149 }
150
CreateMessage(int msgName)151 InternalMessage *StateMachine::CreateMessage(int msgName)
152 {
153 return MessageManage::GetInstance().CreateMessage(msgName);
154 }
155
CreateMessage(int msgName,int param1)156 InternalMessage *StateMachine::CreateMessage(int msgName, int param1)
157 {
158 return MessageManage::GetInstance().CreateMessage(msgName, param1, 0);
159 }
160
CreateMessage(int msgName,int param1,int param2)161 InternalMessage *StateMachine::CreateMessage(int msgName, int param1, int param2)
162 {
163 return MessageManage::GetInstance().CreateMessage(msgName, param1, param2);
164 }
165
CreateMessage(int msgName,const std::any & messageObj)166 InternalMessage *StateMachine::CreateMessage(int msgName, const std::any &messageObj)
167 {
168 return MessageManage::GetInstance().CreateMessage(msgName, messageObj);
169 }
170
CreateMessage(int msgName,int param1,int param2,const std::any & messageObj)171 InternalMessage *StateMachine::CreateMessage(int msgName, int param1, int param2, const std::any &messageObj)
172 {
173 return MessageManage::GetInstance().CreateMessage(msgName, param1, param2, messageObj);
174 }
175
SendMessage(int msgName)176 void StateMachine::SendMessage(int msgName)
177 {
178 pStateMachineHandler->SendMessage(CreateMessage(msgName));
179 return;
180 }
181
SendMessage(int msgName,int param1)182 void StateMachine::SendMessage(int msgName, int param1)
183 {
184 pStateMachineHandler->SendMessage(CreateMessage(msgName, param1));
185 return;
186 }
187
SendMessage(int msgName,int param1,int param2)188 void StateMachine::SendMessage(int msgName, int param1, int param2)
189 {
190 pStateMachineHandler->SendMessage(CreateMessage(msgName, param1, param2));
191 return;
192 }
193
SendMessage(InternalMessage * msg)194 void StateMachine::SendMessage(InternalMessage *msg)
195 {
196 if (msg == nullptr) {
197 return;
198 }
199 pStateMachineHandler->SendMessage(msg);
200 return;
201 }
202
SendMessage(int msgName,const std::any & messageObj)203 void StateMachine::SendMessage(int msgName, const std::any &messageObj)
204 {
205 pStateMachineHandler->SendMessage(CreateMessage(msgName, messageObj));
206 return;
207 }
208
SendMessage(int msgName,int param1,int param2,const std::any & messageObj)209 void StateMachine::SendMessage(int msgName, int param1, int param2, const std::any &messageObj)
210 {
211 pStateMachineHandler->SendMessage(CreateMessage(msgName, param1, param2, messageObj));
212 return;
213 }
214
MessageExecutedLater(int msgName,int64_t delayTimeMs)215 void StateMachine::MessageExecutedLater(int msgName, int64_t delayTimeMs)
216 {
217 pStateMachineHandler->MessageExecutedLater(CreateMessage(msgName), delayTimeMs);
218 return;
219 }
220
MessageExecutedLater(int msgName,int param1,int64_t delayTimeMs)221 void StateMachine::MessageExecutedLater(int msgName, int param1, int64_t delayTimeMs)
222 {
223 pStateMachineHandler->MessageExecutedLater(CreateMessage(msgName, param1), delayTimeMs);
224 return;
225 }
226
MessageExecutedLater(int msgName,int param1,int param2,int64_t delayTimeMs)227 void StateMachine::MessageExecutedLater(int msgName, int param1, int param2, int64_t delayTimeMs)
228 {
229 pStateMachineHandler->MessageExecutedLater(CreateMessage(msgName, param1, param2), delayTimeMs);
230 return;
231 }
232
MessageExecutedLater(InternalMessage * msg,int64_t delayTimeMs)233 void StateMachine::MessageExecutedLater(InternalMessage *msg, int64_t delayTimeMs)
234 {
235 pStateMachineHandler->MessageExecutedLater(msg, delayTimeMs);
236 return;
237 }
238
MessageExecutedLater(int msgName,const std::any & messageObj,int64_t delayTimeMs)239 void StateMachine::MessageExecutedLater(int msgName, const std::any &messageObj, int64_t delayTimeMs)
240 {
241 pStateMachineHandler->MessageExecutedLater(CreateMessage(msgName, messageObj), delayTimeMs);
242 return;
243 }
244
MessageExecutedLater(int msgName,int param1,int param2,const std::any & messageObj,int64_t delayTimeMs)245 void StateMachine::MessageExecutedLater(
246 int msgName, int param1, int param2, const std::any &messageObj, int64_t delayTimeMs)
247 {
248 pStateMachineHandler->MessageExecutedLater(CreateMessage(msgName, param1, param2, messageObj), delayTimeMs);
249 return;
250 }
251
StartTimer(int timerName,int64_t interval)252 void StateMachine::StartTimer(int timerName, int64_t interval)
253 {
254 LOGD("Enter StateMachine::StartTimer, timerName is %{public}d, interval is %" PRIu64 ".", timerName, interval);
255 MessageExecutedLater(timerName, interval);
256 return;
257 }
258
StopTimer(int timerName)259 void StateMachine::StopTimer(int timerName)
260 {
261 LOGD("Enter StateMachine::StopTimer, timerName is %{public}d.", timerName);
262 pStateMachineHandler->DeleteMessageFromQueue(timerName);
263 return;
264 }
265
StateMachineHandler(StateMachine * pStateMgr)266 StateMachineHandler::StateMachineHandler(StateMachine *pStateMgr)
267 {
268 mStateInfoMap.clear();
269 mStateVector.clear();
270 mStateVectorTopIndex = -1;
271 mSequenceStateVector.clear();
272 mSequenceStateVectorCount = 0;
273 mDelayedMessages.clear();
274 pStateMachine = pStateMgr;
275 pFirstState = nullptr;
276 pTargetState = nullptr;
277 mQuitFlag = false;
278 mBuildCompleteFlag = false;
279 mSwitchingStateFlag = false;
280 pCurrentMsg = nullptr;
281 }
282
~StateMachineHandler()283 StateMachineHandler::~StateMachineHandler()
284 {
285 LOGI("StateMachineHandler::~StateMachineHandler");
286 StopHandlerThread();
287 ReleaseDelayedMessages();
288 ClearWhenQuit();
289 return;
290 }
291
InitialSmHandler()292 bool StateMachineHandler::InitialSmHandler()
293 {
294 if (!InitialHandler()) {
295 LOGE("InitialHandler failed.");
296 return false;
297 }
298 return true;
299 }
300
StatePlus(State * state,State * upper)301 StateInfo *StateMachineHandler::StatePlus(State *state, State *upper)
302 {
303 LOGD("Enter StateMachineHandler::StatePlus function.");
304
305 StateInfo *upperStateInfo = nullptr;
306 StateInfoMap::iterator it = mStateInfoMap.begin();
307 if (upper != nullptr) {
308 it = mStateInfoMap.find(upper->GetStateName());
309 if (it != mStateInfoMap.end()) {
310 upperStateInfo = it->second;
311 }
312 if (upperStateInfo == nullptr) {
313 LOGD("upperStateInfo is null, add upper first. upper->GetStateName():%{public}s",
314 upper->GetStateName().c_str());
315 /* Recursively add our upper as it's not been added yet. */
316 StatePlus(upper, nullptr);
317 } else {
318 LOGD("upperStateInfo is not null, go on.");
319 }
320 }
321
322 StateInfo *stateInfo = nullptr;
323 it = mStateInfoMap.find(state->GetStateName());
324 if (it != mStateInfoMap.end()) {
325 stateInfo = it->second;
326 }
327 if (stateInfo == nullptr) {
328 stateInfo = new (std::nothrow) StateInfo();
329 if (stateInfo == nullptr) {
330 LOGE("failed to new StateInfo!");
331 return nullptr;
332 }
333 mStateInfoMap.insert(StateInfoMap::value_type(state->GetStateName(), stateInfo));
334 }
335
336 /* Validate that we aren't adding the same state in two different hierarchies. */
337 if (stateInfo->upperStateInfo != nullptr && stateInfo->upperStateInfo != upperStateInfo) {
338 LOGE("The same state cannot be added to two different hierarchies!");
339 }
340
341 stateInfo->state = state;
342 stateInfo->upperStateInfo = upperStateInfo;
343 stateInfo->active = false;
344
345 LOGD("successfully added a new state!");
346
347 return stateInfo;
348 }
349
StateDelete(State * state)350 void StateMachineHandler::StateDelete(State *state)
351 {
352 StateInfoMap::iterator it = mStateInfoMap.find(state->GetStateName());
353 StateInfo *stateInfo = nullptr;
354 if (it != mStateInfoMap.end()) {
355 stateInfo = it->second;
356 }
357 if (stateInfo == nullptr || stateInfo->active) {
358 return;
359 }
360
361 it = mStateInfoMap.begin();
362 while (it != mStateInfoMap.end()) {
363 if (it->second->upperStateInfo == stateInfo) {
364 return;
365 }
366 ++it;
367 }
368
369 it = mStateInfoMap.find(state->GetStateName());
370 if (it != mStateInfoMap.end()) {
371 delete it->second;
372 it->second = nullptr;
373 mStateInfoMap.erase(it);
374 }
375 }
376
SetFirstState(State * firstState)377 void StateMachineHandler::SetFirstState(State *firstState)
378 {
379 pFirstState = firstState;
380 }
381
BuildTreeComplete()382 void StateMachineHandler::BuildTreeComplete()
383 {
384 /* Determines the maximum depth of the state hierarchy. */
385 int maxDepth = 0;
386 StateInfoMap::iterator it = mStateInfoMap.begin();
387 while (it != mStateInfoMap.end()) {
388 int depth = 0;
389 StateInfo *tempStateInfo = it->second;
390 while (tempStateInfo != nullptr) {
391 depth++;
392 tempStateInfo = tempStateInfo->upperStateInfo;
393 }
394
395 if (maxDepth < depth) {
396 maxDepth = depth;
397 }
398
399 ++it;
400 }
401
402 LOGD("StateMachineHandler::BuildTreeComplete, maxDepth:%{public}d", maxDepth);
403 mStateVector.resize(maxDepth);
404 mSequenceStateVector.resize(maxDepth);
405 BuildStateInitVector();
406 MessageExecutedAtTime(pStateMachine->CreateMessage(SM_INIT_CMD), 0);
407 return;
408 }
409
BuildStateInitVector()410 void StateMachineHandler::BuildStateInitVector()
411 {
412 LOGD("StateMachineHandler::BuildStateInitVector");
413
414 if (pFirstState == nullptr) {
415 LOGE("StateMachineHandler::BuildStateInitVector please set initial state first!");
416 return;
417 }
418
419 StateInfoMap::iterator it = mStateInfoMap.find(pFirstState->GetStateName());
420 StateInfo *startStateInfo = nullptr;
421 if (it != mStateInfoMap.end()) {
422 startStateInfo = it->second;
423 }
424
425 for (mSequenceStateVectorCount = 0; startStateInfo != nullptr; mSequenceStateVectorCount++) {
426 mSequenceStateVector[mSequenceStateVectorCount] = startStateInfo;
427 startStateInfo = startStateInfo->upperStateInfo;
428 }
429
430 /* Clearing the StateVector. */
431 mStateVectorTopIndex = -1;
432 MoveSequenceToStateVector();
433 }
434
BuildSequenceStateVector(State * targetState)435 StateInfo *StateMachineHandler::BuildSequenceStateVector(State *targetState)
436 {
437 mSequenceStateVectorCount = 0;
438 StateInfoMap::iterator it = mStateInfoMap.find(targetState->GetStateName());
439 StateInfo *curStateInfo = nullptr;
440 if (it != mStateInfoMap.end()) {
441 curStateInfo = it->second;
442 }
443
444 if (curStateInfo == nullptr) {
445 return nullptr;
446 }
447
448 do {
449 mSequenceStateVector[mSequenceStateVectorCount++] = curStateInfo;
450 curStateInfo = curStateInfo->upperStateInfo;
451 } while ((curStateInfo != nullptr) && (!curStateInfo->active));
452
453 return curStateInfo;
454 }
455
PlaceDelayedMsgQueueTop()456 void StateMachineHandler::PlaceDelayedMsgQueueTop()
457 {
458 LOGD("Enter StateMachineHandler::PlaceDelayedMsgQueueTop.");
459
460 for (int i = mDelayedMessages.size() - 1; i >= 0; i--) {
461 InternalMessage *curMsg = mDelayedMessages[i];
462 if (curMsg == nullptr) {
463 LOGE("StateMachineHandler::PlaceDelayedMsgQueueTop: curMsg is null.");
464 continue;
465 }
466 PlaceMessageTopOfQueue(curMsg);
467 }
468 mDelayedMessages.clear();
469
470 return;
471 }
472
ReleaseDelayedMessages()473 void StateMachineHandler::ReleaseDelayedMessages()
474 {
475 for (int i = mDelayedMessages.size() - 1; i >= 0; i--) {
476 InternalMessage *curMsg = mDelayedMessages[i];
477 if (curMsg != nullptr) {
478 delete curMsg;
479 curMsg = nullptr;
480 }
481 }
482 mDelayedMessages.clear();
483
484 return;
485 }
486
MoveSequenceToStateVector()487 int StateMachineHandler::MoveSequenceToStateVector()
488 {
489 LOGD("StateMachineHandler::MoveSequenceToStateVector mSequenceStateVectorCount:%{public}d",
490 mSequenceStateVectorCount);
491
492 int newIndex = mStateVectorTopIndex + 1;
493 int i = mSequenceStateVectorCount - 1;
494 int j = newIndex;
495 while (i >= 0) {
496 mStateVector[j] = mSequenceStateVector[i];
497 j += 1;
498 i -= 1;
499 }
500
501 mStateVectorTopIndex = j - 1;
502 return newIndex;
503 }
504
SwitchState(State * targetState)505 void StateMachineHandler::SwitchState(State *targetState)
506 {
507 if (targetState == nullptr) {
508 LOGE("targetState is null.");
509 return;
510 }
511 LOGE("SwitchState, Switch to targetState: %{public}s.", targetState->GetStateName().c_str());
512 pTargetState = static_cast<State *>(targetState);
513 }
514
ClearWhenQuit()515 void StateMachineHandler::ClearWhenQuit()
516 {
517 pStateMachine->SetHandler(nullptr);
518 pStateMachine = nullptr;
519 pCurrentMsg = nullptr;
520 mStateVector.clear();
521 mSequenceStateVector.clear();
522 mDelayedMessages.clear();
523 pFirstState = nullptr;
524 pTargetState = nullptr;
525 mQuitFlag = true;
526
527 StateInfoMap::iterator it = mStateInfoMap.begin();
528 while (it != mStateInfoMap.end()) {
529 delete it->second;
530 it->second = nullptr;
531 it = mStateInfoMap.erase(it);
532 }
533 mStateInfoMap.clear();
534 }
535
PerformSwitchState(State * msgProcessedState,InternalMessage * msg)536 void StateMachineHandler::PerformSwitchState(State *msgProcessedState, InternalMessage *msg)
537 {
538 if (msgProcessedState == nullptr || msg == nullptr) {
539 LOGE("pointer is null.");
540 }
541
542 State *targetState = pTargetState;
543 if (targetState != nullptr) {
544 if (pFirstState != nullptr) {
545 LOGI("StateMachineHandler::PerformSwitchState, Switch %{public}s -->> %{public}s",
546 pFirstState->GetStateName().c_str(), targetState->GetStateName().c_str());
547 }
548 while (true) {
549 StateInfo *commonStateInfo = BuildSequenceStateVector(targetState);
550 mSwitchingStateFlag = true;
551 CallTreeStateExits(commonStateInfo);
552
553 int stateListEnteringIndex = MoveSequenceToStateVector();
554 CallTreeStateEnters(stateListEnteringIndex);
555
556 PlaceDelayedMsgQueueTop();
557
558 if (targetState != pTargetState) {
559 targetState = pTargetState;
560 } else {
561 break;
562 }
563 }
564 pTargetState = nullptr;
565 }
566
567 return;
568 }
569
ExecuteMessage(InternalMessage * msg)570 void StateMachineHandler::ExecuteMessage(InternalMessage *msg)
571 {
572 if (msg == nullptr) {
573 return;
574 }
575 if (!mQuitFlag) {
576 if (pStateMachine != nullptr && msg->GetMessageName() != SM_INIT_CMD) {
577 }
578
579 pCurrentMsg = msg;
580
581 State *msgProcessedState = nullptr;
582 if (mBuildCompleteFlag) {
583 LOGD("StateMachineHandler::ExecuteMessage ExecuteTreeStateMsg!");
584 msgProcessedState = ExecuteTreeStateMsg(msg);
585 } else if (!mBuildCompleteFlag && msg->GetMessageName() == SM_INIT_CMD) {
586 LOGD("StateMachineHandler::ExecuteMessage msg: SM_INIT_CMD");
587 mBuildCompleteFlag = true;
588 CallTreeStateEnters(0);
589 } else {
590 LOGE("The start method not called!");
591 }
592
593 if (pStateMachine != nullptr) {
594 PerformSwitchState(msgProcessedState, msg);
595 } else {
596 LOGE("pointer is null.");
597 }
598
599 if (pStateMachine != nullptr && msg->GetMessageName() != SM_INIT_CMD) {
600 }
601 }
602
603 return;
604 }
605
DelayMessage(const InternalMessage * msg)606 void StateMachineHandler::DelayMessage(const InternalMessage *msg)
607 {
608 LOGD("Enter StateMachineHandler::DelayMessage.");
609 if (msg == nullptr) {
610 return;
611 }
612
613 InternalMessage *newMsg = pStateMachine->CreateMessage(msg);
614 if (newMsg == nullptr) {
615 LOGE("StateMachineHandler::DelayMessage: newMsg is null.");
616 return;
617 }
618 mDelayedMessages.push_back(newMsg);
619 return;
620 }
621
ExecuteTreeStateMsg(InternalMessage * msg)622 State *StateMachineHandler::ExecuteTreeStateMsg(InternalMessage *msg)
623 {
624 LOGD("StateMachineHandler::ExecuteTreeStateMsg mStateVectorTopIndex:%{public}d", mStateVectorTopIndex);
625 if (msg == nullptr) {
626 return nullptr;
627 }
628
629 StateInfo *curStateInfo = mStateVector[mStateVectorTopIndex];
630 if (curStateInfo == nullptr) {
631 LOGE("StateInfo is null.");
632 return nullptr;
633 }
634
635 if (curStateInfo->state) {
636 LOGI("State machine: %{public}s execute Cmd:%{public}d",
637 curStateInfo->state->GetStateName().c_str(), msg->GetMessageName());
638 }
639
640 while (curStateInfo->state && (!curStateInfo->state->ExecuteStateMsg(msg))) {
641 curStateInfo = curStateInfo->upperStateInfo;
642
643 if (curStateInfo == nullptr) {
644 pStateMachine->NotExecutedMessage(msg);
645 break;
646 }
647 }
648
649 return (curStateInfo != nullptr) ? curStateInfo->state : nullptr;
650 }
651
CallTreeStateExits(StateInfo * commonStateInfo)652 void StateMachineHandler::CallTreeStateExits(StateInfo *commonStateInfo)
653 {
654 while ((mStateVectorTopIndex >= 0) && (mStateVector[mStateVectorTopIndex] != commonStateInfo)) {
655 if (mStateVector[mStateVectorTopIndex] != nullptr) {
656 State *curState = mStateVector[mStateVectorTopIndex]->state;
657 if (curState != nullptr) {
658 curState->GoOutState();
659 }
660 mStateVector[mStateVectorTopIndex]->active = false;
661 }
662 mStateVectorTopIndex -= 1;
663 }
664 }
665
CallTreeStateEnters(int index)666 void StateMachineHandler::CallTreeStateEnters(int index)
667 {
668 for (int i = index; i <= mStateVectorTopIndex; i++) {
669 if (index == mStateVectorTopIndex) {
670 /* Last enter state for transition. */
671 mSwitchingStateFlag = false;
672 }
673 LOGD("StateMachineHandler::CallTreeStateEnters mStateVectorTopIndex:%{public}d, i: %{public}d",
674 mStateVectorTopIndex,
675 i);
676 if (mStateVector[i] != nullptr && mStateVector[i]->state != nullptr) {
677 mStateVector[i]->state->GoInState();
678 mStateVector[i]->active = true;
679 }
680 }
681 /* ensure flag set to false if no methods called. */
682 mSwitchingStateFlag = false;
683 }
684 } // namespace Wifi
685 } // namespace OHOS
686