RUM-2708: Refactor and split classes

features/dd-sdk-android-session-replay/src/main/kotlin/com/datadog/android/sessionreplay/SessionReplayRecorder.kt

@@ -32,14 +32,17 @@ import com.datadog.android.sessionreplay.internal.recorder.callback.OnWindowRefr
 import com.datadog.android.sessionreplay.internal.recorder.mapper.DecorViewMapper
 import com.datadog.android.sessionreplay.internal.recorder.mapper.MapperTypeWrapper
 import com.datadog.android.sessionreplay.internal.recorder.mapper.ViewWireframeMapper
+import com.datadog.android.sessionreplay.internal.recorder.resources.BitmapCachesManager
 import com.datadog.android.sessionreplay.internal.recorder.resources.BitmapPool
 import com.datadog.android.sessionreplay.internal.recorder.resources.DefaultImageWireframeHelper
 import com.datadog.android.sessionreplay.internal.recorder.resources.ImageTypeResolver
+import com.datadog.android.sessionreplay.internal.recorder.resources.MD5HashGenerator
+import com.datadog.android.sessionreplay.internal.recorder.resources.ResourceResolver
 import com.datadog.android.sessionreplay.internal.recorder.resources.ResourcesLRUCache
-import com.datadog.android.sessionreplay.internal.recorder.resources.ResourcesSerializer
 import com.datadog.android.sessionreplay.internal.recorder.resources.WebPImageCompression
 import com.datadog.android.sessionreplay.internal.storage.RecordWriter
 import com.datadog.android.sessionreplay.internal.storage.ResourcesWriter
+import com.datadog.android.sessionreplay.internal.utils.DrawableUtils
 import com.datadog.android.sessionreplay.internal.utils.RumContextProvider
 import com.datadog.android.sessionreplay.internal.utils.TimeProvider
 import com.datadog.android.sessionreplay.utils.ColorStringFormatter
@@ -122,20 +125,28 @@ internal class SessionReplayRecorder : OnWindowRefreshedCallback, Recorder {
             drawableToColorMapper
         )
 
