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

package/android/src/main/cpp/worklets/android/WorkletsModule.cpp

@@ -1,12 +1,26 @@
 #include <worklets/NativeModules/JSIWorkletsModuleProxy.h>
+#include <worklets/Tools/ScriptBuffer.h>
 #include <worklets/Tools/WorkletsJSIUtils.h>
 #include <worklets/WorkletRuntime/RNRuntimeWorkletDecorator.h>
+#include <worklets/WorkletRuntime/RuntimeBindings.h>
 #include <worklets/android/AnimationFrameCallback.h>
 #include <worklets/android/WorkletsModule.h>
 
+#if defined(WORKLETS_BUNDLE_MODE_ENABLED) && defined(WORKLETS_FETCH_PREVIEW_ENABLED)
+#include <folly/json/dynamic.h>
+#include <jni.h>
+#include <jsi/JSIDynamic.h>
+#include <react/jni/JCallback.h>
+#include <react/jni/ReadableNativeArray.h>
+#include <react/jni/ReadableNativeMap.h>
+#include <worklets/WorkletRuntime/WorkletRuntime.h>
+#include <worklets/android/JWorkletRuntimeWrapper.h>
+#endif // defined(WORKLETS_BUNDLE_MODE_ENABLED) && defined(WORKLETS_FETCH_PREVIEW_ENABLED)
+
 #include <memory>
 #include <string>
 #include <utility>
+#include <vector>
 
 namespace worklets {
 
@@ -14,12 +28,13 @@ using namespace facebook;
 using namespace react;
 
 WorkletsModule::WorkletsModule(
-    jni::alias_ref<jhybridobject> jThis,
+    jni::alias_ref<jhybridobject> jThis, // NOLINT //(performance-unnecessary-value-param)
     jsi::Runtime *rnRuntime,
-    jni::alias_ref<JavaMessageQueueThread::javaobject> messageQueueThread,
+    jni::alias_ref<JavaMessageQueueThread::javaobject>
+        messageQueueThread, // NOLINT //(performance-unnecessary-value-param)
     const std::shared_ptr<facebook::react::CallInvoker> &jsCallInvoker,
     const std::shared_ptr<UIScheduler> &uiScheduler,
-    const std::shared_ptr<const JSBigStringBuffer> &script,
+    const std::shared_ptr<const ScriptBuffer> &script,
     const std::string &sourceURL)
     : javaPart_(jni::make_global(jThis)),
       rnRuntime_(rnRuntime),
@@ -29,7 +44,15 @@ WorkletsModule::WorkletsModule(
           jsCallInvoker,
           uiScheduler,
           getIsOnJSQueueThread(),
-          RuntimeBindings{.requestAnimationFrame = getRequestAnimationFrame()},
+          std::make_shared<RuntimeBindings>(RuntimeBindings{
+              .requestAnimationFrame = getRequestAnimationFrame()
+#if defined(WORKLETS_BUNDLE_MODE_ENABLED) && defined(WORKLETS_FETCH_PREVIEW_ENABLED)
+                  ,
+              .abortRequest = getAbortRequest(),
+              .clearCookies = getClearCookies(),
+              .sendRequest = getSendRequest()
+#endif // defined(WORKLETS_BUNDLE_MODE_ENABLED) && defined(WORKLETS_FETCH_PREVIEW_ENABLED)
+          }),
           script,
           sourceURL)) {
   auto jsiWorkletsModuleProxy = workletsModuleProxy_->createJSIWorkletsModuleProxy();
@@ -40,27 +63,26 @@ WorkletsModule::WorkletsModule(
 }
 
 jni::local_ref<WorkletsModule::jhybriddata> WorkletsModule::initHybrid(
-    jni::alias_ref<jhybridobject> jThis,
+    jni::alias_ref<jhybridobject> jThis, // NOLINT //(performance-unnecessary-value-param)
     jlong jsContext,
-    jni::alias_ref<JavaMessageQueueThread::javaobject> messageQueueThread,
+    jni::alias_ref<JavaMessageQueueThread::javaobject>
+        messageQueueThread, // NOLINT //(performance-unnecessary-value-param)
     jni::alias_ref<facebook::react::CallInvokerHolder::javaobject> jsCallInvokerHolder,
-    jni::alias_ref<worklets::AndroidUIScheduler::javaobject> androidUIScheduler
-#ifdef WORKLETS_BUNDLE_MODE
-    ,
-    jni::alias_ref<facebook::react::BundleWrapper::javaobject> bundleWrapper,
-    const std::string &sourceURL
-#endif // WORKLETS_BUNDLE_MODE
+    jni::alias_ref<worklets::AndroidUIScheduler::javaobject> androidUIScheduler,
+    jni::alias_ref<JScriptBufferWrapper::javaobject>
+        jScriptBufferWrapper // NOLINT //(performance-unnecessary-value-param)
 ) {
   auto jsCallInvoker = jsCallInvokerHolder->cthis()->getCallInvoker();
-  auto rnRuntime = reinterpret_cast<jsi::Runtime *>(jsContext);
+  auto rnRuntime = reinterpret_cast<jsi::Runtime *>(jsContext); // NOLINT //(performance-no-int-to-ptr)
   auto uiScheduler = androidUIScheduler->cthis()->getUIScheduler();
 
-  std::shared_ptr<const JSBigStringBuffer> script = nullptr;
-#ifdef WORKLETS_BUNDLE_MODE
-  script = bundleWrapper->cthis()->getBundle();
-#else
-  const auto sourceURL = std::string{};
-#endif // WORKLETS_BUNDLE_MODE
+  std::shared_ptr<const ScriptBuffer> script = nullptr;
+  std::string sourceURL;
+#ifdef WORKLETS_BUNDLE_MODE_ENABLED
+  auto cxxWrapper = jScriptBufferWrapper->cthis();
+  script = cxxWrapper->getScript();
+  sourceURL = cxxWrapper->getSourceUrl();
+#endif // WORKLETS_BUNDLE_MODE_ENABLED
 
   return makeCxxInstance(jThis, rnRuntime, messageQueueThread, jsCallInvoker, uiScheduler, script, sourceURL);
 }
@@ -73,6 +95,80 @@ RuntimeBindings::RequestAnimationFrame WorkletsModule::getRequestAnimationFrame(
   };
 }
 
