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

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

@@ -0,0 +1,60 @@
+package com.swmansion.worklets;
+
+import com.facebook.jni.HybridData;
+import com.facebook.proguard.annotations.DoNotStrip;
+import com.facebook.react.bridge.GuardedRunnable;
+import com.facebook.react.bridge.ReactApplicationContext;
+import com.facebook.react.bridge.UiThreadUtil;
+import java.util.concurrent.atomic.AtomicBoolean;
+
+@SuppressWarnings("JavaJniMissingFunction")
+public class AndroidUIScheduler {
+
+  @DoNotStrip
+  @SuppressWarnings({"unused", "FieldCanBeLocal"})
+  private final HybridData mHybridData;
+
+  private final ReactApplicationContext mContext;
+  private final AtomicBoolean mActive = new AtomicBoolean(true);
+
+  private final Runnable mUIThreadRunnable =
+      () -> {
+        // This callback is called on the UI thread, but the module is invalidated on the JS
+        // thread. Therefore we must synchronize for reloads. Without synchronization the cpp part
+        // gets torn down while the UI thread is still executing it, leading to crashes.
+        synchronized (mActive) {
+          if (mActive.get()) {
+            triggerUI();
+          }
+        }
+      };
+
+  public AndroidUIScheduler(ReactApplicationContext context) {
+    mHybridData = initHybrid();
+    mContext = context;
+  }
+
+  private native HybridData initHybrid();
+
+  public native void triggerUI();
+
+  public native void invalidate();
+
+  @DoNotStrip
+  @SuppressWarnings("unused")
+  private void scheduleTriggerOnUI() {
+    UiThreadUtil.runOnUiThread(
+        new GuardedRunnable(mContext.getExceptionHandler()) {
+          public void runGuarded() {
+            mUIThreadRunnable.run();
+          }
+        });
+  }
+
+  public void deactivate() {
+    synchronized (mActive) {
+      mActive.set(false);
+      invalidate();
+    }
+  }
+}

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

@@ -0,0 +1,27 @@
+package com.swmansion.worklets;
+
+import androidx.annotation.OptIn;
+import com.facebook.react.bridge.ReactApplicationContext;
+import com.facebook.react.common.annotations.FrameworkAPI;
+import com.facebook.react.turbomodule.core.CallInvokerHolderImpl;
+
+public class JSCallInvokerResolver {
+
+  @OptIn(markerClass = FrameworkAPI.class)
+  public static CallInvokerHolderImpl getJSCallInvokerHolder(ReactApplicationContext context) {
+    try {
+      var method = context.getClass().getMethod("getJSCallInvokerHolder");
+      return (CallInvokerHolderImpl) method.invoke(context);
+    } catch (Exception ignored) {
+      // In newer implementations, the method is in CatalystInstance, continue.
+    }
+    try {
+      var catalystInstance = context.getClass().getMethod("getCatalystInstance").invoke(context);
+      assert catalystInstance != null;
+      var method = catalystInstance.getClass().getMethod("getJSCallInvokerHolder");
+      return (CallInvokerHolderImpl) method.invoke(catalystInstance);
+    } catch (Exception e) {
+      throw new RuntimeException("Failed to get JSCallInvokerHolder", e);
+    }
+  }
+}

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

@@ -0,0 +1,16 @@
+package com.swmansion.worklets;
+
+import com.facebook.proguard.annotations.DoNotStrip;
+
+@DoNotStrip
+public class WorkletsMessageQueueThread extends WorkletsMessageQueueThreadBase {
+  @Override
+  public boolean runOnQueue(Runnable runnable) {
+    return messageQueueThread.runOnQueue(runnable);
+  }
+
+  @Override
+  public boolean isIdle() {
+    return messageQueueThread.isIdle();
+  }
+}

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

@@ -0,0 +1,73 @@
+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.kt
+// 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
+  @SuppressWarnings("CallToPrintStackTrace")
+  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/WorkletsPackage.java

@@ -0,0 +1,48 @@
+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 name.equals(WorkletsModule.NAME) ? new WorkletsModule(reactContext) : null;
+  }
+
+  @SuppressWarnings({"rawtypes, unchecked"})
+  @NonNull
+  @Override
+  public ReactModuleInfoProvider getReactModuleInfoProvider() {
+    Class[] 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(),
+              true));
+    }
+
+    return () -> reactModuleInfoMap;
+  }
+}

package/android/src/main/java/com/swmansion/worklets/runloop/AnimationFrameCallback.java

@@ -0,0 +1,19 @@
+package com.swmansion.worklets.runloop;
+
+import com.facebook.jni.HybridData;
+import com.facebook.proguard.annotations.DoNotStrip;
+
+@SuppressWarnings("JavaJniMissingFunction")
+public class AnimationFrameCallback {
+
+  @DoNotStrip
+  @SuppressWarnings({"FieldCanBeLocal", "unused"})
+  private final HybridData mHybridData;
+
+  @DoNotStrip
+  private AnimationFrameCallback(HybridData hybridData) {
+    mHybridData = hybridData;
+  }
+
+  public native void onAnimationFrame(double timestampMs);
+}

package/android/src/main/java/com/swmansion/worklets/runloop/AnimationFrameQueue.java

