/** 
   * The offset, in pixels, by which the content of this view is scrolled 
   * horizontally. 
   * {@hide} 
   */ 
  protected int mScrollX;  //該視圖內(nèi)容相當(dāng)于視圖起始坐標(biāo)的偏移量  ， X軸 方向 
  /** 
   * The offset, in pixels, by which the content of this view is scrolled 
   * vertically. 
   * {@hide} 
   */ 
  protected int mScrollY;  //該視圖內(nèi)容相當(dāng)于視圖起始坐標(biāo)的偏移量  ， Y軸方向 
 
  /** 
   * Return the scrolled left position of this view. This is the left edge of 
   * the displayed part of your view. You do not need to draw any pixels 
   * farther left, since those are outside of the frame of your view on 
   * screen. 
   * 
   * @return The left edge of the displayed part of your view, in pixels. 
   */ 
  public final int getScrollX() { 
    return mScrollX; 
  } 
 
  /** 
   * Return the scrolled top position of this view. This is the top edge of 
   * the displayed part of your view. You do not need to draw any pixels above 
   * it, since those are outside of the frame of your view on screen. 
   * 
   * @return The top edge of the displayed part of your view, in pixels. 
   */ 
  public final int getScrollY() { 
    return mScrollY; 
  } 

public void scrollTo(int x, int y)

/** 
 * Set the scrolled position of your view. This will cause a call to 
 * {@link #onScrollChanged(int, int, int, int)} and the view will be 
 * invalidated. 
 * @param x the x position to scroll to 
 * @param y the y position to scroll to 
 */ 
public void scrollTo(int x, int y) { 
  //偏移位置發(fā)生了改變 
  if (mScrollX != x || mScrollY != y) { 
    int oldX = mScrollX; 
    int oldY = mScrollY; 
    mScrollX = x; //賦新值，保存當(dāng)前便宜量 
    mScrollY = y; 
    //回調(diào)onScrollChanged方法 
    onScrollChanged(mScrollX, mScrollY, oldX, oldY); 
    if (!awakenScrollBars()) { 
      invalidate(); //一般都引起重繪 
    } 
  } 
} 
 
   public void scrollBy(int x, int y)  

/** 
  * Move the scrolled position of your view. This will cause a call to 
  * {@link #onScrollChanged(int, int, int, int)} and the view will be 
  * invalidated. 
  * @param x the amount of pixels to scroll by horizontally 
  * @param y the amount of pixels to scroll by vertically 
  */ 
 // 看出原因了吧 。。 mScrollX 與 mScrollY 代表我們當(dāng)前偏移的位置 ， 在當(dāng)前位置繼續(xù)偏移(x ,y)個(gè)單位 
 public void scrollBy(int x, int y) { 
   scrollTo(mScrollX + x, mScrollY + y); 
 } 

//自定義ViewGroup ， 包含了三個(gè)LinearLayout控件，存放在不同的布局位置，通過scrollBy或者scrollTo方法切換 
public class MultiViewGroup extends ViewGroup { 
 
  private Context mContext; 
 
  private static String TAG = "MultiViewGroup"; 
 
  public MultiViewGroup(Context context) { 
    super(context); 
    mContext = context; 
    init(); 
  } 
 
  public MultiViewGroup(Context context, AttributeSet attrs) { 
    super(context, attrs); 
    mContext = context; 
    init(); 
  } 
 
  private void init() { 
    // 初始化3個(gè) LinearLayout控件 
    LinearLayout oneLL = new LinearLayout(mContext); 
    oneLL.setBackgroundColor(Color.RED); 
    addView(oneLL); 
     
    LinearLayout twoLL = new LinearLayout(mContext); 
    twoLL.setBackgroundColor(Color.YELLOW); 
    addView(twoLL); 
     
    LinearLayout threeLL = new LinearLayout(mContext); 
    threeLL.setBackgroundColor(Color.BLUE); 
    addView(threeLL); 
  } 
 
