本节书摘来自异步社区《Android开发进阶：从小工到专家》一书中的第2章，第2.3节Scroller的使用，作者 何红辉，更多章节内容可以访问云栖社区“异步社区”公众号查看

2.3　Scroller的使用
为了更好地理解下拉刷新的实现，我们先要了解Scroller的作用以及如何使用。这里我们将做一个简单的示例来说明。

Scroller是一个帮助View滚动的辅助类，在使用它之前，用户需要通过startScroll来设置滚动的参数，即起始点坐标和（x,y）轴上要滚动的距离。Scroller它封装了滚动时间、要滚动的目标x轴和y轴，以及在每个时间内View应该滚动到的（x,y）轴的坐标点，这样用户就可以在有效的滚动周期内通过Scroller的getCurX()和getCurY()来获取当前时刻View应该滚动的位置，然后通过调用View的scrollTo或者ScrollBy方法进行滚动。那么如何判断滚动是否结束呢？ 我们只需要覆写View类的computeScroll方法，该方法会在View绘制时被调用，在里面调用Scroller的computeScrollOffset来判断滚动是否完成，如果返回true表明滚动未完成，否则滚动完成。上述说的scrollTo或者ScrollBy的调用就是在computeScrollOffset为true的情况下调用，并且最后还要调用目标View的postInvalidate()或者invalidate()以实现View的重绘。View的重绘又会导致computeScroll方法被调用，从而继续整个滚动过程，直至computeScrollOffset返回false， 即滚动结束。整个过程有点绕，我们看一个实例：

public class ScrollLayout extends FrameLayout {
    private String TAG = ScrollLayout.class.getSimpleName();
    Scroller mScroller ;

    public ScrollLayout(Context context) {
        super(context);
        mScroller = new Scroller(context) ;
    }

    // 该函数会在View重绘之时被调用
    @Override
    public void computeScroll() {
        if ( mScroller.computeScrollOffset() ) {
            // 滚动到此,View应该滚动到的x,y坐标上
            this.scrollTo(mScroller.getCurrX(), mScroller.getCurrY());
            // 请求重绘该View，从而又会导致computeScroll被调用，然后继续滚动，
            // 直到computeScrollOffset返回false
          this.postInvalidate();
        }
    }
    // 调用这个方法进行滚动，这里我们只滚动竖直方向
    public void scrollTo(int y) {
          // 参数1和参数2分别为滚动的起始点水平、竖直方向的滚动偏移量
          // 参数3和参数4为在水平和竖直方向上滚动的距离
          mScroller.startScroll(getScrollX(), getScrollY(), 0, y);
          this.invalidate();
    }
}
滚动该视图的代码：

     ScrollLayout scrollView = new ScrollLayout(getContext()) ;
        scrollView.scrollTo(100);

通过上面这段代码会让scrollView在y轴上向下滚动100个像素点。我们结合代码来分析一下。首先调用scrollTo(inty)方法，然后在该方法中通过mScroller.startScroll()方法来设置滚动的参数，再调用invalidate()方法使得该View重绘。重绘时会调用computeScroll方法，在该方法中通过mScroller.computeScrollOffset()判断滚动是否完成，如果返回true，代表没有滚动完成，此时把该View滚动到此刻View应该滚动到的x、 y位置，这个位置通过mScroller的getCurrX和 getCurrY获得。然后继续调用重绘方法，继续执行滚动过程，直至滚动完成。

了解了Scroller原理后，我们继续看通用的下拉刷新组件的实现吧。

下拉刷新实现
代码量不算多，但是也挺有用的，我们这里只拿出重要的点来分析，完整的源码请访问github（地址为https：//github。Com/bboyfeiyu/android my pull refresh viewltreel masterlsvc/coml uit/pull refresh/ scroller）获取。以下是重要的代码段：