+#if defined(WORKLETS_BUNDLE_MODE_ENABLED) && defined(WORKLETS_FETCH_PREVIEW_ENABLED)
+RuntimeBindings::AbortRequest WorkletsModule::getAbortRequest() {
+  return [javaPart = javaPart_](jsi::Runtime &rt, double requestId) -> void {
+    static const auto jAbortRequest = javaPart->getClass()->getMethod<void(int, double)>("abortRequest");
+    auto workletRuntime = WorkletRuntime::getWeakRuntimeFromJSIRuntime(rt).lock();
+    jAbortRequest(javaPart.get(), static_cast<int>(workletRuntime->getRuntimeId()), requestId);
+  };
+}
+
+RuntimeBindings::ClearCookies WorkletsModule::getClearCookies() {
+  return [javaPart = javaPart_](jsi::Runtime &rt, jsi::Function &&responseSender) {
+    static const auto jClearCookies = javaPart->getClass()->getMethod<void(JCallback::javaobject)>("clearCookies");
+    auto jsiFunction = std::make_shared<jsi::Function>(std::move(responseSender));
+    auto workletRuntime = WorkletRuntime::getWeakRuntimeFromJSIRuntime(rt);
+    auto callback = [jsiFunction, workletRuntime](folly::dynamic args) {
+      if (auto runtime = workletRuntime.lock()) {
+        runtime->schedule([jsiFunction, args = std::move(args)](jsi::Runtime &rt) {
+          std::vector<jsi::Value> jsArgs;
+          for (auto &arg : args) {
+            jsArgs.push_back(jsi::valueFromDynamic(rt, arg));
+          }
+          const jsi::Value *rawData = jsArgs.data();
+          size_t size = jsArgs.size();
+          jsiFunction->call(rt, rawData, size);
+        });
+      }
+    };
+    jClearCookies(javaPart.get(), JCxxCallbackImpl::newObjectCxxArgs(std::move(callback)).get());
+  };
+}
+
+RuntimeBindings::SendRequest WorkletsModule::getSendRequest() {
+  return [javaPart = javaPart_](
+             jsi::Runtime &rt,
+             jsi::String &method,
+             jsi::String &url,
+             double requestId,
+             jsi::Array &headers,
+             jsi::Object &data,
+             jsi::String &responseType,
+             bool incrementalUpdates,
+             double timeout,
+             bool withCredentials) {
+    static const auto jSendRequest = javaPart->getClass()
+                                         ->getMethod<void(
+                                             JWorkletRuntimeWrapper::javaobject,
+                                             std::string /* method */,
+                                             std::string /* url */,
+                                             double /* requestId */,
+                                             ReadableNativeArray::javaobject /* headers */,
+                                             ReadableNativeMap::javaobject /* data */,
+                                             std::string /* responseType */,
+                                             bool /* incrementalUpdates */,
+                                             double /* timeout */,
+                                             bool /* withCredentials */
+                                             )>("sendRequest");
+    auto workletRuntime = WorkletRuntime::getWeakRuntimeFromJSIRuntime(rt).lock();
+
+    jSendRequest(
+        javaPart.get(),
+        JWorkletRuntimeWrapper::makeJWorkletRuntimeWrapper(workletRuntime).get(),
+        method.utf8(rt),
+        url.utf8(rt),
+        requestId,
+        ReadableNativeArray::newObjectCxxArgs(jsi::dynamicFromValue(rt, jsi::Value(std::move(headers)))).get(),
+        ReadableNativeMap::newObjectCxxArgs(jsi::dynamicFromValue(rt, jsi::Value(std::move(data)))).get(),
+        responseType.utf8(rt),
+        incrementalUpdates,
+        timeout,
+        withCredentials);
+  };
+}
+#endif // defined(WORKLETS_BUNDLE_MODE_ENABLED) && defined(WORKLETS_FETCH_PREVIEW_ENABLED)
+
 std::function<bool()> WorkletsModule::getIsOnJSQueueThread() {
   return [javaPart = javaPart_]() -> bool {
     return javaPart->getClass()->getMethod<jboolean()>("isOnJSQueueThread").operator()(javaPart);

package/android/src/main/cpp/worklets/android/WorkletsModule.h

@@ -4,14 +4,12 @@
 #include <fbjni/fbjni.h>
 #include <jsi/jsi.h>
 #include <react/jni/JMessageQueueThread.h>
-#include <worklets/Tools/Defs.h>
-#ifdef WORKLETS_BUNDLE_MODE
-#include <react/fabric/BundleWrapper.h>
-#endif // WORKLETS_BUNDLE_MODE
-
 #include <worklets/NativeModules/WorkletsModuleProxy.h>
+#include <worklets/Tools/Defs.h>
+#include <worklets/Tools/ScriptBuffer.h>
 #include <worklets/WorkletRuntime/RuntimeBindings.h>
 #include <worklets/android/AndroidUIScheduler.h>
+#include <worklets/android/JScriptBufferWrapper.h>
 
 #include <memory>
 #include <string>
@@ -30,13 +28,8 @@ class WorkletsModule : public jni::HybridClass<WorkletsModule> {
       jlong jsContext,
       jni::alias_ref<JavaMessageQueueThread::javaobject> messageQueueThread,
       jni::alias_ref<facebook::react::CallInvokerHolder::javaobject> jsCallInvokerHolder,
-      jni::alias_ref<worklets::AndroidUIScheduler::javaobject> androidUIScheduler
-#ifdef WORKLETS_BUNDLE_MODE
-      ,
-      jni::alias_ref<facebook::react::BundleWrapper::javaobject> bundleWrapper,
-      const std::string &sourceURL
-#endif // WORKLETS_BUNDLE_MODE
-  );
+      jni::alias_ref<worklets::AndroidUIScheduler::javaobject> androidUIScheduler,
+      jni::alias_ref<JScriptBufferWrapper::javaobject> jScriptBufferWrapper);
 
   static void registerNatives();
 
@@ -51,7 +44,7 @@ class WorkletsModule : public jni::HybridClass<WorkletsModule> {
       jni::alias_ref<JavaMessageQueueThread::javaobject> messageQueueThread,
       const std::shared_ptr<facebook::react::CallInvoker> &jsCallInvoker,
       const std::shared_ptr<UIScheduler> &uiScheduler,
-      const std::shared_ptr<const JSBigStringBuffer> &bundle,
+      const std::shared_ptr<const ScriptBuffer> &script,
       const std::string &sourceURL);
 
   void invalidateCpp();
@@ -62,6 +55,11 @@ class WorkletsModule : public jni::HybridClass<WorkletsModule> {
   }
 
   RuntimeBindings::RequestAnimationFrame getRequestAnimationFrame();
+#if defined(WORKLETS_BUNDLE_MODE_ENABLED) && defined(WORKLETS_FETCH_PREVIEW_ENABLED)
+  RuntimeBindings::AbortRequest getAbortRequest();
+  RuntimeBindings::ClearCookies getClearCookies();
+  RuntimeBindings::SendRequest getSendRequest();
+#endif // defined(WORKLETS_BUNDLE_MODE_ENABLED) && defined(WORKLETS_FETCH_PREVIEW_ENABLED)
 
   std::function<bool()> getIsOnJSQueueThread();
 

package/android/src/main/cpp/worklets/android/WorkletsOnLoad.cpp

@@ -2,6 +2,8 @@
 
 #include <worklets/android/AndroidUIScheduler.h>
 #include <worklets/android/AnimationFrameCallback.h>
+#include <worklets/android/JScriptBufferWrapper.h>
+#include <worklets/android/JWorkletRuntimeWrapper.h>
 #include <worklets/android/WorkletsModule.h>
 
 JNIEXPORT jint JNICALL JNI_OnLoad(JavaVM *vm, void *) {
@@ -9,5 +11,9 @@ JNIEXPORT jint JNICALL JNI_OnLoad(JavaVM *vm, void *) {
     worklets::WorkletsModule::registerNatives();
     worklets::AndroidUIScheduler::registerNatives();
     worklets::AnimationFrameCallback::registerNatives();
+    worklets::JScriptBufferWrapper::registerNatives();
+#if defined(WORKLETS_BUNDLE_MODE_ENABLED) && defined(WORKLETS_FETCH_PREVIEW_ENABLED)
+    worklets::JWorkletRuntimeWrapper::registerNatives();
+#endif // defined(WORKLETS_BUNDLE_MODE_ENABLED) && defined(WORKLETS_FETCH_PREVIEW_ENABLED)
   });
 }

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

