Lifecycle简介

Jetpack is a suite of libraries to help developers follow best practices, reduce boilerplate code, and write code that works consistently across Android versions and devices so that developers can focus on the code they care about.

Jetpack是Google为了解决Android架构问题而引入的，也归纳了很多能够帮助开发者更好更方便地构建应用程序的组件。

Lifecycle组件是Jetpack库的架构组件中基础性的生命周期感知型组件，提供了可用于构建生命周期感知型组件的类和接口。这些类和接口可以根据 Activity 或 Fragment 的当前生命周期状态自动调整行为，有助于开发者写出更精简更健壮更容易维护的代码。

重学安卓：为你还原一个真实的 Jetpack Lifecycle

Lifecycle 的存在，是为了：

1.实现生命周期 管理的一致性，做到 “一处修改、处处生效”。

2.让第三方组件能够 随时在自己内部拿到生命周期状态，以便执行 及时叫停错过时机的异步业务 等强生命周期操作。

3.让第三方组件在调试时能够 更方便和安全地追踪到事故所在的生命周期源。

Lifecycle出现前

Lifecycle出现前，手段管理生命周期 的方式一般为：定义生命周期组件，然后在 Activity 和 Fragment 的生命周期方法中调用和生命周期相对应的回调组件方法。

手段管理生命周期的例子

class MyListener {
    public MyLocationListener(Context context, Callback callback) {
        // 可能持有Activity或Fragment的引用
    }

    void start() {
       //
    }

    void stop() {
        // 
    }
}

class MyActivity extends AppCompatActivity {

        private MyListener myListener1;
        private MyListener myListener2;

        @Override
        public void onCreate(...) {
           ...
        }

        @Override
        public void onStart() {
            super.onStart();
            myLocationListener1.start();
            myLocationListener2.start();
            // 管理其他需要响应activity生命周期的组件

        }

        @Override
        public void onStop() {
            super.onStop();
            myLocationListener1.stop();
            myLocationListener2.stop();
            // 管理其他需要响应activity生命周期的组件

        }
        ...
}

如上例所示，MyActivity会在每个生命周期方法中调用自定义生命周期组件，每个组件都对应一个对象，MyActivity很可能需要在在每个生命周期方法中都需要调用多个自定义生命周期组件。

手动管理生命周期的弊端

难以维护 在实际业务中，一般需要管理大量页面和大量自定义生命周期组件，随着持续的业务迭代和人员调整，项目很可能出现各种小差错。
无法自定义组件会在 Activity/Fragment停止前启动 在我们需要执行长时间运行的操作（如 onStart() 中的某种配置检查）时尤其如此。这可能会导致出现一种竞态条件，在这种条件下，onStop() 方法会在 onStart() 之前结束，这使得自定义组件留存的时间比所需的时间要长。

使用Lifecycle

使用Lifecycle之后管理生命周期的例子

配置

a. 添加 Google's Maven repository

b. build.gradle添加依赖

dependencies {

        val lifecycle_version = "2.5.0-alpha04"
        val arch_version = "2.1.0"

        // ViewModel
        implementation("androidx.lifecycle:lifecycle-viewmodel-ktx:$lifecycle_version")
        // ViewModel utilities for Compose
        implementation("androidx.lifecycle:lifecycle-viewmodel-compose:$lifecycle_version")
        // LiveData
        implementation("androidx.lifecycle:lifecycle-livedata-ktx:$lifecycle_version")
        // Lifecycles only (without ViewModel or LiveData)
        implementation("androidx.lifecycle:lifecycle-runtime-ktx:$lifecycle_version")
        // Saved state module for ViewModel
        implementation("androidx.lifecycle:lifecycle-viewmodel-savedstate:$lifecycle_version")
        // Annotation processor
        kapt("androidx.lifecycle:lifecycle-compiler:$lifecycle_version")
        // alternately - if using Java8, use the following instead of lifecycle-compiler
        implementation("androidx.lifecycle:lifecycle-common-java8:$lifecycle_version")
        // optional - helpers for implementing LifecycleOwner in a Service
        implementation("androidx.lifecycle:lifecycle-service:$lifecycle_version")
        // optional - ProcessLifecycleOwner provides a lifecycle for the whole application process
        implementation("androidx.lifecycle:lifecycle-process:$lifecycle_version")
        // optional - ReactiveStreams support for LiveData
        implementation("androidx.lifecycle:lifecycle-reactivestreams-ktx:$lifecycle_version")
        // optional - Test helpers for LiveData
        testImplementation("androidx.arch.core:core-testing:$arch_version")
 }

