@depup/react-native-worklets 0.11.3-depup.0

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

@@ -0,0 +1,203 @@
+#include <worklets/Tools/ScriptBuffer.h>
+#include <worklets/WorkletRuntime/BundleModeConfig.h>
+#include <worklets/WorkletRuntime/RuntimeBindings.h>
+#include <worklets/android/AnimationFrameCallback.h>
+#include <worklets/android/WorkletsModule.h>
+
+#ifdef WORKLETS_FETCH_PREVIEW_ENABLED
+#include <folly/json/dynamic.h>
+#include <jni.h>
+#include <jsi/JSIDynamic.h>
+#include <react/jni/JCallback.h>
+#include <react/jni/ReadableNativeArray.h>
+#include <react/jni/ReadableNativeMap.h>
+#include <worklets/WorkletRuntime/WorkletRuntime.h>
+#include <worklets/android/JWorkletRuntimeWrapper.h>
+
+#include <vector>
+#endif // WORKLETS_FETCH_PREVIEW_ENABLED
+
+#include <memory>
+#include <string>
+#include <utility>
+
+namespace worklets {
+
+using namespace facebook;
+using namespace react;
+
+WorkletsModule::WorkletsModule(
+    jni::alias_ref<jhybridobject> jThis, // NOLINT //(performance-unnecessary-value-param)
+    const BundleModeConfig &bundleModeConfig,
+    jsi::Runtime *rnRuntime,
+    const std::shared_ptr<facebook::react::CallInvoker> &jsCallInvoker,
+    const std::shared_ptr<UIScheduler> &uiScheduler)
+    : javaPart_(jni::make_global(jThis)),
+      rnRuntime_(rnRuntime),
+      rnRuntimeStatus_(std::make_shared<RNRuntimeStatus>()),
+      workletsModuleProxy_(std::make_shared<WorkletsModuleProxy>(
+          *rnRuntime,
+          jsCallInvoker,
+          uiScheduler,
+          getIsOnJSQueueThread(),
+          getRuntimeBindings(bundleModeConfig.enabled, *rnRuntime),
+          bundleModeConfig,
+          rnRuntimeStatus_)) {}
+
+jni::local_ref<WorkletsModule::jhybriddata> WorkletsModule::initHybrid(
+    jni::alias_ref<jhybridobject> jThis, // NOLINT //(performance-unnecessary-value-param)
+    jboolean bundleModeEnabled,
+    jlong jsContext,
+    jni::alias_ref<facebook::react::CallInvokerHolder::javaobject> jsCallInvokerHolder,
+    jni::alias_ref<worklets::AndroidUIScheduler::javaobject> androidUIScheduler,
+    jni::alias_ref<JScriptBufferWrapper::javaobject>
+        jScriptBufferWrapper // NOLINT //(performance-unnecessary-value-param)
+) {
+  auto jsCallInvoker = jsCallInvokerHolder->cthis()->getCallInvoker();
+  auto rnRuntime = reinterpret_cast<jsi::Runtime *>(jsContext); // NOLINT //(performance-no-int-to-ptr)
+  auto uiScheduler = androidUIScheduler->cthis()->getUIScheduler();
+
+  std::shared_ptr<const ScriptBuffer> script = nullptr;
+  std::string sourceURL;
+  if (bundleModeEnabled) {
+    auto cxxWrapper = jScriptBufferWrapper->cthis();
+    script = cxxWrapper->getScript();
+    sourceURL = cxxWrapper->getSourceUrl();
+  }
+
+  return makeCxxInstance(
+      jThis,
+      BundleModeConfig{
+          .enabled = static_cast<bool>(bundleModeEnabled),
+          .script = script,
+          .sourceURL = sourceURL,
+      },
+      rnRuntime,
+      jsCallInvoker,
+      uiScheduler);
+}
+
+std::shared_ptr<RuntimeBindings> WorkletsModule::getRuntimeBindings(
+    const bool bundleModeEnabled,
+    jsi::Runtime &rnRuntime) {
+  return std::make_shared<RuntimeBindings>(RuntimeBindings{
+      .requestAnimationFrame = getRequestAnimationFrame(),
+      .nativeLoggingHook =
+          bundleModeEnabled ? extractNativeLoggingHookFromRNRuntime(rnRuntime) : RuntimeBindings::NativeLoggingHook{}
+#ifdef WORKLETS_FETCH_PREVIEW_ENABLED
+      ,
+      .abortRequest = getAbortRequest(),
+      .clearCookies = getClearCookies(),
+      .sendRequest = getSendRequest()
+#endif // WORKLETS_FETCH_PREVIEW_ENABLED
+  });
+}
+
+RuntimeBindings::RequestAnimationFrame WorkletsModule::getRequestAnimationFrame() {
+  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());
+  };
+}
+
+#ifdef WORKLETS_FETCH_PREVIEW_ENABLED
+RuntimeBindings::AbortRequest WorkletsModule::getAbortRequest() {
+  return [javaPart = javaPart_](jsi::Runtime &rt, double requestId) -> void {
+    static const auto jAbortRequest = javaPart->getClass()->getMethod<void(int, double)>("abortRequest");
+    auto workletRuntime = WorkletRuntime::getWeakRuntimeFromJSIRuntime(rt).lock();
+    jAbortRequest(javaPart.get(), static_cast<int>(workletRuntime->getRuntimeId()), requestId);
+  };
+}
+
+RuntimeBindings::ClearCookies WorkletsModule::getClearCookies() {
+  return [javaPart = javaPart_](jsi::Runtime &rt, jsi::Function &&responseSender) {
+    static const auto jClearCookies = javaPart->getClass()->getMethod<void(JCallback::javaobject)>("clearCookies");
+    auto jsiFunction = std::make_shared<jsi::Function>(std::move(responseSender));
+    auto workletRuntime = WorkletRuntime::getWeakRuntimeFromJSIRuntime(rt);
+    auto callback = [jsiFunction, workletRuntime](folly::dynamic args) {
+      if (auto runtime = workletRuntime.lock()) {
+        runtime->schedule([jsiFunction, args = std::move(args)](jsi::Runtime &rt) {
+          std::vector<jsi::Value> jsArgs;
+          for (auto &arg : args) {
+            jsArgs.push_back(jsi::valueFromDynamic(rt, arg));
+          }
+          const jsi::Value *rawData = jsArgs.data();
+          size_t size = jsArgs.size();
+          jsiFunction->call(rt, rawData, size);
+        });
+      }
+    };
+    jClearCookies(javaPart.get(), JCxxCallbackImpl::newObjectCxxArgs(std::move(callback)).get());
+  };
+}
+
+RuntimeBindings::SendRequest WorkletsModule::getSendRequest() {
+  return [javaPart = javaPart_](
+             jsi::Runtime &rt,
+             jsi::String &method,
+             jsi::String &url,
+             double requestId,
+             jsi::Array &headers,
+             jsi::Object &data,
+             jsi::String &responseType,
+             bool incrementalUpdates,
+             double timeout,
+             bool withCredentials) {
+    static const auto jSendRequest = javaPart->getClass()
+                                         ->getMethod<void(
+                                             JWorkletRuntimeWrapper::javaobject,
+                                             std::string /* method */,
+                                             std::string /* url */,
+                                             double /* requestId */,
+                                             ReadableNativeArray::javaobject /* headers */,
+                                             ReadableNativeMap::javaobject /* data */,
+                                             std::string /* responseType */,
+                                             bool /* incrementalUpdates */,
+                                             double /* timeout */,
+                                             bool /* withCredentials */
+                                             )>("sendRequest");
+    auto workletRuntime = WorkletRuntime::getWeakRuntimeFromJSIRuntime(rt).lock();
+
+    jSendRequest(
+        javaPart.get(),
+        JWorkletRuntimeWrapper::makeJWorkletRuntimeWrapper(workletRuntime).get(),
+        method.utf8(rt),
+        url.utf8(rt),
+        requestId,
+        ReadableNativeArray::newObjectCxxArgs(jsi::dynamicFromValue(rt, jsi::Value(std::move(headers)))).get(),
+        ReadableNativeMap::newObjectCxxArgs(jsi::dynamicFromValue(rt, jsi::Value(std::move(data)))).get(),
+        responseType.utf8(rt),
+        incrementalUpdates,
+        timeout,
+        withCredentials);
+  };
+}
+#endif // WORKLETS_FETCH_PREVIEW_ENABLED
+
+std::function<bool()> WorkletsModule::getIsOnJSQueueThread() {
+  return [javaPart = javaPart_]() -> bool {
+    static const auto jIsOnJSQueueThread = javaPart->getClass()->getMethod<jboolean()>("isOnJSQueueThread");
+    return jIsOnJSQueueThread(javaPart);
+  };
+}
+
+void WorkletsModule::invalidateCpp() {
+  rnRuntimeStatus_->setDead();
+  javaPart_.reset();
+  workletsModuleProxy_.reset();
+}
+
+void WorkletsModule::startCpp() {
+  workletsModuleProxy_->start();
+}
+
+void WorkletsModule::registerNatives() {
+  registerHybrid({
+      makeNativeMethod("initHybrid", WorkletsModule::initHybrid),
+      makeNativeMethod("invalidateCpp", WorkletsModule::invalidateCpp),
+      makeNativeMethod("startCpp", WorkletsModule::startCpp),
+  });
+}
+
+} // namespace worklets

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

