react-native-tvos 0.78.0-0rc4 → 0.79.0-0

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

@@ -0,0 +1,189 @@
+/*
+ * 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.common.logging.FLog
+import com.facebook.react.bridge.ReadableArray
+import com.facebook.react.common.annotations.DeprecatedInNewArchitecture
+import com.facebook.react.uimanager.ViewManagersPropertyCache.PropSetter
+import java.util.HashMap
+
+public object ViewManagerPropertyUpdater {
+  public fun interface Settable {
+    public fun getProperties(props: MutableMap<String, String>)
+  }
+
+  @Suppress("FINITE_BOUNDS_VIOLATION_IN_JAVA")
+  public interface ViewManagerSetter<T : ViewManager<V, *>, V : View> : Settable {
+    public fun setProperty(manager: T, view: V, name: String, value: Any?)
+  }
+
+  @Suppress("FINITE_BOUNDS_VIOLATION_IN_JAVA")
+  public interface ShadowNodeSetter<in T : ReactShadowNode<*>> : Settable {
+    public fun setProperty(node: T, name: String, value: Any?)
+  }
+
+  private const val TAG = "ViewManagerPropertyUpdater"
+
+  private val VIEW_MANAGER_SETTER_MAP: MutableMap<Class<*>, ViewManagerSetter<*, *>> = HashMap()
+  private val SHADOW_NODE_SETTER_MAP: MutableMap<Class<*>, ShadowNodeSetter<*>> = HashMap()
+
+  @JvmStatic
+  public fun clear(): Unit {
+    ViewManagersPropertyCache.clear()
+    VIEW_MANAGER_SETTER_MAP.clear()
+    SHADOW_NODE_SETTER_MAP.clear()
+  }
+
+  @JvmStatic
+  @Deprecated("Use ViewManager#updateProperties to update a view's properties")
+  public fun <T : ViewManagerDelegate<V>, V : View> updateProps(
+      delegate: T,
+      view: V,
+      props: ReactStylesDiffMap
+  ) {
+    val iterator = props.mBackingMap.entryIterator
+    while (iterator.hasNext()) {
+      val entry = iterator.next()
+      delegate.setProperty(view, entry.key, entry.value)
+    }
+  }
+
+  @JvmStatic
+  @Deprecated("Use ViewManager#updateProperties to update a view's properties")
+  public fun <V : View> updateProps(
+      manager: ViewManager<V, *>,
+      view: V,
+      props: ReactStylesDiffMap
+  ) {
+    val setter = findManagerSetter(manager.javaClass)
+    val iterator = props.mBackingMap.entryIterator
+    while (iterator.hasNext()) {
+      val entry = iterator.next()
+      setter.setProperty(manager, view, entry.key, entry.value)
+    }
+  }
+
+  @DeprecatedInNewArchitecture
+  @JvmStatic
+  public fun <T : ReactShadowNode<T>> updateProps(node: T, props: ReactStylesDiffMap) {
+    val setter = findNodeSetter(node.javaClass)
+    val iterator = props.mBackingMap.entryIterator
+    while (iterator.hasNext()) {
+      val entry = iterator.next()
+      setter.setProperty(node, entry.key, entry.value)
+    }
+  }
+
+  @JvmStatic
+  public fun getNativeProps(
+      viewManagerTopClass: Class<out ViewManager<Nothing, *>>,
+      shadowNodeTopClass: Class<out Nothing>
+  ): Map<String, String> {
+    val props: MutableMap<String, String> = HashMap()
+    findManagerSetter(viewManagerTopClass).getProperties(props)
+    findNodeSetter(shadowNodeTopClass).getProperties(props)
+    return props
+  }
+
+  private fun <V : View> findManagerSetter(
+      managerClass: Class<out ViewManager<V, *>>
+  ): ViewManagerSetter<ViewManager<V, *>, V> {
+    var setter = VIEW_MANAGER_SETTER_MAP[managerClass]
+    if (setter == null) {
+      setter = findGeneratedSetter(managerClass)
+      if (setter == null) {
+        setter = FallbackViewManagerSetter(managerClass)
+      }
+      VIEW_MANAGER_SETTER_MAP[managerClass] = setter
+    }
+    @Suppress("UNCHECKED_CAST")
+    return setter as ViewManagerSetter<ViewManager<V, *>, V>
+  }
+
+  private fun <T : ReactShadowNode<T>> findNodeSetter(
+      nodeClass: Class<out T>
+  ): ShadowNodeSetter<T> {
+    var setter = SHADOW_NODE_SETTER_MAP[nodeClass]
+    if (setter == null) {
+      setter = findGeneratedSetter(nodeClass)
+      if (setter == null) {
+        @Suppress("UNCHECKED_CAST")
+        setter = FallbackShadowNodeSetter(nodeClass as Class<Nothing>)
+      }
+      SHADOW_NODE_SETTER_MAP[nodeClass] = setter
+    }
+    @Suppress("UNCHECKED_CAST")
+    return setter as ShadowNodeSetter<T>
+  }
+
+  private fun <T> findGeneratedSetter(cls: Class<*>): T? {
+    val clsName = cls.name
+    try {
+      val setterClass = Class.forName("$clsName$\$PropsSetter")
+      @Suppress("DEPRECATION", "UNCHECKED_CAST")
+      return setterClass.newInstance() as T
+    } catch (e: ClassNotFoundException) {
+      FLog.w(TAG, "Could not find generated setter for $cls")
+      return null
+    } catch (e: InstantiationException) {
+      throw RuntimeException("Unable to instantiate methods getter for $clsName", e)
+    } catch (e: IllegalAccessException) {
+      throw RuntimeException("Unable to instantiate methods getter for $clsName", e)
+    }
+  }
+
+  private class FallbackViewManagerSetter<V : View>(
+      viewManagerClass: Class<out ViewManager<V, *>>
+  ) : ViewManagerSetter<ViewManager<V, *>, V> {
+    private val mPropSetters: Map<String, PropSetter> =
+        ViewManagersPropertyCache.getNativePropSettersForViewManagerClass(viewManagerClass)
+
+    override fun setProperty(manager: ViewManager<V, *>, view: V, name: String, value: Any?) {
+      val setter = mPropSetters[name]
+      setter?.updateViewProp(manager, view, value)
+    }
+
+    override fun getProperties(props: MutableMap<String, String>) {
+      for (setter in mPropSetters.values) {
+        props[setter.propName] = setter.propType
+      }
+    }
+  }
+
+  private class FallbackShadowNodeSetter(shadowNodeClass: Class<out Nothing>) :
+      ShadowNodeSetter<ReactShadowNode<*>> {
+    private val propSetters: Map<String, PropSetter> =
+        ViewManagersPropertyCache.getNativePropSettersForShadowNodeClass(shadowNodeClass)
+
+    override fun setProperty(node: ReactShadowNode<*>, name: String, value: Any?) {
+      val setter = propSetters[name]
+      setter?.updateShadowNodeProp(node, value)
+    }
+
+    override fun getProperties(props: MutableMap<String, String>) {
+      for (setter in propSetters.values) {
+        props[setter.propName] = setter.propType
+      }
+    }
+  }
+
+  internal class GenericViewManagerDelegate<T : View>(private val manager: ViewManager<T, *>) :
+      ViewManagerDelegate<T> {
+    private val setter = findManagerSetter(manager.javaClass)
+
+    @Suppress("ACCIDENTAL_OVERRIDE")
+    override fun setProperty(view: T, propName: String, value: Any?): Unit {
+      setter.setProperty(manager, view, propName, value)
+    }
+
+    @Suppress("ACCIDENTAL_OVERRIDE")
+    override fun receiveCommand(view: T, commandName: String, args: ReadableArray?) = Unit
+  }
+}

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

@@ -0,0 +1,20 @@
+/*
+ * 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
+
+/** Enables lazy discovery of a specific [ViewManager] by its name. */
+public interface ViewManagerResolver {
+  /**
+   * [UIManagerModule] class uses this method to get a [ViewManager] by its name. This is the same
+   * name that comes from JS by `UIManager.ViewManagerName` call.
+   */
+  public fun getViewManager(viewManagerName: String): ViewManager<*, *>?
+
+  /** Provides a list of view manager names to register in JS as `UIManager.ViewManagerName` */
+  public fun getViewManagerNames(): Collection<String>
+}

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

