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

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

@@ -0,0 +1,40 @@
+/**
+* Based on OkHttpCallUtil.kt from React Native
+*/
+
+@file:Suppress("DEPRECATION_ERROR") // Conflicting okhttp versions
+
+package com.swmansion.worklets
+
+import okhttp3.OkHttpClient
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+/**
+ * Helper class that provides the necessary methods for canceling queued and running OkHttp calls
+ */
+internal object WorkletsOkHttpCallUtil {
+    @JvmStatic
+    fun cancelTag(
+        client: OkHttpClient,
+        tag: Any,
+    ) {
+        val dispatcher = client.dispatcher()
+        for (call in dispatcher.queuedCalls()) {
+            if (tag == call.request().tag()) {
+                call.cancel()
+                return
+            }
+        }
+        for (call in dispatcher.runningCalls()) {
+            if (tag == call.request().tag()) {
+                call.cancel()
+                return
+            }
+        }
+    }
+}

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

@@ -0,0 +1,13 @@
+/**
+* Based on ProgressListener.kt from React Native
+*/
+
+package com.swmansion.worklets
+
+public fun interface WorkletsProgressListener {
+    public fun onProgress(
+        bytesWritten: Long,
+        contentLength: Long,
+        done: Boolean,
+    )
+}

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

@@ -0,0 +1,98 @@
+/**
+* Based on ProgressRequestBody.kt from React Native
+*/
+
+@file:Suppress("DEPRECATION_ERROR") // Conflicting okio versions
+
+package com.swmansion.worklets
+
+import okhttp3.MediaType
+import okhttp3.RequestBody
+import okio.BufferedSink
+import okio.Okio
+import okio.Sink
+import java.io.FilterOutputStream
+import java.io.IOException
+
+internal class WorkletsProgressRequestBody(
+    private val requestBody: RequestBody,
+    private val progressListener: WorkletsProgressListener,
+) : RequestBody() {
+    private var contentLength = 0L
+
+    companion object {
+        private const val MAX_BODY_PREVIEW_SIZE = 1024 * 1024 // 1MB
+    }
+
+    override fun contentType(): MediaType? = requestBody.contentType()
+
+    @Throws(IOException::class)
+    override fun contentLength(): Long {
+        if (contentLength == 0L) {
+            contentLength = requestBody.contentLength()
+        }
+        return contentLength
+    }
+
+    @Throws(IOException::class)
+    override fun writeTo(sink: BufferedSink) {
+        // In 99% of cases, this method is called strictly once.
+        // The only case when it is called more than once is internal okhttp upload re-try.
+        // We need to re-create CountingOutputStream in this case as progress should be re-evaluated.
+        val sinkWrapper = Okio.buffer(outputStreamSink(sink))
+
+        // contentLength changes for input streams, since we're using inputStream.available(),
+        // so get the length before writing to the sink
+        contentLength()
+
+        requestBody.writeTo(sinkWrapper)
+        sinkWrapper.flush()
+    }
+
+    private fun outputStreamSink(sink: BufferedSink): Sink =
+        Okio.sink(
+            object : FilterOutputStream(sink.outputStream()) {
+                private var count: Long = 0
+
+                @Throws(IOException::class)
+                override fun write(
+                    data: ByteArray,
+                    offset: Int,
+                    byteCount: Int,
+                ) {
+                    super.write(data, offset, byteCount)
+                    count += byteCount.toLong()
+                    sendProgressUpdate()
+                }
+
+                @Throws(IOException::class)
+                override fun write(data: Int) {
+                    super.write(data)
+                    count++
+                    sendProgressUpdate()
+                }
+
+                @Throws(IOException::class)
+                fun sendProgressUpdate() {
+                    val bytesWritten = count
+                    val contentLength = contentLength()
+                    progressListener.onProgress(bytesWritten, contentLength, bytesWritten == contentLength)
+                }
+            },
+        )
+
+    fun getBodyPreview(): String =
+        try {
+            val buffer = okio.Buffer()
+            requestBody.writeTo(buffer)
+            val size = buffer.size()
+            if (size <= MAX_BODY_PREVIEW_SIZE) {
+                buffer.readUtf8()
+            } else {
+                buffer.readUtf8(MAX_BODY_PREVIEW_SIZE.toLong()) +
+                    "\n... [truncated, showing $MAX_BODY_PREVIEW_SIZE of $size bytes]"
+            }
+        } catch (e: Exception) {
+            ""
+        }
+}

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

