Lifecycle感知宿主的生命周期

发布于 2021-8-29 12:07
浏览
2收藏

一、前言

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

二、Lifecycle的使用方式

Lifecycle有两种使用方式。

2、1 方式一:继承LifecycleObserver

2、1、1 创建观察者,创建MyLifecycleObserver类,继承LifecycleObserverLifecycleObserver提供了完整的生命周期事件,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对象中的相应方法。

  • 当系统调用MainAbilitySliceonStart方法,就会调用MyLifecycleObserver对象中的onStart方法。
  • 当系统调用MainAbilitySliceonActive方法,就会调用MyLifecycleObserver对象中的onActive方法。
  • 当系统调用MainAbilitySliceonInactive方法,就会调用MyLifecycleObserver对象中的onInactive方法。
  • 当系统调用MainAbilitySliceonBackground方法,就会调用MyLifecycleObserver对象中的onBackground方法。
  • 当系统调用MainAbilitySliceonStop方法,就会调用MyLifecycleObserver对象中的onStop方法。
  • 当系统调用MainAbilitySliceonForeground方法,就会调用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、FractiongetLifecycle()方法都返回一个了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);
}

四、总结

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

已于2021-8-29 12:31:28修改
4
收藏 2
回复
举报
回复
添加资源
添加资源将有机会获得更多曝光,你也可以直接关联已上传资源 去关联
    相关推荐