StateMachine 的简单使用
步骤
- 源码的frameworks/base/core/java/com/android/internal/util里面把StateMachine.java 、State.java 、IState.java复制到project目录中
- 自定义StateMachine类继承StateMachine
- 自定义状态State继承State：重写enter、processMsg、exit
- 设置更新状态常量,用于状态更新
- addState加入父状态、子状态，setInitialState初始化状态
- start启动状态机stateMachine
- 使用状态机，发送持有更新状态常量的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分析
-
addState为每个State创建相应的StateInfo对象，通过该对象来建立各个状态之间的关系，并且一个State-StateInfo键值对的方式保存到mStateInfo Hash表中。
- StateInfo就是包装State组成一个Node，建立State的父子关系；
- mStateInfo =new HashMap
-
start()调用SmHander的completeConstruction；
- 计算状态树的最大深度;
- 根据查到的树的最大节点个数创建两个状态堆栈mStateStack,mTempStateStack，调用setupInitialStateStack填充该堆栈;
- 初始化完状态栈后，SmHandler将向消息循环中发送一个SM_INIT_CMD消息;
- handleMessage消息处理过程SmHandler首先设置mIsConstructionCompleted为true，表示状态机已经启动完成，SmHandler在以后的消息处理过程中就不在重新启动状态机了。然后调用invokeEnterMethods函数将mStateStack栈中的所有状态设置为激活状态，同时调用每一个状态的enter()函数;
- 最后调用performTransitions函数来切换状态，
-
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();
}
}
- 接收消息处理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
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方法。
首先介绍一下状态切换的思路：
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);
}
}
}