@react-native-ohos/react-native-reanimated 3.18.2-rc.2 → 4.0.0-rc.1

package/harmony/reanimated/src/main/cpp/Common/cpp/reanimated/Fabric/ReanimatedCommitHook.cpp

@@ -1,101 +1,113 @@
-#ifdef RCT_NEW_ARCH_ENABLED
-
-#include <reanimated/Fabric/ReanimatedCommitHook.h>
-#include <reanimated/Fabric/ReanimatedCommitShadowNode.h>
-#include <reanimated/Fabric/ShadowTreeCloner.h>
-
-#include <react/renderer/core/ComponentDescriptor.h>
-
-#include <unordered_map>
-#include <vector>
-
-using namespace facebook::react;
-
-namespace reanimated {
-
-ReanimatedCommitHook::ReanimatedCommitHook(
-    const std::shared_ptr<PropsRegistry> &propsRegistry,
-    const std::shared_ptr<UIManager> &uiManager,
-    const std::shared_ptr<LayoutAnimationsProxy> &layoutAnimationsProxy)
-    : propsRegistry_(propsRegistry),
-      uiManager_(uiManager),
-      layoutAnimationsProxy_(layoutAnimationsProxy) {
-  uiManager_->registerCommitHook(*this);
-}
-
-ReanimatedCommitHook::~ReanimatedCommitHook() noexcept {
-  uiManager_->unregisterCommitHook(*this);
-}
-
-void ReanimatedCommitHook::maybeInitializeLayoutAnimations(
-    SurfaceId surfaceId) {
-  auto lock = std::unique_lock<std::mutex>(mutex_);
-  if (surfaceId > currentMaxSurfaceId_) {
-    // when a new surfaceId is observed we call setMountingOverrideDelegate
-    // for all yet unseen surfaces
-    uiManager_->getShadowTreeRegistry().enumerate(
-        [strongThis = shared_from_this()](
-            const ShadowTree &shadowTree, bool &stop) {
-          // Executed synchronously.
-          if (shadowTree.getSurfaceId() <= strongThis->currentMaxSurfaceId_) {
-            // the set function actually adds our delegate to a list, so we
-            // shouldn't invoke it twice for the same surface
-            return;
-          }
-          shadowTree.getMountingCoordinator()->setMountingOverrideDelegate(
-              strongThis->layoutAnimationsProxy_);
-        });
-    currentMaxSurfaceId_ = surfaceId;
-  }
-}
-
-RootShadowNode::Unshared ReanimatedCommitHook::shadowTreeWillCommit(
-    ShadowTree const &,
-    RootShadowNode::Shared const &,
-    RootShadowNode::Unshared const &newRootShadowNode) noexcept {
-  maybeInitializeLayoutAnimations(newRootShadowNode->getSurfaceId());
-
-  auto reaShadowNode =
-      std::reinterpret_pointer_cast<ReanimatedCommitShadowNode>(
-          newRootShadowNode);
-
-  if (reaShadowNode->hasReanimatedCommitTrait()) {
-    // ShadowTree commited by Reanimated, no need to apply updates from
-    // PropsRegistry
-    reaShadowNode->unsetReanimatedCommitTrait();
-    reaShadowNode->setReanimatedMountTrait();
-    return newRootShadowNode;
-  }
-
-  // ShadowTree not commited by Reanimated, apply updates from PropsRegistry
-  reaShadowNode->unsetReanimatedMountTrait();
-  RootShadowNode::Unshared rootNode = newRootShadowNode;
-  PropsMap propsMap;
-
-  {
-    auto lock = propsRegistry_->createLock();
-
-    propsRegistry_->for_each(
-        [&](const ShadowNodeFamily &family, const folly::dynamic &props) {
-          propsMap[&family].emplace_back(props);
-        });
-
-    rootNode = cloneShadowTreeWithNewProps(*rootNode, propsMap);
-
-    // If the commit comes from React Native then pause commits from
-    // Reanimated since the ShadowTree to be committed by Reanimated may not
-    // include the new changes from React Native yet and all changes of animated
-    // props will be applied in ReanimatedCommitHook by iterating over
-    // PropsRegistry.
-    // This is very important, since if we didn't pause Reanimated commits,
-    // it could lead to RN commits being delayed until the animation is finished
-    // (very bad).
-    propsRegistry_->pauseReanimatedCommits();
-  }
-
-  return rootNode;
-}
-
-} // namespace reanimated
-
-#endif // RCT_NEW_ARCH_ENABLED
+#include <reanimated/Fabric/ReanimatedCommitHook.h>
+#include <reanimated/Fabric/ReanimatedCommitShadowNode.h>
+#include <reanimated/Fabric/ShadowTreeCloner.h>
+#include <reanimated/Tools/FeatureFlags.h>
+#include <reanimated/Tools/ReanimatedSystraceSection.h>
+
+#include <react/renderer/core/ComponentDescriptor.h>
+
+#include <memory>
+#include <unordered_map>
+#include <vector>
+
+using namespace facebook::react;
+
+namespace reanimated {
+
+ReanimatedCommitHook::ReanimatedCommitHook(
+    const std::shared_ptr<UIManager> &uiManager,
+    const std::shared_ptr<UpdatesRegistryManager> &updatesRegistryManager,
+    const std::shared_ptr<LayoutAnimationsProxyCommon> &layoutAnimationsProxy)
+    : uiManager_(uiManager),
+      updatesRegistryManager_(updatesRegistryManager),
+      layoutAnimationsProxy_(layoutAnimationsProxy) {
+  uiManager_->registerCommitHook(*this);
+}
+
+ReanimatedCommitHook::~ReanimatedCommitHook() noexcept {
+  uiManager_->unregisterCommitHook(*this);
+}
+
+void ReanimatedCommitHook::maybeInitializeLayoutAnimations(SurfaceId surfaceId) {
+  auto lock = std::unique_lock<std::mutex>(mutex_);
+  if (surfaceId > currentMaxSurfaceId_) {
+    // when a new surfaceId is observed we call setMountingOverrideDelegate
+    // for all yet unseen surfaces
+    uiManager_->getShadowTreeRegistry().enumerate([strongThis = shared_from_this()](
+                                                      const ShadowTree &shadowTree, bool &stop) {
+      // Executed synchronously.
+      if (shadowTree.getSurfaceId() <= strongThis->currentMaxSurfaceId_) {
+        // the set function actually adds our delegate to a list, so we
+        // shouldn't invoke it twice for the same surface
+        return;
+      }
+      // TODO: We should consider registering a new instance of proxy for each surface.
+      // The current approach will encounter problems on platforms where it is more common to have multiple surfaces.
+      strongThis->layoutAnimationsProxy_->startSurface(shadowTree.getSurfaceId());
+      shadowTree.getMountingCoordinator()->setMountingOverrideDelegate(strongThis->layoutAnimationsProxy_);
+    });
+    currentMaxSurfaceId_ = surfaceId;
+  }
+}
+
+RootShadowNode::Unshared ReanimatedCommitHook::shadowTreeWillCommit(
+    ShadowTree const &,
+    RootShadowNode::Shared const &,
+    RootShadowNode::Unshared const &newRootShadowNode
+#if REACT_NATIVE_MINOR_VERSION >= 80
+    ,
+    const ShadowTreeCommitOptions &commitOptions
+#endif
+    ) noexcept {
+  ReanimatedSystraceSection s("ReanimatedCommitHook::shadowTreeWillCommit");
+
+  maybeInitializeLayoutAnimations(newRootShadowNode->getSurfaceId());
+
+  auto reaShadowNode = std::reinterpret_pointer_cast<ReanimatedCommitShadowNode>(newRootShadowNode);
+
+  if (reaShadowNode->hasReanimatedCommitTrait()) {
+    // ShadowTree commited by Reanimated, no need to apply updates from
+    // the updates registry manager
+    reaShadowNode->unsetReanimatedCommitTrait();
+    reaShadowNode->setReanimatedMountTrait();
+    return newRootShadowNode;
+  }
+
+#if REACT_NATIVE_MINOR_VERSION >= 80
+  if constexpr (StaticFeatureFlags::getFlag("USE_COMMIT_HOOK_ONLY_FOR_REACT_COMMITS")) {
+    // State updates are based on the currently committed ShadowTree,
+    // which means that all animation changes are already included.
+    // Therefore, there's no need to reapply styles from the props map.
+    if (commitOptions.source != ShadowTreeCommitSource::React) {
+      return newRootShadowNode;
+    }
+  }
+#endif
+
+  // ShadowTree not commited by Reanimated, apply updates from the updates
+  // registry manager
+  reaShadowNode->unsetReanimatedMountTrait();
+  RootShadowNode::Unshared rootNode = newRootShadowNode;
+
+  {
+    auto lock = updatesRegistryManager_->lock();
+
+    PropsMap propsMap = updatesRegistryManager_->collectProps();
+    updatesRegistryManager_->cancelCommitAfterPause();
+
+    rootNode = cloneShadowTreeWithNewProps(*rootNode, propsMap);
+    // If the commit comes from React Native then pause commits from
+    // Reanimated since the ShadowTree to be committed by Reanimated may not
+    // include the new changes from React Native yet and all changes of animated
+    // props will be applied in ReanimatedCommitHook by UpdatesRegistryManager
+    // This is very important, since if we didn't pause Reanimated commits,
+    // it could lead to RN commits being delayed until the animation is finished
+    // (very bad). We don't pause Reanimated commits for state updates coming
+    // from React Native as this would break sticky header animations.
+    updatesRegistryManager_->pauseReanimatedCommits();
+  }
+
+  return rootNode;
+}
+
+} // namespace reanimated

