Lifecycle组件，作为LiveDada和ViewModel的支撑的同时，也为我们提供了一种新的监控生命周期的方法，所以我们很有必要了解一下其实现方式。
#1.从getLifecycle()开始
通过Lifecycle的使用流程发现，我们实现的LifecycleObserver的最终都要在Lifecycle#addObserver中注册。那么Lifecycle究竟是什么呢。
查阅源码我们发现，该类是一个抽象类，声明了三个重要的方法：
addObserver(@NonNull LifecycleObserver observer)removeObserver(@NonNull LifecycleObserver observer)getCurrentState()通过前两个方法，我们可以添加/删除回调，而通过getCurrentState()则可以获取一个State类型的实例，来知晓当前Activity/Fragment生命周期，State类声明如下：
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;
}
}
注释很好的解释了每种状态的意义。那么这个Lifecycle又是何时在Activity/Fragment中赋值的呢？
- Activity
Activity的
getLifecycle()方法如下：
public Lifecycle getLifecycle() {
return mLifecycleRegistry;
}
mLifecycleRegistry是LifecycleRegistry类型的，而LifecycleRegistry是Lifecycle的子类，其在Activity被构造时便已经生成：
private final LifecycleRegistry mLifecycleRegistry = new LifecycleRegistry(this);
可以看到，这里把Activity作为参数传给了LifecycleRegistry，其构造函数如下：
public LifecycleRegistry(@NonNull LifecycleOwner provider) {
mLifecycleOwner = new WeakReference<>(provider);
mState = INITIALIZED;
}
而ComponentActivity实现了以下接口：
LifecycleOwnerViewModelStoreOwnerSavedStateRegistryOwnerLifecycleOwner接口仅仅声明了getLifecycle()这一个方法。我们先把目光放在LifecycleRegistry#addObserver()上:
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;
}
// 这里使用弱引用的方式防止Activity泄露
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--;
}
该方法通过mObserverMap.putIfAbsent(observer, statefulObserver)将监听器填入到mObserverMap，该变量实际就是一个链表map，key为LifecycleObserver。实际上最终的生命周期回调都是在ObserverWithState#dispatchEvent(LifecycleOwner, Event)完成的，该类的存在，主要是为了处理临时添加监听器导致的状态不一致的问题。那么Lifecycle究竟是如何感知声明周期的呢，答案在ComponentActivity#onCreate()中：
protected void onCreate(@Nullable Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
mSavedStateRegistryController.performRestore(savedInstanceState);
// 关键代码
ReportFragment.injectIfNeededIn(this);
if (mContentLayoutId != 0) {
setContentView(mContentLayoutId);
}
}
我们继续看ReportFragment.injectIfNeededIn():
public static void injectIfNeededIn(Activity activity) {
// ProcessLifecycleOwner should always correctly work and some activities may not extend
// FragmentActivity from support lib, so we use framework fragments for activities
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();
}
}
该方法的作用就是如果当前Activity不存在ReportFragment便添加一个。manager.executePendingTransactions()这一行很关键，表示这一操作并不会添加到FragmentManager的消息队列中，而是立即执行，以此期望该Fragment能够第一被添加到Activity中。相信很多读者此时已经猜出答案了：Lifecycle正是通过一个无界面的Fragment来感知Activity的生命周期的。但这是之前版本的实现方式，在最新AndroidX 2.2.0版本中，采用了在相关生命周期中直接调用的方式来实现，以State.CREATED为例，该状态在ComponentActivity#onSaveInstanceState()被回调：
protected void onSaveInstanceState(@NonNull Bundle outState) {
Lifecycle lifecycle = getLifecycle();
if (lifecycle instanceof LifecycleRegistry) {
// 关键代码
((LifecycleRegistry) lifecycle).markState(Lifecycle.State.CREATED);
}
super.onSaveInstanceState(outState);
mSavedStateRegistryController.performSave(outState);
}
可以发现，CREATED这一状态实在onCreate()调用之后，onSaveInstanceState()调用之前切换的，而LifecycleRegistry#markState内部则会通过sync()方法来让每一个Observer都追赶上当前的状态。这里之所以用追赶，是因为它并不会只通知当前状态，而是从observer所处的状态过渡到当前状态，这期间经过的每一状态都会产生回调，与Fragment生命周期颇为相似:
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 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();
}
}
}
回调代码如下[ObserverWithState#dispatchEvent()]：
void dispatchEvent(LifecycleOwner owner, Event event) {
State newState = getStateAfter(event);
mState = min(mState, newState);
mLifecycleObserver.onStateChanged(owner, event);
mState = newState;
}
这里的mLifecycleObserver类型为LifecycleEventObserver,它是在ObserverWithState构造函数中通过Lifecycling.lifecycleEventObserver(observer)生成的，实际上是Lifecycling的实例。那么我们转到Lifecycling.lifecycleEventObserver(),看看他做了什么：
static LifecycleEventObserver lifecycleEventObserver(Object object) {
// LifecycleEventObserver 仅拥有onStateChanged()方法的接口
boolean isLifecycleEventObserver = object instanceof LifecycleEventObserver;
// FullLifecycleObserver 拥有全部生命周期回调的接口
boolean isFullLifecycleObserver = object instanceof FullLifecycleObserver;
// 如果同时实现了这两个接口
if (isLifecycleEventObserver && isFullLifecycleObserver) {
// FullLifecycleObserverAdapter是FullLifecycleObserver，LifecycleEventObserver
// 的适配器，实现的是LifecycleEventObserver接口，用于在onStateChanged()转发生命周期
return new FullLifecycleObserverAdapter((FullLifecycleObserver) object,
(LifecycleEventObserver) object);
}
// 如果仅实现了FullLifecycleObserver
if (isFullLifecycleObserver) {
return new FullLifecycleObserverAdapter((FullLifecycleObserver) object, null);
}
// 如果仅实现了LifecycleEventObserver 直接返回该observer
if (isLifecycleEventObserver) {
return (LifecycleEventObserver) object;
}
// 如果使用的是
final Class<?> klass = object.getClass();
int type = getObserverConstructorType(klass);
// 如果是生成类型 @OnLifecycleEvent 注解
if (type == GENERATED_CALLBACK) {
// 获取GeneratedAdapter的列表
List<Constructor<? extends GeneratedAdapter>> constructors =
sClassToAdapters.get(klass);
// 如果仅存在一个对应的adapter
if (constructors.size() == 1) {
GeneratedAdapter generatedAdapter = createGeneratedAdapter(
constructors.get(0), object);
// 通过反射生成GeneratedAdapter并填入dadoter
return new SingleGeneratedAdapterObserver(generatedAdapter);
}
// 如果父类及接口列表中有多个实现了LifecycleObserver，则对应的adapter都会收到通知
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);
}
// 如果是反射类型，直接反射调用
// 反射方法支持三种声明：
// 1.没有参数
// 2.仅有LifecycleOwner
// 3.(LifecycleOwner,Lifecycle.Event)
return new ReflectiveGenericLifecycleObserver(object);
}
这里是解析我们自定义的LifecycleObserver的关键，主要做了以下工作，即识别Observer的类型并返回包装类：
LifecycleEventObserver或者FullLifecycleObserver的实现类，则直接返回对应适配器，这些适配器主要是为了兼顾使用@OnLifecycleEvent的方式。- 使用
@OnLifecycleEvent的方式- 有生成类 xxx_LifecycleAdapter,则包装生成类
CompositeGeneratedAdaptersObserver - 没有生成类，使用反射方式包装：
ReflectiveGenericLifecycleObserver由此看出最终都是通过包装类，最终调用到我们自定义的Observer，完成生命周期的回调。
- 有生成类 xxx_LifecycleAdapter,则包装生成类
Fragment的实现与Activity类似，我们先看LifecycleRegistry的生成：
private void initLifecycle() {
mLifecycleRegistry = new LifecycleRegistry(this);
mSavedStateRegistryController = SavedStateRegistryController.create(this);
if (Build.VERSION.SDK_INT >= 19) {
mLifecycleRegistry.addObserver(new GenericLifecycleObserver() {
@Override
public void onStateChanged(@NonNull LifecycleOwner source,
@NonNull Lifecycle.Event event) {
if (event == Lifecycle.Event.ON_STOP) {
if (mView != null) {
mView.cancelPendingInputEvents();
}
}
}
});
}
}
该方法在FragmentManagerImpl#makeInactive中调用，用于初始化LifecycleRegistry。那么又是如何感知Fragment的生命周期的呢？答案在Fragment的performXXX方法中，以onCreated为例：
void performCreate(Bundle savedInstanceState) {
mChildFragmentManager.noteStateNotSaved();
mState = CREATED;
mCalled = false;
mSavedStateRegistryController.performRestore(savedInstanceState);
onCreate(savedInstanceState);
mIsCreated = true;
if (!mCalled) {
throw new SuperNotCalledException("Fragment " + this
+ " did not call through to super.onCreate()");
}
mLifecycleRegistry.handleLifecycleEvent(Lifecycle.Event.ON_CREATE);
}
handleLifecycleEvent()同样调用了makeState()来变更状态。而Fragment的performXXX正是由FragmentManagerImpl调用的。至此便实现了Fragment声明周期的感知。
