react-native-reanimated 2.9.0 → 3.0.0-rc.1

package/Common/cpp/AnimatedSensor/AnimatedSensorModule.cpp

@@ -35,10 +35,10 @@ jsi::Value AnimatedSensorModule::registerSensor(
     setter = [&, mutableObject](double newValues[]) {
       jsi::Runtime &runtime = *runtimeManager_->runtime.get();
       jsi::Object value(runtime);
-      value.setProperty(runtime, "qw", newValues[0]);
-      value.setProperty(runtime, "qx", newValues[1]);
-      value.setProperty(runtime, "qy", newValues[2]);
-      value.setProperty(runtime, "qz", newValues[3]);
+      value.setProperty(runtime, "qx", newValues[0]);
+      value.setProperty(runtime, "qy", newValues[1]);
+      value.setProperty(runtime, "qz", newValues[2]);
+      value.setProperty(runtime, "qw", newValues[3]);
       value.setProperty(runtime, "yaw", newValues[4]);
       value.setProperty(runtime, "pitch", newValues[5]);
       value.setProperty(runtime, "roll", newValues[6]);

package/Common/cpp/Fabric/FabricUtils.cpp

@@ -0,0 +1,133 @@
+#ifdef RCT_NEW_ARCH_ENABLED
+
+#if RNVERSION < 69
+#error \
+    "Reanimated 3 does not support React Native 0.68.x when Fabric is enabled. Please upgrade to React Native 0.69.0 or newer if you want to use Reanimated with the new architecture."
+#endif
+
+#include "FabricUtils.h"
+
+#include <react/renderer/uimanager/UIManagerBinding.h>
+
+using namespace facebook::react;
+
+namespace reanimated {
+
+#ifdef ANDROID
+RuntimeExecutor getRuntimeExecutorFromBinding(Binding *binding) {
+  BindingPublic *bindingPublic = reinterpret_cast<BindingPublic *>(binding);
+  SchedulerPublic *schedulerPublic =
+      reinterpret_cast<SchedulerPublic *>((bindingPublic->scheduler_).get());
+  return schedulerPublic->runtimeExecutor_;
+}
+#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);
+}
+
+} // namespace reanimated
+
+#endif // RCT_NEW_ARCH_ENABLED

package/Common/cpp/Fabric/ReanimatedUIManagerBinding.cpp

@@ -0,0 +1,220 @@
+#ifdef RCT_NEW_ARCH_ENABLED
+
+#include "ReanimatedUIManagerBinding.h"
+#include "FabricUtils.h"
+#include "NewestShadowNodesRegistry.h"
+
+using namespace facebook;
+using namespace react;
+
+namespace reanimated {
+
+void ReanimatedUIManagerBinding::createAndInstallIfNeeded(
+    jsi::Runtime &runtime,
+    RuntimeExecutor const &runtimeExecutor,
+    std::shared_ptr<UIManager> const &uiManager,
+    std::shared_ptr<NewestShadowNodesRegistry> const
+        &newestShadowNodesRegistry) {
+  // adapted from UIManagerBinding.cpp
+  auto uiManagerModuleName = "nativeFabricUIManager";
+
+  auto eventHandler = [&]() -> std::unique_ptr<EventHandler const> {
+    auto uiManagerValue =
+        runtime.global().getProperty(runtime, uiManagerModuleName);
+    if (uiManagerValue.isUndefined()) {
+      return nullptr;
+    }
+
+    auto uiManagerBinding =
+        uiManagerValue.asObject(runtime).asHostObject<UIManagerBinding>(
+            runtime);
+    auto uiManagerBindingPublic =
+        reinterpret_cast<UIManagerBindingPublic *>(&*uiManagerBinding);
+    return std::move(uiManagerBindingPublic->eventHandler_);
+  }();
+
+  auto reanimatedUiManagerBinding =
+      std::make_shared<ReanimatedUIManagerBinding>(
+          uiManager,
+          runtimeExecutor,
+          std::move(eventHandler),
+          newestShadowNodesRegistry);
+  auto object =
+      jsi::Object::createFromHostObject(runtime, reanimatedUiManagerBinding);
+  runtime.global().setProperty(runtime, uiManagerModuleName, std::move(object));
+}
+
+ReanimatedUIManagerBinding::ReanimatedUIManagerBinding(
+    std::shared_ptr<UIManager> uiManager,
+    RuntimeExecutor runtimeExecutor,
+    std::unique_ptr<EventHandler const> eventHandler,
+    std::shared_ptr<NewestShadowNodesRegistry> newestShadowNodesRegistry)
+    : UIManagerBinding(uiManager, runtimeExecutor),
+      uiManager_(std::move(uiManager)),
+      newestShadowNodesRegistry_(newestShadowNodesRegistry) {
+  if (eventHandler != nullptr) {
+    reinterpret_cast<UIManagerBindingPublic *>(this)->eventHandler_ =
+        std::move(eventHandler);
+  }
+}
+
+ReanimatedUIManagerBinding::~ReanimatedUIManagerBinding() {}
+
+static inline ShadowNode::Shared cloneNode(
+    UIManager *uiManager,
+    NewestShadowNodesRegistry *newestShadowNodesRegistry,
+    const ShadowNode::Shared &shadowNode,
+    const ShadowNode::SharedListOfShared &children = nullptr,
+    const RawProps *rawProps = nullptr) {
+  {
+    auto lock = newestShadowNodesRegistry->createLock();
+    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);
+      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);
+}
+
+jsi::Value ReanimatedUIManagerBinding::get(
+    jsi::Runtime &runtime,
+    jsi::PropNameID const &name) {
+  // Currently, we need to overwrite all variants of `cloneNode` as well as
+  // `appendChild` to prevent React from overwriting layout props animated using
+  // Reanimated. However, this may degrade performance due to using locks.
+  // We already have an idea how this can be done better without locks
+  // (i.e. by overwriting `completeRoot` and using UIManagerCommitHooks).
+
+  // based on implementation from UIManagerBinding.cpp
+  auto methodName = name.utf8(runtime);
+  UIManager *uiManager = uiManager_.get();
+  NewestShadowNodesRegistry *newestShadowNodesRegistry =
+      newestShadowNodesRegistry_.get();
+
+  // Semantic: Clones the node with *same* props and *same* children.
+  if (methodName == "cloneNode") {
+    return jsi::Function::createFromHostFunction(
+        runtime,
+        name,
+        1,
+        [uiManager, newestShadowNodesRegistry](
+            jsi::Runtime &runtime,
+            jsi::Value const &thisValue,
+            jsi::Value const *arguments,
+            size_t count) noexcept -> jsi::Value {
+          return valueFromShadowNode(
+              runtime,
+              cloneNode(
+                  uiManager,
+                  newestShadowNodesRegistry,
+                  shadowNodeFromValue(runtime, arguments[0])));
+        });
+  }
+
+  // Semantic: Clones the node with *same* props and *empty* children.
+  if (methodName == "cloneNodeWithNewChildren") {
+    return jsi::Function::createFromHostFunction(
+        runtime,
+        name,
+        1,
+        [uiManager, newestShadowNodesRegistry](
+            jsi::Runtime &runtime,
+            jsi::Value const &thisValue,
+            jsi::Value const *arguments,
+            size_t count) noexcept -> jsi::Value {
+          return valueFromShadowNode(
+              runtime,
+              cloneNode(
+                  uiManager,
+                  newestShadowNodesRegistry,
+                  shadowNodeFromValue(runtime, arguments[0]),
+                  ShadowNode::emptySharedShadowNodeSharedList()));
+        });
+  }
+
+  // Semantic: Clones the node with *given* props and *same* children.
+  if (methodName == "cloneNodeWithNewProps") {
+    return jsi::Function::createFromHostFunction(
+        runtime,
+        name,
+        2,
+        [uiManager, newestShadowNodesRegistry](
+            jsi::Runtime &runtime,
+            jsi::Value const &thisValue,
+            jsi::Value const *arguments,
+            size_t count) noexcept -> jsi::Value {
+          auto const &rawProps = RawProps(runtime, arguments[1]);
+          return valueFromShadowNode(
+              runtime,
+              cloneNode(
+                  uiManager,
+                  newestShadowNodesRegistry,
+                  shadowNodeFromValue(runtime, arguments[0]),
+                  nullptr,
+                  &rawProps));
+        });
+  }
+
+  // Semantic: Clones the node with *given* props and *empty* children.
+  if (methodName == "cloneNodeWithNewChildrenAndProps") {
+    return jsi::Function::createFromHostFunction(
+        runtime,
+        name,
+        2,
+        [uiManager, newestShadowNodesRegistry](
+            jsi::Runtime &runtime,
+            jsi::Value const &thisValue,
+            jsi::Value const *arguments,
+            size_t count) noexcept -> jsi::Value {
+          auto const &rawProps = RawProps(runtime, arguments[1]);
+          return valueFromShadowNode(
+              runtime,
+              cloneNode(
+                  uiManager,
+                  newestShadowNodesRegistry,
+                  shadowNodeFromValue(runtime, arguments[0]),
+                  ShadowNode::emptySharedShadowNodeSharedList(),
+                  &rawProps));
+        });
+  }
+
+  if (methodName == "appendChild") {
+    return jsi::Function::createFromHostFunction(
+        runtime,
+        name,
+        2,
+        [newestShadowNodesRegistry](
+            jsi::Runtime &runtime,
+            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);
+          return jsi::Value::undefined();
+        });
+  }
+
+  // Methods like "findNodeAtPoint", "getRelativeLayoutMetrics", "measure" etc.
+  // use `UIManager::getNewestCloneOfShadowNode` or
+  // `ShadowTree::getCurrentRevision` under the hood,
+  // so there's no need to overwrite them.
+
+  return UIManagerBinding::get(runtime, name);
+}
+
+} // namespace reanimated
+
+#endif // RCT_NEW_ARCH_ENABLED

