3.1 Lifecycle 的生命周期状态事件和状态

---

Lifecyce 使用 两个枚举 来跟踪其关联组件的生命周期状态， 它们分别是： Event 和 Status。

• State 代表 Lifecycle 的生命周期所处的状态

• Event 代表 Lifecycle 生命周期对应的事件

这些事件会映射到 Activity 和 Fragment的回调事件中。

来看下 Lifecycle 的部分源码：

public abstract class Lifecycle {

public abstract void addObserver(@NonNull LifecycleObserver observer);

public abstract void removeObserver(@NonNull LifecycleObserver observer);

@SuppressWarnings(“WeakerAccess”)

public enum Event {

ON_CREATE,

ON_START,

ON_RESUME,

ON_PAUSE,

ON_STOP,

ON_DESTROY,

ON_ANY;

…

}

public enum State {

DESTROYED,

INITIALIZED,

CREATED,

STARTED,

RESUMED;

public boolean isAtLeast(@NonNull State state) {

return compareTo(state) >= 0;

}

}

}

Lifecycle 是一个抽象类，提供了 add 和 remove 观察者的方法，还定义了 Event 和 Status 两个枚举。

可以看到 Event 中的事件和 Activity 的生命周期几乎是对应的，还有一个 ON_ANY，和它名字一样，用来匹配所有的事件。

Status 与 Events 的关系如下图所示：

3.2 Lifecycle 是如何观察生命周期的

---

因为 MainActivity 继承了 ComponentActivity，它实现了 Lifecycler接口，所以我们可以看看它是如何实现该接口的。下面是一个调用链时序图：

// ComponentActivity.java

public class ComponentActivity extends androidx.core.app.ComponentActivity implements

LifecycleOwner, … {

// 1

private final LifecycleRegistry mLifecycleRegistry = new LifecycleRegistry(this);

@Override

protected void onCreate(@Nullable Bundle savedInstanceState) {

…

// 2

ReportFragment.injectIfNeededIn(this);

}

@Override

protected void onSaveInstanceState(@NonNull Bundle outState) {

// 3

Lifecycle lifecycle = getLifecycle();

if (lifecycle instanceof LifecycleRegistry) {

((LifecycleRegistry) lifecycle).setCurrentState(Lifecycle.State.CREATED);

}

…

}

@Override

public Lifecycle getLifecycle() {

// 4

return mLifecycleRegistry;

}

}

注释1：创建了 LifecycleRegistry， 它是 Lifecycle 的实现类。 注释4实现接口方法，并返回了这个实例。

注释3： 在 onSaveInstanceState() 方法中， 使用 LifecycleRegistry 标记当前的 State 为 CREATED。

正常来说，ComponentActivity 会在每个生命周期方法中，都会去标记下State，但是我们发现它并没有这样做。 而是交给了 注释2中的 ReportFragment 来处理。

注释2：将 ComponentActivity 注入到 ReportFragment 中：

// ReportFragment.java

