react-native-tvos 0.76.5-0 → 0.77.0-0

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

@@ -5,6 +5,10 @@
  * LICENSE file in the root directory of this source tree.
  */
 
+// TODO T207169925: Migrate CatalystInstance to Reacthost and remove the Suppress("DEPRECATION")
+// annotation
+@file:Suppress("DEPRECATION")
+
 package com.facebook.react.runtime
 
 import android.content.res.AssetManager
@@ -21,14 +25,15 @@ import com.facebook.react.bridge.RuntimeExecutor
 import com.facebook.react.bridge.RuntimeScheduler
 import com.facebook.react.bridge.UIManager
 import com.facebook.react.bridge.queue.ReactQueueConfiguration
-import com.facebook.react.common.annotations.DeprecatedInNewArchitecture
 import com.facebook.react.common.annotations.VisibleForTesting
 import com.facebook.react.internal.turbomodule.core.interfaces.TurboModuleRegistry
 import com.facebook.react.turbomodule.core.interfaces.CallInvokerHolder
 import com.facebook.react.turbomodule.core.interfaces.NativeMethodCallInvokerHolder
 
 @DoNotStrip
-@DeprecatedInNewArchitecture
+@Deprecated(
+    message =
+        "This class is deprecated, please to migrate to new architecture using [com.facebook.react.defaults.DefaultReactHost] instead.")
 public class BridgelessCatalystInstance(private val reactHost: ReactHostImpl) : CatalystInstance {
 
   override fun handleMemoryPressure(level: Int) {
@@ -87,10 +92,12 @@ public class BridgelessCatalystInstance(private val reactHost: ReactHostImpl) :
   override fun <T : JavaScriptModule> getJSModule(jsInterface: Class<T>): T? =
       reactHost.currentReactContext?.getJSModule(jsInterface)
 
+  @get:Deprecated("Deprecated in Java")
   override public val javaScriptContextHolder: JavaScriptContextHolder
     get() = reactHost.getJavaScriptContextHolder()!!
 
   @Suppress("INAPPLICABLE_JVM_NAME")
+  @get:Deprecated("Deprecated in Java")
   @get:JvmName("getJSCallInvokerHolder") // This is needed to keep backward compatibility
   override public val jsCallInvokerHolder: CallInvokerHolder
     get() = reactHost.getJSCallInvokerHolder()!!
@@ -145,23 +152,23 @@ public class BridgelessCatalystInstance(private val reactHost: ReactHostImpl) :
     throw UnsupportedOperationException("Unimplemented method 'setGlobalVariable'")
   }
 
-  @DeprecatedInNewArchitecture(
+  @Deprecated(
       message =
-          "This method will be deprecated later as part of Stable APIs with bridge removal and not encouraged usage.")
+          "This class is deprecated, please to migrate to new architecture using [com.facebook.react.defaults.DefaultReactHost] instead.")
   override fun setTurboModuleRegistry(turboModuleRegistry: TurboModuleRegistry) {
     throw UnsupportedOperationException("Unimplemented method 'setTurboModuleRegistry'")
   }
 
-  @DeprecatedInNewArchitecture(
+  @Deprecated(
       message =
-          "This method will be deprecated later as part of Stable APIs with bridge removal and not encouraged usage.")
+          "This class is deprecated, please to migrate to new architecture using [com.facebook.react.defaults.DefaultReactHost] instead.")
   override fun setFabricUIManager(fabricUIManager: UIManager) {
     throw UnsupportedOperationException("Unimplemented method 'setFabricUIManager'")
   }
 
-  @DeprecatedInNewArchitecture(
+  @Deprecated(
       message =
-          "This method will be deprecated later as part of Stable APIs with bridge removal and not encouraged usage.")
+          "This class is deprecated, please to migrate to new architecture using [com.facebook.react.defaults.DefaultReactHost] instead.")
   override fun getFabricUIManager(): UIManager {
     throw UnsupportedOperationException("Unimplemented method 'getFabricUIManager'")
   }

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

@@ -26,7 +26,6 @@ import com.facebook.infer.annotation.Nullsafe;
 import com.facebook.infer.annotation.ThreadConfined;
 import com.facebook.infer.annotation.ThreadSafe;
 import com.facebook.proguard.annotations.DoNotStrip;
-import com.facebook.react.JSEngineResolutionAlgorithm;
 import com.facebook.react.MemoryPressureRouter;
 import com.facebook.react.ReactHost;
 import com.facebook.react.ReactInstanceEventListener;
@@ -47,9 +46,10 @@ import com.facebook.react.bridge.UiThreadUtil;
 import com.facebook.react.bridge.queue.ReactQueueConfiguration;
 import com.facebook.react.common.LifecycleState;
 import com.facebook.react.common.build.ReactBuildConfig;
+import com.facebook.react.devsupport.DefaultDevSupportManagerFactory;
 import com.facebook.react.devsupport.DevSupportManagerBase;
+import com.facebook.react.devsupport.DevSupportManagerFactory;
 import com.facebook.react.devsupport.InspectorFlags;
-import com.facebook.react.devsupport.ReleaseDevSupportManager;
 import com.facebook.react.devsupport.inspector.InspectorNetworkHelper;
 import com.facebook.react.devsupport.inspector.InspectorNetworkRequestListener;
 import com.facebook.react.devsupport.interfaces.BundleLoadCallback;
@@ -79,12 +79,14 @@ import java.util.HashSet;
 import java.util.List;
 import java.util.Map;
 import java.util.Set;
+import java.util.concurrent.CopyOnWriteArrayList;
 import java.util.concurrent.Executor;
 import java.util.concurrent.Executors;
 import java.util.concurrent.atomic.AtomicInteger;
 import java.util.concurrent.atomic.AtomicReference;
 import kotlin.Unit;
 import kotlin.jvm.functions.Function0;
+import kotlin.jvm.functions.Function1;
 
 /**
  * A ReactHost is an object that manages a single {@link ReactInstance}. A ReactHost can be
@@ -106,7 +108,7 @@ public class ReactHostImpl implements ReactHost {
   private final Context mContext;
   private final ReactHostDelegate mReactHostDelegate;
   private final ComponentFactory mComponentFactory;
-  private final DevSupportManager mDevSupportManager;
+  private DevSupportManager mDevSupportManager;
   private final Executor mBGExecutor;
   private final Executor mUIExecutor;
   private final Set<ReactSurfaceImpl> mAttachedSurfaces = new HashSet<>();
@@ -130,12 +132,12 @@ public class ReactHostImpl implements ReactHost {
   private final ReactLifecycleStateManager mReactLifecycleStateManager =
       new ReactLifecycleStateManager(mBridgelessReactStateTracker);
   private final int mId = mCounter.getAndIncrement();
-  private @Nullable JSEngineResolutionAlgorithm mJSEngineResolutionAlgorithm = null;
   private @Nullable MemoryPressureListener mMemoryPressureListener;
   private @Nullable DefaultHardwareBackBtnHandler mDefaultHardwareBackBtnHandler;
 
-  private final List<ReactInstanceEventListener> mReactInstanceEventListeners = new ArrayList<>();
-  private final List<Function0<Unit>> mBeforeDestroyListeners = new ArrayList<>();
+  private final List<ReactInstanceEventListener> mReactInstanceEventListeners =
+      new CopyOnWriteArrayList<>();
+  private final List<Function0<Unit>> mBeforeDestroyListeners = new CopyOnWriteArrayList<>();
 
   private @Nullable ReactHostInspectorTarget mReactHostInspectorTarget;
 
@@ -165,6 +167,26 @@ public class ReactHostImpl implements ReactHost {
       Executor uiExecutor,
       boolean allowPackagerServerAccess,
       boolean useDevSupport) {
+    this(
+        context,
+        delegate,
+        componentFactory,
+        bgExecutor,
+        uiExecutor,
+        allowPackagerServerAccess,
+        useDevSupport,
+        null);
+  }
+
+  public ReactHostImpl(
+      Context context,
+      ReactHostDelegate delegate,
+      ComponentFactory componentFactory,
+      Executor bgExecutor,
+      Executor uiExecutor,
+      boolean allowPackagerServerAccess,
+      boolean useDevSupport,
+      @Nullable DevSupportManagerFactory devSupportManagerFactory) {
     mContext = context;
     mReactHostDelegate = delegate;
     mComponentFactory = componentFactory;
@@ -172,15 +194,25 @@ public class ReactHostImpl implements ReactHost {
     mUIExecutor = uiExecutor;
     mMemoryPressureRouter = new MemoryPressureRouter(context);
     mAllowPackagerServerAccess = allowPackagerServerAccess;
-    mUseDevSupport = useDevSupport;
-
-    if (mUseDevSupport) {
-      mDevSupportManager =
-          new BridgelessDevSupportManager(
-              ReactHostImpl.this, mContext, mReactHostDelegate.getJsMainModulePath());
-    } else {
-      mDevSupportManager = new ReleaseDevSupportManager();
+    mUseDevSupport = useDevSupport || ReactBuildConfig.UNSTABLE_ENABLE_FUSEBOX_RELEASE;
+    if (devSupportManagerFactory == null) {
+      devSupportManagerFactory = new DefaultDevSupportManagerFactory();
     }
+
+    mDevSupportManager =
+        devSupportManagerFactory.create(
+            /* applicationContext */ context.getApplicationContext(),
+            /* reactInstanceManagerHelper */ new ReactHostImplDevHelper(ReactHostImpl.this),
+            /* packagerPathForJSBundleName */ mReactHostDelegate.getJsMainModulePath(),
+            /* enableOnCreate */ true,
+            /* redBoxHandler */ null,
+            /* devBundleDownloadListener */ null,
+            /* minNumShakes */ 2,
+            /* customPackagerCommandHandlers */ null,
+            /* surfaceDelegateFactory */ null,
+            /* devLoadingViewManager */ null,
+            /* pausedInDebuggerOverlayManager */ null,
+            mUseDevSupport);
   }
 
   @Override