  // measure過程 
  @Override 
  protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) { 
 
    Log.i(TAG, "--- start onMeasure --"); 
 
    // 設(shè)置該ViewGroup的大小 
    int width = MeasureSpec.getSize(widthMeasureSpec); 
    int height = MeasureSpec.getSize(heightMeasureSpec); 
    setMeasuredDimension(width, height); 
 
    int childCount = getChildCount(); 
    Log.i(TAG, "--- onMeasure childCount is -->" + childCount); 
    for (int i = 0; i < childCount; i++) { 
      View child = getChildAt(i); 
      // 設(shè)置每個(gè)子視圖的大小 ， 即全屏 
      child.measure(MultiScreenActivity.screenWidth, MultiScreenActivity.scrrenHeight); 
    } 
  } 
 
  // layout過程 
  @Override 
  protected void onLayout(boolean changed, int l, int t, int r, int b) { 
    // TODO Auto-generated method stub 
    Log.i(TAG, "--- start onLayout --"); 
    int startLeft = 0; // 每個(gè)子視圖的起始布局坐標(biāo) 
    int startTop = 10; // 間距設(shè)置為10px 相當(dāng)于 android：marginTop= "10px" 
    int childCount = getChildCount(); 
    Log.i(TAG, "--- onLayout childCount is -->" + childCount); 
    for (int i = 0; i < childCount; i++) { 
      View child = getChildAt(i); 
      child.layout(startLeft, startTop,  
          startLeft + MultiScreenActivity.screenWidth,  
          startTop + MultiScreenActivity.scrrenHeight); 
      startLeft = startLeft + MultiScreenActivity.screenWidth ; //校準(zhǔn)每個(gè)子View的起始布局位置 
      //三個(gè)子視圖的在屏幕中的分布如下 [0 , 320] / [320,640] / [640,960] 
    } 
  } 
 
} 

package com.qin.customviewgroup; 
 
public class View { 
  .... 
  protected int mScrollX;  //該視圖內(nèi)容相當(dāng)于視圖起始坐標(biāo)的偏移量  ， X軸 方向   
  protected int mScrollY;  //該視圖內(nèi)容相當(dāng)于視圖起始坐標(biāo)的偏移量  ， Y軸方向 
  //返回值 
  public final int getScrollX() { 
    return mScrollX; 
  } 
  public final int getScrollY() { 
    return mScrollY; 
  } 
  public void scrollTo(int x, int y) { 
    //偏移位置發(fā)生了改變 
    if (mScrollX != x || mScrollY != y) { 
      int oldX = mScrollX; 
      int oldY = mScrollY; 
      mScrollX = x; //賦新值，保存當(dāng)前便宜量 
      mScrollY = y; 
      //回調(diào)onScrollChanged方法 
      onScrollChanged(mScrollX, mScrollY, oldX, oldY); 
      if (!awakenScrollBars()) { 
        invalidate(); //一般都引起重繪 
      } 
    } 
  } 
  // 看出原因了吧 。。 mScrollX 與 mScrollY 代表我們當(dāng)前偏移的位置 ， 在當(dāng)前位置繼續(xù)偏移(x ,y)個(gè)單位 
  public void scrollBy(int x, int y) { 
    scrollTo(mScrollX + x, mScrollY + y); 
  } 
  //... 
} 

public class Scroller { 
 
  private int mStartX;  //起始坐標(biāo)點(diǎn) , X軸方向 
  private int mStartY;  //起始坐標(biāo)點(diǎn) , Y軸方向 
  private int mCurrX;   //當(dāng)前坐標(biāo)點(diǎn) X軸， 即調(diào)用startScroll函數(shù)后,經(jīng)過一定時(shí)間所達(dá)到的值 
  private int mCurrY;   //當(dāng)前坐標(biāo)點(diǎn) Y軸， 即調(diào)用startScroll函數(shù)后,經(jīng)過一定時(shí)間所達(dá)到的值 
   