public class ReportFragment extends android.app.Fragment {

public static void injectIfNeededIn(Activity activity) {

if (Build.VERSION.SDK_INT >= 29) {

LifecycleCallbacks.registerIn(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();

}

}

static ReportFragment get(Activity activity) {

return (ReportFragment) activity.getFragmentManager().findFragmentByTag(

REPORT_FRAGMENT_TAG);

}

@Override

public void onActivityCreated(Bundle savedInstanceState) {

super.onActivityCreated(savedInstanceState);

dispatchCreate(mProcessListener);

dispatch(Lifecycle.Event.ON_CREATE);

}

@Override

public void onStart() {

super.onStart();

dispatchStart(mProcessListener);

// 1

dispatch(Lifecycle.Event.ON_START);

}

@Override

public void onResume() {

super.onResume();

dispatchResume(mProcessListener);

dispatch(Lifecycle.Event.ON_RESUME);

}

@Override

public void onPause() {

super.onPause();

dispatch(Lifecycle.Event.ON_PAUSE);

}

@Override

public void onStop() {

super.onStop();

dispatch(Lifecycle.Event.ON_STOP);

}

@Override

public void onDestroy() {

super.onDestroy();

dispatch(Lifecycle.Event.ON_DESTROY);

mProcessListener = null;

}

private void dispatch(@NonNull Lifecycle.Event event) {

if (Build.VERSION.SDK_INT < 29) {

dispatch(getActivity(), event);

}

}

void setProcessListener(ActivityInitializationListener processListener) {

mProcessListener = processListener;

}

interface ActivityInitializationListener {

void onCreate();

void onStart();

void onResume();

}

static void dispatch(@NonNull Activity activity, @NonNull Lifecycle.Event event) {

// 2

if (activity instanceof LifecycleRegistryOwner) {

((LifecycleRegistryOwner) activity).getLifecycle().handleLifecycleEvent(event);

return;

}

// 3

if (activity instanceof LifecycleOwner) {

Lifecycle lifecycle = ((LifecycleOwner) activity).getLifecycle();

if (lifecycle instanceof LifecycleRegistry) {

((LifecycleRegistry) lifecycle).handleLifecycleEvent(event);

}

}

}

…

}

ReportFragment 的 onStart() 方法中会调用注释 1 处的 dispatch()。

该方法中，注释2处：判断 Activity 是否实现了 LifecycleRegistryOwner 接口。该接口和 LifecyclerOwner 的不同之处，就是前者 getLifecycle() 返回的是 LifecycleRegistry 实例，后者返回的是 Lifecycle实例。

注释3： 如果 Activity 继承了 LifecycleOwner 接口，则调用 LifecycleRegistry 的 handleLifecycleEvent() 方法，也就是说 注释2 和 3 所做的事情是一样的。

来看看 handleLifecycleEvent() 方法：

public void handleLifecycleEvent(@NonNull Lifecycle.Event event) {、

moveToState(event.getTargetState());

}

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");

}

它会调用 Event getTargetState() 方法，来获取当前Event所映射的State。这个和上面的映射表一致。

接着调用 moveToState():

private void moveToState(State next) {

if (mState == next) {

return;

}

mState = next;

if (mHandlingEvent || mAddingObserverCounter != 0) {

mNewEventOccurred = true;

return;

}

mHandlingEvent = true;

sync();

mHandlingEvent = false;

}

这里主要是调用了 sync() 方法：

private void sync() {

LifecycleOwner lifecycleOwner = mLifecycleOwner.get();

…

while (!isSynced()) {

mNewEventOccurred = false;

// 当前状态 - 最早的状态<0 ，表明当前状态是向后的

if (mState.compareTo(mObserverMap.eldest().getValue().mState) < 0) {

backwardPass(lifecycleOwner);

}

// 当前状态 - 最新的状态>0 ，表明当前状态是向前的

Map.Entry<LifecycleObserver, ObserverWithState> newest = mObserverMap.newest();

if (!mNewEventOccurred && newest != null

&& mState.compareTo(newest.getValue().mState) > 0) {

forwardPass(lifecycleOwner);

}

}

mNewEventOccurred = false;

}

sync() 方法会根据当前状态和 mObserverMap 中的 eldest 和 newest 的状态进行对比，判断当前的状态是向前的还是向后的。 比如 STARTED -> RESUMED 是状态向前，反过来是向后的。

无论向前还是向后，代码都是差不多的，这里以 backwardPass() 为例：

private void backwardPass(LifecycleOwner lifecycleOwner) {

Iterator<Map.Entry<LifecycleObserver, ObserverWithState>> descendingIterator =

mObserverMap.descendingIterator();

while (descendingIterator.hasNext() && !mNewEventOccurred) {

Map.Entry<LifecycleObserver, ObserverWithState> entry = descendingIterator.next();

// 1

ObserverWithState observer = entry.getValue();

while ((observer.mState.compareTo(mState) > 0 && !mNewEventOccurred

&& mObserverMap.contains(entry.getKey()))) {

Event event = Event.downFrom(observer.mState);

if (event == null) {

throw new IllegalStateException("no event down from " + observer.mState);

}

pushParentState(event.getTargetState());

// 2

observer.dispatchEvent(lifecycleOwner, event);

popParentState();

}

}

}

