@react-native-ohos/react-native-reanimated 3.18.1-rc.6 → 4.0.0-rc.1

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

@@ -0,0 +1,220 @@
+#pragma once
+
+#include <react/renderer/componentregistry/ComponentDescriptorFactory.h>
+#include <react/renderer/mounting/MountingOverrideDelegate.h>
+#include <react/renderer/scheduler/Scheduler.h>
+#include <react/renderer/uimanager/UIManagerAnimationDelegate.h>
+#include <react/renderer/uimanager/UIManagerBinding.h>
+#include <reanimated/LayoutAnimations/LayoutAnimationsManager.h>
+#include <reanimated/LayoutAnimations/LayoutAnimationsProxyCommon.h>
+#include <reanimated/LayoutAnimations/LayoutAnimationsUtils.h>
+#include <reanimated/Tools/PlatformDepMethodsHolder.h>
+#include <worklets/Tools/UIScheduler.h>
+
+#include <memory>
+#include <string>
+#include <unordered_map>
+#include <unordered_set>
+#include <utility>
+#include <vector>
+
+namespace reanimated {
+
+class ReanimatedModuleProxy;
+
+using namespace facebook;
+
+typedef enum ExitingState_Legacy {
+  UNDEFINED = 1,
+  WAITING = 2,
+  ANIMATING = 4,
+  DEAD = 8,
+  MOVED = 16,
+  DELETED = 32,
+} ExitingState_Legacy;
+
+struct MutationNode;
+
+/**
+ Represents a view that was either removed or had a child removed from the
+ ShadowTree
+ */
+struct Node {
+  std::vector<std::shared_ptr<MutationNode>> children, unflattenedChildren;
+  std::shared_ptr<Node> parent, unflattenedParent;
+  Tag tag;
+  void removeChildFromUnflattenedTree(std::shared_ptr<MutationNode> child);
+  void applyMutationToIndices(ShadowViewMutation mutation);
+  void insertChildren(std::vector<std::shared_ptr<MutationNode>> &newChildren);
+  void insertUnflattenedChildren(std::vector<std::shared_ptr<MutationNode>> &newChildren);
+  virtual bool isMutationNode();
+  explicit Node(const Tag tag) : tag(tag) {}
+  Node(Node &&node)
+      : children(std::move(node.children)), unflattenedChildren(std::move(node.unflattenedChildren)), tag(node.tag) {}
+  Node(Node &node) : children(node.children), unflattenedChildren(node.unflattenedChildren), tag(node.tag) {}
+  virtual ~Node() = default;
+};
+
+/**
+ Represents a view that was removed from the ShadowTree
+ */
+struct MutationNode : public Node {
+  ShadowViewMutation mutation;
+  ExitingState_Legacy state = UNDEFINED;
+  explicit MutationNode(ShadowViewMutation &mutation) : Node(mutation.oldChildShadowView.tag), mutation(mutation) {}
+  MutationNode(ShadowViewMutation &mutation, Node &&node) : Node(std::move(node)), mutation(mutation) {}
+  bool isMutationNode() override;
+};
+
+static inline bool isRNSScreen(std::shared_ptr<MutationNode> node) {
+  const auto &componentName = node->mutation.oldChildShadowView.componentName;
+  return !std::strcmp(componentName, "RNSScreenStack") || !std::strcmp(componentName, "RNSScreen") ||
+      !std::strcmp(componentName, "RNSModalScreen");
+}
+
+static inline void mergeAndSwap(
+    std::vector<std::shared_ptr<MutationNode>> &A,
+    std::vector<std::shared_ptr<MutationNode>> &B) {
+  std::vector<std::shared_ptr<MutationNode>> merged;
+  auto it1 = A.begin(), it2 = B.begin();
+  while (it1 != A.end() && it2 != B.end()) {
+    if ((*it1)->mutation.index < (*it2)->mutation.index) {
+      merged.push_back(*it1);
+      it1++;
+    } else {
+      merged.push_back(*it2);
+      it2++;
+    }
+  }
+  while (it1 != A.end()) {
+    merged.push_back(*it1);
+    it1++;
+  }
+  while (it2 != B.end()) {
+    merged.push_back(*it2);
+    it2++;
+  }
+  std::swap(A, merged);
+}
+
+struct SurfaceContext {
+  mutable std::unordered_set<std::shared_ptr<MutationNode>> deadNodes;
+};
+
+struct LayoutAnimationsProxy_Legacy : public LayoutAnimationsProxyCommon,
+                                      public UIManagerAnimationDelegate,
+                                      public std::enable_shared_from_this<LayoutAnimationsProxy_Legacy> {
+  mutable std::unordered_map<Tag, std::shared_ptr<Node>> nodeForTag_;
+  mutable std::recursive_mutex mutex;
+  mutable SurfaceManager surfaceManager;
+  mutable std::unordered_map<SurfaceId, SurfaceContext> surfaceContext_;
+  mutable std::unordered_map<Tag, int> leastRemoved;
+  mutable std::unordered_set<SurfaceId> surfacesToRemove_;
+
+  LayoutAnimationsProxy_Legacy(
+      std::shared_ptr<LayoutAnimationsManager> layoutAnimationsManager,
+      SharedComponentDescriptorRegistry componentDescriptorRegistry,
+      std::shared_ptr<const ContextContainer> contextContainer,
+      jsi::Runtime &uiRuntime,
+      const std::shared_ptr<UIScheduler> &uiScheduler
+#ifdef ANDROID
+      ,
+      PreserveMountedTagsFunction filterUnmountedTagsFunction,
+      std::shared_ptr<UIManager> uiManager,
+      std::shared_ptr<CallInvoker> jsInvoker
+#endif
+      )
+      : LayoutAnimationsProxyCommon(
+            std::move(layoutAnimationsManager),
+            std::move(componentDescriptorRegistry),
+            std::move(contextContainer),
+            uiRuntime,
+            uiScheduler
+#ifdef ANDROID
+            ,
+            std::move(filterUnmountedTagsFunction),
+            std::move(uiManager),
+            std::move(jsInvoker)
+#endif
+        ) {
+  }
+
+  void startEnteringAnimation(const int tag, ShadowViewMutation &mutation) const;
+  void startExitingAnimation(const int tag, ShadowViewMutation &mutation) const;
+  void startLayoutAnimation(const int tag, const ShadowViewMutation &mutation) const;
+
+  void transferConfigFromNativeID(const std::string &nativeId, const int tag) const;
+  std::optional<SurfaceId> progressLayoutAnimation(int tag, const jsi::Object &newStyle) override;
+  std::optional<SurfaceId> endLayoutAnimation(int tag, bool shouldRemove) override;
+  void maybeCancelAnimation(const int tag) const;
+
+  void parseRemoveMutations(
+      std::unordered_map<Tag, Tag> &movedViews,
+      ShadowViewMutationList &mutations,
+      std::vector<std::shared_ptr<MutationNode>> &roots) const;
+  void handleRemovals(
+      ShadowViewMutationList &filteredMutations,
+      std::vector<std::shared_ptr<MutationNode>> &roots,
+      std::unordered_set<std::shared_ptr<MutationNode>> &deadNodes,
+      bool shouldAnimate) const;
+
+  void handleUpdatesAndEnterings(
+      ShadowViewMutationList &filteredMutations,
+      const std::unordered_map<Tag, Tag> &movedViews,
+      ShadowViewMutationList &mutations,
+      const PropsParserContext &propsParserContext,
+      SurfaceId surfaceId) const;
+  void addOngoingAnimations(SurfaceId surfaceId, ShadowViewMutationList &mutations) const;
+  void updateOngoingAnimationTarget(const int tag, const ShadowViewMutation &mutation) const;
+  std::shared_ptr<ShadowView> cloneViewWithoutOpacity(
+      facebook::react::ShadowViewMutation &mutation,
+      const PropsParserContext &propsParserContext) const;
+  void maybeRestoreOpacity(LayoutAnimation &layoutAnimation, const jsi::Object &newStyle) const;
+  void maybeUpdateWindowDimensions(facebook::react::ShadowViewMutation &mutation, SurfaceId surfaceId) const;
+  void createLayoutAnimation(
+      const ShadowViewMutation &mutation,
+      ShadowView &oldView,
+      const SurfaceId &surfaceId,
+      const int tag) const;
+
+  void updateIndexForMutation(ShadowViewMutation &mutation) const;
+
+  void removeRecursively(std::shared_ptr<MutationNode> node, ShadowViewMutationList &mutations) const;
+  bool startAnimationsRecursively(
+      const std::shared_ptr<MutationNode> &node,
+      bool shouldRemoveSubviewsWithoutAnimations,
+      bool shouldAnimate,
+      bool isScreenPop,
+      ShadowViewMutationList &mutations) const;
+  void endAnimationsRecursively(const std::shared_ptr<MutationNode> &node, ShadowViewMutationList &mutations) const;
+  void maybeDropAncestors(
+      const std::shared_ptr<Node> &node,
+      const std::shared_ptr<MutationNode> &child,
+      ShadowViewMutationList &cleanupMutations) const;
+
+  const ComponentDescriptor &getComponentDescriptorForShadowView(const ShadowView &shadowView) const;
+  // MountingOverrideDelegate
+
+  bool shouldOverridePullTransaction() const override;
+  std::optional<MountingTransaction> pullTransaction(
+      SurfaceId surfaceId,
+      MountingTransaction::Number number,
+      const TransactionTelemetry &telemetry,
+      ShadowViewMutationList mutations) const override;
+
+  // UIManagerAnimationDelegate
+
+  void uiManagerDidConfigureNextLayoutAnimation(
+      jsi::Runtime &runtime,
+      const RawValue &config,
+      const jsi::Value &successCallbackValue,
+      const jsi::Value &failureCallbackValue) const override;
+
+  void setComponentDescriptorRegistry(const SharedComponentDescriptorRegistry &componentDescriptorRegistry) override;
+
+  bool shouldAnimateFrame() const override;
+
+  void stopSurface(SurfaceId surfaceId) override;
+};
+
+} // namespace reanimated

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

