首先们要明确Lifecycle中两个枚举值，这两个枚举值和生命周期的状态有着直接关系，我们可以先记住，后面会看到使用的地方
public enum Event {
ON_CREATE,
ON_START,
ON_RESUME,
ON_PAUSE,
ON_STOP,
ON_DESTROY,
ON_ANY;
//与state的对应关系
public State getTargetState() {
switch (this) {
//这里看到ON_CREATE和ON_STOP都对应State.CREATED ，在回退生命周期的时候就会用到
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");
}
...
}
public enum State {
DESTROYED,
INITIALIZED,
CREATED,
STARTED,
RESUMED;
public boolean isAtLeast(@NonNull State state) {
return compareTo(state) >= 0;
}
}
下面我们先看下，我们日常开发中是如何使用Lifecycle来监听声明周期的，首先我们需要创建一个监听器
//实现LifecycleObserver接口
class MyLifecycleObserver : LifecycleObserver {
//必须声明对应生命周期的注解 才会回调对应方法 以下同理
@OnLifecycleEvent(Lifecycle.Event.ON_CREATE)
fun onCreate() {}
@OnLifecycleEvent(Lifecycle.Event.ON_START)
fun onStart() {}
@OnLifecycleEvent(Lifecycle.Event.ON_RESUME)
fun onResume() {}
@OnLifecycleEvent(Lifecycle.Event.ON_PAUSE)
fun onPause() {}
@OnLifecycleEvent(Lifecycle.Event.ON_STOP)
fun onStop() {}
@OnLifecycleEvent(Lifecycle.Event.ON_DESTROY)
fun onDestroy() {}
}
然后在Activity中通过以下代码添加监听
//Activity
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
val observer = MyLifecycleObserver()
lifecycle.addObserver(observer)
}
当Activity执行到相应的生命周期方法的时候就会回调监听中定义的方法。那具体的实现是怎么做到的呢？首先我们看下lifecycle，定义在ComponentActivity中
//持有了Activity对象
private final LifecycleRegistry mLifecycleRegistry = new LifecycleRegistry(this);
//enforceMainThread默认true
private LifecycleRegistry(@NonNull LifecycleOwner provider, boolean enforceMainThread) {
//Activity对象 用软引用存储
mLifecycleOwner = new WeakReference<>(provider);
mState = INITIALIZED;
mEnforceMainThread = enforceMainThread;
}
public Lifecycle getLifecycle() {
return mLifecycleRegistry;
}
我们发现lifecycle其实是一个LifecycleRegistry对象，addObserver调用的也是其中的方法，继续看代码
@Override
public void addObserver(@NonNull LifecycleObserver observer) {
//检查是否是主线程，也就是说我们添加监听只能在主线程中调用
enforceMainThreadIfNeeded("addObserver");
//初始状态INITIALIZED
State initialState = mState == DESTROYED ? DESTROYED : INITIALIZED;
//注意这个对象 可以把它看成一个监听对象
ObserverWithState statefulObserver = new ObserverWithState(observer, initialState);
//存储到mObserverMap中 因为可能存在多个监听 这里做处理
ObserverWithState previous = mObserverMap.putIfAbsent(observer, statefulObserver);
//如果注册过 直接返回
if (previous != null) {
return;
}
//如果Activity对象为null直接返回
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);
final Event event = Event.upFrom(statefulObserver.mState);
if (event == null) {
throw new IllegalStateException("no event up from " + statefulObserver.mState);
}
statefulObserver.dispatchEvent(lifecycleOwner, event);
popParentState();
// mState / subling may have been changed recalculate
targetState = calculateTargetState(observer);
}
if (!isReentrance) {
// we do sync only on the top level.
sync();
}
mAddingObserverCounter--;
}
下面看下ObserverWithState这个对象的初始化
ObserverWithState(LifecycleObserver observer, State initialState) {
mLifecycleObserver = Lifecycling.lifecycleEventObserver(observer);
mState = initialState;
}
继续Lifecycling
static LifecycleEventObserver lifecycleEventObserver(Object object) {
boolean isLifecycleEventObserver = object instanceof LifecycleEventObserver;
boolean isFullLifecycleObserver = object instanceof FullLifecycleObserver;
if (isLifecycleEventObserver && isFullLifecycleObserver) {
return new FullLifecycleObserverAdapter((FullLifecycleObserver) object,
(LifecycleEventObserver) object);
}
if (isFullLifecycleObserver) {
return new FullLifecycleObserverAdapter((FullLifecycleObserver) object, null);
}
if (isLifecycleEventObserver) {
return (LifecycleEventObserver) object;
}
//获取class对象
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);
}
继续看ReflectiveGenericLifecycleObserver
class ReflectiveGenericLifecycleObserver implements LifecycleEventObserver {
private final Object mWrapped;
private final CallbackInfo mInfo;
ReflectiveGenericLifecycleObserver(Object wrapped) {
mWrapped = wrapped;
//解析监听器对象信息(我们声明的对应生命周期注解的方法) 存储到mInfo中，具体解析流程不做分析 可自行查看源码
mInfo = ClassesInfoCache.sInstance.getInfo(mWrapped.getClass());
}
@Override
public void onStateChanged(@NonNull LifecycleOwner source, @NonNull Event event) {
//生命周期改变时候调用该方法 event为对应的生命周期
mInfo.invokeCallbacks(source, event, mWrapped);
}
}
目前为止做的工作就是，把我们声明的监听器的信息进行解析并存储了起来。
监听已经注册好了，那么下来就要看看当 生命周期发生改变的时候，是怎么进行分发的了，我们查看ComponentActivity的onCreate()
protected void onCreate(@Nullable Bundle savedInstanceState) {
// Restore the Saved State first so that it is available to
// OnContextAvailableListener instances
mSavedStateRegistryController.performRestore(savedInstanceState);
mContextAwareHelper.dispatchOnContextAvailable(this);
super.onCreate(savedInstanceState);
//关键点就是这里
ReportFragment.injectIfNeededIn(this);
if (mContentLayoutId != 0) {
setContentView(mContentLayoutId);
}
}
下面看ReportFragment
public static void injectIfNeededIn(Activity activity) {
//版本判断进行teshu 处理
if (Build.VERSION.SDK_INT >= 29) {
// On API 29+, we can register for the correct Lifecycle callbacks directly
LifecycleCallbacks.registerIn(activity);
}
// Prior to API 29 and to maintain compatibility with older versions of
// ProcessLifecycleOwner (which may not be updated when lifecycle-runtime is updated and
// need to support activities that don't extend from FragmentActivity from support lib),
// use a framework fragment to get the correct timing of Lifecycle events
//声明了一个没有UI页面的Fragment
android.app.FragmentManager manager = activity.getFragmentManager();
if (manager.findFragmentByTag(REPORT_FRAGMENT_TAG) == null) {
manager.beginTransaction().add(new ReportFragment(), REPORT_FRAGMENT_TAG).commit();
// Hopefully, we are the first to make a transaction.
manager.executePendingTransactions();
}
}
Glide大家应该都用过，对于生命周期的感知就是通过添加Fragment的方式来完成的,这里其实也是一样的,我们看下29及以后的处理
@RequiresApi(29)
static class LifecycleCallbacks implements Application.ActivityLifecycleCallbacks {
static void registerIn(Activity activity) {
//直接注册了回调 29以前应该是没有吧 没有去深究
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的具体实现
dispatch(activity, Lifecycle.Event.ON_CREATE);
}
@Override
public void onActivityStarted(@NonNull Activity activity) {
}
@Override
public void onActivityPostStarted(@NonNull Activity activity) {
dispatch(activity, Lifecycle.Event.ON_START);
}
@Override
public void onActivityResumed(@NonNull Activity activity) {
}
@Override
public void onActivityPostResumed(@NonNull Activity activity) {
dispatch(activity, Lifecycle.Event.ON_RESUME);
}
@Override
public void onActivityPrePaused(@NonNull Activity activity) {
dispatch(activity, Lifecycle.Event.ON_PAUSE);
}
@Override
public void onActivityPaused(@NonNull Activity activity) {
}
@Override
public void onActivityPreStopped(@NonNull Activity activity) {
dispatch(activity, Lifecycle.Event.ON_STOP);
}
@Override
public void onActivityStopped(@NonNull Activity activity) {
}
@Override
public void onActivitySaveInstanceState(@NonNull Activity activity,
@NonNull Bundle bundle) {
}
@Override
public void onActivityPreDestroyed(@NonNull Activity activity) {
dispatch(activity, Lifecycle.Event.ON_DESTROY);
}
@Override
public void onActivityDestroyed(@NonNull Activity activity) {
}
}
既然是通过Fragment进行分发，那么显然我们直接看ReportFragment的生命周期就好了，我们以onResume为例，其余都是一样的处理。
public void onResume() {
super.onResume();
dispatchResume(mProcessListener);
//上面我们看29及之后的处理的时候 也看到该方法的调用了，这就是分发的方法，参数是对应的生命周期枚举
dispatch(Lifecycle.Event.ON_RESUME);
}
下面看下diapatch的实现
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);
}
}
static void dispatch(@NonNull Activity activity, @NonNull Lifecycle.Event event) {
//这里已经弃用 我们不用关心
if (activity instanceof LifecycleRegistryOwner) {
((LifecycleRegistryOwner) activity).getLifecycle().handleLifecycleEvent(event);
return;
}
if (activity instanceof LifecycleOwner) {
//获取LifecycleRegistry对象 我们上面添加监听的时候就是通过LifecycleRegistry添加的
Lifecycle lifecycle = ((LifecycleOwner) activity).getLifecycle();
if (lifecycle instanceof LifecycleRegistry) {
((LifecycleRegistry) lifecycle).handleLifecycleEvent(event);
}
}
}
然后我们看LifecycleRegistry的handleLifecycleEvent方法
public void handleLifecycleEvent(@NonNull Lifecycle.Event event) {
//主线程判断
enforceMainThreadIfNeeded("handleLifecycleEvent");
//注意这里这里是根据Event来判断当前state状态的 这里可以看最开始我们提到的枚举值
moveToState(event.getTargetState());
}
//生命周期状态的处理
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;
}
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.
//如果当前状态值小于监听器状态值 则说明是销毁流程
//比如我们目前是onResume 走到了onPause State.STARTED < State.RESUMED
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;
}
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是ObserverWithState对象 我们上面注册时候 注册的就是这个
observer.dispatchEvent(lifecycleOwner, event);
popParentState();
}
}
}
然后我们再看下ObserverWithState
static class ObserverWithState {
State mState;
LifecycleEventObserver mLifecycleObserver;
ObserverWithState(LifecycleObserver observer, State initialState) {
//ReflectiveGenericLifecycleObserver 对象上面注册时候说过
mLifecycleObserver = Lifecycling.lifecycleEventObserver(observer);
mState = initialState;
}
void dispatchEvent(LifecycleOwner owner, Event event) {
State newState = event.getTargetState();
mState = min(mState, newState);
mLifecycleObserver.onStateChanged(owner, event);
mState = newState;
}
}
然后看ReflectiveGenericLifecycleObserver
@Override
public void onStateChanged(@NonNull LifecycleOwner source, @NonNull Event event) {
//上面说过mInfo 存储了监听器的信息 我们解析的注解方法都在这里
mInfo.invokeCallbacks(source, event, mWrapped);
}
继续看CallbackInfo
void invokeCallbacks(LifecycleOwner source, Lifecycle.Event event, Object target) {
//event 通过Event找到对应的方法
invokeMethodsForEvent(mEventToHandlers.get(event), source, event, target);
invokeMethodsForEvent(mEventToHandlers.get(Lifecycle.Event.ON_ANY), source, event,
target);
}
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);
}
}
}
到这里我们就已经分析完Lifecycle生命周期的分发流程了，总结一下其实很简单:
解析监听器中声明的对应生命周期的注解方法存储起来，在Activity生命周期改变的时候获取对应的注解方法进行调用。
细节点
- 生命周期分发
29以前是通过添加空的Frgament，然后在Fragment中进行分发；
29之后是通过LifecycleCallbacks直接进行分发。 - State判断
不同的Event枚举对应相同的State值,在onResume后复用之前的状态来节省判断变量，达到生命周期正序和逆序的处理。
可能有些细节没有讲到，但是整体的思路和处理应该很清晰，如有哪里讲的不对，请留言。
网友评论