@@ -0,0 +1,75 @@
+#pragma once
+
+#include <ReactCommon/CallInvokerHolder.h>
+#include <fbjni/fbjni.h>
+#include <jsi/jsi.h>
+#include <worklets/NativeModules/WorkletsModuleProxy.h>
+#include <worklets/Tools/RNRuntimeStatus.h>
+#include <worklets/Tools/ScriptBuffer.h>
+#include <worklets/WorkletRuntime/BundleModeConfig.h>
+#include <worklets/WorkletRuntime/RuntimeBindings.h>
+#include <worklets/android/AndroidUIScheduler.h>
+#include <worklets/android/JScriptBufferWrapper.h>
+
+#include <memory>
+#include <string>
+
+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,
+      jboolean bundleModeEnabled,
+      jlong jsContext,
+      jni::alias_ref<facebook::react::CallInvokerHolder::javaobject> jsCallInvokerHolder,
+      jni::alias_ref<worklets::AndroidUIScheduler::javaobject> androidUIScheduler,
+      jni::alias_ref<JScriptBufferWrapper::javaobject> jScriptBufferWrapper);
+
+  static void registerNatives();
+
+  inline std::shared_ptr<WorkletsModuleProxy> getWorkletsModuleProxy() {
+    return workletsModuleProxy_;
+  }
+
+ private:
+  explicit WorkletsModule(
+      jni::alias_ref<jhybridobject> jThis,
+      const BundleModeConfig &bundleModeConfig,
+      jsi::Runtime *rnRuntime,
+      const std::shared_ptr<facebook::react::CallInvoker> &jsCallInvoker,
+      const std::shared_ptr<UIScheduler> &uiScheduler);
+
+  void startCpp();
+
+  void invalidateCpp();
+
+  template <class Signature>
+  JMethod<Signature> getJniMethod(std::string const &methodName) {
+    return javaPart_->getClass()->getMethod<Signature>(methodName.c_str());
+  }
+
+  std::shared_ptr<RuntimeBindings> getRuntimeBindings(bool bundleModeEnabled, jsi::Runtime &rnRuntime);
+
+  RuntimeBindings::RequestAnimationFrame getRequestAnimationFrame();
+#ifdef WORKLETS_FETCH_PREVIEW_ENABLED
+  RuntimeBindings::AbortRequest getAbortRequest();
+  RuntimeBindings::ClearCookies getClearCookies();
+  RuntimeBindings::SendRequest getSendRequest();
+#endif // WORKLETS_FETCH_PREVIEW_ENABLED
+
+  std::function<bool()> getIsOnJSQueueThread();
+
+  friend HybridBase;
+  jni::global_ref<WorkletsModule::javaobject> javaPart_;
+  jsi::Runtime *rnRuntime_;
+  std::shared_ptr<RNRuntimeStatus> rnRuntimeStatus_;
+  std::shared_ptr<WorkletsModuleProxy> workletsModuleProxy_;
+};
+
+} // namespace worklets

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

