看一看ScrollView的源码

欣赏

你对明天有没有美好的期待呢，它是否会如期而来呢.....

线索

主要的成员标记

核心功能与方法

1. 成员

mScroller: 用来计算内部内容滚动的辅助类OverScroller，但是主要的滚动并没有使用到他哦

mEdgeGlowTop：　当滚动到最顶部的时候的上边界阴影效果

mEdgeGlowBottom：　当滚动到最底部时候的下边界阴影效果

mChildToScrollTo：　记录拥有焦点的view, 在layout的时候会将位置滚动到他的地方

mIsBeingDragged：　true表示scrollview在滚动;注意在嵌套滚动的时候，不属于scrollView的滚动，他为false;

mFillViewport: true, ScrollView模式不是MeasureSpec.UNSPECIFIED， 会用scrollView的高度来当自己的高度，重新在给子ｖｉew测量一遍;一般他都不会是这个模式, 什么情况下ScrollView是UNSPECIFIED模式呢，从scollView的测量可以看出，他给子view测量的规格就是UNSPECIFIED，因此scrollView嵌套scrollView的时候， 第二个scrollView如果设置了mFillViewport，依然是不会重新测量他的子view的哦。

mActivePointerId：　当前激活的手指; 这个是scrollView处理多手指滑动的原则。他的基本规则是这样的，当第二个手指落下滑动的时候，那么前面第一个手指滑动就失效了，因为将激活的手指给到了第二个手指，当第二个手指抬起的时候，又会把激活的点给到第一个手指。

其他的就不一一列出来了......

2. 功能与方法

普通的LinearLayout, RelativeLayout, FrameLayout他们的页面内容都是有限的，限于一屏之内，而ScrollView却不是哦，这就是他主要功能。

ScrollView的构造与初始化：

public ScrollView(Context context, AttributeSet attrs, int defStyleAttr, int defStyleRes) {
    super(context, attrs, defStyleAttr, defStyleRes);
    initScrollView();
    final TypedArray a = context.obtainStyledAttributes(
        attrs, com.android.internal.R.styleable.ScrollView, defStyleAttr, defStyleRes);
  //读取是否设置了viewport属性，让子view填充scrollView高度
    setFillViewport(a.getBoolean(R.styleable.ScrollView_fillViewport, false));

    a.recycle();
}


private void initScrollView() {
    mScroller = new OverScroller(getContext());
    setFocusable(true);
    //优先让子view获得焦点
    setDescendantFocusability(FOCUS_AFTER_DESCENDANTS);
    setWillNotDraw(false);
    final ViewConfiguration configuration = ViewConfiguration.get(mContext);
    //滚动识别距离，
    mTouchSlop = configuration.getScaledTouchSlop();
    //fling滑行的最小速度
    mMinimumVelocity = configuration.getScaledMinimumFlingVelocity();
     //fling滑行的最大速度
    mMaximumVelocity = configuration.getScaledMaximumFlingVelocity();
    mOverscrollDistance = configuration.getScaledOverscrollDistance();
    mOverflingDistance = configuration.getScaledOverflingDistance();
}

总结一下，其实构造和初始化比较简单，就是读取scrollView的一个_fillViewport属性，如果他为true, 他的子child一般会经过两侧测量，最终的高度和scollView是一样的; 然后就是读取系统的默认配置，比如移动多少算是滚动，多大速度可以在松手时候认为是要去滑翔。

ScrollView只能有一个child，否则会抛异常, 看这里:

 public void addView(View child) {
     if (getChildCount() > 0) {
         throw new IllegalStateException("ScrollView can host only one direct child");
     }

     super.addView(child);
 }

setFillViewport，动态设定ScrollView的填充属性

public void setFillViewport(boolean fillViewport) {
    if (fillViewport != mFillViewport) {
        mFillViewport = fillViewport;
        //因为要改变子child的高度，自然要重新测量，布局一次啦。
        requestLayout();
    }
}

ScrollView的测量入口, onMeasure：

protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
    //主要的测量还是调用父类FrameLayout的测量，
    super.onMeasure(widthMeasureSpec, heightMeasureSpec);
    //mFillViewport为true, 才需要重新测量一次
    if (!mFillViewport) {
        return;
    }

    final int heightMode = MeasureSpec.getMode(heightMeasureSpec);
    //scrollView本身的模式一般不会是这个，除非是scrollView的父容器也是scrollView
    if (heightMode == MeasureSpec.UNSPECIFIED) {
        return;
    }

    if (getChildCount() > 0) {
        final View child = getChildAt(0);
        int height = getMeasuredHeight();
        //如果child的高度小于scrollView的高度啦，
        if (child.getMeasuredHeight() < height) {
            final FrameLayout.LayoutParams lp = (LayoutParams) child.getLayoutParams();
            int childWidthMeasureSpec = getChildMeasureSpec(widthMeasureSpec,
                                                            mPaddingLeft + mPaddingRight, lp.width);
            height -= mPaddingTop;
            height -= mPaddingBottom;
            int childHeightMeasureSpec =
            MeasureSpec.makeMeasureSpec(height, MeasureSpec.EXACTLY);
          //重新测量子child
            child.measure(childWidthMeasureSpec, childHeightMeasureSpec);
        }
    }
}

总结一下, 可以看出ScrollView的本身测量主要是调用父类FrameLayout的测量方法，简单说说FrameLayout的测量，他其实是先遍历所有的子ｖｉew, 找到一个高度最大的ｖｉew作为预备的高度，然后通过FrameLayout本身的测量规格(包含规格和父容器的剩余高度)，来决定他的高度。比如FrameLayout的onMeasure传递过来的规格是EXACTLY，那么最终高度就是measureSpec解析出来的高度，比如传递过来的是AT_MOST，并且我们的预备高度小于measureSpec解析的高度，那么最终高度就是我们前面计算的预备高度啦, 也就是我们的scrollView的最终高度！

ScrollView的测量之二，子Child的测量measureChildWithMargins：

protected void measureChildWithMargins(View child, int parentWidthMeasureSpec, int widthUsed,
                                       int parentHeightMeasureSpec, int heightUsed) {
    final MarginLayoutParams lp = (MarginLayoutParams) child.getLayoutParams();
  
    //获取child的宽度规格，
    final int childWidthMeasureSpec = getChildMeasureSpec(parentWidthMeasureSpec,
                                                          mPaddingLeft + mPaddingRight + lp.leftMargin + lp.rightMargin
                                                          + widthUsed, lp.width);
    //构建高度的测量规格，可以看到给到size只是一个上下margin, mode是无限制的。根据标准的测量原则
    //可以知道，子child想要多高就给多高啦。
    final int childHeightMeasureSpec = MeasureSpec.makeMeasureSpec(
        lp.topMargin + lp.bottomMargin, MeasureSpec.UNSPECIFIED);
  //测量。
    child.measure(childWidthMeasureSpec, childHeightMeasureSpec);
}

总结一下，在测量scrollview的时候，其实是要在FrameLayout中先测量他的子view的宽高的，然后根据子view的高度来设定Scrollｖｉew的高度。scrollview重写的measureChildWithMargins方法，他在测量子child时候给child的规格是MeasureSpec.UNSPECIFIED，这个是很少见的，但原来也是很有用的，他可以让子child得到他想要的任意高度，ScrollView不限制他的子view高度，　在滚动容器中正好是需要的啦！

ScrollView的布局

protected void onLayout(boolean changed, int l, int t, int r, int b) {
    //依然还是调用frameLayout去布局他的child啦;
    super.onLayout(changed, l, t, r, b);
    //
    mIsLayoutDirty = false;
    // 如果记录了焦点的child,那么就滚到到该child的位置，注意可能不是ScrollView的直接子child哦
    if (mChildToScrollTo != null && isViewDescendantOf(mChildToScrollTo, this)) {
        scrollToChild(mChildToScrollTo);
    }
    mChildToScrollTo = null;

    if (!isLaidOut()) {
        if (mSavedState != null) {
            mScrollY = mSavedState.scrollPosition;
            mSavedState = null;
        } // mScrollY default value is "0"

        final int childHeight = (getChildCount() > 0) ? getChildAt(0).getMeasuredHeight() : 0;
        //计算可以滚动的距离
        final int scrollRange = Math.max(0,
                                         childHeight - (b - t - mPaddingBottom - mPaddingTop));

        // 范围纠正
        if (mScrollY > scrollRange) {
            mScrollY = scrollRange;
        } else if (mScrollY < 0) {
            mScrollY = 0;
        }
    }

    // 重新布局的时候不会丢失原来的滚动位置
    scrollTo(mScrollX, mScrollY);
}

