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

package/android/src/rn76/kotlin/com/datadog/reactnative/sessionreplay/utils/ReactViewBackgroundDrawableUtils.kt

@@ -0,0 +1,101 @@
+/*
+ * 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.
+ */
+import android.graphics.drawable.Drawable
+import android.graphics.drawable.InsetDrawable
+import android.graphics.drawable.LayerDrawable
+import com.datadog.android.internal.utils.densityNormalized
+import com.datadog.android.sessionreplay.model.MobileSegment
+import com.datadog.reactnative.sessionreplay.extensions.getRadius
+import com.datadog.reactnative.sessionreplay.utils.DrawableUtils
+import com.datadog.reactnative.sessionreplay.utils.formatAsRgba
+import com.facebook.react.common.annotations.UnstableReactNativeAPI
+import com.facebook.react.uimanager.Spacing
+import com.facebook.react.uimanager.drawable.CSSBackgroundDrawable
+
+internal class ReactViewBackgroundDrawableUtils : DrawableUtils() {
+    @OptIn(UnstableReactNativeAPI::class)
+    override fun resolveShapeAndBorder(
+        drawable: Drawable,
+        opacity: Float,
+        pixelDensity: Float
+    ): Pair<MobileSegment.ShapeStyle?, MobileSegment.ShapeBorder?> {
+        if (drawable !is CSSBackgroundDrawable) {
+            return null to null
+        }
+
+        val borderProps = resolveBorder(drawable, pixelDensity)
+        val backgroundColor = getBackgroundColor(drawable)
+        val colorHexString = if (backgroundColor != null) {
+            formatAsRgba(backgroundColor)
+        } else {
+            return null to borderProps
+        }
+
+        return MobileSegment.ShapeStyle(
+            colorHexString,
+            opacity,
+            getBorderRadius(drawable)
+        ) to borderProps
+    }
+
+    @OptIn(UnstableReactNativeAPI::class)
+    override fun getReactBackgroundFromDrawable(drawable: Drawable?): Drawable? {
+        if (drawable is CSSBackgroundDrawable) {
+            return drawable
+        }
+
+        if (drawable is InsetDrawable) {
+            return getReactBackgroundFromDrawable(drawable.drawable)
+        }
+
+        if (drawable is LayerDrawable) {
+            for (layerNumber in 0 until drawable.numberOfLayers) {
+                val layer = drawable.getDrawable(layerNumber)
+                if (layer is CSSBackgroundDrawable) {
+                    return layer
+                }
+            }
+        }
+
+        return null
+    }
+
+    @OptIn(UnstableReactNativeAPI::class)
+    private fun getBorderRadius(drawable: CSSBackgroundDrawable): Float {
+        val width = drawable.intrinsicWidth.toFloat()
+        val height = drawable.intrinsicHeight.toFloat()
+        return drawable.borderRadius.uniform?.getRadius(width, height) ?: 0f
+    }
+
+    @OptIn(UnstableReactNativeAPI::class)
+    private fun getBackgroundColor(
+        backgroundDrawable: CSSBackgroundDrawable
+    ): Int? {
+        return reflectionUtils.getDeclaredField(
+            backgroundDrawable,
+            COLOR_FIELD_NAME
+        ) as Int?
+    }
+
+    @OptIn(UnstableReactNativeAPI::class)
+    private fun resolveBorder(
+        backgroundDrawable: CSSBackgroundDrawable,
+        pixelDensity: Float
+    ): MobileSegment.ShapeBorder {
+        val borderWidth =
+            backgroundDrawable.fullBorderWidth.toLong().densityNormalized(pixelDensity)
+        val borderColor = formatAsRgba(backgroundDrawable.getBorderColor(Spacing.ALL))
+
+        return MobileSegment.ShapeBorder(
+            color = borderColor,
+            width = borderWidth
+        )
+    }
+
+    private companion object {
+        private const val COLOR_FIELD_NAME = "mColor"
+    }
+}

package/android/src/rnlegacy/kotlin/com.datadog.reactnative.sessionreplay/utils/ReactViewBackgroundDrawableUtils.kt

