深入理解jetpack系列组件之lifecycle

深入理解jetpack系列组件之lifecycle

activity和fragment都已经实现了LifecycleOwner接口，我们看下源码就知道，fragment中的源码：

activity中的源码：

从代码中可以看到，除了实现的lifecycle相关的接口，还都实现的jetpack组件中的ViewModelStoreOwner接口，该接口是实现保存viewModel实例，并且在activity被异常杀死后恢复实例对象的容器，本篇我们就不探讨viewmodel了，下篇再说吧！
我们接着讲回lifecycle，在ComponentActivity中实现了LifecycleOwner接口，该接口只有一个方法：

public interface LifecycleOwner {
    /**
     * Returns the Lifecycle of the provider.
     *
     * @return The lifecycle of the provider.
     */
    @NonNull
    Lifecycle getLifecycle();
}

所以在我们的activity中就可以通过getLifecycle()方法来获取lifecycle对象：

  @NonNull
    @Override
    public Lifecycle getLifecycle() {
        return mLifecycleRegistry;
    }

看下这个mLifecycleRegistry是什么

可以看到，这是一个常量对象，我们看下这个类是什么：

public class LifecycleRegistry extends Lifecycle {

    /**
     * Custom list that keeps observers and can handle removals / additions during traversal.
     *
     * Invariant: at any moment of time for observer1 & observer2:
     * if addition_order(observer1) < addition_order(observer2), then
     * state(observer1) >= state(observer2),
     */
    private FastSafeIterableMap<LifecycleObserver, ObserverWithState> mObserverMap =
            new FastSafeIterableMap<>();

    /**
     * Sets the current state and notifies the observers.
     * <p>
     * Note that if the {@code currentState} is the same state as the last call to this method,
     * calling this method has no effect.
     *
     * @param event The event that was received
     */
    public void handleLifecycleEvent(@NonNull Lifecycle.Event event) {
        State next = getStateAfter(event);
        moveToState(next);
    }



    @Override
    public void addObserver(@NonNull LifecycleObserver observer) {
        State initialState = mState == DESTROYED ? DESTROYED : INITIALIZED;
        ObserverWithState statefulObserver = new ObserverWithState(observer, initialState);
        ObserverWithState previous = mObserverMap.putIfAbsent(observer, statefulObserver);

        if (previous != null) {
            return;
        }
        LifecycleOwner lifecycleOwner = mLifecycleOwner.get();
        if (lifecycleOwner == null) {
            // it is null we should be destroyed. Fallback quickly
            return;
        }

        boolean isReentrance = mAddingObserverCounter != 0 || mHandlingEvent;
        State targetState = calculateTargetState(observer);
        mAddingObserverCounter++;
        while ((statefulObserver.mState.compareTo(targetState) < 0
                && mObserverMap.contains(observer))) {
            pushParentState(statefulObserver.mState);
            statefulObserver.dispatchEvent(lifecycleOwner, upEvent(statefulObserver.mState));
            popParentState();
            // mState / subling may have been changed recalculate
            targetState = calculateTargetState(observer);
        }

        if (!isReentrance) {
            // we do sync only on the top level.
            sync();
        }
        mAddingObserverCounter--;
    }
}
*
*
*

代码有删减，该类继承了lifecycle，抽象类lifecycle中定义了几种生命周期枚举事件：

  public enum Event {
        /**
         * Constant for onCreate event of the {@link LifecycleOwner}.
         */
        ON_CREATE,
        /**
         * Constant for onStart event of the {@link LifecycleOwner}.
         */
        ON_START,
        /**
         * Constant for onResume event of the {@link LifecycleOwner}.
         */
        ON_RESUME,
        /**
         * Constant for onPause event of the {@link LifecycleOwner}.
         */
        ON_PAUSE,
        /**
         * Constant for onStop event of the {@link LifecycleOwner}.
         */
        ON_STOP,
        /**
         * Constant for onDestroy event of the {@link LifecycleOwner}.
         */
        ON_DESTROY,
        /**
         * An {@link Event Event} constant that can be used to match all events.
         */
        ON_ANY
    }

