react-native-tvos 0.85.3-1 → 0.86.0-0

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

@@ -44,28 +44,27 @@ public class ReactChoreographer private constructor(choreographerProvider: Chore
   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")
-              }
-            }
+  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()
         }
       }
+      maybeRemoveFrameCallback()
+    }
+  }
 
   init {
     UiThreadUtil.runOnUiThread { choreographer = choreographerProvider.getChoreographer() }
@@ -138,6 +137,8 @@ public class ReactChoreographer private constructor(choreographerProvider: Chore
 
     @VisibleForTesting
     internal fun overrideInstanceForTest(instance: ReactChoreographer?): ReactChoreographer? =
-        choreographer.also { choreographer = instance }
+        choreographer.also {
+          choreographer = instance
+        }
   }
 }

package/ReactAndroid/src/main/java/com/facebook/react/modules/deviceinfo/DeviceInfoModule.kt

@@ -7,14 +7,21 @@
 
 package com.facebook.react.modules.deviceinfo
 
+import android.util.DisplayMetrics
+import androidx.annotation.VisibleForTesting
+import androidx.core.view.ViewCompat
+import androidx.core.view.WindowInsetsCompat
+import androidx.window.layout.WindowMetricsCalculator
 import com.facebook.fbreact.specs.NativeDeviceInfoSpec
 import com.facebook.react.bridge.LifecycleEventListener
 import com.facebook.react.bridge.ReactApplicationContext
 import com.facebook.react.bridge.ReactNoCrashSoftException
 import com.facebook.react.bridge.ReactSoftExceptionLogger
 import com.facebook.react.bridge.ReadableMap
+import com.facebook.react.bridge.WritableMap
+import com.facebook.react.bridge.WritableNativeMap
 import com.facebook.react.module.annotations.ReactModule
-import com.facebook.react.uimanager.DisplayMetricsHolder.getDisplayMetricsWritableMap
+import com.facebook.react.uimanager.DisplayMetricsHolder.getScreenDisplayMetrics
 import com.facebook.react.uimanager.DisplayMetricsHolder.initDisplayMetricsIfNotInitialized
 import com.facebook.react.views.view.isEdgeToEdgeFeatureFlagOn
 
@@ -30,8 +37,61 @@ internal class DeviceInfoModule(reactContext: ReactApplicationContext) :
     reactContext.addLifecycleEventListener(this)
   }
 
