最近研究了一下WifiStateMachine，发现它主要继承了StateMachine，这里根据StateMachine文件的英文文档进行翻译。

1. 这个State Machine是一个层级状态机

下面是我移动这个statemachine到安卓应用上面来进行调试的版本：

点击下载：  测试代码

2.每一个状态都是state结构体的一个子类实现

每个子类都必须实现state的processMessage函数，其余的enter/exit/getName是可选实现的。

enter/exit这种实现方式和面向对象的构造函数和析构函数很像。知道它的原理就行了。

3.状态机的创建

通过addState可以把所以状态和这个状态的依赖关系添加到状态机里面去。最终就会形成一个相互依赖的树结构。

然后再通过setInitialState设置状态机的初始状态。以后的状态机就从这里开始。

最后调用start函数启动状态机，这个方法会调用和当前状态有关的所有enter方法，而且调用顺序从第一个父节点开始，这个其实和面向对象的构造方法的调用很像。

比如说有如下的三个状态，

mP1

/           \

mS2      mS1 ----> initial state

那么这棵树需要这样来创建：

addState(mS2,mP1);

addState(mS1,mP1);

setInitialState(mS1);

start();

其中初始状态是mS1,调用start后

enter的调用顺序是mP1->enter();,mS1->enter();

4.状态机的转换

调用transitionTo函数用于状态机的转换。转换的过程中遵循如下的原则。

比较当前的状态的父状态是否和要切换的有一样的，如果有一样，假设他是mP1：就调用当前状态一直到mP1(不包括)的exit函数，然后再冲mP1到新状态的所有节点的enter.

比较当前的状态的父状态是否和要切换的有一样的，如果不一样，就调用当前状态的exit函数，以及其所有父状态的exit函数，然后再从新状态的第一个父状态的enter函数一直调用到当前状态enter。

5.消息处理

涉及到消息处理如果做过安卓应用的都知道有一个叫Handler的东西，这个东西会和一个线程结合起来工作。其实stateMachine的处理方法就用的这个机制。只不过进行了功能多的包装而已。

要给当前状态发送消息时只需要调用sendMessage就可以了，当然还要构造消息，这里用obtainMessage，其实这两个函数就是Handler的包装。

当消息发送后就会调用当前状态的processMessage函数，这里它有三种处理办法：

(1). 如果自己处理不了就返回false 或者 NOT_HANDLED.这样stateMachine就会去调用它的父亲的processMessage，直到处理成功或者最终都没有调用那么unhandledMessage()会被调用。

(2).如果所有的状态都完成了就会调用transitionToHaltingState，调用了它之后，所有的消息都由transitionToHaltingState来处理了。

(3).如果当前消息自己还是没法处理，需要切换到其他状态处理，那么它可以调用deferMessage这样可以把当前的消息保存直到状态切换后处理的第一个消息里面。

最后是谷歌的例子：

