@amazon-devices/react-native-worklets 1.0.0-rn-83

package/android/src/experimentalBundling/com/swmansion/worklets/WorkletsModule.java

@@ -0,0 +1,149 @@
+package com.swmansion.worklets;
+
+import androidx.annotation.OptIn;
+import com.facebook.jni.HybridData;
+import com.facebook.proguard.annotations.DoNotStrip;
+import com.facebook.react.bridge.BundleConsumer;
+import com.facebook.react.bridge.LifecycleEventListener;
+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.BigStringBufferWrapper;
+import com.facebook.react.module.annotations.ReactModule;
+import com.facebook.react.turbomodule.core.CallInvokerHolderImpl;
+import com.facebook.soloader.SoLoader;
+import com.swmansion.worklets.runloop.AnimationFrameCallback;
+import com.swmansion.worklets.runloop.AnimationFrameQueue;
+import java.util.Objects;
+import java.util.concurrent.atomic.AtomicBoolean;
+
+@SuppressWarnings("JavaJniMissingFunction")
+@ReactModule(name = WorkletsModule.NAME)
+public class WorkletsModule extends NativeWorkletsModuleSpec
+    implements LifecycleEventListener, BundleConsumer {
+  static {
+    SoLoader.loadLibrary("worklets");
+  }
+
+  @DoNotStrip
+  @SuppressWarnings("unused")
+  private HybridData mHybridData;
+
+  @SuppressWarnings("unused")
+  protected HybridData getHybridData() {
+    return mHybridData;
+  }
+
+  private final WorkletsMessageQueueThread mMessageQueueThread = new WorkletsMessageQueueThread();
+  private final AndroidUIScheduler mAndroidUIScheduler;
+  private final AnimationFrameQueue mAnimationFrameQueue;
+  private boolean mSlowAnimationsEnabled;
+  private BigStringBufferWrapper mScriptWrapper = null;
+  private String mSourceURL = null;
+
+  @Override
+  public void setScriptWrapper(BigStringBufferWrapper scriptWrapper) {
+    mScriptWrapper = scriptWrapper;
+  }
+
+  @Override
+  public void setSourceURL(String sourceURL) {
+    mSourceURL = sourceURL;
+  }
+
+  /**
+   * Invalidating concurrently could be fatal. It shouldn't happen in a normal flow, but it doesn't
+   * cost us much to add synchronization for extra safety.
+   */
+  private final AtomicBoolean mInvalidated = new AtomicBoolean(false);
+
+  @OptIn(markerClass = FrameworkAPI.class)
+  private native HybridData initHybrid(
+      long jsContext,
+      MessageQueueThread messageQueueThread,
+      CallInvokerHolderImpl jsCallInvokerHolder,
+      AndroidUIScheduler androidUIScheduler,
+      BigStringBufferWrapper scriptWrapper,
+      String sourceURL);
+
+  public WorkletsModule(ReactApplicationContext reactContext) {
+    super(reactContext);
+
+    if (!BuildConfig.BUNDLE_MODE) {
+      reactContext.assertOnJSQueueThread();
+    }
+
+    mAndroidUIScheduler = new AndroidUIScheduler(reactContext);
+    mAnimationFrameQueue = new AnimationFrameQueue(reactContext);
+  }
+
+  @OptIn(markerClass = FrameworkAPI.class)
+  @ReactMethod(isBlockingSynchronousMethod = true)
+  public boolean installTurboModule() {
+    var context = getReactApplicationContext();
+
+    if (!BuildConfig.BUNDLE_MODE) {
+      context.assertOnNativeModulesQueueThread();
+    }
+
+    var jsContext = Objects.requireNonNull(context.getJavaScriptContextHolder()).get();
+    var jsCallInvokerHolder = JSCallInvokerResolver.getJSCallInvokerHolder(context);
+
+    mHybridData =
+        initHybrid(
+            jsContext,
+            mMessageQueueThread,
+            jsCallInvokerHolder,
+            mAndroidUIScheduler,
+            mScriptWrapper,
+            mSourceURL);
+    return true;
+  }
+
+  public void requestAnimationFrame(AnimationFrameCallback animationFrameCallback) {
+    mAnimationFrameQueue.requestAnimationFrame(animationFrameCallback);
+  }
+
+  /**
+   * @noinspection unused
+   */
+  @DoNotStrip
+  public boolean isOnJSQueueThread() {
+    return getReactApplicationContext().isOnJSQueueThread();
+  }
+
+  public void toggleSlowAnimations() {
+    final int ANIMATIONS_DRAG_FACTOR = 10;
+    mSlowAnimationsEnabled = !mSlowAnimationsEnabled;
+    mAnimationFrameQueue.enableSlowAnimations(mSlowAnimationsEnabled, ANIMATIONS_DRAG_FACTOR);
+  }
+
+  public void invalidate() {
+    if (mInvalidated.getAndSet(true)) {
+      return;
+    }
+    if (mHybridData != null && mHybridData.isValid()) {
+      // We have to destroy extra runtimes when invalidate is called. If we clean
+      // it up later instead there's a chance the runtime will retain references
+      // to invalidated memory and will crash on its destruction.
+      invalidateCpp();
+    }
+    mAndroidUIScheduler.deactivate();
+  }
+
+  private native void invalidateCpp();
+
+  @Override
+  public void onHostResume() {
+    mAnimationFrameQueue.resume();
+  }
+
+  @Override
+  public void onHostPause() {
+    mAnimationFrameQueue.pause();
+  }
+
+  @Override
+  public void onHostDestroy() {}
+}

