Jetpack Lifecycle 该怎么看？

Posted 2022-03-08 涂程

前言

本篇从Lifecycle开始将正式进入Jetpack 各个组件的分析。

通过本篇文章你将了解到：

1、为什么需要Lifecycle？
2、Lifecycle 如何使用？
3、Lifecycle 如何感知生命周期
4、Lifecycle 内存泄漏？
5、总结

1、为什么需要Lifecycle?

生命周期的起始

android 中常见的拥有生命周期的组件如Activity、Fragment、Service等，其中Activity、Fragment最为常见，而Fragment的生命周期依托于Activity，因此掌握了Activity的生命周期，其它不在话下。

生命周期的运用

青铜选手

举个简单的例子：当进入Activity 时（获取焦点）需要网络请求，当Activity 退出时（失去焦点）停止网络请求，最简单的做法如下：

    @Override
    protected void onResume() 
        super.onResume();
        NetRequest.startRequest();
    

    @Override
    protected void onPause() 
        super.onPause();
        NetRequest.stopRequest();
    

重写onResume()方法，当该方法被调用时，说明Activity获取了焦点，页面即将展示，此时可以进行网络请求拉取数据。

重写onPause()方法，当该方法被调用时，说明Activity 失去了焦点，此时没必要再请求网络了。

看似没啥问题，但仔细想想：比如在播放视频的时候，也需要在onResume()方法里播放，在onPause()方法里暂停，再比如数据库操作等，这个时候onResume()、onPause()里就叠放了许多代码，使得Activity 变得很臃肿。

白银选手

你说没关系，我有MVP 架构，可以用Presenter 来封装这些业务逻辑。
声明Presenter类：LifecyclePresenter。

public class LifecyclePresenter implements ILifecycle
    @Override
    public void onResume() 
        NetRequest.startRequest();
    

    @Override
    public void onPause() 
        NetRequest.stopRequest();
    

该类实现了接口：ILifecycle，而此接口声明的方法与Activity 生命周期契合：

interface ILifecycle 
    void onCreate();
    void onStart();
    void onResume();
    void onPause();
    void onStop();
    void onDestroy();

好了，最后在Activity 里监听生命周期的变化，进而调用LifecyclePresenter 不同方法：

    @Override
    protected void onResume() 
        super.onResume();
        lifecyclePresenter.onResume();
    

    @Override
    protected void onPause() 
        super.onPause();
        lifecyclePresenter.onPause();
    

如此一来，以后有其它的业务逻辑，只需要在LifecyclePresenter 对应的方法里添加即可，达成了给Activity 减负的效果。

黄金选手

虽然Activity 生命周期各个方法里只新增了一行代码，但是考虑到UI 和逻辑的分离，最好是两者不产生耦合。比如在分工的时候，有些同学负责UI，那么他可能就不会关心什么时候开始/结束网络请求，这些由负责具体业务逻辑的同学来编写。该怎么来实现呢？

还记得在分析Activity生命周期时有说过：
Activity 提供了registerActivityLifecycleCallbacks(callback)方法，当Activity生命周期发生变动时就会调用该方法。因此咱们可以在此监听生命周期的变动，然后调用相应的业务代码：

public class LifecycleHelper 
    @RequiresApi(api = Build.VERSION_CODES.Q)
    public static void bindLifecycle(Activity activity, ILifecycle iLifecycle) 
        if (activity == null)
            return;
        activity.registerActivityLifecycleCallbacks(new Application.ActivityLifecycleCallbacks() 
            @Override
            public void onActivityResumed(@NonNull Activity activity) 
                if (iLifecycle != null)
                    iLifecycle.onResume();
            

            @Override
            public void onActivityPaused(@NonNull Activity activity) 
                if (iLifecycle != null)
                    iLifecycle.onPause();
            
        );
    

传入的Activity 即为想要监听生命周期的Activity。

public class LifecyclePresenterV2 
    @RequiresApi(api = Build.VERSION_CODES.Q)
    public LifecyclePresenterV2(Activity activity) 
        LifecycleHelper.bindLifecycle(activity, new ILifecycle() 
            @Override
            public void onResume() 
                NetRequest.startRequest();
            

            @Override
            public void onPause() 
                NetRequest.stopRequest();
            
        );
    

