网上流传的workspace类的解析

 

几个重要类的解释（每天增加，现在不完整）：

1. Scroller ：该类封装了一个滑动的过程。在构造函数中传递滑动的持续时间以及指定滑动动作可以持续的最大时间。从设计模式上讲，它是一个model类型，也就是，当我们调用它的某个函数(设为afun)来记录我们移动到哪里（此时整个布局并没有实际移动），而在绘图的时候，通过某个函数（设为bfun）根据afun的设置的model来描绘出view现在应该在哪里（其实是将整个viewgroup进行了移动）。这里的afun函数就是Scroller的startScroll()函数，而bfun就是view类中有的computeScroll()函数（看下面的代码，它内部调用scrollTo函数来实现实际移动），从它的doc可以看出，我们可以把它看成是专门为view类移动而设计的函数。当我们重载了computeScroll时，系统就会在重绘时调用该函数。这里有个问题就是每次computeScroll时，是一次性的到达原先指定的目的还是分多次的进行调用？显然，为了达到一个“动画”的过程，就好像我一次向左移动x个px，分n次完成，这样就出现了一个速度，有了速度，我们才能看见有“移动”的效果。这个速度就是根据Scroller的computeScrollOffset()函数算出来的，也就是每次我们要移动整个视图到哪里时，都通过先调用该方法来计算，然后调用Scroller的getCurrX()和getCurrY()明确此次的目标，而Scroller的状态isFinshed()函数将返回false，直到getCurrX()和getCurrY()返回的值是通过startScroll设置的值，此时isFinshed()返回true。还有，当我们在两次computeScroll()之间调用了或者发生了startScroll时，将会产生新的移动方案，也就是原来的方案将会被覆盖而使用新的移动方案。
2. ViewConfiguration类： View类及子类的配置信息（所以有很多静态函数）：
   包含给Ui使用的标准静态函数及函数，比如超时、大小和距离。比如，长按（LongPressed）的标准是多少毫秒才算，两次tap的间隔多长才算作是两次的tap。
   使用ViewConfiguration.get(context)来获取该实例对象。
   方法列举：
   getScaledTouchSlop()返回对一个视图touch时应该忽略的最小移动像素。因为即使你是tap，也可能造成移动了几个像素，那么这里将定义移动了大于该函数返回值的像素点数才被定义为移动操作。

修剪后的源代码如下：

package cn.anycall.ju;

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

/**
* 仿Launcher中的WorkSapce，可以左右滑动切换屏幕的类
* 
*/
public class ScrollLayout extends ViewGroup {

private static final String TAG = "ScrollLayout";
private Scroller mScroller;//滚动封装类
private VelocityTracker mVelocityTracker;//测量touch事件的触发速度

private int mCurScreen;//当前屏幕
private int mDefaultScreen = 0;//默认屏幕

private static final int TOUCH_STATE_REST = 0;//TOUCH状态为静止
private static final int TOUCH_STATE_SCROLLING = 1;//TOUCH状态为滚动

private static final int SNAP_VELOCITY = 600;//瞬时速度

private int mTouchState = TOUCH_STATE_REST;//当前状态
private int mTouchSlop;
private float mLastMotionX;//最终的X方向坐标
private float mLastMotionY;//最终的Y方向坐标

private int currentScreenIndex = 0;//当前屏幕索引值

public int getCurrentScreenIndex() {
return currentScreenIndex;
}

public void setCurrentScreenIndex(int currentScreenIndex) {
this.currentScreenIndex = currentScreenIndex;
}

public ScrollLayout(Context context, AttributeSet attrs) {
this(context, attrs, 0);
// TODO Auto-generated constructor stub
}

public ScrollLayout(Context context, AttributeSet attrs, int defStyle) {
super(context, attrs, defStyle);
// TODO Auto-generated constructor stub
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) {
// TODO Auto-generated method stub
int childLeft = 0;
final int childCount = getChildCount();
System.out.println("childCount=" + childCount);
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);
}
System.out.println("moving to screen " + mCurScreen);
scrollTo(mCurScreen * width, 0);//移动到当前屏幕，屏幕index*屏幕宽
}

/**
* 拖动移动（非快速移动）
* According to the position of current layout scroll to the destination
* page.getScrollX返回值即为拖动以后停留的位置，通过该位置与屏幕宽度相除就可以确定该位置在哪一页，
* 若在该基础上添加半页的大小，再舍去小数，就可以确定是停留在原来页还是向左或则右移动到邻居页
*/
public void snapToDestination() {
final int screenWidth = getWidth();
int sx=getScrollX();
final int destScreen = (sx + screenWidth / 2) / screenWidth;//添加半块屏幕的大小，使得滑动超过半块屏幕算一块，少于半块则回至原处
snapToScreen(destScreen);
}
/**
* 封装scroller的startScroll来实现
* @param whichScreen
*/
public void snapToScreen(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) * 2);//相当于移动一个像素点要2毫秒
mCurScreen = whichScreen;
invalidate(); // Redraw the layout
}
}

public void setToScreen(int whichScreen) {//直接滑动一个屏幕
whichScreen = Math.max(0, Math.min(whichScreen, getChildCount() - 1));
mCurScreen = whichScreen;
scrollTo(whichScreen * getWidth(), 0);
}

public int getCurScreen() {
return mCurScreen;
}

@Override
public void computeScroll() {
// TODO Auto-generated method stub
if (mScroller.computeScrollOffset()) {
scrollTo(mScroller.getCurrX(), mScroller.getCurrY());
postInvalidate();
}
}

@Override
public boolean onTouchEvent(MotionEvent event) {
// TODO Auto-generated method stub

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;
break;

case MotionEvent.ACTION_MOVE:
int deltaX = (int) (mLastMotionX - x);
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");
onScreenChangeListener.onScreenChange(mCurScreen - 1);
System.out.println("mCurScreen=" + (mCurScreen - 1));
snapToScreen(mCurScreen - 1);
} else if (velocityX < -SNAP_VELOCITY
&& mCurScreen < getChildCount() - 1) {
// Fling enough to move right
Log.e(TAG, "snap right");
onScreenChangeListener.onScreenChange(mCurScreen + 1);
//只往右移动才加载数据
onScreenChangeListenerDataLoad.onScreenChange(mCurScreen+1);
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;
}
//截获（返回true）所有事件，当当前状态是滑动状态时，在此截获将会使事件停留在该viewgroup中被处理
//否则将被传递到下一个viewgroup中处理。
@Override
public boolean onInterceptTouchEvent(MotionEvent ev) {
// TODO Auto-generated method stub
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;
}

//分页监听
public interface OnScreenChangeListener {
void onScreenChange(int currentIndex);
}

private OnScreenChangeListener onScreenChangeListener;

public void setOnScreenChangeListener(
OnScreenChangeListener onScreenChangeListener) {
this.onScreenChangeListener = onScreenChangeListener;
}


//动态数据监听
public interface OnScreenChangeListenerDataLoad {
void onScreenChange(int currentIndex);
}
private OnScreenChangeListenerDataLoad onScreenChangeListenerDataLoad;

public void setOnScreenChangeListenerDataLoad(OnScreenChangeListenerDataLoad onScreenChangeListenerDataLoad) {
this.onScreenChangeListenerDataLoad = onScreenChangeListenerDataLoad;
}

}