react-native-tvos 0.74.3-0 → 0.75.2-0

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

@@ -0,0 +1,57 @@
+/*
+ * 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 com.facebook.jni.HybridData
+import com.facebook.proguard.annotations.DoNotStripAny
+import com.facebook.react.bridge.UiThreadUtil
+import com.facebook.soloader.SoLoader
+import java.io.Closeable
+import java.util.concurrent.Executor
+
+@DoNotStripAny
+internal class ReactHostInspectorTarget(private val reactHostImpl: ReactHostImpl) : Closeable {
+  // fbjni looks for the exact name "mHybridData":
+  // https://github.com/facebookincubator/fbjni/blob/5587a7fd2b191656be9391a3832ce04c034009a5/cxx/fbjni/detail/Hybrid.h#L310
+  @Suppress("NoHungarianNotation")
+  private val mHybridData: HybridData = initHybrid(reactHostImpl, UIThreadConditionalSyncExecutor())
+
+  private external fun initHybrid(reactHostImpl: ReactHostImpl, executor: Executor): HybridData
+
+  public external fun sendDebuggerResumeCommand()
+
+  override fun close() {
+    mHybridData.resetNative()
+  }
+
+  fun isValid(): Boolean {
+    return mHybridData.isValid()
+  }
+
+  private companion object {
+    init {
+      SoLoader.loadLibrary("rninstance")
+    }
+  }
+
+  /**
+   * An [java.util.concurrent.Executor] that runs tasks on the UI thread (immediately if already on
+   * that thread).
+   */
+  private class UIThreadConditionalSyncExecutor : Executor {
+    override fun execute(command: Runnable) {
+      if (UiThreadUtil.isOnUiThread()) {
+        // If we're already on the main thread, execute the command immediately
+        command.run()
+      } else {
+        // Otherwise, post it on the main thread handler
+        UiThreadUtil.runOnUiThread(command)
+      }
+    }
+  }
+}

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

@@ -10,6 +10,8 @@ package com.facebook.react.runtime;
 import android.content.res.AssetManager;
 import android.view.View;
 import com.facebook.common.logging.FLog;
+import com.facebook.fbreact.specs.NativeExceptionsManagerSpec;
+import com.facebook.infer.annotation.Assertions;
 import com.facebook.infer.annotation.Nullsafe;
 import com.facebook.infer.annotation.ThreadConfined;
 import com.facebook.infer.annotation.ThreadSafe;
@@ -21,8 +23,8 @@ 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.JavaOnlyMap;
 import com.facebook.react.bridge.JavaScriptContextHolder;
-import com.facebook.react.bridge.LifecycleEventListener;
 import com.facebook.react.bridge.NativeArray;
 import com.facebook.react.bridge.NativeMap;
 import com.facebook.react.bridge.NativeModule;
@@ -36,7 +38,7 @@ import com.facebook.react.bridge.queue.QueueThreadExceptionHandler;
 import com.facebook.react.bridge.queue.ReactQueueConfiguration;
 import com.facebook.react.bridge.queue.ReactQueueConfigurationImpl;
 import com.facebook.react.bridge.queue.ReactQueueConfigurationSpec;
-import com.facebook.react.config.ReactFeatureFlags;
+import com.facebook.react.devsupport.StackTraceHelper;
 import com.facebook.react.devsupport.interfaces.DevSupportManager;
 import com.facebook.react.fabric.Binding;
 import com.facebook.react.fabric.BindingImpl;
@@ -46,6 +48,7 @@ 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.featureflags.ReactNativeFeatureFlags;
 import com.facebook.react.internal.turbomodule.core.TurboModuleManager;
 import com.facebook.react.internal.turbomodule.core.TurboModuleManagerDelegate;
 import com.facebook.react.module.annotations.ReactModule;
@@ -54,10 +57,10 @@ 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.uimanager.ComponentNameResolver;
-import com.facebook.react.uimanager.ComponentNameResolverManager;
+import com.facebook.react.uimanager.ComponentNameResolverBinding;
 import com.facebook.react.uimanager.DisplayMetricsHolder;
 import com.facebook.react.uimanager.IllegalViewOperationException;
-import com.facebook.react.uimanager.UIConstantsProviderManager;
+import com.facebook.react.uimanager.UIConstantsProviderBinding;
 import com.facebook.react.uimanager.UIManagerModule;
 import com.facebook.react.uimanager.UIManagerModuleConstantsHelper;
 import com.facebook.react.uimanager.ViewManager;
