Revert "Determine recording size based on active window (#4354)"

This reverts commit 307b057.

Author: romtsn

CHANGELOG.md

@@ -15,7 +15,6 @@
 - Session Replay: Fix crash on devices with the Unisoc/Spreadtrum T606 chipset ([#4477](https://github.com/getsentry/sentry-java/pull/4477))
 - Session Replay: Fix masking of non-styled `Text` Composables ([#4361](https://github.com/getsentry/sentry-java/pull/4361))
 - Session Replay: Fix masking read-only `TextField` Composables ([#4362](https://github.com/getsentry/sentry-java/pull/4362))
-- Correctly capture Dialogs and non full-sized windows ([#4354](https://github.com/getsentry/sentry-java/pull/4354))
 - Fix Session Replay masking for newer versions of Jetpack Compose (1.8+) ([#4485](https://github.com/getsentry/sentry-java/pull/4485))
 - Session Replay: Expand fix for crash on devices to all Unisoc/Spreadtrum chipsets ([#4510](https://github.com/getsentry/sentry-java/pull/4510))
 

sentry-android-replay/api/sentry-android-replay.api

@@ -34,11 +34,9 @@ public final class io/sentry/android/replay/ModifierExtensionsKt {
 }
 
 public abstract interface class io/sentry/android/replay/Recorder : java/io/Closeable {
-	public abstract fun onConfigurationChanged (Lio/sentry/android/replay/ScreenshotRecorderConfig;)V
 	public abstract fun pause ()V
-	public abstract fun reset ()V
 	public abstract fun resume ()V
-	public abstract fun start ()V
+	public abstract fun start (Lio/sentry/android/replay/ScreenshotRecorderConfig;)V
 	public abstract fun stop ()V
 }
 
@@ -59,24 +57,24 @@ public final class io/sentry/android/replay/ReplayCache$Companion {
 	public final fun makeReplayCacheDir (Lio/sentry/SentryOptions;Lio/sentry/protocol/SentryId;)Ljava/io/File;
 }
 
-public final class io/sentry/android/replay/ReplayIntegration : io/sentry/IConnectionStatusProvider$IConnectionStatusObserver, io/sentry/Integration, io/sentry/ReplayController, io/sentry/android/replay/ScreenshotRecorderCallback, io/sentry/android/replay/WindowCallback, io/sentry/android/replay/gestures/TouchRecorderCallback, io/sentry/transport/RateLimiter$IRateLimitObserver, java/io/Closeable {
+public final class io/sentry/android/replay/ReplayIntegration : android/content/ComponentCallbacks, io/sentry/IConnectionStatusProvider$IConnectionStatusObserver, io/sentry/Integration, io/sentry/ReplayController, io/sentry/android/replay/ScreenshotRecorderCallback, io/sentry/android/replay/gestures/TouchRecorderCallback, io/sentry/transport/RateLimiter$IRateLimitObserver, java/io/Closeable {
 	public static final field $stable I
 	public fun <init> (Landroid/content/Context;Lio/sentry/transport/ICurrentDateProvider;)V
-	public fun <init> (Landroid/content/Context;Lio/sentry/transport/ICurrentDateProvider;Lkotlin/jvm/functions/Function0;Lkotlin/jvm/functions/Function1;)V
-	public synthetic fun <init> (Landroid/content/Context;Lio/sentry/transport/ICurrentDateProvider;Lkotlin/jvm/functions/Function0;Lkotlin/jvm/functions/Function1;ILkotlin/jvm/internal/DefaultConstructorMarker;)V
+	public fun <init> (Landroid/content/Context;Lio/sentry/transport/ICurrentDateProvider;Lkotlin/jvm/functions/Function0;Lkotlin/jvm/functions/Function1;Lkotlin/jvm/functions/Function1;)V
+	public synthetic fun <init> (Landroid/content/Context;Lio/sentry/transport/ICurrentDateProvider;Lkotlin/jvm/functions/Function0;Lkotlin/jvm/functions/Function1;Lkotlin/jvm/functions/Function1;ILkotlin/jvm/internal/DefaultConstructorMarker;)V
 	public fun captureReplay (Ljava/lang/Boolean;)V
 	public fun close ()V
 	public fun getBreadcrumbConverter ()Lio/sentry/ReplayBreadcrumbConverter;
 	public final fun getReplayCacheDir ()Ljava/io/File;
 	public fun getReplayId ()Lio/sentry/protocol/SentryId;
 	public fun isRecording ()Z
-	public final fun onConfigurationChanged (Lio/sentry/android/replay/ScreenshotRecorderConfig;)V
+	public fun onConfigurationChanged (Landroid/content/res/Configuration;)V
 	public fun onConnectionStatusChanged (Lio/sentry/IConnectionStatusProvider$ConnectionStatus;)V
+	public fun onLowMemory ()V
 	public fun onRateLimitChanged (Lio/sentry/transport/RateLimiter;)V
 	public fun onScreenshotRecorded (Landroid/graphics/Bitmap;)V
 	public fun onScreenshotRecorded (Ljava/io/File;J)V
 	public fun onTouchEvent (Landroid/view/MotionEvent;)V
-	public fun onWindowSizeChanged (II)V
 	public fun pause ()V
 	public fun register (Lio/sentry/IHub;Lio/sentry/SentryOptions;)V
 	public fun resume ()V
@@ -114,7 +112,7 @@ public final class io/sentry/android/replay/ScreenshotRecorderConfig {
 }
 
 public final class io/sentry/android/replay/ScreenshotRecorderConfig$Companion {
-	public final fun fromSize (Landroid/content/Context;Lio/sentry/SentryReplayOptions;II)Lio/sentry/android/replay/ScreenshotRecorderConfig;
+	public final fun from (Landroid/content/Context;Lio/sentry/SentryReplayOptions;)Lio/sentry/android/replay/ScreenshotRecorderConfig;
 }
 
 public final class io/sentry/android/replay/SentryReplayModifiers {
@@ -135,10 +133,6 @@ public final class io/sentry/android/replay/ViewExtensionsKt {
 	public static final fun sentryReplayUnmask (Landroid/view/View;)V
 }
 
-public abstract interface class io/sentry/android/replay/WindowCallback {
-	public abstract fun onWindowSizeChanged (II)V
-}
-
 public final class io/sentry/android/replay/gestures/GestureRecorder : io/sentry/android/replay/OnRootViewsChangedListener {
 	public static final field $stable I
 	public fun <init> (Lio/sentry/SentryOptions;Lio/sentry/android/replay/gestures/TouchRecorderCallback;)V

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

@@ -8,15 +8,11 @@ interface Recorder : Closeable {
      * at which the screenshots should be taken, and the screenshots size/resolution, which can
      * change e.g. in the case of orientation change or window size change
      */
-    fun start()
-
-    fun onConfigurationChanged(config: ScreenshotRecorderConfig)
+    fun start(recorderConfig: ScreenshotRecorderConfig)
 
     fun resume()
 
     fun pause()
 
-    fun reset()
-
     fun stop()
 }

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

@@ -1,6 +1,8 @@
 package io.sentry.android.replay
 
+import android.content.ComponentCallbacks
 import android.content.Context
+import android.content.res.Configuration
 import android.graphics.Bitmap
 import android.os.Build
 import android.view.MotionEvent
@@ -57,33 +59,36 @@ public class ReplayIntegration(
     private val context: Context,
     private val dateProvider: ICurrentDateProvider,
     private val recorderProvider: (() -> Recorder)? = null,
+    private val recorderConfigProvider: ((configChanged: Boolean) -> ScreenshotRecorderConfig)? = null,
     private val replayCacheProvider: ((replayId: SentryId) -> ReplayCache)? = null
 ) : Integration,
     Closeable,
     ScreenshotRecorderCallback,
     TouchRecorderCallback,
     ReplayController,
+    ComponentCallbacks,
     IConnectionStatusObserver,
-    IRateLimitObserver,
-    WindowCallback {
+    IRateLimitObserver {
 
     // needed for the Java's call site
     constructor(context: Context, dateProvider: ICurrentDateProvider) : this(
         context.appContext(),
         dateProvider,
         null,
+        null,
         null
     )
 
     internal constructor(
         context: Context,
         dateProvider: ICurrentDateProvider,
         recorderProvider: (() -> Recorder)?,
+        recorderConfigProvider: ((configChanged: Boolean) -> ScreenshotRecorderConfig)?,
         replayCacheProvider: ((replayId: SentryId) -> ReplayCache)?,
         replayCaptureStrategyProvider: ((isFullSession: Boolean) -> CaptureStrategy)? = null,
         mainLooperHandler: MainLooperHandler? = null,
         gestureRecorderProvider: (() -> GestureRecorder)? = null
-    ) : this(context.appContext(), dateProvider, recorderProvider, replayCacheProvider) {
+    ) : this(context.appContext(), dateProvider, recorderProvider, recorderConfigProvider, replayCacheProvider) {
         this.replayCaptureStrategyProvider = replayCaptureStrategyProvider
         this.mainLooperHandler = mainLooperHandler ?: MainLooperHandler()
         this.gestureRecorderProvider = gestureRecorderProvider
@@ -125,12 +130,23 @@ public class ReplayIntegration(
         }
 
         this.hub = hub
-        recorder = recorderProvider?.invoke() ?: WindowRecorder(options, this, this, mainLooperHandler, replayExecutor)
+        recorder = recorderProvider?.invoke() ?: WindowRecorder(options, this, mainLooperHandler, replayExecutor)
         gestureRecorder = gestureRecorderProvider?.invoke() ?: GestureRecorder(options, this)
         isEnabled.set(true)
 
         options.connectionStatusProvider.addConnectionStatusObserver(this)
         hub.rateLimiter?.addRateLimitObserver(this)
+        if (options.sessionReplay.isTrackOrientationChange) {
+            try {
+                context.registerComponentCallbacks(this)
+            } catch (e: Throwable) {
+                options.logger.log(
+                    INFO,
+                    "ComponentCallbacks is not available, orientation changes won't be handled by Session replay",
+                    e
+                )
+            }
+        }
 
         addIntegrationToSdkVersion("Replay")
         SentryIntegrationPackageStorage.getInstance()
@@ -161,16 +177,17 @@ public class ReplayIntegration(
             return
         }
 
-        lifecycle.currentState = STARTED
+        val recorderConfig = recorderConfigProvider?.invoke(false) ?: ScreenshotRecorderConfig.from(context, options.sessionReplay)
         captureStrategy = replayCaptureStrategyProvider?.invoke(isFullSession) ?: if (isFullSession) {
             SessionCaptureStrategy(options, hub, dateProvider, replayExecutor, replayCacheProvider)
         } else {
             BufferCaptureStrategy(options, hub, dateProvider, random, replayExecutor, replayCacheProvider)
         }
-        recorder?.start()
-        captureStrategy?.start()
 
+        captureStrategy?.start(recorderConfig)
+        recorder?.start(recorderConfig)
         registerRootViewListeners()
+        lifecycle.currentState = STARTED
     }
 
     override fun resume() {
@@ -191,9 +208,9 @@ public class ReplayIntegration(
             return
         }
 
-        lifecycle.currentState = RESUMED
         captureStrategy?.resume()
         recorder?.resume()
+        lifecycle.currentState = RESUMED
     }
 
     @Synchronized
@@ -245,7 +262,6 @@ public class ReplayIntegration(
         }
 
         unregisterRootViewListeners()
-        recorder?.reset()
         recorder?.stop()
         gestureRecorder?.stop()
         captureStrategy?.stop()
@@ -277,7 +293,12 @@ public class ReplayIntegration(
 
         options.connectionStatusProvider.removeConnectionStatusObserver(this)
         hub?.rateLimiter?.removeRateLimitObserver(this)
-
+        if (options.sessionReplay.isTrackOrientationChange) {
+            try {
+                context.unregisterComponentCallbacks(this)
+            } catch (ignored: Throwable) {
+            }
+        }
         stop()
         recorder?.close()
         recorder = null
@@ -286,6 +307,24 @@ public class ReplayIntegration(
         lifecycle.currentState = CLOSED
     }
 
+    override fun onConfigurationChanged(newConfig: Configuration) {
+        if (!isEnabled.get() || !isRecording()) {
+            return
+        }
+
+        recorder?.stop()
+
+        // refresh config based on new device configuration
+        val recorderConfig = recorderConfigProvider?.invoke(true) ?: ScreenshotRecorderConfig.from(context, options.sessionReplay)
+        captureStrategy?.onConfigurationChanged(recorderConfig)
+
+        recorder?.start(recorderConfig)
+        // we have to restart recorder with a new config and pause immediately if the replay is paused
+        if (lifecycle.currentState == PAUSED) {
+            recorder?.pause()
+        }
+    }
+
     override fun onConnectionStatusChanged(status: ConnectionStatus) {
         if (captureStrategy !is SessionCaptureStrategy) {
             // we only want to stop recording when offline for session mode
@@ -313,6 +352,8 @@ public class ReplayIntegration(
         }
     }
 
+    override fun onLowMemory() = Unit
+
     override fun onTouchEvent(event: MotionEvent) {
         if (!isEnabled.get() || !lifecycle.isTouchRecordingAllowed()) {
             return
@@ -413,30 +454,6 @@ public class ReplayIntegration(
         }
     }
 
-    override fun onWindowSizeChanged(width: Int, height: Int) {
-        if (!isEnabled.get() || !isRecording()) {
-            return
-        }
-        if (options.sessionReplay.isTrackConfiguration) {
-            val recorderConfig =
-                ScreenshotRecorderConfig.fromSize(context, options.sessionReplay, width, height)
-            onConfigurationChanged(recorderConfig)
-        }
-    }
-
-    public fun onConfigurationChanged(config: ScreenshotRecorderConfig) {
-        if (!isEnabled.get() || !isRecording()) {
-            return
-        }
-        captureStrategy?.onConfigurationChanged(config)
-        recorder?.onConfigurationChanged(config)
-
-        // we have to restart recorder with a new config and pause immediately if the replay is paused
-        if (lifecycle.currentState == PAUSED) {
-            recorder?.pause()
-        }
-    }
-
     private class PreviousReplayHint : Backfillable {
         override fun shouldEnrich(): Boolean = false
     }

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

@@ -7,11 +7,15 @@ import android.graphics.Canvas
 import android.graphics.Color
 import android.graphics.Matrix
 import android.graphics.Paint
+import android.graphics.Point
 import android.graphics.Rect
 import android.graphics.RectF
+import android.os.Build.VERSION
+import android.os.Build.VERSION_CODES
 import android.view.PixelCopy
 import android.view.View
 import android.view.ViewTreeObserver
+import android.view.WindowManager
 import io.sentry.SentryLevel.DEBUG
 import io.sentry.SentryLevel.INFO
 import io.sentry.SentryLevel.WARNING
@@ -174,9 +178,6 @@ internal class ScreenshotRecorder(
     }
 
     override fun onDraw() {
-        if (!isCapturing.get()) {
-            return
-        }
         val root = rootView?.get()
         if (root == null || root.width <= 0 || root.height <= 0 || !root.isShown) {
             options.logger.log(DEBUG, "Root view is invalid, not capturing screenshot")
@@ -289,26 +290,35 @@ public data class ScreenshotRecorderConfig(
             }
         }
 
-        fun fromSize(
+        fun from(
             context: Context,
-            sessionReplay: SentryReplayOptions,
-            windowWidth: Int,
-            windowHeight: Int
+            sessionReplay: SentryReplayOptions
         ): ScreenshotRecorderConfig {
+            // PixelCopy takes screenshots including system bars, so we have to get the real size here
+            val wm = context.getSystemService(Context.WINDOW_SERVICE) as WindowManager
+            val screenBounds = if (VERSION.SDK_INT >= VERSION_CODES.R) {
+                wm.currentWindowMetrics.bounds
+            } else {
+                val screenBounds = Point()
+                @Suppress("DEPRECATION")
+                wm.defaultDisplay.getRealSize(screenBounds)
+                Rect(0, 0, screenBounds.x, screenBounds.y)
+            }
+
             // use the baseline density of 1x (mdpi)
             val (height, width) =
-                ((windowHeight / context.resources.displayMetrics.density) * sessionReplay.quality.sizeScale)
+                ((screenBounds.height() / context.resources.displayMetrics.density) * sessionReplay.quality.sizeScale)
                     .roundToInt()
                     .adjustToBlockSize() to
-                    ((windowWidth / context.resources.displayMetrics.density) * sessionReplay.quality.sizeScale)
+                    ((screenBounds.width() / context.resources.displayMetrics.density) * sessionReplay.quality.sizeScale)
                         .roundToInt()
                         .adjustToBlockSize()
 
             return ScreenshotRecorderConfig(
                 recordingWidth = width,
                 recordingHeight = height,
-                scaleFactorX = width.toFloat() / windowWidth,
-                scaleFactorY = height.toFloat() / windowHeight,
+                scaleFactorX = width.toFloat() / screenBounds.width(),
+                scaleFactorY = height.toFloat() / screenBounds.height(),
                 frameRate = sessionReplay.frameRate,
                 bitRate = sessionReplay.quality.bitRate
             )
@@ -337,10 +347,3 @@ public interface ScreenshotRecorderCallback {
      */
     fun onScreenshotRecorded(screenshot: File, frameTimestamp: Long)
 }
-
-/**
- * A callback to be invoked when once current window size is determined or changes
- */
-public interface WindowCallback {
-    public fun onWindowSizeChanged(width: Int, height: Int)
-}