// 下拉刷新组件抽象基类,泛型参数T为中间内容视图的类型
public abstract class RefreshLayoutBase<T extends View>
    extends ViewGroup implementsOnScrollListener {

    // 滚动控制器
    protected Scroller mScroller;
    //下拉刷新时显示的header View
    protected View mHeaderView;
    //上拉加载更多时显示的footer View
    protected View mFooterView;
    //本次触摸滑动y坐标上的偏移量
    protected int mYOffset;
    // 内容视图, 即用户触摸导致下拉刷新、上拉加载的主视图，如ListView、 GridView等
    protected T mContentView;
    //最初的滚动位置，第一次布局时滚动header高度的距离
    protected int mInitScrollY = 0;
    // 最后一次触摸事件的y轴坐标
    protected int mLastY = 0;
    // 空闲状态
    public static final int STATUS_IDLE = 0;
    // 下拉或者上拉状态, 还没有到达可刷新的状态
    public static final int STATUS_PULL_TO_REFRESH = 1;
    // 下拉或者上拉状态
    public static final int STATUS_RELEASE_TO_REFRESH = 2;
    // 刷新中
    public static final int STATUS_REFRESHING = 3;
    // Loading中
    public static final int STATUS_LOADING = 4;
    //当前状态
    protected int mCurrentStatus = STATUS_IDLE;
    // header中的箭头图标
    private ImageView mArrowImageView;
    // 箭头是否向上
    private boolean isArrowUp;
    // header 中的文本标签
    private TextView mTipsTextView;
    // header中的时间标签
    private TextView mTimeTextView;
    // header中的进度条
    private ProgressBar mProgressBar;
    // 屏幕的高度
    private int mScreenHeight;
    // header的高度
    private int mHeaderHeight;
    // 下拉刷新回调
    protected OnRefreshListener mOnRefreshListener;
    // 加载更多的回调

    protected OnLoadListener mLoadListener;
    public RefreshLayoutBase(Context context) {
         this(context, null);
    }

    public RefreshLayoutBase(Context context, AttributeSet attrs) {
         this(context, attrs, 0);
    }

    public RefreshLayoutBase(Context context, AttributeSet attrs, int defStyle) {
        super(context, attrs);
        // 初始化Scroller对象
        mScroller = new Scroller(context);
        // 获取屏幕高度
        mScreenHeight = context.getResources().
             getDisplayMetrics().heightPixels;
        // header 的高度为屏幕高度的 1/4
        mHeaderHeight = mScreenHeight / 4;

        // 初始化整个布局
        initLayout(context);
    }

    // 初始化整个布局,从上到下分别为header、内容视图、footer
    private final void initLayout(Context context) {
        // 设置header view
      setupHeaderView(context);
        // 设置内容视图
        setupContentView(context);
        // 设置布局参数
       setDefaultContentLayoutParams();
        //添加内容视图,如ListView、GridView等
        addView(mContentView);
        // footer view
        setupFooterView(context);
    }
    // 代码省略
}

在构造函数中首先调用initLayout函数初始化整个布局，从上到下分别为Header View、内容视图、Footer View，我们先看看这3部分的相关函数：

//初始化 header view
protected void setupHeaderView(Context context) {
        mHeaderView = LayoutInflater.from(context).inflate(
            R.layout.pull_to_refresh_header, this,false);
        mHeaderView.setLayoutParams(newViewGroup.LayoutParams(
            LayoutParams.MATCH_PARENT, mHeaderHeight));
        mHeaderView.setBackgroundColor(Color.RED);
        // header的高度为1/4的屏幕高度，但是，它只有100px是有效的显示区域
       //取余为paddingTop，这样是为了达到下拉的效果
        mHeaderView.setPadding(0, mHeaderHeight - 100, 0, 0);
        addView(mHeaderView);
        // 初始化header view中的子视图
        mArrowImageView = (ImageView) 
             mHeaderView.findViewById(R.id.pull_to_arrow_image);
        mTipsTextView = (TextView) 
             mHeaderView.findViewById(R.id.pull_to_refresh_text);
        mTimeTextView = (TextView) 
             mHeaderView.findViewById(R.id.pull_to_refresh_updated_at);
        mProgressBar = (ProgressBar) 
             mHeaderView.findViewById(R.id.pull_to_refresh_progress);
}

 //初始化Content View, 子类覆写
protected abstract void setupContentView(Context context);

// 初始化footer view
protected void setupFooterView(Context context) {
     mFooterView = LayoutInflater.from(context).inflate(
                 R.layout.pull_to_refresh_footer,this, false);
     addView(mFooterView);
 }

