@react-native-ohos/react-native-reanimated 4.0.1 → 4.0.2

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

@@ -1,137 +1,137 @@
-#include <reanimated/LayoutAnimations/LayoutAnimationsManager.h>
-
-#include <memory>
-#include <unordered_map>
-#include <utility>
-#include <vector>
-
-namespace reanimated {
-
-void LayoutAnimationsManager::configureAnimationBatch(const std::vector<LayoutAnimationConfig> &layoutAnimationsBatch) {
-  auto lock = std::unique_lock<std::recursive_mutex>(animationsMutex_);
-  for (const auto &layoutAnimationConfig : layoutAnimationsBatch) {
-    const auto &[tag, type, config, sharedTag] = layoutAnimationConfig;
-
-    if (type == LayoutAnimationType::ENTERING) {
-      enteringAnimationsForNativeID_[tag] = config;
-      continue;
-    }
-    if (type == LayoutAnimationType::SHARED_ELEMENT_TRANSITION_NATIVE_ID) {
-      sharedTransitionsForNativeID_[tag] = config;
-      sharedTransitionManager_->nativeIDToName_[tag] = sharedTag;
-      continue;
-    }
-    if (type == LayoutAnimationType::SHARED_ELEMENT_TRANSITION) {
-      if (config == nullptr) {
-        // TODO (future): if the view was transitioned (e.g. so we are on the second screen)
-        // and we remove the config, we should also bring back the view (probably using tagsToRestore_)
-        sharedTransitions_.erase(tag);
-        sharedTransitionManager_->tagToName_.erase(tag);
-      } else {
-        sharedTransitions_[tag] = config;
-        sharedTransitionManager_->tagToName_[tag] = sharedTag;
-      }
-      continue;
-    }
-    if (config == nullptr) {
-      getConfigsForType(type).erase(tag);
-    } else {
-      getConfigsForType(type)[tag] = config;
-    }
-  }
-}
-
-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 shouldAnimateExitingForTag_.contains(tag) ? shouldAnimateExitingForTag_[tag] : shouldAnimate;
-}
-
-bool LayoutAnimationsManager::hasLayoutAnimation(const int tag, const LayoutAnimationType type) {
-  auto lock = std::unique_lock<std::recursive_mutex>(animationsMutex_);
-  return getConfigsForType(type).contains(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);
-}
-
-void LayoutAnimationsManager::startLayoutAnimation(
-    jsi::Runtime &rt,
-    const int tag,
-    const LayoutAnimationType type,
-    const jsi::Object &values) {
-  std::shared_ptr<Serializable> config;
-  {
-    auto lock = std::unique_lock<std::recursive_mutex>(animationsMutex_);
-    if (!getConfigsForType(type).contains(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));
-}
-
-void LayoutAnimationsManager::transferConfigFromNativeID(const int nativeId, const int tag) {
-  auto lock = std::unique_lock<std::recursive_mutex>(animationsMutex_);
-  const auto config = enteringAnimationsForNativeID_[nativeId];
-  if (config) {
-    enteringAnimations_.insert_or_assign(tag, config);
-  }
-  enteringAnimationsForNativeID_.erase(nativeId);
-
-  const auto sharedTransitionConfig = sharedTransitionsForNativeID_[nativeId];
-  if (sharedTransitionConfig) {
-    sharedTransitions_.insert_or_assign(tag, sharedTransitionConfig);
-    sharedTransitionManager_->tagToName_[tag] = sharedTransitionManager_->nativeIDToName_[nativeId];
-  }
-  sharedTransitionsForNativeID_.erase(nativeId);
-  sharedTransitionManager_->nativeIDToName_.erase(nativeId);
-}
-
-void LayoutAnimationsManager::transferSharedConfig(const Tag from, const Tag to) {
-  sharedTransitions_[to] = sharedTransitions_[from];
-}
-
-std::shared_ptr<SharedTransitionManager> LayoutAnimationsManager::getSharedTransitionManager() {
-  return sharedTransitionManager_;
-}
-
-std::unordered_map<int, std::shared_ptr<Serializable>> &LayoutAnimationsManager::getConfigsForType(
-    const LayoutAnimationType type) {
-  switch (type) {
-    case LayoutAnimationType::ENTERING:
-      return enteringAnimations_;
-    case LayoutAnimationType::EXITING:
-      return exitingAnimations_;
-    case LayoutAnimationType::LAYOUT:
-      return layoutAnimations_;
-    case LayoutAnimationType::SHARED_ELEMENT_TRANSITION:
-      return sharedTransitions_;
-    default:
-      throw std::invalid_argument("[Reanimated] Unknown layout animation type");
-  }
-}
-
-} // namespace reanimated
+#include <reanimated/LayoutAnimations/LayoutAnimationsManager.h>
+
+#include <memory>
+#include <unordered_map>
+#include <utility>
+#include <vector>
+
+namespace reanimated {
+
+void LayoutAnimationsManager::configureAnimationBatch(const std::vector<LayoutAnimationConfig> &layoutAnimationsBatch) {
+  auto lock = std::unique_lock<std::recursive_mutex>(animationsMutex_);
+  for (const auto &layoutAnimationConfig : layoutAnimationsBatch) {
+    const auto &[tag, type, config, sharedTag] = layoutAnimationConfig;
+
+    if (type == LayoutAnimationType::ENTERING) {
+      enteringAnimationsForNativeID_[tag] = config;
+      continue;
+    }
+    if (type == LayoutAnimationType::SHARED_ELEMENT_TRANSITION_NATIVE_ID) {
+      sharedTransitionsForNativeID_[tag] = config;
+      sharedTransitionManager_->nativeIDToName_[tag] = sharedTag;
+      continue;
+    }
+    if (type == LayoutAnimationType::SHARED_ELEMENT_TRANSITION) {
+      if (config == nullptr) {
+        // TODO (future): if the view was transitioned (e.g. so we are on the second screen)
+        // and we remove the config, we should also bring back the view (probably using tagsToRestore_)
+        sharedTransitions_.erase(tag);
+        sharedTransitionManager_->tagToName_.erase(tag);
+      } else {
+        sharedTransitions_[tag] = config;
+        sharedTransitionManager_->tagToName_[tag] = sharedTag;
+      }
+      continue;
+    }
+    if (config == nullptr) {
+      getConfigsForType(type).erase(tag);
+    } else {
+      getConfigsForType(type)[tag] = config;
+    }
+  }
+}
+
+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 shouldAnimateExitingForTag_.contains(tag) ? shouldAnimateExitingForTag_[tag] : shouldAnimate;
+}
+
+bool LayoutAnimationsManager::hasLayoutAnimation(const int tag, const LayoutAnimationType type) {
+  auto lock = std::unique_lock<std::recursive_mutex>(animationsMutex_);
+  return getConfigsForType(type).contains(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);
+}
+
+void LayoutAnimationsManager::startLayoutAnimation(
+    jsi::Runtime &rt,
+    const int tag,
+    const LayoutAnimationType type,
+    const jsi::Object &values) {
+  std::shared_ptr<Serializable> config;
+  {
+    auto lock = std::unique_lock<std::recursive_mutex>(animationsMutex_);
+    if (!getConfigsForType(type).contains(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));
+}
+
+void LayoutAnimationsManager::transferConfigFromNativeID(const int nativeId, const int tag) {
+  auto lock = std::unique_lock<std::recursive_mutex>(animationsMutex_);
+  const auto config = enteringAnimationsForNativeID_[nativeId];
+  if (config) {
+    enteringAnimations_.insert_or_assign(tag, config);
+  }
+  enteringAnimationsForNativeID_.erase(nativeId);
+
+  const auto sharedTransitionConfig = sharedTransitionsForNativeID_[nativeId];
+  if (sharedTransitionConfig) {
+    sharedTransitions_.insert_or_assign(tag, sharedTransitionConfig);
+    sharedTransitionManager_->tagToName_[tag] = sharedTransitionManager_->nativeIDToName_[nativeId];
+  }
+  sharedTransitionsForNativeID_.erase(nativeId);
+  sharedTransitionManager_->nativeIDToName_.erase(nativeId);
+}
+
+void LayoutAnimationsManager::transferSharedConfig(const Tag from, const Tag to) {
+  sharedTransitions_[to] = sharedTransitions_[from];
+}
+
+std::shared_ptr<SharedTransitionManager> LayoutAnimationsManager::getSharedTransitionManager() {
+  return sharedTransitionManager_;
+}
+
+std::unordered_map<int, std::shared_ptr<Serializable>> &LayoutAnimationsManager::getConfigsForType(
+    const LayoutAnimationType type) {
+  switch (type) {
+    case LayoutAnimationType::ENTERING:
+      return enteringAnimations_;
+    case LayoutAnimationType::EXITING:
+      return exitingAnimations_;
+    case LayoutAnimationType::LAYOUT:
+      return layoutAnimations_;
+    case LayoutAnimationType::SHARED_ELEMENT_TRANSITION:
+      return sharedTransitions_;
+    default:
+      throw std::invalid_argument("[Reanimated] Unknown layout animation type");
+  }
+}
+
+} // namespace reanimated

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

