react-native-tvos 0.75.3-0 → 0.76.0-0

package/ReactAndroid/src/main/java/com/facebook/react/modules/core/JavaTimerManager.kt

@@ -0,0 +1,363 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+package com.facebook.react.modules.core
+
+import android.util.SparseArray
+import android.view.Choreographer
+import com.facebook.proguard.annotations.DoNotStrip
+import com.facebook.react.bridge.Arguments
+import com.facebook.react.bridge.LifecycleEventListener
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.bridge.UiThreadUtil
+import com.facebook.react.bridge.WritableArray
+import com.facebook.react.common.SystemClock.currentTimeMillis
+import com.facebook.react.common.SystemClock.nanoTime
+import com.facebook.react.common.SystemClock.uptimeMillis
+import com.facebook.react.devsupport.interfaces.DevSupportManager
+import com.facebook.react.jstasks.HeadlessJsTaskContext
+import com.facebook.react.jstasks.HeadlessJsTaskEventListener
+import java.util.PriorityQueue
+import java.util.concurrent.atomic.AtomicBoolean
+import kotlin.concurrent.Volatile
+import kotlin.math.abs
+import kotlin.math.max
+import kotlin.math.sign
+
+/**
+ * This class is the native implementation for JS timer execution on Android. It schedules JS timers
+ * to be invoked on frame boundaries using [ReactChoreographer].
+ *
+ * This is used by the NativeModule [TimingModule].
+ */
+public open class JavaTimerManager(
+    private val reactApplicationContext: ReactApplicationContext,
+    private val javaScriptTimerExecutor: JavaScriptTimerExecutor,
+    private val reactChoreographer: ReactChoreographer,
+    private val devSupportManager: DevSupportManager
+) : LifecycleEventListener, HeadlessJsTaskEventListener {
+  private class Timer(
+      val timerId: Int,
+      var targetTime: Long,
+      val interval: Int,
+      val repeat: Boolean
+  )
+
+  private val timerGuard = Any()
+  private val idleCallbackGuard = Any()
+  private val timerIdsToTimers: SparseArray<Timer> = SparseArray()
+  private val isPaused = AtomicBoolean(true)
+  private val isRunningTasks = AtomicBoolean(false)
+  private val timerFrameCallback = TimerFrameCallback()
+  private val idleFrameCallback = IdleFrameCallback()
+  private var currentIdleCallbackRunnable: IdleCallbackRunnable? = null
+  private var frameCallbackPosted = false
+  private var frameIdleCallbackPosted = false
+  private var sendIdleEvents = false
+
+  // We store timers sorted by finish time.
+  private val timers: PriorityQueue<Timer> =
+      PriorityQueue(TIMER_QUEUE_CAPACITY) { lhs, rhs -> (lhs.targetTime - rhs.targetTime).sign }
+
+  init {
+    reactApplicationContext.addLifecycleEventListener(this)
+  }
+
+  override fun onHostPause() {
+    isPaused.set(true)
+    clearFrameCallback()
+    maybeIdleCallback()
+  }
+
+  override fun onHostDestroy() {
+    clearFrameCallback()
+    maybeIdleCallback()
+  }
+
+  override fun onHostResume() {
+    isPaused.set(false)
+    // TODO(5195192) Investigate possible problems related to restarting all tasks at the same
+    // moment
+    setChoreographerCallback()
+    maybeSetChoreographerIdleCallback()
+  }
+
+  override fun onHeadlessJsTaskStart(taskId: Int) {
+    if (!isRunningTasks.getAndSet(true)) {
+      setChoreographerCallback()
+      maybeSetChoreographerIdleCallback()
+    }
+  }
+
+  override fun onHeadlessJsTaskFinish(taskId: Int) {
+    val headlessJsTaskContext = HeadlessJsTaskContext.getInstance(reactApplicationContext)
+    if (!headlessJsTaskContext.hasActiveTasks()) {
+      isRunningTasks.set(false)
+      clearFrameCallback()
+      maybeIdleCallback()
+    }
+  }
+
+  public open fun onInstanceDestroy() {
+    reactApplicationContext.removeLifecycleEventListener(this)
+    clearFrameCallback()
+    clearChoreographerIdleCallback()
+  }
+
+  private fun maybeSetChoreographerIdleCallback() {
+    synchronized(idleCallbackGuard) {
+      if (sendIdleEvents) {
+        setChoreographerIdleCallback()
+      }
+    }
+  }
+
+  private fun maybeIdleCallback() {
+    if (isPaused.get() && !isRunningTasks.get()) {
+      clearFrameCallback()
+    }
+  }
+
+  private fun setChoreographerCallback() {
+    if (!frameCallbackPosted) {
+      reactChoreographer.postFrameCallback(
+          ReactChoreographer.CallbackType.TIMERS_EVENTS, timerFrameCallback)
+      frameCallbackPosted = true
+    }
+  }
+
+  private fun clearFrameCallback() {
+    val headlessJsTaskContext = HeadlessJsTaskContext.getInstance(reactApplicationContext)
+    if (frameCallbackPosted && isPaused.get() && !headlessJsTaskContext.hasActiveTasks()) {
+      reactChoreographer.removeFrameCallback(
+          ReactChoreographer.CallbackType.TIMERS_EVENTS, timerFrameCallback)
+      frameCallbackPosted = false
+    }
+  }
+
+  private fun setChoreographerIdleCallback() {
+    if (!frameIdleCallbackPosted) {
+      reactChoreographer.postFrameCallback(
+          ReactChoreographer.CallbackType.IDLE_EVENT, idleFrameCallback)
+      frameIdleCallbackPosted = true
+    }
+  }
+
+  private fun clearChoreographerIdleCallback() {
+    if (frameIdleCallbackPosted) {
+      reactChoreographer.removeFrameCallback(
+          ReactChoreographer.CallbackType.IDLE_EVENT, idleFrameCallback)
+      frameIdleCallbackPosted = false
+    }
+  }
+
+  /**
+   * A method to be used for synchronously creating a timer. The timer will not be invoked until the
+   * next frame, regardless of whether it has already expired (i.e. the delay is 0).
+   *
+   * @param timerId An identifier for the callback that can be passed to JS or C++ to invoke it.
+   * @param delay The time in ms before the callback should be invoked.
+   * @param repeat Whether the timer should be repeated (used for setInterval).
+   */
+  @DoNotStrip
+  public open fun createTimer(timerId: Int, delay: Long, repeat: Boolean) {
+    val initialTargetTime = nanoTime() / 1000000 + delay
+    val timer = Timer(timerId, initialTargetTime, delay.toInt(), repeat)
+    synchronized(timerGuard) {
+      timers.add(timer)
+      timerIdsToTimers.put(timerId, timer)
+    }
+  }
+
+  /**
+   * A method to be used for asynchronously creating a timer. If the timer has already expired,
+   * (based on the provided jsSchedulingTime) then it will be immediately invoked.
+   *
+   * @param timerId An identifier that can be passed back to JS to invoke the callback.
+   * @param duration The time in ms before the callback should be invoked.
+   * @param jsSchedulingTime The time (ms since epoch) when this timer was created in JS.
+   * @param repeat Whether the timer should be repeated (used for setInterval)
+   */
+  public open fun createAndMaybeCallTimer(
+      timerId: Int,
+      duration: Int,
+      jsSchedulingTime: Double,
+      repeat: Boolean
+  ) {
+    val deviceTime = currentTimeMillis()
+    val remoteTime = jsSchedulingTime.toLong()
+
+    // If the times on the server and device have drifted throw an exception to warn the developer
+    // that things might not work or results may not be accurate. This is required only for
+    // developer builds.
+    if (devSupportManager.devSupportEnabled) {
+      val driftTime = abs(remoteTime - deviceTime)
+      if (driftTime > 60000) {
+        javaScriptTimerExecutor.emitTimeDriftWarning(
+            "Debugger and device times have drifted by more than 60s. Please correct this by " +
+                "running adb shell \"date `date +%m%d%H%M%Y.%S`\" on your debugger machine.")
+      }
+    }
+
+    // Adjust for the amount of time it took for native to receive the timer registration call
+    val adjustedDuration = max(0, remoteTime - deviceTime + duration)
+    if (duration == 0 && !repeat) {
+      val timerToCall = Arguments.createArray()
+      timerToCall.pushInt(timerId)
+      javaScriptTimerExecutor.callTimers(timerToCall)
+      return
+    }
+    createTimer(timerId, adjustedDuration, repeat)
+  }
+
+  @DoNotStrip
+  public open fun deleteTimer(timerId: Int) {
+    synchronized(timerGuard) {
+      val timer = timerIdsToTimers[timerId] ?: return
+      timerIdsToTimers.remove(timerId)
+      timers.remove(timer)
+    }
+  }
+
+  @DoNotStrip
+  public open fun setSendIdleEvents(sendIdleEvents: Boolean) {
+    synchronized(idleCallbackGuard) { this.sendIdleEvents = sendIdleEvents }
+    UiThreadUtil.runOnUiThread {
+      synchronized(idleCallbackGuard) {
+        if (sendIdleEvents) {
+          setChoreographerIdleCallback()
+        } else {
+          clearChoreographerIdleCallback()
+        }
+      }
+    }
+  }
+
+  /**
+   * Returns a bool representing whether there are any active timers that will be fired within a
+   * certain period of time. Disregards repeating timers (setInterval). Used for testing to
+   * determine if RN is idle.
+   *
+   * @param rangeMs The time range, in ms, to check
+   * @return True if there are pending timers within the given range; false otherwise
+   */
+  internal fun hasActiveTimersInRange(rangeMs: Long): Boolean {
+    synchronized(timerGuard) {
+      val nextTimer =
+          timers.peek()
+              ?: // Timers queue is empty
+              return false
+      if (isTimerInRange(nextTimer, rangeMs)) {
+        // First check the next timer, so we can avoid iterating over the entire queue if it's
+        // already within range.
+        return true
+      }
+      for (timer in timers) {
+        if (isTimerInRange(timer, rangeMs)) {
+          return true
+        }
+      }
+    }
+    return false
+  }
+
+  private inner class TimerFrameCallback : Choreographer.FrameCallback {
+    // Temporary map for constructing the individual arrays of timers to call
+    private var timersToCall: WritableArray? = null
+
+    /** Calls all timers that have expired since the last time this frame callback was called. */
+    override fun doFrame(frameTimeNanos: Long) {
+      if (isPaused.get() && !isRunningTasks.get()) {
+        return
+      }
+      val frameTimeMillis = frameTimeNanos / 1000000
+      synchronized(timerGuard) {
+        while (!timers.isEmpty() && timers.peek()!!.targetTime < frameTimeMillis) {
+          var timer = timers.poll()
+          if (timer == null) {
+            break
+          }
+          if (timersToCall == null) {
+            timersToCall = Arguments.createArray()
+          }
+          timersToCall?.pushInt(timer.timerId)
+          if (timer.repeat) {
+            timer.targetTime = frameTimeMillis + timer.interval
+            timers.add(timer)
+          } else {
+            timerIdsToTimers.remove(timer.timerId)
+          }
+        }
+      }
+      timersToCall?.let {
+        javaScriptTimerExecutor.callTimers(it)
+        timersToCall = null
+      }
+      reactChoreographer.postFrameCallback(ReactChoreographer.CallbackType.TIMERS_EVENTS, this)
+    }
+  }
+
+  private inner class IdleFrameCallback : Choreographer.FrameCallback {
+    override fun doFrame(frameTimeNanos: Long) {
+      if (isPaused.get() && !isRunningTasks.get()) {
+        return
+      }
+
+      // If the JS thread is busy for multiple frames we cancel any other pending runnable.
+      // We also capture the idleCallbackRunnable to tentatively fix:
+      // https://github.com/facebook/react-native/issues/44842
+      currentIdleCallbackRunnable?.cancel()
+      currentIdleCallbackRunnable = IdleCallbackRunnable(frameTimeNanos)
+      reactApplicationContext.runOnJSQueueThread(currentIdleCallbackRunnable)
+      reactChoreographer.postFrameCallback(ReactChoreographer.CallbackType.IDLE_EVENT, this)
+    }
+  }
+
+  private inner class IdleCallbackRunnable(private val frameStartTime: Long) : Runnable {
+    @Volatile private var isCancelled = false
+
+    override fun run() {
+      if (isCancelled) {
+        return
+      }
+      val frameTimeMillis = frameStartTime / 1000000
+      val timeSinceBoot = uptimeMillis()
+      val frameTimeElapsed = timeSinceBoot - frameTimeMillis
+      val time = currentTimeMillis()
+      val absoluteFrameStartTime = time - frameTimeElapsed
+      if (FRAME_DURATION_MS - frameTimeElapsed.toFloat() < IDLE_CALLBACK_FRAME_DEADLINE_MS) {
+        return
+      }
+      var sendIdleEvents: Boolean
+      synchronized(idleCallbackGuard) { sendIdleEvents = this@JavaTimerManager.sendIdleEvents }
+      if (sendIdleEvents) {
+        javaScriptTimerExecutor.callIdleCallbacks(absoluteFrameStartTime.toDouble())
+      }
+      currentIdleCallbackRunnable = null
+    }
+
+    fun cancel() {
+      isCancelled = true
+    }
+  }
+
+  private companion object {
+    // These timing constants should be kept in sync with the ones in `JSTimers.js`.
+    // The minimum time in milliseconds left in the frame to call idle callbacks.
+    private const val IDLE_CALLBACK_FRAME_DEADLINE_MS = 1f
+
+    // The total duration of a frame in milliseconds, this assumes that devices run at 60 fps.
+    // TODO: Lower frame duration on devices that are too slow to run consistently
+    // at 60 fps.
+    private const val FRAME_DURATION_MS = 1000f / 60f
+
+    private const val TIMER_QUEUE_CAPACITY = 11
+
+    private fun isTimerInRange(timer: Timer, rangeMs: Long): Boolean =
+        !timer.repeat && timer.interval < rangeMs
+  }
+}

