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

package/ReactAndroid/src/main/java/com/facebook/react/CoreModulesPackage.java

@@ -27,6 +27,7 @@ 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.core.TimingModule;
+import com.facebook.react.modules.debug.DevMenuModule;
 import com.facebook.react.modules.debug.DevSettingsModule;
 import com.facebook.react.modules.debug.SourceCodeModule;
 import com.facebook.react.modules.deviceinfo.DeviceInfoModule;
@@ -49,6 +50,7 @@ import java.util.Map;
       AndroidInfoModule.class,
       DeviceEventManagerModule.class,
       DeviceInfoModule.class,
+      DevMenuModule.class,
       DevSettingsModule.class,
       ExceptionsManagerModule.class,
       LogBoxModule.class,
@@ -57,7 +59,7 @@ import java.util.Map;
       TimingModule.class,
       UIManagerModule.class,
     })
-class CoreModulesPackage extends TurboReactPackage implements ReactPackageLogger {
+class CoreModulesPackage extends BaseReactPackage implements ReactPackageLogger {
 
   private final ReactInstanceManager mReactInstanceManager;
   private final DefaultHardwareBackBtnHandler mHardwareBackBtnHandler;
@@ -108,6 +110,7 @@ class CoreModulesPackage extends TurboReactPackage implements ReactPackageLogger
           AndroidInfoModule.class,
           DeviceEventManagerModule.class,
           DeviceInfoModule.class,
+          DevMenuModule.class,
           DevSettingsModule.class,
           ExceptionsManagerModule.class,
           LogBoxModule.class,
@@ -142,6 +145,8 @@ class CoreModulesPackage extends TurboReactPackage implements ReactPackageLogger
         return new AndroidInfoModule(reactContext);
       case DeviceEventManagerModule.NAME:
         return new DeviceEventManagerModule(reactContext, mHardwareBackBtnHandler);
+      case DevMenuModule.NAME:
+        return new DevMenuModule(reactContext, mReactInstanceManager.getDevSupportManager());
       case DevSettingsModule.NAME:
         return new DevSettingsModule(reactContext, mReactInstanceManager.getDevSupportManager());
       case ExceptionsManagerModule.NAME:

package/ReactAndroid/src/main/java/com/facebook/react/DebugCorePackage.java

@@ -37,7 +37,7 @@ import javax.inject.Provider;
       JSCHeapCapture.class,
     })
 /* package */