这些事件都是和activity或者fragment的生命周期对应的，唯一不同的是，它还有个 ON_ANY事件，定义了这个事件的观察者，在lifecycleOwner的任一个生命周期函数，都会回调：
说到这里，是时候先简单用一下lifecycle，不然单看源码显得太空洞了：
首先``定义我们的lifecycle观察者：

 class MyLifeCycleObserver :LifecycleObserver{

        @OnLifecycleEvent(Lifecycle.Event.ON_CREATE)
        fun ON_CREATE(){
           Log.e("MyLifeCycleObserver","ON_CREATE")
        }

        @OnLifecycleEvent(Lifecycle.Event.ON_START)
        fun ON_START(){
            Log.e("MyLifeCycleObserver","ON_START")
        }

        @OnLifecycleEvent(Lifecycle.Event.ON_RESUME)
        fun ON_RESUME(){
            Log.e("MyLifeCycleObserver","ON_RESUME")
        }

        @OnLifecycleEvent(Lifecycle.Event.ON_PAUSE)
        fun ON_PAUSE(){
            Log.e("MyLifeCycleObserver","ON_PAUSE")
        }

        @OnLifecycleEvent(Lifecycle.Event.ON_STOP)
        fun ON_STOP(){
            Log.e("MyLifeCycleObserver","ON_STOP")
        }

        @OnLifecycleEvent(Lifecycle.Event.ON_DESTROY)
        fun ON_DESTROY(){
            Log.e("MyLifeCycleObserver","ON_DESTROY")
        }

        @OnLifecycleEvent(Lifecycle.Event.ON_ANY)
        fun ON_ANY(){
            Log.e("MyLifeCycleObserver","ON_ANY")
        }



    }

很简单，就是定义和acitvity或者fragment相关的几个生命周期函数，并且打印日志，接着在我们的activity的oncreate方法中加入注册监听：

   lifecycle.addObserver(MyLifeCycleObserver())

运行后，打印日志：
可以看到，注册了监听之后，activity的生命周期函数都打印出来了，并且每个生命周期函数都会打印ON_ANY事件。
简单试用之后，我们就要继续深入源码去了解，为什么添加注册之后，就能接受到activity的生命周期函数回调了

在ComponentActivity中，lifecycle的具体生命周期事件都是通过一个ReportFragment进行分发的

public static void injectIfNeededIn(Activity activity) {
        if (Build.VERSION.SDK_INT >= 29) {
            // On API 29+, we can register for the correct Lifecycle callbacks directly
            activity.registerActivityLifecycleCallbacks(
                    new LifecycleCallbacks());
        }
        // Prior to API 29 and to maintain compatibility with older versions of
        // ProcessLifecycleOwner (which may not be updated when lifecycle-runtime is updated and
        // need to support activities that don't extend from FragmentActivity from support lib),
        // use a framework fragment to get the correct timing of Lifecycle events
        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();
        }
    }

看到没有，通过添加一个ReportFragment之后，这个ReportFragment的生命周期就和Activity绑定了，我们来看下这个类。

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

  -----删减部分代码..........
    @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);
    }

    @Override
    public void onDestroy() {
        super.onDestroy();
        dispatch(Lifecycle.Event.ON_DESTROY);
        // just want to be sure that we won't leak reference to an activity
        mProcessListener = null;
    }

    private void dispatch(@NonNull Lifecycle.Event event) {
        if (Build.VERSION.SDK_INT < 29) {
            // Only dispatch events from ReportFragment on API levels prior
            // to API 29. On API 29+, this is handled by the ActivityLifecycleCallbacks
            // added in ReportFragment.injectIfNeededIn
            dispatch(getActivity(), event);
        }
    }

    void setProcessListener(ActivityInitializationListener processListener) {
        mProcessListener = processListener;
    }


 * ............删减一些代码
}