package/harmony/reanimated/src/main/cpp/Common/cpp/reanimated/Fabric/ReanimatedCommitHook.h

@@ -1,51 +1,49 @@
-#pragma once
-#ifdef RCT_NEW_ARCH_ENABLED
-
-#include <reanimated/Fabric/PropsRegistry.h>
-#include <reanimated/LayoutAnimations/LayoutAnimationsProxy.h>
-
-#include <react/renderer/uimanager/UIManagerCommitHook.h>
-
-#include <memory>
-
-using namespace facebook::react;
-
-namespace reanimated {
-
-class ReanimatedCommitHook
-    : public UIManagerCommitHook,
-      public std::enable_shared_from_this<ReanimatedCommitHook> {
- public:
-  ReanimatedCommitHook(
-      const std::shared_ptr<PropsRegistry> &propsRegistry,
-      const std::shared_ptr<UIManager> &uiManager,
-      const std::shared_ptr<LayoutAnimationsProxy> &layoutAnimationsProxy);
-
-  ~ReanimatedCommitHook() noexcept override;
-
-  void commitHookWasRegistered(UIManager const &) noexcept override {}
-
-  void commitHookWasUnregistered(UIManager const &) noexcept override {}
-
-  void maybeInitializeLayoutAnimations(SurfaceId surfaceId);
-
-  RootShadowNode::Unshared shadowTreeWillCommit(
-      ShadowTree const &shadowTree,
-      RootShadowNode::Shared const &oldRootShadowNode,
-      RootShadowNode::Unshared const &newRootShadowNode) noexcept override;
-
- private:
-  std::shared_ptr<PropsRegistry> propsRegistry_;
-
-  std::shared_ptr<UIManager> uiManager_;
-
-  std::shared_ptr<LayoutAnimationsProxy> layoutAnimationsProxy_;
-
-  SurfaceId currentMaxSurfaceId_ = -1;
-
-  std::mutex mutex_; // Protects `currentMaxSurfaceId_`.
-};
-
-} // namespace reanimated
-
-#endif // RCT_NEW_ARCH_ENABLED
+#pragma once
+
+#include <reanimated/Fabric/updates/UpdatesRegistryManager.h>
+#include <reanimated/LayoutAnimations/LayoutAnimationsProxyCommon.h>
+
+#include <react/renderer/uimanager/UIManagerCommitHook.h>
+
+#include <memory>
+
+using namespace facebook::react;
+
+namespace reanimated {
+
+class ReanimatedCommitHook : public UIManagerCommitHook, public std::enable_shared_from_this<ReanimatedCommitHook> {
+ public:
+  ReanimatedCommitHook(
+      const std::shared_ptr<UIManager> &uiManager,
+      const std::shared_ptr<UpdatesRegistryManager> &updatesRegistryManager,
+      const std::shared_ptr<LayoutAnimationsProxyCommon> &layoutAnimationsProxy);
+
+  ~ReanimatedCommitHook() noexcept override;
+
+  void commitHookWasRegistered(UIManager const &) noexcept override {}
+
+  void commitHookWasUnregistered(UIManager const &) noexcept override {}
+
+  void maybeInitializeLayoutAnimations(SurfaceId surfaceId);
+
+  RootShadowNode::Unshared shadowTreeWillCommit(
+      ShadowTree const &shadowTree,
+      RootShadowNode::Shared const &oldRootShadowNode,
+      RootShadowNode::Unshared const &newRootShadowNode
+#if REACT_NATIVE_MINOR_VERSION >= 80
+      ,
+      const ShadowTreeCommitOptions &commitOptions
+#endif
+      ) noexcept override;
+
+ private:
+  std::shared_ptr<UIManager> uiManager_;
+  std::shared_ptr<UpdatesRegistryManager> updatesRegistryManager_;
+  std::shared_ptr<LayoutAnimationsProxyCommon> layoutAnimationsProxy_;
+
+  SurfaceId currentMaxSurfaceId_ = -1;
+
+  std::mutex mutex_; // Protects `currentMaxSurfaceId_`.
+};
+
+} // namespace reanimated

