StateMachine 的简单使用

---

步骤

1. 源码的frameworks/base/core/java/com/android/internal/util里面把StateMachine.java 、State.java 、IState.java复制到project目录中
2. 自定义StateMachine类继承StateMachine
   • 自定义状态State继承State：重写enter、processMsg、exit
   • 设置更新状态常量,用于状态更新
   • addState加入父状态、子状态，setInitialState初始化状态
   • start启动状态机stateMachine
3. 使用状态机，发送持有更新状态常量的Msg

Demo

public class PersonStateMachine extends StateMachine {

    //设置状态改变标志常量
    public static final int MSG_WAKEUP = 1;
    public static final int MSG_TIRED = 2;
    public static final int MSG_HUNGRY = 3;
    private static final int MSG_HALTING = 4;

    //创建状态
    private State mBoringState = new BoringState();
    private State mWorkState = new WorkState();
    private State mEatState = new EatState();
    private State mSleepState = new SleepState();


    PersonStateMachine(String name) {
        super(name);
        //加入状态，初始化状态
        addState(mBoringState, null);
        addState(mSleepState, mBoringState);
        addState(mWorkState, mBoringState);
        addState(mEatState, mBoringState);

        setInitialState(mSleepState); // sleep状态为初始状态
        start(); // 状态机进入初始状态等候外界的命令

    }

    /**
     * @return 创建启动person 状态机
     */
    public static PersonStateMachine makePerson() {
        PersonStateMachine person = new PersonStateMachine("Person");
        person.start();
        return person;
    }


    //定义状态:无聊,睡觉，工作，吃饭

    class BoringState extends State {

        @Override
        public boolean processMessage(Message msg) {
            Log.d("BoringState", "boring.....");
            return true;
        }
    }

    class SleepState extends State {
        @Override
        public void enter() {
            Log.d("SleepState", "enter Sleep");
        }

        @Override
        public boolean processMessage(Message msg) {
            switch (msg.what) {
                case MSG_WAKEUP:
                    //睡觉醒了去工作，工作的时候收到饿了的讯号
                    sendMessage(obtainMessage(MSG_HUNGRY));
                    deferMessage(msg);
                    transitionTo(mWorkState);
                    break;
                case MSG_HALTING:
                    transitionToHaltingState();
                    break;
                default:
                    return false;
            }
            return true;
        }

        @Override
        public void exit() {
            Log.d("SleepState", "exit Sleep");
        }
    }

    @Override
    protected void onHalting() {
        Log.d("PersonStateMachine", "halting");
        synchronized (this) {
            this.notifyAll();
        }
    }

    class WorkState extends State {
        @Override
        public void enter() {
            Log.d("WorkState", "enter Work");
        }

        @Override
        public boolean processMessage(Message msg) {
            switch (msg.what) {
                case MSG_HUNGRY:
                    //工作饿了去吃饭，吃饭的时候收到累了的讯号
                    sendMessage(obtainMessage(MSG_TIRED));
                    deferMessage(msg);
                    transitionTo(mEatState);
                    break;
                default:
                    return false;
            }
            return true;
        }

        @Override
        public void exit() {
            Log.d("WorkState", "exit Work");
        }
    }

    class EatState extends State {
        @Override
        public void enter() {
            Log.d("EatState", "enter Eat");
        }

        @Override
        public boolean processMessage(Message msg) {
            switch (msg.what) {
                case MSG_TIRED:
                    //吃饭吃累了去睡觉，睡觉的时候收到结束的讯号
                    sendMessage(obtainMessage(MSG_HALTING));
                    deferMessage(msg);
                    transitionTo(mSleepState);
                    break;
                default:
                    return false;
            }
            return true;
        }

        @Override
        public void exit() {
            Log.d("EatState", "exit Eat");
        }
    }

}

输出结果

• 08-31 10:44:04.559 10555-10638/com.example.justi.googlestatemachinedemo D/SleepState: enter Sleep
• 08-31 10:44:04.559 10555-10638/com.example.justi.googlestatemachinedemo D/BoringState: boring.....
• 08-31 10:44:04.569 10555-10638/com.example.justi.googlestatemachinedemo D/SleepState: exit Sleep
• 08-31 10:44:04.569 10555-10638/com.example.justi.googlestatemachinedemo D/WorkState: enter Work
• 08-31 10:44:04.569 10555-10638/com.example.justi.googlestatemachinedemo D/BoringState: boring.....
• 08-31 10:44:04.569 10555-10638/com.example.justi.googlestatemachinedemo D/WorkState: exit Work
• 08-31 10:44:04.569 10555-10638/com.example.justi.googlestatemachinedemo D/EatState: enter Eat
• 08-31 10:44:04.569 10555-10638/com.example.justi.googlestatemachinedemo D/BoringState: boring.....
• 08-31 10:44:04.569 10555-10638/com.example.justi.googlestatemachinedemo D/EatState: exit Eat
• 08-31 10:44:04.569 10555-10638/com.example.justi.googlestatemachinedemo D/SleepState: enter Sleep
• 08-31 10:44:04.569 10555-10638/com.example.justi.googlestatemachinedemo D/BoringState: boring.....
• 08-31 10:44:04.569 10555-10638/com.example.justi.googlestatemachinedemo D/SleepState: exit Sleep
• 08-31 10:44:04.569 10555-10638/com.example.justi.googlestatemachinedemo D/PersonStateMachine: halting

