react-native-reanimated 3.8.0 → 3.9.0-layout-animation-experimental

package/Common/cpp/Fabric/ShadowTreeCloner.cpp

@@ -1,5 +1,7 @@
 #ifdef RCT_NEW_ARCH_ENABLED
 
+#include <utility>
+
 #include "ShadowTreeCloner.h"
 
 namespace reanimated {
@@ -22,9 +24,9 @@ ShadowNode::Unshared cloneShadowTreeWithNewProps(
   PropsParserContext propsParserContext{
       source->getSurfaceId(), *source->getContextContainer()};
   const auto props = source->getComponentDescriptor().cloneProps(
-      propsParserContext, source->getProps(), rawProps);
+      propsParserContext, source->getProps(), std::move(rawProps));
 
-  auto newChildNode = source->clone({/* .props = */ props});
+  auto newChildNode = source->clone({/* .props = */ props, ShadowNodeFragment::childrenPlaceholder(), source->getState()});
 
   for (auto it = ancestors.rbegin(); it != ancestors.rend(); ++it) {
     auto &parentNode = it->first.get();
@@ -51,6 +53,7 @@ ShadowNode::Unshared cloneShadowTreeWithNewProps(
     newChildNode = parentNode.clone({
         ShadowNodeFragment::propsPlaceholder(),
         std::make_shared<ShadowNode::ListOfShared>(children),
+        parentNode.getState()
     });
   }
 

package/Common/cpp/LayoutAnimations/LayoutAnimationsManager.cpp

@@ -1,6 +1,7 @@
 #include "LayoutAnimationsManager.h"
 #include "CollectionUtils.h"
 #include "Shareables.h"
+#include <react/renderer/uimanager/primitives.h>
 
 #ifndef NDEBUG
 #include <utility>
@@ -8,48 +9,50 @@
 
 namespace reanimated {
 
-void LayoutAnimationsManager::configureAnimation(
-    const int tag,
-    const LayoutAnimationType type,
-    const std::string &sharedTransitionTag,
-    const std::shared_ptr<Shareable> &config) {
-  auto lock = std::unique_lock<std::mutex>(animationsMutex_);
-  if (type == SHARED_ELEMENT_TRANSITION ||
-      type == SHARED_ELEMENT_TRANSITION_PROGRESS) {
+void LayoutAnimationsManager::configureAnimationBatch(
+    const std::vector<LayoutAnimationConfig> &layoutAnimationsBatch) {
+  auto lock = std::unique_lock<std::recursive_mutex>(animationsMutex_);
+  std::vector<LayoutAnimationConfig> sharedTransitionConfigs;
+  for (auto layoutAnimationConfig : layoutAnimationsBatch) {
+    const auto &[tag, type, config, sharedTransitionTag] =
+        layoutAnimationConfig;
+    if (type == SHARED_ELEMENT_TRANSITION ||
+        type == SHARED_ELEMENT_TRANSITION_PROGRESS) {
+      clearSharedTransitionConfig(tag);
+      sharedTransitionConfigs.push_back(std::move(layoutAnimationConfig));
+    } else {
+      if (config == nullptr) {
+        getConfigsForType(type).erase(tag);
+      } else {
+        getConfigsForType(type)[tag] = config;
+      }
+    }
+  }
+  for (const auto &[tag, type, config, sharedTransitionTag] :
+       sharedTransitionConfigs) {
+    if (config == nullptr) {
+      continue;
+    }
     sharedTransitionGroups_[sharedTransitionTag].push_back(tag);
     viewTagToSharedTag_[tag] = sharedTransitionTag;
     getConfigsForType(SHARED_ELEMENT_TRANSITION)[tag] = config;
     if (type == SHARED_ELEMENT_TRANSITION) {
       ignoreProgressAnimationForTag_.insert(tag);
     }
-  } else {
-    getConfigsForType(type)[tag] = config;
-  }
-}
-
-void LayoutAnimationsManager::configureAnimationBatch(
-    const std::vector<LayoutAnimationConfig> &layoutAnimationsBatch) {
-  auto lock = std::unique_lock<std::mutex>(animationsMutex_);
-  for (auto [tag, type, config] : layoutAnimationsBatch) {
-    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::mutex>(animationsMutex_);
+  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::mutex>(animationsMutex_);
+  auto lock = std::unique_lock<std::recursive_mutex>(animationsMutex_);
   return collection::contains(shouldAnimateExitingForTag_, tag)
       ? shouldAnimateExitingForTag_[tag]
       : shouldAnimate;
@@ -58,7 +61,7 @@ bool LayoutAnimationsManager::shouldAnimateExiting(
 bool LayoutAnimationsManager::hasLayoutAnimation(
     const int tag,
     const LayoutAnimationType type) {
-  auto lock = std::unique_lock<std::mutex>(animationsMutex_);
+  auto lock = std::unique_lock<std::recursive_mutex>(animationsMutex_);
   if (type == SHARED_ELEMENT_TRANSITION_PROGRESS) {
     auto end = ignoreProgressAnimationForTag_.end();
     return ignoreProgressAnimationForTag_.find(tag) == end;
@@ -66,12 +69,8 @@ bool LayoutAnimationsManager::hasLayoutAnimation(
   return collection::contains(getConfigsForType(type), tag);
 }
 
-void LayoutAnimationsManager::clearLayoutAnimationConfig(const int tag) {
-  auto lock = std::unique_lock<std::mutex>(animationsMutex_);
-  enteringAnimations_.erase(tag);
-  exitingAnimations_.erase(tag);
-  layoutAnimations_.erase(tag);
-  shouldAnimateExitingForTag_.erase(tag);
+void LayoutAnimationsManager::clearSharedTransitionConfig(const int tag) {
+  auto lock = std::unique_lock<std::recursive_mutex>(animationsMutex_);
 #ifndef NDEBUG
   const auto &pair = viewsScreenSharedTagMap_[tag];
   screenSharedTagSet_.erase(pair);
@@ -81,6 +80,7 @@ void LayoutAnimationsManager::clearLayoutAnimationConfig(const int tag) {
   sharedTransitionAnimations_.erase(tag);
   auto const &groupName = viewTagToSharedTag_[tag];
   if (groupName.empty()) {
+    viewTagToSharedTag_.erase(tag);
     return;
   }
   auto &group = sharedTransitionGroups_[groupName];
@@ -95,6 +95,15 @@ void LayoutAnimationsManager::clearLayoutAnimationConfig(const int tag) {
   ignoreProgressAnimationForTag_.erase(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);
+  clearSharedTransitionConfig(tag);
+}
+
 void LayoutAnimationsManager::startLayoutAnimation(
     jsi::Runtime &rt,
     const int tag,
@@ -102,7 +111,7 @@ void LayoutAnimationsManager::startLayoutAnimation(
     const jsi::Object &values) {
   std::shared_ptr<Shareable> config, viewShareable;
   {
-    auto lock = std::unique_lock<std::mutex>(animationsMutex_);
+    auto lock = std::unique_lock<std::recursive_mutex>(animationsMutex_);
     config = getConfigsForType(type)[tag];
   }
   // TODO: cache the following!!
@@ -124,6 +133,7 @@ void LayoutAnimationsManager::startLayoutAnimation(
 void LayoutAnimationsManager::cancelLayoutAnimation(
     jsi::Runtime &rt,
     const int tag) const {
+      LOG(ERROR)<<"trying to cancel animation for "<<tag<<std::endl;
   jsi::Value layoutAnimationRepositoryAsValue =
       rt.global()
           .getPropertyAsObject(rt, "global")

package/Common/cpp/LayoutAnimations/LayoutAnimationsManager.h

@@ -13,6 +13,7 @@
 #include <unordered_map>
 #include <unordered_set>
 #include <vector>
+//#include "ShadowNode.h"
 
 namespace reanimated {
 
@@ -22,17 +23,13 @@ struct LayoutAnimationConfig {
   int tag;
   LayoutAnimationType type;
   std::shared_ptr<Shareable> config;
+  std::string sharedTransitionTag;
 };
 
 class LayoutAnimationsManager {
  public:
   explicit LayoutAnimationsManager(const std::shared_ptr<JSLogger> &jsLogger)
       : jsLogger_(jsLogger) {}
-  void configureAnimation(
-      const int tag,
-      const LayoutAnimationType type,
-      const std::string &sharedTransitionTag,
-      const std::shared_ptr<Shareable> &config);
   void configureAnimationBatch(
       const std::vector<LayoutAnimationConfig> &layoutAnimationsBatch);
   void setShouldAnimateExiting(const int tag, const bool value);
@@ -44,6 +41,7 @@ class LayoutAnimationsManager {
       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;
   int findPrecedingViewTagForTransition(const int tag);
 #ifndef NDEBUG
@@ -53,7 +51,7 @@ class LayoutAnimationsManager {
   void checkDuplicateSharedTag(const int viewTag, const int screenTag);
 #endif
 
- private:
+// private:
   std::unordered_map<int, std::shared_ptr<Shareable>> &getConfigsForType(
       const LayoutAnimationType type);
 
@@ -75,7 +73,7 @@ class LayoutAnimationsManager {
   std::unordered_map<std::string, std::vector<int>> sharedTransitionGroups_;
   std::unordered_map<int, std::string> viewTagToSharedTag_;
   std::unordered_map<int, bool> shouldAnimateExitingForTag_;
-  mutable std::mutex
+  mutable std::recursive_mutex
       animationsMutex_; // Protects `enteringAnimations_`, `exitingAnimations_`,
   // `layoutAnimations_`, `viewSharedValues_` and `shouldAnimateExitingForTag_`.
 };