Android StateMachine学习

在看蓝牙源码的时候,发现蓝牙的连接状态以及绑定状态是通过StateMachine(状态机)来实现的。通过StateMachine来管理不同状态下的行为动作,提高灵活性。除了蓝牙,wifi、wps同样是通过StateMachine来处理状态。

先举两个个例子来看看StateMachine是如何使用的,例子是从源码注释里头直接copy来的。在StateMachine源码中可以看到它被@Hide了,所以开发中,我们是用不了。

  • 例1
class HelloWorld extends StateMachine {
    HelloWorld(String name) {
        super(name);
        addState(mState1);
        setInitialState(mState1);
    }

    public static HelloWorld makeHelloWorld() {
        HelloWorld hw = new HelloWorld("hw");
        hw.start();
        return hw;
    }

    class State1 extends State {

        @Override
        public void enter() {
            super.enter();
            log("State1 enter");
        }

        @Override
        public void exit() {
            super.exit();
            log("State1 exit");
        }

        Override 
        public boolean processMessage(Message message) {
            log("Hello World");
            return HANDLED;
        }
    }
    State1 mState1 = new State1();
}

// 测试代码
void testHelloWorld() {
    HelloWorld hw = makeHelloWorld();
    hw.sendMessage(hw.obtainMessage());
}

执行结果:

State1 enter
Hello World

从这个例子中可以了解到StateMachine的使用流程分三步走:

1. `add(state)` 添加状态,将所有的状态都add进去;
2. `setInitialState(state)` 设置初始状态
3. `start()` 启动状态机

从日志上可以看出,状态机启动之后,初始状态的enter()方法会被执行,然后往状态机里头发送message,初始状态的processMessage(msg)方法会被执行。由于没有切换到其他状态,所以exit()方法未被执行。

  • 例2
class Hsm1 extends StateMachine {
    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("makeHsm1 E");
        Hsm1 sm = new Hsm1("hsm1");
        sm.start();
        log("makeHsm1 X");
        return sm;
    }

    Hsm1(String name) {
        super(name);
        log("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("ctor X");
    }

    class P1 extends State {
        Override 
        public void enter() {
            log("mP1.enter");
        }
        Override 
        public boolean processMessage(Message message) {
            boolean retVal;
            log("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("mP1.exit");
        }
    }

    class S1 extends State {
        Override 
        public void enter() {
            log("mS1.enter");
        }
        Override 
        public boolean processMessage(Message message) {
            log("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("mS1.exit");
        }
    }

    class S2 extends State {
        Override 
        public void enter() {
            log("mS2.enter");
        }

        Override 
        public boolean processMessage(Message message) {
            boolean retVal;
            log("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("mS2.exit");
        }
    }

    class P2 extends State {
        Override 
        public void enter() {
            log("mP2.enter");
            sendMessage(obtainMessage(CMD_5));
        }

        Override 
        public boolean processMessage(Message message) {
            log("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("mP2.exit");
        }
    }

    Override
    void onHalting() {
        log("halting");
        synchronized (this) {
            this.notifyAll();
        }
    }

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


// 测试代码
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) {
          loge("exception while waiting " + e.getMessage());
     }
}

这个例子中有4个状态,5条命令,多次的状态切换。

  • step1: 构建状态机并添加状态,添加完状态之后的状态树如下:

            mP1           mP2
           /   \
    初始值->mS1 mS2
    

    其中mP1是mS1和mS2的父状态。

  • step2: 调用start()方法,启动状态机,此时会打印如下日志:

      makeHsm1 E
      ctor E
      ctor X
      mP1.enter
      mS1.enter
      makeHsm1 X
    

    虽然设置的初始状态是mS1,但是mP1的enter()方法也被调用,具体原因会在原理分析中说明。

  • step3: 发送CMD_1指令,当前状态是S1,并且S1会处理该指令事件,通过方法transitionTo(mS1)将状态重新切换到S1,此时会打印的日志如下:

    mS1.processMessage what=1
    mS1.exit        
    mS1.enter
    

    调用transitionTo()方法的时候,上一个状态会先调用exit()方法,然后新的状态调用enter()方法:oldState.exit() -> newState.enter()

  • step4: 发送CMD_2指令,此时的日志如下:

     mS1.processMessage what=2
     mP1.processMessage what=2
    

    S1中是不处理CMD_2的,但是它的父状态会处理,那么就交给P1去处理,具体原因后面分析。

  • step5:P1接收到CMD_2指令之后,发送CMD_3指令,并且通过deferMessage(CMD_2)方法将CMD_2放到消息队列的顶端,然后切换到S2状态,日志如下:

    mS1.exit
    mS2.enter
    mS2.processMessage what=2
    mS2.processMessage what=3
    

    上个状态是S1,切换到S2,所以S1exit(), S2enter(),由于S1和S2是父状态都是P1,那么P1维持不变。

  • step6:S2依次接收到CMD_2CMD_3指令,先后执行发送CMD_4指令、defermessage(CMD_3)、切换到P2状态,日志如下:

     mS2.exit
     mP1.exit
     mP2.enter
     mP2.processMessage what=3
     mP2.processMessage what=4
    

    S2切换到P2,S2先exit(),然后它父状态P1exit(),最后P2执行enter(),接着陆续处理CMD_3CMD_4事件。

  • step6:P2在执行enter()方法的时候,发送了CMD_5指令,CMD_5指令是停止状态机,那么就将执行P2的exit()。日志如下:

    mP2.exit
    halting
    

StateMachine使用总结

  1. 在状态机的构造方法里头,通过addState()方法构建状态树;
  2. 通过setInitialState()设置初始状态;
  3. 通过start()方法启动状态机,初始状态执行enter()方法;
  4. sendMessage(msg)给状态机发送消息之后,当前状态会执行processMessage(msg),来处理消息,如果当前状态处理不了,则交给父状态处理,如果都处理不了,交给状态机处理;
  5. 通过transitionTo(state)来切换状态,oldState执行exit(),newState执行enter()
  6. deferMessage(msg)暂时将当前消息保存到消息队列的顶端, 一旦切换到新的状态,首先处理该消息;
  7. 切换到某个状态的时候,先会从当前状态开始往根状态依次执行各状态的exit()方法,直到与新状态相同的父状态Px为止。然后依次执行从Px到新状态路径下各状态的enter()方法(需要注意的是,公共父状态的enter和exit方法不会执行)。

参考1
参考2

推荐阅读更多精彩内容

  • StateMachine 的简单使用 步骤 源码的frameworks/base/core/java/com/an...
    JustinBetter阅读 4,800评论 3 6
  • 前言 HI,欢迎来到裴智飞的《每周一博》。今天是十一月第五周,我给大家介绍一下安卓系统中的状态机。为什么会介绍状态...
    健身营养爱好者阅读 5,967评论 0 12
  • 前言 最近在了解WIFI模块时,发现WifiController类继承至StateMachine,而WifiCon...
    GrayMonkey阅读 2,197评论 0 3
  • 概念 有限状态机即FSM,简称状态机,表示有限个状态以及在这些状态之间的转移和动作等行为的数学模型。 状态机可以描...
    Galileo_404阅读 6,573评论 0 8
  • 文/向上 已知春风吹, 何苦寻寒意。 念向他人处, 不必穷追去。 草木知春秋, 岂说人不识。 千千无奈生, 自嘲多...
    A向上阅读 859评论 24 32