react-native-worklets 0.0.1-alpha → 0.1.0

package/android/gradle.properties

@@ -0,0 +1,5 @@
+Worklets_kotlinVersion=1.7.0
+Worklets_minSdkVersion=21
+Worklets_targetSdkVersion=31
+Worklets_compileSdkVersion=31
+Worklets_ndkversion=21.4.7075529

package/android/proguard-rules.pro

@@ -0,0 +1,3 @@
+-keep class com.swmansion.worklets.** { *; }
+-keep class com.facebook.react.turbomodule.** { *; }
+-keep class com.facebook.react.fabric.** { *; }

package/android/spotless.gradle

@@ -0,0 +1,9 @@
+// formatter & linter configuration for java
+apply plugin: 'com.diffplug.spotless'
+
+spotless {
+  java {
+    target 'src/**/*.java'
+    googleJavaFormat()
+  }
+}

package/android/src/main/AndroidManifest.xml

@@ -0,0 +1,2 @@
+<manifest xmlns:android="http://schemas.android.com/apk/res/android">
+</manifest>

package/android/src/main/cpp/worklets/CMakeLists.txt

@@ -0,0 +1,85 @@
+cmake_minimum_required(VERSION 3.8)
+
+file(GLOB_RECURSE WORKLETS_COMMON_CPP_SOURCES CONFIGURE_DEPENDS
+     "${COMMON_CPP_DIR}/worklets/*.cpp")
+file(GLOB_RECURSE WORKLETS_ANDROID_CPP_SOURCES CONFIGURE_DEPENDS
+     "${ANDROID_CPP_DIR}/worklets/*.cpp")
+
+# Consume shared libraries and headers from prefabs
+find_package(fbjni REQUIRED CONFIG)
+find_package(ReactAndroid REQUIRED CONFIG)
+
+if(${JS_RUNTIME} STREQUAL "hermes")
+  find_package(hermes-engine REQUIRED CONFIG)
+endif()
+
+add_library(worklets SHARED ${WORKLETS_COMMON_CPP_SOURCES}
+                            ${WORKLETS_ANDROID_CPP_SOURCES})
+
+# includes
+target_include_directories(worklets PUBLIC "${COMMON_CPP_DIR}"
+                                           "${ANDROID_CPP_DIR}")
+
+target_include_directories(
+  worklets
+  PRIVATE "${REACT_NATIVE_DIR}/ReactCommon"
+          "${REACT_NATIVE_DIR}/ReactAndroid/src/main/jni/react/turbomodule"
+          "${REACT_NATIVE_DIR}/ReactCommon/react/nativemodule/core/ReactCommon"
+          "${REACT_NATIVE_DIR}/ReactCommon/callinvoker"
+          "${REACT_NATIVE_DIR}/ReactCommon/runtimeexecutor")
+
+if(${IS_NEW_ARCHITECTURE_ENABLED})
+  target_include_directories(
+    worklets
+    PRIVATE
+      "${REACT_NATIVE_DIR}/ReactCommon/yoga"
+      "${REACT_NATIVE_DIR}/ReactCommon/react/renderer/graphics/platform/cxx")
+
+  if(ReactAndroid_VERSION_MINOR LESS 76)
+    target_link_libraries(
+      worklets ReactAndroid::fabricjni ReactAndroid::react_debug
+      ReactAndroid::react_render_core
+      ReactAndroid::react_render_componentregistry ReactAndroid::rrc_view)
+  endif()
+endif()
+
+# build shared lib
+set_target_properties(worklets PROPERTIES LINKER_LANGUAGE CXX)
+
+target_link_libraries(worklets log ReactAndroid::jsi fbjni::fbjni)
+
+if(ReactAndroid_VERSION_MINOR GREATER_EQUAL 76)
+  target_link_libraries(worklets ReactAndroid::reactnative)
+else()
+  target_link_libraries(
+    worklets ReactAndroid::react_nativemodule_core ReactAndroid::folly_runtime
+    ReactAndroid::glog ReactAndroid::reactnativejni)
+endif()
+
+if(${JS_RUNTIME} STREQUAL "hermes")
+  target_link_libraries(worklets hermes-engine::libhermes)
+
+  if(${HERMES_ENABLE_DEBUGGER})
+    if(ReactAndroid_VERSION_MINOR GREATER_EQUAL 76)
+      target_link_libraries(worklets ReactAndroid::hermestooling)
+    else()
+      target_link_libraries(worklets ReactAndroid::hermes_executor)
+    endif()
+  endif()
+elseif(${JS_RUNTIME} STREQUAL "jsc")
+  if(ReactAndroid_VERSION_MINOR GREATER_EQUAL 76)
+    target_link_libraries(worklets ReactAndroid::jsctooling)
+  else()
+    target_link_libraries(worklets ReactAndroid::jscexecutor)
+  endif()
+elseif(${JS_RUNTIME} STREQUAL "v8")
+  # TODO: Refactor this when adding support for newest V8
+  target_include_directories(worklets PRIVATE "${JS_RUNTIME_DIR}/src")
+  file(GLOB V8_SO_DIR "${JS_RUNTIME_DIR}/android/build/intermediates/\
+    library_jni/**/jni/${ANDROID_ABI}")
+  find_library(
+    V8EXECUTOR_LIB v8executor
+    PATHS ${V8_SO_DIR}
+    NO_DEFAULT_PATH NO_CMAKE_FIND_ROOT_PATH)
+  target_link_libraries(worklets ${V8EXECUTOR_LIB})
+endif()

