简单理解状态机，及框架整理

状态机配置：

StateMachine 处于Android frameworks层源码frameworks/base/core/java/com/android/internal/util路径下。应用层若要使用StateMachine需将对应路径下的三个类拷贝到自己的工程目录下。

这三个类分别为：StateMachine.java、State、IState

---

实例讲解：

1. 创建一个继承StateMachine的类。

2. 新建类用于存放设置状态改变标志常量，然后定义接口，维护一个ConcreteState子类的实例，这个实例定义当前状态。
3. 创建几种状态，均继承自State。

• 状态有三种函数，分别为：
  • 进入状态

            public void enter() {
                Log.e(TAG, "############ enter  ############");
            }

  • 退出状态

    public void exit() {
                Log.e(TAG, "############ exit ############");
            }

  •    过程信息
        过程信息有两种写法，分别为：
            i. 标准写法

        public boolean processMessage(Message msg) {
                Log.e(TAG, "BoringState  processMessage.....");
                return true;
            }

          ii.常用写法

            //过程信息
            @Override
            public boolean processMessage(Message msg) {
                switch (msg.what) {
                    case INITIAL:
                        //跳转状态
                        transitionTo(beginState);
                        return HANDLED;
                    case CLOSE:
                        transitionTo(close);
                        return HANDLED;
                }
                return NOT_HANDLED;
            }

    状态机中此部分使用return HANDLED和使用break的区别：

                   case INITIAL:
                        transitionTo(beginState);
                        break;
                    case OPEN:
                        transitionTo(open);
                        return HANDLED;

    return HANDLED：（中断，且不继续执行。）用于在特定条件下中断当前消息的处理，并且不执行后续状态转换或逻辑。

    break：结束当前，继续下一个。

1.         定义类的对象。

2. 初始化状态

3. 为方便外部调用调用

4. 在构造函数中创建并启动一个线程，在VM层进行调用

   ---

   示例代码：

   public class StateTest extends StateMachine {
       private static final String TAG = "StateTest";
   
       //设置状态机 类的对象，
       private static volatile StateTest stateTest;
       //设置初始状态
       private final Open open = new Open();
       //设置其他状态
       private final Close close = new Close();
       //设置一个空状态，并令他等于初始状态
       private State beginState = open;
   
       private Handler mOutHandler;
   
       protected StateTest() {
           super(TAG,new Handler(Looper.getMainLooper()));
           initState();
       }
       public static StateTest getInstance() {
           if (null == stateTest) {
               synchronized (StateTest.class) {
                   if (null == stateTest) {
                       stateTest = new StateTest();
                   }
               }
           }
           return stateTest;
       }
       private void addHandler(Handler handler){
           this.mOutHandler = handler;
           if (mOutHandler == null) {
               try {
                   throw new IllegalAccessException("参数处理程序不能为空");
               }catch (IllegalAccessException e){
                   e.printStackTrace();
               }
           }
       }
   
       public void start(Handler handler) {
           addHandler(handler);
           super.start();
       }
   
       private void sendMsgToOut(int what) {
           mOutHandler.sendEmptyMessage(what);
       }
       public void sendMessageForOut(int msg) {
           sendMessage(msg);
       }
   
   
       //初始化状态
       private void initState() {
           addState(open);
           addState(close);
           setInitialState(beginState);
       }
   
       //编写状态
       public class Open extends State {
           //进入状态
           @Override
           public void enter() {
               super.enter();
               beginState = open;
   
           }
           //过程信息
           @Override
           public boolean processMessage(Message msg) {
               switch (msg.what) {
                   case INITIAL:
                       //跳转状态
                       transitionTo(beginState);
                       return HANDLED;
                   case OPEN:
                       transitionTo(open);
                       return HANDLED;
                   case CLOSE:
                       transitionTo(close);
                       return HANDLED;
               }
               return NOT_HANDLED;
           }
       }
   
   
       public class Close extends State {
           @Override
           public void enter() {
               super.enter();
               beginState = close;
           }
   
           @Override
           public boolean processMessage(Message msg) {
               switch (msg.what) {
                   case CLOSE:
                       transitionTo(close);
                       return HANDLED;
               }
               return NOT_HANDLED;
           }
       }
   }