然后从源码角度分析一下 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
 

Demo： MVP

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也是这么管理订阅和发送事件的。