程序博客网 > 南昌小目标网络

Android状态机源码分析

来源：互联网 发布：南昌小目标网络 编辑：程序博客网 时间：2024/06/06 02:22


转载自：http://blog.csdn.net/yangwen123/article/details/10591451


在Android系统中，经常使用状态机来处理不同状态下的行为动作。状态机是将对象的状态与行为封装在一起；可以解决庞大的分支语句带来程序阅读性差和不便于进行扩展问题，使整个结构变得更加清晰明了，降低程序管理的复杂性提高灵活度。Android系统的StateMachine机制是一个State模式的应用，StateMachine是一个分层处理消息的状态机，并且是能够有分层排列状态。


构造状态机

StateMachine的构造函数都是protected类型，不能实例化，都是由其子类进行初始化操作。StateMachine有两个重载的构造函数，一个是通过指定消息循环对象来构造状态机

[java] view plain copy
print?
  1. protected StateMachine(String name, Looper looper) {  
  2.     initStateMachine(name, looper);  
  3. }  

另一个则是直接启动一个消息循环线程来构造一个状态机

[java] view plain copy
print?
  1. protected StateMachine(String name) {  
  2.     //启动一个消息循环线程  
  3.     mSmThread = new HandlerThread(name);  
  4.     mSmThread.start();  
  5.     Looper looper = mSmThread.getLooper();  
  6.     initStateMachine(name, looper);  
  7. }  
这两种构造函数都会通过initStateMachine函数来初始化该状态机

[java] view plain copy
print?
  1. private void initStateMachine(String name, Looper looper) {  
  2.     mName = name;  
  3.     mSmHandler = new SmHandler(looper, this);  
  4. }  
初始化过程比较简单，就是将状态机名称保存到成员变量mName中，同时创建SmHandler对象，SmHandler是一个Handle对象，用于派发消息。

状态机中的每个状态使用State来封装，对于每个状态的信息又采用StateInfo来描述

StateMachine三个内部类：
1.ProcessedMessageInfo:保存已处理消息的信息;
2.ProcessedMessages:存储StateMachine最近处理的一些消息，需要保存最近处理的消息条数默认20，可以用户自己设定最大数目;
3.SmHandle是消息处理派发和状态控制切换的核心，运行在单独的线程上;

SmHandle成员变量定义：


ProcessedMessages用于保存已处理过的消息，mStateStack和mTempStateStack是一个数组栈，用于保存状态机中的链式状态关系。

mStateInfo定义为一个Hash链表，用于保存添加的所有状态。mInitialState保存初始状态，mDestState保存切换的目的状态。

建立树形层次结构状态机

在构造完一个状态机前需要向状态机中添加各种状态，StateMachine提供了addState函数来添加状态
[java] view plain copy
print?
  1. protected final void addState(State state, State parent) {  
  2.     mSmHandler.addState(state, parent);  
  3. }  
直接通过mSmHandler来完成状态添加过程
[java] view plain copy
print?
  1. private final StateInfo addState(State state, State parent) {  
  2.     if (mDbg) {  
  3.         Log.d(TAG, "addStateInternal: E state=" + state.getName()  
  4.                 + ",parent=" + ((parent == null) ? "" : parent.getName()));  
  5.     }  
  6.     StateInfo parentStateInfo = null;  
  7.     if (parent != null) {  
  8.         parentStateInfo = mStateInfo.get(parent);  
  9.         if (parentStateInfo == null) {  
  10.             // Recursively add our parent as it's not been added yet.  
  11.             parentStateInfo = addState(parent, null);  
  12.         }  
  13.     }  
  14.     StateInfo stateInfo = mStateInfo.get(state);  
  15.     if (stateInfo == null) {  
  16.         stateInfo = new StateInfo();  
  17.         mStateInfo.put(state, stateInfo);  
  18.     }  
  19.   
  20.     // Validate that we aren't adding the same state in two different hierarchies.  
  21.     if ((stateInfo.parentStateInfo != null) &&  
  22.             (stateInfo.parentStateInfo != parentStateInfo)) {  
  23.             throw new RuntimeException("state already added");  
  24.     }  
  25.     stateInfo.state = state;  
  26.     stateInfo.parentStateInfo = parentStateInfo;  
  27.     stateInfo.active = false;  
  28.     if (mDbg) Log.d(TAG, "addStateInternal: X stateInfo: " + stateInfo);  
  29.     return stateInfo;  
  30. }  
