Android架构灵魂组件Lifecycle的生命周期机制详解_android lifecycleobserver(3)

最新推荐文章于 2024-04-30 07:29:20 发布

2401_83974783

最新推荐文章于 2024-04-30 07:29:20 发布

阅读量786

点赞数 27

分类专栏： 2024年程序员学习文章标签： android 架构

本文链接：https://blog.csdn.net/2401_83974783/article/details/137554272

版权

2024年程序员学习专栏收录该内容

250 篇文章 0 订阅

订阅专栏

// 3.计算出它应该到达的状态，也就是当前宿主的状态
State targetState = calculateTargetState(observer);
mAddingObserverCounter++;
// 4.在while()循环中，会让当前的观察者的状态从init状态前进到当前宿主的状态
//Observer的状态与targetState比较，如果小于0说明观察者的状态还没有到达targetState的状态
while ((statefulObserver.mState.compareTo(targetState) < 0
&& mObserverMap.contains(observer))) {
pushParentState(statefulObserver.mState);
// 5.让Observer的状态前进到targetState
final Event event = Event.upFrom(statefulObserver.mState);
// 6. 分发事件
statefulObserver.dispatchEvent(lifecycleOwner, event);
popParentState();
// 从新计算mState
targetState = calculateTargetState(observer);
}

if (!isReentrance) {
//同步状态
sync();
}
}

在 addObserver(observer) 里面，初始化状态，并且把observer封装成一个ObserverWithState，一个拥有宿主状态的观察者，然后添加到Map集合当中。

这里主要做了四件事：

初始化状态，将 observer 封装成 ObserverWithState，是一个拥有初始状态的观察者；
计算出它应该到达的状态，也就是当前宿主的状态；
while 循环会让当前的观察者的状态从 INITIALIZED 状态前进到当前宿主的状态，Observer 的状态小于 targetState 说明观察者的状态还没有到达 targetState 的状态，那么就会让 Observer 的状态前进到 targetState；
Observe 调用 dispatchEvent() 分发事件。

每个步骤都很重要，我们来一一分析：

4.状态与事件

State 是一个枚举，表示宿主的状态，但是宿主的状态和宿主的生命周期不是同一个概念。

public enum State {
// 宿主的销毁状态，onDestory()之后
DESTROYED,
// 宿主的初始状态，onCreate()之前
INITIALIZED,
// 宿主的创建状态，onCreate()之后，onStop()之前
CREATED,
// 宿主的启动状态，onStart()之后，onPasue()之前
STARTED,
// 恢复状态，onResume()之后
RESUMED;
}

比如宿主切换到后台，会执行 onPause() 方法，那么宿主的状态是什么状态？再从后台切回前台会执行 onStart() 再执行 onResum()，所以切换到后台的时候，执行了 onPause 这个事件，它的状态会变成 STARTED 的状态。可以看到它是没有 PAUSE 状态的。

这里还定义了 Event 事件，一个枚举，表示生命周期事件。它与宿主的生命周期一一对应。

public enum Event {
//LifecycleOwner的onCreate事件的常量
ON_CREATE,
//LifecycleOwner的onStart事件的常量
ON_START,
//LifecycleOwner的onResume事件的常量
ON_RESUME,
//LifecycleOwner的onPause事件的常量
ON_PAUSE,
//LifecycleOwner的onStop事件的常量
ON_STOP,
//LifecycleOwner的onDestroy事件的常量
ON_DESTROY,
//可以匹配所有事件的常量
ON_ANY
}

宿主生命周期与宿主状态关系图：

宿主在创建之初肯定是处于 INITIALIZED 状态，执行了 onCreate() 方法之后就会进入 CREATED 状态，接着执行了 onStart() 方法之后就会进入 STARTED 状态，执行了 onResume() 就会进入 RESUMED 状态，这是生命周期前进的过程，生命周期倒退过程同理。这里就是宿主的生命周期状态和事件完整的流程。

5.状态比较和升降级

回到 addObserver() 方法中：

