2024年鸿蒙最新RecyclerView 实现WheelView和省市区多级联动(4)，2024年最新跳槽面试大厂被拒怎么回复

本文链接：https://blog.csdn.net/2401_84871072/article/details/138901719

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

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

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

fun onCreate() {
    recyclerView.adapter = wheelAdapter

    val wheelModule = recyclerView.setupWheelModule()
    wheelModule.apply {
        offset = 1
        orientation = RecyclerWheelViewModule.VERTICAL
        setWheelDecoration(DefaultWheelDecoration(10.dp, 10.dp, 2.dp, "#dddddd".toColorInt()))
        onSelectChangeListener = {

        }
    }
}

}


## 原理


`WheelView`的功能本身并不复杂，**布局**和**滚动**都是`RecyclerView`已经处理好的。


因此我们只需要解决一些`WheelView`的特性即可。


本着代码越少，Bug越上的原则。绝大多数特性都尽量使用`RecyclerView`提供的API，或者官方已有的模块去实现。


实现一个`WheelView`的功能主要完成以下实现：


* 选中的`Item`居中显示，在滚动后自动居中选中的位置
* `Item`的最上和最下有一定滚动间距，来使得最边缘的`Item`可以居中，同时让`WheelView` 的尺寸恰好显示3个或5个`Item`
* 支持绘制上下边界线来标识给用户滚轮选中区域
* 用户滑动时，更新选中位置，并刷新`Item`数据,如加粗或者设置字体颜色为黑色
* 支持代码设置和获取当前选中位置


### Item居中


`WheelView`在滚动停止后，会自动使得当前最靠近中间的`Item`滚动到布局的中心位置。


官方提供了 SnapHelpe 来帮助我们处理`Item`的对齐。


而它的子类 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` 刚好处于中间位置


![](https://img-blog.csdnimg.cn/img_convert/5c1a5c6067ba84098ce5352ccb26aed6.webp?x-oss-process=image/format,png)


![](https://img-blog.csdnimg.cn/img_convert/f5dfc3ee611172607c43fee8ebdd3e77.webp?x-oss-process=image/format,png)


上下留白的数量我们定义为`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`。


![](https://img-blog.csdnimg.cn/img_convert/fed861b2b85e2c9847e1a14917b13937.webp?x-oss-process=image/format,png)


在`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)
}

}


### 用户滑动更新选中


![](https://img-blog.csdnimg.cn/img_convert/c9bc879e5ff45a8b32e3113f5cac6b9d.webp?x-oss-process=image/format,png)


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


* 滚动的过程中选中：一般用于实时更新`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`


![](https://img-blog.csdnimg.cn/img_convert/b9605576f06d7cde713d2473713a5d2f.webp?x-oss-process=image/format,png)


因此我们实现时还需要考虑**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`，


![](https://img-blog.csdnimg.cn/img_convert/62472195cebbc8db0ad6a50b0ecfcd7d.webp?x-oss-process=image/format,png)


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


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



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


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


![](https://img-blog.csdnimg.cn/img_convert/31661960f799becd0d3d4d9849916ebb.webp?x-oss-process=image/format,png)


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


![](https://img-blog.csdnimg.cn/img_convert/09041472590a72e8f7d8bfa5968d1347.webp?x-oss-process=image/format,png)


我们的目的是让`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<WheelWrapper>
    //...
}

}


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

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

fun interface DataProvider {
    fun onLoad(
        cancellationSignal: CancellationSignal,
        parents: Array<WheelWrapper>,
        loadCallback: (List<CharSequence>) -> 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. 先计算`广东省`在`[广西省,广东省,...]`的位置，然后设置第1个`WheelView`的选中
2. 第2个`WheelView`监听到第1个`WheelView`的选中变化了，于是加载市的数据`[韶关市,广州市,珠海市,...]`
3. 计算`韶关市`在`[韶关市,广州市,珠海市,...]`的位置，然后设置第2个`WheelView`的选中
4. 第3个`WheelView`监听到第2个`WheelView`的选中变化了，于是加载区的数据`[浈江区,曲江区,武江区,...]`
5. 计算`曲江区`在`[浈江区,曲江区,武江区,...]`的位置，然后设置第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)
//省略其他情况…

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

需要这份系统化的资料的朋友，可以戳这里获取

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

hildIndex 指定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)
//省略其他情况…

[外链图片转存中…(img-TIj4kshp-1715743844944)]
[外链图片转存中…(img-n2temZKr-1715743844945)]

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

需要这份系统化的资料的朋友，可以戳这里获取