1. 你必须知道的 View 基础知识

val width = right - left
val height = bottom - top

val left = left;
val right = right
val top = top
val bottom = bottom

val x = left + translationX
val y = top + translationY

    override fun onTouchEvent(event: MotionEvent): Boolean {
        when (event?.action) {
            MotionEvent.ACTION_DOWN -> {
                println("手指按下")
            }
            MotionEvent.ACTION_UP -> {
                println("手指抬起")
            }
            MotionEvent.ACTION_MOVE -> {
                println("手指移动")
            }
        }
        return true
    }

• MotionEvent.ACTION_DOWN: 手指刚接触屏幕
• MotionEvent.ACTION_MOVE: 手指在屏幕上滑动
• MotionEvent.ACTION_UP: ** 手指在屏幕上抬起的一瞬间触发该事件

• DOWN ---> UP: 点击屏幕后立刻抬起手指松开屏幕触发的事件
• DOWN ---> MOVE ---> MOVE ---> MOVE ---> UP: 点击屏幕然后随着在屏幕上滑动之后在松开产生的事件

• getX / getY : 返回相对于当前 View 左上角的 x 和 y 的坐标
• getRawX / getRawY : 返回的是相对于手机屏幕左上角的 x 和 y 坐标。

/**
  * 系统所能识别出来的被认为滑动的最小距离
  */
val scaledDoubleTapSlop = ViewConfiguration.get(context).scaledDoubleTapSlop;

/**
  * 速度追踪
  */
 val velocityTracker = VelocityTracker.obtain()
 velocityTracker.addMovement(event)

velocityTracker.computeCurrentVelocity(1000)
val xVelocity = velocityTracker.getXVelocity()
val yVelocity = velocityTracker.getYVelocity()

velocityTracker.clear()
velocityTracker.recycle()

1. 在触摸事件为 ACTION_DOWN或是进入 onTouchEvent方法时，通过 obtain获取一个 VelocityTracker
2. 在触摸事件为 ACTION_UP时，调用 recycle进行释放 VelocityTracker
3. 在进入 onTouchEvent方法或将 ACTION_DOWN、ACTION_MOVE、ACTION_UP的事件通过 addMovement方法添加进 VelocityTracker
4. 在需要获取速度的地方，先调用 computeCurrentVelocity方法，然后通过 getXVelocity、getYVelocity获取对应方向的速度

1. 首先创建一个 GestureDetector 对象并实现 OnGestureListener 接口，根据需要我们还可以实现 OnDoubleTapListener 从而能够监听双击行为;

   val mGetDetector = GestureDetector(context,this)
   //解决长按屏幕后无法拖动的现象
   mGetDetector.setIsLongpressEnabled(false)
   

2. 接管目前 View 的 onTouchEvent 方法，在 View 的 onTouchEvent 方法中添加如下代码:

   override fun onTouchEvent(event: MotionEvent) = mGetDetector.onTouchEvent(event)
   

class ScrollerSample_1 : LinearLayout {
    constructor(context: Context, attrs: AttributeSet?) : super(context, attrs)
    constructor(context: Context) : super(context) 
    /**
     * 定义滑动 Scroller
     */
    private val mScroller = Scroller(context)
    public fun smoothScrollTo(destX: Int = -100, destY: Int = -100) {
        //滑动了的位置
        val scrollX = scrollY;
        val delta = destY - scrollY;
        //2000 ms 内滑动到 destX 位置，效果就是缓慢滑动
        mScroller.startScroll(scrollX, 0, 0, delta, 2000)
        invalidate()
    }
    override fun computeScroll() {
        if (mScroller.computeScrollOffset()) {
            scrollTo(mScroller.currX, mScroller.currY)
            postInvalidate()
        }
    }
}

• 第一步实例化 Scroller
• 第一步调用 Scroller 的 startScroll 方法，让其内部保存新的变量值
• 第二步重写 View 的 computeScroll 方法，调度自身的 scrollTo 方法，让其缓慢弹性滑动

1. 通过 View 本身提供的 scrollTo / scrollBy 方法来实现滑动（上一小节咱们已经用到 scrollTo 方法了）
2. 通过动画给 View 施加平移效果来实现滑动
3. 通过改变 View 的位置参数

