Jetpack生命周期管理 -Lifecycle实战及源码分析

概述

今天我们来聊聊 Jetpack。具体地说是聊聊他的生命周期管理组件 LifeCycle,因为JetPack这个官方库还蛮大。这里不会再讲 Jetpack的前世今生，以及他的作用什么的。

然后从源码角度分析一下 LifeCycle是如何帮助 Activity 或 Fragment管理生命周期的。后续会继续推出分析 Jetpack其他组件的文章。

我们知道，我们在用某些模块进行数据加载的时候，往往需要去监听 Activity或 Fragment的生命周期。再根据生命周期的变化去调整数据加载或回调的策略。

不使用组件来管理的话，一般我们可以在 Activity或 Fragment的生命周期回调方法里手动去调用模块的生命周期方法。这样页面的生命周期回调方法里可能就会出现大量这样的刻板代码，也不好管理。LifeCycle就用来解决这样的一些问题。

1、使用

使用 LifeCycle不用添加依赖了，因为已经内置了。如果要使用 Viewmodel和 Livedata则需要加依赖，这两个后续会有文章分析。

首先，既然是生命周期的监听，那就会有观察者和被观察者。被观察者需要实现的接口是 LifecycleOwner，也就是生命周期拥有者（Activity 或 Fragment）。这两者都实现了 LifecycleOwner接口，我们可以看一下 Activity 的父类 ComponentActivity：

public class ComponentActivity extends androidx.core.app.ComponentActivity implements
        LifecycleOwner,
        ...
        ...
        {
复制代码

生命周期观察者需要实现的接口是 LifecycleObserver。下面我们就结合上次 MVP架构的例子，给 Presenter添加 LifeCycle生命周期监听方法。

首先让 BasePresenter实现观察者接口：

// 实现 LifecycleObserver
public class BasePresenter implements LifecycleObserver {
    private V mView;
    public void attach(V iView) {
        this.mView = iView;
    }
    public void detach() {
        this.mView = null;
    }
    public V getView() {
        return mView;
    }
}
复制代码

然后我们给 BasePresenter的实现类 Presenter添加几个生命周期的方法，并加上@OnLifecycleEvent注解：

//  Presenter.java

    // onCreate
    @OnLifecycleEvent(Lifecycle.Event.ON_CREATE)
    public void onCreate(){
        Log.d(TAG, "-----------LifecycleObserver -- onCreate");
    }
    // onStart
    @OnLifecycleEvent(Lifecycle.Event.ON_START)
    public void onStart(){
        Log.d(TAG, "-----------LifecycleObserver -- onStart");
    }
    // onPause
    @OnLifecycleEvent(Lifecycle.Event.ON_PAUSE)
    public void onPause(){
        Log.d(TAG, "-----------LifecycleObserver -- onPause");
    }
    // onStop
    @OnLifecycleEvent(Lifecycle.Event.ON_STOP)
    public void onStop(){
        Log.d(TAG, "-----------LifecycleObserver -- onStop");
    }
    // onDestroy
    @OnLifecycleEvent(Lifecycle.Event.ON_DESTROY)
    public void onDestroy(){
        Log.d(TAG, "-----------LifecycleObserver -- onDestroy");
    }
复制代码

然后在 BaseMvpActivity初始化时添加观察者：

// BaseMvpActivity.java

 @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView();
        initView();
        initData();
        mPresenter = createP();
        //mPresenter.attach(this);
        // 注释 1， 添加观察者
        getLifecycle().addObserver(mPresenter);
    }
 @Override
    protected void onDestroy() {
        super.onDestroy();
        // mPresenter.detach();
        // 移除观察者
        getLifecycle().removeObserver(mPresenter);
    }
复制代码

上次例子使用了模板设计模式，所以现在生命周期观察者的添加和移除也放在模板里了。然后打开 Activity后退出，看打印结果：

