Jetpack源码解读(一)——Lifecycle

一、Activity对LifecycleOwner的实现

众所周知，平时我们最常用的AppCompatActivity 是已经实现了LifecycleOwner 接口的，我们可以直接通过对应的 get 方法获取Lifecycle对象。

但是他是在什么时候实现的呢？

继承链路图如下：

通过阅读源码，我们很容易发现ComponentActivity这个类实现了LifecycleOwner接口，重写了getLifecycle()方法。

kotlin 复制代码

public interface LifecycleOwner {
	public val lifecycle: Lifecycle
}

less 复制代码

public class ComponentActivity implements LifecycleOwner{
	@NonNull
    @Override
    public Lifecycle getLifecycle() {
        return mLifecycleRegistry;
    }
}

这个接口就只有一个成员变量，总不能实现下就能解决问题吧，那具体的逻辑到底在哪呢，他是如何感知生命周期变化的呢？如果让你去感知生命周期你会怎么写呢？最显而易见的方法肯定就是重写 onCreate等一系列方法呀，LifeCycle源码部分会不会也这样写呢？

二、LifeCycle 的底层回调

再来看一下ComponentActivity的onCreate方法，里面涉及到一个ReportFragment类。调用了这个类的一个静态方法：injectIfNeededIn。

less 复制代码

public class ComponentActivity implements LifecycleOwner{
	@OptIn(markerClass = BuildCompat.PrereleaseSdkCheck.class)
    @Override
    protected void onCreate(@Nullable Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        ReportFragment.injectIfNeededIn(this);
    }
}

在这个方法中我们发现：在API29+上，我们可以直接注册正确的生命周期回调，也就是调用LifecycleCallbacks.registerIn 方法，而如果是低版本的话就是讲这个隐形的 fragment添加到 activity 中去感知生命周期的变化。

kotlin 复制代码

@JvmStatic
public fun injectIfNeededIn(activity: Activity) {
	if (Build.VERSION.SDK_INT >= 29) {
		//在API29+上，我们可以直接注册正确的生命周期回调
		LifecycleCallbacks.registerIn(activity)
	}
	
	val manager = activity.fragmentManager
	if (manager.findFragmentByTag(REPORT_FRAGMENT_TAG) == null) {
		manager.beginTransaction().add(ReportFragment(), REPORT_FRAGMENT_TAG).commit()
		//希望我们是第一个达成交易的人
		manager.executePendingTransactions()
	}
}

学习当然要学最新的，但是旧的也不能抛弃，这里我就不讲旧的了，你们感兴趣的可以自己去看看，逻辑其实和新的差不多的。

看到LifecycleCallbacks其实是ReportFragment 的内部类，看一下名字，Callback哈哈，一下就能猜到了一定是在这里回调的生命周期方法，而且你看这里有一系列类似于onActivityStarted和onActivityPostStarted的生命周期方法（他们长得都很类似，这里我就只保留了Started 和Created的方法）。

kotlin 复制代码

public open class ReportFragment() : android.app.Fragment() {
	public companion object {
		@JvmStatic
		public fun injectIfNeededIn(activity: Activity) {
			if (Build.VERSION.SDK_INT >= 29) {
				//在API 29+上，我们可以直接注册正确的生命周期回调
				LifecycleCallbacks.registerIn(activity)
			}

			val manager = activity.fragmentManager
			if (manager.findFragmentByTag(REPORT_FRAGMENT_TAG) == null) {
				manager.beginTransaction().add(ReportFragment(), REPORT_FRAGMENT_TAG).commit()
				manager.executePendingTransactions()
			}
		}
	}

	@RequiresApi(29)
	internal class LifecycleCallbacks : Application.ActivityLifecycleCallbacks {
		override fun onActivityCreated(
			activity: Activity,
			bundle: Bundle?
				) {}

		override fun onActivityPostCreated(
			activity: Activity,
			savedInstanceState: Bundle?
				) {
			dispatch(activity, Lifecycle.Event.ON_CREATE)
		}

