Android 架构组件之 Lifecycle

可以认为 Google 将我们以前通过 MVP 框架实现的 V 与 P 的绑定过程 ，放到了Android 的系统框架里，并且功能丰富。

分析框架的组成和实现原理，我习惯从类图开始，在绘制类图的过程中，会了解框架大概包含哪些组成部分，有哪些比较重要的成员变量和方法。

我们以上面的示例 MainActivity，看一下 MainActivity、LifecycleOwner、Lifecycle 和 LifecycleObserver 之间的类图。在类图中对 LifecycleOwner、Lifecycle 和 LifecycleObserver 进行了颜色的区分，方便理解。

看过上面的类图，我们总结一下：

• Lifecycle 是一个抽象类，它有两个枚举类型的内部类 Event和 State，分别对应着事件类型和组件的状态；
• LifecycleOwner 是一个接口，它有一个 getLifecycle()方法要子类去实现。
• 我们的 MainActivity 继承自 FragmentActivity，而 FragmentActivity 是 LifecycleOwner 的实现类。在 MainActivity 中 getLifecycle()方法返回的是 Lifecycle 的子类 LifecycleRegistry实例。
• 在 LifecycleRegistry 类中的静态内部类 ObserverWithState 持有LifecycleEventObserver 对象的实例，LifecycleEventObserver 是 LifecycleObserver 的子类。

至此，MainActivity、LifecycleOwner、Lifecycle 和 LifecycleObserver 就都关联了起来。

**但是这几个类之间通过怎样的调用关系，实现了对 Activity 生命周期的监听呢？**再来看一张时序图。

看过上面的时序图，我们可以总结一下：

• 在 MainActivity 中调用 getLifecycle()方法得到 LifecycleRegistry 对象，LifecycleRegistry 对象的初始化在 FragmentActivity 中完成。调用 addObserver()方法将 LifecycleObserver 的对象作为参数传递进去，这样就完成了一个完整的注册监听过程。

• 在 Activity 生命周期变化时，在每个生命周期回调函数中调用 LifecycleRegistry的 handleLifecycleEvent()方法，在 handleLifecycleEvent()方法的层层调用中，最后通过 observer.dispatchEvent(lifecycleOwner, event) 将生命周期的变化传递到 LifecycleObserver 的实现类MainPresenter 中。

这个过程，参考 LifecycleRegistry 中的 handleLifecycleEvent()方法的调用关系。

public void handleLifecycleEvent(@NonNull 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;
    }

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 newest = mObserverMap.newest();
     if (!mNewEventOccurred && newest != null
      && mState.compareTo(newest.getValue().mState) > 0) {
  forwardPass(lifecycleOwner);
     }
 }
 mNewEventOccurred = false;
    }
    
private void backwardPass(LifecycleOwner lifecycleOwner) {
 Iterator> descendingIterator =
  mObserverMap.descendingIterator();
 while (descendingIterator.hasNext() && !mNewEventOccurred) {
     Entry 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();
     }
 }
    }

class MainPresenter : DefaultLifecycleObserver{

    override fun onCreate(owner: LifecycleOwner) {
 super.onCreate(owner)
 Logger.d("onCreate...")
    }

    override fun onStop(owner: LifecycleOwner) {
 super.onStop(owner)
 Logger.d("onStop...")
    }
}

class MainPresenter : LifecycleObserver {

    @OnLifecycleEvent(Lifecycle.Event.ON_CREATE)
    fun onCreate() {
 Logger.d("onCreate...")
    }

    @OnLifecycleEvent(Lifecycle.Event.ON_START)
    fun onStart() {
 Logger.d("onStart...")
    }

    @OnLifecycleEvent(Lifecycle.Event.ON_RESUME)
    fun onResume() {
 Logger.d("onResume...")
    }

    @OnLifecycleEvent(Lifecycle.Event.ON_PAUSE)
    fun onPause() {
 Logger.d("onPause...")
    }

    @OnLifecycleEvent(Lifecycle.Event.ON_STOP)
    fun onStop() {
 Logger.d("onStop...")
    }

    @OnLifecycleEvent(Lifecycle.Event.ON_DESTROY)
    fun onDestroy() {
 Logger.d("onDestroy...")
    }
}

class MainPresenter : LifecycleEventObserver {

    override fun onStateChanged(source: LifecycleOwner, event: Event) {
 when (event) {
     Event.ON_CREATE,
     Event.ON_START,
     Event.ON_RESUME,
     Event.ON_PAUSE,
     Event.ON_STOP,
     Event.ON_DESTROY -> Logger.d("onStateChanged...${event.name}")
 }
    }
}

class MainActivity : AppCompatActivity() {
    override fun onCreate(savedInstanceState: Bundle?) {
 super.onCreate(savedInstanceState)
 setContentView(R.layout.layout_lifecycle)

 val presenter = MainPresenter()
 lifecycle.addObserver(presenter)
    }
}