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