android ScrollView实现原理，求助

Posted 2023-05-15

能解释下ScrollView滚动显示的原理吗？就比如说你的ScollView有LinearLayout然后LinearLayout内有100个Button（id=1,2,3,4......），创建初，屏幕显示id=1~10的Button，当你向下拖的时候如何重新绘制控件，显示id=3~12的Button，我看ScrollView的源代码，并没有找到这部分功能，不知道能否解释下到底是怎么实现的，在哪里实现的？多谢！！

视图的滚动过程，其实是在不断修改原点坐标。当手指触摸后，ScrollView会暂时拦截触摸事件，使用一个计时器。
假如在计时器到点后没有发生手指移动事件，那么ScrollView发送tracking events到被点击的subView；若是在计时器到点后发生了移动事件，那么ScrollView取消tracking自己促发滚动。
其子类可以重载
touchesShouldBegin: withEvent: inContentView: 决定自己是否接收touch事件。
pagingEnabled: 当值是YES会自动滚动到subView的边界，默认是NO。
touchesShouldCancelInContentView: 开始发送tracking messages消息给subView的时候会调用这个方法。以决定是否发送tracking messages消息到subView。假如返回NO，发送。YES则不发送。若是canCancelContentTouches属性是NO，则不调用这个方法来影响如何处理滚动手势。
ScrollView还可处理缩放和平移手势，要实现这必须实现委托viewForZoomingInScrollView:和scrollViewDidEndZooming: withView: atScale:两个方法。另外maximumZoomScale和minimumZoomScale两个属性要不一样。
常用属性介绍
maximumZoomScale 能放大的最大倍数，是浮点数。
minimumZoomScale 能缩小的最小倍数，是浮点数。
pagingEnabled 是否自动滚动到subView边界
scrollEnabled 是否可以滚动
contentSize 里面内容的大小，即可以滚动的大小，默认是0，没有滚动效果
showsHorizontalScrollIndicator 滚动时是否显示水平滚动条
showsVerticalScrollIndicator 滚动时是否显示垂直滚动条
bounces 默认是YES，就是滚动超过边界会反弹，即有反弹回来的效果。若是NO，则滚动到达边界会立刻停止
bouncesZoom 与bounces类似，只是反映在缩放效果上。
directionalLockEnabled 默认是NO，可以在垂直和水平方向同时运动。当值是YES时，视哪个方向开始则锁定另外一个方向的滚动。
indicatorStyle 滚动条的样式。总共3色：默认、黑、白
scrollIndicatorInsets 设置滚动条位置
tracking 当touch后还没有拖动的时候是YES，否则NO
zoomBouncing 当内容放大到最大或者最小的时候值是YES，否则NO
zooming 当正在缩放的时候值是YES，否则NO
decelerating 当滚动后，手指放开但还在继续滚动中。此时是YES，其它时候都是NO
decelerationRate 设置手指放开后的减速率
基本使用方法：
初始化：一般的控件初始化都是可以用alloc和init来初始化的。
UIScrollView *sv = [[UIScrollView alloc] initWithFrame:CGRectMake(0.0,0.0,self.view.frame.size.width, 400)];
关于控件添加与初始化，建议都采用代码调用合适的初始化方法来操作，虽然IB布局能够节省时间，但不能哪过很好了解整个代码执行流程。
委托方法：UIScrollView也要指定委托对象，该委托对象的控制器同样也要遵循UIScrollViewDelegate协议，实现其相应的代理方法。
scrollViewDidScroll:
scrollViewWillBeginDragging:
scrollViewDidEndDragging:
scrollViewDidEndDecelerating:

属性作用CGPoint contentOffSet监控目前滚动的位置CGSize contentSize滚动范围的大小UIEdgeInsets contentInset视图在scrollView中的位置id<UIScrollerViewDelegate>
delegate设置协议BOOL directionalLockEnabled指定控件是否只能在一个方向上滚动BOOL bounces控制控件遇到边框是否反弹BOOL alwaysBounceVertical控制垂直方向遇到边框是否反弹BOOL alwaysBounceHorizontal控制水平方向遇到边框是否反弹BOOL pagingEnabled控制控件是否整页翻动BOOL scrollEnabled控制控件是否能滚动BOOL showsHorizontalScrollIndicator控制是否显示水平方向的滚动条BOOL
showsVerticalScrollIndicator控制是否显示垂直方向的滚动条UIEdgeInsets scrollIndicatorInsets指定滚动条在scrollerView中的位置UIScrollViewIndicatorStyle
indicatorStyle设定滚动条的样式float decelerationRate改变scrollerView的减速点位置BOOL tracking监控当前目标是否正在被跟踪BOOL dragging监控当前目标是否正在被拖拽BOOL decelerating监控当前目标是否正在减速BOOL delaysContentTouches控制视图是否延时调用开始滚动的方法BOOL canCancelContentTouches控制控件是否接触取消touch的事件float minimumZoomScale缩小的最小比例float maximumZoomScale放大的最大比例float zoomScale设置变化比例BOOL bouncesZoom控制缩放的时候是否会反弹BOOL zooming判断控件的大小是否正在改变BOOL zoomBouncing判断是否正在进行缩放反弹BOOL scrollsToTop控制控件滚动到顶部

