简介
Lifecycle 是一个类,用于存储有关组件(如 Activity 或 Fragment)的生命周期状态的信息,并允许其他对象观察此状态。
官方对Lifecycle的定义非常简单,它的作用也很明确:存储具有生命周期的组件的生命周期状态,并且作为一个被观察者,允许其他组件保持对生命周期状态的观察。
Lifecycle组件的合理使用可赋予我们的代码显著的优点:
- 无需在组件里生命周期方法里放置大量代码,即可实现对组件生命周期的监听的处理,再实现解耦的同时,让代码更有条理且精简易维护;
- Lifecycle组件不会直接持有生命周期组件(Activity,Fragment等)的强引用,可以避免潜在的内存泄露问题。
这一点在ViewMode和LiveData里有着完美的诠释,正是借助了Lifecycle它们才具备了生命周期感知的能力。
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
lifecycle.addObserver(object : LifecycleEventObserver {
override fun onStateChanged(source: LifecycleOwner, event: Lifecycle.Event) {
Log.e("lifecycle","${event.name}")
}
})
}
复制代码
在Activity里实现如上代码就能实现对Activity生命周期的监听,但是前提是该Activity的父类或者间接父类必须是ComponentActivity/AppCompatActivity或者其他实现了LifecycleOwner的类。
Lifecycle组件的角色
Lifecycle组件中有三个重要的组件:LifecycleOwner、LifecycleRegistry/Lifecycle和LifecycleObserver。它们分别扮演着生产者,管理者和消费者的角色。整个组件就是围绕着三个角色实现对生命周期的控制和调度的。LifecycleOwner负责发出生命周期,LifecycleRegistry负责存储和调度,LifecycleObserver通过和LifecycleRegistry绑定实现对生命周期的监听和消费。
- LifecycleOwner:单一方法接口,表示实现该接口的类具有Lifecycle;
- LifecycleRegistry:Lifecycle的子类,同时持有LifecycleOwner的弱引用和LifecycleObserver的强引用,起到了一个桥梁作用,本身是一个观察者的角色。LifecycleOwner将自己的生命周期状态存在LifecycleRegistry里面。每当LifecycleOwner的生命周期发生改变时,会通知LifecycleRegistry(当然,每个生命周期组件都持有LifecycleRegistry的实例),而LifecycleObserver通过观察者模式和LifecycleRegistry绑定实现对生命周期的观察;
- LifecycleObserver:生命周期的观察者,本身是一个空接口,工作全部交由具体的实现类,只起到一个类型标记的作用。
它们的关系大致如下图所示:
LifecycleOwner
LifecycleOwner的定义很简单:
public interface LifecycleOwner {
Lifecycle getLifecycle();
}
复制代码
它是一个单一方法接口,用来标记实现类持有Lifecycle对象。getLifecycle方法返回一个Lifecycle,实际就是一个Lifecycle的实现类LifecycleRegistry的实例。AppCompatActivity、ComponentActivity和androidx.fragment.app.Fragment都实现了该接口。以ComponentActivity为例,LifeCycle在其中的实现如下:
public class ComponentActivity extends Activity implements LifecycleOwner {
private LifecycleRegistry mLifecycleRegistry = new LifecycleRegistry(this);
public Lifecycle getLifecycle() {
return mLifecycleRegistry;
}
}
复制代码
其目的很简单直接,就是为了向外部提供Lifecycle,也就是LifecycleRegistry的实例。
LifecycleRegistry/Lifecycle
LifecycleRegistry是LifeCycle的子类。它在整个组件中起到一个桥梁的作用,负责存储和分发生命周期的状态。整个组件正是通过它实现了解耦和数据传递的。
Lifecycle是一个抽象类,它定义了两个抽象方法addObserver
和removeObserver
用来添加和移除对生命周期进行监听的对象。这两个方法都由LifecycleRegistry实现。
另外还有两个表示生命周期的枚举类:
- Event:生命周期改变时的事件,它由 Lifecycle(Activity)发出,和Activity、Fragment 中的回调事件对应。
- State:组件的当前状态
public enum Event {
ON_CREATE,
ON_START,
ON_RESUME,
ON_PAUSE,
ON_STOP,
ON_DESTROY,
ON_ANY;
}
public enum State {
DESTROYED,
INITIALIZED,
CREATED,
STARTED,
RESUMED;
}
复制代码
注意这两个,看起来很像,关联性也很强。Event表示组件生命周期发生了改变时发生的状态,State表示当前组件处于的生命周期的某个状态。在Event枚举类中有如下方法:
public State getTargetState() {
switch (this) {
case ON_CREATE:
case ON_STOP:
return State.CREATED;
case ON_START:
case ON_PAUSE:
return State.STARTED;
case ON_RESUME:
return State.RESUMED;
case ON_DESTROY:
return State.DESTROYED;
case ON_ANY:
break;
}
throw new IllegalArgumentException(this + " has no target state");
}
复制代码
可以总结出他们的关系如下:
Lifecycle本身作为一个抽象类起到的更多的是定义功能,它的行为实现基本都是通过LifecycleRegistry完成的:
public class LifecycleRegistry extends Lifecycle {
//存储绑定的生命周期观察者
//使用LifecycleObserver作为key值,使用ObserverWithState内部类作为value
//ObserverWithState持有LifecycleObserver和State,前者是观察者的引用
//State表示该观察者所持有的状态
private FastSafeIterableMap<LifecycleObserver, ObserverWithState> mObserverMap =
new FastSafeIterableMap<>();
//组件当前的生命周期状态
private State mState;
//通过弱引用的方式持有LifecycleOwner(Activity/Fragment)
private final WeakReference<LifecycleOwner> mLifecycleOwner;
//正在进行绑定的观察者数量
//用来标价正在通过addObserver进行绑定的观察者的数量
private int mAddingObserverCounter = 0;
//是否正在处理生命周期事件
//mHandlingEvent为true时表示正在向外分生命周期状态
private boolean mHandlingEvent = false;
//标记有新事件发生
private boolean mNewEventOccurred = false;
//构造方法
public LifecycleRegistry(@NonNull LifecycleOwner provider) {
this(provider, true);
}
private LifecycleRegistry(@NonNull LifecycleOwner provider, boolean enforceMainThread) {
mLifecycleOwner = new WeakReference<>(provider);
mState = INITIALIZED;
mEnforceMainThread = enforceMainThread;
}
//根据当前的生命周期事件,设置当前的状态并通知观察者
public void handleLifecycleEvent(@NonNull Lifecycle.Event event) {
enforceMainThreadIfNeeded("handleLifecycleEvent");
moveToState(event.getTargetState());
}
//开始处理状态
private void moveToState(State next) {
//如果当前状态和接收到的状态一致,那么直接返回不做任何处理
if (mState == next) {
return;
}
//修改当前的生命周期状态
mState = next;
//如果正在分发状态或者有观察者正在添加,则标记有新事件发生
if (mHandlingEvent || mAddingObserverCounter != 0) {
mNewEventOccurred = true;
return;
}
//标记正在处理事件
mHandlingEvent = true;
//开始同步生命周期状态
sync();
//还原标记
mHandlingEvent = false;
}
private void sync() {
//获取LifecycleOwner并确保不为空
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;
//第一种是当前的状态值小于之前的状态,则执行回退状态的操作(如CREATED->RESUMED)
//由于backwardPass是采用倒序迭代器对链表中的观察者一次进行迭代
//所以这种情况下通过链表第一个元素进行状态比对
if (mState.compareTo(mObserverMap.eldest().getValue().mState) < 0) {
backwardPass(lifecycleOwner);
}
//第二种是当前的状态值大于之前的状态,则执行前进状态的操作(如>RESUMED->CREATED)
//由于forwardPass是采用正序迭代器对链表中的观察者一次进行迭代
//所以这种情况下通过链表最后一个元素进行状态比对
Map.Entry<LifecycleObserver, ObserverWithState> newest = mObserverMap.newest();
if (!mNewEventOccurred && newest != null
&& mState.compareTo(newest.getValue().mState) > 0) {
forwardPass(lifecycleOwner);
}
}
mNewEventOccurred = false;
}
//判断是否同步完成
//通过判断mObserverMap的最eldest和newest的状态是否和当前状态一致
//来判断是否是否将状态同步到了所有观察者
//mObserverMap是一个FastSafeIterableMap类型的,它继承自SafeIterableMap
//实现了类似LinkedHashMap的功能
//其中eldest获取的是第一个被添加的元素,也就是第一个观察者
//newest为最近一个别添加进来的元素也就是最后一个观察者
//由于生命状态同步是通过FastSafeIterableMap中的迭代器一次实现的
//所以当链表的头尾数据相同且都和当前状态保持一直,则可以认为它们同步完成了
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;
}
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一级一级的改变状态
//如果观察者所处的状态和组件的最新状态跨等级,则一步一步的升级而不会跨状态提升
//于此同时状态每次升级,观察者都会拿到一次回调
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是一个ObserverWithState类型,它是LifecycleRegistry的静态内部类
//它持有生命周期观察者的引用和它所处的状态
observer.dispatchEvent(lifecycleOwner, event);
popParentState();
}
}
}
private void backwardPass(LifecycleOwner lifecycleOwner) {
Iterator<Map.Entry<LifecycleObserver, ObserverWithState>> descendingIterator =
mObserverMap.descendingIterator();
//backwardPass除了采用倒序降级,其他地方与forwardPass逻辑基本一致。
...
}
//增加新的LifecycleObserver观察者对象
public void addObserver(@NonNull LifecycleObserver observer) {
enforceMainThreadIfNeeded("addObserver");
//如果当前组件不处于DESTROYED状态,那么标记LifecycleObserver的初始状态为INITIALIZED
State initialState = mState == DESTROYED ? DESTROYED : INITIALIZED;
//创建ObserverWithState,为LifecycleObserver赋予状态
ObserverWithState statefulObserver = new ObserverWithState(observer, initialState);
//添加到容器mObserverMap中
ObserverWithState previous = mObserverMap.putIfAbsent(observer, statefulObserver);
//如果previous不为null,表示重复添加,直接结束
if (previous != null) {
return;
}
//判断LifecycleOwner是否已经被销毁
LifecycleOwner lifecycleOwner = mLifecycleOwner.get();
if (lifecycleOwner == null) {
return;
}
//判断是否是重入状态
//例如在LifecycleObserver拿到回调之后又立即添加了监听
boolean isReentrance = mAddingObserverCounter != 0 || mHandlingEvent;
//计算状态
State targetState = calculateTargetState(observer);
//标记正在添加的LifecycleObserver的数量
mAddingObserverCounter++;
//通过一个while循环来将LifecycleObserver的状态设置为最新
//设置的过程和forwardPass一致,逐级改变并且可能会多次触发回调
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);
}
//分发事件,此处和forwardPass里的一致
statefulObserver.dispatchEvent(lifecycleOwner, event);
popParentState();
targetState = calculateTargetState(observer);
}
if (!isReentrance) {
// we do sync only on the top level.
sync();
}
mAddingObserverCounter--;
}
@Override
public void removeObserver(@NonNull LifecycleObserver observer) {
//移除观察者LifecycleObserver
mObserverMap.remove(observer);
}
//获取当前的生命周期状态
public State getCurrentState() {
return mState;
}
//封装LifecycleObserver和State
//为LifecycleObserver增加状态
//用来和组件的生命周期状态比对
//以判定生命周期是否发生改变以及后续要执行的操作
static class ObserverWithState {
//观察者LifecycleObserver所处的状态
State mState;
LifecycleEventObserver mLifecycleObserver;
ObserverWithState(LifecycleObserver observer, State initialState) {
//处理LifecycleObserver,下文LifecycleObserver小节会讲到
mLifecycleObserver = Lifecycling.lifecycleEventObserver(observer);
mState = initialState;
}
void dispatchEvent(LifecycleOwner owner, Event event) {
//分发状态并修改LifecycleObserver最新的生命周期状态
State newState = event.getTargetState();
mState = min(mState, newState);
mLifecycleObserver.onStateChanged(owner, event);
mState = newState;
}
}
}
复制代码
详细的逻辑已通过代码注释说明,但仍有几点要特别说明一下:
- LifecycleRegistry并不会直接持有LifecycleObserver,而是通过将LifecycleObserver作为Key值,使用ObserverWithState存储在FastSafeIterableMap中。ObserverWithState持有LifecycleObserver,并会持有一个生命周期状态,表示LifecycleObserver当前所收到的状态,用此状态和组件的生命周期状态进行比对,最终判断状态时升级还是降级或者维持不变;
- FastSafeIterableMap继承自SafeIterableMap,内部通过HashMap存储数据,但具备LinkedHashMap的特性,通过双向链表遍历数据,提供了正序和倒序两个迭代器;
- 每次添加LifecycleObserver的时候,都会为其绑定初始值State状态(如果组件当前状态不为DESTROYED状态默认为INITIALIZED),同时会与组件当前的状态进行比对,如果状态不同,则立刻触发状态分发机制,LifecycleObserver也会立刻收到回调。也就是LifecycleObserver在注册的时候就可能会立刻触发回调。
- 状态有两种改变方式,但是都是沿着顺序改变(DESTROYED;INITIALIZED;CREATED;CREATED;STARTED;RESUMED)一种是通过forwardPass进行升状态,只处理向RESUMED方向转化的状态,一种是backwardPass进行降状态,只处理向DESTROYED方向转化的状态。前者采用正序通知观察者回调,后者逆序。
- 状态时逐级分发调用的,不会跨级分发。状态改变后(或者添加监听时),相差多少级就会通过补发Event的方式触发多次分发以及回调。
关于第五点,使用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();
}
}
}
复制代码
注意里面的第二个while循环,它会不断比对ObserverWithState的状态(也就是LifecycleObserver的当前状态)和组件当前的生命周期状态。如果状态不匹配,则会通过Event.upFrom
获取触发下一级状态的事件并进行补发。注意是下一级,而不是组件当前的状态(LifecycleRegistry.mState)。具体看一下upFrom方法:
public static Event upFrom(@NonNull State state) {
switch (state) {
case INITIALIZED:
return ON_CREATE;
case CREATED:
return ON_START;
case STARTED:
return ON_RESUME;
default:
return null;
}
}
复制代码
注意我们传入的参数为observer.mState,也就是观察者LifecycleObserver当前的状态。紧接着forwardPass调用observer.dispatchEvent(lifecycleOwner, event);
:
static class ObserverWithState {
void dispatchEvent(LifecycleOwner owner, Event event) {
State newState = event.getTargetState();
mState = min(mState, newState);
mLifecycleObserver.onStateChanged(owner, event);
mState = newState;
}
}
复制代码
可以发现,每次循环都只将状态改变一级,然后同过不断的循环直至状态同步。也就是当组件处于RESUMED状态时,而观察者LifecycleObserver处于INITIALIZED。则会触发三次回调,而三次的Event.name依次是ON_CREATE->ON_START->ON_RESUME。
同样的,在backwardPass中,采用的是Event.downFrom方式获取Event:
public static Event downFrom(@NonNull State state) {
switch (state) {
case CREATED:
return ON_DESTROY;
case STARTED:
return ON_STOP;
case RESUMED:
return ON_PAUSE;
default:
return null;
}
}
复制代码
而且在绑定观察者的时候,就会立刻进行状态对比并同步。所以再添加监听的时候就有可能触发回调,当然它也遵守逐级改变状态的规则。所以再onCreate里写下面的代码:
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
lifecycle.addObserver(object : LifecycleEventObserver {
override fun onStateChanged(source: LifecycleOwner, event: Lifecycle.Event) {
Log.e("lifecycleOwnerState","${source.lifecycle.currentState}")
Log.e("lifecycleEvent","${event.name}")
}
})
}
复制代码
输出如下:
E/lifecycleOwnerState: CREATED
E/lifecycleEvent: ON_CREATE
E/lifecycleOwnerState: STARTED
E/lifecycleEvent: ON_START
E/lifecycleOwnerState: RESUMED
E/lifecycleEvent: ON_RESUME
复制代码
因为初始的状态为INITIALIZED,依次升级到RESUMED,回调发生了三次。而LifecycleOwner也就是Activity的状态已经是RESUMED了,所以每次都会取到它最新的状态。状态改变三次是发生在Observer的持有类ObserverWithState里的状态,也就是标记Observer的状态,就是ObserverWithState的成员变量mState。
LifecycleObserver
LifecycleObserver类是一个接口,它更多的起到类型或者身份标记的作用。它本身是一个空接口:
public interface LifecycleObserver {
}
复制代码
所有的任务基本都靠它的具体实现类完成。它有以下几个直接的实现。每个都直接实现都有不同的其他实现。
LifecycleEventObserver是最简单的实现:只提供了onStateChanged方法用于获取事件和当前的状态。
public interface LifecycleEventObserver extends LifecycleObserver {
onStateChanged(@NonNull LifecycleOwner source, @NonNull Lifecycle.Event event);
}
复制代码
还有FullLifecycleObserver:
interface FullLifecycleObserver extends LifecycleObserver {
void onCreate(LifecycleOwner owner);
void onStart(LifecycleOwner owner);
void onResume(LifecycleOwner owner);
void onPause(LifecycleOwner owner);
void onStop(LifecycleOwner owner);
void onDestroy(LifecycleOwner owner);
}
复制代码
FullLifecycleObserver比较复杂,不再一股脑通过onStateChanged回调,而是对事件进行了拆分,根据不同的事件触发不同的方法。
而将事件进行区分的逻辑放在了LifecycleEventObserver的一个实现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.Event event) {
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);
}
}
}
复制代码
FullLifecycleObserverAdapter本身也是个LifecycleEventObserver。可以用它对作为观察者进行绑定实现对生命周期事件的监听。而它重写了onStateChanged方法通过switch实现对事件的细化和区分,同时它持有FullLifecycleObserver和LifecycleEventObserver,可以按需对事件进行分发。
可能你会疑惑:LifecycleRegistry是如何区分这些观察者的具体类型的呢,毕竟它只提供了一个addObserver(LifecycleObserver)方法。答案就在LifecycleRegistry的内部类ObserverWithState中。在上文LifecycleRegistry的addObserver中,我们已经知道:LifecycleRegistry不会直接存储LifecycleObserver,而是通过ObserverWithState持有。它的构造方法如下:
static class ObserverWithState {
State mState;
LifecycleEventObserver mLifecycleObserver;
ObserverWithState(LifecycleObserver observer, State initialState) {
mLifecycleObserver = Lifecycling.lifecycleEventObserver(observer);
mState = initialState;
}
}
复制代码
mState上文已经解释过它是用来标记LifecycleObserver的状态的。重点看Lifecycling.lifecycleEventObserver(observer)
这段代码。lifecycleEventObserver是Lifecycling的一个静态方法:
static LifecycleEventObserver lifecycleEventObserver(Object object) {
//判断Observer的类型
boolean isLifecycleEventObserver = object instanceof LifecycleEventObserver;
boolean isFullLifecycleObserver = object instanceof FullLifecycleObserver;
//如果Observer同时实现了LifecycleEventObserver和FullLifecycleObserver
//通过FullLifecycleObserverAdapter包装它,并为FullLifecycleObserverAdapter的
//两个变量fullLifecycleObserver和lifecycleEventObserver进行赋值。以便回调所有相关的方法。
if (isLifecycleEventObserver && isFullLifecycleObserver) {
return new FullLifecycleObserverAdapter((FullLifecycleObserver) object,
(LifecycleEventObserver) object);
}
//如果只实现了FullLifecycleObserver,进行包装,但为FullLifecycleObserverAdapter.lifecycleEventObserver
//赋值为空。不进行它的回调
if (isFullLifecycleObserver) {
return new FullLifecycleObserverAdapter((FullLifecycleObserver) object, null);
}
//LifecycleEventObserver类型,无需处理直接返回
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);
}
复制代码
可以发现:在每次添加监听的时候,都会通过Lifecycling进行类型判断,从而确保LifecycleRegistry能正确触发不同观察者的回调事件。
另外,LifecycleEventObserver还有一个常用的实现:LifecycleBoundObserver。它是LiveData的内部类,正是它赋予了LiveData生命周期感知能力了。
事件的生产者
通过对LifeCycle的各个角色介绍,我们已经知道了生命周期事件分发和状态的流转处理方式了。LifecycleRegistry通过暴露handleLifecycleEvent方法接受事件,并进行后续处理。消费端的逻辑已经明确了。接下来就是寻找事件源了:也就是LifeCycle所处理的事件是如何产生的。
常见的生命周期事件生产者有Activity和Fragment。上文中讲到过,ComponentActivity实现LifecycleOwner接口,它就是一个能提供事件的生产者。但是它却不直接在自己的生命周期方法里低调用handleLifecycleEvent方法,而是通过ReportFragment进行。在它的onCreate方法里有如下代码:
protected void onCreate(@Nullable Bundle savedInstanceState) {
mSavedStateRegistryController.performRestore(savedInstanceState);
mContextAwareHelper.dispatchOnContextAvailable(this);
super.onCreate(savedInstanceState);
mActivityResultRegistry.onRestoreInstanceState(savedInstanceState);
ReportFragment.injectIfNeededIn(this);
if (mContentLayoutId != 0) {
setContentView(mContentLayoutId);
}
}
复制代码
看一下ReportFragment.injectIfNeededIn做了什么:
public static void injectIfNeededIn(Activity activity) {
if (Build.VERSION.SDK_INT >= 29) {
LifecycleCallbacks.registerIn(activity);
}
android.app.FragmentManager manager = activity.getFragmentManager();
if (manager.findFragmentByTag(REPORT_FRAGMENT_TAG) == null) {
manager.beginTransaction().add(new ReportFragment(), REPORT_FRAGMENT_TAG).commit();
manager.executePendingTransactions();
}
}
复制代码
injectIfNeededIn分了两种情况进行处理:
如果系统版本号>= 29,会向 Activity绑定一个LifecycleCallbacks ,直接进行生命周期监听。 LifecycleCallbacks.registerIn
的部分代码如下:
static class LifecycleCallbacks implements Application.ActivityLifecycleCallbacks {
static void registerIn(Activity activity) {
activity.registerActivityLifecycleCallbacks(new LifecycleCallbacks());
}
@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);
}
.....
}
复制代码
它实现了Application.ActivityLifecycleCallbacks接口,并向Activity进行了注册。
其中的dispatch方法实现如下:
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);
}
}
}
复制代码
就是在这里调用了LifecycleRegistry的handleLifecycleEvent方法,让他进行事件处理和分发。
而在Activity内,每当生命周期方法被触发。都会遍历ActivityLifecycleCallbacks然后进行回调。以onPause为例,相关代码如下:
private final ArrayList<Application.ActivityLifecycleCallbacks> mActivityLifecycleCallbacks =
new ArrayList<Application.ActivityLifecycleCallbacks>();
protected void onPause() {
...
dispatchActivityPaused();
...
}
//分发事件
private void dispatchActivityPaused() {
Object[] callbacks = collectActivityLifecycleCallbacks();
if (callbacks != null) {
for (int i = callbacks.length - 1; i >= 0; i--) {
//遍历注册的对象,并依次触发
((Application.ActivityLifecycleCallbacks) callbacks[i]).onActivityPaused(this);
}
}
getApplication().dispatchActivityPaused(this);
}
//返回所有的注册回调对象
private Object[] collectActivityLifecycleCallbacks() {
Object[] callbacks = null;
synchronized (mActivityLifecycleCallbacks) {
if (mActivityLifecycleCallbacks.size() > 0) {
callbacks = mActivityLifecycleCallbacks.toArray();
}
}
return callbacks;
}
//添加callBack
public void registerActivityLifecycleCallbacks(
@NonNull Application.ActivityLifecycleCallbacks callback) {
synchronized (mActivityLifecycleCallbacks) {
mActivityLifecycleCallbacks.add(callback);
}
}
复制代码
就是一个很简单的回调。
而对于系统版本号小于小于29的。则会向Activity添加一个无 UI 界面的ReportFragment实现监听,摘录一些ReportFragment的生命周期方法:
@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;
}
private void dispatch(@NonNull Lifecycle.Event event) {
if (Build.VERSION.SDK_INT < 29) {
// Only dispatch events from ReportFragment on API levels prior
// to API 29. On API 29+, this is handled by the ActivityLifecycleCallbacks
// added in ReportFragment.injectIfNeededIn
dispatch(getActivity(), event);
}
}
复制代码
最终还是通过dispatch方法调用了LifecycleRegistry的handleLifecycleEvent方法,让他进行事件处理和分发。
只所以这样区分版本号,是registerActivityLifecycleCallbacks在Api 29时才被添加。
而在androidx.fragment.app.Fragment就简单粗暴的多了,已RESUME为例:
LifecycleRegistry mLifecycleRegistry;
public Fragment() {
initLifecycle();
}
private void initLifecycle() {
mLifecycleRegistry = new LifecycleRegistry(this);
...
}
public Lifecycle getLifecycle() {
return mLifecycleRegistry;
}
void performResume() {
...
onResume();
mLifecycleRegistry.handleLifecycleEvent(Lifecycle.Event.ON_RESUME);
..
}
复制代码
就是简单粗暴的在相关生命周期方法执行时直接通过LifecycleRegistry.handleLifecycleEvent发送事件。
相关扩展
LiveData和ViewModel是如何具备生命周期感知能力的呢,并在Activity生命周期结束时自行销毁的呢?
ViewModel的感知方式很简单,在ComponentActivity的构造方法有如下代码:
public ComponentActivity() {
Lifecycle lifecycle = getLifecycle();
getLifecycle().addObserver(new LifecycleEventObserver() {
@Override
public void onStateChanged(@NonNull LifecycleOwner source,
@NonNull Lifecycle.Event event) {
if (event == Lifecycle.Event.ON_DESTROY) {
// Clear out the available context
mContextAwareHelper.clearAvailableContext();
// And clear the ViewModelStore
if (!isChangingConfigurations()) {
getViewModelStore().clear();
}
}
}
});
}
复制代码
可以看到,正式通过LifeCycle实现对ON_DESTROY事件实行监听,然后ViewModelStore.clear方法从而达到销毁ViewModel的目的。
而LiveData则比较复杂一点,它通过一个LifecycleBoundObserver实现了对生命周期的监听。并重写了onStateChanged方法:
public void onStateChanged(@NonNull LifecycleOwner source,
@NonNull Lifecycle.Event event) {
Lifecycle.State currentState = mOwner.getLifecycle().getCurrentState();
if (currentState == DESTROYED) {
removeObserver(mObserver);
return;
}
Lifecycle.State prevState = null;
while (prevState != currentState) {
prevState = currentState;
activeStateChanged(shouldBeActive());
currentState = mOwner.getLifecycle().getCurrentState();
}
}
复制代码
可以看到:LiveData不仅会在DESTROYED进行解除绑定操作。还会进行判断,触发LiveData的回调。
这里只是简略的提了一下LiveData和ViewModel的生命周期处理,更过细节可结合LiveData源码解析和ViewModel源码分析。
Lifecycle还提供了ProcessLifecycleOwner实现对Application也就是应用程序的生命周期的监听。
只需要通过下面代码就可以实现监听:
class MainApplication : Application() {
override fun onCreate() {
super.onCreate()
ProcessLifecycleOwner.get().lifecycle.addObserver(object : LifecycleEventObserver {
override fun onStateChanged(source: LifecycleOwner, event: Lifecycle.Event) {
when(event){
Lifecycle.Event.ON_CREATE-> Log.e("event","App进程被创建")
Lifecycle.Event.ON_START-> Log.e("event","App进入到前台")
Lifecycle.Event.ON_RESUME-> Log.e("event","App进入到前台")
Lifecycle.Event.ON_PAUSE-> Log.e("event","App进入后台")
Lifecycle.Event.ON_STOP-> Log.e("event","App进入后台")
Lifecycle.Event.ON_DESTROY-> Log.e("event","系统不会分发,永远不会触发")
}
}
})
}
}
复制代码
摘录ProcessLifecycleOwner关键代码如下:
public class ProcessLifecycleOwner implements LifecycleOwner {
private Handler mHandler;
private final LifecycleRegistry mRegistry = new LifecycleRegistry(this);
private Runnable mDelayedPauseRunnable = new Runnable() {
@Override
public void run() {
dispatchPauseIfNeeded();
dispatchStopIfNeeded();
}
};
ActivityInitializationListener mInitializationListener =
new ActivityInitializationListener() {
@Override
public void onCreate() {
}
@Override
public void onStart() {
activityStarted();
}
@Override
public void onResume() {
activityResumed();
}
};
private static final ProcessLifecycleOwner sInstance = new ProcessLifecycleOwner();
public static LifecycleOwner get() {
return sInstance;
}
static void init(Context context) {
sInstance.attach(context);
}
void activityStarted() {
mStartedCounter++;
if (mStartedCounter == 1 && mStopSent) {
mRegistry.handleLifecycleEvent(Lifecycle.Event.ON_START);
mStopSent = false;
}
}
void activityResumed() {
...
}
void activityPaused() {
...
mHandler.postDelayed(mDelayedPauseRunnable, TIMEOUT_MS);
}
void activityStopped() {
dispatchStopIfNeeded();
}
void dispatchStopIfNeeded() {
if (mStartedCounter == 0 && mPauseSent) {
mRegistry.handleLifecycleEvent(Lifecycle.Event.ON_STOP);
mStopSent = true;
}
}
private ProcessLifecycleOwner() {
}
void attach(Context context) {
mHandler = new Handler();
mRegistry.handleLifecycleEvent(Lifecycle.Event.ON_CREATE);
Application app = (Application) context.getApplicationContext();
app.registerActivityLifecycleCallbacks(new EmptyActivityLifecycleCallbacks() {
@Override
public void onActivityPreCreated(@NonNull Activity activity,
@Nullable Bundle savedInstanceState) {
.
activity.registerActivityLifecycleCallbacks(new EmptyActivityLifecycleCallbacks() {
@Override
public void onActivityPostStarted(@NonNull Activity activity) {
activityStarted();
}
@Override
public void onActivityPostResumed(@NonNull Activity activity) {
activityResumed();
}
});
}
@Override
public void onActivityCreated(Activity activity, Bundle savedInstanceState) {
if (Build.VERSION.SDK_INT < 29) {
ReportFragment.get(activity).setProcessListener(mInitializationListener);
}
}
@Override
public void onActivityPaused(Activity activity) {
activityPaused();
}
@Override
public void onActivityStopped(Activity activity) {
activityStopped();
}
});
}
@NonNull
@Override
public Lifecycle getLifecycle() {
return mRegistry;
}
}
复制代码
可以总结以下几点:
- ProcessLifecycleOwner通过Application.registerActivityLifecycleCallbacks来监听生命周期回调。
- ProcessLifecycleOwner监听Application生命周期,并且不会触发ON_DESTROY;
- ProcessLifecycleOwner使用可能使用Handler.postDelayed发动时间,会延时TIMEOUT_MS,也就是700毫秒。
接着就是ProcessLifecycleOwner的初始化分析了。
public class ProcessLifecycleOwnerInitializer extends ContentProvider {
@Override
public boolean onCreate() {
LifecycleDispatcher.init(getContext());
ProcessLifecycleOwner.init(getContext());
return true;
}
...
}
复制代码
ProcessLifecycleOwner通过ProcessLifecycleOwnerInitializer进行初始化,它是一个ContentProvider。
而在LifeCycle会自动在AndroidManifest配置文件里注册它:
<manifest xmlns:android="http://schemas.android.com/apk/res/android"
package="androidx.lifecycle.process" >
<uses-sdk
android:minSdkVersion="14"
android:targetSdkVersion="28" />
<application>
<provider
android:name="androidx.lifecycle.ProcessLifecycleOwnerInitializer"
android:authorities="${applicationId}.lifecycle-process"
android:exported="false"
android:multiprocess="true" />
</application>
</manifest>
复制代码
通过这种方式,LifeCycle可以实现无侵入的对Application进行监听。
总结
- Activity和Fragment通过实现LifecycleOwner持有LifecycleRegistry的实例,并通过LifecycleRegistry进行生命周期事件的分发和处理;
- LifecycleRegistry通过持有LifecycleOwner的弱引用来获取相关状态,同时避免可能发生的内存泄露;
- LifecycleRegistry会按步骤分发事件,不可越级跳跃。存在级别差异的则会补发中间所有的事件;
- ComponentActivity会根据系统版本号不同分别采取ReportFragment代发和Application.registerActivityLifecycleCallbacks回调两种方式分发事件。Fragment则是直接分发。