Android RecyclerView 快速滑到顶部

最新推荐文章于 2024-07-03 10:34:52 发布

chenhuakang

最新推荐文章于 2024-07-03 10:34:52 发布

阅读量1.2w

点赞数

分类专栏：学习资料

学习资料专栏收录该内容

250 篇文章 2 订阅

订阅专栏

转载请注明出处 https://github.com/baiiu

使用RecyclerView时，调用smoothScrollToPostion()方法滑动到指定位置，但是条目很多时滑动的很慢，本篇文章就是实现RecyclerView的快速滑动。

先介绍如何实现，然后再介绍原理。

1. 实现代码

创建FastScrollLinearLayoutManager，继承LinearLayoutManager
复写smoothScrollToPosition()方法，主要复写LinearSmoothScroller中方法

代码如下，解释全在注释中：

public class FastScrollLinearLayoutManager extends LinearLayoutManager {
    public FastScrollLinearLayoutManager(Context context) {
        super(context);
    }

    @Override
    public void smoothScrollToPosition(RecyclerView recyclerView, RecyclerView.State state, int position) {
       LinearSmoothScroller linearSmoothScroller = new LinearSmoothScroller(recyclerView.getContext()) {

            @Override 
            public PointF computeScrollVectorForPosition(int targetPosition) {
                return  FastScrollLinearLayoutManager.this.computeScrollVectorForPosition(targetPosition);
            }

            //该方法控制速度。
            //if returned value is 2 ms, it means scrolling 1000 pixels with LinearInterpolation should take 2 seconds.
            @Override 
            protected float calculateSpeedPerPixel(DisplayMetrics displayMetrics) {
                /*
                     控制单位速度,  毫秒/像素, 滑动1像素需要多少毫秒.

                     默认为 (25F/densityDpi) 毫秒/像素

                     mdpi上, 1英寸有160个像素点, 25/160,
                     xxhdpi,1英寸有480个像素点, 25/480,
                  */

                  //return 10F / displayMetrics.densityDpi;//可以减少时间，默认25F
                 return super.calculateSpeedPerPixel(displayMetrics);
            }

           //该方法计算滑动所需时间。在此处间接控制速度。
           //Calculates the time it should take to scroll the given distance (in pixels)
           @Override 
           protected int calculateTimeForScrolling(int dx) {
               /*
                   控制距离, 然后根据上面那个方(calculateSpeedPerPixel())提供的速度算出时间,

                   默认一次 滚动 TARGET_SEEK_SCROLL_DISTANCE_PX = 10000个像素,

                   在此处可以减少该值来达到减少滚动时间的目的.
                */

                //间接计算时提高速度，也可以直接在calculateSpeedPerPixel提高
                if (dx > 3000) {
                    dx = 3000;
                }

                int time = super.calculateTimeForScrolling(dx);
                LogUtil.d(time);//打印时间看下

                return time;
            }
        };

        linearSmoothScroller.setTargetPosition(position);
        startSmoothScroll(linearSmoothScroller);
    }
}
 
 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
 
 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59

从复写的两个方法可以看出，都是为了提高滑动速度。一种是直接修改速度，另外一种是通过减少距离来减少所需时间，间接提高滑动速度。

这两种方法都可以，看自己所需。接下来就讲讲实现的原理。这块我只是梳理的大致的流程，不过至此你已经可以实现快速滑动了。

2. RecyclerView 滑动过程梳理

1.调用RecyclerView.smoothScrollToPosition(position)时

public void smoothScrollToPosition(int position) {
        //...直接调用了LayoutManager的该方法
        mLayout.smoothScrollToPosition(this, mState, position);
    }
 
 1
2
3
4
 
 1
2
3
4

2.LinearLayoutManager中