package/harmony/reanimated/src/main/cpp/Common/cpp/reanimated/Fabric/ReanimatedCommitShadowNode.h

@@ -1,49 +1,46 @@
-#pragma once
-#ifdef RCT_NEW_ARCH_ENABLED
-
-#include <react/renderer/core/ShadowNode.h>
-
-using namespace facebook::react;
-
-namespace reanimated {
-
-// We use this trait to mark that a commit was created by Reanimated.
-// Traits are copied when nodes are cloned, so this information
-// won't be lost unless someone explicitly overrides it.
-// We need this information to skip unnecessary updates in
-// the commit hook.
-// Currently RN traits go up to 10, so hopefully
-// the arbitrarily chosen numbers 27 and 28 will be safe :)
-
-// We have to use 2 traits, because we want to distinguish reanimated
-// commits both in the commit hook and mount hook. If we only had one trait
-// and didn't remove it in the commit hook, then any node that would clone
-// this node would also have our commit trait, rendering this trait useless.
-constexpr ShadowNodeTraits::Trait ReanimatedCommitTrait{1 << 27};
-constexpr ShadowNodeTraits::Trait ReanimatedMountTrait{1 << 28};
-
-class ReanimatedCommitShadowNode : public ShadowNode {
- public:
-  inline void setReanimatedCommitTrait() {
-    traits_.set(ReanimatedCommitTrait);
-  }
-  inline void unsetReanimatedCommitTrait() {
-    traits_.unset(ReanimatedCommitTrait);
-  }
-  inline bool hasReanimatedCommitTrait() {
-    return traits_.check(ReanimatedCommitTrait);
-  }
-  inline void setReanimatedMountTrait() {
-    traits_.set(ReanimatedMountTrait);
-  }
-  inline void unsetReanimatedMountTrait() {
-    traits_.unset(ReanimatedMountTrait);
-  }
-  inline bool hasReanimatedMountTrait() {
-    return traits_.check(ReanimatedMountTrait);
-  }
-};
-
-} // namespace reanimated
-
-#endif // RCT_NEW_ARCH_ENABLED
+#pragma once
+
+#include <react/renderer/core/ShadowNode.h>
+
+using namespace facebook::react;
+
+namespace reanimated {
+
+// We use this trait to mark that a commit was created by Reanimated.
+// Traits are copied when nodes are cloned, so this information
+// won't be lost unless someone explicitly overrides it.
+// We need this information to skip unnecessary updates in
+// the commit hook.
+// Currently RN traits go up to 10, so hopefully
+// the arbitrarily chosen numbers 27 and 28 will be safe :)
+
+// We have to use 2 traits, because we want to distinguish reanimated
+// commits both in the commit hook and mount hook. If we only had one trait
+// and didn't remove it in the commit hook, then any node that would clone
+// this node would also have our commit trait, rendering this trait useless.
+constexpr ShadowNodeTraits::Trait ReanimatedCommitTrait{1 << 27};
+constexpr ShadowNodeTraits::Trait ReanimatedMountTrait{1 << 28};
+
+class ReanimatedCommitShadowNode : public ShadowNode {
+ public:
+  inline void setReanimatedCommitTrait() {
+    traits_.set(ReanimatedCommitTrait);
+  }
+  inline void unsetReanimatedCommitTrait() {
+    traits_.unset(ReanimatedCommitTrait);
+  }
+  inline bool hasReanimatedCommitTrait() {
+    return traits_.check(ReanimatedCommitTrait);
+  }
+  inline void setReanimatedMountTrait() {
+    traits_.set(ReanimatedMountTrait);
+  }
+  inline void unsetReanimatedMountTrait() {
+    traits_.unset(ReanimatedMountTrait);
+  }
+  inline bool hasReanimatedMountTrait() {
+    return traits_.check(ReanimatedMountTrait);
+  }
+};
+
+} // namespace reanimated

