android状态机机制StateMachine-白红宇

android状态机机制StateMachine

阅读量：4544 次

发布时间：2019-06-08

本文共 16323 字，大约阅读时间需要 54 分钟。

最近在看WifiService源码，发现Android2.3中Wifi的状态都是在WifiStateTracker中维护的，4.0中将Wifi的状态全部放到WifiStateMachine中维护了。WifiStateMachine是一个状态机，首先WifiStateMachine继承于StateMachine，StateMachine是一个层次结构的状态机，它可以处理一些消息，并维护一个层次结构的状态。

阅读StateMachine源码，其结构大致如下：

。。。ProcessedMessageInfo类

。。。ProcessedMessages类

。。。SmHandler类

。。。。。。StateInfor

。。。。。。HaltingState

。。。。。。QuitingState

一、ProcessedMessageInfo类

先看下该类的源码：

/**      * {@hide}      *      * The information maintained for a processed message. */ public static class ProcessedMessageInfo {
   private int what; private State state;           消息现在的状态                          private State orgState;        消息没被处理前的状态                ProcessedMessageInfo(Message message, State state, State orgState) {
               this.what = message.what; this.state = state; this.orgState = orgState;         }

　　从该类的构造函数可以看出，这个类就是保存了Message的一些信息。然后我们再了解下State类，状态很简单，只有自已的名字可以用getName（）方法得到名称（如"Connecting"表示当前正在连接 Wifi），然后还有一个处理函数processMessage，它接收一个Message参数，顾名思义，它是用来处理某个事件。另外还有两个函数 enter和exit，表示进入该状态和退出该状态作的一些一般操作，如enter可能会做一些初始化操作，而exit会做一些清理工作。

二、ProcessedMessages类

可以将这个类理解乘一个List，保存了若干刚处理过的Message的ProcessedMessageInfo对象。由类的成员函数： private Vector<ProcessedMessageInfo> mMessages = new Vector<ProcessedMessageInfo>();

可以看出。然后类中有一些定义Vector属性的方法，比如它的Size获得元素，和向Vector中加入新的刚处理过的Message元素。

三、SmHandler类

该类有三个内部类，源码如下：

/**          * Information about a state.          * Used to maintain the hierarchy. */ private class StateInfo {
   /** The state */             State state; /** The parent of this state, null if there is no parent */             StateInfo parentStateInfo; /** True when the state has been entered and on the stack */ boolean active; /**              * Convert StateInfo to string */

StateInfo类保存了State的基本信息。

/**          * State entered when transitionToHaltingState is called. */ private class HaltingState extends State {
               @Override public boolean processMessage(Message msg) {
                   mSm.haltedProcessMessage(msg); return true;             }         } /**          * State entered when a valid quit message is handled. */ private class QuittingState extends State {
               @Override public boolean processMessage(Message msg) {
   return NOT_HANDLED;             }         }

HaltingState和QuittingState类继承自State重写了它的processMessage方法。

接下来就是SmsHandler的handleMessage方法了，在该方法中干了两件事，1，将Message交给State的processMessage方法处理消息，2，对stateStack中的state通过enter和exit操作进行处理消息的先后顺序。

StateMachine的构造函数中开启了一个HandlerThread专门用来发送给SmsHandler消息进而进行处理。源码如下：

protected StateMachine(String name) {
           mSmThread = new HandlerThread(name);         mSmThread.start();         Looper looper = mSmThread.getLooper();         mName = name;         mSmHandler = new SmHandler(looper, this);     }

可以看出在构造器里面创建了有looper的handler对象，然后就开始各种send，obtain以及handle操作了。

现在有一个疑问就是StateMachine中的state是怎末加进来的呢？不解释，看源码：

在StateMachine里有一addState（）方法

/**      * Add a new state to the state machine      * @param state the state to add      * @param parent the parent of state */ protected final void addState(State state, State parent) {
           mSmHandler.addState(state, parent);     }

可以看出它调用了SmHandler的addState方法：

/**          * Add a new state to the state machine. Bottom up addition          * of states is allowed but the same state may only exist          * in one hierarchy.          *          * @param state the state to add          * @param parent the parent of state          * @return stateInfo for this state */ private final StateInfo addState(State state, State parent) {
   if (mDbg) {
                   Log.d(TAG, "addStateInternal: E state=" + state.getName()                         + ",parent=" + ((parent == null) ? "" : parent.getName()));             }             StateInfo parentStateInfo = null; if (parent != null) {
                   parentStateInfo = mStateInfo.get(parent);                                        //得到该parent state的详细内容，返回stateInfo类型。 if (parentStateInfo == null) {
   // Recursively add our parent as it's not been added yet.                     parentStateInfo = addState(parent, null);                                    //是递归算法    若parent state没在StateMachine中，先将parentState加入到消息状态机                 }             }             StateInfo stateInfo = mStateInfo.get(state); if (stateInfo == null) {                                                    //该state没有加入状态机层次结构。                 stateInfo = new StateInfo();                 mStateInfo.put(state, stateInfo);                                       //将该state放入StateMachine中 mStateInfo是HashMap源码见底下                                              } // Validate that we aren't adding the same state in two different hierarchies.             if ((stateInfo.parentStateInfo != null) &&                     (stateInfo.parentStateInfo != parentStateInfo)) {                      //若待加入的state的父state没有加入stateMachine则该state也不能加入 throw new  RunTimexception("state already added");             }             stateInfo.state = state;                                                     //向刚加入StateMachine的state所对应的StateInfo赋值             stateInfo.parentStateInfo = parentStateInfo;             stateInfo.active = false; if (mDbg) Log.d(TAG, "addStateInternal: X stateInfo: " + stateInfo); return stateInfo;         }

/** The map of all of the states in the state machine */ private HashMap
     
       mStateInfo = new HashMap
      
       ();

由上可知stateMachine有层次结构，打个例子，就跟入党一样，必须得有介绍人你才能入，否则组织就不接受你。这个状态机也一样，假如state2要加如statemachine，先判断它的父状态 state1，是否已经加入，若没，就

出现 Runimexception。这样就会出现一庞大的层次树结构。下面举一例子介绍下它的树状层次结构：

StateMachine sm = /*Create a state machine*/; sm.addState(mP0, null);     sm.addState(mP1, mP0);         sm.addState(mS2, mP1);             sm.addState(mS3, mS2);             sm.addState(mS4, mS2);         sm.addState(mS1,mP1);             sm.addState(mS5, mS1);     sm.addState(mS0, mP0); sm.setInitialState(mS5);

初始后的状态机形如一个树状结构，如下图所示：

#           mP0  #          /      \  #        mP1   mS0  #       /      \  #     mS2    mS1  #    /      \       \  # mS3  mS4    mS5  ---> initial state

通过以上的分析理解，可以认为StateMachine是一个处理Message的一个栈，但是它的处理消息的顺序

是可以任意变化的。通过transitionTo（）函数就可以设置先处理哪一个state(message)了。而处理消息是在相应state的ProcessMessage（message）函数里面进行。源码如下：

private final void transitionTo(IState destState) {                              // destState为要处理的State（Message）             mDestState = (State) destState; if (mDbg) Log.d(TAG, "StateMachine.transitionTo EX destState" + mDestState.getName());         }

通过以上的学习对StateMachine有了大致的了解，现在我们再来学习wifiStateMachine类。

该类有很多内部类，但是整体架构很简单，分为两部分继承自state类的内部类，还有就是TetherStateChange类：

先看TetherStateChange类，因为比较简单，源码：

private class TetherStateChange {
           ArrayList
     
       available;         ArrayList
      
        active;         TetherStateChange(ArrayList
       
         av, ArrayList
        
          ac) {
               available = av;             active = ac;         }     }

一会再来分析

然后就是各种state类了。

接下来看wifistatemachine里面的方法，他里面的方法也很有规律，如有很多set....,里面都有sendMessage方法，比如setWifiEnabled（）等，源码如下：

public void setWifiEnabled(boolean enable) {
           mLastEnableUid.set(Binder.getCallingUid()); if (enable) {
   /* Argument is the state that is entered prior to load */             sendMessage(obtainMessage(CMD_LOAD_DRIVER, WIFI_STATE_ENABLING, 0));             sendMessage(CMD_START_SUPPLICANT);         } else {
               sendMessage(CMD_STOP_SUPPLICANT); /* Argument is the state that is entered upon success */             sendMessage(obtainMessage(CMD_UNLOAD_DRIVER, WIFI_STATE_DISABLED, 0));         }     }

观察其没什么特别的就是调用了sendMessage方法，进一步的看sendMessage的源码我们发现：

public final void sendMessage(Message msg) {
   // mSmHandler can be null if the state machine has quit.         if (mSmHandler == null) return;         mSmHandler.sendMessage(msg);     }

是将message发送到消息队列中去，且调用的是StateMachine的内部类SmHandler的sendMessage方法，然后就该轮到SmHandler的handleMessage方法去处理了，在handleMessage里面在进行一些TransitionTo操作，最后交给该state的ProcessMessage方法去解决问题。由此可知所有调用sendMessage方法的函数都是同一种类型。

这时就我产生了一个疑问消息都发送到stateMachine了，为什么不addState（）呢？否则TransitionTo怎末知道状态机里面的state呢？通过查看wifiStateMachine的构造函数我发现所有的addState操作都在里面呢！

通过wifiStateMachine的构造函数我们知道这个构造函数就干了两件事，第一发送了两个广播，第二构建了状态机的树层次结构，接下来就是初始化变量了。部分源码如下：

mContext.registerReceiver(                                                                   //注册第一个广播    ？？？ new BroadcastReceiver() {
                   @Override public void onReceive(Context context, Intent intent) {
                       ArrayList
     
       available = intent.getStringArrayListExtra(                             ConnectivityManager.EXTRA_AVAILABLE_TETHER);                     ArrayList
      
        active = intent.getStringArrayListExtra(                             ConnectivityManager.EXTRA_ACTIVE_TETHER);                     sendMessage(CMD_TETHER_STATE_CHANGE, new TetherStateChange(available, active));                 }             },new IntentFilter(ConnectivityManager.ACTION_TETHER_STATE_CHANGED)); mContext.registerReceiver(                                                               //注册第二个广播    调用了startScan(false);方法关闭wifi热点扫描 new BroadcastReceiver() {
                       @Override public void onReceive(Context context, Intent intent) {
                           startScan(false);                     }                 }, new IntentFilter(ACTION_START_SCAN));         mScanResultCache = new LruCache
       
        (SCAN_RESULT_CACHE_SIZE);         PowerManager powerManager = (PowerManager)mContext.getSystemService(Context.POWER_SERVICE);         mWakeLock = powerManager.newWakeLock(PowerManager.PARTIAL_WAKE_LOCK, TAG);         addState(mDefaultState);                                                                         //构建状态机的树层次结构             addState(mInitialState, mDefaultState);             addState(mDriverUnloadingState, mDefaultState);             addState(mDriverUnloadedState, mDefaultState);                 addState(mDriverFailedState, mDriverUnloadedState);             addState(mDriverLoadingState, mDefaultState);             addState(mDriverLoadedState, mDefaultState);             addState(mSupplicantStartingState, mDefaultState);             addState(mSupplicantStartedState, mDefaultState);                 addState(mDriverStartingState, mSupplicantStartedState);                 addState(mDriverStartedState, mSupplicantStartedState);                     addState(mScanModeState, mDriverStartedState);                     addState(mConnectModeState, mDriverStartedState);                         addState(mConnectingState, mConnectModeState);                         addState(mConnectedState, mConnectModeState);                         addState(mDisconnectingState, mConnectModeState);                         addState(mDisconnectedState, mConnectModeState);                         addState(mWaitForWpsCompletionState, mConnectModeState);                 addState(mDriverStoppingState, mSupplicantStartedState);                 addState(mDriverStoppedState, mSupplicantStartedState);             addState(mSupplicantStoppingState, mDefaultState);             addState(mSoftApStartingState, mDefaultState);             addState(mSoftApStartedState, mDefaultState);                 addState(mTetheringState, mSoftApStartedState);                 addState(mTetheredState, mSoftApStartedState);             addState(mSoftApStoppingState, mDefaultState);             addState(mWaitForP2pDisableState, mDefaultState);         setInitialState(mInitialState);                                                          //设置状态机的初始状态为mInitialtate if (DBG) setDbg(true);                                 //start the state machine                                                     //启动状态机             start();

状态机的树结构图如下：

我们研究下start方法，该方法是StateMachine中的方法，在该方法中调用了mSmHandler.completeConstruction()方法，该方法完善了对StateMachine的初始化，其中比较重要的是计算出了状态机层次结构的深度

源代码如下：

/**          * Complete the construction of the state machine. */ private final void completeConstruction() {
   if (mDbg) Log.d(TAG, "completeConstruction: E"); /**              * Determine the maximum depth of the state hierarchy              * so we can allocate the state stacks. */ int maxDepth = 0; for (StateInfo si : mStateInfo.values()) {                       //遍历取出状态机中通过addState方法加入的，所有的状态。 int depth = 0; for (StateInfo i = si; i != null; depth++) {                                           i = i.parentStateInfo;                 } if (maxDepth < depth) {
                       maxDepth = depth;                                           //求出树的深度                 }             } if (mDbg) Log.d(TAG, "completeConstruction: maxDepth=" + maxDepth);             mStateStack = new StateInfo[maxDepth];             mTempStateStack = new StateInfo[maxDepth];             setupInitialStateStack(); /**              * Construction is complete call all enter methods              * starting at the first entry. */             mIsConstructionCompleted = true;             mMsg = obtainMessage(SM_INIT_CMD);             invokeEnterMethods(0);                                             /**              * Perform any transitions requested by the enter methods */             performTransitions(); if (mDbg) Log.d(TAG, "completeConstruction: X");         }

其中invokeEnterMethods(0); 方法调用了mStateStack[]数组下标小于mStateStackTopIndex数的所有状态（state）的enter方法，即进入了状态机树结构的下标为mStateStackTopIndex的状态。

setupInitialStateStack(); 这个方法首先初始化了mTempStateStack[]数组（）（树根保存在数组下标最大的那个元素上），然后又通过函数moveTempStateStackToStateStack（）将mTempStateStack[]数组的值倒序付给了mStateStack[]数组并且设置了 mStateStackTopIndex（栈顶序列号）的值为数组的最大下标，方便在ProcessMsg（）时取出的state为栈顶元素。

mTempStateStack[]数组保存的是当前正在处理的树叶状态的所有父亲,且树根总是保存在数组下标最大的单元里；它是中间进行值操作所用的

mStateStack[]数组是mTempStateStack[]元素的反向保存，所以，树根永远保存在小标为0的单元里。且它是最终应用的state

接下来在看 performTransitions();其部分源代码如下：

                 /* Determine the states to exit and enter and return the                  * common ancestor state of the enter/exit states. Then                  * invoke the exit methods then the enter methods.                  */    1            StateInfo commonStateInfo = setupTempStateStackWithStatesToEnter(destState);         2            invokeExitMethods(commonStateInfo);                                                 3            int stateStackEnteringIndex = moveTempStateStackToStateStack();         4            invokeEnterMethods(stateStackEnteringIndex);                        //从stateStackEnteringIndex向栈顶依次执行enter方法并设Active为true /**                  * Since we have transitioned to a new state we need to have                  * any deferred messages moved to the front of the message queue                  * so they will be processed before any other messages in the                  * message queue. */                 moveDeferredMessageAtFrontOfQueue();                                //将消息移动到消息队列的顶部以便马上执行             }

1. StateInfo commonStateInfo = setupTempStateStackWithStatesToEnter(destState); 逐次向上查找destState的所有祖先直到该祖先的stateInfo.Active为true才停止，并将值放到mTempStateStake 里面，树根对应下标最大的，commonstateInfo为该祖先的 stateInfor属性，在这个函数里面也将mTempStateStake清空了，并重新赋值了。

2.invokeExitMethods(commonStateInfo)方法从mStateStack的顶部依次向下移动直到找到commonStateInfo，把这些之间的state的exit方法都执行，并将Active赋值为false

3.int stateStackEnteringIndex = moveTempStateStackToStateStack()将mTempStateStack[]数组的值倒序付给了mStateStack[]数组并且设置了 mStateStackTopIndex（栈顶序列号）的值为数组的最大下标。

4. invokeEnterMethods(stateStackEnteringIndex); 从stateStackEnteringIndex向栈顶依次执行enter方法并设Active为true

现在对上面4个函数做一总结，在函数1的时候传入了一个destState参数，这个是目标stat，e即马上想要处理的state，必须把它放置在栈顶才行，好了下面三个函数就是这么做的。函数一先返回一个commonStateinfo就是下面所说的fatherState，这个stateInfo就是destState的一个满足Active参数为true且离他最近的父亲设为fatherState，并且重新赋了mTempStateStack的值，且值为destState到fatherState之间的所有父亲（fatherState的下标最大），函数2就是从当前mStateStack[]（当前状态栈）中的当前状态开始一直到本栈中的fatherState都执行exit方法，且将Active值付为false。这样fatherState所在的mState栈的所有子State就都关闭了。函数三就是将经函数二处理过的mTempStateStake的值反序付给mStateStack且将mTempStateStake中树根fatherState的值对应mStateStack中fatherState的值然后一直到destState，并将mStackstateTopIndex的值改变为destState在mStateStack中的位置（这样做是因为在handlemessge里面就是靠这个索引找目标state的），这样就实现了mStateStack栈完美的转换顺序，最后再将更新后的mStateStack中fatherState到destState之间所有的子state都执行enter函数且将Active的值变为true（栈中fatherState的所有父state不用执行enter操作因为他们就没有关闭一直处于active的状态），；到此为止所有的transmmit工作就结束了，然后不同的message就可以进入到相应的state进行处理。再次慨叹google犀利之处，我等望洋兴叹！