Android Compose 框架组合生命周期（DisposableEffect、LaunchedEffect）深入剖析
一、引言
在现代 Android 开发领域，Android Compose 以其声明式的 UI 构建方式逐渐成为开发者的首选。它摒弃了传统 Android 开发中繁琐的视图操作，使得代码更加简洁、易读和可维护。而在 Android Compose 的生态系统中，组合生命周期管理是一个核心且关键的概念。其中，DisposableEffect 和 LaunchedEffect 这两个重要的 API 扮演着举足轻重的角色，它们分别负责资源管理和异步操作的处理，对于保证应用的性能、稳定性以及资源的合理利用起着至关重要的作用。本文将从源码级别出发，对 DisposableEffect 和 LaunchedEffect 进行全面且深入的分析，详细探讨它们的工作原理、使用方法以及在实际开发中的各种应用场景。
二、Android Compose 组合生命周期基础概念
2.1 组合生命周期的基本定义
在 Android Compose 里，组合生命周期描述了 Composable 函数从创建到销毁的整个过程。这个过程包含了多个关键阶段，如组合（composition）、布局（layout）和绘制（drawing）等。每个阶段都有其特定的任务和意义，并且在不同的阶段，Composable 函数可能需要执行不同的操作，例如初始化资源、启动异步任务或者释放资源等。理解组合生命周期的各个阶段，是正确使用 DisposableEffect 和 LaunchedEffect 的基础。
2.2 组合生命周期的重要性
合理管理组合生命周期对于 Android Compose 应用的性能和稳定性有着决定性的影响。如果不能正确处理资源的初始化和释放，就可能会导致内存泄漏、资源浪费等严重问题。例如，在一个 Composable 函数中，如果在组合创建时打开了一个文件或者注册了一个广播接收器，但在组合销毁时没有及时关闭文件或者取消注册广播接收器，就会造成资源的浪费和内存泄漏。而 DisposableEffect 和 LaunchedEffect 正是为了解决这些问题而设计的，它们可以帮助开发者精确控制资源的生命周期，确保资源在需要时被创建，在不需要时被及时释放，从而提高应用的性能和稳定性。
三、DisposableEffect 的使用与源码深度解析
3.1 DisposableEffect 的基础使用示例
DisposableEffect 是一个非常实用的 Composable 函数，主要用于在组合生命周期的特定阶段执行副作用操作，并且在组合被销毁时进行资源清理。下面是一个简单的示例：
kotlin
import androidx.compose.runtime.*
import androidx.compose.material.Text
import androidx.compose.runtime.Composable
@Composable
fun DisposableEffectExample() {
// 使用 DisposableEffect 来管理资源
DisposableEffect(Unit) {
// 在组合创建时执行初始化操作，这里可以初始化一些资源，比如打开文件、注册广播接收器等
println("Effect started")
// 定义一个销毁操作，当组合被销毁时会调用这个操作，用于释放之前初始化的资源
onDispose {
println("Effect disposed")
}
}
Text(text = "DisposableEffect Example")
}
在这个示例中，DisposableEffect 接收一个 Unit 作为键，这意味着该副作用只在组合创建时执行一次。在 DisposableEffect 的 lambda 表达式中，我们可以执行初始化操作，同时通过 onDispose 函数定义资源清理操作。
3.2 DisposableEffect 函数的源码详细解析
DisposableEffect 函数的源码如下：
kotlin
/**
* 创建一个副作用，该副作用在组合创建时执行，在组合销毁时清理。
*
* @param key1 用于判断是否需要重新执行副作用的键，如果键发生变化，副作用会重新执行。
* @param effect 副作用操作的 lambda 表达式，该表达式需要返回一个销毁操作的 lambda 表达式。
*/
@Composable
fun DisposableEffect(
key1: Any?,
effect: DisposableEffectScope.() -> Disposable?
) {
// 获取当前的组合上下文
val current = currentComposer
// 开始一个可替换的组，用于管理组合的状态
current.startReplaceableGroup(0x728c2a2d)
// 使用 remember 函数来记住副作用的状态
val disposableHolder = remember(key1) {
// 创建一个 DisposableHolder 对象，用于持有销毁操作
DisposableHolder()
}
// 检查是否需要重新执行副作用
if (disposableHolder.key != key1) {
// 如果需要重新执行，先调用之前的销毁操作
disposableHolder.dispose()
// 执行新的副作用操作
disposableHolder.disposable = effect(DisposableEffectScopeImpl())
// 更新键
disposableHolder.key = key1
}
// 结束可替换的组
current.endReplaceableGroup()
// 在组合销毁时调用销毁操作
DisposableEffectImpl(disposableHolder)
}
-
参数分析：
key1：这是一个用于判断是否需要重新执行副作用的关键参数。如果key1的值发生了变化，那么副作用就会重新执行。通过合理设置key1，可以避免不必要的副作用重复执行，提高应用的性能。effect：这是一个副作用操作的 lambda 表达式，该表达式需要返回一个销毁操作的 lambda 表达式。在这个 lambda 表达式中，我们可以执行初始化操作，同时定义在组合销毁时需要执行的清理操作。
-
返回值说明：该函数没有返回值。
-
实现细节剖析：
- 首先，通过
currentComposer获取当前的组合上下文，这个上下文用于管理组合的状态。 - 接着，调用
startReplaceableGroup方法开始一个可替换的组，这有助于管理组合的状态。 - 使用
remember函数来记住DisposableHolder对象，该对象用于持有销毁操作。remember函数可以确保在组合重建时，DisposableHolder对象不会被重新创建，从而避免不必要的资源浪费。 - 检查
key1是否发生变化，如果发生变化，说明需要重新执行副作用。此时，先调用之前的销毁操作，然后执行新的副作用操作，并更新key1的值。 - 调用
endReplaceableGroup方法结束可替换的组。 - 最后，在组合销毁时调用
DisposableEffectImpl函数，该函数会调用DisposableHolder对象的销毁操作，确保资源被正确释放。
- 首先，通过
3.3 DisposableEffectScope 接口的源码分析
DisposableEffectScope 接口定义了 DisposableEffect 的作用域，其源码如下：
kotlin
/**
* DisposableEffect 的作用域接口。
*/
interface DisposableEffectScope {
/**
* 定义一个销毁操作，当组合被销毁时会调用这个操作。
*
* @param onDispose 销毁操作的 lambda 表达式。
* @return 一个 Disposable 对象，用于表示销毁操作。
*/
fun onDispose(onDispose: () -> Unit): Disposable
}
-
方法解析：
onDispose：该方法用于定义销毁操作，当组合被销毁时会调用这个操作。它接收一个 lambda 表达式作为参数，并返回一个Disposable对象，这个对象代表了销毁操作。通过这个方法，我们可以在组合销毁时执行一些必要的清理操作，如关闭文件、取消注册广播接收器等。
3.4 Disposable 接口的源码分析
Disposable 接口定义了一个销毁操作，其源码如下：
kotlin
/**
* 定义一个销毁操作的接口。
*/
interface Disposable {
/**
* 执行销毁操作。
*/
fun dispose()
}
-
方法说明：
dispose：该方法用于执行销毁操作。实现了Disposable接口的类需要实现这个方法，在方法中编写具体的销毁逻辑，如释放资源、取消任务等。
3.5 DisposableEffectImpl 函数的源码分析
DisposableEffectImpl 函数用于在组合销毁时调用销毁操作，其源码如下：
kotlin
/**
* 在组合销毁时调用销毁操作。
*
* @param disposableHolder 持有销毁操作的 DisposableHolder 对象。
*/
@Composable
private fun DisposableEffectImpl(disposableHolder: DisposableHolder) {
// 获取当前的组合上下文
val current = currentComposer
// 开始一个可替换的组
current.startReplaceableGroup(0x728c2a2e)
// 在组合销毁时调用销毁操作
DisposableEffect(Unit) {
onDispose {
disposableHolder.dispose()
}
}
// 结束可替换的组
current.endReplaceableGroup()
}
-
参数说明：
disposableHolder：这是一个持有销毁操作的DisposableHolder对象。通过这个对象，我们可以在组合销毁时调用其dispose方法，执行具体的销毁操作。
-
实现细节：
- 获取当前的组合上下文
currentComposer。 - 调用
startReplaceableGroup方法开始一个可替换的组。 - 使用
DisposableEffect函数在组合销毁时调用disposableHolder的dispose方法，确保资源被正确释放。 - 调用
endReplaceableGroup方法结束可替换的组。
- 获取当前的组合上下文
3.6 DisposableHolder 类的源码分析
DisposableHolder 类用于持有销毁操作，其源码如下：
kotlin
/**
* 用于持有销毁操作的类。
*/
private class DisposableHolder {
// 持有销毁操作的 Disposable 对象
var disposable: Disposable? = null
// 用于判断是否需要重新执行副作用的键
var key: Any? = null
/**
* 执行销毁操作。
*/
fun dispose() {
disposable?.dispose()
disposable = null
}
}
-
属性说明：
disposable：该属性持有销毁操作的Disposable对象，通过这个对象可以执行具体的销毁操作。key：该属性用于判断是否需要重新执行副作用。当key的值发生变化时，会重新执行副作用。
-
方法说明：
dispose：该方法用于执行销毁操作。它会调用disposable对象的dispose方法，并将disposable置为null，确保资源被正确释放。
四、LaunchedEffect 的使用与源码深度解析
4.1 LaunchedEffect 的基础使用示例
LaunchedEffect 是一个专门用于在组合生命周期的特定阶段启动异步任务的 Composable 函数。以下是一个简单的示例：
kotlin
import androidx.compose.runtime.*
import androidx.compose.material.Text
import androidx.compose.runtime.Composable
import kotlinx.coroutines.delay
@Composable
fun LaunchedEffectExample() {
// 使用 LaunchedEffect 启动一个异步任务
LaunchedEffect(Unit) {
// 模拟一个异步操作，比如网络请求、数据库查询等
delay(1000)
println("Async operation completed")
}
Text(text = "LaunchedEffect Example")
}
在这个示例中，LaunchedEffect 接收一个 Unit 作为键，这意味着该异步任务只在组合创建时启动一次。在 LaunchedEffect 的 lambda 表达式中，我们可以使用协程来执行异步操作。
4.2 LaunchedEffect 函数的源码详细解析
LaunchedEffect 函数的源码如下：
kotlin
/**
* 在组合生命周期的特定阶段启动一个协程。
*
* @param key1 用于判断是否需要重新启动协程的键，如果键发生变化，协程会重新启动。
* @param block 协程的执行体，是一个挂起函数。
*/
@Composable
fun LaunchedEffect(
key1: Any?,
block: suspend CoroutineScope.() -> Unit
) {
// 获取当前的组合上下文
val current = currentComposer
// 开始一个可替换的组
current.startReplaceableGroup(0x728c2a2f)
// 获取当前的协程作用域
val coroutineScope = currentComposer.coroutineScope
// 使用 remember 函数来记住协程的状态
val jobHolder = remember(key1) {
// 创建一个 JobHolder 对象，用于持有协程的 Job
JobHolder()
}
// 检查是否需要重新启动协程
if (jobHolder.key != key1) {
// 如果需要重新启动，先取消之前的协程
jobHolder.job?.cancel()
// 启动新的协程
jobHolder.job = coroutineScope.launch(block = block)
// 更新键
jobHolder.key = key1
}
// 结束可替换的组
current.endReplaceableGroup()
// 在组合销毁时取消协程
DisposableEffect(Unit) {
onDispose {
jobHolder.job?.cancel()
}
}
}
-
参数分析：
key1：用于判断是否需要重新启动协程的键。如果key1的值发生变化，协程会重新启动。通过合理设置key1，可以避免不必要的协程重复启动，提高应用的性能。block：协程的执行体，是一个挂起函数。在这个挂起函数中，我们可以编写异步操作的代码，如网络请求、数据库查询等。
-
返回值说明：该函数没有返回值。
-
实现细节剖析：
- 获取当前的组合上下文
currentComposer，用于管理组合的状态。 - 调用
startReplaceableGroup方法开始一个可替换的组。 - 获取当前的协程作用域
coroutineScope，通过这个作用域可以启动协程。 - 使用
remember函数来记住JobHolder对象，该对象用于持有协程的Job。remember函数可以确保在组合重建时，JobHolder对象不会被重新创建，从而避免不必要的资源浪费。 - 检查
key1是否发生变化，如果发生变化，说明需要重新启动协程。此时，先取消之前的协程，然后启动新的协程，并更新key1的值。 - 调用
endReplaceableGroup方法结束可替换的组。 - 使用
DisposableEffect函数在组合销毁时取消协程，确保协程在不需要时被及时取消，避免资源浪费。
- 获取当前的组合上下文
4.3 JobHolder 类的源码分析
JobHolder 类用于持有协程的 Job，其源码如下：
kotlin
/**
* 用于持有协程的 Job 的类。
*/
private class JobHolder {
// 持有协程的 Job
var job: Job? = null
// 用于判断是否需要重新启动协程的键
var key: Any? = null
}
-
属性说明：
job：该属性持有协程的Job，通过这个Job对象可以控制协程的生命周期，如取消协程等。key：该属性用于判断是否需要重新启动协程。当key的值发生变化时，会重新启动协程。
五、DisposableEffect 和 LaunchedEffect 的实际应用场景
5.1 DisposableEffect 的应用场景
5.1.1 资源管理
在 Android 开发中，很多资源需要在使用完毕后进行释放，例如文件句柄、数据库连接、广播接收器等。DisposableEffect 可以帮助我们在组合创建时初始化这些资源，在组合销毁时释放这些资源。以下是一个注册广播接收器的示例：
kotlin
import android.content.BroadcastReceiver
import android.content.Context
import android.content.Intent
import android.content.IntentFilter
import androidx.compose.runtime.*
import androidx.compose.material.Text
import androidx.compose.runtime.Composable
import androidx.compose.ui.platform.LocalContext
@Composable
fun BroadcastReceiverExample() {
// 获取当前的上下文
val context = LocalContext.current
// 使用 DisposableEffect 来管理广播接收器
DisposableEffect(Unit) {
// 创建一个广播接收器
val receiver = object : BroadcastReceiver() {
override fun onReceive(context: Context, intent: Intent) {
println("Received broadcast: ${intent.action}")
}
}
// 注册广播接收器
val filter = IntentFilter(Intent.ACTION_BATTERY_CHANGED)
context.registerReceiver(receiver, filter)
// 定义销毁操作，在组合销毁时取消注册广播接收器
onDispose {
context.unregisterReceiver(receiver)
}
}
Text(text = "Broadcast Receiver Example")
}
5.1.2 动画资源管理
在 Android Compose 中，动画也需要进行资源管理。例如，当动画不再需要时，需要停止动画并释放相关资源。DisposableEffect 可以帮助我们在组合销毁时停止动画。以下是一个简单的动画示例：
kotlin
import androidx.compose.animation.core.*
import androidx.compose.foundation.background
import androidx.compose.foundation.layout.*
import androidx.compose.material.Text
import androidx.compose.runtime.*
import androidx.compose.ui.Modifier
import androidx.compose.ui.graphics.Color
import androidx.compose.ui.unit.dp
@Composable
fun AnimationResourceManagementExample() {
// 定义一个动画值
val animatedValue = rememberInfiniteTransition().animateFloat(
initialValue = 0f,
targetValue = 1f,
animationSpec = infiniteRepeatable(
animation = tween(durationMillis = 1000),
repeatMode = RepeatMode.Reverse
)
)
// 使用 DisposableEffect 来管理动画资源
DisposableEffect(Unit) {
// 这里可以进行一些初始化操作
// 定义销毁操作，在组合销毁时停止动画
onDispose {
// 目前没有直接停止 rememberInfiniteTransition 的方法，这里可以根据具体情况进行处理
// 例如，取消相关的协程等
}
}
Box(
modifier = Modifier
.size(100.dp)
.background(Color.Blue.copy(alpha = animatedValue.value))
) {
Text(text = "Animated Box")
}
}
5.2 LaunchedEffect 的应用场景
5.2.1 网络请求
在 Android 应用中，网络请求是一个常见的异步操作。LaunchedEffect 可以帮助我们在组合创建时启动网络请求，并在组合销毁时取消请求。以下是一个简单的网络请求示例：
kotlin
import androidx.compose.runtime.*
import androidx.compose.material.Text
import androidx.compose.runtime.Composable
import kotlinx.coroutines.delay
import kotlinx.coroutines.withContext
import kotlin.coroutines.CoroutineContext
import kotlin.coroutines.EmptyCoroutineContext
// 模拟一个网络请求函数
suspend fun fetchData(): String {
// 模拟网络延迟
delay(1000)
return "Data from network"
}
@Composable
fun NetworkRequestExample() {
// 定义一个状态来保存网络请求的结果
var data by remember { mutableStateOf<String?>(null) }
// 使用 LaunchedEffect 启动网络请求
LaunchedEffect(Unit) {
try {
// 执行网络请求
val result = fetchData()
// 更新状态
data = result
} catch (e: Exception) {
// 处理异常
println("Network request error: ${e.message}")
}
}
if (data != null) {
Text(text = data!!)
} else {
Text(text = "Loading...")
}
}
5.2.2 数据库查询
在 Android 应用中，数据库查询也是一个常见的异步操作。LaunchedEffect 可以帮助我们在组合创建时启动数据库查询，并在组合销毁时取消查询。以下是一个简单的数据库查询示例：
kotlin
import androidx.compose.runtime.*
import androidx.compose.material.Text
import androidx.compose.runtime.Composable
import kotlinx.coroutines.delay
import kotlinx.coroutines.withContext
import kotlin.coroutines.CoroutineContext
import kotlin.coroutines.EmptyCoroutineContext
// 模拟一个数据库查询函数
suspend fun queryDatabase(): List<String> {
// 模拟数据库查询延迟
delay(1000)
return listOf("Data 1", "Data 2", "Data 3")
}
@Composable
fun DatabaseQueryExample() {
// 定义一个状态来保存数据库查询的结果
var data by remember { mutableStateOf<List<String>?>(null) }
// 使用 LaunchedEffect 启动数据库查询
LaunchedEffect(Unit) {
try {
// 执行数据库查询
val result = queryDatabase()
// 更新状态
data = result
} catch (e: Exception) {
// 处理异常
println("Database query error: ${e.message}")
}
}
if (data != null) {
data!!.forEach { item ->
Text(text = item)
}
} else {
Text(text = "Loading...")
}
}
六、DisposableEffect 和 LaunchedEffect 的性能优化策略
6.1 减少不必要的副作用执行
在使用 DisposableEffect 和 LaunchedEffect 时，应尽量减少不必要的副作用执行。可以通过合理设置键来避免副作用的重复执行。例如，在 DisposableEffect 中，如果某个资源只需要在组合创建时初始化一次，可以使用 Unit 作为键：
kotlin
DisposableEffect(Unit) {
// 初始化资源
println("Resource initialized")
onDispose {
// 释放资源
println("Resource disposed")
}
}
6.2 优化协程的使用
在使用 LaunchedEffect 启动协程时，应注意协程的使用效率。可以使用 withContext 函数来切换协程的上下文，避免在主线程中执行耗时操作。例如：
kotlin
LaunchedEffect(Unit) {
withContext(Dispatchers.IO) {
// 在 IO 线程中执行耗时操作，如网络请求、数据库查询等
val result = fetchData()
withContext(Dispatchers.Main) {
// 切换回主线程更新 UI
data = result
}
}
}
6.3 避免内存泄漏
在使用 DisposableEffect 和 LaunchedEffect 时，应注意避免内存泄漏。确保在组合销毁时正确释放资源和取消协程。例如，在 DisposableEffect 中，通过 onDispose 函数释放资源；在 LaunchedEffect 中，通过 DisposableEffect 函数在组合销毁时取消协程。
七、DisposableEffect 和 LaunchedEffect 的常见问题及解决方案
7.1 副作用重复执行问题
有时候，可能会遇到副作用重复执行的问题。这可能是由于键的设置不合理导致的。解决方案是确保键的设置正确，只有在需要重新执行副作用时才改变键的值。例如：
kotlin
var counter by remember { mutableStateOf(0) }
DisposableEffect(counter) {
// 只有当 counter 发生变化时，副作用才会重新执行
println("Effect executed with counter: $counter")
onDispose {
println("Effect disposed")
}
}
Button(onClick = { counter++ }) {
Text("Increment Counter")
}
7.2 协程未取消问题
在使用 LaunchedEffect 启动协程时，如果协程没有在组合销毁时取消，可能会导致内存泄漏。解决方案是确保在组合销毁时正确取消协程。例如：
kotlin
LaunchedEffect(Unit) {
val job = launch {
// 执行异步操作
delay(10000)
println("Async operation completed")
}
// 在组合销毁时取消协程
DisposableEffect(Unit) {
onDispose {
job.cancel()
}
}
}
7.3 资源未释放问题
在使用 DisposableEffect 管理资源时，如果资源没有在组合销毁时释放，可能会导致资源泄漏。解决方案是确保在 onDispose 函数中正确释放资源。例如：
kotlin
DisposableEffect(Unit) {
// 打开文件
val file = File("example.txt")
val stream = file.outputStream()
onDispose {
// 关闭文件流
stream.close()
}
}
八、DisposableEffect 和 LaunchedEffect 的扩展应用
8.1 自定义副作用函数
可以基于 DisposableEffect 和 LaunchedEffect 自定义副作用函数，以满足特定的需求。以下是一个自定义的 NetworkRequestEffect 函数：
kotlin
import androidx.compose.runtime.*
import androidx.compose.runtime.saveable.rememberSaveable
import kotlinx.coroutines.*
// 自定义的网络请求副作用函数
@Composable
fun NetworkRequestEffect(
url: String,
onSuccess: (String) -> Unit,
onError: (Exception) -> Unit
) {
LaunchedEffect(url) {
try {
// 模拟网络请求
val result = fetchDataFromNetwork(url)
onSuccess(result)
} catch (e: Exception) {
onError(e)
}
}
}
// 模拟网络请求函数
suspend fun fetchDataFromNetwork(url: String): String {
delay(1000)
return "Data from $url"
}
@Composable
fun CustomEffectExample() {
var data by rememberSaveable { mutableStateOf<String?>(null) }
var error by rememberSaveable { mutableStateOf<String?>(null) }
NetworkRequestEffect(
url = "https://example.com",
onSuccess = { result ->
data = result
error = null
},
onError = { e ->
error = e.message
data = null
}
)
if (data != null) {
Text(text = data!!)
} else if (error != null) {
Text(text = "Error: $error")
} else {
Text(text = "Loading...")
}
}
8.2 与其他 Compose 特性结合使用
DisposableEffect 和 LaunchedEffect 可以与其他 Compose 特性结合使用，例如动画、布局等。以下是一个与动画结合的示例：
kotlin
import androidx.compose.animation.core.*
import androidx.compose.foundation.background
import androidx.compose.foundation.layout.*
import androidx.compose.material.Text
import androidx.compose.runtime.*
import androidx.compose.ui.Modifier
import androidx.compose.ui.graphics.Color
import androidx.compose.ui.unit.dp
@Composable
fun AnimationAndEffectExample() {
// 定义一个动画值
val animatedValue = rememberInfiniteTransition().animateFloat(
initialValue = 0f,
targetValue = 1f,
animationSpec = infiniteRepeatable(
animation = tween(durationMillis = 1000),
repeatMode = RepeatMode.Reverse
)
)
// 使用 LaunchedEffect 启动一个协程来处理动画的一些逻辑
LaunchedEffect(animatedValue.value) {
if (animatedValue.value > 0.5f) {
println("Animated value is greater than 0.5")
}
}
Box(
modifier = Modifier
.size(100.dp)
.background(Color.Blue.copy(alpha = animatedValue.value))
) {
Text(text = "Animated Box")
}
}
九、DisposableEffect 和 LaunchedEffect 与 Android 生命周期的关联
9.1 Android 生命周期概述
在 Android 开发中，Activity 和 Fragment 都有自己的生命周期。Activity 的生命周期包括 onCreate、onStart、onResume、onPause、onStop、onDestroy 等方法；Fragment 的生命周期包括 onCreate、onCreateView、onViewCreated、onStart、onResume、onPause、onStop、onDestroyView、onDestroy 等方法。了解 Android 生命周期对于正确使用 DisposableEffect 和 LaunchedEffect 非常重要。
9.2 DisposableEffect 和 LaunchedEffect 与 Android 生命周期的映射
在 Android Compose 中，DisposableEffect 和 LaunchedEffect 可以与 Android 生命周期的某些阶段进行映射。例如，DisposableEffect 可以在组合创建时执行初始化操作，在组合销毁时执行清理操作，类似于 Activity 的 onCreate 和 onDestroy 方法；LaunchedEffect 可以在组合创建时启动异步任务，在组合销毁时取消任务，类似于 Activity 的 onStart 和 onStop 方法。
9.3 示例代码
kotlin
import androidx.activity.ComponentActivity
import androidx.compose.runtime.*
import androidx.compose.material.Text
import androidx.compose.runtime.Composable
import androidx.compose.ui.platform.LocalLifecycleOwner
import androidx.lifecycle.Lifecycle
import androidx.lifecycle.LifecycleEventObserver
import androidx.lifecycle.LifecycleOwner
class MainActivity : ComponentActivity() {
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
setContent {
LifecycleExample()
}
}
}
@Composable
fun LifecycleExample() {
// 获取当前的 LifecycleOwner
val lifecycleOwner = LocalLifecycleOwner.current
// 使用 DisposableEffect 监听 Android 生命周期
DisposableEffect(lifecycleOwner) {
val observer = LifecycleEventObserver { _, event ->
when (event) {
Lifecycle.Event.ON_START -> {
println("Activity started")
}
Lifecycle.Event.ON_STOP -> {
println("Activity stopped")
}
else -> {}
}
}
// 注册生命周期观察者
lifecycleOwner.lifecycle.addObserver(observer)
// 在组合销毁时取消注册生命周期观察者
onDispose {
lifecycleOwner.lifecycle.removeObserver(observer)
}
}
Text(text = "Lifecycle Example")
}
十、DisposableEffect 和 LaunchedEffect 的高级应用场景
10.1 多条件触发的副作用
在实际开发中，可能需要根据多个条件来触发副作用。可以通过组合多个键来实现这一功能。以下是一个示例：
kotlin
import androidx.compose.runtime.*
import androidx.compose.material.Text
import androidx.compose.material.Button
import androidx.compose.runtime.Composable
@Composable
fun MultiConditionEffectExample() {
var condition1 by remember { mutableStateOf(false) }
var condition2 by remember { mutableStateOf(false) }
DisposableEffect(condition1, condition2) {
if (condition1 && condition2) {
println("Both conditions are true, side effect triggered")
}
onDispose {
println("Side effect disposed")
}
}
Button(onClick = { condition1 = !condition1 }) {
Text("Toggle Condition 1")
}
Button(onClick = { condition2 = !condition2 }) {
Text("Toggle Condition 2")
}
}
10.2 嵌套使用 DisposableEffect 和 LaunchedEffect
在某些复杂的场景中，可能需要嵌套使用 DisposableEffect 和 LaunchedEffect。例如，在一个 LaunchedEffect 中启动一个异步任务，同时使用 DisposableEffect 来管理异步任务中使用的资源。以下是一个示例：
kotlin
import androidx.compose.runtime.*
import androidx.compose.material.Text
import androidx.compose.runtime.Composable
import kotlinx.coroutines.delay
@Composable
fun NestedEffectExample() {
LaunchedEffect(Unit) {
// 启动一个异步任务
val job = launch {
delay(2000)
println("Async task completed")
}
DisposableEffect(job) {
// 管理异步任务中使用的资源
println("Resource initialized for async task")
onDispose {
// 在组合销毁时取消异步任务并释放资源
job.cancel()
println("Resource disposed for async task")
}
}
}
Text(text = "Nested Effect Example")
}
十一、总结与展望
11.1 总结
通过对 DisposableEffect 和 LaunchedEffect 的全面深入分析，我们清晰地认识到它们在 Android Compose 组合生命周期管理中扮演的关键角色。DisposableEffect 专注于资源的管理，确保资源在组合创建时被正确初始化，在组合销毁时被及时释放，有效地避免了资源泄漏和浪费问题。而 LaunchedEffect 则擅长处理异步任务，它能够在组合创建时启动异步任务，并在组合销毁时取消任务，保证了异步操作的高效性和安全性。同时，我们还探讨了它们的多种应用场景，包括资源管理、网络请求、数据库查询等，以及性能优化策略、常见问题的解决方案和扩展应用。这些知识和技巧对于开发者来说至关重要，能够帮助他们更好地利用 DisposableEffect 和 LaunchedEffect 来构建高性能、稳定的 Android Compose 应用。
扫一扫
1178
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
