Compose 附帶效應

a. 純函數

純函數指的是函數與外界交換數據只能通過函數參數和函數返回值來進行，純函數的運行不會對外界環境產生任何的影響。比如下面這個函數：

fun Add(a : Int, b : Int) : Int {return a + b
}

“副作用”（side effect），指的是如果一個操作、函數或表達式在其內部與外界進行了互動，產生運算以外的其他結果，則該操作或表達式具有副作用。

最典型的情況，就是修改了外部環境的變量值。例如如下代碼：Add() 函數執行它需要一個外部變量 a，先進行 ++ 操作，然 a + b 返回。只要這個函數一執行，外部變量 a 就會改變。而對于這個 a 所產生的改變，這個就叫做副作用。

var a
fun Add(b : Int) : Unit{a++return a + b
}

因此，組合函數也是一個函數，那么它也分為有副作用的和沒副作用的。而組合函數的副作用和其它函數還有一些差異。

組合函數的特點

a. 執行順序不定；b. 可以并行運行；c. 可能會非常頻繁地運行

處理副作用

雖然我們不希望函數執行中出現副作用，但現實情況是有一些邏輯只能作為副作用來處理。例如一些 IO 操作、計時、日志埋點等，這些都是會對外界或收到外界影響的邏輯，不能無限制的反復執行。所以 Compose 需要能夠合理地處理一些副作用。

?副作用的執行時機是明確的，例如在 Recomposition 時等。

?副作用的執行次數是可控的，不應該隨著函數反復執行。

?副作用不會造成泄漏，例如對于注冊要提供適當的時機取消注冊。

組合函數的副作用

組合函數是主要是用來做 UI 聲明的、描述的，只要你在可組合函數內做了與 UI 描述不相關的操作，這一類操作其實都屬于副作用。

在 Compose 中可組合函數內部理應只做視圖相關的事情，而不應該做函數返回之外的事情，如訪問文件等，如果有，那這就叫做附帶效應，以下操作全部都是危險的附帶效應：

?寫入共享對象的屬性；

?更新 ViewModel 中的可觀察項。

?更新共享偏好設置。

可組合函數應該是無副作用的，但是如果我們要在 Compose 里面使用可組合函數而且會產生附帶效應，這時就需要使用 EffectAPI，以便以可預測的方式執行那些副作用。一個 effect，就是一個可組合函數，這個可組合函數不生成 UI，而是在組合完成時產生副作用。

組合函數的生命周期

這些 Effect API 是與我們組合函數的生命周期相關聯的。可組合項的生命周期比 activity 和 fragment 的生命周期更簡單，一般是進入組合、執行0次或者多次重組、退出組合。

?Enter：掛載到樹上，首次顯示。

?Composition：重組刷新 UI。

?Leave：從樹上移除，不再顯示。

組合函數中沒有自帶的生命周期函數，想要監聽其生命周期，需要使用 Effect（附帶效應）API ：

?LaunchedEffect：第一次調用 Compose 函數的時候調用。

?DisposableEffect：內部有一個 onDispose() 函數，當頁面退出時調用。

?SideEffect：compose 函數每次執行都會調用該方法。

LaunchedEffect

如果在可組合函數中進行耗時操作（副作用往往都是耗時操作，例如網絡請求、I/O等），就需要將耗時操作放入協程中執行，而協程需要在協程作用域中創建，因此 Compose 提供了 LaunchedEffect 用于創建協程。

?當 LaunchedEffect 進入組件樹時，會啟動一個協程，并將 block 放入該協程中執行。

?當組合函數從視圖樹上 detach 時，協程還未被執行完畢，該協程也會被取消執行。

?當 LaunchedEffect 在重組時其 key 不變，那 LaunchedEffect 不會被重新啟動執行 block。

?當 LaunchedEffect?在重組時其 key 發生了變化，則 LaunchedEffect 會執行 cancel 后，再重新啟動一個新協程執行 block。

示例：LaunchedEffect 在初次進入組件樹時，就會啟動一個協程，調用 block 塊執行

1. LaunchedEffectSample.kt

@Composable
fun ScaffoldSample(state : MutableState<Boolean>,scaffoldState : ScaffoldState = rememberScaffoldState()
){// TODO 當我啟動這個應用時，組件一開始加載進來，LaunchedEffect() 就會啟動一個協程，執行它的 block 塊//TODO 當 key = state.value 發生改變時（點擊按鈕時改變），就會啟動協程LaunchedEffect(state.value){// 開啟一個彈窗，TODO 是一個 block 塊scaffoldState.snackbarHostState.showSnackbar(// 彈窗內容message = "Error message",actionLabel = "Retry message")}// TODO 腳手架Scaffold(scaffoldState = scaffoldState,// 頂部標題欄區域topBar = {TopAppBar(title = { Text(text = "腳手架示例！")})},// 屏幕內容區域content = {Box(modifier = Modifier.fillMaxSize(), // 填充父容器contentAlignment = Alignment.Center // 居中){Button(onClick = {//TODO 點擊按鈕時，彈窗，改變 state 的值。一個動畫效果，為耗時操作，即附帶效應state.value = !state.value}) {Text(text = "Click it!")}}})
}@Composable
fun LaunchedEffectSample(){val state = remember { mutableStateOf(false) }ScaffoldSample(state)
}