这里把UIScrollView的几个要点总结下：
从你的手指touch屏幕开始，scrollView开始一个timer，如果：
1. 150ms内如果你的手指没有任何动作，消息就会传给subView。
2. 150ms内手指有明显的滑动（一个swipe动作），scrollView就会滚动，消息不会传给subView，这里就是产生问题二的原因。
3. 150ms内手指没有滑动，scrollView将消息传给subView，但是之后手指开始滑动，scrollView传送touchesCancelled消息给subView，然后开始滚动。
观察下tableView的情况，你先按住一个cell，cell开始高亮，手不要放开，开始滑动，tableView开始滚动，高亮取消。

delaysContentTouches的作用：
这个标志默认是YES，使用上面的150ms的timer，如果设置为NO，touch事件立即传递给subView，不会有150ms的等待。

cancelsTouches的作用：
这个标准默认为YES，如果设置为NO，这消息一旦传递给subView，这scroll事件不会再发生。 参考技术A 1. scrollview使用的时候里面都要放一个linearlayout，这是第一步。
2. 我们先不管linearlayout里面有什么，就假设有100个button，这时候linearlayout的显示长度肯定大于屏幕尺寸，这是第二步。
3. 这里就是重点了，scrollview通过实现手势监听器接口响应滑动事件，接收到滑动消息以后通过改变内部的linearlayout的margin参数来改变显示。重点就是改变其内部的linearlayout的layoutparams参数实现移动linearlayout。方法是：首先调用getLayoutParams获取linearlayout的布局参数，然后强转为MarginLayoutparams类型，然后改变它的marginTop即可实现上下滑动效果。

参考，如果感兴趣的话可以百度下滑动菜单，我是看过那个代码以后产生的灵感。
希望能够帮到你！ 参考技术B

参考scrollView的 onTouchEvent 的。。

从 scrollBy－－> invalidate();----->  p.invalidateChild(this, r);

最终通过调用 scrollView的 父View来重绘 scrollView的特定范围(r)实现的。

450             case MotionEvent.ACTION_DOWN:
451                 /*
452                 * If being flinged and user touches, stop the fling. isFinished
453                 * will be false if being flinged.
454                 */
455                 if (!mScroller.isFinished()) 
456                     mScroller.abortAnimation();
457                 
458 
459                 // Remember where the motion event started
460                 // 记录开始的点击坐标
                    mLastMotionY = y;
461                 break;
462             case MotionEvent.ACTION_MOVE:
463                 // Scroll to follow the motion event
                 // 手指移动时的点击坐标
464                 final int deltaY = (int) (mLastMotionY - y);
                 // 更新点击坐标
                     mLastMotionY = y;
466 
                    // 往下滚动
467                 if (deltaY < 0) 
468                     if (mScrollY > 0) 
469                         scrollBy(0, deltaY);
470                     
                    // 往上滚动
471                  else if (deltaY > 0) 
472                     final int bottomEdge = getHeight() - mPaddingBottom;
473                     final int availableToScroll = getChildAt(0).getBottom() - mScrollY - bottomEdge;
474                     if (availableToScroll > 0) 
475                         scrollBy(0, Math.min(availableToScroll, deltaY));
476                     
477                 
478                 break;

追问

如果触摸点中有子控件的话，ScrollView是不会调用onTouchEvent（）的，只调用了onIntercepEvent（），但是onIntercepEvent（）并没有调用任何方法。。

追答

你参考一下 触摸消息派发
http://androidfanlf.blogspot.jp/2013/06/android-13-view.html.

另外 onInterceptTouchEvent 事件是确定是否打断当前view的 onTouchEvent。