//View.java
    public void scrollTo(int x, int y) {
        /**
         * 传入的位置跟自己目前所滑动的位置不一致才开始滑动
         */
        if (mScrollX != x || mScrollY != y) {
            int oldX = mScrollX;
            int oldY = mScrollY;
            mScrollX = x;
            mScrollY = y;
            invalidateParentCaches();
            onScrollChanged(mScrollX, mScrollY, oldX, oldY);
            if (!awakenScrollBars()) {
                postInvalidateOnAnimation();
            }
        }
    }
    public void scrollBy(int x, int y) {
        /**
         * 其内部也是调用了 View 的 scrollTo 方法，把当前滑动的 mScrollX,mScrollY 分别加上指定的位					 * 置，然后滑动，多次调用相当于接着上一次位置滑动
         */
        scrollTo(mScrollX + x, mScrollY + y);
    }

• scrollTo: 基于所传递的 x , y 坐标来进行绝对滑动，重复点击如果不改变滑动参数，那么内部就会做判断，相等就不会再滑动了。
• scrollBy: 通过源码我们知道内部调用了 scrollTo 方法传递了 mScrollX + x, mScrollY + y 那么这是什么意思呢？其实就是基于当前的位置来做的相对滑动。重复点击滑动会继续在当前所在的位置上继续滑动。

• mScrollX: 在滑动过程中，mScrollX 的值总是等于 View 左边缘和 View 内容左边缘在水平方向的距离。并且当 View 左边缘在 View 内容左边缘的右边时， mScrollX 值为正，反之为负，通俗的来讲就是如果从左向右滑动，那么 mScrollX 为 负值，反之为正值。
• mScrollY: 在滑动过程中，mScrollY 的值总是等于 View 上边缘和 View 内容上边缘在水平方向的距离。并且当 View 上边缘在 View 内容上边缘下边时，mScrollY 为正，反之为负，通俗的来讲就是如果从上往下滑动，那么 mScrollY 为负值，反之为正值。

1. 采用 View 动画，将 View 在 100ms 内从原始位置向右下角移动 100 px

   <?xml version="1.0" encoding="utf-8"?>
   <set xmlns:android="http://schemas.android.com/apk/res/android"
        android:fillAfter="true"
   >
       <translate
               android:duration="100"
               android:fromXDelta="0"
               android:fromYDelta="0"
               android:toXDelta="100"
               android:toYDelta="100"
               android:repeatCount="-1"  
       />
   </set>
   

   注意: View 动画并不能真正改变 View 的位置。
2. 采用属性动画，将 View 在 100ms 内从原始位置向右平移 100 px

   //动画属性有 translationX 、translationY 、alpha 、rotation、rotationX、rotationY 、scaleX、scaleY  
   val objAnimator = ObjectAnimator.ofFloat(View targetView,"translationX",0f,100f).setDuration(100).start()
   

val layoutParams = scroller.layoutParams as LinearLayout.LayoutParams
layoutParams.let {
                it.leftMargin += 100
                it.weight += 100
            }
            scroller.requestLayout()

• scrollTo/scrollBy 操作简单，适合对 View 内容的滑动
• 动画操作简单，主要适合用于没有交互的 View 和实现复杂的动画效果
• 改变布局参数操作稍微复杂，适用于有交互的 View

val valueAnimator = ValueAnimator.ofInt(0, 1).setDuration(2000);
valueAnimator.addUpdateListener {
   val animatedFraction = it.animatedFraction
   scroller.scrollTo(- (100 * animatedFraction).toInt(), 0)
}
valueAnimator.start()

    val MESSAGE_SCROLLER_TO = 1;
    val FRAME_COUNT = 30;
    val DELAYED_TIME = 33L;
    var mCount = 0;
    private val mHandler = object : Handler() {
        override fun handleMessage(msg: Message) {
            super.handleMessage(msg)
            when (msg.what) {
                MESSAGE_SCROLLER_TO -> {
                    mCount++
                    if (mCount <= FRAME_COUNT) {
                        val fraction = mCount / FRAME_COUNT.toFloat()
                        val scrollX = (fraction * 100).toInt()
                        scroller.scrollTo(scrollX, 0)
                        sendEmptyMessageDelayed(MESSAGE_SCROLLER_TO, DELAYED_TIME)
                    }
                }
            }
        }
    }

