android LifeCycle-简单使用和详细原理解析

2401_87029252

于 2024-09-06 23:27:43 发布

阅读量1k

点赞数 18

文章标签： android

本文链接：https://blog.csdn.net/2401_87029252/article/details/141978525

版权

LifecycleOwner lifecycleOwner = mLifecycleOwner.get();
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–;
}

首先会创建ObserverWithState对象，用来记录生命周期状态，

State targetState = calculateTargetState(observer);

方法会计算出此时的生命周期状态，

后面是一个while循环，while循环会分发生命周期状态

比如你在onResume中进行注册其实也是可以收到onCreate和onStart的注册回调的，这种注册方式实际上就是粘性注册，安卓系统中电量信息的广播接受者就是一种很好的粘性广播注册案例，与这个粘性注册原理相同

后面代码中的方法调用如下

if (!isReentrance) {
// we do sync only on the top level.
sync();
}

isReentrance为false的条件是，当前没有在moveToState方法中分发消息，或者注册者的数量不等于0。如果满足这个条件就会调用sync()方法分发消息

Fragment中生命周期方法联动回调

ReportFragment中生命周期方法回调

例如：

dispatch(Lifecycle.Event.ON_DESTROY);

private void dispatch(Lifecycle.Event event) {
Activity activity = getActivity();

if (activity instanceof LifecycleOwner) {
Lifecycle lifecycle = ((LifecycleOwner) activity).getLifecycle();
if (lifecycle instanceof LifecycleRegistry) {
((LifecycleRegistry) lifecycle).handleLifecycleEvent(event);
}
}
}

代码中会把Fragment中的所有生命周期回调都调用dispatch方法进行分发，dispatch方法中会调用lifecycle的handleLifecycleEvent方法继续分发

跳到LifecycleRegistry类中，找到handleLifecycleEvent方法

public void handleLifecycleEvent(@NonNull Lifecycle.Event event) {
State next = getStateAfter(event);
moveToState(next);
}

getStateAfter方法主要用来确认事件触发时下一个生命周期的状态，有下面三种：

CREATED、STARTED、DESTROYED

moveToState方法更改生命周期状态并分发，代码如下：

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;
}

moveToState中的sync()方法用来分发生命周期事件到Observer，

sync() 方法

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.
if (mState.compareTo(mObserverMap.eldest().getValue().mState) < 0) {
backwardPass(lifecycleOwner);
}
Entry<LifecycleObserver, ObserverWithState> newest = mObserverMap.newest();
if (!mNewEventOccurred && newest != null
&& mState.compareTo(newest.getValue().mState) > 0) {
forwardPass(lifecycleOwner);
}
}
mNewEventOccurred = false;
}

下面代码是State的几种状态

public enum State {

DESTROYED,

INITIALIZED,

CREATED,

STARTED,

RESUMED;
}

sync方法的while循环中有如下代码：

if (mState.compareTo(mObserverMap.eldest().getValue().mState) < 0) {
backwardPass(lifecycleOwner);
}

上面这行代码会比较当前生命周期状态和最早被加入到SafeIterableMap中的状态，如果小于零（比如一般第一个被加入的是INITIALIZED状态，当前状态比ONCREATE还小只能是DESTROYED状态了），说明当前生命周期需要被backwardPass处理

Entry<LifecycleObserver, ObserverWithState> newest = mObserverMap.newest();
if (!mNewEventOccurred && newest != null
&& mState.compareTo(newest.getValue().mState) > 0) {
forwardPass(lifecycleOwner);
}

上面代码中newest是最新被添加到mObserverMap中的状态，如果当前生命周期状态大于newest状态，说明状态在前进（比如onCreate到onStart）

继续看backwardPass和forwardPass方法

private void forwardPass(LifecycleOwner lifecycleOwner) {
Iterator<Entry<LifecycleObserver, ObserverWithState>> ascendingIterator =
mObserverMap.iteratorWithAdditions();//获取正序的迭代器
while (ascendingIterator.hasNext() && !mNewEventOccurred) {
Entry<LifecycleObserver, ObserverWithState> entry = ascendingIterator.next();
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();
}
}
}

private void backwardPass(LifecycleOwner lifecycleOwner) {
Iterator<Entry<LifecycleObserver, ObserverWithState>> descendingIterator =
mObserverMap.descendingIterator();//获取逆向迭代器
while (descendingIterator.hasNext() && !mNewEventOccurred) {
Entry<LifecycleObserver, ObserverWithState> entry = descendingIterator.next();
ObserverWithState observer = entry.getValue();
while ((observer.mState.compareTo(mState) > 0 && !mNewEventOccurred
&& mObserverMap.contains(entry.getKey()))) {
Event event = downEvent(observer.mState);
pushParentState(getStateAfter(event));
observer.dispatchEvent(lifecycleOwner, event);
popParentState();
}
}
}

