fix(replay): Detect window size changes on activities with configChanges

Activities that declare android:configChanges="orientation|screenSize|..."
(e.g. Unity, fullscreen video players) keep the same root view across
rotations, so onRootViewsChanged never fires and determineWindowSize was
never re-invoked. The recording bitmap stayed at the pre-rotation size,
the rotated window content rendered into wrong-dim bitmaps, and SurfaceView
captures composited at stale coordinates.

Attach an OnLayoutChangeListener to each tracked root so a same-root
resize triggers determineWindowSize. The existing size-comparison guard
(both width and height must differ) keeps IME/adjustResize relayouts
from causing spurious reconfigurations.

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

Author: romtsn

sentry-android-replay/src/main/java/io/sentry/android/replay/WindowRecorder.kt

@@ -17,6 +17,7 @@ import io.sentry.android.replay.util.hasSize
 import io.sentry.android.replay.util.removeOnPreDrawListenerSafe
 import io.sentry.util.AutoClosableReentrantLock
 import java.lang.ref.WeakReference
+import java.util.WeakHashMap
 import java.util.concurrent.ScheduledExecutorService
 import java.util.concurrent.atomic.AtomicBoolean
 
@@ -33,6 +34,7 @@ internal class WindowRecorder(
   private val isRecording = AtomicBoolean(false)
   private val rootViews = ArrayList<WeakReference<View>>()
   private var lastKnownWindowSize: Point = Point()
+  private val rootLayoutListeners = WeakHashMap<View, View.OnLayoutChangeListener>()
   private val rootViewsLock = AutoClosableReentrantLock()
   private val capturerLock = AutoClosableReentrantLock()
   private val backgroundProcessingHandlerLock = AutoClosableReentrantLock()
@@ -124,21 +126,59 @@ internal class WindowRecorder(
         rootViews.add(WeakReference(root))
         capturer?.recorder?.bind(root)
         determineWindowSize(root)
+        attachLayoutListener(root)
       } else {
+        detachLayoutListener(root)
         capturer?.recorder?.unbind(root)
         rootViews.removeAll { it.get() == root }
 
         val newRoot = rootViews.lastOrNull()?.get()
         if (newRoot != null && root != newRoot) {
           capturer?.recorder?.bind(newRoot)
           determineWindowSize(newRoot)
+          attachLayoutListener(newRoot)
         } else {
           Unit // synchronized block wants us to return something lol
         }
       }
     }
   }
 
+  /**
+   * Activities that handle their own configuration changes (e.g. Unity, video players via
+   * `android:configChanges="orientation|screenSize|..."`) keep the same root view across rotations,
+   * so [onRootViewsChanged] never fires and [determineWindowSize] would never re-detect the new
+   * dimensions. Watch the root for layout-time size changes to catch these cases.
+   */
+  private fun attachLayoutListener(root: View) {
+    if (rootLayoutListeners.containsKey(root)) return
+    val listener =
+      View.OnLayoutChangeListener {
+        v,
+        left,
+        top,
+        right,
+        bottom,
+        oldLeft,
+        oldTop,
+        oldRight,
+        oldBottom ->
+        val width = right - left
+        val height = bottom - top
+        val oldWidth = oldRight - oldLeft
+        val oldHeight = oldBottom - oldTop
+        if (width != oldWidth || height != oldHeight) {
+          determineWindowSize(v)
+        }
+      }
+    rootLayoutListeners[root] = listener
+    root.addOnLayoutChangeListener(listener)
+  }
+
+  private fun detachLayoutListener(root: View) {
+    rootLayoutListeners.remove(root)?.let { root.removeOnLayoutChangeListener(it) }
+  }
+
   fun determineWindowSize(root: View) {
     if (root.hasSize()) {
       if (root.width != lastKnownWindowSize.x && root.height != lastKnownWindowSize.y) {
@@ -222,7 +262,13 @@ internal class WindowRecorder(
   override fun reset() {
     lastKnownWindowSize.set(0, 0)
     rootViewsLock.acquire().use {
-      rootViews.forEach { capturer?.recorder?.unbind(it.get()) }
+      rootViews.forEach {
+        val root = it.get()
+        if (root != null) {
+          detachLayoutListener(root)
+          capturer?.recorder?.unbind(root)
+        }
+      }
       rootViews.clear()
     }
   }