react-native-tvos 0.76.6-0 → 0.77.0-0

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

@@ -9,22 +9,30 @@ package com.facebook.react.uimanager
 
 import android.graphics.Canvas
 import android.graphics.Color
+import android.graphics.Path
 import android.graphics.Rect
+import android.graphics.RectF
 import android.graphics.drawable.Drawable
+import android.graphics.drawable.LayerDrawable
 import android.os.Build
 import android.view.View
+import android.widget.ImageView
 import androidx.annotation.ColorInt
 import com.facebook.react.bridge.ReadableArray
 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.PixelUtil.pxToDp
 import com.facebook.react.uimanager.common.UIManagerType
 import com.facebook.react.uimanager.common.ViewUtil
+import com.facebook.react.uimanager.drawable.BackgroundDrawable
+import com.facebook.react.uimanager.drawable.BorderDrawable
 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.OutlineDrawable
 import com.facebook.react.uimanager.drawable.OutsetBoxShadowDrawable
 import com.facebook.react.uimanager.style.BackgroundImageLayer
 import com.facebook.react.uimanager.style.BorderInsets
@@ -33,6 +41,7 @@ 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
+import com.facebook.react.uimanager.style.OutlineStyle
 
 /**
  * BackgroundStyleApplicator is responsible for applying backgrounds, borders, and related effects,
@@ -49,7 +58,11 @@ public object BackgroundStyleApplicator {
       return
     }
 
-    ensureCSSBackground(view).color = color ?: Color.TRANSPARENT
+    if (ReactNativeFeatureFlags.enableNewBackgroundAndBorderDrawables()) {
+      ensureBackgroundDrawable(view).backgroundColor = color ?: Color.TRANSPARENT
+    } else {
+      ensureCSSBackground(view).color = color ?: Color.TRANSPARENT
+    }
   }
 
   @JvmStatic
@@ -57,43 +70,83 @@ public object BackgroundStyleApplicator {
       view: View,
       backgroundImageLayers: List<BackgroundImageLayer>?
   ): Unit {
-    ensureCSSBackground(view).setBackgroundImage(backgroundImageLayers)
+    if (ReactNativeFeatureFlags.enableNewBackgroundAndBorderDrawables()) {
+      ensureBackgroundDrawable(view).backgroundImageLayers = backgroundImageLayers
+    } else {
+      ensureCSSBackground(view).setBackgroundImage(backgroundImageLayers)
+    }
   }
 
   @JvmStatic
   @ColorInt
-  public fun getBackgroundColor(view: View): Int? = getCSSBackground(view)?.color
+  public fun getBackgroundColor(view: View): Int? {
+    return if (ReactNativeFeatureFlags.enableNewBackgroundAndBorderDrawables()) {
+      getBackground(view)?.backgroundColor
+    } else {
+      getCSSBackground(view)?.color
+    }
+  }
 
   @JvmStatic
   public fun setBorderWidth(view: View, edge: LogicalEdge, width: Float?): Unit {
-    ensureCSSBackground(view).setBorderWidth(edge.toSpacingType(), width?.dpToPx() ?: Float.NaN)
+    val composite = ensureCompositeBackgroundDrawable(view)
+    composite.borderInsets = composite.borderInsets ?: BorderInsets()
+    composite.borderInsets?.setBorderWidth(edge, width)
 
-    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)
+    if (ReactNativeFeatureFlags.enableNewBackgroundAndBorderDrawables()) {
+      ensureBorderDrawable(view).setBorderWidth(edge.toSpacingType(), width?.dpToPx() ?: Float.NaN)
+      composite.background?.borderInsets = composite.borderInsets
+      composite.border?.borderInsets = composite.borderInsets
+
+      composite.background?.invalidateSelf()
+      composite.border?.invalidateSelf()
+    } else {
+      ensureCSSBackground(view).setBorderWidth(edge.toSpacingType(), width?.dpToPx() ?: Float.NaN)
+    }
 
-      for (shadow in composite.innerShadows) {
-        (shadow as InsetBoxShadowDrawable).borderInsets = composite.borderInsets
-        shadow.invalidateSelf()
+    composite.borderInsets = composite.borderInsets ?: BorderInsets()
+    composite.borderInsets?.setBorderWidth(edge, width)
+    if (Build.VERSION.SDK_INT >= MIN_INSET_BOX_SHADOW_SDK_VERSION) {
+      val innerShadows = composite.innerShadows
+      if (innerShadows != null) {
+        for (i in 0 until innerShadows.numberOfLayers) {
+          val shadow = innerShadows.getDrawable(i)
+          (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()
+    return if (ReactNativeFeatureFlags.enableNewBackgroundAndBorderDrawables()) {
+      val width = getBorder(view)?.borderWidth?.getRaw(edge.toSpacingType())
+      if (width == null || width.isNaN()) null else width.pxToDp()
+    } else {
+      val width = getCSSBackground(view)?.getBorderWidth(edge.toSpacingType())
+      if (width == null || width.isNaN()) null else width.pxToDp()
+    }
   }
 
   @JvmStatic
-  public fun setBorderColor(view: View, edge: LogicalEdge, @ColorInt color: Int?): Unit =
+  public fun setBorderColor(view: View, edge: LogicalEdge, @ColorInt color: Int?): Unit {
+    if (ReactNativeFeatureFlags.enableNewBackgroundAndBorderDrawables()) {
+      ensureBorderDrawable(view).setBorderColor(edge, color)
+    } else {
       ensureCSSBackground(view).setBorderColor(edge.toSpacingType(), color)
+    }
+  }
 
   @JvmStatic
   @ColorInt
-  public fun getBorderColor(view: View, edge: LogicalEdge): Int? =
+  public fun getBorderColor(view: View, edge: LogicalEdge): Int? {
+    return if (ReactNativeFeatureFlags.enableNewBackgroundAndBorderDrawables()) {
+      getBorder(view)?.getBorderColor(edge)
+    } else {
       getCSSBackground(view)?.getBorderColor(edge.toSpacingType())
+    }
+  }
 
   @JvmStatic
   public fun setBorderRadius(
@@ -101,41 +154,136 @@ public object BackgroundStyleApplicator {
       corner: BorderRadiusProp,
       radius: LengthPercentage?
   ): Unit {
-    ensureCSSBackground(view).setBorderRadius(corner, radius)
     val compositeBackgroundDrawable = ensureCompositeBackgroundDrawable(view)
+    compositeBackgroundDrawable.borderRadius =
+        compositeBackgroundDrawable.borderRadius ?: BorderRadiusStyle()
+    compositeBackgroundDrawable.borderRadius?.set(corner, radius)
+
+    if (ReactNativeFeatureFlags.enableNewBackgroundAndBorderDrawables()) {
+      if (view is ImageView) {
+        ensureBackgroundDrawable(view)
+      }
+      compositeBackgroundDrawable.background?.borderRadius =
+          compositeBackgroundDrawable.borderRadius
+      compositeBackgroundDrawable.border?.borderRadius = compositeBackgroundDrawable.borderRadius
+
+      compositeBackgroundDrawable.background?.invalidateSelf()
+      compositeBackgroundDrawable.border?.invalidateSelf()
+    } else {
+      ensureCSSBackground(view).setBorderRadius(corner, radius)
+    }
 
     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()
+      val outerShadows = compositeBackgroundDrawable.outerShadows
+      if (outerShadows != null) {
+        for (i in 0 until outerShadows.numberOfLayers) {
+          val shadow = outerShadows.getDrawable(i)
+          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()
+      val innerShadows = compositeBackgroundDrawable.innerShadows
+      if (innerShadows != null) {
+        for (i in 0 until innerShadows.numberOfLayers) {
+          val shadow = innerShadows.getDrawable(i)
+          if (shadow is InsetBoxShadowDrawable) {
+            shadow.borderRadius = shadow.borderRadius ?: BorderRadiusStyle()
+            shadow.borderRadius?.set(corner, radius)
+            shadow.invalidateSelf()
+          }
         }
       }
     }
+
+    compositeBackgroundDrawable.outline?.borderRadius = compositeBackgroundDrawable.borderRadius
+    compositeBackgroundDrawable.invalidateSelf()
   }
 
   @JvmStatic
-  public fun getBorderRadius(view: View, corner: BorderRadiusProp): LengthPercentage? =
+  public fun getBorderRadius(view: View, corner: BorderRadiusProp): LengthPercentage? {
+
+    return if (ReactNativeFeatureFlags.enableNewBackgroundAndBorderDrawables()) {
+      getCompositeBackgroundDrawable(view)?.borderRadius?.get(corner)
+    } else {
       getCSSBackground(view)?.borderRadius?.get(corner)
+    }
+  }
 
   @JvmStatic
   public fun setBorderStyle(view: View, borderStyle: BorderStyle?): Unit {
-    ensureCSSBackground(view).borderStyle = borderStyle
+    if (ReactNativeFeatureFlags.enableNewBackgroundAndBorderDrawables()) {
+      ensureBorderDrawable(view).borderStyle = borderStyle
+    } else {
+      ensureCSSBackground(view).borderStyle = borderStyle
+    }
   }
 
   @JvmStatic
-  public fun getBorderStyle(view: View): BorderStyle? = getCSSBackground(view)?.borderStyle
+  public fun getBorderStyle(view: View): BorderStyle? {
+    return if (ReactNativeFeatureFlags.enableNewBackgroundAndBorderDrawables()) {
+      getBorder(view)?.borderStyle
+    } else {
+      getCSSBackground(view)?.borderStyle
+    }
+  }
+
+  @JvmStatic
+  public fun setOutlineColor(view: View, @ColorInt outlineColor: Int?): Unit {
+    if (ViewUtil.getUIManagerType(view) != UIManagerType.FABRIC) {
+      return
+    }
+
+    val outline = ensureOutlineDrawable(view)
+    if (outlineColor != null) {
+      outline.outlineColor = outlineColor
+    }
+  }
+
+  @JvmStatic public fun getOutlineColor(view: View): Int? = getOutlineDrawable(view)?.outlineColor
+
+  @JvmStatic
+  public fun setOutlineOffset(view: View, outlineOffset: Float): Unit {
+    if (ViewUtil.getUIManagerType(view) != UIManagerType.FABRIC) {
+      return
+    }
+
+    val outline = ensureOutlineDrawable(view)
+    outline.outlineOffset = outlineOffset.dpToPx()
+  }
+
+  public fun getOutlineOffset(view: View): Float? = getOutlineDrawable(view)?.outlineOffset
+
+  @JvmStatic
+  public fun setOutlineStyle(view: View, outlineStyle: OutlineStyle?): Unit {
+    if (ViewUtil.getUIManagerType(view) != UIManagerType.FABRIC) {
+      return
+    }
+
+    val outline = ensureOutlineDrawable(view)
+    if (outlineStyle != null) {
+      outline.outlineStyle = outlineStyle
+    }
+  }
+
+  public fun getOutlineStyle(view: View): OutlineStyle? = getOutlineDrawable(view)?.outlineStyle
+
+  @JvmStatic
+  public fun setOutlineWidth(view: View, width: Float): Unit {
+    if (ViewUtil.getUIManagerType(view) != UIManagerType.FABRIC) {
+      return
+    }
+
+    val outline = ensureOutlineDrawable(view)
+    outline.outlineWidth = width.dpToPx()
+  }
+
+  public fun getOutlineWidth(view: View): Float? = getOutlineDrawable(view)?.outlineOffset
 
   @JvmStatic
   public fun setBoxShadow(view: View, shadows: List<BoxShadow>): Unit {
@@ -143,12 +291,14 @@ public object BackgroundStyleApplicator {
       return
     }
 
-    val outerShadows = mutableListOf<OutsetBoxShadowDrawable>()
-    val innerShadows = mutableListOf<InsetBoxShadowDrawable>()
+    var innerShadows: LayerDrawable? = null
+    var outerShadows: LayerDrawable? = null
 
-    val borderInsets = ensureCompositeBackgroundDrawable(view).borderInsets
+    val compositeBackgroundDrawable = ensureCompositeBackgroundDrawable(view)
+    val borderInsets = compositeBackgroundDrawable.borderInsets
+    val borderRadius = compositeBackgroundDrawable.borderRadius
 
-    for (boxShadow in shadows) {
+    for (boxShadow in shadows.asReversed()) {
       val offsetX = boxShadow.offsetX
       val offsetY = boxShadow.offsetY
       val color = boxShadow.color ?: Color.BLACK
@@ -157,10 +307,13 @@ public object BackgroundStyleApplicator {
       val inset = boxShadow.inset ?: false
 
       if (inset && Build.VERSION.SDK_INT >= MIN_INSET_BOX_SHADOW_SDK_VERSION) {
-        innerShadows.add(
+        if (innerShadows == null) {
+          innerShadows = LayerDrawable(emptyArray())
+        }
+        innerShadows.addLayer(
             InsetBoxShadowDrawable(
                 context = view.context,
-                borderRadius = ensureCSSBackground(view).borderRadius,
+                borderRadius = borderRadius,
                 borderInsets = borderInsets,
                 shadowColor = color,
                 offsetX = offsetX,
@@ -168,10 +321,13 @@ public object BackgroundStyleApplicator {
                 blurRadius = blurRadius,
                 spread = spreadDistance))
       } else if (!inset && Build.VERSION.SDK_INT >= MIN_OUTSET_BOX_SHADOW_SDK_VERSION) {
-        outerShadows.add(
+        if (outerShadows == null) {
+          outerShadows = LayerDrawable(emptyArray())
+        }
+        outerShadows.addLayer(
             OutsetBoxShadowDrawable(
                 context = view.context,
-                borderRadius = ensureCSSBackground(view).borderRadius,
+                borderRadius = borderRadius,
                 shadowColor = color,
                 offsetX = offsetX,
                 offsetY = offsetY,
@@ -180,9 +336,8 @@ public object BackgroundStyleApplicator {
       }
     }
 
-    view.background =
-        ensureCompositeBackgroundDrawable(view)
-            .withNewShadows(outerShadows = outerShadows, innerShadows = innerShadows)
+    view.background = ensureCompositeBackgroundDrawable(view).withNewOuterShadow(outerShadows)
+    view.background = ensureCompositeBackgroundDrawable(view).withNewInnerShadow(innerShadows)
   }
 
   @JvmStatic
@@ -194,36 +349,73 @@ public object BackgroundStyleApplicator {
 
     val shadowStyles = mutableListOf<BoxShadow>()
     for (i in 0..<shadows.size()) {
-      shadowStyles.add(checkNotNull(BoxShadow.parse(shadows.getMap(i))))
+      shadowStyles.add(checkNotNull(BoxShadow.parse(shadows.getMap(i), view.context)))
     }
     BackgroundStyleApplicator.setBoxShadow(view, shadowStyles)
   }
 
   @JvmStatic
   public fun setFeedbackUnderlay(view: View, drawable: Drawable?): Unit {
-    view.background = ensureCompositeBackgroundDrawable(view).withNewFeedbackUnderlay(drawable)
+    if (ReactNativeFeatureFlags.enableNewBackgroundAndBorderDrawables()) {
+
+      ensureCompositeBackgroundDrawable(view).withNewFeedbackUnderlay(drawable)
+    } else {
+      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)
+    if (ReactNativeFeatureFlags.enableNewBackgroundAndBorderDrawables()) {
+      val drawingRect = Rect()
+      view.getDrawingRect(drawingRect)
+      val composite = ensureCompositeBackgroundDrawable(view)
+      val paddingBoxRect = RectF()
+
+      val computedBorderInsets =
+          composite.borderInsets?.resolve(composite.layoutDirection, view.context)
+
+      paddingBoxRect.left = composite.bounds.left + (computedBorderInsets?.left?.dpToPx() ?: 0f)
+      paddingBoxRect.top = composite.bounds.top + (computedBorderInsets?.top?.dpToPx() ?: 0f)
+      paddingBoxRect.right = composite.bounds.right - (computedBorderInsets?.right?.dpToPx() ?: 0f)
+      paddingBoxRect.bottom =
+          composite.bounds.bottom - (computedBorderInsets?.bottom?.dpToPx() ?: 0f)
+
+      if (composite.borderRadius?.hasRoundedBorders() == true) {
+        val paddingBoxPath =
+            createPaddingBoxPath(
+                view,
+                composite,
+                paddingBoxRect,
+                computedBorderInsets,
+            )
+
+        paddingBoxPath.offset(drawingRect.left.toFloat(), drawingRect.top.toFloat())
+        canvas.clipPath(paddingBoxPath)
+      } else {
+        paddingBoxRect.offset(drawingRect.left.toFloat(), drawingRect.top.toFloat())
+        canvas.clipRect(paddingBoxRect)
+      }
+    } else {
+      val drawingRect = Rect()
+      view.getDrawingRect(drawingRect)
 
-    val cssBackground = getCSSBackground(view)
-    if (cssBackground == null) {
-      canvas.clipRect(drawingRect)
-      return
-    }
+      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)
+      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)
+      }
     }
   }
 
@@ -239,7 +431,8 @@ public object BackgroundStyleApplicator {
       return view.background as CompositeBackgroundDrawable
     }
 
-    val compositeDrawable = CompositeBackgroundDrawable(originalBackground = view.background)
+    val compositeDrawable =
+        CompositeBackgroundDrawable(context = view.context, originalBackground = view.background)
     view.background = compositeDrawable
     return compositeDrawable
   }
@@ -249,15 +442,158 @@ public object BackgroundStyleApplicator {
 
   private fun ensureCSSBackground(view: View): CSSBackgroundDrawable {
     val compositeBackgroundDrawable = ensureCompositeBackgroundDrawable(view)
-    if (compositeBackgroundDrawable.cssBackground != null) {
-      return compositeBackgroundDrawable.cssBackground
+    var cssBackground = compositeBackgroundDrawable.cssBackground
+
+    return if (cssBackground != null) {
+      return cssBackground
     } else {
-      val cssBackground = CSSBackgroundDrawable(view.context)
+      cssBackground = CSSBackgroundDrawable(view.context)
       view.background = compositeBackgroundDrawable.withNewCssBackground(cssBackground)
-      return cssBackground
+      cssBackground
+    }
+  }
+
+  private fun ensureBackgroundDrawable(view: View): BackgroundDrawable {
+    val compositeBackgroundDrawable = ensureCompositeBackgroundDrawable(view)
+    var background = compositeBackgroundDrawable.background
+
+    return if (background != null) {
+      background
+    } else {
+      background =
+          BackgroundDrawable(
+              view.context,
+              compositeBackgroundDrawable.borderRadius,
+              compositeBackgroundDrawable.borderInsets)
+      view.background = compositeBackgroundDrawable.withNewBackground(background)
+      background
     }
   }
 
   private fun getCSSBackground(view: View): CSSBackgroundDrawable? =
       getCompositeBackgroundDrawable(view)?.cssBackground
+
+  private fun getBackground(view: View): BackgroundDrawable? =
+      getCompositeBackgroundDrawable(view)?.background
+
+  private fun getBorder(view: View): BorderDrawable? = getCompositeBackgroundDrawable(view)?.border
+
+  private fun ensureBorderDrawable(view: View): BorderDrawable {
+    val compositeBackgroundDrawable = ensureCompositeBackgroundDrawable(view)
+    var border = compositeBackgroundDrawable.border
+    if (border == null) {
+      border =
+          BorderDrawable(
+              context = view.context,
+              borderRadius = compositeBackgroundDrawable.borderRadius,
+              borderWidth = Spacing(0f),
+              borderStyle = BorderStyle.SOLID,
+              borderInsets = compositeBackgroundDrawable.borderInsets,
+          )
+      view.background = compositeBackgroundDrawable.withNewBorder(border)
+    }
+
+    return border
+  }
+
+  private fun ensureOutlineDrawable(view: View): OutlineDrawable {
+    val compositeBackgroundDrawable = ensureCompositeBackgroundDrawable(view)
+    var outline = compositeBackgroundDrawable.outline
+    if (outline == null) {
+      val borderRadius =
+          if (ReactNativeFeatureFlags.enableNewBackgroundAndBorderDrawables()) {
+            compositeBackgroundDrawable.borderRadius
+          } else {
+            ensureCSSBackground(view).borderRadius
+          }
+
+      outline =
+          OutlineDrawable(
+              context = view.context,
+              borderRadius = borderRadius,
+              outlineColor = Color.BLACK,
+              outlineOffset = 0f,
+              outlineStyle = OutlineStyle.SOLID,
+              outlineWidth = 0f,
+          )
+
+      view.background = compositeBackgroundDrawable.withNewOutline(outline)
+    }
+
+    return outline
+  }
+
+  private fun getOutlineDrawable(view: View): OutlineDrawable? =
+      getCompositeBackgroundDrawable(view)?.outline
+
+  /**
+   * Here, "inner" refers to the border radius on the inside of the border. So it ends up being the
+   * "outer" border radius inset by the respective width.
+   */
+  private fun getInnerBorderRadius(computedRadius: Float?, borderWidth: Float?): Float {
+    return ((computedRadius ?: 0f) - (borderWidth ?: 0f)).coerceAtLeast(0f)
+  }
+
+  private fun createPaddingBoxPath(
+      view: View,
+      composite: CompositeBackgroundDrawable,
+      paddingBoxRect: RectF,
+      computedBorderInsets: RectF?
+  ): Path {
+    val computedBorderRadius =
+        composite.borderRadius?.resolve(
+            composite.layoutDirection,
+            view.context,
+            PixelUtil.toDIPFromPixel(composite.bounds.width().toFloat()),
+            PixelUtil.toDIPFromPixel(composite.bounds.height().toFloat()),
+        )
+
+    val paddingBoxPath = Path()
+
+    val innerTopLeftRadiusX =
+        getInnerBorderRadius(
+            computedBorderRadius?.topLeft?.horizontal?.dpToPx(),
+            computedBorderInsets?.left?.dpToPx())
+    val innerTopLeftRadiusY =
+        getInnerBorderRadius(
+            computedBorderRadius?.topLeft?.vertical?.dpToPx(), computedBorderInsets?.top?.dpToPx())
+    val innerTopRightRadiusX =
+        getInnerBorderRadius(
+            computedBorderRadius?.topRight?.horizontal?.dpToPx(),
+            computedBorderInsets?.right?.dpToPx())
+    val innerTopRightRadiusY =
+        getInnerBorderRadius(
+            computedBorderRadius?.topRight?.vertical?.dpToPx(), computedBorderInsets?.top?.dpToPx())
+    val innerBottomRightRadiusX =
+        getInnerBorderRadius(
+            computedBorderRadius?.bottomRight?.horizontal?.dpToPx(),
+            computedBorderInsets?.right?.dpToPx())
+    val innerBottomRightRadiusY =
+        getInnerBorderRadius(
+            computedBorderRadius?.bottomRight?.vertical?.dpToPx(),
+            computedBorderInsets?.bottom?.dpToPx())
+    val innerBottomLeftRadiusX =
+        getInnerBorderRadius(
+            computedBorderRadius?.bottomLeft?.horizontal?.dpToPx(),
+            computedBorderInsets?.left?.dpToPx())
+    val innerBottomLeftRadiusY =
+        getInnerBorderRadius(
+            computedBorderRadius?.bottomLeft?.vertical?.dpToPx(),
+            computedBorderInsets?.bottom?.dpToPx())
+
+    paddingBoxPath.addRoundRect(
+        paddingBoxRect,
+        floatArrayOf(
+            innerTopLeftRadiusX,
+            innerTopLeftRadiusY,
+            innerTopRightRadiusX,
+            innerTopRightRadiusY,
+            innerBottomRightRadiusX,
+            innerBottomRightRadiusY,
+            innerBottomLeftRadiusX,
+            innerBottomLeftRadiusY,
+        ),
+        Path.Direction.CW)
+    return paddingBoxPath
+  }
 }