+  @VisibleForTesting
+  internal fun getWindowDisplayMetrics(): DisplayMetrics {
+    val windowDisplayMetrics = DisplayMetrics()
+    windowDisplayMetrics.setTo(reactApplicationContext.resources.displayMetrics)
+
+    val activity = reactApplicationContext.currentActivity ?: return windowDisplayMetrics
+    val bounds = WindowMetricsCalculator.getOrCreate().computeCurrentWindowMetrics(activity).bounds
+
+    if (isEdgeToEdgeFeatureFlagOn) {
+      windowDisplayMetrics.widthPixels = bounds.width()
+      windowDisplayMetrics.heightPixels = bounds.height()
+    } else {
+      // WindowMetrics bounds include system bars. When edge-to-edge is not enabled, we subtract
+      // them so that window dimensions reflect the usable content area. If insets aren't yet
+      // available (e.g. before the first layout pass), fall back to resources.displayMetrics,
+      // which already excludes system bars in non-edge-to-edge mode.
+      ViewCompat.getRootWindowInsets(activity.window.decorView)?.let {
+        val insets =
+            it.getInsets(
+                WindowInsetsCompat.Type.systemBars() or WindowInsetsCompat.Type.displayCutout()
+            )
+        windowDisplayMetrics.widthPixels = bounds.width() - (insets.left + insets.right)
+        windowDisplayMetrics.heightPixels = bounds.height() - (insets.top + insets.bottom)
+      }
+    }
+
+    return windowDisplayMetrics
+  }
+
+  @VisibleForTesting
+  internal fun getDisplayMetricsWritableMap(): WritableMap =
+      WritableNativeMap().apply {
+        putMap(
+            "windowPhysicalPixels",
+            getPhysicalPixelsWritableMap(getWindowDisplayMetrics()),
+        )
+        putMap(
+            "screenPhysicalPixels",
+            getPhysicalPixelsWritableMap(getScreenDisplayMetrics()),
+        )
+      }
+
+  private fun getPhysicalPixelsWritableMap(
+      displayMetrics: DisplayMetrics,
+  ): WritableMap =
+      WritableNativeMap().apply {
+        putInt("width", displayMetrics.widthPixels)
+        putInt("height", displayMetrics.heightPixels)
+        putDouble("scale", displayMetrics.density.toDouble())
+        putDouble("fontScale", fontScale.toDouble())
+        putDouble("densityDpi", displayMetrics.densityDpi.toDouble())
+      }
+
   public override fun getTypedExportedConstants(): Map<String, Any> {
-    val displayMetrics = getDisplayMetricsWritableMap(fontScale.toDouble())
+    val displayMetrics = getDisplayMetricsWritableMap()
 
     // Cache the initial dimensions for later comparison in emitUpdateDimensionsEvent
     previousDisplayMetrics = displayMetrics.copy()
@@ -58,7 +118,7 @@ internal class DeviceInfoModule(reactContext: ReactApplicationContext) :
     reactApplicationContext.let { context ->
       if (context.hasActiveReactInstance()) {
         // Don't emit an event to JS if the dimensions haven't changed
-        val displayMetrics = getDisplayMetricsWritableMap(fontScale.toDouble())
+        val displayMetrics = getDisplayMetricsWritableMap()
         if (previousDisplayMetrics == null) {
           previousDisplayMetrics = displayMetrics.copy()
         } else if (displayMetrics != previousDisplayMetrics) {

package/ReactAndroid/src/main/java/com/facebook/react/modules/image/ImageLoaderModule.kt

@@ -7,17 +7,20 @@
 
 package com.facebook.react.modules.image
 
+import android.media.ExifInterface
 import android.net.Uri
 import android.util.SparseArray
 import com.facebook.common.executors.CallerThreadExecutor
+import com.facebook.common.memory.PooledByteBuffer
 import com.facebook.common.references.CloseableReference
 import com.facebook.datasource.BaseDataSubscriber
 import com.facebook.datasource.DataSource
 import com.facebook.datasource.DataSubscriber
 import com.facebook.drawee.backends.pipeline.Fresco
 import com.facebook.fbreact.specs.NativeImageLoaderAndroidSpec
+import com.facebook.imagepipeline.common.RotationOptions
 import com.facebook.imagepipeline.core.ImagePipeline
-import com.facebook.imagepipeline.image.CloseableImage
+import com.facebook.imagepipeline.image.EncodedImage
 import com.facebook.imagepipeline.request.ImageRequest
 import com.facebook.imagepipeline.request.ImageRequestBuilder
 import com.facebook.react.bridge.GuardedAsyncTask
@@ -82,39 +85,13 @@ internal class ImageLoaderModule : NativeImageLoaderAndroidSpec, LifecycleEventL
       return
     }
     val source = ImageSource(reactApplicationContext, uriString)
-    val request: ImageRequest = ImageRequestBuilder.newBuilderWithSource(source.uri).build()
-    val dataSource: DataSource<CloseableReference<CloseableImage>> =
-        this.imagePipeline.fetchDecodedImage(request, this.callerContext)
-    val dataSubscriber: DataSubscriber<CloseableReference<CloseableImage>> =
-        object : BaseDataSubscriber<CloseableReference<CloseableImage>>() {
-          override fun onNewResultImpl(dataSource: DataSource<CloseableReference<CloseableImage>>) {
-            if (!dataSource.isFinished) {
-              return
-            }
-            val ref = dataSource.result
-            if (ref != null) {
-              try {
-                val image: CloseableImage = ref.get()
-                val sizes = buildReadableMap {
-                  put("width", image.width)
-                  put("height", image.height)
-                }
-                promise.resolve(sizes)
-              } catch (e: Exception) {
-                promise.reject(ERROR_GET_SIZE_FAILURE, e)
-              } finally {
-                CloseableReference.closeSafely(ref)
-              }
-            } else {
-              promise.reject(ERROR_GET_SIZE_FAILURE, "Failed to get the size of the image")
-            }
-          }
-
-          override fun onFailureImpl(dataSource: DataSource<CloseableReference<CloseableImage>>) {
-            promise.reject(ERROR_GET_SIZE_FAILURE, dataSource.failureCause)
-          }
-        }
-    dataSource.subscribe(dataSubscriber, CallerThreadExecutor.getInstance())
+    val request: ImageRequest =
+        ImageRequestBuilder.newBuilderWithSource(source.uri)
+            .setRotationOptions(RotationOptions.disableRotation())
+            .build()
+    val dataSource: DataSource<CloseableReference<PooledByteBuffer>> =
+        this.imagePipeline.fetchEncodedImage(request, this.callerContext)
+    dataSource.subscribe(createSizeSubscriber(promise), CallerThreadExecutor.getInstance())
   }
 
   /**
@@ -134,41 +111,61 @@ internal class ImageLoaderModule : NativeImageLoaderAndroidSpec, LifecycleEventL
     val source = ImageSource(reactApplicationContext, uriString)
     val imageRequestBuilder: ImageRequestBuilder =
         ImageRequestBuilder.newBuilderWithSource(source.uri)
+            .setRotationOptions(RotationOptions.disableRotation())
     val request: ImageRequest =
         ReactNetworkImageRequest.fromBuilderWithHeaders(imageRequestBuilder, headers)
-    val dataSource: DataSource<CloseableReference<CloseableImage>> =
-        this.imagePipeline.fetchDecodedImage(request, this.callerContext)
-    val dataSubscriber: DataSubscriber<CloseableReference<CloseableImage>> =
-        object : BaseDataSubscriber<CloseableReference<CloseableImage>>() {
-          override fun onNewResultImpl(dataSource: DataSource<CloseableReference<CloseableImage>>) {
-            if (!dataSource.isFinished) {
-              return
-            }
-            val ref = dataSource.result
-            if (ref != null) {
-              try {
-                val image: CloseableImage = ref.get()
-                val sizes = buildReadableMap {
-                  put("width", image.width)
-                  put("height", image.height)
-                }
-                promise.resolve(sizes)
-              } catch (e: Exception) {
-                promise.reject(ERROR_GET_SIZE_FAILURE, e)
-              } finally {
-                CloseableReference.closeSafely(ref)
+    val dataSource: DataSource<CloseableReference<PooledByteBuffer>> =
+        this.imagePipeline.fetchEncodedImage(request, this.callerContext)
+    dataSource.subscribe(createSizeSubscriber(promise), CallerThreadExecutor.getInstance())
+  }
+
+  private fun createSizeSubscriber(
+      promise: Promise
+  ): DataSubscriber<CloseableReference<PooledByteBuffer>> =
+      object : BaseDataSubscriber<CloseableReference<PooledByteBuffer>>() {
+        override fun onNewResultImpl(dataSource: DataSource<CloseableReference<PooledByteBuffer>>) {
+          if (!dataSource.isFinished) {
+            return
+          }
+          val ref = dataSource.result
+          if (ref != null) {
+            var encodedImage: EncodedImage? = null
+            try {
+              encodedImage = EncodedImage(ref)
+              // Swap width and height when the image's EXIF orientation swaps the X/Y axes
+              // (90°/270° rotations, or transpose/transverse), so the values reflect the
+              // visible dimensions, matching iOS behavior.
+              val rotated =
+                  encodedImage.rotationAngle == 90 ||
+                      encodedImage.rotationAngle == 270 ||
+                      encodedImage.exifOrientation == ExifInterface.ORIENTATION_TRANSPOSE ||
+                      encodedImage.exifOrientation == ExifInterface.ORIENTATION_TRANSVERSE
+              val width = if (rotated) encodedImage.height else encodedImage.width
+              val height = if (rotated) encodedImage.width else encodedImage.height
+              if (width < 0 || height < 0) {
+                promise.reject(ERROR_GET_SIZE_FAILURE, "Failed to get the size of the image")
+                return
+              }
+              val sizes = buildReadableMap {
+                put("width", width)
+                put("height", height)
               }
-            } else {
-              promise.reject(ERROR_GET_SIZE_FAILURE, "Failed to get the size of the image")
+              promise.resolve(sizes)
+            } catch (e: Exception) {
+              promise.reject(ERROR_GET_SIZE_FAILURE, e)
+            } finally {
+              encodedImage?.close()
+              CloseableReference.closeSafely(ref)
             }
+          } else {
+            promise.reject(ERROR_GET_SIZE_FAILURE, "Failed to get the size of the image")
           }
+        }
 
-          override fun onFailureImpl(dataSource: DataSource<CloseableReference<CloseableImage>>) {
-            promise.reject(ERROR_GET_SIZE_FAILURE, dataSource.failureCause)
-          }
+        override fun onFailureImpl(dataSource: DataSource<CloseableReference<PooledByteBuffer>>) {
+          promise.reject(ERROR_GET_SIZE_FAILURE, dataSource.failureCause)
         }
-    dataSource.subscribe(dataSubscriber, CallerThreadExecutor.getInstance())
-  }
+      }
 
   /**
    * Prefetches the given image to the Fresco image disk cache.

package/ReactAndroid/src/main/java/com/facebook/react/modules/network/NetworkingModule.kt

@@ -773,6 +773,14 @@ public class NetworkingModule(
                       e.message,
                       e,
                   )
+                } catch (e: OutOfMemoryError) {
+                  NetworkEventUtil.onRequestError(
+                      reactApplicationContext,
+                      requestId,
+                      devToolsRequestId,
+                      "Out of memory while processing network response",
+                      null,
+                  )
                 }
               }
             }

package/ReactAndroid/src/main/java/com/facebook/react/modules/statusbar/StatusBarModule.kt

@@ -9,10 +9,11 @@ package com.facebook.react.modules.statusbar
 
 import android.animation.ArgbEvaluator
 import android.animation.ValueAnimator
-import android.os.Build
-import android.view.View
-import android.view.WindowInsetsController
+import android.view.Window
 import android.view.WindowManager
+import androidx.core.view.ViewCompat
+import androidx.core.view.WindowCompat
+import androidx.core.view.WindowInsetsCompat
 import com.facebook.common.logging.FLog
 import com.facebook.fbreact.specs.NativeStatusBarManagerAndroidSpec
 import com.facebook.react.bridge.GuardedRunnable
@@ -20,17 +21,48 @@ import com.facebook.react.bridge.NativeModule
 import com.facebook.react.bridge.ReactApplicationContext
 import com.facebook.react.bridge.UiThreadUtil
 import com.facebook.react.common.ReactConstants
+import com.facebook.react.interfaces.ExtraWindowEventListener
 import com.facebook.react.module.annotations.ReactModule
 import com.facebook.react.uimanager.DisplayMetricsHolder.getStatusBarHeightPx
 import com.facebook.react.uimanager.PixelUtil
 import com.facebook.react.views.view.isEdgeToEdgeFeatureFlagOn
+import com.facebook.react.views.view.setStatusBarStyle
 import com.facebook.react.views.view.setStatusBarTranslucency
 import com.facebook.react.views.view.setStatusBarVisibility
+import java.util.Collections
+import java.util.WeakHashMap
 
 /** [NativeModule] that allows changing the appearance of the status bar. */
 @ReactModule(name = NativeStatusBarManagerAndroidSpec.NAME)
 internal class StatusBarModule(reactContext: ReactApplicationContext?) :
-    NativeStatusBarManagerAndroidSpec(reactContext) {
+    NativeStatusBarManagerAndroidSpec(reactContext), ExtraWindowEventListener {
+
+  init {
+    reactApplicationContext.addExtraWindowEventListener(this)
+  }
+
+  override fun invalidate() {
+    super.invalidate()
+    reactApplicationContext.removeExtraWindowEventListener(this)
+  }
+
+  override fun onExtraWindowCreate(window: Window) {
+    extraWindows.add(window)
+
+    reactApplicationContext.currentActivity?.window?.let { activityWindow ->
+      val controller = WindowCompat.getInsetsController(activityWindow, activityWindow.decorView)
+      val insets = ViewCompat.getRootWindowInsets(activityWindow.decorView)
+      val style = if (controller.isAppearanceLightStatusBars) "dark-content" else "light-content"
+      val visible = insets?.isVisible(WindowInsetsCompat.Type.statusBars()) ?: true
+
+      window.setStatusBarStyle(style)
+      window.setStatusBarVisibility(!visible)
+    }
+  }
+
+  override fun onExtraWindowDestroy(window: Window) {
+    extraWindows.remove(window)
+  }
 
   @Suppress("DEPRECATION")
   override fun getTypedExportedConstants(): Map<String, Any> {
@@ -118,10 +150,12 @@ internal class StatusBarModule(reactContext: ReactApplicationContext?) :
       )
       return
     }
-    UiThreadUtil.runOnUiThread { activity.window?.setStatusBarVisibility(hidden) }
+    UiThreadUtil.runOnUiThread {
+      activity.window?.setStatusBarVisibility(hidden)
+      extraWindows.forEach { it.setStatusBarVisibility(hidden) }
+    }
   }
 
-  @Suppress("DEPRECATION")
   override fun setStyle(style: String?) {
     val activity = reactApplicationContext.getCurrentActivity()
     if (activity == null) {
@@ -131,41 +165,16 @@ internal class StatusBarModule(reactContext: ReactApplicationContext?) :
       )
       return
     }
-    UiThreadUtil.runOnUiThread(
-        Runnable {
-          val window = activity.window ?: return@Runnable
-          if (Build.VERSION.SDK_INT > Build.VERSION_CODES.R) {
-            val insetsController = window.insetsController ?: return@Runnable
-            if ("dark-content" == style) {
-              // dark-content means dark icons on a light status bar
-              insetsController.setSystemBarsAppearance(
-                  WindowInsetsController.APPEARANCE_LIGHT_STATUS_BARS,
-                  WindowInsetsController.APPEARANCE_LIGHT_STATUS_BARS,
-              )
-            } else {
-              insetsController.setSystemBarsAppearance(
-                  0,
-                  WindowInsetsController.APPEARANCE_LIGHT_STATUS_BARS,
-              )
-            }
-          } else {
-            val decorView = window.decorView
-            var systemUiVisibilityFlags = decorView.systemUiVisibility
-            systemUiVisibilityFlags =
-                if ("dark-content" == style) {
-                  systemUiVisibilityFlags or View.SYSTEM_UI_FLAG_LIGHT_STATUS_BAR
-                } else {
-                  systemUiVisibilityFlags and View.SYSTEM_UI_FLAG_LIGHT_STATUS_BAR.inv()
-                }
-            decorView.systemUiVisibility = systemUiVisibilityFlags
-          }
-        }
-    )
+    UiThreadUtil.runOnUiThread {
+      activity.window?.setStatusBarStyle(style)
+      extraWindows.forEach { it.setStatusBarStyle(style) }
+    }
   }
 
   companion object {
     private const val HEIGHT_KEY = "HEIGHT"
     private const val DEFAULT_BACKGROUND_COLOR_KEY = "DEFAULT_BACKGROUND_COLOR"
     const val NAME: String = NativeStatusBarManagerAndroidSpec.NAME
+    private val extraWindows = Collections.newSetFromMap<Window>(WeakHashMap())
   }
 }

