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

转载于:https://my.oschina.net/zlLeaf/blog/161334