		override fun onActivityStarted(activity: Activity) {}

		override fun onActivityPostStarted(activity: Activity) {
			dispatch(activity, Lifecycle.Event.ON_START)
		}

		//省略了其他生命周期方法

		companion object {
			@JvmStatic
			fun registerIn(activity: Activity) {
				activity.registerActivityLifecycleCallbacks(LifecycleCallbacks())
			}
		}
	}
}

上面为什么有两个Started的回调呢？有什么区别吗？

onActivityStarted用于响应 Activity 进入前台的最早时刻，但此时可能尚未完成布局渲染或数据加载。

onActivityPostStarted确保所有 onStart() 内部逻辑已完成，适合执行需要依赖 onStart() 初始化完成的操作（如启动动画）。

然后就是进入到注册回调的地方看一下了。这里也只保留Started 和Created的方法。

scss 复制代码

public class Activity{
	private final ArrayList<Application.ActivityLifecycleCallbacks> mActivityLifecycleCallbacks =
            new ArrayList<Application.ActivityLifecycleCallbacks>();
	
	public void registerActivityLifecycleCallbacks(
		@NonNull Application.ActivityLifecycleCallbacks callback) {
		synchronized (mActivityLifecycleCallbacks) {
			mActivityLifecycleCallbacks.add(callback);
		}
	}

    private void dispatchActivityCreated(@Nullable Bundle savedInstanceState) {
        getApplication().dispatchActivityCreated(this, savedInstanceState);
        Object[] callbacks = collectActivityLifecycleCallbacks();
        if (callbacks != null) {
            for (int i = 0; i < callbacks.length; i++) {
                ((Application.ActivityLifecycleCallbacks) callbacks[i]).onActivityCreated(this,
                        savedInstanceState);
            }
        }
    }

    private void dispatchActivityPostCreated(@Nullable Bundle savedInstanceState) {
        Object[] callbacks = collectActivityLifecycleCallbacks();
        if (callbacks != null) {
            for (int i = 0; i < callbacks.length; i++) {
                ((Application.ActivityLifecycleCallbacks) callbacks[i]).onActivityPostCreated(this,
                        savedInstanceState);
            }
        }
        getApplication().dispatchActivityPostCreated(this, savedInstanceState);
    }

    private void dispatchActivityStarted() {
        getApplication().dispatchActivityStarted(this);
        Object[] callbacks = collectActivityLifecycleCallbacks();
        if (callbacks != null) {
            for (int i = 0; i < callbacks.length; i++) {
                ((Application.ActivityLifecycleCallbacks) callbacks[i]).onActivityStarted(this);
            }
        }
    }

    private void dispatchActivityPostStarted() {
        Object[] callbacks = collectActivityLifecycleCallbacks();
        if (callbacks != null) {
            for (int i = 0; i < callbacks.length; i++) {
                ((Application.ActivityLifecycleCallbacks) callbacks[i])
                        .onActivityPostStarted(this);
            }
        }
        getApplication().dispatchActivityPostStarted(this);
    }
	
	private Object[] collectActivityLifecycleCallbacks() {
        Object[] callbacks = null;
        synchronized (mActivityLifecycleCallbacks) {
            if (mActivityLifecycleCallbacks.size() > 0) {
                callbacks = mActivityLifecycleCallbacks.toArray();
            }
        }
        return callbacks;
    }
}

继续看这些方法在什么地方调用的，打开 Activity类，看到在 onCreate方法中调用了dispatchActivityCreated方法，这也和前面的就形成了一个闭环，最终的逻辑走到了 dispatch 里面去了，也就搞清楚了它是怎么感知生命周期变化的了。

less 复制代码

public class Activity{
	protected void onCreate(@Nullable Bundle savedInstanceState) {
		//省略一系列代码
		mFragments.dispatchCreate();
		dispatchActivityCreated(savedInstanceState);
		//省略一系列代码
	}	
}

画个图，总结一下。我画的是总体的逻辑图，为了帮你们更好的理解，我先放出来，可以先看一下左上角我们上面讲到了的部分。

