react-native-tvos 0.79.2-0 → 0.80.0-0

package/ReactCommon/react/renderer/scheduler/Scheduler.cpp

@@ -56,14 +56,10 @@ Scheduler::Scheduler(
 
   runtimeScheduler_ = weakRuntimeScheduler.value().lock().get();
 
-  if (ReactNativeFeatureFlags::enableUIConsistency()) {
-    runtimeScheduler_->setShadowTreeRevisionConsistencyManager(
-        uiManager->getShadowTreeRevisionConsistencyManager());
-  }
+  runtimeScheduler_->setShadowTreeRevisionConsistencyManager(
+      uiManager->getShadowTreeRevisionConsistencyManager());
 
-  if (ReactNativeFeatureFlags::enableReportEventPaintTime()) {
-    runtimeScheduler_->setEventTimingDelegate(eventPerformanceLogger_.get());
-  }
+  runtimeScheduler_->setEventTimingDelegate(eventPerformanceLogger_.get());
 
   auto eventPipe = [uiManager](
                        jsi::Runtime& runtime,
@@ -139,26 +135,22 @@ Scheduler::Scheduler(
   }
   uiManager_->setAnimationDelegate(animationDelegate);
 
-  if (ReactNativeFeatureFlags::enableReportEventPaintTime()) {
-    uiManager->registerMountHook(*eventPerformanceLogger_);
-  }
+  uiManager->registerMountHook(*eventPerformanceLogger_);
 }
 
 Scheduler::~Scheduler() {
   LOG(WARNING) << "Scheduler::~Scheduler() was called (address: " << this
                << ").";
 
-  if (ReactNativeFeatureFlags::enableReportEventPaintTime()) {
-    auto weakRuntimeScheduler =
-        contextContainer_->find<std::weak_ptr<RuntimeScheduler>>(
-            RuntimeSchedulerKey);
-    auto runtimeScheduler = weakRuntimeScheduler.has_value()
-        ? weakRuntimeScheduler.value().lock()
-        : nullptr;
+  auto weakRuntimeScheduler =
+      contextContainer_->find<std::weak_ptr<RuntimeScheduler>>(
+          RuntimeSchedulerKey);
+  auto runtimeScheduler = weakRuntimeScheduler.has_value()
+      ? weakRuntimeScheduler.value().lock()
+      : nullptr;
 
-    if (runtimeScheduler) {
-      runtimeScheduler->setEventTimingDelegate(nullptr);
-    }
+  if (runtimeScheduler) {
+    runtimeScheduler->setEventTimingDelegate(nullptr);
   }
 
   for (auto& commitHook : commitHooks_) {
@@ -320,6 +312,31 @@ void Scheduler::uiManagerDidSetIsJSResponder(
   }
 }
 
+void Scheduler::uiManagerShouldSynchronouslyUpdateViewOnUIThread(
+    Tag tag,
+    const folly::dynamic& props) {
+  if (delegate_ != nullptr) {
+    delegate_->schedulerShouldSynchronouslyUpdateViewOnUIThread(tag, props);
+  }
+}
+
+void Scheduler::uiManagerShouldAddEventListener(
+    std::shared_ptr<const EventListener> listener) {
+  addEventListener(listener);
+}
+
+void Scheduler::uiManagerShouldRemoveEventListener(
+    const std::shared_ptr<const EventListener>& listener) {
+  removeEventListener(listener);
+}
+
+void Scheduler::uiManagerDidStartSurface(const ShadowTree& shadowTree) {
+  std::shared_lock lock(onSurfaceStartCallbackMutex_);
+  if (onSurfaceStartCallback_) {
+    onSurfaceStartCallback_(shadowTree);
+  }
+}
+
 void Scheduler::reportMount(SurfaceId surfaceId) const {
   uiManager_->reportMount(surfaceId);
 }
@@ -346,4 +363,10 @@ void Scheduler::removeEventListener(
   }
 }
 
+void Scheduler::uiManagerShouldSetOnSurfaceStartCallback(
+    OnSurfaceStartCallback&& callback) {
+  std::shared_lock lock(onSurfaceStartCallbackMutex_);
+  onSurfaceStartCallback_ = std::move(callback);
+}
+
 } // namespace facebook::react

package/ReactCommon/react/renderer/scheduler/Scheduler.h

@@ -13,7 +13,6 @@
 #include <ReactCommon/RuntimeExecutor.h>
 #include <react/performance/timeline/PerformanceEntryReporter.h>
 #include <react/renderer/componentregistry/ComponentDescriptorFactory.h>
-#include <react/renderer/components/root/RootComponentDescriptor.h>
 #include <react/renderer/core/ComponentDescriptor.h>
 #include <react/renderer/core/EventEmitter.h>
 #include <react/renderer/core/EventListener.h>
@@ -95,6 +94,14 @@ class Scheduler final : public UIManagerDelegate {
       const ShadowNode::Shared& shadowNode,
       bool isJSResponder,
       bool blockNativeResponder) override;
+  void uiManagerShouldSynchronouslyUpdateViewOnUIThread(
+      Tag tag,
+      const folly::dynamic& props) override;
+  void uiManagerShouldAddEventListener(
+      std::shared_ptr<const EventListener> listener) final;
+  void uiManagerShouldRemoveEventListener(
+      const std::shared_ptr<const EventListener>& listener) final;
+  void uiManagerDidStartSurface(const ShadowTree& shadowTree) override;
 
 #pragma mark - ContextContainer
   ContextContainer::Shared getContextContainer() const;
@@ -109,6 +116,10 @@ class Scheduler final : public UIManagerDelegate {
   void removeEventListener(
       const std::shared_ptr<const EventListener>& listener);
 
+#pragma mark - Surface start callback
+  void uiManagerShouldSetOnSurfaceStartCallback(
+      OnSurfaceStartCallback&& callback) override;
+
  private:
   friend class SurfaceHandler;
 
@@ -138,6 +149,9 @@ class Scheduler final : public UIManagerDelegate {
   ContextContainer::Shared contextContainer_;
 
   RuntimeScheduler* runtimeScheduler_{nullptr};
+
+  mutable std::shared_mutex onSurfaceStartCallbackMutex_;
+  OnSurfaceStartCallback onSurfaceStartCallback_;
 };
 
 } // namespace facebook::react

package/ReactCommon/react/renderer/scheduler/SchedulerDelegate.h

@@ -64,6 +64,10 @@ class SchedulerDelegate {
       bool isJSResponder,
       bool blockNativeResponder) = 0;
 
+  virtual void schedulerShouldSynchronouslyUpdateViewOnUIThread(
+      Tag tag,
+      const folly::dynamic& props) = 0;
+
   virtual ~SchedulerDelegate() noexcept = default;
 };
 

