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

package/harmony/reanimated/src/main/cpp/Common/cpp/reanimated/Fabric/updates/propNameFromString.h

@@ -0,0 +1,130 @@
+#pragma once
+
+#include <cxxreact/ReactNativeVersion.h>
+
+#if REACT_NATIVE_VERSION_MINOR >= 85
+#include <react/renderer/animationbackend/AnimationBackend.h>
+
+#include <optional>
+#include <string>
+#include <unordered_map>
+
+namespace reanimated {
+
+inline std::optional<facebook::react::PropName> propNameFromString(const std::string &propName) {
+  static const std::unordered_map<std::string, facebook::react::PropName> propNameMap = {
+      {"opacity", facebook::react::OPACITY},
+      {"width", facebook::react::WIDTH},
+      {"height", facebook::react::HEIGHT},
+      {"borderRadius", facebook::react::BORDER_RADII},
+      {"borderTopRightRadius", facebook::react::BORDER_RADII},
+      {"borderTopLeftRadius", facebook::react::BORDER_RADII},
+      {"borderBottomRightRadius", facebook::react::BORDER_RADII},
+      {"borderBottomLeftRadius", facebook::react::BORDER_RADII},
+      {"borderTopStartRadius", facebook::react::BORDER_RADII},
+      {"borderTopEndRadius", facebook::react::BORDER_RADII},
+      {"borderBottomStartRadius", facebook::react::BORDER_RADII},
+      {"borderBottomEndRadius", facebook::react::BORDER_RADII},
+      {"borderStartStartRadius", facebook::react::BORDER_RADII},
+      {"borderStartEndRadius", facebook::react::BORDER_RADII},
+      {"borderEndStartRadius", facebook::react::BORDER_RADII},
+      {"borderEndEndRadius", facebook::react::BORDER_RADII},
+      {"borderWidth", facebook::react::BORDER_WIDTH},
+      {"borderBottomWidth", facebook::react::BORDER_WIDTH},
+      {"borderTopWidth", facebook::react::BORDER_WIDTH},
+      {"borderLeftWidth", facebook::react::BORDER_WIDTH},
+      {"borderRightWidth", facebook::react::BORDER_WIDTH},
+      {"borderStartWidth", facebook::react::BORDER_WIDTH},
+      {"borderEndWidth", facebook::react::BORDER_WIDTH},
+      {"borderColor", facebook::react::BORDER_COLOR},
+      {"borderEndColor", facebook::react::BORDER_COLOR},
+      {"borderStartColor", facebook::react::BORDER_COLOR},
+      {"borderLeftColor", facebook::react::BORDER_COLOR},
+      {"borderRightColor", facebook::react::BORDER_COLOR},
+      {"borderTopColor", facebook::react::BORDER_COLOR},
+      {"borderBottomColor", facebook::react::BORDER_COLOR},
+      {"borderBlockColor", facebook::react::BORDER_COLOR},
+      {"borderBlockEndColor", facebook::react::BORDER_COLOR},
+      {"borderBlockStartColor", facebook::react::BORDER_COLOR},
+      {"margin", facebook::react::MARGIN},
+      {"marginTop", facebook::react::MARGIN},
+      {"marginBottom", facebook::react::MARGIN},
+      {"marginLeft", facebook::react::MARGIN},
+      {"marginRight", facebook::react::MARGIN},
+      {"marginStart", facebook::react::MARGIN},
+      {"marginEnd", facebook::react::MARGIN},
+      {"marginHorizontal", facebook::react::MARGIN},
+      {"marginVertical", facebook::react::MARGIN},
+      {"padding", facebook::react::PADDING},
+      {"paddingTop", facebook::react::PADDING},
+      {"paddingBottom", facebook::react::PADDING},
+      {"paddingLeft", facebook::react::PADDING},
+      {"paddingRight", facebook::react::PADDING},
+      {"paddingStart", facebook::react::PADDING},
+      {"paddingEnd", facebook::react::PADDING},
+      {"paddingHorizontal", facebook::react::PADDING},
+      {"paddingVertical", facebook::react::PADDING},
+      {"top", facebook::react::POSITION},
+      {"bottom", facebook::react::POSITION},
+      {"left", facebook::react::POSITION},
+      {"right", facebook::react::POSITION},
+      {"start", facebook::react::POSITION},
+      {"end", facebook::react::POSITION},
+      {"position", facebook::react::POSITION_TYPE},
+      {"flex", facebook::react::FLEX},
+      {"transform", facebook::react::TRANSFORM},
+      {"transformOriginX", facebook::react::TRANSFORM_ORIGIN},
+      {"transformOriginY", facebook::react::TRANSFORM_ORIGIN},
+      {"transformOriginZ", facebook::react::TRANSFORM_ORIGIN},
+      {"backgroundColor", facebook::react::BACKGROUND_COLOR},
+      {"shadowColor", facebook::react::SHADOW_COLOR},
+      {"shadowOffsetWidth", facebook::react::SHADOW_OFFSET},
+      {"shadowOffsetHeight", facebook::react::SHADOW_OFFSET},
+      {"shadowOpacity", facebook::react::SHADOW_OPACITY},
+      {"shadowRadius", facebook::react::SHADOW_RADIUS},
+      {"filter", facebook::react::FILTER},
+      {"outlineColor", facebook::react::OUTLINE_COLOR},
+      {"outlineOffset", facebook::react::OUTLINE_OFFSET},
+      {"outlineStyle", facebook::react::OUTLINE_STYLE},
+      {"outlineWidth", facebook::react::OUTLINE_WIDTH},
+      {"alignContent", facebook::react::ALIGN_CONTENT},
+      {"alignItems", facebook::react::ALIGN_ITEMS},
+      {"alignSelf", facebook::react::ALIGN_SELF},
+      {"aspectRatio", facebook::react::ASPECT_RATIO},
+      {"boxSizing", facebook::react::BOX_SIZING},
+      {"display", facebook::react::DISPLAY},
+      {"flexBasis", facebook::react::FLEX_BASIS},
+      {"flexDirection", facebook::react::FLEX_DIRECTION},
+      {"rowGap", facebook::react::ROW_GAP},
+      {"columnGap", facebook::react::COLUMN_GAP},
+      {"flexGrow", facebook::react::FLEX_GROW},
+      {"flexShrink", facebook::react::FLEX_SHRINK},
+      {"flexWrap", facebook::react::FLEX_WRAP},
+      {"justifyContent", facebook::react::JUSTIFY_CONTENT},
+      {"maxHeight", facebook::react::MAX_HEIGHT},
+      {"maxWidth", facebook::react::MAX_WIDTH},
+      {"minHeight", facebook::react::MIN_HEIGHT},
+      {"minWidth", facebook::react::MIN_WIDTH},
+      {"overflow", facebook::react::STYLE_OVERFLOW},
+      {"zIndex", facebook::react::Z_INDEX},
+      {"direction", facebook::react::DIRECTION},
+      {"borderCurve", facebook::react::BORDER_CURVES},
+      {"borderStyle", facebook::react::BORDER_STYLES},
+      {"pointerEvents", facebook::react::POINTER_EVENTS},
+      {"isolation", facebook::react::ISOLATION},
+      {"cursor", facebook::react::CURSOR},
+      {"boxShadow", facebook::react::BOX_SHADOW},
+      {"mixBlendMode", facebook::react::MIX_BLEND_MODE},
+      {"backfaceVisibility", facebook::react::BACKFACE_VISIBILITY},
+  };
+
+  const auto it = propNameMap.find(propName);
+  if (it == propNameMap.end()) {
+    return std::nullopt;
+  }
+  return it->second;
+}
+
+} // namespace reanimated
+
+#endif

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

