WifiStateMachine

转自：http://www.cnblogs.com/dongtaochen2039/archive/2012/03/31/2424626.html

android状态机机制StateMachine

        最近在看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<State, StateInfo> mStateInfo =
            new HashMap<State, StateInfo>();

   由上可知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<String> available;
        ArrayList<String> active;
        TetherStateChange(ArrayList<String> av, ArrayList<String> 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<String> available = intent.getStringArrayListExtra(
                            ConnectivityManager.EXTRA_AVAILABLE_TETHER);
                    ArrayList<String> 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<String, ScanResult>(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犀利之处，我等望洋兴叹！