-public class DebugCorePackage extends TurboReactPackage implements ViewManagerOnDemandReactPackage {
+public class DebugCorePackage extends BaseReactPackage implements ViewManagerOnDemandReactPackage {
   private @Nullable Map<String, ModuleSpec> mViewManagers;
 
   public DebugCorePackage() {}

package/ReactAndroid/src/main/java/com/facebook/react/HeadlessJsTaskService.java

@@ -14,10 +14,12 @@ import android.content.Context;
 import android.content.Intent;
 import android.os.IBinder;
 import android.os.PowerManager;
+import androidx.annotation.NonNull;
 import androidx.annotation.Nullable;
 import com.facebook.infer.annotation.Assertions;
 import com.facebook.react.bridge.ReactContext;
 import com.facebook.react.bridge.UiThreadUtil;
+import com.facebook.react.config.ReactFeatureFlags;
 import com.facebook.react.jstasks.HeadlessJsTaskConfig;
 import com.facebook.react.jstasks.HeadlessJsTaskContext;
 import com.facebook.react.jstasks.HeadlessJsTaskEventListener;
@@ -94,19 +96,11 @@ public abstract class HeadlessJsTaskService extends Service implements HeadlessJ
   protected void startTask(final HeadlessJsTaskConfig taskConfig) {
     UiThreadUtil.assertOnUiThread();
     acquireWakeLockNow(this);
-    final ReactInstanceManager reactInstanceManager =
-        getReactNativeHost().getReactInstanceManager();
-    ReactContext reactContext = reactInstanceManager.getCurrentReactContext();
+
+    ReactContext reactContext = getReactContext();
+
     if (reactContext == null) {
-      reactInstanceManager.addReactInstanceEventListener(
-          new ReactInstanceEventListener() {
-            @Override
-            public void onReactContextInitialized(ReactContext reactContext) {
-              invokeStartTask(reactContext, taskConfig);
-              reactInstanceManager.removeReactInstanceEventListener(this);
-            }
-          });
-      reactInstanceManager.createReactContextInBackground();
+      createReactContextAndScheduleTask(taskConfig);
     } else {
       invokeStartTask(reactContext, taskConfig);
     }
@@ -166,4 +160,54 @@ public abstract class HeadlessJsTaskService extends Service implements HeadlessJ
   protected ReactNativeHost getReactNativeHost() {
     return ((ReactApplication) getApplication()).getReactNativeHost();
   }
+
+  /**
+   * Get the {@link ReactHost} used by this app. By default, assumes {@link #getApplication()} is an
+   * instance of {@link ReactApplication} and calls {@link ReactApplication#getReactHost()}. This
+   * method assumes it is called in new architecture and returns null if not.
+   */
+  protected @Nullable ReactHost getReactHost() {
+    return ((ReactApplication) getApplication()).getReactHost();
+  }
+
+  protected ReactContext getReactContext() {
+    if (ReactFeatureFlags.enableBridgelessArchitecture) {
+      ReactHost reactHost = getReactHost();
+      Assertions.assertNotNull(reactHost, "getReactHost() is null in New Architecture");
+      return reactHost.getCurrentReactContext();
+    } else {
+      final ReactInstanceManager reactInstanceManager =
+          getReactNativeHost().getReactInstanceManager();
+      return reactInstanceManager.getCurrentReactContext();
+    }
+  }
+
+  private void createReactContextAndScheduleTask(final HeadlessJsTaskConfig taskConfig) {
+    final ReactHost reactHost = getReactHost();
+
+    if (reactHost == null) { // old arch
+      final ReactInstanceManager reactInstanceManager =
+          getReactNativeHost().getReactInstanceManager();
+
+      reactInstanceManager.addReactInstanceEventListener(
+          new ReactInstanceEventListener() {
+            @Override
+            public void onReactContextInitialized(@NonNull ReactContext reactContext) {
+              invokeStartTask(reactContext, taskConfig);
+              reactInstanceManager.removeReactInstanceEventListener(this);
+            }
+          });
+      reactInstanceManager.createReactContextInBackground();
+    } else { // new arch
+      reactHost.addReactInstanceEventListener(
+          new ReactInstanceEventListener() {
+            @Override
+            public void onReactContextInitialized(@NonNull ReactContext reactContext) {
+              invokeStartTask(reactContext, taskConfig);
+              reactHost.removeReactInstanceEventListener(this);
+            }
+          });
+      reactHost.start();
+    }
+  }
 }

package/ReactAndroid/src/main/java/com/facebook/react/ReactActivity.java

@@ -113,6 +113,12 @@ public abstract class ReactActivity extends AppCompatActivity
     }
   }
 
