react-native-worklets 0.0.1-alpha → 0.1.0

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

@@ -0,0 +1,72 @@
+package com.swmansion.worklets;
+
+import com.facebook.proguard.annotations.DoNotStrip;
+import com.facebook.react.bridge.queue.MessageQueueThread;
+import com.facebook.react.bridge.queue.MessageQueueThreadImpl;
+import com.facebook.react.bridge.queue.MessageQueueThreadPerfStats;
+import com.facebook.react.bridge.queue.MessageQueueThreadSpec;
+import java.lang.reflect.Field;
+import java.util.concurrent.Callable;
+import java.util.concurrent.Future;
+
+// This class is an almost exact copy of MessageQueueThreadImpl taken from here:
+// https://github.com/facebook/react-native/blob/main/packages/react-native/ReactAndroid/src/main/java/com/facebook/react/bridge/queue/MessageQueueThreadImpl.java
+// The only method that has changed is `quitSynchronous()` (see comment above
+// function implementation for details).
+@DoNotStrip
+public abstract class WorkletsMessageQueueThreadBase implements MessageQueueThread {
+  protected final MessageQueueThreadImpl messageQueueThread;
+
+  public WorkletsMessageQueueThreadBase() {
+    messageQueueThread =
+        MessageQueueThreadImpl.create(
+            MessageQueueThreadSpec.mainThreadSpec(),
+            exception -> {
+              throw new RuntimeException(exception);
+            });
+  }
+
+  @Override
+  public <T> Future<T> callOnQueue(Callable<T> callable) {
+    return messageQueueThread.callOnQueue(callable);
+  }
+
+  @Override
+  public boolean isOnThread() {
+    return messageQueueThread.isOnThread();
+  }
+
+  @Override
+  public void assertIsOnThread() {
+    messageQueueThread.assertIsOnThread();
+  }
+
+  @Override
+  public void assertIsOnThread(String s) {
+    messageQueueThread.assertIsOnThread(s);
+  }
+
+  // We don't want to quit the main looper (which is what MessageQueueThreadImpl would have done),
+  // but we still want to prevent anything else from executing.
+  @Override
+  public void quitSynchronous() {
+    try {
+      Field mIsFinished = messageQueueThread.getClass().getDeclaredField("mIsFinished");
+      mIsFinished.setAccessible(true);
+      mIsFinished.set(messageQueueThread, true);
+      mIsFinished.setAccessible(false);
+    } catch (NoSuchFieldException | IllegalAccessException e) {
+      e.printStackTrace();
+    }
+  }
+
+  @Override
+  public MessageQueueThreadPerfStats getPerfStats() {
+    return messageQueueThread.getPerfStats();
+  }
+
+  @Override
+  public void resetPerfStats() {
+    messageQueueThread.resetPerfStats();
+  }
+}

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

