react-native-tvos 0.75.4-0 → 0.76.0-0

package/ReactAndroid/src/main/java/com/facebook/react/uimanager/BackgroundStyleApplicator.kt

@@ -0,0 +1,263 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+package com.facebook.react.uimanager
+
+import android.graphics.Canvas
+import android.graphics.Color
+import android.graphics.Rect
+import android.graphics.drawable.Drawable
+import android.os.Build
+import android.view.View
+import androidx.annotation.ColorInt
+import com.facebook.react.bridge.ReadableArray
+import com.facebook.react.common.annotations.UnstableReactNativeAPI
+import com.facebook.react.uimanager.PixelUtil.dpToPx
+import com.facebook.react.uimanager.PixelUtil.pxToDp
+import com.facebook.react.uimanager.common.UIManagerType
+import com.facebook.react.uimanager.common.ViewUtil
+import com.facebook.react.uimanager.drawable.CSSBackgroundDrawable
+import com.facebook.react.uimanager.drawable.CompositeBackgroundDrawable
+import com.facebook.react.uimanager.drawable.InsetBoxShadowDrawable
+import com.facebook.react.uimanager.drawable.MIN_INSET_BOX_SHADOW_SDK_VERSION
+import com.facebook.react.uimanager.drawable.MIN_OUTSET_BOX_SHADOW_SDK_VERSION
+import com.facebook.react.uimanager.drawable.OutsetBoxShadowDrawable
+import com.facebook.react.uimanager.style.BackgroundImageLayer
+import com.facebook.react.uimanager.style.BorderInsets
+import com.facebook.react.uimanager.style.BorderRadiusProp
+import com.facebook.react.uimanager.style.BorderRadiusStyle
+import com.facebook.react.uimanager.style.BorderStyle
+import com.facebook.react.uimanager.style.BoxShadow
+import com.facebook.react.uimanager.style.LogicalEdge
+
+/**
+ * BackgroundStyleApplicator is responsible for applying backgrounds, borders, and related effects,
+ * to an Android view
+ */
+@OptIn(UnstableReactNativeAPI::class)
+public object BackgroundStyleApplicator {
+
+  @JvmStatic
+  public fun setBackgroundColor(view: View, @ColorInt color: Int?): Unit {
+    // No color to set, and no color already set
+    if ((color == null || color == Color.TRANSPARENT) &&
+        view.background !is CompositeBackgroundDrawable) {
+      return
+    }
+
+    ensureCSSBackground(view).color = color ?: Color.TRANSPARENT
+  }
+
+  @JvmStatic
+  public fun setBackgroundImage(
+      view: View,
+      backgroundImageLayers: List<BackgroundImageLayer>?
+  ): Unit {
+    ensureCSSBackground(view).setBackgroundImage(backgroundImageLayers)
+  }
+
+  @JvmStatic
+  @ColorInt
+  public fun getBackgroundColor(view: View): Int? = getCSSBackground(view)?.color
+
+  @JvmStatic
+  public fun setBorderWidth(view: View, edge: LogicalEdge, width: Float?): Unit {
+    ensureCSSBackground(view).setBorderWidth(edge.toSpacingType(), width?.dpToPx() ?: Float.NaN)
+
+    if (Build.VERSION.SDK_INT >= MIN_INSET_BOX_SHADOW_SDK_VERSION) {
+      val composite = ensureCompositeBackgroundDrawable(view)
+      composite.borderInsets = composite.borderInsets ?: BorderInsets()
+      composite.borderInsets?.setBorderWidth(edge, width)
+
+      for (shadow in composite.innerShadows) {
+        (shadow as InsetBoxShadowDrawable).borderInsets = composite.borderInsets
+        shadow.invalidateSelf()
+      }
+    }
+  }
+
+  @JvmStatic
+  public fun getBorderWidth(view: View, edge: LogicalEdge): Float? {
+    val width = getCSSBackground(view)?.getBorderWidth(edge.toSpacingType())
+    return if (width == null || width.isNaN()) null else width.pxToDp()
+  }
+
+  @JvmStatic
+  public fun setBorderColor(view: View, edge: LogicalEdge, @ColorInt color: Int?): Unit =
+      ensureCSSBackground(view).setBorderColor(edge.toSpacingType(), color)
+
+  @JvmStatic
+  @ColorInt
+  public fun getBorderColor(view: View, edge: LogicalEdge): Int? =
+      getCSSBackground(view)?.getBorderColor(edge.toSpacingType())
+
+  @JvmStatic
+  public fun setBorderRadius(
+      view: View,
+      corner: BorderRadiusProp,
+      radius: LengthPercentage?
+  ): Unit {
+    ensureCSSBackground(view).setBorderRadius(corner, radius)
+    val compositeBackgroundDrawable = ensureCompositeBackgroundDrawable(view)
+
+    if (Build.VERSION.SDK_INT >= MIN_OUTSET_BOX_SHADOW_SDK_VERSION) {
+      for (shadow in compositeBackgroundDrawable.outerShadows) {
+        if (shadow is OutsetBoxShadowDrawable) {
+          shadow.borderRadius = shadow.borderRadius ?: BorderRadiusStyle()
+          shadow.borderRadius?.set(corner, radius)
+          shadow.invalidateSelf()
+        }
+      }
+    }
+
+    if (Build.VERSION.SDK_INT >= MIN_INSET_BOX_SHADOW_SDK_VERSION) {
+      for (shadow in compositeBackgroundDrawable.innerShadows) {
+        if (shadow is InsetBoxShadowDrawable) {
+          shadow.borderRadius = shadow.borderRadius ?: BorderRadiusStyle()
+          shadow.borderRadius?.set(corner, radius)
+          shadow.invalidateSelf()
+        }
+      }
+    }
+  }
+
+  @JvmStatic
+  public fun getBorderRadius(view: View, corner: BorderRadiusProp): LengthPercentage? =
+      getCSSBackground(view)?.borderRadius?.get(corner)
+
+  @JvmStatic
+  public fun setBorderStyle(view: View, borderStyle: BorderStyle?): Unit {
+    ensureCSSBackground(view).borderStyle = borderStyle
+  }
+
+  @JvmStatic
+  public fun getBorderStyle(view: View): BorderStyle? = getCSSBackground(view)?.borderStyle
+
+  @JvmStatic
+  public fun setBoxShadow(view: View, shadows: List<BoxShadow>): Unit {
+    if (ViewUtil.getUIManagerType(view) != UIManagerType.FABRIC) {
+      return
+    }
+
+    val outerShadows = mutableListOf<OutsetBoxShadowDrawable>()
+    val innerShadows = mutableListOf<InsetBoxShadowDrawable>()
+
+    val borderInsets = ensureCompositeBackgroundDrawable(view).borderInsets
+
+    for (boxShadow in shadows) {
+      val offsetX = boxShadow.offsetX
+      val offsetY = boxShadow.offsetY
+      val color = boxShadow.color ?: Color.BLACK
+      val blurRadius = boxShadow.blurRadius ?: 0f
+      val spreadDistance = boxShadow.spreadDistance ?: 0f
+      val inset = boxShadow.inset ?: false
+
+      if (inset && Build.VERSION.SDK_INT >= MIN_INSET_BOX_SHADOW_SDK_VERSION) {
+        innerShadows.add(
+            InsetBoxShadowDrawable(
+                context = view.context,
+                borderRadius = ensureCSSBackground(view).borderRadius,
+                borderInsets = borderInsets,
+                shadowColor = color,
+                offsetX = offsetX,
+                offsetY = offsetY,
+                blurRadius = blurRadius,
+                spread = spreadDistance))
+      } else if (!inset && Build.VERSION.SDK_INT >= MIN_OUTSET_BOX_SHADOW_SDK_VERSION) {
+        outerShadows.add(
+            OutsetBoxShadowDrawable(
+                context = view.context,
+                borderRadius = ensureCSSBackground(view).borderRadius,
+                shadowColor = color,
+                offsetX = offsetX,
+                offsetY = offsetY,
+                blurRadius = blurRadius,
+                spread = spreadDistance))
+      }
+    }
+
+    view.background =
+        ensureCompositeBackgroundDrawable(view)
+            .withNewShadows(outerShadows = outerShadows, innerShadows = innerShadows)
+  }
+
+  @JvmStatic
+  public fun setBoxShadow(view: View, shadows: ReadableArray?): Unit {
+    if (shadows == null) {
+      BackgroundStyleApplicator.setBoxShadow(view, emptyList())
+      return
+    }
+
+    val shadowStyles = mutableListOf<BoxShadow>()
+    for (i in 0..<shadows.size()) {
+      shadowStyles.add(checkNotNull(BoxShadow.parse(shadows.getMap(i))))
+    }
+    BackgroundStyleApplicator.setBoxShadow(view, shadowStyles)
+  }
+
+  @JvmStatic
+  public fun setFeedbackUnderlay(view: View, drawable: Drawable?): Unit {
+    view.background = ensureCompositeBackgroundDrawable(view).withNewFeedbackUnderlay(drawable)
+  }
+
+  @JvmStatic
+  public fun clipToPaddingBox(view: View, canvas: Canvas): Unit {
+    // The canvas may be scrolled, so we need to offset
+    val drawingRect = Rect()
+    view.getDrawingRect(drawingRect)
+
+    val cssBackground = getCSSBackground(view)
+    if (cssBackground == null) {
+      canvas.clipRect(drawingRect)
+      return
+    }
+
+    val paddingBoxPath = cssBackground.paddingBoxPath
+    if (paddingBoxPath != null) {
+      paddingBoxPath.offset(drawingRect.left.toFloat(), drawingRect.top.toFloat())
+      canvas.clipPath(paddingBoxPath)
+    } else {
+      val paddingBoxRect = cssBackground.paddingBoxRect
+      paddingBoxRect.offset(drawingRect.left.toFloat(), drawingRect.top.toFloat())
+      canvas.clipRect(paddingBoxRect)
+    }
+  }
+
+  @JvmStatic
+  public fun reset(view: View): Unit {
+    if (view.background is CompositeBackgroundDrawable) {
+      view.background = (view.background as CompositeBackgroundDrawable).originalBackground
+    }
+  }
+
+  private fun ensureCompositeBackgroundDrawable(view: View): CompositeBackgroundDrawable {
+    if (view.background is CompositeBackgroundDrawable) {
+      return view.background as CompositeBackgroundDrawable
+    }
+
+    val compositeDrawable = CompositeBackgroundDrawable(originalBackground = view.background)
+    view.background = compositeDrawable
+    return compositeDrawable
+  }
+
+  private fun getCompositeBackgroundDrawable(view: View): CompositeBackgroundDrawable? =
+      view.background as? CompositeBackgroundDrawable
+
+  private fun ensureCSSBackground(view: View): CSSBackgroundDrawable {
+    val compositeBackgroundDrawable = ensureCompositeBackgroundDrawable(view)
+    if (compositeBackgroundDrawable.cssBackground != null) {
+      return compositeBackgroundDrawable.cssBackground
+    } else {
+      val cssBackground = CSSBackgroundDrawable(view.context)
+      view.background = compositeBackgroundDrawable.withNewCssBackground(cssBackground)
+      return cssBackground
+    }
+  }
+
+  private fun getCSSBackground(view: View): CSSBackgroundDrawable? =
+      getCompositeBackgroundDrawable(view)?.cssBackground
+}

