ViewGroup的手勢和繪製機制（我的見解）

    學習最好的辦法就是從實際出發，因此我選擇了ScrollLayout（左右滑動切換屏幕控件）來做爲例子，講述一下我對ViewGroup的一些機制的我的理解。

首先先貼一下ScrollLayout的代碼：

package cn.edu.scau.hci.widget;

import android.content.Context;
import android.util.AttributeSet;
import android.view.MotionEvent;
import android.view.VelocityTracker;
import android.view.View;
import android.view.ViewConfiguration;
import android.view.ViewGroup;
import android.widget.Scroller;

/**
 * 左右滑動切換屏幕控件
 * 
 * @author Yao.GUET date: 2011-05-04
 * @modify liux (http://my.oschina.net/liux)
 */
public class ScrollLayout extends ViewGroup {
  private Scroller mScroller;
  private VelocityTracker mVelocityTracker;
  private int mCurScreen;
  private int mDefaultScreen = 0;
  private static final int TOUCH_STATE_REST = 0;
  private static final int TOUCH_STATE_SCROLLING = 1;
  private static final int SNAP_VELOCITY = 600;
  private int mTouchState = TOUCH_STATE_REST;
  private int mTouchSlop;
  private float mLastMotionX;
  private float mLastMotionY;
  private OnViewChangeListener mOnViewChangeListener;

  /**
   * 設置是否可左右滑動
   * 
   * @author liux
   */
  private boolean isScroll = true;

  public void setIsScroll(boolean b) {
    this.isScroll = b;
  }

  public ScrollLayout(Context context, AttributeSet attrs) {
    this(context, attrs, 0);
  }

  public ScrollLayout(Context context, AttributeSet attrs, int defStyle) {
    super(context, attrs, defStyle);
    mScroller = new Scroller(context);
    mCurScreen = mDefaultScreen;
    mTouchSlop = ViewConfiguration.get(getContext()).getScaledTouchSlop();
  }

  @Override
  protected void onLayout(boolean changed, int l, int t, int r, int b) {
    int childLeft = 0;
    final int childCount = getChildCount();
    for (int i = 0; i < childCount; i++) {
      final View childView = getChildAt(i);
      if (childView.getVisibility() != View.GONE) {
        final int childWidth = childView.getMeasuredWidth();
        childView.layout(childLeft, 0, childLeft + childWidth, childView.getMeasuredHeight());
        childLeft += childWidth;
      }
    }
  }

  @Override
  protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
    // Log.e(TAG, "onMeasure");
    super.onMeasure(widthMeasureSpec, heightMeasureSpec);
    final int width = MeasureSpec.getSize(widthMeasureSpec);
    final int widthMode = MeasureSpec.getMode(widthMeasureSpec);
    if (widthMode != MeasureSpec.EXACTLY) {
      throw new IllegalStateException("ScrollLayout only canmCurScreen run at EXACTLY mode!");
    }
    final int heightMode = MeasureSpec.getMode(heightMeasureSpec);
    if (heightMode != MeasureSpec.EXACTLY) {
      throw new IllegalStateException("ScrollLayout only can run at EXACTLY mode!");
    }