com.ethan.mvpapplication D/Presenter: -----------LifecycleObserver -- onCreate
com.ethan.mvpapplication D/Presenter: -----------LifecycleObserver -- onStart
com.ethan.mvpapplication D/Presenter: -----------LifecycleObserver -- onPause
com.ethan.mvpapplication D/Presenter: -----------LifecycleObserver -- onStop
com.ethan.mvpapplication D/Presenter: -----------LifecycleObserver -- onDestroy
复制代码

2、源码分析

下面我们来分析一下 Lifecycle生命周期监听的原理。简单粗暴，直接点进上面注释 1的getLifecycle()方法，看看干了啥：

//  ComponentActivity.java

private final LifecycleRegistry mLifecycleRegistry = new LifecycleRegistry(this);

    @Override
    public Lifecycle getLifecycle() {
        return mLifecycleRegistry;
    }
复制代码

返回的是一个 LifecycleRegistry 对象，我们可以点进去看。LifecycleRegistry 是抽象类 Lifecycle的实现类：

public abstract class Lifecycle {
        @MainThread
        public abstract void addObserver(@NonNull LifecycleObserver observer);
        @MainThread
        public abstract void removeObserver(@NonNull LifecycleObserver observer);
        @MainThread
        @NonNull
        public abstract androidx.lifecycle.Lifecycle.State getCurrentState();
        public enum Event {
            ON_CREATE,
            ON_START,
            ON_RESUME,
            ON_PAUSE,
            ON_STOP,
            ON_DESTROY,
            ON_ANY
        }
        public enum State {
            DESTROYED,
            INITIALIZED,
            CREATED,
            STARTED,
            RESUMED;
            public boolean isAtLeast(@NonNull androidx.lifecycle.Lifecycle.State state) {
                return compareTo(state) >= 0;
            }
        }
    }
复制代码

上面抽象类 Lifecycle 不仅包含了添加和移除观察者的方法，还包含了 Event 和 State 两个枚举。我们可以看到，Event 这个枚举包含了 Activity最主要的几个生命周期的方法。

下面我们继续看 LifeCycle是怎么监听生命周期的：

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

        @Override
        protected void onCreate(@Nullable Bundle savedInstanceState) {
            super.onCreate(savedInstanceState);
            ......
            // 注释 2， ComponentActivity注入 ReportFragment
            ReportFragment.injectIfNeededIn(this);
            ......
        }
        ......

        @Override
        public androidx.lifecycle.Lifecycle getLifecycle() {
            return mLifecycleRegistry;
        }
    }
复制代码

按理说可以在上面的 ComponentActivity的各个生命周期回调中调用观察者的对应方法，但我们可以看到 ComponentActivity 这个类里并没有这样做。而是在上面注释 2处将当前Activity对象注入 ReportFragment中，我们看看ReportFragment干了啥：

 public class ReportFragment extends Fragment {
        private static final String REPORT_FRAGMENT_TAG = "androidx.lifecycle"
                + ".LifecycleDispatcher.report_fragment_tag";

        public static void injectIfNeededIn(Activity activity) {
            android.app.FragmentManager manager = activity.getFragmentManager();
            if (manager.findFragmentByTag(REPORT_FRAGMENT_TAG) == null) {
                // 注释 3， 创建ReportFragment 添加到 Activity，使得生命周期与之同步
                manager.beginTransaction().add(new androidx.lifecycle.ReportFragment(), REPORT_FRAGMENT_TAG).commit();
                manager.executePendingTransactions();
            }
        }
        static androidx.lifecycle.ReportFragment get(Activity activity) {
            return (androidx.lifecycle.ReportFragment) activity.getFragmentManager().findFragmentByTag(
                    REPORT_FRAGMENT_TAG);
        }
        // 分发生命周期回调事件
        private void dispatchCreate(androidx.lifecycle.ReportFragment.ActivityInitializationListener listener) {
            if (listener != null) {
                listener.onCreate();
            }
        }
     ......
     ......
        @Override
        public void onActivityCreated(Bundle savedInstanceState) {
            super.onActivityCreated(savedInstanceState);
            dispatchCreate(mProcessListener);
            dispatch(androidx.lifecycle.Lifecycle.Event.ON_CREATE);
        }

        @Override
        public void onStart() {
            super.onStart();
           // 注释 4，  开始调用观察者的生命周期
            dispatchStart(mProcessListener);
            dispatch(androidx.lifecycle.Lifecycle.Event.ON_START);
        }
       ......
       ......
        private void dispatch(androidx.lifecycle.Lifecycle.Event event) {
            Activity activity = getActivity();
            if (activity instanceof LifecycleRegistryOwner) {
                ((LifecycleRegistryOwner) activity).getLifecycle().handleLifecycleEvent(event);
                return;
            }

            if (activity instanceof LifecycleOwner) {
                androidx.lifecycle.Lifecycle lifecycle = ((LifecycleOwner) activity).getLifecycle();
                if (lifecycle instanceof LifecycleRegistry) {
                    // 注释 5，生命周期事件分发
                    ((LifecycleRegistry) lifecycle).handleLifecycleEvent(event);
                }
            }
        }
    }