package/ReactCommon/react/renderer/scheduler/SurfaceHandler.cpp

@@ -9,6 +9,7 @@
 
 #include <cxxreact/TraceSection.h>
 #include <react/debug/react_native_assert.h>
+#include <react/featureflags/ReactNativeFeatureFlags.h>
 #include <react/renderer/uimanager/UIManager.h>
 
 namespace facebook::react {
@@ -232,6 +233,77 @@ Size SurfaceHandler::measure(
   return rootShadowNode->getLayoutMetrics().frame.size;
 }
 
+std::shared_ptr<const ShadowNode> SurfaceHandler::dirtyMeasurableNodesRecursive(
+    std::shared_ptr<const ShadowNode> node) const {
+  const auto nodeHasChildren = !node->getChildren().empty();
+  const auto isMeasurableYogaNode =
+      node->getTraits().check(ShadowNodeTraits::Trait::MeasurableYogaNode);
+
+  // Node is not measurable and has no children, its layout will not be affected
+  if (!nodeHasChildren && !isMeasurableYogaNode) {
+    return nullptr;
+  }
+
+  ShadowNode::SharedListOfShared newChildren =
+      ShadowNodeFragment::childrenPlaceholder();
+
+  if (nodeHasChildren) {
+    ShadowNode::UnsharedListOfShared newChildrenMutable = nullptr;
+
+    for (size_t i = 0; i < node->getChildren().size(); i++) {
+      const auto& child = node->getChildren()[i];
+
+      if (const auto& layoutableNode =
+              std::dynamic_pointer_cast<const YogaLayoutableShadowNode>(
+                  child)) {
+        auto newChild = dirtyMeasurableNodesRecursive(layoutableNode);
+
+        if (newChild != nullptr) {
+          if (newChildrenMutable == nullptr) {
+            newChildrenMutable =
+                std::make_shared<ShadowNode::ListOfShared>(node->getChildren());
+            newChildren = newChildrenMutable;
+          }
+
+          (*newChildrenMutable)[i] = newChild;
+        }
+      }
+    }
+
+    // Node is not measurable and its children were not dirtied, its layout will
+    // not be affected
+    if (!isMeasurableYogaNode && newChildrenMutable == nullptr) {
+      return nullptr;
+    }
+  }
+
+  const auto newNode = node->getComponentDescriptor().cloneShadowNode(
+      *node,
+      {
+          .children = newChildren,
+          // Preserve the original state of the node
+          .state = node->getState(),
+      });
+
+  if (isMeasurableYogaNode) {
+    std::static_pointer_cast<YogaLayoutableShadowNode>(newNode)->dirtyLayout();
+  }
+
+  return newNode;
+}
+
+void SurfaceHandler::dirtyMeasurableNodes(ShadowNode& root) const {
+  for (const auto& child : root.getChildren()) {
+    if (const auto& layoutableNode =
+            std::dynamic_pointer_cast<const YogaLayoutableShadowNode>(child)) {
+      const auto newChild = dirtyMeasurableNodesRecursive(layoutableNode);
+      if (newChild != nullptr) {
+        root.replaceChild(*child, newChild);
+      }
+    }
+  }
+}
+
 void SurfaceHandler::constraintLayout(
     const LayoutConstraints& layoutConstraints,
     const LayoutContext& layoutContext) const {
@@ -262,8 +334,19 @@ void SurfaceHandler::constraintLayout(
         link_.shadowTree && "`link_.shadowTree` must not be null.");
     link_.shadowTree->commit(
         [&](const RootShadowNode& oldRootShadowNode) {
-          return oldRootShadowNode.clone(
+          auto newRoot = oldRootShadowNode.clone(
               propsParserContext, layoutConstraints, layoutContext);
+
+          // Dirty all measurable nodes when the fontSizeMultiplier changes to
+          // trigger re-measurement.
+          if (ReactNativeFeatureFlags::enableFontScaleChangesUpdatingLayout() &&
+              layoutContext.fontSizeMultiplier !=
+                  oldRootShadowNode.getConcreteProps()
+                      .layoutContext.fontSizeMultiplier) {
+            dirtyMeasurableNodes(*newRoot);
+          }
+
+          return newRoot;
         },
         {/* default commit options */});
   }

package/ReactCommon/react/renderer/scheduler/SurfaceHandler.h

@@ -10,6 +10,7 @@
 #include <memory>
 #include <shared_mutex>
 
+#include <folly/dynamic.h>
 #include <react/renderer/core/LayoutConstraints.h>
 #include <react/renderer/core/LayoutContext.h>
 #include <react/renderer/core/ReactPrimitives.h>
@@ -156,6 +157,13 @@ class SurfaceHandler {
 
   void applyDisplayMode(DisplayMode displayMode) const;
 
+  /*
+   * An utility for dirtying all measurable shadow nodes present in the tree.
+   */
+  void dirtyMeasurableNodes(ShadowNode& root) const;
+  std::shared_ptr<const ShadowNode> dirtyMeasurableNodesRecursive(
+      std::shared_ptr<const ShadowNode> node) const;
+
 #pragma mark - Link & Parameters
 
   /*

package/ReactCommon/react/renderer/telemetry/CMakeLists.txt

@@ -6,13 +6,7 @@
 cmake_minimum_required(VERSION 3.13)
 set(CMAKE_VERBOSE_MAKEFILE on)
 
-add_compile_options(
-        -fexceptions
-        -frtti
-        -std=c++20
-        -Wall
-        -Wpedantic
-        -DLOG_TAG=\"Fabric\")
+include(${REACT_COMMON_DIR}/cmake-utils/react-native-flags.cmake)
 
 file(GLOB react_renderer_telemetry_SRC CONFIGURE_DEPENDS *.cpp)
 add_library(react_renderer_telemetry OBJECT ${react_renderer_telemetry_SRC})
@@ -30,3 +24,5 @@ target_link_libraries(react_renderer_telemetry
         rrc_root
         rrc_view
         yoga)
+target_compile_reactnative_options(react_renderer_telemetry PRIVATE "Fabric")
+target_compile_options(react_renderer_telemetry PRIVATE -Wpedantic)

package/ReactCommon/react/renderer/textlayoutmanager/CMakeLists.txt

@@ -6,13 +6,7 @@
 cmake_minimum_required(VERSION 3.13)
 set(CMAKE_VERBOSE_MAKEFILE on)
 
-add_compile_options(
-        -fexceptions
-        -frtti
-        -std=c++20
-        -Wall
-        -Wpedantic
-        -DLOG_TAG=\"Fabric\")
+include(${REACT_COMMON_DIR}/cmake-utils/react-native-flags.cmake)
 
 file(GLOB react_renderer_textlayourmanager_SRC CONFIGURE_DEPENDS
         *.cpp
@@ -47,3 +41,5 @@ target_link_libraries(react_renderer_textlayoutmanager
         reactnativejni
         yoga
 )
+target_compile_reactnative_options(react_renderer_textlayoutmanager PRIVATE "Fabric")
+target_compile_options(react_renderer_textlayoutmanager PRIVATE -Wpedantic)

package/ReactCommon/react/renderer/textlayoutmanager/TextLayoutContext.h

@@ -7,6 +7,7 @@
 
 #pragma once
 
+#include <react/renderer/core/ReactPrimitives.h>
 #include <react/renderer/graphics/Float.h>
 
 namespace facebook::react {
@@ -23,18 +24,13 @@ struct TextLayoutContext {
    * to `pixel value`.
    */
   Float pointScaleFactor{1.0};
-};
 
-inline bool operator==(
-    const TextLayoutContext& lhs,
-    const TextLayoutContext& rhs) {
-  return std::tie(lhs.pointScaleFactor) == std::tie(rhs.pointScaleFactor);
-}
+  /**
+   * The ID of the surface being laid out
+   */
+  SurfaceId surfaceId{-1};
 
-inline bool operator!=(
-    const TextLayoutContext& lhs,
-    const TextLayoutContext& rhs) {
-  return !(lhs == rhs);
-}
+  bool operator==(const TextLayoutContext& rhs) const = default;
+};
 
 } // namespace facebook::react

