Android View 滑动的几种实现方式与原理详解

实现步骤：

1. 在 onTouchEvent 的 ACTION_DOWN 记录初始触摸坐标。
2. 在 ACTION_MOVE 计算 dx 和 dy。
3. 调用 layout(left + dx, top + dy, right + dx, bottom + dy)。

缺点： 每次调用 layout 都会触发一次完整的布局流程（measure -> layout），性能开销较大，不适合高频滚动的场景。

Kotlin 示例：

class ScrollableView @JvmOverloads constructor(
    context: Context,
    attrs: AttributeSet? = null
) : View(context, attrs) {

    private var lastX = 0f
    private var lastY = 0f

    override fun onTouchEvent(event: MotionEvent): Boolean {
        when (event.action) {
            MotionEvent.ACTION_DOWN -> {
                lastX = event.x
                lastY = event.y
                return true
            }
            MotionEvent.ACTION_MOVE -> {
                val dx = (event.x - lastX).toInt()
                val dy = (event.y - lastY).toInt()
                // 注意：这里会触发布局重排，性能较低
                layout(left + dx, top + dy, right + dx, bottom + dy)
                lastX = event.x
                lastY = event.y
                invalidate()
            }
        }
        return super.onTouchEvent(event)
    }
}

2. offsetLeftAndRight() / offsetTopAndBottom()

这两个方法是 layout 的便捷封装，专门用于调整 View 的位置而不改变其宽高。

源码逻辑：

public void offsetLeftAndRight(int offset) {
    // ... 省略
    mLeft += offset;
    mRight += offset;
    mRenderNode.offsetLeftAndRight(offset);
    // ... 省略
}

用法： 直接将上述 layout 调用替换为：

offsetLeftAndRight(dx)
offsetTopAndBottom(dy)

特点： 同样会触发布局流程，但语义更清晰，代码更简洁。适用于不需要频繁触发布局测量的场景。

3. translationX / translationY

translationX 和 translationY 属于 View 的属性动画范畴，它们不会改变 View 的实际布局位置（即 left, top 不变），仅影响绘制时的偏移。

优点：

• 不触发布局流程，性能优于 layout。
• 适合做平滑的过渡动画。
• 不会影响父容器的测量结果。

缺点：

• 无法通过 getLocationOnScreen 获取真实物理位置。
• 如果与其他布局约束冲突，可能表现异常。

实现：

override fun onTouchEvent(event: MotionEvent): Boolean {
    when (event.action) {
        MotionEvent.ACTION_MOVE -> {
            val dx = (event.x - lastX).toInt()
            val dy = (event.y - lastY).toInt()
            translationX += dx
            translationY += dy
            lastX = event.x
            lastY = event.y
            invalidate()
        }
    }
    return super.onTouchEvent(event)
}

4. setX() / setY()

setX(float x) 和 setY(float y) 本质上是设置 translationX 和 translationY 的快捷方式。

源码：

public void setX(float x) {
    setTranslationX(x - mLeft);
}

用法：

x += dx
y += dy
setX(x)
setY(y)

这与直接修改 translationX 效果一致，但语义上更接近绝对坐标设定。

5. scrollTo() / scrollBy()

这是最常用的滚动方式，主要用于 ViewGroup 或支持滚动的 View（如 TextView）。

原理：

• scrollTo(x, y)：将内容滚动到指定坐标。
• scrollBy(x, y)：基于当前位置增量滚动。
• 内部维护 mScrollX 和 mScrollY 变量。
• 实际上是通过平移 Canvas 画布来实现的，View 本身的 left/top 不变。

源码：

public void scrollBy(int x, int y) {
    scrollTo(mScrollX + x, mScrollY + y);
}

public void scrollTo(int x, int y) {
    if (mScrollX != x || mScrollY != y) {
        int oldX = mScrollX;
        int oldY = mScrollY;
        mScrollX = x;
        mScrollY = y;
        // ... 触发重绘
    }
}

注意事项：

• 对于普通 View，scrollTo 移动的是 View 内部的内容（如 TextView 的文字）。如果 View 本身没有子元素且背景固定，调用 scrollTo 可能看不到明显效果，除非重写 draw 方法。
• 对于 ViewGroup，它会移动所有子 View 的绘制位置。
• 在自定义 View 中，如果想让整个 View 跟随手指移动，通常需要操作父容器或使用 offset 系列方法；如果是内部内容滚动，则使用 scrollTo。