package/ReactAndroid/src/main/java/com/facebook/react/uimanager/BaseViewManager.java

@@ -29,15 +29,16 @@ import com.facebook.react.common.MapBuilder;
 import com.facebook.react.common.ReactConstants;
 import com.facebook.react.uimanager.ReactAccessibilityDelegate.AccessibilityRole;
 import com.facebook.react.uimanager.ReactAccessibilityDelegate.Role;
+import com.facebook.react.uimanager.annotations.ReactProp;
 import com.facebook.react.uimanager.common.UIManagerType;
 import com.facebook.react.uimanager.common.ViewUtil;
-import com.facebook.react.uimanager.annotations.ReactProp;
 import com.facebook.react.uimanager.events.PointerEventHelper;
 import com.facebook.react.uimanager.util.ReactFindViewUtil;
 import java.util.ArrayList;
 import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
+import java.util.Objects;
 
 /**
  * Base class that should be suitable for the majority of subclasses of {@link ViewManager}. It
@@ -67,7 +68,7 @@ public abstract class BaseViewManager<T extends View, C extends LayoutShadowNode
   }
 
   @Override
-  protected T prepareToRecycleView(@NonNull ThemedReactContext reactContext, T view) {
+  protected @Nullable T prepareToRecycleView(@NonNull ThemedReactContext reactContext, T view) {
     // Reset tags
     view.setTag(null);
     view.setTag(R.id.pointer_events, null);
@@ -94,13 +95,21 @@ public abstract class BaseViewManager<T extends View, C extends LayoutShadowNode
     setTransformProperty(view, null, null);
 
     // RenderNode params not covered by setTransformProperty above
-    view.resetPivot();
+    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.P) {
+      view.resetPivot();
+    } else {
+      // no way of resetting pivot, or knowing whether it is set
+      return null;
+    }
     view.setTop(0);
     view.setBottom(0);
     view.setLeft(0);
     view.setRight(0);
     view.setElevation(0);
-    view.setAnimationMatrix(null);
+    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.Q) {
+      // failsafe - should already be set to null when animation finishes
+      view.setAnimationMatrix(null);
+    }
 
     view.setTag(R.id.transform, null);
     view.setTag(R.id.transform_origin, null);
@@ -109,7 +118,8 @@ public abstract class BaseViewManager<T extends View, C extends LayoutShadowNode
 
     view.setTag(R.id.use_hardware_layer, null);
     view.setTag(R.id.filter, null);
-    applyFilter(view, null);
+    view.setTag(R.id.mix_blend_mode, null);
+    LayerEffectsHelper.apply(view, null, null);
 
     // setShadowColor
     if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.P) {
@@ -191,21 +201,38 @@ public abstract class BaseViewManager<T extends View, C extends LayoutShadowNode
   @Override
   @ReactProp(name = ViewProps.FILTER, customType = "Filter")
   public void setFilter(@NonNull T view, @Nullable ReadableArray filter) {
-    view.setTag(R.id.filter, filter);
+    if (ViewUtil.getUIManagerType(view) == UIManagerType.FABRIC) {
+      view.setTag(R.id.filter, filter);
+    }
+  }
+
+  @Override
+  @ReactProp(name = ViewProps.MIX_BLEND_MODE)
+  public void setMixBlendMode(@NonNull T view, @Nullable String mixBlendMode) {
+    if (ViewUtil.getUIManagerType(view) == UIManagerType.FABRIC) {
+      view.setTag(R.id.mix_blend_mode, BlendModeHelper.parseMixBlendMode(mixBlendMode));
+    }
   }
 
   @Override
   @ReactProp(name = ViewProps.TRANSFORM)
   public void setTransform(@NonNull T view, @Nullable ReadableArray matrix) {
-    view.setTag(R.id.transform, matrix);
-    view.setTag(R.id.invalidate_transform, true);
+    @Nullable ReadableArray currentTransform = (ReadableArray) view.getTag(R.id.transform);
+    if (!Objects.equals(currentTransform, matrix)) {
+      view.setTag(R.id.transform, matrix);
+      view.setTag(R.id.invalidate_transform, true);
+    }
   }
 
   @Override
   @ReactProp(name = ViewProps.TRANSFORM_ORIGIN)
   public void setTransformOrigin(@NonNull T view, @Nullable ReadableArray transformOrigin) {
-    view.setTag(R.id.transform_origin, transformOrigin);
-    view.setTag(R.id.invalidate_transform, true);
+    @Nullable
+    ReadableArray currentTransformOrigin = (ReadableArray) view.getTag(R.id.transform_origin);
+    if (!Objects.equals(currentTransformOrigin, transformOrigin)) {
+      view.setTag(R.id.transform_origin, transformOrigin);
+      view.setTag(R.id.invalidate_transform, true);
+    }
   }
 
   @Override
@@ -499,25 +526,33 @@ public abstract class BaseViewManager<T extends View, C extends LayoutShadowNode
     }
   }
 
-  private void applyFilter(@NonNull T view, @Nullable ReadableArray filter) {
-    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.S) {
-      view.setRenderEffect(null);
-    }
-    Boolean useHWLayer = (Boolean) view.getTag(R.id.use_hardware_layer);
-    int layerType =
-        useHWLayer != null && useHWLayer ? View.LAYER_TYPE_HARDWARE : View.LAYER_TYPE_NONE;
-    view.setLayerType(layerType, null);
+  // Extracting helper method to inner class to avoid reflection on older Android versions
+  // hitting the unknown BlendMode type
+  private static class LayerEffectsHelper {
+    public static void apply(
+        @NonNull View view, @Nullable ReadableArray filter, @Nullable Boolean useHWLayer) {
+      if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.S) {
+        view.setRenderEffect(null);
+      }
 
-    if (filter == null) {
-      return;
-    }
+      @Nullable Paint p = null;
 
-    if (FilterHelper.isOnlyColorMatrixFilters(filter)) {
-      Paint p = new Paint();
-      p.setColorFilter(FilterHelper.parseColorMatrixFilters(filter));
-      view.setLayerType(View.LAYER_TYPE_HARDWARE, p);
-    } else if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.S) {
-      view.setRenderEffect(FilterHelper.parseFilters(filter));
+      if (filter != null) {
+        if (FilterHelper.isOnlyColorMatrixFilters(filter)) {
+          p = new Paint();
+          p.setColorFilter(FilterHelper.parseColorMatrixFilters(filter));
+        } else if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.S) {
+          view.setRenderEffect(FilterHelper.parseFilters(filter));
+        }
+      }
+
+      if (p == null) {
+        int layerType =
+            useHWLayer != null && useHWLayer ? View.LAYER_TYPE_HARDWARE : View.LAYER_TYPE_NONE;
+        view.setLayerType(layerType, null);
+      } else {
+        view.setLayerType(View.LAYER_TYPE_HARDWARE, p);
+      }
     }
   }
 
@@ -630,13 +665,10 @@ public abstract class BaseViewManager<T extends View, C extends LayoutShadowNode
       view.setTag(R.id.invalidate_transform, false);
     }
 
+    ReadableArray filter = (ReadableArray) view.getTag(R.id.filter);
     Boolean useHWLayer = (Boolean) view.getTag(R.id.use_hardware_layer);
-    if (useHWLayer != null) {
-      view.setLayerType(useHWLayer ? View.LAYER_TYPE_HARDWARE : View.LAYER_TYPE_NONE, null);
-    }
 
-    ReadableArray filter = (ReadableArray) view.getTag(R.id.filter);
-    applyFilter(view, filter);
+    LayerEffectsHelper.apply(view, filter, useHWLayer);
   }
 
   @Override

package/ReactAndroid/src/main/java/com/facebook/react/uimanager/BaseViewManagerDelegate.kt

@@ -0,0 +1,109 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+package com.facebook.react.uimanager
+
+import android.view.View
+import com.facebook.react.bridge.ColorPropConverter
+import com.facebook.react.bridge.Dynamic
+import com.facebook.react.bridge.DynamicFromObject
+import com.facebook.react.bridge.ReadableArray
+import com.facebook.react.bridge.ReadableMap
+import com.facebook.yoga.YogaConstants
+
+/**
+ * This is a base implementation of [ViewManagerDelegate] which supports setting properties that
+ * every view should support, such as rotation, background color, etc.
+ */
+public abstract class BaseViewManagerDelegate<T : View, U : BaseViewManagerInterface<T>>(
+    @Suppress("NoHungarianNotation") @JvmField protected val mViewManager: U
+) : ViewManagerDelegate<T> {
+  override public fun setProperty(view: T, propName: String?, value: Any?) {
+    when (propName) {
+      ViewProps.ACCESSIBILITY_ACTIONS ->
+          mViewManager.setAccessibilityActions(view, value as ReadableArray?)
+
+      ViewProps.ACCESSIBILITY_HINT -> mViewManager.setAccessibilityHint(view, value as String?)
+      ViewProps.ACCESSIBILITY_LABEL -> mViewManager.setAccessibilityLabel(view, value as String?)
+      ViewProps.ACCESSIBILITY_LIVE_REGION ->
+          mViewManager.setAccessibilityLiveRegion(view, value as String?)
+
+      ViewProps.ACCESSIBILITY_ROLE -> mViewManager.setAccessibilityRole(view, value as String?)
+      ViewProps.ACCESSIBILITY_STATE -> mViewManager.setViewState(view, value as ReadableMap?)
+      ViewProps.ACCESSIBILITY_COLLECTION ->
+          mViewManager.setAccessibilityCollection(view, value as ReadableMap?)
+
+      ViewProps.ACCESSIBILITY_COLLECTION_ITEM ->
+          mViewManager.setAccessibilityCollectionItem(view, value as ReadableMap?)
+
+      ViewProps.BACKGROUND_COLOR ->
+          mViewManager.setBackgroundColor(
+              view, if (value == null) 0 else ColorPropConverter.getColor(value, view.context))
+
+      ViewProps.BORDER_RADIUS ->
+          mViewManager.setBorderRadius(
+              view, (value as Double?)?.toFloat() ?: YogaConstants.UNDEFINED)
+
+      ViewProps.BORDER_BOTTOM_LEFT_RADIUS ->
+          mViewManager.setBorderBottomLeftRadius(
+              view, (value as Double?)?.toFloat() ?: YogaConstants.UNDEFINED)
+
+      ViewProps.BORDER_BOTTOM_RIGHT_RADIUS ->
+          mViewManager.setBorderBottomRightRadius(
+              view, (value as Double?)?.toFloat() ?: YogaConstants.UNDEFINED)
+
+      ViewProps.BORDER_TOP_LEFT_RADIUS ->
+          mViewManager.setBorderTopLeftRadius(
+              view, (value as Double?)?.toFloat() ?: YogaConstants.UNDEFINED)
+
+      ViewProps.BORDER_TOP_RIGHT_RADIUS ->
+          mViewManager.setBorderTopRightRadius(
+              view, (value as Double?)?.toFloat() ?: YogaConstants.UNDEFINED)
+
+      ViewProps.ELEVATION -> mViewManager.setElevation(view, (value as Double?)?.toFloat() ?: 0.0f)
+
+      ViewProps.SHADOW_COLOR ->
+          mViewManager.setShadowColor(
+              view, if (value == null) 0 else ColorPropConverter.getColor(value, view.context))
+
+      ViewProps.IMPORTANT_FOR_ACCESSIBILITY ->
+          mViewManager.setImportantForAccessibility(view, value as String?)
+
+      ViewProps.ROLE -> mViewManager.setRole(view, value as String?)
+      ViewProps.NATIVE_ID -> mViewManager.setNativeId(view, value as String?)
+      ViewProps.ACCESSIBILITY_LABELLED_BY -> {
+        val dynamicFromObject: Dynamic = DynamicFromObject(value)
+        mViewManager.setAccessibilityLabelledBy(view, dynamicFromObject)
+      }
+
+      ViewProps.OPACITY -> mViewManager.setOpacity(view, (value as Double?)?.toFloat() ?: 1.0f)
+
+      ViewProps.RENDER_TO_HARDWARE_TEXTURE ->
+          mViewManager.setRenderToHardwareTexture(view, value as Boolean? ?: false)
+
+      ViewProps.ROTATION -> mViewManager.setRotation(view, (value as Double?)?.toFloat() ?: 0.0f)
+
+      ViewProps.SCALE_X -> mViewManager.setScaleX(view, (value as Double?)?.toFloat() ?: 1.0f)
+
+      ViewProps.SCALE_Y -> mViewManager.setScaleY(view, (value as Double?)?.toFloat() ?: 1.0f)
+
+      ViewProps.TEST_ID -> mViewManager.setTestId(view, value as String?)
+      ViewProps.TRANSFORM -> mViewManager.setTransform(view, value as ReadableArray?)
+      ViewProps.TRANSFORM_ORIGIN -> mViewManager.setTransformOrigin(view, value as ReadableArray?)
+      ViewProps.TRANSLATE_X ->
+          mViewManager.setTranslateX(view, (value as Double?)?.toFloat() ?: 0.0f)
+
+      ViewProps.TRANSLATE_Y ->
+          mViewManager.setTranslateY(view, (value as Double?)?.toFloat() ?: 0.0f)
+
+      ViewProps.Z_INDEX -> mViewManager.setZIndex(view, (value as Double?)?.toFloat() ?: 0.0f)
+    }
+  }
+
+  override public fun receiveCommand(view: T, commandName: String?, args: ReadableArray?): Unit =
+      Unit
+}

