statemachine详解

本文参考来自：http://blog.csdn.net/lele_cheny/article/details/9289905

代码分析：

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 onHalting() {
        Log.d(TAG, "halting");
        synchronized (this) {
            this.notifyAll();
        }
    }


    P1 mP1 = new P1();
    S1 mS1 = new S1();
    S2 mS2 = new S2();
    P2 mP2 = new P2();
}


</code>
 * <p>If this is executed by sending two messages CMD_1 and CMD_2
 * (Note the synchronize is only needed because we use hsm.wait())</p>
<code>
Hsm1 hsm = makeHsm1();
synchronize(hsm) {
     hsm.sendMessage(obtainMessage(hsm.CMD_1));
     hsm.sendMessage(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 E
D/hsm1    ( 1999): ctor E
D/hsm1    ( 1999): ctor X
D/hsm1    ( 1999): mP1.enter
D/hsm1    ( 1999): mS1.enter
D/hsm1    ( 1999): makeHsm1 X
D/hsm1    ( 1999): mS1.processMessage what=1
D/hsm1    ( 1999): mS1.exit
D/hsm1    ( 1999): mS1.enter
D/hsm1    ( 1999): mS1.processMessage what=2
D/hsm1    ( 1999): mP1.processMessage what=2
D/hsm1    ( 1999): mS1.exit
D/hsm1    ( 1999): mS2.enter
D/hsm1    ( 1999): mS2.processMessage what=2
D/hsm1    ( 1999): mS2.processMessage what=3
D/hsm1    ( 1999): mS2.exit
D/hsm1    ( 1999): mP1.exit
D/hsm1    ( 1999): mP2.enter
D/hsm1    ( 1999): mP2.processMessage what=3
D/hsm1    ( 1999): mP2.processMessage what=4
D/hsm1    ( 1999): mP2.processMessage what=5
D/hsm1    ( 1999): mP2.exit
D/hsm1    ( 1999): halting

打印结果分析：
代码入口：Hsm1 hsm = makeHsm1(); 新建hsm1对象进入方法，打印：makeHsm1 E
进入构造函数，打印：ctor E
打印：ctor X
执行.start()方法,启动出初始状态ms1，先进入父状态，打印：mP1.enter，mS1.enter
在打印：makeHsm1 X
发送消息hsm.sendMessage(obtainMessage(hsm.CMD_1));使得message.what=1
去初始状态匹配执行processMessage(Message message)方法，
打印：mS1.processMessage what=1
执行transitionTo(mS1); 跳转到心状态ms1，退出当前状态，父状态唤起，但是不包括同一个父状态的其他兄弟状态，然后层次遍历的进入从当前父状态到新状态的所有状态。打印：mS1.exit，mS1.enter。
执行hsm.sendMessage(obtainMessage(hsm.CMD_2));使得；message.what=2,去当前状态（ms1）执行processMessage(Message message)，打印：mS1.processMessage what=2
当前message和方法体里面不匹配，那么交给父状态（mp1）的processMessage(Message message)方法去处理,打印：mP1.processMessage what=2
匹配case 2，sendMessage(obtainMessage(CMD_3));  使得message.what=3,
deferMessage(message); 保存message.what=2在list的顶部，
transitionTo(mS2);跳转到状态ms2,当前状态退出，打印：mS1.exit，mS2.enter
此时message.what顶部=2,接下来=3，打印：mS2.processMessage what=2，执行
sendMessage(obtainMessage(CMD_4)); 使得message.what=4.再执行message.what=3,打印：mS2.processMessage what=3
执行： deferMessage(message);  保存最顶部message.what=3,transitionTo(mP2);跳转到状态mp2，当前状态退出，父状态退出，进入新状态，打印：
mS2.exit，mP1.exit，mP2.enter。
执行sendMessage(obtainMessage(CMD_5)); 使得messge.what=5,那么现在
message.what最顶部=3,接下来=4,再=5.进入 processMessage(Message message)
打印mP2.processMessage what=3，mP2.processMessage what=4，mP2.processMessage what=5，执行 transitionToHaltingState();打印：mP2.exit
跳转到onHalting() 打印：halting 完毕