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

package/apple/worklets/apple/AnimationFrameQueue.mm

@@ -0,0 +1,145 @@
+#import <worklets/Tools/FeatureFlags.h>
+#import <worklets/apple/AnimationFrameQueue.h>
+#import <worklets/apple/AssertJavaScriptQueue.h>
+#import <worklets/apple/AssertTurboModuleManagerQueue.h>
+#import <worklets/apple/SlowAnimations.h>
+#import <chrono>
+
+#if TARGET_OS_OSX
+#import <QuartzCore/CADisplayLink.h>
+#endif // TARGET_OS_OSX
+
+#import <React/RCTAssert.h>
+
+constexpr auto TIME_SAMPLES_AMOUNT = 4;
+
+namespace FrameRateRange {
+const auto BEST = CAFrameRateRangeMake(60, 120, 120);
+const auto STANDARD = CAFrameRateRangeMake(30, 60, 60);
+const auto LOW = CAFrameRateRangeMake(24, 30, 30);
+const auto POOR = CAFrameRateRangeMake(10, 24, 24);
+} // namespace FrameRateRange
+
+@implementation AnimationFrameQueue {
+  /* DisplayLink is thread safe. */
+  WorkletsDisplayLink *displayLink_;
+  std::vector<std::function<void(double)>> frameCallbacks_;
+  std::mutex callbacksMutex_;
+  std::chrono::duration<double, std::milli> timeDeltas_[TIME_SAMPLES_AMOUNT];
+  int timeDeltaIndex_;
+  CAFrameRateRange currentFrameRate_;
+}
+
+typedef void (^AnimationFrameCallback)(WorkletsDisplayLink *displayLink);
+
+#pragma mark-- public
+
+- (instancetype)init
+{
+  AssertJavaScriptQueue();
+  if constexpr (worklets::StaticFeatureFlags::getFlag("IOS_DYNAMIC_FRAMERATE_ENABLED")) {
+    bool supportsProMotion = false;
+#if !TARGET_OS_OSX
+    supportsProMotion = [UIScreen mainScreen].maximumFramesPerSecond > 60;
+#endif // !TARGET_OS_OSX
+
+    SEL frameCallback = supportsProMotion ? @selector(executeQueueForProMotion:) : @selector(executeQueue:);
+    currentFrameRate_ = supportsProMotion ? FrameRateRange::BEST : FrameRateRange::STANDARD;
+    displayLink_ = [WorkletsDisplayLink displayLinkWithTarget:self selector:frameCallback];
+  } else {
+    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);
+  }
+}
+
+- (void)executeQueueForProMotion:(WorkletsDisplayLink *)displayLink
+{
+  auto start = std::chrono::high_resolution_clock::now();
+
+  [self executeQueue:displayLink];
+
+  timeDeltaIndex_ = (timeDeltaIndex_ + 1) % TIME_SAMPLES_AMOUNT;
+  timeDeltas_[timeDeltaIndex_] = std::chrono::high_resolution_clock::now() - start;
+  if (timeDeltaIndex_ == TIME_SAMPLES_AMOUNT) {
+    // Perform this on every TIME_SAMPLES_AMOUNT-nth frame instead of each one
+    return;
+  }
+  float averageComputationTime = 0;
+  for (int i = 0; i < TIME_SAMPLES_AMOUNT; i++) {
+    averageComputationTime += timeDeltas_[i].count();
+  }
+  averageComputationTime = averageComputationTime / TIME_SAMPLES_AMOUNT;
+  CAFrameRateRange frameRateRange;
+  if (averageComputationTime < 8) {
+    frameRateRange = FrameRateRange::BEST;
+  } else if (averageComputationTime < 16) {
+    frameRateRange = FrameRateRange::STANDARD;
+  } else if (averageComputationTime < 33) {
+    frameRateRange = FrameRateRange::LOW;
+  } else {
+    frameRateRange = FrameRateRange::POOR;
+  }
+  if (currentFrameRate_.preferred != frameRateRange.preferred) {
+#if !TARGET_OS_OSX
+    displayLink_.preferredFrameRateRange = frameRateRange;
+#endif // !TARGET_OS_OSX
+    currentFrameRate_ = frameRateRange;
+  }
+}
+
+- (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,12 @@
+#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 std::enable_shared_from_this<IOSUIScheduler> {
+ public:
+  void scheduleOnUI(std::function<void()> job) override;
+};
+
+} // namespace worklets

package/apple/worklets/apple/IOSUIScheduler.mm

@@ -0,0 +1,29 @@
+#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(), [weakThis = weak_from_this()] {
+      // Before triggering the UI, we check if the weak pointer is still valid to avoid possible dangling pointer
+      // issues, because when this async callback here gets executed, the original `IOSUIScheduler` object may have been
+      // destroyed.
+      if (auto strongThis = weakThis.lock()) {
+        strongThis->triggerUI();
+      }
+    });
+  }
+}
+
+} // namespace worklets

package/apple/worklets/apple/Networking/WorkletsNetworking.h

@@ -0,0 +1,25 @@
+#pragma once
+
+#ifdef WORKLETS_FETCH_PREVIEW_ENABLED
+/*
+ * This file is based on RCTNetworking.h from React Native.
+ */
+
+#import <React/RCTNetworking.h>
+
+using namespace facebook;
+
+@interface WorkletsNetworking : NSObject
+- (instancetype)init:(RCTNetworking *)rctNetworking;
+
+- (void)jsiSendRequest:(jsi::Runtime &)rt
+                jquery:(const jsi::Value &)jquery
+        responseSender:(jsi::Function &&)responseSender;
+
+- (void)jsiAbortRequest:(double)requestID;
+
+- (void)jsiClearCookies:(jsi::Runtime &)rt responseSender:(jsi::Function &&)responseSender;
+
+@end
+
+#endif // WORKLETS_FETCH_PREVIEW_ENABLED