- Lifecycle作用和优势
- Lifecycle几种使用方法
- 导入依赖
- 基本用法
- 使用DefaultLifecycleObserver用法
- 再封装一层接口的用法
- 源码分析
- 第一步建立联系
- 第二步生命周期方法调用
Lifecycle是生命周期感知组件，能够监听Activity/Fragment生命周期行为的各种变化
可以在Activity/Fragment外处理声明周期相关业务，实现解耦
可以有效的避免内存泄漏
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 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来执行我们相应的方法，也就实现了生命周期的感应。
