RecyclerView之Scroll和Fling_慕课手记

link管理

链接快照平台

输入网页链接，自动生成快照
标签化管理网页链接

1. `Scroll` 和状态

Scroll 大家都知道，我们可以给 RecyclerView 添加监听，在 RecyclerView 滚动的时候会回调。

RecyclerView.addOnScrollListener(mScrollListener);

就是在 RecyclerView 滚动的时候会回调

/**
* An OnScrollListener can be added to a RecyclerView to receive messages when a scrolling event
* has occurred on that RecyclerView.
* @see RecyclerView#addOnScrollListener(OnScrollListener)
* @see RecyclerView#clearOnChildAttachStateChangeListeners()
public abstract static class OnScrollListener { /**
* Callback method to be invoked when RecyclerView's scroll state changes.
* @param recyclerView The RecyclerView whose scroll state has changed.
* @param newState The updated scroll state. One of {@link #SCROLL_STATE_IDLE},
* {@link #SCROLL_STATE_DRAGGING} or {@link #SCROLL_STATE_SETTLING}.
public void onScrollStateChanged(RecyclerView recyclerView, int newState){} /**
* Callback method to be invoked when the RecyclerView has been scrolled. This will be
* called after the scroll has completed.
* This callback will also be called if visible item range changes after a layout
* calculation. In that case, dx and dy will be 0.
* @param recyclerView The RecyclerView which scrolled.
* @param dx The amount of horizontal scroll.
* @param dy The amount of vertical scroll.
public void onScrolled(RecyclerView recyclerView, int dx, int dy){}
}

滚动有三种状态：

    /**
     * The RecyclerView is not currently scrolling.
     * @see #getScrollState()
    public static final int SCROLL_STATE_IDLE = 0;    /**
     * The RecyclerView is currently being dragged by outside input such as user touch input.
     * @see #getScrollState()
    public static final int SCROLL_STATE_DRAGGING = 1;    /**
     * The RecyclerView is currently animating to a final position while not under
     * outside control.
     * @see #getScrollState()
    public static final int SCROLL_STATE_SETTLING = 2;

这三种回调顺序:

SCROLL_STATE_DRAGGING, 先是手指拖拽的状态
SCROLL_STATE_SETTLING，再是手指松开但是 RecyclerView 还在滑动
SCROLL_STATE_IDLE，最后是 RecyclerView 滚动停止状态。

2. `Fling` 和 `Scroll` 的关系

Fling 是怎样一种状态，手指在屏幕上滑动RecyclerView然后松手，RecyclerView中的内容会顺着惯性继续往手指滑动的方向继续滚动直到停止，这个过程叫做 Fling 。 Fling 操作从手指离开屏幕瞬间被触发，在滚动停止时结束。其实 RecyclerView 在 Fling 过程中会把state设置为 SCROLL_STATE_SETTLING 。看下源码：
在Fling触发的时候会回调 SnapHelper 中的 onFling

    @Override
    public boolean onFling(int velocityX, int velocityY) {
        LayoutManager layoutManager = mRecyclerView.getLayoutManager();        if (layoutManager == null) {            return false;
        RecyclerView.Adapter adapter = mRecyclerView.getAdapter();        if (adapter == null) {            return false;
        }        int minFlingVelocity = mRecyclerView.getMinFlingVelocity();        return (Math.abs(velocityY) > minFlingVelocity || Math.abs(velocityX) > minFlingVelocity)
                && snapFromFling(layoutManager, velocityX, velocityY);
    }    private boolean snapFromFling(@NonNull LayoutManager layoutManager, int velocityX,            int velocityY) {
        SmoothScroller smoothScroller = createScroller(layoutManager);        if (smoothScroller == null) {            return false;
        }        int targetPosition = findTargetSnapPosition(layoutManager, velocityX, velocityY);        if (targetPosition == RecyclerView.NO_POSITION) {            return false;
        smoothScroller.setTargetPosition(targetPosition);
        layoutManager.startSmoothScroll(smoothScroller);        return true;
    }

在 onFling 中调用 snapFromFling ， findTargetSnapPosition 会根据滑动速率计算出要滑动到的位置，然后设置给 smoothScroller :

       public void setTargetPosition(int targetPosition) {
             mTargetPosition = targetPosition;
        }        /**
         * Returns the adapter position of the target item
         * @return Adapter position of the target item or
         * {@link RecyclerView#NO_POSITION} if no target view is set.
        public int getTargetPosition() {            return mTargetPosition;
        }

在 snapHelper 中 smoothScroller 默认是 LinearSmoothScroller ,

public class LinearSmoothScroller extends RecyclerView.SmoothScroller

然后会调用 smoothScroller 滚动到指定位置, 开始滚动之前会调用 start 方法, 会设置 mTargetView 就是我们上面设置的要滚到的位置：

        /**
         * Starts a smooth scroll for the given target position.
         * <p>In each animation step, {@link RecyclerView} will check
         * for the target view and call either
         * {@link #onTargetFound(android.view.View, RecyclerView.State, SmoothScroller.Action)} or
         * {@link #onSeekTargetStep(int, int, RecyclerView.State, SmoothScroller.Action)} until
         * SmoothScroller is stopped.</p>
         * <p>Note that if RecyclerView finds the target view, it will automatically stop the
         * SmoothScroller. This <b>does not</b> mean that scroll will stop, it only means it will
         * stop calling SmoothScroller in each animation step.</p>
        void start(RecyclerView recyclerView, LayoutManager layoutManager) {
            mRecyclerView = recyclerView;
            mLayoutManager = layoutManager;            if (mTargetPosition == RecyclerView.NO_POSITION) {                throw new IllegalArgumentException("Invalid target position");
            mRecyclerView.mState.mTargetPosition = mTargetPosition;
            mRunning = true;
            mPendingInitialRun = true;
            mTargetView = findViewByPosition(getTargetPosition());
            onStart();
            mRecyclerView.mViewFlinger.postOnAnimation();
        }

在 RecyclerView.SmoothScroller 滑动是会调用 onAnimation ，在滚动过程中如果发现 getChildPosition(mTargetView) == mTargetPosition ,也就是目标位置已经layout出来了，那么就会回调 onTargetFound .

public abstract static class SmoothScroller {      private void onAnimation(int dx, int dy) {            final RecyclerView recyclerView = mRecyclerView;            if (!mRunning || mTargetPosition == RecyclerView.NO_POSITION || recyclerView == null) {
                stop();
            mPendingInitialRun = false;            if (mTargetView != null) {                // verify target position
                if (getChildPosition(mTargetView) == mTargetPosition) {
                    onTargetFound(mTargetView, recyclerView.mState, mRecyclingAction);
                    mRecyclingAction.runIfNecessary(recyclerView);
                    stop();
                } else {
                    Log.e(TAG, "Passed over target position while smooth scrolling.");
                    mTargetView = null;
}public int getChildPosition(View view) {        return mRecyclerView.getChildLayoutPosition(view);
}

没有悬念，绕了一大圈终于回到 SnapHelper 中 onTargetFound ,在 onTargetFound 中会调用 calculateDistanceToFinalSnap :

        return new LinearSmoothScroller(mRecyclerView.getContext()) {            @Override
            protected void onTargetFound(View targetView, RecyclerView.State state, Action action) {                int[] snapDistances = calculateDistanceToFinalSnap(mRecyclerView.getLayoutManager(),
                        targetView);                final int dx = snapDistances[0];                final int dy = snapDistances[1];                final int time = calculateTimeForDeceleration(Math.max(Math.abs(dx), Math.abs(dy)));                if (time > 0) {
                    action.update(dx, dy, time, mDecelerateInterpolator);
            }            @Override
            protected float calculateSpeedPerPixel(DisplayMetrics displayMetrics) {                return MILLISECONDS_PER_INCH / displayMetrics.densityDpi;
        };

计算到目标位置的坐标然后更新给 RecyclerView.Action ,然后在上面的 onAnimation 会调用 mRecyclingAction.runIfNecessary(recyclerView); ，然后会调用 smoothScrollBy :

            void runIfNecessary(RecyclerView recyclerView) {                if (mJumpToPosition >= 0) {                    final int position = mJumpToPosition;
                    mJumpToPosition = NO_POSITION;
                    recyclerView.jumpToPositionForSmoothScroller(position);
                    mChanged = false;                    return;
                }                if (mChanged) {
                    validate();                    if (mInterpolator == null) {                        if (mDuration == UNDEFINED_DURATION) {
                            recyclerView.mViewFlinger.smoothScrollBy(mDx, mDy);
                        } else {
                            recyclerView.mViewFlinger.smoothScrollBy(mDx, mDy, mDuration);
                    } else {
                        recyclerView.mViewFlinger.smoothScrollBy(
                                mDx, mDy, mDuration, mInterpolator);
                    mConsecutiveUpdates++;                    if (mConsecutiveUpdates > 10) {                        // A new action is being set in every animation step. This looks like a bad
                        // implementation. Inform developer.
                        Log.e(TAG, "Smooth Scroll action is being updated too frequently. Make sure"
                                + " you are not changing it unless necessary");
                    mChanged = false;
                } else {
                    mConsecutiveUpdates = 0;
            }

在 smoothScrollBy 中就会设置状态 SCROLL_STATE_SETTLING :

        public void smoothScrollBy(int dx, int dy, int duration, Interpolator interpolator) {            if (mInterpolator != interpolator) {
                mInterpolator = interpolator;
                mScroller = new OverScroller(getContext(), interpolator);
            setScrollState(SCROLL_STATE_SETTLING);
            mLastFlingX = mLastFlingY = 0;
            mScroller.startScroll(0, 0, dx, dy, duration);            if (Build.VERSION.SDK_INT < 23) {                // b/64931938 before API 23, startScroll() does not reset getCurX()/getCurY()
                // to start values, which causes fillRemainingScrollValues() put in obsolete values
                // for LayoutManager.onLayoutChildren().
                mScroller.computeScrollOffset();
            postOnAnimation();
        }

上面绕了一圈，总结一下调用栈就是：

SnapHelper
onFling ---> snapFromFling

上面得到最终位置 targetPosition ,把位置给 RecyclerView.SmoothScroller , 然后就开始滑动了：

RecyclerView.SmoothScrollerstart --> onAnimation

在滑动过程中如果 targetPosition 对应的 targetView 已经layout出来了，就会回调 SnapHelper ，然后计算得到到当前位置到 targetView 的距离 dx,dy

SnapHelper
onTargetFound ---> calculateDistanceToFinalSnap

然后把距离 dx,dy 更新给 RecyclerView.Action :

RecyclerView.Actionupdate --> runIfNecessary --> recyclerView.mViewFlinger.smoothScrollBy

最后调用 RecyclerView.ViewFlinger , 然后又回到 onAnimation

class ViewFlinger implements Runnable        public void smoothScrollBy(int dx, int dy, int duration, Interpolator interpolator) {            if (mInterpolator != interpolator) {
                mInterpolator = interpolator;
                mScroller = new OverScroller(getContext(), interpolator);
            setScrollState(SCROLL_STATE_SETTLING);
            mLastFlingX = mLastFlingY = 0;
            mScroller.startScroll(0, 0, dx, dy, duration);
            postOnAnimation();
        }

3.触发 `fling` 操作

接着我们再看看Fling操作在 RecyclerView 中是什么时候触发的。

先看下 RecyclerView 的 onTouch 方法：

@Overridepublic boolean onTouchEvent(MotionEvent e) {            case MotionEvent.ACTION_UP: {
                mVelocityTracker.addMovement(vtev);
                eventAddedToVelocityTracker = true;
                mVelocityTracker.computeCurrentVelocity(1000, mMaxFlingVelocity);                final float xvel = canScrollHorizontally
                        ? -mVelocityTracker.getXVelocity(mScrollPointerId) : 0;                final float yvel = canScrollVertically
                        ? -mVelocityTracker.getYVelocity(mScrollPointerId) : 0;                if (!((xvel != 0 || yvel != 0) && fling((int) xvel, (int) yvel))) {
                    setScrollState(SCROLL_STATE_IDLE);
                resetTouch();
            } break;
}

在up触发的时候会调用native方法去获得X和Y方向的速率：

    /**
     * Compute the current velocity based on the points that have been
     * collected.  Only call this when you actually want to retrieve velocity
     * information, as it is relatively expensive.  You can then retrieve
     * the velocity with {@link #getXVelocity()} and
     * {@link #getYVelocity()}.
     * @param units The units you would like the velocity in.  A value of 1
     * provides pixels per millisecond, 1000 provides pixels per second, etc.
     * @param maxVelocity The maximum velocity that can be computed by this method.
     * This value must be declared in the same unit as the units parameter. This value
     * must be positive.
    public void computeCurrentVelocity(int units, float maxVelocity) {
        nativeComputeCurrentVelocity(mPtr, units, maxVelocity);
    }

如果有其中一个不为0就会调用 fling 操作：

    public boolean fling(int velocityX, int velocityY) {        if (mLayout == null) {
            Log.e(TAG, "Cannot fling without a LayoutManager set. "
                    + "Call setLayoutManager with a non-null argument.");            return false;
        }        if (mLayoutFrozen) {            return false;
        }        final boolean canScrollHorizontal = mLayout.canScrollHorizontally();        final boolean canScrollVertical = mLayout.canScrollVertically();        if (!canScrollHorizontal || Math.abs(velocityX) < mMinFlingVelocity) {
            velocityX = 0;
        }        if (!canScrollVertical || Math.abs(velocityY) < mMinFlingVelocity) {
            velocityY = 0;
        }        if (velocityX == 0 && velocityY == 0) {            // If we don't have any velocity, return false
            return false;
        }        if (!dispatchNestedPreFling(velocityX, velocityY)) {            final boolean canScroll = canScrollHorizontal || canScrollVertical;
            dispatchNestedFling(velocityX, velocityY, canScroll);            if (mOnFlingListener != null && mOnFlingListener.onFling(velocityX, velocityY)) {                return true;
            }            if (canScroll) {                int nestedScrollAxis = ViewCompat.SCROLL_AXIS_NONE;                if (canScrollHorizontal) {
                    nestedScrollAxis |= ViewCompat.SCROLL_AXIS_HORIZONTAL;
                }                if (canScrollVertical) {
                    nestedScrollAxis |= ViewCompat.SCROLL_AXIS_VERTICAL;
                startNestedScroll(nestedScrollAxis, TYPE_NON_TOUCH);
                velocityX = Math.max(-mMaxFlingVelocity, Math.min(velocityX, mMaxFlingVelocity));
                velocityY = Math.max(-mMaxFlingVelocity, Math.min(velocityY, mMaxFlingVelocity));
                mViewFlinger.fling(velocityX, velocityY);                return true;
        }        return false;
    }

这里有个 mMinFlingVelocity 字段，如果x和y方向的速率小于这个字段，就不会触发fling操作，直接return false，然后就会把 RecyclerView 的状态设置为 SCROLL_STATE_IDLE 。 mMinFlingVelocity 在 RecyclerView 构造的时候会从 ViewConfiguration 中获取

 final ViewConfiguration vc = ViewConfiguration.get(context);
mMinFlingVelocity = vc.getScaledMinimumFlingVelocity();
mMaxFlingVelocity = vc.getScaledMaximumFlingVelocity();

在 ViewConfiguration 构造函数中：

    /**
     * Minimum velocity to initiate a fling, as measured in dips per second
    private static final int MINIMUM_FLING_VELOCITY = 50;    /**
     * Maximum velocity to initiate a fling, as measured in dips per second
    private static final int MAXIMUM_FLING_VELOCITY = 8000;    public ViewConfiguration() {
        mMinimumFlingVelocity = MINIMUM_FLING_VELOCITY;
        mMaximumFlingVelocity = MAXIMUM_FLING_VELOCITY;
    }

所以如果滑动速率小于50的话就不会触发fling操作。

从上面分析知道，fling操作是在手指离开的时候触发然后直到滑动停止这中间的一段操作。在滑动过程中其实state状态是 SCROLL_STATE_SETTLING ,然后通过 RecyclerView.ViewFlinger 进行滑动。

作者：juexingzhe
链接：https://www.jianshu.com/p/1cf7e9ade0f8

点击查看更多内容

1. Scroll 和状态

2. Fling 和 Scroll 的关系

3.触发 fling 操作

1. `Scroll` 和状态

2. `Fling` 和 `Scroll` 的关系

3.触发 `fling` 操作