package/ReactAndroid/src/main/java/com/facebook/react/modules/systeminfo/ReactNativeVersion.kt

@@ -13,8 +13,8 @@ public object ReactNativeVersion {
   @JvmField
   public val VERSION: Map<String, Any?> = mapOf(
     "major" to 0,
-    "minor" to 85,
-    "patch" to 3,
-    "prerelease" to "1"
+    "minor" to 86,
+    "patch" to 0,
+    "prerelease" to "0"
   )
 }

package/ReactAndroid/src/main/java/com/facebook/react/modules/websocket/WebSocketModule.kt

@@ -29,6 +29,7 @@ import java.net.URISyntaxException
 import java.util.HashMap
 import java.util.concurrent.ConcurrentHashMap
 import java.util.concurrent.TimeUnit
+import okhttp3.CookieJar
 import okhttp3.OkHttpClient
 import okhttp3.Request
 import okhttp3.Response
@@ -83,6 +84,8 @@ public class WebSocketModule(context: ReactApplicationContext) :
     val okHttpBuilder =
         OkHttpClientProvider.getOkHttpClient()
             .newBuilder()
+            // Don't let BridgeInterceptor overwrite a caller-supplied Cookie header.
+            .cookieJar(CookieJar.NO_COOKIES)
             .connectTimeout(10, TimeUnit.SECONDS)
             .writeTimeout(10, TimeUnit.SECONDS)
             .readTimeout(0, TimeUnit.MINUTES) // Disable timeouts for read
