@depup/react-native-worklets 0.12.1-depup.0 → 0.13.0-depup.0

package/android/src/main/cpp/worklets/android/networking/JNetworkRequestListener.cpp

@@ -0,0 +1,73 @@
+#include <worklets/android/networking/JNetworkRequestListener.h>
+
+#include <string>
+#include <utility>
+#include <vector>
+
+namespace worklets {
+
+// Must match the error codes in
+// `android/src/main/java/com/swmansion/worklets/networking/Networking.kt`.
+constexpr jint kErrorTimeout = 1;
+constexpr jint kErrorAborted = 2;
+
+void JNetworkRequestListener::onResponse(
+    jint status,
+    jni::alias_ref<jni::JString> statusText, // NOLINT //(performance-unnecessary-value-param)
+    jni::alias_ref<jni::JArrayClass<jni::JString>> headerNames, // NOLINT //(performance-unnecessary-value-param)
+    jni::alias_ref<jni::JArrayClass<jni::JString>> headerValues, // NOLINT //(performance-unnecessary-value-param)
+    jni::alias_ref<jni::JString> url // NOLINT //(performance-unnecessary-value-param)
+) {
+  ResponseInfo responseInfo;
+  responseInfo.status = status;
+  responseInfo.statusText = statusText->toStdString();
+  const auto size = headerNames->size();
+  responseInfo.headers.reserve(size);
+  for (size_t i = 0; i < size; i++) {
+    responseInfo.headers.emplace_back(
+        headerNames->getElement(i)->toStdString(), headerValues->getElement(i)->toStdString());
+  }
+  responseInfo.url = url->toStdString();
+  listener_->onResponse(std::move(responseInfo));
+}
+
+void JNetworkRequestListener::onUploadProgress(jlong sent, jlong total) {
+  listener_->onUploadProgress(sent, total);
+}
+
+void JNetworkRequestListener::onDownloadProgress(jlong received, jlong total) {
+  listener_->onDownloadProgress(received, total);
+}
+
+void JNetworkRequestListener::onComplete(
+    jni::alias_ref<jni::JArrayByte> body // NOLINT //(performance-unnecessary-value-param)
+) {
+  const auto size = body->size();
+  std::vector<uint8_t> bytes(size);
+  body->getRegion(0, size, reinterpret_cast<jbyte *>(bytes.data()));
+  listener_->onComplete(std::move(bytes));
+}
+
+void JNetworkRequestListener::onError(
+    jint errorCode,
+    jni::alias_ref<jni::JString> message // NOLINT //(performance-unnecessary-value-param)
+) {
+  auto error = RequestError::Network;
+  if (errorCode == kErrorTimeout) {
+    error = RequestError::Timeout;
+  } else if (errorCode == kErrorAborted) {
+    error = RequestError::Aborted;
+  }
+  listener_->onError(error, message->toStdString());
+}
+
+void JNetworkRequestListener::registerNatives() {
+  registerHybrid(
+      {makeNativeMethod("onResponse", JNetworkRequestListener::onResponse),
+       makeNativeMethod("onUploadProgress", JNetworkRequestListener::onUploadProgress),
+       makeNativeMethod("onDownloadProgress", JNetworkRequestListener::onDownloadProgress),
+       makeNativeMethod("onComplete", JNetworkRequestListener::onComplete),
+       makeNativeMethod("onError", JNetworkRequestListener::onError)});
+}
+
+} // namespace worklets

package/android/src/main/cpp/worklets/android/networking/JNetworkRequestListener.h

@@ -0,0 +1,38 @@
+#pragma once
+
+#include <fbjni/fbjni.h>
+#include <worklets/Networking/NetworkingBackend.h>
+
+#include <memory>
+#include <utility>
+
+namespace worklets {
+
+using namespace facebook;
+
+class JNetworkRequestListener : public jni::HybridClass<JNetworkRequestListener> {
+ public:
+  static auto constexpr kJavaDescriptor = "Lcom/swmansion/worklets/networking/NetworkRequestListener;";
+
+  static void registerNatives();
+
+  void onResponse(
+      jint status,
+      jni::alias_ref<jni::JString> statusText,
+      jni::alias_ref<jni::JArrayClass<jni::JString>> headerNames,
+      jni::alias_ref<jni::JArrayClass<jni::JString>> headerValues,
+      jni::alias_ref<jni::JString> url);
+  void onUploadProgress(jlong sent, jlong total);
+  void onDownloadProgress(jlong received, jlong total);
+  void onComplete(jni::alias_ref<jni::JArrayByte> body);
+  void onError(jint errorCode, jni::alias_ref<jni::JString> message);
+
+ private:
+  friend HybridBase;
+
+  explicit JNetworkRequestListener(std::shared_ptr<NetworkRequestListener> listener) : listener_(std::move(listener)) {}
+
+  const std::shared_ptr<NetworkRequestListener> listener_;
+};
+
+} // namespace worklets

