@react-native-ohos/react-native-reanimated 3.18.1-rc.1

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

@@ -0,0 +1,87 @@
+#ifdef RCT_NEW_ARCH_ENABLED
+
+#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;
+    }
+  }
+
+  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({}));
+              {
+                auto lock = propsRegistry_->createLock();
+
+                propsRegistry_->for_each([&](const ShadowNodeFamily &family,
+                                             const folly::dynamic &props) {
+                  propsMap[&family].emplace_back(props);
+                });
+
+                rootNode =
+                    cloneShadowTreeWithNewProps(oldRootShadowNode, propsMap);
+              }
+
+              // Mark the commit as Reanimated commit so that we can
+              // distinguish it in ReanimatedCommitHook.
+              auto reaShadowNode =
+                  std::reinterpret_pointer_cast<ReanimatedCommitShadowNode>(
+                      rootNode);
+              reaShadowNode->setReanimatedCommitTrait();
+
+              return rootNode;
+            },
+            {/* .enableStateReconciliation = */
+             false,
+             /* .mountSynchronously = */ true});
+      });
+}
+
+} // namespace reanimated
+
+#endif // RCT_NEW_ARCH_ENABLED

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

@@ -0,0 +1,33 @@
+#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

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

@@ -0,0 +1,95 @@
+#ifdef RCT_NEW_ARCH_ENABLED
+
+#include <reanimated/Fabric/ShadowTreeCloner.h>
+
+#include <ranges>
+#include <utility>
+
+namespace reanimated {
+
+Props::Shared mergeProps(
+    const ShadowNode &shadowNode,
+    const PropsMap &propsMap,
+    const ShadowNodeFamily &family) {
+  const auto it = propsMap.find(&family);
+
+  if (it == propsMap.end()) {
+    return ShadowNodeFragment::propsPlaceholder();
+  }
+
+  PropsParserContext propsParserContext{
+      shadowNode.getSurfaceId(), *shadowNode.getContextContainer()};
+  const auto &propsVector = it->second;
+  auto newProps = shadowNode.getProps();
+
+#ifdef ANDROID
+  if (propsVector.size() > 1) {
+    folly::dynamic newPropsDynamic = folly::dynamic::object;
+    for (const auto &props : propsVector) {
+      newPropsDynamic = folly::dynamic::merge(
+          props.operator folly::dynamic(), newPropsDynamic);
+    }
+    return shadowNode.getComponentDescriptor().cloneProps(
+        propsParserContext, newProps, RawProps(newPropsDynamic));
+  }
+#endif
+
+  for (const auto &props : propsVector) {
+    newProps = shadowNode.getComponentDescriptor().cloneProps(
+        propsParserContext, newProps, RawProps(props));
+  }
+
+  return newProps;
+}
+
+ShadowNode::Unshared cloneShadowTreeWithNewPropsRecursive(
+    const ShadowNode &shadowNode,
+    const ChildrenMap &childrenMap,
+    const PropsMap &propsMap) {
+  const auto family = &shadowNode.getFamily();
+  const auto affectedChildrenIt = childrenMap.find(family);
+  auto children = shadowNode.getChildren();
+
+  if (affectedChildrenIt != childrenMap.end()) {
+    for (const auto index : affectedChildrenIt->second) {
+      children[index] = cloneShadowTreeWithNewPropsRecursive(
+          *children[index], childrenMap, propsMap);
+    }
+  }
+
+  return shadowNode.clone(
+      {mergeProps(shadowNode, propsMap, *family),
+       std::make_shared<ShadowNode::ListOfShared>(children),
+       shadowNode.getState()});
+}
+
+RootShadowNode::Unshared cloneShadowTreeWithNewProps(
+    const RootShadowNode &oldRootNode,
+    const PropsMap &propsMap) {
+  ChildrenMap childrenMap;
+
+  for (auto &[family, _] : propsMap) {
+    const auto ancestors = family->getAncestors(oldRootNode);
+
+    for (const auto &[parentNode, index] :
+         std::ranges::reverse_view(ancestors)) {
+      const auto parentFamily = &parentNode.get().getFamily();
+      auto &affectedChildren = childrenMap[parentFamily];
+
+      if (affectedChildren.contains(index)) {
+        continue;
+      }
+
+      affectedChildren.insert(index);
+    }
+  }
+
+  // This cast is safe, because this function returns a clone
+  // of the oldRootNode, which is an instance of RootShadowNode
+  return std::static_pointer_cast<RootShadowNode>(
+      cloneShadowTreeWithNewPropsRecursive(oldRootNode, childrenMap, propsMap));
+}
+
+} // namespace reanimated
+
+#endif // RCT_NEW_ARCH_ENABLED

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

