RecyclerView 实现WheelView和省市区多级联动(1)，c#多线程面试题及答案

2401_84166702

已于 2024-04-15 11:32:03 修改

阅读量647

点赞数 11

分类专栏： 2024年程序员学习文章标签： c# 开发语言

于 2024-04-15 11:32:02 首次发布

本文链接：https://blog.csdn.net/2401_84166702/article/details/137774488

版权

2024年程序员学习专栏收录该内容

79 篇文章 0 订阅

订阅专栏

先自我介绍一下，小编浙江大学毕业，去过华为、字节跳动等大厂，目前阿里P7

深知大多数程序员，想要提升技能，往往是自己摸索成长，但自己不成体系的自学效果低效又漫长，而且极易碰到天花板技术停滞不前！

因此收集整理了一份《2024年最新HarmonyOS鸿蒙全套学习资料》，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友。

htt

既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，涵盖了95%以上鸿蒙开发知识点，真正体系化！

由于文件比较多，这里只是将部分目录截图出来，全套包含大厂面经、学习笔记、源码讲义、实战项目、大纲路线、讲解视频，并且后续会持续更新

如果你需要这些资料，可以添加V获取：vip204888 （备注鸿蒙）

正文

而它的子类 LinearSnapHelper 可以监听RecyclerView的滚动，在滚动结束后，使得最接近RecyclerView视图中心的那个Item的中心对齐到视图中心，简单描述就是它能使Item居中。

同时它也提供了很多有用的API的可重写的方法，我们通过重写onFling可以控制一下滚动速度。

class WheelLinearSnapHelper : LinearSnapHelper() {
override fun onFling(velocityX: Int, velocityY: Int): Boolean =
super.onFling(
(velocityX * flingVelocityFactor).toInt(),
(velocityY * flingVelocityFactor).toInt()
)
}

上下留白

这里的留白是指，在WheelView的开始和结束位置有一定的空白，以便于最后一个Item能滚动到中心。

因为留白的存在，当RecyclerView滚动到最上面时，第一个Item 刚好处于中间位置

上下留白的数量我们定义为offset ，从另外一个角度来看可以将留白看成offset个Header 和offset个Footer

这里的每个留白的高度一般就是Item的高度。

一般情况WheelView的每个Item的高度是一致的，我们取第一个Item的高度作为留白的高度。

以下是Header/Footer 的Adapter实现：

class OffsetAdapter(private val adapter: RecyclerView.Adapter<RecyclerView.ViewHolder>) :
RecyclerView.Adapter<RecyclerView.ViewHolder>() {
override fun onCreateViewHolder(parent: ViewGroup, viewType: Int) =
adapter.createViewHolder(parent, viewType)

override fun onBindViewHolder(holder: RecyclerView.ViewHolder, position: Int) {
if (adapter.itemCount > 0) {
adapter.onBindViewHolder(holder, 0)
}
holder.itemView.visibility = View.INVISIBLE
measureItemSize(holder.itemView) //测量和记录一下留白的高度
}

override fun getItemCount(): Int = offset
}

通过ConcatAdapter 依次连接HeaderAdapter+数据Adapter+FooterAdapter 就实现了留白功能。

在项目中，我们想给RecyclerView 的开始和结束加padding 也可以通过这种方式。

然后重新设置RecyclerView 的Adapter。

