Merge 82680fb into b3b7813

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

@@ -21,6 +21,13 @@ public final class io/sentry/android/replay/GeneratedVideo {
 	public fun toString ()Ljava/lang/String;
 }
 
+public abstract interface class io/sentry/android/replay/Recorder : java/io/Closeable {
+	public abstract fun pause ()V
+	public abstract fun resume ()V
+	public abstract fun start (Lio/sentry/android/replay/ScreenshotRecorderConfig;)V
+	public abstract fun stop ()V
+}
+
 public final class io/sentry/android/replay/ReplayCache : java/io/Closeable {
 	public fun <init> (Lio/sentry/SentryOptions;Lio/sentry/protocol/SentryId;Lio/sentry/android/replay/ScreenshotRecorderConfig;)V
 	public final fun addFrame (Ljava/io/File;J)V
@@ -32,11 +39,15 @@ public final class io/sentry/android/replay/ReplayCache : java/io/Closeable {
 
 public final class io/sentry/android/replay/ReplayIntegration : android/content/ComponentCallbacks, io/sentry/Integration, io/sentry/ReplayController, io/sentry/android/replay/ScreenshotRecorderCallback, java/io/Closeable {
 	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;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 close ()V
+	public fun getReplayId ()Lio/sentry/protocol/SentryId;
 	public fun isRecording ()Z
 	public fun onConfigurationChanged (Landroid/content/res/Configuration;)V
 	public fun onLowMemory ()V
 	public fun onScreenshotRecorded (Landroid/graphics/Bitmap;)V
+	public fun onScreenshotRecorded (Ljava/io/File;J)V
 	public fun pause ()V
 	public fun register (Lio/sentry/IHub;Lio/sentry/SentryOptions;)V
 	public fun resume ()V
@@ -47,6 +58,7 @@ public final class io/sentry/android/replay/ReplayIntegration : android/content/
 
 public abstract interface class io/sentry/android/replay/ScreenshotRecorderCallback {
 	public abstract fun onScreenshotRecorded (Landroid/graphics/Bitmap;)V
+	public abstract fun onScreenshotRecorded (Ljava/io/File;J)V
 }
 
 public final class io/sentry/android/replay/ScreenshotRecorderConfig {

sentry-android-replay/build.gradle.kts

@@ -75,6 +75,7 @@ dependencies {
     testImplementation(Config.TestLibs.androidxJunit)
     testImplementation(Config.TestLibs.mockitoKotlin)
     testImplementation(Config.TestLibs.mockitoInline)
+    testImplementation(Config.TestLibs.awaitility)
 }
 
 tasks.withType<Detekt> {

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

@@ -0,0 +1,18 @@
+package io.sentry.android.replay
+
+import java.io.Closeable
+
+interface Recorder : Closeable {
+    /**
+     * @param recorderConfig a [ScreenshotRecorderConfig] that can be used to determine frame rate
+     * 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(recorderConfig: ScreenshotRecorderConfig)
+
+    fun resume()
+
+    fun pause()
+
+    fun stop()
+}

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

@@ -30,14 +30,14 @@ public class ReplayCache internal constructor(
     private val options: SentryOptions,
     private val replayId: SentryId,
     private val recorderConfig: ScreenshotRecorderConfig,
-    private val encoderCreator: (videoFile: File, height: Int, width: Int) -> SimpleVideoEncoder
+    private val encoderProvider: (videoFile: File, height: Int, width: Int) -> SimpleVideoEncoder
 ) : Closeable {
 
     public constructor(
         options: SentryOptions,
         replayId: SentryId,
         recorderConfig: ScreenshotRecorderConfig
-    ) : this(options, replayId, recorderConfig, encoderCreator = { videoFile, height, width ->
+    ) : this(options, replayId, recorderConfig, encoderProvider = { videoFile, height, width ->
         SimpleVideoEncoder(
             options,
             MuxerConfig(
@@ -145,7 +145,7 @@ public class ReplayCache internal constructor(
         }
 
         // TODO: reuse instance of encoder and just change file path to create a different muxer
-        encoder = synchronized(encoderLock) { encoderCreator(videoFile, height, width) }
+        encoder = synchronized(encoderLock) { encoderProvider(videoFile, height, width) }
 
         val step = 1000 / recorderConfig.frameRate.toLong()
         var frameCount = 0

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

@@ -22,17 +22,30 @@ import io.sentry.protocol.SentryId
 import io.sentry.transport.ICurrentDateProvider
 import io.sentry.util.IntegrationUtils.addIntegrationToSdkVersion
 import java.io.Closeable
+import java.io.File
 import java.security.SecureRandom
 import java.util.concurrent.atomic.AtomicBoolean
 
-class ReplayIntegration(
+public class ReplayIntegration(
     private val context: Context,
-    private val dateProvider: ICurrentDateProvider
+    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, ReplayController, ComponentCallbacks {
 
+    // needed for the Java's call site
+    constructor(context: Context, dateProvider: ICurrentDateProvider) : this(
+        context,
+        dateProvider,
+        null,
+        null,
+        null
+    )
+
     private lateinit var options: SentryOptions
     private var hub: IHub? = null
-    private var recorder: WindowRecorder? = null
+    private var recorder: Recorder? = null
     private val random by lazy { SecureRandom() }
 
     // TODO: probably not everything has to be thread-safe here
@@ -58,7 +71,7 @@ class ReplayIntegration(
         }
 
         this.hub = hub
-        recorder = WindowRecorder(options, this)
+        recorder = recorderProvider?.invoke() ?: WindowRecorder(options, this)
         isEnabled.set(true)
 
         try {
@@ -94,15 +107,15 @@ class ReplayIntegration(
             return
         }
 
-        recorderConfig = ScreenshotRecorderConfig.from(context, options.experimental.sessionReplay)
+        recorderConfig = recorderConfigProvider?.invoke(false) ?: ScreenshotRecorderConfig.from(context, options.experimental.sessionReplay)
         captureStrategy = if (isFullSession) {
-            SessionCaptureStrategy(options, hub, dateProvider, recorderConfig)
+            SessionCaptureStrategy(options, hub, dateProvider, recorderConfig, replayCacheProvider = replayCacheProvider)
         } else {
-            BufferCaptureStrategy(options, hub, dateProvider, recorderConfig, random)
+            BufferCaptureStrategy(options, hub, dateProvider, recorderConfig, random, replayCacheProvider)
         }
 
         captureStrategy?.start()
-        recorder?.startRecording(recorderConfig)
+        recorder?.start(recorderConfig)
     }
 
     override fun resume() {
@@ -133,6 +146,8 @@ class ReplayIntegration(
         captureStrategy = captureStrategy?.convert()
     }
 
+    override fun getReplayId(): SentryId = captureStrategy?.currentReplayId?.get() ?: SentryId.EMPTY_ID
+
     override fun pause() {
         if (!isEnabled.get() || !isRecording.get()) {
             return
@@ -147,14 +162,22 @@ class ReplayIntegration(
             return
         }
 
-        recorder?.stopRecording()
+        recorder?.stop()
         captureStrategy?.stop()
         isRecording.set(false)
         captureStrategy = null
     }
 
     override fun onScreenshotRecorded(bitmap: Bitmap) {
-        captureStrategy?.onScreenshotRecorded(bitmap)
+        captureStrategy?.onScreenshotRecorded { frameTimeStamp ->
+            addFrame(bitmap, frameTimeStamp)
+        }
+    }
+
+    override fun onScreenshotRecorded(screenshot: File, frameTimestamp: Long) {
+        captureStrategy?.onScreenshotRecorded { _ ->
+            addFrame(screenshot, frameTimestamp)
+        }
     }
 
     override fun close() {
@@ -169,20 +192,22 @@ class ReplayIntegration(
         stop()
         captureStrategy?.close()
         captureStrategy = null
+        recorder?.close()
+        recorder = null
     }
 
     override fun onConfigurationChanged(newConfig: Configuration) {
         if (!isEnabled.get() || !isRecording.get()) {
             return
         }
 
-        recorder?.stopRecording()
+        recorder?.stop()
 
         // refresh config based on new device configuration
-        recorderConfig = ScreenshotRecorderConfig.from(context, options.experimental.sessionReplay)
+        recorderConfig = recorderConfigProvider?.invoke(true) ?: ScreenshotRecorderConfig.from(context, options.experimental.sessionReplay)
         captureStrategy?.onConfigurationChanged(recorderConfig)
 
-        recorder?.startRecording(recorderConfig)
+        recorder?.start(recorderConfig)
     }
 
     override fun onLowMemory() = Unit

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

@@ -26,6 +26,7 @@ import io.sentry.SentryLevel.WARNING
 import io.sentry.SentryOptions
 import io.sentry.SentryReplayOptions
 import io.sentry.android.replay.viewhierarchy.ViewHierarchyNode
+import java.io.File
 import java.lang.ref.WeakReference
 import java.util.concurrent.atomic.AtomicBoolean
 import java.util.concurrent.atomic.AtomicReference
@@ -35,7 +36,7 @@ import kotlin.math.roundToInt
 internal class ScreenshotRecorder(
     val config: ScreenshotRecorderConfig,
     val options: SentryOptions,
-    private val screenshotRecorderCallback: ScreenshotRecorderCallback
+    private val screenshotRecorderCallback: ScreenshotRecorderCallback?
 ) : ViewTreeObserver.OnDrawListener {
 
     private var rootView: WeakReference<View>? = null
@@ -68,7 +69,7 @@ internal class ScreenshotRecorder(
             options.logger.log(DEBUG, "Content hasn't changed, repeating last known frame")
 
             lastScreenshot?.let {
-                screenshotRecorderCallback.onScreenshotRecorded(
+                screenshotRecorderCallback?.onScreenshotRecorded(
                     it.copy(ARGB_8888, false)
                 )
             }
@@ -140,7 +141,7 @@ internal class ScreenshotRecorder(
                         }
 
                         val screenshot = scaledBitmap.copy(ARGB_8888, false)
-                        screenshotRecorderCallback.onScreenshotRecorded(screenshot)
+                        screenshotRecorderCallback?.onScreenshotRecorded(screenshot)
                         lastScreenshot?.recycle()
                         lastScreenshot = screenshot
                         contentChanged.set(false)
@@ -294,6 +295,24 @@ public data class ScreenshotRecorderConfig(
     }
 }
 
-interface ScreenshotRecorderCallback {
+/**
+ * A callback to be invoked when a new screenshot available. Normally, only one of the
+ * [onScreenshotRecorded] method overloads should be called by a single recorder, however, it will
+ * still work of both are used at the same time.
+ */
+public interface ScreenshotRecorderCallback {
+    /**
+     * Called whenever a new frame screenshot is available.
+     *
+     * @param bitmap a screenshot taken in the form of [android.graphics.Bitmap]
+     */
     fun onScreenshotRecorded(bitmap: Bitmap)
+
+    /**
+     * Called whenever a new frame screenshot is available.
+     *
+     * @param screenshot file containing the frame screenshot
+     * @param frameTimestamp the timestamp when the frame screenshot was taken
+     */
+    fun onScreenshotRecorded(screenshot: File, frameTimestamp: Long)
 }

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

@@ -5,7 +5,6 @@ import android.view.View
 import io.sentry.SentryOptions
 import io.sentry.android.replay.util.gracefullyShutdown
 import io.sentry.android.replay.util.scheduleAtFixedRateSafely
-import java.io.Closeable
 import java.lang.ref.WeakReference
 import java.util.concurrent.Executors
 import java.util.concurrent.ScheduledFuture
@@ -17,8 +16,8 @@ import kotlin.LazyThreadSafetyMode.NONE
 @TargetApi(26)
 internal class WindowRecorder(
     private val options: SentryOptions,
-    private val screenshotRecorderCallback: ScreenshotRecorderCallback
-) : Closeable {
+    private val screenshotRecorderCallback: ScreenshotRecorderCallback? = null
+) : Recorder {
 
     internal companion object {
         private const val TAG = "WindowRecorder"
@@ -51,7 +50,7 @@ internal class WindowRecorder(
         }
     }
 
-    fun startRecording(recorderConfig: ScreenshotRecorderConfig) {
+    override fun start(recorderConfig: ScreenshotRecorderConfig) {
         if (isRecording.getAndSet(true)) {
             return
         }
@@ -69,10 +68,14 @@ internal class WindowRecorder(
         }
     }
 
-    fun resume() = recorder?.resume()
-    fun pause() = recorder?.pause()
+    override fun resume() {
+        recorder?.resume()
+    }
+    override fun pause() {
+        recorder?.pause()
+    }
 
-    fun stopRecording() {
+    override fun stop() {
         rootViewsSpy.listeners -= onRootViewsChangedListener
         rootViews.forEach { recorder?.unbind(it.get()) }
         recorder?.close()
@@ -93,7 +96,7 @@ internal class WindowRecorder(
     }
 
     override fun close() {
-        stopRecording()
+        stop()
         capturer.gracefullyShutdown(options)
     }
 }

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

@@ -33,7 +33,8 @@ internal abstract class BaseCaptureStrategy(
     private val hub: IHub?,
     private val dateProvider: ICurrentDateProvider,
     protected var recorderConfig: ScreenshotRecorderConfig,
-    executor: ScheduledExecutorService? = null
+    executor: ScheduledExecutorService? = null,
+    private val replayCacheProvider: ((replayId: SentryId) -> ReplayCache)? = null
 ) : CaptureStrategy {
 
     internal companion object {
@@ -72,7 +73,7 @@ internal abstract class BaseCaptureStrategy(
             }
         }
 
-        cache = ReplayCache(options, currentReplayId.get(), recorderConfig)
+        cache = replayCacheProvider?.invoke(replayId) ?: ReplayCache(options, replayId, recorderConfig)
 
         // TODO: replace it with dateProvider.currentTimeMillis to also test it
         segmentTimestamp.set(DateUtils.getCurrentDateTime())

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

@@ -1,6 +1,5 @@
 package io.sentry.android.replay.capture
 
-import android.graphics.Bitmap
 import io.sentry.DateUtils
 import io.sentry.Hint
 import io.sentry.IHub
@@ -9,9 +8,11 @@ import io.sentry.SentryLevel.ERROR
 import io.sentry.SentryLevel.INFO
 import io.sentry.SentryOptions
 import io.sentry.SentryReplayEvent.ReplayType.BUFFER
+import io.sentry.android.replay.ReplayCache
 import io.sentry.android.replay.ScreenshotRecorderConfig
 import io.sentry.android.replay.util.sample
 import io.sentry.android.replay.util.submitSafely
+import io.sentry.protocol.SentryId
 import io.sentry.transport.ICurrentDateProvider
 import io.sentry.util.FileUtils
 import java.io.File
@@ -22,8 +23,9 @@ internal class BufferCaptureStrategy(
     private val hub: IHub?,
     private val dateProvider: ICurrentDateProvider,
     recorderConfig: ScreenshotRecorderConfig,
-    private val random: SecureRandom
-) : BaseCaptureStrategy(options, hub, dateProvider, recorderConfig) {
+    private val random: SecureRandom,
+    replayCacheProvider: ((replayId: SentryId) -> ReplayCache)? = null
+) : BaseCaptureStrategy(options, hub, dateProvider, recorderConfig, replayCacheProvider = replayCacheProvider) {
 
     private val bufferedSegments = mutableListOf<ReplaySegment.Created>()
 
@@ -91,12 +93,12 @@ internal class BufferCaptureStrategy(
         }
     }
 
-    override fun onScreenshotRecorded(bitmap: Bitmap) {
+    override fun onScreenshotRecorded(store: ReplayCache.(frameTimestamp: Long) -> Unit) {
         // 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
         replayExecutor.submitSafely(options, "$TAG.add_frame") {
-            cache?.addFrame(bitmap, frameTimestamp)
+            cache?.store(frameTimestamp)
 
             val now = dateProvider.currentTimeMillis
             val bufferLimit = now - options.experimental.sessionReplay.errorReplayDuration