http://blog.csdn.net/wangjinyu501/article/details/32339379

http://blog.csdn.net/wangjinyu501/article/details/32339379

http://blog.csdn.net/wangjinyu501/article/details/32339379

http://blog.csdn.net/wangjinyu501/article/details/32339379

Android scrollTo() scrollBy() Scroller讲解及应用

分类：Android 2014-06-19 20:26 817人阅读 评论(6) 收藏 举报 版本：1.0 日期：2014.6.17 2014.6.18 版权：© 2014 kince 转载注明出处
scrollTo() 、scrollBy()及 Scroller在视图滑动中经常使用到，比如最常见的Launcher就是用这种方式实现。为了更加明了的理解，还是去看一下源码。在View类中，scrollTo的代码如下： [html] view plain copy

1. /**
2. *Setthescrolledpositionofyourview.Thiswillcauseacallto
3. *{@link#onScrollChanged(int,int,int,int)}andtheviewwillbe
4. *invalidated.
5. *@paramxthexpositiontoscrollto
6. *@paramytheypositiontoscrollto
7. */
8. publicvoidscrollTo(intx,inty){
9. if(mScrollX!=x||mScrollY!=y){
10. intoldX=mScrollX;
11. intoldY=mScrollY;
12. mScrollX=x;
13. mScrollY=y;
14. invalidateParentCaches();
15. onScrollChanged(mScrollX,mScrollY,oldX,oldY);
16. if(!awakenScrollBars()){
17. postInvalidateOnAnimation();
18. }
19. }
20. }

在注释中说到，该方法用于设置滚动视图的位置，然后会调用onScrollChanged(int, int, int, int)方法，最后视图会被刷新。那它是如何让视图滚动的呢？首先注意到在这个方法中有两个变量：mScrollX、mScrollY。这两个变量是在View类中定义的， [html] view plain copy

1. /**
2. *Theoffset,inpixels,bywhichthecontentofthisviewisscrolled
3. *horizontally.
4. *{@hide}
5. */
6. @ViewDebug.ExportedProperty(category="scrolling")
7. protectedintmScrollX;
8. /**
9. *Theoffset,inpixels,bywhichthecontentofthisviewisscrolled
10. *vertically.
11. *{@hide}
12. */
13. @ViewDebug.ExportedProperty(category="scrolling")
14. protectedintmScrollY;

这两个变量分别是视图在水平和垂直方向的偏移量，

• mScrollX:该视图内容相当于视图起始坐标的偏移量， X轴方向
• mScrollY:该视图内容相当于视图起始坐标的偏移量， Y轴方向