package/ReactAndroid/src/main/java/com/facebook/react/modules/core/PermissionAwareActivity.kt

@@ -0,0 +1,30 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+package com.facebook.react.modules.core
+
+/**
+ * Interface used to denote activities that can forward permission requests and call
+ * [PermissionListener] with the permission request results.
+ */
+public interface PermissionAwareActivity {
+  /** See [Activity.checkPermission]. */
+  public fun checkPermission(permission: String, pid: Int, uid: Int): Int
+
+  /** See [Activity.checkSelfPermission]. */
+  public fun checkSelfPermission(permission: String): Int
+
+  /** See [Activity.shouldShowRequestPermissionRationale]. */
+  public fun shouldShowRequestPermissionRationale(permission: String): Boolean
+
+  /** See [Activity.requestPermissions]. */
+  public fun requestPermissions(
+      permissions: Array<String>,
+      requestCode: Int,
+      listener: PermissionListener?
+  )
+}

package/ReactAndroid/src/main/java/com/facebook/react/modules/core/{PermissionListener.java → PermissionListener.kt}

@@ -5,21 +5,21 @@
  * LICENSE file in the root directory of this source tree.
  */
 
-package com.facebook.react.modules.core;
-
-import android.app.Activity;
-
+package com.facebook.react.modules.core
 /**
  * Interface used by activities to delegate permission request results. Classes implementing this
  * class will be notified whenever there's a result for a permission request.
  */