状态添加过程其实就是为每个State创建相应的StateInfo对象，通过该对象来建立各个状态之间的关系，并且一个State-StateInfo键值对的方式保存到mStateInfo Hash表中。StateInfo就是包装State组成一个Node，建立State的父子关系；mStateInfo =new HashMap<State, StateInfo>();用来保存State Machine中的所有State，可以按照树形层次结构组织状态机中的所有状态
接下来介绍构造以下树形状态机的过程：
[java] view plain copy
print?
  1. sm.addState(S0,null);  
  2. sm.addState(S1,S0);  
  3. sm.addState(S2,S0);  
  4. sm.addState(S3,S1);  
  5. sm.addState(S4,S1);  
  6. sm.addState(S5,S2);  
  7. sm.addState(S6,S2);  
  8. sm.addState(S7,S2);  
  9. setInitialState(S4);      //设置初始状态  
1.添加根节点状态过程
对于根节点状态的加入sm.addState(S0,null)代码执行如下：
[java] view plain copy
print?
  1. private final StateInfo addState(S0,null)   
  2. {  
  3.     StateInfo parentStateInfo = null;  
  4.     //状态S0还未加入状态机中  
  5.     StateInfo stateInfo = mStateInfo.get(state);  
  6. 　　if (stateInfo == null) {  
  7. 　　　　//创建State详细信息对象  
  8. 　　　　stateInfo = new StateInfo();  
  9.         //将S0加入状态机中  
  10. 　　　　mStateInfo.put(state, stateInfo);  
  11. 　　}  
  12. 　　//设置状态S0的状态信息  
  13. 　   stateInfo.state = state;  
  14.     //S0的父节点为null  
  15. 　   stateInfo.parentStateInfo = parentStateInfo;  
  16. 　　stateInfo.active = false;  
  17. 　　return stateInfo;  
  18. }  
2.添加树枝节点状态过程
对于子节点S1状态的加入过程如下sm.addState(S1,S0)：
[java] view plain copy
print?
  1. private final StateInfo addState(State state, State parent)   
  2. {  
  3. 　　StateInfo parentStateInfo = null;  
  4.     //状态S0在前面已经加入状态机中了  
  5. 　　if (parent != null) {  
  6. 　　　　//获取S0详细信息 StateInfo  
  7.         parentStateInfo = mStateInfo.get(parent);  
  8.         //因为S0已经存在于状态机中，因此这里不为空  
  9. 　　　　if (parentStateInfo == null) {  
  10. 　　　　　　//当前状态父状态未加入到StateMachine中，递归先加入其父State  
  11. 　　　　　　parentStateInfo = addState(parent, null);  
  12. 　　　　}  
  13. 　　}  
  14. 　　//从状态机中得到S1的状态信息，由于S1还为加入状态机，因此得到的结果为空  
  15. 　　StateInfo stateInfo = mStateInfo.get(state);  
  16. 　　if (stateInfo == null) {  
  17. 　　　　//创建State详细信息对象  
  18. 　　　　stateInfo = new StateInfo();  
  19.         //将S1加入状态机中  
  20. 　　　　mStateInfo.put(state, stateInfo);  
  21. 　　}  
  22. 　　//S1的状态信息刚创建，还没有为其设置父节点，因此其父节点为空  
  23. 　　if ((stateInfo.parentStateInfo != null) &&  
  24. 　　　　(stateInfo.parentStateInfo != parentStateInfo)) {  
  25. 　　　　　　throw new RuntimeException("state already added");  
  26. 　　}  
  27. 　　//设置状态S1的状态信息  
  28. 　   stateInfo.state = state;  
  29.     //S1的父节点为S0  
  30. 　   stateInfo.parentStateInfo = parentStateInfo;  
  31. 　　stateInfo.active = false;  
  32. 　　return stateInfo;  
  33. }  