@@ -0,0 +1,19 @@
+#include <fbjni/fbjni.h>
+
+#include <worklets/android/AndroidUIScheduler.h>
+#include <worklets/android/AnimationFrameCallback.h>
+#include <worklets/android/JScriptBufferWrapper.h>
+#include <worklets/android/JWorkletRuntimeWrapper.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();
+    worklets::JScriptBufferWrapper::registerNatives();
+#ifdef WORKLETS_FETCH_PREVIEW_ENABLED
+    worklets::JWorkletRuntimeWrapper::registerNatives();
+#endif // WORKLETS_FETCH_PREVIEW_ENABLED
+  });
+}

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

@@ -0,0 +1,56 @@
+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
+
+@Suppress("KotlinJniMissingFunction")
+class AndroidUIScheduler(
+    context: ReactApplicationContext,
+) {
+    @field:DoNotStrip
+    private val mHybridData: HybridData = initHybrid()
+
+    private val mContext: ReactApplicationContext = context
+    private val mActive = AtomicBoolean(true)
+
+    private val mUIThreadRunnable =
+        Runnable {
+            // 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()
+                }
+            }
+        }
+
+    private external fun initHybrid(): HybridData
+
+    external fun triggerUI()
+
+    external fun invalidate()
+
+    @DoNotStrip
+    @Suppress("unused")
+    private fun scheduleTriggerOnUI() {
+        UiThreadUtil.runOnUiThread(
+            object : GuardedRunnable(mContext.exceptionHandler) {
+                override fun runGuarded() {
+                    mUIThreadRunnable.run()
+                }
+            },
+        )
+    }
+
+    fun deactivate() {
+        synchronized(mActive) {
+            mActive.set(false)
+            invalidate()
+        }
+    }
+}

