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

package/ReactAndroid/src/main/java/com/facebook/react/internal/turbomodule/core/TurboModuleManager.java

@@ -16,8 +16,6 @@ import com.facebook.jni.HybridData;
 import com.facebook.proguard.annotations.DoNotStrip;
 import com.facebook.react.bridge.CxxModuleWrapper;
 import com.facebook.react.bridge.NativeModule;
-import com.facebook.react.bridge.ReactNoCrashSoftException;
-import com.facebook.react.bridge.ReactSoftExceptionLogger;
 import com.facebook.react.bridge.RuntimeExecutor;
 import com.facebook.react.internal.turbomodule.core.interfaces.TurboModuleRegistry;
 import com.facebook.react.turbomodule.core.CallInvokerHolderImpl;
@@ -27,6 +25,7 @@ import com.facebook.react.turbomodule.core.interfaces.NativeMethodCallInvokerHol
 import com.facebook.react.turbomodule.core.interfaces.TurboModule;
 import java.util.ArrayList;
 import java.util.Collection;
+import java.util.Collections;
 import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
@@ -37,6 +36,8 @@ import java.util.Map;
  * a Java module, that the C++ counterpart calls.
  */
 public class TurboModuleManager implements TurboModuleRegistry {
+  private static final String TAG = "TurboModuleManager";
+
   private final List<String> mEagerInitModuleNames;
   private final ModuleProvider mTurboModuleProvider;
   private final ModuleProvider mLegacyModuleProvider;
@@ -72,10 +73,10 @@ public class TurboModuleManager implements TurboModuleRegistry {
             (CallInvokerHolderImpl) jsCallInvokerHolder,
             (NativeMethodCallInvokerHolderImpl) nativeMethodCallInvokerHolder,
             delegate);
-    installJSIBindings(shouldEnableLegacyModuleInterop(), enableSyncVoidMethods());
+    installJSIBindings(shouldEnableLegacyModuleInterop());
 
     mEagerInitModuleNames =
-        delegate == null ? new ArrayList<>() : delegate.getEagerInitModuleNames();
+        delegate == null ? Collections.emptyList() : delegate.getEagerInitModuleNames();
 
     ModuleProvider nullProvider = moduleName -> null;
 
@@ -112,15 +113,6 @@ public class TurboModuleManager implements TurboModuleRegistry {
     return mDelegate != null && mDelegate.unstable_shouldEnableLegacyModuleInterop();
   }
 
-  private boolean shouldRouteTurboModulesThroughLegacyModuleInterop() {
-    return mDelegate != null
-        && mDelegate.unstable_shouldRouteTurboModulesThroughLegacyModuleInterop();
-  }
-
-  private boolean enableSyncVoidMethods() {
-    return mDelegate != null && mDelegate.unstable_enableSyncVoidMethods();
-  }
-
   @Override
   @NonNull
   public List<String> getEagerInitModuleNames() {
@@ -140,11 +132,6 @@ public class TurboModuleManager implements TurboModuleRegistry {
   @DoNotStrip
   @Nullable
   private NativeModule getLegacyJavaModule(String moduleName) {
-    if (shouldRouteTurboModulesThroughLegacyModuleInterop()) {
-      final NativeModule module = getModule(moduleName);
-      return !(module instanceof CxxModuleWrapper) ? module : null;
-    }
-
     /*
      * This API is invoked from global.nativeModuleProxy.
      * Only call getModule if the native module is a legacy module.
@@ -164,11 +151,6 @@ public class TurboModuleManager implements TurboModuleRegistry {
   @DoNotStrip
   @Nullable
   private CxxModuleWrapper getLegacyCxxModule(String moduleName) {
-    if (shouldRouteTurboModulesThroughLegacyModuleInterop()) {
-      final NativeModule module = getModule(moduleName);
-      return module instanceof CxxModuleWrapper ? (CxxModuleWrapper) module : null;
-    }
-
     /*
      * This API is invoked from global.nativeModuleProxy.
      * Only call getModule if the native module is a legacy module.
@@ -188,10 +170,6 @@ public class TurboModuleManager implements TurboModuleRegistry {
   @DoNotStrip
   @Nullable
   private CxxModuleWrapper getTurboLegacyCxxModule(String moduleName) {
-    if (shouldRouteTurboModulesThroughLegacyModuleInterop()) {
-      return null;
-    }
-
     /*
      * This API is invoked from global.__turboModuleProxy.
      * Only call getModule if the native module is a turbo module.
@@ -211,10 +189,6 @@ public class TurboModuleManager implements TurboModuleRegistry {
   @DoNotStrip
   @Nullable
   private TurboModule getTurboJavaModule(String moduleName) {
-    if (shouldRouteTurboModulesThroughLegacyModuleInterop()) {
-      return null;
-    }
-
     /*
      * This API is invoked from global.__turboModuleProxy.
      * Only call getModule if the native module is a turbo module.
@@ -244,14 +218,13 @@ public class TurboModuleManager implements TurboModuleRegistry {
         /*
          * Always return null after cleanup has started, so that getNativeModule(moduleName) returns null.
          */
-        logError(
-            "getModule(): Tried to get module \""
-                + moduleName
-                + "\", but TurboModuleManager was tearing down. Returning null. Was legacy: "
-                + isLegacyModule(moduleName)
-                + ". Was turbo: "
-                + isTurboModule(moduleName)
-                + ".");
+        FLog.e(
+            TAG,
+            "getModule(): Tried to get module \"%s\", but TurboModuleManager was tearing down"
+                + " (legacy: %b, turbo: %b)",
+            moduleName,
+            isLegacyModule(moduleName),
+            isTurboModule(moduleName));
         return null;
       }
 
@@ -328,14 +301,12 @@ public class TurboModuleManager implements TurboModuleRegistry {
          */
         nativeModule.initialize();
       } else {
-        logError(
-            "getOrCreateModule(): Unable to create module \""
-                + moduleName
-                + "\". Was legacy: "
-                + isLegacyModule(moduleName)
-                + ". Was turbo: "
-                + isTurboModule(moduleName)
-                + ".");
+        FLog.e(
+            TAG,
+            "getOrCreateModule(): Unable to create module \"%s\" (legacy: %b, turbo: %b)",
+            moduleName,
+            isLegacyModule(moduleName),
+            isTurboModule(moduleName));
       }
 
       TurboModulePerfLogger.moduleCreateSetUpEnd(moduleName, moduleHolder.getModuleId());
@@ -408,22 +379,13 @@ public class TurboModuleManager implements TurboModuleRegistry {
     return false;
   }
 
-  private void logError(String message) {
-    FLog.e("TurboModuleManager", message);
-    if (shouldRouteTurboModulesThroughLegacyModuleInterop()) {
-      ReactSoftExceptionLogger.logSoftException(
-          "TurboModuleManager", new ReactNoCrashSoftException(message));
-    }
-  }
-
   private native HybridData initHybrid(
       RuntimeExecutor runtimeExecutor,
       CallInvokerHolderImpl jsCallInvokerHolder,
       NativeMethodCallInvokerHolderImpl nativeMethodCallInvoker,
       TurboModuleManagerDelegate tmmDelegate);
 
-  private native void installJSIBindings(
-      boolean shouldCreateLegacyModules, boolean enableSyncVoidMethods);
+  private native void installJSIBindings(boolean shouldCreateLegacyModules);
 
   @Override
   public void invalidate() {

package/ReactAndroid/src/main/java/com/facebook/react/internal/turbomodule/core/TurboModuleManagerDelegate.java

@@ -13,7 +13,7 @@ import com.facebook.jni.HybridData;
 import com.facebook.proguard.annotations.DoNotStrip;
 import com.facebook.react.bridge.NativeModule;
 import com.facebook.react.turbomodule.core.interfaces.TurboModule;
-import java.util.ArrayList;
+import java.util.Collections;
 import java.util.List;
 
 @Nullsafe(Nullsafe.Mode.LOCAL)
@@ -62,7 +62,7 @@ public abstract class TurboModuleManagerDelegate {
   ;
 
   public List<String> getEagerInitModuleNames() {
-    return new ArrayList<>();
+    return Collections.emptyList();
   }
 
   /** Can the TurboModule system create legacy modules? */
@@ -70,19 +70,6 @@ public abstract class TurboModuleManagerDelegate {
     return false;
   }
 
-  /**
-   * Should the TurboModule system treat all turbo native modules as though they were legacy
-   * modules? This method is for testing purposes only.
-   */
-  public boolean unstable_shouldRouteTurboModulesThroughLegacyModuleInterop() {
-    return false;
-  }
-
-  /* Can TurboModule methods that return void execute on the JS thread? */
-  public boolean unstable_enableSyncVoidMethods() {
-    return false;
-  }
-
   // TODO(T171231381): Consider removing this method: could we just use the static initializer
   // of derived classes instead?
   protected synchronized void maybeLoadOtherSoLibraries() {}

package/ReactAndroid/src/main/java/com/facebook/react/jstasks/HeadlessJsTaskContext.java

@@ -169,26 +169,25 @@ public class HeadlessJsTaskContext {
 
   /**
    * Finish a JS task. Doesn't actually stop the task on the JS side, only removes it from the list
-   * of active tasks and notifies listeners. A task can only be finished once.
+   * of active tasks and notifies listeners.
    *
    * @param taskId the unique id returned by {@link #startTask}.
    */
   public synchronized void finishTask(final int taskId) {
-    Assertions.assertCondition(
-        mActiveTasks.remove(taskId), "Tried to finish non-existent task with id " + taskId + ".");
-    Assertions.assertCondition(
-        mActiveTaskConfigs.remove(taskId) != null,
-        "Tried to remove non-existent task config with id " + taskId + ".");
+    boolean removed = mActiveTasks.remove(taskId);
+    mActiveTaskConfigs.remove(taskId);
     removeTimeout(taskId);
-    UiThreadUtil.runOnUiThread(
-        new Runnable() {
-          @Override
-          public void run() {
-            for (HeadlessJsTaskEventListener listener : mHeadlessJsTaskEventListeners) {
-              listener.onHeadlessJsTaskFinish(taskId);
+    if (removed) {
+      UiThreadUtil.runOnUiThread(
+          new Runnable() {
+            @Override
+            public void run() {
+              for (HeadlessJsTaskEventListener listener : mHeadlessJsTaskEventListeners) {
+                listener.onHeadlessJsTaskFinish(taskId);
+              }
             }
-          }
-        });
+          });
+    }
   }
 
   private void removeTimeout(int taskId) {

package/ReactAndroid/src/main/java/com/facebook/react/modules/appearance/AppearanceModule.kt

@@ -24,7 +24,7 @@ constructor(
     private val overrideColorScheme: OverrideColorScheme? = null
 ) : NativeAppearanceSpec(reactContext) {
 
-  private var colorScheme = colorSchemeForCurrentConfiguration(reactContext)
+  private var lastEmittedColorScheme: String? = null
 
   /** Optional override to the current color scheme */
   public fun interface OverrideColorScheme {
@@ -42,10 +42,10 @@ constructor(
 
     val currentNightMode =
         context.resources.configuration.uiMode and Configuration.UI_MODE_NIGHT_MASK
-    when (currentNightMode) {
-      Configuration.UI_MODE_NIGHT_NO -> return "light"
-      Configuration.UI_MODE_NIGHT_YES -> return "dark"
-      else -> return "light"
+    return when (currentNightMode) {
+      Configuration.UI_MODE_NIGHT_NO -> "light"
+      Configuration.UI_MODE_NIGHT_YES -> "dark"
+      else -> "light"
     }
   }
 
@@ -54,16 +54,16 @@ constructor(
     // scheme. This covers the scenario when AppCompatDelegate.setDefaultNightMode()
     // is called directly (which can occur in Brownfield apps for example).
     val activity = getCurrentActivity()
-    colorScheme = colorSchemeForCurrentConfiguration(activity ?: getReactApplicationContext())
-    return colorScheme
+    return colorSchemeForCurrentConfiguration(activity ?: getReactApplicationContext())
   }
 
   public override fun setColorScheme(style: String) {
-    when {
-      style == "dark" -> AppCompatDelegate.setDefaultNightMode(AppCompatDelegate.MODE_NIGHT_YES)
-      style == "light" -> AppCompatDelegate.setDefaultNightMode(AppCompatDelegate.MODE_NIGHT_NO)
-      style == "unspecified" ->
+    when (style) {
+      "dark" -> AppCompatDelegate.setDefaultNightMode(AppCompatDelegate.MODE_NIGHT_YES)
+      "light" -> AppCompatDelegate.setDefaultNightMode(AppCompatDelegate.MODE_NIGHT_NO)
+      "unspecified" ->
           AppCompatDelegate.setDefaultNightMode(AppCompatDelegate.MODE_NIGHT_FOLLOW_SYSTEM)
+
     }
   }
 
@@ -79,9 +79,9 @@ constructor(
    */
   public fun onConfigurationChanged(currentContext: Context) {
     val newColorScheme = colorSchemeForCurrentConfiguration(currentContext)
-    if (colorScheme != newColorScheme) {
-      colorScheme = newColorScheme
-      emitAppearanceChanged(colorScheme)
+    if (lastEmittedColorScheme != newColorScheme) {
+      lastEmittedColorScheme = newColorScheme
+      emitAppearanceChanged(newColorScheme)
     }
   }
 

package/ReactAndroid/src/main/java/com/facebook/react/modules/blob/FileReaderModule.java

@@ -41,6 +41,9 @@ public class FileReaderModule extends NativeFileReaderModuleSpec {
       promise.reject(
           new IllegalStateException("Could not get BlobModule from ReactApplicationContext"));
       return;
+    } else if (blob == null) {
+      promise.reject(ERROR_INVALID_BLOB, "The specified blob is null");
+      return;
     }
 
     byte[] bytes =
@@ -66,6 +69,9 @@ public class FileReaderModule extends NativeFileReaderModuleSpec {
       promise.reject(
           new IllegalStateException("Could not get BlobModule from ReactApplicationContext"));
       return;
+    } else if (blob == null) {
+      promise.reject(ERROR_INVALID_BLOB, "The specified blob is null");
+      return;
     }
 
     byte[] bytes =

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

@@ -0,0 +1,16 @@
+/*
+ * 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.view.Choreographer
+
+public open class ChoreographerCompat {
+
+  @Deprecated("Use Choreographer.FrameCallback instead")
+  public abstract class FrameCallback : Choreographer.FrameCallback
+}

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

@@ -5,19 +5,17 @@
  * LICENSE file in the root directory of this source tree.
  */
 
-package com.facebook.react.modules.core;
-
+package com.facebook.react.modules.core
 /**
- * Interface used by {@link DeviceEventManagerModule} to delegate hardware back button events. It's
+ * Interface used by [DeviceEventManagerModule] to delegate hardware back button events. It's
  * suppose to provide a default behavior since it would be triggered in the case when JS side
  * doesn't want to handle back press events.
  */
-public interface DefaultHardwareBackBtnHandler {
-
+public fun interface DefaultHardwareBackBtnHandler {
   /**
    * By default, all onBackPress() calls should not execute the default backpress handler and should
    * instead propagate it to the JS instance. If JS doesn't want to handle the back press itself, it
    * shall call back into native to invoke this function which should execute the default handler
    */
-  void invokeDefaultOnBackPressed();
+  public fun invokeDefaultOnBackPressed()
 }

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

@@ -0,0 +1,65 @@
+/*
+ * 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.net.Uri
+import com.facebook.fbreact.specs.NativeDeviceEventManagerSpec
+import com.facebook.proguard.annotations.DoNotStripAny
+import com.facebook.react.bridge.Arguments
+import com.facebook.react.bridge.JavaScriptModule
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.bridge.UiThreadUtil
+import com.facebook.react.module.annotations.ReactModule
+
+/** Native module that handles device hardware events like hardware back presses. */
+@ReactModule(name = NativeDeviceEventManagerSpec.NAME)
+public open class DeviceEventManagerModule(
+    reactContext: ReactApplicationContext?,
+    backBtnHandler: DefaultHardwareBackBtnHandler?
+) : NativeDeviceEventManagerSpec(reactContext) {
+  @DoNotStripAny
+  public fun interface RCTDeviceEventEmitter : JavaScriptModule {
+    public fun emit(eventName: String, data: Any?)
+  }
+
+  private val invokeDefaultBackPressRunnable: Runnable = Runnable {
+    UiThreadUtil.assertOnUiThread()
+    backBtnHandler?.invokeDefaultOnBackPressed()
+  }
+
+  /** Sends an event to the JS instance that the hardware back has been pressed. */
+  public open fun emitHardwareBackPressed() {
+    val reactApplicationContext: ReactApplicationContext? =
+        getReactApplicationContextIfActiveOrWarn()
+    reactApplicationContext?.emitDeviceEvent("hardwareBackPress", null)
+  }
+
+  /** Sends an event to the JS instance that a new intent was received. */
+  public open fun emitNewIntentReceived(uri: Uri) {
+    val reactApplicationContext: ReactApplicationContext? =
+        getReactApplicationContextIfActiveOrWarn()
+    val map = Arguments.createMap()
+    map.putString("url", uri.toString())
+    reactApplicationContext?.emitDeviceEvent("url", map)
+  }
+
+  /**
+   * Invokes the default back handler for the host of this catalyst instance. This should be invoked
+   * if JS does not want to handle the back press itself.
+   */
+  override fun invokeDefaultBackPressHandler() {
+    // There should be no need to check if the catalyst instance is alive. After initialization
+    // the thread instances cannot be null, and scheduling on a thread after ReactApplicationContext
+    // teardown is a noop.
+    getReactApplicationContext().runOnUiQueueThread(invokeDefaultBackPressRunnable)
+  }
+
+  public companion object {
+    public const val NAME: String = NativeDeviceEventManagerSpec.NAME
+  }
+}

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

@@ -0,0 +1,79 @@
+/*
+ * 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.common.logging.FLog
+import com.facebook.fbreact.specs.NativeExceptionsManagerSpec
+import com.facebook.react.bridge.Arguments
+import com.facebook.react.bridge.JavaOnlyMap
+import com.facebook.react.bridge.ReadableArray
+import com.facebook.react.bridge.ReadableMap
+import com.facebook.react.common.JavascriptException
+import com.facebook.react.common.ReactConstants
+import com.facebook.react.devsupport.interfaces.DevSupportManager
+import com.facebook.react.module.annotations.ReactModule
+import com.facebook.react.util.ExceptionDataHelper.getExtraDataAsJson
+import com.facebook.react.util.JSStackTrace.format
+
+@ReactModule(name = NativeExceptionsManagerSpec.NAME)
+public open class ExceptionsManagerModule(private val devSupportManager: DevSupportManager) :
+    NativeExceptionsManagerSpec(null) {
+  override fun reportFatalException(message: String?, stack: ReadableArray?, idDouble: Double) {
+    val id = idDouble.toInt()
+    val data = JavaOnlyMap()
+    data.putString("message", message)
+    data.putArray("stack", stack)
+    data.putInt("id", id)
+    data.putBoolean("isFatal", true)
+    reportException(data)
+  }
+
+  override fun reportSoftException(message: String?, stack: ReadableArray?, idDouble: Double) {
+    val id = idDouble.toInt()
+    val data = JavaOnlyMap()
+    data.putString("message", message)
+    data.putArray("stack", stack)
+    data.putInt("id", id)
+    data.putBoolean("isFatal", false)
+    reportException(data)
+  }
+
+  override fun reportException(data: ReadableMap) {
+    val message = data.getString("message").orEmpty()
+    val stack = data.getArray("stack") ?: Arguments.createArray()
+    val isFatal = if (data.hasKey("isFatal")) data.getBoolean("isFatal") else false
+    val extraDataAsJson = getExtraDataAsJson(data)
+    if (isFatal) {
+      val ex = JavascriptException(format(message, stack))
+      ex.extraDataAsJson = extraDataAsJson
+      throw ex
+    } else {
+      FLog.e(ReactConstants.TAG, format(message, stack))
+      if (extraDataAsJson != null) {
+        FLog.d(ReactConstants.TAG, "extraData: %s", extraDataAsJson)
+      }
+    }
+  }
+
+  override fun updateExceptionMessage(
+      title: String?,
+      details: ReadableArray?,
+      exceptionIdDouble: Double
+  ) {
+    val exceptionId = exceptionIdDouble.toInt()
+    if (devSupportManager.devSupportEnabled) {
+      devSupportManager.updateJSError(title, details, exceptionId)
+    }
+  }
+
+  override fun dismissRedbox() {
+    if (devSupportManager.devSupportEnabled) {
+      devSupportManager.hideRedboxDialog()
+    }
+  }
+}

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

@@ -0,0 +1,51 @@
+/*
+ * 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.common.logging.FLog
+import com.facebook.fbreact.specs.NativeHeadlessJsTaskSupportSpec
+import com.facebook.react.bridge.Promise
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.jstasks.HeadlessJsTaskContext
+import com.facebook.react.module.annotations.ReactModule
+
+/**
+ * Simple native module that allows JS to notify native of having completed some task work, so that
+ * it can e.g. release any resources, stop timers etc.
+ */
+@ReactModule(name = NativeHeadlessJsTaskSupportSpec.NAME)
+public open class HeadlessJsTaskSupportModule(reactContext: ReactApplicationContext?) :
+    NativeHeadlessJsTaskSupportSpec(reactContext) {
+  override fun notifyTaskRetry(taskIdDouble: Double, promise: Promise) {
+    val taskId = taskIdDouble.toInt()
+    val headlessJsTaskContext = HeadlessJsTaskContext.getInstance(getReactApplicationContext())
+    if (headlessJsTaskContext.isTaskRunning(taskId)) {
+      val retryPosted = headlessJsTaskContext.retryTask(taskId)
+      promise.resolve(retryPosted)
+    } else {
+      FLog.w(
+          HeadlessJsTaskSupportModule::class.java,
+          "Tried to retry non-active task with id %d. Did it time out?",
+          taskId)
+      promise.resolve(false)
+    }
+  }
+
+  override fun notifyTaskFinished(taskIdDouble: Double) {
+    val taskId = taskIdDouble.toInt()
+    val headlessJsTaskContext = HeadlessJsTaskContext.getInstance(getReactApplicationContext())
+    if (headlessJsTaskContext.isTaskRunning(taskId)) {
+      headlessJsTaskContext.finishTask(taskId)
+    } else {
+      FLog.w(
+          HeadlessJsTaskSupportModule::class.java,
+          "Tried to finish non-active task with id %d. Did it time out?",
+          taskId)
+    }
+  }
+}

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

@@ -0,0 +1,21 @@
+/*
+ * 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
+import com.facebook.react.bridge.WritableArray
+
+@DoNotStrip
+public interface JSTimers : JavaScriptModule {
+  public fun callTimers(timerIDs: WritableArray)
+
+  public fun callIdleCallbacks(frameTime: Double)
+
+  public fun emitTimeDriftWarning(warningMessage: String)
+}

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

@@ -5,33 +5,32 @@
  * LICENSE file in the root directory of this source tree.
  */
 
-package com.facebook.react.modules.core;
+package com.facebook.react.modules.core
 
-import com.facebook.react.bridge.WritableArray;
+import com.facebook.react.bridge.WritableArray
 
-/** An interface used by {@link JavaTimerManager} to access and call JS timers from Java. */
+/** An interface used by [JavaTimerManager] to access and call JS timers from Java. */
 public interface JavaScriptTimerExecutor {
-
   /**
    * Calls the JS callback(s) associated with the timer ID(s). Also unregisters the callback if the
    * timer isn't recurring (e.g. unregisters for setTimeout, doesn't for setInterval).
    *
    * @param timerIDs An array of timer handles to call. Accepts an array as an optimization, to
-   *     avoid unnecessary JNI calls.
+   *   avoid unnecessary JNI calls.
    */
-  void callTimers(WritableArray timerIDs);
+  public fun callTimers(timerIDs: WritableArray)
 
   /**
    * Invoke the JS callback registered with `requestIdleCallback`.
    *
    * @param frameTime The amount of time left in the frame, in ms.
    */
-  void callIdleCallbacks(double frameTime);
+  public fun callIdleCallbacks(frameTime: Double)
 
   /**
    * Shows a warning message in development when environment times are out of sync.
    *
    * @param warningMessage The message to show
    */
-  void emitTimeDriftWarning(String warningMessage);
+  public fun emitTimeDriftWarning(warningMessage: String)
 }