构建具有生命周期的页面（被观察者） LifecycleOwner接口的实现类具有Android生命周期，常用的FragmentActivity和Fragment都继承了这个接口。
构建观察者

从Java8开始，推荐使用DefaultLifecycleObserver构建LifecycleObserver对象。 只实现需要的方法

val myObserver = object : DefaultLifecycleObserver {

    override fun onCreate(owner: LifecycleOwner) {
    ...
    }

    override fun onStop(owner: LifecycleOwner) {
    ... 
    }
}

// DefaultLifecycleObserver.java 
public interface DefaultLifecycleObserver extends FullLifecycleObserver {

    @Override
    default void onCreate(@NonNull LifecycleOwner owner) {
    }

    @Override
    default void onStart(@NonNull LifecycleOwner owner) {
    }

    @Override
    default void onResume(@NonNull LifecycleOwner owner) {
    }

    @Override
    default void onPause(@NonNull LifecycleOwner owner) {
    }

    @Override
    default void onStop(@NonNull LifecycleOwner owner) {
    }

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

}

将被观察者与观察者绑定

// LifecycleOwner的实现类可以获取lifecycle
lifecycle.addObserver(myObserver)

完成这些步骤后，页面的生命周期变化时会通知绑定的观察者，触发我们实现的方法。

注：不推荐以下实例所示的@OnLifecycleEvent注解。使用该注解需要在编译时期使用 apt 根据注解生成对应逻辑，并根据反射调用回调方法，好处仅是写法简单。Java8支持接口方法具有默认实现，使得DefaultLifecycleObserver写法和@OnLifecycleEvent注解一样简单，省去了反射的性能损耗。

lifecycle.addObserver(object : LifecycleObserver {
    @OnLifecycleEvent(Lifecycle.Event.ON_RESUME)
    fun onResume() {
    }
})

源码分析

整体流程图

Activity/Fragment的生命周期变化
ReportFragment/Fragment对象会将生命周期事件分发给LifecycleRegistry对象
LifecycleRegistry对象会根据生命周期事件处理之前添加的每个observer

核心类型

Lifecycle类

Lifecycle 使用两种枚举跟踪其关联组件的生命周期状态：

Event（生命周期事件），LifecycleOwner生命周期变化时会触发Event，看作生命周期状态转移图的边
State（生命周期状态），LifecycleOwner的当前状态，看作生命周期状态转移图的点

public abstract class Lifecycle {

    ...

    @MainThread
    public abstract void addObserver(@NonNull LifecycleObserver observer);
    @MainThread
    public abstract void removeObserver(@NonNull LifecycleObserver observer);
    @MainThread
    @NonNull
    public abstract State getCurrentState();
    // Event类用于抽象Activity/Fragment的生命周期事件发生变化时所触发的事件
    public enum Event {
        ON_CREATE,
        ON_START,
        ON_RESUME,
        ON_PAUSE,
        ON_STOP,
        ON_DESTROY,
        ON_ANY;
        // 改变State需要的Event
        public static Event downFrom(@NonNull State state) {...}
        public static Event downTo(@NonNull State state) {...}
        public static Event upFrom(@NonNull State state) {...}
        public static Event upTo(@NonNull State state) {...}
        // 通知Event事件时的State
        public State getTargetState() {...}
    }

    // 生命周期状态
    public enum State {
        // LifecycleOwner的销毁状态。在此事件之后，此生命周期将不再派发任何事件。
        //例如，对于android.app.Activity，在 Activity的onDestroy调用之前达到此状态
        DESTROYED,
        // LifecycleOwner的初始化状态。
        // 例如，对于android.app.Activity，这是它被构造但尚未收到onCreate时的状态
        INITIALIZED,
        // LifecycleOwner的创建状态。
        // 例如对于android.app.Activity ，在两种情况下会达到此状态：在onCreate调用之后；就在onStop调用之前
        CREATED,
        // LifecycleOwner的启动状态。
        // 例如，对于android.app.Activity，在两种情况下会达到此状态：在onStart调用之后；在onPause调用之前
        STARTED,
        // LifecycleOwner的恢复状态。
        // 例如，对于android.app.Activity，在调用onResume后达到此状态。
        RESUMED;
        public boolean isAtLeast(@NonNull State state) {
            return compareTo(state) >= 0;
        }
    }
}

生命周期状态转移图

