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

package/RNWorklets.podspec

@@ -10,8 +10,20 @@ worklets_assert_new_architecture_enabled($new_arch_enabled)
 
 ios_min_version = '13.4'
 
-feature_flags = "-DWORKLETS_FEATURE_FLAGS=\"#{worklets_get_static_feature_flags()}\""
+feature_flags = $worklets_config[:feature_flags_flag]
 version_flags = "-DWORKLETS_VERSION=#{package['version']} -DREACT_NATIVE_MINOR_VERSION=#{$worklets_config[:react_native_minor_version]}"
+worklets_profiling_flag = ENV['IS_WORKLETS_PROFILING'] ? '-DWORKLETS_PROFILING' : ''
+bundle_mode_flag = $worklets_config[:bundle_mode_flag]
+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
+# can lead to runtime errors due to ABI mismatches.
+# There's also
+#   HERMESVM_PROFILER_OPCODE
+#   HERMESVM_PROFILER_BB
+# which shouldn't be defined in standard setups.
+hermes_debug_hidden_flags = 'HERMES_ENABLE_DEBUGGER=1'
 
 Pod::Spec.new do |s|
   s.name         = "RNWorklets"
@@ -47,16 +59,6 @@ Pod::Spec.new do |s|
   if using_hermes && !$worklets_config[:is_tvos_target]
     s.dependency 'React-hermes'
   end
-
-  # React Native doesn't expose these flags, but not having them
-  # can lead to runtime errors due to ABI mismatches.
-  # There's also
-  #   HERMESVM_PROFILER_OPCODE
-  #   HERMESVM_PROFILER_BB
-  # which shouldn't be defined in standard setups.
-  hermes_debug_hidden_flags = 'HERMES_ENABLE_DEBUGGER=1'
-
-  bundle_mode_flag = $worklets_config[:bundle_mode] ? 'WORKLETS_BUNDLE_MODE=1' : ''
   
   s.pod_target_xcconfig = {
     "USE_HEADERMAP" => "YES",
@@ -73,9 +75,9 @@ Pod::Spec.new do |s|
     ].join(' '),
     "FRAMEWORK_SEARCH_PATHS" => '"${PODS_CONFIGURATION_BUILD_DIR}/React-hermes"',
     "CLANG_CXX_LANGUAGE_STANDARD" => "c++20",