@@ -0,0 +1,106 @@
+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 java.util.Objects;
+
+/**
+ * @noinspection 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;
+
+  @OptIn(markerClass = FrameworkAPI.class)
+  private native HybridData initHybrid(
+      long jsContext,
+      String valueUnpackerCode,
+      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(String valueUnpackerCode) {
+    var context = getReactApplicationContext();
+    context.assertOnJSQueueThread();
+
+    var jsContext = Objects.requireNonNull(context.getJavaScriptContextHolder()).get();
+    var jsCallInvokerHolder = JSCallInvokerResolver.getJSCallInvokerHolder(context);
+
+    mHybridData =
+        initHybrid(
+            jsContext,
+            valueUnpackerCode,
+            mMessageQueueThread,
+            jsCallInvokerHolder,
+            mAndroidUIScheduler);
+    return true;
+  }
+
+  public void requestAnimationFrame(AnimationFrameCallback animationFrameCallback) {
+    mAnimationFrameQueue.requestAnimationFrame(animationFrameCallback);
+  }
+
+  public void toggleSlowAnimations() {
+    final int ANIMATIONS_DRAG_FACTOR = 10;
+    mSlowAnimationsEnabled = !mSlowAnimationsEnabled;
+    mAnimationFrameQueue.enableSlowAnimations(mSlowAnimationsEnabled, ANIMATIONS_DRAG_FACTOR);
+  }
+
+  public void invalidate() {
+    // 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/java/com/swmansion/worklets/WorkletsPackage.java

@@ -0,0 +1,49 @@
+package com.swmansion.worklets;
+
+import androidx.annotation.NonNull;
+import com.facebook.react.BaseReactPackage;
+import com.facebook.react.ReactPackage;
+import com.facebook.react.bridge.NativeModule;
+import com.facebook.react.bridge.ReactApplicationContext;
+import com.facebook.react.module.annotations.ReactModule;
+import com.facebook.react.module.annotations.ReactModuleList;
+import com.facebook.react.module.model.ReactModuleInfo;
+import com.facebook.react.module.model.ReactModuleInfoProvider;
+import java.util.HashMap;
+import java.util.Map;
+import java.util.Objects;
+
+@ReactModuleList(nativeModules = {WorkletsModule.class})
+public class WorkletsPackage extends BaseReactPackage implements ReactPackage {
+  @Override
+  public NativeModule getModule(
+      @NonNull String name, @NonNull ReactApplicationContext reactContext) {
+    return switch (name) {
+      case WorkletsModule.NAME -> new WorkletsModule(reactContext);
+      default -> null;
+    };
+  }
+
+  @Override
+  public ReactModuleInfoProvider getReactModuleInfoProvider() {
+    Class<? extends NativeModule>[] moduleList = new Class[] {WorkletsModule.class};
+
+    final Map<String, ReactModuleInfo> reactModuleInfoMap = new HashMap<>();
+    for (Class<? extends NativeModule> moduleClass : moduleList) {
+      ReactModule reactModule =
+          Objects.requireNonNull(moduleClass.getAnnotation(ReactModule.class));
+
+      reactModuleInfoMap.put(
+          reactModule.name(),
+          new ReactModuleInfo(
+              reactModule.name(),
+              moduleClass.getName(),
+              reactModule.canOverrideExistingModule(),
+              reactModule.needsEagerInit(),
+              reactModule.isCxxModule(),
+              BuildConfig.IS_NEW_ARCHITECTURE_ENABLED));
+    }
+
+    return () -> reactModuleInfoMap;
+  }
+}

package/android/src/paper/com/swmansion/worklets/NativeWorkletsModuleSpec.java

@@ -0,0 +1,26 @@
+package com.swmansion.worklets;
+
+import com.facebook.proguard.annotations.DoNotStrip;
+import com.facebook.react.bridge.ReactApplicationContext;
+import com.facebook.react.bridge.ReactContextBaseJavaModule;
+import com.facebook.react.bridge.ReactMethod;
+import com.facebook.react.turbomodule.core.interfaces.TurboModule;
+import javax.annotation.Nonnull;
+
+public abstract class NativeWorkletsModuleSpec extends ReactContextBaseJavaModule
+    implements TurboModule {
+  public static final String NAME = "WorkletsModule";
+
+  public NativeWorkletsModuleSpec(ReactApplicationContext reactContext) {
+    super(reactContext);
+  }
+
+  @Override
+  public @Nonnull String getName() {
+    return NAME;
+  }
+
+  @ReactMethod(isBlockingSynchronousMethod = true)
+  @DoNotStrip
+  public abstract boolean installTurboModule(String valueUnpackerCode);
+}

package/apple/worklets/apple/AnimationFrameQueue.h

@@ -0,0 +1,15 @@
+#if __cplusplus
+
+#import <worklets/apple/WorkletsDisplayLink.h>
+#import <functional>
+
+@interface AnimationFrameQueue : NSObject
+
+- (void)requestAnimationFrame:(std::function<void(double)>)callback;
+- (void)executeQueue:(WorkletsDisplayLink *)displayLink;
+
+- (void)invalidate;
+
+@end
+
+#endif // __cplusplus

package/apple/worklets/apple/AnimationFrameQueue.mm

@@ -0,0 +1,81 @@
+#import <worklets/apple/AnimationFrameQueue.h>
+#import <worklets/apple/AssertJavaScriptQueue.h>
+#import <worklets/apple/AssertTurboModuleManagerQueue.h>
+#import <worklets/apple/SlowAnimations.h>
+
+#import <React/RCTAssert.h>
+
+@implementation AnimationFrameQueue {
+  /* DisplayLink is thread safe. */
+  WorkletsDisplayLink *displayLink_;
+  std::vector<std::function<void(double)>> frameCallbacks_;
+  std::mutex callbacksMutex_;
+}
+
+typedef void (^AnimationFrameCallback)(WorkletsDisplayLink *displayLink);
+
+#pragma mark-- public
+
+- (instancetype)init
+{
+  AssertJavaScriptQueue();
+  displayLink_ = [WorkletsDisplayLink displayLinkWithTarget:self selector:@selector(executeQueue:)];
+#if TARGET_OS_OSX
+  // nothing
+#else // TARGET_OS_OSX
+  displayLink_.preferredFramesPerSecond = 120; // will fallback to 60 fps for devices without Pro Motion display
+#endif // TARGET_OS_OSX
+  [displayLink_ setPaused:TRUE];
+  [displayLink_ addToRunLoop:[NSRunLoop mainRunLoop] forMode:NSRunLoopCommonModes];
+  return self;
+}
+
+- (void)requestAnimationFrame:(std::function<void(double)>)callback
+{
+  {
+    std::lock_guard<std::mutex> lock(callbacksMutex_);
+    frameCallbacks_.push_back(callback);
+  }
+  [self scheduleQueueExecution];
+}
+
+- (void)invalidate
+{
+  AssertTurboModuleManagerQueue();
+  [displayLink_ invalidate];
+}
+
+#pragma mark-- private
+
+- (void)scheduleQueueExecution
+{
+  [displayLink_ setPaused:FALSE];
+}
+
+- (void)executeQueue:(WorkletsDisplayLink *)displayLink
+{
+  RCTAssertMainQueue();
+
+  auto frameCallbacks = [self pullCallbacks];
+  [displayLink_ setPaused:TRUE];
+
+#if TARGET_OS_OSX
+  auto targetTimestamp = displayLink.timestamp + displayLink.duration;
+#else // TARGET_OS_OSX
+  auto targetTimestamp = displayLink.targetTimestamp;
+#endif // TARGET_OS_OSX
+  targetTimestamp = worklets::calculateTimestampWithSlowAnimations(targetTimestamp);
+
+  for (const auto &callback : frameCallbacks) {
+    callback(targetTimestamp);
+  }
+}
+
+- (std::vector<std::function<void(double)>>)pullCallbacks
+{
+  RCTAssertMainQueue();
+  std::lock_guard<std::mutex> lock(callbacksMutex_);
+  return std::move(frameCallbacks_);
+}
+
+@end

