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

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

@@ -9,18 +9,19 @@ package com.facebook.react.runtime;
 
 import android.content.res.AssetManager;
 import android.view.View;
-import androidx.annotation.NonNull;
 import com.facebook.common.logging.FLog;
 import com.facebook.infer.annotation.Nullsafe;
 import com.facebook.infer.annotation.ThreadConfined;
 import com.facebook.infer.annotation.ThreadSafe;
 import com.facebook.jni.HybridData;
 import com.facebook.proguard.annotations.DoNotStrip;
+import com.facebook.react.DebugCorePackage;
 import com.facebook.react.ReactPackage;
 import com.facebook.react.ViewManagerOnDemandReactPackage;
 import com.facebook.react.bridge.Arguments;
 import com.facebook.react.bridge.JSBundleLoader;
 import com.facebook.react.bridge.JSBundleLoaderDelegate;
+import com.facebook.react.bridge.JavaScriptContextHolder;
 import com.facebook.react.bridge.LifecycleEventListener;
 import com.facebook.react.bridge.NativeArray;
 import com.facebook.react.bridge.NativeMap;
@@ -44,20 +45,21 @@ import com.facebook.react.fabric.FabricUIManager;
 import com.facebook.react.fabric.ReactNativeConfig;
 import com.facebook.react.fabric.events.EventBeatManager;
 import com.facebook.react.interfaces.exceptionmanager.ReactJsExceptionHandler;
+import com.facebook.react.internal.AndroidChoreographerProvider;
+import com.facebook.react.internal.turbomodule.core.TurboModuleManager;
+import com.facebook.react.internal.turbomodule.core.TurboModuleManagerDelegate;
 import com.facebook.react.module.annotations.ReactModule;
 import com.facebook.react.modules.core.JavaTimerManager;
 import com.facebook.react.modules.core.ReactChoreographer;
 import com.facebook.react.turbomodule.core.CallInvokerHolderImpl;
 import com.facebook.react.turbomodule.core.NativeMethodCallInvokerHolderImpl;
-import com.facebook.react.turbomodule.core.TurboModuleManager;
-import com.facebook.react.turbomodule.core.TurboModuleManagerDelegate;
 import com.facebook.react.uimanager.ComponentNameResolver;
 import com.facebook.react.uimanager.ComponentNameResolverManager;
 import com.facebook.react.uimanager.DisplayMetricsHolder;
 import com.facebook.react.uimanager.IllegalViewOperationException;
-import com.facebook.react.uimanager.UIConstantsProvider;
 import com.facebook.react.uimanager.UIConstantsProviderManager;
 import com.facebook.react.uimanager.UIManagerModule;
+import com.facebook.react.uimanager.UIManagerModuleConstantsHelper;
 import com.facebook.react.uimanager.ViewManager;
 import com.facebook.react.uimanager.ViewManagerRegistry;
 import com.facebook.react.uimanager.ViewManagerResolver;
@@ -71,7 +73,6 @@ import java.util.HashSet;
 import java.util.List;
 import java.util.Map;
 import java.util.Set;
