第07章 状态管理与性能优化¶

// 屏幕级状态持有者
class NewsListStateHolder(
    private val getNewsUseCase: GetNewsUseCase,
    private val coroutineScope: CoroutineScope
) {
    private val _uiState = MutableStateFlow(NewsUiState())
    val uiState: StateFlow<NewsUiState> = _uiState.asStateFlow()

    fun loadNews() {
        _uiState.update { it.copy(isLoading = true) }

        coroutineScope.launch {
            getNewsUseCase()
                .onSuccess { news ->
                    _uiState.update {
                        it.copy(news = news, isLoading = false)
                    }
                }
        }
    }
}

// 在ViewModel中使用
class NewsViewModel @Inject constructor(
    getNewsUseCase: GetNewsUseCase
) : ViewModel() {

    private val stateHolder = NewsListStateHolder(getNewsUseCase, viewModelScope)
    val uiState = stateHolder.uiState

    fun loadNews() = stateHolder.loadNews()
}

// 应用级状态
class AppState {
    val theme = mutableStateOf(Theme.LIGHT)
    val user = mutableStateOf<User?>(null)
}

// 屏幕级状态
class ScreenState {
    val isLoading = mutableStateOf(false)
    val data = mutableStateOf<List<Item>>(emptyList())
}

// 组件级状态
class ComponentState {
    var isExpanded by mutableStateOf(false)
}

// ❌ 问题：整个列表都会重组
@Composable
fun BadList(items: List<Item>) {
    Column {
        items.forEach { item ->
            ItemRow(item) // 任何item变化都会导致全部重组
        }
    }
}

// ✅ 解决：使用LazyColumn和key
@Composable
fun GoodList(items: List<Item>) {
    LazyColumn {
        items(
            items = items,
            key = { it.id } // 使用稳定key
        ) { item ->
            ItemRow(item)
        }
    }
}

// ✅ 使用remember避免重复计算
@Composable
fun ExpensiveCalculation(data: List<Int>) {
    val sum = remember(data) {
        data.sum() // 只在data变化时计算
    }
    Text("Sum: $sum")
}

// ✅ 使用不可变数据类
data class User(
    val id: String,
    val name: String
)

// ❌ 避免可变类
class MutableUser {
    var id: String = ""
    var name: String = ""
}

// ✅ 使用@Stable标记
@Stable
interface UserRepository {  // interface定义类型契约
    fun getUser(): User
}

// ✅ 使用Immutable集合
@Composable
fun ListScreen(items: ImmutableList<Item>) {
    // items变化时才会重组
}

// LazyColumn自动实现延迟加载
LazyColumn {
    items(1000) { index ->
        ListItem(index) // 只渲染可见项
    }
}

// 图片延迟加载
AsyncImage(
    model = ImageRequest.Builder(context)
        .data(imageUrl)
        .placeholderMemoryCacheKey(previewImageUrl)
        .build(),
    contentDescription = null
)

// 使用animate*AsState而不是手动动画
val animatedProgress by animateFloatAsState(
    targetValue = progress,
    animationSpec = tween(300),
    label = "progress"
)

// 避免在动画中读取状态
Canvas(modifier = Modifier.fillMaxSize()) {
    // ❌ 错误：每次重组都会读取
    drawCircle(color = if (isSelected) Color.Red else Color.Blue)

    // ✅ 正确：使用动画状态
    drawCircle(color = animatedColor)
}

// ❌ 错误：在ViewModel中持有Context引用
class BadViewModel(private val context: Context) : ViewModel()

// ✅ 正确：使用Application Context
class GoodViewModel @Inject constructor(
    @ApplicationContext private val context: Context
) : ViewModel()

// ❌ 错误：在Composable中使用非生命周期感知的协程
@Composable
fun BadExample() {
    scope.launch { // 可能导致泄漏
        // 长时间运行的任务
    }
}

// ✅ 正确：使用rememberCoroutineScope
@Composable
fun GoodExample() {
    val scope = rememberCoroutineScope()

    Button(onClick = {
        scope.launch {
            // 任务
        }
    }) {
        Text("Click")
    }
}

// 限制图片大小
AsyncImage(
    model = ImageRequest.Builder(context)
        .data(url)
        .size(Size.ORIGINAL)
        .scale(Scale.FILL)
        .build(),
    contentDescription = null,
    contentScale = ContentScale.Crop
)

// 使用合适的大小
val size = if (isThumbnail) 100 else 500
AsyncImage(
    model = "$url?w=$size",
    contentDescription = null
)