react-native 0.70.6 → 0.71.0-rc.1

package/ReactAndroid/src/main/jni/react/cxxcomponents/BUCK

@@ -0,0 +1,44 @@
+load(
+    "//tools/build_defs/oss:rn_defs.bzl",
+    "ANDROID",
+    "APPLE",
+    "CXX",
+    "react_native_xplat_target",
+    "rn_xplat_cxx_library",
+    "subdir_glob",
+)
+
+rn_xplat_cxx_library(
+    name = "components",
+    srcs = glob(
+        ["**/*.cpp"],
+    ),
+    headers = glob(
+        ["**/*.h"],
+    ),
+    header_namespace = "",
+    exported_headers = subdir_glob(
+        [
+            ("", "**/*.h"),
+        ],
+        prefix = "react/cxxcomponents",
+    ),
+    force_static = True,
+    labels = [
+        "pfh:ReactNative_CommonInfrastructurePlaceholder",
+    ],
+    platforms = (APPLE, ANDROID, CXX),
+    preprocessor_flags = [
+        "-DLOG_TAG=\"ReactNative\"",
+        "-DWITH_FBSYSTRACE=1",
+    ],
+    soname = "libcxxcomponents.$(ext)",
+    visibility = ["PUBLIC"],
+    deps = [
+        "//third-party/glog:glog",
+        "//xplat/fbsystrace:fbsystrace",
+        "//xplat/folly:memory",
+        "//xplat/folly:molly",
+        react_native_xplat_target("react/renderer/core:core"),
+    ],
+)

package/ReactAndroid/src/main/jni/react/cxxcomponents/CMakeLists.txt

@@ -0,0 +1,22 @@
+# 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)
+set(CMAKE_VERBOSE_MAKEFILE on)
+
+add_compile_options(
+        -fexceptions
+        -frtti
+        -std=c++17
+        -Wall
+        -Wpedantic
+        -Wno-gnu-zero-variadic-macro-arguments)
+
+file(GLOB_RECURSE cxxcomponents_SRC CONFIGURE_DEPENDS *.cpp *.h)
+
+add_library(cxxcomponents SHARED ${cxxcomponents_SRC})
+
+target_include_directories(cxxcomponents PUBLIC .)
+set_target_properties(cxxcomponents PROPERTIES LINKER_LANGUAGE CXX)

package/ReactAndroid/src/main/jni/react/cxxcomponents/Component.h

@@ -0,0 +1,66 @@
+/*
+ * 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.
+ */
+
+#pragma once
+
+#include <react/renderer/core/Props.h>
+#include <react/renderer/core/ReactPrimitives.h>
+#include <memory>
+#include <string>
+
+namespace facebook::react {
+
+class Component {
+ public:
+  Component(Tag tag, Props::Shared initialProps)
+      : tag_(tag), props_(std::move(initialProps)) {}
+
+  virtual ~Component() = default;
+
+  /*
+   * Called for updating component's props.
+   * Receiver must update native view props accordingly changed props.
+   */
+  virtual void updateProps(
+      Props::Shared const &oldProps,
+      Props::Shared const &newProps) = 0;
+
+  /*
+   * Called for mounting (attaching) a child component view inside `self`
+   * component view.
+   * Receiver must add `childComponent` as a sub component.
+   */
+  virtual void mountChildComponent(
+      std::shared_ptr<facebook::react::Component> childComponent,
+      int index){};
+
+  /*
+   * Called for unmounting (detaching) a child component view from `self`
+   * component view.
+   * Receiver must remove `childComponent` from a sub component
+   */
+  virtual void unmountChildComponent(
+      std::shared_ptr<facebook::react::Component> childComponent,
+      int index){};
+
+  /*
+   * Called for updating component's state.
+   * Receiver must update native view according to changed state.
+   */
+  virtual void updateState(){};
+
+  /*
+   * Called when the component is being deleted.
+   */
+  virtual void deleteComponent() = 0;
+
+ protected:
+  Tag tag_ = -1;
+  Props::Shared props_;
+};
+
+} // namespace facebook::react

