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

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

@@ -0,0 +1,187 @@
+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.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 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,
+        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 = context.jsCallInvokerHolder as CallInvokerHolderImpl
+
+        val sourceURL = context.sourceURL
+
+        val scriptBufferWrapper: ScriptBufferWrapper? =
+            if (bundleModeEnabled) {
+                ScriptBufferWrapper(sourceURL!!, context.assets)
+            } else {
+                null
+            }
+
+        mHybridData =
+            initHybrid(
+                bundleModeEnabled,
+                jsContext,
+                jsCallInvokerHolder,
+                mAndroidUIScheduler,
+                scriptBufferWrapper,
+            )
+        return true
+    }
+
+    @OptIn(FrameworkAPI::class)
+    @ReactMethod(isBlockingSynchronousMethod = true)
+    override fun start(): Boolean {
+        reactApplicationContext.assertOnJSQueueThread()
+        startCpp()
+        return true
+    }
+
+    @DoNotStrip
+    fun abortRequest(
+        runtimeId: Int,
+        requestIdAsDouble: Double,
+    ) {
+        mWorkletsNetworking.jsiAbortRequest(runtimeId, requestIdAsDouble)
+    }
+
+    @DoNotStrip
+    fun clearCookies(callback: Callback) {
+        mWorkletsNetworking.jsiClearCookies(callback)
+    }
+
+    @DoNotStrip
+    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,
+        )
+    }
+
+    @DoNotStrip
+    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)
+    }
+
+    @OptIn(FrameworkAPI::class)
+    @ReactMethod(isBlockingSynchronousMethod = true)
+    override fun toggleSlowAnimationsOnUIRuntime(): Boolean {
+        toggleSlowAnimations()
+        return mSlowAnimationsEnabled
+    }
+
+    override fun invalidate() {
+        if (mInvalidated.getAndSet(true)) {
+            return
+        }
+        if (mHybridData != null && mHybridData!!.isValid) {
+            invalidateCpp()
+        }
+        mAndroidUIScheduler.deactivate()
+    }
+
+    private external fun invalidateCpp()
+
+    private external fun startCpp()
+
+    override fun onHostResume() {
+        mAnimationFrameQueue.resume()
+    }
+
+    override fun onHostPause() {
+        mAnimationFrameQueue.pause()
+    }
+
+    override fun onHostDestroy() {}
+}

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

