前言

Jetpack的众多组件都依赖于Lifecycle，例如LiveData、ViewModel等，可见Lifecycle的作用十分核心，Lifecycle可以让我们感知Activity、Fragment的生命周期变化，而无需手动在Activity、Fragment的生命周期方法中转调来进行通知，这对于视频播放、注册注销等场景的功能更加内聚，可以少很多模板代码

简单使用

我们就以打Log的形式，在Activity中注册监听器，具体的使用场景，可以看我这篇博客Jetpack Lifecycle使用，这里就不再赘述了

Lifecycle提供了好几种监听方式

• 统一回调一个方法的监听器的方式，生命周期变化时，都回调一个onStateChanged()方法，通过event入参来判断最新的生命周期状态

getLifecycle().addObserver(new LifecycleEventObserver() {
    @Override
    public void onStateChanged(LifecycleOwner source, Lifecycle.Event event) {
        Log.d(event.name());
    }
});

• 拆分回调具体的方法的形式，这种回调方式会更加具体化，如果只需要其中一个回调，则需要自己手动添加一个FullLifecycleObserver的空实现

getLifecycle().addObserver(new FullLifecycleObserver() {
    @Override
    public void onCreate(LifecycleOwner owner) {
        Log.d("ON_CREATE");
    }

    @Override
    public void onStart(LifecycleOwner owner) {
        Log.d("ON_START");
    }

    @Override
    public void onResume(LifecycleOwner owner) {
        Log.d("ON_RESUME");
    }

    @Override
    public void onPause(LifecycleOwner owner) {
        Log.d("ON_PAUSE");
    }

    @Override
    public void onStop(LifecycleOwner owner) {
        Log.d("ON_STOP");
    }

    @Override
    public void onDestroy(LifecycleOwner owner) {
        Log.d("ON_DESTROY");
    }
});

• 反射注解方法的方式，这种方式是通过注解 + 反射来实现回调的，大家都知道反射是比较消耗性能的，所以Google还提供了编译时生成适配器的方式，来避免反射

getLifecycle().addObserver(new LifecycleLogObserver());
//监听器类
private static class LifecycleLogObserver implements LifecycleObserver {
    @OnLifecycleEvent(Lifecycle.Event.ON_CREATE)
    public void onCreate() {
        Log.d("ON_CREATE");
    }

    @OnLifecycleEvent(Lifecycle.Event.ON_START)
    public void onStart() {
        Log.d("ON_START");
    }

    @OnLifecycleEvent(Lifecycle.Event.ON_RESUME)
    public void onResume() {
        Log.d("ON_RESUME");
    }

    @OnLifecycleEvent(Lifecycle.Event.ON_PAUSE)
    public void onPause() {
        Log.d("ON_PAUSE");
    }

    @OnLifecycleEvent(Lifecycle.Event.ON_STOP)
    public void onStop() {
        Log.d("ON_STOP");
    }

    @OnLifecycleEvent(Lifecycle.Event.ON_DESTROY)
    public void onDestroy() {
        Log.d("ON_DESTROY");
    }
}

• Java8默认方法的方式，如果你的工程是Java8编译，则可以使用这种方式，作用和空实现差不多，所有回调方法都是有default关键字修饰，也就是空实现，但Java8的默认方法是在接口上使用的，Java8以下只能创建一个类实现接口，所有子类就只能继承它，我们都知道Java是单继承的，因为空实现失去了继承的位置，少了一份优雅

//Java8默认方法的方式
getLifecycle().addObserver(new DefaultLifecycleObserver() {
    @Override
    public void onCreate(LifecycleOwner owner) {
        Log.d("ON_CREATE");
    }

    @Override
    public void onStart(LifecycleOwner owner) {
        Log.d("ON_START");
    }

    @Override
    public void onResume(LifecycleOwner owner) {
        Log.d("ON_RESUME");
    }

    @Override
    public void onPause(LifecycleOwner owner) {
        Log.d("ON_PAUSE");
    }

    @Override
    public void onStop(LifecycleOwner owner) {
        Log.d("ON_STOP");
    }

    @Override
    public void onDestroy(LifecycleOwner owner) {
        Log.d("ON_DESTROY");
    }
});

源码分析

Lifecycle

Lifecycle是一个抽象类，内部有2个枚举类，Event生命周期事件类型，State生命周期状态，以及3个方法，addObserver()添加一个监听器，removeObserver()移除一个监听器，getCurrentState()获取当前状态，还有一个成员变量mInternalScopeRef，它只在引入了lifecycle-common-ktx包时，就是使用kotlin协程库时才有用