其中header view和footer view都是从默认的布局中加载，因此，它们是固定的。但是，最中间的内容视图是可变的，例如，我们显示内容的控件可能是ListView、GridView、TextView等，因此，这部分是未知的，所以setContentView留给子类去具体化。还有另外两个抽象函数，分别为判断是否下拉到顶部以及上拉到底部的函数，因为不同内容视图判断是否滚动到顶部、底部的实现代码也是不一样的，因此，也需要抽象化。函数定义如下：

//是否已经到了最顶部,子类需覆写该方法,使得mContentView滑动到最顶端时返回true
//如果到达最顶端用户继续下拉则拦截事件
protected abstract boolean isTop();

//是否已经到了最底部,子类需覆写该方法,使得mContentView滑动到最底端时返回true
//从而触发自动加载更多的操作
protected abstract boolean isBottom();
初始化这3部分视图之后，接下来的第一个关键步骤就是视图测量与布局，也就是我们自定义ViewGroup中必备的两个步骤。上文我们已经说过，header view、内容视图、footer是纵向布局的，因此，需要将它们从上到下布局。在布局之前还需要测量各个子视图的尺寸以及该下拉刷新组件自身的尺寸。代码如下：

    /*
     * 丈量视图的宽、高。宽度为用户设置的宽度，高度则为header、 content view、 footer这三个子控件的高度之和
     */
    @Override
    protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
         // MeasureSpec中的宽度值
        int width = MeasureSpec.getSize(widthMeasureSpec);
        // 子视图的个数
        int childCount = getChildCount();
        // 最终的高度
        int finalHeight = 0;

        for (int i = 0; i < childCount; i++) {
            View child = getChildAt(i);
            // 测量每个子视图的尺寸
             measureChild(child, widthMeasureSpec, heightMeasureSpec);
            // 所有子视图的高度和就是该下拉刷新组件的总高度
            finalHeight += child.getMeasuredHeight();
        }
        // 设置该下拉刷新组件的尺寸
        setMeasuredDimension(width, finalHeight);
    }

    /*
     * 布局函数，将header、 content view、footer这3个View从上到下布局。
     *布局完成后通过Scroller滚动到header的底部，即滚动距离为header的高度 +本视图的paddingTop，从而达到隐藏header的效果
     */
    @Override
    protected void onLayout(boolean changed, int l, int t, int r, int b) {
        int childCount = getChildCount();
        int left = getPaddingLeft();
        int top = getPaddingTop();
        for (int i = 0; i < childCount; i++) {
            View child = getChildAt(i);
            child.layout(left, top, 
                          child.getMeasuredWidth(), child.getMeasuredHeight() + top);
            top += child.getMeasuredHeight();
        }

        // 计算初始化滑动的y轴距离
        mInitScrollY = mHeaderView.getMeasuredHeight() + getPaddingTop();
        // 滑动到header view高度的位置, 从而达到隐藏header view的效果
        scrollTo(0, mInitScrollY);
    }

在onMeasure中我们测量了该组件自身的大小以及所有子视图的大小，并且将该控件的高度设置为所有子视图的高度之和，在这里也就是header、content view、footer的高度之和，这样在布局时我们才有足够的空间竖向放置子视图。

