Android Architecture Components

Android架构组件库的集合,帮助您设计健壮的、可测试的、可维护的应用程序。从类管理UI组件的生命周期和处理数据持久性。

一 Android常规生命周期管理方式

二 Lifecycle的使用

三 Lifecycle组件的关键类

四 Lifecycle实现原理

一 Android常规生命周期管理方式

在应用开发的过程中，我们经常需要根据 组件如 Activity/Fragment 的生命周期，来做相应的操作，如果代码基于 MVP 架构开发，那么我们需要在 presenter 中定义好接口，如：

public interface ILoginPresenter {
    void login(String name, String pw);
    void onCreate();
    void onStart();
    void onResume();
    void onPause();
    void onStop();
    void onDestroy();
}

然后在 Activity/Fragment 相应的生命周期方法中，将不同的生命周期状态回调给 presenter：

@Override
protected void onStart() {
    super.onStart();
    mLoginPresenter.onStart();
}

@Override
protected void onResume() {
    super.onResume();
    mLoginPresenter.onResume();
}

@Override
protected void onPause() {
    super.onPause();
    mLoginPresenter.onPause();
}

@Override
protected void onStop() {
    super.onStop();
    mLoginPresenter.onStop();
}

@Override
protected void onDestroy() {
    super.onDestroy();
    mLoginPresenter.onDestroy();
}

尽管这样看起来，代码结构是清晰的，但这是在应用体量小的情况下，想象一下，如果我们在一个核心界面，该界面需要处理各种各样的受当前组件生命周期影响的事物，那么在该组件的生命周期方法中（onStart()/onResume()/onDestroy...）,我们就需要去做大量的处理，以及时通知不同的 presenter 去做相应的操作，这将使得我们的生命周期方法中的代码变得冗杂。

而且组件的状态是具备不确定性的，例如我们在 onResume() 方法中做了大量的工作去初始化组件，但这个初始化工作可能还没做完，该组件就进入 stopped 状态了。

此外，假如除了 presenter ，还有其他类需要监听组件的生命周期变化，那同样需要新增很多生命周期回调接口，这时相当繁琐的，那我们是否可以在组件的生命周期发生变化的时候主动通知需要该状态的类呢？答案就是使用 Google提供Lifecycle组件，下面来看看使用 Lifecycle 组件，能带来什么样的改善吧。

---

二 Lifecycle的使用

Google官方文档 ： Handling Lifecycles with Lifecycle-Aware Components

先简单介绍下使用 Lifecycle 的方法，后续再对几个常用类及源码实现展开细讲

1.首先是依赖导入:

在应用/模块的 build.gradle 文件中按需添加如下依赖

官网地址：Declaring dependencies

dependencies {
    def lifecycle_version = "2.1.0"

    // ViewModel and LiveData
    implementation "androidx.lifecycle:lifecycle-extensions:$lifecycle_version"
    // alternatively - just ViewModel
    implementation "androidx.lifecycle:lifecycle-viewmodel:$lifecycle_version" // For Kotlin use lifecycle-viewmodel-ktx
    // alternatively - just LiveData
    implementation "androidx.lifecycle:lifecycle-livedata:$lifecycle_version"
    // alternatively - Lifecycles only (no ViewModel or LiveData). Some UI
    //     AndroidX libraries use this lightweight import for Lifecycle
    implementation "androidx.lifecycle:lifecycle-runtime:$lifecycle_version"

    annotationProcessor "androidx.lifecycle:lifecycle-compiler:$lifecycle_version" // For Kotlin use kapt instead of annotationProcessor
    // alternately - if using Java8, use the following instead of lifecycle-compiler
    implementation "androidx.lifecycle:lifecycle-common-java8:$lifecycle_version"

    // optional - ReactiveStreams support for LiveData
    implementation "androidx.lifecycle:lifecycle-reactivestreams:$lifecycle_version" // For Kotlin use lifecycle-reactivestreams-ktx

    // optional - Test helpers for LiveData
    testImplementation "androidx.arch.core:core-testing:$lifecycle_version"
}

生命周期observer需要做的：