总结一下，可以看出，布局的主要手段还是借助了FrameLayout，这个其实也很简单，就一个child.　ScrollView不本身做了焦点child的位置滚动，以及还原以前的scroll位置.

ScrollView的绘制，draw方法

public void draw(Canvas canvas) {
    //调用fm.draw绘制自己的内容
    super.draw(canvas);
    if (mEdgeGlowTop != null) {
        final int scrollY = mScrollY;
        if (!mEdgeGlowTop.isFinished()) {//拖到了边界处没有松手
            final int restoreCount = canvas.save();
            final int width = getWidth() - mPaddingLeft - mPaddingRight;
          
            canvas.translate(mPaddingLeft, Math.min(0, scrollY));
            mEdgeGlowTop.setSize(width, getHeight());
            //绘制他的上边界
            if (mEdgeGlowTop.draw(canvas)) {
                postInvalidateOnAnimation();
            }
            canvas.restoreToCount(restoreCount);
        }
        if (!mEdgeGlowBottom.isFinished()) {//拖到了边界处没有松手
            final int restoreCount = canvas.save();
            final int width = getWidth() - mPaddingLeft - mPaddingRight;
            final int height = getHeight();

            canvas.translate(-width + mPaddingLeft,
                             Math.max(getScrollRange(), scrollY) + height);
            canvas.rotate(180, width, 0);
            mEdgeGlowBottom.setSize(width, height);
            //绘制他的下边界
            if (mEdgeGlowBottom.draw(canvas)) {
                postInvalidateOnAnimation();
            }
            canvas.restoreToCount(restoreCount);
        }
    }
}

总结一下，除了借助Fm去绘制child和本身外，这里主要的内容就是当滚动了边界处的时候，绘制上边界的阴影和下边界的阴影效果。

ScollView滚动之拦截，onInterceptTouchEvent, 如果拦截了触摸，那么子view就不能顺利地使用触摸事件啦，比如ScrollView下面的Recyclerｖｉew等，看看代码吧:

public boolean onInterceptTouchEvent(MotionEvent ev) {
       
        final int action = ev.getAction();
      //如果之前拦截了，档次又是move,那么就拦下来，不去后面的计算啦
        if ((action == MotionEvent.ACTION_MOVE) && (mIsBeingDragged)) {
            return true;
        }

          //没得去滑了，而且还要没滑动过不拦截，奇怪，为什么要getScrollY＝＝？
        if (getScrollY() == 0 && !canScrollVertically(1)) {
            return false;
        }

        switch (action & MotionEvent.ACTION_MASK) {
            case MotionEvent.ACTION_MOVE: {
     
                final int activePointerId = mActivePointerId;
                if (activePointerId == INVALID_POINTER) {
                    // If we don't have a valid id, the touch down wasn't on content.
                    break;
                }

                final int pointerIndex = ev.findPointerIndex(activePointerId);
                if (pointerIndex == -1) {
                    Log.e(TAG, "Invalid pointerId=" + activePointerId
                            + " in onInterceptTouchEvent");
                    break;
                }

                final int y = (int) ev.getY(pointerIndex);
                final int yDiff = Math.abs(y - mLastMotionY);
               
                //如果move达到了滚动，并且不是嵌套滚动，立即拦截。
                if (yDiff > mTouchSlop && (getNestedScrollAxes() & SCROLL_AXIS_VERTICAL) == 0) {
                    mIsBeingDragged = true;
                    mLastMotionY = y;
                    initVelocityTrackerIfNotExists();
                    mVelocityTracker.addMovement(ev);
                    mNestedYOffset = 0;
                    if (mScrollStrictSpan == null) {
                        mScrollStrictSpan = StrictMode.enterCriticalSpan("ScrollView-scroll");
                    }
                    final ViewParent parent = getParent();
                    if (parent != null) {
                        parent.requestDisallowInterceptTouchEvent(true);
                    }
                }
                break;
            }

            case MotionEvent.ACTION_DOWN: {
                final int y = (int) ev.getY();
                if (!inChild((int) ev.getX(), (int) y)) {
                    //不拦截
                    mIsBeingDragged = false;
                    recycleVelocityTracker();
                    break;
                }

              ........
                
                //如果在fling状态，立即拦截。
                mIsBeingDragged = !mScroller.isFinished();
                if (mIsBeingDragged && mScrollStrictSpan == null) {
                    mScrollStrictSpan = StrictMode.enterCriticalSpan("ScrollView-scroll");
                }
                startNestedScroll(SCROLL_AXIS_VERTICAL);
                break;
            }

            case MotionEvent.ACTION_CANCEL:
            case MotionEvent.ACTION_UP:
                //取消拦截
                mIsBeingDragged = false;
                mActivePointerId = INVALID_POINTER;
                recycleVelocityTracker();
                if (mScroller.springBack(mScrollX, mScrollY, 0, 0, 0, getScrollRange())) {
                    postInvalidateOnAnimation();
                }
                stopNestedScroll();
                break;
            case MotionEvent.ACTION_POINTER_UP:
                onSecondaryPointerUp(ev);
                break;
        }

      //拦截与否，主要还是ｉ看这个标记呢，
        return mIsBeingDragged;
    }

