前言

ScrollView垂直可滑动控件，当容器中的子视图高度大于ScrollView高度时，通过滑动ScrollView展示内容。

ScrollView继承FrameLayout。它只能有一个子视图，通常默认是LinearLayout。真正展示视图的垂直方向的区域是ScrollView高度除去其上下的padding值。即当计算出LinearLayout高度大于ScrollView高度，可滑动。

ScrollView视图如下图所示

ScrollView视图.png

ScrollView要显示非可见部分视图，需要通过触屏滑动实现，因此，本文分析的滑动原理，和触屏事件方法有很大关系。
几个重要方法，onInterceptTouchEvent方法，事件拦截，onTouchEvent方法，事件处理，OverScroller类，滚动控制。结合几个特定的手势场景解析ScrollView如何实现滑动。

静止状态，手指触屏到ScrollView，向上滑动
静止状态，手指触屏到ScrollView，向上滑动，然后猛地松开甩出。
滚动状态，手指触屏到ScrollView，向上滑动。

onInterceptTouchEvent方法

负责事件拦截决策，容器类视图都有这个方法，默认不拦截，ScrollView重写该方法。

@Override
public boolean onInterceptTouchEvent(MotionEvent ev) {
    //如果是Move，且mIsBeingDragged已经为true，直接返回。
    final int action = ev.getAction();
    if ((action == MotionEvent.ACTION_MOVE) && (mIsBeingDragged)) {
        return true;
    }
    //不支持滚动，返回false。
    if (getScrollY() == 0 && !canScrollVertically(1)) {
        return false;
    }
    //根据事件类型处理代码段，下面说明
    ...
    return mIsBeingDragged;
}

当Move事件并且设置mIsBeingDragged拖拽标志时，拦截。如果y轴不支持滚动，不拦截，在这种情况下，不管事件交给谁处理，ScrollView都不会介入事件处理。
打断方法，ACTION_DOWN事件处理。

case MotionEvent.ACTION_DOWN: {
    final int y = (int) ev.getY();
    //判断触屏坐标是否在子视图。
    if (!inChild((int) ev.getX(), (int) y)) {
        mIsBeingDragged = false;
        recycleVelocityTracker();
        break;
    }
    //记住y轴位置
    mLastMotionY = y;
    mActivePointerId = ev.getPointerId(0);  
    initOrResetVelocityTracker();
    mVelocityTracker.addMovement(ev);
    //Scroller未结束运动，说明ScrollView在滚动。返回mIsBeingDragged=true。
    mIsBeingDragged = !mScroller.isFinished();
    ...
    startNestedScroll(SCROLL_AXIS_VERTICAL);//Nested相关暂不谈
    break;
}

手指触屏ScrollView的第一个事件。mIsBeingDragged是全局变量，true说明ScrollView正在拖拽。
inChild方法，判断触屏点坐标是否在ScrollView的子视图中，坐标是相对于ScrollView坐标系的坐标，不在子视图中，返回mIsBeingDragged是false，不拦截。
OverScroller#isFinished判断ScrollView是否正在滚动，滚动可能是OverScroller#fing或startScroll触发，那么对应第三种手势场景。设置mIsBeingDragged是true，拦截。
ACTION_DOWN事件拦截时，并被成功处理(onTouchEvent返回true)，后续事件就不会再往下传递了。
ACTION_DOWN事件不拦截时，事件传递给LinearLayout内部子View，如果有子View接收事件(如按钮)，ACTION_DOWN就被消耗掉啦，否则还得靠ScrollView的onTouchEvent方法处理，反正onTouchEvent总能消耗返回true(后面介绍)。
打断方法，ACTION_MOVE事件处理。

case MotionEvent.ACTION_MOVE: {
    final int activePointerId = mActivePointerId;
    //activePointerId无效break
    ...
    final int y = (int) ev.getY(pointerIndex);
    final int yDiff = Math.abs(y - mLastMotionY);
    //没有垂直嵌套滚动
    if (yDiff > mTouchSlop && (getNestedScrollAxes() 
                            & SCROLL_AXIS_VERTICAL) == 0) {
        mIsBeingDragged = true;
        mLastMotionY = y;
        initVelocityTrackerIfNotExists();
        mVelocityTracker.addMovement(ev);
        mNestedYOffset = 0;
        .....
         final ViewParent parent = getParent();
        //告诉父节点，你不要拦截了，直接给我
        if (parent != null) {
            parent.requestDisallowInterceptTouchEvent(true);
        }
    }
    break;
}

