Lifecycle的定義：

生命周期感知型組件可執(zhí)行操作來響應(yīng)另一個(gè)組件（如 Activity 和 Fragment）的生命周期狀態(tài)的變化。
通過這句定義我們可以了解到Lifecycle是什么以及其主要的用途：生命感知型組件和響應(yīng)生命周期狀態(tài)的變化玉凯，生命周期使用兩個(gè)主要枚舉來跟蹤其關(guān)聯(lián)組件的生命周期狀態(tài)：
Event：從框架和Lifecycle類派發(fā)的生命周期事件。 這些事件映射到活動(dòng)和片段中的回調(diào)事件盖文。
State：由Lifecycle對(duì)象跟蹤的組件的當(dāng)前狀態(tài)挠轴。
這是官方給出的狀態(tài)與事件轉(zhuǎn)換圖：

image.png

Lifecycle的使用

首先是創(chuàng)建觀察者，然后通過調(diào)用Lifecycle類的addObserver()方法傳遞觀察者實(shí)例：

public class MyObserver implements LifecycleObserver {
    @OnLifecycleEvent(Lifecycle.Event.ON_RESUME)
    public void connectListener() {
        ...
    }

    @OnLifecycleEvent(Lifecycle.Event.ON_PAUSE)
    public void disconnectListener() {
        ...
    }
}

myLifecycleOwner.getLifecycle().addObserver(new MyObserver());

Lifecycle源碼解析

getLifecycle()是CompontActivity中重寫的一個(gè)方法來自LifecycleOwner接口屹培，下面展示CompontActivity中的主要方法

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

private final LifecycleRegistry mLifecycleRegistry = new LifecycleRegistry(this);
 
 public ComponentActivity() {
        Lifecycle lifecycle = getLifecycle();
        //noinspection ConstantConditions
        if (lifecycle == null) {
            throw new IllegalStateException("getLifecycle() returned null in ComponentActivity's "
                    + "constructor. Please make sure you are lazily constructing your Lifecycle "
                    + "in the first call to getLifecycle() rather than relying on field "
                    + "initialization.");
        }
        if (Build.VERSION.SDK_INT >= 19) {
            getLifecycle().addObserver(new LifecycleEventObserver() {
                @Override
                public void onStateChanged(@NonNull LifecycleOwner source,
                        @NonNull Lifecycle.Event event) {
                    if (event == Lifecycle.Event.ON_STOP) {
                        Window window = getWindow();
                        final View decor = window != null ? window.peekDecorView() : null;
                        if (decor != null) {
                            decor.cancelPendingInputEvents();
                        }
                    }
                }
            });
        }
        getLifecycle().addObserver(new LifecycleEventObserver() {
            @Override
            public void onStateChanged(@NonNull LifecycleOwner source,
                    @NonNull Lifecycle.Event event) {
                if (event == Lifecycle.Event.ON_DESTROY) {
                    if (!isChangingConfigurations()) {
                        getViewModelStore().clear();
                    }
                }
            }
        });

        if (19 <= SDK_INT && SDK_INT <= 23) {
            getLifecycle().addObserver(new ImmLeaksCleaner(this));
        }
    }

    @NonNull
    @Override
    public Lifecycle getLifecycle() {
        return mLifecycleRegistry;
    }
    @Override
    protected void onCreate(@Nullable Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        mSavedStateRegistryController.performRestore(savedInstanceState);
        ReportFragment.injectIfNeededIn(this);
        if (mContentLayoutId != 0) {
            setContentView(mContentLayoutId);
        }
    }
}

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