这样看来，Lifecycle类还是比较简单清晰的，Lifecycle类只有一个子类LifecycleRegistry，后面我们再来解析它

public abstract class Lifecycle {
    /**
     * Lifecycle coroutines extensions stashes the CoroutineScope into this field.
     *
     * @hide used by lifecycle-common-ktx
     */
    AtomicReference<Object> mInternalScopeRef = new AtomicReference<>();

    /**
     * 添加一个观察者
     */
    public abstract void addObserver(LifecycleObserver observer);

    /**
     * 移除一个观察者
     */
    public abstract void removeObserver(LifecycleObserver observer);

    /**
     * 返回当前的生命周期状态
     */
    public abstract State getCurrentState();

    /**
     * 生命事件枚举
     */
    @SuppressWarnings("WeakerAccess")
    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
    }

    /**
     * 生命周期状态枚举
     */
    @SuppressWarnings("WeakerAccess")
    public enum State {
        /**
         * 当处于DESTROYED状态时，Lifecycle 将不会发布其它Event值
         * 当Activity即将回调onDestroy()时则处于此状态
         */
        DESTROYED,

        /**
         * 已初始化的状态。例如，当Activity的构造函数已完成，但还未回调 onCreate 时则处于此状态
         */
        INITIALIZED,

        /**
         * 创建状态
         */
        CREATED,

        /**
         * 启动状态
         */
        STARTED,

        /**
         * 交互状态
         */
        RESUMED;

        /**
         * 如果当前状态大于入参值state时，则返回true
         */
        public boolean isAtLeast(State state) {
            return compareTo(state) >= 0;
        }
    }
}

LifecycleOwner

LifecycleOwner，用在能产生生命周期事件的类，就是事件的源头，例如AppCompatActivity和Fragment都实现了这个接口，其中getLifecycle()方法用来获取Lifecycle的实例

public interface LifecycleOwner {
    /**
     * 返回生命周期提供对象
     */
    Lifecycle getLifecycle();
}

LifecycleObserver

LifecycleObserver，事件监听器接口，它只是一个标识接口，里面没有任何方法，而我们一般都是使用它的具体子类

public interface LifecycleObserver {
}

LifecycleEventObserver

LifecycleEventObserver，LifecycleObserver的一个子类，生命周期变化时，统一回调onStateChanged()方法，通过event入参，判断当前变化的声明周期

public interface LifecycleEventObserver extends LifecycleObserver {
    /**
     * 发生状态变更时回调
     *
     * @param source 事件源
     * @param event  事件
     */
    void onStateChanged(LifecycleOwner source, Lifecycle.Event event);
}

FullLifecycleObserver

FullLifecycleObserver，LifecycleObserver的一个子类，相比LifecycleEventObserver，就是生命周期回调细化到具体的回调函数

public interface FullLifecycleObserver extends LifecycleObserver {
    void onCreate(LifecycleOwner owner);

    void onStart(LifecycleOwner owner);

    void onResume(LifecycleOwner owner);

    void onPause(LifecycleOwner owner);

    void onStop(LifecycleOwner owner);

    void onDestroy(LifecycleOwner owner);
}

DefaultLifecycleObserver

DefaultLifecycleObserver，继承于FullLifecycleObserver，它把所有生命周期回调方法都加上了default关键字，就是把所有回调方法都作为默认方法进行空实现，如果你的工程使用的是Java8编译环境，则可以使用它

public interface DefaultLifecycleObserver extends FullLifecycleObserver {
    @Override
    default void onCreate(LifecycleOwner owner) {
    }

    @Override
    default void onStart(LifecycleOwner owner) {
    }

    @Override
    default void onResume(LifecycleOwner owner) {
    }

    @Override
    default void onPause(LifecycleOwner owner) {
    }

    @Override
    default void onStop(LifecycleOwner owner) {
    }

    @Override
    default void onDestroy(LifecycleOwner owner) {
    }
}

FullLifecycleObserverAdapter

FullLifecycleObserverAdapter，LifecycleEventObserver的一个子类，构造方法传入2个参数，分别为FullLifecycleObserver和LifecycleEventObserver，然后统一复写了onStateChanged()方法，统一回调2个传入的监听器，相当于一个装饰器

class FullLifecycleObserverAdapter implements LifecycleEventObserver {
    private final FullLifecycleObserver mFullLifecycleObserver;
    private final LifecycleEventObserver mLifecycleEventObserver;

    FullLifecycleObserverAdapter(FullLifecycleObserver fullLifecycleObserver,
                                 LifecycleEventObserver lifecycleEventObserver) {
        mFullLifecycleObserver = fullLifecycleObserver;
        mLifecycleEventObserver = lifecycleEventObserver;
    }

