feat: adds click and swipe interactions to session replay (#292)

<!-- CURSOR_SUMMARY -->
> [!NOTE]
> Adds touch interaction (down/move/up) capture and RRWeb event
generation, refactors capture/export pipeline to batch per session and
handle full vs incremental snapshots.
> 
> - **Replay capture**:
> - Introduce `InteractionEvent`, `Position`, and `InteractionSource` to
intercept window touch events and emit interaction logs
(ACTION_DOWN/UP/MOVE) with buffering.
> - Add `InteractionMoveGrouper` to filter/group MOVE positions by
distance/time and periodically emit grouped events.
> - Rename `Capture` to `CaptureEvent`; `CaptureSource` now tracks the
most recent activity safely and uses `DispatcherProviderHolder`.
> - **Exporter (`RRwebGraphQLReplayLogExporter`)**:
> - Process logs sorted by time, group events by `session.id`, and
initialize sessions once before pushing payloads.
> - Replace send methods with generators: `generateCaptureFullEvents`,
`generateCaptureIncrementalEvents`, and new `generateInteractionEvents`
(RRWeb-compatible).
> - Track last-seen state (session/size) to choose full vs incremental
snapshots.
> - **Instrumentation (`ReplayInstrumentation`)**:
> - Wire `InteractionSource` into logging; emit
`event.domain=interaction` with serialized coords; use dispatcher
provider for coroutines.
> - **Tests**:
> - Add comprehensive `InteractionMoveGrouperTest` and update
`RRwebGraphQLReplayLogExporterTest` for event generation and batching
behavior.
> 
> <sup>Written by [Cursor
Bugbot](https://cursor.com/dashboard?tab=bugbot) for commit
6abf164. This will update automatically
on new commits. Configure
[here](https://cursor.com/dashboard?tab=bugbot).</sup>
<!-- /CURSOR_SUMMARY -->

Author: tanderson-ld

sdk/@launchdarkly/observability-android/lib/src/main/kotlin/com/launchdarkly/observability/replay/Capture.kt renamed to sdk/@launchdarkly/observability-android/lib/src/main/kotlin/com/launchdarkly/observability/replay/CaptureEvent.kt

@@ -10,7 +10,7 @@ package com.launchdarkly.observability.replay
  * @property session The unique session identifier that this capture belongs to. This links
  *                   the capture to a specific user session.
  */
-data class Capture(
+data class CaptureEvent(
     val imageBase64: String,
     val origHeight: Int,
     val origWidth: Int,

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

@@ -19,9 +19,9 @@ import android.view.ViewGroup
 import androidx.compose.ui.platform.ComposeView
 import androidx.compose.ui.semantics.SemanticsNode
 import androidx.compose.ui.semantics.SemanticsOwner
+import com.launchdarkly.observability.coroutines.DispatcherProviderHolder
 import io.opentelemetry.android.session.SessionManager
 import kotlinx.coroutines.CoroutineScope
-import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.flow.MutableSharedFlow
 import kotlinx.coroutines.flow.SharedFlow
 import kotlinx.coroutines.flow.asSharedFlow
@@ -34,10 +34,10 @@ import kotlin.coroutines.resumeWithException
 import androidx.compose.ui.geometry.Rect as ComposeRect
 
 /**
- * A source of [Capture]s taken from the most recently resumed [Activity]s window. Captures
+ * A source of [CaptureEvent]s taken from the most recently resumed [Activity]s window. Captures
  * are emitted on the [captureFlow] property of this class.
  *
- * @param sessionManager Used to get current session for tagging [Capture] with session id
+ * @param sessionManager Used to get current session for tagging [CaptureEvent] with session id
  */
 class CaptureSource(
     private val sessionManager: SessionManager,
@@ -46,10 +46,10 @@ class CaptureSource(
 ) :
     Application.ActivityLifecycleCallbacks {
 
-    private var _activity: Activity? = null
+    private var _mostRecentActivity: Activity? = null
 
-    private val _captureFlow = MutableSharedFlow<Capture>()
-    val captureFlow: SharedFlow<Capture> = _captureFlow.asSharedFlow()
+    private val _captureEventFlow = MutableSharedFlow<CaptureEvent>()
+    val captureFlow: SharedFlow<CaptureEvent> = _captureEventFlow.asSharedFlow()
 
     /**
      * Attaches the [CaptureSource] to the [Application] whose [Activity]s will be captured.
@@ -66,12 +66,12 @@ class CaptureSource(
     }
 
     /**
-     * Requests a [Capture] be taken now.
+     * Requests a [CaptureEvent] be taken now.
      */
     suspend fun captureNow() {
         val capture = doCapture()
         if (capture != null) {
-            _captureFlow.emit(capture)
+            _captureEventFlow.emit(capture)
         }
     }
 
@@ -84,11 +84,14 @@ class CaptureSource(
     }
 
     override fun onActivityResumed(activity: Activity) {
-        _activity = activity
+        _mostRecentActivity = activity
     }
 
     override fun onActivityPaused(activity: Activity) {
-        _activity = null
+        // this if check prevents pausing of a different activity from interfering with tracking of most recent activity.
+        if (activity == _mostRecentActivity) {
+            _mostRecentActivity = null
+        }
     }
 
     override fun onActivityStopped(activity: Activity) {
@@ -106,12 +109,12 @@ class CaptureSource(
     /**
      * Internal capture routine.
      */
-    private suspend fun doCapture(): Capture? = withContext(Dispatchers.Main) {
-        val activity = _activity ?: return@withContext null
-
+    private suspend fun doCapture(): CaptureEvent? = withContext(DispatcherProviderHolder.current.main) {
         try {
             if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
-                val window = activity.window
+                val activity = _mostRecentActivity ?: return@withContext null // return if no activity
+                val window = activity.window ?: return@withContext null // return if activity has no window
+
                 val decorView = window.decorView
                 val decorViewWidth = decorView.width
                 val decorViewHeight = decorView.height
@@ -146,7 +149,7 @@ class CaptureSource(
                                 val session = sessionManager.getSessionId()
 
                                 if (result == PixelCopy.SUCCESS) {
-                                    CoroutineScope(Dispatchers.Default).launch {
+                                    CoroutineScope(DispatcherProviderHolder.current.default).launch {
                                         try {
                                             val postMask = if (maskMatchers.isNotEmpty()) {
                                                 maskSensitiveRects(bitmap, sensitiveComposeRects)
@@ -161,14 +164,14 @@ class CaptureSource(
                                             val byteArray = outputStream.toByteArray()
                                             val compressedImage = Base64.encodeToString(byteArray, Base64.NO_WRAP)
 
-                                            val capture = Capture(
+                                            val captureEvent = CaptureEvent(
                                                 imageBase64 = compressedImage,
                                                 origWidth = decorViewWidth,
                                                 origHeight = decorViewHeight,
                                                 timestamp = timestamp,
                                                 session = session
                                             )
-                                            continuation.resume(capture)
+                                            continuation.resume(captureEvent)
                                         } catch (e: Exception) {
                                             continuation.resumeWithException(e)
                                         }

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

@@ -0,0 +1,13 @@
+package com.launchdarkly.observability.replay
+
+data class Position(
+    val x: Int,
+    val y: Int,
+    val timestamp: Long,
+)
+
+data class InteractionEvent(
+    val action: Int,
+    val positions: List<Position>,
+    val session: String,
+)

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

@@ -0,0 +1,103 @@
+package com.launchdarkly.observability.replay
+
+import android.view.MotionEvent
+import io.opentelemetry.android.session.SessionManager
+import kotlinx.coroutines.flow.MutableSharedFlow
+
+private const val FILTER_THRESHOLD_DISTANCE_SQUARED_PIXELS = 100
+private const val FILTER_THRESHOLD_TIME_MILLIS = 20
+private const val EMIT_PERIOD_MILLIS = 400
+
+/**
+ * Class for filtering and grouping emissions of movement interactions to reduce data rates.
+ *
+ * This class can only be used from a single thread, usually the main thread.
+ *
+ * @param _sessionManager used for tagging events with session id
+ * @param _bufferedFlow a buffered flow that emitted events will be given to, this is buffered to
+ * avoid delays handing off data to collector of flow
+ */
+class InteractionMoveGrouper(
+    private val _sessionManager: SessionManager,
+    private val _bufferedFlow: MutableSharedFlow<InteractionEvent>,
+) {
+    private val acceptedPositions = mutableListOf<Position>()
+    private var lastAccepted : Position? = null
+    private var lastEmitTime = 0L
+
+    // Handles another move applying filtering and possibly invoking tryEmit on the buffered flow when necessary.
+    fun handleMove(x: Int, y: Int, timestamp: Long) {
+        val current = Position(x, y, timestamp)
+
+        val last = lastAccepted
+        val passedFilter: Boolean
+        if (last != null) {
+            // if we have a last position, only use this new position if it passes filter (both thresholds have been exceeded)
+            val distThresholdExceeded = distanceSq(
+                current,
+                last
+            ) > FILTER_THRESHOLD_DISTANCE_SQUARED_PIXELS // note this is square of distance in pixels
+            val timeThresholdExceeded = (timestamp - last.timestamp) > FILTER_THRESHOLD_TIME_MILLIS
+            passedFilter = distThresholdExceeded && timeThresholdExceeded
+        } else {
+            // if we don't have a last position that got through filtering, this one is the first and should be used
+            passedFilter = true
+        }
+
+        if (passedFilter) {
+            // position has passed filtering, add it to list
+            acceptedPositions.add(current)
+            lastAccepted = current
+        }
+
+        // if enough time has passed since last emission, tryEmit the group
+        val currentTime = System.currentTimeMillis()
+        if (acceptedPositions.isNotEmpty() && (currentTime - lastEmitTime > EMIT_PERIOD_MILLIS)) {
+            val interaction = InteractionEvent(
+                action = MotionEvent.ACTION_MOVE,
+                positions = acceptedPositions.toList(), // toList() makes a copy, which is required
+                session = _sessionManager.getSessionId(),
+            )
+            _bufferedFlow.tryEmit(interaction)
+
+            lastEmitTime = currentTime
+            acceptedPositions.clear()
+        }
+    }
+
+    // Call this when the last position of a move is known, this will trigger tryEmit on the buffered flow so no
+    // positions are left behind in the buffer.
+    fun completeWithLastPosition(x: Int, y: Int, timestamp: Long) {
+        val current = Position(x, y, timestamp)
+
+        // last position that got through filtering
+        val last = lastAccepted
+        if (last == null || last != current) {
+            acceptedPositions.add(current)
+            lastAccepted = current
+        }
+
+        // since we have distance and time filtering, it is possible that there are no positions that
+        // make it through the filtering, need to protect against this case
+        if (acceptedPositions.isNotEmpty()) {
+            val interaction = InteractionEvent(
+                action = MotionEvent.ACTION_MOVE,
+                positions = acceptedPositions.toList(), // toList() makes a copy, which is required
+                session = _sessionManager.getSessionId(),
+            )
+            _bufferedFlow.tryEmit(interaction)
+        }
+
+        // reset state so next move sequence is treated as an independent sequence
+        lastAccepted = null
+        lastEmitTime = 0L
+        acceptedPositions.clear()
+    }
+
+    // Calculates squared distance between positions
+    private fun distanceSq(a: Position, b: Position): Int {
+        val dx = a.x - b.x
+        val dy = a.y - b.y
+        return dx * dx + dy * dy
+    }
+}