-    "GCC_PREPROCESSOR_DEFINITIONS[config=*Debug*]" => "$(inherited) #{hermes_debug_hidden_flags} #{bundle_mode_flag}",
-    "GCC_PREPROCESSOR_DEFINITIONS[config=*Release*]" => "$(inherited) #{bundle_mode_flag}",
-    "OTHER_CFLAGS" => "$(inherited) #{feature_flags} #{version_flags}",
+    "GCC_PREPROCESSOR_DEFINITIONS[config=*Debug*]" => "$(inherited) #{hermes_debug_hidden_flags}",
+    "GCC_PREPROCESSOR_DEFINITIONS[config=*Release*]" => "$(inherited)",
+    "OTHER_CFLAGS" => "$(inherited) #{feature_flags} #{version_flags} #{worklets_profiling_flag} #{bundle_mode_flag} #{fetch_preview_flag} #{hermes_v1_flag}",
   }
   s.xcconfig = {
     "HEADER_SEARCH_PATHS" => [

package/android/CMakeLists.txt

@@ -21,11 +21,17 @@ string(
 
 string(APPEND CMAKE_CXX_FLAGS " -fno-omit-frame-pointer -fstack-protector-all")
 
+if(${WORKLETS_PROFILING})
+  string(APPEND CMAKE_CXX_FLAGS " -DWORKLETS_PROFILING")
+endif()
 if(${IS_REANIMATED_EXAMPLE_APP})
   string(APPEND CMAKE_CXX_FLAGS " -DIS_REANIMATED_EXAMPLE_APP -Wpedantic")
 endif()
-if(${WORKLETS_BUNDLE_MODE})
-  string(APPEND CMAKE_CXX_FLAGS " -DWORKLETS_BUNDLE_MODE")
+if(${WORKLETS_BUNDLE_MODE_ENABLED})
+  string(APPEND CMAKE_CXX_FLAGS " -DWORKLETS_BUNDLE_MODE_ENABLED")
+endif()
+if(${WORKLETS_FETCH_PREVIEW_ENABLED})
+  string(APPEND CMAKE_CXX_FLAGS " -DWORKLETS_FETCH_PREVIEW_ENABLED")
 endif()
 
 if(NOT ${CMAKE_BUILD_TYPE} MATCHES "Debug")

package/android/build.gradle

@@ -1,7 +1,7 @@
 import com.android.build.gradle.tasks.ExternalNativeBuildJsonTask
 import groovy.json.JsonSlurper
-import java.nio.file.Paths
 import org.apache.tools.ant.taskdefs.condition.Os
+import javax.inject.Inject
 
 def safeExtGet(prop, fallback) {
     rootProject.ext.has(prop) ? rootProject.ext.get(prop) : fallback
@@ -13,7 +13,12 @@ def safeAppExtGet(prop, fallback) {
 }
 
 def isNewArchitectureEnabled() {
-    // To opt-in for the New Architecture, you can either:
+    // In React Native 0.82+, users can no longer opt-out of the New Architecture.
+    if(getReactNativeMinorVersion() >= 82){
+        return true
+    }
+
+    // In older versions, to opt-in for the New Architecture, you can either:
     // - Set `newArchEnabled` to true inside the `gradle.properties` file
     // - Invoke gradle with `-newArchEnabled=true`
     // - Set an environment variable `ORG_GRADLE_PROJECT_newArchEnabled=true`
@@ -27,19 +32,15 @@ def resolveReactNativeDirectory() {
     }
 
     // Fallback to node resolver for custom directory structures like monorepos.
-    def reactNativePackage = file(
-        providers.exec {
-            workingDir(rootDir)
-            commandLine("node", "--print", "require.resolve('react-native/package.json')")
-        }.standardOutput.asText.get().trim()
-    )
+    def reactNativePackage = file(providers.exec {
+        workingDir(rootDir)
+        commandLine("node", "--print", "require.resolve('react-native/package.json')")
+    }.standardOutput.asText.get().trim())
     if (reactNativePackage.exists()) {
         return reactNativePackage.parentFile
     }
 
-    throw new GradleException(
-        "[Worklets] Unable to resolve react-native location in node_modules. You should set project extension property (in `app/build.gradle`) named `REACT_NATIVE_NODE_MODULES_DIR` with the path to react-native in node_modules."
-    )
+    throw new GradleException("[Worklets] Unable to resolve react-native location in node_modules. You should set project extension property (in `app/build.gradle`) named `REACT_NATIVE_NODE_MODULES_DIR` with the path to react-native in node_modules.")
 }
 
 def getReactNativeVersion() {
@@ -60,7 +61,7 @@ def getWorkletsVersion() {
     return json.version
 }
 
-def toPlatformFileString(String path) {
+static def toPlatformFileString(String path) {
     if (Os.isFamily(Os.FAMILY_WINDOWS)) {
         path = path.replace(File.separatorChar, '/' as char)
     }
@@ -74,25 +75,33 @@ def getStaticFeatureFlags() {
     if (!staticFeatureFlagsFile.exists()) {
         throw new GradleException("[Worklets] Feature flags file not found at ${staticFeatureFlagsFile.absolutePath}.")
     }
-    new JsonSlurper().parseText(staticFeatureFlagsFile.text).each { key, value ->
-        featureFlags[key] = value.toString()
+    new JsonSlurper().parseText(staticFeatureFlagsFile.text).each { key, value -> featureFlags[key] = value.toString()
     }
 
     def packageJsonFile = file(rootDir.path + "/../package.json")
     if (packageJsonFile.exists()) {
         def packageJson = new JsonSlurper().parseText(packageJsonFile.text)
-        packageJson.worklets?.staticFeatureFlags?.each { key, value ->
-            featureFlags[key] = value.toString()
+        packageJson.worklets?.staticFeatureFlags?.each { key, value -> featureFlags[key] = value.toString()
         }
     }
 
+    return featureFlags;
+}
+
+def getStaticFeatureFlagsString(featureFlags) {
     return featureFlags.collect { key, value -> "[${key}:${value}]" }.join("")
 }
 
-if (isNewArchitectureEnabled()) {
+def isFlagEnabled(featureFlags, flagName) {
+    return (featureFlags.containsKey(flagName) && featureFlags[flagName] == "true");
+}
+
+if (isNewArchitectureEnabled() && project != rootProject) {
     apply plugin: "com.facebook.react"
 }
 
+def featureFlags = getStaticFeatureFlags()
+
 def packageDir = project.projectDir.parentFile
 def reactNativeRootDir = resolveReactNativeDirectory()
 def REACT_NATIVE_MINOR_VERSION = getReactNativeMinorVersion()
@@ -100,14 +109,16 @@ def REACT_NATIVE_VERSION = getReactNativeVersion()
 def WORKLETS_VERSION = getWorkletsVersion()
 def IS_NEW_ARCHITECTURE_ENABLED = isNewArchitectureEnabled()
 def IS_REANIMATED_EXAMPLE_APP = safeAppExtGet("isReanimatedExampleApp", false)
-def BUNDLE_MODE = safeAppExtGet("workletsBundleMode", false)
-def WORKLETS_FEATURE_FLAGS = getStaticFeatureFlags()
+def BUNDLE_MODE_ENABLED = isFlagEnabled(featureFlags, "BUNDLE_MODE_ENABLED");
+def FETCH_PREVIEW_ENABLED = isFlagEnabled(featureFlags, "FETCH_PREVIEW_ENABLED");
+def WORKLETS_FEATURE_FLAGS = getStaticFeatureFlagsString(featureFlags)
 def HERMES_V1_ENABLED = safeAppExtGet("hermesV1Enabled", false)
+def WORKLETS_PROFILING = safeAppExtGet("enableWorkletsProfiling", false)
 
 // Set version for prefab
 version WORKLETS_VERSION
 
-def workletsPrefabHeadersDir = project.file("$buildDir/prefab-headers/worklets")
+def workletsPrefabHeadersDir = project.file("${getLayout().getBuildDirectory().getAsFile().get().absolutePath}/prefab-headers/worklets")
 
 def JS_RUNTIME = {
     // Override JS runtime with environment variable
@@ -136,20 +147,22 @@ buildscript {
         mavenCentral()
     }
     dependencies {
-        classpath "com.android.tools.build:gradle:8.2.1"
+        classpath "com.android.tools.build:gradle:8.13.1"
         classpath "de.undercouch:gradle-download-task:5.6.0"
-        classpath "com.diffplug.spotless:spotless-plugin-gradle:6.25.0"
+        classpath "com.diffplug.spotless:spotless-plugin-gradle:8.1.0"
     }
 }
 
-if (project == rootProject) {
-    apply from: "spotless.gradle"
-}
-
 apply plugin: "com.android.library"
 apply plugin: "maven-publish"
 apply plugin: "de.undercouch.download"
 
+if (project == rootProject) {
+    apply from: "spotless.gradle"
+} else {
+    apply plugin: "org.jetbrains.kotlin.android"
+}
+
 apply from: "./fix-prefab.gradle"
 
 
@@ -183,10 +196,11 @@ android {
         versionCode 1
         versionName WORKLETS_VERSION
 
+        buildConfigField("boolean", "WORKLETS_PROFILING", WORKLETS_PROFILING.toString())
         buildConfigField("boolean", "IS_INTERNAL_BUILD", "false")
         buildConfigField("int", "EXOPACKAGE_FLAGS", "0")
         buildConfigField("int", "REACT_NATIVE_MINOR_VERSION", REACT_NATIVE_MINOR_VERSION.toString())
-        buildConfigField("boolean", "BUNDLE_MODE", BUNDLE_MODE.toString())
+        buildConfigField("boolean", "BUNDLE_MODE_ENABLED", BUNDLE_MODE_ENABLED.toString())
 
         externalNativeBuild {
             cmake {
@@ -196,12 +210,14 @@ android {
                         "-DREACT_NATIVE_DIR=${toPlatformFileString(reactNativeRootDir.path)}",
                         "-DJS_RUNTIME=${JS_RUNTIME}",
                         "-DIS_REANIMATED_EXAMPLE_APP=${IS_REANIMATED_EXAMPLE_APP}",
-                        "-DWORKLETS_BUNDLE_MODE=${BUNDLE_MODE}",
+                        "-DWORKLETS_BUNDLE_MODE_ENABLED=${BUNDLE_MODE_ENABLED}",
+                        "-DWORKLETS_FETCH_PREVIEW_ENABLED=${FETCH_PREVIEW_ENABLED}",
+                        "-DWORKLETS_PROFILING=${WORKLETS_PROFILING}",
                         "-DWORKLETS_VERSION=${WORKLETS_VERSION}",
                         "-DANDROID_SUPPORT_FLEXIBLE_PAGE_SIZES=ON",
                         "-DWORKLETS_FEATURE_FLAGS=${WORKLETS_FEATURE_FLAGS}",
                         "-DHERMES_V1_ENABLED=${HERMES_V1_ENABLED}"
-                abiFilters (*reactNativeArchitectures())
+                abiFilters(*reactNativeArchitectures())
                 targets("worklets")
             }
         }
@@ -240,20 +256,18 @@ android {
     packagingOptions {
         // For some reason gradle only complains about the duplicated version of librrc_root and libreact_render libraries
         // while there are more libraries copied in intermediates folder of the lib build directory, we exclude
-        // only the ones that make the build fail (ideally we should only include libreanimated but we
+        // only the ones that make the build fail (ideally we should only include libworklets but we
         // are only allowed to specify exclude patterns)
-        excludes = [
-                "META-INF",
-                "META-INF/**",
-                "**/libc++_shared.so",
-                "**/libfbjni.so",
-                "**/libjsi.so",
-                "**/libhermes.so",
-                "**/libhermesvm.so",
-                "**/libhermestooling.so",
-                "**/libreactnative.so",
-                "**/libjscexecutor.so",
-        ]
+        excludes = ["META-INF",
+                    "META-INF/**",
+                    "**/libc++_shared.so",
+                    "**/libfbjni.so",
+                    "**/libjsi.so",
+                    "**/libhermes.so",
+                    "**/libhermesvm.so",
+                    "**/libhermestooling.so",
+                    "**/libreactnative.so",
+                    "**/libjscexecutor.so",]
     }
     compileOptions {
         sourceCompatibility JavaVersion.VERSION_17
@@ -262,16 +276,21 @@ android {
     sourceSets {
         main {
             java {
-                if (BUNDLE_MODE) {
-                    srcDirs += "src/experimentalBundling"
+                if (FETCH_PREVIEW_ENABLED) {
+                    srcDirs += "src/networking"
                 } else {
-                    srcDirs += "src/legacyBundling"
+                    srcDirs += "src/no-networking"
                 }
             }
         }
     }
-    tasks.withType(ExternalNativeBuildJsonTask) {
-        compileTask ->
+    if(project != rootProject) {
+        kotlinOptions {
+            jvmTarget = '17'
+        }
+    }
+    tasks.withType(ExternalNativeBuildJsonTask).tap {
+        configureEach { compileTask ->
             compileTask.doLast {
                 if (!IS_REANIMATED_EXAMPLE_APP) {
                     return
@@ -284,6 +303,7 @@ android {
 
                 println("Generated clangd metadata.")
             }
+        }
     }
 }
 
@@ -293,7 +313,7 @@ def validateReactNativeVersionResult = providers.exec {
     ignoreExitValue = true
 }
 
-task assertMinimalReactNativeVersionTask {
+tasks.register('assertMinimalReactNativeVersionTask') {
     doFirst {
         if (validateReactNativeVersionResult.getResult().get().exitValue != 0) {
             throw new GradleException(validateReactNativeVersionResult.getStandardError().getAsText().get().trim())
@@ -303,7 +323,7 @@ task assertMinimalReactNativeVersionTask {
 
 preBuild.dependsOn(assertMinimalReactNativeVersionTask)
 
-task assertNewArchitectureEnabledTask {
+tasks.register('assertNewArchitectureEnabledTask') {
     onlyIf { !IS_NEW_ARCHITECTURE_ENABLED }
     doFirst {
         throw new GradleException("[Worklets] Worklets require new architecture to be enabled. Please enable it by setting `newArchEnabled` to `true` in `gradle.properties`.")
@@ -312,17 +332,25 @@ task assertNewArchitectureEnabledTask {
 
 preBuild.dependsOn(assertNewArchitectureEnabledTask)
 
-task prepareWorkletsHeadersForPrefabs(type: Copy) {
+tasks.register('prepareWorkletsHeadersForPrefabs', Copy) {
     from("$projectDir/src/main/cpp")
     from("$projectDir/../Common/cpp")
     include("worklets/**/*.h")
-    into(workletsPrefabHeadersDir)
+    into(workletsPrefabHeadersDir.absolutePath)
+}
+
+interface FSService {
+    @Inject
+    FileSystemOperations getFs()
 }
 
-task cleanCmakeCache() {
-    tasks.getByName("clean").dependsOn(cleanCmakeCache)
+tasks.register('cleanCMakeCache') {
+    def fsProvider = project.objects.newInstance(FSService)
+    def cxxDir = file("${projectDir}/.cxx")
     doFirst {
-        delete "${projectDir}/.cxx"
+        fsProvider.fs.delete {
+            delete cxxDir
+        }
     }
 }
 
@@ -333,13 +361,21 @@ repositories {
 
 dependencies {
     implementation "com.facebook.yoga:proguard-annotations:1.19.0"
-    implementation "androidx.transition:transition:1.1.0"
-    implementation "androidx.core:core:1.6.0"
+    implementation "androidx.transition:transition:1.6.0"
+    implementation "androidx.core:core:1.15.0"
 
     implementation "com.facebook.react:react-android" // version substituted by RNGP
+    implementation "androidx.core:core-ktx:1.17.0"
     if (JS_RUNTIME == "hermes") {
         implementation "com.facebook.react:hermes-android" // version substituted by RNGP
     }
 }
 
 preBuild.dependsOn(prepareWorkletsHeadersForPrefabs)
+
+afterEvaluate {
+    tasks.named("clean") {
+        it.finalizedBy(cleanCMakeCache)
+    }
+}
+

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

@@ -0,0 +1,67 @@
+/**
+ * Based on
+ * https://github.com/facebook/react-native/blob/main/packages/react-native/ReactAndroid/src/main/jni/react/jni/JSLoader.cpp
+ */
+
+#include <cxxreact/JSBigString.h>
+#include <cxxreact/RecoverableError.h>
+#include <worklets/Tools/ScriptBuffer.h>
+#include <worklets/android/JScriptBufferWrapper.h>
+
+#include <utility>
+
+namespace worklets {
+
+using namespace facebook::jni;
+
+jni::local_ref<JScriptBufferWrapper::jhybriddata> JScriptBufferWrapper::initHybridFromAssets(
+    jni::alias_ref<jhybridobject> jThis, // NOLINT //(performance-unnecessary-value-param)
+    jni::alias_ref<JAssetManager::javaobject> assetManager, // NOLINT //(performance-unnecessary-value-param)
+    const std::string &sourceURL) {
+  auto manager = extractAssetManager(assetManager);
+  auto bigString = loadScriptFromAssets(manager, sourceURL);
+  auto script = std::make_shared<ScriptBuffer>(std::move(bigString));
+  return makeCxxInstance(std::move(script), sourceURL);
+}
+
+jni::local_ref<JScriptBufferWrapper::jhybriddata> JScriptBufferWrapper::initHybridFromFile(
+    jni::alias_ref<jhybridobject> jThis, // NOLINT //(performance-unnecessary-value-param)
+    const std::string &fileName) {
+  std::shared_ptr<const ScriptBuffer> script;
+  RecoverableError::runRethrowingAsRecoverable<std::system_error>([&fileName, &script]() {
+    auto bigString = JSBigFileString::fromPath(fileName);
+    script = std::make_shared<ScriptBuffer>(std::move(bigString));
+  });
+  return makeCxxInstance(std::move(script), fileName);
+}
+
+jni::local_ref<JScriptBufferWrapper::jhybriddata> JScriptBufferWrapper::initHybridFromString(
+    jni::alias_ref<jhybridobject> jThis, // NOLINT //(performance-unnecessary-value-param)
+    const std::string &scriptStr,
+    const std::string &sourceURL) {
+  auto bigString = std::make_shared<JSBigStdString>(scriptStr);
+  auto script = std::make_shared<ScriptBuffer>(std::move(bigString));
+  return makeCxxInstance(std::move(script), sourceURL);
+}
+
+JScriptBufferWrapper::JScriptBufferWrapper(
+    const std::shared_ptr<const ScriptBuffer> &script,
+    const std::string &sourceUrl)
+    : script_(script), sourceUrl_(sourceUrl) {}
+
+std::shared_ptr<const ScriptBuffer> JScriptBufferWrapper::getScript() const {
+  return script_;
+}
+
+std::string JScriptBufferWrapper::getSourceUrl() const {
+  return sourceUrl_;
+}
+
+void JScriptBufferWrapper::registerNatives() {
+  registerHybrid({
+      makeNativeMethod("initHybridFromAssets", JScriptBufferWrapper::initHybridFromAssets),
+      makeNativeMethod("initHybridFromFile", JScriptBufferWrapper::initHybridFromFile),
+      makeNativeMethod("initHybridFromString", JScriptBufferWrapper::initHybridFromString),
+  });
+}
+} // namespace worklets

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

@@ -0,0 +1,48 @@
+#pragma once
+
+#include <fbjni/fbjni.h>
+#include <jsireact/JSIExecutor.h>
+#include <react/jni/JSLoader.h>
+#include <worklets/Tools/ScriptBuffer.h>
+
+#include <memory>
+#include <string>
+
+namespace worklets {
+
+using namespace facebook;
+using namespace facebook::react;
+
+/**
+ * JScriptBufferWrapper is a JNI wrapper class that holds a ScriptBuffer containing 
+ * JavaScript code and its source URL, to be evaluated on a WorkletRuntime.
+ */
+class JScriptBufferWrapper : public jni::HybridClass<JScriptBufferWrapper> {
+ public:
+  constexpr static const char *const kJavaDescriptor = "Lcom/swmansion/worklets/ScriptBufferWrapper;";
+
+  static void registerNatives();
+
+  [[nodiscard]] std::shared_ptr<const ScriptBuffer> getScript() const;
+  [[nodiscard]] std::string getSourceUrl() const;
+
+ private:
+  static jni::local_ref<JScriptBufferWrapper::jhybriddata> initHybridFromAssets(
+      jni::alias_ref<jhybridobject> jThis,
+      jni::alias_ref<JAssetManager::javaobject> assetManager,
+      const std::string &assetURL);
+  static jni::local_ref<JScriptBufferWrapper::jhybriddata> initHybridFromFile(
+      jni::alias_ref<jhybridobject> jThis,
+      const std::string &fileName);
+  static jni::local_ref<JScriptBufferWrapper::jhybriddata>
+  initHybridFromString(jni::alias_ref<jhybridobject> jThis, const std::string &script, const std::string &sourceURL);
+
+  friend HybridBase;
+
+  explicit JScriptBufferWrapper(const std::shared_ptr<const ScriptBuffer> &script, const std::string &sourceUrl);
+
+  const std::shared_ptr<const ScriptBuffer> script_;
+  const std::string sourceUrl_;
+};
+
+} // namespace worklets

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

@@ -0,0 +1,52 @@
+#if defined(WORKLETS_BUNDLE_MODE_ENABLED) && defined(WORKLETS_FETCH_PREVIEW_ENABLED)
+
+#include <jsi/JSIDynamic.h>
+#include <jsi/jsi.h>
+#include <worklets/android/JWorkletRuntimeWrapper.h>
+
+#include <utility>
+#include <vector>
+
+namespace worklets {
+
+using namespace facebook::jni;
+
+local_ref<JWorkletRuntimeWrapper::JavaPart> JWorkletRuntimeWrapper::makeJWorkletRuntimeWrapper(
+    std::shared_ptr<WorkletRuntime> workletRuntime) {
+  return JWorkletRuntimeWrapper::newObjectCxxArgs(std::move(workletRuntime), workletRuntime->getRuntimeId());
+}
+
+JWorkletRuntimeWrapper::JWorkletRuntimeWrapper(std::shared_ptr<WorkletRuntime> workletRuntime, uint64_t runtimeId)
+    : workletRuntime_(std::move(workletRuntime)) {}
+
+void JWorkletRuntimeWrapper::cxxEmitDeviceEvent(
+    jni::alias_ref<WritableNativeArray::javaobject> params // NOLINT //(performance-unnecessary-value-param
+) {
+  workletRuntime_->schedule([params = params->cthis()->consume()](jsi::Runtime &rt) {
+    facebook::jsi::Value emitter = rt.global().getProperty(rt, "__rctDeviceEventEmitter");
+    if (!emitter.isUndefined()) {
+      facebook::jsi::Object emitterObject = emitter.asObject(rt);
+      facebook::jsi::Function emitFunction = emitterObject.getPropertyAsFunction(rt, "emit");
+      std::vector<jsi::Value> jsArgs;
+      for (auto &param : params) {
+        jsArgs.push_back(jsi::valueFromDynamic(rt, param));
+      }
+
+      emitFunction.callWithThis(rt, emitterObject, static_cast<const jsi::Value *>(jsArgs.data()), jsArgs.size());
+    }
+  });
+}
+
+int JWorkletRuntimeWrapper::cxxGetRuntimeId() {
+  return static_cast<int>(workletRuntime_->getRuntimeId());
+}
+
+void JWorkletRuntimeWrapper::registerNatives() {
+  javaClassStatic()->registerNatives({});
+  registerHybrid(
+      {makeNativeMethod("cxxEmitDeviceEvent", JWorkletRuntimeWrapper::cxxEmitDeviceEvent),
+       makeNativeMethod("cxxGetRuntimeId", JWorkletRuntimeWrapper::cxxGetRuntimeId)});
+}
+} // namespace worklets
+
+#endif // defined(WORKLETS_BUNDLE_MODE_ENABLED) && defined(WORKLETS_FETCH_PREVIEW_ENABLED)

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

@@ -0,0 +1,43 @@
+#pragma once
+
+#if defined(WORKLETS_BUNDLE_MODE_ENABLED) && defined(WORKLETS_FETCH_PREVIEW_ENABLED)
+
+#include <fbjni/fbjni.h>
+#include <react/jni/ReadableNativeArray.h>
+#include <react/jni/WritableNativeArray.h>
+#include <worklets/WorkletRuntime/WorkletRuntime.h>
+
+#include <memory>
+
+namespace worklets {
+
+using namespace facebook;
+using namespace facebook::react;
+using namespace facebook::jni;
+
+/**
+    * JNI wrapper around WorkletRuntime to expose its methods to Java.
+ */
+class JWorkletRuntimeWrapper : public jni::HybridClass<JWorkletRuntimeWrapper> {
+ public:
+  constexpr static const char *const kJavaDescriptor = "Lcom/swmansion/worklets/WorkletRuntimeWrapper;";
+
+  static local_ref<JWorkletRuntimeWrapper::JavaPart> makeJWorkletRuntimeWrapper(
+      std::shared_ptr<WorkletRuntime> workletRuntime);
+
+  static void registerNatives();
+
+  void cxxEmitDeviceEvent(jni::alias_ref<WritableNativeArray::javaobject> params);
+  int cxxGetRuntimeId();
+
+ private:
+  friend HybridBase;
+
+  JWorkletRuntimeWrapper(std::shared_ptr<WorkletRuntime> workletRuntime, uint64_t runtimeId);
+
+  const std::shared_ptr<WorkletRuntime> workletRuntime_;
+};
+
+} // namespace worklets
+
+#endif // defined(WORKLETS_BUNDLE_MODE_ENABLED) && defined(WORKLETS_FETCH_PREVIEW_ENABLED)