目录
[一、Lifecycle 组件概述](#一、Lifecycle 组件概述)
[1.1 核心组件](#1.1 核心组件)
[1.2 源码解析](#1.2 源码解析)
[1.2.1 LifecycleOwner](#1.2.1 LifecycleOwner)
[1.2.2 Lifecycle](#1.2.2 Lifecycle)
[1.2.3 LifecycleRegistry （重点）](#1.2.3 LifecycleRegistry （重点）)
[1.2.4 LifecycleObserver](#1.2.4 LifecycleObserver)
[1.2.5 事件生产者](#1.2.5 事件生产者)
系列入口导航：Android Jetpack 概述
一、Lifecycle 组件概述
Lifecycle 是 Android Jetpack 的核心组件，用于管理 Android 组件（Activity/Fragment）的生命周期状态，实现生命周期感知的组件设计模式。
1.1 核心组件
-
Lifecycle：生命周期状态持有者
-
LifecycleOwner：生命周期拥有者（Activity/Fragment），负责发出生命周期
-
LifecycleObserver：生命周期观察者，对生命周期的监听和消费
-
LifecycleRegistry ：生命周期状态管理实现（继承自Lifecycle），负责存储和调度
Lifecycle组件中有三个重要的组件：LifecycleOwner、LifecycleRegistry/Lifecycle和LifecycleObserver。它们分别扮演着生产者，管理者和消费者的角色。LifecycleOwner，Lifecycle，LifecycleObserver在之前的文章里提到过，这着重说一下LifecycleRegistry。AppCompatActivity里的getLifecycle()获取的就是LifecycleRegistry。
LifecycleRegistry：Lifecycle的子类，同时持有LifecycleOwner的弱引用 和LifecycleObserver的强引用，起到了一个桥梁作用，本身是一个观察者的角色。
LifecycleOwner将自己的生命周期状态存在LifecycleRegistry里面。每当LifecycleOwner的生命周期发生改变时，会通知LifecycleRegistry（当然，每个生命周期组件都持有LifecycleRegistry的实例），而LifecycleObserver通过观察者模式和LifecycleRegistry绑定实现对生命周期的观察；
它们的关系大致如下图所示：
1.2 源码解析
1.2.1 LifecycleOwner
java
import androidx.annotation.NonNull;
/**
* A class that has an Android lifecycle. These events can be used by custom components to
* handle lifecycle changes without implementing any code inside the Activity or the Fragment.
*
* @see Lifecycle
* @see ViewTreeLifecycleOwner
*/
@SuppressWarnings({"WeakerAccess", "unused"})
public interface LifecycleOwner {
/**
* Returns the Lifecycle of the provider.
*
* @return The lifecycle of the provider.
*/
@NonNull
Lifecycle getLifecycle();
}LifecycleOwner的定义很简单：它是一个单一方法接口，用来标记实现类持有Lifecycle对象。getLifecycle方法返回一个Lifecycle，实际就是一个Lifecycle的实现类LifecycleRegistry的实例。
以ComponentActivity为例，LifeCycle在其中的实现如下：
java
public class ComponentActivity extends Activity implements LifecycleOwner {
private LifecycleRegistry mLifecycleRegistry = new LifecycleRegistry(this);
public Lifecycle getLifecycle() {
return mLifecycleRegistry;
}
}其目的很简单直接，就是为了向外部提供Lifecycle，也就是LifecycleRegistry的实例。
思考下：为什么是接口而不是抽象类？
java
// 设计决策：使用接口的优势
public interface LifecycleOwner {
// 1. 允许多重实现（虽然 Android 组件通常单继承）
// 2. 更好的解耦和测试
// 3. 支持动态代理
// 4. 符合接口隔离原则
}
// 对比：如果是抽象类
public abstract class LifecycleOwner {
// 会限制实现类的继承结构
// Android 组件（Activity/Fragment）已经继承了特定基类
}关键限制：Java 是单继承语言，一个类只能继承一个父类。
下面的情况就是不被允许的：
java
// ❌ 错误的设计：使用抽象类
public abstract class AbstractLifecycleOwner {
private final LifecycleRegistry registry = new LifecycleRegistry(this);
public Lifecycle getLifecycle() {
return registry;
}
protected abstract void handleLifecycleEvent(Event event);
}
// Activity 无法同时继承 AbstractLifecycleOwner
class MyActivity extends AppCompatActivity
extends AbstractLifecycleOwner { // ❌ 编译错误：不能多重继承
}1.2.2 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();
@SuppressWarnings("WeakerAccess")
public enum Event {
ON_CREATE,
ON_START,
ON_RESUME,
ON_PAUSE,
ON_STOP,
ON_DESTROY,
ON_ANY;
@Nullable
public static Event downFrom(@NonNull State state) {
switch (state) {
case CREATED:
return ON_DESTROY;
case STARTED:
return ON_STOP;
case RESUMED:
return ON_PAUSE;
default:
return null;
}
}
@Nullable
public static Event downTo(@NonNull State state) {
switch (state) {
case DESTROYED:
return ON_DESTROY;
case CREATED:
return ON_STOP;
case STARTED:
return ON_PAUSE;
default:
return null;
}
}
@Nullable
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;
}
}
@Nullable
public static Event upTo(@NonNull State state) {
switch (state) {
case CREATED:
return ON_CREATE;
case STARTED:
return ON_START;
case RESUMED:
return ON_RESUME;
default:
return null;
}
}
@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");
}
}
@SuppressWarnings("WeakerAccess")
public enum State {
DESTROYED,
INITIALIZED,
CREATED,
STARTED,
RESUMED;
public boolean isAtLeast(@NonNull State state) {
return compareTo(state) >= 0;
}
}
}Lifecycle是一个抽象类，它定义了两个抽象方法 addObserver 和 removeObserver 用来添加和移除对生命周期进行监听的对象。这两个方法都由LifecycleRegistry实现。
另外还有两个表示生命周期的枚举类，之前的文章介绍过：
- Event：生命周期改变时的事件
- State：组件的当前状态
java
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;
}可以观察 getTargetState() 他们的关系如下：
Lifecycle本身作为一个抽象类起到的更多的是定义功能，它的行为实现基本都是通过LifecycleRegistry完成的。
1.2.3 LifecycleRegistry （重点）
java
public class LifecycleRegistry extends Lifecycle {
//存储绑定的生命周期观察者
//使用LifecycleObserver作为key值，使用ObserverWithState内部类作为value
//ObserverWithState持有LifecycleObserver和State，前者是观察者的引用
//State表示该观察者所持有的状态
private FastSafeIterableMap<LifecycleObserver, ObserverWithState> mObserverMap =
new FastSafeIterableMap<>();
//组件当前的生命周期状态
private State mState;
//通过弱引用的方式持有LifecycleOwner（Activity/Fragment）
private final WeakReference<LifecycleOwner> mLifecycleOwner;
//正在进行绑定的观察者数量
//用来标价正在通过addObserver进行绑定的观察者的数量
private int mAddingObserverCounter = 0;
//是否正在处理生命周期事件
//mHandlingEvent为true时表示正在向外分生命周期状态
private boolean mHandlingEvent = false;
//标记有新事件发生
private boolean mNewEventOccurred = false;
//状态栈，用于管理在递归分发生命周期事件时的父状态，防止无限递归并确保状态转换的正确性
private ArrayList<State> mParentStates = new ArrayList<>();
//控制是否强制要求生命周期操作必须在主线程执行
private final boolean mEnforceMainThread;
//构造方法
public LifecycleRegistry(@NonNull LifecycleOwner provider) {
this(provider, true);
}
private LifecycleRegistry(@NonNull LifecycleOwner provider, boolean enforceMainThread) {
mLifecycleOwner = new WeakReference<>(provider);
mState = INITIALIZED;
mEnforceMainThread = enforceMainThread;
}
//已废弃的旧方法
@Deprecated
@MainThread
public void markState(@NonNull State state) {
enforceMainThreadIfNeeded("markState");
setCurrentState(state); // 直接转发
}
//设置目标状态
@MainThread
public void setCurrentState(@NonNull State state) {
enforceMainThreadIfNeeded("setCurrentState");
moveToState(state); // 调用内部状态迁移
}
//根据当前的生命周期事件，设置当前的状态并通知观察者
public void handleLifecycleEvent(@NonNull Lifecycle.Event event) {
enforceMainThreadIfNeeded("handleLifecycleEvent");
moveToState(event.getTargetState()); // 通过事件计算状态
}
//开始处理状态
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 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;
//第一种是当前的状态值小于之前的状态，则执行回退状态的操作（如CREATED->RESUMED）
//由于backwardPass是采用倒序迭代器对链表中的观察者一次进行迭代
//所以这种情况下通过链表第一个元素进行状态比对
if (mState.compareTo(mObserverMap.eldest().getValue().mState) < 0) {
backwardPass(lifecycleOwner);
}
//第二种是当前的状态值大于之前的状态，则执行前进状态的操作（如>RESUMED->CREATED）
//由于forwardPass是采用正序迭代器对链表中的观察者一次进行迭代
//所以这种情况下通过链表最后一个元素进行状态比对
Map.Entry<LifecycleObserver, ObserverWithState> newest = mObserverMap.newest();
if (!mNewEventOccurred && newest != null
&& mState.compareTo(newest.getValue().mState) > 0) {
forwardPass(lifecycleOwner);
}
}
mNewEventOccurred = false;
}
//判断是否同步完成
//通过判断mObserverMap的最eldest和newest的状态是否和当前状态一致
//来判断是否是否将状态同步到了所有观察者
//mObserverMap是一个FastSafeIterableMap类型的，它继承自SafeIterableMap
//实现了类似LinkedHashMap的功能
//其中eldest获取的是第一个被添加的元素，也就是第一个观察者
//newest为最近一个别添加进来的元素也就是最后一个观察者
//由于生命状态同步是通过FastSafeIterableMap中的迭代器一次实现的
//所以当链表的头尾数据相同且都和当前状态保持一直，则可以认为它们同步完成了
private boolean isSynced() {
if (mObserverMap.size() == 0) {
return true;
}
State eldestObserverState = mObserverMap.eldest().getValue().mState;
State newestObserverState = mObserverMap.newest().getValue().mState;
return eldestObserverState == newestObserverState && mState == newestObserverState;
}
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一级一级的改变状态
//如果观察者所处的状态和组件的最新状态跨等级，则一步一步的升级而不会跨状态提升
//于此同时状态每次升级，观察者都会拿到一次回调
while ((observer.mState.compareTo(mState) < 0 && !mNewEventOccurred
&& mObserverMap.contains(entry.getKey()))) {
pushParentState(observer.mState);
final Event event = Event.upFrom(observer.mState);
if (event == null) {
throw new IllegalStateException("no event up from " + observer.mState);
}
//此处的observer是一个ObserverWithState类型，它是LifecycleRegistry的静态内部类
//它持有生命周期观察者的引用和它所处的状态
observer.dispatchEvent(lifecycleOwner, event);
popParentState();
}
}
}
private void backwardPass(LifecycleOwner lifecycleOwner) {
Iterator<Map.Entry<LifecycleObserver, ObserverWithState>> descendingIterator =
mObserverMap.descendingIterator();
//backwardPass除了采用倒序降级，其他地方与forwardPass逻辑基本一致。
...
}
//增加新的LifecycleObserver观察者对象
public void addObserver(@NonNull LifecycleObserver observer) {
enforceMainThreadIfNeeded("addObserver");
//如果当前组件不处于DESTROYED状态，那么标记LifecycleObserver的初始状态为INITIALIZED
State initialState = mState == DESTROYED ? DESTROYED : INITIALIZED;
//创建ObserverWithState，为LifecycleObserver赋予状态
ObserverWithState statefulObserver = new ObserverWithState(observer, initialState);
//添加到容器mObserverMap中
ObserverWithState previous = mObserverMap.putIfAbsent(observer, statefulObserver);
//如果previous不为null，表示重复添加，直接结束
if (previous != null) {
return;
}
//判断LifecycleOwner是否已经被销毁
LifecycleOwner lifecycleOwner = mLifecycleOwner.get();
if (lifecycleOwner == null) {
return;
}
//判断是否是重入状态
//例如在LifecycleObserver拿到回调之后又立即添加了监听
boolean isReentrance = mAddingObserverCounter != 0 || mHandlingEvent;
//计算状态
State targetState = calculateTargetState(observer);
//标记正在添加的LifecycleObserver的数量
mAddingObserverCounter++;
//通过一个while循环来将LifecycleObserver的状态设置为最新
//设置的过程和forwardPass一致，逐级改变并且可能会多次触发回调
while ((statefulObserver.mState.compareTo(targetState) < 0
&& mObserverMap.contains(observer))) {
pushParentState(statefulObserver.mState);
final Event event = Event.upFrom(statefulObserver.mState);
if (event == null) {
throw new IllegalStateException("no event up from " + statefulObserver.mState);
}
//分发事件，此处和forwardPass里的一致
statefulObserver.dispatchEvent(lifecycleOwner, event);
popParentState();
targetState = calculateTargetState(observer);
}
if (!isReentrance) {
// we do sync only on the top level.
sync();
}
mAddingObserverCounter--;
}
@Override
public void removeObserver(@NonNull LifecycleObserver observer) {
//移除观察者LifecycleObserver
mObserverMap.remove(observer);
}
//获取当前的生命周期状态
public State getCurrentState() {
return mState;
}
//封装LifecycleObserver和State
//为LifecycleObserver增加状态
//用来和组件的生命周期状态比对
//以判定生命周期是否发生改变以及后续要执行的操作
static class ObserverWithState {
//观察者LifecycleObserver所处的状态
State mState;
LifecycleEventObserver mLifecycleObserver;
ObserverWithState(LifecycleObserver observer, State initialState) {
//处理LifecycleObserver，下文LifecycleObserver小节会讲到
mLifecycleObserver = Lifecycling.lifecycleEventObserver(observer);
mState = initialState;
}
void dispatchEvent(LifecycleOwner owner, Event event) {
//分发状态并修改LifecycleObserver最新的生命周期状态
State newState = event.getTargetState();
mState = min(mState, newState);
mLifecycleObserver.onStateChanged(owner, event);
mState = newState;
}
}
}（1）核心状态管理流程
状态更变入口：
bash
handleLifecycleEvent(Event) 或 setCurrentState(State)
↓
moveToState(目标状态)
↓
更新 mState = 新状态
↓
sync() 同步所有观察者同步过程：
bash
while (!isSynced()) { // 检查是否所有观察者状态一致
if (当前状态 < 最老观察者状态)
backwardPass() // 反向遍历，状态降级
if (当前状态 > 最新观察者状态)
forwardPass() // 正向遍历，状态升级
}（2）观察者通知流程
状态升级（forwardPass）：
bash
正序遍历观察者 (从老到新)
↓
while (观察者状态 < 目标状态)
↓
计算下一级事件 Event.upFrom(当前状态)
↓
观察者.dispatchEvent(事件)
↓
观察者状态 = 事件的目标状态状态降级（backwardPass）：
bash
逆序遍历观察者 (从新到老)
↓
while (观察者状态 > 目标状态)
↓
计算下一级事件 Event.downFrom(当前状态)
↓
观察者.dispatchEvent(事件)
↓
观察者状态 = 事件的目标状态（3）观察者管理流程
添加观察者：
bash
addObserver(观察者)
↓
创建 ObserverWithState(观察者, 初始状态)
↓
while (观察者状态 < 当前组件状态)
↓
逐级分发事件，让观察者同步到最新状态
↓
触发全局同步 sync()移除观察者：
bash
removeObserver(观察者)
↓
直接从 mObserverMap 中移除详细的逻辑已通过代码注释说明，但仍有几点要特别说明一下：
- **间接管理：**ObserverWithState封装
LifecycleRegistry并不会直接持有LifecycleObserver，而是通过将LifecycleObserver作为Key值，使用ObserverWithState存储在FastSafeIterableMap中。
ObserverWithState持有LifecycleObserver，并会持有一个生命周期状态，表示LifecycleObserver当前所收到的状态，用此状态和组件的生命周期状态进行比对，最终判断状态时升级还是降级或者维持不变；
- **双重存储：**FastSafeIterableMap
FastSafeIterableMap继承自SafeIterableMap，内部通过HashMap存储数据，但具备LinkedHashMap的特性，通过双向链表遍历数据，提供了正序和倒序两个迭代器；
- **立即补发：**添加时立即回调
每次添加LifecycleObserver的时候，都会为其绑定初始值State状态（如果组件当前状态不为DESTROYED状态默认为INITIALIZED），同时会与组件当前的状态进行比对，如果状态不同，则立刻触发状态分发机制，LifecycleObserver也会立刻收到回调。也就是LifecycleObserver在注册的时候就可能会立刻触发回调。
- **双向通知：**双向状态改变
状态有两种改变方式，但是都是沿着顺序改变(DESTROYED;INITIALIZED;CREATED;CREATED;STARTED;RESUMED)一种是通过forwardPass进行升状态，只处理向RESUMED方向转化的状态，一种是backwardPass进行降状态，只处理向DESTROYED方向转化的状态。前者采用正序通知观察者回调，后者逆序。
- **逐级变化：**不跳级，多次回调
状态时逐级分发调用的，不会跨级分发。状态改变后（或者添加监听时），相差多少级就会通过补发Event的方式触发多次分发以及回调。
- 多重防护：防递归机制
mHandlingEvent标记：正在处理事件时，新事件会被延迟，防止处理过程中 的新事件立即执行，避免栈溢出
mParentStates 栈：防止观察者回调中再次触发事件
mNewEventOccurred标记：处理过程中有新事件，重新同步，确保延迟事件 得到处理，同时防止事件丢失
1.2.4 LifecycleObserver
java
package androidx.lifecycle;
/**
* Marks a class as a LifecycleObserver. It does not have any methods, instead, relies on
* {@link OnLifecycleEvent} annotated methods.
* <p>
* @see Lifecycle Lifecycle - for samples and usage patterns.
*/
@SuppressWarnings("WeakerAccess")
public interface LifecycleObserver {
}LifecycleObserver类是一个接口，它更多的起到类型或者身份标记的作用。它本身是一个空接口
LifecycleEventObserver是最简单的实现：只提供了onStateChanged方法用于获取事件和当前的状态。
java
public interface LifecycleEventObserver extends LifecycleObserver {
onStateChanged(@NonNull LifecycleOwner source, @NonNull Lifecycle.Event event);
}可能你会疑惑：LifecycleRegistry是如何区分这些观察者的具体类型的呢，毕竟它只提供了一个addObserver(LifecycleObserver)方法。
答案就在LifecycleRegistry的内部类ObserverWithState中。在上文LifecycleRegistry的addObserver中，我们已经知道：LifecycleRegistry不会直接存储LifecycleObserver，而是通过ObserverWithState持有。它的构造方法如下：
java
static class ObserverWithState {
State mState;
LifecycleEventObserver mLifecycleObserver;
ObserverWithState(LifecycleObserver observer, State initialState) {
mLifecycleObserver = Lifecycling.lifecycleEventObserver(observer);
mState = initialState;
}
}重点看Lifecycling.lifecycleEventObserver(observer)这段代码。
java
static LifecycleEventObserver lifecycleEventObserver(Object object) {
//判断Observer的类型
boolean isLifecycleEventObserver = object instanceof LifecycleEventObserver;
boolean isFullLifecycleObserver = object instanceof FullLifecycleObserver;
//如果Observer同时实现了LifecycleEventObserver和FullLifecycleObserver
//通过FullLifecycleObserverAdapter包装它，并为FullLifecycleObserverAdapter的
//两个变量fullLifecycleObserver和lifecycleEventObserver进行赋值。以便回调所有相关的方法。
if (isLifecycleEventObserver && isFullLifecycleObserver) {
return new FullLifecycleObserverAdapter((FullLifecycleObserver) object,
(LifecycleEventObserver) object);
}
//如果只实现了FullLifecycleObserver，进行包装，但为FullLifecycleObserverAdapter.lifecycleEventObserver
//赋值为空。不进行它的回调
if (isFullLifecycleObserver) {
return new FullLifecycleObserverAdapter((FullLifecycleObserver) object, null);
}
//LifecycleEventObserver类型，无需处理直接返回
if (isLifecycleEventObserver) {
return (LifecycleEventObserver) object;
}
//通过反射处理用户自定义的回调实现
final Class<?> klass = object.getClass();
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);
}
return new CompositeGeneratedAdaptersObserver(adapters);
}
return new ReflectiveGenericLifecycleObserver(object);
}可以发现：在每次添加监听的时候，都会通过Lifecycling进行类型判断，从而确保LifecycleRegistry能正确触发不同观察者的回调事件。
另外，LifecycleEventObserver还有一个常用的实现：LifecycleBoundObserver。它是LiveData的内部类，正是它赋予了LiveData生命周期感知能力了，这个后面会介绍。
1.2.5 事件生产者
通过对LifeCycle的各个角色介绍，我们已经知道了生命周期事件分发和状态的流转处理方式了。LifecycleRegistry通过暴露handleLifecycleEvent方法接受事件，并进行后续处理 。消费端的逻辑已经明确了。接下来就是寻找事件源了：也就是LifeCycle所处理的事件是如何产生的。
上文中讲到过，ComponentActivity实现LifecycleOwner接口，它就是一个能提供事件的生产者。但是它却不直接在自己的生命周期方法里低调用handleLifecycleEvent方法 ，而是通过ReportFragment进行。
java
protected void onCreate(@Nullable Bundle savedInstanceState) {
mSavedStateRegistryController.performRestore(savedInstanceState);
mContextAwareHelper.dispatchOnContextAvailable(this);
super.onCreate(savedInstanceState);
mActivityResultRegistry.onRestoreInstanceState(savedInstanceState);
ReportFragment.injectIfNeededIn(this);
if (mContentLayoutId != 0) {
setContentView(mContentLayoutId);
}
}看一下ReportFragment.injectIfNeededIn做了什么：
java
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();
}
}injectIfNeededIn分了两种情况进行处理：
（1）版本号>=29
如果系统版本号>= 29，会向 Activity绑定一个LifecycleCallbacks ，直接进行生命周期监听。 LifecycleCallbacks.registerIn的部分代码如下：
java
static class LifecycleCallbacks implements Application.ActivityLifecycleCallbacks {
static void registerIn(Activity activity) {
activity.registerActivityLifecycleCallbacks(new LifecycleCallbacks());
}
@Override
public void onActivityCreated(@NonNull Activity activity,
@Nullable Bundle bundle) {
}
@Override
public void onActivityPostCreated(@NonNull Activity activity,
@Nullable Bundle savedInstanceState) {
dispatch(activity, Lifecycle.Event.ON_CREATE);
}
.....
}它实现了Application.ActivityLifecycleCallbacks接口，并向Activity进行了注册。
其中的dispatch方法实现如下：
java
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);
}
}
}就是在这里调用了LifecycleRegistry的handleLifecycleEvent方法，让他进行事件处理和分发。
而在Activity内，每当生命周期方法被触发。都会遍历ActivityLifecycleCallbacks然后进行回调。以onPause为例，相关代码如下：
java
private final ArrayList<Application.ActivityLifecycleCallbacks> mActivityLifecycleCallbacks =
new ArrayList<Application.ActivityLifecycleCallbacks>();
protected void onPause() {
...
dispatchActivityPaused();
...
}
//分发事件
private void dispatchActivityPaused() {
Object[] callbacks = collectActivityLifecycleCallbacks();
if (callbacks != null) {
for (int i = callbacks.length - 1; i >= 0; i--) {
//遍历注册的对象，并依次触发
((Application.ActivityLifecycleCallbacks) callbacks[i]).onActivityPaused(this);
}
}
getApplication().dispatchActivityPaused(this);
}
//返回所有的注册回调对象
private Object[] collectActivityLifecycleCallbacks() {
Object[] callbacks = null;
synchronized (mActivityLifecycleCallbacks) {
if (mActivityLifecycleCallbacks.size() > 0) {
callbacks = mActivityLifecycleCallbacks.toArray();
}
}
return callbacks;
}
//添加callBack
public void registerActivityLifecycleCallbacks(
@NonNull Application.ActivityLifecycleCallbacks callback) {
synchronized (mActivityLifecycleCallbacks) {
mActivityLifecycleCallbacks.add(callback);
}
}就是一个很简单的回调。
（2）版本号<29
而对于系统版本号小于小于29的。则会向Activity添加一个无 UI 界面的ReportFragment实现监听，摘录一些ReportFragment的生命周期方法：
java
@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);
}
@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);
// just want to be sure that we won't leak reference to an activity
mProcessListener = null;
}
private void dispatch(@NonNull Lifecycle.Event event) {
if (Build.VERSION.SDK_INT < 29) {
// Only dispatch events from ReportFragment on API levels prior
// to API 29\. On API 29+, this is handled by the ActivityLifecycleCallbacks
// added in ReportFragment.injectIfNeededIn
dispatch(getActivity(), event);
}
}最终还是通过dispatch方法调用了LifecycleRegistry的handleLifecycleEvent方法，让他进行事件处理和分发。
只所以这样区分版本号，是registerActivityLifecycleCallbacks在Api 29时才被添加。
而在androidx.fragment.app.Fragment就简单粗暴的多了，已RESUME为例：
java
LifecycleRegistry mLifecycleRegistry;
public Fragment() {
initLifecycle();
}
private void initLifecycle() {
mLifecycleRegistry = new LifecycleRegistry(this);
...
}
public Lifecycle getLifecycle() {
return mLifecycleRegistry;
}
void performResume() {
...
onResume();
mLifecycleRegistry.handleLifecycleEvent(Lifecycle.Event.ON_RESUME);
..
}就是简单粗暴的在相关生命周期方法执行时直接通过LifecycleRegistry.handleLifecycleEvent发送事件。