★理论知识
●View在屏幕上显示出来要先经过measure（计算）和layout（布局）。
◆当控件的父元素正要放置该控件时调用，父元素会问子控件“你想要用多大的地方？”，然后传入两个参数widthMeasureSpec和heightMeasureSpec，这两个参数指明控件可获得的空间以及关于这个空间描述的元数据。
◆更好的方法是你传递View的高度和宽度到setMeasureDimension方法里，这样可以直接告诉父控件需要多大地方放置子控件。
◆示例：
@Override
protected void onMeasure(int widthMeasureSpec,int heightMeasureSpec){int measuredHeight=measureHeight(heightMeasureSpec);int measuredWidth=measureWidth(widthMeasureSpec);setMeasuredDimension(measureHeight,measuredWidth);}private int measureHeight(int measureSpec){//Return measured widget height.int specMode=MeasureSpec.getMode(measureSpec);
int specSize=MeasureSpec.getSize(measureSpec);
int result=0;
if(specMode == MeasureSpec.AT_MOST){
result=specSize;
}else if(specMode==MeasureSpec.EXACTLY){
result=specSize;
}
return result;
}private int measureWidth(int measureSpec){//Return measured widget width.int specMode=MeasureSpec.getMode(measureSpec);
int specSize=MeasureSpec.getSize(measureSpec);
int result=0;
if(specMode == MeasureSpec.AT_MOST){
result=specSize;
}else if(specMode==MeasureSpec.EXACTLY){
result=specSize;
}
return result;
}
边界参数widthMeasureSpec和heightMeasureSpec效率原因以整数的方式传入。在使用之前首先要做的是使用MeasureSpec类的静态方法getMode和getSize来译解。
int specMode=MeasureSpec.getMode(measureSpec);
int specSize=MeasureSpec.getSize(measureSpec);
根据specMode的值（MeasureSpec有3种模式分别是UNSPECIFIED、EXACTLY、AT_MOST）
如果是AT_MOST，specSize代表的是最大可获得的空间
如果是EXACTLY，specSize代表的是精确的尺寸
如果是UNSPECIFIED，对于控件尺寸来说，没有任何参考意义
◆这些模式和设置的layout参数的fill_parent、wrap_content是什么关系呢？
当设置width或height为fill_parent时，容器在布局时调用子view的measure方法，传入的模式是EXACTLY，因为子view会占据剩余容器的空间，所以它大小是确定的。当设置为wrap_content时，容器传进去的是AT_MOST，表示子view的大小最多是多少，这样子view会根据上限来设置自己的尺寸。当子view的大小设置为精确值时，容器传入的是EXACTLY。
●VelocityTracker用来追踪触摸事件（flinging事件和其他手势事件）的速率。
◆用obtain()函数来获得类的实例，用addMovement(MotionEvent)函数将motion event加入到VelocityTracker类实例中，当你使用到速率时，使用computeCurrentVelocity(int)初始化速率的单位，并获得当前的事件的速率，然后使用getXVelocity()或getYVelocity()获得横向和竖向的速率。
◆VelocityTracker.computeCurrentVelocity(int units,float maxVelocity)用来计算已经发生触摸事件点的当前速率。这个函数只有在你需要得到速率消息的情况下才调用，因为使用它需要消耗很大的性能。参数units为速率单位，值为1的意思是以一毫秒运动了多少个像素的速率，1000表示一秒时间内运动了多少个像素。maxVelocity代表这个方法能计算出事件的最大速率，值和units的值具有一样的单位。
◆示例：
private VelocityTracker velocityTracker;
//在onTouchEvent(MotionEvent ev)中
if(velocityTracker==null){
velocityTracker=VelocityTracker.obtain();//获得VelocityTracker类实例
}
velocityTracker.addMovement(ev);//将事件加入到VelocityTracker类实例中
★实现代码：
import java.util.ArrayList;
import java.util.List;
import android.content.Context;
import android.graphics.Canvas;
import android.graphics.Color;
import android.os.Handler;
import android.os.Message;
import android.view.MotionEvent;
import android.view.VelocityTracker;
import android.view.View;
import android.view.ViewConfiguration;
import android.view.ViewGroup;
import android.widget.LinearLayout;
import android.widget.TextView;
public class TouchPageTransfer extends ViewGroup {
/**
* 手势临界速度，当速度超过这个时切换到下一屏
*/
private final static int SNAP_VELOCITY = 100;
/**
* 停止状态
*/
private final static int TOUCH_STATE_REST = 0;
/**
* 滚动状态
*/
private final static int TOUCH_STATE_MOVING = 1;
/**
* 减速停止状态
*/
private final static int TOUCH_STATE_SLOWING = 2;
/**
* 移动的阈值
*/
private static final int TOUCH_SLOP = 10;
private Context context;
/**
* 速度跟踪
*/
private VelocityTracker velocityTracker;
/**
* 速度最大值
*/
private int maximumVelocity;
/**
* 当前触摸状态
*/
private int touchState = TOUCH_STATE_REST;
/**
* 触摸起始点坐标
*/
private float lastMotionX;
private float lastMotionY;
/**
* 是否移动了
*/
private boolean isMoved;
private List<LinearLayout> views;
private LinearLayout view1;
private LinearLayout view2;
private LinearLayout view3;
public TouchPageTransfer(Context context) {
super(context);
// TODO Auto-generated constructor stub
this.context = context;
init();
}
private void init() {
views = new ArrayList<LinearLayout>();
view1 = new LinearLayout(context);
view1.setBackgroundColor(Color.YELLOW);
this.addView(view1);
TextView tv = new TextView(context);
tv.setText("测试");
view1.addView(tv);
views.add(view1);
view2 = new LinearLayout(context);
view2.setBackgroundColor(Color.RED);
this.addView(view2);
views.add(view2);
view3 = new LinearLayout(context);
view3.setBackgroundColor(Color.GREEN);
this.addView(view3);
views.add(view3);
final ViewConfiguration configuration = ViewConfiguration
.get(getContext());
maximumVelocity = configuration.getScaledMaximumFlingVelocity();
}
@Override
protected void onLayout(boolean changed, int l, int t, int r, int b) {
// TODO Auto-generated method stub
int viewLeft = -1;
int count = views.size();
//水平从左到右放置View
for (int i = 0; i < count; i++) {
View view = views.get(i);
if (view.getVisibility() != View.GONE) {//View处于显示状态
int viewWidth = view.getMeasuredWidth();
if (viewLeft == -1) {
viewLeft = -viewWidth;
}
view.layout(viewLeft, 0, viewLeft + viewWidth,
view.getMeasuredHeight());
viewLeft += viewWidth;
}
}
}
@Override
protected void onDraw(Canvas canvas) {
//水平从左到右放置
int count = views.size();
for (int i = 0; i < count; i++) {
View view = views.get(i);
drawChild(canvas, view, getDrawingTime());
}
}
@Override
protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
// TODO Auto-generated method stub
super.onMeasure(widthMeasureSpec, heightMeasureSpec);
int count = views.size();
for (int i = 0; i < count; i++) {
View view = views.get(i);
view.measure(widthMeasureSpec, heightMeasureSpec);
}
}
@Override
public boolean onTouchEvent(MotionEvent event) {
if (velocityTracker == null) {
velocityTracker = VelocityTracker.obtain();
}
velocityTracker.addMovement(event);
int action = event.getAction();
float x = event.getX();
float y = event.getY();
switch (action) {
case MotionEvent.ACTION_DOWN:
if (touchState == TOUCH_STATE_REST) {
//记录按下去的坐标
lastMotionX = x;
lastMotionY = y;
//改变触摸状态
touchState = TOUCH_STATE_MOVING;
isMoved = false;
}
break;
case MotionEvent.ACTION_MOVE:
if (touchState == TOUCH_STATE_MOVING) {
//计算位移量，向左为负，向右为正
float offsetX = x - lastMotionX;
float offsetY = y - lastMotionY;
if (isMoved) {
lastMotionX = x;
lastMotionY = y;
int count = views.size();
for (int i = 0; i < count; i++) {
View view = views.get(i);
if (view.getVisibility() != View.GONE) {//对于显示的View才进行布局
int viewWidth = view.getMeasuredWidth();
int viewLeft = view.getLeft() + (int) offsetX;
view.layout(viewLeft, 0, viewLeft + viewWidth,
view.getMeasuredHeight());
viewLeft += viewWidth;
}
}
} else if (Math.abs(offsetX) > TOUCH_SLOP
|| Math.abs(offsetY) > TOUCH_SLOP) {//移动超过阈值，则表示移动了
isMoved = true;
}
}
break;
case MotionEvent.ACTION_UP:
if (isMoved) {
if (touchState == TOUCH_STATE_MOVING) {
touchState = TOUCH_STATE_SLOWING;
int sign = 0;//标志有足够能力移动的移动方向，向左为1，向右为-1，否则为0
//计算当前速度
velocityTracker.computeCurrentVelocity(1000,
maximumVelocity);
//x方向速度
int velocityX = (int) velocityTracker.getXVelocity();
if (velocityX > SNAP_VELOCITY) {//足够的能力向左
sign = 1;
} else if (velocityX < -SNAP_VELOCITY) {//足够的能力向右
sign = -1;
} else {
sign = 0;
}
moveToFitView(sign);
if (velocityTracker != null) {
velocityTracker.recycle();//回收VelocityTracker对象
velocityTracker = null;
}
}
}
break;
default:
break;
}
return true;
}
/**
* 总的位移量，向右为正，向左为负
*/
int tOffsetX = 0;
private void moveToFitView(int sign) {
swapView(sign);
int left = views.get(1).getLeft();
tOffsetX = 0;
if (left != 0) {
tOffsetX = -left;
}
moveView();
}
FlipAnimationHandler flipAnimationHandler;
int ovv = 40;//每次预期moveView位移量
/**
* 移动View
*/
private void moveView() {
int count = views.size();
if (tOffsetX != 0) {
int ov = 0;//本次moveView位移量，向右为正，向左为负
if (tOffsetX > 0) {//向右
ov = ovv;
} else {//向左
ov = -1 * ovv;
}
ovv -= 3;
if (ovv < 1) {
ovv = 3;
}
if (Math.abs(tOffsetX) < Math.abs(ov)) {//总位移量的绝对值小于本次位移量的绝对值
ov = tOffsetX;
tOffsetX = 0;
} else {
tOffsetX -= ov;
}
//水平从左到右放置
for (int i = 0; i < count; i++) {
View view = views.get(i);
int viewWidth = view.getMeasuredWidth();
int viewLeft = view.getLeft() + ov;
view.layout(viewLeft, 0, viewLeft + viewWidth,
view.getMeasuredHeight());
viewLeft += viewWidth;
}
if (flipAnimationHandler == null) {
flipAnimationHandler = new FlipAnimationHandler();
}
flipAnimationHandler.sleep(1);
} else {
ovv = 40;
touchState = TOUCH_STATE_REST;
}
}
class FlipAnimationHandler extends Handler {
@Override
public void handleMessage(Message msg) {
TouchPageTransfer.this.moveView();//
}
public void sleep(long millis) {
this.removeMessages(0);
sendMessageDelayed(obtainMessage(0), millis);
}
}
/**
* 向左移动时将原来最左边的View移到最右边，向右移动时将原来最右边的View移到最左边，并根据当前其他的View布局移动的这个View
* @param sign 1代表向左移动，-1代表向右移动，0代表不移动
* @return
*/
private boolean swapView(int sign) {
boolean flag = false;
if (sign == -1) {//向左
View view0 = views.get(0);
if (view0.getLeft() <= -1 * view0.getMeasuredWidth()) {
swapViewIndex(sign);
View view1 = views.get(1);
View view2 = views.get(2);
int viewLeft = view1.getLeft() + view1.getMeasuredWidth();
view2.layout(viewLeft, 0, viewLeft + view2.getMeasuredWidth(),
view2.getMeasuredHeight());
flag = true;
}
} else if (sign == 1) {//向右
View view2 = views.get(2);
if (view2.getLeft() >= view2.getMeasuredWidth()) {
swapViewIndex(sign);
View view0 = views.get(0);
View view1 = views.get(1);
int viewLeft = view1.getLeft() - view0.getMeasuredWidth();
view0.layout(viewLeft, 0, viewLeft + view0.getMeasuredWidth(),
view0.getMeasuredHeight());
flag = true;
}
}
return flag;
}
/**
* 向左移动时将原来最左边的View移到最右边，向右移动时将原来最右边的View移到最左边
* @param sign 1代表向左移动，-1代表向右移动，0代表不移动
*/
private void swapViewIndex(int sign) {
if (sign == -1) {//向左
LinearLayout v = views.remove(0);
views.add(v);
} else if (sign == 1) {//向右
LinearLayout v = views.remove(views.size() - 1);
views.add(0, v);
}
}
}