package/ReactAndroid/src/main/jni/react/cxxcomponents/ComponentManager.h

@@ -0,0 +1,26 @@
+/*
+ * 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.
+ */
+
+#pragma once
+
+#include <react/cxxcomponents/Component.h>
+#include <react/renderer/core/Props.h>
+
+namespace facebook::react {
+
+class ComponentManager {
+ public:
+  ComponentManager() {}
+
+  virtual std::shared_ptr<Component> createComponent(
+      Tag tag,
+      Props::Shared initialProps) = 0;
+
+  virtual ~ComponentManager() = default;
+};
+
+} // namespace facebook::react

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

@@ -7,14 +7,13 @@ rn_xplat_cxx_library(
     header_namespace = "",
     exported_headers = subdir_glob(
         [
-            ("", "**/*.h"),
+            ("", "*.h"),
         ],
         prefix = "react/fabric",
     ),
     fbandroid_allow_jni_merging = True,
     labels = [
         "pfh:ReactNative_CommonInfrastructurePlaceholder",
-        "supermodule:xplat/default/public.react_native.infra",
     ],
     platforms = ANDROID,
     preprocessor_flags = [
@@ -24,6 +23,7 @@ rn_xplat_cxx_library(
     soname = "libfabricjni.$(ext)",
     visibility = ["PUBLIC"],
     deps = [
+        react_native_xplat_target("butter:butter"),
         react_native_xplat_target("react/renderer/mapbuffer:mapbuffer"),
         react_native_xplat_target("react/config:config"),
         react_native_xplat_target("react/renderer/animations:animations"),
@@ -34,9 +34,9 @@ rn_xplat_cxx_library(
         react_native_xplat_target("react/renderer/componentregistry:componentregistry"),
         react_native_xplat_target("react/renderer/components/scrollview:scrollview"),
         react_native_xplat_target("runtimeexecutor:runtimeexecutor"),
+        "//xplat/js/react-native-github/ReactAndroid/src/main/jni/react/cxxcomponents:components",
         react_native_target("jni/react/jni:jni"),
         "//xplat/fbsystrace:fbsystrace",
-        "//xplat/folly:molly",
         "//xplat/jsi:JSIDynamic",
         "//xplat/jsi:jsi",
         "//xplat/third-party/linker_lib:atomic",

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

@@ -8,6 +8,7 @@
 #include "Binding.h"
 
 #include "AsyncEventBeat.h"
+#include "CppComponentRegistry.h"
 #include "EventEmitterWrapper.h"
 #include "JBackgroundExecutor.h"
 #include "ReactNativeConfigHolder.h"
@@ -22,6 +23,7 @@
 #include <react/renderer/animations/LayoutAnimationDriver.h>
 #include <react/renderer/componentregistry/ComponentDescriptorFactory.h>
 #include <react/renderer/components/scrollview/ScrollViewProps.h>
+#include <react/renderer/core/CoreFeatures.h>
 #include <react/renderer/core/EventBeat.h>
 #include <react/renderer/core/EventEmitter.h>
 #include <react/renderer/core/conversions.h>
@@ -360,7 +362,8 @@ void Binding::installFabricUIManager(
     jni::alias_ref<jobject> javaUIManager,
     EventBeatManager *eventBeatManager,
     ComponentFactory *componentsRegistry,
-    jni::alias_ref<jobject> reactNativeConfig) {
+    jni::alias_ref<jobject> reactNativeConfig,
+    CppComponentRegistry *cppComponentRegistry) {
   SystraceSection s("FabricUIManagerBinding::installFabricUIManager");
 
   std::shared_ptr<const ReactNativeConfig> config =
@@ -369,24 +372,24 @@ void Binding::installFabricUIManager(
   enableFabricLogs_ =
       config->getBool("react_fabric:enabled_android_fabric_logs");
 
-  disableRevisionCheckForPreallocation_ =
-      config->getBool("react_fabric:disable_revision_check_for_preallocation");
-
-  disablePreallocationOnClone_ =
-      getFeatureFlagValue("disablePreallocationOnClone");
-
   if (enableFabricLogs_) {
     LOG(WARNING) << "Binding::installFabricUIManager() was called (address: "
                  << this << ").";
   }
 
+  // TODO[T135327389]: Investigate why code relying on CppComponentRegistry
+  // crashing during hot reload restart.
+  // sharedCppComponentRegistry_ =
+  //     std::shared_ptr<const facebook::react::CppComponentRegistry>(
+  //         cppComponentRegistry ? cppComponentRegistry : nullptr);
+
   // Use std::lock and std::adopt_lock to prevent deadlocks by locking mutexes
   // at the same time
   std::unique_lock<butter::shared_mutex> lock(installMutex_);
 
   auto globalJavaUiManager = make_global(javaUIManager);
-  mountingManager_ =
-      std::make_shared<FabricMountingManager>(config, globalJavaUiManager);
+  mountingManager_ = std::make_shared<FabricMountingManager>(
+      config, sharedCppComponentRegistry_, globalJavaUiManager);
 
   ContextContainer::Shared contextContainer =
       std::make_shared<ContextContainer>();
@@ -431,25 +434,15 @@ void Binding::installFabricUIManager(
   reactNativeConfig_ = config;
 
   contextContainer->insert(
-      "MapBufferSerializationEnabled",
-      getFeatureFlagValue("mapBufferSerializationEnabled"));
+      "CalculateTransformedFramesEnabled",
+      getFeatureFlagValue("calculateTransformedFramesEnabled"));
 
   disablePreallocateViews_ = reactNativeConfig_->getBool(
       "react_fabric:disabled_view_preallocation_android");
 
-  dispatchPreallocationInBackground_ = reactNativeConfig_->getBool(
-      "react_native_new_architecture:dispatch_preallocation_in_bg");
-
-  contextContainer->insert(
-      "EnableLargeTextMeasureCache",
-      getFeatureFlagValue("enableLargeTextMeasureCache"));
-
   // Props setter pattern feature
-  Props::enablePropIteratorSetter =
+  CoreFeatures::enablePropIteratorSetter =
       getFeatureFlagValue("enableCppPropsIteratorSetter");
-  AccessibilityProps::enablePropIteratorSetter =
-      Props::enablePropIteratorSetter;
-  BaseTextProps::enablePropIteratorSetter = Props::enablePropIteratorSetter;
 
   // RemoveDelete mega-op
   ShadowViewMutation::PlatformSupportsRemoveDeleteTreeInstruction =
@@ -458,12 +451,20 @@ void Binding::installFabricUIManager(
   auto toolbox = SchedulerToolbox{};
   toolbox.contextContainer = contextContainer;
   toolbox.componentRegistryFactory = componentsRegistry->buildRegistryFunction;
+
+  // TODO: (T130208323) runtimeExecutor should execute lambdas after
+  // main bundle eval, and bindingsInstallExecutor should execute before.
+  toolbox.bridgelessBindingsExecutor = std::nullopt;
   toolbox.runtimeExecutor = runtimeExecutor;
+
   toolbox.synchronousEventBeatFactory = synchronousBeatFactory;
   toolbox.asynchronousEventBeatFactory = asynchronousBeatFactory;
 
-  backgroundExecutor_ = JBackgroundExecutor::create("fabric_bg");
-  toolbox.backgroundExecutor = backgroundExecutor_;
+  if (reactNativeConfig_->getBool(
+          "react_fabric:enable_background_executor_android")) {
+    backgroundExecutor_ = JBackgroundExecutor::create("fabric_bg");
+    toolbox.backgroundExecutor = backgroundExecutor_;
+  }
 
   animationDriver_ = std::make_shared<LayoutAnimationDriver>(
       runtimeExecutor, contextContainer, this);
@@ -482,6 +483,7 @@ void Binding::uninstallFabricUIManager() {
   scheduler_ = nullptr;
   mountingManager_ = nullptr;
   reactNativeConfig_ = nullptr;
+  sharedCppComponentRegistry_ = nullptr;
 }
 
 std::shared_ptr<FabricMountingManager> Binding::verifyMountingManager(
@@ -518,40 +520,20 @@ void Binding::schedulerDidRequestPreliminaryViewAllocation(
   preallocateView(surfaceId, shadowNode);
 }
 
-void Binding::schedulerDidCloneShadowNode(
+void Binding::preallocateView(
     SurfaceId surfaceId,
-    ShadowNode const &oldShadowNode,
-    ShadowNode const &newShadowNode) {
-  if (disablePreallocationOnClone_) {
+    ShadowNode const &shadowNode) {
+  auto name = std::string(shadowNode.getComponentName());
+
+  // Disable preallocation in java for C++ view managers
+  // RootComponents that are implmented as C++ view managers are still
+  // preallocated (this could be avoided by using Portals)
+  if (sharedCppComponentRegistry_ && sharedCppComponentRegistry_.get() &&
+      sharedCppComponentRegistry_->containsComponentManager(name) &&
+      !sharedCppComponentRegistry_->isRootComponent(name)) {
     return;
   }
-  // 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 (!disableRevisionCheckForPreallocation_) {
-    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)) {
-    preallocateView(surfaceId, newShadowNode);
-  }
-}
-
-void Binding::preallocateView(
-    SurfaceId surfaceId,
-    ShadowNode const &shadowNode) {
   auto shadowView = ShadowView(shadowNode);
   auto preallocationFunction = [this,
                                 surfaceId,
@@ -564,11 +546,7 @@ void Binding::preallocateView(
     mountingManager->preallocateShadowView(surfaceId, shadowView);
   };
 
-  if (dispatchPreallocationInBackground_) {
-    backgroundExecutor_(preallocationFunction);
-  } else {
-    preallocationFunction();
-  }
+  preallocationFunction();
 }
 
 void Binding::schedulerDidDispatchCommand(

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

@@ -7,6 +7,7 @@
 
 #pragma once
 
+#include "CppComponentRegistry.h"
 #include "FabricMountingManager.h"
 
 #include <memory>
@@ -65,7 +66,8 @@ class Binding : public jni::HybridClass<Binding>,
       jni::alias_ref<jobject> javaUIManager,
       EventBeatManager *eventBeatManager,
       ComponentFactory *componentsRegistry,
-      jni::alias_ref<jobject> reactNativeConfig);
+      jni::alias_ref<jobject> reactNativeConfig,
+      CppComponentRegistry *cppComponentRegistry);
 
   void startSurface(
       jint surfaceId,
@@ -100,11 +102,6 @@ class Binding : public jni::HybridClass<Binding>,
       const SurfaceId surfaceId,
       const ShadowNode &shadowNode) override;
 
-  void schedulerDidCloneShadowNode(
-      SurfaceId surfaceId,
-      const ShadowNode &oldShadowNode,
-      const ShadowNode &newShadowNode) override;
-
   void schedulerDidDispatchCommand(
       const ShadowView &shadowView,
       std::string const &commandName,
@@ -150,11 +147,10 @@ class Binding : public jni::HybridClass<Binding>,
   float pointScaleFactor_ = 1;
 
   std::shared_ptr<const ReactNativeConfig> reactNativeConfig_{nullptr};
+  std::shared_ptr<const facebook::react::CppComponentRegistry>
+      sharedCppComponentRegistry_{nullptr};
   bool disablePreallocateViews_{false};
   bool enableFabricLogs_{false};
-  bool disableRevisionCheckForPreallocation_{false};
-  bool dispatchPreallocationInBackground_{false};
-  bool disablePreallocationOnClone_{false};
 };
 
 } // namespace react

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

@@ -18,6 +18,7 @@ target_include_directories(fabricjni PUBLIC ${CMAKE_CURRENT_SOURCE_DIR})
 target_link_libraries(
         fabricjni
         butter
+        cxxcomponents
         fb
         fbjni
         folly_runtime

package/ReactAndroid/src/main/jni/react/fabric/ComponentRegistryResolver.cpp

@@ -0,0 +1,51 @@
+/*
+ * 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.
+ */
+
+#include "ComponentRegistryResolver.h"
+
+#include <android/log.h>
+
+namespace facebook {
+namespace react {
+
+void ComponentRegistryResolver::addComponentManager(
+    std::string name,
+    bool isRootComponent,
+    std::function<std::shared_ptr<facebook::react::ComponentManager>(
+        const std::string &name)> f) {
+  ComponentResolverData data = {isRootComponent, std::move(f)};
+  resolverMap_.insert({name, data});
+}
+
+bool ComponentRegistryResolver::containsComponentManager(
+    std::string componentName) const {
+  return resolverMap_.contains(componentName);
+}
+
+std::shared_ptr<facebook::react::ComponentManager>
+ComponentRegistryResolver::getComponentManager(
+    std::string componentName) const {
+  auto iterator = resolverMap_.find(componentName);
+  if (iterator != resolverMap_.end()) {
+    return iterator->second.getComponentManagerFunction(componentName);
+  }
+
+  return nullptr;
+}
+
+bool ComponentRegistryResolver::isRootComponent(
+    std::string componentName) const {
+  auto iterator = resolverMap_.find(componentName);
+  if (iterator != resolverMap_.end()) {
+    return iterator->second.isRootComponent;
+  }
+
+  return false;
+}
+
+} // namespace react
+} // namespace facebook

package/ReactAndroid/src/main/jni/react/fabric/ComponentRegistryResolver.h

@@ -0,0 +1,47 @@
+/*
+ * 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.
+ */
+
+#pragma once
+
+#include <fbjni/fbjni.h>
+#include <react/cxxcomponents/ComponentManager.h>
+
+namespace facebook {
+namespace react {
+
+struct ComponentResolverData {
+  bool isRootComponent;
+  std::function<std::shared_ptr<facebook::react::ComponentManager>(
+      const std::string &name)>
+      getComponentManagerFunction;
+};
+
+using ComponentResolverMap = butter::map<std::string, ComponentResolverData>;
+
+class ComponentRegistryResolver {
+ public:
+  ComponentRegistryResolver(){};
+
+  void addComponentManager(
+      std::string name,
+      bool isRootComponent,
+      std::function<std::shared_ptr<facebook::react::ComponentManager>(
+          const std::string &name)> f);
+
+  bool containsComponentManager(std::string componentName) const;
+
+  bool isRootComponent(std::string componentName) const;
+
+  std::shared_ptr<facebook::react::ComponentManager> getComponentManager(
+      std::string name) const;
+
+ private:
+  butter::map<std::string, ComponentResolverData> resolverMap_{};
+};
+
+} // namespace react
+} // namespace facebook

package/ReactAndroid/src/main/jni/react/fabric/CppComponentRegistry.cpp

@@ -0,0 +1,73 @@
+/*
+ * 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.
+ */
+
+#include "CppComponentRegistry.h"
+#include <android/log.h>
+#include <fbjni/fbjni.h>
+#include <jsi/jsi.h>
+#include <react/renderer/componentregistry/ComponentDescriptorRegistry.h>
+
+using namespace facebook::jsi;
+
+namespace facebook {
+namespace react {
+
+jni::local_ref<CppComponentRegistry::jhybriddata>
+CppComponentRegistry::initHybrid(jni::alias_ref<jclass>) {
+  return makeCxxInstance();
+}
+
+void CppComponentRegistry::registerNatives() {
+  registerHybrid({
+      makeNativeMethod("initHybrid", CppComponentRegistry::initHybrid),
+  });
+}
+
+void CppComponentRegistry::addComponentManager(
+    std::string name,
+    bool isRootComponent,
+    std::function<std::shared_ptr<facebook::react::ComponentManager>(
+        const std::string &name)> f) {
+  componentManagerResolver_.addComponentManager(name, isRootComponent, f);
+}
+
+bool CppComponentRegistry::containsComponentManager(std::string name) const {
+  return componentManagerResolver_.containsComponentManager(name);
+}
+
+std::shared_ptr<facebook::react::ComponentManager>
+CppComponentRegistry::getComponentManager(const std::string &name) const {
+  return componentManagerResolver_.getComponentManager(name);
+}
+
+std::shared_ptr<facebook::react::Component>
+CppComponentRegistry::getComponentInstance(Tag tag) const {
+  return components_[tag];
+}
+
+bool CppComponentRegistry::isRootComponent(std::string name) const {
+  return componentManagerResolver_.isRootComponent(name);
+}
+
+std::shared_ptr<facebook::react::Component>
+CppComponentRegistry::createComponentInstance(
+    const std::string &componentName,
+    Tag tag,
+    Props::Shared initialProps) const {
+  // TODO: cache component managers
+  auto componentManager = getComponentManager(componentName);
+  auto component = componentManager->createComponent(tag, initialProps);
+  components_[tag] = component;
+  return component;
+}
+
+void CppComponentRegistry::deleteComponentInstance(Tag tag) const {
+  components_.erase(tag);
+}
+
+} // namespace react
+} // namespace facebook

package/ReactAndroid/src/main/jni/react/fabric/CppComponentRegistry.h

@@ -0,0 +1,64 @@
+/*
+ * 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.
+ */
+
+#pragma once
+
+#include <fbjni/fbjni.h>
+#include <glog/logging.h>
+#include <jsi/jsi.h>
+#include <react/utils/ContextContainer.h>
+#include <mutex>
+#include <unordered_set>
+
+#include <react/cxxcomponents/Component.h>
+#include <react/cxxcomponents/ComponentManager.h>
+#include <react/fabric/ComponentRegistryResolver.h>
+
+namespace facebook {
+namespace react {
+
+class Instance;
+
+class CppComponentRegistry : public jni::HybridClass<CppComponentRegistry> {
+ public:
+  constexpr static const char *const kJavaDescriptor =
+      "Lcom/facebook/react/fabric/CppComponentRegistry;";
+
+  static void registerNatives();
+
+  void addComponentManager(
+      std::string name,
+      bool isRootComponent,
+      std::function<std::shared_ptr<facebook::react::ComponentManager>(
+          const std::string &name)> f);
+
+  bool isRootComponent(std::string name) const;
+
+  bool containsComponentManager(std::string name) const;
+
+  std::shared_ptr<facebook::react::ComponentManager> getComponentManager(
+      const std::string &name) const;
+
+  std::shared_ptr<facebook::react::Component> getComponentInstance(
+      Tag tag) const;
+
+  std::shared_ptr<facebook::react::Component> createComponentInstance(
+      const std::string &componentName,
+      Tag tag,
+      Props::Shared initialProps) const;
+
+  void deleteComponentInstance(Tag tag) const;
+
+ private:
+  static jni::local_ref<jhybriddata> initHybrid(jni::alias_ref<jclass>);
+  ComponentRegistryResolver componentManagerResolver_{};
+  mutable butter::map<Tag, std::shared_ptr<facebook::react::Component>>
+      components_{};
+};
+
+} // namespace react
+} // namespace facebook