class Hsm1 extends StateMachine {

private static final String TAG = "hsm1";

public static final int CMD_1 = 1;

public static final int CMD_2 = 2;

public static final int CMD_3 = 3;

public static final int CMD_4 = 4;

public static final int CMD_5 = 5;

public static Hsm1 makeHsm1() {

Log.d(TAG, "makeHsm1 E");

Hsm1 sm = new Hsm1("hsm1");

sm.start();

Log.d(TAG, "makeHsm1 X");

return sm;

}

Hsm1(String name) {

super(name);

Log.d(TAG, "ctor E");

// Add states, use indentation to show hierarchy

addState(mP1);

addState(mS1, mP1);

addState(mS2, mP1);

addState(mP2);

// Set the initial state

setInitialState(mS1);

Log.d(TAG, "ctor X");

}

class P1 extends State {

@Override public void enter() {

Log.d(TAG, "mP1.enter");

}

@Override public boolean processMessage(Message message) {

boolean retVal;

Log.d(TAG, "mP1.processMessage what=" + message.what);

switch(message.what) {

case CMD_2:

// CMD_2 will arrive in mS2 before CMD_3

sendMessage(obtainMessage(CMD_3));

deferMessage(message);

transitionTo(mS2);

retVal = HANDLED;

break;

default:

// Any message we don't understand in this state invokes unhandledMessage

retVal = NOT_HANDLED;

break;

}

return retVal;

}

@Override public void exit() {

Log.d(TAG, "mP1.exit");

}

}

class S1 extends State {

@Override public void enter() {

Log.d(TAG, "mS1.enter");

}

@Override public boolean processMessage(Message message) {

Log.d(TAG, "S1.processMessage what=" + message.what);

if (message.what == CMD_1) {

// Transition to ourself to show that enter/exit is called

transitionTo(mS1);

return HANDLED;

} else {

// Let parent process all other messages

return NOT_HANDLED;

}

}

@Override public void exit() {

Log.d(TAG, "mS1.exit");

}

}

class S2 extends State {

@Override public void enter() {

Log.d(TAG, "mS2.enter");

}

@Override public boolean processMessage(Message message) {

boolean retVal;

Log.d(TAG, "mS2.processMessage what=" + message.what);

switch(message.what) {

case(CMD_2):

sendMessage(obtainMessage(CMD_4));

retVal = HANDLED;

break;

case(CMD_3):

deferMessage(message);

transitionTo(mP2);

retVal = HANDLED;

break;

default:

retVal = NOT_HANDLED;

break;

}

return retVal;

}

@Override public void exit() {

Log.d(TAG, "mS2.exit");

}

}

class P2 extends State {

@Override public void enter() {

Log.d(TAG, "mP2.enter");

sendMessage(obtainMessage(CMD_5));

}

@Override public boolean processMessage(Message message) {

Log.d(TAG, "P2.processMessage what=" + message.what);

switch(message.what) {

case(CMD_3):

break;

case(CMD_4):

break;

case(CMD_5):

transitionToHaltingState();

break;

}

return HANDLED;

}

@Override public void exit() {

Log.d(TAG, "mP2.exit");

}

}

@Override

void halting() {

Log.d(TAG, "halting");

synchronized (this) {

this.notifyAll();

}

}

P1 mP1 = new P1();

S1 mS1 = new S1();

S2 mS2 = new S2();

P2 mP2 = new P2();

}它所构造的树结构：

mP1                 mP2

/           \

mS2   mS1

如果用下面的代码开始状态机：

Hsm1 hsm = hsm.makeHsm1();

synchronize(hsm) {

hsm.sendMessage(hsm.obtainMessage(hsm.CMD_1)); hsm.sendMessage(hsm.obtainMessage(hsm.CMD_2)); try { // wait for the messages to be handled hsm.wait(); } catch (InterruptedException e) { Log.e(TAG, "exception while waiting " + e.getMessage()); }}

最后输出：D/hsm1    ( 1999): makeHsm1 ED/hsm1    ( 1999): ctor ED/hsm1    ( 1999): ctor XD/hsm1    ( 1999): mP1.enterD/hsm1    ( 1999): mS1.enterD/hsm1    ( 1999): makeHsm1 XD/hsm1    ( 1999): mS1.processMessage what=1D/hsm1    ( 1999): mS1.exitD/hsm1    ( 1999):

mS1.enterD/hsm1    ( 1999): mS1.processMessage what=2D/hsm1    ( 1999): mP1.processMessage what=2D/hsm1    ( 1999): mS1.exitD/hsm1    ( 1999): mS2.enterD/hsm1    ( 1999): mS2.processMessage what=2D/hsm1    ( 1999): mS2.processMessage what=3D/hsm1    ( 1999):

mS2.exitD/hsm1    ( 1999): mP1.exitD/hsm1    ( 1999): mP2.enterD/hsm1    ( 1999): mP2.processMessage what=3D/hsm1    ( 1999): mP2.processMessage what=4D/hsm1    ( 1999): mP2.processMessage what=5D/hsm1    ( 1999): mP2.exitD/hsm1    ( 1999): halting