react-native-worklets 0.8.0 → 0.9.0-nightly-20260320-548038843

package/Common/cpp/worklets/SharedItems/Serializable.h

@@ -52,7 +52,7 @@ class RetainingSerializable : virtual public BaseClass {
   explicit RetainingSerializable(jsi::Runtime &rt, Args &&...args)
       : BaseClass(rt, std::forward<Args>(args)...), primaryRuntime_(&rt) {}
 
-  jsi::Value toJSValue(jsi::Runtime &rt) {
+  jsi::Value toJSValue(jsi::Runtime &rt) override {
     if (&rt == primaryRuntime_) {
       // TODO: it is suboptimal to generate new object every time getJS is
       // called on host runtime – the objects we are generating already exists
@@ -74,7 +74,7 @@ class RetainingSerializable : virtual public BaseClass {
     return BaseClass::toJSValue(rt);
   }
 
-  ~RetainingSerializable() {
+  ~RetainingSerializable() override {
     cleanupIfRuntimeExists(secondaryRuntime_, secondaryValue_);
   }
 };

package/Common/cpp/worklets/Tools/WorkletsJSIUtils.h

@@ -84,7 +84,7 @@ getArgsForFunction(std::function<Ret(Args...)>, jsi::Runtime &rt, const jsi::Val
 // passing `rt` as the first argument
 template <typename Ret, typename... Args>
 std::tuple<jsi::Runtime &, Args...> getArgsForFunction(
-    std::function<Ret(jsi::Runtime &, Args...)>,
+    const std::function<Ret(jsi::Runtime &, Args...)> &,
     jsi::Runtime &rt,
     const jsi::Value *args,
     const size_t count) {
@@ -116,7 +116,7 @@ inline jsi::Value apply(std::function<void(Args...)> function, std::tuple<Args..
 // returns a function with JSI calling convention
 // from a native function `function`
 template <typename Fun>
-jsi::HostFunctionType createHostFunction(Fun function) {
+jsi::HostFunctionType createHostFunction(const Fun &function) {
   return [function](jsi::Runtime &rt, const jsi::Value &, const jsi::Value *args, const size_t count) {
     auto argz = getArgsForFunction(function, rt, args, count);
     return apply(function, std::move(argz));
@@ -150,7 +150,7 @@ struct takes_runtime<jsi::Runtime &, Rest...> {
 // and installs it as a global function named `name`
 // in the `rt` JS runtime
 template <typename Ret, typename... Args>
-void installJsiFunction(jsi::Runtime &rt, std::string_view name, std::function<Ret(Args...)> function) {
+void installJsiFunction(jsi::Runtime &rt, std::string_view name, const std::function<Ret(Args...)> &function) {
   auto clb = createHostFunction(function);
   auto argsCount = sizeof...(Args) - takes_runtime<Args...>::value;
   jsi::Value jsiFunction =

package/Common/cpp/worklets/WorkletRuntime/UIRuntimeDecorator.cpp

@@ -8,12 +8,13 @@ namespace worklets {
 
 void UIRuntimeDecorator::decorate(
     facebook::jsi::Runtime &uiRuntime,
-    std::function<void(facebook::jsi::Runtime &rt, const facebook::jsi::Value &callback)> &&requestAnimationFrame) {
+    const std::function<void(facebook::jsi::Runtime &rt, const facebook::jsi::Value &callback)>
+        &requestAnimationFrame) {
   uiRuntime.global().setProperty(uiRuntime, runtimeKindBindingName, static_cast<int>(RuntimeKind::UI));
 
   uiRuntime.global().setProperty(uiRuntime, "_UI", true);
 
-  jsi_utils::installJsiFunction(uiRuntime, "requestAnimationFrame", std::move(requestAnimationFrame));
+  jsi_utils::installJsiFunction(uiRuntime, "requestAnimationFrame", requestAnimationFrame);
 }
 
 } // namespace worklets

package/Common/cpp/worklets/WorkletRuntime/UIRuntimeDecorator.h

@@ -8,7 +8,8 @@ class UIRuntimeDecorator {
  public:
   static void decorate(
       facebook::jsi::Runtime &uiRuntime,
-      std::function<void(facebook::jsi::Runtime &rt, const facebook::jsi::Value &callback)> &&requestAnimationFrame);
+      const std::function<void(facebook::jsi::Runtime &rt, const facebook::jsi::Value &callback)>
+          &requestAnimationFrame);
 };
 
 } // namespace worklets

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

@@ -0,0 +1,54 @@
+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/JSCallInvokerResolver.kt

@@ -0,0 +1,28 @@
+package com.swmansion.worklets
+
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.common.annotations.FrameworkAPI
+import com.facebook.react.turbomodule.core.CallInvokerHolderImpl
+
+object JSCallInvokerResolver {
+
+    @OptIn(FrameworkAPI::class)
+    @JvmStatic
+    fun getJSCallInvokerHolder(context: ReactApplicationContext): CallInvokerHolderImpl {
+        try {
+            val method = context.javaClass.getMethod("getJSCallInvokerHolder")
+            return method.invoke(context) as CallInvokerHolderImpl
+        } catch (_: Exception) {
+            // In newer implementations, the method is in CatalystInstance, continue.
+        }
+        try {
+            val catalystInstance =
+                context.javaClass.getMethod("getCatalystInstance").invoke(context)
+            checkNotNull(catalystInstance)
+            val method = catalystInstance.javaClass.getMethod("getJSCallInvokerHolder")
+            return method.invoke(catalystInstance) as CallInvokerHolderImpl
+        } catch (e: Exception) {
+            throw RuntimeException("Failed to get JSCallInvokerHolder", e)
+        }
+    }
+}

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

@@ -0,0 +1,89 @@
+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 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)
+            }
+            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/WorkletsMessageQueueThread.kt

@@ -0,0 +1,11 @@
+package com.swmansion.worklets
+
+import com.facebook.proguard.annotations.DoNotStrip
+
+@DoNotStrip
+class WorkletsMessageQueueThread : WorkletsMessageQueueThreadBase() {
+
+    override fun runOnQueue(runnable: Runnable): Boolean = messageQueueThread.runOnQueue(runnable)
+
+    override fun isIdle(): Boolean = messageQueueThread.isIdle()
+}

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

@@ -0,0 +1,59 @@
+package com.swmansion.worklets
+
+import com.facebook.proguard.annotations.DoNotStrip
+import com.facebook.react.bridge.queue.MessageQueueThread
+import com.facebook.react.bridge.queue.MessageQueueThreadImpl
+import com.facebook.react.bridge.queue.MessageQueueThreadPerfStats
+import com.facebook.react.bridge.queue.MessageQueueThreadSpec
+import java.util.concurrent.Callable
+import java.util.concurrent.Future
+
+// This class is an almost exact copy of MessageQueueThreadImpl taken from here:
+// https://github.com/facebook/react-native/blob/main/packages/react-native/ReactAndroid/src/main/java/com/facebook/react/bridge/queue/MessageQueueThreadImpl.kt
+// The only method that has changed is `quitSynchronous()` (see comment above
+// function implementation for details).
+@DoNotStrip
+abstract class WorkletsMessageQueueThreadBase : MessageQueueThread {
+
+    protected val messageQueueThread: MessageQueueThreadImpl =
+        MessageQueueThreadImpl.create(
+            MessageQueueThreadSpec.mainThreadSpec()
+        ) { exception ->
+            throw RuntimeException(exception)
+        }
+
+    override fun <T> callOnQueue(callable: Callable<T>): Future<T> =
+        messageQueueThread.callOnQueue(callable)
+
+    override fun isOnThread(): Boolean = messageQueueThread.isOnThread()
+
+    override fun assertIsOnThread() {
+        messageQueueThread.assertIsOnThread()
+    }
+
+    override fun assertIsOnThread(s: String) {
+        messageQueueThread.assertIsOnThread(s)
+    }
+
+    // We don't want to quit the main looper (which is what MessageQueueThreadImpl would have done),
+    // but we still want to prevent anything else from executing.
+    @Suppress("CallToPrintStackTrace")
+    override fun quitSynchronous() {
+        try {
+            val mIsFinished = messageQueueThread.javaClass.getDeclaredField("mIsFinished")
+            mIsFinished.isAccessible = true
+            mIsFinished.set(messageQueueThread, true)
+            mIsFinished.isAccessible = false
+        } catch (e: NoSuchFieldException) {
+            e.printStackTrace()
+        } catch (e: IllegalAccessException) {
+            e.printStackTrace()
+        }
+    }
+
+    override fun getPerfStats(): MessageQueueThreadPerfStats? = messageQueueThread.getPerfStats()
+
+    override fun resetPerfStats() {
+        messageQueueThread.resetPerfStats()
+    }
+}

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

@@ -0,0 +1,39 @@
+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,11 @@
+package com.swmansion.worklets.runloop
+
+import com.facebook.jni.HybridData
+import com.facebook.proguard.annotations.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,106 @@
+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/WorkletsModule.kt

@@ -0,0 +1,164 @@
+package com.swmansion.worklets
+
+import com.facebook.jni.HybridData
+import com.facebook.proguard.annotations.DoNotStrip
+import com.facebook.react.bridge.Callback
+import com.facebook.react.bridge.LifecycleEventListener
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.bridge.ReactMethod
+import com.facebook.react.bridge.ReadableNativeArray
+import com.facebook.react.bridge.ReadableNativeMap
+import com.facebook.react.bridge.queue.MessageQueueThread
+import com.facebook.react.common.annotations.FrameworkAPI
+import com.facebook.react.module.annotations.ReactModule
+import com.facebook.react.turbomodule.core.CallInvokerHolderImpl
+import com.facebook.soloader.SoLoader
+import com.swmansion.worklets.runloop.AnimationFrameCallback
+import com.swmansion.worklets.runloop.AnimationFrameQueue
+import java.util.concurrent.atomic.AtomicBoolean
+
+@Suppress("KotlinJniMissingFunction")
+@ReactModule(name = WorkletsModule.NAME)
+class WorkletsModule(reactContext: ReactApplicationContext) :
+    NativeWorkletsModuleSpec(reactContext), LifecycleEventListener {
+
+    companion object {
+        const val NAME = "WorkletsModule"
+
+        init {
+            SoLoader.loadLibrary("worklets")
+        }
+    }
+
+    @field:DoNotStrip
+    @Suppress("unused")
+    private var mHybridData: HybridData? = null
+
+    @Suppress("unused")
+    protected fun getHybridData(): HybridData? = mHybridData
+
+    init {
+        reactContext.assertOnJSQueueThread()
+    }
+
+    private val mMessageQueueThread = WorkletsMessageQueueThread()
+    private val mAndroidUIScheduler = AndroidUIScheduler(reactContext)
+    private val mAnimationFrameQueue = AnimationFrameQueue(reactContext)
+    private val mWorkletsNetworking = WorkletsNetworking()
+    private var mSlowAnimationsEnabled = false
+
+    /**
+     * Invalidating concurrently could be fatal. It shouldn't happen in a normal flow, but it doesn't
+     * cost us much to add synchronization for extra safety.
+     */
+    private val mInvalidated = AtomicBoolean(false)
+
+    @OptIn(FrameworkAPI::class)
+    private external fun initHybrid(
+        bundleModeEnabled: Boolean,
+        jsContext: Long,
+        messageQueueThread: MessageQueueThread,
+        jsCallInvokerHolder: CallInvokerHolderImpl,
+        androidUIScheduler: AndroidUIScheduler,
+        scriptBufferWrapper: ScriptBufferWrapper?
+    ): HybridData
+
+    @OptIn(FrameworkAPI::class)
+    @ReactMethod(isBlockingSynchronousMethod = true)
+    override fun installTurboModule(bundleModeEnabled: Boolean): Boolean {
+        val context = reactApplicationContext
+
+        context.assertOnJSQueueThread()
+
+        val jsContext = checkNotNull(context.javaScriptContextHolder).get()
+        val jsCallInvokerHolder = JSCallInvokerResolver.getJSCallInvokerHolder(context)
+
+        val sourceURL = context.sourceURL
+
+        val scriptBufferWrapper: ScriptBufferWrapper? = if (bundleModeEnabled) {
+            ScriptBufferWrapper(sourceURL!!, context.assets)
+        } else null
+
+        mHybridData =
+            initHybrid(
+                bundleModeEnabled,
+                jsContext,
+                mMessageQueueThread,
+                jsCallInvokerHolder,
+                mAndroidUIScheduler,
+                scriptBufferWrapper)
+        return true
+    }
+
+    fun abortRequest(runtimeId: Int, requestIdAsDouble: Double) {
+        mWorkletsNetworking.jsiAbortRequest(runtimeId, requestIdAsDouble)
+    }
+
+    fun clearCookies(callback: Callback) {
+        mWorkletsNetworking.jsiClearCookies(callback)
+    }
+
+    fun sendRequest(
+        runtimeWrapper: WorkletRuntimeWrapper,
+        method: String,
+        url: String,
+        requestIdAsDouble: Double,
+        headers: ReadableNativeArray,
+        data: ReadableNativeMap,
+        responseType: String,
+        useIncrementalUpdates: Boolean,
+        timeoutAsDouble: Double,
+        withCredentials: Boolean
+    ) {
+        mWorkletsNetworking.jsiSendRequest(
+            runtimeWrapper,
+            method,
+            url,
+            requestIdAsDouble,
+            headers,
+            data,
+            responseType,
+            useIncrementalUpdates,
+            timeoutAsDouble,
+            withCredentials)
+    }
+
+    fun requestAnimationFrame(animationFrameCallback: AnimationFrameCallback) {
+        mAnimationFrameQueue.requestAnimationFrame(animationFrameCallback)
+    }
+
+    /** @noinspection unused */
+    @DoNotStrip
+    fun isOnJSQueueThread(): Boolean = reactApplicationContext.isOnJSQueueThread
+
+    fun toggleSlowAnimations() {
+        val animationsDragFactor = 10
+        mSlowAnimationsEnabled = !mSlowAnimationsEnabled
+        mAnimationFrameQueue.enableSlowAnimations(mSlowAnimationsEnabled, animationsDragFactor)
+    }
+
+    override fun invalidate() {
+        if (mInvalidated.getAndSet(true)) {
+            return
+        }
+        if (mHybridData != null && mHybridData!!.isValid) {
+            // We have to destroy extra runtimes when invalidate is called. If we clean
+            // it up later instead there's a chance the runtime will retain references
+            // to invalidated memory and will crash on its destruction.
+            invalidateCpp()
+        }
+        mAndroidUIScheduler.deactivate()
+    }
+
+    private external fun invalidateCpp()
+
+    override fun onHostResume() {
+        mAnimationFrameQueue.resume()
+    }
+
+    override fun onHostPause() {
+        mAnimationFrameQueue.pause()
+    }
+
+    override fun onHostDestroy() {}
+}