forwardPass和backwardPass都有三句重要代码：

pushParentState(getStateAfter(event));
observer.dispatchEvent(lifecycleOwner, event);
popParentState();

pushParentState(getStateAfter(event));

向列表中存入状态

observer.dispatchEvent(lifecycleOwner, event);

向Observer分发状态

popParentState();

弹出上一步代码中存入的状态

查看dispathchEvent方法

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

这里的mLifecycleObserver.onStateChanged(owner, event);最终会回调到我们声明的注解方法，mLifecycleObserver的实例是ReflectiveGenericLifecycleObserver，ReflectiveGenericLifecycleObserver最终通过反射的方式回调注解方法，这一部分下一节会详细讲

如何回调注解方法

说到注解方法回调就不得不提addObserver方法了，在LifecycleRegistry类的addObserver方法中，我们创建了一个ObserverWithState对象，并放到Map中

实际上在ObserverWithState方法的构造中就会对注解方法进行包装处理，从而最终用反射回调方法，下面开始代码解析：

ObserverWithState方法的构造如下

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

mLifecycleObserver = Lifecycling.lifecycleEventObserver(observer);

这一行代码最终获得的mLifecycleObserver实例的真实类型是ReflectiveGenericLifecycleObserver

ObserverWithState的dispatchEvent方法如下

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

在dispatchEvent方法中，会调用

mLifecycleObserver.onStateChanged(owner, event);

代码进行消息分发，实际上就是调用ReflectiveGenericLifecycleObserver.onStateChanged方法。

那么我就看看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(LifecycleOwner source, Event event) {
mInfo.invokeCallbacks(source, event, mWrapped);
}
}

ReflectiveGenericLifecycleObserver类构造参数中的wrapped对象就是我们addObserver中注册的自定义Observer对象。

在构造中通过一些了反射操作拿到Observer对象中的信息封装成了CallbackInfo对象。

然后当我们在ObserverWithState中调用ReflectiveGenericLifecycleObserver的onStateChanged方法的时候，就会调用如下代码：

mInfo.invokeCallbacks(source, event, mWrapped);

invokeCallbacks方法的方法体已经后续调用的代码如下：

@SuppressWarnings(“ConstantConditions”)
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);
}

private static void invokeMethodsForEvent(List 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);
}
}
}

上面这一大坨代码最终会调用到MethodReference的如下代码

void invokeCallback(LifecycleOwner source, Lifecycle.Event event, Object target) {
//noinspection TryWithIdenticalCatches
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;

学习分享

在当下这个信息共享的时代，很多资源都可以在网络上找到，只取决于你愿不愿意找或是找的方法对不对了

很多朋友不是没有资料，大多都是有几十上百个G，但是杂乱无章，不知道怎么看从哪看起，甚至是看后就忘

如果大家觉得自己在网上找的资料非常杂乱、不成体系的话，我也分享一套给大家，比较系统，我平常自己也会经常研读。

2021最新上万页的大厂面试真题

七大模块学习资料：如NDK模块开发、Android框架体系架构…

只有系统，有方向的学习，才能在段时间内迅速提高自己的技术。

这份体系学习笔记，适应人群：
第一，学习知识比较碎片化，没有合理的学习路线与进阶方向。
第二，开发几年，不知道如何进阶更进一步，比较迷茫。
第三，到了合适的年纪，后续不知道该如何发展，转型管理，还是加强技术研究。如果你有需要，我这里恰好有为什么，不来领取！说不定能改变你现在的状态呢！
由于文章内容比较多，篇幅不允许，部分未展示内容以截图方式展示。

加入社区》https://bbs.csdn.net/forums/4304bb5a486d4c3ab8389e65ecb71ac0
roid框架体系架构…**

[外链图片转存中…(img-X1kI2TRx-1725636453442)]

只有系统，有方向的学习，才能在段时间内迅速提高自己的技术。

这份体系学习笔记，适应人群：
第一，学习知识比较碎片化，没有合理的学习路线与进阶方向。
第二，开发几年，不知道如何进阶更进一步，比较迷茫。
第三，到了合适的年纪，后续不知道该如何发展，转型管理，还是加强技术研究。如果你有需要，我这里恰好有为什么，不来领取！说不定能改变你现在的状态呢！
由于文章内容比较多，篇幅不允许，部分未展示内容以截图方式展示。

加入社区》https://bbs.csdn.net/forums/4304bb5a486d4c3ab8389e65ecb71ac0