react-native-reanimated 0.0.0-20230509-6d9c5aec5

package/Common/cpp/AnimatedSensor/AnimatedSensorModule.cpp

@@ -0,0 +1,88 @@
+#include "AnimatedSensorModule.h"
+
+#include <memory>
+#include <utility>
+
+#include "Shareables.h"
+
+namespace reanimated {
+
+AnimatedSensorModule::AnimatedSensorModule(
+    const PlatformDepMethodsHolder &platformDepMethodsHolder)
+    : platformRegisterSensorFunction_(platformDepMethodsHolder.registerSensor),
+      platformUnregisterSensorFunction_(
+          platformDepMethodsHolder.unregisterSensor) {}
+
+AnimatedSensorModule::~AnimatedSensorModule() {
+  assert(sensorsIds_.empty());
+}
+
+jsi::Value AnimatedSensorModule::registerSensor(
+    jsi::Runtime &rt,
+    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);
+
+  int sensorId = platformRegisterSensorFunction_(
+      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]);
+          value.setProperty(rt, "qw", newValues[3]);
+          value.setProperty(rt, "yaw", newValues[4]);
+          value.setProperty(rt, "pitch", newValues[5]);
+          value.setProperty(rt, "roll", newValues[6]);
+          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]);
+          value.setProperty(rt, "interfaceOrientation", orientationDegrees);
+          runtimeHelper->runOnUIGuarded(handler, value);
+        }
+      });
+  if (sensorId != -1) {
+    sensorsIds_.insert(sensorId);
+  }
+  return jsi::Value(sensorId);
+}
+
+void AnimatedSensorModule::unregisterSensor(const jsi::Value &sensorId) {
+  // It is called during sensor hook unmounting
+  sensorsIds_.erase(sensorId.getNumber());
+  platformUnregisterSensorFunction_(sensorId.asNumber());
+}
+
+void AnimatedSensorModule::unregisterAllSensors() {
+  for (auto sensorId : sensorsIds_) {
+    platformUnregisterSensorFunction_(sensorId);
+  }
+  sensorsIds_.clear();
+}
+
+} // namespace reanimated

package/Common/cpp/AnimatedSensor/AnimatedSensorModule.h