改造Presenter为：LifecyclePresenterV2。
此时，Activity 里只需要调用：

  //this 表示当前需要监听的Activity
  LifecyclePresenterV2 lifecyclePresenterV2 = new LifecyclePresenterV2(this);

可以看出：

Activity 里无需再重写各个生命周期的回调方法，仅仅只需要一行代码，即可将这些逻辑放到单独的业务层处理，生命周期和具体业务绑定，看业务的需求想怎么和生命周期联动就怎么来。

后续若是换了Activity，那么逻辑层的业务也无需变动。

似乎万事大吉了？非也，仔细看registerActivityLifecycleCallbacks()方法调用有版本限制：@RequiresApi(api = Build.VERSION_CODES.Q)
意思就是该API 必须是Android 10(29)以上才能调用，这局限性可大了。

Lifecycle 的引入

从上面的分析我们可以感知到，生命周期和业务的联动场景挺丰富的，也着实需要一套工具来帮助我们简化联动过程。

Google说要有Lifecycle，于是便有了Lifecycle。

开宗明义：Lifecycle 源码并不复杂，主要就是做了三件事：

1、提供给外界监听感兴趣的生命周期里的某个阶段(onResume、onPause、onDestroy等）的接口，外界此时化身为观察者。
2、在某个地方监听Activity生命周期，此时Activity为被观察者。
3、将生命周期告知给观察者。

2、Lifecycle 如何使用？

添加观察者

从Lifecycle 三件事可知，外界想要监听生命周期变化，仅仅只需要添加观察接口，在接口的回调方法里处理对应生命周期即可。
有两种不同的方式：

1、注解方式处理观察结果

Lifecycle 以前的版本为了少重写接口里的方法，使用了注解来简化观察者。

    //注解的实现方式
    class MyObserver7 implements LifecycleObserver 
        @OnLifecycleEvent(Lifecycle.Event.ON_PAUSE)
        void onPause() 
            Log.d(TAG, "onPause");
        
    

此处只关注onPause，若是还想监测其它状态变化，只需要添加对应状态的注解即可。
而后在Activity 里监听：

    protected void onCreate(Bundle savedInstanceState) 
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_lifecycle);

        getLifecycle().addObserver(new MyObserver7());
    

当Activity 失去焦点后就会调用MyObserver7里的onPause()方法。
可以看出，在Activity里只需要添加观察者即可。

2、接口方式处理观察结果

Lifecycle 新版本废弃了注解观察方式，使用了接口来代替，若是你使用了Java8或者开启了Java8 特性，建议使用接口方式。

    //Java8 方式
    class MyObserver8 implements DefaultLifecycleObserver 
        @Override
        public void onPause(LifecycleOwner owner) 
            Log.d(TAG, "pause");
        
    

    protected void onCreate(Bundle savedInstanceState) 
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_lifecycle);
        getLifecycle().addObserver(new MyObserver8());
    

可以看出，实现了DefaultLifecycleObserver 接口，该接口继承了FullLifecycleObserver 接口。

interface FullLifecycleObserver extends LifecycleObserver 
    void onCreate(LifecycleOwner owner);
    void onStart(LifecycleOwner owner);
    void onResume(LifecycleOwner owner);
    void onPause(LifecycleOwner owner);
    void onStop(LifecycleOwner owner);
    void onDestroy(LifecycleOwner owner);

而DefaultLifecycleObserver 接口默认实现了FullLifecycleObserver全部的方法

    @Override
    default void onCreate(@NonNull LifecycleOwner owner) 
    
    ....

可以看出使用了Java8 的新特性：default 修饰接口方法。
因此当我们实现了DefaultLifecycleObserver接口时，仅仅只需要重写关注的状态对应的接口即可。

3、Lifecycle 如何感知生命周期

综上所述，通过Lifecycle 可以很方便地感知Activity生命周期的变化，前面部分咱们也是一步步分析该怎么封装生命周期，很遗憾遇到了registerActivityLifecycleCallbacks 版本限制的问题，接下来探究Lifecycle究竟是怎么做到绕开限制的。

第一步：注册观察者

LifecycleRegistry

不管是接口还是注解方式都使用了getLifecycle()，该方法返回Lifecycle 对象，而Lifecycle是抽象类，getLifecycle()返回的是Lifecycle 的子类：LifecycleRegistry 的对象。

#ComponentActivity.java
    private LifecycleRegistry mLifecycleRegistry = new LifecycleRegistry(this);
    public Lifecycle getLifecycle() 
        return mLifecycleRegistry;
    

