react-native-tvos 0.79.3-0 → 0.80.0-0

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

@@ -7,7 +7,10 @@
 
 package com.facebook.react.uimanager.layoutanimation
 
+import com.facebook.react.common.annotations.internal.LegacyArchitecture
+
 /** Interface for an animation type that takes care of updating the view layout. */
+@LegacyArchitecture
 internal interface LayoutHandlingAnimation {
   /**
    * Notifies the animation of a layout update in case one occurs during the animation. This avoids
@@ -20,4 +23,13 @@ internal interface LayoutHandlingAnimation {
    * @param height the new height value for the view
    */
   fun onLayoutUpdate(x: Int, y: Int, width: Int, height: Int)
+
+  /**
+   * Returns whether the animation is valid and should be used. Because layout animations generally
+   * hold {@link java.lang.ref.WeakReference<android.view.View>} objects, it's possible that the
+   * view has been garbage collected. In this case, the animation should not be used.
+   *
+   * @return true if the animation is valid and can be used, false otherwise
+   */
+  fun isValid(): Boolean
 }

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

@@ -10,14 +10,18 @@ package com.facebook.react.uimanager.layoutanimation
 import android.view.View
 import android.view.animation.Animation
 import android.view.animation.TranslateAnimation
+import com.facebook.react.common.annotations.internal.LegacyArchitecture
+import com.facebook.react.common.annotations.internal.LegacyArchitectureLogLevel
+import com.facebook.react.common.annotations.internal.LegacyArchitectureLogger
 
 /**
  * Class responsible for handling layout update animation, applied to view whenever a valid config
  * was supplied for the layout animation of UPDATE type.
  */