    // The children are given the same width and height as the scrollLayout
    final int count = getChildCount();
    for (int i = 0; i < count; i++) {
      getChildAt(i).measure(widthMeasureSpec, heightMeasureSpec);
    }
    // Log.e(TAG, "moving to screen "+mCurScreen);
    scrollTo(mCurScreen * width, 0);
  }

  /**
   * According to the position of current layout scroll to the destination page.
   */
  public void snapToDestination() {
    final int screenWidth = getWidth();
    final int destScreen = (getScrollX() + screenWidth / 2) / screenWidth;
    snapToScreen(destScreen);
  }

  public void snapToScreen(int whichScreen) {
    // 是否可滑動
    if (!isScroll) {
      this.setToScreen(whichScreen);
      return;
    }

    scrollToScreen(whichScreen);
  }

  public void scrollToScreen(int whichScreen) {
    // get the valid layout page
    whichScreen = Math.max(0, Math.min(whichScreen, getChildCount() - 1));
    if (getScrollX() != (whichScreen * getWidth())) {
      final int delta = whichScreen * getWidth() - getScrollX();
      mScroller.startScroll(getScrollX(), 0, delta, 0, Math.abs(delta) * 1);// 持續滾動時間 以毫秒爲單位
      mCurScreen = whichScreen;

      invalidate(); // Redraw the layout

      if (mOnViewChangeListener != null) {
        mOnViewChangeListener.OnViewChange(mCurScreen);
      }
    }

  }

  public void setToScreen(int whichScreen) {
    whichScreen = Math.max(0, Math.min(whichScreen, getChildCount() - 1));
    mCurScreen = whichScreen;
    scrollTo(whichScreen * getWidth(), 0);

    if (mOnViewChangeListener != null) {
      mOnViewChangeListener.OnViewChange(mCurScreen);
    }
  }

  public int getCurScreen() {
    return mCurScreen;
  }

  @Override
  public void computeScroll() {
    if (mScroller.computeScrollOffset()) {
      scrollTo(mScroller.getCurrX(), mScroller.getCurrY());
      postInvalidate();
    }
  }

  @Override
  public boolean onTouchEvent(MotionEvent event) {
    // 是否可滑動
    if (!isScroll) {
      return false;
    }

    if (mVelocityTracker == null) {
      mVelocityTracker = VelocityTracker.obtain();
    }
    mVelocityTracker.addMovement(event);
    final int action = event.getAction();
    final float x = event.getX();
    final float y = event.getY();
    switch (action) {
      case MotionEvent.ACTION_DOWN:
        // Log.e(TAG, "event down!");
        if (!mScroller.isFinished()) {
          mScroller.abortAnimation();
        }
        mLastMotionX = x;

        // ---------------New Code----------------------
        mLastMotionY = y;
        // ---------------------------------------------

        break;
      case MotionEvent.ACTION_MOVE:
        int deltaX = (int) (mLastMotionX - x);

        // ---------------New Code----------------------
        int deltaY = (int) (mLastMotionY - y);
        if (Math.abs(deltaX) < 200 && Math.abs(deltaY) > 10) break;
        mLastMotionY = y;
        // -------------------------------------

        mLastMotionX = x;
        scrollBy(deltaX, 0);
        break;
      case MotionEvent.ACTION_UP:
        // Log.e(TAG, "event : up");
        // if (mTouchState == TOUCH_STATE_SCROLLING) {
        final VelocityTracker velocityTracker = mVelocityTracker;
        velocityTracker.computeCurrentVelocity(1000);
        int velocityX = (int) velocityTracker.getXVelocity();
        // Log.e(TAG, "velocityX:" + velocityX);
        if (velocityX > SNAP_VELOCITY && mCurScreen > 0) {
          // Fling enough to move left
          // Log.e(TAG, "snap left");
          snapToScreen(mCurScreen - 1);
        } else if (velocityX < -SNAP_VELOCITY && mCurScreen < getChildCount() - 1) {
          // Fling enough to move right
          // Log.e(TAG, "snap right");
          snapToScreen(mCurScreen + 1);
        } else {
          snapToDestination();
        }
        if (mVelocityTracker != null) {
          mVelocityTracker.recycle();
          mVelocityTracker = null;
        }
        // }
        mTouchState = TOUCH_STATE_REST;
        break;
      case MotionEvent.ACTION_CANCEL:
        mTouchState = TOUCH_STATE_REST;
        break;
    }
    return true;
  }

  @Override
  public boolean onInterceptTouchEvent(MotionEvent ev) {
    // Log.e(TAG, "onInterceptTouchEvent-slop:" + mTouchSlop);
    final int action = ev.getAction();
    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:
        final int xDiff = (int) Math.abs(mLastMotionX - x);
        if (xDiff > mTouchSlop) {
          mTouchState = TOUCH_STATE_SCROLLING;
        }
        break;
      case MotionEvent.ACTION_DOWN:
        mLastMotionX = x;
        mLastMotionY = y;
        mTouchState = mScroller.isFinished() ? TOUCH_STATE_REST : TOUCH_STATE_SCROLLING;
        break;
      case MotionEvent.ACTION_CANCEL:
      case MotionEvent.ACTION_UP:
        mTouchState = TOUCH_STATE_REST;
        break;
    }
    return mTouchState != TOUCH_STATE_REST;
  }

  /**
   * 設置屏幕切換監聽器
   * 
   * @param listener
   */
  public void SetOnViewChangeListener(OnViewChangeListener listener) {
    mOnViewChangeListener = listener;
  }

  /**
   * 屏幕切換監聽器
   * 
   * @author liux
   */
  public interface OnViewChangeListener {
    public void OnViewChange(int view);
  }
}

下面我就根據個人理解講述一下整個滑動的過程

首先是整個組建的初始化，調用構造函數（這個就不詳細說了）

調用onMeasure(int widthMeasureSpec, int heightMeasureSpec)函數，循環計算沒一個子View的寬高。

調用onLayout(boolean changed, int l, int t, int r, int b)設置每個子View的佈局

調用onDraw方法開始畫圖。在調用onDraw方法時候會調用computeScroll()方法，假如正在滑動的時候就調用使ViewscrollTo方法滑動，而後調用postInvalidate更新界面。

用戶滑動的時候，會先到用onInterceptTouchEvent(MotionEvent ev)，第一次ACTION_DOWN的時候，onInterceptTouchEvent方法會返回false，表示ViewGroup不攔截這個以後的手勢（即這一系列的手勢會傳到其子View），而後會觸發ScrollLayout的onTouchEvent(MotionEvent event)方法（子View的onTouchEvent均返回false的狀況下）。

onTouchEvent(MotionEvent event)方法中

ACTION_DOWN事件：

記下事件的座標。

ACTION_MOVE事件：

計算滑動的距離，當水平華東大於200,垂直滑動大於10時候組建滑動。

ACTION_UP事件：

使用VelocityTracker計算滑動的速度，當速度大於600 千像素/微秒 時候，根據速度方向滑動。而後註銷VelocityTracker。當速度達不到的時候，調用snapToDestination()方法判斷應該返回到那一個頁面。

參考連接

onMeasure和onLayout：http://blog.csdn.net/czh0766/article/details/5846460

Scroller：http://www.cnblogs.com/over140/archive/2010/12/16/1907528.html，http://ipjmc.iteye.com/blog/1615828

onInterceptTouchEvent和onTouchEvent：http://blog.csdn.net/ddna/article/details/5473293