【Android】Jetpack Compose 渲染管线与重组优化：稳定性、作用域、智能状态读取三重法则

// 编译器会将此函数转换为类似以下的逻辑：
@Composable
fun MyButton(label: String, onClick: () -> Unit) {
    // Compose 编译器插入的跳过检查：
    // if (currentComposer.changed(label) || currentComposer.changed(onClick)) {
    //     // 执行实际渲染
    // } else {
    //     // 跳过，复用上次结果
    // }
}

// ❌ 不稳定类型 → 每次都重组
data class UserState(
    val name: String,
    val email: String,
    val orders: List<Order>  // List 是接口，实际类型可能是 ArrayList
)

@Composable
fun UserProfile(state: UserState) {
    // 由于 UserState 是 unstable，
    // 即使 state 引用没变，Compose 也会重新执行此函数
}

// ✅ 稳定类型 → 精确跳过
@Immutable
data class UserState(
    val name: String,
    val email: String,
    val orders: ImmutableList<Order>  // 明确不可变
)

@Composable
fun UserProfile(state: UserState) {
    // Compose 可以通过 equals 精确判断是否需要重组
}

@Immutable
data class UiState(
    val title: String,
    val items: List<Item>,
    val isLoading: Boolean
)

// 替换前
val items: List<Item> = listOf(...)

// 替换后
val items: ImmutableList<Item> = persistentListOf(...)

// ❌ 每次父级重组都创建新 lambda → 子组件重组
@Composable
fun Parent() {
    var count by remember { mutableIntStateOf(0) }
    
    Child(
        onClick = { 
            // 这是一个新的 lambda 实例！
            count++ 
        }
    )
}

// ✅ 使用 remember + rememberUpdatedState 固定 lambda
@Composable
fun Parent() {
    var count by remember { mutableIntStateOf(0) }
    val onClick by rememberUpdatedState(newValue = {
        count++
    })
    
    Child(onClick = onClick)
}

// ✅ 或者将 lambda 提升到不会重组的层级
@Composable
fun GrandParent(onClick: () -> Unit) {
    // onClick 在这里创建，不会随 Parent 重组而变化
    Parent(onClick = onClick)
}

@Composable
fun Screen() {                    // Scope: Screen
    var count by remember { mutableIntStateOf(0) }
    
    Header()                       // Scope: Header（独立重组）
    
    Column {                       // Scope: Column
        Text("Count: $count")      // Scope: Text（最细粒度）
        Counter()                  // Scope: Counter（独立重组）
    }
}

// ❌ 状态放在 GrandParent，但只影响 Counter
@Composable
fun GrandParent() {
    var count by remember { mutableIntStateOf(0) }  // 放在这里
    
    Parent(count = count, onCountChange = { count = it })
}

@Composable
fun Parent(count: Int, onCountChange: () -> Unit) {
    Text("Count: $count")  // 这里用到了
    Counter(onClick = onCountChange)  // 这里也用到了
}

// ✅ 使用 key 隔离 Counter 的重组
@Composable
fun Parent(count: Int, onCountChange: () -> Unit) {
    Column {
        Text("Count: $count")
        key(count) {  // 当 count 变化时，只有这里重组
            Counter(onClick = onCountChange)
        }
    }
}

// ❌ ViewModel 中暴露 MutableList（不稳定）
class MyViewModel {
    val items = mutableStateListOf<Item>()  // 每次变化都触发全列表重组
}

@Composable
fun ListScreen(vm: MyViewModel) {
    LazyColumn {
        items(vm.items) { item ->
            // 每次 items 变化，整个列表重组
        }
    }
}

// ✅ 使用 ImmutableList + stable key
@Composable
fun ListScreen(vm: MyViewModel) {
    LazyColumn {
        items(
            items = vm.items,
            key = { item -> item.id }  // 稳定的唯一标识
        ) { item ->
            ListItem(item = item)
        }
    }
}

@Composable
fun StatsDisplay(state: StatsState) {
    // 4个订阅点：每次任何一个变化都会触发重组
    Text(state.totalCount.toString())
    Text(state.completedCount.toString())
    Text(state.pendingCount.toString())
    Text(state.errorCount.toString())
}

// ❌ 每次 recomposition 都重新计算
@Composable
fun SearchResults(query: String, items: List<Item>) {
    val filteredItems = items.filter { it.matches(query) }  // 每次都执行！
}

// ✅ 使用 derivedStateOf，只有依赖状态真正变化时才重算
@Composable
fun SearchResults(query: String, items: List<Item>) {
    val filteredItems by remember {
        derivedStateOf { items.filter { it.matches(query) } }
    }
    LazyColumn {
        items(filteredItems) { item -> SearchItem(item) }
    }
}

@Composable
fun ScrollPositionTracker(lazyListState: LazyListState) {
    val firstVisibleItem by remember {
        derivedStateOf { lazyListState.firstVisibleItemIndex }
    }
    
    LaunchedEffect(firstVisibleItem) {
        analytics.logScrollDepth(firstVisibleItem)
    }
}

composeOptions {
    compilerExtensions {
        enableComposeCompilerMetrics()
        enableComposeCompilerReports()
    }
}

@Composable
fun MyScreen() {
    // 在 DEBUG 模式下输出重组信息
    if (BuildConfig.DEBUG) {
        val composition = rememberCompositionContext()
        LaunchedEffect(Unit) {
            snapshotFlow { composition.hasInvalidations() }
                .collect { hasInvalidations ->
                    Log.d("ComposePerf", "Invalidation detected")
                }
        }
    }
}