ComponentActivity實(shí)現(xiàn)了LifecycleOwner接口箱蟆，該類以及其子類都具有了提供getLifecycle的能力浆西。比較重要的ReportFragment.injectIfNeededIn(this)。Lifecycle應(yīng)該是創(chuàng)建了一個(gè)Fragment來觀察生命周期顽腾，這種方式和Glide等其它優(yōu)秀框架相同近零。先來看看ReportFragment的內(nèi)容：

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

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

    static ReportFragment get(Activity activity) {
        return (ReportFragment) activity.getFragmentManager().findFragmentByTag(
                REPORT_FRAGMENT_TAG);
    }

    private ActivityInitializationListener mProcessListener;

    ....

    @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(Lifecycle.Event event) {
        Activity activity = getActivity();
        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);
            }
        }
    }
  ....
  ....
}

在Fragment的每個(gè)生命周期的回調(diào)中都執(zhí)行了disaptch()方法來分發(fā)事件。在此方法中最終都調(diào)用了LifecycleRegistry的handleLifecycleEvent()抄肖。
再來看看LifecycleRegistry的內(nèi)容

public class LifecycleRegistry extends Lifecycle {

  ///自定義了一個(gè)列表用于保存觀察者并且可以在遍歷期間處理移除和添加
  ///窮人版的LinkedHashMap  不是線程安全的
  private FastSafeIterableMap<LifecycleObserver, ObserverWithState>       mObserverMap = new FastSafeIterableMap<>();
  ///當(dāng)前狀態(tài)   State是一個(gè)枚舉值   包含的狀態(tài)與生命周期對(duì)應(yīng)
  private State mState;
  ///擁有此生命周期的提供者  注意使用的WeakReference
  private final WeakReference<LifecycleOwner> mLifecycleOwner;
  ///添加觀察者計(jì)數(shù)器
  private int mAddingObserverCounter = 0;
  ///是否正在處理事件
  private boolean mHandlingEvent = false;
  ///是否新事件發(fā)生
  private boolean mNewEventOccurred = false;
  ///父狀態(tài)列表
  private ArrayList<State> mParentStates = new ArrayList<>();
  ///傳遞生命周期提供者  創(chuàng)建LifecycleRegistry
  public LifecycleRegistry(@NonNull LifecycleOwner provider) {
        ///這里的provider可能是Activity或者Fragment也可以是自定義的具有生命周期的組件
        mLifecycleOwner = new WeakReference<>(provider);
        ///設(shè)置當(dāng)前狀態(tài)為 initialized 未初始化狀態(tài) 
        mState = INITIALIZED;
  }
    ///設(shè)置當(dāng)前狀態(tài) 調(diào)用moveToState
   @MainThread
    public void setCurrentState(@NonNull State state) {
        moveToState(state);
    }
    ///狀態(tài)轉(zhuǎn)移
    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();
        mHandlingEvent = false;
    }
    
    @Override
    public void addObserver(@NonNull LifecycleObserver observer) {
        ///狀態(tài)賦值
        State initialState = mState == DESTROYED ? DESTROYED : INITIALIZED;
        ///創(chuàng)建ObserverWithState對(duì)象  兩個(gè)參數(shù)observer  state 
        ObserverWithState statefulObserver = new ObserverWithState(observer, initialState);
        ObserverWithState previous = mObserverMap.putIfAbsent(observer, statefulObserver);
        ///previous == null  表示 obsever 不存在 map中 
        ///previous != null   表示 obsever 存在 map中 則已經(jīng)添加過observer了
        if (previous != null) {
            return;
        }
        LifecycleOwner lifecycleOwner = mLifecycleOwner.get();
        ///判斷生命周期擁有者的引用是否為null 為null則說明引用被銷毀  已經(jīng)被destroyed
        if (lifecycleOwner == null) {
            // it is null we should be destroyed. Fallback quickly
            return;
        }
        ///已經(jīng)添加過obsever 或者 正在處理事件  視為重入
        boolean isReentrance = mAddingObserverCounter != 0 || mHandlingEvent;
        ///計(jì)算目標(biāo)狀態(tài)
        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--;
    }