@@ -284,7 +316,7 @@ public class ReactHostImpl implements ReactHost {
     setCurrentActivity(activity);
     ReactContext currentContext = getCurrentReactContext();
 
-    // TODO(T137233065): Enable DevSupportManager here
+    maybeEnableDevSupport(true);
     mReactLifecycleStateManager.moveToOnHostResume(currentContext, getCurrentActivity());
   }
 
@@ -322,7 +354,7 @@ public class ReactHostImpl implements ReactHost {
               + activityClass);
     }
 
-    // TODO(T137233065): Disable DevSupportManager here
+    maybeEnableDevSupport(false);
     mDefaultHardwareBackBtnHandler = null;
     mReactLifecycleStateManager.moveToOnHostPause(currentContext, currentActivity);
   }
@@ -336,7 +368,7 @@ public class ReactHostImpl implements ReactHost {
 
     ReactContext currentContext = getCurrentReactContext();
 
-    // TODO(T137233065): Disable DevSupportManager here
+    maybeEnableDevSupport(false);
     mDefaultHardwareBackBtnHandler = null;
     mReactLifecycleStateManager.moveToOnHostPause(currentContext, getCurrentActivity());
   }
@@ -348,7 +380,7 @@ public class ReactHostImpl implements ReactHost {
     final String method = "onHostDestroy()";
     log(method);
 
-    // TODO(T137233065): Disable DevSupportManager here
+    maybeEnableDevSupport(false);
     moveToHostDestroy(getCurrentReactContext());
   }
 
