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

package/RNWorklets.podspec

@@ -16,7 +16,6 @@ compilation_metadata_generation_flag = worklets_config[:is_reanimated_example_ap
 feature_flags = worklets_config[:feature_flags_flag]
 version_flag = "-DWORKLETS_VERSION=#{package['version']}"
 worklets_profiling_flag = ENV['IS_WORKLETS_PROFILING'] ? '-DWORKLETS_PROFILING' : ''
-fetch_preview_flag = worklets_config[:fetch_preview_flag]
 hermes_v1_flag = ENV['RCT_HERMES_V1_ENABLED'] == '1' ? '-DHERMES_V1_ENABLED' : ''
 
 # React Native doesn't expose these flags, but not having them
@@ -75,7 +74,7 @@ Pod::Spec.new do |s|
     "CLANG_CXX_LANGUAGE_STANDARD" => "c++20",
     "GCC_PREPROCESSOR_DEFINITIONS[config=*Debug*]" => "$(inherited) #{hermes_debug_hidden_flags}",
     "GCC_PREPROCESSOR_DEFINITIONS[config=*Release*]" => "$(inherited)",
-    "OTHER_CFLAGS" => "$(inherited) #{feature_flags} #{version_flag} #{compilation_metadata_generation_flag} #{worklets_profiling_flag} #{fetch_preview_flag} #{hermes_v1_flag}",
+    "OTHER_CFLAGS" => "$(inherited) #{feature_flags} #{version_flag} #{compilation_metadata_generation_flag} #{worklets_profiling_flag} #{hermes_v1_flag}",
   }
   s.xcconfig = {
     "HEADER_SEARCH_PATHS" => [

package/android/CMakeLists.txt

@@ -19,16 +19,10 @@ add_compile_options(${folly_FLAGS})
 string(APPEND CMAKE_CXX_FLAGS " -DWORKLETS_VERSION=${WORKLETS_VERSION}\
     -DWORKLETS_FEATURE_FLAGS=\"${WORKLETS_FEATURE_FLAGS}\"")
 
-# HERMES_V1_ENABLED is centralized in react-native-flags.cmake for RN >= 84.
-# Only define manually for older versions to avoid macro redefinition error.
-if(ReactAndroid_VERSION_MINOR LESS 84)
-  string(APPEND CMAKE_CXX_FLAGS " -DHERMES_V1_ENABLED=${HERMES_V1_ENABLED}")
-else()
-  # Reference the value so CMake records it as used, otherwise it warns:
-  # "Manually-specified variables were not used by the project:
-  # HERMES_V1_ENABLED"
-  set(HERMES_V1_ENABLED "${HERMES_V1_ENABLED}")
-endif()
+# HERMES_V1_ENABLED is centralized in react-native-flags.cmake. Reference the
+# value so CMake records it as used, otherwise it warns: "Manually-specified
+# variables were not used by the project: HERMES_V1_ENABLED"
+set(HERMES_V1_ENABLED "${HERMES_V1_ENABLED}")
 
 string(APPEND CMAKE_CXX_FLAGS " -fno-omit-frame-pointer -fstack-protector-all")
 
@@ -38,9 +32,6 @@ endif()
 if(${IS_REANIMATED_EXAMPLE_APP})
   string(APPEND CMAKE_CXX_FLAGS " -DIS_REANIMATED_EXAMPLE_APP -Wpedantic")
 endif()
-if(${WORKLETS_FETCH_PREVIEW_ENABLED})
-  string(APPEND CMAKE_CXX_FLAGS " -DWORKLETS_FETCH_PREVIEW_ENABLED")
-endif()
 
 if(NOT ${CMAKE_BUILD_TYPE} MATCHES "Debug")
   string(APPEND CMAKE_CXX_FLAGS " -DNDEBUG")
@@ -66,14 +57,8 @@ target_precompile_headers(worklets PRIVATE "${ANDROID_CPP_DIR}/WorkletsPCH.h")
 target_compile_options(
   worklets PRIVATE "$<$<COMPILE_LANGUAGE:CXX>:-Xclang;-fno-pch-timestamp>")
 
-if(ReactAndroid_VERSION_MINOR GREATER_EQUAL 80)
-  include(
-    "${REACT_NATIVE_DIR}/ReactCommon/cmake-utils/react-native-flags.cmake")
-  target_compile_reactnative_options(worklets PUBLIC)
-else()
-  string(APPEND CMAKE_CXX_FLAGS
-         " -fexceptions -frtti -std=c++${CMAKE_CXX_STANDARD} -Wall -Werror")
-endif()
+include("${REACT_NATIVE_DIR}/ReactCommon/cmake-utils/react-native-flags.cmake")
+target_compile_reactnative_options(worklets PUBLIC)
 
 # includes
 target_include_directories(worklets PUBLIC "${COMMON_CPP_DIR}"
@@ -97,11 +82,7 @@ set_target_properties(worklets PROPERTIES LINKER_LANGUAGE CXX)
 target_link_libraries(worklets android log ReactAndroid::reactnative
                       ReactAndroid::jsi fbjni::fbjni)
 
-if(ReactAndroid_VERSION_MINOR GREATER_EQUAL 82)
-  target_link_libraries(worklets hermes-engine::hermesvm)
-else()
-  target_link_libraries(worklets hermes-engine::libhermes)
-endif()
+target_link_libraries(worklets hermes-engine::hermesvm)
 
 if(${HERMES_ENABLE_DEBUGGER})
   string(APPEND CMAKE_CXX_FLAGS " -DHERMES_ENABLE_DEBUGGER=1")

package/android/build.gradle.kts

@@ -69,22 +69,13 @@ fun getReactNativeVersion(): String {
     return reactProperties.getProperty("VERSION_NAME")
 }
 
-fun getReactNativeMinorVersion(): Int {
-    val reactNativeVersion = getReactNativeVersion()
-    return if (reactNativeVersion.startsWith("0.0.0-")) 1000 else reactNativeVersion.split(".")[1].toInt()
-}
-
 fun getHermesV1Enabled(): Boolean {
     // Even though `HERMES_V1_ENABLED` is now centralized
-    // in `react-native-flags.cmake` for React Native >= 0.84
-    // that CMake file depends on definitions provided
-    // in local `externalNativeBuild` configuration of the LIBRARY.
+    // in `react-native-flags.cmake`, that CMake file depends
+    // on definitions provided in local `externalNativeBuild`
+    // configuration of the LIBRARY.
     // I hope this is only a temporary workaround.
-    return if (getReactNativeMinorVersion() >= 84) {
-        safeAppExtGet("hermesV1Enabled", true)?.toString()?.toBoolean() ?: true
-    } else {
-        safeAppExtGet("hermesV1Enabled", false)?.toString()?.toBoolean() ?: false
-    }
+    return safeAppExtGet("hermesV1Enabled", true)?.toString()?.toBoolean() ?: true
 }
 
 fun getWorkletsVersion(): String {
@@ -127,9 +118,6 @@ fun getStaticFeatureFlags(): Map<String, String> {
 fun getStaticFeatureFlagsString(featureFlags: Map<String, String>): String =
     featureFlags.entries.joinToString("") { (key, value) -> "[$key:$value]" }
 
-fun isFlagEnabled(featureFlags: Map<String, String>, flagName: String): Boolean =
-    featureFlags.containsKey(flagName) && featureFlags[flagName] == "true"
-
 if (project != rootProject) {
     apply(plugin = "com.facebook.react")
 }
@@ -141,7 +129,6 @@ val reactNativeRootDir: File = resolveReactNativeDirectory()
 val REACT_NATIVE_VERSION: String = getReactNativeVersion()
 val WORKLETS_VERSION: String = getWorkletsVersion()
 val IS_REANIMATED_EXAMPLE_APP: Boolean = safeAppExtGet("isReanimatedExampleApp", false)?.toString()?.toBoolean() ?: false
-val FETCH_PREVIEW_ENABLED: Boolean = isFlagEnabled(featureFlags, "FETCH_PREVIEW_ENABLED")
 val WORKLETS_FEATURE_FLAGS: String = getStaticFeatureFlagsString(featureFlags)
 val HERMES_V1_ENABLED: Boolean = getHermesV1Enabled()
 val WORKLETS_PROFILING: Boolean = safeAppExtGet("enableWorkletsProfiling", false)?.toString()?.toBoolean() ?: false
@@ -216,7 +203,6 @@ android {
                     "-DANDROID_TOOLCHAIN=clang",
                     "-DREACT_NATIVE_DIR=${toPlatformFileString(reactNativeRootDir.path)}",
                     "-DIS_REANIMATED_EXAMPLE_APP=$IS_REANIMATED_EXAMPLE_APP",
-                    "-DWORKLETS_FETCH_PREVIEW_ENABLED=$FETCH_PREVIEW_ENABLED",
                     "-DWORKLETS_PROFILING=$WORKLETS_PROFILING",
                     "-DWORKLETS_VERSION=$WORKLETS_VERSION",
                     "-DANDROID_SUPPORT_FLEXIBLE_PAGE_SIZES=ON",
@@ -286,18 +272,6 @@ android {
         targetCompatibility = JavaVersion.VERSION_17
     }
 
-    sourceSets {
-        getByName("main") {
-            kotlin {
-                if (FETCH_PREVIEW_ENABLED) {
-                    directories.add("src/networking")
-                } else {
-                    directories.add("src/no-networking")
-                }
-            }
-        }
-    }
-
     if (IS_REANIMATED_EXAMPLE_APP) {
         apply(from = "../../../scripts/llvm-tools/android-hook.gradle.kts")
     }
@@ -336,7 +310,7 @@ tasks.named("preBuild") { dependsOn("assertMinimalReactNativeVersionTask") }
 
 // Workaround for AGP 9 + Kotlin 2.x lint K2 UAST crash on .gradle.kts build scripts.
 // See: https://issuetracker.google.com/issues/432144179
-tasks.configureEach { if (name.startsWith("lintVital")) enabled = false }
+tasks.configureEach { if (name.startsWith("lint")) enabled = false }
 
 tasks.register<Copy>("prepareWorkletsHeadersForPrefabs") {
     from("$projectDir/src/main/cpp")

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

@@ -1,22 +1,10 @@
+#include <worklets/Tools/JSScheduler.h>
 #include <worklets/Tools/ScriptBuffer.h>
 #include <worklets/WorkletRuntime/BundleModeConfig.h>
 #include <worklets/WorkletRuntime/RuntimeBindings.h>
 #include <worklets/android/AnimationFrameCallback.h>
 #include <worklets/android/WorkletsModule.h>
 
-#ifdef 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>
-
-#include <vector>
-#endif // WORKLETS_FETCH_PREVIEW_ENABLED
-
 #include <memory>
 #include <string>
 #include <utility>
@@ -28,152 +16,75 @@ using namespace react;
 
 WorkletsModule::WorkletsModule(
     jni::alias_ref<jhybridobject> jThis, // NOLINT //(performance-unnecessary-value-param)
-    const BundleModeConfig &bundleModeConfig,
     jsi::Runtime *rnRuntime,
     const std::shared_ptr<facebook::react::CallInvoker> &jsCallInvoker,
-    const std::shared_ptr<UIScheduler> &uiScheduler)
+    const std::shared_ptr<UIScheduler> &uiScheduler,
+    jni::global_ref<JNetworking::javaobject> networking)
     : javaPart_(jni::make_global(jThis)),
       rnRuntime_(rnRuntime),
       rnRuntimeStatus_(std::make_shared<RNRuntimeStatus>()),
-      workletsModuleProxy_(std::make_shared<WorkletsModuleProxy>(
-          *rnRuntime,
-          jsCallInvoker,
+      initializer_(std::make_shared<WorkletsModuleProxyInitializer>(
+          std::make_shared<JSScheduler>(*rnRuntime, jsCallInvoker, getIsOnJSQueueThread()),
           uiScheduler,
-          getIsOnJSQueueThread(),
-          getRuntimeBindings(bundleModeConfig.enabled, *rnRuntime),
-          bundleModeConfig,
+          getRuntimeBindings(javaPart_, std::move(networking)),
           rnRuntimeStatus_)) {}
 
 jni::local_ref<WorkletsModule::jhybriddata> WorkletsModule::initHybrid(
     jni::alias_ref<jhybridobject> jThis, // NOLINT //(performance-unnecessary-value-param)
-    jboolean bundleModeEnabled,
     jlong jsContext,
     jni::alias_ref<facebook::react::CallInvokerHolder::javaobject> jsCallInvokerHolder,
     jni::alias_ref<worklets::AndroidUIScheduler::javaobject> androidUIScheduler,
-    jni::alias_ref<JScriptBufferWrapper::javaobject>
-        jScriptBufferWrapper // NOLINT //(performance-unnecessary-value-param)
+    jni::alias_ref<JNetworking::javaobject> networking // NOLINT //(performance-unnecessary-value-param)
 ) {
   auto jsCallInvoker = jsCallInvokerHolder->cthis()->getCallInvoker();
   auto rnRuntime = reinterpret_cast<jsi::Runtime *>(jsContext); // NOLINT //(performance-no-int-to-ptr)
   auto uiScheduler = androidUIScheduler->cthis()->getUIScheduler();
+  return makeCxxInstance(jThis, rnRuntime, jsCallInvoker, uiScheduler, jni::make_global(networking));
+}
 
-  std::shared_ptr<const ScriptBuffer> script = nullptr;
-  std::string sourceURL;
-  if (bundleModeEnabled) {
-    auto cxxWrapper = jScriptBufferWrapper->cthis();
-    script = cxxWrapper->getScript();
-    sourceURL = cxxWrapper->getSourceUrl();
-  }
-
-  return makeCxxInstance(
-      jThis,
-      BundleModeConfig{
-          .enabled = static_cast<bool>(bundleModeEnabled),
-          .script = script,
-          .sourceURL = sourceURL,
-      },
-      rnRuntime,
-      jsCallInvoker,
-      uiScheduler);
+void WorkletsModule::prepareProxyCpp() {
+  initializer_->prepareProxy();
 }
 
-std::shared_ptr<RuntimeBindings> WorkletsModule::getRuntimeBindings(
-    const bool bundleModeEnabled,
-    jsi::Runtime &rnRuntime) {
-  return std::make_shared<RuntimeBindings>(RuntimeBindings{
-      .requestAnimationFrame = getRequestAnimationFrame(),
-      .nativeLoggingHook =
-          bundleModeEnabled ? extractNativeLoggingHookFromRNRuntime(rnRuntime) : RuntimeBindings::NativeLoggingHook{}
-#ifdef WORKLETS_FETCH_PREVIEW_ENABLED
-      ,
-      .abortRequest = getAbortRequest(),
-      .clearCookies = getClearCookies(),
-      .sendRequest = getSendRequest()
-#endif // WORKLETS_FETCH_PREVIEW_ENABLED
-  });
+void WorkletsModule::beginBundleModeAOTCpp() {
+  initializer_->beginBundleModeAOT();
 }
 
-RuntimeBindings::RequestAnimationFrame WorkletsModule::getRequestAnimationFrame() {
-  return [javaPart = javaPart_](std::function<void(const double)> &&callback) -> void {
-    static const auto jRequestAnimationFrame =
-        javaPart->getClass()->getMethod<void(AnimationFrameCallback::javaobject)>("requestAnimationFrame");
-    jRequestAnimationFrame(javaPart.get(), AnimationFrameCallback::newObjectCxxArgs(std::move(callback)).get());
-  };
+void WorkletsModule::prepareBundleModeAOTCpp() {
+  initializer_->prepareBundleModeAOT([this] { return loadBundleModeConfig(); });
 }
 
-#ifdef 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);
-  };
+void WorkletsModule::installTurboModuleCpp(jboolean bundleModeEnabled) {
+  workletsModuleProxy_ = initializer_->finalize(
+      *rnRuntime_, static_cast<bool>(bundleModeEnabled), [this] { return loadBundleModeConfig(); });
 }
 
-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());
-  };
+std::shared_ptr<RuntimeBindings> WorkletsModule::getRuntimeBindings(
+    const jni::global_ref<jhybridobject> &javaPart,
+    jni::global_ref<JNetworking::javaobject> networking) {
+  return std::make_shared<RuntimeBindings>(RuntimeBindings{
+      .requestAnimationFrame = getRequestAnimationFrame(javaPart),
+      .nativeLoggingHook = makeNativeLoggingHook(),
+      .networkingBackend = std::make_shared<AndroidNetworkingBackend>(std::move(networking))});
 }
 
-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);
+BundleModeConfig WorkletsModule::loadBundleModeConfig() {
+  static const auto jCreateScriptBufferWrapper =
+      getJniMethod<JScriptBufferWrapper::javaobject()>("createScriptBufferWrapper");
+  const auto jScriptBufferWrapper = jCreateScriptBufferWrapper(javaPart_.get());
+  const auto scriptBufferWrapper = jScriptBufferWrapper->cthis();
+  return BundleModeConfig{
+      .enabled = true, .script = scriptBufferWrapper->getScript(), .sourceURL = scriptBufferWrapper->getSourceUrl()};
+}
+
+RuntimeBindings::RequestAnimationFrame WorkletsModule::getRequestAnimationFrame(
+    const jni::global_ref<jhybridobject> &javaPart) {
+  return [javaPart](std::function<void(const double)> &&callback) -> void {
+    static const auto jRequestAnimationFrame =
+        javaPart->getClass()->getMethod<void(AnimationFrameCallback::javaobject)>("requestAnimationFrame");
+    jRequestAnimationFrame(javaPart.get(), AnimationFrameCallback::newObjectCxxArgs(std::move(callback)).get());
   };
 }
-#endif // WORKLETS_FETCH_PREVIEW_ENABLED
 
 std::function<bool()> WorkletsModule::getIsOnJSQueueThread() {
   return [javaPart = javaPart_]() -> bool {
@@ -184,6 +95,8 @@ std::function<bool()> WorkletsModule::getIsOnJSQueueThread() {
 
 void WorkletsModule::invalidateCpp() {
   rnRuntimeStatus_->setDead();
+  initializer_->invalidate();
+  initializer_.reset();
   javaPart_.reset();
   workletsModuleProxy_.reset();
 }
@@ -195,6 +108,10 @@ void WorkletsModule::startCpp() {
 void WorkletsModule::registerNatives() {
   registerHybrid({
       makeNativeMethod("initHybrid", WorkletsModule::initHybrid),
+      makeNativeMethod("prepareProxyCpp", WorkletsModule::prepareProxyCpp),
+      makeNativeMethod("beginBundleModeAOTCpp", WorkletsModule::beginBundleModeAOTCpp),
+      makeNativeMethod("prepareBundleModeAOTCpp", WorkletsModule::prepareBundleModeAOTCpp),
+      makeNativeMethod("installTurboModuleCpp", WorkletsModule::installTurboModuleCpp),
       makeNativeMethod("invalidateCpp", WorkletsModule::invalidateCpp),
       makeNativeMethod("startCpp", WorkletsModule::startCpp),
   });

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

@@ -4,12 +4,14 @@
 #include <fbjni/fbjni.h>
 #include <jsi/jsi.h>
 #include <worklets/NativeModules/WorkletsModuleProxy.h>
+#include <worklets/NativeModules/WorkletsModuleProxyInitializer.h>
 #include <worklets/Tools/RNRuntimeStatus.h>
 #include <worklets/Tools/ScriptBuffer.h>
 #include <worklets/WorkletRuntime/BundleModeConfig.h>
 #include <worklets/WorkletRuntime/RuntimeBindings.h>
 #include <worklets/android/AndroidUIScheduler.h>
 #include <worklets/android/JScriptBufferWrapper.h>
+#include <worklets/android/networking/AndroidNetworkingBackend.h>
 
 #include <memory>
 #include <string>
@@ -25,11 +27,10 @@ class WorkletsModule : public jni::HybridClass<WorkletsModule> {
 
   static jni::local_ref<jhybriddata> initHybrid(
       jni::alias_ref<jhybridobject> jThis,
-      jboolean bundleModeEnabled,
       jlong jsContext,
       jni::alias_ref<facebook::react::CallInvokerHolder::javaobject> jsCallInvokerHolder,
       jni::alias_ref<worklets::AndroidUIScheduler::javaobject> androidUIScheduler,
-      jni::alias_ref<JScriptBufferWrapper::javaobject> jScriptBufferWrapper);
+      jni::alias_ref<JNetworking::javaobject> networking);
 
   static void registerNatives();
 
@@ -40,10 +41,18 @@ class WorkletsModule : public jni::HybridClass<WorkletsModule> {
  private:
   explicit WorkletsModule(
       jni::alias_ref<jhybridobject> jThis,
-      const BundleModeConfig &bundleModeConfig,
       jsi::Runtime *rnRuntime,
       const std::shared_ptr<facebook::react::CallInvoker> &jsCallInvoker,
-      const std::shared_ptr<UIScheduler> &uiScheduler);
+      const std::shared_ptr<UIScheduler> &uiScheduler,
+      jni::global_ref<JNetworking::javaobject> networking);
+
+  void prepareProxyCpp();
+
+  void beginBundleModeAOTCpp();
+
+  void prepareBundleModeAOTCpp();
+
+  void installTurboModuleCpp(jboolean bundleModeEnabled);
 
   void startCpp();
 
@@ -54,14 +63,14 @@ class WorkletsModule : public jni::HybridClass<WorkletsModule> {
     return javaPart_->getClass()->getMethod<Signature>(methodName.c_str());
   }
 
-  std::shared_ptr<RuntimeBindings> getRuntimeBindings(bool bundleModeEnabled, jsi::Runtime &rnRuntime);
+  static std::shared_ptr<RuntimeBindings> getRuntimeBindings(
+      const jni::global_ref<jhybridobject> &javaPart,
+      jni::global_ref<JNetworking::javaobject> networking);
+
+  BundleModeConfig loadBundleModeConfig();
 
-  RuntimeBindings::RequestAnimationFrame getRequestAnimationFrame();
-#ifdef WORKLETS_FETCH_PREVIEW_ENABLED
-  RuntimeBindings::AbortRequest getAbortRequest();
-  RuntimeBindings::ClearCookies getClearCookies();
-  RuntimeBindings::SendRequest getSendRequest();
-#endif // WORKLETS_FETCH_PREVIEW_ENABLED
+  static RuntimeBindings::RequestAnimationFrame getRequestAnimationFrame(
+      const jni::global_ref<jhybridobject> &javaPart);
 
   std::function<bool()> getIsOnJSQueueThread();
 
@@ -69,6 +78,7 @@ class WorkletsModule : public jni::HybridClass<WorkletsModule> {
   jni::global_ref<WorkletsModule::javaobject> javaPart_;
   jsi::Runtime *rnRuntime_;
   std::shared_ptr<RNRuntimeStatus> rnRuntimeStatus_;
+  std::shared_ptr<WorkletsModuleProxyInitializer> initializer_;
   std::shared_ptr<WorkletsModuleProxy> workletsModuleProxy_;
 };
 

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

@@ -3,8 +3,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>
+#include <worklets/android/networking/JNetworkRequestListener.h>
 
 JNIEXPORT jint JNICALL JNI_OnLoad(JavaVM *vm, void *) {
   return facebook::jni::initialize(vm, [] {
@@ -12,8 +12,6 @@ JNIEXPORT jint JNICALL JNI_OnLoad(JavaVM *vm, void *) {
     worklets::AndroidUIScheduler::registerNatives();
     worklets::AnimationFrameCallback::registerNatives();
     worklets::JScriptBufferWrapper::registerNatives();
-#ifdef WORKLETS_FETCH_PREVIEW_ENABLED
-    worklets::JWorkletRuntimeWrapper::registerNatives();
-#endif // WORKLETS_FETCH_PREVIEW_ENABLED
+    worklets::JNetworkRequestListener::registerNatives();
   });
 }

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

@@ -0,0 +1,82 @@
+#include <worklets/android/networking/AndroidNetworkingBackend.h>
+#include <worklets/android/networking/JNetworkRequestListener.h>
+
+#include <optional>
+#include <string>
+#include <utility>
+
+namespace worklets {
+
+AndroidNetworkingBackend::AndroidNetworkingBackend(jni::global_ref<JNetworking::javaobject> networking)
+    : networking_(std::move(networking)) {}
+
+void AndroidNetworkingBackend::sendRequest(
+    const uint64_t requestId,
+    RequestConfig &&config,
+    const std::shared_ptr<NetworkRequestListener> &listener) {
+  jni::ThreadScope::WithClassLoader([&] {
+    static const auto jSendRequest = networking_->getClass()
+                                         ->getMethod<void(
+                                             jdouble,
+                                             std::string,
+                                             std::string,
+                                             jni::JArrayClass<jni::JString>::javaobject,
+                                             jni::JArrayClass<jni::JString>::javaobject,
+                                             jni::JArrayByte::javaobject,
+                                             jdouble,
+                                             jboolean,
+                                             JNetworkRequestListener::javaobject)>("sendRequest");
+
+    const auto headersSize = config.headers.size();
+    auto headerNames = jni::JArrayClass<jni::JString>::newArray(headersSize);
+    auto headerValues = jni::JArrayClass<jni::JString>::newArray(headersSize);
+    for (size_t i = 0; i < headersSize; i++) {
+      headerNames->setElement(i, *jni::make_jstring(config.headers[i].first));
+      headerValues->setElement(i, *jni::make_jstring(config.headers[i].second));
+    }
+
+    jni::local_ref<jni::JArrayByte> body = nullptr;
+    if (config.body.has_value()) {
+      body = jni::JArrayByte::newArray(config.body->size());
+      body->setRegion(0, config.body->size(), reinterpret_cast<const jbyte *>(config.body->data()));
+    }
+
+    jSendRequest(
+        networking_.get(),
+        static_cast<jdouble>(requestId),
+        config.method,
+        config.url,
+        headerNames.get(),
+        headerValues.get(),
+        body.get(),
+        config.timeoutMs,
+        config.withCredentials,
+        JNetworkRequestListener::newObjectCxxArgs(listener).get());
+  });
+}
+
+std::optional<std::string>
+AndroidNetworkingBackend::decodeText(const uint8_t *data, const size_t size, const std::string &label) {
+  std::optional<std::string> result;
+  jni::ThreadScope::WithClassLoader([&] {
+    static const auto jDecodeText =
+        networking_->getClass()->getMethod<jni::JString::javaobject(jni::JArrayByte::javaobject, std::string)>(
+            "decodeText");
+    auto bytes = jni::JArrayByte::newArray(size);
+    bytes->setRegion(0, size, reinterpret_cast<const jbyte *>(data));
+    const auto decoded = jDecodeText(networking_.get(), bytes.get(), label);
+    if (decoded) {
+      result = decoded->toStdString();
+    }
+  });
+  return result;
+}
+
+void AndroidNetworkingBackend::abortRequest(const uint64_t requestId) {
+  jni::ThreadScope::WithClassLoader([&] {
+    static const auto jAbortRequest = networking_->getClass()->getMethod<void(jdouble)>("abortRequest");
+    jAbortRequest(networking_.get(), static_cast<jdouble>(requestId));
+  });
+}
+
+} // namespace worklets

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

@@ -0,0 +1,32 @@
+#pragma once
+
+#include <fbjni/fbjni.h>
+#include <worklets/Networking/NetworkingBackend.h>
+
+#include <memory>
+#include <optional>
+#include <string>
+
+namespace worklets {
+
+namespace jni = facebook::jni;
+
+class JNetworking : public jni::JavaClass<JNetworking> {
+ public:
+  static auto constexpr kJavaDescriptor = "Lcom/swmansion/worklets/networking/Networking;";
+};
+
+class AndroidNetworkingBackend final : public NetworkingBackend {
+ public:
+  explicit AndroidNetworkingBackend(jni::global_ref<JNetworking::javaobject> networking);
+
+  void sendRequest(uint64_t requestId, RequestConfig &&config, const std::shared_ptr<NetworkRequestListener> &listener)
+      override;
+  void abortRequest(uint64_t requestId) override;
+  std::optional<std::string> decodeText(const uint8_t *data, size_t size, const std::string &label) override;
+
+ private:
+  const jni::global_ref<JNetworking::javaobject> networking_;
+};
+
+} // namespace worklets