ACTION_DOWN未拦截，继续看ACTION_MOVE
1：比较当前y坐标与上一次记住的mLastMotionY的差值yDiff，差值太小(小于阀值mTouchSlop )，不足以让屏幕认为是手指在滑动，不拦截。后期传递与处理与ACTION_DOWN不拦截的处理方法一致。
2：y坐标不同，ACTION_MOVE事件会连续，当有一次差值大于阀值，手指滑动。开始拦截。
对应第一种手势场景，mIsBeingDragged拖拽标志true。屏幕认为：手指从点击到滑动开启新的动作。
3：屏幕认为你在滑动了，需要告诉ScrollView的父视图不要拦截，所有的事件发到ScrollView处理，因为要滚动。
打断方法，ACTION_UP事件处理。

case MotionEvent.ACTION_CANCEL:
case MotionEvent.ACTION_UP:
            /* Release the drag */
    mIsBeingDragged = false;
    mActivePointerId = INVALID_POINTER;
    recycleVelocityTracker();
    if (mScroller.springBack(mScrollX, mScrollY, 0, 0, 0, 
                            getScrollRange())) {
                postInvalidateOnAnimation();
    }
    stopNestedScroll();
    break;
}

ACTION_MOVE未拦截，手指离开，一直未被屏幕认为要滑动，事件可能被子视图消耗，也可能在onTouchEvent中消耗，无关紧要了，反正我要离开了，将mIsBeingDragged恢复到false。

onTouchEvent分析

负责事件处理，基类View方法，基类已经提供了成功接纳事件的场景，如View可点击，返回true。
ScrollView完全重写该方法，在方法中未触发View的onTouchEvent。导致ScrollView无法使用OnClickListener监听，貌似也没有业务会用到，呵。除非子视图不存在。ScrollView#onTouchEvent的返回值一定是true。
两种基本情景 ，1：被拦截的事件。2：下层未消耗的事件。
事件处理，ACTION_DOWN事件

case MotionEvent.ACTION_DOWN: {
    if (getChildCount() == 0) {
        return false;
    }
    //总之我要处理，上面别拦我
    if ((mIsBeingDragged = !mScroller.isFinished())) {
        final ViewParent parent = getParent();
        if (parent != null) {
            parent.requestDisallowInterceptTouchEvent(true);
        }
    }
    //正在滚动，停止
    if (!mScroller.isFinished()) {
        mScroller.abortAnimation();
        if (mFlingStrictSpan != null) {
            mFlingStrictSpan.finish();
            mFlingStrictSpan = null;
        }
    }
    // 记住开始的y坐标
    mLastMotionY = (int) ev.getY();
    mActivePointerId = ev.getPointerId(0);
    startNestedScroll(SCROLL_AXIS_VERTICAL);
    break;
}

1：正在滚动，在拦截方法的down事件，已经设置了mIsBeingDragged=true，也有可能都是false，还没滚动，下面未消耗事件传上来的，告诉父视图，别拦我。
2：若正在滚动，则停止滚动abortAnimation，最终返回true，ACTION_DOWN事件被消耗。这就是为什么我们在正滑动的ScrollView视图触摸后，它停止了的原因。
事件处理，ACTION_MOVE事件

