Android 下拉刷新控件原理解析

private void init(Context context, AttributeSet attrs) {
	// 因为是LinearLayout的子类，可以根据需要设置横纵向展示
	switch (getPullToRefreshScrollDirection()) {
		case HORIZONTAL:
			setOrientation(LinearLayout.HORIZONTAL);
			break;
		case VERTICAL:
		default:
			setOrientation(LinearLayout.VERTICAL);
			break;
	}

	// ..... 读取一些参数

	// 创建与添加需要下拉刷新的视图
	mRefreshableView = createRefreshableView(context, attrs);
	addRefreshableView(context, mRefreshableView);

    // 仅创建顶部与底部视图，并未添加视图到视图树中
	mHeaderLayout = createLoadingLayout(context, Mode.PULL_FROM_START, a);
	mFooterLayout = createLoadingLayout(context, Mode.PULL_FROM_END, a);

	// ..... 读取一些参数
	
	// 刷新UI
	updateUIForMode();
}

protected void updateUIForMode() {
	// We need to use the correct LayoutParam values, based on scroll
	// direction
	final LinearLayout.LayoutParams lp = getLoadingLayoutLayoutParams();
	
	// 添加Header View到顶部
	if (this == mHeaderLayout.getParent()) {
		removeView(mHeaderLayout);
	}
	if (mMode.showHeaderLoadingLayout()) {
		addViewInternal(mHeaderLayout, 0, lp);
	}

	// 添加Header View到底部
	if (this == mFooterLayout.getParent()) {
		removeView(mFooterLayout);
	}
	if (mMode.showFooterLoadingLayout()) {
		addViewInternal(mFooterLayout, lp);
	}

	// Hide Loading Views
	refreshLoadingViewsSize();

	// If we're not using Mode.BOTH, set mCurrentMode to mMode, otherwise
	// set it to pull down
	mCurrentMode = (mMode != Mode.BOTH) ? mMode : Mode.PULL_FROM_START;
}


protected final void refreshLoadingViewsSize() {
	final int maximumPullScroll = (int) (getMaximumPullScroll() * 1.2f);

	int pLeft = getPaddingLeft();
	int pTop = getPaddingTop();
	int pRight = getPaddingRight();
	int pBottom = getPaddingBottom();

	switch (getPullToRefreshScrollDirection()) {
		case HORIZONTAL:
			if (mMode.showHeaderLoadingLayout()) {
				mHeaderLayout.setWidth(maximumPullScroll);
				pLeft = -maximumPullScroll;
			} else {
				pLeft = 0;
			}

			if (mMode.showFooterLoadingLayout()) {
				mFooterLayout.setWidth(maximumPullScroll);
				pRight = -maximumPullScroll;
			} else {
				pRight = 0;
			}
			break;

		case VERTICAL:
			if (mMode.showHeaderLoadingLayout()) {
				mHeaderLayout.setHeight(maximumPullScroll);
				pTop = -maximumPullScroll;
			} else {
				pTop = 0;
			}

			if (mMode.showFooterLoadingLayout()) {
				mFooterLayout.setHeight(maximumPullScroll);
				pBottom = -maximumPullScroll;
			} else {
				pBottom = 0;
			}
			break;
	}

	if (DEBUG) {
		Log.d(LOG_TAG, String.format("Setting Padding. L: %d, T: %d, R: %d, B: %d", pLeft, pTop, pRight, pBottom));
	}
	
	// 通过把相应padding设置被负数，隐藏Header与Footer
	setPadding(pLeft, pTop, pRight, pBottom);
}