@@ -395,9 +398,9 @@ public class WebSocketModule(context: ReactApplicationContext) :
 
         val defaultOrigin =
             if (requestURI.port != -1) {
-              String.format("%s://%s:%s", scheme, requestURI.host, requestURI.port)
+              "$scheme://${requestURI.host}:${requestURI.port}"
             } else {
-              String.format("%s://%s", scheme, requestURI.host)
+              "$scheme://${requestURI.host}"
             }
 
         return defaultOrigin

package/ReactAndroid/src/main/java/com/facebook/react/runtime/CoreReactPackage.kt

@@ -20,6 +20,7 @@ import com.facebook.react.module.model.ReactModuleInfoProvider
 import com.facebook.react.modules.core.DefaultHardwareBackBtnHandler
 import com.facebook.react.modules.core.DeviceEventManagerModule
 import com.facebook.react.modules.core.ExceptionsManagerModule
+import com.facebook.react.modules.core.HeadlessJsTaskSupportModule
 import com.facebook.react.modules.debug.DevMenuModule
 import com.facebook.react.modules.debug.DevSettingsModule
 import com.facebook.react.modules.debug.SourceCodeModule
@@ -38,6 +39,7 @@ import java.util.HashMap
             LogBoxModule::class,
             DeviceEventManagerModule::class,
             ExceptionsManagerModule::class,