case MotionEvent.ACTION_MOVE:
    final int activePointerIndex = ev.findPointerIndex(mActivePointerId);
    //无效activePointerIndex 
    .....
    final int y = (int) ev.getY(activePointerIndex);
    int deltaY = mLastMotionY - y;//mLastMotionY >y时说明手指上移
    if (dispatchNestedPreScroll(0, deltaY, mScrollConsumed, mScrollOffset)) {
        deltaY -= mScrollConsumed[1];
        vtev.offsetLocation(0, mScrollOffset[1]);
        mNestedYOffset += mScrollOffset[1];
    }
    if (!mIsBeingDragged && Math.abs(deltaY) > mTouchSlop) {
        final ViewParent parent = getParent();
        if (parent != null) {
            parent.requestDisallowInterceptTouchEvent(true);
        }
        mIsBeingDragged = true;
        if (deltaY > 0) {//说明手指上移
            deltaY -= mTouchSlop;
        } else {
            deltaY += mTouchSlop;
        }
    }
    if (mIsBeingDragged) {
        ...
        final int oldY = mScrollY;
        final int range = getScrollRange();
        final int overscrollMode = getOverScrollMode();
        boolean canOverscroll = overscrollMode == OVER_SCROLL_ALWAYS ||
                (overscrollMode == OVER_SCROLL_IF_CONTENT_SCROLLS && range > 0);

        // View#overScrollBy会触发onOverScrolled
        if (overScrollBy(0, deltaY, 0, mScrollY, 0, range, 0, mOverscrollDistance, true)
                && !hasNestedScrollingParent()) {
            // Break our velocity if we hit a scroll barrier.
            mVelocityTracker.clear();
        }

        final int scrolledDeltaY = mScrollY - oldY;
        final int unconsumedY = deltaY - scrolledDeltaY;
        if (dispatchNestedScroll(0, scrolledDeltaY, 0, unconsumedY, mScrollOffset)) {
            mLastMotionY -= mScrollOffset[1];
            vtev.offsetLocation(0, mScrollOffset[1]);
            mNestedYOffset += mScrollOffset[1];
        } else if (canOverscroll) {
            //处理底部与顶部的边缘效果
            final int pulledToY = oldY + deltaY;
            if (pulledToY < 0) {
                mEdgeGlowTop.onPull((float) deltaY / getHeight(),
                        ev.getX(activePointerIndex) / getWidth());
                if (!mEdgeGlowBottom.isFinished()) {
                    mEdgeGlowBottom.onRelease();
                }
            } else if (pulledToY > range) {
                //见底后上拉的阴影效果
                mEdgeGlowBottom.onPull((float) deltaY / getHeight(),
                        1.f - ev.getX(activePointerIndex) / getWidth());
                if (!mEdgeGlowTop.isFinished()) {
                    mEdgeGlowTop.onRelease();
                }
            }
            if (mEdgeGlowTop != null
                    && (!mEdgeGlowTop.isFinished() || !mEdgeGlowBottom.isFinished())) {
                postInvalidateOnAnimation();
            }
        }
    }

1：判断上次mLastMotionY坐标与当前的差值deltaY，mIsBeingDragged=false且大于阀值mTouchSlop，说明下层未消耗事件，差值可能因Nested发生了改变，在onInterceptTouchEvent未发现需要拦截所以mIsBeingDragged是false，此时设置拖拽状态mIsBeingDragged=true。
2：拖拽状态下，以手指向上滑动为例分析。
滚动范围，getScrollRange方法，获取滚动的范围Range，即橙色部分。
child.getHeight() - (getHeight() - mPaddingBottom - mPaddingTop)，ScrollView子视图的高度height=(mBottom - mTop)大于可视区域，height减去可视区域的高度(注意Padding)就是滚动范围Range。当子视图高度较小，可视区域满足，不需滚动，Range=0。
滚动模式，View#mOverScrollMode滚动模式，OVER_SCROLL_IF_CONTENT_SCROLLS默认，可以滚动canOverscroll的要求是，一直可以滚OVER_SCROLL_ALWAYS或内容足够大以支持有意义的滚动OVER_SCROLL_IF_CONTENT_SCROLLS且Range大于0。
View#overScrollBy滚动，一旦开启了滚动mIsBeingDragged=true我就停不下来。在方法onTouchEvent中会连续的ACTION_MOVE事件，上滑时deltaY较大，速度慢下来deltaY变小，总之是deltaY动态变化的，也可能中间两个间隔deltaY是0，但都不影响overScrollBy。

protected boolean overScrollBy(int deltaX, int deltaY,
            int scrollX, int scrollY,
            int scrollRangeX, int scrollRangeY,
            int maxOverScrollX, int maxOverScrollY,
            boolean isTouchEvent) {
    //X轴滚动忽略
    ...
    int newScrollY = scrollY + deltaY;
    ...
    final int top = -maxOverScrollY;
    final int bottom = maxOverScrollY + scrollRangeY;
    ..
    boolean clampedY = false;
    if (newScrollY > bottom) {
        newScrollY = bottom;
        clampedY = true;
    } else if (newScrollY < top) {
        newScrollY = top;
        clampedY = true;
    }
    onOverScrolled(newScrollX, newScrollY, clampedX, clampedY);
    return clampedX || clampedY;
}

当前scrollY+deltaY得到新newScrollY，这里传入的maxOverScrollY是mOverscrollDistance=0，
如果新值大于滑动区域range，newScrollY设为range，并设置clampedY=true说明上滑已见底。overScrollBy返回的clampedY表示是否已见底。
触发onOverScrolled方法，ScrollView中重写onOverScrolled。onOverScrolled功能就是为View设置偏移mScrollY。一种是立即设置scrollTo，另一种是平滑设置OverScroller。