package/ReactAndroid/src/main/java/com/facebook/react/uimanager/BaseViewManagerInterface.kt

@@ -0,0 +1,85 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+package com.facebook.react.uimanager
+
+import android.view.View
+import com.facebook.react.bridge.Dynamic
+import com.facebook.react.bridge.ReadableArray
+import com.facebook.react.bridge.ReadableMap
+
+/**
+ * This is an interface that should be implemented by view managers supporting the base view
+ * properties such as backgroundColor, opacity, etc.
+ */
+public interface BaseViewManagerInterface<T : View> {
+  public fun setAccessibilityActions(view: T, accessibilityActions: ReadableArray?)
+
+  public fun setAccessibilityHint(view: T, accessibilityHint: String?)
+
+  public fun setAccessibilityLabel(view: T, accessibilityLabel: String?)
+
+  public fun setAccessibilityLiveRegion(view: T, liveRegion: String?)
+
+  public fun setAccessibilityRole(view: T, accessibilityRole: String?)
+
+  public fun setAccessibilityCollection(view: T, accessibilityCollection: ReadableMap?)
+
+  public fun setAccessibilityCollectionItem(view: T, accessibilityCollectionItem: ReadableMap?)
+
+  public fun setViewState(view: T, accessibilityState: ReadableMap?)
+
+  public fun setBackgroundColor(view: T, backgroundColor: Int)
+
+  public fun setBorderRadius(view: T, borderRadius: Float)
+
+  public fun setBorderBottomLeftRadius(view: T, borderRadius: Float)
+
+  public fun setBorderBottomRightRadius(view: T, borderRadius: Float)
+
+  public fun setBorderTopLeftRadius(view: T, borderRadius: Float)
+
+  public fun setBorderTopRightRadius(view: T, borderRadius: Float)
+
+  public fun setElevation(view: T, elevation: Float)
+
+  public fun setFilter(view: T, filter: ReadableArray)
+
+  public fun setMixBlendMode(view: T, setMixBlendMode: String)
+
+  public fun setShadowColor(view: T, shadowColor: Int)
+
+  public fun setImportantForAccessibility(view: T, importantForAccessibility: String?)
+
+  public fun setRole(view: T, role: String?)
+
+  public fun setNativeId(view: T, nativeId: String?)
+
+  public fun setAccessibilityLabelledBy(view: T, nativeId: Dynamic?)
+
+  public fun setOpacity(view: T, opacity: Float)
+
+  public fun setRenderToHardwareTexture(view: T, useHWTexture: Boolean)
+
+  public fun setRotation(view: T, rotation: Float)
+
+  public fun setScaleX(view: T, scaleX: Float)
+
+  public fun setScaleY(view: T, scaleY: Float)
+
+  public fun setTestId(view: T, testId: String?)
+
+  public fun setTransform(view: T, matrix: ReadableArray?)
+
+  public fun setTransformOrigin(view: T, transformOrigin: ReadableArray?)
+
+  public fun setTranslateX(view: T, translateX: Float)
+
+  public fun setTranslateY(view: T, translateY: Float)
+
+  public fun setZIndex(view: T, zIndex: Float)
+}

