Android StateMachine 分析

        State模式允许一个对象在期内部状态改变时改变其行为模式，State 模式是将对象的状态封装成一个对象，是在不同的状态下执行不同的操作。Android系统通过StateMachine 是State模式的一种应用，其实现的相当精妙。本文对StateMachine做个深入分析，介绍其实现机制。

         首先通过一个例子来引入问题，假如我们有6个状态S1、S2、S3、S4、S5、S6。其中：1、每个状态对某些消息都要做不同的处理；2、S1是S2的父状态，S2是S3的父状态，S3是S4的父，S1是S5的父状态，S5是S6的父状态；3、初始状态是S4；4、在运行过程中，收到某个消息时状态机有S4转到S3。如下图：

        

                   图1：状态结构图

        图1显示了个状态的关系，在解析Android StateMachine如何管理State之前，先介绍State。

State：

public class State implements IState {        protected State() {    }     @Override    public void enter() {    }    @Override    public void exit() {    }    @Override    public boolean processMessage(Message msg) {        return false;    }    @Override    public String getName() {        String name = getClass().getName();        int lastDollar = name.lastIndexOf('$');        return name.substring(lastDollar + 1);    }}

         State 作为状态基类，StateMachine 管理的state都需要从此继承下来。重写几个重要方法，enter表示进入该状态的调用，exit是退出该状态会调用，processMessage是当前状态下处理消息的函数。如果当前状态处理后返回false表明还需要父状态处理，如图1中示例，如果状态S4处理消息后返回false表明还需要其父状态S2处理，直到递归到根状态。通过这样的机制为设计状态机的各种状态提供了便利，对于一些公共消息可以放到公共状态上来处理，后面会介绍其实现的机制。

         在Android Handler机制博文中介绍了Android线程处理消息的一种方式，在StateMachine中，核心也是采用了类似的机制来管理states。StateMachine通过一独立线程来完成三个功能

• 建立树型状态层次结构
• 状态机状态堆栈的建立并管理状态切换
• 分发消息

         以上三个功能均有mSmHandler来完成，mSmHandler类继承于Handler，下面来分析其如何完成以上三个功能。