@@ -0,0 +1,88 @@
+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. */
+@SuppressWarnings("JavaJniMissingFunction")
+@SuppressLint("MissingNativeLoadLibrary")
+@DoNotStripAny
+public class ScriptBufferWrapper {
+  public ScriptBufferWrapper(String uri, AssetManager assetManager) {
+    String filePrefix = "file://";
+    String assetsPrefix = "assets://";
+
+    if (uri.startsWith(filePrefix)) {
+      String fileName = uri.substring(filePrefix.length());
+      mHybridData = initHybridFromFile(fileName);
+    } else if (uri.startsWith(assetsPrefix)) {
+      String assetURL = uri.substring(assetsPrefix.length());
+      mHybridData = initHybridFromAssets(assetManager, assetURL);
+    } else {
+      String scriptContent;
+      try {
+        scriptContent = downloadScript(uri);
+      } catch (IOException e) {
+        throw new RuntimeException(e);
+      }
+      mHybridData = initHybridFromString(scriptContent, uri);
+    }
+  }
+
+  private static String downloadScript(String url) throws IOException {
+    var scriptUrl = new URL(url);
+    HttpURLConnection connection = (HttpURLConnection) scriptUrl.openConnection();
+    try {
+      byte[] content;
+
+      if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.TIRAMISU) {
+        content = connection.getInputStream().readAllBytes();
+      } else {
+        content = readBytes(connection.getInputStream());
+      }
+
+      return new String(content, StandardCharsets.UTF_8);
+    } finally {
+      if (connection != null) {
+        connection.disconnect();
+      }
+    }
+  }
+
+  /** Reads all bytes from an InputStream into a byte array for SDKs below 33. */
+  private static byte[] readBytes(InputStream inputStream) throws IOException {
+    final int BUFFER_SIZE = 4096;
+    try {
+      java.io.ByteArrayOutputStream byteBuffer = new java.io.ByteArrayOutputStream();
+      byte[] buffer = new byte[BUFFER_SIZE];
+      int len;
+      while ((len = inputStream.read(buffer)) != -1) {
+        byteBuffer.write(buffer, 0, len);
+      }
+      return byteBuffer.toByteArray();
+    } finally {
+      if (inputStream != null) {
+        inputStream.close();
+      }
+    }
+  }
+
+  private native HybridData initHybridFromAssets(AssetManager assetManager, String assetURL);
+
+  private native HybridData initHybridFromFile(String fileName);
+
+  private native HybridData initHybridFromString(String script, String url);
+
+  @DoNotStrip
+  @SuppressWarnings({"unused", "FieldCanBeLocal"})
+  private final HybridData mHybridData;
+}

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