Demo分析

1. addState为每个State创建相应的StateInfo对象，通过该对象来建立各个状态之间的关系，并且一个State-StateInfo键值对的方式保存到mStateInfo Hash表中。

   • StateInfo就是包装State组成一个Node，建立State的父子关系；
   • mStateInfo =new HashMap<State, StateInfo>();用来保存State Machine中的所有State，可以按照树形层次结构组织状态机中的所有状态；

2. start()调用SmHander的completeConstruction；

   • 计算状态树的最大深度;
   • 根据查到的树的最大节点个数创建两个状态堆栈mStateStack,mTempStateStack，调用setupInitialStateStack填充该堆栈;
   • 初始化完状态栈后，SmHandler将向消息循环中发送一个SM_INIT_CMD消息;
   • handleMessage消息处理过程SmHandler首先设置mIsConstructionCompleted为true，表示状态机已经启动完成，SmHandler在以后的消息处理过程中就不在重新启动状态机了。然后调用invokeEnterMethods函数将mStateStack栈中的所有状态设置为激活状态，同时调用每一个状态的enter()函数;
   • 最后调用performTransitions函数来切换状态，

3. performTransitions切换状态

   • 处理完消息后(processMessage)，根据SmHandler中的标记mDestState进行状态路径切换（对外提供transitionTo接口方法改变mDestState），状态切换主要是执行原状态的exit方法和enter方法。
   • 首先介绍一下状态切换的思路：

     以上图中，初始状态为S4，现在目标状态mDestState被设置为S7。

   • 首先如果保存在mStateStack数组中的节点为:
     • mStateStack={S0,S1,S4}
     • mStateStackTopIndex = 2
   • 这是以初始状态节点为起点遍历节点树得到的节点链表。
     现在要切换到S7状态节点，则以S7为起始节点，同样遍历状态节点树，查找未激活的所有节点，并保存到mTempStateStack数组中
     • mTempStateStack={S7,S2,S0}
     • mTempStateStackCount = 3
   • 接着调用mStateStack中除S0节点外的其他所有节点的exit函数，并且将每个状态节点设置为未激活状态，因此S4，S1被设置为未激活状态；将切换后的状态节点链表mTempStateStack移动到mStateStack，
     • mStateStack={S0,S2,S7}
     • mStateStackTopIndex = 2

   并调用节点S2，S7的enter函数，同时设置为激活状态。

        //简化的源码
        private void performTransitions() 
        {
        　　while (mDestState != null)
        　　{
        　　　　//当前状态切换了 存在于mStateStack中的State需要改变
        　　　　//仍然按照链式父子关系来存储
        　　　　//先从当前状态S3找到 最近的被激活的parent状态S0
        　　　　//未被激活的全部保存起来(S3,S1) 返回S0
        　　　　StateInfo commonStateInfo = setupTempStateStackWithStatesToEnter(destState);
        
        　　　　//将mStateStack中 不属于当前状态(S3)，
        　　　　//关系链上的State(S5,S2)退出(执行exit方法)
        　　　　invokeExitMethods(commonStateInfo);
        
        　　　　//将S3关系链 加入到栈中(S3,S1)
        　　　　int stateStackEnteringIndex = moveTempStateStackToStateStack();
        
        　　　　//将新加入到mStateStack中 未被激活的State激活(S3,S1)
        　　　　invokeEnterMethods(stateStackEnteringIndex);
        
        　　　　//将延迟的消息移动到消息队列的前面，以便快速得到处理               
        　　　　moveDeferredMessageAtFrontOfQueue();
        　　}
        }

4. 接收消息处理handleMessage