在onLayout时，会将Header View、内容视图、Footer View从上到下布局，即Header View实际上显示在该ViewGroup的最上面，如前文的图2-17所示。而在onLayout的最后，我们通过Scroller将该ViewGroup向上滚动了Header View的高度，使得Header View变得不可见，如上文的图2-18所示。当用户向下拉时，该组件判断内容视图滑到了顶部，此时又通过Scroller将该组件向下滚动，使得Header View慢慢显示出来。实现这些功能就需要我们处理该控件的触摸事件，通过内容视图滚动到了顶部或者底部来判断是否需要拦截触摸事件。相关代码如下：

     /*
     * 在适当的时候拦截触摸事件，这里指的适当的时候是当mContentView滑动到顶部，并且是下拉时拦截触摸事件，否则不拦截，交给其child、view 来处理
     */
    @Override
    public boolean onInterceptTouchEvent(MotionEvent ev) {
        // 获取触摸事件的类型
        final int action = MotionEventCompat.getActionMasked(ev);
        // 取消事件和抬起事件则直接返回false
        if (action == MotionEvent.ACTION_CANCEL || action == MotionEvent.ACTION_UP) {
            return false;
        }

        switch (action) {
            case MotionEvent.ACTION_DOWN:
                mLastY = (int) ev.getRawY();
                break;

            case MotionEvent.ACTION_MOVE:
                mYOffset = (int) ev.getRawY() - mLastY;
                // 如果拉到了顶部, 并且是下拉,则拦截触摸事件
                // 从而转到onTouchEvent来处理下拉刷新事件
                if (isTop() && mYOffset > 0) {
                    return true;
                }
                break;

        }
        // 默认不拦截触摸事件,使得该控件的子视图能够得到处理机会
        return false;
    }

onInterceptTouchEvent是ViewGroup中对触摸事件进行拦截的函数，当返回true时后续的触摸事件就会被该ViewGroup拦截，此时子视图将不会再获得触摸事件。相应地，返回false则表示不进行拦截。例如在上述onInterceptTouchEvent函数中，我们在ACTION_DOWN事件（手指第一次按下）时记录了y轴的坐标，当用户的手指在屏幕上滑动时就会产生ACTION_MOVE事件，此时我们获取y轴坐标，并且与最初ACTION_DOWN事件的y轴相减。如果mYOffset大于0，那么表示用户的手指是从上到下滑动，如果此时内容视图已经是到了顶部，例如，ListView的第一个可见元素就是第一项，那么则返回true，也就是将后续的触摸事件拦截。此时，后续的ACTION_MOVE、ACTION_UP等事件就会有该组件进行处理，处理函数为onTouchEvent函数，代码如下：

     /*
     * 在这里处理触摸事件以达到下拉刷新或者上拉自动加载的问题
     */
    @Override
    public boolean onTouchEvent(MotionEvent event) {
        switch (event.getAction()) {
              // 滑动事件
             case MotionEvent.ACTION_MOVE:
                  // 获取手指触摸的当前y坐标
                  int currentY = (int) event.getRawY();
                  // 当前坐标减去按下时的y坐标得到y轴上的偏移量
                  mYOffset = currentY - mLastY;
                  if (mCurrentStatus != STATUS_LOADING) {
                     // 在y轴方向上滚动该控件
                     changeScrollY(mYOffset);
                  }
                 // 旋转Header 中的箭头图标
                 rotateHeaderArrow();
                // 修改Header中的文本信息
                changeTips();
                // mLastY 设置为这次的y轴坐标
                mLastY = currentY;
                break;

            case MotionEvent.ACTION_UP:
                // 下拉刷新的具体操作
                doRefresh();
                break;
            default:
                break;
        }
        return true;        // 返回true,消费该事件，不再传递
    }

在onTouchEvent函数中，我们会判断触摸事件的类型，如果还是ACTION_MOVE事件，那么计算当前触摸事件的y坐标与ACTION_DOWN时的y坐标的差值，然后调用changeScrollY函数在y轴上滚动该控件。如果用户一直向下滑动手指，那么mYOffset值将不断增大，那么此时该控件将不断地往上滚动，Header View的可见高度也就越来越大。我们看看changeScrollY函数的实现

    /**
     * 修改y轴上的滚动值，从而实现Header被下拉的效果
     * @param distance 这次触摸事件的y轴与上一次的y轴的差值
     * @return
     */
    private void changeScrollY(int distance) {
        // 最大值为 scrollY(header 隐藏), 最小值为0 ( Header 完全显示)
        int curY = getScrollY();
        // 下拉
        if (distance > 0 && curY - distance >getPaddingTop()) {
           scrollBy(0, -distance);
        } else if (distance < 0 && curY - distance <= mInitScrollY) {
            // 上拉过程
            scrollBy(0, -distance);
        }

        curY = getScrollY();
        int slop = mInitScrollY / 2;
        if (curY > 0 && curY < slop) {
            mCurrentStatus = STATUS_RELEASE_TO_REFRESH;
        } else if (curY > 0 && curY > slop) {
            mCurrentStatus = STATUS_PULL_TO_REFRESH;
        }
    }

