[置顶] Android Scroller简单用法

         Android里Scroller类是为了实现View平滑滚动的一个Helper类。通常在自定义的View时使用,在View中定义一个私有成员mScroller = new Scroller(context)。设置mScroller滚动的位置时,并不会导致View的滚动,通常是用mScroller记录/计算View滚动的位置,再重写View的computeScroll(),完成实际的滚动。 

      相关API介绍如下
 
Java代码   收藏代码
  1. mScroller.getCurrX() //获取mScroller当前水平滚动的位置  
  2. mScroller.getCurrY() //获取mScroller当前竖直滚动的位置  
  3. mScroller.getFinalX() //获取mScroller最终停止的水平位置  
  4. mScroller.getFinalY() //获取mScroller最终停止的竖直位置  
  5. mScroller.setFinalX(int newX) //设置mScroller最终停留的水平位置,没有动画效果,直接跳到目标位置  
  6. mScroller.setFinalY(int newY) //设置mScroller最终停留的竖直位置,没有动画效果,直接跳到目标位置  
  7.   
  8. //滚动,startX, startY为开始滚动的位置,dx,dy为滚动的偏移量, duration为完成滚动的时间  
  9. mScroller.startScroll(int startX, int startY, int dx, int dy) //使用默认完成时间250ms  
  10. mScroller.startScroll(int startX, int startY, int dx, int dy, int duration)  
  11.   
  12. mScroller.computeScrollOffset() //返回值为boolean,true说明滚动尚未完成,false说明滚动已经完成。这是一个很重要的方法,通常放在View.computeScroll()中,用来判断是否滚动是否结束。  

 Scroller这个类理解起来有一定的困难,刚开始接触Scroller类的程序员可能无法理解Scroller和View系统是怎么样联系起来的。我经过自己的学习和实践,对Scroller的用法和工作原理有了一定的理解,在这里和大家分享一下,希望大家多多指教。

      首先从源码开始分析:

        View.java

 

[java]  view plain copy
  1.   /** 
  2.  * Called by a parent to request that a child update its values for mScrollX 
  3.  * and mScrollY if necessary. This will typically be done if the child is 
  4.  * animating a scroll using a {@link android.widget.Scroller Scroller} 
  5.  * object. 
  6.  */  
  7. public void computeScroll()  
  8. {  
  9. }  



 

    computeScroll是一个空函数,很明显我们需要去实现它,至于做什么,就由我们自己来决定了。

    因为View的子类很多,在下面的例子中,我会在一个自定义的类MyLinearLayout中去实现它。

 

    ViewGroup.java

   

