Android RecyclerView：如果有很多项目，则假平滑滚动到顶部

Question

我们RecyclerView的应用程序中有您基于标准的 Feed 屏幕。

如果我有 100 多个项目RecyclerView并按“转到顶部”快捷方式，则默认行为smoothScrollToPosition(0)是需要很长时间才能滚动到顶部。

它需要多长时间几乎是可笑的 - 如果您向下滚动到顶部的速度足够快（这是一个常见的用例），则需要 10 秒的快速滚动！

我们正在寻找一种方法来“伪造”滚动到顶部，如果RecyclerView> 中的项目数SOME_THRESHOLD。

我不是 iOS 人，但我们的 iOS 版本（正如开发人员告诉我的那样）似乎将这种行为融入了控件中。如果项目太多，它只会做一个超级快速的模糊滚动，这显然会伪造/省略中间的许多项目。

RecyclerView 有这样的功能吗？

我们认为做多部分的事情，我们快速跳转到该项目指数SOME_THRESHOLD和再调用smoothScrollToPosition(0)-你的想法-但也有缺点，大多数的我们已经想到的事情。

感谢帮助，谢谢。

Answer 1

控制滚动速度的解决方案，更快地滚动到更远的位置

聚会有点晚了，但这里有一个 Kotlin 解决方案，供其他人看。

这证明棘手通过覆盖来解决calculateSpeedPerPixel的LinearSmoothScroller。通过对解决方案的尝试，我收到了很多“RecyclerView 通过目标位置”错误。如果有人知道如何解决这些问题，请分享。

我对这个解决方案采取了不同的方法：首先跳转到更接近目标位置的位置，然后平滑滚动：

/**
 * Enables still giving an impression of difference in scroll depending on how far the item scrolled to is,
 * while not having that tedious huge linear scroll time for distant items.
 * 
 * If scrolling to a position more than minJumpPosition diff away from current position, then jump closer first and then smooth scroll.
 * The distance how far from the target position to jump to is determined by a logarithmic function,
 * which in our case is y=20 at x=20 and for all practical purposes never goes over a y=100 (@x~1000) (so max distance is 100).
 * 
 * If the diff is under 20 there is no jump - for diff 15 the scroll distance is 15 items.
 * If the diff (x) is 30, jumpDiff (y) is around 28, so jump 2 and scroll 28 items.
 * If the diff (x) is 65, jumpDiff (y) is around 44, so jump 21 and scroll 44 items.
 * If the diff (x) is 100, jumpDiff (y) is around 53, so jump 47 and scroll 53 items.
 * If the diff (x) is 380, jumpDiff (y) is around 80, so jump 300 and scroll 80 items.
 * If the diff (x) is 1000, jumpDiff (y) is around 100 items scroll distance.
 * If the diff (x) is 5000, jumpDiff (y) is around 133 items scroll distance.
 * If the diff (x) is 8000, jumpDiff (y) is around 143 items scroll distance.
 * If the diff (x) is 10000, jumpDiff (y) is around 147 items scroll distance.
 *
 * You can play with the parameters to change the:
 *  - minJumpPosition: change when to start applying the jump
 *  - maxScrollAllowed: change speed change rate (steepness of the curve)
 *  - maxPracticalPosition: change what is the highest expected number of items
 * You might find it easier with a visual tool:
 * https://www.desmos.com/calculator/auubsajefh
 */
fun RecyclerView.jumpThenSmoothScroll(smoothScroller: SmoothScroller, position: Int,
                                      delay: Long = 0L,
                                      doAfterScrolled: (() -> Unit)? = null) {
    smoothScroller.targetPosition = position

    val layoutManager = layoutManager as LinearLayoutManager

    fun smoothScrollAndDoAfter() {
        layoutManager.startSmoothScroll(smoothScroller)
        doAfterScrolled?.let { post { postDelayed({ doAfterScrolled() }, max(0L, delay)) } }
    }

    val firstVisiblePosition = layoutManager.findFirstVisibleItemPosition()

    val diff = abs(position - firstVisiblePosition).toFloat()

    // Position from which to start applying "jump then scroll".
    val minJumpPosition = 20f

    if (diff > minJumpPosition) {
        // On the logarithmic function graph, 
        // y=minJumpPosition when x=minJumpPosition, and y=maxScrollAllowed when x=maxPracticalPosition.
        // So we are using two points to determine the function: 
        // (minJumpPosition, minJumpPosition) and (maxPracticalPosition, maxScrollAllowed)
        // In our case (20, 20) and (1000, 100)

        // Max practical possible items (max diff between current and target position).
        // It is OK for this to be high as logarithmic function is long approaching this value.
        val maxPracticalPosition = 1000
        // Never scroll more than this number of items. 
        // Scroll will be from 0 to maxScrollAllowed for all practical purposes 
        // ("practical" as determined by maxPracticalPosition).
        val maxScrollAllowed = 100

        // b = (x2/x1)^(1f/(y2-y1))
        val logBase = (maxPracticalPosition / minJumpPosition).pow (1f / (maxScrollAllowed - minJumpPosition))
        // s = (log(b)x1) - y1
        val logShift = log(minJumpPosition, logBase) - minJumpPosition

        val jumpDiff = (log(diff, logBase) - logShift).toInt() // y: 20 to 100 (for diff x: 20 to 1000)
        val jumpDiffDirection = if (position < firstVisiblePosition) 1 else -1
        val jumpPosition = position + (jumpDiff * jumpDiffDirection)

        // First jump closer
        layoutManager.scrollToPositionWithOffset(jumpPosition, 0)
        // Then smooth scroll
        smoothScrollAndDoAfter()
    } else {
        smoothScrollAndDoAfter()
    }
}