Add support for React Native 0.71

Common/cpp/Fabric/FabricUtils.cpp

@@ -7,6 +7,7 @@
 
 #include "FabricUtils.h"
 
+#include <react/renderer/debug/SystraceSection.h>
 #include <react/renderer/uimanager/UIManagerBinding.h>
 
 using namespace facebook::react;
@@ -22,110 +23,10 @@ RuntimeExecutor getRuntimeExecutorFromBinding(Binding *binding) {
 }
 #endif
 
-inline static const UIManagerPublic *getUIManagerPublic(
-    const UIManager *uiManager) {
-  return reinterpret_cast<const UIManagerPublic *>(uiManager);
-}
-
 std::shared_ptr<const ContextContainer> getContextContainerFromUIManager(
     const UIManager *uiManager) {
-  return getUIManagerPublic(uiManager)->contextContainer_;
-}
-
-inline static UIManagerDelegate *getDelegateFromUIManager(
-    const UIManager *uiManager) {
-  return getUIManagerPublic(uiManager)->delegate_;
-}
-
-void UIManager_dispatchCommand(
-    const std::shared_ptr<UIManager> &uiManager,
-    const ShadowNode::Shared &shadowNode,
-    std::string const &commandName,
-    folly::dynamic const &args) {
-  auto delegate_ = getDelegateFromUIManager(&*uiManager);
-
-  // copied from UIManager.cpp
-  if (delegate_) {
-    delegate_->uiManagerDidDispatchCommand(shadowNode, commandName, args);
-  }
-}
-
-LayoutMetrics UIManager_getRelativeLayoutMetrics(
-    const std::shared_ptr<UIManager> &uiManager,
-    ShadowNode const &shadowNode,
-    ShadowNode const *ancestorShadowNode,
-    LayoutableShadowNode::LayoutInspectingPolicy policy) {
-  // based on implementation from UIManager.cpp
-  const auto &shadowTreeRegistry = uiManager->getShadowTreeRegistry();
-
-  // We might store here an owning pointer to `ancestorShadowNode` to ensure
-  // that the node is not deallocated during method execution lifetime.
-  auto owningAncestorShadowNode = ShadowNode::Shared{};
-
-  if (!ancestorShadowNode) {
-    shadowTreeRegistry.visit(
-        shadowNode.getSurfaceId(), [&](ShadowTree const &shadowTree) {
-          owningAncestorShadowNode =
-              shadowTree.getCurrentRevision().rootShadowNode;
-          ancestorShadowNode = owningAncestorShadowNode.get();
-        });
-  } else {
-    // It is possible for JavaScript (or other callers) to have a reference
-    // to a previous version of ShadowNodes, but we enforce that
-    // metrics are only calculated on most recently committed versions.
-    owningAncestorShadowNode =
-        uiManager->getNewestCloneOfShadowNode(*ancestorShadowNode);
-    ancestorShadowNode = owningAncestorShadowNode.get();
-  }
-
-  auto layoutableAncestorShadowNode =
-      traitCast<LayoutableShadowNode const *>(ancestorShadowNode);
-
-  if (!layoutableAncestorShadowNode) {
-    return EmptyLayoutMetrics;
-  }
-
-  return LayoutableShadowNode::computeRelativeLayoutMetrics(
-      shadowNode.getFamily(), *layoutableAncestorShadowNode, policy);
-}
-
-ShadowNode::Shared UIManager_cloneNode(
-    const UIManager *uiManager,
-    const ShadowNode::Shared &shadowNode,
-    const ShadowNode::SharedListOfShared &children,
-    const RawProps *rawProps) {
-  auto delegate_ = getDelegateFromUIManager(uiManager);
-  auto contextContainer_ = getContextContainerFromUIManager(uiManager);
-
-  // copied from UIManager.cpp
-  PropsParserContext propsParserContext{
-      shadowNode->getFamily().getSurfaceId(), *contextContainer_.get()};
-
-  auto &componentDescriptor = shadowNode->getComponentDescriptor();
-  auto clonedShadowNode = componentDescriptor.cloneShadowNode(
-      *shadowNode,
-      {
-          /* .props = */
-          rawProps ? componentDescriptor.cloneProps(
-                         propsParserContext, shadowNode->getProps(), *rawProps)
-                   : ShadowNodeFragment::propsPlaceholder(),
-          /* .children = */ children,
-      });
-
-  if (delegate_) {
-    delegate_->uiManagerDidCloneShadowNode(
-        *shadowNode.get(), *clonedShadowNode);
-  }
-
-  return clonedShadowNode;
-}
-
-void UIManager_appendChild(
-    const ShadowNode::Shared &parentShadowNode,
-    const ShadowNode::Shared &childShadowNode) {
-  // copied from UIManager.cpp
-  auto &componentDescriptor = parentShadowNode->getComponentDescriptor();
-  componentDescriptor.appendChild(parentShadowNode, childShadowNode);
+  return reinterpret_cast<const UIManagerPublic *>(uiManager)
+      ->contextContainer_;
 }
 
 } // namespace reanimated