@Override
public final boolean onInterceptTouchEvent(MotionEvent event) {
	if (!isPullToRefreshEnabled()) {
		return false;
	}

	final int action = event.getAction();

	// 手指抬起与取消操作，不把事件拦截给onTouchEvent
	if (action == MotionEvent.ACTION_CANCEL || action == MotionEvent.ACTION_UP) {
		mIsBeingDragged = false;
		return false;
	}

	// 已经符合下拉刷新条件，果断拦截
	if (action != MotionEvent.ACTION_DOWN && mIsBeingDragged) {
		return true;
	}

	switch (action) {
		case MotionEvent.ACTION_MOVE: {
			// If we're refreshing, and the flag is set. Eat all MOVE events
			if (!mScrollingWhileRefreshingEnabled && isRefreshing()) {
				return true;
			}

			if (isReadyForPull()) {
				final float y = event.getY(), x = event.getX();
				final float diff, oppositeDiff, absDiff;

				// We need to use the correct values, based on scroll
				// direction
				switch (getPullToRefreshScrollDirection()) {
					case HORIZONTAL:
						diff = x - mLastMotionX;
						oppositeDiff = y - mLastMotionY;
						break;
					case VERTICAL:
					default:
						diff = y - mLastMotionY;
						oppositeDiff = x - mLastMotionX;
						break;
				}
				// 滑动的绝对值，仅用于获取移动长度，后续有单独的方向判断
				absDiff = Math.abs(diff);

				// 手指在屏幕上的移动距离已经满足滚动条件，但是移动距离小于TouchSlop时ListView ItemView会处于tap按下状态，此时并不拦截
				// 需要纵轴的移动距离大于横轴的移动距离，目的是斜着在屏幕上滑动时不会触发。
				if (absDiff > mTouchSlop && (!mFilterTouchEvents || absDiff > Math.abs(oppositeDiff))) {
					// diff >= 1f 方向判断，说明是向下或者向右
					if (mMode.showHeaderLoadingLayout() && diff >= 1f && isReadyForPullStart()) {
						mLastMotionY = y;
						mLastMotionX = x;
						mIsBeingDragged = true;
						if (mMode == Mode.BOTH) {
							mCurrentMode = Mode.PULL_FROM_START;
						}
					} else if (mMode.showFooterLoadingLayout() && diff <= -1f && isReadyForPullEnd()) {
						mLastMotionY = y;
						mLastMotionX = x;
						mIsBeingDragged = true;
						if (mMode == Mode.BOTH) {
							mCurrentMode = Mode.PULL_FROM_END;
						}
					}
				}
			}
			break;
		}
		case MotionEvent.ACTION_DOWN: {
			if (isReadyForPull()) {
				mLastMotionY = mInitialMotionY = event.getY();
				mLastMotionX = mInitialMotionX = event.getX();
				mIsBeingDragged = false;
			}
			break;
		}
	}

	// 返回true说明已经触发拖住刷新
	return mIsBeingDragged;
}

// 来自PullToRefreshAdapterViewBase，用于判断ListView与GridView是否满足下拉条件
protected boolean isReadyForPullStart() {
	return isFirstItemVisible();
}

private boolean isFirstItemVisible() {
	final Adapter adapter = mRefreshableView.getAdapter();

	if (null == adapter || adapter.isEmpty()) {
		if (DEBUG) {
			Log.d(LOG_TAG, "isFirstItemVisible. Empty View.");
		}
		return true;

	} else {

		/**
		 * This check should really just be:
		 * mRefreshableView.getFirstVisiblePosition() == 0, but PtRListView
		 * internally use a HeaderView which messes the positions up. For
		 * now we'll just add one to account for it and rely on the inner
		 * condition which checks getTop().
		 */
		if (mRefreshableView.getFirstVisiblePosition() <= 1) {
			final View firstVisibleChild = mRefreshableView.getChildAt(0);
			if (firstVisibleChild != null) {
				return firstVisibleChild.getTop() >= mRefreshableView.getTop();
			}
		}
	}

	return false;
}

	有视图处理，onTouchEvent return true（消耗），View.dispatchTouchEvent()逐层返回true。            
	最底层子视图未处理，会返回上层，父视图是否处理。      

@Override
public final boolean onTouchEvent(MotionEvent event) {
    
	if (!isPullToRefreshEnabled()) {
		return false;
	}

	// If we're refreshing, and the flag is set. Eat the event
	if (!mScrollingWhileRefreshingEnabled && isRefreshing()) {
		return true;
	}

	// 按下的时候已经到当前视图边界，已经出范围所以不是拖拽刷新
	if (event.getAction() == MotionEvent.ACTION_DOWN && event.getEdgeFlags() != 0) {
		return false;
	}

	switch (event.getAction()) {
		case MotionEvent.ACTION_MOVE: {
			if (mIsBeingDragged) {
				mLastMotionY = event.getY();
				mLastMotionX = event.getX();
				// 处理视图拖拽操作
				pullEvent();
				return true;
			}
			break;
		}

		case MotionEvent.ACTION_DOWN: {
		    // 如果手指触及的当前类的子视图未处理onTouch，此时当前onInterceptTouchEvent函数
		    // 还未满足判断是否为mIsBeingDragged的条件，所以此处需要判断是否满足滚动前的边界条件
			if (isReadyForPull()) {
				mLastMotionY = mInitialMotionY = event.getY();
				mLastMotionX = mInitialMotionX = event.getX();
				return true;
			}
			break;
		}

		case MotionEvent.ACTION_CANCEL:
		case MotionEvent.ACTION_UP: {
			if (mIsBeingDragged) {
				mIsBeingDragged = false;

				if (mState == State.RELEASE_TO_REFRESH
						&& (null != mOnRefreshListener || null != mOnRefreshListener2)) {
					setState(State.REFRESHING, true);
					return true;
				}

				// If we're already refreshing, just scroll back to the top
				if (isRefreshing()) {
					smoothScrollTo(0);
					return true;
				}

				// If we haven't returned by here, then we're not in a state
				// to pull, so just reset
				setState(State.RESET);

				return true;
			}
			break;
		}
	}

	return false;
}

