[Android] Remove workaround for touch events allowing to change state too soon (#3793)

## Description

Supersedes
#2283

On Android, `onTouchesDown` was delayed to be dispatched after `onBegin`
so that the handlers had the time to initialize themselves (which
happens in `onHandle`) so that the non-touch events would have correct
data.

The old approach was saving the event, which triggered the touch event,
and using that event to initialize the handler during imperative state
change. The issues with that approach were:
1. Storing the event for the duration of the event handling
2. It wouldn't work with asynchronous state changes, which are now
possible

The new approach is to add an option to force gestures to initialize
regardless of the state they are in. This way, when the state is updated
and the current state of the handler is `UNDETERMINED`, the flag is set
on the handler, and when it starts handling the event, it will first
initialize itself.

## Test plan

Tested on the following snippet, with affected gestures
```
import React from 'react';
import { StyleSheet, View } from 'react-native';
import { usePan, NativeDetector } from 'react-native-gesture-handler';

export default function EmptyExample() {
  const pan = usePan({
    onTouchesDown: () => {
      'worklet';
      console.log('Touch down');
      globalThis._setGestureStateSync(57, 4);
    },
    onTouchesMove: () => {
      'worklet';
      console.log('Touch move');
    },
    onTouchesUp: () => {
      'worklet';
      console.log('Touch up');
    },
    onTouchesCancelled: () => {
      'worklet';
      console.log('Touch cancel');
    },
    onBegin: () => {
      'worklet';
      console.log('Gesture begin');
    },
    onStart: (e) => {
      'worklet';
      console.log('Gesture start');
    },
    onUpdate: (e) => {
      'worklet';
      console.log('Gesture update', e.handlerData.translationX, e.handlerData.translationY);
    },
    onEnd: () => {
      'worklet';
      console.log('Gesture end');
    },
    onFinalize: () => {
      'worklet';
      console.log('Gesture finalize');
    },
  });

  console.log('Rendering EmptyExamplee', pan.tag);

  return (
    <View style={styles.container}>
      <NativeDetector gesture={pan}>
        <View style={{ width: 300, height: 300, backgroundColor: 'green' }} />
      </NativeDetector>
    </View>
  );
}

const styles = StyleSheet.create({
  container: {
    flex: 1,
    justifyContent: 'center',
    alignItems: 'center',
  },
});

```

Author: j-piasecki

packages/react-native-gesture-handler/android/src/main/java/com/swmansion/gesturehandler/core/GestureHandler.kt

@@ -82,6 +82,7 @@ open class GestureHandler {
     }
   var actionType = 0
 
+  var forceReinitializeDuringOnHandle = false
   var changedTouchesPayload: WritableArray? = null
     private set
   var allTouchesPayload: WritableArray? = null
@@ -755,6 +756,7 @@ open class GestureHandler {
   // if the handler is waiting for failure of other one)
   open fun resetProgress() {}
 
+  protected open fun initialize(event: MotionEvent, sourceEvent: MotionEvent) {}
   protected open fun onHandle(event: MotionEvent, sourceEvent: MotionEvent) {
     moveToState(STATE_FAILED)
   }

packages/react-native-gesture-handler/android/src/main/java/com/swmansion/gesturehandler/core/GestureHandlerOrchestrator.kt

@@ -287,15 +287,7 @@ class GestureHandlerOrchestrator(
     val action = sourceEvent.actionMasked
     val event = transformEventToViewCoords(handler.view, MotionEvent.obtain(sourceEvent))
 
-    // Touch events are sent before the handler itself has a chance to process them,
-    // mainly because `onTouchesUp` should be send before gesture finishes. This means that
-    // the first `onTouchesDown` event is sent before a gesture begins, activation in
-    // callback for this event causes problems because the handler doesn't have a chance
-    // to initialize itself with starting values of pointer (in pan this causes translation
-    // to be equal to the coordinates of the pointer). The simplest solution is to send
-    // the first `onTouchesDown` event after the handler processes it and changes state
-    // to `BEGAN`.
-    if (handler.needsPointerData && handler.state != 0) {
+    if (handler.needsPointerData) {
       handler.updatePointerData(event, sourceEvent)
     }
 
@@ -317,10 +309,6 @@ class GestureHandlerOrchestrator(
         handler.dispatchHandlerUpdate(event)
       }
 
-      if (handler.needsPointerData && isFirstEvent) {
-        handler.updatePointerData(event, sourceEvent)
-      }
-
       // if event was of type UP or POINTER_UP we request handler to stop tracking now that
       // the event has been dispatched
       if (action == MotionEvent.ACTION_UP ||

packages/react-native-gesture-handler/android/src/main/java/com/swmansion/gesturehandler/core/LongPressGestureHandler.kt

@@ -65,14 +65,23 @@ class LongPressGestureHandler(context: Context) : GestureHandler() {
     return Pair(x, y)
   }
 
+  override fun initialize(event: MotionEvent, sourceEvent: MotionEvent) {
+    previousTime = SystemClock.uptimeMillis()
+    startTime = previousTime
+  }
+
   override fun onHandle(event: MotionEvent, sourceEvent: MotionEvent) {
     if (!shouldActivateWithMouse(sourceEvent)) {
       return
     }
 
+    if (forceReinitializeDuringOnHandle) {
+      forceReinitializeDuringOnHandle = false
+      initialize(event, sourceEvent)
+    }
+
     if (state == STATE_UNDETERMINED) {
-      previousTime = SystemClock.uptimeMillis()
-      startTime = previousTime
+      initialize(event, sourceEvent)
       begin()
 
       val (x, y) = getAverageCoords(sourceEvent)

packages/react-native-gesture-handler/android/src/main/java/com/swmansion/gesturehandler/core/PanGestureHandler.kt

@@ -148,11 +148,25 @@ class PanGestureHandler(context: Context?) : GestureHandler() {
     return failOffsetYEnd != MIN_VALUE_IGNORE && dy > failOffsetYEnd
   }
 
+  override fun initialize(event: MotionEvent, sourceEvent: MotionEvent) {
+    resetProgress()
+    offsetX = 0f
+    offsetY = 0f
+    velocityX = 0f
+    velocityY = 0f
+    velocityTracker = VelocityTracker.obtain()
+  }
+
   override fun onHandle(event: MotionEvent, sourceEvent: MotionEvent) {
     if (!shouldActivateWithMouse(sourceEvent)) {
       return
     }
 
+    if (forceReinitializeDuringOnHandle) {
+      forceReinitializeDuringOnHandle = false
+      initialize(event, sourceEvent)
+    }
+
     if (event.getToolType(0) == MotionEvent.TOOL_TYPE_STYLUS) {
       stylusData = StylusData.fromEvent(event)
     }
@@ -174,12 +188,7 @@ class PanGestureHandler(context: Context?) : GestureHandler() {
       lastY = getLastPointerY(sourceEvent, averageTouches)
     }
     if (state == STATE_UNDETERMINED && sourceEvent.pointerCount >= minPointers) {
-      resetProgress()
-      offsetX = 0f
-      offsetY = 0f
-      velocityX = 0f
-      velocityY = 0f
-      velocityTracker = VelocityTracker.obtain()
+      initialize(event, sourceEvent)
       addVelocityMovement(velocityTracker, sourceEvent)
       begin()
 

packages/react-native-gesture-handler/android/src/main/java/com/swmansion/gesturehandler/core/PinchGestureHandler.kt

@@ -49,18 +49,26 @@ class PinchGestureHandler : GestureHandler() {
     }
   }
 
-  override fun onHandle(event: MotionEvent, sourceEvent: MotionEvent) {
-    if (state == STATE_UNDETERMINED) {
-      val context = view!!.context
-      resetProgress()
-      scaleGestureDetector = ScaleGestureDetector(context, gestureListener)
-      val configuration = ViewConfiguration.get(context)
-      spanSlop = configuration.scaledTouchSlop.toFloat()
+  override fun initialize(event: MotionEvent, sourceEvent: MotionEvent) {
+    val context = view!!.context
+    resetProgress()
+    scaleGestureDetector = ScaleGestureDetector(context, gestureListener)
+    val configuration = ViewConfiguration.get(context)
+    spanSlop = configuration.scaledTouchSlop.toFloat()
 
-      // set the focal point to the position of the first pointer as NaN causes the event not to arrive
-      this.focalPointX = event.x
-      this.focalPointY = event.y
+    // set the focal point to the position of the first pointer as NaN causes the event not to arrive
+    this.focalPointX = event.x
+    this.focalPointY = event.y
+  }
 
+  override fun onHandle(event: MotionEvent, sourceEvent: MotionEvent) {
+    if (forceReinitializeDuringOnHandle) {
+      forceReinitializeDuringOnHandle = false
+      initialize(event, sourceEvent)
+    }
+
+    if (state == STATE_UNDETERMINED) {
+      initialize(event, sourceEvent)
       begin()
     }
     scaleGestureDetector?.onTouchEvent(sourceEvent)

packages/react-native-gesture-handler/android/src/main/java/com/swmansion/gesturehandler/core/RotationGestureHandler.kt

@@ -39,15 +39,23 @@ class RotationGestureHandler : GestureHandler() {
     }
   }
 
-  override fun onHandle(event: MotionEvent, sourceEvent: MotionEvent) {
-    if (state == STATE_UNDETERMINED) {
-      resetProgress()
-      rotationGestureDetector = RotationGestureDetector(gestureListener)
+  override fun initialize(event: MotionEvent, sourceEvent: MotionEvent) {
+    resetProgress()
+    rotationGestureDetector = RotationGestureDetector(gestureListener)
 
-      // set the anchor to the position of the first pointer as NaN causes the event not to arrive
-      this.anchorX = event.x
-      this.anchorY = event.y
+    // set the anchor to the position of the first pointer as NaN causes the event not to arrive
+    this.anchorX = event.x
+    this.anchorY = event.y
+  }
 
+  override fun onHandle(event: MotionEvent, sourceEvent: MotionEvent) {
+    if (forceReinitializeDuringOnHandle) {
+      forceReinitializeDuringOnHandle = false
+      initialize(event, sourceEvent)
+    }
+
+    if (state == STATE_UNDETERMINED) {
+      initialize(event, sourceEvent)
       begin()
     }
     rotationGestureDetector?.onTouchEvent(sourceEvent)

packages/react-native-gesture-handler/android/src/main/java/com/swmansion/gesturehandler/core/TapGestureHandler.kt

@@ -81,18 +81,27 @@ class TapGestureHandler : GestureHandler() {
     return maxDist != MAX_VALUE_IGNORE && dist > maxDist * maxDist
   }
 
+  override fun initialize(event: MotionEvent, sourceEvent: MotionEvent) {
+    offsetX = 0f
+    offsetY = 0f
+    startX = getLastPointerX(sourceEvent, true)
+    startY = getLastPointerY(sourceEvent, true)
+  }
+
   override fun onHandle(event: MotionEvent, sourceEvent: MotionEvent) {
     if (!shouldActivateWithMouse(sourceEvent)) {
       return
     }
 
+    if (forceReinitializeDuringOnHandle) {
+      forceReinitializeDuringOnHandle = false
+      initialize(event, sourceEvent)
+    }
+
     val state = state
     val action = sourceEvent.actionMasked
     if (state == STATE_UNDETERMINED) {
-      offsetX = 0f
-      offsetY = 0f
-      startX = getLastPointerX(sourceEvent, true)
-      startY = getLastPointerY(sourceEvent, true)
+      initialize(event, sourceEvent)
     }
     if (action == MotionEvent.ACTION_POINTER_UP || action == MotionEvent.ACTION_POINTER_DOWN) {
       offsetX += lastX - startX

packages/react-native-gesture-handler/android/src/main/java/com/swmansion/gesturehandler/react/RNGestureHandlerModule.kt

@@ -140,6 +140,16 @@ class RNGestureHandlerModule(reactContext: ReactApplicationContext?) :
     UiThreadUtil.assertOnUiThread()
 
     registry.getHandler(handlerTag)?.let { handler ->
+      if (handler.state == GestureHandler.STATE_UNDETERMINED) {
+        handler.forceReinitializeDuringOnHandle = true
+
+        // When going from UNDETERMINED to ACTIVE, force going through BEGAN to preserve
+        // the correct state flow
+        if (newState == GestureHandler.STATE_ACTIVE) {
+          handler.begin()
+        }
+      }
+
       when (newState) {
         GestureHandler.STATE_ACTIVE -> handler.activate(force = true)
         GestureHandler.STATE_BEGAN -> handler.begin()