react-native 0.71.6 → 0.72.0-rc.1

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

@@ -7,6 +7,8 @@
 
 package com.facebook.react;
 
+import androidx.annotation.Nullable;
+import com.facebook.react.bridge.ModuleSpec;
 import com.facebook.react.bridge.NativeModule;
 import com.facebook.react.bridge.ReactApplicationContext;
 import com.facebook.react.devsupport.JSCHeapCapture;
@@ -15,8 +17,15 @@ import com.facebook.react.module.annotations.ReactModuleList;
 import com.facebook.react.module.model.ReactModuleInfo;
 import com.facebook.react.module.model.ReactModuleInfoProvider;
 import com.facebook.react.turbomodule.core.interfaces.TurboModule;
+import com.facebook.react.uimanager.UIManagerModule;
+import com.facebook.react.uimanager.ViewManager;
+import com.facebook.react.views.traceupdateoverlay.TraceUpdateOverlayManager;
+import java.util.ArrayList;
+import java.util.Collection;
 import java.util.HashMap;
+import java.util.List;
 import java.util.Map;
+import javax.inject.Provider;
 
 /**
  * Package defining core framework modules (e.g. UIManager). It should be used for modules that
@@ -27,13 +36,15 @@ import java.util.Map;
     nativeModules = {
       JSCHeapCapture.class,
     })
-public class DebugCorePackage extends TurboReactPackage {
+public class DebugCorePackage extends TurboReactPackage implements ViewManagerOnDemandReactPackage {
+  private @Nullable Map<String, ModuleSpec> mViewManagers;
+
   public DebugCorePackage() {}
 
   @Override
   public NativeModule getModule(String name, ReactApplicationContext reactContext) {
     switch (name) {
-      case JSCHeapCapture.TAG:
+      case JSCHeapCapture.NAME:
         return new JSCHeapCapture(reactContext);
       default:
         throw new IllegalArgumentException(
@@ -81,4 +92,45 @@ public class DebugCorePackage extends TurboReactPackage {
           "No ReactModuleInfoProvider for DebugCorePackage$$ReactModuleInfoProvider", e);
     }
   }
+
+  private static void appendMap(
+      Map<String, ModuleSpec> map, String name, Provider<? extends NativeModule> provider) {
+    map.put(name, ModuleSpec.viewManagerSpec(provider));
+  }
+
+  /** @return a map of view managers that should be registered with {@link UIManagerModule} */
+  private Map<String, ModuleSpec> getViewManagersMap(final ReactApplicationContext reactContext) {
+    if (mViewManagers == null) {
+      Map<String, ModuleSpec> viewManagers = new HashMap<>();
+      appendMap(
+          viewManagers,
+          TraceUpdateOverlayManager.REACT_CLASS,
+          new Provider<NativeModule>() {
+            @Override
+            public NativeModule get() {
+              return new TraceUpdateOverlayManager();
+            }
+          });
+
+      mViewManagers = viewManagers;
+    }
+    return mViewManagers;
+  }
+
+  @Override
+  public List<ModuleSpec> getViewManagers(ReactApplicationContext reactContext) {
+    return new ArrayList<>(getViewManagersMap(reactContext).values());
+  }
+
+  @Override
+  public Collection<String> getViewManagerNames(ReactApplicationContext reactContext) {
+    return getViewManagersMap(reactContext).keySet();
+  }
+
+  @Override
+  public @Nullable ViewManager createViewManager(
+      ReactApplicationContext reactContext, String viewManagerName) {
+    ModuleSpec spec = getViewManagersMap(reactContext).get(viewManagerName);
+    return spec != null ? (ViewManager) spec.getProvider().get() : null;
+  }
 }

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

