feat(Slider): Add slider semantics modifier for accesability

Author: levinzonr

slider/src/main/java/io/monstarlab/mosaic/slider/Modifiers.kt

@@ -0,0 +1,67 @@
+package io.monstarlab.mosaic.slider
+
+import androidx.compose.foundation.gestures.Orientation
+import androidx.compose.foundation.gestures.detectTapGestures
+import androidx.compose.foundation.gestures.draggable
+import androidx.compose.foundation.interaction.MutableInteractionSource
+import androidx.compose.foundation.progressSemantics
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.input.pointer.pointerInput
+import androidx.compose.ui.semantics.disabled
+import androidx.compose.ui.semantics.semantics
+import androidx.compose.ui.semantics.setProgress
+
+internal fun Modifier.sliderDragModifier(
+    state: SliderState,
+    interactionSource: MutableInteractionSource,
+    isRtl: Boolean,
+): Modifier = this.draggable(
+    state = state,
+    orientation = Orientation.Horizontal,
+    enabled = true,
+    interactionSource = interactionSource,
+    startDragImmediately = state.isDragging,
+    reverseDirection = isRtl,
+    onDragStopped = {},
+)
+
+internal fun Modifier.sliderTapModifier(
+    state: SliderState,
+    interactionSource: MutableInteractionSource,
+): Modifier {
+    return this.pointerInput(state, interactionSource) {
+        detectTapGestures(
+            onPress = { state.handlePress(it) },
+        )
+    }
+}
+
+internal fun Modifier.sliderSemantics(state: SliderState, enabled: Boolean): Modifier {
+    return semantics {
+        if (!enabled) disabled()
+        setProgress(
+            action = { targetValue ->
+                val coercedValue = state.coerceValue(targetValue)
+                // This is to keep it consistent with AbsSeekbar.java: return false if no
+                // change from current.
+                if (coercedValue == state.value) {
+                    false
+                } else {
+                    if (coercedValue != state.value) {
+                        if (state.onValueChange != null) {
+                            state.onValueChange?.let {
+                                it(coercedValue)
+                            }
+                        } else {
+                            state.value = coercedValue
+                        }
+                    }
+                    true
+                }
+            },
+        )
+    }.progressSemantics(
+        value = state.value,
+        valueRange = state.range.start..state.range.endInclusive,
+    )
+}

slider/src/main/java/io/monstarlab/mosaic/slider/Slider.kt

@@ -2,9 +2,6 @@ package io.monstarlab.mosaic.slider
 
 import androidx.compose.foundation.background
 import androidx.compose.foundation.focusable
-import androidx.compose.foundation.gestures.Orientation
-import androidx.compose.foundation.gestures.detectTapGestures
-import androidx.compose.foundation.gestures.draggable
 import androidx.compose.foundation.interaction.MutableInteractionSource
 import androidx.compose.foundation.layout.Box
 import androidx.compose.foundation.layout.size
@@ -13,7 +10,6 @@ import androidx.compose.runtime.Composable
 import androidx.compose.runtime.remember
 import androidx.compose.ui.Modifier
 import androidx.compose.ui.graphics.Color
-import androidx.compose.ui.input.pointer.pointerInput
 import androidx.compose.ui.platform.LocalLayoutDirection
 import androidx.compose.ui.tooling.preview.Preview
 import androidx.compose.ui.unit.LayoutDirection
@@ -73,25 +69,12 @@ public fun Slider(
     thumb: @Composable (SliderState) -> Unit,
 ) {
     val isRtl = LocalLayoutDirection.current == LayoutDirection.Rtl
-
-    val tap = Modifier.pointerInput(state, interactionSource) {
-        detectTapGestures(
-            onPress = { state.handlePress(it) },
-        )
-    }
-
-    val drag = Modifier.draggable(
-        state = state,
-        orientation = Orientation.Horizontal,
-        enabled = true,
-        interactionSource = interactionSource,
-        startDragImmediately = state.isDragging,
-        reverseDirection = isRtl,
-        onDragStopped = {},
-    )
+    val tap = Modifier.sliderTapModifier(state, interactionSource)
+    val drag = Modifier.sliderDragModifier(state, interactionSource, isRtl)
 
     SliderLayout(
         modifier = modifier
+            .sliderSemantics(state, true)
             .focusable(true, interactionSource)
             .then(tap)
             .then(drag),

slider/src/main/java/io/monstarlab/mosaic/slider/SliderState.kt

@@ -19,7 +19,7 @@ import kotlinx.coroutines.coroutineScope
  */
 public class SliderState(
     value: Float,
-    private val range: ClosedFloatingPointRange<Float>,
+    public val range: ClosedFloatingPointRange<Float>,
     private val disabledRange: ClosedFloatingPointRange<Float>,
     private val valueDistribution: SliderValueDistribution,
 ) : DraggableState {
@@ -39,7 +39,7 @@ public class SliderState(
         }
 
     internal val disabledRangeAsFractions: ClosedFloatingPointRange<Float>
-        get() = coerceRange(disabledRange)
+        get() = coerceRangeIntoFractions(disabledRange)
 
     /**
      * Current value of the slider
@@ -88,7 +88,13 @@ public class SliderState(
         }
     }
 
-    private fun coerceRange(
+    internal fun coerceValue(value: Float): Float {
+        return value
+            .coerceIn(range)
+            .coerceIntoDisabledRange()
+    }
+
+    private fun coerceRangeIntoFractions(
         subrange: ClosedFloatingPointRange<Float>,
     ): ClosedFloatingPointRange<Float> {
         if (subrange.isEmpty()) return subrange
@@ -108,23 +114,11 @@ public class SliderState(
     private fun scaleToUserValue(offset: Float): Float {
         val range = valueDistribution.interpolate(range)
         val scaledUserValue = scale(0f, totalWidth, offset, range.start, range.endInclusive)
-        return valueDistribution.inverse(scaledUserValue)
-            .coerceIn(this.range)
-            .coerceIntoDisabledRange()
-    }
-
-    private fun Float.coerceIntoDisabledRange(): Float {
-        if (disabledRange.isEmpty()) return this
-        // check if disabled range is on the left or right
-        return if (disabledRange.start == range.start) {
-            coerceAtLeast(disabledRange.endInclusive)
-        } else {
-            coerceAtMost(disabledRange.start)
-        }
+        return coerceValue(valueDistribution.inverse(scaledUserValue))
     }
 
     private fun scaleToOffset(value: Float): Float {
-        val coerced = value.coerceIn(range).coerceIntoDisabledRange()
+        val coerced = coerceValue(value)
         val interpolatedRange = valueDistribution.interpolate(range)
         val interpolated = valueDistribution.interpolate(coerced)
         return scale(
@@ -135,6 +129,16 @@ public class SliderState(
             totalWidth,
         )
     }
+
+    private fun Float.coerceIntoDisabledRange(): Float {
+        if (disabledRange.isEmpty()) return this
+        // check if disabled range is on the left or right
+        return if (disabledRange.start == range.start) {
+            coerceAtLeast(disabledRange.endInclusive)
+        } else {
+            coerceAtMost(disabledRange.start)
+        }
+    }
 }
 
 @Composable