6. 异步处理与共享状态
6.1. 示例 19:协程、Flow 和定时器
许多事情都发生在“稍后”:定时器的滴答、按键、服务器的响应。[Dart] 有它的 [Future] 和 [Stream],[Kotlin] 则有协程:
- [suspend] 函数可以等待([delay]、服务器响应等)而不会冻结手机:等待期间,屏幕保持活跃。它稍后返回一个值:这相当于返回 [Future] 的 [async] 函数;
- [Flow<T>] 是随时间产生的一个值序列,可以使用运算符([map]、[debounce] 等)对其进行转换:相当于 [Stream];
- 协程在一个作用域中启动([LaunchedEffect]、[rememberCoroutineScope]、[viewModelScope] 等);当其作用域结束时,它被取消。
| // =========================================================================
// ex19/Ex19Activity.kt - 协程、Flow、定时器
// -------------------------------------------------------------------------
// 许多事情都发生在“稍后”:定时器的滴答、
// 按键、服务器的响应。Kotlin 为此提供了
// 协程:
// - “suspend”函数可以等待(delay、服务器的
// 响应等)而不阻塞手机:等待期间,屏幕
// 继续保持活跃。它稍后返回一个值;
// - Flow<T> 是随时间产生的值序列(滴答、
// 输入等),可以用运算符(map、debounce 等)转换;
// - 协程在一个作用域中启动:LaunchedEffect、
// rememberCoroutineScope 等;当其作用域消失时,它被取消。
// Compose 可以显示 Flow,在每个值到来时重组:
// collectAsStateWithLifecycle。
// =========================================================================
@file:OptIn(FlowPreview::class, ExperimentalCoroutinesApi::class)
package fr.stahe.examples.ex19
import android.os.Bundle
import androidx.activity.ComponentActivity
import androidx.activity.compose.setContent
import androidx.activity.enableEdgeToEdge
import androidx.compose.foundation.layout.Column
import androidx.compose.foundation.layout.fillMaxWidth
import androidx.compose.foundation.layout.padding
import androidx.compose.material3.Card
import androidx.compose.material3.MaterialTheme
import androidx.compose.material3.OutlinedTextField
import androidx.compose.material3.Text
import androidx.compose.runtime.Composable
import androidx.compose.runtime.LaunchedEffect
import androidx.compose.runtime.getValue
import androidx.compose.runtime.mutableStateListOf
import androidx.compose.runtime.mutableStateOf
import androidx.compose.runtime.produceState
import androidx.compose.runtime.remember
import androidx.compose.runtime.setValue
import androidx.compose.runtime.snapshotFlow
import androidx.compose.ui.Modifier
import androidx.compose.ui.graphics.Color
import androidx.compose.ui.unit.dp
import androidx.compose.ui.unit.sp
import androidx.lifecycle.compose.collectAsStateWithLifecycle
import fr.stahe.examples.common.ExamplePage
import fr.stahe.examples.common.ExamplesTheme
import kotlinx.coroutines.CancellationException
import kotlinx.coroutines.ExperimentalCoroutinesApi
import kotlinx.coroutines.FlowPreview
import kotlinx.coroutines.delay
import kotlinx.coroutines.flow.Flow
import kotlinx.coroutines.flow.debounce
import kotlinx.coroutines.flow.flow
import kotlinx.coroutines.flow.map
import kotlinx.coroutines.flow.mapLatest
import java.time.LocalTime
import java.time.format.DateTimeFormatter
import kotlin.random.Random
val doctors = listOf("Marie PELISSIER", "Paul TATOU", "Sophie DUPONT", "Jacques DURAND", "Martine PELLETIER")
// 一个模拟的“服务器”:一个挂起函数,其响应在
// 随机延迟之后到达
suspend fun search(text: String): List<String> {
delay(200L + Random.nextLong(600))
return doctors.filter { it.lowercase().contains(text) }
}
// 1. 由 flow { } 构建器构建的 Flow:每次 emit 都会向收集它的一方
// 发送一个值
fun countdown(start: Int): Flow<Int> = flow {
for (remaining in start downTo 0) {
emit(remaining)
if (remaining > 0) delay(1000)
}
}
fun currentTime(): String = LocalTime.now().format(DateTimeFormatter.ofPattern("HH:mm:ss"))
class Ex19Activity : ComponentActivity() {
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
enableEdgeToEdge()
setContent { ExamplesTheme { AsynchronousPage() } }
}
}
@Composable
fun AsynchronousPage() {
val log = remember { mutableStateListOf<String>() }
fun trace(message: String) = log.add("${currentTime()} $message")
// Flow 只创建一次(remember):否则每次重组
// 都会重新开始倒计时!
val countdownFlow = remember { countdown(20) }
// collectAsStateWithLifecycle:一个跟随 Flow 的值变化的状态
// (第一个值到来之前为 null);当应用
// 进入后台时,收集会停止
val remaining by countdownFlow.collectAsStateWithLifecycle(initialValue = null)
// 2. 边输入边搜索
var input by remember { mutableStateOf("") }
var results by remember { mutableStateOf(listOf<String>()) }
LaunchedEffect(Unit) {
// snapshotFlow:由 Compose 状态的连续值构成的 Flow
snapshotFlow { input }
// 防抖:只有在 400 毫秒内没有按键之后,输入才会被传递
.debounce(400)
.map { it.trim().lowercase() }
// mapLatest:新的输入会取消上一次尚未完成的
// 搜索:不会出现过期的响应
.mapLatest { text ->
// 少于两个字母:不搜索,没有结果
if (text.length < 2) return@mapLatest emptyList()
trace("search sent: \"$text\"")
try {
search(text)
} catch (e: CancellationException) {
trace("search cancelled (stale): \"$text\"")
throw e // 被取消的协程必须保持被取消的状态
}
}
// collect:逐个消费 Flow 的值
.collect { results = it }
}
// 3. 一秒之后到达的值:produceState 启动一个
// 产生状态的协程
val message by produceState<String?>(initialValue = null) {
delay(1000)
value = "three (one second later)"
}
val titleStyle = MaterialTheme.typography.titleSmall
ExamplePage("Example 19 - asynchronous code") {
Card(Modifier.fillMaxWidth()) {
Column(Modifier.padding(12.dp)) {
Text("A countdown (a Flow, collected)", style = titleStyle)
Text(remaining?.toString() ?: "...", style = MaterialTheme.typography.displaySmall)
}
}
Card(Modifier.fillMaxWidth()) {
Column(Modifier.padding(12.dp)) {
Text("A search as you type (debounce, stale responses)", style = titleStyle)
OutlinedTextField(
value = input,
onValueChange = { input = it },
placeholder = { Text("at least two letters: pel, dur...") },
singleLine = true,
modifier = Modifier.fillMaxWidth(),
)
for (r in results) Text("• $r")
if (results.isEmpty()) Text("no result", color = Color.Gray)
}
}
Card(Modifier.fillMaxWidth()) {
Column(Modifier.padding(12.dp)) {
Text("Waiting for a value (produceState)", style = titleStyle)
// 在值到达之前:显示等待文本
if (message == null) Text("waiting...", color = Color.Gray) else Text("received: $message")
}
}
Text("Log", style = titleStyle)
log.forEachIndexed { i, line -> Text("${i + 1}. $line", fontSize = 12.sp) }
}
}
|
- 第 65–67 行:一个模拟的“服务器”:一个挂起函数,其响应在随机延迟之后到达;
- 第 72–75 行:由 [flow [ ... ]] 创建的 [Flow]:每次 [emit] 都向收集它的一方发送一个值;[downTo]:递减循环;
- 第 96–100 行:[Flow] 只创建一次([remember]):否则每次重组都会重新开始倒计时![collectAsStateWithLifecycle] 实际上创建了一个跟踪其值的状态;当应用进入后台时,收集会停止;
- 第 107–125 行:边输入边搜索。[snapshotFlow [ input ]]:来自 [Compose] 状态的连续值的 [Flow];[debounce(400)],即防抖:只有在 400 毫秒内没有按键之后,才发送一次输入;[mapLatest]:新的输入会取消上一次尚未完成的搜索:不会出现过期响应;
- 第 119–121 行:被取消的协程会收到 [CancellationException]:可以记录它,但必须重新抛出([throw e])才能完成取消;
- 第 130–132 行:[produceState]:一个产生状态的协程(这里是一个在一秒钟之后到达的值)。


