fix(android): Replace GestureDetectorCompat with lightweight SentryGestureDetector to fix ANR

GestureDetectorCompat internally uses Handler.sendMessage/removeMessages which
acquires a synchronized lock on the main thread MessageQueue, plus
recordGestureClassification triggers IPC calls. This caused ANRs under load
(SDK-CRASHES-JAVA-596, 175K+ occurrences).

Replace with a minimal custom detector that only detects click, scroll, and
fling without any Handler scheduling, MessageQueue contention, or IPC overhead.

Co-Authored-By: Claude Opus 4.6 <[email protected]>

Author: romtsn

sentry-android-core/src/main/java/io/sentry/android/core/internal/gestures/SentryGestureDetector.java

@@ -0,0 +1,125 @@
+package io.sentry.android.core.internal.gestures;
+
+import android.content.Context;
+import android.view.GestureDetector;
+import android.view.MotionEvent;
+import android.view.VelocityTracker;
+import android.view.ViewConfiguration;
+import org.jetbrains.annotations.ApiStatus;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+/**
+ * A lightweight gesture detector that replaces {@link
+ * androidx.core.view.GestureDetectorCompat}/{@link GestureDetector} to avoid ANRs caused by
+ * Handler/MessageQueue lock contention and IPC calls (FrameworkStatsLog.write).
+ *
+ * <p>Only detects click (tap), scroll, and fling — the gestures used by {@link
+ * SentryGestureListener}. Long-press, show-press, and double-tap detection (which require Handler
+ * message scheduling) are intentionally omitted.
+ */
+@ApiStatus.Internal
+public final class SentryGestureDetector {
+
+  private final @NotNull GestureDetector.OnGestureListener listener;
+  private final int touchSlopSquare;
+  private final int minimumFlingVelocity;
+  private final int maximumFlingVelocity;
+
+  private boolean isInTapRegion;
+  private float downX;
+  private float downY;
+  private float lastX;
+  private float lastY;
+  private @Nullable MotionEvent currentDownEvent;
+  private @Nullable VelocityTracker velocityTracker;
+
+  SentryGestureDetector(
+      final @NotNull Context context, final @NotNull GestureDetector.OnGestureListener listener) {
+    this.listener = listener;
+    final ViewConfiguration config = ViewConfiguration.get(context);
+    final int touchSlop = config.getScaledTouchSlop();
+    this.touchSlopSquare = touchSlop * touchSlop;
+    this.minimumFlingVelocity = config.getScaledMinimumFlingVelocity();
+    this.maximumFlingVelocity = config.getScaledMaximumFlingVelocity();
+  }
+
+  boolean onTouchEvent(final @NotNull MotionEvent event) {
+    final int action = event.getActionMasked();
+
+    if (velocityTracker == null) {
+      velocityTracker = VelocityTracker.obtain();
+    }
+    velocityTracker.addMovement(event);
+
+    switch (action) {
+      case MotionEvent.ACTION_DOWN:
+        downX = event.getX();
+        downY = event.getY();
+        lastX = downX;
+        lastY = downY;
+        isInTapRegion = true;
+
+        if (currentDownEvent != null) {
+          currentDownEvent.recycle();
+        }
+        currentDownEvent = MotionEvent.obtain(event);
+
+        listener.onDown(event);
+        break;
+
+      case MotionEvent.ACTION_MOVE:
+        {
+          final float x = event.getX();
+          final float y = event.getY();
+          final float dx = x - downX;
+          final float dy = y - downY;
+          final float distanceSquare = (dx * dx) + (dy * dy);
+
+          if (distanceSquare > touchSlopSquare) {
+            final float scrollX = lastX - x;
+            final float scrollY = lastY - y;
+            listener.onScroll(currentDownEvent, event, scrollX, scrollY);
+            isInTapRegion = false;
+            lastX = x;
+            lastY = y;
+          }
+          break;
+        }
+
+      case MotionEvent.ACTION_UP:
+        if (isInTapRegion) {
+          listener.onSingleTapUp(event);
+        } else if (velocityTracker != null) {
+          final int pointerId = event.getPointerId(0);
+          velocityTracker.computeCurrentVelocity(1000, maximumFlingVelocity);
+          final float velocityX = velocityTracker.getXVelocity(pointerId);
+          final float velocityY = velocityTracker.getYVelocity(pointerId);
+
+          if (Math.abs(velocityX) > minimumFlingVelocity
+              || Math.abs(velocityY) > minimumFlingVelocity) {
+            listener.onFling(currentDownEvent, event, velocityX, velocityY);
+          }
+        }
+        cleanup();
+        break;
+
+      case MotionEvent.ACTION_CANCEL:
+        cleanup();
+        break;
+    }
+
+    return false;
+  }
+
+  private void cleanup() {
+    if (velocityTracker != null) {
+      velocityTracker.recycle();
+      velocityTracker = null;
+    }
+    if (currentDownEvent != null) {
+      currentDownEvent.recycle();
+      currentDownEvent = null;
+    }
+  }
+}

