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,12 @@ 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 and just call stopTracking()
+    // to release our resources. The upstream wrapper holds a reference to ours, so it'll be
+    // GC'd whenever that upstream holder is (typically when the window is destroyed).
     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,10 @@ public final class SentryWindowCallback extends WindowCallbackAdapter {
   private final @Nullable SentryOptions options;
   private final @NotNull MotionEventObtainer motionEventObtainer;
 
+  // When we can't be removed from the callback chain (see UserInteractionIntegration),
+  // stopTracking() flips this so handleTouchEvent short-circuits.
+  private volatile boolean inert;
+
   public SentryWindowCallback(
       final @NotNull Window.Callback delegate,
       final @NotNull Context context,
@@ -64,6 +68,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 +79,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,25 @@ 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)
+    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)
+  }
 }