@Override
public void addObserver(@NonNull LifecycleObserver observer) {
enforceMainThreadIfNeeded(“addObserver”);
// 1.获取observer需要设置的初始状态
State initialState = mState == DESTROYED ? DESTROYED : INITIALIZED;
// 2.将observer封装成 ObserverWithState，并绑定初始的生命周期状态
ObserverWithState statefulObserver = new ObserverWithState(observer, initialState);
// 添加到Map集合中
ObserverWithState previous = mObserverMap.putIfAbsent(observer, statefulObserver);

boolean isReentrance = mAddingObserverCounter != 0 || mHandlingEvent;
// 3.计算出它应该到达的目标状态
State targetState = calculateTargetState(observer);
mAddingObserverCounter++;
// 4.在while()循环中，会让当前的观察者的状态从init状态前进到目标状态
//Observer的状态与targetState比较，如果小于0说明观察者的状态还没有到达targetState的状态
while ((statefulObserver.mState.compareTo(targetState) < 0
&& mObserverMap.contains(observer))) {
pushParentState(statefulObserver.mState);
// 5.让Observer的状态升级到targetState
final Event event = Event.upFrom(statefulObserver.mState);
// 6. 分发事件，同步状态
statefulObserver.dispatchEvent(lifecycleOwner, event);
popParentState();
// 重新计算mState
targetState = calculateTargetState(observer);
}

if (!isReentrance) {
//同步状态
sync();
}
}

在初始状态中，只要不是在 onDestory 注册的 Observer，每个观察者的初始状态都是 INITIALIZED 状态。在 while 循环中，会让当前的观察者的状态从 INITIALIZED 状态升级到目标状态，如果观察者的状态小于目标状态，就会通过 Event.upFrom() 方法让生命周期升级。

比如我们在 onResme() 方法中注册一个观察者，那么它会接收到哪几种状态呢？INITIALIZED、ONSTART、ONRESUME 它都会有，这个逻辑就在 while 循环里面，先通过 calculateTargetState(observer) 计算出它应该到达的目标状态，也就是当前宿主的状态，然后会拿 Observer 的状态比较，如果小于0说明观察者的状态还没有到达 targetState 的状态，那么就会让 Observer 的状态升级到 targetState。那么是如何进行升级的呢？

// 计算传入状态升级所对应的事件
public static Event upFrom(@NonNull State state) {
switch (state) {
case INITIALIZED:
return ON_CREATE;
case CREATED:
return ON_START;
case STARTED:
return ON_RESUME;
default:
return null;
}
}

离开当前的状态到达更高的状态，事件的状态从较低向上升级。在 INITIALIZED 状态中接收的是 on_Create 事件，然后来到 dispatchEvent() 方法里面：

static class ObserverWithState {
// 当前状态
State mState;
// Observer封装
LifecycleEventObserver mLifecycleObserver;

ObserverWithState(LifecycleObserver observer, State initialState) {
mLifecycleObserver = Lifecycling.lifecycleEventObserver(observer);
mState = initialState;
}

//事件分发逻辑
void dispatchEvent(LifecycleOwner owner, Event event) {
//根据Event获取目标状态
State newState = event.getTargetState();
// 获取最小状态
mState = min(mState, newState);
// 状态改变回调
mLifecycleObserver.onStateChanged(owner, event);
// 更新当前状态
mState = newState;
}
}

会根据 Event 反推出目标状态，在 event.getTargetState() 里面，如果 Event 事件是 ON_CREATE 那么就会到达 State.CREATED 的状态，在调用 mLifecycleObserver.onStateChanged(owner, event) 之后，mState = newState状态就变成新的状态，前进了一步，从 INITIALIZED 状态变成了 CREATED 状态。

// 获取事件目标状态
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;
}
}

它在分发事件的时候是根据观察者的状态推导出分发的事件，然后再根据分发的事件推导出观察者的状态，在这个方法执行完后，会再次回到While()循环中，再次进行观察者状态与目标状态比较，当前状态 mState 已经变成 CREATE, 如果 targetState 是 INITIALIZED，那么就实现了状态的升级。

但是如果 targetState 是 RESUME，while循环比较还是小于0的，则会再次调用 Event.upFrom(mState) 和 dispatchEvent() 方法，将状态升级到 STATED，继续循环升级到 RESUME，依此类推，mState = newState状态就变成新的状态 RESUME。直到观察者的状态和宿主的状态达到一致，然后退出While()循环，如下图

添加Observer时，完整的生命周期事件分发