package/android/src/main/cpp/worklets/android/AndroidUIScheduler.cpp

@@ -0,0 +1,63 @@
+#include <worklets/android/AndroidUIScheduler.h>
+
+namespace worklets {
+
+using namespace facebook;
+using namespace react;
+
+class UISchedulerWrapper : public UIScheduler {
+ private:
+  jni::global_ref<AndroidUIScheduler::javaobject> androidUiScheduler_;
+
+ public:
+  explicit UISchedulerWrapper(
+      jni::global_ref<AndroidUIScheduler::javaobject> androidUiScheduler)
+      : androidUiScheduler_(androidUiScheduler) {}
+
+  void scheduleOnUI(std::function<void()> job) override {
+    UIScheduler::scheduleOnUI(job);
+    if (!scheduledOnUI_) {
+      scheduledOnUI_ = true;
+      androidUiScheduler_->cthis()->scheduleTriggerOnUI();
+    }
+  }
+};
+
+AndroidUIScheduler::AndroidUIScheduler(
+    jni::alias_ref<AndroidUIScheduler::javaobject> jThis)
+    : javaPart_(jni::make_global(jThis)),
+      uiScheduler_(
+          std::make_shared<UISchedulerWrapper>(jni::make_global(jThis))) {}
+
+jni::local_ref<AndroidUIScheduler::jhybriddata> AndroidUIScheduler::initHybrid(
+    jni::alias_ref<jhybridobject> jThis) {
+  return makeCxxInstance(jThis);
+}
+
+void AndroidUIScheduler::triggerUI() {
+  if (!uiScheduler_) {
+    return;
+  }
+  uiScheduler_->triggerUI();
+}
+
+void AndroidUIScheduler::scheduleTriggerOnUI() {
+  static const auto method =
+      javaPart_->getClass()->getMethod<void()>("scheduleTriggerOnUI");
+  method(javaPart_.get());
+}
+
+void AndroidUIScheduler::invalidate() {
+  javaPart_ = nullptr;
+  uiScheduler_.reset();
+}
+
+void AndroidUIScheduler::registerNatives() {
+  registerHybrid({
+      makeNativeMethod("initHybrid", AndroidUIScheduler::initHybrid),
+      makeNativeMethod("triggerUI", AndroidUIScheduler::triggerUI),
+      makeNativeMethod("invalidate", AndroidUIScheduler::invalidate),
+  });
+}
+
+} // namespace worklets