-        val resourcesSerializer = ResourcesSerializer.Builder(
+        val bitmapCachesManager = BitmapCachesManager(
+            bitmapPool = BitmapPool(),
+            resourcesLRUCache = ResourcesLRUCache(),
+            logger = internalLogger
+        )
+
+        val resourceResolver = ResourceResolver(
             applicationId = applicationId,
             recordedDataQueueHandler = recordedDataQueueHandler,
-            bitmapPool = BitmapPool(),
-            resourcesLRUCache = ResourcesLRUCache()
-        ).build()
+            bitmapCachesManager = bitmapCachesManager,
+            drawableUtils = DrawableUtils(internalLogger, bitmapCachesManager),
+            logger = internalLogger,
+            md5HashGenerator = MD5HashGenerator(internalLogger),
+            webPImageCompression = WebPImageCompression(internalLogger)
+        )
 
         this.viewOnDrawInterceptor = ViewOnDrawInterceptor(
             recordedDataQueueHandler = recordedDataQueueHandler,
             SnapshotProducer(
                 DefaultImageWireframeHelper(
                     logger = internalLogger,
-                    resourcesSerializer = resourcesSerializer,
-                    imageCompression = WebPImageCompression(),
+                    resourceResolver = resourceResolver,
                     viewIdentifierResolver = viewIdentifierResolver,
                     viewUtilsInternal = ViewUtilsInternal(),
                     imageTypeResolver = ImageTypeResolver()

features/dd-sdk-android-session-replay/src/main/kotlin/com/datadog/android/sessionreplay/internal/recorder/resources/BitmapCachesManager.kt

@@ -0,0 +1,74 @@
+/*
+ * Unless explicitly stated otherwise all files in this repository are licensed under the Apache License Version 2.0.
+ * This product includes software developed at Datadog (https://www.datadoghq.com/).
+ * Copyright 2016-Present Datadog, Inc.
+ */
+
+package com.datadog.android.sessionreplay.internal.recorder.resources
+
+import android.content.ComponentCallbacks2
+import android.content.Context
+import android.graphics.Bitmap
+import android.graphics.drawable.Drawable
+import androidx.annotation.MainThread
+import com.datadog.android.api.InternalLogger
+
+internal class BitmapCachesManager(
+    private val resourcesLRUCache: Cache<Drawable, ByteArray>,
+    private val bitmapPool: BitmapPool,
+    private val logger: InternalLogger
+) {
+    private var isResourcesCacheRegisteredForCallbacks: Boolean = false
+    private var isBitmapPoolRegisteredForCallbacks: Boolean = false
+
+    @MainThread
+    internal fun registerCallbacks(applicationContext: Context) {
+        registerResourceLruCacheForCallbacks(applicationContext)
+        registerBitmapPoolForCallbacks(applicationContext)
+    }
+
+    @MainThread
+    private fun registerResourceLruCacheForCallbacks(applicationContext: Context) {
+        if (isResourcesCacheRegisteredForCallbacks) return
+
+        if (resourcesLRUCache is ComponentCallbacks2) {
+            applicationContext.registerComponentCallbacks(resourcesLRUCache)
+            isResourcesCacheRegisteredForCallbacks = true
+        } else {
+            logger.log(
+                level = InternalLogger.Level.ERROR,
+                target = InternalLogger.Target.MAINTAINER,
+                messageBuilder = { Cache.DOES_NOT_IMPLEMENT_COMPONENTCALLBACKS }
+            )
+        }
+    }
+
+    @MainThread
+    private fun registerBitmapPoolForCallbacks(applicationContext: Context) {
+        if (isBitmapPoolRegisteredForCallbacks) return
+
+        applicationContext.registerComponentCallbacks(bitmapPool)
+        isBitmapPoolRegisteredForCallbacks = true
+    }
+
+    internal fun putInResourceCache(drawable: Drawable, resourceId: String) {
+        resourcesLRUCache.put(drawable, resourceId.toByteArray(Charsets.UTF_8))
+    }
+
+    internal fun getFromResourceCache(drawable: Drawable): String? {
+        val resourceId = resourcesLRUCache.get(drawable) ?: return null
+        return String(resourceId, Charsets.UTF_8)
+    }
+
+    internal fun putInBitmapPool(bitmap: Bitmap) {
+        bitmapPool.put(bitmap)
+    }
+
+    internal fun getBitmapByProperties(
+        width: Int,
+        height: Int,
+        config: Bitmap.Config
+    ): Bitmap? {
+        return bitmapPool.getBitmapByProperties(width, height, config)
+    }
+}

features/dd-sdk-android-session-replay/src/main/kotlin/com/datadog/android/sessionreplay/internal/recorder/resources/DefaultImageWireframeHelper.kt

@@ -24,13 +24,12 @@ import com.datadog.android.sessionreplay.utils.ImageWireframeHelper
 import com.datadog.android.sessionreplay.utils.ViewIdentifierResolver
 import java.util.Locale
 
-// This should not have a callback but it should just create a placeholder for base64Serializer
-// The resourcesSerializer dependency should be removed from here
-// TODO: RUM-0000 Remove the resourcesSerializer dependency from here
+// This should not have a callback but it should just create a placeholder for resourceResolver
+// The resourceResolver dependency should be removed from here
+// TODO: RUM-0000 Remove the resourceResolver dependency from here
 internal class DefaultImageWireframeHelper(
     private val logger: InternalLogger,
-    private val resourcesSerializer: ResourcesSerializer,
-    private val imageCompression: ImageCompression,
+    private val resourceResolver: ResourceResolver,
     private val viewIdentifierResolver: ViewIdentifierResolver,
     private val viewUtilsInternal: ViewUtilsInternal,
     private val imageTypeResolver: ImageTypeResolver
@@ -83,7 +82,6 @@ internal class DefaultImageWireframeHelper(
             return null
         }
 
-        val mimeType = imageCompression.getMimeType()
         val density = displayMetrics.density
 
         // in case we suspect the image is PII, return a placeholder
@@ -94,31 +92,35 @@ internal class DefaultImageWireframeHelper(
         val drawableWidthDp = width.densityNormalized(density).toLong()
         val drawableHeightDp = height.densityNormalized(density).toLong()
 
-        val imageWireframe = MobileSegment.Wireframe.ImageWireframe(
-            id = id,
-            x,
-            y,
-            width = drawableWidthDp,
-            height = drawableHeightDp,
-            shapeStyle = shapeStyle,
-            border = border,
-            clip = clipping,
-            mimeType = mimeType,
-            isEmpty = true
-        )
+        val imageWireframe =
+            MobileSegment.Wireframe.ImageWireframe(
+                id = id,
+                x,
+                y,
+                width = drawableWidthDp,
+                height = drawableHeightDp,
+                shapeStyle = shapeStyle,
+                border = border,
+                clip = clipping,
+                isEmpty = true
+            )
 
         asyncJobStatusCallback.jobStarted()
 
-        resourcesSerializer.handleBitmap(
+        resourceResolver.resolveResourceId(
             resources = resources,
             applicationContext = applicationContext,
             displayMetrics = displayMetrics,
             drawable = drawableProperties.drawable,
             drawableWidth = width,
             drawableHeight = height,
-            imageWireframe = imageWireframe,
-            resourcesSerializerCallback = object : ResourcesSerializerCallback {
-                override fun onReady() {
+            resourceResolverCallback = object : ResourceResolverCallback {
+                override fun onSuccess(resourceId: String) {
+                    populateResourceIdInWireframe(resourceId, imageWireframe)
+                    asyncJobStatusCallback.jobFinished()
+                }
+
+                override fun onFailure() {
                     asyncJobStatusCallback.jobFinished()
                 }
             }
@@ -255,6 +257,14 @@ internal class DefaultImageWireframeHelper(
         }
     }
 
+    private fun populateResourceIdInWireframe(
+        resourceId: String,
+        wireframe: MobileSegment.Wireframe.ImageWireframe
+    ) {
+        wireframe.resourceId = resourceId
+        wireframe.isEmpty = false
+    }
+
     internal companion object {
 
         @VisibleForTesting

features/dd-sdk-android-session-replay/src/main/kotlin/com/datadog/android/sessionreplay/internal/recorder/resources/ImageCompression.kt

@@ -14,11 +14,6 @@ import java.io.ByteArrayOutputStream
  */
 internal interface ImageCompression {
 
-    /**
-     * Get the mimetype for the image format.
-     */
-    fun getMimeType(): String?
-
     /**
      * Compress the bitmap to a [ByteArrayOutputStream].
      */

features/dd-sdk-android-session-replay/src/main/kotlin/com/datadog/android/sessionreplay/internal/recorder/resources/MD5HashGenerator.kt

@@ -25,7 +25,7 @@ internal class MD5HashGenerator(
         } catch (e: NoSuchAlgorithmException) {
             logger.log(
                 InternalLogger.Level.ERROR,
-                InternalLogger.Target.USER,
+                listOf(InternalLogger.Target.MAINTAINER, InternalLogger.Target.TELEMETRY),
                 { MD5_HASH_GENERATION_ERROR },
                 e
             )

features/dd-sdk-android-session-replay/src/main/kotlin/com/datadog/android/sessionreplay/internal/recorder/resources/ResolveResourceCallback.kt

@@ -0,0 +1,12 @@
+/*
+ * Unless explicitly stated otherwise all files in this repository are licensed under the Apache License Version 2.0.
+ * This product includes software developed at Datadog (https://www.datadoghq.com/).
+ * Copyright 2016-Present Datadog, Inc.
+ */
+
+package com.datadog.android.sessionreplay.internal.recorder.resources
+
+internal interface ResolveResourceCallback {
+    fun onResolved(resourceId: String, resourceData: ByteArray)
+    fun onFailed()
+}

features/dd-sdk-android-session-replay/src/main/kotlin/com/datadog/android/sessionreplay/internal/recorder/resources/ResourceItemCreationHandler.kt

@@ -0,0 +1,34 @@
+/*
+ * Unless explicitly stated otherwise all files in this repository are licensed under the Apache License Version 2.0.
+ * This product includes software developed at Datadog (https://www.datadoghq.com/).
+ * Copyright 2016-Present Datadog, Inc.
+ */
+
+package com.datadog.android.sessionreplay.internal.recorder.resources
+
+import androidx.annotation.VisibleForTesting
+import com.datadog.android.sessionreplay.internal.async.DataQueueHandler
+import java.util.Collections
+
+internal class ResourceItemCreationHandler(
+    private val recordedDataQueueHandler: DataQueueHandler,
+    private val applicationId: String
+) {
+    // resource IDs previously sent in this session -
+    // optimization to avoid sending the same resource multiple times
+    // atm this set is unbounded but expected to use relatively little space (~80kb per 1k items)
+    @VisibleForTesting internal val resourceIdsSeen: MutableSet<String> =
+        Collections.synchronizedSet(HashSet<String>())
+
+    internal fun queueItem(resourceId: String, resourceData: ByteArray) {
+        if (!resourceIdsSeen.contains(resourceId)) {
+            resourceIdsSeen.add(resourceId)
+
+            recordedDataQueueHandler.addResourceItem(
+                identifier = resourceId,
+                resourceData = resourceData,
+                applicationId = applicationId
+            )
+        }
+    }
+}