feat: support shared JS runtime for same-origin sandbox instances (Android only)

Author: Dev Patel

packages/react-native-sandbox/android/src/main/java/io/callstack/rnsandbox/SandboxJSIInstaller.kt

@@ -44,4 +44,13 @@ object SandboxJSIInstaller {
      */
     @JvmStatic
     external fun nativeDestroy(stateHandle: Long)
+
+    /**
+     * Installs the error handler into the JS runtime. Must be called on the
+     * JS thread after the bundle has loaded (when ErrorUtils is available).
+     *
+     * @param stateHandle Handle returned by nativeInstall
+     */
+    @JvmStatic
+    external fun nativeInstallErrorHandler(stateHandle: Long)
 }

packages/react-native-sandbox/android/src/main/java/io/callstack/rnsandbox/SandboxReactNativeDelegate.kt

@@ -33,29 +33,21 @@ class SandboxReactNativeDelegate(
 ) {
     companion object {
         private const val TAG = "SandboxRNDelegate"
+
+        private val sharedHosts = mutableMapOf<String, SharedReactHost>()
+
+        private data class SharedReactHost(
+            val reactHost: ReactHostImpl,
+            val sandboxContext: Context,
+            var refCount: Int,
+        )
     }
 
-    var origin: String = ""
-        set(value) {
-            if (field == value) return
-            if (field.isNotEmpty()) {
-                SandboxRegistry.unregister(field)
-            }
-            field = value
-            if (value.isNotEmpty()) {
-                SandboxRegistry.register(value, this, allowedOrigins)
-            }
-        }
+    @JvmField var origin: String = ""
 
     var jsBundleSource: String = ""
     var allowedTurboModules: Set<String> = emptySet()
     var allowedOrigins: Set<String> = emptySet()
-        set(value) {
-            field = value
-            if (origin.isNotEmpty()) {
-                SandboxRegistry.register(origin, this, value)
-            }
-        }
 
     @JvmField var hasOnMessageHandler: Boolean = false
 
@@ -66,6 +58,7 @@ class SandboxReactNativeDelegate(
     private var reactSurface: ReactSurface? = null
     private var jsiStateHandle: Long = 0
     private var sandboxReactContext: ReactContext? = null
+    private var ownsReactHost = false
 
     @OptIn(UnstableReactNativeAPI::class)
     fun loadReactNativeView(
@@ -79,49 +72,75 @@ class SandboxReactNativeDelegate(
 
         val capturedBundleSource = jsBundleSource
         val capturedAllowedModules = allowedTurboModules
-        val sandboxId = System.identityHashCode(this).toString(16)
-        val sandboxContext = SandboxContextWrapper(context, sandboxId)
 
         try {
-            val packages: List<ReactPackage> =
-                listOf(
-                    FilteredReactPackage(MainReactPackage(), capturedAllowedModules),
-                )
-
-            val bundleLoader = createBundleLoader(capturedBundleSource) ?: return null
-
-            val tmmDelegateBuilder = DefaultTurboModuleManagerDelegate.Builder()
-
-            val bindingsInstaller = SandboxBindingsInstaller.create(this)
-
-            val hostDelegate =
-                DefaultReactHostDelegate(
-                    jsMainModulePath = capturedBundleSource,
-                    jsBundleLoader = bundleLoader,
-                    reactPackages = packages,
-                    jsRuntimeFactory = HermesInstance(),
-                    turboModuleManagerDelegateBuilder = tmmDelegateBuilder,
-                    bindingsInstaller = bindingsInstaller,
-                )
-
-            val componentFactory = ComponentFactory()
-            DefaultComponentsRegistry.register(componentFactory)
-
-            val host =
-                ReactHostImpl(
-                    sandboxContext,
-                    hostDelegate,
-                    componentFactory,
-                    true,
-                    true,
-                )
+            val shared = if (origin.isNotEmpty()) sharedHosts[origin] else null
+
+            val host: ReactHostImpl
+            val sandboxContext: Context
+
+            if (shared != null) {
+                host = shared.reactHost
+                sandboxContext = shared.sandboxContext
+                shared.refCount++
+                ownsReactHost = false
+                Log.d(TAG, "Reusing shared ReactHost for origin '$origin' (refCount=${shared.refCount})")
+            } else {
+                val sandboxId = System.identityHashCode(this).toString(16)
+                sandboxContext = SandboxContextWrapper(context, sandboxId)
+
+                val packages: List<ReactPackage> =
+                    listOf(
+                        FilteredReactPackage(MainReactPackage(), capturedAllowedModules),
+                    )
+
+                val bundleLoader = createBundleLoader(capturedBundleSource) ?: return null
+
+                val tmmDelegateBuilder = DefaultTurboModuleManagerDelegate.Builder()
+
+                val bindingsInstaller = SandboxBindingsInstaller.create(this)
+
+                val hostDelegate =
+                    DefaultReactHostDelegate(
+                        jsMainModulePath = capturedBundleSource,
+                        jsBundleLoader = bundleLoader,
+                        reactPackages = packages,
+                        jsRuntimeFactory = HermesInstance(),
+                        turboModuleManagerDelegateBuilder = tmmDelegateBuilder,
+                        bindingsInstaller = bindingsInstaller,
+                    )
+
+                val componentFactory = ComponentFactory()
+                DefaultComponentsRegistry.register(componentFactory)
+
+                host =
+                    ReactHostImpl(
+                        sandboxContext,
+                        hostDelegate,
+                        componentFactory,
+                        true,
+                        true,
+                    )
+
+                ownsReactHost = true
+
+                if (origin.isNotEmpty()) {
+                    sharedHosts[origin] = SharedReactHost(host, sandboxContext, refCount = 1)
+                    Log.d(TAG, "Created shared ReactHost for origin '$origin'")
+                }
+            }
 
             reactHost = host
 
             host.addReactInstanceEventListener(
                 object : ReactInstanceEventListener {
                     override fun onReactContextInitialized(reactContext: ReactContext) {
                         sandboxReactContext = reactContext
+                        if (jsiStateHandle != 0L) {
+                            reactContext.runOnJSQueueThread {
+                                SandboxJSIInstaller.nativeInstallErrorHandler(jsiStateHandle)
+                            }
+                        }
                     }
                 },
             )
@@ -240,7 +259,8 @@ class SandboxReactNativeDelegate(
             return false
         }
 
-        return routeMessage(messageJson, targetOrigin)
+        // Routing handled entirely in C++ SandboxRegistry (see SandboxJSIInstaller.cpp)
+        return false
     }
 
     @Suppress("unused")
@@ -261,28 +281,6 @@ class SandboxReactNativeDelegate(
         }
     }
 
-    fun routeMessage(
-        message: String,
-        targetId: String,
-    ): Boolean {
-        val target = SandboxRegistry.find(targetId)
-        Log.d(TAG, "routeMessage from '$origin' to '$targetId': target found=${target != null}")
-        if (target == null) return false
-
-        if (!SandboxRegistry.isPermittedFrom(origin, targetId)) {
-            Log.w(TAG, "routeMessage DENIED: '$origin' -> '$targetId'")
-            sandboxView?.emitOnError(
-                "AccessDeniedError",
-                "Access denied: Sandbox '$origin' is not permitted to send messages to '$targetId'",
-            )
-            return false
-        }
-
-        Log.d(TAG, "routeMessage PERMITTED: '$origin' -> '$targetId', delivering...")
-        target.postMessage(message)
-        return true
-    }
-
     private fun getActivity(): Activity? {
         var ctx = context
         while (ctx is android.content.ContextWrapper) {
@@ -305,17 +303,28 @@ class SandboxReactNativeDelegate(
         }
         reactSurface = null
 
-        reactHost?.let {
-            it.onHostDestroy()
-            it.destroy("sandbox cleanup", null)
+        val host = reactHost
+        if (host != null) {
+            if (origin.isNotEmpty()) {
+                val shared = sharedHosts[origin]
+                if (shared != null && shared.reactHost === host) {
+                    shared.refCount--
+                    if (shared.refCount <= 0) {
+                        sharedHosts.remove(origin)
+                        host.onHostDestroy()
+                        host.destroy("sandbox cleanup", null)
+                    }
+                }
+            } else if (ownsReactHost) {
+                host.onHostDestroy()
+                host.destroy("sandbox cleanup", null)
+            }
         }
         reactHost = null
+        ownsReactHost = false
     }
 
     fun destroy() {
-        if (origin.isNotEmpty()) {
-            SandboxRegistry.unregister(origin)
-        }
         cleanup()
     }