@@ -1,10 +1,11 @@
-#ifdef RCT_NEW_ARCH_ENABLED
 #include <reanimated/LayoutAnimations/LayoutAnimationsUtils.h>
 
+#include <memory>
+#include <unordered_map>
+
 namespace reanimated {
 
-std::unordered_map<Tag, UpdateValues> &SurfaceManager::getUpdateMap(
-    SurfaceId surfaceId) {
+std::unordered_map<Tag, UpdateValues> &SurfaceManager::getUpdateMap(SurfaceId surfaceId) {
   auto props = props_.find(surfaceId);
   if (props != props_.end()) {
     return *props->second;
@@ -15,10 +16,7 @@ std::unordered_map<Tag, UpdateValues> &SurfaceManager::getUpdateMap(
   return *newProps;
 }
 
-void SurfaceManager::updateWindow(
-    const SurfaceId surfaceId,
-    const double windowWidth,
-    const double windowHeight) {
+void SurfaceManager::updateWindow(const SurfaceId surfaceId, const double windowWidth, const double windowHeight) {
   windows_.insert_or_assign(surfaceId, Rect{windowWidth, windowHeight});
 }
 
@@ -30,62 +28,4 @@ Rect SurfaceManager::getWindow(SurfaceId surfaceId) {
   return Rect{0, 0};
 }
 
-void Node::applyMutationToIndices(ShadowViewMutation mutation) {
-#if REACT_NATIVE_MINOR_VERSION >= 78
-  const auto parentTag = mutation.parentTag;
-#else
-  const auto parentTag = mutation.parentShadowView.tag;
-#endif // REACT_NATIVE_MINOR_VERSION >= 78
-
-  if (tag != parentTag) {
-    return;
-  }
-
-  int delta = mutation.type == ShadowViewMutation::Insert ? 1 : -1;
-  for (int i = children.size() - 1; i >= 0; i--) {
-    if (children[i]->mutation.index < mutation.index) {
-      return;
-    }
-    children[i]->mutation.index += delta;
-  }
-}
-
-// Should only be called on unflattened parents
-void Node::removeChildFromUnflattenedTree(std::shared_ptr<MutationNode> child) {
-  for (int i = unflattenedChildren.size() - 1; i >= 0; i--) {
-    if (unflattenedChildren[i]->tag == child->tag) {
-      unflattenedChildren.erase(unflattenedChildren.begin() + i);
-      break;
-    }
-  }
-
-  auto &flattenedChildren = child->parent->children;
-  for (int i = flattenedChildren.size() - 1; i >= 0; i--) {
-    if (flattenedChildren[i]->tag == child->tag) {
-      flattenedChildren.erase(flattenedChildren.begin() + i);
-      return;
-    }
-    flattenedChildren[i]->mutation.index--;
-  }
-}
-
-void Node::insertChildren(
-    std::vector<std::shared_ptr<MutationNode>> &newChildren) {
-  mergeAndSwap(children, newChildren);
-}
-
-void Node::insertUnflattenedChildren(
-    std::vector<std::shared_ptr<MutationNode>> &newChildren) {
-  mergeAndSwap(unflattenedChildren, newChildren);
-}
-
-bool Node::isMutationMode() {
-  return false;
-}
-
-bool MutationNode::isMutationMode() {
-  return true;
-}
 } // namespace reanimated
-
-#endif

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

@@ -1,6 +1,5 @@
 #pragma once
 
-#include <reanimated/Fabric/PropsRegistry.h>
 #include <reanimated/LayoutAnimations/LayoutAnimationsManager.h>
 
 #include <react/renderer/mounting/MountingOverrideDelegate.h>
@@ -14,12 +13,15 @@
 
 namespace reanimated {
 
+enum BeforeOrAfter { BEFORE = 0, AFTER = 1 };
+
 struct Rect {
   double width, height;
 };
 
 struct Frame {
   std::optional<double> x, y, width, height;
+  Frame(double x, double y, double width, double height) : x(x), y(y), width(width), height(height) {}
   Frame(jsi::Runtime &runtime, const jsi::Object &newStyle) {
     if (newStyle.hasProperty(runtime, "originX")) {
       x = newStyle.getProperty(runtime, "originX").asNumber();
@@ -54,72 +56,57 @@ struct Snapshot {
   }
 };
 
-typedef enum ExitingState {
+typedef enum class ExitingState : std::uint8_t {
   UNDEFINED = 1,
   WAITING = 2,
-  ANIMATING = 4,
-  DEAD = 8,
-  MOVED = 16,
-  DELETED = 32,
+  ANIMATING = 3,
+  DEAD = 4,
+  DELETED = 5,
 } ExitingState;
 
 struct MutationNode;
 
-/**
- Represents a view that was either removed or had a child removed from the
- ShadowTree
- */
-struct Node {
-  std::vector<std::shared_ptr<MutationNode>> children, unflattenedChildren;
-  std::shared_ptr<Node> parent, unflattenedParent;
-  Tag tag;
-  void removeChildFromUnflattenedTree(std::shared_ptr<MutationNode> child);
-  void applyMutationToIndices(ShadowViewMutation mutation);
-  void insertChildren(std::vector<std::shared_ptr<MutationNode>> &newChildren);
-  void insertUnflattenedChildren(
-      std::vector<std::shared_ptr<MutationNode>> &newChildren);
-  virtual bool isMutationMode();
-  explicit Node(const Tag tag) : tag(tag) {}
-  Node(Node &&node)
-      : children(std::move(node.children)),
-        unflattenedChildren(std::move(node.unflattenedChildren)),
-        tag(node.tag) {}
-  Node(Node &node)
-      : children(node.children),
-        unflattenedChildren(node.unflattenedChildren),
-        tag(node.tag) {}
-  virtual ~Node() = default;
+enum TransitionState {
+  NONE = 0,
+  START = 1,
+  ACTIVE = 2,
+  END = 3,
+  CANCELLED = 4,
 };
 
-/**
- Represents a view that was removed from the ShadowTree
- */
-struct MutationNode : public Node {
-  ShadowViewMutation mutation;
-  ExitingState state = UNDEFINED;
-  explicit MutationNode(ShadowViewMutation &mutation)
-      : Node(mutation.oldChildShadowView.tag), mutation(mutation) {}
-  MutationNode(ShadowViewMutation &mutation, Node &&node)
-      : Node(std::move(node)), mutation(mutation) {}
-  bool isMutationMode() override;
+enum Intent {
+  NO_INTENT = 0,
+  TO_MOVE = 1,
+  TO_DELETE = 2,
+};
+
+struct LightNode {
+  ShadowView previous;
+  ShadowView current;
+  ExitingState state = ExitingState::UNDEFINED;
+  std::weak_ptr<LightNode> parent;
+  std::vector<std::shared_ptr<LightNode>> children;
+  int removeChild(std::shared_ptr<LightNode> child) {
+    for (int i = children.size() - 1; i >= 0; i--) {
+      if (children[i]->current.tag == child->current.tag) {
+        children.erase(children.begin() + i);
+        return i;
+      }
+    }
+    return -1;
+  }
 };
 
 struct SurfaceManager {
-  mutable std::unordered_map<
-      SurfaceId,
-      std::shared_ptr<std::unordered_map<Tag, UpdateValues>>>
-      props_;
+  mutable std::unordered_map<SurfaceId, std::shared_ptr<std::unordered_map<Tag, UpdateValues>>> props_;
   mutable std::unordered_map<SurfaceId, Rect> windows_;
 
   std::unordered_map<Tag, UpdateValues> &getUpdateMap(SurfaceId surfaceId);
-  void
-  updateWindow(SurfaceId surfaceId, double windowWidth, double windowHeight);
+  void updateWindow(SurfaceId surfaceId, double windowWidth, double windowHeight);
   Rect getWindow(SurfaceId surfaceId);
 };
 
-static inline void updateLayoutMetrics(
-    LayoutMetrics &layoutMetrics,
-    Frame &frame) {
+static inline void updateLayoutMetrics(LayoutMetrics &layoutMetrics, const Frame &frame) {
   // we use optional's here to avoid overwriting non-animated values
   if (frame.width) {
     layoutMetrics.frame.size.width = *frame.width;
@@ -135,42 +122,25 @@ static inline void updateLayoutMetrics(
   }
 }
 
-static inline bool isRNSScreen(std::shared_ptr<MutationNode> node) {
-  return !std::strcmp(
-             node->mutation.oldChildShadowView.componentName,
-             "RNSScreenStack") ||
-      !std::strcmp(
-          node->mutation.oldChildShadowView.componentName, "RNSScreen");
+static inline bool isRNSScreenOrStack(const std::shared_ptr<LightNode> &node) {
+  const auto componentName = node->current.componentName;
+  react_native_assert(componentName && "Component name is nullptr");
+  return !std::strcmp(componentName, "RNSScreenStack") || !std::strcmp(componentName, "RNSScreen") ||
+      !std::strcmp(componentName, "RNSModalScreen");
 }
 
-static inline bool hasLayoutChanged(const ShadowViewMutation &mutation) {
-  return mutation.oldChildShadowView.layoutMetrics.frame !=
-      mutation.newChildShadowView.layoutMetrics.frame;
+static inline bool isRNSScreen(const std::shared_ptr<LightNode> &node) {
+  const auto componentName = node->current.componentName;
+  react_native_assert(componentName && "Component name is nullptr");
+  return !std::strcmp(componentName, "RNSScreen") || !std::strcmp(componentName, "RNSModalScreen");
 }
 
-static inline void mergeAndSwap(
-    std::vector<std::shared_ptr<MutationNode>> &A,
-    std::vector<std::shared_ptr<MutationNode>> &B) {
-  std::vector<std::shared_ptr<MutationNode>> merged;
-  auto it1 = A.begin(), it2 = B.begin();
-  while (it1 != A.end() && it2 != B.end()) {
-    if ((*it1)->mutation.index < (*it2)->mutation.index) {
-      merged.push_back(*it1);
-      it1++;
-    } else {
-      merged.push_back(*it2);
-      it2++;
-    }
-  }
-  while (it1 != A.end()) {
-    merged.push_back(*it1);
-    it1++;
-  }
-  while (it2 != B.end()) {
-    merged.push_back(*it2);
-    it2++;
-  }
-  std::swap(A, merged);
+static inline bool isRoot(const std::shared_ptr<LightNode> &node) {
+  return node->current.tag % 10 == 1;
+}
+
+static inline bool hasLayoutChanged(const ShadowViewMutation &mutation) {
+  return mutation.oldChildShadowView.layoutMetrics.frame != mutation.newChildShadowView.layoutMetrics.frame;
 }
 
 } // namespace reanimated