2.让需要监听组件生命周期方法的observer实现 LifecycleObserver 接口，表示当前类是组件生命周期的观察者

public class LoginPresenterImpl implements ILoginPresenter, LifecycleObserver {...}

3.同时在需要被通知的接口上，添加 @OnLifecycleEvent(Lifecycle.Event.ON_XXX 注解, OnLifecycleEvent 对应了 组件 Activity/Fragment 的生命周期方法

@OnLifecycleEvent(Lifecycle.Event.ON_CREATE)
@Override
public void onCreate() {
    Log.d(TAG, "onCreate: state=" + getLifecycle().getCurrentState());
}

@OnLifecycleEvent(Lifecycle.Event.ON_START)
@Override
public void onStart() {
    Log.d(TAG, "onStart: state=" + getLifecycle().getCurrentState());
}

生命周期owner需要做的:

4.实现 LifecycleOwner 接口，表明自己是生命周期的拥有者

public class LoginActivity extends AppCompatActivity implements ILoginView, LifecycleOwner {...}

5.注册observer，这样就能在组件的生命周期变化时主动通知observer了

@Override
protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.activity_main);

    // 注册需要监听组件生命周期的 observer
    getLifecycle().addObserver(new LoginPresenterImpl());
}

到这里，observer就能在owner每次生命周期变化时收到通知，相较于前面在owner的生命周期函数中逐个去手动通知各个observer，这种方式显然更便捷。

---

下面看看log：

// step1 : 进入应用
com.example.lifecycletest2 D/LoginActivity: onCreate: state=INITIALIZED
com.example.lifecycletest2 D/LoginPresenterImpl: onCreate: state=CREATED
com.example.lifecycletest2 D/LoginActivity: onStart: state=CREATED
com.example.lifecycletest2 D/LoginPresenterImpl: onStart: state=STARTED
com.example.lifecycletest2 D/LoginActivity: onResume: enter,state=STARTED
com.example.lifecycletest2 D/LoginPresenterImpl: onResume: state=RESUMED

// step2 : 退出应用
com.example.lifecycletest2 D/LoginPresenterImpl: onPause: state=STARTED
com.example.lifecycletest2 D/LoginActivity: onPause: enter,state=STARTED
com.example.lifecycletest2 D/LoginPresenterImpl: onStop: state=CREATED
com.example.lifecycletest2 D/LoginActivity: onStop: enter,state=CREATED
com.example.lifecycletest2 D/LoginPresenterImpl: onDestroy: state=DESTROYED
com.example.lifecycletest2 D/LoginActivity: onDestroy: enter,state=DESTROYED

可以看到，当 Activity 挂起后再次回到当前界面时，收到生命周期事件的顺序变了，先看看官网对 Event && State 这两个状态是怎么解释的吧

Enent:

从框架和生命周期类Lifecycle分发过来的生命周期事件，这些事件对应活动和碎片中的生命周期回调事件

State:

由Lifecycle对象追踪的组件当前的状态

官方文档是这么说的：Think of the states as nodes of a graph and events as the edges between these nodes.也就是将state当做 图的节点 ，将event当做 两个节点之间的边。看下下面的图：

Google给出的 时间 && 状态 的流程图 结合上面的log打印，就很清晰了，即：

组件处于 INITIALIZED状态 时，触发 ON_CREATE 事件，分发事件onCreate()给observer，此时组件仍处于 INITIALIZED状态 状态，当observer收到onCreate()事件时，组件owner进入CREATED状态，依次类推...

至于为什么上面log中，step1阶段时是owner先收到生命周期事件，接着observer才收到；而 step2阶段是 observer先收到生命周期事件，接着owner才收到。这个在 Lifecycle类 中有解释，下面来看看

---

三 Lifecycle组件的关键类

上面介绍完简单用法后，我们来看下用到的几个关键类：

1.抽象类Lifecycle

下面是该类给出的说明：

