WIP

Author: romtsn

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

@@ -15,4 +15,6 @@ interface Recorder : Closeable {
     fun pause()
 
     fun stop()
+
+    fun setReplayStrategy(isSession: Boolean) = Unit
 }

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

@@ -109,7 +109,7 @@ public class ReplayIntegration(
         }
 
         this.hub = hub
-        recorder = recorderProvider?.invoke() ?: WindowRecorder(options, this, mainLooperHandler)
+        recorder = recorderProvider?.invoke() ?: WindowRecorder(options, this, mainLooperHandler, hub.rateLimiter)
         gestureRecorder = gestureRecorderProvider?.invoke() ?: GestureRecorder(options, this)
         isEnabled.set(true)
 
@@ -157,6 +157,10 @@ public class ReplayIntegration(
 
         captureStrategy?.start(recorderConfig)
         recorder?.start(recorderConfig)
+        // TODO: move this here
+        // TODO: add 2 listeners here: OnRateLimit(category, applied) and OnConnectionChanged(connected)
+        // TODO: when they are fired, call either recorder?.resume() + strategy.resume() or recorder?.pause() + strategy.pause()
+        recorder?.setReplayStrategy(captureStrategy is SessionCaptureStrategy)
         registerRootViewListeners()
     }
 
@@ -184,6 +188,7 @@ public class ReplayIntegration(
             captureStrategy?.segmentTimestamp = newTimestamp
         })
         captureStrategy = captureStrategy?.convert()
+        recorder?.setReplayStrategy(captureStrategy is SessionCaptureStrategy)
     }
 
     override fun getReplayId(): SentryId = captureStrategy?.currentReplayId ?: SentryId.EMPTY_ID

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

@@ -17,6 +17,9 @@ import android.view.PixelCopy
 import android.view.View
 import android.view.ViewTreeObserver
 import android.view.WindowManager
+import io.sentry.DataCategory.All
+import io.sentry.DataCategory.Replay
+import io.sentry.IConnectionStatusProvider.ConnectionStatus.DISCONNECTED
 import io.sentry.SentryLevel.DEBUG
 import io.sentry.SentryLevel.INFO
 import io.sentry.SentryLevel.WARNING
@@ -30,12 +33,12 @@ import io.sentry.android.replay.util.traverse
 import io.sentry.android.replay.viewhierarchy.ViewHierarchyNode
 import io.sentry.android.replay.viewhierarchy.ViewHierarchyNode.ImageViewHierarchyNode
 import io.sentry.android.replay.viewhierarchy.ViewHierarchyNode.TextViewHierarchyNode
+import io.sentry.transport.RateLimiter
 import java.io.File
 import java.lang.ref.WeakReference
 import java.util.concurrent.Executors
 import java.util.concurrent.ThreadFactory
 import java.util.concurrent.atomic.AtomicBoolean
-import java.util.concurrent.atomic.AtomicReference
 import kotlin.LazyThreadSafetyMode.NONE
 import kotlin.math.roundToInt
 