看到没，在这个fragment的生命周期函数中，进行了具体的事件分发，并且在分发事件的方法内部有做了个判断，如果SDK版本低于29的话才是通过这里来进行分发，否则的话就是通过它的一个内部类来进行分发

 static class LifecycleCallbacks implements Application.ActivityLifecycleCallbacks {
        @Override
        public void onActivityCreated(@NonNull Activity activity,
                @Nullable Bundle bundle) {
        }

        @Override
        public void onActivityPostCreated(@NonNull Activity activity,
                @Nullable Bundle savedInstanceState) {
            dispatch(activity, Lifecycle.Event.ON_CREATE);
        }

        @Override
        public void onActivityStarted(@NonNull Activity activity) {
        }

        @Override
        public void onActivityPostStarted(@NonNull Activity activity) {
            dispatch(activity, Lifecycle.Event.ON_START);
        }

        @Override
        public void onActivityResumed(@NonNull Activity activity) {
        }

        @Override
        public void onActivityPostResumed(@NonNull Activity activity) {
            dispatch(activity, Lifecycle.Event.ON_RESUME);
        }

        @Override
        public void onActivityPrePaused(@NonNull Activity activity) {
            dispatch(activity, Lifecycle.Event.ON_PAUSE);
        }

        @Override
        public void onActivityPaused(@NonNull Activity activity) {
        }

        @Override
        public void onActivityPreStopped(@NonNull Activity activity) {
            dispatch(activity, Lifecycle.Event.ON_STOP);
        }

        @Override
        public void onActivityStopped(@NonNull Activity activity) {
        }

        @Override
        public void onActivitySaveInstanceState(@NonNull Activity activity,
                @NonNull Bundle bundle) {
        }

        @Override
        public void onActivityPreDestroyed(@NonNull Activity activity) {
            dispatch(activity, Lifecycle.Event.ON_DESTROY);
        }

        @Override
        public void onActivityDestroyed(@NonNull Activity activity) {
        }

因为在创建ReportFragment对象的时候，它还做了一个版本号的判断来决定是否给activity添加生命周期的回调监听

  public static void injectIfNeededIn(Activity activity) {
        if (Build.VERSION.SDK_INT >= 29) {
            // On API 29+, we can register for the correct Lifecycle callbacks directly
            activity.registerActivityLifecycleCallbacks(
                    new LifecycleCallbacks());
        }
      ................
    }

接下来我们看下具体的分发逻辑

  private void dispatch(@NonNull Lifecycle.Event event) {
        if (Build.VERSION.SDK_INT < 29) {
            // Only dispatch events from ReportFragment on API levels prior
            // to API 29. On API 29+, this is handled by the ActivityLifecycleCallbacks
            // added in ReportFragment.injectIfNeededIn
            dispatch(getActivity(), event);
        }
    }

在这个方法的内部又回调了它的一个静态dispatch方法

  @SuppressWarnings("deprecation")
    static void dispatch(@NonNull Activity activity, @NonNull Lifecycle.Event event) {
        if (activity instanceof LifecycleRegistryOwner) {
            ((LifecycleRegistryOwner) activity).getLifecycle().handleLifecycleEvent(event);
            return;
        }

        if (activity instanceof LifecycleOwner) {
            Lifecycle lifecycle = ((LifecycleOwner) activity).getLifecycle();
            if (lifecycle instanceof LifecycleRegistry) {
                ((LifecycleRegistry) lifecycle).handleLifecycleEvent(event);
            }
        }
    }

这个方法里面会走到第二个判断里面去，因为ComponentActivity实现的是LifecycleOwner接口，接着通过强制转换获取 LifecycleRegistry对象进行事件的处理

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

通过getStateAfter(event)来获取目前activity所处的生命周期

 static State getStateAfter(Event event) {
        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;
        }
        throw new IllegalArgumentException("Unexpected event value " + event);
    }

接下来就是滚动到具体生命周期状态的处理了

 private void moveToState(State next) {
        if (mState == next) {
            return;
        }
        mState = next;
        if (mHandlingEvent || mAddingObserverCounter != 0) {
            mNewEventOccurred = true;
            // we will figure out what to do on upper level.
            return;
        }
        mHandlingEvent = true;      //1
        sync();
        mHandlingEvent = false;    //2
    }

mHandlingEvent变量赋值的地方就只有注释1和注释2，所以一般都为false，而mAddingObserverCounter赋值的地方就是在添加观察这的时候会赋值，添加完之后又会重置，所以一般也为0

接着我们看sync（）方法

  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) {     //1
                backwardPass(lifecycleOwner);
            }
            Entry<LifecycleObserver, ObserverWithState> newest = mObserverMap.newest();
            if (!mNewEventOccurred && newest != null
                    && mState.compareTo(newest.getValue().mState) > 0) {   //2
                forwardPass(lifecycleOwner);
            }
        }
        mNewEventOccurred = false;
    }

注释1是判断当前的activity生命周期是否比上一个生命周期小，比如从onstop变为onresume就符合这个判断，所以就要进行生命周期的回退，注释2的话就是相反的判断。接着我们看下 backwardPass(lifecycleOwner)方法。

  private void backwardPass(LifecycleOwner lifecycleOwner) {
        Iterator<Entry<LifecycleObserver, ObserverWithState>> descendingIterator =
                mObserverMap.descendingIterator();
        while (descendingIterator.hasNext() && !mNewEventOccurred) {          //1
            Entry<LifecycleObserver, ObserverWithState> entry = descendingIterator.next();
            ObserverWithState observer = entry.getValue();
            while ((observer.mState.compareTo(mState) > 0 && !mNewEventOccurred  //2
                    && mObserverMap.contains(entry.getKey()))) {
                Event event = downEvent(observer.mState);   //3
                pushParentState(getStateAfter(event));
                observer.dispatchEvent(lifecycleOwner, event);   //4
                popParentState();
            }
        }
    }

注释1是遍历所有添加进来的观察者，接着注释2就是判断观察者中的mState是否大于当前activity的state，注释3是根据当前观察者的生命周期获取到正确的后退之后的生命周期事件，注释4才是真正的分发事件，后面是会根据观察者的类型来决定是调用onStateChanged方法来进行事件分发还是通过反射来调用观察者的各个方法，如果我们的观察者实现的接口是LifecycleObserver，那么具体的分发是通过反射来回调观察者的各个方法的。