package/android/src/main/cpp/worklets/android/AndroidUIScheduler.h

@@ -0,0 +1,41 @@
+#pragma once
+
+#include <worklets/Tools/UIScheduler.h>
+
+#include <fbjni/fbjni.h>
+#include <jsi/jsi.h>
+
+namespace worklets {
+
+using namespace facebook;
+using namespace worklets;
+
+class AndroidUIScheduler : public jni::HybridClass<AndroidUIScheduler> {
+ public:
+  static auto constexpr kJavaDescriptor =
+      "Lcom/swmansion/worklets/AndroidUIScheduler;";
+  static jni::local_ref<jhybriddata> initHybrid(
+      jni::alias_ref<jhybridobject> jThis);
+  static void registerNatives();
+
+  std::shared_ptr<UIScheduler> getUIScheduler() {
+    return uiScheduler_;
+  }
+
+  void scheduleTriggerOnUI();
+
+ private:
+  friend HybridBase;
+
+  void triggerUI();
+
+  void invalidate();
+
+  jni::global_ref<AndroidUIScheduler::javaobject> javaPart_;
+  std::shared_ptr<UIScheduler> uiScheduler_;
+
+  explicit AndroidUIScheduler(
+      jni::alias_ref<AndroidUIScheduler::jhybridobject> jThis);
+};
+
+} // namespace worklets

package/android/src/main/cpp/worklets/android/AnimationFrameCallback.h

@@ -0,0 +1,32 @@
+#pragma once
+
+#include <fbjni/fbjni.h>
+
+namespace worklets {
+
+class AnimationFrameCallback
+    : public facebook::jni::HybridClass<AnimationFrameCallback> {
+ public:
+  static auto constexpr kJavaDescriptor =
+      "Lcom/swmansion/worklets/AnimationFrameCallback;";
+
+  void onAnimationFrame(double timestampMs) {
+    callback_(timestampMs);
+  }
+
+  static void registerNatives() {
+    javaClassStatic()->registerNatives({
+        makeNativeMethod(
+            "onAnimationFrame", AnimationFrameCallback::onAnimationFrame),
+    });
+  }
+
+ private:
+  friend HybridBase;
+
+  explicit AnimationFrameCallback(std::function<void(const double)> callback)
+      : callback_(std::move(callback)) {}
+
+  std::function<void(double)> callback_;
+};
+} // namespace worklets

package/android/src/main/cpp/worklets/android/PlatformLogger.cpp

@@ -0,0 +1,29 @@
+#include <android/log.h>
+
+#include <worklets/Tools/PlatformLogger.h>
+
+constexpr const auto tag = "Worklets";
+
+namespace worklets {
+
+void PlatformLogger::log(const char *str) {
+  __android_log_print(ANDROID_LOG_VERBOSE, tag, "%s", str);
+}
+
+void PlatformLogger::log(const std::string &str) {
+  log(str.c_str());
+}
+
+void PlatformLogger::log(const double d) {
+  __android_log_print(ANDROID_LOG_VERBOSE, tag, "%f", d);
+}
+
+void PlatformLogger::log(const int i) {
+  __android_log_print(ANDROID_LOG_VERBOSE, tag, "%d", i);
+}
+
+void PlatformLogger::log(const bool b) {
+  log(b ? "true" : "false");
+}
+
+} // namespace worklets

package/android/src/main/cpp/worklets/android/WorkletsModule.cpp

