feat: let native modules register ActivityResultContracts via ReactContext

Adds com.facebook.react.activityresult with a ReactActivityResultCaller
that registers AndroidX ActivityResultContracts against the host
Activity's own ActivityResultRegistry (ReactActivity already extends
ComponentActivity, so it is an ActivityResultRegistryOwner). No changes
to consumers' MainActivity, no manifest entries, no forked registry.

- Registration is legal at any time: modules are created lazily, so the
  returned launcher is a deferred wrapper that binds to the registry on
  onHostResume, queues a single launch issued while unbound, and rebinds
  under the same key after Activity recreation.
- Keys are the contract's fully-qualified class name; duplicate
  registrations throw at registration time, with an owner-scoped
  overload as the escape hatch.
- ReactContext gains registerForActivityResult convenience methods
  mirroring ComponentActivity, plus getActivityResultCaller().
- ActivityEventListener dispatch is untouched; results flow through
  ComponentActivity's existing onActivityResult /
  onRequestPermissionsResult into its registry.

Demo: SampleTurboModule.requestSamplePermission (CAMERA) wired into
rn-tester's SampleTurboModuleExample under an Android-only section.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>

Author: matinzd

packages/react-native/ReactAndroid/src/main/java/com/facebook/react/activityresult/DeferredActivityResultLauncher.kt

@@ -0,0 +1,79 @@
+/*
+ * 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.activityresult
+
+import androidx.activity.result.ActivityResultLauncher
+import androidx.activity.result.contract.ActivityResultContract
+import androidx.core.app.ActivityOptionsCompat
+import com.facebook.common.logging.FLog
+import com.facebook.react.common.ReactConstants
+
+/**
+ * An [ActivityResultLauncher] handed out before the host Activity's `ActivityResultRegistry` is
+ * available. It delegates to the real launcher once [bind] is called, and queues a single pending
+ * [launch] issued while unbound, firing it on bind. [unbind] detaches it when the host Activity is
+ * destroyed so that [ReactActivityResultCallerImpl] can rebind it against the next host's registry.
+ */
+internal class DeferredActivityResultLauncher<I>(
+    private val key: String,
+    private val contract: ActivityResultContract<I, *>,
+    private val onUnregister: () -> Unit,
+) : ActivityResultLauncher<I>() {
+
+  override fun getContract(): ActivityResultContract<I, *> = contract
+
+  private class PendingLaunch<I>(val input: I, val options: ActivityOptionsCompat?)
+
+  private var delegate: ActivityResultLauncher<I>? = null
+  private var pendingLaunch: PendingLaunch<I>? = null
+
+  @Synchronized
+  override fun launch(input: I, options: ActivityOptionsCompat?) {
+    val boundDelegate = delegate
+    if (boundDelegate != null) {
+      boundDelegate.launch(input, options)
+    } else {
+      if (pendingLaunch != null) {
+        FLog.w(
+            ReactConstants.TAG,
+            "Launcher for '$key' was launched again before an Activity was available; " +
+                "replacing the previously queued launch.")
+      }
+      pendingLaunch = PendingLaunch(input, options)
+    }
+  }
+
+  @Synchronized
+  override fun unregister() {
+    delegate?.unregister()
+    delegate = null
+    pendingLaunch = null
+    onUnregister()
+  }
+
+  /** Attaches the real launcher and fires any launch queued while unbound. */
+  @Synchronized
+  fun bind(launcher: ActivityResultLauncher<I>) {
+    delegate = launcher
+    pendingLaunch?.let { pending ->
+      pendingLaunch = null
+      launcher.launch(pending.input, pending.options)
+    }
+  }
+
+  /** Detaches from a dying registry, keeping any queued launch for the next [bind]. */
+  @Synchronized
+  fun unbind() {
+    delegate?.unregister()
+    delegate = null
+  }
+
+  @get:Synchronized
+  val isBound: Boolean
+    get() = delegate != null
+}

packages/react-native/ReactAndroid/src/main/java/com/facebook/react/activityresult/ReactActivityResultCaller.kt

@@ -0,0 +1,52 @@
+/*
+ * 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.activityresult
+
+import androidx.activity.result.ActivityResultCallback
+import androidx.activity.result.ActivityResultLauncher
+import androidx.activity.result.contract.ActivityResultContract
+
+/**
+ * Lets a native module register an AndroidX [ActivityResultContract] against the host Activity's
+ * `ActivityResultRegistry` and receive results, without any changes to the consumer's
+ * `MainActivity`.
+ *
+ * The API deliberately mirrors `androidx.activity.ComponentActivity.registerForActivityResult`:
+ * same method name, same [ActivityResultCallback] shape, same returned [ActivityResultLauncher]
+ * type. Unlike an Activity, a caller obtained from a `ReactContext` may register at any time --
+ * including before any Activity exists -- and the returned launcher binds lazily to the real
+ * registry once the host resumes.
+ *
+ * Registrations are keyed by the contract's fully-qualified class name. Registering the same
+ * contract class twice throws an [IllegalStateException] at registration time; disambiguate by
+ * subclassing the contract or using the [registerForActivityResult] overload that takes an `owner`.
+ */
+public interface ReactActivityResultCaller {
+
+  /**
+   * Registers [contract] and returns a launcher for it. The registration key is the contract's
+   * fully-qualified class name.
+   *
+   * @throws IllegalStateException if a registration with the same key already exists
+   */
+  public fun <I, O> registerForActivityResult(
+      contract: ActivityResultContract<I, O>,
+      callback: ActivityResultCallback<O>,
+  ): ActivityResultLauncher<I>
+
+  /**
+   * Same as [registerForActivityResult], but scopes the registration key to [owner]
+   * (`"<owner class>:<contract class>"`). Use this when two independent callers need the same
+   * stock contract class, or when registering from something other than a native module.
+   */
+  public fun <I, O> registerForActivityResult(
+      owner: Any,
+      contract: ActivityResultContract<I, O>,
+      callback: ActivityResultCallback<O>,
+  ): ActivityResultLauncher<I>
+}

