欣赏
你对明天有没有美好的期待呢，它是否会如期而来呢.....
线索
- 主要的成员标记
- 核心功能与方法
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的理解就到这里了吧， 说实话感觉代码有点恶心，代码不算太多，但是功能不是特别明确，对应用开发可造成的隐性的问题不少。