react-native-tvos 0.85.2-0 → 0.86.0-0rc2

package/ReactAndroid/src/main/java/com/facebook/react/bridge/ReactContext.java

@@ -15,6 +15,7 @@ import android.content.ContextWrapper;
 import android.content.Intent;
 import android.os.Bundle;
 import android.view.LayoutInflater;
+import android.view.Window;
 import androidx.annotation.NonNull;
 import androidx.annotation.Nullable;
 import com.facebook.common.logging.FLog;
@@ -25,6 +26,7 @@ import com.facebook.react.bridge.interop.InteropModuleRegistry;
 import com.facebook.react.bridge.queue.MessageQueueThread;
 import com.facebook.react.bridge.queue.ReactQueueConfiguration;
 import com.facebook.react.common.LifecycleState;
+import com.facebook.react.interfaces.ExtraWindowEventListener;
 import com.facebook.react.turbomodule.core.interfaces.CallInvokerHolder;
 import java.lang.ref.WeakReference;
 import java.util.Collection;
@@ -48,6 +50,8 @@ public abstract class ReactContext extends ContextWrapper {
       new CopyOnWriteArraySet<>();
   private final CopyOnWriteArraySet<ActivityEventListener> mActivityEventListeners =
       new CopyOnWriteArraySet<>();
+  private final CopyOnWriteArraySet<ExtraWindowEventListener> mExtraWindowEventListeners =
+      new CopyOnWriteArraySet<>();
   private final CopyOnWriteArraySet<WindowFocusChangeListener> mWindowFocusEventListeners =
       new CopyOnWriteArraySet<>();
   private final ScrollEndedListeners mScrollEndedListeners = new ScrollEndedListeners();
@@ -246,6 +250,14 @@ public abstract class ReactContext extends ContextWrapper {
     mActivityEventListeners.remove(listener);
   }
 
+  public void addExtraWindowEventListener(ExtraWindowEventListener listener) {
+    mExtraWindowEventListeners.add(listener);
+  }
+
+  public void removeExtraWindowEventListener(ExtraWindowEventListener listener) {
+    mExtraWindowEventListeners.remove(listener);
+  }
+
   public void addWindowFocusChangeListener(WindowFocusChangeListener listener) {
     mWindowFocusEventListeners.add(listener);
   }
@@ -356,6 +368,30 @@ public abstract class ReactContext extends ContextWrapper {
     }
   }
 
