expo-dev-launcher 4.0.0 → 4.0.2

package/android/src/main/java/com/facebook/react/devsupport/NonFinalBridgeDevSupportManager.java

@@ -0,0 +1,273 @@
+/*
+ * 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.devsupport;
+
+import android.content.Context;
+import android.widget.Toast;
+
+import androidx.annotation.Nullable;
+
+import com.facebook.common.logging.FLog;
+import com.facebook.debug.holder.PrinterHolder;
+import com.facebook.debug.tags.ReactDebugOverlayTags;
+import com.facebook.infer.annotation.Assertions;
+import com.facebook.react.R;
+import com.facebook.react.bridge.CatalystInstance;
+import com.facebook.react.bridge.JSBundleLoader;
+import com.facebook.react.bridge.JavaJSExecutor;
+import com.facebook.react.bridge.JavaScriptExecutorFactory;
+import com.facebook.react.bridge.ReactMarker;
+import com.facebook.react.bridge.ReactMarkerConstants;
+import com.facebook.react.bridge.UiThreadUtil;
+import com.facebook.react.common.ReactConstants;
+import com.facebook.react.common.SurfaceDelegateFactory;
+import com.facebook.react.common.futures.SimpleSettableFuture;
+import com.facebook.react.devsupport.interfaces.DevBundleDownloadListener;
+import com.facebook.react.devsupport.interfaces.DevLoadingViewManager;
+import com.facebook.react.devsupport.interfaces.DevOptionHandler;
+import com.facebook.react.devsupport.interfaces.DevSplitBundleCallback;
+import com.facebook.react.devsupport.interfaces.RedBoxHandler;
+import com.facebook.react.packagerconnection.RequestHandler;
+
+import java.io.File;
+import java.io.IOException;
+import java.util.Map;
+import java.util.concurrent.ExecutionException;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.TimeoutException;
+
+//
+// Expo: This is a copy of react-native's {@link com.facebook.react.devsupport.BridgeDevSupportManager}
+// just removing the "final" modifier that we can inherit and reuse.
+// From time to time for react-native upgrade, just follow the steps to update the code
+//   1. Copy the contents from BridgeDevSupportManager to this file.
+//   2. Rename the class to NonFinalBridgeDevSupportManager.
+//   3. Remove the "final" modifier.
+//   4. Revert the comment
+//
+
+/**
+ * Interface for accessing and interacting with development features. Following features
+ * are supported through this manager class:
+ * 1) Displaying JS errors (aka RedBox)
+ * 2) Displaying developers menu (Reload JS, Debug JS)
+ * 3) Communication with developer server in order to download updated JS bundle
+ * 4) Starting/stopping broadcast receiver for js reload signals
+ * 5) Starting/stopping motion sensor listener that recognize shake gestures which in turn may
+ *    trigger developers menu.
+ * 6) Launching developers settings view
+ *
+ * This class automatically monitors the state of registered views and activities to which they are
+ * bound to make sure that we don't display overlay or that we we don't listen for sensor events
+ * when app is backgrounded.
+ *
+ * {@link com.facebook.react.ReactInstanceManager} implementation is responsible for instantiating
+ * this class as well as for populating with a reference to {@link CatalystInstance} whenever
+ * instance manager recreates it (through {@link #onNewReactContextCreated). Also, instance manager
+ * is responsible for enabling/disabling dev support in case when app is backgrounded or when all
+ * the views has been detached from the instance (through {@link #setDevSupportEnabled} method).
+ */
+public class NonFinalBridgeDevSupportManager extends DevSupportManagerBase {
+    private boolean mIsSamplingProfilerEnabled = false;
+    private ReactInstanceDevHelper mReactInstanceManagerHelper;
+    private @Nullable DevLoadingViewManager mDevLoadingViewManager;
+
+    public NonFinalBridgeDevSupportManager(
+            Context applicationContext,
+            ReactInstanceDevHelper reactInstanceManagerHelper,
+            @Nullable String packagerPathForJSBundleName,
+            boolean enableOnCreate,
+            @Nullable RedBoxHandler redBoxHandler,
+            @Nullable DevBundleDownloadListener devBundleDownloadListener,
+            int minNumShakes,
+            @Nullable Map<String, RequestHandler> customPackagerCommandHandlers,
+            @Nullable SurfaceDelegateFactory surfaceDelegateFactory,
+            @Nullable DevLoadingViewManager devLoadingViewManager) {
+        super(
+                applicationContext,
+                reactInstanceManagerHelper,
+                packagerPathForJSBundleName,
+                enableOnCreate,
+                redBoxHandler,
+                devBundleDownloadListener,
+                minNumShakes,
+                customPackagerCommandHandlers,
+                surfaceDelegateFactory,
+                devLoadingViewManager);
+
+        if (getDevSettings().isStartSamplingProfilerOnInit()) {
+            // Only start the profiler. If its already running, there is an error
+            if (!mIsSamplingProfilerEnabled) {
+                toggleJSSamplingProfiler();
+            } else {
+                Toast.makeText(
+                                applicationContext,
+                                "JS Sampling Profiler was already running, so did not start the sampling profiler",
+                                Toast.LENGTH_LONG)
+                        .show();
+            }
+        }
+
+        addCustomDevOption(
+                applicationContext.getString(R.string.catalyst_sample_profiler_toggle),
+                new DevOptionHandler() {
+                    @Override
+                    public void onOptionSelected() {
+                        toggleJSSamplingProfiler();
+                    }
+                });
+    }
+
+    @Override
+    protected String getUniqueTag() {
+        return "Bridge";
+    }
+
+    @Override
+    public void loadSplitBundleFromServer(
+            final String bundlePath, final DevSplitBundleCallback callback) {
+        fetchSplitBundleAndCreateBundleLoader(
+                bundlePath,
+                new CallbackWithBundleLoader() {
+                    @Override
+                    public void onSuccess(JSBundleLoader bundleLoader) {
+                        bundleLoader.loadScript(getCurrentContext().getCatalystInstance());
+                        getCurrentContext()
+                                .getJSModule(HMRClient.class)
+                                .registerBundle(getDevServerHelper().getDevServerSplitBundleURL(bundlePath));
+                        callback.onSuccess();
+                    }
+
+                    @Override
+                    public void onError(String url, Throwable cause) {
+                        callback.onError(url, cause);
+                    }
+                });
+    }
+
+    private WebsocketJavaScriptExecutor.JSExecutorConnectCallback getExecutorConnectCallback(
+            final SimpleSettableFuture<Boolean> future) {
+        return new WebsocketJavaScriptExecutor.JSExecutorConnectCallback() {
+            @Override
+            public void onSuccess() {
+                future.set(true);
+                hideDevLoadingView();
+            }
+
+            @Override
+            public void onFailure(final Throwable cause) {
+                hideDevLoadingView();
+                FLog.e(ReactConstants.TAG, "Failed to connect to debugger!", cause);
+                future.setException(
+                        new IOException(
+                                getApplicationContext().getString(com.facebook.react.R.string.catalyst_debug_error),
+                                cause));
+            }
+        };
+    }
+
+    private void reloadJSInProxyMode() {
+        // When using js proxy, there is no need to fetch JS bundle as proxy executor will do that
+        // anyway
+        getDevServerHelper().launchJSDevtools();
+
+        JavaJSExecutor.Factory factory =
+                new JavaJSExecutor.Factory() {
+                    @Override
+                    public JavaJSExecutor create() throws Exception {
+                        WebsocketJavaScriptExecutor executor = new WebsocketJavaScriptExecutor();
+                        SimpleSettableFuture<Boolean> future = new SimpleSettableFuture<>();
+                        executor.connect(
+                                getDevServerHelper().getWebsocketProxyURL(), getExecutorConnectCallback(future));
+                        // TODO(t9349129) Don't use timeout
+                        try {
+                            future.get(90, TimeUnit.SECONDS);
+                            return executor;
+                        } catch (ExecutionException e) {
+                            throw (Exception) e.getCause();
+                        } catch (InterruptedException | TimeoutException e) {
+                            throw new RuntimeException(e);
+                        }
+                    }
+                };
+        getReactInstanceDevHelper().onReloadWithJSDebugger(factory);
+    }
+
+    @Override
+    public void handleReloadJS() {
+
+        UiThreadUtil.assertOnUiThread();
+
+        ReactMarker.logMarker(
+                ReactMarkerConstants.RELOAD,
+                getDevSettings().getPackagerConnectionSettings().getDebugServerHost());
+
+        // dismiss redbox if exists
+        hideRedboxDialog();
+
+        if (getDevSettings().isRemoteJSDebugEnabled()) {
+            PrinterHolder.getPrinter()
+                    .logMessage(ReactDebugOverlayTags.RN_CORE, "RNCore: load from Proxy");
+            showDevLoadingViewForRemoteJSEnabled();
+            reloadJSInProxyMode();
+        } else {
+            PrinterHolder.getPrinter()
+                    .logMessage(ReactDebugOverlayTags.RN_CORE, "RNCore: load from Server");
+            String bundleURL =
+                    getDevServerHelper()
+                            .getDevServerBundleURL(Assertions.assertNotNull(getJSAppBundleName()));
+            reloadJSFromServer(bundleURL);
+        }
+    }
+
+    /** Starts of stops the sampling profiler */
+    private void toggleJSSamplingProfiler() {
+        JavaScriptExecutorFactory javaScriptExecutorFactory =
+                getReactInstanceDevHelper().getJavaScriptExecutorFactory();
+        if (!mIsSamplingProfilerEnabled) {
+            try {
+                javaScriptExecutorFactory.startSamplingProfiler();
+                Toast.makeText(getApplicationContext(), "Starting Sampling Profiler", Toast.LENGTH_SHORT)
+                        .show();
+            } catch (UnsupportedOperationException e) {
+                Toast.makeText(
+                                getApplicationContext(),
+                                javaScriptExecutorFactory.toString() + " does not support Sampling Profiler",
+                                Toast.LENGTH_LONG)
+                        .show();
+            } finally {
+                mIsSamplingProfilerEnabled = true;
+            }
+        } else {
+            try {
+                final String outputPath =
+                        File.createTempFile(
+                                        "sampling-profiler-trace", ".cpuprofile", getApplicationContext().getCacheDir())
+                                .getPath();
+                javaScriptExecutorFactory.stopSamplingProfiler(outputPath);
+                Toast.makeText(
+                                getApplicationContext(),
+                                "Saved results from Profiler to " + outputPath,
+                                Toast.LENGTH_LONG)
+                        .show();
+            } catch (IOException e) {
+                FLog.e(
+                        ReactConstants.TAG,
+                        "Could not create temporary file for saving results from Sampling Profiler");
+            } catch (UnsupportedOperationException e) {
+                Toast.makeText(
+                                getApplicationContext(),
+                                javaScriptExecutorFactory.toString() + "does not support Sampling Profiler",
+                                Toast.LENGTH_LONG)
+                        .show();
+            } finally {
+                mIsSamplingProfilerEnabled = false;
+            }
+        }
+    }
+}

