react-native-reanimated 3.0.0-rc.8 → 3.0.0

package/Common/cpp/AnimatedSensor/AnimatedSensorModule.cpp

@@ -14,11 +14,7 @@ AnimatedSensorModule::AnimatedSensorModule(
           platformDepMethodsHolder.unregisterSensor) {}
 
 AnimatedSensorModule::~AnimatedSensorModule() {
-  // It is called during app reload because app reload doesn't call hooks
-  // unmounting
-  for (auto sensorId : sensorsIds_) {
-    platformUnregisterSensorFunction_(sensorId);
-  }
+  assert(sensorsIds_.empty());
 }
 
 jsi::Value AnimatedSensorModule::registerSensor(
@@ -26,19 +22,32 @@ jsi::Value AnimatedSensorModule::registerSensor(
     const std::shared_ptr<JSRuntimeHelper> &runtimeHelper,
     const jsi::Value &sensorTypeValue,
     const jsi::Value &interval,
+    const jsi::Value &iosReferenceFrame,
     const jsi::Value &sensorDataHandler) {
   SensorType sensorType = static_cast<SensorType>(sensorTypeValue.asNumber());
 
   auto shareableHandler = extractShareableOrThrow(rt, sensorDataHandler);
-  auto uiRuntime = runtimeHelper->uiRuntime();
 
   int sensorId = platformRegisterSensorFunction_(
-      sensorType, interval.asNumber(), [=](double newValues[]) {
-        jsi::Runtime &rt = *uiRuntime;
-        auto handler =
-            shareableHandler->getJSValue(rt).asObject(rt).asFunction(rt);
+      sensorType,
+      interval.asNumber(),
+      iosReferenceFrame.asNumber(),
+      [sensorType,
+       shareableHandler,
+       weakRuntimeHelper = std::weak_ptr<JSRuntimeHelper>(runtimeHelper)](
+          double newValues[], int orientationDegrees) {
+        auto runtimeHelper = weakRuntimeHelper.lock();
+        if (runtimeHelper == nullptr || runtimeHelper->uiRuntimeDestroyed) {
+          return;
+        }
+
+        auto &rt = *runtimeHelper->uiRuntime();
+        auto handler = shareableHandler->getJSValue(rt);
         if (sensorType == SensorType::ROTATION_VECTOR) {
           jsi::Object value(rt);
+          // TODO: timestamp should be provided by the platform implementation
+          // such that the native side has a chance of providing a true event
+          // timestamp
           value.setProperty(rt, "qx", newValues[0]);
           value.setProperty(rt, "qy", newValues[1]);
           value.setProperty(rt, "qz", newValues[2]);
@@ -46,13 +55,15 @@ jsi::Value AnimatedSensorModule::registerSensor(
           value.setProperty(rt, "yaw", newValues[4]);
           value.setProperty(rt, "pitch", newValues[5]);
           value.setProperty(rt, "roll", newValues[6]);
-          handler.call(rt, value);
+          value.setProperty(rt, "interfaceOrientation", orientationDegrees);
+          runtimeHelper->runOnUIGuarded(handler, value);
         } else {
           jsi::Object value(rt);
           value.setProperty(rt, "x", newValues[0]);
           value.setProperty(rt, "y", newValues[1]);
           value.setProperty(rt, "z", newValues[2]);
-          handler.call(rt, value);
+          value.setProperty(rt, "interfaceOrientation", orientationDegrees);
+          runtimeHelper->runOnUIGuarded(handler, value);
         }
       });
   if (sensorId != -1) {
@@ -67,4 +78,11 @@ void AnimatedSensorModule::unregisterSensor(const jsi::Value &sensorId) {
   platformUnregisterSensorFunction_(sensorId.asNumber());
 }
 
+void AnimatedSensorModule::unregisterAllSensors() {
+  for (auto sensorId : sensorsIds_) {
+    platformUnregisterSensorFunction_(sensorId);
+  }
+  sensorsIds_.clear();
+}
+
 } // namespace reanimated

package/Common/cpp/AnimatedSensor/AnimatedSensorModule.h

@@ -35,8 +35,10 @@ class AnimatedSensorModule {
       const std::shared_ptr<JSRuntimeHelper> &runtimeHelper,
       const jsi::Value &sensorType,
       const jsi::Value &interval,
+      const jsi::Value &iosReferenceFrame,
       const jsi::Value &sensorDataContainer);
   void unregisterSensor(const jsi::Value &sensorId);
+  void unregisterAllSensors();
 };
 
 } // namespace reanimated

package/Common/cpp/Fabric/FabricUtils.cpp

@@ -1,12 +1,8 @@
 #ifdef RCT_NEW_ARCH_ENABLED
 
-#if REACT_NATIVE_MINOR_VERSION < 69
-#error \
-    "Reanimated 3 does not support React Native 0.68.x when Fabric is enabled. Please upgrade to React Native 0.69.0 or newer if you want to use Reanimated with the new architecture."
-#endif
-
 #include "FabricUtils.h"
 
+#include <react/renderer/debug/SystraceSection.h>
 #include <react/renderer/uimanager/UIManagerBinding.h>
 
 using namespace facebook::react;
@@ -22,110 +18,10 @@ RuntimeExecutor getRuntimeExecutorFromBinding(Binding *binding) {
 }
 #endif
 
-inline static const UIManagerPublic *getUIManagerPublic(
-    const UIManager *uiManager) {
-  return reinterpret_cast<const UIManagerPublic *>(uiManager);
-}
-
 std::shared_ptr<const ContextContainer> getContextContainerFromUIManager(
     const UIManager *uiManager) {
-  return getUIManagerPublic(uiManager)->contextContainer_;
-}
-
-inline static UIManagerDelegate *getDelegateFromUIManager(
-    const UIManager *uiManager) {
-  return getUIManagerPublic(uiManager)->delegate_;
-}
-
-void UIManager_dispatchCommand(
-    const std::shared_ptr<UIManager> &uiManager,
-    const ShadowNode::Shared &shadowNode,
-    std::string const &commandName,
-    folly::dynamic const &args) {
-  auto delegate_ = getDelegateFromUIManager(&*uiManager);
-
-  // copied from UIManager.cpp
-  if (delegate_) {
-    delegate_->uiManagerDidDispatchCommand(shadowNode, commandName, args);
-  }
-}
-
-LayoutMetrics UIManager_getRelativeLayoutMetrics(
-    const std::shared_ptr<UIManager> &uiManager,
-    ShadowNode const &shadowNode,
-    ShadowNode const *ancestorShadowNode,
-    LayoutableShadowNode::LayoutInspectingPolicy policy) {
-  // based on implementation from UIManager.cpp
-  const auto &shadowTreeRegistry = uiManager->getShadowTreeRegistry();
-
-  // We might store here an owning pointer to `ancestorShadowNode` to ensure
-  // that the node is not deallocated during method execution lifetime.
-  auto owningAncestorShadowNode = ShadowNode::Shared{};
-
-  if (!ancestorShadowNode) {
-    shadowTreeRegistry.visit(
-        shadowNode.getSurfaceId(), [&](ShadowTree const &shadowTree) {
-          owningAncestorShadowNode =
-              shadowTree.getCurrentRevision().rootShadowNode;
-          ancestorShadowNode = owningAncestorShadowNode.get();
-        });
-  } else {
-    // It is possible for JavaScript (or other callers) to have a reference
-    // to a previous version of ShadowNodes, but we enforce that
-    // metrics are only calculated on most recently committed versions.
-    owningAncestorShadowNode =
-        uiManager->getNewestCloneOfShadowNode(*ancestorShadowNode);
-    ancestorShadowNode = owningAncestorShadowNode.get();
-  }
-
-  auto layoutableAncestorShadowNode =
-      traitCast<LayoutableShadowNode const *>(ancestorShadowNode);
-
-  if (!layoutableAncestorShadowNode) {
-    return EmptyLayoutMetrics;
-  }
-
-  return LayoutableShadowNode::computeRelativeLayoutMetrics(
-      shadowNode.getFamily(), *layoutableAncestorShadowNode, policy);
-}
-
-ShadowNode::Shared UIManager_cloneNode(
-    const UIManager *uiManager,
-    const ShadowNode::Shared &shadowNode,
-    const ShadowNode::SharedListOfShared &children,
-    const RawProps *rawProps) {
-  auto delegate_ = getDelegateFromUIManager(uiManager);
-  auto contextContainer_ = getContextContainerFromUIManager(uiManager);
-
-  // copied from UIManager.cpp
-  PropsParserContext propsParserContext{
-      shadowNode->getFamily().getSurfaceId(), *contextContainer_.get()};
-
-  auto &componentDescriptor = shadowNode->getComponentDescriptor();
-  auto clonedShadowNode = componentDescriptor.cloneShadowNode(
-      *shadowNode,
-      {
-          /* .props = */
-          rawProps ? componentDescriptor.cloneProps(
-                         propsParserContext, shadowNode->getProps(), *rawProps)
-                   : ShadowNodeFragment::propsPlaceholder(),
-          /* .children = */ children,
-      });
-
-  if (delegate_) {
-    delegate_->uiManagerDidCloneShadowNode(
-        *shadowNode.get(), *clonedShadowNode);
-  }
-
-  return clonedShadowNode;
-}
-
-void UIManager_appendChild(
-    const ShadowNode::Shared &parentShadowNode,
-    const ShadowNode::Shared &childShadowNode) {
-  // copied from UIManager.cpp
-  auto &componentDescriptor = parentShadowNode->getComponentDescriptor();
-  componentDescriptor.appendChild(parentShadowNode, childShadowNode);
+  return reinterpret_cast<const UIManagerPublic *>(uiManager)
+      ->contextContainer_;
 }
 
 } // namespace reanimated

package/Common/cpp/Fabric/FabricUtils.h

@@ -2,15 +2,16 @@
 #ifdef RCT_NEW_ARCH_ENABLED
 
 #ifdef ANDROID
-#include <Binding.h>
 #include <fbjni/fbjni.h>
+#include <react/fabric/Binding.h>
 #endif
 #include <react/renderer/uimanager/UIManager.h>
 
 #include <memory>
 #include <string>
 
-using namespace facebook::react;
+using namespace facebook;
+using namespace react;
 
 namespace reanimated {
 
@@ -52,28 +53,6 @@ RuntimeExecutor getRuntimeExecutorFromBinding(Binding *binding);
 std::shared_ptr<const ContextContainer> getContextContainerFromUIManager(
     const UIManager *uiManager);
 
-void UIManager_dispatchCommand(
-    const std::shared_ptr<UIManager> &uiManager,
-    const ShadowNode::Shared &shadowNode,
-    std::string const &commandName,
-    folly::dynamic const &args);
-
-LayoutMetrics UIManager_getRelativeLayoutMetrics(
-    const std::shared_ptr<UIManager> &uiManager,
-    ShadowNode const &shadowNode,
-    ShadowNode const *ancestorShadowNode,
-    LayoutableShadowNode::LayoutInspectingPolicy policy);
-
-ShadowNode::Shared UIManager_cloneNode(
-    const UIManager *uiManager,
-    const ShadowNode::Shared &shadowNode,
-    const ShadowNode::SharedListOfShared &children = nullptr,
-    const RawProps *rawProps = nullptr);
-
-void UIManager_appendChild(
-    const ShadowNode::Shared &parentShadowNode,
-    const ShadowNode::Shared &childShadowNode);
-
 } // namespace reanimated
 
 #endif // RCT_NEW_ARCH_ENABLED

package/Common/cpp/Fabric/ReanimatedUIManagerBinding.cpp

@@ -4,6 +4,8 @@
 #include "FabricUtils.h"
 #include "NewestShadowNodesRegistry.h"
 
+#include <react/renderer/debug/SystraceSection.h>
+
 #include <utility>
 
 using namespace facebook;
@@ -51,7 +53,7 @@ ReanimatedUIManagerBinding::ReanimatedUIManagerBinding(
     RuntimeExecutor runtimeExecutor,
     std::unique_ptr<EventHandler const> eventHandler,
     std::shared_ptr<NewestShadowNodesRegistry> newestShadowNodesRegistry)
-    : UIManagerBinding(uiManager, runtimeExecutor),
+    : UIManagerBinding(uiManager),
       uiManager_(std::move(uiManager)),
       newestShadowNodesRegistry_(newestShadowNodesRegistry) {
   if (eventHandler != nullptr) {
@@ -62,25 +64,44 @@ ReanimatedUIManagerBinding::ReanimatedUIManagerBinding(
 
 ReanimatedUIManagerBinding::~ReanimatedUIManagerBinding() {}
 
-static inline ShadowNode::Shared cloneNode(
+static inline ShadowNode::Shared cloneNodeUsingNewest(
     UIManager *uiManager,
     NewestShadowNodesRegistry *newestShadowNodesRegistry,
-    const ShadowNode::Shared &shadowNode,
-    const ShadowNode::SharedListOfShared &children = nullptr,
-    const RawProps *rawProps = nullptr) {
+    ShadowNode const &shadowNode,
+    ShadowNode::SharedListOfShared const &children = nullptr,
+    RawProps const *rawProps = nullptr) {
   {
     auto lock = newestShadowNodesRegistry->createLock();
-    auto newest = newestShadowNodesRegistry->get(shadowNode->getTag());
+    auto newest = newestShadowNodesRegistry->get(shadowNode.getTag());
     if (newest != nullptr) {
       // ShadowNode managed by Reanimated, use newest ShadowNode from registry
-      auto clone = UIManager_cloneNode(uiManager, newest, children, rawProps);
+      auto clone = uiManager->cloneNode(*newest, children, rawProps);
       newestShadowNodesRegistry->update(clone);
       return clone;
     }
   } // release lock since we don't need registry anymore
 
   // ShadowNode not managed by Reanimated (yet?)
-  return UIManager_cloneNode(uiManager, shadowNode, children, rawProps);
+  return uiManager->cloneNode(shadowNode, children, rawProps);
+}
+
+static inline void appendChildUsingNewest(
+    UIManager *uiManager,
+    NewestShadowNodesRegistry *newestShadowNodesRegistry,
+    const ShadowNode::Shared &parentShadowNode,
+    const ShadowNode::Shared &childShadowNode) {
+  {
+    auto lock = newestShadowNodesRegistry->createLock();
+    auto newestChildShadowNode =
+        newestShadowNodesRegistry->get(childShadowNode->getTag());
+    if (newestChildShadowNode != nullptr) {
+      uiManager->appendChild(parentShadowNode, newestChildShadowNode);
+      return;
+    }
+  } // release lock since we don't need registry anymore
+
+  // child ShadowNode not managed by Reanimated (yet?)
+  uiManager->appendChild(parentShadowNode, childShadowNode);
 }
 
 jsi::Value ReanimatedUIManagerBinding::get(
@@ -94,6 +115,7 @@ jsi::Value ReanimatedUIManagerBinding::get(
 
   // based on implementation from UIManagerBinding.cpp
   auto methodName = name.utf8(runtime);
+  SystraceSection s("ReanimatedUIManagerBinding::get", "name", methodName);
   UIManager *uiManager = uiManager_.get();
   NewestShadowNodesRegistry *newestShadowNodesRegistry =
       newestShadowNodesRegistry_.get();
@@ -106,15 +128,15 @@ jsi::Value ReanimatedUIManagerBinding::get(
         1,
         [uiManager, newestShadowNodesRegistry](
             jsi::Runtime &runtime,
-            jsi::Value const &thisValue,
+            jsi::Value const & /*thisValue*/,
             jsi::Value const *arguments,
-            size_t count) noexcept -> jsi::Value {
+            size_t /*count*/) noexcept -> jsi::Value {
           return valueFromShadowNode(
               runtime,
-              cloneNode(
+              cloneNodeUsingNewest(
                   uiManager,
                   newestShadowNodesRegistry,
-                  shadowNodeFromValue(runtime, arguments[0])));
+                  *shadowNodeFromValue(runtime, arguments[0])));
         });
   }
 
@@ -126,15 +148,15 @@ jsi::Value ReanimatedUIManagerBinding::get(
         1,
         [uiManager, newestShadowNodesRegistry](
             jsi::Runtime &runtime,
-            jsi::Value const &thisValue,
+            jsi::Value const & /*thisValue*/,
             jsi::Value const *arguments,
-            size_t count) noexcept -> jsi::Value {
+            size_t /*count*/) noexcept -> jsi::Value {
           return valueFromShadowNode(
               runtime,
-              cloneNode(
+              cloneNodeUsingNewest(
                   uiManager,
                   newestShadowNodesRegistry,
-                  shadowNodeFromValue(runtime, arguments[0]),
+                  *shadowNodeFromValue(runtime, arguments[0]),
                   ShadowNode::emptySharedShadowNodeSharedList()));
         });
   }
@@ -147,16 +169,16 @@ jsi::Value ReanimatedUIManagerBinding::get(
         2,
         [uiManager, newestShadowNodesRegistry](
             jsi::Runtime &runtime,
-            jsi::Value const &thisValue,
+            jsi::Value const & /*thisValue*/,
             jsi::Value const *arguments,
-            size_t count) noexcept -> jsi::Value {
+            size_t /*count*/) noexcept -> jsi::Value {
           auto const &rawProps = RawProps(runtime, arguments[1]);
           return valueFromShadowNode(
               runtime,
-              cloneNode(
+              cloneNodeUsingNewest(
                   uiManager,
                   newestShadowNodesRegistry,
-                  shadowNodeFromValue(runtime, arguments[0]),
+                  *shadowNodeFromValue(runtime, arguments[0]),
                   nullptr,
                   &rawProps));
         });
@@ -170,16 +192,16 @@ jsi::Value ReanimatedUIManagerBinding::get(
         2,
         [uiManager, newestShadowNodesRegistry](
             jsi::Runtime &runtime,
-            jsi::Value const &thisValue,
+            jsi::Value const & /*thisValue*/,
             jsi::Value const *arguments,
-            size_t count) noexcept -> jsi::Value {
+            size_t /*count*/) noexcept -> jsi::Value {
           auto const &rawProps = RawProps(runtime, arguments[1]);
           return valueFromShadowNode(
               runtime,
-              cloneNode(
+              cloneNodeUsingNewest(
                   uiManager,
                   newestShadowNodesRegistry,
-                  shadowNodeFromValue(runtime, arguments[0]),
+                  *shadowNodeFromValue(runtime, arguments[0]),
                   ShadowNode::emptySharedShadowNodeSharedList(),
                   &rawProps));
         });
@@ -190,21 +212,16 @@ jsi::Value ReanimatedUIManagerBinding::get(
         runtime,
         name,
         2,
-        [newestShadowNodesRegistry](
+        [uiManager, newestShadowNodesRegistry](
             jsi::Runtime &runtime,
-            jsi::Value const &thisValue,
+            jsi::Value const & /*thisValue*/,
             jsi::Value const *arguments,
-            size_t count) noexcept -> jsi::Value {
-          auto parent = shadowNodeFromValue(runtime, arguments[0]);
-          auto child = shadowNodeFromValue(runtime, arguments[1]);
-          {
-            auto lock = newestShadowNodesRegistry->createLock();
-            auto newest = newestShadowNodesRegistry->get(child->getTag());
-            if (newest != nullptr) {
-              child = newest;
-            }
-          }
-          UIManager_appendChild(parent, child);
+            size_t /*count*/) noexcept -> jsi::Value {
+          appendChildUsingNewest(
+              uiManager,
+              newestShadowNodesRegistry,
+              shadowNodeFromValue(runtime, arguments[0]),
+              shadowNodeFromValue(runtime, arguments[1]));
           return jsi::Value::undefined();
         });
   }

package/Common/cpp/LayoutAnimations/LayoutAnimationType.h

@@ -0,0 +1,8 @@
+#pragma once
+
+typedef enum LayoutAnimationType {
+  ENTERING = 1,
+  EXITING = 2,
+  LAYOUT = 3,
+  SHARED_ELEMENT_TRANSITION = 4
+} LayoutAnimationType;

package/Common/cpp/LayoutAnimations/LayoutAnimationsManager.cpp

@@ -1,4 +1,5 @@
 #include "LayoutAnimationsManager.h"
+#include "CollectionUtils.h"
 #include "Shareables.h"
 
 #include <utility>
@@ -7,30 +8,22 @@ namespace reanimated {
 
 void LayoutAnimationsManager::configureAnimation(
     int tag,
-    const std::string &type,
+    LayoutAnimationType type,
+    const std::string &sharedTransitionTag,
     std::shared_ptr<Shareable> config) {
   auto lock = std::unique_lock<std::mutex>(animationsMutex_);
-  if (type == "entering") {
-    enteringAnimations_[tag] = config;
-  } else if (type == "exiting") {
-    exitingAnimations_[tag] = config;
-  } else if (type == "layout") {
-    layoutAnimations_[tag] = config;
+  getConfigsForType(type)[tag] = config;
+  if (type == SHARED_ELEMENT_TRANSITION) {
+    sharedTransitionGroups_[sharedTransitionTag].push_back(tag);
+    viewTagToSharedTag_[tag] = sharedTransitionTag;
   }
 }
 
 bool LayoutAnimationsManager::hasLayoutAnimation(
     int tag,
-    const std::string &type) {
+    LayoutAnimationType type) {
   auto lock = std::unique_lock<std::mutex>(animationsMutex_);
-  if (type == "entering") {
-    return enteringAnimations_.find(tag) != enteringAnimations_.end();
-  } else if (type == "exiting") {
-    return exitingAnimations_.find(tag) != exitingAnimations_.end();
-  } else if (type == "layout") {
-    return layoutAnimations_.find(tag) != layoutAnimations_.end();
-  }
-  return false;
+  return collection::contains(getConfigsForType(type), tag);
 }
 
 void LayoutAnimationsManager::clearLayoutAnimationConfig(int tag) {
@@ -38,25 +31,30 @@ void LayoutAnimationsManager::clearLayoutAnimationConfig(int tag) {
   enteringAnimations_.erase(tag);
   exitingAnimations_.erase(tag);
   layoutAnimations_.erase(tag);
+
+  sharedTransitionAnimations_.erase(tag);
+  auto const &groupName = viewTagToSharedTag_[tag];
+  auto &group = sharedTransitionGroups_[groupName];
+  auto position = std::find(group.begin(), group.end(), tag);
+  if (position != group.end()) {
+    group.erase(position);
+  }
+  if (group.size() == 0) {
+    sharedTransitionGroups_.erase(groupName);
+  }
+  viewTagToSharedTag_.erase(tag);
 }
 
 void LayoutAnimationsManager::startLayoutAnimation(
     jsi::Runtime &rt,
     int tag,
-    const std::string &type,
+    LayoutAnimationType type,
     const jsi::Object &values) {
   std::shared_ptr<Shareable> config, viewShareable;
   {
     auto lock = std::unique_lock<std::mutex>(animationsMutex_);
-    if (type == "entering") {
-      config = enteringAnimations_[tag];
-    } else if (type == "exiting") {
-      config = exitingAnimations_[tag];
-    } else if (type == "layout") {
-      config = layoutAnimations_[tag];
-    }
+    config = getConfigsForType(type)[tag];
   }
-
   // TODO: cache the following!!
   jsi::Value layoutAnimationRepositoryAsValue =
       rt.global()
@@ -68,9 +66,66 @@ void LayoutAnimationsManager::startLayoutAnimation(
   startAnimationForTag.call(
       rt,
       jsi::Value(tag),
-      jsi::String::createFromAscii(rt, type),
+      jsi::Value(static_cast<int>(type)),
       values,
       config->getJSValue(rt));
 }
 
+void LayoutAnimationsManager::cancelLayoutAnimation(
+    jsi::Runtime &rt,
+    int tag,
+    LayoutAnimationType type,
+    bool cancelled = true,
+    bool removeView = true) {
+  jsi::Value layoutAnimationRepositoryAsValue =
+      rt.global()
+          .getPropertyAsObject(rt, "global")
+          .getProperty(rt, "LayoutAnimationsManager");
+  jsi::Function cancelLayoutAnimation =
+      layoutAnimationRepositoryAsValue.getObject(rt).getPropertyAsFunction(
+          rt, "stop");
+  std::shared_ptr<Shareable> config;
+  {
+    auto lock = std::unique_lock<std::mutex>(animationsMutex_);
+    config = sharedTransitionAnimations_[tag];
+  }
+  if (config != nullptr) {
+    cancelLayoutAnimation.call(
+        rt, jsi::Value(tag), config->getJSValue(rt), cancelled, removeView);
+  }
+}
+
+/*
+  The top screen on the stack triggers the animation, so we need to find
+  the sibling view registered in the past. This method finds view
+  registered in the same transition group (with the same transition tag)
+  which has been added to that group directly before the one that we
+  provide as an argument.
+*/
+int LayoutAnimationsManager::findPrecedingViewTagForTransition(int tag) {
+  auto const &groupName = viewTagToSharedTag_[tag];
+  auto const &group = sharedTransitionGroups_[groupName];
+  auto position = std::find(group.begin(), group.end(), tag);
+  if (position != group.end() && position != group.begin()) {
+    return *std::prev(position);
+  }
+  return -1;
+}
+
+std::unordered_map<int, std::shared_ptr<Shareable>>
+    &LayoutAnimationsManager::getConfigsForType(LayoutAnimationType type) {
+  switch (type) {
+    case ENTERING:
+      return enteringAnimations_;
+    case EXITING:
+      return exitingAnimations_;
+    case LAYOUT:
+      return layoutAnimations_;
+    case SHARED_ELEMENT_TRANSITION:
+      return sharedTransitionAnimations_;
+    default:
+      assert(false);
+  }
+}
+
 } // namespace reanimated

package/Common/cpp/LayoutAnimations/LayoutAnimationsManager.h

@@ -1,6 +1,7 @@
 #pragma once
 
 #include "ErrorHandler.h"
+#include "LayoutAnimationType.h"
 #include "Shareables.h"
 
 #include <jsi/jsi.h>
@@ -10,6 +11,7 @@
 #include <mutex>
 #include <string>
 #include <unordered_map>
+#include <vector>
 
 namespace reanimated {
 
@@ -19,20 +21,35 @@ class LayoutAnimationsManager {
  public:
   void configureAnimation(
       int tag,
-      const std::string &type,
+      LayoutAnimationType type,
+      const std::string &sharedTransitionTag,
       std::shared_ptr<Shareable> config);
-  bool hasLayoutAnimation(int tag, const std::string &type);
+  bool hasLayoutAnimation(int tag, LayoutAnimationType type);
   void startLayoutAnimation(
       jsi::Runtime &rt,
       int tag,
-      const std::string &type,
+      LayoutAnimationType type,
       const jsi::Object &values);
   void clearLayoutAnimationConfig(int tag);
+  void cancelLayoutAnimation(
+      jsi::Runtime &rt,
+      int tag,
+      LayoutAnimationType type,
+      bool cancelled /* = true */,
+      bool removeView /* = true */);
+  int findPrecedingViewTagForTransition(int tag);
 
  private:
+  std::unordered_map<int, std::shared_ptr<Shareable>> &getConfigsForType(
+      LayoutAnimationType type);
+
   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_map<std::string, std::vector<int>> sharedTransitionGroups_;
+  std::unordered_map<int, std::string> viewTagToSharedTag_;
   mutable std::mutex
       animationsMutex_; // Protects `enteringAnimations_`, `exitingAnimations_`,
                         // `layoutAnimations_` and `viewSharedValues_`.