@@ -0,0 +1,60 @@
+/**
+* Based on ProgressResponseBody.kt from React Native
+*/
+
+@file:Suppress("DEPRECATION_ERROR") // Conflicting okhttp versions
+
+package com.swmansion.worklets
+
+import okhttp3.MediaType
+import okhttp3.ResponseBody
+import okio.Buffer
+import okio.BufferedSource
+import okio.ForwardingSource
+import okio.Okio
+import okio.Source
+import java.io.IOException
+
+public class WorkletsProgressResponseBody
+    public constructor(
+        private val responseBody: ResponseBody,
+        private val progressListener: WorkletsProgressListener,
+    ) : ResponseBody() {
+        private lateinit var bufferedSource: BufferedSource
+        private var totalBytesRead = 0L
+
+        public override fun contentType(): MediaType? = responseBody.contentType()
+
+        override fun contentLength(): Long = responseBody.contentLength()
+
+        public fun totalBytesRead(): Long = totalBytesRead
+
+        public override fun source(): BufferedSource {
+            if (!::bufferedSource.isInitialized) {
+                bufferedSource = Okio.buffer(source(responseBody.source()))
+            }
+            return bufferedSource
+        }
+
+        private fun source(source: Source): Source {
+            return object : ForwardingSource(source) {
+                @Throws(IOException::class)
+                override fun read(
+                    sink: Buffer,
+                    byteCount: Long,
+                ): Long {
+                    // read() returns the number of bytes read, or -1 if this source is exhausted.
+                    return super.read(sink, byteCount).also { bytesRead ->
+                        if (bytesRead != -1L) {
+                            totalBytesRead += bytesRead
+                        }
+                        progressListener.onProgress(
+                            totalBytesRead,
+                            responseBody.contentLength(),
+                            bytesRead == -1L,
+                        )
+                    }
+                }
+            }
+        }
+    }

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

@@ -0,0 +1,87 @@
+/**
+* Based on ProgressiveStringDecoder.kt from React Native
+*/
+
+package com.swmansion.worklets
+
+import com.facebook.common.logging.FLog
+import com.facebook.react.common.ReactConstants
+import java.nio.ByteBuffer
+import java.nio.CharBuffer
+import java.nio.charset.Charset
+import java.nio.charset.CharsetDecoder
+
+/**
+ * Class to decode encoded strings from byte array chunks. As in different encodings single
+ * character could take up to 4 characters byte array passed to decode could have parts of the
+ * characters which can't be correctly decoded.
+ *
+ * This class is designed in assumption that original byte stream is correctly formatted string in
+ * given encoding. Otherwise some parts of the data won't be decoded.
+ */
+internal class WorkletsProgressiveStringDecoder(
+    charset: Charset,
+) {
+    private val decoder: CharsetDecoder = charset.newDecoder()
+    private var remainder: ByteArray? = null
+
+    /**
+     * Parses data to String If there is a partial multi-byte symbol on the edge of the String it get
+     * saved to the reminder and added to the string on the decodeNext call.
+     *
+     * @param data The byte array containing the encoded string data.
+     * @param initialLength The number of valid bytes in the provided data array that should be
+     *   decoded.
+     * @return The decoded string. If decoding fails, an empty string is returned.
+     */
+    fun decodeNext(
+        data: ByteArray,
+        initialLength: Int,
+    ): String {
+        var length = initialLength
+        var decodeData: ByteArray = data
+
+        remainder?.let { r ->
+            decodeData = ByteArray(r.size + length)
+            System.arraycopy(r, 0, decodeData, 0, r.size)
+            System.arraycopy(data, 0, decodeData, r.size, length)
+            length += r.size
+        }
+
+        var decodeBuffer = ByteBuffer.wrap(decodeData, 0, length)
+        var result: CharBuffer? = null
+        var decoded = false
+        var remainderLength = 0
+
+        while (!decoded && (remainderLength < 4)) {
+            try {
+                result = decoder.decode(decodeBuffer)
+                decoded = true
+            } catch (e: CharacterCodingException) {
+                remainderLength++
+                decodeBuffer = ByteBuffer.wrap(decodeData, 0, length - remainderLength)
+            }
+        }
+
+        val hasRemainder = decoded && remainderLength > 0
+        remainder =
+            if (hasRemainder) {
+                ByteArray(remainderLength).apply {
+                    System.arraycopy(decodeData, length - remainderLength, this, 0, remainderLength)
+                }
+            } else {
+                null
+            }
+
+        if (!decoded) {
+            FLog.w(ReactConstants.TAG, "failed to decode string from byte array")
+            return EMPTY_STRING
+        } else {
+            return result?.let { String(it.array(), 0, it.length) } ?: EMPTY_STRING
+        }
+    }
+
+    companion object {
+        private const val EMPTY_STRING = ""
+    }
+}

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

