react-native-reanimated 3.0.0-rc.4 → 3.0.0-rc.6

package/Common/cpp/LayoutAnimations/LayoutAnimationsProxy.cpp

@@ -11,35 +11,117 @@ namespace reanimated {
 const long long idOffset = 1e9;
 
 LayoutAnimationsProxy::LayoutAnimationsProxy(
-    std::function<void(int, jsi::Object newProps)> _notifyAboutProgress,
-    std::function<void(int, bool)> _notifyAboutEnd)
-    : notifyAboutProgress(std::move(_notifyAboutProgress)),
-      notifyAboutEnd(std::move(_notifyAboutEnd)) {}
+    std::function<void(int, jsi::Object newProps)> progressHandler,
+    std::function<void(int, bool, bool)> endHandler,
+    std::weak_ptr<ErrorHandler> weakErrorHandler)
+    : progressHandler_(std::move(progressHandler)),
+      endHandler_(std::move(endHandler)),
+      weakErrorHandler_(weakErrorHandler) {}
 
 void LayoutAnimationsProxy::startObserving(
     int tag,
     std::shared_ptr<MutableValue> sv,
     jsi::Runtime &rt) {
-  observedValues[tag] = sv;
+  observedValues_[tag] = sv;
+  this->progressHandler_(tag, sv->value->toJSValue(rt).asObject(rt));
   sv->addListener(tag + idOffset, [sv, tag, this, &rt]() {
-    std::shared_ptr<FrozenObject> newValue =
-        ValueWrapper::asFrozenObject(sv->value->valueContainer);
-    this->notifyAboutProgress(tag, newValue->shallowClone(rt));
+    this->progressHandler_(tag, sv->value->toJSValue(rt).asObject(rt));
   });
 }
 
-void LayoutAnimationsProxy::stopObserving(int tag, bool finished) {
-  if (observedValues.count(tag) == 0) {
+void LayoutAnimationsProxy::stopObserving(
+    int tag,
+    bool finished,
+    bool removeView) {
+  if (observedValues_.count(tag) == 0) {
     return;
   }
-  std::shared_ptr<MutableValue> sv = observedValues[tag];
+  std::shared_ptr<MutableValue> sv = observedValues_[tag];
   sv->removeListener(tag + idOffset);
-  observedValues.erase(tag);
-  this->notifyAboutEnd(tag, !finished);
+  observedValues_.erase(tag);
+  this->endHandler_(tag, !finished, removeView);
+}
+
+void LayoutAnimationsProxy::configureAnimation(
+    int tag,
+    const std::string &type,
+    std::shared_ptr<ShareableValue> config,
+    std::shared_ptr<ShareableValue> viewSharedValue) {
+  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;
+  }
+  viewSharedValues_[tag] = viewSharedValue;
+}
+
+bool LayoutAnimationsProxy::hasLayoutAnimation(
+    int tag,
+    const std::string &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;
+}
+
+void LayoutAnimationsProxy::clearLayoutAnimationConfig(int tag) {
+  auto lock = std::unique_lock<std::mutex>(animationsMutex_);
+  enteringAnimations_.erase(tag);
+  exitingAnimations_.erase(tag);
+  layoutAnimations_.erase(tag);
+  viewSharedValues_.erase(tag);
 }
 
-void LayoutAnimationsProxy::notifyAboutCancellation(int tag) {
-  this->notifyAboutEnd(tag, false);
+void LayoutAnimationsProxy::startLayoutAnimation(
+    jsi::Runtime &rt,
+    int tag,
+    const std::string &type,
+    const jsi::Object &values) {
+  std::shared_ptr<ShareableValue> config;
+  std::shared_ptr<ShareableValue> viewSharedValue;
+  {
+    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];
+    }
+    viewSharedValue = viewSharedValues_[tag];
+  }
+
+  jsi::Value layoutAnimationRepositoryAsValue =
+      rt.global()
+          .getPropertyAsObject(rt, "global")
+          .getProperty(rt, "LayoutAnimationRepository");
+  if (layoutAnimationRepositoryAsValue.isUndefined()) {
+    auto errorHandler = weakErrorHandler_.lock();
+    if (errorHandler != nullptr) {
+      errorHandler->setError(
+          "startLayoutAnimation called before initializing LayoutAnimationRepository");
+      errorHandler->raise();
+    }
+    return;
+  }
+  jsi::Function startAnimationForTag =
+      layoutAnimationRepositoryAsValue.getObject(rt).getPropertyAsFunction(
+          rt, "startAnimationForTag");
+  startAnimationForTag.call(
+      rt,
+      jsi::Value(tag),
+      jsi::String::createFromAscii(rt, type),
+      values,
+      config->toJSValue(rt),
+      viewSharedValue->toJSValue(rt));
 }
 
 } // namespace reanimated