@@ -0,0 +1,44 @@
+#pragma once
+
+#include <jsi/jsi.h>
+#include <memory>
+#include <unordered_set>
+
+#include "PlatformDepMethodsHolder.h"
+#include "RuntimeManager.h"
+#include "Shareables.h"
+
+namespace reanimated {
+
+using namespace facebook;
+
+enum SensorType {
+  ACCELEROMETER = 1,
+  GYROSCOPE = 2,
+  GRAVITY = 3,
+  MAGNETIC_FIELD = 4,
+  ROTATION_VECTOR = 5,
+};
+
+class AnimatedSensorModule {
+  std::unordered_set<int> sensorsIds_;
+  RegisterSensorFunction platformRegisterSensorFunction_;
+  UnregisterSensorFunction platformUnregisterSensorFunction_;
+
+ public:
+  AnimatedSensorModule(
+      const PlatformDepMethodsHolder &platformDepMethodsHolder);
+  ~AnimatedSensorModule();
+
+  jsi::Value registerSensor(
+      jsi::Runtime &rt,
+      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

@@ -0,0 +1,29 @@
+#ifdef RCT_NEW_ARCH_ENABLED
+
+#include "FabricUtils.h"
+
+#include <react/renderer/debug/SystraceSection.h>
+#include <react/renderer/uimanager/UIManagerBinding.h>
+
+using namespace facebook::react;
+
+namespace reanimated {
+
+#ifdef ANDROID
+RuntimeExecutor getRuntimeExecutorFromBinding(Binding *binding) {
+  BindingPublic *bindingPublic = reinterpret_cast<BindingPublic *>(binding);
+  SchedulerPublic *schedulerPublic =
+      reinterpret_cast<SchedulerPublic *>((bindingPublic->scheduler_).get());
+  return schedulerPublic->runtimeExecutor_;
+}
+#endif
+
+std::shared_ptr<const ContextContainer> getContextContainerFromUIManager(
+    const UIManager *uiManager) {
+  return reinterpret_cast<const UIManagerPublic *>(uiManager)
+      ->contextContainer_;
+}
+
+} // namespace reanimated
+
+#endif // RCT_NEW_ARCH_ENABLED

package/Common/cpp/Fabric/FabricUtils.h

@@ -0,0 +1,58 @@
+#pragma once
+#ifdef RCT_NEW_ARCH_ENABLED
+
+#ifdef ANDROID
+#include <fbjni/fbjni.h>
+#include <react/fabric/Binding.h>
+#endif
+#include <react/renderer/uimanager/UIManager.h>
+
+#include <memory>
+#include <string>
+
+using namespace facebook;
+using namespace react;
+
+namespace reanimated {
+
+struct UIManagerBindingPublic {
+  void *vtable;
+  std::shared_ptr<UIManager> uiManager_;
+  std::unique_ptr<EventHandler const> eventHandler_;
+};
+
+struct UIManagerPublic {
+  void *vtable;
+  SharedComponentDescriptorRegistry componentDescriptorRegistry_;
+  UIManagerDelegate *delegate_;
+  UIManagerAnimationDelegate *animationDelegate_{nullptr};
+  RuntimeExecutor const runtimeExecutor_{};
+  ShadowTreeRegistry shadowTreeRegistry_{};
+  BackgroundExecutor const backgroundExecutor_{};
+  ContextContainer::Shared contextContainer_;
+};
+
+#ifdef ANDROID
+struct BindingPublic : public jni::HybridClass<Binding>,
+                       public SchedulerDelegate,
+                       public LayoutAnimationStatusDelegate {
+  std::shared_mutex installMutex_;
+  std::shared_ptr<FabricMountingManager> mountingManager_;
+  std::shared_ptr<facebook::react::Scheduler> scheduler_;
+};
+
+struct SchedulerPublic : public UIManagerDelegate {
+  SchedulerDelegate *delegate_;
+  SharedComponentDescriptorRegistry componentDescriptorRegistry_;
+  RuntimeExecutor runtimeExecutor_;
+};
+
+RuntimeExecutor getRuntimeExecutorFromBinding(Binding *binding);
+#endif
+
+std::shared_ptr<const ContextContainer> getContextContainerFromUIManager(
+    const UIManager *uiManager);
+
+} // namespace reanimated
+
+#endif // RCT_NEW_ARCH_ENABLED

package/Common/cpp/Fabric/ReanimatedUIManagerBinding.cpp

@@ -0,0 +1,239 @@
+#ifdef RCT_NEW_ARCH_ENABLED
+
+#include "ReanimatedUIManagerBinding.h"
+#include "FabricUtils.h"
+#include "NewestShadowNodesRegistry.h"
+
+#include <react/renderer/debug/SystraceSection.h>
+
+#include <utility>
+
+using namespace facebook;
+using namespace react;
+
+namespace reanimated {
+
+void ReanimatedUIManagerBinding::createAndInstallIfNeeded(
+    jsi::Runtime &runtime,
+    RuntimeExecutor const &runtimeExecutor,
+    std::shared_ptr<UIManager> const &uiManager,
+    std::shared_ptr<NewestShadowNodesRegistry> const
+        &newestShadowNodesRegistry) {
+  // adapted from UIManagerBinding.cpp
+  auto uiManagerModuleName = "nativeFabricUIManager";
+
+  auto eventHandler = [&]() -> std::unique_ptr<EventHandler const> {
+    auto uiManagerValue =
+        runtime.global().getProperty(runtime, uiManagerModuleName);
+    if (uiManagerValue.isUndefined()) {
+      return nullptr;
+    }
+
+    auto uiManagerBinding =
+        uiManagerValue.asObject(runtime).asHostObject<UIManagerBinding>(
+            runtime);
+    auto uiManagerBindingPublic =
+        reinterpret_cast<UIManagerBindingPublic *>(&*uiManagerBinding);
+    return std::move(uiManagerBindingPublic->eventHandler_);
+  }();
+
+  auto reanimatedUiManagerBinding =
+      std::make_shared<ReanimatedUIManagerBinding>(
+          uiManager,
+          runtimeExecutor,
+          std::move(eventHandler),
+          newestShadowNodesRegistry);
+  auto object =
+      jsi::Object::createFromHostObject(runtime, reanimatedUiManagerBinding);
+  runtime.global().setProperty(runtime, uiManagerModuleName, std::move(object));
+}
+
+ReanimatedUIManagerBinding::ReanimatedUIManagerBinding(
+    std::shared_ptr<UIManager> uiManager,
+    RuntimeExecutor runtimeExecutor,
+    std::unique_ptr<EventHandler const> eventHandler,
+    std::shared_ptr<NewestShadowNodesRegistry> newestShadowNodesRegistry)
+    : UIManagerBinding(uiManager),
+      uiManager_(std::move(uiManager)),
+      newestShadowNodesRegistry_(newestShadowNodesRegistry) {
+  if (eventHandler != nullptr) {
+    reinterpret_cast<UIManagerBindingPublic *>(this)->eventHandler_ =
+        std::move(eventHandler);
+  }
+}
+
+ReanimatedUIManagerBinding::~ReanimatedUIManagerBinding() {}
+
+static inline ShadowNode::Shared cloneNodeUsingNewest(
+    UIManager *uiManager,
+    NewestShadowNodesRegistry *newestShadowNodesRegistry,
+    ShadowNode const &shadowNode,
+    ShadowNode::SharedListOfShared const &children = nullptr,
+    RawProps const *rawProps = nullptr) {
+  {
+    auto lock = newestShadowNodesRegistry->createLock();
+    auto newest = newestShadowNodesRegistry->get(shadowNode.getTag());
+    if (newest != nullptr) {
+      // ShadowNode managed by Reanimated, use newest ShadowNode from registry
+      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(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(
+    jsi::Runtime &runtime,
+    jsi::PropNameID const &name) {
+  // Currently, we need to overwrite all variants of `cloneNode` as well as
+  // `appendChild` to prevent React from overwriting layout props animated using
+  // Reanimated. However, this may degrade performance due to using locks.
+  // We already have an idea how this can be done better without locks
+  // (i.e. by overwriting `completeRoot` and using UIManagerCommitHooks).
+
+  // 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();
+
+  // Semantic: Clones the node with *same* props and *same* children.
+  if (methodName == "cloneNode") {
+    return jsi::Function::createFromHostFunction(
+        runtime,
+        name,
+        1,
+        [uiManager, newestShadowNodesRegistry](
+            jsi::Runtime &runtime,
+            jsi::Value const & /*thisValue*/,
+            jsi::Value const *arguments,
+            size_t /*count*/) noexcept -> jsi::Value {
+          return valueFromShadowNode(
+              runtime,
+              cloneNodeUsingNewest(
+                  uiManager,
+                  newestShadowNodesRegistry,
+                  *shadowNodeFromValue(runtime, arguments[0])));
+        });
+  }
+
+  // Semantic: Clones the node with *same* props and *empty* children.
+  if (methodName == "cloneNodeWithNewChildren") {
+    return jsi::Function::createFromHostFunction(
+        runtime,
+        name,
+        1,
+        [uiManager, newestShadowNodesRegistry](
+            jsi::Runtime &runtime,
+            jsi::Value const & /*thisValue*/,
+            jsi::Value const *arguments,
+            size_t /*count*/) noexcept -> jsi::Value {
+          return valueFromShadowNode(
+              runtime,
+              cloneNodeUsingNewest(
+                  uiManager,
+                  newestShadowNodesRegistry,
+                  *shadowNodeFromValue(runtime, arguments[0]),
+                  ShadowNode::emptySharedShadowNodeSharedList()));
+        });
+  }
+
+  // Semantic: Clones the node with *given* props and *same* children.
+  if (methodName == "cloneNodeWithNewProps") {
+    return jsi::Function::createFromHostFunction(
+        runtime,
+        name,
+        2,
+        [uiManager, newestShadowNodesRegistry](
+            jsi::Runtime &runtime,
+            jsi::Value const & /*thisValue*/,
+            jsi::Value const *arguments,
+            size_t /*count*/) noexcept -> jsi::Value {
+          auto const &rawProps = RawProps(runtime, arguments[1]);
+          return valueFromShadowNode(
+              runtime,
+              cloneNodeUsingNewest(
+                  uiManager,
+                  newestShadowNodesRegistry,
+                  *shadowNodeFromValue(runtime, arguments[0]),
+                  nullptr,
+                  &rawProps));
+        });
+  }
+
+  // Semantic: Clones the node with *given* props and *empty* children.
+  if (methodName == "cloneNodeWithNewChildrenAndProps") {
+    return jsi::Function::createFromHostFunction(
+        runtime,
+        name,
+        2,
+        [uiManager, newestShadowNodesRegistry](
+            jsi::Runtime &runtime,
+            jsi::Value const & /*thisValue*/,
+            jsi::Value const *arguments,
+            size_t /*count*/) noexcept -> jsi::Value {
+          auto const &rawProps = RawProps(runtime, arguments[1]);
+          return valueFromShadowNode(
+              runtime,
+              cloneNodeUsingNewest(
+                  uiManager,
+                  newestShadowNodesRegistry,
+                  *shadowNodeFromValue(runtime, arguments[0]),
+                  ShadowNode::emptySharedShadowNodeSharedList(),
+                  &rawProps));
+        });
+  }
+
+  if (methodName == "appendChild") {
+    return jsi::Function::createFromHostFunction(
+        runtime,
+        name,
+        2,
+        [uiManager, newestShadowNodesRegistry](
+            jsi::Runtime &runtime,
+            jsi::Value const & /*thisValue*/,
+            jsi::Value const *arguments,
+            size_t /*count*/) noexcept -> jsi::Value {
+          appendChildUsingNewest(
+              uiManager,
+              newestShadowNodesRegistry,
+              shadowNodeFromValue(runtime, arguments[0]),
+              shadowNodeFromValue(runtime, arguments[1]));
+          return jsi::Value::undefined();
+        });
+  }
+
+  // Methods like "findNodeAtPoint", "getRelativeLayoutMetrics", "measure" etc.
+  // use `UIManager::getNewestCloneOfShadowNode` or
+  // `ShadowTree::getCurrentRevision` under the hood,
+  // so there's no need to overwrite them.
+
+  return UIManagerBinding::get(runtime, name);
+}
+
+} // namespace reanimated
+
+#endif // RCT_NEW_ARCH_ENABLED

package/Common/cpp/Fabric/ReanimatedUIManagerBinding.h

@@ -0,0 +1,47 @@
+#pragma once
+#ifdef RCT_NEW_ARCH_ENABLED
+
+#include <ReactCommon/RuntimeExecutor.h>
+#include <jsi/jsi.h>
+#include <react/renderer/uimanager/UIManager.h>
+#include <react/renderer/uimanager/UIManagerBinding.h>
+#include <react/renderer/uimanager/primitives.h>
+
+#include <memory>
+
+#include "NewestShadowNodesRegistry.h"
+
+using namespace facebook;
+using namespace react;
+
+namespace reanimated {
+
+class ReanimatedUIManagerBinding : public UIManagerBinding {
+ public:
+  static void createAndInstallIfNeeded(
+      jsi::Runtime &runtime,
+      RuntimeExecutor const &runtimeExecutor,
+      std::shared_ptr<UIManager> const &uiManager,
+      std::shared_ptr<NewestShadowNodesRegistry> const
+          &newestShadowNodesRegistry);
+
+  ReanimatedUIManagerBinding(
+      std::shared_ptr<UIManager> uiManager,
+      RuntimeExecutor runtimeExecutor,
+      std::unique_ptr<EventHandler const> eventHandler,
+      std::shared_ptr<NewestShadowNodesRegistry> newestShadowNodesRegistry);
+
+  ~ReanimatedUIManagerBinding();
+
+  void invalidate() const;
+
+  jsi::Value get(jsi::Runtime &runtime, jsi::PropNameID const &name) override;
+
+ private:
+  std::shared_ptr<UIManager> uiManager_;
+  std::shared_ptr<NewestShadowNodesRegistry> newestShadowNodesRegistry_;
+};
+
+} // namespace reanimated
+
+#endif // RCT_NEW_ARCH_ENABLED

package/Common/cpp/Fabric/ShadowTreeCloner.cpp

@@ -0,0 +1,92 @@
+#ifdef RCT_NEW_ARCH_ENABLED
+
+#include "ShadowTreeCloner.h"
+#include "FabricUtils.h"
+
+namespace reanimated {
+
+ShadowTreeCloner::ShadowTreeCloner(
+    std::shared_ptr<NewestShadowNodesRegistry> newestShadowNodesRegistry,
+    std::shared_ptr<UIManager> uiManager,
+    SurfaceId surfaceId)
+    : newestShadowNodesRegistry_{newestShadowNodesRegistry},
+      propsParserContext_{
+          surfaceId,
+          *getContextContainerFromUIManager(&*uiManager)} {}
+
+ShadowTreeCloner::~ShadowTreeCloner() {
+#ifdef DEBUG
+  react_native_assert(
+      yogaChildrenUpdates_.empty() &&
+      "Deallocating `ShadowTreeCloner` without calling `updateYogaChildren`.");
+#endif
+}
+
+ShadowNode::Unshared ShadowTreeCloner::cloneWithNewProps(
+    const ShadowNode::Shared &oldRootNode,
+    const ShadowNodeFamily &family,
+    RawProps &&rawProps) {
+  // adapted from ShadowNode::cloneTree
+
+  auto ancestors = family.getAncestors(*oldRootNode);
+
+  if (ancestors.empty()) {
+    return ShadowNode::Unshared{nullptr};
+  }
+
+  auto &parent = ancestors.back();
+  auto &oldShadowNode = parent.first.get().getChildren().at(parent.second);
+
+  const auto newest = newestShadowNodesRegistry_->get(oldShadowNode->getTag());
+
+  const auto &source = newest == nullptr ? oldShadowNode : newest;
+
+  const auto props = source->getComponentDescriptor().cloneProps(
+      propsParserContext_, source->getProps(), rawProps);
+
+  auto newChildNode = source->clone({/* .props = */ props});
+
+  for (auto it = ancestors.rbegin(); it != ancestors.rend(); ++it) {
+    auto &parentNode = it->first.get();
+    auto childIndex = it->second;
+
+    auto children = parentNode.getChildren();
+    const auto &oldChildNode = *children.at(childIndex);
+    react_native_assert(ShadowNode::sameFamily(oldChildNode, *newChildNode));
+
+    newestShadowNodesRegistry_->set(newChildNode, parentNode.getTag());
+
+    if (!parentNode.getSealed()) {
+      // Optimization: if a ShadowNode is unsealed, we can directly update its
+      // children instead of cloning the whole path to the root node.
+      auto &parentNodeNonConst = const_cast<ShadowNode &>(parentNode);
+      parentNodeNonConst.replaceChild(oldChildNode, newChildNode, childIndex);
+      yogaChildrenUpdates_.insert(&parentNodeNonConst);
+      return std::const_pointer_cast<ShadowNode>(oldRootNode);
+    }
+
+    children[childIndex] = newChildNode;
+
+    newChildNode = parentNode.clone({
+        ShadowNodeFragment::propsPlaceholder(),
+        std::make_shared<ShadowNode::ListOfShared>(children),
+    });
+  }
+
+  return std::const_pointer_cast<ShadowNode>(newChildNode);
+}
+
+void ShadowTreeCloner::updateYogaChildren() {
+  // Unfortunately, `replaceChild` does not update Yoga nodes, so we need to
+  // update them manually here.
+  for (ShadowNode *shadowNode : yogaChildrenUpdates_) {
+    static_cast<YogaLayoutableShadowNode *>(shadowNode)->updateYogaChildren();
+  }
+#ifdef DEBUG
+  yogaChildrenUpdates_.clear();
+#endif
+}
+
+} // namespace reanimated
+
+#endif // RCT_NEW_ARCH_ENABLED

package/Common/cpp/Fabric/ShadowTreeCloner.h

@@ -0,0 +1,41 @@
+#pragma once
+#ifdef RCT_NEW_ARCH_ENABLED
+
+#include <react/renderer/core/PropsParserContext.h>
+#include <react/renderer/uimanager/UIManager.h>
+
+#include <memory>
+#include <set>
+
+#include "NewestShadowNodesRegistry.h"
+
+using namespace facebook;
+using namespace react;
+
+namespace reanimated {
+
+class ShadowTreeCloner {
+ public:
+  ShadowTreeCloner(
+      std::shared_ptr<NewestShadowNodesRegistry> newestShadowNodesRegistry,
+      std::shared_ptr<UIManager> uiManager,
+      SurfaceId surfaceId);
+
+  ~ShadowTreeCloner();
+
+  ShadowNode::Unshared cloneWithNewProps(
+      const ShadowNode::Shared &oldRootNode,
+      const ShadowNodeFamily &family,
+      RawProps &&rawProps);
+
+  void updateYogaChildren();
+
+ private:
+  std::shared_ptr<NewestShadowNodesRegistry> newestShadowNodesRegistry_;
+  PropsParserContext propsParserContext_;
+  std::set<ShadowNode *> yogaChildrenUpdates_;
+};
+
+} // namespace reanimated
+
+#endif // RCT_NEW_ARCH_ENABLED

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;