react-native-tvos 0.73.7-1 → 0.74.0-0

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

@@ -9,13 +9,16 @@ package com.facebook.react;
 
 import android.app.Activity;
 import android.content.Intent;
+import android.content.res.Configuration;
 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.config.ReactFeatureFlags;
+import com.facebook.react.devsupport.DisabledDevSupportManager;
 import com.facebook.react.devsupport.DoubleTapReloadRecognizer;
+import com.facebook.react.devsupport.interfaces.DevSupportManager;
 import com.facebook.react.interfaces.fabric.ReactSurface;
 import com.facebook.react.modules.core.DefaultHardwareBackBtnHandler;
 
@@ -42,6 +45,15 @@ public class ReactDelegate {
 
   private boolean mFabricEnabled = false;
 
+  /**
+   * Do not use this constructor as it's not accounting for New Architecture at all. You should
+   * either use {@link ReactDelegate#ReactDelegate(Activity, ReactHost, String, Bundle)} if you're
+   * on bridgeless mode or {@link ReactDelegate#ReactDelegate(Activity, ReactNativeHost, String,
+   * Bundle, boolean)} and use the last parameter to toggle paper/fabric.
+   *
+   * @deprecated Use one of the other constructors instead to account for New Architecture.
+   */
+  @Deprecated
   public ReactDelegate(
       Activity activity,
       ReactNativeHost reactNativeHost,
@@ -72,12 +84,26 @@ public class ReactDelegate {
       @Nullable String appKey,
       @Nullable Bundle launchOptions,
       boolean fabricEnabled) {
+    mFabricEnabled = fabricEnabled;
     mActivity = activity;
     mMainComponentName = appKey;
     mLaunchOptions = composeLaunchOptions(launchOptions);
     mDoubleTapReloadRecognizer = new DoubleTapReloadRecognizer();
     mReactNativeHost = reactNativeHost;
-    mFabricEnabled = fabricEnabled;
+  }
+
+  @Nullable
+  private DevSupportManager getDevSupportManager() {
+    if (ReactFeatureFlags.enableBridgelessArchitecture
+        && mReactHost != null
+        && mReactHost.getDevSupportManager() != null) {
+      return mReactHost.getDevSupportManager();
+    } else if (getReactNativeHost().hasInstance()
+        && getReactNativeHost().getUseDeveloperSupport()) {
+      return getReactNativeHost().getReactInstanceManager().getDevSupportManager();
+    } else {
+      return null;
+    }
   }
 
   public void onHostResume() {
@@ -136,11 +162,23 @@ public class ReactDelegate {
     return false;
   }
 
+  public boolean onNewIntent(Intent intent) {
+    if (ReactFeatureFlags.enableBridgelessArchitecture) {
+      mReactHost.onNewIntent(intent);
+      return true;
+    } else {
+      if (getReactNativeHost().hasInstance()) {
+        getReactNativeHost().getReactInstanceManager().onNewIntent(intent);
+        return true;
+      }
+    }
+    return false;
+  }
+
   public void onActivityResult(
       int requestCode, int resultCode, Intent data, boolean shouldForwardToReactInstance) {
     if (ReactFeatureFlags.enableBridgelessArchitecture) {
-      // TODO T156475655: Implement onActivityResult for Bridgeless
-      return;
+      mReactHost.onActivityResult(mActivity, requestCode, resultCode, data);
     } else {
       if (getReactNativeHost().hasInstance() && shouldForwardToReactInstance) {
         getReactNativeHost()
@@ -150,6 +188,72 @@ public class ReactDelegate {
     }
   }
 
+  public void onWindowFocusChanged(boolean hasFocus) {
+    if (ReactFeatureFlags.enableBridgelessArchitecture) {
+      mReactHost.onWindowFocusChange(hasFocus);
+    } else {
+      if (getReactNativeHost().hasInstance()) {
+        getReactNativeHost().getReactInstanceManager().onWindowFocusChange(hasFocus);
+      }
+    }
+  }
+
+  public void onConfigurationChanged(Configuration newConfig) {
+    if (ReactFeatureFlags.enableBridgelessArchitecture) {
+      mReactHost.onConfigurationChanged(Assertions.assertNotNull(mActivity));
+    } else {
+      if (getReactNativeHost().hasInstance()) {
+        getReactInstanceManager()
+            .onConfigurationChanged(Assertions.assertNotNull(mActivity), newConfig);
+      }
+    }
+  }
+
+  public boolean onKeyDown(int keyCode, KeyEvent event) {
+    if (keyCode == KeyEvent.KEYCODE_MEDIA_FAST_FORWARD
+        && ((ReactFeatureFlags.enableBridgelessArchitecture
+                && mReactHost != null
+                && mReactHost.getDevSupportManager() != null)
+            || (getReactNativeHost().hasInstance()
+                && getReactNativeHost().getUseDeveloperSupport()))) {
+      event.startTracking();
+      return true;
+    }
+    return false;
+  }
+
+  public boolean onKeyLongPress(int keyCode) {
+    if (keyCode == KeyEvent.KEYCODE_MEDIA_FAST_FORWARD) {
+      if (ReactFeatureFlags.enableBridgelessArchitecture
+          && mReactHost != null
+          && mReactHost.getDevSupportManager() != null) {
+        mReactHost.getDevSupportManager().showDevOptionsDialog();
+        return true;
+      } else {
+        if (getReactNativeHost().hasInstance() && getReactNativeHost().getUseDeveloperSupport()) {
+          getReactNativeHost().getReactInstanceManager().showDevOptionsDialog();
+          return true;
+        }
+      }
+    }
+    return false;
+  }
+
+  public void reload() {
+    DevSupportManager devSupportManager = getDevSupportManager();
+    if (devSupportManager != null) {
+      // With Bridgeless enabled, reload in RELEASE mode
+      if (devSupportManager instanceof DisabledDevSupportManager
+          && ReactFeatureFlags.enableBridgelessArchitecture
+          && mReactHost != null) {
+        // Do not reload the bundle from JS as there is no bundler running in release mode.
+        mReactHost.reload("ReactDelegate.reload()");
+      } else {
+        devSupportManager.handleReloadJS();
+      }
+    }
+  }
+
   public void loadApp() {
     loadApp(mMainComponentName);
   }
@@ -196,22 +300,21 @@ public class ReactDelegate {
    *     application.
    */
   public boolean shouldShowDevMenuOrReload(int keyCode, KeyEvent event) {
-    if (ReactFeatureFlags.enableBridgelessArchitecture) {
-      // TODO T156475655: Implement shouldShowDevMenuOrReload for Bridgeless
+    DevSupportManager devSupportManager = getDevSupportManager();
+    if (devSupportManager == null) {
       return false;
-    } else if (getReactNativeHost().hasInstance()
-        && getReactNativeHost().getUseDeveloperSupport()) {
-      if (keyCode == KeyEvent.KEYCODE_MENU) {
-        getReactNativeHost().getReactInstanceManager().showDevOptionsDialog();
-        return true;
-      }
-      boolean didDoubleTapR =
-          Assertions.assertNotNull(mDoubleTapReloadRecognizer)
-              .didDoubleTapR(keyCode, mActivity.getCurrentFocus());
-      if (didDoubleTapR) {
-        getReactNativeHost().getReactInstanceManager().getDevSupportManager().handleReloadJS();
-        return true;
-      }
+    }
+
+    if (keyCode == KeyEvent.KEYCODE_MENU) {
+      devSupportManager.showDevOptionsDialog();
+      return true;
+    }
+    boolean didDoubleTapR =
+        Assertions.assertNotNull(mDoubleTapReloadRecognizer)
+            .didDoubleTapR(keyCode, mActivity.getCurrentFocus());
+    if (didDoubleTapR) {
+      devSupportManager.handleReloadJS();
+      return true;
     }
     return false;
   }
@@ -240,7 +343,6 @@ public class ReactDelegate {
       if (composedLaunchOptions == null) {
         composedLaunchOptions = new Bundle();
       }
-      composedLaunchOptions.putBoolean("concurrentRoot", true);
     }
     return composedLaunchOptions;
   }

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

@@ -7,10 +7,8 @@
 
 package com.facebook.react;
 
-import android.annotation.TargetApi;
 import android.app.Activity;
 import android.content.Intent;
-import android.os.Build;
 import android.os.Bundle;
 import android.view.KeyEvent;
 import android.view.LayoutInflater;
@@ -32,7 +30,7 @@ public class ReactFragment extends Fragment implements PermissionAwareActivity {
   protected static final String ARG_LAUNCH_OPTIONS = "arg_launch_options";
   protected static final String ARG_FABRIC_ENABLED = "arg_fabric_enabled";
 
-  private ReactDelegate mReactDelegate;
+  protected ReactDelegate mReactDelegate;
 
   @Nullable private PermissionListener mPermissionListener;
 
@@ -161,13 +159,11 @@ public class ReactFragment extends Fragment implements PermissionAwareActivity {
     return getActivity().checkPermission(permission, pid, uid);
   }
 
-  @TargetApi(Build.VERSION_CODES.M)
   @Override
   public int checkSelfPermission(String permission) {
     return getActivity().checkSelfPermission(permission);
   }
 
-  @TargetApi(Build.VERSION_CODES.M)
   @Override
   public void requestPermissions(
       String[] permissions, int requestCode, PermissionListener listener) {
@@ -185,7 +181,7 @@ public class ReactFragment extends Fragment implements PermissionAwareActivity {
     public Builder() {
       mComponentName = null;
       mLaunchOptions = null;
-      mFabricEnabled = null;
+      mFabricEnabled = false;
     }
 
     /**

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

@@ -9,6 +9,7 @@ package com.facebook.react
 
 import android.app.Activity
 import android.content.Context
+import android.content.Intent
 import android.os.Bundle
 import com.facebook.react.bridge.ReactContext
 import com.facebook.react.bridge.queue.ReactQueueConfiguration
@@ -25,49 +26,59 @@ import com.facebook.react.modules.core.DefaultHardwareBackBtnHandler
  *
  * The implementation of this interface should be Thread Safe
  */
-interface ReactHost {
+public interface ReactHost {
 
   /** The current [LifecycleState] for React Host */
-  val lifecycleState: LifecycleState
+  public val lifecycleState: LifecycleState
 
   /**
    * The current [ReactContext] associated with ReactInstance. It could be nullable if ReactInstance
    * hasn't been created.
    */
-  val currentReactContext: ReactContext?
+  public val currentReactContext: ReactContext?
 
   // TODO: review if DevSupportManager should be nullable
   /** [DevSupportManager] used by this ReactHost */
-  val devSupportManager: DevSupportManager?
+  public val devSupportManager: DevSupportManager?
 
   // TODO: review if possible to remove ReactQueueConfiguration
   /** [ReactQueueConfiguration] for caller to post jobs in React Native threads */
-  val reactQueueConfiguration: ReactQueueConfiguration?
+  public val reactQueueConfiguration: ReactQueueConfiguration?
+
+  /** [JSEngineResolutionAlgorithm] used by this host. */
+  public var jsEngineResolutionAlgorithm: JSEngineResolutionAlgorithm?
 
   /** To be called when back button is pressed */
-  fun onBackPressed(): Boolean
+  public fun onBackPressed(): Boolean
 
   // TODO: review why activity is nullable in all of the lifecycle methods
   /** To be called when the host activity is resumed. */
-  fun onHostResume(activity: Activity?, defaultBackButtonImpl: DefaultHardwareBackBtnHandler?)
+  public fun onHostResume(
+      activity: Activity?,
+      defaultBackButtonImpl: DefaultHardwareBackBtnHandler?
+  )
 
   /** To be called when the host activity is resumed. */
-  fun onHostResume(activity: Activity?)
+  public fun onHostResume(activity: Activity?)
 
   /** To be called when the host activity is paused. */
-  fun onHostPause(activity: Activity?)
+  public fun onHostPause(activity: Activity?)
 
   /** To be called when the host activity is paused. */
-  fun onHostPause()
+  public fun onHostPause()
 
   /** To be called when the host activity is destroyed. */
-  fun onHostDestroy()
+  public fun onHostDestroy()
 
   /** To be called when the host activity is destroyed. */
-  fun onHostDestroy(activity: Activity?)
+  public fun onHostDestroy(activity: Activity?)
 
   /** To be called to create and setup an ReactSurface. */
-  fun createSurface(context: Context, moduleName: String, initialProps: Bundle?): ReactSurface?
+  public fun createSurface(
+      context: Context,
+      moduleName: String,
+      initialProps: Bundle?
+  ): ReactSurface?
 
   /**
    * This function can be used to initialize the ReactInstance in a background thread before a
@@ -78,7 +89,7 @@ interface ReactHost {
    *   errors occur during initialization, and will be cancelled if ReactHost.destroy() is called
    *   before it completes.
    */
-  fun start(): TaskInterface<Void>
+  public fun start(): TaskInterface<Void>
 
   /**
    * Entrypoint to reload the ReactInstance. If the ReactInstance is destroying, will wait until
@@ -88,7 +99,7 @@ interface ReactHost {
    *   button)
    * @return A task that completes when React Native reloads
    */
-  fun reload(reason: String): TaskInterface<Void>
+  public fun reload(reason: String): TaskInterface<Void>
 
   /**
    * Entrypoint to destroy the ReactInstance. If the ReactInstance is reloading, will wait until
@@ -99,9 +110,25 @@ interface ReactHost {
    *   be used to log properly the cause of destroy operation.
    * @return A task that completes when React Native gets destroyed.
    */
-  fun destroy(reason: String, ex: Exception?): TaskInterface<Void>
+  public fun destroy(reason: String, ex: Exception?): TaskInterface<Void>
+
+  /* To be called when the host activity receives an activity result. */
+  public fun onActivityResult(
+      activity: Activity,
+      requestCode: Int,
+      resultCode: Int,
+      data: Intent?,
+  )
+
+  /* To be called when focus has changed for the hosting window. */
+  public fun onWindowFocusChange(hasFocus: Boolean)
+
+  /* This method will give JS the opportunity to receive intents via Linking. */
+  public fun onNewIntent(intent: Intent)
+
+  public fun onConfigurationChanged(context: Context)
 
-  fun addBeforeDestroyListener(onBeforeDestroy: () -> Unit)
+  public fun addBeforeDestroyListener(onBeforeDestroy: () -> Unit)
 
-  fun removeBeforeDestroyListener(onBeforeDestroy: () -> Unit)
+  public fun removeBeforeDestroyListener(onBeforeDestroy: () -> Unit)
 }

package/ReactAndroid/src/main/java/com/facebook/react/{ReactInstanceEventListener.java → ReactInstanceEventListener.kt}

@@ -5,19 +5,15 @@
  * LICENSE file in the root directory of this source tree.
  */
 
-package com.facebook.react;
+package com.facebook.react
 
-import com.facebook.react.bridge.ReactContext;
+import com.facebook.react.bridge.ReactContext
 
-/**
- * New Listener interface for react instance events. {@Link
- * ReactInstanceManager.ReactInstanceEventListener will be deprecated.}
- */
+/** Interface to subscribe for react instance events */
 public interface ReactInstanceEventListener {
-
   /**
    * Called when the react context is initialized (all modules registered). Always called on the UI
    * thread.
    */
-  void onReactContextInitialized(ReactContext context);
+  public fun onReactContextInitialized(context: ReactContext)
 }

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

@@ -55,8 +55,6 @@ import com.facebook.react.bridge.CatalystInstance;
 import com.facebook.react.bridge.CatalystInstanceImpl;
 import com.facebook.react.bridge.JSBundleLoader;
 import com.facebook.react.bridge.JSExceptionHandler;
-import com.facebook.react.bridge.JSIModulePackage;
-import com.facebook.react.bridge.JSIModuleType;
 import com.facebook.react.bridge.JavaJSExecutor;
 import com.facebook.react.bridge.JavaScriptExecutor;
 import com.facebook.react.bridge.JavaScriptExecutorFactory;
@@ -71,12 +69,14 @@ import com.facebook.react.bridge.ReactMarkerConstants;
 import com.facebook.react.bridge.ReactNoCrashSoftException;
 import com.facebook.react.bridge.ReactSoftExceptionLogger;
 import com.facebook.react.bridge.UIManager;
+import com.facebook.react.bridge.UIManagerProvider;
 import com.facebook.react.bridge.UiThreadUtil;
 import com.facebook.react.bridge.WritableNativeMap;
 import com.facebook.react.bridge.queue.ReactQueueConfigurationSpec;
 import com.facebook.react.common.LifecycleState;
 import com.facebook.react.common.ReactConstants;
 import com.facebook.react.common.SurfaceDelegateFactory;
+import com.facebook.react.common.annotations.StableReactNativeAPI;
 import com.facebook.react.common.annotations.VisibleForTesting;
 import com.facebook.react.config.ReactFeatureFlags;
 import com.facebook.react.devsupport.DevSupportManagerFactory;
@@ -86,6 +86,10 @@ 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;
+import com.facebook.react.internal.AndroidChoreographerProvider;
+import com.facebook.react.internal.ChoreographerProvider;
+import com.facebook.react.internal.turbomodule.core.TurboModuleManager;
+import com.facebook.react.internal.turbomodule.core.TurboModuleManagerDelegate;
 import com.facebook.react.modules.appearance.AppearanceModule;
 import com.facebook.react.modules.appregistry.AppRegistry;
 import com.facebook.react.modules.core.DefaultHardwareBackBtnHandler;
@@ -93,12 +97,9 @@ 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.packagerconnection.RequestHandler;
-import com.facebook.react.surface.ReactStage;
-import com.facebook.react.turbomodule.core.TurboModuleManager;
-import com.facebook.react.turbomodule.core.TurboModuleManagerDelegate;
-import com.facebook.react.turbomodule.core.interfaces.TurboModuleRegistry;
 import com.facebook.react.uimanager.DisplayMetricsHolder;
 import com.facebook.react.uimanager.ReactRoot;
+import com.facebook.react.uimanager.ReactStage;
 import com.facebook.react.uimanager.UIManagerHelper;
 import com.facebook.react.uimanager.ViewManager;
 import com.facebook.react.uimanager.common.UIManagerType;
@@ -133,6 +134,7 @@ import java.util.Set;
  * <p>To instantiate an instance of this class use {@link #builder}.
  */
 @ThreadSafe
+@StableReactNativeAPI
 public class ReactInstanceManager {
 
   private static final String TAG = ReactInstanceManager.class.getSimpleName();
@@ -182,7 +184,7 @@ public class ReactInstanceManager {
   private volatile Boolean mHasStartedDestroying = false;
   private final MemoryPressureRouter mMemoryPressureRouter;
   private final @Nullable JSExceptionHandler mJSExceptionHandler;
-  private final @Nullable JSIModulePackage mJSIModulePackage;
+  private final @Nullable UIManagerProvider mUIManagerProvider;
   private final @Nullable ReactPackageTurboModuleManagerDelegate.Builder mTMMDelegateBuilder;
   private List<ViewManager> mViewManagers;
   private boolean mUseFallbackBundle = true;
@@ -230,11 +232,12 @@ public class ReactInstanceManager {
       @Nullable DevBundleDownloadListener devBundleDownloadListener,
       int minNumShakes,
       int minTimeLeftInFrameForNonBatchedOperationMs,
-      @Nullable JSIModulePackage jsiModulePackage,
+      @Nullable UIManagerProvider uIManagerProvider,
       @Nullable Map<String, RequestHandler> customPackagerCommandHandlers,
       @Nullable ReactPackageTurboModuleManagerDelegate.Builder tmmDelegateBuilder,
       @Nullable SurfaceDelegateFactory surfaceDelegateFactory,
-      @Nullable DevLoadingViewManager devLoadingViewManager) {
+      @Nullable DevLoadingViewManager devLoadingViewManager,
+      @Nullable ChoreographerProvider choreographerProvider) {
     FLog.d(TAG, "ReactInstanceManager.ctor()");
     initializeSoLoaderIfNecessary(applicationContext);
 
@@ -276,7 +279,12 @@ public class ReactInstanceManager {
       mPackages.add(
           new CoreModulesPackage(
               this,
-              this::invokeDefaultOnBackPressed,
+              new DefaultHardwareBackBtnHandler() {
+                @Override
+                public void invokeDefaultOnBackPressed() {
+                  ReactInstanceManager.this.invokeDefaultOnBackPressed();
+                }
+              },
               lazyViewManagersEnabled,
               minTimeLeftInFrameForNonBatchedOperationMs));
       if (mUseDeveloperSupport) {
@@ -284,10 +292,13 @@ public class ReactInstanceManager {
       }
       mPackages.addAll(packages);
     }
-    mJSIModulePackage = jsiModulePackage;
+    mUIManagerProvider = uIManagerProvider;
 
     // Instantiate ReactChoreographer in UI thread.
-    ReactChoreographer.initialize();
+    ReactChoreographer.initialize(
+        choreographerProvider != null
+            ? choreographerProvider
+            : AndroidChoreographerProvider.getInstance());
     if (mUseDeveloperSupport) {
       mDevSupportManager.startInspector();
     }
@@ -327,8 +338,9 @@ public class ReactInstanceManager {
         Activity currentActivity = getCurrentActivity();
         if (currentActivity != null) {
           ReactRootView rootView = new ReactRootView(currentActivity);
-          rootView.setIsFabric(ReactFeatureFlags.enableFabricRenderer);
-          rootView.startReactApplication(ReactInstanceManager.this, appKey, null);
+          boolean isFabric = ReactFeatureFlags.enableFabricRenderer;
+          rootView.setIsFabric(isFabric);
+          rootView.startReactApplication(ReactInstanceManager.this, appKey, new Bundle());
           return rootView;
         }
 
@@ -368,7 +380,7 @@ public class ReactInstanceManager {
     mDevSupportManager.handleException(e);
   }
 
-  public void registerCxxErrorHandlerFunc() {
+  private void registerCxxErrorHandlerFunc() {
     Class[] parameterTypes = new Class[1];
     parameterTypes[0] = Exception.class;
     Method handleCxxErrorFunc = null;
@@ -380,6 +392,10 @@ public class ReactInstanceManager {
     ReactCxxErrorHandler.setHandleErrorFunc(this, handleCxxErrorFunc);
   }
 
+  private void unregisterCxxErrorHandlerFunc() {
+    ReactCxxErrorHandler.setHandleErrorFunc(null, null);
+  }
+
   static void initializeSoLoaderIfNecessary(Context applicationContext) {
     // Call SoLoader.initialize here, this is required for apps that does not use exopackage and
     // does not use SoLoader for loading other native code except from the one used by React Native
@@ -728,23 +744,22 @@ public class ReactInstanceManager {
     }
 
     moveToBeforeCreateLifecycleState();
-
-    if (mCreateReactContextThread != null) {
-      mCreateReactContextThread = null;
-    }
-
     mMemoryPressureRouter.destroy(mApplicationContext);
+    unregisterCxxErrorHandlerFunc();
 
+    mCreateReactContextThread = null;
     synchronized (mReactContextLock) {
       if (mCurrentReactContext != null) {
         mCurrentReactContext.destroy();
         mCurrentReactContext = null;
       }
     }
+
     mHasStartedCreatingInitialContext = false;
     mCurrentActivity = null;
 
     ResourceDrawableIdHelper.getInstance().clear();
+
     mHasStartedDestroying = false;
     synchronized (mHasStartedDestroying) {
       mHasStartedDestroying.notifyAll();
@@ -983,6 +998,11 @@ public class ReactInstanceManager {
               if (names != null) {
                 uniqueNames.addAll(names);
               }
+            } else {
+              FLog.w(
+                  ReactConstants.TAG,
+                  "Package %s is not a ViewManagerOnDemandReactPackage, view managers will not be loaded",
+                  reactPackage.getClass().getSimpleName());
             }
             Systrace.endSection(TRACE_TAG_REACT_JAVA_BRIDGE);
           }
@@ -1237,8 +1257,7 @@ public class ReactInstanceManager {
               reactRoot.getRootViewGroup(),
               initialProperties == null
                   ? new WritableNativeMap()
-                  : Arguments.fromBundle(initialProperties),
-              reactRoot.getInitialUITemplate());
+                  : Arguments.fromBundle(initialProperties));
       reactRoot.setRootViewTag(rootTag);
       reactRoot.runApplication();
     }
@@ -1328,7 +1347,7 @@ public class ReactInstanceManager {
         mJSExceptionHandler != null ? mJSExceptionHandler : mDevSupportManager;
     reactContext.setJSExceptionHandler(exceptionHandler);
 
-    NativeModuleRegistry nativeModuleRegistry = processPackages(reactContext, mPackages, false);
+    NativeModuleRegistry nativeModuleRegistry = processPackages(reactContext, mPackages);
 
     CatalystInstanceImpl.Builder catalystInstanceBuilder =
         new CatalystInstanceImpl.Builder()
@@ -1351,14 +1370,12 @@ public class ReactInstanceManager {
 
     reactContext.initializeWithInstance(catalystInstance);
 
-    if (ReactFeatureFlags.unstable_useRuntimeSchedulerAlways) {
-      // On Old Architecture, we need to initialize the Native Runtime Scheduler so that
-      // the `nativeRuntimeScheduler` object is registered on JS.
-      // On New Architecture, this is normally triggered by instantiate a TurboModuleManager.
-      // Here we invoke getRuntimeScheduler() to trigger the creation of it regardless of the
-      // architecture so it will always be there.
-      catalystInstance.getRuntimeScheduler();
-    }
+    // On Old Architecture, we need to initialize the Native Runtime Scheduler so that
+    // the `nativeRuntimeScheduler` object is registered on JS.
+    // On New Architecture, this is normally triggered by instantiate a TurboModuleManager.
+    // Here we invoke getRuntimeScheduler() to trigger the creation of it regardless of the
+    // architecture so it will always be there.
+    catalystInstance.getRuntimeScheduler();
 
     if (ReactFeatureFlags.useTurboModules && mTMMDelegateBuilder != null) {
       TurboModuleManagerDelegate tmmDelegate =
@@ -1374,23 +1391,23 @@ public class ReactInstanceManager {
               catalystInstance.getJSCallInvokerHolder(),
               catalystInstance.getNativeMethodCallInvokerHolder());
 
-      catalystInstance.setTurboModuleManager(turboModuleManager);
-
-      TurboModuleRegistry registry = (TurboModuleRegistry) turboModuleManager;
+      catalystInstance.setTurboModuleRegistry(turboModuleManager);
 
       // Eagerly initialize TurboModules
-      for (String moduleName : registry.getEagerInitModuleNames()) {
-        registry.getModule(moduleName);
+      for (String moduleName : turboModuleManager.getEagerInitModuleNames()) {
+        turboModuleManager.getModule(moduleName);
       }
     }
 
-    if (mJSIModulePackage != null) {
-      catalystInstance.addJSIModules(
-          mJSIModulePackage.getJSIModules(
-              reactContext, catalystInstance.getJavaScriptContextHolder()));
-    }
-    if (ReactFeatureFlags.enableFabricRenderer) {
-      catalystInstance.getJSIModule(JSIModuleType.UIManager);
+    if (mUIManagerProvider != null) {
+      UIManager uiManager = mUIManagerProvider.createUIManager(reactContext);
+      if (uiManager != null) {
+        catalystInstance.setFabricUIManager(uiManager);
+
+        // Initialize the UIManager
+        uiManager.initialize();
+        catalystInstance.setFabricUIManager(uiManager);
+      }
     }
     if (mBridgeIdleDebugListener != null) {
       catalystInstance.addBridgeIdleDebugListener(mBridgeIdleDebugListener);
@@ -1408,9 +1425,7 @@ public class ReactInstanceManager {
   }
 
   private NativeModuleRegistry processPackages(
-      ReactApplicationContext reactContext,
-      List<ReactPackage> packages,
-      boolean checkAndUpdatePackageMembership) {
+      ReactApplicationContext reactContext, List<ReactPackage> packages) {
     NativeModuleRegistryBuilder nativeModuleRegistryBuilder =
         new NativeModuleRegistryBuilder(reactContext, this);
 
@@ -1418,14 +1433,8 @@ public class ReactInstanceManager {
 
     synchronized (mPackages) {
       for (ReactPackage reactPackage : packages) {
-        if (checkAndUpdatePackageMembership && mPackages.contains(reactPackage)) {
-          continue;
-        }
         Systrace.beginSection(TRACE_TAG_REACT_JAVA_BRIDGE, "createAndProcessCustomReactPackage");
         try {
-          if (checkAndUpdatePackageMembership) {
-            mPackages.add(reactPackage);
-          }
           processPackage(reactPackage, nativeModuleRegistryBuilder);
         } finally {
           Systrace.endSection(TRACE_TAG_REACT_JAVA_BRIDGE);