@datadog/mobile-react-native-session-replay 2.4.4-alpha.0 → 2.5.0-alpha.0

package/android/build.gradle

@@ -134,6 +134,14 @@ android {
       } else {
         java.srcDirs += ['src/oldarch/kotlin']
       }
+
+      if (reactNativeMinorVersion >= 76) {
+        java.srcDirs += ['src/rn76/kotlin']
+      } else if (reactNativeMinorVersion >= 75) {
+        java.srcDirs += ['src/rn75/kotlin']
+      } else {
+        java.srcDirs += ['src/rnlegacy/kotlin']
+      }
     }
     test {
       java.srcDir("src/test/kotlin")
@@ -149,6 +157,7 @@ android {
   buildTypes {
     release {
       minifyEnabled false
+      consumerProguardFiles 'consumer-proguard-rules.pro'
     }
   }
   lintOptions {
@@ -188,7 +197,8 @@ dependencies {
     api "com.facebook.react:react-android:$reactNativeVersion"
   }
   implementation "org.jetbrains.kotlin:kotlin-stdlib:$kotlin_version"
-  implementation "com.datadoghq:dd-sdk-android-session-replay:2.14.0"
+  implementation "com.datadoghq:dd-sdk-android-session-replay:2.16.1"
+  implementation "com.datadoghq:dd-sdk-android-internal:2.16.1"
   implementation project(path: ':datadog_mobile-react-native')
 
   testImplementation "org.junit.platform:junit-platform-launcher:1.6.2"

package/android/consumer-proguard-rules.pro

@@ -0,0 +1,3 @@
+-keepclassmembers class com.facebook.drawee.drawable.RoundedBitmapDrawable {
+    private android.graphics.Bitmap mBitmap;
+}

package/android/src/main/kotlin/com/datadog/reactnative/sessionreplay/DdSessionReplayImplementation.kt

@@ -28,14 +28,25 @@ class DdSessionReplayImplementation(
     /**
      * Enable session replay and start recording session.
      * @param replaySampleRate The sample rate applied for session replay.
-     * @param defaultPrivacyLevel The privacy level used for replay.
      * @param customEndpoint Custom server url for sending replay data.
+     * @param privacySettings Defines the way visual elements should be masked.
+     * @param customEndpoint Custom server url for sending replay data.
+     * @param startRecordingImmediately Whether the recording should start immediately when the feature is enabled.
      */
-    fun enable(replaySampleRate: Double, defaultPrivacyLevel: String, customEndpoint: String, promise: Promise) {
+    fun enable(
+        replaySampleRate: Double,
+        customEndpoint: String,
+        privacySettings: SessionReplayPrivacySettings,
+        startRecordingImmediately: Boolean,
+        promise: Promise
+    ) {
         val sdkCore = DatadogSDKWrapperStorage.getSdkCore() as FeatureSdkCore
         val logger = sdkCore.internalLogger
         val configuration = SessionReplayConfiguration.Builder(replaySampleRate.toFloat())
-            .configurePrivacy(defaultPrivacyLevel)
+            .startRecordingImmediately(startRecordingImmediately)
+            .setImagePrivacy(privacySettings.imagePrivacyLevel)
+            .setTouchPrivacy(privacySettings.touchPrivacyLevel)
+            .setTextAndInputPrivacy(privacySettings.textAndInputPrivacyLevel)
             .addExtensionSupport(ReactNativeSessionReplayExtensionSupport(reactContext, logger))
 
         if (customEndpoint != "") {
@@ -46,30 +57,24 @@ class DdSessionReplayImplementation(
         promise.resolve(null)
     }
 
-    @Deprecated("Privacy should be set with separate properties mapped to " +
-            "`setImagePrivacy`, `setTouchPrivacy`, `setTextAndInputPrivacy`, but they are" +
-            " currently unavailable.")
-    private fun SessionReplayConfiguration.Builder.configurePrivacy(
-        defaultPrivacyLevel: String
-    ): SessionReplayConfiguration.Builder {
-        when (defaultPrivacyLevel.lowercase(Locale.US)) {
-            "mask" -> {
-                this.setTextAndInputPrivacy(TextAndInputPrivacy.MASK_ALL)
-                this.setImagePrivacy(ImagePrivacy.MASK_ALL)
-                this.setTouchPrivacy(TouchPrivacy.HIDE)
-            }
-            "mask_user_input" -> {
-                this.setTextAndInputPrivacy(TextAndInputPrivacy.MASK_ALL_INPUTS)
-                this.setImagePrivacy(ImagePrivacy.MASK_NONE)
-                this.setTouchPrivacy(TouchPrivacy.HIDE)
-            }
-            "allow" -> {
-                this.setTextAndInputPrivacy(TextAndInputPrivacy.MASK_SENSITIVE_INPUTS)
-                this.setImagePrivacy(ImagePrivacy.MASK_NONE)
-                this.setTouchPrivacy(TouchPrivacy.SHOW)
-            }
-        }
-        return this
+    /**
+     * Manually start recording the current session.
+     */
+    fun startRecording(promise: Promise) {
+        sessionReplayProvider().startRecording(
+            DatadogSDKWrapperStorage.getSdkCore() as FeatureSdkCore
+        )
+        promise.resolve(null)
+    }
+
+    /**
+     * Manually stop recording the current session.
+     */
+    fun stopRecording(promise: Promise) {
+        sessionReplayProvider().stopRecording(
+            DatadogSDKWrapperStorage.getSdkCore() as FeatureSdkCore
+        )
+        promise.resolve(null)
     }
 
     companion object {

package/android/src/main/kotlin/com/datadog/reactnative/sessionreplay/ReactNativeSessionReplayExtensionSupport.kt

@@ -11,11 +11,14 @@ import com.datadog.android.api.InternalLogger
 import com.datadog.android.sessionreplay.ExtensionSupport
 import com.datadog.android.sessionreplay.MapperTypeWrapper
 import com.datadog.android.sessionreplay.recorder.OptionSelectorDetector
+import com.datadog.android.sessionreplay.utils.DrawableToColorMapper
 import com.datadog.reactnative.sessionreplay.mappers.ReactEditTextMapper
+import com.datadog.reactnative.sessionreplay.mappers.ReactNativeImageViewMapper
 import com.datadog.reactnative.sessionreplay.mappers.ReactTextMapper
 import com.datadog.reactnative.sessionreplay.mappers.ReactViewGroupMapper
 import com.facebook.react.bridge.ReactContext
 import com.facebook.react.uimanager.UIManagerModule
+import com.facebook.react.views.image.ReactImageView
 import com.facebook.react.views.text.ReactTextView
 import com.facebook.react.views.textinput.ReactEditText
 import com.facebook.react.views.view.ReactViewGroup
@@ -24,21 +27,21 @@ internal class ReactNativeSessionReplayExtensionSupport(
     private val reactContext: ReactContext,
     private val logger: InternalLogger
 ) : ExtensionSupport {
+    override fun name(): String {
+        return ReactNativeSessionReplayExtensionSupport::class.java.simpleName
+    }
 
     override fun getCustomViewMappers(): List<MapperTypeWrapper<*>> {
         val uiManagerModule = getUiManagerModule()
 
         return listOf(
+            MapperTypeWrapper(ReactImageView::class.java, ReactNativeImageViewMapper()),
             MapperTypeWrapper(ReactViewGroup::class.java, ReactViewGroupMapper()),
             MapperTypeWrapper(ReactTextView::class.java, ReactTextMapper(reactContext, uiManagerModule)),
             MapperTypeWrapper(ReactEditText::class.java, ReactEditTextMapper(reactContext, uiManagerModule)),
         )
     }
 
-    override fun getOptionSelectorDetectors(): List<OptionSelectorDetector> {
-        return listOf()
-    }
-
     @VisibleForTesting
     internal fun getUiManagerModule(): UIManagerModule? {
         return try {
@@ -54,6 +57,14 @@ internal class ReactNativeSessionReplayExtensionSupport(
         }
     }
 
+    override fun getOptionSelectorDetectors(): List<OptionSelectorDetector> {
+        return listOf()
+    }
+
+    override fun getCustomDrawableMapper(): List<DrawableToColorMapper> {
+        return emptyList()
+    }
+
     internal companion object {
         internal const val RESOLVE_UIMANAGERMODULE_ERROR = "Unable to resolve UIManagerModule"
     }

package/android/src/main/kotlin/com/datadog/reactnative/sessionreplay/ReactTextPropertiesResolver.kt

@@ -6,28 +6,26 @@
 
 package com.datadog.reactnative.sessionreplay
 
+import ReactViewBackgroundDrawableUtils
 import android.view.Gravity
 import android.widget.TextView
 import androidx.annotation.VisibleForTesting
+import com.datadog.android.internal.utils.densityNormalized
 import com.datadog.android.sessionreplay.model.MobileSegment
-import com.datadog.reactnative.sessionreplay.extensions.convertToDensityNormalized
 import com.datadog.reactnative.sessionreplay.utils.DrawableUtils
-import com.datadog.reactnative.sessionreplay.utils.ReactViewBackgroundDrawableUtils
 import com.datadog.reactnative.sessionreplay.utils.ReflectionUtils
 import com.datadog.reactnative.sessionreplay.utils.formatAsRgba
 import com.facebook.react.bridge.ReactContext
 import com.facebook.react.uimanager.UIManagerModule
 import com.facebook.react.views.text.TextAttributes
-import com.facebook.react.views.view.ReactViewBackgroundDrawable
 import java.util.Locale
 
 internal class ReactTextPropertiesResolver(
     private val reactContext: ReactContext,
     private val uiManagerModule: UIManagerModule,
     private val reflectionUtils: ReflectionUtils = ReflectionUtils(),
-    private val reactViewBackgroundDrawableUtils: ReactViewBackgroundDrawableUtils =
-        ReactViewBackgroundDrawableUtils(),
-    private val drawableUtils: DrawableUtils = DrawableUtils()
+    private val drawableUtils: DrawableUtils =
+        ReactViewBackgroundDrawableUtils()
 ): TextPropertiesResolver {
     override fun addReactNativeProperties(
         originalWireframe: MobileSegment.Wireframe.TextWireframe,
@@ -94,14 +92,14 @@ internal class ReactTextPropertiesResolver(
         view: TextView,
         pixelDensity: Float,
     ): Pair<MobileSegment.ShapeStyle?, MobileSegment.ShapeBorder?>? {
-        val backgroundDrawable: ReactViewBackgroundDrawable =
-            drawableUtils.getReactBackgroundFromDrawable(view.background) ?: return null
+        val backgroundDrawable = drawableUtils
+            .getReactBackgroundFromDrawable(view.background) ?: return null
 
         // view.alpha is the value of the opacity prop on the js side
         val opacity = view.alpha
 
         val (shapeStyle, border) =
-            reactViewBackgroundDrawableUtils
+            drawableUtils
                 .resolveShapeAndBorder(backgroundDrawable, opacity, pixelDensity)
 
         return shapeStyle to border
@@ -136,7 +134,7 @@ internal class ReactTextPropertiesResolver(
         val fontFamily = getFontFamily(shadowNodeWrapper)
             ?: textWireframe.textStyle.family
         val fontSize = getFontSize(shadowNodeWrapper)
-            ?.convertToDensityNormalized(pixelsDensity)
+            ?.densityNormalized(pixelsDensity)
             ?: textWireframe.textStyle.size
         val fontColor = getTextColor(shadowNodeWrapper)
             ?: textWireframe.textStyle.color

package/android/src/main/kotlin/com/datadog/reactnative/sessionreplay/SessionReplayPrivacySettings.kt

@@ -0,0 +1,90 @@
+/*
+ * 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.reactnative.sessionreplay
+
+import android.util.Log
+import com.datadog.android.sessionreplay.ImagePrivacy
+import com.datadog.android.sessionreplay.TextAndInputPrivacy
+import com.datadog.android.sessionreplay.TouchPrivacy
+
+/**
+ * A utility class to store Session Replay privacy settings, and convert them from string to
+ * enum values.
+ *
+ * @param imagePrivacyLevel Defines the way images should be masked.
+ * @param touchPrivacyLevel Defines the way user touches should be masked.
+ * @param textAndInputPrivacyLevel Defines the way text and input should be masked.
+ */
+class SessionReplayPrivacySettings(
+    imagePrivacyLevel: String,
+    touchPrivacyLevel: String,
+    textAndInputPrivacyLevel: String
+){
+    /**
+     * Defines the way images should be masked.
+     */
+    val imagePrivacyLevel = getImagePrivacy(imagePrivacyLevel)
+
+    /**
+     * Defines the way user touches should be masked.
+     */
+    val touchPrivacyLevel = getTouchPrivacy(touchPrivacyLevel)
+
+    /**
+     * Defines the way text and input should be masked.
+     */
+    val textAndInputPrivacyLevel = getTextAndInputPrivacy(textAndInputPrivacyLevel)
+
+    companion object {
+        internal fun getImagePrivacy(imagePrivacyLevel: String): ImagePrivacy {
+            return when (imagePrivacyLevel) {
+                "MASK_NON_BUNDLED_ONLY" -> ImagePrivacy.MASK_LARGE_ONLY
+                "MASK_ALL" -> ImagePrivacy.MASK_ALL
+                "MASK_NONE" -> ImagePrivacy.MASK_NONE
+                else -> {
+                    Log.w(
+                        SessionReplayPrivacySettings::class.java.canonicalName,
+                        "Unknown Session Replay Image Privacy Level given: $imagePrivacyLevel, " +
+                                "using ${ImagePrivacy.MASK_ALL} as default"
+                    )
+                    ImagePrivacy.MASK_ALL
+                }
+            }
+        }
+
+        internal fun getTouchPrivacy(touchPrivacyLevel: String): TouchPrivacy {
+            return when (touchPrivacyLevel) {
+                "SHOW" -> TouchPrivacy.SHOW
+                "HIDE" -> TouchPrivacy.HIDE
+                else -> {
+                    Log.w(
+                        SessionReplayPrivacySettings::class.java.canonicalName,
+                        "Unknown Session Replay Touch Privacy Level given: $touchPrivacyLevel, " +
+                                "using ${TouchPrivacy.HIDE} as default"
+                    )
+                    TouchPrivacy.HIDE
+                }
+            }
+        }
+
+        internal fun getTextAndInputPrivacy(textAndInputPrivacyLevel: String): TextAndInputPrivacy {
+            return when (textAndInputPrivacyLevel) {
+                "MASK_SENSITIVE_INPUTS" -> TextAndInputPrivacy.MASK_SENSITIVE_INPUTS
+                "MASK_ALL_INPUTS" -> TextAndInputPrivacy.MASK_ALL_INPUTS
+                "MASK_ALL" -> TextAndInputPrivacy.MASK_ALL
+                else -> {
+                    Log.w(
+                        SessionReplayPrivacySettings::class.java.canonicalName,
+                        "Unknown Session Replay Text And Input Privacy Level given: $textAndInputPrivacyLevel, " +
+                                "using ${TextAndInputPrivacy.MASK_ALL} as default"
+                    )
+                    TextAndInputPrivacy.MASK_ALL
+                }
+            }
+        }
+    }
+}

package/android/src/main/kotlin/com/datadog/reactnative/sessionreplay/SessionReplaySDKWrapper.kt

@@ -24,4 +24,18 @@ internal class SessionReplaySDKWrapper : SessionReplayWrapper {
             sdkCore,
         )
     }
+
+    /**
+     * Manually start recording the current session.
+     */
+    override fun startRecording(sdkCore: SdkCore) {
+        SessionReplay.startRecording(sdkCore)
+    }
+
+    /**
+     * Manually stop recording the current session.
+     */
+    override fun stopRecording(sdkCore: SdkCore) {
+        SessionReplay.stopRecording(sdkCore)
+    }
 }

package/android/src/main/kotlin/com/datadog/reactnative/sessionreplay/SessionReplayWrapper.kt

@@ -21,4 +21,14 @@ interface SessionReplayWrapper {
         sessionReplayConfiguration: SessionReplayConfiguration,
         sdkCore: SdkCore
     )
+
+    /**
+     * Manually start recording the current session.
+     */
+    fun startRecording(sdkCore: SdkCore)
+
+    /**
+     * Manually stop recording the current session.
+     */
+    fun stopRecording(sdkCore: SdkCore)
 }

package/android/src/main/kotlin/com/datadog/reactnative/sessionreplay/extensions/ReactDrawablesExt.kt

@@ -0,0 +1,190 @@
+/*
+ * 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.reactnative.sessionreplay.extensions
+
+import android.content.res.Resources
+import android.graphics.Bitmap
+import android.graphics.Bitmap.Config
+import android.graphics.Canvas
+import android.graphics.drawable.BitmapDrawable
+import android.graphics.drawable.Drawable
+import android.graphics.drawable.ShapeDrawable
+import android.graphics.drawable.VectorDrawable
+import android.widget.ImageView
+import androidx.appcompat.graphics.drawable.DrawerArrowDrawable
+import com.facebook.drawee.drawable.ArrayDrawable
+import com.facebook.drawee.drawable.ForwardingDrawable
+import com.facebook.drawee.drawable.RoundedBitmapDrawable
+import com.facebook.drawee.drawable.ScaleTypeDrawable
+import com.facebook.drawee.drawable.ScalingUtils
+
+internal fun ScaleTypeDrawable.imageViewScaleType(): ImageView.ScaleType? {
+    return when (scaleType) {
+        ScalingUtils.ScaleType.CENTER -> ImageView.ScaleType.CENTER
+        ScalingUtils.ScaleType.CENTER_CROP -> ImageView.ScaleType.CENTER_CROP
+        ScalingUtils.ScaleType.CENTER_INSIDE -> ImageView.ScaleType.CENTER_INSIDE
+        ScalingUtils.ScaleType.FIT_CENTER -> ImageView.ScaleType.FIT_CENTER
+        ScalingUtils.ScaleType.FIT_START -> ImageView.ScaleType.FIT_START
+        ScalingUtils.ScaleType.FIT_END -> ImageView.ScaleType.FIT_END
+        ScalingUtils.ScaleType.FIT_XY -> ImageView.ScaleType.FIT_XY
+        else -> null
+    }
+}
+
+internal fun ArrayDrawable.getScaleTypeDrawable(): ScaleTypeDrawable? {
+    for (i in 0 until numberOfLayers) {
+        val drawable = getDrawableOrNull(i)
+        if (drawable is ScaleTypeDrawable) return drawable
+    }
+
+    return null
+}
+
+internal fun ArrayDrawable.getDrawableOrNull(index: Int): Drawable? {
+    return try {
+        getDrawable(index)
+    } catch (_: IllegalArgumentException) {
+        null
+    }
+}
+
+internal fun ForwardingDrawable.tryToExtractBitmap(resources: Resources): Bitmap? {
+    val forwardedDrawable = drawable
+    return if (forwardedDrawable != null) {
+        forwardedDrawable.tryToExtractBitmap(resources)
+    } else {
+       toBitmapOrNull(
+            intrinsicWidth,
+            intrinsicHeight,
+            Config.ARGB_8888
+        )
+    }
+}
+
+internal fun RoundedBitmapDrawable.tryToExtractBitmap(): Bitmap? {
+    val privateBitmap = try {
+        val field = RoundedBitmapDrawable::class.java.getDeclaredField("mBitmap")
+        field.isAccessible = true
+        field.get(this) as? Bitmap
+    } catch (_: NoSuchFieldException) {
+        null
+    } catch (_: IllegalAccessException) {
+        null
+    } catch (_: Exception) {
+        null
+    }
+
+    return privateBitmap ?: toBitmapOrNull(
+        intrinsicWidth,
+        intrinsicHeight,
+        Config.ARGB_8888
+    )
+}
+
+internal fun BitmapDrawable.tryToExtractBitmap(resources: Resources): Bitmap? {
+    if (bitmap != null) {
+        return bitmap
+    }
+
+    if (constantState != null) {
+        val copy = constantState?.newDrawable(resources)
+        return (copy as? BitmapDrawable)?.bitmap ?: copy?.toBitmapOrNull(
+            intrinsicWidth,
+            intrinsicHeight,
+            Config.ARGB_8888
+        )
+    }
+
+    return null
+}
+
+internal fun ArrayDrawable.tryToExtractBitmap(resources: Resources): Bitmap? {
+    var width = 0
+    var height = 0
+    for (index in 0 until numberOfLayers) {
+        val drawable = getDrawableOrNull(index) ?: continue
+
+        if (drawable is ScaleTypeDrawable) {
+            return drawable.tryToExtractBitmap(resources)
+        }
+
+        if (drawable.intrinsicWidth * drawable.intrinsicHeight > width * height) {
+            width = drawable.intrinsicWidth
+            height = drawable.intrinsicHeight
+        }
+    }
+
+    return if (width > 0 && height > 0)
+        toBitmapOrNull(width, height, Config.ARGB_8888)
+    else
+        null
+}
+
+internal fun Drawable.tryToExtractBitmap(
+    resources: Resources
+): Bitmap? {
+    when (this) {
+        is ArrayDrawable -> {
+            return tryToExtractBitmap(resources)
+        }
+        is ForwardingDrawable -> {
+            return tryToExtractBitmap(resources)
+        }
+        is RoundedBitmapDrawable -> {
+            return tryToExtractBitmap()
+        }
+        is BitmapDrawable -> {
+            return tryToExtractBitmap(resources)
+        }
+        is VectorDrawable, is ShapeDrawable, is DrawerArrowDrawable -> {
+            return toBitmapOrNull(
+                intrinsicWidth,
+                intrinsicHeight,
+                Config.ARGB_8888
+            )
+        }
+        else -> return null
+    }
+}
+
+internal fun Drawable.toBitmapOrNull(
+    width: Int = intrinsicWidth,
+    height: Int = intrinsicHeight,
+    config: Config? = null
+): Bitmap? {
+    if (this is BitmapDrawable && bitmap == null) {
+        return null
+    }
+    return toBitmap(width, height, config)
+}
+
+internal fun Drawable.toBitmap(
+    width: Int = intrinsicWidth,
+    height: Int = intrinsicHeight,
+    config: Config? = null
+): Bitmap {
+    if (this is BitmapDrawable) {
+        if (bitmap == null) {
+            return Bitmap.createBitmap(width, height, config ?: Config.ARGB_8888)
+        }
+        if (config == null || bitmap.config == config) {
+            // Fast-path to return original. Bitmap.createScaledBitmap will do this check, but it
+            // involves allocation and two jumps into native code so we perform the check ourselves.
+            if (width == bitmap.width && height == bitmap.height) {
+                return bitmap
+            }
+            return Bitmap.createScaledBitmap(bitmap, width, height, true)
+        }
+    }
+
+    val bitmap = Bitmap.createBitmap(width, height, config ?: Config.ARGB_8888)
+    setBounds(0, 0, width, height)
+    draw(Canvas(bitmap))
+
+    setBounds(bounds.left, bounds.top, bounds.right, bounds.bottom)
+    return bitmap
+}