  private float mDeltaX; //應(yīng)該繼續(xù)滑動(dòng)的距離， X軸方向 
  private float mDeltaY; //應(yīng)該繼續(xù)滑動(dòng)的距離， Y軸方向 
  private boolean mFinished; //是否已經(jīng)完成本次滑動(dòng)操作， 如果完成則為 true 
 
  //構(gòu)造函數(shù) 
  public Scroller(Context context) { 
    this(context, null); 
  } 
  public final boolean isFinished() { 
    return mFinished; 
  } 
  //強(qiáng)制結(jié)束本次滑屏操作 
  public final void forceFinished(boolean finished) { 
    mFinished = finished; 
  } 
  public final int getCurrX() { 
    return mCurrX; 
  } 
   /* Call this when you want to know the new location. If it returns true, 
   * the animation is not yet finished. loc will be altered to provide the 
   * new location. */  
  //根據(jù)當(dāng)前已經(jīng)消逝的時(shí)間計(jì)算當(dāng)前的坐標(biāo)點(diǎn)，保存在mCurrX和mCurrY值中 
  public boolean computeScrollOffset() { 
    if (mFinished) { //已經(jīng)完成了本次動(dòng)畫控制，直接返回為false 
      return false; 
    } 
    int timePassed = (int)(AnimationUtils.currentAnimationTimeMillis() - mStartTime); 
    if (timePassed < mDuration) { 
      switch (mMode) { 
      case SCROLL_MODE: 
        float x = (float)timePassed * mDurationReciprocal; 
        ... 
        mCurrX = mStartX + Math.round(x * mDeltaX); 
        mCurrY = mStartY + Math.round(x * mDeltaY); 
        break; 
      ... 
    } 
    else { 
      mCurrX = mFinalX; 
      mCurrY = mFinalY; 
      mFinished = true; 
    } 
    return true; 
  } 
  //開始一個(gè)動(dòng)畫控制，由(startX , startY)在duration時(shí)間內(nèi)前進(jìn)(dx,dy)個(gè)單位，即到達(dá)坐標(biāo)為(startX+dx , startY+dy)出 
  public void startScroll(int startX, int startY, int dx, int dy, int duration) { 
    mFinished = false; 
    mDuration = duration; 
    mStartTime = AnimationUtils.currentAnimationTimeMillis(); 
    mStartX = startX;    mStartY = startY; 
    mFinalX = startX + dx; mFinalY = startY + dy; 
    mDeltaX = dx;      mDeltaY = dy; 
    ... 
  } 
} 

public void startScroll(int startX, int startY, int dx, int dy, int duration)

public void startScroll(int startX, int startY, int dx, int dy, int duration)