@@ -0,0 +1,29 @@
+#pragma once
+#ifdef RCT_NEW_ARCH_ENABLED
+
+#include <react/renderer/core/PropsParserContext.h>
+#include <react/renderer/uimanager/UIManager.h>
+
+#include <memory>
+#include <type_traits>
+#include <unordered_map>
+#include <unordered_set>
+#include <vector>
+
+using namespace facebook;
+using namespace react;
+
+namespace reanimated {
+
+using PropsMap =
+    std::unordered_map<const ShadowNodeFamily *, std::vector<RawProps>>;
+using ChildrenMap =
+    std::unordered_map<const ShadowNodeFamily *, std::unordered_set<int>>;
+
+RootShadowNode::Unshared cloneShadowTreeWithNewProps(
+    const RootShadowNode &oldRootNode,
+    const PropsMap &propsMap);
+
+} // namespace reanimated
+
+#endif // RCT_NEW_ARCH_ENABLED

package/harmony/reanimated/src/main/cpp/Common/cpp/reanimated/LayoutAnimations/LayoutAnimationType.h

@@ -0,0 +1,9 @@
+#pragma once
+
+typedef enum LayoutAnimationType {
+  ENTERING = 1,
+  EXITING = 2,
+  LAYOUT = 3,
+  SHARED_ELEMENT_TRANSITION = 4,
+  SHARED_ELEMENT_TRANSITION_PROGRESS = 5,
+} LayoutAnimationType;

package/harmony/reanimated/src/main/cpp/Common/cpp/reanimated/LayoutAnimations/LayoutAnimationsManager.cpp

