IssueTracker

I had code that required detecting a number of different gestures that were possible only in certain states. I started off using the gesture detecting functions and global variables like so:

var isInTurn = false
var isInSelect = false

detectDragGesturesAfterLongPress { change, _ ->
    if (!isInTurn) {
        isInSelect = true
        /* ... */
    }
}

detectDragGestures { change, _ ->
    if (!isInSelect) {
        isInTurn = true
        /* ... */
    }
}
// ...

I eventually traced a number of bugs down to updating the state non-atomically, so I was planning to add a mutex. That reminded me of how coroutines can often be used to solve concurrency issues, and I came up with

while (true) {
    val event = awaitPointerEventScope { awaitFirstDown() }

    when {
        isStartOfTurn(event) ->
            awaitTurnOrCancel(event)

        isStartOfSelect(event) ->
            awaitSelectOrCancel(event)

        // ...
    }
}

I defined a bunch of my own functions on PointerInputScope, and the approach solved my concurrency issues in a relatively clean way.

The problem is that most of the framework detectors block forever, so they can't be combined. I ended up copying a framework function, editing it to remove the line forEachGesture {, and copying over all their private/internal dependencies.

I'm suggesting that framework gesture detector functions should (when it makes sense) delegate to another public function that detects only one gesture.

fun detectDragGesturesAfterLongPress(/* ... */) {
   forEachGesture {
      detectOneDragGestureAfterLongPress(/* ... */)
    }
}

fun detectOneDragGestureAfterLongPress(/* ... */)

I'm also suggesting that more of the private helpers you use in gesture detection be made public, such as awaitLongPressOrCancellation, to enable users to write code that combines small suspending functions to detect complex gestures as cleanly as the framework.