• SmHandler的主要方法,处理通过SmHandler发送的消息：：
• 通过变量mIsConstructionCompleted判断状态机是否启动，如果启动调用processMsg函数来完成消息处理，否则重新启动一次，手动调用主要的状态机启动方法

    //简化源码
      public final void handleMessage(Message msg) {
       
            if (mIsConstructionCompleted) {
                /** Normal path */
                msgProcessedState = processMsg(msg);
            } else if (!mIsConstructionCompleted && (mMsg.what == SM_INIT_CMD)
                    && (mMsg.obj == mSmHandlerObj)) {
                /** Initial one time path. */
                mIsConstructionCompleted = true;
                invokeEnterMethods(0);
            } else {
                throw new RuntimeException("StateMachine.handleMessage: "
                        + "The start method not called, received msg: " + msg);
            }
            performTransitions(msgProcessedState, msg);

          
    }

• 从mStateStack取出当前state处理，调用processMessage
  • 如果当前状态没有处理消息（processMessage返回false），那么持续调用这个状态的父状态，如果没有一个父状态处理，最后由unhandleMessage(msg)处理。

        private final State processMsg(Message msg) {
            StateInfo curStateInfo = mStateStack[mStateStackTopIndex];
            if (mDbg) {
                mSm.log("processMsg: " + curStateInfo.state.getName());
            }

            if (isQuit(msg)) {
                transitionTo(mQuittingState);
            } else {
                while (!curStateInfo.state.processMessage(msg)) {
                    /**
                     * Not processed
                     */
                    curStateInfo = curStateInfo.parentStateInfo;
                    if (curStateInfo == null) {
                        /**
                         * No parents left so it's not handled
                         */
                        mSm.unhandledMessage(msg);
                        break;
                    }
                    if (mDbg) {
                        mSm.log("processMsg: " + curStateInfo.state.getName());
                    }
                }
            }
            return (curStateInfo != null) ? curStateInfo.state : null;
        }

相关原理

Android平台中对于State模式的应用。
Context——StateMachine
State ——State
Android 状态机 类似树的继承结构，如果当前状态不能对这个事件作出响应，会到父节点继续判断响应
===》可以简单称状态路径、状态树。

State模式

---

将对象的状态封装成一个独立对象,将不同的状态下调用会执行不同的操作。
根据对象的状态改变行为采用分支语句的实现方式。

StateMachine

---

State

---

状态机中的状态封装类----实现了IState接口。

定义了状态的基本方法：enter、exit、processMessage（消息处理方法）:enter在状态机转入该状态时调用，exit方法在状态机转出该状态时调用。

构造方法声明为protect类型，其他类在状态机stateMachine只能通过StateInfo使用。

构造函数

protected类型，不能实例化，由其子类初始化操作
两个重载的构造函数：指定消息循环队列构造；新建并启动一个HandlerThread构造
都会通过initStateMachine(name,looper)初始化:指定状态机名称，创建SmHandler对象

StateMachine的三个内部类

---

LogRec类（实现了IState接口）

保存已处理Message的一些信息。
what、state、orgState、dstState...

LogRecords类

保存若干刚处理的LogRec的Vector集合

SmHandler类

---

消息处理派发和状态控制切换的核心，运行在单独的线程上
stateMachine主要工作都是SmHandler类完成，大多数方法都是对SmHandler的方法的二次封装。

stateMachine的构造函数中开启了一个特殊的子线程HandlerThread专门给SmHandler发送消息，让其处理。

成员变量

mStateInfo定义为一个Hash链表，用于保存添加的所有状态。mInitialState保存初始状态，mDestState保存切换的目的状态。
mLogRecords用于保存已处理过的消息，mStateStack和mTempStateStack是一个数组栈，用于保存状态机中的链式状态关系。

SmHandler主要的三个内部类

---

StateInfo

保存了StateInfo的基本信息
state、parentStateInfo、active

HaltingState

QuittingState

继承了State重写了processMessage方法

---

addState(State state ,State parent)

定义stateInfo，
根据传入的State从保存state和stateInfo对应关系的HashMap中获取stateInfo
注意层次结构中的子状态要加入之前，父状态没有加入会RuntimeException
状态添加过程其实就是为每个State创建相应的StateInfo对象，通过该对象来建立各个状态之间的关系，并且一个State-StateInfo键值对的方式保存到mStateInfo Hash表中。StateInfo就是包装State组成一个Node，建立State的父子关系；mStateInfo =new HashMap<State, StateInfo>();用来保存State Machine中的所有State，可以按照树形层次结构组织状态机中的所有状态

---

completeConstruction

