鸿蒙系统之Lifecycle感知宿主的生命周期

一、前言

Ability、AbilitySlice、Fraction都有生命周期，很多操作需要写在生命周期的方法中，这样就会导致生命周期方法中的代码越来越臃肿，代码维护越来越困难，如果能够将生命周期中的代码放到其它类中就好了，这样就能减少生命周期方法中的代码。Lifecycle就是用来感知宿主（宿主就是Ability、AbilitySlice、Fraction）的生命周期，Lifecycle内部使用了观察者模式，当系统调用宿主的生命周期时，还会调用观察者的方法。有了Lifecycle，就可以把宿主生命周期中的代码放到观察者的方法里面。

二、Lifecycle的使用方式

Lifecycle有两种使用方式。

2、1 方式一：继承LifecycleObserver

2、1、1 创建观察者，创建MyLifecycleObserver类，继承LifecycleObserver，LifecycleObserver提供了完整的生命周期事件，MyLifecycleObserver可以重写LifecycleObserver中的方法，MyLifecycleObserver就是观察者，当宿主的生命周期发生改变时，就会调用MyLifecycleObserver中相应的方法。

/**
 * 这是观察者类，用于监听宿主的生命周期
 * 
 * @author 裴云飞
 * @date 2021/6/13
 */
public class MyLifecycleObserver extends LifecycleObserver {

    public MyLifecycleObserver() {
    }

    /**
     * 当宿主执行完onStart方法，就会调用该方法
     *
     * @param intent
     */
    public void onStart(Intent intent) {
        LogUtils.info("yunfei", "onStart");
    }

    /**
     * 当宿主执行完onForeground方法，就会调用该方法
     *
     * @param intent
     */
    public void onForeground(Intent intent) {
        LogUtils.info("yunfei", "onForeground");
    }

    /**
     * 当宿主执行完onActive方法，就会调用该方法
     */
    public void onActive() {
        LogUtils.info("yunfei", "onActive");
    }

    /**
     * 当宿主执行完onInactive方法，就会调用该方法
     */
    public void onInactive() {
        LogUtils.info("yunfei", "onInactive");
    }

    /**
     * 当宿主执行完onBackground方法，就会调用该方法
     */
    public void onBackground() {
        LogUtils.info("yunfei", "onBackground");
    }

    /**
     * 当宿主执行完onStop方法，就会调用该方法
     */
    public void onStop() {
        LogUtils.info("yunfei", "onStop");
    }
}

2、1、2 在MainAbilitySlice类的onStart方法中调用getLifecycle方法来获取Lifecycle对象 ，然后调用Lifecycle对象的addObserver方法来添加观察者，这里的观察者就是MyLifecycleObserver对象。代码运行起来后，当系统调用MainAbilitySlice的生命周期时，就会调用到MyLifecycleObserver对象中的相应方法。

• 当系统调用MainAbilitySlice的onStart方法，就会调用MyLifecycleObserver对象中的onStart方法。
• 当系统调用MainAbilitySlice的onActive方法，就会调用MyLifecycleObserver对象中的onActive方法。
• 当系统调用MainAbilitySlice的onInactive方法，就会调用MyLifecycleObserver对象中的onInactive方法。
• 当系统调用MainAbilitySlice的onBackground方法，就会调用MyLifecycleObserver对象中的onBackground方法。
• 当系统调用MainAbilitySlice的onStop方法，就会调用MyLifecycleObserver对象中的onStop方法。
• 当系统调用MainAbilitySlice的onForeground方法，就会调用MyLifecycleObserver对象中的onForeground方法。

public class MainAbilitySlice extends AbilitySlice {

    @Override
    public void onStart(Intent intent) {
        super.onStart(intent);
        super.setUIContent(ResourceTable.Layout_ability_main);
        // 添加观察者，将添加观察者的代码放在宿主的onStart方法中，这样观察者就能接收完整的生命周期回调
        getLifecycle().addObserver(new MyLifecycleObserver());
    }