对于其他树枝节点的添加过程类似，这里不在介绍，最后保存在mStateInfo表中的所有状态之间就建立了以下树形关系：


启动状态机

当向状态机中添加完所有状态时，通过函数start函数来启动状态机
[java] view plain copy
print?
  1. public void start() {  
  2.     // mSmHandler can be null if the state machine has quit.  
  3.     if (mSmHandler == null) return;  
  4.     /** Send the complete construction message */  
  5.     mSmHandler.completeConstruction();  
  6. }  
调用mSmHandler的completeConstruction函数来完成状态机的构造完成处理
[java] view plain copy
print?
  1. private final void completeConstruction() {  
  2.     if (mDbg) Log.d(TAG, "completeConstruction: E");  
  3.     //查找状态树的深度  
  4.     int maxDepth = 0;  
  5.     for (StateInfo si : mStateInfo.values()) {  
  6.         int depth = 0;  
  7.         //根据父子关系计算树枝层次数  
  8.         for (StateInfo i = si; i != null; depth++) {  
  9.             i = i.parentStateInfo;  
  10.         }  
  11.         if (maxDepth < depth) {  
  12.             maxDepth = depth;  
  13.         }  
  14.     }  
  15.     if (mDbg) Log.d(TAG, "completeConstruction: maxDepth=" + maxDepth);  
  16.     //创建mStateStack，mTempStateStack状态栈  
  17.     mStateStack = new StateInfo[maxDepth];  
  18.     mTempStateStack = new StateInfo[maxDepth];  
  19.     //设置状态堆栈  
  20.     setupInitialStateStack();  
  21.     /** Sending SM_INIT_CMD message to invoke enter methods asynchronously */  
  22.     sendMessageAtFrontOfQueue(obtainMessage(SM_INIT_CMD, mSmHandlerObj));  
  23.     if (mDbg) Log.d(TAG, "completeConstruction: X");  
  24. }  
计算状态树的最大深度方法：
1.遍历状态树中的所有节点；
2.以每一个节点为起始点，根据节点父子关系查找到根节点；
3.累计起始节点到根节点之间的节点个数；查找最大的节点个数。
根据查找到的树的最大节点个数来创建两个状态堆栈，并调用函数setupInitialStateStack来填充该堆栈
[java] view plain copy
print?
  1. private final void setupInitialStateStack() {  
  2.     //在mStateInfo中取得初始状态mInitialState对应的StateInfo  
  3.     StateInfo curStateInfo = mStateInfo.get(mInitialState);  
  4.     //从初始状态mInitialState开始根据父子关系填充mTempStateStack堆栈  
  5.     for (mTempStateStackCount = 0; curStateInfo != null; mTempStateStackCount++) {  
  6.         mTempStateStack[mTempStateStackCount] = curStateInfo;  
  7.         curStateInfo = curStateInfo.parentStateInfo;  
  8.     }  
  9.     // Empty the StateStack  
  10.     mStateStackTopIndex = -1;  
  11.     //将mTempStateStack中的状态按反序方式移动到mStateStack栈中  
  12.     moveTempStateStackToStateStack();  
  13. }  
从上图可以看出，当初始状态为S4时，保存到mTempStateStack的节点为：
mTempStateStack={S4,S1,S0}
mTempStateStackCount = 3;
mStateStackTopIndex = -1;
然后调用函数moveTempStateStackToStateStack将节点以反序方式保存到mStateStack中
[java] view plain copy
print?
  1. private final int moveTempStateStackToStateStack() {  
  2.     //startingIndex= 0  
  3.     int startingIndex = mStateStackTopIndex + 1;  
  4.     int i = mTempStateStackCount - 1;  
  5.     int j = startingIndex;  
  6.     while (i >= 0) {  
  7.         if (mDbg) Log.d(TAG, "moveTempStackToStateStack: i=" + i + ",j=" + j);  
  8.         mStateStack[j] = mTempStateStack[i];  
  9.         j += 1;  
  10.         i -= 1;  
  11.     }  
  12.     mStateStackTopIndex = j - 1;  
  13.     return startingIndex;  
  14. }  
