07.1.1.6.1 ViewModel、Lifecycle 与 SavedState
所属:全栈开发面试题库 / 07 端侧与桌面开发 / 07.1 原生移动开发 / 07.1.1 Android / 07.1.1.6 Jetpack 基础与架构
本节要解决的问题
本节围绕「状态归谁持有、生命周期跟谁走、进程被杀后怎么恢复」展开:ViewModel 负责页面内存状态与作用域绑定,Lifecycle 负责把回调、协程和观察行为挂到状态机上,SavedStateHandle 负责在进程死亡后恢复小体积关键状态。版本基线:Android 14 / compileSdk 34、Kotlin 2.x、Lifecycle 与 ViewModel 最新稳定版;版本敏感行为标「待确认」并写明验证点。
07.1.1.6.1-001 ViewModel 解决的核心问题是什么?
一句话结论
ViewModel 把页面业务状态从 Activity/Fragment 中剥离,使配置变更(如旋转屏幕)导致界面重建时内存状态不丢失,同时避免界面层在重建中重复请求与重复持有。
概念解释
Activity 因配置变更会被销毁重建,直接写在 Activity 成员变量里的数据会随之清空;ViewModel 的生命周期独立于界面重建,在重建过程中实例保持不变,界面层从同一个实例取回状态。
原理流程
配置变更 → Activity 销毁并重建
→ ViewModelStore 不随重建清除
→ 新 Activity 从同一 Store 取到原 ViewModel 实例
→ 界面从 ViewModel 读取状态重新渲染
代码或图示
class ProfileViewModel : ViewModel() {
val uiState = MutableStateFlow(ProfileUiState())
}
常见误区
- ViewModel 不是「全局单例」,它只在绑定的 Owner 存活期间存活。
- ViewModel 解决配置变更丢失,不解决进程被系统回收后的内存数据恢复。
追问
- 配置变更时 ViewModel 为什么不一起销毁?答:ViewModelStore 由系统在重建场景中保留,归属 Owner 的非配置销毁周期。
- 它能替代数据库做持久化吗?答:不能,内存数据进程被杀即消失,长期数据仍需落盘。
07.1.1.6.1-002 ViewModel 和普通成员变量、静态单例有什么区别?
一句话结论
成员变量随界面实例一起销毁;静态单例脱离页面生命周期难以释放,容易跨页面串状态;ViewModel 按作用域持有、有明确清除时机,是介于两者之间的受控容器。
概念解释
普通成员变量绑定 Activity 实例,重建即清空;companion object 级单例存活到进程结束,且无法感知页面退出;ViewModel 绑定到 ViewModelStoreOwner,Owner 非配置销毁时调用 onCleared 清理。
原理流程
成员变量:随 Activity 实例销毁
静态单例:进程结束才回收,跨页面共享且难释放
ViewModel:Owner 清除时 onCleared,作用域内复用
代码或图示
// 不推荐:全局持有页面状态
object GlobalHolder { var draft: String? = null }
// 推荐:页面作用域内持有
class DraftViewModel : ViewModel() {
var draft: String = ""
}
常见误区
- 把 ViewModel 当静态缓存复用给多个无关页面,导致旧数据串入新页面。
- 用静态单例代替 ViewModel 保存编辑草稿,退出后仍残留隐私内容。
追问
- 两个页面需要共享同一份状态用什么?答:提升作用域到宿主 Activity 或导航目的地的 ViewModel,而不是写成静态单例。
- 静态单例在多进程下会怎样?答:每个进程各有一份,互不可见。
07.1.1.6.1-003 ViewModel 在什么时机被创建,又在什么时机被清除?
一句话结论
ViewModel 首次通过 ViewModelProvider 获取时由工厂创建并存入 ViewModelStore;当绑定的 Owner 真正销毁(非配置变更)时,Store 被清空并对每个 ViewModel 调用 onCleared。
概念解释
创建是懒加载:首次 get(...) 时 Store 中没有对应 key 才走工厂;清除发生在 Owner 执行 ViewModelStore.clear() 时,Activity 路径为 finish 或被系统回收后的最终销毁。
原理流程
首次获取 → Store 查不到 → 工厂创建 → 存入 Store
配置变更重建 → Store 保留,实例复用
Owner 真销毁 → Store.clear() → 逐个 onCleared → 释放引用
代码或图示
class MyViewModel : ViewModel() {
override fun onCleared() {
super.onCleared()
// 释放订阅、取消不需要在存活期保留的资源
}
}
常见误区
- 以为旋转屏幕也会触发
onCleared,实际不会。 - 在
onCleared里再去启动新的协程或访问已销毁的 View。
追问
- 导航返回栈弹出目的地时其 ViewModel 何时清除?答:对应 NavBackStackEntry 进入 destroy 后清除。
onCleared是否保证一定被调用?答:进程被整体杀死时不会走回调,只保证正常销毁路径。
07.1.1.6.1-004 ViewModel 的作用域绑定到谁?
一句话结论
ViewModel 绑定到实现 ViewModelStoreOwner 的对象上,常见为 Activity、Fragment、NavBackStackEntry;同一 Owner 内同名取到同一实例,不同 Owner 互不可见。
概念解释
ViewModelStoreOwner 只暴露一个 viewModelStore,Store 内部用键值表缓存 ViewModel;作用域边界就是这个 Store,决定实例存活多久、被谁共享。
原理流程
Owner(Activity/Fragment/Entry) 持有 ViewModelStore
→ ViewModelProvider 从 Store 取或建实例
→ 同 Owner 同 key 复用,跨 Owner 隔离
代码或图示
val vm: ProfileViewModel by viewModels() // 绑定当前 Fragment/Activity
val shared: SharedViewModel by activityViewModels() // 绑定宿主 Activity
常见误区
- 以为只要在同一个 App 内任意位置都能拿到同一 ViewModel。
- 在 Fragment 里直接用
viewModels()却期望与兄弟 Fragment 共享。
追问
- NavBackStackEntry 为什么也是 Owner?答:它代表导航目的地的生命周期与回栈条目,可为该目的地提供独立作用域。
- 自定义宿主能否作为 Owner?答:可以,实现
ViewModelStoreOwner并提供自己的 Store。
07.1.1.6.1-005 两个 Activity 实例能否拿到同一个 ViewModel?
一句话结论
不能。Activity 各有自己的 ViewModelStore,跨 Activity 取到的是不同实例;需要跨界面共享的数据应放在更高层作用域(如进程级仓库)或落盘,而不是寄望于两个 Activity 共享 ViewModel。
概念解释
启动新 Activity 属于新的 Owner 链路,Store 不共享;即便两个 Activity 指向同一类,ViewModel 也是各自独立实例。
原理流程
Activity A → StoreA → ViewModelA
Activity B → StoreB → ViewModelB(互不引用)
代码或图示
// A 与 B 中分别获取,得到的是两个实例
val a = ViewModelProvider(this)[ProfileViewModel::class.java]
常见误区
- 认为「页面类相同」ViewModel 就相同。
- 跨 Activity 传状态时塞进 ViewModel,结果新页面读到空状态。
追问
- 跨 Activity 共享登录态放哪里?答:进程级单例仓库、DataStore 或数据库,配合生命周期清理策略。
- Activity 重建算不算两个实例?答:重建是同一 Owner 链路,Store 保留,实例复用。
07.1.1.6.1-006 ViewModelProvider 默认工厂能构造什么样的 ViewModel?
一句话结论
默认工厂只能提供有无参构造函数的 ViewModel(以及可拿到 Application 的 AndroidViewModel);需要构造参数时必须提供自定义工厂或使用 Hilt 注入。
概念解释
ViewModelProvider 在 Store 未命中时调用 Factory 的 create;默认反射实例化要求构造可被无参调用,带参构造会抛异常。
原理流程
Store 未命中 → Factory.create(modelClass)
→ 默认工厂:反射调无参构造 / 匹配 AndroidViewModel
→ 带参构造不满足 → 抛出初始化异常
代码或图示
class CountViewModel(private val start: Int) : ViewModel()
// 反射无参构造会失败,必须提供工厂
常见误区
- 给 ViewModel 加了构造参数却仍用默认
viewModels(),运行时崩溃。 - 把参数理解成可以从
SavedStateHandle自动反序列化任意对象。
追问
- 较新工厂接口有什么变化?答:
CreationExtras可携带 SavedStateHandle、Owner、默认参数等信息,旧NewInstanceFactory仍兼容(具体版本行为待确认,以官方文档为准)。 - Hilt 下还需要手写工厂吗?答:
@HiltViewModel由 Hilt 工厂提供注入,不需要手写。
07.1.1.6.1-007 ViewModel 需要带参构造时如何写自定义工厂?
一句话结论
实现 ViewModelProvider.Factory,在 create 中用构造参数 new 出 ViewModel;Kotlin 下可用 viewModelFactory { initializer { ... } } 简写,并通过 CreationExtras 取 SavedStateHandle。
概念解释
工厂负责把外部依赖(仓库、初始值)注入 ViewModel;它在 Store 未命中时执行一次,实例随后被缓存。
原理流程
viewModels(factory = 自定义Factory)
→ create(modelClass, extras)
→ 取参数 → 构造 ViewModel → 存入 Store
代码或图示
val factory = viewModelFactory {
initializer {
val handle = createSavedStateHandle()
DetailViewModel(repository = AppRepository, savedStateHandle = handle)
}
}
val vm: DetailViewModel by viewModels { factory }
常见误区
- 工厂里每次
create都重新构造一个昂贵依赖,却没意识到实例只建一次。 - 直接在 Activity 里
new ViewModel(...),绕过 Store 导致重建后拿不到同一实例。
追问
- 工厂能否返回多个不同类型 ViewModel?答:按 modelClass 判断分支,分别构造;推荐一厂一物保持清晰。
createSavedStateHandle()从哪里取?答:来自 extras 中已保存的状态 Bundle。
07.1.1.6.1-008 AndroidViewModel 和普通 ViewModel 有什么区别?
一句话结论
AndroidViewModel 构造函数接收 Application,适合需要 Context(且是 Application 级)做系统服务、资源或全局依赖的场景;普通 ViewModel 不应持有任何 Context。
概念解释
Application 是进程级单例,生命周期长于页面,把它作为依赖注入不会造成界面泄漏;但 AndroidViewModel 仍不代表可以持有 Activity Context。
原理流程
默认工厂识别 AndroidViewModel
→ 构造时传入 Application
→ ViewModel 通过 Application 取系统服务 / 全局仓库
代码或图示
class AppViewModel(app: Application) : AndroidViewModel(app) {
private val resolver = app.contentResolver
}
常见误区
- 用 AndroidViewModel 拿到 Application 后再去取 Activity 实例,仍会泄漏。
- 为了拿一个字符串资源就继承 AndroidViewModel,徒增耦合。
追问
- 非 AndroidViewModel 怎么访问资源?答:把资源解析放到仓库或传字符串/枚举进入 ViewModel,界面层负责展示。
- Application 注入是否也可以走 Hilt?答:可以,
@HiltViewModel构造注入 Application 依赖。
07.1.1.6.1-009 SavedStateViewModelFactory 的作用是什么?
一句话结论
它是配合 Activity/Fragment 使用的默认工厂,能在创建 ViewModel 时注入 SavedStateHandle,并支持 AndroidViewModel 与无参 ViewModel 的构造,是进程死亡恢复链路的入口之一。
概念解释
普通 ViewModelFactory 只负责反射构造;SavedState 工厂额外把已保存的状态 Bundle 包装成 SavedStateHandle 传给需要它的 ViewModel。
原理流程
系统创建 Owner → 组装 savedInstanceState
→ SavedStateViewModelFactory 创建 ViewModel
→ 注入 SavedStateHandle → 存回 Store
代码或图示
// ComponentActivity / Fragment 自带该工厂,一般无需手写
val vm: SavedStateViewModel by viewModels()
常见误区
- 以为任何自定义工厂都自动注入 SavedStateHandle,实际需走 SavedState 链路。
- 把工厂换掉后,SavedStateHandle 取不到值。
追问
- 该工厂需要额外依赖吗?答:属于 lifecycle-viewmodel-savedstate 构件,版本坐标以官方文档为准(待确认)。
- 它和 Hilt 工厂冲突吗?答:Hilt 已整合 SavedState 注入,使用
hiltViewModel时由 Hilt 链路处理。
07.1.1.6.1-010 为什么 ViewModel 不能持有 Activity、Fragment 或 View?
一句话结论
ViewModel 存活可能长于界面实例;持有界面引用会让已销毁的 Activity/Fragment/View 无法回收,形成内存泄漏,旋转重建时旧实例仍被新 ViewModel 引用。
概念解释
配置变更重建时旧 Activity 被销毁,但 ViewModel 仍存活;若 ViewModel 持有旧 Activity,旧对象被长期引用,堆内存与控件资源无法释放。
原理流程
重建:旧 Activity 销毁 → ViewModel 存活
→ ViewModel 仍引用旧 Activity
→ GC 无法回收旧 Activity 及其 View 树
→ 内存泄漏
代码或图示
class BadViewModel : ViewModel() {
var activity: MainActivity? = null // 禁止
}
常见误区
- 持有 View 只为调一个刷新方法,正确做法是把状态暴露成观察数据,由界面订阅。
- 用弱引用持有 Activity 就以为安全:弱引用只是推迟泄漏,回调链路仍可能拿旧实例。
追问
- 需要 Context 取系统服务怎么办?答:用 Application Context 或把职责上移到仓库/界面层。
- ViewModel 持有监听器注册到全局对象也会泄漏吗?答:会,必须在
onCleared反注册。
07.1.1.6.1-011 持有 Application Context 为什么通常被认为安全?
一句话结论
Application 是进程级单例,生命周期等于进程,不与某个界面实例绑定,ViewModel 引用它不会间接拖住已销毁的 Activity。
概念解释
泄漏风险来自「长生命周期对象引用短生命周期对象」;Application 与 ViewModel 同属长生命周期,引用方向不构成界面泄漏。
原理流程
ViewModel(长) → Application(长):生命周期匹配,不泄漏
ViewModel(长) → Activity(短):反向拖住短对象,泄漏
代码或图示
class SafeViewModel(app: Application) : AndroidViewModel(app) {
// app 为 Application Context,可取系统服务
}
常见误区
- 拿 Application Context 去
startActivity缺FLAG_ACTIVITY_NEW_TASK场景仍会失败,这是用法问题不是泄漏问题。 - 认为只要是 Context 就安全:Service Context、Activity Context 仍需按生命周期判断。
追问
- BroadcastReceiver 注册放哪里?答:应跟随界面或生命周期 Owner,不写进长期存活的 ViewModel 里常驻。
- Application 引用多了会拖慢进程回收吗?答:进程整体结束时统一回收,单例数量需克制。
07.1.1.6.1-012 ViewModel 常见的内存泄漏场景有哪些?
一句话结论
典型泄漏包括:向全局单例/总线注册回调未解绑、持有静态引用、线程/协程在销毁后仍持有界面对象、注册了未反注册的系统监听器。
概念解释
泄漏的本质是 ViewModel(或其持有的资源)被更长链路引用,反过来拖住界面或大对象;onCleared 是主要清理点,但异步链路未必在此停止。
原理流程
ViewModel 注册回调到全局总线
→ onCleared 未反注册
→ 总线持有 ViewModel → 间接持有旧界面
→ 泄漏
代码或图示
open class BaseViewModel : ViewModel() {
protected val disposables = CompositeDisposable()
override fun onCleared() {
disposables.clear()
super.onCleared()
}
}
常见误区
- 只取消协程,却忘了取消 RxJava/EventBus/传感器/定位订阅。
- 把 View 引用藏在匿名内部类或 Lambda 捕获里,静态扫描不易发现。
追问
- 线上怎么定位 ViewModel 泄漏?答:用 LeakCanary 看泄漏链是否指向 ViewModel 与持有它的 Store/总线。
- 配置重建期间旧界面被 ViewModel 引用算泄漏吗?答:重建结束后旧界面应可回收;仍被引用即算。
07.1.1.6.1-013 viewModelScope 是什么,绑定到哪个 Job?
一句话结论
viewModelScope 是 ViewModel 内置的协程作用域,绑定一个 SupervisorJob 与 Dispatchers.Main.immediate;ViewModel 清除时该作用域被取消,所有子协程随之取消。
概念解释
作用域把协程的生命周期与 ViewModel 绑在一起:在 viewModelScope 内启动的任务,随 onCleared 统一取消,避免后台任务继续持有界面状态。
原理流程
ViewModel 创建 → viewModelScope(SupervisorJob + Main.immediate)
→ 启动业务协程
→ onCleared → scope.cancel() → 子协程级联取消
代码或图示
class MyViewModel : ViewModel() {
fun load() = viewModelScope.launch {
val result = repository.fetch()
_uiState.value = result
}
}
常见误区
- 在
viewModelScope里跑必须完整落地、即使页面退出也要完成的任务,取消后任务半途终止,这类应交给 WorkManager。 - 把
Dispatchers.IO与作用域混淆:作用域默认主线程调度,切线程用withContext。
追问
- 为什么用 SupervisorJob 而不是普通 Job?答:一个子协程失败不级联取消其他兄弟协程,错误由各自的异常处理接管。
- 作用域取消后
flow.collect会怎样?答:协程收到取消异常停止收集,状态不再更新。
07.1.1.6.1-014 页面退出后 viewModelScope 协程的取消行为是怎样的?
一句话结论
Owner 真销毁时 onCleared 触发,viewModelScope.cancel() 取消作用域;正在执行的挂起点响应取消,已写入的内存状态保留到实例被回收为止,配置变更期间协程不取消。
概念解释
取消是协作式的:线程内非挂起的计算不会立刻中断,但遇到挂起点会检查取消状态;需要在长循环中主动 isActive 判断。
原理流程
onCleared → scope.cancel()
→ 挂起点抛 CancellationException
→ 收集/请求停止,引用等待 GC 回收
代码或图示
viewModelScope.launch {
while (isActive) { // 长循环需主动检查
delay(500)
}
}
常见误区
- 认为取消会杀死正在进行的网络请求底层 socket;取消的是协程等待,请求是否中断取决于客户端实现。
- 在
onCleared里launch新协程去保存数据,作用域已取消,任务不会执行。
追问
- 取消异常要不要 catch?答:协程取消应由作用域机制处理,业务层不要吞掉
CancellationException。 - 配置重建时协程为什么不中断?答:ViewModel 未清除,作用域仍存活。
07.1.1.6.1-015 为什么不应该用 GlobalScope 在 ViewModel 里跑业务协程?
一句话结论
GlobalScope 不绑定任何生命周期,协程脱离 ViewModel 存活,页面退出后任务仍在跑,容易泄漏引用并做无用功;业务协程应使用 viewModelScope。
概念解释
GlobalScope 的生命周期等于进程,没有自动取消点;它适合进程级长期任务,不适合跟随页面生命周期的业务逻辑。
原理流程
GlobalScope.launch { ... }
→ 无取消时机
→ 页面退出后仍持有 ViewModel/闭包引用
代码或图示
// 不推荐
GlobalScope.launch(Dispatchers.IO) { repository.save(draft) }
// 推荐
viewModelScope.launch { withContext(Dispatchers.IO) { repository.save(draft) } }
常见误区
- 为了「页面退出也要保存草稿」用 GlobalScope;正确做法是落盘时机独立于界面,或交给 WorkManager 保证任务调度。
- 把 GlobalScope 包装成单例作用域却没有清理策略。
追问
- 进程级后台任务用什么?答:WorkManager 做可延迟、可重试的系统调度;仓库层可用独立的进程级作用域并明确管理。
- 单元测试里 GlobalScope 会有什么问题?答:测试结束协程可能仍在跑,导致线程泄漏与断言不稳定。
07.1.1.6.1-016 跨 Fragment 共享状态为什么用 activityViewModels,边界在哪里?
一句话结论
activityViewModels() 把 ViewModel 绑定到宿主 Activity,Fragment 之间通过同一实例共享状态;边界是该 Activity 存活期间,离开 Activity 或 Activity 销毁即清除。
概念解释
适合同屏多 Fragment 协作(如列表与详情、筛选面板与主列表);不适合跨 Activity、不适合承载需要落盘的长期数据。
原理流程
Fragment A、Fragment B 都取 activityViewModels
→ 绑定 Activity Store → 同一实例
→ 状态互通;Activity 销毁时清除
代码或图示
class ListFragment : Fragment() {
val shared: SharedViewModel by activityViewModels()
}
class DetailFragment : Fragment() {
val shared: SharedViewModel by activityViewModels()
}
常见误区
- 共享范围过大:把无关 Fragment 都塞进同一个共享 ViewModel,职责膨胀。
- 在 Fragment 视图销毁后仍观察共享 ViewModel 而不绑定 viewLifecycleOwner。
追问
- 同一 Activity 重建时共享 ViewModel 存活吗?答:配置变更存活;Activity finish 后清除。
- 多 Fragment 同时改一份状态如何避免互相覆盖?答:用单向数据流与明确事件协议,状态变更收敛到 ViewModel 内处理。
07.1.1.6.1-017 ViewModel 与 Navigation 目的地作用域是如何嵌套的?
一句话结论
Navigation 中每个 NavBackStackEntry 都是独立 Owner,目的地 ViewModel 绑定该条目;图表级作用域(如导航图)上的 ViewModel 在图内多个目的地之间共享,条目弹出时对应作用域清除。
概念解释
作用域层级为:Activity → 导航图(graph)→ 目的地条目(entry);越上层共享范围越大、存活越久。取 ViewModel 时指定不同 Owner 得到不同作用域实例。
原理流程
Activity Store
└─ Graph Entry Store(图内共享)
└─ Destination Entry Store(目的地私有)
代码或图示
// 目的地私有
val detail: DetailViewModel by navGraphViewModels(R.id.detail_graph)
// 图内共享
val graph: GraphSharedViewModel by navGraphViewModels(R.id.detail_graph)
常见误区
- 把图内共享 ViewModel 当成 Activity 级单例,返回图后仍期望旧状态。
- 弹出目的地后继续持有条目 ViewModel 引用,造成间接泄漏。
追问
- 两个平级目的地能共享 ViewModel 吗?答:可提升到它们共同的父图作用域。
- 深层链接重新进入目的地会新建条目吗?答:按回栈重建规则新建或复用条目,作用域随之建立或复用(具体行为待确认,以 Navigation 文档为准)。
07.1.1.6.1-018 导航目的地的 ViewModel 什么时候被清除?
一句话结论
当对应 NavBackStackEntry 被弹出回栈并进入 DESTROYED 状态时,其 Store 清空、ViewModel 调 onCleared;返回上一级、弹出到图外或任务栈销毁都会触发。
概念解释
条目进入 DESTROYED 不一定立即同步清除 Store,但导航框架在条目销毁路径上会清理其作用域;目的地私有 ViewModel 不会活到 Activity 结束。
原理流程
popBackStack / 跳转销毁条目
→ NavBackStackEntry ON_DESTROYED
→ Store.clear() → onCleared
代码或图示
// 返回上一级会销毁当前条目
findNavController().popBackStack()
常见误区
- 以为只要 Activity 没死,目的地 ViewModel 就一直留着。
- 在条目销毁后用旧 ViewModel 发送界面事件。
追问
- 图级 ViewModel 何时清除?答:父图条目被弹出或宿主销毁时。
- 配置变更下目的地条目 ViewModel 存活吗?答:随导航回栈状态保留,重建后重新挂到同一条目。
07.1.1.6.1-019 ViewModelStore 内部是如何缓存实例的?
一句话结论
Store 内部维护一个键到 ViewModel 的映射(实现为 ConcurrentHashMap 风格的线程安全表),put 覆盖、get 取值,clear 遍历调用每个 ViewModel 的 onCleared 并清空映射。
概念解释
默认以 ViewModel 类名为键;工厂键可区分同一类的多个实例。缓存只在 Store 生命周期内有效,不做跨进程持久化。
原理流程
get(key) → 命中返回;未命中走 Factory → put(key, vm)
clear() → 遍历 values → onCleared() → map.clear()
代码或图示
ViewModelStore
└─ Map<String, ViewModel>
├─ get(key)
├─ put(key, vm)
└─ clear()
常见误区
- 指望 Store 提供跨页面的全局缓存能力。
- 手动
put一个 ViewModel 后忘记其清除仍由 Store 统一管理。
追问
- 并发获取同一 ViewModel 安全吗?答:Store 查表与写入有同步保护;工厂构造仍应保持轻量、无副作用。
- 键冲突会怎样?答:后放入的覆盖旧实例,旧实例走清理路径。
07.1.1.6.1-020 onCleared 里能做什么,不能做什么?
一句话结论
onCleared 适合反注册回调、释放订阅、关闭本地资源句柄;不能访问已销毁的 View/Activity、不能启动新协程保存关键状态,也不能假设它在进程被杀时一定执行。
概念解释
这是 ViewModel 的最后同步清理点,作用域协程在此之前已被取消;关键持久化必须在状态变更时即时落盘,而不是寄希望于回调收尾。
原理流程
Store.clear()
→ onCleared() 同步执行清理
→ 映射清空,等待 GC
代码或图示
override fun onCleared() {
bus.unregister(this)
disposables.clear()
super.onCleared()
}
常见误区
- 在
onCleared里写数据库或发起网络请求,任务可能来不及执行。 - 引用
viewLifecycleOwner的 View 做最后一次刷新。
追问
- 必须保证落盘的数据放哪?答:状态变更时写入数据库/DataStore;不可丢失任务交给 WorkManager。
- 回调没反注册会怎样?答:总线仍持有 ViewModel,连带拖住旧界面。
07.1.1.6.1-021 ViewModel 和 onSaveInstanceState 如何分工?
一句话结论
ViewModel 存配置变更后仍可用的内存业务状态;onSaveInstanceState(及 SavedStateHandle)存进程被杀后需要恢复的少量关键状态;长期数据交给数据库或磁盘文件。
概念解释
两者解决不同回收场景:配置变更重建靠 ViewModel 存活;系统内存不足杀进程靠保存的 Bundle 恢复。Bundle 有大小与类型限制,不适合放大列表或图片。
原理流程
配置变更:ViewModel 内存保留,无需进 Bundle
进程死亡:Bundle 序列化恢复页面关键状态
长期数据:落盘存储,启动时读取
代码或图示
class ProfileViewModel(private val handle: SavedStateHandle) : ViewModel() {
var draft: String by handle // 关键编辑态走 SavedState
var list: List<Item> = emptyList() // 大列表走内存/仓库
}
常见误区
- 把整页数据塞进 SavedStateHandle,触发 Binder 事务超限或恢复变慢。
- 认为 ViewModel 能扛进程死亡,进程被杀后内存实例并不存在。
追问
- 哪些状态适合进 Bundle?答:滚动位置、表单草稿、选中项、页面参数等可序列化的小值。
- 大列表恢复策略?答:重启后从仓库/数据库重新加载,Bundle 只记位置与关键键。
07.1.1.6.1-022 进程被系统回收后 ViewModel 的数据还在吗?
一句话结论
不在。进程被杀后内存中的 ViewModel 实例与字段全部销毁;恢复时新建 ViewModel,只能从 SavedStateHandle 保存过的值、磁盘数据库或网络重新构建状态。
概念解释
配置变更只是界面重建,进程仍在;低内存回收属于进程级死亡,堆内存整体释放,ViewModel 无法跨进程存活。
原理流程
后台进程被系统回收 → 堆内存释放
→ 用户返回 → 重建 Activity/ViewModel
→ 从 SavedStateHandle + 本地存储 + 网络恢复
代码或图示
内存 ViewModel:进程死亡即丢失
SavedStateHandle:序列化进 savedInstanceState
数据库 / 文件:进程死亡后仍可读
常见误区
- 以为 ViewModel 「比 Activity 活得久」就等于能扛进程杀死。
- 只在内存缓存登录信息,进程被杀后回到未登录状态。
追问
- 如何验证进程死亡恢复?答:开发者选项「不保留活动」或后台划灭进程后返回,检查状态是否重建。
- SavedStateHandle 恢复不了哪些类型?答:不可序列化、体积过大、运行时对象(回调、View)。
07.1.1.6.1-023 SavedStateHandle 是什么,如何取值与写入?
一句话结论
SavedStateHandle 是可注入 ViewModel 的键值容器,界面重建与进程死亡恢复时能保留简单类型值;可直接读写,也可通过 LiveData/StateFlow 形式观察。
概念解释
它桥接 ViewModel 与系统保存的 Bundle:写入的值在合适时机被保存,恢复时重新组装进 Handle;ViewModel 通过构造参数接收。
原理流程
ViewModel 构造注入 Handle
→ set/get / 观察状态
→ 保存阶段写入 Bundle
→ 重建后从 Bundle 还原 Handle
代码或图示
class SearchViewModel(private val handle: SavedStateHandle) : ViewModel() {
val query: MutableLiveData<String> = handle.getLiveData("query", "")
fun onInput(s: String) { query.value = s }
}
常见误区
- 把 Handle 当普通内存 Map,存自定义未序列化对象导致保存失败。
- 不同 ViewModel 用相同键却期望彼此隔离,键冲突会互相覆盖。
追问
- Handle 支持哪些基础类型?答:Bundle 可序列化类型与 Parcelable/Serializable 等,具体清单以官方文档为准(待确认边界)。
- 如何删除一个键?答:
remove(key);观察型 LiveData 随键状态更新。
07.1.1.6.1-024 SavedStateHandle 与 savedInstanceState Bundle 是什么映射关系?
一句话结论
Handle 内部以 Bundle(或映射)形式保存键值;系统在销毁时把它纳入 savedInstanceState,重建时从该 Bundle 还原 Handle,ViewModel 拿到的是恢复后的同一接口。
概念解释
Bundle 是系统跨重建传递状态的载体,Handle 是给 ViewModel 用的友好封装;保存与恢复由 SavedStateRegistry 在中间协调。
原理流程
保存:Handle 键值 → 写入 Registry 对应的 Bundle
重建:savedInstanceState Bundle → Registry 还原 → Handle 重新组装
代码或图示
Activity.savedInstanceState
└─ SavedStateRegistry
└─ SavedStateHandle(ViewModel 注入)
常见误区
- 直接操作 Activity 的
savedInstanceState却忘了 Handle 链路已管理同名键。 - 假设 Handle 里的值自动同步到 DataStore,两者是不同存储。
追问
- 自定义组件如何参与同一 Bundle?答:向 SavedStateRegistry 注册提供者,按约定键保存与恢复。
- 键名带前缀能避免冲突吗?答:可以,模块内用前缀命名空间。
07.1.1.6.1-025 SavedStateHandle 能存哪些类型,Parcelable/Serializable 怎么处理?
一句话结论
只能存 Android Bundle 支持的可序列化类型:基本类型及其数组、字符串、Parcelable、Serializable、Bundle 等;复杂运行时对象、监听器、View 不能存。
概念解释
值最终要写入 Binder 可处理的 Bundle,超过事务大小或不可序列化会在保存阶段失败;自定义数据结构应实现 Parcelable 或拆解成基础字段保存。
原理流程
handle["item"] = parcelableItem
→ 保存时写入 Bundle
→ 恢复时按类加载还原(类需向后兼容)
代码或图示
@Parcelize
data class Filter(val keyword: String, val onlyOnline: Boolean) : Parcelable
handle["filter"] = Filter("book", true)
常见误区
- 存内部匿名类、Lambda、集合里装未序列化元素,恢复时抛异常。
- 改了 Parcelable 字段顺序/类型却不兼容旧保存数据。
追问
- 大对象存不进去怎么办?答:只存主键或关键字段,对象从数据库/仓库重新加载。
- Serializable 相比 Parcelable 在 Android 上的取舍?答:Parcelable 性能更好但需实现接口,序列化规则细节以文档为准。
07.1.1.6.1-026 进程死亡后 SavedStateHandle 的值如何被恢复?
一句话结论
系统在销毁时把 Handle 数据随 Activity 的 savedInstanceState 写入;进程重建后系统传回该 Bundle,SavedStateRegistry 还原 Handle,新 ViewModel 构造时拿到恢复后的值。
概念解释
恢复链路依赖系统在「可随时杀进程」场景下保留的实例状态;用户主动划掉任务栈、某些极端场景下保存数据仍可能丢失,关键业务不能只靠它。
原理流程
后台被回收前:写 savedInstanceState
重建:onCreate(savedInstanceState)
→ Registry 还原 → Handle 注入新 ViewModel
代码或图示
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
// 框架内部完成 Bundle → Handle 的还原
}
常见误区
- 认为只要调了
set就一定能恢复:任务被主动清除或保存失败时 Bundle 为空。 - 恢复后不做字段兼容,旧版本保存的数据在新版本崩溃。
追问
- 如何模拟该链路?答:开发者选项开启「不保留活动」,或用测试中传入
savedInstanceState的重建场景。 - 网络请求结果要恢复吗?答:不进 Handle;恢复后重新请求或读缓存。
07.1.1.6.1-027 配置变更恢复与进程死亡恢复两条路径有什么区别?
一句话结论
配置变更:ViewModel 内存实例存活,Bundle 是兜底;进程死亡:ViewModel 重建,靠 SavedStateHandle 与磁盘存储从头恢复。
概念解释
两条路径的内存可用性不同:前者对象还在,后者只保留可序列化的少量值。面试常考「某状态放在哪一层」,判断依据就是它在哪个路径下必须存活。
原理流程
配置变更:旧 ViewModel 复用 → 状态直接可读
进程死亡:新 ViewModel + Handle 还原小值 → 大状态从存储/网络重建
代码或图示
| 状态类型 | 配置变更 | 进程死亡 | 推荐存放 |
|---|---|---|---|
| 大列表、缓存 | ViewModel 内存 | 丢失 | 仓库 / 数据库 |
| 表单草稿、选中项 | ViewModel | Bundle 还原 | SavedStateHandle |
| 长期登录态 | 内存 | 落盘保留 | DataStore / 数据库 |
常见误区
- 用一个容器同时承诺两种恢复,结果大小与类型都不合适。
- 测试只覆盖旋转屏幕,没验证进程死亡恢复。
追问
- 旋转后列表位置如何保留?答:内存由 ViewModel 保留;进程死亡时把可见位置键存入 Handle,重启后定位。
- 哪种场景系统一定会保存 Bundle?答:组件进入后台后可能被回收的路径;前台立即 finish 不保证保存。
07.1.1.6.1-028 如何把 SavedStateHandle 暴露成 LiveData 或 Flow 观察?
一句话结论
Handle 提供 getLiveData(key, initial) 返回可观察 MutableLiveData;Kotlin 协程侧可配合 saveableFlow 或手动在状态写入时同步到 Handle,界面观察状态流即可。
概念解释
观察型接口让界面订阅持久化状态,写入值同时更新观察源;恢复后初始值来自 Bundle,缺失时用默认值。
原理流程
handle.getLiveData(key, default)
→ 写入 value → 同步保存
→ 界面观察变化;重建后从恢复值初始化
代码或图示
val query: MutableLiveData<String> = handle.getLiveData("query", "")
// Flow 侧:写入时同步保存到 handle
val query = MutableStateFlow(handle.get<String>("query") ?: "")
fun setQuery(v: String) { query.value = v; handle["query"] = v }
常见误区
- 直接
handle["key"] = flow,把 Flow 对象本身当可序列化值存入。 - 观察 LiveData 时不绑定合适的 LifecycleOwner。
追问
saveableFlow的能力边界?答:仅持久化可序列化快照,流的中间订阅状态不保留;具体 API 与版本以官方文档为准(待确认)。- 多个界面观察同一 Handle LiveData 安全吗?答:安全,状态由 Handle 持有。
07.1.1.6.1-029 SavedStateHandle 与导航参数(arguments)是什么关系?
一句话结论
导航目的地的参数会通过 Bundle 进入 NavBackStackEntry,注入到该目的地 ViewModel 的 SavedStateHandle 中;Handle 同时承担参数读取与页面临时状态保存。
概念解释
从 Handle 取目的地参数比直接读 arguments 更统一;参数是入口快照,页面编辑态也写进 Handle,二者按键区分。
原理流程
导航传入 arguments
→ Entry Bundle → Handle
→ ViewModel 读取参数;页面状态也写入同一 Handle
代码或图示
class DetailViewModel(private val handle: SavedStateHandle) : ViewModel() {
private val itemId: Long = handle["item_id"] ?: -1L
}
常见误区
- 把入口参数又保存回 Handle 同键,覆盖恢复语义。
- 期望 Handle 自动做参数类型转换,类型不符仍需手动解析。
追问
- Safe Args 生成的绑定与 Handle 读取如何选?答:类型安全首选 Safe Args;ViewModel 内统一读取可用 Handle,注意类型一致。
- 参数缺失时怎么办?答:给默认值或校验后导航回退,避免崩溃。
07.1.1.6.1-030 为什么不能把大对象塞进 SavedStateHandle?
一句话结论
Bundle 受 Binder 事务与序列化成本限制,大对象会导致保存/恢复变慢、 TransactionTooLargeException,且不可序列化部分直接丢失;Handle 只应保存小体积关键状态。
概念解释
进程死亡保存是逐键写入 Bundle,列表、位图、复杂树都应通过标识或快照落盘,恢复时再组装。
原理流程
Handle 写入大对象
→ 保存阶段序列化进 Bundle
→ 超事务限额 → 抛异常 / 恢复卡顿
代码或图示
// 不推荐:整列表入 Handle
handle["full_list"] = items
// 推荐:只存定位键,列表从仓库读取
handle["visible_key"] = items.firstOrNull()?.id
常见误区
- 为了「重建不丢数据」把整个 UiState 图序列化进 Handle。
- 忽视历史版本累积,键越存越多。
追问
- Bundle 事务上限大约多少?答:系统默认有事务缓冲区限制,超限抛 TransactionTooLargeException,具体阈值随设备版本(待确认,以异常与文档为准)。
- 大列表恢复策略?答:数据库/网络重建,Handle 记位置与筛选条件。
07.1.1.6.1-031 onSaveInstanceState 在什么时机被触发?
一句话结论
当 Activity 进入可能被系统回收的后台状态时(如按 Home、切到其他应用、被部分遮挡),系统调用保存回调;用户主动 finish 销毁一般不保存该实例状态。
概念解释
回调不保证在每次离开都执行,也不是「销毁前一定调用」;它用于给系统保留可恢复快照,而不是正常的清理收尾。
原理流程
Activity Stop / 可能回收
→ onSaveInstanceState(Bundle)
→ 组件把状态写入 Bundle
→ 重建时回传
代码或图示
override fun onSaveInstanceState(outState: Bundle) {
super.onSaveInstanceState(outState)
outState.putString("draft", binding.input.text.toString())
}
常见误区
- 把清理逻辑放在
onSaveInstanceState,以为它一定在销毁时跑。 - 回调里做耗时操作,影响切换流畅度。
追问
- 旋转屏幕会触发保存吗?答:配置变更重建路径会保存实例状态,ViewModel 仍保留内存实例。
- 与
onRestoreInstanceState的顺序?答:保存发生在 Stop 前后区间,重建时在onCreate/onRestoreInstanceState取回(版本行为细节待确认)。
07.1.1.6.1-032 状态持久化策略如何分层:内存、Handle、磁盘?
一句话结论
按「存活周期与体积」分层:页面瞬时状态放 ViewModel 内存;进程死亡需恢复的小值放 SavedStateHandle;跨会话长期数据放数据库/DataStore/文件,每层只承担自己擅长的职责。
概念解释
分层避免单一容器越界:内存快但易失,Handle 小而可恢复,磁盘可靠但读写成本高。状态变更时明确写哪一层,读取时按层组装。
原理流程
UI 事件 → ViewModel 更新内存状态
→ 关键字段同步 Handle
→ 长期变更写入磁盘
代码或图示
| 层级 | 载体 | 存活 | 适合内容 |
|---|---|---|---|
| 内存 | ViewModel | 配置变更内 | 列表、临时计算结果 |
| 快照 | SavedStateHandle | 进程死亡后恢复 | 草稿、位置、选中项 |
| 磁盘 | 数据库 / DataStore | 跨会话 | 账号、配置、历史记录 |
常见误区
- 所有状态都堆在 ViewModel,进程一杀全丢。
- 频繁写磁盘追求「绝不丢失」,造成 IO 与耗电。
追问
- 草稿自动保存落盘时机?答:输入停顿或切后台时写数据库/DataStore,Handle 只存当前页快照。
- 分层如何测试?答:旋转、进程死亡、冷启动三条路径分别验证数据来源。
07.1.1.6.1-033 SavedStateHandle 与 SavedStateRegistry 是什么关系?
一句话结论
SavedStateRegistry 是 Owner 级的状态登记与恢复中枢,管理各组件的保存键;Handle 是 Registry 提供给 ViewModel 的视图包装,ViewModel 通过它读写被 Registry 托管的状态。
概念解释
Registry 在重建时收集所有注册组件的 Bundle,死亡恢复时再分发还原;Handle 是其中面向 ViewModel 的入口,避免 ViewModel 直接触碰系统 Bundle。
原理流程
Owner 持有 Registry
→ 注册可保存组件 / 还原 Handle
→ 保存阶段汇总 Bundle,重建阶段分发
代码或图示
LifecycleOwner
└─ SavedStateRegistry
├─ registered savers(自定义组件)
└─ SavedStateHandle(ViewModel 注入)
常见误区
- 在 ViewModel 里直接拿 Activity 的 Registry 操作,绕过 Handle 约定。
- 注册时机晚于恢复分发,导致初始状态读不到。
追问
- 自定义 View 如何参与保存?答:实现
SavedStateRegistryOwner链路并注册SavedStateProvider,在视图状态保存回调中提供 Bundle。 - Registry 何时分发恢复值?答:Owner STARTED 之前完成恢复分发,避免观察者拿到空状态。
07.1.1.6.1-034 保存键冲突会发生什么,如何避免?
一句话结论
同一 Registry 下同名键会互相覆盖:后写入的先于先写入的值;模块/组件应使用带前缀的命名空间键,避免与框架或其他组件撞键。
概念解释
Handle 与注册表共享同一套键空间;导航参数、页面状态、自定义组件状态都可能落到同名键。
原理流程
组件 A 写 "filter"
组件 B 写 "filter" → 覆盖
恢复时只保留最后写入值
代码或图示
private const val KEY_QUERY = "profile:query"
handle[KEY_QUERY] = keyword
常见误区
- 用单字母或通用名(
"state"、"data")作键。 - 重构时改键名却不兼容旧版本保存的快照。
追问
- 发现键被覆盖如何排查?答:打印 Handle 全部键值,定位写入来源;恢复异常时检查旧 Bundle。
- 嵌套结构用什么键?答:复合路径前缀,或直接存一个 Parcelable/子 Bundle。
07.1.1.6.1-035 自定义组件如何把状态注册进 SavedStateRegistry?
一句话结论
实现 SavedStateProvider(saveState(): Bundle),在组件初始化阶段向 Owner 的 Registry 注册并分配键;恢复时 Registry 把之前保存的 Bundle 交回组件读取。
概念解释
适合自定义 View、地图、编辑器等有内部状态的控件;注册要早于 STARTED,确保恢复值可用;状态变化时由组件自行决定何时保存。
原理流程
组件初始化 → registry.registerSavedStateProvider(key, provider)
→ 保存:provider.saveState() 汇总
→ 恢复:registry.consumeRestoredStateForKey(key)
代码或图示
val provider = SavedStateProvider {
Bundle().apply { putInt("scroll", scrollPosition) }
}
savedStateRegistry.registerSavedStateProvider("editor", provider)
val restored = savedStateRegistry.consumeRestoredStateForKey("editor")
常见误区
- 注册过晚,恢复分发已完成,初始状态读不到旧值。
- 保存不可序列化的控件内部对象。
追问
- 注册后能否更换 Provider?答:同一键重新注册会替换提供者,旧保存值按 consume 规则读取(细节待确认)。
- ViewModel 还需要走这条路吗?答:不需要,Handle 已由框架注册好。
07.1.1.6.1-036 Lifecycle 有哪些状态,顺序是什么?
一句话结论
状态由弱到强为 INITIALIZED、CREATED、STARTED、RESUMED;Owner 创建后进入 CREATED,可见可交互逐级上升到 RESUMED,销毁时逐级下降回 INITIALIZED/DESTROYED。
概念解释
状态是当前生命周期强度的快照,事件(ON_CREATE/ON_START/ON_RESUME/ON_PAUSE/ON_STOP/ON_DESTROY)驱动状态迁移;观察者注册时会被补发到当前对应状态。
原理流程
INITIALIZED → CREATED → STARTED → RESUMED
↑ ↓
└──────── DESTROYED ← STOP ← PAUSE ←┘
代码或图示
when (lifecycle.currentState) {
Lifecycle.State.RESUMED -> /* 前台可交互 */
Lifecycle.State.STARTED -> /* 可见不可交互 */
Lifecycle.State.CREATED -> /* 已创建不可见 */
else -> Unit
}
常见误区
- 把状态和事件混为一谈:事件是迁移动作,状态是当前位置。
- 以为 RESUMED 才表示可见,STARTED 已处于可见区间。
追问
- DESTROYED 是状态吗?答:是终止态枚举,Owner 销毁后处于该状态,不能再回升。
- 状态能否跳跃迁移?答:框架按事件逐级推进;手动自定义 Owner 时需保证状态机一致。
07.1.1.6.1-037 Lifecycle.Event 与状态升降是什么对应关系?
一句话结论
ON_CREATE/ON_START/ON_RESUME 推动状态上升,ON_PAUSE/ON_STOP/ON_DESTROY 推动下降;每个事件对应一组状态边界,观察者在事件发生时收到回调。
概念解释
ON_CREATE 后到 CREATED,ON_START 后到 STARTED,ON_RESUME 后到 RESUMED;下降沿反向走。事件顺序与 Activity/Fragment 回调顺序一致。
原理流程
ON_CREATE → CREATED
ON_START → STARTED
ON_RESUME → RESUMED
ON_PAUSE → STARTED(回落)
ON_STOP → CREATED(回落)
ON_DESTROY → DESTROYED
代码或图示
override fun onCreate(owner: LifecycleOwner, event: Lifecycle.Event) {
when (event) {
Lifecycle.Event.ON_STOP -> pauseSensor()
Lifecycle.Event.ON_START -> resumeSensor()
else -> Unit
}
}
常见误区
- 在 ON_PAUSE 里就释放可见资源,实际视图仍可能短暂可见,通常等 ON_STOP。
- 认为 ON_DESTROY 一定与 ViewModel 清除同时发生。
追问
- ON_ANY_EVENT 有什么用?答:调试、日志、通用拦截,不替代具体事件分支。
- 事件顺序在 Fragment 视图上有何差异?答:视图生命周期独立分发一套事件,需绑 viewLifecycleOwner。
07.1.1.6.1-038 谁是默认的 LifecycleOwner?
一句话结论
ComponentActivity 及其子类、Fragment、NavBackStackEntry 都实现了 LifecycleOwner;普通 View、第三方对象不自带 Owner,需要外部把生命周期事件接进来。
概念解释
Owner 暴露 lifecycle 实例供观察者订阅;框架组件的生命周期由系统回调同步到 LifecycleRegistry,自定义宿主需要手动驱动状态。
原理流程
系统回调 → ComponentActivity/Fragment
→ 更新内部 LifecycleRegistry
→ 通知各 LifecycleObserver
代码或图示
class MainActivity : ComponentActivity() {
override fun onCreate(...) {
lifecycle.addObserver(myObserver)
}
}
常见误区
- 把 Context 强转成 Owner,普通 Service/View 不一定实现该接口。
- 在 Fragment 未初始化完就访问
viewLifecycleOwner.lifecycle。
追问
- Service 是 Owner 吗?答:标准 Service 不是 LifecycleOwner,需要自行封装生命周期感知。
- ViewModel 能实现 Owner 吗?答:不建议,它本身不持有界面生命周期,事件来源应来自界面 Owner。
07.1.1.6.1-039 注解观察者与 DefaultLifecycleObserver 接口方式有什么区别?
一句话结论
老方式用 @OnLifecycleEvent 注解标注方法,靠反射分发;新方式实现 DefaultLifecycleObserver 接口,直接重写 onCreate/onStart/... 等回调,编译期可检查、性能更好。
概念解释
注解方式已不推荐;接口方式在 Observer 上提供默认空实现,按需重写,方法签名与事件一一对应。
原理流程
注解:扫描 @OnLifecycleEvent 方法 → 反射调用
接口:implements DefaultLifecycleObserver → 虚方法分发
代码或图示
class MyObserver : DefaultLifecycleObserver {
override fun onStart(owner: LifecycleOwner) { }
override fun onStop(owner: LifecycleOwner) { }
}
常见误区
- 仍在新代码里使用被废弃的注解处理器。
- 接口回调里持有 Owner 的 View 引用造成泄漏。
追问
- 两种方式能混用吗?答:可以,但新项目统一用接口方式;注解处理器依赖与版本以官方公告为准(待确认)。
- 接口回调能否拿到当前状态?答:可通过
owner.lifecycle.currentState查询。
07.1.1.6.1-040 addObserver 时观察者会被补发当前状态吗?
一句话结论
会。注册时框架把当前状态到注册点之间遗漏的事件按顺序补发给观察者,保证新观察者从当前状态正确起步,而不是只等下一次事件。
概念解释
补发逻辑基于「目标状态与当前状态的差距」生成缺失事件序列;已处于 RESUMED 的 Owner 上注册,观察者会收到创建到当前的过程事件。
原理流程
addObserver(observer)
→ 计算 currentState 对应应补发的事件链
→ 依次分发 → 再跟随后续事件
代码或图示
// 在 onResume 之后注册,仍能收到前置创建类事件
lifecycle.addObserver(object : DefaultLifecycleObserver {
override fun onCreate(owner: LifecycleOwner) { /* 已被补发 */ }
})
常见误区
- 以为注册后只能收到未来事件,初始化逻辑漏跑。
- 重复注册同一观察者导致事件被多次处理。
追问
- 补发是否会调多次 ON_CREATE?答:对同一观察者只补发到当前位置一次,不会把完整历史循环播放。
- 注销后再注册呢?答:视为新观察者,再次按当前状态补发。
07.1.1.6.1-041 currentState 有什么用途?
一句话结论
lifecycle.currentState 用于在事件之外查询当前生命周期强度,决定能否安全更新界面、是否该暂停订阅;异步回调回来时先判断状态再触碰 View。
概念解释
状态是只读快照,可能与异步线程上的实际事件存在短暂差异;它适合做「是否在前台」的快速判断,不替代事件回调里的资源开关。
原理流程
异步回调返回
→ 读 currentState
→ >= STARTED 才更新可见 UI
→ 否则丢弃或缓存到状态容器
代码或图示
fun onResult(data: UiState) {
if (lifecycle.currentState.isAtLeast(Lifecycle.State.STARTED)) {
binding.render(data)
}
}
常见误区
- 在非主线程直接读状态并操作 View,View 操作仍必须回主线程。
- 用 currentState 替代 ON_STOP 释放资源,导致可见区间内被误停。
追问
isAtLeast(STARTED)判断什么?答:状态不低于 STARTED,即处于可见或交互区间。- 状态在 DESTROYED 后还会回升吗?答:不会,Owner 已终止。
07.1.1.6.1-042 观察者如何可靠感知 ON_STOP 和 ON_DESTROY?
一句话结论
实现 DefaultLifecycleObserver 重写 onStop/onDestroy,或在通用 onStateChanged 里匹配事件;订阅必须绑定真实 Owner(Fragment 用 viewLifecycleOwner),避免视图销毁后收不到终止事件。
概念解释
ON_STOP 对应不可见,ON_DESTROY 对应资源释放;Fragment 场景中视图销毁与 Fragment 销毁是两条生命周期,观察对象选错就漏收事件。
原理流程
Owner 进入 STOP → observer.onStop
Owner 进入 DESTROYED → observer.onDestroy
代码或图示
viewLifecycleOwner.lifecycle.addObserver(object : DefaultLifecycleObserver {
override fun onStop(owner: LifecycleOwner) { adapter.pause() }
override fun onDestroy(owner: LifecycleOwner) { adapter.detach() }
})
常见误区
- Fragment 里给
this加观察者,视图销毁后回调仍挂在 Fragment 生命周期上。 - 在 onDestroy 里再访问 binding,视图已置空。
追问
- 多个观察者顺序如何保证?答:按注册顺序分发,不依赖反向顺序做清理。
- 事件丢失怎么排查?答:确认订阅用的 Owner 是否进入过对应状态、是否提前注销。
07.1.1.6.1-043 repeatOnLifecycle 是做什么的,有哪几个档位?
一句话结论
repeatOnLifecycle(state) 在协程里按生命周期重复启动与停止收集:进入指定档位以上启动块,降到档位以下取消块,回到档位以上重新启动;常用档位为 STARTED、RESUMED,也可 CREATED。
概念解释
它把 Flow 收集与生命周期绑定,避免后台继续消费流;状态下降时取消协程,上升时重新执行块,天然处理「可见才订阅」。
原理流程
进入 >= STARTED → 启动 collect 块
降到 < STARTED → 取消块
再次回升 → 重新执行块
代码或图示
viewLifecycleOwner.lifecycleScope.launch {
repeatOnLifecycle(Lifecycle.State.STARTED) {
viewModel.uiState.collect { binding.render(it) }
}
}
常见误区
- 只在 onCreate 里 collect 一次,页面后台时仍在接收并更新已隐藏的界面。
- 档位选 RESUMED 导致 STARTED 区间的事件被不必要地中断。
追问
- repeatOnLifecycle 阻塞所在协程吗?答:块持续到生命周期销毁;外层 launch 与之配合使用。
- 它属于哪个构件?答:lifecycle-runtime-ktx,依赖与最低版本以官方文档为准(待确认)。
07.1.1.6.1-044 repeatOnLifecycle 与 launchWhenStarted/launchWhenResumed 有什么区别?
一句话结论
launchWhenXxx 在状态下降时只是挂起协程、不取消,块内资源与订阅可能仍保留;repeatOnLifecycle 下降时真正取消协程并释放块,回升时重新执行,资源清理更彻底。
概念解释
前者是「暂停执行」,后者是「销毁重建协程块」;对于 Flow 收集、注册回调等需要释放资源的场景,后者行为更可控。
原理流程
launchWhenStarted:下降 → 挂起;回升 → 继续(不重建)
repeatOnLifecycle:下降 → 取消;回升 → 重新启动块
代码或图示
// 旧方式:挂起不取消
lifecycleScope.launchWhenStarted { viewModel.uiState.collect { } }
// 推荐:下降即取消
lifecycleScope.launch {
repeatOnLifecycle(Lifecycle.State.STARTED) { viewModel.uiState.collect { } }
}
常见误区
- 以为 launchWhenStarted 停止收集就是取消了上游订阅。
- 块内持有资源,挂起期间没有释放,后台仍占用。
追问
- 为什么官方推荐 repeatOnLifecycle?答:避免后台保持活跃订阅与资源占用,行为与生命周期严格对齐。
- 什么场景 launchWhenXxx 仍够用?答:轻量、无资源持有、挂起恢复即可接受的简单展示逻辑,新代码仍建议 repeat。
07.1.1.6.1-045 launchWhenStarted 为什么被标记废弃?
一句话结论
它在生命周期下降时不取消协程,只暂停执行,容易让上游订阅、监听器和资源在后台保持活跃;与「可见才工作」的目标不符,因此官方推荐改用 repeatOnLifecycle。
概念解释
废弃的核心是语义缺陷:协程 Job 未被取消,块内已建立的订阅不会自动断开;开发者很难从代码表面判断后台是否仍在跑。
原理流程
launchWhenStarted 启动协程
→ 进入后台 → 协程挂起(Job 仍存活)
→ 订阅未释放 → 后台占用风险
代码或图示
废弃原因:挂起 ≠ 取消;资源释放依赖块内手动处理
替代:repeatOnLifecycle(STARTED) / RESUMED
常见误区
- 看到协程暂停就认为后台没有任何活动。
- 项目里大量旧用法未迁移,后台订阅与耗电问题被掩盖。
追问
- 废弃后旧代码会编译失败吗?答:多数为警告/废弃标记,能否编译取决于 lint 与版本;迁移优先级以官方公告为准(待确认)。
- 迁移要点?答:把收集块包进 repeatOnLifecycle,确认取消后无需手动恢复的资源。
07.1.1.6.1-046 为什么观察 Flow 要用 repeatOnLifecycle 包一层?
一句话结论
Flow 收集需要在界面可见时进行;用 repeatOnLifecycle 绑定 STARTED/RESUMED,页面不可见时取消收集,回到前台重新订阅,避免后台更新 UI 与无效资源占用。
概念解释
直接在 lifecycleScope 里 collect,协程在 Owner 存活期间一直运行;可见性下降不会自动停止流消费。生命周期感知收集让订阅区间与界面区间对齐。
原理流程
onCreate → lifecycleScope.launch
→ repeatOnLifecycle(STARTED) { collect }
→ 不可见取消,可见重建收集
代码或图示
lifecycleScope.launch {
repeatOnLifecycle(Lifecycle.State.STARTED) {
viewModel.uiState.collect { state -> binding.render(state) }
}
}
常见误区
- 用
GlobalScope或普通 scope 收集,脱离生命周期。 - 把多个流分别 collect 却忘记每个都要生命周期边界。
追问
- StateFlow 在后台收集会怎样?答:订阅仍活跃,新值仍下发;界面隐藏时更新无意义且占用 CPU。
- Compose 侧怎么对应?答:用
collectAsStateWithLifecycle等生命周期感知收集器,行为一致。
07.1.1.6.1-047 如何让打开/关闭的资源随生命周期开关?
一句话结论
把资源初始化放在 ON_START/ON_RESUME,释放放在 ON_STOP/ON_PAUSE,通过 DefaultLifecycleObserver 或 repeatOnLifecycle 绑定;传感器、定位、蓝牙、动画、注册广播都应按可见区间开关。
概念解释
生命周期感知避免在后台保持硬件连接与回调;资源开关成对出现,状态下降时释放,回升时重建。
原理流程
ON_START → 注册监听 / 连接传感器
ON_STOP → 反注册 / 断开连接
代码或图示
class SensorObserver(private val sensor: SensorManager) : DefaultLifecycleObserver {
override fun onStart(owner: LifecycleOwner) { sensor.register() }
override fun onStop(owner: LifecycleOwner) { sensor.unregister() }
}
常见误区
- 只在 onCreate 打开,从不关闭,后台持续耗电。
- 释放时机过早(ON_PAUSE 就停)导致短暂遮挡时资源反复重建。
追问
- 前台播放类资源跟谁走?答:与音频焦点/前台服务绑定,不跟随页面可见性;页面 View 资源仍随页面释放。
- 如何验证开关配对?答:生命周期日志对照进入/退出前台次数,检查反注册调用。
07.1.1.6.1-048 状态下降时协程和回调如何收尾?
一句话结论
协程侧由 repeatOnLifecycle 或生命周期 scope 取消,挂起点响应 CancellationException;回调侧在 ON_STOP/ON_PAUSE 反注册;需要保留的状态先写入状态容器,而不是依赖回调最后一次执行。
概念解释
收尾分两类:可取消的异步任务随作用域取消;必须落地的数据在状态变更时即时持久化,不能等销毁回调兜底。
原理流程
状态下降
→ 协程取消(挂起点退出)
→ 回调反注册
→ 已落盘数据保留,内存状态由 ViewModel/Handle 托管
代码或图示
override fun onStop(owner: LifecycleOwner) {
bus.unregister(this)
// 协程由 repeatOnLifecycle 取消,无需在此手动 stop
}
常见误区
- 在 onStop 里等待未完成的网络回调再更新界面,界面已隐藏。
- 取消协程后仍在 finally 之外触碰 View。
追问
- 取消后 finally 块还会执行吗?答:会,适合释放非协程资源;不要再启动新任务。
- 回调没解体会怎样?答:长期持有 Owner 链路,形成泄漏。
07.1.1.6.1-049 自定义 LifecycleOwner 的步骤是什么?
一句话结论
实现 LifecycleOwner 接口,内部持有 LifecycleRegistry,把外部事件源(自定义容器、第三方页面)的回调映射成 Lifecycle.Event 并 handleLifecycleEvent 推进状态。
概念解释
Registry 是可手动驱动的状态机;Owner 负责把真实生命周期来源翻译成框架事件,观察者就能复用同一套订阅模型。
原理流程
实现 LifecycleOwner → 持有 LifecycleRegistry
→ 外部回调 → registry.handleLifecycleEvent(...)
→ 观察者收到对应事件
代码或图示
class CustomOwner : LifecycleOwner {
private val registry = LifecycleRegistry(this)
override val lifecycle: Lifecycle get() = registry
fun enterForeground() = registry.handleLifecycleEvent(Lifecycle.Event.ON_START)
fun leaveForeground() = registry.handleLifecycleEvent(Lifecycle.Event.ON_STOP)
}
常见误区
- 事件顺序乱跳(未 START 直接 RESUMED)导致观察者状态错乱。
- Registry 未随 Owner 释放,残留观察者。
追问
- 直接 new LifecycleRegistry 可以吗?答:可以手动驱动;状态边界与事件序列必须保持自洽。
- 自定义 Owner 能否提供 ViewModelStore?答:另实现 ViewModelStoreOwner,两者职责独立。
07.1.1.6.1-050 第三方 SDK 需要感知页面生命周期如何接入?
一句话结论
让 SDK 暴露「开始/停止/释放」接口,由宿主在生命周期观察者中调用;SDK 不直接依赖 Activity 类,通过 Owner 或回调接口解耦,宿主选择绑定 ON_START/ON_STOP 还是 ON_RESUME/ON_PAUSE。
概念解释
接入点放在应用层而非 SDK 内部硬取 Context:页面可见区间开关 SDK 资源,销毁时释放,便于多宿主复用与测试。
原理流程
宿主 lifecycle.addObserver
→ ON_START → sdk.start()
→ ON_STOP → sdk.stop()
→ ON_DESTROY → sdk.release()
代码或图示
lifecycle.addObserver(object : DefaultLifecycleObserver {
override fun onStart(owner: LifecycleOwner) { sdk.resume() }
override fun onStop(owner: LifecycleOwner) { sdk.pause() }
override fun onDestroy(owner: LifecycleOwner) { sdk.destroy() }
})
常见误区
- SDK 内部自动注册全局广播/监听,脱离宿主生命周期。
- 只在初始化时 start,从不 stop,后台持续占用。
追问
- SDK 想自己拿生命周期怎么办?答:宿主把 LifecycleOwner 传给 SDK,SDK 观察而不反向持有 Activity。
- 多个页面复用同一 SDK 实例如何引用计数?答:由宿主按可见性计数开关,避免重复初始化。
07.1.1.6.1-051 ProcessLifecycleOwner 如何监听应用前后台?
一句话结论
ProcessLifecycleOwner 是进程级 Owner,统计所有可见 Activity 的数量,全部不可见时发 ON_STOP,重新有可见 Activity 时发 ON_START,用于判断整应用进入前后台。
概念解释
它观察进程内 Activity 生命周期汇总,事件粒度是「应用整体」,不是单个页面;适合全局埋点、前后台切换日志、会话超时判断。
原理流程
Activity 可见计数 +1 → 达到 1 → ON_START(前台)
Activity 全部不可见 → 计数 0 → ON_STOP(后台)
代码或图示
ProcessLifecycleOwner.get().lifecycle.addObserver(object : DefaultLifecycleObserver {
override fun onStart(owner: LifecycleOwner) { appEnterForeground() }
override fun onStop(owner: LifecycleOwner) { appEnterBackground() }
})
常见误区
- 把它当成「进程退出」回调,ON_STOP 只代表不可见,进程仍存活。
- 在 ON_STOP 里释放必须常驻的全局资源。
追问
- 它属于哪个构件?答:lifecycle-process,引入坐标与最低版本以官方文档为准(待确认)。
- 多进程下行为?答:每个进程各自统计本进程可见 Activity,不跨进程汇总。
07.1.1.6.1-052 进程前后台与单个 Activity 生命周期有什么区别?
一句话结论
Activity 事件描述单个页面的创建/可见/交互/销毁;进程前后台由可见 Activity 数量汇总,多个页面交替可见时 Activity 事件不断,而进程整体前台状态保持不变。
概念解释
判断「应用是否在前台」用 ProcessLifecycleOwner;判断「当前页面是否可交互」用页面 Owner;两者粒度不同,不要混用。
原理流程
页面 A → B:A STOP、B START,进程计数仍 >=1,前台状态不变
全部页面 STOP:进程计数 0 → 进程后台
代码或图示
| 判断对象 | 来源 | 典型用途 |
|---|---|---|
| 单页面可见 | Activity/Fragment lifecycle | UI 订阅、传感器 |
| 整应用前台 | ProcessLifecycleOwner | 会话、全局埋点 |
常见误区
- 用当前 Activity 的 onStop 判定应用退到后台,结果切页面时误判。
- 在页面 onStop 里清全局登录态。
追问
- 弹窗/透明 Activity 会影响计数吗?答:按可见性统计,具体边界受主题与可见状态影响(待确认,实测为准)。
- 前后台切换有没有延迟?答:计数归零到触发后台事件存在系统调度窗口。
07.1.1.6.1-053 ProcessLifecycleOwner 不能用来做什么?
一句话结论
它不能感知进程被杀死、不能保证收到退出前回调、不代表页面已销毁;不能在它的 ON_STOP 里做必须落地的收尾,也不能替代页面 ViewModel 的清理。
概念解释
后台与退出是两回事:进程可能在后台存活很久,也可能被系统直接回收而不走任何回调;进程级事件只反映可见性。
原理流程
ON_STOP(不可见)≠ 进程结束
进程被杀:无 ON_DESTROY 保证
代码或图示
// 不推荐:依赖进程后台回调保存关键数据
override fun onStop(owner: LifecycleOwner) { saveCriticalData() }
常见误区
- 把 ON_STOP 当应用退出钩子做注销、清缓存。
- 监听它释放长生命周期单例,导致再次进前台要重建。
追问
- 必须保证落盘的数据怎么做?答:状态变更时即时写存储;任务交付 WorkManager。
- 如何检测进程真的销毁?答:系统回收无可靠用户态回调,启动时按落盘状态恢复。
07.1.1.6.1-054 Fragment 本身的生命周期和 Fragment 视图生命周期有什么区别?
一句话结论
Fragment 实例生命周期跟随 Fragment 附着与分离;视图生命周期(viewLifecycleOwner)跟随 onCreateView 到 onDestroyView,反复进入返回栈或视图重建时视图 Owner 可销毁而 Fragment 实例仍存活。
概念解释
Fragment 可能 detach/reattach、视图被重建;观察 View 相关数据必须绑 viewLifecycleOwner,否则视图销毁后旧观察者仍挂在 Fragment 上。
原理流程
Fragment 实例:onAttach → onCreate → ... → onDetach
视图:onCreateView → viewLifecycleOwner STARTED... → onDestroyView
代码或图示
// 视图相关观察,必须用 viewLifecycleOwner
viewLifecycleOwner.lifecycle.observe(viewModel.uiState) { render(it) }
常见误区
- 在
onViewCreated里用this作为 Owner 订阅,返回栈再进入后视图泄漏。 - 把 Fragment 视图状态存到 Fragment 字段,视图重建后读到旧 binding。
追问
- 视图 Owner 何时进入 DESTROYED?答:
onDestroyView调用后。 - Fragment 实例何时清除其 ViewModel?答:Fragment 进入真正销毁时;视图销毁不清除 Fragment 作用域 ViewModel。
07.1.1.6.1-055 为什么 Fragment 观察 LiveData/Flow 要用 viewLifecycleOwner?
一句话结论
视图绑定的数据只应在视图存活时更新;用 viewLifecycleOwner 订阅,视图销毁时观察者自动移除,避免旧 binding 被回调引用,也防止重建后重复观察。
概念解释
this(Fragment)生命周期长于视图;若绑 Fragment,onDestroyView 后 LiveData 仍可能回调持有旧 binding 的观察者,造成泄漏与空引用。
原理流程
订阅绑 viewLifecycleOwner
→ onDestroyView → 该 Owner DESTROYED
→ 观察者自动移除
代码或图示
override fun onViewCreated(view: View, savedInstanceState: Bundle?) {
viewModel.uiState.observe(viewLifecycleOwner) { binding.render(it) }
}
常见误区
- 多个
onViewCreated分支重复订阅却每次用新 Owner,旧 Owner 已销毁不会泄漏,但状态重建需重新订阅。 - 在
onAttach阶段就访问viewLifecycleOwner,视图尚未创建。
追问
- 不自动移除会怎样?答:观察者持有旧 binding 闭包,Fragment 回栈后仍被 LiveData 引用。
- 订阅 Fragment 级共享数据用哪个 Owner?答:数据观察仍绑视图 Owner;ViewModel 作用域可提升到 activityViewModels。
07.1.1.6.1-056 Fragment 视图销毁后继续观察会有什么泄漏风险?
一句话结论
回调闭包捕获了旧 binding/View,观察者未随视图 Owner 移除;视图销毁后 LiveData/Flow 回调仍触发,访问旧 View 树,既泄漏又可能空指针或渲染到不可见界面。
概念解释
泄漏链为:观察者 → 闭包 → 旧 binding → 旧 View 树 → 旧 Fragment 视图;视图重建后新 binding 与旧观察者并存。
原理流程
视图销毁 → binding 置空
→ 旧观察者仍在 Fragment 生命周期上
→ 数据更新 → 回调捕获旧 binding → 泄漏 / NPE
代码或图示
// 风险写法:绑 this,闭包捕获 binding
viewModel.uiState.observe(this) { binding.render(it) }
常见误区
- 以为 LiveData 观察者只要页面退出就自动清,实际取决于绑定的 Owner。
- 在回栈 Fragment 上复用旧视图引用。
追问
- 如何检查这类泄漏?答:LeakCanary 链中出现 binding/View 与 LiveData observer;检查订阅 Owner 是否为 viewLifecycleOwner。
- 视图重建后状态怎么恢复?答:新视图重新订阅 ViewModel 当前状态,按最新值渲染。
07.1.1.6.1-057 LiveData 如何按 LifecycleOwner 决定是否回调?
一句话结论
LiveData 为每个 Owner 维护观察者与其活跃状态;只有 Owner 处于 STARTED 及以上才分发当前值,进入后台暂停分发,回到前台再同步最新值;Owner DESTROYED 时移除观察者。
概念解释
这是 LiveData 内置的生命周期感知:不活跃 Owner 不接收更新,销毁后自动清理订阅,减少后台回调。
原理流程
setValue → 遍历观察者
→ Owner >= STARTED → 回调
→ Owner < STARTED → 跳过
→ DESTROYED → 移除
代码或图示
viewModel.user.observe(viewLifecycleOwner) { user ->
binding.name.text = user.name
}
常见误区
- 用无 Owner 的
observeForever订阅却不手动 remove,形成长期订阅。 - 认为后台收到的值会排队,回到前台依次重放历史,实际只同步最新值。
追问
observeForever适合什么场景?答:无界面 Owner 的全局观察,必须在合适时机removeObserver。- LiveData 活跃状态由谁通知?答:由绑定 Owner 的生命周期事件驱动。
07.1.1.6.1-058 LiveData 的「粘性事件」是什么,如何规避?
一句话结论
LiveData 持有最近值,新观察者注册后立即收到当前值,事件与状态混用就会出现「旧事件再次触发」的粘性问题;一次性事件应使用事件包装、单向 Channel 或只暴露状态而不复用事件流。
概念解释
状态型数据(页面内容)重放最新值是合理的;动作型事件(Toast、跳转)重放则不符合预期。区分状态与事件是规避关键。
原理流程
LiveData setValue(event)
→ 旧观察者处理一次
→ 新观察者注册 → 立即收到同一值(粘性重放)
代码或图示
// 一次性事件:Channel 或 Event 包装 + 已消费标记
private val _events = Channel<UiEvent>(Channel.BUFFERED)
val events = _events.receiveAsFlow()
常见误区
- 把导航、提示等动作塞进普通 MutableLiveData,重建或新订阅时重复执行。
- 在 ViewModel 里反复 setValue 同一事件对象。
追问
SingleLiveEvent思路是什么?答:包装一次消费状态,仅未消费分发给活跃观察者;通用方案更推荐 Flow/Channel。- 配置重建后状态要不要重放?答:状态要,动作不要,按类型选择载体。
07.1.1.6.1-059 Compose 中如何对应生命周期感知?
一句话结论
Compose 用副作用 API 对齐生命周期:DisposableEffect 在进入组合/离开组合时配对清理;需要感知显隐档位时可配合 LifecycleResumeEffect 或 repeatOnLifecycle 的状态读取,避免离开组合后仍订阅。
概念解释
组合的进入/离开对应可感知的挂载点;副作用必须在 onDispose 中释放订阅、监听与资源,与传统观察者清理目标一致。
原理流程
进入组合 → DisposableEffect 建立订阅
离开组合 → onDispose 反注册
可见性变化 → 按 Lifecycle 档位暂停/恢复收集
代码或图示
DisposableEffect(lifecycle) {
val observer = register(...)
onDispose { observer.remove() }
}
常见误区
- 在 Composable 里直接
GlobalScope.launch收集,离开组合不取消。 - 把生命周期事件当成重组触发器,状态更新应走 State 而非事件监听。
追问
collectAsStateWithLifecycle解决什么?答:在 Compose 中按生命周期档位收集流,后台停止消费;构件坐标以官方文档为准(待确认)。- 组合与 Activity 生命周期谁先谁后?答:视图组合发生在视图创建后,清理在视图销毁前。
07.1.1.6.1-060 Activity 重建后观察者重新订阅会发生什么?
一句话结论
重建产生新的 Owner 实例,旧观察者随旧 Owner 销毁被移除;新视图重新订阅时,状态型载体(LiveData/StateFlow)把当前最新值推给新观察者,动作型事件需避免重放。
概念解释
重建不是「同一观察者延续」,而是新 Owner 新订阅;ViewModel 仍存活,其状态作为数据源决定新视图初始渲染。
原理流程
重建 → 旧 Owner DESTROYED → 旧观察者移除
→ 新 onCreate/onViewCreated → 重新订阅
→ 收到 ViewModel 当前状态
代码或图示
// 重建后 onViewCreated 再次执行,订阅新 viewLifecycleOwner
viewModel.uiState.observe(viewLifecycleOwner) { render(it) }
常见误区
- 以为旧观察者还在,重复注册导致多份回调。
- 事件型数据在重建后被再次执行(跳转、弹窗)。
追问
- 订阅注册在哪个回调最稳?答:视图创建完成后(onViewCreated / Compose 挂载点),避免过早访问 binding。
- 状态丢失时新视图显示什么?答:由 ViewModel/仓库当前值决定,空态或加载态兜底。
07.1.1.6.1-061 旋转屏幕导致 Activity 重建的完整路径是怎样的?
一句话结论
系统检测到配置变更 → 销毁当前 Activity 实例(走 pause/stop/destroy 保存实例状态)→ 创建新实例 → 从保存的 Bundle 恢复,并复用保留的 ViewModelStore 与导航回栈。
概念解释
重建过程中 ViewModelStore 被系统标记保留,不随旧实例清除;新实例通过同一 Owner 链路取回原 ViewModel,界面用当前状态重绘。
原理流程
配置变更 → 旧实例销毁(保存 Bundle)
→ 新实例创建 → 读取 savedInstanceState
→ 复用 ViewModelStore → 重新订阅状态
代码或图示
旧 Activity ——销毁——> ViewModelStore 保留
新 Activity ——取 Store——> 同一 ViewModel 实例
常见误区
- 把配置变更当成进程死亡,以为 ViewModel 会重建。
- 在旧实例回调里依赖单例静态字段传递全部状态。
追问
- 哪些对象在重建后必须重新创建?答:View、binding、Observer 订阅、Handler/监听器绑定。
- 重建期间是否会调用 onSaveInstanceState?答:配置变更路径会保存实例状态,用于恢复非 ViewModel 托管的值。
07.1.1.6.1-062 配置变更时 ViewModel 为什么能存活?
一句话结论
系统在配置变更销毁 Activity 时保留其 ViewModelStore(以及关联的导航条目状态),新 Activity 复用同一 Store;ViewModel 实例未被 clear,因此字段与协程作用域继续存活。
概念解释
存活的是 Store 里的实例,不是 ViewModel 自己绕过了销毁;Owner 标识在重建后重新关联到保留的 Store。
原理流程
配置变更:Activity 销毁但 Store 保留
→ 新 Activity 绑定保留 Store
→ get 命中原 ViewModel 实例
代码或图示
// 重建前后获取到同一实例
val vm: ProfileViewModel by viewModels()
常见误区
- 认为 ViewModel 不参与任何销毁流程,其持有的 View 引用也能活下来。
- 依赖 ViewModel 持有旧 binding,重建后访问已销毁视图。
追问
- Store 保留由谁管理?答:Activity 非配置销毁的保留机制,属于框架行为。
- 什么情况下配置变更也不保留 Store?答:Owner 被真正销毁(finish)或进程死亡时清除。
07.1.1.6.1-063 各类状态应放在哪一层,决策依据是什么?
一句话结论
按「是否跨配置变更存活、是否跨进程死亡存活、体积大小」决策:瞬时界面派生值在 ViewModel,进程死亡需恢复的小值在 SavedStateHandle,跨会话数据在数据库/DataStore。
概念解释
先问重建后是否需要原样恢复,再问进程被杀后是否需要恢复,最后看体积与类型是否可序列化;三个问题决定落点。
原理流程
需要跨配置变更?→ ViewModel
还需要跨进程死亡?→ 可序列化小值进 Handle,其余落盘
长期跨会话?→ 数据库 / DataStore
代码或图示
| 状态示例 | ViewModel | Handle | 磁盘 |
|---|---|---|---|
| 列表数据、加载态 | 是 | 否 | 兜底缓存 |
| 输入草稿、选中项 | 是 | 是 | 可选 |
| 登录令牌、偏好 | 内存缓存 | 否 | 是 |
常见误区
- 所有状态先塞 ViewModel,进程死亡后回到空白。
- 所有状态都写数据库,输入频繁导致 IO 放大。
追问
- 图片位图放哪?答:不进 Handle/ViewModel 长期持有,用图片库缓存与磁盘,内存只保留引用。
- 网络请求结果放哪?答:ViewModel 内存 + 仓库缓存;磁盘按业务需要持久化。
07.1.1.6.1-064 哪些场景下 ViewModel 作用域会丢失?
一句话结论
Owner 真正销毁(finish、导航弹出条目、Fragment 分离销毁)、进程被回收、作用域对象未正确保留时,ViewModel 会被清除或重建;配置变更本身不丢失作用域。
概念解释
作用域丢失 = Store 被 clear 或进程堆释放;表现为新页面拿到空状态、重新走初始化流程。
原理流程
finish / popBackStack / 真销毁 → Store.clear → onCleared
进程回收 → 堆释放 → 新进程重建实例
代码或图示
// 导航弹出目的地,条目 ViewModel 随之清除
navController.popBackStack()
常见误区
- 把「返回上一页」当成配置变更,以为详情 ViewModel 还能继续用。
- 多进程下默认 ViewModel 跨进程共享。
追问
- 跳转新页面后旧页面 ViewModel 还在吗?答:旧页面在回栈中其作用域保留;弹出销毁才清除。
- 如何验证作用域丢失?答:在 onCleared 打日志,结合返回栈与进程恢复路径观察。
07.1.1.6.1-065 configChanges 声明后自行处理配置变更有什么代价?
一句话结论
在 Manifest 给 Activity 声明 android:configChanges 后,旋转、语言等变更不再重建 Activity,回调 onConfigurationChanged 由开发者自行更新界面;省去重建但要手动适配所有配置项,遗漏会出现旧资源与旧布局。
概念解释
这是绕过框架重建的逃生口:生命周期不重建,ViewModel 存活语义不变,但布局、字符串、尺寸、深色模式等都需手动刷新。
原理流程
配置变更 → 不重建 Activity
→ onConfigurationChanged(newConfig)
→ 手动刷新资源与 UI
代码或图示
<activity android:name=".MainActivity"
android:configChanges="orientation|screenSize|uiMode" />
常见误区
- 声明后不刷新布局,深色模式/横竖屏显示旧资源。
- 把所有配置项都拦下来,增加自适配工作量与漏适配风险。
追问
- 哪些配置最常拦?答:方向、屏幕尺寸、深色模式;语言变更一般仍建议重建以保证资源一致(策略待按项目确认)。
- 与 ViewModel 存活是什么关系?答:不重建时实例自然存活,不代表重建路径下 ViewModel 不存活。
07.1.1.6.1-066 配置变更时 ViewModel 内部持有的回调需要重新绑定吗?
一句话结论
回调若绑定到旧界面对象(View、binding、Fragment 实例),重建后必须在新视图上重新绑定;绑定到仓库/总线且不持有界面引用的回调可保留,但回调回来时要通过新 Owner 判断能否更新 UI。
概念解释
ViewModel 存活,但旧 View 已销毁;清理掉对旧 View 的引用,订阅逻辑保留,渲染入口切换到新 binding。
原理流程
重建 → 旧 View 销毁
→ ViewModel 保留非界面订阅
→ 新视图重新建立渲染订阅 / 回调绑定
代码或图示
// ViewModel 只暴露状态;视图订阅在新视图上重建
viewModel.uiState.observe(viewLifecycleOwner) { binding.render(it) }
常见误区
- ViewModel 字段里存旧 binding,重建后回调渲染到旧视图。
- 仓库回调直接持有 View 引用。
追问
- 回调里缓存的结果怎么给新视图?答:状态存 ViewModel 字段,新视图订阅时读取当前值。
- 反注册旧回调的时机?答:旧视图 onDestroyView 清理界面侧监听;ViewModel 侧订阅按仓库生命周期管理。
07.1.1.6.1-067 深色模式、多语言切换后如何保持状态一致?
一句话结论
这类配置变更默认重建界面,ViewModel 保留内存状态,新视图按新配置读取资源重绘;需要跨进程恢复的选择项放 Handle,偏好设置从 DataStore 读取,避免旧主题/旧文案残留。
概念解释
状态与资源分离:业务状态不随配置重置,展示资源随新配置加载;切换语言后字符串、布局方向需重新解析。
原理流程
切换模式/语言 → 重建界面
→ ViewModel 状态保留 → 新视图按新配置渲染
→ 偏好从存储读取
代码或图示
// 视图重建后自动取新配置资源
binding.title.text = getString(R.string.profile_title)
常见误区
- 在内存缓存了旧语言文案,切换后不刷新。
- 拦截 configChanges 后忘记手动切换主题色与布局。
追问
- 进程死亡后偏好如何恢复?答:DataStore/数据库读取;界面选择项由 Handle 还原。
- 夜间模式手动跟随系统怎么选?答:在应用偏好里记录模式,启动时应用,重建后保持一致。
07.1.1.6.1-068 进程重建后导航栈与目的地状态如何恢复?
一句话结论
系统恢复任务栈与回栈条目,Navigation 从保存状态还原目的地与参数;各条目 ViewModel 重建,需从 Handle 与本地/网络数据恢复页面状态,未持久化的内存快照丢失。
概念解释
导航框架负责恢复栈结构和入口参数,不负责恢复页面业务内存;详情页滚动位置、编辑草稿等要自行决定保存层级。
原理流程
进程重建 → 任务栈恢复 → NavController 还原回栈
→ 各条目重建 ViewModel → Handle 还原小值 → 加载数据
代码或图示
// 恢复后按 Handle 中保存的定位键重新请求列表
val anchorId: String? = handle["anchor_id"]
常见误区
- 以为导航恢复会连带恢复列表滚动与临时表单。
- 深度链接入口参数在重建后丢失,未从 Handle/arguments 取回。
追问
- 回栈深度有限制吗?答:系统保存实例状态有大小与条目约束,过深栈可能被裁剪(具体行为待确认)。
- 关键页面状态如何兜底?答:草稿落盘,列表位置保存锚点键。
07.1.1.6.1-069 一个页面需要多个 ViewModel 时如何组织缓存?
一句话结论
按职责拆分多个 ViewModel(如页面主 ViewModel、列表 ViewModel、筛选 ViewModel),各自绑定同一或提升的作用域;通过共享状态仓库或图级 ViewModel 协作,避免一个超大 ViewModel 聚合全部字段。
概念解释
多 ViewModel 各自持有 Store 键下的实例;共享数据放在共同作用域或仓库,页面订阅多个状态流组合渲染。
原理流程
页面 Owner Store
├─ MainViewModel
├─ ListViewModel
└─ FilterViewModel
共同依赖 → 仓库 / 图级 SharedViewModel
代码或图示
val main: MainViewModel by viewModels()
val list: ListViewModel by viewModels()
val filter: FilterViewModel by viewModels()
常见误区
- 多个 ViewModel 各自重复请求同一仓库数据。
- 跨 ViewModel 直接互相引用字段,耦合难以测试。
追问
- 何时该提升为图级共享?答:多个目的地都需要同一份筛选/会话状态时。
- 测试如何拆分?答:每个 ViewModel 单独构造与断言,仓库依赖可替换。
07.1.1.6.1-070 配置变更导致宿主重建时,WebView、地图等控件如何处理?
一句话结论
这类重型控件状态不能靠 ViewModel 自动恢复:需保存控件内部状态(WebView 用 saveState/restoreState,地图保存位置与缩放),或在配置变更时保留控件实例;重建后重新附着并恢复状态,避免白屏与重复加载。
概念解释
控件内部持有大量运行时状态,重建后新控件是空白的;控件状态恢复与页面业务状态是两条线,需分别处理。
原理流程
重建前 → 控件 saveState 到 Bundle/Handle
重建后 → 新控件 restoreState → 重新加载页面/地图视角
代码或图示
val bundle = Bundle()
webView.saveState(bundle)
// 重建后
webView.restoreState(bundle)
常见误区
- 把 WebView 实例塞进 ViewModel 持有,重建后旧视图无法复用还泄漏。
- 旋转后地图回到默认定位,用户视角丢失。
追问
- 控件初始化昂贵如何减少重建成本?答:评估 configChanges 保留宿主,或用保留的 Fragment/视图方案;代价是手动适配配置。
- WebView 状态保存边界?答:历史记录、表单等可保存,JS 运行时会话与已加载页面状态恢复能力有限(待确认,以控件文档为准)。
07.1.1.6.1-071 ViewModelProvider 如何决定取到哪个缓存实例?
一句话结论
Provider 以 Owner 的 ViewModelStore 为缓存表,默认键为 ViewModel 类名(可带自定义键);Store 命中就返回旧实例,未命中走工厂创建后存入,同一 Owner 同键复用。
概念解释
ViewModelProvider(owner, factory) 每次获取时先查 Store;多实例场景用 get(key, modelClass) 区分,避免同类型互相覆盖。
原理流程
provider.get(Model::class)
→ Store[key] 命中 → 返回
→ 未命中 → factory.create → put → 返回
代码或图示
val vm = ViewModelProvider(this)[ProfileViewModel::class.java]
常见误区
- 不同 Owner 下默认以为键全局唯一,实际键空间在各自 Store 内。
- 同类型需要两个实例却没设自定义键,互相覆盖。
追问
- 自定义键什么时候用?答:同一类在同一 Owner 内需要多份独立状态时。
- 工厂每次 get 都执行吗?答:未命中才执行,命中不调工厂。
07.1.1.6.1-072 ViewModelStoreOwner 的实现链条有哪些?
一句话结论
ComponentActivity、Fragment、NavBackStackEntry 是常见 Owner;链条上层是 Activity Store,中层是导航图条目 Store,下层是目的地条目 Store,各层独立缓存与清除。
概念解释
导航组件把回栈条目也实现成 Owner,使目的地与图作用域 ViewModel 成为一等公民;取实例时传入不同 Owner 即落到不同 Store。
原理流程
ComponentActivity Store
└─ NavBackStackEntry(graph) Store
└─ NavBackStackEntry(destination) Store
代码或图示
val activityVm: SharedViewModel by activityViewModels()
val graphVm: GraphViewModel by navGraphViewModels(R.id.graph)
val destVm: DetailViewModel by viewModels()
常见误区
- 把 NavBackStackEntry 当成纯数据对象,忽略它也是生命周期与作用域 Owner。
- 层级取错,导致共享范围偏大或偏小。
追问
- Fragment 自身 Store 与 Activity Store 关系?答:Fragment 有独立 Store,同时可向上访问 Activity Store。
- 自定义组件想当 Owner?答:实现 ViewModelStoreOwner 并提供 Store。
07.1.1.6.1-073 onCleared 是从哪条调用链触发的?
一句话结论
由 Owner 真正销毁时调用 ViewModelStore.clear() 触发:Activity 销毁路径、导航条目弹出销毁、Fragment 分离销毁;Store.clear 遍历每个 ViewModel 调 onCleared 后清空映射。
概念解释
配置变更不进入该链路;进程被系统回收时用户态回调不执行。理解调用链有助于判断清理是否发生在预期时机。
原理流程
Owner 真销毁
→ Store.clear()
→ vm.onCleared()
→ map.clear()
代码或图示
override fun onCleared() {
disposables.clear()
super.onCleared()
}
常见误区
- 在配置变更重建路径上期望
onCleared执行清理旧资源。 - 把
onCleared当成 ActivityonDestroy的等价回调,二者触发条件不同。
追问
- 导航弹出时调用栈大致是?答:条目 ON_DESTROYED → 其 Store 清理;具体源码顺序以 AOSP/Jetpack 版本为准(待确认)。
- 多次 clear 安全吗?答:Store 清空后再次 clear 不重复回调已移除实例。
07.1.1.6.1-074 ViewModel 构造失败时异常如何暴露?
一句话结论
未命中 Store 时工厂 create 抛异常会沿 get/委托调用链抛出,通常在页面初始化阶段崩溃;依赖缺失、构造参数非法、反射失败都属于构造期问题,应在开发阶段暴露而不是吞掉。
概念解释
ViewModel 只创建一次,构造异常不会等到业务回调才出现;工厂内可做参数校验,抛出带明确信息的异常便于定位。
原理流程
首次 get → 工厂 create
→ 构造异常 → 向上抛出 → 页面初始化崩溃点
代码或图示
initializer {
val id = checkNotNull(handle.get<Long>("item_id")) { "缺少 item_id" }
DetailViewModel(repository, id)
}
常见误区
- 工厂里 catch 异常返回空 ViewModel,掩盖依赖问题。
- 构造里开启重活,把初始化成本放到首次获取时阻塞主线程。
追问
- 构造里能做网络请求吗?答:不建议,构造应轻量;数据加载放 ViewModelScope 或仓库方法。
- 测试中如何复现构造失败?答:传入缺失参数/假依赖,断言异常类型。
07.1.1.6.1-075 多线程同时获取同一 ViewModel 是否安全?
一句话结论
Store 查表与写入有同步保护,并发首次获取不会产出两个实例;但工厂构造逻辑本身应保持轻量且无副作用,避免在构造里做加锁或远程初始化。
概念解释
框架保证 Store 内单实例;线程安全不代表构造函数可以任意耗时或持有全局锁。常规获取发生在主线程初始化路径。
原理流程
并发 get 同一 key
→ Store 同步查表/写入
→ 仅一个实例被放入并返回
代码或图示
// 首次获取仍应放在主线程初始化流程
val vm: ProfileViewModel by viewModels()
常见误区
- 在子线程首次获取 ViewModel,并假设工厂多次被调用做幂等初始化。
- 构造里抢全局锁,与主线程初始化形成死锁风险。
追问
- 工厂 create 会被并发调用吗?答:实现层面可能在未命中时进入创建逻辑,工厂应可重入且轻量;细节以源码版本为准(待确认)。
- 单例仓库注入线程安全吗?答:仓库自身需保证线程安全,与 ViewModel Store 无关。
07.1.1.6.1-076 viewModelScope 默认用什么 Dispatcher?
一句话结论
viewModelScope 绑定 SupervisorJob() 与 Dispatchers.Main.immediate;默认在主线程调度,CPU/IO 工作用 withContext(Dispatchers.IO) 或默认调度器切换。
概念解释
Main.immediate 允许在主线程时立即执行不排队;作用域的 Job 负责取消,Dispatcher 负责线程切换,两者职责分开。
原理流程
viewModelScope = SupervisorJob() + Main.immediate
→ launch 默认主线程
→ withContext(IO) 切到 IO 线程执行后回主线程
代码或图示
fun load() = viewModelScope.launch {
val data = withContext(Dispatchers.IO) { repository.query() }
_uiState.value = data
}
常见误区
- 以为 scope 自带 IO 调度,直接在默认协程里跑阻塞 IO。
- 替换作用域 Job 导致取消链路断开。
追问
- Main.immediate 与 Main 区别?答:immediate 在当前已是主线程时不延迟投递;具体调度语义以协程文档为准。
- 能否自定义 scope?答:可以在 ViewModel 内自建 scope,但要在 onCleared 取消,不能替代内置 viewModelScope 的约定。
07.1.1.6.1-077 viewModels() 委托背后是怎么取到 Owner 的?
一句话结论
viewModels() 委托从宿主(Activity 或 Fragment)拿到当前 ViewModelStoreOwner 与默认工厂,调用 Provider 取或建 ViewModel;属性首次访问时解析,随后复用同一实例。
概念解释
委托把 by 语法落成 ViewModelProvider(owner, factory)[class];Fragment 场景委托内部处理 Fragment 与视图 Owner 的选择。
原理流程
属性首次访问
→ 取宿主 Owner + Factory
→ Provider.get(ViewModel::class)
→ 返回 Store 命中或新建实例
代码或图示
class DetailFragment : Fragment() {
private val vm: DetailViewModel by viewModels()
}
常见误区
- 在 Fragment 视图尚未创建时访问委托属性取视图相关实例,时机过早。
- 换宿主后仍用旧委托引用,作用域不随之改变。
追问
- 委托能传自定义工厂吗?答:
viewModels { factory }传入;也可传 Owner 选择器。 - 委托实例何时初始化?答:首次属性访问时,不是类实例化时。
07.1.1.6.1-078 activityViewModels 与 viewModels 的作用域差异是什么?
一句话结论
viewModels() 绑定当前 Fragment/Activity 自身 Store;activityViewModels() 绑定宿主 Activity Store,Fragment 间共享;两者工厂相同但 Owner 不同,实例缓存位置不同。
概念解释
取错作用域会导致共享状态拿不到或隔离过度;兄弟 Fragment 协作选 activityViewModels,页面私有状态选 viewModels。
原理流程
viewModels → Fragment Store
activityViewModels → Activity Store
代码或图示
val local: ListViewModel by viewModels()
val shared: CartViewModel by activityViewModels()
常见误区
- 在 Fragment 销毁后仍持有 activityViewModels 返回的实例引用,超出共享必要范围。
- 把应隔离的表单状态放 Activity 作用域,返回后残留。
追问
- Navigation 场景对应物?答:
navGraphViewModels(route)绑定图条目 Store。 - Activity 重建时共享实例存活吗?答:配置变更存活;Activity finish 后清除。
07.1.1.6.1-079 hiltViewModel 如何确定 ViewModel 作用域与注入?
一句话结论
hiltViewModel() 由 Hilt 提供工厂并接入 ViewModel 生命周期,注入的依赖来自 Hilt 容器;作用域仍由所选 Owner(Fragment/Activity/导航条目)决定,Hilt 负责构造而非扩大存活范围。
概念解释
@HiltViewModel 标注的 ViewModel 构造注入仓库、Handle 等;Hilt 工厂在未命中 Store 时创建,清除时机与普通 ViewModel 一致。
原理流程
hiltViewModel() → Hilt 工厂
→ 从 Hilt 容器取依赖构造
→ 存入所选 Owner 的 Store
代码或图示
@HiltViewModel
class ProfileViewModel @Inject constructor(
private val repository: ProfileRepository,
savedStateHandle: SavedStateHandle
) : ViewModel()
常见误区
- 以为 Hilt 注入让 ViewModel 变成进程级单例,实际作用域仍跟随 Owner。
- 在 ViewModel 里注入 Activity 绑定作用域对象,造成作用域不匹配编译/运行问题。
追问
- Hilt 如何注入 SavedStateHandle?答:Hilt 整合 SavedState 工厂,Handle 可作为构造参数注入(版本行为以 Hilt 文档为准,待确认)。
- 导航条目作用域怎么取?答:
hiltViewModel(navGraphBackStackEntry)绑定对应条目。
07.1.1.6.1-080 Navigation 下 SavedStateHandle 是如何注入 ViewModel 的?
一句话结论
目的地 NavBackStackEntry 持有保存状态与参数 Bundle,其 Owner 链路在创建 ViewModel 时通过 SavedState 工厂把 Handle 传给 ViewModel 构造,参数与页面快照都从该 Handle 读取。
概念解释
Handle 数据源是条目 Bundle:入口 arguments、保存状态;ViewModel 不直接依赖 NavController,只通过 Handle 拿键值。
原理流程
Entry Bundle(arguments + savedState)
→ SavedState 工厂 → SavedStateHandle
→ 注入 ViewModel 构造
代码或图示
@HiltViewModel
class DetailViewModel @Inject constructor(
private val handle: SavedStateHandle
) : ViewModel() {
val itemId: Long = handle["itemId"] ?: -1L
}
常见误区
- 导航参数改了键名却没同步 Handle 读取键。
- 在 Handle 里存导航 arguments 同名键又写页面状态,语义混淆。
追问
- 深层链接参数也进 Handle 吗?答:进入目的地的 arguments 会进入条目 Bundle 与 Handle。
- 图级共享 ViewModel 的 Handle 数据来自哪?答:对应图条目的保存状态,不自动合并各目的地参数。
07.1.1.6.1-081 手动驱动 LifecycleRegistry 的典型写法是什么?
一句话结论
创建 LifecycleRegistry(owner),在外部事件源回调里调用 handleLifecycleEvent(Event);事件按状态机顺序分发,观察者收到对应回调,自定义容器即可复用生命周期订阅模型。
概念解释
Registry 负责状态计算与观察者通知;Owner 只负责把真实事件翻译为 Event,不能乱序跳跃。
原理流程
外部回调 → registry.handleLifecycleEvent(ON_START)
→ 状态升至 STARTED → 通知观察者
代码或图示
class PanelOwner : LifecycleOwner {
private val registry = LifecycleRegistry(this)
override val lifecycle get() = registry
fun show() = registry.handleLifecycleEvent(Lifecycle.Event.ON_RESUME)
fun hide() = registry.handleLifecycleEvent(Lifecycle.Event.ON_PAUSE)
}
常见误区
- 先发 ON_RESUME 再 ON_START,状态机不一致导致观察者漏回调。
- Owner 销毁时不发 ON_DESTROY,观察者残留。
追问
- 能否直接 set 当前状态?答:较新版本 Registry 支持状态设置接口,但事件序列仍需自洽;API 细节以文档为准(待确认)。
- 手动 Owner 需要清理观察者吗?答:DESTROYED 后框架会移除观察者;Registry 引用应随 Owner 释放。
07.1.1.6.1-082 观察者列表在分发过程中被修改有什么风险?
一句话结论
生命周期分发遍历观察者时若并发增删,可能出现 ConcurrentModificationException、漏通知或重复通知;观察者注册/注销应在主线程并与事件分发同线程,避免在回调里修改全局观察者集合。
概念解释
框架内部对列表做了同步或副本处理,但业务代码在观察者回调里反注册、跨线程 add/remove 仍可能踩到边界。
原理流程
分发遍历中 → 另一线程增删观察者
→ 迭代器状态异常 / 漏发
代码或图示
// 注册与注销均在主线程生命周期回调内
lifecycle.addObserver(observer)
// onDestroy 中移除
常见误区
- 在异步回调里
lifecycle.removeObserver,与主线条文分发并发。 - 同一观察者重复 add,列表中出现重复条目。
追问
- 框架是否已兜底?答:Lifecycle 实现对并发分发有内部处理,但业务仍应遵循主线程约定;具体实现以版本源码为准(待确认)。
- 多观察者清理顺序?答:按注册/移除状态分发,不要依赖逆序做资源释放。
07.1.1.6.1-083 状态下降与 ON_DESTROY 的事件顺序是怎样的?
一句话结论
下降沿按 RESUMED → STARTED → CREATED → DESTROYED 逐级触发 PAUSE/STOP/DESTROY 事件;ON_DESTROY 是最后事件,之后状态终止,观察者被移除,不能再回升。
概念解释
顺序与 Activity 销毁回调对应:先不可交互、再不可见、最后销毁;资源释放按阶段放在对应回调,而非全堆到 DESTROY。
原理流程
ON_PAUSE → ON_STOP → ON_DESTROY
RESUMED → STARTED → CREATED → DESTROYED
代码或图示
override fun onPause(owner: LifecycleOwner) { /* 暂停动画/输入 */ }
override fun onStop(owner: LifecycleOwner) { /* 释放可见资源 */ }
override fun onDestroy(owner: LifecycleOwner) { /* 释放长持有引用 */ }
常见误区
- 在 ON_DESTROY 才反注册广播/传感器,后台期间仍在接收。
- 认为 DESTROYED 后还能通过 addObserver 收到回升事件。
追问
- Fragment 视图销毁事件与 Fragment 销毁事件如何错开?答:两套 Owner 各自分发,先视图 ON_DESTROY,后 Fragment ON_DESTROY。
- ON_STOP 一定在 ON_PAUSE 之后吗?答:正常生命周期顺序如此;多窗口/特殊模式下回调顺序需实测确认(待确认)。
07.1.1.6.1-084 LiveData 与 StateFlow 在 MVVM 中各自边界是什么?
一句话结论
LiveData 自带生命周期感知,适合直接驱动界面观察;StateFlow/Flow 提供更丰富的流操作与协程集成,需要配合生命周期收集器使用;状态容器在 ViewModel,界面只订阅渲染,不反向持有业务对象。
概念解释
LiveData 与 Owner 绑定自动停发;StateFlow 默认共享当前值,后台订阅仍活跃,必须用 repeatOnLifecycle 或 collectAsStateWithLifecycle 包裹。
原理流程
ViewModel 暴露不可变状态
→ 界面按生命周期订阅
→ 用户事件回写 ViewModel → 更新状态 → 再渲染
代码或图示
// StateFlow 方案
private val _uiState = MutableStateFlow(ProfileUiState())
val uiState: StateFlow<ProfileUiState> = _uiState.asStateFlow()
常见误区
- 在 ViewModel 里暴露 MutableLiveData/MutableStateFlow 可变引用,界面可随意改状态。
- 用 StateFlow 承载一次性动作事件,导致重放。
追问
- 单向数据流怎么落地?答:ViewModel 接收意图,更新状态;界面观察状态,事件用 Channel/事件流。
- 两者能混用吗?答:可以,但同一状态避免双载体;迁移期注意生命周期收集方式。
07.1.1.6.1-085 旧页面状态串入新页面如何排查?
一句话结论
先确认串状态来自哪里:静态单例、作用域取错的共享 ViewModel、未清理的仓库缓存、未反注册总线回调;从泄漏链与作用域边界入手,对比新旧页面拿到的实例是否同一引用。
概念解释
典型症状:打开 B 页显示 A 页的筛选/草稿/列表;排查路径是「实例是否复用 → 状态写入点 → 缓存载体」。
原理流程
新页面出现旧数据
→ 打印 ViewModel 实例标识
→ 检查是否拿到共享作用域 / 单例 / 仓库旧缓存
→ 定位未清空的状态写入点
代码或图示
// 日志中对比实例与状态来源
Log.d("VM", "hash=${this.hashCode()}, state=${_uiState.value}")
常见误区
- 把导航条目 ViewModel 当成页面私有,实际取到了图级或 Activity 级共享实例。
- 仓库内存缓存按全局键复用,新页面未刷新。
追问
- 静态单例残留怎么清?答:退出对应流程时显式清空,或改为作用域内持有。
- 如何回归测试?答:A 页填数据 → 退出 → 进 B 页,断言 B 页为空态/默认态。
07.1.1.6.1-086 列表滚动位置和编辑草稿应放在哪一层?
一句话结论
列表滚动锚点(可见项键/位置)配置变更内放 ViewModel,进程死亡需恢复的小锚点放 Handle;编辑草稿同理:内存在 ViewModel,关键草稿可落盘数据库/DataStore,位图与大对象不进 Handle。
概念解释
判断标准:重建后是否必须回到原位置、进程被杀后是否需要找回草稿;锚点用可序列化的键,完整内容由仓库/数据库恢复。
原理流程
滚动锚点:ViewModel 内存 + Handle 存键
草稿:ViewModel 内存 → 停顿/切后台落盘
代码或图示
private val anchorKey: String?
get() = handle["anchor_key"]
fun saveAnchor(key: String) { handle["anchor_key"] = key }
常见误区
- 把整份列表数据塞进 Handle 恢复。
- 草稿只存内存,进程被杀后全部丢失。
追问
- 列表恢复定位时机?答:数据加载完成后按锚点键滚动,避免先跳到顶部再回弹。
- 表单未保存离开如何提示?答:ViewModel 跟踪脏状态,宿主拦截返回或提示保存。
07.1.1.6.1-087 页面跳转带回结果时如何与 ViewModel 协作?
一句话结论
结果通过导航返回栈或共享作用域回传,接收方 ViewModel 暴露状态/事件;不要把结果临时挂在静态字段,也不要在销毁后的 ViewModel 上等待回调。
概念解释
跨页面结果先落到导航机制(回栈条目、共享 ViewModel),再由目标 ViewModel 转为状态;生命周期未就绪时结果进入状态容器,订阅后渲染。
原理流程
B 页返回结果
→ 导航回传 / 共享 ViewModel 更新
→ A 页 ViewModel 接收 → 更新状态 → 界面订阅渲染
代码或图示
// 共享作用域接收结果
val shared: ResultViewModel by activityViewModels()
shared.result.observe(viewLifecycleOwner) { render(it) }
常见误区
- 用接口回调直接持有旧页面实例,销毁后回调崩溃。
- 结果事件复用状态流,重建后重复处理。
追问
- Fragment 结果 API 与 ViewModel 怎么配合?答:结果先进入 Fragment 回调,再转交 ViewModel 更新状态;不要在回调里直接操作 View。
- 多页面链式传结果怎么设计?答:收敛到共同作用域或仓库,按事件协议传递。
07.1.1.6.1-088 多线程回调回来时如何判断能否更新界面?
一句话结论
先切回主线程,再检查绑定 Owner 的 currentState 是否达到需要的档位(通常 STARTED),达到才更新 View;不可达时把结果写入 ViewModel 状态,等界面重新订阅时渲染。
概念解释
异步回调可能在页面不可见或已销毁时返回;直接碰 View 会空指针或渲染到旧视图,状态判断与线程切换缺一不可。
原理流程
异步回调(后台线程)
→ 切主线程
→ 检查 lifecycle.currentState
→ 达标更新 View;否则写状态容器
代码或图示
fun onResult(data: Profile) {
mainHandler.post {
if (lifecycle.currentState.isAtLeast(Lifecycle.State.STARTED)) {
binding.render(data)
} else {
viewModel.cache(data)
}
}
}
常见误区
- 只切线程不检查状态,视图销毁后回调访问 binding。
- 在子线程直接改 View 字段。
追问
- ViewModel 回调为什么通常不直接碰 View?答:ViewModel 无视图引用,结果写入状态,界面订阅负责渲染。
- 状态已销毁的 Owner 还能 post 到其 Handler 吗?答:可投递但视图不可用,必须以状态检查为准。
07.1.1.6.1-089 用户会话数据应放哪里,何时清空?
一句话结论
长期会话凭证放安全存储(DataStore/加密数据库),内存缓存放进程级仓库或 Application 作用域;页面 ViewModel 只持有当前页派生数据,退出登录时统一清内存缓存与存储令牌,不把会话长期挂在页面 ViewModel。
概念解释
会话跨页面、跨进程死亡都要存活,因此不适合页面作用域 ViewModel;页面 ViewModel 退出即清除,凭证残留会带来安全风险。
原理流程
登录成功 → 写安全存储 + 内存缓存
页面 → 从仓库读派生数据
退出登录 → 清存储令牌 + 清内存缓存
代码或图示
// 仓库持有进程级缓存,ViewModel 引用仓库而非令牌本身
class SessionRepository(private val store: TokenStore) {
fun currentToken(): String? = store.read()
}
常见误区
- 把登录令牌存进 Activity 作用域 ViewModel,新页面取不到。
- 退出登录只清内存不清持久化存储。
追问
- 多进程会话怎么同步?答:安全存储按进程读取;内存缓存各进程独立,需要跨进程状态走 IPC 或重新读取。
- 会话过期如何处理?答:仓库检测失效后清缓存并通知页面跳转登录。
07.1.1.6.1-090 弹窗、底部面板与宿主页面如何共享状态?
一句话结论
面板作为子视图或独立 Fragment 时,共享状态提升到宿主 Activity 或导航图作用域 ViewModel;面板自身的临时编辑态用页面/面板作用域,关闭即清除,避免残留到下次弹出。
概念解释
共享范围按生命周期需求决定:宿主长期可见用 Activity/图级;面板一次性输入用面板作用域;两者通过状态流通信,不直接互持 View。
原理流程
宿主 ViewModel(共享状态)
├─ 主页面订阅
└─ 面板 Fragment 订阅 / 写临时态
代码或图示
val shared: FilterViewModel by activityViewModels()
val panelLocal: PanelDraftViewModel by viewModels()
常见误区
- 面板草稿写进宿主 ViewModel,下次打开残留上次输入。
- 面板持有主页面 View 引用做回调刷新。
追问
- 面板关闭后状态保留吗?答:临时态随面板作用域清除;需保留的筛选条件提升到共享作用域或落盘。
- 弹窗用 DialogFragment 时 Owner 选谁?答:视图观察绑 Dialog 的 viewLifecycleOwner,共享数据取宿主作用域。
07.1.1.6.1-091 深度链接直接进入页面后状态如何恢复?
一句话结论
入口参数从导航 arguments/Handle 读取,页面按参数加载数据;进程死亡恢复时导航栈重建,参数从保存 Bundle 还原,未持久化的内存状态重新请求,处理好参数缺失与非法跳转兜底。
概念解释
深链可能直达深层页面,宿主链路与返回栈由系统/导航恢复;ViewModel 拿到参数后应判空校验,不能假设上游页面已准备好数据。
原理流程
深链 Intent → 目的地 arguments
→ ViewModel 读 Handle 参数
→ 校验 → 加载;缺参数回退或展示空态
代码或图示
fun init() {
val id = handle.get<Long>("itemId")
if (id == null || id < 0) { back(); return }
load(id)
}
常见误区
- 依赖上一个页面已缓存的数据,深链直达时仓库为空。
- 参数类型/格式不校验,崩溃或展示错误内容。
追问
- 深链权限与导出怎么配?答:目的地 exported 与 intent-filter 配置属清单/导航层,安全校验在服务端与页面入口都做。
- 恢复后返回栈如何?答:按系统重建的任务栈;自定义回退行为在目的地导航动作中定义。
07.1.1.6.1-092 配置变更时如何避免重复发起网络请求?
一句话结论
请求放在 ViewModel 作用域内执行,结果缓存在 ViewModel/仓库;重建后新视图订阅已有状态,不重新触发加载;ViewModel 存活期间不重复请求,进程死亡后由仓库缓存或网络重建。
概念解释
重复请求多因请求写在 Activity onCreate/onResume,重建即重发;把加载触发收敛到 ViewModel 初始化或状态驱动,配合仓库去重。
原理流程
首次进入 → ViewModel 触发加载 → 结果缓存
配置变更 → 重建 → 订阅缓存状态,不重发
代码或图示
fun load() {
if (_uiState.value is Loading) return // 进行中不重复发起
viewModelScope.launch { /* fetch */ }
}
常见误区
- 在
onResume里无条件刷新,每次回前台都请求。 - 仓库不缓存,ViewModel 重建后只能重新拉。
追问
- 下拉刷新与首次加载如何区分?答:显式刷新动作允许重发;初始化订阅命中缓存即展示。
- 请求进行中重建会丢失结果吗?答:ViewModel 存活时协程继续,结果回写状态;进程死亡则需重新请求。
07.1.1.6.1-093 ViewModel 过大时如何拆分?
一句话结论
按职责拆成多个 ViewModel(页面状态、列表、表单、弹窗),公共依赖下沉到仓库;状态与事件分流,单个 ViewModel 只维护一类界面状态,可独立测试与复用。
概念解释
信号:字段过多、多个不相关流程共用、构造依赖一串仓库、单测难以构造;拆分时先识别状态边界,再决定作用域层级。
原理流程
巨型 ViewModel
→ 识别状态簇(列表 / 表单 / 面板)
→ 拆为多个 ViewModel,共享数据走共同作用域或仓库
代码或图示
class ListViewModel(private val repo: ItemRepository) : ViewModel()
class FormViewModel(private val repo: FormRepository) : ViewModel()
常见误区
- 为拆而拆,把强相关的一个流程硬切成多个,互相频繁调用。
- 拆分后状态同步靠互相暴露可变字段。
追问
- 拆分后协作怎么保持单向?答:共享状态放仓库/共同作用域,各自暴露状态与意图事件。
- 何时保留单一 ViewModel?答:页面状态内聚、流程单一、依赖少时不必过度拆分。
07.1.1.6.1-094 全局共享状态与页面 ViewModel 的边界怎么定?
一句话结论
全局状态(会话、主题、配置)放进程级仓库/单例容器;页面状态放页面或导航作用域 ViewModel;边界是「离开该页面是否还需要」,需要则上移,不需要则留在页面作用域。
概念解释
提升作用域会延长存活与共享范围,带来串状态与泄漏风险;页面 ViewModel 不承担跨页面持久化职责。
原理流程
离开页面仍需 → 仓库 / 共同作用域
仅本页使用 → 页面 ViewModel
代码或图示
// 全局:SessionRepository(进程级)
// 页面:DetailViewModel(条目作用域)
常见误区
- 把页面筛选条件放全局单例,其他页面读到残留。
- 全局状态塞进 Activity 作用域 ViewModel,多页面耦合。
追问
- 全局容器如何释放?答:会话类随登录退出清理;进程结束统一回收。
- 全局状态变更如何通知页面?答:仓库暴露流,页面按生命周期订阅。
07.1.1.6.1-095 旧项目从 onSaveInstanceState 迁移到 ViewModel + SavedStateHandle 的路径是什么?
一句话结论
先按状态分类(内存态、可恢复小值、长期数据),把页面成员状态迁到 ViewModel,可序列化关键值改由 Handle 读写,旧 Bundle 回调逐步下线;迁移期双写兜底,验证旋转与进程死亡两条路径后再移除旧逻辑。
概念解释
不要一次性重写:先建立 ViewModel 承载状态,再把 Bundle 中的小值迁到 Handle,长期数据归仓库;每步保留可回退的旧实现对照。
原理流程
梳理现有 Bundle 键与成员字段
→ 建 ViewModel 迁内存态
→ 小值迁 Handle
→ 磁盘数据归仓库 → 移除旧回调
代码或图示
class LegacyViewModel(private val handle: SavedStateHandle) : ViewModel() {
var draft: String by handle
}
常见误区
- 直接把所有旧字段原样塞进 Handle,体积与类型问题未处理。
- 迁移后只测旋转,不测进程死亡恢复。
追问
- 旧
onSaveInstanceState自定义键如何映射?答:对应迁移到 Handle 同键或加前缀,恢复时兼容旧 Bundle。 - 验证清单?答:旋转、后台划灭进程、冷启动、深链进入四类路径分别核对状态。
07.1.1.6.1-096 ViewModel 与 SavedStateHandle 是从哪些版本引入的?
一句话结论
ViewModel 属于 AndroidX 架构组件早期引入;SavedStateHandle 随 lifecycle-viewmodel-savedstate 构件提供。具体最低依赖版本、包坐标与 API 变更需以官方 release notes 核对,本库不臆造版本号。
概念解释
版本敏感点包括:Handle 注入方式、工厂接口演进、Kotlin 委托扩展;项目升级时应对照当前 compileSdk 与 AndroidX BOM。
原理流程
核对 androidx.lifecycle / viewmodel BOM 版本
→ 确认 Handle 工厂与委托 API 可用
→ 旧版本行为差异标注「待确认」
代码或图示
// 版本以项目 BOM / 官方 release notes 为准,不在此写死坐标版本
implementation "androidx.lifecycle:lifecycle-viewmodel-ktx"
implementation "androidx.lifecycle:lifecycle-viewmodel-savedstate"
常见误区
- 凭记忆写死版本号,与项目实际 BOM 不符。
- 假设旧系统版本上新 API 行为一致。
追问
- 如何查当前引入版本?答:查看 Gradle 依赖树与 AndroidX release notes;API 缺失时编译/ lint 会提示。
- 待确认验证点?答:Handle 支持类型清单、工厂
CreationExtras可用版本边界。
07.1.1.6.1-097 repeatOnLifecycle 依赖什么构件,最低运行要求是什么?
一句话结论
repeatOnLifecycle 位于 lifecycle-runtime-ktx(Kotlin 扩展),协程能力依赖 kotlinx-coroutines;其 API 与最低 SDK/依赖版本以官方文档为准,本项目不臆造。
概念解释
使用前确认生命周期与协程构件已引入;纯 Java 项目没有该扩展,需手写生命周期感知取消逻辑。
原理流程
引入 lifecycle-runtime-ktx + coroutines
→ lifecycleScope.launch { repeatOnLifecycle(...) }
代码或图示
lifecycleScope.launch {
repeatOnLifecycle(Lifecycle.State.STARTED) {
viewModel.uiState.collect { /* render */ }
}
}
常见误区
- 只引协程不引 lifecycle-runtime-ktx,找不到 repeatOnLifecycle。
- 在 Fragment 视图未准备好时调用,Owner 状态异常。
追问
- 构件最低 minSdk?答:以官方文档与 BOM 为准(待确认)。
- 替代方案?答:手写 ON_START/ON_STOP 中启停协程,行为对齐但样板更多。
07.1.1.6.1-098 单元测试中如何构造 ViewModel 与 SavedStateHandle?
一句话结论
直接实例化 ViewModel 并传入测试仓库;需要 Handle 时构造 SavedStateHandle(emptyMap()) 或预置键值 map;用 runTest 测试 viewModelScope 协程,断言状态变更与取消行为。
概念解释
单测不依赖 Activity/Fragment:仓库用假实现替换,Handle 用预置数据模拟恢复;作用域在测试调度器上可控执行。
原理流程
new SavedStateHandle(mapOf("id" to 1L))
→ 构造 ViewModel(假仓库 + Handle)
→ 调用方法 → 断言状态流
代码或图示
@Test
fun `loads detail by id`() = runTest {
val handle = SavedStateHandle(mapOf("itemId" to 7L))
val vm = DetailViewModel(FakeRepository(), handle)
vm.load()
assertEquals(7, vm.uiState.value.item?.id)
}
常见误区
- 测试里用真实 Android 依赖(Context/系统服务)导致单测变集成测试。
- 不控制调度器,协程断言异步不稳定。
追问
- viewModelScope 在测试中怎么替换?答:可通过注入调度器或测试构造替换;内置 scope 用主调度器时按库测试能力处理。
- Handle 预置值能模拟进程恢复吗?答:可以模拟恢复后的初始值;完整重建链路需集成测试。
07.1.1.6.1-099 集成测试中如何模拟进程死亡后的状态恢复?
一句话结论
通过保存与恢复 savedInstanceState 的测试链路:先在界面操作产生状态,保存到 Bundle,销毁并重建 Owner/ViewModel,再从 Bundle 还原 Handle,断言草稿、锚点等关键值恢复。
概念解释
进程死亡测试区别于旋转重建:ViewModel 实例必须重建,只靠 Bundle/Handle 与磁盘存储恢复;测试要验证不可序列化与未持久化内容确实丢失。
原理流程
操作界面 → 保存状态到 Bundle
→ 销毁(ViewModel 重建)
→ 从 Bundle 还原 Handle → 断言恢复值
代码或图示
// 测试框架中模拟 savedInstanceState 保存/重建
val saved = Bundle()
// 保存 → 重建 → 断言 handle 中 "draft" 仍在
常见误区
- 用旋转测试代替进程死亡测试,实例未重建,掩盖内存依赖。
- 断言大列表也能恢复,实际未持久化必然丢失。
追问
- 设备上如何手动模拟?答:开发者选项「不保留活动」、后台划灭任务后返回;或用
am相关指令配合(具体命令以调试文档为准,待确认)。 - 恢复一致性验证什么?答:锚点位置、表单草稿、选中筛选;列表与位图按重加载设计断言。
07.1.1.6.1-100 线上 ViewModel 泄漏如何排查,有哪些典型案例?
一句话结论
用 LeakCanary 堆快照看泄漏链:ViewModel 被总线/静态单例/未反注册回调/旧 View 闭包引用;典型案例包括 EventBus 未反注册、RxJava 订阅未清理、匿名回调持有 binding、全局监听常驻。修复点是在 onCleared/视图销毁时解绑并释放引用。
概念解释
先确认泄漏对象是 ViewModel 还是其间接持有的 View;按引用链反向定位未释放的订阅或单例,再决定清理时机。
原理流程
堆转储 → LeakCanary 分析引用链
→ 找到长生命周期持有者
→ 补反注册 / 解引用 → 回归验证
代码或图示
override fun onCleared() {
bus.unregister(this)
disposables.clear()
super.onCleared()
}
常见误区
- 只取消 viewModelScope 协程,忘了其他订阅链路(总线、传感器、定位、蓝牙)。
- 用弱引用掩盖问题,回调闭包仍可能持有强引用链。
追问
- 线上如何采样堆快照?答:按崩溃/泄漏告警触发,结合 LeakCanary 或平台分析工具;具体采集策略以团队工具为准。
- 配置重建期间旧 View 被短暂引用算泄漏吗?答:重建结束后应可回收;若旧 View 树仍被 ViewModel 或闭包持有即算。
参考来源
- Android 官方文档:ViewModel:ViewModel 作用域、Store 生命周期与
onCleared机制。 - Android 官方文档:Lifecycle:状态机、事件、LifecycleOwner 与观察者接入方式。
- Android 官方文档:Saved State module for ViewModel:SavedStateHandle 注入、保存与恢复链路。
- Android 官方文档:ViewModel 与 Navigation 作用域:目的地与导航图作用域 ViewModel 的边界。
- AndroidX Lifecycle Release Notes:构件版本、API 演进与废弃说明(版本核对以该页为准)。
待整理清单
- [ ] 核对项目实际 AndroidX BOM 下 lifecycle/viewmodel/savedstate 构件的具体版本与最低 minSdk。
- [ ] 补充
repeatOnLifecycle与collectAsStateWithLifecycle在当前 Compose BOM 下的构件坐标与行为差异。 - [ ] 验证 Fragment 视图生命周期与导航条目生命周期在回栈场景下的事件顺序。
- [ ] 补充多进程下 ViewModel 内存隔离与会话缓存恢复的实测案例。
- [ ] 整理 LiveData 粘性事件的成熟替代方案与团队约定。