react-native 0.68.1 → 0.69.0-rc.0

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

@@ -24,6 +24,7 @@ import com.facebook.react.uimanager.StateWrapper;
  * the Bindings.cpp, where the pointer to the C++ event emitter is set.
  */
 @SuppressLint("MissingNativeLoadLibrary")
+@DoNotStrip
 public class StateWrapperImpl implements StateWrapper {
   static {
     FabricSoLoader.staticInit();
@@ -46,7 +47,7 @@ public class StateWrapperImpl implements StateWrapper {
 
   @Override
   @Nullable
-  public ReadableMapBuffer getStatDataMapBuffer() {
+  public ReadableMapBuffer getStateDataMapBuffer() {
     if (mDestroyed) {
       FLog.e(TAG, "Race between StateWrapperImpl destruction and getState");
       return null;

package/ReactAndroid/src/main/java/com/facebook/react/fabric/jni/Android.mk

@@ -15,8 +15,7 @@ LOCAL_SHARED_LIBRARIES := \
   libbutter \
   libfb \
   libfbjni \
-  libfolly_futures \
-  libfolly_json \
+  libfolly_runtime \
   libglog \
   libglog_init \
   libjsi \

package/ReactAndroid/src/main/java/com/facebook/react/fabric/jni/{AsyncEventBeatV2.cpp → AsyncEventBeat.cpp}

@@ -9,11 +9,11 @@
 #include <react/renderer/core/EventBeat.h>
 #include <react/renderer/uimanager/primitives.h>
 
-#include "AsyncEventBeatV2.h"
+#include "AsyncEventBeat.h"
 
 namespace facebook::react {
 
-AsyncEventBeatV2::AsyncEventBeatV2(
+AsyncEventBeat::AsyncEventBeat(
     EventBeat::SharedOwnerBox const &ownerBox,
     EventBeatManager *eventBeatManager,
     RuntimeExecutor runtimeExecutor,
@@ -25,11 +25,11 @@ AsyncEventBeatV2::AsyncEventBeatV2(
   eventBeatManager->addObserver(*this);
 }
 
-AsyncEventBeatV2::~AsyncEventBeatV2() {
+AsyncEventBeat::~AsyncEventBeat() {
   eventBeatManager_->removeObserver(*this);
 }
 
-void AsyncEventBeatV2::tick() const {
+void AsyncEventBeat::tick() const {
   if (!isRequested_ || isBeatCallbackScheduled_) {
     return;
   }
@@ -50,11 +50,11 @@ void AsyncEventBeatV2::tick() const {
   });
 }
 
-void AsyncEventBeatV2::induce() const {
+void AsyncEventBeat::induce() const {
   tick();
 }
 
-void AsyncEventBeatV2::request() const {
+void AsyncEventBeat::request() const {
   bool alreadyRequested = isRequested_;
   EventBeat::request();
   if (!alreadyRequested) {

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

@@ -7,14 +7,11 @@
 
 #pragma once
 
-#include <jsi/jsi.h>
 #include <react/renderer/core/EventBeat.h>
-#include <react/renderer/uimanager/primitives.h>
 
 #include "EventBeatManager.h"
 
-namespace facebook {
-namespace react {
+namespace facebook::react {
 
 class AsyncEventBeat final : public EventBeat, public EventBeatManagerObserver {
  public:
@@ -22,50 +19,21 @@ class AsyncEventBeat final : public EventBeat, public EventBeatManagerObserver {
       EventBeat::SharedOwnerBox const &ownerBox,
       EventBeatManager *eventBeatManager,
       RuntimeExecutor runtimeExecutor,
-      jni::global_ref<jobject> javaUIManager)
-      : EventBeat(ownerBox),
-        eventBeatManager_(eventBeatManager),
-        runtimeExecutor_(std::move(runtimeExecutor)),
-        javaUIManager_(std::move(javaUIManager)) {
-    eventBeatManager->addObserver(*this);
-  }
+      jni::global_ref<jobject> javaUIManager);
 
-  ~AsyncEventBeat() {
-    eventBeatManager_->removeObserver(*this);
-  }
+  ~AsyncEventBeat() override;
 
-  void tick() const override {
-    runtimeExecutor_([this, ownerBox = ownerBox_](jsi::Runtime &runtime) {
-      auto owner = ownerBox->owner.lock();
-      if (!owner) {
-        return;
-      }
+  void tick() const override;
 
-      this->beat(runtime);
-    });
-  }
+  void induce() const override;
 
-  void induce() const override {
-    tick();
-  }
-
-  void request() const override {
-    bool alreadyRequested = isRequested_;
-    EventBeat::request();
-    if (!alreadyRequested) {
-      // Notifies java side that an event will be dispatched (e.g. LayoutEvent)
-      static auto onRequestEventBeat =
-          jni::findClassStatic("com/facebook/react/fabric/FabricUIManager")
-              ->getMethod<void()>("onRequestEventBeat");
-      onRequestEventBeat(javaUIManager_);
-    }
-  }
+  void request() const override;
 
  private:
   EventBeatManager *eventBeatManager_;
   RuntimeExecutor runtimeExecutor_;
   jni::global_ref<jobject> javaUIManager_;
+  mutable std::atomic<bool> isBeatCallbackScheduled_{false};
 };
 
-} // namespace react
-} // namespace facebook
+} // namespace facebook::react

package/ReactAndroid/src/main/java/com/facebook/react/fabric/jni/BUCK

@@ -11,10 +11,11 @@ rn_xplat_cxx_library(
         ],
         prefix = "react/fabric",
     ),
-    compiler_flags_enable_exceptions = False,
-    compiler_flags_enable_rtti = False,  # for YogaLayoutableShadowNode?
     fbandroid_allow_jni_merging = True,
-    labels = ["supermodule:xplat/default/public.react_native.infra"],
+    labels = [
+        "pfh:ReactNative_CommonInfrastructurePlaceholder",
+        "supermodule:xplat/default/public.react_native.infra",
+    ],
     platforms = ANDROID,
     preprocessor_flags = [
         "-DLOG_TAG=\"ReactNative\"",
@@ -26,6 +27,7 @@ rn_xplat_cxx_library(
         react_native_xplat_target("react/renderer/mapbuffer:mapbuffer"),
         react_native_xplat_target("react/config:config"),
         react_native_xplat_target("react/renderer/animations:animations"),
+        react_native_xplat_target("react/renderer/graphics:graphics"),
         react_native_xplat_target("react/renderer/uimanager:uimanager"),
         react_native_xplat_target("react/renderer/scheduler:scheduler"),
         react_native_xplat_target("react/renderer/mounting:mounting"),
@@ -48,6 +50,7 @@ rn_xplat_cxx_library(
         react_native_xplat_target("react/renderer/components/switch:androidswitch"),
         react_native_xplat_target("react/renderer/components/progressbar:androidprogressbar"),
         react_native_xplat_target("react/renderer/components/text:text"),
+        react_native_xplat_target("react/renderer/components/view:view"),
         react_native_xplat_target("react/renderer/components/textinput:androidtextinput"),
     ],
 )

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

@@ -7,7 +7,6 @@
 
 #include "Binding.h"
 #include "AsyncEventBeat.h"
-#include "AsyncEventBeatV2.h"
 #include "EventEmitterWrapper.h"
 #include "ReactNativeConfigHolder.h"
 #include "StateWrapperImpl.h"
@@ -60,9 +59,8 @@ Binding::getInspectorDataForInstance(
   }
 
   EventEmitterWrapper *cEventEmitter = cthis(eventEmitterWrapper);
-  InspectorData data = scheduler->getInspectorDataForInstance(
-      enableEventEmitterRawPointer_ ? *cEventEmitter->eventEmitterPointer
-                                    : *cEventEmitter->eventEmitter);
+  InspectorData data =
+      scheduler->getInspectorDataForInstance(*cEventEmitter->eventEmitter);
 
   folly::dynamic result = folly::dynamic::object;
   result["fileName"] = data.fileName;
@@ -78,6 +76,14 @@ 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);
+}
+
 bool isMapBufferSerializationEnabled() {
   static const auto reactFeatureFlagsJavaDescriptor =
       jni::findClassStatic(Binding::ReactFeatureFlagsJavaDescriptor);
@@ -266,13 +272,37 @@ void Binding::stopSurface(jint surfaceId) {
 }
 
 void Binding::registerSurface(SurfaceHandlerBinding *surfaceHandlerBinding) {
+  auto const &surfaceHandler = surfaceHandlerBinding->getSurfaceHandler();
   auto scheduler = getScheduler();
-  scheduler->registerSurface(surfaceHandlerBinding->getSurfaceHandler());
+  if (!scheduler) {
+    LOG(ERROR) << "Binding::registerSurface: scheduler disappeared";
+    return;
+  }
+  scheduler->registerSurface(surfaceHandler);
+
+  auto mountingManager =
+      verifyMountingManager("FabricUIManagerBinding::registerSurface");
+  if (!mountingManager) {
+    return;
+  }
+  mountingManager->onSurfaceStart(surfaceHandler.getSurfaceId());
 }
 
 void Binding::unregisterSurface(SurfaceHandlerBinding *surfaceHandlerBinding) {
+  auto const &surfaceHandler = surfaceHandlerBinding->getSurfaceHandler();
   auto scheduler = getScheduler();
-  scheduler->unregisterSurface(surfaceHandlerBinding->getSurfaceHandler());
+  if (!scheduler) {
+    LOG(ERROR) << "Binding::unregisterSurface: scheduler disappeared";
+    return;
+  }
+  scheduler->unregisterSurface(surfaceHandler);
+
+  auto mountingManager =
+      verifyMountingManager("FabricUIManagerBinding::unregisterSurface");
+  if (!mountingManager) {
+    return;
+  }
+  mountingManager->onSurfaceStop(surfaceHandler.getSurfaceId());
 }
 
 void Binding::setConstraints(
@@ -345,8 +375,8 @@ void Binding::installFabricUIManager(
   disableRevisionCheckForPreallocation_ =
       config->getBool("react_fabric:disable_revision_check_for_preallocation");
 
-  enableEventEmitterRawPointer_ =
-      config->getBool("react_fabric:enable_event_emitter_wrapper_raw_pointer");
+  disablePreallocationOnClone_ = config->getBool(
+      "react_native_new_architecture:disable_preallocation_on_clone_android");
 
   if (enableFabricLogs_) {
     LOG(WARNING) << "Binding::installFabricUIManager() was called (address: "
@@ -369,46 +399,34 @@ 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) {
             runtimeScheduler->scheduleWork(std::move(callback));
           };
+      contextContainer->insert(
+          "RuntimeScheduler",
+          std::weak_ptr<RuntimeScheduler>(runtimeScheduler));
     }
   }
 
-  auto enableV2AsynchronousEventBeat =
-      config->getBool("react_fabric:enable_asynchronous_event_beat_v2_android");
-
   // TODO: T31905686 Create synchronous Event Beat
   EventBeat::Factory synchronousBeatFactory =
-      [eventBeatManager,
-       runtimeExecutor,
-       globalJavaUiManager,
-       enableV2AsynchronousEventBeat](EventBeat::SharedOwnerBox const &ownerBox)
+      [eventBeatManager, runtimeExecutor, globalJavaUiManager](
+          EventBeat::SharedOwnerBox const &ownerBox)
       -> std::unique_ptr<EventBeat> {
-    if (enableV2AsynchronousEventBeat) {
-      return std::make_unique<AsyncEventBeatV2>(
-          ownerBox, eventBeatManager, runtimeExecutor, globalJavaUiManager);
-    } else {
-      return std::make_unique<AsyncEventBeat>(
-          ownerBox, eventBeatManager, runtimeExecutor, globalJavaUiManager);
-    }
+    return std::make_unique<AsyncEventBeat>(
+        ownerBox, eventBeatManager, runtimeExecutor, globalJavaUiManager);
   };
 
   EventBeat::Factory asynchronousBeatFactory =
-      [eventBeatManager,
-       runtimeExecutor,
-       globalJavaUiManager,
-       enableV2AsynchronousEventBeat](EventBeat::SharedOwnerBox const &ownerBox)
+      [eventBeatManager, runtimeExecutor, globalJavaUiManager](
+          EventBeat::SharedOwnerBox const &ownerBox)
       -> std::unique_ptr<EventBeat> {
-    if (enableV2AsynchronousEventBeat) {
-      return std::make_unique<AsyncEventBeatV2>(
-          ownerBox, eventBeatManager, runtimeExecutor, globalJavaUiManager);
-    } else {
-      return std::make_unique<AsyncEventBeat>(
-          ownerBox, eventBeatManager, runtimeExecutor, globalJavaUiManager);
-    }
+    return std::make_unique<AsyncEventBeat>(
+        ownerBox, eventBeatManager, runtimeExecutor, globalJavaUiManager);
   };
 
   contextContainer->insert("ReactNativeConfig", config);
@@ -427,9 +445,7 @@ void Binding::installFabricUIManager(
       "react_native_new_architecture:dispatch_preallocation_in_bg");
 
   contextContainer->insert(
-      "EnableLargeTextMeasureCache",
-      reactNativeConfig_->getBool(
-          "react_fabric:enable_large_text_measure_cache_android"));
+      "EnableLargeTextMeasureCache", isLargeTextMeasureCacheEnabled());
 
   auto toolbox = SchedulerToolbox{};
   toolbox.contextContainer = contextContainer;
@@ -498,6 +514,9 @@ void Binding::schedulerDidCloneShadowNode(
     SurfaceId surfaceId,
     ShadowNode const &oldShadowNode,
     ShadowNode const &newShadowNode) {
+  if (disablePreallocationOnClone_) {
+    return;
+  }
   // This is only necessary if view preallocation was skipped during
   // createShadowNode
 

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

@@ -43,6 +43,8 @@ class Binding : public jni::HybridClass<Binding>,
 
   static void registerNatives();
 
+  std::shared_ptr<Scheduler> getScheduler();
+
  private:
   void setConstraints(
       jint surfaceId,
@@ -133,7 +135,6 @@ class Binding : public jni::HybridClass<Binding>,
   std::shared_ptr<FabricMountingManager> mountingManager_;
   std::shared_ptr<Scheduler> scheduler_;
 
-  std::shared_ptr<Scheduler> getScheduler();
   std::shared_ptr<FabricMountingManager> verifyMountingManager(
       std::string const &locationHint);
 
@@ -155,8 +156,8 @@ class Binding : public jni::HybridClass<Binding>,
   bool disablePreallocateViews_{false};
   bool enableFabricLogs_{false};
   bool disableRevisionCheckForPreallocation_{false};
-  bool enableEventEmitterRawPointer_{false};
   bool dispatchPreallocationInBackground_{false};
+  bool disablePreallocationOnClone_{false};
 };
 
 } // namespace react

package/ReactAndroid/src/main/java/com/facebook/react/fabric/jni/CMakeLists.txt

@@ -0,0 +1,70 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+#
+# This source code is licensed under the MIT license found in the
+# LICENSE file in the root directory of this source tree.
+
+cmake_minimum_required(VERSION 3.13)
+
+file(GLOB fabricjni_SRCS CONFIGURE_DEPENDS *.cpp)
+
+add_library(
+        fabricjni
+        SHARED
+        ${fabricjni_SRCS}
+)
+
+target_include_directories(fabricjni PUBLIC ${CMAKE_CURRENT_SOURCE_DIR})
+
+target_link_libraries(
+        fabricjni
+        butter
+        fb
+        fbjni
+        folly_runtime
+        glog
+        glog_init
+        jsi
+        mapbufferjni
+        react_codegen_rncore
+        react_debug
+        react_render_animations
+        react_render_attributedstring
+        react_render_componentregistry
+        react_render_core
+        react_render_debug
+        react_render_graphics
+        react_render_imagemanager
+        react_render_mapbuffer
+        react_render_mounting
+        react_render_runtimescheduler
+        react_render_scheduler
+        react_render_telemetry
+        react_render_templateprocessor
+        react_render_textlayoutmanager
+        react_render_uimanager
+        react_utils
+        react_config
+        reactnativeutilsjni
+        rrc_image
+        rrc_modal
+        rrc_progressbar
+        rrc_root
+        rrc_scrollview
+        rrc_slider
+        rrc_switch
+        rrc_text
+        rrc_textinput
+        rrc_unimplementedview
+        rrc_view
+        yoga
+)
+
+target_compile_options(
+        fabricjni
+        PRIVATE
+        -DLOG_TAG=\"Fabric\"
+        -fexceptions
+        -frtti
+        -std=c++17
+        -Wall
+)

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

@@ -19,18 +19,9 @@ EventEmitterWrapper::initHybrid(jni::alias_ref<jclass>) {
 }
 
 void EventEmitterWrapper::invokeEvent(
-    std::string const &eventName,
+    std::string eventName,
     NativeMap *payload,
     int category) {
-  if (eventEmitterPointer) {
-    eventEmitterPointer->dispatchEvent(
-        eventName,
-        payload->consume(),
-        EventPriority::AsynchronousBatched,
-        static_cast<RawEvent::Category>(category));
-    return;
-  }
-
   // It is marginal, but possible for this to be constructed without a valid
   // EventEmitter. In those cases, make sure we noop/blackhole events instead of
   // crashing.
@@ -44,13 +35,9 @@ void EventEmitterWrapper::invokeEvent(
 }
 
 void EventEmitterWrapper::invokeUniqueEvent(
-    std::string const &eventName,
+    std::string eventName,
     NativeMap *payload,
     int customCoalesceKey) {
-  if (eventEmitterPointer) {
-    eventEmitterPointer->dispatchUniqueEvent(eventName, payload->consume());
-    return;
-  }
   // TODO: customCoalesceKey currently unused
   // It is marginal, but possible for this to be constructed without a valid
   // EventEmitter. In those cases, make sure we noop/blackhole events instead of

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

@@ -24,12 +24,10 @@ class EventEmitterWrapper : public jni::HybridClass<EventEmitterWrapper> {
   static void registerNatives();
 
   SharedEventEmitter eventEmitter;
-  EventEmitter const *eventEmitterPointer;
 
-  void
-  invokeEvent(std::string const &eventName, NativeMap *params, int category);
+  void invokeEvent(std::string eventName, NativeMap *params, int category);
   void invokeUniqueEvent(
-      std::string const &eventName,
+      std::string eventName,
       NativeMap *params,
       int customCoalesceKey);
 

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

@@ -28,8 +28,11 @@ CppMountItem CppMountItem::RemoveMountItem(
     int index) {
   return {CppMountItem::Type::Remove, parentView, shadowView, {}, index};
 }
-CppMountItem CppMountItem::UpdatePropsMountItem(ShadowView const &shadowView) {
-  return {CppMountItem::Type::UpdateProps, {}, {}, shadowView, -1};
+CppMountItem CppMountItem::UpdatePropsMountItem(
+    ShadowView const &oldShadowView,
+    ShadowView const &newShadowView) {
+  return {
+      CppMountItem::Type::UpdateProps, {}, oldShadowView, newShadowView, -1};
 }
 CppMountItem CppMountItem::UpdateStateMountItem(ShadowView const &shadowView) {
   return {CppMountItem::Type::UpdateState, {}, {}, shadowView, -1};

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

@@ -35,7 +35,9 @@ struct CppMountItem final {
       ShadowView const &shadowView,
       int index);
 
-  static CppMountItem UpdatePropsMountItem(ShadowView const &shadowView);
+  static CppMountItem UpdatePropsMountItem(
+      ShadowView const &oldShadowView,
+      ShadowView const &newShadowView);
 
   static CppMountItem UpdateStateMountItem(ShadowView const &shadowView);