@@ -0,0 +1,272 @@
+/**
+* Based on NetworkEventUtil.kt from React Native
+*/
+
+@file:Suppress("DEPRECATION_ERROR") // Conflicting okhttp versions
+
+package com.swmansion.worklets
+
+import android.os.Bundle
+import android.util.Base64
+import com.facebook.react.bridge.Arguments
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.bridge.WritableMap
+import com.facebook.react.bridge.buildReadableArray
+import com.facebook.react.internal.featureflags.ReactNativeFeatureFlags
+import okhttp3.Headers
+import okhttp3.Protocol
+import okhttp3.Request
+import okhttp3.Response
+import java.net.SocketTimeoutException
+
+/**
+ * Utility class for reporting network lifecycle events to JavaScript and InspectorNetworkReporter.
+ */
+internal object WorkletsNetworkEventUtil {
+    @JvmStatic
+    fun onCreateRequest(
+        devToolsRequestId: String,
+        request: Request,
+    ) {
+        if (ReactNativeFeatureFlags.enableNetworkEventReporting()) {
+            val headersMap = okHttpHeadersToMap(request.headers())
+//      InspectorNetworkReporter.reportRequestStart(
+//          devToolsRequestId,
+//          request.url().toString(),
+//          request.method(),
+//          headersMap,
+//          (request.body() as? ProgressRequestBody)?.getBodyPreview()
+//              ?: request.body()?.toString().orEmpty(),
+//          request.body()?.contentLength() ?: 0,
+//      )
+//      InspectorNetworkReporter.reportConnectionTiming(devToolsRequestId, headersMap)
+        }
+    }
+
+    @JvmStatic
+    fun onDataSend(
+        runtimeWrapper: WorkletRuntimeWrapper,
+        requestId: Int,
+        progress: Long,
+        total: Long,
+    ) {
+        runtimeWrapper.emitDeviceEvent(
+            "didSendNetworkData",
+            buildReadableArray {
+                add(requestId)
+                add(progress.toInt())
+                add(total.toInt())
+            },
+        )
+    }
+
+    @JvmStatic
+    fun onIncrementalDataReceived(
+        runtimeWrapper: WorkletRuntimeWrapper,
+        requestId: Int,
+        devToolsRequestId: String,
+        data: String?,
+        progress: Long,
+        total: Long,
+    ) {
+//    if (ReactNativeFeatureFlags.enableNetworkEventReporting() && data != null) {
+//      InspectorNetworkReporter.reportDataReceived(devToolsRequestId, data)
+//      InspectorNetworkReporter.maybeStoreResponseBodyIncremental(devToolsRequestId, data)
+//    }
+        runtimeWrapper.emitDeviceEvent(
+            "didReceiveNetworkIncrementalData",
+            buildReadableArray {
+                add(requestId)
+                add(data)
+                add(progress.toInt())
+                add(total.toInt())
+            },
+        )
+    }
+
+    @JvmStatic
+    fun onDataReceivedProgress(
+        runtimeWrapper: WorkletRuntimeWrapper,
+        requestId: Int,
+        progress: Long,
+        total: Long,
+    ) {
+        runtimeWrapper.emitDeviceEvent(
+            "didReceiveNetworkDataProgress",
+            buildReadableArray {
+                add(requestId)
+                add(progress.toInt())
+                add(total.toInt())
+            },
+        )
+    }
+
+    @JvmStatic
+    fun onDataReceived(
+        runtimeWrapper: WorkletRuntimeWrapper,
+        requestId: Int,
+        devToolsRequestId: String,
+        data: String?,
+        responseType: String,
+    ) {
+//    if (ReactNativeFeatureFlags.enableNetworkEventReporting()) {
+//      InspectorNetworkReporter.maybeStoreResponseBody(
+//          devToolsRequestId,
+//          data.orEmpty(),
+//          responseType == "base64",
+//      )
+//    }
+        runtimeWrapper.emitDeviceEvent(
+            "didReceiveNetworkData",
+            buildReadableArray {
+                add(requestId)
+                add(data)
+            },
+        )
+    }
+
+    @JvmStatic
+    fun onDataReceived(
+        runtimeWrapper: WorkletRuntimeWrapper,
+        requestId: Int,
+        devToolsRequestId: String,
+        data: WritableMap,
+        rawData: ByteArray,
+    ) {
+//    if (ReactNativeFeatureFlags.enableNetworkEventReporting()) {
+//      InspectorNetworkReporter.maybeStoreResponseBody(
+//          devToolsRequestId,
+//          Base64.encodeToString(rawData, Base64.NO_WRAP),
+//          true,
+//      )
+//    }
+        runtimeWrapper.emitDeviceEvent(
+            "didReceiveNetworkData",
+            Arguments.createArray().apply {
+                pushInt(requestId)
+                pushMap(data)
+            },
+        )
+    }
+
+    @JvmStatic
+    fun onRequestError(
+        runtimeWrapper: WorkletRuntimeWrapper,
+        requestId: Int,
+        devToolsRequestId: String,
+        error: String?,
+        e: Throwable?,
+    ) {
+        runtimeWrapper.emitDeviceEvent(
+            "didCompleteNetworkResponse",
+            buildReadableArray {
+                add(requestId)
+                add(error)
+                if (e?.javaClass == SocketTimeoutException::class.java) {
+                    add(true) // last argument is a time out boolean
+                }
+            },
+        )
+    }
+
+    @JvmStatic
+    fun onRequestSuccess(
+        runtimeWrapper: WorkletRuntimeWrapper,
+        requestId: Int,
+        devToolsRequestId: String,
+        encodedDataLength: Long,
+    ) {
+        runtimeWrapper.emitDeviceEvent(
+            "didCompleteNetworkResponse",
+            buildReadableArray {
+                add(requestId)
+                addNull()
+            },
+        )
+    }
+
+    @JvmStatic
+    fun onResponseReceived(
+        runtimeWrapper: WorkletRuntimeWrapper,
+        requestId: Int,
+        devToolsRequestId: String,
+        requestUrl: String?,
+        response: Response,
+    ) {
+        val headersMap = okHttpHeadersToMap(response.headers())
+        val headersBundle = Bundle()
+        for ((headerName, headerValue) in headersMap) {
+            headersBundle.putString(headerName, headerValue)
+        }
+
+//    if (ReactNativeFeatureFlags.enableNetworkEventReporting()) {
+//      InspectorNetworkReporter.reportResponseStart(
+//          devToolsRequestId,
+//          requestUrl.orEmpty(),
+//          response.code(),
+//          headersMap,
+//          response.body()?.contentLength() ?: 0,
+//      )
+//    }
+        runtimeWrapper.emitDeviceEvent(
+            "didReceiveNetworkResponse",
+            Arguments.createArray().apply {
+                pushInt(requestId)
+                pushInt(response.code())
+                pushMap(Arguments.fromBundle(headersBundle))
+                pushString(requestUrl)
+            },
+        )
+    }
+
+    @Deprecated("Compatibility overload")
+    @JvmStatic
+    fun onResponseReceived(
+        runtimeWrapper: WorkletRuntimeWrapper,
+        requestId: Int,
+        devToolsRequestId: String,
+        statusCode: Int,
+        headers: WritableMap?,
+        url: String?,
+    ) {
+        val headersBuilder = Headers.Builder()
+        headers?.let { map ->
+            val iterator = map.keySetIterator()
+            while (iterator.hasNextKey()) {
+                val key = iterator.nextKey()
+                val value = map.getString(key)
+                if (value != null) {
+                    headersBuilder.add(key, value)
+                }
+            }
+        }
+        onResponseReceived(
+            runtimeWrapper,
+            requestId,
+            devToolsRequestId,
+            url,
+            Response
+                .Builder()
+                .protocol(Protocol.HTTP_1_1)
+                .request(Request.Builder().url(url.orEmpty()).build())
+                .headers(headersBuilder.build())
+                .code(statusCode)
+                .message("")
+                .build(),
+        )
+    }
+
+    private fun okHttpHeadersToMap(headers: Headers): Map<String, String> {
+        val responseHeaders = mutableMapOf<String, String>()
+        for (i in 0 until headers.size()) {
+            val headerName = headers.name(i)
+            // multiple values for the same header
+            if (responseHeaders.containsKey(headerName)) {
+                responseHeaders[headerName] = "${responseHeaders[headerName]}, ${headers.value(i)}"
+            } else {
+                responseHeaders[headerName] = headers.value(i)
+            }
+        }
+        return responseHeaders
+    }
+}