Android: 彻底搞懂Lifecycle

系列文章目录

第一章 Android: 彻底搞懂Lifecycle——使用篇

第二章 Android: 彻底搞懂Lifcycle——原理篇

文章目录

系列文章目录

前言

一、复杂原理——简单说

二、复杂原理——详细说

1. Lifecycle抽象类

2. 如何跟Activity/Fragment生命周期关联？

总结

前言

上一篇我们认识了Lifecycle，并且学会了它怎么用。本篇再深入了解下它的原理，你会明白它是怎么做到感知生命周期的？

创作此时的最新稳定版是：lifecycle-* 2.4.1

在这里插入图片描述

一、复杂原理——简单说

【一句话概括】

就是会向当前界面添加一个隐藏的fragment，由这个fragment来触发生命周期通知，然后观察者再做出具体的响应处理。

现在我们知道了思路，如需详细了解，咱们接着看源码。

二、复杂原理——详细说

1. Lifecycle抽象类

先看Lifecycle抽象类，下面是Lifecycle 2.4.1的源码：

lifecycle-common-2.4.1.jar—— androidx.lifecycle.Lifecycle.java;

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 State getCurrentState();

public enum Event {

ON_CREATE,

ON_START,

ON_RESUME,

ON_PAUSE,

ON_STOP,

ON_DESTROY,

ON_ANY;

public static Event downFrom(@NonNull State state) {}

public static Event downTo(@NonNull State state) {}

public static Event upFrom(@NonNull State state) {}

public static Event upTo(@NonNull State state) {}

public State getTargetState() {}

}

public enum State {

DESTROYED,

INITIALIZED,

CREATED,

STARTED,

RESUMED;

public boolean isAtLeast(@NonNull State state)

}

}

Lifecycle是个抽象类，里面有添加/移除观察者的方法，还有两个枚举类Event和State：

Event对应Activity/Fragment中的生命周期回调事件，其中ON_ANY适用于匹配所有的事件；

State是所处的生命周期状态。

除此之外其他方法如downFrom()，upTo()这些是辅助状态和事件对应切换的工具方法。

下面是Event和State的关系图：

在这里插入图片描述

2. 如何跟Activity/Fragment生命周期关联？

【疑问】那么它是如何跟Activity/Fragment生命周期关联的呢？

在支持库 26.1.0 及更高版本中的 Fragment 和 Activity 已实现 LifecycleOwner 接口。已经是一个拥有生命周期的被观察者了。

可以在AppCompatActivity——>FragmentActivity——>ComponentActivity——>androidx.core.app.ComponentActivity中找到实现。

androidx.core:core:1.8.0-alpha06——androidx.core.app.ComponentActivity.java

@RestrictTo(LIBRARY_GROUP_PREFIX)

public class ComponentActivity extends Activity implements LifecycleOwner{

private LifecycleRegistry mLifecycleRegistry = new LifecycleRegistry(this);// [1]

@SuppressLint("RestrictedApi")

@Override

protected void onCreate(@Nullable Bundle savedInstanceState) {

super.onCreate(savedInstanceState);

ReportFragment.injectIfNeededIn(this);// [2]

}

@CallSuper

@Override

protected void onSaveInstanceState(@NonNull Bundle outState) {

mLifecycleRegistry.markState(Lifecycle.State.CREATED);// [3]

super.onSaveInstanceState(outState);

}

@NonNull

@Override

public Lifecycle getLifecycle() {

return mLifecycleRegistry;// [4]

}

}

注释[1]，创建了LifecycleRegistry, 上篇我们学过如何让自定义的类实现LifecycleOwner接口，而它是 Lifecycle 的实现类。

[4]，实现了LifecycleOwner的getLifecycle方法。

[3]，设置Lifecycle状态为CREATED。这里注意到ComponentActivity并没有在各个生命周期方法中来改变 Lifecycle 的 State。

【疑问】那状态怎么改变？

其实是交给了ReportFragment来处理。

[2]，这里看到将 ComponentActivity 注入到了 ReportFragment 中。我们再看看它源码。

androidx.lifecycle:lifecycle-runtime:2.4.1——androidx.lifecycle.ReportFragment.java

public class ReportFragment extends android.app.Fragment {

public static void injectIfNeededIn(Activity activity) {

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

LifecycleCallbacks.registerIn(activity);// [1]

}

android.app.FragmentManager manager = activity.getFragmentManager();

if (manager.findFragmentByTag(REPORT_FRAGMENT_TAG) == null) {

manager.beginTransaction().add(new ReportFragment(), REPORT_FRAGMENT_TAG).commit();// [2]

manager.executePendingTransactions();

}

}

// [3]

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

if (activity instanceof LifecycleRegistryOwner) {

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

return;

}

if (activity instanceof LifecycleOwner) {

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

if (lifecycle instanceof LifecycleRegistry) {

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

}

}

}

@Override

public void onActivityCreated(Bundle savedInstanceState) {

super.onActivityCreated(savedInstanceState);

dispatchCreate(mProcessListener);

dispatch(Lifecycle.Event.ON_CREATE);// [4]

}

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

}

...

@RequiresApi(29)

static class LifecycleCallbacks implements Application.ActivityLifecycleCallbacks {

...

}

}

[4]，可以看到各个生命周期方法中都调用了dispatch方法，并传递了Event事件。