所有的触摸事件，都是从顶层的view一层一层派发下来的。 所以，父控件肯定比子控件先接触到
onTouchEvent。

下面有android各个版本的源代码。
http://grepcode.com/project/repository.grepcode.com/java/ext/com.google.android/android/。
开源的东西，你可以设置断点一点一点进去看一下就明白了。

本回答被提问者采纳

Android 自定义ScrollView 支持惯性滑动，惯性回弹效果。支持上拉加载更多

先讲下原理：

ScrollView的子View 主要分为3部分：head头部，滚动内容，fooder底部

我们实现惯性滑动，以及回弹，都是靠超过head或者fooder 就重新滚动到  ，内容的顶部或者底部。

之前看了Pulltorefresh 他是通过不断改变 head或者 fooder的 pading 值来实现 上拉或者 下拉的效果。感觉有点不流畅，而且层次嵌套得比较多。当然他的好处是扩展性好。

因工作需求，需要层次嵌套少，对性能要求非常高。因此重新自定义了ViewGroup实现。

直接上代码：

[java] view plain copy

1. package com.example.administrator.customscrollview;  
2.   
3. import android.content.Context;  
4. import android.content.res.TypedArray;  
5. import android.util.AttributeSet;  
6. import android.util.Log;  
7. import android.view.Gravity;  
8. import android.view.MotionEvent;  
9. import android.view.VelocityTracker;  
10. import android.view.View;  
11. import android.view.ViewConfiguration;  
12. import android.view.ViewGroup;  
13. import android.widget.OverScroller;  
14.   
15. /** 
16.  * 自定义 pulltorefresh Layout 
17.  * TODO: ferris 2015年9月11日 18:52:40 
18.  */  
19. public class PullTorefreshScrollView extends ViewGroup {  
20.   
21.     private FoodeLayout fooder_layout;// top and buttom  
22.     private View top_layout;  
23.   
24.     private int desireWidth, desireHeight;  
25.     private VelocityTracker velocityTracker;  
26.     private int mPointerId;  
27.     private float x, y;  
28.     private OverScroller mScroller;  
29.     private int maxFlingVelocity, minFlingVelocity;  
30.     private int mTouchSlop;  
31.     protected Boolean isMove = false;  
32.     protected float downX = 0, downY = 0;  
33.     private int top_hight = 0;  
34.     private int scrollYButtom = 0;  
35.     private int nScrollYButtom = 0;  
36.   
37.     private int pullDownMin = 0;  
38.     private Boolean isEnablePullDown = true;  
39.   
40.     private Boolean isFirst=true;  
41.   
42.     public void setEnablePullDown(Boolean isEnablePullDown) {  
43.         this.isEnablePullDown = isEnablePullDown;  
44.     }  
45.   
46.     public PullTorefreshScrollView(Context context) {  
47.         super(context);  
48.         init(null, 0);  
49.     }  
50.   
51.     public PullTorefreshScrollView(Context context, AttributeSet attrs) {  
52.         super(context, attrs);  
53.         init(attrs, 0);  
54.     }  
55.   
56.     public PullTorefreshScrollView(Context context, AttributeSet attrs, int defStyle) {  
57.         super(context, attrs, defStyle);  
58.         init(attrs, defStyle);  
59.     }  
60.   
61.     private void init(AttributeSet attrs, int defStyle) {  
62.         // Load attributes  
63. //        final TypedArray a = getContext().obtainStyledAttributes(  
64. //                attrs, R.styleable.PullTorefreshScrollView, defStyle, 0);  
65. //  
66. //  
67. //        a.recycle();  
68.         mScroller = new OverScroller(getContext());  
69.         maxFlingVelocity = ViewConfiguration.get(getContext()).getScaledMaximumFlingVelocity();  
70.         minFlingVelocity = ViewConfiguration.get(getContext()).getScaledMinimumFlingVelocity();  
71.         mTouchSlop = ViewConfiguration.get(getContext()).getScaledTouchSlop();  
72.     }  
73.   
74.     @Override  
75.     protected void onFinishInflate() {  
76.         super.onFinishInflate();  
77.         fooder_layout = (FoodeLayout) findViewById(R.id.fooder_layout);  
78.         top_layout = findViewById(R.id.top_layout);  
79.   
80.   
81.         if (isEnablePullDown) {  
82.             fooder_layout.showFooderPull();  
83.         } else {  
84.             fooder_layout.hideFooder();  
85.         }  
86.     }  
87.   
88.   
89.     public int getScrollYTop() {  
90.         return top_hight;  
91.     }  
92.   
93.     public int getScrollYButtom() {  
94.         return scrollYButtom;  
95.     }  
96.   
97.     public int getNScrollYTop() {  
98.         return 0;  
99.     }  
100.   
101.     public int getNScrollYButtom() {  
102.         return nScrollYButtom;  
103.     }  
104.   
105.     public int measureWidth(int widthMeasureSpec) {  
106.         int result = 0;  
107.         int measureMode = MeasureSpec.getMode(widthMeasureSpec);  
108.         int width = MeasureSpec.getSize(widthMeasureSpec);  
109.         switch (measureMode) {  
110.             case MeasureSpec.AT_MOST:  
111.             case MeasureSpec.EXACTLY:  
112.                 result = width;  
113.                 break;  
114.             default:  
115.                 break;  
116.         }  
117.         return result;  
118.     }  
119.   
120.     public int measureHeight(int heightMeasureSpec) {  
121.         int result = 0;  
122.         int measureMode = MeasureSpec.getMode(heightMeasureSpec);  
123.         int height = MeasureSpec.getSize(heightMeasureSpec);  
124.         switch (measureMode) {  
125.             case MeasureSpec.AT_MOST:  
126.             case MeasureSpec.EXACTLY:  
127.                 result = height;  
128.                 break;  
129.             default:  
130.                 break;  
131.         }  
132.         return result;  
133.     }  
134.   
135.     @Override  
136.     protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {  
137.         // 计算所有child view 要占用的空间  
138.         int width = measureWidth(widthMeasureSpec);  
139.         int height = measureHeight(heightMeasureSpec);  
140.   
141.         desireWidth = 0;  
142.         desireHeight = 0;  
143.         int count = getChildCount();  
144.         for (int i = 0; i < count; ++i) {  
145.             View v = getChildAt(i);  
146.   
147.             if (v.getVisibility() != View.GONE) {  
148.   
149.                 LayoutParams lp = (LayoutParams) v.getLayoutParams();  
150.                 measureChildWithMargins(v, widthMeasureSpec, 0,  
151.                         heightMeasureSpec, 0);  
152.   
153.                 //只是在这里增加了垂直或者水平方向的判断  
154.                 if (v.getId() == R.id.top_layout) {  
155.                     top_hight = v.getMeasuredHeight();  
156.                 }  
157.                 desireWidth = Math.max(desireWidth, v.getMeasuredWidth()  
158.                         + lp.leftMargin + lp.rightMargin);  
159.                 desireHeight += v.getMeasuredHeight() + lp.topMargin  
160.                         + lp.bottomMargin;  
161.   
162.             }  
163.         }  
164.   
165.         // count with padding  
166.         desireWidth += getPaddingLeft() + getPaddingRight();  
167.         desireHeight += getPaddingTop() + getPaddingBottom();  
168.   
169.         // see if the size is big enough  
170.         desireWidth = Math.max(desireWidth, getSuggestedMinimumWidth());  
171.         desireHeight = Math.max(desireHeight, getSuggestedMinimumHeight());  
172.   
173.   
174.         //处理内容比较少的时候，就添加一定的高度  
175.         int scrollHight = height + top_hight * 2;  
176.         if (scrollHight > desireWidth) {  
177.             int offset = scrollHight - desireHeight;  
178.             View view = new View(getContext());  
179.             view.setBackgroundResource(R.color.top_layout_color);  
180.             LayoutParams lp = new LayoutParams(LayoutParams.MATCH_PARENT, offset);  
181.             addView(view, getChildCount() - 1, lp);  
182.             desireWidth = scrollHight;  
183.         }  
184.   
185.   
186.         setMeasuredDimension(resolveSize(desireWidth, widthMeasureSpec),  
187.                 resolveSize(desireHeight, heightMeasureSpec));  
188.   
189.         scrollYButtom = desireHeight - getMeasuredHeight() - top_hight;  
190.         nScrollYButtom = desireHeight - getMeasuredHeight();  
191.         //如果上啦拖出一半的高度，就代表将要执行上啦  
192.         pullDownMin = nScrollYButtom - top_hight / 2;  
193.         if(isFirst){  
194.             scrollTo(0, top_hight);  
195.             isFirst=false;  
196.         }  
197.   
198.     }  
199.   
200.     @Override  
201.     protected void onLayout(boolean changed, int l, int t, int r, int b) {  
202.         final int parentLeft = getPaddingLeft();  
203.         final int parentRight = r - l - getPaddingRight();  
204.         final int parentTop = getPaddingTop();  
205.         final int parentBottom = b - t - getPaddingBottom();  
206.   
207.         if (BuildConfig.DEBUG)  
208.             Log.d("onlayout", "parentleft: " + parentLeft + "   parenttop: "  
209.                     + parentTop + "   parentright: " + parentRight  
210.                     + "   parentbottom: " + parentBottom);  
211.   
212.         int left = parentLeft;  
213.         int top = parentTop;  
214.   
215.         int count = getChildCount();  
216.         for (int i = 0; i < count; ++i) {  
217.             View v = getChildAt(i);  
218.             if (v.getVisibility() != View.GONE) {  
219.                 LayoutParams lp = (LayoutParams) v.getLayoutParams();  
220.                 final int childWidth = v.getMeasuredWidth();  
221.                 final int childHeight = v.getMeasuredHeight();  
222.                 final int gravity = lp.gravity;  
223.                 final int horizontalGravity = gravity  
224.                         & Gravity.HORIZONTAL_GRAVITY_MASK;  
225.                 final int verticalGravity = gravity  
226.                         & Gravity.VERTICAL_GRAVITY_MASK;  
227.   
228.   
229.                 // layout vertical, and only consider horizontal gravity  
230.   
231.                 left = parentLeft;  
232.                 top += lp.topMargin;  
233.                 switch (horizontalGravity) {  
234.                     case Gravity.LEFT:  
235.                         break;  
236.                     case Gravity.CENTER_HORIZONTAL:  
237.                         left = parentLeft  
238.                                 + (parentRight - parentLeft - childWidth) / 2  
239.                                 + lp.leftMargin - lp.rightMargin;  
240.                         break;  
241.                     case Gravity.RIGHT:  
242.                         left = parentRight - childWidth - lp.rightMargin;  
243.                         break;  
244.                 }  
245.                 v.layout(left, top, left + childWidth, top + childHeight);  
246.                 top += childHeight + lp.bottomMargin;  
247.             }  
248.   
249.         }  
250.   
251.   
252.     }  
253.   
254.     @Override  
255.     protected android.view.ViewGroup.LayoutParams generateDefaultLayoutParams() {  
256.         return new LayoutParams(ViewGroup.LayoutParams.MATCH_PARENT,  
257.                 ViewGroup.LayoutParams.MATCH_PARENT);  
258.     }  
259.   
260.     @Override  
261.     public android.view.ViewGroup.LayoutParams generateLayoutParams(  
262.             AttributeSet attrs) {  
263.         return new LayoutParams(getContext(), attrs);  
264.     }  
265.   
266.     @Override  
267.     protected android.view.ViewGroup.LayoutParams generateLayoutParams(  
268.             android.view.ViewGroup.LayoutParams p) {  
269.         return new LayoutParams(p);  
270.     }  
271.   
272.     public static class LayoutParams extends MarginLayoutParams {  
273.         public int gravity = -1;  
274.   
275.         public LayoutParams(Context c, AttributeSet attrs) {  
276.             super(c, attrs);  
277.   
278.             TypedArray ta = c.obtainStyledAttributes(attrs,  
279.                     R.styleable.SlideGroup);  
280.   
281.             gravity = ta.getInt(R.styleable.SlideGroup_layout_gravity, -1);  
282.   
283.             ta.recycle();  
284.         }  
285.   
286.         public LayoutParams(int width, int height) {  
287.             this(width, height, -1);  
288.         }  
289.   
290.         public LayoutParams(int width, int height, int gravity) {  
291.             super(width, height);  
292.             this.gravity = gravity;  
293.         }  
294.   
295.         public LayoutParams(android.view.ViewGroup.LayoutParams source) {  
296.             super(source);  
297.         }  
298.   
299.         public LayoutParams(MarginLayoutParams source) {  
300.             super(source);  
301.         }  
302.     }  
303.   
304.   
305.     /** 
306.      * onInterceptTouchEvent()用来询问是否要拦截处理。 onTouchEvent()是用来进行处理。 
307.      * <p/> 
308.      * 例如：parentLayout----childLayout----childView 事件的分发流程： 
309.      * parentLayout::onInterceptTouchEvent()---false?---> 
310.      * childLayout::onInterceptTouchEvent()---false?---> 
311.      * childView::onTouchEvent()---false?---> 
312.      * childLayout::onTouchEvent()---false?---> parentLayout::onTouchEvent() 
313.      * <p/> 
314.      * <p/> 
315.      * <p/> 
316.      * 如果onInterceptTouchEvent()返回false，且分发的子View的onTouchEvent()中返回true， 
317.      * 那么onInterceptTouchEvent()将收到所有的后续事件。 
318.      * <p/> 
319.      * 如果onInterceptTouchEvent()返回true，原本的target将收到ACTION_CANCEL，该事件 
320.      * 将会发送给我们自己的onTouchEvent()。 
321.      */  
322.     @Override  
323.     public boolean onInterceptTouchEvent(MotionEvent ev) {  
324.         final int action = ev.getActionMasked();  
325.         if (BuildConfig.DEBUG)  
326.             Log.d("onInterceptTouchEvent", "action: " + action);  
327.   
328.         if (action == MotionEvent.ACTION_DOWN && ev.getEdgeFlags() != 0) {  
329.             // 该事件可能不是我们的  
330.             return false;  
331.         }  
332.   
333.         boolean isIntercept = false;  
334.         switch (action) {  
335.             case MotionEvent.ACTION_DOWN:  
336.                 // 如果动画还未结束，则将此事件交给onTouchEvet()处理，  
337.                 // 否则，先分发给子View  
338.                 isIntercept = !mScroller.isFinished();  
339.                 // 如果此时不拦截ACTION_DOWN时间，应该记录下触摸地址及手指id，当我们决定拦截ACTION_MOVE的event时，  
340.                 // 将会需要这些初始信息（因为我们的onTouchEvent将可能接收不到ACTION_DOWN事件）  
341.                 mPointerId = ev.getPointerId(0);  
342. //          if (!isIntercept) {  
343.                 downX = x = ev.getX();  
344.                 downY = y = ev.getY();  
345. //          }  
346.                 break;  
347.             case MotionEvent.ACTION_MOVE:  
348.                 int pointerIndex = ev.findPointerIndex(mPointerId);  
349.                 if (BuildConfig.DEBUG)  
350.                     Log.d("onInterceptTouchEvent", "pointerIndex: " + pointerIndex  
351.                             + ", pointerId: " + mPointerId);  
352.                 float mx = ev.getX(pointerIndex);  
353.                 float my = ev.getY(pointerIndex);  
354.   
355.                 if (BuildConfig.DEBUG)  
356.                     Log.d("onInterceptTouchEvent", "action_move [touchSlop: "  
357.                             + mTouchSlop + ", deltaX: " + (x - mx) + ", deltaY: "  
358.                             + (y - my) + "]");  
359.   
360.                 // 根据方向进行拦截，（其实这样，如果我们的方向是水平的，里面有一个ScrollView，那么我们是支持嵌套的）  
361.   
362.                 if (Math.abs(y - my) >= mTouchSlop) {  
363.                     isIntercept = true;  
364.                 }  
365.   
366.   
367.                 //如果不拦截的话，我们不会更新位置，这样可以通过累积小的移动距离来判断是否达到可以认为是Move的阈值。  
368.                 //这里当产生拦截的话，会更新位置（这样相当于损失了mTouchSlop的移动距离，如果不更新，可能会有一点点跳的感觉）  
369.                 if (isIntercept) {  
370.                     x = mx;  
371.                     y = my;  
372.                 }  
373.                 break;  
374.             case MotionEvent.ACTION_CANCEL:  
375.             case MotionEvent.ACTION_UP:  
376.                 // 这是触摸的最后一个事件，无论如何都不会拦截  
377.                 if (velocityTracker != null) {  
378.                     velocityTracker.recycle();  
379.                     velocityTracker = null;  
380.                 }  
381.                 break;  
382.             case MotionEvent.ACTION_POINTER_UP:  
383.                 solvePointerUp(ev);  
384.   
385.                 break;  
386.         }  
387.         return isIntercept;  
388.     }  
389.   
390.     private void solvePointerUp(MotionEvent event) {  
391.         // 获取离开屏幕的手指的索引  
392.         int pointerIndexLeave = event.getActionIndex();  
393.         int pointerIdLeave = event.getPointerId(pointerIndexLeave);  
394.         if (mPointerId == pointerIdLeave) {  
395.             // 离开屏幕的正是目前的有效手指，此处需要重新调整，并且需要重置VelocityTracker  
396.             int reIndex = pointerIndexLeave == 0 ? 1 : 0;  
397.             mPointerId = event.getPointerId(reIndex);  
398.             // 调整触摸位置，防止出现跳动  
399.             x = event.getX(reIndex);  
400.             y = event.getY(reIndex);  
401.             if (velocityTracker != null)  
402.                 velocityTracker.clear();  
403.         }  
404.     }  
405.   
406.     @Override  
407.     public boolean onTouchEvent(MotionEvent event) {  
408.   
409.         final int action = event.getActionMasked();  
410.   
411.         if (velocityTracker == null) {  
412.             velocityTracker = VelocityTracker.obtain();  
413.         }  
414.         velocityTracker.addMovement(event);  
415.   
416.         switch (action) {  
417.             case MotionEvent.ACTION_DOWN:  
418.                 // 获取索引为0的手指id  
419.   
420.   
421.                 isMove = false;  
422.                 mPointerId = event.getPointerId(0);  
423.                 x = event.getX();  
424.                 y = event.getY();  
425.                 if (!mScroller.isFinished())  
426.                     mScroller.abortAnimation();  
427.                 break;  
428.             case MotionEvent.ACTION_MOVE:  
429.                 isMove = true;  
430.                 // 获取当前手指id所对应的索引，虽然在ACTION_DOWN的时候，我们默认选取索引为0  
431.                 // 的手指，但当有第二个手指触摸，并且先前有效的手指up之后，我们会调整有效手指  
432.   
433.                 // 屏幕上可能有多个手指，我们需要保证使用的是同一个手指的移动轨迹，  
434.                 // 因此此处不能使用event.getActionIndex()来获得索引  
435.                 final int pointerIndex = event.findPointerIndex(mPointerId);  
436.                 float mx = event.getX(pointerIndex);  
437.                 float my = event.getY(pointerIndex);  
438.   
439.                 moveBy((int) (x - mx), (int) (y - my));  
440.   
441.                 x = mx;  
442.                 y = my;  
443.                 break;  
444.             case MotionEvent.ACTION_UP:  
445.                 isMove = false;  
446.                 velocityTracker.computeCurrentVelocity(1000, maxFlingVelocity);  
447.                 float velocityX = velocityTracker.getXVelocity(mPointerId);  
448.                 float velocityY = velocityTracker.getYVelocity(mPointerId);  
449.   
450.                 completeMove(-velocityX, -velocityY);  
451.                 if (velocityTracker != null) {  
452.                     velocityTracker.recycle();  
453.                     velocityTracker = null;  
454.                 }  
455.                 break;  
456.   
457.             case MotionEvent.ACTION_POINTER_UP:  
458.                 // 获取离开屏幕的手指的索引  
459.                 isMove = false;  
460.                 int pointerIndexLeave = event.getActionIndex();  
461.                 int pointerIdLeave = event.getPointerId(pointerIndexLeave);  
462.                 if (mPointerId == pointerIdLeave) {  
463.                     // 离开屏幕的正是目前的有效手指，此处需要重新调整，并且需要重置VelocityTracker  
464.                     int reIndex = pointerIndexLeave == 0 ? 1 : 0;  
465.                     mPointerId = event.getPointerId(reIndex);  
466.                     // 调整触摸位置，防止出现跳动  
467.                     x = event.getX(reIndex);  
468.                     y = event.getY(reIndex);  
469.                     if (velocityTracker != null)  
470.                         velocityTracker.clear();  
471.                 }  
472.                 break;  
473.             case MotionEvent.ACTION_CANCEL:  
474.                 isMove = false;  
475.                 break;  
476.         }  
477.         return true;  
478.     }  
479.   
480.     private Boolean isPull = false;  
481.   
482.     //此处的moveBy是根据水平或是垂直排放的方向，  
483. //来选择是水平移动还是垂直移动  
484.     public void moveBy(int deltaX, int deltaY) {  
485.         if (BuildConfig.DEBUG)  
486.             Log.d("moveBy", "deltaX: " + deltaX + "    deltaY: " + deltaY);  
487.         if (Math.abs(deltaY) >= Math.abs(deltaX)) {  
488.             int mScrollY = getScrollY();  
489.             if (mScrollY <= 0) {  
490.                 scrollTo(0, 0);  
491.             } else if (mScrollY >= getNScrollYButtom()) {  
492.                 scrollTo(0, getNScrollYButtom());  
493.   
494.   
495.             } else {  
496.                 scrollBy(0, deltaY);  
497.             }  
498.   
499.             if (isEnablePullDown && deltaY > 0 && mScrollY >= pullDownMin) {  
500.                 isPull = true;  
501.                 Log.d("onlayout", "isPull: true");  
502.             }  
503.         }  
504.   
505.   
506.     }  
507.   
508.     private void completeMove(float velocityX, float velocityY) {  
509.   
510.         int mScrollY = getScrollY();  
511.         int maxY = getScrollYButtom();  
512.         int minY = getScrollYTop();  
513.   
514.   
515.         if (mScrollY >= maxY) {//如果滚动，超过了 下边界，就回弹到下边界  
516.   
517.             if (isPull) {//滚动到最底部  
518.                 mScroller.startScroll(0, mScrollY, 0, getNScrollYButtom() - mScrollY, 300);  
519.                 invalidate();  
520.   
521.                 //显示雷达  
522.                 fooder_layout.showFooderRadar();  
523.                 if (pullDownListem != null) {  
524.                     pullDownListem.onPullDown();  
525.                 }  
526.                 Log.d("onlayout", "isPull: true 滚动到最底部，显示出雷达");  
527.   
528.             } else {  
529.                 mScroller.startScroll(0, mScrollY, 0, maxY - mScrollY);  
530.                 invalidate();  
531.                 Log.d("onlayout", "isPull: true");  
532.             }  
533.   
534.         } else if (mScrollY <= minY) {//如果滚动，超过了上边界，就回弹到上边界  
535.             // 超出了上边界，弹回  
536.             mScroller.startScroll(0, mScrollY, 0, minY - mScrollY);  
537.             invalidate();  
538.         } else if (Math.abs(velocityY) >= minFlingVelocity && maxY > 0) {//大于1页的时候  
539. //            mScroller.fling(0, mScrollY, 0, (int) (velocityY * 1.2f), 0, 0, minY, maxY);  
540.             mScroller.fling(0, mScrollY, 0, (int) (velocityY * 2f), 0, 0, getNScrollYTop(), getNScrollYButtom());  
541.             invalidate();  
542.         }  
543.   
544.   
545.     }  
546.   
547.   
548.     public void ifNeedScrollBack() {  
549.         int mScrollY = getScrollY();  
550.         int maxY = getScrollYButtom();  
551.         int minY = getScrollYTop();  
552.         if (mScrollY > maxY) {  
553.             // 超出了下边界，弹回  
554.             mScroller.startScroll(0, mScrollY, 0, maxY - mScrollY);  
555.   
556.             invalidate();  
557.   
558.         } else if (mScrollY < minY) {  
559.             // 超出了上边界，弹回  
560.             mScroller.startScroll(0, mScrollY, 0, minY - mScrollY);  
561.             invalidate();  
562.         }  
563.     }  
564.   
565.     @Override  
566.     protected void onScrollChanged(int l, int t, int oldl, int oldt) {  
567.         super.onScrollChanged(l, t, oldl, oldt);  
568.     }  
569.   
570.     @Override  
571.     public void computeScroll() {  
572.         if (mScroller.computeScrollOffset()) {  
573.   
574.             scrollTo(0, mScroller.getCurrY());  
575.   
576.             postInvalidate();  
577.   
578.         } else {  
579.             Log.d("onlayout", "computeScroll,isMove:"+isMove+",isPull:"+isPull);  
580.             if (!isMove && !isPull) {  
581.                 ifNeedScrollBack();  
582.             }  
583.   
584.         }  
585.     }  
586.   
587.   
588.     public void onPullSuccess() {  
589.   
590.         soomToBack();  
591.     }  
592.   
593.     public void soomToBack() {  
594.         int mScrollY = getScrollY();  
595.         int maxY = getScrollYButtom();  
596.         Log.d("onlayout", "soomToBack: (maxY - mScrollY)="+(maxY - mScrollY)+"，maxY="+maxY+",mScrollY="+mScrollY);  
597.         // 超出了下边界，弹回  
598.         mScroller.startScroll(0, mScrollY, 0, maxY - mScrollY, 300);  
599.         invalidate();  
600.         postDelayed(new Runnable() {  
601.             @Override  
602.             public void run() {  
603.                 fooder_layout.showFooderPull();  
604.                 isPull = false;  
605.             }  
606.         }, 310);  
607.   
608.   
609.     }  
610.   
611.     private PullDownListem pullDownListem;  
612.   
613.     public void setPullDownListem(PullDownListem pullDownListem) {  
614.         this.pullDownListem = pullDownListem;  
615.     }  
616.   
617.     public interface PullDownListem {  
618.   
619.         public void onPullDown();  
620.   
621.     }  
622. }