mStateStack={S0,S1,S4}
mStateStackTopIndex = 2
初始化完状态栈后，SmHandler将向消息循环中发送一个SM_INIT_CMD消息
[java] view plain copy
print?
  1. sendMessageAtFrontOfQueue(obtainMessage(SM_INIT_CMD, mSmHandlerObj))  
该消息对应的处理如下：
[java] view plain copy
print?
  1. else if (!mIsConstructionCompleted &&(mMsg.what == SM_INIT_CMD) && (mMsg.obj == mSmHandlerObj)) {  
  2.     mIsConstructionCompleted = true;  
  3.     invokeEnterMethods(0);  
  4. }  
  5. performTransitions();  
消息处理过程首先调用invokeEnterMethods函数将mStateStack栈中的所有状态设置为激活状态，同时调用每一个状态的enter()函数
[java] view plain copy
print?
  1. private final void invokeEnterMethods(int stateStackEnteringIndex) {  
  2.     for (int i = stateStackEnteringIndex; i <= mStateStackTopIndex; i++) {  
  3.         if (mDbg) Log.d(TAG, "invokeEnterMethods: " + mStateStack[i].state.getName());  
  4.         mStateStack[i].state.enter();  
  5.         mStateStack[i].active = true;  
  6.     }  
  7. }  
最后调用performTransitions函数来切换状态，同时设置mIsConstructionCompleted为true，表示状态机已经启动完成，SmHandler在以后的消息处理过程中就不在重新启动状态机了。

状态切换


SmHandler在处理每个消息时都会调用performTransitions来检查状态切换
[java] view plain copy
print?
  1. private synchronized void performTransitions() {  
  2. 　　while (mDestState != null){  
  3. 　　　　//当前状态切换了 存在于mStateStack中的State需要改变  
  4. 　　　　//仍然按照链式父子关系来存储  
  5. 　　　　//先从当前状态S3找到 最近的被激活的parent状态S0  
  6. 　　　　//未被激活的全部保存起来(S3,S1) 返回S0  
  7. 　　　　StateInfo commonStateInfo = setupTempStateStackWithStatesToEnter(destState);  
  8. 　　　　//将mStateStack中 不属于当前状态(S3)，  
  9. 　　　　//关系链上的State(S5,S2)退出(执行exit方法)  
  10. 　　　　invokeExitMethods(commonStateInfo);  
  11. 　　　　//将S3关系链 加入到栈中(S3,S1)  
  12. 　　　　int stateStackEnteringIndex = moveTempStateStackToStateStack();  
  13. 　　　　//将新加入到mStateStack中 未被激活的State激活(S3,S1)  
  14. 　　　　invokeEnterMethods(stateStackEnteringIndex);  
  15. 　　　　//将延迟的消息移动到消息队列的前面，以便快速得到处理                 
  16. 　　　　moveDeferredMessageAtFrontOfQueue();  
  17. 　　}  
  18. }  
首先介绍一下状态切换的思路：

以上图中，初始状态为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函数，同时设置为激活状态。
理解了整个状态切换过程后，就能更好地理解代码，首先根据目标状态建立状态节点链路表
[java] view plain copy
print?
  1. private final StateInfo setupTempStateStackWithStatesToEnter(State destState) {  
  2.     mTempStateStackCount = 0;  
  3.     StateInfo curStateInfo = mStateInfo.get(destState);  
  4.     do {  
  5.         mTempStateStack[mTempStateStackCount++] = curStateInfo;  
  6.         if (curStateInfo != null) {  
  7.             curStateInfo = curStateInfo.parentStateInfo;  
  8.         }  
  9.     } while ((curStateInfo != null) && !curStateInfo.active);  
  10.     return curStateInfo;  
  11. }  
