fix(replay): Track wrapped windows and inert buried recorders on stop

Track wrapped windows in a WeakHashMap so GestureRecorder skips re-wrapping already-instrumented windows and can locate its own recorder even when another wrapper (e.g. UserInteractionIntegration) has been installed on top of it. When our wrapper is buried in the callback chain, inert() it instead of mutating the chain so unrelated instrumentation isn't broken; the next replay session wraps on top with a fresh active recorder.

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

Author: romtsn

sentry-android-replay/src/main/java/io/sentry/android/replay/gestures/GestureRecorder.kt

@@ -11,6 +11,7 @@ import io.sentry.android.replay.phoneWindow
 import io.sentry.android.replay.util.FixedWindowCallback
 import io.sentry.util.AutoClosableReentrantLock
 import java.lang.ref.WeakReference
+import java.util.WeakHashMap
 
 internal class GestureRecorder(
   private val options: SentryOptions,
@@ -19,6 +20,11 @@ internal class GestureRecorder(
   private val rootViews = ArrayList<WeakReference<View>>()
   private val rootViewsLock = AutoClosableReentrantLock()
 
+  // WeakReference value, because the callback chain strongly references the wrapper — a strong
+  // value would prevent the window from ever being GC'd.
+  private val wrappedWindows = WeakHashMap<Window, WeakReference<SentryReplayGestureRecorder>>()
+  private val wrappedWindowsLock = AutoClosableReentrantLock()
+
   override fun onRootViewsChanged(root: View, added: Boolean) {
     rootViewsLock.acquire().use {
       if (added) {
@@ -45,10 +51,16 @@ internal class GestureRecorder(
       return
     }
 
-    val delegate = window.callback
-    if (delegate !is SentryReplayGestureRecorder) {
-      window.callback = SentryReplayGestureRecorder(options, touchRecorderCallback, delegate)
+    wrappedWindowsLock.acquire().use {
+      if (wrappedWindows[window]?.get() != null) {
+        return
+      }
     }
+
+    val delegate = window.callback
+    val wrapper = SentryReplayGestureRecorder(options, touchRecorderCallback, delegate)
+    window.callback = wrapper
+    wrappedWindowsLock.acquire().use { wrappedWindows[window] = WeakReference(wrapper) }
   }
 
   private fun View.stopGestureTracking() {
@@ -60,14 +72,25 @@ internal class GestureRecorder(
 
     val callback = window.callback
     if (callback is SentryReplayGestureRecorder) {
-      val delegate = callback.delegate
-      window.callback = delegate
+      window.callback = callback.delegate
+      wrappedWindowsLock.acquire().use { wrappedWindows.remove(window) }
+      return
+    }
+
+    // Another wrapper (e.g. UserInteractionIntegration) sits on top of ours — cutting it out of
+    // the chain would break its instrumentation, so we inert our buried wrapper instead. The
+    // next replay session will then wrap on top with a fresh active instance.
+    val ours: SentryReplayGestureRecorder?
+    wrappedWindowsLock.acquire().use {
+      ours = wrappedWindows[window]?.get()
+      wrappedWindows.remove(window)
     }
+    ours?.inert()
   }
 
   internal class SentryReplayGestureRecorder(
     private val options: SentryOptions,
-    private val touchRecorderCallback: TouchRecorderCallback?,
+    @Volatile private var touchRecorderCallback: TouchRecorderCallback?,
     delegate: Window.Callback?,
   ) : FixedWindowCallback(delegate) {
     override fun dispatchTouchEvent(event: MotionEvent?): Boolean {
@@ -83,6 +106,14 @@ internal class GestureRecorder(
       }
       return super.dispatchTouchEvent(event)
     }
+
+    /**
+     * Turns this wrapper into a passthrough when it can't be removed from the chain (another
+     * wrapper sits on top). Subsequent dispatches only delegate, skipping the recorder callback.
+     */
+    fun inert() {
+      touchRecorderCallback = null
+    }
   }
 }
 

sentry-android-replay/src/test/java/io/sentry/android/replay/gestures/GestureRecorderTest.kt

@@ -5,6 +5,7 @@ import android.app.Activity
 import android.os.Bundle
 import android.view.MotionEvent
 import android.view.View
+import android.view.Window
 import android.widget.LinearLayout
 import androidx.test.ext.junit.runners.AndroidJUnit4
 import io.sentry.SentryOptions
@@ -14,6 +15,7 @@ import io.sentry.android.replay.phoneWindow
 import kotlin.test.Test
 import kotlin.test.assertEquals
 import kotlin.test.assertFalse
+import kotlin.test.assertSame
 import kotlin.test.assertTrue
 import org.junit.runner.RunWith
 import org.robolectric.Robolectric
@@ -37,17 +39,44 @@ class GestureRecorderTest {
   }
 
   @Test
-  fun `when new window added and window callback is already wrapped, does not wrap it again`() {
+  fun `does not double-wrap when root is added twice and another callback wraps on top`() {
     val activity = Robolectric.buildActivity(TestActivity::class.java).setup().get()
     val gestureRecorder = fixture.getSut()
 
-    activity.root.phoneWindow?.callback = SentryReplayGestureRecorder(fixture.options, null, null)
     gestureRecorder.onRootViewsChanged(activity.root, true)
+    val ourWrapper = activity.root.phoneWindow?.callback as SentryReplayGestureRecorder
 
-    assertFalse(
-      (activity.root.phoneWindow?.callback as SentryReplayGestureRecorder).delegate
-        is SentryReplayGestureRecorder
-    )
+    val outer = WrapperCallback(ourWrapper)
+    activity.root.phoneWindow?.callback = outer
+
+    gestureRecorder.onRootViewsChanged(activity.root, true)
+
+    assertSame(outer, activity.root.phoneWindow?.callback)
+  }
+
+  @Test
+  fun `when stopped with another wrapper on top, inerts the buried recorder`() {
+    var called = false
+    val activity = Robolectric.buildActivity(TestActivity::class.java).setup().get()
+    val gestureRecorder =
+      fixture.getSut(
+        touchRecorderCallback =
+          object : TouchRecorderCallback {
+            override fun onTouchEvent(event: MotionEvent) {
+              called = true
+            }
+          }
+      )
+
+    gestureRecorder.onRootViewsChanged(activity.root, true)
+    val ourWrapper = activity.root.phoneWindow?.callback as SentryReplayGestureRecorder
+    activity.root.phoneWindow?.callback = WrapperCallback(ourWrapper)
+
+    gestureRecorder.onRootViewsChanged(activity.root, false)
+
+    val motionEvent = MotionEvent.obtain(0, 0, MotionEvent.ACTION_DOWN, 0f, 0f, 0)
+    ourWrapper.dispatchTouchEvent(motionEvent)
+    assertFalse(called)
   }
 
   @Test
@@ -109,6 +138,9 @@ class GestureRecorderTest {
   }
 }
 
+private open class WrapperCallback(@JvmField val delegate: Window.Callback) :
+  Window.Callback by delegate
+
 private class TestActivity : Activity() {
   lateinit var root: View