手指上滑scroll，ScrollView整体往上移动，mScrollY值大于0，mScrollY值不断加deltaY递增。

边缘效果，如果已经见底，手指继续上滑动，oldY即mScrollY是经过overScrollBy设置的最新值，此时一直是range，不会改变。+deltaY后的pulledToY将大于range，mEdgeGlowBottom#onPull触发阴影效果。
ACTION_MOVE事件结束，第一种手势场景主要在这儿完成。
3：未拖拽状态，不关心事件来自哪里，反正我来管，返回true。
事件处理，ACTION_UP事件

case MotionEvent.ACTION_UP:
    if (mIsBeingDragged) {
        final VelocityTracker velocityTracker = mVelocityTracker;
        velocityTracker.computeCurrentVelocity(1000, mMaximumVelocity);
        int initialVelocity = (int) velocityTracker.getYVelocity(mActivePointerId);

        if ((Math.abs(initialVelocity) > mMinimumVelocity)) {
            //手指猛地一滑，速度很大，触发fling
            flingWithNestedDispatch(-initialVelocity);
        } else if (mScroller.springBack(mScrollX, mScrollY, 0, 0, 0,
                getScrollRange())) {
            postInvalidateOnAnimation();
        }

        mActivePointerId = INVALID_POINTER;
        endDrag();
    }

手指离开屏幕ACTION_UP事件
1：如果mIsBeingDragged=false，未拖拽，下层未处理，我来管，返回tue。
2：拖拽状态时，速度判断，速度未达到最小值，安静的离开endDrag初始化mIsBeingDragged=false并释放速度追踪器和顶部/底部的边缘效果。速度大于最小值时，触发fling平滑一段距离。

ScrollView#flingWithNestedDispatch方法
private void flingWithNestedDispatch(int velocityY) {
    final boolean canFling = (mScrollY > 0 || velocityY > 0) &&
                (mScrollY < getScrollRange() || velocityY < 0);
    if (!dispatchNestedPreFling(0, velocityY)) {
        dispatchNestedFling(0, velocityY, canFling);
        if (canFling) {
            fling(velocityY);
        }
    }
}

在flingWithNestedDispatch方法中，判定mScrollY在Range范围，且有启动速度，那么开始fling吧。(这里暂不支持Nested，dispatchNestedPreFling会返回false)，
ScrollView的fling方法，由OverScroller负责。

public void fling(int velocityY) {
    if (getChildCount() > 0) {
        int height = getHeight() - mPaddingBottom - mPaddingTop;
        int bottom = getChildAt(0).getHeight();
        mScroller.fling(mScrollX, mScrollY, 0, velocityY, 0, 0, 0,
                    Math.max(0, bottom - height), 0, height/2);
        ...
        postInvalidateOnAnimation();
    }
}

height是ScrollView可显示区域的高度即绿色区域，bottom是子视图LinearLayout高度。bottom-height即滑动区域Range。fling自动滚动一段距离，mScrollY的最大值不应超过range，最小值是0。
ACTION_UP事件结束，手指离开触屏，第二种手势场景主要在这儿完成。

OverScroller

先看ScrollView#onOverScrolled，在overScrollBy中触发。

@Override
protected void onOverScrolled(int scrollX, int scrollY,
            boolean clampedX, boolean clampedY) {
    if (!mScroller.isFinished()) {
        final int oldX = mScrollX;
        final int oldY = mScrollY;
        mScrollX = scrollX;
        mScrollY = scrollY;
        invalidateParentIfNeeded();
        onScrollChanged(mScrollX, mScrollY, oldX, oldY);
        if (clampedY) {
            mScroller.springBack(mScrollX, mScrollY, 0, 0, 0, getScrollRange());
        }
    } else {
        super.scrollTo(scrollX, scrollY);
    }

    awakenScrollBars();
}

isFinished平滑运动判定

所谓平滑运动是指mScrollY并非直接设置为最终值，而是经过一个duration到达某数值。此时在绘制时，就会出现平滑运动的效果，系统中默认持续时间250毫秒。

触发View的scrollTo方法，ScrollView设置新scrollY，并重新绘制。连续的ACTION_MOVE事件，不断更新scrollY，于是就会出现手指在ScrollView上滑动，ScrollView发生滚动的效果。触屏事件的overScrollBy处理一般都这条路。