@@ -360,12 +392,18 @@ public class ReactHostImpl implements ReactHost {
 
     Activity currentActivity = getCurrentActivity();
 
-    // TODO(T137233065): Disable DevSupportManager here
     if (currentActivity == activity) {
+      maybeEnableDevSupport(false);
       moveToHostDestroy(getCurrentReactContext());
     }
   }
 
+  private void maybeEnableDevSupport(boolean enabled) {
+    if (mUseDevSupport) {
+      mDevSupportManager.setDevSupportEnabled(enabled);
+    }
+  }
+
   /**
    * Returns current ReactContext which could be nullable if ReactInstance hasn't been created.
    *
@@ -430,16 +468,12 @@ public class ReactHostImpl implements ReactHost {
 
   /** Add a listener to be notified of ReactInstance events. */
   public void addReactInstanceEventListener(ReactInstanceEventListener listener) {
-    synchronized (mReactInstanceEventListeners) {
-      mReactInstanceEventListeners.add(listener);
-    }
+    mReactInstanceEventListeners.add(listener);
   }
 
   /** Remove a listener previously added with {@link #addReactInstanceEventListener}. */
   public void removeReactInstanceEventListener(ReactInstanceEventListener listener) {
-    synchronized (mReactInstanceEventListeners) {
-      mReactInstanceEventListeners.remove(listener);
-    }
+    mReactInstanceEventListeners.remove(listener);
   }
 
   /**
@@ -519,8 +553,48 @@ public class ReactHostImpl implements ReactHost {
    * Entrypoint to destroy the ReactInstance. If the ReactInstance is reloading, will wait until
    * reload is finished, before destroying.
    *
-   * @param reason {@link String} describing why ReactHost is being destroyed (e.g. memmory
-   *     pressure)
+   * <p>The destroy operation is asynchronous and the task returned by this method will complete
+   * when React Native gets destroyed. Note that the destroy operation will execute in multiple
+   * threads, in particular some of the sub-tasks will run in the UIThread. Calling {@link
+   * TaskInterface#waitForCompletion()} from the UIThread will lead into a deadlock. Use
+   * onDestroyFinished callback to be notified when React Native gets destroyed.
+   *
+   * @param reason describing why ReactHost is being destroyed (e.g. memory pressure)
+   * @param ex exception that caused the trigger to destroy ReactHost (or null) This exception will
+   *     be used to log properly the cause of destroy operation.
+   * @param onDestroyFinished callback that will be called when React Native gets destroyed, the
+   *     callback will run on a background thread.
+   * @return A task that completes when React Native gets destroyed.
+   */
+  @NonNull
+  @Override
+  public TaskInterface<Void> destroy(
+      @NonNull String reason,
+      @Nullable Exception ex,
+      @NonNull Function1<? super Boolean, Unit> onDestroyFinished) {
+    Task<Void> task = (Task<Void>) destroy(reason, ex);
+    return task.continueWith(
+        new Continuation<Void, Void>() {
+          @Nullable
+          @Override
+          public Void then(@NonNull Task<Void> task) throws Exception {
+            boolean instanceDestroyedSuccessfully = task.isCompleted() && !task.isFaulted();
+            onDestroyFinished.invoke(instanceDestroyedSuccessfully);
+            return null;
+          }
+        });
+  }
+
+  /**
+   * Entrypoint to destroy the ReactInstance. If the ReactInstance is reloading, will wait until
+   * reload is finished, before destroying.
+   *
+   * <p>The destroy operation is asynchronous and the task returned by this method will complete
+   * when React Native gets destroyed. Note that the destroy operation will execute in multiple
+   * threads, in particular some of the sub-tasks will run in the UIThread. Calling {@link
+   * TaskInterface#waitForCompletion()} from the UIThread will lead into a deadlock.
+   *
+   * @param reason {@link String} describing why ReactHost is being destroyed (e.g. memory pressure)
    * @param ex {@link Exception} exception that caused the trigger to destroy ReactHost (or null)
    *     This exception will be used to log properly the cause of destroy operation.
    * @return A task that completes when React Native gets destroyed.
@@ -876,16 +950,12 @@ public class ReactHostImpl implements ReactHost {
 
   @Override
   public void addBeforeDestroyListener(@NonNull Function0<Unit> onBeforeDestroy) {
-    synchronized (mBeforeDestroyListeners) {
-      mBeforeDestroyListeners.add(onBeforeDestroy);
-    }
+    mBeforeDestroyListeners.add(onBeforeDestroy);
   }
 
   @Override
   public void removeBeforeDestroyListener(@NonNull Function0<Unit> onBeforeDestroy) {
-    synchronized (mBeforeDestroyListeners) {
-      mBeforeDestroyListeners.remove(onBeforeDestroy);
-    }
+    mBeforeDestroyListeners.remove(onBeforeDestroy);
   }
 
   private interface ReactInstanceCalback {
@@ -900,6 +970,19 @@ public class ReactHostImpl implements ReactHost {
     final String method = "getOrCreateStartTask()";
     if (mStartTask == null) {
       log(method, "Schedule");
+      if (ReactBuildConfig.DEBUG) {
+        Assertions.assertCondition(
+            ReactNativeFeatureFlags.enableBridgelessArchitecture(),
+            "enableBridgelessArchitecture FeatureFlag must be set to start ReactNative.");
+
+        Assertions.assertCondition(
+            ReactNativeFeatureFlags.enableFabricRenderer(),
+            "enableFabricRenderer FeatureFlag must be set to start ReactNative.");
+
+        Assertions.assertCondition(
+            ReactNativeFeatureFlags.useTurboModules(),
+            "useTurboModules FeatureFlag must be set to start ReactNative.");
+      }
       mStartTask =
           waitThenCallGetOrCreateReactInstanceTask()
               .continueWithTask(
@@ -1189,12 +1272,7 @@ public class ReactHostImpl implements ReactHost {
                 }
 
                 log(method, "Executing ReactInstanceEventListeners");
-                ReactInstanceEventListener[] instanceEventListeners;
-                synchronized (mReactInstanceEventListeners) {
-                  instanceEventListeners =
-                      mReactInstanceEventListeners.toArray(new ReactInstanceEventListener[0]);
-                }
-                for (ReactInstanceEventListener listener : instanceEventListeners) {
+                for (ReactInstanceEventListener listener : mReactInstanceEventListeners) {
                   if (listener != null) {
                     listener.onReactContextInitialized(reactContext);
                   }
@@ -1400,9 +1478,14 @@ public class ReactHostImpl implements ReactHost {
         createReactInstanceUnwrapper("Reload", method, reason);
 
     if (mReloadTask == null) {
+      // When using the immediate executor, we want to avoid scheduling any further work immediately
+      // when destruction is kicked off.
+      Task<ReactInstance> createTask =
+          ReactNativeFeatureFlags.completeReactInstanceCreationOnBgThreadOnAndroid()
+              ? mCreateReactInstanceTaskRef.getAndReset()
+              : mCreateReactInstanceTaskRef.get();
       mReloadTask =
-          mCreateReactInstanceTaskRef
-              .get()
+          createTask
               .continueWithTask(
                   (task) -> {
                     log(method, "Starting React Native reload");
@@ -1442,22 +1525,10 @@ public class ReactHostImpl implements ReactHost {
                   mBGExecutor)
               .continueWithTask(
                   (task) -> {
-                    reactInstanceTaskUnwrapper.unwrap(
-                        task, "3: Executing Before Destroy Listeners");
-
-                    Function0<Unit>[] beforeDestroyListeners;
-                    synchronized (mBeforeDestroyListeners) {
-                      beforeDestroyListeners = mBeforeDestroyListeners.toArray(new Function0[0]);
-                    }
-                    for (Function0<Unit> destroyListener : beforeDestroyListeners) {
+                    reactInstanceTaskUnwrapper.unwrap(task, "3: Destroying ReactContext");
+                    for (Function0<Unit> destroyListener : mBeforeDestroyListeners) {
                       destroyListener.invoke();
                     }
-                    return task;
-                  },
-                  mUIExecutor)
-              .continueWithTask(
-                  task -> {
-                    reactInstanceTaskUnwrapper.unwrap(task, "4: Destroying ReactContext");
 
                     if (mMemoryPressureListener != null) {
                       log(method, "Removing memory pressure listener");
@@ -1486,7 +1557,7 @@ public class ReactHostImpl implements ReactHost {
               .continueWithTask(
                   task -> {
                     final ReactInstance reactInstance =
-                        reactInstanceTaskUnwrapper.unwrap(task, "5: Destroying ReactInstance");
+                        reactInstanceTaskUnwrapper.unwrap(task, "4: Destroying ReactInstance");
 
                     if (reactInstance == null) {
                       raiseSoftException(
@@ -1499,8 +1570,13 @@ public class ReactHostImpl implements ReactHost {
                       reactInstance.destroy();
                     }
 
-                    log(method, "Resetting createReactInstance task ref");
-                    mCreateReactInstanceTaskRef.reset();
+                    // Originally, we reset the instance task ref quite late, leading to potential
+                    // racing invocations while shutting down
+                    if (!ReactNativeFeatureFlags
+                        .completeReactInstanceCreationOnBgThreadOnAndroid()) {
+                      log(method, "Resetting createReactInstance task ref");
+                      mCreateReactInstanceTaskRef.reset();
+                    }
 
                     log(method, "Resetting start task ref");
                     mStartTask = null;
@@ -1512,7 +1588,7 @@ public class ReactHostImpl implements ReactHost {
               .continueWithTask(
                   task -> {
                     final ReactInstance reactInstance =
-                        reactInstanceTaskUnwrapper.unwrap(task, "6: Restarting surfaces");
+                        reactInstanceTaskUnwrapper.unwrap(task, "5: Restarting surfaces");
 
                     if (reactInstance == null) {
                       raiseSoftException(method, "Skipping surface restart: ReactInstance null");
@@ -1578,9 +1654,15 @@ public class ReactHostImpl implements ReactHost {
         createReactInstanceUnwrapper("Destroy", method, reason);
 
     if (mDestroyTask == null) {
+      // When using the immediate executor, we want to avoid scheduling any further work immediately
+      // when destruction is kicked off.
+      Task<ReactInstance> createTask =
+          ReactNativeFeatureFlags.completeReactInstanceCreationOnBgThreadOnAndroid()
+              ? mCreateReactInstanceTaskRef.getAndReset()
+              : mCreateReactInstanceTaskRef.get();
+
       mDestroyTask =
-          mCreateReactInstanceTaskRef
-              .get()
+          createTask
               .continueWithTask(
                   task -> {
                     log(method, "Starting React Native destruction");
@@ -1608,7 +1690,6 @@ public class ReactHostImpl implements ReactHost {
                     }
 
                     final ReactContext reactContext = mBridgelessReactContextRef.getNullable();
-
                     if (reactContext == null) {
                       raiseSoftException(method, "ReactContext is null. Destroy reason: " + reason);
                     }
@@ -1624,7 +1705,6 @@ public class ReactHostImpl implements ReactHost {
                   task -> {
                     final ReactInstance reactInstance =
                         reactInstanceTaskUnwrapper.unwrap(task, "2: Stopping surfaces");
-
                     if (reactInstance == null) {
                       raiseSoftException(method, "Skipping surface shutdown: ReactInstance null");
                       return task;
@@ -1641,23 +1721,10 @@ public class ReactHostImpl implements ReactHost {
                   mBGExecutor)
               .continueWithTask(
                   task -> {
-                    reactInstanceTaskUnwrapper.unwrap(
-                        task, "3: Executing Before Destroy Listeners");
-
-                    Set<Function0<Unit>> beforeDestroyListeners;
-                    synchronized (mBeforeDestroyListeners) {
-                      beforeDestroyListeners = new HashSet<>(mBeforeDestroyListeners);
-                    }
-
-                    for (Function0<Unit> destroyListener : beforeDestroyListeners) {
+                    reactInstanceTaskUnwrapper.unwrap(task, "3: Destroying ReactContext");
+                    for (Function0<Unit> destroyListener : mBeforeDestroyListeners) {
                       destroyListener.invoke();
                     }
-                    return task;
-                  },
-                  mUIExecutor)
-              .continueWithTask(
-                  task -> {
-                    reactInstanceTaskUnwrapper.unwrap(task, "4: Destroying ReactContext");
 
                     final ReactContext reactContext = mBridgelessReactContextRef.getNullable();
                     if (reactContext == null) {
@@ -1688,7 +1755,7 @@ public class ReactHostImpl implements ReactHost {
               .continueWithTask(
                   task -> {
                     final ReactInstance reactInstance =
-                        reactInstanceTaskUnwrapper.unwrap(task, "5: Destroying ReactInstance");
+                        reactInstanceTaskUnwrapper.unwrap(task, "4: Destroying ReactInstance");
 
                     if (reactInstance == null) {
                       raiseSoftException(
@@ -1701,8 +1768,13 @@ public class ReactHostImpl implements ReactHost {
                       reactInstance.destroy();
                     }
 
-                    log(method, "Resetting createReactInstance task ref");
-                    mCreateReactInstanceTaskRef.reset();
+                    // Originally, we reset the instance task ref quite late, leading to potential
+                    // racing invocations while shutting down
+                    if (!ReactNativeFeatureFlags
+                        .completeReactInstanceCreationOnBgThreadOnAndroid()) {
+                      log(method, "Resetting createReactInstance task ref");
+                      mCreateReactInstanceTaskRef.reset();
+                    }
 
                     log(method, "Resetting start task ref");
                     mStartTask = null;

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

@@ -0,0 +1,75 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+package com.facebook.react.runtime
+
+import android.app.Activity
+import android.os.Bundle
+import android.view.View
+import com.facebook.react.bridge.JSBundleLoader
+import com.facebook.react.bridge.JavaJSExecutor
+import com.facebook.react.bridge.JavaScriptExecutorFactory
+import com.facebook.react.bridge.ReactContext
+import com.facebook.react.devsupport.ReactInstanceDevHelper
+import com.facebook.react.interfaces.TaskInterface
+import com.facebook.react.modules.core.DeviceEventManagerModule
+
+/**
+ * Implementation of [ReactInstanceDevHelper] for [ReactHostImpl].
+ *
+ * This allows [BridgelessDevSupportHelper] and other classes inside the .devsupport package to
+ * communicate with the Bridgeless infrastructure without exposing public APIs.
+ */
+internal class ReactHostImplDevHelper(private val delegate: ReactHostImpl) :
+    ReactInstanceDevHelper {
+
+  override fun onReloadWithJSDebugger(proxyExecutorFactory: JavaJSExecutor.Factory) {
+    // Not implemented, only used by BridgeDevSupportManager to reload with proxy executor
+  }
+
+  override fun onJSBundleLoadedFromServer() {
+    // Not implemented, only referenced by BridgeDevSupportManager
+  }
+
+  override fun toggleElementInspector() {
+    val reactContext = delegate.currentReactContext
+    reactContext
+        ?.getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter::class.java)
+        ?.emit("toggleElementInspector", null)
+  }
+
+  override fun getCurrentActivity(): Activity? = delegate.lastUsedActivity
+
+  override fun getJavaScriptExecutorFactory(): JavaScriptExecutorFactory {
+    throw IllegalStateException("Not implemented for bridgeless mode")
+  }
+
+  override fun createRootView(appKey: String): View? {
+    val currentActivity = currentActivity
+    if (currentActivity != null && !delegate.isSurfaceWithModuleNameAttached(appKey)) {
+      val reactSurface = ReactSurfaceImpl.createWithView(currentActivity, appKey, Bundle())
+      reactSurface.attach(delegate)
+      reactSurface.start()
+
+      return reactSurface.view
+    }
+    return null
+  }
+
+  override fun destroyRootView(rootView: View) {
+    // Not implemented, only referenced by BridgeDevSupportManager
+  }
+
+  override fun reload(s: String) {
+    delegate.reload(s)
+  }
+
+  override fun loadBundle(bundleLoader: JSBundleLoader): TaskInterface<Boolean> =
+      delegate.loadBundle(bundleLoader)
+
+  override fun getCurrentReactContext(): ReactContext? = delegate.currentReactContext
+}