fun setAdapter(adapter: RecyclerView.Adapter

一般情况下我们的WheelView的高度都是中间选中Item的高度加上上下额外显示offset个Item的高度。

也就是一共显示offset+1+offset个Item。

所以一般WheelView高度为(offset+1+offset)*itemSize

这里我们在OffsetAdapter测量出Item尺寸后顺便设置一下WheelView的高度。

fun measureItemSize(itemView: View) {
//…
itemSize = itemView.measuredHeight + margin
recyclerView.layoutParams = recyclerView.layoutParams.apply {
width = (offset + offset + 1) * itemSize
}
}

绘制边界线

边框是一般指WheelView中间有2条边界线，用来标识WheelView 选中区域。用来告知用户，滚动到这2个边界线中间的是选中的Item。

在RecyclerView中绘制在Item之上的内容我们可以使用RecyclerView.ItemDecoration,所以几乎也不需要我们实现。

我们主要主要根据itemSize 去计算当前上下边框位置来绘制即可。

class DrawableWheelDecoration(
val drawable: Drawable,
@Px private val size: Int,
) : WheelDecoration() {
override fun onDrawOver(c: Canvas, parent: RecyclerView, state: RecyclerView.State) {
//…
val center = parent.width / 2
val left = center - wheelItemSize / 2
val right = center + wheelItemSize / 2

drawable.setBounds(left, top, right, top + size,)
drawable.draw(canvas)

drawable.setBounds(left, bottom, right, bottom + size)
drawable.draw(canvas)
}
}

用户滑动更新选中

用户滑动更新选中包括滚动的过程中选中，和滚动结束后选中。

滚动的过程中选中：一般用于实时更新Item选中状态。
滚动结束后选中：一般用于选择回调。

滚动的过程中选中

先通过SnapHelper.findSnapView()可以获取当前RecyclerView视图中心的View

然后通过layoutManager.getPosition(snapView) 来获取View的位置，就是选中的位置currentSelectedPosition。

override fun onScrolled(recyclerView: RecyclerView, dx: Int, dy: Int) {
if (itemSize == 0) {
return
}
val layoutManager = recyclerView.layoutManager ?: return
val globalAdapter = recyclerView.adapter ?: return
val dataAdapter = dataAdapter ?: return
val snapView = wheelLinearSnapHelper.findSnapView(layoutManager) ?: return
val snapViewHolder = recyclerView.getChildViewHolder(snapView)
val snapViewPositionGlobal = layoutManager.getPosition(snapView)

val snapViewPosition = globalAdapter.findRelativeAdapterPositionIn(
dataAdapter,
snapViewHolder,
snapViewPositionGlobal
)
if (snapViewPosition == RecyclerView.NO_POSITION) {
return
}

updateSelectPosition(snapViewPosition)
}

@SuppressLint(“NotifyDataSetChanged”)
private fun updateSelectPosition(selectedPositionNew: Int) {
if (currentSelectedPosition != selectedPositionNew) {
currentSelectedPosition = selectedPositionNew
onScrollingSelectListener?.invoke(selectedPositionNew)
//…
}
}

滚动过程的的选中往往是用来更新WheelView的选中状态的。

如果是BindingAdapter 的情况，我们可以添加ViewHolder.isWheelItemSelected拓展属性来方便在onBindViewHolder时获取当前是否Item是否选中。

var BindingViewHolder<*>.isWheelItemSelected: Boolean
set(value) { setTag(R.id.binding_adapter_view_holder_tag_wheel_selected, value) }
get() = getTag(R.id.binding_adapter_view_holder_tag_wheel_selected) == true

滚动结束后选中

在滚动停止时的currentSelectedPosition就是滚动结束后选中currentDeterminePosition。

override fun onScrollStateChanged(recyclerView: RecyclerView, newState: Int) {
super.onScrollStateChanged(recyclerView, newState)
if (newState == RecyclerView.SCROLL_STATE_IDLE) {
notifySelectDetermine(currentSelectedPosition)
}
}
private fun notifySelectDetermine(value: Int) {
if (currentDeterminePosition == value) {
return
}
currentDeterminePosition = value
onSelectChangeListener?.invoke(value)
}

设置选中位置

除了用户滑动去选中Item，有时候我们需要默认回显之前选中的位置，也就是代码设置选中的位置。其关键在于如何使得目标View滚动到RecyclerView中心。

可以先了解下RecyclerView的滚动到指定位置的API。

scrollToPosition 使得位于position的View显示在RecyclerView中，无法控制具体显示在上面中间还是下面。
scrollToPositionWithOffset 使得位于position的View显示在RecyclerView的顶部，并且通过offset控制偏移距离。
smoothScrollToPosition 使得位于position的View滑动到RecyclerView中，无法控制具体显示在上面中间还是下面。

可见RecyclerView没有提供直接使得目标View滚动到中心的API，因此我们需要自己实现。

实现前先稍微介绍下RecyclerView的一些布局概念：

RecyclerView重点在Recycler，Adapter里面即使有1万个数据，实际上RecyclerView的子View 也只有几个，只是复用了同样View去绑定不同数据。 这是和用LinearLayout来实现WheelView的一个比较大的区别。

也就是想设置选中位置为position=1000,并不能直接通过找position=1000的View然后计算的距离来滚动的。因为position=1000可能在屏幕外面很远，所以对应的View可能还不存在，或者说是还没有Layout 到RecyclerView中。

你可能会疑问，那scrollToPosition是咋实现的呢？

可以看看源码，它实际是设置了标记位mPendingScrollPosition，然后触发requestLayout() ，来使得RecyclerView从mPendingScrollPosition开始布局子View

因此我们实现时还需要考虑View还没有Layout到RecyclerView的情况。

幸运的是它提供了layoutManager.findViewByPosition(position) 这个API来得知是否目标View是否Layout 到RecyclerView，如果已经Layout返回其View引用。

非平滑滚动(smooth=false)

我们通过scrollToPositionWithOffset 来触发目标位置的View进行Layout，然后再下一次Layout 时找到目标位置的View，并使它滚动到中心。

doOnNextLayout 是core-ktx 实现的一个拓展函数，可以监听下一次onLayout

layoutManager.scrollToPositionWithOffset(position, 0)
recyclerView.doOnNextLayout {
//…
recyclerView.scrollToPositionCenter(wheelLinearSnapHelper, adapter, position)
}

然后实现滚动到中心的逻辑，利用 snapHelper.calculateDistanceToFinalSnap计算目标view到中心的距离，然后通过scrollBy 滚动即可

internal fun RecyclerView.scrollToPositionCenter(
snapHelper: SnapHelper,
adapter: RecyclerView.Adapter<*>,
position: Int
) {
val globalAdapter = this.adapter ?: return
val globalPosition =
globalAdapter.findGlobalAdapterPositionInCompatSelf(adapter, position)
val layoutManager = this.layoutManager as? LinearLayoutManager ?: return
val view = layoutManager.findViewByPosition(globalPosition)
?: return

val snapDistance =
snapHelper.calculateDistanceToFinalSnap(layoutManager, view)
?: return
scrollBy(snapDistance[0], snapDistance[1])
}

经过了scrollToPositionWithOffset和doOnNextLayout，这里的目标View应该是已经Layout到RecyclerView中的，也就是layoutManager.findViewByPosition(globalPosition) 理论上不会返回null。如果使用了ConcatAdapter，findViewByPosition使用的position需要注意使用全局的position，具体如何转换可以查看本项目源码，这里不展开讲。

平滑滚动(smooth=true)

平滑滚动在设置选中目标View时，它是通过动画慢慢滑动到对应的View的。

当View是已经Layout的情况下，和非平滑滚动的处理方式一样，只需把上面的scrollBy 改成 smoothScrollBy 即可实现滚动动画。

当View是没有Layout的情况，稍微复杂一点，先看看RecyclerView提供的API。

查看源码可以看到 recyclerView.smoothScrollToPosition 最终是调用的layoutManager.startSmoothScroll(linearSmoothScroller)

也就是将滑动逻辑封装在了LinearSmoothScroller中，查看LinearSmoothScroller 源码可以发现，它会通过动画慢慢向目标位置滚动。边滚动边触发那些快要进入RecyclerView可见范围的View进行数据绑定和Layout，直到发现目标位置的View时会回调onTargetFound，

因为发现的时候，可能是在RecyclerView的边缘，这个时候它通过calculateDyToMakeVisible

去计算能使得这个View完全显示所需要的滚动距离。

从方法名也可以看出，calculateDyToMakeVisible只是为了让View变得可见，而不是让View变得到顶部或底部或正中间，所以它只能保证是可见的。

calculateDyToMakeVisible 和calculateDxToMakeVisible 只是适配了横向和竖向，最终都调用了calculateDtToFit 来计算滚动距离的计算。

calculateDtToFit 的默认实现就是只是滚动到让View可见的距离，比如View顶部和RecyclerView 顶部对其时的距离。

我们的目的是让View在正中间，所以需要计算子View的中心位置和RecyclerView的中心位置的距离。

private class CenterLinearSmoothScroller(context: Context?) : LinearSmoothScroller(context) {
override fun calculateDtToFit(
viewStart: Int,
viewEnd: Int,
boxStart: Int,
boxEnd: Int,
snapPreference: Int
): Int {
val childCenter = viewStart + ((viewEnd - viewStart) / 2)
val containerCenter = boxStart + ((boxEnd - boxStart) / 2)
return containerCenter - childCenter
}
}

最后实例化这个CenterLinearSmoothScroller使用layoutManager.startSmoothScroll 来实现滑动到中心。

internal fun RecyclerView.smoothScrollToPositionCenter(
snapHelper: SnapHelper,
duration: Int,
position: Int
) {
if (position < 0) {
return
}
val layoutManager = this.layoutManager as? LinearLayoutManager ?: return
val view = layoutManager.findViewByPosition(position)

if (view == null) {
val linearSmoothScroller = CenterLinearSmoothScroller(this.context)
linearSmoothScroller.targetPosition = position
layoutManager.startSmoothScroll(linearSmoothScroller)
return
}
val snapDistance =
snapHelper.calculateDistanceToFinalSnap(layoutManager, view)
?: return

this.smoothScrollBy(snapDistance[0], snapDistance[1], null, duration)

}

多个滚轮的联动封装

联动就是多个滚轮的数据是有联系的，比如年月日，省市区等。

在一个滚轮的选中变化时，被联动的滚轮数据也会进行变化。

以省市区为例，市的数据是根据选的省定的，区的数据是根据选的省和市定的。

也就是这种联动关系本质也是一种依赖关系，A依赖[],B依赖[A],C依赖[A,B],D依赖[A,B,C],...。

这里为了方便我们就不单独成一个模块了，而是直接继承LinearLayout来线性放置多个滚轮WheelView。

然后使用去存储来支持任意个WheelView的联动。

为了方便存储和获取各个WheelView的属性，我们使用WheelWrapper来稍微包装一下每一个WheelView, 并存储到List<WheelWrapper> 中。

同时我们将各个WheelView上述的依赖关系也存储起来，方便加载数据的时候使用。

class LinkageWheelView : LinearLayout(context, attrs) {
//…
val children: MutableList = ArrayList()

class WheelWrapper internal constructor(
parent: WheelWrapper?,
private val dataProvider: DataProvider,
private val wheelModule: RecyclerWheelViewModule,
private val adapter: BindingAdapter<CharSequence, *>,
) {
private val parents: Array
//…
}
}

因为WheelView的数据是不定的，因此每个WheelView提供数据时不是直接提供固定的List 数据，而是需要提供一个DataProvider作为数据加载器，根据其依赖的的WheelView去加载。

class LinkageWheelView {
//…
private val currentData: MutableList = ArrayList()

fun interface DataProvider {
fun onLoad(
cancellationSignal: CancellationSignal,
parents: Array,
loadCallback: (List) -> Unit
)
}
}

CancellationSignal 是Android的一个帮助实现取消的工具。

比如区的WheelView根据省和市来加载的DataProvider大约是这样的：

DataProvider { cancel, parents, callback ->
val (provinceWheel, cityWheel) = parents
val counties = getCounties(provinceWheel.selectItem, cityWheel.selectItem)
callback(counties)
}

然后设置DataProvider的时候，根据每个DataProvider去实例化WheelView。

然后按顺序依次建立联动：也就是其依赖的WheelView选中数据变化时，重新加载数据。

fun setData(currentData: List) {
//…
var parent: WheelWrapper? = null
for ((index, dataProvider) in currentData.withIndex()) {
//创建一个WheelView,addView 添加到布局
val wheelItem = instantWheelWrapper(index, factory, parent, dataProvider)

parent?.observeDetermineChange {
//联动的WheelView选中数据变化时，重新加载本WheelView的数据
wheelItem.loadData()
}

children.add(wheelItem)
parent = wheelItem
}

//加载初始数据
children.firstOrNull()?.loadData()
}

observeDetermineChange 的作用是设置监听器，监听当前选中数据的变化，一般就是WheelView选中变化和数据更新2种情况

class WheelWrapper {
private var selectChangeListener: (() -> Unit)? = null

init {
wheelModule.onSelectChangeListener = { selectChangeListener?.invoke() }
}

internal fun observeDetermineChange(listener: () -> Unit) {
selectChangeListener = listener
}

internal fun loadData() {
//…
dataProvider.onLoad(cancellationSignal, parents) { data ->
//…
adapter.replaceData(data)
selectChangeListener?.invoke()
}
}
}

至此滚轮联动的核心逻辑就完成了。

设置选中位置

但是往往我们选中省市区时，需要回显当前选中的数据，因此我们还需要支持设置选中位置。

在前面的WheelView中我们已经实现了设置单个WheelView的选中位置。因此如果WheelView之间关联不大，能直接各自设置自己位置就简单了比如3个WheelView都是选择一个0~9的数，那么只需要计算其位置设置上去即可

fun setCurrentPositions(positions: List, smooth: Boolean = true) {
for (i in 0 until positions.size.coerceAtMost(children.size)) {
children[i].setSelectedPosition(positions[i], smooth)
}
}

但是联动的情况，选中广东省-韶关市-曲江区的流程是这样的：

先计算广东省在[广西省,广东省,...]的位置，然后设置第1个WheelView的选中
第2个WheelView监听到第1个WheelView的选中变化了，于是加载市的数据[韶关市,广州市,珠海市,...]
计算韶关市在[韶关市,广州市,珠海市,...]的位置，然后设置第2个WheelView的选中
第3个WheelView监听到第2个WheelView的选中变化了，于是加载区的数据[浈江区,曲江区,武江区,...]
计算曲江区在[浈江区,曲江区,武江区,...]的位置，然后设置第3个WheelView的选中

因此我们需要实现一个API，能单独设置某个WheelView的选中位置，然后其引导的数据加载完成后，需要回调给调用者。

/**

设置指定WheelView位置
@param childIndex 指定index的滚轮
@param position 滚轮需要滑动到的位置
@param smooth 是否平滑滚动
@param childDataLoad 滚轮滑动完成回调,并且子滚轮数据已经加载完成。如果当前滚轮已经是最后的，那么不会触发回调
*/
fun setCurrentPosition(
childIndex: Int,
position: Int,
smooth: Boolean = true,
childDataLoad: ((WheelWrapper) -> Unit)
) {
//…
children.getOrNull(childIndex)?.setSelectedPosition(position, smooth)
//省略其他情况…

val after = children.getOrNull(childIndex + 1)?.scheduleDataLoadCallback {
childDataLoad(after)
}
}

scheduleDataLoadCallback 就是放置一个callback来监听数据加载。

class WheelWrapper {
private var dataLoadedCallback: ((data: List) -> Unit)? = null
fun scheduleDataLoadCallback(callback: (data: List) -> Unit) {
dataLoadedCallback = callback
}
internal fun loadData() {
//…
dataProvider.onLoad(cancellationSignal, parents) { data ->
//…
adapter.replaceData(data)
dataLoadedCallback?.invoke(data)
dataLoadedCallback = null
}
}

}

使用起来就像这样:

val p0 = linkageWheelView.wheels.first().items.indexOf(“广东省”)
linkageWheelView.setCurrentPosition(0, p0) {
val p1 = it.items.indexOf(“韶关市”)
linkageWheelView.setCurrentPosition(1, p1) {
val p2 = it.items.indexOf(“曲江区”)
linkageWheelView.setCurrentPosition(2, p2) {

}
}
}

好像方式丑了一点,那就再用 DSL 拓展优化一下：

网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。

需要这份系统化的资料的朋友，可以添加V获取：vip204888 （备注鸿蒙）

一个人可以走的很快，但一群人才能走的更远！不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！

ationSignal, parents) { data ->
//…
adapter.replaceData(data)
dataLoadedCallback?.invoke(data)
dataLoadedCallback = null
}
}

}

使用起来就像这样:

}
}
}

好像方式丑了一点,那就再用 DSL 拓展优化一下：

网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。

需要这份系统化的资料的朋友，可以添加V获取：vip204888 （备注鸿蒙）
[外链图片转存中…(img-AT6Cfwsm-1713151846239)]

2401_84166702

关注

11
点赞
踩
20

收藏

觉得还不错? 一键收藏
0
评论
RecyclerView 实现WheelView和省市区多级联动(1)，c#多线程面试题及答案

经过了scrollToPositionWithOffset和doOnNextLayout，这里的目标View应该是已经Layout到RecyclerView中的，也就是layoutManager.findViewByPosition(globalPosition) 理论上不会返回null。如果使用了ConcatAdapter，findViewByPosition使用的position需要注意使用全局的position，具体如何转换可以查看本项目源码，这里不展开讲。边滚动边触发那些快要进入。
复制链接

扫一扫