package/android/src/legacyBundling/com/swmansion/worklets/WorkletsModule.java

@@ -0,0 +1,122 @@
+package com.swmansion.worklets;
+
+import androidx.annotation.OptIn;
+import com.facebook.jni.HybridData;
+import com.facebook.proguard.annotations.DoNotStrip;
+import com.facebook.react.bridge.LifecycleEventListener;
+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.module.annotations.ReactModule;
+import com.facebook.react.turbomodule.core.CallInvokerHolderImpl;
+import com.facebook.soloader.SoLoader;
+import com.swmansion.worklets.runloop.AnimationFrameCallback;
+import com.swmansion.worklets.runloop.AnimationFrameQueue;
+import java.util.Objects;
+import java.util.concurrent.atomic.AtomicBoolean;
+
+@SuppressWarnings("JavaJniMissingFunction")
+@ReactModule(name = WorkletsModule.NAME)
+public class WorkletsModule extends NativeWorkletsModuleSpec implements LifecycleEventListener {
+  static {
+    SoLoader.loadLibrary("worklets");
+  }
+
+  @DoNotStrip
+  @SuppressWarnings("unused")
+  private HybridData mHybridData;
+
+  @SuppressWarnings("unused")
+  protected HybridData getHybridData() {
+    return mHybridData;
+  }
+
+  private final WorkletsMessageQueueThread mMessageQueueThread = new WorkletsMessageQueueThread();
+  private final AndroidUIScheduler mAndroidUIScheduler;
+  private final AnimationFrameQueue mAnimationFrameQueue;
+  private boolean mSlowAnimationsEnabled;
+
+  /**
+   * Invalidating concurrently could be fatal. It shouldn't happen in a normal flow, but it doesn't
+   * cost us much to add synchronization for extra safety.
+   */
+  private final AtomicBoolean mInvalidated = new AtomicBoolean(false);
+
+  @OptIn(markerClass = FrameworkAPI.class)
+  private native HybridData initHybrid(
+      long jsContext,
+      MessageQueueThread messageQueueThread,
+      CallInvokerHolderImpl jsCallInvokerHolder,
+      AndroidUIScheduler androidUIScheduler);
+
+  public WorkletsModule(ReactApplicationContext reactContext) {
+    super(reactContext);
+
+    reactContext.assertOnJSQueueThread();
+
+    mAndroidUIScheduler = new AndroidUIScheduler(reactContext);
+    mAnimationFrameQueue = new AnimationFrameQueue(reactContext);
+  }
+
+  @OptIn(markerClass = FrameworkAPI.class)
+  @ReactMethod(isBlockingSynchronousMethod = true)
+  public boolean installTurboModule() {
+    var context = getReactApplicationContext();
+
+    context.assertOnJSQueueThread();
+
+    var jsContext = Objects.requireNonNull(context.getJavaScriptContextHolder()).get();
+    var jsCallInvokerHolder = JSCallInvokerResolver.getJSCallInvokerHolder(context);
+
+    mHybridData =
+        initHybrid(jsContext, mMessageQueueThread, jsCallInvokerHolder, mAndroidUIScheduler);
+    return true;
+  }
+
+  public void requestAnimationFrame(AnimationFrameCallback animationFrameCallback) {
+    mAnimationFrameQueue.requestAnimationFrame(animationFrameCallback);
+  }
+
+  /**
+   * @noinspection unused
+   */
+  @DoNotStrip
+  public boolean isOnJSQueueThread() {
+    return getReactApplicationContext().isOnJSQueueThread();
+  }
+
+  public void toggleSlowAnimations() {
+    final int ANIMATIONS_DRAG_FACTOR = 10;
+    mSlowAnimationsEnabled = !mSlowAnimationsEnabled;
+    mAnimationFrameQueue.enableSlowAnimations(mSlowAnimationsEnabled, ANIMATIONS_DRAG_FACTOR);
+  }
+
+  public void invalidate() {
+    if (mInvalidated.getAndSet(true)) {
+      return;
+    }
+    if (mHybridData != null && mHybridData.isValid()) {
+      // We have to destroy extra runtimes when invalidate is called. If we clean
+      // it up later instead there's a chance the runtime will retain references
+      // to invalidated memory and will crash on its destruction.
+      invalidateCpp();
+    }
+    mAndroidUIScheduler.deactivate();
+  }
+
+  private native void invalidateCpp();
+
+  @Override
+  public void onHostResume() {
+    mAnimationFrameQueue.resume();
+  }
+
+  @Override
+  public void onHostPause() {
+    mAnimationFrameQueue.pause();
+  }
+
+  @Override
+  public void onHostDestroy() {}
+}

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/worklets/android/AndroidUIScheduler.cpp