@@ -99,9 +102,6 @@ final class ReactInstance {
 
   private JavaScriptContextHolder mJavaScriptContextHolder;
 
-  @DoNotStrip @Nullable private ComponentNameResolverManager mComponentNameResolverManager;
-  @DoNotStrip @Nullable private UIConstantsProviderManager mUIConstantsProviderManager;
-
   static {
     loadLibraryIfNeeded();
   }
@@ -114,8 +114,8 @@ final class ReactInstance {
       ComponentFactory componentFactory,
       DevSupportManager devSupportManager,
       QueueThreadExceptionHandler exceptionHandler,
-      ReactJsExceptionHandler reactExceptionManager,
-      boolean useDevSupport) {
+      boolean useDevSupport,
+      @Nullable ReactHostInspectorTarget reactHostInspectorTarget) {
     mBridgelessReactContext = bridgelessReactContext;
     mDelegate = delegate;
 
@@ -143,6 +143,7 @@ final class ReactInstance {
     if (useDevSupport) {
       devSupportManager.startInspector();
     }
+
     JSTimerExecutor jsTimerExecutor = createJSTimerExecutor();
     mJavaTimerManager =
         new JavaTimerManager(
@@ -151,29 +152,12 @@ final class ReactInstance {
             ReactChoreographer.getInstance(),
             devSupportManager);
 
-    mBridgelessReactContext.addLifecycleEventListener(
-        new LifecycleEventListener() {
-          @Override
-          public void onHostResume() {
-            mJavaTimerManager.onHostResume();
-          }
-
-          @Override
-          public void onHostPause() {
-            mJavaTimerManager.onHostPause();
-          }
-
-          @Override
-          public void onHostDestroy() {
-            mJavaTimerManager.onHostDestroy();
-          }
-        });
-
     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(
             jsRuntimeFactory,
@@ -181,9 +165,10 @@ final class ReactInstance {
             nativeModulesMessageQueueThread,
             mJavaTimerManager,
             jsTimerExecutor,
-            reactExceptionManager,
+            new ReactJsExceptionHandlerImpl(nativeModulesMessageQueueThread),
             bindingsInstaller,
-            isProfiling);
+            isProfiling,
+            reactHostInspectorTarget);
 
     mJavaScriptContextHolder = new JavaScriptContextHolder(getJavaScriptContext());
 
@@ -217,11 +202,6 @@ final class ReactInstance {
             getJSCallInvokerHolder(),
             getNativeMethodCallInvokerHolder());
 
-    // Eagerly initialize TurboModules
-    for (String moduleName : mTurboModuleManager.getEagerInitModuleNames()) {
-      mTurboModuleManager.getModule(moduleName);
-    }
-
     Systrace.endSection(Systrace.TRACE_TAG_REACT_JAVA_BRIDGE);
 
     // Set up Fabric
@@ -232,67 +212,63 @@ final class ReactInstance {
         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]);
-                });
+    ComponentNameResolverBinding.install(
+        // 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) {
+    if (ReactNativeFeatureFlags.useNativeViewConfigsInBridgelessMode()) {
       Map<String, Object> customDirectEvents = new HashMap<>();
 
-      mUIConstantsProviderManager =
-          new UIConstantsProviderManager(
-              // Use unbuffered RuntimeExecutor to install binding
-              unbufferedRuntimeExecutor,
-              // Here we are construncting the return value for UIManager.getConstants call.
-              // The old architectre relied on the constatnts struct to contain:
-              // 1. Eagerly loaded view configs for all native components.
-              // 2. genericBubblingEventTypes.
-              // 3. genericDirectEventTypes.
-              // We want to match this beahavior.
-              () -> {
-                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);
-              });
+      UIConstantsProviderBinding.install(
+          // Use unbuffered RuntimeExecutor to install binding
+          unbufferedRuntimeExecutor,
+          // Here we are construncting the return value for UIManager.getConstants call.
+          // The old architectre relied on the constatnts struct to contain:
+          // 1. Eagerly loaded view configs for all native components.
+          // 2. genericBubblingEventTypes.
+          // 3. genericDirectEventTypes.
+          // We want to match this beahavior.
+          () -> {
+            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<>(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);
+          });
     }
 
     EventBeatManager eventBeatManager = new EventBeatManager();
@@ -315,10 +291,19 @@ final class ReactInstance {
         eventBeatManager,
         componentFactory,
         config);
-    Systrace.endSection(Systrace.TRACE_TAG_REACT_JAVA_BRIDGE);
 
     // Initialize the FabricUIManager
     mFabricUIManager.initialize();
+
+    Systrace.endSection(Systrace.TRACE_TAG_REACT_JAVA_BRIDGE);
+    Systrace.endSection(Systrace.TRACE_TAG_REACT_JAVA_BRIDGE);
+  }
+
+  void initializeEagerTurboModules() {
+    // Eagerly initialize TurboModules
+    for (String moduleName : mTurboModuleManager.getEagerInitModuleNames()) {
+      mTurboModuleManager.getModule(moduleName);
+    }
   }
 
   private static synchronized void loadLibraryIfNeeded() {
@@ -332,6 +317,29 @@ final class ReactInstance {
     return mQueueConfiguration;
   }
 
+  private class ReactJsExceptionHandlerImpl implements ReactJsExceptionHandler {
+    private final MessageQueueThread mNativemodulesmessagequeuethread;
+
+    ReactJsExceptionHandlerImpl(MessageQueueThread nativeModulesMessageQueueThread) {
+      this.mNativemodulesmessagequeuethread = nativeModulesMessageQueueThread;
+    }
+
+    @Override
+    public void reportJsException(ParsedError error) {
+      JavaOnlyMap data = StackTraceHelper.convertParsedError(error);
+
+      // Simulate async native module method call
+      mNativemodulesmessagequeuethread.runOnQueue(
+          () -> {
+            NativeExceptionsManagerSpec exceptionsManager =
+                (NativeExceptionsManagerSpec)
+                    Assertions.assertNotNull(
+                        mTurboModuleManager.getModule(NativeExceptionsManagerSpec.NAME));
+            exceptionsManager.reportException(data);
+          });
+    }
+  }
+
   public void loadJSBundle(JSBundleLoader bundleLoader) {
     // Load the JS bundle
     Systrace.beginSection(Systrace.TRACE_TAG_REACT_JAVA_BRIDGE, "ReactInstance.loadJSBundle");
@@ -390,6 +398,7 @@ final class ReactInstance {
     }
   }
 
+  @ThreadConfined("ReactHost")
   /* package */ void prerenderSurface(ReactSurfaceImpl surface) {
     Systrace.beginSection(Systrace.TRACE_TAG_REACT_JAVA_BRIDGE, "ReactInstance.prerenderSurface");
     FLog.d(TAG, "call prerenderSurface with surface: " + surface.getModuleName());
@@ -450,9 +459,8 @@ final class ReactInstance {
     mQueueConfiguration.destroy();
     mTurboModuleManager.invalidate();
     mFabricUIManager.invalidate();
+    mJavaTimerManager.onInstanceDestroy();
     mHybridData.resetNative();
-    mComponentNameResolverManager = null;
-    mUIConstantsProviderManager = null;
     mJavaScriptContextHolder.clear();
   }
 
@@ -467,7 +475,8 @@ final class ReactInstance {
       JSTimerExecutor jsTimerExecutor,
       ReactJsExceptionHandler jReactExceptionsManager,
       @Nullable BindingsInstaller jBindingsInstaller,
-      boolean isProfiling);
+      boolean isProfiling,
+      @Nullable ReactHostInspectorTarget reactHostInspectorTarget);
 
   @DoNotStrip
   private static native JSTimerExecutor createJSTimerExecutor();
@@ -498,6 +507,9 @@ final class ReactInstance {
 
   private native void handleMemoryPressureJs(int pressureLevel);
 
+  @ThreadConfined(ThreadConfined.UI)
+  /* package */ native void unregisterFromInspector();
+
   public void handleMemoryPressure(int level) {
     try {
       handleMemoryPressureJs(level);
@@ -505,7 +517,8 @@ final class ReactInstance {
       ReactSoftExceptionLogger.logSoftException(
           TAG,
           new ReactNoCrashSoftException(
-              "Native method handleMemoryPressureJs is called earlier than librninstance.so got ready."));
+              "Native method handleMemoryPressureJs is called earlier than librninstance.so got"
+                  + " ready."));
     }
   }
 
@@ -516,7 +529,9 @@ final class ReactInstance {
     return mFabricUIManager.getEventDispatcher();
   }
 
-  /** @return The {@link FabricUIManager} if it's been initialized. */
+  /**
+   * @return The {@link FabricUIManager} if it's been initialized.
+   */
   /* package */ FabricUIManager getUIManager() {
     return mFabricUIManager;
   }

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

@@ -0,0 +1,183 @@
+/*
+ * 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.
+ */
+
+@file:Suppress("DEPRECATION")
+
+package com.facebook.react.runtime
+
+import android.content.Context
+import android.graphics.Point
+import android.graphics.Rect
+import android.view.MotionEvent
+import android.view.View
+import com.facebook.common.logging.FLog
+import com.facebook.react.ReactRootView
+import com.facebook.react.bridge.ReactContext
+import com.facebook.react.config.ReactFeatureFlags
+import com.facebook.react.uimanager.IllegalViewOperationException
+import com.facebook.react.uimanager.JSPointerDispatcher
+import com.facebook.react.uimanager.JSTouchDispatcher
+import com.facebook.react.uimanager.common.UIManagerType
+import com.facebook.systrace.Systrace
+import java.util.Objects
+
+/** A view created by [ReactSurface] that's responsible for rendering a React component. */
+public class ReactSurfaceView(context: Context?, private val surface: ReactSurfaceImpl) :
+    ReactRootView(context) {
+  private val jsTouchDispatcher: JSTouchDispatcher = JSTouchDispatcher(this)
+  private var jsPointerDispatcher: JSPointerDispatcher? = null
+  private var wasMeasured = false
+  private var widthMeasureSpec = 0
+  private var heightMeasureSpec = 0
+
+  init {
+    if (ReactFeatureFlags.dispatchPointerEvents) {
+      jsPointerDispatcher = JSPointerDispatcher(this)
+    }
+  }
+
+  override fun onMeasure(widthMeasureSpec: Int, heightMeasureSpec: Int) {
+    Systrace.beginSection(Systrace.TRACE_TAG_REACT_JAVA_BRIDGE, "ReactSurfaceView.onMeasure")
+    var width = 0
+    var height = 0
+    val widthMode = MeasureSpec.getMode(widthMeasureSpec)
+    if (widthMode == MeasureSpec.AT_MOST || widthMode == MeasureSpec.UNSPECIFIED) {
+      for (i in 0 until childCount) {
+        val child = getChildAt(i)
+        val childSize = (child.left + child.measuredWidth + child.paddingLeft + child.paddingRight)
+        width = Math.max(width, childSize)
+      }
+    } else {
+      width = MeasureSpec.getSize(widthMeasureSpec)
+    }
+    val heightMode = MeasureSpec.getMode(heightMeasureSpec)
+    if (heightMode == MeasureSpec.AT_MOST || heightMode == MeasureSpec.UNSPECIFIED) {
+      for (i in 0 until childCount) {
+        val child = getChildAt(i)
+        val childSize = (child.top + child.measuredHeight + child.paddingTop + child.paddingBottom)
+        height = Math.max(height, childSize)
+      }
+    } else {
+      height = MeasureSpec.getSize(heightMeasureSpec)
+    }
+    setMeasuredDimension(width, height)
+    wasMeasured = true
+    this.widthMeasureSpec = widthMeasureSpec
+    this.heightMeasureSpec = heightMeasureSpec
+    val viewportOffset = viewportOffset
+    surface.updateLayoutSpecs(
+        widthMeasureSpec, heightMeasureSpec, viewportOffset.x, viewportOffset.y)
+    Systrace.endSection(Systrace.TRACE_TAG_REACT_JAVA_BRIDGE)
+  }
+
+  override fun onLayout(changed: Boolean, left: Int, top: Int, right: Int, bottom: Int) {
+    // Call updateLayoutSpecs to update locationOnScreen offsets, in case they've changed
+    if (wasMeasured && changed) {
+      val viewportOffset = viewportOffset
+      surface.updateLayoutSpecs(
+          widthMeasureSpec, heightMeasureSpec, viewportOffset.x, viewportOffset.y)
+    }
+  }
+
+  private val viewportOffset: Point
+    get() {
+      val locationOnScreen = IntArray(2)
+      getLocationOnScreen(locationOnScreen)
+
+      // we need to subtract visibleWindowCoords - to subtract possible window insets, split
+      // screen or multi window
+      val visibleWindowFrame = Rect()
+      getWindowVisibleDisplayFrame(visibleWindowFrame)
+      locationOnScreen[0] -= visibleWindowFrame.left
+      locationOnScreen[1] -= visibleWindowFrame.top
+      return Point(locationOnScreen[0], locationOnScreen[1])
+    }
+
+  override fun requestDisallowInterceptTouchEvent(disallowIntercept: Boolean) {
+    // Override in order to still receive events to onInterceptTouchEvent even when some other
+    // views disallow that, but propagate it up the tree if possible.
+    parent?.requestDisallowInterceptTouchEvent(disallowIntercept)
+  }
+
+  /**
+   * Called when a child starts a native gesture (e.g. a scroll in a ScrollView). Should be called
+   * from the child's onTouchIntercepted implementation.
+   */
+  override fun onChildStartedNativeGesture(childView: View?, ev: MotionEvent) {
+    val eventDispatcher = surface.eventDispatcher ?: return
+    jsTouchDispatcher.onChildStartedNativeGesture(ev, eventDispatcher)
+    childView?.let { jsPointerDispatcher?.onChildStartedNativeGesture(it, ev, eventDispatcher) }
+  }
+
+  override fun onChildEndedNativeGesture(childView: View, ev: MotionEvent) {
+    val eventDispatcher = surface.eventDispatcher ?: return
+    jsTouchDispatcher.onChildEndedNativeGesture(ev, eventDispatcher)
+    jsPointerDispatcher?.onChildEndedNativeGesture()
+  }
+
+  override fun handleException(t: Throwable) {
+    val reactHost = surface.reactHost
+    val errorMessage = Objects.toString(t.message, "")
+    val e: Exception = IllegalViewOperationException(errorMessage, this, t)
+    reactHost.handleHostException(e)
+  }
+
+  override fun setIsFabric(isFabric: Boolean) {
+    // This surface view is always on Fabric regardless.
+    super.setIsFabric(true)
+  }
+
+  // This surface view is always on Fabric.
+  @UIManagerType override fun getUIManagerType(): Int = UIManagerType.FABRIC
+
+  override fun getJSModuleName(): String = surface.moduleName
+
+  override fun dispatchJSTouchEvent(event: MotionEvent) {
+    val eventDispatcher = surface.eventDispatcher
+    if (eventDispatcher != null) {
+      jsTouchDispatcher.handleTouchEvent(event, eventDispatcher)
+    } else {
+      FLog.w(
+          TAG, "Unable to dispatch touch events to JS as the React instance has not been attached")
+    }
+  }
+
+  override fun dispatchJSPointerEvent(event: MotionEvent, isCapture: Boolean) {
+    if (jsPointerDispatcher == null) {
+      if (!ReactFeatureFlags.dispatchPointerEvents) {
+        return
+      }
+      FLog.w(TAG, "Unable to dispatch pointer events to JS before the dispatcher is available")
+      return
+    }
+    val eventDispatcher = surface.eventDispatcher
+    if (eventDispatcher != null) {
+      jsPointerDispatcher?.handleMotionEvent(event, eventDispatcher, isCapture)
+    } else {
+      FLog.w(
+          TAG,
+          "Unable to dispatch pointer events to JS as the React instance has not been attached")
+    }
+  }
+
+  override fun hasActiveReactContext(): Boolean =
+      surface.isAttached && surface.reactHost.currentReactContext != null
+
+  override fun hasActiveReactInstance(): Boolean =
+      surface.isAttached && surface.reactHost.isInstanceInitialized
+
+  override fun getCurrentReactContext(): ReactContext? =
+      if (surface.isAttached) {
+        surface.reactHost.currentReactContext
+      } else null
+
+  override fun isViewAttachedToReactInstance(): Boolean = surface.isAttached
+
+  private companion object {
+    private const val TAG = "ReactSurfaceView"
+  }
+}

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

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

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

@@ -0,0 +1,53 @@
+/*
+ * 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.internal.bolts;
+
+import com.facebook.infer.annotation.Nullsafe;
+import com.facebook.react.bridge.UiThreadUtil;
+import java.util.concurrent.Executor;
+
+/**
+ * This was created because the helper methods in {@link java.util.concurrent.Executors} do not work
+ * as people would normally expect.
+ *
+ * <p>Normally, you would think that a cached thread pool would create new threads when necessary,
+ * queue them when the pool is full, and kill threads when they've been inactive for a certain
+ * period of time. This is not how {@link java.util.concurrent.Executors#newCachedThreadPool()}
+ * works.
+ *
+ * <p>Instead, {@link java.util.concurrent.Executors#newCachedThreadPool()} executes all tasks on a
+ * new or cached thread immediately because corePoolSize is 0, SynchronousQueue is a queue with size
+ * 0 and maxPoolSize is Integer.MAX_VALUE. This is dangerous because it can create an unchecked
+ * amount of threads.
+ */
+@Nullsafe(Nullsafe.Mode.LOCAL)
+/* package */
+final class Executors {
+  public static final Executor UI_THREAD = new UIThreadExecutor();
+
+  public static final Executor IMMEDIATE = new ImmediateExecutor();
+
+  private static class UIThreadExecutor implements Executor {
+    @Override
+    public void execute(Runnable command) {
+      // Otherwise, post it on the main thread handler
+      UiThreadUtil.runOnUiThread(command);
+    }
+  }
+
+  /**
+   * An {@link java.util.concurrent.Executor} that schedules tasks to run asynchronously on the UI
+   * thread.
+   */
+  private static class ImmediateExecutor implements Executor {
+    @Override
+    public void execute(Runnable command) {
+      command.run();
+    }
+  }
+}