scrollBy(x,y)，当前视图内容在x轴和y轴分别偏移x和y个坐标点。
scrollTo(x,y)，当前视图内容移动到x轴和y轴上的某个坐标点。
这两个方法都是View提供的方法，控制视图内容的偏移。这种偏移会非常快的移到目标位置，并不能进行流程控制。

OverScroller原理分析
OverScroller的作用就是在偏移的过程中进行流程控制，通过设定一个时间，在规定的时间内移动到指定位置。

OverScroller#startScroll开启平滑滚动
startScroll(int startX, int startY, int dx, int dy, int duration)，从x，y的起始位置，偏移一定的距离dx和dy，经历的时间是duration，内部触发SplineOverScroller#startScroll方法

SplineOverScroller#startScroll
void startScroll(int start, int distance, int duration) {
    mFinished = false;

    mCurrentPosition = mStart = start;
    mFinal = start + distance;

    mStartTime = AnimationUtils.currentAnimationTimeMillis();
    mDuration = duration;
    ....
}

start代表当前ScrollY，mFinal 是最终值，duration是持续时间。
当我开启了一次startScroll平滑，并触发postInvalidateOnAnimation重绘，computeScroll()是在绘制树形结构中一直触发的方法。

ScrollView#computeScroll()
@Override
public void computeScroll() {
    if (mScroller.computeScrollOffset()) {
        int oldX = mScrollX;
        int oldY = mScrollY;
        int x = mScroller.getCurrX();
        int y = mScroller.getCurrY();

        if (oldX != x || oldY != y) {
            final int range = getScrollRange();
            final int overscrollMode = getOverScrollMode();
            final boolean canOverscroll = overscrollMode == OVER_SCROLL_ALWAYS ||
                        (overscrollMode == OVER_SCROLL_IF_CONTENT_SCROLLS && range > 0);
            overScrollBy(x - oldX, y - oldY, oldX, oldY, 0, range,
                        0, mOverflingDistance, false);
            onScrollChanged(mScrollX, mScrollY, oldX, oldY);
            ....
        }
        if (!awakenScrollBars()) {
            // Keep on drawing until the animation has finished.
            postInvalidateOnAnimation();
        }
    } else {
        .....           
    }
}

computeScrollOffset判断平滑duration是否耗完，根据duration和起始终点位置计算此时的值。从OverScroll中获取当前计算的值，根据与mScrollY差值变化触发overScrollBy，这里会触及到onOverScrolled的isFinished为false的情况，设定新mScrollY，不停地个绘制看到平滑的滚动，直到到达终点。
可以看出OverScroller只是会计算一定的时间内滚动多少才会在滚动时间完成滚动。真正的View移动还是通过View的overScrollBy方法去设置mScrollY。

OverScroller并不是控制滚动，它只是空间移动轨迹的辅助计算类，计算什么时间滚动到什么位置。

OverScroller#fling速度自动移动距离一段，内部触发SplineOverScroller的fling方法。由ACTION_UP事件发起

SplineOverScroller#fling方法
void fling(int start, int velocity, int min, int max, int over) {
    ...
    mFinished = false;
    mCurrVelocity = mVelocity = velocity;
    mDuration = mSplineDuration = 0;
    mStartTime = AnimationUtils.currentAnimationTimeMillis();
    mCurrentPosition = mStart = start;
    ....
    if (velocity != 0) {
        mDuration = mSplineDuration = getSplineFlingDuration(velocity);
        totalDistance = getSplineFlingDistance(velocity);
    }
    mSplineDistance = (int) (totalDistance * Math.signum(velocity));
    mFinal = start + mSplineDistance;
    ... 根据最大值和最小值校正mFinal和mDuration 
    if (mFinal > max) {
        adjustDuration(mStart, mFinal, max);
        mFinal = max;
    }
}

从代码可以看出，start是当前的ScrollY，velocity是速度，max是range，即ScrollY的最大值。主要目的是根据当前速度，计算出后续自动移动的距离mSplineDistance与耗时mDuration，mFinal是最终偏移值，最后根据最大偏移max，校正时间与mFinal 。

简单一句总结就是fling方法手指离开屏幕时的速度初始化了一个持续时间和可滑动距离，后续开始自动滑动并最终在该时间达到指定位置的过程。

同startScroll类似，也是触发computeScroll方法，不同点在于computeScrollOffset计算当前值的差值器算法不同。

任重而道远