定义的一个持有Android生命周期的类。 Fragment 和 FragmentActivity 类实现了 LifecycleOwner 接口，Support Library 26.1.0 及以上的Activity && Fragment 也都实现了LifecycleOwner接口 并 重写了LifecycleOwner#getLifecycle() ，所以如果我们的组件是继承自以上类型组件的话，就不用再去实现 LifecycleOwner 接口而可以直接调用 getLifecycle() 来获取 Lifecycle

Event#ON_CREATE} && Event#ON_START && Event#ON_RESUME 这三个事件是在 LifecycleOwner 自身相关的生命周期方法返回后分发的，所以上面log的setp1中， Activity 先于监听类收到生命周期函数回调。

Event#ON_PAUSE && Event#ON_STOP && Event#ON_DESTROY 这三个事件是在 LifecycleOwner 自身相关的生命周期方法被调用前分发的，所以上面log的setp2中，监听类先于组件类收到回调。

清楚了这个之后，在监听类中我们就可以确切得知道当前组件确切的生命周期节点了，而向上文提到的，onResume() 还没做完就进入 onStopped()了，这种情况也就迎刃而解了。

此外基于不同的Java版本，推荐使用的LifecycleObserver也有所区别：

• 如果你用的是Java8，监听组件生命周期时推荐继承DefaultLifecycleObserver类，build.gradle中导入的包为"androidx.lifecycle:common-java8:<version>"；
• 如果你使用的是Java7，生命周期事件的监听是通过注解实现的，监听生命周期组件时继承LifecycleObserver类。
• 而Java8一旦成为主流，注解的方式将被丢弃(注解通过反射实现，而反射需要的成本较大)，所以我们使用的时候尽量选择DefaultLifecycleObserver。

上面的使用例子中用的就是LifecycleObserver，下面再来看看Java8上使用DefaultLifecycleObserver是怎么样的

监听者

public class LoginPresenterImpl implements ILoginPresenter, DefaultLifecycleObserver {

    private static final String TAG = "LoginPresenterImpl";

    @Override
    public void onCreate(@NonNull LifecycleOwner owner) {
        Log.d(TAG, "onCreate: owner=" + owner);
    }

    @Override
    public void onStart(@NonNull LifecycleOwner owner) {
        Log.d(TAG, "onStart: ");
    }

    @Override
    public void onResume(@NonNull LifecycleOwner owner) {
        Log.d(TAG, "onResume: ");
    }

    @Override
    public void onPause(@NonNull LifecycleOwner owner) {
        Log.d(TAG, "onPause: ");
    }

    @Override
    public void onStop(@NonNull LifecycleOwner owner) {
        Log.d(TAG, "onStop: ");
    }

    @Override
    public void onDestroy(@NonNull LifecycleOwner owner) {
        Log.d(TAG, "onDestroy: ");
    }
}

DefaultLifecycleObserver接口中定义了各个生命周期函数,所以我们可在需要监听组件生命周期的observer中按需重写生命周期回调函数，然后在组件类中将监听者添加到监听列表（getLifecycle().addObserver(new LoginPresenterImpl());）即可收到回调了

可以看到，如果我们用的是DefaultLifecycleObserver接口，就不再需要去给每个需要监听生命周期函数的方法添加注解了，使用上明显更方便了，所以更推荐用这种方式

当然使用DefaultLifecycleObserver接口是有条件的，否则编译会报错：

default interface methods are only supported starting with Android N (--min-api 24): void androidx.lifecycle.DefaultLifecycleObserver.onCreate(androidx.lifecycle.LifecycleOwner)

也就是build.gradle文件中声明的minSdkVersion必须大于等于24，否则会报错，所以我们使用的时候需要综合Java版本 && minSdkVersion要求来做选择。

接着来看该类提供了哪些方法：

// 添加一个生命周期观察者，在 LifecycleOwner 生命周期改变时观察者将能收到回调，例如
// 当 LifecycleOwner 处于 STARTED 时,观察者将能收到 Event#ON_CREATE && Event#ON_START 两个时间回调
@MainThread
public abstract void addObserver(@NonNull LifecycleObserver observer);

