react-native-tvos 0.74.5-0 → 0.75.2-0rc0

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

@@ -12,12 +12,14 @@ import android.view.Choreographer;
 import androidx.annotation.Nullable;
 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;
 import com.facebook.react.devsupport.interfaces.DevSupportManager;
 import com.facebook.react.jstasks.HeadlessJsTaskContext;
+import com.facebook.react.jstasks.HeadlessJsTaskEventListener;
 import java.util.Comparator;
 import java.util.PriorityQueue;
 import java.util.concurrent.atomic.AtomicBoolean;
@@ -28,7 +30,7 @@ import java.util.concurrent.atomic.AtomicBoolean;
  *
  * <p>This is used by the NativeModule {@link TimingModule}.
  */
-public class JavaTimerManager {
+public class JavaTimerManager implements LifecycleEventListener, HeadlessJsTaskEventListener {
 
   // 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.
@@ -199,19 +201,24 @@ public class JavaTimerManager {
               }
             });
     mTimerIdsToTimers = new SparseArray<>();
+
+    mReactApplicationContext.addLifecycleEventListener(this);
   }
 
+  @Override
   public void onHostPause() {
     isPaused.set(true);
     clearFrameCallback();
     maybeIdleCallback();
   }
 
+  @Override
   public void onHostDestroy() {
     clearFrameCallback();
     maybeIdleCallback();
   }
 