@Override
    public void smoothScrollToPosition(RecyclerView recyclerView, RecyclerView.State state,
            int position) {
        LinearSmoothScroller linearSmoothScroller = new  LinearSmoothScroller(recyclerView.getContext()) {
                  //...
                };
        //设置终点位置
        linearSmoothScroller.setTargetPosition(position);
        //开始滚动，使用LinearSmoothScroller(一直匀速滑动，当targetPosition出现在屏幕上时再减速滑动)，startSmoothScroll()是LayoutManager中的方法
        startSmoothScroll(linearSmoothScroller);
    }
 
 1
2
3
4
5
6
7
8
9
10
11
 
 1
2
3
4
5
6
7
8
9
10
11

3.LayoutManager中

public void startSmoothScroll(SmoothScroller smoothScroller) {
     //...
     mSmoothScroller = smoothScroller;
     //调用SmoothScroller.start()方法开始滚动,this参数指当前LayoutManager
     mSmoothScroller.start(mRecyclerView, this);
}
 
 1
2
3
4
5
6
 
 1
2
3
4
5
6

4.SmoothScroller中

void start(RecyclerView recyclerView, LayoutManager layoutManager) {
    //...
    //使用ViewFlinger进行动画，ViewFlinger实现了Runnable接口，并且内部使用了Scroller，这样就可以post自己进而对RecyclerView不断layout就可以实现滑动
    mRecyclerView.mViewFlinger.postOnAnimation();
}
 
 1
2
3
4
5
 
 1
2
3
4
5

5.ViewFlinger中，这是实现滑动的重点,省略了很多代码逻辑

private class ViewFlinger implements Runnable {
     @Override
     public void run() {
        if (scroller.computeScrollOffset()) {
            //调用SmoothScroller的onAnimation方法
            smoothScroller.onAnimation(dx - overscrollX, dy - overscrollY);
        }
     }
}
 
 1
2
3
4
5
6
7
8
9
 
 1
2
3
4
5
6
7
8
9

6.SmoothScroller中