// 移除观察者
这里有几种情况：
如果该函数被调用时，某个生命周期状态已经被分发出去了：
a.如果观察者此时还未收到该事件，它将能继续收到
b.如果观察者类中有多个方法监听了该事件且其中至少一个方法已经收到了该回调，
则剩余所有的方法也都能收到该回调，所有回调完成后该观察者才会被移除
@MainThread
public abstract void removeObserver(@NonNull LifecycleObserver observer);

// 获取组件的生命周期状态，一个常用场景是：当我们要去触发某个操作时，这个操作依赖于生命周期的状态，
// 这时我们可以这么做：if (lifecycle.getCurrentState().isAtLeast(STARTED)){ // TO DO }
@MainThread
@NonNull
public abstract State getCurrentState();

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

public enum State {
    DESTROYED,
    INITIALIZED,
    CREATED,
    STARTED,
    RESUMED;
    
    public boolean isAtLeast(@NonNull State state) {
        return compareTo(state) >= 0;
    }
}

2.接口LifecycleObserver观察者

这是个空的接口，依赖于OnLifecycleEvent注解

3.接口LifecycleOwner/接口DefaultLifecycleObserver生命周期拥有者

• 接口LifecycleOwner

只有一个方法**Lifecycle getLifecycle();**用于获取Lifecycle对象

• 接口DefaultLifecycleObserver

上文已经简单叙述了该接口同LifecycleObserver的区别了，来看看该类给出的说明：如果一个监听者同时实现了DefaultLifecycleObserver && LifecycleEventObserver，那么DefaultLifecycleObserver的方法将会先被调用，随后才是LifecycleEventObserver#onStateChanged(LifecycleOwner, Lifecycle.Event)，如果一个类在实现该接口的同时还给方法添加OnLifecycleEvent注解，那么相关注解将被忽视。

4.LifecycleEventObserver

上文提到了这个接口，来看下该类的描述：该类能接收任何生命周期改变同时分发给监听者，这里试了一下observer同时实现DefaultLifecycleObserver && LifecycleEventObserver，结合上面第3点，看下下面的log：

com.example.lifecycletest2 D/LoginActivity: onCreate: enter,state=INITIALIZED
com.example.lifecycletest2 D/LoginPresenterImpl: onCreate: 
com.example.lifecycletest2 D/LoginPresenterImpl: onStateChanged: event=ON_CREATE

com.example.lifecycletest2 D/LoginActivity: onStart: enter,state=CREATED
com.example.lifecycletest2 D/LoginPresenterImpl: onStart: 
com.example.lifecycletest2 D/LoginPresenterImpl: onStateChanged: event=ON_START

com.example.lifecycletest2 D/LoginActivity: onResume: enter,state=STARTED
com.example.lifecycletest2 D/LoginPresenterImpl: onResume: 
com.example.lifecycletest2 D/LoginPresenterImpl: onStateChanged: event=ON_RESUME

可以看到，如果一个类同时实现了DefaultLifecycleObserver && LifecycleEventObserver，那么会先调用相应的生命周期函数，接着才是onStateChanged(),所以关于这两个接口的选择也就一目了然了，如果你需要在确切的生命周期做特定的事，那么实现DefaultLifecycleObserver，如果你只是想在生命周期变化时被告知，可以实现LifecycleEventObserver

5.LifecycleReistry

前面说过，Fragment 和 FragmentActivity 类本身实现了 LifecycleOwner 接口，Support Library 26.1.0 及以上的Activity && Fragment 也都实现了LifecycleOwner接口，而如果你的组件不是以上类型的呢（如android.app.Avtivity），这个时候如果你想实现上面同样的效果的话就需要用到 LifecycleOwner + LifecycleReistry 了，下面来看看具体例子：