@@ -29,8 +29,8 @@ public object ViewUtil {
       }
 
   /**
-   * Overload for {@link #getUIManagerType(int)} that uses the view's id to determine if it
-   * originated from Fabric
+   * Overload for [getUIManagerType] that uses the view's id to determine if it originated from
+   * Fabric
    */
   @JvmStatic @UIManagerType public fun getUIManagerType(view: View): Int = getUIManagerType(view.id)
 

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

@@ -227,7 +227,7 @@ internal class BorderDrawable(
     return borderColors?.edgeColors?.get(position.ordinal) ?: Color.BLACK
   }
 
-  public fun invalidateSelfAndUpdatePath() {
+  fun invalidateSelfAndUpdatePath() {
     needUpdatePath = true
     invalidateSelf()
   }

package/ReactAndroid/src/main/java/com/facebook/react/uimanager/drawable/CSSBackgroundDrawable.java

@@ -390,9 +390,6 @@ public class CSSBackgroundDrawable extends Drawable {
     updatePath();
     canvas.save();
 
-    // Clip outer border
-    canvas.clipPath(Preconditions.checkNotNull(mOuterClipPathForBorderRadius), Region.Op.INTERSECT);
-
     // Draws the View without its border first (with background color fill)
     int useColor = ColorUtils.setAlphaComponent(mColor, (Color.alpha(mColor) * mAlpha) >> 8);
     if (Color.alpha(useColor) != 0) {
@@ -434,6 +431,10 @@ public class CSSBackgroundDrawable extends Drawable {
         || borderWidth.left > 0
         || borderWidth.right > 0) {
 
+      // Clip outer border
+      canvas.clipPath(
+          Preconditions.checkNotNull(mOuterClipPathForBorderRadius), Region.Op.INTERSECT);
+
       // If it's a full and even border draw inner rect path with stroke
       final float fullBorderWidth = getFullBorderWidth();
       int borderColor = getBorderColor(Spacing.ALL);
@@ -647,7 +648,6 @@ public class CSSBackgroundDrawable extends Drawable {
     }
 
     // Clip border ONLY if at least one edge is non-transparent
-    float pathAdjustment = 0f;
     if (Color.alpha(colorLeft) != 0
         || Color.alpha(colorTop) != 0
         || Color.alpha(colorRight) != 0
@@ -658,10 +658,6 @@ public class CSSBackgroundDrawable extends Drawable {
       mInnerClipTempRectForBorderRadius.bottom -= borderWidth.bottom;
       mInnerClipTempRectForBorderRadius.left += borderWidth.left;
       mInnerClipTempRectForBorderRadius.right -= borderWidth.right;
-
-      // only close gap between border and main path if we draw the border, otherwise
-      // we wind up pixelating small pixel-radius curves
-      pathAdjustment = mGapBetweenPaths;
     }
 
     mTempRectForCenterDrawPath.top += borderWidth.top * 0.5f;
@@ -715,11 +711,21 @@ public class CSSBackgroundDrawable extends Drawable {
     // border. mGapBetweenPaths is used to slightly enlarge the rectangle
     // (mInnerClipTempRectForBorderRadius), ensuring the border can be
     // drawn on top without the gap.
+    // only close gap between border and main path if we draw the border, otherwise
+    // we wind up pixelating small pixel-radius curves
     mBackgroundColorRenderPath.addRoundRect(
-        mInnerClipTempRectForBorderRadius.left - pathAdjustment,
-        mInnerClipTempRectForBorderRadius.top - pathAdjustment,
-        mInnerClipTempRectForBorderRadius.right + pathAdjustment,
-        mInnerClipTempRectForBorderRadius.bottom + pathAdjustment,
+        (borderWidth.left > 0)
+            ? mInnerClipTempRectForBorderRadius.left - mGapBetweenPaths
+            : mInnerClipTempRectForBorderRadius.left,
+        (borderWidth.top > 0)
+            ? mInnerClipTempRectForBorderRadius.top - mGapBetweenPaths
+            : mInnerClipTempRectForBorderRadius.top,
+        (borderWidth.right > 0)
+            ? mInnerClipTempRectForBorderRadius.right + mGapBetweenPaths
+            : mInnerClipTempRectForBorderRadius.right,
+        (borderWidth.bottom > 0)
+            ? mInnerClipTempRectForBorderRadius.bottom + mGapBetweenPaths
+            : mInnerClipTempRectForBorderRadius.bottom,
         new float[] {
           innerTopLeftRadiusX,
           innerTopLeftRadiusY,

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

@@ -15,7 +15,7 @@ import android.graphics.drawable.Drawable
 import android.graphics.drawable.LayerDrawable
 import android.os.Build
 import com.facebook.react.common.annotations.UnstableReactNativeAPI
-import com.facebook.react.internal.featureflags.ReactNativeFeatureFlags
+import com.facebook.react.uimanager.PixelUtil.dpToPx
 import com.facebook.react.uimanager.style.BorderInsets
 import com.facebook.react.uimanager.style.BorderRadiusStyle
 
@@ -30,10 +30,10 @@ internal class CompositeBackgroundDrawable(
      * Any non-react-managed background already part of the view, like one set as Android style on a
      * TextInput
      */
-    public val originalBackground: Drawable? = null,
+    val originalBackground: Drawable? = null,
 
     /** Non-inset box shadows */
-    outerShadows: LayerDrawable? = null,
+    val outerShadows: List<Drawable> = emptyList(),
 
     /**
      * CSS background layer and border rendering
@@ -41,147 +41,144 @@ internal class CompositeBackgroundDrawable(
      * TODO: we should extract path logic from here, and fast-path to using simpler drawables like
      *   ColorDrawable in the common cases
      */
-    public val cssBackground: CSSBackgroundDrawable? = null,
+    val cssBackground: CSSBackgroundDrawable? = null,
 
     /** Background rendering Layer */
-    background: BackgroundDrawable? = null,
+    val background: BackgroundDrawable? = null,
 
     /** Border rendering Layer */
-    border: BorderDrawable? = null,
+    val border: BorderDrawable? = null,
 
     /** TouchableNativeFeeback set selection background, like "SelectableBackground" */
-    feedbackUnderlay: Drawable? = null,
+    val feedbackUnderlay: Drawable? = null,
 
     /** Inset box-shadows */
-    innerShadows: LayerDrawable? = null,
+    val innerShadows: List<Drawable> = emptyList(),
 
     /** Outline */
-    outline: OutlineDrawable? = null,
-) : LayerDrawable(emptyArray()) {
-  public var outerShadows: LayerDrawable? = outerShadows
-    private set
+    val outline: OutlineDrawable? = null,
 
-  public var background: BackgroundDrawable? = background
-    private set
+    // Holder value for currently set insets
+    var borderInsets: BorderInsets? = null,
 
-  public var border: BorderDrawable? = border
-    private set
-
-  public var feedbackUnderlay: Drawable? = feedbackUnderlay
-    private set
-
-  public var innerShadows: LayerDrawable? = innerShadows
-    private set
-
-  public var outline: OutlineDrawable? = outline
-    private set
-
-  // Holder value for currently set insets
-  public var borderInsets: BorderInsets? = null
-
-  // Holder value for currently set border radius
-  public var borderRadius: BorderRadiusStyle? = null
+    // Holder value for currently set border radius
+    var borderRadius: BorderRadiusStyle? = null,
+) :
+    LayerDrawable(
+        createLayersArray(
+            originalBackground,
+            outerShadows,
+            cssBackground,
+            background,
+            border,
+            feedbackUnderlay,
+            innerShadows,
+            outline)) {
 
   init {
     // We want to overlay drawables, instead of placing future drawables within the content area of
     // previous ones. E.g. an EditText style may set padding on a TextInput, but we don't want to
     // constrain background color to the area inside of the padding.
     setPaddingMode(LayerDrawable.PADDING_MODE_STACK)
-
-    addLayer(originalBackground, ORIGINAL_BACKGROUND_ID)
-    addLayer(outerShadows, OUTER_SHADOWS_ID)
-    addLayer(cssBackground, CSS_BACKGROUND_ID)
-    addLayer(background, BACKGROUND_ID)
-    addLayer(border, BORDER_ID)
-    addLayer(feedbackUnderlay, FEEDBACK_UNDERLAY_ID)
-    addLayer(innerShadows, INNER_SHADOWS_ID)
-    addLayer(outline, OUTLINE_ID)
   }
 
-  public fun withNewCssBackground(
-      cssBackground: CSSBackgroundDrawable?
-  ): CompositeBackgroundDrawable {
+  fun withNewCssBackground(cssBackground: CSSBackgroundDrawable?): CompositeBackgroundDrawable {
     return CompositeBackgroundDrawable(
-            context,
-            originalBackground,
-            outerShadows,
-            cssBackground,
-            background,
-            border,
-            feedbackUnderlay,
-            innerShadows,
-            outline)
-        .also { composite ->
-          composite.borderInsets = this.borderInsets
-          composite.borderRadius = this.borderRadius
-        }
+        context,
+        originalBackground,
+        outerShadows,
+        cssBackground,
+        background,
+        border,
+        feedbackUnderlay,
+        innerShadows,
+        outline,
+        borderInsets,
+        borderRadius,
+    )
   }
 
-  public fun withNewOuterShadow(outerShadows: LayerDrawable?): CompositeBackgroundDrawable =
-      withNewLayer(outerShadows, OUTER_SHADOWS_ID, this::outerShadows::set)
-
-  public fun withNewBackground(background: BackgroundDrawable?): CompositeBackgroundDrawable =
-      withNewLayer(background, BACKGROUND_ID, this::background::set)
-
-  public fun withNewBorder(border: BorderDrawable?): CompositeBackgroundDrawable =
-      withNewLayer(border, BORDER_ID, this::border::set)
-
-  public fun withNewFeedbackUnderlay(newUnderlay: Drawable?): CompositeBackgroundDrawable =
-      withNewLayer(newUnderlay, FEEDBACK_UNDERLAY_ID, this::feedbackUnderlay::set)
-
-  public fun withNewInnerShadow(innerShadows: LayerDrawable?): CompositeBackgroundDrawable =
-      withNewLayer(innerShadows, INNER_SHADOWS_ID, this::innerShadows::set)
-
-  public fun withNewOutline(outline: OutlineDrawable?): CompositeBackgroundDrawable =
-      withNewLayer(outline, OUTLINE_ID, this::outline::set)
-
-  /** @return true if the layer was updated, false if it was not */
-  private fun updateLayer(layer: Drawable?, id: Int): Boolean {
-    if (layer == null) {
-      return findDrawableByLayerId(id) == null
-    }
-
-    if (findDrawableByLayerId(id) == null) {
-      insertNewLayer(layer, id)
-    } else {
-      setDrawableByLayerId(id, layer)
-    }
-    invalidateSelf()
-    return true
+  fun withNewBackground(background: BackgroundDrawable?): CompositeBackgroundDrawable {
+    return CompositeBackgroundDrawable(
+        context,
+        originalBackground,
+        outerShadows,
+        cssBackground,
+        background,
+        border,
+        feedbackUnderlay,
+        innerShadows,
+        outline,
+        borderInsets,
+        borderRadius,
+    )
   }
 
-  private fun insertNewLayer(layer: Drawable?, id: Int) {
-    layer ?: return
-
-    if (numberOfLayers == 0) {
-      addLayer(layer, id)
-      return
-    }
+  fun withNewShadows(
+      outerShadows: List<Drawable>,
+      innerShadows: List<Drawable>
+  ): CompositeBackgroundDrawable {
+    return CompositeBackgroundDrawable(
+        context,
+        originalBackground,
+        outerShadows,
+        cssBackground,
+        background,
+        border,
+        feedbackUnderlay,
+        innerShadows,
+        outline,
+        borderInsets,
+        borderRadius,
+    )
+  }
 
-    for (i in 0..<numberOfLayers) {
-      if (id < getId(i)) {
-        val tempDrawable: Drawable = getDrawable(i)
-        val tempId = getId(i)
-        setDrawable(i, layer)
-        setId(i, id)
-        insertNewLayer(tempDrawable, tempId)
-        return
-      } else if (i == numberOfLayers - 1) {
-        addLayer(layer, id)
-        return
-      }
-    }
+  fun withNewBorder(border: BorderDrawable): CompositeBackgroundDrawable {
+    return CompositeBackgroundDrawable(
+        context,
+        originalBackground,
+        outerShadows,
+        cssBackground,
+        background,
+        border,
+        feedbackUnderlay,
+        innerShadows,
+        outline,
+        borderInsets,
+        borderRadius,
+    )
   }
 
-  private fun addLayer(layer: Drawable?, id: Int) {
-    if (layer == null) {
-      return
-    }
+  fun withNewOutline(outline: OutlineDrawable): CompositeBackgroundDrawable {
+    return CompositeBackgroundDrawable(
+        context,
+        originalBackground,
+        outerShadows,
+        cssBackground,
+        background,
+        border,
+        feedbackUnderlay,
+        innerShadows,
+        outline,
+        borderInsets,
+        borderRadius,
+    )
+  }
 
-    addLayer(layer)
-    layer.callback = this
-    setId(numberOfLayers - 1, id)
-    invalidateSelf()
+  fun withNewFeedbackUnderlay(newUnderlay: Drawable?): CompositeBackgroundDrawable {
+    return CompositeBackgroundDrawable(
+        context,
+        originalBackground,
+        outerShadows,
+        cssBackground,
+        background,
+        border,
+        newUnderlay,
+        innerShadows,
+        outline,
+        borderInsets,
+        borderRadius,
+    )
   }
 
   /* Android's elevation implementation requires this to be implemented to know where to draw the
@@ -200,14 +197,14 @@ internal class CompositeBackgroundDrawable(
         pathForOutline.addRoundRect(
             RectF(bounds),
             floatArrayOf(
-                it.topLeft.horizontal + (computedBorderInsets?.left ?: 0f),
-                it.topLeft.vertical + (computedBorderInsets?.top ?: 0f),
-                it.topRight.horizontal + (computedBorderInsets?.right ?: 0f),
-                it.topRight.vertical + (computedBorderInsets?.top ?: 0f),
-                it.bottomRight.horizontal + (computedBorderInsets?.right ?: 0f),
-                it.bottomRight.vertical + (computedBorderInsets?.bottom ?: 0f),
-                it.bottomLeft.horizontal + (computedBorderInsets?.left ?: 0f),
-                it.bottomLeft.vertical) + (computedBorderInsets?.bottom ?: 0f),
+                (it.topLeft.horizontal + (computedBorderInsets?.left ?: 0f)).dpToPx(),
+                (it.topLeft.vertical + (computedBorderInsets?.top ?: 0f)).dpToPx(),
+                (it.topRight.horizontal + (computedBorderInsets?.right ?: 0f)).dpToPx(),
+                (it.topRight.vertical + (computedBorderInsets?.top ?: 0f)).dpToPx(),
+                (it.bottomRight.horizontal + (computedBorderInsets?.right ?: 0f)).dpToPx(),
+                (it.bottomRight.vertical + (computedBorderInsets?.bottom ?: 0f)).dpToPx(),
+                (it.bottomLeft.horizontal + (computedBorderInsets?.left ?: 0f)).dpToPx(),
+                (it.bottomLeft.vertical + (computedBorderInsets?.bottom ?: 0f)).dpToPx()),
             Path.Direction.CW)
       }
 
@@ -221,41 +218,27 @@ internal class CompositeBackgroundDrawable(
     }
   }
 
-  private fun <T> withNewLayer(
-      newLayer: T,
-      id: Int,
-      setNewLayer: (T) -> Unit,
-  ): CompositeBackgroundDrawable where T : Drawable? {
-    setNewLayer(newLayer)
-    if (ReactNativeFeatureFlags.enableNewBackgroundAndBorderDrawables()) {
-      if (updateLayer(newLayer, id)) {
-        return this
-      }
+  companion object {
+    private fun createLayersArray(
+        originalBackground: Drawable?,
+        outerShadows: List<Drawable>,
+        cssBackground: CSSBackgroundDrawable?,
+        background: BackgroundDrawable?,
+        border: BorderDrawable?,
+        feedbackUnderlay: Drawable?,
+        innerShadows: List<Drawable>,
+        outline: OutlineDrawable?
+    ): Array<Drawable?> {
+      val layers = mutableListOf<Drawable?>()
+      originalBackground?.let { layers.add(it) }
+      layers.addAll(outerShadows.asReversed())
+      cssBackground?.let { layers.add(it) }
+      background?.let { layers.add(it) }
+      border?.let { layers.add(it) }
+      feedbackUnderlay?.let { layers.add(it) }
+      layers.addAll(innerShadows.asReversed())
+      outline?.let { layers.add(it) }
+      return layers.toTypedArray()
     }
-    return CompositeBackgroundDrawable(
-            context,
-            originalBackground,
-            outerShadows,
-            cssBackground,
-            background,
-            border,
-            feedbackUnderlay,
-            innerShadows,
-            outline)
-        .also { composite ->
-          composite.borderInsets = this.borderInsets
-          composite.borderRadius = this.borderRadius
-        }
-  }
-
-  private companion object {
-    private const val ORIGINAL_BACKGROUND_ID: Int = 0
-    private const val OUTER_SHADOWS_ID: Int = 1
-    private const val CSS_BACKGROUND_ID: Int = 2
-    private const val BACKGROUND_ID: Int = 3
-    private const val BORDER_ID: Int = 4
-    private const val FEEDBACK_UNDERLAY_ID: Int = 5
-    private const val INNER_SHADOWS_ID: Int = 6
-    private const val OUTLINE_ID: Int = 7
   }
 }