@@ -0,0 +1,88 @@
+import android.graphics.drawable.Drawable
+import android.graphics.drawable.InsetDrawable
+import android.graphics.drawable.LayerDrawable
+import com.datadog.android.internal.utils.densityNormalized
+import com.datadog.android.sessionreplay.model.MobileSegment
+import com.datadog.reactnative.sessionreplay.utils.DrawableUtils
+import com.datadog.reactnative.sessionreplay.utils.formatAsRgba
+import com.facebook.react.uimanager.Spacing
+import com.facebook.react.views.view.ReactViewBackgroundDrawable
+
+internal class ReactViewBackgroundDrawableUtils() : DrawableUtils() {
+    override fun resolveShapeAndBorder(
+        drawable: Drawable,
+        opacity: Float,
+        pixelDensity: Float
+    ): Pair<MobileSegment.ShapeStyle?, MobileSegment.ShapeBorder?> {
+        if (drawable !is ReactViewBackgroundDrawable) {
+            return null to null
+        }
+
+        val borderProps = resolveBorder(drawable, pixelDensity)
+        val cornerRadius = drawable
+            .fullBorderRadius
+            .toLong()
+            .densityNormalized(pixelDensity)
+
+        val backgroundColor = getBackgroundColor(drawable)
+        val colorHexString = if (backgroundColor != null) {
+            formatAsRgba(backgroundColor)
+        } else {
+            return null to borderProps
+        }
+
+        return MobileSegment.ShapeStyle(
+            colorHexString,
+            opacity,
+            cornerRadius
+        ) to borderProps
+    }
+
+    override fun getReactBackgroundFromDrawable(drawable: Drawable?): Drawable? {
+        if (drawable is ReactViewBackgroundDrawable) {
+            return drawable
+        }
+
+        if (drawable is InsetDrawable) {
+            return getReactBackgroundFromDrawable(drawable.drawable)
+        }
+
+        if (drawable is LayerDrawable) {
+            for (layerNumber in 0 until drawable.numberOfLayers) {
+                val layer = drawable.getDrawable(layerNumber)
+                if (layer is ReactViewBackgroundDrawable) {
+                    return layer
+                }
+            }
+        }
+
+        return null
+    }
+
+    private fun resolveBorder(
+        backgroundDrawable: ReactViewBackgroundDrawable,
+        pixelDensity: Float
+    ): MobileSegment.ShapeBorder {
+        val borderWidth =
+            backgroundDrawable.fullBorderWidth.toLong().densityNormalized(pixelDensity)
+        val borderColor = formatAsRgba(backgroundDrawable.getBorderColor(Spacing.ALL))
+
+        return MobileSegment.ShapeBorder(
+            color = borderColor,
+            width = borderWidth
+        )
+    }
+
+    private fun getBackgroundColor(
+        backgroundDrawable: ReactViewBackgroundDrawable
+    ): Int? {
+        return reflectionUtils.getDeclaredField(
+            backgroundDrawable,
+            COLOR_FIELD_NAME
+        ) as Int?
+    }
+
+    private companion object {
+        private const val COLOR_FIELD_NAME = "mColor"
+    }
+}

package/android/src/test/kotlin/com/datadog/reactnative/sessionreplay/DdSessionReplayImplementationTest.kt

@@ -16,10 +16,10 @@ import com.facebook.react.bridge.NativeModule
 import com.facebook.react.bridge.Promise
 import com.facebook.react.bridge.ReactContext
 import com.facebook.react.uimanager.UIManagerModule
+import fr.xgouchet.elmyr.annotation.BoolForgery
 import fr.xgouchet.elmyr.annotation.DoubleForgery
 import fr.xgouchet.elmyr.annotation.StringForgery
 import fr.xgouchet.elmyr.junit5.ForgeExtension
-import java.util.Locale
 import org.junit.jupiter.api.AfterEach
 import org.junit.jupiter.api.BeforeEach
 import org.junit.jupiter.api.Test