复制代码

上面注释 3处我们可以看到，这里创建了一个 Fragment，然后将 Fragment添加到 Activity中。这样的话，新创建的这个 Fragment和 Activity就可以同步生命周期。之后，在上面注释 4的地方，Fragment的各种生命周期的方法里就可以调用观察者（LifecycleObserver）的相关的生命周期方法了。

也就是说，ComponentActivity 创建了一个 ReportFragment ，并把生命周期回调的事务交给了Fragment。这sao操作是不是很熟悉？没错！我们之前分析过，Glide也是这么管理生命周期的。

上面注释 5，我们再看看生命周期事件分发，看看观察者方法最终调用的地方：

  // LifecycleRegistry.java
    static class ObserverWithState {
        androidx.lifecycle.Lifecycle.State mState;
        LifecycleEventObserver mLifecycleObserver;
        ObserverWithState(LifecycleObserver observer, androidx.lifecycle.Lifecycle.State initialState) {
            // 获取 ReflectiveGenericLifecycleObserver对象
            mLifecycleObserver = Lifecycling.lifecycleEventObserver(observer);
            mState = initialState;
        }

        void dispatchEvent(LifecycleOwner owner, androidx.lifecycle.Lifecycle.Event event) {
            ......
            // 生命周期回调事件分发
            mLifecycleObserver.onStateChanged(owner, event);
        }
    }

    // Lifecycling.java
    static LifecycleEventObserver lifecycleEventObserver(Object object) {
        .....
        // 返回 ReflectiveGenericLifecycleObserver对象
        return new androidx.lifecycle.ReflectiveGenericLifecycleObserver(object);
    }

    // ReflectiveGenericLifecycleObserver.java
    class ReflectiveGenericLifecycleObserver implements LifecycleEventObserver {
        private final Object mWrapped;
        private final ClassesInfoCache.CallbackInfo mInfo;
        ReflectiveGenericLifecycleObserver(Object wrapped) {
            mWrapped = wrapped;
            mInfo = ClassesInfoCache.sInstance.getInfo(mWrapped.getClass());
        }

        @Override
        public void onStateChanged(LifecycleOwner source, androidx.lifecycle.Lifecycle.Event event) {
            // 生命周期回调
            mInfo.invokeCallbacks(source, event, mWrapped);
        }
    }

    // ClassesInfoCache.java
    private ClassesInfoCache.CallbackInfo createInfo(Class klass, @Nullable Method[] declaredMethods) {
        Class superclass = klass.getSuperclass();
        for (Method method : methods) {
            // 反射遍历观察者的各个方法，将带 @OnLifecycleEvent注解的方法保存在
            // Map对象中，方便生命周期变化时调用
            OnLifecycleEvent annotation = method.getAnnotation(OnLifecycleEvent.class);
            if (annotation == null) { continue; }
            Class[] params = method.getParameterTypes();
            ......
            androidx.lifecycle.Lifecycle.Event event = annotation.value();
            ......
            ClassesInfoCache.MethodReference methodReference = new ClassesInfoCache.MethodReference(callType, method);
            verifyAndPutHandler(handlerToEvent, methodReference, event, klass);
            mCallbackMap.put(klass, info);
            mHasLifecycleMethods.put(klass, hasLifecycleMethods);
        }
        ......
        return info;
    }
    static class CallbackInfo {
        final Map> mEventToHandlers;
        final Map mHandlerToEvent;

        CallbackInfo(Map handlerToEvent) {
            mHandlerToEvent = handlerToEvent;
            mEventToHandlers = new HashMap<>();
            for (Map.Entry entry : handlerToEvent.entrySet()) {
                androidx.lifecycle.Lifecycle.Event event = entry.getValue();
                List methodReferences = mEventToHandlers.get(event);
                if (methodReferences == null) {
                    methodReferences = new ArrayList<>();
                    mEventToHandlers.put(event, methodReferences);
                }
                methodReferences.add(entry.getKey());
            }
        }

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

        private static void invokeMethodsForEvent(List handlers,
                                                  LifecycleOwner source, androidx.lifecycle.Lifecycle.Event event, Object mWrapped) {
            if (handlers != null) {
                for (int i = handlers.size() - 1; i >= 0; i--) {
                    // 调用 MethodReference的 invokeCallback方法
                    handlers.get(i).invokeCallback(source, event, mWrapped);
                }
            }
        }
    }

    // ClassesInfoCache.MethodReference
    static class MethodReference {
        final int mCallType;
        final Method mMethod;
        .......
        void invokeCallback(LifecycleOwner source, androidx.lifecycle.Lifecycle.Event event, Object target) {
            //noinspection TryWithIdenticalCatches
            try {
                switch (mCallType) {
                    case CALL_TYPE_NO_ARG:
                        mMethod.invoke(target);
                        break;
                    case CALL_TYPE_PROVIDER:
                        mMethod.invoke(target, source);
                        break;
                    case CALL_TYPE_PROVIDER_WITH_EVENT:
                        mMethod.invoke(target, source, event);
                        break;
                }
            } catch (InvocationTargetException e) {
                throw new RuntimeException("Failed to call observer method", e.getCause());
            } catch (IllegalAccessException e) {
                throw new RuntimeException(e);
            }
        }
    }

