fix(user-interaction): Inert buried SentryWindowCallback and drop its cache entry on stop

Two follow-ups to the buried-wrapper path:

- stopTracking() now sets an inert flag that short-circuits handleTouchEvent, so a SentryWindowCallback that can't be cut out of the chain stops forwarding events to its gesture detector and listener. Without this, the "stopped" wrapper kept emitting ui.click breadcrumbs, so as soon as a fresh wrapper was installed on top the duplicates came back.
- unwrapWindow removes the wrapped window from the tracking map in the buried path too. Previously only the top-of-chain path cleared it, which meant the next startTracking() found a stale (but alive, since the inert wrapper is still referenced by the chain) entry and returned early, permanently losing gesture tracking for that window.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

Author: romtsn

sentry-android-core/src/main/java/io/sentry/android/core/UserInteractionIntegration.java

@@ -110,11 +110,13 @@ private void unwrapWindow(final @NotNull Window window) {
     }
 
     // Another wrapper (e.g. Session Replay) sits on top of ours — cutting it out of the chain
-    // would break its instrumentation, so we leave the chain alone and only release our
-    // resources. The inert wrapper gets GC'd when the window is destroyed.
+    // would break its instrumentation, so we leave the chain alone. stopTracking() flips the
+    // wrapper into inert mode so it stops emitting breadcrumbs; it gets GC'd when the window
+    // is destroyed. We also drop it from the map so the next startTracking() can install a
+    // fresh active wrapper on top.
     final @Nullable SentryWindowCallback ours;
     synchronized (wrappedWindowsLock) {
-      final @Nullable WeakReference<SentryWindowCallback> cached = wrappedWindows.get(window);
+      final @Nullable WeakReference<SentryWindowCallback> cached = wrappedWindows.remove(window);
       ours = cached != null ? cached.get() : null;
     }
     if (ours != null) {

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

@@ -19,6 +19,11 @@ public final class SentryWindowCallback extends WindowCallbackAdapter {
   private final @Nullable SentryOptions options;
   private final @NotNull MotionEventObtainer motionEventObtainer;
 
+  // Set to true once stopTracking() has been called. When the wrapper is buried under another
+  // Window.Callback we can't remove ourselves from the chain, so we flip this flag to make
+  // handleTouchEvent a no-op and stop emitting gesture breadcrumbs.
+  private volatile boolean inert;
+
   public SentryWindowCallback(
       final @NotNull Window.Callback delegate,
       final @NotNull Context context,
@@ -64,6 +69,9 @@ public boolean dispatchTouchEvent(final @Nullable MotionEvent motionEvent) {
   }
 
   private void handleTouchEvent(final @NotNull MotionEvent motionEvent) {
+    if (inert) {
+      return;
+    }
     gestureDetector.onTouchEvent(motionEvent);
     int action = motionEvent.getActionMasked();
     if (action == MotionEvent.ACTION_UP) {
@@ -72,6 +80,7 @@ private void handleTouchEvent(final @NotNull MotionEvent motionEvent) {
   }
 
   public void stopTracking() {
+    inert = true;
     gestureListener.stopTracing(SpanStatus.CANCELLED);
     gestureDetector.release();
   }

sentry-android-core/src/test/java/io/sentry/android/core/UserInteractionIntegrationTest.kt

@@ -14,6 +14,7 @@ import kotlin.test.BeforeTest
 import kotlin.test.Test
 import kotlin.test.assertIs
 import kotlin.test.assertIsNot
+import kotlin.test.assertNotSame
 import kotlin.test.assertSame
 import org.junit.runner.RunWith
 import org.mockito.kotlin.any
@@ -148,21 +149,28 @@ class UserInteractionIntegrationTest {
   }
 
   @Test
-  fun `does not double-wrap when another callback wraps SentryWindowCallback`() {
+  fun `resume after buried pause installs a fresh wrapper on top`() {
     val sut = fixture.getSut()
     sut.register(fixture.scopes, fixture.options)
 
     sut.onActivityResumed(fixture.activity)
-    val sentryCallback = fixture.window.callback
-    assertIs<SentryWindowCallback>(sentryCallback)
+    val originalSentryCallback = fixture.window.callback
+    assertIs<SentryWindowCallback>(originalSentryCallback)
 
-    val outerWrapper = WrapperCallback(sentryCallback)
+    // Third-party wraps on top of us mid-activity.
+    val outerWrapper = WrapperCallback(originalSentryCallback)
     fixture.window.callback = outerWrapper
 
     sut.onActivityPaused(fixture.activity)
     sut.onActivityResumed(fixture.activity)
 
-    assertSame(outerWrapper, fixture.window.callback)
+    // Buried path must drop its map entry so the resume can install a fresh wrapper on top;
+    // otherwise the stale cache entry makes startTracking() return early and we permanently
+    // lose gesture tracking for this window.
+    val newTop = fixture.window.callback
+    assertIs<SentryWindowCallback>(newTop)
+    assertNotSame(originalSentryCallback, newTop)
+    assertSame(outerWrapper, newTop.delegate)
   }
 
   @Test

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

@@ -82,4 +82,18 @@ class SentryWindowCallbackTest {
 
     verify(fixture.gestureDetector, never()).onTouchEvent(any())
   }
+
+  @Test
+  fun `after stopTracking does not forward touches to detector or listener`() {
+    val event = mock<MotionEvent> { whenever(it.actionMasked).thenReturn(MotionEvent.ACTION_UP) }
+    val sut = fixture.getSut()
+
+    sut.stopTracking()
+    sut.dispatchTouchEvent(event)
+
+    verify(fixture.gestureDetector, never()).onTouchEvent(any())
+    verify(fixture.gestureListener, never()).onUp(any())
+    // super.dispatchTouchEvent still delegates to the wrapped delegate so the chain keeps working.
+    verify(fixture.delegate).dispatchTouchEvent(event)
+  }
 }