package/Common/cpp/LayoutAnimations/LayoutAnimationsProxy.h

@@ -1,32 +1,56 @@
 #pragma once
 
+#include <ErrorHandler.h>
 #include <jsi/jsi.h>
 #include <stdio.h>
 #include <functional>
-#include <map>
 #include <memory>
+#include <mutex>
+#include <string>
+#include <unordered_map>
 
 namespace reanimated {
 
 using namespace facebook;
 
 class MutableValue;
+class ShareableValue;
 
 class LayoutAnimationsProxy {
  public:
   LayoutAnimationsProxy(
-      std::function<void(int, jsi::Object newProps)> _notifyAboutProgress,
-      std::function<void(int, bool)> _notifyAboutEnd);
+      std::function<void(int, jsi::Object newProps)> progressHandler,
+      std::function<void(int, bool, bool)> endHandler,
+      std::weak_ptr<ErrorHandler> weakErrorHandler);
 
   void
   startObserving(int tag, std::shared_ptr<MutableValue> sv, jsi::Runtime &rt);
-  void stopObserving(int tag, bool finished);
-  void notifyAboutCancellation(int tag);
+  void stopObserving(int tag, bool finished, bool removeView);
+  void configureAnimation(
+      int tag,
+      const std::string &type,
+      std::shared_ptr<ShareableValue> config,
+      std::shared_ptr<ShareableValue> viewSharedValue);
+  bool hasLayoutAnimation(int tag, const std::string &type);
+  void startLayoutAnimation(
+      jsi::Runtime &rt,
+      int tag,
+      const std::string &type,
+      const jsi::Object &values);
+  void clearLayoutAnimationConfig(int tag);
 
  private:
-  std::function<void(int, jsi::Object newProps)> notifyAboutProgress;
-  std::function<void(int, bool)> notifyAboutEnd;
-  std::map<int, std::shared_ptr<MutableValue>> observedValues;
+  std::function<void(int, jsi::Object newProps)> progressHandler_;
+  std::function<void(int, bool, bool)> endHandler_;
+  std::weak_ptr<ErrorHandler> weakErrorHandler_;
+  std::unordered_map<int, std::shared_ptr<MutableValue>> observedValues_;
+  std::unordered_map<int, std::shared_ptr<ShareableValue>> viewSharedValues_;
+  std::unordered_map<int, std::shared_ptr<ShareableValue>> enteringAnimations_;
+  std::unordered_map<int, std::shared_ptr<ShareableValue>> exitingAnimations_;
+  std::unordered_map<int, std::shared_ptr<ShareableValue>> layoutAnimations_;
+  mutable std::mutex
+      animationsMutex_; // Protects `enteringAnimations_`, `exitingAnimations_`,
+                        // `layoutAnimations_` and `viewSharedValues_`.
 };
 
 } // namespace reanimated

package/Common/cpp/NativeModules/NativeReanimatedModule.cpp

@@ -87,6 +87,7 @@ NativeReanimatedModule::NativeReanimatedModule(
     PlatformDepMethodsHolder platformDepMethodsHolder)
     : NativeReanimatedModuleSpec(jsInvoker),
       RuntimeManager(rt, errorHandler, scheduler, RuntimeType::UI),
+      layoutAnimationsProxy_(layoutAnimationsProxy),
       mapperRegistry(std::make_shared<MapperRegistry>()),
       eventHandlerRegistry(std::make_shared<EventHandlerRegistry>()),
       requestRender(platformDepMethodsHolder.requestRender),
@@ -109,7 +110,7 @@ NativeReanimatedModule::NativeReanimatedModule(
     maybeRequestRender();
   };
 
