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

package/ReactAndroid/src/main/java/com/facebook/react/animated/NativeAnimatedModule.kt

@@ -23,14 +23,11 @@ import com.facebook.react.bridge.UIManagerListener
 import com.facebook.react.bridge.buildReadableMap
 import com.facebook.react.common.annotations.UnstableReactNativeAPI
 import com.facebook.react.common.annotations.VisibleForTesting
-import com.facebook.react.common.build.ReactBuildConfig
 import com.facebook.react.module.annotations.ReactModule
 import com.facebook.react.modules.core.ReactChoreographer
 import com.facebook.react.uimanager.GuardedFrameCallback
-import com.facebook.react.uimanager.UIBlock
 import com.facebook.react.uimanager.UIManagerHelper
 import com.facebook.react.uimanager.common.UIManagerType
-import com.facebook.react.uimanager.common.ViewUtil
 import java.util.ArrayList
 import java.util.Queue
 import java.util.concurrent.ConcurrentLinkedQueue
@@ -207,11 +204,6 @@ public class NativeAnimatedModule(reactContext: ReactApplicationContext) :
   @Volatile private var currentBatchNumber: Long = 0
 
   private var initializedForFabric = false
-  private var initializedForNonFabric = false
-
-  @UIManagerType private var uiManagerType = UIManagerType.LEGACY
-  private var numFabricAnimations = 0
-  private var numNonFabricAnimations = 0
 
   /**
    * This method is used to notify the JS side that the user has stopped scrolling. With natively
@@ -285,10 +277,6 @@ public class NativeAnimatedModule(reactContext: ReactApplicationContext) :
   // For FabricUIManager only
   @UiThread
   override fun didDispatchMountItems(uiManager: UIManager) {
-    if (uiManagerType != UIManagerType.FABRIC) {
-      return
-    }
-
     var batchNumber = currentBatchNumber - 1
 
     // TODO T71377544: delete this when the JS method is confirmed safe
@@ -313,33 +301,10 @@ public class NativeAnimatedModule(reactContext: ReactApplicationContext) :
     operations.executeBatch(batchNumber, nodesManager)
   }
 
-  // For non-FabricUIManager only
-  @Suppress("DEPRECATION")
+  // For non-FabricUIManager only (no-op since Fabric is the only supported UIManager)
   @UiThread
   override fun willDispatchViewUpdates(uiManager: UIManager) {
-    if (operations.isEmpty && preOperations.isEmpty) {
-      return
-    }
-    if (
-        uiManagerType == UIManagerType.FABRIC ||
-            ReactBuildConfig.UNSTABLE_ENABLE_MINIFY_LEGACY_ARCHITECTURE
-    ) {
-      return
-    }
-
-    // The following code ONLY executes for non-fabric
-    // When ReactBuildConfig.UNSTABLE_ENABLE_MINIFY_LEGACY_ARCHITECTURE is true, the folowing code
-    // might be stripped out.
-    val frameNo = currentBatchNumber++
-
-    val preOperationsUIBlock = UIBlock { preOperations.executeBatch(frameNo, nodesManager) }
-
-    val operationsUIBlock = UIBlock { operations.executeBatch(frameNo, nodesManager) }
-
-    assert(uiManager is com.facebook.react.uimanager.UIManagerModule)
-    val uiManagerModule = uiManager as com.facebook.react.uimanager.UIManagerModule
-    uiManagerModule.prependUIBlock(preOperationsUIBlock)
-    uiManagerModule.addUIBlock(operationsUIBlock)
+    // No-op: Fabric is the only supported UIManager
   }
 
   override fun onHostPause() {
@@ -411,23 +376,15 @@ public class NativeAnimatedModule(reactContext: ReactApplicationContext) :
   }
 
   /**
-   * Given a viewTag, detect if we're running in Fabric or non-Fabric and attach an event listener
-   * to the correct UIManager, if necessary. This is expected to only be called from the native
-   * module thread, and not concurrently.
+   * Given a viewTag, attach an event listener to the Fabric UIManager if necessary. This is
+   * expected to only be called from the native module thread, and not concurrently.
    *
    * @param viewTag
    */
   private fun initializeLifecycleEventListenersForViewTag(viewTag: Int) {
-    uiManagerType = ViewUtil.getUIManagerType(viewTag)
-    if (uiManagerType == UIManagerType.FABRIC) {
-      numFabricAnimations++
-    } else {
-      numNonFabricAnimations++
-    }
-
     val nodesManager = this.nodesManager
     if (nodesManager != null) {
-      nodesManager.initializeEventListenerForUIManagerType(uiManagerType)
+      nodesManager.initializeEventListenerForUIManagerType(UIManagerType.FABRIC)
     } else {
       ReactSoftExceptionLogger.logSoftException(
           NAME,
@@ -437,62 +394,21 @@ public class NativeAnimatedModule(reactContext: ReactApplicationContext) :
       )
     }
 
-    // Subscribe to UIManager (Fabric or non-Fabric) lifecycle events if we haven't yet
-    val initialized =
-        if (uiManagerType == UIManagerType.FABRIC) initializedForFabric else initializedForNonFabric
-    if (initialized) {
+    // Subscribe to Fabric UIManager lifecycle events if we haven't yet
+    if (initializedForFabric) {
       return
     }
 
     val reactApplicationContext = reactApplicationContextIfActiveOrWarn
     if (reactApplicationContext != null) {
-      val uiManager = UIManagerHelper.getUIManager(reactApplicationContext, uiManagerType)
+      val uiManager = UIManagerHelper.getUIManager(reactApplicationContext, UIManagerType.FABRIC)
       if (uiManager != null) {
         uiManager.addUIManagerEventListener(this)
-        if (uiManagerType == UIManagerType.FABRIC) {
-          initializedForFabric = true
-        } else {
-          initializedForNonFabric = true
-        }
+        initializedForFabric = true
       }
     }
   }
 
-  /**
-   * Given a viewTag and the knowledge that a "disconnect" or "stop"-type imperative command is
-   * being executed, decrement the number of inflight animations and possibly switch UIManager
-   * modes.
-   *
-   * @param viewTag
-   */
-  private fun decrementInFlightAnimationsForViewTag(viewTag: Int) {
-    @UIManagerType val animationManagerType = ViewUtil.getUIManagerType(viewTag)
-    if (animationManagerType == UIManagerType.FABRIC) {
-      numFabricAnimations--
-    } else {
-      numNonFabricAnimations--
-    }
-
-    // Should we switch to a different animation mode?
-    // This can be useful when navigating between Fabric and non-Fabric screens:
-    // If there are ongoing Fabric animations from a previous screen,
-    // and we tear down the current non-Fabric screen, we should expect
-    // the animation mode to switch back - and vice-versa.
-    if (
-        numNonFabricAnimations == 0 &&
-            numFabricAnimations > 0 &&
-            uiManagerType != UIManagerType.FABRIC
-    ) {
-      uiManagerType = UIManagerType.FABRIC
-    } else if (
-        numFabricAnimations == 0 &&
-            numNonFabricAnimations > 0 &&
-            uiManagerType != UIManagerType.LEGACY
-    ) {
-      uiManagerType = UIManagerType.LEGACY
-    }
-  }
-
   override fun startOperationBatch() {
     batchingControlledByJS = true
     currentBatchNumber++
@@ -804,8 +720,6 @@ public class NativeAnimatedModule(reactContext: ReactApplicationContext) :
       FLog.d(NAME, "queue disconnectAnimatedNodeFromView: $animatedNodeTag viewTag: $viewTag")
     }
 
-    decrementInFlightAnimationsForViewTag(viewTag)
-
     addOperation(
         object : UIThreadOperation() {
           override fun execute(animatedNodesManager: NativeAnimatedNodesManager) {
@@ -883,8 +797,6 @@ public class NativeAnimatedModule(reactContext: ReactApplicationContext) :
       )
     }
 
-    decrementInFlightAnimationsForViewTag(viewTag)
-
     addOperation(
         object : UIThreadOperation() {
           override fun execute(animatedNodesManager: NativeAnimatedNodesManager) {
@@ -1085,7 +997,6 @@ public class NativeAnimatedModule(reactContext: ReactApplicationContext) :
                 BatchExecutionOpCodes.OP_CODE_DISCONNECT_ANIMATED_NODE_FROM_VIEW -> {
                   val animatedNodeTag = opsAndArgs.getInt(i++)
                   viewTag = opsAndArgs.getInt(i++)
-                  decrementInFlightAnimationsForViewTag(viewTag)
                   animatedNodesManager.disconnectAnimatedNodeFromView(animatedNodeTag, viewTag)
                 }
 
@@ -1104,7 +1015,6 @@ public class NativeAnimatedModule(reactContext: ReactApplicationContext) :
 
                 BatchExecutionOpCodes.OP_CODE_REMOVE_ANIMATED_EVENT_FROM_VIEW -> {
                   viewTag = opsAndArgs.getInt(i++)
-                  decrementInFlightAnimationsForViewTag(viewTag)
                   animatedNodesManager.removeAnimatedEventFromView(
                       viewTag,
                       checkNotNull(opsAndArgs.getString(i++)),

package/ReactAndroid/src/main/java/com/facebook/react/animated/NativeAnimatedNodesManager.kt

@@ -61,25 +61,17 @@ public class NativeAnimatedNodesManager(
   private val runUpdateNodeList: MutableList<AnimatedNode> = LinkedList()
 
   private var eventListenerInitializedForFabric = false
-  private var eventListenerInitializedForNonFabric = false
 
   private var warnedAboutGraphTraversal = false
 
   /**
-   * Initialize event listeners for Fabric UIManager or non-Fabric UIManager, exactly once. Once
-   * Fabric is the only UIManager, this logic can be simplified. This is expected to only be called
-   * from the native module thread.
+   * Initialize event listeners for Fabric UIManager exactly once. This is expected to only be
+   * called from the native module thread.
    *
    * @param uiManagerType
    */
   public fun initializeEventListenerForUIManagerType(@UIManagerType uiManagerType: Int) {
-    val isEventListenerInitialized =
-        when (uiManagerType) {
-          UIManagerType.FABRIC -> eventListenerInitializedForFabric
-          else -> eventListenerInitializedForNonFabric
-        }
-
-    if (isEventListenerInitialized) {
+    if (eventListenerInitializedForFabric) {
       return
     }
 
@@ -87,11 +79,7 @@ public class NativeAnimatedNodesManager(
         UIManagerHelper.getUIManager(checkNotNull(reactApplicationContext), uiManagerType)
     if (uiManager != null) {
       uiManager.eventDispatcher.addListener(this)
-      if (uiManagerType == UIManagerType.FABRIC) {
-        eventListenerInitializedForFabric = true
-      } else {
-        eventListenerInitializedForNonFabric = true
-      }
+      eventListenerInitializedForFabric = true
     }
   }
 
@@ -763,7 +751,6 @@ public class NativeAnimatedNodesManager(
         FLog.e(TAG, node.prettyPrintWithChildren())
       }
 
-      // If we're running only in non-Fabric, we still throw an exception.
       // In Fabric, it seems that animations enter an inconsistent state fairly often.
       // We detect if the inconsistency is due to a cycle (a fatal error for which we must crash)
       // or disconnected regions, indicating a partially-set-up animation graph, which is not
@@ -773,17 +760,9 @@ public class NativeAnimatedNodesManager(
           IllegalStateException(
               ("Looks like animated nodes graph has ${reason}, there are $activeNodesCount but toposort visited only $updatedNodesCount")
           )
-      if (eventListenerInitializedForFabric && cyclesDetected == 0) {
-        // TODO T71377544: investigate these SoftExceptions and see if we can remove entirely
-        // or fix the root cause
-        ReactSoftExceptionLogger.logSoftException(TAG, ReactNoCrashSoftException(ex))
-      } else if (eventListenerInitializedForFabric) {
-        // TODO T71377544: investigate these SoftExceptions and see if we can remove entirely
-        // or fix the root cause
-        ReactSoftExceptionLogger.logSoftException(TAG, ReactNoCrashSoftException(ex))
-      } else {
-        throw ex
-      }
+      // TODO T71377544: investigate these SoftExceptions and see if we can remove entirely
+      // or fix the root cause
+      ReactSoftExceptionLogger.logSoftException(TAG, ReactNoCrashSoftException(ex))
     } else {
       warnedAboutGraphTraversal = false
     }

package/ReactAndroid/src/main/java/com/facebook/react/animated/PropsAnimatedNode.kt

@@ -12,8 +12,6 @@ import com.facebook.react.bridge.JSApplicationIllegalArgumentException
 import com.facebook.react.bridge.JavaOnlyMap
 import com.facebook.react.bridge.ReadableMap
 import com.facebook.react.bridge.UIManager
-import com.facebook.react.uimanager.common.UIManagerType
-import com.facebook.react.uimanager.common.ViewUtil.getUIManagerType
 
 /**
  * Animated node that represents view properties. There is a special handling logic implemented for
@@ -67,23 +65,8 @@ internal class PropsAnimatedNode(
   }
 
   fun restoreDefaultValues() {
-    // Cannot restore default values if this view has already been disconnected.
-    if (connectedViewTag == -1) {
-      return
-    }
-    // Don't restore default values in Fabric.
-    // In Non-Fabric this had the effect of "restore the value to whatever the value was on the
-    // ShadowNode instead of in the View hierarchy". However, "synchronouslyUpdateViewOnUIThread"
-    // will not have that impact on Fabric, because the FabricUIManager doesn't have access to the
-    // ShadowNode layer.
-    if (getUIManagerType(connectedViewTag) == UIManagerType.FABRIC) {
-      return
-    }
-    val it = propMap.keySetIterator()
-    while (it.hasNextKey()) {
-      propMap.putNull(it.nextKey())
-    }
-    connectedViewUIManager?.synchronouslyUpdateViewOnUIThread(connectedViewTag, propMap)
+    // In Fabric, we don't restore default values since the FabricUIManager doesn't have access
+    // to the ShadowNode layer. This method was only relevant for the legacy Paper renderer.
   }
 
   fun updateView() {

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

@@ -25,15 +25,9 @@ import java.lang.reflect.Method
 @DoNotStrip
 @InteropLegacyArchitecture
 internal class JavaModuleWrapper(
-    @Suppress("DEPRECATION") private val jsInstance: JSInstance,
+    @Suppress("DEPRECATION", "unused") private val jsInstance: JSInstance,
     private val moduleHolder: ModuleHolder,
 ) {
-  interface NativeMethod {
-    @Suppress("DEPRECATION") fun invoke(jsInstance: JSInstance, parameters: ReadableArray)
-
-    val type: String
-  }
-
   @DoNotStrip
   class MethodDescriptor {
     @DoNotStrip var method: Method? = null
@@ -45,7 +39,6 @@ internal class JavaModuleWrapper(
     @DoNotStrip var type: String? = null
   }
 
-  private val methods = ArrayList<NativeMethod>()
   private val descs = ArrayList<MethodDescriptor>()
 
   @get:DoNotStrip
@@ -63,26 +56,26 @@ internal class JavaModuleWrapper(
     var classForMethods: Class<*> = moduleHolder.module.javaClass
     val superClass = classForMethods.superclass
     if (superClass != null && TurboModule::class.java.isAssignableFrom(superClass)) {
-      // For java module that is based on generated flow-type spec, inspect the
-      // spec abstract class instead, which is the super class of the given Java
-      // module.
       classForMethods = superClass
     }
 
     val targetMethods = classForMethods.declaredMethods
     for (targetMethod in targetMethods) {
       targetMethod.getAnnotation(ReactMethod::class.java)?.let { annotation ->
-        val methodName = targetMethod.name
         val md = MethodDescriptor()
-        @Suppress("DEPRECATION")
-        val method = JavaMethodWrapper(this, targetMethod, annotation.isBlockingSynchronousMethod)
-        md.name = methodName
-        md.type = method.type
+        md.name = targetMethod.name
+        md.type =
+            when {
+              annotation.isBlockingSynchronousMethod -> BaseJavaModule.METHOD_TYPE_SYNC
+              targetMethod.parameterTypes.let { params ->
+                params.isNotEmpty() && params.last() == Promise::class.java
+              } -> BaseJavaModule.METHOD_TYPE_PROMISE
+              else -> BaseJavaModule.METHOD_TYPE_ASYNC
+            }
         if (BaseJavaModule.METHOD_TYPE_SYNC == md.type) {
-          md.signature = method.signature
+          md.signature = ""
           md.method = targetMethod
         }
-        methods.add(method)
         descs.add(md)
       }
     }
@@ -128,11 +121,10 @@ internal class JavaModuleWrapper(
 
   @DoNotStrip
   fun invoke(methodId: Int, parameters: ReadableNativeArray) {
-    if (methodId >= methods.size) {
-      return
-    }
-
-    methods[methodId].invoke(jsInstance, parameters)
+    throw UnsupportedOperationException(
+        "JavaModuleWrapper.invoke() is no longer supported. " +
+            "Use TurboModule interop instead (ReactNativeFeatureFlags.useTurboModuleInterop)."
+    )
   }
 
   private companion object {

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,8 +9,10 @@ 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 {

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"
 }