package/Common/cpp/Fabric/ShadowTreeCloner.cpp

@@ -0,0 +1,92 @@
+#ifdef RCT_NEW_ARCH_ENABLED
+
+#include "ShadowTreeCloner.h"
+#include "FabricUtils.h"
+
+namespace reanimated {
+
+ShadowTreeCloner::ShadowTreeCloner(
+    std::shared_ptr<NewestShadowNodesRegistry> newestShadowNodesRegistry,
+    std::shared_ptr<UIManager> uiManager,
+    SurfaceId surfaceId)
+    : newestShadowNodesRegistry_{newestShadowNodesRegistry},
+      propsParserContext_{
+          surfaceId,
+          *getContextContainerFromUIManager(&*uiManager)} {}
+
+ShadowTreeCloner::~ShadowTreeCloner() {
+#ifdef DEBUG
+  react_native_assert(
+      yogaChildrenUpdates_.empty() &&
+      "Deallocating `ShadowTreeCloner` without calling `updateYogaChildren`.");
+#endif
+}
+
+ShadowNode::Unshared ShadowTreeCloner::cloneWithNewProps(
+    const ShadowNode::Shared &oldRootNode,
+    const ShadowNodeFamily &family,
+    RawProps &&rawProps) {
+  // adapted from ShadowNode::cloneTree
+
+  auto ancestors = family.getAncestors(*oldRootNode);
+
+  if (ancestors.empty()) {
+    return ShadowNode::Unshared{nullptr};
+  }
+
+  auto &parent = ancestors.back();
+  auto &oldShadowNode = parent.first.get().getChildren().at(parent.second);
+
+  const auto newest = newestShadowNodesRegistry_->get(oldShadowNode->getTag());
+
+  const auto &source = newest == nullptr ? oldShadowNode : newest;
+
+  const auto props = source->getComponentDescriptor().cloneProps(
+      propsParserContext_, source->getProps(), rawProps);
+
+  auto newChildNode = source->clone({/* .props = */ props});
+
+  for (auto it = ancestors.rbegin(); it != ancestors.rend(); ++it) {
+    auto &parentNode = it->first.get();
+    auto childIndex = it->second;
+
+    auto children = parentNode.getChildren();
+    const auto &oldChildNode = *children.at(childIndex);
+    react_native_assert(ShadowNode::sameFamily(oldChildNode, *newChildNode));
+
+    newestShadowNodesRegistry_->set(newChildNode, parentNode.getTag());
+
+    if (!parentNode.getSealed()) {
+      // Optimization: if a ShadowNode is unsealed, we can directly update its
+      // children instead of cloning the whole path to the root node.
+      auto &parentNodeNonConst = const_cast<ShadowNode &>(parentNode);
+      parentNodeNonConst.replaceChild(oldChildNode, newChildNode, childIndex);
+      yogaChildrenUpdates_.insert(&parentNodeNonConst);
+      return std::const_pointer_cast<ShadowNode>(oldRootNode);
+    }
+
+    children[childIndex] = newChildNode;
+
+    newChildNode = parentNode.clone({
+        ShadowNodeFragment::propsPlaceholder(),
+        std::make_shared<ShadowNode::ListOfShared>(children),
+    });
+  }
+
+  return std::const_pointer_cast<ShadowNode>(newChildNode);
+}
+
+void ShadowTreeCloner::updateYogaChildren() {
+  // Unfortunately, `replaceChild` does not update Yoga nodes, so we need to
+  // update them manually here.
+  for (ShadowNode *shadowNode : yogaChildrenUpdates_) {
+    static_cast<YogaLayoutableShadowNode *>(shadowNode)->updateYogaChildren();
+  }
+#ifdef DEBUG
+  yogaChildrenUpdates_.clear();
+#endif
+}
+
+} // namespace reanimated
+
+#endif // RCT_NEW_ARCH_ENABLED