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

package/android/generate-stub-pch.gradle.kts

@@ -0,0 +1,84 @@
+import groovy.json.JsonSlurper
+
+// Workaround for Android Studio's C++ analyzer surfacing errors during Gradle
+// Sync when CMake's precompiled header binary (`cmake_pch.hxx.pch`, generated
+// from `WorkletsPCH.h`) hasn't been built yet. The project compiles fine,
+// but on a clean sync the IDE can't index sources without the PCH binary. See
+// the underlying issue: https://issuetracker.google.com/issues/187448826
+
+// Generates minimal stub `.pch` files from an empty header so the IDE's C++
+// engine doesn't fail during sync. The actual build regenerates the real PCH
+// files via ninja because we set each stub PCH's mtime older than its source
+// (`cmake_pch.hxx.cxx`).
+
+// Adapted from Expo's PR: https://github.com/expo/expo/pull/45921
+
+val cxxDir = project.file(".cxx")
+
+val generateStubPCHTask = tasks.register("generateStubPCH") {
+    dependsOn("configureCMakeDebug")
+    doLast {
+        if (!cxxDir.exists()) {
+            return@doLast
+        }
+        cxxDir.walkTopDown().forEach { file ->
+            if (file.name != "compile_commands.json") {
+                return@forEach
+            }
+            @Suppress("UNCHECKED_CAST")
+            val entries = JsonSlurper().parseText(file.readText()) as List<Map<String, Any>>
+            entries.forEach entry@{ entry ->
+                val entryFile = entry["file"] as String
+                if (!entryFile.endsWith("cmake_pch.hxx.cxx")) {
+                    return@entry
+                }
+                val pchFile = File(entryFile.substring(0, entryFile.length - ".cxx".length) + ".pch")
+                if (!pchFile.exists() || pchFile.length() == 0L) {
+                    pchFile.parentFile.mkdirs()
+
+                    val command = entry["command"] as String
+                    val compiler = command.split(" ").first()
+                    val target = Regex("""--target=\S+""").find(command)!!.value
+                    val sysroot = Regex("""--sysroot=\S+""").find(command)!!.value
+
+                    val stubHeader = File(pchFile.parentFile, "stub_pch.hxx")
+                    stubHeader.writeText("")
+
+                    val process = ProcessBuilder(
+                        compiler,
+                        target,
+                        sysroot,
+                        "-x", "c++-header",
+                        "-o", pchFile.absolutePath,
+                        stubHeader.absolutePath,
+                    )
+                        .directory(File(entry["directory"] as String))
+                        .redirectErrorStream(true)
+                        .start()
+                    process.outputStream.close()
+                    if (process.waitFor() != 0) {
+                        throw GradleException(
+                            "Stub PCH generation failed: ${process.inputStream.bufferedReader().readText()}",
+                        )
+                    }
+                }
+                // Ensure PCH is older than source so ninja rebuilds the real one during build
+                pchFile.setLastModified(File(entryFile).lastModified() - 1)
+            }
+        }
+    }
+}
+
+// Register `prepareKotlinBuildScriptModel` if absent (Android Studio sync needs it
+// to exist so the stub PCH generation runs) or configure it if some other plugin
+// already registered it (e.g. on CI, where re-registering throws `Cannot add task
+// 'prepareKotlinBuildScriptModel' as a task with that name already exists.`).
+if (tasks.findByName("prepareKotlinBuildScriptModel") == null) {
+    tasks.register("prepareKotlinBuildScriptModel") {
+        dependsOn(generateStubPCHTask)
+    }
+} else {
+    tasks.named("prepareKotlinBuildScriptModel") {
+        dependsOn(generateStubPCHTask)
+    }
+}

package/android/gradle.properties

@@ -0,0 +1,25 @@
+# Project-wide Gradle settings.
+
+# IDE (e.g. Android Studio) users:
+# Gradle settings configured through the IDE *will override*
+# any settings specified in this file.
+
+# For more details on how to configure your build environment visit
+# http://www.gradle.org/docs/current/userguide/build_environment.html
+
+# Specifies the JVM arguments used for the daemon process.
+# The setting is particularly useful for tweaking memory settings.
+# Default value: -Xmx10248m -XX:MaxPermSize=256m
+org.gradle.jvmargs=-Xmx2048m -XX:+HeapDumpOnOutOfMemoryError -Dfile.encoding=UTF-8 --add-exports jdk.compiler/com.sun.tools.javac.api=ALL-UNNAMED \
+  --add-exports jdk.compiler/com.sun.tools.javac.file=ALL-UNNAMED \
+  --add-exports jdk.compiler/com.sun.tools.javac.parser=ALL-UNNAMED \
+  --add-exports jdk.compiler/com.sun.tools.javac.tree=ALL-UNNAMED \
+  --add-exports jdk.compiler/com.sun.tools.javac.util=ALL-UNNAMED
+
+# When configured, Gradle will run in incubating parallel mode.
+# This option should only be used with decoupled projects. More details, visit
+# http://www.gradle.org/docs/current/userguide/multi_project_builds.html#sec:decoupled_projects
+# org.gradle.parallel=true
+
+android.useAndroidX=true
+android.enableJetifier=true

