jetpack系列之Lifecycle实现原理及使用场景

目录结构

1.Lifecycle简介
2.使用场景
3.使用方式
4.源码解析
5.其他事项

1.Lifecycle简介

简介，当然是官方的最权威：https://developer.android.com/jetpack/androidx/releases/lifecycle?hl=zh-cn
我的理解：从命名可以看出，这个组件就是通过对生命周期监控。Lifecycle可以有效的避免内存泄漏和解决android生命周期的常见难题。类似ActivityLifecycle ，常见的就是我们的Activity、 Fragment 都能满足（默认androidX support需要倒入对应依赖）实现原理借鉴了Glide 的生命周期监控实现方式。

LifeCycle 基于观察者模式实现

1.被观察者
2.观察者
3.建立监听关系
Actiivty 默认是继承AppcompatActivty，又继承componentActivity 而这个componentActivity又实现了LifeCycleOwner.

public class ComponentActivity extends androidx.core.app.ComponentActivity implements
        LifecycleOwner,
        ViewModelStoreOwner,
        SavedStateRegistryOwner,
        OnBackPressedDispatcherOwner {

2.使用场景

我们在使用MVP模式时，经常要在Actvity的ondestroy 方法中调用presenter的销毁方法，这样容易遗忘，切书写麻烦，当然可以通过在IbasePresenter中及在BaseActivity中释放，但是还有更好的方式：lifecycle

1.解耦 Activity、 Fragment

在我们常规MVC MVP中可能会在Activity的onCreate生命周期通过通过调用presenter层的方法请求数据，在onDestroy生命周期中再去释放presenter,这样代码业务膨胀后，耦合就比较严重。借助Lifecycle 可以实现解耦。这样就可以把生命周期转移到观察者，一般就是处理逻辑的presenter中。

2.使用 LifecycleService 解耦 Service 与组件

implementation "androidx.lifecycle:lifecycle-service:2.2.0"

引入上面的依赖，创建实现 LifecycleObserver 接口。使用 @OnLifecycleEvent 标记希望在 Server 生命周期发生变化时得到同步调用的方法，然后创建服务继承 LifecycleService 就可以正常使用，和普通服务没区别。

3.使用方式

1.确定观察者

实现 LifecycleObserver ，然后通过注解定义自己关心的生命周期方法。注意Lifecycle.Event.ON_ANY 注解标记的会在每个生命周期执行回调

class LifeCyclePresent : LifecycleObserver {
    companion object {
        val TAG = LifeCyclePresent::class.java.simpleName
    }
    @OnLifecycleEvent(Lifecycle.Event.ON_CREATE)
    public fun onCreate() {
        Log.e(SecondActivity.TAG, " :onCreate 调用了")
    }
    @OnLifecycleEvent(Lifecycle.Event.ON_ANY)
    public fun onAny() {
        Log.e(SecondActivity.TAG, ":onAny 调用了")
    }
    @OnLifecycleEvent(Lifecycle.Event.ON_DESTROY)
    public fun onDestroy() {
        Log.e(SecondActivity.TAG, ":onDestroy 调用了")
    }
}

2.确定被观察者

如果是Activity、Fragment可以直接使用，如果是别的，需要实现LifecycleOwner

3.建立观察链路

kt写法如下：如果是java 还需要用getLifeCycleI() ，被观察者.addObserver(观察者)
getLifecycle().addObserver(presenter);

 lifecycle.addObserver(LifeCyclePresent())

小结

Livecycle 是一个表示android生命周期及状态的对象
LivecycleOwner 用于连接有生命周期的对象，如activity,fragment
LivecycleObserver 用于观察查LifecycleOwner

   override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_second)
        val lifeCyclePresent = LifeCyclePresent()
        lifecycle.addObserver(LifeCyclePresent())

4.源码解析

源码分析，对于这种生命周期的还是比较好找入口，直接看addObserver(传入的就是观察者)

思考

1.从用法上看，被观察者的生命周期回调，通过注解实现，可以猜到，要么是在编译期生成代码了，要么就是运行期使用反射获取注解来判断了，我们可点击看一下OnLifecycleEvent注解定义的类，保留类型是运行时。大致可以推断，当然不排除有些比较流氓的框架,只是在Class阶段操作，非要设置为runtime。

生命周期怎么发通知
大致也能猜到在ComponentActivity中处理的

源码分析：

1.LifecycleRegister 类中的addObserver方法

这里你会发现生成了一个ObserverWithState，然后放入FastSafeIterableMap里，这个类是一个自定义列表，用于保存观察者并可在遍历期间处理删除/添加。

State initialState = mState == DESTROYED ? DESTROYED : INITIALIZED;
ObserverWithState statefulObserver = new ObserverWithState(observer, initialState);
ObserverWithState previous = mObserverMap.putIfAbsent(observer, statefulObserver);

2.再看ComponentActivity中的onCretae方法

通过下面的方法调用，看下注入这个方法，有没有很熟悉，就是抄袭Glide 添加fragment 的方法。

ReportFragment.injectIfNeededIn(this);

public static void injectIfNeededIn(Activity activity) {
        // ProcessLifecycleOwner should always correctly work and some activities may not extend
        // FragmentActivity from support lib, so we use framework fragments for activities
        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();
        }
    }

