react-native-tvos 0.76.5-0 → 0.77.0-0

package/ReactAndroid/src/main/jni/react/fabric/{Binding.cpp → FabricUIManagerBinding.cpp}

@@ -5,15 +5,14 @@
  * LICENSE file in the root directory of this source tree.
  */
 
-#include "Binding.h"
+#include "FabricUIManagerBinding.h"
 
-#include "AsyncEventBeat.h"
+#include "AndroidEventBeat.h"
 #include "ComponentFactory.h"
 #include "EventBeatManager.h"
 #include "EventEmitterWrapper.h"
 #include "FabricMountingManager.h"
 #include "ReactNativeConfigHolder.h"
-#include "SurfaceHandlerBinding.h"
 
 #include <cxxreact/SystraceSection.h>
 #include <fbjni/fbjni.h>
@@ -31,17 +30,15 @@
 #include <react/renderer/scheduler/SchedulerToolbox.h>
 #include <react/renderer/uimanager/primitives.h>
 #include <react/utils/ContextContainer.h>
-#include <react/utils/CoreFeatures.h>
 
 namespace facebook::react {
 
-jni::local_ref<Binding::jhybriddata> Binding::initHybrid(
-    jni::alias_ref<jclass>) {
-  return makeCxxInstance();
+void FabricUIManagerBinding::initHybrid(jni::alias_ref<jhybridobject> jobj) {
+  setCxxInstance(jobj);
 }
 
 // Thread-safe getter
-std::shared_ptr<Scheduler> Binding::getScheduler() {
+std::shared_ptr<Scheduler> FabricUIManagerBinding::getScheduler() {
   std::shared_lock lock(installMutex_);
   // Need to return a copy of the shared_ptr to make sure this is safe if called
   // concurrently with uninstallFabricUIManager
@@ -49,11 +46,11 @@ std::shared_ptr<Scheduler> Binding::getScheduler() {
 }
 
 jni::local_ref<ReadableNativeMap::jhybridobject>
-Binding::getInspectorDataForInstance(
+FabricUIManagerBinding::getInspectorDataForInstance(
     jni::alias_ref<EventEmitterWrapper::javaobject> eventEmitterWrapper) {
   auto scheduler = getScheduler();
   if (!scheduler) {
-    LOG(ERROR) << "Binding::startSurface: scheduler disappeared";
+    LOG(ERROR) << "FabricUIManagerBinding::startSurface: scheduler disappeared";
     return ReadableNativeMap::newObjectCxxArgs(folly::dynamic::object());
   }
 
@@ -75,25 +72,15 @@ Binding::getInspectorDataForInstance(
   return ReadableNativeMap::newObjectCxxArgs(result);
 }
 
-constexpr static auto kReactFeatureFlagsJavaDescriptor =
-    "com/facebook/react/config/ReactFeatureFlags";
-
-static bool getFeatureFlagValue(const char* name) {
-  static const auto reactFeatureFlagsClass =
-      jni::findClassStatic(kReactFeatureFlagsJavaDescriptor);
-  const auto field = reactFeatureFlagsClass->getStaticField<jboolean>(name);
-  return reactFeatureFlagsClass->getStaticFieldValue(field);
-}
-
-void Binding::setPixelDensity(float pointScaleFactor) {
+void FabricUIManagerBinding::setPixelDensity(float pointScaleFactor) {
   pointScaleFactor_ = pointScaleFactor;
 }
 
-void Binding::driveCxxAnimations() {
+void FabricUIManagerBinding::driveCxxAnimations() {
   getScheduler()->animationTick();
 }
 
-void Binding::drainPreallocateViewsQueue() {
+void FabricUIManagerBinding::drainPreallocateViewsQueue() {
   auto mountingManager = getMountingManager("drainPreallocateViewsQueue");
   if (!mountingManager) {
     return;
@@ -101,7 +88,7 @@ void Binding::drainPreallocateViewsQueue() {
   mountingManager->drainPreallocateViewsQueue();
 }
 
-void Binding::reportMount(SurfaceId surfaceId) {
+void FabricUIManagerBinding::reportMount(SurfaceId surfaceId) {
   if (ReactNativeFeatureFlags::
           fixMountingCoordinatorReportedPendingTransactionsOnAndroid()) {
     // This is a fix for `MountingCoordinator::hasPendingTransactions` on
@@ -109,17 +96,34 @@ void Binding::reportMount(SurfaceId surfaceId) {
     // incorrectly. This is due to the push model used on Android and can be
     // removed when we migrate to a pull model.
     std::shared_lock lock(surfaceHandlerRegistryMutex_);
-
     auto iterator = surfaceHandlerRegistry_.find(surfaceId);
     if (iterator != surfaceHandlerRegistry_.end()) {
-      auto& surfaceHandler = iterator->second;
-      surfaceHandler.getMountingCoordinator()->didPerformAsyncTransactions();
+      const auto* surfaceHandler =
+          std::get_if<SurfaceHandler>(&iterator->second);
+      if (surfaceHandler == nullptr) {
+        auto javaSurfaceHandler =
+            std::get<jni::weak_ref<SurfaceHandlerBinding::jhybridobject>>(
+                iterator->second)
+                .lockLocal();
+        if (javaSurfaceHandler) {
+          surfaceHandler = &javaSurfaceHandler->cthis()->getSurfaceHandler();
+        }
+      }
+      if (surfaceHandler != nullptr) {
+        auto mountingCoordinator = surfaceHandler->getMountingCoordinator();
+        if (mountingCoordinator != nullptr) {
+          mountingCoordinator->didPerformAsyncTransactions();
+        }
+      }
+    } else {
+      LOG(ERROR) << "FabricUIManagerBinding::reportMount: Surface with id "
+                 << surfaceId << " is not found";
     }
   }
 
   auto scheduler = getScheduler();
   if (!scheduler) {
-    LOG(ERROR) << "Binding::reportMount: scheduler disappeared";
+    LOG(ERROR) << "FabricUIManagerBinding::reportMount: scheduler disappeared";
     return;
   }
   scheduler->reportMount(surfaceId);
@@ -127,15 +131,67 @@ void Binding::reportMount(SurfaceId surfaceId) {
 
 #pragma mark - Surface management
 
-void Binding::startSurface(
+// Used by bridgeless
+void FabricUIManagerBinding::startSurfaceWithSurfaceHandler(
+    jint surfaceId,
+    jni::alias_ref<SurfaceHandlerBinding::jhybridobject> surfaceHandlerBinding,
+    jboolean isMountable) {
+  SystraceSection s("FabricUIManagerBinding::startSurfaceWithSurfaceHandler");
+  if (enableFabricLogs_) {
+    LOG(WARNING)
+        << "FabricUIManagerBinding::startSurfaceWithSurfaceHandler() was called (address: "
+        << this << ", surfaceId: " << surfaceId << ").";
+  }
+
+  const auto& surfaceHandler =
+      surfaceHandlerBinding->cthis()->getSurfaceHandler();
+  surfaceHandler.setSurfaceId(surfaceId);
+  surfaceHandler.setDisplayMode(
+      isMountable != 0 ? DisplayMode::Visible : DisplayMode::Suspended);
+
+  auto scheduler = getScheduler();
+  if (!scheduler) {
+    LOG(ERROR)
+        << "FabricUIManagerBinding::startSurfaceWithSurfaceHandler: scheduler disappeared";
+    return;
+  }
+  scheduler->registerSurface(surfaceHandler);
+
+  auto mountingManager = getMountingManager("startSurfaceWithSurfaceHandler");
+  if (mountingManager != nullptr) {
+    mountingManager->onSurfaceStart(surfaceId);
+  }
+
+  surfaceHandler.start();
+
+  if (ReactNativeFeatureFlags::enableLayoutAnimationsOnAndroid()) {
+    surfaceHandler.getMountingCoordinator()->setMountingOverrideDelegate(
+        animationDriver_);
+  }
+
+  {
+    std::unique_lock lock(surfaceHandlerRegistryMutex_);
+    surfaceHandlerRegistry_.emplace(
+        surfaceId, jni::make_weak(surfaceHandlerBinding));
+  }
+}
+
+// Used by non-bridgeless+Fabric
+void FabricUIManagerBinding::startSurface(
     jint surfaceId,
     jni::alias_ref<jstring> moduleName,
     NativeMap* initialProps) {
   SystraceSection s("FabricUIManagerBinding::startSurface");
 
+  if (enableFabricLogs_) {
+    LOG(WARNING)
+        << "FabricUIManagerBinding::startSurface() was called (address: "
+        << this << ", surfaceId: " << surfaceId << ").";
+  }
+
   auto scheduler = getScheduler();
   if (!scheduler) {
-    LOG(ERROR) << "Binding::startSurface: scheduler disappeared";
+    LOG(ERROR) << "FabricUIManagerBinding::startSurface: scheduler disappeared";
     return;
   }
 
@@ -149,26 +205,26 @@ void Binding::startSurface(
 
   scheduler->registerSurface(surfaceHandler);
 
+  auto mountingManager = getMountingManager("startSurface");
+  if (mountingManager != nullptr) {
+    mountingManager->onSurfaceStart(surfaceId);
+  }
+
   surfaceHandler.start();
 
-  surfaceHandler.getMountingCoordinator()->setMountingOverrideDelegate(
-      animationDriver_);
+  if (ReactNativeFeatureFlags::enableLayoutAnimationsOnAndroid()) {
+    surfaceHandler.getMountingCoordinator()->setMountingOverrideDelegate(
+        animationDriver_);
+  }
 
   {
-    SystraceSection s2("FabricUIManagerBinding::startSurface::surfaceId::lock");
     std::unique_lock lock(surfaceHandlerRegistryMutex_);
-    SystraceSection s3("FabricUIManagerBinding::startSurface::surfaceId");
     surfaceHandlerRegistry_.emplace(surfaceId, std::move(surfaceHandler));
   }
-
-  auto mountingManager = getMountingManager("startSurface");
-  if (!mountingManager) {
-    return;
-  }
-  mountingManager->onSurfaceStart(surfaceId);
 }
 
-void Binding::startSurfaceWithConstraints(
+// Used by non-bridgeless+Fabric
+void FabricUIManagerBinding::startSurfaceWithConstraints(
     jint surfaceId,
     jni::alias_ref<jstring> moduleName,
     NativeMap* initialProps,
@@ -184,13 +240,14 @@ void Binding::startSurfaceWithConstraints(
 
   if (enableFabricLogs_) {
     LOG(WARNING)
-        << "Binding::startSurfaceWithConstraints() was called (address: "
+        << "FabricUIManagerBinding::startSurfaceWithConstraints() was called (address: "
         << this << ", surfaceId: " << surfaceId << ").";
   }
 
   auto scheduler = getScheduler();
   if (!scheduler) {
-    LOG(ERROR) << "Binding::startSurfaceWithConstraints: scheduler disappeared";
+    LOG(ERROR)
+        << "FabricUIManagerBinding::startSurfaceWithConstraints: scheduler disappeared";
     return;
   }
 
@@ -203,12 +260,12 @@ void Binding::startSurfaceWithConstraints(
   context.viewportOffset =
       Point{offsetX / pointScaleFactor_, offsetY / pointScaleFactor_};
   context.pointScaleFactor = {pointScaleFactor_};
-  context.swapLeftAndRightInRTL = doLeftAndRightSwapInRTL;
+  context.swapLeftAndRightInRTL = doLeftAndRightSwapInRTL != 0;
   LayoutConstraints constraints = {};
   constraints.minimumSize = minimumSize;
   constraints.maximumSize = maximumSize;
   constraints.layoutDirection =
-      isRTL ? LayoutDirection::RightToLeft : LayoutDirection::LeftToRight;
+      isRTL != 0 ? LayoutDirection::RightToLeft : LayoutDirection::LeftToRight;
 
   auto surfaceHandler = SurfaceHandler{moduleName->toStdString(), surfaceId};
   surfaceHandler.setContextContainer(scheduler->getContextContainer());
@@ -217,55 +274,56 @@ void Binding::startSurfaceWithConstraints(
 
   scheduler->registerSurface(surfaceHandler);
 
+  auto mountingManager = getMountingManager("startSurfaceWithConstraints");
+  if (mountingManager != nullptr) {
+    mountingManager->onSurfaceStart(surfaceId);
+  }
+
   surfaceHandler.start();
 
-  surfaceHandler.getMountingCoordinator()->setMountingOverrideDelegate(
-      animationDriver_);
+  if (ReactNativeFeatureFlags::enableLayoutAnimationsOnAndroid()) {
+    surfaceHandler.getMountingCoordinator()->setMountingOverrideDelegate(
+        animationDriver_);
+  }
 
   {
-    SystraceSection s2(
-        "FabricUIManagerBinding::startSurfaceWithConstraints::surfaceId::lock");
     std::unique_lock lock(surfaceHandlerRegistryMutex_);
-    SystraceSection s3(
-        "FabricUIManagerBinding::startSurfaceWithConstraints::surfaceId");
     surfaceHandlerRegistry_.emplace(surfaceId, std::move(surfaceHandler));
   }
-
-  auto mountingManager = getMountingManager("startSurfaceWithConstraints");
-  if (!mountingManager) {
-    return;
-  }
-  mountingManager->onSurfaceStart(surfaceId);
 }
 
-void Binding::stopSurface(jint surfaceId) {
+// Used by non-bridgeless+Fabric
+void FabricUIManagerBinding::stopSurface(jint surfaceId) {
   SystraceSection s("FabricUIManagerBinding::stopSurface");
-
   if (enableFabricLogs_) {
-    LOG(WARNING) << "Binding::stopSurface() was called (address: " << this
-                 << ", surfaceId: " << surfaceId << ").";
+    LOG(WARNING)
+        << "FabricUIManagerBinding::stopSurface() was called (address: " << this
+        << ", surfaceId: " << surfaceId << ").";
   }
 
   auto scheduler = getScheduler();
   if (!scheduler) {
-    LOG(ERROR) << "Binding::stopSurface: scheduler disappeared";
+    LOG(ERROR) << "FabricUIManagerBinding::stopSurface: scheduler disappeared";
     return;
   }
 
   {
     std::unique_lock lock(surfaceHandlerRegistryMutex_);
-
     auto iterator = surfaceHandlerRegistry_.find(surfaceId);
-
     if (iterator == surfaceHandlerRegistry_.end()) {
-      LOG(ERROR) << "Binding::stopSurface: Surface with given id is not found";
+      LOG(ERROR)
+          << "FabricUIManagerBinding::stopSurface: Surface with given id is not found";
       return;
     }
 
-    auto surfaceHandler = std::move(iterator->second);
+    auto* surfaceHandler = std::get_if<SurfaceHandler>(&iterator->second);
+    if (surfaceHandler != nullptr) {
+      surfaceHandler->stop();
+      scheduler->unregisterSurface(*surfaceHandler);
+    } else {
+      LOG(ERROR) << "Java-owned SurfaceHandler found in stopSurface";
+    }
     surfaceHandlerRegistry_.erase(iterator);
-    surfaceHandler.stop();
-    scheduler->unregisterSurface(surfaceHandler);
   }
 
   auto mountingManager = getMountingManager("stopSurface");
@@ -275,31 +333,34 @@ void Binding::stopSurface(jint surfaceId) {
   mountingManager->onSurfaceStop(surfaceId);
 }
 
-void Binding::registerSurface(SurfaceHandlerBinding* surfaceHandlerBinding) {
-  const auto& surfaceHandler = surfaceHandlerBinding->getSurfaceHandler();
-  auto scheduler = getScheduler();
-  if (!scheduler) {
-    LOG(ERROR) << "Binding::registerSurface: scheduler disappeared";
-    return;
+// Used by bridgeless
+void FabricUIManagerBinding::stopSurfaceWithSurfaceHandler(
+    jni::alias_ref<SurfaceHandlerBinding::jhybridobject>
+        surfaceHandlerBinding) {
+  SystraceSection s("FabricUIManagerBinding::stopSurfaceWithSurfaceHandler");
+  const auto& surfaceHandler =
+      surfaceHandlerBinding->cthis()->getSurfaceHandler();
+  if (enableFabricLogs_) {
+    LOG(WARNING)
+        << "FabricUIManagerBinding::stopSurfaceWithSurfaceHandler() was called (address: "
+        << this << ", surfaceId: " << surfaceHandler.getSurfaceId() << ").";
   }
-  scheduler->registerSurface(surfaceHandler);
 
-  auto mountingManager = getMountingManager("registerSurface");
-  if (!mountingManager) {
-    return;
-  }
-  mountingManager->onSurfaceStart(surfaceHandler.getSurfaceId());
-}
+  surfaceHandler.stop();
 
-void Binding::unregisterSurface(SurfaceHandlerBinding* surfaceHandlerBinding) {
-  const auto& surfaceHandler = surfaceHandlerBinding->getSurfaceHandler();
   auto scheduler = getScheduler();
   if (!scheduler) {
-    LOG(ERROR) << "Binding::unregisterSurface: scheduler disappeared";
+    LOG(ERROR)
+        << "FabricUIManagerBinding::unregisterSurface: scheduler disappeared";
     return;
   }
   scheduler->unregisterSurface(surfaceHandler);
 
+  {
+    std::unique_lock lock(surfaceHandlerRegistryMutex_);
+    surfaceHandlerRegistry_.erase(surfaceHandler.getSurfaceId());
+  }
+
   auto mountingManager = getMountingManager("unregisterSurface");
   if (!mountingManager) {
     return;
@@ -307,7 +368,7 @@ void Binding::unregisterSurface(SurfaceHandlerBinding* surfaceHandlerBinding) {
   mountingManager->onSurfaceStop(surfaceHandler.getSurfaceId());
 }
 
-void Binding::setConstraints(
+void FabricUIManagerBinding::setConstraints(
     jint surfaceId,
     jfloat minWidth,
     jfloat maxWidth,
@@ -321,7 +382,8 @@ void Binding::setConstraints(
 
   auto scheduler = getScheduler();
   if (!scheduler) {
-    LOG(ERROR) << "Binding::setConstraints: scheduler disappeared";
+    LOG(ERROR)
+        << "FabricUIManagerBinding::setConstraints: scheduler disappeared";
     return;
   }
 
@@ -334,7 +396,7 @@ void Binding::setConstraints(
   context.viewportOffset =
       Point{offsetX / pointScaleFactor_, offsetY / pointScaleFactor_};
   context.pointScaleFactor = {pointScaleFactor_};
-  context.swapLeftAndRightInRTL = doLeftAndRightSwapInRTL;
+  context.swapLeftAndRightInRTL = doLeftAndRightSwapInRTL != 0;
   LayoutConstraints constraints = {};
   constraints.minimumSize = minimumSize;
   constraints.maximumSize = maximumSize;
@@ -343,23 +405,22 @@ void Binding::setConstraints(
 
   {
     std::shared_lock lock(surfaceHandlerRegistryMutex_);
-
     auto iterator = surfaceHandlerRegistry_.find(surfaceId);
-
     if (iterator == surfaceHandlerRegistry_.end()) {
       LOG(ERROR)
-          << "Binding::setConstraints: Surface with given id is not found";
+          << "FabricUIManagerBinding::setConstraints: Surface with given id is not found";
       return;
     }
-
-    auto& surfaceHandler = iterator->second;
-    surfaceHandler.constraintLayout(constraints, context);
+    auto* surfaceHandler = std::get_if<SurfaceHandler>(&iterator->second);
+    if (surfaceHandler != nullptr) {
+      surfaceHandler->constraintLayout(constraints, context);
+    }
   }
 }
 
 #pragma mark - Install/uninstall java binding
 
-void Binding::installFabricUIManager(
+void FabricUIManagerBinding::installFabricUIManager(
     jni::alias_ref<JRuntimeExecutor::javaobject> runtimeExecutorHolder,
     jni::alias_ref<JRuntimeScheduler::javaobject> runtimeSchedulerHolder,
     jni::alias_ref<JFabricUIManager::javaobject> javaUIManager,
@@ -374,8 +435,9 @@ void Binding::installFabricUIManager(
   enableFabricLogs_ = ReactNativeFeatureFlags::enableFabricLogs();
 
   if (enableFabricLogs_) {
-    LOG(WARNING) << "Binding::installFabricUIManager() was called (address: "
-                 << this << ").";
+    LOG(WARNING)
+        << "FabricUIManagerBinding::installFabricUIManager() was called (address: "
+        << this << ").";
   }
 
   std::unique_lock lock(installMutex_);
@@ -389,39 +451,33 @@ void Binding::installFabricUIManager(
 
   auto runtimeExecutor = runtimeExecutorHolder->cthis()->get();
 
-  if (runtimeSchedulerHolder) {
-    auto runtimeScheduler = runtimeSchedulerHolder->cthis()->get().lock();
-    if (runtimeScheduler) {
-      runtimeExecutor =
-          [runtimeScheduler](
-              std::function<void(jsi::Runtime & runtime)>&& callback) {
-            runtimeScheduler->scheduleWork(std::move(callback));
-          };
-      contextContainer->insert(
-          "RuntimeScheduler",
-          std::weak_ptr<RuntimeScheduler>(runtimeScheduler));
-    }
+  auto runtimeScheduler = runtimeSchedulerHolder->cthis()->get().lock();
+  if (runtimeScheduler) {
+    runtimeExecutor =
+        [runtimeScheduler](
+            std::function<void(jsi::Runtime & runtime)>&& callback) {
+          runtimeScheduler->scheduleWork(std::move(callback));
+        };
+    contextContainer->insert(
+        "RuntimeScheduler", std::weak_ptr<RuntimeScheduler>(runtimeScheduler));
   }
 
-  EventBeat::Factory asynchronousBeatFactory =
-      [eventBeatManager, runtimeExecutor, globalJavaUiManager](
-          const EventBeat::SharedOwnerBox& ownerBox)
+  EventBeat::Factory eventBeatFactory =
+      [eventBeatManager, &runtimeScheduler, globalJavaUiManager](
+          std::shared_ptr<EventBeat::OwnerBox> ownerBox)
       -> std::unique_ptr<EventBeat> {
-    return std::make_unique<AsyncEventBeat>(
-        ownerBox, eventBeatManager, runtimeExecutor, globalJavaUiManager);
+    return std::make_unique<AndroidEventBeat>(
+        std::move(ownerBox),
+        eventBeatManager,
+        *runtimeScheduler,
+        globalJavaUiManager);
   };
 
-  contextContainer->insert("ReactNativeConfig", config);
   contextContainer->insert("FabricUIManager", globalJavaUiManager);
 
   // Keep reference to config object and cache some feature flags here
   reactNativeConfig_ = config;
 
-  CoreFeatures::enablePropIteratorSetter =
-      getFeatureFlagValue("enableCppPropsIteratorSetter");
-  CoreFeatures::excludeYogaFromRawProps =
-      ReactNativeFeatureFlags::excludeYogaFromRawProps();
-
   auto toolbox = SchedulerToolbox{};
   toolbox.contextContainer = contextContainer;
   toolbox.componentRegistryFactory = componentsRegistry->buildRegistryFunction;
@@ -431,7 +487,7 @@ void Binding::installFabricUIManager(
   toolbox.bridgelessBindingsExecutor = std::nullopt;
   toolbox.runtimeExecutor = runtimeExecutor;
 
-  toolbox.asynchronousEventBeatFactory = asynchronousBeatFactory;
+  toolbox.eventBeatFactory = eventBeatFactory;
 
   animationDriver_ = std::make_shared<LayoutAnimationDriver>(
       runtimeExecutor, contextContainer, this);
@@ -439,10 +495,11 @@ void Binding::installFabricUIManager(
       std::make_shared<Scheduler>(toolbox, animationDriver_.get(), this);
 }
 
-void Binding::uninstallFabricUIManager() {
+void FabricUIManagerBinding::uninstallFabricUIManager() {
   if (enableFabricLogs_) {
-    LOG(WARNING) << "Binding::uninstallFabricUIManager() was called (address: "
-                 << this << ").";
+    LOG(WARNING)
+        << "FabricUIManagerBinding::uninstallFabricUIManager() was called (address: "
+        << this << ").";
   }
 
   std::unique_lock lock(installMutex_);
@@ -452,8 +509,8 @@ void Binding::uninstallFabricUIManager() {
   reactNativeConfig_ = nullptr;
 }
 
-std::shared_ptr<FabricMountingManager> Binding::getMountingManager(
-    const char* locationHint) {
+std::shared_ptr<FabricMountingManager>
+FabricUIManagerBinding::getMountingManager(const char* locationHint) {
   std::shared_lock lock(installMutex_);
   if (!mountingManager_) {
     LOG(ERROR) << "FabricMountingManager::" << locationHint
@@ -464,8 +521,8 @@ std::shared_ptr<FabricMountingManager> Binding::getMountingManager(
   return mountingManager_;
 }
 
-void Binding::schedulerDidFinishTransaction(
-    const MountingCoordinator::Shared& mountingCoordinator) {
+void FabricUIManagerBinding::schedulerDidFinishTransaction(
+    const std::shared_ptr<const MountingCoordinator>& mountingCoordinator) {
   // We shouldn't be pulling the transaction here (which triggers diffing of
   // the trees to determine the mutations to run on the host platform),
   // but we have to due to current limitations in the Android implementation.
@@ -493,48 +550,59 @@ void Binding::schedulerDidFinishTransaction(
   }
 }
 
-void Binding::schedulerShouldRenderTransactions(
-    const MountingCoordinator::Shared& mountingCoordinator) {
+void FabricUIManagerBinding::schedulerShouldRenderTransactions(
+    const std::shared_ptr<
+        const MountingCoordinator>& /* mountingCoordinator */) {
   auto mountingManager =
       getMountingManager("schedulerShouldRenderTransactions");
   if (!mountingManager) {
     return;
   }
 
-  if (ReactNativeFeatureFlags::
-          allowRecursiveCommitsWithSynchronousMountOnAndroid()) {
-    std::vector<MountingTransaction> pendingTransactions;
-
-    {
-      // Retain the lock to access the pending transactions but not to execute
-      // the mount operations because that method can call into this method
-      // again.
-      std::unique_lock<std::mutex> lock(pendingTransactionsMutex_);
-      pendingTransactions_.swap(pendingTransactions);
-    }
+  std::vector<MountingTransaction> pendingTransactions;
 
-    for (auto& transaction : pendingTransactions) {
-      mountingManager->executeMount(transaction);
-    }
-  } else {
+  {
+    // Retain the lock to access the pending transactions but not to execute
+    // the mount operations because that method can call into this method
+    // again.
+    //
+    // This can be re-entrant when mounting manager triggers state updates
+    // synchronously (this can happen when committing from the UI thread).
+    // This is safe because we're already combining all the transactions for the
+    // same surface ID in a single transaction in the pending transactions list,
+    // so operations won't run out of order.
     std::unique_lock<std::mutex> lock(pendingTransactionsMutex_);
-    for (auto& transaction : pendingTransactions_) {
-      mountingManager->executeMount(transaction);
-    }
-    pendingTransactions_.clear();
+    pendingTransactions_.swap(pendingTransactions);
+  }
+
+  for (auto& transaction : pendingTransactions) {
+    mountingManager->executeMount(transaction);
   }
 }
 
-void Binding::schedulerDidRequestPreliminaryViewAllocation(
+void FabricUIManagerBinding::schedulerDidRequestPreliminaryViewAllocation(
     const ShadowNode& shadowNode) {
   auto mountingManager = getMountingManager("preallocateView");
   if (!mountingManager) {
     return;
   }
   mountingManager->maybePreallocateShadowNode(shadowNode);
+  // Only the Views of ShadowNode that were pre-allocated (forms views) needs
+  // to be destroyed if the ShadowNode is destroyed but it was never mounted
+  // on the screen.
+  if (ReactNativeFeatureFlags::enableDeletionOfUnmountedViews() &&
+      shadowNode.getTraits().check(ShadowNodeTraits::Trait::FormsView)) {
+    shadowNode.getFamily().onUnmountedFamilyDestroyed(
+        [weakMountingManager =
+             std::weak_ptr(mountingManager)](const ShadowNodeFamily& family) {
+          if (auto mountingManager = weakMountingManager.lock()) {
+            mountingManager->destroyUnmountedShadowNode(family);
+          }
+        });
+  }
 }
 
-void Binding::schedulerDidDispatchCommand(
+void FabricUIManagerBinding::schedulerDidDispatchCommand(
     const ShadowView& shadowView,
     const std::string& commandName,
     const folly::dynamic& args) {
@@ -545,7 +613,7 @@ void Binding::schedulerDidDispatchCommand(
   mountingManager->dispatchCommand(shadowView, commandName, args);
 }
 
-void Binding::schedulerDidSendAccessibilityEvent(
+void FabricUIManagerBinding::schedulerDidSendAccessibilityEvent(
     const ShadowView& shadowView,
     const std::string& eventType) {
   auto mountingManager =
@@ -556,7 +624,7 @@ void Binding::schedulerDidSendAccessibilityEvent(
   mountingManager->sendAccessibilityEvent(shadowView, eventType);
 }
 
-void Binding::schedulerDidSetIsJSResponder(
+void FabricUIManagerBinding::schedulerDidSetIsJSResponder(
     const ShadowView& shadowView,
     bool isJSResponder,
     bool blockNativeResponder) {
@@ -568,7 +636,7 @@ void Binding::schedulerDidSetIsJSResponder(
       shadowView, isJSResponder, blockNativeResponder);
 }
 
-void Binding::onAnimationStarted() {
+void FabricUIManagerBinding::onAnimationStarted() {
   auto mountingManager = getMountingManager("onAnimationStarted");
   if (!mountingManager) {
     return;
@@ -576,7 +644,7 @@ void Binding::onAnimationStarted() {
   mountingManager->onAnimationStarted();
 }
 
-void Binding::onAllAnimationsComplete() {
+void FabricUIManagerBinding::onAllAnimationsComplete() {
   auto mountingManager = getMountingManager("onAnimationComplete");
   if (!mountingManager) {
     return;
@@ -584,27 +652,39 @@ void Binding::onAllAnimationsComplete() {
   mountingManager->onAllAnimationsComplete();
 }
 
-void Binding::registerNatives() {
+void FabricUIManagerBinding::registerNatives() {
   registerHybrid({
-      makeNativeMethod("initHybrid", Binding::initHybrid),
+      makeNativeMethod("initHybrid", FabricUIManagerBinding::initHybrid),
+      makeNativeMethod(
+          "installFabricUIManager",
+          FabricUIManagerBinding::installFabricUIManager),
+      makeNativeMethod("startSurface", FabricUIManagerBinding::startSurface),
+      makeNativeMethod(
+          "getInspectorDataForInstance",
+          FabricUIManagerBinding::getInspectorDataForInstance),
+      makeNativeMethod(
+          "startSurfaceWithConstraints",
+          FabricUIManagerBinding::startSurfaceWithConstraints),
+      makeNativeMethod("stopSurface", FabricUIManagerBinding::stopSurface),
+      makeNativeMethod(
+          "setConstraints", FabricUIManagerBinding::setConstraints),
+      makeNativeMethod(
+          "setPixelDensity", FabricUIManagerBinding::setPixelDensity),
       makeNativeMethod(
-          "installFabricUIManager", Binding::installFabricUIManager),
-      makeNativeMethod("startSurface", Binding::startSurface),
+          "driveCxxAnimations", FabricUIManagerBinding::driveCxxAnimations),
       makeNativeMethod(
-          "getInspectorDataForInstance", Binding::getInspectorDataForInstance),
+          "drainPreallocateViewsQueue",
+          FabricUIManagerBinding::drainPreallocateViewsQueue),
+      makeNativeMethod("reportMount", FabricUIManagerBinding::reportMount),
       makeNativeMethod(
-          "startSurfaceWithConstraints", Binding::startSurfaceWithConstraints),
-      makeNativeMethod("stopSurface", Binding::stopSurface),
-      makeNativeMethod("setConstraints", Binding::setConstraints),
-      makeNativeMethod("setPixelDensity", Binding::setPixelDensity),
-      makeNativeMethod("driveCxxAnimations", Binding::driveCxxAnimations),
+          "uninstallFabricUIManager",
+          FabricUIManagerBinding::uninstallFabricUIManager),
       makeNativeMethod(
-          "drainPreallocateViewsQueue", Binding::drainPreallocateViewsQueue),
-      makeNativeMethod("reportMount", Binding::reportMount),
+          "startSurfaceWithSurfaceHandler",
+          FabricUIManagerBinding::startSurfaceWithSurfaceHandler),
       makeNativeMethod(
-          "uninstallFabricUIManager", Binding::uninstallFabricUIManager),
-      makeNativeMethod("registerSurface", Binding::registerSurface),
-      makeNativeMethod("unregisterSurface", Binding::unregisterSurface),
+          "stopSurfaceWithSurfaceHandler",
+          FabricUIManagerBinding::stopSurfaceWithSurfaceHandler),
   });
 }