@@ -0,0 +1,83 @@
+#include <react/jni/JMessageQueueThread.h>
+
+#include <worklets/WorkletRuntime/RNRuntimeWorkletDecorator.h>
+#include <worklets/android/AnimationFrameCallback.h>
+#include <worklets/android/WorkletsModule.h>
+
+namespace worklets {
+
+using namespace facebook;
+using namespace react;
+
+WorkletsModule::WorkletsModule(
+    jni::alias_ref<jhybridobject> jThis,
+    jsi::Runtime *rnRuntime,
+    const std::string &valueUnpackerCode,
+    jni::alias_ref<JavaMessageQueueThread::javaobject> messageQueueThread,
+    const std::shared_ptr<facebook::react::CallInvoker> &jsCallInvoker,
+    const std::shared_ptr<worklets::JSScheduler> &jsScheduler,
+    const std::shared_ptr<UIScheduler> &uiScheduler)
+    : javaPart_(jni::make_global(jThis)),
+      rnRuntime_(rnRuntime),
+      workletsModuleProxy_(std::make_shared<WorkletsModuleProxy>(
+          *rnRuntime,
+          valueUnpackerCode,
+          std::make_shared<JMessageQueueThread>(messageQueueThread),
+          jsCallInvoker,
+          jsScheduler,
+          uiScheduler,
+          getForwardedRequestAnimationFrame())) {
+  RNRuntimeWorkletDecorator::decorate(*rnRuntime_, workletsModuleProxy_);
+}
+
+jni::local_ref<WorkletsModule::jhybriddata> WorkletsModule::initHybrid(
+    jni::alias_ref<jhybridobject> jThis,
+    jlong jsContext,
+    const std::string &valueUnpackerCode,
+    jni::alias_ref<JavaMessageQueueThread::javaobject> messageQueueThread,
+    jni::alias_ref<facebook::react::CallInvokerHolder::javaobject>
+        jsCallInvokerHolder,
+    jni::alias_ref<worklets::AndroidUIScheduler::javaobject>
+        androidUIScheduler) {
+  auto jsCallInvoker = jsCallInvokerHolder->cthis()->getCallInvoker();
+  auto rnRuntime = reinterpret_cast<jsi::Runtime *>(jsContext);
+  auto jsScheduler =
+      std::make_shared<worklets::JSScheduler>(*rnRuntime, jsCallInvoker);
+  auto uiScheduler = androidUIScheduler->cthis()->getUIScheduler();
+  return makeCxxInstance(
+      jThis,
+      rnRuntime,
+      valueUnpackerCode,
+      messageQueueThread,
+      jsCallInvoker,
+      jsScheduler,
+      uiScheduler);
+}
+
+std::function<void(std::function<void(const double)>)>
+WorkletsModule::getForwardedRequestAnimationFrame() {
+  return [javaPart =
+              javaPart_](std::function<void(const double)> &&callback) -> void {
+    static const auto jRequestAnimationFrame =
+        javaPart->getClass()
+            ->getMethod<void(AnimationFrameCallback::javaobject)>(
+                "requestAnimationFrame");
+    jRequestAnimationFrame(
+        javaPart.get(),
+        AnimationFrameCallback::newObjectCxxArgs(std::move(callback)).get());
+  };
+}
+
+void WorkletsModule::invalidateCpp() {
+  javaPart_.reset();
+  workletsModuleProxy_.reset();
+}
+
+void WorkletsModule::registerNatives() {
+  registerHybrid({
+      makeNativeMethod("initHybrid", WorkletsModule::initHybrid),
+      makeNativeMethod("invalidateCpp", WorkletsModule::invalidateCpp),
+  });
+}
+
+} // namespace worklets

package/android/src/main/cpp/worklets/android/WorkletsModule.h