    @Override
    public void onStateChanged(LifecycleOwner source, Lifecycle.Event event) {
        //详细具体方法回调的派发
        switch (event) {
            case ON_CREATE:
                mFullLifecycleObserver.onCreate(source);
                break;
            case ON_START:
                mFullLifecycleObserver.onStart(source);
                break;
            case ON_RESUME:
                mFullLifecycleObserver.onResume(source);
                break;
            case ON_PAUSE:
                mFullLifecycleObserver.onPause(source);
                break;
            case ON_STOP:
                mFullLifecycleObserver.onStop(source);
                break;
            case ON_DESTROY:
                mFullLifecycleObserver.onDestroy(source);
                break;
            case ON_ANY:
                throw new IllegalArgumentException("ON_ANY must not been send by anybody");
        }
        //统一为一个状态变化方法回调的派发
        if (mLifecycleEventObserver != null) {
            mLifecycleEventObserver.onStateChanged(source, event);
        }
    }
}

OnLifecycleEvent

OnLifecycleEvent，注解类，在注解 + 反射或注解 + 编译时注解解释器，这2种方案时使用，用来标记在某个生命周期回调方法，注解的value属性为具体的Lifecycle.Event事件类型

//保留到运行时
@Retention(RetentionPolicy.RUNTIME)
//只能标记在方法上
@Target(ElementType.METHOD)
public @interface OnLifecycleEvent {
    /**
     * 回调方法在什么事件类型时回调
     */
    Lifecycle.Event value();
}

ReportFragment

我们了解完那几种监听方式后，发现生命周期监听变得特别简单，只要能获取到Lifecycle的实例，就可以在任意类中实现LifecycleObserver接口或其子类接口，复写相关回调方法，就可以轻松实现了，接下来就是分析事件怎么派发到监听器了，就是怎么回调到监听器的onStateChanged()方法

我们的Activity一般继承于AppCompatActivity，而在它的onCreate()方法中，有这么一段代码，调用了ReportFragment的injectIfNeededIn()方法，传入了Activity的实例

@Override
protected void onCreate(@Nullable Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    ReportFragment.injectIfNeededIn(this);
}

injectIfNeededIn

public static void injectIfNeededIn(Activity activity) {
    if (Build.VERSION.SDK_INT >= 29) {
        //API是29以上才有，就是安卓10以上时，通过对某个activity注册生命周期监听来实现
        activity.registerActivityLifecycleCallbacks(
                new LifecycleCallbacks());
    }
    //API是29以下是，因为Activity并没有这个registerActivityLifecycleCallbacks()的方法，所以通过添加一个透明的Fragment来获取生命周期
    android.app.FragmentManager manager = activity.getFragmentManager();
    if (manager.findFragmentByTag(REPORT_FRAGMENT_TAG) == null) {
        manager.beginTransaction().add(new ReportFragment(), REPORT_FRAGMENT_TAG).commit();
        manager.executePendingTransactions();
    }
}

API29以上

API29以上，通过activity.registerActivityLifecycleCallbacks()注册生命周期，注意这个和Application的registerActivityLifecycleCallbacks()的区别

通过具体的activity注册的监听，只是回调这个activity的生命周期变化，而application的注册是所有Activity的生命周期变化时都回调

注册的是LifecycleCallbacks类，目的只有复写所有生命周期回调方法，在其中调用dispatch(activity, event)方法分发生命周期事件

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

dispatch方法

dispatch()方法，用于分发生命周期事件，其中判断activity有没有实现LifecycleRegistryOwner或LifecycleRegistry接口，然后都调用这2个接口的handleLifecycleEvent()方法进行具体转发

其中，LifecycleRegistryOwner已经被废弃了，所以一般都看LifecycleRegistry即可

static void dispatch(Ability activity, Lifecycle.Event event) {
    //先判断有没有实现LifecycleRegistryOwner接口，有则交给它分发
    if (activity instanceof LifecycleRegistryOwner) {
        ((LifecycleRegistryOwner) activity).getLifecycle().handleLifecycleEvent(event);
        return;
    }
    //没有实现LifecycleRegistryOwner接口，但实现LifecycleOwner接口，则交给它分发
    if (activity instanceof LifecycleOwner) {
        Lifecycle lifecycle = ((LifecycleOwner) activity).getLifecycle();
        if (lifecycle instanceof LifecycleRegistry) {
            ((LifecycleRegistry) lifecycle).handleLifecycleEvent(event);
        }
    }
}