圆角方形：类
椭圆形：方法
普通箭头：方法调用链
空性箭头：继承
虚线：方法属于哪一类

三、事件分发逻辑

上面说走到了 dispatch()的逻辑之中，看到这个单词，就立马反应过来，开始分发阶段了。

dispatch()是一个静态方法。写在ReportFragment类的companion object中

kotlin 复制代码

@JvmStatic
internal fun dispatch(activity: Activity, event: Lifecycle.Event) {
	if (activity is LifecycleRegistryOwner) {
		activity.lifecycle.handleLifecycleEvent(event)
		return
	}
	if (activity is LifecycleOwner) {
		val lifecycle = (activity as LifecycleOwner).lifecycle
		if (lifecycle is LifecycleRegistry) {
			lifecycle.handleLifecycleEvent(event)
		}
	}
}

LifecycleRegistryOwner已经被deprecated标记，也就是强烈反对使用的了。Google 推荐直接使用 LifecycleOwner + LifecycleRegistry 组合，减少中间层。

java 复制代码

/** @deprecated */
@Deprecated
public interface LifecycleRegistryOwner extends LifecycleOwner {
	@NonNull
	LifecycleRegistry getLifecycle();
}

看一下LifecycleRegistry 的handleLifecycleEvent()方法。

kotlin 复制代码

public actual open fun handleLifecycleEvent(event: Event) {
	enforceMainThreadIfNeeded("handleLifecycleEvent")
	moveToState(event.targetState)
}

我们先回过头看一下 Lifecycle 类，里面的关键是两个方法和两个枚举类，这里区分一下Event 事件和State状态，一个是过程一个是状态，状态与事件的转变里面也提供了一些静态方法。

这种状态改变可以用官网的一张图来概括：

kotlin 复制代码

public abstract class Lifecycle {
	@MainThread
	public abstract fun addObserver(observer: LifecycleObserver)

	@MainThread
	public abstract fun removeObserver(observer: LifecycleObserver)

	public enum class Event {
		ON_CREATE,
		ON_START,
		ON_RESUME,
		ON_PAUSE,
		ON_STOP,
		ON_DESTROY,
		ON_ANY;

		public val targetState: State
		get() {
			when (this) {
				ON_CREATE, ON_STOP -> return State.CREATED
				ON_START, ON_PAUSE -> return State.STARTED
				ON_RESUME -> return State.RESUMED
				ON_DESTROY -> return State.DESTROYED
				ON_ANY -> {}
			}
			throw IllegalArgumentException("$this has no target state")
		}

		public companion object {
			@JvmStatic
			public fun downFrom(state: State): Event? {
				return when (state) {
					State.CREATED -> ON_DESTROY
					State.STARTED -> ON_STOP
					State.RESUMED -> ON_PAUSE
					else -> null
				}
			}

			@JvmStatic
			public fun downTo(state: State): Event? {
				return when (state) {
					State.DESTROYED -> ON_DESTROY
					State.CREATED -> ON_STOP
					State.STARTED -> ON_PAUSE
					else -> null
				}
			}

            @JvmStatic
            public fun upFrom(state: State): Event? {
                return when (state) {
                    State.INITIALIZED -> ON_CREATE
                    State.CREATED -> ON_START
                    State.STARTED -> ON_RESUME
                    else -> null
                }
            }

            @JvmStatic
            public fun upTo(state: State): Event? {
                return when (state) {
                    State.CREATED -> ON_CREATE
                    State.STARTED -> ON_START
                    State.RESUMED -> ON_RESUME
                    else -> null
                }
            }
        }
    }

	public enum class State {
        DESTROYED,
        INITIALIZED,
        CREATED,
        STARTED,
        RESUMED;

        public fun isAtLeast(state: State): Boolean {
            return compareTo(state) >= 0
        }
    }
}