@@ -44,14 +47,14 @@ internal class ScreenshotRecorder(
     val config: ScreenshotRecorderConfig,
     val options: SentryOptions,
     val mainLooperHandler: MainLooperHandler,
-    private val screenshotRecorderCallback: ScreenshotRecorderCallback?
+    private val screenshotRecorderCallback: ScreenshotRecorderCallback?,
+    private val rateLimiter: RateLimiter?
 ) : ViewTreeObserver.OnDrawListener {
 
     private val recorder by lazy {
         Executors.newSingleThreadScheduledExecutor(RecorderExecutorServiceThreadFactory())
     }
     private var rootView: WeakReference<View>? = null
-    private val pendingViewHierarchy = AtomicReference<ViewHierarchyNode>()
     private val maskingPaint by lazy(NONE) { Paint() }
     private val singlePixelBitmap: Bitmap by lazy(NONE) {
         Bitmap.createBitmap(
@@ -69,13 +72,24 @@ internal class ScreenshotRecorder(
     private val contentChanged = AtomicBoolean(false)
     private val isCapturing = AtomicBoolean(true)
     private var lastScreenshot: Bitmap? = null
+    internal val isSession = AtomicBoolean(false)
 
     fun capture() {
         if (!isCapturing.get()) {
             options.logger.log(DEBUG, "ScreenshotRecorder is paused, not capturing screenshot")
             return
         }
 
+        if (isSession.get() && options.connectionStatusProvider.connectionStatus == DISCONNECTED) {
+            options.logger.log(DEBUG, "Skipping screenshot recording, no internet connection")
+            return
+        }
+
+        if (isSession.get() && (rateLimiter?.isActiveForCategory(All) == true || rateLimiter?.isActiveForCategory(Replay) == true)) {
+            options.logger.log(DEBUG, "Skipping screenshot recording, rate limit is active")
+            return
+        }
+
         if (!contentChanged.get() && lastScreenshot != null && !lastScreenshot!!.isRecycled) {
             options.logger.log(DEBUG, "Content hasn't changed, repeating last known frame")
 
@@ -230,7 +244,6 @@ internal class ScreenshotRecorder(
         unbind(rootView?.get())
         rootView?.clear()
         lastScreenshot?.recycle()
-        pendingViewHierarchy.set(null)
         isCapturing.set(false)
         recorder.gracefullyShutdown(options)
     }

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

@@ -6,6 +6,7 @@ import io.sentry.SentryOptions
 import io.sentry.android.replay.util.MainLooperHandler
 import io.sentry.android.replay.util.gracefullyShutdown
 import io.sentry.android.replay.util.scheduleAtFixedRateSafely
+import io.sentry.transport.RateLimiter
 import java.lang.ref.WeakReference
 import java.util.concurrent.Executors
 import java.util.concurrent.ScheduledFuture
@@ -17,7 +18,8 @@ import java.util.concurrent.atomic.AtomicBoolean
 internal class WindowRecorder(
     private val options: SentryOptions,
     private val screenshotRecorderCallback: ScreenshotRecorderCallback? = null,
-    private val mainLooperHandler: MainLooperHandler
+    private val mainLooperHandler: MainLooperHandler,
+    private val rateLimiter: RateLimiter?
 ) : Recorder, OnRootViewsChangedListener {
 
     internal companion object {
@@ -52,7 +54,7 @@ internal class WindowRecorder(
             return
         }
 
-        recorder = ScreenshotRecorder(recorderConfig, options, mainLooperHandler, screenshotRecorderCallback)
+        recorder = ScreenshotRecorder(recorderConfig, options, mainLooperHandler, screenshotRecorderCallback, rateLimiter)
         capturingTask = capturer.scheduleAtFixedRateSafely(
             options,
             "$TAG.capture",
@@ -86,6 +88,10 @@ internal class WindowRecorder(
         capturer.gracefullyShutdown(options)
     }
 
+    override fun setReplayStrategy(isSession: Boolean) {
+        recorder?.isSession?.set(isSession)
+    }
+
     private class RecorderExecutorServiceThreadFactory : ThreadFactory {
         private var cnt = 0
         override fun newThread(r: Runnable): Thread {

sentry-android-replay/src/main/java/io/sentry/android/replay/capture/SessionCaptureStrategy.kt

@@ -75,17 +75,6 @@ internal class SessionCaptureStrategy(
     }
 
     override fun onScreenshotRecorded(bitmap: Bitmap?, store: ReplayCache.(frameTimestamp: Long) -> Unit) {
-        if (options.connectionStatusProvider.connectionStatus == DISCONNECTED) {
-            options.logger.log(DEBUG, "Skipping screenshot recording, no internet connection")
-            bitmap?.recycle()
-            return
-        }
-        val rateLimiter = hub?.rateLimiter
-        if (rateLimiter?.isActiveForCategory(All) == true || rateLimiter?.isActiveForCategory(Replay) == true) {
-            options.logger.log(DEBUG, "Skipping screenshot recording, rate limit is active")
-            bitmap?.recycle()
-            return
-        }
         // have to do it before submitting, otherwise if the queue is busy, the timestamp won't be
         // reflecting the exact time of when it was captured
         val frameTimestamp = dateProvider.currentTimeMillis

sentry-android-replay/src/test/java/io/sentry/android/replay/capture/SessionCaptureStrategyTest.kt

@@ -372,18 +372,4 @@ class SessionCaptureStrategyTest {
                 "the current replay cache folder is not being deleted."
         )
     }
-
-    @Test
-    fun `when rate limited does not capture screenshots`() {
-        val strategy = fixture.getSut()
-
-        whenever(fixture.hub.rateLimiter?.isActiveForCategory(eq(DataCategory.Replay))).thenReturn(true)
-
-        strategy.start(fixture.recorderConfig)
-        var called = false
-        strategy.onScreenshotRecorded(mock<Bitmap>()) {
-            called = true
-        }
-        assertFalse(called)
-    }
 }