package/harmony/reanimated/src/main/cpp/Common/cpp/reanimated/Fabric/ReanimatedMountHook.cpp

@@ -1,96 +1,56 @@
-#ifdef RCT_NEW_ARCH_ENABLED
-
-#include <glog/logging.h>
-#include <reanimated/Fabric/ReanimatedCommitShadowNode.h>
-#include <reanimated/Fabric/ReanimatedMountHook.h>
-
-namespace reanimated {
-
-ReanimatedMountHook::ReanimatedMountHook(
-    const std::shared_ptr<PropsRegistry> &propsRegistry,
-    const std::shared_ptr<UIManager> &uiManager)
-    : propsRegistry_(propsRegistry), uiManager_(uiManager) {
-  uiManager_->registerMountHook(*this);
-}
-
-ReanimatedMountHook::~ReanimatedMountHook() noexcept {
-  uiManager_->unregisterMountHook(*this);
-}
-
-void ReanimatedMountHook::shadowTreeDidMount(
-    const RootShadowNode::Shared &rootShadowNode,
-    double) noexcept {
-  auto reaShadowNode =
-      std::reinterpret_pointer_cast<ReanimatedCommitShadowNode>(
-          std::const_pointer_cast<RootShadowNode>(rootShadowNode));
-
-  if (reaShadowNode->hasReanimatedMountTrait()) {
-    // We mark reanimated commits with ReanimatedMountTrait. We don't want other
-    // shadow nodes to use this trait, but since this rootShadowNode is Shared,
-    // we don't have that guarantee. That's why we also unset this trait in the
-    // commit hook. We remove it here mainly for the sake of cleanliness.
-    reaShadowNode->unsetReanimatedMountTrait();
-    return;
-  }
-
-  {
-    auto lock = propsRegistry_->createLock();
-    propsRegistry_->handleNodeRemovals(*rootShadowNode);
-
-    // When commit from React Native has finished, we reset the skip commit flag
-    // in order to allow Reanimated to commit its tree
-    propsRegistry_->unpauseReanimatedCommits();
-    if (!propsRegistry_->shouldCommitAfterPause()) {
-      return;
-    }
-  }
-
-  try {
-    const auto &shadowTreeRegistry = uiManager_->getShadowTreeRegistry();
-    shadowTreeRegistry.visit(
-        rootShadowNode->getSurfaceId(), [=](ShadowTree const &shadowTree) {
-        shadowTree.commit(
-            [=](RootShadowNode const &oldRootShadowNode)
-                -> RootShadowNode::Unshared {
-              PropsMap propsMap;
-
-              RootShadowNode::Unshared rootNode =
-                  std::static_pointer_cast<RootShadowNode>(
-                      oldRootShadowNode.ShadowNode::clone({}));
-
-              if (rootNode) {
-                auto lock = propsRegistry_->createLock();
-
-                if (!propsRegistry_->isEmpty()) {
-                  propsRegistry_->for_each([&](const ShadowNodeFamily &family,
-                                               const folly::dynamic &props) {
-                    propsMap[&family].emplace_back(props);
-                  });
-
-                  rootNode = cloneShadowTreeWithNewProps(oldRootShadowNode, propsMap);
-                }
-              }
-
-              if (rootNode) {
-                auto reaShadowNode =
-                    std::reinterpret_pointer_cast<ReanimatedCommitShadowNode>(
-                        rootNode);
-                reaShadowNode->setReanimatedCommitTrait();
-              }
-
-              return rootNode;
-            },
-            {/* .enableStateReconciliation = */
-             false,
-             /* .mountSynchronously = */ true});
-      });
-  } catch (const std::exception &e) {
-    LOG(ERROR) << "ReanimatedMountHook::shadowTreeDidMount error: " << e.what();
-  } catch (...) {
-    LOG(ERROR) << "ReanimatedMountHook::shadowTreeDidMount unknown error";
-  }
-}
-
-} // namespace reanimated
-
-#endif // RCT_NEW_ARCH_ENABLED
+#include <reanimated/Fabric/ReanimatedCommitShadowNode.h>
+#include <reanimated/Fabric/ReanimatedMountHook.h>
+#include <reanimated/Tools/ReanimatedSystraceSection.h>
+
+#include <memory>
+
+namespace reanimated {
+
+ReanimatedMountHook::ReanimatedMountHook(
+    const std::shared_ptr<UIManager> &uiManager,
+    const std::shared_ptr<UpdatesRegistryManager> &updatesRegistryManager,
+    const std::function<void()> &requestFlush)
+    : uiManager_(uiManager), updatesRegistryManager_(updatesRegistryManager), requestFlush_(requestFlush) {
+  uiManager_->registerMountHook(*this);
+}
+
+ReanimatedMountHook::~ReanimatedMountHook() noexcept {
+  uiManager_->unregisterMountHook(*this);
+}
+
+void ReanimatedMountHook::shadowTreeDidMount(
+    const RootShadowNode::Shared &rootShadowNode,
+#if REACT_NATIVE_MINOR_VERSION >= 81
+    HighResTimeStamp
+#else
+    double
+#endif // REACT_NATIVE_MINOR_VERSION >= 81
+    ) noexcept {
+  ReanimatedSystraceSection s("ReanimatedMountHook::shadowTreeDidMount");
+
+  auto reaShadowNode = std::reinterpret_pointer_cast<ReanimatedCommitShadowNode>(
+      std::const_pointer_cast<RootShadowNode>(rootShadowNode));
+
+  if (reaShadowNode->hasReanimatedMountTrait()) {
+    // We mark reanimated commits with ReanimatedMountTrait. We don't want other
+    // shadow nodes to use this trait, but since this rootShadowNode is Shared,
+    // we don't have that guarantee. That's why we also unset this trait in the
+    // commit hook. We remove it here mainly for the sake of cleanliness.
+    reaShadowNode->unsetReanimatedMountTrait();
+    return;
+  }
+
+  {
+    auto lock = updatesRegistryManager_->lock();
+    updatesRegistryManager_->handleNodeRemovals(*rootShadowNode);
+
+    // When commit from React Native has finished, we reset the skip commit flag
+    // in order to allow Reanimated to commit its tree
+    updatesRegistryManager_->unpauseReanimatedCommits();
+    if (updatesRegistryManager_->shouldCommitAfterPause()) {
+      requestFlush_();
+    }
+  }
+}
+
+} // namespace reanimated

