本文讲解 Lifecycle 用法，以及 Lifecycle 源码解析。
官方文档：https://developer.android.google.cn/topic/libraries/architecture/lifecycle
一句话介绍 Lifecycle ：使用生命周期感知型组件处理生命周期。
Google 推出的 Lifecycle 为 Activity 和 Fragment 的生命周期做了一个很好的工具，去观测他们的生命周期。让生命周期的这部分逻辑代码不用写在 Activity 或 Fragment 的类里。避免过多的代码量和耦合性。
注：本文使用 Kotlin 编写。
导入 Lifecycle 库：implementation "androidx.lifecycle:lifecycle-runtime-ktx:2.2.0"
一、用法
1. 自定义生命周期观察者
class MainObserver : LifecycleObserver {
val TAG = "MainObserver"
@OnLifecycleEvent(Lifecycle.Event.ON_CREATE)
fun create() {
Log.d(TAG, "onCreate")
}
@OnLifecycleEvent(Lifecycle.Event.ON_START)
fun start() {
Log.d(TAG, "onStart")
}
@OnLifecycleEvent(Lifecycle.Event.ON_RESUME)
fun resume() {
Log.d(TAG, "onResume")
}
@OnLifecycleEvent(Lifecycle.Event.ON_PAUSE)
fun pause() {
Log.d(TAG, "onPause")
}
@OnLifecycleEvent(Lifecycle.Event.ON_STOP)
fun stop() {
Log.d(TAG, "onStop")
}
@OnLifecycleEvent(Lifecycle.Event.ON_DESTROY)
fun destroy() {
Log.d(TAG, "onDestroy")
}
}2. 在 Activity 里获取 Lifecycle 实例
class MainActivity : AppCompatActivity() {
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
setContentView(R.layout.activity_main)
val observer = MainObserver()
lifecycle.addObserver(observer)
}
}3. 查看 Log 日志
app 启动
D/MainObserver: onCreate
D/MainObserver: onStart
D/MainObserver: onResume手机锁屏
D/MainObserver: onPause
D/MainObserver: onStop二、源码解析
Lifecycle 源码
public abstract class Lifecycle {
@RestrictTo(RestrictTo.Scope.LIBRARY_GROUP)
@NonNull
AtomicReference<Object> mInternalScopeRef = new AtomicReference<>();
// 添加观察者
@MainThread
public abstract void addObserver(@NonNull LifecycleObserver observer);
// 移除观察者
@MainThread
public abstract void removeObserver(@NonNull LifecycleObserver observer);
@MainThread
@NonNull
public abstract androidx.lifecycle.Lifecycle.State getCurrentState();
// Activity 或 Fragment 生命周期的事件
@SuppressWarnings("WeakerAccess")
public enum Event {
ON_CREATE,
ON_START,
ON_RESUME,
ON_PAUSE,
ON_STOP,
ON_DESTROY,
ON_ANY
}
// Activity 或 Fragment 生命周期的状态
@SuppressWarnings("WeakerAccess")
public enum State {
DESTROYED,
INITIALIZED,
CREATED,
STARTED,
RESUMED;
public boolean isAtLeast(@NonNull androidx.lifecycle.Lifecycle.State state) {
return compareTo(state) >= 0;
}
}
}
从 Lifecycle 这个类中可以发现：生命周期代表了 Activity 或 Fragment 的生命周期。他一定是通过 Lifecycle 这个类衍生出来一些方法，让 Activity 或 Fragment 把它的生命周期通过事件和改变状态通知到它的观察者中。
Lifecycle 组件会有一个观察者，官方定义为 LifecycleEventObserver ，他会观察他所对应的生命周期事件，通过 addObserver 添加到 LifecycleOwner ，LifecycleOwner 中存在一个 Lifecycle 对象，Lifecycle 对象会把它自身的 Event 和 State 通过特定的观察去遍历去通知所有 add 进来的观察者，实现了 LifecyOwner 的类在 ComponentActivity 。LifecycleOwner 包含 Activity 和 Fragment ，他可以通过 Lifecycle 向外部传递事件，外部的东西不用写到 Activity 或 Fragment 里面的生命周期回调里，就可以感知到 Activity 或 Fragment 的生命周期了。
以 getLifecycle().addObserver() 为入口，探索源码实现。
（注：Kotlin 里面 getLifecycle() 为 lifecycle ）
@MainThread
public abstract void addObserver(@NonNull LifecycleObserver observer);@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--;
}这是一个抽象方法，会有一个初始状态 initialState ，给的是 INITIALIZED 。就把这个 observer ，也就是表示层，进行了一个包装 ObserverWithState statefulObserver = new ObserverWithState() 。包装好以后把 statefulObserver 存到 mObserverMap 里面，这个 Map 里面就有我们的表示层和它的相关信息。所以前期在初始化的时候这个数据会被保存下来。所以 getLifecycle().addObserver() 就完成了一个保存动作。
那么整个流程是如何做到的？
看 AppCompatActivity 的父类 ComponentActivity ，
public class ComponentActivity extends androidx.core.app.ComponentActivity implements LifecycleOwner,
ViewModelStoreOwner,
SavedStateRegistryOwner,
OnBackPressedDispatcherOwner {}它实现了一个 Lifecycle 接口，在 onCreate 方法里：
@Override
protected void onCreate(@Nullable Bundle savedInstanceState) {
...
ReportFragment.injectIfNeededIn(this);
...
}执行了 ReportFragment.injectIfNeededIn 方法，把当前的 Activity 传进去。
public static void injectIfNeededIn(Activity 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();
}
}在当前 Activity 上面添加了一个叫做 ReportFragment 的 空 Fragemnt 。
在 ReportFragment 里面，查看和生命周期相关的代码：
@Override
public void onStart() {
...
dispatch(Lifecycle.Event.ON_START);
}
@Override
public void onResume() {
...
dispatch(Lifecycle.Event.ON_RESUME);
}
@Override
public void onPause() {
...
dispatch(Lifecycle.Event.ON_PAUSE);
}
@Override
public void onStop() {
...
dispatch(Lifecycle.Event.ON_STOP);
}
@Override
public void onDestroy() {
...
dispatch(Lifecycle.Event.ON_DESTROY);
...
}都有一个共同的特点，就是执行 dispatch 分发。并且会传递一个 Event 进去。
static void dispatch(@NonNull Activity activity, @NonNull Lifecycle.Event event) {
...
if (activity instanceof LifecycleOwner) {
Lifecycle lifecycle = ((LifecycleOwner) activity).getLifecycle();
if (lifecycle instanceof LifecycleRegistry) { ((LifecycleRegistry) lifecycle).handleLifecycleEvent(event);
}
}
}在 dispatch 方法里，会先判断是不是 LifecycleOwner 的接口。刚才包装以后实际上是一个 LifecycleRegistry ，它会执行 handleLifecycleEvent ：
public void handleLifecycleEvent(@NonNull Lifecycle.Event event) {
State next = getStateAfter(event);
moveToState(next);
}先进到 getStateAfter 方法里：
static State getStateAfter(Event event) {
switch (event) {
case ON_CREATE:
case ON_STOP:
return CREATED;
case ON_START:
case ON_PAUSE:
return STARTED;
case ON_RESUME:
return RESUMED;
case ON_DESTROY:
return DESTROYED;
case ON_ANY:
break;
}
throw new IllegalArgumentException("Unexpected event value " + event);
}这一段是 Lifecycle 的精华！和官方文档的图相呼应：
蓝色方框里是代码 return 的那行，带箭头的是代码 case 那行。它能够保存当前的一个状态信息。也就是说 Activity 每次执行完它的生命周期之后，表示层会记录一个状态信息。通过这个状态信息就知道当前的状态。Activity 在状态变化的同时，对应的观察者会记录一下状态。
再进到 moveToState 方法里：
private void moveToState(State next) {
...
sync();
...
}执行同步。
private void sync() {
...
while (!isSynced()) {
...
if (mState.compareTo(mObserverMap.eldest().getValue().mState) < 0) {
backwardPass(lifecycleOwner);
}
...
if (!mNewEventOccurred && newest != null && mState.compareTo(newest.getValue().mState) > 0) {
forwardPass(lifecycleOwner);
}
}
...
}他会有一个 正推（forwardPass）和 反推（backwardPass）。也可以看上面那那张官方图表去理解。目的是保证 Activity 和 观察者之间状态信息同步。
以 正推 （forwardPass）举例：
private void forwardPass(LifecycleOwner lifecycleOwner) {
// Map 是初始化的时候保存的
// 先从 Map 里面把数据取出来
Iterator < Entry < LifecycleObserver,
ObserverWithState >> ascendingIterator = mObserverMap.iteratorWithAdditions();
while (ascendingIterator.hasNext() && !mNewEventOccurred) {
Entry < LifecycleObserver,
ObserverWithState > entry = ascendingIterator.next();
// observer 就是我们的观察者这个类
ObserverWithState observer = entry.getValue();
// 状态的比较
while ((observer.mState.compareTo(mState) < 0 && !mNewEventOccurred && mObserverMap.contains(entry.getKey()))) {
pushParentState(observer.mState);
// 分发（会把观察者存下来的状态传下去）
observer.dispatchEvent(lifecycleOwner, upEvent(observer.mState));
popParentState();
}
}
}void dispatchEvent(LifecycleOwner owner, Event event) {
State newState = getStateAfter(event);
mState = min(mState, newState);
mLifecycleObserver.onStateChanged(owner, event);
mState = newState;
}public interface LifecycleEventObserver extends LifecycleObserver {
void onStateChanged(@NonNull LifecycleOwner source, @NonNull Lifecycle.Event event);
}会进到 ReflectiveGenericLifecycleObserver 这个类里。
class ReflectiveGenericLifecycleObserver implements LifecycleEventObserver {
private final Object mWrapped;
private final CallbackInfo mInfo;
// wrapped 就是观察者
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);
}
}先进到 getInfo 方法里：
CallbackInfo getInfo(Class < ?>klass) {
CallbackInfo existing = mCallbackMap.get(klass);
if (existing != null) {
return existing;
}
existing = createInfo(klass, null);
return existing;
}private CallbackInfo createInfo(Class < ?>klass, @Nullable Method[] declaredMethods) {
...
Method[] methods = declaredMethods != null ? declaredMethods: getDeclaredMethods(klass);
...
for (Method method: methods) {
OnLifecycleEvent annotation = method.getAnnotation(OnLifecycleEvent.class);
if (annotation == null) {
continue;
}
...
Class < ?>[] params = method.getParameterTypes();
...
if (params.length > 0) {
...
}
...
if (params.length > 1) {
...
}
if (params.length > 2) {
...
}
...
}
CallbackInfo info = new CallbackInfo(handlerToEvent);
mCallbackMap.put(klass, info);
mHasLifecycleMethods.put(klass, hasLifecycleMethods);
return info;
}这个 method 数组中就已经把表示层我们要用的所有方法的反射的对象全部存下来了。也就是你用的哪个观察者，观察者里所有的方法都存在了数组里。然后取方法上有没有我们刚刚写的注解 OnLifecycleEvent ，也就是说通过注解反射判断的，如果不带注解的就不理会，带注解的继续往下执行去处理参数。0，1，2，也就限制了参数只有3个以内。最后把信息保存下来返回。
再回到 ReflectiveGenericLifecycleObserver ，当前 mInfo 就已经有信息了，执行 onStateChanged 方法，进入到 invokeCallbacks 里：
void invokeCallbacks(LifecycleOwner source, Lifecycle.Event event, Object target) {
invokeMethodsForEvent(mEventToHandlers.get(event), source, event, target);
invokeMethodsForEvent(mEventToHandlers.get(Lifecycle.Event.ON_ANY), source, event, target);
}在进入到 invokeMethodsForEvent 里：
private static void invokeMethodsForEvent(List < MethodReference > handlers, LifecycleOwner source, Lifecycle.Event event, Object mWrapped) {
if (handlers != null) {
for (int i = handlers.size() - 1; i >= 0; i--) {
handlers.get(i).invokeCallback(source, event, mWrapped);
}
}
}在进到 invokeCallback 里：
void invokeCallback(LifecycleOwner source, Lifecycle.Event event, Object target) {
try {
switch (mCallType) {
case CALL_TYPE_NO_ARG:
mMethod.invoke(target);
break;
case CALL_TYPE_PROVIDER:
mMethod.invoke(target, source);
break;
case CALL_TYPE_PROVIDER_WITH_EVENT:
mMethod.invoke(target, source, event);
break;
}
} catch(InvocationTargetException e) {
throw new RuntimeException("Failed to call observer method", e.getCause());
} catch(IllegalAccessException e) {
throw new RuntimeException(e);
}
}使用 method 的 invoke 形式，一旦 invoke 就直接通过反射调用到了我们写的 onCreate 等。
所以设计原理就是：通过反射去找你写的方法里面是否有我需要的注解，如果有，就通过 invoke 去执行你的代码。通过这种注解+反射的形式，在 Activity 里面就不需要去直接存储相关对象。一是可以解耦，二是不会发生内存泄漏。
如果本文对你有帮助，请点赞支持！！！