Lifecycle用法与源码分析
Lifecycle作用和优势
Lifecycle是生命周期感知组件,能够监听Activity/Fragment生命周期行为的各种变化
可以在Activity/Fragment外处理声明周期相关业务,实现解耦
可以有效的避免内存泄漏
Lifecycle几种使用方法
Lifecycle框架使用的是观察者模式,Activity/Fragment就是被观察者
导入依赖
implementation "androidx.lifecycle:lifecycle-runtime:2.0.0"
implementation "androidx.lifecycle:lifecycle-extensions:2.0.0"
//如果要使用DefaultLifecycleObserver必须导入此依赖
implementation "androidx.lifecycle:lifecycle-common-java8:2.0.0"
annotationProcessor "androidx.lifecycle:lifecycle-compiler:2.0.0"
基本用法
class LifecycleActivity : AppCompatActivity() {
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
lifecycle.addObserver(TestObserver())
}
}
class TestObserver : LifecycleObserver {
private val TAG = "TestObserver"
@OnLifecycleEvent(Lifecycle.Event.ON_CREATE)
fun onCreate() = Log.d(TAG, "onCreate")
@OnLifecycleEvent(Lifecycle.Event.ON_RESUME)
fun onResume() = Log.d(TAG, "onResume")
@OnLifecycleEvent(Lifecycle.Event.ON_PAUSE)
fun onPause() = Log.d(TAG, "onPause")
}
使用DefaultLifecycleObserver用法
class LifecycleActivity : AppCompatActivity() {
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
lifecycle.addObserver(TestObserver2())
}
}
class TestObserver2 : DefaultLifecycleObserver {
override fun onCreate(owner: LifecycleOwner) {
super.onCreate(owner)
}
override fun onResume(owner: LifecycleOwner) {
super.onResume(owner)
}
override fun onPause(owner: LifecycleOwner) {
super.onPause(owner)
}
}
再封装一层接口的用法
这种用法可以在P层直接使用生命周期方法,但是由于Lifecycle经常会和Jetpack全家桶一起使用,在使用ViewModel时,可能用不上这个。如果在mvp模式中单独使用Lifecycle,还是很好用的~
interface IPresenter : LifecycleObserver {
@OnLifecycleEvent(Lifecycle.Event.ON_CREATE)
fun onCreate()
@OnLifecycleEvent(Lifecycle.Event.ON_RESUME)
fun onResume()
@OnLifecycleEvent(Lifecycle.Event.ON_PAUSE)
fun onPause()
}
class LifecycleActivity : AppCompatActivity() {
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
lifecycle.addObserver(TestPresenter())
}
}
class TestPresenter : IPresenter {
private val TAG = "TestPresenter"
override fun onCreate() {
Log.d(TAG, "onCreate")
}
override fun onResume() {
Log.d(TAG, "onResume")
}
override fun onPause() {
Log.d(TAG, "onPause")
}
}
源码分析
既然是观察者模式,我们可以分两步来分析,第一步是观察者与被观察者如何建立联系,第二步是当被观察者的生命周期方法被调用时,观察者如何调用到对应的方法。
第一步建立联系
查看addObserver
方法,是在Lifecycle中的一个抽象方法,具体实现在子类LifecycleRegistry
中
@Override
public void addObserver(@NonNull LifecycleObserver observer) {
enforceMainThreadIfNeeded("addObserver");
State initialState = mState == DESTROYED ? DESTROYED : INITIALIZED;
ObserverWithState statefulObserver = new ObserverWithState(observer, initialState);
ObserverWithState previous = mObserverMap.putIfAbsent(observer, statefulObserver);
...
}
可以看到在创建ObserverWithState
类时,传入了observer
,也就是我们自己创建的观察者类,再保存在mObserverMap
中,这个Map在后续同步事件中会用到。我们先跟进ObserverWithState
看一下
ObserverWithState(LifecycleObserver observer, State initialState) {
mLifecycleObserver = Lifecycling.lifecycleEventObserver(observer);
mState = initialState;
}
可以看到这是LifecycleRegistry
的一个内部类,继续跟进lifecycleEventObserver
方法
@NonNull
static LifecycleEventObserver lifecycleEventObserver(Object object) {
...
return new ReflectiveGenericLifecycleObserver(object);
}
这里用Object
来接收我们传入的observer
,其实就是我们自己的观察者类,直接方法最后返回一个ReflectiveGenericLifecycleObserver
对象,继续跟进来看一下
ReflectiveGenericLifecycleObserver(Object wrapped) {
mWrapped = wrapped;
mInfo = ClassesInfoCache.sInstance.getInfo(mWrapped.getClass());
}
这里调用了getInfo
方法,传入的是我们的观察者的getClass
,看到getClass
,很自然的想到后面可能要用到反射了,我们继续跟进一下
CallbackInfo getInfo(Class<?> klass) {
CallbackInfo existing = mCallbackMap.get(klass);
if (existing != null) {
return existing;
}
existing = createInfo(klass, null);
return existing;
}
这里是一个判断,如果mCallbackMap
中已经存在CallbackInfo
,就直接返回,否则createInfo
,防止重复创建,提高性能。进入createInfo
方法查看
private CallbackInfo createInfo(Class<?> klass, @Nullable Method[] declaredMethods) {
...
Method[] methods = declaredMethods != null ? declaredMethods : getDeclaredMethods(klass);
boolean hasLifecycleMethods = false;
for (Method method : methods) {
OnLifecycleEvent annotation = method.getAnnotation(OnLifecycleEvent.class);
if (annotation == null) {
continue;
}
...
}
CallbackInfo info = new CallbackInfo(handlerToEvent);
mCallbackMap.put(klass, info);
mHasLifecycleMethods.put(klass, hasLifecycleMethods);
return info;
}
OK,到这里可以看出,最终是反射得到观察者中带有OnLifecycleEvent
注解的所有方法,到此为止,这条被观察者与观察者关联的线我们就看完了。其实就是通过反射得到观察者中所有带有OnLifecycleEvent
注解的方法,让被观察者持有这些方法,等到生命周期变化的时候去invoke对应的方法。
第二步生命周期方法调用
接下来我们看一下当Activity的生命周期发生变化的时候,观察者如果观测到并相应对应的方法的
首先通过查看Activity的父类,可以看到继承于ComponentActivity,实现了LifecycleOwner,所以Activity就是被观察者
public class ComponentActivity extends Activity implements
LifecycleOwner,
KeyEventDispatcher.Component {
...
}
在ComponentActivity的onCreate
方法中,我们看到ReportFragment.injectIfNeededIn(this)
方法
@Override
protected void onCreate(@Nullable Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
ReportFragment.injectIfNeededIn(this);
}
进入查看ReportFragment源码可以看到,Lifecycle是通过创建一个无布局的空Fragment附加在Activity,实现对Activity声明周期的监听。
在ReportFragment声明周期变化时,可以看到都调用了dispatch
方法,入参是一个枚举类型的event
@Override
public void onActivityCreated(Bundle savedInstanceState) {
super.onActivityCreated(savedInstanceState);
dispatchCreate(mProcessListener);
dispatch(Lifecycle.Event.ON_CREATE);
}
@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);
}
跟进以后,可以看到调用了handleLifecycleEvent
方法,最终会调用moveToState
,并传入一个event.getTargetState()
public void handleLifecycleEvent(@NonNull Lifecycle.Event event) {
enforceMainThreadIfNeeded("handleLifecycleEvent");
moveToState(event.getTargetState());
}
event.getTargetState()
返回的是一个枚举类型的状态,这里就是Lifecycle设计最核心的地方,这里要区分Lifecycle设计时的两种枚举:事件和状态。当被观察者发生生命周期改变的事件时,状态就会改变,这是由事件驱动状态的一种思想,这个状态被保存到mState
变量中,用于下次的比对。这个状态会变成什么,对照这张图来看就很清晰了
@NonNull
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");
}
继续跟进,我们可以看到最终调用了moveToState
中的sync()
方法
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;
}
这里是用过比较枚举大小来决定是前进流程还是后退流程,比较时用到了我们前面保存的mObserverMap
,循环是可以同时有多个观察者时可以全部观察到变化。
前进流程会调用Event.upFrom(observer.mState);
后退流程调用Event.downFrom(observer.mState);
来返回需要执行的事件,最终看到都会调用observer.dispatchEvent(lifecycleOwner, event);
来分发事件,我们跟进来看一下
void dispatchEvent(LifecycleOwner owner, Event event) {
State newState = event.getTargetState();
mState = min(mState, newState);
mLifecycleObserver.onStateChanged(owner, event);
mState = newState;
}
这里调用了onStateChanged
,并传入了LifecycleOwner
,也就是我们的被观察者-Activity,跟进后我们找到ReflectiveGenericLifecycleObserver
实现类
@Override
public void onStateChanged(@NonNull LifecycleOwner source, @NonNull Event event) {
mInfo.invokeCallbacks(source, event, mWrapped);
}
这里最终会调用invoke
来执行我们相应的方法,也就实现了生命周期的感应。