Android Jetpack Compose LazyColumn以编程方式滚动到项目

有没有办法通过编程将

LazyColumn

滚动到列表中的某个项目？我原以为可以通过提升

LazyColumn

参数

state:LazyListState=rememberLazyListState（）

来实现，但我不知道如何更改此状态，例如单击按钮。

在Compose中，没有公共API，但有一些内部API可供使用

---

也许在即将发布的版本中，我们可以看到更新。

下面是我的代码，它可以制作粘性标题、列表和滚动条

@ExperimentalFoundationApi
@Composable
private fun ListView(data: YourClass) { 

//this is to remember state, internal API also use the same
    val state = rememberLazyListState()

    LazyColumn(Modifier.fillMaxSize(), state) {
        itemsIndexed(items = data.list, itemContent = { index, dataItem ->
            ItemView(dataItem)// your row
        })
       // header after some data, according to your condition
            stickyHeader {
                ItemDecoration()// compose fun for sticky header 
            }
// More items after header
            itemsIndexed(items = data.list2, itemContent = { index, dataItem ->
            ItemView(dataItem)// your row
        })
        }

       // scroll to top
      // I am scrolling to top every time data changes, use accordingly
        CoroutineScope(Dispatchers.Main).launch {
            state.snapToItemIndex(0, 0)
        }
    }
}

试一试

lazyListState.animateScrollToItem(lazyListState.firstVisibleItemIndex)


@Composable
fun CircularScrollList(
    value: Long,
    onValueChange: () -> Unit = {}
) {
    val lazyListState = rememberLazyListState()
    val scope = rememberCoroutineScope()

    val items = CircularAdapter(listOf(0, 1, 2, 3, 4, 5, 6, 7, 8, 9))
    scope.launch { lazyListState.scrollToItem(items.midIndex()) }

    LazyColumn(
        modifier = Modifier
            .requiredHeight(height = 120.dp)
            .border(width = 1.dp, color = Color.Black),
        state = lazyListState,
    ) {
        items(items) {
            if (!lazyListState.isScrollInProgress) {
                scope.launch {
                    lazyListState.animateScrollToItem(lazyListState.firstVisibleItemIndex)
                }
            }
            Text(
                text = "$it",
                modifier = Modifier.requiredHeight(40.dp),
                style = TextStyle(fontSize = 30.sp)
            )
        }
    }
}

class CircularAdapter(
    private val content: List<Int>
) : List<Int> {
    fun midIndex(): Int = Int.MAX_VALUE / 2 + 6
    override val size: Int = Int.MAX_VALUE
    override fun contains(element: Int): Boolean = content.contains(element = element)
    override fun containsAll(elements: Collection<Int>): Boolean = content.containsAll(elements)
    override fun get(index: Int): Int = content[index % content.size]
    override fun indexOf(element: Int): Int = content.indexOf(element)
    override fun isEmpty(): Boolean = content.isEmpty()
    override fun iterator(): Iterator<Int> = content.iterator()
    override fun lastIndexOf(element: Int): Int = content.lastIndexOf(element)
    override fun listIterator(): ListIterator<Int> = content.listIterator()
    override fun listIterator(index: Int): ListIterator<Int> = content.listIterator(index)
    override fun subList(fromIndex: Int, toIndex: Int): List<Int> =
        content.subList(fromIndex, toIndex)
}

lazyListState.animateScrollToItem（lazyListState.firstVisibleItemIndex）
@组合的
有趣的循环列表(
价值：长，
onValueChange:（）->Unit={}
) {
val lazyListState=rememberLazyListState（）
val scope=rememberCoroutineScope（）
val项目=圆形指示器（列表（0、1、2、3、4、5、6、7、8、9））
scope.launch{lazyListState.scrollToItem（items.midIndex（））}
懒散柱(
修饰语=修饰语
.所需高度（高度=120.dp）
.边框（宽度=1.dp，颜色=color.Black），
状态=懒散状态，
) {
项目（项目）{
如果（！lazyListState.isScrollInProgress）{
范围.发射{
lazyListState.animateScrollToItem（lazyListState.firstVisibleItemIndex）
}
}
正文(
text=“$it”，
修改器=修改器所需高度（40.dp），
style=TextStyle（fontSize=30.sp）
)
}
}
}
类圆翅目(
私有val内容：列表
)：列表{
fun midIndex（）：Int=Int.MAX_值/2+6
覆盖值大小：Int=Int.MAX_值
覆盖包含（元素：Int）：布尔值=内容。包含（元素=元素）
重写fun containsAll（元素：集合）：布尔=内容。containsAll（元素）
覆盖乐趣获取（索引：Int）：Int=content[索引%content.size]
重写fun indexOf（元素：Int）：Int=content.indexOf（元素）
override fun isEmpty（）：Boolean=content.isEmpty（）
重写有趣的迭代器（）：迭代器=内容。迭代器（）
覆盖lastIndexOf（元素：Int）：Int=content.lastIndexOf（元素）
重写有趣的listIterator（）：listIterator=content.listIterator（）
重写有趣的listIterator（索引：Int）：listIterator=content.listIterator（索引）
覆盖乐趣子列表（从索引：Int，到索引：Int）：列表=
content.subList（从索引到索引）
}
使用
1.0.0
（使用
1.0.0-beta08
进行测试）
LazyListState支持通过


“立即”捕捉滚动位置的功能
它使用动画滚动

比如：

val listState = rememberLazyListState()
// Remember a CoroutineScope to be able to launch
val coroutineScope = rememberCoroutineScope()

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

Button (
    onClick = { 
        coroutineScope.launch {
            // Animate scroll to the 10th item
            listState.animateScrollToItem(index = 10)
        }
    }
){
    Text("Click")
}

  

我解决了两个问题

一种方法：我选择了这个最好的方法

LaunchedEffect(true) {
  repeat(Int.MAX_VALUE) {
      delay(TIME_DELAY_BANNER)
      pagerState.animateScrollToPage(page = it % pagerState.pageCount)
  }
}

双向：

var index = pagerState.currentPage
LaunchedEffect(true) {
            while (true) {
                delay(TIME_DELAY_BANNER)
                if (index == pagerState.pageCount) {
                    index = 0
                }
      pagerState.animateScrollToPage(page = index++)
  }
}

var index = pagerState.currentPage
LaunchedEffect(true) {
            while (true) {
                delay(TIME_DELAY_BANNER)
                if (index == pagerState.pageCount) {
                    index = 0
                }
      pagerState.animateScrollToPage(page = index++)
  }
}