@@ -0,0 +1,63 @@
+#pragma once
+
+#include <ReactCommon/CallInvokerHolder.h>
+#include <fbjni/fbjni.h>
+#include <jsi/jsi.h>
+#include <react/jni/JMessageQueueThread.h>
+
+#include <worklets/NativeModules/WorkletsModuleProxy.h>
+#include <worklets/android/AndroidUIScheduler.h>
+
+namespace worklets {
+
+using namespace facebook;
+using namespace facebook::jni;
+
+class WorkletsModule : public jni::HybridClass<WorkletsModule> {
+ public:
+  static auto constexpr kJavaDescriptor =
+      "Lcom/swmansion/worklets/WorkletsModule;";
+
+  static jni::local_ref<jhybriddata> initHybrid(
+      jni::alias_ref<jhybridobject> jThis,
+      jlong jsContext,
+      const std::string &valueUnpackerCode,
+      jni::alias_ref<JavaMessageQueueThread::javaobject> messageQueueThread,
+      jni::alias_ref<facebook::react::CallInvokerHolder::javaobject>
+          jsCallInvokerHolder,
+      jni::alias_ref<worklets::AndroidUIScheduler::javaobject>
+          androidUIScheduler);
+
+  static void registerNatives();
+
+  inline std::shared_ptr<WorkletsModuleProxy> getWorkletsModuleProxy() {
+    return workletsModuleProxy_;
+  }
+
+ private:
+  explicit WorkletsModule(
+      jni::alias_ref<jhybridobject> jThis,
+      jsi::Runtime *rnRuntime,
+      const std::string &valueUnpackerCode,
+      jni::alias_ref<JavaMessageQueueThread::javaobject> messageQueueThread,
+      const std::shared_ptr<facebook::react::CallInvoker> &jsCallInvoker,
+      const std::shared_ptr<worklets::JSScheduler> &jsScheduler,
+      const std::shared_ptr<UIScheduler> &uiScheduler);
+
+  void invalidateCpp();
+
+  template <class Signature>
+  JMethod<Signature> getJniMethod(std::string const &methodName) {
+    return javaPart_->getClass()->getMethod<Signature>(methodName.c_str());
+  }
+
+  std::function<void(std::function<void(const double)>)>
+  getForwardedRequestAnimationFrame();
+
+  friend HybridBase;
+  jni::global_ref<WorkletsModule::javaobject> javaPart_;
+  jsi::Runtime *rnRuntime_;
+  std::shared_ptr<WorkletsModuleProxy> workletsModuleProxy_;
+};
+
+} // namespace worklets

package/android/src/main/cpp/worklets/android/WorkletsOnLoad.cpp

@@ -0,0 +1,13 @@
+#include <fbjni/fbjni.h>
+
+#include <worklets/android/AndroidUIScheduler.h>
+#include <worklets/android/AnimationFrameCallback.h>
+#include <worklets/android/WorkletsModule.h>
+
+JNIEXPORT jint JNICALL JNI_OnLoad(JavaVM *vm, void *) {
+  return facebook::jni::initialize(vm, [] {
+    worklets::WorkletsModule::registerNatives();
+    worklets::AndroidUIScheduler::registerNatives();
+    worklets::AnimationFrameCallback::registerNatives();
+  });
+}

package/android/src/main/java/com/swmansion/worklets/AndroidUIScheduler.java

@@ -0,0 +1,60 @@
+package com.swmansion.worklets;
+
+import com.facebook.jni.HybridData;
+import com.facebook.proguard.annotations.DoNotStrip;
+import com.facebook.react.bridge.GuardedRunnable;
+import com.facebook.react.bridge.ReactApplicationContext;
+import com.facebook.react.bridge.UiThreadUtil;
+import java.util.concurrent.atomic.AtomicBoolean;
+
+public class AndroidUIScheduler {
+
+  @DoNotStrip
+  @SuppressWarnings("unused")
+  private final HybridData mHybridData;
+
+  private final ReactApplicationContext mContext;
+  private final AtomicBoolean mActive = new AtomicBoolean(true);
+
+  private final Runnable mUIThreadRunnable =
+      () -> {
+        /**
+         * This callback is called on the UI thread, but the module is invalidated on the JS thread.
+         * Therefore we must synchronize for reloads. Without synchronization the cpp part gets torn
+         * down while the UI thread is still executing it, leading to crashes.
+         */
+        synchronized (mActive) {
+          if (mActive.get()) {
+            triggerUI();
+          }
+        }
+      };
+
+  public AndroidUIScheduler(ReactApplicationContext context) {
+    mHybridData = initHybrid();
+    mContext = context;
+  }
+
+  private native HybridData initHybrid();
+
+  public native void triggerUI();
+
+  public native void invalidate();
+
+  @DoNotStrip
+  private void scheduleTriggerOnUI() {
+    UiThreadUtil.runOnUiThread(
+        new GuardedRunnable(mContext.getExceptionHandler()) {
+          public void runGuarded() {
+            mUIThreadRunnable.run();
+          }
+        });
+  }
+
+  public void deactivate() {
+    synchronized (mActive) {
+      mActive.set(false);
+      invalidate();
+    }
+  }
+}

