Fragment 是如何派发生命周期的？也就是它会在自己生命周期里面，让 LifecycleRegistry 去分发生命周期事件，给每一个观察者。但是 Activity 中并不是这么做的。
2.Activity是如何是实现Lifecycle的
Activity 实现 Lifecycle 的核心源码，需要来到 ComponentActivity 里面，同样也是实现了 LifecycleOwner 接口：
public class ComponentActivity extends Activity implements LifecycleOwner {
private LifecycleRegistry mLifecycleRegistry = new LifecycleRegistry(this);
//复写getLifecycle()，返回LifecycleRegistry对象
@Override
public Lifecycle getLifecycle() {
return mLifecycleRegistry;
}
@Override
protected void onCreate(@Nullable Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
//往Activity上添加一个fragment，用以报告生命周期的变化
//目的是为了兼顾不是继承自AppCompactActivity的场景
ReportFragment.injectIfNeededIn(this);
}
}
与上面 Fragment 的实现类似，它实现了 LifecycleOwner，表示一个生命周期的宿主，必须实现 getLifecycle() 方法，返回一个 Lifecycle，也就是 LifecycleRegistry。
但是在 ComponentActivity 里面并没有在它的每个生命周期方法里面把它的状态分发给一个观察者，但是在 onCreate() 方法里面调用 ReportFragment.injectIfNeededIn(this) 这种做法实际上是往自己里面添加了一个不可见的 Fragment，专门用于报告分发给每个观察者。
public class ReportFragment extends Fragment {
public static void injectIfNeededIn (Activity activity) {
if (Build.VERSION.SDK_INT >= 29) {
// API 29 以上可以直接注册正确的生命周期回调
activity.registerActivityLifecycleCallbacks(
new LifecycleCallbacks ()
);
}
// 兼容API 29之前的，需要支持直接继承Activity的，使用Fragment来正确获得生命周期事件
android.app.FragmentManager manager = activity . getFragmentManager ();
if (manager.findFragmentByTag(REPORT_FRAGMENT_TAG) == null) {
manager.beginTransaction().add(new ReportFragment (), REPORT_FRAGMENT_TAG).commit();
manager.executePendingTransactions();
}
}
}
所以 Activity 事件的分发是依靠 ReportFragment 来完成的。
- API 29 以下: 主要是通过
ReportFragment将自身添加到 Activity 中实现。 - API 29 及以上：Activity 中增加一组
ActivityLifecycleCallbacks的相关方法，可以直接通过注册ActivityLifecycleCallbacks观察生命周期。
ComponentActivity 为什么这么做而不直接在 Activity 内部直接分发呢？主要是为了兼顾不是继承自 AppCompatActivity 的场景。有可能是直接继承自 Activity，然后自己实现了 Lifecycle 接口。
public class ReportFragment extends Fragment {
// 增加dispatch重载，尝试获取Activity中的LifecycleRegistry并调用 handleLifecycleEvent
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);
}
}
}
// 2.各个生命周期方法里面都调用了dispatch()方法
@Override
public void onStart() {
super.onStart();
dispatch(Lifecycle.Event.ON_START);
}
@Override
public void onResume() {
super.onResume();
dispatch(Lifecycle.Event.ON_RESUME);
}
@Override
public void onPause() {
super.onPause();
dispatch(Lifecycle.Event.ON_PAUSE);
}
//······
// 3.拿到Activity的Lifecycle对象，把当前的事件分发给每个观察者
private void dispatch(@NonNull Lifecycle.Event event) {
if (Build.VERSION.SDK_INT < 29) {
// 在API 29之前从ReportFragment分派事件。
// 在API 29+上，由reportfragment.injectifneededdin中添加的activitylifecyecallbacks处理
dispatch(getActivity(), event);
}
}
}
为了前向兼容，ReportFragment 依然会被添加到 Activity，并在 dispatch() 中增加过滤避免出现二次调用。
ReportFragment 会在侦测到 Activity 生命周期变化的时候调用 LifecycleRegistry.handleLifecycleEvent() 传入对应的状态。 这时候会有一个类 LifecycleDispatcher:
//挂钩到Activity的回调并进行观察
class LifecycleDispatcher {
private static AtomicBoolean sInitialized = new AtomicBoolean(false);
static void init(Context context) {
((Application) context.getApplicationContext())
.registerActivityLifecycleCallbacks(new DispatcherActivityCallback());
}
static class DispatcherActivityCallback extends EmptyActivityLifecycleCallbacks {
@Override
public void onActivityCreated(Activity activity, Bundle savedInstanceState) {
// 监听到每个Activity打开的事件
ReportFragment.injectIfNeededIn(activity);
}
}
}
在它的 init() 方法里面调用了 registerActivityLifecycleCallbacks()，这里就能监察到每个 Activity 打开的事件，会再次利用 ReportFragment.injectIfNeededIn(activity)，也就是说往每个 Activity 里面注册一个 ReportFragment，用于分发和报告当前宿主的生命周期到每个观察者，它这里是以一个切面编程的方式注入了一个 Fragment 对象，尽管我们是继承子 Activity，只要你实现了 LifecycleOwner 的接口，也能具备生命周期分发的能力。所以 Activity 生命周期分发的功能提取到 ReportFragment 里面，主要是为了不是继承自 AppCompatActivity 的场景。
到这里 Activity/Fragment 各自是如何实现 Lifecycle 能力的已经分析完成。但是无论如何生命周期能力都是依赖 LifecycleRegistry 来完成的。
3.LifecycleRegistry 源码分析
它是 Lifecycle 的实现，可以处理多个观察者。生命周期事件分发都是依靠 LifecycleRegistry 来完成的。先从添加观察者方法开始：
@Override
public void addObserver(@NonNull LifecycleObserver observer) {
enforceMainThreadIfNeeded(“addObserver”);
// 1.初始化状态，当前宿主的状态
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();
}
}
在 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)，根据当前观察者的状态在生命周期前进的时候计算出它应该分发哪一个事件。
自我介绍一下，小编13年上海交大毕业，曾经在小公司待过，也去过华为、OPPO等大厂，18年进入阿里一直到现在。
深知大多数HarmonyOS鸿蒙开发工程师，想要提升技能，往往是自己摸索成长或者是报班学习，但对于培训机构动则几千的学费，着实压力不小。自己不成体系的自学效果低效又漫长，而且极易碰到天花板技术停滞不前！
因此收集整理了一份《2024年HarmonyOS鸿蒙开发全套学习资料》，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友，同时减轻大家的负担。
既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，基本涵盖了95%以上HarmonyOS鸿蒙开发知识点，真正体系化！
由于文件比较大，这里只是将部分目录大纲截图出来，每个节点里面都包含大厂面经、学习笔记、源码讲义、实战项目、讲解视频，并且会持续更新
如果你觉得这些内容对你有帮助，可以添加VX：vip204888 （备注鸿蒙获取）
一个人可以走的很快，但一群人才能走的更远。不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎扫码加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！
自学效果低效又漫长，而且极易碰到天花板技术停滞不前！**
因此收集整理了一份《2024年HarmonyOS鸿蒙开发全套学习资料》，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友，同时减轻大家的负担。
[外链图片转存中…(img-8n29gri1-1712785017158)]
[外链图片转存中…(img-bLGtbHzo-1712785017158)]
[外链图片转存中…(img-GCaOaIHT-1712785017159)]
既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，基本涵盖了95%以上HarmonyOS鸿蒙开发知识点，真正体系化！
由于文件比较大，这里只是将部分目录大纲截图出来，每个节点里面都包含大厂面经、学习笔记、源码讲义、实战项目、讲解视频，并且会持续更新
如果你觉得这些内容对你有帮助，可以添加VX：vip204888 （备注鸿蒙获取）
[外链图片转存中…(img-oOo2JqDu-1712785017159)]
一个人可以走的很快，但一群人才能走的更远。不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎扫码加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