[java]  view plain copy
  1. @Override  
  2. protected void dispatchDraw(Canvas canvas) {  
  3.   
  4.             .......  
  5.   
  6.             .......  
  7.   
  8.             .......  
  9.   
  10.             .......  
  11.   
  12.             for (int i = 0; i < count; i++) {  
  13.             final View child = children[i];  
  14.             if ((child.mViewFlags & VISIBILITY_MASK) == VISIBLE || child.getAnimation() != null)  
  15.   
  16.             {  
  17.                 more |= drawChild(canvas, child, drawingTime);  
  18.             }  
  19.   
  20.             .......  
  21.   
  22.             .......  
  23.   
  24.             .......  


从dispatchDraw函数可以看出,ViewGroup会对它的每个孩子调用drawChild(),  在下面的例子中, ContentLinearLayout的孩子有2个,是2个MyLinearLayout类型的实例。

再看看drawChild函数:

[java]  view plain copy
  1.  protected boolean drawChild(Canvas canvas, View child, long drawingTime) {  
  2.   
  3.             ................  
  4.   
  5.             ................  
  6.   
  7.            child.computeScroll();  
  8.   
  9.             ................  
  10.   
  11.             ................  
  12.   
  13. }  

 

看到这里,我想大家应该就明白了,在父容器重画自己的孩子时,它会调用孩子的computScroll方法,也就是说例程中的ContentLinearLayout在调用dispatchDraw()函数时会调用MyLinearLayout的computeScroll方法。

     这个computeScroll()函数正是我们大展身手的地方,在这个函数里我们可以去取得事先设置好的成员变量mScroller中的位置信息、速度信息等等,用这些参数来做我们想做的事情。

    看到这里大家一定迫不及待的想看代码了,代码如下:

    

[java]  view plain copy
  1. package com.yulongfei.scroller;  
  2.   
  3. import android.widget.LinearLayout;  
  4. import android.widget.Scroller;  
  5. import android.app.Activity;  
  6. import android.content.Context;  
  7. import android.graphics.Canvas;  
  8. import android.os.Bundle;  
  9. import android.util.Log;  
  10. import android.view.View;  
  11. import android.widget.Button;  
  12. import android.view.View.OnClickListener;  
  13.   
  14. public class TestScrollerActivity extends Activity {  
  15.  private static final String TAG = "TestScrollerActivity";  
  16.     LinearLayout lay1,lay2,lay0;  
  17.      private Scroller mScroller;  
  18.     @Override  
  19.     public void onCreate(Bundle savedInstanceState) {  
  20.         super.onCreate(savedInstanceState);  
  21.         mScroller = new Scroller(this);  
  22.         lay1 = new MyLinearLayout(this);  
  23.         lay2 = new MyLinearLayout(this);  
  24.    
  25.         lay1.setBackgroundColor(this.getResources().getColor(android.R.color.darker_gray));  
  26.         lay2.setBackgroundColor(this.getResources().getColor(android.R.color.white));  
  27.         lay0 = new ContentLinearLayout(this);  
  28.         lay0.setOrientation(LinearLayout.VERTICAL);  
  29.         LinearLayout.LayoutParams p0 = new LinearLayout.LayoutParams  
  30.         (LinearLayout.LayoutParams.FILL_PARENT,LinearLayout.LayoutParams.FILL_PARENT);      
  31.         this.setContentView(lay0, p0);  
  32.    
  33.         LinearLayout.LayoutParams p1 = new LinearLayout.LayoutParams  
  34.         (LinearLayout.LayoutParams.FILL_PARENT,LinearLayout.LayoutParams.FILL_PARENT);      
  35.         p1.weight=1;  
  36.         lay0.addView(lay1,p1);  
  37.         LinearLayout.LayoutParams p2 = new LinearLayout.LayoutParams  
  38.         (LinearLayout.LayoutParams.FILL_PARENT,LinearLayout.LayoutParams.FILL_PARENT);      
  39.         p2.weight=1;  
  40.         lay0.addView(lay2,p2);  
  41.         MyButton btn1 = new MyButton(this);  
  42.         MyButton btn2 = new MyButton(this);  
  43.         btn1.setText("btn in layout1");  
  44.         btn2.setText("btn in layout2");  
  45.         btn1.setOnClickListener(new OnClickListener(){  
  46.             @Override  
  47.             public void onClick(View v) {  
  48.                     mScroller.startScroll(00, -30, -3050);  
  49.                 }  
  50.         });  
  51.         btn2.setOnClickListener(new OnClickListener(){  
  52.             @Override  
  53.             public void onClick(View v) {  
  54.                     mScroller.startScroll(2020, -50, -5050);  
  55.                 }  
  56.         });  
  57.         lay1.addView(btn1);  
  58.         lay2.addView(btn2);  
  59.     }  
  60.     class MyButton extends Button  
  61.     {  
  62.      public MyButton(Context ctx)  
  63.      {  
  64.       super(ctx);  
  65.      }  
  66.      @Override  
  67.      protected void onDraw(Canvas canvas)  
  68.      {  
  69.       super.onDraw(canvas);  
  70.       Log.d("MyButton"this.toString() + " onDraw------");  
  71.      }  
  72.     }  
  73.       
  74.     class MyLinearLayout extends LinearLayout  
  75.     {  
  76.      public MyLinearLayout(Context ctx)  
  77.      {  
  78.       super(ctx);  
  79.      }  
  80.        
  81.      @Override  
  82.         /** 
  83.          * Called by a parent to request that a child update its values for mScrollX 
  84.          * and mScrollY if necessary. This will typically be done if the child is 
  85.          * animating a scroll using a {@link android.widget.Scroller Scroller} 
  86.          * object. 
  87.          */  
  88.         public void computeScroll()   
  89.      {    
  90.     Log.d(TAG, this.toString() + " computeScroll-----------");  
  91.     if (mScroller.computeScrollOffset())//如果mScroller没有调用startScroll,这里将会返回false。  
  92.     {    
  93.         //因为调用computeScroll函数的是MyLinearLayout实例,  
  94.      //所以调用scrollTo移动的将是该实例的孩子,也就是MyButton实例  
  95.         scrollTo(mScroller.getCurrX(), 0);   
  96.         Log.d(TAG, "getCurrX = " +  mScroller.getCurrX());  
  97.   
  98.         //继续让系统重绘  
  99.         getChildAt(0).invalidate();   
  100.     }  
  101.      }  
  102.     }  
  103.       
  104.     class ContentLinearLayout extends LinearLayout  
  105.     {  
  106.      public ContentLinearLayout(Context ctx)  
  107.      {  
  108.       super(ctx);  
  109.      }  
  110.        
  111.      @Override  
  112.      protected void dispatchDraw(Canvas canvas)  
  113.      {  
  114.       Log.d("ContentLinearLayout""contentview dispatchDraw");  
  115.       super.dispatchDraw(canvas);  
  116.      }  
  117.     }  
  118. }  


    对代码做一个简单介绍:

    例子中定义了2个MyButton实例btn1和btn2,它们将被其父容器MyLinearLayout实例lay1和lay2通过调用scrollTo来移动。

  ContentLinearLayout实例lay0为Activity的contentview,它有2个孩子,分别是lay1和lay2。

   mScroller是一个封装位置和速度等信息的变量,startScroll()函数只是对它的一些成员变量做一些设置,这个设置的唯一效果就是导致mScroller.computeScrollOffset()    返回true。

      这里大家可能有个疑问,既然startScroll()只是虚晃一枪,那scroll的动态效果到底是谁触发的呢?

后面我将给出答案。

 

运行程序,我们来看看Log

点击btn1:

 [置顶] Android Scroller简单用法_第1张图片

 

点击btn2:[置顶] Android Scroller简单用法_第2张图片


   对照Log,我从button被点击开始,对整个绘制流程进行分析,首先button被点击(这里将回答上文的问题),button的背景将发生变化,这时button将调用invalidate()请求重绘,这就是View系统重绘的源头,即scroll动态效果的触发者。与此同时,mScroller.startScroll被调用了,mScroller在此时被设置了一些有效值。

   好了,既然重绘请求已发出了,那么整个View系统就会来一次自上而下的绘制了,首先输出的Log就是“contentview dispatchDraw”了,它将绘制需要重绘的孩子(lay1和lay2中的一个),接着会调用drawChild,使得computeScroll函数被触发(drawChild里面会调用child.computeScroll()),于是,lay1或者lay2就会以mScroller的位置信息为依据来调用scrollTo了,它的孩子btn1或者btn2就会被移动了。之后又调用了getChildAt(0).invalidate(),这将导致系统不断重绘,直到startScroll中设置的时间耗尽mScroller.computeScrollOffset()返回false才停下来。

   好了,现在整个流程都分析完了,相信大家应该清楚了Scroller类与View系统的关系了吧。理解了Scroller的工作原理,你会发现原来Scroller类并不神秘,甚至有点被动,它除了储存一些数值,什么其他的事情都没做,Scroller类中的一些变量mStartX, mFinalX, mDuration等等的意义也很好理解。





      举例说明,自定义一个CustomView,使用Scroller实现滚动: 

Java代码   收藏代码
  1. import android.content.Context;  
  2. import android.util.AttributeSet;  
  3. import android.util.Log;  
  4. import android.view.View;  
  5. import android.widget.LinearLayout;  
  6. import android.widget.Scroller;  
  7.   
  8. public class CustomView extends LinearLayout {  
  9.   
  10.     private static final String TAG = "Scroller";  
  11.   
  12.     private Scroller mScroller;  
  13.   
  14.     public CustomView(Context context, AttributeSet attrs) {  
  15.         super(context, attrs);  
  16.         mScroller = new Scroller(context);  
  17.     }  
  18.   
  19.     //调用此方法滚动到目标位置  
  20.     public void smoothScrollTo(int fx, int fy) {  
  21.         int dx = fx - mScroller.getFinalX();  
  22.         int dy = fy - mScroller.getFinalY();  
  23.         smoothScrollBy(dx, dy);  
  24.     }  
  25.   
  26.     //调用此方法设置滚动的相对偏移  
  27.     public void smoothScrollBy(int dx, int dy) {  
  28.   
  29.         //设置mScroller的滚动偏移量  
  30.         mScroller.startScroll(mScroller.getFinalX(), mScroller.getFinalY(), dx, dy);  
  31.         invalidate();//这里必须调用invalidate()才能保证computeScroll()会被调用,否则不一定会刷新界面,看不到滚动效果  
  32.     }  
  33.       
  34.     @Override  
  35.     public void computeScroll() {  
  36.       
  37.         //先判断mScroller滚动是否完成  
  38.         if (mScroller.computeScrollOffset()) {  
  39.           
  40.             //这里调用View的scrollTo()完成实际的滚动  
  41.             scrollTo(mScroller.getCurrX(), mScroller.getCurrY());  
  42.               
  43.             //必须调用该方法,否则不一定能看到滚动效果  
  44.             postInvalidate();  
  45.         }  
  46.         super.computeScroll();  
  47.     }  
  48. }  

你可能感兴趣的:([置顶] Android Scroller简单用法)