   computeScroll()方法原型如下，該方法位于ViewGroup.java類中   
/** 
   * Called by a parent to request that a child update its values for mScrollX 
   * and mScrollY if necessary. This will typically be done if the child is 
   * animating a scroll using a {@link android.widget.Scroller Scroller} 
   * object. 
   */由父視圖調(diào)用用來請求子視圖根據(jù)偏移值 mScrollX,mScrollY重新繪制 
  public void computeScroll() { //空方法 ，自定義ViewGroup必須實(shí)現(xiàn)方法體 
     
  } 

：@Override protected void dispatchDraw(Canvas canvas){ 
  ... 
   
  for (int i = 0; i < count; i++) { 
    final View child = children[getChildDrawingOrder(count, i)]; 
    if ((child.mViewFlags & VISIBILITY_MASK) == VISIBLE || child.getAnimation() != null) { 
      more |= drawChild(canvas, child, drawingTime); 
    } 
  } 
} 
protected boolean drawChild(Canvas canvas, View child, long drawingTime) { 
  ... 
  child.computeScroll(); 
  ... 
} 

//自定義ViewGroup ， 包含了三個(gè)LinearLayout控件，存放在不同的布局位置，通過scrollBy或者scrollTo方法切換 
public class MultiViewGroup extends ViewGroup { 
  ... 
  //startScroll開始移至下一屏 
  public void startMove(){ 
    curScreen ++ ; 
    Log.i(TAG, "----startMove---- curScreen " + curScreen); 
     
    //使用動(dòng)畫控制偏移過程 , 3s內(nèi)到位 
    mScroller.startScroll((curScreen-1) * getWidth(), 0, getWidth(), 0,3000); 
    //其實(shí)點(diǎn)擊按鈕的時(shí)候，系統(tǒng)會(huì)自動(dòng)重新繪制View，我們還是手動(dòng)加上吧。 
    invalidate(); 
    //使用scrollTo一步到位 
    //scrollTo(curScreen * MultiScreenActivity.screenWidth, 0); 
  } 
  // 由父視圖調(diào)用用來請求子視圖根據(jù)偏移值 mScrollX,mScrollY重新繪制 
  @Override 
  public void computeScroll() {   
    // TODO Auto-generated method stub 
    Log.e(TAG, "computeScroll"); 
    // 如果返回true，表示動(dòng)畫還沒有結(jié)束 
    // 因?yàn)榍懊鎠tartScroll，所以只有在startScroll完成時(shí) 才會(huì)為false 
    if (mScroller.computeScrollOffset()) { 
      Log.e(TAG, mScroller.getCurrX() + "======" + mScroller.getCurrY()); 
      // 產(chǎn)生了動(dòng)畫效果，根據(jù)當(dāng)前值 每次滾動(dòng)一點(diǎn) 
      scrollTo(mScroller.getCurrX(), mScroller.getCurrY()); 
       
      Log.e(TAG, "### getleft is " + getLeft() + " ### getRight is " + getRight()); 
      //此時(shí)同樣也需要刷新View ，否則效果可能有誤差 
      postInvalidate(); 
    } 
    else 
      Log.i(TAG, "have done the scoller -----"); 
  } 
  //馬上停止移動(dòng)，如果已經(jīng)超過了下一屏的一半，我們強(qiáng)制滑到下一個(gè)屏幕 
  public void stopMove(){ 
     
    Log.v(TAG, "----stopMove ----"); 
     
    if(mScroller != null){ 
      //如果動(dòng)畫還沒結(jié)束，我們就按下了結(jié)束的按鈕，那我們就結(jié)束該動(dòng)畫，即馬上滑動(dòng)指定位置 
      if(!mScroller.isFinished()){ 
         
        int scrollCurX= mScroller.getCurrX() ; 
        //判斷是否超過下一屏的中間位置，如果達(dá)到就抵達(dá)下一屏，否則保持在原屏幕 
        // 這樣的一個(gè)簡單公式意思是：假設(shè)當(dāng)前滑屏偏移值即 scrollCurX 加上每個(gè)屏幕一半的寬度，除以每個(gè)屏幕的寬度就是 
        // 我們目標(biāo)屏所在位置了。 假如每個(gè)屏幕寬度為320dip, 我們滑到了500dip處，很顯然我們應(yīng)該到達(dá)第二屏,索引值為1 
        //即(500 + 320/2)/320 = 1 
        int descScreen = ( scrollCurX + getWidth() / 2) / getWidth() ; 
         
        Log.i(TAG, "-mScroller.is not finished scrollCurX +" + scrollCurX); 
        Log.i(TAG, "-mScroller.is not finished descScreen +" + descScreen); 
        mScroller.abortAnimation(); 
 
        //停止了動(dòng)畫，我們馬上滑倒目標(biāo)位置 
        scrollTo(descScreen *getWidth() , 0); 
        curScreen = descScreen ; //糾正目標(biāo)屏位置 
      } 
      else 
        Log.i(TAG, "----OK mScroller.is finished ---- "); 
    }   
  } 
  ... 
} 

//自定義ViewGroup ， 包含了三個(gè)LinearLayout控件，存放在不同的布局位置，通過scrollBy或者scrollTo方法切換 
public class MultiViewGroup extends ViewGroup { 
 
  private static String TAG = "MultiViewGroup"; 
   