package/harmony/reanimated/src/main/cpp/Common/cpp/reanimated/Fabric/ReanimatedMountHook.h

@@ -1,33 +1,37 @@
-#pragma once
-#ifdef RCT_NEW_ARCH_ENABLED
-
-#include <reanimated/Fabric/PropsRegistry.h>
-#include <reanimated/Fabric/ShadowTreeCloner.h>
-
-#include <react/renderer/uimanager/UIManagerMountHook.h>
-
-#include <memory>
-
-namespace reanimated {
-
-using namespace facebook::react;
-
-class ReanimatedMountHook : public UIManagerMountHook {
- public:
-  ReanimatedMountHook(
-      const std::shared_ptr<PropsRegistry> &propsRegistry,
-      const std::shared_ptr<UIManager> &uiManager);
-  ~ReanimatedMountHook() noexcept override;
-
-  void shadowTreeDidMount(
-      RootShadowNode::Shared const &rootShadowNode,
-      double mountTime) noexcept override;
-
- private:
-  const std::shared_ptr<PropsRegistry> propsRegistry_;
-  const std::shared_ptr<UIManager> uiManager_;
-};
-
-} // namespace reanimated
-
-#endif // RCT_NEW_ARCH_ENABLED
+#pragma once
+
+#include <reanimated/Fabric/ShadowTreeCloner.h>
+#include <reanimated/Fabric/updates/UpdatesRegistryManager.h>
+
+#include <react/renderer/uimanager/UIManagerMountHook.h>
+
+#include <memory>
+
+namespace reanimated {
+
+using namespace facebook::react;
+
+class ReanimatedMountHook : public UIManagerMountHook {
+ public:
+  ReanimatedMountHook(
+      const std::shared_ptr<UIManager> &uiManager,
+      const std::shared_ptr<UpdatesRegistryManager> &updatesRegistryManager,
+      const std::function<void()> &requestFlush);
+  ~ReanimatedMountHook() noexcept override;
+
+  void shadowTreeDidMount(
+      RootShadowNode::Shared const &rootShadowNode,
+#if REACT_NATIVE_MINOR_VERSION >= 81
+      HighResTimeStamp mountTime
+#else
+      double mountTime
+#endif // REACT_NATIVE_MINOR_VERSION >= 81
+      ) noexcept override;
+
+ private:
+  const std::shared_ptr<UIManager> uiManager_;
+  const std::shared_ptr<UpdatesRegistryManager> updatesRegistryManager_;
+  const std::function<void()> requestFlush_;
+};
+
+} // namespace reanimated