Event触发的时机：

ON_CREATE、ON_START、ON_RESUME事件，是在LifecycleOwner对应的方法执行之后分发；
ON_PAUSE、ON_STOP、ON_DESTROY事件，是在LifecycleOwner对应的方法调用之前分发；

LifecycleOwner接口

标记其实现类的对象具备 Android生命周期

public interface LifecycleOwner {
    @NonNull
    Lifecycle getLifecycle();
}

LifecycleObserver接口

标记实现类可以观察生命周期

public interface LifecycleObserver {
}

public interface LifecycleEventObserver extends LifecycleObserver {
    void onStateChanged(@NonNull LifecycleOwner source, @NonNull Lifecycle.Event event);
}

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

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

    @Override
    default void onStart(@NonNull LifecycleOwner owner) {
    }
    
    @Override
    default void onResume(@NonNull LifecycleOwner owner) {
    }

    @Override
    default void onPause(@NonNull LifecycleOwner owner) {
    }

    @Override
    default void onStop(@NonNull LifecycleOwner owner) {
    }

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

实现思路

LifecycleOwner：将生命周期事件交给对应的LifecycleRegistry

无论AppCompatActivity、Fragment还是其他实现LifecycleOwner 接口的对象，实现的逻辑都是一样的，将生命周期事件交给各自的LifecycleRegistry处理。

AppCompatActivity实现LifecycleOwner接口

AppCompatActivity实现LifecycleOwner接口，是在ComponentActivity中完成。

public class ComponentActivity extends androidx.core.app.ComponentActivity implements LifecycleOwner {
    ...
    // LifecycleRegistry是Lifecycle的具体实现
    private final LifecycleRegistry mLifecycleRegistry = new LifecycleRegistry(this);
    
    public Lifecycle getLifecycle() {
        return mLifecycleRegistry;
    }

    public ComponentActivity() {
        Lifecycle lifecycle = getLifecycle();
        ...
        // 添加观察者
        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 ) {
                          ...
                        }
                 }
         }) ;
       }
       getLifecycle().addObserver(new LifecycleEventObserver () {
            @Override
            public void onStateChanged ( @NonNull LifecycleOwner source, @NonNull Lifecycle.Event event ) {
                 if ( event == Lifecycle.Event.ON_DESTROY ) {
                        ...
                  }
             }
       });
       getLifecycle().addObserver(new LifecycleEventObserver () {
           @Override
            public void onStateChanged ( @NonNull LifecycleOwner source, @NonNull Lifecycle.Event event ) {
                ensureViewModelStore () ;
                getLifecycle () .removeObserver ( this ) ;
            }
        } );
        if (19 <= SDK_INT && SDK_INT <= 23) {
             getLifecycle () .addObserver ( new ImmLeaksCleaner ( this )) ;
        }
    }

    ...

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

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

ComponentActivity注册了ReportFragment，将处理生命周期事件的职责委托给它处理。

ReportFragment的两种分发方式

ReportFragment收到ComponentActivity的生命周期事件后，会分发给注册的回调类。

ReportFragmentjava

public static void injectIfNeededIn(Activity activity) {
        if (Build.VERSION.SDK_INT >= 29) {
            LifecycleCallbacks.registerIn(activity);
        }

        // 添加ReportFragment
        // 与ProcessLifecycleOwner和非继承support.FragmentActivity的Activity兼容
        android.app.FragmentManager manager = activity.getFragmentManager();
        if (manager.findFragmentByTag(REPORT_FRAGMENT_TAG) == null) {
            manager.beginTransaction().add(new ReportFragment(), REPORT_FRAGMENT_TAG).commit();
            manager.executePendingTransactions();
        }
    }

根据系统版本号不同，ReportFragment.``injectIfNeededI``n``(Activity activity)有两种分发方式：

运行设备的系统版本号>= 29时，向 Activity 注册 LifecycleCallbacks对象。LifecycleCallbacks是Application.ActivityLifecycleCallbacks的子类。注册之后，Activity 的生命周期变化时会触发LifecycleCallbacks的对应方法，从而调用ReportFragment.dispatch方法。 ReportFragment.dispatch方法是activity真正分发生命周期事件的地方，随后介绍。

@RequiresApi(29)
static class LifecycleCallbacks implements Application.ActivityLifecycleCallbacks {
    static void registerIn(Activity activity) {
        // 让activity注册LifecycleCallbacks 
        activity.registerActivityLifecycleCallbacks(new LifecycleCallbacks () );
    }

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

}