package/android/src/main/java/com/swmansion/worklets/AnimationFrameQueue/AnimationFrameCallback.java

@@ -0,0 +1,20 @@
+package com.swmansion.worklets;
+
+import com.facebook.jni.HybridData;
+import com.facebook.proguard.annotations.DoNotStrip;
+
+/**
+ * @noinspection JavaJniMissingFunction
+ */
+@DoNotStrip
+public class AnimationFrameCallback {
+
+  @DoNotStrip private final HybridData mHybridData;
+
+  @DoNotStrip
+  private AnimationFrameCallback(HybridData hybridData) {
+    mHybridData = hybridData;
+  }
+
+  public native void onAnimationFrame(double timestampMs);
+}

package/android/src/main/java/com/swmansion/worklets/AnimationFrameQueue/AnimationFrameQueue.java

@@ -0,0 +1,113 @@
+package com.swmansion.worklets;
+
+import android.os.SystemClock;
+import com.facebook.react.bridge.ReactApplicationContext;
+import com.facebook.react.modules.core.ReactChoreographer;
+import com.facebook.react.uimanager.GuardedFrameCallback;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.concurrent.atomic.AtomicBoolean;
+
+public class AnimationFrameQueue {
+
+  private Long mFirstUptime = SystemClock.uptimeMillis();
+  private boolean mSlowAnimationsEnabled = false;
+  private double lastFrameTimeMs;
+  private int mAnimationsDragFactor = 1;
+
+  /// ReactChoreographer is
+  /// <a
+  // href="https://github.com/facebook/react-native/blob/main/packages/react-native/ReactAndroid/src/main/java/com/facebook/react/modules/core/ReactChoreographer.kt#L21">thread safe</a>.
+  ///
+  private final ReactChoreographer mReactChoreographer = ReactChoreographer.getInstance();
+  private final GuardedFrameCallback mChoreographerCallback;
+  private final AtomicBoolean mCallbackPosted = new AtomicBoolean();
+  private final AtomicBoolean mPaused = new AtomicBoolean();
+  private final List<AnimationFrameCallback> mFrameCallbacks = new ArrayList<>();
+
+  public AnimationFrameQueue(ReactApplicationContext reactApplicationContext) {
+    mChoreographerCallback =
+        new GuardedFrameCallback(reactApplicationContext) {
+          @Override
+          protected void doFrameGuarded(long frameTimeNanos) {
+            executeQueue(frameTimeNanos);
+          }
+        };
+  }
+
+  public void resume() {
+    if (mPaused.getAndSet(false)) {
+      scheduleQueueExecution();
+    }
+  }
+
+  public void pause() {
+    synchronized (mPaused) {
+      if (!mPaused.getAndSet(true) && mCallbackPosted.getAndSet(false)) {
+        mReactChoreographer.removeFrameCallback(
+            ReactChoreographer.CallbackType.NATIVE_ANIMATED_MODULE, mChoreographerCallback);
+      }
+    }
+  }
+
+  public void requestAnimationFrame(AnimationFrameCallback animationFrameCallback) {
+    synchronized (mFrameCallbacks) {
+      mFrameCallbacks.add(animationFrameCallback);
+    }
+    scheduleQueueExecution();
+  }
+
+  public void enableSlowAnimations(boolean slowAnimationsEnabled, int animationsDragFactor) {
+    mSlowAnimationsEnabled = slowAnimationsEnabled;
+    mAnimationsDragFactor = animationsDragFactor;
+    if (slowAnimationsEnabled) {
+      mFirstUptime = SystemClock.uptimeMillis();
+    }
+  }
+
+  private void scheduleQueueExecution() {
+    synchronized (mPaused) {
+      if (!mPaused.get() && !mCallbackPosted.getAndSet(true)) {
+        mReactChoreographer.postFrameCallback(
+            ReactChoreographer.CallbackType.NATIVE_ANIMATED_MODULE, mChoreographerCallback);
+      }
+    }
+  }
+
+  private void executeQueue(long frameTimeNanos) {
+    double currentFrameTimeMs = calculateTimestamp(frameTimeNanos);
+    if (currentFrameTimeMs <= lastFrameTimeMs) {
+      // It is possible for ChoreographerCallback to be executed twice within the same frame
+      // due to frame drops. If this occurs, the additional callback execution should be ignored.
+      mCallbackPosted.set(false);
+      scheduleQueueExecution();
+      return;
+    }
+
+    var frameCallbacks = pullCallbacks();
+    mCallbackPosted.set(false);
+
+    lastFrameTimeMs = currentFrameTimeMs;
+    for (var callback : frameCallbacks) {
+      callback.onAnimationFrame(currentFrameTimeMs);
+    }
+  }
+
+  private List<AnimationFrameCallback> pullCallbacks() {
+    synchronized (mFrameCallbacks) {
+      List<AnimationFrameCallback> frameCallbacks = new ArrayList<>(mFrameCallbacks);
+      mFrameCallbacks.clear();
+      return frameCallbacks;
+    }
+  }
+
+  private double calculateTimestamp(long frameTimeNanos) {
+    final double NANOSECONDS_IN_MILLISECONDS = 1000000;
+    double currentFrameTimeMs = frameTimeNanos / NANOSECONDS_IN_MILLISECONDS;
+    if (mSlowAnimationsEnabled) {
+      currentFrameTimeMs =
+          mFirstUptime + (currentFrameTimeMs - mFirstUptime) / mAnimationsDragFactor;
+    }
+    return currentFrameTimeMs;
+  }
+}