1. 建立树形结构层次

       StateMachine 提供AddState方法来添加状态到状态机中，函数如下：

  protected final void addState(State state, State parent) {        mSmHandler.addState(state, parent);    }

       这里其实调用的是mSmHandler的addState 方法，再网下跟踪

  private final StateInfo addState(State state, State parent) {            // 获取当前状态父状态信息            StateInfo parentStateInfo = null;            if (parent != null) {                parentStateInfo = mStateInfo.get(parent);                if (parentStateInfo == null) {                    // 当父状态未添加进来时，递归添加进来.                    parentStateInfo = addState(parent, null);                }            }            // 判断状态信息是否添加到树形结构中            StateInfo stateInfo = mStateInfo.get(state);            if (stateInfo == null) {                stateInfo = new StateInfo();                mStateInfo.put(state, stateInfo);            }            // Validate that we aren't adding the same state in two different hierarchies.            if ((stateInfo.parentStateInfo != null) &&                    (stateInfo.parentStateInfo != parentStateInfo)) {                    throw new RuntimeException("state already added");            }            stateInfo.state = state;            stateInfo.parentStateInfo = parentStateInfo;            stateInfo.active = false;            if (mDbg) Log.d(TAG, "addStateInternal: X stateInfo: " + stateInfo);            return stateInfo;        }

     在StateMachine类中，StateInfo就是一个包装State的树节点，每一个状态对应一个状态信息StateInfo，通过HashMaps存储下来

 private HashMap<State, StateInfo> mStateInfo =new HashMap<State, StateInfo>();

     因此图1所的示状态构成可以通过以下流程来实现：

     addState(S1,null);addState(S2,S1);addState(S3,S2);addState(S4,S2);addState(S5,S1);addState(S6,S5);

2. 状态机堆栈的建立和状态切换

          2.1 状态机堆栈建立

         StateMachine 通过两个结构来建立和切换状态堆栈， mStateStack[] 及  mTempStateStack[]。建立堆栈API如下：

 private final void completeConstruction() {                       // 计算堆栈深度，状态个数            int maxDepth = 0;            for (StateInfo si : mStateInfo.values()) {                int depth = 0;                for (StateInfo i = si; i != null; depth++) {                    i = i.parentStateInfo;                }                if (maxDepth < depth) {                    maxDepth = depth;                }            }            // 建立两个栈            mStateStack = new StateInfo[maxDepth];            mTempStateStack = new StateInfo[maxDepth];            //根据初始状态构建父子关系栈             setupInitialStateStack();           // 激活对应状态，并调用State的entry方法表明进入当前状态            mIsConstructionCompleted = true;            mMsg = obtainMessage(SM_INIT_CMD);            invokeEnterMethods(0);            //如果需要将做状态切换，在后面会介绍            performTransitions();        }

          在来分析setUpInitialStateStack()的实现。

 private final void setupInitialStateStack() {            // 根据初始状态建立临时栈，如本文开始提出的初始状态为S4，那么临时栈存储的状态为：S4->S2->S1            StateInfo curStateInfo = mStateInfo.get(mInitialState);            for (mTempStateStackCount = 0; curStateInfo != null; mTempStateStackCount++) {                mTempStateStack[mTempStateStackCount] = curStateInfo;                curStateInfo = curStateInfo.parentStateInfo;            }            // Empty the StateStack            mStateStackTopIndex = -1;            // 将临时栈数据反过来存到state 栈中，即S1->S2->S4 来保持堆栈先进后出的机制            moveTempStateStackToStateStack();        }

        2.2 状态切换

        SateMachine 提供的方法是：

protected final void transitionTo(IState destState) {        mSmHandler.transitionTo(destState);    }

       mSmHandler 提供的方法是：

 private final void transitionTo(IState destState) {            mDestState = (State) destState;        }

       从中可以看出mSmHandler只是记录了一下切换到的目的状态，真正的切换实现在performTransitions 中。

 private void performTransitions() {                       State destState = null;            while (mDestState != null) {                               destState = mDestState;                mDestState = null;                //当前状态切换了存在于mStateStack中的State需要改变　　　　       //仍然按照链式父子关系来存储　　　       　//先从当前状态S4找到 最近的被激活的parent状态S4　　　　       //未被激活的全部保存起来（S3) 返回S3                StateInfo commonStateInfo = setupTempStateStackWithStatesToEnter(destState);                invokeExitMethods(commonStateInfo);                // 将临时栈的state修改到State栈中                int stateStackEnteringIndex = moveTempStateStackToStateStack();                invokeEnterMethods(stateStackEnteringIndex);            }        }

       mTempStateStack 原来的数据是： S4-S2-S1；mStateStack状态切换前是：S1-S2-S4 栈顶是2状态切换到S3后，mTempStateStack的数据是：S3-S2-S1；mStateStack状态是S1-S2-S3。

3. 消息分发

          mSmHandler实际是一Handler对象，消息处理函数在handleMessage方法中。

public final void handleMessage(Message msg) {　　//处理当前消息到state中去处理　　processMsg(msg);　　//消息处理完毕状态切换 更新mStateStack　　performTransitions();}

private final void processMsg(Message msg){　　//派发消息到state中去处理　　StateInfo curStateInfo = mStateStack[mStateStackTopIndex];　　while (!curStateInfo.state.processMessage(msg))　　{　　　　//当前状态mDestState 未处理该消息，交给其parent state处理　　　　curStateInfo = curStateInfo.parentStateInfo;　　　　if (curStateInfo == null){　　　　　　//此消息未被当前层次状态链处理　　　　}　　}}

       SateMachine 通过堆栈来管理State一是方便状态切换，二是实现消息的链式处理，功能强大。除此之外，SateMachine还提供处理完消息记录功能及延时消息处理功能，

在这里就不再介绍了。参考方法deferMessage，ProcessedMessages的实现。