+@LegacyArchitecture
 internal class LayoutUpdateAnimation : AbstractLayoutAnimation() {
 
-  internal override fun isValid(): Boolean = mDurationMs > 0
+  internal override fun isValid(): Boolean = durationMs > 0
 
   internal override fun createAnimationImpl(
       view: View,
@@ -45,5 +49,10 @@ internal class LayoutUpdateAnimation : AbstractLayoutAnimation() {
     // We are currently not enabling translation GPU-accelerated animated, as it creates odd
     // artifacts with native react scrollview. This needs to be investigated.
     private const val USE_TRANSLATE_ANIMATION = false
+
+    init {
+      LegacyArchitectureLogger.assertLegacyArchitecture(
+          "LayoutUpdateAnimation", LegacyArchitectureLogLevel.WARNING)
+    }
   }
 }

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

@@ -0,0 +1,69 @@
+/*
+ * 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.View
+import android.view.animation.Animation
+import android.view.animation.Transformation
+import com.facebook.react.common.annotations.VisibleForTesting
+import com.facebook.react.common.annotations.internal.LegacyArchitecture
+import com.facebook.react.common.annotations.internal.LegacyArchitectureLogLevel
+import com.facebook.react.common.annotations.internal.LegacyArchitectureLogger
+import java.lang.ref.WeakReference
+
+/**
+ * Animation responsible for updating opacity of a view. It should ideally use hardware texture to
+ * optimize rendering performances.
+ */
+@LegacyArchitecture
+internal class OpacityAnimation(view: View, private val startOpacity: Float, endOpacity: Float) :
+    Animation() {
+  private val viewRef = WeakReference(view)
+  private val deltaOpacity = endOpacity - startOpacity
+
+  init {
+    setAnimationListener(OpacityAnimationListener(view))
+    LegacyArchitectureLogger.assertLegacyArchitecture(
+        "OpacityAnimation", LegacyArchitectureLogLevel.WARNING)
+  }
+
+  class OpacityAnimationListener(view: View) : Animation.AnimationListener {
+    private val viewRef = WeakReference(view)
+    private var layerTypeChanged = false
+
+    override fun onAnimationStart(animation: Animation) {
+      viewRef.get()?.let { view ->
+        if (view.hasOverlappingRendering() && view.layerType == View.LAYER_TYPE_NONE) {
+          layerTypeChanged = true
+          view.setLayerType(View.LAYER_TYPE_HARDWARE, null)
+        }
+      }
+    }
+
+    override fun onAnimationEnd(animation: Animation) {
+      viewRef.get()?.let { view ->
+        if (layerTypeChanged) {
+          view.setLayerType(View.LAYER_TYPE_NONE, null)
+        }
+      }
+    }
+
+    override fun onAnimationRepeat(animation: Animation) {
+      // do nothing
+    }
+  }
+
+  @VisibleForTesting
+  public override fun applyTransformation(interpolatedTime: Float, t: Transformation) {
+    viewRef.get()?.let { view -> view.alpha = startOpacity + deltaOpacity * interpolatedTime }
+  }
+
+  override fun willChangeBounds(): Boolean {
+    return false
+  }
+}

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

@@ -0,0 +1,87 @@
+/*
+ * 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.View
+import android.view.animation.Animation
+import android.view.animation.Transformation
+import com.facebook.react.common.annotations.internal.LegacyArchitecture
+import com.facebook.react.common.annotations.internal.LegacyArchitectureLogger
+import java.lang.ref.WeakReference
+
+/**
+ * Animation responsible for updating size and position of a view. We can't use scaling as view
+ * content may not necessarily stretch. As a result, this approach is inefficient because of layout
+ * passes occurring on every frame. What we might want to try to do instead is use a combined
+ * ScaleAnimation and TranslateAnimation.
+ */
+@LegacyArchitecture
+internal class PositionAndSizeAnimation(view: View, x: Int, y: Int, width: Int, height: Int) :
+    Animation(), LayoutHandlingAnimation {
+  private val viewRef = WeakReference(view)
+  private var startX = 0f
+  private var startY = 0f
+  private var deltaX = 0f
+  private var deltaY = 0f
+  private var startWidth = 0
+  private var startHeight = 0
+  private var deltaWidth = 0
+  private var deltaHeight = 0
+
+  init {
+    calculateAnimation(x, y, width, height)
+  }
+
+  override fun applyTransformation(interpolatedTime: Float, t: Transformation) {
+    viewRef.get()?.let { view ->
+      val newX = startX + deltaX * interpolatedTime
+      val newY = startY + deltaY * interpolatedTime
+      val newWidth = startWidth + deltaWidth * interpolatedTime
+      val newHeight = startHeight + deltaHeight * interpolatedTime
+      view.layout(
+          Math.round(newX),
+          Math.round(newY),
+          Math.round(newX + newWidth),
+          Math.round(newY + newHeight))
+    }
+  }
+
+  override fun onLayoutUpdate(x: Int, y: Int, width: Int, height: Int) {
+    // Layout changed during the animation, we should update our values so that the final layout
+    // is correct.
+    calculateAnimation(x, y, width, height)
+  }
+
+  override fun isValid(): Boolean {
+    return viewRef.get() != null
+  }
+
+  override fun willChangeBounds(): Boolean {
+    return true
+  }
+
+  private fun calculateAnimation(x: Int, y: Int, width: Int, height: Int) {
+    viewRef.get()?.let { view ->
+      startX = view.x - view.translationX
+      startY = view.y - view.translationY
+      startWidth = view.width
+      startHeight = view.height
+
+      deltaX = x - startX
+      deltaY = y - startY
+      deltaWidth = width - startWidth
+      deltaHeight = height - startHeight
+    }
+  }
+
+  private companion object {
+    init {
+      LegacyArchitectureLogger.assertLegacyArchitecture("PositionAndSizeAnimation")
+    }
+  }
+}

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

@@ -10,11 +10,13 @@ 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
+import com.facebook.react.common.annotations.internal.LegacyArchitecture
+import com.facebook.react.common.annotations.internal.LegacyArchitectureLogLevel
+import com.facebook.react.common.annotations.internal.LegacyArchitectureLogger
 
 /** Simple spring interpolator */
 // TODO(7613736): Improve spring interpolator with friction and damping variable support
-/* package */
+@LegacyArchitecture
 internal class SimpleSpringInterpolator : Interpolator {
   private val _springDamping: Float
 
@@ -34,6 +36,12 @@ internal class SimpleSpringInterpolator : Interpolator {
           .toFloat()
 
   companion object {
+
+    init {
+      LegacyArchitectureLogger.assertLegacyArchitecture(
+          "SimpleSpringInterpolator", LegacyArchitectureLogLevel.WARNING)
+    }
+
     private const val FACTOR = 0.5f
     const val PARAM_SPRING_DAMPING: String = "springDamping"
 

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

@@ -11,19 +11,37 @@ import android.content.Context
 import android.graphics.Rect
 import android.graphics.Shader
 import com.facebook.react.bridge.ReadableMap
+import com.facebook.react.bridge.ReadableType
 
-public class BackgroundImageLayer(gradientMap: ReadableMap?, context: Context) {
-  private val gradient: Gradient? =
-      if (gradientMap != null) {
-        try {
-          Gradient(gradientMap, context)
-        } catch (e: IllegalArgumentException) {
-          // Gracefully reject invalid styles
-          null
-        }
-      } else {
-        null
+public class BackgroundImageLayer() {
+  private lateinit var gradient: Gradient
+
+  private constructor(gradient: Gradient) : this() {
+    this.gradient = gradient
+  }
+
+  public companion object {
+    public fun parse(gradientMap: ReadableMap?, context: Context): BackgroundImageLayer? {
+      if (gradientMap == null) {
+        return null
+      }
+      val gradient = parseGradient(gradientMap, context) ?: return null
+      return BackgroundImageLayer(gradient)
+    }
+
+    private fun parseGradient(gradientMap: ReadableMap, context: Context): Gradient? {
+      if (!gradientMap.hasKey("type") || gradientMap.getType("type") != ReadableType.String) {
+        return null
+      }
+
+      return when (gradientMap.getString("type")) {
+        "linear-gradient" -> LinearGradient.parse(gradientMap, context)
+        "radial-gradient" -> RadialGradient.parse(gradientMap, context)
+        else -> null
       }
+    }
+  }
 
-  public fun getShader(bounds: Rect): Shader? = gradient?.getShader(bounds)
+  public fun getShader(bounds: Rect): Shader =
+      gradient.getShader(bounds.width().toFloat(), bounds.height().toFloat())
 }

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

@@ -113,16 +113,21 @@ internal data class BorderRadiusStyle(
       LayoutDirection.LTR ->
           ensureNoOverlap(
               topLeft =
-                  (startStart ?: topStart ?: topLeft ?: uniform)?.resolve(width, height)
-                      ?: zeroRadii,
+                  (startStart ?: topStart ?: topLeft ?: uniform)?.let {
+                    CornerRadii(it, width, height)
+                  } ?: zeroRadii,
               topRight =
-                  (endStart ?: topEnd ?: topRight ?: uniform)?.resolve(width, height) ?: zeroRadii,
+                  (endStart ?: topEnd ?: topRight ?: uniform)?.let {
+                    CornerRadii(it, width, height)
+                  } ?: zeroRadii,
               bottomLeft =
-                  (startEnd ?: bottomStart ?: bottomLeft ?: uniform)?.resolve(width, height)
-                      ?: zeroRadii,
+                  (startEnd ?: bottomStart ?: bottomLeft ?: uniform)?.let {
+                    CornerRadii(it, width, height)
+                  } ?: zeroRadii,
               bottomRight =
-                  (endEnd ?: bottomEnd ?: bottomRight ?: uniform)?.resolve(width, height)
-                      ?: zeroRadii,
+                  (endEnd ?: bottomEnd ?: bottomRight ?: uniform)?.let {
+                    CornerRadii(it, width, height)
+                  } ?: zeroRadii,
               width = width,
               height = height,
           )
@@ -130,33 +135,42 @@ internal data class BorderRadiusStyle(
           if (I18nUtil.instance.doLeftAndRightSwapInRTL(context)) {
             ensureNoOverlap(
                 topLeft =
-                    (endStart ?: topEnd ?: topRight ?: uniform)?.resolve(width, height)
-                        ?: zeroRadii,
+                    (endStart ?: topEnd ?: topRight ?: uniform)?.let {
+                      CornerRadii(it, width, height)
+                    } ?: zeroRadii,
                 topRight =
-                    (startStart ?: topStart ?: topLeft ?: uniform)?.resolve(width, height)
-                        ?: zeroRadii,
+                    (startStart ?: topStart ?: topLeft ?: uniform)?.let {
+                      CornerRadii(it, width, height)
+                    } ?: zeroRadii,
                 bottomLeft =
-                    (endEnd ?: bottomEnd ?: bottomRight ?: uniform)?.resolve(width, height)
-                        ?: zeroRadii,
+                    (endEnd ?: bottomEnd ?: bottomRight ?: uniform)?.let {
+                      CornerRadii(it, width, height)
+                    } ?: zeroRadii,
                 bottomRight =
-                    (startEnd ?: bottomStart ?: bottomLeft ?: uniform)?.resolve(width, height)
-                        ?: zeroRadii,
+                    (startEnd ?: bottomStart ?: bottomLeft ?: uniform)?.let {
+                      CornerRadii(it, width, height)
+                    } ?: zeroRadii,
                 width = width,
                 height = height,
             )
           } else {
             ensureNoOverlap(
                 topLeft =
-                    (endStart ?: topEnd ?: topLeft ?: uniform)?.resolve(width, height) ?: zeroRadii,
+                    (endStart ?: topEnd ?: topLeft ?: uniform)?.let {
+                      CornerRadii(it, width, height)
+                    } ?: zeroRadii,
                 topRight =
-                    (startStart ?: topStart ?: topRight ?: uniform)?.resolve(width, height)
-                        ?: zeroRadii,
+                    (startStart ?: topStart ?: topRight ?: uniform)?.let {
+                      CornerRadii(it, width, height)
+                    } ?: zeroRadii,
                 bottomLeft =
-                    (endEnd ?: bottomStart ?: bottomLeft ?: uniform)?.resolve(width, height)
-                        ?: zeroRadii,
+                    (endEnd ?: bottomStart ?: bottomLeft ?: uniform)?.let {
+                      CornerRadii(it, width, height)
+                    } ?: zeroRadii,
                 bottomRight =
-                    (startEnd ?: bottomEnd ?: bottomRight ?: uniform)?.resolve(width, height)
-                        ?: zeroRadii,
+                    (startEnd ?: bottomEnd ?: bottomRight ?: uniform)?.let {
+                      CornerRadii(it, width, height)
+                    } ?: zeroRadii,
                 width = width,
                 height = height,
             )

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

@@ -0,0 +1,206 @@
+/*
+ * 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.core.graphics.ColorUtils
+import com.facebook.react.uimanager.FloatUtil
+import com.facebook.react.uimanager.LengthPercentage
+import com.facebook.react.uimanager.LengthPercentageType
+import com.facebook.react.uimanager.PixelUtil
+import kotlin.math.ln
+
+// ColorStop type is passed by user, so color and position both could be null.
+// e.g.
+// color is null in transition hint syntax: (red, 20%, green)
+// position can be null too (red 20%, green, purple)
+internal class ColorStop(var color: Int? = null, val position: LengthPercentage? = null)
+
+// ProcessedColorStop type describes type after processing.
+// Here both types are nullable to keep it convenient for the color stop fix up algorithm.
+// Final Color stop will have both non-null, we check for non null after calling getFixedColorStop.
+internal class ProcessedColorStop(var color: Int? = null, val position: Float? = null)
+
+internal object ColorStopUtils {
+  public fun getFixedColorStops(
+      colorStops: List<ColorStop>,
+      gradientLineLength: Float
+  ): List<ProcessedColorStop> {
+    val fixedColorStops = Array<ProcessedColorStop>(colorStops.size) { ProcessedColorStop() }
+    var hasNullPositions = false
+    var maxPositionSoFar =
+        resolveColorStopPosition(colorStops[0].position, gradientLineLength) ?: 0f
+
+    for (i in colorStops.indices) {
+      val colorStop = colorStops[i]
+      var newPosition = resolveColorStopPosition(colorStop.position, gradientLineLength)
+
+      // Step 1:
+      // If the first color stop does not have a position,
+      // set its position to 0%. If the last color stop does not have a position,
+      // set its position to 100%.
+      newPosition =
+          newPosition
+              ?: when (i) {
+                0 -> 0f
+                colorStops.size - 1 -> 1f
+                else -> null
+              }
+
+      // Step 2:
+      // If a color stop or transition hint has a position
+      // that is less than the specified position of any color stop or transition hint
+      // before it in the list, set its position to be equal to the
+      // largest specified position of any color stop or transition hint before it.
+      if (newPosition != null) {
+        newPosition = maxOf(newPosition, maxPositionSoFar)
+        fixedColorStops[i] = ProcessedColorStop(colorStop.color, newPosition)
+        maxPositionSoFar = newPosition
+      } else {
+        hasNullPositions = true
+      }
+    }
+
+    // Step 3:
+    // If any color stop still does not have a position,
+    // then, for each run of adjacent color stops without positions,
+    // set their positions so that they are evenly spaced between the preceding and
+    // following color stops with positions.
+    if (hasNullPositions) {
+      var lastDefinedIndex = 0
+      for (i in 1 until fixedColorStops.size) {
+        val endPosition = fixedColorStops[i].position
+        val startPosition = fixedColorStops[lastDefinedIndex].position
+        val unpositionedStops = i - lastDefinedIndex - 1
+        if (endPosition != null && startPosition != null && unpositionedStops > 0) {
+          val increment = (endPosition - startPosition) / (unpositionedStops + 1)
+          for (j in 1..unpositionedStops) {
+            fixedColorStops[lastDefinedIndex + j] =
+                ProcessedColorStop(
+                    colorStops[lastDefinedIndex + j].color, startPosition + increment * j)
+          }
+          lastDefinedIndex = i
+        }
+      }
+    }
+
+    return processColorTransitionHints(fixedColorStops)
+  }
+
+  // Spec: https://drafts.csswg.org/css-images-4/#coloring-gradient-line (Refer transition hint
+  // section)
+  // Browsers add 9 intermediate color stops when a transition hint is present
+  // Algorithm is referred from Blink engine
+  // [source](https://github.com/chromium/chromium/blob/a296b1bad6dc1ed9d751b7528f7ca2134227b828/third_party/blink/renderer/core/css/css_gradient_value.cc#L240).
+  private fun processColorTransitionHints(
+      originalStops: Array<ProcessedColorStop>
+  ): List<ProcessedColorStop> {
+    val colorStops = originalStops.toMutableList()
+    var indexOffset = 0
+
+    for (i in 1 until originalStops.size - 1) {
+      // Skip if not a color hint
+      if (originalStops[i].color != null) {
+        continue
+      }
+
+      val x = i + indexOffset
+      if (x < 1) {
+        continue
+      }
+
+      val offsetLeft = colorStops[x - 1].position
+      val offsetRight = colorStops[x + 1].position
+      val offset = colorStops[x].position
+      if (offsetLeft == null || offsetRight == null || offset == null) {
+        continue
+      }
+      val leftDist = offset - offsetLeft
+      val rightDist = offsetRight - offset
+      val totalDist = offsetRight - offsetLeft
+      val leftColor = colorStops[x - 1].color
+      val rightColor = colorStops[x + 1].color
+
+      if (FloatUtil.floatsEqual(leftDist, rightDist)) {
+        colorStops.removeAt(x)
+        --indexOffset
+        continue
+      }
+
+      if (FloatUtil.floatsEqual(leftDist, 0f)) {
+        colorStops[x].color = rightColor
+        continue
+      }
+
+      if (FloatUtil.floatsEqual(rightDist, 0f)) {
+        colorStops[x].color = leftColor
+        continue
+      }
+
+      val newStops = ArrayList<ProcessedColorStop>(9)
+
+      // Position the new color stops
+      if (leftDist > rightDist) {
+        for (y in 0..6) {
+          newStops.add(ProcessedColorStop(null, offsetLeft + leftDist * ((7f + y) / 13f)))
+        }
+        newStops.add(ProcessedColorStop(null, offset + rightDist * (1f / 3f)))
+        newStops.add(ProcessedColorStop(null, offset + rightDist * (2f / 3f)))
+      } else {
+        newStops.add(ProcessedColorStop(null, offsetLeft + leftDist * (1f / 3f)))
+        newStops.add(ProcessedColorStop(null, offsetLeft + leftDist * (2f / 3f)))
+        for (y in 0..6) {
+          newStops.add(ProcessedColorStop(null, offset + rightDist * (y / 13f)))
+        }
+      }
+
+      // Calculate colors for the new stops
+      val hintRelativeOffset = leftDist / totalDist
+      val logRatio = ln(0.5) / ln(hintRelativeOffset)
+
+      for (newStop in newStops) {
+        if (newStop.position == null) {
+          continue
+        }
+        val pointRelativeOffset = (newStop.position - offsetLeft) / totalDist
+        val weighting = Math.pow(pointRelativeOffset.toDouble(), logRatio).toFloat()
+
+        if (!weighting.isFinite() || weighting.isNaN()) {
+          continue
+        }
+
+        // Interpolate color using the calculated weighting
+        leftColor?.let { left ->
+          rightColor?.let { right -> newStop.color = ColorUtils.blendARGB(left, right, weighting) }
+        }
+      }
+
+      // Replace the color hint with new color stops
+      colorStops.removeAt(x)
+      colorStops.addAll(x, newStops)
+      indexOffset += 8
+    }
+
+    return colorStops
+  }
+
+  private fun resolveColorStopPosition(
+      position: LengthPercentage?,
+      gradientLineLength: Float
+  ): Float? {
+    if (position == null) {
+      return null
+    }
+
+    return when (position.type) {
+      LengthPercentageType.POINT ->
+          PixelUtil.toPixelFromDIP(position.resolve(0f)) / gradientLineLength
+
+      LengthPercentageType.PERCENT -> position.resolve(1f)
+    }
+  }
+}

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

@@ -7,12 +7,20 @@
 
 package com.facebook.react.uimanager.style
 
+import com.facebook.react.uimanager.LengthPercentage
 import com.facebook.react.uimanager.PixelUtil
 
+/** Represents the resolved horizontal and vertical radii of the ellipse representing a corner. */
 public data class CornerRadii(
     val horizontal: Float = 0f,
     val vertical: Float = 0f,
 ) {
+  public constructor(
+      length: LengthPercentage,
+      referenceWidth: Float,
+      referenceHeight: Float
+  ) : this(horizontal = length.resolve(referenceWidth), vertical = length.resolve(referenceHeight))
+
   public fun toPixelFromDIP(): CornerRadii {
     return CornerRadii(PixelUtil.toPixelFromDIP(horizontal), PixelUtil.toPixelFromDIP(vertical))
   }

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

@@ -7,44 +7,8 @@
 
 package com.facebook.react.uimanager.style
 
-import android.content.Context
-import android.graphics.Rect
 import android.graphics.Shader
-import com.facebook.react.bridge.ReadableMap
 
-internal class Gradient(gradient: ReadableMap?, context: Context) {
-  private enum class GradientType {
-    LINEAR_GRADIENT
-  }
-
-  private val type: GradientType
-  private val linearGradient: LinearGradient
-
-  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")
-        }
-
-    val directionMap =
-        gradient.getMap("direction")
-            ?: throw IllegalArgumentException("Gradient must have direction")
-
-    val colorStops =
-        gradient.getArray("colorStops")
-            ?: throw IllegalArgumentException("Invalid colorStops array")
-
-    linearGradient = LinearGradient(directionMap, colorStops, context)
-  }
-
-  fun getShader(bounds: Rect): Shader? {
-    return when (type) {
-      GradientType.LINEAR_GRADIENT ->
-          linearGradient.getShader(bounds.width().toFloat(), bounds.height().toFloat())
-    }
-  }
+internal interface Gradient {
+  public fun getShader(width: Float, height: Float): Shader
 }