@@ -0,0 +1,181 @@
+/**
+* Based on RequestBodyUtil.kt from React Native
+*/
+
+@file:Suppress("DEPRECATION_ERROR") // Conflicting okio versions
+
+package com.swmansion.worklets
+
+import android.content.Context
+import android.net.Uri
+import android.util.Base64
+import com.facebook.common.logging.FLog
+import com.facebook.react.common.ReactConstants
+import okhttp3.MediaType
+import okhttp3.RequestBody
+import okio.BufferedSink
+import okio.ByteString
+import okio.Okio
+import okio.Source
+import java.io.ByteArrayInputStream
+import java.io.ByteArrayOutputStream
+import java.io.File
+import java.io.FileInputStream
+import java.io.FileOutputStream
+import java.io.IOException
+import java.io.InputStream
+import java.io.OutputStream
+import java.net.URL
+import java.nio.channels.Channels
+import java.util.zip.GZIPOutputStream
+
+/**
+ * Helper class that provides the necessary methods for creating the [RequestBody] from a file
+ * specification, such as a contentUri.
+ */
+internal object WorkletsRequestBodyUtil {
+    private const val CONTENT_ENCODING_GZIP = "gzip"
+    private const val NAME = "RequestBodyUtil"
+    private const val TEMP_FILE_SUFFIX = "temp"
+
+    /** Returns whether encode type indicates the body needs to be gzip-ed. */
+    @JvmStatic
+    fun isGzipEncoding(encodingType: String?): Boolean = CONTENT_ENCODING_GZIP.equals(encodingType, ignoreCase = true)
+
+    /**
+     * Returns the input stream for a file given by its contentUri. Returns null if the file has not
+     * been found or if an error as occurred.
+     */
+    @JvmStatic
+    fun getFileInputStream(
+        context: Context,
+        fileContentUriStr: String,
+    ): InputStream? {
+        try {
+            val fileContentUri = Uri.parse(fileContentUriStr)
+
+            if (fileContentUri.scheme?.startsWith("http") == true) {
+                return getDownloadFileInputStream(context, fileContentUri)
+            }
+
+            if (fileContentUriStr.startsWith("data:")) {
+                val decodedDataUrString =
+                    Base64.decode(
+                        fileContentUriStr
+                            .split(",".toRegex())
+                            .dropLastWhile { it.isEmpty() }
+                            .toTypedArray()[1],
+                        Base64.DEFAULT,
+                    )
+                return ByteArrayInputStream(decodedDataUrString)
+            }
+
+            return context.contentResolver.openInputStream(fileContentUri)
+        } catch (e: Exception) {
+            FLog.e(ReactConstants.TAG, "Could not retrieve file for contentUri $fileContentUriStr", e)
+            return null
+        }
+    }
+
+    /**
+     * Download and cache a file locally. This should be used when document picker returns a URI that
+     * points to a file on the network. Returns input stream for the downloaded file.
+     */
+    @Throws(IOException::class)
+    private fun getDownloadFileInputStream(
+        context: Context,
+        uri: Uri,
+    ): InputStream {
+        val outputDir = context.applicationContext.cacheDir
+        val file = File.createTempFile(NAME, TEMP_FILE_SUFFIX, outputDir)
+        file.deleteOnExit()
+
+        val url = URL(uri.toString())
+        FileOutputStream(file).use { stream ->
+            url.openStream().use { `is` ->
+                Channels.newChannel(`is`).use { channel ->
+                    stream.channel.transferFrom(channel, 0, Long.MAX_VALUE)
+                    return FileInputStream(file)
+                }
+            }
+        }
+    }
+
+    /** Creates a [RequestBody] from a mediaType and gzip-ed body string. */
+    @JvmStatic
+    fun createGzip(
+        mediaType: MediaType?,
+        body: String,
+    ): RequestBody? {
+        val gzipByteArrayOutputStream = ByteArrayOutputStream()
+        try {
+            val gzipOutputStream: OutputStream = GZIPOutputStream(gzipByteArrayOutputStream)
+            gzipOutputStream.write(body.toByteArray())
+            gzipOutputStream.close()
+        } catch (e: IOException) {
+            return null
+        }
+        @Suppress("DEPRECATION")
+        return RequestBody.create(mediaType, gzipByteArrayOutputStream.toByteArray())
+    }
+
+    /**
+     * Reference:
+     * https://github.com/square/okhttp/blob/8c8c3dbcfa91e28de2e13975ec414e07f153fde4/okhttp/src/commonMain/kotlin/okhttp3/internal/-UtilCommon.kt#L281-L288
+     * Checked exceptions will be ignored
+     */
+    private fun closeQuietly(source: Source) {
+        try {
+            source.close()
+        } catch (e: RuntimeException) {
+            throw e
+        } catch (e: Exception) {
+            // no-op
+        }
+    }
+
+    /** Creates a [RequestBody] from a mediaType and inputStream given. */
+    @JvmStatic
+    fun create(
+        mediaType: MediaType?,
+        inputStream: InputStream,
+    ): RequestBody =
+        object : RequestBody() {
+            override fun contentType(): MediaType? = mediaType
+
+            override fun contentLength(): Long =
+                try {
+                    inputStream.available().toLong()
+                } catch (e: IOException) {
+                    0
+                }
+
+            @Throws(IOException::class)
+            override fun writeTo(sink: BufferedSink) {
+                var source: Source? = null
+                try {
+                    source = Okio.source(inputStream)
+                    sink.writeAll(source)
+                } finally {
+                    source?.let { closeQuietly(it) }
+                }
+            }
+        }
+
+    /** Creates a [ProgressRequestBody] that can be used for showing uploading progress. */
+    @JvmStatic
+    fun createProgressRequest(
+        requestBody: RequestBody,
+        listener: WorkletsProgressListener,
+    ): WorkletsProgressRequestBody = WorkletsProgressRequestBody(requestBody, listener)
+
+    /** Creates an empty [RequestBody] if required by the http method spec, otherwise use null. */
+    @JvmStatic
+    fun getEmptyBody(method: String): RequestBody? =
+        if (method == "POST" || method == "PUT" || method == "PATCH") {
+            @Suppress("DEPRECATION")
+            RequestBody.create(null, ByteString.EMPTY)
+        } else {
+            null
+        }
+}

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

@@ -0,0 +1,143 @@
+package com.swmansion.worklets
+
+import com.facebook.jni.HybridData
+import com.facebook.proguard.annotations.DoNotStrip
+import com.facebook.react.bridge.LifecycleEventListener
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.bridge.ReactMethod
+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 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 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/apple/worklets/apple/AnimationFrameQueue.h

@@ -0,0 +1,15 @@
+#if __cplusplus
+
+#import <worklets/apple/WorkletsDisplayLink.h>
+#import <functional>
+
+@interface AnimationFrameQueue : NSObject
+
+- (void)requestAnimationFrame:(std::function<void(double)>)callback;
+- (void)executeQueue:(WorkletsDisplayLink *)displayLink;
+
+- (void)invalidate;
+
+@end
+
+#endif // __cplusplus