+            HeadlessJsTaskSupportModule::class,
         ]
 )
 internal class CoreReactPackage(
@@ -57,6 +59,7 @@ internal class CoreReactPackage(
 
         LogBoxModule.NAME -> LogBoxModule(reactContext, devSupportManager)
         ExceptionsManagerModule.NAME -> ExceptionsManagerModule(devSupportManager)
+        HeadlessJsTaskSupportModule.NAME -> HeadlessJsTaskSupportModule(reactContext)
         else -> null
       }
 
@@ -96,6 +99,7 @@ internal class CoreReactPackage(
             DeviceEventManagerModule::class.java,
             LogBoxModule::class.java,
             ExceptionsManagerModule::class.java,
+            HeadlessJsTaskSupportModule::class.java,
         )
     val reactModuleInfoMap: MutableMap<String, ReactModuleInfo> = HashMap()
     for (moduleClass in moduleList) {

package/ReactAndroid/src/main/java/com/facebook/react/runtime/ReactHostImpl.kt

@@ -12,6 +12,7 @@ import android.content.Context
 import android.content.Intent
 import android.nfc.NfcAdapter
 import android.os.Bundle
+import androidx.appcompat.app.AppCompatDelegate
 import androidx.core.graphics.createBitmap
 import com.facebook.common.logging.FLog
 import com.facebook.infer.annotation.Assertions
@@ -448,6 +449,19 @@ public class ReactHostImpl(
     InspectorNetworkHelper.loadNetworkResource(url, listener)
   }
 
+  @DoNotStrip
+  private fun setEmulatedMedia(colorScheme: String) {
+    UiThreadUtil.runOnUiThread {
+      val mode =
+          when (colorScheme) {
+            "dark" -> AppCompatDelegate.MODE_NIGHT_YES
+            "light" -> AppCompatDelegate.MODE_NIGHT_NO
+            else -> AppCompatDelegate.MODE_NIGHT_FOLLOW_SYSTEM
+          }
+      AppCompatDelegate.setDefaultNightMode(mode)
+    }
+  }
+
   @DoNotStrip
   private fun captureScreenshot(format: String, quality: Int): String? {
     val activity = currentActivity ?: return null
@@ -1027,11 +1041,10 @@ public class ReactHostImpl(
           jsBundleLoader.onSuccess(
               { task ->
                 val bundleLoader = checkNotNull(task.getResult())
-                val reactContext =
-                    bridgelessReactContextRef.getOrCreate {
-                      stateTracker.enterState(method, "Creating BridgelessReactContext")
-                      BridgelessReactContext(context, this)
-                    }
+                val reactContext = bridgelessReactContextRef.getOrCreate {
+                  stateTracker.enterState(method, "Creating BridgelessReactContext")
+                  BridgelessReactContext(context, this)
+                }
                 reactContext.jsExceptionHandler = devSupportManager
 
                 stateTracker.enterState(method, "Creating ReactInstance")

package/ReactAndroid/src/main/java/com/facebook/react/runtime/ReactHostImplDevHelper.kt

@@ -70,7 +70,14 @@ internal class ReactHostImplDevHelper(private val delegate: ReactHostImpl) :
   }
 
   override fun destroyRootView(rootView: View) {
-    // Not implemented, only referenced by BridgeDevSupportManager
+    val surface = (rootView as? ReactSurfaceView)?.surface ?: return
+    // stop() synchronously removes the surface from ReactHostImpl.attachedSurfaces via
+    // detachSurface(), then asynchronously tears down the React component tree.
+    // detach() severs the surface's back-reference to the host.
+    // clear() removes child views from the ReactSurfaceView.
+    surface.stop()
+    surface.detach()
+    surface.clear()
   }
 
   override fun reload(reason: String) {

package/ReactAndroid/src/main/java/com/facebook/react/runtime/ReactSurfaceView.kt

@@ -15,6 +15,8 @@ import android.graphics.Rect
 import android.view.KeyEvent
 import android.view.MotionEvent
 import android.view.View
+import androidx.core.view.ViewCompat
+import androidx.core.view.WindowInsetsCompat
 import com.facebook.common.logging.FLog
 import com.facebook.react.ReactRootView
 import com.facebook.react.bridge.ReactContext
@@ -26,7 +28,7 @@ import com.facebook.react.uimanager.IllegalViewOperationException
 import com.facebook.react.uimanager.JSKeyDispatcher
 import com.facebook.react.uimanager.JSPointerDispatcher
 import com.facebook.react.uimanager.JSTouchDispatcher
-import com.facebook.react.uimanager.common.UIManagerType
+import com.facebook.react.views.view.isEdgeToEdgeFeatureFlagOn
 import com.facebook.systrace.Systrace
 import java.util.Objects
 import kotlin.math.max
@@ -36,7 +38,7 @@ import kotlin.math.max
  * rendering a React component.
  */
 @OptIn(FrameworkAPI::class, UnstableReactNativeAPI::class)
-public class ReactSurfaceView(context: Context?, private val surface: ReactSurfaceImpl) :
+public class ReactSurfaceView(context: Context?, internal val surface: ReactSurfaceImpl) :
     ReactRootView(context) {
   private val jsTouchDispatcher: JSTouchDispatcher = JSTouchDispatcher(this)
   private var jsPointerDispatcher: JSPointerDispatcher? = null
@@ -47,16 +49,24 @@ public class ReactSurfaceView(context: Context?, private val surface: ReactSurfa
 
   private val viewportOffset: Point
     get() {
-      val locationOnScreen = IntArray(2)
-      getLocationOnScreen(locationOnScreen)
+      val locationInWindow = IntArray(2)
+      getLocationInWindow(locationInWindow)
 
-      // we need to subtract visibleWindowCoords - to subtract possible window insets, split
-      // screen or multi window
-      val visibleWindowFrame = Rect()
-      getWindowVisibleDisplayFrame(visibleWindowFrame)
-      locationOnScreen[0] -= visibleWindowFrame.left
-      locationOnScreen[1] -= visibleWindowFrame.top
-      return Point(locationOnScreen[0], locationOnScreen[1])
+      if (!isEdgeToEdgeFeatureFlagOn) {
+        // When not in edge-to-edge mode, subtract the top system bar insets so the offset is
+        // relative to the content area (below the status bar / cutout).
+        ViewCompat.getRootWindowInsets(this)?.apply {
+          val insets =
+              getInsets(
+                  WindowInsetsCompat.Type.statusBars() or WindowInsetsCompat.Type.displayCutout()
+              )
+
+          locationInWindow[0] -= insets.left
+          locationInWindow[1] -= insets.top
+        }
+      }
+
+      return Point(locationInWindow[0], locationInWindow[1])
     }
 
   init {
@@ -150,14 +160,6 @@ public class ReactSurfaceView(context: Context?, private val surface: ReactSurfa
     (surface.reactHost ?: throw e).handleHostException(e)
   }
 
-  override fun setIsFabric(isFabric: Boolean) {
-    // This surface view is always on Fabric regardless.
-    super.setIsFabric(true)
-  }
-
-  // This surface view is always on Fabric.
-  @UIManagerType override fun getUIManagerType(): Int = UIManagerType.FABRIC
-
   override fun getJSModuleName(): String = surface.moduleName
 
   override fun dispatchJSTouchEvent(event: MotionEvent) {