package/android/src/main/java/com/swmansion/worklets/ScriptBufferWrapper.kt

@@ -0,0 +1,103 @@
+package com.swmansion.worklets
+
+import android.annotation.SuppressLint
+import android.content.res.AssetManager
+import android.os.Build
+import com.facebook.jni.HybridData
+import com.facebook.proguard.annotations.DoNotStrip
+import com.facebook.proguard.annotations.DoNotStripAny
+import java.io.IOException
+import java.io.InputStream
+import java.net.HttpURLConnection
+import java.net.URL
+import java.nio.charset.StandardCharsets
+
+/** A wrapper around a JavaScript bundle that is backed by a native C++ object. */
+@Suppress("KotlinJniMissingFunction")
+@SuppressLint("MissingNativeLoadLibrary")
+@DoNotStripAny
+class ScriptBufferWrapper(
+    uri: String,
+    assetManager: AssetManager,
+) {
+    @field:DoNotStrip
+    private val mHybridData: HybridData
+
+    init {
+        val filePrefix = "file://"
+        val absPathPrefix = "/"
+        val assetsPrefix = "assets://"
+
+        mHybridData =
+            when {
+                uri.startsWith(filePrefix) -> {
+                    val fileName = uri.substring(filePrefix.length)
+                    initHybridFromFile(fileName)
+                }
+                uri.startsWith(assetsPrefix) -> {
+                    val assetURL = uri.substring(assetsPrefix.length)
+                    initHybridFromAssets(assetManager, assetURL)
+                }
+                uri.startsWith(absPathPrefix) -> {
+                    initHybridFromFile(uri)
+                }
+                else -> {
+                    val scriptContent =
+                        try {
+                            downloadScript(uri)
+                        } catch (e: IOException) {
+                            throw RuntimeException(e)
+                        }
+                    initHybridFromString(scriptContent, uri)
+                }
+            }
+    }
+
+    private external fun initHybridFromAssets(
+        assetManager: AssetManager,
+        assetURL: String,
+    ): HybridData
+
+    private external fun initHybridFromFile(fileName: String): HybridData
+
+    private external fun initHybridFromString(
+        script: String,
+        url: String,
+    ): HybridData
+
+    companion object {
+        private fun downloadScript(url: String): String {
+            val scriptUrl = URL(url)
+            val connection = scriptUrl.openConnection() as HttpURLConnection
+            try {
+                val content: ByteArray
+
+                if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.TIRAMISU) {
+                    content = connection.inputStream.readAllBytes()
+                } else {
+                    content = readBytes(connection.inputStream)
+                }
+
+                return String(content, StandardCharsets.UTF_8)
+            } finally {
+                connection.disconnect()
+            }
+        }
+
+        /** Reads all bytes from an InputStream into a byte array for SDKs below 33. */
+        private fun readBytes(inputStream: InputStream): ByteArray {
+            val bufferSize = 4096
+            try {
+                val byteBuffer = java.io.ByteArrayOutputStream()
+                val buffer = ByteArray(bufferSize)
+                var len: Int
+                while (inputStream.read(buffer).also { len = it } != -1) {
+                    byteBuffer.write(buffer, 0, len)
+                }
+                return byteBuffer.toByteArray()
+            } finally {
+                inputStream.close()
+            }
+        }
+    }
+}

