Copy as Markdown[Open in ChatGPT](https://chatgpt.com/?q=Read%20https%3A%2F%2Fcoralogix.com%2Fdocs%2Fuser-guides%2Frum%2Fsdk-installation%2Fandroid%2Ffeatures%2Fsession-replay.md%20and%20help%20me%20with%20my%20question%20about%20this%20Coralogix%20documentation%20page.)[Open in Claude](https://claude.ai/new?q=Read%20https%3A%2F%2Fcoralogix.com%2Fdocs%2Fuser-guides%2Frum%2Fsdk-installation%2Fandroid%2Ffeatures%2Fsession-replay.md%20and%20help%20me%20with%20my%20question%20about%20this%20Coralogix%20documentation%20page.) # Session Replay Session Replay captures a visual sequence of user interactions in your app by recording periodic screenshots. This allows you to analyze what the user saw before, during, and after an issue — helping you quickly pinpoint the source of errors, performance slowdowns, or unexpected behavior. Use Session Replay to recreate the user experience and better understand the context behind each session. ## Prerequisites[​](#prerequisites "Direct link to Prerequisites") Before enabling Session Replay, you must install and initialize the [Coralogix Android RUM SDK](#coralogix-android-rum-sdk) in your app. Note The Session Replay feature extends the Android RUM SDK and must be initialized after the base SDK setup. Attempting to initialize Session Replay without the base SDK will result in an initialization error. ## Session Replay by default[​](#session-replay-by-default "Direct link to Session Replay by default") Session Replay on Android: * Evaluates UI one frame per second (FPS) and captures only if the layout changed since the previous screenshot. * Masks all text inputs by default (controlled by `maskAllTexts`). * Optionally masks only specific text values or regex patterns (via `textsToMask` when `maskAllTexts` is `false`). * Redacts sensitive input field types (passwords, emails, numbers, etc.) via `maskInputFieldsOfTypes`. * Optionally masks all image views when `maskAllImages` is enabled. * Samples 100% of sessions by default. * Sample frames at 1fps. You can customize these defaults using the configuration options below. ## Configure and initialize[​](#configure-and-initialize "Direct link to Configure and initialize") Use the `SessionReplayOptions` class to configure capture behavior, privacy masking, and sampling. ### Example[​](#example "Direct link to Example") ``` class MyApp : Application() { override fun onCreate() { super.onCreate() // step 1: initialize the Android RUM SDK val sdkOptions = CoralogixOptions( applicationName = "", coralogixDomain = CoralogixDomain.EU1, publicKey = "" ) CoralogixRum.initialize( application = this, options = sdkOptions ) // now you can safely initialize SessionReplay val sessionReplayOptions = SessionReplayOptions( captureScale = 0.5f, // Scale screenshots to half resolution captureCompressQuality = 0.8f, // Compress images for size optimization sessionRecordingSampleRate = 80, // Capture 80% of sessions autoStartSessionRecording = true, // Start recording automatically maskAllTexts = false, // Do not mask all text by default textsToMask = listOf("password", "secret.*"), // Mask specific words or regex patterns maskInputFieldsOfTypes = listOf( EditTextType.PASSWORD, EditTextType.EMAIL ), maskAllImages = true, // Mask all image views ) SessionReplay.initialize(this, sessionReplayOptions) } } ``` ## Options reference[​](#options-reference "Direct link to Options reference") Configuration fields for `SessionReplayOptions`: | Option | Type | Description | Default | | ------------------------------ | -------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------- | | `autoStartSessionRecording` | `Boolean` | Start recording automatically | `true` | | `captureScale` | `Float` | Screenshot resolution scale factor (0–1). Lower values reduce size and memory usage | `0.5f` | | `captureCompressQuality` | `Float` | Image compression (0–1). Lower values reduce fidelity and file size | `1.0f` | | `sessionRecordingSampleRate` | `Int` (0–100) | % of sessions to capture | `100` | | `maskAllTexts` | `Boolean` | Redact all on-screen text | `true` | | `textsToMask` | `List` | Redact only specific text values or regex patterns (used when `maskAllTexts` is `false`) | `emptyList()` | | `maskInputFieldsOfTypes` | `List` | Redact only specific input fields (e.g., password, email, phone) | `emptyList()` | | `maskAllImages` | `Boolean` | Mask all image views on screen | `false` | | ~~`sampleFrameRatePerSecond`~~ | `Int` *(deprecated)* | **Deprecated — do not change.** 1 fps is the only supported capture rate. Values above 1 degrade app performance and make mask-rect alignment unreliable, causing sensitive content to bleed through masks during scroll and animation. This field will be removed in a future release. | `1` | ## Image capture triggers[​](#image-capture-triggers "Direct link to Image capture triggers") Screenshots are captured during session replay in the following cases: * User interacts with the screen (tap, scroll, or swipe). * User navigates between activities or fragments. * A periodic capture is triggered at 1 fps (the `sampleFrameRatePerSecond` option is deprecated and will be removed in a future release) * Error or crash occurs. * Manual screen capture event via [`SessionReplay.captureScreenshot()`](#manually-capture-screen). Android Session Replay combines periodic sampling with **event-based captures** (click, error), so you still see key moments even if they occur between checks. Note Periodic sampling triggers a capture but only process that frame if a meaningful layout change has taken place to avoid noise and improve performance. ## Start and stop recording[​](#start-and-stop-recording "Direct link to Start and stop recording") If `autoStartSessionRecording` is `false`, you can manually control recording: ``` SessionReplay.startSessionRecording() SessionReplay.stopSessionRecording() ``` ## Manually capture screen[​](#manually-capture-screen "Direct link to Manually capture screen") Use `captureScreenshot` to capture a specific moment in the session: ``` SessionReplay.captureScreenshot() ``` ## Privacy and masking[​](#privacy-and-masking "Direct link to Privacy and masking") Coralogix provides flexible masking options to help you meet privacy requirements: * **Text masking:** Use `maskAllTexts` to redact all on-screen text, or `textsToMask` to selectively mask specific text values or regex patterns. Patterns use Kotlin/Java regex syntax (e.g. `(?i)button` for case-insensitive matching). * **Input field masking:** Protect sensitive data such as passwords, emails, phone numbers, and other input fields by specifying their `EditTextType`. * **Image masking:** Use `maskAllImages = true` to redact all `ImageView` instances on screen. * **View masking:** You can programmatically mark a specific view as sensitive: ``` mySensitiveView.maskView() ``` ### What masking covers[​](#what-masking-covers "Direct link to What masking covers") Marking a view as sensitive applies to its whole subtree — every child is masked too, and a child cannot be opted back out. Masking a container is therefore enough to cover everything inside it, which is the recommended way to protect a composite element such as a PIN keypad whose keys are individual views. A masked view, and anything inside it: * is covered by a black overlay in session replays; * absorbs tap markers — a tap landing anywhere inside it draws no marker in the recording, so the replay does not reveal which part of the masked area was touched; * reports its inner text as `***` in user interaction events. Everything else on the interaction event is reported as-is — the element's id, class, resolved element name, and the touch coordinates — and the event is still emitted. This matches the Coralogix web SDK: masking hides what an element says, not what it is or that it was used. The event also carries `interaction_context.is_masked_element` (always present, `true`/`false`) so you can enforce a stricter policy yourself in `beforeSend` — see below. > **Upgrading from 2.19.4:** that release also redacted the id, class, and element name of a masked element. From 2.20.0 those fields are reported as-is again to match the web SDK; use `is_masked_element` in `beforeSend` if you need them redacted. > **Shared identifiers for masked keypads:** an element's resource name can identify it as plainly as its label — a keypad laid out as `key_0`…`key_9` spells out the entered sequence through ids alone. If that matters to you, give the keys one shared id (or drop masked interactions in `beforeSend`). ### Enforcing a stricter policy with `is_masked_element`[​](#enforcing-a-stricter-policy-with-is_masked_element "Direct link to enforcing-a-stricter-policy-with-is_masked_element") `is_masked_element` is `true` when the interaction targeted masked content (via `maskView()`, the masked-view tag, or `Modifier.coralogixMasked()` — independent of whether session replay is recording). It is `false` in every case where the SDK cannot resolve masking — deliberately under-reporting rather than guessing: * a hybrid (React Native / Flutter) interaction reported without coordinates, such as React Native scrolls and swipes; * more than one hybrid root is on screen **and** the candidate readings disagree — the coordinates are root-relative and carry no root identity, so their owner is ambiguous (two windows are routinely attached for a moment during an activity transition; when all candidates agree, the agreed answer is used); * no view tree was available when the interaction was processed. For hybrid interactions the resolution is best-effort at processing time: it reads the screen as it is when the event is processed, so a navigation between the tap and its processing can make the flag wrong in either direction. A wrapper that needs an exact answer supplies `UserInteractionDetails.isMasked`, which is authoritative and skips coordinate resolution entirely. Drop every masked interaction: ``` beforeSend = { event -> if (event.interactionContext?.isMaskedElement == true) null else event } ``` Keep the event but blank the coordinates: ``` beforeSend = { event -> if (event.interactionContext?.isMaskedElement == true) { event.copy( interactionContext = event.interactionContext?.copy(attributes = buildJsonObject {}) ) } else { event } } ``` > **Jetpack Compose:** All masking options above apply to Compose content as well. Use `Modifier.coralogixMasked()` for explicit per-composable masking. See the [Compose SDK README](https://coralogix.com/docs/user-guides/rum/sdk-installation/android/jetpack-compose.md#session-replay-masking) for Compose-specific limitations (image detection, password-only input masking, and the `invisibleToUser()` known limitation). Tip Always verify your masking rules in staging before going live, especially for sensitive inputs like login screens and payment forms.