package/ReactCommon/react/renderer/textlayoutmanager/TextLayoutManagerExtended.h

@@ -0,0 +1,124 @@
+/*
+ * 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 <glog/logging.h>
+#include <cstddef>
+
+#include <react/renderer/attributedstring/AttributedStringBox.h>
+#include <react/renderer/attributedstring/ParagraphAttributes.h>
+#include <react/renderer/graphics/Size.h>
+#include <react/renderer/textlayoutmanager/TextLayoutManager.h>
+#include <react/renderer/textlayoutmanager/TextMeasureCache.h>
+
+namespace facebook::react {
+
+template <typename TextLayoutManagerT>
+concept TextLayoutManagerWithPreparedLayout = requires(
+    TextLayoutManagerT textLayoutManager,
+    AttributedString attributedString,
+    ParagraphAttributes paragraphAttributes,
+    TextLayoutContext layoutContext,
+    LayoutConstraints layoutConstraints,
+    typename TextLayoutManagerT::PreparedLayout preparedLayout) {
+  sizeof(typename TextLayoutManagerT::PreparedLayout);
+  {
+    textLayoutManager.prepareLayout(
+        attributedString, paragraphAttributes, layoutContext, layoutConstraints)
+  } -> std::same_as<typename TextLayoutManagerT::PreparedLayout>;
+  {
+    textLayoutManager.measurePreparedLayout(
+        preparedLayout, layoutContext, layoutConstraints)
+  } -> std::same_as<TextMeasurement>;
+};
+
+namespace detail {
+template <typename T>
+struct PreparedLayoutT {
+  using type = std::nullptr_t;
+};
+
+template <TextLayoutManagerWithPreparedLayout T>
+struct PreparedLayoutT<T> {
+  using type = typename T::PreparedLayout;
+};
+
+/**
+ * TextLayoutManagerExtended acts as an adapter for TextLayoutManager methods
+ * which may not exist for a specific platform. Callers can check at
+ * compile-time whether a method is supported, and calling if it is not will
+ * terminate.
+ */
+template <typename TextLayoutManagerT>
+class TextLayoutManagerExtended {
+ public:
+  static constexpr bool supportsLineMeasurement() {
+    return requires(TextLayoutManagerT textLayoutManager) {
+      {
+        textLayoutManager.measureLines(
+            AttributedStringBox{}, ParagraphAttributes{}, Size{})
+      } -> std::same_as<LinesMeasurements>;
+    };
+  }
+
+  static constexpr bool supportsPreparedLayout() {
+    return TextLayoutManagerWithPreparedLayout<TextLayoutManagerT>;
+  }
+
+  using PreparedLayout = typename PreparedLayoutT<TextLayoutManagerT>::type;
+
+  TextLayoutManagerExtended(const TextLayoutManagerT& textLayoutManager)
+      : textLayoutManager_(textLayoutManager) {}
+
+  LinesMeasurements measureLines(
+      const AttributedStringBox& attributedStringBox,
+      const ParagraphAttributes& paragraphAttributes,
+      const Size& size) {
+    if constexpr (supportsLineMeasurement()) {
+      return textLayoutManager_.measureLines(
+          attributedStringBox, paragraphAttributes, size);
+    }
+    LOG(FATAL) << "Platform TextLayoutManager does not support measureLines";
+  }
+
+  PreparedLayout prepareLayout(
+      const AttributedString& attributedString,
+      const ParagraphAttributes& paragraphAttributes,
+      const TextLayoutContext& layoutContext,
+      const LayoutConstraints& layoutConstraints) const {
+    if constexpr (supportsPreparedLayout()) {
+      return textLayoutManager_.prepareLayout(
+          attributedString,
+          paragraphAttributes,
+          layoutContext,
+          layoutConstraints);
+    }
+    LOG(FATAL) << "Platform TextLayoutManager does not support prepareLayout";
+  }
+
+  TextMeasurement measurePreparedLayout(
+      const PreparedLayout& layout,
+      const TextLayoutContext& layoutContext,
+      const LayoutConstraints& layoutConstraints) const {
+    if constexpr (supportsPreparedLayout()) {
+      return textLayoutManager_.measurePreparedLayout(
+          layout, layoutContext, layoutConstraints);
+    }
+    LOG(FATAL)
+        << "Platform TextLayoutManager does not support measurePreparedLayout";
+  }
+
+ private:
+  const TextLayoutManagerT& textLayoutManager_;
+};
+} // namespace detail
+
+using TextLayoutManagerExtended =
+    detail::TextLayoutManagerExtended<TextLayoutManager>;
+
+} // namespace facebook::react

package/ReactCommon/react/renderer/textlayoutmanager/TextMeasureCache.h

@@ -35,6 +35,13 @@ struct LineMeasurement {
   LineMeasurement(const folly::dynamic& data);
 
   bool operator==(const LineMeasurement& rhs) const;
+
+  static inline Float baseline(const std::vector<LineMeasurement>& lines) {
+    if (!lines.empty()) {
+      return lines[0].ascender;
+    }
+    return 0;
+  }
 };
 
 using LinesMeasurements = std::vector<LineMeasurement>;

package/ReactCommon/react/renderer/textlayoutmanager/platform/android/react/renderer/textlayoutmanager/JPreparedLayout.h

@@ -0,0 +1,20 @@
+/*
+ * 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>
+
+namespace facebook::react {
+
+class JPreparedLayout : public jni::JavaClass<JPreparedLayout> {
+ public:
+  static auto constexpr kJavaDescriptor =
+      "Lcom/facebook/react/views/text/PreparedLayout;";
+};
+
+} // namespace facebook::react