react-native-tvos 0.75.2-0rc0 → 0.76.0-0rc0

package/ReactAndroid/src/main/java/com/facebook/react/uimanager/events/FabricEventDispatcher.java

@@ -7,6 +7,7 @@
 
 package com.facebook.react.uimanager.events;
 
+import android.os.Handler;
 import android.view.Choreographer;
 import com.facebook.infer.annotation.Nullsafe;
 import com.facebook.react.bridge.LifecycleEventListener;
@@ -15,6 +16,7 @@ import com.facebook.react.bridge.ReactNoCrashSoftException;
 import com.facebook.react.bridge.ReactSoftExceptionLogger;
 import com.facebook.react.bridge.UIManager;
 import com.facebook.react.bridge.UiThreadUtil;
+import com.facebook.react.internal.featureflags.ReactNativeFeatureFlags;
 import com.facebook.react.modules.core.ReactChoreographer;
 import com.facebook.react.uimanager.UIManagerHelper;
 import com.facebook.react.uimanager.common.UIManagerType;
@@ -27,6 +29,8 @@ import java.util.concurrent.CopyOnWriteArrayList;
  */
 @Nullsafe(Nullsafe.Mode.LOCAL)
 public class FabricEventDispatcher implements EventDispatcher, LifecycleEventListener {
+  private static final Handler uiThreadHandler = UiThreadUtil.getUiThreadHandler();
+
   private final ReactEventEmitter mReactEventEmitter;
   private final ReactApplicationContext mReactContext;
   private final CopyOnWriteArrayList<EventDispatcherListener> mListeners =
@@ -36,6 +40,25 @@ public class FabricEventDispatcher implements EventDispatcher, LifecycleEventLis
   private final FabricEventDispatcher.ScheduleDispatchFrameCallback mCurrentFrameCallback =
       new FabricEventDispatcher.ScheduleDispatchFrameCallback();
 
+  private boolean mIsDispatchScheduled = false;
+  private final Runnable mDispatchEventsRunnable =
+      new Runnable() {
+        @Override
+        public void run() {
+          mIsDispatchScheduled = false;
+
+          Systrace.beginSection(
+              Systrace.TRACE_TAG_REACT_JAVA_BRIDGE, "BatchEventDispatchedListeners");
+          try {
+            for (BatchEventDispatchedListener listener : mPostEventDispatchListeners) {
+              listener.onBatchEventDispatched();
+            }
+          } finally {
+            Systrace.endSection(Systrace.TRACE_TAG_REACT_JAVA_BRIDGE);
+          }
+        }
+      };
+
   public FabricEventDispatcher(ReactApplicationContext reactContext) {
     mReactContext = reactContext;
     mReactContext.addLifecycleEventListener(this);
@@ -54,7 +77,7 @@ public class FabricEventDispatcher implements EventDispatcher, LifecycleEventLis
     }
 
     event.dispose();
-    maybePostFrameCallbackFromNonUI();
+    scheduleDispatchOfBatchedEvents();
   }
 
   private void dispatchSynchronous(Event event) {
@@ -85,19 +108,17 @@ public class FabricEventDispatcher implements EventDispatcher, LifecycleEventLis
   }
 
   public void dispatchAllEvents() {
-    maybePostFrameCallbackFromNonUI();
+    scheduleDispatchOfBatchedEvents();
   }
 