总结一下，ScrollView有几个地方会去拦截：当在down事件时候，如果当前的ScrollView在滑行状态，会拦截下来不给子view使用，这个时候down事件都并不会下发下去。当move的时候，如果不是嵌套滚动，一般ScrollView也将它拦截下来自己使用, 还有就是之前拦截了，这次又是move事件也会立刻拦截下来，整体上ScrollView就是这么处理拦截的啦，不过拦截了也不是说子view就不能用，毕竟子child可以用requestDisallowInterceptTouchEvent来禁止他的拦截生效。

ScollView滚动之触摸，这个算是滚动的最重要的地方之一啦, onTouchEvent, 根据手指的事件一个个地看吧：

case MotionEvent.ACTION_DOWN: {
    //没有child,不消耗啦，没搞头啊
    if (getChildCount() == 0) {
        return false;
    }
    //如果当前在滚动状态，说明之前自己消耗的，这次也要自己来，请求父容器不要消耗.
    if ((mIsBeingDragged = !mScroller.isFinished())) {
        final ViewParent parent = getParent();
        if (parent != null) {
            parent.requestDisallowInterceptTouchEvent(true);
        }
    }

  //这里有意思，当上一次的滚动还在fling状态的时候，手指一放下，那么就会停止滑动啦，不信试试
    if (!mScroller.isFinished()) {
        //停止滑动。
        mScroller.abortAnimation();
        if (mFlingStrictSpan != null) {
            mFlingStrictSpan.finish();
            mFlingStrictSpan = null;
        }
    }

    // Remember where the motion event started
    mLastMotionY = (int) ev.getY();
    mActivePointerId = ev.getPointerId(0);
    //触发嵌套滑动，ScrollView的嵌套滑动太鸡肋，这里觉得没有分析的必要
    startNestedScroll(SCROLL_AXIS_VERTICAL);
    break;
}

........
    
return true;

case MotionEvent.ACTION_MOVE:
  //找到当前激活的手指，获取他的手势事件
    final int activePointerIndex = ev.findPointerIndex(mActivePointerId);
    if (activePointerIndex == -1) {
        Log.e(TAG, "Invalid pointerId=" + mActivePointerId + " in onTouchEvent");
        break;
    }

    final int y = (int) ev.getY(activePointerIndex);
  //向上滑动，大于0
    int deltaY = mLastMotionY - y;
  //嵌套滚动相关的，在ScrollView中的实现是很鸡肋的,没什么好说的
    if (dispatchNestedPreScroll(0, deltaY, mScrollConsumed, mScrollOffset)) {
        deltaY -= mScrollConsumed[1];
        vtev.offsetLocation(0, mScrollOffset[1]);
        mNestedYOffset += mScrollOffset[1];
    }
