@truewatchtech/react-native-session-replay 0.4.1

package/android/src/main/java/com/ft/sdk/reactnative/sessionreplay/FTSessionReplayImpl.java

@@ -0,0 +1,119 @@
+package com.ft.sdk.reactnative.sessionreplay;
+
+import com.ft.sdk.reactnative.sessionreplay.utils.text.TextViewUtils;
+import com.ft.sdk.reactnative.sessionreplay.utils.ReactNativeUtils;
+import com.facebook.react.bridge.Promise;
+import com.facebook.react.bridge.ReactContext;
+import com.facebook.react.bridge.ReactMethod;
+import com.facebook.react.bridge.ReadableArray;
+import com.facebook.react.bridge.ReadableMap;
+import com.ft.sdk.FTSdk;
+import com.ft.sdk.SessionReplayManager;
+import com.ft.sdk.sessionreplay.FTSessionReplayConfig;
+import com.ft.sdk.sessionreplay.SessionReplayPrivacy;
+import com.ft.sdk.sessionreplay.TouchPrivacy;
+import com.ft.sdk.sessionreplay.ImagePrivacy;
+import com.ft.sdk.sessionreplay.TextAndInputPrivacy;
+
+import java.util.HashMap;
+
+public class FTSessionReplayImpl {
+
+  public static final String NAME = "FTReactNativeSessionReplay";
+
+
+  @ReactMethod
+  public void sessionReplayConfig(ReadableMap context, Promise promise, ReactContext reactContext) {
+    HashMap<String, Object> map = context.toHashMap();
+
+    Double sampleRate = map.get("sampleRate") instanceof Double ? (Double) map.get("sampleRate") : null;
+    Double sessionReplayOnErrorSampleRate = map.get("sessionReplayOnErrorSampleRate") instanceof Double ? (Double) map.get("sessionReplayOnErrorSampleRate") : null;
+    Integer privacy = ReactNativeUtils.convertToNativeInt(map.get("privacy"));
+    String touchPrivacy = map.get("touchPrivacy") instanceof String ? (String) map.get("touchPrivacy") : null;
+    String textAndInputPrivacy = map.get("textAndInputPrivacy") instanceof String ? (String) map.get("textAndInputPrivacy") : null;
+    String imagePrivacy = map.get("imagePrivacy") instanceof String ? (String) map.get("imagePrivacy") : null;
+    Object enableLinkRUMKeysObj = map.get("enableLinkRUMKeys");
+
+    FTSessionReplayConfig sessionReplayConfig = new FTSessionReplayConfig();
+
+    if (sampleRate != null) {
+      sessionReplayConfig.setSampleRate(sampleRate.floatValue());
+    }
+
+    if (sessionReplayOnErrorSampleRate != null) {
+      sessionReplayConfig.setSessionReplayOnErrorSampleRate(sessionReplayOnErrorSampleRate.floatValue());
+    }
+
+    // Handle deprecated privacy setting for backward compatibility
+    if (privacy != null) {
+      SessionReplayPrivacy sessionReplayPrivacy = switch (privacy) {
+        case 0 -> SessionReplayPrivacy.MASK;
+        case 1 -> SessionReplayPrivacy.ALLOW;
+        case 2 -> SessionReplayPrivacy.MASK_USER_INPUT;
+        default -> null;
+      };
+      sessionReplayConfig.setPrivacy(sessionReplayPrivacy);
+    }
+
+    // Handle fine-grained privacy settings (overrides deprecated privacy setting if provided)
+    if (touchPrivacy != null) {
+      switch (touchPrivacy) {
+        case "SHOW":
+          sessionReplayConfig.setTouchPrivacy(TouchPrivacy.SHOW);
+          break;
+        case "HIDE":
+          sessionReplayConfig.setTouchPrivacy(TouchPrivacy.HIDE);
+          break;
+      }
+    }
+
+    if (textAndInputPrivacy != null) {
+      switch (textAndInputPrivacy) {
+        case "MASK_SENSITIVE_INPUTS":
+          sessionReplayConfig.setTextAndInputPrivacy(TextAndInputPrivacy.MASK_SENSITIVE_INPUTS);
+          break;
+        case "MASK_ALL_INPUTS":
+          sessionReplayConfig.setTextAndInputPrivacy(TextAndInputPrivacy.MASK_ALL_INPUTS);
+          break;
+        case "MASK_ALL":
+          sessionReplayConfig.setTextAndInputPrivacy(TextAndInputPrivacy.MASK_ALL);
+          break;
+      }
+    }
+
+    if (imagePrivacy != null) {
+      switch (imagePrivacy) {
+        case "MASK_NON_BUNDLED_ONLY":
+          // MASK_NON_BUNDLED_ONLY (iOS) maps to MASK_LARGE_ONLY (Android)
+          sessionReplayConfig.setImagePrivacy(ImagePrivacy.MASK_LARGE_ONLY);
+          break;
+        case "MASK_ALL":
+          // MASK_ALL
+          sessionReplayConfig.setImagePrivacy(ImagePrivacy.MASK_ALL);
+          break;
+        case "MASK_NONE":
+          // MASK_NONE
+          sessionReplayConfig.setImagePrivacy(ImagePrivacy.MASK_NONE);
+          break;
+      }
+    }
+
+    // Handle enableLinkRUMKeys
+    if (enableLinkRUMKeysObj instanceof ReadableArray rumKeysArray) {
+      String[] rumKeys = new String[rumKeysArray.size()];
+      for (int i = 0; i < rumKeysArray.size(); i++) {
+        rumKeys[i] = rumKeysArray.getString(i);
+      }
+      sessionReplayConfig.enableLinkRUMKeys(rumKeys);
+    }
+
+    TextViewUtils textViewUtils = TextViewUtils.create(reactContext,
+      SessionReplayManager.get().getInternalLogger());
+    sessionReplayConfig.addExtensionSupport(
+      new ReactNativeSessionReplayExtensionSupport(textViewUtils
+      )
+    ).setDelayInit(true);
+    FTSdk.initSessionReplayConfig(sessionReplayConfig);
+    promise.resolve(null);
+  }
+}

