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

package/ReactAndroid/src/main/java/com/facebook/react/runtime/ReactInstance.java

@@ -44,7 +44,6 @@ import com.facebook.react.fabric.Binding;
 import com.facebook.react.fabric.BindingImpl;
 import com.facebook.react.fabric.ComponentFactory;
 import com.facebook.react.fabric.FabricUIManager;
-import com.facebook.react.fabric.ReactNativeConfig;
 import com.facebook.react.fabric.events.EventBeatManager;
 import com.facebook.react.interfaces.exceptionmanager.ReactJsExceptionHandler;
 import com.facebook.react.internal.AndroidChoreographerProvider;
@@ -90,17 +89,13 @@ final class ReactInstance {
 
   @DoNotStrip private final HybridData mHybridData;
 
-  private final ReactHostDelegate mDelegate;
   private final BridgelessReactContext mBridgelessReactContext;
-  private final List<ReactPackage> mReactPackages;
-
   private final ReactQueueConfiguration mQueueConfiguration;
   private final TurboModuleManager mTurboModuleManager;
   private final FabricUIManager mFabricUIManager;
   private final JavaTimerManager mJavaTimerManager;
   private final BridgelessViewManagerResolver mViewManagerResolver;
-
-  private JavaScriptContextHolder mJavaScriptContextHolder;
+  private final JavaScriptContextHolder mJavaScriptContextHolder;
 
   static {
     loadLibraryIfNeeded();
@@ -117,7 +112,6 @@ final class ReactInstance {
       boolean useDevSupport,
       @Nullable ReactHostInspectorTarget reactHostInspectorTarget) {
     mBridgelessReactContext = bridgelessReactContext;
-    mDelegate = delegate;
 
     Systrace.beginSection(Systrace.TRACE_TAG_REACT_JAVA_BRIDGE, "ReactInstance.initialize");
 
@@ -125,13 +119,10 @@ final class ReactInstance {
      * Prepare the ReactInstance by installing JSI bindings, initializing Fabric + TurboModules, and
      * loading the JS bundle.
      */
-    MessageQueueThreadSpec nativeModulesSpec =
-        MessageQueueThreadSpec.newBackgroundThreadSpec("v_native");
     ReactQueueConfigurationSpec spec =
-        ReactQueueConfigurationSpec.builder()
-            .setJSQueueThreadSpec(MessageQueueThreadSpec.newBackgroundThreadSpec("v_js"))
-            .setNativeModulesQueueThreadSpec(nativeModulesSpec)
-            .build();
+        new ReactQueueConfigurationSpec(
+            MessageQueueThreadSpec.newBackgroundThreadSpec("v_native"),
+            MessageQueueThreadSpec.newBackgroundThreadSpec("v_js"));
     mQueueConfiguration = ReactQueueConfigurationImpl.create(spec, exceptionHandler);
     FLog.d(TAG, "Calling initializeMessageQueueThreads()");
     mBridgelessReactContext.initializeMessageQueueThreads(mQueueConfiguration);
@@ -152,8 +143,8 @@ final class ReactInstance {
             ReactChoreographer.getInstance(),
             devSupportManager);
 
-    JSRuntimeFactory jsRuntimeFactory = mDelegate.getJsRuntimeFactory();
-    BindingsInstaller bindingsInstaller = mDelegate.getBindingsInstaller();
+    JSRuntimeFactory jsRuntimeFactory = delegate.getJsRuntimeFactory();
+    BindingsInstaller bindingsInstaller = delegate.getBindingsInstaller();
     // Notify JS if profiling is enabled
     boolean isProfiling =
         Systrace.isTracing(Systrace.TRACE_TAG_REACT_APPS | Systrace.TRACE_TAG_REACT_JS_VM_CALLS);
@@ -165,7 +156,7 @@ final class ReactInstance {
             nativeModulesMessageQueueThread,
             mJavaTimerManager,
             jsTimerExecutor,
-            new ReactJsExceptionHandlerImpl(nativeModulesMessageQueueThread),
+            new ReactJsExceptionHandlerImpl(exceptionHandler),
             bindingsInstaller,
             isProfiling,
             reactHostInspectorTarget);
@@ -176,20 +167,20 @@ final class ReactInstance {
     Systrace.beginSection(
         Systrace.TRACE_TAG_REACT_JAVA_BRIDGE, "ReactInstance.initialize#initTurboModules");
 
-    mReactPackages = new ArrayList<>();
-    mReactPackages.add(
+    List<ReactPackage> reactPackages = new ArrayList<>();
+    reactPackages.add(
         new CoreReactPackage(
             bridgelessReactContext.getDevSupportManager(),
             bridgelessReactContext.getDefaultHardwareBackBtnHandler()));
     if (useDevSupport) {
-      mReactPackages.add(new DebugCorePackage());
+      reactPackages.add(new DebugCorePackage());
     }
-    mReactPackages.addAll(mDelegate.getReactPackages());
+    reactPackages.addAll(delegate.getReactPackages());
 
     TurboModuleManagerDelegate turboModuleManagerDelegate =
-        mDelegate
+        delegate
             .getTurboModuleManagerDelegateBuilder()
-            .setPackages(mReactPackages)
+            .setPackages(reactPackages)
             .setReactApplicationContext(mBridgelessReactContext)
             .build();
 
@@ -209,7 +200,7 @@ final class ReactInstance {
         Systrace.TRACE_TAG_REACT_JAVA_BRIDGE, "ReactInstance.initialize#initFabric");
 
     mViewManagerResolver =
-        new BridgelessViewManagerResolver(mReactPackages, mBridgelessReactContext);
+        new BridgelessViewManagerResolver(reactPackages, mBridgelessReactContext);
 
     // Initialize function for JS's UIManager.hasViewManagerConfig()
     ComponentNameResolverBinding.install(
@@ -278,8 +269,6 @@ final class ReactInstance {
             new ViewManagerRegistry(mViewManagerResolver),
             eventBeatManager);
 
-    ReactNativeConfig config = mDelegate.getReactNativeConfig();
-
     // Misc initialization that needs to be done before Fabric init
     DisplayMetricsHolder.initDisplayMetricsIfNotInitialized(mBridgelessReactContext);
 
@@ -290,7 +279,7 @@ final class ReactInstance {
         mFabricUIManager,
         eventBeatManager,
         componentFactory,
-        config);
+        delegate.getReactNativeConfig());
 
     // Initialize the FabricUIManager
     mFabricUIManager.initialize();
@@ -300,9 +289,20 @@ final class ReactInstance {
   }
 
   void initializeEagerTurboModules() {
-    // Eagerly initialize TurboModules
-    for (String moduleName : mTurboModuleManager.getEagerInitModuleNames()) {
-      mTurboModuleManager.getModule(moduleName);
+    Runnable task =
+        () -> {
+          Systrace.beginSection(
+              Systrace.TRACE_TAG_REACT_JAVA_BRIDGE, "initializeEagerTurboModules");
+          // Eagerly initialize TurboModules
+          for (String moduleName : mTurboModuleManager.getEagerInitModuleNames()) {
+            mTurboModuleManager.getModule(moduleName);
+          }
+          Systrace.endSection(Systrace.TRACE_TAG_REACT_JAVA_BRIDGE);
+        };
+    if (ReactNativeFeatureFlags.initEagerTurboModulesOnNativeModulesQueueAndroid()) {
+      mQueueConfiguration.getNativeModulesQueueThread().runOnQueue(task);
+    } else {
+      task.run();
     }
   }
 
@@ -318,30 +318,32 @@ final class ReactInstance {
   }
 
   private class ReactJsExceptionHandlerImpl implements ReactJsExceptionHandler {
-    private final MessageQueueThread mNativemodulesmessagequeuethread;
+    private final QueueThreadExceptionHandler mQueueThreadExceptionHandler;
 
-    ReactJsExceptionHandlerImpl(MessageQueueThread nativeModulesMessageQueueThread) {
-      this.mNativemodulesmessagequeuethread = nativeModulesMessageQueueThread;
+    ReactJsExceptionHandlerImpl(QueueThreadExceptionHandler queueThreadExceptionHandler) {
+      mQueueThreadExceptionHandler = queueThreadExceptionHandler;
     }
 
     @Override
     public void reportJsException(ParsedError error) {
       JavaOnlyMap data = StackTraceHelper.convertParsedError(error);
 
-      // Simulate async native module method call
-      mNativemodulesmessagequeuethread.runOnQueue(
-          () -> {
-            NativeExceptionsManagerSpec exceptionsManager =
-                (NativeExceptionsManagerSpec)
-                    Assertions.assertNotNull(
-                        mTurboModuleManager.getModule(NativeExceptionsManagerSpec.NAME));
-            exceptionsManager.reportException(data);
-          });
+      try {
+        NativeExceptionsManagerSpec exceptionsManager =
+            (NativeExceptionsManagerSpec)
+                Assertions.assertNotNull(
+                    mTurboModuleManager.getModule(NativeExceptionsManagerSpec.NAME));
+        exceptionsManager.reportException(data);
+      } catch (Exception e) {
+        // Sometimes (e.g: always with the default exception manager) the native module exceptions
+        // manager can throw. In those cases, call into the lower-level queue thread exceptions
+        // handler.
+        mQueueThreadExceptionHandler.handleException(e);
+      }
     }
   }
 
   public void loadJSBundle(JSBundleLoader bundleLoader) {
-    // Load the JS bundle
     Systrace.beginSection(Systrace.TRACE_TAG_REACT_JAVA_BRIDGE, "ReactInstance.loadJSBundle");
     bundleLoader.loadScript(
         new JSBundleLoaderDelegate() {
@@ -541,9 +543,9 @@ final class ReactInstance {
   }
 
   private static class BridgelessViewManagerResolver implements ViewManagerResolver {
-    private List<ReactPackage> mReactPackages;
-    private BridgelessReactContext mBridgelessReactContext;
-    private Map<String, ViewManager> mLazyViewManagerMap = new HashMap<>();
+    private final List<ReactPackage> mReactPackages;
+    private final BridgelessReactContext mBridgelessReactContext;
+    private final Map<String, ViewManager> mLazyViewManagerMap = new HashMap<>();
     private @Nullable Map<String, ViewManager> mEagerViewManagerMap = null;
 
     public BridgelessViewManagerResolver(

package/ReactAndroid/src/main/java/com/facebook/react/runtime/ReactSurfaceView.kt

@@ -139,7 +139,8 @@ public class ReactSurfaceView(context: Context?, private val surface: ReactSurfa
   override fun dispatchJSTouchEvent(event: MotionEvent) {
     val eventDispatcher = surface.eventDispatcher
     if (eventDispatcher != null) {
-      jsTouchDispatcher.handleTouchEvent(event, eventDispatcher)
+      jsTouchDispatcher.handleTouchEvent(
+          event, eventDispatcher, surface.reactHost.currentReactContext)
     } else {
       FLog.w(
           TAG, "Unable to dispatch touch events to JS as the React instance has not been attached")

package/ReactAndroid/src/main/java/com/facebook/react/runtime/hermes/HermesInstance.kt

@@ -13,13 +13,20 @@ import com.facebook.react.fabric.ReactNativeConfig
 import com.facebook.react.runtime.JSRuntimeFactory
 import com.facebook.soloader.SoLoader
 
-public class HermesInstance(reactNativeConfig: ReactNativeConfig?) :
-    JSRuntimeFactory(initHybrid(reactNativeConfig as Any?)) {
+public class HermesInstance(
+    reactNativeConfig: ReactNativeConfig?,
+    allocInOldGenBeforeTTI: Boolean
+) : JSRuntimeFactory(initHybrid(reactNativeConfig as Any?, allocInOldGenBeforeTTI)) {
 
-  public constructor() : this(null)
+  public constructor() : this(null, false)
 
   public companion object {
-    @JvmStatic @DoNotStrip protected external fun initHybrid(reactNativeConfig: Any?): HybridData
+    @JvmStatic
+    @DoNotStrip
+    protected external fun initHybrid(
+        reactNativeConfig: Any?,
+        allocInOldGenBeforeTTI: Boolean
+    ): HybridData
 
     init {
       SoLoader.loadLibrary("hermesinstancejni")

package/ReactAndroid/src/main/java/com/facebook/react/runtime/internal/bolts/Executors.kt

@@ -0,0 +1,44 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+package com.facebook.react.runtime.internal.bolts
+
+import com.facebook.react.bridge.UiThreadUtil
+import java.util.concurrent.Executor
+
+/**
+ * This was created because the helper methods in [java.util.concurrent.Executors] do not work as
+ * people would normally expect.
+ *
+ * Normally, you would think that a cached thread pool would create new threads when necessary,
+ * queue them when the pool is full, and kill threads when they've been inactive for a certain
+ * period of time. This is not how [java.util.concurrent.Executors.newCachedThreadPool] works.
+ *
+ * Instead, [java.util.concurrent.Executors.newCachedThreadPool] executes all tasks on a new or
+ * cached thread immediately because corePoolSize is 0, SynchronousQueue is a queue with size 0 and
+ * maxPoolSize is Integer.MAX_VALUE. This is dangerous because it can create an unchecked amount of
+ * threads.
+ */
+internal object Executors {
+  @JvmField public val UI_THREAD: Executor = UIThreadExecutor()
+  @JvmField public val IMMEDIATE: Executor = ImmediateExecutor()
+
+  private class UIThreadExecutor : Executor {
+    override fun execute(command: Runnable) {
+      UiThreadUtil.runOnUiThread(command)
+    }
+  }
+
+  /**
+   * An [java.util.concurrent.Executor] that schedules tasks to run asynchronously on the UI thread.
+   */
+  private class ImmediateExecutor : Executor {
+    override fun execute(command: Runnable) {
+      command.run()
+    }
+  }
+}

package/ReactAndroid/src/main/java/com/facebook/react/shell/MainReactPackage.java

@@ -9,7 +9,7 @@ package com.facebook.react.shell;
 
 import android.annotation.SuppressLint;
 import androidx.annotation.Nullable;
-import com.facebook.react.TurboReactPackage;
+import com.facebook.react.BaseReactPackage;
 import com.facebook.react.ViewManagerOnDemandReactPackage;
 import com.facebook.react.animated.NativeAnimatedModule;
 import com.facebook.react.bridge.ModuleSpec;
@@ -48,6 +48,7 @@ import com.facebook.react.views.drawer.ReactDrawerLayoutManager;
 import com.facebook.react.views.image.ReactImageManager;
 import com.facebook.react.views.modal.ReactModalHostManager;
 import com.facebook.react.views.progressbar.ReactProgressBarViewManager;
+import com.facebook.react.views.safeareaview.ReactSafeAreaViewManager;
 import com.facebook.react.views.scroll.ReactHorizontalScrollContainerViewManager;
 import com.facebook.react.views.scroll.ReactHorizontalScrollViewManager;
 import com.facebook.react.views.scroll.ReactScrollViewManager;
@@ -93,7 +94,7 @@ import javax.inject.Provider;
       VibrationModule.class,
       WebSocketModule.class,
     })
-public class MainReactPackage extends TurboReactPackage implements ViewManagerOnDemandReactPackage {
+public class MainReactPackage extends BaseReactPackage implements ViewManagerOnDemandReactPackage {
 
   private MainPackageConfig mConfig;
   private @Nullable Map<String, ModuleSpec> mViewManagers;
@@ -169,6 +170,7 @@ public class MainReactPackage extends TurboReactPackage implements ViewManagerOn
     viewManagers.add(new ReactProgressBarViewManager());
     viewManagers.add(new ReactScrollViewManager());
     viewManagers.add(new ReactSwitchManager());
+    viewManagers.add(new ReactSafeAreaViewManager());
     viewManagers.add(new SwipeRefreshLayoutManager());
 
     // Native equivalents
@@ -209,6 +211,7 @@ public class MainReactPackage extends TurboReactPackage implements ViewManagerOn
           ReactHorizontalScrollContainerViewManager::new);
       appendMap(
           viewManagers, ReactProgressBarViewManager.REACT_CLASS, ReactProgressBarViewManager::new);
+      appendMap(viewManagers, ReactSafeAreaViewManager.REACT_CLASS, ReactSafeAreaViewManager::new);
       appendMap(viewManagers, ReactScrollViewManager.REACT_CLASS, ReactScrollViewManager::new);
       appendMap(viewManagers, ReactSwitchManager.REACT_CLASS, ReactSwitchManager::new);
       appendMap(

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

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