react-native-tvos 0.84.1-0 → 0.85.0-0

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

@@ -29,7 +29,7 @@ class TextLayoutManager;
  */
 class TextLayoutManager {
  public:
-  using PreparedLayout = SafeReleaseJniRef<jni::global_ref<JPreparedLayout>>;
+  using PreparedTextLayout = SafeReleaseJniRef<jni::global_ref<JPreparedLayout>>;
 
   TextLayoutManager(const std::shared_ptr<const ContextContainer> &contextContainer);
 
@@ -77,17 +77,17 @@ class TextLayoutManager {
    * Create a platform representation of fully laid out text, to later be
    * reused.
    */
-  PreparedLayout prepareLayout(
+  PreparedTextLayout prepareLayout(
       const AttributedString &attributedString,
       const ParagraphAttributes &paragraphAttributes,
       const TextLayoutContext &layoutContext,
       const LayoutConstraints &layoutConstraints) const;
 
   /**
-   * Derive text and attachment measurements from a PreparedLayout.
+   * Derive text and attachment measurements from a PreparedTextLayout.
    */
   TextMeasurement measurePreparedLayout(
-      const PreparedLayout &layout,
+      const PreparedTextLayout &layout,
       const TextLayoutContext &layoutContext,
       const LayoutConstraints &layoutConstraints) const;
 
@@ -95,7 +95,7 @@ class TextLayoutManager {
   std::shared_ptr<const ContextContainer> contextContainer_;
   TextMeasureCache textMeasureCache_;
   LineMeasureCache lineMeasureCache_;
-  SimpleThreadSafeCache<PreparedTextCacheKey, PreparedLayout, -1 /* Set dynamically*/> preparedTextCache_;
+  SimpleThreadSafeCache<PreparedTextCacheKey, PreparedTextLayout, -1 /* Set dynamically*/> preparedTextCache_;
 };
 
 } // namespace facebook::react

package/ReactCommon/react/renderer/textlayoutmanager/platform/ios/react/renderer/textlayoutmanager/RCTAttributedTextUtils.h

@@ -52,17 +52,17 @@ BOOL RCTIsAttributedStringEffectivelySame(
     NSDictionary<NSAttributedStringKey, id> *insensitiveAttributes,
     const facebook::react::TextAttributes &baseTextAttributes);
 
-static inline NSData *RCTWrapEventEmitter(const facebook::react::SharedEventEmitter &eventEmitter)
+static inline NSData *RCTWrapEventEmitter(const std::shared_ptr<const facebook::react::EventEmitter> &eventEmitter)
 {
   auto eventEmitterPtr = new std::weak_ptr<const facebook::react::EventEmitter>(eventEmitter);
   return [[NSData alloc] initWithBytesNoCopy:eventEmitterPtr
                                       length:sizeof(eventEmitterPtr)
                                  deallocator:^(void *ptrToDelete, NSUInteger) {
-                                   delete (std::weak_ptr<facebook::react::EventEmitter> *)ptrToDelete;
+                                   delete (std::weak_ptr<const facebook::react::EventEmitter> *)ptrToDelete;
                                  }];
 }
 
-static inline facebook::react::SharedEventEmitter RCTUnwrapEventEmitter(NSData *data)
+static inline std::shared_ptr<const facebook::react::EventEmitter> RCTUnwrapEventEmitter(NSData *data)
 {
   if (data.length == 0) {
     return nullptr;

package/ReactCommon/react/renderer/textlayoutmanager/platform/ios/react/renderer/textlayoutmanager/RCTAttributedTextUtils.mm

@@ -60,10 +60,11 @@ inline static UIFontTextStyle RCTUIFontTextStyleForDynamicTypeRamp(const Dynamic
     case DynamicTypeRamp::Title1:
       return UIFontTextStyleTitle1;
     case DynamicTypeRamp::LargeTitle:
-#if TARGET_OS_TV
-      return UIFontTextStyleTitle1;
-#else
+// UIFontTextStyleLargeTitle is not available on tvOS.
+#if !TARGET_OS_TV
       return UIFontTextStyleLargeTitle;
+#else
+      return UIFontTextStyleTitle1;
 #endif
   }
 }

package/ReactCommon/react/renderer/textlayoutmanager/platform/ios/react/renderer/textlayoutmanager/RCTTextLayoutManager.h

@@ -47,7 +47,7 @@ using RCTTextLayoutFragmentEnumerationBlock =
                                                   (facebook::react::ParagraphAttributes)paragraphAttributes
                                                              size:(CGSize)size;
 
-- (facebook::react::SharedEventEmitter)
+- (std::shared_ptr<const facebook::react::EventEmitter>)
     getEventEmitterWithAttributeString:(facebook::react::AttributedString)attributedString
                    paragraphAttributes:(facebook::react::ParagraphAttributes)paragraphAttributes
                                  frame:(CGRect)frame

package/ReactCommon/react/renderer/textlayoutmanager/platform/ios/react/renderer/textlayoutmanager/RCTTextLayoutManager.mm

@@ -251,10 +251,10 @@ static NSLineBreakMode RCTNSLineBreakModeFromEllipsizeMode(EllipsizeMode ellipsi
   return textStorage;
 }
 
-- (SharedEventEmitter)getEventEmitterWithAttributeString:(AttributedString)attributedString
-                                     paragraphAttributes:(ParagraphAttributes)paragraphAttributes
-                                                   frame:(CGRect)frame
-                                                 atPoint:(CGPoint)point
+- (std::shared_ptr<const EventEmitter>)getEventEmitterWithAttributeString:(AttributedString)attributedString
+                                                      paragraphAttributes:(ParagraphAttributes)paragraphAttributes
+                                                                    frame:(CGRect)frame
+                                                                  atPoint:(CGPoint)point
 {
   NSTextStorage *textStorage = [self
       _textStorageAndLayoutManagerWithAttributesString:[self _nsAttributedStringFromAttributedString:attributedString]
@@ -391,6 +391,8 @@ static NSLineBreakMode RCTNSLineBreakModeFromEllipsizeMode(EllipsizeMode ellipsi
   size = (CGSize){ceil(size.width * layoutContext.pointScaleFactor) / layoutContext.pointScaleFactor,
                   ceil(size.height * layoutContext.pointScaleFactor) / layoutContext.pointScaleFactor};
 
+  NSRange visibleGlyphRange = [layoutManager glyphRangeForTextContainer:textContainer];
+
   __block auto attachments = TextMeasurement::Attachments{};
 
   [textStorage
@@ -406,7 +408,15 @@ static NSLineBreakMode RCTNSLineBreakModeFromEllipsizeMode(EllipsizeMode ellipsi
                                                                      actualCharacterRange:NULL];
                 NSRange truncatedRange =
                     [layoutManager truncatedGlyphRangeInLineFragmentForGlyphAtIndex:attachmentGlyphRange.location];
-                if (truncatedRange.location != NSNotFound && attachmentGlyphRange.location >= truncatedRange.location) {
+
+                // Attachment on a line that did not fit (e.g. on the 4th line when the container is limited to 3 lines)
+                BOOL isOutsideVisibleRange = !NSLocationInRange(attachmentGlyphRange.location, visibleGlyphRange);
+                // Attachment in the ellipsis range of the last visible line (line truncated with "..." and the
+                // attachment falls in that portion)
+                BOOL isInTruncatedRange =
+                    truncatedRange.location != NSNotFound && attachmentGlyphRange.location >= truncatedRange.location;
+
+                if (isOutsideVisibleRange || isInTruncatedRange) {
                   attachments.push_back(TextMeasurement::Attachment{.isClipped = true});
                 } else {
                   CGSize attachmentSize = attachment.bounds.size;

package/ReactCommon/react/renderer/textlayoutmanager/platform/ios/react/renderer/textlayoutmanager/RCTTextPrimitivesConversions.h

@@ -49,13 +49,13 @@ inline static NSLineBreakStrategy RCTNSLineBreakStrategyFromLineBreakStrategy(
     case facebook::react::LineBreakStrategy::PushOut:
       return NSLineBreakStrategyPushOut;
     case facebook::react::LineBreakStrategy::HangulWordPriority:
-      if (@available(iOS 14.0, *)) {
+      if (@available(iOS 14.0, tvOS 14.0, *)) {
         return NSLineBreakStrategyHangulWordPriority;
       } else {
         return NSLineBreakStrategyNone;
       }
     case facebook::react::LineBreakStrategy::Standard:
-      if (@available(iOS 14.0, *)) {
+      if (@available(iOS 14.0, tvOS 14.0, *)) {
         return NSLineBreakStrategyStandard;
       } else {
         return NSLineBreakStrategyNone;

package/ReactCommon/react/renderer/textlayoutmanager/platform/ios/react/renderer/textlayoutmanager/TextLayoutManager.mm

@@ -37,7 +37,8 @@ TextMeasurement TextLayoutManager::measure(
 
   switch (attributedStringBox.getMode()) {
     case AttributedStringBox::Mode::Value: {
-      auto attributedString = ensurePlaceholderIfEmpty_DO_NOT_USE(attributedStringBox.getValue());
+      auto originalAtributedString = attributedStringBox.getValue();
+      auto attributedString = ensurePlaceholderIfEmpty_DO_NOT_USE(originalAtributedString);
 
       measurement = textMeasureCache_.get(
           {.attributedString = attributedString,
@@ -54,6 +55,14 @@ TextMeasurement TextLayoutManager::measure(
                                                             layoutContext:layoutContext
                                                         layoutConstraints:layoutConstraints];
 
+            // TODO(D63303709): We compensate for the placeholder character
+            // being used to represent empty string. iOS TextLayoutManager
+            // should instead measure using `baseTextAttributes` of the
+            // `AttributedString`.
+            if (originalAtributedString.isEmpty()) {
+              measurement.size.width = 0;
+            }
+
             if (telemetry) {
               telemetry->didMeasureText();
             }

package/ReactCommon/react/renderer/uimanager/PointerEventsProcessor.cpp

@@ -15,7 +15,7 @@ namespace facebook::react {
 std::shared_ptr<const ShadowNode>
 PointerEventsProcessor::getShadowNodeFromEventTarget(
     jsi::Runtime& runtime,
-    const EventTarget* target) {
+    EventTarget* target) {
   if (target != nullptr) {
     target->retain(runtime);
     auto instanceHandle = target->getInstanceHandle(runtime);

package/ReactCommon/react/renderer/uimanager/PointerEventsProcessor.h

@@ -47,9 +47,7 @@ using PointerHoverTrackerRegistry = std::unordered_map<PointerIdentifier, Pointe
 
 class PointerEventsProcessor final {
  public:
-  static std::shared_ptr<const ShadowNode> getShadowNodeFromEventTarget(
-      jsi::Runtime &runtime,
-      const EventTarget *target);
+  static std::shared_ptr<const ShadowNode> getShadowNodeFromEventTarget(jsi::Runtime &runtime, EventTarget *target);
 
   void interceptPointerEvent(
       const std::shared_ptr<const ShadowNode> &target,

package/ReactCommon/react/renderer/uimanager/PointerHoverTracker.cpp

@@ -19,7 +19,7 @@ PointerHoverTracker::PointerHoverTracker(
     : target_(std::move(target)) {
   if (target_ != nullptr) {
     // Retrieve the root shadow node at this current revision so that we can
-    // leverage it to get the event path list at the moment the event occured
+    // leverage it to get the event path list at the moment the event occurred
     auto rootShadowNode = std::shared_ptr<const ShadowNode>{};
     auto& shadowTreeRegistry = uiManager.getShadowTreeRegistry();
     shadowTreeRegistry.visit(

package/ReactCommon/react/renderer/uimanager/UIManager.cpp

@@ -107,7 +107,8 @@ std::shared_ptr<ShadowNode> UIManager::createNode(
 
 std::shared_ptr<ShadowNode> UIManager::cloneNode(
     const ShadowNode& shadowNode,
-    const ShadowNode::SharedListOfShared& children,
+    const std::shared_ptr<const std::vector<std::shared_ptr<const ShadowNode>>>&
+        children,
     RawProps rawProps) const {
   TraceSection s(
       "UIManager::cloneNode", "componentName", shadowNode.getComponentName());
@@ -184,12 +185,15 @@ void UIManager::appendChild(
 
 void UIManager::completeSurface(
     SurfaceId surfaceId,
-    const ShadowNode::UnsharedListOfShared& rootChildren,
+    const std::shared_ptr<std::vector<std::shared_ptr<const ShadowNode>>>&
+        rootChildren,
     ShadowTree::CommitOptions commitOptions) {
   TraceSection s("UIManager::completeSurface", "surfaceId", surfaceId);
 
+  ShadowTree::CommitStatus result;
+
   shadowTreeRegistry_.visit(surfaceId, [&](const ShadowTree& shadowTree) {
-    auto result = shadowTree.commit(
+    result = shadowTree.commit(
         [&](const RootShadowNode& oldRootShadowNode) {
           return std::make_shared<RootShadowNode>(
               oldRootShadowNode,
@@ -199,20 +203,17 @@ void UIManager::completeSurface(
               });
         },
         commitOptions);
+  });
 
-    if (result == ShadowTree::CommitStatus::Succeeded) {
-      // It's safe to update the visible revision of the shadow tree immediately
-      // after we commit a specific one.
-      lazyShadowTreeRevisionConsistencyManager_->updateCurrentRevision(
-          surfaceId, shadowTree.getCurrentRevision().rootShadowNode);
+  if (result == ShadowTree::CommitStatus::Succeeded) {
+    // It's safe to update the visible revision of the shadow tree immediately
+    // after we commit a specific one.
+    lazyShadowTreeRevisionConsistencyManager_->updateCurrentRevision(surfaceId);
 
-      if (ReactNativeFeatureFlags::useSharedAnimatedBackend()) {
-        if (auto animationBackend = animationBackend_.lock()) {
-          animationBackend->clearRegistry(surfaceId);
-        }
-      }
+    if (ReactNativeFeatureFlags::useSharedAnimatedBackend()) {
+      animationBackend_->clearRegistry(surfaceId);
     }
-  });
+  }
 }
 
 void UIManager::setIsJSResponder(
@@ -437,8 +438,8 @@ void UIManager::setNativeProps_DEPRECATED(
   if (family.nativeProps_DEPRECATED) {
     // Values in `rawProps` patch (take precedence over)
     // `nativeProps_DEPRECATED`. For example, if both `nativeProps_DEPRECATED`
-    // and `rawProps` contain key 'A'. Value from `rawProps` overrides what was
-    // previously in `nativeProps_DEPRECATED`.
+    // and `rawProps` contain key 'A'. Value from `rawProps` overrides what
+    // was previously in `nativeProps_DEPRECATED`.
     family.nativeProps_DEPRECATED =
         std::make_unique<folly::dynamic>(mergeDynamicProps(
             *family.nativeProps_DEPRECATED,
@@ -470,7 +471,7 @@ void UIManager::setNativeProps_DEPRECATED(
                             ->getProps(),
                         RawProps(rawProps));
 
-                    return oldShadowNode.clone({/* .props = */ .props = props});
+                    return oldShadowNode.clone({.props = props});
                   });
 
               return std::static_pointer_cast<RootShadowNode>(rootNode);
@@ -494,15 +495,12 @@ void UIManager::configureNextLayoutAnimation(
     const jsi::Value& failureCallback) const {
   if (animationDelegate_ != nullptr) {
     animationDelegate_->uiManagerDidConfigureNextLayoutAnimation(
-        runtime,
-        config,
-        std::move(successCallback),
-        std::move(failureCallback));
+        runtime, config, successCallback, failureCallback);
   }
 }
 
 static std::shared_ptr<const ShadowNode> findShadowNodeByTagRecursively(
-    std::shared_ptr<const ShadowNode> parentShadowNode,
+    const std::shared_ptr<const ShadowNode>& parentShadowNode,
     Tag tag) {
   if (parentShadowNode->getTag() == tag) {
     return parentShadowNode;
@@ -524,20 +522,30 @@ std::shared_ptr<const ShadowNode> UIManager::findShadowNodeByTag_DEPRECATED(
   auto shadowNode = std::shared_ptr<const ShadowNode>{};
 
   shadowTreeRegistry_.enumerate([&](const ShadowTree& shadowTree, bool& stop) {
+    // Obtain a pointer to the root node. The flag-gated path uses
+    // getCurrentRevision() which keeps the root alive via shared_ptr for
+    // the entire traversal, fixing a use-after-free race condition.
+    RootShadowNode::Shared rootShadowNodeHolder;
     const RootShadowNode* rootShadowNode = nullptr;
-    // The public interface of `ShadowTree` discourages accessing a stored
-    // pointer to a root node because of the possible data race.
-    // To work around this, we ask for a commit and immediately cancel it
-    // returning `nullptr` instead of a new shadow tree.
-    // We don't want to add a way to access a stored pointer to a root node
-    // because this `findShadowNodeByTag` is deprecated. It is only added
-    // to make migration to the new architecture easier.
-    shadowTree.tryCommit(
-        [&](const RootShadowNode& oldRootShadowNode) {
-          rootShadowNode = &oldRootShadowNode;
-          return nullptr;
-        },
-        {/* default commit options */});
+    if (ReactNativeFeatureFlags::fixFindShadowNodeByTagRaceCondition()) {
+      rootShadowNodeHolder = shadowTree.getCurrentRevision().rootShadowNode;
+      rootShadowNode = rootShadowNodeHolder.get();
+    } else {
+      // TODO(T257154369): Remove after flag rollout.
+      // The public interface of `ShadowTree` discourages accessing a stored
+      // pointer to a root node because of the possible data race.
+      // To work around this, we ask for a commit and immediately cancel it
+      // returning `nullptr` instead of a new shadow tree.
+      // We don't want to add a way to access a stored pointer to a root
+      // node because this `findShadowNodeByTag` is deprecated. It is only
+      // added to make migration to the new architecture easier.
+      shadowTree.tryCommit(
+          [&](const RootShadowNode& oldRootShadowNode) {
+            rootShadowNode = &oldRootShadowNode;
+            return nullptr;
+          },
+          {/* default commit options */});
+    }
 
     if (rootShadowNode != nullptr) {
       const auto& children = rootShadowNode->getChildren();
@@ -645,6 +653,20 @@ void UIManager::shadowTreeDidFinishTransaction(
   }
 }
 
+void UIManager::shadowTreeDidFinishReactCommit(
+    const ShadowTree& shadowTree) const {
+  if (delegate_ != nullptr) {
+    delegate_->uiManagerDidFinishReactCommit(shadowTree);
+  }
+}
+
+void UIManager::shadowTreeDidPromoteReactRevision(
+    const ShadowTree& shadowTree) const {
+  if (delegate_ != nullptr) {
+    delegate_->uiManagerDidPromoteReactRevision(shadowTree);
+  }
+}
+
 void UIManager::reportMount(SurfaceId surfaceId) const {
   TraceSection s("UIManager::reportMount");
 
@@ -687,7 +709,7 @@ void UIManager::setNativeAnimatedDelegate(
 }
 
 void UIManager::unstable_setAnimationBackend(
-    std::weak_ptr<UIManagerAnimationBackend> animationBackend) {
+    std::shared_ptr<UIManagerAnimationBackend> animationBackend) {
   animationBackend_ = animationBackend;
 }
 
@@ -704,8 +726,10 @@ void UIManager::animationTick() const {
     });
   }
 
-  if (auto nativeAnimatedDelegate = nativeAnimatedDelegate_.lock()) {
-    nativeAnimatedDelegate->runAnimationFrame();
+  if (!ReactNativeFeatureFlags::useSharedAnimatedBackend()) {
+    if (auto nativeAnimatedDelegate = nativeAnimatedDelegate_.lock()) {
+      nativeAnimatedDelegate->runAnimationFrame();
+    }
   }
 }
 
@@ -717,6 +741,12 @@ void UIManager::synchronouslyUpdateViewOnUIThread(
   }
 }
 
+#pragma mark ContextContainer
+
+std::shared_ptr<const ContextContainer> UIManager::getContextContainer() const {
+  return contextContainer_;
+}
+
 #pragma mark - Add & Remove event listener
 
 void UIManager::addEventListener(

package/ReactCommon/react/renderer/uimanager/UIManager.h

@@ -64,11 +64,11 @@ class UIManager final : public ShadowTreeDelegate {
   /**
    * Sets and gets UIManager's AnimationBackend reference.
    */
-  void unstable_setAnimationBackend(std::weak_ptr<UIManagerAnimationBackend> animationBackend);
+  void unstable_setAnimationBackend(std::shared_ptr<UIManagerAnimationBackend> animationBackend);
   std::weak_ptr<UIManagerAnimationBackend> unstable_getAnimationBackend();
 
   /**
-   * Execute stopSurface on any UIMAnagerAnimationDelegate.
+   * Execute stopSurface on any UIManagerAnimationDelegate.
    */
   void stopSurfaceForAnimationDelegate(SurfaceId surfaceId) const;
 
@@ -79,9 +79,9 @@ class UIManager final : public ShadowTreeDelegate {
   void synchronouslyUpdateViewOnUIThread(Tag tag, const folly::dynamic &props);
 
   /*
-   * Provides access to a UIManagerBindging.
+   * Provides access to a UIManagerBinding.
    * The `callback` methods will not be called if the internal pointer to
-   * `UIManagerBindging` is `nullptr`.
+   * `UIManagerBinding` is `nullptr`.
    * The callback is called synchronously on the same thread.
    */
   void visitBinding(
@@ -135,6 +135,10 @@ class UIManager final : public ShadowTreeDelegate {
       const RootShadowNode::Unshared &newRootShadowNode,
       const ShadowTree::CommitOptions &commitOptions) const override;
 
+  void shadowTreeDidFinishReactCommit(const ShadowTree &shadowTree) const override;
+
+  void shadowTreeDidPromoteReactRevision(const ShadowTree &shadowTree) const override;
+
   std::shared_ptr<ShadowNode> createNode(
       Tag tag,
       const std::string &componentName,
@@ -142,8 +146,10 @@ class UIManager final : public ShadowTreeDelegate {
       RawProps props,
       InstanceHandle::Shared instanceHandle) const;
 
-  std::shared_ptr<ShadowNode>
-  cloneNode(const ShadowNode &shadowNode, const ShadowNode::SharedListOfShared &children, RawProps rawProps) const;
+  std::shared_ptr<ShadowNode> cloneNode(
+      const ShadowNode &shadowNode,
+      const std::shared_ptr<const std::vector<std::shared_ptr<const ShadowNode>>> &children,
+      RawProps rawProps) const;
 
   void appendChild(
       const std::shared_ptr<const ShadowNode> &parentShadowNode,
@@ -151,7 +157,7 @@ class UIManager final : public ShadowTreeDelegate {
 
   void completeSurface(
       SurfaceId surfaceId,
-      const ShadowNode::UnsharedListOfShared &rootChildren,
+      const std::shared_ptr<std::vector<std::shared_ptr<const ShadowNode>>> &rootChildren,
       ShadowTree::CommitOptions commitOptions);
 
   void setIsJSResponder(
@@ -201,6 +207,9 @@ class UIManager final : public ShadowTreeDelegate {
 
   void updateShadowTree(std::unordered_map<Tag, folly::dynamic> &&tagToProps);
 
+#pragma mark - ContextContainer
+  std::shared_ptr<const ContextContainer> getContextContainer() const;
+
 #pragma mark - Add & Remove event listener
 
   void addEventListener(std::shared_ptr<const EventListener> listener);
@@ -248,7 +257,7 @@ class UIManager final : public ShadowTreeDelegate {
 
   std::unique_ptr<LazyShadowTreeRevisionConsistencyManager> lazyShadowTreeRevisionConsistencyManager_;
 
-  std::weak_ptr<UIManagerAnimationBackend> animationBackend_;
+  std::shared_ptr<UIManagerAnimationBackend> animationBackend_;
 };
 
 } // namespace facebook::react

package/ReactCommon/react/renderer/uimanager/UIManagerAnimationBackend.h

@@ -7,19 +7,31 @@
 
 #pragma once
 
-#include <react/renderer/components/view/BaseViewProps.h>
-#include <react/renderer/core/ShadowNodeFamily.h>
+#include <ReactCommon/CallInvoker.h>
+#include <react/renderer/core/ReactPrimitives.h>
+#include <chrono>
+#include <functional>
+#include <memory>
 
 namespace facebook::react {
 
+struct AnimationMutations;
+
+using AnimationTimestamp = std::chrono::duration<double, std::milli>;
+using CallbackId = uint64_t;
+
 class UIManagerAnimationBackend {
  public:
+  using Callback = std::function<AnimationMutations(AnimationTimestamp)>;
+
   virtual ~UIManagerAnimationBackend() = default;
 
-  virtual void onAnimationFrame(double timestamp) = 0;
-  // TODO: T240293839 Move over start() function and mutation types
-  virtual void stop(bool isAsync) = 0;
+  virtual void onAnimationFrame(AnimationTimestamp timestamp) = 0;
+  virtual CallbackId start(const Callback &callback) = 0;
+  virtual void stop(CallbackId callbackId) = 0;
   virtual void clearRegistry(SurfaceId surfaceId) = 0;
+  virtual void trigger() = 0;
+  virtual void registerJSInvoker(std::shared_ptr<CallInvoker> jsInvoker) = 0;
 };
 
 } // namespace facebook::react

package/ReactCommon/react/renderer/uimanager/UIManagerBinding.cpp

@@ -62,7 +62,7 @@ UIManagerBinding::~UIManagerBinding() {
 
 void UIManagerBinding::dispatchEvent(
     jsi::Runtime& runtime,
-    const EventTarget* eventTarget,
+    EventTarget* eventTarget,
     const std::string& type,
     ReactEventPriority priority,
     const EventPayload& eventPayload) const {
@@ -101,7 +101,7 @@ void UIManagerBinding::dispatchEvent(
 
 void UIManagerBinding::dispatchEventToJS(
     jsi::Runtime& runtime,
-    const EventTarget* eventTarget,
+    EventTarget* eventTarget,
     const std::string& type,
     ReactEventPriority priority,
     const EventPayload& eventPayload) const {

package/ReactCommon/react/renderer/uimanager/UIManagerBinding.h

@@ -44,7 +44,7 @@ class UIManagerBinding : public jsi::HostObject {
    */
   void dispatchEvent(
       jsi::Runtime &runtime,
-      const EventTarget *eventTarget,
+      EventTarget *eventTarget,
       const std::string &type,
       ReactEventPriority priority,
       const EventPayload &payload) const;
@@ -73,7 +73,7 @@ class UIManagerBinding : public jsi::HostObject {
    */
   void dispatchEventToJS(
       jsi::Runtime &runtime,
-      const EventTarget *eventTarget,
+      EventTarget *eventTarget,
       const std::string &type,
       ReactEventPriority priority,
       const EventPayload &payload) const;

package/ReactCommon/react/renderer/uimanager/UIManagerDelegate.h

@@ -84,6 +84,16 @@ class UIManagerDelegate {
    */
   virtual void uiManagerDidStartSurface(const ShadowTree &shadowTree) = 0;
 
+  /*
+   * Called after a new React revision of the shadow tree is committed.
+   */
+  virtual void uiManagerDidFinishReactCommit(const ShadowTree &shadowTree) = 0;
+
+  /*
+   * Called after a React revision of the shadow tree is promoted to be merged.
+   */
+  virtual void uiManagerDidPromoteReactRevision(const ShadowTree &shadowTree) = 0;
+
   using OnSurfaceStartCallback = std::function<void(const ShadowTree &shadowTree)>;
   virtual void uiManagerShouldSetOnSurfaceStartCallback(OnSurfaceStartCallback &&callback) = 0;
 

package/ReactCommon/react/renderer/uimanager/consistency/LazyShadowTreeRevisionConsistencyManager.cpp

@@ -15,22 +15,34 @@ LazyShadowTreeRevisionConsistencyManager::
         ShadowTreeRegistry& shadowTreeRegistry)
     : shadowTreeRegistry_(shadowTreeRegistry) {}
 
-void LazyShadowTreeRevisionConsistencyManager::updateCurrentRevision(
-    SurfaceId surfaceId,
-    RootShadowNode::Shared rootShadowNode) {
+std::shared_ptr<const RootShadowNode>
+LazyShadowTreeRevisionConsistencyManager::updateCurrentRevision(
+    SurfaceId surfaceId) {
+  // This method is only going to be called from JS, so we don't need to protect
+  // the access to the shadow tree registry as well.
+  // If this was multi-threaded, we would need to protect it to avoid capturing
+  // root shadow nodes concurrently.
+  RootShadowNode::Shared rootShadowNode;
+  shadowTreeRegistry_.visit(surfaceId, [&](const ShadowTree& shadowTree) {
+    auto reactRevision = shadowTree.getCurrentReactRevision();
+    rootShadowNode =
+        reactRevision.value_or(shadowTree.getCurrentRevision()).rootShadowNode;
+  });
+
   std::unique_lock lock(capturedRootShadowNodesForConsistencyMutex_);
 
   // We don't need to store the revision if we haven't locked.
   // We can resolve lazily when requested.
   if (lockCount > 0) {
-    capturedRootShadowNodesForConsistency_[surfaceId] =
-        std::move(rootShadowNode);
+    capturedRootShadowNodesForConsistency_[surfaceId] = rootShadowNode;
   }
+
+  return rootShadowNode;
 }
 
 #pragma mark - ShadowTreeRevisionProvider
 
-RootShadowNode::Shared
+std::shared_ptr<const RootShadowNode>
 LazyShadowTreeRevisionConsistencyManager::getCurrentRevision(
     SurfaceId surfaceId) {
   {
@@ -43,23 +55,7 @@ LazyShadowTreeRevisionConsistencyManager::getCurrentRevision(
     }
   }
 
-  // This method is only going to be called from JS, so we don't need to protect
-  // the access to the shadow tree registry as well.
-  // If this was multi-threaded, we would need to protect it to avoid capturing
-  // root shadow nodes concurrently.
-  RootShadowNode::Shared rootShadowNode;
-  shadowTreeRegistry_.visit(surfaceId, [&](const ShadowTree& shadowTree) {
-    rootShadowNode = shadowTree.getCurrentRevision().rootShadowNode;
-  });
-
-  {
-    std::unique_lock lock(capturedRootShadowNodesForConsistencyMutex_);
-    if (lockCount > 0) {
-      capturedRootShadowNodesForConsistency_[surfaceId] = rootShadowNode;
-    }
-  }
-
-  return rootShadowNode;
+  return updateCurrentRevision(surfaceId);
 }
 
 #pragma mark - ConsistentShadowTreeRevisionProvider

package/ReactCommon/react/renderer/uimanager/consistency/LazyShadowTreeRevisionConsistencyManager.h

@@ -13,7 +13,6 @@
 #include <react/renderer/uimanager/consistency/ShadowTreeRevisionProvider.h>
 #include <cstdint>
 #include <memory>
-#include <shared_mutex>
 
 namespace facebook::react {
 
@@ -28,11 +27,11 @@ class LazyShadowTreeRevisionConsistencyManager : public ShadowTreeRevisionConsis
  public:
   explicit LazyShadowTreeRevisionConsistencyManager(ShadowTreeRegistry &shadowTreeRegistry);
 
-  void updateCurrentRevision(SurfaceId surfaceId, RootShadowNode::Shared rootShadowNode);
+  std::shared_ptr<const RootShadowNode> updateCurrentRevision(SurfaceId surfaceId);
 
 #pragma mark - ShadowTreeRevisionProvider
 
-  RootShadowNode::Shared getCurrentRevision(SurfaceId surfaceId) override;
+  std::shared_ptr<const RootShadowNode> getCurrentRevision(SurfaceId surfaceId) override;
 
 #pragma mark - ShadowTreeRevisionConsistencyManager