ObserverWithState 被创建之初状态为 INITIALIZED，如果在宿主的 onResume() 生命周期注册一个 Observer，会把宿主的 onCreate，onStart，onResume 都分发给 Observer：

直到 Observer 的状态和宿主的状态对齐为止，而不是直接从 INITIALIZED 状态直接分发一个 RESUME 直接到达 RESUME，目的因为我们可以在任何地方注册，并且可以接收到完整的接收事件，从而完成初始化，暂停，释放的工作。

这是添加观察者时的事件分发流程。

6.Lifecycle是如何分发宿主状态的

那么宿主的生命周期变化之后是如何分发给每一个观察者的？

根据上面 Activity/Fragment 源码分析，它会在每个生命周期方法里面执行handleLifecycleEvent(event)，event.getTargetState()根据当前的事件推导出每个观察者目标的生命周期状态。

public void handleLifecycleEvent(@NonNull Lifecycle.Event event) {
enforceMainThreadIfNeeded(“handleLifecycleEvent”);
moveToState(event.getTargetState());
}

private void moveToState(State next) {
if (mState == next) {
return;
}
mState = next;
mHandlingEvent = true;
// 同步新状态事件
sync();
mHandlingEvent = false;
}

moveToState(next) 里面主要是做一些条件的判断，真正的状态同步是在 sync() 方法里面：

private void sync() {
LifecycleOwner lifecycleOwner = mLifecycleOwner.get();
//循环，直到isSynced()同步完成，所有观察者的状态都分发完，状态都与宿主的状态一致
while (!isSynced()) {
mNewEventOccurred = false;
// 1.宿主的状态小于观察者状态，观察者状态进行降级
if (mState.compareTo(mObserverMap.eldest().getValue().mState) < 0) {
//状态降级
backwardPass(lifecycleOwner);
}
Entry<LifecycleObserver, ObserverWithState> newest = mObserverMap.newest();
// 2. 宿主的状态大于观察者状态，观察者状态进行升级
if (!mNewEventOccurred && newest != null
&& mState.compareTo(newest.getValue().mState) > 0) {
// 状态升级
forwardPass(lifecycleOwner);
}
}
mNewEventOccurred = false;
}

isSynced() 判断这个接口里面注册的 Observer 是否所有观察者的状态都分发完成，都已经同步到跟宿主一致的状态。如果不是则进入状态判断：

宿主的状态小于观察者状态，观察者状态进行降级；
宿主的状态大于观察者状态，观察者状态进行升级。

如果宿主的状态小于观察者状态，这种发生在生命周期倒退的阶段，比如前台切换到后台，执行 onPause() 方法，宿主进入 STARED 状态，观察者还处于 RESUME 状态，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();
ObserverWithState observer = entry.getValue();
// 循环对比单个观察者的状态，直到单个观察者同步到目标状态，观察者状态大于宿主状态，则将观察者状态降级处理
while ((observer.mState.compareTo(mState) > 0 && !mNewEventOccurred
&& mObserverMap.contains(entry.getKey()))) {
// 根据observer.mState 的状态降级，获取对应的Event事件
Event event = Event.downFrom(observer.mState);

pushParentState(event.getTargetState());
// 分发相应的事件Event
observer.dispatchEvent(lifecycleOwner, event);
popParentState();
}
}
}

这里的核心逻辑就是遍历所有观察者，根据当前观察者的状态，计算出它应该分发哪一种事件，由于是生命周期的倒退，这里执行的是 Event.downFrom(observer.mState)，也就是生命周期的降级：

// 计算传入状态降级所对应的事件
public static Event downFrom(@NonNull State state) {
switch (state) {
// 如果当前的状态是 CREATED，发生生命周期倒退就是执行了ON_DESTROY，返回ON_DESTROY事件
case CREATED:
return ON_DESTROY;
case STARTED:
return ON_STOP;
case RESUMED:
return ON_PAUSE;
default:
return null;
}
}

如果观察者是 RESUME 状态，发生生命周期倒退，就会返回一个 ON_PAUSE 事件，如果是 STARTED 状态发生生命周期的倒退也就是返回 ON_STOP 事件。

然后根据返回的事件，调用 observer.dispatchEvent() 分发给它，根据上面的分析，还会当前的事件推导出目标的状态，然后赋值给 mState。