private void pullEvent() {
	final int newScrollValue;
	final int itemDimension;
	final float initialMotionValue, lastMotionValue;

	switch (getPullToRefreshScrollDirection()) {
		case HORIZONTAL:
			initialMotionValue = mInitialMotionX;
			lastMotionValue = mLastMotionX;
			break;
		case VERTICAL:
		default:
			initialMotionValue = mInitialMotionY;
			lastMotionValue = mLastMotionY;
			break;
	}
	
	switch (mCurrentMode) {
		case PULL_FROM_END:
		    // 向上或者向左拖拽不能为正值
			newScrollValue = Math.round(Math.max(initialMotionValue - lastMotionValue, 0) / FRICTION);
			itemDimension = getFooterSize();
			break;
		case PULL_FROM_START:
		default:
		    // 向下或者向右如果满足拖拽条件，移动的值肯定是大于0。
		    // 移动的值/2是摩察系数，最明显的就是屏幕顶部向下滚动到底部，但是其中被拖拽视图仅向下移动屏幕的一半
		    // 如果不添加Math.round，手指在屏幕上一个像素的速度移动，此处算出的float值会永远不变，视图也不会移动
			newScrollValue = Math.round(Math.min(initialMotionValue - lastMotionValue, 0) / FRICTION);
			itemDimension = getHeaderSize();
			break;
	}

	// 视图移动使用scrollTo，所以传入的是手指在屏幕上移动的距离
	// 如果减去mTouchSlop，刚开始滚动的时候就不会有一个跳动的感觉
	setHeaderScroll(newScrollValue);

	if (newScrollValue != 0 && !isRefreshing()) {
		float scale = Math.abs(newScrollValue) / (float) itemDimension;
		switch (mCurrentMode) {
			case PULL_FROM_END:
				mFooterLayout.onPull(scale);
				break;
			case PULL_FROM_START:
			default:
			    // 通知顶部视图刷新
				mHeaderLayout.onPull(scale);
				break;
		}

		if (mState != State.PULL_TO_REFRESH && itemDimension >= Math.abs(newScrollValue)) {
			// 向下滚动的距离已经超出顶部视图高度，认为是下拉刷新状态
			setState(State.PULL_TO_REFRESH);
		} else if (mState == State.PULL_TO_REFRESH && itemDimension < Math.abs(newScrollValue)) {
		    // 向下滑动距离大于顶部视图高度，现在如果松开手已经满足刷新数据的条件
			setState(State.RELEASE_TO_REFRESH);
		}
	}
}

protected final void setHeaderScroll(int value) {
	if (DEBUG) {
		Log.d(LOG_TAG, "setHeaderScroll: " + value);
	}

	// -max ~ max
	// Clamp value to with pull scroll range
	final int maximumPullScroll = getMaximumPullScroll();
	value = Math.min(maximumPullScroll, Math.max(-maximumPullScroll, value));

	if (mLayoutVisibilityChangesEnabled) {
	    // 移动方向正确，且有移动距离才展示
		if (value < 0) {
			mHeaderLayout.setVisibility(View.VISIBLE);
		} else if (value > 0) {
			mFooterLayout.setVisibility(View.VISIBLE);
		} else {
			mHeaderLayout.setVisibility(View.INVISIBLE);
			mFooterLayout.setVisibility(View.INVISIBLE);
		}
	}

	if (USE_HW_LAYERS) {
		/**
		 * Use a Hardware Layer on the Refreshable View if we've scrolled at
		 * all. We don't use them on the Header/Footer Views as they change
		 * often, which would negate any HW layer performance boost.
		 */
		ViewCompat.setLayerType(mRefreshableViewWrapper, value != 0 ? View.LAYER_TYPE_HARDWARE
				: View.LAYER_TYPE_NONE);
	}

	// 移动到指定位置
	switch (getPullToRefreshScrollDirection()) {
		case VERTICAL:
			scrollTo(0, value);
			break;
		case HORIZONTAL:
			scrollTo(value, 0);
			break;
	}
}