package/ReactAndroid/src/main/java/com/facebook/react/runtime/ReactInstance.java

@@ -40,10 +40,9 @@ import com.facebook.react.bridge.queue.ReactQueueConfigurationImpl;
 import com.facebook.react.bridge.queue.ReactQueueConfigurationSpec;
 import com.facebook.react.devsupport.StackTraceHelper;
 import com.facebook.react.devsupport.interfaces.DevSupportManager;
-import com.facebook.react.fabric.Binding;
-import com.facebook.react.fabric.BindingImpl;
 import com.facebook.react.fabric.ComponentFactory;
 import com.facebook.react.fabric.FabricUIManager;
+import com.facebook.react.fabric.FabricUIManagerBinding;
 import com.facebook.react.fabric.events.EventBeatManager;
 import com.facebook.react.interfaces.exceptionmanager.ReactJsExceptionHandler;
 import com.facebook.react.internal.AndroidChoreographerProvider;
@@ -272,7 +271,7 @@ final class ReactInstance {
     // Misc initialization that needs to be done before Fabric init
     DisplayMetricsHolder.initDisplayMetricsIfNotInitialized(mBridgelessReactContext);
 
-    Binding binding = new BindingImpl();
+    FabricUIManagerBinding binding = new FabricUIManagerBinding();
     binding.register(
         getBufferedRuntimeExecutor(),
         getRuntimeScheduler(),

package/ReactAndroid/src/main/java/com/facebook/react/runtime/ReactSurfaceImpl.java

@@ -16,6 +16,7 @@ import android.view.ViewGroup;
 import androidx.annotation.UiThread;
 import com.facebook.infer.annotation.Nullsafe;
 import com.facebook.infer.annotation.ThreadSafe;
+import com.facebook.react.ReactHost;
 import com.facebook.react.bridge.Arguments;
 import com.facebook.react.bridge.NativeMap;
 import com.facebook.react.bridge.UiThreadUtil;
@@ -93,9 +94,12 @@ public class ReactSurfaceImpl implements ReactSurface {
    *
    * @param host The ReactHost to attach.
    */
-  public void attach(ReactHostImpl host) {
-    if (!mReactHost.compareAndSet(null, host)) {
+  public void attach(ReactHost host) {
+    if (host instanceof ReactHostImpl && !mReactHost.compareAndSet(null, (ReactHostImpl) host)) {
       throw new IllegalStateException("This surface is already attached to a host!");
+    } else if (!(host instanceof ReactHostImpl)) {
+      throw new IllegalArgumentException(
+          "ReactSurfaceImpl.attach can only attach to ReactHostImpl.");
     }
   }
 

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

@@ -10,10 +10,10 @@ package com.facebook.react.runtime.cxxreactpackage
 
 import com.facebook.jni.HybridData
 import com.facebook.proguard.annotations.DoNotStrip
-import com.facebook.react.common.annotations.UnstableReactNativeAPI
+import com.facebook.react.common.annotations.FrameworkAPI
 
 /** CxxReactPackage is used to register C++ Turbo Modules with React Native. */
-@UnstableReactNativeAPI
+@OptIn(FrameworkAPI::class)
 public abstract class CxxReactPackage protected constructor(hybridData: HybridData?) {
 
   @DoNotStrip @Suppress("NoHungarianNotation") private var mHybridData: HybridData? = hybridData