static class ObserverWithState {
void dispatchEvent(LifecycleOwner owner, Event event) {
//根据Event获取目标状态
State newState = event.getTargetState();
// 获取最小状态
mState = min(mState, newState);
// 状态改变回调
mLifecycleObserver.onStateChanged(owner, event);
// 更新当前状态
mState = newState;
}
}

backwardPass() 执行完之后，观察者的状态就会降级到和宿主一样的状态，直到集合里面的所有观察者的状态和宿主的一样为止。

private void sync() {
LifecycleOwner lifecycleOwner = mLifecycleOwner.get();
//所有观察者的状态都分发完，状态都与宿主的状态一致
while (!isSynced()) {
// ······
Entry<LifecycleObserver, ObserverWithState> newest = mObserverMap.newest();
// 2. 宿主的状态和Observe状态比较，宿主的状态大于观察者状态，观察者状态进行升级
if (!mNewEventOccurred && newest != null
&& mState.compareTo(newest.getValue().mState) > 0) {
// 状态升级
forwardPass(lifecycleOwner);
}
}
mNewEventOccurred = false;
}

同理，进入 sync() 的第二个判断条件，把当前宿主的状态和每个观察者的状态进行比较，如果大于0，生命周期前进(比如后台切换到前台)，从 STARTES 状态切换到 RESUME 状态， forwardPass(lifecycleOwner) 逻辑与 backwardPass() 相似，只不过这是状态前进的过程，会调用 Event.upForm(observer.mState)，根据当前观察者的状态在生命周期前进的时候计算出它应该分发哪一个事件。

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);
// 根据mState状态升级，获取对应的分发事件Event
final Event event = Event.upFrom(observer.mState);
// 分发完后就和宿主达到一致的状态
observer.dispatchEvent(lifecycleOwner, event);
popParentState();
}
}
}

observer.dispatchEvent() 分发完就会与宿主达到一致的状态，直到 Observer 集合当中所有观察者与宿主的状态保持一致，并且退出这个循环。

到这里，宿主的生命周期和宿主状态的关系，每个生命周期变化的时候，都会分发相应的事件，并且根据这个事件推导出宿主的状态，遍历所有的观察者，让他们的状态也随之升级，或者降级，并且把本次事件分发给观察者。

7.如何区分LifecycleObserver的类型

那么这个事件它在分发的时候，是如何区分的 LifecycleObserver 还是 FullLifecycleObserver,亦或者是 LifecycleEventObserver 这三种类类型的？在 addObserver() 里面，每次注册一个 Observer 都会把它包装成一个 ObserverWithState：

static class ObserverWithState {
State mState;
LifecycleEventObserver mLifecycleObserver;
//把传递进来的observer转换成LifecycleEventObserver
ObserverWithState(LifecycleObserver observer, State initialState) {
mLifecycleObserver = Lifecycling.lifecycleEventObserver(observer);
mState = initialState;
}

void dispatchEvent(LifecycleOwner owner, Event event) {
State newState = getStateAfter(event);
mState = min(mState, newState);
// 分发事件
mLifecycleObserver.onStateChanged(owner, event);
mState = newState;
}
}

它把传递进来的 observer 转换成 LifecycleEventObserver，分发事件的时候调用了 mLifecycleObserver.onStateChanged() 方法，但是我们在使用的时候明明是 LifecycleObserver 或者 FullLifecycleObserver，主要是原理在 Lifecycling.lifecycleEventObserver(observer) 里面，本质上是一个工具类，把传递进来的 observer 转化成 LifecycleEventObserver，主要是通过适配器来转化的。

static LifecycleEventObserver lifecycleEventObserver(Object object) {
// 是否为LifecycleEventObserver类型
boolean isLifecycleEventObserver = object instanceof LifecycleEventObserver;
// 是否为FullLifecycleObserver类型
boolean isFullLifecycleObserver = object instanceof FullLifecycleObserver;
// 1.这种情况发生在自定义Observer,上面两种都实现了
if (isLifecycleEventObserver && isFullLifecycleObserver) {
return new FullLifecycleObserverAdapter((FullLifecycleObserver) object,
(LifecycleEventObserver) object);
}
// 2. FullLifecycleObserver 将object当做FullLifecycleObserver传递
if (isFullLifecycleObserver) {
return new FullLifecycleObserverAdapter((FullLifecycleObserver) object, null);
}
// 3. LifecycleEventObserver 直接返回object本身
if (isLifecycleEventObserver) {
return (LifecycleEventObserver) object;
}
//······
}