接收的是事件，要转换为状态，调用的moveToState()方法，应该走到它的下一个对应状态上去，但是如果观察者和宿主的生命周期不同步，那就调用sync()方法把生命周期状态同步给所有观察者。

kotlin 复制代码

private fun moveToState(next: State) {
    // 状态未变化时直接返回（幂等性处理）
    if (state == next) {
        return
    }
    
    // 校验非法状态迁移：INITIALIZED -> DESTROYED 是禁止的
    check(!(state == State.INITIALIZED && next == State.DESTROYED)) {
        "State must be at least CREATED to move to $next, but was $state in component " +
        "${lifecycleOwner.get()}"
    }
    
    // 更新当前状态记录
    state = next
    
    // 若当前正在处理其他事件或添加观察者，标记新事件发生并延迟处理
    if (handlingEvent || addingObserverCounter != 0) {
        newEventOccurred = true // 标记需要后续处理
        return // 退出当前处理流程，由上层逻辑处理
    }
    
    // 开始处理事件（防止重入）
    handlingEvent = true
    sync() // 核心：执行状态同步流程（触发观察者事件分发）
    handlingEvent = false
    
    // 若最终状态为 DESTROYED，清理观察者集合（防止内存泄漏）
    if (state == State.DESTROYED) {
        observerMap = FastSafeIterableMap() // 重置为空的快速安全迭代集合
    }
}

kotlin 复制代码

private fun sync() {
    // 获取绑定的 LifecycleOwner，若已被回收则抛出异常（防止在无效状态下操作）
    val lifecycleOwner = lifecycleOwner.get()
        ?: throw IllegalStateException(
            "LifecycleOwner of this LifecycleRegistry is already " +
                "garbage collected. It is too late to change lifecycle state."
        )
    
    // 循环处理状态同步，直到所有观察者状态一致（可能需要多次 forward/backward 调用）
    while (!isSynced) {
        newEventOccurred = false // 重置新事件标记
        
        // 向后同步：若当前状态 < 最旧观察者的状态（需降级观察者状态）
        // 场景：系统状态回退（如 Activity 进入 onPause）
        if (state < observerMap.eldest()!!.value.state) {
            backwardPass(lifecycleOwner) // 示例：RESUMED -> STARTED -> CREATED
        }
        
        // 向前同步：若当前状态 > 最新观察者的状态（需升级观察者状态）
        // 条件：无新事件打断 && 存在观察者 && 系统状态高于观察者
        val newest = observerMap.newest()
        if (!newEventOccurred && newest != null && state > newest.value.state) {
            forwardPass(lifecycleOwner) // 示例：CREATED -> STARTED -> RESUMED
        }
    }
    
    // 同步完成后，重置事件标记并更新状态流
    newEventOccurred = false
    _currentStateFlow.value = currentState // 通过 StateFlow 对外发布最新状态
}

sync 中用一个 while 循环将状态同步一下。也就是说：如果在宿主的onResume生命周期注册一个observer需要把宿主的oncreate,onstart,onresume都分发给observer。

其核心逻辑是：当观察者（LifecycleObserver）注册时，会立即收到从初始状态到当前状态的所有生命周期事件。

kotlin 复制代码

private fun backwardPass(lifecycleOwner: LifecycleOwner) {
	// 获取观察者列表的降序迭代器（从状态高的观察者向状态低的遍历）
	val descendingIterator = observerMap.descendingIterator()

	// 遍历所有观察者，直到处理完或检测到新事件发生
	while (descendingIterator.hasNext() && !newEventOccurred) {
		// 获取当前观察者及其标识
		val (key, observer) = descendingIterator.next()

		// 循环处理：当观察者状态高于当前系统状态时，持续回退其状态
		while (
			observer.state > state &&              // 观察者状态高于目标状态
				!newEventOccurred &&                     // 无新事件打断
				observerMap.contains(key)               // 观察者未被移除
		) {
			// 获取向下迁移的事件（如 RESUMED -> ON_PAUSE -> STARTED）
			val event = Event.downFrom(observer.state) 
			?: throw IllegalStateException("无法从状态 ${observer.state} 生成向下事件")

			// 更新父状态栈，确保事件分发时状态一致性
			pushParentState(event.targetState)

			// 向观察者分发生命周期事件（触发其状态回退）
			observer.dispatchEvent(lifecycleOwner, event)

			// 恢复父状态栈
			popParentState()
		}
	}
}

