前言
滚轮经常在挑选中用到,首要包含类型挑选、省市区联动挑选、年月日联动挑选等。
项目中的WheelView
一般都是ScrollView+LinearLayout
组合完结的。
可是自界说起来比较杂乱,也有一些优秀的第三方库DateSelecter
经过Adapter
的思想来灵敏处理自界说的问题。
可是既然用到了Adapter
的思想,那为啥不运用RecyclerView
来完结呢?,毕竟咱们比较了解RecyclerView.Adapter
也便利和项目中现有的Adapter
复用。
所以我基于RecyclerView
完结了一个滚轮模块,这些是他的根底功用:
- 对
RecyclerView
,Adapter
低侵入性,逻辑独自封装成RecyclerWheelViewModule
- 支撑经过
Adapter
自界说WheelView
样式 - 支撑横向和竖向
- 支撑自界说
WheelView
边框
一起在滚轮模块的根底上,完结了联动滚轮View
的封装。
项目地址 BindingAdapter
- 拓宽模块-分页模块
- 拓宽模块-挑选模块
- 拓宽模块-滚轮模块
- 拓宽模块-悬浮模块
效果
滚轮模块的用法也很简单,一起侵入性极低,运用拓宽就能recyclerView.setupWheelModule()
将RecyclerView
改形成WheelView
:
它会回来RecyclerWheelViewModule
里边包含了操作滚轮模块的各种API
class XxxActivity {
val recyclerView: RecyclerView
val wheelAdapter =
BindingAdapter<String, ItemWheelVerticalBinding>(ItemWheelVerticalBinding::inflate) { _, item ->
itemBinding.text.text = item
itemBinding.text.setTextColor(if (isWheelItemSelected) Color.BLACK else Color.GRAY)
}
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
翻滚到布局的中心方位。
官方供给了SnapHelper 来协助咱们处理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
刚好处于中心方位
上下留白的数量咱们界说为offset
,从另外一个角度来看能够将留白当作offset
个Header
和offset
个Footer
提起Header/Footer
,咱们在之前的文章
RecyclerView封装-结合ViewBinding 3行代码创建Adapter!
中有介绍ConcatAdapter
来完结Header/Footer
,因而这儿就直接选用ConcatAdapter
不再赘述。
这儿的每个留白的高度一般便是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<out RecyclerView.ViewHolder>?) {
val startOffsetAdapter = OffsetAdapter(adapter)
val endOffsetAdapter = OffsetAdapter(adapter)
recyclerView.adapter = ConcatAdapter(
startOffsetAdapter,
adapter,
endOffsetAdapter
)
}
一般状况下咱们的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
这儿不明白的同学也不要紧,不影响本文后续阅读,或许去之前文章看也行RecyclerView 低耦合单选、多选模块完结。
翻滚完毕后选中
在翻滚中止时的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<WheelWrapper> = 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<DataProvider> = 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<DataProvider>) {
//...
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<Int>, 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<CharSequence>) -> Unit)? = null
fun scheduleDataLoadCallback(callback: (data: List<CharSequence>) -> 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 拓宽优化一下:
linkageWheelView.setCurrentPositions {
setPosition { it.indexOf("广东省") }
setPosition { it.indexOf("韶关市") }
setPosition { it.indexOf("曲江区") }
}
linkageWheelView.setData
也顺便经过DSL 拓宽简化了下:
linkageWheelView.setData {
provideData { arrayOf("Wheel0-0", "Wheel0-1") }
provideData { arrayOf("Wheel1-0", "Wheel1-1") }
}
联动挑选示例
完结联动挑选需求只需求调用linkageWheelView.setData
完结数据加载即可。
可是为了快捷运用一般也会完结数据转化,能够看以下2个比如。
完结省市区联动挑选
数据
首要咱们去网上下载,省市区数据JSON格局 ,并解析出来。
data class Province(
val name: String,
val cities: List<City>,
) : Serializable
data class City(
val name: String,
val counties: List<String>,
) : Serializable
@JvmStatic
fun loadLocalData(context: Context, fileName: String = "address.json"): List<Province> {
val text = context.assets.open(fileName).use { it.bufferedReader().readText() }
return JSONArray(text)
.objects()
.map { province ->
val cities = province.getJSONArray("city").objects().map { city ->
val counties = city.getJSONArray("area").strings()
City(city.getString("name"), counties)
}
Province(province.getString("name"), cities)
}
}
得到了List<Province>
作为原始数据。
然后经过linkageWheelView.setData
设置即可。
fun setAddressData(provinces: List<Province>) {
//...
linkageWheelView.setData {
provideData { provinces.map { it.name } }
provideData { provinces[it[0].selectedPosition].cities.map { it.name } }
provideData { provinces[it[0].selectedPosition].cities[it[1].selectedPosition].counties }
}
}
数据转化
数据转化首要是给调用者更加便利去设置和获取当时的省市区数据。 先界说一个Model类,描绘省市区。
data class AddressBean(
val provinceName: String,
val cityName: String,
val countyName: String,
)
然后完结set办法和get办法
var current: AddressBean?
get() {
//...
val (province, city, county) = linkageWheelView.currentItems.map { it.toString() }
return AddressBean(province, city, county)
}
set(value) {
//...
linkageWheelView.setCurrentPositions {
setPosition { it.indexOf(value.provinceName) }
setPosition { it.indexOf(value.cityName) }
setPosition { it.indexOf(value.countyName) }
}
}
完结年月日联动挑选
省市区的完结比较简单,咱们来完结一个略微杂乱一点的。
完结一个年月日挑选滚轮,支撑以下装备内容,
-
能够支撑
年-月-日
,月-日
,年-月
,年
,月
,日
形式。 -
能动态核算日的规模。 如挑选
年=2023
且月=02
时,需求核算出可选的日的规模是0-28
。 -
支撑设置最大、最小日期。当最小日期是
2022-05-05
时,最小年份只能选到2022
;当年=2022
时,月最小只能选到05
;当年=2022
且月=05
时,日最小只能选到05
。最大日期同理。 -
支撑装备年月日的显现格局。
装备类如下:
/**
* @param year 支撑年
* @param month 支撑月
* @param day 支撑日
* @param maxValue 最大日期
* @param minValue 最小日期
* @param yearFormatter 年格局
* @param monthFormatter 月格局
* @param dayFormatter 日格局
*/
data class Options(
val year: Boolean = true,
val month: Boolean = true,
val day: Boolean = true,
val maxValue: Calendar = Calendar.getInstance(),
val minValue: Calendar = Calendar.getInstance().apply { add(Calendar.YEAR, -10) },
var yearFormatter: Formatter = Formatter { it.toString() },
var monthFormatter: Formatter = Formatter { (it + 1).toString() },
var dayFormatter: Formatter = Formatter { it.toString() }
)
数据
界说一些常量,便利后续用到,年月日的规模标准和Calendar
类界说共同 。
companion object {
val DEFAULT_MONTH_RANGE: IntRange = (0..11)
val DEFAULT_DAY_RANGE: IntRange = (1..31)
}
年月日数据,经过linkageWheelView.setData
设置即可
- 装备年
provideData
:没有依靠项,直接设置规模即可 - 装备月
provideData
:或许会依靠年,取决所以否存在年,所以需求处理月-
,年-月-
2种状况(不依靠日,所以不需考虑月-日
和年-月-日
的状况) - 装备日
provideData
:或许会依靠年和月,取决所以否存在年和月,所以需求处理日
,月-日
,年-月-日
3种状况 (年-日
暂时没见过,所以不完结这种状况)
处理时只需求判别当时选中的值是否处于边界状况即可。
linkageWheelView.setData {
val (maxYear, maxMonth, maxDay) = options.maxValue.flattenYmd()
val (minYear, minMonth, minDay) = options.minValue.flattenYmd()
if (options.year) {
//形式“年-”
provideData {
(maxYear downTo minYear).formatYear()
}
}
if (options.month) {
provideData {
//月份
if (it.size < 1) {
//形式“月-”
return@provideData (minMonth..maxMonth).formatMonth()
}
//形式“年-月-”
val selectedYear = it[0].realValue//当时年份
val startYear =
if (selectedYear == minYear) minMonth else DEFAULT_MONTH_RANGE.first
val endYear =
if (selectedYear == maxYear) maxMonth else DEFAULT_MONTH_RANGE.last
(startYear..endYear).formatMonth()
}
}
if (options.day) {
provideData {
if (it.size < 1) {
//形式“日”
return@provideData (minDay..maxDay).formatDay()
}
if (it.size < 2) {
//形式“月-日” (不存在“年-日”形式)
val selectedMonth = it[0].realValue
val startDay =
if (selectedMonth == minMonth) minDay else DEFAULT_DAY_RANGE.first
val endDay =
if (selectedMonth == maxMonth) maxDay else DEFAULT_DAY_RANGE.last
return@provideData (startDay..endDay).formatDay()
}
//形式“年-月-日”
val selectedYear = it[0].realValue//当时年份
val selectedMonth = it[1].realValue//当时月份
val selected = Calendar.getInstance().apply {
set(selectedYear, selectedMonth, 1)
}
val startDay =
if (selectedYear == minYear && selectedMonth == minMonth) minDay else DEFAULT_DAY_RANGE.first
val endDay =
if (selectedYear == maxYear && selectedMonth == maxMonth) maxDay else selected.getActualMaximum(
Calendar.DAY_OF_MONTH
)
return@provideData (startDay..endDay).formatDay()
}
}
}
format 和flattenYmd便是东西类,这儿就不贴出来了,感兴趣能够看源码
数据转化
数据类直接运用Calendar
完结年月日到对应方位的转化即可。
var current: Calendar
get() {
val values = linkageWheelView.currentItems.map { (it as ValueWrapper).realValue }
val calendar = Calendar.getInstance()
var index = 0
if (options.year && index < values.size) {
calendar.set(Calendar.YEAR, values[index++])
}
if (options.month && index < values.size) {
calendar.set(Calendar.MONTH, values[index++])
}
if (options.day && index < values.size) {
calendar.set(Calendar.DAY_OF_MONTH, values[index])
} else {
calendar.set(Calendar.DAY_OF_MONTH, 1)
}
return calendar
}
set(value) {
linkageWheelView.setCurrentPositions {
if (options.year) {
setPosition {
it.indexOf(value.get(Calendar.YEAR)).coerceAtLeast(0)
}
}
if (options.month) {
setPosition {
it.indexOf(value.get(Calendar.MONTH)).coerceAtLeast(0)
}
}
if (options.day) {
setPosition {
it.indexOf(value.get(Calendar.DAY_OF_MONTH)).coerceAtLeast(0)
}
}
}
}
总结
本文完结了滚轮模块CalendarChooseModule
,能够低侵入性的将RecyclerView
改形成 WheelView
,一起UI能经过Adapter
自界说。
而且完结了联动滚轮LinkageWheelView
,能够比较便利的完结省市区多级联动,年月日联动等。
以上提到的比如源码均可在项意图Demo(wheel
目录)找到。