public class SlideView1(context: Context?, attrs: AttributeSet?) : View(context, attrs) {
    /**
     * 记录上次滑动的坐标
     */
    private var mLastX = 0;
    private var mLastY = 0;
    /**
     * 初始化画笔
     */
    val paint = Paint().apply {
        color = Color.BLACK
        isAntiAlias = true
        strokeWidth = 3f
    }
    override fun onTouchEvent(event: MotionEvent): Boolean {
        when (event.action) {
            MotionEvent.ACTION_DOWN -> {
                //拿到相对于屏幕按下的坐标点
                mLastX = event.getX().toInt();
                mLastY = event.getY().toInt();
                println("拿到相对于屏幕按下的坐标点: x:$mLastX y:$mLastY")
            }
            MotionEvent.ACTION_MOVE -> {
                var offsetX = event.getX().toInt() - mLastX;//计算 View 新的摆放位置
                var offsetY = event.getY().toInt() - mLastY;
                //重新放置新的位置
                layout(getLeft() + offsetX, getTop() + offsetY, getRight() + offsetX, getBottom() + offsetY);
            }
            MotionEvent.ACTION_UP -> {
            }
        }
        return true//消耗触摸事件
    }
    override fun onDraw(canvas: Canvas) {
        super.onDraw(canvas)
        canvas.drawCircle(300f, 300f, 150f, paint)
    }
}

public class SlideView2(context: Context?, attrs: AttributeSet?) : View(context, attrs) {
    /**
     * 记录上次滑动的坐标
     */
    private var mLastX = 0;
    private var mLastY = 0;
    private val mScroller = Scroller(context)
    /**
     * 初始化画笔
     */
    val paint = Paint().apply {
        color = Color.BLACK
        isAntiAlias = true
        strokeWidth = 3f
    }
    override fun onTouchEvent(event: MotionEvent): Boolean {
        when (event.action) {
            MotionEvent.ACTION_DOWN -> {
                //拿到相对于屏幕按下的坐标点
                mLastX = event.getRawX().toInt();
                mLastY = event.getRawY().toInt();
                println("拿到相对于屏幕按下的坐标点: x:$mLastX y:$mLastY")
            }
            MotionEvent.ACTION_MOVE -> {
              //1
//                x = event.getRawX() - mLastX
//                y =  event.getRawY() - mLastY
							//2
                translationX = event.getRawX() - mLastX
                translationY = event.getRawY() - mLastY
            }
            MotionEvent.ACTION_UP -> {
            }
        }
        return true//消耗触摸事件
    }
    override fun onDraw(canvas: Canvas) {
        super.onDraw(canvas)
        canvas.drawCircle(300f, 300f, 150f, paint)
    }
}

//View.java
    public void setX(float x) {
        setTranslationX(x - mLeft);
    }

1. 创建 Scroller 的实例
2. 调用 startScroll() 方法来初始化滚动数据并刷新界面
3. 重写 computeScroll() 方法，并在其内部完成平滑滚动的逻辑

/**
 * <pre>
 *     author  : devyk on 2019-11-16 19:23
 *     blog    : https://juejin.im/user/578259398ac2470061f3a3fb/posts
 *     github  : https://github.com/yangkun19921001
 *     mailbox : yang1001yk@gmail.com
 *     desc    : This is ScrollerViewPager
 * </pre>
 */