@@ -0,0 +1,63 @@
+#include <worklets/android/AndroidUIScheduler.h>
+
+namespace worklets {
+
+using namespace facebook;
+using namespace react;
+
+class UISchedulerWrapper : public UIScheduler {
+ private:
+  jni::global_ref<AndroidUIScheduler::javaobject> androidUiScheduler_;
+
+ public:
+  explicit UISchedulerWrapper(
+      jni::global_ref<AndroidUIScheduler::javaobject> androidUiScheduler)
+      : androidUiScheduler_(androidUiScheduler) {}
+
+  void scheduleOnUI(std::function<void()> job) override {
+    UIScheduler::scheduleOnUI(job);
+    if (!scheduledOnUI_) {
+      scheduledOnUI_ = true;
+      androidUiScheduler_->cthis()->scheduleTriggerOnUI();
+    }
+  }
+};
+
+AndroidUIScheduler::AndroidUIScheduler(
+    jni::alias_ref<AndroidUIScheduler::javaobject> jThis)
+    : javaPart_(jni::make_global(jThis)),
+      uiScheduler_(
+          std::make_shared<UISchedulerWrapper>(jni::make_global(jThis))) {}
+
+jni::local_ref<AndroidUIScheduler::jhybriddata> AndroidUIScheduler::initHybrid(
+    jni::alias_ref<jhybridobject> jThis) {
+  return makeCxxInstance(jThis);
+}
+
+void AndroidUIScheduler::triggerUI() {
+  if (!uiScheduler_) {
+    return;
+  }
+  uiScheduler_->triggerUI();
+}
+
+void AndroidUIScheduler::scheduleTriggerOnUI() {
+  static const auto method =
+      javaPart_->getClass()->getMethod<void()>("scheduleTriggerOnUI");
+  method(javaPart_.get());
+}
+
+void AndroidUIScheduler::invalidate() {
+  javaPart_ = nullptr;
+  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,43 @@
+#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);
+  static void registerNatives();
+
+  std::shared_ptr<UIScheduler> getUIScheduler() {
+    return uiScheduler_;
+  }
+
+  void scheduleTriggerOnUI();
+
+ private:
+  friend HybridBase;
+
+  void triggerUI();
+
+  void invalidate();
+
+  jni::global_ref<AndroidUIScheduler::javaobject> javaPart_;
+  std::shared_ptr<UIScheduler> uiScheduler_;
+
+  explicit AndroidUIScheduler(
+      jni::alias_ref<AndroidUIScheduler::jhybridobject> jThis);
+};
+
+} // namespace worklets

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