简单看一下状态后退的逻辑，和前进的逻辑是一样的。

kotlin 复制代码

private fun backwardPass(lifecycleOwner: LifecycleOwner) {
	val descendingIterator = observerMap.descendingIterator()
	while (descendingIterator.hasNext() && !newEventOccurred) {
		val (key, observer) = descendingIterator.next()
		while (observer.state > state && !newEventOccurred && observerMap.contains(key)
				  ) {
			val event = Event.downFrom(observer.state)
			?: throw IllegalStateException("no event down from ${observer.state}")
			pushParentState(event.targetState)
			observer.dispatchEvent(lifecycleOwner, event)
			popParentState()
		}
	}
}

这个又出现一个dispatchEvent但是主体变成看observer，看到LifecycleRegistry 的内部类ObserverWithState，这里终于出现了Observer。

kotlin 复制代码

internal class ObserverWithState(observer: LifecycleObserver?, initialState: State) {
	var state: State
	var lifecycleObserver: LifecycleEventObserver

	init {
		lifecycleObserver = Lifecycling.lifecycleEventObserver(observer!!)
		state = initialState
	}

	fun dispatchEvent(owner: LifecycleOwner?, event: Event) {
		val newState = event.targetState
		state = min(state, newState)
		lifecycleObserver.onStateChanged(owner!!, event)
		state = newState
	}
}

既然出现了观察者，我们这里就先介绍一下Observer是如何观察上宿主的。

Android 官方只推荐使用两种方法：

① 实现DefaultLifecycleObserver接口，实现对应的生命周期方法。

kotlin 复制代码

class MyLifecycleObserver :DefaultLifecycleObserver {
	override fun onCreate(owner: LifecycleOwner) {
		super.onCreate(owner)
		Log.d("BaseViewModel", "onCreate")
	}
	override fun onStart(owner: LifecycleOwner) {
		super.onStart(owner)
		Log.d("BaseViewModel", "onStart")
	}
}

② 实现LifecycleEventObserver接口，实现onStateChanged方法。

kotlin 复制代码

class MyLifecycleObserver : LifecycleEventObserver {
    override fun onStateChanged(source: LifecycleOwner, event: Lifecycle.Event) {
        when (event) {
            Lifecycle.Event.ON_CREATE -> {
                println("Lifecycle: ON_CREATE")
            }
            Lifecycle.Event.ON_START -> {
                println("Lifecycle: ON_START")
            }
        }
    }
}

但是上面方法调用链路中的dispatchEvent()是在ObserverWithState类中的，所以我们猜测这个类和我们注册时候用的DefaultLifecycleObserver和LifecycleEventObserver肯定有什么小秘密。

四、观察者添加逻辑

activity 会持有一个 lifecycle，要添加一个观察者我们只需要调用addObserver 方法。但是上面注册的时候是有两个接口供我们选用，但是无论是哪种，最终都会被封装成ObserverWithState，这个类我们之前也见过，是它持有了dispatchEvent方法。

kotlin 复制代码

