Lifecycle的源码解读

本文只做记录，可能有错误，请勿参考

入口点ProcessLifecycleOwnerInitializer的onCreate()方法

public class ProcessLifecycleOwnerInitializer extends ContentProvider {
    @Override
    public boolean onCreate() {
        LifecycleDispatcher.init(getContext());
        ProcessLifecycleOwner.init(getContext());
        return true;
    }
}

第二步，进入LifecycleDispatcher的init()方法

通过Application的registerActivityLifecycleCallbacks()获取每一个activity的生命周期回调.

class LifecycleDispatcher {

    private static AtomicBoolean sInitialized = new AtomicBoolean(false);

    static void init(Context context) {
        if (sInitialized.getAndSet(true)) {
            return;
        }
        ((Application) context.getApplicationContext())
                .registerActivityLifecycleCallbacks(new DispatcherActivityCallback());
    }

    @SuppressWarnings("WeakerAccess")
    @VisibleForTesting
    static class DispatcherActivityCallback extends EmptyActivityLifecycleCallbacks {

        @Override
        public void onActivityCreated(Activity activity, Bundle savedInstanceState) {
            ReportFragment.injectIfNeededIn(activity);
        }

        @Override
        public void onActivityStopped(Activity activity) {
        }

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

第三步，进入ReportFragment的injectIfNeededIn()

在injectIfNeededIn()根据根据sdk的版本，有不同的处理方法。当版本小于29时，通过将ReportFragment绑定到activity上面，然后在ReportFragment的生命周期回调方法中发送事件。当版本大于29时，直接给activity注册生命周期回调接口，在回调接口中发送事件。

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

    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();
        }
    }

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

   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);
            }
        }
    }

第四步，进入LifecycleRegistry的handleLifecycleEvent()方法

public void handleLifecycleEvent(@NonNull Lifecycle.Event event) {
    //获取event后面的状态,具体可以参考下图
    比如ON_CREATE事件后面的状态是CREATED,ON_STOP事件后面的状态也是CREATED
    State next = getStateAfter(event);
    moveToState(next);
}

/**
* 将LifecycleRegistry自身的状态变成指定的状态，然后把所有的观察者变成LifecycleRegistry的状态(通过sync方法)
*/
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;
        sync(); //将所有观察者的状态变成LifecycleRegistry的状态
        mHandlingEvent = false;
    }

/**
* 将所有观察者的状态变成LifecycleRegistry的状态，并且对观察者回调事件
*/
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.
            //LifecycleRegistry的状态比观察者列表中最先插入的结点的状态还要小,比如LifecycleRegistry的状态
            //是CREATED，而观察者列表中最先插入的结点的状态是STARTED
            if (mState.compareTo(mObserverMap.eldest().getValue().mState) < 0) {
                //将观察者列表中所有结点的状态向回推，一直回推到LifecycleRegistry的状态
                //回推举例：从RESUMED状态到STARTED状态，或者从STARTED状态到CREATED
                //或者从CREATED到INITIALIZED，或者从INITIALIZED到DESTROYED
                backwardPass(lifecycleOwner);
            }
            Entry<LifecycleObserver, ObserverWithState> newest = mObserverMap.newest();
            //LifecycleRegistry的状态比观察者列表中最后插入的结点的状态还要大
            if (!mNewEventOccurred && newest != null
                    && mState.compareTo(newest.getValue().mState) > 0) {
                //将观察者列表中所有结点的状态向后推，一直后推到LifecycleRegistry的状态
                forwardPass(lifecycleOwner);
            }
        }
        mNewEventOccurred = false;
    }

   private boolean isSynced() {
        if (mObserverMap.size() == 0) {
            return true;
        }
        State eldestObserverState = mObserverMap.eldest().getValue().mState;//最先插入的结点的状态
        State newestObserverState = mObserverMap.newest().getValue().mState;//最后插入的结点的状态
        return eldestObserverState == newestObserverState && mState == newestObserverState;
    }

public enum State {
        DESTROYED,
        INITIALIZED,
        CREATED,
        STARTED,
        RESUMED;
    }

public enum Event {
        ON_CREATE,
        ON_START,
        ON_RESUME,
        ON_PAUSE,      
        ON_STOP, 
        ON_DESTROY,
        ON_ANY
    }