package/android/src/main/java/com/swmansion/worklets/JSCallInvokerResolver.java

@@ -0,0 +1,27 @@
+package com.swmansion.worklets;
+
+import androidx.annotation.OptIn;
+import com.facebook.react.bridge.ReactApplicationContext;
+import com.facebook.react.common.annotations.FrameworkAPI;
+import com.facebook.react.turbomodule.core.CallInvokerHolderImpl;
+
+public class JSCallInvokerResolver {
+
+  @OptIn(markerClass = FrameworkAPI.class)
+  public static CallInvokerHolderImpl getJSCallInvokerHolder(ReactApplicationContext context) {
+    try {
+      var method = context.getClass().getMethod("getJSCallInvokerHolder");
+      return (CallInvokerHolderImpl) method.invoke(context);
+    } catch (Exception ignored) {
+      // In newer implementations, the method is in CatalystInstance, continue.
+    }
+    try {
+      var catalystInstance = context.getClass().getMethod("getCatalystInstance").invoke(context);
+      assert catalystInstance != null;
+      var method = catalystInstance.getClass().getMethod("getJSCallInvokerHolder");
+      return (CallInvokerHolderImpl) method.invoke(catalystInstance);
+    } catch (Exception e) {
+      throw new RuntimeException("Failed to get JSCallInvokerHolder", e);
+    }
+  }
+}

package/android/src/main/java/com/swmansion/worklets/WorkletsMessageQueueThread.java

@@ -0,0 +1,16 @@
+package com.swmansion.worklets;
+
+import com.facebook.proguard.annotations.DoNotStrip;
+
+@DoNotStrip
+public class WorkletsMessageQueueThread extends WorkletsMessageQueueThreadBase {
+  @Override
+  public boolean runOnQueue(Runnable runnable) {
+    return messageQueueThread.runOnQueue(runnable);
+  }
+
+  @Override
+  public boolean isIdle() {
+    return messageQueueThread.isIdle();
+  }
+}