@@ -0,0 +1,34 @@
+#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/PlatformLogger.cpp

@@ -0,0 +1,29 @@
+#include <android/log.h>
+
+#include <worklets/Tools/PlatformLogger.h>
+
+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

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

@@ -0,0 +1,115 @@
+#include <worklets/NativeModules/JSIWorkletsModuleProxy.h>
+#include <worklets/Tools/WorkletsJSIUtils.h>
+#include <worklets/WorkletRuntime/RNRuntimeWorkletDecorator.h>
+#include <worklets/android/AnimationFrameCallback.h>
+#include <worklets/android/WorkletsModule.h>
+
+#include <memory>
+#include <utility>
+
+namespace worklets {
+
+using namespace facebook;
+using namespace react;
+
+WorkletsModule::WorkletsModule(
+    jni::alias_ref<jhybridobject> jThis,
+    jsi::Runtime *rnRuntime,
+    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 BigStringBuffer> &script,
+    const std::string &sourceURL)
+    : javaPart_(jni::make_global(jThis)),
+      rnRuntime_(rnRuntime),
+      workletsModuleProxy_(std::make_shared<WorkletsModuleProxy>(
+          *rnRuntime,
+          std::make_shared<JMessageQueueThread>(messageQueueThread),
+          jsCallInvoker,
+          uiScheduler,
+          getIsOnJSQueueThread(),
+          getForwardedRequestAnimationFrame(),
+          script,
+          sourceURL)) {
+  auto jsiWorkletsModuleProxy =
+      workletsModuleProxy_->createJSIWorkletsModuleProxy();
+  auto optimizedJsiWorkletsModuleProxy = jsi_utils::optimizedFromHostObject(
+      *rnRuntime_,
+      std::static_pointer_cast<jsi::HostObject>(
+          std::move(jsiWorkletsModuleProxy)));
+  RNRuntimeWorkletDecorator::decorate(
+      *rnRuntime_,
+      std::move(optimizedJsiWorkletsModuleProxy),
+      workletsModuleProxy_->getJSLogger());
+}
+
+jni::local_ref<WorkletsModule::jhybriddata> WorkletsModule::initHybrid(
+    jni::alias_ref<jhybridobject> jThis,
+    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::BigStringBufferWrapper::javaobject>
+        scriptWrapper,
+    const std::string &sourceURL
+#endif // WORKLETS_BUNDLE_MODE
+) {
+  auto jsCallInvoker = jsCallInvokerHolder->cthis()->getCallInvoker();
+  auto rnRuntime = reinterpret_cast<jsi::Runtime *>(jsContext);
+  auto uiScheduler = androidUIScheduler->cthis()->getUIScheduler();
+
+  std::shared_ptr<const BigStringBuffer> script = nullptr;
+#ifdef WORKLETS_BUNDLE_MODE
+  script = scriptWrapper->cthis()->getScript();
+#else
+  const auto sourceURL = std::string{};
+#endif // WORKLETS_BUNDLE_MODE
+
+  return makeCxxInstance(
+      jThis,
+      rnRuntime,
+      messageQueueThread,
+      jsCallInvoker,
+      uiScheduler,
+      script,
+      sourceURL);
+}
+
+std::function<void(std::function<void(const double)>)>
+WorkletsModule::getForwardedRequestAnimationFrame() {
+  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());
+  };
+}
+
+std::function<bool()> WorkletsModule::getIsOnJSQueueThread() {
+  return [javaPart = javaPart_]() -> bool {
+    return javaPart->getClass()
+        ->getMethod<jboolean()>("isOnJSQueueThread")
+        .operator()(javaPart);
+  };
+}
+
+void WorkletsModule::invalidateCpp() {
+  javaPart_.reset();
+  workletsModuleProxy_.reset();
+}
+
+void WorkletsModule::registerNatives() {
+  registerHybrid({
+      makeNativeMethod("initHybrid", WorkletsModule::initHybrid),
+      makeNativeMethod("invalidateCpp", WorkletsModule::invalidateCpp),
+  });
+}
+
+} // namespace worklets

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