class ScrollerViewPager(context: Context?, attrs: AttributeSet?) : ViewGroup(context, attrs) {
    /**
     * 第一步 定义 Scroller 实例
     */
    private var mScroller = Scroller(context)
    /**
     * 判断拖动的最小移动像素点
     */
    private var mTouchSlop = 0
    /**
     * 手指按下屏幕的 x 坐标
     */
    private var mDownX = 0f
    /**
     * 手指当前所在的坐标
     */
    private var mMoveX = 0f
    /**
     * 记录上一次触发 按下是的坐标
     */
    private var mLastMoveX = 0f
    /**
     * 界面可以滚动的左边界
     */
    private var mLeftBorder = 0
    /**
     * 界面可以滚动的右边界
     */
    private var mRightBorder = 0
    init {
        init()
    }
    constructor(context: Context?) : this(context, null) {
    }
    private fun init() {
        /**
         * 通过 ViewConfiguration 拿到认为手指滑动的最短的移动 px 值
         */
        mTouchSlop = ViewConfiguration.get(context).scaledPagingTouchSlop
    }
    /**
     * 测量 child 宽高
     */
    override fun onMeasure(widthMeasureSpec: Int, heightMeasureSpec: Int) {
        super.onMeasure(widthMeasureSpec, heightMeasureSpec)
        //拿到子View 个数
        val childCount = childCount
        for (index in 0..childCount - 1) {
            val childView = getChildAt(index)
            //为 ScrollerViewPager 中的每一个子控件测量大小
            measureChild(childView, widthMeasureSpec, heightMeasureSpec)
        }
    }
    /**
     * 测量完之后，拿到 child 的大小然后开始对号入座
     */
    override fun onLayout(changed: Boolean, left: Int, top: Int, right: Int, bottom: Int) {
        if (changed) {
            val childCount = childCount
            for (child in 0..childCount - 1) {
                //拿到子View
                val childView = getChildAt(child)
                //开始对号入座
                childView.layout(
                    child * childView.measuredWidth, 0,
                    (child + 1) * childView.measuredWidth, childView.measuredHeight
                )
            }
            //初始化左右边界
            mLeftBorder = getChildAt(0).left
            mRightBorder = getChildAt(childCount - 1).right
        }
    }
    /**
     * 重写拦截事件
     */
    override fun onInterceptTouchEvent(ev: MotionEvent): Boolean {
        when (ev.action) {
            MotionEvent.ACTION_DOWN -> {
                //拿到手指按下相当于屏幕的坐标
                mDownX = ev.getRawX()
                mLastMoveX = mDownX
            }
            MotionEvent.ACTION_MOVE -> {
                //拿到当前移动的 x 坐标
                mMoveX = ev.getRawX()
                //拿到差值
                val absDiff = Math.abs(mMoveX - mDownX)
                mLastMoveX = mMoveX
                //当手指拖动值大于 TouchSlop 值时，就认为是在滑动，拦截子控件的触摸事件
                if (absDiff > mTouchSlop)
                    return true
            }
        }
        return super.onInterceptTouchEvent(ev)
    }
    /**
     * 父容器没有拦截事件，这里就会接收到用户的触摸事件
     */
    override fun onTouchEvent(event: MotionEvent): Boolean {
        when (event.action) {
            MotionEvent.ACTION_MOVE -> {
                //拿到当前滑动的相对于屏幕左上角的坐标
                mMoveX = event.getRawX()
                var scrolledX = (mLastMoveX - mMoveX).toInt()
                if (scrollX + scrolledX < mLeftBorder) {
                    scrollTo(mLeftBorder, 0)
                    return true
                }else if (scrollX + width + scrolledX > mRightBorder){
                    scrollTo(mRightBorder-width,0)
                    return true
                }
                scrollBy(scrolledX,0)
                mLastMoveX = mMoveX
            }
            MotionEvent.ACTION_UP -> {
                //当手指抬起是，根据当前滚动值来判定应该回滚到哪个子控件的界面上
                var targetIndex = (scrollX + width/2 ) / width
                var dx = targetIndex * width - scrollX
                /** 第二步 调用 startScroll 方法弹性回滚并刷新页面*/
                mScroller.startScroll(scrollX,0,dx,0)
                invalidate()
            }
        }
    return super.onTouchEvent(event)
    }
    override fun computeScroll() {
        super.computeScroll()
        /**
         * 第三步 重写 computeScroll 方法，并在其内部完成平滑滚动的逻辑
         */
        if (mScroller.computeScrollOffset()){
            scrollTo(mScroller.currX,mScroller.currY)
            postInvalidate()
        }
    }
}

<?xml version="1.0" encoding="utf-8"?>
<com.devyk.customview.sample_1.ScrollerViewPager
        xmlns:android="http://schemas.android.com/apk/res/android"
        xmlns:tools="http://schemas.android.com/tools"
        android:layout_width="match_parent"
        android:layout_height="match_parent"
        tools:context=".MainActivity">
    <Button
            android:id="@+id/btn_1"
            android:text="1"
            android:layout_width="match_parent"
            android:layout_height="match_parent"/>
    <Button
            android:id="@+id/btn_2"
            android:text="2"
            android:layout_width="match_parent"
            android:layout_height="match_parent"/>
    <Button
            android:id="@+id/btn_3"
            android:text="3"
            android:layout_width="match_parent"
            android:layout_height="match_parent"/>
    <Button
            android:id="@+id/btn_4"
            android:text="4"
            android:layout_width="match_parent"
            android:layout_height="match_parent"/>
    <Button
            android:id="@+id/btn_5"
            android:text="5"
            android:layout_width="match_parent"
            android:layout_height="match_parent"/>
    <Button
            android:id="@+id/btn_6"
            android:text="6"
            android:layout_width="match_parent"
            android:layout_height="match_parent"/>
</com.devyk.customview.sample_1.ScrollerViewPager>