Scroller源码解析

我们都知道要使用Scroller，就必须创建一个Scroller对象，下面来看看Scroller的构造函数

  public Scroller(Context context) {
        this(context, null);
    }

    public Scroller(Context context, Interpolator interpolator) {
        this(context, interpolator, context.getApplicationInfo().targetSdkVersion >=         
             Build.VERSION_CODES.HONEYCOMB);
    }

    public Scroller(Context context, Interpolator interpolator, boolean flywheel) {
        mFinished = true;
        if (interpolator == null) {
            mInterpolator = new ViscousFluidInterpolator();
        } else {
            mInterpolator = interpolator;
        }
        mPpi = context.getResources().getDisplayMetrics().density * 160.0f;
        mDeceleration = computeDeceleration(ViewConfiguration.getScrollFriction());
        mFlywheel = flywheel;

        mPhysicalCoeff = computeDeceleration(0.84f);
    }

从源码可以看到Scroller有三个构造函数， 第一个是需要传递一个Context，通常也是用得最多的一个构造函数。第二还需要传达一个插值器Interpolator，如果传递为NULL，就会采用默.认的插值器ViscousFluidInterpolator。第三个需要传递一个是对滑动的 "惯性轮"特性的支持flyWheel。接下来看看startScroll()方法

    public void startScroll(int startX, int startY, int dx, int dy, int duration) {
        mMode = SCROLL_MODE;
        mFinished = false;
        mDuration = duration;
        mStartTime = AnimationUtils.currentAnimationTimeMillis();
        mStartX = startX;
        mStartY = startY;
        mFinalX = startX + dx;
        mFinalY = startY + dy;
        mDeltaX = dx;
        mDeltaY = dy;
        mDurationReciprocal = 1.0f / (float) mDuration;
    }

可以看到startsScroll()方法只是保存了传递进来的各种参数：startX和StartY表示滑动开始的起点，dx和dy表示滑动的距离，duration则表示滑动继续时间，该方法只是为滑动来做准备的，并没有看到有开启滑动的方法，也不能把View进行滑动。

在调用完startScroll()方法之后又调用了invalidate()方法，这个方法会导致View的重绘，而View的重绘会调用View的draw()方法，draw()方法又会调用computeScroll()方法，如下：

    override fun computeScroll() {
        if(mScroller.computeScrollOffset()) {
            scrollTo(mScroller.getCurrX(), mScroller.getCurrY())
            invalidate()
        }
    }

    //开始移动方法
    fun startScroll(distanceX: Int, distanceY: Int) {
        mScroller.startScroll(scrollX, scrollY, distanceX, distanceY, 2000)
        invalidate()
    }

在computeScroll()方法中通过调用Scroller对象来获取当前ScrollX和ScrollY，然后调用scrollTo()方法进行View的滑动，接着调用了invalidate()方法来让View进行重绘，重绘就会调用computeScroll()方法来实现View的滑动。这样通过不断地移动一个小的距离并连贯起来就实现了平滑移动的效果。在Scroller中如何获取当前位置的ScrollX和ScrollY，其实是通过computeScrollOffset()方法进行计算的，如下：

    public boolean computeScrollOffset() {
        if (mFinished) {
            return false;
        }

        int timePassed = (int)(AnimationUtils.currentAnimationTimeMillis() - mStartTime);
    
        if (timePassed < mDuration) {
            switch (mMode) {
            case SCROLL_MODE:
                final float x = mInterpolator.getInterpolation(timePassed * mDurationReciprocal);
                mCurrX = mStartX + Math.round(x * mDeltaX);
                mCurrY = mStartY + Math.round(x * mDeltaY);
                break;
            case FLING_MODE:
                final float t = (float) timePassed / mDuration;
                final int index = (int) (NB_SAMPLES * t);
                float distanceCoef = 1.f;
                float velocityCoef = 0.f;
                if (index < NB_SAMPLES) {
                    final float t_inf = (float) index / NB_SAMPLES;
                    final float t_sup = (float) (index + 1) / NB_SAMPLES;
                    final float d_inf = SPLINE_POSITION[index];
                    final float d_sup = SPLINE_POSITION[index + 1];
                    velocityCoef = (d_sup - d_inf) / (t_sup - t_inf);
                    distanceCoef = d_inf + (t - t_inf) * velocityCoef;
                }

                mCurrVelocity = velocityCoef * mDistance / mDuration * 1000.0f;
                
                mCurrX = mStartX + Math.round(distanceCoef * (mFinalX - mStartX));
                // Pin to mMinX <= mCurrX <= mMaxX
                mCurrX = Math.min(mCurrX, mMaxX);
                mCurrX = Math.max(mCurrX, mMinX);
                
                mCurrY = mStartY + Math.round(distanceCoef * (mFinalY - mStartY));
                // Pin to mMinY <= mCurrY <= mMaxY
                mCurrY = Math.min(mCurrY, mMaxY);
                mCurrY = Math.max(mCurrY, mMinY);

                if (mCurrX == mFinalX && mCurrY == mFinalY) {
                    mFinished = true;
                }

                break;
            }
        }
        else {
            mCurrX = mFinalX;
            mCurrY = mFinalY;
            mFinished = true;
        }
        return true;
    }

首先就进行判断是否滚动已完成，如果完成直接返回了false，下面计算了动画的持续时间timePassed。如果动画持续时间小于我们设置的滑动时间持续时间mDuration，则执行Switch语句。mMode有两种值，一种是SCROLL_MODE平移滚动，另外一种是FLING_MODE惯性滚动。可以看到SCROLL_MODE中的代码非常简单，就是用插值器Interpolator来计算该时间内移动的距离，赋值给mCurrX和mCurrY，最后返回了true，代表动画并未结束。

通过上面的分析，Scroller并不能直接让View进行滑动，它需要配合View的computeScroll()方法,在computeScroll()方法中不断地让View进行重绘，每次重绘都会计算滑动持续时间和滑动的距离，最后调用scrollTo()进行滑动，不断重复上面的过程，就形成平移动画。