@@ -0,0 +1,23 @@
+package com.swmansion.worklets
+
+import com.facebook.jni.HybridData
+import com.facebook.jni.annotations.DoNotStrip
+import com.facebook.react.bridge.Arguments
+import com.facebook.react.bridge.WritableNativeArray
+
+@Suppress("KotlinJniMissingFunction")
+class WorkletRuntimeWrapper @DoNotStrip private constructor(
+    @field:DoNotStrip private val mHybridData: HybridData
+) {
+    fun emitDeviceEvent(eventName: String, params: Any?) {
+        cxxEmitDeviceEvent(Arguments.fromJavaArgs(arrayOf(eventName, params)));
+    }
+
+    fun getRuntimeId(): Int {
+        return cxxGetRuntimeId();
+    }
+
+    private external fun cxxEmitDeviceEvent(args: WritableNativeArray);
+
+    private external fun cxxGetRuntimeId(): Int;
+}

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

@@ -0,0 +1,30 @@
+/**
+* Based on HeaderUtil.kt from React Native 
+*/
+
+package com.swmansion.worklets
+
+/**
+ * The class purpose is to weaken too strict OkHttp restriction on http headers. See:
+ * https://github.com/square/okhttp/issues/2016 Auth headers might have an Authentication
+ * information. It is better to get 401 from the server in this case, rather than non descriptive
+ * error as 401 could be handled to invalidate the wrong token in the client code.
+ */
+internal class WorkletsHeaderUtil {
+  companion object {
+    @JvmStatic
+    fun stripHeaderName(name: String): String {
+      val builder = StringBuilder(name.length)
+      var modified = false
+      for (i in 0 until name.length) {
+        val c = name[i]
+        if (c > '\u0020' && c < '\u007f') {
+          builder.append(c)
+        } else {
+          modified = true
+        }
+      }
+      return if (modified) builder.toString() else name
+    }
+  }
+}