package/apple/worklets/apple/AssertJavaScriptQueue.h

@@ -0,0 +1,14 @@
+#import <react/debug/react_native_assert.h>
+
+// Copied from RCTJSThreadManager.mm
+static NSString *const RCTJSThreadName = @"com.facebook.react.runtime.JavaScript";
+
+static BOOL IsJavaScriptQueue()
+{
+  return [NSThread.currentThread.name isEqualToString:RCTJSThreadName];
+}
+
+static void AssertJavaScriptQueue()
+{
+  react_native_assert(IsJavaScriptQueue() && "This function must be called on the JavaScript queue");
+}

package/apple/worklets/apple/AssertTurboModuleManagerQueue.h

@@ -0,0 +1,16 @@
+#import <react/debug/react_native_assert.h>
+
+constexpr auto turboModuleManagerQueueLabel =
+    "com.meta.react.turbomodulemanager.queue";
+
+static bool IsTurboModuleManagerQueue() {
+  const auto currentQueueLabel =
+      dispatch_queue_get_label(DISPATCH_CURRENT_QUEUE_LABEL);
+  return strcmp(currentQueueLabel, turboModuleManagerQueueLabel) == 0;
+}
+
+static void AssertTurboModuleManagerQueue() {
+  react_native_assert(
+      IsTurboModuleManagerQueue() &&
+      "This function must be called on the TurboModuleManager queue");
+}