package/android/src/main/java/com/facebook/react/runtime/NonFinalBridgelessDevSupportManager.java

@@ -0,0 +1,177 @@
+/*
+ * 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.content.Context;
+import android.os.Bundle;
+import android.view.View;
+import com.facebook.debug.holder.PrinterHolder;
+import com.facebook.debug.tags.ReactDebugOverlayTags;
+import com.facebook.infer.annotation.Assertions;
+import com.facebook.infer.annotation.Nullsafe;
+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.bridge.UiThreadUtil;
+import com.facebook.react.devsupport.DevSupportManagerBase;
+import com.facebook.react.devsupport.HMRClient;
+import com.facebook.react.devsupport.ReactInstanceDevHelper;
+import com.facebook.react.devsupport.interfaces.DevSplitBundleCallback;
+import com.facebook.react.modules.core.DeviceEventManagerModule;
+import com.facebook.react.runtime.internal.bolts.Continuation;
+import com.facebook.react.runtime.internal.bolts.Task;
+import javax.annotation.Nullable;
+
+//
+// Expo: This is a copy of react-native's {@link com.facebook.react.runtime.BridgelessDevSupportManager}
+// just removing the "final" modifier that we can inherit and reuse.
+// From time to time for react-native upgrade, just follow the steps to update the code
+//   1. Copy the contents from BridgelessDevSupportManager to this file.
+//   2. Rename the class to NonFinalBridgelessDevSupportManager.
+//   3. Add "public" modifier
+//   4. Revert the comment
+//
+
+/**
+ * An implementation of {@link com.facebook.react.devsupport.interfaces.DevSupportManager} that
+ * extends the functionality in {@link DevSupportManagerBase} with some additional, more flexible
+ * APIs for asynchronously loading the JS bundle.
+ */
+@Nullsafe(Nullsafe.Mode.LOCAL)
+public class NonFinalBridgelessDevSupportManager extends DevSupportManagerBase {
+
+    private final ReactHostImpl mReactHost;
+
+    public NonFinalBridgelessDevSupportManager(
+            ReactHostImpl host, Context context, @Nullable String packagerPathForJSBundleName) {
+        super(
+                context.getApplicationContext(),
+                createInstanceDevHelper(host),
+                packagerPathForJSBundleName,
+                true /* enableOnCreate */,
+                null /* redBoxHandler */,
+                null /* devBundleDownloadListener */,
+                2 /* minNumShakes */,
+                null /* customPackagerCommandHandlers */,
+                null /* surfaceDelegateFactory */,
+                null /* devLoadingViewManager */);
+        mReactHost = host;
+    }
+
+    @Override
+    protected String getUniqueTag() {
+        return "Bridgeless";
+    }
+
+    @Override
+    public void loadSplitBundleFromServer(
+            final String bundlePath, final DevSplitBundleCallback callback) {
+        fetchSplitBundleAndCreateBundleLoader(
+                bundlePath,
+                new CallbackWithBundleLoader() {
+                    @Override
+                    public void onSuccess(final JSBundleLoader bundleLoader) {
+                        mReactHost
+                                .loadBundle(bundleLoader)
+                                .onSuccess(
+                                        new Continuation<Boolean, Void>() {
+                                            @Override
+                                            public Void then(Task<Boolean> task) {
+                                                if (task.getResult().equals(Boolean.TRUE)) {
+                                                    String bundleURL =
+                                                            getDevServerHelper().getDevServerSplitBundleURL(bundlePath);
+                                                    ReactContext reactContext = mReactHost.getCurrentReactContext();
+                                                    if (reactContext != null) {
+                                                        reactContext.getJSModule(HMRClient.class).registerBundle(bundleURL);
+                                                    }
+                                                    callback.onSuccess();
+                                                }
+                                                return null;
+                                            }
+                                        });
+                    }
+
+                    @Override
+                    public void onError(String url, Throwable cause) {
+                        callback.onError(url, cause);
+                    }
+                });
+    }
+
+    @Override
+    public void handleReloadJS() {
+        UiThreadUtil.assertOnUiThread();
+
+        // dismiss redbox if exists
+        hideRedboxDialog();
+        mReactHost.reload("BridgelessDevSupportManager.handleReloadJS()");
+
+        PrinterHolder.getPrinter()
+                .logMessage(ReactDebugOverlayTags.RN_CORE, "RNCore: load from Server");
+        String bundleURL =
+                getDevServerHelper().getDevServerBundleURL(Assertions.assertNotNull(getJSAppBundleName()));
+        reloadJSFromServer(bundleURL);
+    }
+
+    private static ReactInstanceDevHelper createInstanceDevHelper(final ReactHostImpl reactHost) {
+        return new ReactInstanceDevHelper() {
+            @Override
+            public void onReloadWithJSDebugger(JavaJSExecutor.Factory proxyExecutorFactory) {
+                // Not implemented
+            }
+
+            @Override
+            public void onJSBundleLoadedFromServer() {
+                // Not implemented
+            }
+
+            @Override
+            public void toggleElementInspector() {
+                ReactContext reactContext = reactHost.getCurrentReactContext();
+                if (reactContext != null) {
+                    reactContext
+                            .getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter.class)
+                            .emit("toggleElementInspector", null);
+                }
+            }
+
+            @androidx.annotation.Nullable
+            @Override
+            public Activity getCurrentActivity() {
+                return reactHost.getLastUsedActivity();
+            }
+
+            @Override
+            public JavaScriptExecutorFactory getJavaScriptExecutorFactory() {
+                throw new IllegalStateException("Not implemented for bridgeless mode");
+            }
+
+            @androidx.annotation.Nullable
+            @Override
+            public View createRootView(String appKey) {
+                Activity currentActivity = getCurrentActivity();
+                if (currentActivity != null && !reactHost.isSurfaceWithModuleNameAttached(appKey)) {
+                    ReactSurfaceImpl reactSurface =
+                            ReactSurfaceImpl.createWithView(currentActivity, appKey, new Bundle());
+                    reactSurface.attach(reactHost);
+                    reactSurface.start();
+
+                    return reactSurface.getView();
+                }
+                return null;
+            }
+
+            @Override
+            public void destroyRootView(View rootView) {
+                // Not implemented
+            }
+        };
+    }
+}