Common/cpp/Fabric/FabricUtils.h

@@ -2,15 +2,16 @@
 #ifdef RCT_NEW_ARCH_ENABLED
 
 #ifdef ANDROID
-#include <Binding.h>
 #include <fbjni/fbjni.h>
+#include <react/fabric/Binding.h>
 #endif
 #include <react/renderer/uimanager/UIManager.h>
 
 #include <memory>
 #include <string>
 
-using namespace facebook::react;
+using namespace facebook;
+using namespace react;
 
 namespace reanimated {
 
@@ -52,28 +53,6 @@ RuntimeExecutor getRuntimeExecutorFromBinding(Binding *binding);
 std::shared_ptr<const ContextContainer> getContextContainerFromUIManager(
     const UIManager *uiManager);
 
-void UIManager_dispatchCommand(
-    const std::shared_ptr<UIManager> &uiManager,
-    const ShadowNode::Shared &shadowNode,
-    std::string const &commandName,
-    folly::dynamic const &args);
-
-LayoutMetrics UIManager_getRelativeLayoutMetrics(
-    const std::shared_ptr<UIManager> &uiManager,
-    ShadowNode const &shadowNode,
-    ShadowNode const *ancestorShadowNode,
-    LayoutableShadowNode::LayoutInspectingPolicy policy);
-
-ShadowNode::Shared UIManager_cloneNode(
-    const UIManager *uiManager,
-    const ShadowNode::Shared &shadowNode,
-    const ShadowNode::SharedListOfShared &children = nullptr,
-    const RawProps *rawProps = nullptr);
-
-void UIManager_appendChild(
-    const ShadowNode::Shared &parentShadowNode,
-    const ShadowNode::Shared &childShadowNode);
-
 } // namespace reanimated
 
 #endif // RCT_NEW_ARCH_ENABLED

Common/cpp/Fabric/ReanimatedUIManagerBinding.cpp

@@ -4,6 +4,8 @@
 #include "FabricUtils.h"
 #include "NewestShadowNodesRegistry.h"
 
+#include <react/renderer/debug/SystraceSection.h>
+
 #include <utility>
 
 using namespace facebook;
@@ -51,7 +53,7 @@ ReanimatedUIManagerBinding::ReanimatedUIManagerBinding(
     RuntimeExecutor runtimeExecutor,
     std::unique_ptr<EventHandler const> eventHandler,
     std::shared_ptr<NewestShadowNodesRegistry> newestShadowNodesRegistry)