• stateMachine.start()方法调用SmHander的completeConstruction；
• 计算状态树的最大深度;
• 根据查到的树的最大节点个数创建两个状态堆栈mStateStack,mTempStateStack，调用setupInitialStateStack填充该堆栈;
• 初始化完状态栈后，SmHandler将向消息循环中发送一个SM_INIT_CMD消息;
• 消息处理过程首先调用invokeEnterMethods函数将mStateStack栈中的所有状态设置为激活状态，同时调用每一个状态的enter()函数;
• 最后调用performTransitions函数来切换状态，同时设置mIsConstructionCompleted为true，表示状态机已经启动完成，SmHandler在以后的消息处理过程中就不在重新启动状态机了。

---

performTransitions

处理完消息后(processMessage)，根据SmHandler中的标记mDestState进行状态路径切换（对外提供transitionTo接口方法改变mDestState），状态切换主要是执行原状态的exit方法和enter方法。
首先介绍一下状态切换的思路：

以上图中，初始状态为S4，现在目标状态mDestState被设置为S7。前面介绍了保存在mStateStack数组中的节点为:
mStateStack={S0,S1,S4}
mStateStackTopIndex = 2
这是以初始状态节点为起点遍历节点树得到的节点链表。
现在要切换到S7状态节点，则以S7为起始节点，同样遍历状态节点树，查找未激活的所有节点，并保存到mTempStateStack数组中
mTempStateStack={S7,S2,S0}
mTempStateStackCount = 3
接着调用mStateStack中除S0节点外的其他所有节点的exit函数，并且将每个状态节点设置为未激活状态，因此S4，S1被设置为未激活状态；将切换后的状态节点链表mTempStateStack移动到mStateStack，
mStateStack={S0,S2,S7}
mStateStackTopIndex = 2

并调用节点S2，S7的enter函数，同时设置为激活状态。

---

transitionTo

StateMachine可以认为是处理Message的一个栈，它处理消息的顺序是可以任意变化的。
transitionTo可以设置先处理哪一个state
在相应的state的processMessage()处理
简单地设置了mDestState变量，并未真正更新状态栈mStateStack，在前面介绍了SmHandler在每次处理消息时都会自动更新一次mStateStack，无论mDestState变量值是否改变。由此可知目标状态的设置与状态栈的更新是异步的。

消息处理

SmHandler，就是一个Handler，运行在单独线程中。Handler是用来异步处理派发消息，这里使用Handler管理各个状态，派发消息处理到各个状态中去执行。StateMachine提供了多个消息发送接口，通过这些接口函数可以将消息发送到SmHandler中。
消息处理过程是从mStateStack栈顶派发到栈底，直到该消息被处理！

handlerMessage方法

---

SmHandler的主要方法,处理通过SmHandler发送的消息:
主要做了两件事：
1.将Message交给State的processMessage方法处理消息；
2.对stateStack中的state通过enter和exit处理先后顺序

状态的初始化（enter方法）、状态的处理（processMessage）、状态的转移（更新状态树）。

if (mIsConstructionCompleted) {  
    /** Normal path */  
    processMsg(msg);//第一个消息处理  
} else if (!mIsConstructionCompleted &&  
        (mMsg.what == SM_INIT_CMD) && (mMsg.obj == mSmHandlerObj)) {  
    /** Initial one time path. */  
    mIsConstructionCompleted = true;  
    invokeEnterMethods(0);//第二个状态的初始化  
} else {  
    throw new RuntimeException("StateMachine.handleMessage: " +  
                "The start method not called, received msg: " + msg);  
}  
performTransitions();//第三个执行状态转移 

processMessage

变量mIsConstructionCompleted在状态机启动完成后被设置为true，因此这里将调用processMsg函数来完成消息处理。

如果当前状态没有处理消息（processMessage返回false），那么持续调用这个状态的父状态，如果没有一个父状态处理，最后由unhandleMessage(msg)处理。

private final void processMsg(Message msg) {  
    StateInfo curStateInfo = mStateStack[mStateStackTopIndex];  
    //如果当前状态未处理该消息  
    while (!curStateInfo.state.processMessage(msg)) {  
        //将消息传给当前状态的父节点处理  
        curStateInfo = curStateInfo.parentStateInfo;  
        if (curStateInfo == null) {  
             //当前状态无父几点，则丢弃该消息  
            mSm.unhandledMessage(msg);  
            if (isQuit(msg)) {  
                transitionTo(mQuittingState);  
            }  
            break;  
        }  
    }  
    //记录处理过的消息  
    if (mSm.recordProcessedMessage(msg)) {  
        if (curStateInfo != null) {  
            State orgState = mStateStack[mStateStackTopIndex].state;  
            mProcessedMessages.add(msg, mSm.getMessageInfo(msg), curStateInfo.state,orgState);  
        } else {  
            mProcessedMessages.add(msg, mSm.getMessageInfo(msg), null, null);  
        }  
    }  
}