一、简介
Lifecycle是一个类，用于存储有关组件（如 Activity 或 Fragment）的生命周期状态的信息，并允许其他对象观察此状态。
二、为什么要引入 Lifecycle
在没引入 lifecycle 之前，我们一些对 activity 或者 fragment 生命周期敏感的工具类，需要在页面销毁的时候销毁或者停止某些状态（比如持续性的东西，如倒计时或定位等）。就造成了在页面关闭的时候，我们要注意当前页面是否有跟生命周期敏感的数据需要处理，有时候处理不好，轻则内存泄漏， 重则应用直接崩溃。所以，一直就有一个想法，工具类能否自己感知到对应页面的生命周期，并在对应的生命周期中，自己处理自己的逻辑？终于，lifecycle 他来了。
三、Lifecycle 的使用
lifecycle 的各种情况下的引入方式，都有注释。
dependencies {
def lifecycle_version = "2.6.0-alpha01"
def arch_version = "2.1.0"
// ViewModel
implementation "androidx.lifecycle:lifecycle-viewmodel:$lifecycle_version"
// LiveData
implementation "androidx.lifecycle:lifecycle-livedata:$lifecycle_version"
// Lifecycles only (without ViewModel or LiveData)
implementation "androidx.lifecycle:lifecycle-runtime:$lifecycle_version"
// Saved state module for ViewModel
implementation "androidx.lifecycle:lifecycle-viewmodel-savedstate:$lifecycle_version"
// Annotation processor
annotationProcessor "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:$lifecycle_version"
// optional - Test helpers for LiveData
testImplementation "androidx.arch.core:core-testing:$arch_version"
// optional - Test helpers for Lifecycle runtime
testImplementation "androidx.lifecycle:lifecycle-runtime-testing:$lifecycle_version"
}
除了 Activity 类以外，其他的应该是都实现了 LifecycleOwner 接口。所以，可以通过一下方式来设置一个生命周期的观察者：
getLifecycle().addObserver(new MyObserver());
而需要监听控件生命周期的类，则通过实现 DefaultLifecycleObserver 接口，并在对应的生命周期中做对应的操作就可以了。类似 MVP 的 Presenter 中，可以做如下操作：
class BasePresenter implements DefaultLifecycleObserver {
@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: ");
}
}
这样，在 Presenter 中就可以控制网络请求终止等相关操作。
此处注意，不要使用通过 LifecycleObserver 和 @OnLifecycleEvent 注解的方式来实现了，官方的更新日志明确表明不会再支持此方式：
自 2.3.0 以来的重要变更
废弃了 @OnLifecycleEvent。应改用 LifecycleEventObserver 或 DefaultLifecycleObserver。
LifecycleEventObserver 的使用方式是：
class BasePresenter implements LifecycleEventObserver {
@Override
public void onStateChanged(@NonNull LifecycleOwner source, @NonNull Lifecycle.Eventevent){
}
}
可以看到，就是 通过 LifecycleObserver 和 @OnLifecycleEvent 注解的方式的变种。
ProcessLifecycleOwner
如果我们要监听整个应用的生命周期，及是否在前台/后台，则可以通过以下方式实现。
1、观察类实现 LifecycleObserver
public class ApplicationObserver implements DefaultLifecycleObserver {
/**
* 整个生命周期只调一次
* */
@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: ");
}
}
2、在 Application 中使用
public class MyApplication extends Application{
@Override
public void onCreate() {
super.onCreate();
ProcessLifecycleOwner.get().getLifecycle().addObserver(newApplicationObserver());
}
}
要注意的是，这只跟应用的生命周期有关系，跟有多少个 Activity 没关系。还有就是在 lifecycle 2.2.0 之后， 要通过引入
implementation "androidx.lifecycle:lifecycle-process:$lifecycle_version"
使用 ProcessLifecycleOwner，之前的 lifecycle-extensions 已经被废弃，这里引用官方原话：
2.2.0 版本更新日志
...
-
弃用 lifecycle-extensions 工件：在上面弃用 ViewModelProviders.of() 后，此版本标志着弃用 lifecycle-extensions 中的最后一个 API，因此现在该工件已完全被弃用。我们强烈建议依赖于您需要的特定 Lifecycle 工件（例如，如果您使用的是 LifecycleService，则依赖于 lifecycle-service；如果您使用的是 ProcessLifecycleOwner，则依赖于 ifecycle-process）而不是 lifecycle-extensions，因为将来不会有 lifecycle-extensions 的 2.3.0 版本。
...
四、原理解析
在分析原理之前，我们需要先知道三个概念，分别是LifecycleOwner ，LifecycleObserver 和 Lifecycle。
LifecycleOwner，顾名思义，就是生命周期的拥有者（Activity 和 Fragment等）。在源码中是一个具有Android生命周期的接口，Activity 和 Fragment都实现了此接口，该接口声明如下：
@SuppressWarnings({"WeakerAccess", "unused"})
public interface LifecycleOwner {
/**
* Returns the Lifecycle of the provider.
*
* @return The lifecycle of the provider.
*/
@NonNull
Lifecycle getLifecycle();
}
LifecycleObserver，生命周期的观察者，它是一个空接口，依赖于OnLifecycleEvent注解的方法来回调对应的生命周期，其接口如下：
public interface LifecycleObserver {
}
Lifecycle，我们看到 LifecycleOwner 的 getLifecycle() 方法返回一个 Lifecycle 对象，它的作用就是将 LifecycleOwner 和 LifecycleObserver 绑定在一起，这样当 LifecycleOwner 的生命周期有变化的时候，可以通过 Lifecycle 将状态传递给 LifecycleObserver。它的接口如下：
public abstract class Lifecycle {
/**
* Lifecycle coroutines extensions stashes the CoroutineScope into this field.
*
* @hide used by lifecycle-common-ktx
*/
@RestrictTo(RestrictTo.Scope.LIBRARY_GROUP)
@NonNull
AtomicReference<Object> mInternalScopeRef = new AtomicReference<>();
/**
* Adds a LifecycleObserver that will be notified when the LifecycleOwner changes
* state.
* <p>
* The given observer will be brought to the current state of the LifecycleOwner.
* For example, if the LifecycleOwner is in {@link State#STARTED} state, the given observer
* will receive {@link Event#ON_CREATE}, {@link Event#ON_START} events.
*
* @param observer The observer to notify.
*/
@MainThread
public abstract void addObserver(@NonNull LifecycleObserver observer);
/**
* Removes the given observer from the observers list.
* <p>
* If this method is called while a state change is being dispatched,
* <ul>
* <li>If the given observer has not yet received that event, it will not receive it.
* <li>If the given observer has more than 1 method that observes the currently dispatched
* event and at least one of them received the event, all of them will receive the event and
* the removal will happen afterwards.
* </ul>
*
* @param observer The observer to be removed.
*/
@MainThread
public abstract void removeObserver(@NonNull LifecycleObserver observer);
/**
* Returns the current state of the Lifecycle.
*
* @return The current state of the Lifecycle.
*/
@MainThread
@NonNull
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
}
/**
* Lifecycle states. You can consider the states as the nodes in a graph and
* {@link Event}s as the edges between these nodes.
*/
@SuppressWarnings("WeakerAccess")
public enum State {
/**
* Destroyed state for a LifecycleOwner. After this event, this Lifecycle will not dispatch
* any more events. For instance, for an {@link android.app.Activity}, this state is reached
* <b>right before</b> Activity's {@link android.app.Activity#onDestroy() onDestroy} call.
*/
DESTROYED,
/**
* Initialized state for a LifecycleOwner. For an {@link android.app.Activity}, this is
* the state when it is constructed but has not received
* {@link android.app.Activity#onCreate(android.os.Bundle) onCreate} yet.
*/
INITIALIZED,
/**
* Created state for a LifecycleOwner. For an {@link android.app.Activity}, this state
* is reached in two cases:
* <ul>
* <li>after {@link android.app.Activity#onCreate(android.os.Bundle) onCreate} call;
* <li><b>right before</b> {@link android.app.Activity#onStop() onStop} call.
* </ul>
*/
CREATED,
/**
* Started state for a LifecycleOwner. For an {@link android.app.Activity}, this state
* is reached in two cases:
* <ul>
* <li>after {@link android.app.Activity#onStart() onStart} call;
* <li><b>right before</b> {@link android.app.Activity#onPause() onPause} call.
* </ul>
*/
STARTED,
/**
* Resumed state for a LifecycleOwner. For an {@link android.app.Activity}, this state
* is reached after {@link android.app.Activity#onResume() onResume} is called.
*/
RESUMED;
/**
* Compares if this State is greater or equal to the given {@code state}.
*
* @param state State to compare with
* @return true if this State is greater or equal to the given {@code state}
*/
public boolean isAtLeast(@NonNull State state) {
return compareTo(state) >= 0;
}
}
}
其中，需要注意一下 Event 和 Status 这两个枚举类，Event 代表生命周期的事件，Status 代表生命周期的状态。在后续的源码分析中，我们再细说。
然后，我们带着问题看源码，除了lifecycle怎么绑定生命周期等常规问题外，再想几个小问题：
1、observer 如果在某个生命周期中执行耗时操作，会影响到Activity 或者 Fragment 接下来的生命周期的执行么？
会，所以 observer 类中的对应方法里，也要注意不要有耗时操作，耗时操作可以放在子线程
image-20220831174730063.png
2、如果在onResume 中绑定observer ，那 oberver 能监听到onCreate 么？怎么监听的？
在 onResume 中绑定，会有 onCreate 和 onStart 的回调，且在 Activity 的 onResume 之前，但在 Activity 的onStart 之后 ：
image-20220831174809091.png
好了，带着上面的问题，我们去看看原理。我们从 addObserver() 方法开始看起：
getLifecycle().addObserver(new BasePresenter());
getLifecycle() 所获取到的是 LifecycleRegistry 对象，这个类继承了 Lifecycle ，并重写了其 addObserver 方法。我们跟进这个类，看看它的 addObserver 方法做了哪些事情
@Override
public void addObserver(@NonNull LifecycleObserver observer) {
State initialState = mState == DESTROYED ? DESTROYED : INITIALIZED;
ObserverWithState statefulObserver = new ObserverWithState(observer, initialState);
ObserverWithState previous = mObserverMap.putIfAbsent(observer, statefulObserver);
if (previous != null) {
return;
}
LifecycleOwner lifecycleOwner = mLifecycleOwner.get();
if (lifecycleOwner == null) {
// it is null we should be destroyed. Fallback quickly
return;
}
boolean isReentrance = mAddingObserverCounter != 0 || mHandlingEvent;
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--;
}
这个方法主要作用就是绑定观察者并同步当前的生命周期状态，其中 calculateTargetState 方法计算了 targetState 的值。这也就是我们刚开始问的，如果在 onResume 方法中绑定了观察者，会不会走观察者的 onCreate 方法？这里就是答案。
现在我们知道观察者是怎么绑定和同步生命周期，那生命周期的变化是如何通知到观察者呢？在 addObserver 中并没有找到，那我们返回 Activity 去找找哪里实现了 LifecycleOwner。
Activity 继承了 AppCompatActivity，而 AppCompatActivity 又继承了 FragmentActivity，FragmentActivity 又继承了 ComponentActivity，最后 ComponentActivity 继承了 androidx.core.app.ComponentActivity 且实现了 LifecycleOwner 接口。仔细找了好久，都没有发现哪里能通知观察者生命周期的变动，但是发现一段看起来有点奇怪的代码
@Override
protected void onCreate(@Nullable Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
mSavedStateRegistryController.performRestore(savedInstanceState);
//这块有点奇怪
ReportFragment.injectIfNeededIn(this);
if (mContentLayoutId != 0) {
setContentView(mContentLayoutId);
}
}
这个 ReportFragment.injectIfNeededIn(this) 方法是用来干嘛的？进去看看
public static void injectIfNeededIn(Activity activity) {
if (Build.VERSION.SDK_INT >= 29) {
// On API 29+, we can register for the correct Lifecycle callbacks directly
activity.registerActivityLifecycleCallbacks(
new LifecycleCallbacks());
}
// Prior to API 29 and to maintain compatibility with older versions of
// ProcessLifecycleOwner (which may not be updated when lifecycle-runtime is updated and
// need to support activities that don't extend from FragmentActivity from support lib),
// use a framework fragment to get the correct timing of Lifecycle events
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();
}
}
嘿，巧了，找到了（这个就是我当时的感觉）。这个方法如果在 Android Q 及以上，设置一个生命周期的监听，还给Activity 注入一个没有页面的 Fragment。我们看一下它的主要代码
...
@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;
}
...
// this class isn't inlined only because we need to add a proguard rule for it. (b/142778206)
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) {
}
}
我们看到不管是 LifecycleCallbacks 类中的方法还是 ReportFragment 自己的生命周期方法，都调用了不同的 dispatch 方法，好了，我们看看 dispatch 方法干了什么
private void dispatch(@NonNull Lifecycle.Event event) {
if (Build.VERSION.SDK_INT < 29) {
//仅在 API 29 之前的 API 级别上从 ReportFragment 处理调度事件。在 API 29+ 上，这由 //ReportFragment.injectIfNeededIn 中添加的 ActivityLifecycleCallbacks 处理
dispatch(getActivity(), event);
}
}
static void dispatch(@NonNull Activity activity, @NonNull Lifecycle.Event event) {
//低版本适配
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);
}
}
}
可以看到，在 dispatch 方法中调用了 LifecycleRegistry 的 handleLifecycleEvent 方法，我们去看看
/**
* Sets the current state and notifies the observers.
* <p>
* Note that if the {@code currentState} is the same state as the last call to this method,
* calling this method has no effect.
*
* @param event The event that was received
*/
public void handleLifecycleEvent(@NonNull Lifecycle.Event event) {
State next = getStateAfter(event);
moveToState(next);
}
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);
}
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;
}
getStateAfter 是根据 Event 获取事件之后的状态，moveToState 则是将获取到的状态同步到 mState，然后调用 sync 方法，同步到所有观察者
// happens only on the top of stack (never in reentrance),
// so it doesn't have to take in account parents
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;
// mState 小于 mObserverMap 中的状态值，调用 backwardPass()
if (mState.compareTo(mObserverMap.eldest().getValue().mState) < 0) {
backwardPass(lifecycleOwner);
}
Entry<LifecycleObserver, ObserverWithState> newest = mObserverMap.newest();
// mState 大于 mObserverMap 中的状态值，调用 forwardPass()
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;
}
这个方法比较了 mState 和 mObserverMap 中观察者的 status 状态，然后根据比较结果来同步观察者的 status 。我们先看 backwardPass 方法的流程
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 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);
}
可以看到，backwardPass 通过对比并循环调用 downEvent 方法，来同步观察者的状态。forwardPass 也是类似的逻辑，区别在于，backwardPass 是降级，向后同步，forwardPass 是升级，向前同步。我们来看看 forwardPass 方法
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 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);
}
可以看到，backwardPass 和 forwardPass 方法，在状态同步的过程中，都调用了 ObserverWithState 的 dispatchEvent 方法，我们跟进去看一下
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;
}
}
我们可以看到，在 dispatchEvent 方法中，通过 mLifecycleObserver.onStateChanged 来回调生命周期的状态，mLifecycleObserver 又是什么呢？我们跟进 Lifecycling.lifecycleEventObserver 去看一下：
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);
}
我们如果使用 DefaultLifecycleObserver ，那么因为 DefaultLifecycleObserver 继承了 FullLifecycleObserver，所以，这里返回的就是 FullLifecycleObserver。如果是 继承了 LifecycleEventObserver，那么返回的就是 LifecycleEventObserver。如果都不满足，那就通过 getObserverConstructorType 方法来判断是使用注解或者反射的方式。
我们先看 FullLifecycleObserverAdapter
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(@NonNull LifecycleOwner source, @NonNull Lifecycle.Eventevent) {
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);
}
}
}
它实现了 LifecycleEventObserver 接口，并在 onStateChanged 方法中，回调了观察者好对应的生命周期方法。
接着，我们看一下 CompositeGeneratedAdaptersObserver 和 ReflectiveGenericLifecycleObserver ，他们都实现了 LifecycleEventObserver 接口，并在 onStateChanged 方法里处理对应的逻辑
class CompositeGeneratedAdaptersObserver implements LifecycleEventObserver {
private final GeneratedAdapter[] mGeneratedAdapters;
CompositeGeneratedAdaptersObserver(GeneratedAdapter[] generatedAdapters) {
mGeneratedAdapters = generatedAdapters;
}
@Override
public void onStateChanged(@NonNull LifecycleOwner source, @NonNull Lifecycle.Eventevent) {
MethodCallsLogger logger = new MethodCallsLogger();
for (GeneratedAdapter mGenerated: mGeneratedAdapters) {
mGenerated.callMethods(source, event, false, logger);
}
for (GeneratedAdapter mGenerated: mGeneratedAdapters) {
mGenerated.callMethods(source, event, true, logger);
}
}
}
public interface GeneratedAdapter {
/**
* 当状态转换事件发生时调用。
* 参数：
* source – 事件的来源
* 事件——事件
* onAny –approveCall onAny 处理程序
* logger – 如果通过，用于跟踪调用的方法并防止调用相同的方法两次
*/
void callMethods(LifecycleOwner source, Lifecycle.Event event, boolean onAny,
MethodCallsLogger logger);
}</pre>
<pre class="md-fences md-end-block ty-contain-cm modeLoaded" spellcheck="false" lang="java" cid="n149" mdtype="fences" style="font-style: normal; font-variant-caps: normal; font-weight: 400; letter-spacing: normal; orphans: auto; text-indent: 0px; text-transform: none; widows: auto; word-spacing: 0px; -webkit-text-size-adjust: auto; -webkit-text-stroke-width: 0px; text-decoration: none; box-sizing: border-box; overflow: visible; font-family: Monaco, Consolas, "Andale Mono", "DejaVu Sans Mono", monospace; margin-top: 0px; margin-bottom: 20px; font-size: 0.9rem; display: block; break-inside: avoid; text-align: left; white-space: normal; background-color: rgb(51, 51, 51); padding: 10px 10px 10px 30px; width: inherit; caret-color: rgb(184, 191, 198); color: rgb(184, 191, 198); position: relative !important;">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);
}
}
我们分析一下 ReflectiveGenericLifecycleObserver 的回调流程，在 onStateChanged 方法中，调用了 CallbackInfo 的 invokeCallbacks 方法，我们跟进去看一下
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);
}
}
}
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);
}
}
可以看到，就是通过反射的方式分发了生命周期的状态。