当自定义的Activity 继承自AppCompatActivity时，而ComponentActivity 是 AppCompatActivity 的父类，因此自定义的Activity 调用getLifecycle()时返回的即是mLifecycleRegistry 对象。
而LifecycleRegistry里的mLifecycleOwner对象即是自定义的Activity 本身（弱引用)。

addObserver()

#LifecycleRegistry.java
    @Override
    public void addObserver(@NonNull LifecycleObserver observer) 
        Lifecycle.State initialState = mState == DESTROYED ? DESTROYED : INITIALIZED;
        //传入observer，构造ObserverWithState
        LifecycleRegistry.ObserverWithState statefulObserver = new LifecycleRegistry.ObserverWithState(observer, initialState);
        //将ObserverWithState 加入到map 里
        LifecycleRegistry.ObserverWithState previous = mObserverMap.putIfAbsent(observer, statefulObserver);
        ...
    

关键之处在于ObserverWithState：

#LifecycleRegistry.java
    static class ObserverWithState 
        //生命周期状态
        Lifecycle.State mState;
        //观察者
        LifecycleEventObserver mLifecycleObserver;

        ObserverWithState(LifecycleObserver observer, Lifecycle.State initialState) 
            //封装观察者
            mLifecycleObserver = Lifecycling.lifecycleEventObserver(observer);
            mState = initialState;
        

        void dispatchEvent(LifecycleOwner owner, Lifecycle.Event event) 
            //分发事件，将event转为state
            Lifecycle.State newState = event.getTargetState();
            mState = min(mState, newState);
            mLifecycleObserver.onStateChanged(owner, event);
            mState = newState;
        
    

再看Lifecycling.lifecycleEventObserver：

#Lifecycling.java
    static LifecycleEventObserver lifecycleEventObserver(Object object) 
        //接口方式
        boolean isFullLifecycleObserver = object instanceof FullLifecycleObserver;
        ...
        if (isFullLifecycleObserver) 
            //如果观察者是接口方式，直接返回
            return new FullLifecycleObserverAdapter((FullLifecycleObserver) object, null);
        

        //处理注解，将注解记录下来，下次直接从map里取
        final Class<?> klass = object.getClass();
        int type = getObserverConstructorType(klass);
        ...
        return new ReflectiveGenericLifecycleObserver(object);
    

addObserver()的重点是将Observer经过一些列封装后添加到Map里。

明显地我们会想到：当生命周期变更后，将会从Map里取出观察者，并通知它。

第二步：生命周期变更-通知观察者

Android10(含) 以上处理方式

了解Lifecycle 如何通知观察者，最好的方法莫过于通过断点查看其调用堆栈。
以接口处理方式为例，当观察者被调用时，其调用栈如下：

注意到Activity. dispatchActivityPostStarted()方法：

#Activity.java
    private void dispatchActivityPostStarted() 
        //找到监听者
        Object[] callbacks = collectActivityLifecycleCallbacks();
        if (callbacks != null) 
            for (int i = 0; i < callbacks.length; i++) 
                //调用回调方法
                ((Application.ActivityLifecycleCallbacks) callbacks[i])
                        .onActivityPostStarted(this);
            
        
        ...
    

而此处的监听者即为通过Activity.registerActivityLifecycleCallbacks(callback)注册的。 而callback 即为：ReportFragment.LifecycleCallbacks 对象，该对象的注册在：

#ReportFragment.java
    public static void injectIfNeededIn(Activity activity) 
        if (Build.VERSION.SDK_INT >= 29) 
            //如果是Android10以上，则直接注册ActivityLifecycleCallbacks
            ReportFragment.LifecycleCallbacks.registerIn(activity);
        
        //将一个空的Fragment添加到Activity里
        android.app.FragmentManager manager = activity.getFragmentManager();
        if (manager.findFragmentByTag(REPORT_FRAGMENT_TAG) == null) 
            manager.beginTransaction().add(new ReportFragment(), REPORT_FRAGMENT_TAG).commit();
            // Hopefully, we are the first to make a transaction.
            manager.executePendingTransactions();
        
    

而injectIfNeededIn的调用时机是在Activity.onCreate()里。
好了，现在我们已经了解了：

在Activity 创建时，通过ReportFragment 监听Activity 状态变化。