• 组件类的实现：

  • a.实现LifecycleOwner接口

  • b.重写getLifecycle()方法，并返回mLifecycleRegistry

  • c.创建LifecycleRegistry对象，并在希望通知监听者的生命周期方法中用LifecycleRegistry.markState(Lifecycle.State.XXX)标记相应的状态，

  • d.最后添加监听者即可

      public class LoginActivity extends Activity implements ILoginView ,LifecycleOwner//a {
    
          private static final String TAG = "LoginActivity";
          private LifecycleRegistry mLifecycleRegistry;
      
          @Override
          protected void onCreate(Bundle savedInstanceState) {
              super.onCreate(savedInstanceState);
              setContentView(R.layout.activity_main);
              // c
              mLifecycleRegistry = new LifecycleRegistry(this);
              Log.d(TAG, "onCreate: state=" + getLifecycle().getCurrentState());
              mLifecycleRegistry.markState(Lifecycle.State.CREATED);
              // d
              getLifecycle().addObserver(new LoginPresenterImpl());
          }
      
          @Override
          protected void onStart() {
              super.onStart();
              Log.d(TAG, "onStart: state=" + getLifecycle().getCurrentState());
              mLifecycleRegistry.markState(Lifecycle.State.STARTED);
          }
      
          // b
          @NonNull
          @Override
          public Lifecycle getLifecycle() {
              return mLifecycleRegistry;
          }
      }
    

• 监听者的实现：有两种，一种是实现LifecycleObserver，然后在希望监听生命周期的函数上添加OnLifecycleEvent注解

    public class LoginPresenterImpl implements ILoginPresenter, LifecycleObserver {
  
        private static final String TAG = "LoginPresenterImpl";
    
        @OnLifecycleEvent(Lifecycle.Event.ON_CREATE)
        @Override
        public void onCreate() {
            Log.d(TAG, "onCreate: ");
        }
    
        @OnLifecycleEvent(Lifecycle.Event.ON_START)
        @Override
        public void onStart() {
            Log.d(TAG, "onStart: ");
        }
        
        @OnLifecycleEvent(Lifecycle.Event.ON_RESUME)
        @Override
        public void onResume() {
            Log.d(TAG, "onResume: ");
        }
    }
  

log打印如下

com.example.lifecycletest2 D/LoginActivity: onCreate: state=INITIALIZED
com.example.lifecycletest2 D/LoginPresenterImpl: onCreate: 

com.example.lifecycletest2 D/LoginActivity: onStart: state=CREATED
com.example.lifecycletest2 D/LoginPresenterImpl: onStart: 
// owner 中未用 markState 标记，所以 observer 无法收到回调
com.example.lifecycletest2 D/LoginActivity: onResume: enter,state=STARTED

可以看到，只有在owner中使用LifecycleRegistry.markState(Lifecycle.State.XXX)标记了的函数，监听者才能收到回调。

• 监听者的另一种实现：实现DefaultLifecycleObserver接口，按需实现需要的回调函数，

    public class LoginPresenterImpl implements ILoginPresenter, DefaultLifecycleObserver {
  
        private static final String TAG = "LoginPresenterImpl";
    
        @Override
        public void onCreate(@NonNull LifecycleOwner owner) {
            Log.d(TAG, "onCreate: ");
        }
    
        @Override
        public void onStart(@NonNull LifecycleOwner owner) {
            Log.d(TAG, "onStart: ");
        }
    
        @Override
        public void onResume(@NonNull LifecycleOwner owner) {
            Log.d(TAG, "onResume: ");
        }
    
        @Override
        public void onPause(@NonNull LifecycleOwner owner) {
            Log.d(TAG, "onPause: ");
        }
    
        @Override
        public void onStop(@NonNull LifecycleOwner owner) {
            Log.d(TAG, "onStop: ");
        }
    
        @Override
        public void onDestroy(@NonNull LifecycleOwner owner) {
            Log.d(TAG, "onDestroy: ");
        }
    }
  

log打印结果同上，同样是只有用LifecycleRegistry.markState标记过的生命周期函数才会自动通知到监听者类中。

---

四 Lifecycle实现原理

看完Lifecycle的用法后，我们来看看它是怎么实现的：

相信大家也是很多疑惑的，Lifecycle组件这套逻辑是怎么搭起来的，Activity/Fragment 是怎么在生命周期变化的时候自动通知到观察者的？

首先解答一个疑问：自定义实现LifecycleOwner必须重写getLifecycle()方法并返回一个LifecycleRegistry实例，那么不需要我们手动重写getLifecycle()的组件，是在哪个地方帮我们做了这件事呢,下面来看看：

