react-native-worklets 0.7.2 → 0.8.0-bundle-mode-preview-1

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

@@ -0,0 +1,37 @@
+/**
+* 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,9 @@
+/**
+* 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 java.io.FilterOutputStream
+import java.io.IOException
+import okhttp3.MediaType
+import okhttp3.RequestBody
+import okio.BufferedSink
+import okio.Okio
+import okio.Sink
+
+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? {
+    return 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 {
+    return 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 {
+    return 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,57 @@
+/**
+* Based on ProgressResponseBody.kt from React Native 
+*/
+
+@file:Suppress("DEPRECATION_ERROR") // Conflicting okhttp versions
+
+package com.swmansion.worklets
+
+import java.io.IOException
+import okhttp3.MediaType
+import okhttp3.ResponseBody
+import okio.Buffer
+import okio.BufferedSource
+import okio.ForwardingSource
+import okio.Okio
+import okio.Source
+
+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,82 @@
+/**
+* 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,177 @@
+/**
+* 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 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
+import okhttp3.MediaType
+import okhttp3.RequestBody
+import okio.BufferedSink
+import okio.ByteString
+import okio.Okio
+import okio.Source
+
+/**
+ * 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 {
+    return 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 {
+    return object : RequestBody() {
+      override fun contentType(): MediaType? {
+        return mediaType
+      }
+
+      override fun contentLength(): Long {
+        return 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 {
+    return WorkletsProgressRequestBody(requestBody, listener)
+  }
+
+  /** Creates an empty [RequestBody] if required by the http method spec, otherwise use null. */
+  @JvmStatic
+  fun getEmptyBody(method: String): RequestBody? {
+    return if (method == "POST" || method == "PUT" || method == "PATCH") {
+      @Suppress("DEPRECATION") RequestBody.create(null, ByteString.EMPTY)
+    } else {
+      null
+    }
+  }
+}

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

@@ -8,7 +8,6 @@ import com.facebook.react.bridge.ReactApplicationContext;
 import com.facebook.react.bridge.ReactMethod;
 import com.facebook.react.bridge.queue.MessageQueueThread;
 import com.facebook.react.common.annotations.FrameworkAPI;
-import com.facebook.react.fabric.BundleWrapper;
 import com.facebook.react.module.annotations.ReactModule;
 import com.facebook.react.turbomodule.core.CallInvokerHolderImpl;
 import com.facebook.soloader.SoLoader;
@@ -37,8 +36,6 @@ public class WorkletsModule extends NativeWorkletsModuleSpec implements Lifecycl
   private final AndroidUIScheduler mAndroidUIScheduler;
   private final AnimationFrameQueue mAnimationFrameQueue;
   private boolean mSlowAnimationsEnabled;
-  private BundleWrapper mBundleWrapper = null;
-  private String mSourceURL = null;
 
   /**
    * Invalidating concurrently could be fatal. It shouldn't happen in a normal flow, but it doesn't
@@ -52,15 +49,12 @@ public class WorkletsModule extends NativeWorkletsModuleSpec implements Lifecycl
       MessageQueueThread messageQueueThread,
       CallInvokerHolderImpl jsCallInvokerHolder,
       AndroidUIScheduler androidUIScheduler,
-      BundleWrapper bundleWrapper,
-      String sourceURL);
+      ScriptBufferWrapper scriptBufferWrapper);
 
   public WorkletsModule(ReactApplicationContext reactContext) {
     super(reactContext);
 
-    if (!BuildConfig.BUNDLE_MODE) {
-      reactContext.assertOnJSQueueThread();
-    }
+    reactContext.assertOnJSQueueThread();
 
     mAndroidUIScheduler = new AndroidUIScheduler(reactContext);
     mAnimationFrameQueue = new AnimationFrameQueue(reactContext);
@@ -71,15 +65,17 @@ public class WorkletsModule extends NativeWorkletsModuleSpec implements Lifecycl
   public boolean installTurboModule() {
     var context = getReactApplicationContext();
 
-    if (!BuildConfig.BUNDLE_MODE) {
-      context.assertOnNativeModulesQueueThread();
-    }
+    context.assertOnJSQueueThread();
 
     var jsContext = Objects.requireNonNull(context.getJavaScriptContextHolder()).get();
     var jsCallInvokerHolder = JSCallInvokerResolver.getJSCallInvokerHolder(context);
 
-    mSourceURL = context.getSourceURL();
-    mBundleWrapper = context.getBundle();
+    var sourceURL = context.getSourceURL();
+
+    ScriptBufferWrapper scriptBufferWrapper = null;
+    if (BuildConfig.BUNDLE_MODE_ENABLED) {
+      scriptBufferWrapper = new ScriptBufferWrapper(sourceURL, context.getAssets());
+    }
 
     mHybridData =
         initHybrid(
@@ -87,8 +83,7 @@ public class WorkletsModule extends NativeWorkletsModuleSpec implements Lifecycl
             mMessageQueueThread,
             jsCallInvokerHolder,
             mAndroidUIScheduler,
-            mBundleWrapper,
-            mSourceURL);
+            scriptBufferWrapper);
     return true;
   }
 

package/apple/worklets/apple/Networking/WorkletsNetworking.h

@@ -0,0 +1,22 @@
+#if defined(WORKLETS_BUNDLE_MODE_ENABLED) && defined(WORKLETS_FETCH_PREVIEW_ENABLED)
+/*
+ * This file is based on RCTNetworking.h from React Native.
+ */
+
+#import <React/RCTNetworking.h>
+
+using namespace facebook;
+
+@interface WorkletsNetworking : NSObject
+- (instancetype)init:(RCTNetworking *)rctNetworking;
+
+- (void)jsiSendRequest:(jsi::Runtime &)rt
+                jquery:(const jsi::Value &)jquery
+        responseSender:(jsi::Function &&)responseSender;
+
+- (void)jsiAbortRequest:(double)requestID;
+
+- (void)jsiClearCookies:(jsi::Runtime &)rt responseSender:(jsi::Function &&)responseSender;
+
+@end
+#endif // defined(WORKLETS_BUNDLE_MODE_ENABLED) && defined(WORKLETS_FETCH_PREVIEW_ENABLED)