深知大多数程序员,想要提升技能,往往是自己摸索成长,但自己不成体系的自学效果低效又漫长,而且极易碰到天花板技术停滞不前!
既有适合小白学习的零基础资料,也有适合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)]
网上学习资料一大堆,但如果学到的知识不成体系,遇到问题时只是浅尝辄止,不再深入研究,那么很难做到真正的技术提升。
一个人可以走的很快,但一群人才能走的更远!不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人,都欢迎加入我们的的圈子(技术交流、学习资源、职场吐槽、大厂内推、面试辅导),让我们一起学习成长!