private void forwardPass(LifecycleOwner lifecycleOwner) {
        Iterator<Entry<LifecycleObserver, ObserverWithState>> ascendingIterator =
                mObserverMap.iteratorWithAdditions();//获取观察者列表的迭代器
        while (ascendingIterator.hasNext() && !mNewEventOccurred) {
            Entry<LifecycleObserver, ObserverWithState> entry = ascendingIterator.next();
            ObserverWithState observer = entry.getValue();
            //如果观察者的状态小于LifecycleRegistry的状态
            //DESTROYED < INITIALIZED < CREATED < STARTED < RESUMED
            while ((observer.mState.compareTo(mState) < 0 && !mNewEventOccurred
                    && mObserverMap.contains(entry.getKey()))) {
                pushParentState(observer.mState);
                //先调用upEvent()获取观察者的当前状态之后的事件
                //当前状态之后的事件，可以参考下面的那张图
                //CREATED状态之后的事件就是ON_START，下面的STARTED状态之后就是ON_STOP
                //上面的STARTED状态之后的事件是ON_RESUME
                observer.dispatchEvent(lifecycleOwner, upEvent(observer.mState));
                popParentState();
            }
        }
    }

void dispatchEvent(LifecycleOwner owner, Event event) {
            State newState = getStateAfter(event);//获取事件之后的状态，可以参考上图
            mState = min(mState, newState);
            mLifecycleObserver.onStateChanged(owner, event);//回调
            mState = newState;//更新观察者的状态
        }

private void backwardPass(LifecycleOwner lifecycleOwner) {
        Iterator<Entry<LifecycleObserver, ObserverWithState>> descendingIterator =
                mObserverMap.descendingIterator();
        while (descendingIterator.hasNext() && !mNewEventOccurred) {
            Entry<LifecycleObserver, ObserverWithState> entry = descendingIterator.next();
            ObserverWithState observer = entry.getValue();
            //如果观察者的状态大于LifecycleRegistry的状态
            //DESTROYED < INITIALIZED < CREATED < STARTED < RESUMED
            while ((observer.mState.compareTo(mState) > 0 && !mNewEventOccurred
                    && mObserverMap.contains(entry.getKey()))) {
                Event event = downEvent(observer.mState);
                pushParentState(getStateAfter(event));
                observer.dispatchEvent(lifecycleOwner, event);
                popParentState();
            }
        }
    }

关于forwardPass()的举例

假设LifecycleRegistry当前的状态是RESUMED，而观察者列表中的某个观察者的状态是CREATED。

1. CREATED状态之后的事件是ON_START，观察者回调ON_START事件，mLifecycleObserver.onStateChanged(owner, event)
2. 获取ON_START事件之后的状态，ON_START事件之后的状态是STARTED，将观察者的状态更改为STARTED
3. 观察者的状态STARTED还是小于LifecycleRegistry的状态RESUMED，接着获取STARTED之后的事件ON_RESUME，观察者回调ON_RESUME事件
4. ON_RESUME事件之后的状态是RESUMED，将观察者的状态更改为RESUMED
5. 观察者的状态RESUMED等于LifecycleRegistry的状态RESUMED，退出while循环
6. 获取观察者列表的下一个观察者，再从1开始循环，
7. 结果是所有观察者的状态都等于LifecycleRegistry的状态RESUMED

关于backwardPass()的举例

假设LifecycleRegistry当前的状态是CREATED，而观察者列表中的某个观察者的状态是RESUMED。

1. 观察者的状态RESUMED之前的事件是ON_PAUSE，观察者回调ON_PAUSE事件
2. ON_PAUSE事件之后的状态是STARTED，将观察者的状态更改为STARTED
3. 观察者的状态STARTED还是大于LifecycleRegistry的状态CREATED
4. 观察者的状态STARTED之后的事件是ON_STOP，观察者回调ON_STOP事件
5. ON_STOP事件之后的状态是CREATED，将观察者的状态更改为CREATED
6. 观察者的状态CREATED等于LifecycleRegistry的状态CREATED，退出while循环
7. 获取观察者列表的下一个观察者，再从1开始循环
8. 结果是所有观察者的状态都等于LifecycleRegistry的状态CREATED