····
····
    private State calculateTargetState(LifecycleObserver observer) {
        Entry<LifecycleObserver, ObserverWithState> previous = mObserverMap.ceil(observer);

        State siblingState = previous != null ? previous.getValue().mState : null;
        State parentState = !mParentStates.isEmpty() ? mParentStates.get(mParentStates.size() - 1)
                : null;
        return min(min(mState, siblingState), parentState);
     }
    ///兩個(gè)狀態(tài)state1和state2對(duì)比  取位置靠前的state  
    static State min(@NonNull State state1, @Nullable State state2) {
        return state2 != null && state2.compareTo(state1) < 0 ? state2 : state1;
    }
}

LifecycleRegistry中有幾個(gè)比較重要的自定義屬性久信，mState是表示當(dāng)前狀態(tài)。mObserverMap是自定義的map漓摩，封裝了監(jiān)聽者LifecycleObserver和監(jiān)聽者的封裝ObserverWithState之間的映射關(guān)系裙士，mObserverMap內(nèi)部封裝了三種迭代器 AscendingIterator、DescendingIterator管毙、IteratorWithAdditions腿椎，在遍歷操作其中的監(jiān)聽者時(shí)，會(huì)保證其中監(jiān)聽者的狀態(tài)是從大到小排序的夭咬。
監(jiān)聽者的封裝ObserverWithState則是維護(hù)了每一個(gè)監(jiān)聽者和其狀態(tài)啃炸，該狀態(tài)主要是為了給調(diào)用事件分發(fā)前的判斷，另外卓舵，在分發(fā)Event事件后會(huì)同步更新自己的狀態(tài)南用。

    static class ObserverWithState {
        State mState;
        LifecycleEventObserver mLifecycleObserver;

        ObserverWithState(LifecycleObserver observer, State initialState) {
            mLifecycleObserver = Lifecycling.lifecycleEventObserver(observer);
            mState = initialState;
        }

        void dispatchEvent(LifecycleOwner owner, Event event) {
            State newState = getStateAfter(event);
            mState = min(mState, newState);
            mLifecycleObserver.onStateChanged(owner, event);
            mState = newState;
        }
    }

在handleLifecycleEnvent方法中主要用到兩個(gè)方法分別是：getStateAfter(event)和moveToState()

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

該方法通過傳遞進(jìn)來的event事件來獲取之后的狀態(tài)，文章前面放有一張官方的狀態(tài)與事件的對(duì)應(yīng)關(guān)系圖。獲取到新的狀態(tài)之后調(diào)用moveToState()

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

該方法主要判斷新狀態(tài)與當(dāng)前狀態(tài)是否發(fā)生改變裹虫，如果發(fā)生改變則調(diào)用sync()方法進(jìn)行同步肿嘲。

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

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

首先判斷i通過mObserverMap.eldest()和mObserverMap.newest()的state來判斷isSynced()，再在while循環(huán)中用mState和map中的eldest()和newest()的狀態(tài)對(duì)比筑公，分別調(diào)用 backwardPass(lifecycleOwner)分發(fā)降級(jí)事件和 forwardPass(lifecycleOwner)分發(fā)升級(jí)事件
再具體一點(diǎn)說雳窟，如果mObserverMap里最大狀態(tài)比當(dāng)前狀態(tài)大，那就需要調(diào)用backwardPass()匣屡，遍歷mObserverMap封救，同步其中每一個(gè)observer狀態(tài)的同時(shí)，分發(fā)降級(jí)事件耸采，反之兴泥，如果mObserverMap里最小狀態(tài)比當(dāng)前狀態(tài)小工育，就調(diào)用forwardPass()分發(fā)升級(jí)事件虾宇。

    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();
            while ((observer.mState.compareTo(mState) < 0 && !mNewEventOccurred
                    && mObserverMap.contains(entry.getKey()))) {
                pushParentState(observer.mState);
                observer.dispatchEvent(lifecycleOwner, upEvent(observer.mState));
                popParentState();
            }
        }
    }

    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();
            while ((observer.mState.compareTo(mState) > 0 && !mNewEventOccurred
                    && mObserverMap.contains(entry.getKey()))) {
                Event event = downEvent(observer.mState);
                pushParentState(getStateAfter(event));
                observer.dispatchEvent(lifecycleOwner, event);
                popParentState();
            }
        }
    }

