@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/LayoutAnimationsManager.h

@@ -1,8 +1,10 @@
 #pragma once
 
+#include <react/renderer/graphics/Transform.h>
+#include <react/renderer/mounting/ShadowView.h>
 #include <reanimated/LayoutAnimations/LayoutAnimationType.h>
 
-#include <worklets/SharedItems/Shareables.h>
+#include <worklets/SharedItems/Serializable.h>
 #include <worklets/Tools/JSLogger.h>
 
 #include <jsi/jsi.h>
@@ -10,81 +12,71 @@
 #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<Shareable> config;
+  std::shared_ptr<Serializable> config;
   std::string sharedTransitionTag;
 };
 
 class LayoutAnimationsManager {
  public:
   explicit LayoutAnimationsManager(const std::shared_ptr<JSLogger> &jsLogger)
-      : jsLogger_(jsLogger) {}
-  void configureAnimationBatch(
-      const std::vector<LayoutAnimationConfig> &layoutAnimationsBatch);
+      : 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 startLayoutAnimation(jsi::Runtime &rt, const int tag, const LayoutAnimationType type, const jsi::Object &values);
   void clearLayoutAnimationConfig(const int tag);
-  void clearSharedTransitionConfig(const int tag);
   void cancelLayoutAnimation(jsi::Runtime &rt, const int tag) const;
-#ifdef RCT_NEW_ARCH_ENABLED
   void transferConfigFromNativeID(const int nativeId, const int tag);
-#endif
-  int findPrecedingViewTagForTransition(const int tag);
-  const std::vector<int> &getSharedGroup(const int viewTag);
-#ifndef NDEBUG
-  std::string getScreenSharedTagPairString(
-      const int screenTag,
-      const std::string &sharedTag) const;
-  void checkDuplicateSharedTag(const int viewTag, const int screenTag);
-#endif
+  void transferSharedConfig(const Tag from, const Tag to);
+  std::shared_ptr<SharedTransitionManager> getSharedTransitionManager();
 
  private:
-  std::unordered_map<int, std::shared_ptr<Shareable>> &getConfigsForType(
-      const LayoutAnimationType type);
+  std::unordered_map<int, std::shared_ptr<Serializable>> &getConfigsForType(const LayoutAnimationType type);
 
   std::shared_ptr<JSLogger> jsLogger_;
-#ifndef NDEBUG
-  // This set's function is to detect duplicate sharedTags on a single screen
-  // it contains strings in form: "reactScreenTag:sharedTag"
-  std::unordered_set<std::string> screenSharedTagSet_;
-  // And this map is to remove collected pairs on SET removal
-  std::unordered_map<int, std::string> viewsScreenSharedTagMap_;
-#endif
-
-#ifdef RCT_NEW_ARCH_ENABLED
-  std::unordered_map<int, std::shared_ptr<Shareable>>
-      enteringAnimationsForNativeID_;
-#endif
-  std::unordered_map<int, std::shared_ptr<Shareable>> enteringAnimations_;
-  std::unordered_map<int, std::shared_ptr<Shareable>> exitingAnimations_;
-  std::unordered_map<int, std::shared_ptr<Shareable>> layoutAnimations_;
-  std::unordered_map<int, std::shared_ptr<Shareable>>
-      sharedTransitionAnimations_;
-  std::unordered_set<int> ignoreProgressAnimationForTag_;
-  std::unordered_map<std::string, std::vector<int>> sharedTransitionGroups_;
-  std::unordered_map<int, std::string> viewTagToSharedTag_;
+  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_`, `viewSharedValues_` and `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

@@ -0,0 +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

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

@@ -0,0 +1,81 @@
+#pragma once
+
+#include <jsi/jsi.h>
+#include <react/renderer/componentregistry/ComponentDescriptorFactory.h>
+#include <react/renderer/mounting/MountingOverrideDelegate.h>
+#include <react/renderer/uimanager/UIManager.h>
+#include <reanimated/LayoutAnimations/LayoutAnimationsManager.h>
+#include <reanimated/Tools/PlatformDepMethodsHolder.h>
+#include <worklets/Tools/UIScheduler.h>
+
+#include <memory>
+#include <optional>
+#include <unordered_map>
+#include <vector>
+
+namespace reanimated {
+
+struct LayoutAnimation {
+  ShadowView finalView, currentView, startView;
+  Tag parentTag;
+  std::optional<double> opacity;
+  bool isViewAlreadyMounted = false;
+  int count = 1;
+  LayoutAnimation &operator=(const LayoutAnimation &other) = default;
+};
+
+class LayoutAnimationsProxyCommon : public facebook::react::MountingOverrideDelegate {
+ public:
+  LayoutAnimationsProxyCommon(
+      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<facebook::react::UIManager> uiManager,
+      std::shared_ptr<facebook::react::CallInvoker> jsInvoker
+#endif
+      )
+      : layoutAnimationsManager_(layoutAnimationsManager),
+        contextContainer_(contextContainer),
+        componentDescriptorRegistry_(componentDescriptorRegistry),
+        uiRuntime_(uiRuntime),
+        uiScheduler_(uiScheduler)
+#ifdef ANDROID
+        ,
+        preserveMountedTags_(filterUnmountedTagsFunction),
+        uiManager_(uiManager),
+        jsInvoker_(jsInvoker)
+#endif
+  {
+  }
+  virtual std::optional<facebook::react::SurfaceId>
+  onTransitionProgress(int tag, double progress, bool isClosing, bool isGoingForward);
+  virtual std::optional<facebook::react::SurfaceId> onGestureCancel();
+  virtual std::optional<SurfaceId> progressLayoutAnimation(int tag, const jsi::Object &newStyle) = 0;
+  virtual std::optional<SurfaceId> endLayoutAnimation(int tag, bool shouldRemove) = 0;
+  virtual void startSurface(const SurfaceId surfaceId);
+
+ protected:
+  mutable std::vector<Tag> finishedAnimationTags_;
+  mutable std::unordered_map<Tag, LayoutAnimation> layoutAnimations_;
+  std::shared_ptr<LayoutAnimationsManager> layoutAnimationsManager_;
+  std::shared_ptr<const ContextContainer> contextContainer_;
+  SharedComponentDescriptorRegistry componentDescriptorRegistry_;
+  jsi::Runtime &uiRuntime_;
+  const std::shared_ptr<UIScheduler> uiScheduler_;
+  PreserveMountedTagsFunction preserveMountedTags_;
+
+#ifdef ANDROID
+  std::shared_ptr<facebook::react::UIManager> uiManager_;
+  std::shared_ptr<facebook::react::CallInvoker> jsInvoker_;
+
+  void restoreOpacityInCaseOfFlakyEnteringAnimation(SurfaceId surfaceId) const;
+
+#endif
+};
+
+} // namespace reanimated