+  @ThreadConfined(UI)
+  public void onExtraWindowCreate(Window window) {
+    UiThreadUtil.assertOnUiThread();
+    for (ExtraWindowEventListener listener : mExtraWindowEventListeners) {
+      try {
+        listener.onExtraWindowCreate(window);
+      } catch (RuntimeException e) {
+        handleException(e);
+      }
+    }
+  }
+
+  @ThreadConfined(UI)
+  public void onExtraWindowDestroy(Window window) {
+    UiThreadUtil.assertOnUiThread();
+    for (ExtraWindowEventListener listener : mExtraWindowEventListeners) {
+      try {
+        listener.onExtraWindowDestroy(window);
+      } catch (RuntimeException e) {
+        handleException(e);
+      }
+    }
+  }
+
   @ThreadConfined(UI)
   public void onWindowFocusChange(boolean hasFocus) {
     UiThreadUtil.assertOnUiThread();

package/ReactAndroid/src/main/java/com/facebook/react/bridge/ReactNativeJNISoLoader.kt

@@ -9,7 +9,9 @@ package com.facebook.react.bridge
 
 import com.facebook.react.common.annotations.internal.InteropLegacyArchitecture
 import com.facebook.soloader.SoLoader
+import com.facebook.soloader.annotation.SoLoaderLibrary
 
+@SoLoaderLibrary("reactnativejni")
 @InteropLegacyArchitecture
 internal object ReactNativeJNISoLoader {
 

package/ReactAndroid/src/main/java/com/facebook/react/bridge/ReactNativeJniCommonSoLoader.kt

@@ -8,7 +8,9 @@
 package com.facebook.react.bridge
 
 import com.facebook.soloader.SoLoader
+import com.facebook.soloader.annotation.SoLoaderLibrary
 
+@SoLoaderLibrary("reactnativejni_common")
 internal object ReactNativeJniCommonSoLoader {
 
   @JvmStatic

package/ReactAndroid/src/main/java/com/facebook/react/bridge/ReactSoftExceptionLogger.kt

@@ -11,6 +11,7 @@ import androidx.annotation.StringDef
 import com.facebook.common.logging.FLog
 import com.facebook.proguard.annotations.DoNotStrip
 import com.facebook.react.bridge.ReactSoftExceptionLogger.Categories.CLIPPING_PROHIBITED_VIEW
+import com.facebook.react.bridge.ReactSoftExceptionLogger.Categories.RVG_ADD_CHILDREN_FOR_ACCESSIBILITY
 import com.facebook.react.bridge.ReactSoftExceptionLogger.Categories.RVG_IS_VIEW_CLIPPED
 import com.facebook.react.bridge.ReactSoftExceptionLogger.Categories.RVG_ON_VIEW_REMOVED
 import com.facebook.react.bridge.ReactSoftExceptionLogger.Categories.SOFT_ASSERTIONS
@@ -21,6 +22,7 @@ import java.util.concurrent.CopyOnWriteArrayList
 internal object ReactSoftExceptionLogger {
   @Retention(AnnotationRetention.SOURCE)
   @StringDef(
+      RVG_ADD_CHILDREN_FOR_ACCESSIBILITY,
       RVG_IS_VIEW_CLIPPED,
       RVG_ON_VIEW_REMOVED,
       CLIPPING_PROHIBITED_VIEW,
@@ -31,6 +33,8 @@ internal object ReactSoftExceptionLogger {
 
   /** Constants that listeners can utilize for custom category-based behavior. */
   object Categories {
+    const val RVG_ADD_CHILDREN_FOR_ACCESSIBILITY: String =
+        "ReactViewGroup.addChildrenForAccessibility"
     const val RVG_IS_VIEW_CLIPPED: String = "ReactViewGroup.isViewClipped"
     const val RVG_ON_VIEW_REMOVED: String = "ReactViewGroup.onViewRemoved"
     const val CLIPPING_PROHIBITED_VIEW: String = "ReactClippingProhibitedView"

package/ReactAndroid/src/main/java/com/facebook/react/defaults/DefaultSoLoader.kt

@@ -8,7 +8,9 @@
 package com.facebook.react.defaults
 
 import com.facebook.soloader.SoLoader
+import com.facebook.soloader.annotation.SoLoaderLibrary
 
+@SoLoaderLibrary("react_newarchdefaults")
 internal object DefaultSoLoader {
   @Synchronized
   @JvmStatic

package/ReactAndroid/src/main/java/com/facebook/react/devsupport/FpsView.kt

@@ -23,7 +23,7 @@ import java.util.Locale
  *
  * NB: Requires API 16 for use of FpsDebugFrameCallback.
  */
-internal class FpsView(reactContext: ReactContext?) : FrameLayout(reactContext!!) {
+internal class FpsView(reactContext: ReactContext) : FrameLayout(reactContext) {
   private val textView: TextView
   private val frameCallback: FpsDebugFrameCallback
   private val fpsMonitorRunnable: FPSMonitorRunnable
@@ -31,7 +31,7 @@ internal class FpsView(reactContext: ReactContext?) : FrameLayout(reactContext!!
   init {
     inflate(reactContext, R.layout.fps_view, this)
     textView = findViewById<View>(R.id.fps_text) as TextView
-    frameCallback = FpsDebugFrameCallback(reactContext!!)
+    frameCallback = FpsDebugFrameCallback(reactContext)
     fpsMonitorRunnable = FPSMonitorRunnable()
     setCurrentFPS(0.0, 0.0, 0, 0, frameCallback.isRunningOnFabric)
   }

package/ReactAndroid/src/main/java/com/facebook/react/devsupport/InspectorFlags.kt

@@ -9,15 +9,21 @@ package com.facebook.react.devsupport
 
 import com.facebook.proguard.annotations.DoNotStrip
 import com.facebook.soloader.SoLoader
+import com.facebook.soloader.annotation.SoLoaderLibrary
 
 /** JNI wrapper for `jsinspector_modern::InspectorFlags`. */
+@SoLoaderLibrary("react_devsupportjni")
 @DoNotStrip
 internal object InspectorFlags {
   init {
     SoLoader.loadLibrary("react_devsupportjni")
   }
 
+  @DoNotStrip @JvmStatic external fun getScreenshotCaptureEnabled(): Boolean
+
   @DoNotStrip @JvmStatic external fun getFuseboxEnabled(): Boolean
 
   @DoNotStrip @JvmStatic external fun getIsProfilingBuild(): Boolean
+
+  @DoNotStrip @JvmStatic external fun getFrameRecordingEnabled(): Boolean
 }

package/ReactAndroid/src/main/java/com/facebook/react/devsupport/LogBoxDialogSurfaceDelegate.kt

@@ -45,7 +45,7 @@ internal class LogBoxDialogSurfaceDelegate(private val devSupportManager: DevSup
   }
 
   override fun show() {
-    if (isShowing() || !isContentViewReady()) {
+    if (isShowing()) {
       return
     }
     val context = devSupportManager.currentActivity
@@ -56,9 +56,21 @@ internal class LogBoxDialogSurfaceDelegate(private val devSupportManager: DevSup
       )
       return
     }
+
+    if (!isContentViewReady()) {
+      createContentView("LogBox")
+    }
+    if (!isContentViewReady()) {
+      return
+    }
+
     dialog = LogBoxDialog(context, reactRootView)
     dialog?.let { dialog ->
-      dialog.setCancelable(false)
+      dialog.setCancelable(true)
+      dialog.setCanceledOnTouchOutside(false)
+      dialog.setOnCancelListener {
+        devSupportManager.currentReactContext?.emitDeviceEvent("hardwareBackPress")
+      }
       dialog.show()
     }
   }
@@ -69,6 +81,7 @@ internal class LogBoxDialogSurfaceDelegate(private val devSupportManager: DevSup
     }
     (reactRootView?.parent as ViewGroup?)?.removeView(reactRootView)
     dialog = null
+    destroyContentView()
   }
 
   override fun isShowing(): Boolean = dialog?.isShowing ?: false

package/ReactAndroid/src/main/java/com/facebook/react/devsupport/RedBoxDialogSurfaceDelegate.kt

@@ -125,6 +125,7 @@ internal class RedBoxDialogSurfaceDelegate(private val devSupportManager: DevSup
               .apply {
                 requestWindowFeature(Window.FEATURE_NO_TITLE)
                 setContentView(checkNotNull(redBoxContentView))
+                setOnCancelListener { devSupportManager.hideRedboxDialog() }
               }
     }
     dialog?.show()

package/ReactAndroid/src/main/java/com/facebook/react/devsupport/inspector/DevSupportHttpClient.kt

@@ -9,66 +9,41 @@
 
 package com.facebook.react.devsupport.inspector
 
-import java.util.concurrent.ConcurrentHashMap
+import com.facebook.react.modules.network.OkHttpClientProvider
 import java.util.concurrent.TimeUnit
-import okhttp3.Interceptor
 import okhttp3.OkHttpClient
 
 /**
  * Shared [OkHttpClient] instances for devsupport networking. Uses a single connection pool and
- * dispatcher across all dev support HTTP and WebSocket usage. Supports injecting custom request
- * headers that are applied to every outgoing request via an OkHttp interceptor.
+ * dispatcher across all dev support HTTP and WebSocket usage.
  */
-public object DevSupportHttpClient {
-  private val customHeaders = ConcurrentHashMap<String, String>()
-
-  private val headerInterceptor = Interceptor { chain ->
-    val builder = chain.request().newBuilder()
-    for ((name, value) in customHeaders) {
-      builder.header(name, value)
-    }
-    chain.proceed(builder.build())
-  }
-
+internal object DevSupportHttpClient {
   /** Client for HTTP requests: connect=5s, write=disabled, read=disabled. */
-  public val httpClient: OkHttpClient =
-      OkHttpClient.Builder()
-          .addInterceptor(headerInterceptor)
+  internal val httpClient: OkHttpClient =
+      OkHttpClientProvider.getOkHttpClient()
+          .newBuilder()
           .connectTimeout(5, TimeUnit.SECONDS)
           .writeTimeout(0, TimeUnit.MILLISECONDS)
           .readTimeout(0, TimeUnit.MINUTES)
           .build()
 
   /** Client for WebSocket connections: connect=10s, write=10s, read=disabled. */
-  public val websocketClient: OkHttpClient =
+  internal val websocketClient: OkHttpClient =
       httpClient
           .newBuilder()
           .connectTimeout(10, TimeUnit.SECONDS)
           .writeTimeout(10, TimeUnit.SECONDS)
           .build()
 
-  /** Add a custom header to be included in all requests made through both clients. */
-  @JvmStatic
-  public fun addRequestHeader(name: String, value: String) {
-    customHeaders[name] = value
-  }
-
-  /** Remove a previously added custom header. */
-  @JvmStatic
-  public fun removeRequestHeader(name: String) {
-    customHeaders.remove(name)
-  }
-
   /**
    * Returns the appropriate HTTP scheme ("http" or "https") for the given host. Uses "https" when
    * the host specifies port 443 explicitly (e.g. "example.com:443").
    */
-  @JvmStatic
-  public fun httpScheme(host: String): String = if (host.endsWith(":443")) "https" else "http"
+  internal fun httpScheme(host: String): String = if (host.endsWith(":443")) "https" else "http"
 
   /**
    * Returns the appropriate WebSocket scheme ("ws" or "wss") for the given host. Uses "wss" when
    * the host specifies port 443 explicitly (e.g. "example.com:443").
    */
-  @JvmStatic public fun wsScheme(host: String): String = if (host.endsWith(":443")) "wss" else "ws"
+  internal fun wsScheme(host: String): String = if (host.endsWith(":443")) "wss" else "ws"
 }

package/ReactAndroid/src/main/java/com/facebook/react/devsupport/inspector/FrameTimingSequence.kt

@@ -12,5 +12,5 @@ internal data class FrameTimingSequence(
     val threadId: Int,
     val beginTimestamp: Long,
     val endTimestamp: Long,
-    val screenshot: String? = null,
+    val screenshot: ByteArray? = null,
 )

package/ReactAndroid/src/main/java/com/facebook/react/devsupport/inspector/FrameTimingsObserver.kt

@@ -12,14 +12,18 @@ import android.os.Build
 import android.os.Handler
 import android.os.Looper
 import android.os.Process
-import android.util.Base64
 import android.view.FrameMetrics
 import android.view.PixelCopy
 import android.view.Window
 import com.facebook.proguard.annotations.DoNotStripAny
 import java.io.ByteArrayOutputStream
+import java.util.concurrent.Executors
+import java.util.concurrent.atomic.AtomicBoolean
+import java.util.concurrent.atomic.AtomicReference
+import kotlinx.coroutines.CoroutineDispatcher
 import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.asCoroutineDispatcher
 import kotlinx.coroutines.launch
 
 @DoNotStripAny
@@ -30,20 +34,39 @@ internal class FrameTimingsObserver(
   private val isSupported = Build.VERSION.SDK_INT >= Build.VERSION_CODES.N
   private val mainHandler = Handler(Looper.getMainLooper())
 
+  // Serial dispatcher for encoding work (single background thread). We limit to 1 thread to
+  // minimize the performance impact of screenshot recording.
+  private val encodingDispatcher: CoroutineDispatcher =
+      Executors.newSingleThreadExecutor().asCoroutineDispatcher()
+
+  // Stores the most recently captured frame to opportunistically encode after the current frame.
+  // Replaced frames are emitted as timings without screenshots.
+  private val lastFrameBuffer = AtomicReference<FrameData?>(null)
+
   private var frameCounter: Int = 0
+  private val encodingInProgress = AtomicBoolean(false)
   @Volatile private var isTracing: Boolean = false
   @Volatile private var currentWindow: Window? = null
 
+  private data class FrameData(
+      val bitmap: Bitmap,
+      val frameId: Int,
+      val threadId: Int,
+      val beginTimestamp: Long,
+      val endTimestamp: Long,
+  )
+
   fun start() {
     if (!isSupported) {
       return
     }
 
     frameCounter = 0
+    encodingInProgress.set(false)
+    lastFrameBuffer.set(null)
     isTracing = true
 
-    // Capture initial screenshot to ensure there's always at least one frame
-    // recorded at the start of tracing, even if no UI changes occur
+    // Emit initial frame event
     val timestamp = System.nanoTime()
     emitFrameTiming(timestamp, timestamp)
 
@@ -59,6 +82,7 @@ internal class FrameTimingsObserver(
 
     currentWindow?.removeOnFrameMetricsAvailableListener(frameMetricsListener)
     mainHandler.removeCallbacksAndMessages(null)
+    lastFrameBuffer.getAndSet(null)?.bitmap?.recycle()
   }
 
   fun setCurrentWindow(window: Window?) {
@@ -73,50 +97,121 @@ internal class FrameTimingsObserver(
     }
   }
 
-  private val frameMetricsListener =
-      Window.OnFrameMetricsAvailableListener { _, frameMetrics, _ ->
-        // Guard against calls arriving after stop() has ended tracing. Async work scheduled from
-        // previous frames will still finish.
-        if (!isTracing) {
-          return@OnFrameMetricsAvailableListener
-        }
-        val beginTimestamp = frameMetrics.getMetric(FrameMetrics.VSYNC_TIMESTAMP)
-        val endTimestamp = beginTimestamp + frameMetrics.getMetric(FrameMetrics.TOTAL_DURATION)
-        emitFrameTiming(beginTimestamp, endTimestamp)
-      }
+  private val frameMetricsListener = Window.OnFrameMetricsAvailableListener { _, frameMetrics, _ ->
+    // Guard against calls after stop()
+    if (!isTracing) {
+      return@OnFrameMetricsAvailableListener
+    }
+    val beginTimestamp = frameMetrics.getMetric(FrameMetrics.VSYNC_TIMESTAMP)
+    val endTimestamp = beginTimestamp + frameMetrics.getMetric(FrameMetrics.TOTAL_DURATION)
+    emitFrameTiming(beginTimestamp, endTimestamp)
+  }
 
   private fun emitFrameTiming(beginTimestamp: Long, endTimestamp: Long) {
     val frameId = frameCounter++
     val threadId = Process.myTid()
 
-    if (screenshotsEnabled) {
-      // Initiate PixelCopy immediately on the main thread, while still in the current frame,
-      // then process and emit asynchronously once the copy is complete.
-      captureScreenshot { screenshot ->
-        CoroutineScope(Dispatchers.Default).launch {
-          onFrameTimingSequence(
-              FrameTimingSequence(frameId, threadId, beginTimestamp, endTimestamp, screenshot)
-          )
+    if (!screenshotsEnabled) {
+      // Screenshots disabled - emit without screenshot
+      emitFrameEvent(frameId, threadId, beginTimestamp, endTimestamp, null)
+      return
+    }
+
+    captureScreenshot(frameId, threadId, beginTimestamp, endTimestamp) { frameData ->
+      if (frameData != null) {
+        if (encodingInProgress.compareAndSet(false, true)) {
+          // Not encoding - encode this frame immediately
+          encodeFrame(frameData)
+        } else {
+          // Encoding thread busy - store current screenshot in buffer for tail-capture
+          val oldFrameData = lastFrameBuffer.getAndSet(frameData)
+          if (oldFrameData != null) {
+            // Skipped frame - emit event without screenshot
+            emitFrameEvent(
+                oldFrameData.frameId,
+                oldFrameData.threadId,
+                oldFrameData.beginTimestamp,
+                oldFrameData.endTimestamp,
+                null,
+            )
+            oldFrameData.bitmap.recycle()
+          }
         }
+      } else {
+        // Failed to capture (e.g. timeout) - emit without screenshot
+        emitFrameEvent(frameId, threadId, beginTimestamp, endTimestamp, null)
       }
-    } else {
-      CoroutineScope(Dispatchers.Default).launch {
-        onFrameTimingSequence(
-            FrameTimingSequence(frameId, threadId, beginTimestamp, endTimestamp, null)
+    }
+  }
+
+  private fun emitFrameEvent(
+      frameId: Int,
+      threadId: Int,
+      beginTimestamp: Long,
+      endTimestamp: Long,
+      screenshot: ByteArray?,
+  ) {
+    CoroutineScope(Dispatchers.Default).launch {
+      onFrameTimingSequence(
+          FrameTimingSequence(frameId, threadId, beginTimestamp, endTimestamp, screenshot)
+      )
+    }
+  }
+
+  private fun encodeFrame(frameData: FrameData) {
+    CoroutineScope(encodingDispatcher).launch {
+      try {
+        val screenshot = encodeScreenshot(frameData.bitmap)
+        emitFrameEvent(
+            frameData.frameId,
+            frameData.threadId,
+            frameData.beginTimestamp,
+            frameData.endTimestamp,
+            screenshot,
         )
+      } finally {
+        frameData.bitmap.recycle()
+      }
+
+      // Clear encoding flag early, allowing new frames to start fresh encoding sessions
+      encodingInProgress.set(false)
+
+      // Opportunistically encode tail frame (if present) without blocking new frames
+      val tailFrame = lastFrameBuffer.getAndSet(null)
+      if (tailFrame != null) {
+        try {
+          val screenshot = encodeScreenshot(tailFrame.bitmap)
+          emitFrameEvent(
+              tailFrame.frameId,
+              tailFrame.threadId,
+              tailFrame.beginTimestamp,
+              tailFrame.endTimestamp,
+              screenshot,
+          )
+        } finally {
+          tailFrame.bitmap.recycle()
+        }
       }
     }
   }
 
   // Must be called from the main thread so that PixelCopy captures the current frame.
-  private fun captureScreenshot(callback: (String?) -> Unit) {
+  private fun captureScreenshot(
+      frameId: Int,
+      threadId: Int,
+      beginTimestamp: Long,
+      endTimestamp: Long,
+      callback: (FrameData?) -> Unit,
+  ) {
     if (Build.VERSION.SDK_INT < Build.VERSION_CODES.O) {
+      // PixelCopy not available
       callback(null)
       return
     }
 
     val window = currentWindow
     if (window == null) {
+      // No window
       callback(null)
       return
     }
@@ -131,9 +226,7 @@ internal class FrameTimingsObserver(
         bitmap,
         { copyResult ->
           if (copyResult == PixelCopy.SUCCESS) {
-            CoroutineScope(Dispatchers.Default).launch {
-              callback(encodeScreenshot(window, bitmap, width, height))
-            }
+            callback(FrameData(bitmap, frameId, threadId, beginTimestamp, endTimestamp))
           } else {
             bitmap.recycle()
             callback(null)
@@ -143,9 +236,12 @@ internal class FrameTimingsObserver(
     )
   }
 
-  private fun encodeScreenshot(window: Window, bitmap: Bitmap, width: Int, height: Int): String? {
+  private fun encodeScreenshot(bitmap: Bitmap): ByteArray? {
     var scaledBitmap: Bitmap? = null
     return try {
+      val window = currentWindow ?: return null
+      val width = bitmap.width
+      val height = bitmap.height
       val density = window.context.resources.displayMetrics.density
       val scaledWidth = (width / density * SCREENSHOT_SCALE_FACTOR).toInt()
       val scaledHeight = (height / density * SCREENSHOT_SCALE_FACTOR).toInt()
@@ -155,20 +251,24 @@ internal class FrameTimingsObserver(
           if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.R) Bitmap.CompressFormat.WEBP_LOSSY
           else Bitmap.CompressFormat.JPEG
 
-      ByteArrayOutputStream().use { outputStream ->
+      ByteArrayOutputStream(SCREENSHOT_OUTPUT_SIZE_HINT).use { outputStream ->
         scaledBitmap.compress(compressFormat, SCREENSHOT_QUALITY, outputStream)
-        Base64.encodeToString(outputStream.toByteArray(), Base64.NO_WRAP)
+        outputStream.toByteArray()
       }
     } catch (e: Exception) {
       null
     } finally {
       scaledBitmap?.recycle()
-      bitmap.recycle()
     }
   }
 
   companion object {
-    private const val SCREENSHOT_SCALE_FACTOR = 0.75f
+    private const val SCREENSHOT_SCALE_FACTOR = 1.0f
     private const val SCREENSHOT_QUALITY = 80
+
+    // Capacity hint for the ByteArrayOutputStream used during bitmap
+    // compression. Sized slightly above typical compressed output to minimise
+    // internal buffer resizing.
+    private const val SCREENSHOT_OUTPUT_SIZE_HINT = 65536 // 64 KB
   }
 }

package/ReactAndroid/src/main/java/com/facebook/react/devsupport/inspector/InspectorNetworkRequestListener.kt

@@ -11,11 +11,13 @@ import com.facebook.jni.HybridData
 import com.facebook.proguard.annotations.DoNotStrip
 import com.facebook.proguard.annotations.DoNotStripAny
 import com.facebook.soloader.SoLoader
+import com.facebook.soloader.annotation.SoLoaderLibrary
 
 /**
  * JNI wrapper for `jsinspectormodern::NetworkRequestListener`. Handles the `ScopedExecutor`
  * callback use on the C++ side.
  */
+@SoLoaderLibrary("reactnativejni")
 @DoNotStripAny
 internal class InspectorNetworkRequestListener(
     @field:DoNotStrip private val mHybridData: HybridData

package/ReactAndroid/src/main/java/com/facebook/react/devsupport/perfmonitor/PerfMonitorOverlayView.kt

@@ -142,8 +142,9 @@ internal class PerfMonitorOverlayView(
     val dialog =
         createAnchoredDialog(dpToPx(12f), dpToPx(12f)).apply { setContentView(containerLayout) }
     dialog.window?.apply {
-      attributes =
-          attributes?.apply { flags = flags or WindowManager.LayoutParams.FLAG_NOT_FOCUSABLE }
+      attributes = attributes?.apply {
+        flags = flags or WindowManager.LayoutParams.FLAG_NOT_FOCUSABLE
+      }
     }
 
     return dialog
@@ -158,14 +159,13 @@ internal class PerfMonitorOverlayView(
           setCancelable(false)
         }
     dialog.window?.apply {
-      attributes =
-          attributes?.apply {
-            width = WindowManager.LayoutParams.WRAP_CONTENT
-            height = WindowManager.LayoutParams.WRAP_CONTENT
-            gravity = Gravity.TOP or Gravity.END
-            x = offsetX.toInt()
-            y = offsetY.toInt()
-          }
+      attributes = attributes?.apply {
+        width = WindowManager.LayoutParams.WRAP_CONTENT
+        height = WindowManager.LayoutParams.WRAP_CONTENT
+        gravity = Gravity.TOP or Gravity.END
+        x = offsetX.toInt()
+        y = offsetY.toInt()
+      }
     }
     dialog.window?.decorView?.let { decorView ->
       ViewCompat.setOnApplyWindowInsetsListener(decorView) { view, windowInsets ->

package/ReactAndroid/src/main/java/com/facebook/react/fabric/AnimationBackendChoreographer.kt

@@ -46,24 +46,26 @@ internal class AnimationBackendChoreographer(
   }
 
   fun pause() {
+    val shouldRemove: Boolean
     synchronized(paused) {
-      if (!paused.getAndSet(true) && callbackPosted.getAndSet(false)) {
-        reactChoreographer.removeFrameCallback(
-            ReactChoreographer.CallbackType.NATIVE_ANIMATED_MODULE,
-            choreographerCallback,
-        )
-      }
+      shouldRemove = !paused.getAndSet(true) && callbackPosted.getAndSet(false)
+    }
+    if (shouldRemove) {
+      reactChoreographer.removeFrameCallback(
+          ReactChoreographer.CallbackType.NATIVE_ANIMATED_MODULE,
+          choreographerCallback,
+      )
     }
   }
 
   private fun scheduleCallback() {
-    synchronized(paused) {
-      if (!paused.get() && !callbackPosted.getAndSet(true)) {
-        reactChoreographer.postFrameCallback(
-            ReactChoreographer.CallbackType.NATIVE_ANIMATED_MODULE,
-            choreographerCallback,
-        )
-      }
+    val shouldPost: Boolean
+    synchronized(paused) { shouldPost = !paused.get() && !callbackPosted.getAndSet(true) }
+    if (shouldPost) {
+      reactChoreographer.postFrameCallback(
+          ReactChoreographer.CallbackType.NATIVE_ANIMATED_MODULE,
+          choreographerCallback,
+      )
     }
   }
 

package/ReactAndroid/src/main/java/com/facebook/react/fabric/DevToolsReactPerfLogger.kt

@@ -134,7 +134,10 @@ public class DevToolsReactPerfLogger : FabricMarkerListener {
       }
       commitPoint.addPoint(name, FabricCommitPointData(timestamp, counter))
 
-      if (name == ReactMarkerConstants.FABRIC_BATCH_EXECUTION_END && timestamp > 0) {
+      if (
+          (name == ReactMarkerConstants.FABRIC_BATCH_EXECUTION_END ||
+              name == ReactMarkerConstants.FABRIC_UPDATE_UI_MAIN_THREAD_END) && timestamp > 0
+      ) {
         onFabricCommitEnd(commitPoint)
         fabricCommitMarkers.remove(instanceKey)
       }