API29以下

API29时，通过给Activity添加一个透明的Fragment来获取生命周期，其实就是复写Fragment上的生命周期回调，再调用dispatch(event)方法进行分发

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

@Override
public void onStart() {
    super.onStart();
    dispatch(Lifecycle.Event.ON_START);
}

@Override
public void onResume() {
    super.onResume();
    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);
}

dispatch(event)，会判断如果API大于29的话，Fragment分发的事件将被忽略，避免Activity注册的LifecycleCallbacks回调的事件和Fragment分发的事件重复分发

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

LifecycleRegistry

ReportFragment.dispatch(activity, event)方法中，最终都是调用Activity上实现的LifecycleRegistryOwner或LifecycleRegistry接口的handleLifecycleEvent(event)方法

而实现LifecycleRegistry接口的是ComponentActivity，一般我们使用AppCompatActivity，AppCompatActivity又是继承于ComponentActivity的，所以我们来看看ComponentActivity

可以看到，getLifecycle()方法被复写了，并且返回了LifecycleRegistry实例

//ComponentActivity
public class ComponentActivity extends androidx.core.app.ComponentActivity implements
        LifecycleOwner,
        ViewModelStoreOwner,
        HasDefaultViewModelProviderFactory,
        SavedStateRegistryOwner,
        OnBackPressedDispatcherOwner {
    private final LifecycleRegistry mLifecycleRegistry = new LifecycleRegistry(this);
 
    @NonNull
    @Override
    public Lifecycle getLifecycle() {
        return mLifecycleRegistry;
    }
}

//Fragment
public class Fragment implements ComponentCallbacks, OnCreateContextMenuListener, LifecycleOwner,
        ViewModelStoreOwner, HasDefaultViewModelProviderFactory, SavedStateRegistryOwner {
    LifecycleRegistry mLifecycleRegistry;
 
    @Override
    @NonNull
    public Lifecycle getLifecycle() {
        return mLifecycleRegistry;
    }
}

LifecycleRegistry的构造方法，弱引用保存Lifecycle和当前状态State

public class LifecycleRegistry extends Lifecycle {
    /**
     * 当前状态
     */
    private State mState;
    /**
     * LifecycleOwner的实现往往是Activity或Fragment，使用弱引用来避免内存泄漏
     */
    private final WeakReference<LifecycleOwner> mLifecycleOwner;
    
    public LifecycleRegistry(LifecycleOwner provider) {
        mLifecycleOwner = new WeakReference<>(provider);
        mState = Lifecycle.State.INITIALIZED;
    }
}

addObserver()，把传入的LifecycleObserver和当前state包装为一个ObserverWithState对象，目的是为了把多种回调方式，统一回调dispatchEvent()方法。

当添加LifecycleObserver时，Lifecycle的状态可能不是INITIALIZED状态了，所以需要把之前经过的状态都补发给LifecycleObserver，所以通过一个循环来分发

@Override
public void addObserver(LifecycleObserver observer) {
    State initialState = mState == Lifecycle.State.DESTROYED ? Lifecycle.State.DESTROYED : Lifecycle.State.INITIALIZED;
    //把LifecycleObserver和状态State，包装为一个ObserverWithState对象
    ObserverWithState statefulObserver = new ObserverWithState(observer, initialState);
    ObserverWithState previous = mObserverMap.putIfAbsent(observer, statefulObserver);

    if (previous != null) {
        //如果已经添加过了，则不重复添加
        return;
    }
    LifecycleOwner lifecycleOwner = mLifecycleOwner.get();
    if (lifecycleOwner == null) {
        //如果LifecycleOwner已经被销毁了，直接return
        return;
    }

    //如果为true，则说明此时是多线程同时调用addObserver()，或者正在向外回调状态
    boolean isReentrance = mAddingObserverCounter != 0 || mHandlingEvent;
    //计算目标状态
    State targetState = calculateTargetState(observer);
    //自增，标记正在向新添加的LifecycleObserver回调Event值
    mAddingObserverCounter++;
    //statefulObserver.mState.compareTo(targetState) < 0，如果为true，则说明State值还没遍历到目标状态
    //mObserverMap.contains(observer)，如果为true，则代表observer还没有并移除，因为有可能在遍历过程中observer就被移除了，所以每次循环都检查下
    while ((statefulObserver.mState.compareTo(targetState) < 0
            && mObserverMap.contains(observer))) {
        //将observer已经遍历到的当前的状态值mState保存下来
        pushParentState(statefulObserver.mState);
        //向observer回调进入“statefulObserver.mState”前需要收到的 Event 值
        statefulObserver.dispatchEvent(lifecycleOwner, upEvent(statefulObserver.mState));
        //移除mState
        popParentState();
        // mState / subling may have been changed recalculate
        targetState = calculateTargetState(observer);
    }

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

sync()，派发状态给监听器

如果关闭页面时，当前状态在RESUME，则需要回调状态为onPause、onStop、onDestroy，这种向后传递的方式，被称为backwardPass

如果打开一个新页面，会执行onCreate、onStart、onResume，这种向前传递，被称为forwardPass

/**
 * 派发状态
 */
private void sync() {
    // happens only on the top of stack (never in reentrance),
    // so it doesn't have to take in account parents
    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 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();
        }
    }
}