实现：

// 假设这是一个可以滚动的容器
(parent as View).scrollBy(-dx, -dy)

注：传入负值是因为手指向下滑动时，我们希望内容向上移动，而 scrollBy 的正方向是向右/向下移动画布，导致内容向左/向上移动。

拓展：Scroller 与惯性滑动

上述基础方法仅处理了手指按下和移动的过程，当手指抬起时，View 会立即停止，缺乏惯性效果。为了模拟真实的滚动体验，我们需要引入 Scroller 类。

Scroller 的作用

Scroller 是一个滑动算法工具类，它根据给定的起始位置、目标位置和持续时间，计算出每一帧应该到达的位置。

关键参数：

• startScrollX/Y: 起始滚动坐标。
• deltaX/Y: 增量值，最终位置 = 起始 + 增量。
• duration: 滑动持续时长（毫秒）。
• interpolator: 插值器，控制速度曲线（如先快后慢）。

完整惯性滑动实现

要实现流畅的惯性滑动，需要结合 computeScroll() 方法和 Scroller。

1. 初始化 Scroller：在构造函数中创建。
2. 计算初速度：在 ACTION_UP 时计算手指离开时的速度。
3. 启动 Scroller：调用 fling 或 startScroll。
4. 循环刷新：在 computeScroll() 中检查 scroller.computeScrollOffset()，若未结束则更新位置并 invalidate()。

完整代码示例：

class InertialScrollableView @JvmOverloads constructor(
    context: Context,
    attrs: AttributeSet? = null
) : View(context, attrs) {

    private var lastX = 0f
    private var lastY = 0f
    private var velocityTracker: VelocityTracker? = null
    private val scroller: Scroller
    
    init {
        scroller = Scroller(context)
        // 配置过冲效果
        overScrollMode = OVER_SCROLL_NEVER
    }

    override fun onDetachedFromWindow() {
        super.onDetachedFromWindow()
        velocityTracker?.recycle()
    }

    override fun onTouchEvent(event: MotionEvent): Boolean {
        if (velocityTracker == null) {
            velocityTracker = VelocityTracker.obtain()
        }
        velocityTracker?.addMovement(event)

        when (event.action) {
            MotionEvent.ACTION_DOWN -> {
                lastX = event.x
                lastY = event.y
                scroller.forceFinished(true)
                return true
            }
            MotionEvent.ACTION_MOVE -> {
                val dx = (event.x - lastX).toInt()
                val dy = (event.y - lastY).toInt()
                // 使用 offset 方法移动整个 View
                offsetLeftAndRight(-dx)
                offsetTopAndBottom(-dy)
                lastX = event.x
                lastY = event.y
                invalidate()
            }
            MotionEvent.ACTION_UP -> {
                velocityTracker?.computeCurrentVelocity(1000)
                val vx = velocityTracker?.xVelocity ?: 0f
                val vy = velocityTracker?.yVelocity ?: 0f
                
                // 启动惯性滑动
                scroller.fling(
                    scrollX, scrollY,
                    vx.toInt(), vy.toInt(),
                    Integer.MIN_VALUE, Integer.MAX_VALUE,
                    Integer.MIN_VALUE, Integer.MAX_VALUE
                )
                invalidate()
            }
        }
        return true
    }

    override fun computeScroll() {
        if (scroller.computeScrollOffset()) {
            scrollTo(scroller.currX, scroller.currY)
            invalidate()
        }
    }
}

computeScroll() 原理

computeScroll() 是 View 的一个回调方法，通常在 draw() 之前被调用。它的作用是告诉 View 是否需要继续渲染下一帧动画。

• 如果 scroller.computeScrollOffset() 返回 true，说明滑动尚未结束，需要更新位置并重绘。
• 如果返回 false，说明滑动已完成，停止刷新。

这种机制保证了动画的流畅性，同时避免了不必要的 CPU 消耗。

总结与对比

最佳实践建议：

1. 优先使用 translationX/Y 进行轻量级位移，避免触发布局。
2. 对于列表或内容区域滚动，使用 scrollTo 或继承 ScrollView。
3. 必须实现惯性效果时，务必集成 Scroller 或 OverScroller。
4. 注意 invalidate() 的调用频率，避免过度绘制。

通过掌握以上几种方式及其底层原理，开发者可以更灵活地控制 View 的行为，构建出符合预期的高质量交互界面。