-    : UIManagerBinding(uiManager, runtimeExecutor),
+    : UIManagerBinding(uiManager),
       uiManager_(std::move(uiManager)),
       newestShadowNodesRegistry_(newestShadowNodesRegistry) {
   if (eventHandler != nullptr) {
@@ -62,25 +64,44 @@ ReanimatedUIManagerBinding::ReanimatedUIManagerBinding(
 
 ReanimatedUIManagerBinding::~ReanimatedUIManagerBinding() {}
 
-static inline ShadowNode::Shared cloneNode(
+static inline ShadowNode::Shared cloneNodeUsingNewest(
     UIManager *uiManager,
     NewestShadowNodesRegistry *newestShadowNodesRegistry,
-    const ShadowNode::Shared &shadowNode,
-    const ShadowNode::SharedListOfShared &children = nullptr,
-    const RawProps *rawProps = nullptr) {
+    ShadowNode const &shadowNode,
+    ShadowNode::SharedListOfShared const &children = nullptr,
+    RawProps const *rawProps = nullptr) {
   {
     auto lock = newestShadowNodesRegistry->createLock();
-    auto newest = newestShadowNodesRegistry->get(shadowNode->getTag());
+    auto newest = newestShadowNodesRegistry->get(shadowNode.getTag());
     if (newest != nullptr) {
       // ShadowNode managed by Reanimated, use newest ShadowNode from registry
-      auto clone = UIManager_cloneNode(uiManager, newest, children, rawProps);
+      auto clone = uiManager->cloneNode(*newest, children, rawProps);
       newestShadowNodesRegistry->update(clone);
       return clone;
     }
   } // release lock since we don't need registry anymore
 
   // ShadowNode not managed by Reanimated (yet?)
-  return UIManager_cloneNode(uiManager, shadowNode, children, rawProps);
+  return uiManager->cloneNode(shadowNode, children, rawProps);
+}
+
+static inline void appendChildUsingNewest(
+    UIManager *uiManager,
+    NewestShadowNodesRegistry *newestShadowNodesRegistry,
+    const ShadowNode::Shared &parentShadowNode,
+    const ShadowNode::Shared &childShadowNode) {
+  {
+    auto lock = newestShadowNodesRegistry->createLock();
+    auto newestChildShadowNode =
+        newestShadowNodesRegistry->get(childShadowNode->getTag());
+    if (newestChildShadowNode != nullptr) {
+      uiManager->appendChild(parentShadowNode, newestChildShadowNode);
+      return;
+    }
+  } // release lock since we don't need registry anymore
+
+  // child ShadowNode not managed by Reanimated (yet?)
+  uiManager->appendChild(parentShadowNode, childShadowNode);
 }
 
 jsi::Value ReanimatedUIManagerBinding::get(
@@ -94,6 +115,7 @@ jsi::Value ReanimatedUIManagerBinding::get(
 
   // based on implementation from UIManagerBinding.cpp
   auto methodName = name.utf8(runtime);
+  SystraceSection s("ReanimatedUIManagerBinding::get", "name", methodName);
   UIManager *uiManager = uiManager_.get();
   NewestShadowNodesRegistry *newestShadowNodesRegistry =
       newestShadowNodesRegistry_.get();
@@ -106,15 +128,15 @@ jsi::Value ReanimatedUIManagerBinding::get(
         1,
         [uiManager, newestShadowNodesRegistry](
             jsi::Runtime &runtime,
-            jsi::Value const &thisValue,
+            jsi::Value const & /*thisValue*/,
             jsi::Value const *arguments,
-            size_t count) noexcept -> jsi::Value {
+            size_t /*count*/) noexcept -> jsi::Value {
           return valueFromShadowNode(
               runtime,
-              cloneNode(
+              cloneNodeUsingNewest(
                   uiManager,
                   newestShadowNodesRegistry,
-                  shadowNodeFromValue(runtime, arguments[0])));
+                  *shadowNodeFromValue(runtime, arguments[0])));
         });
   }
 
@@ -126,15 +148,15 @@ jsi::Value ReanimatedUIManagerBinding::get(
         1,
         [uiManager, newestShadowNodesRegistry](
             jsi::Runtime &runtime,
-            jsi::Value const &thisValue,
+            jsi::Value const & /*thisValue*/,
             jsi::Value const *arguments,
-            size_t count) noexcept -> jsi::Value {
+            size_t /*count*/) noexcept -> jsi::Value {
           return valueFromShadowNode(
               runtime,
-              cloneNode(
+              cloneNodeUsingNewest(
                   uiManager,
                   newestShadowNodesRegistry,
-                  shadowNodeFromValue(runtime, arguments[0]),
+                  *shadowNodeFromValue(runtime, arguments[0]),
                   ShadowNode::emptySharedShadowNodeSharedList()));
         });
   }
@@ -147,16 +169,16 @@ jsi::Value ReanimatedUIManagerBinding::get(
         2,
         [uiManager, newestShadowNodesRegistry](
             jsi::Runtime &runtime,
-            jsi::Value const &thisValue,
+            jsi::Value const & /*thisValue*/,
             jsi::Value const *arguments,
-            size_t count) noexcept -> jsi::Value {
+            size_t /*count*/) noexcept -> jsi::Value {
           auto const &rawProps = RawProps(runtime, arguments[1]);
           return valueFromShadowNode(
               runtime,
-              cloneNode(
+              cloneNodeUsingNewest(
                   uiManager,
                   newestShadowNodesRegistry,
-                  shadowNodeFromValue(runtime, arguments[0]),
+                  *shadowNodeFromValue(runtime, arguments[0]),
                   nullptr,
                   &rawProps));
         });
@@ -170,16 +192,16 @@ jsi::Value ReanimatedUIManagerBinding::get(
         2,
         [uiManager, newestShadowNodesRegistry](
             jsi::Runtime &runtime,
-            jsi::Value const &thisValue,
+            jsi::Value const & /*thisValue*/,
             jsi::Value const *arguments,
-            size_t count) noexcept -> jsi::Value {
+            size_t /*count*/) noexcept -> jsi::Value {
           auto const &rawProps = RawProps(runtime, arguments[1]);
           return valueFromShadowNode(
               runtime,
-              cloneNode(
+              cloneNodeUsingNewest(
                   uiManager,
                   newestShadowNodesRegistry,
-                  shadowNodeFromValue(runtime, arguments[0]),
+                  *shadowNodeFromValue(runtime, arguments[0]),
                   ShadowNode::emptySharedShadowNodeSharedList(),
                   &rawProps));
         });
@@ -190,21 +212,16 @@ jsi::Value ReanimatedUIManagerBinding::get(
         runtime,
         name,
         2,
-        [newestShadowNodesRegistry](
+        [uiManager, newestShadowNodesRegistry](
             jsi::Runtime &runtime,
-            jsi::Value const &thisValue,
+            jsi::Value const & /*thisValue*/,
             jsi::Value const *arguments,
-            size_t count) noexcept -> jsi::Value {
-          auto parent = shadowNodeFromValue(runtime, arguments[0]);
-          auto child = shadowNodeFromValue(runtime, arguments[1]);
-          {
-            auto lock = newestShadowNodesRegistry->createLock();
-            auto newest = newestShadowNodesRegistry->get(child->getTag());
-            if (newest != nullptr) {
-              child = newest;
-            }
-          }
-          UIManager_appendChild(parent, child);
+            size_t /*count*/) noexcept -> jsi::Value {
+          appendChildUsingNewest(
+              uiManager,
+              newestShadowNodesRegistry,
+              shadowNodeFromValue(runtime, arguments[0]),
+              shadowNodeFromValue(runtime, arguments[1]));
           return jsi::Value::undefined();
         });
   }

Common/cpp/NativeModules/NativeReanimatedModule.cpp

@@ -597,9 +597,7 @@ void NativeReanimatedModule::dispatchCommand(
   ShadowNode::Shared shadowNode = shadowNodeFromValue(rt, shadowNodeValue);
   std::string commandName = stringFromValue(rt, commandNameValue);
   folly::dynamic args = commandArgsFromValue(rt, argsValue);
-
-  // TODO: use uiManager_->dispatchCommand once it's public
-  UIManager_dispatchCommand(uiManager_, shadowNode, commandName, args);
+  uiManager_->dispatchCommand(shadowNode, commandName, args);
 }
 
 jsi::Value NativeReanimatedModule::measure(
@@ -608,11 +606,8 @@ jsi::Value NativeReanimatedModule::measure(
   // based on implementation from UIManagerBinding.cpp
 
   auto shadowNode = shadowNodeFromValue(rt, shadowNodeValue);
-  // TODO: use uiManager_->getRelativeLayoutMetrics once it's public
-  // auto layoutMetrics = uiManager_->getRelativeLayoutMetrics(
-  //     *shadowNode, nullptr, {/* .includeTransform = */ true});
-  auto layoutMetrics = UIManager_getRelativeLayoutMetrics(
-      uiManager_, *shadowNode, nullptr, {/* .includeTransform = */ true});
+  auto layoutMetrics = uiManager_->getRelativeLayoutMetrics(
+      *shadowNode, nullptr, {/* .includeTransform = */ true});
 
   if (layoutMetrics == EmptyLayoutMetrics) {
     // Originally, in this case React Native returns `{0, 0, 0, 0, 0, 0}`, most
@@ -626,7 +621,8 @@ jsi::Value NativeReanimatedModule::measure(
 
   auto layoutableShadowNode =
       traitCast<LayoutableShadowNode const *>(newestCloneOfShadowNode.get());
-  facebook::react::Point originRelativeToParent = layoutableShadowNode
+  facebook::react::Point originRelativeToParent =
+      layoutableShadowNode != nullptr
       ? layoutableShadowNode->getLayoutMetrics().frame.origin
       : facebook::react::Point();