react-native-reanimated 2.9.1 → 2.11.0

package/android/gradle/wrapper/gradle-wrapper.properties

@@ -1,5 +1,5 @@
 distributionBase=GRADLE_USER_HOME
 distributionPath=wrapper/dists
-distributionUrl=https\://services.gradle.org/distributions/gradle-7.2-bin.zip
+distributionUrl=https\://services.gradle.org/distributions/gradle-7.5.1-all.zip
 zipStoreBase=GRADLE_USER_HOME
 zipStorePath=wrapper/dists

package/android/src/main/cpp/AndroidErrorHandler.cpp

@@ -1,5 +1,6 @@
 #include "AndroidErrorHandler.h"
 #include <fbjni/fbjni.h>
+#include <exception>
 #include <string>
 #include "Logger.h"
 
@@ -17,11 +18,9 @@ void AndroidErrorHandler::raiseSpec() {
     return;
   }
 
-  static const auto cls = javaClassStatic();
-  static auto method = cls->getStaticMethod<void(std::string)>("raise");
-  method(cls, error->message);
-
+  // mark error as handled before this method throws exception
   this->error->handled = true;
+  throw std::runtime_error(this->error->message);
 }
 
 std::shared_ptr<Scheduler> AndroidErrorHandler::getScheduler() {

package/android/src/main/cpp/{headers/AndroidErrorHandler.h → AndroidErrorHandler.h}

@@ -11,15 +11,12 @@
 
 namespace reanimated {
 
-class AndroidErrorHandler : public JavaClass<AndroidErrorHandler>,
-                            public ErrorHandler {
+class AndroidErrorHandler : public ErrorHandler {
   std::shared_ptr<ErrorWrapper> error;
   std::shared_ptr<Scheduler> scheduler;
   void raiseSpec() override;
 
  public:
-  static auto constexpr kJavaDescriptor =
-      "Lcom/swmansion/reanimated/AndroidErrorHandler;";
   explicit AndroidErrorHandler(std::shared_ptr<Scheduler> scheduler);
   std::shared_ptr<Scheduler> getScheduler() override;
   std::shared_ptr<ErrorWrapper> getError() override;

package/android/src/main/cpp/AndroidLogger.cpp

@@ -1,6 +1,9 @@
-#include "AndroidLogger.h"
 #include <android/log.h>
+#include <memory>
+
+#include "AndroidLogger.h"
 #include "Logger.h"
+
 #define APPNAME "NATIVE_REANIMATED"
 
 namespace reanimated {

package/android/src/main/cpp/NativeProxy.cpp

@@ -7,8 +7,10 @@
 #include <memory>
 #include <string>
 
-#if FOR_HERMES
+#if JS_RUNTIME_HERMES
 #include <hermes/hermes.h>
+#elif JS_RUNTIME_V8
+#include <v8runtime/V8RuntimeFactory.h>
 #else
 #include <jsi/JSCRuntime.h>
 #endif
@@ -38,10 +40,8 @@ NativeProxy::NativeProxy(
       layoutAnimations(std::move(_layoutAnimations)) {}
 
 NativeProxy::~NativeProxy() {
-  runtime_->global().setProperty(
-      *runtime_,
-      jsi::PropNameID::forAscii(*runtime_, "__reanimatedModuleProxy"),
-      jsi::Value::undefined());
+  // removed temporary, new event listener mechanism need fix on the RN side
+  // reactScheduler_->removeEventListener(eventListener_);
 }
 
 jni::local_ref<NativeProxy::jhybriddata> NativeProxy::initHybrid(
@@ -73,11 +73,10 @@ void NativeProxy::installJSIBindings() {
   };
 
   auto getCurrentTime = [this]() {
-    auto method =
-        javaPart_->getClass()->getMethod<local_ref<JString>()>("getUptime");
-    local_ref<JString> output = method(javaPart_.get());
-    return static_cast<double>(
-        std::strtoll(output->toStdString().c_str(), NULL, 10));
+    static const auto method =
+        javaPart_->getClass()->getMethod<jlong()>("getCurrentTime");
+    jlong output = method(javaPart_.get());
+    return static_cast<double>(output);
   };
 
   auto requestRender = [this, getCurrentTime](
@@ -136,31 +135,44 @@ void NativeProxy::installJSIBindings() {
   auto setGestureStateFunction = [this](int handlerTag, int newState) -> void {
     setGestureState(handlerTag, newState);
   };
-#if FOR_HERMES
+
+  auto subscribeForKeyboardEventsFunction =
+      [this](std::function<void(int, int)> keyboardEventDataUpdater) -> int {
+    return subscribeForKeyboardEvents(std::move(keyboardEventDataUpdater));
+  };
+
+  auto unsubscribeFromKeyboardEventsFunction = [this](int listenerId) -> void {
+    unsubscribeFromKeyboardEvents(listenerId);
+  };
+
+#if JS_RUNTIME_HERMES
   auto config =
       ::hermes::vm::RuntimeConfig::Builder().withEnableSampleProfiling(false);
   std::shared_ptr<jsi::Runtime> animatedRuntime =
       facebook::hermes::makeHermesRuntime(config.build());
+#elif JS_RUNTIME_V8
+  auto config = std::make_unique<rnv8::V8RuntimeConfig>();
+  config->enableInspector = false;
+  config->appName = "reanimated";
+  std::shared_ptr<jsi::Runtime> animatedRuntime =
+      rnv8::createSharedV8Runtime(runtime_, std::move(config));
 #else
   std::shared_ptr<jsi::Runtime> animatedRuntime =
       facebook::jsc::makeJSCRuntime();
 #endif
-  auto workletRuntimeValue = runtime_->global()
-    .getProperty(*runtime_, "ArrayBuffer")
-    .asObject(*runtime_)
-    .asFunction(*runtime_)
-    .callAsConstructor(*runtime_, {static_cast<double>(sizeof(void*))});
-  uintptr_t* workletRuntimeData = reinterpret_cast<uintptr_t*>(
-    workletRuntimeValue
-      .getObject(*runtime_)
-      .getArrayBuffer(*runtime_)
-      .data(*runtime_));
+  auto workletRuntimeValue =
+      runtime_->global()
+          .getProperty(*runtime_, "ArrayBuffer")
+          .asObject(*runtime_)
+          .asFunction(*runtime_)
+          .callAsConstructor(*runtime_, {static_cast<double>(sizeof(void *))});
+  uintptr_t *workletRuntimeData = reinterpret_cast<uintptr_t *>(
+      workletRuntimeValue.getObject(*runtime_).getArrayBuffer(*runtime_).data(
+          *runtime_));
   workletRuntimeData[0] = reinterpret_cast<uintptr_t>(animatedRuntime.get());
 
   runtime_->global().setProperty(
-      *runtime_,
-      "_WORKLET_RUNTIME",
-      workletRuntimeValue);
+      *runtime_, "_WORKLET_RUNTIME", workletRuntimeValue);
 
   std::shared_ptr<ErrorHandler> errorHandler =
       std::make_shared<AndroidErrorHandler>(scheduler_);
@@ -198,7 +210,10 @@ void NativeProxy::installJSIBindings() {
       registerSensorFunction,
       unregisterSensorFunction,
       setGestureStateFunction,
-      configurePropsFunction};
+      configurePropsFunction,
+      subscribeForKeyboardEventsFunction,
+      unsubscribeFromKeyboardEventsFunction,
+  };
 
   auto module = std::make_shared<NativeReanimatedModule>(
       jsCallInvoker_,
@@ -337,12 +352,29 @@ void NativeProxy::configureProps(
                         ReadableNativeArray::javaobject)>("configureProps");
   method(
       javaPart_.get(),
-      ReadableNativeArray::newObjectCxxArgs(
-          std::move(jsi::dynamicFromValue(rt, uiProps)))
+      ReadableNativeArray::newObjectCxxArgs(jsi::dynamicFromValue(rt, uiProps))
           .get(),
       ReadableNativeArray::newObjectCxxArgs(
-          std::move(jsi::dynamicFromValue(rt, nativeProps)))
+          jsi::dynamicFromValue(rt, nativeProps))
+          .get());
+}
+
+int NativeProxy::subscribeForKeyboardEvents(
+    std::function<void(int, int)> keyboardEventDataUpdater) {
+  auto method = javaPart_->getClass()
+                    ->getMethod<int(KeyboardEventDataUpdater::javaobject)>(
+                        "subscribeForKeyboardEvents");
+  return method(
+      javaPart_.get(),
+      KeyboardEventDataUpdater::newObjectCxxArgs(
+          std::move(keyboardEventDataUpdater))
           .get());
 }
 
+void NativeProxy::unsubscribeFromKeyboardEvents(int listenerId) {
+  auto method = javaPart_->getClass()->getMethod<void(int)>(
+      "unsubscribeFromKeyboardEvents");
+  method(javaPart_.get(), listenerId);
+}
+
 } // namespace reanimated

package/android/src/main/cpp/{headers/NativeProxy.h → NativeProxy.h}

@@ -118,6 +118,32 @@ class SensorSetter : public HybridClass<SensorSetter> {
   std::function<void(double[])> callback_;
 };
 
+class KeyboardEventDataUpdater : public HybridClass<KeyboardEventDataUpdater> {
+ public:
+  static auto constexpr kJavaDescriptor =
+      "Lcom/swmansion/reanimated/NativeProxy$KeyboardEventDataUpdater;";
+
+  void keyboardEventDataUpdater(int keyboardState, int height) {
+    callback_(keyboardState, height);
+  }
+
+  static void registerNatives() {
+    javaClassStatic()->registerNatives({
+        makeNativeMethod(
+            "keyboardEventDataUpdater",
+            KeyboardEventDataUpdater::keyboardEventDataUpdater),
+    });
+  }
+
+ private:
+  friend HybridBase;
+
+  explicit KeyboardEventDataUpdater(std::function<void(int, int)> callback)
+      : callback_(std::move(callback)) {}
+
+  std::function<void(int, int)> callback_;
+};
+
 class NativeProxy : public jni::HybridClass<NativeProxy> {
  public:
   static auto constexpr kJavaDescriptor =
@@ -160,6 +186,9 @@ class NativeProxy : public jni::HybridClass<NativeProxy> {
       jsi::Runtime &rt,
       const jsi::Value &uiProps,
       const jsi::Value &nativeProps);
+  int subscribeForKeyboardEvents(
+      std::function<void(int, int)> keyboardEventDataUpdater);
+  void unsubscribeFromKeyboardEvents(int listenerId);
 
   explicit NativeProxy(
       jni::alias_ref<NativeProxy::jhybridobject> jThis,

package/android/src/main/cpp/OnLoad.cpp

@@ -13,5 +13,6 @@ JNIEXPORT jint JNICALL JNI_OnLoad(JavaVM *vm, void *) {
     reanimated::AndroidScheduler::registerNatives();
     reanimated::LayoutAnimations::registerNatives();
     reanimated::SensorSetter::registerNatives();
+    reanimated::KeyboardEventDataUpdater::registerNatives();
   });
 }

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

@@ -16,6 +16,7 @@ import com.facebook.react.turbomodule.core.CallInvokerHolderImpl;
 import com.facebook.react.uimanager.UIManagerModule;
 import com.facebook.react.uimanager.events.RCTEventEmitter;
 import com.swmansion.common.GestureHandlerStateManager;
+import com.swmansion.reanimated.keyboardObserver.ReanimatedKeyboardEventListener;
 import com.swmansion.reanimated.layoutReanimation.AnimationsManager;
 import com.swmansion.reanimated.layoutReanimation.LayoutAnimations;
 import com.swmansion.reanimated.layoutReanimation.NativeMethodsHolder;
@@ -87,6 +88,18 @@ public class NativeProxy {
     public native void sensorSetter(float[] value);
   }
 
+  @DoNotStrip
+  public static class KeyboardEventDataUpdater {
+    @DoNotStrip private final HybridData mHybridData;
+
+    @DoNotStrip
+    private KeyboardEventDataUpdater(HybridData hybridData) {
+      mHybridData = hybridData;
+    }
+
+    public native void keyboardEventDataUpdater(int keyboardState, int height);
+  }
+
   @DoNotStrip
   @SuppressWarnings("unused")
   private final HybridData mHybridData;
@@ -96,6 +109,7 @@ public class NativeProxy {
   private Scheduler mScheduler = null;
   private ReanimatedSensorContainer reanimatedSensorContainer;
   private final GestureHandlerStateManager gestureHandlerStateManager;
+  private ReanimatedKeyboardEventListener reanimatedKeyboardEventListener;
   private Long firstUptime = SystemClock.uptimeMillis();
   private boolean slowAnimationsEnabled = false;
 
@@ -110,6 +124,7 @@ public class NativeProxy {
     mContext = new WeakReference<>(context);
     prepare(LayoutAnimations);
     reanimatedSensorContainer = new ReanimatedSensorContainer(mContext);
+    reanimatedKeyboardEventListener = new ReanimatedKeyboardEventListener(mContext);
     addDevMenuOption();
 
     GestureHandlerStateManager tempHandlerStateManager;
@@ -188,14 +203,13 @@ public class NativeProxy {
   }
 
   @DoNotStrip
-  private String getUptime() {
+  private long getCurrentTime() {
     if (slowAnimationsEnabled) {
       final long ANIMATIONS_DRAG_FACTOR = 10;
-      return Long.toString(
-          this.firstUptime
-              + (SystemClock.uptimeMillis() - this.firstUptime) / ANIMATIONS_DRAG_FACTOR);
+      return this.firstUptime
+          + (SystemClock.uptimeMillis() - this.firstUptime) / ANIMATIONS_DRAG_FACTOR;
     } else {
-      return Long.toString(SystemClock.uptimeMillis());
+      return SystemClock.uptimeMillis();
     }
   }
 
@@ -237,6 +251,16 @@ public class NativeProxy {
     reanimatedSensorContainer.unregisterSensor(sensorId);
   }
 
+  @DoNotStrip
+  private int subscribeForKeyboardEvents(KeyboardEventDataUpdater keyboardEventDataUpdater) {
+    return reanimatedKeyboardEventListener.subscribeForKeyboardEvents(keyboardEventDataUpdater);
+  }
+
+  @DoNotStrip
+  private void unsubscribeFromKeyboardEvents(int listenerId) {
+    reanimatedKeyboardEventListener.unsubscribeFromKeyboardEvents(listenerId);
+  }
+
   public void onCatalystInstanceDestroy() {
     mScheduler.deactivate();
     mHybridData.resetNative();

package/android/src/main/java/com/swmansion/reanimated/NodesManager.java

@@ -1,5 +1,7 @@
 package com.swmansion.reanimated;
 
+import static java.lang.Float.NaN;
+
 import android.util.SparseArray;
 import android.view.View;
 import com.facebook.react.bridge.Arguments;
@@ -83,7 +85,7 @@ public class NodesManager implements EventDispatcherListener {
       view = mUIManager.resolveView(viewTag);
     } catch (IllegalViewOperationException e) {
       e.printStackTrace();
-      return (new float[] {});
+      return (new float[] {NaN, NaN, NaN, NaN, NaN, NaN});
     }
     return NativeMethodsHelper.measure(view);
   }

package/android/src/main/java/com/swmansion/reanimated/keyboardObserver/ReanimatedKeyboardEventListener.java

@@ -0,0 +1,166 @@
+package com.swmansion.reanimated.keyboardObserver;
+
+import android.os.Handler;
+import android.os.Looper;
+import android.view.View;
+import android.widget.FrameLayout;
+import androidx.annotation.NonNull;
+import androidx.core.view.ViewCompat;
+import androidx.core.view.WindowCompat;
+import androidx.core.view.WindowInsetsAnimationCompat;
+import androidx.core.view.WindowInsetsCompat;
+import com.facebook.react.bridge.ReactApplicationContext;
+import com.facebook.react.uimanager.PixelUtil;
+import com.swmansion.reanimated.BuildConfig;
+import com.swmansion.reanimated.NativeProxy.KeyboardEventDataUpdater;
+import java.lang.ref.WeakReference;
+import java.util.HashMap;
+import java.util.List;
+
+public class ReanimatedKeyboardEventListener {
+  enum KeyboardState {
+    UNKNOWN(0),
+    OPENING(1),
+    OPEN(2),
+    CLOSING(3),
+    CLOSED(4);
+
+    private final int value;
+
+    KeyboardState(int value) {
+      this.value = value;
+    }
+
+    public int asInt() {
+      return value;
+    }
+  }
+
+  private final WeakReference<ReactApplicationContext> reactContext;
+  private int nextListenerId = 0;
+  private KeyboardState state;
+  private final HashMap<Integer, KeyboardEventDataUpdater> listeners = new HashMap<>();
+
+  public ReanimatedKeyboardEventListener(WeakReference<ReactApplicationContext> reactContext) {
+    this.reactContext = reactContext;
+  }
+
+  private View getRootView() {
+    return reactContext.get().getCurrentActivity().getWindow().getDecorView();
+  }
+
+  private void setupWindowInsets() {
+    View rootView = getRootView();
+    WindowCompat.setDecorFitsSystemWindows(
+        reactContext.get().getCurrentActivity().getWindow(), false);
+    ViewCompat.setOnApplyWindowInsetsListener(
+        rootView,
+        (v, insets) -> {
+          int paddingBottom = 0;
+          if (!BuildConfig.IS_NEW_ARCHITECTURE_ENABLED
+              && BuildConfig.REACT_NATIVE_MINOR_VERSION < 70) {
+            paddingBottom = insets.getInsets(WindowInsetsCompat.Type.navigationBars()).bottom;
+          }
+          int paddingTop = insets.getInsets(WindowInsetsCompat.Type.systemBars()).top;
+          View content =
+              rootView.getRootView().findViewById(com.swmansion.reanimated.R.id.action_bar_root);
+
+          FrameLayout.LayoutParams params =
+              new FrameLayout.LayoutParams(
+                  FrameLayout.LayoutParams.MATCH_PARENT, FrameLayout.LayoutParams.MATCH_PARENT);
+          params.setMargins(0, paddingTop, 0, paddingBottom);
+          content.setLayoutParams(params);
+          return insets;
+        });
+  }
+
+  private void updateKeyboard(int keyboardHeight) {
+    for (KeyboardEventDataUpdater listener : listeners.values()) {
+      listener.keyboardEventDataUpdater(state.asInt(), keyboardHeight);
+    }
+  }
+
+  private class WindowInsetsCallback extends WindowInsetsAnimationCompat.Callback {
+    private int keyboardHeight = 0;
+
+    public WindowInsetsCallback() {
+      super(WindowInsetsAnimationCompat.Callback.DISPATCH_MODE_CONTINUE_ON_SUBTREE);
+    }
+
+    @NonNull
+    @Override
+    public WindowInsetsAnimationCompat.BoundsCompat onStart(
+        @NonNull WindowInsetsAnimationCompat animation,
+        @NonNull WindowInsetsAnimationCompat.BoundsCompat bounds) {
+      state = keyboardHeight == 0 ? KeyboardState.OPENING : KeyboardState.CLOSING;
+      updateKeyboard(keyboardHeight);
+      return super.onStart(animation, bounds);
+    }
+
+    @NonNull
+    @Override
+    public WindowInsetsCompat onProgress(
+        @NonNull WindowInsetsCompat insets,
+        @NonNull List<WindowInsetsAnimationCompat> runningAnimations) {
+
+      keyboardHeight =
+          (int)
+              PixelUtil.toDIPFromPixel(
+                  Math.max(
+                      0,
+                      insets.getInsets(WindowInsetsCompat.Type.ime()).bottom
+                          - insets.getInsets(WindowInsetsCompat.Type.systemBars()).bottom));
+      updateKeyboard(keyboardHeight);
+      return insets;
+    }
+
+    @Override
+    public void onEnd(@NonNull WindowInsetsAnimationCompat animation) {
+      state = keyboardHeight == 0 ? KeyboardState.CLOSED : KeyboardState.OPEN;
+      updateKeyboard(keyboardHeight);
+    }
+  }
+
+  private void setUpCallbacks() {
+    View rootView = getRootView();
+    new Handler(Looper.getMainLooper()).post(this::setupWindowInsets);
+    ViewCompat.setWindowInsetsAnimationCallback(rootView, new WindowInsetsCallback());
+  }
+
+  public int subscribeForKeyboardEvents(KeyboardEventDataUpdater updater) {
+    int listenerId = nextListenerId++;
+    if (listeners.isEmpty()) {
+      setUpCallbacks();
+    }
+    listeners.put(listenerId, updater);
+    return listenerId;
+  }
+
+  private void bringBackWindowInsets() {
+    WindowCompat.setDecorFitsSystemWindows(
+        reactContext.get().getCurrentActivity().getWindow(), true);
+    ViewCompat.setOnApplyWindowInsetsListener(getRootView(), null);
+    ViewCompat.setWindowInsetsAnimationCallback(getRootView(), null);
+    View content =
+        getRootView().getRootView().findViewById(com.swmansion.reanimated.R.id.action_bar_root);
+
+    FrameLayout.LayoutParams params =
+        new FrameLayout.LayoutParams(
+            FrameLayout.LayoutParams.MATCH_PARENT, FrameLayout.LayoutParams.MATCH_PARENT);
+    params.setMargins(0, 0, 0, 0);
+    content.setLayoutParams(params);
+  }
+
+  private void removeCallbacks() {
+    View rootView = getRootView();
+    new Handler(Looper.getMainLooper()).post(this::bringBackWindowInsets);
+    ViewCompat.setWindowInsetsAnimationCallback(rootView, null);
+  }
+
+  public void unsubscribeFromKeyboardEvents(int listenerId) {
+    listeners.remove(listenerId);
+    if (listeners.isEmpty()) {
+      removeCallbacks();
+    }
+  }
+}

package/android/src/main/java/com/swmansion/reanimated/layoutReanimation/AnimationsManager.java

@@ -229,24 +229,27 @@ public class AnimationsManager implements ViewHierarchyObserver {
   }
 
   private void removeLeftovers() {
-    HashSet<Integer> roots = new HashSet<>();
-    // go through ready to remove from bottom to top
-    for (int tag : mToRemove) {
-      View view = mViewForTag.get(tag);
-      if (view == null) {
-        try {
-          view = mUIManager.resolveView(tag);
-          mViewForTag.put(tag, view);
-        } catch (IllegalViewOperationException ignored) {
-          continue;
+    // mToRemove may be null if onCatalystInstanceDestroy was called first
+    if (mToRemove != null) {
+      HashSet<Integer> roots = new HashSet<>();
+      // go through ready to remove from bottom to top
+      for (int tag : mToRemove) {
+        View view = mViewForTag.get(tag);
+        if (view == null) {
+          try {
+            view = mUIManager.resolveView(tag);
+            mViewForTag.put(tag, view);
+          } catch (IllegalViewOperationException ignored) {
+            continue;
+          }
         }
+        findRoot(view, roots);
       }
-      findRoot(view, roots);
-    }
-    for (int tag : roots) {
-      View view = mViewForTag.get(tag);
-      if (view != null) {
-        dfs(view, view, mToRemove);
+      for (int tag : roots) {
+        View view = mViewForTag.get(tag);
+        if (view != null) {
+          dfs(view, view, mToRemove);
+        }
       }
     }
   }

package/android/src/main/java/com/swmansion/reanimated/sensor/ReanimatedSensor.java

@@ -23,7 +23,11 @@ public class ReanimatedSensor {
     sensorManager =
         (SensorManager) reactContext.get().getSystemService(reactContext.get().SENSOR_SERVICE);
     this.sensorType = sensorType;
-    this.interval = interval;
+    if (interval == -1) {
+      this.interval = SensorManager.SENSOR_DELAY_UI;
+    } else {
+      this.interval = interval;
+    }
   }
 
   boolean initialize() {

package/android/src/main/java/com/swmansion/reanimated/sensor/ReanimatedSensorType.java

@@ -3,7 +3,7 @@ package com.swmansion.reanimated.sensor;
 import android.hardware.Sensor;
 
 public enum ReanimatedSensorType {
-  ACCELEROMETER(Sensor.TYPE_ACCELEROMETER),
+  ACCELEROMETER(Sensor.TYPE_LINEAR_ACCELERATION),
   GYROSCOPE(Sensor.TYPE_GYROSCOPE),
   GRAVITY(Sensor.TYPE_GRAVITY),
   MAGNETIC_FIELD(Sensor.TYPE_MAGNETIC_FIELD),

package/ios/{REAModule.m → REAModule.mm}

@@ -3,15 +3,27 @@
 #import <RNReanimated/REANodesManager.h>
 #import <RNReanimated/REATransitionManager.h>
 
+#import "SingleInstanceChecker.h"
+
+using namespace reanimated;
+
 typedef void (^AnimatedOperation)(REANodesManager *nodesManager);
 
 @implementation REAModule {
   NSMutableArray<AnimatedOperation> *_operations;
   REATransitionManager *_transitionManager;
+#ifdef DEBUG
+  SingleInstanceChecker<REAModule> singleInstanceChecker_;
+#endif
 }
 
 RCT_EXPORT_MODULE(ReanimatedModule);
 
++ (BOOL)requiresMainQueueSetup
+{
+  return YES;
+}
+
 - (void)invalidate
 {
   _transitionManager = nil;