@@ -0,0 +1,232 @@
+#include <reanimated/LayoutAnimations/LayoutAnimationsManager.h>
+#include <reanimated/Tools/CollectionUtils.h>
+
+#ifndef NDEBUG
+#include <utility>
+#endif
+
+namespace reanimated {
+
+void LayoutAnimationsManager::configureAnimationBatch(
+    const std::vector<LayoutAnimationConfig> &layoutAnimationsBatch) {
+  auto lock = std::unique_lock<std::recursive_mutex>(animationsMutex_);
+  std::vector<LayoutAnimationConfig> sharedTransitionConfigs;
+  for (auto layoutAnimationConfig : layoutAnimationsBatch) {
+    const auto &[tag, type, config, sharedTransitionTag] =
+        layoutAnimationConfig;
+    if (type == SHARED_ELEMENT_TRANSITION ||
+        type == SHARED_ELEMENT_TRANSITION_PROGRESS) {
+      clearSharedTransitionConfig(tag);
+      sharedTransitionConfigs.push_back(std::move(layoutAnimationConfig));
+    } else {
+#ifdef RCT_NEW_ARCH_ENABLED
+      if (type == ENTERING) {
+        enteringAnimationsForNativeID_[tag] = config;
+        continue;
+      }
+#endif
+      if (config == nullptr) {
+        getConfigsForType(type).erase(tag);
+      } else {
+        getConfigsForType(type)[tag] = config;
+      }
+    }
+  }
+  for (const auto &[tag, type, config, sharedTransitionTag] :
+       sharedTransitionConfigs) {
+    if (config == nullptr) {
+      continue;
+    }
+    sharedTransitionGroups_[sharedTransitionTag].push_back(tag);
+    viewTagToSharedTag_[tag] = sharedTransitionTag;
+    getConfigsForType(SHARED_ELEMENT_TRANSITION)[tag] = config;
+    if (type == SHARED_ELEMENT_TRANSITION) {
+      ignoreProgressAnimationForTag_.insert(tag);
+    }
+  }
+}
+
+void LayoutAnimationsManager::setShouldAnimateExiting(
+    const int tag,
+    const bool value) {
+  auto lock = std::unique_lock<std::recursive_mutex>(animationsMutex_);
+  shouldAnimateExitingForTag_[tag] = value;
+}
+
+bool LayoutAnimationsManager::shouldAnimateExiting(
+    const int tag,
+    const bool shouldAnimate) {
+  auto lock = std::unique_lock<std::recursive_mutex>(animationsMutex_);
+  return collection::contains(shouldAnimateExitingForTag_, tag)
+      ? shouldAnimateExitingForTag_[tag]
+      : shouldAnimate;
+}
+
+bool LayoutAnimationsManager::hasLayoutAnimation(
+    const int tag,
+    const LayoutAnimationType type) {
+  auto lock = std::unique_lock<std::recursive_mutex>(animationsMutex_);
+  if (type == SHARED_ELEMENT_TRANSITION_PROGRESS) {
+    auto end = ignoreProgressAnimationForTag_.end();
+    return ignoreProgressAnimationForTag_.find(tag) == end;
+  }
+  return collection::contains(getConfigsForType(type), tag);
+}
+
+void LayoutAnimationsManager::clearSharedTransitionConfig(const int tag) {
+  auto lock = std::unique_lock<std::recursive_mutex>(animationsMutex_);
+#ifndef NDEBUG
+  const auto &pair = viewsScreenSharedTagMap_[tag];
+  screenSharedTagSet_.erase(pair);
+  viewsScreenSharedTagMap_.erase(tag);
+#endif // NDEBUG
+
+  sharedTransitionAnimations_.erase(tag);
+  auto const &groupName = viewTagToSharedTag_[tag];
+  if (groupName.empty()) {
+    viewTagToSharedTag_.erase(tag);
+    return;
+  }
+  auto &group = sharedTransitionGroups_[groupName];
+  auto position = std::find(group.begin(), group.end(), tag);
+  if (position != group.end()) {
+    group.erase(position);
+  }
+  if (group.size() == 0) {
+    sharedTransitionGroups_.erase(groupName);
+  }
+  viewTagToSharedTag_.erase(tag);
+  ignoreProgressAnimationForTag_.erase(tag);
+}
+
+void LayoutAnimationsManager::clearLayoutAnimationConfig(const int tag) {
+  auto lock = std::unique_lock<std::recursive_mutex>(animationsMutex_);
+  enteringAnimations_.erase(tag);
+  exitingAnimations_.erase(tag);
+  layoutAnimations_.erase(tag);
+  shouldAnimateExitingForTag_.erase(tag);
+  clearSharedTransitionConfig(tag);
+}
+
+void LayoutAnimationsManager::startLayoutAnimation(
+    jsi::Runtime &rt,
+    const int tag,
+    const LayoutAnimationType type,
+    const jsi::Object &values) {
+  std::shared_ptr<Shareable> config, viewShareable;
+  {
+    auto lock = std::unique_lock<std::recursive_mutex>(animationsMutex_);
+    if (!collection::contains(getConfigsForType(type), tag)) {
+      return;
+    }
+    config = getConfigsForType(type)[tag];
+  }
+  // TODO: cache the following!!
+  jsi::Value layoutAnimationRepositoryAsValue =
+      rt.global()
+          .getPropertyAsObject(rt, "global")
+          .getProperty(rt, "LayoutAnimationsManager");
+  jsi::Function startAnimationForTag =
+      layoutAnimationRepositoryAsValue.getObject(rt).getPropertyAsFunction(
+          rt, "start");
+  startAnimationForTag.call(
+      rt,
+      jsi::Value(tag),
+      jsi::Value(static_cast<int>(type)),
+      values,
+      config->toJSValue(rt));
+}
+
+void LayoutAnimationsManager::cancelLayoutAnimation(
+    jsi::Runtime &rt,
+    const int tag) const {
+  jsi::Value layoutAnimationRepositoryAsValue =
+      rt.global()
+          .getPropertyAsObject(rt, "global")
+          .getProperty(rt, "LayoutAnimationsManager");
+  jsi::Function cancelLayoutAnimation =
+      layoutAnimationRepositoryAsValue.getObject(rt).getPropertyAsFunction(
+          rt, "stop");
+  cancelLayoutAnimation.call(rt, jsi::Value(tag));
+}
+
+/*
+  The top screen on the stack triggers the animation, so we need to find
+  the sibling view registered in the past. This method finds view
+  registered in the same transition group (with the same transition tag)
+  which has been added to that group directly before the one that we
+  provide as an argument.
+*/
+int LayoutAnimationsManager::findPrecedingViewTagForTransition(const int tag) {
+  auto const &groupName = viewTagToSharedTag_[tag];
+  auto const &group = sharedTransitionGroups_[groupName];
+  auto position = std::find(group.begin(), group.end(), tag);
+  if (position != group.end() && position != group.begin()) {
+    return *std::prev(position);
+  }
+  return -1;
+}
+
+const std::vector<int> &LayoutAnimationsManager::getSharedGroup(
+    const int viewTag) {
+  const auto &groupSharedTag = viewTagToSharedTag_[viewTag];
+  return sharedTransitionGroups_[groupSharedTag];
+}
+
+#ifdef RCT_NEW_ARCH_ENABLED
+void LayoutAnimationsManager::transferConfigFromNativeID(
+    const int nativeId,
+    const int tag) {
+  auto lock = std::unique_lock<std::recursive_mutex>(animationsMutex_);
+  auto config = enteringAnimationsForNativeID_[nativeId];
+  if (config) {
+    enteringAnimations_.insert_or_assign(tag, config);
+  }
+  enteringAnimationsForNativeID_.erase(nativeId);
+}
+#endif
+
+#ifndef NDEBUG
+std::string LayoutAnimationsManager::getScreenSharedTagPairString(
+    const int screenTag,
+    const std::string &sharedTag) const {
+  return std::to_string(screenTag) + ":" + sharedTag;
+}
+
+void LayoutAnimationsManager::checkDuplicateSharedTag(
+    const int viewTag,
+    const int screenTag) {
+  if (!viewTagToSharedTag_.count(viewTag)) {
+    return;
+  }
+  const auto &sharedTag = viewTagToSharedTag_[viewTag];
+  const auto &pair = getScreenSharedTagPairString(screenTag, sharedTag);
+  bool hasDuplicate = screenSharedTagSet_.count(pair);
+  if (hasDuplicate) {
+    jsLogger_->warnOnJS(
+        "[Reanimated] Duplicate shared tag \"" + sharedTag +
+        "\" on the same screen");
+  }
+  viewsScreenSharedTagMap_[viewTag] = pair;
+  screenSharedTagSet_.insert(pair);
+}
+#endif // NDEBUG
+
+std::unordered_map<int, std::shared_ptr<Shareable>> &
+LayoutAnimationsManager::getConfigsForType(const LayoutAnimationType type) {
+  switch (type) {
+    case ENTERING:
+      return enteringAnimations_;
+    case EXITING:
+      return exitingAnimations_;
+    case LAYOUT:
+      return layoutAnimations_;
+    case SHARED_ELEMENT_TRANSITION:
+    case SHARED_ELEMENT_TRANSITION_PROGRESS:
+      return sharedTransitionAnimations_;
+    default:
+      assert(false);
+  }
+}
+
+} // namespace reanimated

