Jetpack中的Lifecycle可以让我们感知Activity或Fragment生命周期的变化，进而可以让业务代码在组件的生命周期内执行。
Lifecycle用于存储有关组件（Activity或Fragment）的生命周期状态的信息，并允许其他对象观察此状态。Lifecycle允许其他对象观察查询当前状态（通过isAtLeast方法）。
LifecycleOwner是单一方法接口，表示类具有Lifecycle，它只有一个方法getLifecycle.LifecycleObserver可以注册到Lifecycle中，以观察其生命周期的变化。若使用自定义LifecycleOwner，可以使用LifecycleRegistry，然后将事件转发到LifecycleRegistry。LifecycleRegistry实现了Lifecycle。
可以从官方给的图中看出生命周期状态的变化，它是一种升级和降级的状态变化，状态从小到大为DESTROYED，INITIALIZED，CREATED，STARTED，RESUMED。在Fragment或Activity创建后，其处于INITIALIZED状态，在发送ON_CREATE事件（onCreate方法被调用）后，Fragment的生命状态变为CREATED，在发送ON_START事件（onStart方法被调用）后，变为STARTED状态，以此类推。
借由上图介绍一下Lifecycle.Event类中的几个方法：
downFrom(State state)方法，此方法返回使“state”降一级的事件。例如，若state为RESUMED，则方法的返回值为ON_PAUSE事件，因为ON_PAUSE事件可以使状态RESUMED降为STARTED
downTo(State state)方法，返回使状态将到state需要的事件。例如，若state为STARTED，则方法返回ON_PAUSE事件。
upFrom(State state)方法，返回使状态“state”升一级的事件。例如，若state为STARTED，则方法返回ON_RESUME事件，因为ON_RESUME事件可以使状态STARTED升级为RESUMED。
upTo(State state)方法，返回升级到状态“state”需要的事件。例如，若state为RESUMED，则方法返回ON_RESUME。
getTargetState(Event event)，返回事件event发生后组件的状态。例如，若event为ON_START或ON_PAUSE，则方法返回STARTED，因为ON_START事件及ON_PAUSE事件发生后，组件的状态都会变为STARTED（区别为一个是升级为STARTED，一个是降级为STARTED）。
接下来，以一个使用例子来从代码角度介绍Lifecycle的原理。
Lifecycle生命周期代码分析
在这里，先给出一个例子，然后借由此例子介绍Lifecycle的实现原理。在Fragment中，可能会持有LiveData变量，并在LiveData中的数据发生改变时，进行一些操作。代码如下：
class MyFragment :Fragment(){
var testLiveData:LiveData<String> = MutableLiveData("value")
override fun onCreateView(inflater: LayoutInflater, container: ViewGroup?, savedInstanceState: Bundle?): View? {
return super.onCreateView(inflater, container, savedInstanceState)
testLiveData.observe(viewLifecycleOwner, Observer {
//省略逻辑操作
})
}
}在上面的代码中，testLiveData会在viewLifecycle的生命周期改变时，收到通知。若数据发生改变则会通知观察者，去做进一步处理。其实现逻辑是，将Observer对象封装到了LifecycleObserver对象中，以实现在view生命周期变化时，通知Observer的目的。在此，主要介绍Lifecycle，关于LiveData部分将在下一节介绍。先给出Lifecycle的类图：
从图中可以看出，viewLifecyclerOwner的类型为FragmentViewLifecyclerOwner，其内部持有Lifecycle对象，即LifecycleRegistry，而LifecycleRegistry是Lifecycle的实现类，其内部持有一个LifecycleOwner的弱引用，和一组LifecycleObserver对象（生命周期的观察者）。这样在生命周期发生改变时，可以通过LifecycleRegistry的handleLifecycleEvent方法通知内部的观察者，被观察者的生命周期发生变化。
Lifecycle中的观察者类为LifecyclerObserver，但是在Lifecycle体系中，通常还会创建一个类ObserverWithState来同时保存观察者和状态，这与LiveData有关联，LiveData的特性是只给处于活跃状态（STARTED或RESUMED）的观察者发送更新通知，因此，需要给观察者设置一个state，以表示观察者的状态。例如，在LifecycleRegistry中使用FastSafeIterableMap，以key--value的形式保存观察者及生命状态，其中key是LifecycleObserver，value就是ObserverWithState。ObserverWithState中保存了生命状态和观察者，其代码如下：
static class ObserverWithState {
State mState;
LifecycleEventObserver mLifecycleObserver;
ObserverWithState(LifecycleObserver observer, State initialState) {
mLifecycleObserver = Lifecycling.lifecycleEventObserver(observer);
mState = initialState;
}
void dispatchEvent(LifecycleOwner owner, Event event) {
//获取事件event对应的状态
State newState = event.getTargetState();
mState = min(mState, newState);
//通知观察者，生命状态发生变化
mLifecycleObserver.onStateChanged(owner, event);
//根据事件event，更新状态
mState = newState;
}
}当我们在使用自定义的lifecycle对象时，可以通过handleLifecycleEvent方法或markState方法来通知观察者生命状态发生改变。这2个方法的代码如下：
public void handleLifecycleEvent(@NonNull Lifecycle.Event event) {
enforceMainThreadIfNeeded("handleLifecycleEvent");
moveToState(event.getTargetState());
}
public void markState(@NonNull State state) {
enforceMainThreadIfNeeded("markState");
setCurrentState(state);
}
public void setCurrentState(@NonNull State state) {
enforceMainThreadIfNeeded("setCurrentState");
//最终都调用此方法
moveToState(state);
}可以看到，这2个方法最终都会调用moveToState方法，moveToState方法代码如下：
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;
} 接下会调用sync方法，代码如下：
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);
}
Map.Entry<LifecycleObserver, ObserverWithState> newest = mObserverMap.newest();
if (!mNewEventOccurred && newest != null
&& mState.compareTo(newest.getValue().mState) > 0) {
//有的观察者的状态低于当前状态，通知他们升级
forwardPass(lifecycleOwner);
}
}
mNewEventOccurred = false;
}首先，调用isSynced检查是否需要让观察者同步状态，此方法会检查所注册观察者的状态是否与当前状态一致，若不一致（返回false），则需要通知观察者同步状态。接下来，从2个方面同步观察者的状态，1）、若存在状态等级高于当前状态的观察者，则调用backwardPass方法通知观察者让状态降级；2）、若存在状态等级低于当前状态的观察者，则调用forwardPasst方法通知观察者让状态升级。
backwardPass方法的代码如下：
private void backwardPass(LifecycleOwner lifecycleOwner) {
Iterator<Map.Entry<LifecycleObserver, ObserverWithState>> descendingIterator =
mObserverMap.descendingIterator();
//遍历所有的观察者
while (descendingIterator.hasNext() && !mNewEventOccurred) {
Map.Entry<LifecycleObserver, ObserverWithState> entry = descendingIterator.next();
ObserverWithState observer = entry.getValue();
//检查观察者状态是否高于当前状态，若高于，则循环降低其状态，直至与当前状态相同
while ((observer.mState.compareTo(mState) > 0 && !mNewEventOccurred
&& mObserverMap.contains(entry.getKey()))) {
//根据观察者的当前状态，获取一个可以使当前状态降一级的事件
Event event = Event.downFrom(observer.mState);
if (event == null) {
throw new IllegalStateException("no event down from " + observer.mState);
}
pushParentState(event.getTargetState());
//通知观察者生命周期状态发生改变，观察者会降低其状态。
observer.dispatchEvent(lifecycleOwner, event);
popParentState();
}
}
}此方法会遍历所有注册的观察者，然后，针对每一个观察者，循环检查其状态是否高于当前状态，若高于当前状态，则先调用downFrom方法，获取一个可以使状态降一级的事件；再调用observer.dispatchEvent告知观察者生命周期发生变化，并使其生命状态降一级。
forwardPass方法的代码如下：
private void forwardPass(LifecycleOwner lifecycleOwner) {
Iterator<Map.Entry<LifecycleObserver, ObserverWithState>> ascendingIterator =
mObserverMap.iteratorWithAdditions();
while (ascendingIterator.hasNext() && !mNewEventOccurred) {
Map.Entry<LifecycleObserver, ObserverWithState> entry = ascendingIterator.next();
ObserverWithState observer = entry.getValue();
//循环升高观察者的状态，直至与当前状态相同
while ((observer.mState.compareTo(mState) < 0 && !mNewEventOccurred
&& mObserverMap.contains(entry.getKey()))) {
pushParentState(observer.mState);
//根据观察者的状态，获取一个可以升高状态的事件
final Event event = Event.upFrom(observer.mState);
if (event == null) {
throw new IllegalStateException("no event up from " + observer.mState);
}
//通知观察者 生命周期发生变化,并升级观察者中保存的状态
observer.dispatchEvent(lifecycleOwner, event);
popParentState();
}
}
}forwardPass方法的逻辑与backwardPass方法相反，在此不再详细解释。
Lifecycle除了在生命周期变化时通知观察者，也会在观察者刚刚注册时，给观察者发送通知，注册观察者的代码如下：
public void addObserver(@NonNull LifecycleObserver observer) {
enforceMainThreadIfNeeded("addObserver");
//设置观察者的初始状态，一般为INITIALIZED
State initialState = mState == DESTROYED ? DESTROYED : INITIALIZED;
ObserverWithState statefulObserver = new ObserverWithState(observer, initialState);
//将观察者保存到mObserverMap中
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);
//根据观察者的状态，获取一个升级状态的事件
final Event event = Event.upFrom(statefulObserver.mState);
if (event == null) {
throw new IllegalStateException("no event up from " + statefulObserver.mState);
}
//通知观察者状态变化，并更新观察者的状态，在fragment中，通常在onCreateView中注册
//观察者，这时候组件的生命状态为CREATED,所以会进入到此while循环，以通知观察者更新状态
statefulObserver.dispatchEvent(lifecycleOwner, event);
popParentState();
// mState / subling may have been changed recalculate
targetState = calculateTargetState(observer);
}
if (!isReentrance) {
// we do sync only on the top level.
//检查并更新所有注册的观察者
sync();
}
mAddingObserverCounter--;
}总结：在Lifecyle体系中，当组件的生命周期变化时会通知观察者，同时在观察者注册时，也会通知观察者。而观察者中通常也保存了生命状态（ObserverWithState）。在使用时，通常用LifecycleRegistry存储生命周期信息和观察者，从而发挥生命组件的作用。
扫一扫
567
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