  private int curScreen = 0 ; //當(dāng)前屏幕 
  private Scroller mScroller = null ; //Scroller對象實(shí)例 
   
  public MultiViewGroup(Context context) { 
    super(context); 
    mContext = context; 
    init(); 
  } 
  public MultiViewGroup(Context context, AttributeSet attrs) { 
    super(context, attrs); 
    mContext = context; 
    init(); 
  } 
  //初始化 
  private void init() {   
    ... 
    //初始化Scroller實(shí)例 
    mScroller = new Scroller(mContext); 
    // 初始化3個(gè) LinearLayout控件 
    ... 
    //初始化一個(gè)最小滑動(dòng)距離 
    mTouchSlop = ViewConfiguration.get(getContext()).getScaledTouchSlop(); 
  } 
  // 由父視圖調(diào)用用來請求子視圖根據(jù)偏移值 mScrollX,mScrollY重新繪制 
  @Override 
  public void computeScroll() {   
    // TODO Auto-generated method stub 
    Log.e(TAG, "computeScroll"); 
    // 如果返回true，表示動(dòng)畫還沒有結(jié)束 
    // 因?yàn)榍懊鎠tartScroll，所以只有在startScroll完成時(shí) 才會(huì)為false 
    if (mScroller.computeScrollOffset()) { 
      Log.e(TAG, mScroller.getCurrX() + "======" + mScroller.getCurrY()); 
      // 產(chǎn)生了動(dòng)畫效果，根據(jù)當(dāng)前值 每次滾動(dòng)一點(diǎn) 
      scrollTo(mScroller.getCurrX(), mScroller.getCurrY()); 
       
      Log.e(TAG, "### getleft is " + getLeft() + " ### getRight is " + getRight()); 
      //此時(shí)同樣也需要刷新View ，否則效果可能有誤差 
      postInvalidate(); 
    } 
    else 
      Log.i(TAG, "have done the scoller -----"); 
  } 
  //兩種狀態(tài): 是否處于滑屏狀態(tài) 
  private static final int TOUCH_STATE_REST = 0; //什么都沒做的狀態(tài) 
  private static final int TOUCH_STATE_SCROLLING = 1; //開始滑屏的狀態(tài) 
  private int mTouchState = TOUCH_STATE_REST; //默認(rèn)是什么都沒做的狀態(tài) 
  //--------------------------  
  //處理觸摸事件 ~ 
  public static int SNAP_VELOCITY = 600 ; //最小的滑動(dòng)速率 
  private int mTouchSlop = 0 ;       //最小滑動(dòng)距離，超過了，才認(rèn)為開始滑動(dòng) 
  private float mLastionMotionX = 0 ;    //記住上次觸摸屏的位置 
  //處理觸摸的速率 
  private VelocityTracker mVelocityTracker = null ; 
   