@@ -33,44 +33,16 @@ import java.util.Map;
  */
 public abstract class LazyReactPackage implements ReactPackage {
 
+  @Deprecated
   public static ReactModuleInfoProvider getReactModuleInfoProviderViaReflection(
       LazyReactPackage lazyReactPackage) {
-    Class<?> reactModuleInfoProviderClass;
-    try {
-      reactModuleInfoProviderClass =
-          Class.forName(
-              lazyReactPackage.getClass().getCanonicalName() + "$$ReactModuleInfoProvider");
-    } catch (ClassNotFoundException e) {
-      // In OSS case, when the annotation processor does not run, we fall back to non-lazy mode
-      // For this, we simply return an empty moduleMap.
-      // NativeModuleRegistryBuilder will eagerly get all the modules, and get the info from the
-      // modules directly
-      return new ReactModuleInfoProvider() {
-        @Override
-        public Map<String, ReactModuleInfo> getReactModuleInfos() {
-          return Collections.emptyMap();
-        }
-      };
-    }
-
-    if (reactModuleInfoProviderClass == null) {
-      throw new RuntimeException(
-          "ReactModuleInfoProvider class for "
-              + lazyReactPackage.getClass().getCanonicalName()
-              + " not found.");
-    }
-
-    try {
-      return (ReactModuleInfoProvider) reactModuleInfoProviderClass.newInstance();
-    } catch (InstantiationException e) {
-      throw new RuntimeException(
-          "Unable to instantiate ReactModuleInfoProvider for " + lazyReactPackage.getClass(), e);
-    } catch (IllegalAccessException e) {
-      throw new RuntimeException(
-          "Unable to instantiate ReactModuleInfoProvider for " + lazyReactPackage.getClass(), e);
-    }
+    return new ReactModuleInfoProvider() {
+      @Override
+      public Map<String, ReactModuleInfo> getReactModuleInfos() {
+        return Collections.emptyMap();
+      }
+    };
   }
-
   /**
    * We return an iterable
    *

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

@@ -34,7 +34,6 @@ public class ReactActivityDelegate {
   private @Nullable PermissionListener mPermissionListener;
   private @Nullable Callback mPermissionsCallback;
   private ReactDelegate mReactDelegate;
-  private boolean mConcurrentRootEnabled;
 
   @Deprecated
   public ReactActivityDelegate(Activity activity, @Nullable String mainComponentName) {
@@ -57,9 +56,9 @@ public class ReactActivityDelegate {
     return null;
   }
 
-  private @NonNull Bundle composeLaunchOptions() {
+  protected @NonNull Bundle composeLaunchOptions() {
     Bundle composedLaunchOptions = getLaunchOptions();
-    if (isConcurrentRootEnabled()) {
+    if (isFabricEnabled()) {
       if (composedLaunchOptions == null) {
         composedLaunchOptions = new Bundle();
       }
@@ -72,6 +71,10 @@ public class ReactActivityDelegate {
     return new ReactRootView(getContext());
   }
 
+  protected ReactRootView createRootView(Bundle initialProps) {
+    return new ReactRootView(getContext());
+  }
+
   /**
    * Get the {@link ReactNativeHost} used by this app. By default, assumes {@link
    * Activity#getApplication()} is an instance of {@link ReactApplication} and calls {@link
@@ -93,13 +96,13 @@ public class ReactActivityDelegate {
 
   protected void onCreate(Bundle savedInstanceState) {
     String mainComponentName = getMainComponentName();
-    Bundle launchOptions = composeLaunchOptions();
+    final Bundle launchOptions = composeLaunchOptions();
     mReactDelegate =
         new ReactDelegate(
             getPlainActivity(), getReactNativeHost(), mainComponentName, launchOptions) {
           @Override
           protected ReactRootView createRootView() {
-            return ReactActivityDelegate.this.createRootView();
+            return ReactActivityDelegate.this.createRootView(launchOptions);
           }
         };
     if (mainComponentName != null) {
@@ -212,14 +215,12 @@ public class ReactActivityDelegate {
   }
 
   /**
-   * Override this method to enable Concurrent Root on the surface for this Activity. See:
-   * https://reactjs.org/blog/2022/03/29/react-v18.html
-   *
-   * <p>This requires to be rendering on Fabric (i.e. on the New Architecture).
+   * Override this method if you wish to selectively toggle Fabric for a specific surface. This will
+   * also control if Concurrent Root (React 18) should be enabled or not.
    *
-   * @return Wether you want to enable Concurrent Root for this surface or not.
+   * @return true if Fabric is enabled for this Activity, false otherwise.
    */
-  protected boolean isConcurrentRootEnabled() {
+  protected boolean isFabricEnabled() {
     return false;
   }
 }

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

@@ -11,6 +11,7 @@ import android.app.Activity;
 import android.content.Intent;
 import android.os.Bundle;
 import android.view.KeyEvent;
+import androidx.annotation.NonNull;
 import androidx.annotation.Nullable;
 import com.facebook.infer.annotation.Assertions;
 import com.facebook.react.devsupport.DoubleTapReloadRecognizer;
@@ -33,6 +34,8 @@ public class ReactDelegate {
 
   private ReactNativeHost mReactNativeHost;
 
+  private boolean mFabricEnabled = false;
+
   public ReactDelegate(
       Activity activity,
       ReactNativeHost reactNativeHost,
@@ -45,6 +48,20 @@ public class ReactDelegate {
     mReactNativeHost = reactNativeHost;
   }
 
+  public ReactDelegate(
+      Activity activity,
+      ReactNativeHost reactNativeHost,
+      @Nullable String appKey,
+      @Nullable Bundle launchOptions,
+      boolean fabricEnabled) {
+    mActivity = activity;
+    mMainComponentName = appKey;
+    mLaunchOptions = composeLaunchOptions(launchOptions);
+    mDoubleTapReloadRecognizer = new DoubleTapReloadRecognizer();
+    mReactNativeHost = reactNativeHost;
+    mFabricEnabled = fabricEnabled;
+  }
+
   public void onHostResume() {
     if (getReactNativeHost().hasInstance()) {
       if (mActivity instanceof DefaultHardwareBackBtnHandler) {
@@ -109,7 +126,9 @@ public class ReactDelegate {
   }
 
   protected ReactRootView createRootView() {
-    return new ReactRootView(mActivity);
+    ReactRootView reactRootView = new ReactRootView(mActivity);
+    reactRootView.setIsFabric(isFabricEnabled());
+    return reactRootView;
   }
 
   /**
@@ -144,4 +163,24 @@ public class ReactDelegate {
   public ReactInstanceManager getReactInstanceManager() {
     return getReactNativeHost().getReactInstanceManager();
   }
+
+  /**
+   * Override this method if you wish to selectively toggle Fabric for a specific surface. This will
+   * also control if Concurrent Root (React 18) should be enabled or not.
+   *
+   * @return true if Fabric is enabled for this Activity, false otherwise.
+   */
+  protected boolean isFabricEnabled() {
+    return mFabricEnabled;
+  }
+
+  private @NonNull Bundle composeLaunchOptions(Bundle composedLaunchOptions) {
+    if (isFabricEnabled()) {
+      if (composedLaunchOptions == null) {
+        composedLaunchOptions = new Bundle();
+      }
+      composedLaunchOptions.putBoolean("concurrentRoot", true);
+    }
+    return composedLaunchOptions;
+  }
 }

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

@@ -16,6 +16,7 @@ import android.view.KeyEvent;
 import android.view.LayoutInflater;
 import android.view.View;
 import android.view.ViewGroup;
+import androidx.annotation.NonNull;
 import androidx.annotation.Nullable;
 import androidx.fragment.app.Fragment;
 import com.facebook.react.modules.core.PermissionAwareActivity;
@@ -29,6 +30,7 @@ public class ReactFragment extends Fragment implements PermissionAwareActivity {
 
   protected static final String ARG_COMPONENT_NAME = "arg_component_name";
   protected static final String ARG_LAUNCH_OPTIONS = "arg_launch_options";
+  protected static final String ARG_FABRIC_ENABLED = "arg_fabric_enabled";
 
   private ReactDelegate mReactDelegate;
 
@@ -40,13 +42,16 @@ public class ReactFragment extends Fragment implements PermissionAwareActivity {
 
   /**
    * @param componentName The name of the react native component
+   * @param fabricEnabled Flag to enable Fabric for ReactFragment
    * @return A new instance of fragment ReactFragment.
    */
-  private static ReactFragment newInstance(String componentName, Bundle launchOptions) {
+  private static ReactFragment newInstance(
+      String componentName, Bundle launchOptions, Boolean fabricEnabled) {
     ReactFragment fragment = new ReactFragment();
     Bundle args = new Bundle();
     args.putString(ARG_COMPONENT_NAME, componentName);
     args.putBundle(ARG_LAUNCH_OPTIONS, launchOptions);
+    args.putBoolean(ARG_FABRIC_ENABLED, fabricEnabled);
     fragment.setArguments(args);
     return fragment;
   }
@@ -57,15 +62,18 @@ public class ReactFragment extends Fragment implements PermissionAwareActivity {
     super.onCreate(savedInstanceState);
     String mainComponentName = null;
     Bundle launchOptions = null;
+    Boolean fabricEnabled = null;
     if (getArguments() != null) {
       mainComponentName = getArguments().getString(ARG_COMPONENT_NAME);
       launchOptions = getArguments().getBundle(ARG_LAUNCH_OPTIONS);
+      fabricEnabled = getArguments().getBoolean(ARG_FABRIC_ENABLED);
     }
     if (mainComponentName == null) {
       throw new IllegalStateException("Cannot loadApp if component name is null");
     }
     mReactDelegate =
-        new ReactDelegate(getActivity(), getReactNativeHost(), mainComponentName, launchOptions);
+        new ReactDelegate(
+            getActivity(), getReactNativeHost(), mainComponentName, launchOptions, fabricEnabled);
   }
 
   /**
@@ -85,7 +93,7 @@ public class ReactFragment extends Fragment implements PermissionAwareActivity {
 
   @Override
   public View onCreateView(
-      LayoutInflater inflater, ViewGroup container, Bundle savedInstanceState) {
+      @NonNull LayoutInflater inflater, ViewGroup container, Bundle savedInstanceState) {
     mReactDelegate.loadApp();
     return mReactDelegate.getReactRootView();
   }
@@ -140,7 +148,7 @@ public class ReactFragment extends Fragment implements PermissionAwareActivity {
 
   @Override
   public void onRequestPermissionsResult(
-      int requestCode, String[] permissions, int[] grantResults) {
+      int requestCode, @NonNull String[] permissions, @NonNull int[] grantResults) {
     super.onRequestPermissionsResult(requestCode, permissions, grantResults);
     if (mPermissionListener != null
         && mPermissionListener.onRequestPermissionsResult(requestCode, permissions, grantResults)) {
@@ -170,12 +178,14 @@ public class ReactFragment extends Fragment implements PermissionAwareActivity {
   /** Builder class to help instantiate a ReactFragment */
   public static class Builder {
 
-    String mComponentName;
-    Bundle mLaunchOptions;
+    @Nullable String mComponentName;
+    @Nullable Bundle mLaunchOptions;
+    @Nullable Boolean mFabricEnabled;
 
     public Builder() {
       mComponentName = null;
       mLaunchOptions = null;
+      mFabricEnabled = null;
     }
 
     /**
@@ -201,7 +211,12 @@ public class ReactFragment extends Fragment implements PermissionAwareActivity {
     }
 
     public ReactFragment build() {
-      return ReactFragment.newInstance(mComponentName, mLaunchOptions);
+      return ReactFragment.newInstance(mComponentName, mLaunchOptions, mFabricEnabled);
+    }
+
+    public Builder setFabricEnabled(boolean fabricEnabled) {
+      mFabricEnabled = fabricEnabled;
+      return this;
     }
   }
 }

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

@@ -82,6 +82,7 @@ import com.facebook.react.config.ReactFeatureFlags;
 import com.facebook.react.devsupport.DevSupportManagerFactory;
 import com.facebook.react.devsupport.ReactInstanceDevHelper;
 import com.facebook.react.devsupport.interfaces.DevBundleDownloadListener;
+import com.facebook.react.devsupport.interfaces.DevLoadingViewManager;
 import com.facebook.react.devsupport.interfaces.DevSupportManager;
 import com.facebook.react.devsupport.interfaces.PackagerStatusCallback;
 import com.facebook.react.devsupport.interfaces.RedBoxHandler;
@@ -233,7 +234,8 @@ public class ReactInstanceManager {
       @Nullable JSIModulePackage jsiModulePackage,
       @Nullable Map<String, RequestHandler> customPackagerCommandHandlers,
       @Nullable ReactPackageTurboModuleManagerDelegate.Builder tmmDelegateBuilder,
-      @Nullable SurfaceDelegateFactory surfaceDelegateFactory) {
+      @Nullable SurfaceDelegateFactory surfaceDelegateFactory,
+      @Nullable DevLoadingViewManager devLoadingViewManager) {
     FLog.d(TAG, "ReactInstanceManager.ctor()");
     initializeSoLoaderIfNecessary(applicationContext);
 
@@ -261,7 +263,8 @@ public class ReactInstanceManager {
             devBundleDownloadListener,
             minNumShakes,
             customPackagerCommandHandlers,
-            surfaceDelegateFactory);
+            surfaceDelegateFactory,
+            devLoadingViewManager);
     Systrace.endSection(TRACE_TAG_REACT_JAVA_BRIDGE);
     mBridgeIdleDebugListener = bridgeIdleDebugListener;
     mLifecycleState = initialLifecycleState;
@@ -384,7 +387,7 @@ public class ReactInstanceManager {
     try {
       handleCxxErrorFunc = ReactInstanceManager.class.getMethod("handleCxxError", parameterTypes);
     } catch (NoSuchMethodException e) {
-      FLog.e("ReactInstanceHolder", "Failed to set cxx error hanlder function", e);
+      FLog.e("ReactInstanceHolder", "Failed to set cxx error handler function", e);
     }
     ReactCxxErrorHandler.setHandleErrorFunc(this, handleCxxErrorFunc);
   }
@@ -551,9 +554,7 @@ public class ReactInstanceManager {
   private void toggleElementInspector() {
     ReactContext currentContext = getCurrentReactContext();
     if (currentContext != null && currentContext.hasActiveReactInstance()) {
-      currentContext
-          .getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter.class)
-          .emit("toggleElementInspector", null);
+      currentContext.emitDeviceEvent("toggleElementInspector");
     } else {
       ReactSoftExceptionLogger.logSoftException(
           TAG,
@@ -920,10 +921,11 @@ public class ReactInstanceManager {
       if (mViewManagers == null) {
         synchronized (mPackages) {
           if (mViewManagers == null) {
-            mViewManagers = new ArrayList<>();
+            ArrayList<ViewManager> viewManagers = new ArrayList<>();
             for (ReactPackage reactPackage : mPackages) {
-              mViewManagers.addAll(reactPackage.createViewManagers(catalystApplicationContext));
+              viewManagers.addAll(reactPackage.createViewManagers(catalystApplicationContext));
             }
+            mViewManagers = viewManagers;
             return mViewManagers;
           }
         }

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

@@ -28,6 +28,7 @@ import com.facebook.react.common.SurfaceDelegateFactory;
 import com.facebook.react.devsupport.DefaultDevSupportManagerFactory;
 import com.facebook.react.devsupport.DevSupportManagerFactory;
 import com.facebook.react.devsupport.interfaces.DevBundleDownloadListener;
+import com.facebook.react.devsupport.interfaces.DevLoadingViewManager;
 import com.facebook.react.devsupport.interfaces.DevSupportManager;
 import com.facebook.react.devsupport.interfaces.RedBoxHandler;
 import com.facebook.react.jscexecutor.JSCExecutor;
@@ -67,6 +68,7 @@ public class ReactInstanceManagerBuilder {
   private @Nullable Map<String, RequestHandler> mCustomPackagerCommandHandlers;
   private @Nullable ReactPackageTurboModuleManagerDelegate.Builder mTMMDelegateBuilder;
   private @Nullable SurfaceDelegateFactory mSurfaceDelegateFactory;
+  private @Nullable DevLoadingViewManager mDevLoadingViewManager;
   private JSEngineResolutionAlgorithm jsEngineResolutionAlgorithm = null;
 
   /* package protected */ ReactInstanceManagerBuilder() {}
@@ -216,6 +218,13 @@ public class ReactInstanceManagerBuilder {
     return this;
   }
 
+  /** Sets the Dev Loading View Manager. */
+  public ReactInstanceManagerBuilder setDevLoadingViewManager(
+      @Nullable DevLoadingViewManager devLoadingViewManager) {
+    mDevLoadingViewManager = devLoadingViewManager;
+    return this;
+  }
+
   /**
    * Sets the initial lifecycle state of the host. For example, if the host is already resumed at
    * creation time, we wouldn't expect an onResume call until we get an onPause call.
@@ -337,7 +346,8 @@ public class ReactInstanceManagerBuilder {
         mJSIModulesPackage,
         mCustomPackagerCommandHandlers,
         mTMMDelegateBuilder,
-        mSurfaceDelegateFactory);
+        mSurfaceDelegateFactory,
+        mDevLoadingViewManager);
   }
 
   private JavaScriptExecutorFactory getDefaultJSExecutorFactory(

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

@@ -18,6 +18,7 @@ import com.facebook.react.common.LifecycleState;
 import com.facebook.react.common.SurfaceDelegate;
 import com.facebook.react.common.SurfaceDelegateFactory;
 import com.facebook.react.devsupport.DevSupportManagerFactory;
+import com.facebook.react.devsupport.interfaces.DevLoadingViewManager;
 import com.facebook.react.devsupport.interfaces.RedBoxHandler;
 import java.util.List;
 
@@ -71,6 +72,7 @@ public abstract class ReactNativeHost {
             .setJSMainModulePath(getJSMainModuleName())
             .setUseDeveloperSupport(getUseDeveloperSupport())
             .setDevSupportManagerFactory(getDevSupportManagerFactory())
+            .setDevLoadingViewManager(getDevLoadingViewManager())
             .setRequireActivity(getShouldRequireActivity())
             .setSurfaceDelegateFactory(getSurfaceDelegateFactory())
             .setLazyViewManagersEnabled(getLazyViewManagersEnabled())
@@ -149,6 +151,13 @@ public abstract class ReactNativeHost {
     };
   }
 
+  /**
+   * Get the {@link DevLoadingViewManager}. Override this to use a custom dev loading view manager
+   */
+  protected @Nullable DevLoadingViewManager getDevLoadingViewManager() {
+    return null;
+  }
+
   /**
    * Returns the name of the main module. Determines the URL used to fetch the JS bundle from Metro.
    * It is only used when dev support is enabled. This is the first file to be executed once the

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

@@ -11,8 +11,11 @@ import androidx.annotation.Nullable;
 import com.facebook.infer.annotation.Assertions;
 import com.facebook.proguard.annotations.DoNotStrip;
 import com.facebook.react.bridge.CxxModuleWrapper;
+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.module.annotations.ReactModule;
 import com.facebook.react.module.model.ReactModuleInfo;
 import com.facebook.react.turbomodule.core.TurboModuleManagerDelegate;
 import com.facebook.react.turbomodule.core.interfaces.TurboModule;
@@ -20,22 +23,118 @@ import java.util.ArrayList;
 import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
+import javax.inject.Provider;
 
 public abstract class ReactPackageTurboModuleManagerDelegate extends TurboModuleManagerDelegate {
-  private final List<TurboReactPackage> mPackages = new ArrayList<>();
-  private final Map<TurboReactPackage, Map<String, ReactModuleInfo>> mPackageModuleInfos =
+  interface ModuleProvider {
+    @Nullable
+    NativeModule getModule(String moduleName);
+  }
+
+  private final List<ModuleProvider> mModuleProviders = new ArrayList<>();
+  private final Map<ModuleProvider, Map<String, ReactModuleInfo>> mPackageModuleInfos =
       new HashMap<>();
-  private final ReactApplicationContext mReactApplicationContext;
+
+  private static boolean shouldSupportLegacyPackages() {
+    return ReactFeatureFlags.enableBridgelessArchitecture
+        && ReactFeatureFlags.unstable_useTurboModuleInterop;
+  }
 
   protected ReactPackageTurboModuleManagerDelegate(
       ReactApplicationContext reactApplicationContext, List<ReactPackage> packages) {
     super();
-    mReactApplicationContext = reactApplicationContext;
+    final ReactApplicationContext applicationContext = reactApplicationContext;
     for (ReactPackage reactPackage : packages) {
       if (reactPackage instanceof TurboReactPackage) {
-        TurboReactPackage pkg = (TurboReactPackage) reactPackage;
-        mPackages.add(pkg);
-        mPackageModuleInfos.put(pkg, pkg.getReactModuleInfoProvider().getReactModuleInfos());
+        final TurboReactPackage turboPkg = (TurboReactPackage) reactPackage;
+        final ModuleProvider moduleProvider =
+            new ModuleProvider() {
+              public NativeModule getModule(String moduleName) {
+                return turboPkg.getModule(moduleName, applicationContext);
+              }
+            };
+        mModuleProviders.add(moduleProvider);
+        mPackageModuleInfos.put(
+            moduleProvider, turboPkg.getReactModuleInfoProvider().getReactModuleInfos());
+        continue;
+      }
+
+      if (shouldSupportLegacyPackages() && reactPackage instanceof LazyReactPackage) {
+        // TODO(T145105887): Output warnings that LazyReactPackage was used
+        final LazyReactPackage lazyPkg = ((LazyReactPackage) reactPackage);
+        final List<ModuleSpec> moduleSpecs = lazyPkg.getNativeModules(reactApplicationContext);
+        final Map<String, Provider<? extends NativeModule>> moduleSpecProviderMap = new HashMap<>();
+        for (final ModuleSpec moduleSpec : moduleSpecs) {
+          moduleSpecProviderMap.put(moduleSpec.getName(), moduleSpec.getProvider());
+        }
+
+        final ModuleProvider moduleProvider =
+            new ModuleProvider() {
+              public NativeModule getModule(String moduleName) {
+                Provider<? extends NativeModule> provider = moduleSpecProviderMap.get(moduleName);
+                return provider != null ? provider.get() : null;
+              }
+            };
+
+        mModuleProviders.add(moduleProvider);
+        mPackageModuleInfos.put(
+            moduleProvider, lazyPkg.getReactModuleInfoProvider().getReactModuleInfos());
+        continue;
+      }
+
+      if (shouldSupportLegacyPackages() && reactPackage instanceof ReactInstancePackage) {
+        // TODO(T145105887): Output error that ReactPackage was used
+
+        continue;
+      }
+
+      if (shouldSupportLegacyPackages()) {
+        // TODO(T145105887): Output warnings that ReactPackage was used
+
+        final List<NativeModule> nativeModules =
+            reactPackage.createNativeModules(reactApplicationContext);
+
+        final Map<String, NativeModule> moduleMap = new HashMap<>();
+        final Map<String, ReactModuleInfo> reactModuleInfoMap = new HashMap<>();
+
+        for (final NativeModule module : nativeModules) {
+          final Class<? extends NativeModule> moduleClass = module.getClass();
+          final @Nullable ReactModule reactModule = moduleClass.getAnnotation(ReactModule.class);
+
+          final String moduleName = reactModule != null ? reactModule.name() : module.getName();
+
+          final ReactModuleInfo moduleInfo =
+              reactModule != null
+                  ? new ReactModuleInfo(
+                      moduleName,
+                      moduleClass.getName(),
+                      reactModule.canOverrideExistingModule(),
+                      true,
+                      reactModule.hasConstants(),
+                      reactModule.isCxxModule(),
+                      TurboModule.class.isAssignableFrom(moduleClass))
+                  : new ReactModuleInfo(
+                      moduleName,
+                      moduleClass.getName(),
+                      module.canOverrideExistingModule(),
+                      true,
+                      true,
+                      CxxModuleWrapper.class.isAssignableFrom(moduleClass),
+                      TurboModule.class.isAssignableFrom(moduleClass));
+
+          reactModuleInfoMap.put(moduleName, moduleInfo);
+          moduleMap.put(moduleName, module);
+        }
+
+        final ModuleProvider moduleProvider =
+            new ModuleProvider() {
+              public NativeModule getModule(String moduleName) {
+                return moduleMap.get(moduleName);
+              }
+            };
+
+        mModuleProviders.add(moduleProvider);
+        mPackageModuleInfos.put(moduleProvider, reactModuleInfoMap);
       }
     }
   }
@@ -75,16 +174,16 @@ public abstract class ReactPackageTurboModuleManagerDelegate extends TurboModule
   private TurboModule resolveModule(String moduleName) {
     NativeModule resolvedModule = null;
 
-    for (final TurboReactPackage pkg : mPackages) {
+    for (final ModuleProvider moduleProvider : mModuleProviders) {
       try {
-        final ReactModuleInfo moduleInfo = mPackageModuleInfos.get(pkg).get(moduleName);
+        final ReactModuleInfo moduleInfo = mPackageModuleInfos.get(moduleProvider).get(moduleName);
         if (moduleInfo == null
             || !moduleInfo.isTurboModule()
             || resolvedModule != null && !moduleInfo.canOverrideExistingModule()) {
           continue;
         }
 
-        final NativeModule module = pkg.getModule(moduleName, mReactApplicationContext);
+        final NativeModule module = moduleProvider.getModule(moduleName);
         if (module != null) {
           resolvedModule = module;
         }
@@ -107,10 +206,8 @@ public abstract class ReactPackageTurboModuleManagerDelegate extends TurboModule
   @Override
   public List<String> getEagerInitModuleNames() {
     List<String> moduleNames = new ArrayList<>();
-    for (TurboReactPackage reactPackage : mPackages) {
-      for (ReactModuleInfo moduleInfo :
-          reactPackage.getReactModuleInfoProvider().getReactModuleInfos().values()) {
-
+    for (final ModuleProvider moduleProvider : mModuleProviders) {
+      for (final ReactModuleInfo moduleInfo : mPackageModuleInfos.get(moduleProvider).values()) {
         if (moduleInfo.isTurboModule() && moduleInfo.needsEagerInit()) {
           moduleNames.add(moduleInfo.name());
         }