//如果当前没有被认定为scrollview的滚动，会根据情况让scollView去滚动，这也是scrollView实现
//内容滚动的核心地方。
    if (!mIsBeingDragged && Math.abs(deltaY) > mTouchSlop) {
        final ViewParent parent = getParent();
        //这里的意思是说，当move传递到了scrollView了，并且达到了滚动距离，就认为该让scrollview去
        //消耗事件了,请求不要拦截后续的事件就交给scrollview处理了。但是这种实现有点诡异，因为如果ScollView
        //的父容器拦截了move，根本就不会走到这里来了，这里的请求不要拦截也不会生效，只有当父容器在move中拦截的条件还没有生效，在这里设定才会起到作用。
        if (parent != null) {
            parent.requestDisallowInterceptTouchEvent(true);
        }
        
        mIsBeingDragged = true;
        if (deltaY > 0) {
            deltaY -= mTouchSlop;
        } else {
            deltaY += mTouchSlop;
        }
    }
    if (mIsBeingDragged) {
        // Scroll to follow the motion event
        mLastMotionY = y - mScrollOffset[1];

        final int oldY = mScrollY;
        //子child.height - scrollview的height,得出可以滚动的范围
        final int range = getScrollRange();
        final int overscrollMode = getOverScrollMode();
        //如果是OVER_SCROLL_IF_CONTENT_SCROLLS，那么必须child的内容高度大于scollview的高度才可
        //认为绘制过度滚动视觉阴影
        boolean canOverscroll = overscrollMode == OVER_SCROLL_ALWAYS ||
            (overscrollMode == OVER_SCROLL_IF_CONTENT_SCROLLS && range > 0);

       //overScollBy进行了主要的内容哦你那个滚动啦;
        if (overScrollBy(0, deltaY, 0, mScrollY, 0, range, 0, mOverscrollDistance, true)
            && !hasNestedScrollingParent()) {
            // Break our velocity if we hit a scroll barrier.
            mVelocityTracker.clear();
        }
      //计算scrolledDeltaY滚动过的距离
        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) {//如果累计的滚动已经小于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();
            }
        }
    }
break;

总结一下，在onTouchEvent中的move中，处理scrollView的内容滚动的关键地方，同时还根据滑动的位置，去计算将要绘制的上下阴影的图形效果呢。这里要有一个地方注意的是，在scrollView的move中会根据实际滑动的距离来请求他的父容器不要拦截，但是这里我认为这样的设计有太多的风险了，因为他要求父容器的拦截计算要很精确，如果在scrollview的请求不要拦截之前已经预先拦截了，那么后续的move根本不会走到这个请求的逻辑，就凉凉了。所以嵌套scrollview写拦截逻辑，是要小心一点的.......
对了， ScrollView中关键滚动内容的地方在overScrollBy这里，还没有说明呢:

----view.java


protected boolean overScrollBy(int deltaX, int deltaY,
                               int scrollX, int scrollY,
                               int scrollRangeX, int scrollRangeY,
                               int maxOverScrollX, int maxOverScrollY,
                               boolean isTouchEvent) {
    //获取scrollView的模式:三种模式啦，ｉf_content, none, alaways;
    final int overScrollMode = mOverScrollMode;
    
    .......
        
        //computeVerticalScrollRange, 高度呢，说白了child的实际高度;
        //computeVerticalScrollExtent---就是scrollView的高度
    final boolean canScrollVertical =
        computeVerticalScrollRange() > computeVerticalScrollExtent();
   
    final boolean overScrollVertical = overScrollMode == OVER_SCROLL_ALWAYS ||
        (overScrollMode == OVER_SCROLL_IF_CONTENT_SCROLLS && canScrollVertical);
   .......
       
   //新的滚动距离，等于老的＋这次move移动的距离
    int newScrollY = scrollY + deltaY;
    if (!overScrollVertical) {
        maxOverScrollY = 0;
    }

    // maxOverScrollY一般都是0,这里没看头，掠过
    final int left = -maxOverScrollX;
    final int right = maxOverScrollX + scrollRangeX;
    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;
    }

    //这里计算新的滚动距离后就调用scrollView的滚动方法，他重写了这个方法,
    onOverScrolled(newScrollX, newScrollY, clampedX, clampedY);
  //表示滚动到了边界啦......
    return clampedX || clampedY;
}