package/harmony/reanimated/src/main/cpp/Common/cpp/reanimated/LayoutAnimations/LayoutAnimationsManager.h

@@ -0,0 +1,90 @@
+#pragma once
+
+#include <reanimated/LayoutAnimations/LayoutAnimationType.h>
+
+#include <worklets/SharedItems/Shareables.h>
+#include <worklets/Tools/JSLogger.h>
+
+#include <jsi/jsi.h>
+#include <stdio.h>
+#include <functional>
+#include <memory>
+#include <mutex>
+#include <string>
+#include <unordered_map>
+#include <unordered_set>
+#include <vector>
+
+namespace reanimated {
+
+using namespace facebook;
+using namespace worklets;
+
+struct LayoutAnimationConfig {
+  int tag;
+  LayoutAnimationType type;
+  std::shared_ptr<Shareable> config;
+  std::string sharedTransitionTag;
+};
+
+class LayoutAnimationsManager {
+ public:
+  explicit LayoutAnimationsManager(const std::shared_ptr<JSLogger> &jsLogger)
+      : jsLogger_(jsLogger) {}
+  void configureAnimationBatch(
+      const std::vector<LayoutAnimationConfig> &layoutAnimationsBatch);
+  void setShouldAnimateExiting(const int tag, const bool value);
+  bool shouldAnimateExiting(const int tag, const bool shouldAnimate);
+  bool hasLayoutAnimation(const int tag, const LayoutAnimationType type);
+  void startLayoutAnimation(
+      jsi::Runtime &rt,
+      const int tag,
+      const LayoutAnimationType type,
+      const jsi::Object &values);
+  void clearLayoutAnimationConfig(const int tag);
+  void clearSharedTransitionConfig(const int tag);
+  void cancelLayoutAnimation(jsi::Runtime &rt, const int tag) const;
+#ifdef RCT_NEW_ARCH_ENABLED
+  void transferConfigFromNativeID(const int nativeId, const int tag);
+#endif
+  int findPrecedingViewTagForTransition(const int tag);
+  const std::vector<int> &getSharedGroup(const int viewTag);
+#ifndef NDEBUG
+  std::string getScreenSharedTagPairString(
+      const int screenTag,
+      const std::string &sharedTag) const;
+  void checkDuplicateSharedTag(const int viewTag, const int screenTag);
+#endif
+
+ private:
+  std::unordered_map<int, std::shared_ptr<Shareable>> &getConfigsForType(
+      const LayoutAnimationType type);
+
+  std::shared_ptr<JSLogger> jsLogger_;
+#ifndef NDEBUG
+  // This set's function is to detect duplicate sharedTags on a single screen
+  // it contains strings in form: "reactScreenTag:sharedTag"
+  std::unordered_set<std::string> screenSharedTagSet_;
+  // And this map is to remove collected pairs on SET removal
+  std::unordered_map<int, std::string> viewsScreenSharedTagMap_;
+#endif
+
+#ifdef RCT_NEW_ARCH_ENABLED
+  std::unordered_map<int, std::shared_ptr<Shareable>>
+      enteringAnimationsForNativeID_;
+#endif
+  std::unordered_map<int, std::shared_ptr<Shareable>> enteringAnimations_;
+  std::unordered_map<int, std::shared_ptr<Shareable>> exitingAnimations_;
+  std::unordered_map<int, std::shared_ptr<Shareable>> layoutAnimations_;
+  std::unordered_map<int, std::shared_ptr<Shareable>>
+      sharedTransitionAnimations_;
+  std::unordered_set<int> ignoreProgressAnimationForTag_;
+  std::unordered_map<std::string, std::vector<int>> sharedTransitionGroups_;
+  std::unordered_map<int, std::string> viewTagToSharedTag_;
+  std::unordered_map<int, bool> shouldAnimateExitingForTag_;
+  mutable std::recursive_mutex
+      animationsMutex_; // Protects `enteringAnimations_`, `exitingAnimations_`,
+  // `layoutAnimations_`, `viewSharedValues_` and `shouldAnimateExitingForTag_`.
+};
+
+} // namespace reanimated