3.直接看进去ReportFragment

生命周期函数都调用了dispatch()方法，并且传入了枚举类的类型。有7个类型，和生命周期对应的 3对+any，

 @Override
    public void onActivityCreated(Bundle savedInstanceState) {
        super.onActivityCreated(savedInstanceState);
        dispatchCreate(mProcessListener);
        dispatch(Lifecycle.Event.ON_CREATE);
    }

    @Override
    public void onStart() {
        super.onStart();
        dispatchStart(mProcessListener);
        dispatch(Lifecycle.Event.ON_START);
    }

    @Override
    public void onResume() {
        super.onResume();
        dispatchResume(mProcessListener);
        dispatch(Lifecycle.Event.ON_RESUME);
    }

    @Override
    public void onPause() {
        super.onPause();
        dispatch(Lifecycle.Event.ON_PAUSE);
    }

    @Override
    public void onStop() {
        super.onStop();
        dispatch(Lifecycle.Event.ON_STOP);
    }

4.dispatch()会获取Lifecycle再调用handleLifecycleEvent

dispatch()方法则会判断Activity是否实现了LifecycleOwner接口，如果实现了该接口就调用LifecycleRegister的handleLifecycleEvent()，这样生命周期的状态就会借由LifecycleRegistry通知给各个LifecycleObserver从而调用其中对应Lifecycle.Event的方法。

5.状态处理

 public void handleLifecycleEvent(@NonNull Lifecycle.Event event) {
        State next = getStateAfter(event);
        moveToState(next);
    }

5.根据Event返回state状态

可以看到下面Event有7种，但是状态只有四种，这么设计我猜应该是为了使用最小的代价更好的维护状态。分别是创建、开始、获得焦点、销毁

switch (event) {
            case ON_CREATE:
            case ON_STOP:
                return CREATED;
            case ON_START:
            case ON_PAUSE:
                return STARTED;
            case ON_RESUME:
                return RESUMED;
            case ON_DESTROY:
                return DESTROYED;
            case ON_ANY:
                break;
        }

6.根据状态，同步状态

上面提到只有四种状态要表示6个事件，还需要借助前一个事件类型判断，

private void sync() {
        LifecycleOwner lifecycleOwner = mLifecycleOwner.get();
        if (lifecycleOwner == null) {
            throw new IllegalStateException("LifecycleOwner of this LifecycleRegistry is already"
                    + "garbage collected. It is too late to change lifecycle state.");
        }
        while (!isSynced()) {
            mNewEventOccurred = false;
            // no need to check eldest for nullability, because isSynced does it for us.
            if (mState.compareTo(mObserverMap.eldest().getValue().mState) < 0) {
                backwardPass(lifecycleOwner);
            }
            Entry<LifecycleObserver, ObserverWithState> newest = mObserverMap.newest();
            if (!mNewEventOccurred && newest != null
                    && mState.compareTo(newest.getValue().mState) > 0) {
                forwardPass(lifecycleOwner);
            }
        }
        mNewEventOccurred = false;
    }

代码看起来还是比较不好理解，看下执行逻辑：

image.png

7.forwardPass(lifecycleOwner)方法

调用observer.dispatchEvent 方法去通知

    ObserverWithState observer = entry.getValue();

找到ObserverWithState 类调用代码生成观察者适配器

mLifecycleObserver = Lifecycling.lifecycleEventObserver(observer);

8.通知实现

调用onStateChanged(),来通知实现了 LifecycleObserver的类，生命周期发生了变化

10.查看实现类
ReflectiveGenericLifecycleObserver。onStateChanged()

ReflectiveGenericLifecycleObserver。的构造方法中就把presenter中的方法和注解保存了下来
再通过onStateChanged()进行生命周期的方法的调用

        @SuppressWarnings("ConstantConditions")
        void invokeCallbacks(LifecycleOwner source, Lifecycle.Event event, Object target) {
            invokeMethodsForEvent(mEventToHandlers.get(event), source, event, target);
            invokeMethodsForEvent(mEventToHandlers.get(Lifecycle.Event.ON_ANY), source, event,
                    target);
        }

小结

1.首先是调用addObserver( 观察者) 里面会通过反射先从缓存中Map查找key是观察者的class,value是CallbackInfo,没查找到，把事件和方法存在一个handlers的map种。

2.ComponentActivity 的oncreate中，会创建一个ReportFragment, Fragment能监控到Activity生命周期变化，而在生命周期中，调用dispatch一个具体的Event. 里面会获取到当前的State状态，因为他使用了4种状态来表示多个生命周期，里面进行了判断，确认具体生命周期方法

3.调用dispatchEvent 。里面继续 LifecycleObserver.onStateChanged(owner, event);再通过CallBackInfo.invokeCallbacks 反射调用具体注解的观察者方法

5.其他事项

1. 我们添加观察者，调用addObserver方法，API同时还提供了removeObserver 方法，是否需要调用

A：不需要，github上开发工程师答复，从注解也可以看出不希望开发者调用。可能引起不必要的异常 https://github.com/googlecodelabs/android-lifecycles/issues/5