package/android/src/main/java/com/swmansion/worklets/WorkletsPackage.kt

@@ -0,0 +1,42 @@
+package com.swmansion.worklets
+
+import com.facebook.react.BaseReactPackage
+import com.facebook.react.ReactPackage
+import com.facebook.react.bridge.NativeModule
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.module.annotations.ReactModule
+import com.facebook.react.module.annotations.ReactModuleList
+import com.facebook.react.module.model.ReactModuleInfo
+import com.facebook.react.module.model.ReactModuleInfoProvider
+
+@ReactModuleList(nativeModules = [WorkletsModule::class])
+class WorkletsPackage :
+    BaseReactPackage(),
+    ReactPackage {
+    override fun getModule(
+        name: String,
+        reactContext: ReactApplicationContext,
+    ): NativeModule? = if (name == WorkletsModule.NAME) WorkletsModule(reactContext) else null
+
+    override fun getReactModuleInfoProvider(): ReactModuleInfoProvider {
+        val moduleList: Array<Class<*>> = arrayOf(WorkletsModule::class.java)
+
+        val reactModuleInfoMap = HashMap<String, ReactModuleInfo>()
+        for (moduleClass in moduleList) {
+            val reactModule: ReactModule =
+                checkNotNull(moduleClass.getAnnotation(ReactModule::class.java))
+
+            reactModuleInfoMap[reactModule.name] =
+                ReactModuleInfo(
+                    reactModule.name,
+                    moduleClass.name,
+                    reactModule.canOverrideExistingModule,
+                    reactModule.needsEagerInit,
+                    reactModule.isCxxModule,
+                    true,
+                )
+        }
+
+        return ReactModuleInfoProvider { reactModuleInfoMap }
+    }
+}

package/android/src/main/java/com/swmansion/worklets/runloop/AnimationFrameCallback.kt

@@ -0,0 +1,14 @@
+package com.swmansion.worklets.runloop
+
+import com.facebook.jni.HybridData
+import com.facebook.proguard.annotations.DoNotStrip
+
+@DoNotStrip
+@Suppress("KotlinJniMissingFunction")
+class AnimationFrameCallback
+    @DoNotStrip
+    private constructor(
+        @field:DoNotStrip private val mHybridData: HybridData,
+    ) {
+        external fun onAnimationFrame(timestampMs: Double)
+    }

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