package/android/src/{no-networking → main/java}/com/swmansion/worklets/WorkletsModule.kt

@@ -9,11 +9,12 @@ 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.networking.Networking
 import com.swmansion.worklets.runloop.AnimationFrameCallback
 import com.swmansion.worklets.runloop.AnimationFrameQueue
 
 @Suppress("KotlinJniMissingFunction")
-@ReactModule(name = WorkletsModule.NAME)
+@ReactModule(name = WorkletsModule.NAME, needsEagerInit = true)
 class WorkletsModule(
     reactContext: ReactApplicationContext,
 ) : NativeWorkletsModuleSpec(reactContext),
@@ -33,12 +34,9 @@ class WorkletsModule(
     @Suppress("unused")
     protected fun getHybridData(): HybridData? = mHybridData
 
-    init {
-        reactContext.assertOnJSQueueThread()
-    }
-
     private val mAndroidUIScheduler = AndroidUIScheduler(reactContext)
     private val mAnimationFrameQueue = AnimationFrameQueue(reactContext)
+    private val mNetworking = Networking()
     private var mSlowAnimationsEnabled = false
 
     /**
@@ -50,38 +48,34 @@ class WorkletsModule(
 
     @OptIn(FrameworkAPI::class)
     private external fun initHybrid(
-        bundleModeEnabled: Boolean,
         jsContext: Long,
         jsCallInvokerHolder: CallInvokerHolderImpl,
         androidUIScheduler: AndroidUIScheduler,
-        scriptBufferWrapper: ScriptBufferWrapper?,
+        networking: Networking,
     ): HybridData
 
-    @OptIn(FrameworkAPI::class)
-    @ReactMethod(isBlockingSynchronousMethod = true)
-    override fun installTurboModule(bundleModeEnabled: Boolean): Boolean {
-        val context = reactApplicationContext
+    private external fun prepareProxyCpp()
 
-        context.assertOnJSQueueThread()
+    private external fun beginBundleModeAOTCpp()
 
-        val jsContext = checkNotNull(context.javaScriptContextHolder).get()
-        val jsCallInvokerHolder = context.jsCallInvokerHolder as CallInvokerHolderImpl
+    private external fun prepareBundleModeAOTCpp()
 
-        val scriptBufferWrapper: ScriptBufferWrapper? =
-            if (bundleModeEnabled) {
-                ScriptBufferWrapper(context.sourceURL, context)
-            } else {
-                null
-            }
+    private external fun installTurboModuleCpp(bundleModeEnabled: Boolean)
+
+    @OptIn(FrameworkAPI::class)
+    @ReactMethod(isBlockingSynchronousMethod = true)
+    override fun prepareBundleMode(): Boolean {
+        reactApplicationContext.assertOnJSQueueThread()
+        beginBundleModeAOTCpp()
+        Thread({ prepareBundleModeAOTCpp() }, "WorkletsBundleModePrepare").start()
+        return true
+    }
 
-        mHybridData =
-            initHybrid(
-                bundleModeEnabled,
-                jsContext,
-                jsCallInvokerHolder,
-                mAndroidUIScheduler,
-                scriptBufferWrapper,
-            )
+    @OptIn(FrameworkAPI::class)
+    @ReactMethod(isBlockingSynchronousMethod = true)
+    override fun installTurboModule(bundleModeEnabled: Boolean): Boolean {
+        reactApplicationContext.assertOnJSQueueThread()
+        installTurboModuleCpp(bundleModeEnabled)
         return true
     }
 
@@ -102,6 +96,10 @@ class WorkletsModule(
     @DoNotStrip
     fun isOnJSQueueThread(): Boolean = reactApplicationContext.isOnJSQueueThread
 
+    /** @noinspection unused */
+    @DoNotStrip
+    fun createScriptBufferWrapper(): ScriptBufferWrapper = ScriptBufferWrapper(reactApplicationContext.sourceURL, reactApplicationContext)
+
     fun toggleSlowAnimations() {
         val animationsDragFactor = 10
         mSlowAnimationsEnabled = !mSlowAnimationsEnabled
@@ -117,6 +115,8 @@ class WorkletsModule(
 
     override fun initialize() {
         reactApplicationContext.addLifecycleEventListener(this)
+        createHybrid()
+        Thread({ prepareProxyCpp() }, "WorkletsProxyPrepare").start()
     }
 
     override fun invalidate() {
@@ -127,6 +127,7 @@ class WorkletsModule(
             mInvalidated = true
             reactApplicationContext.removeLifecycleEventListener(this)
         }
+        mAnimationFrameQueue.invalidate()
         if (mHybridData != null && mHybridData!!.isValid) {
             invalidateCpp()
         }
@@ -156,4 +157,15 @@ class WorkletsModule(
     }
 
     override fun onHostDestroy() {}
+
+    @OptIn(FrameworkAPI::class)
+    private fun createHybrid() {
+        val context = reactApplicationContext
+        val jsContext =
+            checkNotNull(context.javaScriptContextHolder) {
+                "[Worklets] JavaScript context is not available yet."
+            }.get()
+        val jsCallInvokerHolder = context.jsCallInvokerHolder as CallInvokerHolderImpl
+        mHybridData = initHybrid(jsContext, jsCallInvokerHolder, mAndroidUIScheduler, mNetworking)
+    }
 }

package/android/src/main/java/com/swmansion/worklets/networking/NetworkRequestListener.kt

@@ -0,0 +1,37 @@
+package com.swmansion.worklets.networking
+
+import com.facebook.jni.HybridData
+import com.facebook.proguard.annotations.DoNotStrip
+
+@DoNotStrip
+@Suppress("KotlinJniMissingFunction")
+class NetworkRequestListener
+    @DoNotStrip
+    private constructor(
+        @field:DoNotStrip private val mHybridData: HybridData,
+    ) {
+        external fun onResponse(
+            status: Int,
+            statusText: String,
+            headerNames: Array<String>,
+            headerValues: Array<String>,
+            url: String,
+        )
+
+        external fun onUploadProgress(
+            sent: Long,
+            total: Long,
+        )
+
+        external fun onDownloadProgress(
+            received: Long,
+            total: Long,
+        )
+
+        external fun onComplete(body: ByteArray)
+
+        external fun onError(
+            errorCode: Int,
+            message: String,
+        )
+    }

package/android/src/main/java/com/swmansion/worklets/networking/Networking.kt

@@ -0,0 +1,244 @@
+package com.swmansion.worklets.networking
+
+import com.facebook.proguard.annotations.DoNotStrip
+import com.facebook.react.modules.network.CookieJarContainer
+import com.facebook.react.modules.network.ForwardingCookieHandler
+import com.facebook.react.modules.network.OkHttpClientProvider
+import okhttp3.Call
+import okhttp3.Callback
+import okhttp3.CookieJar
+import okhttp3.JavaNetCookieJar
+import okhttp3.MediaType
+import okhttp3.MediaType.Companion.toMediaTypeOrNull
+import okhttp3.OkHttpClient
+import okhttp3.Request
+import okhttp3.RequestBody
+import okhttp3.Response
+import okio.Buffer
+import okio.BufferedSink
+import okio.ForwardingSink
+import okio.buffer
+import java.io.IOException
+import java.io.InterruptedIOException
+import java.nio.charset.Charset
+import java.util.Collections
+import java.util.concurrent.ConcurrentHashMap
+import java.util.concurrent.TimeUnit
+
+class Networking {
+    companion object {
+        const val ERROR_NETWORK = 0
+        const val ERROR_TIMEOUT = 1
+        const val ERROR_ABORTED = 2
+        private const val PROGRESS_INTERVAL_MS = 50L
+        private const val READ_BUFFER_SIZE = 65536L
+        private val METHODS_REQUIRING_BODY = setOf("POST", "PUT", "PATCH")
+    }
+
+    private val mClient: OkHttpClient by lazy {
+        val client = OkHttpClientProvider.createClient()
+        (client.cookieJar as? CookieJarContainer)?.setCookieJar(JavaNetCookieJar(ForwardingCookieHandler()))
+        client
+    }
+    private val mCalls = ConcurrentHashMap<Long, Call>()
+    private val mAbortedIds: MutableSet<Long> = Collections.newSetFromMap(ConcurrentHashMap())
+
+    @DoNotStrip
+    @Suppress("TooGenericExceptionCaught")
+    fun sendRequest(
+        requestIdAsDouble: Double,
+        method: String,
+        url: String,
+        headerNames: Array<String>,
+        headerValues: Array<String>,
+        body: ByteArray?,
+        timeoutMs: Double,
+        withCredentials: Boolean,
+        listener: NetworkRequestListener,
+    ) {
+        val requestId = requestIdAsDouble.toLong()
+        try {
+            val call = buildCall(method, url, headerNames, headerValues, body, timeoutMs, withCredentials, listener)
+            mCalls[requestId] = call
+            if (mAbortedIds.contains(requestId)) {
+                call.cancel()
+            }
+            call.enqueue(
+                object : Callback {
+                    override fun onFailure(
+                        call: Call,
+                        e: IOException,
+                    ) {
+                        val code = errorCode(requestId, call, e)
+                        cleanup(requestId)
+                        listener.onError(code, e.message ?: e.javaClass.simpleName)
+                    }
+
+                    override fun onResponse(
+                        call: Call,
+                        response: Response,
+                    ) {
+                        try {
+                            response.use { handleResponse(it, listener) }
+                        } catch (t: Throwable) {
+                            listener.onError(
+                                if (t is IOException) errorCode(requestId, call, t) else ERROR_NETWORK,
+                                t.message ?: t.javaClass.simpleName,
+                            )
+                        } finally {
+                            cleanup(requestId)
+                        }
+                    }
+                },
+            )
+        } catch (e: Exception) {
+            cleanup(requestId)
+            listener.onError(ERROR_NETWORK, e.message ?: e.javaClass.simpleName)
+        }
+    }
+
+    @DoNotStrip
+    @Suppress("SwallowedException")
+    fun decodeText(
+        bytes: ByteArray,
+        label: String,
+    ): String? =
+        try {
+            String(bytes, Charset.forName(label))
+        } catch (e: IllegalArgumentException) {
+            null
+        }
+
+    @DoNotStrip
+    fun abortRequest(requestIdAsDouble: Double) {
+        val requestId = requestIdAsDouble.toLong()
+        mAbortedIds.add(requestId)
+        mCalls[requestId]?.cancel()
+    }
+
+    @Suppress("LongParameterList")
+    private fun buildCall(
+        method: String,
+        url: String,
+        headerNames: Array<String>,
+        headerValues: Array<String>,
+        body: ByteArray?,
+        timeoutMs: Double,
+        withCredentials: Boolean,
+        listener: NetworkRequestListener,
+    ): Call {
+        val requestBuilder = Request.Builder().url(url)
+        var contentType: MediaType? = null
+        for (i in headerNames.indices) {
+            requestBuilder.addHeader(headerNames[i], headerValues[i])
+            if (headerNames[i].equals("content-type", ignoreCase = true)) {
+                contentType = headerValues[i].toMediaTypeOrNull()
+            }
+        }
+        val requestBody =
+            when {
+                body != null -> ProgressRequestBody(body, contentType, listener)
+                method.uppercase() in METHODS_REQUIRING_BODY ->
+                    ProgressRequestBody(ByteArray(0), contentType, listener)
+                else -> null
+            }
+        requestBuilder.method(method, requestBody)
+
+        val clientBuilder =
+            mClient
+                .newBuilder()
+                .callTimeout(if (timeoutMs > 0) timeoutMs.toLong() else 0, TimeUnit.MILLISECONDS)
+        if (!withCredentials) {
+            clientBuilder.cookieJar(CookieJar.NO_COOKIES)
+        }
+        return clientBuilder.build().newCall(requestBuilder.build())
+    }
+
+    private fun handleResponse(
+        response: Response,
+        listener: NetworkRequestListener,
+    ) {
+        val headers = response.headers
+        val headerNames = Array(headers.size) { headers.name(it) }
+        val headerValues = Array(headers.size) { headers.value(it) }
+        listener.onResponse(response.code, response.message, headerNames, headerValues, response.request.url.toString())
+
+        val responseBody = response.body
+        if (responseBody == null) {
+            listener.onComplete(ByteArray(0))
+            return
+        }
+
+        val contentLength = responseBody.contentLength()
+        val source = responseBody.source()
+        val output = Buffer()
+        var lastProgressAt = 0L
+        while (true) {
+            val read = source.read(output, READ_BUFFER_SIZE)
+            if (read == -1L) {
+                break
+            }
+            val now = System.currentTimeMillis()
+            if (now - lastProgressAt >= PROGRESS_INTERVAL_MS) {
+                lastProgressAt = now
+                listener.onDownloadProgress(output.size, contentLength)
+            }
+        }
+
+        listener.onComplete(output.readByteArray())
+    }
+
+    private fun cleanup(requestId: Long) {
+        mCalls.remove(requestId)
+        mAbortedIds.remove(requestId)
+    }
+
+    private fun errorCode(
+        requestId: Long,
+        call: Call,
+        e: IOException,
+    ): Int =
+        when {
+            mAbortedIds.contains(requestId) -> ERROR_ABORTED
+            e is InterruptedIOException -> ERROR_TIMEOUT
+            call.isCanceled() -> ERROR_ABORTED
+            else -> ERROR_NETWORK
+        }
+
+    private class ProgressRequestBody(
+        private val body: ByteArray,
+        private val contentType: MediaType?,
+        private val listener: NetworkRequestListener,
+    ) : RequestBody() {
+        override fun contentType(): MediaType? = contentType
+
+        override fun contentLength(): Long = body.size.toLong()
+
+        override fun writeTo(sink: BufferedSink) {
+            var sent = 0L
+            var lastProgressAt = 0L
+            val total = body.size.toLong()
+            val countingSink =
+                object : ForwardingSink(sink) {
+                    override fun write(
+                        source: Buffer,
+                        byteCount: Long,
+                    ) {
+                        super.write(source, byteCount)
+                        sent += byteCount
+                        val now = System.currentTimeMillis()
+                        if (sent == total || now - lastProgressAt >= PROGRESS_INTERVAL_MS) {
+                            lastProgressAt = now
+                            listener.onUploadProgress(sent, total)
+                        }
+                    }
+                }
+            val bufferedSink = countingSink.buffer()
+            bufferedSink.write(body)
+            bufferedSink.flush()
+            if (sent == 0L) {
+                listener.onUploadProgress(0L, 0L)
+            }
+        }
+    }
+}

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

@@ -25,7 +25,9 @@ class AnimationFrameQueue(
         }
     private val mCallbackPosted = AtomicBoolean()
     private val mPaused = AtomicBoolean()
+    private val mInvalidated = AtomicBoolean()
     private val mFrameCallbacks = mutableListOf<AnimationFrameCallback>()
+    private val mDispatchLock = Any()
 
     fun resume() {
         if (mPaused.getAndSet(false)) {
@@ -44,8 +46,21 @@ class AnimationFrameQueue(
         }
     }
 
+    fun invalidate() {
+        mInvalidated.set(true)
+        removePostedFrameCallback()
+        synchronized(mDispatchLock) {
+            synchronized(mFrameCallbacks) {
+                mFrameCallbacks.clear()
+            }
+        }
+    }
+
     fun requestAnimationFrame(animationFrameCallback: AnimationFrameCallback) {
         synchronized(mFrameCallbacks) {
+            if (mInvalidated.get()) {
+                return
+            }
             mFrameCallbacks.add(animationFrameCallback)
         }
         scheduleQueueExecution()
@@ -64,6 +79,9 @@ class AnimationFrameQueue(
 
     private fun scheduleQueueExecution() {
         synchronized(mPaused) {
+            if (mInvalidated.get()) {
+                return
+            }
             if (!mPaused.get() && !mCallbackPosted.getAndSet(true)) {
                 mReactChoreographer.postFrameCallback(
                     ReactChoreographer.CallbackType.NATIVE_ANIMATED_MODULE,
@@ -73,6 +91,15 @@ class AnimationFrameQueue(
         }
     }
 
+    private fun removePostedFrameCallback() {
+        if (mCallbackPosted.getAndSet(false)) {
+            mReactChoreographer.removeFrameCallback(
+                ReactChoreographer.CallbackType.NATIVE_ANIMATED_MODULE,
+                mChoreographerCallback,
+            )
+        }
+    }
+
     private fun executeQueue(frameTimeNanos: Long) {
         val currentFrameTimeMs = calculateTimestamp(frameTimeNanos)
         if (currentFrameTimeMs <= lastFrameTimeMs) {
@@ -83,12 +110,20 @@ class AnimationFrameQueue(
             return
         }
 
-        val frameCallbacks = pullCallbacks()
-        mCallbackPosted.set(false)
+        synchronized(mDispatchLock) {
+            val frameCallbacks = pullCallbacks()
+            mCallbackPosted.set(false)
+            if (mInvalidated.get()) {
+                return
+            }
 
-        lastFrameTimeMs = currentFrameTimeMs
-        for (callback in frameCallbacks) {
-            callback.onAnimationFrame(currentFrameTimeMs)
+            lastFrameTimeMs = currentFrameTimeMs
+            for (callback in frameCallbacks) {
+                if (mInvalidated.get()) {
+                    break
+                }
+                callback.onAnimationFrame(currentFrameTimeMs)
+            }
         }
     }
 

package/apple/worklets/apple/AnimationFrameQueue.mm

@@ -5,11 +5,17 @@
 #import <worklets/apple/SlowAnimations.h>
 #import <chrono>
 
+#import <Foundation/Foundation.h>
+#if !TARGET_OS_OSX
+#import <UIKit/UIKit.h>
+#endif // !TARGET_OS_OSX
+
 #if TARGET_OS_OSX
 #import <QuartzCore/CADisplayLink.h>
 #endif // TARGET_OS_OSX
 
 #import <React/RCTAssert.h>
+#import <React/RCTUtils.h>
 
 constexpr auto TIME_SAMPLES_AMOUNT = 4;
 
@@ -36,7 +42,9 @@ typedef void (^AnimationFrameCallback)(WorkletsDisplayLink *displayLink);
 
 - (instancetype)init
 {
-  AssertJavaScriptQueue();
+  react_native_assert(
+      (IsJavaScriptQueue() || RCTIsMainQueue()) &&
+      "AnimationFrameQueue must be created on the JavaScript queue or the main queue");
   if constexpr (worklets::StaticFeatureFlags::getFlag("IOS_DYNAMIC_FRAMERATE_ENABLED")) {
     bool supportsProMotion = false;
 #if !TARGET_OS_OSX

package/apple/worklets/apple/AssertJavaScriptQueue.h

@@ -1,14 +1,15 @@
+#import <Foundation/Foundation.h>
 #import <react/debug/react_native_assert.h>
 
 // Copied from RCTJSThreadManager.mm
 static NSString *const RCTJSThreadName = @"com.facebook.react.runtime.JavaScript";
 
-static BOOL IsJavaScriptQueue()
+static inline BOOL IsJavaScriptQueue()
 {
   return [NSThread.currentThread.name isEqualToString:RCTJSThreadName];
 }
 
-static void AssertJavaScriptQueue()
+static inline void AssertJavaScriptQueue()
 {
   react_native_assert(IsJavaScriptQueue() && "This function must be called on the JavaScript queue");
 }

package/apple/worklets/apple/AssertTurboModuleManagerQueue.h

@@ -1,3 +1,7 @@
+#import <dispatch/dispatch.h>
+
+#import <cstring>
+
 #import <react/debug/react_native_assert.h>
 
 constexpr auto turboModuleManagerQueueLabel = "com.meta.react.turbomodulemanager.queue";

package/apple/worklets/apple/IOSUIScheduler.mm

@@ -1,3 +1,6 @@
+#import <Foundation/Foundation.h>
+#import <dispatch/dispatch.h>
+
 #import <worklets/apple/IOSUIScheduler.h>
 
 namespace worklets {