Lifecycle原理解析
[TOC]
1.Lifecyce出现的背景
先看官方文档中对Lifecycle出现背景的介绍处理生命周期
官方文档中举了一个获取自身位置的类，该类实现的功能依赖Activity的生命周期，需要在Activity的onCreate方法中start开始定位，需要在onStop方法中stop结束定位。代码如下：
internal class MyLocationListener(
private val context: Context,
private val callback: (Location) -> Unit
) {
fun start() {
// connect to system location service
}
fun stop() {
// disconnect from system location service
}
}
class MyActivity : AppCompatActivity() {
private lateinit var myLocationListener: MyLocationListener
override fun onCreate(...) {
myLocationListener = MyLocationListener(this) { location ->
// update UI
}
}
public override fun onStart() {
super.onStart()
myLocationListener.start()
// manage other components that need to respond
// to the activity lifecycle
}
public override fun onStop() {
super.onStop()
myLocationListener.stop()
// manage other components that need to respond
// to the activity lifecycle
}
}
以上代码看起来没有问题，但实际运行过程中，可能会出现onStart方法中需要执行长时间运行的操作，在该操作没有完成时，onStop方法会在onStart方法之前结束，使得组件存留的时间比需要的时间要长。
class MyActivity : AppCompatActivity() {
private lateinit var myLocationListener: MyLocationListener
override fun onCreate(...) {
myLocationListener = MyLocationListener(this) { location ->
// update UI
}
}
public override fun onStart() {
super.onStart()
Util.checkUserStatus { result ->
// what if this callback is invoked AFTER activity is stopped?
// 这里的方法有可能在activity的onStop方法调用后执行
if (result) {
myLocationListener.start()
}
}
}
public override fun onStop() {
super.onStop()
myLocationListener.stop()
}
}
这时，就需要以另外一种方式解决该问题，Lifecycle出现了。
2.认识Lifecycle
首先介绍几个Lifecycle类库中几个常见的类，分别是Lifecycle,LifecycleOwner,LifecycleRegistry,LifecycleObserver。
Lifecycle
Lifecycle 是一个类，用于存储有关组件（如 activity 或 fragment）的生命周期状态的信息，并允许其他对象观察此状态。
Lifecycle 使用两种主要枚举跟踪其关联组件的生命周期状态：
事件
从框架和 Lifecycle 类分派的生命周期事件。这些事件映射到 activity 和 fragment 中的回调事件。
状态
由 Lifecycle 对象跟踪的组件的当前状态。
可以将状态看作图中的节点，将事件看作这些节点之间的边。
LifecycleOwner
LifecycleOwner 是单一方法接口，表示类具有生命周期 Lifecycle。它具有一种方法（即 getLifecycle()），该方法必须由类实现。
Android中的Activity、fragment实现了该接口。
public interface LifecycleOwner {
/**
* Returns the Lifecycle of the provider.
*
* @return The lifecycle of the provider.
*/
@NonNull
Lifecycle getLifecycle();
}
LifecycleRegistry LifecycleRegistry继承自Lifecycle用来处理生命周期。
LifecycleObserver
LifecycleObserver实现该接口，用来观察生命周期。
3.Lifecycle的使用
- 定义一个Observer实现LifecycerObserver
- 因为Activity实现了LifecycleOwner接口，所以可以直接调用getLifecycle方法获取Lifecyle对象。
- 通过Lifecycle的addObserver方法，添加定义的LifecyceObserver
通过以上步骤，就可以在定义Observer中，观察到Activity的生命周期变化了。
class MyObserver : DefaultLifecycleObserver {
override fun onResume(owner: LifecycleOwner) {
connect()
}
override fun onPause(owner: LifecycleOwner) {
disconnect()
}
}
myLifecycleOwner.getLifecycle().addObserver(MyObserver())
4.Lifecycle的原理
了解了Lifecycle的使用，有一个疑问，一般添加observer都是在Activity中的onCreate方法，当onCreate方法执行完，Lifecycle是怎么让observer执行onCreate方法的呢？
其实原理是
- 当activity启动时，会调用performCreate方法，在该方法中会调用onCreate方法，onCreate方法被ConponentActivity重写，所以会调用ConponentActivity的onCreate方法
- ConponentActivity的onCreate方法中调用了ReportFragment.injectIfNeededIn(this);将一个ReportFragment添加到了Activity，同时注册了ActivityLifecycleCallbacks监听Activity的声明周期。
- 然后会继续调用我们Activity的onCreate方法，将observer添加到LifecycleRegistry中。
- 最后会执行perfomCreate方法中的dispatchActivityPostCreated方法。最后执行ReportFragment中的dispatch方法来分发生命周期。
接下来理清调用链
Activity:performCreate->dispatchActivityPostCreated | ReportFragment:onActivityPostCreated->diapatch | LifecycleRegistry:handleLifecycleEvent->moveToState->sync->forwardPass->diapatchEvent->onStateChange
首先当在Activity中调用getLifecycle方法时，会获取一个mLifecycleRegistry，此时调用的getLifecycle是父类ComponentActivity的方法。
@Override
public Lifecycle getLifecycle() {
// Instead of directly using the Activity's Lifecycle, we
// use a LifecycleRegistry that is nested exactly outside of
// when Fragments get their lifecycle changed
// TODO(b/127528777) Drive Fragment Lifecycle with LifecycleObserver
return mFragmentLifecycleRegistry;
}
这个mFragmentLifecycleRegistry是在ComponentActivity实例化时初始化的。
final LifecycleRegistry mFragmentLifecycleRegistry = new LifecycleRegistry(this);
LifecycleRegistry是继承自Lifecycle的，所以当调用addObserver方法时，调用的其实是LifecycleRegistry类的addObserver方法。 下面看一下该方法。
@Override
public void addObserver(@NonNull LifecycleObserver observer) {
// 注释1：判断当前状态是否等于destoryed，如果不是，则初始状态赋值为initalized，如果是赋值为destoryed.
State initialState = mState == DESTROYED ? DESTROYED : INITIALIZED;
// 注释2：ObserverWithState是LifecycleRegistry中的一个静态内部类
ObserverWithState statefulObserver = new ObserverWithState(observer, initialState);
// 注释3：将传递进来的observer和被statefulObserver包装的observer作为参数传递进putIfAbsent方法
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;
// 注释4：计算目标状态
State targetState = calculateTargetState(observer);
mAddingObserverCounter++;
// 注释5：当前状态和目标状态对比
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--;
}
注释1：判断当前状态是否等于destoryed，如果不是，则初始状态赋值为initalized，如果是赋值为destoryed. 注释2：ObserverWithState是LifecycleRegistry中的一个静态内部类，接下来看一下这个类
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;
}
}
可以看到，在ObserverWithState类的构造方法中，会将传递进来的observer包装成LifecycleObserver，并被ObserverWithState持有，同时也持有当前的状态值mState。
注释3：将传递进来的observer和被statefulObserver包装的observer作为参数传递进putIfAbsent方法。其中，mObserverMap是一个FastSafeIterableMap，它是一个可迭代的HashMap。
注释4：计算目标状态，其实就是拿当前状态和上一个observer状态的值做对比，取最小的状态值。
private State calculateTargetState(LifecycleObserver observer) {
Entry<LifecycleObserver, ObserverWithState> previous = mObserverMap.ceil(observer);
State siblingState = previous != null ? previous.getValue().mState : null;
State parentState = !mParentStates.isEmpty() ? mParentStates.get(mParentStates.size() - 1)
: null;
return min(min(mState, siblingState), parentState);
}
总结
activity/fragment继承了lifecycleOwner表示activity/fragment是具有生命周期的组件。实现getLifecycle方法，返回lifecycle对象。
activity/fragmnet中实例化了实现了Lifecycle接口的LifecycleRegistry对象，用来处理生命周期变化。
通过lifecycle的addObserver方法，观察者模式，即可观察生命周期变化。