package/ReactAndroid/src/main/java/com/facebook/react/uimanager/BlendModeHelper.kt

@@ -0,0 +1,44 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+package com.facebook.react.uimanager
+
+import android.annotation.TargetApi
+import android.graphics.BlendMode
+import android.os.Build
+
+@TargetApi(29)
+internal object BlendModeHelper {
+
+  /** @see https://www.w3.org/TR/compositing-1/#mix-blend-mode */
+  @JvmStatic
+  public fun parseMixBlendMode(mixBlendMode: String?): BlendMode? {
+    if (mixBlendMode == null || Build.VERSION.SDK_INT < Build.VERSION_CODES.Q) {
+      return null
+    }
+
+    return when (mixBlendMode) {
+      "normal" -> null
+      "multiply" -> BlendMode.MULTIPLY
+      "screen" -> BlendMode.SCREEN
+      "overlay" -> BlendMode.OVERLAY
+      "darken" -> BlendMode.DARKEN
+      "lighten" -> BlendMode.LIGHTEN
+      "color-dodge" -> BlendMode.COLOR_DODGE
+      "color-burn" -> BlendMode.COLOR_BURN
+      "hard-light" -> BlendMode.HARD_LIGHT
+      "soft-light" -> BlendMode.SOFT_LIGHT
+      "difference" -> BlendMode.DIFFERENCE
+      "exclusion" -> BlendMode.EXCLUSION
+      "hue" -> BlendMode.HUE
+      "saturation" -> BlendMode.SATURATION
+      "color" -> BlendMode.COLOR
+      "luminosity" -> BlendMode.LUMINOSITY
+      else -> throw IllegalArgumentException("Invalid mix-blend-mode name: $mixBlendMode")
+    }
+  }
+}