-import java.util.concurrent.ConcurrentHashMap;
 import javax.annotation.Nullable;
 
 /**
@@ -94,7 +95,9 @@ final class ReactInstance {
   private final TurboModuleManager mTurboModuleManager;
   private final FabricUIManager mFabricUIManager;
   private final JavaTimerManager mJavaTimerManager;
-  private final Map<String, ViewManager> mViewManagers = new ConcurrentHashMap<>();
+  private final BridgelessViewManagerResolver mViewManagerResolver;
+
+  private JavaScriptContextHolder mJavaScriptContextHolder;
 
   @DoNotStrip @Nullable private ComponentNameResolverManager mComponentNameResolverManager;
   @DoNotStrip @Nullable private UIConstantsProviderManager mUIConstantsProviderManager;
@@ -136,7 +139,7 @@ final class ReactInstance {
     MessageQueueThread nativeModulesMessageQueueThread =
         mQueueConfiguration.getNativeModulesQueueThread();
 
-    ReactChoreographer.initialize();
+    ReactChoreographer.initialize(AndroidChoreographerProvider.getInstance());
     if (useDevSupport) {
       devSupportManager.startInspector();
     }
@@ -166,14 +169,14 @@ final class ReactInstance {
           }
         });
 
-    JSEngineInstance jsEngineInstance = mDelegate.getJsEngineInstance();
+    JSRuntimeFactory jsRuntimeFactory = mDelegate.getJsRuntimeFactory();
     BindingsInstaller bindingsInstaller = mDelegate.getBindingsInstaller();
     // Notify JS if profiling is enabled
     boolean isProfiling =
         Systrace.isTracing(Systrace.TRACE_TAG_REACT_APPS | Systrace.TRACE_TAG_REACT_JS_VM_CALLS);
     mHybridData =
         initHybrid(
-            jsEngineInstance,
+            jsRuntimeFactory,
             jsMessageQueueThread,
             nativeModulesMessageQueueThread,
             mJavaTimerManager,
@@ -182,32 +185,21 @@ final class ReactInstance {
             bindingsInstaller,
             isProfiling);
 
-    RuntimeExecutor unbufferedRuntimeExecutor = getUnbufferedRuntimeExecutor();
-
-    // Initialize function for JS's UIManager.hasViewManagerConfig()
-    mComponentNameResolverManager =
-        new ComponentNameResolverManager(
-            // Use unbuffered RuntimeExecutor to install binding
-            unbufferedRuntimeExecutor,
-            (ComponentNameResolver)
-                () -> {
-                  Collection<String> viewManagerNames = getViewManagerNames();
-                  if (viewManagerNames.size() < 1) {
-                    FLog.e(TAG, "No ViewManager names found");
-                    return new String[0];
-                  }
-                  return viewManagerNames.toArray(new String[0]);
-                });
+    mJavaScriptContextHolder = new JavaScriptContextHolder(getJavaScriptContext());
 
     // Set up TurboModules
     Systrace.beginSection(
         Systrace.TRACE_TAG_REACT_JAVA_BRIDGE, "ReactInstance.initialize#initTurboModules");
 
-    mReactPackages = new ArrayList<>(mDelegate.getReactPackages());
+    mReactPackages = new ArrayList<>();
     mReactPackages.add(
         new CoreReactPackage(
             bridgelessReactContext.getDevSupportManager(),
             bridgelessReactContext.getDefaultHardwareBackBtnHandler()));
+    if (useDevSupport) {
+      mReactPackages.add(new DebugCorePackage());
+    }
+    mReactPackages.addAll(mDelegate.getReactPackages());
 
     TurboModuleManagerDelegate turboModuleManagerDelegate =
         mDelegate
@@ -216,6 +208,7 @@ final class ReactInstance {
             .setReactApplicationContext(mBridgelessReactContext)
             .build();
 
+    RuntimeExecutor unbufferedRuntimeExecutor = getUnbufferedRuntimeExecutor();
     mTurboModuleManager =
         new TurboModuleManager(
             // Use unbuffered RuntimeExecutor to install binding
@@ -231,11 +224,35 @@ final class ReactInstance {
 
     Systrace.endSection(Systrace.TRACE_TAG_REACT_JAVA_BRIDGE);
 
+    // Set up Fabric
+    Systrace.beginSection(
+        Systrace.TRACE_TAG_REACT_JAVA_BRIDGE, "ReactInstance.initialize#initFabric");
+
+    mViewManagerResolver =
+        new BridgelessViewManagerResolver(mReactPackages, mBridgelessReactContext);
+
+    // Initialize function for JS's UIManager.hasViewManagerConfig()
+    mComponentNameResolverManager =
+        new ComponentNameResolverManager(
+            // Use unbuffered RuntimeExecutor to install binding
+            unbufferedRuntimeExecutor,
+            (ComponentNameResolver)
+                () -> {
+                  Collection<String> viewManagerNames = mViewManagerResolver.getViewManagerNames();
+                  if (viewManagerNames.size() < 1) {
+                    FLog.e(TAG, "No ViewManager names found");
+                    return new String[0];
+                  }
+                  return viewManagerNames.toArray(new String[0]);
+                });
+
     // Initialize function for JS's UIManager.getViewManagerConfig()
     // It should come after getTurboModuleManagerDelegate as it relies on react packages being
     // initialized.
     // This happens inside getTurboModuleManagerDelegate getter.
     if (ReactFeatureFlags.useNativeViewConfigsInBridgelessMode) {
+      Map<String, Object> customDirectEvents = new HashMap<>();
+
       mUIConstantsProviderManager =
           new UIConstantsProviderManager(
               // Use unbuffered RuntimeExecutor to install binding
@@ -246,35 +263,46 @@ final class ReactInstance {
               // 2. genericBubblingEventTypes.
               // 3. genericDirectEventTypes.
               // We want to match this beahavior.
-              (UIConstantsProvider)
-                  () -> {
-                    return getUIManagerConstants();
-                  });
+              () -> {
+                return (NativeMap)
+                    Arguments.makeNativeMap(
+                        UIManagerModuleConstantsHelper.getDefaultExportableEventTypes());
+              },
+              (String viewManagerName) -> {
+                ViewManager viewManager = mViewManagerResolver.getViewManager(viewManagerName);
+                if (viewManager == null) {
+                  return null;
+                }
+                return (NativeMap)
+                    UIManagerModule.getConstantsForViewManager(viewManager, customDirectEvents);
+              },
+              () -> {
+                List<ViewManager> viewManagers =
+                    new ArrayList<ViewManager>(
+                        mViewManagerResolver.getEagerViewManagerMap().values());
+
+                Map<String, Object> constants =
+                    UIManagerModule.createConstants(viewManagers, null, customDirectEvents);
+
+                Collection<String> lazyViewManagers =
+                    mViewManagerResolver.getLazyViewManagerNames();
+                if (lazyViewManagers.size() > 0) {
+                  constants.put("ViewManagerNames", new ArrayList<>(lazyViewManagers));
+                  constants.put("LazyViewManagersEnabled", true);
+                }
+
+                return Arguments.makeNativeMap(constants);
+              });
     }
 
-    // Set up Fabric
-    Systrace.beginSection(
-        Systrace.TRACE_TAG_REACT_JAVA_BRIDGE, "ReactInstance.initialize#initFabric");
-
-    ViewManagerRegistry viewManagerRegistry =
-        new ViewManagerRegistry(
-            new ViewManagerResolver() {
-              @Override
-              public @Nullable ViewManager getViewManager(String viewManagerName) {
-                return createViewManager(viewManagerName);
-              }
-
-              @Override
-              public Collection<String> getViewManagerNames() {
-                return ReactInstance.this.getViewManagerNames();
-              }
-            });
-
     EventBeatManager eventBeatManager = new EventBeatManager();
     mFabricUIManager =
-        new FabricUIManager(mBridgelessReactContext, viewManagerRegistry, eventBeatManager);
+        new FabricUIManager(
+            mBridgelessReactContext,
+            new ViewManagerRegistry(mViewManagerResolver),
+            eventBeatManager);
 
-    ReactNativeConfig config = mDelegate.getReactNativeConfig(mTurboModuleManager);
+    ReactNativeConfig config = mDelegate.getReactNativeConfig();
 
     // Misc initialization that needs to be done before Fabric init
     DisplayMetricsHolder.initDisplayMetricsIfNotInitialized(mBridgelessReactContext);
@@ -411,23 +439,28 @@ final class ReactInstance {
     mFabricUIManager.stopSurface(surface.getSurfaceHandler());
   }
 
+  /* package */ JavaScriptContextHolder getJavaScriptContextHolder() {
+    return mJavaScriptContextHolder;
+  }
+
   /* --- Lifecycle methods --- */
   @ThreadConfined("ReactHost")
   /* package */ void destroy() {
     FLog.d(TAG, "ReactInstance.destroy() is called.");
     mQueueConfiguration.destroy();
-    mTurboModuleManager.onCatalystInstanceDestroy();
-    mFabricUIManager.onCatalystInstanceDestroy();
+    mTurboModuleManager.invalidate();
+    mFabricUIManager.invalidate();
     mHybridData.resetNative();
     mComponentNameResolverManager = null;
     mUIConstantsProviderManager = null;
+    mJavaScriptContextHolder.clear();
   }
 
   /* --- Native methods --- */
 
   @DoNotStrip
   private native HybridData initHybrid(
-      JSEngineInstance jsEngineInstance,
+      JSRuntimeFactory jsRuntimeFactory,
       MessageQueueThread jsMessageQueueThread,
       MessageQueueThread nativeModulesMessageQueueThread,
       JavaTimerManager timerManager,
@@ -446,16 +479,18 @@ final class ReactInstance {
 
   private native void loadJSBundleFromAssets(AssetManager assetManager, String assetURL);
 
-  private native CallInvokerHolderImpl getJSCallInvokerHolder();
+  /* package */ native CallInvokerHolderImpl getJSCallInvokerHolder();
 
   private native NativeMethodCallInvokerHolderImpl getNativeMethodCallInvokerHolder();
 
   private native RuntimeExecutor getUnbufferedRuntimeExecutor();
 
-  private native RuntimeExecutor getBufferedRuntimeExecutor();
+  /* package */ native RuntimeExecutor getBufferedRuntimeExecutor();
 
   private native RuntimeScheduler getRuntimeScheduler();
 
+  private native long getJavaScriptContext();
+
   /* package */ native void callFunctionOnModule(
       String moduleName, String methodName, NativeArray args);
 
@@ -490,92 +525,97 @@ final class ReactInstance {
     registerSegmentNative(segmentId, path);
   }
 
-  private @Nullable ViewManager createViewManager(String viewManagerName) {
-    // Return cached view manager if available, no matter it's eagerly or lazily loaded
-    if (mViewManagers.containsKey(viewManagerName)) {
-      return mViewManagers.get(viewManagerName);
+  private static class BridgelessViewManagerResolver implements ViewManagerResolver {
+    private List<ReactPackage> mReactPackages;
+    private BridgelessReactContext mBridgelessReactContext;
+    private Map<String, ViewManager> mLazyViewManagerMap = new HashMap<>();
+    private @Nullable Map<String, ViewManager> mEagerViewManagerMap = null;
+
+    public BridgelessViewManagerResolver(
+        List<ReactPackage> reactPackages, BridgelessReactContext context) {
+      mReactPackages = reactPackages;
+      mBridgelessReactContext = context;
     }
-    List<ReactPackage> packages = mReactPackages;
-    if (mDelegate != null) {
-      if (packages != null) {
-        synchronized (packages) {
-          for (ReactPackage reactPackage : packages) {
-            if (reactPackage instanceof ViewManagerOnDemandReactPackage) {
-              ViewManager viewManager =
-                  ((ViewManagerOnDemandReactPackage) reactPackage)
-                      .createViewManager(mBridgelessReactContext, viewManagerName);
-              if (viewManager != null) {
-                mViewManagers.put(viewManagerName, viewManager);
-                return viewManager;
-              }
-            }
-          }
-        }
+
+    @Override
+    public synchronized @Nullable ViewManager getViewManager(String viewManagerName) {
+      ViewManager viewManager = getLazyViewManager(viewManagerName);
+      if (viewManager != null) {
+        return viewManager;
       }
+
+      // Once a view manager is not found in all react packages via lazy loading, fall back to
+      // default implementation: eagerly initialize all view managers
+      return getEagerViewManagerMap().get(viewManagerName);
     }
 
-    // Once a view manager is not found in all react packages via lazy loading, fall back to default
-    // implementation: eagerly initialize all view managers
-    for (ReactPackage reactPackage : packages) {
-      List<ViewManager> viewManagersInPackage =
-          reactPackage.createViewManagers(mBridgelessReactContext);
-      for (ViewManager viewManager : viewManagersInPackage) {
-        mViewManagers.put(viewManager.getName(), viewManager);
-      }
+    @Override
+    public synchronized Collection<String> getViewManagerNames() {
+      Set<String> allViewManagerNames = new HashSet<>();
+      allViewManagerNames.addAll(getLazyViewManagerNames());
+      allViewManagerNames.addAll(getEagerViewManagerMap().keySet());
+      return allViewManagerNames;
     }
 
-    return mViewManagers.get(viewManagerName);
-  }
+    public synchronized Map<String, ViewManager> getEagerViewManagerMap() {
+      if (mEagerViewManagerMap != null) {
+        return mEagerViewManagerMap;
+      }
 
-  private @NonNull Collection<String> getViewManagerNames() {
-    Set<String> uniqueNames = new HashSet<>();
-    if (mDelegate != null) {
-      List<ReactPackage> packages = mReactPackages;
-      if (packages != null) {
-        synchronized (packages) {
-          for (ReactPackage reactPackage : packages) {
-            if (reactPackage instanceof ViewManagerOnDemandReactPackage) {
-              Collection<String> names =
-                  ((ViewManagerOnDemandReactPackage) reactPackage)
-                      .getViewManagerNames(mBridgelessReactContext);
-              if (names != null) {
-                uniqueNames.addAll(names);
-              }
-            }
-          }
+      Map<String, ViewManager> viewManagerMap = new HashMap<>();
+      for (ReactPackage reactPackage : mReactPackages) {
+        if (reactPackage instanceof ViewManagerOnDemandReactPackage) {
+          continue;
+        }
+
+        List<ViewManager> viewManagersInPackage =
+            reactPackage.createViewManagers(mBridgelessReactContext);
+        for (ViewManager viewManager : viewManagersInPackage) {
+          // TODO(T173624687): Should we throw/warn when the same view manager name is registered
+          // twice?
+          viewManagerMap.put(viewManager.getName(), viewManager);
         }
       }
+
+      mEagerViewManagerMap = viewManagerMap;
+      return mEagerViewManagerMap;
     }
-    return uniqueNames;
-  }
 
-  private @NonNull NativeMap getUIManagerConstants() {
-    List<ViewManager> viewManagers = new ArrayList<ViewManager>();
-    boolean canLoadViewManagersLazily = true;
+    private @Nullable ViewManager getLazyViewManager(String viewManagerName) {
+      if (mLazyViewManagerMap.containsKey(viewManagerName)) {
+        return mLazyViewManagerMap.get(viewManagerName);
+      }
 
-    List<ReactPackage> packages = mReactPackages;
-    for (ReactPackage reactPackage : packages) {
-      if (!(reactPackage instanceof ViewManagerOnDemandReactPackage)) {
-        canLoadViewManagersLazily = false;
-        break;
+      for (ReactPackage reactPackage : mReactPackages) {
+        if (reactPackage instanceof ViewManagerOnDemandReactPackage) {
+          ViewManager viewManager =
+              ((ViewManagerOnDemandReactPackage) reactPackage)
+                  .createViewManager(mBridgelessReactContext, viewManagerName);
+          if (viewManager != null) {
+            // TODO(T173624687): Should we throw/warn when the same view manager name is registered
+            // twice?
+            mLazyViewManagerMap.put(viewManagerName, viewManager);
+            return viewManager;
+          }
+        }
       }
+
+      return null;
     }
-    // 1, Retrive view managers via on demand loading
-    if (canLoadViewManagersLazily) {
-      for (String viewManagerName : getViewManagerNames()) {
-        viewManagers.add(createViewManager(viewManagerName));
-      }
-    } else {
-      // 2, There are packages that don't implement ViewManagerOnDemandReactPackage so we retrieve
-      // view managers via eager loading
-      for (ReactPackage reactPackage : packages) {
-        List<ViewManager> viewManagersInPackage =
-            reactPackage.createViewManagers(mBridgelessReactContext);
-        viewManagers.addAll(viewManagersInPackage);
+
+    public synchronized Collection<String> getLazyViewManagerNames() {
+      Set<String> uniqueNames = new HashSet<>();
+      for (ReactPackage reactPackage : mReactPackages) {
+        if (reactPackage instanceof ViewManagerOnDemandReactPackage) {
+          Collection<String> names =
+              ((ViewManagerOnDemandReactPackage) reactPackage)
+                  .getViewManagerNames(mBridgelessReactContext);
+          if (names != null) {
+            uniqueNames.addAll(names);
+          }
+        }
       }
+      return uniqueNames;
     }
-    Map<String, Object> constants =
-        UIManagerModule.createConstants(viewManagers, new HashMap<>(), new HashMap<>());
-    return Arguments.makeNativeMap(constants);
   }
 }

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

@@ -0,0 +1,31 @@
+/*
+ * 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.
+ */
+
+// TODO(170197717): Consider moving this to runtime.cxx, or just runtime
+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.soloader.SoLoader
+
+/** CxxReactPackage is used to register C++ Turbo Modules with React Native. */
+@UnstableReactNativeAPI()
+public abstract class CxxReactPackage {
+
+  @DoNotStrip @Suppress("NoHungarianNotation") private var mHybridData: HybridData?
+
+  protected constructor(hybridData: HybridData?) {
+    mHybridData = hybridData
+  }
+
+  private companion object {
+    init {
+      SoLoader.loadLibrary("react_cxxreactpackage")
+    }
+  }
+}

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

@@ -9,13 +9,17 @@ package com.facebook.react.runtime.hermes
 
 import com.facebook.jni.HybridData
 import com.facebook.jni.annotations.DoNotStrip
-import com.facebook.react.runtime.JSEngineInstance
+import com.facebook.react.fabric.ReactNativeConfig
+import com.facebook.react.runtime.JSRuntimeFactory
 import com.facebook.soloader.SoLoader
 
-class HermesInstance : JSEngineInstance(initHybrid()!!) {
+public class HermesInstance(reactNativeConfig: ReactNativeConfig?) :
+    JSRuntimeFactory(initHybrid(reactNativeConfig as Any?)) {
 
-  companion object {
-    @JvmStatic @DoNotStrip protected external fun initHybrid(): HybridData?
+  public constructor() : this(null)
+
+  public companion object {
+    @JvmStatic @DoNotStrip protected external fun initHybrid(reactNativeConfig: Any?): HybridData
 
     init {
       SoLoader.loadLibrary("hermesinstancejni")

package/ReactAndroid/src/main/java/com/facebook/react/runtime/internal/bolts/AggregateException.java

@@ -21,7 +21,7 @@ import java.util.List;
  *
  * @see Task#whenAll(java.util.Collection)
  */
-public class AggregateException extends Exception {
+class AggregateException extends Exception {
   private static final long serialVersionUID = 1L;
 
   private static final String DEFAULT_MESSAGE = "There were multiple errors.";

package/ReactAndroid/src/main/java/com/facebook/react/runtime/internal/bolts/CancellationTokenRegistration.java

@@ -16,7 +16,7 @@ import java.io.Closeable;
  *
  * @see CancellationToken#register(Runnable)
  */
-public class CancellationTokenRegistration implements Closeable {
+class CancellationTokenRegistration implements Closeable {
 
   private final Object lock = new Object();
   private @Nullable CancellationTokenSource tokenSource;

package/ReactAndroid/src/main/java/com/facebook/react/runtime/internal/bolts/Capture.java

@@ -14,7 +14,7 @@ import androidx.annotation.Nullable;
  *
  * @param <T>
  */
-public class Capture<T> {
+class Capture<T> {
   private @Nullable T value;
 
   public Capture() {}

package/ReactAndroid/src/main/java/com/facebook/react/runtime/internal/bolts/ExecutorException.java

@@ -13,7 +13,7 @@ import androidx.annotation.Nullable;
  * This is a wrapper class for emphasizing that task failed due to bad {@code Executor}, rather than
  * the continuation block it self.
  */
-public class ExecutorException extends RuntimeException {
+class ExecutorException extends RuntimeException {
 
   public ExecutorException(@Nullable Exception e) {
     super("An exception was thrown by an Executor", e);

package/ReactAndroid/src/main/java/com/facebook/react/runtime/internal/bolts/Task.java

@@ -647,7 +647,7 @@ public class Task<TResult> implements TaskInterface<TResult> {
     synchronized (lock) {
       completed = this.isCompleted();
       if (!completed) {
-        this.continuations.add(
+        continuations.add(
             new Continuation<TResult, Void>() {
               @Override
               public Void then(Task<TResult> task) {
@@ -704,7 +704,7 @@ public class Task<TResult> implements TaskInterface<TResult> {
     synchronized (lock) {
       completed = this.isCompleted();
       if (!completed) {
-        this.continuations.add(
+        continuations.add(
             new Continuation<TResult, Void>() {
               @Override
               public Void then(Task<TResult> task) {

package/ReactAndroid/src/main/java/com/facebook/react/runtime/internal/bolts/UnobservedErrorNotifier.java

@@ -24,7 +24,7 @@ class UnobservedErrorNotifier {
   @Override
   protected void finalize() throws Throwable {
     try {
-      Task faultedTask = this.task;
+      Task faultedTask = task;
       if (faultedTask != null) {
         Task.UnobservedExceptionHandler ueh = Task.getUnobservedExceptionHandler();
         if (ueh != null) {

package/ReactAndroid/src/main/java/com/facebook/react/runtime/internal/bolts/UnobservedTaskException.java

@@ -10,7 +10,7 @@ package com.facebook.react.runtime.internal.bolts;
 import androidx.annotation.Nullable;
 
 /** Used to signify that a Task's error went unobserved. */
-public class UnobservedTaskException extends RuntimeException {
+class UnobservedTaskException extends RuntimeException {
   public UnobservedTaskException(@Nullable Throwable cause) {
     super(cause);
   }

package/ReactAndroid/src/main/java/com/facebook/react/shell/MainPackageConfig.java

@@ -12,7 +12,7 @@ import com.facebook.imagepipeline.core.ImagePipelineConfig;
 /** Configuration for {@link MainReactPackage} */
 public class MainPackageConfig {
 
-  private ImagePipelineConfig mFrescoConfig;
+  private final ImagePipelineConfig mFrescoConfig;
 
   private MainPackageConfig(Builder builder) {
     mFrescoConfig = builder.mFrescoConfig;

package/ReactAndroid/src/main/java/com/facebook/react/shell/MainReactPackage.java

@@ -41,7 +41,6 @@ import com.facebook.react.modules.statusbar.StatusBarModule;
 import com.facebook.react.modules.toast.ToastModule;
 import com.facebook.react.modules.vibration.VibrationModule;
 import com.facebook.react.modules.websocket.WebSocketModule;
-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.drawer.ReactDrawerLayoutManager;
@@ -297,16 +296,18 @@ public class MainReactPackage extends TurboReactPackage implements ViewManagerOn
                   reactModule.canOverrideExistingModule(),
                   reactModule.needsEagerInit(),
                   reactModule.isCxxModule(),
-                  TurboModule.class.isAssignableFrom(moduleClass)));
+                  ReactModuleInfo.classIsTurboModule(moduleClass)));
         }
       }
       return () -> reactModuleInfoMap;
     } catch (InstantiationException e) {
       throw new RuntimeException(
-          "No ReactModuleInfoProvider for CoreModulesPackage$$ReactModuleInfoProvider", e);
+          "No ReactModuleInfoProvider for com.facebook.react.shell.MainReactPackage$$ReactModuleInfoProvider",
+          e);
     } catch (IllegalAccessException e) {
       throw new RuntimeException(
-          "No ReactModuleInfoProvider for CoreModulesPackage$$ReactModuleInfoProvider", e);
+          "No ReactModuleInfoProvider for com.facebook.react.shell.MainReactPackage$$ReactModuleInfoProvider",
+          e);
     }
   }
 }