@react-native-ohos/react-native-reanimated 4.0.2-beta.1 → 4.1.0-beta.1

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

@@ -5,11 +5,11 @@
 #include <react/renderer/scheduler/Scheduler.h>
 #include <react/renderer/uimanager/UIManagerAnimationDelegate.h>
 #include <react/renderer/uimanager/UIManagerBinding.h>
+#include <reanimated/Compat/WorkletsApi.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>
@@ -24,7 +24,7 @@ class ReanimatedModuleProxy;
 
 using namespace facebook;
 
-typedef enum ExitingState_Legacy {
+typedef enum class ExitingState_Legacy : std::uint8_t {
   UNDEFINED = 1,
   WAITING = 2,
   ANIMATING = 4,
@@ -43,13 +43,13 @@ 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 removeChildFromUnflattenedTree(const std::shared_ptr<MutationNode> &child);
+  void applyMutationToIndices(const 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)
+  Node(Node &&node) noexcept
       : 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;
@@ -60,13 +60,13 @@ struct Node {
  */
 struct MutationNode : public Node {
   ShadowViewMutation mutation;
-  ExitingState_Legacy state = UNDEFINED;
+  ExitingState_Legacy state = ExitingState_Legacy::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) {
+static inline bool isRNSScreen(const 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");
@@ -112,29 +112,29 @@ struct LayoutAnimationsProxy_Legacy : public LayoutAnimationsProxyCommon,
   mutable std::unordered_set<SurfaceId> surfacesToRemove_;
 
   LayoutAnimationsProxy_Legacy(
-      std::shared_ptr<LayoutAnimationsManager> layoutAnimationsManager,
-      SharedComponentDescriptorRegistry componentDescriptorRegistry,
-      std::shared_ptr<const ContextContainer> contextContainer,
+      const std::shared_ptr<LayoutAnimationsManager> &layoutAnimationsManager,
+      const SharedComponentDescriptorRegistry &componentDescriptorRegistry,
+      const 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
+      const PreserveMountedTagsFunction &filterUnmountedTagsFunction,
+      const std::shared_ptr<UIManager> &uiManager,
+      const std::shared_ptr<CallInvoker> &jsInvoker
 #endif
       )
       : LayoutAnimationsProxyCommon(
-            std::move(layoutAnimationsManager),
-            std::move(componentDescriptorRegistry),
-            std::move(contextContainer),
+            layoutAnimationsManager,
+            componentDescriptorRegistry,
+            contextContainer,
             uiRuntime,
             uiScheduler
 #ifdef ANDROID
             ,
-            std::move(filterUnmountedTagsFunction),
-            std::move(uiManager),
-            std::move(jsInvoker)
+            filterUnmountedTagsFunction,
+            uiManager,
+            jsInvoker
 #endif
         ) {
   }
@@ -148,6 +148,10 @@ struct LayoutAnimationsProxy_Legacy : public LayoutAnimationsProxyCommon,
   std::optional<SurfaceId> endLayoutAnimation(int tag, bool shouldRemove) override;
   void maybeCancelAnimation(const int tag) const;
 
+  void reconcileContradictedRemovals(
+      ShadowViewMutationList &mutations,
+      ShadowViewMutationList &filteredMutations,
+      SurfaceId surfaceId) const;
   void parseRemoveMutations(
       std::unordered_map<Tag, Tag> &movedViews,
       ShadowViewMutationList &mutations,

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

@@ -1,9 +1,9 @@
 #pragma once
 
-#include <reanimated/LayoutAnimations/LayoutAnimationsManager.h>
-
+#include <react/renderer/components/rnreanimated/Props.h>
 #include <react/renderer/mounting/MountingOverrideDelegate.h>
 #include <react/renderer/mounting/ShadowView.h>
+#include <reanimated/LayoutAnimations/LayoutAnimationsManager.h>
 
 #include <memory>
 #include <unordered_map>
@@ -13,7 +13,7 @@
 
 namespace reanimated {
 
-enum BeforeOrAfter { BEFORE = 0, AFTER = 1 };
+enum BeforeOrAfter : std::uint8_t { BEFORE = 0, AFTER = 1 }; // NOLINT
 
 struct Rect {
   double width, height;
@@ -66,7 +66,7 @@ typedef enum class ExitingState : std::uint8_t {
 
 struct MutationNode;
 
-enum TransitionState {
+enum class TransitionState : std::uint8_t {
   NONE = 0,
   START = 1,
   ACTIVE = 2,
@@ -74,7 +74,7 @@ enum TransitionState {
   CANCELLED = 4,
 };
 
-enum Intent {
+enum class Intent : std::uint8_t {
   NO_INTENT = 0,
   TO_MOVE = 1,
   TO_DELETE = 2,
@@ -86,7 +86,7 @@ struct LightNode {
   ExitingState state = ExitingState::UNDEFINED;
   std::weak_ptr<LightNode> parent;
   std::vector<std::shared_ptr<LightNode>> children;
-  int removeChild(std::shared_ptr<LightNode> child) {
+  int removeChild(const 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);
@@ -135,6 +135,34 @@ static inline bool isRNSScreen(const std::shared_ptr<LightNode> &node) {
   return !std::strcmp(componentName, "RNSScreen") || !std::strcmp(componentName, "RNSModalScreen");
 }
 
+static inline std::shared_ptr<LightNode> findParentRNSScreen(const std::shared_ptr<LightNode> &node) {
+  auto current = node->parent.lock();
+  while (current && !isRNSScreen(current)) {
+    current = current->parent.lock();
+  }
+  return current;
+}
+
+static inline bool isSETBoundary(const std::shared_ptr<LightNode> &node) {
+  return !std::strcmp(node->current.componentName, "REASharedTransitionBoundary");
+}
+
+static inline bool isBoundaryActive(const std::shared_ptr<LightNode> &node) {
+  auto boundaryProps = std::static_pointer_cast<const REASharedTransitionBoundaryProps>(node->current.props);
+  return boundaryProps->isActive;
+}
+
+static inline bool isInsideInactiveBoundary(const std::shared_ptr<LightNode> &node) {
+  auto current = node->parent.lock();
+  while (current) {
+    if (isSETBoundary(current)) {
+      return !isBoundaryActive(current);
+    }
+    current = current->parent.lock();
+  }
+  return false;
+}
+
 static inline bool isRoot(const std::shared_ptr<LightNode> &node) {
   return node->current.tag % 10 == 1;
 }

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

@@ -1,48 +1,48 @@
+#include <folly/dynamic.h>
+#include <react/renderer/components/rnreanimated/Props.h>
 #include <react/renderer/components/scrollview/ScrollViewState.h>
 #include <reanimated/LayoutAnimations/LayoutAnimationsProxy_Experimental.h>
+#include <reanimated/LayoutAnimations/LayoutAnimationsUtils.h>
 #include <reanimated/Tools/ReanimatedSystraceSection.h>
-#ifndef ANDROID
-#if __has_include(<react/renderer/components/rnscreens/Props.h>)
-#define HAS_SCREENS_PROPS
-#include <react/renderer/components/rnscreens/Props.h>
-#endif
-#endif // !ANDROID
-
-#include <folly/dynamic.h>
-
 #include <ranges>
 
 namespace reanimated {
 
 // MARK: Shared Element Transitions
 
-std::shared_ptr<LightNode> LayoutAnimationsProxy_Experimental::findTopScreen(
+// A boundary is active when its `isActive` prop (controlled from JS,
+// e.g. with `useIsFocused`) is true and it's not currently exiting.
+std::shared_ptr<LightNode> LayoutAnimationsProxy_Experimental::findActiveBoundary(
     const std::shared_ptr<LightNode> &node) const {
   std::shared_ptr<LightNode> result = nullptr;
-  // TODO: We could get rid of the RNScreens c++ dependency if we create a custom native component that would be a boundary for Shared Element Transitions.
-  // This way we could allow for transitions without screens, and across components on the same screen.
-  if (isRNSScreen(node)) {
-    bool isActive = false;
-#ifdef ANDROID
-    // TODO (future): this looks like a RNScreens bug - sometimes there is no active
-    // screen at a deeper level, when going back (uncomment the following when fixed)
-    // float f = node->current.props->rawProps.getDefault("activityState",
-    // 0).asDouble(); isActive = f == 2.0f;
-    isActive = true;
-#elif defined(HAS_SCREENS_PROPS)
-    isActive = std::static_pointer_cast<const RNSScreenProps>(node->current.props)->activityState == 2.0f;
-#endif
-    if (isActive) {
-      result = node;
+
+  if (isSETBoundary(node) && isBoundaryActive(node) && node->state == ExitingState::UNDEFINED) {
+    return node;
+  }
+  for (const auto &child : std::views::reverse(node->children)) {
+    auto top = findActiveBoundary(child);
+    if (top) {
+      return top;
     }
   }
-    for (auto it = node->children.rbegin(); it != node->children.rend(); ++it) {
-        const auto& child = *it;
-        auto top = findTopScreen(child);
-        if (top) {
-          return top;
-        }
+
+  return result;
+}
+
+std::shared_ptr<LightNode> LayoutAnimationsProxy_Experimental::findBoundaryGuess(
+    const std::shared_ptr<LightNode> &node) const {
+  std::shared_ptr<LightNode> result = nullptr;
+
+  if (isSETBoundary(node)) {
+    result = node;
+  }
+  for (const auto &child : std::views::reverse(node->children)) {
+    auto top = findBoundaryGuess(child);
+    if (top) {
+      return top;
     }
+  }
+
   return result;
 }
 
@@ -62,9 +62,11 @@ void LayoutAnimationsProxy_Experimental::findSharedElementsOnScreen(
     auto newTransform = parseParentTransforms(node, absolutePositions);
     const auto &parent = node->parent.lock();
     react_native_assert(parent && "Parent node is nullptr");
-    transform[index] = std::move(newTransform);
-    snapshot[index] = copy;
-    parentTag[index] = parent->current.tag;
+
+    int indexNum = static_cast<int>(index);
+    transform[indexNum] = std::move(newTransform);
+    snapshot[indexNum] = copy;
+    parentTag[indexNum] = parent->current.tag;
 
     if (parentTag[BEFORE] && parentTag[AFTER]) {
       transitions_.emplace_back(sharedTag, transition);
@@ -88,14 +90,14 @@ void LayoutAnimationsProxy_Experimental::handleProgressTransition(
   }
   transitionUpdated_ = false;
 
-  if (!mutations.empty() || !transitionState_) {
+  if (!mutations.empty() || !static_cast<bool>(transitionState_)) {
     return;
   }
 
-  if (transitionState_ == START) {
+  if (transitionState_ == TransitionState::START) {
     auto root = lightNodes_[surfaceId];
     auto beforeTopScreen = topScreen[surfaceId];
-    auto afterTopScreen = lightNodes_[transitionTag_];
+    auto afterTopScreen = findBoundaryGuess(lightNodes_[transitionTag_]);
     if (beforeTopScreen && afterTopScreen && beforeTopScreen != afterTopScreen) {
       findSharedElementsOnScreen(beforeTopScreen, BEFORE, propsParserContext);
       findSharedElementsOnScreen(afterTopScreen, AFTER, propsParserContext);
@@ -119,7 +121,7 @@ void LayoutAnimationsProxy_Experimental::handleProgressTransition(
         startProgressTransition(containerTag, before, after, surfaceId);
       }
     }
-  } else if (transitionState_ == ACTIVE) {
+  } else if (transitionState_ == TransitionState::ACTIVE) {
     for (auto tag : activeTransitions_) {
       auto layoutAnimation = layoutAnimations_[tag];
       auto &updateMap = surfaceManager.getUpdateMap(layoutAnimation.finalView.surfaceId);
@@ -153,23 +155,22 @@ void LayoutAnimationsProxy_Experimental::handleProgressTransition(
     }
   }
 
-  if (transitionState_ == START) {
-    transitionState_ = ACTIVE;
-  } else if (transitionState_ == END || transitionState_ == CANCELLED) {
+  if (transitionState_ == TransitionState::START) {
+    transitionState_ = TransitionState::ACTIVE;
+  } else if (transitionState_ == TransitionState::END || transitionState_ == TransitionState::CANCELLED) {
     for (auto tag : activeTransitions_) {
       sharedContainersToRemove_.push_back(tag);
       tagsToRestore_.push_back(restoreMap_[tag][AFTER]);
-      if (transitionState_ == CANCELLED) {
+      if (transitionState_ == TransitionState::CANCELLED) {
         tagsToRestore_.push_back(restoreMap_[tag][BEFORE]);
       }
     }
-    if (transitionState_ == END) {
-      topScreen[surfaceId] = lightNodes_[transitionTag_];
+    if (transitionState_ == TransitionState::END) {
       synchronized_ = false;
     }
     sharedTransitionManager_->containerTags_.clear();
     activeTransitions_.clear();
-    transitionState_ = NONE;
+    transitionState_ = TransitionState::NONE;
   }
 }
 
@@ -206,7 +207,11 @@ Tag LayoutAnimationsProxy_Experimental::getOrCreateContainer(
     ShadowViewMutationList &filteredMutations,
     SurfaceId surfaceId) const {
   auto containerTag = sharedTransitionManager_->containerTags_[sharedTag];
-  auto shouldCreateContainer = (containerTag == -1 || !layoutAnimations_.contains(containerTag));
+  auto shouldCreateContainer = true;
+  if (containerTag != -1) {
+    const auto layoutAnimationIt = layoutAnimations_.find(containerTag);
+    shouldCreateContainer = layoutAnimationIt == layoutAnimations_.end() || layoutAnimationIt->second.isSettled();
+  }
 
   if (shouldCreateContainer) {
     containerTag = containerTag_;
@@ -260,11 +265,12 @@ void LayoutAnimationsProxy_Experimental::handleSharedTransitionsStart(
       auto &[_, after] = transition.snapshot;
 
       auto containerTag = sharedTransitionManager_->containerTags_[sharedTag];
-      if (!layoutAnimations_.contains(containerTag)) {
+      const auto layoutAnimationIt = layoutAnimations_.find(containerTag);
+      if (layoutAnimationIt == layoutAnimations_.end() || layoutAnimationIt->second.isSettled()) {
         continue;
       }
       after.tag = containerTag;
-      const auto &la = layoutAnimations_[containerTag];
+      const auto &la = layoutAnimationIt->second;
       if (la.finalView.layoutMetrics != after.layoutMetrics) {
         overrideTransform(after, transition.transform[AFTER], propsParserContext);
         startSharedTransition(containerTag, la.currentView, after, surfaceId);
@@ -278,8 +284,9 @@ void LayoutAnimationsProxy_Experimental::hideTransitioningViews(
     ShadowViewMutationList &filteredMutations,
     const PropsParserContext &propsParserContext) const {
   for (auto &[sharedTag, transition] : transitions_) {
-    const auto &shadowView = transition.snapshot[index];
-    const auto &parentTag = transition.parentTag[index];
+    int indexNum = static_cast<int>(index);
+    const auto &shadowView = transition.snapshot[indexNum];
+    const auto &parentTag = transition.parentTag[indexNum];
     auto m = ShadowViewMutation::UpdateMutation(
         shadowView, cloneViewWithoutOpacity(shadowView, propsParserContext), parentTag);
     filteredMutations.push_back(m);
@@ -301,13 +308,16 @@ std::optional<SurfaceId> LayoutAnimationsProxy_Experimental::onTransitionProgres
 #endif
   // TODO (future): this new approach causes all back transitions to be progress
   // transitions (maybe that's ok?)
+  if (isClosing && !isGoingForward && !isAndroid) {
+    closingScreenTag_ = tag;
+  }
   if (!isClosing && !isGoingForward && !isAndroid) {
     transitionProgress_ = progress;
-    if (transitionState_ == NONE && progress < 1) {
-      transitionState_ = START;
+    if (transitionState_ == TransitionState::NONE && progress < 1) {
+      transitionState_ = TransitionState::START;
       transitionTag_ = tag;
-    } else if (transitionState_ == ACTIVE && progress == 1) {
-      transitionState_ = END;
+    } else if (transitionState_ == TransitionState::ACTIVE && progress == 1) {
+      transitionState_ = TransitionState::END;
     }
     const auto &node = lightNodes_[tag];
     react_native_assert(node && "LightNode is nullptr");
@@ -320,8 +330,8 @@ std::optional<SurfaceId> LayoutAnimationsProxy_Experimental::onTransitionProgres
 
 std::optional<SurfaceId> LayoutAnimationsProxy_Experimental::onGestureCancel() {
   auto lock = std::unique_lock<std::recursive_mutex>(mutex);
-  if (transitionState_) {
-    transitionState_ = CANCELLED;
+  if (static_cast<bool>(transitionState_)) {
+    transitionState_ = TransitionState::CANCELLED;
     transitionUpdated_ = true;
     react_native_assert(transitioningSurfaceId_ != -1 && "Cancelling non-observed transition");
 
@@ -467,15 +477,12 @@ std::optional<Transform> LayoutAnimationsProxy_Experimental::parseParentTransfor
     combinedMatrix.operations.clear();
   }
   if (parentHasTransform) {
-      react::TransformOperation transformOp {
-        react::TransformOperationType::Arbitrary,
-        {},
-        {},
-        {}
-    };    
-        
+    // OHOS patch: brace-initialize the TransformOperation aggregate —
+    // clang 15 doesn't apply parenthesized aggregate initialization (P0960)
+    // in functional-style casts, so TransformOperation(...) fails with
+    // "no matching conversion". Braces are equivalent here.
     return Transform::FromTransformOperation(
-        transformOp, {}, combinedMatrix);
+        react::TransformOperation{TransformOperationType::Arbitrary}, {}, combinedMatrix);
   }
 
   return {};