package/android/src/main/java/expo/modules/devlauncher/launcher/DevLauncherControllerInterface.kt

@@ -4,12 +4,12 @@ import android.content.Intent
 import android.net.Uri
 import com.facebook.react.ReactActivity
 import com.facebook.react.ReactActivityDelegate
-import com.facebook.react.ReactNativeHost
 import com.facebook.react.bridge.ReactContext
 import expo.modules.devlauncher.DevLauncherController
+import expo.interfaces.devmenu.ReactHostWrapper
 import expo.modules.manifests.core.Manifest
-import expo.modules.updatesinterface.UpdatesInterfaceCallbacks
 import expo.modules.updatesinterface.UpdatesInterface
+import expo.modules.updatesinterface.UpdatesInterfaceCallbacks
 import kotlinx.coroutines.CoroutineScope
 
 interface DevLauncherControllerInterface :
@@ -26,9 +26,9 @@ interface DevLauncherControllerInterface :
 
   val manifest: Manifest?
   val manifestURL: Uri?
-  val devClientHost: DevLauncherClientHost
+  val devClientHost: ReactHostWrapper
   val mode: DevLauncherController.Mode
-  val appHost: ReactNativeHost
+  val appHost: ReactHostWrapper
   val latestLoadedApp: Uri?
   val useDeveloperSupport: Boolean
   var updatesInterface: UpdatesInterface?