然后弹出mStateStack中保存的原始状态
[java] view plain copy
print?
  1. private final void invokeExitMethods(StateInfo commonStateInfo) {  
  2.     while ((mStateStackTopIndex >= 0) &&  
  3.             (mStateStack[mStateStackTopIndex] != commonStateInfo)) {  
  4.         State curState = mStateStack[mStateStackTopIndex].state;  
  5.         if (mDbg) Log.d(TAG, "invokeExitMethods: " + curState.getName());  
  6.         curState.exit();  
  7.         mStateStack[mStateStackTopIndex].active = false;  
  8.         mStateStackTopIndex -= 1;  
  9.     }  
  10. }  
将新建立的状态节点链表保存到mStateStack栈中
[java] view plain copy
print?
  1. private final int moveTempStateStackToStateStack() {  
  2.     //startingIndex= 0  
  3.     int startingIndex = mStateStackTopIndex + 1;  
  4.     int i = mTempStateStackCount - 1;  
  5.     int j = startingIndex;  
  6.     while (i >= 0) {  
  7.         if (mDbg) Log.d(TAG, "moveTempStackToStateStack: i=" + i + ",j=" + j);  
  8.         mStateStack[j] = mTempStateStack[i];  
  9.         j += 1;  
  10.         i -= 1;  
  11.     }  
  12.     mStateStackTopIndex = j - 1;  
  13.     return startingIndex;  
  14. }  
初始化入栈的所有新状态，并设置为激活状态
[java] view plain copy
print?
  1. private final void invokeEnterMethods(int stateStackEnteringIndex) {  
  2.     for (int i = stateStackEnteringIndex; i <= mStateStackTopIndex; i++) {  
  3.         if (mDbg) Log.d(TAG, "invokeEnterMethods: " + mStateStack[i].state.getName());  
  4.         mStateStack[i].state.enter();  
  5.         mStateStack[i].active = true;  
  6.     }  
  7. }  
如何设置目标状态呢？StateMachine提供了transitionTo函数来切换状态
[java] view plain copy
print?
  1. protected final void transitionTo(IState destState) {  
  2.     mSmHandler.transitionTo(destState);  
  3. }  
该函数直接调用SmHandler的transitionTo函数来实现，SmHandler的transitionTo函数定义如下：
[java] view plain copy
print?
  1. private final void transitionTo(IState destState) {  
  2.     mDestState = (State) destState;  
  3.     if (mDbg) Log.d(TAG, "transitionTo: destState=" + mDestState.getName());  
  4. }  
这里只是简单地设置了mDestState变量，并未真正更新状态栈mStateStack，在前面介绍了SmHandler在每次处理消息时都会自动更新一次mStateStack，无论mDestState变量值是否改变。由此可知目标状态的设置与状态栈的更新是异步的。

消息处理


StateMachine处理的核心就是SmHandler，就是一个Handler，运行在单独线程中。Handler是用来异步处理派发消息，这里使用Handler管理各个状态，派发消息处理到各个状态中去执行。StateMachine提供了多个消息发送接口，通过这些接口函数可以将消息发送到SmHandler中。
[java] view plain copy
print?
  1. public final void sendMessage(int what) {  
  2.     // mSmHandler can be null if the state machine has quit.  
  3.     if (mSmHandler == null) return;  
  4.     mSmHandler.sendMessage(obtainMessage(what));  
  5. }  
SmHandler将处理通过SmHandler发送的消息，处理过程如下：
[java] view plain copy
print?
  1. public final void handleMessage(Message msg) {  
  2.     /** Save the current message */  
  3.     mMsg = msg;  
  4.     if (mIsConstructionCompleted) {  
  5.         //派发当前消息到state中去处理  
  6.         processMsg(msg);  
  7.     } else if (!mIsConstructionCompleted &&  
  8.             (mMsg.what == SM_INIT_CMD) && (mMsg.obj == mSmHandlerObj)) {  
  9.         /** Initial one time path. */  
  10.         mIsConstructionCompleted = true;  
  11.         invokeEnterMethods(0);  
  12.     } else {  
  13.         throw new RuntimeException("StateMachine.handleMessage: " +  
  14.                     "The start method not called, received msg: " + msg);  
  15.     }  
  16.     //消息处理完毕更新mStateStack  
  17.     performTransitions();  
  18. }  
