@datadog/mobile-react-native-session-replay 2.4.3-alpha.0 → 2.5.0-alpha.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.reactnative.sessionreplay.extensions.convertToDensityNormalized
+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().convertToDensityNormalized(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

@@ -6,15 +6,18 @@
 
 package com.datadog.reactnative.sessionreplay
 
+import com.datadog.android.sessionreplay.ImagePrivacy
 import com.datadog.android.sessionreplay.SessionReplayConfiguration
 import com.datadog.android.sessionreplay.SessionReplayPrivacy
+import com.datadog.android.sessionreplay.TextAndInputPrivacy
+import com.datadog.android.sessionreplay.TouchPrivacy
 import com.datadog.tools.unit.GenericAssert.Companion.assertThat
 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.Forgery
 import fr.xgouchet.elmyr.annotation.StringForgery
 import fr.xgouchet.elmyr.junit5.ForgeExtension
 import org.junit.jupiter.api.AfterEach
@@ -53,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>>()))
@@ -67,10 +87,32 @@ internal class DdSessionReplayImplementationTest {
     }
 
     @Test
-    fun `M enable session replay W enable()`(
+    fun `M enable session replay W random privacy settings`(
         @DoubleForgery(min = 0.0, max = 100.0) replaySampleRate: Double,
-        @Forgery privacy: SessionReplayPrivacy,
-        @StringForgery(regex = ".+") customEndpoint: String
+        @StringForgery(regex = ".+") customEndpoint: String,
+        @BoolForgery startRecordingImmediately: Boolean
+    ) {
+        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(
+        replaySampleRate: Double,
+        customEndpoint: String,
+        imagePrivacy: String,
+        touchPrivacy: String,
+        textAndInputPrivacy: String,
+        startRecordingImmediately: Boolean
     ) {
         // Given
         val sessionReplayConfigCaptor = argumentCaptor<SessionReplayConfiguration>()
@@ -78,8 +120,9 @@ internal class DdSessionReplayImplementationTest {
         // When
         testedSessionReplay.enable(
             replaySampleRate,
-            privacy.toString(),
             customEndpoint,
+            SessionReplayPrivacySettings(imagePrivacy, touchPrivacy, textAndInputPrivacy),
+            startRecordingImmediately,
             mockPromise
         )
 
@@ -87,27 +130,42 @@ internal class DdSessionReplayImplementationTest {
         verify(mockSessionReplay).enable(sessionReplayConfigCaptor.capture(), any())
         assertThat(sessionReplayConfigCaptor.firstValue)
             .hasFieldEqualTo("sampleRate", replaySampleRate.toFloat())
-            .hasFieldEqualTo("privacy", privacy)
             .hasFieldEqualTo("customEndpointUrl", customEndpoint)
+            .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

package/ios/Sources/DdSessionReplayImplementation.swift

@@ -30,14 +30,26 @@ public class DdSessionReplayImplementation: NSObject {
     }
 
     @objc
-    public func enable(replaySampleRate: Double, defaultPrivacyLevel: String, customEndpoint: String, resolve:RCTPromiseResolveBlock, reject:RCTPromiseRejectBlock) -> Void {
+    public func enable(
+        replaySampleRate: Double,
+        customEndpoint: String,
+        imagePrivacyLevel: NSString,
+        touchPrivacyLevel: NSString,
+        textAndInputPrivacyLevel: NSString,
+        startRecordingImmediately: Bool,
+        resolve:RCTPromiseResolveBlock,
+        reject:RCTPromiseRejectBlock
+    ) -> Void {
         var customEndpointURL: URL? = nil
         if (customEndpoint != "") {
             customEndpointURL = URL(string: "\(customEndpoint)/api/v2/replay" as String)
         }
         var sessionReplayConfiguration = SessionReplay.Configuration(
             replaySampleRate: Float(replaySampleRate),
-            defaultPrivacyLevel: buildPrivacyLevel(privacyLevel: defaultPrivacyLevel as NSString),
+            textAndInputPrivacyLevel: convertTextAndInputPrivacy(textAndInputPrivacyLevel),
+            imagePrivacyLevel: convertImagePrivacy(imagePrivacyLevel),
+            touchPrivacyLevel: convertTouchPrivacy(touchPrivacyLevel),
+            startRecordingImmediately: startRecordingImmediately,
             customEndpoint: customEndpointURL
         )
                     
@@ -55,16 +67,65 @@ public class DdSessionReplayImplementation: NSObject {
         resolve(nil)
     }
     
-    func buildPrivacyLevel(privacyLevel: NSString) -> SessionReplayPrivacyLevel {
-        switch privacyLevel.lowercased {
-        case "mask":
-            return .mask
-        case "mask_user_input":
-            return .maskUserInput
-        case "allow":
-            return .allow
+    @objc
+    public func startRecording(resolve: RCTPromiseResolveBlock, reject: RCTPromiseRejectBlock) -> Void {
+        if let core = DatadogSDKWrapper.shared.getCoreInstance() {
+            sessionReplay.startRecording(in: core)
+        } else {
+            consolePrint("Core instance was not found when calling startRecording in Session Replay.", .critical)
+        }
+        
+        resolve(nil)
+    }
+    
+    @objc
+    public func stopRecording(resolve: RCTPromiseResolveBlock, reject: RCTPromiseRejectBlock) -> Void {
+        if let core = DatadogSDKWrapper.shared.getCoreInstance() {
+            sessionReplay.stopRecording(in: core)
+        } else {
+            consolePrint("Core instance was not found when calling stopRecording in Session Replay.", .critical)
+        }
+        
+        resolve(nil)
+    }
+    
+    func convertImagePrivacy(_ imagePrivacy: NSString) -> ImagePrivacyLevel {
+        switch imagePrivacy {
+        case "MASK_NON_BUNDLED_ONLY":
+            return .maskNonBundledOnly
+        case "MASK_ALL":
+            return .maskAll
+        case "MASK_NONE":
+            return .maskNone
         default:
-            return .mask
+            consolePrint("Unknown Session Replay Image Privacy Level given: \(imagePrivacy), using .maskAll as default.", .warn)
+            return .maskAll
+        }
+    }
+    
+    func convertTouchPrivacy(_ touchPrivacy: NSString) -> TouchPrivacyLevel {
+        switch touchPrivacy {
+        case "SHOW":
+            return .show
+        case "HIDE":
+            return .hide
+        default:
+            consolePrint("Unknown Session Replay Touch Privacy Level given: \(touchPrivacy), using .hide as default.", .warn)
+            return .hide
+        }
+    }
+    
+    func convertTextAndInputPrivacy(_ textAndInputPrivacy: NSString) -> TextAndInputPrivacyLevel {
+        switch textAndInputPrivacy {
+        case "MASK_SENSITIVE_INPUTS":
+            return .maskSensitiveInputs
+        case "MASK_ALL_INPUTS":
+            return .maskAllInputs
+        case "MASK_ALL":
+            return .maskAll
+        default:
+            consolePrint("Unknown Session Replay Text and Input Privacy Level given: \(textAndInputPrivacy), using .maskAll as default.", .warn)
+            return .maskAll
         }
     }
 }
@@ -74,10 +135,21 @@ internal protocol SessionReplayProtocol {
         with configuration: SessionReplay.Configuration,
         in core: DatadogCoreProtocol
     )
+    
+    func startRecording(in core: DatadogCoreProtocol)
+    func stopRecording(in core: DatadogCoreProtocol)
 }
 
 internal class NativeSessionReplay: SessionReplayProtocol {
     func enable(with configuration: DatadogSessionReplay.SessionReplay.Configuration, in core: DatadogCoreProtocol) {
         SessionReplay.enable(with: configuration, in: core)
     }
+    
+    func startRecording(in core: any DatadogInternal.DatadogCoreProtocol) {
+        SessionReplay.startRecording(in: core)
+    }
+    
+    func stopRecording(in core: any DatadogInternal.DatadogCoreProtocol) {
+        SessionReplay.stopRecording(in: core)
+    }
 }

package/ios/Sources/RCTTextViewRecorder.swift

@@ -11,7 +11,7 @@ import React
 
 internal class RCTTextViewRecorder: SessionReplayNodeRecorder {
     internal var textObfuscator: (SessionReplayViewTreeRecordingContext) -> SessionReplayTextObfuscating = { context in
-        return context.recorder.privacy.staticTextObfuscator
+        return context.recorder.textAndInputPrivacy.staticTextObfuscator
     }
 
     internal var identifier = UUID()