package/android/src/react-native-74/debug/expo/modules/devlauncher/rncompatibility/DevLauncherBridgeDevSupportManager.kt

@@ -0,0 +1,75 @@
+package expo.modules.devlauncher.rncompatibility
+
+import android.content.Context
+import android.util.Log
+import com.facebook.react.devsupport.NonFinalBridgeDevSupportManager
+import com.facebook.react.devsupport.ReactInstanceDevHelper
+import com.facebook.react.devsupport.interfaces.DevBundleDownloadListener
+import com.facebook.react.devsupport.interfaces.RedBoxHandler
+import com.facebook.react.packagerconnection.RequestHandler
+import expo.modules.devlauncher.DevLauncherController
+import expo.modules.devlauncher.koin.DevLauncherKoinComponent
+import expo.modules.devlauncher.koin.optInject
+import expo.modules.devlauncher.launcher.DevLauncherControllerInterface
+import expo.modules.devlauncher.launcher.errors.DevLauncherAppError
+import expo.modules.devlauncher.launcher.errors.DevLauncherErrorActivity
+
+class DevLauncherBridgeDevSupportManager(
+  applicationContext: Context?,
+  reactInstanceDevHelper: ReactInstanceDevHelper?,
+  packagerPathForJSBundleName: String?,
+  enableOnCreate: Boolean,
+  redBoxHandler: RedBoxHandler?,
+  devBundleDownloadListener: DevBundleDownloadListener?,
+  minNumShakes: Int,
+  customPackagerCommandHandlers: MutableMap<String, RequestHandler>?
+) : NonFinalBridgeDevSupportManager(
+  applicationContext,
+  reactInstanceDevHelper,
+  packagerPathForJSBundleName,
+  enableOnCreate,
+  redBoxHandler,
+  devBundleDownloadListener,
+  minNumShakes,
+  customPackagerCommandHandlers,
+  null,
+  null
+),
+  DevLauncherKoinComponent {
+  private val controller: DevLauncherControllerInterface? by optInject()
+
+  override fun showNewJavaError(message: String?, e: Throwable) {
+    Log.e("DevLauncher", "$message", e)
+    if (!DevLauncherController.wasInitialized()) {
+      Log.e("DevLauncher", "DevLauncher wasn't initialized. Couldn't intercept native error handling.")
+      super.showNewJavaError(message, e)
+      return
+    }
+
+    val activity = reactInstanceDevHelper?.currentActivity
+    if (activity == null || activity.isFinishing || activity.isDestroyed) {
+      return
+    }
+
+    controller?.onAppLoadedWithError()
+    DevLauncherErrorActivity.showError(activity, DevLauncherAppError(message, e))
+  }
+
+  override fun getUniqueTag() = "DevLauncherApp - Bridge"
+
+  override fun startInspector() {
+    // no-op for the default `startInspector` which would be implicitly called
+    // right after `ReactInstanceManager` construction.
+    // For dev-launcher, we should inject the correct dev server address and
+    // call our customized `startInspectorWhenDevLauncherReady`.
+    // Check `DevLauncherReactUtils.injectReactInterceptor()` for details.
+  }
+
+  fun startInspectorWhenDevLauncherReady() {
+    super.startInspector()
+  }
+
+  companion object {
+    fun getDevHelperInternalFieldName() = "mReactInstanceDevHelper"
+  }
+}