@@ -0,0 +1,113 @@
+package com.swmansion.worklets.runloop;
+
+import android.os.SystemClock;
+import com.facebook.react.bridge.ReactApplicationContext;
+import com.facebook.react.modules.core.ReactChoreographer;
+import com.facebook.react.uimanager.GuardedFrameCallback;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.concurrent.atomic.AtomicBoolean;
+
+public class AnimationFrameQueue {
+
+  private Long mFirstUptime = SystemClock.uptimeMillis();
+  private boolean mSlowAnimationsEnabled = false;
+  private double lastFrameTimeMs;
+  private int mAnimationsDragFactor = 1;
+
+  /// ReactChoreographer is
+  /// <a
+  // href="https://github.com/facebook/react-native/blob/main/packages/react-native/ReactAndroid/src/main/java/com/facebook/react/modules/core/ReactChoreographer.kt#L21">thread safe</a>.
+  ///
+  private final ReactChoreographer mReactChoreographer = ReactChoreographer.getInstance();
+  private final GuardedFrameCallback mChoreographerCallback;
+  private final AtomicBoolean mCallbackPosted = new AtomicBoolean();
+  private final AtomicBoolean mPaused = new AtomicBoolean();
+  private final List<AnimationFrameCallback> mFrameCallbacks = new ArrayList<>();
+
+  public AnimationFrameQueue(ReactApplicationContext reactApplicationContext) {
+    mChoreographerCallback =
+        new GuardedFrameCallback(reactApplicationContext) {
+          @Override
+          protected void doFrameGuarded(long frameTimeNanos) {
+            executeQueue(frameTimeNanos);
+          }
+        };
+  }
+
+  public void resume() {
+    if (mPaused.getAndSet(false)) {
+      scheduleQueueExecution();
+    }
+  }
+
+  public void pause() {
+    synchronized (mPaused) {
+      if (!mPaused.getAndSet(true) && mCallbackPosted.getAndSet(false)) {
+        mReactChoreographer.removeFrameCallback(
+            ReactChoreographer.CallbackType.NATIVE_ANIMATED_MODULE, mChoreographerCallback);
+      }
+    }
+  }
+
+  public void requestAnimationFrame(AnimationFrameCallback animationFrameCallback) {
+    synchronized (mFrameCallbacks) {
+      mFrameCallbacks.add(animationFrameCallback);
+    }
+    scheduleQueueExecution();
+  }
+
+  public void enableSlowAnimations(boolean slowAnimationsEnabled, int animationsDragFactor) {
+    mSlowAnimationsEnabled = slowAnimationsEnabled;
+    mAnimationsDragFactor = animationsDragFactor;
+    if (slowAnimationsEnabled) {
+      mFirstUptime = SystemClock.uptimeMillis();
+    }
+  }
+
+  private void scheduleQueueExecution() {
+    synchronized (mPaused) {
+      if (!mPaused.get() && !mCallbackPosted.getAndSet(true)) {
+        mReactChoreographer.postFrameCallback(
+            ReactChoreographer.CallbackType.NATIVE_ANIMATED_MODULE, mChoreographerCallback);
+      }
+    }
+  }
+
+  private void executeQueue(long frameTimeNanos) {
+    double currentFrameTimeMs = calculateTimestamp(frameTimeNanos);
+    if (currentFrameTimeMs <= lastFrameTimeMs) {
+      // It is possible for ChoreographerCallback to be executed twice within the same frame
+      // due to frame drops. If this occurs, the additional callback execution should be ignored.
+      mCallbackPosted.set(false);
+      scheduleQueueExecution();
+      return;
+    }
+
+    var frameCallbacks = pullCallbacks();
+    mCallbackPosted.set(false);
+
+    lastFrameTimeMs = currentFrameTimeMs;
+    for (var callback : frameCallbacks) {
+      callback.onAnimationFrame(currentFrameTimeMs);
+    }
+  }
+
+  private List<AnimationFrameCallback> pullCallbacks() {
+    synchronized (mFrameCallbacks) {
+      List<AnimationFrameCallback> frameCallbacks = new ArrayList<>(mFrameCallbacks);
+      mFrameCallbacks.clear();
+      return frameCallbacks;
+    }
+  }
+
+  private double calculateTimestamp(long frameTimeNanos) {
+    final double NANOSECONDS_IN_MILLISECONDS = 1000000;
+    double currentFrameTimeMs = frameTimeNanos / NANOSECONDS_IN_MILLISECONDS;
+    if (mSlowAnimationsEnabled) {
+      currentFrameTimeMs =
+          mFirstUptime + (currentFrameTimeMs - mFirstUptime) / mAnimationsDragFactor;
+    }
+    return currentFrameTimeMs;
+  }
+}

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,135 @@
+#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>
+
+#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 = [UIScreen mainScreen].maximumFramesPerSecond > 60;
+    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) {
+    displayLink_.preferredFrameRateRange = frameRateRange;
+    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,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,15 @@
+#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/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,45 @@
+#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);
+  }
+#endif // TARGET_IPHONE_SIMULATOR
+  currentTimestamp *= MILLISECONDS_IN_SECOND;
+  return currentTimestamp;
+}
+
+} // namespace worklets