@@ -0,0 +1,78 @@
+#pragma once
+
+#include <ReactCommon/CallInvokerHolder.h>
+#include <fbjni/fbjni.h>
+#include <jsi/jsi.h>
+#include <jsireact/JSIExecutor.h>
+#include <react/jni/JMessageQueueThread.h>
+#ifdef WORKLETS_BUNDLE_MODE
+#include <react/fabric/BigStringBufferWrapper.h>
+#endif // WORKLETS_BUNDLE_MODE
+
+#include <worklets/NativeModules/WorkletsModuleProxy.h>
+#include <worklets/android/AndroidUIScheduler.h>
+
+#include <memory>
+#include <string>
+
+namespace worklets {
+
+using namespace facebook;
+using namespace facebook::jni;
+
+class WorkletsModule : public jni::HybridClass<WorkletsModule> {
+ public:
+  static auto constexpr kJavaDescriptor =
+      "Lcom/swmansion/worklets/WorkletsModule;";
+
+  static jni::local_ref<jhybriddata> initHybrid(
+      jni::alias_ref<jhybridobject> jThis,
+      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::BigStringBufferWrapper::javaobject>
+          scriptWrapper,
+      const std::string &sourceURL
+#endif // WORKLETS_BUNDLE_MODE
+  );
+
+  static void registerNatives();
+
+  inline std::shared_ptr<WorkletsModuleProxy> getWorkletsModuleProxy() {
+    return workletsModuleProxy_;
+  }
+
+ private:
+  explicit WorkletsModule(
+      jni::alias_ref<jhybridobject> jThis,
+      jsi::Runtime *rnRuntime,
+      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 BigStringBuffer> &script,
+      const std::string &sourceURL);
+
+  void invalidateCpp();
+
+  template <class Signature>
+  JMethod<Signature> getJniMethod(std::string const &methodName) {
+    return javaPart_->getClass()->getMethod<Signature>(methodName.c_str());
+  }
+
+  std::function<void(std::function<void(const double)>)>
+  getForwardedRequestAnimationFrame();
+
+  std::function<bool()> getIsOnJSQueueThread();
+
+  friend HybridBase;
+  jni::global_ref<WorkletsModule::javaobject> javaPart_;
+  jsi::Runtime *rnRuntime_;
+  std::shared_ptr<WorkletsModuleProxy> workletsModuleProxy_;
+};
+
+} // namespace worklets

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

@@ -0,0 +1,13 @@
+#include <fbjni/fbjni.h>
+
+#include <worklets/android/AndroidUIScheduler.h>
+#include <worklets/android/AnimationFrameCallback.h>
+#include <worklets/android/WorkletsModule.h>
+
+JNIEXPORT jint JNICALL JNI_OnLoad(JavaVM *vm, void *) {
+  return facebook::jni::initialize(vm, [] {
+    worklets::WorkletsModule::registerNatives();
+    worklets::AndroidUIScheduler::registerNatives();
+    worklets::AnimationFrameCallback::registerNatives();
+  });
+}