@@ -0,0 +1,112 @@
+package com.swmansion.worklets.runloop
+
+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.concurrent.atomic.AtomicBoolean
+
+class AnimationFrameQueue(
+    reactApplicationContext: ReactApplicationContext,
+) {
+    private var mFirstUptime = SystemClock.uptimeMillis()
+    private var mSlowAnimationsEnabled = false
+    private var lastFrameTimeMs = 0.0
+    private var mAnimationsDragFactor = 1
+
+    // ReactChoreographer is
+    // [thread safe](https://github.com/facebook/react-native/blob/main/packages/react-native/ReactAndroid/src/main/java/com/facebook/react/modules/core/ReactChoreographer.kt#L21).
+    private val mReactChoreographer: ReactChoreographer = ReactChoreographer.getInstance()
+    private val mChoreographerCallback: GuardedFrameCallback =
+        object : GuardedFrameCallback(reactApplicationContext) {
+            override fun doFrameGuarded(frameTimeNanos: Long) {
+                executeQueue(frameTimeNanos)
+            }
+        }
+    private val mCallbackPosted = AtomicBoolean()
+    private val mPaused = AtomicBoolean()
+    private val mFrameCallbacks = mutableListOf<AnimationFrameCallback>()
+
+    fun resume() {
+        if (mPaused.getAndSet(false)) {
+            scheduleQueueExecution()
+        }
+    }
+
+    fun pause() {
+        synchronized(mPaused) {
+            if (!mPaused.getAndSet(true) && mCallbackPosted.getAndSet(false)) {
+                mReactChoreographer.removeFrameCallback(
+                    ReactChoreographer.CallbackType.NATIVE_ANIMATED_MODULE,
+                    mChoreographerCallback,
+                )
+            }
+        }
+    }
+
+    fun requestAnimationFrame(animationFrameCallback: AnimationFrameCallback) {
+        synchronized(mFrameCallbacks) {
+            mFrameCallbacks.add(animationFrameCallback)
+        }
+        scheduleQueueExecution()
+    }
+
+    fun enableSlowAnimations(
+        slowAnimationsEnabled: Boolean,
+        animationsDragFactor: Int,
+    ) {
+        mSlowAnimationsEnabled = slowAnimationsEnabled
+        mAnimationsDragFactor = animationsDragFactor
+        if (slowAnimationsEnabled) {
+            mFirstUptime = SystemClock.uptimeMillis()
+        }
+    }
+
+    private fun scheduleQueueExecution() {
+        synchronized(mPaused) {
+            if (!mPaused.get() && !mCallbackPosted.getAndSet(true)) {
+                mReactChoreographer.postFrameCallback(
+                    ReactChoreographer.CallbackType.NATIVE_ANIMATED_MODULE,
+                    mChoreographerCallback,
+                )
+            }
+        }
+    }
+
+    private fun executeQueue(frameTimeNanos: Long) {
+        val 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
+        }
+
+        val frameCallbacks = pullCallbacks()
+        mCallbackPosted.set(false)
+
+        lastFrameTimeMs = currentFrameTimeMs
+        for (callback in frameCallbacks) {
+            callback.onAnimationFrame(currentFrameTimeMs)
+        }
+    }
+
+    private fun pullCallbacks(): List<AnimationFrameCallback> {
+        synchronized(mFrameCallbacks) {
+            val frameCallbacks = mFrameCallbacks.toList()
+            mFrameCallbacks.clear()
+            return frameCallbacks
+        }
+    }
+
+    private fun calculateTimestamp(frameTimeNanos: Long): Double {
+        val nanosecondsInMilliseconds = 1000000.0
+        var currentFrameTimeMs = frameTimeNanos / nanosecondsInMilliseconds
+        if (mSlowAnimationsEnabled) {
+            currentFrameTimeMs =
+                mFirstUptime + (currentFrameTimeMs - mFirstUptime) / mAnimationsDragFactor
+        }
+        return currentFrameTimeMs
+    }
+}

package/android/src/networking/com/swmansion/worklets/WorkletRuntimeWrapper.kt

@@ -0,0 +1,27 @@
+package com.swmansion.worklets
+
+import com.facebook.jni.HybridData
+import com.facebook.jni.annotations.DoNotStrip
+import com.facebook.react.bridge.Arguments
+import com.facebook.react.bridge.WritableNativeArray
+
+@DoNotStrip
+@Suppress("KotlinJniMissingFunction")
+class WorkletRuntimeWrapper
+    @DoNotStrip
+    private constructor(
+        @field:DoNotStrip private val mHybridData: HybridData,
+    ) {
+        fun emitDeviceEvent(
+            eventName: String,
+            params: Any?,
+        ) {
+            cxxEmitDeviceEvent(Arguments.fromJavaArgs(arrayOf(eventName, params)))
+        }
+
+        fun getRuntimeId(): Int = cxxGetRuntimeId()
+
+        private external fun cxxEmitDeviceEvent(args: WritableNativeArray)
+
+        private external fun cxxGetRuntimeId(): Int
+    }

package/android/src/networking/com/swmansion/worklets/WorkletsHeaderUtil.kt

@@ -0,0 +1,30 @@
+/**
+* Based on HeaderUtil.kt from React Native
+*/
+
+package com.swmansion.worklets
+
+/**
+ * The class purpose is to weaken too strict OkHttp restriction on http headers. See:
+ * https://github.com/square/okhttp/issues/2016 Auth headers might have an Authentication
+ * information. It is better to get 401 from the server in this case, rather than non descriptive
+ * error as 401 could be handled to invalidate the wrong token in the client code.
+ */
+internal class WorkletsHeaderUtil {
+    companion object {
+        @JvmStatic
+        fun stripHeaderName(name: String): String {
+            val builder = StringBuilder(name.length)
+            var modified = false
+            for (i in 0 until name.length) {
+                val c = name[i]
+                if (c > '\u0020' && c < '\u007f') {
+                    builder.append(c)
+                } else {
+                    modified = true
+                }
+            }
+            return if (modified) builder.toString() else name
+        }
+    }
+}