-  private void maybePostFrameCallbackFromNonUI() {
-    if (mReactEventEmitter != null) {
-      // If the host activity is paused, the frame callback may not be currently
-      // posted. Ensure that it is so that this event gets delivered promptly.
-      mCurrentFrameCallback.maybePostFromNonUI();
+  private void scheduleDispatchOfBatchedEvents() {
+    if (ReactNativeFeatureFlags.useOptimizedEventBatchingOnAndroid()) {
+      if (!mIsDispatchScheduled) {
+        mIsDispatchScheduled = true;
+        uiThreadHandler.postAtFrontOfQueue(mDispatchEventsRunnable);
+      }
     } else {
-      // No JS application has started yet, or resumed. This can happen when a ReactRootView is
-      // added to view hierarchy, but ReactContext creation has not completed yet. In this case, any
-      // touch event dispatch will hit this codepath, and we simply queue them so that they
-      // are dispatched once ReactContext creation completes and JS app is running.
+      mCurrentFrameCallback.maybeScheduleDispatchOfBatchedEvents();
     }
   }
 
@@ -121,17 +142,17 @@ public class FabricEventDispatcher implements EventDispatcher, LifecycleEventLis
 
   @Override
   public void onHostResume() {
-    maybePostFrameCallbackFromNonUI();
+    scheduleDispatchOfBatchedEvents();
   }
 
   @Override
   public void onHostPause() {
-    stopFrameCallback();
+    cancelDispatchOfBatchedEvents();
   }
 
   @Override
   public void onHostDestroy() {
-    stopFrameCallback();
+    cancelDispatchOfBatchedEvents();
   }
 
   public void onCatalystInstanceDestroyed() {
@@ -139,14 +160,19 @@ public class FabricEventDispatcher implements EventDispatcher, LifecycleEventLis
         new Runnable() {
           @Override
           public void run() {
-            stopFrameCallback();
+            cancelDispatchOfBatchedEvents();
           }
         });
   }
 
-  private void stopFrameCallback() {
+  private void cancelDispatchOfBatchedEvents() {
     UiThreadUtil.assertOnUiThread();
-    mCurrentFrameCallback.stop();
+    if (ReactNativeFeatureFlags.useOptimizedEventBatchingOnAndroid()) {
+      mIsDispatchScheduled = false;
+      uiThreadHandler.removeCallbacks(mDispatchEventsRunnable);
+    } else {
+      mCurrentFrameCallback.stop();
+    }
   }
 
   public void registerEventEmitter(@UIManagerType int uiManagerType, RCTEventEmitter eventEmitter) {
@@ -163,7 +189,7 @@ public class FabricEventDispatcher implements EventDispatcher, LifecycleEventLis
   }
 
   private class ScheduleDispatchFrameCallback implements Choreographer.FrameCallback {
-    private volatile boolean mIsPosted = false;
+    private volatile boolean mIsDispatchScheduled = false;
     private boolean mShouldStop = false;
 
     @Override
@@ -171,9 +197,9 @@ public class FabricEventDispatcher implements EventDispatcher, LifecycleEventLis
       UiThreadUtil.assertOnUiThread();
 
       if (mShouldStop) {
-        mIsPosted = false;
+        mIsDispatchScheduled = false;
       } else {
-        post();
+        dispatchBatchedEvents();
       }
 
       Systrace.beginSection(Systrace.TRACE_TAG_REACT_JAVA_BRIDGE, "BatchEventDispatchedListeners");
@@ -190,32 +216,32 @@ public class FabricEventDispatcher implements EventDispatcher, LifecycleEventLis
       mShouldStop = true;
     }
 
-    public void maybePost() {
-      if (!mIsPosted) {
-        mIsPosted = true;
-        post();
+    public void maybeDispatchBatchedEvents() {
+      if (!mIsDispatchScheduled) {
+        mIsDispatchScheduled = true;
+        dispatchBatchedEvents();
       }
     }
 
-    private void post() {
+    private void dispatchBatchedEvents() {
       ReactChoreographer.getInstance()
           .postFrameCallback(ReactChoreographer.CallbackType.TIMERS_EVENTS, mCurrentFrameCallback);
     }
 
-    public void maybePostFromNonUI() {
-      if (mIsPosted) {
+    public void maybeScheduleDispatchOfBatchedEvents() {
+      if (mIsDispatchScheduled) {
         return;
       }
 
       // We should only hit this slow path when we receive events while the host activity is paused.
       if (mReactContext.isOnUiQueueThread()) {
-        maybePost();
+        maybeDispatchBatchedEvents();
       } else {
         mReactContext.runOnUiQueueThread(
             new Runnable() {
               @Override
               public void run() {
-                maybePost();
+                maybeDispatchBatchedEvents();
               }
             });
       }

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

@@ -0,0 +1,48 @@
+/*
+ * 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.layoutanimation
+
+import android.view.animation.Interpolator
+import com.facebook.react.bridge.ReadableMap
+import com.facebook.react.bridge.ReadableType
+import com.facebook.react.bridge.ReadableType.Number
+
+/** Simple spring interpolator */
+// TODO(7613736): Improve spring interpolator with friction and damping variable support
+/* package */
+internal class SimpleSpringInterpolator : Interpolator {
+  private val _springDamping: Float
+
+  @JvmOverloads
+  public constructor(springDamping: Float = FACTOR) {
+    _springDamping = springDamping
+  }
+
+  override public fun getInterpolation(input: Float): Float =
+      // Using mSpringDamping in this equation is not really the exact mathematical springDamping,
+      // but a good approximation
+      // We need to replace this equation with the right Factor that accounts for damping and
+      // friction
+      (1 +
+              Math.pow(2.0, (-10 * input).toDouble()) *
+                  Math.sin((input - _springDamping / 4) * Math.PI * 2 / _springDamping))
+          .toFloat()
+
+  public companion object {
+    private const val FACTOR = 0.5f
+    public const val PARAM_SPRING_DAMPING: String = "springDamping"
+
+    @JvmStatic
+    public fun getSpringDamping(params: ReadableMap): Float =
+        if (params.getType(PARAM_SPRING_DAMPING) == ReadableType.Number) {
+          params.getDouble(PARAM_SPRING_DAMPING).toFloat()
+        } else {
+          FACTOR
+        }
+  }
+}

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

@@ -0,0 +1,28 @@
+/*
+ * 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.style
+
+import android.graphics.Rect
+import android.graphics.Shader
+import com.facebook.react.bridge.ReadableMap
+
+public class BackgroundImageLayer(gradientMap: ReadableMap?) {
+  private val gradient: Gradient? =
+      if (gradientMap != null) {
+        try {
+          Gradient(gradientMap)
+        } catch (e: IllegalArgumentException) {
+          // Gracefully reject invalid styles
+          null
+        }
+      } else {
+        null
+      }
+
+  public fun getShader(bounds: Rect): Shader? = gradient?.getShader(bounds)
+}

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

@@ -0,0 +1,105 @@
+/*
+ * 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.style
+
+import android.content.Context
+import android.graphics.RectF
+import android.util.LayoutDirection
+import com.facebook.react.modules.i18nmanager.I18nUtil
+
+/** Represents the insets from border pox to padding box (i.e. border widths) */
+internal class BorderInsets {
+  private val edgeInsets = arrayOfNulls<Float?>(LogicalEdge.values().size)
+
+  public fun setBorderWidth(edge: LogicalEdge, width: Float?) {
+    edgeInsets[edge.ordinal] = width
+  }
+
+  public fun resolve(
+      layoutDirection: Int,
+      context: Context,
+  ): RectF {
+    return when (layoutDirection) {
+      LayoutDirection.LTR ->
+          RectF(
+              edgeInsets[LogicalEdge.START.ordinal]
+                  ?: edgeInsets[LogicalEdge.LEFT.ordinal]
+                  ?: edgeInsets[LogicalEdge.HORIZONTAL.ordinal]
+                  ?: edgeInsets[LogicalEdge.ALL.ordinal]
+                  ?: 0f,
+              edgeInsets[LogicalEdge.BLOCK_START.ordinal]
+                  ?: edgeInsets[LogicalEdge.TOP.ordinal]
+                  ?: edgeInsets[LogicalEdge.BLOCK.ordinal]
+                  ?: edgeInsets[LogicalEdge.VERTICAL.ordinal]
+                  ?: edgeInsets[LogicalEdge.ALL.ordinal]
+                  ?: 0f,
+              edgeInsets[LogicalEdge.END.ordinal]
+                  ?: edgeInsets[LogicalEdge.RIGHT.ordinal]
+                  ?: edgeInsets[LogicalEdge.HORIZONTAL.ordinal]
+                  ?: edgeInsets[LogicalEdge.ALL.ordinal]
+                  ?: 0f,
+              edgeInsets[LogicalEdge.BLOCK_END.ordinal]
+                  ?: edgeInsets[LogicalEdge.BOTTOM.ordinal]
+                  ?: edgeInsets[LogicalEdge.BLOCK.ordinal]
+                  ?: edgeInsets[LogicalEdge.VERTICAL.ordinal]
+                  ?: edgeInsets[LogicalEdge.ALL.ordinal]
+                  ?: 0f)
+      LayoutDirection.RTL ->
+          if (I18nUtil.instance.doLeftAndRightSwapInRTL(context)) {
+            RectF(
+                edgeInsets[LogicalEdge.END.ordinal]
+                    ?: edgeInsets[LogicalEdge.RIGHT.ordinal]
+                    ?: edgeInsets[LogicalEdge.HORIZONTAL.ordinal]
+                    ?: edgeInsets[LogicalEdge.ALL.ordinal]
+                    ?: 0f,
+                edgeInsets[LogicalEdge.BLOCK_START.ordinal]
+                    ?: edgeInsets[LogicalEdge.TOP.ordinal]
+                    ?: edgeInsets[LogicalEdge.BLOCK.ordinal]
+                    ?: edgeInsets[LogicalEdge.VERTICAL.ordinal]
+                    ?: edgeInsets[LogicalEdge.ALL.ordinal]
+                    ?: 0f,
+                edgeInsets[LogicalEdge.START.ordinal]
+                    ?: edgeInsets[LogicalEdge.LEFT.ordinal]
+                    ?: edgeInsets[LogicalEdge.HORIZONTAL.ordinal]
+                    ?: edgeInsets[LogicalEdge.ALL.ordinal]
+                    ?: 0f,
+                edgeInsets[LogicalEdge.BLOCK_END.ordinal]
+                    ?: edgeInsets[LogicalEdge.BOTTOM.ordinal]
+                    ?: edgeInsets[LogicalEdge.BLOCK.ordinal]
+                    ?: edgeInsets[LogicalEdge.VERTICAL.ordinal]
+                    ?: edgeInsets[LogicalEdge.ALL.ordinal]
+                    ?: 0f)
+          } else {
+            RectF(
+                edgeInsets[LogicalEdge.END.ordinal]
+                    ?: edgeInsets[LogicalEdge.LEFT.ordinal]
+                    ?: edgeInsets[LogicalEdge.HORIZONTAL.ordinal]
+                    ?: edgeInsets[LogicalEdge.ALL.ordinal]
+                    ?: 0f,
+                edgeInsets[LogicalEdge.BLOCK_START.ordinal]
+                    ?: edgeInsets[LogicalEdge.TOP.ordinal]
+                    ?: edgeInsets[LogicalEdge.BLOCK.ordinal]
+                    ?: edgeInsets[LogicalEdge.VERTICAL.ordinal]
+                    ?: edgeInsets[LogicalEdge.ALL.ordinal]
+                    ?: 0f,
+                edgeInsets[LogicalEdge.START.ordinal]
+                    ?: edgeInsets[LogicalEdge.RIGHT.ordinal]
+                    ?: edgeInsets[LogicalEdge.HORIZONTAL.ordinal]
+                    ?: edgeInsets[LogicalEdge.ALL.ordinal]
+                    ?: 0f,
+                edgeInsets[LogicalEdge.BLOCK_END.ordinal]
+                    ?: edgeInsets[LogicalEdge.BOTTOM.ordinal]
+                    ?: edgeInsets[LogicalEdge.BLOCK.ordinal]
+                    ?: edgeInsets[LogicalEdge.VERTICAL.ordinal]
+                    ?: edgeInsets[LogicalEdge.ALL.ordinal]
+                    ?: 0f)
+          }
+      else -> throw IllegalArgumentException("Expected resolved layout direction")
+    }
+  }
+}

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

@@ -107,37 +107,52 @@ public data class BorderRadiusStyle(
       width: Float,
       height: Float,
   ): ComputedBorderRadius {
+    val zeroRadii: CornerRadii = CornerRadii(0f, 0f)
+
     return when (layoutDirection) {
       LayoutDirection.LTR ->
           ComputedBorderRadius(
               topLeft =
-                  (startStart ?: topStart ?: topLeft ?: uniform)?.resolve(width, height) ?: 0f,
-              topRight = (endStart ?: topEnd ?: topRight ?: uniform)?.resolve(width, height) ?: 0f,
+                  (startStart ?: topStart ?: topLeft ?: uniform)?.resolve(width, height)
+                      ?: zeroRadii,
+              topRight =
+                  (endStart ?: topEnd ?: topRight ?: uniform)?.resolve(width, height) ?: zeroRadii,
               bottomLeft =
-                  (startEnd ?: bottomStart ?: bottomLeft ?: uniform)?.resolve(width, height) ?: 0f,
+                  (startEnd ?: bottomStart ?: bottomLeft ?: uniform)?.resolve(width, height)
+                      ?: zeroRadii,
               bottomRight =
-                  (endEnd ?: bottomEnd ?: bottomRight ?: uniform)?.resolve(width, height) ?: 0f,
+                  (endEnd ?: bottomEnd ?: bottomRight ?: uniform)?.resolve(width, height)
+                      ?: zeroRadii,
           )
       LayoutDirection.RTL ->
           if (I18nUtil.instance.doLeftAndRightSwapInRTL(context)) {
             ComputedBorderRadius(
-                topLeft = (endStart ?: topEnd ?: topRight ?: uniform)?.resolve(width, height) ?: 0f,
+                topLeft =
+                    (endStart ?: topEnd ?: topRight ?: uniform)?.resolve(width, height)
+                        ?: zeroRadii,
                 topRight =
-                    (startStart ?: topStart ?: topLeft ?: uniform)?.resolve(width, height) ?: 0f,
+                    (startStart ?: topStart ?: topLeft ?: uniform)?.resolve(width, height)
+                        ?: zeroRadii,
                 bottomLeft =
-                    (endEnd ?: bottomStart ?: bottomRight ?: uniform)?.resolve(width, height) ?: 0f,
+                    (endEnd ?: bottomStart ?: bottomRight ?: uniform)?.resolve(width, height)
+                        ?: zeroRadii,
                 bottomRight =
-                    (startEnd ?: bottomEnd ?: bottomLeft ?: uniform)?.resolve(width, height) ?: 0f,
+                    (startEnd ?: bottomEnd ?: bottomLeft ?: uniform)?.resolve(width, height)
+                        ?: zeroRadii,
             )
           } else {
             ComputedBorderRadius(
-                topLeft = (endStart ?: topEnd ?: topLeft ?: uniform)?.resolve(width, height) ?: 0f,
+                topLeft =
+                    (endStart ?: topEnd ?: topLeft ?: uniform)?.resolve(width, height) ?: zeroRadii,
                 topRight =
-                    (startStart ?: topStart ?: topRight ?: uniform)?.resolve(width, height) ?: 0f,
+                    (startStart ?: topStart ?: topRight ?: uniform)?.resolve(width, height)
+                        ?: zeroRadii,
                 bottomLeft =
-                    (endEnd ?: bottomStart ?: bottomLeft ?: uniform)?.resolve(width, height) ?: 0f,
+                    (endEnd ?: bottomStart ?: bottomLeft ?: uniform)?.resolve(width, height)
+                        ?: zeroRadii,
                 bottomRight =
-                    (startEnd ?: bottomEnd ?: bottomRight ?: uniform)?.resolve(width, height) ?: 0f,
+                    (startEnd ?: bottomEnd ?: bottomRight ?: uniform)?.resolve(width, height)
+                        ?: zeroRadii,
             )
           }
       else -> throw IllegalArgumentException("Expected?.resolved layout direction")

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

@@ -0,0 +1,26 @@
+/*
+ * 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.style
+
+public enum class BorderStyle {
+  SOLID,
+  DASHED,
+  DOTTED;
+
+  public companion object {
+    @JvmStatic
+    public fun fromString(borderStyle: String): BorderStyle? {
+      return when (borderStyle.lowercase()) {
+        "solid" -> SOLID
+        "dashed" -> DASHED
+        "dotted" -> DOTTED
+        else -> null
+      }
+    }
+  }
+}

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

@@ -0,0 +1,50 @@
+/*
+ * 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.style
+
+import androidx.annotation.ColorInt
+import com.facebook.react.bridge.ReadableMap
+
+/** Represents all logical properties and shorthands for border radius. */
+public data class BoxShadow(
+    val offsetX: Float,
+    val offsetY: Float,
+    @ColorInt val color: Int? = null,
+    val blurRadius: Float? = null,
+    val spreadDistance: Float? = null,
+    val inset: Boolean? = null,
+) {
+  public companion object {
+    @JvmStatic
+    public fun parse(boxShadow: ReadableMap): BoxShadow? {
+      if (!(boxShadow.hasKey("offsetX") && boxShadow.hasKey("offsetY"))) {
+        return null
+      }
+
+      val offsetX = boxShadow.getDouble("offsetX").toFloat()
+      val offsetY = boxShadow.getDouble("offsetY").toFloat()
+
+      val color = if (boxShadow.hasKey("color")) boxShadow.getInt("color") else null
+      val blurRadius =
+          if (boxShadow.hasKey("blurRadius")) boxShadow.getDouble("blurRadius").toFloat() else null
+      val spreadDistance =
+          if (boxShadow.hasKey("spreadDistance")) boxShadow.getDouble("spreadDistance").toFloat()
+          else null
+      val inset = if (boxShadow.hasKey("inset")) boxShadow.getBoolean("inset") else null
+
+      return BoxShadow(
+          offsetX = offsetX,
+          offsetY = offsetY,
+          color = color,
+          blurRadius = blurRadius,
+          spreadDistance = spreadDistance,
+          inset = inset,
+      )
+    }
+  }
+}

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

@@ -7,16 +7,40 @@
 
 package com.facebook.react.uimanager.style
 
+/** Represents the collection of possible computed border radius style properties. */
+public enum class ComputedBorderRadiusProp {
+  COMPUTED_BORDER_TOP_LEFT_RADIUS,
+  COMPUTED_BORDER_TOP_RIGHT_RADIUS,
+  COMPUTED_BORDER_BOTTOM_RIGHT_RADIUS,
+  COMPUTED_BORDER_BOTTOM_LEFT_RADIUS,
+}
+
 /** Phsysical edge lengths (in DIPs) for a border-radius. */
 public data class ComputedBorderRadius(
-    val topLeft: Float,
-    val topRight: Float,
-    val bottomLeft: Float,
-    val bottomRight: Float,
+    val topLeft: CornerRadii,
+    val topRight: CornerRadii,
+    val bottomLeft: CornerRadii,
+    val bottomRight: CornerRadii,
 ) {
   public fun hasRoundedBorders(): Boolean {
-    return topLeft > 0f || topRight > 0f || bottomLeft > 0f || bottomRight > 0f
+    return topLeft.horizontal > 0f ||
+        topLeft.vertical > 0f ||
+        topRight.horizontal > 0f ||
+        topRight.vertical > 0f ||
+        bottomLeft.horizontal > 0f ||
+        bottomLeft.vertical > 0f ||
+        bottomRight.horizontal > 0f
+  }
+
+  public fun get(property: ComputedBorderRadiusProp): CornerRadii {
+    return when (property) {
+      ComputedBorderRadiusProp.COMPUTED_BORDER_TOP_LEFT_RADIUS -> topLeft
+      ComputedBorderRadiusProp.COMPUTED_BORDER_TOP_RIGHT_RADIUS -> topRight
+      ComputedBorderRadiusProp.COMPUTED_BORDER_BOTTOM_LEFT_RADIUS -> bottomLeft
+      ComputedBorderRadiusProp.COMPUTED_BORDER_BOTTOM_RIGHT_RADIUS -> bottomRight
+    }
   }
 
-  public constructor() : this(0f, 0f, 0f, 0f)
+  public constructor() :
+      this(CornerRadii(0f, 0f), CornerRadii(0f, 0f), CornerRadii(0f, 0f), CornerRadii(0f, 0f))
 }

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

@@ -0,0 +1,19 @@
+/*
+ * 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.style
+
+import com.facebook.react.uimanager.PixelUtil
+
+public data class CornerRadii(
+    val horizontal: Float = 0f,
+    val vertical: Float = 0f,
+) {
+  public fun toPixelFromDIP(): CornerRadii {
+    return CornerRadii(PixelUtil.toPixelFromDIP(horizontal), PixelUtil.toPixelFromDIP(vertical))
+  }
+}

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

@@ -0,0 +1,76 @@
+/*
+ * 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.style
+
+import android.graphics.LinearGradient
+import android.graphics.Rect
+import android.graphics.Shader
+import com.facebook.react.bridge.ReadableMap
+
+public class Gradient(gradient: ReadableMap?) {
+  private enum class GradientType {
+    LINEAR_GRADIENT
+  }
+
+  private val type: GradientType
+  private var startX: Float = 0f
+  private var startY: Float = 0f
+  private var endX: Float = 0f
+  private var endY: Float = 0f
+  private val colors: IntArray
+  private val positions: FloatArray
+
+  init {
+    gradient ?: throw IllegalArgumentException("Gradient cannot be null")
+
+    val typeString = gradient.getString("type")
+    type =
+        when (typeString) {
+          "linearGradient" -> GradientType.LINEAR_GRADIENT
+          else -> throw IllegalArgumentException("Unsupported gradient type: $typeString")
+        }
+
+    gradient.getMap("start")?.let { start ->
+      startX = start.getDouble("x").toFloat()
+      startY = start.getDouble("y").toFloat()
+    }
+
+    gradient.getMap("end")?.let { end ->
+      endX = end.getDouble("x").toFloat()
+      endY = end.getDouble("y").toFloat()
+    }
+
+    val colorStops =
+        gradient.getArray("colorStops")
+            ?: throw IllegalArgumentException("Invalid colorStops array")
+
+    val size = colorStops.size()
+    colors = IntArray(size)
+    positions = FloatArray(size)
+
+    for (i in 0 until size) {
+      val colorStop = colorStops.getMap(i)
+      colors[i] = colorStop.getInt("color")
+      positions[i] = colorStop.getDouble("position").toFloat()
+    }
+  }
+
+  public fun getShader(bounds: Rect): Shader? {
+    return when (type) {
+      GradientType.LINEAR_GRADIENT ->
+          LinearGradient(
+              startX * bounds.width(),
+              startY * bounds.height(),
+              endX * bounds.width(),
+              endY * bounds.height(),
+              colors,
+              positions,
+              Shader.TileMode.CLAMP)
+    }
+  }
+}