/**
 * 向前传递
 */
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();
        }
    }
}

ObserverWithState，封装LifecycleEventObserver和State，通过Lifecycling把监听器包装为统一的LifecycleEventObserver类型，回调生命周期则统一调用onStateChanged方法来统一入口

static class ObserverWithState {
    State mState;
    LifecycleEventObserver mLifecycleObserver;

    ObserverWithState(LifecycleObserver observer, State initialState) {
        //统一把监听器包装为LifecycleEventObserver
        mLifecycleObserver = Lifecycling.lifecycleEventObserver(observer);
        mState = initialState;
    }

    /**
     * 分发事件
     */
    void dispatchEvent(LifecycleOwner owner, Event event) {
        State newState = getStateAfter(event);
        mState = min(mState, newState);
        //统一调用onStateChanged()，转发到各种不同使用方式的LifecycleObserver
        mLifecycleObserver.onStateChanged(owner, event);
        mState = newState;
    }
}

前面在分析ReportFragment的时候，我们知道ReportFragment在向外分发事件时，调用的是LifecycleRegistry的handleLifecycleEvent(event)方法，这个方法会把Event转换为对应的State，然后更新当前State，再回调所有Observer监听器，最终都会调用到ObserverWithState的dispatchEvent()方法

/**
 * 更新状态，并派发生命周期事件给订阅者，如果指定状态和当前状态相同，则不会被派发
 */
public void handleLifecycleEvent(Lifecycle.Event event) {
    //获取事件的下一个状态
    State next = getStateAfter(event);
    //更新状态
    moveToState(next);
}

/**
 * 更新状态
 */
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;
}

Lifecycling

ObserverWithState类的构造方法中，调用了Lifecycling的lifecycleEventObserver()方法，把LifecycleObserver监听器统一包装为了一个LifecycleEventObserver，对外统一暴露onStateChanged()方法来触发回调

前2种情况，对LifecycleEventObserver和FullLifecycleObserver类型进行包装，通过一个适配器FullLifecycleObserverAdapter，在onStateChanged()方法中，转调LifecycleEventObserver和FullLifecycleObserver，达到适配的目的。

如果传入的直接就是LifecycleEventObserver类型，则直接就有onStateChanged()方法，那么不需要适配，直接返回即可

第3种，注解 + APT生成适配类是和注解 + 反射，第一个是通过SingleGeneratedAdapterObserver或CompositeGeneratedAdaptersObserver这2种适配器进行适配，而反射的方式则是通过ReflectiveGenericLifecycleObserver适配器进行适配

/**
 * 把不同订阅方式的订阅者，统一包装为一个LifecycleEventObserver
 * 事件改变时，统一调用LifecycleEventObserver类的onStateChanged()方法，再适配到不同的订阅方式
 *
 * @param object 订阅者
 */
static LifecycleEventObserver lifecycleEventObserver(Object object) {
    //统一回调onStateChanged()方法的订阅方式
    boolean isLifecycleEventObserver = object instanceof LifecycleEventObserver;
    //分发为详细的生命周期方法的订阅方式
    boolean isFullLifecycleObserver = object instanceof FullLifecycleObserver;
    //实现了2种方式的接口，则通过一个适配器来同时支持
    if (isLifecycleEventObserver && isFullLifecycleObserver) {
        return new FullLifecycleObserverAdapter((FullLifecycleObserver) object,
                (LifecycleEventObserver) object);
    }
    //只需要详细方式的回调，也通过适配器，但把第二个参数置空即可
    if (isFullLifecycleObserver) {
        return new FullLifecycleObserverAdapter((FullLifecycleObserver) object, null);
    }
    //统一回调方式，直接返回，不需要适配器处理
    if (isLifecycleEventObserver) {
        return (LifecycleEventObserver) object;
    }
    //通过注解 + APT编译时生成的Class的方式订阅
    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);
}