-public interface PermissionListener {
-
+public fun interface PermissionListener {
   /**
-   * Method called whenever there's a result to a permission request. It is forwarded from {@link
-   * Activity#onRequestPermissionsResult}.
+   * Method called whenever there's a result to a permission request. It is forwarded from
+   * [Activity.onRequestPermissionsResult].
    *
    * @return boolean Whether the PermissionListener can be removed.
    */
-  boolean onRequestPermissionsResult(int requestCode, String[] permissions, int[] grantResults);
+  public fun onRequestPermissionsResult(
+      requestCode: Int,
+      permissions: Array<String>,
+      grantResults: IntArray
+  ): Boolean
 }

package/ReactAndroid/src/main/java/com/facebook/react/modules/core/RCTNativeAppEventEmitter.kt

@@ -0,0 +1,17 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+package com.facebook.react.modules.core
+
+import com.facebook.proguard.annotations.DoNotStrip
+import com.facebook.react.bridge.JavaScriptModule
+
+/** Module that handles global application events. */
+@DoNotStrip
+public fun interface RCTNativeAppEventEmitter : JavaScriptModule {
+  public fun emit(eventName: String, data: Any?)
+}

package/ReactAndroid/src/main/java/com/facebook/react/modules/core/ReactChoreographer.kt

@@ -0,0 +1,144 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+package com.facebook.react.modules.core
+
+import androidx.annotation.GuardedBy
+import android.view.Choreographer
+import com.facebook.common.logging.FLog
+import com.facebook.infer.annotation.Assertions
+import com.facebook.react.bridge.UiThreadUtil
+import com.facebook.react.common.ReactConstants
+import com.facebook.react.common.annotations.VisibleForTesting
+import com.facebook.react.internal.ChoreographerProvider
+import java.util.ArrayDeque
+
+/**
+ * A simple wrapper around Choreographer that allows us to control the order certain callbacks are
+ * executed within a given frame. The wrapped Choreographer instance will always be the main thread
+ * one and the API's are safe to use from any thread.
+ */
+public class ReactChoreographer private constructor(choreographerProvider: ChoreographerProvider) {
+  public enum class CallbackType(internal val order: Int) {
+    /** For use by perf markers that need to happen immediately after draw */
+    PERF_MARKERS(0),
+    /** For use by [com.facebook.react.uimanager.UIManagerModule] */
+    DISPATCH_UI(1),
+    /** For use by [com.facebook.react.animated.NativeAnimatedModule] */
+    NATIVE_ANIMATED_MODULE(2),
+    /** Events that make JS do things. */
+    TIMERS_EVENTS(3),
+    /**
+     * Event used to trigger the idle callback. Called after all UI work has been dispatched to JS.
+     */
+    IDLE_EVENT(4)
+  }
+
+  private var choreographer: ChoreographerProvider.Choreographer? = null
+  private val callbackQueues: Array<ArrayDeque<Choreographer.FrameCallback>> =
+      Array(CallbackType.entries.size) { ArrayDeque() }
+  private var totalCallbacks = 0
+  @GuardedBy("callbackQueues")
+  private var hasPostedCallback = false
+
+  private val frameCallback =
+      Choreographer.FrameCallback { frameTimeNanos ->
+        synchronized(callbackQueues) {
+          // Callbacks run once and are then automatically removed, the callback will
+          // be posted again from postFrameCallback
+          hasPostedCallback = false
+          for (i in callbackQueues.indices) {
+            val callbackQueue = callbackQueues[i]
+            val initialLength = callbackQueue.size
+            for (callback in 0 until initialLength) {
+              val frameCallback = callbackQueue.pollFirst()
+              if (frameCallback != null) {
+                frameCallback.doFrame(frameTimeNanos)
+                totalCallbacks--
+              } else {
+                FLog.e(ReactConstants.TAG, "Tried to execute non-existent frame callback")
+              }
+            }
+          }
+          maybeRemoveFrameCallback()
+        }
+      }
+
+  init {
+    UiThreadUtil.runOnUiThread { choreographer = choreographerProvider.getChoreographer() }
+  }
+
+  public fun postFrameCallback(type: CallbackType, callback: Choreographer.FrameCallback) {
+    synchronized(callbackQueues) {
+      callbackQueues[type.order].addLast(callback)
+      totalCallbacks++
+      Assertions.assertCondition(totalCallbacks > 0)
+      postFrameCallbackOnChoreographer()
+    }
+  }
+
+  public fun removeFrameCallback(type: CallbackType, frameCallback: Choreographer.FrameCallback?) {
+    synchronized(callbackQueues) {
+      if (callbackQueues[type.order].removeFirstOccurrence(frameCallback)) {
+        totalCallbacks--
+        maybeRemoveFrameCallback()
+      } else {
+        FLog.e(ReactConstants.TAG, "Tried to remove non-existent frame callback")
+      }
+    }
+  }
+
+  /**
+   * This method writes [hasPostedCallback] and it should be called from another method that has
+   * the lock on [callbackQueues].
+   */
+  private fun postFrameCallbackOnChoreographer() {
+    if (!hasPostedCallback) {
+      val choreographer = choreographer
+      if (choreographer == null) {
+        // Schedule on the main thread, at which point the constructor's async work will have
+         UiThreadUtil.runOnUiThread {
+                   synchronized(callbackQueues) { postFrameCallbackOnChoreographer() }
+                  }
+      } else {
+        choreographer.postFrameCallback(frameCallback)
+        hasPostedCallback = true
+      }
+    }
+  }
+
+  /**
+   * This method reads and writes on mHasPostedCallback and it should be called from another method
+   * that already has the lock on [callbackQueues].
+   */
+  private fun maybeRemoveFrameCallback() {
+    Assertions.assertCondition(totalCallbacks >= 0)
+    if (totalCallbacks == 0 && hasPostedCallback) {
+      choreographer?.removeFrameCallback(frameCallback)
+      hasPostedCallback = false
+    }
+  }
+
+  public companion object {
+    private var choreographer: ReactChoreographer? = null
+
+    @JvmStatic
+    public fun initialize(choreographerProvider: ChoreographerProvider) {
+      if (choreographer == null) {
+        choreographer = ReactChoreographer(choreographerProvider)
+      }
+    }
+
+    @JvmStatic
+    public fun getInstance(): ReactChoreographer =
+        checkNotNull(choreographer) { "ReactChoreographer needs to be initialized." }
+
+    @VisibleForTesting
+    internal fun overrideInstanceForTest(instance: ReactChoreographer?): ReactChoreographer? =
+        choreographer.also { choreographer = instance }
+  }
+}

package/ReactAndroid/src/main/java/com/facebook/react/modules/core/TimingModule.kt

@@ -0,0 +1,83 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+package com.facebook.react.modules.core
+
+import com.facebook.fbreact.specs.NativeTimingSpec
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.bridge.WritableArray
+import com.facebook.react.common.annotations.VisibleForTesting
+import com.facebook.react.devsupport.interfaces.DevSupportManager
+import com.facebook.react.jstasks.HeadlessJsTaskContext
+import com.facebook.react.module.annotations.ReactModule
+
+/** Native module for JS timer execution. Timers fire on frame boundaries. */
+@ReactModule(name = NativeTimingSpec.NAME)
+public class TimingModule(
+    reactContext: ReactApplicationContext,
+    devSupportManager: DevSupportManager
+) : com.facebook.fbreact.specs.NativeTimingSpec(reactContext), JavaScriptTimerExecutor {
+  private val javaTimerManager: JavaTimerManager =
+      JavaTimerManager(reactContext, this, ReactChoreographer.getInstance(), devSupportManager)
+
+  override fun initialize() {
+    HeadlessJsTaskContext.getInstance(getReactApplicationContext())
+        .addTaskEventListener(javaTimerManager)
+  }
+
+  override fun createTimer(
+      callbackIDDouble: Double,
+      durationDouble: Double,
+      jsSchedulingTime: Double,
+      repeat: Boolean
+  ) {
+    val callbackID = callbackIDDouble.toInt()
+    val duration = durationDouble.toInt()
+    javaTimerManager.createAndMaybeCallTimer(callbackID, duration, jsSchedulingTime, repeat)
+  }
+
+  override fun deleteTimer(timerIdDouble: Double) {
+    val timerId = timerIdDouble.toInt()
+    javaTimerManager.deleteTimer(timerId)
+  }
+
+  override fun setSendIdleEvents(sendIdleEvents: Boolean) {
+    javaTimerManager.setSendIdleEvents(sendIdleEvents)
+  }
+
+  override fun callTimers(timerIDs: WritableArray) {
+    getReactApplicationContextIfActiveOrWarn()
+        ?.getJSModule(JSTimers::class.java)
+        ?.callTimers(timerIDs)
+  }
+
+  override fun callIdleCallbacks(frameTime: Double) {
+    getReactApplicationContextIfActiveOrWarn()
+        ?.getJSModule(JSTimers::class.java)
+        ?.callIdleCallbacks(frameTime)
+  }
+
+  override fun emitTimeDriftWarning(warningMessage: String) {
+    getReactApplicationContextIfActiveOrWarn()
+        ?.getJSModule(JSTimers::class.java)
+        ?.emitTimeDriftWarning(warningMessage)
+  }
+
+  override fun invalidate() {
+    val headlessJsTaskContext = HeadlessJsTaskContext.getInstance(getReactApplicationContext())
+    headlessJsTaskContext.removeTaskEventListener(javaTimerManager)
+    javaTimerManager.onInstanceDestroy()
+  }
+
+  @VisibleForTesting
+  public fun hasActiveTimersInRange(rangeMs: Long): Boolean =
+      javaTimerManager.hasActiveTimersInRange(rangeMs)
+
+  public companion object {
+    public const val NAME: String = NativeTimingSpec.NAME
+  }
+}