這兩個(gè)方法中分別用到了兩個(gè)不同的迭代器ascendingIterator、descendingIterator如绸，再以內(nèi)部循環(huán)通過downEvent()和upEvent()獲取下一步的Event事件嘱朽，并通過observer.dispatchEvent()分發(fā)事件和同步狀態(tài)。直到mObserverMap中的每一個(gè)observer的狀態(tài)都與當(dāng)前狀態(tài)一致為止怔接。

    private static Event downEvent(State state) {
        switch (state) {
            case INITIALIZED:
                throw new IllegalArgumentException();
            case CREATED:
                return ON_DESTROY;
            case STARTED:
                return ON_STOP;
            case RESUMED:
                return ON_PAUSE;
            case DESTROYED:
                throw new IllegalArgumentException();
        }
        throw new IllegalArgumentException("Unexpected state value " + state);
    }

    private static Event upEvent(State state) {
        switch (state) {
            case INITIALIZED:
            case DESTROYED:
                return ON_CREATE;
            case CREATED:
                return ON_START;
            case STARTED:
                return ON_RESUME;
            case RESUMED:
                throw new IllegalArgumentException();
        }
        throw new IllegalArgumentException("Unexpected state value " + state);
    }

downEvent()和upEvent()的實(shí)現(xiàn)同樣可以從官網(wǎng)給的Event與State的關(guān)系圖中找到對(duì)應(yīng)關(guān)系搪泳。下面再放一下這張圖。

image.png

從backwardPass和forwardPass方法中可以看到事件是經(jīng)過dispatchEvent進(jìn)行分發(fā)的扼脐。

  static class ObserverWithState {
        State mState;
        LifecycleEventObserver mLifecycleObserver;

        ObserverWithState(LifecycleObserver observer, State initialState) {
            mLifecycleObserver = Lifecycling.lifecycleEventObserver(observer);
            mState = initialState;
        }

        void dispatchEvent(LifecycleOwner owner, Event event) {
            State newState = getStateAfter(event);
            mState = min(mState, newState);
            mLifecycleObserver.onStateChanged(owner, event);
            mState = newState;
        }
    }

通過 mLifecycleObserver = Lifecycling.lifecycleEventObserver(observer)可以知道靜態(tài)方法Lifecycling.lifecycleEventObserver()對(duì)傳入的監(jiān)聽者進(jìn)行了處理

    static LifecycleEventObserver lifecycleEventObserver(Object object) {
        boolean isLifecycleEventObserver = object instanceof LifecycleEventObserver;
        boolean isFullLifecycleObserver = object instanceof FullLifecycleObserver;
        if (isLifecycleEventObserver && isFullLifecycleObserver) {
            return new FullLifecycleObserverAdapter((FullLifecycleObserver) object,
                    (LifecycleEventObserver) object);
        }
        if (isFullLifecycleObserver) {
            return new FullLifecycleObserverAdapter((FullLifecycleObserver) object, null);
        }

        if (isLifecycleEventObserver) {
            return (LifecycleEventObserver) object;
        }

        final Class<?> klass = object.getClass();
        int type = getObserverConstructorType(klass);
        if (type == GENERATED_CALLBACK) {
            List<Constructor<? extends GeneratedAdapter>> constructors =
                    sClassToAdapters.get(klass);
            if (constructors.size() == 1) {
                GeneratedAdapter generatedAdapter = createGeneratedAdapter(
                        constructors.get(0), object);
                return new SingleGeneratedAdapterObserver(generatedAdapter);
            }
            GeneratedAdapter[] adapters = new GeneratedAdapter[constructors.size()];
            for (int i = 0; i < constructors.size(); i++) {
                adapters[i] = createGeneratedAdapter(constructors.get(i), object);
            }
            return new CompositeGeneratedAdaptersObserver(adapters);
        }
        return new ReflectiveGenericLifecycleObserver(object);
    }