LifecycleEventObserver和FullLifecycleObserver类型的适配，这2种方式的适配比较简单，LifecycleEventObserver本身就自带onStateChanged()方法，直接在adapter类的回调中转发即可。而FullLifecycleObserver是拆分了具体的回调方法，那么在adapter类的回调中判断具体类型，再做转发即可

class FullLifecycleObserverAdapter implements LifecycleEventObserver {
    private final FullLifecycleObserver mFullLifecycleObserver;
    private final LifecycleEventObserver mLifecycleEventObserver;

    FullLifecycleObserverAdapter(FullLifecycleObserver fullLifecycleObserver,
                                 LifecycleEventObserver lifecycleEventObserver) {
        mFullLifecycleObserver = fullLifecycleObserver;
        mLifecycleEventObserver = lifecycleEventObserver;
    }

    @Override
    public void onStateChanged(LifecycleOwner source, Lifecycle.Event event) {
        //详细具体方法回调的派发
        switch (event) {
            case ON_CREATE:
                mFullLifecycleObserver.onCreate(source);
                break;
            case ON_START:
                mFullLifecycleObserver.onStart(source);
                break;
            case ON_RESUME:
                mFullLifecycleObserver.onResume(source);
                break;
            case ON_PAUSE:
                mFullLifecycleObserver.onPause(source);
                break;
            case ON_STOP:
                mFullLifecycleObserver.onStop(source);
                break;
            case ON_DESTROY:
                mFullLifecycleObserver.onDestroy(source);
                break;
            case ON_ANY:
                throw new IllegalArgumentException("ON_ANY must not been send by anybody");
        }
        //统一为一个状态变化方法回调的派发
        if (mLifecycleEventObserver != null) {
            mLifecycleEventObserver.onStateChanged(source, event);
        }
    }
}

第3种情况，是通过反射来进行回调，那么需要解析监听器上的方法、注解，并且因为反射比较消耗性能，所以需要进行缓存，而回调参数有多种，则需要进行校验，如参数不符合规定的个数，还需要进行异常抛出

getObserverConstructorType，获取监听器的构造类型，由于获取构造方法是使用反射，比较消耗性能，所以有一个sCallbackCache缓存Map，如果从缓存中查找到，则直接返回，否则通过resolveObserverCallbackType()获取回调类型

/**
 * 回调类型，反射
 */
private static final int REFLECTIVE_CALLBACK = 1;
/**
 * 回调类型，APT生成
 */
private static final int GENERATED_CALLBACK = 2;

/**
 * 回调类型缓存Map，避免每次反射查找构造函数的低效
 */
private static final Map<Class, Integer> sCallbackCache = new HashMap<>();

/**
 * 获取订阅者的构造类型
 */
private static int getObserverConstructorType(Class<?> klass) {
    //优先缓存中拿，找得到则直接返回
    Integer callbackCache = sCallbackCache.get(klass);
    if (callbackCache != null) {
        return callbackCache;
    }
    //找不到缓存，查询订阅的回调类型
    int type = resolveObserverCallbackType(klass);
    //查询到，加入缓存中
    sCallbackCache.put(klass, type);
    return type;
}

/**
 * 查询订阅者的回调类型
 */
private static int resolveObserverCallbackType(Class<?> klass) {
    // anonymous class bug:35073837
    //获取不到类名，使用反射的方式
    if (klass.getCanonicalName() == null) {
        return REFLECTIVE_CALLBACK;
    }
    //获取APT方式生成的适配器类的构造方法
    Constructor<? extends GeneratedAdapter> constructor = generatedConstructor(klass);
    //获取成功，放进缓存
    if (constructor != null) {
        sClassToAdapters.put(klass, Collections
                .<Constructor<? extends GeneratedAdapter>>singletonList(constructor));
        return GENERATED_CALLBACK;
    }
    //获取失败，则只能通过反射的方式回调，则通过反射查询加了注解的回调方法
    boolean hasLifecycleMethods = ClassesInfoCache.sInstance.hasLifecycleMethods(klass);
    if (hasLifecycleMethods) {
        return REFLECTIVE_CALLBACK;
    }

    //没有查找到，去父类上找
    Class<?> superclass = klass.getSuperclass();
    List<Constructor<? extends GeneratedAdapter>> adapterConstructors = null;
    if (isLifecycleParent(superclass)) {
        if (getObserverConstructorType(superclass) == REFLECTIVE_CALLBACK) {
            return REFLECTIVE_CALLBACK;
        }
        adapterConstructors = new ArrayList<>(sClassToAdapters.get(superclass));
    }

    for (Class<?> intrface : klass.getInterfaces()) {
        if (!isLifecycleParent(intrface)) {
            continue;
        }
        if (getObserverConstructorType(intrface) == REFLECTIVE_CALLBACK) {
            return REFLECTIVE_CALLBACK;
        }
        if (adapterConstructors == null) {
            adapterConstructors = new ArrayList<>();
        }
        adapterConstructors.addAll(sClassToAdapters.get(intrface));
    }
    if (adapterConstructors != null) {
        sClassToAdapters.put(klass, adapterConstructors);
        return GENERATED_CALLBACK;
    }

    return REFLECTIVE_CALLBACK;
}