package/apple/worklets/apple/IOSUIScheduler.h

@@ -0,0 +1,14 @@
+#import <worklets/Tools/UIScheduler.h>
+
+namespace worklets {
+
+using namespace facebook;
+using namespace react;
+using namespace worklets;
+
+class IOSUIScheduler : public UIScheduler {
+ public:
+  void scheduleOnUI(std::function<void()> job) override;
+};
+
+} // namespace worklets

package/apple/worklets/apple/IOSUIScheduler.mm

@@ -0,0 +1,24 @@
+#import <worklets/apple/IOSUIScheduler.h>
+
+namespace worklets {
+
+using namespace facebook;
+using namespace react;
+
+void IOSUIScheduler::scheduleOnUI(std::function<void()> job)
+{
+  if ([NSThread isMainThread]) {
+    job();
+    return;
+  }
+
+  UIScheduler::scheduleOnUI(job);
+
+  if (!scheduledOnUI_) {
+    dispatch_async(dispatch_get_main_queue(), ^{
+      triggerUI();
+    });
+  }
+}
+
+} // namespace worklets

package/apple/worklets/apple/PlatformLogger.mm

@@ -0,0 +1,31 @@
+#import <Foundation/Foundation.h>
+#import <worklets/Tools/PlatformLogger.h>
+
+namespace worklets {
+
+void PlatformLogger::log(const char *str)
+{
+  NSLog(@"%@", [NSString stringWithCString:str encoding:[NSString defaultCStringEncoding]]);
+}
+
+void PlatformLogger::log(const std::string &str)
+{
+  log(str.c_str());
+}
+
+void PlatformLogger::log(const double d)
+{
+  NSLog(@"%lf", d);
+}
+
+void PlatformLogger::log(const int i)
+{
+  NSLog(@"%i", i);
+}
+
+void PlatformLogger::log(const bool b)
+{
+  log(b ? "true" : "false");
+}
+
+} // namespace worklets

package/apple/worklets/apple/SlowAnimations.h

@@ -0,0 +1,8 @@
+#import <Foundation/Foundation.h>
+
+namespace worklets {
+
+CGFloat getUIAnimationDragCoefficient(void);
+CFTimeInterval calculateTimestampWithSlowAnimations(CFTimeInterval currentTimestamp);
+
+} // namespace worklets

package/apple/worklets/apple/SlowAnimations.mm