+  @Override
   public void onHostResume() {
     isPaused.set(false);
     // TODO(5195192) Investigate possible problems related to restarting all tasks at the same
@@ -220,6 +227,7 @@ public class JavaTimerManager {
     maybeSetChoreographerIdleCallback();
   }
 
+  @Override
   public void onHeadlessJsTaskStart(int taskId) {
     if (!isRunningTasks.getAndSet(true)) {
       setChoreographerCallback();
@@ -227,6 +235,7 @@ public class JavaTimerManager {
     }
   }
 
+  @Override
   public void onHeadlessJsTaskFinish(int taskId) {
     HeadlessJsTaskContext headlessJsTaskContext =
         HeadlessJsTaskContext.getInstance(mReactApplicationContext);
@@ -238,6 +247,8 @@ public class JavaTimerManager {
   }
 
   public void onInstanceDestroy() {
+    mReactApplicationContext.removeLifecycleEventListener(this);
+
     clearFrameCallback();
     clearChoreographerIdleCallback();
   }

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

@@ -8,49 +8,16 @@
 package com.facebook.react.modules.core;
 
 import com.facebook.fbreact.specs.NativeTimingSpec;
-import com.facebook.react.bridge.LifecycleEventListener;
 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.jstasks.HeadlessJsTaskEventListener;
 import com.facebook.react.module.annotations.ReactModule;
 
 /** Native module for JS timer execution. Timers fire on frame boundaries. */
 @ReactModule(name = NativeTimingSpec.NAME)
-public final class TimingModule extends NativeTimingSpec
-    implements LifecycleEventListener, HeadlessJsTaskEventListener {
-
-  public class BridgeTimerExecutor implements JavaScriptTimerExecutor {
-    @Override
-    public void callTimers(WritableArray timerIDs) {
-      ReactApplicationContext reactApplicationContext = getReactApplicationContextIfActiveOrWarn();
-
-      if (reactApplicationContext != null) {
-        reactApplicationContext.getJSModule(JSTimers.class).callTimers(timerIDs);
-      }
-    }
-
-    @Override
-    public void callIdleCallbacks(double frameTime) {
-      ReactApplicationContext reactApplicationContext = getReactApplicationContextIfActiveOrWarn();
-
-      if (reactApplicationContext != null) {
-        reactApplicationContext.getJSModule(JSTimers.class).callIdleCallbacks(frameTime);
-      }
-    }
-
-    @Override
-    public void emitTimeDriftWarning(String warningMessage) {
-      ReactApplicationContext reactApplicationContext = getReactApplicationContextIfActiveOrWarn();
-
-      if (reactApplicationContext != null) {
-        reactApplicationContext.getJSModule(JSTimers.class).emitTimeDriftWarning(warningMessage);
-      }
-    }
-  }
-
+public final class TimingModule extends NativeTimingSpec implements JavaScriptTimerExecutor {
   private final JavaTimerManager mJavaTimerManager;
 
   public TimingModule(ReactApplicationContext reactContext, DevSupportManager devSupportManager) {
@@ -58,18 +25,14 @@ public final class TimingModule extends NativeTimingSpec
 
     mJavaTimerManager =
         new JavaTimerManager(
-            reactContext,
-            new BridgeTimerExecutor(),
-            ReactChoreographer.getInstance(),
-            devSupportManager);
+            reactContext, this, ReactChoreographer.getInstance(), devSupportManager);
   }
 
   @Override
   public void initialize() {
-    getReactApplicationContext().addLifecycleEventListener(this);
     HeadlessJsTaskContext headlessJsTaskContext =
         HeadlessJsTaskContext.getInstance(getReactApplicationContext());
-    headlessJsTaskContext.addTaskEventListener(this);
+    headlessJsTaskContext.addTaskEventListener(mJavaTimerManager);
   }
 
   @Override
@@ -97,28 +60,30 @@ public final class TimingModule extends NativeTimingSpec
   }
 
   @Override
-  public void onHostResume() {
-    mJavaTimerManager.onHostResume();
-  }
+  public void callTimers(WritableArray timerIDs) {
+    ReactApplicationContext reactApplicationContext = getReactApplicationContextIfActiveOrWarn();
 
-  @Override
-  public void onHostPause() {
-    mJavaTimerManager.onHostPause();
+    if (reactApplicationContext != null) {
+      reactApplicationContext.getJSModule(JSTimers.class).callTimers(timerIDs);
+    }
   }
 
   @Override
-  public void onHostDestroy() {
-    mJavaTimerManager.onHostDestroy();
-  }
+  public void callIdleCallbacks(double frameTime) {
+    ReactApplicationContext reactApplicationContext = getReactApplicationContextIfActiveOrWarn();
 
-  @Override
-  public void onHeadlessJsTaskStart(int taskId) {
-    mJavaTimerManager.onHeadlessJsTaskStart(taskId);
+    if (reactApplicationContext != null) {
+      reactApplicationContext.getJSModule(JSTimers.class).callIdleCallbacks(frameTime);
+    }
   }
 
   @Override
-  public void onHeadlessJsTaskFinish(int taskId) {
-    mJavaTimerManager.onHeadlessJsTaskFinish(taskId);
+  public void emitTimeDriftWarning(String warningMessage) {
+    ReactApplicationContext reactApplicationContext = getReactApplicationContextIfActiveOrWarn();
+
+    if (reactApplicationContext != null) {
+      reactApplicationContext.getJSModule(JSTimers.class).emitTimeDriftWarning(warningMessage);
+    }
   }
 
   @Override
@@ -127,9 +92,9 @@ public final class TimingModule extends NativeTimingSpec
 
     HeadlessJsTaskContext headlessJsTaskContext =
         HeadlessJsTaskContext.getInstance(reactApplicationContext);
-    headlessJsTaskContext.removeTaskEventListener(this);
+    headlessJsTaskContext.removeTaskEventListener(mJavaTimerManager);
+
     mJavaTimerManager.onInstanceDestroy();
-    reactApplicationContext.removeLifecycleEventListener(this);
   }
 
   @VisibleForTesting

package/ReactAndroid/src/main/java/com/facebook/react/modules/debug/DevSettingsModule.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.debug
+
+import com.facebook.fbreact.specs.NativeDevSettingsSpec
+import com.facebook.react.bridge.Arguments
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.bridge.UiThreadUtil
+import com.facebook.react.devsupport.interfaces.DevSupportManager
+import com.facebook.react.module.annotations.ReactModule
+
+/**
+ * Module that exposes the URL to the source code map (used for exception stack trace parsing) to JS
+ */
+@ReactModule(name = NativeDevSettingsSpec.NAME)
+public class DevSettingsModule(
+    reactContext: ReactApplicationContext?,
+    private val devSupportManager: DevSupportManager
+) : NativeDevSettingsSpec(reactContext) {
+  override fun reload() {
+    if (devSupportManager.devSupportEnabled) {
+      UiThreadUtil.runOnUiThread { devSupportManager.handleReloadJS() }
+    }
+  }
+
+  override fun reloadWithReason(reason: String) {
+    reload()
+  }
+
+  override fun onFastRefresh() {
+    // noop
+  }
+
+  override fun setHotLoadingEnabled(isHotLoadingEnabled: Boolean) {
+    devSupportManager.setHotModuleReplacementEnabled(isHotLoadingEnabled)
+  }
+
+  override fun setIsDebuggingRemotely(isDebugginRemotelyEnabled: Boolean) {
+    devSupportManager.setRemoteJSDebugEnabled(isDebugginRemotelyEnabled)
+  }
+
+  override fun setProfilingEnabled(isProfilingEnabled: Boolean) {
+    devSupportManager.setFpsDebugEnabled(isProfilingEnabled)
+  }
+
+  override fun toggleElementInspector() {
+    devSupportManager.toggleElementInspector()
+  }
+
+  override fun addMenuItem(title: String) {
+    devSupportManager.addCustomDevOption(title) {
+      val data = Arguments.createMap()
+      data.putString("title", title)
+      val reactApplicationContext = reactApplicationContextIfActiveOrWarn
+      reactApplicationContext?.emitDeviceEvent("didPressMenuItem", data)
+    }
+  }
+
+  override fun openDebugger() {
+    devSupportManager.openDebugger()
+  }
+
+  override fun setIsShakeToShowDevMenuEnabled(enabled: Boolean) {
+    // iOS only
+  }
+
+  override fun addListener(eventName: String) {
+    // iOS only
+  }
+
+  override fun removeListeners(count: Double) {
+    // iOS only
+  }
+}

package/ReactAndroid/src/main/java/com/facebook/react/modules/debug/DidJSUpdateUiDuringFrameDetector.kt

@@ -0,0 +1,158 @@
+/*
+ * 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.debug
+
+import com.facebook.react.bridge.NotThreadSafeBridgeIdleDebugListener
+import com.facebook.react.common.LongArray
+import com.facebook.react.uimanager.debug.NotThreadSafeViewHierarchyUpdateDebugListener
+
+/**
+ * Debug object that listens to bridge busy/idle events and UiManagerModule dispatches and uses it
+ * to calculate whether JS was able to update the UI during a given frame. After being installed on
+ * a [ReactBridge] and a [UIManagerModule], [.getDidJSHitFrameAndCleanup] should be called once per
+ * frame via a [Choreographer.FrameCallback].
+ */
+internal class DidJSUpdateUiDuringFrameDetector :
+    NotThreadSafeBridgeIdleDebugListener, NotThreadSafeViewHierarchyUpdateDebugListener {
+  private val transitionToIdleEvents = LongArray.createWithInitialCapacity(20)
+  private val transitionToBusyEvents = LongArray.createWithInitialCapacity(20)
+  private val viewHierarchyUpdateEnqueuedEvents = LongArray.createWithInitialCapacity(20)
+  private val viewHierarchyUpdateFinishedEvents = LongArray.createWithInitialCapacity(20)
+  @Volatile private var wasIdleAtEndOfLastFrame = true
+
+  @Synchronized
+  override fun onTransitionToBridgeIdle() {
+    transitionToIdleEvents.add(System.nanoTime())
+  }
+
+  @Synchronized
+  override fun onTransitionToBridgeBusy() {
+    transitionToBusyEvents.add(System.nanoTime())
+  }
+
+  @Synchronized
+  override fun onBridgeDestroyed() {
+    // do nothing
+  }
+
+  @Synchronized
+  override fun onViewHierarchyUpdateEnqueued() {
+    viewHierarchyUpdateEnqueuedEvents.add(System.nanoTime())
+  }
+
+  @Synchronized
+  override fun onViewHierarchyUpdateFinished() {
+    viewHierarchyUpdateFinishedEvents.add(System.nanoTime())
+  }
+
+  /**
+   * Designed to be called from a [Choreographer.FrameCallback.doFrame] call.
+   *
+   * There are two 'success' cases that will cause [.getDidJSHitFrameAndCleanup] to return true for
+   * a given frame:
+   * 1. UIManagerModule finished dispatching a batched UI update on the UI thread during the frame.
+   *    This means that during the next hierarchy traversal, new UI will be drawn if needed (good).
+   * 1. The bridge ended the frame idle (meaning there were no JS nor native module calls still in
+   *    flight) AND there was no UiManagerModule update enqueued that didn't also finish. NB: if
+   *    there was one enqueued that actually finished, we'd have case 1), so effectively we just
+   *    look for whether one was enqueued.
+   *
+   * NB: This call can only be called once for a given frame time range because it cleans up events
+   * it recorded for that frame.
+   *
+   * NB2: This makes the assumption that onViewHierarchyUpdateEnqueued is called from the
+   * [ ][UIManagerModule.onBatchComplete], e.g. while the bridge is still considered busy, which
+   * means there is no race condition where the bridge has gone idle but a hierarchy update is
+   * waiting to be enqueued.
+   *
+   * @param frameStartTimeNanos the time in nanos that the last frame started
+   * @param frameEndTimeNanos the time in nanos that the last frame ended
+   */
+  @Synchronized
+  fun getDidJSHitFrameAndCleanup(frameStartTimeNanos: Long, frameEndTimeNanos: Long): Boolean {
+    // Case 1: We dispatched a UI update
+    val finishedUiUpdate =
+        hasEventBetweenTimestamps(
+            viewHierarchyUpdateFinishedEvents, frameStartTimeNanos, frameEndTimeNanos)
+    val didEndFrameIdle = didEndFrameIdle(frameStartTimeNanos, frameEndTimeNanos)
+    val hitFrame =
+        if (finishedUiUpdate) {
+          true
+        } else {
+          // Case 2: Ended idle but no UI was enqueued during that frame
+          (didEndFrameIdle &&
+              !hasEventBetweenTimestamps(
+                  viewHierarchyUpdateEnqueuedEvents, frameStartTimeNanos, frameEndTimeNanos))
+        }
+    cleanUp(transitionToIdleEvents, frameEndTimeNanos)
+    cleanUp(transitionToBusyEvents, frameEndTimeNanos)
+    cleanUp(viewHierarchyUpdateEnqueuedEvents, frameEndTimeNanos)
+    cleanUp(viewHierarchyUpdateFinishedEvents, frameEndTimeNanos)
+    wasIdleAtEndOfLastFrame = didEndFrameIdle
+    return hitFrame
+  }
+
+  private fun didEndFrameIdle(startTime: Long, endTime: Long): Boolean {
+    val lastIdleTransition =
+        getLastEventBetweenTimestamps(transitionToIdleEvents, startTime, endTime)
+    val lastBusyTransition =
+        getLastEventBetweenTimestamps(transitionToBusyEvents, startTime, endTime)
+    return if (lastIdleTransition == -1L && lastBusyTransition == -1L) {
+      wasIdleAtEndOfLastFrame
+    } else lastIdleTransition > lastBusyTransition
+  }
+
+  companion object {
+    private fun hasEventBetweenTimestamps(
+        eventArray: LongArray,
+        startTime: Long,
+        endTime: Long
+    ): Boolean {
+      for (i in 0 until eventArray.size()) {
+        val time = eventArray[i]
+        if (time in startTime until endTime) {
+          return true
+        }
+      }
+      return false
+    }
+
+    private fun getLastEventBetweenTimestamps(
+        eventArray: LongArray,
+        startTime: Long,
+        endTime: Long
+    ): Long {
+      var lastEvent: Long = -1
+      for (i in 0 until eventArray.size()) {
+        val time = eventArray[i]
+        if (time in startTime until endTime) {
+          lastEvent = time
+        } else if (time >= endTime) {
+          break
+        }
+      }
+      return lastEvent
+    }
+
+    private fun cleanUp(eventArray: LongArray, endTime: Long) {
+      val size = eventArray.size()
+      var indicesToRemove = 0
+      for (i in 0 until size) {
+        if (eventArray[i] < endTime) {
+          indicesToRemove++
+        }
+      }
+      if (indicesToRemove > 0) {
+        for (i in 0 until size - indicesToRemove) {
+          eventArray[i] = eventArray[i + indicesToRemove]
+        }
+        eventArray.dropTail(indicesToRemove)
+      }
+    }
+  }
+}

package/ReactAndroid/src/main/java/com/facebook/react/modules/debug/FpsDebugFrameCallback.kt

@@ -0,0 +1,172 @@
+/*
+ * 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.debug
+
+import android.view.Choreographer
+import com.facebook.infer.annotation.Assertions
+import com.facebook.react.bridge.ReactContext
+import com.facebook.react.bridge.UiThreadUtil
+import com.facebook.react.uimanager.UIManagerModule
+import java.util.TreeMap
+
+/**
+ * Each time a frame is drawn, records whether it should have expected any more callbacks since the
+ * last time a frame was drawn (i.e. was a frame skipped?). Uses this plus total elapsed time to
+ * determine FPS. Can also record total and expected frame counts, though NB, since the expected
+ * frame rate is estimated, the expected frame count will lose accuracy over time.
+ *
+ * Also records the JS FPS, i.e. the frames per second with which either JS updated the UI or was
+ * idle and not trying to update the UI. This is different from the FPS above since JS rendering is
+ * async.
+ */
+public class FpsDebugFrameCallback(private val reactContext: ReactContext) :
+    Choreographer.FrameCallback {
+  public class FpsInfo(
+      public val totalFrames: Int,
+      public val totalJsFrames: Int,
+      public val totalExpectedFrames: Int,
+      public val total4PlusFrameStutters: Int,
+      public val fps: Double,
+      public val jsFps: Double,
+      public val totalTimeMs: Int
+  )
+
+  private var choreographer: Choreographer? = null
+  private val uiManagerModule: UIManagerModule? =
+      reactContext.getNativeModule(UIManagerModule::class.java)
+  private val didJSUpdateUiDuringFrameDetector: DidJSUpdateUiDuringFrameDetector =
+      DidJSUpdateUiDuringFrameDetector()
+  private var firstFrameTime: Long = -1
+  private var lastFrameTime: Long = -1
+  private var numFrameCallbacks = 0
+  private var expectedNumFramesPrev = 0
+  private var fourPlusFrameStutters = 0
+  private var numFrameCallbacksWithBatchDispatches = 0
+  private var isRecordingFpsInfoAtEachFrame = false
+  private var targetFps = DEFAULT_FPS
+  private var timeToFps: TreeMap<Long, FpsInfo>? = null
+
+  override fun doFrame(l: Long) {
+    if (firstFrameTime == -1L) {
+      firstFrameTime = l
+    }
+    val lastFrameStartTime = lastFrameTime
+    lastFrameTime = l
+    if (didJSUpdateUiDuringFrameDetector.getDidJSHitFrameAndCleanup(lastFrameStartTime, l)) {
+      numFrameCallbacksWithBatchDispatches++
+    }
+    numFrameCallbacks++
+    val expectedNumFrames = expectedNumFrames
+    val framesDropped = expectedNumFrames - expectedNumFramesPrev - 1
+    if (framesDropped >= 4) {
+      fourPlusFrameStutters++
+    }
+    if (isRecordingFpsInfoAtEachFrame) {
+      Assertions.assertNotNull(timeToFps)
+      val info =
+          FpsInfo(
+              numFrames,
+              numJSFrames,
+              expectedNumFrames,
+              fourPlusFrameStutters,
+              fps,
+              jsFPS,
+              totalTimeMS)
+      timeToFps?.put(System.currentTimeMillis(), info)
+    }
+    expectedNumFramesPrev = expectedNumFrames
+    choreographer?.postFrameCallback(this)
+  }
+
+  @JvmOverloads
+  public fun start(targetFps: Double = this.targetFps) {
+    // T172641976: re-think if we need to implement addBridgeIdleDebugListener and
+    // removeBridgeIdleDebugListener for Bridgeless
+    @Suppress("DEPRECATION")
+    if (!reactContext.isBridgeless) {
+      reactContext.catalystInstance.addBridgeIdleDebugListener(didJSUpdateUiDuringFrameDetector)
+    }
+    uiManagerModule?.setViewHierarchyUpdateDebugListener(didJSUpdateUiDuringFrameDetector)
+    this.targetFps = targetFps
+    UiThreadUtil.runOnUiThread {
+      choreographer = Choreographer.getInstance()
+      choreographer?.postFrameCallback(this)
+    }
+  }
+
+  public fun startAndRecordFpsAtEachFrame() {
+    timeToFps = TreeMap()
+    isRecordingFpsInfoAtEachFrame = true
+    start()
+  }
+
+  public fun stop() {
+    @Suppress("DEPRECATION")
+    if (!reactContext.isBridgeless) {
+      reactContext.catalystInstance.removeBridgeIdleDebugListener(didJSUpdateUiDuringFrameDetector)
+    }
+    uiManagerModule?.setViewHierarchyUpdateDebugListener(null)
+    UiThreadUtil.runOnUiThread {
+      choreographer = Choreographer.getInstance()
+      choreographer?.removeFrameCallback(this)
+    }
+  }
+
+  public val fps: Double
+    get() =
+        if (lastFrameTime == firstFrameTime) {
+          0.0
+        } else numFrames.toDouble() * 1e9 / (lastFrameTime - firstFrameTime)
+
+  public val jsFPS: Double
+    get() =
+        if (lastFrameTime == firstFrameTime) {
+          0.0
+        } else numJSFrames.toDouble() * 1e9 / (lastFrameTime - firstFrameTime)
+
+  public val numFrames: Int
+    get() = numFrameCallbacks - 1
+
+  public val numJSFrames: Int
+    get() = numFrameCallbacksWithBatchDispatches - 1
+
+  public val expectedNumFrames: Int
+    get() {
+      val totalTimeMS = totalTimeMS.toDouble()
+      return (targetFps * totalTimeMS / 1000 + 1).toInt()
+    }
+
+  public fun get4PlusFrameStutters(): Int = fourPlusFrameStutters
+
+  public val totalTimeMS: Int
+    get() = (lastFrameTime.toDouble() - firstFrameTime).toInt() / 1000000
+
+  /**
+   * Returns the FpsInfo as if stop had been called at the given upToTimeMs. Only valid if
+   * monitoring was started with [.startAndRecordFpsAtEachFrame].
+   */
+  public fun getFpsInfo(upToTimeMs: Long): FpsInfo? {
+    Assertions.assertNotNull(timeToFps, "FPS was not recorded at each frame!")
+    val (_, value) = timeToFps?.floorEntry(upToTimeMs) ?: return null
+    return value
+  }
+
+  public fun reset() {
+    firstFrameTime = -1
+    lastFrameTime = -1
+    numFrameCallbacks = 0
+    fourPlusFrameStutters = 0
+    numFrameCallbacksWithBatchDispatches = 0
+    isRecordingFpsInfoAtEachFrame = false
+    timeToFps = null
+  }
+
+  private companion object {
+    private const val DEFAULT_FPS = 60.0
+  }
+}

package/ReactAndroid/src/main/java/com/facebook/react/modules/debug/SourceCodeModule.kt

@@ -0,0 +1,27 @@
+/*
+ * 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.debug
+
+import com.facebook.fbreact.specs.NativeSourceCodeSpec
+import com.facebook.infer.annotation.Assertions
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.module.annotations.ReactModule
+
+/**
+ * Module that exposes the URL to the source code map (used for exception stack trace parsing) to JS
+ */
+@ReactModule(name = NativeSourceCodeSpec.NAME)
+public class SourceCodeModule(reactContext: ReactApplicationContext) :
+    NativeSourceCodeSpec(reactContext) {
+  override protected fun getTypedExportedConstants(): Map<String, Any> =
+      mapOf(
+          "scriptURL" to
+              Assertions.assertNotNull<String>(
+                  getReactApplicationContext().getSourceURL(),
+                  "No source URL loaded, have you initialised the instance?"))
+}

package/ReactAndroid/src/main/java/com/facebook/react/modules/debug/interfaces/DeveloperSettings.kt

@@ -0,0 +1,46 @@
+/*
+ * 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.debug.interfaces
+
+import com.facebook.react.packagerconnection.PackagerConnectionSettings
+
+/** Provides access to React Native developers settings. */
+public interface DeveloperSettings {
+  /** Return the underlying [PackagerConnectionSettings] instance. */
+  public val packagerConnectionSettings: PackagerConnectionSettings
+
+  /** Whether an overlay showing current FPS should be shown. */
+  public var isFpsDebugEnabled: Boolean
+
+  /** Whether debug information about transitions should be displayed. */
+  public var isAnimationFpsDebugEnabled: Boolean
+
+  /** Whether dev mode should be enabled in JS bundles. */
+  public var isJSDevModeEnabled: Boolean
+
+  /** Whether JS bundle should be minified. */
+  public var isJSMinifyEnabled: Boolean
+
+  /** Whether element inspector is enabled. */
+  public var isElementInspectorEnabled: Boolean
+
+  /** Whether Nuclide JS debugging is enabled. */
+  public var isDeviceDebugEnabled: Boolean
+
+  /** Whether remote JS debugging is enabled. */
+  public var isRemoteJSDebugEnabled: Boolean
+
+  /** Whether Start Sampling Profiler on App Start is enabled. */
+  public var isStartSamplingProfilerOnInit: Boolean
+
+  /** Whether HMR is enabled. */
+  public var isHotModuleReplacementEnabled: Boolean
+
+  /** Add an item to the dev menu. */
+  public fun addMenuItem(title: String)
+}