判断 observer 是否为 LifecycleEventObserver && FullLifecycleObserver，如果条件都成立（一般发生在自定义的 Observer，即实现了两个接口），返回了一个FullLifecycleObserverAdapter，它实现了 LifecycleEventObserver 接口，复写了onStateChanged()方法，判断 Event 的类型，从而回调传递进来的 FullLifecycleObserver 相应的方法，如果还实现了 mLifecycleEventObserver 接口，则最后还会回调mLifecycleEventObserver.onStateChanged()方法。

// 实现LifecycleEventObserver接口
class FullLifecycleObserverAdapter implements LifecycleEventObserver {
// mFullLifecycleObserver回调生命周期方法
@Override
public void onStateChanged(LifecycleOwner source, 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;
}
// 回调mLifecycleEventObserver的onStateChanged()方法
if (mLifecycleEventObserver != null) {
mLifecycleEventObserver.onStateChanged(source, event);
}
}
}

如果仅仅是实现了 FullLifecycleObserver，同样是返回了一个FullLifecycleObserverAdapter，但是 lifecycleEventObserver 为 null，说明不再回调 onStateChanged(source, event) 方法，实际上通过 FullLifecycleObserverAdapter 包装实现转化过程，将 LifecycleObserver 转化为 LifecycleEventObserver。
如果是直接实现了 LifecycleEventObserver 的则直接返回，那么在生命周期事件分发的时候， Observer 就能直接分发到 onStateChanged() 这个方法里面。

static LifecycleEventObserver lifecycleEventObserver(Object object) {
·····
final Class<?> klass = object.getClass();
// 获取Observer构造器类型，是否添加了注解编译器
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);
}
// 返回CompositeGeneratedAdaptersObserver
return new CompositeGeneratedAdaptersObserver(adapters);
}
// 返回ReflectiveGenericLifecycleObserver，内部实现依赖反射
return new ReflectiveGenericLifecycleObserver(object);
}

上面的代码则是判断 LifecycleOberver，我们知道它只是一个空实现，但是为什么还要定义这个接口呢？这里仅仅是起到一个约束和规范的作用，方便在运行的时候判断 Observer 是那种类型。

自我介绍一下，小编13年上海交大毕业，曾经在小公司待过，也去过华为、OPPO等大厂，18年进入阿里一直到现在。

深知大多数HarmonyOS鸿蒙开发工程师，想要提升技能，往往是自己摸索成长或者是报班学习，但对于培训机构动则几千的学费，着实压力不小。自己不成体系的自学效果低效又漫长，而且极易碰到天花板技术停滞不前！

因此收集整理了一份《2024年HarmonyOS鸿蒙开发全套学习资料》，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友，同时减轻大家的负担。

既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，基本涵盖了95%以上HarmonyOS鸿蒙开发知识点，真正体系化！

由于文件比较大，这里只是将部分目录大纲截图出来，每个节点里面都包含大厂面经、学习笔记、源码讲义、实战项目、讲解视频，并且会持续更新

如果你觉得这些内容对你有帮助，可以添加VX：vip204888 （备注鸿蒙获取）

一个人可以走的很快，但一群人才能走的更远。不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎扫码加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！

长，而且极易碰到天花板技术停滞不前！**

因此收集整理了一份《2024年HarmonyOS鸿蒙开发全套学习资料》，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友，同时减轻大家的负担。
[外链图片转存中…(img-Js3BuV0n-1712647732583)]
[外链图片转存中…(img-C4O8dfgm-1712647732584)]
[外链图片转存中…(img-KEqXZqRg-1712647732584)]

由于文件比较大，这里只是将部分目录大纲截图出来，每个节点里面都包含大厂面经、学习笔记、源码讲义、实战项目、讲解视频，并且会持续更新

如果你觉得这些内容对你有帮助，可以添加VX：vip204888 （备注鸿蒙获取）
[外链图片转存中…(img-pXjVKeSd-1712647732584)]