package/android/proguard-rules.pro

@@ -0,0 +1,3 @@
+-keep class com.swmansion.worklets.** { *; }
+-keep class com.facebook.react.turbomodule.** { *; }
+-keep class com.facebook.react.fabric.** { *; }

package/android/settings.gradle.kts

@@ -0,0 +1,21 @@
+pluginManagement {
+    repositories {
+        google()
+        mavenCentral()
+    }
+    resolutionStrategy {
+        eachPlugin {
+            if (requested.id.id.startsWith("com.android")) {
+                useModule("com.android.tools.build:gradle:8.13.1")
+            }
+            if (requested.id.id == "com.diffplug.spotless") {
+                useModule("com.diffplug.spotless:spotless-plugin-gradle:8.1.0")
+            }
+            if (requested.id.id.startsWith("org.jetbrains.kotlin")) {
+                useModule("org.jetbrains.kotlin:kotlin-gradle-plugin:2.1.20")
+            }
+        }
+    }
+}
+
+rootProject.name = "worklets"

package/android/src/main/AndroidManifest.xml

@@ -0,0 +1,2 @@
+<manifest xmlns:android="http://schemas.android.com/apk/res/android">
+</manifest>

package/android/src/main/cpp/WorkletsPCH.h

@@ -0,0 +1,26 @@
+#pragma once
+
+// IWYU pragma: begin_keep
+
+// C++ standard library
+#include <algorithm>
+#include <atomic>
+#include <functional>
+#include <map>
+#include <memory>
+#include <mutex>
+#include <optional>
+#include <string>
+#include <string_view>
+#include <type_traits>
+#include <unordered_map>
+#include <utility>
+#include <vector>
+
+// fbjni
+#include <fbjni/fbjni.h>
+
+// jsi
+#include <jsi/jsi.h>
+
+// IWYU pragma: end_keep

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

@@ -0,0 +1,66 @@
+#include <worklets/android/AndroidUIScheduler.h>
+
+#include <utility>
+
+namespace worklets {
+
+using namespace facebook;
+using namespace react;
+
+static thread_local bool tls_isOnUIThread = false;
+
+class UISchedulerWrapper : public UIScheduler {
+ private:
+  jni::global_ref<AndroidUIScheduler::javaobject> androidUiScheduler_;
+
+ public:
+  explicit UISchedulerWrapper(jni::global_ref<AndroidUIScheduler::javaobject> androidUiScheduler)
+      : androidUiScheduler_(std::move(androidUiScheduler)) {}
+
+  void scheduleOnUI(std::function<void()> job) override {
+    if (tls_isOnUIThread) {
+      job();
+      return;
+    }
+    UIScheduler::scheduleOnUI(job);
+    if (!scheduledOnUI_) {
+      scheduledOnUI_ = true;
+      static const auto method = androidUiScheduler_->getClass()->getMethod<void()>("scheduleTriggerOnUI");
+      method(androidUiScheduler_);
+    }
+  }
+
+  void triggerUI() override {
+    tls_isOnUIThread = true;
+    UIScheduler::triggerUI();
+  }
+};
+
+AndroidUIScheduler::AndroidUIScheduler(const jni::alias_ref<AndroidUIScheduler::jhybridobject> &jThis)
+    : uiScheduler_(std::make_shared<UISchedulerWrapper>(jni::make_global(jThis))) {}
+
+jni::local_ref<AndroidUIScheduler::jhybriddata> AndroidUIScheduler::initHybrid(
+    jni::alias_ref<jhybridobject> jThis) { // NOLINT //(performance-unnecessary-value-param)
+  return makeCxxInstance(jThis);
+}
+
+void AndroidUIScheduler::triggerUI() {
+  if (!uiScheduler_) {
+    return;
+  }
+  uiScheduler_->triggerUI();
+}
+
+void AndroidUIScheduler::invalidate() {
+  uiScheduler_.reset();
+}
+
+void AndroidUIScheduler::registerNatives() {
+  registerHybrid({
+      makeNativeMethod("initHybrid", AndroidUIScheduler::initHybrid),
+      makeNativeMethod("triggerUI", AndroidUIScheduler::triggerUI),
+      makeNativeMethod("invalidate", AndroidUIScheduler::invalidate),
+  });
+}
+
+} // namespace worklets

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