sentry-android-core/src/main/java/io/sentry/android/core/internal/gestures/SentryWindowCallback.java

@@ -1,11 +1,8 @@
 package io.sentry.android.core.internal.gestures;
 
 import android.content.Context;
-import android.os.Handler;
-import android.os.Looper;
 import android.view.MotionEvent;
 import android.view.Window;
-import androidx.core.view.GestureDetectorCompat;
 import io.sentry.SentryLevel;
 import io.sentry.SentryOptions;
 import io.sentry.SpanStatus;
@@ -18,7 +15,7 @@ public final class SentryWindowCallback extends WindowCallbackAdapter {
 
   private final @NotNull Window.Callback delegate;
   private final @NotNull SentryGestureListener gestureListener;
-  private final @NotNull GestureDetectorCompat gestureDetector;
+  private final @NotNull SentryGestureDetector gestureDetector;
   private final @Nullable SentryOptions options;
   private final @NotNull MotionEventObtainer motionEventObtainer;
 
@@ -29,15 +26,15 @@ public SentryWindowCallback(
       final @Nullable SentryOptions options) {
     this(
         delegate,
-        new GestureDetectorCompat(context, gestureListener, new Handler(Looper.getMainLooper())),
+        new SentryGestureDetector(context, gestureListener),
         gestureListener,
         options,
         new MotionEventObtainer() {});
   }
 
   SentryWindowCallback(
       final @NotNull Window.Callback delegate,
-      final @NotNull GestureDetectorCompat gestureDetector,
+      final @NotNull SentryGestureDetector gestureDetector,
       final @NotNull SentryGestureListener gestureListener,
       final @Nullable SentryOptions options,
       final @NotNull MotionEventObtainer motionEventObtainer) {

sentry-android-core/src/test/java/io/sentry/android/core/internal/gestures/SentryWindowCallbackTest.kt

@@ -2,7 +2,6 @@ package io.sentry.android.core.internal.gestures
 
 import android.view.MotionEvent
 import android.view.Window
-import androidx.core.view.GestureDetectorCompat
 import io.sentry.android.core.SentryAndroidOptions
 import io.sentry.android.core.internal.gestures.SentryWindowCallback.MotionEventObtainer
 import kotlin.test.Test
@@ -18,7 +17,7 @@ class SentryWindowCallbackTest {
   class Fixture {
     val delegate = mock<Window.Callback>()
     val options = SentryAndroidOptions().apply { dsn = "https://[email protected]/proj" }
-    val gestureDetector = mock<GestureDetectorCompat>()
+    val gestureDetector = mock<SentryGestureDetector>()
     val gestureListener = mock<SentryGestureListener>()
     val motionEventCopy = mock<MotionEvent>()