方法中有三種生命周期轉(zhuǎn)發(fā)的方式FullLifecycleObserverAdapter岸军、CompositeGeneratedAdaptersObserver、ReflectiveGenericLifecycleObserver瓦侮。我們只分析最后一種：

class ReflectiveGenericLifecycleObserver implements LifecycleEventObserver {
    private final Object mWrapped;
    private final CallbackInfo mInfo;

    ReflectiveGenericLifecycleObserver(Object wrapped) {
        mWrapped = wrapped;
        mInfo = ClassesInfoCache.sInstance.getInfo(mWrapped.getClass());
    }

    @Override
    public void onStateChanged(@NonNull LifecycleOwner source, @NonNull Event event) {
        mInfo.invokeCallbacks(source, event, mWrapped);
    }
}

該類的實(shí)現(xiàn)很簡(jiǎn)單艰赞，在創(chuàng)建實(shí)例時(shí)，使用getInfo()方法肚吏，通過傳入監(jiān)聽者的class方妖，構(gòu)造出CallbackInfo實(shí)例。在接受到生命周期回調(diào)后罚攀，方法流轉(zhuǎn)到CallbackInfo實(shí)例的invokeCallbacks()方法上党觅。

    CallbackInfo getInfo(Class<?> klass) {
        CallbackInfo existing = mCallbackMap.get(klass);
        if (existing != null) {
            return existing;
        }
        existing = createInfo(klass, null);
        return existing;
    }

getInfo()查看是否已有緩存，如果沒有斋泄，就調(diào)用createInfo()方法解析class對(duì)象杯瞻。

    private CallbackInfo createInfo(Class<?> klass, @Nullable Method[] declaredMethods) {
        Class<?> superclass = klass.getSuperclass();
        Map<MethodReference, Lifecycle.Event> handlerToEvent = new HashMap<>();
        if (superclass != null) {
            CallbackInfo superInfo = getInfo(superclass);
            if (superInfo != null) {
                handlerToEvent.putAll(superInfo.mHandlerToEvent);
            }
        }

        Class<?>[] interfaces = klass.getInterfaces();
        for (Class<?> intrfc : interfaces) {
            for (Map.Entry<MethodReference, Lifecycle.Event> entry : getInfo(
                    intrfc).mHandlerToEvent.entrySet()) {
                verifyAndPutHandler(handlerToEvent, entry.getKey(), entry.getValue(), klass);
            }
        }

        Method[] methods = declaredMethods != null ? declaredMethods : getDeclaredMethods(klass);
        boolean hasLifecycleMethods = false;
        for (Method method : methods) {
            OnLifecycleEvent annotation = method.getAnnotation(OnLifecycleEvent.class);
            if (annotation == null) {
                continue;
            }
            hasLifecycleMethods = true;
            Class<?>[] params = method.getParameterTypes();
            int callType = CALL_TYPE_NO_ARG;
            if (params.length > 0) {
                callType = CALL_TYPE_PROVIDER;
                if (!params[0].isAssignableFrom(LifecycleOwner.class)) {
                    throw new IllegalArgumentException(
                            "invalid parameter type. Must be one and instanceof LifecycleOwner");
                }
            }
            Lifecycle.Event event = annotation.value();

            if (params.length > 1) {
                callType = CALL_TYPE_PROVIDER_WITH_EVENT;
                if (!params[1].isAssignableFrom(Lifecycle.Event.class)) {
                    throw new IllegalArgumentException(
                            "invalid parameter type. second arg must be an event");
                }
                if (event != Lifecycle.Event.ON_ANY) {
                    throw new IllegalArgumentException(
                            "Second arg is supported only for ON_ANY value");
                }
            }
            if (params.length > 2) {
                throw new IllegalArgumentException("cannot have more than 2 params");
            }
            MethodReference methodReference = new MethodReference(callType, method);
            verifyAndPutHandler(handlerToEvent, methodReference, event, klass);
        }
        CallbackInfo info = new CallbackInfo(handlerToEvent);
        mCallbackMap.put(klass, info);
        mHasLifecycleMethods.put(klass, hasLifecycleMethods);
        return info;
    }