@@ -56,6 +56,23 @@ internal class DdSessionReplayImplementationTest {
     @Mock
     lateinit var mockUiManagerModule: UIManagerModule
 
+    private val imagePrivacyMap = mapOf(
+        "MASK_ALL" to ImagePrivacy.MASK_ALL,
+        "MASK_NON_BUNDLED_ONLY" to ImagePrivacy.MASK_LARGE_ONLY,
+        "MASK_NONE" to ImagePrivacy.MASK_NONE
+    )
+
+    private val touchPrivacyMap = mapOf(
+        "SHOW" to TouchPrivacy.SHOW,
+        "HIDE" to TouchPrivacy.HIDE
+    )
+
+    private val inputPrivacyMap = mapOf(
+        "MASK_ALL" to TextAndInputPrivacy.MASK_ALL,
+        "MASK_ALL_INPUTS" to TextAndInputPrivacy.MASK_ALL_INPUTS,
+        "MASK_SENSITIVE_INPUTS" to TextAndInputPrivacy.MASK_SENSITIVE_INPUTS
+    )
+
     @BeforeEach
     fun `set up`() {
         whenever(mockReactContext.getNativeModule(any<Class<NativeModule>>()))
@@ -70,33 +87,32 @@ internal class DdSessionReplayImplementationTest {
     }
 
     @Test
-    fun `M enable session replay W privacy = ALLOW`(
-        @DoubleForgery(min = 0.0, max = 100.0) replaySampleRate: Double,
-        @StringForgery(regex = ".+") customEndpoint: String
-    ) {
-        testSessionReplayEnable("ALLOW", replaySampleRate, customEndpoint)
-    }
-
-    @Test
-    fun `M enable session replay W privacy = MASK`(
+    fun `M enable session replay W random privacy settings`(
         @DoubleForgery(min = 0.0, max = 100.0) replaySampleRate: Double,
-        @StringForgery(regex = ".+") customEndpoint: String
+        @StringForgery(regex = ".+") customEndpoint: String,
+        @BoolForgery startRecordingImmediately: Boolean
     ) {
-        testSessionReplayEnable("MASK", replaySampleRate, customEndpoint)
-    }
-
-    @Test
-    fun `M enable session replay W privacy = MASK_USER_INPUT`(
-        @DoubleForgery(min = 0.0, max = 100.0) replaySampleRate: Double,
-        @StringForgery(regex = ".+") customEndpoint: String
-    ) {
-        testSessionReplayEnable("MASK_USER_INPUT", replaySampleRate, customEndpoint)
+        val imagePrivacy = imagePrivacyMap.keys.random()
+        val touchPrivacy = touchPrivacyMap.keys.random()
+        val textAndInputPrivacy = inputPrivacyMap.keys.random()
+
+        testSessionReplayEnable(
+            replaySampleRate = replaySampleRate,
+            customEndpoint = customEndpoint,
+            imagePrivacy = imagePrivacy,
+            touchPrivacy = touchPrivacy,
+            textAndInputPrivacy = textAndInputPrivacy,
+            startRecordingImmediately = startRecordingImmediately
+        )
     }
 
     private fun testSessionReplayEnable(
-        privacy: String,
         replaySampleRate: Double,
-        customEndpoint: String
+        customEndpoint: String,
+        imagePrivacy: String,
+        touchPrivacy: String,
+        textAndInputPrivacy: String,
+        startRecordingImmediately: Boolean
     ) {
         // Given
         val sessionReplayConfigCaptor = argumentCaptor<SessionReplayConfiguration>()
@@ -104,8 +120,9 @@ internal class DdSessionReplayImplementationTest {
         // When
         testedSessionReplay.enable(
             replaySampleRate,
-            privacy,
             customEndpoint,
+            SessionReplayPrivacySettings(imagePrivacy, touchPrivacy, textAndInputPrivacy),
+            startRecordingImmediately,
             mockPromise
         )
 
@@ -114,49 +131,41 @@ internal class DdSessionReplayImplementationTest {
         assertThat(sessionReplayConfigCaptor.firstValue)
             .hasFieldEqualTo("sampleRate", replaySampleRate.toFloat())
             .hasFieldEqualTo("customEndpointUrl", customEndpoint)
-
-        when (privacy.lowercase(Locale.US)) {
-            "mask_user_input" -> {
-                assertThat(sessionReplayConfigCaptor.firstValue)
-                    .hasFieldEqualTo("textAndInputPrivacy", TextAndInputPrivacy.MASK_ALL_INPUTS)
-                    .hasFieldEqualTo("imagePrivacy", ImagePrivacy.MASK_NONE)
-                    .hasFieldEqualTo("touchPrivacy", TouchPrivacy.HIDE)
-            }
-            "allow" -> {
-                assertThat(sessionReplayConfigCaptor.firstValue)
-                    .hasFieldEqualTo(
-                        "textAndInputPrivacy",
-                        TextAndInputPrivacy.MASK_SENSITIVE_INPUTS
-                    )
-                    .hasFieldEqualTo("imagePrivacy", ImagePrivacy.MASK_NONE)
-                    .hasFieldEqualTo("touchPrivacy", TouchPrivacy.SHOW)
-            }
-            else -> {
-                assertThat(sessionReplayConfigCaptor.firstValue)
-                    .hasFieldEqualTo("textAndInputPrivacy", TextAndInputPrivacy.MASK_ALL)
-                    .hasFieldEqualTo("imagePrivacy", ImagePrivacy.MASK_ALL)
-                    .hasFieldEqualTo("touchPrivacy", TouchPrivacy.HIDE)
-            }
-        }
+            .hasFieldEqualTo("textAndInputPrivacy", inputPrivacyMap[textAndInputPrivacy])
+            .hasFieldEqualTo("imagePrivacy", imagePrivacyMap[imagePrivacy])
+            .hasFieldEqualTo("touchPrivacy", touchPrivacyMap[touchPrivacy])
     }
 
     @Test
     fun `M enable session replay without custom endpoint W empty string()`(
         @DoubleForgery(min = 0.0, max = 100.0) replaySampleRate: Double,
-        // Not ALLOW nor MASK_USER_INPUT
-        @StringForgery(regex = "^/(?!ALLOW|MASK_USER_INPUT)([a-z0-9]+)$/i") privacy: String
+        @BoolForgery startRecordingImmediately: Boolean
     ) {
         // Given
+        val imagePrivacy = imagePrivacyMap.keys.random()
+        val touchPrivacy = touchPrivacyMap.keys.random()
+        val textAndInputPrivacy = inputPrivacyMap.keys.random()
         val sessionReplayConfigCaptor = argumentCaptor<SessionReplayConfiguration>()
 
         // When
-        testedSessionReplay.enable(replaySampleRate, privacy, "", mockPromise)
+        testedSessionReplay.enable(
+            replaySampleRate,
+            "",
+            SessionReplayPrivacySettings(
+                imagePrivacyLevel = imagePrivacy,
+                touchPrivacyLevel = touchPrivacy,
+                textAndInputPrivacyLevel = textAndInputPrivacy
+            ),
+            startRecordingImmediately,
+            mockPromise
+        )
 
         // Then
         verify(mockSessionReplay).enable(sessionReplayConfigCaptor.capture(), any())
         assertThat(sessionReplayConfigCaptor.firstValue)
             .hasFieldEqualTo("sampleRate", replaySampleRate.toFloat())
             .hasFieldEqualTo("privacy", SessionReplayPrivacy.MASK)
+            .hasFieldEqualTo("startRecordingImmediately", startRecordingImmediately)
             .doesNotHaveField("customEndpointUrl")
     }
 }

package/android/src/test/kotlin/com/datadog/reactnative/sessionreplay/ReactNativeSessionReplayExtensionSupportTest.kt

@@ -8,6 +8,7 @@ package com.datadog.reactnative.sessionreplay
 
 import com.datadog.android.api.InternalLogger
 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.NativeModule
@@ -62,15 +63,18 @@ internal class ReactNativeSessionReplayExtensionSupportTest {
         val customViewMappers = testedExtensionSupport.getCustomViewMappers()
 
         // Then
-        assertThat(customViewMappers).hasSize(3)
+        assertThat(customViewMappers).hasSize(4)
 
         assertThat(customViewMappers[0].getUnsafeMapper())
-            .isInstanceOf(ReactViewGroupMapper::class.java)
+            .isInstanceOf(ReactNativeImageViewMapper::class.java)
 
         assertThat(customViewMappers[1].getUnsafeMapper())
-            .isInstanceOf(ReactTextMapper::class.java)
+            .isInstanceOf(ReactViewGroupMapper::class.java)
 
         assertThat(customViewMappers[2].getUnsafeMapper())
+            .isInstanceOf(ReactTextMapper::class.java)
+
+        assertThat(customViewMappers[3].getUnsafeMapper())
             .isInstanceOf(ReactEditTextMapper::class.java)
     }
 

package/android/src/test/kotlin/com/datadog/reactnative/sessionreplay/ReactTextPropertiesResolverTest.kt

@@ -15,7 +15,6 @@ import com.datadog.reactnative.sessionreplay.ReactTextPropertiesResolver.Compani
 import com.datadog.reactnative.sessionreplay.ReactTextPropertiesResolver.Companion.TEXT_ATTRIBUTES_FIELD_NAME
 import com.datadog.reactnative.sessionreplay.ShadowNodeWrapper.Companion.UI_IMPLEMENTATION_FIELD_NAME
 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.datadog.reactnative.tools.unit.forge.ForgeConfigurator
@@ -64,14 +63,11 @@ internal class ReactTextPropertiesResolverTest {
     @Mock
     lateinit var mockTextView: TextView
 
-    @Mock
-    lateinit var mockDrawableUtils: DrawableUtils
-
     @Mock
     lateinit var mockReactViewBackgroundDrawable: ReactViewBackgroundDrawable
 
     @Mock
-    lateinit var mockReactViewBackgroundDrawableUtils: ReactViewBackgroundDrawableUtils
+    lateinit var mockDrawableUtils: DrawableUtils
 
     @Mock
     lateinit var mockShadowNodeWrapper: ShadowNodeWrapper
@@ -108,7 +104,6 @@ internal class ReactTextPropertiesResolverTest {
         testedResolver = ReactTextPropertiesResolver(
             reactContext = mockReactContext,
             uiManagerModule = mockUiManagerModule,
-            reactViewBackgroundDrawableUtils = mockReactViewBackgroundDrawableUtils,
             drawableUtils = mockDrawableUtils,
             reflectionUtils = mockReflectionUtils
         )
@@ -145,7 +140,7 @@ internal class ReactTextPropertiesResolverTest {
             )
         ).thenReturn(mockReactViewBackgroundDrawable)
         whenever(
-            mockReactViewBackgroundDrawableUtils.resolveShapeAndBorder(
+            mockDrawableUtils.resolveShapeAndBorder(
                 drawable = eq(mockReactViewBackgroundDrawable),
                 opacity = eq(0f),
                 pixelDensity = eq(0f)

package/android/src/test/kotlin/com/datadog/reactnative/sessionreplay/mappers/ReactViewGroupMapperTest.kt

@@ -15,7 +15,6 @@ import com.datadog.android.sessionreplay.recorder.MappingContext
 import com.datadog.android.sessionreplay.recorder.SystemInformation
 import com.datadog.android.sessionreplay.utils.AsyncJobStatusCallback
 import com.datadog.reactnative.sessionreplay.utils.DrawableUtils
-import com.datadog.reactnative.sessionreplay.utils.ReactViewBackgroundDrawableUtils
 import com.facebook.react.views.view.ReactViewBackgroundDrawable
 import com.facebook.react.views.view.ReactViewGroup
 import fr.xgouchet.elmyr.junit5.ForgeExtension
@@ -40,7 +39,7 @@ internal class ReactViewGroupMapperTest {
     private lateinit var testedMapper: ReactViewGroupMapper
 
     @Mock
-    private lateinit var mockReactViewBackgroundDrawableUtils: ReactViewBackgroundDrawableUtils
+    private lateinit var mockDrawableUtils: DrawableUtils
 
     @Mock
     private lateinit var mockReactViewGroup: ReactViewGroup
@@ -57,9 +56,6 @@ internal class ReactViewGroupMapperTest {
     @Mock
     private lateinit var mockSystemInformation: SystemInformation
 
-    @Mock
-    private lateinit var mockDrawableUtils: DrawableUtils
-
     @Mock
     private lateinit var mockReactViewBackgroundDrawable: ReactViewBackgroundDrawable
 
@@ -75,7 +71,6 @@ internal class ReactViewGroupMapperTest {
         whenever(mockSystemInformation.screenDensity).thenReturn(0f)
 
         testedMapper = ReactViewGroupMapper(
-            reactViewBackgroundDrawableUtils = mockReactViewBackgroundDrawableUtils,
             drawableUtils = mockDrawableUtils
         )
     }
@@ -115,7 +110,7 @@ internal class ReactViewGroupMapperTest {
             )
         ).thenReturn(mockReactViewBackgroundDrawable)
         whenever(
-            mockReactViewBackgroundDrawableUtils.resolveShapeAndBorder(
+            mockDrawableUtils.resolveShapeAndBorder(
                 drawable = eq(mockReactViewBackgroundDrawable),
                 pixelDensity = eq(0f),
                 opacity = eq(0f)

package/android/src/test/kotlin/com/datadog/reactnative/sessionreplay/utils/DrawableUtilsTest.kt

@@ -6,6 +6,7 @@
 
 package com.datadog.reactnative.sessionreplay.utils
 
+import ReactViewBackgroundDrawableUtils
 import android.graphics.drawable.ColorDrawable
 import android.graphics.drawable.InsetDrawable
 import android.graphics.drawable.LayerDrawable
@@ -47,7 +48,7 @@ internal class DrawableUtilsTest {
         whenever(mockLayerDrawable.numberOfLayers).thenReturn(3)
         whenever(mockLayerDrawable.getDrawable(0)).thenReturn(mockReactViewBackgroundDrawable)
 
-        testedDrawableUtils = DrawableUtils()
+        testedDrawableUtils = ReactViewBackgroundDrawableUtils()
     }
 
     @Test

package/ios/Sources/DdSessionReplay.mm

@@ -18,12 +18,32 @@
 RCT_EXPORT_MODULE()
 
 RCT_REMAP_METHOD(enable, withEnableReplaySampleRate:(double)replaySampleRate
-                 withDefaultPrivacyLevel:(NSString*)defaultPrivacyLevel
                  withCustomEndpoint:(NSString*)customEndpoint
+                 withImagePrivacyLevel:(NSString*)imagePrivacyLevel
+                 withTouchPrivacyLevel:(NSString*)touchPrivacyLevel
+                 withTextAndInputPrivacyLevel:(NSString*)textAndInputPrivacyLevel
+                 withStartRecordingImmediately:(BOOL)startRecordingImmediately
                  withResolver:(RCTPromiseResolveBlock)resolve
                  withRejecter:(RCTPromiseRejectBlock)reject)
 {
-    [self enable:replaySampleRate defaultPrivacyLevel:defaultPrivacyLevel customEndpoint:customEndpoint resolve:resolve reject:reject];
+    [self enable:replaySampleRate
+          customEndpoint:customEndpoint
+          imagePrivacyLevel:imagePrivacyLevel
+          touchPrivacyLevel:touchPrivacyLevel
+          textAndInputPrivacyLevel:textAndInputPrivacyLevel
+          startRecordingImmediately:startRecordingImmediately
+          resolve:resolve
+          reject:reject];
+}
+
+RCT_EXPORT_METHOD(startRecording:(RCTPromiseResolveBlock)resolve withRejecter:(RCTPromiseRejectBlock)reject)
+{
+    [self startRecordingWithResolver:resolve reject:reject];
+}
+
+RCT_EXPORT_METHOD(stopRecording:(RCTPromiseResolveBlock)resolve withRejecter:(RCTPromiseRejectBlock)reject)
+{
+    [self stopRecordingWithResolver:resolve reject:reject];
 }
 
 // Thanks to this guard, we won't compile this code when we build for the old architecture.
@@ -47,8 +67,30 @@ RCT_REMAP_METHOD(enable, withEnableReplaySampleRate:(double)replaySampleRate
     return NO;
 }
 
-- (void)enable:(double)replaySampleRate defaultPrivacyLevel:(NSString *)defaultPrivacyLevel customEndpoint:(NSString*)customEndpoint resolve:(RCTPromiseResolveBlock)resolve reject:(RCTPromiseRejectBlock)reject {
-    [self.ddSessionReplayImplementation enableWithReplaySampleRate:replaySampleRate defaultPrivacyLevel:defaultPrivacyLevel customEndpoint:customEndpoint resolve:resolve reject:reject];
+- (void)enable:(double)replaySampleRate
+        customEndpoint:(NSString*)customEndpoint
+        imagePrivacyLevel:(NSString *)imagePrivacyLevel
+        touchPrivacyLevel:(NSString *)touchPrivacyLevel
+        textAndInputPrivacyLevel:(NSString *)textAndInputPrivacyLevel
+        startRecordingImmediately:(BOOL)startRecordingImmediately
+        resolve:(RCTPromiseResolveBlock)resolve
+        reject:(RCTPromiseRejectBlock)reject {
+    [self.ddSessionReplayImplementation enableWithReplaySampleRate:replaySampleRate
+                                                    customEndpoint:customEndpoint
+                                                 imagePrivacyLevel:imagePrivacyLevel
+                                                 touchPrivacyLevel:touchPrivacyLevel
+                                          textAndInputPrivacyLevel:textAndInputPrivacyLevel
+                                         startRecordingImmediately:startRecordingImmediately
+                                                           resolve:resolve
+                                                            reject:reject];
+}
+
+- (void)startRecordingWithResolver:(RCTPromiseResolveBlock)resolve reject:(RCTPromiseRejectBlock)reject {
+    [self.ddSessionReplayImplementation startRecordingWithResolve:resolve reject:reject];
+}
+
+- (void)stopRecordingWithResolver:(RCTPromiseResolveBlock)resolve reject:(RCTPromiseRejectBlock)reject {
+    [self.ddSessionReplayImplementation stopRecordingWithResolve:resolve reject:reject];
 }
 
 @end