@@ -111,6 +111,7 @@ void LayoutAnimationsManager::transferConfigFromNativeID(const int nativeId, con
 }
 
 void LayoutAnimationsManager::transferSharedConfig(const Tag from, const Tag to) {
+  auto lock = std::unique_lock<std::recursive_mutex>(animationsMutex_);
   sharedTransitions_[to] = sharedTransitions_[from];
 }
 

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

@@ -2,11 +2,9 @@
 
 #include <react/renderer/graphics/Transform.h>
 #include <react/renderer/mounting/ShadowView.h>
+#include <reanimated/Compat/WorkletsApi.h>
 #include <reanimated/LayoutAnimations/LayoutAnimationType.h>
 
-#include <worklets/SharedItems/Serializable.h>
-#include <worklets/Tools/JSLogger.h>
-
 #include <jsi/jsi.h>
 #include <stdio.h>
 #include <functional>
@@ -22,6 +20,7 @@
 namespace reanimated {
 
 using namespace facebook;
+using namespace facebook::react;
 using namespace worklets;
 using SharedTag = std::string;
 
@@ -50,8 +49,7 @@ struct LayoutAnimationConfig {
 
 class LayoutAnimationsManager {
  public:
-  explicit LayoutAnimationsManager(const std::shared_ptr<JSLogger> &jsLogger)
-      : jsLogger_(jsLogger), sharedTransitionManager_(std::make_shared<SharedTransitionManager>()) {}
+  LayoutAnimationsManager() : sharedTransitionManager_(std::make_shared<SharedTransitionManager>()) {}
   void configureAnimationBatch(const std::vector<LayoutAnimationConfig> &layoutAnimationsBatch);
   void setShouldAnimateExiting(const int tag, const bool value);
   bool shouldAnimateExiting(const int tag, const bool shouldAnimate);
@@ -66,7 +64,6 @@ class LayoutAnimationsManager {
  private:
   std::unordered_map<int, std::shared_ptr<Serializable>> &getConfigsForType(const LayoutAnimationType type);
 
-  std::shared_ptr<JSLogger> jsLogger_;
   std::shared_ptr<SharedTransitionManager> sharedTransitionManager_;
   std::unordered_map<int, std::shared_ptr<Serializable>> enteringAnimationsForNativeID_;
   std::unordered_map<int, std::shared_ptr<Serializable>> sharedTransitionsForNativeID_;
@@ -75,7 +72,8 @@ class LayoutAnimationsManager {
   std::unordered_map<int, std::shared_ptr<Serializable>> exitingAnimations_;
   std::unordered_map<int, std::shared_ptr<Serializable>> layoutAnimations_;
   std::unordered_map<int, bool> shouldAnimateExitingForTag_;
-  mutable std::recursive_mutex animationsMutex_; // Protects `enteringAnimations_`, `exitingAnimations_`,
+  mutable std::recursive_mutex animationsMutex_; // Protects `enteringAnimationsForNativeID_`,
+  // `sharedTransitionsForNativeID_`, `sharedTransitions_`, `enteringAnimations_`, `exitingAnimations_`,
   // `layoutAnimations_` and `shouldAnimateExitingForTag_`.
 };
 

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

@@ -1,6 +1,5 @@
 #include <ReactCommon/CallInvoker.h>
 #include <folly/dynamic.h>
-#include <react/renderer/uimanager/UIManagerBinding.h>
 #include <reanimated/Fabric/ShadowTreeCloner.h>
 #include <reanimated/LayoutAnimations/LayoutAnimationsProxyCommon.h>
 
@@ -38,8 +37,12 @@ const facebook::react::ShadowNode *findInShadowTreeByTag(const facebook::react::
 
 void LayoutAnimationsProxyCommon::restoreOpacityInCaseOfFlakyEnteringAnimation(SurfaceId surfaceId) const {
   std::vector<std::pair<double, Tag>> opacityToRestore;
-  for (const auto tag : finishedAnimationTags_) {
-    const auto &opacity = layoutAnimations_[tag].opacity;
+  for (const auto tag : maybeSettledAnimationTags_) {
+    const auto layoutAnimationIt = layoutAnimations_.find(tag);
+    if (layoutAnimationIt == layoutAnimations_.end() || !layoutAnimationIt->second.isSettled()) {
+      continue;
+    }
+    const auto &opacity = layoutAnimationIt->second.opacity;
     if (opacity.has_value()) {
       opacityToRestore.emplace_back(std::pair<double, Tag>{opacity.value(), tag});
     }
@@ -64,7 +67,7 @@ void LayoutAnimationsProxyCommon::restoreOpacityInCaseOfFlakyEnteringAnimation(S
             for (const auto &[opacity, tag] : opacityToRestore) {
               const auto *targetShadowNode = findInShadowTreeByTag(rootShadowNode, tag);
               if (targetShadowNode != nullptr) {
-                propsMap[&targetShadowNode->getFamily()].emplace_back(folly::dynamic::object("opacity", opacity));
+                propsMap[targetShadowNode->getFamilyShared()].emplace_back(folly::dynamic::object("opacity", opacity));
               }
             }
             return cloneShadowTreeWithNewProps(oldRootShadowNode, propsMap);

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

@@ -1,16 +1,18 @@
 #pragma once
 
 #include <jsi/jsi.h>
+#include <react/debug/react_native_assert.h>
 #include <react/renderer/componentregistry/ComponentDescriptorFactory.h>
 #include <react/renderer/mounting/MountingOverrideDelegate.h>
 #include <react/renderer/uimanager/UIManager.h>
+#include <reanimated/Compat/WorkletsApi.h>
 #include <reanimated/LayoutAnimations/LayoutAnimationsManager.h>
 #include <reanimated/Tools/PlatformDepMethodsHolder.h>
-#include <worklets/Tools/UIScheduler.h>
 
 #include <memory>
 #include <optional>
 #include <unordered_map>
+#include <unordered_set>
 #include <vector>
 
 namespace reanimated {
@@ -22,21 +24,50 @@ struct LayoutAnimation {
   bool isViewAlreadyMounted = false;
   int count = 1;
   LayoutAnimation &operator=(const LayoutAnimation &other) = default;
+
+  bool isSettled() const {
+    return count == 0;
+  }
+};
+
+#ifdef ANDROID
+// Bookkeeping for animation starts that were scheduled onto the UI thread but
+// haven't run yet — see `pendingStarts_` below.
+struct PendingStart {
+  int count = 0;
+  uint64_t handle = 0;
 };
 
+// Removes one pending start for the given tag and returns whether it was
+// cancelled since it was scheduled (i.e. its handle is no longer current).
+// Call under the proxy mutex.
+inline bool
+consumeIsCancelled(std::unordered_map<Tag, PendingStart> &pendingStarts, const Tag tag, const uint64_t handle) {
+  const auto it = pendingStarts.find(tag);
+  // every scheduled start keeps its entry alive until it is consumed —
+  // cancellations only bump the handle, they never erase
+  react_native_assert(it != pendingStarts.end() && "PendingStart not found");
+  const bool isCancelled = it->second.handle != handle;
+  if (--it->second.count == 0) {
+    pendingStarts.erase(it);
+  }
+  return isCancelled;
+}
+#endif
+
 class LayoutAnimationsProxyCommon : public facebook::react::MountingOverrideDelegate {
  public:
   LayoutAnimationsProxyCommon(
-      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<facebook::react::UIManager> uiManager,
-      std::shared_ptr<facebook::react::CallInvoker> jsInvoker
+      const PreserveMountedTagsFunction &filterUnmountedTagsFunction,
+      const std::shared_ptr<facebook::react::UIManager> &uiManager,
+      const std::shared_ptr<facebook::react::CallInvoker> &jsInvoker
 #endif
       )
       : layoutAnimationsManager_(layoutAnimationsManager),
@@ -60,7 +91,7 @@ class LayoutAnimationsProxyCommon : public facebook::react::MountingOverrideDele
   virtual void startSurface(const SurfaceId surfaceId);
 
  protected:
-  mutable std::vector<Tag> finishedAnimationTags_;
+  mutable std::unordered_set<Tag> maybeSettledAnimationTags_;
   mutable std::unordered_map<Tag, LayoutAnimation> layoutAnimations_;
   std::shared_ptr<LayoutAnimationsManager> layoutAnimationsManager_;
   std::shared_ptr<const ContextContainer> contextContainer_;
@@ -75,6 +106,18 @@ class LayoutAnimationsProxyCommon : public facebook::react::MountingOverrideDele
 
   void restoreOpacityInCaseOfFlakyEnteringAnimation(SurfaceId surfaceId) const;
 
+  // On Android pullTransaction can run on the JS thread, so animation starts
+  // are scheduled onto the UI thread. If `maybeCancelAnimation` is called between the
+  // start was scheduled and the lambda runs, it
+  // finds no `layoutAnimations_` entry to erase (the start lambda hasn't created it
+  // yet) and the cancellation is lost — the stale start would later
+  // "resurrect" the animation for a view whose Remove+Delete are already on
+  // their way to the mounting layer
+  // (https://github.com/software-mansion/react-native-reanimated/issues/7493).
+
+  // To work around this, we keep a separate `pendingStarts_` map that tracks scheduled starts by tag,
+  //  with a generation counter to detect cancellations.
+  mutable std::unordered_map<Tag, PendingStart> pendingStarts_;
 #endif
 };