createInfo()方法主要是對(duì)類中的方法的遍歷處理，這里只接受三種類型的方法炫掐，使用callType區(qū)分又兵，第一種CALL_TYPE_NO_ARG是沒有參數(shù)的方法，第二種CALL_TYPE_PROVIDER是一個(gè)參數(shù)的方法，參數(shù)類型為L(zhǎng)ifecycleOwner本身沛厨，第三種CALL_TYPE_PROVIDER_WITH_EVENT是二個(gè)參數(shù)的方法宙地，第一個(gè)參數(shù)類型同CALL_TYPE_PROVIDER一樣，第二個(gè)參數(shù)則是ON_ANY枚舉值的Event逆皮。
每次遍歷會(huì)將方法用MethodReference封裝起來宅粥，并使用hanlderToEvent建立MethodReference與event的映射關(guān)系，注意這時(shí)候一個(gè)方法只能有一種Event事件類型相對(duì)應(yīng)电谣，最后以hanlderToEvent這個(gè)map創(chuàng)建CallbackInfo對(duì)象秽梅。

    static class CallbackInfo {
        final Map<Lifecycle.Event, List<MethodReference>> mEventToHandlers;
        final Map<MethodReference, Lifecycle.Event> mHandlerToEvent;

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

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

        private static void invokeMethodsForEvent(List<MethodReference> handlers,
                LifecycleOwner source, Lifecycle.Event event, Object mWrapped) {
            if (handlers != null) {
                for (int i = handlers.size() - 1; i >= 0; i--) {
                    handlers.get(i).invokeCallback(source, event, mWrapped);
                }
            }
        }
    }

CallbakcInfo在創(chuàng)建時(shí)，會(huì)解析hanlderToEvent剿牺，把一個(gè)MethodReference對(duì)應(yīng)一個(gè)event的關(guān)系企垦，轉(zhuǎn)化為一個(gè)event對(duì)應(yīng)多個(gè)MethodReference，并存入到mEventToHandlers中晒来。這樣在被調(diào)用invokeCallbacks()方法時(shí)钞诡，只需要從mEventToHandlers中取出對(duì)應(yīng)的MethodReference，就可以回調(diào)監(jiān)聽者了湃崩。

    @SuppressWarnings("WeakerAccess")
    static final class MethodReference {
        final int mCallType;
        final Method mMethod;

        MethodReference(int callType, Method method) {
            mCallType = callType;
            mMethod = method;
            mMethod.setAccessible(true);
        }

        void invokeCallback(LifecycleOwner source, 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);
            }
        }

        @Override
        public boolean equals(Object o) {
            if (this == o) {
                return true;
            }
            if (!(o instanceof MethodReference)) {
                return false;
            }

            MethodReference that = (MethodReference) o;
            return mCallType == that.mCallType && mMethod.getName().equals(that.mMethod.getName());
        }

        @Override
        public int hashCode() {
            return 31 * mCallType + mMethod.getName().hashCode();
        }
    }

invokeCallback()就是根據(jù)callType對(duì)mMethod進(jìn)行反射調(diào)用荧降，最終執(zhí)行到Lifecycling.lifecycleEventObserver()傳入的監(jiān)聽器的方法實(shí)現(xiàn)中。
參考文獻(xiàn)：
https://mp.weixin.qq.com/s/Gy7aXJZJCUzh7OyKegNjxA
https://blog.csdn.net/XAVI_2010/article/details/105595462