    @Override
    public void onActive() {
        super.onActive();
        // 在onActive中添加观察者，观察者将接收不到slice的onStart方法
        // getLifecycle().addObserver(new MyLifecycleStateObserver());
    }

    @Override
    public void onForeground(Intent intent) {
        super.onForeground(intent);
    }
}

2、1、3 需要注意的是，下面的这段代码，也就是添加观察者的代码，最好将添加观察者的代码放在宿主的onStart中，这样的观察者就能接收完整的生命周期回调。如果在宿主的onActive方法添加观察者，观察者的onStart方法将不会执行。

// 将这段放在宿主的`onStart`方法中，这样的观察者就能接收完整的生命周期回调
getLifecycle().addObserver(new MyLifecycleStateObserver());

2、2 方式二：实现LifecycleStateObserver接口

2、2、1 上面的观察者是继承LifecycleObserver，其实还可以实现LifecycleStateObserver接口，并且重写onStateChanged方法，当宿主的生命周期发生改变时，就会调用onStateChanged方法。在onStateChanged方法中根据宿主的状态来判断宿主执行了哪些生命周期方法。

public class MyLifecycleStateObserver implements LifecycleStateObserver {
    @Override
    public void onStateChanged(Lifecycle.Event event, Intent intent) {
        if (event == Lifecycle.Event.ON_START) {
            // 宿主执行了onStart方法
            LogUtils.info("yunfei", "onStart");
        } else if (event == Lifecycle.Event.ON_ACTIVE) {
            // 宿主执行了onActive方法
            LogUtils.info("yunfei", "onActive");
        } else if (event == Lifecycle.Event.ON_FOREGROUND) {
            // 宿主执行了onForeground方法
            LogUtils.info("yunfei", "onForeground");
        } else if (event == Lifecycle.Event.ON_INACTIVE) {
            // 宿主执行了onInactive方法
            LogUtils.info("yunfei", "onInactive");
        } else if (event == Lifecycle.Event.ON_BACKGROUND) {
            // 宿主执行了onBackground方法
            LogUtils.info("yunfei", "onBackground");
        } else if (event == Lifecycle.Event.ON_STOP) {
            // 宿主执行了onStop方法
            LogUtils.info("yunfei", "onStop");
        }
    }
}

2、2、2 在MainAbilitySlice类的onStart方法中调用getLifecycle方法来获取Lifecycle对象 ，然后调用Lifecycle对象的addObserver方法来添加观察者，这里的观察者就是MyLifecycleStateObserver对象。代码运行起来后，当系统调用MainAbilitySlice的生命周期时，就会调用到MyLifecycleStateObserver对象中的onStateChanged方法。

public class MainAbilitySlice extends AbilitySlice {

    @Override
    public void onStart(Intent intent) {
        super.onStart(intent);
        super.setUIContent(ResourceTable.Layout_ability_main);
        // 添加观察者，将添加观察者的代码放在宿主的onStart方法中，这样观察者就能接收完整的生命周期回调
        getLifecycle().addObserver(new MyLifecycleStateObserver());
    }

    @Override
    public void onActive() {
        super.onActive();
        // 在onActive中添加观察者，观察者将接收不到slice的onStart方法
        // getLifecycle().addObserver(new MyLifecycleStateObserver());
    }

    @Override
    public void onForeground(Intent intent) {
        super.onForeground(intent);
    }
}

从这两种使用方式来看，Lifecycle有几个核心类，下面一一介绍。

三、Lifecycle的几个核心类

在Lifecycle中有几个核心类，分别ILifecycle接口、Lifecycle类、ILifecycleObserver接口、LifecycleObserver类、LifecycleStateObserver类、

3、1 ILifecycle接口

