mirror of
https://gitee.com/jiuyilian/embedded-framework.git
synced 2025-01-06 10:16:51 -05:00
521 lines
15 KiB
C++
521 lines
15 KiB
C++
/*
|
|
* Copyright (C) 2021 Huawei Device Co., Ltd.
|
|
* Licensed under the Apache License, Version 2.0 (the "License");
|
|
* you may not use this file except in compliance with the License.
|
|
* You may obtain a copy of the License at
|
|
*
|
|
* http://www.apache.org/licenses/LICENSE-2.0
|
|
*
|
|
* Unless required by applicable law or agreed to in writing, software
|
|
* distributed under the License is distributed on an "AS IS" BASIS,
|
|
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
* See the License for the specific language governing permissions and
|
|
* limitations under the License.
|
|
*/
|
|
|
|
#ifndef OHOS_STA_MACHINE_H
|
|
#define OHOS_STA_MACHINE_H
|
|
|
|
#include "IStateMachine.h"
|
|
#include "handler.h"
|
|
#include "message_queue.h"
|
|
#include <map>
|
|
#include <string>
|
|
#include <vector>
|
|
|
|
// namespace OHOS {
|
|
// namespace Wifi {
|
|
#define CMD_SET_OPERATIONAL_MODE 1
|
|
|
|
class StateMachineHandler;
|
|
class StateMachine : public VStateMachineHandle
|
|
{
|
|
public:
|
|
/**
|
|
* @Description : StateMachine Initialization Function
|
|
*
|
|
* @return true :success, false : failed.
|
|
*/
|
|
bool InitialStateMachine() override;
|
|
|
|
/**
|
|
* @Description : Start StateMachine.
|
|
*
|
|
*/
|
|
void StartStateMachine() override;
|
|
|
|
/**
|
|
* @Description : Set Handler.
|
|
*
|
|
* @param handler - StateMachineHandler instance.[in]
|
|
*/
|
|
void SetHandler(StateMachineHandler *handler);
|
|
|
|
/**
|
|
* @Description : The Message is not handled.
|
|
*
|
|
* @param msg - Message object.[in]
|
|
*/
|
|
void NotExecutedMessage(const InternalMessage *msg);
|
|
|
|
/**
|
|
* @Description Stop Handler Thread.
|
|
*
|
|
*/
|
|
void StopHandlerThread() override;
|
|
|
|
/**
|
|
* @Description : Start the timer.
|
|
*
|
|
* @param timerName - Timer Name.[in]
|
|
* @param interval - Timer duration, in milliseconds.[in]
|
|
*/
|
|
virtual void StartTimer(int timerName, int64_t interval);
|
|
|
|
/**
|
|
* @Description : Stop the timer.
|
|
*
|
|
* @param timerName - Timer Name.[in]
|
|
*/
|
|
virtual void StopTimer(int timerName) override;
|
|
|
|
/**
|
|
* @Description : Construct internal messages.
|
|
*
|
|
* @return InternalMessage* : Pointer to the constructed internal message.
|
|
*/
|
|
InternalMessage *CreateMessage();
|
|
|
|
/**
|
|
* @Description : Construct an information message based on
|
|
* the original message.
|
|
*
|
|
* @param orig - Original message.[in]
|
|
* @return InternalMessage* : Pointer to the constructed internal message.
|
|
*/
|
|
InternalMessage *CreateMessage(const InternalMessage *orig);
|
|
|
|
/**
|
|
* @Description : Construct internal messages.
|
|
*
|
|
* @param msgName - Message Name.[in]
|
|
* @return InternalMessage* : Pointer to the constructed internal message.
|
|
*/
|
|
InternalMessage *CreateMessage(int msgName);
|
|
|
|
/**
|
|
* @Description : Construct internal messages.
|
|
*
|
|
* @param msgName - Message Name.[in]
|
|
* @param param1 - Message parameters.[in]
|
|
* @return InternalMessage* : Pointer to the constructed internal message.
|
|
*/
|
|
InternalMessage *CreateMessage(int msgName, int param1);
|
|
|
|
/**
|
|
* @Description : Construct internal messages.
|
|
*
|
|
* @param msgName - Message Name.[in]
|
|
* @param param1 - Message parameters.[in]
|
|
* @param param2 - Message parameters.[in]
|
|
* @return InternalMessage* : Pointer to the constructed internal message.
|
|
*/
|
|
InternalMessage *CreateMessage(int msgName, int param1, int param2);
|
|
|
|
/**
|
|
* @Description : Construct internal messages.
|
|
*
|
|
* @param msgName - Message Name.[in]
|
|
* @param messageObj - User-defined data
|
|
* @return InternalMessage* : Pointer to the constructed internal message.
|
|
*/
|
|
InternalMessage *CreateMessage(int msgName, const std::shared_ptr<VStateMessage> &messageObj);
|
|
|
|
/**
|
|
* @Description : Constructs internal messages.
|
|
*
|
|
* @param msgName - Message name.[in]
|
|
* @param param1 - First Message parameter.[in]
|
|
* @param param2 - Second Message parameter.[in]
|
|
* @param messageObj - User-defined data
|
|
* @return InternalMessage* : Pointer to the constructed internal message.
|
|
*/
|
|
InternalMessage *CreateMessage(int msgName, int param1, int param2,
|
|
const std::shared_ptr<VStateMessage> &messageObj);
|
|
|
|
/**
|
|
* @Description : Constructs internal messages and places the
|
|
* messages in the message queue of the state machine.
|
|
*
|
|
* @param msgName - Message name.[in]
|
|
*/
|
|
virtual void SendMessage(int msgName) override;
|
|
|
|
/**
|
|
* @Description : Constructs internal messages and places the messages
|
|
* in the message queue of the state machine.
|
|
*
|
|
* @param msgName - Message name.[in]
|
|
* @param param1 - Message parameter.[in]
|
|
*/
|
|
virtual void SendMessage(int msgName, int param1);
|
|
|
|
/**
|
|
* @Description : Constructs internal messages and places the messages
|
|
* in the message queue of the state machine.
|
|
*
|
|
* @param msgName - Message name.[in]
|
|
* @param param1 - Message parameter.[in]
|
|
* @param param2 - Message parameter.[in]
|
|
*/
|
|
virtual void SendMessage(int msgName, int param1, int param2);
|
|
|
|
/**
|
|
* @Description : Puts messages into the message queue of the state machine.
|
|
*
|
|
* @param msg - Message to be sent.[in]
|
|
*/
|
|
virtual void SendMessage(InternalMessage *msg);
|
|
|
|
/**
|
|
* @Description : Puts messages into the message queue of the state machine.
|
|
*
|
|
* @param msgName - Message Name.[in]
|
|
* @param messageObj - User-defined data
|
|
*/
|
|
virtual void SendMessage(int msgName, const std::shared_ptr<VStateMessage> &messageObj) override;
|
|
|
|
/**
|
|
* @Description : Puts messages into the message queue of the state machine.
|
|
*
|
|
* @param msgName - Message Name.[in]
|
|
* @param param1 - Message parameters.[in]
|
|
* @param param2 - Message parameters.[in]
|
|
* @param messageObj - User-defined data
|
|
*/
|
|
virtual void SendMessage(int msgName, int param1, int param2, const std::shared_ptr<VStateMessage> &messageObj);
|
|
|
|
/**
|
|
* @Description Constructs internal messages and places them in the
|
|
* message queue of the state machine. The messages are processed
|
|
* after the specified delay time.
|
|
*
|
|
* @param msgName - Message Name.[in]
|
|
* @param delayTimeMs - Delay time, in milliseconds.[in]
|
|
*/
|
|
void MessageExecutedLater(int msgName, int64_t delayTimeMs);
|
|
|
|
/**
|
|
* @Description : Constructs internal messages and places them in the
|
|
* message queue of the state machine. The messages are processed
|
|
* after the specified delay time.
|
|
*
|
|
* @param msgName - Message Name.[in]
|
|
* @param param1 - Message parameters.[in]
|
|
* @param delayTimeMs - Delay time, in milliseconds.[in]
|
|
*/
|
|
void MessageExecutedLater(int msgName, int param1, int64_t delayTimeMs);
|
|
|
|
/**
|
|
* @Description : Constructs internal messages and places them in the
|
|
* message queue of the state machine. The messages are processed
|
|
* after the specified delay time.
|
|
*
|
|
* @param msgName - Message Name.[in]
|
|
* @param param1 - Message parameters.[in]
|
|
* @param param2 - Message parameters.[in]
|
|
* @param delayTimeMs - Delay time, in milliseconds.[in]
|
|
*/
|
|
void MessageExecutedLater(int msgName, int param1, int param2, int64_t delayTimeMs);
|
|
|
|
/**
|
|
* @Description : Constructs internal messages and places them in the
|
|
* message queue of the state machine. The messages are processed
|
|
* after the specified delay time.
|
|
*
|
|
* @param msg - Message to be sent.[in]
|
|
* @param delayTimeMs - Delay time, in milliseconds.[in]
|
|
*/
|
|
void MessageExecutedLater(InternalMessage *msg, int64_t delayTimeMs);
|
|
|
|
/**
|
|
* @Description : Constructs internal messages and places them in the
|
|
* message queue of the state machine. The messages are processed
|
|
* after the specified delay time.
|
|
*
|
|
* @param msgName - Message Name.[in]
|
|
* @param messageObj -User-defined data
|
|
* @param delayTimeMs - Delay time, in milliseconds.[in]
|
|
*/
|
|
void MessageExecutedLater(int msgName, const std::shared_ptr<VStateMessage> &messageObj,
|
|
int64_t delayTimeMs) override;
|
|
|
|
/**
|
|
* @Description : Constructs internal messages and places them in the
|
|
* message queue of the state machine. The messages are processed
|
|
* after the specified delay time.
|
|
*
|
|
* @param msgName - Message Name.[in]
|
|
* @param param1 - Message parameters.[in]
|
|
* @param param2 - Message parameters.[in]
|
|
* @param messageObj - User-defined data
|
|
* @param delayTimeMs - Delay time, in milliseconds.[in]
|
|
*/
|
|
void MessageExecutedLater(int msgName, int param1, int param2, const std::shared_ptr<VStateMessage> &messageObj,
|
|
int64_t delayTimeMs);
|
|
|
|
/**
|
|
* @Description : Construct a new State Machine:: State Machine object.
|
|
*
|
|
* @param name - State name.[in]
|
|
*/
|
|
explicit StateMachine(const std::string &name);
|
|
|
|
/**
|
|
* @Description : Destroy the State Machine:: State Machine object.
|
|
*
|
|
*/
|
|
virtual ~StateMachine();
|
|
|
|
protected:
|
|
/**
|
|
* @Description : Add state.
|
|
*
|
|
* @param state - state.[in]
|
|
* @param upper - upper state.[in]
|
|
*/
|
|
void StatePlus(State *state, State *upper) override;
|
|
|
|
/**
|
|
* @Description : Remove state.
|
|
*
|
|
* @param state - state.[in]
|
|
*/
|
|
void StateDelete(State *state);
|
|
|
|
/**
|
|
* @Description : Set first state.
|
|
*
|
|
* @param firstState - First state.[in]
|
|
*/
|
|
void SetTopState(State *firstState) override;
|
|
|
|
/**
|
|
* @Description : Transition to orther state.
|
|
*
|
|
* @param targetState - state.[in]
|
|
*/
|
|
void SwitchState(State *targetState) override;
|
|
|
|
/**
|
|
* @Description : Delay Message.
|
|
*
|
|
* @param msg - Message object.[in]
|
|
*/
|
|
void DelayMessage(const InternalMessage *msg);
|
|
void DelayMessage(VStateMachineData *msg) override;
|
|
|
|
private:
|
|
StateMachineHandler *pStateMachineHandler;
|
|
std::string mStateName;
|
|
};
|
|
|
|
typedef struct StateInfo
|
|
{
|
|
State *state;
|
|
StateInfo *upperStateInfo;
|
|
bool active;
|
|
} StateInfo;
|
|
|
|
class StateMachineHandler : public Handler
|
|
{
|
|
public:
|
|
using StateInfoMap = std::map<std::string, StateInfo *>;
|
|
using StateVector = std::vector<StateInfo *>;
|
|
using DelayedMessage = std::vector<InternalMessage *>;
|
|
|
|
/**
|
|
* @Description : Construct a new state machine Handler:: StateMachine Handler object.
|
|
*
|
|
* @param pStateMgr - Handler pointer.[in]
|
|
*/
|
|
explicit StateMachineHandler(StateMachine *pStateMgr);
|
|
|
|
/**
|
|
* @Description : Destroy the StateMachine Handler:: StateMachine Handler object.
|
|
*
|
|
*/
|
|
~StateMachineHandler();
|
|
|
|
/**
|
|
* @Description : StateMachineHandler Initialization Function.
|
|
*
|
|
* @return true : success, false : failed.
|
|
*/
|
|
bool InitialSmHandler();
|
|
|
|
/**
|
|
* @Description : Add a new state.
|
|
*
|
|
* @param state - State to be added.[in]
|
|
* @param upper - upper of state.[in]
|
|
* @return StateInfo*
|
|
*/
|
|
StateInfo *StatePlus(State *state, State *upper);
|
|
|
|
/**
|
|
* @Description : Delete a state.
|
|
*
|
|
* @param state - State to be deleted.[in]
|
|
*/
|
|
void StateDelete(State *state);
|
|
|
|
/**
|
|
* @Description : Sets the Initialization State.
|
|
*
|
|
* @param firstState - Initialization State.[in]
|
|
*/
|
|
void SetTopState(State *firstState);
|
|
|
|
/**
|
|
* @Description : State transition function.
|
|
*
|
|
* @param targetState - Destination State.[in]
|
|
*/
|
|
void SwitchState(State *targetState);
|
|
|
|
/**
|
|
* @Description : Delay Message Processing Function.
|
|
*
|
|
* @param msg - Message body pointer.[in]
|
|
*/
|
|
void DelayMessage(const InternalMessage *msg);
|
|
// void DelayMessage(const std::shared_ptr<VStateMessage> &messageObj);
|
|
|
|
/**
|
|
* @Description : The state machine is constructed.
|
|
*
|
|
*/
|
|
void BuildTreeComplete();
|
|
|
|
private:
|
|
/**
|
|
* @Description : Sets the initial state sequence.
|
|
*
|
|
*/
|
|
void BuildStateInitVector();
|
|
|
|
/**
|
|
* @Description : Writes the inactive upper states of targetState
|
|
* and targetState to the sequenceStateVector list.
|
|
*
|
|
* @param targetState - Target State Machine.[in]
|
|
* @return StateInfo*
|
|
*/
|
|
StateInfo *BuildSequenceStateVector(State *targetState);
|
|
|
|
/**
|
|
* @Description : Move Delayed Message At Front Of Queue.
|
|
*
|
|
*/
|
|
void PlaceDelayedMsgQueueTop();
|
|
|
|
/**
|
|
* @Description : Release all messages in delayed Messages.
|
|
*
|
|
*/
|
|
void ReleaseDelayedMessages();
|
|
|
|
/**
|
|
* @Description : Fill the status in the sequential status
|
|
* list in reverse order.
|
|
*
|
|
* @return int
|
|
*/
|
|
int MoveSequenceToStateVector();
|
|
|
|
/**
|
|
* @Description : Invoke the ExecuteStateMsg interface of the current state
|
|
* to process messages sent to the state machine. The entry/exit of the
|
|
* state machine is also called, and the delayed messagei s put back
|
|
* into queue when transitioning to a new state.
|
|
*
|
|
* @param msg - Messages.[in]
|
|
*/
|
|
void ExecuteMessage(InternalMessage *msg) override;
|
|
|
|
/**
|
|
* @Description : Clean up After Quitting.
|
|
*
|
|
*/
|
|
void ClearWhenQuit();
|
|
|
|
/**
|
|
* @Description : Performing Status Transitions.
|
|
*
|
|
* @param msgProcessedState - Message processing status.[in]
|
|
* @param msg - Messages.[in]
|
|
*/
|
|
void PerformSwitchState(State *msgProcessedState, InternalMessage *msg);
|
|
|
|
/**
|
|
* @Description : Process messages. If the current state doesnot process it,
|
|
* the upper state processing is called, and so on. If all upper states
|
|
* are not processed, invoke the NotExecutedMessage method of the state machine.
|
|
*
|
|
* @param msg - Message body pointer.[in]
|
|
* @return State*
|
|
*/
|
|
State *ExecuteTreeStateMsg(InternalMessage *msg);
|
|
|
|
/**
|
|
* @Description : Invoke GoOutState() for each state from the first
|
|
* state in the list to the public upper state.
|
|
*
|
|
* @param commonStateInfo - common upper state machine.[in]
|
|
*/
|
|
void CallTreeStateExits(StateInfo *commonStateInfo);
|
|
|
|
/**
|
|
* @Description : Call the GoInState method from the start state
|
|
* index to the top of the state stack.
|
|
*
|
|
* @param index - Start state index of the
|
|
* state machine list.
|
|
*/
|
|
void CallTreeStateEnters(int index);
|
|
|
|
private:
|
|
/* All state mappings of the state machine */
|
|
StateInfoMap mStateInfoMap;
|
|
/* From child state to upper state list */
|
|
StateVector mStateVector;
|
|
/* Top index of mStateVector */
|
|
int mStateVectorTopIndex;
|
|
/* From upper state to child state list */
|
|
StateVector mSequenceStateVector;
|
|
/* Top of mSequenceStateVector */
|
|
int mSequenceStateVectorCount;
|
|
/* Delayed Message Queue */
|
|
DelayedMessage mDelayedMessages;
|
|
/* State machine instance */
|
|
StateMachine *pStateMachine;
|
|
/* Initial state */
|
|
State *pFirstState;
|
|
/* Target Status */
|
|
State *pTargetState;
|
|
/* StateMachine exit or not */
|
|
bool mQuitFlag;
|
|
/* Whether the state machine has been built */
|
|
bool mBuildCompleteFlag;
|
|
/*
|
|
* All State exit/enter calls are true before the
|
|
* last enter call in the target state.
|
|
*/
|
|
bool mSwitchingStateFlag;
|
|
/* Current Message */
|
|
InternalMessage *pCurrentMsg;
|
|
};
|
|
// } // namespace Wifi
|
|
// } // namespace OHOS
|
|
#endif |