而ReportFragment 依据系统版本的不同，分两种监听方式：

1、在Android 10以上(含)的设备是通过registerActivityLifecycleCallbacks()监听的。
2、在Android 10以下是通过Fragment 监听的。

行文至此，Lifecycle仅仅只是监听了Activity 的状态，还需要将状态分发下去。
还是以Android10处理方式为例：

#ReportFragment.java
    static void dispatch(@NonNull Activity activity, @NonNull Lifecycle.Event event) 
        ...
        if (activity instanceof LifecycleOwner) 
            //获取Lifecycle，也即是LifecycleRegistry
            Lifecycle lifecycle = ((LifecycleOwner) activity).getLifecycle();
            if (lifecycle instanceof LifecycleRegistry) 
                //分发事件
                ((LifecycleRegistry) lifecycle).handleLifecycleEvent(event);
            
        
    

最终事件还是交由LifecycleRegistry 处理，而LifecycleRegistry 里依据Event和State 转换，最后从Map 里找到对应的封装Observer，最终通知Activity里注册的observer，至此就完成了一次生命周期状态变化的通知。

Android 10以下处理方式

我们知道，当Fragment关联上Activity时，那么它的生命周期就与Activity 联动了。

因此当Activity 生命周期变化时，会调用Fragment某个方法，以onStart()状态为例：

#ReportFragment.java
    @Override
    public void onStart() 
        super.onStart();
        dispatchStart(mProcessListener);
        //分发事件
        dispatch(Lifecycle.Event.ON_START);
    

    private void dispatch(@NonNull Lifecycle.Event event) 
        if (Build.VERSION.SDK_INT < 29) 
            //Android 10 以下才处理
            dispatch(getActivity(), event);
        
    

此时，我们知道了Lifecycle 如何处理registerActivityLifecycleCallbacks()版本限制问题：即是通过ReportFragment 对上层调用者屏蔽监听Activity生命周期变化的细节。在Android 10(含)以上使用registerActivityLifecycleCallbacks()，在其之下使用空的Fragment 添加到Activity。

Lifecycle 感知生命周期总结

用图表示如下：

绿色部分：

Lifecycle 监听Activity生命周期变化。

蓝色部分：

外界通过Lifecycle 注册观察者。

红色部分：

Lifecycle 监听到生命周期发生变化，通知观察者。

4、Lifecycle 内存泄漏？

在Activity(假设自定义为LifeActivity) onCreate()里添加如下代码，监测Activity 生命周期：

        getLifecycle().addObserver(new DefaultLifecycleObserver() 
            @Override
            public void onCreate(@NonNull @org.jetbrains.annotations.NotNull LifecycleOwner owner) 

            
        );

问题来了：是否需要在Activity.onDestroy()里移除观察者呢？

我们知道，匿名内部类持有外部类引用，addObserver(xx)，这个xx 对象持有了Activity，通常来说看到这样的写法我们立马就关联到了：若是xx没有被释放，那么当Activity 销毁时，Activity 对象是无法被释放的，因为它被xx持有。
因此大部分时候我们需要在Activity.onDestroy() 里removeObserver(xx)。

接着来看看getLifecycle().addObserver(xx)此种情况是否需要主动移除observer。问题的关键是xx被谁持有了。

通过前面的分析可知，xx 被封装为ObserverWithState 对象，最后存储到Map里。而这个Map为：

#LifecycleRegistry.java
    private FastSafeIterableMap<LifecycleObserver, ObserverWithState> mObserverMap =
            new FastSafeIterableMap<>();

它是LifecycleRegistry 的成员变量，而LifecycleRegistry 对象是ComponentActivity 的成员变量，最终结果：Map 是LifeActivity 的成员变量。
当Activity 销毁时，Map将会被销毁，而Map 将不会再持有Observer。
因此，得出的结论是：

无需调用getLifecycle().removeObserver(observer);

内存泄漏的本质是：长生命周期的对象持有短生命周期对象的引用，导致短生命周期对象无法释放。

5、总结

本篇文章并没有将侧重点放在Lifecycle.State 与Lifecycle.Event 之间的转换，而是着眼于为什么需要Lifecycle以及Lifecycle 如何感知生命周期，希望能够自然而然地引入Lifecycle，并了解其设计原理。
Lifecycle 是LiveData的基础，接下来将会分析LiveData的妙用。