左图:启动时;右图:快速输入“pel”“du”再输入“dup”之后:只有后面跟着停顿的按键才触发了搜索,显示的是最后一次搜索的结果。
6.2. 示例 20:共享状态
“存储”是存活于屏幕之外的状态,只有一个实例,由所有读取它的组件共享。示例 14 是手动做到这一点的;[Android] 为此提供了以下机制:一个按需创建的对象([viewModel()]),然后对所有请求它的组件呈现为同一个对象,并且在 Activity 发生变更(屏幕旋转、语言更改)时会被重新创建。这相当于 [Flutter] 的 [provider] 或 [riverpod] 包。
| // =========================================================================
// ex20/stores/Cart.kt - 位于 ViewModel 中的共享状态
// -------------------------------------------------------------------------
// “存储”是存活于屏幕之外的状态,只有一份
// 副本,由所有读取它的组件共享。示例 14 是
// 手动做到这一点的(CompositionLocal);Android 为此提供了 ViewModel:
// - 一个在第一次请求时创建的对象,之后对
// Activity 中所有请求它的函数都返回同一个对象:viewModel();
// - 它能在 Activity 被重新创建(屏幕旋转、
// 更改语言)后存活:只有当 Activity
// 被彻底关闭时它才会被销毁。
// 常见的组织方式:
// - 状态:一个私有的 MutableStateFlow,一个可观察的值;对外只能看到
// 它的只读版本(StateFlow);
// - 动作:函数,只有它们才会修改状态;
// - 计算值:由第一个状态推导出的其他 StateFlow(map),
// 只有它们的值变化时才会变化。
// =========================================================================
package fr.stahe.examples.ex20.stores
import androidx.lifecycle.ViewModel
import androidx.lifecycle.viewModelScope
import kotlinx.coroutines.flow.MutableStateFlow
import kotlinx.coroutines.flow.SharingStarted
import kotlinx.coroutines.flow.StateFlow
import kotlinx.coroutines.flow.asStateFlow
import kotlinx.coroutines.flow.map
import kotlinx.coroutines.flow.stateIn
import kotlinx.coroutines.flow.update
data class Item(val label: String, val price: Double)
class Cart : ViewModel() {
private val _items = MutableStateFlow(listOf<Item>())
val items: StateFlow<List<Item>> = _items.asStateFlow()
// 推导出的值:stateIn 把它们变成 StateFlow,它们的存活时间
// 与 ViewModel 相同(viewModelScope)
val count: StateFlow<Int> = items.map { it.size }.stateIn(viewModelScope, SharingStarted.Eagerly, 0)
val total: StateFlow<Double> = items.map { list -> list.sumOf { it.price } }.stateIn(viewModelScope, SharingStarted.Eagerly, 0.0)
// update:用一个根据旧值计算出的新值替换当前值
fun add(item: Item) = _items.update { it + item }
fun clear() {
_items.value = emptyList()
}
}
|
- 第 34–35 行:状态:一个私有的 [MutableStateFlow],一个可观察的值;对外只能看到只读版本([StateFlow]);
- 第 39–40 行:推导出的值:[map],然后是 [stateIn],它又创建了在 [ViewModel] 存活期间一直存在的 [StateFlow]([viewModelScope])。[StateFlow] 只有在其值变化时才会发出;
- 第 43–46 行:只有这些动作才会修改状态;[update] 用一个根据旧值计算出的新值替换当前值。
要让数据在应用停止之后依然保留,必须把它存储在设备上。[DataStore] 库来自 [Jetpack],它提供一个小型的键值字典,存储在应用专属的文件中:
| // =========================================================================
// ex20/stores/Preferences.kt - 一个在停止之后依然保留的状态
// -------------------------------------------------------------------------
// 要让数据在应用停止之后依然保留,必须把它存储
// 在设备上。Jetpack DataStore 库提供一个小型
// 键 -> 值字典(Boolean、Int、Float、String 等),专属于
// 应用,保存在手机的一个文件中:
// - 读取是一个 Flow:它发出已存储的值(异步
// 读取,不阻塞屏幕),然后发出每个新值;
// - 写入是一个挂起函数(edit)。
// 绝不要在其中存储敏感数据(密码、令牌):它们会
// 以明文写入。
// =========================================================================
package fr.stahe.examples.ex20.stores
import android.content.Context
import androidx.datastore.core.DataStore
import androidx.datastore.preferences.core.Preferences
import androidx.datastore.preferences.core.booleanPreferencesKey
import androidx.datastore.preferences.core.edit
import androidx.datastore.preferences.core.floatPreferencesKey
import androidx.datastore.preferences.preferencesDataStore
import kotlinx.coroutines.flow.Flow
import kotlinx.coroutines.flow.map
// 示例的偏好设置文件:Context 的一个扩展属性,
// 委托给 preferencesDataStore(每个文件只有一个 DataStore)
val Context.storage: DataStore<Preferences> by preferencesDataStore(name = "example20")
// 存储的内容
data class Settings(val dark: Boolean, val size: Float)
class UserPreferences(private val storage: DataStore<Preferences>) {
private val darkKey = booleanPreferencesKey("dark")
private val sizeKey = floatPreferencesKey("size")
// 设备所存储的内容,否则使用默认值
val settings: Flow<Settings> = storage.data.map { p -> Settings(p[darkKey] ?: false, p[sizeKey] ?: 16f) }
// 每个偏好设置对应一个可选的具名参数:只有提供的内容才会被修改
suspend fun update(dark: Boolean? = null, size: Float? = null) {
storage.edit { p ->
if (dark != null) p[darkKey] = dark
if (size != null) p[sizeKey] = size
}
}
}
|
- 第 28 行:示例的偏好设置文件:[Context] 的一个扩展属性,委托给 [preferencesDataStore](每个文件只有一个 [DataStore]);
- 第 38 行:读取操作是一个 [Flow]:它输出已存储的值(读取时不会阻塞屏幕),然后输出每个新值;
- 第 41–44 行:写入操作是一个挂起函数([edit])。敏感数据(密码、令牌)绝不存放在这里:它们会以明文写入。
使用购物车的组件:
| // =========================================================================
// ex20/components/Components.kt - 示例 20 的三个组件
// -------------------------------------------------------------------------
// viewModel():Activity 的 Cart,在第一次请求时创建,之后
// 对所有请求它的组件都是同一个。
// =========================================================================
package fr.stahe.examples.ex20.components
import androidx.compose.foundation.layout.Column
import androidx.compose.foundation.layout.Row
import androidx.compose.foundation.layout.Spacer
import androidx.compose.foundation.layout.padding
import androidx.compose.foundation.layout.width
import androidx.compose.material.icons.Icons
import androidx.compose.material.icons.filled.Add
import androidx.compose.material.icons.filled.ShoppingCart
import androidx.compose.material3.Card
import androidx.compose.material3.Icon
import androidx.compose.material3.ListItem
import androidx.compose.material3.MaterialTheme
import androidx.compose.material3.OutlinedButton
import androidx.compose.material3.Text
import androidx.compose.material3.TextButton
import androidx.compose.runtime.Composable
import androidx.compose.runtime.getValue
import androidx.compose.runtime.mutableIntStateOf
import androidx.compose.runtime.saveable.rememberSaveable
import androidx.compose.runtime.setValue
import androidx.compose.ui.Alignment
import androidx.compose.ui.Modifier
import androidx.compose.ui.unit.dp
import androidx.lifecycle.compose.collectAsStateWithLifecycle
import androidx.lifecycle.viewmodel.compose.viewModel
import fr.stahe.examples.ex20.stores.Item
import fr.stahe.examples.ex20.stores.Cart
val products = listOf(Item("Consultation", 30.0), Item("Vaccine", 12.5))
// 向共享购物车添加商品:商店不读取购物车,所以
// 购物车变化时它不会被重组
@Composable
fun Shop(cart: Cart = viewModel()) {
Card {
Column(Modifier.padding(12.dp)) {
Text("Shop", style = MaterialTheme.typography.titleSmall)
for (p in products) {
TextButton(onClick = { cart.add(p) }) {
Icon(Icons.Default.Add, contentDescription = null)
Text("${p.label} (€${p.price})")
}
}
}
}
}
// 读取同一个购物车:只读取数量和总价(只有当这两者之一
// 变化时才重组)
@Composable
fun CartSummary(cart: Cart = viewModel()) {
val count by cart.count.collectAsStateWithLifecycle()
val total by cart.total.collectAsStateWithLifecycle()
Card {
Row(Modifier.padding(12.dp), verticalAlignment = Alignment.CenterVertically) {
Icon(Icons.Default.ShoppingCart, contentDescription = null)
Spacer(Modifier.width(8.dp))
Text("$count item(s), €$total", Modifier.weight(1f))
TextButton(onClick = { cart.clear() }, enabled = count > 0) { Text("Clear") }
}
}
}
// 一个局部状态(rememberSaveable),它随组件一起消失……
// 除非把它放在 SaveableStateProvider 中(参见 Ex20Activity.kt)
@Composable
fun LocalCounter(title: String) {
var clicks by rememberSaveable { mutableIntStateOf(0) }
Card {
ListItem(
headlineContent = { Text(title) },
trailingContent = { OutlinedButton(onClick = { clicks++ }) { Text("$clicks click(s)") } },
)
}
}
|
- 第 42 行:[cart: Cart = viewModel()]:Activity 的购物车,在首次请求时创建。商店([Shop])向购物车添加商品而不读取它:购物车变化时它不会被重新生成;
- 第 60–61 行:摘要只读取数量和总价;只有当其中任何一个变化时才会重新生成;
- 第 75–76 行:一个计数器(局部的),它随组件一起消失。
屏幕:
| // =========================================================================
// ex20/Ex20Activity.kt - 数据的三种“作用域”
// -------------------------------------------------------------------------
// - 组件的局部状态(LocalCounter)随组件一起消失;
// - 存储(购物车,一个 ViewModel)的状态由所有
// 组件共享,并且在它们被移除后依然存在,甚至在屏幕
// 旋转后也是如此,但应用停止之后则不然;
// - 存储在设备上的状态(偏好设置,DataStore)在应用停止之后
// 依然保留。
// 还有 SaveableStateHolder:它保存已从屏幕上移除的内容的
// 局部状态(rememberSaveable),并在内容返回时将其交还。
// 取消勾选再重新勾选“show the area”,然后停止并重新启动
// 应用:比较一下。
// =========================================================================
package fr.stahe.examples.ex20
import android.os.Bundle
import androidx.activity.ComponentActivity
import androidx.activity.compose.setContent
import androidx.activity.enableEdgeToEdge
import androidx.compose.foundation.layout.padding
import androidx.compose.foundation.selection.toggleable
import androidx.compose.material3.Checkbox
import androidx.compose.material3.ListItem
import androidx.compose.material3.Slider
import androidx.compose.material3.Switch
import androidx.compose.material3.Text
import androidx.compose.runtime.Composable
import androidx.compose.runtime.CompositionLocalProvider
import androidx.compose.runtime.getValue
import androidx.compose.runtime.mutableStateOf
import androidx.compose.runtime.rememberCoroutineScope
import androidx.compose.runtime.saveable.rememberSaveable
import androidx.compose.runtime.saveable.rememberSaveableStateHolder
import androidx.compose.runtime.setValue
import androidx.compose.ui.Modifier
import androidx.compose.ui.platform.LocalDensity
import androidx.compose.ui.unit.Density
import androidx.compose.ui.unit.dp
import androidx.lifecycle.compose.collectAsStateWithLifecycle
import fr.stahe.examples.common.ExamplePage
import fr.stahe.examples.common.ExamplesTheme
import fr.stahe.examples.ex20.components.Shop
import fr.stahe.examples.ex20.components.LocalCounter
import fr.stahe.examples.ex20.components.CartSummary
import fr.stahe.examples.ex20.stores.UserPreferences
import fr.stahe.examples.ex20.stores.storage
import kotlinx.coroutines.launch
import kotlin.math.roundToInt
class Ex20Activity : ComponentActivity() {
// lazy:对象在首次使用时创建(构建 Activity 时,应用上下文
// 尚不存在)
private val preferences by lazy { UserPreferences(applicationContext.storage) }
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
enableEdgeToEdge()
setContent { App(preferences) }
}
}
@Composable
fun App(preferences: UserPreferences) {
// 已存储的偏好设置:在读取完成之前为 null
val settings by preferences.settings.collectAsStateWithLifecycle(initialValue = null)
val s = settings ?: return // 在读取完成之前没有可显示的内容(几毫秒)
val scope = rememberCoroutineScope()
// 深色主题,或浅色主题
ExamplesTheme(dark = s.dark) {
// 文字大小:fontScale 会放大所有文本的大小
val density = LocalDensity.current
CompositionLocalProvider(LocalDensity provides Density(density.density, fontScale = s.size / 16f)) {
SharedStatePage(
dark = s.dark,
size = s.size,
onDark = { v -> scope.launch { preferences.update(dark = v) } },
onSize = { v -> scope.launch { preferences.update(size = v) } },
)
}
}
}
@Composable
fun SharedStatePage(dark: Boolean, size: Float, onDark: (Boolean) -> Unit, onSize: (Float) -> Unit) {
var areaVisible by rememberSaveable { mutableStateOf(true) }
// 被移除内容的状态的保管者
val keptStates = rememberSaveableStateHolder()
ExamplePage("Example 20 - a shared state") {
ListItem(
headlineContent = { Text("dark theme") },
trailingContent = { Switch(checked = dark, onCheckedChange = onDark) },
)
ListItem(
headlineContent = { Text("text size: ${size.roundToInt()}") },
supportingContent = { Slider(value = size, onValueChange = onSize, valueRange = 12f..22f, steps = 9) },
)
ListItem(
modifier = Modifier.toggleable(value = areaVisible, onValueChange = { areaVisible = it }),
leadingContent = { Checkbox(checked = areaVisible, onCheckedChange = null) },
headlineContent = { Text("show the area") },
)
if (areaVisible) {
// 已移除:这些组件连同它们的局部状态一起消失
Shop()
CartSummary()
LocalCounter("Local state")
// 同样被移除,但它的状态由 keptStates 保留,键为“counter”
keptStates.SaveableStateProvider("counter") {
LocalCounter("Local state, kept by a SaveableStateHolder")
}
}
Text(
"Outside the area, a second summary of the SAME cart (it stays there when the area disappears):",
Modifier.padding(vertical = 8.dp),
)
CartSummary()
}
}
|
- 第 54 行:[by lazy]:对象在首次使用时创建(构建 Activity 时应用上下文尚不存在);
- 第 66–67 行:读取偏好设置;[?: return]:在读取完成之前(几毫秒)没有任何内容可显示;
- 第 71–79 行:深色或浅色主题,以及文字大小(所有文本:[fontScale] 和 [LocalDensity]);更改偏好设置会启动一个协程;
- 第 89–112 行:[rememberSaveableStateHolder]:一个保管者,它会保存已从屏幕上移除的内容的局部状态([rememberSaveable]),并在内容返回时恢复它。



左图:两个商品,并点击了两个计数器;中图:深色主题且区域已隐藏:区域之外的摘要仍然显示购物车;右图:区域重新显示:购物车完好无损,局部计数器已重置为 0,而被保存的计数器恢复了原来的值。停止应用再重新启动:只有偏好设置(主题、文字大小)被保留了下来。