awaitVerticalTouchSlopOrCancellation

suspend fun AwaitPointerEventScope.awaitVerticalTouchSlopOrCancellation(
    pointerId: PointerId,
    onTouchSlopReached: (change: PointerInputChange, overSlop: Float) -> Unit,
) =
    awaitPointerSlopOrCancellation(
        pointerId = pointerId,
        pointerType = PointerType.Touch,
        onPointerSlopReached = { change, overSlop -> onTouchSlopReached(change, overSlop.y) },
        orientation = Orientation.Vertical,
    )

Waits for vertical drag motion to pass touch slop, using pointerId as the pointer to examine. If pointerId is raised, another pointer from those that are down will be chosen to lead the gesture, and if none are down, null is returned. If pointerId is not down when awaitVerticalTouchSlopOrCancellation is called, then null is returned.

onTouchSlopReached is called after ViewConfiguration.touchSlop motion in the vertical direction with the change that caused the motion beyond touch slop and the pixels beyond touch slop. onTouchSlopReached should consume the position change if it accepts the motion. If it does, then the method returns that PointerInputChange. If not, touch slop detection will continue.

Example Usage:

Returns

Code Examples

AwaitVerticalDragOrCancellationSample

@Composable
fun AwaitVerticalDragOrCancellationSample() {
    val offsetX = remember { mutableStateOf(0f) }
    val offsetY = remember { mutableStateOf(0f) }
    var height by remember { mutableStateOf(0f) }
    Box(Modifier.fillMaxSize().onSizeChanged { height = it.height.toFloat() }) {
        Box(
            Modifier.offset { IntOffset(offsetX.value.roundToInt(), offsetY.value.roundToInt()) }
                .fillMaxWidth()
                .height(50.dp)
                .background(Color.Blue)
                .pointerInput(Unit) {
                    awaitEachGesture {
                        val down = awaitFirstDown()
                        var change =
                            awaitVerticalTouchSlopOrCancellation(down.id) { change, over ->
                                val originalY = offsetY.value
                                val newValue =
                                    (originalY + over).coerceIn(0f, height - 50.dp.toPx())
                                change.consume()
                                offsetY.value = newValue
                            }
                        while (change != null && change.pressed) {
                            change = awaitVerticalDragOrCancellation(change.id)
                            if (change != null && change.pressed) {
                                val originalY = offsetY.value
                                val newValue =
                                    (originalY + change.positionChange().y).coerceIn(
                                        0f,
                                        height - 50.dp.toPx(),
                                    )
                                change.consume()
                                offsetY.value = newValue
                            }
                        }
                    }
                }
        )
    }
}