@@ -0,0 +1,47 @@
+#import <QuartzCore/QuartzCore.h>
+
+#import <worklets/apple/SlowAnimations.h>
+
+#if TARGET_IPHONE_SIMULATOR
+#import <dlfcn.h>
+#endif
+
+namespace worklets {
+
+CGFloat getUIAnimationDragCoefficient(void)
+{
+  static float (*UIAnimationDragCoefficient)(void) = NULL;
+#if TARGET_IPHONE_SIMULATOR
+  static dispatch_once_t onceToken;
+  dispatch_once(&onceToken, ^{
+    UIAnimationDragCoefficient = (float (*)(void))dlsym(RTLD_DEFAULT, "UIAnimationDragCoefficient");
+  });
+#endif
+  return UIAnimationDragCoefficient ? UIAnimationDragCoefficient() : 1.f;
+}
+
+CFTimeInterval calculateTimestampWithSlowAnimations(CFTimeInterval currentTimestamp)
+{
+  static const auto MILLISECONDS_IN_SECOND = 1000;
+#if TARGET_IPHONE_SIMULATOR
+  static CFTimeInterval dragCoefChangedTimestamp = CACurrentMediaTime();
+  static CGFloat previousDragCoef = getUIAnimationDragCoefficient();
+
+  const CGFloat dragCoef = getUIAnimationDragCoefficient();
+  if (previousDragCoef != dragCoef) {
+    previousDragCoef = dragCoef;
+    dragCoefChangedTimestamp = CACurrentMediaTime();
+  }
+
+  const bool areSlowAnimationsEnabled = dragCoef != 1.f;
+  if (areSlowAnimationsEnabled) {
+    currentTimestamp = (dragCoefChangedTimestamp + (currentTimestamp - dragCoefChangedTimestamp) / dragCoef);
+  }
+  currentTimestamp *= MILLISECONDS_IN_SECOND;
+  return currentTimestamp;
+#else // TARGET_IPHONE_SIMULATOR
+  return currentTimestamp;
+#endif // TARGET_IPHONE_SIMULATOR
+}
+
+} // namespace worklets

package/apple/worklets/apple/WorkletsDisplayLink.h

@@ -0,0 +1,21 @@
+#if TARGET_OS_OSX
+
+#ifdef __cplusplus
+extern "C" {
+#endif // __cplusplus
+
+#import <React/RCTPlatformDisplayLink.h>
+
+#ifdef __cplusplus
+}
+#endif // __cplusplus
+
+typedef RCTPlatformDisplayLink WorkletsDisplayLink;
+
+#else // TARGET_OS_OSX
+
+#import <QuartzCore/CADisplayLink.h>
+
+typedef CADisplayLink WorkletsDisplayLink;
+
+#endif // TARGET_OS_OSX

package/apple/worklets/apple/WorkletsMessageThread.h

@@ -0,0 +1,16 @@
+#pragma once
+
+#import <Foundation/Foundation.h>
+#import <React/RCTMessageThread.h>
+
+namespace facebook {
+namespace react {
+
+class WorkletsMessageThread : public RCTMessageThread {
+ public:
+  using RCTMessageThread::RCTMessageThread;
+  virtual void quitSynchronous() override;
+};
+
+} // namespace react
+} // namespace facebook

package/apple/worklets/apple/WorkletsMessageThread.mm

@@ -0,0 +1,32 @@
+#import <worklets/apple/AssertJavaScriptQueue.h>
+#import <worklets/apple/WorkletsMessageThread.h>
+
+namespace facebook {
+namespace react {
+
+// Essentially the same as RCTMessageThread, but with public fields.
+struct WorkletsMessageThreadPublic {
+  // I don't know why we need three vtables (if you know then feel free to explain it instead of this message),
+  // but this is what makes the casts in quitSynchronous() work correctly.
+  void *vtable1;
+  void *vtable2;
+  void *vtable3;
+  CFRunLoopRef m_cfRunLoop;
+  RCTJavaScriptCompleteBlock m_errorBlock;
+  std::atomic_bool m_shutdown;
+};
+
+// We need to prevent any new code from being executed on the thread as there
+// is an assertion for that in the destructor of RCTMessageThread, but we have
+// to override quitSynchronous() as it would quit the main looper and freeze
+// the app.
+void WorkletsMessageThread::quitSynchronous()
+{
+  AssertJavaScriptQueue();
+  RCTMessageThread *rctThread = static_cast<RCTMessageThread *>(this);
+  WorkletsMessageThreadPublic *rctThreadPublic = reinterpret_cast<WorkletsMessageThreadPublic *>(rctThread);
+  rctThreadPublic->m_shutdown = true;
+}
+
+} // namespace react
+} // namespace facebook

package/apple/worklets/apple/WorkletsModule.h