总结一下, 这个方法之view中的方法，主要思路是根据scollView当次move的距离，进行一次距离纠正让他不会划出我们子child提供的最大范围, 没什么东西了.

接着再看上面的onOverScrolled方法:


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);
    }

    //唤醒scrollbar
    awakenScrollBars();
}

从上面可以看到，如果当次没滚动完，是不会滚动的，要等到下次再滚动哦.如果可以滚动就调用View.scrollTo去滑动内容。
好了，继续把onTouchEvent中的事件阅读完:

 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)) {
            //滑行
            flingWithNestedDispatch(-initialVelocity);
        } else if (mScroller.springBack(mScrollX, mScrollY, 0, 0, 0,
                                        getScrollRange())) {
            postInvalidateOnAnimation();
        }
      //清除手指活动目标
        mActivePointerId = INVALID_POINTER;
        endDrag();
    }
    break;
    case MotionEvent.ACTION_CANCEL:
    if (mIsBeingDragged && getChildCount() > 0) {
        if (mScroller.springBack(mScrollX, mScrollY, 0, 0, 0, getScrollRange())) {
            postInvalidateOnAnimation();
        }
        //清除手指活动目标
        mActivePointerId = INVALID_POINTER;
        endDrag();
    }
    break;
    case MotionEvent.ACTION_POINTER_DOWN: {//副手指手指放下
        final int index = ev.getActionIndex();
        mLastMotionY = (int) ev.getY(index);
        //将副手指替换成主手指
        mActivePointerId = ev.getPointerId(index);
        break;
    }
    case MotionEvent.ACTION_POINTER_UP://副手指抬起
  //将原来的第一个手指替换成现在的主手指，或者抬起的是第一个手指，那么什么都不用做了。
    onSecondaryPointerUp(ev);
    mLastMotionY = (int) ev.getY(ev.findPointerIndex(mActivePointerId));
    break;

总结一下，当主手指抬起来的时候，判断一下要不要去滑行一下。除此之外，这里有多手指操作的判断，他的逻辑是，当第二个手指放下的时候，会将前面记录主手指的第一个手指换成第二个，然后后面的滑动第一个手指就没有效果，滑动第二个才有效果，因为计算只是跟踪主手指。现在第一个手指是副手指，第二个手指是主手指了。还有抬起的时候，如果抬起的是第二个手指即主手指抬起, 那么还要将前面的第一个手指又还原成主手指，后面滑动又跟踪他了，如果抬起的是原来的第一个手指即非主手指，那么就不做什么了....这种多指操作，也是android系统的标准行为。
看看onSecondaryPointerUp的实现吧....

private void onSecondaryPointerUp(MotionEvent ev) {
    final int pointerIndex = (ev.getAction() & MotionEvent.ACTION_POINTER_INDEX_MASK) >>
        MotionEvent.ACTION_POINTER_INDEX_SHIFT;
    final int pointerId = ev.getPointerId(pointerIndex);
    //如果当前抬起的是主手指，就要进行主手指的重新定位，如果不是那么就啥都不做.....
    if (pointerId == mActivePointerId) {
        // This was our active pointer going up. Choose a new
        // active pointer and adjust accordingly.
        // TODO: Make this decision more intelligent.
        final int newPointerIndex = pointerIndex == 0 ? 1 : 0;
        mLastMotionY = (int) ev.getY(newPointerIndex);
        mActivePointerId = ev.getPointerId(newPointerIndex);
        if (mVelocityTracker != null) {
            mVelocityTracker.clear();
        }
    }
}

3. 结束

好了，原来ScollView的滚动还是利用View标准的scrollTo去滚动的呀，对ScrollView的理解就到这里了吧，说实话感觉代码有点恶心，代码不算太多，但是功能不是特别明确，对应用开发可造成的隐性的问题不少。