[Android] Dispatch onPressIn when the native press starts (#4575)

## Description 

On Android `onPressIn` was sent when the `Native` gesture began, i.e. on
the `DOWN`. The platform defers the pressed state inside scrolling
containers and drops it when a parent intercepts the touch, so a tap
that stops a fling fired `onPressIn` and `onPressOut` with no `onPress`,
and feedback driven from `onPressIn` ran ahead of the native ripple
(#4515).

`onPressIn` and the long press timer now follow `setPressed(true)`, the
moment the native press feedback starts. The long press timer is still
measured from the `DOWN`. `onPressOut`, `onPress` and the
`pressOutAfterAnimation` hold are unchanged.

Fixes #4515

## Test plan

<details>
<summary>Tested on the following code:</summary>

```tsx
import React, { useRef, useState } from 'react';
import {
  Animated,
  FlatList as RNFlatList,
  StyleSheet,
  Text,
  View,
} from 'react-native';
import { FlatList, Touchable } from 'react-native-gesture-handler';

// onPressIn follows the native press (#4515, #4547). Every row scales down from onPressIn and
// back from onPressOut, next to the native ripple, so the two should start together.
//  - Fling the list, then stop it with a finger on a row and lift: no callback should fire.
//  - Start a fast swipe on a row: no onPressIn. Press, hold, then drag: onPressIn with the
//    ripple, onPressOut when the scroll takes over.
//  - Hold a row: onLongPress at ~500 ms, in both lists.
const ROWS = Array.from({ length: 200 }, (_, i) => i);
const LONG_PRESS_MS = 500;
const COLORS = ['#6750a4', '#0b6e4f', '#b3261e', '#1d4ed8', '#b45309'];

type Counts = {
  pressIn: number;
  pressOut: number;
  press: number;
  longPress: number;
};

const EMPTY_COUNTS: Counts = {
  pressIn: 0,
  pressOut: 0,
  press: 0,
  longPress: 0,
};

function Row({
  index,
  count,
}: {
  index: number;
  count: (key: keyof Counts) => void;
}) {
  const scale = useRef(new Animated.Value(1)).current;
  const animateTo = (value: number) =>
    Animated.timing(scale, {
      toValue: value,
      duration: 100,
      useNativeDriver: true,
    }).start();
  const color = COLORS[index % COLORS.length];

  return (
    <Touchable
      androidRipple={{ color: 'rgba(0, 0, 0, 0.12)' }}
      delayLongPress={LONG_PRESS_MS}
      onPressIn={() => {
        count('pressIn');
        animateTo(0.95);
      }}
      onPressOut={() => {
        count('pressOut');
        animateTo(1);
      }}
      onPress={() => count('press')}
      onLongPress={() => count('longPress')}>
      <Animated.View style={[styles.row, { transform: [{ scale }] }]}>
        <View style={[styles.avatar, { backgroundColor: color }]}>
          <Text style={styles.avatarText}>{index}</Text>
        </View>
        <View>
          <Text style={styles.rowTitle}>Row {index}</Text>
          <Text style={styles.rowSubtitle}>
            scales on onPressIn, ripple on native press
          </Text>
        </View>
      </Animated.View>
    </Touchable>
  );
}

function Stat({ label, value }: { label: string; value: number }) {
  return (
    <View style={styles.stat}>
      <Text style={styles.statValue}>{value}</Text>
      <Text style={styles.statLabel}>{label}</Text>
    </View>
  );
}

export default function PressInNativeTimingExample() {
  const [useRNGHList, setUseRNGHList] = useState(true);
  const [counts, setCounts] = useState<Counts>(EMPTY_COUNTS);
  const count = (key: keyof Counts) =>
    setCounts((c) => ({ ...c, [key]: c[key] + 1 }));

  const List = useRNGHList ? FlatList : RNFlatList;

  return (
    <View style={styles.root}>
      <View style={styles.panel}>
        <View style={styles.stats}>
          <Stat label="pressIn" value={counts.pressIn} />
          <Stat label="pressOut" value={counts.pressOut} />
          <Stat label="press" value={counts.press} />
          <Stat label="longPress" value={counts.longPress} />
        </View>
        <View style={styles.actions}>
          <Touchable
            style={styles.button}
            onPress={() => setUseRNGHList((v) => !v)}>
            <Text style={styles.buttonText}>
              {useRNGHList ? 'RNGH FlatList' : 'RN FlatList'}
            </Text>
          </Touchable>
          <Touchable
            style={[styles.button, styles.buttonSecondary]}
            onPress={() => setCounts(EMPTY_COUNTS)}>
            <Text style={[styles.buttonText, styles.buttonSecondaryText]}>
              Reset
            </Text>
          </Touchable>
        </View>
        <Text style={styles.hint}>
          Fling, then stop the list with a finger on a row: nothing should
          count. Hold a row for onLongPress.
        </Text>
      </View>
      <List
        key={useRNGHList ? 'rngh' : 'rn'}
        data={ROWS}
        keyExtractor={(i) => String(i)}
        contentContainerStyle={styles.content}
        renderItem={({ item }) => <Row index={item} count={count} />}
      />
    </View>
  );
}

const styles = StyleSheet.create({
  root: { flex: 1, backgroundColor: '#f4f3f8' },
  panel: {
    margin: 16,
    marginBottom: 8,
    padding: 16,
    borderRadius: 16,
    backgroundColor: '#fff',
    gap: 12,
    shadowColor: '#000',
    shadowOpacity: 0.08,
    shadowRadius: 12,
    shadowOffset: { width: 0, height: 4 },
    elevation: 3,
  },
  stats: { flexDirection: 'row', justifyContent: 'space-between' },
  stat: { alignItems: 'flex-start' },
  statValue: { fontSize: 24, fontWeight: '700', color: '#1c1b1f' },
  statLabel: { fontSize: 12, color: '#79747e' },
  actions: { flexDirection: 'row', gap: 8 },
  button: {
    flex: 1,
    alignItems: 'center',
    paddingVertical: 10,
    borderRadius: 10,
    backgroundColor: '#6750a4',
  },
  buttonText: { color: '#fff', fontWeight: '600' },
  buttonSecondary: {
    flex: 0,
    paddingHorizontal: 16,
    backgroundColor: '#e8e8ee',
  },
  buttonSecondaryText: { color: '#1c1b1f' },
  hint: { color: '#5f5c66', fontSize: 13, lineHeight: 18 },
  content: { paddingHorizontal: 16, paddingBottom: 16, gap: 8 },
  row: {
    flexDirection: 'row',
    alignItems: 'center',
    gap: 12,
    padding: 12,
    borderRadius: 14,
    backgroundColor: '#fff',
  },
  avatar: {
    width: 40,
    height: 40,
    borderRadius: 20,
    alignItems: 'center',
    justifyContent: 'center',
  },
  avatarText: { color: '#fff', fontWeight: '700' },
  rowTitle: { fontSize: 16, fontWeight: '600', color: '#1c1b1f' },
  rowSubtitle: { fontSize: 12, color: '#79747e', marginTop: 2 },
});
```

</details>

Author: m-bert

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

@@ -738,6 +738,10 @@ class RNGestureHandlerButtonViewManager :
     // container) instead of pressing right away.
     private var pressDeferredByPlatform = false
 
+    // Uptime of the DOWN that began the current press sequence; the long press timer is measured from it.
+    private var pressDownTime = 0L
+    private var pressStarted = false
+
     override fun onHandlerUpdate(handler: NativeViewGestureHandler) {
       if (managedHandlerTag == null || handler.isWithinBounds == lastEventWasInside) {
         return
@@ -773,17 +777,16 @@ class RNGestureHandlerButtonViewManager :
         // native dispatch of the same DOWN and the sweep that reads the flag.
         receivedNativeDown = false
         flushPendingPressOut()
-        dispatchJSEvent(EventType.PressIn, handler)
+        pressDownTime = SystemClock.uptimeMillis()
+        pressStarted = false
         longPressDetected = false
 
-        if (hasLongPressHandler && longPressDuration >= 0) {
-          val runnable = Runnable {
-            pendingLongPress = null
-            longPressDetected = true
-            dispatchJSEvent(EventType.LongPress, handler)
-          }
-          pendingLongPress = runnable
-          this.handler?.postDelayed(runnable, longPressDuration.toLong())
+        // Touch-driven presses report PressIn and arm the long press timer from `setPressed`, when the
+        // press feedback starts. A synthetic activation (TalkBack, keyboard) has no touch and no
+        // pressed state to follow, so it reports PressIn right away. Nothing deferred it either.
+        if (!handler.hasTrackedPointers) {
+          pressDeferredByPlatform = false
+          dispatchJSEvent(EventType.PressIn, handler)
         }
       }
 
@@ -819,6 +822,42 @@ class RNGestureHandlerButtonViewManager :
       }
     }
 
+    // The framework defers the pressed state inside scrolling containers and drops it when a parent
+    // intercepts the DOWN (e.g. a fling catch), so PressIn and the long press timer follow the pressed
+    // state, not BEGAN. Like `View.CheckForTap`, long press is still measured from the DOWN.
+    private fun onPressedStateStarted() {
+      val moduleId = moduleId ?: return
+      val handlerTag = managedHandlerTag ?: return
+      val handler =
+        RNGestureHandlerModule.registries[moduleId]?.getHandler(handlerTag) as? NativeViewGestureHandler ?: return
+
+      if (handler.state != GestureHandler.STATE_BEGAN && handler.state != GestureHandler.STATE_ACTIVE) {
+        return
+      }
+
+      if (!lastEventWasInside) {
+        dispatchJSEvent(EventType.PressIn, handler)
+      }
+
+      // Re-entry after leaving (cancelOnLeave off) reports PressIn again but never re-arms the timer.
+      if (pressStarted) {
+        return
+      }
+
+      pressStarted = true
+
+      if (hasLongPressHandler && longPressDuration >= 0) {
+        val elapsed = SystemClock.uptimeMillis() - pressDownTime
+        val runnable = Runnable {
+          pendingLongPress = null
+          longPressDetected = true
+          dispatchJSEvent(EventType.LongPress, handler)
+        }
+        pendingLongPress = runnable
+        this.handler?.postDelayed(runnable, (longPressDuration - elapsed).coerceAtLeast(0))
+      }
+    }
+
     private fun dispatchJSEvent(type: EventType, handler: NativeViewGestureHandler) {
       dispatchEvent(RNGestureHandlerButtonEvent.obtain(this, handler, type))
 
@@ -1595,6 +1634,7 @@ class RNGestureHandlerButtonViewManager :
 
         if (pressed) {
           animatePressIn()
+          onPressedStateStarted()
         } else {
           animatePressOut()
         }