@@ -0,0 +1,10 @@
+#import <React/RCTCallInvokerModule.h>
+#import <React/RCTEventEmitter.h>
+
+#import <worklets/NativeModules/WorkletsModuleProxy.h>
+
+@interface WorkletsModule : RCTEventEmitter <RCTCallInvokerModule>
+
+- (std::shared_ptr<worklets::WorkletsModuleProxy>)getWorkletsModuleProxy;
+
+@end

package/apple/worklets/apple/WorkletsModule.mm

@@ -0,0 +1,85 @@
+#import <worklets/Tools/SingleInstanceChecker.h>
+#import <worklets/WorkletRuntime/RNRuntimeWorkletDecorator.h>
+#import <worklets/apple/AnimationFrameQueue.h>
+#import <worklets/apple/AssertJavaScriptQueue.h>
+#import <worklets/apple/AssertTurboModuleManagerQueue.h>
+#import <worklets/apple/IOSUIScheduler.h>
+#import <worklets/apple/WorkletsMessageThread.h>
+#import <worklets/apple/WorkletsModule.h>
+
+#import <React/RCTCallInvoker.h>
+
+using worklets::RNRuntimeWorkletDecorator;
+using worklets::WorkletsModuleProxy;
+
+@interface RCTBridge (JSIRuntime)
+- (void *)runtime;
+@end
+
+@implementation WorkletsModule {
+  AnimationFrameQueue *animationFrameQueue_;
+  std::shared_ptr<WorkletsModuleProxy> workletsModuleProxy_;
+#ifndef NDEBUG
+  worklets::SingleInstanceChecker<WorkletsModule> singleInstanceChecker_;
+#endif // NDEBUG
+}
+
+- (std::shared_ptr<WorkletsModuleProxy>)getWorkletsModuleProxy
+{
+  AssertJavaScriptQueue();
+  return workletsModuleProxy_;
+}
+
+@synthesize callInvoker = _callInvoker;
+
+RCT_EXPORT_MODULE(WorkletsModule);
+
+RCT_EXPORT_BLOCKING_SYNCHRONOUS_METHOD(installTurboModule : (nonnull NSString *)valueUnpackerCode)
+{
+  AssertJavaScriptQueue();
+
+  react_native_assert(self.bridge != nullptr);
+  react_native_assert(self.bridge.runtime != nullptr);
+  jsi::Runtime &rnRuntime = *reinterpret_cast<facebook::jsi::Runtime *>(self.bridge.runtime);
+
+  auto jsQueue = std::make_shared<WorkletsMessageThread>([NSRunLoop currentRunLoop], ^(NSError *error) {
+    throw error;
+  });
+
+  std::string valueUnpackerCodeStr = [valueUnpackerCode UTF8String];
+  auto jsCallInvoker = _callInvoker.callInvoker;
+  auto jsScheduler = std::make_shared<worklets::JSScheduler>(rnRuntime, jsCallInvoker);
+  auto uiScheduler = std::make_shared<worklets::IOSUIScheduler>();
+  animationFrameQueue_ = [AnimationFrameQueue new];
+  auto forwardedRequestAnimationFrame = std::function<void(std::function<void(const double)>)>(
+      [animationFrameQueue = animationFrameQueue_](std::function<void(const double)> callback) {
+        [animationFrameQueue requestAnimationFrame:callback];
+      });
+  workletsModuleProxy_ = std::make_shared<WorkletsModuleProxy>(
+      rnRuntime,
+      valueUnpackerCodeStr,
+      jsQueue,
+      jsCallInvoker,
+      jsScheduler,
+      uiScheduler,
+      std::move(forwardedRequestAnimationFrame));
+  RNRuntimeWorkletDecorator::decorate(rnRuntime, workletsModuleProxy_);
+
+  return @YES;
+}
+
+- (void)invalidate
+{
+  AssertTurboModuleManagerQueue();
+
+  [animationFrameQueue_ invalidate];
+
+  // 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 destruction.
+  workletsModuleProxy_.reset();
+
+  [super invalidate];
+}
+
+@end