private void onAnimation(int dx, int dy) {
    //...
    if (mTargetView != null) {
        // verify target position
        if (getChildPosition(mTargetView) == mTargetPosition) {
            //要滑动到的位置已经显示在屏幕上，onTargetFound()方法里update了差值器，由线性差值器变成了减速的差值器。
            onTargetFound(mTargetView, recyclerView.mState, mRecyclingAction);
             mRecyclingAction.runIfNecessary(recyclerView);
         }

         //...

        if (mRunning) {
            //再下一次滑动
            onSeekTargetStep(dx, dy, recyclerView.mState, mRecyclingAction);
            //调用内部类Action的runIfNecessary方法
            mRecyclingAction.runIfNecessary(recyclerView);
            }
        }
 
 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
 
 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

7.Action中

private void runIfNecessary(RecyclerView recyclerView) {
    //调用了ViewFlinger.smoothScrollBy()方法，并传入了mDuration，mDuration是在SmoothScroller中upDate()时传入的，就是由前文讲的两个方法共同决定的
    recyclerView.mViewFlinger.smoothScrollBy(mDx, mDy, mDuration, mInterpolator);
}
 
 1
2
3
4
 
 1
2
3
4

8.ViewFlinger中开始滚动

public void smoothScrollBy(int dx, int dy, int duration, Interpolator interpolator) {
            if (mInterpolator != interpolator) {
                mInterpolator = interpolator;
                mScroller = ScrollerCompat.create(getContext(), interpolator);
            }
            setScrollState(SCROLL_STATE_SETTLING);
            mLastFlingX = mLastFlingY = 0;
            //调用Scroller开始滚动，此处即duration
            mScroller.startScroll(0, 0, dx, dy, duration);
            postOnAnimation();
        }
 
 1
2
3
4
5
6
7
8
9
10
11
 
 1
2
3
4
5
6
7
8
9
10
11

这块粗略的按照流程说了一下滚动过程，涉及的类比较多，最终通过Scroller来进行滚动。

使用Demo

public class FastScrollFragment extends Fragment implements View.OnClickListener {

private RecyclerView recyclerView;
private SimpleTextAdapter mAdapter;
private int mVisibleCount;

@Nullable @Override public View onCreateView(LayoutInflater inflater, @Nullable ViewGroup container,
@Nullable Bundle savedInstanceState) {
View view = inflater.inflate(R.layout.fragment_fastscroll, container, false);

recyclerView = (RecyclerView) view.findViewById(R.id.recyclerView);

LinearLayoutManager linearLayoutManager = new FastScrollLinearLayoutManager(getContext());
recyclerView.setLayoutManager(linearLayoutManager);

mAdapter = new SimpleTextAdapter(getContext(), 500);
recyclerView.setAdapter(mAdapter);

recyclerView.getViewTreeObserver()
.addOnGlobalLayoutListener(new ViewTreeObserver.OnGlobalLayoutListener() {
@Override public void onGlobalLayout() {
recyclerView.getViewTreeObserver()
.removeGlobalOnLayoutListener(this);

LinearLayoutManager linearLayoutManager = (LinearLayoutManager) recyclerView.getLayoutManager();

mVisibleCount = linearLayoutManager.findLastVisibleItemPosition()
- linearLayoutManager.findFirstVisibleItemPosition() + 1;
LogUtil.d("显示这么多个: " + mVisibleCount);
}
});

recyclerView.addItemDecoration(
new RecyclerViewDivider(getContext(), LinearLayoutManager.VERTICAL, 20, Color.BLUE));

view.findViewById(R.id.fast_top)
.setOnClickListener(this);
view.findViewById(R.id.fast_top_zhihuway)
.setOnClickListener(this);
view.findViewById(R.id.fast_end)
.setOnClickListener(this);

return view;
}

@Override public void onClick(View v) {
switch (v.getId()) {
case R.id.fast_top_zhihuway:
/*
仿知乎,先直接到一个位置,然后再滑动到顶部
*/
LinearLayoutManager linearLayoutManager = (LinearLayoutManager) recyclerView.getLayoutManager();
int firstVisibleItemPosition = linearLayoutManager.findFirstVisibleItemPosition();

if (firstVisibleItemPosition > mVisibleCount) {
recyclerView.scrollToPosition(mVisibleCount);
}
recyclerView.smoothScrollToPosition(0);

break;

/*
这两个都是在LinearSmoothScroller里缩短了单位时间距离以达到减少时间,快速滑动
*/
case R.id.fast_top:
recyclerView.smoothScrollToPosition(10000);
break;
case R.id.fast_end:
recyclerView.smoothScrollToPosition(0);
break;
}
}
}

结语：

本篇文章实现了RecyclerView的快速滚动，但需要注意一个问题：如果你的Item比较复杂，滚动起来会卡顿。这个在看源码时的一个注释里面有提到，后来实践时确实也发现。不得不说微信朋友圈滑动起来的真的快，它用的是ListView，貌似开启了FastEnable属性。
同时也可以仿照知乎，先使用RecyclerView.scrollToPosition(position)直接滑动到某一个位置后再使用smoothScrollToPosition(0)滑动到顶部。这块在RecyclerView里的Action类中jumpTo()的注释里有提到，如果很远的话可以先到一个位置后再滑动。

这两种滑动到顶部的方式都实现了一个小Demo。测试代码在GitHub上 FastScrollFragment 。
另外在自己写的小项目上也用上了 ZhihuDaily，可以查看这两个Demo来具体了解。

原文地址：http://blog.csdn.net/u014099894/article/details/51855129

chenhuakang

关注

0
点赞
踩
2

收藏

觉得还不错? 一键收藏
0
评论
Android RecyclerView 快速滑到顶部

转载请注明出处 https://github.com/baiiu使用RecyclerView时，调用smoothScrollToPostion()方法滑动到指定位置，但是条目很多时滑动的很慢，本篇文章就是实现RecyclerView的快速滑动。先介绍如何实现，然后再介绍原理。1. 实现代码创建FastScrollLinearLayoutManager
复制链接

扫一扫

专栏目录