package/android/src/main/java/com/ft/sdk/reactnative/sessionreplay/NoopTextPropertiesResolver.java

@@ -0,0 +1,23 @@
+/*
+ *
+ *  * 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.ft.sdk.reactnative.sessionreplay;
+
+import android.widget.TextView;
+import com.ft.sdk.sessionreplay.model.TextWireframe;
+
+public class NoopTextPropertiesResolver implements TextPropertiesResolver {
+    @Override
+    public TextWireframe addReactNativeProperties(
+            TextWireframe originalWireframe,
+            TextView view,
+            float pixelDensity
+    ) {
+        return originalWireframe;
+    }
+}

package/android/src/main/java/com/ft/sdk/reactnative/sessionreplay/ReactNativeSessionReplayExtensionSupport.java

@@ -0,0 +1,57 @@
+/*
+ * 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.ft.sdk.reactnative.sessionreplay;
+
+import com.ft.sdk.reactnative.sessionreplay.mappers.ReactEditTextMapper;
+import com.ft.sdk.reactnative.sessionreplay.mappers.ReactNativeImageViewMapper;
+import com.ft.sdk.reactnative.sessionreplay.mappers.ReactTextMapper;
+import com.ft.sdk.reactnative.sessionreplay.mappers.ReactViewGroupMapper;
+import com.ft.sdk.reactnative.sessionreplay.mappers.ReactViewModalMapper;
+import com.ft.sdk.reactnative.sessionreplay.utils.text.TextViewUtils;
+import com.facebook.react.views.image.ReactImageView;
+import com.facebook.react.views.modal.ReactModalHostView;
+import com.facebook.react.views.text.ReactTextView;
+import com.facebook.react.views.textinput.ReactEditText;
+import com.facebook.react.views.view.ReactViewGroup;
+import com.ft.sdk.sessionreplay.ExtensionSupport;
+import com.ft.sdk.sessionreplay.MapperTypeWrapper;
+import com.ft.sdk.sessionreplay.recorder.OptionSelectorDetector;
+import com.ft.sdk.sessionreplay.utils.DrawableToColorMapper;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.List;
+
+public class ReactNativeSessionReplayExtensionSupport implements ExtensionSupport {
+    private final TextViewUtils textViewUtils;
+
+    public ReactNativeSessionReplayExtensionSupport(TextViewUtils textViewUtils) {
+        this.textViewUtils = textViewUtils;
+    }
+
+    @Override
+    public List<MapperTypeWrapper<?>> getCustomViewMappers() {
+        return Arrays.asList(
+                new MapperTypeWrapper<>(ReactImageView.class, new ReactNativeImageViewMapper()),
+                new MapperTypeWrapper<>(ReactViewGroup.class, new ReactViewGroupMapper()),
+                new MapperTypeWrapper<>(ReactTextView.class, new ReactTextMapper(textViewUtils)),
+                new MapperTypeWrapper<>(ReactEditText.class, new ReactEditTextMapper(textViewUtils)),
+                new MapperTypeWrapper<>(ReactModalHostView.class, new ReactViewModalMapper())
+        );
+    }
+
+    @Override
+    public List<OptionSelectorDetector> getOptionSelectorDetectors() {
+        return new ArrayList<>();
+    }
+
+    @Override
+    public List<DrawableToColorMapper> getCustomDrawableMapper() {
+        return new ArrayList<>();
+    }
+}

package/android/src/main/java/com/ft/sdk/reactnative/sessionreplay/ShadowNodeWrapper.java

@@ -0,0 +1,84 @@
+/*
+ *
+ *  * 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.ft.sdk.reactnative.sessionreplay;
+
+import androidx.annotation.VisibleForTesting;
+import com.ft.sdk.reactnative.sessionreplay.utils.ReflectionUtils;
+import com.facebook.react.bridge.ReactContext;
+import com.facebook.react.uimanager.ReactShadowNode;
+import com.facebook.react.uimanager.UIImplementation;
+import com.facebook.react.uimanager.UIManagerModule;
+
+import java.util.concurrent.CountDownLatch;
+import java.util.concurrent.TimeUnit;
+
+public class ShadowNodeWrapper {
+    private final ReactShadowNode<?> shadowNode;
+    private final ReflectionUtils reflectionUtils;
+
+    public static final String UI_IMPLEMENTATION_FIELD_NAME = "mUIImplementation";
+
+    public ShadowNodeWrapper(ReactShadowNode<?> shadowNode, ReflectionUtils reflectionUtils) {
+        this.shadowNode = shadowNode;
+        this.reflectionUtils = reflectionUtils;
+    }
+
+    public Object getDeclaredShadowNodeField(String fieldName) {
+        if (shadowNode != null) {
+            return reflectionUtils.getDeclaredField(shadowNode, fieldName);
+        }
+        return null;
+    }
+
+    public static ShadowNodeWrapper getShadowNodeWrapper(
+            ReactContext reactContext,
+            UIManagerModule uiManagerModule,
+            ReflectionUtils reflectionUtils,
+            int viewId
+    ) {
+        if (reactContext == null) {
+            return null;
+        }
+
+        CountDownLatch countDownLatch = new CountDownLatch(1);
+        final ReactShadowNode<?>[] target = new ReactShadowNode[1];
+
+        Runnable shadowNodeRunnable = new Runnable() {
+            @Override
+            public void run() {
+                ReactShadowNode<?> node = resolveShadowNode(reflectionUtils, uiManagerModule, viewId);
+                if (node != null) {
+                    target[0] = node;
+                }
+                countDownLatch.countDown();
+            }
+        };
+
+        reactContext.runOnNativeModulesQueueThread(shadowNodeRunnable);
+        try {
+            countDownLatch.await(5, TimeUnit.SECONDS);
+        } catch (InterruptedException e) {
+            Thread.currentThread().interrupt();
+        }
+
+        if (target[0] == null) {
+            return null;
+        }
+
+        return new ShadowNodeWrapper(target[0], reflectionUtils);
+    }
+
+    private static ReactShadowNode<?> resolveShadowNode(ReflectionUtils reflectionUtils, UIManagerModule uiManagerModule, int tag) {
+        if (uiManagerModule == null ) {
+            return null;
+        }
+        UIImplementation uiManagerImplementation = (UIImplementation) reflectionUtils.getDeclaredField(uiManagerModule, UI_IMPLEMENTATION_FIELD_NAME);
+        return uiManagerImplementation != null ? uiManagerImplementation.resolveShadowNode(tag) : null;
+    }
+}

package/android/src/main/java/com/ft/sdk/reactnative/sessionreplay/TextPropertiesResolver.java

@@ -0,0 +1,20 @@
+/*
+ *
+ *  * 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.ft.sdk.reactnative.sessionreplay;
+
+import android.widget.TextView;
+import com.ft.sdk.sessionreplay.model.TextWireframe;
+
+public interface TextPropertiesResolver {
+    TextWireframe addReactNativeProperties(
+            TextWireframe originalWireframe,
+            TextView view,
+            float pixelDensity
+    );
+}

package/android/src/main/java/com/ft/sdk/reactnative/sessionreplay/extensions/ReactDrawablesExt.java

@@ -0,0 +1,155 @@
+/*
+ * 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.ft.sdk.reactnative.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;
+
+public class ReactDrawablesExt {
+    public static ImageView.ScaleType imageViewScaleType(ScaleTypeDrawable scaleTypeDrawable) {
+        ScalingUtils.ScaleType scaleType = scaleTypeDrawable.getScaleType();
+        if (scaleType == ScalingUtils.ScaleType.CENTER) return ImageView.ScaleType.CENTER;
+        if (scaleType == ScalingUtils.ScaleType.CENTER_CROP) return ImageView.ScaleType.CENTER_CROP;
+        if (scaleType == ScalingUtils.ScaleType.CENTER_INSIDE) return ImageView.ScaleType.CENTER_INSIDE;
+        if (scaleType == ScalingUtils.ScaleType.FIT_CENTER) return ImageView.ScaleType.FIT_CENTER;
+        if (scaleType == ScalingUtils.ScaleType.FIT_START) return ImageView.ScaleType.FIT_START;
+        if (scaleType == ScalingUtils.ScaleType.FIT_END) return ImageView.ScaleType.FIT_END;
+        if (scaleType == ScalingUtils.ScaleType.FIT_XY) return ImageView.ScaleType.FIT_XY;
+        return null;
+    }
+
+    public static ScaleTypeDrawable getScaleTypeDrawable(ArrayDrawable arrayDrawable) {
+        for (int i = 0; i < arrayDrawable.getNumberOfLayers(); i++) {
+            Drawable drawable = getDrawableOrNull(arrayDrawable, i);
+            if (drawable instanceof ScaleTypeDrawable) return (ScaleTypeDrawable) drawable;
+        }
+        return null;
+    }
+
+    public static Drawable getDrawableOrNull(ArrayDrawable arrayDrawable, int index) {
+        try {
+            return arrayDrawable.getDrawable(index);
+        } catch (IllegalArgumentException e) {
+            return null;
+        }
+    }
+
+    public static Bitmap tryToExtractBitmap(ForwardingDrawable forwardingDrawable, Resources resources) {
+        Drawable forwardedDrawable = forwardingDrawable.getDrawable();
+        if (forwardedDrawable != null) {
+            return tryToExtractBitmap(forwardedDrawable, resources);
+        } else {
+            return toBitmapOrNull(forwardingDrawable, forwardingDrawable.getIntrinsicWidth(), forwardingDrawable.getIntrinsicHeight(), Config.ARGB_8888);
+        }
+    }
+
+    public static Bitmap tryToExtractBitmap(RoundedBitmapDrawable roundedBitmapDrawable) {
+        try {
+            java.lang.reflect.Field field = RoundedBitmapDrawable.class.getDeclaredField("mBitmap");
+            field.setAccessible(true);
+            Object value = field.get(roundedBitmapDrawable);
+            if (value instanceof Bitmap) {
+                return (Bitmap) value;
+            }
+        } catch (NoSuchFieldException | IllegalAccessException e) {
+            // ignore
+        } catch (Exception e) {
+            // ignore
+        }
+        return toBitmapOrNull(roundedBitmapDrawable, roundedBitmapDrawable.getIntrinsicWidth(), roundedBitmapDrawable.getIntrinsicHeight(), Config.ARGB_8888);
+    }
+
+    public static Bitmap tryToExtractBitmap(BitmapDrawable bitmapDrawable, Resources resources) {
+        if (bitmapDrawable.getBitmap() != null) {
+            return bitmapDrawable.getBitmap();
+        }
+        if (bitmapDrawable.getConstantState() != null) {
+            Drawable copy = bitmapDrawable.getConstantState().newDrawable(resources);
+            if (copy instanceof BitmapDrawable) {
+                Bitmap b = ((BitmapDrawable) copy).getBitmap();
+                if (b != null) return b;
+            }
+            return toBitmapOrNull(copy, copy.getIntrinsicWidth(), copy.getIntrinsicHeight(), Config.ARGB_8888);
+        }
+        return null;
+    }
+
+    public static Bitmap tryToExtractBitmap(ArrayDrawable arrayDrawable, Resources resources) {
+        int width = 0, height = 0;
+        for (int i = 0; i < arrayDrawable.getNumberOfLayers(); i++) {
+            Drawable drawable = getDrawableOrNull(arrayDrawable, i);
+            if (drawable instanceof ScaleTypeDrawable) {
+                return tryToExtractBitmap((ScaleTypeDrawable) drawable, resources);
+            }
+            if (drawable != null && drawable.getIntrinsicWidth() * drawable.getIntrinsicHeight() > width * height) {
+                width = drawable.getIntrinsicWidth();
+                height = drawable.getIntrinsicHeight();
+            }
+        }
+        if (width > 0 && height > 0) {
+            return toBitmapOrNull(arrayDrawable, width, height, Config.ARGB_8888);
+        } else {
+            return null;
+        }
+    }
+
+    public static Bitmap tryToExtractBitmap(Drawable drawable, Resources resources) {
+        if (drawable instanceof ArrayDrawable) {
+            return tryToExtractBitmap((ArrayDrawable) drawable, resources);
+        } else if (drawable instanceof ForwardingDrawable) {
+            return tryToExtractBitmap((ForwardingDrawable) drawable, resources);
+        } else if (drawable instanceof RoundedBitmapDrawable) {
+            return tryToExtractBitmap((RoundedBitmapDrawable) drawable);
+        } else if (drawable instanceof BitmapDrawable) {
+            return tryToExtractBitmap((BitmapDrawable) drawable, resources);
+        } else if (drawable instanceof VectorDrawable || drawable instanceof ShapeDrawable || drawable instanceof DrawerArrowDrawable) {
+            return toBitmapOrNull(drawable, drawable.getIntrinsicWidth(), drawable.getIntrinsicHeight(), Config.ARGB_8888);
+        } else {
+            return null;
+        }
+    }
+
+    public static Bitmap toBitmapOrNull(Drawable drawable, int width, int height, Config config) {
+        if (drawable instanceof BitmapDrawable && ((BitmapDrawable) drawable).getBitmap() == null) {
+            return null;
+        }
+        return toBitmap(drawable, width, height, config);
+    }
+
+    public static Bitmap toBitmap(Drawable drawable, int width, int height, Config config) {
+        if (drawable instanceof BitmapDrawable) {
+            Bitmap bitmap = ((BitmapDrawable) drawable).getBitmap();
+            if (bitmap == null) {
+                return Bitmap.createBitmap(width, height, config != null ? config : Config.ARGB_8888);
+            }
+            if (config == null || bitmap.getConfig() == config) {
+                if (width == bitmap.getWidth() && height == bitmap.getHeight()) {
+                    return bitmap;
+                }
+                return Bitmap.createScaledBitmap(bitmap, width, height, true);
+            }
+        }
+        Bitmap bitmap = Bitmap.createBitmap(width, height, config != null ? config : Config.ARGB_8888);
+        drawable.setBounds(0, 0, width, height);
+        drawable.draw(new Canvas(bitmap));
+        // restore bounds if needed
+        return bitmap;
+    }
+}

package/android/src/main/java/com/ft/sdk/reactnative/sessionreplay/mappers/DefaultMapper.java

@@ -0,0 +1,78 @@
+/*
+ * 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.ft.sdk.reactnative.sessionreplay.mappers;
+
+import android.graphics.drawable.Drawable;
+import android.view.View;
+
+import com.ft.sdk.reactnative.sessionreplay.utils.DrawableUtils;
+import com.ft.sdk.reactnative.sessionreplay.utils.ReactViewBackgroundDrawableUtils;
+import com.ft.sdk.sessionreplay.model.ShapeBorder;
+import com.ft.sdk.sessionreplay.model.ShapeStyle;
+import com.ft.sdk.sessionreplay.model.ShapeWireframe;
+import com.ft.sdk.sessionreplay.model.Wireframe;
+import com.ft.sdk.sessionreplay.recorder.MappingContext;
+import com.ft.sdk.sessionreplay.recorder.mapper.BaseWireframeMapper;
+import com.ft.sdk.sessionreplay.utils.AsyncJobStatusCallback;
+import com.ft.sdk.sessionreplay.utils.DefaultColorStringFormatter;
+import com.ft.sdk.sessionreplay.utils.DefaultViewBoundsResolver;
+import com.ft.sdk.sessionreplay.utils.DefaultViewIdentifierResolver;
+import com.ft.sdk.sessionreplay.utils.DrawableToColorMapperFactory;
+import com.ft.sdk.sessionreplay.utils.GlobalBounds;
+import com.ft.sdk.sessionreplay.utils.InternalLogger;
+
+import java.util.Collections;
+import java.util.List;
+
+public class DefaultMapper<T extends View> extends BaseWireframeMapper<T> {
+  private final DrawableUtils drawableUtils;
+
+  public DefaultMapper(DrawableUtils drawableUtils) {
+    super(
+      DefaultViewIdentifierResolver.get(),
+      DefaultColorStringFormatter.get(),
+      DefaultViewBoundsResolver.get(),
+      DrawableToColorMapperFactory.getDefault()
+    );
+    this.drawableUtils = drawableUtils;
+  }
+
+  @Override
+  public List<Wireframe> map(
+    T view,
+    MappingContext mappingContext,
+    AsyncJobStatusCallback asyncJobStatusCallback,
+    InternalLogger internalLogger
+  ) {
+    float pixelDensity = mappingContext.getSystemInformation().getScreenDensity();
+    GlobalBounds viewGlobalBounds =
+      DefaultViewBoundsResolver.get().resolveViewGlobalBounds(view, pixelDensity);
+    Drawable backgroundDrawable = drawableUtils.getReactBackgroundFromDrawable(view.getBackground());
+
+    float opacity = view.getAlpha();
+
+    Pair<ShapeStyle, ShapeBorder> shapeAndBorder =
+      backgroundDrawable != null ?
+        drawableUtils.resolveShapeAndBorder(backgroundDrawable, opacity, pixelDensity)
+        : new Pair<>(null, null);
+
+    ShapeStyle shapeStyle = shapeAndBorder.first;
+    ShapeBorder border = shapeAndBorder.second;
+
+    ShapeWireframe shapeWireframe = new ShapeWireframe(
+      resolveViewId(view),
+      viewGlobalBounds.getX(),
+      viewGlobalBounds.getY(),
+      viewGlobalBounds.getWidth(),
+      viewGlobalBounds.getHeight(),
+      null,
+      shapeStyle,
+      border
+    );
+    return Collections.singletonList(shapeWireframe);
+  }
+}

package/android/src/main/java/com/ft/sdk/reactnative/sessionreplay/mappers/Pair.java

@@ -0,0 +1,11 @@
+package com.ft.sdk.reactnative.sessionreplay.mappers;
+
+public class Pair<F, S> {
+  public final F first;
+  public final S second;
+
+  public Pair(F first, S second) {
+    this.first = first;
+    this.second = second;
+  }
+}

package/android/src/main/java/com/ft/sdk/reactnative/sessionreplay/mappers/ReactEditTextMapper.java

@@ -0,0 +1,136 @@
+/*
+ * 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.ft.sdk.reactnative.sessionreplay.mappers;
+
+import android.graphics.drawable.Drawable;
+import android.view.View;
+
+import com.ft.sdk.reactnative.sessionreplay.utils.ReactViewBackgroundDrawableUtils;
+import com.ft.sdk.reactnative.sessionreplay.utils.text.TextViewUtils;
+import com.facebook.react.views.textinput.ReactEditText;
+import com.ft.sdk.sessionreplay.model.ImageWireframe;
+import com.ft.sdk.sessionreplay.model.PlaceholderWireframe;
+import com.ft.sdk.sessionreplay.model.ShapeBorder;
+import com.ft.sdk.sessionreplay.model.ShapeStyle;
+import com.ft.sdk.sessionreplay.model.ShapeWireframe;
+import com.ft.sdk.sessionreplay.model.Wireframe;
+import com.ft.sdk.sessionreplay.recorder.MappingContext;
+import com.ft.sdk.sessionreplay.recorder.mapper.BaseAsyncBackgroundWireframeMapper;
+import com.ft.sdk.sessionreplay.recorder.mapper.EditTextMapper;
+import com.ft.sdk.sessionreplay.utils.AsyncJobStatusCallback;
+import com.ft.sdk.sessionreplay.utils.DefaultColorStringFormatter;
+import com.ft.sdk.sessionreplay.utils.DefaultViewBoundsResolver;
+import com.ft.sdk.sessionreplay.utils.DefaultViewIdentifierResolver;
+import com.ft.sdk.sessionreplay.utils.DrawableToColorMapperFactory;
+import com.ft.sdk.sessionreplay.utils.GlobalBounds;
+import com.ft.sdk.sessionreplay.utils.InternalLogger;
+
+import java.util.ArrayList;
+import java.util.List;
+
+public class ReactEditTextMapper extends BaseAsyncBackgroundWireframeMapper<ReactEditText> {
+  private final TextViewUtils textViewUtils;
+  private final ReactViewBackgroundDrawableUtils drawableUtils = new ReactViewBackgroundDrawableUtils();
+  private final EditTextMapper editTextMapper;
+
+  public ReactEditTextMapper(TextViewUtils textViewUtils) {
+    super(
+      DefaultViewIdentifierResolver.get(),
+      DefaultColorStringFormatter.get(),
+      DefaultViewBoundsResolver.get(),
+      DrawableToColorMapperFactory.getDefault()
+    );
+    this.textViewUtils = textViewUtils;
+    this.editTextMapper = new EditTextMapper(
+      viewIdentifierResolver,
+      colorStringFormatter,
+      viewBoundsResolver,
+      drawableToColorMapper
+    );
+  }
+
+  @Override
+  public List<Wireframe> map(
+    ReactEditText view,
+    MappingContext mappingContext,
+    AsyncJobStatusCallback asyncJobStatusCallback,
+    InternalLogger internalLogger
+  ) {
+    List<Wireframe> backgroundWireframes = new ArrayList<>(super.map(view, mappingContext, asyncJobStatusCallback, internalLogger));
+    List<Wireframe> editTextWireframes = editTextMapper.map(
+      view,
+      mappingContext,
+      asyncJobStatusCallback,
+      internalLogger
+    );
+
+    List<Wireframe> filteredEditTextWireframes = new ArrayList<>();
+    for (Wireframe wf : editTextWireframes) {
+      if (!(wf instanceof ImageWireframe) && !(wf instanceof PlaceholderWireframe)) {
+        filteredEditTextWireframes.add(wf);
+      }
+    }
+    backgroundWireframes.addAll(filteredEditTextWireframes);
+    return textViewUtils.mapTextViewToWireframes(
+      backgroundWireframes,
+      view,
+      mappingContext
+    );
+  }
+
+  @Override
+  public Wireframe resolveBackgroundAsImageWireframe(
+    View view,
+    GlobalBounds bounds,
+    int width,
+    int height,
+    MappingContext mappingContext,
+    AsyncJobStatusCallback asyncJobStatusCallback
+  ) {
+    if (!(view instanceof ReactEditText)) {
+      return super.resolveBackgroundAsImageWireframe(
+        view,
+        bounds,
+        width,
+        height,
+        mappingContext,
+        asyncJobStatusCallback
+      );
+    }
+    Drawable backgroundDrawable = drawableUtils.getReactBackgroundFromDrawable(((ReactEditText) view).getBackground());
+    if (backgroundDrawable == null) {
+      return null;
+    }
+    float density = mappingContext.getSystemInformation().getScreenDensity();
+    Long identifier = viewIdentifierResolver.resolveChildUniqueIdentifier(
+      view,
+      "drawable0"
+    );
+    if (identifier == null) {
+      return null;
+    }
+    GlobalBounds globalBounds = viewBoundsResolver.resolveViewGlobalBounds(
+      view,
+      density
+    );
+    Pair<ShapeStyle, ShapeBorder> shapeAndBorder = drawableUtils.resolveShapeAndBorder(
+      backgroundDrawable,
+      ((ReactEditText) view).getAlpha(),
+      mappingContext.getSystemInformation().getScreenDensity()
+    );
+    return new ShapeWireframe(
+      identifier,
+      globalBounds.getX(),
+      globalBounds.getY(),
+      globalBounds.getWidth(),
+      globalBounds.getHeight(),
+      null,
+      shapeAndBorder.first,
+      shapeAndBorder.second
+    );
+  }
+}