feat: [SDK-2197] Add LDReplay. registerActivity() method for React Native. (#472)

## Summary

Adds a `LDReplay. registerActivity()` method that allows registering an
activity after it has already been created. Normally, Android Session
Replay uses Activity lifecycle hooks to listen for when Activities get
created and register them. But React Native Session Replay gets
initialized after the main Activity has already been created. So this
method can be used to hook it up manually.

## How did you test this change?

I manually tested this by publishing to a local maven repo and using it
with the example app and a modified session replay SDK.

## Are there any deployment considerations?

N/A

<!-- CURSOR_SUMMARY -->
---

> [!NOTE]
> **Low Risk**
> Low risk additive change that exposes a new optional API for wiring
touch capture when initialization happens after an `Activity` has
started; primary risk is incorrect registration leading to missed or
duplicate touch interception in edge cases.
> 
> **Overview**
> Adds a new opt-in `LDReplay.registerActivity(Activity)` API to support
frameworks (e.g. React Native) that initialize Session Replay after the
host `Activity` is already running.
> 
> This threads a new `registerActivity` call through `LDReplay` →
`SessionReplayService` → `InteractionSource`, where
`InteractionSource.registerActivity` simulates the
`onActivityStarted`/`onActivityResumed` lifecycle events to install the
touch interceptor and set the active window.
> 
> <sup>Reviewed by [Cursor Bugbot](https://cursor.com/bugbot) for commit
fe49982. Bugbot is set up for automated
code reviews on this repo. Configure
[here](https://www.cursor.com/dashboard/bugbot).</sup>
<!-- /CURSOR_SUMMARY -->
<!-- ld-jira-link -->
---
Related Jira issue: [SDK-2197: Fix Android RN Session Replay not
attaching to
MainActivity](https://launchdarkly.atlassian.net/browse/SDK-2197)
<!-- end-ld-jira-link -->

Author: beekld

sdk/@launchdarkly/observability-android/lib/src/main/kotlin/com/launchdarkly/observability/replay/InteractionSource.kt

@@ -153,6 +153,16 @@ class InteractionSource(
         application.registerActivityLifecycleCallbacks(this)
     }
 
+    /**
+     * Registers the given activity for touch capture, as if [onActivityStarted]
+     * and [onActivityResumed] had already fired for it. Call this when the SDK is initialized
+     * after the activity is already running (e.g. React Native).
+     */
+    fun registerActivity(activity: Activity) {
+        onActivityStarted(activity)
+        onActivityResumed(activity)
+    }
+
     /**
      * Detaches the [InteractionSource] from the [Application].
      */

sdk/@launchdarkly/observability-android/lib/src/main/kotlin/com/launchdarkly/observability/replay/SessionReplayService.kt

@@ -1,5 +1,6 @@
 package com.launchdarkly.observability.replay
 
+import android.app.Activity
 import androidx.lifecycle.DefaultLifecycleObserver
 import androidx.lifecycle.Lifecycle
 import androidx.lifecycle.LifecycleOwner
@@ -233,6 +234,14 @@ class SessionReplayService(
         }
     }
 
+    /**
+     * Registers [activity] for touch capture. Call this after SDK initialization when the
+     * activity is already running (e.g. React Native, where init happens after the activity starts).
+     */
+    override fun registerActivity(activity: Activity) {
+        interactionSource?.registerActivity(activity)
+    }
+
     // TODO: O11Y-621 - This should be called somewhere (Probably inside ObservabilityService.kt) to shutdown the instrumentation.
     fun shutdown() {
         pauseCapture()

sdk/@launchdarkly/observability-android/lib/src/main/kotlin/com/launchdarkly/observability/sdk/LDReplay.kt

@@ -1,5 +1,6 @@
 package com.launchdarkly.observability.sdk
 
+import android.app.Activity
 import com.launchdarkly.observability.replay.plugin.SessionReplayHookProxy
 
 /**
@@ -53,11 +54,23 @@ object LDReplay {
     fun flush() {
         delegate.flush()
     }
+
+    /**
+     * Registers [activity] for touch capture.
+     *
+     * You do not normally need to call this. It is only necessary when the SDK is initialized
+     * after the activity has already started (e.g. in React Native, where the host activity
+     * is already running before the SDK initializes).
+     */
+    fun registerActivity(activity: Activity) {
+        delegate.registerActivity(activity)
+    }
 }
 
 internal interface SessionReplayServicing {
     fun start()
     fun stop()
     fun flush()
     fun afterIdentify(contextKeys: Map<String, String>, canonicalKey: String, completed: Boolean)
+    fun registerActivity(activity: Activity) {}
 }

sdk/@launchdarkly/observability-android/lib/src/test/kotlin/com/launchdarkly/observability/sdk/LDReplayTest.kt

@@ -1,5 +1,7 @@
 package com.launchdarkly.observability.sdk
 
+import android.app.Activity
+import io.mockk.mockk
 import org.junit.jupiter.api.Assertions.assertEquals
 import org.junit.jupiter.api.Test
 
@@ -9,6 +11,7 @@ class LDReplayTest {
         var startCalls = 0
         var stopCalls = 0
         var flushCalls = 0
+        var registerActivityCalls = 0
 
         override fun start() {
             startCalls++
@@ -23,6 +26,10 @@ class LDReplayTest {
         }
 
         override fun afterIdentify(contextKeys: Map<String, String>, canonicalKey: String, completed: Boolean) {}
+
+        override fun registerActivity(activity: Activity) {
+            registerActivityCalls++
+        }
     }
 
     @Test
@@ -54,4 +61,14 @@ class LDReplayTest {
 
         assertEquals(1, control.flushCalls)
     }
+
+    @Test
+    fun `registerActivity delegates to replay control`() {
+        val control = TestControl()
+        LDReplay.init(control)
+
+        LDReplay.registerActivity(mockk<Activity>())
+
+        assertEquals(1, control.registerActivityCalls)
+    }
 }