react-native-tvos 0.64.2-2 → 0.66.3-0

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

@@ -11,7 +11,9 @@
 #include "ReactNativeConfigHolder.h"
 #include "StateWrapperImpl.h"
 
-#include <better/set.h>
+#include <cfenv>
+#include <cmath>
+
 #include <fbjni/fbjni.h>
 #include <jsi/JSIDynamic.h>
 #include <jsi/jsi.h>
@@ -43,14 +45,6 @@ struct JMountItem : public JavaClass<JMountItem> {
       "Lcom/facebook/react/fabric/mounting/mountitems/MountItem;";
 };
 
-struct RemoveDeleteMetadata {
-  Tag tag;
-  Tag parentTag;
-  int index;
-  bool shouldRemove;
-  bool shouldDelete;
-};
-
 } // namespace
 
 CppMountItem CppMountItem::CreateMountItem(ShadowView shadowView) {
@@ -103,7 +97,7 @@ static inline int getIntBufferSizeForType(CppMountItem::Type mountItemType) {
   } else if (mountItemType == CppMountItem::Type::UpdatePadding) {
     return 5; // tag, top, left, bottom, right
   } else if (mountItemType == CppMountItem::Type::UpdateLayout) {
-    return 6; // tag, x, y, w, h, layoutDirection
+    return 6; // tag, x, y, w, h, DisplayType
   } else if (mountItemType == CppMountItem::Type::UpdateEventEmitter) {
     return 1; // tag
   } else {
@@ -165,7 +159,8 @@ static inline void computeBufferSizes(
 
     batchMountItemIntsSize += getIntBufferSizeForType(mountItemType);
     if (mountItemType == CppMountItem::Type::Create) {
-      batchMountItemObjectsSize += 3; // component name, props, state
+      batchMountItemObjectsSize +=
+          4; // component name, props, state, event emitter
     }
   }
 
@@ -237,6 +232,33 @@ std::shared_ptr<Scheduler> Binding::getScheduler() {
   return scheduler_;
 }
 
+jni::local_ref<ReadableNativeMap::jhybridobject>
+Binding::getInspectorDataForInstance(
+    jni::alias_ref<EventEmitterWrapper::javaobject> eventEmitterWrapper) {
+  std::shared_ptr<Scheduler> scheduler = getScheduler();
+  if (!scheduler) {
+    LOG(ERROR) << "Binding::startSurface: scheduler disappeared";
+    return ReadableNativeMap::newObjectCxxArgs(folly::dynamic::object());
+  }
+
+  EventEmitterWrapper *cEventEmitter = cthis(eventEmitterWrapper);
+  InspectorData data =
+      scheduler->getInspectorDataForInstance(cEventEmitter->eventEmitter);
+
+  folly::dynamic result = folly::dynamic::object;
+  result["fileName"] = data.fileName;
+  result["lineNumber"] = data.lineNumber;
+  result["columnNumber"] = data.columnNumber;
+  result["selectedIndex"] = data.selectedIndex;
+  result["props"] = data.props;
+  auto hierarchy = folly::dynamic::array();
+  for (auto hierarchyItem : data.hierarchy) {
+    hierarchy.push_back(hierarchyItem);
+  }
+  result["hierarchy"] = hierarchy;
+  return ReadableNativeMap::newObjectCxxArgs(result);
+}
+
 void Binding::startSurface(
     jint surfaceId,
     jni::alias_ref<jstring> moduleName,
@@ -249,15 +271,27 @@ void Binding::startSurface(
     return;
   }
 
-  LayoutContext context;
-  context.pointScaleFactor = pointScaleFactor_;
-  scheduler->startSurface(
-      surfaceId,
-      moduleName->toStdString(),
-      initialProps->consume(),
-      {},
-      context,
+  auto layoutContext = LayoutContext{};
+  layoutContext.pointScaleFactor = pointScaleFactor_;
+
+  auto surfaceHandler = SurfaceHandler{moduleName->toStdString(), surfaceId};
+  surfaceHandler.setContextContainer(scheduler->getContextContainer());
+  surfaceHandler.setProps(initialProps->consume());
+  surfaceHandler.constraintLayout({}, layoutContext);
+
+  scheduler->registerSurface(surfaceHandler);
+
+  surfaceHandler.start();
+
+  surfaceHandler.getMountingCoordinator()->setMountingOverrideDelegate(
       animationDriver_);
+
+  {
+    SystraceSection s2("FabricUIManagerBinding::startSurface::surfaceId::lock");
+    std::unique_lock<better::shared_mutex> lock(surfaceHandlerRegistryMutex_);
+    SystraceSection s3("FabricUIManagerBinding::startSurface::surfaceId");
+    surfaceHandlerRegistry_.emplace(surfaceId, std::move(surfaceHandler));
+  }
 }
 
 void Binding::startSurfaceWithConstraints(
@@ -302,13 +336,26 @@ void Binding::startSurfaceWithConstraints(
   constraints.layoutDirection =
       isRTL ? LayoutDirection::RightToLeft : LayoutDirection::LeftToRight;
 
-  scheduler->startSurface(
-      surfaceId,
-      moduleName->toStdString(),
-      initialProps->consume(),
-      constraints,
-      context,
+  auto surfaceHandler = SurfaceHandler{moduleName->toStdString(), surfaceId};
+  surfaceHandler.setContextContainer(scheduler_->getContextContainer());
+  surfaceHandler.setProps(initialProps->consume());
+  surfaceHandler.constraintLayout(constraints, context);
+
+  scheduler->registerSurface(surfaceHandler);
+
+  surfaceHandler.start();
+
+  surfaceHandler.getMountingCoordinator()->setMountingOverrideDelegate(
       animationDriver_);
+
+  {
+    SystraceSection s2(
+        "FabricUIManagerBinding::startSurfaceWithConstraints::surfaceId::lock");
+    std::unique_lock<better::shared_mutex> lock(surfaceHandlerRegistryMutex_);
+    SystraceSection s3(
+        "FabricUIManagerBinding::startSurfaceWithConstraints::surfaceId");
+    surfaceHandlerRegistry_.emplace(surfaceId, std::move(surfaceHandler));
+  }
 }
 
 void Binding::renderTemplateToSurface(jint surfaceId, jstring uiTemplate) {
@@ -340,7 +387,47 @@ void Binding::stopSurface(jint surfaceId) {
     return;
   }
 
-  scheduler->stopSurface(surfaceId);
+  {
+    std::unique_lock<better::shared_mutex> lock(surfaceHandlerRegistryMutex_);
+
+    auto iterator = surfaceHandlerRegistry_.find(surfaceId);
+
+    if (iterator == surfaceHandlerRegistry_.end()) {
+      LOG(ERROR) << "Binding::stopSurface: Surface with given id is not found";
+      return;
+    }
+
+    auto surfaceHandler = std::move(iterator->second);
+    surfaceHandlerRegistry_.erase(iterator);
+    surfaceHandler.stop();
+    scheduler->unregisterSurface(surfaceHandler);
+  }
+}
+
+void Binding::registerSurface(SurfaceHandlerBinding *surfaceHandlerBinding) {
+  auto scheduler = getScheduler();
+  scheduler->registerSurface(surfaceHandlerBinding->getSurfaceHandler());
+}
+
+void Binding::unregisterSurface(SurfaceHandlerBinding *surfaceHandlerBinding) {
+  auto scheduler = getScheduler();
+  scheduler->unregisterSurface(surfaceHandlerBinding->getSurfaceHandler());
+}
+
+static inline float scale(Float value, Float pointScaleFactor) {
+  std::feclearexcept(FE_ALL_EXCEPT);
+  float result = value * pointScaleFactor;
+  if (std::fetestexcept(FE_OVERFLOW)) {
+    LOG(ERROR) << "Binding::scale - FE_OVERFLOW - value: " << value
+               << " pointScaleFactor: " << pointScaleFactor
+               << " result: " << result;
+  }
+  if (std::fetestexcept(FE_UNDERFLOW)) {
+    LOG(ERROR) << "Binding::scale - FE_UNDERFLOW - value: " << value
+               << " pointScaleFactor: " << pointScaleFactor
+               << " result: " << result;
+  }
+  return result;
 }
 
 void Binding::setConstraints(
@@ -377,7 +464,31 @@ void Binding::setConstraints(
   constraints.layoutDirection =
       isRTL ? LayoutDirection::RightToLeft : LayoutDirection::LeftToRight;
 
-  scheduler->constraintSurfaceLayout(surfaceId, constraints, context);
+  {
+    std::shared_lock<better::shared_mutex> lock(surfaceHandlerRegistryMutex_);
+
+    auto iterator = surfaceHandlerRegistry_.find(surfaceId);
+
+    if (iterator == surfaceHandlerRegistry_.end()) {
+      LOG(ERROR)
+          << "Binding::setConstraints: Surface with given id is not found";
+      return;
+    }
+
+    auto &surfaceHandler = iterator->second;
+    surfaceHandler.constraintLayout(constraints, context);
+  }
+}
+
+bool isMapBufferSerializationEnabled() {
+  static const auto reactFeatureFlagsJavaDescriptor =
+      jni::findClassStatic(Binding::ReactFeatureFlagsJavaDescriptor);
+  static const auto isMapBufferSerializationEnabledMethod =
+      reactFeatureFlagsJavaDescriptor->getStaticMethod<jboolean()>(
+          "isMapBufferSerializationEnabled");
+  bool value =
+      isMapBufferSerializationEnabledMethod(reactFeatureFlagsJavaDescriptor);
+  return value;
 }
 
 void Binding::installFabricUIManager(
@@ -420,39 +531,34 @@ void Binding::installFabricUIManager(
   jni::global_ref<jobject> localJavaUIManager = javaUIManager_;
   EventBeat::Factory synchronousBeatFactory =
       [eventBeatManager, runtimeExecutor, localJavaUIManager](
-          EventBeat::SharedOwnerBox const &ownerBox) {
-        return std::make_unique<AsyncEventBeat>(
-            ownerBox, eventBeatManager, runtimeExecutor, localJavaUIManager);
-      };
+          EventBeat::SharedOwnerBox const &ownerBox)
+      -> std::unique_ptr<EventBeat> {
+    return std::make_unique<AsyncEventBeat>(
+        ownerBox, eventBeatManager, runtimeExecutor, localJavaUIManager);
+  };
 
   EventBeat::Factory asynchronousBeatFactory =
       [eventBeatManager, runtimeExecutor, localJavaUIManager](
-          EventBeat::SharedOwnerBox const &ownerBox) {
-        return std::make_unique<AsyncEventBeat>(
-            ownerBox, eventBeatManager, runtimeExecutor, localJavaUIManager);
-      };
+          EventBeat::SharedOwnerBox const &ownerBox)
+      -> std::unique_ptr<EventBeat> {
+    return std::make_unique<AsyncEventBeat>(
+        ownerBox, eventBeatManager, runtimeExecutor, localJavaUIManager);
+  };
 
   contextContainer->insert("ReactNativeConfig", config);
   contextContainer->insert("FabricUIManager", javaUIManager_);
 
   // Keep reference to config object and cache some feature flags here
   reactNativeConfig_ = config;
-  collapseDeleteCreateMountingInstructions_ =
-      reactNativeConfig_->getBool(
-          "react_fabric:enabled_collapse_delete_create_mounting_instructions") &&
-      !reactNativeConfig_->getBool(
-          "react_fabric:enable_reparenting_detection_android") &&
-      !reactNativeConfig_->getBool(
-          "react_fabric:enabled_layout_animations_android");
 
-  useIntBufferBatchMountItem_ = reactNativeConfig_->getBool(
-      "react_fabric:use_int_buffer_batch_mountitem_android");
+  contextContainer->insert(
+      "MapBufferSerializationEnabled", isMapBufferSerializationEnabled());
 
   disablePreallocateViews_ = reactNativeConfig_->getBool(
       "react_fabric:disabled_view_preallocation_android");
 
-  bool enableLayoutAnimations = reactNativeConfig_->getBool(
-      "react_fabric:enabled_layout_animations_android");
+  enableEarlyEventEmitterUpdate_ = reactNativeConfig_->getBool(
+      "react_fabric:enable_early_event_emitter_update");
 
   auto toolbox = SchedulerToolbox{};
   toolbox.contextContainer = contextContainer;
@@ -467,10 +573,8 @@ void Binding::installFabricUIManager(
     toolbox.backgroundExecutor = backgroundExecutor_->get();
   }
 
-  if (enableLayoutAnimations) {
-    animationDriver_ =
-        std::make_shared<LayoutAnimationDriver>(runtimeExecutor, this);
-  }
+  animationDriver_ =
+      std::make_shared<LayoutAnimationDriver>(runtimeExecutor, this);
   scheduler_ = std::make_shared<Scheduler>(
       toolbox, (animationDriver_ ? animationDriver_.get() : nullptr), this);
 }
@@ -519,226 +623,7 @@ local_ref<JString> getPlatformComponentName(const ShadowView &shadowView) {
   return componentName;
 }
 
-local_ref<JMountItem::javaobject> createUpdateEventEmitterMountItem(
-    const jni::global_ref<jobject> &javaUIManager,
-    const ShadowViewMutation &mutation) {
-  if (!mutation.newChildShadowView.eventEmitter) {
-    return nullptr;
-  }
-  SharedEventEmitter eventEmitter = mutation.newChildShadowView.eventEmitter;
-
-  // Do not hold a reference to javaEventEmitter from the C++ side.
-  auto javaEventEmitter = EventEmitterWrapper::newObjectJavaArgs();
-  EventEmitterWrapper *cEventEmitter = cthis(javaEventEmitter);
-  cEventEmitter->eventEmitter = eventEmitter;
-
-  static auto updateEventEmitterInstruction =
-      jni::findClassStatic(Binding::UIManagerJavaDescriptor)
-          ->getMethod<alias_ref<JMountItem>(jint, jobject)>(
-              "updateEventEmitterMountItem");
-
-  return updateEventEmitterInstruction(
-      javaUIManager, mutation.newChildShadowView.tag, javaEventEmitter.get());
-}
-
-local_ref<JMountItem::javaobject> createUpdatePropsMountItem(
-    const jni::global_ref<jobject> &javaUIManager,
-    const ShadowViewMutation &mutation) {
-  auto shadowView = mutation.newChildShadowView;
-
-  // TODO: move props from map to a typed object.
-  auto newProps = shadowView.props->rawProps;
-
-  local_ref<ReadableMap::javaobject> readableMap =
-      castReadableMap(ReadableNativeMap::newObjectCxxArgs(newProps));
-  static auto updatePropsInstruction =
-      jni::findClassStatic(Binding::UIManagerJavaDescriptor)
-          ->getMethod<alias_ref<JMountItem>(jint, ReadableMap::javaobject)>(
-              "updatePropsMountItem");
-
-  return updatePropsInstruction(
-      javaUIManager, mutation.newChildShadowView.tag, readableMap.get());
-}
-
-local_ref<JMountItem::javaobject> createUpdateLayoutMountItem(
-    const jni::global_ref<jobject> &javaUIManager,
-    const ShadowViewMutation &mutation) {
-  auto oldChildShadowView = mutation.oldChildShadowView;
-  auto newChildShadowView = mutation.newChildShadowView;
-
-  if (newChildShadowView.layoutMetrics != EmptyLayoutMetrics &&
-      oldChildShadowView.layoutMetrics != newChildShadowView.layoutMetrics) {
-    static auto updateLayoutInstruction =
-        jni::findClassStatic(Binding::UIManagerJavaDescriptor)
-            ->getMethod<alias_ref<JMountItem>(
-                jint, jint, jint, jint, jint, jint)>("updateLayoutMountItem");
-    auto layoutMetrics = newChildShadowView.layoutMetrics;
-    auto pointScaleFactor = layoutMetrics.pointScaleFactor;
-    auto frame = layoutMetrics.frame;
-
-    int x = round(frame.origin.x * pointScaleFactor);
-    int y = round(frame.origin.y * pointScaleFactor);
-    int w = round(frame.size.width * pointScaleFactor);
-    int h = round(frame.size.height * pointScaleFactor);
-    auto layoutDirection =
-        toInt(newChildShadowView.layoutMetrics.layoutDirection);
-    return updateLayoutInstruction(
-        javaUIManager, newChildShadowView.tag, x, y, w, h, layoutDirection);
-  }
-
-  return nullptr;
-}
-
-local_ref<JMountItem::javaobject> createUpdatePaddingMountItem(
-    const jni::global_ref<jobject> &javaUIManager,
-    const ShadowViewMutation &mutation) {
-  auto oldChildShadowView = mutation.oldChildShadowView;
-  auto newChildShadowView = mutation.newChildShadowView;
-
-  if (oldChildShadowView.layoutMetrics.contentInsets ==
-          newChildShadowView.layoutMetrics.contentInsets &&
-      mutation.type != ShadowViewMutation::Type::Insert) {
-    return nullptr;
-  }
-
-  static auto updatePaddingInstruction =
-      jni::findClassStatic(Binding::UIManagerJavaDescriptor)
-          ->getMethod<alias_ref<JMountItem>(jint, jint, jint, jint, jint)>(
-              "updatePaddingMountItem");
-
-  auto layoutMetrics = newChildShadowView.layoutMetrics;
-  auto pointScaleFactor = layoutMetrics.pointScaleFactor;
-  auto contentInsets = layoutMetrics.contentInsets;
-
-  int left = floor(contentInsets.left * pointScaleFactor);
-  int top = floor(contentInsets.top * pointScaleFactor);
-  int right = floor(contentInsets.right * pointScaleFactor);
-  int bottom = floor(contentInsets.bottom * pointScaleFactor);
-
-  return updatePaddingInstruction(
-      javaUIManager, newChildShadowView.tag, left, top, right, bottom);
-}
-
-local_ref<JMountItem::javaobject> createInsertMountItem(
-    const jni::global_ref<jobject> &javaUIManager,
-    const ShadowViewMutation &mutation) {
-  static auto insertInstruction =
-      jni::findClassStatic(Binding::UIManagerJavaDescriptor)
-          ->getMethod<alias_ref<JMountItem>(jint, jint, jint)>(
-              "insertMountItem");
-
-  return insertInstruction(
-      javaUIManager,
-      mutation.newChildShadowView.tag,
-      mutation.parentShadowView.tag,
-      mutation.index);
-}
-
-local_ref<JMountItem::javaobject> createUpdateStateMountItem(
-    const jni::global_ref<jobject> &javaUIManager,
-    const ShadowViewMutation &mutation) {
-  static auto updateStateInstruction =
-      jni::findClassStatic(Binding::UIManagerJavaDescriptor)
-          ->getMethod<alias_ref<JMountItem>(jint, jobject)>(
-              "updateStateMountItem");
-
-  auto state = mutation.newChildShadowView.state;
-
-  // Do not hold onto Java object from C
-  // We DO want to hold onto C object from Java, since we don't know the
-  // lifetime of the Java object
-  local_ref<StateWrapperImpl::JavaPart> javaStateWrapper = nullptr;
-  if (state != nullptr) {
-    javaStateWrapper = StateWrapperImpl::newObjectJavaArgs();
-    StateWrapperImpl *cStateWrapper = cthis(javaStateWrapper);
-    cStateWrapper->state_ = state;
-  }
-
-  return updateStateInstruction(
-      javaUIManager,
-      mutation.newChildShadowView.tag,
-      (javaStateWrapper != nullptr ? javaStateWrapper.get() : nullptr));
-}
-
-local_ref<JMountItem::javaobject> createRemoveAndDeleteMultiMountItem(
-    const jni::global_ref<jobject> &javaUIManager,
-    const std::vector<RemoveDeleteMetadata> &metadata) {
-  auto env = Environment::current();
-  auto removeAndDeleteArray = env->NewIntArray(metadata.size() * 4);
-  int position = 0;
-  jint temp[4];
-  for (const auto &x : metadata) {
-    temp[0] = x.tag;
-    temp[1] = x.parentTag;
-    temp[2] = x.index;
-    temp[3] = (x.shouldRemove ? 1 : 0) | (x.shouldDelete ? 2 : 0);
-    env->SetIntArrayRegion(removeAndDeleteArray, position, 4, temp);
-    position += 4;
-  }
-
-  static auto removeDeleteMultiInstruction =
-      jni::findClassStatic(Binding::UIManagerJavaDescriptor)
-          ->getMethod<alias_ref<JMountItem>(jintArray)>(
-              "removeDeleteMultiMountItem");
-
-  auto ret = removeDeleteMultiInstruction(javaUIManager, removeAndDeleteArray);
-
-  // It is not strictly necessary to manually delete the ref here, in this
-  // particular case. If JNI memory is being allocated in a loop, it's easy to
-  // overload the localref table and crash; this is not possible in this case
-  // since the JNI would automatically clear this ref when it goes out of scope,
-  // anyway. However, this is being left here as a reminder of good hygiene and
-  // to be careful with JNI-allocated memory in general.
-  env->DeleteLocalRef(removeAndDeleteArray);
-
-  return ret;
-}
-
-// TODO T48019320: because we pass initial props and state to the Create (and
-// preallocate) mount instruction, we technically don't need to pass the first
-// Update to any components. Dedupe?
-local_ref<JMountItem::javaobject> createCreateMountItem(
-    const jni::global_ref<jobject> &javaUIManager,
-    const ShadowViewMutation &mutation,
-    const Tag surfaceId) {
-  static auto createJavaInstruction =
-      jni::findClassStatic(Binding::UIManagerJavaDescriptor)
-          ->getMethod<alias_ref<JMountItem>(
-              jstring, ReadableMap::javaobject, jobject, jint, jint, jboolean)>(
-              "createMountItem");
-
-  auto newChildShadowView = mutation.newChildShadowView;
-
-  local_ref<JString> componentName =
-      getPlatformComponentName(newChildShadowView);
-
-  jboolean isLayoutable =
-      newChildShadowView.layoutMetrics != EmptyLayoutMetrics;
-
-  local_ref<ReadableMap::javaobject> props = castReadableMap(
-      ReadableNativeMap::newObjectCxxArgs(newChildShadowView.props->rawProps));
-
-  // Do not hold onto Java object from C
-  // We DO want to hold onto C object from Java, since we don't know the
-  // lifetime of the Java object
-  local_ref<StateWrapperImpl::JavaPart> javaStateWrapper = nullptr;
-  if (newChildShadowView.state != nullptr) {
-    javaStateWrapper = StateWrapperImpl::newObjectJavaArgs();
-    StateWrapperImpl *cStateWrapper = cthis(javaStateWrapper);
-    cStateWrapper->state_ = newChildShadowView.state;
-  }
-
-  return createJavaInstruction(
-      javaUIManager,
-      componentName.get(),
-      props.get(),
-      (javaStateWrapper != nullptr ? javaStateWrapper.get() : nullptr),
-      surfaceId,
-      newChildShadowView.tag,
-      isLayoutable);
-}
-
-void Binding::schedulerDidFinishTransactionIntBuffer(
+void Binding::schedulerDidFinishTransaction(
     MountingCoordinator::Shared const &mountingCoordinator) {
   std::lock_guard<std::recursive_mutex> lock(commitMutex_);
 
@@ -782,8 +667,7 @@ void Binding::schedulerDidFinishTransactionIntBuffer(
     auto &mutationType = mutation.type;
     auto &index = mutation.index;
 
-    bool isVirtual = newChildShadowView.layoutMetrics == EmptyLayoutMetrics &&
-        oldChildShadowView.layoutMetrics == EmptyLayoutMetrics;
+    bool isVirtual = mutation.mutatedViewIsVirtual();
 
     switch (mutationType) {
       case ShadowViewMutation::Create: {
@@ -949,7 +833,7 @@ void Binding::schedulerDidFinishTransactionIntBuffer(
   int intBufferPosition = 0;
   int objBufferPosition = 0;
   int prevMountItemType = -1;
-  jint temp[6];
+  jint temp[7];
   for (int i = 0; i < cppCommonMountItems.size(); i++) {
     const auto &mountItem = cppCommonMountItems[i];
     const auto &mountItemType = mountItem.type;
@@ -996,6 +880,13 @@ void Binding::schedulerDidFinishTransactionIntBuffer(
         cStateWrapper->state_ = mountItem.newChildShadowView.state;
       }
 
+      // Do not hold a reference to javaEventEmitter from the C++ side.
+      SharedEventEmitter eventEmitter =
+          mountItem.newChildShadowView.eventEmitter;
+      auto javaEventEmitter = EventEmitterWrapper::newObjectJavaArgs();
+      EventEmitterWrapper *cEventEmitter = cthis(javaEventEmitter);
+      cEventEmitter->eventEmitter = eventEmitter;
+
       temp[0] = mountItem.newChildShadowView.tag;
       temp[1] = isLayoutable;
       env->SetIntArrayRegion(intBufferArray, intBufferPosition, 2, temp);
@@ -1005,6 +896,7 @@ void Binding::schedulerDidFinishTransactionIntBuffer(
       (*objBufferArray)[objBufferPosition++] = props.get();
       (*objBufferArray)[objBufferPosition++] =
           javaStateWrapper != nullptr ? javaStateWrapper.get() : nullptr;
+      (*objBufferArray)[objBufferPosition++] = javaEventEmitter.get();
     } else if (mountItemType == CppMountItem::Type::Insert) {
       temp[0] = mountItem.newChildShadowView.tag;
       temp[1] = mountItem.parentShadowView.tag;
@@ -1081,10 +973,10 @@ void Binding::schedulerDidFinishTransactionIntBuffer(
       auto pointScaleFactor = layoutMetrics.pointScaleFactor;
       auto contentInsets = layoutMetrics.contentInsets;
 
-      int left = floor(contentInsets.left * pointScaleFactor);
-      int top = floor(contentInsets.top * pointScaleFactor);
-      int right = floor(contentInsets.right * pointScaleFactor);
-      int bottom = floor(contentInsets.bottom * pointScaleFactor);
+      int left = floor(scale(contentInsets.left, pointScaleFactor));
+      int top = floor(scale(contentInsets.top, pointScaleFactor));
+      int right = floor(scale(contentInsets.right, pointScaleFactor));
+      int bottom = floor(scale(contentInsets.bottom, pointScaleFactor));
 
       temp[0] = mountItem.newChildShadowView.tag;
       temp[1] = left;
@@ -1108,19 +1000,19 @@ void Binding::schedulerDidFinishTransactionIntBuffer(
       auto pointScaleFactor = layoutMetrics.pointScaleFactor;
       auto frame = layoutMetrics.frame;
 
-      int x = round(frame.origin.x * pointScaleFactor);
-      int y = round(frame.origin.y * pointScaleFactor);
-      int w = round(frame.size.width * pointScaleFactor);
-      int h = round(frame.size.height * pointScaleFactor);
-      int layoutDirection =
-          toInt(mountItem.newChildShadowView.layoutMetrics.layoutDirection);
+      int x = round(scale(frame.origin.x, pointScaleFactor));
+      int y = round(scale(frame.origin.y, pointScaleFactor));
+      int w = round(scale(frame.size.width, pointScaleFactor));
+      int h = round(scale(frame.size.height, pointScaleFactor));
+      int displayType =
+          toInt(mountItem.newChildShadowView.layoutMetrics.displayType);
 
       temp[0] = mountItem.newChildShadowView.tag;
       temp[1] = x;
       temp[2] = y;
       temp[3] = w;
       temp[4] = h;
-      temp[5] = layoutDirection;
+      temp[5] = displayType;
       env->SetIntArrayRegion(intBufferArray, intBufferPosition, 6, temp);
       intBufferPosition += 6;
     }
@@ -1196,295 +1088,6 @@ void Binding::schedulerDidFinishTransactionIntBuffer(
   env->DeleteLocalRef(intBufferArray);
 }
 
-void Binding::schedulerDidFinishTransaction(
-    MountingCoordinator::Shared const &mountingCoordinator) {
-  std::lock_guard<std::recursive_mutex> lock(commitMutex_);
-
-  if (useIntBufferBatchMountItem_) {
-    return schedulerDidFinishTransactionIntBuffer(mountingCoordinator);
-  }
-
-  SystraceSection s("FabricUIManagerBinding::schedulerDidFinishTransaction");
-  auto finishTransactionStartTime = telemetryTimePointNow();
-
-  jni::global_ref<jobject> localJavaUIManager = getJavaUIManager();
-  if (!localJavaUIManager) {
-    LOG(ERROR)
-        << "Binding::schedulerDidFinishTransaction: JavaUIManager disappeared";
-    return;
-  }
-
-  auto mountingTransaction = mountingCoordinator->pullTransaction();
-
-  if (!mountingTransaction.has_value()) {
-    return;
-  }
-
-  auto telemetry = mountingTransaction->getTelemetry();
-  auto surfaceId = mountingTransaction->getSurfaceId();
-  auto &mutations = mountingTransaction->getMutations();
-
-  facebook::better::set<Tag> createAndDeleteTagsToProcess;
-  // When collapseDeleteCreateMountingInstructions_ is enabled, the
-  // createAndDeleteTagsToProcess set will contain all the tags belonging to
-  // CREATE and DELETE mutation instructions that needs to be processed. If a
-  // CREATE or DELETE mutation instruction does not belong in the set, it means
-  // that the we received a pair of mutation instructions: DELETE - CREATE and
-  // it is not necessary to create or delete on the screen.
-  if (collapseDeleteCreateMountingInstructions_) {
-    for (const auto &mutation : mutations) {
-      if (mutation.type == ShadowViewMutation::Delete) {
-        // TAG on 'Delete' mutation instructions are part of the
-        // oldChildShadowView
-        createAndDeleteTagsToProcess.insert(mutation.oldChildShadowView.tag);
-      } else if (mutation.type == ShadowViewMutation::Create) {
-        // TAG on 'Create' mutation instructions are part of the
-        // newChildShadowView
-        Tag tag = mutation.newChildShadowView.tag;
-        if (createAndDeleteTagsToProcess.find(tag) ==
-            createAndDeleteTagsToProcess.end()) {
-          createAndDeleteTagsToProcess.insert(tag);
-        } else {
-          createAndDeleteTagsToProcess.erase(tag);
-        }
-      }
-    }
-  }
-
-  auto revisionNumber = telemetry.getRevisionNumber();
-
-  std::vector<local_ref<jobject>> queue;
-  // Upper bound estimation of mount items to be delivered to Java side.
-  int size = mutations.size() * 3 + 42;
-
-  local_ref<JArrayClass<JMountItem::javaobject>> mountItemsArray =
-      JArrayClass<JMountItem::javaobject>::newArray(size);
-
-  auto mountItems = *(mountItemsArray);
-  std::unordered_set<Tag> deletedViewTags;
-
-  // Find the set of tags that are removed and deleted in one block
-  std::vector<RemoveDeleteMetadata> toRemove;
-
-  int position = 0;
-  for (const auto &mutation : mutations) {
-    auto oldChildShadowView = mutation.oldChildShadowView;
-    auto newChildShadowView = mutation.newChildShadowView;
-    auto mutationType = mutation.type;
-
-    if (collapseDeleteCreateMountingInstructions_ &&
-        (mutationType == ShadowViewMutation::Create ||
-         mutationType == ShadowViewMutation::Delete) &&
-        createAndDeleteTagsToProcess.size() > 0) {
-      // The TAG on 'Delete' mutation instructions are part of the
-      // oldChildShadowView. On the other side, the TAG on 'Create' mutation
-      // instructions are part of the newChildShadowView
-      Tag tag = mutationType == ShadowViewMutation::Create
-          ? mutation.newChildShadowView.tag
-          : mutation.oldChildShadowView.tag;
-      if (createAndDeleteTagsToProcess.find(tag) ==
-          createAndDeleteTagsToProcess.end()) {
-        continue;
-      }
-    }
-
-    bool isVirtual = newChildShadowView.layoutMetrics == EmptyLayoutMetrics &&
-        oldChildShadowView.layoutMetrics == EmptyLayoutMetrics;
-
-    // Handle accumulated removals/deletions
-    if (mutation.type != ShadowViewMutation::Remove &&
-        mutation.type != ShadowViewMutation::Delete) {
-      if (toRemove.size() > 0) {
-        mountItems[position++] =
-            createRemoveAndDeleteMultiMountItem(localJavaUIManager, toRemove);
-        toRemove.clear();
-      }
-    }
-
-    switch (mutation.type) {
-      case ShadowViewMutation::Create: {
-        if (disablePreallocateViews_ ||
-            mutation.newChildShadowView.props->revision > 1 ||
-            deletedViewTags.find(mutation.newChildShadowView.tag) !=
-                deletedViewTags.end()) {
-          mountItems[position++] =
-              createCreateMountItem(localJavaUIManager, mutation, surfaceId);
-        }
-        break;
-      }
-      case ShadowViewMutation::Remove: {
-        if (!isVirtual) {
-          toRemove.push_back(
-              RemoveDeleteMetadata{mutation.oldChildShadowView.tag,
-                                   mutation.parentShadowView.tag,
-                                   mutation.index,
-                                   true,
-                                   false});
-        }
-        break;
-      }
-      case ShadowViewMutation::Delete: {
-        // It is impossible to delete without removing node first
-        const auto &it = std::find_if(
-            std::begin(toRemove),
-            std::end(toRemove),
-            [&mutation](const auto &x) {
-              return x.tag == mutation.oldChildShadowView.tag;
-            });
-
-        if (it != std::end(toRemove)) {
-          it->shouldDelete = true;
-        } else {
-          toRemove.push_back(RemoveDeleteMetadata{
-              mutation.oldChildShadowView.tag, -1, -1, false, true});
-        }
-
-        deletedViewTags.insert(mutation.oldChildShadowView.tag);
-        break;
-      }
-      case ShadowViewMutation::Update: {
-        if (!isVirtual) {
-          if (mutation.oldChildShadowView.props !=
-              mutation.newChildShadowView.props) {
-            mountItems[position++] =
-                createUpdatePropsMountItem(localJavaUIManager, mutation);
-          }
-          if (mutation.oldChildShadowView.state !=
-              mutation.newChildShadowView.state) {
-            mountItems[position++] =
-                createUpdateStateMountItem(localJavaUIManager, mutation);
-          }
-
-          // Padding: padding mountItems must be executed before layout props
-          // are updated in the view. This is necessary to ensure that events
-          // (resulting from layout changes) are dispatched with the correct
-          // padding information.
-          auto updatePaddingMountItem =
-              createUpdatePaddingMountItem(localJavaUIManager, mutation);
-          if (updatePaddingMountItem) {
-            mountItems[position++] = updatePaddingMountItem;
-          }
-
-          auto updateLayoutMountItem =
-              createUpdateLayoutMountItem(localJavaUIManager, mutation);
-          if (updateLayoutMountItem) {
-            mountItems[position++] = updateLayoutMountItem;
-          }
-        }
-
-        if (mutation.oldChildShadowView.eventEmitter !=
-            mutation.newChildShadowView.eventEmitter) {
-          auto updateEventEmitterMountItem =
-              createUpdateEventEmitterMountItem(localJavaUIManager, mutation);
-          if (updateEventEmitterMountItem) {
-            mountItems[position++] = updateEventEmitterMountItem;
-          }
-        }
-        break;
-      }
-      case ShadowViewMutation::Insert: {
-        if (!isVirtual) {
-          // Insert item
-          mountItems[position++] =
-              createInsertMountItem(localJavaUIManager, mutation);
-
-          if (disablePreallocateViews_ ||
-              mutation.newChildShadowView.props->revision > 1 ||
-              deletedViewTags.find(mutation.newChildShadowView.tag) !=
-                  deletedViewTags.end()) {
-            mountItems[position++] =
-                createUpdatePropsMountItem(localJavaUIManager, mutation);
-          }
-
-          // State
-          if (mutation.newChildShadowView.state) {
-            mountItems[position++] =
-                createUpdateStateMountItem(localJavaUIManager, mutation);
-          }
-
-          // Padding: padding mountItems must be executed before layout props
-          // are updated in the view. This is necessary to ensure that events
-          // (resulting from layout changes) are dispatched with the correct
-          // padding information.
-          auto updatePaddingMountItem =
-              createUpdatePaddingMountItem(localJavaUIManager, mutation);
-          if (updatePaddingMountItem) {
-            mountItems[position++] = updatePaddingMountItem;
-          }
-
-          // Layout
-          auto updateLayoutMountItem =
-              createUpdateLayoutMountItem(localJavaUIManager, mutation);
-          if (updateLayoutMountItem) {
-            mountItems[position++] = updateLayoutMountItem;
-          }
-        }
-
-        // EventEmitter
-        auto updateEventEmitterMountItem =
-            createUpdateEventEmitterMountItem(localJavaUIManager, mutation);
-        if (updateEventEmitterMountItem) {
-          mountItems[position++] = updateEventEmitterMountItem;
-        }
-
-        break;
-      }
-      default: {
-        break;
-      }
-    }
-  }
-
-  // Handle remaining removals and deletions
-  if (toRemove.size() > 0) {
-    mountItems[position++] =
-        createRemoveAndDeleteMultiMountItem(localJavaUIManager, toRemove);
-    toRemove.clear();
-  }
-
-  static auto createMountItemsBatchContainer =
-      jni::findClassStatic(Binding::UIManagerJavaDescriptor)
-          ->getMethod<alias_ref<JMountItem>(
-              jint, jtypeArray<JMountItem::javaobject>, jint, jint)>(
-              "createBatchMountItem");
-
-  // If there are no items, we pass a nullptr instead of passing the object
-  // through the JNI
-  auto batch = createMountItemsBatchContainer(
-      localJavaUIManager,
-      surfaceId,
-      position == 0 ? nullptr : mountItemsArray.get(),
-      position,
-      revisionNumber);
-
-  static auto scheduleMountItem =
-      jni::findClassStatic(Binding::UIManagerJavaDescriptor)
-          ->getMethod<void(
-              JMountItem::javaobject,
-              jint,
-              jlong,
-              jlong,
-              jlong,
-              jlong,
-              jlong,
-              jlong,
-              jlong)>("scheduleMountItem");
-
-  auto finishTransactionEndTime = telemetryTimePointNow();
-
-  scheduleMountItem(
-      localJavaUIManager,
-      batch.get(),
-      telemetry.getRevisionNumber(),
-      telemetryTimePointToMilliseconds(telemetry.getCommitStartTime()),
-      telemetryTimePointToMilliseconds(telemetry.getDiffStartTime()),
-      telemetryTimePointToMilliseconds(telemetry.getDiffEndTime()),
-      telemetryTimePointToMilliseconds(telemetry.getLayoutStartTime()),
-      telemetryTimePointToMilliseconds(telemetry.getLayoutEndTime()),
-      telemetryTimePointToMilliseconds(finishTransactionStartTime),
-      telemetryTimePointToMilliseconds(finishTransactionEndTime));
-}
-
 void Binding::setPixelDensity(float pointScaleFactor) {
   pointScaleFactor_ = pointScaleFactor;
 }
@@ -1520,13 +1123,9 @@ void Binding::driveCxxAnimations() {
   scheduler_->animationTick();
 }
 
-void Binding::schedulerDidRequestPreliminaryViewAllocation(
+void Binding::preallocateShadowView(
     const SurfaceId surfaceId,
     const ShadowView &shadowView) {
-  if (disablePreallocateViews_) {
-    return;
-  }
-
   jni::global_ref<jobject> localJavaUIManager = getJavaUIManager();
   if (!localJavaUIManager) {
     LOG(ERROR)
@@ -1536,15 +1135,16 @@ void Binding::schedulerDidRequestPreliminaryViewAllocation(
 
   bool isLayoutableShadowNode = shadowView.layoutMetrics != EmptyLayoutMetrics;
 
-  if (disableVirtualNodePreallocation_ && !isLayoutableShadowNode) {
-    return;
-  }
-
   static auto preallocateView =
       jni::findClassStatic(Binding::UIManagerJavaDescriptor)
           ->getMethod<void(
-              jint, jint, jstring, ReadableMap::javaobject, jobject, jboolean)>(
-              "preallocateView");
+              jint,
+              jint,
+              jstring,
+              ReadableMap::javaobject,
+              jobject,
+              jobject,
+              jboolean)>("preallocateView");
 
   // Do not hold onto Java object from C
   // We DO want to hold onto C object from Java, since we don't know the
@@ -1556,6 +1156,17 @@ void Binding::schedulerDidRequestPreliminaryViewAllocation(
     cStateWrapper->state_ = shadowView.state;
   }
 
+  // Do not hold a reference to javaEventEmitter from the C++ side.
+  local_ref<EventEmitterWrapper::JavaPart> javaEventEmitter = nullptr;
+  if (enableEarlyEventEmitterUpdate_) {
+    SharedEventEmitter eventEmitter = shadowView.eventEmitter;
+    if (eventEmitter != nullptr) {
+      javaEventEmitter = EventEmitterWrapper::newObjectJavaArgs();
+      EventEmitterWrapper *cEventEmitter = cthis(javaEventEmitter);
+      cEventEmitter->eventEmitter = eventEmitter;
+    }
+  }
+
   local_ref<ReadableMap::javaobject> props = castReadableMap(
       ReadableNativeMap::newObjectCxxArgs(shadowView.props->rawProps));
   auto component = getPlatformComponentName(shadowView);
@@ -1567,9 +1178,53 @@ void Binding::schedulerDidRequestPreliminaryViewAllocation(
       component.get(),
       props.get(),
       (javaStateWrapper != nullptr ? javaStateWrapper.get() : nullptr),
+      (javaEventEmitter != nullptr ? javaEventEmitter.get() : nullptr),
       isLayoutableShadowNode);
 }
 
+void Binding::schedulerDidRequestPreliminaryViewAllocation(
+    const SurfaceId surfaceId,
+    const ShadowNode &shadowNode) {
+  if (disablePreallocateViews_) {
+    return;
+  }
+
+  auto shadowView = ShadowView(shadowNode);
+
+  if (!shadowView.traits.check(ShadowNodeTraits::Trait::FormsView)) {
+    return;
+  }
+
+  preallocateShadowView(surfaceId, shadowView);
+}
+
+void Binding::schedulerDidCloneShadowNode(
+    SurfaceId surfaceId,
+    const ShadowNode &oldShadowNode,
+    const ShadowNode &newShadowNode) {
+  // This is only necessary if view preallocation was skipped during
+  // createShadowNode
+
+  // We may need to PreAllocate a ShadowNode at this point if this is the
+  // earliest point it is possible to do so:
+  // 1. The revision is exactly 1
+  // 2. At revision 0 (the old node), View Preallocation would have been skipped
+
+  if (newShadowNode.getProps()->revision != 1) {
+    return;
+  }
+  if (oldShadowNode.getProps()->revision != 0) {
+    return;
+  }
+
+  // If the new node is concrete and the old wasn't, we can preallocate
+  if (!oldShadowNode.getTraits().check(ShadowNodeTraits::Trait::FormsView) &&
+      newShadowNode.getTraits().check(ShadowNodeTraits::Trait::FormsView)) {
+    auto shadowView = ShadowView(newShadowNode);
+    preallocateShadowView(surfaceId, shadowView);
+  }
+}
+
 void Binding::schedulerDidDispatchCommand(
     const ShadowView &shadowView,
     std::string const &commandName,
@@ -1583,7 +1238,7 @@ void Binding::schedulerDidDispatchCommand(
 
   static auto dispatchCommand =
       jni::findClassStatic(Binding::UIManagerJavaDescriptor)
-          ->getMethod<void(jint, jstring, ReadableArray::javaobject)>(
+          ->getMethod<void(jint, jint, jstring, ReadableArray::javaobject)>(
               "dispatchCommand");
 
   local_ref<JString> command = make_jstring(commandName);
@@ -1592,62 +1247,92 @@ void Binding::schedulerDidDispatchCommand(
       castReadableArray(ReadableNativeArray::newObjectCxxArgs(args));
 
   dispatchCommand(
-      localJavaUIManager, shadowView.tag, command.get(), argsArray.get());
+      localJavaUIManager,
+      shadowView.surfaceId,
+      shadowView.tag,
+      command.get(),
+      argsArray.get());
 }
 
-void Binding::schedulerDidSetJSResponder(
-    SurfaceId surfaceId,
+void Binding::schedulerDidSendAccessibilityEvent(
     const ShadowView &shadowView,
-    const ShadowView &initialShadowView,
-    bool blockNativeResponder) {
+    std::string const &eventType) {
   jni::global_ref<jobject> localJavaUIManager = getJavaUIManager();
   if (!localJavaUIManager) {
-    LOG(ERROR) << "Binding::schedulerSetJSResponder: JavaUIManager disappeared";
+    LOG(ERROR)
+        << "Binding::schedulerDidDispatchCommand: JavaUIManager disappeared";
     return;
   }
 
-  static auto setJSResponder =
+  local_ref<JString> eventTypeStr = make_jstring(eventType);
+
+  static auto sendAccessibilityEventFromJS =
       jni::findClassStatic(Binding::UIManagerJavaDescriptor)
-          ->getMethod<void(jint, jint, jboolean)>("setJSResponder");
+          ->getMethod<void(jint, jint, jstring)>(
+              "sendAccessibilityEventFromJS");
 
-  setJSResponder(
+  sendAccessibilityEventFromJS(
       localJavaUIManager,
+      shadowView.surfaceId,
       shadowView.tag,
-      initialShadowView.tag,
-      (jboolean)blockNativeResponder);
+      eventTypeStr.get());
 }
 
-void Binding::schedulerDidClearJSResponder() {
+void Binding::schedulerDidSetIsJSResponder(
+    ShadowView const &shadowView,
+    bool isJSResponder,
+    bool blockNativeResponder) {
   jni::global_ref<jobject> localJavaUIManager = getJavaUIManager();
   if (!localJavaUIManager) {
-    LOG(ERROR)
-        << "Binding::schedulerClearJSResponder: JavaUIManager disappeared";
+    LOG(ERROR) << "Binding::schedulerSetJSResponder: JavaUIManager disappeared";
     return;
   }
 
+  static auto setJSResponder =
+      jni::findClassStatic(Binding::UIManagerJavaDescriptor)
+          ->getMethod<void(jint, jint, jint, jboolean)>("setJSResponder");
+
   static auto clearJSResponder =
       jni::findClassStatic(Binding::UIManagerJavaDescriptor)
           ->getMethod<void()>("clearJSResponder");
 
-  clearJSResponder(localJavaUIManager);
+  if (isJSResponder) {
+    setJSResponder(
+        localJavaUIManager,
+        shadowView.surfaceId,
+        shadowView.tag,
+        // The closest non-flattened ancestor of the same value if the node is
+        // not flattened. For now, we don't support the case when the node can
+        // be flattened because the only component that uses this feature -
+        // ScrollView - cannot be flattened.
+        shadowView.tag,
+        (jboolean)blockNativeResponder);
+  } else {
+    clearJSResponder(localJavaUIManager);
+  }
 }
 
 void Binding::registerNatives() {
-  registerHybrid(
-      {makeNativeMethod("initHybrid", Binding::initHybrid),
-       makeNativeMethod(
-           "installFabricUIManager", Binding::installFabricUIManager),
-       makeNativeMethod("startSurface", Binding::startSurface),
-       makeNativeMethod(
-           "startSurfaceWithConstraints", Binding::startSurfaceWithConstraints),
-       makeNativeMethod(
-           "renderTemplateToSurface", Binding::renderTemplateToSurface),
-       makeNativeMethod("stopSurface", Binding::stopSurface),
-       makeNativeMethod("setConstraints", Binding::setConstraints),
-       makeNativeMethod("setPixelDensity", Binding::setPixelDensity),
-       makeNativeMethod("driveCxxAnimations", Binding::driveCxxAnimations),
-       makeNativeMethod(
-           "uninstallFabricUIManager", Binding::uninstallFabricUIManager)});
+  registerHybrid({
+      makeNativeMethod("initHybrid", Binding::initHybrid),
+      makeNativeMethod(
+          "installFabricUIManager", Binding::installFabricUIManager),
+      makeNativeMethod("startSurface", Binding::startSurface),
+      makeNativeMethod(
+          "getInspectorDataForInstance", Binding::getInspectorDataForInstance),
+      makeNativeMethod(
+          "startSurfaceWithConstraints", Binding::startSurfaceWithConstraints),
+      makeNativeMethod(
+          "renderTemplateToSurface", Binding::renderTemplateToSurface),
+      makeNativeMethod("stopSurface", Binding::stopSurface),
+      makeNativeMethod("setConstraints", Binding::setConstraints),
+      makeNativeMethod("setPixelDensity", Binding::setPixelDensity),
+      makeNativeMethod("driveCxxAnimations", Binding::driveCxxAnimations),
+      makeNativeMethod(
+          "uninstallFabricUIManager", Binding::uninstallFabricUIManager),
+      makeNativeMethod("registerSurface", Binding::registerSurface),
+      makeNativeMethod("unregisterSurface", Binding::unregisterSurface),
+  });
 }
 
 } // namespace react