从上述程序中可以看到，changeScrollY函数实际上就是根据这一次与上一次y轴的差值来滚动当前控件，由于两次触摸事件的差值较小，因此，滚动起来相对比较流畅。当distance小于0时，则是向上滚动，此时Header View的可见范围越来越小，最后完全隐藏；当distance大于0时则是向下滚动，此时Header View的可见范围越来越大，这样一来也就实现了下拉时显示Header View的效果。当然在下拉过程中，我们也会修改Header View布局中的一些控件状态，例如箭头ImageView、文本信息等。

Header View显示之后，当我们的手指离开屏幕时，如果在y轴上的滚动高度大于Header View有效区域高度的二分之一，那么就会触发刷新操作，否则就会通过Scroller将Header View再次隐藏起来。相关代码为ACTION_UP触摸事件中调用的doRefresh函数：

    // 执行下拉刷新
    private void doRefresh() {
        changeHeaderViewStaus();
        // 执行刷新操作
        if (mCurrentStatus == STATUS_REFRESHING &&mOnRefreshListener != null) {
            mOnRefreshListener.onRefresh();
        }
    }

    /**
     * 手指抬起时,根据用户下拉的高度来判断是否是有效的下拉刷新操作
     如果下拉的距离超过Header View的1/2
     *那么则认为是有效的下拉刷新操作，否则恢复原来的视图状态
     */
    private void changeHeaderViewStaus() {
        int curScrollY = getScrollY();
        // 超过1/2则认为是有效的下拉刷新, 否则还原
        if (curScrollY < mInitScrollY / 2) {
            // 滚动到能够正常显示Header的位置
            mScroller.startScroll(getScrollX(), curScrollY, 
                 0, mHeaderView.getPaddingTop() - curScrollY);
            mCurrentStatus = STATUS_REFRESHING;
            mTipsTextView.setText(R.string.pull_to_refresh_refreshing_label);
            mArrowImageView.clearAnimation();
            mArrowImageView.setVisibility(View.GONE);
            mProgressBar.setVisibility(View.VISIBLE);
        } else {
            mScroller.startScroll(getScrollX(), curScrollY, 
                 0, mInitScrollY - curScrollY);
            mCurrentStatus = STATUS_IDLE;
        }
        invalidate();
    }

在changeHeaderViewStaus函数中，当判断为满足下拉刷新的条件时，就会设置当前组件的状态为STATUS_REFRESHING状态，并且设置正好显示Header View区域，最后调用OnRefreshListener实现用户设定的下拉刷新操作。刷新操作执行完成之后，用户需要调用refreshComplete函数告知当前控件刷新完毕，此时当前控件会将Header View隐藏。相关代码如下：

     /**
     * 刷新结束，恢复状态
     */
    public void refreshComplete() {
        mCurrentStatus = STATUS_IDLE;
        // 隐藏Header View
        mScroller.startScroll(getScrollX(), getScrollY(),
        0, mInitScrollY - getScrollY());
        invalidate();
        updateHeaderTimeStamp();

        // 200毫秒后处理arrow和progressbar,免得太突兀
       this.postDelayed(new Runnable() {

            @Override
            public void run() {
                mArrowImageView.setVisibility(View.VISIBLE);
                mProgressBar.setVisibility(View.GONE);
            }
        }, 100);
    }

在refreshComplete中将重置控件的状态，并且将Header View滚动到屏幕之外。此时，整个下拉刷新操作就完成了。滚动到底部时加载更多比下拉刷新要简单一些，只需要判断是否滚动到底部，如果已经到底部那么直接触发加载更多，因此，当前控件需要监听内容视图的滚动事件：

    /*
     * 滚动监听，当滚动到最底部，且用户设置了加载更多的监听器时触发加载更多操作
     */
    @Override
    public void onScroll(AbsListView view, int firstVisibleItem, int visibleItemCount,
            int totalItemCount) {
        // 用户设置了加载更多监听器，且到了最底部，并且是上拉操作，那么执行加载更多
        if (mLoadListener != null && isBottom()
          && mScroller.getCurrY() <= mInitScrollY
          && mYOffset <= 0
          && mCurrentStatus == STATUS_IDLE) {
            // 显示Footer View
            showFooterView();
           // 调用加载更多
           doLoadMore();
        }
    }

      // 显示footer view
      private void showFooterView() {
          startScroll(mFooterView.getMeasuredHeight());
          mCurrentStatus = STATUS_LOADING;
     }

    // 执行下拉(自动)加载更多的操作
    private void doLoadMore() {
        if (mLoadListener != null) {
            mLoadListener.onLoadMore();
        }
    }