2. MainActivity.kt

class MainActivity : ComponentActivity() {override fun onCreate(savedInstanceState: Bundle?) {super.onCreate(savedInstanceState)setContent {JetpackComposeSideEffectsTheme {LaunchedEffectSample()}}}
}

上面的示例中，當我們啟動 App 時就會讓 LaunchedEffect 進入組件樹時，啟動一個協程，并將 block 放入該協程中執行。可以做如下改變，讓進入 App 時不執行 block 塊。修改 LaunchedEffect 代碼如下：

    if(state.value){LaunchedEffect(scaffoldState.snackbarHostState){// 開啟一個彈窗，TODO 是一個 block 塊scaffoldState.snackbarHostState.showSnackbar(// 彈窗內容message = "Error message",actionLabel = "Retry message")}}

rememberCoroutineScope

由于 LauncedEffect 本身就是個可組合函數，因此只能在其他可組合函數中使用。想要在可組合項外啟動協程，且需要對這個協程存在作用域限制，以便協程在退出組合后自動取消，可以使用 rememberCoroutineScope。

此外，如果需要手動控制一個或多個協程的生命周期，請使用 rememberCoroutineScope。拿到協程的作用域。

示例：

1. RememberCoroutineScopeSample.kt

@Composable
fun ScaffoldSample(){val scaffoldState = rememberScaffoldState()// TODO　拿到協程作用域，啟動多個協程val scope = rememberCoroutineScope()Scaffold(scaffoldState = scaffoldState,//TODO 左側抽屜欄，點擊了菜單按鈕時，彈出drawerContent = {Box(modifier = Modifier.fillMaxSize(),contentAlignment = Alignment.Center) {Text(text = "抽屜組件中的內容")}                },// 頂部標題欄區域topBar = {TopAppBar(// 左上角的菜單欄按鈕，點擊后左側彈窗navigationIcon = {IconButton(onClick = {// TODO 點擊菜單按鈕時，彈出左側抽屜欄// TODO 1 啟動一個協程scope.launch {// 以動畫的形式打開這個抽屜scaffoldState.drawerState.open()}}) {// 菜單按鈕Icon(imageVector = Icons.Filled.Menu, contentDescription = null)}},title = { Text(text = "腳手架示例！")})},// 屏幕內容區域content = {Box(modifier = Modifier.fillMaxSize(),contentAlignment = Alignment.Center) {Text(text = "屏幕內容區域")}},// TODO 右下角的懸浮按鈕floatingActionButton = {ExtendedFloatingActionButton(text = { Text(text = "懸浮按鈕") },onClick = {// TODO 2 啟動一個協程scope.launch {// 彈窗scaffoldState.snackbarHostState.showSnackbar("點擊了懸浮按鈕")}})})
}

2. MainActivity.kt

class MainActivity : ComponentActivity() {override fun onCreate(savedInstanceState: Bundle?) {super.onCreate(savedInstanceState)setContent {JetpackComposeSideEffectsTheme {//LaunchedEffectSample()ScaffoldSample()}}}
}

在上面代碼中，我們通過??val scope = rememberCoroutineScope() 拿到協程作用域，以此來控制多個協程生命周期

rememberUpdatedState

如果 key 值有更新，那么 LaunchedEffect 在重組時就會被重新啟動。但是有時候需要在 LaunchedEffect 中使用最新的參數值，但是又不想重新啟動 LaunchedEffect，此時就需要用到 rememberUpdatedState。

rememberUpdatedState 的作用是給某個參數創建一個引用，來跟蹤這些參數，并保證其值被使用時是最新值，參數被改變時不重啟 effect。

示例：RememberUpdatedStateSample.kt

@Composable
fun LandingScreen(onTimeOut : () -> Unit){// TODO onTimeOut() 轉換成一個狀態了val currentOnTimeout by rememberUpdatedState(newValue = onTimeOut)//TODO key1 = Unit 表示這個 key 值不會變LaunchedEffect(key1 = Unit){Log.d("HL", "LaunchedEffect")repeat(10){delay(1000)Log.d("HL", "delay ${it + 1}s")}////onTimeOut()currentOnTimeout()}
}@Composable
fun RememberUpdatedStateSample(){val onTimeOut1 : () -> Unit = { Log.d("HL", "landing timeout 1") }val onTImeOut2 : () -> Unit = { Log.d("HL", "landing timeout 2") }// 創建一個 state, 默認值為 onTimeOut1val changeOnTimeOutState = remember { mutableStateOf(onTimeOut1) }Column {Button(onClick = {// TODO 點擊按鈕時，改變 changeOnTimeOutState 的值if(changeOnTimeOutState.value == onTimeOut1){changeOnTimeOutState.value = onTImeOut2}else{changeOnTimeOutState.value = onTimeOut1}}) {Text(text = "choose onTimeOut ${if(changeOnTimeOutState.value == onTimeOut1) 1 else 2}")}//TODO changeOnTimeOutState.value == OnTimeOut1 / OnTimeOut2LandingScreen(changeOnTimeOutState.value)}
}

DisposableEffect

DisposableEffect 也是一個可組合函數，當 DisposableEffect 在其 key 值變化或者組合函數離開組件樹時，會取消之前啟動的協程，并會在取消協程前調用其回收方法進行資源回收相關的操作，可以對一些資源等進行清理。

示例：當開關按鈕打開時，攔截返回按鈕。

DisposableEffectSample.kt

// 對返回進行一個攔截
@Composable
fun BackHandler(backDispatcher : OnBackPressedDispatcher,onBack : () -> Unit
){// onBack 包裝成一個狀態, TODO　以便可以隨時替換為其它的函數val currentOnBack by rememberUpdatedState(newValue = onBack)val backCallback = remember {object : OnBackPressedCallback(true){override fun handleOnBackPressed() {//onBack()currentOnBack()}}}DisposableEffect(key1 = backDispatcher){// 開關打開，添加攔截 backCallbackbackDispatcher.addCallback(backCallback)// 執行時機為：BackHandler 從組件樹中移除，也就是 switch 開關關掉的時候onDispose {Log.d("HL", "onDispose")// 開關一關，從組件樹中移除backCallback.remove()}}
}@Composable
fun DisposableEffectSample(backDispatcher : OnBackPressedDispatcher){// TODO 設置一個狀態var addBackCallback by remember { mutableStateOf(false) }Row {// 開關按鈕Switch(checked = addBackCallback, // 默認選中或不選中onCheckedChange = {// 當點擊開關進行切換的時候，調用這里的代碼addBackCallback = !addBackCallback})Text(text = if (addBackCallback) "Add back callback" else "Not add back callback")}if(addBackCallback){ // TODO 打開開關，BackHandler() 執行BackHandler(backDispatcher){Log.d("HL", "onBack")}}
}

MainActivity.kt

class MainActivity : ComponentActivity() {override fun onCreate(savedInstanceState: Bundle?) {super.onCreate(savedInstanceState)setContent {JetpackComposeSideEffectsTheme {//LaunchedEffectSample()//ScaffoldSample()//RememberUpdatedStateSample()DisposableEffectSample(onBackPressedDispatcher)}}}
}

SideEffect

SideEffect 是簡化版的 DisposableEffect，SideEffect 并未接收任何 key 值，所以，每次重組，就會執行其 block。當不需要 onDispose、不需要參數控制時使用 SideEffect。SideEffect 主要用來與非 Compose 管理的對象共享 Compose 狀態。

SideEffect 在組合函數被創建并載入視圖樹后才會被調用。

例如，我們的分析庫可能允許通過將自定義元數據（在此示例中為“用戶屬性”）附加到所有后續分析事件，來細分用戶群體。如需將當前用戶的用戶類型傳遞給你的分析庫，請使用 SideEffect 更新其值。

prodeceState

produceState 可以將非 Compose（如 Flow、LiveData 或 RxJava）狀態轉換為 Compose 狀態。它接收一個 lambda 表達式作為函數體，能將這些入參經過一些操作后生成一個 State 類型變量并返回。

?produceState 創建了一個協程，但它也可用于觀察非掛起的數據源。

?當 produceState 進入 Composition 時，獲取數據的任務被啟動，當其離開 Composition 時，該任務被取消。

derivedStateOf

如果某個狀態是從其它狀態對象計算或派生得出的，請使用 derivedStateOf。作為條件的狀態我們稱為條件狀態。當任意一個條件狀態更新時，結果狀態都會重新計算。

snapshotFlow

使用 snapshotFlow 可以將 State 對象轉換為 Flow。snapshotFlow 會運行傳入的 block，并發出從塊中讀取的 State 對象的結果。當在 snapshotFlow 塊中讀取的 State 對象之一發生變化時，如果新值與之前發出的值不相等，Flow 會向其收集器發出新值。