@@ -1,82 +1,82 @@
-#pragma once
-
-#include <react/renderer/graphics/Transform.h>
-#include <react/renderer/mounting/ShadowView.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>
-#include <memory>
-#include <mutex>
-#include <stack>
-#include <string>
-#include <unordered_map>
-#include <unordered_set>
-#include <utility>
-#include <vector>
-
-namespace reanimated {
-
-using namespace facebook;
-using namespace worklets;
-using SharedTag = std::string;
-
-// [0] is before and [1] is after (best to use BeforeOrAfter enum)
-struct Transition {
-  ShadowView snapshot[2];
-  Tag parentTag[2] = {0, 0};
-  std::optional<Transform> transform[2];
-};
-
-struct SharedTransitionManager {
-  std::unordered_map<std::string, Tag> containerTags_;
-  std::unordered_map<Tag, std::string> tagToName_;
-  std::unordered_map<Tag, std::string> nativeIDToName_;
-};
-
-using TransitionMap = std::unordered_map<SharedTag, Transition>;
-using Transitions = std::vector<std::pair<SharedTag, Transition>>;
-
-struct LayoutAnimationConfig {
-  int tag;
-  LayoutAnimationType type;
-  std::shared_ptr<Serializable> config;
-  std::string sharedTransitionTag;
-};
-
-class LayoutAnimationsManager {
- public:
-  explicit LayoutAnimationsManager(const std::shared_ptr<JSLogger> &jsLogger)
-      : jsLogger_(jsLogger), 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);
-  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 cancelLayoutAnimation(jsi::Runtime &rt, const int tag) const;
-  void transferConfigFromNativeID(const int nativeId, const int tag);
-  void transferSharedConfig(const Tag from, const Tag to);
-  std::shared_ptr<SharedTransitionManager> getSharedTransitionManager();
-
- 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_;
-  std::unordered_map<int, std::shared_ptr<Serializable>> sharedTransitions_;
-  std::unordered_map<int, std::shared_ptr<Serializable>> enteringAnimations_;
-  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_`,
-  // `layoutAnimations_` and `shouldAnimateExitingForTag_`.
-};
-
-} // namespace reanimated
+#pragma once
+
+#include <react/renderer/graphics/Transform.h>
+#include <react/renderer/mounting/ShadowView.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>
+#include <memory>
+#include <mutex>
+#include <stack>
+#include <string>
+#include <unordered_map>
+#include <unordered_set>
+#include <utility>
+#include <vector>
+
+namespace reanimated {
+
+using namespace facebook;
+using namespace worklets;
+using SharedTag = std::string;
+
+// [0] is before and [1] is after (best to use BeforeOrAfter enum)
+struct Transition {
+  ShadowView snapshot[2];
+  Tag parentTag[2] = {0, 0};
+  std::optional<Transform> transform[2];
+};
+
+struct SharedTransitionManager {
+  std::unordered_map<std::string, Tag> containerTags_;
+  std::unordered_map<Tag, std::string> tagToName_;
+  std::unordered_map<Tag, std::string> nativeIDToName_;
+};
+
+using TransitionMap = std::unordered_map<SharedTag, Transition>;
+using Transitions = std::vector<std::pair<SharedTag, Transition>>;
+
+struct LayoutAnimationConfig {
+  int tag;
+  LayoutAnimationType type;
+  std::shared_ptr<Serializable> config;
+  std::string sharedTransitionTag;
+};
+
+class LayoutAnimationsManager {
+ public:
+  explicit LayoutAnimationsManager(const std::shared_ptr<JSLogger> &jsLogger)
+      : jsLogger_(jsLogger), 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);
+  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 cancelLayoutAnimation(jsi::Runtime &rt, const int tag) const;
+  void transferConfigFromNativeID(const int nativeId, const int tag);
+  void transferSharedConfig(const Tag from, const Tag to);
+  std::shared_ptr<SharedTransitionManager> getSharedTransitionManager();
+
+ 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_;
+  std::unordered_map<int, std::shared_ptr<Serializable>> sharedTransitions_;
+  std::unordered_map<int, std::shared_ptr<Serializable>> enteringAnimations_;
+  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_`,
+  // `layoutAnimations_` and `shouldAnimateExitingForTag_`.
+};
+
+} // namespace reanimated

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