+  @Override
+  public void onUserLeaveHint() {
+    super.onUserLeaveHint();
+    mDelegate.onUserLeaveHint();
+  }
+
   @Override
   public void requestPermissions(
       String[] permissions, int requestCode, PermissionListener listener) {

package/ReactAndroid/src/main/java/com/facebook/react/ReactActivityDelegate.java

@@ -70,7 +70,7 @@ public class ReactActivityDelegate {
    *
    * <p>Not used on bridgeless
    */
-  protected ReactRootView createRootView() {
+  protected @Nullable ReactRootView createRootView() {
     return null;
   }
 
@@ -138,6 +138,12 @@ public class ReactActivityDelegate {
     getPlainActivity().setContentView(mReactDelegate.getReactRootView());
   }
 
+  public void onUserLeaveHint() {
+    if (mReactDelegate != null) {
+      mReactDelegate.onUserLeaveHint();
+    }
+  }
+
   public void onPause() {
     mReactDelegate.onHostPause();
   }

package/ReactAndroid/src/main/java/com/facebook/react/ReactDelegate.java

@@ -122,6 +122,16 @@ public class ReactDelegate {
     }
   }
 
+  public void onUserLeaveHint() {
+    if (ReactFeatureFlags.enableBridgelessArchitecture) {
+      mReactHost.onHostLeaveHint(mActivity);
+    } else {
+      if (getReactNativeHost().hasInstance()) {
+        getReactNativeHost().getReactInstanceManager().onUserLeaveHint(mActivity);
+      }
+    }
+  }
+
   public void onHostPause() {
     if (ReactFeatureFlags.enableBridgelessArchitecture) {
       mReactHost.onHostPause(mActivity);
@@ -279,10 +289,7 @@ public class ReactDelegate {
     // With Bridgeless enabled, create and start the surface
     if (ReactFeatureFlags.enableBridgelessArchitecture) {
       if (mReactSurface == null) {
-        // Create a ReactSurface
         mReactSurface = mReactHost.createSurface(mActivity, appKey, mLaunchOptions);
-        // Set main Activity's content view
-        mActivity.setContentView(mReactSurface.getView());
       }
       mReactSurface.start();
     } else {

package/ReactAndroid/src/main/java/com/facebook/react/ReactFragment.java

@@ -17,6 +17,7 @@ import android.view.ViewGroup;
 import androidx.annotation.NonNull;
 import androidx.annotation.Nullable;
 import androidx.fragment.app.Fragment;
+import com.facebook.react.config.ReactFeatureFlags;
 import com.facebook.react.modules.core.PermissionAwareActivity;
 import com.facebook.react.modules.core.PermissionListener;
 
@@ -69,9 +70,15 @@ public class ReactFragment extends Fragment implements PermissionAwareActivity {
     if (mainComponentName == null) {
       throw new IllegalStateException("Cannot loadApp if component name is null");
     }
-    mReactDelegate =
-        new ReactDelegate(
-            getActivity(), getReactNativeHost(), mainComponentName, launchOptions, fabricEnabled);
+    if (ReactFeatureFlags.enableBridgelessArchitecture) {
+      mReactDelegate =
+          new ReactDelegate(
+              getActivity(), getReactHost(), mainComponentName, launchOptions);
+    } else {
+      mReactDelegate =
+          new ReactDelegate(
+              getActivity(), getReactNativeHost(), mainComponentName, launchOptions, fabricEnabled);
+    }
   }
 
   /**
@@ -81,8 +88,34 @@ public class ReactFragment extends Fragment implements PermissionAwareActivity {
    * implement {@code ReactApplication} or you simply have a different mechanism for storing a
    * {@code ReactNativeHost}, e.g. as a static field somewhere.
    */
+  @Nullable
   protected ReactNativeHost getReactNativeHost() {
-    return ((ReactApplication) getActivity().getApplication()).getReactNativeHost();
+    ReactApplication application = ((ReactApplication) getActivity().getApplication());
+    if (application != null) {
+      return application.getReactNativeHost();
+    } else {
+      return null;
+    }
+  }
+
+  /**
+   * Get the {@link ReactHost} used by this app. By default, assumes {@link
+   * Activity#getApplication()} is an instance of {@link ReactApplication} and calls {@link
+   * ReactApplication#getReactHost()}. Override this method if your application class does not
+   * implement {@code ReactApplication} or you simply have a different mechanism for storing a
+   * {@code ReactHost}, e.g. as a static field somewhere.
+   *
+   * <p>If you're using Old Architecture/Bridge Mode, this method should return null as {@link
+   * ReactHost} is a Bridgeless-only concept.
+   */
+  @Nullable
+  protected ReactHost getReactHost() {
+    ReactApplication application = ((ReactApplication) getActivity().getApplication());
+    if (application != null) {
+      return application.getReactHost();
+    } else {
+      return null;
+    }
   }
 
   protected ReactDelegate getReactDelegate() {

package/ReactAndroid/src/main/java/com/facebook/react/ReactHost.kt

@@ -45,9 +45,6 @@ public interface ReactHost {
   /** [ReactQueueConfiguration] for caller to post jobs in React Native threads */
   public val reactQueueConfiguration: ReactQueueConfiguration?
 
-  /** [JSEngineResolutionAlgorithm] used by this host. */
-  public var jsEngineResolutionAlgorithm: JSEngineResolutionAlgorithm?
-
   /** Routes memory pressure events to interested components */
   public val memoryPressureRouter: MemoryPressureRouter
 
@@ -64,6 +61,12 @@ public interface ReactHost {
   /** To be called when the host activity is resumed. */
   public fun onHostResume(activity: Activity?)
 
+  /**
+   * To be called when the host activity is about to go into the background as the result of user
+   * choice.
+   */
+  public fun onHostLeaveHint(activity: Activity?)
+
   /** To be called when the host activity is paused. */
   public fun onHostPause(activity: Activity?)
 
@@ -115,6 +118,20 @@ public interface ReactHost {
    */
   public fun destroy(reason: String, ex: Exception?): TaskInterface<Void>
 
+  /**
+   * Permanently destroys the ReactHost, including the ReactInstance (if any). The application MUST
+   * NOT call any further methods on an invalidated ReactHost.
+   *
+   * Applications where the ReactHost may be destroyed before the end of the process SHOULD call
+   * invalidate() before releasing the reference to the ReactHost, to ensure resources are freed in
+   * a timely manner.
+   *
+   * NOTE: This method is designed for complex integrations. Integrators MAY instead hold a
+   * long-lived reference to a single ReactHost for the lifetime of the Application, without ever
+   * calling invalidate(). This is explicitly allowed.
+   */
+  public fun invalidate()
+
   /* To be called when the host activity receives an activity result. */
   public fun onActivityResult(
       activity: Activity,
@@ -134,4 +151,10 @@ public interface ReactHost {
   public fun addBeforeDestroyListener(onBeforeDestroy: () -> Unit)
 
   public fun removeBeforeDestroyListener(onBeforeDestroy: () -> Unit)
+
+  /** Add a listener to be notified of ReactInstance events. */
+  public fun addReactInstanceEventListener(listener: ReactInstanceEventListener)
+
+  /** Remove a listener previously added with {@link #addReactInstanceEventListener}. */
+  public fun removeReactInstanceEventListener(listener: ReactInstanceEventListener)
 }

package/ReactAndroid/src/main/java/com/facebook/react/ReactInstanceManager.java

@@ -84,6 +84,8 @@ import com.facebook.react.config.ReactFeatureFlags;
 import com.facebook.react.devsupport.DevSupportManagerFactory;
 import com.facebook.react.devsupport.InspectorFlags;
 import com.facebook.react.devsupport.ReactInstanceDevHelper;
+import com.facebook.react.devsupport.inspector.InspectorNetworkHelper;
+import com.facebook.react.devsupport.inspector.InspectorNetworkRequestListener;
 import com.facebook.react.devsupport.interfaces.DevBundleDownloadListener;
 import com.facebook.react.devsupport.interfaces.DevLoadingViewManager;
 import com.facebook.react.devsupport.interfaces.DevSupportManager;
@@ -102,6 +104,7 @@ import com.facebook.react.modules.core.DefaultHardwareBackBtnHandler;
 import com.facebook.react.modules.core.DeviceEventManagerModule;
 import com.facebook.react.modules.core.ReactChoreographer;
 import com.facebook.react.modules.debug.interfaces.DeveloperSettings;
+import com.facebook.react.modules.systeminfo.AndroidInfoHelpers;
 import com.facebook.react.packagerconnection.RequestHandler;
 import com.facebook.react.uimanager.DisplayMetricsHolder;
 import com.facebook.react.uimanager.ReactRoot;
@@ -113,6 +116,7 @@ import com.facebook.react.views.imagehelper.ResourceDrawableIdHelper;
 import com.facebook.soloader.SoLoader;
 import com.facebook.systrace.Systrace;
 import com.facebook.systrace.SystraceMessage;
+import java.lang.ref.WeakReference;
 import java.lang.reflect.Method;
 import java.util.ArrayList;
 import java.util.Collection;
@@ -196,6 +200,7 @@ public class ReactInstanceManager {
   private final @Nullable ReactPackageTurboModuleManagerDelegate.Builder mTMMDelegateBuilder;
   private List<ViewManager> mViewManagers;
   private boolean mUseFallbackBundle = true;
+  private volatile boolean mInstanceManagerInvalidated = false;
 
   private class ReactContextInitParams {
     private final JavaScriptExecutorFactory mJsExecutorFactory;
@@ -462,7 +467,6 @@ public class ReactInstanceManager {
 
     if (mUseDeveloperSupport && mJSMainModulePath != null) {
       final DeveloperSettings devSettings = mDevSupportManager.getDevSettings();
-
       if (!Systrace.isTracing(TRACE_TAG_REACT_APPS | TRACE_TAG_REACT_JS_VM_CALLS)) {
         if (mBundleLoader == null) {
           mDevSupportManager.handleReloadJS();
@@ -473,6 +477,11 @@ public class ReactInstanceManager {
                 public void onPackagerStatusFetched(final boolean packagerIsRunning) {
                   UiThreadUtil.runOnUiThread(
                       () -> {
+                        // ReactInstanceManager is no longer valid, ignore callback
+                        if (mInstanceManagerInvalidated) {
+                          return;
+                        }
+
                         if (packagerIsRunning) {
                           mDevSupportManager.handleReloadJS();
                         } else if (mDevSupportManager.hasUpToDateJSBundleInCache()
@@ -595,6 +604,25 @@ public class ReactInstanceManager {
     moveToBeforeResumeLifecycleState();
   }
 
+  /**
+   * This method should be called from {@link Activity#onUserLeaveHint()}. It notifies all listening
+   * modules that the user is about to leave the activity. The passed Activity is has to be the
+   * current Activity.
+   *
+   * @param activity the activity being backgrounded as a result of user action
+   */
+  @ThreadConfined(UI)
+  public void onUserLeaveHint(@Nullable Activity activity) {
+    if (mCurrentActivity != null && activity == mCurrentActivity) {
+      UiThreadUtil.assertOnUiThread();
+
+      ReactContext currentContext = getCurrentReactContext();
+      if (currentContext != null) {
+        currentContext.onUserLeaveHint(activity);
+      }
+    }
+  }
+
   /**
    * Call this from {@link Activity#onPause()}. This notifies any listening modules so they can do
    * any necessary cleanup. The passed Activity is the current Activity being paused. This will
@@ -780,10 +808,13 @@ public class ReactInstanceManager {
       }
     }
 
-    // If the host is being destroyed, now that the current context/instance
+    // If the host has been invalidated, now that the current context/instance
     // has been destroyed, we can safely destroy the host's inspector target.
-    if (mLifecycleState == LifecycleState.BEFORE_CREATE) {
-      destroyInspectorHostTarget();
+    if (mInstanceManagerInvalidated) {
+      if (mInspectorTarget != null) {
+        mInspectorTarget.close();
+        mInspectorTarget = null;
+      }
     }
 
     mHasStartedCreatingInitialContext = false;
@@ -839,10 +870,6 @@ public class ReactInstanceManager {
       if (mLifecycleState == LifecycleState.BEFORE_RESUME) {
         currentContext.onHostDestroy(mKeepActivity);
       }
-    } else {
-      // There's no current context that requires the host inspector target to
-      // be kept alive, so we can destroy it immediately.
-      destroyInspectorHostTarget();
     }
     mLifecycleState = LifecycleState.BEFORE_CREATE;
   }
@@ -1083,6 +1110,25 @@ public class ReactInstanceManager {
     return mJavaScriptExecutorFactory.toString();
   }
 
+  /**
+   * Permanently destroys the ReactInstanceManager, including the CatalystInstance (if any). The
+   * application MUST NOT call any further methods on an invalidated ReactInstanceManager.
+   *
+   * <p>Applications where the ReactInstanceManager may be destroyed before the end of the process
+   * SHOULD call invalidate() before releasing the reference to the ReactInstanceManager, to ensure
+   * resources are freed in a timely manner.
+   *
+   * <p>NOTE: This method is designed for complex integrations. Integrators MAY instead hold a
+   * long-lived reference to a single ReactInstanceManager for the lifetime of the Application,
+   * without ever calling invalidate(). This is explicitly allowed.
+   */
+  @ThreadConfined(UI)
+  public void invalidate() {
+    FLog.d(ReactConstants.TAG, "ReactInstanceManager.invalidate()");
+    mInstanceManagerInvalidated = true;
+    destroy();
+  }
+
   @ThreadConfined(UI)
   private void onReloadWithJSDebugger(JavaJSExecutor.Factory jsExecutorFactory) {
     FLog.d(ReactConstants.TAG, "ReactInstanceManager.onReloadWithJSDebugger()");
@@ -1123,6 +1169,9 @@ public class ReactInstanceManager {
   private void runCreateReactContextOnNewThread(final ReactContextInitParams initParams) {
     FLog.d(ReactConstants.TAG, "ReactInstanceManager.runCreateReactContextOnNewThread()");
     UiThreadUtil.assertOnUiThread();
+    Assertions.assertCondition(
+        !mInstanceManagerInvalidated,
+        "Cannot create a new React context on an invalidated ReactInstanceManager");
 
     // Mark start of bridge loading
     ReactMarker.logMarker(ReactMarkerConstants.REACT_BRIDGE_LOADING_START);
@@ -1383,6 +1432,7 @@ public class ReactInstanceManager {
       JavaScriptExecutor jsExecutor, JSBundleLoader jsBundleLoader) {
     FLog.d(ReactConstants.TAG, "ReactInstanceManager.createReactContext()");
     ReactMarker.logMarker(CREATE_REACT_CONTEXT_START, jsExecutor.getName());
+
     final BridgeReactContext reactContext = new BridgeReactContext(mApplicationContext);
 
     JSExceptionHandler exceptionHandler =
@@ -1515,46 +1565,72 @@ public class ReactInstanceManager {
     SystraceMessage.endSection(TRACE_TAG_REACT_JAVA_BRIDGE).flush();
   }
 
-  private @Nullable ReactInstanceManagerInspectorTarget getOrCreateInspectorTarget() {
-    if (mInspectorTarget == null && InspectorFlags.getFuseboxEnabled()) {
+  private static class InspectorTargetDelegateImpl
+      implements ReactInstanceManagerInspectorTarget.TargetDelegate {
+    // This weak reference breaks the cycle between the C++ HostTarget and the
+    // Java ReactInstanceManager, preventing memory leaks in apps that create
+    // multiple ReactInstanceManagers over time.
+    private WeakReference<ReactInstanceManager> mReactInstanceManagerWeak;
 
-      mInspectorTarget =
-          new ReactInstanceManagerInspectorTarget(
-              new ReactInstanceManagerInspectorTarget.TargetDelegate() {
-                @Override
-                public void onReload() {
-                  UiThreadUtil.runOnUiThread(() -> mDevSupportManager.handleReloadJS());
-                }
+    public InspectorTargetDelegateImpl(ReactInstanceManager inspectorTarget) {
+      mReactInstanceManagerWeak = new WeakReference<ReactInstanceManager>(inspectorTarget);
+    }
 
-                @Override
-                public void onSetPausedInDebuggerMessage(@Nullable String message) {
-                  if (message == null) {
-                    mDevSupportManager.hidePausedInDebuggerOverlay();
-                  } else {
-                    mDevSupportManager.showPausedInDebuggerOverlay(
-                        message,
-                        new PausedInDebuggerOverlayCommandListener() {
-                          @Override
-                          public void onResume() {
-                            UiThreadUtil.assertOnUiThread();
-                            if (mInspectorTarget != null) {
-                              mInspectorTarget.sendDebuggerResumeCommand();
-                            }
-                          }
-                        });
-                  }
+    @Override
+    public Map<String, String> getMetadata() {
+      ReactInstanceManager reactInstanceManager = mReactInstanceManagerWeak.get();
+
+      return AndroidInfoHelpers.getInspectorHostMetadata(
+          reactInstanceManager != null ? reactInstanceManager.mApplicationContext : null);
+    }
+
+    @Override
+    public void onReload() {
+      UiThreadUtil.runOnUiThread(
+          () -> {
+            ReactInstanceManager reactInstanceManager = mReactInstanceManagerWeak.get();
+            if (reactInstanceManager != null) {
+              reactInstanceManager.mDevSupportManager.handleReloadJS();
+            }
+          });
+    }
+
+    @Override
+    public void onSetPausedInDebuggerMessage(@Nullable String message) {
+      ReactInstanceManager reactInstanceManager = mReactInstanceManagerWeak.get();
+      if (reactInstanceManager == null) {
+        return;
+      }
+      if (message == null) {
+        reactInstanceManager.mDevSupportManager.hidePausedInDebuggerOverlay();
+      } else {
+        reactInstanceManager.mDevSupportManager.showPausedInDebuggerOverlay(
+            message,
+            new PausedInDebuggerOverlayCommandListener() {
+              @Override
+              public void onResume() {
+                UiThreadUtil.assertOnUiThread();
+                if (reactInstanceManager.mInspectorTarget != null) {
+                  reactInstanceManager.mInspectorTarget.sendDebuggerResumeCommand();
                 }
-              });
+              }
+            });
+      }
     }
 
-    return mInspectorTarget;
+    @Override
+    public void loadNetworkResource(String url, InspectorNetworkRequestListener listener) {
+      InspectorNetworkHelper.loadNetworkResource(url, listener);
+    }
   }
 
-  @ThreadConfined(UI)
-  private void destroyInspectorHostTarget() {
-    if (mInspectorTarget != null) {
-      mInspectorTarget.close();
-      mInspectorTarget = null;
+  private @Nullable ReactInstanceManagerInspectorTarget getOrCreateInspectorTarget() {
+    if (mInspectorTarget == null && InspectorFlags.getFuseboxEnabled()) {
+
+      mInspectorTarget =
+          new ReactInstanceManagerInspectorTarget(new InspectorTargetDelegateImpl(this));
     }
+
+    return mInspectorTarget;
   }
 }

package/ReactAndroid/src/main/java/com/facebook/react/ReactNativeHost.java

@@ -43,8 +43,14 @@ public abstract class ReactNativeHost {
     mApplication = application;
   }
 
-  /** Get the current {@link ReactInstanceManager} instance, or create one. */
-  public ReactInstanceManager getReactInstanceManager() {
+  /**
+   * Get the current {@link ReactInstanceManager} instance, or create one.
+   *
+   * <p>NOTE: Care must be taken when storing this reference outside of the ReactNativeHost
+   * lifecycle. The ReactInstanceManager will be invalidated during {@link #clear()}, and may not be
+   * used again afterwards.
+   */
+  public synchronized ReactInstanceManager getReactInstanceManager() {
     if (mReactInstanceManager == null) {
       ReactMarker.logMarker(ReactMarkerConstants.INIT_REACT_RUNTIME_START);
       ReactMarker.logMarker(ReactMarkerConstants.GET_REACT_INSTANCE_MANAGER_START);
@@ -59,16 +65,17 @@ public abstract class ReactNativeHost {
    * {@link #getReactInstanceManager()} has been called at least once since this object was created
    * or {@link #clear()} was called.
    */
-  public boolean hasInstance() {
+  public synchronized boolean hasInstance() {
     return mReactInstanceManager != null;
   }
 
   /**
-   * Destroy the current instance and release the internal reference to it, allowing it to be GCed.
+   * Destroy the current instance and invalidate the internal ReactInstanceManager, reclaiming its
+   * resources and preventing it from being reused.
    */
-  public void clear() {
+  public synchronized void clear() {
     if (mReactInstanceManager != null) {
-      mReactInstanceManager.destroy();
+      mReactInstanceManager.invalidate();
       mReactInstanceManager = null;
     }
   }

package/ReactAndroid/src/main/java/com/facebook/react/ReactPackageTurboModuleManagerDelegate.java

@@ -15,6 +15,7 @@ import com.facebook.react.bridge.ModuleSpec;
 import com.facebook.react.bridge.NativeModule;
 import com.facebook.react.bridge.ReactApplicationContext;
 import com.facebook.react.config.ReactFeatureFlags;
+import com.facebook.react.internal.featureflags.ReactNativeFeatureFlags;
 import com.facebook.react.internal.turbomodule.core.TurboModuleManagerDelegate;
 import com.facebook.react.module.annotations.ReactModule;
 import com.facebook.react.module.model.ReactModuleInfo;
@@ -37,14 +38,7 @@ public abstract class ReactPackageTurboModuleManagerDelegate extends TurboModule
 
   private final boolean mShouldEnableLegacyModuleInterop =
       ReactFeatureFlags.enableBridgelessArchitecture
-          && ReactFeatureFlags.unstable_useTurboModuleInterop;
-
-  private final boolean mShouldRouteTurboModulesThroughLegacyModuleInterop =
-      mShouldEnableLegacyModuleInterop
-          && ReactFeatureFlags.unstable_useTurboModuleInteropForAllTurboModules;
-
-  private final boolean mEnableTurboModuleSyncVoidMethods =
-      ReactFeatureFlags.unstable_enableTurboModuleSyncVoidMethods;
+          && ReactNativeFeatureFlags.useTurboModuleInterop();
 
   // Lazy Props
   private List<ReactPackage> mPackages;
@@ -147,15 +141,6 @@ public abstract class ReactPackageTurboModuleManagerDelegate extends TurboModule
     return mShouldEnableLegacyModuleInterop;
   }
 
-  @Override
-  public boolean unstable_shouldRouteTurboModulesThroughLegacyModuleInterop() {
-    return mShouldRouteTurboModulesThroughLegacyModuleInterop;
-  }
-
-  public boolean unstable_enableSyncVoidMethods() {
-    return mEnableTurboModuleSyncVoidMethods;
-  }
-
   @Nullable
   @Override
   public TurboModule getModule(String moduleName) {