Android Compose 生命周期和附带效应

@Composable
fun HomeDetail() {
    val state = rememberUserState()

    LaunchedEffect(key1 = state) {
    	//模拟网络操作	
        delay(3000)
        state.value = MyUserState()
    }
    state.value?.run {
        Log.e("---345--->", this.name);
        Log.e("---345--->", this.toString());
        Scaffold() {
            Column() {
                Spacer(modifier = Modifier.padding(top = 50.dp))

                Button(onClick = {
                    state.value = MyUserState("张三",50)
                }) {
                    Text(text = "按钮")
                }
                Spacer(modifier = Modifier.padding(top = 100.dp))
                Text(text = "姓名 ${this@run.name}")
                Text(text = "姓名 ${this@run.age}")
            }
        }
    }


}

@Composable
fun rememberUserState(myUserState: MutableState = mutableStateOf(null)) =
    remember() {
        mutableStateOf(myUserState.value)
    }
}
class MyUserState(
    var name: String = "345",
    var age: Int = 20
)
复制代码

@Composable
fun MyScreen(
    state: UiState>,
    scaffoldState: ScaffoldState = rememberScaffoldState()
) {

    // 如果 UI 状态包含错误，则显示提示栏
    if (state.hasError) {

        // `LaunchedEffect` 将取消并重新启动，如果`scaffoldState.snackbarHostState` 改变
        LaunchedEffect(scaffoldState.snackbarHostState) {
            // 使用协程显示snackbar，当协程被取消时snackbar 会自动关闭。当 `state.hasError` 为 false 时，此协程将取消，并且仅在 `state.hasError` 为 true（由于上述 if-check）或 `scaffoldState.snackbarHostState` 更改时启动
            scaffoldState.snackbarHostState.showSnackbar(
                message = "Error message",
                actionLabel = "Retry message"
            )
        }
    }

    Scaffold(scaffoldState = scaffoldState) {
        /* ... */
    }
}
复制代码

var coroutineScope: CoroutineScope? = null

@Composable
fun HomeDetail(
    activity: MainActivity
) {
    val state = rememberUserState()
    coroutineScope = rememberCoroutineScope()
    coroutineScope?.launch {
        while (true) {
            delay(1000)
            Log.e("---345--->", "345");
        }
    }
}
复制代码

@Composable
fun MoviesScreen(scaffoldState: ScaffoldState = rememberScaffoldState()) {
    val scope = rememberCoroutineScope()
    Scaffold(scaffoldState = scaffoldState) {
        Column {
            Button(
                onClick = {
                    scope.launch {
                        scaffoldState.snackbarHostState.showSnackbar("Something happened!")
                    }
                }
            ) {
                Text("Press me")
            }
        }
    }
}
复制代码

@Composable
fun LandingScreen(onTimeout: () -> Unit) {

    // 这将始终引用 LandingScreen 重构的最新 onTimeout 函数
    val currentOnTimeout by rememberUpdatedState(onTimeout)

    // 创建与 LandingScreen 的生命周期相匹配的效果。
    // 如果 LandingScreen 重组，延迟不应再次开始。
    LaunchedEffect(true) {
        delay(3000)
        currentOnTimeout()
    }

    /* Landing screen content */
}

@Composable
fun HomeDetail() {
    LandingScreen {
        Log.e("---345--->", "----");
    }
    //....
}
复制代码

@Composable
fun HomeScreen(
    lifecycleOwner: LifecycleOwner = LocalLifecycleOwner.current,
    onStart: () -> Unit, // 开启事件
    onStop: () -> Unit // 停止时间
) {
    // 当提供了一个新的lambdas时，可以安全地更新当前的lambdas
    val currentOnStart by rememberUpdatedState(onStart)
    val currentOnStop by rememberUpdatedState(onStop)

    // 如果“lifecycleOwner”改变，处置并重置效果
    DisposableEffect(lifecycleOwner) {
        // 创建一个观察者来触发我们所记得的回调来发送事件
        val observer = LifecycleEventObserver { _, event ->
            if (event == Lifecycle.Event.ON_START) {
                currentOnStart()
            } else if (event == Lifecycle.Event.ON_STOP) {
                currentOnStop()
            }
        }

        // 将观察者添加到生命周期中
        lifecycleOwner.lifecycle.addObserver(observer)

        // 当组合函数离开时，会执行
        onDispose {
            lifecycleOwner.lifecycle.removeObserver(observer)
        }
    }

    /* Home screen content */
}
复制代码

@Composable
private fun SetImmersion() {
    if (isImmersion()) {
        val systemUiController = rememberSystemUiController()
        SideEffect {
            systemUiController.run {
                setSystemBarsColor(color = Color.Transparent, darkIcons = isDark())
                setNavigationBarColor(color = Color.Black)
            }
        }
    }
}
复制代码

@Composable
fun rememberAnalytics(user: User): FirebaseAnalytics {
    val analytics: FirebaseAnalytics = remember {
        /* ... */
    }

    // 在每一次成功的组合中，从当前的用户更新FirebaseAnalytics的userType，确保未来的分析事件附加此元数据
    SideEffect {
        analytics.setUserProperty("userType", user.userType)
    }
    return analytics
}
复制代码

@Composable
fun loadNetworkImage(
    url: String,
    imageRepository: ImageRepository
): State> {

    // 创建一个以 Result.Loading 作为初始值的 State>(initialValue = Result.Loading, url, imageRepository) {

        // 在协程中，可以进行挂起调用
        val image = imageRepository.load(url)

        // 使用错误或成功结果更新状态。这将触发读取State时的重组
        value = if (image == null) {
            Result.Error
        } else {
            Result.Success(image)
        }
    }
}
复制代码

@Composable
fun TodoList(highPriorityKeywords: List = listOf("Review", "Unblock", "Compose")) {

    val todoTasks = remember { mutableStateListOf() }

    // 只在todoTasks或highPriorityKeywords变化时计算高优先级任务，而不是在每次重组时
    val highPriorityTasks by remember(highPriorityKeywords) {
        derivedStateOf { todoTasks.filter { it.containsWord(highPriorityKeywords) } }
    }

    Box(Modifier.fillMaxSize()) {
        LazyColumn {
            items(highPriorityTasks) { /* ... */ }
            items(todoTasks) { /* ... */ }
        }
        /* Rest of the UI where users can add elements to the list */
    }
}
复制代码

val listState = rememberLazyListState()

LazyColumn(state = listState) {
    // ...
}

LaunchedEffect(listState) {
    snapshotFlow { listState.firstVisibleItemIndex }
        .map { index -> index > 0 }
        .distinctUntilChanged()
        .filter { it == true }
        .collect {
            MyAnalyticsService.sendScrolledPastFirstItemEvent()
        }
}
复制代码