public actual open class LifecycleRegistry: Lifecycle() {

	private var observerMap = FastSafeIterableMap<LifecycleObserver, ObserverWithState>()

	
	override fun addObserver(observer: LifecycleObserver) {
		enforceMainThreadIfNeeded("addObserver")
		val initialState = if (state == State.DESTROYED) State.DESTROYED else State.INITIALIZED
		val statefulObserver = ObserverWithState(observer, initialState)
		val previous = observerMap.putIfAbsent(observer, statefulObserver)
		if (previous != null) {
			return
		}
		val lifecycleOwner = lifecycleOwner.get()
		?: // it is null we should be destroyed. Fallback quickly
		return
		val isReentrance = addingObserverCounter != 0 || handlingEvent
		var targetState = calculateTargetState(observer)
		addingObserverCounter++
		while (statefulObserver.state < targetState && observerMap.contains(observer)
			  ) {
			pushParentState(statefulObserver.state)
			val event = Event.upFrom(statefulObserver.state)
			?: throw IllegalStateException("no event up from ${statefulObserver.state}")
			statefulObserver.dispatchEvent(lifecycleOwner, event)
			popParentState()
			// mState / subling may have been changed recalculate
			targetState = calculateTargetState(observer)
		}
		if (!isReentrance) {
			// we do sync only on the top level.
			sync()
		}
		addingObserverCounter--
	}
}

在 init 中调用Lifecycling.lifecycleEventObserver对observer对象进行调整。

csharp 复制代码

internal class ObserverWithState(observer: LifecycleObserver?, initialState: State) {
	var state: State
	var lifecycleObserver: LifecycleEventObserver

	init {
		lifecycleObserver = Lifecycling.lifecycleEventObserver(observer!!)
		state = initialState
	}
}

这里见到了LifecycleEventObserver和DefaultLifecycleObserver，最后返回的是DefaultLifecycleObserverAdapter。

kotlin 复制代码

@JvmStatic
@Suppress("DEPRECATION")
public actual fun lifecycleEventObserver(`object`: Any): LifecycleEventObserver {
	val isLifecycleEventObserver = `object` is LifecycleEventObserver
	val isDefaultLifecycleObserver = `object` is DefaultLifecycleObserver
	if (isLifecycleEventObserver && isDefaultLifecycleObserver) {
		return DefaultLifecycleObserverAdapter(
			`object` as DefaultLifecycleObserver,
			`object` as LifecycleEventObserver
		)
	}
	if (isDefaultLifecycleObserver) {
		return DefaultLifecycleObserverAdapter(`object` as DefaultLifecycleObserver, null)
	}
	if (isLifecycleEventObserver) {
		return `object` as LifecycleEventObserver
	}
	//省略一些代码
}

DefaultLifecycleObserverAdapter 是 Android 生命周期库中的桥接组件， 将 DefaultLifecycleObserver 的细粒度生命周期方法适配到 LifecycleEventObserver 的 onStateChanged() 方法中。

允许同时持有一个 DefaultLifecycleObserver 和 LifecycleEventObserver。先调用 DefaultLifecycleObserver 的具体方法 → 再调用 LifecycleEventObserver 的 onStateChanged()。

kotlin 复制代码

internal class DefaultLifecycleObserverAdapter(
	private val defaultLifecycleObserver: DefaultLifecycleObserver,
	private val lifecycleEventObserver: LifecycleEventObserver?
		) : LifecycleEventObserver {
	override fun onStateChanged(source: LifecycleOwner, event: Lifecycle.Event) {
		when (event) {
			Lifecycle.Event.ON_CREATE -> defaultLifecycleObserver.onCreate(source)
			Lifecycle.Event.ON_START -> defaultLifecycleObserver.onStart(source)
			Lifecycle.Event.ON_RESUME -> defaultLifecycleObserver.onResume(source)
			Lifecycle.Event.ON_PAUSE -> defaultLifecycleObserver.onPause(source)
			Lifecycle.Event.ON_STOP -> defaultLifecycleObserver.onStop(source)
			Lifecycle.Event.ON_DESTROY -> defaultLifecycleObserver.onDestroy(source)
			Lifecycle.Event.ON_ANY ->
			throw IllegalArgumentException("ON_ANY must not been send by anybody")
		}
		lifecycleEventObserver?.onStateChanged(source, event)
	}
}

到这里就形成了一个闭环，终于搞清楚属主和观察者注册运行的逻辑。

Jetpack源码解读(一)——Lifecycle

一、Activity对LifecycleOwner的实现

二、LifeCycle 的底层回调

三、事件分发逻辑

四、观察者添加逻辑

五、总结一下