-  this->layoutAnimationsProxy = layoutAnimationsProxy;
+  this->layoutAnimationsProxy_ = layoutAnimationsProxy;
 
 #ifdef RCT_NEW_ARCH_ENABLED
   auto updateProps = [this](
@@ -337,6 +338,20 @@ jsi::Value NativeReanimatedModule::configureProps(
   return jsi::Value::undefined();
 }
 
+jsi::Value NativeReanimatedModule::configureLayoutAnimation(
+    jsi::Runtime &rt,
+    const jsi::Value &viewTag,
+    const jsi::Value &type,
+    const jsi::Value &config,
+    const jsi::Value &viewSharedValue) {
+  layoutAnimationsProxy_->configureAnimation(
+      viewTag.asNumber(),
+      type.asString(rt).utf8(rt),
+      ShareableValue::adapt(rt, config, this),
+      ShareableValue::adapt(rt, viewSharedValue, this));
+  return jsi::Value::undefined();
+}
+
 void NativeReanimatedModule::onEvent(
     std::string eventName,
 #ifdef RCT_NEW_ARCH_ENABLED

package/Common/cpp/NativeModules/NativeReanimatedModule.h

@@ -144,11 +144,19 @@ class NativeReanimatedModule : public NativeReanimatedModuleSpec,
       jsi::Runtime &rt,
       const jsi::Value &listenerId) override;
 
+  jsi::Value configureLayoutAnimation(
+      jsi::Runtime &rt,
+      const jsi::Value &viewTag,
+      const jsi::Value &type,
+      const jsi::Value &config,
+      const jsi::Value &viewSharedValue) override;
+
  private:
 #ifdef RCT_NEW_ARCH_ENABLED
   bool isThereAnyLayoutProp(jsi::Runtime &rt, const jsi::Value &props);
 #endif // RCT_NEW_ARCH_ENABLED
 
+  std::shared_ptr<LayoutAnimationsProxy> layoutAnimationsProxy_;
   std::shared_ptr<MapperRegistry> mapperRegistry;
   std::shared_ptr<EventHandlerRegistry> eventHandlerRegistry;
   std::function<void(FrameCallback &, jsi::Runtime &)> requestRender;
@@ -158,7 +166,6 @@ class NativeReanimatedModule : public NativeReanimatedModuleSpec,
   std::function<jsi::Value(jsi::Runtime &, const int, const jsi::String &)>
       propObtainer;
   std::function<void(double)> onRenderCallback;
-  std::shared_ptr<LayoutAnimationsProxy> layoutAnimationsProxy;
   AnimatedSensorModule animatedSensorModule;
   ConfigurePropsFunction configurePropsPlatformFunction;
 

package/Common/cpp/NativeModules/NativeReanimatedModuleSpec.cpp

@@ -159,6 +159,20 @@ static jsi::Value SPEC_PREFIX(unsubscribeFromKeyboardEvents)(
   return jsi::Value::undefined();
 }
 
+static jsi::Value SPEC_PREFIX(configureLayoutAnimation)(
+    jsi::Runtime &rt,
+    TurboModule &turboModule,
+    const jsi::Value *args,
+    size_t count) {
+  return static_cast<NativeReanimatedModuleSpec *>(&turboModule)
+      ->configureLayoutAnimation(
+          rt,
+          std::move(args[0]),
+          std::move(args[1]),
+          std::move(args[2]),
+          std::move(args[3]));
+}
+
 NativeReanimatedModuleSpec::NativeReanimatedModuleSpec(
     std::shared_ptr<CallInvoker> jsInvoker)
     : TurboModule("NativeReanimated", jsInvoker) {
@@ -188,5 +202,8 @@ NativeReanimatedModuleSpec::NativeReanimatedModuleSpec(
       MethodMetadata{1, SPEC_PREFIX(subscribeForKeyboardEvents)};
   methodMap_["unsubscribeFromKeyboardEvents"] =
       MethodMetadata{1, SPEC_PREFIX(unsubscribeFromKeyboardEvents)};
+
+  methodMap_["configureLayoutAnimation"] =
+      MethodMetadata{4, SPEC_PREFIX(configureLayoutAnimation)};
 }
 } // namespace reanimated

package/Common/cpp/NativeModules/NativeReanimatedModuleSpec.h

@@ -85,6 +85,14 @@ class JSI_EXPORT NativeReanimatedModuleSpec : public TurboModule {
       jsi::Runtime &rt,
       const jsi::Value &uiProps,
       const jsi::Value &nativeProps) = 0;
+
+  // layout animations
+  virtual jsi::Value configureLayoutAnimation(
+      jsi::Runtime &rt,
+      const jsi::Value &viewTag,
+      const jsi::Value &type,
+      const jsi::Value &config,
+      const jsi::Value &viewSharedValue) = 0;
 };
 
 } // namespace reanimated