[3]，dispatch方法主要负责获取Lifecycle，调用handleLifecycleEvent方法来处理生命周期Event事件。

[2]，这里将ReportFragment添加进了当前Activity，由于ReportFragment是无界面的，所以对于用户是看不见的；

[1]，在SDK29以上注册了LifecycleCallbacks回调，LifecycleCallbacks是Application.ActivityLifecycleCallbacks的实现类，这是29以上才有的api, 在ReportFragment中主要做的任务也是调用dispatch方法，分发生命周期事件。

androidx.lifecycle:lifecycle-runtime:2.4.1——androidx.lifecycle.LifecycleRegistry.java

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

enforceMainThreadIfNeeded("handleLifecycleEvent");

moveToState(event.getTargetState());

}

首先验证了下是否在主线程，event.getTargetState()获取此事件的状态，然后传递给moveToState方法，改变状态。

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

}

这里的状态变化可以参考开头的关系时序图。

private void moveToState(State next) {

if (mState == next) {

return;

}

mState = next;

if (mHandlingEvent || mAddingObserverCounter != 0) {

mNewEventOccurred = true;

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;

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;

}

moveToState方法：先判断与当前状态是否一致，不一致则调用sync方法改变状态；

sync 方法中会根据当前状态判断是向前还是向后。

【疑问】怎样是向前？怎样是向后呢？

我们可以对照开头的Lifecycle时序图，状态由INITIALIZED——>到RESUMED 是向前，反之就是向后。

向前和向后的代码实现差不多，这里就以向前为例：

private void backwardPass(LifecycleOwner lifecycleOwner) {

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

mObserverMap.descendingIterator();

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

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

ObserverWithState observer = entry.getValue();

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

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

Event event = Event.downFrom(observer.mState);// [1]

if (event == null) {

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

}

pushParentState(event.getTargetState());

observer.dispatchEvent(lifecycleOwner, event);

popParentState();// [2]

}

}

}

[1]，获取了当前状态的下个event事件。

[2]，事件会传给ObserverWithState（状态观察者）对象的dispatchEvent方法来分发。

ObserverWithState是LifecycleRegistry的内部类。

static class ObserverWithState {

State mState;

LifecycleEventObserver mLifecycleObserver;

ObserverWithState(LifecycleObserver observer, State initialState) {

mLifecycleObserver = Lifecycling.lifecycleEventObserver(observer);// [1]

mState = initialState;

}

void dispatchEvent(LifecycleOwner owner, Event event) {

State newState = event.getTargetState();

mState = min(mState, newState);

mLifecycleObserver.onStateChanged(owner, event);// [2]

mState = newState;

}

}

[2]，主要是这里，调用观察者的onStateChanged方法。

[1],可以看到mLifecycleObserver会在ObserverWithState构造方法实例化。通过调用Lifecycling.lifecycleEventObserver方法获取LifecycleEventObserver实例；

而ObserverWithState的实例化是在调用addObserver方法添加观察者的时候自动创建的。

androidx.lifecycle.Lifecycling.java

public class 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;

}

...

}

}

此方法通过判断观察者类型来转换对应的观察者适配器；

还记得上篇中，我们继承DefaultLifecycleObserver来自定义观察者类吗， DefaultLifecycleObserver的父类就是FullLifecycleObserver， 现在我们主要看下FullLifecycleObserverAdapter适配器怎么实现的。

androidx.lifecycle.FullLifecycleObserverAdapter.java

class FullLifecycleObserverAdapter implements LifecycleEventObserver {

private final FullLifecycleObserver mFullLifecycleObserver;

private final LifecycleEventObserver mLifecycleEventObserver;

FullLifecycleObserverAdapter(FullLifecycleObserver fullLifecycleObserver,

LifecycleEventObserver lifecycleEventObserver) {

mFullLifecycleObserver = fullLifecycleObserver;

mLifecycleEventObserver = lifecycleEventObserver;

}

@Override

public void onStateChanged(@NonNull LifecycleOwner source, @NonNull Lifecycle.Event event) {

switch (event) {

case ON_CREATE:

mFullLifecycleObserver.onCreate(source);

break;

case ON_START:

mFullLifecycleObserver.onStart(source);

break;

case ON_RESUME:

mFullLifecycleObserver.onResume(source);

break;

case ON_PAUSE:

mFullLifecycleObserver.onPause(source);

break;

case ON_STOP:

mFullLifecycleObserver.onStop(source);

break;

case ON_DESTROY:

mFullLifecycleObserver.onDestroy(source);

break;

case ON_ANY:

throw new IllegalArgumentException("ON_ANY must not been send by anybody");

}

if (mLifecycleEventObserver != null) {

mLifecycleEventObserver.onStateChanged(source, event);

}

}

}

在onStateChanged中判断事件类型，直接调用了观察者的生命周期回调方法。

总结

简单吧，利用Fragment来分发状态，并计算出下一状态和事件后，经过适配器转换找到观察者的生命周期回调方法。这是目前新版的原理。

在之前的版本中是利用注解找到观察者的事件对应回调方法，然后通过反射进行调用的。现在新版中已经弃用了。

最后，官方是强烈推荐使用DefaultLifecycleObserver来代替@OnLifecycleEvent注解方式的。

【思考🤔】你知道使用“Fragment来观察生命周期”这种方式的，还有哪些知名第三方库吗？