IssueTracker

Thanks for a detailed issue overview.

This is by design. We've designed detect* methods as a standalone, non combinable methods to be used for higher levels. You still can combine some of them that make sense together using multiply instances of Modifier.pointerInput modifiers.

You were absolutely right when you defined a bunch of your own extension functions on a scope; It's the intended way for developers to implement more sophisticated or domain specific gestures. We opened building blocks for detect* methods that might be hard to write 100% correct, such as drag function or forEachGesture.

Let me know if you are missing a particular building block that is hard to write yourself.

In the meantime, Im' closing the issue as WAI, thanks!

Thank you for going into depth on your thought processes. I think awaitLongPressOrCancellation would be a useful building block to open up.

Copying awaitLongPressOrCancellation and it's private/internal dependencies to my project led to me copying about 40 lines of code (excluding comments/blank). (In comparison, if forEachGesture was private, I would have had to copy about 20 lines to use it.)

If I hadn't seen awaitLongPressOrCancellation's implementation while reading the source code of another function I suspect I would have incorrectly assumed I could solve the problem with a simpler approach, and had to figure out some bugs (such as around pointer events out of bounds).

Here's what I copied into my project:

// Copied from Compose
private suspend fun PointerInputScope.awaitLongPressOrCancellation(
    initialDown: PointerInputChange
): PointerInputChange? {
    var longPress: PointerInputChange? = null
    var currentDown = initialDown
    val longPressTimeout = viewConfiguration.longPressTimeoutMillis
    return try {
        // wait for first tap up or long press
        withTimeout(longPressTimeout) {
            awaitPointerEventScope {
                var finished = false
                while (!finished) {
                    val event = awaitPointerEvent(PointerEventPass.Main)
                    if (event.changes.fastAll { it.changedToUpIgnoreConsumed() }) {
                        // All pointers are up
                        finished = true
                    }

                    if (
                        event.changes.fastAny { it.consumed.downChange || it.isOutOfBounds(size) }
                    ) {
                        finished = true // Canceled
                    }

                    // Check for cancel by position consumption. We can look on the Final pass of
                    // the existing pointer event because it comes after the Main pass we checked
                    // above.
                    val consumeCheck = awaitPointerEvent(PointerEventPass.Final)
                    if (consumeCheck.changes.fastAny { it.positionChangeConsumed() }) {
                        finished = true
                    }
                    if (!event.isPointerUp(currentDown.id)) {
                        longPress = event.changes.firstOrNull { it.id == currentDown.id }
                    } else {
                        val newPressed = event.changes.fastFirstOrNull { it.pressed }
                        if (newPressed != null) {
                            currentDown = newPressed
                            longPress = currentDown
                        } else {
                            // should technically never happen as we checked it above
                            finished = true
                        }
                    }
                }
            }
        }
        null
    } catch (_: TimeoutCancellationException) {
        longPress ?: initialDown
    }
}

// Copied from Compose
private fun PointerEvent.isPointerUp(pointerId: PointerId): Boolean =
    changes.firstOrNull { it.id == pointerId }?.pressed != true

Filed b/181764910 to track the awaitLongPressOrCancellation separately, thanks!

awaitLongPressOrCancellation() is now public per issuetracker/181764910.