向 Activity 添加一个无 UI 界面的 ReportFragment 通过ReportFragment间接感知 Activity 的各个生命周期事件，若版本号大于29，会调用dispatch方法。

ReportFragment.java

private void dispatchCreate(ActivityInitializationListener listener) {
     if (listener != null) {
         listener.onCreate () ;
     }
 }
...
@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 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) {
        dispatch( getActivity () , event ) ;
    }
 }

interface ActivityInitializationListener {
    void onCreate();
    void onStart();
    void onResume();
 }

dispatch方法：分发事件

dispatch方法将生命周期事件交给activity的LifecycleRegistry 对象处理。

static void dispatch(@NonNull Activity activity, @NonNull Lifecycle.Event event) {
    if (activity instanceof LifecycleOwner) {
        Lifecycle lifecycle = ((LifecycleOwner) activity).getLifecycle();
        if (lifecycle instanceof LifecycleRegistry) {
            // LifecycleRegistry属于Activity
            ((LifecycleRegistry) lifecycle).handleLifecycleEvent(event);
        }
    }
}

Fragment实现LifecycleOwner接口

Fragment不需要分发生命周期事件，在生命周期变化时直接将生命周期事件交给LifecycleRegistry 对象处理。

Fragment.java

LifecycleRegistry mLifecycleRegistry;

public Fragment() {
    initLifecycle();
}

private void initLifecycle() {
    mLifecycleRegistry = new LifecycleRegistry(this);
    ...
}

public Lifecycle getLifecycle() {
    return mLifecycleRegistry;
}

void performCreate(Bundle savedInstanceState) {
    ...
    onCreate(savedInstanceState);
    mLifecycleRegistry.handleLifecycleEvent(Lifecycle.Event.ON_CREATE);
}


void performStart() {
    onStart();
    mLifecycleRegistry.handleLifecycleEvent(Lifecycle.Event.ON_START);
    ...
}
...

LifecycleRegistry：具体处理逻辑

LifecycleRegistry屏蔽了LifecycleOwner的具体类型，使得其他类只需要转发生命周期事件，但是它的方法只能在主线程执行。由 LifecycleRegistry 来实现具体的事件回调和状态管理，更加统一和规范化。

需要处理生命周期事件的情况有两种：

获取到dispatch方法分发出的生命周期事件
添加Observer时会逐步触发对应生命周期之前的回调

LifecycleRegistry内部逻辑

添加观察者

addObserver方法，只能用于主线程

LifecycleRegistry.java

// 持有虚引用
private final WeakReference<LifecycleOwner> mLifecycleOwner;

public void addObserver(@NonNull LifecycleObserver observer) {
    // 校验主线程
    enforceMainThreadIfNeeded("addObserver");
    State initialState = mState == DESTROYED ? DESTROYED : INITIALIZED;
    // 将observer和生命周期状态包装为ObserverWithState对象，注释1
    ObserverWithState statefulObserver = new ObserverWithState(observer, initialState);
    // 不重复添加ObserverWithState对象 
    ObserverWithState previous = mObserverMap.putIfAbsent(observer, statefulObserver);
    if (previous != null) {
       return;
    }

    // 校验虚引用lifecycleOwner
    LifecycleOwner lifecycleOwner = mLifecycleOwner.get();
    if (lifecycleOwner == null) {
        return;
    }

    // 不是正在添加observer的过程且不是正在处理生命周期事件的过程中
    boolean isReentrance = mAddingObserverCounter != 0 || mHandlingEvent;
    // 期望的observer生命周期状态
    State targetState = calculateTargetState(observer);
    mAddingObserverCounter++;
    // 注释3
    while ((statefulObserver.mState.compareTo(targetState) < 0
            && mObserverMap.contains(observer)) ) {
        // 将 observer 已经遍历到的当前的状态值 mState 保存下来
        pushParentState ( statefulObserver.mState ) ;
        // 只会得到并处理下一个Event
        final Event event = Event.upFrom( statefulObserver.mState ) ;
        ...
        // 处理生命周期状态
        statefulObserver.dispatchEvent ( lifecycleOwner, event ) ;
        // 移除 mState
        popParentState () ;
        // 期望状态可能有了变化
        targetState = calculateTargetState ( observer ) ;
    }
    if (!isReentrance) {
        // we do sync only on the top level.
        sync () ;
    }
    mAddingObserverCounter--;
 }

static class ObserverWithState {