分别通过getScrollX() 和getScrollY()方法获得。 我们知道Android的坐标体系是这样的： （ps：相对于父类视图的左上角坐标为坐标原点（0，0），而不是整体ViewGroup的左上角为原点。） scrollTo()方法就是将一个视图移动到指定位置，偏移量mScrollX、mScrollY就是视图初始位置的距离，默认是情况下当然是0。如果视图要发生移动，比如要移动到（x，y），首先要检查这个点的坐标是否和偏移量一样，因为scrollTo()是移动到指定的点，如果这次移动的点的坐标和上次偏移量一样，也就是说这次移动和上次移动的坐标是同一个，那么就没有必要进行移动了。这也是这个方法为什么进行if (mScrollX != x || mScrollY != y) {这样一个判断的原因。接下来再看一下scrollBy()的源码， [html] view plain copy

1. /**
2. *Movethescrolledpositionofyourview.Thiswillcauseacallto
3. *{@link#onScrollChanged(int,int,int,int)}andtheviewwillbe
4. *invalidated.
5. *@paramxtheamountofpixelstoscrollbyhorizontally
6. *@paramytheamountofpixelstoscrollbyvertically
7. */
8. publicvoidscrollBy(intx,inty){
9. scrollTo(mScrollX+x,mScrollY+y);
10. }

很简单，就是直接调用了scrollTo方法，但是从这个方法的实现机制可以看出，它是一个累加减的过程，不断的将当前视图内容继续偏移(x , y)个单位。比如第一次scrollBy(10,10)，第二次scrollBy(10,10)，那么最后的结果就相当于scrollTo（20,20）。 理解这两个方法的实现机制之后，还有一个重要的问题，就是关于移动的方向。比如一个位于原点的视图，如果调用了scrollTo（0,20）方法，如果你认为是垂直向下移动20像素就错了，其实是向上移动了20个像素。在上图中，我已经给出了一个十字坐标，正负代表坐标的正负以及相应的方向。为什么会是这样的情况呢？按坐标系的认知来说，不应该是这个结果的，所以必须研究一下究竟为何。 线索当然还是要分析源码，在scrollTo(x, y)中，x和y分别被赋值给了mScrollX和mScrollY，最后调用了postInvalidateOnAnimation()方法。之后这个方法会通知View进行重绘。所以就去看一下draw()方法的源码，因为这个方法比较长，基于篇幅就不全部列出，直说重点。先列出方法的前几行， [html] view plain copy

1. publicvoiddraw(Canvascanvas){
2. if(mClipBounds!=null){
3. canvas.clipRect(mClipBounds);
4. }
5. finalintprivateFlags=mPrivateFlags;
6. finalbooleandirtyOpaque=(privateFlags&PFLAG_DIRTY_MASK)==PFLAG_DIRTY_OPAQUE&&
7. (mAttachInfo==null||!mAttachInfo.mIgnoreDirtyState);
8. mPrivateFlags=(privateFlags&~PFLAG_DIRTY_MASK)|PFLAG_DRAWN;
10. /*
11. *Drawtraversalperformsseveraldrawingstepswhichmustbeexecuted
12. *intheappropriateorder:
13. *
14. *1.Drawthebackground
15. *2.Ifnecessary,savethecanvas'layerstoprepareforfading
16. *3.Drawview'scontent
17. *4.Drawchildren
18. *5.Ifnecessary,drawthefadingedgesandrestorelayers
19. *6.Drawdecorations(scrollbarsforinstance)
20. */
22. //Step1,drawthebackground,ifneeded
23. intsaveCount;

在注释中可以看到这个方法的步骤，第六步6就是绘制scrollbars，而scrollbars就是由于scroll引起的，所以先定位到这里。在方法的最后，看到了 [html] view plain copy

1. //Step6,drawdecorations(scrollbars)
2. onDrawScrollBars(canvas);

然后看一下onDrawScrollBars(canvas)方法，
[html] view plain copy

1. protectedfinalvoidonDrawScrollBars(Canvascanvas){
2. //scrollbarsaredrawnonlywhentheanimationisrunning
3. finalScrollabilityCachecache=mScrollCache;
4. if(cache!=null){
6. intstate=cache.state;
8. if(state==ScrollabilityCache.OFF){
9. return;
10. }
12. booleaninvalidate=false;
14. if(state==ScrollabilityCache.FADING){
15. //We'refading--getourfadeinterpolation
16. if(cache.interpolatorValues==null){
17. cache.interpolatorValues=newfloat[1];
18. }
20. float[]values=cache.interpolatorValues;
22. //Stopstheanimationifwe'redone
23. if(cache.scrollBarInterpolator.timeToValues(values)==
24. Interpolator.Result.FREEZE_END){
25. cache.state=ScrollabilityCache.OFF;
26. }else{
27. cache.scrollBar.setAlpha(Math.round(values[0]));
28. }
30. //Thiswillmakethescrollbarsinvalthemselvesafter
31. //drawing.Weonlywantthiswhenwe'refadingsothat
32. //wepreventexcessiveredraws
33. invalidate=true;
34. }else{
35. //We'rejuston--butwemayhavebeenfadingbeforeso
36. //resetalpha
37. cache.scrollBar.setAlpha(255);
38. }
41. finalintviewFlags=mViewFlags;
43. finalbooleandrawHorizontalScrollBar=
44. (viewFlags&SCROLLBARS_HORIZONTAL)==SCROLLBARS_HORIZONTAL;
45. finalbooleandrawVerticalScrollBar=
46. (viewFlags&SCROLLBARS_VERTICAL)==SCROLLBARS_VERTICAL
47. &&!isVerticalScrollBarHidden();
49. if(drawVerticalScrollBar||drawHorizontalScrollBar){
50. finalintwidth=mRight-mLeft;
51. finalintheight=mBottom-mTop;
53. finalScrollBarDrawablescrollBar=cache.scrollBar;
55. finalintscrollX=mScrollX;
56. finalintscrollY=mScrollY;
57. finalintinside=(viewFlags&SCROLLBARS_OUTSIDE_MASK)==0?~0:0;
59. intleft;
60. inttop;
61. intright;
62. intbottom;
64. if(drawHorizontalScrollBar){
65. intsize=scrollBar.getSize(false);
66. if(size<=0){
67. size=cache.scrollBarSize;
68. }
70. scrollBar.setParameters(computeHorizontalScrollRange(),
71. computeHorizontalScrollOffset(),
72. computeHorizontalScrollExtent(),false);
73. finalintverticalScrollBarGap=drawVerticalScrollBar?
74. getVerticalScrollbarWidth():0;
75. top=scrollY+height-size-(mUserPaddingBottom&inside);
76. left=scrollX+(mPaddingLeft&inside);
77. right=scrollX+width-(mUserPaddingRight&inside)-verticalScrollBarGap;
78. bottom=top+size;
79. onDrawHorizontalScrollBar(canvas,scrollBar,left,top,right,bottom);
80. if(invalidate){
81. invalidate(left,top,right,bottom);
82. }
83. }
85. if(drawVerticalScrollBar){
86. intsize=scrollBar.getSize(true);
87. if(size<=0){
88. size=cache.scrollBarSize;
89. }
91. scrollBar.setParameters(computeVerticalScrollRange(),
92. computeVerticalScrollOffset(),
93. computeVerticalScrollExtent(),true);
94. intverticalScrollbarPosition=mVerticalScrollbarPosition;
95. if(verticalScrollbarPosition==SCROLLBAR_POSITION_DEFAULT){
96. verticalScrollbarPosition=isLayoutRtl()?
97. SCROLLBAR_POSITION_LEFT:SCROLLBAR_POSITION_RIGHT;
98. }
99. switch(verticalScrollbarPosition){
100. default:
101. caseSCROLLBAR_POSITION_RIGHT:
102. left=scrollX+width-size-(mUserPaddingRight&inside);
103. break;
104. caseSCROLLBAR_POSITION_LEFT:
105. left=scrollX+(mUserPaddingLeft&inside);
106. break;
107. }
108. top=scrollY+(mPaddingTop&inside);
109. right=left+size;
110. bottom=scrollY+height-(mUserPaddingBottom&inside);
111. onDrawVerticalScrollBar(canvas,scrollBar,left,top,right,bottom);
112. if(invalidate){
113. invalidate(left,top,right,bottom);
114. }
115. }
116. }
117. }
118. }

这个方法分别绘制水平和垂直方向的ScrollBar，最后都会调用invalidate(left, top, right, bottom)方法。 [html] view plain copy

1. publicvoidinvalidate(intl,intt,intr,intb){
2. if(skipInvalidate()){
3. return;
4. }
5. if((mPrivateFlags&(PFLAG_DRAWN|PFLAG_HAS_BOUNDS))==(PFLAG_DRAWN|PFLAG_HAS_BOUNDS)||
6. (mPrivateFlags&PFLAG_DRAWING_CACHE_VALID)==PFLAG_DRAWING_CACHE_VALID||
7. (mPrivateFlags&PFLAG_INVALIDATED)!=PFLAG_INVALIDATED){
8. mPrivateFlags&=~PFLAG_DRAWING_CACHE_VALID;
9. mPrivateFlags|=PFLAG_INVALIDATED;
10. mPrivateFlags|=PFLAG_DIRTY;
11. finalViewParentp=mParent;
12. finalAttachInfoai=mAttachInfo;
13. //noinspectionPointlessBooleanExpression,ConstantConditions
14. if(!HardwareRenderer.RENDER_DIRTY_REGIONS){
15. if(p!=null&&ai!=null&&ai.mHardwareAccelerated){
16. //fast-trackforGL-enabledapplications;justinvalidatethewholehierarchy
17. //withanulldirtyrect,whichtellstheViewAncestortoredraweverything
18. p.invalidateChild(this,null);
19. return;
20. }
21. }
22. if(p!=null&&ai!=null&&l<r&&t<b){
23. finalintscrollX=mScrollX;
24. finalintscrollY=mScrollY;
25. finalRecttmpr=ai.mTmpInvalRect;
26. tmpr.set(l-scrollX,t-scrollY,r-scrollX,b-scrollY);
27. p.invalidateChild(this,tmpr);
28. }
29. }
30. }

在这个方法的最后，可以看到tmpr.set(l - scrollX, t - scrollY, r - scrollX, b - scrollY)，真相终于大白，相信也都清楚为什么会是反方向的了。也会明白当向右移动视图时候，为什么getScrollX()返回值会是负的了。下面做一个测试的demo，来练习一下这两个方法的使用。 Activity：
[html] view plain copy

1. packagecom.kince.scrolldemo;
3. importandroid.app.Activity;
4. importandroid.os.Bundle;
5. importandroid.view.View;
6. importandroid.view.View.OnClickListener;
7. importandroid.widget.Button;
8. importandroid.widget.TextView;
10. publicclassMainActivityextendsActivityimplementsOnClickListener{
12. privateButtonmButton1;
13. privateButtonmButton2;
14. privateButtonmButton3;
15. privateTextViewmTextView;
17. @Override
18. protectedvoidonCreate(BundlesavedInstanceState){
19. super.onCreate(savedInstanceState);
20. setContentView(R.layout.activity_main);
22. mTextView=(TextView)this.findViewById(R.id.tv);
24. mButton1=(Button)this.findViewById(R.id.button_scroll1);
25. mButton2=(Button)this.findViewById(R.id.button_scroll2);
26. mButton3=(Button)this.findViewById(R.id.button_scroll3);
27. mButton1.setOnClickListener(this);
28. mButton2.setOnClickListener(this);
29. mButton3.setOnClickListener(this);
30. }
32. @Override
33. publicvoidonClick(Viewv){
34. //TODOAuto-generatedmethodstub
35. switch(v.getId()){
36. caseR.id.button_scroll1:
37. mTextView.scrollTo(-10,-10);
38. break;
39. caseR.id.button_scroll2:
40. mTextView.scrollBy(-2,-2);
41. break;
42. caseR.id.button_scroll3:
43. mTextView.scrollTo(0,0);
44. break;
45. default:
46. break;
47. }
48. }
50. }

xml： [html] view plain copy

1. <LinearLayoutxmlns:android="http://schemas.android.com/apk/res/android"
2. xmlns:tools="http://schemas.android.com/tools"
3. android:layout_width="match_parent"
4. android:layout_height="match_parent"
5. android:orientation="vertical">
7. <RelativeLayout
8. android:layout_width="match_parent"
9. android:layout_height="400dp"
10. android:background="@android:color/holo_green_light">
12. <TextView
13. android:id="@+id/tv"
14. android:layout_width="wrap_content"
15. android:layout_height="wrap_content"
16. android:layout_centerInParent="true"
17. android:background="@android:color/holo_blue_dark"
18. android:textSize="20sp"
19. android:text="SCROLL"/>
20. </RelativeLayout>
22. <LinearLayout
23. android:layout_width="match_parent"
24. android:layout_height="wrap_content"
25. android:gravity="center_horizontal"
26. android:orientation="horizontal">
28. <Button
29. android:id="@+id/button_scroll1"
30. android:layout_width="wrap_content"
31. android:layout_height="wrap_content"
32. android:text="SCROLL_TO"/>
34. <Button
35. android:id="@+id/button_scroll2"
36. android:layout_width="wrap_content"
37. android:layout_height="wrap_content"
38. android:text="SCROLL_BY"/>
40. <Button
41. android:id="@+id/button_scroll3"
42. android:layout_width="wrap_content"
43. android:layout_height="wrap_content"
44. android:text="复位"/>
45. </LinearLayout>
47. </LinearLayout>

点击SCROLL_TO按钮，TxtView移动后显示如下： 然后，不断按SCROLL_BY按钮，显示如下： 可以看到，TextView逐渐向下移动，直到看不到文字（还会继续移动）。看到这样的结果，可能会与之前预想的有些出入。我之前以为TextView会在它的父类容器控件中移动，也就是图中绿黄色的区域。结果却是视图相对于自身的移动，其实还是对于这个方法包括mScrollX、mScrollY的理解不全面，回过头来再看一下 protected int mScrollX; //The offset, in pixels, by which the content of this view is scrolled 重点就是the content of this view，视图的内容的偏移量，而不是视图相对于其他容器或者视图的偏移量。也就是说，移动的是视图里面的内容，从上面的例子也可以看出，TextView的文字移动了，而背景色一直没变化，说明不是整个视图在移动。 接着，改一下代码，在xml文件中将TextView的宽高设置成填充父容器。再看一下效果， 这下看的效果就仿佛是在父容器中移动，但是其实还是TextView本身的内容在移动。那这两个方法在实际开发中是如何运用的呢？光凭上面的例子是看不出什么作用的，但是就像文章开头部分说的那样，在视图滑动的情况下，这两个方法发挥了巨大的作用。以类似Launcher左右滑屏为例， 先自定义一个View继承于ViewGroup，如下： [html] view plain copy

1. /**
2. *
3. */
4. packagecom.kince.scrolldemo;
6. importandroid.content.Context;
7. importandroid.util.AttributeSet;
8. importandroid.view.MotionEvent;
9. importandroid.view.View;
10. importandroid.view.ViewGroup;
12. /**
13. *@authorkince
14. *
15. *
16. */
17. publicclassCusScrollViewextendsViewGroup{
19. privateintlastX=0;
20. privateintcurrX=0;
21. privateintoffX=0;
23. /**
24. *@paramcontext
25. */
26. publicCusScrollView(Contextcontext){
27. this(context,null);
28. //TODOAuto-generatedconstructorstub
29. }
31. /**
32. *@paramcontext
33. *@paramattrs
34. */
35. publicCusScrollView(Contextcontext,AttributeSetattrs){
36. this(context,attrs,0);
37. //TODOAuto-generatedconstructorstub
38. }
40. /**
41. *@paramcontext
42. *@paramattrs
43. *@paramdefStyle
44. */
45. publicCusScrollView(Contextcontext,AttributeSetattrs,intdefStyle){
46. super(context,attrs,defStyle);
47. //TODOAuto-generatedconstructorstub
49. }
51. /*
52. *(non-Javadoc)
53. *
54. *@seeandroid.view.ViewGroup#onLayout(boolean,int,int,int,int)
55. */
56. @Override
57. protectedvoidonLayout(booleanchanged,intl,intt,intr,intb){
58. //TODOAuto-generatedmethodstub
60. for(inti=0;i<getChildCount();i++){
61. Viewv=getChildAt(i);
62. v.layout(0+i*getWidth(),0,getWidth()+i*getWidth(),
63. getHeight());
64. }
65. }
67. @Override
68. publicbooleanonTouchEvent(MotionEventevent){
69. //TODOAuto-generatedmethodstub
70. switch(event.getAction()){
71. caseMotionEvent.ACTION_DOWN:
72. //只考虑水平方向
73. lastX=(int)event.getX();
74. returntrue;
76. caseMotionEvent.ACTION_MOVE:
77. currX=(int)event.getX();
78. offX=currX-lastX;
79. scrollBy(-offX,0);
80. break;
82. caseMotionEvent.ACTION_UP:
83. scrollTo(0,0);
84. break;
85. }
86. invalidate();
87. returnsuper.onTouchEvent(event);
88. }
89. }

这个控件用于水平滑动里面的视图，Activity代码如下： [html] view plain copy

1. packagecom.kince.scrolldemo;
3. importandroid.app.Activity;
4. importandroid.app.ActionBar;
5. importandroid.app.Fragment;
6. importandroid.os.Bundle;
7. importandroid.view.LayoutInflater;
8. importandroid.view.Menu;
9. importandroid.view.MenuItem;
10. importandroid.view.View;
11. importandroid.view.ViewGroup;
12. importandroid.view.ViewGroup.LayoutParams;
13. importandroid.widget.ImageView;
14. importandroid.widget.ImageView.ScaleType;
15. importandroid.os.Build;
17. publicclassLauncherActivityextendsActivity{
19. privateint[]images={R.drawable.jy1,R.drawable.jy2,R.drawable.jy3,
20. R.drawable.jy4,R.drawable.jy5,};
22. privateCusScrollViewmCusScrollView;
24. @Override
25. protectedvoidonCreate(BundlesavedInstanceState){
26. super.onCreate(savedInstanceState);
27. setContentView(R.layout.activity_launcher);
29. mCusScrollView=(CusScrollView)this.findViewById(R.id.CusScrollView);
30. for(inti=0;i<images.length;i++){
31. ImageViewmImageView=newImageView(this);
32. mImageView.setScaleType(ScaleType.FIT_XY);
33. mImageView.setBackgroundResource(images[i]);
34. mImageView.setLayoutParams(newLayoutParams(
35. LayoutParams.MATCH_PARENT,LayoutParams.MATCH_PARENT));
36. mCusScrollView.addView(mImageView);
37. }
39. }
41. }

在Activity中为CusScrollView添加5个ImageView用于显示图片，xml如下： [html] view plain copy

1. <LinearLayoutxmlns:android="http://schemas.android.com/apk/res/android"
2. xmlns:tools="http://schemas.android.com/tools"
3. android:layout_width="match_parent"
4. android:layout_height="match_parent"
5. android:orientation="vertical">
7. <com.kince.scrolldemo.CusScrollView
8. android:id="@+id/CusScrollView"
9. android:layout_width="match_parent"
10. android:layout_height="match_parent">
12. </com.kince.scrolldemo.CusScrollView>
14. </LinearLayout>

这个例子对CusScrollView里面的图片进行左右滑动，在onTouchEvent(MotionEvent event)的MotionEvent.ACTION_MOVE中对图片进行移动，使用的是scrollBy()方法，因为手指每次移动都会产生差值，利用scrollBy()方法就可以跟随手指进行左右滑动。在MotionEvent.ACTION_UP事件中，也就是手指抬起时候，直接使用scrollTo()方法让视图回到初始位置。再强调一遍，注意不管是scrollBy()还是scrollTo()方法，都是对CusScrollView内容视图进行移动。效果如下：

（ps：图中女孩是我的老婆，感谢她对我工作的肯定与支持，希望她开开心心、快快乐乐）
至此，就大体完成了对scrollBy()、scrollTo()这两个方法的介绍。不过通过上面的例子，发现一个问题就是滑动速度很快，尤其是scrollTo()方法，几乎是瞬间移动到指定位置。这样倒不能说是缺点，不过在某些情况下，是希望可以缓慢的移动或者有一个明显的移动效果，就像侧滑菜单那样，仿佛有一个移动的动画。这时候Scroller闪亮登场了。 Scroller类是滚动的一个封装类，可以实现View的平滑滚动效果，还可以使用插值器先加速后减速，或者先减速后加速等等效果，而不是瞬间的移动的效果。那是如何实现带动画效果平滑移动的呢？除了Scroller这个类之外，还需要使用View类的computeScroll()方法来配合完成这个过程。看一下这个方法的源码： [html] view plain copy

1. /**
2. *CalledbyaparenttorequestthatachildupdateitsvaluesformScrollX
3. *andmScrollYifnecessary.Thiswilltypicallybedoneifthechildis
4. *animatingascrollusinga{@linkandroid.widget.ScrollerScroller}
5. *object.
6. */
7. publicvoidcomputeScroll(){
8. }

从注释中了解到当子视图使用Scroller滑动的时候会调用这个方法，之后View类的mScrollX和mScrollY的值会相应发生变化。并且在绘制View时，会在draw()过程调用该方法。可以看到这个方法是一个空的方法，因此需要子类去重写该方法来实现逻辑，那该方法在何处被触发呢？继续看看View的draw()方法，上面说到会在子视图中调用该方法，也就是说绘制子视图的时候，那么在draw()等等的第四部， [html] view plain copy

1. //Step4,drawthechildren
2. dispatchDraw(canvas);

正是绘制子视图，然后看一下这个方法， [html] view plain copy

1. /**
2. *Calledbydrawtodrawthechildviews.Thismaybeoverridden
3. *byderivedclassestogaincontroljustbeforeitschildrenaredrawn
4. *(butafteritsownviewhasbeendrawn).
5. *@paramcanvasthecanvasonwhichtodrawtheview
6. */
7. protectedvoiddispatchDraw(Canvascanvas){
9. }

也是一个空方法，但是我们知道这个方法是ViewGroup用来绘制子视图的方法，所以找到View的子类ViewGroup来看看该方法的具体实现逻辑 ，基于篇幅只贴部分代码。 [html] view plain copy

1. @Override
2. protectedvoiddispatchDraw(Canvascanvas){
3. ...
4. ...
5. ...
7. if((flags&FLAG_USE_CHILD_DRAWING_ORDER)==0){
8. for(inti=0;i<count;i++){
9. finalViewchild=children[i];
10. if((child.mViewFlags&VISIBILITY_MASK)==VISIBLE||child.getAnimation()!=null){
11. more|=drawChild(canvas,child,drawingTime);
12. }
13. }
14. }else{
15. for(inti=0;i<count;i++){
16. finalViewchild=children[getChildDrawingOrder(count,i)];
17. if((child.mViewFlags&VISIBILITY_MASK)==VISIBLE||child.getAnimation()!=null){
18. more|=drawChild(canvas,child,drawingTime);
19. }
20. }
21. }
23. //Drawanydisappearingviewsthathaveanimations
24. if(mDisappearingChildren!=null){
25. finalArrayList<View>disappearingChildren=mDisappearingChildren;
26. finalintdisappearingCount=disappearingChildren.size()-1;
27. //Gobackwards--wemaydeleteasanimationsfinish
28. for(inti=disappearingCount;i>=0;i--){
29. finalViewchild=disappearingChildren.get(i);
30. more|=drawChild(canvas,child,drawingTime);
31. }
32. }
33. ...
34. ...
35. ...
37. }
38. }

可以看到，在dispatchDraw方法中调用了drawChild(canvas, child, drawingTime)方法，再看一下其代码： [html] view plain copy

1. protectedbooleandrawChild(Canvascanvas,Viewchild,longdrawingTime){
2. ...
3. ...
4. ...
6. if(!concatMatrix&&canvas.quickReject(cl,ct,cr,cb,Canvas.EdgeType.BW)&&
7. (child.mPrivateFlags&DRAW_ANIMATION)==0){
8. returnmore;
9. }
11. child.computeScroll();
13. finalintsx=child.mScrollX;
14. finalintsy=child.mScrollY;
16. booleanscalingRequired=false;
17. Bitmapcache=null;
19. ...
20. ...
21. ...
23. }

果然，child.computeScroll()，在这里调用的。也就是ViewGroup在分发绘制自己的孩子的时候，会对其子View调用computeScroll()方法。 回过头来再看一下Scroller，还是先看一下源码（简化），
[html] view plain copy

1. publicclassScroller{
2. privateintmMode;
4. privateintmStartX;
5. privateintmStartY;
6. privateintmFinalX;
7. privateintmFinalY;
9. privateintmMinX;
10. privateintmMaxX;
11. privateintmMinY;
12. privateintmMaxY;
14. privateintmCurrX;
15. privateintmCurrY;
16. privatelongmStartTime;
17. privateintmDuration;
18. privatefloatmDurationReciprocal;
19. privatefloatmDeltaX;
20. privatefloatmDeltaY;
21. privatebooleanmFinished;
22. privateInterpolatormInterpolator;
24. privatefloatmVelocity;
25. privatefloatmCurrVelocity;
26. privateintmDistance;
28. privatefloatmFlingFriction=ViewConfiguration.getScrollFriction();
30. privatestaticfinalintDEFAULT_DURATION=250;
31. privatestaticfinalintSCROLL_MODE=0;
32. privatestaticfinalintFLING_MODE=1;
34. /**
35. *CreateaScrollerwiththedefaultdurationandinterpolator.
36. */
37. publicScroller(Contextcontext){
38. this(context,null);
39. }
41. /**
42. *CreateaScrollerwiththespecifiedinterpolator.Iftheinterpolatoris
43. *null,thedefault(viscous)interpolatorwillbeused."Flywheel"behaviorwill
44. *beineffectforappstargetingHoneycombornewer.
45. */
46. publicScroller(Contextcontext,Interpolatorinterpolator){
47. this(context,interpolator,
48. context.getApplicationInfo().targetSdkVersion>=Build.VERSION_CODES.HONEYCOMB);
49. }
51. /**
52. *CreateaScrollerwiththespecifiedinterpolator.Iftheinterpolatoris
53. *null,thedefault(viscous)interpolatorwillbeused.Specifywhetheror
54. *nottosupportprogressive"flywheel"behaviorinflinging.
55. */
56. publicScroller(Contextcontext,Interpolatorinterpolator,booleanflywheel){
57. mFinished=true;
58. mInterpolator=interpolator;
59. mPpi=context.getResources().getDisplayMetrics().density*160.0f;
60. mDeceleration=computeDeceleration(ViewConfiguration.getScrollFriction());
61. mFlywheel=flywheel;
63. mPhysicalCoeff=computeDeceleration(0.84f);//lookandfeeltuning
64. }
66. /**
67. *Callthiswhenyouwanttoknowthenewlocation.Ifitreturnstrue,
68. *theanimationisnotyetfinished.
69. */
70. publicbooleancomputeScrollOffset(){
71. if(mFinished){
72. returnfalse;
73. }
75. inttimePassed=(int)(AnimationUtils.currentAnimationTimeMillis()-mStartTime);
77. if(timePassed<mDuration){
78. switch(mMode){
79. caseSCROLL_MODE:
80. floatx=timePassed*mDurationReciprocal;
82. if(mInterpolator==null)
83. x=viscousFluid(x);
84. else
85. x=mInterpolator.getInterpolation(x);
87. mCurrX=mStartX+Math.round(x*mDeltaX);
88. mCurrY=mStartY+Math.round(x*mDeltaY);
89. break;
90. caseFLING_MODE:
91. finalfloatt=(float)timePassed/mDuration;
92. finalintindex=(int)(NB_SAMPLES*t);
93. floatdistanceCoef=1.f;
94. floatvelocityCoef=0.f;
95. if(index<NB_SAMPLES){
96. finalfloatt_inf=(float)index/NB_SAMPLES;
97. finalfloatt_sup=(float)(index+1)/NB_SAMPLES;
98. finalfloatd_inf=SPLINE_POSITION[index];
99. finalfloatd_sup=SPLINE_POSITION[index+1];
100. velocityCoef=(d_sup-d_inf)/(t_sup-t_inf);
101. distanceCoef=d_inf+(t-t_inf)*velocityCoef;
102. }
104. mCurrVelocity=velocityCoef*mDistance/mDuration*1000.0f;
106. mCurrX=mStartX+Math.round(distanceCoef*(mFinalX-mStartX));
107. //PintomMinX<=mCurrX<=mMaxX
108. mCurrX=Math.min(mCurrX,mMaxX);
109. mCurrX=Math.max(mCurrX,mMinX);
111. mCurrY=mStartY+Math.round(distanceCoef*(mFinalY-mStartY));
112. //PintomMinY<=mCurrY<=mMaxY
113. mCurrY=Math.min(mCurrY,mMaxY);
114. mCurrY=Math.max(mCurrY,mMinY);
116. if(mCurrX==mFinalX&&mCurrY==mFinalY){
117. mFinished=true;
118. }
120. break;
121. }
122. }
123. else{
124. mCurrX=mFinalX;
125. mCurrY=mFinalY;
126. mFinished=true;
127. }
128. returntrue;
129. }
131. /**
132. *Startscrollingbyprovidingastartingpointandthedistancetotravel.
133. *Thescrollwillusethedefaultvalueof250millisecondsforthe
134. *duration.
135. *
136. *@paramstartXStartinghorizontalscrolloffsetinpixels.Positive
137. *numberswillscrollthecontenttotheleft.
138. *@paramstartYStartingverticalscrolloffsetinpixels.Positivenumbers
139. *willscrollthecontentup.
140. *@paramdxHorizontaldistancetotravel.Positivenumberswillscrollthe
141. *contenttotheleft.
142. *@paramdyVerticaldistancetotravel.Positivenumberswillscrollthe
143. *contentup.
144. */
145. publicvoidstartScroll(intstartX,intstartY,intdx,intdy){
146. startScroll(startX,startY,dx,dy,DEFAULT_DURATION);
147. }
149. /**
150. *Startscrollingbyprovidingastartingpoint,thedistancetotravel,
151. *andthedurationofthescroll.
152. *
153. *@paramstartXStartinghorizontalscrolloffsetinpixels.Positive
154. *numberswillscrollthecontenttotheleft.
155. *@paramstartYStartingverticalscrolloffsetinpixels.Positivenumbers
156. *willscrollthecontentup.
157. *@paramdxHorizontaldistancetotravel.Positivenumberswillscrollthe
158. *contenttotheleft.
159. *@paramdyVerticaldistancetotravel.Positivenumberswillscrollthe
160. *contentup.
161. *@paramdurationDurationofthescrollinmilliseconds.
162. */
163. publicvoidstartScroll(intstartX,intstartY,intdx,intdy,intduration){
164. mMode=SCROLL_MODE;
165. mFinished=false;
166. mDuration=duration;
167. mStartTime=AnimationUtils.currentAnimationTimeMillis();
168. mStartX=startX;
169. mStartY=startY;
170. mFinalX=startX+dx;
171. mFinalY=startY+dy;
172. mDeltaX=dx;
173. mDeltaY=dy;
174. mDurationReciprocal=1.0f/(float)mDuration;
175. }
177. /**
178. *Startscrollingbasedonaflinggesture.Thedistancetravelledwill
179. *dependontheinitialvelocityofthefling.
180. *
181. *@paramstartXStartingpointofthescroll(X)
182. *@paramstartYStartingpointofthescroll(Y)
183. *@paramvelocityXInitialvelocityofthefling(X)measuredinpixelsper
184. *second.
185. *@paramvelocityYInitialvelocityofthefling(Y)measuredinpixelsper
186. *second
187. *@paramminXMinimumXvalue.Thescrollerwillnotscrollpastthis
188. *point.
189. *@parammaxXMaximumXvalue.Thescrollerwillnotscrollpastthis
190. *point.
191. *@paramminYMinimumYvalue.Thescrollerwillnotscrollpastthis
192. *point.
193. *@parammaxYMaximumYvalue.Thescrollerwillnotscrollpastthis
194. *point.
195. */
196. publicvoidfling(intstartX,intstartY,intvelocityX,intvelocityY,
197. intminX,intmaxX,intminY,intmaxY){
198. //Continueascrollorflinginprogress
199. if(mFlywheel&&!mFinished){
200. floatoldVel=getCurrVelocity();
202. floatdx=(float)(mFinalX-mStartX);
203. floatdy=(float)(mFinalY-mStartY);
204. floathyp=FloatMath.sqrt(dx*dx+dy*dy);
206. floatndx=dx/hyp;
207. floatndy=dy/hyp;
209. floatoldVelocityX=ndx*oldVel;
210. floatoldVelocityY=ndy*oldVel;
211. if(Math.signum(velocityX)==Math.signum(oldVelocityX)&&
212. Math.signum(velocityY)==Math.signum(oldVelocityY)){
213. velocityX+=oldVelocityX;
214. velocityY+=oldVelocityY;
215. }
216. }
218. mMode=FLING_MODE;
219. mFinished=false;
221. floatvelocity=FloatMath.sqrt(velocityX*velocityX+velocityY*velocityY);
223. mVelocity=velocity;
224. mDuration=getSplineFlingDuration(velocity);
225. mStartTime=AnimationUtils.currentAnimationTimeMillis();
226. mStartX=startX;
227. mStartY=startY;
229. floatcoeffX=velocity==0?1.0f:velocityX/velocity;
230. floatcoeffY=velocity==0?1.0f:velocityY/velocity;
232. doubletotalDistance=getSplineFlingDistance(velocity);
233. mDistance=(int)(totalDistance*Math.signum(velocity));
235. mMinX=minX;
236. mMaxX=maxX;
237. mMinY=minY;
238. mMaxY=maxY;
240. mFinalX=startX+(int)Math.round(totalDistance*coeffX);
241. //PintomMinX<=mFinalX<=mMaxX
242. mFinalX=Math.min(mFinalX,mMaxX);
243. mFinalX=Math.max(mFinalX,mMinX);
245. mFinalY=startY+(int)Math.round(totalDistance*coeffY);
246. //PintomMinY<=mFinalY<=mMaxY
247. mFinalY=Math.min(mFinalY,mMaxY);
248. mFinalY=Math.max(mFinalY,mMinY);
249. }
251. }

Scroller有三个构造方法，其中二、三可以使用动画插值器。除了构造方法外，Scroller还有以下几个重要方法：computeScrollOffset()、startScroll(int startX, int startY, int dx, int dy, int duration)、fling(int startX, int startY, int velocityX, int velocityY, int minX, int maxX, int minY, int maxY)等。 startScroll(int startX, int startY, int dx, int dy, int duration)从方法名字来看应该是滑动开始的地方，事实上我们在使用的时候也是先调用这个方法的，它的作用是：(startX , startY)在duration时间内前进(dx,dy)个单位，即到达坐标为(startX+dx , startY+dy) 但是从源码来看， [html] view plain copy

1. publicvoidstartScroll(intstartX,intstartY,intdx,intdy,intduration){
2. mMode=SCROLL_MODE;
3. mFinished=false;
4. mDuration=duration;
5. mStartTime=AnimationUtils.currentAnimationTimeMillis();
6. mStartX=startX;
7. mStartY=startY;
8. mFinalX=startX+dx;
9. mFinalY=startY+dy;
10. mDeltaX=dx;
11. mDeltaY=dy;
12. mDurationReciprocal=1.0f/(float)mDuration;
13. }

这个方法更像是一个构造方法用来初始化赋值的，比如设置滚动模式、开始时间，持续时间、起始坐标、结束坐标等等，并没有任何对View的滚动操作，当然还有一个重要的变量：mDurationReciprocal。因为这个变量要在接下来介绍的computeScrollOffset()方法使用，computeScrollOffset()方法主要是根据当前已经消逝的时间来计算当前的坐标点，并且保存在mCurrX和mCurrY值中，那这个消逝的时间就是如何计算出来的呢？之前在startScroll()方法的时候获取了当前的动画毫秒并赋值给了mStartTime，在computeScrollOffset()中再一次调用AnimationUtils.currentAnimationTimeMillis()来获取动画毫秒减去mStartTime就是消逝时间了。然后进去if判断，如果动画持续时间小于设置的滚动持续时间mDuration，则是SCROLL_MODE，再根据Interpolator来计算出在该时间段里面移动的距离，移动的距离是根据这个消逝时间乘以mDurationReciprocal，就得到一个相对偏移量，再进行Math.round(x * mDeltaX)计算，就得到最后的偏移量，然后赋值给mCurrX， mCurrY，所以mCurrX、 mCurrY的值也是一直变化的。总结一下该方法的作用就是，计算在0到mDuration时间段内滚动的偏移量，并且判断滚动是否结束，true代表还没结束，false则表示滚动结束了。 之前说到是Scroller配合computeScroll()方法来实现移动的，那是如何配合的呢？ 1、首先调用Scroller的startScroll()方法来进行一些滚动的初始化设置， [html] view plain copy

1. scroller.startScroll(getScrollX(),0,distance,0);

2、然后调用View的invalidate()或postInvalidate()进行重绘。 [html] view plain copy

1. invalidate();//刷新视图

3、绘制View的时候会触发computeScroll()方法，接着重写computeScroll()，在computeScroll()里面先调用Scroller的computeScrollOffset()方法来判断滚动是否结束，如果滚动没有结束就调用scrollTo()方法来进行滚动。 [html] view plain copy

1. @Override
2. blicvoidcomputeScroll(){
3. if(scroller.computeScrollOffset()){
4. scrollTo(scroller.getCurrX(),0);
5. }

4、scrollTo()方法虽然会重新绘制View,但是还是要手动调用下invalidate()或者postInvalidate()来触发界面重绘，重新绘制View又触发computeScroll()，所以就进入一个递归循环阶段，这样就实现在某个时间段里面滚动某段距离的一个平滑的滚动效果。 [html] view plain copy

1. @Override
2. publicvoidcomputeScroll(){
3. if(scroller.computeScrollOffset()){
4. scrollTo(scroller.getCurrX(),0);
5. invalidate();
6. }
7. }

具体流程图如下：

了解完Scroller之后，我们就对之前的例子进行一下改进，不直接使用scrollTo()、ScrollBy()方法了，而是使用Scroller来实现一个平滑的移动效果。只需把代码稍微改一下就可以了，如下： [html] view plain copy

1. /**
2. *
3. */
4. packagecom.kince.scrolldemo;
6. importandroid.content.Context;
7. importandroid.util.AttributeSet;
8. importandroid.view.MotionEvent;
9. importandroid.view.View;
10. importandroid.view.ViewGroup;
11. importandroid.widget.Scroller;
13. /**
14. *@authorkince
15. *
16. *
17. */
18. publicclassCusScrollViewextendsViewGroup{
20. privateintlastX=0;
21. privateintcurrX=0;
22. privateintoffX=0;
23. privateScrollermScroller;
25. /**
26. *@paramcontext
27. */
28. publicCusScrollView(Contextcontext){
29. this(context,null);
30. //TODOAuto-generatedconstructorstub
31. }
33. /**
34. *@paramcontext
35. *@paramattrs
36. */
37. publicCusScrollView(Contextcontext,AttributeSetattrs){
38. this(context,attrs,0);
39. //TODOAuto-generatedconstructorstub
40. }
42. /**
43. *@paramcontext
44. *@paramattrs
45. *@paramdefStyle
46. */
47. publicCusScrollView(Contextcontext,AttributeSetattrs,intdefStyle){
48. super(context,attrs,defStyle);
49. //TODOAuto-generatedconstructorstub
50. mScroller=newScroller(context);
51. }
53. /*
54. *(non-Javadoc)
55. *
56. *@seeandroid.view.ViewGroup#onLayout(boolean,int,int,int,int)
57. */
58. @Override
59. protectedvoidonLayout(booleanchanged,intl,intt,intr,intb){
60. //TODOAuto-generatedmethodstub
62. for(inti=0;i<getChildCount();i++){
63. Viewv=getChildAt(i);
64. v.layout(0+i*getWidth(),0,getWidth()+i*getWidth(),
65. getHeight());
66. }
67. }
69. @Override
70. publicbooleanonTouchEvent(MotionEventevent){
71. //TODOAuto-generatedmethodstub
72. switch(event.getAction()){
73. caseMotionEvent.ACTION_DOWN:
74. //只考虑水平方向
75. lastX=(int)event.getX();
76. returntrue;
78. caseMotionEvent.ACTION_MOVE:
79. currX=(int)event.getX();
80. offX=currX-lastX;
81. //scrollBy(-offX,0);
82. mScroller.startScroll(getScrollX(),0,-offX,0);
84. break;
86. caseMotionEvent.ACTION_UP:
87. //scrollTo(0,0);
88. mScroller.startScroll(getScrollX(),0,-100,0);
89. break;
90. }
91. invalidate();
92. returnsuper.onTouchEvent(event);
93. }
95. @Override
96. publicvoidcomputeScroll(){
97. //TODOAuto-generatedmethodstub
98. if(mScroller.computeScrollOffset()){
99. scrollTo(mScroller.getCurrX(),0);
100. invalidate();
101. }
102. }
104. }

这样就实现了一个平滑的移动效果。关于scrollTo() 、scrollBy()、 Scroller讲解就进行到这里。之后会更新两篇关于这方面的UI效果开发，一篇是模仿Zaker的开门效果；另一篇是首页推荐图片轮播效果。

更多相关文章

1. 浅谈Java中Collections.sort对List排序的两种方法
2. Python list sort方法的具体使用
3. python list.sort()根据多个关键字排序的方法实现
4. android上一些方法的区别和用法的注意事项
5. android实现字体闪烁动画的方法
6. Android(安卓)matrix 控制图片的旋转、缩放、移动
7. Android中dispatchDraw分析
8. Android四大基本组件介绍与生命周期
9. Android(安卓)MediaPlayer 常用方法介绍

随机推荐

1. Android(安卓)Bundle类
2. AndroidManifest.xml【 manifest -> perm
3. Android(安卓)Studio 3.0以后打包修改文
4. [Android] 环境优化配置Android(安卓)Stu
5. Android(安卓)studio maven pom.xml
6. Android(安卓)启动页，倒计时 view
7. Android传感器介绍
8. android图片缩放手势检测类--ScaleGestur
9. android stdio Error Could not find com
10. android 开发工具下载地址