在onScroll中监听内容视图的滚动事件，当内容视图滚动到底部时显示Footer View，并且调用OnLoadListener回调执行加载更多的操作。当操作执行完毕后用户需要调用loadCompelte函数告知当前控件加载完毕，下拉刷新组件此时隐藏Footer View并且设置为STATUS_IDLE状态。

这就是整个RefreshLayoutBase类的核心逻辑，下面我们看看具体实现类，例如内容视图是ListView的实现：

public class RefreshListView extends RefreshAdaterView<ListView> {
    // 构造函数省略
    // 设置内容视图为ListView,并且设置mContentView的滚动监听器为当前对象
    @Override
    protected void setupContentView(Context context) {
        mContentView = new ListView(context);
        // 设置滚动监听器
        mContentView.setOnScrollListener(this);

    }

    @Override
    protected boolean isTop() {
         // 当第一个可见项是第一项时表示到了顶部
        return mContentView.getFirstVisiblePosition() == 0
             &&getScrollY() <= mHeaderView.getMeasuredHeight();
    }

    @Override
    protected boolean isBottom() {
         // 最后一个可见项是最后一项时表示滚动到了底部
        return mContentView != null && mContentView.getAdapter() != null
        && mContentView.getLastVisiblePosition() ==
                mContentView.getAdapter().getCount() - 1;
    }
}

RefreshListView覆写了RefreshLayoutBase的3个函数，分别为设置内容视图、判断是否是滚动到顶部、判断是否是滚动到底部。需要注意的是，在setContentView函数中，我们将mContentView（在这里也就是ListView）的onScrollListener设置为this，这是因为需要监听ListView的滚动状态，当滚动到最后一项时触发加载更多操作。因为RefreshLayoutBase实现了onScrollListener接口，而判断是否调用加载更多的代码被封装在了RefreshLayoutBase类中，因此，在这里直接调用mContentView对象的setOnScrollListener(this)即可。使用示例代码如下：

        final RefreshListView refreshLayout = new RefreshListView(this);
        String[] dataStrings = new String[20];
        for (int i = 0; i < dataStrings.length; i++) {
            dataStrings[i] = "item - " + i;
        }
        // 获取ListView, 这里的listview就是Content view
        refreshLayout.setAdapter(new ArrayAdapter<String>(this,
                android.R.layout.simple_list_item_1, dataStrings));
        // 设置下拉刷新监听器
        refreshLayout.setOnRefreshListener(new OnRefreshListener() {

            @Override
            public void onRefresh() {
                Toast.makeText(getApplicationContext(), "refreshing", 
                Toast.LENGTH_SHORT).show();

                refreshLayout.postDelayed(new Runnable() {

                    @Override
                    public void run() {
                        refreshLayout.refreshComplete();
                    }
                }, 1500);
            }
        });

        // 不设置的话到底部不会自动加载
        refreshLayout.setOnLoadListener(new OnLoadListener() {

            @Override
            public void onLoadMore() {
                Toast.makeText(getApplicationContext(), "loading", 
                      Toast.LENGTH_SHORT).show();

                refreshLayout.postDelayed(new Runnable() {

                    @Override
                    public void run() {
                        refreshLayout.loadCompelte();
                    }
                }, 1500);
            }
        });

效果如图2-19、图2-20和图2-21所示。

效果图中含有下拉刷新的ListView、GridView、TextView，而扩展一个支持下拉刷新的控件也非常简单，只需要继承自RefreshLayoutBase类并且覆写setContentView、isTop、isBottom函数即可。通过这种形式，使得下拉刷新组件具有良好的可扩展性。