package/Common/cpp/ReanimatedRuntime/ReanimatedRuntime.cpp

@@ -20,6 +20,7 @@ using namespace facebook;
 using namespace react;
 
 std::shared_ptr<jsi::Runtime> ReanimatedRuntime::make(
+    jsi::Runtime *rnRuntime,
     std::shared_ptr<MessageQueueThread> jsQueue) {
 #if JS_RUNTIME_HERMES
   std::unique_ptr<facebook::hermes::HermesRuntime> runtime =
@@ -37,7 +38,7 @@ std::shared_ptr<jsi::Runtime> ReanimatedRuntime::make(
   auto config = std::make_unique<rnv8::V8RuntimeConfig>();
   config->enableInspector = false;
   config->appName = "reanimated";
-  return rnv8::createSharedV8Runtime(runtime_, std::move(config));
+  return rnv8::createSharedV8Runtime(rnRuntime, std::move(config));
 #else
   // This is required by iOS, because there is an assertion in the destructor
   // that the thread was indeed `quit` before

package/Common/cpp/ReanimatedRuntime/ReanimatedRuntime.h

@@ -21,6 +21,7 @@ using namespace react;
 class ReanimatedRuntime {
  public:
   static std::shared_ptr<jsi::Runtime> make(
+      jsi::Runtime *rnRuntime,
       std::shared_ptr<MessageQueueThread> jsQueue);
 };
 

package/Common/cpp/Tools/RuntimeDecorator.cpp

@@ -277,7 +277,8 @@ void RuntimeDecorator::decorateUIRuntime(
     if (layoutProxy.expired()) {
       return jsi::Value::undefined();
     }
-    proxy->stopObserving(args[0].asNumber(), args[1].getBool());
+    proxy->stopObserving(
+        args[0].asNumber(), args[1].getBool(), args[2].getBool());
     return jsi::Value::undefined();
   };
   jsi::Value _stopObservingProgress = jsi::Function::createFromHostFunction(

package/android/CMakeLists.txt

@@ -332,3 +332,4 @@ endif()
 set (ignoreMe "${CLIENT_SIDE_BUILD}")
 set (ignoreMe "${JS_RUNTIME_DIR}")
 set (ignoreMe "${PLAYGROUND_APP_NAME}")
+set (ignoreMe "${REANIMATED_PACKAGE_BUILD}")

package/android/build.gradle

@@ -1,5 +1,6 @@
 import com.android.Version
 import org.apache.tools.ant.filters.ReplaceTokens
+import org.apache.tools.ant.taskdefs.condition.Os
 import groovy.json.JsonSlurper
 import java.nio.file.Paths
 
@@ -183,6 +184,13 @@ def getReanimatedVersion() {
     return major.toInteger()
 }
 
+def toPlatformFileString(String path) {
+  if (Os.isFamily(Os.FAMILY_WINDOWS)) {
+      path = path.replace(File.separatorChar, '/' as char)
+  }
+  return path
+}
+
 boolean CLIENT_SIDE_BUILD = resolveClientSideBuild()
 if (CLIENT_SIDE_BUILD) {
     configurations.maybeCreate("default")
@@ -447,7 +455,7 @@ android {
                         "-DREACT_NATIVE_MINOR_VERSION=${REACT_NATIVE_MINOR_VERSION}",
                         "-DANDROID_TOOLCHAIN=clang",
                         "-DBOOST_VERSION=${BOOST_VERSION}",
-                        "-DREACT_NATIVE_DIR=${reactNativeRootDir.path}",
+                        "-DREACT_NATIVE_DIR=${toPlatformFileString(reactNativeRootDir.path)}",
                         "-DJS_RUNTIME=${JS_RUNTIME}",
                         "-DJS_RUNTIME_DIR=${jsRuntimeDir}",
                         "-DCLIENT_SIDE_BUILD=${CLIENT_SIDE_BUILD}",

package/android/src/fabric/java/com/swmansion/reanimated/NativeProxy.java

@@ -307,31 +307,22 @@ public class NativeProxy {
 
     WeakReference<LayoutAnimations> weakLayoutAnimations = new WeakReference<>(LayoutAnimations);
     animationsManager.setNativeMethods(
-        new NativeMethodsHolder() {
-          @Override
-          public void startAnimationForTag(int tag, String type, HashMap<String, Float> values) {
-            LayoutAnimations LayoutAnimations = weakLayoutAnimations.get();
-            if (LayoutAnimations != null) {
-              HashMap<String, String> preparedValues = new HashMap<>();
-              for (String key : values.keySet()) {
-                preparedValues.put(key, values.get(key).toString());
+            new NativeMethodsHolder() {
+              @Override
+              public void startAnimation(int tag, String type, HashMap<String, Float> values) {}
+
+              @Override
+              public boolean isLayoutAnimationEnabled() {
+                return false;
+              }
+
+              @Override
+              public boolean hasAnimation(int tag, String type) {
+                return false;
               }
-              LayoutAnimations.startAnimationForTag(tag, type, preparedValues);
-            }
-          }
-
-          @Override
-          public void removeConfigForTag(int tag) {
-            LayoutAnimations LayoutAnimations = weakLayoutAnimations.get();
-            if (LayoutAnimations != null) {
-              LayoutAnimations.removeConfigForTag(tag);
-            }
-          }
-
-          @Override
-          public boolean isLayoutAnimationEnabled() {
-            return LayoutAnimations.isLayoutAnimationEnabled();
-          }
-        });
+
+              @Override
+              public void clearAnimationConfig(int tag) {}
+            });
   }
 }

package/android/src/main/cpp/LayoutAnimations.cpp

@@ -17,70 +17,59 @@ void LayoutAnimations::setWeakUIRuntime(std::weak_ptr<jsi::Runtime> wrt) {
   this->weakUIRuntime = wrt;
 }
 
+void LayoutAnimations::setAnimationStartingBlock(
+    AnimationStartingBlock animationStartingBlock) {
+  this->animationStartingBlock_ = animationStartingBlock;
+}
+
 void LayoutAnimations::startAnimationForTag(
     int tag,
     alias_ref<JString> type,
     alias_ref<JMap<jstring, jstring>> values) {
-  if (auto rt = this->weakUIRuntime.lock()) {
-    jsi::Value layoutAnimationRepositoryAsValue =
-        rt->global()
-            .getPropertyAsObject(*rt, "global")
-            .getProperty(*rt, "LayoutAnimationRepository");
-    if (!layoutAnimationRepositoryAsValue.isUndefined()) {
-      jsi::Function startAnimationForTag =
-          layoutAnimationRepositoryAsValue.getObject(*rt).getPropertyAsFunction(
-              *rt, "startAnimationForTag");
-      jsi::Object target(*rt);
-
-      for (const auto &entry : *values) {
-        target.setProperty(
-            *rt,
-            entry.first->toStdString().c_str(),
-            std::stof(entry.second->toStdString()));
-      }
-      startAnimationForTag.call(
-          *rt,
-          jsi::Value(tag),
-          jsi::String::createFromUtf8(*rt, type->toStdString()),
-          target);
-    }
-  }
+  this->animationStartingBlock_(tag, type, values);
 }
 
-void LayoutAnimations::removeConfigForTag(int tag) {
-  if (auto rt = this->weakUIRuntime.lock()) {
-    jsi::Value layoutAnimationRepositoryAsValue =
-        rt->global()
-            .getPropertyAsObject(*rt, "global")
-            .getProperty(*rt, "LayoutAnimationRepository");
-    if (!layoutAnimationRepositoryAsValue.isUndefined()) {
-      jsi::Function removeConfig =
-          layoutAnimationRepositoryAsValue.getObject(*rt).getPropertyAsFunction(
-              *rt, "removeConfig");
-      removeConfig.call(*rt, jsi::Value(tag));
-    }
-  }
-}
-
-void LayoutAnimations::notifyAboutProgress(
-    const jsi::Value &progress,
-    int tag) {
+void LayoutAnimations::progressLayoutAnimation(
+    int tag,
+    const jsi::Value &progress) {
   if (auto rt = this->weakUIRuntime.lock()) {
     static const auto method =
         javaPart_->getClass()
-            ->getMethod<void(JMap<JString, JObject>::javaobject, int)>(
-                "notifyAboutProgress");
+            ->getMethod<void(int, JMap<JString, JObject>::javaobject)>(
+                "progressLayoutAnimation");
     method(
         javaPart_.get(),
-        JNIHelper::ConvertToPropsMap(*rt, progress.asObject(*rt)).get(),
-        tag);
+        tag,
+        JNIHelper::ConvertToPropsMap(*rt, progress.asObject(*rt)).get());
   }
 }
 
-void LayoutAnimations::notifyAboutEnd(int tag, int cancelled) {
+void LayoutAnimations::endLayoutAnimation(
+    int tag,
+    bool cancelled,
+    bool removeView) {
   static const auto method =
-      javaPart_->getClass()->getMethod<void(int, int)>("notifyAboutEnd");
-  method(javaPart_.get(), tag, cancelled);
+      javaPart_->getClass()->getMethod<void(int, bool, bool)>(
+          "endLayoutAnimation");
+  method(javaPart_.get(), tag, cancelled, removeView);
+}
+
+void LayoutAnimations::setHasAnimationBlock(
+    HasAnimationBlock hasAnimationBlock) {
+  this->hasAnimationBlock_ = hasAnimationBlock;
+}
+
+bool LayoutAnimations::hasAnimationForTag(int tag, std::string type) {
+  return hasAnimationBlock_(tag, type);
+}
+
+void LayoutAnimations::setClearAnimationConfigBlock(
+    ClearAnimationConfigBlock clearAnimationConfigBlock) {
+  this->clearAnimationConfigBlock_ = clearAnimationConfigBlock;
+}
+
+void LayoutAnimations::clearAnimationConfigForTag(int tag) {
+  clearAnimationConfigBlock_(tag);
 }
 
 bool LayoutAnimations::isLayoutAnimationEnabled() {
@@ -93,7 +82,10 @@ void LayoutAnimations::registerNatives() {
       makeNativeMethod(
           "startAnimationForTag", LayoutAnimations::startAnimationForTag),
       makeNativeMethod(
-          "removeConfigForTag", LayoutAnimations::removeConfigForTag),
+          "hasAnimationForTag", LayoutAnimations::hasAnimationForTag),
+      makeNativeMethod(
+          "clearAnimationConfigForTag",
+          LayoutAnimations::clearAnimationConfigForTag),
       makeNativeMethod(
           "isLayoutAnimationEnabled",
           LayoutAnimations::isLayoutAnimationEnabled),

package/android/src/main/cpp/LayoutAnimations.h

@@ -3,6 +3,7 @@
 #include <fbjni/fbjni.h>
 #include <jsi/jsi.h>
 #include <memory>
+#include <string>
 #include "JNIHelper.h"
 
 namespace reanimated {
@@ -11,6 +12,11 @@ using namespace facebook::jni;
 using namespace facebook;
 
 class LayoutAnimations : public jni::HybridClass<LayoutAnimations> {
+  using AnimationStartingBlock = std::function<
+      void(int, alias_ref<JString>, alias_ref<JMap<jstring, jstring>>)>;
+  using HasAnimationBlock = std::function<bool(int, std::string)>;
+  using ClearAnimationConfigBlock = std::function<void(int)>;
+
  public:
   static auto constexpr kJavaDescriptor =
       "Lcom/swmansion/reanimated/layoutReanimation/LayoutAnimations;";
@@ -22,18 +28,26 @@ class LayoutAnimations : public jni::HybridClass<LayoutAnimations> {
       int tag,
       alias_ref<JString> type,
       alias_ref<JMap<jstring, jstring>> values);
-  void removeConfigForTag(int tag);
+  bool hasAnimationForTag(int tag, std::string type);
   bool isLayoutAnimationEnabled();
 
   void setWeakUIRuntime(std::weak_ptr<jsi::Runtime> wrt);
+  void setAnimationStartingBlock(AnimationStartingBlock animationStartingBlock);
+  void setHasAnimationBlock(HasAnimationBlock hasAnimationBlock);
+  void setClearAnimationConfigBlock(
+      ClearAnimationConfigBlock clearAnimationConfigBlock);
 
-  void notifyAboutProgress(const jsi::Value &progress, int tag);
-  void notifyAboutEnd(int tag, int cancelled);
+  void progressLayoutAnimation(int tag, const jsi::Value &progress);
+  void endLayoutAnimation(int tag, bool cancelled, bool removeView);
+  void clearAnimationConfigForTag(int tag);
 
  private:
   friend HybridBase;
   jni::global_ref<LayoutAnimations::javaobject> javaPart_;
   std::weak_ptr<jsi::Runtime> weakUIRuntime;
+  AnimationStartingBlock animationStartingBlock_;
+  HasAnimationBlock hasAnimationBlock_;
+  ClearAnimationConfigBlock clearAnimationConfigBlock_;
 
   explicit LayoutAnimations(
       jni::alias_ref<LayoutAnimations::jhybridobject> jThis);