    State mState;
    LifecycleEventObserver mLifecycleObserver;

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

    void dispatchEvent(LifecycleOwner owner, Event event) {
        State newState = event.getTargetState();
        mState = min(mState, newState);
        // 触发我们自定义的回调
        mLifecycleObserver.onStateChanged(owner, event);
        mState = newState;
    }
}

将LifecycleObserver对象observer包装为ObserverWithState对象，使observer有了生命周期状态。
将observer以<LifecycleObserver, ObserverWithState>的形式存储在mObserverMap中。而ObserverWithState 将传入的LifecycleObserver对象包装为LifecycleEventObserver。

适配器模式

Lifecycling将LifecycleEventObserver和LifecycleEventObserver类型统一转换为LifecycleEventObserver的子类型，以便统一触发回调。之前推荐使用的FullLifecycleObserver就是被转换为FullLifecycleObserverAdapter，推荐不使用的OnLifecycleEvent写法会在这根据注解生成具体逻辑再通过反射调用。

Lifecycling.java

static LifecycleEventObserver lifecycleEventObserver(Object object) {
    boolean isLifecycleEventObserver = object instanceof LifecycleEventObserver;
    boolean isFullLifecycleObserver = object instanceof FullLifecycleObserver;
    // FullLifecycleObserver写法
    if (isLifecycleEventObserver && isFullLifecycleObserver) {
         return new FullLifecycleObserverAdapter (( FullLifecycleObserver ) object, ( LifecycleEventObserver ) object ) ;
    }
    if (isFullLifecycleObserver) {
         return new FullLifecycleObserverAdapter (( FullLifecycleObserver ) object, null ) ;
    }
   if (isLifecycleEventObserver) {
         return ( LifecycleEventObserver ) object;
    }
    // @OnLifecycleEvent写法
    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);
 }

public interface LifecycleEventObserver extends LifecycleObserver {
     void onStateChanged(@NonNull LifecycleOwner source, @NonNull Lifecycle.Event event);
}

向添加的observer同步最新生命周期事件，触发我们自定义的回调。例如，在activity处于 RESUMED 状态时添加一个observer，observer会收到CREATED、STARTED、RESUMED 三个 Event。

删除观察者

removeObserver方法删除观察者，从mObserverMap删除observer

 public void removeObserver(@NonNull LifecycleObserver observer) {
       mObserverMap.remove(observer);
 }

更新状态，触发observer

LifecycleRegistry收到ReportFragment分发的事件后，调用moveToState方法更新状态。moveToState方法负责判断是否更新，实际处理所有observer的过程在sync()方法中。

public void handleLifecycleEvent(@NonNull Lifecycle.Event event) {
    ...
    moveToState(event.getTargetState());
}

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

sync()方法会通过backwardPass方法和forwardPass方法，更新mObserverMap内所有ObserverWithState对象的生命周期。

private void sync() {
    ...
    while (!isSynced()) {
        mNewEventOccurred = false;
        if (mState.compareTo(mObserverMap.eldest().getValue().mState) < 0) {
            backwardPass(lifecycleOwner);
        }
        Map.Entry<LifecycleObserver, ObserverWithState> newest = mObserverMap.newest();
        if (!mNewEventOccurred && newest != null
                && mState.compareTo(newest.getValue().mState) > 0) {
            forwardPass(lifecycleOwner);
        }
    }
    mNewEventOccurred = false;
}

private void forwardPass(LifecycleOwner lifecycleOwner) {
    ...
    while (ascendingIterator.hasNext() && !mNewEventOccurred) {
        while ((observer.mState.compareTo(mState) < 0 && !mNewEventOccurred
                && mObserverMap.contains(entry.getKey()))) {
           ...
           // 触发observer的回调
           observer.dispatchEvent(lifecycleOwner, event);
        }
    }
}

private void backwardPass(LifecycleOwner lifecycleOwner) {
    while (descendingIterator.hasNext() && !mNewEventOccurred) {
        ...
        while ((observer.mState.compareTo(mState) > 0 && !mNewEventOccurred
                && mObserverMap.contains(entry.getKey()))) {
              ...
              // 触发observer的回调
              observer.dispatchEvent(lifecycleOwner, event);
        }
    }
}

参考文档

Lifecycle官网

一文带你了解Lifecycle（原理篇）

Jetpack AAC完整解析（一）

从源码看 Jetpack（1）-Lifecycle 源码详解

Android Lifecycle 简单分析