final void setState(State state, final boolean... params) {
	mState = state;
	if (DEBUG) {
		Log.d(LOG_TAG, "State: " + mState.name());
	}

	switch (mState) {
		case RESET:
			// 列表滚动到顶部，顶部视图也重置为默认状态
			onReset();
			break;
		case PULL_TO_REFRESH:
			// 通知顶部视图下拉中
			onPullToRefresh();
			break;
		case RELEASE_TO_REFRESH:
			// 通知顶部视图手指释放刷新中
			onReleaseToRefresh();
			break;
		case REFRESHING:
		case MANUAL_REFRESHING:
			// 自动滚动到漏出顶部视图区域
			onRefreshing(params[0]); 
			break;
		case OVERSCROLLING:
			// NO-OP
			break;
	}

	// Call OnPullEventListener
	if (null != mOnPullEventListener) {
		mOnPullEventListener.onPullEvent(this, mState, mCurrentMode);
	}
}

protected void onRefreshing(final boolean doScroll) {
    if (mMode.showHeaderLoadingLayout()) {
        mHeaderLayout.refreshing();
    }
    if (mMode.showFooterLoadingLayout()) {
        mFooterLayout.refreshing();
    }
 
    if (doScroll) {
        if (mShowViewWhileRefreshing) {
 
            // Call Refresh Listener when the Scroll has finished
            OnSmoothScrollFinishedListener listener = new OnSmoothScrollFinishedListener() {
                @Override
                public void onSmoothScrollFinished() {
                    callRefreshListener();
                }
            };
 
            switch (mCurrentMode) {
                case MANUAL_REFRESH_ONLY:
                case PULL_FROM_END:
                    smoothScrollTo(getFooterSize(), listener);
                    break;
                default:
                case PULL_FROM_START:
					// 注意是负值，scrollY向下是负数，向上相反
					// 向上滚动到HeaderSize高度的位置
                    smoothScrollTo(-getHeaderSize(), listener);
                    break;
            }
        } else {
			// 回滚到初始状态
            smoothScrollTo(0);
        }
    } else {
        // We're not scrolling, so just call Refresh Listener now
        callRefreshListener();
    }
}

private final void smoothScrollTo(int newScrollValue, long duration, long delayMillis,
		OnSmoothScrollFinishedListener listener) {
	// 停止自动滚动动画
	if (null != mCurrentSmoothScrollRunnable) {
		mCurrentSmoothScrollRunnable.stop();
	}

	// 当前位置
	final int oldScrollValue;
	switch (getPullToRefreshScrollDirection()) {
		case HORIZONTAL:
			oldScrollValue = getScrollX();
			break;
		case VERTICAL:
		default:
			oldScrollValue = getScrollY();
			break;
	}

	if (oldScrollValue != newScrollValue) {
		if (null == mScrollAnimationInterpolator) {
			// Default interpolator is a Decelerate Interpolator
			mScrollAnimationInterpolator = new DecelerateInterpolator();
		}
		mCurrentSmoothScrollRunnable = new SmoothScrollRunnable(oldScrollValue, newScrollValue, duration, listener);

		// 执行子线程
		if (delayMillis > 0) {
			postDelayed(mCurrentSmoothScrollRunnable, delayMillis);
		} else {
			post(mCurrentSmoothScrollRunnable);
		}
	}
}


final class SmoothScrollRunnable implements Runnable {

	@Override
	public void run() {

		/**
		 * Only set mStartTime if this is the first time we're starting,
		 * else actually calculate the Y delta
		 */
		if (mStartTime == -1) {
			mStartTime = System.currentTimeMillis();
		} else {

			/**
			 * We do do all calculations in long to reduce software float
			 * calculations. We use 1000 as it gives us good accuracy and
			 * small rounding errors
			 */
			// 时间消耗比例
			long normalizedTime = (1000 * (System.currentTimeMillis() - mStartTime)) / mDuration;
			normalizedTime = Math.max(Math.min(normalizedTime, 1000), 0);
			
			final int deltaY = Math.round((mScrollFromY - mScrollToY)
					* mInterpolator.getInterpolation(normalizedTime / 1000f));
			mCurrentY = mScrollFromY - deltaY;
			setHeaderScroll(mCurrentY);
		}

		// If we're not at the target Y, keep going...
		if (mContinueRunning && mScrollToY != mCurrentY) {
			ViewCompat.postOnAnimation(PullToRefreshBase.this, this);
		} else {
			if (null != mListener) {
				mListener.onSmoothScrollFinished();
			}
		}
	}

	public void stop() {
		mContinueRunning = false;
		removeCallbacks(this);
	}
}

public class ViewCompat {

	public static void postOnAnimation(View view, Runnable runnable) {
		if (VERSION.SDK_INT >= VERSION_CODES.JELLY_BEAN) {
			SDK16.postOnAnimation(view, runnable);
		} else {
			view.postDelayed(runnable, 16);
		}
	}
}