因为有APT方式生成的适配器类的方式，以及反射回调的方式，所以需要先判断是否存在APT生成的适配器类，有则加载适配器类，同时获取适配器类的构造方法

/**
 * 获取APT方式生成的适配器类的构造方法
 */
private static Constructor<? extends GeneratedAdapter> generatedConstructor(Class<?> klass) {
    try {
        Package aPackage = klass.getPackage();
        String name = klass.getCanonicalName();
        //获取全类名
        final String fullPackage = aPackage != null ? aPackage.getName() : "";
        //根据特定的规则，组合出适配器的类名
        final String adapterName = getAdapterName(fullPackage.isEmpty() ? name :
                name.substring(fullPackage.length() + 1));
        //加载生成的适配器类
        @SuppressWarnings("unchecked") final Class<? extends GeneratedAdapter> aClass =
                (Class<? extends GeneratedAdapter>) Class.forName(
                        fullPackage.isEmpty() ? adapterName : fullPackage + "." + adapterName);
        //如果找得到，则返回生成的适配器类的构造方法对象
        Constructor<? extends GeneratedAdapter> constructor =
                aClass.getDeclaredConstructor(klass);
        //如果构造方法是私有的，把无视私有操作符，把访问限制设置为允许
        if (!constructor.isAccessible()) {
            constructor.setAccessible(true);
        }
        return constructor;
    } catch (ClassNotFoundException e) {
        //没有适配器类，只能使用反射
        return null;
    } catch (NoSuchMethodException e) {
        throw new RuntimeException(e);
    }
}

适配器的类名是通过一定规则拼接而成的，例如：BroadcastRegistry.RegistryTableItem是订阅者类名，则生成的适配类为BroadcastRegistry_RegistryTableItem_LifecycleAdapter

public static String getAdapterName(String className) {
    return className.replace(".", "_") + "_LifecycleAdapter";
}

获取失败，则使用反射的方式，ClassesInfoCache类用于查询订阅者上的注解方法，缓存方法，反射回调方法则通过MethodReference内部类进行调用

其中，有一个mHasLifecycleMethods缓存Map，当查询监听器上的生命周期回调方法时，如果缓存中有则直接返回，避免每次调用都查找一次的低效

class ClassesInfoCache {
    /**
     * 单实例
     */
    static ClassesInfoCache sInstance = new ClassesInfoCache();
    
    /**
     * 回调信息缓存
     */
    private final Map<Class, CallbackInfo> mCallbackMap = new HashMap<>();
    /**
     * 是否有生命周期回调方法的缓存
     */
    private final Map<Class, Boolean> mHasLifecycleMethods = new HashMap<>();
    
    /**
     * 判断订阅者上是否有生命周期回调方法
     */
    boolean hasLifecycleMethods(Class klass) {
        //优先从缓存中获取，缓存中有则直接返回
        Boolean hasLifecycleMethods = mHasLifecycleMethods.get(klass);
        if (hasLifecycleMethods != null) {
            return hasLifecycleMethods;
        }
        //没有缓存，反射获取方法列表
        Method[] methods = getDeclaredMethods(klass);
        //遍历判断有没有方法加了@OnLifecycleEvent注解
        for (Method method : methods) {
            OnLifecycleEvent annotation = method.getAnnotation(OnLifecycleEvent.class);
            if (annotation != null) {
                // Optimization for reflection, we know that this method is called
                // when there is no generated adapter. But there are methods with @OnLifecycleEvent
                // so we know that will use ReflectiveGenericLifecycleObserver,
                // so we createInfo in advance.
                // CreateInfo always initialize mHasLifecycleMethods for a class, so we don't do it
                // here.
                //缓存回调信息
                createInfo(klass, methods);
                return true;
            }
        }
        //没有找到方法，加入缓存中
        mHasLifecycleMethods.put(klass, false);
        return false;
    }
}