ILifecycle接口有一个getLifecycle()方法，实现了这个接口的类就可以作为一个被观察者，Ability、AbilitySlice、Fraction都实现了这个接口，所以它们的生命周期就可以被观察和监听。getLifecycle()方法返回一个Lifecycle对象，Ability、AbilitySlice、Fraction在getLifecycle()方法都返回一个了Lifecycle对象。

3、2 Lifecycle

Lifecycle管理着观察者，可以添加观察者，删除观察者，获取宿主的状态，当宿主的生命周期发生改变时，通知观察者。

public class Lifecycle {

    public Lifecycle() {

    }

    /**
     * 当宿主的生命周期发生改变时，就会调用该方法，该方法内部会调用观察者的方法
     */
    public void dispatchLifecycle(Lifecycle.Event event, Intent intent) {

    }

    /**
     * 添加观察者
     */
    public void addObserver(ILifecycleObserver observer) {

    }

    /**
     * 删除观察者
     */
    public void removeObserver(ILifecycleObserver observer) {

    }

    /**
     * 获取宿主的状态
     */
    public Lifecycle.Event getLifecycleState() {

    }

    /**
     * 宿主的状态
     */
    public static enum Event {
        // 未定义的生命周期事件，表示生命周期可能尚未开始或已被销毁。
        UNDEFINED,
        // 宿主执行了onStart方法
        ON_START,
        // 宿主执行了onInactive方法
        ON_INACTIVE,
        // 宿主执行了onActive方法
        ON_ACTIVE,
        // 宿主执行了onActive方法
        ON_BACKGROUND,
        // 宿主执行了onForeground方法
        ON_FOREGROUND,
        // 宿主执行了onStop方法
        ON_STOP;

        private Event() {
        }
    }
}

3、3 ILifecycleObserver接口

实现了ILifecycleObserver接口的类就可以作为一个观察者。
LifecycleObserver就实现了ILifecycleObserver接口，LifecycleObserver提供了完整的生命周期事件，外界需要继承LifecycleObserver，重写LifecycleObserver中的方法。当宿主的生命周期发生改变时，就会调用LifecycleObserver中的方法。

public class LifecycleObserver implements ILifecycleObserver {

    public LifecycleObserver() {
        
    }

    /**
     * 当宿主执行完onStart方法，就会调用该方法
     *
     * @param intent
     */
    public void onStart(Intent intent) {
        
    }

    /**
     * 当宿主执行完onInactive方法，就会调用该方法
     */
    public void onInactive() {
        
    }

    /**
     * 当宿主执行完onActive方法，就会调用该方法
     */
    public void onActive() {
       
    }

    /**
     * 当宿主执行完onBackground方法，就会调用该方法
     */
    public void onBackground() {
        
    }

    /**
     * 当宿主执行完onForeground方法，就会调用该方法
     */
    public void onForeground(Intent intent) {
        
    }

    /**
     * 当宿主执行完onStop方法，就会调用该方法
     */
    public void onStop() {
        
    }
}

LifecycleStateObserver接口同样继承了ILifecycleObserver接口，LifecycleStateObserver接口提供了onStateChanged方法，外界需要实现LifecycleStateObserver，重写onStateChanged方法。当宿主的生命周期发生改变时，就会onStateChanged方法。

public interface LifecycleStateObserver extends ILifecycleObserver {
    void onStateChanged(Event var1, Intent var2);
}

四、总结

本文主要介绍了Lifecycle，Lifecycle可以感知宿主的生命周期，当宿主的生命周期发生改变时，就会调用观察者的相应方法。Lifecycle除了能够把宿主生命周期中的代码放到观察者的方法里面，还有其它的作用，一些第三方框架会要求调用者在onStart方法中进行注册操作，在onStop方法中注销操作，现在有了Lifecycle，调用者只需要进行注册操作，注销就不需要了，注销可以由第三方框架自己来完成。
最后，有兴趣的读者可以阅读“好雨知时节，当春乃发生”的ActiveData这篇文章。ActiveData就利用了Lifecycle来感知宿主的生命周期。