人生得意须尽欢，
桃花坞里桃花庵。
对于ViewPager 其实本来没啥事也不想研究它的，无奈最近在开发一款宇宙无敌吊炸天的控件 《开发一款商业级Banner控件》时碰到了一些天坑，强大的google和度娘没能解决我的问题，怀着不怪网上连能人少，只恨问题太奇葩 沉痛的心情，只有自己对着 ViewPager源码撸一发了。
本文遵循以下节点 依次展开内容。
1、测量 onMeasure
自定义View三部曲 ，那自然是onMeasure了；
protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
// 没有指定的情况下宽高为0 ;
setMeasuredDimension(getDefaultSize(0, widthMeasureSpec),
getDefaultSize(0, heightMeasureSpec));
...
// 得到可用空间
int childWidthSize = measuredWidth - getPaddingLeft() - getPaddingRight();
int childHeightSize = getMeasuredHeight() - getPaddingTop() - getPaddingBottom();
// 得到孩子总数量 遍历
int size = getChildCount();
for (int i = 0; i < size; ++i) {
final View child = getChildAt(i);
if (child.getVisibility() != GONE) { //如果属性不为GONE
final LayoutParams lp = (LayoutParams) child.getLayoutParams();
//如果是装饰view
if (lp != null && lp.isDecor) {
//得到重力位置
final int hgrav = lp.gravity & Gravity.HORIZONTAL_GRAVITY_MASK;
final int vgrav = lp.gravity & Gravity.VERTICAL_GRAVITY_MASK;
int widthMode = MeasureSpec.AT_MOST; //默认测量模式
int heightMode = MeasureSpec.AT_MOST;//默认测量模式
// 计算是否消费 纵向 空间
boolean consumeVertical = vgrav == Gravity.TOP || vgrav == Gravity.BOTTOM;
//计算是否消费 横向 空间
boolean consumeHorizontal = hgrav == Gravity.LEFT || hgrav == Gravity.RIGHT;
// 设置测量模式
if (consumeVertical) {
widthMode = MeasureSpec.EXACTLY;
} else if (consumeHorizontal) {
heightMode = MeasureSpec.EXACTLY;
}
// 父类最大可提供的大小
int widthSize = childWidthSize;
int heightSize = childHeightSize;
//计算测量模式 与 父类可提供的大小
if (lp.width != LayoutParams.WRAP_CONTENT) {
// 测量模式为 EXACTLY
widthMode = MeasureSpec.EXACTLY;
//如果width为 match_parent
if (lp.width != LayoutParams.MATCH_PARENT) {
//测量宽度就等于 实际设置的宽度
widthSize = lp.width;
}
}
//与上面 width 测量类似
if (lp.height != LayoutParams.WRAP_CONTENT) {
heightMode = MeasureSpec.EXACTLY;
if (lp.height != LayoutParams.MATCH_PARENT) {
heightSize = lp.height;
}
}
//通过makeMeasureSpec方法 合成测量规格
final int widthSpec = MeasureSpec.makeMeasureSpec(widthSize, widthMode);
final int heightSpec = MeasureSpec.makeMeasureSpec(heightSize, heightMode);
// 调用child.measure方法
child.measure(widthSpec, heightSpec);
// 如果被消费，那么可用空间减去消费掉的空间
if (consumeVertical) {
childHeightSize -= child.getMeasuredHeight();
} else if (consumeHorizontal) {
childWidthSize -= child.getMeasuredWidth();
}
}
}
}
// 合成测量规格
mChildWidthMeasureSpec = MeasureSpec.makeMeasureSpec(childWidthSize, MeasureSpec.EXACTLY);
mChildHeightMeasureSpec = MeasureSpec.makeMeasureSpec(childHeightSize, MeasureSpec.EXACTLY);
mInLayout = true;
//这个方法很厉害
populate();
mInLayout = false;
// 遍历孩子VIew
size = getChildCount();
for (int i = 0; i < size; ++i) {
final View child = getChildAt(i);
if (child.getVisibility() != GONE) {
if (DEBUG) {
Log.v(TAG, "Measuring #" + i + " " + child + ": " + mChildWidthMeasureSpec);
}
final LayoutParams lp = (LayoutParams) child.getLayoutParams();
if (lp == null || !lp.isDecor) {
//做成新的规格 其中宽度=childWidthSize * lp.widthFactor
final int widthSpec = MeasureSpec.makeMeasureSpec(
(int) (childWidthSize * lp.widthFactor), MeasureSpec.EXACTLY);
//调用孩子的 measure 方法
child.measure(widthSpec, mChildHeightMeasureSpec);
}
}
}
}
1、可以看到就是先是给自己设定了大小；其中用了getDefaultSize方法，所以我们给viewPager设置的 wrap_content最终还是 match_parent的效果；
2、然后就是遍历所有的装饰view 测量它们的大小 与 计算它们消耗的空间，与计算剩余空间；
3、调用populate方法
4、测量孩子； 其中给孩子的宽度为 剩余宽度*lp.widthFactor也是这段代码final int widthSpec = MeasureSpec.makeMeasureSpec( (int) (childWidthSize * lp.widthFactor), MeasureSpec.EXACTLY);
populate
那我们再来看一下 populate 吧
populate 顾名思义 填充的意思。
void populate() {
// 将当前选中position放入
populate(mCurItem);
}
void populate(int newCurrentItem) {
// 旧的选中的 ItemInfo
ItemInfo oldCurInfo = null;
if (mCurItem != newCurrentItem) {
//infoForPosition方法得到 旧 ItemInfo
oldCurInfo = infoForPosition(mCurItem);
mCurItem = newCurrentItem;
}
if (mAdapter == null) {
//排序绘制view的顺序
sortChildDrawingOrder();
return;
}
// Bail now if we are waiting to populate. This is to hold off
// on creating views from the time the user releases their finger to
// fling to a new position until we have finished the scroll to
// that position, avoiding glitches from happening at that point.
// 如果是在等待填充 的时候，，解释是说为了避免 在用户释放手指之前创建view
if (mPopulatePending) {
if (DEBUG) Log.i(TAG, "populate is pending, skipping for now...");
sortChildDrawingOrder();
return;
}
// 不在window中时
if (getWindowToken() == null) {
return;
}
// 调用 startUpdate 方法
mAdapter.startUpdate(this);
//页的限制
final int pageLimit = mOffscreenPageLimit;
//开始页
final int startPos = Math.max(0, mCurItem - pageLimit);
//总数
final int N = mAdapter.getCount();
// 结束页
final int endPos = Math.min(N - 1, mCurItem + pageLimit);
// 如果预期数量不一致
if (N != mExpectedAdapterCount) {
String resName;
try {
//得到资源名称
resName = getResources().getResourceName(getId());
} catch (Resources.NotFoundException e) {
resName = Integer.toHexString(getId());
}
throw new IllegalStateException("The application's PagerAdapter changed the adapter's"
+ " contents without calling PagerAdapter#notifyDataSetChanged!"
+ " Expected adapter item count: " + mExpectedAdapterCount + ", found: " + N
+ " Pager id: " + resName
+ " Pager class: " + getClass()
+ " Problematic adapter: " + mAdapter.getClass());
}
// Locate the currently focused item or add it if needed.
int curIndex = -1;
ItemInfo curItem = null;
for (curIndex = 0; curIndex < mItems.size(); curIndex++) {
//得到当前 ItemInfo
final ItemInfo ii = mItems.get(curIndex);
//如果 position 大于 mCurItem
if (ii.position >= mCurItem) {
// cutlItem=ii
if (ii.position == mCurItem) curItem = ii;
break;
}
}
// 如果等于空 添加
if (curItem == null && N > 0) {
curItem = addNewItem(mCurItem, curIndex);
}
// 如果 curItem 不为空
if (curItem != null) {
float extraWidthLeft = 0.f;
//-1
int itemIndex = curIndex - 1;
//ii 如果itemIndex 大于 0 取出，否则null
ItemInfo ii = itemIndex >= 0 ? mItems.get(itemIndex) : null;
//得到可用宽度
final int clientWidth = getClientWidth();
// 计算左边需要的宽度
final float leftWidthNeeded = clientWidth <= 0 ? 0 :
2.f - curItem.widthFactor + (float) getPaddingLeft() / (float) clientWidth;
// 从'选中的下标-1' --> 0 遍历
for (int pos = mCurItem - 1; pos >= 0; pos--) {
//如果额外的 大于 需要的 和 pos 小于 startPos
if (extraWidthLeft >= leftWidthNeeded && pos < startPos) {
if (ii == null) {
break;
}
// 移除
if (pos == ii.position && !ii.scrolling) {
mItems.remove(itemIndex);
mAdapter.destroyItem(this, pos, ii.object);
if (DEBUG) {
Log.i(TAG, "populate() - destroyItem() with pos: " + pos
+ " view: " + ((View) ii.object));
}
itemIndex--;
curIndex--;
ii = itemIndex >= 0 ? mItems.get(itemIndex) : null;
}
} else if (ii != null && pos == ii.position) { // 如果选中的上一个有 infoItem
// extraWidthLeft 加上 ii.widthFactor
extraWidthLeft += ii.widthFactor;
itemIndex--;
//拿上一个 infoItem
ii = itemIndex >= 0 ? mItems.get(itemIndex) : null;
} else {
// 新增一个 INfoItem
ii = addNewItem(pos, itemIndex + 1);
// 将占用的宽度比例加进来
extraWidthLeft += ii.widthFactor;
curIndex++;
ii = itemIndex >= 0 ? mItems.get(itemIndex) : null;
}
}
// 右边消耗的比例
float extraWidthRight = curItem.widthFactor;
//右边index
itemIndex = curIndex + 1;
if (extraWidthRight < 2.f) {
ii = itemIndex < mItems.size() ? mItems.get(itemIndex) : null;
// 計算右边需要的宽度
final float rightWidthNeeded = clientWidth <= 0 ? 0 :
(float) getPaddingRight() / (float) clientWidth + 2.f;
for (int pos = mCurItem + 1; pos < N; pos++) {
// 如果 pos大于 endPos
if (extraWidthRight >= rightWidthNeeded && pos > endPos) {
if (ii == null) {
break;
}
//移除
if (pos == ii.position && !ii.scrolling) {
mItems.remove(itemIndex);
mAdapter.destroyItem(this, pos, ii.object);
if (DEBUG) {
Log.i(TAG, "populate() - destroyItem() with pos: " + pos
+ " view: " + ((View) ii.object));
}
ii = itemIndex < mItems.size() ? mItems.get(itemIndex) : null;
}
} else if (ii != null && pos == ii.position) {
// 相等 那么取出数据
extraWidthRight += ii.widthFactor;
itemIndex++;
ii = itemIndex < mItems.size() ? mItems.get(itemIndex) : null;
} else {
// 否则 新建 infoItem
ii = addNewItem(pos, itemIndex);
itemIndex++;
extraWidthRight += ii.widthFactor;
ii = itemIndex < mItems.size() ? mItems.get(itemIndex) : null;
}
}
}
// 计算偏移量
calculatePageOffsets(curItem, curIndex, oldCurInfo);
}
if (DEBUG) {
Log.i(TAG, "Current page list:");
for (int i = 0; i < mItems.size(); i++) {
Log.i(TAG, "#" + i + ": page " + mItems.get(i).position);
}
}
// 通知适配器 哪个个是主页
mAdapter.setPrimaryItem(this, mCurItem, curItem != null ? curItem.object : null);
// 结束更新
mAdapter.finishUpdate(this);
// Check width measurement of current pages and drawing sort order.
// Update LayoutParams as needed.
final int childCount = getChildCount();
// 遍历view
for (int i = 0; i < childCount; i++) {
final View child = getChildAt(i);
final LayoutParams lp = (LayoutParams) child.getLayoutParams();
lp.childIndex = i;
if (!lp.isDecor && lp.widthFactor == 0.f) {
// 0 means requery the adapter for this, it doesn't have a valid width.
final ItemInfo ii = infoForChild(child);
if (ii != null) {
// 设置属性
lp.widthFactor = ii.widthFactor;
lp.position = ii.position;
}
}
}
//排序
sortChildDrawingOrder();
if (hasFocus()) {
View currentFocused = findFocus();
ItemInfo ii = currentFocused != null ? infoForAnyChild(currentFocused) : null;
if (ii == null || ii.position != mCurItem) {
for (int i = 0; i < getChildCount(); i++) {
View child = getChildAt(i);
ii = infoForChild(child);
//如果拿到当前view
if (ii != null && ii.position == mCurItem) {
//设置聚焦
if (child.requestFocus(View.FOCUS_FORWARD)) {
break;
}
}
}
}
}
}
populate的作用：
通过当前选中项， 移除两边 不需要的 view以及 infoItem；
通过选中项，创建需要view 以及 infoItem；
计算设置view的偏移量信息（计算位置放入 infoItem）；
设置聚焦当前选中项child.requestFocus(View.FOCUS_FORWARD)(焦点转移处理);
2、布局 onLayout()
protected void onLayout(boolean changed, int l, int t, int r, int b) {
// 拿到和计算各种变量 ，相信大家能看懂
final int count = getChildCount();
int width = r - l;
int height = b - t;
int paddingLeft = getPaddingLeft();
int paddingTop = getPaddingTop();
int paddingRight = getPaddingRight();
int paddingBottom = getPaddingBottom();
final int scrollX = getScrollX();
// 装饰view的数量
int decorCount = 0;
//遍历
for (int i = 0; i < count; i++) {
final View child = getChildAt(i);
// 设置不为GONE
if (child.getVisibility() != GONE) {
//拿到布局参数
final LayoutParams lp = (LayoutParams) child.getLayoutParams();
int childLeft = 0;
int childTop = 0;
//如果是装饰布局
if (lp.isDecor) {
//得到重力方向
final int hgrav = lp.gravity & Gravity.HORIZONTAL_GRAVITY_MASK;
final int vgrav = lp.gravity & Gravity.VERTICAL_GRAVITY_MASK;
//根据重力的方向 计算位置
switch (hgrav) {
default:
childLeft = paddingLeft;
break;
case Gravity.LEFT:
childLeft = paddingLeft;
paddingLeft += child.getMeasuredWidth();
break;
case Gravity.CENTER_HORIZONTAL:
childLeft = Math.max((width - child.getMeasuredWidth()) / 2,
paddingLeft);
break;
case Gravity.RIGHT:
childLeft = width - paddingRight - child.getMeasuredWidth();
paddingRight += child.getMeasuredWidth();
break;
}
switch (vgrav) {
default:
childTop = paddingTop;
break;
case Gravity.TOP:
childTop = paddingTop;
paddingTop += child.getMeasuredHeight();
break;
case Gravity.CENTER_VERTICAL:
childTop = Math.max((height - child.getMeasuredHeight()) / 2,
paddingTop);
break;
case Gravity.BOTTOM:
childTop = height - paddingBottom - child.getMeasuredHeight();
paddingBottom += child.getMeasuredHeight();
break;
}
//加上偏移量
childLeft += scrollX;
//布局装饰视图
child.layout(childLeft, childTop,
childLeft + child.getMeasuredWidth(),
childTop + child.getMeasuredHeight());
decorCount++;
}
}
}
//最终可用的宽度
final int childWidth = width - paddingLeft - paddingRight;
//遍历
for (int i = 0; i < count; i++) {
final View child = getChildAt(i);
//如果不为空
if (child.getVisibility() != GONE) {
final LayoutParams lp = (LayoutParams) child.getLayoutParams();
ItemInfo ii;
//如果不为装饰，以及 infoForChild方法不为空
if (!lp.isDecor && (ii = infoForChild(child)) != null) {
// 偏移
int loff = (int) (childWidth * ii.offset);
//计算左边距 上边距
int childLeft = paddingLeft + loff;
int childTop = paddingTop;
// 如果需要测量
if (lp.needsMeasure) {
//测量一遍
lp.needsMeasure = false;
final int widthSpec = MeasureSpec.makeMeasureSpec(
(int) (childWidth * lp.widthFactor),
MeasureSpec.EXACTLY);
final int heightSpec = MeasureSpec.makeMeasureSpec(
(int) (height - paddingTop - paddingBottom),
MeasureSpec.EXACTLY);
child.measure(widthSpec, heightSpec);
}
if (DEBUG) {
Log.v(TAG, "Positioning #" + i + " " + child + " f=" + ii.object
+ ":" + childLeft + "," + childTop + " " + child.getMeasuredWidth()
+ "x" + child.getMeasuredHeight());
}
//布局
child.layout(childLeft, childTop,
childLeft + child.getMeasuredWidth(),
childTop + child.getMeasuredHeight());
}
}
}
//上边距位置
mTopPageBounds = paddingTop;
// 下临界点位置
mBottomPageBounds = height - paddingBottom;
mDecorChildCount = decorCount;
if (mFirstLayout) {
// 滑动至当前页面
scrollToItem(mCurItem, false, 0, false);
}
mFirstLayout = false;
}
布局做了以下这些事：
布局装饰视图，并消耗一定的空间；
在剩余空间中布局view； 而我们的view的布局位置 与 ItemInfo.offset 有关。
3、setAdapter
public void setAdapter(PagerAdapter adapter) {
//如果不为空
if (mAdapter != null) {
//移除监听
mAdapter.setViewPagerObserver(null);
// 调用 startUpdate方法
mAdapter.startUpdate(this);
for (int i = 0; i < mItems.size(); i++) {
// 所有都移除掉
final ItemInfo ii = mItems.get(i);
mAdapter.destroyItem(this, ii.position, ii.object);
}
mAdapter.finishUpdate(this);
//清除
mItems.clear();
// 移除所有非 装饰的 view
removeNonDecorViews();
mCurItem = 0;
//滑动至 0,0
scrollTo(0, 0);
}
//赋值
final PagerAdapter oldAdapter = mAdapter;
mAdapter = adapter;
// 支持的数量置为零
mExpectedAdapterCount = 0;
if (mAdapter != null) {·
//初始化 观察者
if (mObserver == null) {
mObserver = new PagerObserver();
}
//设置监听
mAdapter.setViewPagerObserver(mObserver);
// 支持填充
mPopulatePending = false;
final boolean wasFirstLayout = mFirstLayout;
mFirstLayout = true;
//数量
mExpectedAdapterCount = mAdapter.getCount();
// mRestoredCurItem >=0
if (mRestoredCurItem >= 0) {
//调用适配器 回复状态方法
mAdapter.restoreState(mRestoredAdapterState, mRestoredClassLoader);
//设置当前item
setCurrentItemInternal(mRestoredCurItem, false, true);
mRestoredCurItem = -1;
mRestoredAdapterState = null;
mRestoredClassLoader = null;
//如果不是第一次布局
} else if (!wasFirstLayout) {
// 填充
populate();
} else {
//重新布局
requestLayout();
}
}
// 分发一些改变给 监听者
if (mAdapterChangeListeners != null && !mAdapterChangeListeners.isEmpty()) {
for (int i = 0, count = mAdapterChangeListeners.size(); i < count; i++) {
mAdapterChangeListeners.get(i).onAdapterChanged(this, oldAdapter, adapter);
}
}
}
setAdapter先是判断 是否有旧适配器；移除旧适配器，view，监听等等。
存放新的adapter,设置新的监听；
如果非第一次布局 那么调用populate
4、手势 Gesture , touch
手势呢 是一个比较难得点。 我们想要搞懂的是：
- 它是如何根据手势来滑动的；
- 在手势过程中 加载 view的流程是怎么样的；
@Override
public boolean onInterceptTouchEvent(MotionEvent ev) {
//拿到手势事件
final int action = ev.getAction() & MotionEventCompat.ACTION_MASK;
// Always take care of the touch gesture being complete.
if (action == MotionEvent.ACTION_CANCEL || action == MotionEvent.ACTION_UP) {
// Release the drag.
if (DEBUG) Log.v(TAG, "Intercept done!");
//重设触摸
resetTouch();
return false;
}
// Nothing more to do here if we have decided whether or not we
// are dragging.
if (action != MotionEvent.ACTION_DOWN) {
//是否开始拖拽
if (mIsBeingDragged) {
if (DEBUG) Log.v(TAG, "Intercept returning true!");
return true;
}
// 如果不能拖
if (mIsUnableToDrag) {
if (DEBUG) Log.v(TAG, "Intercept returning false!");
return false;
}
}
switch (action) {
case MotionEvent.ACTION_MOVE: {
/*
* mIsBeingDragged == false, otherwise the shortcut would have caught it. Check
* whether the user has moved far enough from his original down touch.
*/
/*
* Locally do absolute value. mLastMotionY is set to the y value
* of the down event.
*/
//手势点
final int activePointerId = mActivePointerId;
if (activePointerId == INVALID_POINTER) {
// If we don't have a valid id, the touch down wasn't on content.
break;
}
//得到该触摸点的下标
final int pointerIndex = ev.findPointerIndex(activePointerId);
// 得到该触摸点的 x
final float x = ev.getX(pointerIndex);
// 相对值
final float dx = x - mLastMotionX;
final float xDiff = Math.abs(dx);
final float y = ev.getY(pointerIndex);
final float yDiff = Math.abs(y - mInitialMotionY);
if (DEBUG) Log.v(TAG, "Moved x to " + x + "," + y + " diff=" + xDiff + "," + yDiff);
//判断子view是否有滑动动作
if (dx != 0 && !isGutterDrag(mLastMotionX, dx)
&& canScroll(this, false, (int) dx, (int) x, (int) y)) {
// Nested view has scrollable area under this point. Let it be handled there.
mLastMotionX = x;
mLastMotionY = y;
mIsUnableToDrag = true;
return false;
}
// 偏移量大于最小滑动距离
if (xDiff > mTouchSlop && xDiff * 0.5f > yDiff) {
if (DEBUG) Log.v(TAG, "Starting drag!");
// 开始拖拽
mIsBeingDragged = true;
// 通知父view不要拦截
requestParentDisallowInterceptTouchEvent(true);
// 设置滑动状态
setScrollState(SCROLL_STATE_DRAGGING);
// 设置最后坐标
mLastMotionX = dx > 0
? mInitialMotionX + mTouchSlop : mInitialMotionX - mTouchSlop;
mLastMotionY = y;
setScrollingCacheEnabled(true);
} else if (yDiff > mTouchSlop) {
// The finger has moved enough in the vertical
// direction to be counted as a drag... abort
// any attempt to drag horizontally, to work correctly
// with children that have scrolling containers.
if (DEBUG) Log.v(TAG, "Starting unable to drag!");
mIsUnableToDrag = true;
}
if (mIsBeingDragged) {
// Scroll to follow the motion event
// 执行滑动且 计算是否需要 刷新界面
if (performDrag(x)) {
ViewCompat.postInvalidateOnAnimation(this);
}
}
break;
}
case MotionEvent.ACTION_DOWN: {
/*
* Remember location of down touch.
* ACTION_DOWN always refers to pointer index 0.
*/
mLastMotionX = mInitialMotionX = ev.getX();
mLastMotionY = mInitialMotionY = ev.getY();
// 设置触摸标识id
mActivePointerId = ev.getPointerId(0);
mIsUnableToDrag = false;
mIsScrollStarted = true;
//
mScroller.computeScrollOffset();
// 如果状态==SCROLL_STATE_SETTLING 和 预估的滑动绝对值大于mCloseEnough
if (mScrollState == SCROLL_STATE_SETTLING
&& Math.abs(mScroller.getFinalX() - mScroller.getCurrX()) > mCloseEnough) {
// 中止scroller的动画
mScroller.abortAnimation();
// 设置是否等待填充
mPopulatePending = false;
// 填充
populate();
// 开始拖拽
mIsBeingDragged = true;
requestParentDisallowInterceptTouchEvent(true);
// 设置滑动属性
setScrollState(SCROLL_STATE_DRAGGING);
} else {
// 完成滑动？
completeScroll(false);
mIsBeingDragged = false;
}
if (DEBUG) {
Log.v(TAG, "Down at " + mLastMotionX + "," + mLastMotionY
+ " mIsBeingDragged=" + mIsBeingDragged
+ "mIsUnableToDrag=" + mIsUnableToDrag);
}
break;
}
case MotionEventCompat.ACTION_POINTER_UP:
//触摸抬起
onSecondaryPointerUp(ev);
break;
}
if (mVelocityTracker == null) {
// 得到新的 速度追踪
mVelocityTracker = VelocityTracker.obtain();
}
// 加入
mVelocityTracker.addMovement(ev);
/*
* The only time we want to intercept motion events is if we are in the
* drag mode.
*/
return mIsBeingDragged;
}
@Override
public boolean onTouchEvent(MotionEvent ev) {
if (mFakeDragging) {
// A fake drag is in progress already, ignore this real one
// but still eat the touch events.
// (It is likely that the user is multi-touching the screen.)
return true;
}
//判断是不在边缘
if (ev.getAction() == MotionEvent.ACTION_DOWN && ev.getEdgeFlags() != 0) {
// Don't handle edge touches immediately -- they may actually belong to one of our
// descendants.
return false;
}
//适配器为空
if (mAdapter == null || mAdapter.getCount() == 0) {
// Nothing to present or scroll; nothing to touch.
return false;
}
//速度追踪器
if (mVelocityTracker == null) {
mVelocityTracker = VelocityTracker.obtain();
}
mVelocityTracker.addMovement(ev);
final int action = ev.getAction();
boolean needsInvalidate = false;
//区分行为
switch (action & MotionEventCompat.ACTION_MASK) {
case MotionEvent.ACTION_DOWN: {
//中止滑动
mScroller.abortAnimation();
mPopulatePending = false;
//填充
populate();
// Remember where the motion event started
mLastMotionX = mInitialMotionX = ev.getX();
mLastMotionY = mInitialMotionY = ev.getY();
mActivePointerId = ev.getPointerId(0);
break;
}
case MotionEvent.ACTION_MOVE:
//如果还没有开始拖拽
if (!mIsBeingDragged) {
final int pointerIndex = ev.findPointerIndex(mActivePointerId);
if (pointerIndex == -1) {
// A child has consumed some touch events and put us into an inconsistent
// state.
needsInvalidate = resetTouch();
break;
}
final float x = ev.getX(pointerIndex);
final float xDiff = Math.abs(x - mLastMotionX);
final float y = ev.getY(pointerIndex);
final float yDiff = Math.abs(y - mLastMotionY);
if (DEBUG) {
Log.v(TAG, "Moved x to " + x + "," + y + " diff=" + xDiff + "," + yDiff);
}
//如果满足拖拽条件
if (xDiff > mTouchSlop && xDiff > yDiff) {
if (DEBUG) Log.v(TAG, "Starting drag!");
// 设置为true
mIsBeingDragged = true;
// 请求父布局不允许拦截
requestParentDisallowInterceptTouchEvent(true);
mLastMotionX = x - mInitialMotionX > 0 ? mInitialMotionX + mTouchSlop :
mInitialMotionX - mTouchSlop;
mLastMotionY = y;
setScrollState(SCROLL_STATE_DRAGGING);
setScrollingCacheEnabled(true);
// Disallow Parent Intercept, just in case
ViewParent parent = getParent();
if (parent != null) {
// 请求父布局不允许拦截
parent.requestDisallowInterceptTouchEvent(true);
}
}
}
// Not else! Note that mIsBeingDragged can be set above.
if (mIsBeingDragged) {
// Scroll to follow the motion event
final int activePointerIndex = ev.findPointerIndex(mActivePointerId);
final float x = ev.getX(activePointerIndex);
//或运算 ， 执行拖拽
needsInvalidate |= performDrag(x);
}
break;
case MotionEvent.ACTION_UP:
// 拖拽
if (mIsBeingDragged) {
final VelocityTracker velocityTracker = mVelocityTracker;
// 计算滑动速度
velocityTracker.computeCurrentVelocity(1000, mMaximumVelocity);
//得到初始速度
int initialVelocity = (int) VelocityTrackerCompat.getXVelocity(
velocityTracker, mActivePointerId);
mPopulatePending = true;
// 空间
final int width = getClientWidth();
//滑动距离
final int scrollX = getScrollX();
// 得到当前滑动的 ItemInfo
final ItemInfo ii = infoForCurrentScrollPosition();
// margin偏移
final float marginOffset = (float) mPageMargin / width;
// 得到当前页下标
final int currentPage = ii.position;
// 计算偏移量
final float pageOffset = (((float) scrollX / width) - ii.offset)
/ (ii.widthFactor + marginOffset);
final int activePointerIndex = ev.findPointerIndex(mActivePointerId);
final float x = ev.getX(activePointerIndex);
final int totalDelta = (int) (x - mInitialMotionX);
// 确定下一个目标oage
int nextPage = determineTargetPage(currentPage, pageOffset, initialVelocity,
totalDelta);
//滑动至下一个page 并且带有速度的滑动
setCurrentItemInternal(nextPage, true, true, initialVelocity);
//判断是否刷新
needsInvalidate = resetTouch();
}
break;
case MotionEvent.ACTION_CANCEL:
if (mIsBeingDragged) {
//滑到当前页
scrollToItem(mCurItem, true, 0, false);
needsInvalidate = resetTouch();
}
break;
case MotionEventCompat.ACTION_POINTER_DOWN: {
final int index = MotionEventCompat.getActionIndex(ev);
final float x = ev.getX(index);
mLastMotionX = x;
mActivePointerId = ev.getPointerId(index);
break;
}
case MotionEventCompat.ACTION_POINTER_UP:
//抬起第二根手指
onSecondaryPointerUp(ev);
mLastMotionX = ev.getX(ev.findPointerIndex(mActivePointerId));
break;
}
if (needsInvalidate) {
ViewCompat.postInvalidateOnAnimation(this);
}
return true;
}
先还是捋一下这个流程：
onInterceptTouchEvent
1、如果是行为是ACTION_CANCEL或者是ACTION_UP那么就重置触摸resetTouch()并且不拦截事件；
2、如果行为不是ACTION_DOWN判断 如果mIsBeingDragged已经开始拖拽了 那么返回true，如果mIsUnableToDrag返回 false；
3、在行为是ACTION_MOVE的时候：等到当前触摸点的各种信息，计算偏移量，如果子布局自身也是当前可滑动的canScroll()返回true那么不拦截事件；
4、在行为是ACTION_MOVE的时候：通过偏移量计算滑动方向，如果是横向滑动 将mIsBeingDragged置为true代表开始拖拽了，并且通过requestParentDisallowInterceptTouchEvent(true);通知副布局不要拦截事件； 如果认为是纵向滑动，那么将mIsUnableToDrag = true; ;如果mIsUnableToDrag = true; 调用
performDrag(x) 如果返回true 调用ViewCompat.postInvalidateOnAnimation(this);；
5、行为是ACTION_DOWN时：各种数据 调用populate , 刷新一次状态
6、行为是ACTION_POINTER_UP时 设置一些参数；
onTouchEvent
1、先也是一些类的判断 ，什么adapter是否为空，是否点击在边界等等。
2、行为是ACTION_DOWN 先停止scroller， 在调用populate ，在记录位置，活动点（手指点标识）
3、行为是ACTION_MOVE 如果 !mIsBeingDragged 通过触摸点位置计算是否达到拖拽标准以及方向 将mIsBeingDragged=true； 如果mIsBeingDragged 调用perfrom（x）执行拖拽。
4、行为ACTION_UP 时,如果 mIsBeingDragged ,那么调用determineTargetPage方法 计算需要滑动至那一页nextPage。在调用setCurrentItemInternal滑动至nextPage页，resetTouch。
5、行为为ACTION_CANCEL时 如果是mIsBeingDragged 滑动至当前页;
6、行为为ACTION_POINTER_DOWN切换触摸点（手指）
7、行为为ACTION_POINTER_UP 手指抬起 各种初始化。
以上有些比较重要的方法 可以拿出来遛一遛；
setScrollState(）； 设置滑动状态
setScrollingCacheEnabled（） 滑动时缓存；
determineTargetPage； 计算下一个page页是哪个；
setCurrentItemInternal 设置当前页 以及是否滑动；
scrollToItem 滑动至某项；
onPageScrolled（ ） ; 通知滑动的监听，
哎呀 这些就一个个去看吧
5、notifyDataSetChanged
1、刷新开始
PageAdapter.class
public void notifyDataSetChanged() {
synchronized (this) {
if (mViewPagerObserver != null) {
mViewPagerObserver.onChanged();
}
}
mObservable.notifyChanged();
}
public void unregisterDataSetObserver(DataSetObserver observer) {
mObservable.unregisterObserver(observer);
}
void setViewPagerObserver(DataSetObserver observer) {
synchronized (this) {
mViewPagerObserver = observer;
}
}
ok，看到这就知道这是个观察者模式，而且成员变量mViewPagerObserver是在 setViewPagerObserver方法中设置进来的， 那么现在 找到这个'mViewPagerObserver' 是个什么东西以及mViewPagerObserver.onChanged()方法都做了些什么
2、PagerObserver 以及 dataSetChanged（）
可以看到 在ViewPager当中我们创建了 PagerObserver并调用了 mAdapter.setViewPagerObserver(mObserver); 所以我们的 mViewPagerBoserver 是PagerObserver； 它又调用了dataSetChanged()方法
ViewPager.class
public void setAdapter(PagerAdapter adapter) {
....
if (mAdapter != null) {
if (mObserver == null) {
mObserver = new PagerObserver();
}
//监听adapter
mAdapter.setViewPagerObserver(mObserver);
}
// viewPager内部类
private class PagerObserver extends DataSetObserver {
PagerObserver() {
}
@Override
public void onChanged() {
// 数据改变时调用这个方法
dataSetChanged();
}
@Override
public void onInvalidated() {
dataSetChanged();
}
}
3、dataSetChanged
void dataSetChanged() {
// This method only gets called if our observer is attached, so mAdapter is non-null. 只给observer调用
// 拿到数据数量
final int adapterCount = mAdapter.getCount();
mExpectedAdapterCount = adapterCount;
//判断是否需要填充
boolean needPopulate = mItems.size() < mOffscreenPageLimit * 2 + 1
&& mItems.size() < adapterCount;
//拿到当前选中的item下标
int newCurrItem = mCurItem;
boolean isUpdating = false;
//循环mitems
for (int i = 0; i < mItems.size(); i++) {
final ItemInfo ii = mItems.get(i);
final int newPos = mAdapter.getItemPosition(ii.object);
if (newPos == PagerAdapter.POSITION_UNCHANGED) {
continue;
}
if (newPos == PagerAdapter.POSITION_NONE) {
mItems.remove(i);
i--;
if (!isUpdating) {
mAdapter.startUpdate(this);
isUpdating = true;
}
mAdapter.destroyItem(this, ii.position, ii.object);
// 需要填充
needPopulate = true;
if (mCurItem == ii.position) {
// Keep the current item in the valid range
newCurrItem = Math.max(0, Math.min(mCurItem, adapterCount - 1));
// 需要填充
needPopulate = true;
}
continue;
}
...
if (needPopulate) {
// Reset our known page widths; populate will recompute them.
final int childCount = getChildCount();
for (int i = 0; i < childCount; i++) {
final View child = getChildAt(i);
final LayoutParams lp = (LayoutParams) child.getLayoutParams();
if (!lp.isDecor) {
lp.widthFactor = 0.f;
}
}
//滑动至当前页
setCurrentItemInternal(newCurrItem, false, true);
requestLayout();
}
}
可以看到 大致的意思是：循环遍历视图上所有的item, 并通过adapter.getgetItemPosition方法 拿到一个newPos ，该值有两种状态 一种：PagerAdapter.POSITION_UNCHANGED 和PagerAdapter.POSITION_NONE ,如果为PagerAdapter.POSITION_UNCHANGED状态那么就不刷新itemView，否则 先销毁现有的itemView再重新创建一个新的itemVIew； 最后滑动至指定页，以及requestLayout。
好的 分析得差不多。 之后碰到问题就应该不会迷茫了。
希望我的文章不会误导在观看的你，如果有异议的地方欢迎讨论和指正。
如果能给观看的你带来收获，那就是最好不过了。