注释1： 获取了 ObserverWithState 实例

注释2： 执行注释1实例的 dispatchEvent，传入的 event 代表的是当前状态的向后状态

来看看那 ObserverWithState.dispatchEvent():

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 = event.getTargetState();

mState = min(mState, newState);

mLifecycleObserver.onStateChanged(owner, event);

mState = newState;

}

}

该类包含了 State 和 LifecycleEventObserver，后者是一个接口，继承了 LifecycleObserver~

而 ReflectiveGenericLifecycleObserver 则是它的一个实现类，来看看它是如何实现的：

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) {

// 1

mInfo.invokeCallbacks(source, event, mWrapped);

}

}

注释1处会调用 CallbackInfo 的 invokeCallbacks()。这个就是执行回调咯。 所以我们要搞清楚 CallbackInfo 是如何创建出来的。

下面这个 createInfo() 方法用来创建 CallbackInfo的：

private CallbackInfo createInfo(Class<?> klass, @Nullable Method[] declaredMethods) {

Class<?> superclass = klass.getSuperclass();

Map<MethodReference, Lifecycle.Event> handlerToEvent = new HashMap<>();

…

Method[] methods = declaredMethods != null ? declaredMethods : getDeclaredMethods(klass);

boolean hasLifecycleMethods = false;

for (Method method : methods) {

// 1

OnLifecycleEvent annotation = method.getAnnotation(OnLifecycleEvent.class);

…

Lifecycle.Event event = annotation.value();

if (params.length > 1) {

callType = CALL_TYPE_PROVIDER_WITH_EVENT;

if (!params[1].isAssignableFrom(Lifecycle.Event.class)) {

throw new IllegalArgumentException(

“invalid parameter type. second arg must be an event”);

}

if (event != Lifecycle.Event.ON_ANY) {

throw new IllegalArgumentException(

“Second arg is supported only for ON_ANY value”);

}

}

if (params.length > 2) {

throw new IllegalArgumentException(“cannot have more than 2 params”);

}

// 3

MethodReference methodReference = new MethodReference(callType, method);

// 4

verifyAndPutHandler(handlerToEvent, methodReference, event, klass);

}

// 5

CallbackInfo info = new CallbackInfo(handlerToEvent);

mCallbackMap.put(klass, info);

mHasLifecycleMethods.put(klass, hasLifecycleMethods);

return info;

}

注释1： 遍历所有方法，获取其 OnLifecycleEvent 注解，这个注解正是实现 LifecycleObserver 接口时用到的。

注释2：获取该注解的值， 也就是在 @OnLifecycleEvent 中定义的事件

注释3： 创建一个 MethodReference 对象，其内部包括使用了该注解的方法。

}

if (event != Lifecycle.Event.ON_ANY) {

throw new IllegalArgumentException(

“Second arg is supported only for ON_ANY value”);

}

}

if (params.length > 2) {

throw new IllegalArgumentException(“cannot have more than 2 params”);

}

// 3

MethodReference methodReference = new MethodReference(callType, method);

// 4

verifyAndPutHandler(handlerToEvent, methodReference, event, klass);

}

// 5

CallbackInfo info = new CallbackInfo(handlerToEvent);

mCallbackMap.put(klass, info);

mHasLifecycleMethods.put(klass, hasLifecycleMethods);

return info;

}

注释1： 遍历所有方法，获取其 OnLifecycleEvent 注解，这个注解正是实现 LifecycleObserver 接口时用到的。

注释2：获取该注解的值， 也就是在 @OnLifecycleEvent 中定义的事件

注释3： 创建一个 MethodReference 对象，其内部包括使用了该注解的方法。