• createInfo()，创建回调信息，查找回调方法，解析注解和形参，限制形参的个数和类型，确定一个回调类型和Method引用保存到MethodReference对象，反射回调的操作统一都在MethodReference中，处理不同形参的回调，最后把信息保存到CallbackInfo类中，以及加入到mCallbackMap缓存Map中

/**
 * 无形参的回调方法
 */
private static final int CALL_TYPE_NO_ARG = 0;
/**
 * 只有1个形参，并且形参类型为LifecycleOwner的回调方法
 */
private static final int CALL_TYPE_PROVIDER = 1;
/**
 * 有2个形参，并且形参类型为LifecycleOwner和Event事件类型的回调方法
 */
private static final int CALL_TYPE_PROVIDER_WITH_EVENT = 2;

/**
 * 把回调方法的信息都保存到一个CallbackInfo对象中
 */
private CallbackInfo createInfo(Class klass, Method[] declaredMethods) {
    //获取父类Class
    Class superclass = klass.getSuperclass();
    //回调方法和对应的事件Map
    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();
        //如果参数个数为0，则callType = CALL_TYPE_NO_ARG，method不包含入参参数
        int callType = CALL_TYPE_NO_ARG;
        //如果参数个数大于0，则第一个参数必须是LifecycleOwner类型的对象，否则抛出异常
        if (params.length > 0) {
            //如果参数个数为1，则 callType = CALL_TYPE_PROVIDER
            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();
        //如果参数个数为 2，注解值必须是Lifecycle.Event类型，而注解值，必须是Lifecycle.Event.ON_ANY
        if (params.length > 1) {
            //设置callType = CALL_TYPE_PROVIDER_WITH_EVENT
            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");
            }
        }
        //如果参数个数大于2，则抛出异常，所以要求回调方法最多包含两个参数，且对参数类型和参数顺序进行了限制
        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;
}

/**
 * 存储回调信息的类
 */
@SuppressWarnings("WeakerAccess")
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());
        }
    }

    /**
     * 回调生命周期方法
     *
     * @param source 事件源
     * @param event  事件
     * @param target 要被回调的订阅者
     */
    @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);
            }
        }
    }
}

MethodReference

在createInfo()方法中，已经限制和校验回调类型，在MethodReference中根据不同的回调参数进行反射回调，即可调用到监听器的生命周期方法

/**
 * 方法引用，处理方法调用
 */
@SuppressWarnings("WeakerAccess")
static class MethodReference {
    /**
     * 回调类型
     */
    final int mCallType;
    /**
     * 方法引用
     */
    final Method mMethod;

    MethodReference(int callType, Method method) {
        mCallType = callType;
        mMethod = method;
        //设置可访问，所以如果设置为private也可以调用
        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 == null || getClass() != o.getClass()) {
            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();
    }
}

ReflectiveGenericLifecycleObserver

在适配器中，通过ClassesInfoCache获取订阅者的CallbackInfo信息，在onStateChanged()回调方法中，调用CallbackInfo的invokeCallbacks()方法，执行反射回调

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, Lifecycle.Event event) {
        //反射回调方法
        mInfo.invokeCallbacks(source, event, mWrapped);
    }
}

class ClassesInfoCache {
    //省略其他方法...

    /**
     * 获取订阅者的回调信息
     */
    CallbackInfo getInfo(Class klass) {
        CallbackInfo existing = mCallbackMap.get(klass);
        if (existing != null) {
            return existing;
        }
        existing = createInfo(klass, null);
        return existing;
    }

    //省略其他方法...
}

总结

梳理一下Lifecycle的总体流程，分为以下几步

• 我们平时使用的AppCompatActivity、Fragment，都实现了LifecycleOwner接口，在getLifecycle()方法中，返回的Lifecycle对象，都为LifecycleRegistry的实例
• AppCompatActivity的onCreate()方法中，默认都插入一个透明的ReportFragment，通过它来获取生命周期，其中当API大于29，就是安卓10以上时，直接通过activity注册生命周期来获取生命周期，29以下则通过ReportFragment来获取
• 无论是第二步的哪种方式获取，都会通过ReportFragment的dispatch(activity, event)方法进行分发，该方法把生命周期事件交给LifecycleRegistry，调用它的handleLifecycleEvent(event)
• LifecycleRegistry.handleLifecycleEvent(event)中，会把所有的LifecycleObserver监听器都包装为ObserverWithState类，通过Lifecycling，把回调方式都统一为LifecycleEventObserver，屏蔽不同监听类型的监听器的差异，统一回调入口
• Lifecycling包装监听器为LifecycleEventObserver，当包装的监听器回调onStateChanged()时，就把事件回调给我们设置的监听器回调方法