如何在Paging3库结合LazyColumn时保存滚动位置？

要实现Paging3+LazyColumn的滚动位置保存，核心需要解决两个问题：保留已加载的分页数据和恢复滚动状态，以下是具体方案：

一、为什么普通ScrollState方案无效？ #

普通Column的verticalScrollState方案不适用，原因在于：

• LazyPagingItems的itemCount会随分页加载动态变化，滚动状态的索引无法稳定对应
• 默认情况下，Pager创建的Flow<PagingData>是一次性的，配置变化（如屏幕旋转）时会重新生成Flow，导致已加载数据丢失，滚动状态无数据可对应

二、核心解决方案 #

1. 保留已加载的分页数据 #

根据需求分两种场景处理：

场景1：仅处理配置变化（如屏幕旋转）

无需Room，只需在ViewModel中用cachedIn缓存PagingData：

override fun getPagedData(): Flow<PagingData<Item>> {
    return Pager(
        config = PagingConfig(pageSize = 20) // 根据需求调整参数
    ) {
        ScreenPagingSource()
    }.flow
    .cachedIn(viewModelScope) // 关键：将PagingData缓存到ViewModel生命周期内
}

cachedIn会让Flow在ViewModel的作用域内缓存数据，配置变化时不会重新发起网络请求，保留已加载的分页内容。

场景2：需要持久化缓存（App重启后仍保留数据）

必须结合Room和Paging3的RemoteMediator实现本地缓存，步骤如下：

• 定义Room实体类和Dao，支持分页查询：

@Entity(tableName = "items")
data class ItemEntity(
    @PrimaryKey val id: String,
    // 其他业务字段
)

@Dao
interface ItemDao {
    @Query("SELECT * FROM items ORDER BY id ASC")
    fun getPagedItems(): PagingSource<Int, ItemEntity>
}

• 实现RemoteMediator，负责协调网络请求与本地缓存：

class ScreenRemoteMediator(
    private val roomDb: RoomDatabase,
    private val apiService: ApiService
) : RemoteMediator<Int, ItemEntity>() {
    override suspend fun load(
        loadType: LoadType,
        state: PagingState<Int, ItemEntity>
    ): MediatorResult {
        return try {
            // 根据loadType计算请求页码，发起网络请求
            val pageKey = when (loadType) {
                LoadType.REFRESH -> 1
                LoadType.PREPEND -> return MediatorResult.Success(endOfPaginationReached = true)
                LoadType.APPEND -> state.lastItemOrNull()?.id?.let { getNextPageKey(it) } ?: 1
            }
            val items = apiService.getItems(page = pageKey)
            // 将数据插入Room
            roomDb.itemDao().insertAll(items.map { it.toEntity() })
            MediatorResult.Success(endOfPaginationReached = items.isEmpty())
        } catch (e: Exception) {
            MediatorResult.Error(e)
        }
    }

    private fun getNextPageKey(lastItemId: String): Int {
        // 根据业务逻辑计算下一页页码
        return lastItemId.toInt() / 20 + 1
    }
}

• 调整Pager配置，使用Room的PagingSource和RemoteMediator：

override fun getPagedData(): Flow<PagingData<Item>> {
    return Pager(
        config = PagingConfig(pageSize = 20),
        remoteMediator = ScreenRemoteMediator(roomDb, apiService),
        pagingSourceFactory = { roomDb.itemDao().getPagedItems() }
    ).flow
    .cachedIn(viewModelScope)
    .map { pagingData -> pagingData.map { it.toModel() } } // 转成业务模型
}

2. 保存与恢复滚动位置 #

使用LazyListState结合ViewModel保存滚动关键信息：

在ViewModel中保存滚动状态

class ScreenViewModel : ViewModel() {
    private val _scrollPosition = mutableStateOf<Pair<Int, Int>?>(null)
    val scrollPosition: State<Pair<Int, Int>?> = _scrollPosition

    // 保存滚动位置：第一个可见item的索引和偏移量
    fun saveScrollPosition(index: Int, offset: Int) {
        _scrollPosition.value = index to offset
    }

    // ... 其他业务代码
}

在Composable中监听并恢复滚动状态

@Composable
fun ScreenComposable(viewModel: ScreenViewModel) {
    val lazyItems = viewModel.getPagedData().collectAsLazyPagingItems()
    val lazyListState = rememberLazyListState()
    val savedScrollPosition = viewModel.scrollPosition.value

    // 恢复滚动位置
    LaunchedEffect(savedScrollPosition) {
        savedScrollPosition?.let { (index, offset) ->
            lazyListState.scrollToItem(index, offset)
        }
    }

    // 监听滚动状态变化，实时保存到ViewModel
    LaunchedEffect(lazyListState) {
        snapshotFlow {
            lazyListState.firstVisibleItemIndex to lazyListState.firstVisibleItemScrollOffset
        }.distinctUntilChanged().collect { (index, offset) ->
            viewModel.saveScrollPosition(index, offset)
        }
    }

    LazyColumn(state = lazyListState) {
        // 渲染分页数据
        items(lazyItems) { item ->
            item?.let { ScreenItemComposable(it) }
        }

        // 加载状态处理（可选）
        lazyItems.apply {
            when (loadState.refresh) {
                is LoadState.Loading -> item { LoadingItem() }
                is LoadState.Error -> item { ErrorItem((loadState.refresh as LoadState.Error).error) }
                else -> {}
            }
            when (loadState.append) {
                is LoadState.Loading -> item { LoadingItem() }
                is LoadState.Error -> item { ErrorItem((loadState.append as LoadState.Error).error) }
                else -> {}
            }
        }
    }
}

三、关键注意事项 #

• cachedIn(viewModelScope)是必须的，它确保PagingData不会因为Compose重组而被重新创建
• 滚动状态恢复要在LaunchedEffect中执行，避免重组时重复触发
• 如果使用Room缓存，确保RemoteMediator正确处理分页逻辑和错误情况

内容的提问来源于stack exchange，提问作者PrzemekTom