@@ -0,0 +1,38 @@
+#pragma once
+
+#include <worklets/Tools/UIScheduler.h>
+
+#include <fbjni/fbjni.h>
+#include <jsi/jsi.h>
+
+#include <memory>
+
+namespace worklets {
+
+using namespace facebook;
+using namespace worklets;
+
+class AndroidUIScheduler : public jni::HybridClass<AndroidUIScheduler> {
+ public:
+  static auto constexpr kJavaDescriptor = "Lcom/swmansion/worklets/AndroidUIScheduler;";
+  static jni::local_ref<jhybriddata> initHybrid(
+      jni::alias_ref<jhybridobject> jThis); // NOLINT //(performance-unnecessary-value-param)
+  static void registerNatives();
+
+  std::shared_ptr<UIScheduler> getUIScheduler() {
+    return uiScheduler_;
+  }
+
+ private:
+  friend HybridBase;
+
+  void triggerUI();
+
+  void invalidate();
+
+  std::shared_ptr<UIScheduler> uiScheduler_;
+
+  explicit AndroidUIScheduler(const jni::alias_ref<AndroidUIScheduler::jhybridobject> &jThis);
+};
+
+} // namespace worklets

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

@@ -0,0 +1,30 @@
+#pragma once
+
+#include <fbjni/fbjni.h>
+
+#include <utility>
+
+namespace worklets {
+
+class AnimationFrameCallback : public facebook::jni::HybridClass<AnimationFrameCallback> {
+ public:
+  static auto constexpr kJavaDescriptor = "Lcom/swmansion/worklets/runloop/AnimationFrameCallback;";
+
+  void onAnimationFrame(double timestampMs) {
+    callback_(timestampMs);
+  }
+
+  static void registerNatives() {
+    javaClassStatic()->registerNatives({
+        makeNativeMethod("onAnimationFrame", AnimationFrameCallback::onAnimationFrame),
+    });
+  }
+
+ private:
+  friend HybridBase;
+
+  explicit AnimationFrameCallback(std::function<void(const double)> callback) : callback_(std::move(callback)) {}
+
+  std::function<void(double)> callback_;
+};
+} // namespace worklets

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

@@ -0,0 +1,66 @@
+/**
+ * Based on
+ * https://github.com/facebook/react-native/blob/main/packages/react-native/ReactAndroid/src/main/jni/react/jni/JSLoader.cpp
+ */
+
+#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,51 @@
+#ifdef 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));
+}
+
+JWorkletRuntimeWrapper::JWorkletRuntimeWrapper(std::shared_ptr<WorkletRuntime> workletRuntime)
+    : 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() {
+  registerHybrid(
+      {makeNativeMethod("cxxEmitDeviceEvent", JWorkletRuntimeWrapper::cxxEmitDeviceEvent),
+       makeNativeMethod("cxxGetRuntimeId", JWorkletRuntimeWrapper::cxxGetRuntimeId)});
+}
+} // namespace worklets
+
+#endif // WORKLETS_FETCH_PREVIEW_ENABLED

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

@@ -0,0 +1,43 @@
+#pragma once
+
+#ifdef 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;
+
+  explicit JWorkletRuntimeWrapper(std::shared_ptr<WorkletRuntime> workletRuntime);
+
+  const std::shared_ptr<WorkletRuntime> workletRuntime_;
+};
+
+} // namespace worklets
+
+#endif // WORKLETS_FETCH_PREVIEW_ENABLED

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

@@ -0,0 +1,31 @@
+#include <android/log.h>
+
+#include <worklets/Tools/PlatformLogger.h>
+
+#include <string>
+
+constexpr const auto tag = "Worklets";
+
+namespace worklets {
+
+void PlatformLogger::log(const char *str) {
+  __android_log_print(ANDROID_LOG_VERBOSE, tag, "%s", str);
+}
+
+void PlatformLogger::log(const std::string &str) {
+  log(str.c_str());
+}
+
+void PlatformLogger::log(const double d) {
+  __android_log_print(ANDROID_LOG_VERBOSE, tag, "%f", d);
+}
+
+void PlatformLogger::log(const int i) {
+  __android_log_print(ANDROID_LOG_VERBOSE, tag, "%d", i);
+}
+
+void PlatformLogger::log(const bool b) {
+  log(b ? "true" : "false");
+}
+
+} // namespace worklets