@@ -1,79 +1,79 @@
-#include <ReactCommon/CallInvoker.h>
-#include <folly/dynamic.h>
-#include <react/renderer/uimanager/UIManagerBinding.h>
-#include <reanimated/Fabric/ShadowTreeCloner.h>
-#include <reanimated/LayoutAnimations/LayoutAnimationsProxyCommon.h>
-
-#include <functional>
-#include <memory>
-#include <utility>
-#include <vector>
-
-namespace reanimated {
-
-std::optional<facebook::react::SurfaceId>
-LayoutAnimationsProxyCommon::onTransitionProgress(int tag, double progress, bool isClosing, bool isGoingForward) {
-  return std::nullopt;
-}
-
-std::optional<facebook::react::SurfaceId> LayoutAnimationsProxyCommon::onGestureCancel() {
-  return std::nullopt;
-}
-
-void LayoutAnimationsProxyCommon::startSurface(const SurfaceId surfaceId) {}
-
-#ifdef ANDROID
-
-const facebook::react::ShadowNode *findInShadowTreeByTag(const facebook::react::ShadowNode &node, Tag tag) {
-  if (node.getTag() == tag) {
-    return &node;
-  }
-  for (const auto &child : node.getChildren()) {
-    if (const auto result = findInShadowTreeByTag(*child, tag)) {
-      return result;
-    }
-  }
-  return nullptr;
-}
-
-void LayoutAnimationsProxyCommon::restoreOpacityInCaseOfFlakyEnteringAnimation(SurfaceId surfaceId) const {
-  std::vector<std::pair<double, Tag>> opacityToRestore;
-  for (const auto tag : finishedAnimationTags_) {
-    const auto &opacity = layoutAnimations_[tag].opacity;
-    if (opacity.has_value()) {
-      opacityToRestore.emplace_back(std::pair<double, Tag>{opacity.value(), tag});
-    }
-  }
-  if (opacityToRestore.empty()) {
-    // Animation was successfully finished, and the opacity was restored, so we
-    // don't need to do anything. Only the Entering animation has a set opacity
-    // value.
-    return;
-  }
-  const std::weak_ptr<UIManager> weakUiManager = uiManager_;
-  jsInvoker_->invokeAsync([=](jsi::Runtime &runtime) {
-    auto uiManager = weakUiManager.lock();
-    if (!uiManager) {
-      return;
-    }
-    uiManager->getShadowTreeRegistry().visit(surfaceId, [=](ShadowTree const &shadowTree) {
-      shadowTree.commit(
-          [=](RootShadowNode const &oldRootShadowNode) {
-            const auto &rootShadowNode = static_cast<const ShadowNode &>(oldRootShadowNode);
-            PropsMap propsMap;
-            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));
-              }
-            }
-            return cloneShadowTreeWithNewProps(oldRootShadowNode, propsMap);
-          },
-          {});
-    });
-  });
-}
-
-#endif // ANDROID
-
-} // namespace reanimated
+#include <ReactCommon/CallInvoker.h>
+#include <folly/dynamic.h>
+#include <react/renderer/uimanager/UIManagerBinding.h>
+#include <reanimated/Fabric/ShadowTreeCloner.h>
+#include <reanimated/LayoutAnimations/LayoutAnimationsProxyCommon.h>
+
+#include <functional>
+#include <memory>
+#include <utility>
+#include <vector>
+
+namespace reanimated {
+
+std::optional<facebook::react::SurfaceId>
+LayoutAnimationsProxyCommon::onTransitionProgress(int tag, double progress, bool isClosing, bool isGoingForward) {
+  return std::nullopt;
+}
+
+std::optional<facebook::react::SurfaceId> LayoutAnimationsProxyCommon::onGestureCancel() {
+  return std::nullopt;
+}
+
+void LayoutAnimationsProxyCommon::startSurface(const SurfaceId surfaceId) {}
+
+#ifdef ANDROID
+
+const facebook::react::ShadowNode *findInShadowTreeByTag(const facebook::react::ShadowNode &node, Tag tag) {
+  if (node.getTag() == tag) {
+    return &node;
+  }
+  for (const auto &child : node.getChildren()) {
+    if (const auto result = findInShadowTreeByTag(*child, tag)) {
+      return result;
+    }
+  }
+  return nullptr;
+}
+
+void LayoutAnimationsProxyCommon::restoreOpacityInCaseOfFlakyEnteringAnimation(SurfaceId surfaceId) const {
+  std::vector<std::pair<double, Tag>> opacityToRestore;
+  for (const auto tag : finishedAnimationTags_) {
+    const auto &opacity = layoutAnimations_[tag].opacity;
+    if (opacity.has_value()) {
+      opacityToRestore.emplace_back(std::pair<double, Tag>{opacity.value(), tag});
+    }
+  }
+  if (opacityToRestore.empty()) {
+    // Animation was successfully finished, and the opacity was restored, so we
+    // don't need to do anything. Only the Entering animation has a set opacity
+    // value.
+    return;
+  }
+  const std::weak_ptr<UIManager> weakUiManager = uiManager_;
+  jsInvoker_->invokeAsync([=](jsi::Runtime &runtime) {
+    auto uiManager = weakUiManager.lock();
+    if (!uiManager) {
+      return;
+    }
+    uiManager->getShadowTreeRegistry().visit(surfaceId, [=](ShadowTree const &shadowTree) {
+      shadowTree.commit(
+          [=](RootShadowNode const &oldRootShadowNode) {
+            const auto &rootShadowNode = static_cast<const ShadowNode &>(oldRootShadowNode);
+            PropsMap propsMap;
+            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));
+              }
+            }
+            return cloneShadowTreeWithNewProps(oldRootShadowNode, propsMap);
+          },
+          {});
+    });
+  });
+}
+
+#endif // ANDROID
+
+} // namespace reanimated