变量mIsConstructionCompleted在状态机启动完成后被设置为true，因此这里将调用processMsg函数来完成消息处理。
[java] view plain copy
print?
  1. private final void processMsg(Message msg) {  
  2.     StateInfo curStateInfo = mStateStack[mStateStackTopIndex];  
  3.     //如果当前状态未处理该消息  
  4.     while (!curStateInfo.state.processMessage(msg)) {  
  5.         //将消息传给当前状态的父节点处理  
  6.         curStateInfo = curStateInfo.parentStateInfo;  
  7.         if (curStateInfo == null) {  
  8.              //当前状态无父几点，则丢弃该消息  
  9.             mSm.unhandledMessage(msg);  
  10.             if (isQuit(msg)) {  
  11.                 transitionTo(mQuittingState);  
  12.             }  
  13.             break;  
  14.         }  
  15.     }  
  16.     //记录处理过的消息  
  17.     if (mSm.recordProcessedMessage(msg)) {  
  18.         if (curStateInfo != null) {  
  19.             State orgState = mStateStack[mStateStackTopIndex].state;  
  20.             mProcessedMessages.add(msg, mSm.getMessageInfo(msg), curStateInfo.state,orgState);  
  21.         } else {  
  22.             mProcessedMessages.add(msg, mSm.getMessageInfo(msg), null, null);  
  23.         }  
  24.     }  
  25. }  
消息处理过程是从mStateStack栈顶派发到栈底，直到该消息被处理！

阅读全文
0 0
南昌小目标网络 南昌小目标网络
原创粉丝点击
热门IT博客
淘宝阿狸下单截图淘宝阿狸下单截图
便携式网络测试仪便携式网络测试仪
mac 10.12 dns flush
c语言的书哪本比较好
ipad视频加密软件
白银投资实时数据
软件开发英语面试
机智云怎么样 知乎
淘宝如何设置自动回复
程序员常用浏览器
vscode golang debug
bec和托业哪个好 知乎
源码编译内核配置
sql语句去重 distinct
sem优化师(ka)是什么
淘宝售后评价
权重优化
后端数据库
小贷公司软件
淘宝图片保护怎么开通
热门问题 老师的惩罚 人脸识别 我在镇武司摸鱼那些年 重生之率土为王 我在大康的咸鱼生活 盘龙之生命进化 天生仙种 凡人之先天五行 春回大明朝 姑娘不必设防，我是瞎子 交增值税怎么做账 合伙做生意怎么做账 未开票收入如何做账 小规模公司怎么做账 个人所得税怎么做账 小规模企业怎么做账 刚成立的公司怎么做账 个人所得税如何做账 低值易耗品如何做账 一般纳税人怎么做账 减免的增值税怎么做账 车辆保险费怎么做账 刚注册的公司怎么做账 缴纳增值税怎么做账 小规模纳税人怎么做账 车辆购置税怎么做账 车辆购置税如何做账 小规模纳税人要做账吗 小规模纳税人需要做账吗 桂花酒怎么做 高铁可以带酒 2018做火车带酒新规定 家庭制作酒枣怎么做 甜酒怎么做 13种水果做水果酒 高铁带酒 做个月子千万别喝糯米甜酒 石榴酒怎么做 辣蓼草做酒曲配方 糯米酒怎么做 甜酒 做高铁可以带酒吗 做甜酒 石榴做酒 做酒设备多少钱小型 酒曲怎么做 家庭做甜酒的方法 怎样做甜酒 正宗绍兴酒醉蟹怎么做 做满月酒邀请函怎么写 做一次喉镜取一根鱼刺多少钱

程序博客网，程序员的互联网技术博客家园。csdn论坛精品 msdn技术资料都在这里