  // 這個(gè)感覺沒什么作用 不管true還是false 都是會(huì)執(zhí)行onTouchEvent的 因?yàn)樽觱iew里面onTouchEvent返回false了 
  @Override 
  public boolean onInterceptTouchEvent(MotionEvent ev) { 
    // TODO Auto-generated method stub 
    Log.e(TAG, "onInterceptTouchEvent-slop:" + mTouchSlop); 
 
    final int action = ev.getAction(); 
    //表示已經(jīng)開始滑動(dòng)了，不需要走該Action_MOVE方法了(第一次時(shí)可能調(diào)用)。 
    //該方法主要用于用戶快速松開手指，又快速按下的行為。此時(shí)認(rèn)為是出于滑屏狀態(tài)的。 
    if ((action == MotionEvent.ACTION_MOVE) && (mTouchState != TOUCH_STATE_REST)) { 
      return true; 
    } 
     
    final float x = ev.getX(); 
    final float y = ev.getY(); 
 
    switch (action) { 
    case MotionEvent.ACTION_MOVE: 
      Log.e(TAG, "onInterceptTouchEvent move"); 
      final int xDiff = (int) Math.abs(mLastionMotionX - x); 
      //超過了最小滑動(dòng)距離，就可以認(rèn)為開始滑動(dòng)了 
      if (xDiff > mTouchSlop) { 
        mTouchState = TOUCH_STATE_SCROLLING; 
      } 
      break; 
 
    case MotionEvent.ACTION_DOWN: 
      Log.e(TAG, "onInterceptTouchEvent down"); 
      mLastionMotionX = x; 
      mLastMotionY = y; 
      Log.e(TAG, mScroller.isFinished() + ""); 
      mTouchState = mScroller.isFinished() ? TOUCH_STATE_REST : TOUCH_STATE_SCROLLING; 
 
      break; 
 
    case MotionEvent.ACTION_CANCEL: 
    case MotionEvent.ACTION_UP: 
      Log.e(TAG, "onInterceptTouchEvent up or cancel"); 
      mTouchState = TOUCH_STATE_REST; 
      break; 
    } 
    Log.e(TAG, mTouchState + "====" + TOUCH_STATE_REST); 
    return mTouchState != TOUCH_STATE_REST; 
  } 
  public boolean onTouchEvent(MotionEvent event){ 
 
    super.onTouchEvent(event); 
     
    Log.i(TAG, "--- onTouchEvent--> " ); 
 
    // TODO Auto-generated method stub 
    Log.e(TAG, "onTouchEvent start"); 
    //獲得VelocityTracker對象，并且添加滑動(dòng)對象 
    if (mVelocityTracker == null) { 
      mVelocityTracker = VelocityTracker.obtain(); 
    } 
    mVelocityTracker.addMovement(event); 
     
    //觸摸點(diǎn) 
    float x = event.getX(); 
    float y = event.getY(); 
    switch(event.getAction()){ 
    case MotionEvent.ACTION_DOWN: 
      //如果屏幕的動(dòng)畫還沒結(jié)束，你就按下了，我們就結(jié)束上一次動(dòng)畫，即開始這次新ACTION_DOWN的動(dòng)畫 
      if(mScroller != null){ 
        if(!mScroller.isFinished()){ 
          mScroller.abortAnimation();  
        } 
      } 
      mLastionMotionX = x ; //記住開始落下的屏幕點(diǎn) 
      break ; 
    case MotionEvent.ACTION_MOVE: 
      int detaX = (int)(mLastionMotionX - x ); //每次滑動(dòng)屏幕，屏幕應(yīng)該移動(dòng)的距離 
      scrollBy(detaX, 0);//開始緩慢滑屏咯。 detaX > 0 向右滑動(dòng) ， detaX < 0 向左滑動(dòng) ， 
       
      Log.e(TAG, "--- MotionEvent.ACTION_MOVE--> detaX is " + detaX ); 
      mLastionMotionX = x ; 
      break ; 
    case MotionEvent.ACTION_UP: 
       
      final VelocityTracker velocityTracker = mVelocityTracker ; 
      velocityTracker.computeCurrentVelocity(1000); 
      //計(jì)算速率 
      int velocityX = (int) velocityTracker.getXVelocity() ;  
      Log.e(TAG , "---velocityX---" + velocityX); 
       
      //滑動(dòng)速率達(dá)到了一個(gè)標(biāo)準(zhǔn)(快速向右滑屏，返回上一個(gè)屏幕) 馬上進(jìn)行切屏處理 
      if (velocityX > SNAP_VELOCITY && curScreen > 0) { 
        // Fling enough to move left 
        Log.e(TAG, "snap left"); 
        snapToScreen(curScreen - 1); 
      } 
      //快速向左滑屏，返回下一個(gè)屏幕) 
      else if(velocityX < -SNAP_VELOCITY && curScreen < (getChildCount()-1)){ 
        Log.e(TAG, "snap right"); 
        snapToScreen(curScreen + 1); 
      } 
      //以上為快速移動(dòng)的 ，強(qiáng)制切換屏幕 
      else{ 
        //我們是緩慢移動(dòng)的，因此先判斷是保留在本屏幕還是到下一屏幕 
        snapToDestination(); 
      } 
      //回收VelocityTracker對象 
      if (mVelocityTracker != null) { 
        mVelocityTracker.recycle(); 
        mVelocityTracker = null; 
      } 
      //修正mTouchState值 
      mTouchState = TOUCH_STATE_REST ; 
       
      break; 
    case MotionEvent.ACTION_CANCEL: 
      mTouchState = TOUCH_STATE_REST ; 
      break; 
    } 
     
    return true ; 
  } 
  ////我們是緩慢移動(dòng)的，因此需要根據(jù)偏移值判斷目標(biāo)屏是哪個(gè)？ 
  private void snapToDestination(){ 
    //當(dāng)前的偏移位置 
    int scrollX = getScrollX() ; 
    int scrollY = getScrollY() ; 
     
    Log.e(TAG, "### onTouchEvent snapToDestination ### scrollX is " + scrollX); 
    //判斷是否超過下一屏的中間位置，如果達(dá)到就抵達(dá)下一屏，否則保持在原屏幕   
    //直接使用這個(gè)公式判斷是哪一個(gè)屏幕 前后或者自己 
    //判斷是否超過下一屏的中間位置，如果達(dá)到就抵達(dá)下一屏，否則保持在原屏幕 
    // 這樣的一個(gè)簡單公式意思是：假設(shè)當(dāng)前滑屏偏移值即 scrollCurX 加上每個(gè)屏幕一半的寬度，除以每個(gè)屏幕的寬度就是 
    // 我們目標(biāo)屏所在位置了。 假如每個(gè)屏幕寬度為320dip, 我們滑到了500dip處，很顯然我們應(yīng)該到達(dá)第二屏 
    int destScreen = (getScrollX() + MultiScreenActivity.screenWidth / 2 ) / MultiScreenActivity.screenWidth ; 
     
    Log.e(TAG, "### onTouchEvent ACTION_UP### dx destScreen " + destScreen); 
     
    snapToScreen(destScreen); 
  } 
  //真正的實(shí)現(xiàn)跳轉(zhuǎn)屏幕的方法 
  private void snapToScreen(int whichScreen){  
    //簡單的移到目標(biāo)屏幕，可能是當(dāng)前屏或者下一屏幕 
    //直接跳轉(zhuǎn)過去，不太友好 
    //scrollTo(mLastScreen * MultiScreenActivity.screenWidth, 0); 
    //為了友好性，我們在增加一個(gè)動(dòng)畫效果 
    //需要再次滑動(dòng)的距離 屏或者下一屏幕的繼續(xù)滑動(dòng)距離 
     
    curScreen = whichScreen ; 
    //防止屏幕越界，即超過屏幕數(shù) 
    if(curScreen > getChildCount() - 1) 
      curScreen = getChildCount() - 1 ; 
    //為了達(dá)到下一屏幕或者當(dāng)前屏幕，我們需要繼續(xù)滑動(dòng)的距離.根據(jù)dx值，可能想左滑動(dòng)，也可能像又滑動(dòng) 
    int dx = curScreen * getWidth() - getScrollX() ; 
     
    Log.e(TAG, "### onTouchEvent ACTION_UP### dx is " + dx); 
     
    mScroller.startScroll(getScrollX(), 0, dx, 0,Math.abs(dx) * 2); 
     
    //由于觸摸事件不會(huì)重新繪制View，所以此時(shí)需要手動(dòng)刷新View 否則沒效果 
    invalidate(); 
  } 
  //開始滑動(dòng)至下一屏 
  public void startMove(){ 
    ...    
  } 
  //理解停止滑動(dòng) 
  public void stopMove(){ 
    ... 
  } 
  // measure過程 
  @Override 
  protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) { 
    ... 
  } 
  // layout過程 
  @Override 
  protected void onLayout(boolean changed, int l, int t, int r, int b) { 
    ... 
  } 
}