复制代码

时序图就不画了，大概写一下调用流程吧：

LifecycleRegistry.java

--> handleLifecycleEvent();
--> moveToState(next);
--> sync();
--> forwardPass(lifecycleOwner);
--> LifecycleRegistry.ObserverWithState --> dispatchEvent(owner, event);

ReflectiveGenericLifecycleObserver .java

--> onStateChanged()

ClassesInfoCache.java

--> CallbackInfo createInfo(); (反射将观察者带注解的方法保存)

MethodReference.java

-->invokeCallback(source, event, mWrapped);
--> mMethod.invoke(target); (反射调用观察者的生命周期的方法)

经过层层调用和包装，注册时最终会用反射将观察者带@OnLifecycleEvent注解的方法保存在MethodReference中，并放入HashMap。当 Activity生命周期改变时，随着层层调用，最终保存在集合里的观察者LifecycleObserver生命周期相关方法会被调用。

这波sao操作是不是又似曾相识？没错！EventBus也是这么管理订阅和发送事件的。

结尾

想要进一步学习LifeCycle及jetpack其它组件的同学，我这里准备了一份《Jetpack架构组件从入门到精通》pdf学习笔记，有需要的同学可以私信我免费获取！

Jetpack生命周期管理 -Lifecycle实战及源码分析

概述

1、使用

2、源码分析

结尾

你可能感兴趣的:(Jetpack生命周期管理 -Lifecycle实战及源码分析)