react-native 0.69.0-rc.6 → 0.70.0-rc.0

package/ReactAndroid/src/main/java/com/facebook/react/fabric/FabricUIManager.java

@@ -59,6 +59,7 @@ import com.facebook.react.fabric.events.FabricEventEmitter;
 import com.facebook.react.fabric.mounting.MountItemDispatcher;
 import com.facebook.react.fabric.mounting.MountingManager;
 import com.facebook.react.fabric.mounting.SurfaceMountingManager;
+import com.facebook.react.fabric.mounting.SurfaceMountingManager.ViewEvent;
 import com.facebook.react.fabric.mounting.mountitems.DispatchIntCommandMountItem;
 import com.facebook.react.fabric.mounting.mountitems.DispatchStringCommandMountItem;
 import com.facebook.react.fabric.mounting.mountitems.IntBufferBatchMountItem;
@@ -105,8 +106,57 @@ public class FabricUIManager implements UIManager, LifecycleEventListener {
       ReactFeatureFlags.enableFabricLogs
           || PrinterHolder.getPrinter()
               .shouldDisplayLogMessage(ReactDebugOverlayTags.FABRIC_UI_MANAGER);
+  public static final boolean ENABLE_FABRIC_PERF_LOGS = ENABLE_FABRIC_LOGS || false;
   public DevToolsReactPerfLogger mDevToolsReactPerfLogger;
 
+  private static final DevToolsReactPerfLogger.DevToolsReactPerfLoggerListener FABRIC_PERF_LOGGER =
+      new DevToolsReactPerfLogger.DevToolsReactPerfLoggerListener() {
+        @Override
+        public void onFabricCommitEnd(DevToolsReactPerfLogger.FabricCommitPoint commitPoint) {
+          long commitDuration = commitPoint.getCommitDuration();
+          long layoutDuration = commitPoint.getLayoutDuration();
+          long diffDuration = commitPoint.getDiffDuration();
+          long transactionEndDuration = commitPoint.getTransactionEndDuration();
+          long batchExecutionDuration = commitPoint.getBatchExecutionDuration();
+
+          DevToolsReactPerfLogger.mStreamingCommitStats.add(commitDuration);
+          DevToolsReactPerfLogger.mStreamingLayoutStats.add(layoutDuration);
+          DevToolsReactPerfLogger.mStreamingDiffStats.add(diffDuration);
+          DevToolsReactPerfLogger.mStreamingTransactionEndStats.add(transactionEndDuration);
+          DevToolsReactPerfLogger.mStreamingBatchExecutionStats.add(batchExecutionDuration);
+
+          FLog.i(
+              TAG,
+              "Statistics of Fabric commit #%d:\n"
+                  + " - Total commit time: %d ms. Avg: %.2f. Median: %.2f ms. Max: %d ms.\n"
+                  + " - Layout time: %d ms. Avg: %.2f. Median: %.2f ms. Max: %d ms.\n"
+                  + " - Diffing time: %d ms. Avg: %.2f. Median: %.2f ms. Max: %d ms.\n"
+                  + " - FinishTransaction (Diffing + JNI serialization): %d ms. Avg: %.2f. Median: %.2f ms. Max: %d ms.\n"
+                  + " - Mounting: %d ms. Avg: %.2f. Median: %.2f ms. Max: %d ms.\n",
+              commitPoint.getCommitNumber(),
+              commitDuration,
+              DevToolsReactPerfLogger.mStreamingCommitStats.getAverage(),
+              DevToolsReactPerfLogger.mStreamingCommitStats.getMedian(),
+              DevToolsReactPerfLogger.mStreamingCommitStats.getMax(),
+              layoutDuration,
+              DevToolsReactPerfLogger.mStreamingLayoutStats.getAverage(),
+              DevToolsReactPerfLogger.mStreamingLayoutStats.getMedian(),
+              DevToolsReactPerfLogger.mStreamingLayoutStats.getMax(),
+              diffDuration,
+              DevToolsReactPerfLogger.mStreamingDiffStats.getAverage(),
+              DevToolsReactPerfLogger.mStreamingDiffStats.getMedian(),
+              DevToolsReactPerfLogger.mStreamingDiffStats.getMax(),
+              transactionEndDuration,
+              DevToolsReactPerfLogger.mStreamingTransactionEndStats.getAverage(),
+              DevToolsReactPerfLogger.mStreamingTransactionEndStats.getMedian(),
+              DevToolsReactPerfLogger.mStreamingTransactionEndStats.getMax(),
+              batchExecutionDuration,
+              DevToolsReactPerfLogger.mStreamingBatchExecutionStats.getAverage(),
+              DevToolsReactPerfLogger.mStreamingBatchExecutionStats.getMedian(),
+              DevToolsReactPerfLogger.mStreamingBatchExecutionStats.getMax());
+        }
+      };
+
   static {
     FabricSoLoader.staticInit();
   }
@@ -116,6 +166,7 @@ public class FabricUIManager implements UIManager, LifecycleEventListener {
   @NonNull private final MountingManager mMountingManager;
   @NonNull private final EventDispatcher mEventDispatcher;
   @NonNull private final MountItemDispatcher mMountItemDispatcher;
+  @NonNull private final ViewManagerRegistry mViewManagerRegistry;
 
   @NonNull private final EventBeatManager mEventBeatManager;
 
@@ -176,6 +227,9 @@ public class FabricUIManager implements UIManager, LifecycleEventListener {
     mShouldDeallocateEventDispatcher = false;
     mEventBeatManager = eventBeatManager;
     mReactApplicationContext.addLifecycleEventListener(this);
+
+    mViewManagerRegistry = viewManagerRegistry;
+    mReactApplicationContext.registerComponentCallbacks(viewManagerRegistry);
   }
 
   public FabricUIManager(
@@ -194,6 +248,9 @@ public class FabricUIManager implements UIManager, LifecycleEventListener {
     mShouldDeallocateEventDispatcher = true;
     mEventBeatManager = eventBeatManager;
     mReactApplicationContext.addLifecycleEventListener(this);
+
+    mViewManagerRegistry = viewManagerRegistry;
+    mReactApplicationContext.registerComponentCallbacks(viewManagerRegistry);
   }
 
   // TODO (T47819352): Rename this to startSurface for consistency with xplat/iOS
@@ -365,32 +422,10 @@ public class FabricUIManager implements UIManager, LifecycleEventListener {
   public void initialize() {
     mEventDispatcher.registerEventEmitter(FABRIC, new FabricEventEmitter(this));
     mEventDispatcher.addBatchEventDispatchedListener(mEventBeatManager);
-    if (ENABLE_FABRIC_LOGS) {
+    if (ENABLE_FABRIC_PERF_LOGS) {
       mDevToolsReactPerfLogger = new DevToolsReactPerfLogger();
-      mDevToolsReactPerfLogger.addDevToolsReactPerfLoggerListener(
-          new DevToolsReactPerfLogger.DevToolsReactPerfLoggerListener() {
-            @Override
-            public void onFabricCommitEnd(DevToolsReactPerfLogger.FabricCommitPoint commitPoint) {
-              FLog.i(
-                  TAG,
-                  "Statistic of Fabric commit #: "
-                      + commitPoint.getCommitNumber()
-                      + "\n - Total commit time: "
-                      + (commitPoint.getFinishTransactionEnd() - commitPoint.getCommitStart())
-                      + " ms.\n - Layout: "
-                      + (commitPoint.getLayoutEnd() - commitPoint.getLayoutStart())
-                      + " ms.\n - Diffing: "
-                      + (commitPoint.getDiffEnd() - commitPoint.getDiffStart())
-                      + " ms.\n"
-                      + " - FinishTransaction (Diffing + JNI serialization): "
-                      + (commitPoint.getFinishTransactionEnd()
-                          - commitPoint.getFinishTransactionStart())
-                      + " ms.\n"
-                      + " - Mounting: "
-                      + (commitPoint.getBatchExecutionEnd() - commitPoint.getBatchExecutionStart())
-                      + " ms.");
-            }
-          });
+      mDevToolsReactPerfLogger.addDevToolsReactPerfLoggerListener(FABRIC_PERF_LOGGER);
+
       ReactMarker.addFabricListener(mDevToolsReactPerfLogger);
     }
   }
@@ -403,6 +438,7 @@ public class FabricUIManager implements UIManager, LifecycleEventListener {
     FLog.i(TAG, "FabricUIManager.onCatalystInstanceDestroy");
 
     if (mDevToolsReactPerfLogger != null) {
+      mDevToolsReactPerfLogger.removeDevToolsReactPerfLoggerListener(FABRIC_PERF_LOGGER);
       ReactMarker.removeFabricListener(mDevToolsReactPerfLogger);
     }
 
@@ -422,6 +458,8 @@ public class FabricUIManager implements UIManager, LifecycleEventListener {
     mEventDispatcher.removeBatchEventDispatchedListener(mEventBeatManager);
     mEventDispatcher.unregisterEventEmitter(FABRIC);
 
+    mReactApplicationContext.unregisterComponentCallbacks(mViewManagerRegistry);
+
     // Remove lifecycle listeners (onHostResume, onHostPause) since the FabricUIManager is going
     // away. Then stop the mDispatchUIFrameCallback false will cause the choreographer
     // callbacks to stop firing.
@@ -491,11 +529,16 @@ public class FabricUIManager implements UIManager, LifecycleEventListener {
   }
 
   @SuppressWarnings("unused")
-  public int getColor(int surfaceId, ReadableMap platformColor) {
+  public int getColor(int surfaceId, String[] resourcePaths) {
     ThemedReactContext context =
         mMountingManager.getSurfaceManagerEnforced(surfaceId, "getColor").getContext();
-    Integer color = ColorPropConverter.getColor(platformColor, context);
-    return color != null ? color : 0;
+    for (String resourcePath : resourcePaths) {
+      Integer color = ColorPropConverter.resolveResourcePath(context, resourcePath);
+      if (color != null) {
+        return color;
+      }
+    }
+    return 0;
   }
 
   @SuppressWarnings("unused")
@@ -768,9 +811,29 @@ public class FabricUIManager implements UIManager, LifecycleEventListener {
 
     if (shouldSchedule) {
       mMountItemDispatcher.addMountItem(mountItem);
+      Runnable runnable =
+          new Runnable() {
+            @Override
+            public void run() {
+              mMountItemDispatcher.tryDispatchMountItems();
+            }
+          };
       if (UiThreadUtil.isOnUiThread()) {
-        // We only read these flags on the UI thread.
-        mMountItemDispatcher.tryDispatchMountItems();
+        runnable.run();
+      } else {
+        // The Choreographer will dispatch any mount items,
+        // but it only gets called at the /beginning/ of the
+        // frame - it has no idea if, or when, there is actually work scheduled. That means if we
+        // have a big chunk of work
+        // scheduled but the scheduling happens 1ms after the
+        // start of a UI frame, we'll miss out on 15ms of time
+        // to perform the work (assuming a 16ms frame).
+        // The DispatchUIFrameCallback still has value because of
+        // the PreMountItems that we need to process at a lower
+        // priority.
+        if (ReactFeatureFlags.enableEarlyScheduledMountItemExecution) {
+          UiThreadUtil.runOnUiThread(runnable);
+        }
       }
     }
 
@@ -923,8 +986,18 @@ public class FabricUIManager implements UIManager, LifecycleEventListener {
     EventEmitterWrapper eventEmitter = mMountingManager.getEventEmitter(surfaceId, reactTag);
 
     if (eventEmitter == null) {
-      // This can happen if the view has disappeared from the screen (because of async events)
-      FLog.d(TAG, "Unable to invoke event: " + eventName + " for reactTag: " + reactTag);
+      if (ReactFeatureFlags.enableFabricPendingEventQueue
+          && mMountingManager.getViewExists(reactTag)) {
+        // The view is preallocated and created. However, it hasn't been mounted yet. We will have
+        // access to the event emitter later when the view is mounted. For now just save the event
+        // in the view state and trigger it later.
+        mMountingManager.enqueuePendingEvent(
+            reactTag,
+            new ViewEvent(eventName, params, eventCategory, canCoalesceEvent, customCoalesceKey));
+      } else {
+        // This can happen if the view has disappeared from the screen (because of async events)
+        FLog.d(TAG, "Unable to invoke event: " + eventName + " for reactTag: " + reactTag);
+      }
       return;
     }
 

package/ReactAndroid/src/main/java/com/facebook/react/fabric/GuardedFrameCallback.java

@@ -8,20 +8,20 @@
 package com.facebook.react.fabric;
 
 import androidx.annotation.NonNull;
-import com.facebook.react.bridge.NativeModuleCallExceptionHandler;
+import com.facebook.react.bridge.JSExceptionHandler;
 import com.facebook.react.bridge.ReactContext;
 import com.facebook.react.modules.core.ChoreographerCompat;
 
 public abstract class GuardedFrameCallback extends ChoreographerCompat.FrameCallback {
 
-  @NonNull private final NativeModuleCallExceptionHandler mExceptionHandler;
+  @NonNull private final JSExceptionHandler mExceptionHandler;
 
   @Deprecated
   protected GuardedFrameCallback(@NonNull ReactContext reactContext) {
     this(reactContext.getExceptionHandler());
   }
 
-  protected GuardedFrameCallback(@NonNull NativeModuleCallExceptionHandler exceptionHandler) {
+  protected GuardedFrameCallback(@NonNull JSExceptionHandler exceptionHandler) {
     mExceptionHandler = exceptionHandler;
   }
 

package/ReactAndroid/src/main/java/com/facebook/react/fabric/jni/Binding.cpp

@@ -6,8 +6,10 @@
  */
 
 #include "Binding.h"
+
 #include "AsyncEventBeat.h"
 #include "EventEmitterWrapper.h"
+#include "JBackgroundExecutor.h"
 #include "ReactNativeConfigHolder.h"
 #include "StateWrapperImpl.h"
 
@@ -30,6 +32,9 @@
 #include <react/renderer/uimanager/primitives.h>
 #include <react/utils/ContextContainer.h>
 
+// Included to set BaseTextProps config; can be deleted later.
+#include <react/renderer/components/text/BaseTextProps.h>
+
 #include <glog/logging.h>
 
 using namespace facebook::jni;
@@ -76,23 +81,15 @@ Binding::getInspectorDataForInstance(
   return ReadableNativeMap::newObjectCxxArgs(result);
 }
 
-bool isLargeTextMeasureCacheEnabled() {
-  static const auto reactFeatureFlagsJavaDescriptor =
-      jni::findClassStatic(Binding::ReactFeatureFlagsJavaDescriptor);
-  const auto field = reactFeatureFlagsJavaDescriptor->getStaticField<jboolean>(
-      "enableLargeTextMeasureCache");
-  return reactFeatureFlagsJavaDescriptor->getStaticFieldValue(field);
-}
+constexpr static auto ReactFeatureFlagsJavaDescriptor =
+    "com/facebook/react/config/ReactFeatureFlags";
 
-bool isMapBufferSerializationEnabled() {
+static bool getFeatureFlagValue(const char *name) {
   static const auto reactFeatureFlagsJavaDescriptor =
-      jni::findClassStatic(Binding::ReactFeatureFlagsJavaDescriptor);
-  static const auto isMapBufferSerializationEnabledMethod =
-      reactFeatureFlagsJavaDescriptor->getStaticMethod<jboolean()>(
-          "isMapBufferSerializationEnabled");
-  bool value =
-      isMapBufferSerializationEnabledMethod(reactFeatureFlagsJavaDescriptor);
-  return value;
+      jni::findClassStatic(ReactFeatureFlagsJavaDescriptor);
+  const auto field =
+      reactFeatureFlagsJavaDescriptor->getStaticField<jboolean>(name);
+  return reactFeatureFlagsJavaDescriptor->getStaticFieldValue(field);
 }
 
 void Binding::setPixelDensity(float pointScaleFactor) {
@@ -375,8 +372,8 @@ void Binding::installFabricUIManager(
   disableRevisionCheckForPreallocation_ =
       config->getBool("react_fabric:disable_revision_check_for_preallocation");
 
-  disablePreallocationOnClone_ = config->getBool(
-      "react_native_new_architecture:disable_preallocation_on_clone_android");
+  disablePreallocationOnClone_ =
+      getFeatureFlagValue("disablePreallocationOnClone");
 
   if (enableFabricLogs_) {
     LOG(WARNING) << "Binding::installFabricUIManager() was called (address: "
@@ -399,8 +396,6 @@ void Binding::installFabricUIManager(
   if (runtimeSchedulerHolder) {
     auto runtimeScheduler = runtimeSchedulerHolder->cthis()->get().lock();
     if (runtimeScheduler) {
-      runtimeScheduler->setEnableYielding(config->getBool(
-          "react_native_new_architecture:runtimescheduler_enable_yielding_android"));
       runtimeExecutor =
           [runtimeScheduler](
               std::function<void(jsi::Runtime & runtime)> &&callback) {
@@ -436,7 +431,8 @@ void Binding::installFabricUIManager(
   reactNativeConfig_ = config;
 
   contextContainer->insert(
-      "MapBufferSerializationEnabled", isMapBufferSerializationEnabled());
+      "MapBufferSerializationEnabled",
+      getFeatureFlagValue("mapBufferSerializationEnabled"));
 
   disablePreallocateViews_ = reactNativeConfig_->getBool(
       "react_fabric:disabled_view_preallocation_android");
@@ -445,7 +441,19 @@ void Binding::installFabricUIManager(
       "react_native_new_architecture:dispatch_preallocation_in_bg");
 
   contextContainer->insert(
-      "EnableLargeTextMeasureCache", isLargeTextMeasureCacheEnabled());
+      "EnableLargeTextMeasureCache",
+      getFeatureFlagValue("enableLargeTextMeasureCache"));
+
+  // Props setter pattern feature
+  Props::enablePropIteratorSetter =
+      getFeatureFlagValue("enableCppPropsIteratorSetter");
+  AccessibilityProps::enablePropIteratorSetter =
+      Props::enablePropIteratorSetter;
+  BaseTextProps::enablePropIteratorSetter = Props::enablePropIteratorSetter;
+
+  // RemoveDelete mega-op
+  ShadowViewMutation::PlatformSupportsRemoveDeleteTreeInstruction =
+      getFeatureFlagValue("enableRemoveDeleteTreeInstruction");
 
   auto toolbox = SchedulerToolbox{};
   toolbox.contextContainer = contextContainer;
@@ -454,8 +462,8 @@ void Binding::installFabricUIManager(
   toolbox.synchronousEventBeatFactory = synchronousBeatFactory;
   toolbox.asynchronousEventBeatFactory = asynchronousBeatFactory;
 
-  backgroundExecutor_ = std::make_unique<JBackgroundExecutor>();
-  toolbox.backgroundExecutor = backgroundExecutor_->get();
+  backgroundExecutor_ = JBackgroundExecutor::create("fabric_bg");
+  toolbox.backgroundExecutor = backgroundExecutor_;
 
   animationDriver_ = std::make_shared<LayoutAnimationDriver>(
       runtimeExecutor, contextContainer, this);
@@ -557,8 +565,7 @@ void Binding::preallocateView(
   };
 
   if (dispatchPreallocationInBackground_) {
-    auto backgroundExecutor = backgroundExecutor_->get();
-    backgroundExecutor(preallocationFunction);
+    backgroundExecutor_(preallocationFunction);
   } else {
     preallocationFunction();
   }

package/ReactAndroid/src/main/java/com/facebook/react/fabric/jni/Binding.h

@@ -9,6 +9,9 @@
 
 #include "FabricMountingManager.h"
 
+#include <memory>
+#include <mutex>
+
 #include <fbjni/fbjni.h>
 #include <react/jni/JRuntimeExecutor.h>
 #include <react/jni/JRuntimeScheduler.h>
@@ -18,12 +21,9 @@
 #include <react/renderer/scheduler/SchedulerDelegate.h>
 #include <react/renderer/uimanager/LayoutAnimationStatusDelegate.h>
 
-#include <memory>
-#include <mutex>
 #include "ComponentFactory.h"
 #include "EventBeatManager.h"
 #include "EventEmitterWrapper.h"
-#include "JBackgroundExecutor.h"
 #include "SurfaceHandlerBinding.h"
 
 namespace facebook {
@@ -38,9 +38,6 @@ class Binding : public jni::HybridClass<Binding>,
   constexpr static const char *const kJavaDescriptor =
       "Lcom/facebook/react/fabric/Binding;";
 
-  constexpr static auto ReactFeatureFlagsJavaDescriptor =
-      "com/facebook/react/config/ReactFeatureFlags";
-
   static void registerNatives();
 
   std::shared_ptr<Scheduler> getScheduler();
@@ -144,7 +141,7 @@ class Binding : public jni::HybridClass<Binding>,
 
   std::shared_ptr<LayoutAnimationDriver> animationDriver_;
 
-  std::unique_ptr<JBackgroundExecutor> backgroundExecutor_;
+  BackgroundExecutor backgroundExecutor_;
 
   butter::map<SurfaceId, SurfaceHandler> surfaceHandlerRegistry_{};
   butter::shared_mutex

package/ReactAndroid/src/main/java/com/facebook/react/fabric/jni/FabricMountItem.cpp

@@ -28,6 +28,13 @@ CppMountItem CppMountItem::RemoveMountItem(
     int index) {
   return {CppMountItem::Type::Remove, parentView, shadowView, {}, index};
 }
+CppMountItem CppMountItem::RemoveDeleteTreeMountItem(
+    ShadowView const &parentView,
+    ShadowView const &shadowView,
+    int index) {
+  return {
+      CppMountItem::Type::RemoveDeleteTree, parentView, shadowView, {}, index};
+}
 CppMountItem CppMountItem::UpdatePropsMountItem(
     ShadowView const &oldShadowView,
     ShadowView const &newShadowView) {

package/ReactAndroid/src/main/java/com/facebook/react/fabric/jni/FabricMountItem.h

@@ -35,6 +35,11 @@ struct CppMountItem final {
       ShadowView const &shadowView,
       int index);
 
+  static CppMountItem RemoveDeleteTreeMountItem(
+      ShadowView const &parentView,
+      ShadowView const &shadowView,
+      int index);
+
   static CppMountItem UpdatePropsMountItem(
       ShadowView const &oldShadowView,
       ShadowView const &newShadowView);
@@ -64,7 +69,8 @@ struct CppMountItem final {
     UpdateLayout = 128,
     UpdateEventEmitter = 256,
     UpdatePadding = 512,
-    UpdateOverflowInset = 1024
+    UpdateOverflowInset = 1024,
+    RemoveDeleteTree = 2048,
   };
 
 #pragma mark - Fields

package/ReactAndroid/src/main/java/com/facebook/react/fabric/jni/FabricMountingManager.cpp

@@ -28,13 +28,12 @@ using namespace facebook::jni;
 namespace facebook {
 namespace react {
 
-static bool doesUseOverflowInset() {
+static bool getFeatureFlagValue(const char *name) {
   static const auto reactFeatureFlagsJavaDescriptor = jni::findClassStatic(
       FabricMountingManager::ReactFeatureFlagsJavaDescriptor);
-  static const auto doesUseOverflowInset =
-      reactFeatureFlagsJavaDescriptor->getStaticMethod<jboolean()>(
-          "doesUseOverflowInset");
-  return doesUseOverflowInset(reactFeatureFlagsJavaDescriptor);
+  const auto field =
+      reactFeatureFlagsJavaDescriptor->getStaticField<jboolean>(name);
+  return reactFeatureFlagsJavaDescriptor->getStaticFieldValue(field);
 }
 
 FabricMountingManager::FabricMountingManager(
@@ -47,9 +46,9 @@ FabricMountingManager::FabricMountingManager(
           config->getBool("react_fabric:disabled_view_preallocation_android")),
       disableRevisionCheckForPreallocation_(config->getBool(
           "react_fabric:disable_revision_check_for_preallocation")),
-      useOverflowInset_(doesUseOverflowInset()),
-      shouldRememberAllocatedViews_(config->getBool(
-          "react_native_new_architecture:remember_views_on_mount_android")),
+      useOverflowInset_(getFeatureFlagValue("useOverflowInset")),
+      shouldRememberAllocatedViews_(
+          getFeatureFlagValue("shouldRememberAllocatedViews")),
       useMapBufferForViewProps_(config->getBool(
           "react_native_new_architecture:use_mapbuffer_for_viewprops")) {}
 
@@ -70,6 +69,8 @@ static inline int getIntBufferSizeForType(CppMountItem::Type mountItemType) {
     case CppMountItem::Type::Insert:
     case CppMountItem::Type::Remove:
       return 3; // tag, parentTag, index
+    case CppMountItem::Type::RemoveDeleteTree:
+      return 3; // tag, parentTag, index
     case CppMountItem::Type::Delete:
     case CppMountItem::Type::UpdateProps:
     case CppMountItem::Type::UpdateState:
@@ -333,15 +334,25 @@ void FabricMountingManager::executeMount(
           break;
         }
         case ShadowViewMutation::Remove: {
-          if (!isVirtual) {
+          if (!isVirtual && !mutation.isRedundantOperation) {
             cppCommonMountItems.push_back(CppMountItem::RemoveMountItem(
                 parentShadowView, oldChildShadowView, index));
           }
           break;
         }
+        case ShadowViewMutation::RemoveDeleteTree: {
+          if (!isVirtual) {
+            cppCommonMountItems.push_back(
+                CppMountItem::RemoveDeleteTreeMountItem(
+                    parentShadowView, oldChildShadowView, index));
+          }
+          break;
+        }
         case ShadowViewMutation::Delete: {
-          cppDeleteMountItems.push_back(
-              CppMountItem::DeleteMountItem(oldChildShadowView));
+          if (!mutation.isRedundantOperation) {
+            cppDeleteMountItems.push_back(
+                CppMountItem::DeleteMountItem(oldChildShadowView));
+          }
           break;
         }
         case ShadowViewMutation::Update: {
@@ -422,20 +433,23 @@ void FabricMountingManager::executeMount(
             // are updated in the view. This is necessary to ensure that events
             // (resulting from layout changes) are dispatched with the correct
             // padding information.
-            cppUpdatePaddingMountItems.push_back(
-                CppMountItem::UpdatePaddingMountItem(
-                    mutation.newChildShadowView));
+            if (newChildShadowView.layoutMetrics.contentInsets !=
+                EdgeInsets::ZERO) {
+              cppUpdatePaddingMountItems.push_back(
+                  CppMountItem::UpdatePaddingMountItem(newChildShadowView));
+            }
 
             // Layout
             cppUpdateLayoutMountItems.push_back(
-                CppMountItem::UpdateLayoutMountItem(
-                    mutation.newChildShadowView));
+                CppMountItem::UpdateLayoutMountItem(newChildShadowView));
 
             // OverflowInset: This is the values indicating boundaries including
             // children of the current view. The layout of current view may not
             // change, and we separate this part from layout mount items to not
             // pack too much data there.
-            if (useOverflowInset_) {
+            if (useOverflowInset_ &&
+                newChildShadowView.layoutMetrics.overflowInset !=
+                    EdgeInsets::ZERO) {
               cppUpdateOverflowInsetMountItems.push_back(
                   CppMountItem::UpdateOverflowInsetMountItem(
                       newChildShadowView));
@@ -607,6 +621,12 @@ void FabricMountingManager::executeMount(
       temp[2] = mountItem.index;
       env->SetIntArrayRegion(intBufferArray, intBufferPosition, 3, temp);
       intBufferPosition += 3;
+    } else if (mountItemType == CppMountItem::RemoveDeleteTree) {
+      temp[0] = mountItem.oldChildShadowView.tag;
+      temp[1] = mountItem.parentShadowView.tag;
+      temp[2] = mountItem.index;
+      env->SetIntArrayRegion(intBufferArray, intBufferPosition, 3, temp);
+      intBufferPosition += 3;
     } else {
       LOG(ERROR) << "Unexpected CppMountItem type";
     }

package/ReactAndroid/src/main/java/com/facebook/react/fabric/jni/JBackgroundExecutor.cpp

@@ -5,29 +5,24 @@
  * LICENSE file in the root directory of this source tree.
  */
 
-#include <fbjni/fbjni.h>
-#include <react/jni/JNativeRunnable.h>
-
 #include "JBackgroundExecutor.h"
 
+#include <fbjni/NativeRunnable.h>
+#include <fbjni/fbjni.h>
+
 namespace facebook {
 namespace react {
 
 using namespace facebook::jni;
 
-using facebook::react::JNativeRunnable;
-using facebook::react::Runnable;
-
-BackgroundExecutor JBackgroundExecutor::get() {
-  auto self = JBackgroundExecutor::create();
-
-  return [self](std::function<void()> &&runnable) {
+BackgroundExecutor JBackgroundExecutor::create(const std::string &name) {
+  auto instance = make_global(newInstance(name));
+  return [instance = std::move(instance)](std::function<void()> &&runnable) {
     static auto method =
-        findClassStatic(JBackgroundExecutor::JBackgroundExecutorJavaDescriptor)
-            ->getMethod<void(Runnable::javaobject)>("queueRunnable");
-
+        javaClassStatic()->getMethod<void(JRunnable::javaobject)>(
+            "queueRunnable");
     auto jrunnable = JNativeRunnable::newObjectCxxArgs(std::move(runnable));
-    method(self, static_ref_cast<Runnable::javaobject>(jrunnable).get());
+    method(instance, jrunnable.get());
   };
 }
 

package/ReactAndroid/src/main/java/com/facebook/react/fabric/jni/JBackgroundExecutor.h

@@ -20,14 +20,7 @@ class JBackgroundExecutor : public JavaClass<JBackgroundExecutor> {
   static auto constexpr kJavaDescriptor =
       "Lcom/facebook/react/bridge/BackgroundExecutor;";
 
-  constexpr static auto JBackgroundExecutorJavaDescriptor =
-      "com/facebook/react/bridge/BackgroundExecutor";
-
-  static global_ref<javaobject> create() {
-    return make_global(newInstance());
-  }
-
-  BackgroundExecutor get();
+  static BackgroundExecutor create(const std::string &name);
 };
 
 } // namespace react

package/ReactAndroid/src/main/java/com/facebook/react/fabric/jni/viewPropConversions.h

@@ -55,6 +55,9 @@ constexpr MapBuffer::Key VP_SHADOW_COLOR = 31;
 constexpr MapBuffer::Key VP_TEST_ID = 32;
 constexpr MapBuffer::Key VP_TRANSFORM = 33;
 constexpr MapBuffer::Key VP_ZINDEX = 34;
+constexpr MapBuffer::Key VP_POINTER_ENTER_CAPTURE = 38;
+constexpr MapBuffer::Key VP_POINTER_LEAVE_CAPTURE = 39;
+constexpr MapBuffer::Key VP_POINTER_MOVE_CAPTURE = 40;
 
 // Yoga values
 constexpr MapBuffer::Key YG_BORDER_WIDTH = 100;
@@ -462,6 +465,16 @@ static inline MapBuffer viewPropsDiff(
         VP_POINTER_LEAVE, newProps.events[ViewEvents::Offset::PointerLeave]);
     builder.putBool(
         VP_POINTER_MOVE, newProps.events[ViewEvents::Offset::PointerMove]);
+
+    builder.putBool(
+        VP_POINTER_ENTER_CAPTURE,
+        newProps.events[ViewEvents::Offset::PointerEnterCapture]);
+    builder.putBool(
+        VP_POINTER_LEAVE_CAPTURE,
+        newProps.events[ViewEvents::Offset::PointerLeaveCapture]);
+    builder.putBool(
+        VP_POINTER_MOVE_CAPTURE,
+        newProps.events[ViewEvents::Offset::PointerMoveCapture]);
   }
 
   if (oldProps.removeClippedSubviews != newProps.removeClippedSubviews) {

package/ReactAndroid/src/main/java/com/facebook/react/fabric/mounting/LayoutMetricsConversions.java

@@ -13,7 +13,7 @@ import android.view.View;
 import com.facebook.react.uimanager.PixelUtil;
 import com.facebook.yoga.YogaMeasureMode;
 
-public class LayoutMetricsConversions {
+public interface LayoutMetricsConversions {
 
   public static float getMinSize(int viewMeasureSpec) {
     int mode = View.MeasureSpec.getMode(viewMeasureSpec);