package/android/src/react-native-74/debug/expo/modules/devlauncher/rncompatibility/DevLauncherBridgelessDevSupportManager.kt

@@ -0,0 +1,55 @@
+package expo.modules.devlauncher.rncompatibility
+
+import android.content.Context
+import android.util.Log
+import com.facebook.react.runtime.NonFinalBridgelessDevSupportManager
+import com.facebook.react.runtime.ReactHostImpl
+import expo.modules.devlauncher.DevLauncherController
+import expo.modules.devlauncher.koin.DevLauncherKoinComponent
+import expo.modules.devlauncher.koin.optInject
+import expo.modules.devlauncher.launcher.DevLauncherControllerInterface
+import expo.modules.devlauncher.launcher.errors.DevLauncherAppError
+import expo.modules.devlauncher.launcher.errors.DevLauncherErrorActivity
+
+class DevLauncherBridgelessDevSupportManager(
+  host: ReactHostImpl,
+  context: Context,
+  packagerPathForJSBundleName: String?
+) : NonFinalBridgelessDevSupportManager(host, context, packagerPathForJSBundleName), DevLauncherKoinComponent {
+  private val controller: DevLauncherControllerInterface? by optInject()
+
+  override fun showNewJavaError(message: String?, e: Throwable) {
+    Log.e("DevLauncher", "$message", e)
+    if (!DevLauncherController.wasInitialized()) {
+      Log.e("DevLauncher", "DevLauncher wasn't initialized. Couldn't intercept native error handling.")
+      super.showNewJavaError(message, e)
+      return
+    }
+
+    val activity = reactInstanceDevHelper?.currentActivity
+    if (activity == null || activity.isFinishing || activity.isDestroyed) {
+      return
+    }
+
+    controller?.onAppLoadedWithError()
+    DevLauncherErrorActivity.showError(activity, DevLauncherAppError(message, e))
+  }
+
+  override fun getUniqueTag() = "DevLauncherApp - Bridgeless"
+
+  override fun startInspector() {
+    // no-op for the default `startInspector` which would be implicitly called
+    // right after `ReactInstanceManager` construction.
+    // For dev-launcher, we should inject the correct dev server address and
+    // call our customized `startInspectorWhenDevLauncherReady`.
+    // Check `DevLauncherReactUtils.injectReactInterceptor()` for details.
+  }
+
+  fun startInspectorWhenDevLauncherReady() {
+    super.startInspector()
+  }
+
+  companion object {
+    fun getDevHelperInternalFieldName() = "mReactInstanceDevHelper"
+  }
+}

