一、Android Jetpack简介
Android官网对Jetpack的介绍如下：
Jetpack is a suite of libraries to help developers follow best practices, reduce boilerplate code, and write code that works consistently across Android versions and devices so that developers can focus on the code they care about.
可见Jetpack是一个由多个库组成的套件，使用这个套件可以帮助开发者：
- 遵循最佳实践：
Jetpack提供的组件基于最新的设计方法构建，可以减少崩溃和内存泄漏等问题的出现； - 减少样板代码：
Jetpack提供的组件提供对繁琐的生命周期、后台任务的管理，帮助开发者实现可维护的代码； - 减少差异：实现在不同版本和设备上表现一致的应用，开发者可以集中精力编写对他们来说真正重要的代码，而不是各种版本兼容的代码。
Android官网上对Jetpack组成部分的分类如下图所示（最新官网无下图）：
Android提供的Jetpack一共分为四个部分：架构、基础、UI和行为，其中Android Architecture Component是各个应用使用最多的部分，通常在工程中使用Lifecycle、LiveData以及ViewModel来实现MVVM架构，因此下面会这三个组件进行分析，本文主要对Lifecycle这个生命周期感知型组件进行分析，其他两个组件的分析见下面链接：
浅析Android Jetpack ACC之LiveData
浅析Android Jetpack ACC之ViewModel
二、Lifecycle-生命周期感知组件
Lifecycle用于管理Activity/Fragment等组件的生命周期并在生命周期发生变化时通知给已注册的生命周期观察者。
1. 作用目的
Lifecycle组件在Android源码层面实现了生命周期的管理和分发，开发者基于Lifecycle组件相关的接口可以无需在各个生命周期回调方法中添加各种各样的业务代码，而是将业务代码聚合到一个观察者类中进行实现，有助于提高代码的可维护性。下面给出没有使用Lifecycle组件时在一个页面中展示当前所在位置的代码。
class LocationActivity : ComponentActivity() {
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
setContentView(R.layout.activity_location)
}
override fun onStart() {
super.onStart()
LocationImpl.startLocation(object: LocationImpl.LocationListener {
override fun onLocationChanged(location: LocationImpl.Location) {
runOnUiThread {
// update location
}
}
})
}
override fun onStop() {
super.onStop()
LocationImpl.stopLocation()
}
}
可以看到，定位的启动和停止直接写在Activity的生命周期方法中，如果类似的业务逻辑变多，那么Activity的生命周期方法将会充斥着各种各样的业务逻辑，整个Activity的代码将会变得臃肿，可维护性大大降低。
此外，如果业务逻辑会间接引用Activity对象，那么还可能出现内存泄漏的问题，因为业务逻辑无法知道Activity是否销毁，所以无法及时释放Activity对象。
下面看看使用Lifecycle组件后的实现，对比两者将会发现Lifecycle组件的作用是很明显的。
2. 使用示例
Lifecycle组件的使用步骤主要包括：
- 通过对
Activity/Fragment等具备生命周期的组件（即LifecycleOwner）调用getLifecycle()方法获取Lifecycle实例，然后调用Lifecycle#addObserve方法添加自定义的生命周期观察者； - 通过实现
LifecycleEventObserver或者DefaultLifecycleObserver接口来处理对应的生命周期状态，或者实现LifecycleObserver接口并在方法上添加OnLifecycleEvent注解来观察相应的生命周期状态，生命周期状态转换后自动调用此方法。
class LocationActivity : ComponentActivity() {
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
setContentView(R.layout.activity_location)
lifecycle.addObserver(LocationObserver(object: LocationImpl.LocationListener {
override fun onLocationChanged(location: LocationImpl.Location) {
runOnUiThread {
updateLocation(location)
}
}
}))
}
fun updateLocation(location: LocationImpl.Location) {
// update location
}
}
class LocationObserver(private val locationListener: LocationImpl.LocationListener) : LifecycleEventObserver {
override fun onStateChanged(source: LifecycleOwner, event: Lifecycle.Event) {
when (event) {
Lifecycle.Event.ON_START -> {
LocationImpl.startLocation(locationListener)
}
Lifecycle.Event.ON_STOP -> {
LocationImpl.stopLocation()
}
else -> {
// do nothing
}
}
}
}
可以看到，定位的逻辑已经收敛到LocationObserver这个类中了，LocationActivity中的代码逻辑变得更加简洁明了。
3. 实现原理
Lifecycle的实现主要分为两部分：
Activity/Fragment组件的生命周期是如何监听的？Activity/Fragment组件的生命周期是如何通知给观察者进行处理的？
3.1 生命周期的监听
// androidx.core.app.ComponentActivity
public open class ComponentActivity : Activity(), LifecycleOwner, KeyEventDispatcher.Component {
/**
* This is only used for apps that have not switched to Fragments 1.1.0, where this behavior is
* provided by `androidx.activity.ComponentActivity`.
*/
@Suppress("LeakingThis") private val lifecycleRegistry = LifecycleRegistry(this)
override val lifecycle: Lifecycle
get() = lifecycleRegistry
}
// androidx.activity.ComponentActivity
open class ComponentActivity() : androidx.core.app.ComponentActivity(),
ContextAware,
LifecycleOwner, // 实现了LifecycleOwner接口，管理生命周期
ViewModelStoreOwner,
HasDefaultViewModelProviderFactory,
SavedStateRegistryOwner,
OnBackPressedDispatcherOwner,
ActivityResultRegistryOwner,
ActivityResultCaller,
OnConfigurationChangedProvider,
OnTrimMemoryProvider,
OnNewIntentProvider,
OnMultiWindowModeChangedProvider,
OnPictureInPictureModeChangedProvider,
OnUserLeaveHintProvider,
MenuHost,
FullyDrawnReporterOwner {
// ...
override fun onCreate(savedInstanceState: Bundle?) {
// Restore the Saved State first so that it is available to
// OnContextAvailableListener instances
savedStateRegistryController.performRestore(savedInstanceState)
contextAwareHelper.dispatchOnContextAvailable(this)
super.onCreate(savedInstanceState)
// 生命周期管理的入口
ReportFragment.injectIfNeededIn(this)
if (contentLayoutId != 0) {
setContentView(contentLayoutId)
}
}
// ...
}
androidx.core.app.ComponentActivity类中定义了类型为LifecycleRegistry的成员变量，在androidx.activity.ComponentActivity#onCreate方法中调用ReportFragment#injectIfNeededIn进行监听生命周期的准备工作。
public open class ReportFragment() : android.app.Fragment() {
@RequiresApi(29)
internal class LifecycleCallbacks : Application.ActivityLifecycleCallbacks {
companion object {
@JvmStatic
fun registerIn(activity: Activity) {
activity.registerActivityLifecycleCallbacks(LifecycleCallbacks())
}
}
}
public companion object {
@JvmStatic
public fun injectIfNeededIn(activity: Activity) {
if (Build.VERSION.SDK_INT >= 29) {
// On API 29+, we can register for the correct Lifecycle callbacks directly
LifecycleCallbacks.registerIn(activity)
}
// Prior to API 29 and to maintain compatibility with older versions of
// ProcessLifecycleOwner (which may not be updated when lifecycle-runtime is updated and
// need to support activities that don't extend from FragmentActivity from support lib),
// use a framework fragment to get the correct timing of Lifecycle events
val manager = activity.fragmentManager
if (manager.findFragmentByTag(REPORT_FRAGMENT_TAG) == null) {
manager.beginTransaction().add(ReportFragment(), REPORT_FRAGMENT_TAG).commit()
// Hopefully, we are the first to make a transaction.
manager.executePendingTransactions()
}
}
}
}
ReportFragment#injectIfNeededIn方法对不同Android版本进行区分处理，API 29及以上通过Activity#registerActivityLifecycleCallbacks直接注册回调来监听和分发生命周期，API 29以下通过添加ReportFragment到Activity中来间接地监听和分发生命周期（Activity与Fragment之间的生命周期存在关联）。
public open class ReportFragment() : android.app.Fragment() {
private var processListener: ActivityInitializationListener? = null
private fun dispatchCreate(listener: ActivityInitializationListener?) {
listener?.onCreate()
}
private fun dispatchStart(listener: ActivityInitializationListener?) {
listener?.onStart()
}
private fun dispatchResume(listener: ActivityInitializationListener?) {
listener?.onResume()
}
override fun onActivityCreated(savedInstanceState: Bundle?) {
super.onActivityCreated(savedInstanceState)
dispatchCreate(processListener)
dispatch(Lifecycle.Event.ON_CREATE)
}
override fun onStart() {
super.onStart()
dispatchStart(processListener)
dispatch(Lifecycle.Event.ON_START)
}
override fun onResume() {
super.onResume()
dispatchResume(processListener)
dispatch(Lifecycle.Event.ON_RESUME)
}
override fun onPause() {
super.onPause()
dispatch(Lifecycle.Event.ON_PAUSE)
}
override fun onStop() {
super.onStop()
dispatch(Lifecycle.Event.ON_STOP)
}
override fun onDestroy() {
super.onDestroy()
dispatch(Lifecycle.Event.ON_DESTROY)
// just want to be sure that we won't leak reference to an activity
processListener = null
}
private fun dispatch(event: Lifecycle.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(activity, event) // 最终还是调用了两个入参的dispatch方法，即下面伴生对象的dispatch方法
}
}
public companion object {
// 最终的分发方法，无论是什么版本最终都会调用到这里
@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)
}
}
}
}
@RequiresApi(29)
internal class LifecycleCallbacks : Application.ActivityLifecycleCallbacks {
companion object {
@JvmStatic
fun registerIn(activity: Activity) {
activity.registerActivityLifecycleCallbacks(LifecycleCallbacks())
}
}
override fun onActivityCreated(
activity: Activity,
bundle: Bundle?
) {}
override fun onActivityPostCreated(
activity: Activity,
savedInstanceState: Bundle?
) {
dispatch(activity, Lifecycle.Event.ON_CREATE) // 调用到上面的伴生对象的dispatch方法
}
override fun onActivityStarted(activity: Activity) {}
override fun onActivityPostStarted(activity: Activity) {
dispatch(activity, Lifecycle.Event.ON_START)
}
override fun onActivityResumed(activity: Activity) {}
override fun onActivityPostResumed(activity: Activity) {
dispatch(activity, Lifecycle.Event.ON_RESUME)
}
override fun onActivityPrePaused(activity: Activity) {
dispatch(activity, Lifecycle.Event.ON_PAUSE)
}
override fun onActivityPaused(activity: Activity) {}
override fun onActivityPreStopped(activity: Activity) {
dispatch(activity, Lifecycle.Event.ON_STOP)
}
override fun onActivityStopped(activity: Activity) {}
override fun onActivitySaveInstanceState(
activity: Activity,
bundle: Bundle
) {}
override fun onActivityPreDestroyed(activity: Activity) {
dispatch(activity, Lifecycle.Event.ON_DESTROY)
}
override fun onActivityDestroyed(activity: Activity) {}
}
}
从源码可以看出，API 29以下是通过添加的无界面的ReportFragment的生命周期回调来监听Activity的生命周期，API 29及以上是通过注册回调来监听Activity的生命周期，最终都会通过静态方法ReportFragment#dispatch方法将生命周期通过LifecycleRegistry#handleLifecycleEvent方法分发给已注册的观察者LifecycleObserver。
3.2 生命周期的分发
通过上面的分析我们知道了，Activity的生命周期的管理和分发是通过注册回调或者添加ReportFragment来实现的。那么当Activity的生命周期发生变化之后就会分发给已注册的观察者进行处理，入口方法就是LifecycleRegistry#handleLifecycleEvent。
public actual open class LifecycleRegistry private constructor(
provider: LifecycleOwner,
private val enforceMainThread: Boolean
) : Lifecycle() {
public actual open fun handleLifecycleEvent(event: Event) {
enforceMainThreadIfNeeded("handleLifecycleEvent")
moveToState(event.targetState)
}
private fun moveToState(next: State) {
// 如果当前状态与新状态一致则忽略
if (state == next) {
return
}
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
// we will figure out what to do on upper level.
return
}
handlingEvent = true
sync() // 开始分发生命周期给已注册的观察者
handlingEvent = false
if (state == State.DESTROYED) {
observerMap = FastSafeIterableMap()
}
}
private val isSynced: Boolean
get() {
if (observerMap.size() == 0) {
return true
}
val eldestObserverState = observerMap.eldest()!!.value.state
val newestObserverState = observerMap.newest()!!.value.state
return eldestObserverState == newestObserverState && state == newestObserverState
}
private fun sync() {
val lifecycleOwner = lifecycleOwner.get()
?: throw IllegalStateException(
"LifecycleOwner of this LifecycleRegistry is already " +
"garbage collected. It is too late to change lifecycle state."
)
// 如果为同步完，则继续同步生命周期事件
while (!isSynced) { // isSynced只有当没有观察者或者观察者的状态与当前状态一致时才为true
newEventOccurred = false
// eldest方法返回最早添加的观察者
if (state < observerMap.eldest()!!.value.state) {
backwardPass(lifecycleOwner) // 依次将生命周期同步给对应的观察者，最终会调用到、ObserverWithState#dispatchEvent方法
}
// newest方法返回最晚添加的观察者
val newest = observerMap.newest()
if (!newEventOccurred && newest != null && state > newest.value.state) {
forwardPass(lifecycleOwner) // 依次将生命周期同步给对应的观察者，最终会调用到、ObserverWithState#dispatchEvent方法
}
}
newEventOccurred = false
_currentStateFlow.value = currentState
}
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
}
}
}
从源码可以看出，当生命周期发生变化时会遍历所有的观察者，并根据最新添加的观察者的生命周期状态和最早添加的观察者的生命周期状态，和当前生命周期状态进行比较，并视情况同步相关的生命周期给观察者。
public actual object Lifecycling {
private const val REFLECTIVE_CALLBACK = 1
private const val GENERATED_CALLBACK = 2
private val callbackCache: MutableMap<Class<*>, Int> = HashMap()
private val classToAdapters: MutableMap<Class<*>, List<Constructor<out GeneratedAdapter>>> =
HashMap()
@JvmStatic
@Suppress("DEPRECATION")
public actual fun lifecycleEventObserver(`object`: Any): LifecycleEventObserver {
// observer的类型是否实现了LifecycleEventObserver接口
val isLifecycleEventObserver = `object` is LifecycleEventObserver
// observer的类型是否实现了DefaultLifecycleObserver接口
val isDefaultLifecycleObserver = `object` is DefaultLifecycleObserver
// 如果observer的类型同时实现了LifecycleEventObserver和DefaultLifecycleObserver这两个接口，就包装成一个DefaultLifecycleObserverAdapter对象并返回
if (isLifecycleEventObserver && isDefaultLifecycleObserver) {
return DefaultLifecycleObserverAdapter(
`object` as DefaultLifecycleObserver,
`object` as LifecycleEventObserver
)
}
// 如果observer的类型实现了DefaultLifecycleObserver接口，就包装成一个DefaultLifecycleObserverAdapter对象并返回
if (isDefaultLifecycleObserver) {
return DefaultLifecycleObserverAdapter(`object` as DefaultLifecycleObserver, null)
}
// 如果observer的类型实现了LifecycleEventObserver接口，就转换成LifecycleEventObserver接口并返回
if (isLifecycleEventObserver) {
return `object` as LifecycleEventObserver
}
// 如果没有实现LifecycleEventObserver和DefaultLifecycleObserver这两个接口中的任意一个，那么继续判断构造函数
val klass: Class<*> = `object`.javaClass
val type = getObserverConstructorType(klass)
if (type == GENERATED_CALLBACK) {
val constructors = classToAdapters[klass]!!
if (constructors.size == 1) {
val generatedAdapter = createGeneratedAdapter(
constructors[0], `object`
)
return SingleGeneratedAdapterObserver(generatedAdapter)
}
val adapters: Array<GeneratedAdapter> = Array(constructors.size) { i ->
createGeneratedAdapter(constructors[i], `object`)
}
return CompositeGeneratedAdaptersObserver(adapters)
}
return ReflectiveGenericLifecycleObserver(`object`)
}
}
当通过LifecycleRegistry#addObserver方法添加一个类型为LifecycleObserver的对象时，首先将该对象包装成ObserverWithState对象，而ObserverWithState对象的初始化代码块会调用Lifecycling#lifecycleEventObserver方法对LifecycleObserver对象进行转换处理，根据LifecycleObserver对象实现的接口进行必要的适配处理，最终返回一个实现了LifecycleEventObserver接口的对象。
通过Lifecycling#lifecycleEventObserver方法的源码实现可以看出，如果实现了DefaultLifecycleObserver接口那么会转换为DefaultLifecycleObserverAdapter对象（基于对象适配器模式实现）并返回，DefaultLifecycleObserverAdapter类实现了LifecycleEventObserver接口，可见最终还是将注册的LifecycleObserver对象转换成实现了LifecycleEventObserver接口的对象，实现在生命周期发生变化时统一调用LifecycleEventObserver#onStateChanged方法进行分发。
如果LifecycleObserver对象既没有实现DefaultLifecycleObserver接口，也没有实现DefaultLifecycleObserverAdapter接口，这种情况下一般是直接实现了LifecycleObserver接口，并在类的方法中通过添加OnLifecycleEvent注解来观察生命周期状态，此时就会通过反射将添加注解的方法进行获取并包装成MethodReference，最终封装成CallbackInfo对象，并将LifecycleObserver对象对应的Class对象与CallbackInfo对象进行关联，用于后续分发生命周期时使用，这种情况下对应返回的就是ReflectiveGenericLifecycleObserver类型的对象。
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)
}
}
总结
Lifecycle组件内部对Activity组件的生命周期进行管理，对上层业务开发提供了接口用于观察生命周期，使得开发者可以将业务逻辑统一聚合到单独的观察者类中，并通过Lifecycle组件分发的生命周期来触发业务逻辑的执行，提高了代码的可维护性。
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
