RV怎么翻滚到指定索引
前语
看到标题或许有同学有点疑问，这不是有手就行？ 且慢，听我渐渐道来。
确实，RV 内部提供了一系列的翻滚办法：
scrollTo，scrollBy，scrollToPosition ，还有一系列的 smoothScrollTo，smoothScrollBy，smoothScrollToPosition。甚至还有嵌套的 nestedScrollBy，nestedScrollByInternal等等。
难道这些都不能完结指定到翻滚索引的逻辑？额，当然能，可是又不是那么能！
为什么这么说？或许咱们对 翻滚到指定索引 这个需求的理解有所误差。
谷歌理解的 翻滚到指定索引 是当时索引在屏幕上可见了就到达意图，而咱们需求的作用是展现到指定索引并且在顶部展现。
那这又有什么区别？
比方咱们要翻滚到第 75 的索引，那么当这个 Item 在屏幕中间，或许在屏幕上面，或许在屏幕下面，三种状况翻滚到索引的作用都是不同的。
从屏幕上翻滚到 75 索引，是契合咱们的预期，展现出来也是在顶部展现，可是假如从屏幕下翻滚到 75 索引，就只会出现在底部，而假如 75 索引的 Item 本来就在屏幕中间，那么点击回到索引则无反响。在谷歌看来它现已是在屏幕中了。
所以为了完结 翻滚到指定索引并在顶部展现 这个作用，本文才对 RV 的翻滚做了一些兼容操作，尝试性的出一篇文章讨论一下。
本文并没有涉及到源码，全程轻松愉快容易理解，下面开端正文 ↓
一、scrollToPosition的运用
首要不管是 scrollToPosition 还是 smoothScrollToPosition 都是由 LayoutManager 办理与完结的。
所以关于 scrollToPosition 咱们其实调用 LayoutManager 的办法也是能完结的：
layoutManager.scrollToPositionWithOffset(position, 0) layoutManager.scrollToPosition(position)
其次，scrollToPosition 与 smoothScrollToPosition 的基本是有区别的。
scrollToPosition 内部其实仅仅 requestLayout 从头布局罢了，办法写的是scroll，可是并没有滚。能够理解为仅仅相当于改写了布局罢了。
而 smoothScrollToPosition 是实在的翻滚了，由 RecyclerView.SmoothScroller 办理，而咱们常用的 LinearLayoutManager 内部也是用的默许完结的 LinearSmoothScroller 来办理翻滚的。
大部分状况下都是够咱们用的了，假如想要一些特殊作用也能够自定义 LinearLayoutManager 与 LinearSmoothScroller 自己办理翻滚，也能够重写部分办法到达想要的作用，比方翻滚的间隔操控，翻滚的速度操控等。
咱们先看看前语中的三种作用，究竟是不是对的，下面给出简易代码：
val datas = arrayListOf<String>()
for (i in 0..99) {
datas.add("Item 内容 $i")
}
//RV绑定Adapter
mBinding.recyclerView.vertical()
.bindData(datas, R.layout.item_custom_jobs) { holder, t, _ ->
holder.setText(R.id.tv_job_text, t)
}
.divider(Color.BLACK)
.scrollToPosition(50)
mBinding.btnScollTo.click {
mBinding.recyclerView.scrollToPosition(75)
}
下面给出 GIF 的图片演示：
我要翻滚的是第 75 个索引，可是这个 Item 要么就不收效，要么就在底部展现，这并不契合我（产品）的要求。
没办法，只能对翻滚作用对这三种状况别离做处理，（我知道 scrollToPositionWithOffset 好用），可是或许部分同学的RV版本并没有那么高，还是分状况判别兼容性更好一点。
修正代码如下：
private fun rvScrollToPosition(rv: RecyclerView, layoutManager: LinearLayoutManager, position: Int) {
val firstPos = layoutManager.findFirstVisibleItemPosition()
val lastPos: Int = layoutManager.findLastVisibleItemPosition()
YYLogUtils.w("firstPos:$firstPos lastPos:$lastPos position:$position")
if (position <= firstPos) {
//当要置顶的项在当时显现的第一个项的前面时
rv.scrollToPosition(position)
} else if (position <= lastPos) {
//当要置顶的项现已在屏幕上显现时
val childAt: View? = layoutManager.findViewByPosition(position)
var top = childAt?.top ?: 0
rv.scrollBy(0, top)
} else {
//当要置顶的项在当时显现的最后一项之后
layoutManager.scrollToPositionWithOffset(position, 0)
}
}
那么咱们经过这个办法去翻滚的话，那么作用如下：
没错这样才是我（产品）想要的作用！
二、smoothScrollToPosition的运用
虽然能完结作用了，可是有些时分，我（产品）更喜爱用一些翻滚作用，这中选中作用太突兀了，只适合一些初始化选中的作用，当用户点击按钮或操作之后，咱们的 RV 缓缓翻滚到指定的索引位置，看起来很美！
咱们先试试原生的 smoothScrollToPosition 运用作用，还是分为上面的三种状况，那么作用便是如下：
还是会有相同的问题，那么咱们能不能经过像上面相同的办法来判别呢？能，又不能。
思路是一个思路，可是完结的进程不同了，由于不同的间隔的翻滚进程与翻滚时长是不同的，所以咱们至少需求在翻滚完结之后的监听中进行处理，可是咱们有翻滚完结的监听吗？没有！
所以咱们只能间接的经过RV的翻滚监听来完结是否现已完结翻滚
mBinding.recyclerView.addOnScrollListener(object : RecyclerView.OnScrollListener() {
override fun onScrollStateChanged(recyclerView: RecyclerView, newState: Int) {
if (smoothScrolling || newState == SCROLL_STATE_IDLE) {
val lastPos: Int = layoutManager.findLastVisibleItemPosition()
if (smoothScrollPosition >= 0 && lastPos == smoothScrollPosition) {
val childAt: View? = layoutManager.findViewByPosition(lastPos)
var top = childAt?.top ?: 0
recyclerView.scrollBy(0, top)
mBinding.recyclerView.removeOnScrollListener(this)
smoothScrollPosition = -1
}
smoothScrolling = false
}
}
override fun onScrolled(recyclerView: RecyclerView, dx: Int, dy: Int) {
}
})
作用为：
这不就行了吗？
下面给出完好的工具类办法，假如咱们想要横向的翻滚或许其他 LayoutManager 的作用，稍作修正即可：
object RVScrollUtils {
/**
* 缓慢翻滚
*/
fun rvSmoothScrollToPosition(recyclerView: RecyclerView, layoutManager: LinearLayoutManager, position: Int) {
var smoothScrolling = true
val firstPos: Int = layoutManager.findFirstVisibleItemPosition()
val lastPos: Int = layoutManager.findLastVisibleItemPosition()
if (position in (firstPos + 1) until lastPos) {
val childAt: View? = layoutManager.findViewByPosition(position)
var top = childAt?.top ?: 0
recyclerView.smoothScrollBy(0, top)
} else {
recyclerView.addOnScrollListener(object : RecyclerView.OnScrollListener() {
override fun onScrollStateChanged(recyclerView: RecyclerView, newState: Int) {
if (smoothScrolling || newState == RecyclerView.SCROLL_STATE_IDLE) {
if (position in layoutManager.findFirstVisibleItemPosition() + 1..layoutManager.findLastVisibleItemPosition()) {
val childAt: View? = layoutManager.findViewByPosition(position)
val top = childAt?.top ?: 0
recyclerView.scrollBy(0, top)
recyclerView.removeOnScrollListener(this)
}
smoothScrolling = false
}
}
override fun onScrolled(recyclerView: RecyclerView, dx: Int, dy: Int) {
}
})
recyclerView.smoothScrollToPosition(position)
}
}
/**
* 直接跳转改写Layout
*/
fun rvScrollToPosition(rv: RecyclerView, layoutManager: LinearLayoutManager, position: Int) {
val firstPos = layoutManager.findFirstVisibleItemPosition()
val lastPos: Int = layoutManager.findLastVisibleItemPosition()
if (position <= firstPos) {
//当要置顶的项在当时显现的第一个项的前面时
rv.scrollToPosition(position)
} else if (position <= lastPos) {
//当要置顶的项现已在屏幕上显现时,经过LayoutManager
val childAt: View? = layoutManager.findViewByPosition(position)
var top = childAt?.top ?: 0
rv.scrollBy(0, top)
} else {
//当要置顶的项在当时显现的最后一项之后
layoutManager.scrollToPositionWithOffset(position, 0)
}
}
}
三、smoothScroll的速度操控
产品：不错，作用不错，可是还差了那么一丢丢。 开发：这不挺好的吗？翻滚作用不错。 产品：你这个隔的远的翻滚时刻长，隔的近的翻滚时刻短，作用不统一，我想要的是不管远近都要翻滚时刻统一。 开发：你这什么鬼需求，就不契合物理学规律，牛顿的棺材… 哎哎哎，有话好好说，快把刀放下，又没说不能做，急什么…
虽然说体系的默许翻滚作用以及能满足绝大部分的需求了，可是总有一些奇葩的需求需求一些定制，咱们也能经过重写一些 LayoutManager 等类，能够自己操控股翻滚的间隔与翻滚的速度。
LayoutManager 本身是负责 RV 的布局展现的，内部的 翻滚 逻辑是交由LinearSmoothScroller 来完结的。
那么怎么获取翻滚的间隔呢？咱们需求重写 onTargetFound 办法，内部的参数是需求翻滚到的 ItemView 目标，然后经过体系办法 calculateDyToMakeVisible 级能够核算出需求翻滚的间隔。
计划一：指定翻滚时刻
@Override
protected void onTargetFound(View targetView, RecyclerView.State state, Action action) {
final int dx = calculateDxToMakeVisible(targetView, getHorizontalSnapPreference());
final int dy = calculateDyToMakeVisible(targetView, getVerticalSnapPreference());
//获取翻滚间隔
final int distance = (int) Math.sqrt(dx * dx + dy * dy);
//依据翻滚间隔核算时刻
final int time = calculateTimeForDeceleration(distance);
YYLogUtils.w("打印需求翻滚的时刻与间隔，distance："+distance + " time:"+time);
if (time > 0) {
action.update(-dx, -dy, time, mDecelerateInterpolator);
}
}
打印成果如下：
能够看到确实是翻滚的间隔越长，所需求的时刻也是越长的。假如咱们需求修正翻滚的时刻，那么还需求修正翻滚的速度，应该这个 calculateTimeForDeceleration 办法，假如想定死翻滚的时长咱们能够直接重写 calculateTimeForDeceleration 或 calculateTimeForScrolling 即可。
@Override
protected int calculateTimeForDeceleration(int dx) {
return 5000;
}
打印日志：
作用便是：
咱们改为实在的 250ms 之后感觉还行，可是假如翻滚间隔太长，而实际动画时刻太短，会导致更难看的作用：
产品看了这个作用直拍脑门。。。这作用不太行啊。那能不能动态的改动翻滚速度呢？
计划二：指定翻滚速度
先说怎么改变翻滚速度，咱们只需求重写 calculateSpeedPerPixel 办法即可，内部完结滑动一个像素需求多少毫秒。
比方：
@Override
protected float calculateSpeedPerPixel(DisplayMetrics displayMetrics) {
//滑动一个像素需求多少毫秒
return 25f / displayMetrics.density;
}
作用为：
假如想更快或更慢，就能够自己调试。那么再接上面的需求，咱们就能够修正速度不就行了吗？当间隔隔得比较远的时分咱们就设置速度快一些，当隔的比较近的时分咱们设置速度慢一些。
public class SmoothLinearLayoutManager extends LinearLayoutManager {
private float MILLISECONDS_PER_INCH = 25f;
private Context contxt;
public SmoothLinearLayoutManager(Context context) {
super(context);
this.contxt = context;
}
public SmoothLinearLayoutManager(Context context, int orientation, boolean reverseLayout) {
super(context, orientation, reverseLayout);
this.contxt = context;
}
@Override
public void smoothScrollToPosition(RecyclerView recyclerView, RecyclerView.State state, int position) {
LinearSmoothScroller linearSmoothScroller = new LinearSmoothScroller(recyclerView.getContext()) {
private int distance = 0;
@Override
protected void onTargetFound(View targetView, RecyclerView.State state, Action action) {
final int dx = calculateDxToMakeVisible(targetView, getHorizontalSnapPreference());
final int dy = calculateDyToMakeVisible(targetView, getVerticalSnapPreference());
//获取翻滚间隔
distance = (int) Math.sqrt(dx * dx + dy * dy);
//依据翻滚间隔核算时刻
final int time = calculateTimeForDeceleration(distance);
if (time > 0) {
action.update(-dx, -dy, time, mDecelerateInterpolator);
}
}
@Override
public PointF computeScrollVectorForPosition(int targetPosition) {
return super.computeScrollVectorForPosition(targetPosition);
}
@Override
protected int calculateTimeForDeceleration(int dx) {
return 250;
}
@Override
protected float calculateSpeedPerPixel(DisplayMetrics displayMetrics) {
return 15f / displayMetrics.densityDpi;
}
};
linearSmoothScroller.setTargetPosition(position);
startSmoothScroll(linearSmoothScroller);
}
}
再从远处滚到到一个长间隔的索引的作用：
计划三：自定义翻滚与改写
其实到这儿现已基本满足产品的需求了，可是咱们寻求细节的话，其实也能够看到从 0 到 75 的索引是稍微大于 250ms 的。
为什么呢？这就要看源码…，好吧直接讲结论。
其实 RV 的翻滚原理便是从第一帧的动画回调开端就开端找 View ,检查当时 Position 是否在屏幕上了。假如指定的 View 没有在屏幕上，那么就履行 onSeekTargetStep 持续找，假如不在就持续找，一直到找到View在屏幕上了才会调用 onTargetFound 办法。所以咱们上面的办法直接从 onTargetFound 拿参数就现已是晚了。现已履行了N次 onTargetFound 和动画办法了。仅仅咱们设置了动画时刻短显得比较快罢了。
//太远了，没有找到View
@Override
protected void onSeekTargetStep(int dx, int dy, RecyclerView.State state, Action action) {
YYLogUtils.w("太远了，没有找到View dy："+dy);
super.onSeekTargetStep(dx, dy, state, action);
}
//渐渐滚渐渐找，找到了！
@Override
protected void onTargetFound(View targetView, RecyclerView.State state, Action action) {
YYLogUtils.w("渐渐滚渐渐找，找到了");
//下面才开端翻滚到实在的位置
}
能够看到调用的次序：
所以假如真的要针对性的优化这一点话，咱们能够绕过这些流程，直接做到另一种作用：假如需求翻滚的间隔大于一屏高度，咱们就只翻滚一屏的高度，然后直接改写到指定的位置，比方：scrollToPositionWithOffset 。
咱们修正代码如下：
LinearSmoothScroller linearSmoothScroller = new LinearSmoothScroller(recyclerView.getContext()) {
boolean startScrolling = false;
//太远了，没有找到View
@Override
protected void onSeekTargetStep(int dx, int dy, RecyclerView.State state, Action action) {
if (!startScrolling) {
startScrolling = true;
int height = recyclerView.getMeasuredHeight();
recyclerView.smoothScrollBy(0, height);
recyclerView.addOnScrollListener(new RecyclerView.OnScrollListener() {
@Override
public void onScrollStateChanged(@NonNull RecyclerView rv, int newState) {
if (startScrolling && newState == RecyclerView.SCROLL_STATE_IDLE) {
scrollToPositionWithOffset(position, 0);
recyclerView.removeOnScrollListener(this);
startScrolling = false;
}
}
@Override
public void onScrolled(@NonNull RecyclerView recyclerView, int dx, int dy) {
}
});
}
}
//渐渐滚渐渐找，找到了！
@Override
protected void onTargetFound(View targetView, RecyclerView.State state, Action action) {
final int dx = calculateDxToMakeVisible(targetView, getHorizontalSnapPreference());
final int dy = calculateDyToMakeVisible(targetView, getVerticalSnapPreference());
//获取翻滚间隔
final int distance = (int) Math.sqrt(dx * dx + dy * dy);
//依据翻滚间隔核算时刻
final int time = calculateTimeForDeceleration(distance);
if (time > 0) {
action.update(-dx, -dy, time, mDecelerateInterpolator);
}
}
@Override
public PointF computeScrollVectorForPosition(int targetPosition) {
return super.computeScrollVectorForPosition(targetPosition);
}
@Override
protected int calculateTimeForDeceleration(int dx) {
return 250;
}
@Override
protected float calculateSpeedPerPixel(DisplayMetrics displayMetrics) {
return 15f / displayMetrics.densityDpi;
}
};
linearSmoothScroller.setTargetPosition(position);
startSmoothScroll(linearSmoothScroller);
}
这样便是先滚着，翻滚到指定间隔之后再改写到指定的索引：
看似还行，可是这个计划有一点不完美，便是翻滚完结之后改写的那一下卡顿作用有一点突兀。
计划四：自定义改写与翻滚
那其实咱们换一个思路，先改写到离当时 Position 的一屏幕间隔然后再滚过去不就行了吗？
听起来就比较靠谱，这儿分为索引的完结办法与间隔的完结办法：
@Override
protected void onSeekTargetStep(int dx, int dy, RecyclerView.State state, Action action) {
YYLogUtils.w("太远了，没有找到View dy：" + dy + " action-dy:" + action.getDy() + " action-du:" + action.getDuration());
//实在场景需求判别索引与方向
if (!startScrolling) {
startScrolling = true;
int firstPos = findFirstVisibleItemPosition();
//依据实在场景判别是否超越索引边界与展现边界
if (firstPos < position) {
scrollToPositionWithOffset(position - 10, 0);
} else {
scrollToPositionWithOffset(position + 10, 0);
}
recyclerView.addOnScrollListener(new RecyclerView.OnScrollListener() {
@Override
public void onScrollStateChanged(@NonNull RecyclerView rv, int newState) {
if (startScrolling && newState == RecyclerView.SCROLL_STATE_IDLE) {
recyclerView.removeOnScrollListener(this);
startScrolling = false;
}
}
@Override
public void onScrolled(@NonNull RecyclerView recyclerView, int dx, int dy) {
}
});
recyclerView.smoothScrollToPosition(position);
}
}
下面一种是依据间隔来完结：
@Override
protected void onSeekTargetStep(int dx, int dy, RecyclerView.State state, Action action) {
YYLogUtils.w("太远了，没有找到View dy：" + dy + " action-dy:" + action.getDy() + " action-du:" + action.getDuration());
//实在场景需求判别索引与方向
int firstPos = findFirstVisibleItemPosition();
int lastPos = findLastVisibleItemPosition();
PointF pointF = computeScrollVectorForPosition(position);
int height = recyclerView.getMeasuredHeight();
float distance = Math.abs((position - firstPos) * getDecoratedMeasuredHeight(getChildAt(0))) / pointF.y;
if (distance > 0) {
recyclerView.scrollBy(0, (int) distance - height);
} else {
recyclerView.scrollBy(0, (int) distance + height);
}
recyclerView.smoothScrollToPosition(position);
}
作用，从0 翻滚到 75 索引：
这生成的都是什么鬼GIF 。原谅我这录制工具…由于不是录屏是MP4转的，作用欠好，咱们有条件能够去自行完结或运行Demo。
总结
看到这儿咱们应该对这些翻滚作用有所了解，怎么 scrollToPosition 并置顶，怎么 smoothScrollToPosition 并置顶。
这也是咱们常用的作用，一般来说咱们只用到上面的几种办法即可，假如要完结产品这种固定时长的翻滚的类似作用，咱们也能够参阅第三点的四种计划来完结。
由于这些翻滚作用是跟事务逻辑关联的，许多当地都是伪代码，并没有完善也没有解决索引越界之类的问题，假如咱们有需求还是需求参阅来完结的。
惯例了，我如有解说不到位或错漏的当地，期望同学们能够指出。
我知道各位大神都有各种骚操作完结这些作用，假如有更好的办法或其他办法，或许你有遇到的坑也都能够在谈论区沟通一下，咱们互相学习进步嘛。
本文的部分代码能够在我的 Kotlin 测验项目中看到，【传送门】。你也能够关注我的这个Kotlin项目，我有时刻都会持续更新。
Ok,这一期就此完结。
本文正在参加「金石计划」
