Positional and velocity thresholds in Swipeable V2.
Positional thresholds allow defining a point from the origin of an interaction (swipes or animations) that needs to be crossed in order for the next closest state in the interaction direction to be considered the target state.
In Material 2, the default value is 56 dp. A positional threshold can be either a fixed (absolute value) or a fractional value. A fixed threshold can be defined using `fixedPositionalThreshold(x.dp)`, a fractional threshold using `fractionalPositionalThreshold(0.3f)`.
Positional thresholds should not be different between different states, but can be calculated from the distance, i.e. when expressing a fractional threshold.
Velocity thresholds help interpret user intent. Velocity thresholds take precedence over positional thresholds when calculating the target. If the velocity is higher than the velocity threshold but the positional threshold has not yet been reached, the next closest state in the interaction direction will still be the target state.
Velocity thresholds are always constant per Swipeable instance and should not change between different states to create consistent UX.
In Material 2, the default value is 125 dp/ms.
Compared to Swipeable V1, thresholds are more consistent and have simpler layering, removing the `ThresholdConfig` API.
Test: SwipeableV2GestureTest
Relnote: N/A
Bug: 247983516
Change-Id: I61679a2e310d710f82ec4adce538a9c156a69939
diff --git a/compose/material/material/src/androidAndroidTest/kotlin/androidx/compose/material/swipeable/SwipeableV2AnchorTest.kt b/compose/material/material/src/androidAndroidTest/kotlin/androidx/compose/material/swipeable/SwipeableV2AnchorTest.kt
index 546a345..c7f0a55 100644
--- a/compose/material/material/src/androidAndroidTest/kotlin/androidx/compose/material/swipeable/SwipeableV2AnchorTest.kt
+++ b/compose/material/material/src/androidAndroidTest/kotlin/androidx/compose/material/swipeable/SwipeableV2AnchorTest.kt
@@ -53,9 +53,10 @@
rule.mainClock.autoAdvance = false
var compositionCounter = 0
- val state = SwipeableV2State(initialState = A)
+ lateinit var state: SwipeableV2State<TestState>
rule.setContent {
+ state = rememberSwipeableV2State(initialState = A)
compositionCounter++
Box(
Modifier
@@ -82,7 +83,7 @@
@Test
fun swipeable_swipeAnchors_calculatedCorrectlyFromLayoutSize() {
- val state = SwipeableV2State(initialState = A)
+ lateinit var state: SwipeableV2State<TestState>
fun anchorA() = 0f
fun anchorB(layoutHeight: Float) = layoutHeight / 2
@@ -91,6 +92,7 @@
val swipeableSize = 200.dp
rule.setContent {
+ state = rememberSwipeableV2State(initialState = A)
Box(
Modifier
.requiredHeight(swipeableSize)
diff --git a/compose/material/material/src/androidAndroidTest/kotlin/androidx/compose/material/swipeable/SwipeableV2GestureTest.kt b/compose/material/material/src/androidAndroidTest/kotlin/androidx/compose/material/swipeable/SwipeableV2GestureTest.kt
index 15409f5..551c9bc 100644
--- a/compose/material/material/src/androidAndroidTest/kotlin/androidx/compose/material/swipeable/SwipeableV2GestureTest.kt
+++ b/compose/material/material/src/androidAndroidTest/kotlin/androidx/compose/material/swipeable/SwipeableV2GestureTest.kt
@@ -17,11 +17,15 @@
package androidx.compose.material.swipeable
import androidx.compose.foundation.gestures.Orientation
+import androidx.compose.material.AutoTestFrameClock
import androidx.compose.material.ExperimentalMaterialApi
import androidx.compose.material.SwipeableV2State
+import androidx.compose.material.fixedPositionalThreshold
+import androidx.compose.material.fractionalPositionalThreshold
import androidx.compose.material.swipeable.TestState.A
import androidx.compose.material.swipeable.TestState.B
import androidx.compose.material.swipeable.TestState.C
+import androidx.compose.ui.geometry.Offset
import androidx.compose.ui.test.TouchInjectionScope
import androidx.compose.ui.test.junit4.createComposeRule
import androidx.compose.ui.test.onNodeWithTag
@@ -30,9 +34,15 @@
import androidx.compose.ui.test.swipeLeft
import androidx.compose.ui.test.swipeRight
import androidx.compose.ui.test.swipeUp
+import androidx.compose.ui.test.swipeWithVelocity
+import androidx.compose.ui.unit.Density
+import androidx.compose.ui.unit.Dp
+import androidx.compose.ui.unit.dp
import androidx.test.ext.junit.runners.AndroidJUnit4
import androidx.test.filters.LargeTest
import com.google.common.truth.Truth.assertThat
+import kotlin.math.abs
+import kotlinx.coroutines.runBlocking
import org.junit.Rule
import org.junit.Test
import org.junit.runner.RunWith
@@ -47,21 +57,21 @@
@Test
fun swipeable_swipe_horizontal() = directionalSwipeTest(
- SwipeableV2State(initialState = A),
+ SwipeableTestState(initialState = A),
orientation = Orientation.Horizontal,
verify = verifyOffsetMatchesAnchor()
)
@Test
fun swipeable_swipe_vertical() = directionalSwipeTest(
- SwipeableV2State(initialState = A),
+ SwipeableTestState(initialState = A),
orientation = Orientation.Vertical,
verify = verifyOffsetMatchesAnchor()
)
@Test
fun swipeable_swipe_disabled_horizontal() = directionalSwipeTest(
- SwipeableV2State(initialState = A),
+ SwipeableTestState(initialState = A),
orientation = Orientation.Horizontal,
enabled = false,
verify = verifyOffset0(),
@@ -69,7 +79,7 @@
@Test
fun swipeable_swipe_disabled_vertical(): Unit = directionalSwipeTest(
- SwipeableV2State(initialState = A),
+ SwipeableTestState(initialState = A),
orientation = Orientation.Vertical,
enabled = false,
verify = verifyOffset0(),
@@ -77,7 +87,7 @@
@Test
fun swipeable_swipe_reverse_direction_horizontal() = directionalSwipeTest(
- SwipeableV2State(initialState = A),
+ SwipeableTestState(initialState = A),
orientation = Orientation.Horizontal,
verify = verifyOffsetMatchesAnchor()
)
@@ -136,6 +146,214 @@
verify(state, A)
}
+ @Test
+ fun swipeable_positionalThresholds_fractional_targetState() = fractionalThresholdsTest(0.5f)
+
+ @Test
+ fun swipeable_positionalThresholds_fractional_negativeThreshold_targetState() =
+ fractionalThresholdsTest(-0.5f)
+
+ private fun fractionalThresholdsTest(positionalThreshold: Float) {
+ val absThreshold = abs(positionalThreshold)
+ val state = SwipeableTestState(
+ initialState = A,
+ positionalThreshold = fractionalPositionalThreshold(positionalThreshold)
+ )
+ rule.setContent { SwipeableBox(state) }
+
+ val positionOfA = state.anchors.getValue(A)
+ val positionOfB = state.anchors.getValue(B)
+ val distance = abs(positionOfA - positionOfB)
+ state.dispatchRawDelta(positionOfA + distance * (absThreshold * 0.9f))
+ rule.waitForIdle()
+
+ assertThat(state.currentState).isEqualTo(A)
+ assertThat(state.targetState).isEqualTo(A)
+
+ state.dispatchRawDelta(distance * 0.2f)
+ rule.waitForIdle()
+
+ assertThat(state.currentState).isEqualTo(A)
+ assertThat(state.targetState).isEqualTo(B)
+
+ runBlocking(AutoTestFrameClock()) { state.settle(velocity = 0f) }
+
+ assertThat(state.currentState).isEqualTo(B)
+ assertThat(state.targetState).isEqualTo(B)
+
+ state.dispatchRawDelta(-distance * (absThreshold * 0.9f))
+ rule.waitForIdle()
+
+ assertThat(state.currentState).isEqualTo(B)
+ assertThat(state.targetState).isEqualTo(B)
+
+ state.dispatchRawDelta(-distance * 0.2f)
+ rule.waitForIdle()
+
+ assertThat(state.currentState).isEqualTo(B)
+ assertThat(state.targetState).isEqualTo(A)
+
+ runBlocking(AutoTestFrameClock()) { state.settle(velocity = 0f) }
+
+ assertThat(state.currentState).isEqualTo(A)
+ assertThat(state.targetState).isEqualTo(A)
+ }
+
+ @Test
+ fun swipeable_positionalThresholds_fixed_targetState() = fixedThresholdsTest(56.dp)
+
+ @Test
+ fun swipeable_positionalThresholds_fixed_negativeThreshold_targetState() =
+ fixedThresholdsTest((-56).dp)
+
+ private fun fixedThresholdsTest(positionalThreshold: Dp) {
+ val absThreshold = with(rule.density) { abs(positionalThreshold.toPx()) }
+ val state = SwipeableTestState(
+ initialState = A,
+ positionalThreshold = fixedPositionalThreshold(positionalThreshold)
+ )
+ rule.setContent { SwipeableBox(state) }
+
+ val initialOffset = state.requireOffset()
+
+ // Swipe towards B, close before threshold
+ state.dispatchRawDelta(initialOffset + (absThreshold * 0.9f))
+ rule.waitForIdle()
+
+ assertThat(state.currentState).isEqualTo(A)
+ assertThat(state.targetState).isEqualTo(A)
+
+ // Swipe towards B, close after threshold
+ state.dispatchRawDelta(absThreshold * 0.2f)
+ rule.waitForIdle()
+
+ assertThat(state.currentState).isEqualTo(A)
+ assertThat(state.targetState).isEqualTo(B)
+
+ runBlocking(AutoTestFrameClock()) { state.settle(velocity = 0f) }
+
+ assertThat(state.currentState).isEqualTo(B)
+ assertThat(state.targetState).isEqualTo(B)
+
+ // Swipe towards A, close before threshold
+ state.dispatchRawDelta(-(absThreshold * 0.9f))
+ rule.waitForIdle()
+
+ assertThat(state.currentState).isEqualTo(B)
+ assertThat(state.targetState).isEqualTo(B)
+
+ // Swipe towards A, close after threshold
+ state.dispatchRawDelta(-(absThreshold * 0.2f))
+ rule.waitForIdle()
+
+ assertThat(state.currentState).isEqualTo(B)
+ assertThat(state.targetState).isEqualTo(A)
+
+ runBlocking(AutoTestFrameClock()) { state.settle(velocity = 0f) }
+
+ assertThat(state.currentState).isEqualTo(A)
+ assertThat(state.targetState).isEqualTo(A)
+ }
+
+ @Test
+ fun swipeable_velocityThreshold_settle_velocityHigherThanThreshold_advances() =
+ runBlocking(AutoTestFrameClock()) {
+ val velocity = 100.dp
+ val velocityPx = with(rule.density) { velocity.toPx() }
+ val state = with(rule) {
+ SwipeableTestState(
+ initialState = A,
+ anchors = mapOf(
+ A to 0f,
+ B to 100f,
+ C to 200f
+ ),
+ velocityThreshold = velocity / 2
+ )
+ }
+ state.dispatchRawDelta(60f)
+ state.settle(velocityPx)
+ assertThat(state.currentState).isEqualTo(B)
+ }
+
+ @Test
+ fun swipeable_velocityThreshold_settle_velocityLowerThanThreshold_doesntAdvance() =
+ runBlocking(AutoTestFrameClock()) {
+ val velocity = 100.dp
+ val velocityPx = with(rule.density) { velocity.toPx() }
+ val state = SwipeableTestState(
+ initialState = A,
+ anchors = mapOf(
+ A to 0f,
+ B to 100f,
+ C to 200f
+ ),
+ velocityThreshold = velocity,
+ positionalThreshold = { Float.POSITIVE_INFINITY }
+ )
+ state.dispatchRawDelta(60f)
+ state.settle(velocityPx / 2)
+ assertThat(state.currentState).isEqualTo(A)
+ }
+
+ @Test
+ fun swipeable_velocityThreshold_swipe_velocityHigherThanThreshold_advances() {
+ val velocityThreshold = 100.dp
+ val state = SwipeableTestState(
+ initialState = A,
+ velocityThreshold = velocityThreshold
+ )
+ rule.setContent { SwipeableBox(state) }
+
+ rule.onNodeWithTag(swipeableTestTag)
+ .performTouchInput {
+ swipeWithVelocity(
+ start = Offset(left, 0f),
+ end = Offset(right / 2, 0f),
+ endVelocity = with(rule.density) { velocityThreshold.toPx() } * 1.1f
+ )
+ }
+
+ rule.waitForIdle()
+ assertThat(state.currentState).isEqualTo(B)
+ }
+
+ @Test
+ fun swipeable_velocityThreshold_swipe_velocityLowerThanThreshold_doesntAdvance() {
+ val velocityThreshold = 100.dp
+ val state = SwipeableTestState(
+ initialState = A,
+ velocityThreshold = velocityThreshold,
+ positionalThreshold = { Float.POSITIVE_INFINITY }
+ )
+ rule.setContent { SwipeableBox(state) }
+
+ rule.onNodeWithTag(swipeableTestTag)
+ .performTouchInput {
+ swipeWithVelocity(
+ start = Offset(left, 0f),
+ end = Offset(right / 2, 0f),
+ endVelocity = with(rule.density) { velocityThreshold.toPx() } * 0.9f
+ )
+ }
+
+ rule.waitForIdle()
+ assertThat(state.currentState).isEqualTo(A)
+ }
+
+ private fun SwipeableTestState(
+ initialState: TestState,
+ density: Density = rule.density,
+ positionalThreshold: Density.(distance: Float) -> Float = { 56f },
+ velocityThreshold: Dp = 125.dp,
+ anchors: Map<TestState, Float>? = null
+ ) = SwipeableV2State(
+ initialState = initialState,
+ positionalThreshold = positionalThreshold,
+ velocityThreshold = velocityThreshold,
+ density = density
+ ).apply { if (anchors != null) updateAnchors(anchors) }
+
private fun TouchInjectionScope.endEdge(orientation: Orientation) =
if (orientation == Orientation.Horizontal) right else bottom
diff --git a/compose/material/material/src/androidAndroidTest/kotlin/androidx/compose/material/swipeable/SwipeableV2StateTest.kt b/compose/material/material/src/androidAndroidTest/kotlin/androidx/compose/material/swipeable/SwipeableV2StateTest.kt
index 888ce82..d7433e2 100644
--- a/compose/material/material/src/androidAndroidTest/kotlin/androidx/compose/material/swipeable/SwipeableV2StateTest.kt
+++ b/compose/material/material/src/androidAndroidTest/kotlin/androidx/compose/material/swipeable/SwipeableV2StateTest.kt
@@ -56,8 +56,9 @@
@Test
fun swipeable_state_canSkipStateByFling() {
- val state = SwipeableV2State(A)
+ lateinit var state: SwipeableV2State<TestState>
rule.setContent {
+ state = rememberSwipeableV2State(initialState = A)
SwipeableBox(
swipeableState = state,
orientation = Orientation.Vertical,
@@ -75,8 +76,9 @@
@Test
fun swipeable_targetState_updatedOnSwipe() {
- val state = SwipeableV2State(A)
+ lateinit var state: SwipeableV2State<TestState>
rule.setContent {
+ state = rememberSwipeableV2State(initialState = A)
SwipeableBox(
swipeableState = state,
orientation = Orientation.Vertical,
@@ -104,12 +106,13 @@
fun swipeable_targetState_updatedWithAnimation() {
rule.mainClock.autoAdvance = false
val animationDuration = 300
- val state = SwipeableV2State(
- initialState = A,
- animationSpec = tween(animationDuration, easing = LinearEasing)
- )
+ lateinit var state: SwipeableV2State<TestState>
lateinit var scope: CoroutineScope
rule.setContent {
+ state = rememberSwipeableV2State(
+ initialState = A,
+ animationSpec = tween(animationDuration, easing = LinearEasing)
+ )
scope = rememberCoroutineScope()
SwipeableBox(
swipeableState = state,
@@ -142,8 +145,9 @@
@Test
fun swipeable_progress_matchesSwipePosition() {
- val state = SwipeableV2State(A)
+ lateinit var state: SwipeableV2State<TestState>
rule.setContent {
+ state = rememberSwipeableV2State(initialState = A)
WithTouchSlop(touchSlop = 0f) {
SwipeableBox(
swipeableState = state,
@@ -175,8 +179,9 @@
@Test
fun swipeable_snapTo_updatesImmediately() = runBlocking {
- val state = SwipeableV2State(A)
+ lateinit var state: SwipeableV2State<TestState>
rule.setContent {
+ state = rememberSwipeableV2State(initialState = A)
SwipeableBox(
swipeableState = state,
orientation = Orientation.Vertical
@@ -247,15 +252,22 @@
}
@Test
+ @Ignore("Todo: Fix differences between tests and real code - this shouldn't work :)")
fun swipeable_requireOffset_accessedInInitialComposition_throws() {
var exception: Throwable? = null
+ lateinit var state: SwipeableV2State<TestState>
+ var offset: Float? = null
rule.setContent {
- val state = rememberSwipeableV2State(initialState = B)
- exception = runCatching { state.requireOffset() }.exceptionOrNull()
+ state = rememberSwipeableV2State(initialState = B)
+ SwipeableBox(state)
+ exception = runCatching { offset = state.requireOffset() }.exceptionOrNull()
}
+ assertThat(state.anchors).isNotEmpty()
+ assertThat(offset).isNull()
assertThat(exception).isNotNull()
assertThat(exception).isInstanceOf(IllegalStateException::class.java)
+ assertThat(exception).hasMessageThat().contains("offset")
}
@Test
diff --git a/compose/material/material/src/commonMain/kotlin/androidx/compose/material/SwipeableV2.kt b/compose/material/material/src/commonMain/kotlin/androidx/compose/material/SwipeableV2.kt
index 03a7fc4..b21f1bc 100644
--- a/compose/material/material/src/commonMain/kotlin/androidx/compose/material/SwipeableV2.kt
+++ b/compose/material/material/src/commonMain/kotlin/androidx/compose/material/SwipeableV2.kt
@@ -17,6 +17,7 @@
package androidx.compose.material
import androidx.compose.animation.core.AnimationSpec
+import androidx.compose.animation.core.SpringSpec
import androidx.compose.animation.core.animate
import androidx.compose.foundation.gestures.DraggableState
import androidx.compose.foundation.gestures.Orientation
@@ -33,7 +34,11 @@
import androidx.compose.runtime.setValue
import androidx.compose.ui.Modifier
import androidx.compose.ui.layout.onSizeChanged
+import androidx.compose.ui.platform.LocalDensity
+import androidx.compose.ui.unit.Density
+import androidx.compose.ui.unit.Dp
import androidx.compose.ui.unit.IntSize
+import androidx.compose.ui.unit.dp
import kotlin.math.abs
import kotlinx.coroutines.CancellationException
import kotlinx.coroutines.launch
@@ -115,32 +120,49 @@
*
* This contains necessary information about any ongoing swipe or animation and provides methods
* to change the state either immediately or by starting an animation. To create and remember a
- * [SwipeableState] use [rememberSwipeableState].
+ * [SwipeableV2State] use [rememberSwipeableV2State].
*
* @param initialState The initial value of the state.
+ * @param density The density used to convert thresholds from px to dp.
* @param animationSpec The default animation that will be used to animate to a new state.
* @param confirmStateChange Optional callback invoked to confirm or veto a pending state change.
+ * @param positionalThreshold The positional threshold to be used when calculating the target state
+ * while a swipe is in progress and when settling after the swipe ends. This is the distance from
+ * the start of a transition. It will be, depending on the direction of the interaction, added or
+ * subtracted from/to the origin offset. It should always be a positive value. See the
+ * [fractionalPositionalThreshold] and [fixedPositionalThreshold] methods.
+ * @param velocityThreshold The velocity threshold (in dp per second) that the end velocity has to
+ * exceed in order to animate to the next state, even if the [positionalThreshold] has not been
+ * reached.
*/
@Stable
@ExperimentalMaterialApi
internal class SwipeableV2State<T>(
initialState: T,
- val animationSpec: AnimationSpec<Float> = SwipeableDefaults.AnimationSpec,
- val confirmStateChange: (newValue: T) -> Boolean = { true },
+ internal val density: Density,
+ internal val animationSpec: AnimationSpec<Float> = SwipeableV2Defaults.AnimationSpec,
+ internal val confirmStateChange: (newValue: T) -> Boolean = { true },
+ internal val positionalThreshold: Density.(totalDistance: Float) -> Float =
+ SwipeableV2Defaults.PositionalThreshold,
+ internal val velocityThreshold: Dp = SwipeableV2Defaults.VelocityThreshold,
) {
/**
- * The current state of the [SwipeableState].
+ * The current state of the [SwipeableV2State].
*/
var currentState: T by mutableStateOf(initialState)
private set
/**
* The target state. This is the closest state to the current offset (taking into account
- * positional thresholds). If no animation is in progress, this will be the current state.
+ * positional thresholds). If no interactions like animations or drags are in progress, this
+ * will be the current state.
*/
val targetState: T by derivedStateOf {
- if (offset != null) anchors.closestState(offset!!) else currentState
+ val currentOffset = offset
+ if (currentOffset != null) {
+ computeTarget(currentOffset, currentState, velocity = 0f)
+ } else currentState
}
/**
@@ -205,11 +227,7 @@
private val minBound by derivedStateOf { anchors.minOrNull() ?: Float.NEGATIVE_INFINITY }
private val maxBound by derivedStateOf { anchors.maxOrNull() ?: Float.POSITIVE_INFINITY }
- private var positionalThresholds: (lower: T, upper: T) -> Float by mutableStateOf(
- { _, _ -> 0f } // TODO
- )
-
- private var velocityThreshold by mutableStateOf(0f)
+ private val velocityThresholdPx = with(density) { velocityThreshold.toPx() }
internal val draggableState = DraggableState {
dragPosition = (dragPosition ?: 0f) + it
@@ -276,8 +294,10 @@
}
lastVelocity = 0f
} finally {
- val endOffset = requireNotNull(dragPosition) { "The drag position was in an " +
- "invalid state. Please report this issue." }
+ val endOffset = requireNotNull(dragPosition) {
+ "The drag position was in an " +
+ "invalid state. Please report this issue."
+ }
val endState = anchors
.entries
.firstOrNull { (_, anchorOffset) -> abs(anchorOffset - endOffset) < 0.5f }
@@ -294,9 +314,7 @@
val targetState = computeTarget(
offset = requireOffset(),
currentState = previousState,
- thresholds = positionalThresholds,
- velocity = velocity,
- velocityThreshold = velocityThreshold
+ velocity = velocity
)
if (confirmStateChange(targetState)) {
animateTo(targetState, velocity)
@@ -325,28 +343,31 @@
private fun computeTarget(
offset: Float,
currentState: T,
- thresholds: (lower: T, upper: T) -> Float,
- velocity: Float,
- velocityThreshold: Float
+ velocity: Float
): T {
val currentAnchors = anchors
- return if (currentAnchors.requireAnchor(currentState) <= offset) {
+ val currentAnchor = currentAnchors.requireAnchor(currentState)
+ return if (currentAnchor <= offset) {
// Swiping from lower to upper (positive).
- if (velocity >= velocityThreshold) {
+ if (velocity >= velocityThresholdPx) {
currentAnchors.closestState(offset, true)
} else {
val upper = currentAnchors.closestState(offset, true)
- val threshold = thresholds(currentState, upper)
- if (offset < threshold) currentState else upper
+ val distance = abs(currentAnchors.getValue(upper) - currentAnchor)
+ val relativeThreshold = abs(positionalThreshold(density, distance))
+ val absoluteThreshold = abs(currentAnchor + relativeThreshold)
+ if (offset < absoluteThreshold) currentState else upper
}
} else {
// Swiping from upper to lower (negative).
- if (velocity <= -velocityThreshold) {
+ if (velocity <= -velocityThresholdPx) {
currentAnchors.closestState(offset, false)
} else {
val lower = currentAnchors.closestState(offset, false)
- val threshold = thresholds(currentState, lower)
- if (offset > threshold) currentState else lower
+ val distance = abs(currentAnchor - currentAnchors.getValue(lower))
+ val relativeThreshold = abs(positionalThreshold(density, distance))
+ val absoluteThreshold = abs(currentAnchor - relativeThreshold)
+ if (offset > absoluteThreshold) currentState else lower
}
}
}
@@ -355,9 +376,13 @@
/**
* The default [Saver] implementation for [SwipeableV2State].
*/
+ @ExperimentalMaterialApi
fun <T : Any> Saver(
animationSpec: AnimationSpec<Float>,
confirmStateChange: (T) -> Boolean,
+ positionalThreshold: Density.(distance: Float) -> Float,
+ velocityThreshold: Dp,
+ density: Density
) = Saver<SwipeableV2State<T>, T>(
save = { it.currentState },
restore = {
@@ -365,6 +390,9 @@
initialState = it,
animationSpec = animationSpec,
confirmStateChange = confirmStateChange,
+ positionalThreshold = positionalThreshold,
+ velocityThreshold = velocityThreshold,
+ density = density
)
}
)
@@ -382,28 +410,78 @@
@ExperimentalMaterialApi
internal fun <T : Any> rememberSwipeableV2State(
initialState: T,
- animationSpec: AnimationSpec<Float> = SwipeableDefaults.AnimationSpec,
- confirmStateChange: (newValue: T) -> Boolean = { true },
+ animationSpec: AnimationSpec<Float> = SwipeableV2Defaults.AnimationSpec,
+ confirmStateChange: (newValue: T) -> Boolean = { true }
): SwipeableV2State<T> {
+ val density = LocalDensity.current
return rememberSaveable(
+ initialState, animationSpec, confirmStateChange, density,
saver = SwipeableV2State.Saver(
animationSpec = animationSpec,
- confirmStateChange = confirmStateChange
- )
+ confirmStateChange = confirmStateChange,
+ positionalThreshold = SwipeableV2Defaults.PositionalThreshold,
+ velocityThreshold = SwipeableV2Defaults.VelocityThreshold,
+ density = density
+ ),
) {
SwipeableV2State(
initialState = initialState,
animationSpec = animationSpec,
- confirmStateChange = confirmStateChange
+ confirmStateChange = confirmStateChange,
+ positionalThreshold = SwipeableV2Defaults.PositionalThreshold,
+ velocityThreshold = SwipeableV2Defaults.VelocityThreshold,
+ density = density
)
}
}
-private fun <T> Map<T, Float>.closestState(offset: Float = 0f): T {
- require(isNotEmpty()) { "The anchors were empty when trying to find the closest state" }
- return minBy { (_, anchor) ->
- abs(anchor - offset)
- }.key
+/**
+ * Expresses a fixed positional threshold of [threshold] dp. This will be the distance from an
+ * anchor that needs to be reached for [SwipeableV2State] to settle to the next closest anchor.
+ *
+ * @see [fractionalPositionalThreshold] for a fractional positional threshold
+ */
+@ExperimentalMaterialApi
+internal fun fixedPositionalThreshold(threshold: Dp): Density.(distance: Float) -> Float = {
+ threshold.toPx()
+}
+
+/**
+ * Expresses a relative positional threshold of the [fraction] of the distance to the closest anchor
+ * in the current direction. This will be the distance from an anchor that needs to be reached for
+ * [SwipeableV2State] to settle to the next closest anchor.
+ *
+ * @see [fixedPositionalThreshold] for a fixed positional threshold
+ */
+@ExperimentalMaterialApi
+internal fun fractionalPositionalThreshold(
+ fraction: Float
+): Density.(distance: Float) -> Float = { distance -> distance * fraction }
+
+/**
+ * Contains useful defaults for [swipeableV2] and [SwipeableV2State].
+ */
+@Stable
+@ExperimentalMaterialApi
+internal object SwipeableV2Defaults {
+ /**
+ * The default animation used by [SwipeableV2State].
+ */
+ @ExperimentalMaterialApi
+ val AnimationSpec = SpringSpec<Float>()
+
+ /**
+ * The default velocity threshold (1.8 dp per millisecond) used by [rememberSwipeableV2State].
+ */
+ @ExperimentalMaterialApi
+ val VelocityThreshold: Dp = 125.dp
+
+ /**
+ * The default positional threshold (56 dp) used by [rememberSwipeableV2State]
+ */
+ @ExperimentalMaterialApi
+ val PositionalThreshold: Density.(totalDistance: Float) -> Float =
+ fixedPositionalThreshold(56.dp)
}
private fun <T> Map<T, Float>.closestState(