如果我们的Activity是继承自AppCompatActivity，我们就不需要再手动去实现LifecycleOwner了，我们往上追溯可以发现，父类ComponentActivity实现了该接口，其getLifecycle()方法返回了一个LifecycleRegistry实例，所以就是在这里帮我们做了这件事的。

先思考下面两个问题：

• 往LifecycleRegistry中添加监听者后，LifecycleRegistry是怎么感知组件的生命周期变化的?
• LifecycleRegistry是如何将生命周期变化分发到对应的observer的？

核心实现涉及两个类：ComponentActivity && LifecycleRegistry

ComponentActivity#onCreate():

有这么一行代码ReportFragment.injectIfNeededIn(this),这个FragmentManager是什么，injectIfNeededIn()方法又做了什么事？

public class ReportFragment extends Fragment {
    
    public static void injectIfNeededIn(Activity 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();
    }
    
    @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;
    }
    
    // 分发生命周期函数到 LifecycleRegistry 
    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);
            }
        }
    }
    ...
}

类的注释是：一个分发初始化事件的内部类，上面贴出了该类的几个关键方法：

a.首先是injectIfNeededIn()方法，创建了一个Fragment然后添加到Activity中去

b.在该Fragment的生命周期函数中都调用了dispatch(Lifecycle.Event event)方法，而该方法做的就是，判断当前Activity是否实现了LifecycleRegistryOwner/LifecycleOwner接口，是的话就调用LifecycleRegistry#handleLifecycleEvent(event)

到这里我们就可以明白了第一个问题了，即通过添加一个Fragment到当前Activity中，然后利用Fragment与Activity的生命周期函数前后调用关系，来感知Activity的生命周期。

来看看LifecycleRegistry#handleLifecycleEvent(event)又做了什么,关键代码都做了注释

public void handleLifecycleEvent(@NonNull Lifecycle.Event event) {
    // 根据 owner 传过来的生命周期事件，拿到要分发给 observer 的状态
    State next = getStateAfter(event);
    // 将状态分发给 observer
    moveToState(next);
}

// moveToState(State next) 中的关键代码只有一句：调用 sync()
private void sync() {
    ......
    while (!isSynced()) {
        mNewEventOccurred = false;
        if (mState.compareTo(mObserverMap.eldest().getValue().mState) < 0) {
            // 分发点1
            backwardPass(lifecycleOwner);
        }
        Entry<LifecycleObserver, ObserverWithState> newest = mObserverMap.newest();
        if (!mNewEventOccurred && newest != null
                && mState.compareTo(newest.getValue().mState) > 0) {
            // 分发点2
            forwardPass(lifecycleOwner);
        }
    }
    mNewEventOccurred = false;
}

// 分发点1
private void forwardPass(LifecycleOwner lifecycleOwner) {
    Iterator<Entry<LifecycleObserver, ObserverWithState>> ascendingIterator =
            mObserverMap.iteratorWithAdditions();
    // 遍历当前的 observer 
    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
            observer.dispatchEvent(lifecycleOwner, upEvent(observer.mState));
            popParentState();
        }
    }
}

// 分发点2
private void backwardPass(LifecycleOwner lifecycleOwner) {
    Iterator<Entry<LifecycleObserver, ObserverWithState>> descendingIterator =
            mObserverMap.descendingIterator();
    // 遍历当前的 observer 
    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
            observer.dispatchEvent(lifecycleOwner, event);
            popParentState();
        }
    }
}

看到这里我们能明白第二个问题了，即ReportFragment在自身的生命周期函数中，将当前生命周期事件报告给LifecycleRegistry, 而LifecycleRegistry经由addObserver(observer),是持有各个observer的引用的，这样便能将收到的报告转发给各个observer了。

整个流程用了一个很巧妙的技巧：利用一个Fragment以及 Fragment的各个生命周期函数与Activity的生命周期函数的前后调用关系，以LifecycleRegistry为桥梁，将Activity的生命周期分发给observer。