package/android/src/{legacyBundling → networking}/com/swmansion/worklets/WorkletsModule.java

@@ -3,9 +3,12 @@ package com.swmansion.worklets;
 import androidx.annotation.OptIn;
 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;
@@ -35,6 +38,7 @@ public class WorkletsModule extends NativeWorkletsModuleSpec implements Lifecycl
   private final WorkletsMessageQueueThread mMessageQueueThread = new WorkletsMessageQueueThread();
   private final AndroidUIScheduler mAndroidUIScheduler;
   private final AnimationFrameQueue mAnimationFrameQueue;
+  private final WorkletsNetworking mWorkletsNetworking;
   private boolean mSlowAnimationsEnabled;
 
   /**
@@ -48,7 +52,8 @@ public class WorkletsModule extends NativeWorkletsModuleSpec implements Lifecycl
       long jsContext,
       MessageQueueThread messageQueueThread,
       CallInvokerHolderImpl jsCallInvokerHolder,
-      AndroidUIScheduler androidUIScheduler);
+      AndroidUIScheduler androidUIScheduler,
+      ScriptBufferWrapper scriptBufferWrapper);
 
   public WorkletsModule(ReactApplicationContext reactContext) {
     super(reactContext);
@@ -57,6 +62,7 @@ public class WorkletsModule extends NativeWorkletsModuleSpec implements Lifecycl
 
     mAndroidUIScheduler = new AndroidUIScheduler(reactContext);
     mAnimationFrameQueue = new AnimationFrameQueue(reactContext);
+    mWorkletsNetworking = new WorkletsNetworking();
   }
 
   @OptIn(markerClass = FrameworkAPI.class)
@@ -69,11 +75,55 @@ public class WorkletsModule extends NativeWorkletsModuleSpec implements Lifecycl
     var jsContext = Objects.requireNonNull(context.getJavaScriptContextHolder()).get();
     var jsCallInvokerHolder = JSCallInvokerResolver.getJSCallInvokerHolder(context);
 
+    var sourceURL = context.getSourceURL();
+
+    ScriptBufferWrapper scriptBufferWrapper = null;
+    if (BuildConfig.BUNDLE_MODE_ENABLED) {
+      scriptBufferWrapper = new ScriptBufferWrapper(sourceURL, context.getAssets());
+    }
+
     mHybridData =
-        initHybrid(jsContext, mMessageQueueThread, jsCallInvokerHolder, mAndroidUIScheduler);
+        initHybrid(
+            jsContext,
+            mMessageQueueThread,
+            jsCallInvokerHolder,
+            mAndroidUIScheduler,
+            scriptBufferWrapper);
     return true;
   }
 
+  public void abortRequest(int runtimeId, double requestIdAsDouble) {
+    mWorkletsNetworking.jsiAbortRequest(runtimeId, requestIdAsDouble);
+  }
+
+  public void clearCookies(Callback callback) {
+    mWorkletsNetworking.jsiClearCookies(callback);
+  }
+
+  public void sendRequest(
+      WorkletRuntimeWrapper runtimeWrapper,
+      String method,
+      String url,
+      double requestIdAsDouble,
+      ReadableNativeArray headers,
+      ReadableNativeMap data,
+      String responseType,
+      boolean useIncrementalUpdates,
+      double timeoutAsDouble,
+      boolean withCredentials) {
+    mWorkletsNetworking.jsiSendRequest(
+        runtimeWrapper,
+        method,
+        url,
+        requestIdAsDouble,
+        headers,
+        data,
+        responseType,
+        useIncrementalUpdates,
+        timeoutAsDouble,
+        withCredentials);
+  }
+
   public void requestAnimationFrame(AnimationFrameCallback animationFrameCallback) {
     mAnimationFrameQueue.requestAnimationFrame(animationFrameCallback);
   }