一.Lifecycle是什么?
Lifecycle是生命周期的意思。它是Jetpack中的一个 生命周期感知型组件 ，可执行操作来感知响应另一个组件（如 Activity 和 Fragment）的生命周期状态的变化。
二.Lifecycle的使用
1.第一步添加依赖
api "androidx.lifecycle:lifecycle-viewmodel-ktx:2.2.0" //根据实际版本添加
api "androidx.lifecycle:lifecycle-extensions:2.2.0" //根据实际版本添加
2.实现LifecycleObserver接口以及添加注解
class MytViewModelLifecycle: LifecycleObserver {
var TAG="MytViewModelLifecycle"
@OnLifecycleEvent(Lifecycle.Event.ON_CREATE)
fun onCreate(){
Log.d(TAG,"onCreate")
}
@OnLifecycleEvent(Lifecycle.Event.ON_START)
fun onStart(){
Log.d(TAG,"onStart")
}
@OnLifecycleEvent(Lifecycle.Event.ON_RESUME)
fun onResume(){
Log.d(TAG,"onResume")
}
@OnLifecycleEvent(Lifecycle.Event.ON_PAUSE)
fun onPause(){
Log.d(TAG,"onPause")
}
@OnLifecycleEvent(Lifecycle.Event.ON_STOP)
fun onStop(){
Log.d(TAG,"onStop")
}
@OnLifecycleEvent(Lifecycle.Event.ON_DESTROY)
fun onDestroy() {
Log.d(TAG,"onDestroy")
}
}
3.在Activity中或者Fragment中调用lifecycle.addObserver方法,把LifecycleObserver传入进去就可以
lifecycle.addObserver(MytViewModelLifecycle())
使用是不是很简单,在MytViewModelLifecycle里面就可以监听到Activity中或者Fragment生命周期了
三.原理分析
1.首先分析lifecycle怎么来的
lifecycle调用的是ComponentActivity的getLifecycle方法,返回了一个mLifecycleRegistry
ComponentActivity.class
@Override
public Lifecycle getLifecycle() {
return mLifecycleRegistry;
}
那么我们就从ComponentActivity入手会实现了它LifecycleOwner接口,并且初始化了LifecycleRegistry
2.addObserver分析
上面了解了lifecycle的实例,那么我们就从LifecycleRegistry入手,首先看addObserver方法,我们只管传入的参数哪里去了,也就是说我们只需要看ObserverWithState做了什么事.
ObserverWithState会调用Lifecycling.lifecycleEventObserver方法,然后创建ReflectiveGenericLifecycleObserver对象,然后调用ClassesInfoCache.sInstance.getInfo,这个方法传入的是我们的MytViewModelLifecycle的对象,拿到他的class,然后通过反射拿到MytViewModelLifecycle方法和注解并且存入map.具体怎么反射这里就不细讲了! (在反射中一般都是通过map去存取提高性能)
@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--;
}
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;
}
}
Lifecycling.class
@NonNull
static LifecycleEventObserver lifecycleEventObserver(Object object) {
....
return new ReflectiveGenericLifecycleObserver(object);
}
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);
}
}
3.观察者(MytViewModelLifecycle)是如何知道被观察者(Activity)的生命周期的
回到ComponentActivity中的onCreate方法,它会创建一个空白的ReportFragment,有了这个ReportFragment,当activity执行生命周期ReportFragment也会执行相应的生命周期. 我们以onStart为例,每个生命周期都会调用dispatch方法,最终都会调用**dispatch( Activity activity, Lifecycle.Event event)方法. 然后调用((LifecycleRegistry) lifecycle).handleLifecycleEvent(event)方法
在handleLifecycleEvent分别会调用getStateAfter和moveToState方法这两个方法,getStateAfter的目的就是通过生命周期得到一个状态.方便大家理解大家可以看白色背景的那张图.通过不同的事件拿到相应的状态
1.初始化状态->页面显示状态,这种情况属于activity的创建到显示 这属于前进状态
2.页面显示状态->销毁状态:这种情况下属于activity回到不可见了 这属于倒退状态
moveToState(next):这个方法的意思就是状态对齐.举个栗子吧:假如activity(被观察者)现在是onstart状态,这时候观察者MytViewModelLifecycle还是CREATE状态,这时候为了保证生命周期对齐,所以需要将next赋值给State,接着调用sync()进行同步
isSynced是否完整对齐,如果没有完成对齐就进入循环
if (mState.compareTo(mObserverMap.eldest().getValue().mState) <0)这个判断的意思就是比较枚举大小 mState指的是activity(被观察者)的状态,mObserverMap指的是观察者的状态, 之所以有这个判断的原因就是区分前进状态还倒退状态,如果是倒退流程就进入backwardPass方法,否则的话调用forwardPass前进状态
backwardPass方法 如果满足条件的主要调用downEvent 这个方法主要通过状态拿到事件,例如现在是STARTED对应上面的图拿到ON_STOP事件,然后又通过getStateAfter(ON_STOP)方法去拿到CREATED状态,
LifecycleEventObserver是一个接口 然后ReflectiveGenericLifecycleObserver实现了这个接口,所以最终调用了ReflectiveGenericLifecycleObserver的onStateChanged方法
invokeCallbacks方法里面通过反射拿到执行相应方法,这里就不多阐述了!
再回到sync()里面的forwardPass方法 如果满足条件的主要调用upEvent(observer.mState)拿到前进状态,例如现在是STARTED状态就可以到ON_RESUME事件通过ON_RESUME事件最终通过反射调用@OnLifecycleEvent(Lifecycle.Event.ON_RESUME)的方法
总结一下:
1.ComponentActivity里面实现了LifecycleOwner接口 ,并且初始化LifecycleRegistry了,LifecycleRegistry是实现了LifecycleOwner接口
2.在ComponentActivity里面创建了一个透明的ReportFragment来感应activity的生命周期,在Fragment的生命周期方法里面分别执行对应的dispatch方法
2.addObserver方法创建了ReflectiveGenericLifecycleObserver并且存储了观察者的class信息,
3.在dispatch传入相应的事件之后,然后通过getStateAfter拿到相应的状态
4.通过状态枚举比大小,如果是倒退流程就调用backwardPass方法,backwardPass方法会通过downEvent拿到状态拿到事件,然后又通过事件拿到状态
5.,如果是前进流程就调用forwardPass方法,forwardPass方法会通过upEvent拿到状态拿到事件
6.最后在ReflectiveGenericLifecycleObserver.onStateChanged里面执行mInfo.invokeCallbacks执行相应的方法
7.之所以要设计状态 是要留给其他框架用的