@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_Experimental.cpp

@@ -1,10 +1,6 @@
-#include <glog/logging.h>
-#include <react/renderer/animations/utils.h>
-#include <react/renderer/core/ConcreteState.h>
 #include <react/renderer/mounting/ShadowViewMutation.h>
 #include <reanimated/LayoutAnimations/LayoutAnimationsProxy_Experimental.h>
 #include <reanimated/LayoutAnimations/PropsDiffer.h>
-#include <reanimated/NativeModules/ReanimatedModuleProxy.h>
 #include <reanimated/Tools/ReanimatedSystraceSection.h>
 
 #include <algorithm>
@@ -32,17 +28,17 @@ std::optional<MountingTransaction> LayoutAnimationsProxy_Experimental::pullTrans
   ShadowViewMutationList filteredMutations;
   auto rootChildCount = static_cast<int>(lightNodes_[surfaceId]->children.size());
   const std::vector<std::shared_ptr<MutationNode>> roots;
-  const bool isInTransition = transitionState_;
+  const bool isInTransition = static_cast<bool>(transitionState_);
 
   if (isInTransition) {
     updateLightTree(propsParserContext, mutations, filteredMutations);
     handleProgressTransition(filteredMutations, mutations, propsParserContext, surfaceId);
   } else if (!synchronized_) {
-    auto actualTop = topScreen[surfaceId];
     updateLightTree(propsParserContext, mutations, filteredMutations);
-    auto reactTop = findTopScreen(lightNodes_[surfaceId]);
-    if (reactTop == actualTop) {
+    if (!lightNodes_.contains(closingScreenTag_)) {
+      topScreen[surfaceId] = findActiveBoundary(lightNodes_[surfaceId]);
       synchronized_ = true;
+      closingScreenTag_ = -1;
     }
   } else if (!mutations.empty()) {
     auto root = lightNodes_[surfaceId];
@@ -55,13 +51,19 @@ std::optional<MountingTransaction> LayoutAnimationsProxy_Experimental::pullTrans
 
     updateLightTree(propsParserContext, mutations, filteredMutations);
 
-    auto afterTopScreen = findTopScreen(root);
+    auto afterTopScreen = findActiveBoundary(root);
     topScreen[surfaceId] = afterTopScreen;
     if (afterTopScreen) {
       ReanimatedSystraceSection s("find after elements");
       findSharedElementsOnScreen(afterTopScreen, AFTER, propsParserContext);
 #ifdef __APPLE__
-      forceScreenSnapshot_(afterTopScreen->current.tag);
+      // TODO (future): this is a temporary workaround for RNScreens on iOS,
+      // which takes the snapshot of the popped screen before we hide the
+      // shared element, the issue should be gone with the new stack
+      // implementation
+      if (auto screen = findParentRNSScreen(afterTopScreen)) {
+        forceScreenSnapshot_(screen->current.tag);
+      }
 #endif
     }
     const bool hasScreenChanged = beforeTopScreen && afterTopScreen && beforeTopScreen != afterTopScreen;
@@ -151,7 +153,8 @@ void LayoutAnimationsProxy_Experimental::updateLightTree(
         react_native_assert(node && "LightNode not found");
         node->previous = mutation.oldChildShadowView;
 #ifdef ANDROID
-        // TODO (future): We don't merge the root view as the currently stored version might not be accurate, because of the inconsequential initialization order of proxy and the surface
+        // TODO (future): We don't merge the root view as the currently stored version might not be accurate, because of
+        // the inconsequential initialization order of proxy and the surface
         if (!isRoot(node) && node->current.props) {
           // On android rawProps are used to store the diffed props so we need to merge them
           // This should soon be replaced in RN with Props 2.0 (the diffing will be done at the end of the pipeline)
@@ -201,6 +204,30 @@ void LayoutAnimationsProxy_Experimental::updateLightTree(
         } else if (layoutAnimationsManager_->hasLayoutAnimation(tag, ENTERING)) {
           entering_.push_back(node);
           filteredMutations.push_back(mutation);
+          // [OHOS patch] Mirror LayoutAnimationsProxy_Legacy: hide the entering
+          // view in the same transaction (Insert + Update with opacity 0).
+          // Experimental otherwise passes the Insert through with final props
+          // and only hides the view once the animation's first frame arrives
+          // via the async pipeline (scheduleOnUI -> startLayoutAnimation ->
+          // progressLayoutAnimation), which on OHOS can span a vsync — the
+          // view flashes at its final state before the animation starts.
+          // maybeRestoreOpacity in progressLayoutAnimation restores the
+          // original opacity for entering animations that don't animate it
+          // (the original opacity is stored in startEnteringAnimation).
+          filteredMutations.push_back(ShadowViewMutation::UpdateMutation(
+              mutation.newChildShadowView,
+              cloneViewWithoutOpacity(mutation.newChildShadowView, propsParserContext),
+              mutation.parentTag));
+        } else if (sharedTransitionManager_->tagToName_.contains(tag)) {
+          const bool insideInactiveBoundary = isInsideInactiveBoundary(node);
+          if (insideInactiveBoundary) {
+            filteredMutations.push_back(mutation);
+            auto hiddenView = cloneViewWithoutOpacity(mutation.newChildShadowView, propsParserContext);
+            filteredMutations.push_back(
+                ShadowViewMutation::UpdateMutation(mutation.newChildShadowView, hiddenView, mutation.parentTag));
+          } else {
+            filteredMutations.push_back(mutation);
+          }
         } else {
           filteredMutations.push_back(mutation);
         }
@@ -279,11 +306,10 @@ std::optional<SurfaceId> LayoutAnimationsProxy_Experimental::endLayoutAnimation(
   // one after the other, so we need to keep count of how many
   // were actually triggered, so that we don't cleanup necessary
   // structures too early
-  if (layoutAnimation.count > 1) {
-    layoutAnimation.count--;
+  if (--layoutAnimation.count > 0) {
     return {};
   }
-  finishedAnimationTags_.push_back(tag);
+  maybeSettledAnimationTags_.insert(tag);
   auto surfaceId = layoutAnimation.finalView.surfaceId;
 
   if (sharedTransitionManager_->tagToName_.contains(tag)) {
@@ -328,9 +354,10 @@ void LayoutAnimationsProxy_Experimental::handleRemovals(
       react_native_assert(parent && "Parent node is nullptr");
       // TODO (future): figure out a better way to handle this
       // Currently we remove each view, and then if we want to animate it, reinsert it at the end.
-      // This is nice, but introduces extra mutations (which could have some side effects, like making a snapshot in RNScreens),
-      // and it changes the zIndex of animated views, which is different from what've had.
-      // The biggest convenience of this approach is that it is much easier to maintain indices of animated views, and handle reparentings.
+      // This is nice, but introduces extra mutations (which could have some side effects, like making a snapshot in
+      // RNScreens), and it changes the zIndex of animated views, which is different from what've had. The biggest
+      // convenience of this approach is that it is much easier to maintain indices of animated views, and handle
+      // reparentings.
 
       auto current = node->current;
       if (layoutAnimations_.contains(node->current.tag)) {
@@ -399,7 +426,7 @@ void LayoutAnimationsProxy_Experimental::addOngoingAnimations(SurfaceId surfaceI
 
     const auto layoutAnimationIt = layoutAnimations_.find(tag);
 
-    if (layoutAnimationIt == layoutAnimations_.end()) {
+    if (layoutAnimationIt == layoutAnimations_.end() || layoutAnimationIt->second.isSettled()) {
       continue;
     }
 
@@ -518,11 +545,10 @@ bool LayoutAnimationsProxy_Experimental::startAnimationsRecursively(
 
   if (hasExitAnimation) {
     node->state = ANIMATING;
-    startExitingAnimation(node);
     lightNodes_[node->current.tag] = node;
+    startExitingAnimation(node);
   } else {
-    // TODO (future): add proper cleanup
-    //    layoutAnimationsManager_->clearLayoutAnimationConfig(node->tag);
+    layoutAnimationsManager_->clearLayoutAnimationConfig(node->current.tag);
   }
 
   return wantAnimateExit;
@@ -534,11 +560,23 @@ void LayoutAnimationsProxy_Experimental::updateOngoingAnimationTarget(const int
 }
 
 void LayoutAnimationsProxy_Experimental::maybeCancelAnimation(const int tag) const {
-  if (!layoutAnimations_.contains(tag)) {
+#ifdef ANDROID
+  // also invalidate animation starts that are scheduled but haven't run yet,
+  // so they don't re-create the animation after this cancellation
+  if (const auto it = pendingStarts_.find(tag); it != pendingStarts_.end()) {
+    it->second.handle++;
+  }
+#endif
+  const auto layoutAnimationIt = layoutAnimations_.find(tag);
+  if (layoutAnimationIt == layoutAnimations_.end()) {
     return;
   }
-  layoutAnimations_.erase(tag);
-  uiScheduler_->scheduleOnUI([weakThis = weak_from_this(), tag]() {
+  if (layoutAnimationIt->second.isSettled()) {
+    // Already settled - cleanupAnimations will erase it together with its updateMap entry.
+    return;
+  }
+  layoutAnimations_.erase(layoutAnimationIt);
+  scheduleOnUI(uiScheduler_, [weakThis = weak_from_this(), tag]() {
     auto strongThis = weakThis.lock();
     if (!strongThis) {
       return;
@@ -576,6 +614,8 @@ ShadowView LayoutAnimationsProxy_Experimental::cloneViewWithoutOpacity(
   const folly::dynamic opacity = folly::dynamic::object("opacity", 0);
   auto newProps =
       getComponentDescriptorForShadowView(newView).cloneProps(propsParserContext, newView.props, RawProps(opacity));
+  auto viewProps = std::const_pointer_cast<ViewProps>(std::static_pointer_cast<const ViewProps>(newProps));
+  viewProps->opacity = 0;
   newView.props = newProps;
   return newView;
 }
@@ -627,12 +667,17 @@ void LayoutAnimationsProxy_Experimental::cleanupAnimations(
 #ifdef ANDROID
   restoreOpacityInCaseOfFlakyEnteringAnimation(surfaceId);
 #endif // ANDROID
-  for (const auto tag : finishedAnimationTags_) {
-    auto &updateMap = surfaceManager.getUpdateMap(surfaceId);
-    layoutAnimations_.erase(tag);
+  auto &updateMap = surfaceManager.getUpdateMap(surfaceId);
+  for (const auto tag : maybeSettledAnimationTags_) {
+    // Skip tags re-animated since they settled (count back above 0).
+    const auto layoutAnimationIt = layoutAnimations_.find(tag);
+    if (layoutAnimationIt == layoutAnimations_.end() || !layoutAnimationIt->second.isSettled()) {
+      continue;
+    }
+    layoutAnimations_.erase(layoutAnimationIt);
     updateMap.erase(tag);
   }
-  finishedAnimationTags_.clear();
+  maybeSettledAnimationTags_.clear();
 }
 
 // MARK: Start Animation
@@ -678,9 +723,24 @@ void LayoutAnimationsProxy_Experimental::startEnteringAnimation(const std::share
   const auto &parent = node->parent.lock();
   react_native_assert(parent && "Parent node is nullptr");
   const auto parentTag = parent->current.tag;
+#ifdef ANDROID
+  const auto handle = pendingStarts_[newChildShadowView.tag].handle;
+  pendingStarts_[newChildShadowView.tag].count++;
+#endif
 
-  uiScheduler_->scheduleOnUI(
-      [weakThis = weak_from_this(), finalView, currentView, newChildShadowView, parentTag, opacity]() {
+  scheduleOnUI(
+      uiScheduler_,
+      [weakThis = weak_from_this(),
+       finalView,
+       currentView,
+       newChildShadowView,
+       parentTag,
+       opacity
+#ifdef ANDROID
+       ,
+       handle
+#endif
+  ]() {
         auto strongThis = weakThis.lock();
         if (!strongThis) {
           return;
@@ -690,6 +750,12 @@ void LayoutAnimationsProxy_Experimental::startEnteringAnimation(const std::share
         const auto tag = newChildShadowView.tag;
         {
           auto lock = std::unique_lock<std::recursive_mutex>(strongThis->mutex);
+#ifdef ANDROID
+          if (consumeIsCancelled(strongThis->pendingStarts_, tag, handle)) {
+            // the view was removed before this start could run
+            return;
+          }
+#endif
           strongThis->layoutAnimations_[tag] = {
               .finalView = newChildShadowView,
               .currentView = newChildShadowView,
@@ -723,38 +789,63 @@ void LayoutAnimationsProxy_Experimental::startExitingAnimation(const std::shared
   const auto &parent = node->parent.lock();
   react_native_assert(parent && "Parent node is nullptr");
   const auto parentTag = parent->current.tag;
+#ifdef ANDROID
+  const auto handle = pendingStarts_[tag].handle;
+  pendingStarts_[tag].count++;
+#endif
 
-  uiScheduler_->scheduleOnUI([weakThis = weak_from_this(), tag, parentTag, oldChildShadowView, surfaceId]() {
-    auto strongThis = weakThis.lock();
-    if (!strongThis) {
-      return;
-    }
+  scheduleOnUI(
+      uiScheduler_,
+      [weakThis = weak_from_this(),
+       tag,
+       parentTag,
+       oldChildShadowView,
+       surfaceId
+#ifdef ANDROID
+       ,
+       handle
+#endif
+  ]() {
+        auto strongThis = weakThis.lock();
+        if (!strongThis) {
+          return;
+        }
 
-    auto oldView = oldChildShadowView;
-    Rect window{};
-    {
-      auto &mutex = strongThis->mutex;
-      auto lock = std::unique_lock<std::recursive_mutex>(mutex);
-      oldView = strongThis->maybeCreateLayoutAnimation(oldView, oldView, parentTag);
-      window = strongThis->surfaceManager.getWindow(surfaceId);
-    }
+        auto oldView = oldChildShadowView;
+        Rect window{};
+        {
+          auto &mutex = strongThis->mutex;
+          auto lock = std::unique_lock<std::recursive_mutex>(mutex);
+#ifdef ANDROID
+          if (consumeIsCancelled(strongThis->pendingStarts_, tag, handle)) {
+            // the view was removed (e.g. its subtree was force-ended by a screen
+            // pop) before this start could run — its Remove+Delete are already on
+            // their way to the mounting layer, so starting the animation now
+            // would emit updates for a view that's about to be deleted
+            strongThis->layoutAnimationsManager_->clearLayoutAnimationConfig(tag);
+            return;
+          }
+#endif
+          oldView = strongThis->maybeCreateLayoutAnimation(oldView, oldView, parentTag);
+          window = strongThis->surfaceManager.getWindow(surfaceId);
+        }
 
-    const Snapshot values(oldView, window);
+        const Snapshot values(oldView, window);
 
-    auto &uiRuntime = strongThis->uiRuntime_;
-    const jsi::Object yogaValues(uiRuntime);
-    yogaValues.setProperty(uiRuntime, "currentOriginX", values.x);
-    yogaValues.setProperty(uiRuntime, "currentGlobalOriginX", values.x);
-    yogaValues.setProperty(uiRuntime, "currentOriginY", values.y);
-    yogaValues.setProperty(uiRuntime, "currentGlobalOriginY", values.y);
-    yogaValues.setProperty(uiRuntime, "currentWidth", values.width);
-    yogaValues.setProperty(uiRuntime, "currentHeight", values.height);
-    yogaValues.setProperty(uiRuntime, "windowWidth", values.windowWidth);
-    yogaValues.setProperty(uiRuntime, "windowHeight", values.windowHeight);
-    strongThis->layoutAnimationsManager_->startLayoutAnimation(
-        uiRuntime, tag, LayoutAnimationType::EXITING, yogaValues);
-    strongThis->layoutAnimationsManager_->clearLayoutAnimationConfig(tag);
-  });
+        auto &uiRuntime = strongThis->uiRuntime_;
+        const jsi::Object yogaValues(uiRuntime);
+        yogaValues.setProperty(uiRuntime, "currentOriginX", values.x);
+        yogaValues.setProperty(uiRuntime, "currentGlobalOriginX", values.x);
+        yogaValues.setProperty(uiRuntime, "currentOriginY", values.y);
+        yogaValues.setProperty(uiRuntime, "currentGlobalOriginY", values.y);
+        yogaValues.setProperty(uiRuntime, "currentWidth", values.width);
+        yogaValues.setProperty(uiRuntime, "currentHeight", values.height);
+        yogaValues.setProperty(uiRuntime, "windowWidth", values.windowWidth);
+        yogaValues.setProperty(uiRuntime, "windowHeight", values.windowHeight);
+        strongThis->layoutAnimationsManager_->startLayoutAnimation(
+            uiRuntime, tag, LayoutAnimationType::EXITING, yogaValues);
+        strongThis->layoutAnimationsManager_->clearLayoutAnimationConfig(tag);
+      });
 }
 
 void LayoutAnimationsProxy_Experimental::startLayoutAnimation(const std::shared_ptr<LightNode> &node) const {
@@ -765,9 +856,24 @@ void LayoutAnimationsProxy_Experimental::startLayoutAnimation(const std::shared_
   const auto &parent = node->parent.lock();
   react_native_assert(parent && "Parent node is nullptr");
   const auto parentTag = parent->current.tag;
+#ifdef ANDROID
+  const auto handle = pendingStarts_[tag].handle;
+  pendingStarts_[tag].count++;
+#endif
 
-  uiScheduler_->scheduleOnUI(
-      [weakThis = weak_from_this(), surfaceId, oldChildShadowView, newChildShadowView, parentTag, tag]() {
+  scheduleOnUI(
+      uiScheduler_,
+      [weakThis = weak_from_this(),
+       surfaceId,
+       oldChildShadowView,
+       newChildShadowView,
+       parentTag,
+       tag
+#ifdef ANDROID
+       ,
+       handle
+#endif
+  ]() {
         auto strongThis = weakThis.lock();
         if (!strongThis) {
           return;
@@ -778,6 +884,12 @@ void LayoutAnimationsProxy_Experimental::startLayoutAnimation(const std::shared_
         {
           auto &mutex = strongThis->mutex;
           auto lock = std::unique_lock<std::recursive_mutex>(mutex);
+#ifdef ANDROID
+          if (consumeIsCancelled(strongThis->pendingStarts_, tag, handle)) {
+            // the view was removed before this start could run
+            return;
+          }
+#endif
           oldView = strongThis->maybeCreateLayoutAnimation(oldView, newChildShadowView, parentTag);
           window = strongThis->surfaceManager.getWindow(surfaceId);
         }
@@ -811,7 +923,7 @@ void LayoutAnimationsProxy_Experimental::startSharedTransition(
     const ShadowView &before,
     const ShadowView &after,
     SurfaceId surfaceId) const {
-  uiScheduler_->scheduleOnUI([weakThis = weak_from_this(), before, after, surfaceId, tag]() {
+  scheduleOnUI(uiScheduler_, [weakThis = weak_from_this(), before, after, surfaceId, tag]() {
     auto strongThis = weakThis.lock();
     if (!strongThis) {
       return;
@@ -844,7 +956,7 @@ void LayoutAnimationsProxy_Experimental::startProgressTransition(
     const ShadowView &before,
     const ShadowView &after,
     SurfaceId surfaceId) const {
-  uiScheduler_->scheduleOnUI([weakThis = weak_from_this(), before, after, surfaceId]() {
+  scheduleOnUI(uiScheduler_, [weakThis = weak_from_this(), before, after, surfaceId]() {
     auto strongThis = weakThis.lock();
     if (!strongThis) {
       return;

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

@@ -1,12 +1,11 @@
 #pragma once
 
+#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 <react/renderer/componentregistry/ComponentDescriptorFactory.h>
 #include <react/renderer/graphics/Transform.h>
 #include <react/renderer/mounting/MountingOverrideDelegate.h>
@@ -44,7 +43,7 @@ struct LayoutAnimationsProxy_Experimental : public LayoutAnimationsProxyCommon,
   mutable Tag transitionTag_;
   mutable double transitionProgress_;
   mutable bool transitionUpdated_;
-  mutable TransitionState transitionState_ = NONE;
+  mutable TransitionState transitionState_ = TransitionState::NONE;
   mutable SurfaceId transitioningSurfaceId_ = -1;
   mutable std::unordered_map<SurfaceId, std::shared_ptr<LightNode>> topScreen;
   mutable int containerTag_ = 10000002;
@@ -54,6 +53,7 @@ struct LayoutAnimationsProxy_Experimental : public LayoutAnimationsProxyCommon,
   mutable TransitionMap transitionMap_;
   mutable Transitions transitions_;
   mutable bool synchronized_ = true;
+  mutable Tag closingScreenTag_ = -1;
   mutable std::vector<std::shared_ptr<LightNode>> entering_, layout_, exiting_;
   std::shared_ptr<SharedTransitionManager> sharedTransitionManager_;
   mutable std::unordered_map<Tag, std::shared_ptr<LightNode>> lightNodes_;
@@ -63,16 +63,16 @@ struct LayoutAnimationsProxy_Experimental : public LayoutAnimationsProxyCommon,
   mutable ForceScreenSnapshotFunction forceScreenSnapshot_;
 
   LayoutAnimationsProxy_Experimental(
-      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
+      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(
@@ -146,7 +146,8 @@ struct LayoutAnimationsProxy_Experimental : public LayoutAnimationsProxyCommon,
 
   void maybeCancelAnimation(const int tag) const;
 
-  std::shared_ptr<LightNode> findTopScreen(const std::shared_ptr<LightNode> &node) const;
+  std::shared_ptr<LightNode> findActiveBoundary(const std::shared_ptr<LightNode> &node) const;
+  std::shared_ptr<LightNode> findBoundaryGuess(const std::shared_ptr<LightNode> &node) const;
 
   void findSharedElementsOnScreen(
       const std::shared_ptr<LightNode> &node,