package/android/src/react-native-74/debug/expo/modules/devlauncher/rncompatibility/DevLauncherDevSupportManagerFactory.kt

@@ -14,7 +14,7 @@ import com.facebook.react.packagerconnection.RequestHandler
 class DevLauncherDevSupportManagerFactory : DevSupportManagerFactory {
   override fun create(
     applicationContext: Context,
-    reactInstanceManagerHelper: ReactInstanceDevHelper,
+    reactInstanceDevHelper: ReactInstanceDevHelper,
     packagerPathForJSBundleName: String?,
     enableOnCreate: Boolean,
     redBoxHandler: RedBoxHandler?,
@@ -27,9 +27,9 @@ class DevLauncherDevSupportManagerFactory : DevSupportManagerFactory {
     return if (!enableOnCreate) {
       DisabledDevSupportManager()
     } else {
-      DevLauncherDevSupportManager(
+      DevLauncherBridgeDevSupportManager(
         applicationContext,
-        reactInstanceManagerHelper,
+        reactInstanceDevHelper,
         packagerPathForJSBundleName,
         enableOnCreate,
         redBoxHandler,

package/android/src/release/java/expo/modules/devlauncher/DevLauncherController.kt

@@ -5,13 +5,12 @@ import android.content.Intent
 import android.net.Uri
 import com.facebook.react.ReactActivity
 import com.facebook.react.ReactActivityDelegate
-import com.facebook.react.ReactNativeHost
+import com.facebook.react.ReactApplication
 import com.facebook.react.bridge.ReactContext
-import expo.modules.devlauncher.launcher.DevLauncherClientHost
+import expo.interfaces.devmenu.ReactHostWrapper
+import expo.modules.devlauncher.launcher.DevLauncherAppEntry
 import expo.modules.devlauncher.launcher.DevLauncherControllerInterface
 import expo.modules.devlauncher.launcher.DevLauncherReactActivityDelegateSupplier
-import expo.modules.devlauncher.launcher.DevLauncherAppEntry
-
 import expo.modules.manifests.core.Manifest
 import expo.modules.updatesinterface.UpdatesInterface
 import kotlinx.coroutines.CoroutineScope
@@ -29,7 +28,7 @@ class DevLauncherController private constructor() : DevLauncherControllerInterfa
   override val mode: Mode
     get() = throw IllegalStateException(DEV_LAUNCHER_IS_NOT_AVAILABLE)
 
-  override val devClientHost: DevLauncherClientHost
+  override val devClientHost: ReactHostWrapper
     get() = throw IllegalStateException(DEV_LAUNCHER_IS_NOT_AVAILABLE)
 
   override val manifest: Manifest
@@ -38,7 +37,7 @@ class DevLauncherController private constructor() : DevLauncherControllerInterfa
   override val manifestURL: Uri
     get() = throw IllegalStateException(DEV_LAUNCHER_IS_NOT_AVAILABLE)
 
-  override val appHost: ReactNativeHost
+  override val appHost: ReactHostWrapper
     get() = throw IllegalStateException(DEV_LAUNCHER_IS_NOT_AVAILABLE)
 
   override var updatesInterface: UpdatesInterface?
@@ -100,14 +99,19 @@ class DevLauncherController private constructor() : DevLauncherControllerInterfa
       }
 
     @JvmStatic
-    fun initialize(context: Context, reactNativeHost: ReactNativeHost) {
+    internal fun initialize(context: Context, reactHost: ReactHostWrapper) {
       check(sInstance == null) { "DevelopmentClientController was initialized." }
       sInstance = DevLauncherController()
     }
 
     @JvmStatic
-    fun initialize(context: Context, appHost: ReactNativeHost, cazz: Class<*>) {
-      initialize(context, appHost)
+    fun initialize(context: Context, reactHost: ReactHostWrapper, launcherClass: Class<*>? = null) {
+      initialize(context, reactHost)
+    }
+
+    @JvmStatic
+    fun initialize(reactApplication: ReactApplication, additionalPackages: List<*>? = null, launcherClass: Class<*>? = null) {
+      initialize(reactApplication as Context, ReactHostWrapper(reactApplication.reactNativeHost, reactApplication.reactHost))
     }
 
     @JvmStatic