packages/react-native/ReactAndroid/src/main/java/com/facebook/react/activityresult/ReactActivityResultCallerImpl.kt

@@ -0,0 +1,128 @@
+/*
+ * 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.activityresult
+
+import androidx.activity.result.ActivityResultCallback
+import androidx.activity.result.ActivityResultLauncher
+import androidx.activity.result.ActivityResultRegistry
+import androidx.activity.result.ActivityResultRegistryOwner
+import androidx.activity.result.contract.ActivityResultContract
+import com.facebook.common.logging.FLog
+import com.facebook.react.bridge.LifecycleEventListener
+import com.facebook.react.bridge.ReactContext
+import com.facebook.react.common.ReactConstants
+
+/**
+ * Default [ReactActivityResultCaller], owned by a [ReactContext].
+ *
+ * Registrations are accepted at any time -- native modules are created lazily, typically well after
+ * the host Activity has resumed -- and bound to the current Activity's [ActivityResultRegistry]
+ * either immediately (when an Activity is already available) or on the next `onHostResume`. When
+ * the host Activity is destroyed the registrations are kept and rebound against the new Activity's
+ * registry under the same keys, so AndroidX can re-associate a result that arrives after Activity
+ * recreation.
+ */
+public class ReactActivityResultCallerImpl(private val reactContext: ReactContext) :
+    ReactActivityResultCaller, LifecycleEventListener {
+
+  private class Entry<I, O>(
+      val key: String,
+      val registrantDescription: String,
+      val contract: ActivityResultContract<I, O>,
+      val callback: ActivityResultCallback<O>,
+      val launcher: DeferredActivityResultLauncher<I>,
+  )
+
+  private val entries = LinkedHashMap<String, Entry<*, *>>()
+
+  init {
+    reactContext.addLifecycleEventListener(this)
+  }
+
+  override fun <I, O> registerForActivityResult(
+      contract: ActivityResultContract<I, O>,
+      callback: ActivityResultCallback<O>,
+  ): ActivityResultLauncher<I> =
+      register(contract.javaClass.name, callback.javaClass.name, contract, callback)
+
+  override fun <I, O> registerForActivityResult(
+      owner: Any,
+      contract: ActivityResultContract<I, O>,
+      callback: ActivityResultCallback<O>,
+  ): ActivityResultLauncher<I> =
+      register(
+          "${owner.javaClass.name}:${contract.javaClass.name}",
+          owner.javaClass.name,
+          contract,
+          callback)
+
+  @Synchronized
+  private fun <I, O> register(
+      key: String,
+      registrantDescription: String,
+      contract: ActivityResultContract<I, O>,
+      callback: ActivityResultCallback<O>,
+  ): ActivityResultLauncher<I> {
+    entries[key]?.let { existing ->
+      throw IllegalStateException(
+          "A launcher is already registered for key '$key' (registered by " +
+              "${existing.registrantDescription}, now requested by $registrantDescription). " +
+              "Subclass the contract to get a distinct key, or use the " +
+              "registerForActivityResult(owner, contract, callback) overload.")
+    }
+    val launcher = DeferredActivityResultLauncher(key, contract) { unregister(key) }
+    val entry = Entry(key, registrantDescription, contract, callback, launcher)
+    entries[key] = entry
+    currentRegistry()?.let { registry -> bind(entry, registry) }
+    return launcher
+  }
+
+  @Synchronized
+  private fun unregister(key: String) {
+    entries.remove(key)
+  }
+
+  @Synchronized
+  override fun onHostResume() {
+    val registry = currentRegistry() ?: return
+    for (entry in entries.values) {
+      if (!entry.launcher.isBound) {
+        bind(entry, registry)
+      }
+    }
+  }
+
+  override fun onHostPause(): Unit = Unit
+
+  @Synchronized
+  override fun onHostDestroy() {
+    // Detach from the dying registry but keep the registrations: they are rebound against the next
+    // host's registry (same keys) on the next onHostResume, which is also how a result that
+    // outlives the Activity gets re-associated by AndroidX.
+    for (entry in entries.values) {
+      entry.launcher.unbind()
+    }
+  }
+
+  private fun currentRegistry(): ActivityResultRegistry? {
+    val activity = reactContext.currentActivity ?: return null
+    val owner = activity as? ActivityResultRegistryOwner
+    if (owner == null) {
+      FLog.w(
+          ReactConstants.TAG,
+          "Current Activity ${activity.javaClass.name} is not an ActivityResultRegistryOwner; " +
+              "ActivityResultContract launchers will stay queued until one is available.")
+      return null
+    }
+    return owner.activityResultRegistry
+  }
+
+  private fun <I, O> bind(entry: Entry<I, O>, registry: ActivityResultRegistry) {
+    entry.launcher.bind(registry.register(entry.key, entry.contract, entry.callback))
+  }
+}