diff --git a/analytics/build.gradle b/analytics/build.gradle
index 781525b3a..4297b3d38 100644
--- a/analytics/build.gradle
+++ b/analytics/build.gradle
@@ -1,5 +1,7 @@
 plugins {
     id 'com.android.library'
+    id 'org.jetbrains.kotlin.android'
+    id 'org.jetbrains.kotlin.plugin.compose'
     id 'mixpanel.maven-publish'
     id 'jacoco'
     id 'ru.vyarus.animalsniffer' version '2.0.0'
@@ -25,6 +27,12 @@ android {
         sourceCompatibility JavaVersion.VERSION_17
         targetCompatibility JavaVersion.VERSION_17
     }
+    kotlinOptions {
+        jvmTarget = "17"
+    }
+    buildFeatures {
+        compose true
+    }
 
 
     sourceSets {
@@ -146,8 +154,13 @@ dependencies {
     implementation 'androidx.core:core:1.13.1'
     implementation 'androidx.lifecycle:lifecycle-process:2.6.2'
     implementation 'io.github.jamsesso:json-logic-java:1.1.0'
+    // Curtains: root view (window) observation for autocapture dialog/popup tracking.
+    // Compatible with other Curtains consumers (e.g., Session Replay SDK).
+    implementation 'com.squareup.curtains:curtains:1.2.5'
     // json-logic-java pulls in an outdated json with cve
     implementation 'com.google.code.gson:gson:2.13.2'
+    // Compose UI for autocapture semantics extraction (optional - graceful degradation if not present)
+    compileOnly 'androidx.compose.ui:ui:1.7.7'
     // AndroidJUnitRunner and JUnit Rules
     testImplementation 'junit:junit:4.13.2'
     androidTestImplementation 'androidx.test:core:1.6.1'
@@ -162,6 +175,13 @@ dependencies {
     testImplementation 'androidx.test:core:1.5.0'
     testImplementation 'org.json:json:20231013'
     androidTestImplementation 'androidx.test.espresso:espresso-core:3.6.1'
+    // Compose dependencies for androidTest only (Compose autocapture tests)
+    androidTestImplementation platform('androidx.compose:compose-bom:2024.12.01')
+    androidTestImplementation 'androidx.compose.ui:ui'
+    androidTestImplementation 'androidx.compose.material3:material3'
+    androidTestImplementation 'androidx.compose.ui:ui-test-junit4'
+    androidTestImplementation 'androidx.activity:activity-compose:1.9.1'
+    debugImplementation 'androidx.compose.ui:ui-test-manifest:1.7.7'
 }
 
 jacoco {
diff --git a/analytics/docs/autocapture.md b/analytics/docs/autocapture.md
new file mode 100644
index 000000000..25347f0d4
--- /dev/null
+++ b/analytics/docs/autocapture.md
@@ -0,0 +1,542 @@
+# Android Autocapture
+
+Autocapture automatically tracks user interactions in your Android app without requiring manual instrumentation.
+
+## Overview
+
+Autocapture captures three types of events:
+
+| Event | Name | Description |
+|-------|------|-------------|
+| Click | `$mp_click` | Fired when a user taps any element |
+| Rage Click | `$mp_rage_click` | Fired when a user taps rapidly (4+ times) in the same area |
+| Dead Click | `$mp_dead_click` | Fired when a tap produces no visible UI response |
+
+**Privacy:** Autocapture is designed with privacy in mind. No personally identifiable information (PII) is captured by default.
+
+## Quick Start
+
+Autocapture is **disabled by default**. Enable it by providing `AutocaptureOptions` during SDK initialization:
+
+### Kotlin
+
+```kotlin
+import com.mixpanel.android.mpmetrics.AutocaptureOptions
+import com.mixpanel.android.mpmetrics.MixpanelAPI
+import com.mixpanel.android.mpmetrics.MixpanelOptions
+
+val autocaptureOptions = AutocaptureOptions.Builder().build()
+
+val options = MixpanelOptions.Builder()
+    .autocaptureOptions(autocaptureOptions)
+    .build()
+
+val mixpanel = MixpanelAPI.getInstance(context, "YOUR_TOKEN", true, options)
+```
+
+### Java
+
+```java
+import com.mixpanel.android.mpmetrics.AutocaptureOptions;
+import com.mixpanel.android.mpmetrics.MixpanelAPI;
+import com.mixpanel.android.mpmetrics.MixpanelOptions;
+
+AutocaptureOptions autocaptureOptions = new AutocaptureOptions.Builder().build();
+
+MixpanelOptions options = new MixpanelOptions.Builder()
+    .autocaptureOptions(autocaptureOptions)
+    .build();
+
+MixpanelAPI mixpanel = MixpanelAPI.getInstance(context, "YOUR_TOKEN", true, options);
+```
+
+That's it! No additional setup required. Autocapture automatically intercepts all touch events.
+
+## Configuration Options
+
+### ClickOptions
+
+| Option | Default | Description |
+|--------|---------|-------------|
+| `enabled` | `true` | Track all click events |
+
+### RageClickOptions
+
+| Option | Default | Description |
+|--------|---------|-------------|
+| `enabled` | `true` | Track rage click events |
+| `clickThreshold` | `4` | Number of clicks required to trigger |
+| `timeWindowMs` | `1000` | Time window in milliseconds |
+| `radius` | `44` | Spatial threshold in dp (density-independent pixels) |
+
+### DeadClickOptions
+
+| Option | Default | Description |
+|--------|---------|-------------|
+| `enabled` | `true` | Track dead click events |
+| `timeoutMs` | `500` | Response wait time in milliseconds |
+
+### Custom Configuration Example
+
+#### Kotlin
+
+```kotlin
+val autocaptureOptions = AutocaptureOptions.Builder()
+    .clickOptions(ClickOptions.Builder().enabled(true).build())
+    .rageClickOptions(
+        RageClickOptions.Builder()
+            .enabled(true)
+            .clickThreshold(5)        // Require 5 clicks instead of 4
+            .timeWindowMs(800)        // Shorter time window
+            .radius(50f)              // Larger radius
+            .build()
+    )
+    .deadClickOptions(
+        DeadClickOptions.Builder()
+            .enabled(false)           // Disable dead click detection
+            .build()
+    )
+    .build()
+
+val options = MixpanelOptions.Builder()
+    .autocaptureOptions(autocaptureOptions)
+    .build()
+```
+
+#### Java
+
+```java
+AutocaptureOptions autocaptureOptions = new AutocaptureOptions.Builder()
+    .clickOptions(new ClickOptions.Builder().enabled(true).build())
+    .rageClickOptions(
+        new RageClickOptions.Builder()
+            .enabled(true)
+            .clickThreshold(5)        // Require 5 clicks instead of 4
+            .timeWindowMs(800)        // Shorter time window
+            .radius(50f)              // Larger radius
+            .build()
+    )
+    .deadClickOptions(
+        new DeadClickOptions.Builder()
+            .enabled(false)           // Disable dead click detection
+            .build()
+    )
+    .build();
+
+MixpanelOptions options = new MixpanelOptions.Builder()
+    .autocaptureOptions(autocaptureOptions)
+    .build();
+```
+
+## Event Properties
+
+All autocapture events include these properties:
+
+| Property | Description |
+|----------|-------------|
+| `$x` | Touch X coordinate (screen pixels) |
+| `$y` | Touch Y coordinate (screen pixels) |
+| `$el_id` | Element identifier (see resolution rules below) |
+| `$el_tag_name` | Class name of the view (e.g., `Button`, `TextView`) |
+| `$attr-aria-label` | Content description (accessibility label) |
+| `$attr-role` | Element role (Button, Switch, etc.) |
+| `$elements` | View hierarchy string (max 5 levels) |
+
+## Element Identification (`$el_id`)
+
+The `$el_id` property uses the following resolution order:
+
+### Resolution Order
+
+1. `contentDescription` (if non-empty)
+2. Resource ID name (e.g., `R.id.checkout_button` → `"checkout_button"`)
+3. `ClassName_view_<hashCode>` (fallback)
+
+### Best Practices
+
+#### XML Views
+
+```xml
+<!-- Recommended: Set contentDescription for reliable tracking -->
+<Button
+    android:id="@+id/checkout_button"
+    android:contentDescription="checkout_button"
+    android:text="Checkout"
+    android:onClick="onCheckoutClick"/>
+
+<!-- Alternative: Use meaningful resource IDs -->
+<Button
+    android:id="@+id/checkout_button"
+    android:text="Checkout"
+    android:onClick="onCheckoutClick"/>
+```
+
+#### Jetpack Compose
+
+```kotlin
+// Recommended: Set semantics for reliable tracking
+Button(
+    onClick = { /* ... */ },
+    modifier = Modifier.semantics {
+        contentDescription = "checkout_button"
+    }
+) {
+    Text("Checkout")
+}
+
+// Alternative: Use testTag (maps to contentDescription)
+Button(
+    onClick = { /* ... */ },
+    modifier = Modifier.testTag("checkout_button")
+) {
+    Text("Checkout")
+}
+```
+
+## Compose Support
+
+Autocapture has **full support** for Jetpack Compose UI. The SDK uses Compose's native semantic APIs to extract element information.
+
+### How It Works
+
+1. Touch events are intercepted via `Window.Callback`
+2. Compose semantic nodes are traversed using `SemanticsOwner`
+3. Element properties extracted from `SemanticsConfiguration`
+
+### Compose Semantics Mapping
+
+| Compose Semantics | Maps To |
+|-------------------|---------|
+| `contentDescription` / `testTag` | `$el_id` |
+| `role` | `$attr-role` |
+| Semantic flags | Element type detection |
+
+### Example
+
+```kotlin
+@Composable
+fun CheckoutButton() {
+    Button(
+        onClick = { processCheckout() },
+        modifier = Modifier.semantics {
+            contentDescription = "checkout_button"  // → $el_id
+            role = Role.Button                       // → $attr-role: "Button"
+        }
+    ) {
+        Text("Checkout")
+    }
+}
+```
+
+## Dead Click Detection
+
+Dead click detection monitors interactive elements for UI response:
+
+### How It Works
+
+1. User taps an element with click handlers
+2. Capture a baseline snapshot of the UI state immediately (before the click handler runs)
+3. Attach listeners for layout changes, scroll events, and window additions
+4. If any UI change is detected, cancel detection early (not a dead click)
+5. After 500ms (timeout), compare final state to baseline
+6. If UI hasn't changed, emit `$mp_dead_click`
+
+### Excluded Controls
+
+These controls are excluded from dead click detection because they always produce a visual response when tapped (inherent feedback). They still emit `$mp_click` events.
+
+**Android (XML Views):**
+- `EditText` - Keyboard appears
+- `Switch` / `CompoundButton` / `Checkbox` / `RadioButton` / `ToggleButton` - Toggles own state
+- `SeekBar` - Thumb moves
+- `Spinner` - Dropdown opens
+- `DatePicker` / `NumberPicker` - Picker UI appears
+
+**Android (Compose):**
+- `TextField` / `BasicTextField` - Keyboard appears
+- `Switch` / `Checkbox` / `RadioButton` - Toggles own state
+- `Slider` - Thumb moves
+
+**iOS (UIKit):**
+- `UITextField` / `UITextView` - Keyboard appears
+- `UISwitch` - Toggles own state
+- `UISlider` - Thumb moves
+- `UIStepper` - Value changes
+- `UISegmentedControl` - Selection changes
+- `UIDatePicker` / `UIPickerView` - Picker UI appears
+
+**iOS (SwiftUI):**
+- `TextField` / `TextEditor` / `SecureField` - Keyboard appears
+- `Toggle` - Toggles own state
+- `Slider` / `Stepper` - Value changes
+- `Picker` / `DatePicker` - Picker UI appears
+
+### What Counts as UI Change
+
+- View count change (new views added/removed)
+- Content change (text, button states, etc.)
+- Window count change (alerts, dialogs, bottom sheets)
+- Navigation events (Activity changes)
+
+**Note:** Text input controls (`EditText`, `UITextField`, `TextField`, etc.) are fully excluded from dead click monitoring, so the keyboard appearing after a tap does not produce a false `$mp_dead_click`.
+
+## Multi-Window Support
+
+Autocapture tracks touches across multiple windows using `WindowSpy`:
+
+| Window Type | Tracked | Notes |
+|-------------|---------|-------|
+| Activity | ✅ | |
+| AlertDialog | ✅ | Both `android.app.AlertDialog` and `androidx.appcompat.app.AlertDialog` |
+| BottomSheetDialog | ✅ | Material `BottomSheetDialog` and Compose `ModalBottomSheet` |
+| DatePickerDialog | ✅ | |
+| TimePickerDialog | ✅ | |
+| Snackbar | ✅ | |
+| Toast | ⚠️ | Detected but not interactive |
+| PopupWindow | ❌ | Child views consume touches before interception (known limitation) |
+| PopupMenu | ❌ | Uses `PopupWindow` internally |
+| Spinner dropdown | ❌ | Uses `PopupWindow` internally |
+| Compose DropdownMenu | ❌ | Uses `PopupWindow` internally |
+
+### How It Works
+
+Autocapture uses [Square's Curtains](https://github.com/square/curtains) library to observe root view (window) additions and removals. This allows autocapture to track clicks on dialogs, popups, and other overlays without any manual setup. Curtains is compatible with other consumers such as the Mixpanel Session Replay SDK.
+
+## Signal UI Change API
+
+For JS-based navigation frameworks (React Native) or custom navigation that bypasses standard Activity lifecycle, use `signalUIChange()` to prevent false dead click positives:
+
+```kotlin
+// Kotlin
+mixpanel.signalUIChange()
+
+// Java
+mixpanel.signalUIChange();
+```
+
+This cancels any pending dead click detection by notifying the SDK that a UI change occurred.
+
+## Privacy Considerations
+
+### What is Captured
+
+- Touch coordinates
+- View class names and hierarchy
+- Content descriptions (accessibility labels)
+- Resource ID names
+
+### What is NOT Captured
+
+Autocapture does not capture visible text content (`$el_text`) from tapped elements. Tracking text can be invasive and raise privacy concerns. Additionally, the complexity of nested view hierarchies can cause text extraction to capture content from unintended views — for example, tapping a container layout might extract text from a deeply nested label that isn't semantically related to the tap. The remaining captured properties (`$el_id`, `$el_tag_name`, `$attr-aria-label`, `$attr-role`, `$elements`) are purely structural UI metadata.
+
+## Platform Support
+
+| Platform | Support | Notes |
+|----------|---------|-------|
+| Android 5.0+ (API 21) | Full | Minimum SDK version |
+| XML Views | Full | Traditional Android UI |
+| Jetpack Compose | Full | Native Compose semantics support |
+| React Native | Full | Via bridge to native SDK |
+| Flutter | Partial | Native SDK sees only FlutterView |
+
+## Requirements
+
+- Min SDK: 21 (Android 5.0)
+- Compile SDK: 34
+- Java: 17 (source/target compatibility)
+- No additional dependencies required
+
+## Troubleshooting
+
+### Enable Debug Logging
+
+```kotlin
+// Kotlin
+mixpanel.setEnableLogging(true)
+
+// Java
+mixpanel.setEnableLogging(true);
+```
+
+This will log autocapture events to Logcat:
+
+```
+MP.AutocaptureManager: emitted $mp_click for checkout_button
+MP.AutocaptureManager: emitted $mp_rage_click for submit_btn (count: 4)
+MP.AutocaptureManager: emitted $mp_dead_click for broken_link
+```
+
+### Verify Events in Dashboard
+
+1. Enable logging as shown above
+2. Trigger interactions in your app
+3. Check Logcat for autocapture events
+4. Check the Mixpanel Live View for events appearing with names `$mp_click`, `$mp_rage_click`, `$mp_dead_click`
+
+### Common Issues
+
+**Events not appearing:**
+- Verify `AutocaptureOptions` is passed to `MixpanelOptions`
+- Ensure autocapture is enabled (check `isEnabled()` returns true)
+- Verify network connectivity and event flushing
+
+**Compose elements showing hash IDs:**
+- Set `contentDescription` or `testTag` on interactive elements
+- Use `Modifier.semantics { contentDescription = "..." }`
+
+**False positive dead clicks:**
+- Element may have a handler that doesn't produce visible UI change
+- Use `signalUIChange()` for custom navigation
+
+**Missing clicks on dialogs/popups:**
+- Dialogs, bottom sheets, and snackbars are tracked automatically via `WindowSpy`
+- Check ProGuard rules are applied (if using ProGuard)
+- Verify `WindowManagerGlobal` is not obfuscated
+- `PopupWindow`-based components (PopupMenu, Spinner dropdown, Compose DropdownMenu) are **not supported** — see Multi-Window Support table
+
+## Technical Details
+
+### Touch Interception
+
+Autocapture uses `Window.Callback` wrapping to intercept touch events:
+
+1. `WindowSpy` detects all root view additions (Activities, Dialogs, etc.)
+2. For each window, a `TouchInterceptor` wraps the existing `Window.Callback`
+3. On `dispatchTouchEvent`, the interceptor:
+   - Lets the event propagate normally (non-invasive)
+   - Captures `ACTION_UP` events for processing
+   - Extracts semantic information from the tapped view
+
+This approach:
+- Requires zero customer setup
+- Captures all windows (main, alerts, sheets, popups)
+- Works with both XML Views and Jetpack Compose
+- Non-blocking (< 5ms overhead per touch)
+
+### Thread Safety
+
+All autocapture components use thread-safe patterns:
+- Synchronized access to shared state
+- WeakHashMap for window tracking (prevents memory leaks)
+- Main thread for UI operations
+- Background thread for event emission
+
+### Performance
+
+Target performance budgets:
+- Touch event processing: < 5ms
+- Semantic extraction: < 10ms
+- Dead click snapshot: < 15ms
+
+Actual overhead is minimal and should not be noticeable in production apps.
+
+### Memory Management
+
+- `WeakReference` for Activity tracking (prevents leaks)
+- `WeakHashMap` for window interceptors (auto-cleanup)
+- Automatic cleanup on Activity pause
+- No persistent state across sessions
+
+## Migration from Manual Tracking
+
+If you're currently using manual `track()` calls for clicks, you can gradually migrate:
+
+1. Enable autocapture alongside existing tracking
+2. Compare event counts in dashboard
+3. Set meaningful `contentDescription` or resource IDs for important elements
+4. Identify and remove redundant manual `track()` calls
+5. Keep manual tracking for business-specific events
+
+## Example Integration
+
+### Application Class
+
+```kotlin
+// Kotlin
+class MyApplication : Application() {
+    override fun onCreate() {
+        super.onCreate()
+
+        val autocaptureOptions = AutocaptureOptions.Builder().build()
+
+        val options = MixpanelOptions.Builder()
+            .autocaptureOptions(autocaptureOptions)
+            .build()
+
+        val mixpanel = MixpanelAPI.getInstance(
+            this,
+            "YOUR_PROJECT_TOKEN",
+            true,  // trackAutomaticEvents
+            options
+        )
+
+        mixpanel.setEnableLogging(BuildConfig.DEBUG)
+    }
+}
+```
+
+```java
+// Java
+public class MyApplication extends Application {
+    @Override
+    public void onCreate() {
+        super.onCreate();
+
+        AutocaptureOptions autocaptureOptions = new AutocaptureOptions.Builder().build();
+
+        MixpanelOptions options = new MixpanelOptions.Builder()
+            .autocaptureOptions(autocaptureOptions)
+            .build();
+
+        MixpanelAPI mixpanel = MixpanelAPI.getInstance(
+            this,
+            "YOUR_PROJECT_TOKEN",
+            true,  // trackAutomaticEvents
+            options
+        );
+
+        mixpanel.setEnableLogging(BuildConfig.DEBUG);
+    }
+}
+```
+
+### AndroidManifest.xml
+
+```xml
+<application
+    android:name=".MyApplication"
+    ...>
+```
+
+## FAQ
+
+**Does autocapture work with custom Views?**
+
+Yes! Custom Views are tracked like any other View. Set `contentDescription` or a meaningful resource ID for proper identification.
+
+**Does autocapture impact app performance?**
+
+The overhead is minimal (< 5ms per touch). Touch interception is non-blocking and runs on the main thread with minimal processing.
+
+**Can I disable autocapture at runtime?**
+
+Autocapture is configured at SDK initialization and cannot be toggled at runtime. To disable it, don't pass `AutocaptureOptions` to `MixpanelOptions`.
+
+**Does autocapture work in app extensions?**
+
+No, autocapture is automatically disabled in app extensions to avoid unexpected behavior.
+
+**How does autocapture handle ProGuard/R8?**
+
+The SDK includes necessary ProGuard rules. If you're using ProGuard/R8, ensure your configuration includes the SDK's rules (automatically applied when using AGP 3.0+).
+
+**Can I capture custom properties with autocapture events?**
+
+Autocapture events have predefined properties. For custom properties, continue using manual `track()` calls.
+
+## Learn More
+
+- [Mixpanel Android SDK Documentation](https://mixpanel.com/help/reference/android)
+- [Javadoc Reference](http://mixpanel.github.io/mixpanel-android/)
+- [GitHub Repository](https://github.com/mixpanel/mixpanel-android)
+- [Sample App](https://github.com/mixpanel/mixpanel-android/tree/master/analytics/mixpaneldemo)
diff --git a/analytics/mixpaneldemo/build.gradle.kts b/analytics/mixpaneldemo/build.gradle.kts
index aeeb5f1e9..068ccf4f5 100644
--- a/analytics/mixpaneldemo/build.gradle.kts
+++ b/analytics/mixpaneldemo/build.gradle.kts
@@ -57,6 +57,8 @@ dependencies {
     implementation("androidx.core:core-ktx:1.13.1")
     implementation("androidx.lifecycle:lifecycle-runtime-ktx:2.8.4")
     implementation("androidx.activity:activity-compose:1.9.1")
+    implementation("androidx.appcompat:appcompat:1.7.0")
+    implementation("com.google.android.material:material:1.12.0")
     implementation(platform("androidx.compose:compose-bom:2024.12.01"))
     implementation("androidx.compose.ui:ui")
     implementation("androidx.compose.ui:ui-graphics")
diff --git a/analytics/mixpaneldemo/src/main/AndroidManifest.xml b/analytics/mixpaneldemo/src/main/AndroidManifest.xml
index 1b081d496..6c4386391 100644
--- a/analytics/mixpaneldemo/src/main/AndroidManifest.xml
+++ b/analytics/mixpaneldemo/src/main/AndroidManifest.xml
@@ -2,6 +2,7 @@
 <manifest xmlns:android="http://schemas.android.com/apk/res/android">
 
     <application
+        android:name=".DemoApplication"
         android:allowBackup="true"
         android:icon="@mipmap/ic_launcher"
         android:label="@string/app_name"
@@ -19,6 +20,12 @@
                 <category android:name="android.intent.category.LAUNCHER" />
             </intent-filter>
         </activity>
+
+        <activity
+            android:name=".XmlAutocaptureTestActivity"
+            android:exported="false"
+            android:label="XML Autocapture Test"
+            android:theme="@style/Theme.AppCompat.Light.DarkActionBar" />
     </application>
 
 </manifest>
\ No newline at end of file
diff --git a/analytics/mixpaneldemo/src/main/java/com/mixpanel/mixpaneldemo/ComposeAutocaptureTestScreen.kt b/analytics/mixpaneldemo/src/main/java/com/mixpanel/mixpaneldemo/ComposeAutocaptureTestScreen.kt
new file mode 100644
index 000000000..b736ba066
--- /dev/null
+++ b/analytics/mixpaneldemo/src/main/java/com/mixpanel/mixpaneldemo/ComposeAutocaptureTestScreen.kt
@@ -0,0 +1,513 @@
+package com.mixpanel.mixpaneldemo
+
+import android.content.Intent
+import android.widget.LinearLayout
+import android.widget.TextView
+import androidx.compose.foundation.background
+import androidx.compose.foundation.clickable
+import androidx.compose.foundation.layout.*
+import androidx.compose.foundation.lazy.LazyColumn
+import androidx.compose.foundation.shape.RoundedCornerShape
+import androidx.compose.material.icons.Icons
+import androidx.compose.material.icons.automirrored.filled.ArrowBack
+import androidx.compose.material3.*
+import androidx.compose.runtime.*
+import androidx.compose.ui.Alignment
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.draw.clip
+import androidx.compose.ui.graphics.Color
+import androidx.compose.ui.platform.LocalContext
+import androidx.compose.ui.platform.testTag
+import androidx.compose.ui.semantics.contentDescription
+import androidx.compose.ui.semantics.semantics
+import androidx.compose.ui.text.input.PasswordVisualTransformation
+import androidx.compose.ui.unit.dp
+import androidx.compose.ui.unit.sp
+import androidx.compose.ui.viewinterop.AndroidView
+import androidx.navigation.NavHostController
+import kotlinx.coroutines.launch
+
+/**
+ * Jetpack Compose Autocapture Test Screen
+ *
+ * Tests $mp_click, $mp_rage_click, and $mp_dead_click on Compose elements,
+ * and verifies $el_id resolution via Compose's accessibility semantics:
+ * 1. semantics { contentDescription } (if non-empty)
+ * 2. testTag / resource ID mapping
+ * 3. ClassName_view_<hashCode>
+ */
+@OptIn(ExperimentalMaterial3Api::class)
+@Composable
+fun ComposeAutocaptureTestScreen(navController: NavHostController) {
+    val context = LocalContext.current
+    var tapCount by remember { mutableIntStateOf(0) }
+    var switchOn by remember { mutableStateOf(false) }
+    var textValue by remember { mutableStateOf("") }
+    var passwordValue by remember { mutableStateOf("") }
+    var sliderValue by remember { mutableFloatStateOf(0.5f) }
+    var showAlertDialog by remember { mutableStateOf(false) }
+    var showBottomSheet by remember { mutableStateOf(false) }
+    var showDropdownMenu by remember { mutableStateOf(false) }
+    var snackbarHostState = remember { SnackbarHostState() }
+    val coroutineScope = rememberCoroutineScope()
+
+    Scaffold(
+        snackbarHost = { SnackbarHost(snackbarHostState) },
+        topBar = {
+            TopAppBar(
+                title = { Text("Compose Autocapture Test") },
+                navigationIcon = {
+                    IconButton(onClick = { navController.popBackStack() }) {
+                        Icon(Icons.AutoMirrored.Filled.ArrowBack, contentDescription = "Back")
+                    }
+                }
+            )
+        }
+    ) { innerPadding ->
+        LazyColumn(
+            contentPadding = PaddingValues(
+                start = 16.dp,
+                end = 16.dp,
+                top = innerPadding.calculateTopPadding() + 16.dp,
+                bottom = 32.dp
+            ),
+            verticalArrangement = Arrangement.spacedBy(8.dp)
+        ) {
+            // $el_id Resolution
+            item { SectionHeader("\$el_id Resolution") }
+
+            item {
+                Button(
+                    onClick = { },
+                    modifier = Modifier
+                        .fillMaxWidth()
+                        .semantics { contentDescription = "compose_rule1" }
+                ) {
+                    Text("Rule 1 - semantics contentDescription")
+                }
+            }
+
+            item {
+                Button(
+                    onClick = { },
+                    modifier = Modifier
+                        .fillMaxWidth()
+                        .testTag("compose_rule2_btn")
+                    // No contentDescription
+                ) {
+                    Text("Rule 2 - testTag (no contentDescription)")
+                }
+            }
+
+            item {
+                Button(
+                    onClick = { },
+                    modifier = Modifier.fillMaxWidth()
+                    // No semantics at all
+                ) {
+                    Text("Rule 3 - No semantics (hash fallback)")
+                }
+            }
+
+            item {
+                Button(
+                    onClick = { },
+                    modifier = Modifier
+                        .fillMaxWidth()
+                        .semantics { contentDescription = "compose_desc_wins" }
+                        .testTag("ignored_tag")
+                ) {
+                    Text("Rule 1 Wins - contentDescription + testTag")
+                }
+            }
+
+            item {
+                Box(
+                    modifier = Modifier
+                        .fillMaxWidth()
+                        .height(48.dp)
+                        .background(Color.Blue.copy(alpha = 0.1f))
+                        .clickable { }
+                        .semantics { contentDescription = "compose_box" },
+                    contentAlignment = Alignment.Center
+                ) {
+                    Text("Clickable Box (non-Button)")
+                }
+            }
+
+            // Dead Click
+            item { SectionHeader("Dead Click") }
+
+            item {
+                Button(
+                    onClick = { }, // Empty - no UI change, only ripple
+                    modifier = Modifier
+                        .fillMaxWidth()
+                        .semantics { contentDescription = "compose_dead_btn" }
+                ) {
+                    Text("Dead Button (ripple only) -> \$mp_dead_click")
+                }
+            }
+
+            // Rage Click
+            item { SectionHeader("Rage Click - tap 4+ times") }
+
+            item {
+                Button(
+                    onClick = { }, // Does nothing visible
+                    modifier = Modifier
+                        .fillMaxWidth()
+                        .height(80.dp)
+                        .semantics { contentDescription = "compose_rage_btn" },
+                    colors = ButtonDefaults.buttonColors(
+                        containerColor = Color.Red.copy(alpha = 0.3f)
+                    )
+                ) {
+                    Text("Rage Zone - tap rapidly")
+                }
+            }
+
+            item {
+                Button(
+                    onClick = { tapCount++ },
+                    modifier = Modifier
+                        .fillMaxWidth()
+                        .semantics { contentDescription = "compose_rage_click_btn" }
+                ) {
+                    Text("Click + Rage - tap 4x (both events): ${tapCount}x")
+                }
+            }
+
+            // Excluded Controls
+            item { SectionHeader("Excluded Controls (no dead click)") }
+
+            item {
+                Row(
+                    modifier = Modifier.fillMaxWidth(),
+                    horizontalArrangement = Arrangement.SpaceBetween,
+                    verticalAlignment = Alignment.CenterVertically
+                ) {
+                    Text("Switch - no dead click")
+                    Switch(checked = switchOn, onCheckedChange = { switchOn = it })
+                }
+            }
+
+            item {
+                OutlinedTextField(
+                    value = textValue,
+                    onValueChange = { textValue = it },
+                    label = { Text("TextField - no dead click, text not captured") },
+                    modifier = Modifier.fillMaxWidth()
+                )
+            }
+
+            item {
+                OutlinedTextField(
+                    value = passwordValue,
+                    onValueChange = { passwordValue = it },
+                    label = { Text("Password") },
+                    visualTransformation = PasswordVisualTransformation(),
+                    modifier = Modifier.fillMaxWidth()
+                )
+            }
+
+            item {
+                Column(modifier = Modifier.fillMaxWidth()) {
+                    Slider(value = sliderValue, onValueChange = { sliderValue = it })
+                    Text(
+                        "Slider - no dead click (value: ${(sliderValue * 100).toInt()}%)",
+                        style = MaterialTheme.typography.bodySmall
+                    )
+                }
+            }
+
+            // Multi-Window / Overlay
+            item { SectionHeader("Multi-Window / Overlay") }
+
+            item {
+                Button(
+                    onClick = { showAlertDialog = true },
+                    modifier = Modifier
+                        .fillMaxWidth()
+                        .semantics { contentDescription = "compose_alert_trigger" }
+                ) {
+                    Text("Show AlertDialog")
+                }
+            }
+
+            item {
+                Button(
+                    onClick = { showBottomSheet = true },
+                    modifier = Modifier
+                        .fillMaxWidth()
+                        .semantics { contentDescription = "compose_bottomsheet_trigger" }
+                ) {
+                    Text("Show Bottom Sheet")
+                }
+            }
+
+            item {
+                Box {
+                    Button(
+                        onClick = { showDropdownMenu = true },
+                        modifier = Modifier
+                            .fillMaxWidth()
+                            .semantics { contentDescription = "compose_dropdown_trigger" }
+                    ) {
+                        Text("Show Dropdown Menu")
+                    }
+                    DropdownMenu(
+                        expanded = showDropdownMenu,
+                        onDismissRequest = { showDropdownMenu = false }
+                    ) {
+                        DropdownMenuItem(
+                            text = { Text("Option 1") },
+                            onClick = { showDropdownMenu = false },
+                            modifier = Modifier.semantics { contentDescription = "compose_dropdown_option_1" }
+                        )
+                        DropdownMenuItem(
+                            text = { Text("Option 2") },
+                            onClick = { showDropdownMenu = false },
+                            modifier = Modifier.semantics { contentDescription = "compose_dropdown_option_2" }
+                        )
+                        DropdownMenuItem(
+                            text = { Text("Option 3") },
+                            onClick = { showDropdownMenu = false },
+                            modifier = Modifier.semantics { contentDescription = "compose_dropdown_option_3" }
+                        )
+                    }
+                }
+            }
+
+            item {
+                Button(
+                    onClick = {
+                        coroutineScope.launch {
+                            snackbarHostState.showSnackbar(
+                                message = "Snackbar message",
+                                actionLabel = "Dismiss"
+                            )
+                        }
+                    },
+                    modifier = Modifier
+                        .fillMaxWidth()
+                        .semantics { contentDescription = "compose_snackbar_trigger" }
+                ) {
+                    Text("Show Snackbar")
+                }
+            }
+
+            // Mixed Framework Dead Click Tests
+            item { SectionHeader("Mixed Framework Dead Click Tests") }
+
+            item {
+                Text(
+                    "None of these should trigger \$mp_dead_click",
+                    style = MaterialTheme.typography.bodySmall
+                )
+            }
+
+            item {
+                val composeCounter = remember { mutableIntStateOf(0) }
+                var xmlCounter by remember { mutableIntStateOf(0) }
+
+                Column(
+                    modifier = Modifier.fillMaxWidth(),
+                    verticalArrangement = Arrangement.spacedBy(8.dp)
+                ) {
+                    // XML elements (Cases 1 & 2) inside AndroidView with orange background
+                    AndroidView(
+                        modifier = Modifier
+                            .fillMaxWidth()
+                            .clip(RoundedCornerShape(8.dp))
+                            .background(Color(0xFFFFF3E0)),
+                        factory = { ctx ->
+                            LinearLayout(ctx).apply {
+                                orientation = LinearLayout.VERTICAL
+                                val dp16 = (16 * ctx.resources.displayMetrics.density).toInt()
+                                val dp8 = (8 * ctx.resources.displayMetrics.density).toInt()
+                                setPadding(dp16, dp16, dp16, dp16)
+
+                                val xmlTextCounter = TextView(ctx).apply {
+                                    text = "XML counter: 0"
+                                    textSize = 16f
+                                    setPadding(0, dp8, 0, 0)
+                                    this.contentDescription = "xml_text_counter"
+                                }
+
+                                // Case 1: XML Button -> XML Text
+                                val xmlBtnXmlText = android.widget.Button(ctx).apply {
+                                    text = "1. XML Btn -> XML Text"
+                                    this.contentDescription = "xml_btn_xml_text"
+                                    setOnClickListener {
+                                        xmlCounter++
+                                        xmlTextCounter.text = "XML counter: $xmlCounter"
+                                    }
+                                }
+                                addView(xmlBtnXmlText, LinearLayout.LayoutParams(
+                                    LinearLayout.LayoutParams.MATCH_PARENT,
+                                    LinearLayout.LayoutParams.WRAP_CONTENT
+                                ))
+
+                                addView(xmlTextCounter, LinearLayout.LayoutParams(
+                                    LinearLayout.LayoutParams.MATCH_PARENT,
+                                    LinearLayout.LayoutParams.WRAP_CONTENT
+                                ))
+
+                                // Case 2: XML Button -> Compose Text
+                                val xmlBtnComposeText = android.widget.Button(ctx).apply {
+                                    text = "2. XML Btn -> Compose Text"
+                                    this.contentDescription = "xml_btn_compose_text"
+                                    layoutParams = LinearLayout.LayoutParams(
+                                        LinearLayout.LayoutParams.MATCH_PARENT,
+                                        LinearLayout.LayoutParams.WRAP_CONTENT
+                                    ).apply { topMargin = dp8 }
+                                    setOnClickListener {
+                                        composeCounter.intValue++
+                                    }
+                                }
+                                addView(xmlBtnComposeText)
+                            }
+                        }
+                    )
+
+                    // Case 3: Compose Button -> XML Text
+                    Button(
+                        onClick = {
+                            xmlCounter++
+                        },
+                        modifier = Modifier
+                            .fillMaxWidth()
+                            .semantics { contentDescription = "compose_btn_xml_text" }
+                    ) {
+                        Text("3. Compose Btn -> XML Text")
+                    }
+
+                    // XML text updated by Compose button (Case 3)
+                    AndroidView(
+                        modifier = Modifier.fillMaxWidth(),
+                        factory = { ctx ->
+                            TextView(ctx).apply {
+                                this.contentDescription = "xml_text_from_compose"
+                            }
+                        },
+                        update = { textView ->
+                            textView.text = "XML counter (from Compose): $xmlCounter"
+                        }
+                    )
+
+                    // Case 4: Compose Button -> Compose Text
+                    Button(
+                        onClick = {
+                            composeCounter.intValue++
+                        },
+                        modifier = Modifier
+                            .fillMaxWidth()
+                            .semantics { contentDescription = "compose_btn_compose_text" }
+                    ) {
+                        Text("4. Compose Btn -> Compose Text")
+                    }
+
+                    // Compose text counter (updated by cases 2 & 4)
+                    Text(
+                        text = "Compose counter: ${composeCounter.intValue}",
+                        modifier = Modifier.semantics { contentDescription = "compose_text_counter" }
+                    )
+                }
+            }
+
+            // Navigate to XML Test
+            item { SectionHeader("XML Views Test") }
+
+            item {
+                Button(
+                    onClick = {
+                        context.startActivity(Intent(context, XmlAutocaptureTestActivity::class.java))
+                    },
+                    modifier = Modifier.fillMaxWidth(),
+                    colors = ButtonDefaults.buttonColors(containerColor = Color(0xFF4CAF50))
+                ) {
+                    Text("Open XML Test Activity")
+                }
+            }
+        }
+
+        if (showAlertDialog) {
+            AlertDialog(
+                onDismissRequest = { showAlertDialog = false },
+                title = { Text("Test Alert Dialog") },
+                text = { Text("Tap buttons inside this dialog to test autocapture") },
+                confirmButton = {
+                    TextButton(
+                        onClick = { showAlertDialog = false },
+                        modifier = Modifier.semantics { contentDescription = "compose_alert_confirm" }
+                    ) {
+                        Text("Confirm")
+                    }
+                },
+                dismissButton = {
+                    TextButton(
+                        onClick = { showAlertDialog = false },
+                        modifier = Modifier.semantics { contentDescription = "compose_alert_cancel" }
+                    ) {
+                        Text("Cancel")
+                    }
+                }
+            )
+        }
+
+        if (showBottomSheet) {
+            ModalBottomSheet(
+                onDismissRequest = { showBottomSheet = false }
+            ) {
+                Column(modifier = Modifier.padding(16.dp)) {
+                    Button(
+                        onClick = { },
+                        modifier = Modifier
+                            .fillMaxWidth()
+                            .semantics { contentDescription = "compose_sheet_action_1" }
+                    ) {
+                        Text("Bottom Sheet Action 1")
+                    }
+                    Spacer(modifier = Modifier.height(8.dp))
+                    Button(
+                        onClick = { },
+                        modifier = Modifier
+                            .fillMaxWidth()
+                            .semantics { contentDescription = "compose_sheet_action_2" }
+                    ) {
+                        Text("Bottom Sheet Action 2")
+                    }
+                    Spacer(modifier = Modifier.height(8.dp))
+                    Button(
+                        onClick = { },
+                        modifier = Modifier
+                            .fillMaxWidth()
+                            .semantics { contentDescription = "compose_sheet_action_3" }
+                    ) {
+                        Text("Bottom Sheet Action 3")
+                    }
+                    Spacer(modifier = Modifier.height(8.dp))
+                    Button(
+                        onClick = { showBottomSheet = false },
+                        modifier = Modifier.fillMaxWidth()
+                    ) {
+                        Text("Close")
+                    }
+                }
+            }
+        }
+    }
+}
+
+@Composable
+private fun SectionHeader(text: String) {
+    Column(modifier = Modifier.padding(top = 8.dp)) {
+        Text(
+            text = text.uppercase(),
+            style = MaterialTheme.typography.labelSmall,
+            color = MaterialTheme.colorScheme.secondary
+        )
+        HorizontalDivider(modifier = Modifier.padding(top = 4.dp))
+    }
+}
diff --git a/analytics/mixpaneldemo/src/main/java/com/mixpanel/mixpaneldemo/DemoApplication.kt b/analytics/mixpaneldemo/src/main/java/com/mixpanel/mixpaneldemo/DemoApplication.kt
new file mode 100644
index 000000000..d95609ed3
--- /dev/null
+++ b/analytics/mixpaneldemo/src/main/java/com/mixpanel/mixpaneldemo/DemoApplication.kt
@@ -0,0 +1,24 @@
+package com.mixpanel.mixpaneldemo
+
+import android.app.Application
+import com.mixpanel.android.autocapture.ClickEvent
+import com.mixpanel.android.mpmetrics.AutocaptureOptions
+import com.mixpanel.android.mpmetrics.MixpanelAPI
+import com.mixpanel.android.mpmetrics.MixpanelOptions
+
+class DemoApplication : Application() {
+    override fun onCreate() {
+        super.onCreate()
+
+        // Initialize Mixpanel with autocapture enabled
+        val autocaptureOptions = AutocaptureOptions.Builder().build()
+
+        val options = MixpanelOptions.Builder()
+            .autocaptureOptions(autocaptureOptions)
+            .build()
+
+        val mixpanel = MixpanelAPI.getInstance(this, MIXPANEL_PROJECT_TOKEN, true, options)
+        mixpanel.setEnableLogging(true)
+
+    }
+}
diff --git a/analytics/mixpaneldemo/src/main/java/com/mixpanel/mixpaneldemo/LandingPage.kt b/analytics/mixpaneldemo/src/main/java/com/mixpanel/mixpaneldemo/LandingPage.kt
index b4f67659a..dbdf36d41 100644
--- a/analytics/mixpaneldemo/src/main/java/com/mixpanel/mixpaneldemo/LandingPage.kt
+++ b/analytics/mixpaneldemo/src/main/java/com/mixpanel/mixpaneldemo/LandingPage.kt
@@ -74,6 +74,15 @@ fun LandingPage(navController: NavHostController) {
             ) {
                 Text("Groups")
             }
+            Button(
+                onClick = { navController.navigate("autocaptureTestPage") },
+                modifier = Modifier
+                    .fillMaxWidth()
+                    .padding(vertical = 8.dp),
+                colors = ButtonDefaults.buttonColors(containerColor = Color(red = 76, green = 175, blue = 80)),
+            ) {
+                Text("Autocapture Test")
+            }
         }
     }
 }
\ No newline at end of file
diff --git a/analytics/mixpaneldemo/src/main/java/com/mixpanel/mixpaneldemo/NavGraph.kt b/analytics/mixpaneldemo/src/main/java/com/mixpanel/mixpaneldemo/NavGraph.kt
index 96550d9be..77f18d4f4 100644
--- a/analytics/mixpaneldemo/src/main/java/com/mixpanel/mixpaneldemo/NavGraph.kt
+++ b/analytics/mixpaneldemo/src/main/java/com/mixpanel/mixpaneldemo/NavGraph.kt
@@ -19,5 +19,6 @@ fun NavGraph(navController: NavHostController, modifier: Modifier = Modifier) {
         composable("utilityPage") { UtilityPage(navController) }
         composable("gdprPage") { GDPRPage(navController) }
         composable("groupsPage") { GroupsPage(navController) }
+        composable("autocaptureTestPage") { ComposeAutocaptureTestScreen(navController) }
     }
 }
diff --git a/analytics/mixpaneldemo/src/main/java/com/mixpanel/mixpaneldemo/XmlAutocaptureTestActivity.kt b/analytics/mixpaneldemo/src/main/java/com/mixpanel/mixpaneldemo/XmlAutocaptureTestActivity.kt
new file mode 100644
index 000000000..2dae7edcb
--- /dev/null
+++ b/analytics/mixpaneldemo/src/main/java/com/mixpanel/mixpaneldemo/XmlAutocaptureTestActivity.kt
@@ -0,0 +1,230 @@
+package com.mixpanel.mixpaneldemo
+
+import android.os.Bundle
+import android.view.View
+import android.widget.Button
+import android.widget.ImageView
+import android.widget.LinearLayout
+import android.widget.PopupMenu
+import android.widget.TextView
+import androidx.appcompat.app.AlertDialog
+import androidx.appcompat.app.AppCompatActivity
+import androidx.compose.foundation.background
+import androidx.compose.foundation.layout.Column
+import androidx.compose.foundation.layout.fillMaxWidth
+import androidx.compose.foundation.layout.padding
+import androidx.compose.foundation.shape.RoundedCornerShape
+import androidx.compose.material3.Button
+import androidx.compose.material3.Text
+import androidx.compose.runtime.mutableIntStateOf
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.draw.clip
+import androidx.compose.ui.graphics.Color
+import androidx.compose.ui.platform.ComposeView
+import androidx.compose.ui.semantics.contentDescription
+import androidx.compose.ui.semantics.semantics
+import androidx.compose.ui.unit.dp
+import androidx.compose.ui.unit.sp
+import com.google.android.material.bottomsheet.BottomSheetDialog
+
+/**
+ * XML Views Autocapture Test Screen
+ *
+ * Tests $mp_click, $mp_rage_click, and $mp_dead_click on traditional XML View elements,
+ * and verifies $el_id resolution across all three Android rules:
+ * 1. contentDescription (if non-empty)
+ * 2. Resource ID name (R.id.xxx)
+ * 3. ClassName_view_<hashCode>
+ */
+class XmlAutocaptureTestActivity : AppCompatActivity() {
+
+    private var tapCount = 0
+    private var xmlCounter = 0
+    private val composeCounter = mutableIntStateOf(0)
+
+    override fun onCreate(savedInstanceState: Bundle?) {
+        super.onCreate(savedInstanceState)
+        setContentView(R.layout.activity_xml_autocapture_test)
+        title = "XML Autocapture Test"
+
+        setupElIdResolutionTests()
+        setupRageClickTests()
+        setupPrivacyTests()
+        setupMultiWindowTests()
+        setupComposeInXmlTests()
+    }
+
+    private fun setupElIdResolutionTests() {
+        // Rule 1 - contentDescription set in XML (rule1_btn)
+        findViewById<Button>(R.id.rule1_btn).setOnClickListener {
+            // Click action - shows $mp_click
+        }
+
+        // Rule 2 - resource ID name, no contentDescription (rule2_btn)
+        findViewById<Button>(R.id.rule2_btn).setOnClickListener {
+            // Click action - shows $mp_click
+        }
+
+        // Rule 3 - remove contentDescription programmatically for hash fallback
+        val rule3Btn = findViewById<Button>(R.id.rule3_btn)
+        rule3Btn.contentDescription = null
+        rule3Btn.setOnClickListener {
+            // Click action - shows $mp_click with hash-based $el_id
+        }
+
+        // Rule 1 wins over Rule 2 (has both contentDescription and ID)
+        findViewById<Button>(R.id.also_has_id).setOnClickListener {
+            // Click action - $el_id should be "desc_wins"
+        }
+
+        // Clickable container (non-button)
+        findViewById<LinearLayout>(R.id.custom_layout).setOnClickListener {
+            // Click action
+        }
+
+        // ImageView with click listener
+        findViewById<ImageView>(R.id.tap_image).setOnClickListener {
+            // Click action
+        }
+    }
+
+    private fun setupRageClickTests() {
+        // Dead button - intentionally NO listener
+        // R.id.dead_xml_btn has no setOnClickListener - should trigger $mp_dead_click
+
+        // Rage zone - listener that produces no UI change
+        findViewById<View>(R.id.rage_zone).setOnClickListener {
+            // Does nothing visible - good for rage click testing
+        }
+
+        // Rage + Click - updates counter TextView (UI change)
+        val tapCounter = findViewById<TextView>(R.id.tap_counter)
+        findViewById<Button>(R.id.rage_and_click_btn).setOnClickListener {
+            tapCount++
+            tapCounter.text = "Tap count: $tapCount"
+            // Each tap: $mp_click
+            // 4th+ tap within 1s: also $mp_rage_click
+        }
+    }
+
+    private fun setupPrivacyTests() {
+    }
+
+    private fun setupComposeInXmlTests() {
+        val xmlTextCounter = findViewById<TextView>(R.id.xml_text_counter)
+
+        // Case 1: XML Button -> XML Text
+        findViewById<android.widget.Button>(R.id.xml_btn_xml_text).setOnClickListener {
+            xmlCounter++
+            xmlTextCounter.text = "XML counter: $xmlCounter"
+        }
+
+        // Case 2: XML Button -> Compose Text
+        findViewById<android.widget.Button>(R.id.xml_btn_compose_text).setOnClickListener {
+            composeCounter.intValue++
+        }
+
+        // Cases 3 & 4 are Compose buttons inside the ComposeView
+        findViewById<ComposeView>(R.id.compose_click_counter).setContent {
+            Column(
+                modifier = Modifier
+                    .fillMaxWidth()
+                    .clip(RoundedCornerShape(8.dp))
+                    .background(Color(0xFFE8F5E9))
+                    .padding(16.dp)
+            ) {
+                // Case 3: Compose Button -> XML Text
+                Button(
+                    onClick = {
+                        xmlCounter++
+                        xmlTextCounter.text = "XML counter: $xmlCounter"
+                    },
+                    modifier = Modifier
+                        .fillMaxWidth()
+                        .semantics { contentDescription = "compose_btn_xml_text" }
+                ) {
+                    Text("3. Compose Btn -> XML Text")
+                }
+
+                // Case 4: Compose Button -> Compose Text
+                Button(
+                    onClick = { composeCounter.intValue++ },
+                    modifier = Modifier
+                        .fillMaxWidth()
+                        .padding(top = 8.dp)
+                        .semantics { contentDescription = "compose_btn_compose_text" }
+                ) {
+                    Text("4. Compose Btn -> Compose Text")
+                }
+
+                // Compose text counter (updated by cases 2 & 4)
+                Text(
+                    text = "Compose counter: ${composeCounter.intValue}",
+                    fontSize = 16.sp,
+                    modifier = Modifier
+                        .padding(top = 8.dp)
+                        .semantics { contentDescription = "compose_text_counter" }
+                )
+            }
+        }
+    }
+
+    private fun setupMultiWindowTests() {
+        // AlertDialog
+        findViewById<Button>(R.id.show_alert_dialog_btn).setOnClickListener {
+            val dialog = AlertDialog.Builder(this)
+                .setTitle("Test Alert Dialog")
+                .setMessage("Tap buttons inside this dialog")
+                .setPositiveButton("Confirm", null)
+                .setNegativeButton("Cancel", null)
+                .show()
+
+            dialog.getButton(AlertDialog.BUTTON_POSITIVE)?.contentDescription = "xml_alert_confirm"
+            dialog.getButton(AlertDialog.BUTTON_NEGATIVE)?.contentDescription = "xml_alert_cancel"
+        }
+
+        // BottomSheetDialog
+        findViewById<Button>(R.id.show_bottom_sheet_btn).setOnClickListener {
+            val bottomSheet = BottomSheetDialog(this)
+
+            val layout = LinearLayout(this).apply {
+                orientation = LinearLayout.VERTICAL
+                setPadding(48, 48, 48, 48)
+            }
+
+            val layoutParams = LinearLayout.LayoutParams(
+                LinearLayout.LayoutParams.MATCH_PARENT,
+                LinearLayout.LayoutParams.WRAP_CONTENT
+            ).apply {
+                topMargin = 16
+            }
+
+            for (i in 1..3) {
+                val btn = Button(this).apply {
+                    text = "Bottom Sheet Action $i"
+                    contentDescription = "xml_sheet_action_$i"
+                }
+                layout.addView(btn, layoutParams)
+            }
+
+            val closeBtn = Button(this).apply {
+                text = "Close"
+                contentDescription = "xml_sheet_close"
+                setOnClickListener { bottomSheet.dismiss() }
+            }
+            layout.addView(closeBtn, layoutParams)
+
+            bottomSheet.setContentView(layout)
+            bottomSheet.show()
+        }
+
+        // PopupMenu
+        findViewById<Button>(R.id.show_popup_menu_btn).setOnClickListener { anchor ->
+            val popup = PopupMenu(this, anchor)
+            popup.menu.add(0, 1, 0, "Option 1")
+            popup.menu.add(0, 2, 1, "Option 2")
+            popup.menu.add(0, 3, 2, "Option 3")
+            popup.show()
+        }
+    }
+}
diff --git a/analytics/mixpaneldemo/src/main/res/layout/activity_xml_autocapture_test.xml b/analytics/mixpaneldemo/src/main/res/layout/activity_xml_autocapture_test.xml
new file mode 100644
index 000000000..2032e8bd2
--- /dev/null
+++ b/analytics/mixpaneldemo/src/main/res/layout/activity_xml_autocapture_test.xml
@@ -0,0 +1,324 @@
+<?xml version="1.0" encoding="utf-8"?>
+<ScrollView xmlns:android="http://schemas.android.com/apk/res/android"
+    android:layout_width="match_parent"
+    android:layout_height="match_parent">
+
+    <LinearLayout
+        android:layout_width="match_parent"
+        android:layout_height="wrap_content"
+        android:orientation="vertical"
+        android:padding="16dp">
+
+        <!-- $el_id Resolution -->
+        <TextView
+            android:layout_width="wrap_content"
+            android:layout_height="wrap_content"
+            android:text="$EL_ID RESOLUTION"
+            android:textStyle="bold"
+            android:textColor="@android:color/holo_blue_dark"
+            android:layout_marginTop="8dp"
+            android:layout_marginBottom="4dp" />
+
+        <View
+            android:layout_width="match_parent"
+            android:layout_height="1dp"
+            android:background="@android:color/darker_gray"
+            android:layout_marginBottom="8dp" />
+
+        <Button
+            android:id="@+id/rule1_btn"
+            android:layout_width="match_parent"
+            android:layout_height="wrap_content"
+            android:text="Rule 1 - contentDescription"
+            android:contentDescription="rule1_btn" />
+
+        <Button
+            android:id="@+id/rule2_btn"
+            android:layout_width="match_parent"
+            android:layout_height="wrap_content"
+            android:text="Rule 2 - resource ID name (no contentDescription)"
+            android:layout_marginTop="8dp" />
+
+        <Button
+            android:id="@+id/rule3_btn"
+            android:layout_width="match_parent"
+            android:layout_height="wrap_content"
+            android:text="Rule 3 - No ID, No Desc (hash fallback)"
+            android:layout_marginTop="8dp" />
+
+        <Button
+            android:id="@+id/also_has_id"
+            android:layout_width="match_parent"
+            android:layout_height="wrap_content"
+            android:text="Rule 1 Wins - contentDescription + ID"
+            android:contentDescription="desc_wins"
+            android:layout_marginTop="8dp" />
+
+        <LinearLayout
+            android:id="@+id/custom_layout"
+            android:layout_width="match_parent"
+            android:layout_height="48dp"
+            android:background="#1A0000FF"
+            android:clickable="true"
+            android:focusable="true"
+            android:contentDescription="custom_layout"
+            android:gravity="center"
+            android:layout_marginTop="8dp">
+
+            <TextView
+                android:layout_width="wrap_content"
+                android:layout_height="wrap_content"
+                android:text="Clickable Layout (non-button container)" />
+        </LinearLayout>
+
+        <ImageView
+            android:id="@+id/tap_image"
+            android:layout_width="48dp"
+            android:layout_height="48dp"
+            android:src="@android:drawable/star_on"
+            android:clickable="true"
+            android:focusable="true"
+            android:contentDescription="tap_image"
+            android:layout_marginTop="8dp" />
+
+        <!-- Dead Click -->
+        <TextView
+            android:layout_width="wrap_content"
+            android:layout_height="wrap_content"
+            android:text="DEAD CLICK"
+            android:textStyle="bold"
+            android:textColor="@android:color/holo_blue_dark"
+            android:layout_marginTop="16dp"
+            android:layout_marginBottom="4dp" />
+
+        <View
+            android:layout_width="match_parent"
+            android:layout_height="1dp"
+            android:background="@android:color/darker_gray"
+            android:layout_marginBottom="8dp" />
+
+        <Button
+            android:id="@+id/dead_xml_btn"
+            android:layout_width="match_parent"
+            android:layout_height="wrap_content"
+            android:text="Dead Button (no listener) -> $mp_dead_click"
+            android:contentDescription="dead_xml_btn" />
+
+        <!-- Rage Click -->
+        <TextView
+            android:layout_width="wrap_content"
+            android:layout_height="wrap_content"
+            android:text="RAGE CLICK - TAP 4+ TIMES"
+            android:textStyle="bold"
+            android:textColor="@android:color/holo_blue_dark"
+            android:layout_marginTop="16dp"
+            android:layout_marginBottom="4dp" />
+
+        <View
+            android:layout_width="match_parent"
+            android:layout_height="1dp"
+            android:background="@android:color/darker_gray"
+            android:layout_marginBottom="8dp" />
+
+        <View
+            android:id="@+id/rage_zone"
+            android:layout_width="match_parent"
+            android:layout_height="80dp"
+            android:background="#1AFF0000"
+            android:clickable="true"
+            android:focusable="true"
+            android:contentDescription="rage_zone" />
+
+        <TextView
+            android:layout_width="match_parent"
+            android:layout_height="wrap_content"
+            android:text="Tap the red zone above 4+ times rapidly"
+            android:textSize="12sp"
+            android:gravity="center"
+            android:layout_marginBottom="8dp" />
+
+        <Button
+            android:id="@+id/rage_and_click_btn"
+            android:layout_width="match_parent"
+            android:layout_height="wrap_content"
+            android:text="Click + Rage - tap 4x (both events)"
+            android:contentDescription="rage_and_click_btn" />
+
+        <TextView
+            android:id="@+id/tap_counter"
+            android:layout_width="match_parent"
+            android:layout_height="wrap_content"
+            android:text="Tap count: 0"
+            android:gravity="center"
+            android:layout_marginTop="4dp" />
+
+        <!-- Excluded Controls -->
+        <TextView
+            android:layout_width="wrap_content"
+            android:layout_height="wrap_content"
+            android:text="EXCLUDED CONTROLS (no dead click)"
+            android:textStyle="bold"
+            android:textColor="@android:color/holo_blue_dark"
+            android:layout_marginTop="16dp"
+            android:layout_marginBottom="4dp" />
+
+        <View
+            android:layout_width="match_parent"
+            android:layout_height="1dp"
+            android:background="@android:color/darker_gray"
+            android:layout_marginBottom="8dp" />
+
+        <LinearLayout
+            android:layout_width="match_parent"
+            android:layout_height="wrap_content"
+            android:orientation="horizontal"
+            android:gravity="center_vertical">
+
+            <TextView
+                android:layout_width="0dp"
+                android:layout_height="wrap_content"
+                android:layout_weight="1"
+                android:text="Switch - no dead click" />
+
+            <Switch
+                android:id="@+id/test_switch"
+                android:layout_width="wrap_content"
+                android:layout_height="wrap_content" />
+        </LinearLayout>
+
+        <EditText
+            android:layout_width="match_parent"
+            android:layout_height="wrap_content"
+            android:hint="EditText - no dead click, text not captured"
+            android:layout_marginTop="8dp" />
+
+        <EditText
+            android:id="@+id/test_password"
+            android:layout_width="match_parent"
+            android:layout_height="wrap_content"
+            android:hint="Password"
+            android:inputType="textPassword"
+            android:layout_marginTop="8dp" />
+
+        <SeekBar
+            android:id="@+id/test_seekbar"
+            android:layout_width="match_parent"
+            android:layout_height="wrap_content"
+            android:layout_marginTop="8dp" />
+
+        <TextView
+            android:layout_width="match_parent"
+            android:layout_height="wrap_content"
+            android:text="SeekBar - no dead click"
+            android:textSize="12sp"
+            android:gravity="center" />
+
+        <!-- Multi-Window / Overlay -->
+        <TextView
+            android:layout_width="wrap_content"
+            android:layout_height="wrap_content"
+            android:text="MULTI-WINDOW / OVERLAY"
+            android:textStyle="bold"
+            android:textColor="@android:color/holo_blue_dark"
+            android:layout_marginTop="16dp"
+            android:layout_marginBottom="4dp" />
+
+        <View
+            android:layout_width="match_parent"
+            android:layout_height="1dp"
+            android:background="@android:color/darker_gray"
+            android:layout_marginBottom="8dp" />
+
+        <Button
+            android:id="@+id/show_alert_dialog_btn"
+            android:layout_width="match_parent"
+            android:layout_height="wrap_content"
+            android:text="Show AlertDialog"
+            android:contentDescription="xml_alert_trigger" />
+
+        <Button
+            android:id="@+id/show_bottom_sheet_btn"
+            android:layout_width="match_parent"
+            android:layout_height="wrap_content"
+            android:text="Show BottomSheetDialog"
+            android:contentDescription="xml_bottomsheet_trigger"
+            android:layout_marginTop="8dp" />
+
+        <Button
+            android:id="@+id/show_popup_menu_btn"
+            android:layout_width="match_parent"
+            android:layout_height="wrap_content"
+            android:text="Show PopupMenu"
+            android:contentDescription="xml_popup_trigger"
+            android:layout_marginTop="8dp" />
+
+        <Spinner
+            android:id="@+id/test_spinner"
+            android:layout_width="match_parent"
+            android:layout_height="wrap_content"
+            android:contentDescription="xml_spinner"
+            android:entries="@array/spinner_options"
+            android:layout_marginTop="8dp" />
+
+        <!-- Mixed Framework Dead Click Tests -->
+        <TextView
+            android:layout_width="wrap_content"
+            android:layout_height="wrap_content"
+            android:text="MIXED FRAMEWORK DEAD CLICK TESTS"
+            android:textStyle="bold"
+            android:textColor="@android:color/holo_blue_dark"
+            android:layout_marginTop="16dp"
+            android:layout_marginBottom="4dp" />
+
+        <View
+            android:layout_width="match_parent"
+            android:layout_height="1dp"
+            android:background="@android:color/darker_gray"
+            android:layout_marginBottom="8dp" />
+
+        <TextView
+            android:layout_width="match_parent"
+            android:layout_height="wrap_content"
+            android:text="None of these should trigger $mp_dead_click"
+            android:textSize="12sp"
+            android:gravity="center"
+            android:layout_marginBottom="8dp" />
+
+        <!-- Case 1: XML Button -> XML Text -->
+        <Button
+            android:id="@+id/xml_btn_xml_text"
+            android:layout_width="match_parent"
+            android:layout_height="wrap_content"
+            android:text="1. XML Btn -> XML Text"
+            android:contentDescription="xml_btn_xml_text" />
+
+        <TextView
+            android:id="@+id/xml_text_counter"
+            android:layout_width="match_parent"
+            android:layout_height="wrap_content"
+            android:text="XML counter: 0"
+            android:gravity="center"
+            android:layout_marginTop="4dp" />
+
+        <!-- Case 2: XML Button -> Compose Text -->
+        <Button
+            android:id="@+id/xml_btn_compose_text"
+            android:layout_width="match_parent"
+            android:layout_height="wrap_content"
+            android:text="2. XML Btn -> Compose Text"
+            android:contentDescription="xml_btn_compose_text"
+            android:layout_marginTop="8dp" />
+
+        <!-- Cases 3 & 4 (Compose buttons) + Compose text counter -->
+        <androidx.compose.ui.platform.ComposeView
+            android:id="@+id/compose_click_counter"
+            android:layout_width="match_parent"
+            android:layout_height="wrap_content"
+            android:layout_marginTop="8dp" />
+
+        <View
+            android:layout_width="match_parent"
+            android:layout_height="32dp" />
+
+    </LinearLayout>
+</ScrollView>
diff --git a/analytics/mixpaneldemo/src/main/res/values/spinner_items.xml b/analytics/mixpaneldemo/src/main/res/values/spinner_items.xml
new file mode 100644
index 000000000..a02ec32be
--- /dev/null
+++ b/analytics/mixpaneldemo/src/main/res/values/spinner_items.xml
@@ -0,0 +1,8 @@
+<?xml version="1.0" encoding="utf-8"?>
+<resources>
+    <string-array name="spinner_options">
+        <item>Spinner Option 1</item>
+        <item>Spinner Option 2</item>
+        <item>Spinner Option 3</item>
+    </string-array>
+</resources>
diff --git a/analytics/proguard.txt b/analytics/proguard.txt
index f81203f97..18b66bd8d 100644
--- a/analytics/proguard.txt
+++ b/analytics/proguard.txt
@@ -1 +1 @@
--dontwarn com.mixpanel.**
\ No newline at end of file
+-dontwarn com.mixpanel.**
diff --git a/analytics/src/androidTest/AndroidManifest.xml b/analytics/src/androidTest/AndroidManifest.xml
index 748fda232..b4d2bbc1b 100644
--- a/analytics/src/androidTest/AndroidManifest.xml
+++ b/analytics/src/androidTest/AndroidManifest.xml
@@ -4,5 +4,11 @@
         <activity
             android:name="com.mixpanel.android.mpmetrics.TestActivity"
             android:exported="false" />
+        <activity
+            android:name="com.mixpanel.android.mpmetrics.AutocaptureXmlTestActivity"
+            android:exported="false" />
+        <activity
+            android:name="com.mixpanel.android.mpmetrics.AutocaptureComposeTestActivity"
+            android:exported="false" />
     </application>
 </manifest>
diff --git a/analytics/src/androidTest/java/com/mixpanel/android/mpmetrics/AutocaptureComposeInstrumentedTest.kt b/analytics/src/androidTest/java/com/mixpanel/android/mpmetrics/AutocaptureComposeInstrumentedTest.kt
new file mode 100644
index 000000000..3e68c66fd
--- /dev/null
+++ b/analytics/src/androidTest/java/com/mixpanel/android/mpmetrics/AutocaptureComposeInstrumentedTest.kt
@@ -0,0 +1,385 @@
+package com.mixpanel.android.mpmetrics
+
+import android.content.Context
+import android.content.SharedPreferences
+import android.os.SystemClock
+import android.view.MotionEvent
+import androidx.compose.ui.test.SemanticsNodeInteraction
+import androidx.compose.ui.test.junit4.createEmptyComposeRule
+import androidx.compose.ui.test.onNodeWithContentDescription
+import androidx.compose.ui.test.onNodeWithTag
+import androidx.compose.ui.test.onNodeWithText
+import androidx.test.core.app.ActivityScenario
+import androidx.test.ext.junit.runners.AndroidJUnit4
+import androidx.test.filters.LargeTest
+import androidx.test.platform.app.InstrumentationRegistry
+import org.json.JSONObject
+import org.junit.After
+import org.junit.Before
+import org.junit.Rule
+import org.junit.Test
+import org.junit.runner.RunWith
+import java.util.concurrent.BlockingQueue
+import java.util.concurrent.Future
+import java.util.concurrent.LinkedBlockingQueue
+import java.util.concurrent.TimeUnit
+
+/**
+ * Instrumentation tests for autocapture on Jetpack Compose UIs.
+ *
+ * Uses sendPointerSync for clicks because compose-ui-test's performTouchInput
+ * bypasses Window.Callback, which is where autocapture's touch interceptor lives.
+ * The compose test rule is used only to find element bounds.
+ */
+@RunWith(AndroidJUnit4::class)
+@LargeTest
+class AutocaptureComposeInstrumentedTest {
+
+    companion object {
+        private const val TEST_TOKEN = "COMPOSE_AUTOCAPTURE_TEST_TOKEN"
+    }
+
+    @get:Rule
+    val composeTestRule = createEmptyComposeRule()
+
+    private val mEvents: BlockingQueue<JSONObject> = LinkedBlockingQueue()
+    private lateinit var mMixpanel: MixpanelAPI
+    private lateinit var mMockAdapter: MPDbAdapter
+    private lateinit var mContext: Context
+    private var mDecorViewOffset = intArrayOf(0, 0)
+
+    @Before
+    fun setUp() {
+        mContext = InstrumentationRegistry.getInstrumentation().context
+
+        val messages = AnalyticsMessages.getInstance(
+            mContext,
+            MPConfig.getInstance(mContext, null)
+        )
+        messages.hardKill()
+        Thread.sleep(2000)
+
+        mEvents.clear()
+
+        val mockPreferences = TestUtils.EmptyPreferences(mContext)
+        val config = MPConfig.getInstance(mContext, null)
+
+        mMockAdapter = object : MPDbAdapter(mContext, config) {
+            override fun addJSON(message: JSONObject, token: String, table: Table): Int {
+                if (table == Table.EVENTS) {
+                    try {
+                        val eventName = message.optString("event", "")
+                        if (eventName.startsWith("\$mp_")) {
+                            mEvents.add(message)
+                        }
+                    } catch (e: Exception) {
+                        android.util.Log.e("ComposeAutocaptureTest", "Error capturing event", e)
+                    }
+                }
+                return super.addJSON(message, token, table)
+            }
+        }
+
+        val customMessages = object : AnalyticsMessages(mContext, config) {
+            override fun makeDbAdapter(context: Context): MPDbAdapter = mMockAdapter
+        }
+
+        val autocaptureOptions = AutocaptureOptions.Builder().build()
+        val options = MixpanelOptions.Builder()
+            .autocaptureOptions(autocaptureOptions)
+            .build()
+
+        mMixpanel = object : MixpanelAPI(
+            mContext, mockPreferences, TEST_TOKEN, config, options, true
+        ) {
+            override fun getAnalyticsMessages(): AnalyticsMessages = customMessages
+
+            override fun getPersistentIdentity(
+                context: Context,
+                referrerPreferences: Future<SharedPreferences>,
+                token: String,
+                instanceName: String?,
+                deviceIdProvider: DeviceIdProvider?
+            ): PersistentIdentity {
+                val instanceKey = instanceName ?: token
+                val prefsName = "com.mixpanel.android.mpmetrics.MixpanelAPI_$instanceKey"
+                context.getSharedPreferences(prefsName, Context.MODE_PRIVATE)
+                    .edit().clear().commit()
+
+                val timePrefsName =
+                    "com.mixpanel.android.mpmetrics.MixpanelAPI.TimeEvents_$instanceKey"
+                context.getSharedPreferences(timePrefsName, Context.MODE_PRIVATE)
+                    .edit().clear().commit()
+
+                val mpPrefsName = "com.mixpanel.android.mpmetrics.Mixpanel"
+                context.getSharedPreferences(mpPrefsName, Context.MODE_PRIVATE)
+                    .edit().clear().putBoolean(token, true)
+                    .putBoolean("has_launched", true).apply()
+
+                return super.getPersistentIdentity(
+                    context, referrerPreferences, token, instanceName, deviceIdProvider
+                )
+            }
+        }
+    }
+
+    @After
+    fun tearDown() {
+        if (::mMixpanel.isInitialized) {
+            mMixpanel.clearSuperProperties()
+            mMixpanel.flush()
+        }
+        mEvents.clear()
+        mContext.deleteDatabase("mixpanel")
+        TestUtils.cleanUpMixpanelData(mContext)
+    }
+
+    /**
+     * Gets the screen coordinates of the center of a Compose node.
+     * boundsInRoot is relative to the AndroidComposeView, so we need its screen position.
+     */
+    private fun getNodeScreenCenter(
+        node: SemanticsNodeInteraction,
+        scenario: ActivityScenario<*>
+    ): FloatArray {
+        val semanticsNode = node.fetchSemanticsNode()
+        val bounds = semanticsNode.boundsInRoot
+        val centerX = (bounds.left + bounds.right) / 2
+        val centerY = (bounds.top + bounds.bottom) / 2
+
+        // Get the AndroidComposeView's screen position (not decor view)
+        val composeViewOffset = intArrayOf(0, 0)
+        scenario.onActivity { activity ->
+            val contentView =
+                activity.findViewById<android.view.ViewGroup>(android.R.id.content)
+            val composeView = contentView.getChildAt(0)
+            composeView.getLocationOnScreen(composeViewOffset)
+        }
+
+        return floatArrayOf(
+            composeViewOffset[0] + centerX,
+            composeViewOffset[1] + centerY
+        )
+    }
+
+    /**
+     * Sends a real touch event (DOWN + UP) at the center of a Compose node.
+     * Uses sendPointerSync so the event goes through Window.Callback → touch interceptor.
+     */
+    private fun tapNode(node: SemanticsNodeInteraction, scenario: ActivityScenario<*>) {
+        val (screenX, screenY) = getNodeScreenCenter(node, scenario)
+
+        val instrumentation = InstrumentationRegistry.getInstrumentation()
+        val downTime = SystemClock.uptimeMillis()
+        val down = MotionEvent.obtain(
+            downTime, downTime, MotionEvent.ACTION_DOWN, screenX, screenY, 0
+        )
+        val up = MotionEvent.obtain(
+            downTime, downTime + 50, MotionEvent.ACTION_UP, screenX, screenY, 0
+        )
+        instrumentation.sendPointerSync(down)
+        instrumentation.sendPointerSync(up)
+        down.recycle()
+        up.recycle()
+    }
+
+    /**
+     * Sends N rapid taps at the center of a Compose node (for rage click testing).
+     */
+    private fun rapidTapNode(
+        node: SemanticsNodeInteraction,
+        scenario: ActivityScenario<*>,
+        count: Int
+    ) {
+        val (screenX, screenY) = getNodeScreenCenter(node, scenario)
+
+        val instrumentation = InstrumentationRegistry.getInstrumentation()
+        for (i in 0 until count) {
+            val downTime = SystemClock.uptimeMillis()
+            val down = MotionEvent.obtain(
+                downTime, downTime, MotionEvent.ACTION_DOWN, screenX, screenY, 0
+            )
+            val up = MotionEvent.obtain(
+                downTime, downTime + 10, MotionEvent.ACTION_UP, screenX, screenY, 0
+            )
+            instrumentation.sendPointerSync(down)
+            instrumentation.sendPointerSync(up)
+            down.recycle()
+            up.recycle()
+        }
+    }
+
+    @Test
+    fun testComposeClickEventBasic() {
+        ActivityScenario.launch(AutocaptureComposeTestActivity::class.java).use { scenario ->
+            Thread.sleep(1000)
+
+            tapNode(
+                composeTestRule.onNodeWithContentDescription("compose_rule1_btn"),
+                scenario
+            )
+
+            val event = mEvents.poll(10, TimeUnit.SECONDS)
+            assert(event != null) { "Click event should be captured" }
+            event!!
+
+            assert(event.getString("event") == "\$mp_click")
+
+            val properties = event.getJSONObject("properties")
+            assert(properties.getString("\$el_id") == "compose_rule1_btn")
+            assert(properties.getString("\$el_tag_name") == "Button")
+            assert(properties.getDouble("\$x") >= 0)
+            assert(properties.getDouble("\$y") >= 0)
+        }
+    }
+
+    @Test
+    fun testComposeElementIdFromTestTag() {
+        ActivityScenario.launch(AutocaptureComposeTestActivity::class.java).use { scenario ->
+            Thread.sleep(1000)
+
+            tapNode(
+                composeTestRule.onNodeWithTag("compose_rule2_btn"),
+                scenario
+            )
+
+            val event = mEvents.poll(10, TimeUnit.SECONDS)
+            assert(event != null) { "Event should be captured" }
+            event!!
+
+            val properties = event.getJSONObject("properties")
+            assert(properties.getString("\$el_id") == "compose_rule2_btn") {
+                "Expected testTag as \$el_id, got: ${properties.getString("\$el_id")}"
+            }
+        }
+    }
+
+    @Test
+    fun testComposeElementIdHashFallback() {
+        ActivityScenario.launch(AutocaptureComposeTestActivity::class.java).use { scenario ->
+            Thread.sleep(1000)
+
+            tapNode(
+                composeTestRule.onNodeWithText("Rule 3 - hash fallback"),
+                scenario
+            )
+
+            val event = mEvents.poll(10, TimeUnit.SECONDS)
+            assert(event != null) { "Event should be captured" }
+            event!!
+
+            val properties = event.getJSONObject("properties")
+            val elId = properties.getString("\$el_id")
+            assert(elId.matches(Regex("Button_-?[0-9a-f]+"))) {
+                "\$el_id should use hash fallback format, got: $elId"
+            }
+        }
+    }
+
+    @Test
+    fun testComposeRageClickDetection() {
+        ActivityScenario.launch(AutocaptureComposeTestActivity::class.java).use { scenario ->
+            Thread.sleep(1000)
+
+            rapidTapNode(
+                composeTestRule.onNodeWithContentDescription("compose_rage_zone"),
+                scenario,
+                4
+            )
+
+            val events = mutableListOf<JSONObject>()
+            var event: JSONObject?
+            while (mEvents.poll(2, TimeUnit.SECONDS).also { event = it } != null) {
+                events.add(event!!)
+            }
+
+            val rageClickEvent = events.find { it.getString("event") == "\$mp_rage_click" }
+            assert(rageClickEvent != null) { "Rage click event should be captured" }
+
+            val properties = rageClickEvent!!.getJSONObject("properties")
+            assert(properties.getString("\$el_id") == "compose_rage_zone")
+        }
+    }
+
+    @Test
+    fun testComposeDeadClickDetection() {
+        ActivityScenario.launch(AutocaptureComposeTestActivity::class.java).use { scenario ->
+            Thread.sleep(1000)
+
+            tapNode(
+                composeTestRule.onNodeWithContentDescription("compose_dead_btn"),
+                scenario
+            )
+
+            val clickEvent = mEvents.poll(2, TimeUnit.SECONDS)
+            assert(clickEvent != null) { "Click event should be captured first" }
+            assert(clickEvent!!.getString("event") == "\$mp_click")
+
+            val deadClickEvent = mEvents.poll(3, TimeUnit.SECONDS)
+            assert(deadClickEvent != null) { "Dead click event should be captured" }
+            assert(deadClickEvent!!.getString("event") == "\$mp_dead_click")
+
+            val properties = deadClickEvent.getJSONObject("properties")
+            assert(properties.getString("\$el_id") == "compose_dead_btn")
+        }
+    }
+
+    @Test
+    fun testComposeMultipleClicksGenerateMultipleEvents() {
+        ActivityScenario.launch(AutocaptureComposeTestActivity::class.java).use { scenario ->
+            Thread.sleep(1000)
+
+            tapNode(
+                composeTestRule.onNodeWithContentDescription("compose_rule1_btn"),
+                scenario
+            )
+            Thread.sleep(200)
+
+            tapNode(
+                composeTestRule.onNodeWithContentDescription("compose_dead_btn"),
+                scenario
+            )
+            Thread.sleep(200)
+
+            tapNode(
+                composeTestRule.onNodeWithContentDescription("compose_rage_zone"),
+                scenario
+            )
+            Thread.sleep(200)
+
+            val clickEvents = mutableListOf<JSONObject>()
+            var event: JSONObject?
+            while (mEvents.poll(2, TimeUnit.SECONDS).also { event = it } != null) {
+                if (event!!.getString("event") == "\$mp_click") {
+                    clickEvents.add(event!!)
+                }
+            }
+
+            assert(clickEvents.size == 3) {
+                "Should capture exactly 3 click events, got: ${clickEvents.size}"
+            }
+        }
+    }
+
+    @Test
+    fun testComposeClickEventHasTokenProperty() {
+        ActivityScenario.launch(AutocaptureComposeTestActivity::class.java).use { scenario ->
+            Thread.sleep(1000)
+
+            tapNode(
+                composeTestRule.onNodeWithContentDescription("compose_rule1_btn"),
+                scenario
+            )
+
+            val event = mEvents.poll(10, TimeUnit.SECONDS)
+            assert(event != null) { "Event should be captured" }
+            event!!
+
+            val properties = event.getJSONObject("properties")
+            assert(properties.has("distinct_id")) { "distinct_id should exist" }
+            assert(properties.getString("token") == TEST_TOKEN) {
+                "Token should match, got: ${properties.getString("token")}"
+            }
+        }
+    }
+}
diff --git a/analytics/src/androidTest/java/com/mixpanel/android/mpmetrics/AutocaptureComposeTestActivity.kt b/analytics/src/androidTest/java/com/mixpanel/android/mpmetrics/AutocaptureComposeTestActivity.kt
new file mode 100644
index 000000000..376becc5a
--- /dev/null
+++ b/analytics/src/androidTest/java/com/mixpanel/android/mpmetrics/AutocaptureComposeTestActivity.kt
@@ -0,0 +1,215 @@
+package com.mixpanel.android.mpmetrics
+
+import android.os.Bundle
+import android.widget.LinearLayout
+import android.widget.TextView
+import androidx.activity.ComponentActivity
+import androidx.activity.compose.setContent
+import androidx.compose.foundation.clickable
+import androidx.compose.foundation.layout.Column
+import androidx.compose.foundation.layout.Spacer
+import androidx.compose.foundation.layout.fillMaxSize
+import androidx.compose.foundation.layout.fillMaxWidth
+import androidx.compose.foundation.layout.height
+import androidx.compose.foundation.layout.padding
+import androidx.compose.foundation.rememberScrollState
+import androidx.compose.foundation.verticalScroll
+import androidx.compose.material3.Button
+import androidx.compose.material3.Text
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.mutableIntStateOf
+import androidx.compose.runtime.remember
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.platform.testTag
+import androidx.compose.ui.semantics.contentDescription
+import androidx.compose.ui.semantics.semantics
+import androidx.compose.ui.unit.dp
+import androidx.compose.ui.viewinterop.AndroidView
+
+/**
+ * Compose test activity for autocapture instrumentation tests.
+ * All composables are created programmatically with explicit semantics.
+ *
+ * Includes mixed-framework elements (AndroidView inside Compose) for cross-framework
+ * dead click testing.
+ */
+class AutocaptureComposeTestActivity : ComponentActivity() {
+    override fun onCreate(savedInstanceState: Bundle?) {
+        super.onCreate(savedInstanceState)
+        setContent {
+            TestContent()
+        }
+    }
+}
+
+@Composable
+private fun TestContent() {
+    val composeTextCounter = remember { mutableIntStateOf(0) }
+
+    Column(
+        modifier = Modifier
+            .fillMaxSize()
+            .verticalScroll(rememberScrollState())
+            .padding(16.dp)
+    ) {
+        // Rule 1 button - contentDescription priority
+        Button(
+            onClick = {},
+            modifier = Modifier
+                .fillMaxWidth()
+                .semantics { contentDescription = "compose_rule1_btn" }
+        ) {
+            Text("Rule 1 - contentDescription")
+        }
+
+        Spacer(modifier = Modifier.height(8.dp))
+
+        // Rule 2 button - testTag fallback (no contentDescription)
+        Button(
+            onClick = {},
+            modifier = Modifier
+                .fillMaxWidth()
+                .testTag("compose_rule2_btn")
+        ) {
+            Text("Rule 2 - testTag")
+        }
+
+        Spacer(modifier = Modifier.height(8.dp))
+
+        // Rule 3 button - hash fallback (no contentDescription, no testTag)
+        Button(
+            onClick = {},
+            modifier = Modifier.fillMaxWidth()
+        ) {
+            Text("Rule 3 - hash fallback")
+        }
+
+        Spacer(modifier = Modifier.height(16.dp))
+
+        // Dead click button - onClick does nothing (no UI change)
+        Button(
+            onClick = {},
+            modifier = Modifier
+                .fillMaxWidth()
+                .semantics { contentDescription = "compose_dead_btn" }
+        ) {
+            Text("Dead Button (no effect)")
+        }
+
+        Spacer(modifier = Modifier.height(16.dp))
+
+        // Rage zone - clickable area
+        Spacer(
+            modifier = Modifier
+                .fillMaxWidth()
+                .height(80.dp)
+                .clickable {}
+                .semantics { contentDescription = "compose_rage_zone" }
+        )
+
+        Spacer(modifier = Modifier.height(16.dp))
+
+        // ============ Mixed-Framework Dead Click Test Elements ============
+
+        // XML button + XML text counter embedded via AndroidView
+        AndroidView(
+            modifier = Modifier.fillMaxWidth(),
+            factory = { ctx ->
+                LinearLayout(ctx).apply {
+                    orientation = LinearLayout.VERTICAL
+                    val dp8 = (8 * ctx.resources.displayMetrics.density).toInt()
+
+                    // XML button that changes XML text
+                    val xmlTextCounter = TextView(ctx).apply {
+                        text = "XML counter: 0"
+                        this.contentDescription = "xml_text_counter_in_compose"
+                        setPadding(0, dp8, 0, 0)
+                    }
+
+                    val xmlBtnXmlText = android.widget.Button(ctx).apply {
+                        text = "XML Btn -> XML Text"
+                        this.contentDescription = "xml_btn_xml_text_in_compose"
+                        setOnClickListener {
+                            val current = xmlTextCounter.text.toString()
+                                .substringAfter(": ").toIntOrNull() ?: 0
+                            xmlTextCounter.text = "XML counter: ${current + 1}"
+                        }
+                    }
+                    addView(xmlBtnXmlText, LinearLayout.LayoutParams(
+                        LinearLayout.LayoutParams.MATCH_PARENT,
+                        LinearLayout.LayoutParams.WRAP_CONTENT
+                    ))
+                    addView(xmlTextCounter, LinearLayout.LayoutParams(
+                        LinearLayout.LayoutParams.MATCH_PARENT,
+                        LinearLayout.LayoutParams.WRAP_CONTENT
+                    ))
+
+                    // XML button that changes Compose text
+                    val xmlBtnComposeText = android.widget.Button(ctx).apply {
+                        text = "XML Btn -> Compose Text"
+                        this.contentDescription = "xml_btn_compose_text_in_compose"
+                        layoutParams = LinearLayout.LayoutParams(
+                            LinearLayout.LayoutParams.MATCH_PARENT,
+                            LinearLayout.LayoutParams.WRAP_CONTENT
+                        ).apply { topMargin = dp8 }
+                        setOnClickListener {
+                            composeTextCounter.intValue++
+                        }
+                    }
+                    addView(xmlBtnComposeText)
+                }
+            }
+        )
+
+        // Compose button that changes XML text (via AndroidView update)
+        // We use a separate AndroidView to hold the XML counter that this button updates
+        val xmlCounterFromCompose = remember { mutableIntStateOf(0) }
+
+        Button(
+            onClick = {
+                xmlCounterFromCompose.intValue++
+            },
+            modifier = Modifier
+                .fillMaxWidth()
+                .padding(top = 8.dp)
+                .semantics { contentDescription = "compose_btn_xml_text_in_compose" }
+        ) {
+            Text("Compose Btn -> XML Text")
+        }
+
+        AndroidView(
+            modifier = Modifier
+                .fillMaxWidth()
+                .padding(top = 4.dp),
+            factory = { ctx ->
+                TextView(ctx).apply {
+                    this.contentDescription = "xml_text_from_compose_btn"
+                }
+            },
+            update = { textView ->
+                textView.text = "XML counter (from Compose): ${xmlCounterFromCompose.intValue}"
+            }
+        )
+
+        // Compose button that changes Compose text
+        Button(
+            onClick = {
+                composeTextCounter.intValue++
+            },
+            modifier = Modifier
+                .fillMaxWidth()
+                .padding(top = 8.dp)
+                .semantics { contentDescription = "compose_btn_compose_text_in_compose" }
+        ) {
+            Text("Compose Btn -> Compose Text")
+        }
+
+        // Compose text counter
+        Text(
+            text = "Compose counter: ${composeTextCounter.intValue}",
+            modifier = Modifier
+                .padding(top = 4.dp)
+                .semantics { contentDescription = "compose_text_counter_in_compose" }
+        )
+    }
+}
diff --git a/analytics/src/androidTest/java/com/mixpanel/android/mpmetrics/AutocaptureMixedFrameworkInstrumentedTest.kt b/analytics/src/androidTest/java/com/mixpanel/android/mpmetrics/AutocaptureMixedFrameworkInstrumentedTest.kt
new file mode 100644
index 000000000..353c99862
--- /dev/null
+++ b/analytics/src/androidTest/java/com/mixpanel/android/mpmetrics/AutocaptureMixedFrameworkInstrumentedTest.kt
@@ -0,0 +1,356 @@
+package com.mixpanel.android.mpmetrics
+
+import android.content.Context
+import android.content.SharedPreferences
+import android.os.SystemClock
+import android.view.MotionEvent
+import androidx.compose.ui.test.SemanticsNodeInteraction
+import androidx.compose.ui.test.junit4.createEmptyComposeRule
+import androidx.compose.ui.test.onNodeWithContentDescription
+import androidx.test.core.app.ActivityScenario
+import androidx.test.espresso.Espresso.onView
+import androidx.test.espresso.action.ViewActions.click
+import androidx.test.espresso.matcher.ViewMatchers.withId
+import androidx.test.ext.junit.runners.AndroidJUnit4
+import androidx.test.filters.LargeTest
+import androidx.test.platform.app.InstrumentationRegistry
+import org.json.JSONObject
+import org.junit.After
+import org.junit.Before
+import org.junit.Rule
+import org.junit.Test
+import org.junit.runner.RunWith
+import java.util.concurrent.BlockingQueue
+import java.util.concurrent.Future
+import java.util.concurrent.LinkedBlockingQueue
+import java.util.concurrent.TimeUnit
+
+/**
+ * Instrumented tests for dead click detection in mixed-framework UI scenarios.
+ *
+ * Tests verify that clicks producing cross-framework UI changes do NOT trigger
+ * false dead clicks ($mp_dead_click). Each test clicks a button that updates
+ * a counter text in either the same or different framework.
+ *
+ * Test matrix (4 combinations × 2 screen types = 8 tests):
+ *
+ * In XML-based screen (AutocaptureXmlTestActivity with ComposeView):
+ * 1. XML button → XML text change
+ * 2. XML button → Compose text change
+ * 3. Compose button → XML text change
+ * 4. Compose button → Compose text change
+ *
+ * In Compose-based screen (AutocaptureComposeTestActivity with AndroidView):
+ * 5. XML button → XML text change
+ * 6. XML button → Compose text change
+ * 7. Compose button → XML text change
+ * 8. Compose button → Compose text change
+ */
+@RunWith(AndroidJUnit4::class)
+@LargeTest
+class AutocaptureMixedFrameworkInstrumentedTest {
+
+    companion object {
+        private const val TEST_TOKEN = "MIXED_FRAMEWORK_TEST_TOKEN"
+    }
+
+    @get:Rule
+    val composeTestRule = createEmptyComposeRule()
+
+    private val mEvents: BlockingQueue<JSONObject> = LinkedBlockingQueue()
+    private lateinit var mMixpanel: MixpanelAPI
+    private lateinit var mContext: Context
+
+    @Before
+    fun setUp() {
+        mContext = InstrumentationRegistry.getInstrumentation().context
+
+        val messages = AnalyticsMessages.getInstance(
+            mContext,
+            MPConfig.getInstance(mContext, null)
+        )
+        messages.hardKill()
+        Thread.sleep(2000)
+
+        mEvents.clear()
+
+        val mockPreferences = TestUtils.EmptyPreferences(mContext)
+        val config = MPConfig.getInstance(mContext, null)
+
+        val mockAdapter = object : MPDbAdapter(mContext, config) {
+            override fun addJSON(message: JSONObject, token: String, table: Table): Int {
+                if (table == Table.EVENTS) {
+                    try {
+                        val eventName = message.optString("event", "")
+                        if (eventName.startsWith("\$mp_")) {
+                            mEvents.add(message)
+                        }
+                    } catch (e: Exception) {
+                        android.util.Log.e("MixedFrameworkTest", "Error capturing event", e)
+                    }
+                }
+                return super.addJSON(message, token, table)
+            }
+        }
+
+        val customMessages = object : AnalyticsMessages(mContext, config) {
+            override fun makeDbAdapter(context: Context): MPDbAdapter = mockAdapter
+        }
+
+        val autocaptureOptions = AutocaptureOptions.Builder().build()
+        val options = MixpanelOptions.Builder()
+            .autocaptureOptions(autocaptureOptions)
+            .build()
+
+        mMixpanel = object : MixpanelAPI(
+            mContext, mockPreferences, TEST_TOKEN, config, options, true
+        ) {
+            override fun getAnalyticsMessages(): AnalyticsMessages = customMessages
+
+            override fun getPersistentIdentity(
+                context: Context,
+                referrerPreferences: Future<SharedPreferences>,
+                token: String,
+                instanceName: String?,
+                deviceIdProvider: DeviceIdProvider?
+            ): PersistentIdentity {
+                val instanceKey = instanceName ?: token
+                val prefsName = "com.mixpanel.android.mpmetrics.MixpanelAPI_$instanceKey"
+                context.getSharedPreferences(prefsName, Context.MODE_PRIVATE)
+                    .edit().clear().commit()
+
+                val timePrefsName =
+                    "com.mixpanel.android.mpmetrics.MixpanelAPI.TimeEvents_$instanceKey"
+                context.getSharedPreferences(timePrefsName, Context.MODE_PRIVATE)
+                    .edit().clear().commit()
+
+                val mpPrefsName = "com.mixpanel.android.mpmetrics.Mixpanel"
+                context.getSharedPreferences(mpPrefsName, Context.MODE_PRIVATE)
+                    .edit().clear().putBoolean(token, true)
+                    .putBoolean("has_launched", true).apply()
+
+                return super.getPersistentIdentity(
+                    context, referrerPreferences, token, instanceName, deviceIdProvider
+                )
+            }
+        }
+    }
+
+    @After
+    fun tearDown() {
+        if (::mMixpanel.isInitialized) {
+            mMixpanel.clearSuperProperties()
+            mMixpanel.flush()
+        }
+        mEvents.clear()
+        mContext.deleteDatabase("mixpanel")
+        TestUtils.cleanUpMixpanelData(mContext)
+    }
+
+    // ==================== XML Screen (with ComposeView) ====================
+
+    @Test
+    fun testXmlScreen_xmlButtonChangesXmlText_noDeadClick() {
+        ActivityScenario.launch(AutocaptureXmlTestActivity::class.java).use {
+            Thread.sleep(500)
+
+            onView(withId(AutocaptureXmlTestActivity.ID_XML_BTN_XML_TEXT)).perform(click())
+
+            assertClickWithoutDeadClick("xml_btn_xml_text")
+        }
+    }
+
+    @Test
+    fun testXmlScreen_xmlButtonChangesComposeText_noDeadClick() {
+        ActivityScenario.launch(AutocaptureXmlTestActivity::class.java).use {
+            Thread.sleep(500)
+
+            onView(withId(AutocaptureXmlTestActivity.ID_XML_BTN_COMPOSE_TEXT)).perform(click())
+
+            assertClickWithoutDeadClick("xml_btn_compose_text")
+        }
+    }
+
+    @Test
+    fun testXmlScreen_composeButtonChangesXmlText_noDeadClick() {
+        ActivityScenario.launch(AutocaptureXmlTestActivity::class.java).use { scenario ->
+            Thread.sleep(1000)
+
+            tapComposeNode(
+                composeTestRule.onNodeWithContentDescription("compose_btn_xml_text"),
+                scenario
+            )
+
+            assertClickWithoutDeadClick("compose_btn_xml_text")
+        }
+    }
+
+    @Test
+    fun testXmlScreen_composeButtonChangesComposeText_noDeadClick() {
+        ActivityScenario.launch(AutocaptureXmlTestActivity::class.java).use { scenario ->
+            Thread.sleep(1000)
+
+            tapComposeNode(
+                composeTestRule.onNodeWithContentDescription("compose_btn_compose_text"),
+                scenario
+            )
+
+            assertClickWithoutDeadClick("compose_btn_compose_text")
+        }
+    }
+
+    // ==================== Compose Screen (with AndroidView) ====================
+
+    @Test
+    fun testComposeScreen_xmlButtonChangesXmlText_noDeadClick() {
+        ActivityScenario.launch(AutocaptureComposeTestActivity::class.java).use { scenario ->
+            Thread.sleep(1000)
+
+            tapViewByContentDescription(
+                "xml_btn_xml_text_in_compose",
+                scenario
+            )
+
+            assertClickWithoutDeadClick("xml_btn_xml_text_in_compose")
+        }
+    }
+
+    @Test
+    fun testComposeScreen_xmlButtonChangesComposeText_noDeadClick() {
+        ActivityScenario.launch(AutocaptureComposeTestActivity::class.java).use { scenario ->
+            Thread.sleep(1000)
+
+            tapViewByContentDescription(
+                "xml_btn_compose_text_in_compose",
+                scenario
+            )
+
+            assertClickWithoutDeadClick("xml_btn_compose_text_in_compose")
+        }
+    }
+
+    @Test
+    fun testComposeScreen_composeButtonChangesXmlText_noDeadClick() {
+        ActivityScenario.launch(AutocaptureComposeTestActivity::class.java).use { scenario ->
+            Thread.sleep(1000)
+
+            tapComposeNode(
+                composeTestRule.onNodeWithContentDescription("compose_btn_xml_text_in_compose"),
+                scenario
+            )
+
+            assertClickWithoutDeadClick("compose_btn_xml_text_in_compose")
+        }
+    }
+
+    @Test
+    fun testComposeScreen_composeButtonChangesComposeText_noDeadClick() {
+        ActivityScenario.launch(AutocaptureComposeTestActivity::class.java).use { scenario ->
+            Thread.sleep(1000)
+
+            tapComposeNode(
+                composeTestRule.onNodeWithContentDescription("compose_btn_compose_text_in_compose"),
+                scenario
+            )
+
+            assertClickWithoutDeadClick("compose_btn_compose_text_in_compose")
+        }
+    }
+
+    // ==================== Helpers ====================
+
+    /**
+     * Asserts that a $mp_click event was captured and NO $mp_dead_click follows
+     * within the dead click timeout window.
+     *
+     * @param description Human-readable test case description for error messages.
+     */
+    private fun assertClickWithoutDeadClick(description: String) {
+        // First: should get $mp_click
+        val clickEvent = mEvents.poll(10, TimeUnit.SECONDS)
+        assert(clickEvent != null) { "Should capture \$mp_click event for: $description" }
+        assert(clickEvent!!.getString("event") == "\$mp_click") {
+            "Expected \$mp_click, got: ${clickEvent.getString("event")} for: $description"
+        }
+
+        // Second: should NOT get $mp_dead_click (wait longer than dead click timeout)
+        val nextEvent = mEvents.poll(3, TimeUnit.SECONDS)
+        if (nextEvent != null) {
+            assert(nextEvent.getString("event") != "\$mp_dead_click") {
+                "\$mp_dead_click should NOT be emitted when button produces UI change. " +
+                    "Case: $description"
+            }
+        }
+        // null means no dead click — correct behavior
+    }
+
+    /**
+     * Sends a real touch event at the center of a Compose node.
+     * Uses positionInWindow from the semantics node for accurate screen coordinates.
+     * Calls waitForIdle() after tap to ensure Compose recomposition completes
+     * before the dead click detector's timeout fires.
+     */
+    private fun tapComposeNode(node: SemanticsNodeInteraction, scenario: ActivityScenario<*>) {
+        val semanticsNode = node.fetchSemanticsNode()
+        val bounds = semanticsNode.boundsInWindow
+        val screenX = (bounds.left + bounds.right) / 2
+        val screenY = (bounds.top + bounds.bottom) / 2
+
+        sendTap(screenX, screenY)
+
+        // Wait for Compose recomposition to complete. Without this, the test
+        // framework's clock control may prevent recomposition from running,
+        // causing the dead click detector's semantic snapshot to see stale state.
+        composeTestRule.waitForIdle()
+    }
+
+    /**
+     * Sends a real touch event at the center of an XML view found by contentDescription.
+     */
+    private fun tapViewByContentDescription(
+        desc: String,
+        scenario: ActivityScenario<*>
+    ) {
+        val location = floatArrayOf(0f, 0f)
+        scenario.onActivity { activity ->
+            val view = findViewByContentDescription(
+                activity.window.decorView, desc
+            ) ?: throw AssertionError("View with contentDescription '$desc' not found")
+            val loc = intArrayOf(0, 0)
+            view.getLocationOnScreen(loc)
+            location[0] = loc[0] + view.width / 2f
+            location[1] = loc[1] + view.height / 2f
+        }
+
+        sendTap(location[0], location[1])
+    }
+
+    private fun findViewByContentDescription(
+        root: android.view.View,
+        desc: String
+    ): android.view.View? {
+        if (root.contentDescription?.toString() == desc) return root
+        if (root is android.view.ViewGroup) {
+            for (i in 0 until root.childCount) {
+                val found = findViewByContentDescription(root.getChildAt(i), desc)
+                if (found != null) return found
+            }
+        }
+        return null
+    }
+
+    private fun sendTap(screenX: Float, screenY: Float) {
+        val instrumentation = InstrumentationRegistry.getInstrumentation()
+        val downTime = SystemClock.uptimeMillis()
+        val down = MotionEvent.obtain(
+            downTime, downTime, MotionEvent.ACTION_DOWN, screenX, screenY, 0
+        )
+        val up = MotionEvent.obtain(
+            downTime, downTime + 50, MotionEvent.ACTION_UP, screenX, screenY, 0
+        )
+        instrumentation.sendPointerSync(down)
+        instrumentation.sendPointerSync(up)
+        down.recycle()
+        up.recycle()
+    }
+}
diff --git a/analytics/src/androidTest/java/com/mixpanel/android/mpmetrics/AutocaptureXmlInstrumentedTest.java b/analytics/src/androidTest/java/com/mixpanel/android/mpmetrics/AutocaptureXmlInstrumentedTest.java
new file mode 100644
index 000000000..f52ed6207
--- /dev/null
+++ b/analytics/src/androidTest/java/com/mixpanel/android/mpmetrics/AutocaptureXmlInstrumentedTest.java
@@ -0,0 +1,474 @@
+package com.mixpanel.android.mpmetrics;
+
+import android.content.Context;
+import android.content.SharedPreferences;
+import android.view.View;
+
+import androidx.test.core.app.ActivityScenario;
+import androidx.test.ext.junit.runners.AndroidJUnit4;
+import androidx.test.filters.LargeTest;
+import androidx.test.platform.app.InstrumentationRegistry;
+
+import org.json.JSONObject;
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+
+import java.util.concurrent.Future;
+import java.util.concurrent.BlockingQueue;
+import java.util.concurrent.LinkedBlockingQueue;
+import java.util.concurrent.TimeUnit;
+
+import static androidx.test.espresso.Espresso.onView;
+import static androidx.test.espresso.action.ViewActions.click;
+import static androidx.test.espresso.matcher.ViewMatchers.withId;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertTrue;
+
+/**
+ * Instrumentation tests for autocapture functionality.
+ *
+ * <p>These tests verify the happy path scenarios for click, rage click, and dead click detection.
+ * They follow the SDK's established testing patterns using BlockingQueue for async verification
+ * and CleanMixpanelAPI for test isolation.
+ */
+@RunWith(AndroidJUnit4.class)
+@LargeTest
+public class AutocaptureXmlInstrumentedTest {
+
+    private static final String TEST_TOKEN = "AUTOCAPTURE_TEST_TOKEN";
+
+    private final BlockingQueue<JSONObject> mEvents = new LinkedBlockingQueue<>();
+    private MixpanelAPI mMixpanel;
+    private MPDbAdapter mMockAdapter;
+    private Context mContext;
+
+    @Before
+    public void setUp() throws Exception {
+        mContext = InstrumentationRegistry.getInstrumentation().getContext();
+
+        // Hard-kill existing AnalyticsMessages instance for clean state
+        AnalyticsMessages messages = AnalyticsMessages.getInstance(
+                mContext,
+                MPConfig.getInstance(mContext, null));
+        messages.hardKill();
+        Thread.sleep(2000);
+
+        // Clear events queue
+        mEvents.clear();
+
+        // Create mock preferences for test isolation
+        final TestUtils.EmptyPreferences mockPreferences = new TestUtils.EmptyPreferences(mContext);
+
+        // Create MPDbAdapter mock that captures events to BlockingQueue
+        final MPConfig config = MPConfig.getInstance(mContext, null);
+        mMockAdapter = new MPDbAdapter(mContext, config) {
+            @Override
+            public int addJSON(JSONObject message, String token, MPDbAdapter.Table table) {
+                if (table == MPDbAdapter.Table.EVENTS) {
+                    try {
+                        // Only capture autocapture events ($mp_click, $mp_rage_click, $mp_dead_click)
+                        String eventName = message.optString("event", "");
+                        if (eventName.startsWith("$mp_")) {
+                            mEvents.add(message);
+                        }
+                    } catch (Exception e) {
+                        android.util.Log.e("AutocaptureTest", "Error capturing event", e);
+                    }
+                }
+                return super.addJSON(message, token, table);
+            }
+        };
+
+        // Create custom AnalyticsMessages with mocked adapter
+        final AnalyticsMessages customMessages = new AnalyticsMessages(mContext, config) {
+            @Override
+            protected MPDbAdapter makeDbAdapter(Context context) {
+                return mMockAdapter;
+            }
+        };
+
+        // Configure autocapture options (all features enabled)
+        AutocaptureOptions autocaptureOptions = new AutocaptureOptions.Builder().build();
+
+        MixpanelOptions options = new MixpanelOptions.Builder()
+                .autocaptureOptions(autocaptureOptions)
+                .build();
+
+        // Create MixpanelAPI with trackAutomaticEvents=true for most tests
+        mMixpanel = new MixpanelAPI(mContext, mockPreferences, TEST_TOKEN, config, options, true) {
+            @Override
+            AnalyticsMessages getAnalyticsMessages() {
+                return customMessages;
+            }
+
+            @Override
+            PersistentIdentity getPersistentIdentity(
+                    final Context context,
+                    final Future<SharedPreferences> referrerPreferences,
+                    final String token,
+                    final String instanceName,
+                    final DeviceIdProvider deviceIdProvider) {
+                String instanceKey = instanceName != null ? instanceName : token;
+                final String prefsName = "com.mixpanel.android.mpmetrics.MixpanelAPI_" + instanceKey;
+                final SharedPreferences ret = context.getSharedPreferences(prefsName, Context.MODE_PRIVATE);
+                ret.edit().clear().commit();
+
+                final String timeEventsPrefsName = "com.mixpanel.android.mpmetrics.MixpanelAPI.TimeEvents_" + instanceKey;
+                final SharedPreferences timeSharedPrefs = context.getSharedPreferences(timeEventsPrefsName, Context.MODE_PRIVATE);
+                timeSharedPrefs.edit().clear().commit();
+
+                final String mixpanelPrefsName = "com.mixpanel.android.mpmetrics.Mixpanel";
+                final SharedPreferences mpSharedPrefs = context.getSharedPreferences(mixpanelPrefsName, Context.MODE_PRIVATE);
+                mpSharedPrefs.edit().clear().putBoolean(token, true).putBoolean("has_launched", true).apply();
+
+                return super.getPersistentIdentity(context, referrerPreferences, token, instanceName, deviceIdProvider);
+            }
+        };
+    }
+
+    @After
+    public void tearDown() throws Exception {
+        if (mMixpanel != null) {
+            // Clear super properties
+            mMixpanel.clearSuperProperties();
+
+            // Flush any pending events
+            mMixpanel.flush();
+        }
+
+        // Clear events queue
+        mEvents.clear();
+
+        // Delete Mixpanel database
+        mContext.deleteDatabase("mixpanel");
+
+        // Clean up Mixpanel data
+        TestUtils.cleanUpMixpanelData(mContext);
+    }
+
+    @Test
+    public void testXmlClickEventBasic() throws Exception {
+        try (ActivityScenario<AutocaptureXmlTestActivity> scenario =
+                     ActivityScenario.launch(AutocaptureXmlTestActivity.class)) {
+
+            // Wait for autocapture to attach to window
+            Thread.sleep(500);
+
+            // Click the rule1_btn button
+            onView(withId(AutocaptureXmlTestActivity.ID_RULE1_BTN)).perform(click());
+
+            // Poll for the event with 10-second timeout
+            JSONObject event = mEvents.poll(10, TimeUnit.SECONDS);
+            assertNotNull("Click event should be captured", event);
+
+            // Verify event name
+            assertEquals("$mp_click", event.getString("event"));
+
+            // Verify event properties
+            JSONObject properties = event.getJSONObject("properties");
+            assertNotNull("Event properties should exist", properties);
+
+            // Verify element ID uses contentDescription (Rule 1)
+            assertEquals("rule1_btn", properties.getString("$el_id"));
+
+            // Verify element tag name
+            assertEquals("Button", properties.getString("$el_tag_name"));
+
+            // Verify coordinates are present and non-negative
+            assertTrue("X coordinate should be non-negative",
+                    properties.getDouble("$x") >= 0);
+            assertTrue("Y coordinate should be non-negative",
+                    properties.getDouble("$y") >= 0);
+        }
+    }
+
+    @Test
+    public void testRageClickDetection() throws Exception {
+        try (ActivityScenario<AutocaptureXmlTestActivity> scenario =
+                     ActivityScenario.launch(AutocaptureXmlTestActivity.class)) {
+
+            Thread.sleep(500);
+
+            // Get rage zone coordinates for rapid touch injection
+            final int[] location = new int[2];
+            scenario.onActivity(activity -> {
+                View rageZone = activity.findViewById(AutocaptureXmlTestActivity.ID_RAGE_ZONE);
+                rageZone.getLocationOnScreen(location);
+                location[0] += rageZone.getWidth() / 2;
+                location[1] += rageZone.getHeight() / 2;
+            });
+
+            // Inject 4 rapid tap events using Instrumentation (bypasses Espresso UI idle wait)
+            android.app.Instrumentation instrumentation =
+                    InstrumentationRegistry.getInstrumentation();
+            for (int i = 0; i < 4; i++) {
+                long downTime = android.os.SystemClock.uptimeMillis();
+                android.view.MotionEvent down = android.view.MotionEvent.obtain(
+                        downTime, downTime,
+                        android.view.MotionEvent.ACTION_DOWN,
+                        location[0], location[1], 0);
+                android.view.MotionEvent up = android.view.MotionEvent.obtain(
+                        downTime, downTime + 10,
+                        android.view.MotionEvent.ACTION_UP,
+                        location[0], location[1], 0);
+                instrumentation.sendPointerSync(down);
+                instrumentation.sendPointerSync(up);
+                down.recycle();
+                up.recycle();
+            }
+
+            // Collect all events
+            java.util.List<JSONObject> events = new java.util.ArrayList<>();
+            JSONObject event;
+            while ((event = mEvents.poll(2, TimeUnit.SECONDS)) != null) {
+                events.add(event);
+            }
+
+            // Find rage click event
+            JSONObject rageClickEvent = null;
+            for (JSONObject e : events) {
+                if ("$mp_rage_click".equals(e.getString("event"))) {
+                    rageClickEvent = e;
+                    break;
+                }
+            }
+
+            // Assert rage click event exists
+            assertNotNull("Rage click event should be captured", rageClickEvent);
+
+            // Verify rage click event properties
+            JSONObject properties = rageClickEvent.getJSONObject("properties");
+            assertEquals("rage_zone", properties.getString("$el_id"));
+            assertEquals("View", properties.getString("$el_tag_name"));
+        }
+    }
+
+    @Test
+    public void testDeadClickDetection() throws Exception {
+        try (ActivityScenario<AutocaptureXmlTestActivity> scenario =
+                     ActivityScenario.launch(AutocaptureXmlTestActivity.class)) {
+
+            Thread.sleep(500);
+
+            // Click the dead button (has NO click listener)
+            onView(withId(AutocaptureXmlTestActivity.ID_DEAD_XML_BTN)).perform(click());
+
+            // First, collect the $mp_click event
+            JSONObject clickEvent = mEvents.poll(2, TimeUnit.SECONDS);
+            assertNotNull("Click event should be captured first", clickEvent);
+            assertEquals("$mp_click", clickEvent.getString("event"));
+
+            // Now wait for the dead click event (1000ms detection delay)
+            JSONObject deadClickEvent = mEvents.poll(3, TimeUnit.SECONDS);
+            assertNotNull("Dead click event should be captured", deadClickEvent);
+
+            // Verify event name
+            assertEquals("$mp_dead_click", deadClickEvent.getString("event"));
+
+            // Verify properties match dead button
+            JSONObject properties = deadClickEvent.getJSONObject("properties");
+            assertEquals("dead_xml_btn", properties.getString("$el_id"));
+            assertEquals("Button", properties.getString("$el_tag_name"));
+        }
+    }
+
+    @Test
+    public void testElementIdResolutionRule2() throws Exception {
+        try (ActivityScenario<AutocaptureXmlTestActivity> scenario =
+                     ActivityScenario.launch(AutocaptureXmlTestActivity.class)) {
+
+            Thread.sleep(500);
+
+            // Click button with resource ID only (no contentDescription)
+            onView(withId(AutocaptureXmlTestActivity.ID_RULE2_BTN)).perform(click());
+
+            JSONObject event = mEvents.poll(10, TimeUnit.SECONDS);
+            assertNotNull("Event should be captured", event);
+
+            JSONObject properties = event.getJSONObject("properties");
+
+            // Verify $el_id uses resource ID name (android.R.id.button1 resolves to "button1")
+            assertEquals("button1", properties.getString("$el_id"));
+        }
+    }
+
+    @Test
+    public void testMultipleClicksGenerateMultipleEvents() throws Exception {
+        try (ActivityScenario<AutocaptureXmlTestActivity> scenario =
+                     ActivityScenario.launch(AutocaptureXmlTestActivity.class)) {
+
+            Thread.sleep(500);
+
+            // Click 3 different buttons with spacing to avoid rage click
+            onView(withId(AutocaptureXmlTestActivity.ID_RULE1_BTN)).perform(click());
+            Thread.sleep(200);
+
+            onView(withId(AutocaptureXmlTestActivity.ID_RULE2_BTN)).perform(click());
+            Thread.sleep(200);
+
+            onView(withId(AutocaptureXmlTestActivity.ID_RULE3_BTN)).perform(click());
+            Thread.sleep(200);
+
+            // Collect all events and filter for $mp_click only
+            // (dead click events may also fire since empty listeners cause no UI change)
+            java.util.List<JSONObject> clickEvents = new java.util.ArrayList<>();
+            JSONObject event;
+            while ((event = mEvents.poll(2, TimeUnit.SECONDS)) != null) {
+                if ("$mp_click".equals(event.getString("event"))) {
+                    clickEvents.add(event);
+                }
+            }
+
+            // Assert exactly 3 click events captured
+            assertEquals("Should capture exactly 3 click events", 3, clickEvents.size());
+        }
+    }
+
+    @Test
+    public void testClickEventHasTokenProperty() throws Exception {
+        try (ActivityScenario<AutocaptureXmlTestActivity> scenario =
+                     ActivityScenario.launch(AutocaptureXmlTestActivity.class)) {
+
+            Thread.sleep(500);
+
+            // Click a button
+            onView(withId(AutocaptureXmlTestActivity.ID_RULE1_BTN)).perform(click());
+
+            // Poll for the event
+            JSONObject event = mEvents.poll(10, TimeUnit.SECONDS);
+            assertNotNull("Event should be captured", event);
+
+            // Verify standard Mixpanel properties exist
+            JSONObject properties = event.getJSONObject("properties");
+
+            // Assert distinct_id exists
+            assertTrue("distinct_id should exist", properties.has("distinct_id"));
+            assertNotNull("distinct_id should not be null", properties.get("distinct_id"));
+
+            // Assert token matches (token is in properties)
+            assertEquals("Token should match", TEST_TOKEN, properties.getString("token"));
+        }
+    }
+
+    // Note: Dialog/BottomSheet/Popup autocapture tests require the full Application lifecycle
+    // (WindowSpy + ActivityLifecycleCallbacks) which isn't available in instrumented tests
+    // with a mock MixpanelAPI. These are tested manually via the demo app's
+    // "Multi-Window / Overlay" section in both Compose and XML test screens.
+
+    /**
+     * Regression test: autocapture events must NOT be gated by trackAutomaticEvents flag.
+     * The trackAutomaticEvents flag controls legacy $ae_ lifecycle events only.
+     * Autocapture events ($mp_click, $mp_rage_click, $mp_dead_click) must flow
+     * regardless of this flag.
+     *
+     * @see <a href="https://github.com/mixpanel/mixpanel-android/pull/982#issuecomment-4860033738">PR #982 review - Issue 1</a>
+     */
+    @Test
+    public void testAutocaptureEventsNotDroppedWhenTrackAutomaticEventsFalse() throws Exception {
+        // Create a separate MixpanelAPI with trackAutomaticEvents=false
+        final BlockingQueue<JSONObject> events = new LinkedBlockingQueue<>();
+        final TestUtils.EmptyPreferences prefs = new TestUtils.EmptyPreferences(mContext);
+        final MPConfig config = MPConfig.getInstance(mContext, null);
+
+        final MPDbAdapter adapter = new MPDbAdapter(mContext, config) {
+            @Override
+            public int addJSON(JSONObject message, String token, MPDbAdapter.Table table) {
+                if (table == MPDbAdapter.Table.EVENTS) {
+                    try {
+                        String eventName = message.optString("event", "");
+                        if (eventName.startsWith("$mp_")) {
+                            events.add(message);
+                        }
+                    } catch (Exception e) {
+                        // ignore
+                    }
+                }
+                return super.addJSON(message, token, table);
+            }
+        };
+
+        final AnalyticsMessages messages = new AnalyticsMessages(mContext, config) {
+            @Override
+            protected MPDbAdapter makeDbAdapter(Context context) {
+                return adapter;
+            }
+        };
+
+        AutocaptureOptions autocaptureOpts = new AutocaptureOptions.Builder().build();
+        MixpanelOptions opts = new MixpanelOptions.Builder()
+                .autocaptureOptions(autocaptureOpts)
+                .build();
+
+        // trackAutomaticEvents = FALSE
+        MixpanelAPI api = new MixpanelAPI(mContext, prefs, "TRACK_AUTO_FALSE_TOKEN", config, opts, false) {
+            @Override
+            AnalyticsMessages getAnalyticsMessages() {
+                return messages;
+            }
+
+            @Override
+            PersistentIdentity getPersistentIdentity(
+                    final Context context,
+                    final Future<SharedPreferences> referrerPreferences,
+                    final String token,
+                    final String instanceName,
+                    final DeviceIdProvider deviceIdProvider) {
+                String instanceKey = instanceName != null ? instanceName : token;
+                final String prefsName = "com.mixpanel.android.mpmetrics.MixpanelAPI_" + instanceKey;
+                final SharedPreferences ret = context.getSharedPreferences(prefsName, Context.MODE_PRIVATE);
+                ret.edit().clear().commit();
+                final String timeEventsPrefsName = "com.mixpanel.android.mpmetrics.MixpanelAPI.TimeEvents_" + instanceKey;
+                final SharedPreferences timeSharedPrefs = context.getSharedPreferences(timeEventsPrefsName, Context.MODE_PRIVATE);
+                timeSharedPrefs.edit().clear().commit();
+                final String mixpanelPrefsName = "com.mixpanel.android.mpmetrics.Mixpanel";
+                final SharedPreferences mpSharedPrefs = context.getSharedPreferences(mixpanelPrefsName, Context.MODE_PRIVATE);
+                mpSharedPrefs.edit().clear().putBoolean(token, true).putBoolean("has_launched", true).apply();
+                return super.getPersistentIdentity(context, referrerPreferences, token, instanceName, deviceIdProvider);
+            }
+        };
+
+        try (ActivityScenario<AutocaptureXmlTestActivity> scenario =
+                     ActivityScenario.launch(AutocaptureXmlTestActivity.class)) {
+
+            Thread.sleep(500);
+
+            onView(withId(AutocaptureXmlTestActivity.ID_RULE1_BTN)).perform(click());
+
+            JSONObject event = events.poll(10, TimeUnit.SECONDS);
+            assertNotNull(
+                    "Autocapture $mp_click must not be dropped when trackAutomaticEvents=false",
+                    event);
+            assertEquals("$mp_click", event.getString("event"));
+        } finally {
+            api.clearSuperProperties();
+            api.flush();
+        }
+    }
+
+    @Test
+    public void testElementIdResolutionRule3HashFallback() throws Exception {
+        try (ActivityScenario<AutocaptureXmlTestActivity> scenario =
+                     ActivityScenario.launch(AutocaptureXmlTestActivity.class)) {
+
+            Thread.sleep(500);
+
+            // Click button with no contentDescription and invalid resource ID (10003)
+            // This forces resolveElementId to fall through Rule 1 and Rule 2 to the hash fallback
+            onView(withId(AutocaptureXmlTestActivity.ID_RULE3_BTN)).perform(click());
+
+            JSONObject event = mEvents.poll(10, TimeUnit.SECONDS);
+            assertNotNull("Event should be captured", event);
+
+            JSONObject properties = event.getJSONObject("properties");
+
+            // Verify $el_id uses hash fallback format: ClassName_<hexHashCode>
+            String elId = properties.getString("$el_id");
+            assertTrue("$el_id should start with 'Button_' for hash fallback, got: " + elId,
+                    elId.matches("Button_[0-9a-f]+"));
+        }
+    }
+
+}
diff --git a/analytics/src/androidTest/java/com/mixpanel/android/mpmetrics/AutocaptureXmlTestActivity.java b/analytics/src/androidTest/java/com/mixpanel/android/mpmetrics/AutocaptureXmlTestActivity.java
new file mode 100644
index 000000000..20417bb2c
--- /dev/null
+++ b/analytics/src/androidTest/java/com/mixpanel/android/mpmetrics/AutocaptureXmlTestActivity.java
@@ -0,0 +1,224 @@
+package com.mixpanel.android.mpmetrics;
+
+import android.os.Bundle;
+import android.view.View;
+import android.view.ViewGroup;
+import android.widget.Button;
+import android.widget.LinearLayout;
+import android.widget.ScrollView;
+import android.widget.TextView;
+
+import androidx.activity.ComponentActivity;
+import androidx.compose.runtime.MutableIntState;
+import androidx.compose.ui.platform.ComposeView;
+
+/**
+ * Test activity for autocapture instrumentation tests.
+ * UI is created programmatically to avoid R class issues in library modules.
+ *
+ * <p>Includes mixed-framework elements (ComposeView inside XML) for cross-framework
+ * dead click testing.
+ */
+public class AutocaptureXmlTestActivity extends ComponentActivity {
+
+    public static final int ID_RULE1_BTN = 10001;
+    public static final int ID_RULE2_BTN = android.R.id.button1;
+    public static final int ID_RULE3_BTN = 10003;
+    public static final int ID_DEAD_XML_BTN = 10004;
+    public static final int ID_RAGE_ZONE = 10005;
+    public static final int ID_ALERT_DIALOG_BTN = 10006;
+    public static final int ID_BOTTOM_SHEET_BTN = 10007;
+
+    // Mixed-framework dead click test IDs
+    public static final int ID_XML_BTN_XML_TEXT = 10010;
+    public static final int ID_XML_TEXT_COUNTER = 10011;
+    public static final int ID_XML_BTN_COMPOSE_TEXT = 10012;
+    public static final int ID_COMPOSE_VIEW = 10013;
+
+    // Counters for mixed-framework tests
+    private int mXmlCounter = 0;
+    private int mComposeCounter = 0;
+
+    // Compose state exposed for the ComposeView
+    // Accessed from MixedFrameworkComposeContent helper
+    MutableIntState composeTextCounter;
+    TextView xmlTextCounter;
+
+    @Override
+    protected void onCreate(Bundle savedInstanceState) {
+        super.onCreate(savedInstanceState);
+
+        // Create layout programmatically
+        ScrollView scrollView = new ScrollView(this);
+        scrollView.setLayoutParams(new ViewGroup.LayoutParams(
+                ViewGroup.LayoutParams.MATCH_PARENT,
+                ViewGroup.LayoutParams.MATCH_PARENT));
+
+        LinearLayout layout = new LinearLayout(this);
+        layout.setOrientation(LinearLayout.VERTICAL);
+        layout.setLayoutParams(new ViewGroup.LayoutParams(
+                ViewGroup.LayoutParams.MATCH_PARENT,
+                ViewGroup.LayoutParams.WRAP_CONTENT));
+        int padding = dpToPx(16);
+        layout.setPadding(padding, padding, padding, padding);
+
+        // Rule 1 button - contentDescription priority
+        Button rule1Btn = createButton("Rule 1 - contentDescription");
+        rule1Btn.setId(ID_RULE1_BTN);
+        rule1Btn.setContentDescription("rule1_btn");
+        rule1Btn.setOnClickListener(v -> {});
+        layout.addView(rule1Btn);
+
+        // Rule 2 button - resource ID fallback
+        Button rule2Btn = createButton("Rule 2 - resource ID");
+        rule2Btn.setId(ID_RULE2_BTN);
+        rule2Btn.setOnClickListener(v -> {});
+        addMarginTop(rule2Btn, 8);
+        layout.addView(rule2Btn);
+
+        // Rule 3 button - hash fallback (no contentDescription, invalid resource ID)
+        Button rule3Btn = createButton("Rule 3 - hash fallback");
+        rule3Btn.setId(ID_RULE3_BTN);
+        rule3Btn.setOnClickListener(v -> {});
+        addMarginTop(rule3Btn, 8);
+        layout.addView(rule3Btn);
+
+        // Dead click button - no listener
+        Button deadBtn = createButton("Dead Button (no listener)");
+        deadBtn.setId(ID_DEAD_XML_BTN);
+        deadBtn.setContentDescription("dead_xml_btn");
+        addMarginTop(deadBtn, 16);
+        layout.addView(deadBtn);
+
+        // Rage zone - clickable view
+        View rageZone = new View(this);
+        rageZone.setId(ID_RAGE_ZONE);
+        rageZone.setLayoutParams(new LinearLayout.LayoutParams(
+                ViewGroup.LayoutParams.MATCH_PARENT,
+                dpToPx(80)));
+        rageZone.setBackgroundColor(0x1AFF0000); // Semi-transparent red
+        rageZone.setClickable(true);
+        rageZone.setFocusable(true);
+        rageZone.setContentDescription("rage_zone");
+        addMarginTop(rageZone, 16);
+        layout.addView(rageZone);
+
+        // AlertDialog trigger button
+        Button alertBtn = createButton("Show AlertDialog");
+        alertBtn.setId(ID_ALERT_DIALOG_BTN);
+        alertBtn.setContentDescription("test_alert_trigger");
+        alertBtn.setOnClickListener(v -> {
+            android.app.AlertDialog dialog = new android.app.AlertDialog.Builder(this)
+                    .setTitle("Test Alert Dialog")
+                    .setMessage("Tap buttons inside this dialog")
+                    .setPositiveButton("Confirm", null)
+                    .setNegativeButton("Cancel", null)
+                    .show();
+            dialog.getButton(android.app.AlertDialog.BUTTON_POSITIVE)
+                    .setContentDescription("test_alert_confirm");
+            dialog.getButton(android.app.AlertDialog.BUTTON_NEGATIVE)
+                    .setContentDescription("test_alert_cancel");
+        });
+        addMarginTop(alertBtn, 16);
+        layout.addView(alertBtn);
+
+        // BottomSheet trigger button (uses a regular Dialog for test simplicity)
+        Button sheetBtn = createButton("Show Bottom Sheet");
+        sheetBtn.setId(ID_BOTTOM_SHEET_BTN);
+        sheetBtn.setContentDescription("test_sheet_trigger");
+        sheetBtn.setOnClickListener(v -> {
+            android.app.Dialog dialog = new android.app.Dialog(this);
+            LinearLayout sheetLayout = new LinearLayout(this);
+            sheetLayout.setOrientation(LinearLayout.VERTICAL);
+            int pad = dpToPx(16);
+            sheetLayout.setPadding(pad, pad, pad, pad);
+
+            Button sheetAction = new Button(this);
+            sheetAction.setText("Sheet Action");
+            sheetAction.setContentDescription("test_sheet_action");
+            sheetLayout.addView(sheetAction, new LinearLayout.LayoutParams(
+                    ViewGroup.LayoutParams.MATCH_PARENT,
+                    ViewGroup.LayoutParams.WRAP_CONTENT));
+
+            dialog.setContentView(sheetLayout);
+            dialog.show();
+        });
+        addMarginTop(sheetBtn, 8);
+        layout.addView(sheetBtn);
+
+        // ============ Mixed-Framework Dead Click Test Elements ============
+
+        // XML button that changes XML text
+        Button xmlBtnXmlText = createButton("XML Btn -> XML Text");
+        xmlBtnXmlText.setId(ID_XML_BTN_XML_TEXT);
+        xmlBtnXmlText.setContentDescription("xml_btn_xml_text");
+        addMarginTop(xmlBtnXmlText, 16);
+        layout.addView(xmlBtnXmlText);
+
+        // XML text counter (updated by XML and Compose buttons)
+        xmlTextCounter = new TextView(this);
+        xmlTextCounter.setId(ID_XML_TEXT_COUNTER);
+        xmlTextCounter.setLayoutParams(new LinearLayout.LayoutParams(
+                ViewGroup.LayoutParams.MATCH_PARENT,
+                ViewGroup.LayoutParams.WRAP_CONTENT));
+        xmlTextCounter.setText("XML counter: 0");
+        xmlTextCounter.setContentDescription("xml_text_counter");
+        addMarginTop(xmlTextCounter, 4);
+        layout.addView(xmlTextCounter);
+
+        // XML button that changes Compose text
+        Button xmlBtnComposeText = createButton("XML Btn -> Compose Text");
+        xmlBtnComposeText.setId(ID_XML_BTN_COMPOSE_TEXT);
+        xmlBtnComposeText.setContentDescription("xml_btn_compose_text");
+        addMarginTop(xmlBtnComposeText, 8);
+        layout.addView(xmlBtnComposeText);
+
+        // ComposeView hosting Compose button + Compose text counter
+        ComposeView composeView = new ComposeView(this);
+        composeView.setId(ID_COMPOSE_VIEW);
+        composeView.setLayoutParams(new LinearLayout.LayoutParams(
+                ViewGroup.LayoutParams.MATCH_PARENT,
+                ViewGroup.LayoutParams.WRAP_CONTENT));
+        addMarginTop(composeView, 8);
+        layout.addView(composeView);
+
+        // Wire up XML button -> XML text
+        xmlBtnXmlText.setOnClickListener(v -> {
+            mXmlCounter++;
+            xmlTextCounter.setText("XML counter: " + mXmlCounter);
+        });
+
+        // Wire up XML button -> Compose text (increments compose state)
+        xmlBtnComposeText.setOnClickListener(v -> {
+            if (composeTextCounter != null) {
+                composeTextCounter.setIntValue(composeTextCounter.getIntValue() + 1);
+            }
+        });
+
+        // Set Compose content with buttons and text counter
+        MixedFrameworkComposeContent.setContent(composeView, this);
+
+        scrollView.addView(layout);
+        setContentView(scrollView);
+    }
+
+    private Button createButton(String text) {
+        Button button = new Button(this);
+        button.setLayoutParams(new LinearLayout.LayoutParams(
+                ViewGroup.LayoutParams.MATCH_PARENT,
+                ViewGroup.LayoutParams.WRAP_CONTENT));
+        button.setText(text);
+        return button;
+    }
+
+    private void addMarginTop(View view, int dp) {
+        LinearLayout.LayoutParams params = (LinearLayout.LayoutParams) view.getLayoutParams();
+        params.topMargin = dpToPx(dp);
+        view.setLayoutParams(params);
+    }
+
+    private int dpToPx(int dp) {
+        float density = getResources().getDisplayMetrics().density;
+        return Math.round(dp * density);
+    }
+}
diff --git a/analytics/src/androidTest/java/com/mixpanel/android/mpmetrics/MixedFrameworkComposeContent.kt b/analytics/src/androidTest/java/com/mixpanel/android/mpmetrics/MixedFrameworkComposeContent.kt
new file mode 100644
index 000000000..0777766e7
--- /dev/null
+++ b/analytics/src/androidTest/java/com/mixpanel/android/mpmetrics/MixedFrameworkComposeContent.kt
@@ -0,0 +1,75 @@
+package com.mixpanel.android.mpmetrics
+
+import androidx.compose.foundation.layout.Column
+import androidx.compose.foundation.layout.fillMaxWidth
+import androidx.compose.foundation.layout.padding
+import androidx.compose.material3.Button
+import androidx.compose.material3.Text
+import androidx.compose.runtime.mutableIntStateOf
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.platform.ComposeView
+import androidx.compose.ui.semantics.contentDescription
+import androidx.compose.ui.semantics.semantics
+import androidx.compose.ui.unit.dp
+
+/**
+ * Sets up Compose content inside a ComposeView for mixed-framework dead click testing
+ * in [AutocaptureXmlTestActivity].
+ *
+ * Contains:
+ * - A Compose button that updates the XML TextView counter
+ * - A Compose button that updates the Compose text counter
+ * - A Compose text displaying the counter value
+ */
+object MixedFrameworkComposeContent {
+
+    @JvmStatic
+    fun setContent(composeView: ComposeView, activity: AutocaptureXmlTestActivity) {
+        val composeTextCounter = mutableIntStateOf(0)
+        activity.composeTextCounter = composeTextCounter
+
+        composeView.setContent {
+            Column(
+                modifier = Modifier
+                    .fillMaxWidth()
+                    .padding(8.dp)
+            ) {
+                // Compose button that changes XML text
+                Button(
+                    onClick = {
+                        val xmlCounter = activity.xmlTextCounter
+                        val currentText = xmlCounter.text.toString()
+                        val currentCount = currentText.substringAfter(": ").toIntOrNull() ?: 0
+                        xmlCounter.text = "XML counter: ${currentCount + 1}"
+                    },
+                    modifier = Modifier
+                        .fillMaxWidth()
+                        .semantics { contentDescription = "compose_btn_xml_text" }
+                ) {
+                    Text("Compose Btn -> XML Text")
+                }
+
+                // Compose button that changes Compose text
+                Button(
+                    onClick = {
+                        composeTextCounter.intValue++
+                    },
+                    modifier = Modifier
+                        .fillMaxWidth()
+                        .padding(top = 8.dp)
+                        .semantics { contentDescription = "compose_btn_compose_text" }
+                ) {
+                    Text("Compose Btn -> Compose Text")
+                }
+
+                // Compose text counter
+                Text(
+                    text = "Compose counter: ${composeTextCounter.intValue}",
+                    modifier = Modifier
+                        .padding(top = 8.dp)
+                        .semantics { contentDescription = "compose_text_counter" }
+                )
+            }
+        }
+    }
+}
diff --git a/analytics/src/androidTest/java/com/mixpanel/android/mpmetrics/OptOutTest.java b/analytics/src/androidTest/java/com/mixpanel/android/mpmetrics/OptOutTest.java
index 0456fbc7a..28245e70f 100644
--- a/analytics/src/androidTest/java/com/mixpanel/android/mpmetrics/OptOutTest.java
+++ b/analytics/src/androidTest/java/com/mixpanel/android/mpmetrics/OptOutTest.java
@@ -8,6 +8,7 @@
 import androidx.test.ext.junit.runners.AndroidJUnit4;
 import androidx.test.platform.app.InstrumentationRegistry;
 
+import com.mixpanel.android.autocapture.AutocaptureManager;
 import com.mixpanel.android.util.Base64Coder;
 import com.mixpanel.android.util.HttpService;
 import com.mixpanel.android.util.ProxyServerInteractor;
@@ -378,6 +379,174 @@ private void forceFlush() {
         mAnalyticsMessages.postToServer(new AnalyticsMessages.MixpanelDescription(TOKEN));
     }
 
+    // region Autocapture opt-out tests
+
+    @Test
+    public void testAutocaptureNotStartedWhenOptedOutByDefault() {
+        MixpanelOptions options = new MixpanelOptions.Builder()
+                .optOutTrackingDefault(true)
+                .autocaptureOptions(new AutocaptureOptions.Builder().build())
+                .build();
+
+        mMixpanelAPI = new MixpanelAPI(
+                InstrumentationRegistry.getInstrumentation().getContext(),
+                mMockReferrerPreferences,
+                TOKEN,
+                MPConfig.getInstance(InstrumentationRegistry.getInstrumentation().getContext(), null),
+                options,
+                false) {
+            @Override
+            PersistentIdentity getPersistentIdentity(
+                    Context context, Future<SharedPreferences> referrerPreferences,
+                    String token, String instanceName, DeviceIdProvider deviceIdProvider) {
+                String prefsName = "com.mixpanel.android.mpmetrics.MixpanelAPI_" + token;
+                context.getSharedPreferences(prefsName, Context.MODE_PRIVATE).edit().clear().commit();
+                mPersistentIdentity = super.getPersistentIdentity(context, referrerPreferences, token, instanceName, deviceIdProvider);
+                return mPersistentIdentity;
+            }
+
+            @Override
+            AnalyticsMessages getAnalyticsMessages() {
+                return mAnalyticsMessages;
+            }
+        };
+
+        assertTrue("Should be opted out", mMixpanelAPI.hasOptedOutTracking());
+        assertNull("AutocaptureManager should not be created when opted out by default",
+                mMixpanelAPI.getAutocaptureManager());
+    }
+
+    @Test
+    public void testAutocaptureStopsOnOptOut() {
+        MixpanelOptions options = new MixpanelOptions.Builder()
+                .autocaptureOptions(new AutocaptureOptions.Builder().build())
+                .build();
+
+        mMixpanelAPI = new MixpanelAPI(
+                InstrumentationRegistry.getInstrumentation().getContext(),
+                mMockReferrerPreferences,
+                TOKEN,
+                MPConfig.getInstance(InstrumentationRegistry.getInstrumentation().getContext(), null),
+                options,
+                false) {
+            @Override
+            PersistentIdentity getPersistentIdentity(
+                    Context context, Future<SharedPreferences> referrerPreferences,
+                    String token, String instanceName, DeviceIdProvider deviceIdProvider) {
+                String prefsName = "com.mixpanel.android.mpmetrics.MixpanelAPI_" + token;
+                context.getSharedPreferences(prefsName, Context.MODE_PRIVATE).edit().clear().commit();
+                // Clear opt-out flag from prior test runs
+                String mixpanelPrefsName = "com.mixpanel.android.mpmetrics.Mixpanel";
+                context.getSharedPreferences(mixpanelPrefsName, Context.MODE_PRIVATE).edit()
+                        .remove(token).remove("opt_out_" + token).commit();
+                mPersistentIdentity = super.getPersistentIdentity(context, referrerPreferences, token, instanceName, deviceIdProvider);
+                return mPersistentIdentity;
+            }
+
+            @Override
+            AnalyticsMessages getAnalyticsMessages() {
+                return mAnalyticsMessages;
+            }
+        };
+
+        assertNotNull("AutocaptureManager should be created", mMixpanelAPI.getAutocaptureManager());
+        assertTrue("AutocaptureManager should be started", mMixpanelAPI.getAutocaptureManager().isStarted());
+
+        mMixpanelAPI.optOutTracking();
+
+        assertFalse("AutocaptureManager should be stopped after opt-out",
+                mMixpanelAPI.getAutocaptureManager().isStarted());
+    }
+
+    @Test
+    public void testAutocaptureRestartsOnOptIn() {
+        MixpanelOptions options = new MixpanelOptions.Builder()
+                .autocaptureOptions(new AutocaptureOptions.Builder().build())
+                .build();
+
+        mMixpanelAPI = new MixpanelAPI(
+                InstrumentationRegistry.getInstrumentation().getContext(),
+                mMockReferrerPreferences,
+                TOKEN,
+                MPConfig.getInstance(InstrumentationRegistry.getInstrumentation().getContext(), null),
+                options,
+                false) {
+            @Override
+            PersistentIdentity getPersistentIdentity(
+                    Context context, Future<SharedPreferences> referrerPreferences,
+                    String token, String instanceName, DeviceIdProvider deviceIdProvider) {
+                String prefsName = "com.mixpanel.android.mpmetrics.MixpanelAPI_" + token;
+                context.getSharedPreferences(prefsName, Context.MODE_PRIVATE).edit().clear().commit();
+                // Clear opt-out flag from prior test runs
+                String mixpanelPrefsName = "com.mixpanel.android.mpmetrics.Mixpanel";
+                context.getSharedPreferences(mixpanelPrefsName, Context.MODE_PRIVATE).edit()
+                        .remove(token).remove("opt_out_" + token).commit();
+                mPersistentIdentity = super.getPersistentIdentity(context, referrerPreferences, token, instanceName, deviceIdProvider);
+                return mPersistentIdentity;
+            }
+
+            @Override
+            AnalyticsMessages getAnalyticsMessages() {
+                return mAnalyticsMessages;
+            }
+        };
+
+        // Opt out — autocapture stops
+        mMixpanelAPI.optOutTracking();
+        assertFalse("AutocaptureManager should be stopped after opt-out",
+                mMixpanelAPI.getAutocaptureManager().isStarted());
+
+        // Opt in — autocapture restarts
+        mMixpanelAPI.optInTracking();
+        assertNotNull("AutocaptureManager should exist after opt-in",
+                mMixpanelAPI.getAutocaptureManager());
+        assertTrue("AutocaptureManager should be started after opt-in",
+                mMixpanelAPI.getAutocaptureManager().isStarted());
+    }
+
+    @Test
+    public void testAutocaptureStartsOnOptInAfterOptOutByDefault() {
+        MixpanelOptions options = new MixpanelOptions.Builder()
+                .optOutTrackingDefault(true)
+                .autocaptureOptions(new AutocaptureOptions.Builder().build())
+                .build();
+
+        mMixpanelAPI = new MixpanelAPI(
+                InstrumentationRegistry.getInstrumentation().getContext(),
+                mMockReferrerPreferences,
+                TOKEN,
+                MPConfig.getInstance(InstrumentationRegistry.getInstrumentation().getContext(), null),
+                options,
+                false) {
+            @Override
+            PersistentIdentity getPersistentIdentity(
+                    Context context, Future<SharedPreferences> referrerPreferences,
+                    String token, String instanceName, DeviceIdProvider deviceIdProvider) {
+                String prefsName = "com.mixpanel.android.mpmetrics.MixpanelAPI_" + token;
+                context.getSharedPreferences(prefsName, Context.MODE_PRIVATE).edit().clear().commit();
+                mPersistentIdentity = super.getPersistentIdentity(context, referrerPreferences, token, instanceName, deviceIdProvider);
+                return mPersistentIdentity;
+            }
+
+            @Override
+            AnalyticsMessages getAnalyticsMessages() {
+                return mAnalyticsMessages;
+            }
+        };
+
+        assertNull("AutocaptureManager should not be created when opted out by default",
+                mMixpanelAPI.getAutocaptureManager());
+
+        // Opt in — autocapture should be created and started
+        mMixpanelAPI.optInTracking();
+        assertNotNull("AutocaptureManager should be created after opt-in",
+                mMixpanelAPI.getAutocaptureManager());
+        assertTrue("AutocaptureManager should be started after opt-in",
+                mMixpanelAPI.getAutocaptureManager().isStarted());
+    }
+
+    // endregion
+
     private MPDbAdapter getMockDBAdapter() {
         return new MPDbAdapter(InstrumentationRegistry.getInstrumentation().getContext(), MPConfig.getInstance(InstrumentationRegistry.getInstrumentation().getContext(), null)) {
 
diff --git a/analytics/src/main/java/com/mixpanel/android/autocapture/AutocaptureDefaults.java b/analytics/src/main/java/com/mixpanel/android/autocapture/AutocaptureDefaults.java
new file mode 100644
index 000000000..066de9f3d
--- /dev/null
+++ b/analytics/src/main/java/com/mixpanel/android/autocapture/AutocaptureDefaults.java
@@ -0,0 +1,88 @@
+package com.mixpanel.android.autocapture;
+
+/**
+ * Internal constants for autocapture functionality.
+ *
+ * <p>These values are not exposed in the public API but can be adjusted internally if needed.
+ */
+final class AutocaptureDefaults {
+
+    /**
+     * Maximum depth of the view hierarchy captured in {@code $elements}.
+     * Limits the number of ancestor elements included in the hierarchy string.
+     */
+    static final int MAX_HIERARCHY_DEPTH = 5;
+
+    /**
+     * Maximum number of accessibility nodes to visit during hit-test traversal.
+     * Limits total work per tap on complex screens (e.g., large RecyclerViews,
+     * dashboards with many cards). When exceeded, the traversal returns the best
+     * match found so far rather than continuing to search.
+     */
+    static final int MAX_ACCESSIBILITY_NODES = 200;
+
+    /**
+     * Maximum recursion depth for tree traversal operations.
+     * Prevents {@code StackOverflowError} in deeply nested view/semantic trees.
+     */
+    static final int MAX_RECURSION_DEPTH = 20;
+
+    /**
+     * Event name for click events.
+     */
+    static final String EVENT_CLICK = "$mp_click";
+
+    /**
+     * Event name for rage click events.
+     */
+    static final String EVENT_RAGE_CLICK = "$mp_rage_click";
+
+    /**
+     * Event name for dead click events.
+     */
+    static final String EVENT_DEAD_CLICK = "$mp_dead_click";
+
+    /**
+     * Property name for X coordinate.
+     */
+    static final String PROP_X = "$x";
+
+    /**
+     * Property name for Y coordinate.
+     */
+    static final String PROP_Y = "$y";
+
+    /**
+     * Property name for element ID.
+     */
+    static final String PROP_EL_ID = "$el_id";
+
+    /**
+     * Property name for element tag name (class name).
+     */
+    static final String PROP_EL_TAG_NAME = "$el_tag_name";
+
+    /**
+     * Property name for accessibility label (contentDescription).
+     */
+    static final String PROP_ARIA_LABEL = "$attr-aria-label";
+
+    /**
+     * Property name for element role.
+     */
+    static final String PROP_ROLE = "$attr-role";
+
+    /**
+     * Property name for view hierarchy.
+     */
+    static final String PROP_ELEMENTS = "$elements";
+
+    /**
+     * Separator used in view hierarchy string.
+     */
+    static final String HIERARCHY_SEPARATOR = " > ";
+
+    private AutocaptureDefaults() {
+        // Prevent instantiation
+    }
+}
diff --git a/analytics/src/main/java/com/mixpanel/android/autocapture/AutocaptureManager.java b/analytics/src/main/java/com/mixpanel/android/autocapture/AutocaptureManager.java
new file mode 100644
index 000000000..1df37c337
--- /dev/null
+++ b/analytics/src/main/java/com/mixpanel/android/autocapture/AutocaptureManager.java
@@ -0,0 +1,335 @@
+package com.mixpanel.android.autocapture;
+
+import android.app.Activity;
+import android.app.Application;
+import android.content.Context;
+import android.os.Bundle;
+import android.view.View;
+import android.view.Window;
+
+import androidx.annotation.MainThread;
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+
+import com.mixpanel.android.mpmetrics.AutocaptureOptions;
+import com.mixpanel.android.mpmetrics.MixpanelAPI;
+import com.mixpanel.android.util.MPLog;
+
+import curtains.Curtains;
+import curtains.OnTouchEventListener;
+
+import java.util.Map;
+import java.util.WeakHashMap;
+
+/**
+ * Main coordinator for autocapture functionality.
+ *
+ * <p>Manages the lifecycle of touch interception, semantic extraction, and event detection
+ * (click, rage click, dead click). Integrates with the application lifecycle to attach
+ * and detach interceptors appropriately.
+ *
+ * <p>Thread safety: All public methods must be called from the main thread.
+ * {@link #start()} and {@link #stop()} are idempotent — duplicate calls are no-ops.
+ */
+public final class AutocaptureManager implements
+        Application.ActivityLifecycleCallbacks,
+        WindowSpy.OnRootViewChangedListener,
+        TapListener,
+        DeadClickDetector.DeadClickListener {
+
+    private static final String TAG = "MP.AutocaptureManager";
+
+    private final Context mContext;
+    private final AutocaptureOptions mOptions;
+    private final MixpanelAPI.Autocapture mAutocapture;
+
+    @Nullable
+    private RageClickTracker mRageClickTracker;
+    @Nullable
+    private DeadClickDetector mDeadClickDetector;
+
+    // Track Curtains touch listeners per window to avoid duplicates and enable cleanup
+    private final Map<Window, OnTouchEventListener> mWindowListeners = new WeakHashMap<>();
+
+    private boolean mStarted = false;
+
+    /**
+     * Returns whether autocapture is currently started.
+     */
+    public boolean isStarted() {
+        return mStarted;
+    }
+
+    /**
+     * Creates an AutocaptureManager.
+     *
+     * @param context     The application context.
+     * @param options     The autocapture configuration options.
+     * @param autocapture The Autocapture instance for event tracking.
+     */
+    public AutocaptureManager(
+            @NonNull Context context,
+            @NonNull AutocaptureOptions options,
+            @NonNull MixpanelAPI.Autocapture autocapture) {
+        mContext = context.getApplicationContext();
+        mOptions = options;
+        mAutocapture = autocapture;
+
+        // Initialize trackers based on options
+        if (mOptions.getRageClickOptions().isEnabled()) {
+            mRageClickTracker = new RageClickTracker(mOptions.getRageClickOptions(), mContext);
+        }
+
+        if (mOptions.getDeadClickOptions().isEnabled()) {
+            mDeadClickDetector = new DeadClickDetector(mOptions.getDeadClickOptions(), this);
+        }
+    }
+
+    /**
+     * Starts autocapture.
+     *
+     * <p>Registers lifecycle callbacks and installs window tracking.
+     * This should be called once during SDK initialization.
+     * Duplicate calls are no-ops.
+     */
+    @MainThread
+    public void start() {
+        if (mStarted) {
+            return;
+        }
+
+        try {
+            // Register activity lifecycle callbacks
+            if (mContext instanceof Application) {
+                ((Application) mContext).registerActivityLifecycleCallbacks(this);
+            }
+
+            // Install WindowSpy (Curtains-backed) for dialog/popup tracking
+            WindowSpy.install();
+            WindowSpy.addListener(this);
+
+            // Retroactively attach to already-visible root views.
+            // registerActivityLifecycleCallbacks does not replay onActivityResumed
+            // for already-resumed activities, and WindowSpy's initial copy of existing
+            // views doesn't trigger add notifications. This ensures deferred SDK init
+            // captures the current screen.
+            for (View rootView : Curtains.getRootViews()) {
+                onRootViewChanged(rootView, true);
+            }
+
+            mStarted = true;
+            MPLog.d(TAG, "Autocapture started");
+
+        } catch (Exception e) {
+            MPLog.e(TAG, "Failed to start autocapture", e);
+        }
+    }
+
+    /**
+     * Stops autocapture.
+     *
+     * <p>Unregisters lifecycle callbacks and removes all interceptors.
+     * Duplicate calls are no-ops.
+     */
+    @MainThread
+    public void stop() {
+        if (!mStarted) {
+            return;
+        }
+
+        try {
+            // Unregister activity lifecycle callbacks
+            if (mContext instanceof Application) {
+                ((Application) mContext).unregisterActivityLifecycleCallbacks(this);
+            }
+
+            // Remove WindowSpy listener
+            WindowSpy.removeListener(this);
+
+            // Remove all Curtains touch listeners
+            for (Map.Entry<Window, OnTouchEventListener> entry :
+                    new java.util.ArrayList<>(mWindowListeners.entrySet())) {
+                CurtainsHelper.removeTouchListener(entry.getKey(), entry.getValue());
+            }
+            mWindowListeners.clear();
+
+            // Cancel pending detection
+            if (mDeadClickDetector != null) {
+                mDeadClickDetector.cancelDetection();
+            }
+
+            // Clear rage click history
+            if (mRageClickTracker != null) {
+                mRageClickTracker.clear();
+            }
+
+            mStarted = false;
+            MPLog.d(TAG, "Autocapture stopped");
+
+        } catch (Exception e) {
+            MPLog.e(TAG, "Error stopping autocapture", e);
+        }
+    }
+
+    // ==================== TapListener ====================
+
+    @Override
+    public void onTap(float x, float y, @NonNull View decorView) {
+        try {
+            processTouchEvent(x, y, decorView);
+        } catch (Exception e) {
+            MPLog.e(TAG, "Error processing touch event", e);
+        }
+    }
+
+    private void processTouchEvent(float x, float y, @NonNull View decorView) {
+        // Extract semantics from the touched view
+        ClickEvent.Builder builder = SemanticExtractor.extract(decorView, x, y);
+        if (builder == null) {
+            // No view found at position
+            return;
+        }
+
+        ClickEvent clickEvent = builder.build();
+
+        // Track basic click
+        if (mOptions.getClickOptions().isEnabled()) {
+            mAutocapture.trackClick(clickEvent);
+            MPLog.d(TAG, "Emitted $mp_click event");
+        }
+
+        // Check for rage click
+        if (mRageClickTracker != null) {
+            ClickEvent rageClick = mRageClickTracker.recordClick(clickEvent);
+            if (rageClick != null) {
+                mAutocapture.trackRageClick(rageClick);
+                MPLog.d(TAG, "Emitted $mp_rage_click event");
+            }
+        }
+
+        // Start dead click detection
+        if (mDeadClickDetector != null) {
+            mDeadClickDetector.startDetection(clickEvent, decorView);
+        }
+    }
+
+    // ==================== DeadClickDetector.DeadClickListener ====================
+
+    @Override
+    public void onDeadClickDetected(@NonNull ClickEvent clickEvent) {
+        try {
+            mAutocapture.trackDeadClick(clickEvent);
+            MPLog.d(TAG, "Emitted $mp_dead_click event");
+        } catch (Exception e) {
+            MPLog.e(TAG, "Error emitting dead click event", e);
+        }
+    }
+
+    // ==================== WindowSpy.OnRootViewChangedListener ====================
+
+    @Override
+    public void onRootViewChanged(@NonNull View view, boolean added) {
+        try {
+            if (added) {
+                // Notify dead click detector - new window is a UI change
+                if (mDeadClickDetector != null) {
+                    mDeadClickDetector.onWindowAdded();
+                }
+
+                // Try to attach touch listener via Curtains
+                Window window = CurtainsHelper.getWindow(view);
+                if (window != null && !mWindowListeners.containsKey(window)) {
+                    attachTouchListener(window);
+                }
+            } else {
+                // Window removed (dialog/sheet dismissed) — this is a UI change
+                if (mDeadClickDetector != null) {
+                    mDeadClickDetector.cancelDetection();
+                }
+            }
+        } catch (Exception e) {
+            MPLog.e(TAG, "Error handling root view change", e);
+        }
+    }
+
+    // ==================== Activity Lifecycle Callbacks ====================
+
+    @Override
+    public void onActivityCreated(@NonNull Activity activity, @Nullable Bundle savedInstanceState) {
+        // No action needed
+    }
+
+    @Override
+    public void onActivityStarted(@NonNull Activity activity) {
+        // No action needed
+    }
+
+    @Override
+    public void onActivityResumed(@NonNull Activity activity) {
+        try {
+            // Attach touch listener to activity window
+            Window window = activity.getWindow();
+            if (window != null && !mWindowListeners.containsKey(window)) {
+                attachTouchListener(window);
+            }
+        } catch (Exception e) {
+            MPLog.e(TAG, "Error in onActivityResumed", e);
+        }
+    }
+
+    @Override
+    public void onActivityPaused(@NonNull Activity activity) {
+        try {
+            // Cancel dead click detection - activity transition is a UI change
+            if (mDeadClickDetector != null) {
+                mDeadClickDetector.cancelDetection();
+            }
+
+            // Clear rage click history on activity change
+            if (mRageClickTracker != null) {
+                mRageClickTracker.clear();
+            }
+        } catch (Exception e) {
+            MPLog.e(TAG, "Error in onActivityPaused", e);
+        }
+    }
+
+    @Override
+    public void onActivityStopped(@NonNull Activity activity) {
+        // No action needed
+    }
+
+    @Override
+    public void onActivitySaveInstanceState(@NonNull Activity activity, @NonNull Bundle outState) {
+        // No action needed
+    }
+
+    @Override
+    public void onActivityDestroyed(@NonNull Activity activity) {
+        try {
+            // Clean up touch listener for this activity's window
+            Window window = activity.getWindow();
+            if (window != null) {
+                OnTouchEventListener listener = mWindowListeners.remove(window);
+                if (listener != null) {
+                    CurtainsHelper.removeTouchListener(window, listener);
+                }
+            }
+        } catch (Exception e) {
+            MPLog.e(TAG, "Error in onActivityDestroyed", e);
+        }
+    }
+
+    // ==================== Private Helpers ====================
+
+    /**
+     * Attaches a Curtains-based touch listener to a window.
+     * The listener filters for taps (touch slop + duration) and forwards to onTouchUp.
+     */
+    private void attachTouchListener(@NonNull Window window) {
+        OnTouchEventListener listener = CurtainsHelper.installTouchListener(window, this);
+        mWindowListeners.put(window, listener);
+        MPLog.d(TAG, "Attached touch listener to window: " + window);
+    }
+
+}
diff --git a/analytics/src/main/java/com/mixpanel/android/autocapture/ClickEvent.java b/analytics/src/main/java/com/mixpanel/android/autocapture/ClickEvent.java
new file mode 100644
index 000000000..daefb9499
--- /dev/null
+++ b/analytics/src/main/java/com/mixpanel/android/autocapture/ClickEvent.java
@@ -0,0 +1,269 @@
+package com.mixpanel.android.autocapture;
+
+import android.view.View;
+
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+
+import org.json.JSONException;
+import org.json.JSONObject;
+
+import java.lang.ref.WeakReference;
+
+/**
+ * Represents a captured click event with element metadata.
+ *
+ * <p>Contains all semantic information about the clicked element and its context.
+ * Create a {@code ClickEvent} using the {@link Builder} and pass it to
+ * {@code mixpanel.getAutocapture().trackClick()} to track click events with full element metadata.
+ */
+public final class ClickEvent {
+
+    /**
+     * Touch X coordinate in absolute screen pixels.
+     *
+     * <p>The SDK captures this as {@code event.getRawX()}.
+     * When tracking manually, use {@code motionEvent.getRawX()}.
+     */
+    public final float x;
+
+    /**
+     * Touch Y coordinate in absolute screen pixels.
+     *
+     * <p>The SDK captures this as {@code event.getRawY()}.
+     * When tracking manually, use {@code motionEvent.getRawY()}.
+     */
+    public final float y;
+
+    /**
+     * A stable identifier for the tapped element, used to group clicks in analytics.
+     *
+     * <p>Recommended sources (in order of preference):
+     * <ul>
+     *   <li>Resource ID name — stable and not user-visible
+     *       ({@code view.getResources().getResourceEntryName(view.getId())})</li>
+     *   <li>{@code contentDescription} — if no resource ID is set</li>
+     *   <li>Compose {@code Modifier.testTag("...")} value</li>
+     *   <li>A custom string like {@code "buy_button"} or {@code "settings_row_notifications"}</li>
+     * </ul>
+     *
+     * <p>Avoid dynamic values (e.g., adapter position, timestamp) — they prevent meaningful grouping.
+     */
+    @NonNull
+    public final String elementId;
+
+    /**
+     * The class name or component type of the tapped element.
+     *
+     * <p>Examples: {@code "Button"}, {@code "MaterialCardView"}, {@code "ComposeView"}.
+     * Use {@code view.getClass().getSimpleName()} to get the class name.
+     * Defaults to {@code null} if not provided.
+     */
+    @Nullable
+    public final String tagName;
+
+    /**
+     * The human-readable accessibility label of the element.
+     *
+     * <p>This is the text read aloud by TalkBack — typically the view's {@code contentDescription}.
+     * Examples: {@code "Add to cart"}, {@code "Play video"}, {@code "Close"}.
+     * Set to {@code null} if the element has no accessibility label.
+     */
+    @Nullable
+    public final String accessibleLabel;
+
+    /**
+     * The semantic role describing what the element does.
+     *
+     * <p>Common values: {@code "button"}, {@code "link"}, {@code "switch"}, {@code "checkbox"},
+     * {@code "slider"}, {@code "tab"}, {@code "textfield"}, {@code "image"}.
+     * Set to {@code null} if the element has no specific role.
+     */
+    @Nullable
+    public final String role;
+
+    /**
+     * View hierarchy path from the tapped element up to 5 ancestor levels, {@code ">"} separated.
+     *
+     * <p>Example: {@code "Button > LinearLayout > CardView > RecyclerView > FrameLayout"}.
+     * Useful for identifying where in the view tree the click occurred.
+     * Defaults to {@code null} if not provided.
+     */
+    @Nullable
+    public final String elements;
+
+    /** Whether the clicked view is considered interactive (clickable/longClickable). */
+    public final boolean isInteractive;
+
+    /** Whether this click originated from a Compose element (set at construction, not affected by GC). */
+    final boolean isCompose;
+
+    /**
+     * Reference to Compose root view for dead click detection.
+     * Only set for clicks on Compose elements. Weak reference to avoid memory leaks.
+     */
+    @Nullable
+    final WeakReference<View> composeRootRef;
+
+    /**
+     * Creates a new ClickEvent.
+     */
+    ClickEvent(
+            float x,
+            float y,
+            @NonNull String elementId,
+            @Nullable String tagName,
+            @Nullable String accessibleLabel,
+            @Nullable String role,
+            @Nullable String elements,
+            boolean isInteractive,
+            @Nullable View composeRoot) {
+        this.x = x;
+        this.y = y;
+        this.elementId = elementId;
+        this.tagName = tagName;
+        this.accessibleLabel = accessibleLabel;
+        this.role = role;
+        this.elements = elements;
+        this.isInteractive = isInteractive;
+        this.isCompose = composeRoot != null;
+        this.composeRootRef = composeRoot != null ? new WeakReference<>(composeRoot) : null;
+    }
+
+    /**
+     * Returns true if this click was on a Compose element.
+     */
+    boolean isComposeClick() {
+        return isCompose;
+    }
+
+    /**
+     * Returns the Compose root view, or null if not a Compose click or view was garbage collected.
+     */
+    @Nullable
+    View getComposeRoot() {
+        return composeRootRef != null ? composeRootRef.get() : null;
+    }
+
+    /**
+     * Converts this ClickEvent to a JSONObject for event tracking.
+     *
+     * @return A JSONObject containing all non-null properties.
+     */
+    @NonNull
+    public JSONObject toProperties() {
+        JSONObject props = new JSONObject();
+        try {
+            props.put(AutocaptureDefaults.PROP_X, (int) x);
+            props.put(AutocaptureDefaults.PROP_Y, (int) y);
+            props.put(AutocaptureDefaults.PROP_EL_ID, elementId);
+            if (tagName != null) {
+                props.put(AutocaptureDefaults.PROP_EL_TAG_NAME, tagName);
+            }
+            if (accessibleLabel != null) {
+                props.put(AutocaptureDefaults.PROP_ARIA_LABEL, accessibleLabel);
+            }
+            if (role != null) {
+                props.put(AutocaptureDefaults.PROP_ROLE, role);
+            }
+            if (elements != null) {
+                props.put(AutocaptureDefaults.PROP_ELEMENTS, elements);
+            }
+        } catch (JSONException e) {
+            // Should not happen with these simple types
+        }
+        return props;
+    }
+
+    /**
+     * Builder for creating {@link ClickEvent} instances.
+     *
+     * <p>Only {@code x}, {@code y}, and {@code elementId} are required.
+     * All other fields default to {@code null}/{@code false}.
+     *
+     * <p><b>Minimal usage:</b>
+     * <pre>{@code
+     * ClickEvent click = new ClickEvent.Builder(150, 300, "buy_button").build();
+     * mixpanel.getAutocapture().trackClick(click);
+     * }</pre>
+     *
+     * <p><b>Full usage:</b>
+     * <pre>{@code
+     * ClickEvent click = new ClickEvent.Builder(motionEvent.getRawX(), motionEvent.getRawY(), "buy_button")
+     *     .tagName(view.getClass().getSimpleName())
+     *     .accessibleLabel(view.getContentDescription().toString())
+     *     .role("button")
+     *     .elements("MaterialButton > LinearLayout > CardView")
+     *     .build();
+     * mixpanel.getAutocapture().trackClick(click);
+     * }</pre>
+     */
+    public static class Builder {
+        private final float x;
+        private final float y;
+        private final String elementId;
+        private String tagName;
+        private String accessibleLabel;
+        private String role;
+        private String elements;
+        private boolean isInteractive;
+        private View composeRoot;
+
+        /**
+         * @param x         Touch X coordinate in absolute screen pixels
+         * @param y         Touch Y coordinate in absolute screen pixels
+         * @param elementId Stable identifier for the tapped element
+         */
+        public Builder(float x, float y, @NonNull String elementId) {
+            this.x = x;
+            this.y = y;
+            this.elementId = elementId;
+        }
+
+        /**
+         * @param tagName Class name of the tapped element, e.g. {@code "Button"}, {@code "MaterialCardView"}
+         */
+        public Builder tagName(@Nullable String tagName) {
+            this.tagName = tagName;
+            return this;
+        }
+
+        /**
+         * @param accessibleLabel The element's accessibility label (contentDescription)
+         */
+        public Builder accessibleLabel(@Nullable String accessibleLabel) {
+            this.accessibleLabel = accessibleLabel;
+            return this;
+        }
+
+        /**
+         * @param role Semantic role like {@code "button"}, {@code "switch"}, {@code "link"}
+         */
+        public Builder role(@Nullable String role) {
+            this.role = role;
+            return this;
+        }
+
+        /**
+         * @param elements View hierarchy path, {@code ">"} separated (max 5 levels)
+         */
+        public Builder elements(@Nullable String elements) {
+            this.elements = elements;
+            return this;
+        }
+
+        Builder isInteractive(boolean isInteractive) {
+            this.isInteractive = isInteractive;
+            return this;
+        }
+
+        Builder composeRoot(@Nullable View composeRoot) {
+            this.composeRoot = composeRoot;
+            return this;
+        }
+
+        public ClickEvent build() {
+            return new ClickEvent(x, y, elementId, tagName, accessibleLabel, role, elements, isInteractive, composeRoot);
+        }
+    }
+}
diff --git a/analytics/src/main/java/com/mixpanel/android/autocapture/ComposeSemanticHelper.java b/analytics/src/main/java/com/mixpanel/android/autocapture/ComposeSemanticHelper.java
new file mode 100644
index 000000000..08cea622c
--- /dev/null
+++ b/analytics/src/main/java/com/mixpanel/android/autocapture/ComposeSemanticHelper.java
@@ -0,0 +1,446 @@
+package com.mixpanel.android.autocapture;
+
+import android.view.View;
+
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+import androidx.compose.ui.geometry.Rect;
+import androidx.compose.ui.node.RootForTest;
+import androidx.compose.ui.semantics.Role;
+import androidx.compose.ui.semantics.SemanticsActions;
+import androidx.compose.ui.semantics.SemanticsConfiguration;
+import androidx.compose.ui.semantics.SemanticsNode;
+import androidx.compose.ui.semantics.SemanticsProperties;
+import androidx.compose.ui.semantics.SemanticsPropertyKey;
+import androidx.compose.ui.text.AnnotatedString;
+
+import com.mixpanel.android.util.MPLog;
+
+import java.util.List;
+
+/**
+ * Helper class for extracting semantics from Compose views.
+ *
+ * <p>This class directly uses Compose UI APIs. It requires the Compose UI library
+ * at runtime. The caller (SemanticExtractor) must catch NoClassDefFoundError when
+ * calling methods in this class to handle apps without Compose.
+ *
+ * <p>This class is only loaded when Compose is available, avoiding ClassNotFoundException
+ * for apps that don't use Compose.
+ */
+final class ComposeSemanticHelper {
+
+    private static final String TAG = "MP.ComposeHelper";
+
+    /**
+     * Extracts semantics from a Compose view at the given screen coordinates.
+     *
+     * <p>Converts screen coordinates to window-relative coordinates before matching
+     * against Compose's {@code getBoundsInWindow()}, which is necessary for correct
+     * hit testing in split-screen, multi-window, or any mode where the window origin
+     * is offset from the screen origin.
+     *
+     * @param view    The view (must implement RootForTest)
+     * @param screenX Screen X coordinate (from MotionEvent.getRawX)
+     * @param screenY Screen Y coordinate (from MotionEvent.getRawY)
+     * @return A ClickEvent.Builder with extracted semantics, or null if no node found
+     */
+    @Nullable
+    static ClickEvent.Builder extract(@NonNull View view, float screenX, float screenY) {
+        if (!(view instanceof RootForTest)) {
+            MPLog.d(TAG, "View is not RootForTest, returning null");
+            return null;
+        }
+
+        // Convert screen coordinates to window-relative coordinates.
+        // Compose's getBoundsInWindow() returns bounds relative to the window, not the
+        // screen. In split-screen or multi-window the window origin is offset from (0,0).
+        int[] windowOffset = new int[2];
+        view.getLocationInWindow(windowOffset);
+        int[] screenOffset = new int[2];
+        view.getLocationOnScreen(screenOffset);
+        float windowX = screenX - (screenOffset[0] - windowOffset[0]);
+        float windowY = screenY - (screenOffset[1] - windowOffset[1]);
+
+        RootForTest root = (RootForTest) view;
+        SemanticsNode rootNode = root.getSemanticsOwner().getRootSemanticsNode();
+
+        // Find the node using window-relative coordinates
+        SemanticsNode node = findNodeAtPosition(rootNode, windowX, windowY);
+        if (node == null) {
+            MPLog.d(TAG, "No Compose semantics node at position (" + windowX + ", " + windowY + ")");
+            return null;
+        }
+
+        // Pass original screen coordinates to extractFromNode for the ClickEvent
+        return extractFromNode(node, screenX, screenY);
+    }
+
+    /**
+     * Checks if a view is a Compose root.
+     */
+    static boolean isComposeRoot(@NonNull View view) {
+        return view instanceof RootForTest;
+    }
+
+    /**
+     * Snapshot of semantic tree state for dead click detection.
+     */
+    static class SemanticSnapshot {
+        final int contentHash;
+
+        SemanticSnapshot(int contentHash) {
+            this.contentHash = contentHash;
+        }
+
+        /**
+         * Checks if the tree has meaningfully changed.
+         * The content hash is structurally sensitive — computeTreeHash folds
+         * child hashes sequentially, so any node addition/removal (even
+         * text-less nodes) produces a different hash.
+         */
+        boolean hasChanged(SemanticSnapshot current) {
+            if (current == null) return true;
+
+            if (this.contentHash != current.contentHash) {
+                MPLog.d(TAG, "Snapshot: contentHash changed");
+                return true;
+            }
+
+            return false;
+        }
+    }
+
+    /**
+     * Captures a snapshot of the semantic tree for change detection.
+     */
+    @Nullable
+    static SemanticSnapshot captureSnapshot(@NonNull View view) {
+        if (!(view instanceof RootForTest)) {
+            return null;
+        }
+
+        try {
+            RootForTest root = (RootForTest) view;
+            SemanticsNode rootNode = root.getSemanticsOwner().getRootSemanticsNode();
+            int hash = computeTreeHash(rootNode, 0);
+            MPLog.d(TAG, "Captured snapshot - hash: " + hash);
+            return new SemanticSnapshot(hash);
+        } catch (Exception e) {
+            MPLog.e(TAG, "Error capturing semantic snapshot", e);
+            return null;
+        }
+    }
+
+    /**
+     * Computes a content hash for the semantic tree.
+     * The hash is structurally sensitive — child hashes are folded sequentially,
+     * so any node addition/removal produces a different hash.
+     */
+    private static int computeTreeHash(@NonNull SemanticsNode node, int depth) {
+        if (depth >= AutocaptureDefaults.MAX_RECURSION_DEPTH) {
+            return 0;
+        }
+
+        int hash = 17;
+
+        SemanticsConfiguration config = node.getConfig();
+
+        // Include text content in hash
+        String text = getTextProperty(config);
+        if (text != null) {
+            hash = 31 * hash + text.hashCode();
+        }
+
+        // Include content description
+        String contentDesc = getStringProperty(config, SemanticsProperties.INSTANCE.getContentDescription());
+        if (contentDesc != null) {
+            hash = 31 * hash + contentDesc.hashCode();
+        }
+
+        // Recurse into children
+        List<SemanticsNode> children = node.getChildren();
+        for (SemanticsNode child : children) {
+            hash = 31 * hash + computeTreeHash(child, depth + 1);
+        }
+
+        return hash;
+    }
+
+    /**
+     * Finds the best SemanticsNode at the given position.
+     * Prefers clickable nodes over non-interactive leaf nodes.
+     */
+    @Nullable
+    private static SemanticsNode findNodeAtPosition(@NonNull SemanticsNode node, float x, float y) {
+        return findNodeAtPositionRecursive(node, x, y, 0);
+    }
+
+    @Nullable
+    private static SemanticsNode findNodeAtPositionRecursive(
+            @NonNull SemanticsNode node, float x, float y, int depth) {
+        if (depth >= AutocaptureDefaults.MAX_RECURSION_DEPTH) {
+            return null;
+        }
+
+        Rect bounds = node.getBoundsInWindow();
+
+        // Check if point is within bounds
+        if (x < bounds.getLeft() || x > bounds.getRight() ||
+            y < bounds.getTop() || y > bounds.getBottom()) {
+            return null;
+        }
+
+        // Check children (iterate in reverse for top-most first)
+        List<SemanticsNode> children = node.getChildren();
+        SemanticsNode bestMatch = null;
+
+        for (int i = children.size() - 1; i >= 0; i--) {
+            SemanticsNode child = children.get(i);
+            SemanticsNode childMatch = findNodeAtPositionRecursive(child, x, y, depth + 1);
+            if (childMatch != null) {
+                // Prefer clickable nodes
+                if (isClickable(childMatch)) {
+                    return childMatch;
+                }
+                if (bestMatch == null) {
+                    bestMatch = childMatch;
+                }
+            }
+        }
+
+        // If we found a non-clickable child but current node is clickable, prefer current
+        if (bestMatch != null && !isClickable(bestMatch) && isClickable(node)) {
+            return node;
+        }
+
+        if (bestMatch != null) {
+            return bestMatch;
+        }
+
+        return node;
+    }
+
+    /**
+     * Checks if a node is clickable.
+     */
+    private static boolean isClickable(@NonNull SemanticsNode node) {
+        SemanticsConfiguration config = node.getConfig();
+        return config.contains(SemanticsActions.INSTANCE.getOnClick());
+    }
+
+    /**
+     * Extracts semantic information from a SemanticsNode.
+     */
+    @Nullable
+    private static ClickEvent.Builder extractFromNode(@NonNull SemanticsNode node, float x, float y) {
+        SemanticsConfiguration config = node.getConfig();
+
+        String contentDesc = getStringProperty(config, SemanticsProperties.INSTANCE.getContentDescription());
+        String testTag = getStringProperty(config, SemanticsProperties.INSTANCE.getTestTag());
+
+        // Element ID resolution (matching Android plan):
+        // 1. contentDescription (from semantics { contentDescription = ... })
+        // 2. testTag (from Modifier.testTag(...)) - equivalent to resource ID
+        // 3. ClassName_<hashCode>
+        String elementId = null;
+        String accessibleLabel = null;
+
+        if (contentDesc != null && !contentDesc.isEmpty()) {
+            elementId = contentDesc;
+            accessibleLabel = contentDesc;
+        }
+
+        if (elementId == null && testTag != null && !testTag.isEmpty()) {
+            elementId = testTag;
+        }
+
+        if (elementId == null) {
+            String tagName = getTagName(config);
+            elementId = tagName + "_" + Integer.toHexString(node.hashCode());
+        }
+
+        ClickEvent.Builder builder = new ClickEvent.Builder(x, y, elementId);
+
+        if (accessibleLabel != null) {
+            builder.accessibleLabel(accessibleLabel);
+        }
+
+        // Tag name from role
+        String tagName = getTagName(config);
+        builder.tagName(tagName);
+
+        // Role
+        String role = getRoleString(config);
+        builder.role(role);
+
+        // Interactive check
+        builder.isInteractive(isInteractiveElement(config));
+
+        MPLog.d(TAG, "Extracted Compose semantics - id: " + elementId +
+                ", tag: " + tagName + ", role: " + role);
+
+        return builder;
+    }
+
+    /**
+     * Gets a string property from config (handles List<AnnotatedString>).
+     */
+    @Nullable
+    private static <T> String getStringProperty(
+            @NonNull SemanticsConfiguration config,
+            @NonNull SemanticsPropertyKey<T> key) {
+        if (!config.contains(key)) {
+            return null;
+        }
+
+        T value = config.get(key);
+        if (value == null) {
+            return null;
+        }
+
+        // Handle List<AnnotatedString> for ContentDescription
+        if (value instanceof List) {
+            List<?> list = (List<?>) value;
+            if (!list.isEmpty()) {
+                Object first = list.get(0);
+                return first != null ? first.toString() : null;
+            }
+            return null;
+        }
+
+        return value.toString();
+    }
+
+    /**
+     * Gets text from Text property.
+     */
+    @Nullable
+    private static String getTextProperty(@NonNull SemanticsConfiguration config) {
+        SemanticsPropertyKey<List<AnnotatedString>> textKey = SemanticsProperties.INSTANCE.getText();
+        if (!config.contains(textKey)) {
+            return null;
+        }
+
+        List<AnnotatedString> texts = config.get(textKey);
+        if (texts == null || texts.isEmpty()) {
+            return null;
+        }
+
+        StringBuilder sb = new StringBuilder();
+        for (AnnotatedString text : texts) {
+            if (sb.length() > 0) sb.append(" ");
+            sb.append(text.getText());
+        }
+        return sb.toString();
+    }
+
+    /**
+     * Checks if element is editable (text field).
+     */
+    private static boolean isEditable(@NonNull SemanticsConfiguration config) {
+        return config.contains(SemanticsProperties.INSTANCE.getEditableText());
+    }
+
+    /**
+     * Gets tag name from role or infers from properties.
+     */
+    @NonNull
+    private static String getTagName(@NonNull SemanticsConfiguration config) {
+        SemanticsPropertyKey<Role> roleKey = SemanticsProperties.INSTANCE.getRole();
+        if (config.contains(roleKey)) {
+            Role role = config.get(roleKey);
+            if (role != null) {
+                String roleName = role.toString();
+                if (roleName.contains("Button")) return "Button";
+                if (roleName.contains("Checkbox")) return "Checkbox";
+                if (roleName.contains("Switch")) return "Switch";
+                if (roleName.contains("RadioButton")) return "RadioButton";
+                if (roleName.contains("Tab")) return "Tab";
+                if (roleName.contains("Slider")) return "Slider";
+                if (roleName.contains("Image")) return "Image";
+                if (roleName.contains("DropdownList")) return "DropdownList";
+            }
+        }
+
+        // Infer from properties - check EditableText BEFORE OnClick
+        // (TextFields are clickable to gain focus but should be identified as TextField)
+        if (config.contains(SemanticsProperties.INSTANCE.getEditableText())) {
+            return "TextField";
+        }
+        if (config.contains(SemanticsActions.INSTANCE.getOnClick())) {
+            return "Button";
+        }
+        if (config.contains(SemanticsProperties.INSTANCE.getText())) {
+            return "Text";
+        }
+
+        return "View";
+    }
+
+    /**
+     * Gets role string for $attr-role.
+     */
+    @Nullable
+    private static String getRoleString(@NonNull SemanticsConfiguration config) {
+        SemanticsPropertyKey<Role> roleKey = SemanticsProperties.INSTANCE.getRole();
+        if (config.contains(roleKey)) {
+            Role role = config.get(roleKey);
+            if (role != null) {
+                String roleName = role.toString().toLowerCase();
+                if (roleName.contains("button")) return "Button";
+                if (roleName.contains("checkbox")) return "Checkbox";
+                if (roleName.contains("switch")) return "Switch";
+                if (roleName.contains("radiobutton")) return "Radio";
+                if (roleName.contains("tab")) return "Tab";
+                if (roleName.contains("slider")) return "Slider";
+                if (roleName.contains("image")) return "Image";
+                if (roleName.contains("dropdownlist")) return "ComboBox";
+            }
+        }
+
+        // Infer from properties - check EditableText BEFORE OnClick
+        // (TextFields are clickable to gain focus but should be identified as TextField)
+        if (config.contains(SemanticsProperties.INSTANCE.getEditableText())) {
+            return "TextField";
+        }
+        if (config.contains(SemanticsActions.INSTANCE.getOnClick())) {
+            return "Button";
+        }
+
+        return null;
+    }
+
+    /**
+     * Checks if element is interactive for dead click detection.
+     * Excludes elements with inherent visual feedback.
+     */
+    private static boolean isInteractiveElement(@NonNull SemanticsConfiguration config) {
+        // Exclude editable (keyboard feedback)
+        if (config.contains(SemanticsProperties.INSTANCE.getEditableText())) {
+            return false;
+        }
+
+        // Exclude toggle controls (visual feedback)
+        SemanticsPropertyKey<Role> roleKey = SemanticsProperties.INSTANCE.getRole();
+        if (config.contains(roleKey)) {
+            Role role = config.get(roleKey);
+            if (role != null) {
+                String roleName = role.toString().toLowerCase();
+                if (roleName.contains("checkbox") ||
+                    roleName.contains("switch") ||
+                    roleName.contains("radiobutton") ||
+                    roleName.contains("slider")) {
+                    return false;
+                }
+            }
+        }
+
+        // Interactive if clickable
+        return config.contains(SemanticsActions.INSTANCE.getOnClick());
+    }
+
+    private ComposeSemanticHelper() {
+        // Prevent instantiation
+    }
+}
diff --git a/analytics/src/main/java/com/mixpanel/android/autocapture/CurtainsHelper.kt b/analytics/src/main/java/com/mixpanel/android/autocapture/CurtainsHelper.kt
new file mode 100644
index 000000000..bcd0bb592
--- /dev/null
+++ b/analytics/src/main/java/com/mixpanel/android/autocapture/CurtainsHelper.kt
@@ -0,0 +1,119 @@
+package com.mixpanel.android.autocapture
+
+import android.view.MotionEvent
+import android.view.View
+import android.view.ViewConfiguration
+import android.view.Window
+import com.mixpanel.android.util.MPLog
+import curtains.OnTouchEventListener
+import curtains.phoneWindow
+import curtains.touchEventInterceptors
+
+/**
+ * Listener interface for processed tap events.
+ */
+internal fun interface TapListener {
+    /**
+     * Called when a valid tap is detected (single-pointer ACTION_UP within touch slop
+     * and duration threshold).
+     *
+     * @param x         Screen X coordinate.
+     * @param y         Screen Y coordinate.
+     * @param decorView The window's decor view.
+     */
+    fun onTap(x: Float, y: Float, decorView: View)
+}
+
+/**
+ * Bridge between Curtains' Kotlin extensions and the Java-based autocapture code.
+ *
+ * Provides window resolution via [phoneWindow] and touch interception via
+ * [touchEventInterceptors], replacing custom reflection and Window.Callback wrapping.
+ */
+internal object CurtainsHelper {
+
+    private const val TAG = "MP.CurtainsHelper"
+
+    /** Maximum duration (ms) for a touch to be considered a tap, not a long press. */
+    private const val MAX_TAP_DURATION_MS = 500L
+
+    /**
+     * Gets the [Window] associated with a root [View] using Curtains' phoneWindow extension.
+     * Returns null for views not attached to a PhoneWindow (e.g., PopupWindow, Toast).
+     */
+    @JvmStatic
+    fun getWindow(view: View): Window? {
+        return try {
+            view.phoneWindow
+        } catch (e: Exception) {
+            MPLog.d(TAG, "Could not get window from view", e)
+            null
+        }
+    }
+
+    /**
+     * Installs a tap listener on a [Window] using Curtains' touchEventInterceptors.
+     *
+     * The listener filters for taps (single-pointer ACTION_UP within touch slop
+     * and duration threshold) and notifies [onTap] with screen coordinates
+     * and the window's decor view.
+     *
+     * @return The installed [OnTouchEventListener], to be kept for later removal.
+     */
+    @JvmStatic
+    fun installTouchListener(window: Window, onTap: TapListener): OnTouchEventListener {
+        val context = window.context
+        val touchSlop = ViewConfiguration.get(context).scaledTouchSlop
+        val touchSlopSq = touchSlop * touchSlop
+
+        var downX = 0f
+        var downY = 0f
+        var downTime = 0L
+
+        val listener = OnTouchEventListener { event ->
+            try {
+                when (event.actionMasked) {
+                    MotionEvent.ACTION_DOWN -> {
+                        downX = event.rawX
+                        downY = event.rawY
+                        downTime = event.eventTime
+                    }
+                    MotionEvent.ACTION_POINTER_DOWN,
+                    MotionEvent.ACTION_CANCEL -> {
+                        downTime = 0L
+                    }
+                    MotionEvent.ACTION_UP -> {
+                        if (event.pointerCount == 1) {
+                            val duration = event.eventTime - downTime
+                            val dx = event.rawX - downX
+                            val dy = event.rawY - downY
+                            if (downTime > 0 && duration <= MAX_TAP_DURATION_MS
+                                && (dx * dx + dy * dy) <= touchSlopSq
+                            ) {
+                                val decorView = window.decorView
+                                onTap.onTap(event.rawX, event.rawY, decorView)
+                            }
+                        }
+                    }
+                }
+            } catch (e: Exception) {
+                MPLog.e(TAG, "Error in touch listener", e)
+            }
+        }
+
+        window.touchEventInterceptors += listener
+        return listener
+    }
+
+    /**
+     * Removes a previously installed touch listener from a [Window].
+     */
+    @JvmStatic
+    fun removeTouchListener(window: Window, listener: OnTouchEventListener) {
+        try {
+            window.touchEventInterceptors -= listener
+        } catch (e: Exception) {
+            MPLog.d(TAG, "Error removing touch listener", e)
+        }
+    }
+}
diff --git a/analytics/src/main/java/com/mixpanel/android/autocapture/DeadClickDetector.java b/analytics/src/main/java/com/mixpanel/android/autocapture/DeadClickDetector.java
new file mode 100644
index 000000000..0f0bf3b0d
--- /dev/null
+++ b/analytics/src/main/java/com/mixpanel/android/autocapture/DeadClickDetector.java
@@ -0,0 +1,618 @@
+package com.mixpanel.android.autocapture;
+
+import android.os.Handler;
+import android.os.Looper;
+import android.view.View;
+import android.view.ViewGroup;
+import android.view.ViewTreeObserver;
+import android.widget.TextView;
+
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+
+import com.mixpanel.android.mpmetrics.DeadClickOptions;
+import com.mixpanel.android.util.MPLog;
+
+import java.lang.ref.WeakReference;
+
+/**
+ * Detects dead clicks by monitoring UI changes after a click.
+ *
+ * <p>A dead click is detected when a user clicks on an element that appears to be interactive
+ * but produces no UI response within the configured timeout period.
+ *
+ * <p>Detection strategy:
+ * <ol>
+ *   <li>On click detected, capture baseline snapshot immediately (before the click
+ *       handler runs), so any UI response is visible as a delta</li>
+ *   <li>Attach listeners for UI changes (layout, scroll, window focus, new windows)
+ *       — any change cancels detection early</li>
+ *   <li>After timeout (default 500ms), compare final state to baseline</li>
+ *   <li>If no change detected, emit dead click event</li>
+ * </ol>
+ *
+ * <p>Thread safety: This class is NOT thread-safe and should only be called from the main thread.
+ */
+final class DeadClickDetector {
+
+    private static final String TAG = "MP.DeadClickDetector";
+
+    /**
+     * Listener for dead click detection results.
+     */
+    interface DeadClickListener {
+        /**
+         * Called when a dead click is detected.
+         *
+         * @param clickEvent The original click event that had no UI response.
+         */
+        void onDeadClickDetected(@NonNull ClickEvent clickEvent);
+    }
+
+    /**
+     * Strategy interface for monitoring UI changes. Implementations capture a baseline
+     * snapshot and later compare against it to determine if the UI changed.
+     */
+    interface UiChangeMonitor {
+        /**
+         * Captures the baseline UI state. Called synchronously before the click handler runs.
+         *
+         * @return true if the baseline was captured successfully.
+         */
+        boolean captureBaseline();
+
+        /**
+         * Compares current UI state against the baseline.
+         *
+         * @return true if the UI has changed since the baseline was captured.
+         */
+        boolean hasChanged();
+
+        /**
+         * Attaches listeners for early cancellation (e.g., layout/scroll changes).
+         *
+         * @param rootView The root view to attach listeners to.
+         * @param session  The session to notify on change.
+         */
+        void attachListeners(@NonNull View rootView, @NonNull DetectionSession session);
+
+        /**
+         * Removes any listeners attached by {@link #attachListeners}.
+         *
+         * @param rootView The root view listeners were attached to.
+         * @param session  The session that was being notified.
+         */
+        void detachListeners(@NonNull View rootView, @NonNull DetectionSession session);
+    }
+
+    private final long mTimeoutMs;
+    private final Handler mHandler;
+    private final DeadClickListener mListener;
+
+    // Current detection state
+    @Nullable
+    private DetectionSession mCurrentSession;
+
+    /**
+     * Creates a DeadClickDetector with the given options.
+     *
+     * @param options  The dead click configuration options.
+     * @param listener The listener to receive dead click events.
+     */
+    DeadClickDetector(@NonNull DeadClickOptions options, @NonNull DeadClickListener listener) {
+        mTimeoutMs = options.getTimeoutMs();
+        mHandler = new Handler(Looper.getMainLooper());
+        mListener = listener;
+    }
+
+    /**
+     * Starts detection for a click event.
+     *
+     * <p>Only monitors clicks on interactive elements (clickable, long-clickable,
+     * or known interactive types).
+     *
+     * @param clickEvent The click event to monitor.
+     * @param rootView   The root view to monitor for changes.
+     */
+    void startDetection(@NonNull ClickEvent clickEvent, @NonNull View rootView) {
+        // Cancel any existing detection
+        cancelDetection();
+
+        // Only monitor interactive elements
+        if (!clickEvent.isInteractive) {
+            return;
+        }
+
+        try {
+            UiChangeMonitor monitor = new UnifiedUiChangeMonitor(rootView, clickEvent);
+            mCurrentSession = new DetectionSession(clickEvent, rootView, monitor);
+            mCurrentSession.start();
+        } catch (Exception e) {
+            MPLog.e(TAG, "Error starting dead click detection", e);
+            mCurrentSession = null;
+        }
+    }
+
+    /**
+     * Cancels any ongoing detection.
+     * Call this when the activity is paused or a navigation occurs.
+     */
+    void cancelDetection() {
+        if (mCurrentSession != null) {
+            mCurrentSession.cancel();
+            mCurrentSession = null;
+        }
+    }
+
+    /**
+     * Notifies the detector that a new window was added.
+     * This is a UI change signal that cancels dead click detection.
+     */
+    void onWindowAdded() {
+        if (mCurrentSession != null) {
+            mCurrentSession.onUiChange("window_added");
+        }
+    }
+
+    /**
+     * Notifies the detector that window focus changed.
+     * This is a UI change signal that cancels dead click detection.
+     */
+    void onWindowFocusChanged() {
+        if (mCurrentSession != null) {
+            mCurrentSession.onUiChange("focus_changed");
+        }
+    }
+
+    // ==================== UiChangeMonitor Implementation ====================
+
+    /**
+     * Unified monitor that detects UI changes across both XML and Compose frameworks.
+     *
+     * <p>Automatically detects the UI framework composition at baseline time and adapts
+     * its detection strategy:
+     *
+     * <ul>
+     *   <li><b>Pure XML:</b> Full structural hash (position, size, class, text, state)
+     *       with ViewTreeObserver early cancellation. Maximum sensitivity.</li>
+     *   <li><b>Pure Compose:</b> Compose semantic snapshot only (text, contentDescription).
+     *       No ViewTreeObserver (Compose ripple causes false positives).</li>
+     *   <li><b>Mixed framework:</b> Content-only XOR hash for XML views (immune to
+     *       Compose ripple structural changes) + Compose semantic snapshot. Together
+     *       these cover the complete UI surface. No ViewTreeObserver.</li>
+     * </ul>
+     *
+     * <p>For mixed-framework screens, the XOR hash detects text and toggle state changes
+     * in XML views while ignoring structural changes caused by Compose animations.
+     * The semantic snapshot covers all Compose text and contentDescription changes.
+     */
+    private static class UnifiedUiChangeMonitor implements UiChangeMonitor {
+
+        private final WeakReference<View> mRootViewRef;
+
+        // Framework detection flags, determined once at baseline time
+        private boolean mHasCompose;
+
+        // XML baseline — always captured
+        // Pure XML: structural hash (position, size, class, text, state)
+        // Mixed: content-only XOR hash (text and toggle state only)
+        private int mBaselineXmlViewCount;
+        private int mBaselineXmlHash;
+
+        // Compose baseline — captured only when Compose is present
+        @Nullable
+        private WeakReference<View> mComposeRootRef;
+        @Nullable
+        private ComposeSemanticHelper.SemanticSnapshot mComposeBaseline;
+
+        UnifiedUiChangeMonitor(@NonNull View rootView, @NonNull ClickEvent clickEvent) {
+            mRootViewRef = new WeakReference<>(rootView);
+
+            // Resolve Compose root:
+            // - For Compose clicks, the ClickEvent already has the reference
+            // - For XML clicks, search the view tree for a Compose root
+            View composeRoot = clickEvent.getComposeRoot();
+            if (composeRoot == null) {
+                composeRoot = findComposeRoot(rootView);
+            }
+            mHasCompose = composeRoot != null;
+            mComposeRootRef = composeRoot != null ? new WeakReference<>(composeRoot) : null;
+        }
+
+        @Override
+        public boolean captureBaseline() {
+            try {
+                View rootView = mRootViewRef.get();
+                if (rootView == null) return false;
+
+                // Capture XML baseline
+                if (mHasCompose) {
+                    mBaselineXmlHash = captureXmlContentHash(rootView);
+                } else {
+                    long snapshot = captureStructuralSnapshot(rootView);
+                    mBaselineXmlViewCount = unpackCount(snapshot);
+                    mBaselineXmlHash = unpackHash(snapshot);
+                }
+
+                // Capture Compose baseline if present
+                if (mHasCompose) {
+                    View composeRoot = mComposeRootRef != null ? mComposeRootRef.get() : null;
+                    if (composeRoot == null) return false;
+                    mComposeBaseline = ComposeSemanticHelper.captureSnapshot(composeRoot);
+                    if (mComposeBaseline == null) return false;
+                }
+
+                return true;
+            } catch (NoClassDefFoundError e) {
+                // Compose classes not available at runtime — fall back to XML-only.
+                // Capture the XML structural baseline directly instead of recursing,
+                // to avoid infinite recursion if an unexpected error occurs.
+                mHasCompose = false;
+                mComposeRootRef = null;
+                mComposeBaseline = null;
+                View rootView = mRootViewRef.get();
+                if (rootView == null) return false;
+                long snapshot = captureStructuralSnapshot(rootView);
+                mBaselineXmlViewCount = unpackCount(snapshot);
+                mBaselineXmlHash = unpackHash(snapshot);
+                return true;
+            } catch (Exception e) {
+                MPLog.e(TAG, "Error capturing baseline", e);
+                return false;
+            }
+        }
+
+        @Override
+        public boolean hasChanged() {
+            View rootView = mRootViewRef.get();
+            if (rootView == null) return true; // View gone = change
+
+            // Check XML changes
+            if (hasXmlChanged(rootView)) return true;
+
+            // Check Compose changes
+            if (mHasCompose && hasComposeChanged()) return true;
+
+            return false;
+        }
+
+        @Override
+        public void attachListeners(@NonNull View rootView, @NonNull DetectionSession session) {
+            // ViewTreeObserver early cancellation is only safe for pure XML screens.
+            // When Compose is present, ripple animations trigger layout changes that
+            // would cause false cancellation of dead click detection.
+            if (!mHasCompose) {
+                ViewTreeObserver observer = rootView.getViewTreeObserver();
+                if (observer.isAlive()) {
+                    observer.addOnGlobalLayoutListener(session);
+                    observer.addOnScrollChangedListener(session);
+                }
+            }
+        }
+
+        @Override
+        public void detachListeners(@NonNull View rootView, @NonNull DetectionSession session) {
+            if (!mHasCompose) {
+                ViewTreeObserver observer = rootView.getViewTreeObserver();
+                if (observer.isAlive()) {
+                    observer.removeOnGlobalLayoutListener(session);
+                    observer.removeOnScrollChangedListener(session);
+                }
+            }
+        }
+
+        // -------------------- XML Change Detection --------------------
+
+        /**
+         * Checks whether XML views have changed since baseline.
+         * Uses structural hash for pure XML, content-only hash for mixed screens.
+         */
+        private boolean hasXmlChanged(@NonNull View rootView) {
+            if (mHasCompose) {
+                // Mixed screen: content-only comparison (immune to Compose ripple)
+                int currentHash = captureXmlContentHash(rootView);
+                return currentHash != mBaselineXmlHash;
+            } else {
+                // Pure XML: full structural comparison
+                long snapshot = captureStructuralSnapshot(rootView);
+                return unpackCount(snapshot) != mBaselineXmlViewCount ||
+                        unpackHash(snapshot) != mBaselineXmlHash;
+            }
+        }
+
+        /**
+         * Captures view count and structural hash in a single tree walk.
+         * Includes position, size, class name, text, and control state.
+         * Used for pure XML screens where maximum detection sensitivity is desired.
+         *
+         * <p>Returns a packed {@code long}: upper 32 bits = view count, lower 32 bits = hash.
+         * Use {@link #unpackCount} and {@link #unpackHash} to extract values.
+         * This avoids allocating an {@code int[]} per node during recursion.
+         */
+        private static long captureStructuralSnapshot(@NonNull View view) {
+            return captureStructuralSnapshotRecursive(view, 0);
+        }
+
+        private static long captureStructuralSnapshotRecursive(@NonNull View view, int depth) {
+            if (depth >= AutocaptureDefaults.MAX_RECURSION_DEPTH) return 0L;
+            if (view.getVisibility() != View.VISIBLE || view.getAlpha() <= 0f) return 0L;
+
+            int count = 1;
+            int hash = 17;
+
+            // Position and size
+            hash = 31 * hash + view.getLeft();
+            hash = 31 * hash + view.getTop();
+            hash = 31 * hash + view.getWidth();
+            hash = 31 * hash + view.getHeight();
+
+            // Class name (getName() is JVM-cached, unlike getSimpleName())
+            hash = 31 * hash + view.getClass().getName().hashCode();
+
+            // Text content (for TextViews, which includes Button)
+            if (view instanceof TextView) {
+                CharSequence text = ((TextView) view).getText();
+                if (text != null) {
+                    hash = 31 * hash + text.hashCode();
+                }
+            }
+
+            // Control state
+            if (view instanceof android.widget.CompoundButton) {
+                hash = 31 * hash + (((android.widget.CompoundButton) view).isChecked() ? 1 : 0);
+            }
+            if (view.isEnabled()) {
+                hash = 31 * hash + 1;
+            }
+
+            // Recurse into children
+            if (view instanceof ViewGroup) {
+                ViewGroup group = (ViewGroup) view;
+                for (int i = 0; i < group.getChildCount(); i++) {
+                    long child = captureStructuralSnapshotRecursive(group.getChildAt(i), depth + 1);
+                    count += unpackCount(child);
+                    hash = 31 * hash + unpackHash(child);
+                }
+            }
+
+            return pack(count, hash);
+        }
+
+        /** Packs view count and hash into a single long. */
+        private static long pack(int count, int hash) {
+            return ((long) count << 32) | (hash & 0xFFFFFFFFL);
+        }
+
+        /** Extracts view count from a packed long. */
+        private static int unpackCount(long packed) {
+            return (int) (packed >>> 32);
+        }
+
+        /** Extracts hash from a packed long. */
+        private static int unpackHash(long packed) {
+            return (int) packed;
+        }
+
+        /**
+         * Captures a content-only hash of XML views using XOR accumulation.
+         * Only hashes text content (TextView) and toggle state (CompoundButton).
+         *
+         * <p>XOR accumulation makes the hash immune to tree structure changes
+         * (node additions/removals from Compose ripple animations) while still
+         * detecting meaningful content changes in XML views.
+         *
+         * <p>Used for mixed-framework screens where structural changes from Compose
+         * animations would cause false positives with the full structural hash.
+         */
+        private static int captureXmlContentHash(@NonNull View view) {
+            return captureXmlContentHashRecursive(view, 0);
+        }
+
+        private static int captureXmlContentHashRecursive(@NonNull View view, int depth) {
+            if (depth >= AutocaptureDefaults.MAX_RECURSION_DEPTH) return 0;
+            if (view.getVisibility() != View.VISIBLE) return 0;
+
+            int hash = 0;
+
+            // Text content
+            if (view instanceof TextView) {
+                CharSequence text = ((TextView) view).getText();
+                if (text != null) {
+                    hash ^= text.hashCode();
+                }
+            }
+
+            // Toggle state (use distinct constants to differentiate checked/unchecked)
+            if (view instanceof android.widget.CompoundButton) {
+                hash ^= ((android.widget.CompoundButton) view).isChecked() ? 0x55555555 : 0xAAAAAAAA;
+            }
+
+            // Recurse into children
+            if (view instanceof ViewGroup) {
+                ViewGroup group = (ViewGroup) view;
+                for (int i = 0; i < group.getChildCount(); i++) {
+                    hash ^= captureXmlContentHashRecursive(group.getChildAt(i), depth + 1);
+                }
+            }
+
+            return hash;
+        }
+
+        // -------------------- Compose Change Detection --------------------
+
+        /**
+         * Checks whether the Compose semantic tree has changed since baseline.
+         */
+        private boolean hasComposeChanged() {
+            View composeRoot = mComposeRootRef != null ? mComposeRootRef.get() : null;
+            if (composeRoot == null) return true; // View gone = change
+
+            try {
+                ComposeSemanticHelper.SemanticSnapshot current =
+                        ComposeSemanticHelper.captureSnapshot(composeRoot);
+                boolean changed = mComposeBaseline != null && mComposeBaseline.hasChanged(current);
+                MPLog.d(TAG, "Compose dead click check - changed: " + changed);
+                return changed;
+            } catch (NoClassDefFoundError e) {
+                // Compose classes no longer available — treat as changed to be safe
+                return true;
+            }
+        }
+
+        // -------------------- Compose Root Discovery --------------------
+
+        // Cached result of Compose classpath check. Null = not yet checked.
+        @Nullable
+        private static Boolean sComposeAvailable;
+
+        /**
+         * Checks if Compose UI library is available at runtime.
+         * Result is cached after the first check.
+         */
+        private static boolean isComposeAvailable() {
+            if (sComposeAvailable != null) return sComposeAvailable;
+            try {
+                Class.forName("androidx.compose.ui.node.RootForTest");
+                sComposeAvailable = true;
+            } catch (ClassNotFoundException e) {
+                sComposeAvailable = false;
+            }
+            return sComposeAvailable;
+        }
+
+        /**
+         * Searches the view tree for a Compose root (a view implementing RootForTest).
+         * Used for XML clicks in mixed-framework screens to locate the Compose root
+         * for semantic baseline capture.
+         *
+         * <p>Skips the tree walk entirely if Compose is not on the classpath,
+         * avoiding unnecessary traversal for pure XML apps.
+         *
+         * @return The Compose root view, or null if no Compose is present.
+         */
+        @Nullable
+        private static View findComposeRoot(@NonNull View view) {
+            if (!isComposeAvailable()) return null;
+            try {
+                return findComposeRootRecursive(view, 0);
+            } catch (NoClassDefFoundError e) {
+                // Compose classes unexpectedly missing — update cache
+                sComposeAvailable = false;
+                return null;
+            }
+        }
+
+        @Nullable
+        private static View findComposeRootRecursive(@NonNull View view, int depth) {
+            if (depth >= AutocaptureDefaults.MAX_RECURSION_DEPTH) return null;
+
+            if (ComposeSemanticHelper.isComposeRoot(view)) {
+                return view;
+            }
+
+            if (view instanceof ViewGroup) {
+                ViewGroup group = (ViewGroup) view;
+                for (int i = 0; i < group.getChildCount(); i++) {
+                    View result = findComposeRootRecursive(group.getChildAt(i), depth + 1);
+                    if (result != null) return result;
+                }
+            }
+
+            return null;
+        }
+    }
+
+    // ==================== Detection Session ====================
+
+    /**
+     * Manages the detection lifecycle for a single click.
+     * Delegates UI monitoring to a {@link UiChangeMonitor}.
+     */
+    class DetectionSession implements
+            ViewTreeObserver.OnGlobalLayoutListener,
+            ViewTreeObserver.OnScrollChangedListener {
+
+        private final ClickEvent mClickEvent;
+        private final WeakReference<View> mRootViewRef;
+        private final UiChangeMonitor mMonitor;
+        private boolean mCancelled = false;
+        private final Runnable mCheckResultRunnable = this::checkResult;
+
+        DetectionSession(@NonNull ClickEvent clickEvent, @NonNull View rootView,
+                         @NonNull UiChangeMonitor monitor) {
+            mClickEvent = clickEvent;
+            mRootViewRef = new WeakReference<>(rootView);
+            mMonitor = monitor;
+        }
+
+        void start() {
+            // Schedule final check
+            mHandler.postDelayed(mCheckResultRunnable, mTimeoutMs);
+
+            View rootView = mRootViewRef.get();
+            if (rootView == null) {
+                cancel();
+                return;
+            }
+
+            // Capture baseline immediately (before click handler runs)
+            if (!mMonitor.captureBaseline()) {
+                cancel();
+                return;
+            }
+
+            // Attach listeners for early cancellation
+            mMonitor.attachListeners(rootView, this);
+        }
+
+        void cancel() {
+            if (mCancelled) return;
+            mCancelled = true;
+            cleanup();
+        }
+
+        void onUiChange(String reason) {
+            if (mCancelled) return;
+            MPLog.d(TAG, "UI change detected: " + reason + ", cancelling dead click detection");
+            cancel();
+        }
+
+        @Override
+        public void onGlobalLayout() {
+            onUiChange("layout");
+        }
+
+        @Override
+        public void onScrollChanged() {
+            onUiChange("scroll");
+        }
+
+        private void checkResult() {
+            if (mCancelled) return;
+
+            try {
+                if (!mMonitor.hasChanged()) {
+                    // Dead click detected!
+                    mListener.onDeadClickDetected(mClickEvent);
+                }
+            } catch (Exception e) {
+                MPLog.e(TAG, "Error checking dead click result", e);
+            } finally {
+                cleanup();
+            }
+        }
+
+        private void cleanup() {
+            mHandler.removeCallbacks(mCheckResultRunnable);
+
+            View rootView = mRootViewRef.get();
+            if (rootView != null) {
+                mMonitor.detachListeners(rootView, this);
+            }
+
+            if (mCurrentSession == this) {
+                mCurrentSession = null;
+            }
+        }
+    }
+}
diff --git a/analytics/src/main/java/com/mixpanel/android/autocapture/RageClickTracker.java b/analytics/src/main/java/com/mixpanel/android/autocapture/RageClickTracker.java
new file mode 100644
index 000000000..4d4984558
--- /dev/null
+++ b/analytics/src/main/java/com/mixpanel/android/autocapture/RageClickTracker.java
@@ -0,0 +1,155 @@
+package com.mixpanel.android.autocapture;
+
+import android.content.Context;
+import android.util.DisplayMetrics;
+
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+import androidx.annotation.VisibleForTesting;
+
+import com.mixpanel.android.mpmetrics.RageClickOptions;
+
+import java.util.ArrayList;
+import java.util.Iterator;
+import java.util.List;
+
+/**
+ * Tracks click patterns to detect rage clicks.
+ *
+ * <p>A rage click is detected when a user rapidly clicks multiple times in the same area,
+ * indicating frustration with an unresponsive UI element.
+ *
+ * <p>Detection criteria (all configurable):
+ * <ul>
+ *   <li>N clicks within time window (default: 4 clicks within 1000ms)</li>
+ *   <li>All clicks within spatial radius (default: 44dp)</li>
+ * </ul>
+ *
+ * <p>Thread safety: This class is NOT thread-safe and should only be called from the main thread.
+ */
+final class RageClickTracker {
+
+    /**
+     * Interface for providing current time (for testability).
+     */
+    interface TimeProvider {
+        long currentTimeMillis();
+    }
+
+    private final int mClickThreshold;
+    private final long mTimeWindowMs;
+    private final float mRadiusPx;
+    private final TimeProvider mTimeProvider;
+
+    private final List<ClickRecord> mRecentClicks = new ArrayList<>();
+
+    /**
+     * Creates a RageClickTracker with the given options and screen density.
+     *
+     * @param options The rage click configuration options.
+     * @param context The context to get screen density.
+     */
+    RageClickTracker(@NonNull RageClickOptions options, @NonNull Context context) {
+        this(options, context, System::currentTimeMillis);
+    }
+
+    /**
+     * Creates a RageClickTracker with injectable time provider (for testing).
+     */
+    @VisibleForTesting
+    RageClickTracker(@NonNull RageClickOptions options, @NonNull Context context, @NonNull TimeProvider timeProvider) {
+        mClickThreshold = options.getClickThreshold();
+        mTimeWindowMs = options.getTimeWindowMs();
+        mTimeProvider = timeProvider;
+
+        // Convert dp to pixels
+        DisplayMetrics metrics = context.getResources().getDisplayMetrics();
+        mRadiusPx = options.getRadius() * metrics.density;
+    }
+
+    /**
+     * Records a click and checks if it triggers a rage click.
+     *
+     * @param clickEvent The click event to record.
+     * @return The ClickEvent that triggered the rage click (same as input), or null if no rage click detected.
+     */
+    @Nullable
+    ClickEvent recordClick(@NonNull ClickEvent clickEvent) {
+        long now = mTimeProvider.currentTimeMillis();
+        float x = clickEvent.x;
+        float y = clickEvent.y;
+
+        // Remove expired clicks
+        pruneExpiredClicks(now);
+
+        // Add new click
+        mRecentClicks.add(new ClickRecord(x, y, now));
+
+        // Count clicks within radius of the current click
+        int clicksInRadius = countClicksInRadius(x, y);
+
+        // Check if threshold reached
+        if (clicksInRadius >= mClickThreshold) {
+            // Clear tracked clicks to avoid multiple rage click events for the same sequence
+            mRecentClicks.clear();
+            return clickEvent;
+        }
+
+        return null;
+    }
+
+    /**
+     * Clears all tracked clicks.
+     * Call this on activity changes or when the user navigates away.
+     */
+    void clear() {
+        mRecentClicks.clear();
+    }
+
+    /**
+     * Removes clicks that are outside the time window.
+     */
+    private void pruneExpiredClicks(long now) {
+        long cutoff = now - mTimeWindowMs;
+        Iterator<ClickRecord> iterator = mRecentClicks.iterator();
+        while (iterator.hasNext()) {
+            if (iterator.next().timestamp < cutoff) {
+                iterator.remove();
+            }
+        }
+    }
+
+    /**
+     * Counts clicks within the spatial radius of the given position.
+     */
+    private int countClicksInRadius(float x, float y) {
+        int count = 0;
+
+        for (ClickRecord record : mRecentClicks) {
+            float dx = record.x - x;
+            float dy = record.y - y;
+            float distance = (float) Math.sqrt(dx * dx + dy * dy);
+
+            if (distance <= mRadiusPx) {
+                count++;
+            }
+        }
+
+        return count;
+    }
+
+    /**
+     * Simple record of a click's position and time.
+     */
+    private static class ClickRecord {
+        final float x;
+        final float y;
+        final long timestamp;
+
+        ClickRecord(float x, float y, long timestamp) {
+            this.x = x;
+            this.y = y;
+            this.timestamp = timestamp;
+        }
+    }
+}
diff --git a/analytics/src/main/java/com/mixpanel/android/autocapture/SemanticExtractor.java b/analytics/src/main/java/com/mixpanel/android/autocapture/SemanticExtractor.java
new file mode 100644
index 000000000..cbdd5daef
--- /dev/null
+++ b/analytics/src/main/java/com/mixpanel/android/autocapture/SemanticExtractor.java
@@ -0,0 +1,718 @@
+package com.mixpanel.android.autocapture;
+
+import android.graphics.Rect;
+import android.view.View;
+import android.view.ViewGroup;
+import android.view.accessibility.AccessibilityNodeInfo;
+import android.view.accessibility.AccessibilityNodeProvider;
+import android.widget.Button;
+import android.widget.CheckBox;
+import android.widget.CompoundButton;
+import android.widget.EditText;
+import android.widget.ImageButton;
+import android.widget.ImageView;
+import android.widget.RadioButton;
+import android.widget.SeekBar;
+import android.widget.Spinner;
+import android.widget.Switch;
+import android.widget.TextView;
+import android.widget.ToggleButton;
+
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+
+import com.mixpanel.android.util.MPLog;
+
+
+/**
+ * Extracts semantic information from Views and AccessibilityNodeInfo for autocapture.
+ *
+ * <p>Handles both traditional XML Views and Jetpack Compose views (via AccessibilityNodeProvider).
+ */
+final class SemanticExtractor {
+
+    private static final String TAG = "MP.SemanticExtractor";
+
+    // Flag to track if Compose is available (checked once at runtime)
+    private static volatile Boolean composeAvailable = null;
+
+    /**
+     * Extracts semantic information from a view at the given coordinates.
+     *
+     * @param rootView           The root view to search within.
+     * @param x                  Screen X coordinate.
+     * @param y                  Screen Y coordinate.
+     * @return A ClickEvent.Builder with extracted semantics, or null if no view found.
+     */
+    @Nullable
+    static ClickEvent.Builder extract(@NonNull View rootView, float x, float y) {
+        try {
+            // Find the view at the tap position
+            View targetView = findViewAtPosition(rootView, (int) x, (int) y);
+            if (targetView == null) {
+                return null;
+            }
+
+            // Check if target view (or an ancestor) is a Compose root
+            // This handles Compose views by using Compose's SemanticsNode API directly
+            View composeRoot = findComposeRoot(targetView);
+            MPLog.d(TAG, "findComposeRoot result: " + (composeRoot != null ? composeRoot.getClass().getSimpleName() : "null") +
+                    ", targetView: " + targetView.getClass().getSimpleName());
+            if (composeRoot != null) {
+                ClickEvent.Builder composeResult = extractFromCompose(composeRoot, x, y);
+                MPLog.d(TAG, "extractFromCompose result: " + (composeResult != null ? "found" : "not found"));
+
+                if (composeResult != null) {
+                    // Set Compose root for dead click detection using semantic comparison
+                    composeResult.composeRoot(composeRoot);
+                    return composeResult;
+                }
+
+                // Only fall back to accessibility if Compose didn't find a node
+                MPLog.d(TAG, "Compose node not found, falling back to accessibility");
+                ClickEvent.Builder accessibilityResult = extractFromAccessibility(composeRoot, x, y);
+                if (accessibilityResult != null) {
+                    return accessibilityResult;
+                }
+            }
+
+            // Fall back to direct view extraction (XML views)
+            return extractFromView(targetView, x, y);
+        } catch (Exception e) {
+            MPLog.e(TAG, "Error extracting semantics", e);
+        }
+
+        return null;
+    }
+
+    /**
+     * Finds a Compose root view (AndroidComposeView) in the view hierarchy.
+     */
+    @Nullable
+    private static View findComposeRoot(@NonNull View view) {
+        if (!isComposeAvailable()) {
+            return null;
+        }
+
+        View current = view;
+        while (current != null) {
+            try {
+                if (ComposeSemanticHelper.isComposeRoot(current)) {
+                    return current;
+                }
+            } catch (NoClassDefFoundError e) {
+                // Compose not available, mark it and stop checking
+                composeAvailable = false;
+                return null;
+            }
+            if (current.getParent() instanceof View) {
+                current = (View) current.getParent();
+            } else {
+                break;
+            }
+        }
+        return null;
+    }
+
+    /**
+     * Extracts semantics from a Compose root using Compose's SemanticsNode API.
+     */
+    @Nullable
+    private static ClickEvent.Builder extractFromCompose(@NonNull View composeRoot, float x, float y) {
+        try {
+            return ComposeSemanticHelper.extract(composeRoot, x, y);
+        } catch (NoClassDefFoundError e) {
+            // Compose not available at runtime
+            composeAvailable = false;
+            MPLog.d(TAG, "Compose semantics not available: " + e.getMessage());
+            return null;
+        } catch (Exception e) {
+            MPLog.e(TAG, "Error extracting Compose semantics", e);
+            return null;
+        }
+    }
+
+    /**
+     * Checks if Compose UI library is available at runtime.
+     */
+    private static boolean isComposeAvailable() {
+        if (composeAvailable != null) {
+            return composeAvailable;
+        }
+
+        try {
+            Class.forName("androidx.compose.ui.node.RootForTest");
+            composeAvailable = true;
+        } catch (ClassNotFoundException e) {
+            composeAvailable = false;
+        }
+        return composeAvailable;
+    }
+
+    /**
+     * Extracts semantics using AccessibilityNodeProvider (for Compose views).
+     */
+    @Nullable
+    private static ClickEvent.Builder extractFromAccessibility(@NonNull View viewWithProvider, float x, float y) {
+        AccessibilityNodeProvider provider = viewWithProvider.getAccessibilityNodeProvider();
+        if (provider == null) {
+            return null;
+        }
+
+        MPLog.d(TAG, "Using AccessibilityNodeProvider from: " + viewWithProvider.getClass().getSimpleName());
+
+        AccessibilityNodeInfo rootNode = null;
+        AccessibilityNodeInfo targetNode = null;
+        try {
+            rootNode = provider.createAccessibilityNodeInfo(View.NO_ID);
+            if (rootNode == null) {
+                MPLog.d(TAG, "No root accessibility node from provider");
+                return null;
+            }
+
+            targetNode = findNodeAtPosition(
+                    rootNode, (int) x, (int) y, 0, new int[]{0});
+            if (targetNode != null) {
+                // Log what we found for debugging
+                CharSequence className = targetNode.getClassName();
+                CharSequence contentDesc = targetNode.getContentDescription();
+                CharSequence text = targetNode.getText();
+                String viewId = targetNode.getViewIdResourceName();
+                MPLog.d(TAG, "Found accessibility node - class: " + className +
+                        ", contentDesc: " + contentDesc +
+                        ", text: " + text +
+                        ", viewId: " + viewId +
+                        ", clickable: " + targetNode.isClickable());
+
+                return extractFromNode(targetNode, x, y);
+            }
+
+            MPLog.d(TAG, "No accessibility node found at position");
+        } catch (Exception e) {
+            MPLog.d(TAG, "Error extracting from accessibility", e);
+        } finally {
+            if (targetNode != null) {
+                targetNode.recycle();
+            }
+            if (rootNode != null) {
+                rootNode.recycle();
+            }
+        }
+
+        return null;
+    }
+
+    /**
+     * Recursively finds the best AccessibilityNodeInfo at the given position.
+     * Prefers clickable/interactive nodes over non-interactive leaf nodes.
+     *
+     * @param nodeCount Mutable counter tracking total nodes visited across the
+     *                  entire traversal. When {@code nodeCount[0]} exceeds
+     *                  {@link AutocaptureDefaults#MAX_ACCESSIBILITY_NODES}, the
+     *                  traversal stops early and returns the best match found so far.
+     */
+    @Nullable
+    private static AccessibilityNodeInfo findNodeAtPosition(
+            @NonNull AccessibilityNodeInfo node, int x, int y, int depth,
+            @NonNull int[] nodeCount) {
+
+        if (depth > AutocaptureDefaults.MAX_RECURSION_DEPTH) {
+            return null;
+        }
+
+        nodeCount[0]++;
+        if (nodeCount[0] > AutocaptureDefaults.MAX_ACCESSIBILITY_NODES) {
+            if (nodeCount[0] == AutocaptureDefaults.MAX_ACCESSIBILITY_NODES + 1) {
+                MPLog.w(TAG, "Accessibility node limit ("
+                        + AutocaptureDefaults.MAX_ACCESSIBILITY_NODES
+                        + ") reached during hit-test. This screen has a very complex view "
+                        + "hierarchy (e.g., large list, dense dashboard). Autocapture will "
+                        + "use the best match found so far. This limit prevents excessive "
+                        + "main-thread work per tap.");
+            }
+            return null;
+        }
+
+        Rect bounds = new Rect();
+        node.getBoundsInScreen(bounds);
+
+        if (!bounds.contains(x, y)) {
+            return null;
+        }
+
+        // Check children for a more specific match
+        AccessibilityNodeInfo deepestChild = null;
+        int childCount = node.getChildCount();
+        for (int i = childCount - 1; i >= 0; i--) {
+            AccessibilityNodeInfo child = null;
+            try {
+                child = node.getChild(i);
+                if (child != null) {
+                    AccessibilityNodeInfo result = findNodeAtPosition(
+                            child, x, y, depth + 1, nodeCount);
+                    if (result != null) {
+                        child.recycle();
+                        child = null;
+                        if (deepestChild != null) {
+                            deepestChild.recycle();
+                        }
+                        deepestChild = result;
+                        // Continue looking - we'll prefer clickable nodes
+                        break;
+                    }
+                    child.recycle();
+                    child = null;
+                }
+            } catch (Exception e) {
+                if (child != null) {
+                    child.recycle();
+                }
+            }
+        }
+
+        // If we found a child and it's clickable, return it
+        if (deepestChild != null) {
+            if (deepestChild.isClickable() || deepestChild.isLongClickable() || deepestChild.isCheckable()) {
+                return deepestChild;
+            }
+            // Child is not interactive - check if current node is interactive
+            // If so, prefer the current (parent) node for better semantics
+            if (node.isClickable() || node.isLongClickable() || node.isCheckable()) {
+                deepestChild.recycle();
+                return AccessibilityNodeInfo.obtain(node);
+            }
+            // Neither is interactive, return the deepest
+            return deepestChild;
+        }
+
+        // No children matched - return this node
+        return AccessibilityNodeInfo.obtain(node);
+    }
+
+    /**
+     * Extracts semantics from an AccessibilityNodeInfo.
+     */
+    @Nullable
+    private static ClickEvent.Builder extractFromNode(@NonNull AccessibilityNodeInfo node, float x, float y) {
+        CharSequence contentDesc = node.getContentDescription();
+
+        // Element ID resolution for Compose:
+        // 1. viewIdResourceName (from Modifier.testTag)
+        // 2. contentDescription (from Modifier.semantics { contentDescription = ... })
+        // 3. text content (from Text composable)
+        // 4. Class name fallback
+        String elementId = null;
+        String accessibleLabel = null;
+
+        // Try viewIdResourceName first (Compose testTag)
+        String viewId = node.getViewIdResourceName();
+        if (viewId != null && !viewId.isEmpty()) {
+            // viewIdResourceName format: "package:id/name" - extract just the name
+            int slashIndex = viewId.lastIndexOf('/');
+            elementId = slashIndex >= 0 ? viewId.substring(slashIndex + 1) : viewId;
+        }
+
+        // Try contentDescription
+        if (elementId == null && contentDesc != null && contentDesc.length() > 0) {
+            elementId = contentDesc.toString();
+            accessibleLabel = contentDesc.toString();
+        }
+
+        // Fallback to class name + hash
+        if (elementId == null) {
+            CharSequence className = node.getClassName();
+            if (className != null) {
+                String simpleName = getSimpleClassName(className.toString());
+                elementId = simpleName + "_" + Integer.toHexString(node.hashCode());
+            }
+        }
+
+        if (elementId == null) {
+            elementId = "unknown_" + Integer.toHexString(node.hashCode());
+        }
+
+        ClickEvent.Builder builder = new ClickEvent.Builder(x, y, elementId);
+
+        if (accessibleLabel != null) {
+            builder.accessibleLabel(accessibleLabel);
+        }
+
+        // Tag name - for Compose, try to get a meaningful name
+        CharSequence className = node.getClassName();
+        if (className != null) {
+            String simpleName = getSimpleClassName(className.toString());
+            // Map generic Compose class names to more meaningful ones
+            String tagName = mapComposeClassName(simpleName, node);
+            builder.tagName(tagName);
+        }
+
+        // Role
+        builder.role(inferRoleFromNode(node));
+
+        // Build hierarchy from ancestors
+        builder.elements(buildHierarchyFromNode(node));
+
+        // Interactive check - for Compose, also check if it's a known interactive type
+        builder.isInteractive(isInteractiveNode(node));
+
+        return builder;
+    }
+
+    /**
+     * Maps generic Compose class names to more meaningful tag names.
+     */
+    @NonNull
+    private static String mapComposeClassName(@NonNull String className, @NonNull AccessibilityNodeInfo node) {
+        // Compose often reports "View" as the class name
+        // Try to infer a better name from the node's properties
+        if ("View".equals(className)) {
+            if (node.isClickable()) {
+                if (node.isCheckable()) {
+                    return node.isChecked() ? "Switch" : "Checkbox";
+                }
+                return "Button";
+            }
+            if (node.isEditable()) {
+                return "TextField";
+            }
+            if (node.getText() != null && node.getText().length() > 0) {
+                return "Text";
+            }
+        }
+        return className;
+    }
+
+    /**
+     * Builds hierarchy string from AccessibilityNodeInfo ancestors.
+     */
+    @NonNull
+    private static String buildHierarchyFromNode(@NonNull AccessibilityNodeInfo node) {
+        StringBuilder sb = new StringBuilder();
+        AccessibilityNodeInfo current = node;
+        int depth = 0;
+
+        while (current != null && depth < AutocaptureDefaults.MAX_HIERARCHY_DEPTH) {
+            CharSequence className = current.getClassName();
+            if (className != null) {
+                if (sb.length() > 0) {
+                    sb.insert(0, AutocaptureDefaults.HIERARCHY_SEPARATOR);
+                }
+                sb.insert(0, getSimpleClassName(className.toString()));
+            }
+
+            AccessibilityNodeInfo parent;
+            try {
+                parent = current.getParent();
+            } catch (IllegalStateException e) {
+                // Nodes from AccessibilityNodeProvider.createAccessibilityNodeInfo()
+                // are not sealed and cannot call getParent(). Return what we have.
+                break;
+            }
+            if (current != node) {
+                current.recycle();
+            }
+            current = parent;
+            depth++;
+        }
+
+        if (current != null && current != node) {
+            current.recycle();
+        }
+
+        return sb.toString();
+    }
+
+    /**
+     * Checks if an AccessibilityNodeInfo represents an interactive element.
+     * Excludes controls with inherent visual feedback from dead click monitoring.
+     */
+    private static boolean isInteractiveNode(@NonNull AccessibilityNodeInfo node) {
+        // Exclude controls with inherent visual feedback
+        if (node.isEditable()) {
+            // TextField - keyboard appears
+            return false;
+        }
+        if (node.isCheckable()) {
+            // Switch, Checkbox - toggle animation
+            return false;
+        }
+        CharSequence className = node.getClassName();
+        if (className != null) {
+            String name = className.toString();
+            if (name.contains("Slider") || name.contains("SeekBar") ||
+                name.contains("ProgressBar")) {
+                return false;
+            }
+        }
+
+        // Check if clickable/longClickable
+        return node.isClickable() || node.isLongClickable();
+    }
+
+    /**
+     * Extracts semantics from a traditional View.
+     */
+    @Nullable
+    private static ClickEvent.Builder extractFromView(@NonNull View view, float x, float y) {
+        // Element ID resolution: contentDescription > resource ID > fallback
+        String elementId = resolveElementId(view);
+        if (elementId == null) {
+            elementId = "unknown_" + Integer.toHexString(view.hashCode());
+        }
+
+        ClickEvent.Builder builder = new ClickEvent.Builder(x, y, elementId);
+
+        // Tag name
+        builder.tagName(view.getClass().getSimpleName());
+
+        // Content description (aria-label)
+        CharSequence contentDesc = view.getContentDescription();
+        if (contentDesc != null && contentDesc.length() > 0) {
+            builder.accessibleLabel(contentDesc.toString());
+        }
+
+        // Role
+        builder.role(inferRoleFromView(view));
+
+        // View hierarchy
+        builder.elements(buildHierarchyString(view));
+
+        // Interactive check
+        builder.isInteractive(isInteractive(view));
+
+        return builder;
+    }
+
+    /**
+     * Finds the deepest view at the given screen coordinates.
+     */
+    @Nullable
+    private static View findViewAtPosition(@NonNull View view, int x, int y) {
+        return findViewAtPosition(view, x, y, 0);
+    }
+
+    @Nullable
+    private static View findViewAtPosition(@NonNull View view, int x, int y, int depth) {
+        if (depth >= AutocaptureDefaults.MAX_RECURSION_DEPTH) {
+            return null;
+        }
+
+        if (!isViewVisible(view)) {
+            return null;
+        }
+
+        int[] location = new int[2];
+        view.getLocationOnScreen(location);
+        int left = location[0];
+        int top = location[1];
+        int right = left + view.getWidth();
+        int bottom = top + view.getHeight();
+
+        if (x < left || x > right || y < top || y > bottom) {
+            return null;
+        }
+
+        // Check children in reverse order (top-most first)
+        if (view instanceof ViewGroup) {
+            ViewGroup group = (ViewGroup) view;
+            for (int i = group.getChildCount() - 1; i >= 0; i--) {
+                View child = group.getChildAt(i);
+                View result = findViewAtPosition(child, x, y, depth + 1);
+                if (result != null) {
+                    return result;
+                }
+            }
+        }
+
+        return view;
+    }
+
+    /**
+     * Resolves the element ID according to the priority:
+     * 1. contentDescription (if non-empty)
+     * 2. Resource ID name (R.id.xxx)
+     * 3. ClassName_<hashCode>
+     */
+    @NonNull
+    private static String resolveElementId(@NonNull View view) {
+        // 1. Try contentDescription
+        CharSequence contentDesc = view.getContentDescription();
+        if (contentDesc != null && contentDesc.length() > 0) {
+            return contentDesc.toString();
+        }
+
+        // 2. Try resource ID name
+        int id = view.getId();
+        if (id != View.NO_ID) {
+            try {
+                String resourceName = view.getResources().getResourceEntryName(id);
+                if (resourceName != null && !resourceName.isEmpty()) {
+                    return resourceName;
+                }
+            } catch (Exception ignored) {
+                // Resource not found, use fallback
+            }
+        }
+
+        // 3. Fallback: ClassName_<hashCode>
+        return view.getClass().getSimpleName() + "_" + Integer.toHexString(view.hashCode());
+    }
+
+    /**
+     * Builds a hierarchy string of ancestor views (max depth).
+     */
+    @NonNull
+    private static String buildHierarchyString(@NonNull View view) {
+        StringBuilder sb = new StringBuilder();
+        View current = view;
+        int depth = 0;
+
+        while (current != null && depth < AutocaptureDefaults.MAX_HIERARCHY_DEPTH) {
+            if (sb.length() > 0) {
+                sb.insert(0, AutocaptureDefaults.HIERARCHY_SEPARATOR);
+            }
+            sb.insert(0, current.getClass().getSimpleName());
+
+            if (current.getParent() instanceof View) {
+                current = (View) current.getParent();
+            } else {
+                break;
+            }
+            depth++;
+        }
+
+        return sb.toString();
+    }
+
+    /**
+     * Infers the semantic role from a View's class.
+     */
+    @Nullable
+    private static String inferRoleFromView(@NonNull View view) {
+        if (view instanceof Button || view instanceof ImageButton) {
+            return "Button";
+        }
+        if (view instanceof Switch || view instanceof ToggleButton) {
+            return "Switch";
+        }
+        if (view instanceof CheckBox) {
+            return "Checkbox";
+        }
+        if (view instanceof RadioButton) {
+            return "Radio";
+        }
+        if (view instanceof SeekBar) {
+            return "Slider";
+        }
+        if (view instanceof Spinner) {
+            return "ComboBox";
+        }
+        if (view instanceof EditText) {
+            return "TextField";
+        }
+        if (view instanceof ImageView) {
+            return "Image";
+        }
+        if (view instanceof TextView) {
+            return "Text";
+        }
+        if (view.isClickable() || view.isLongClickable()) {
+            return "Button";
+        }
+        return null;
+    }
+
+    /**
+     * Infers the semantic role from an AccessibilityNodeInfo.
+     */
+    @Nullable
+    private static String inferRoleFromNode(@NonNull AccessibilityNodeInfo node) {
+        CharSequence className = node.getClassName();
+        if (className == null) {
+            return null;
+        }
+
+        String name = className.toString();
+        if (name.contains("Button")) {
+            return "Button";
+        }
+        if (name.contains("Switch") || name.contains("Toggle")) {
+            return "Switch";
+        }
+        if (name.contains("CheckBox")) {
+            return "Checkbox";
+        }
+        if (name.contains("RadioButton")) {
+            return "Radio";
+        }
+        if (name.contains("SeekBar") || name.contains("Slider")) {
+            return "Slider";
+        }
+        if (name.contains("Spinner")) {
+            return "ComboBox";
+        }
+        if (name.contains("EditText")) {
+            return "TextField";
+        }
+        if (name.contains("Image")) {
+            return "Image";
+        }
+        if (name.contains("Text")) {
+            return "Text";
+        }
+        if (node.isClickable() || node.isLongClickable()) {
+            return "Button";
+        }
+        return null;
+    }
+
+    /**
+     * Checks if a view is interactive for dead click detection purposes.
+     *
+     * <p>Note: Controls with inherent visual feedback (EditText, Switch, SeekBar)
+     * are excluded because they always produce a UI response:
+     * - EditText: Shows cursor, keyboard appears
+     * - Switch/CompoundButton: Toggle animation and state change
+     * - SeekBar: Thumb moves with drag
+     */
+    private static boolean isInteractive(@NonNull View view) {
+        // Exclude controls with inherent visual feedback from dead click monitoring
+        if (view instanceof EditText ||
+            view instanceof CompoundButton ||  // Switch, CheckBox, RadioButton, ToggleButton
+            view instanceof SeekBar) {
+            return false;
+        }
+
+        if (view.hasOnClickListeners()) {
+            return true;
+        }
+        if (view.isClickable() || view.isLongClickable()) {
+            return true;
+        }
+        // Known interactive types
+        return view instanceof Button ||
+               view instanceof Spinner;
+    }
+
+    /**
+     * Checks if a view is visible (not gone/invisible and has positive dimensions).
+     */
+    private static boolean isViewVisible(@NonNull View view) {
+        return view.getVisibility() == View.VISIBLE &&
+               view.getWidth() > 0 &&
+               view.getHeight() > 0;
+    }
+
+    /**
+     * Extracts the simple class name from a fully qualified class name.
+     */
+    @NonNull
+    private static String getSimpleClassName(@NonNull String fullyQualifiedName) {
+        int lastDot = fullyQualifiedName.lastIndexOf('.');
+        return lastDot >= 0 ? fullyQualifiedName.substring(lastDot + 1) : fullyQualifiedName;
+    }
+
+    private SemanticExtractor() {
+        // Prevent instantiation
+    }
+}
diff --git a/analytics/src/main/java/com/mixpanel/android/autocapture/WindowSpy.java b/analytics/src/main/java/com/mixpanel/android/autocapture/WindowSpy.java
new file mode 100644
index 000000000..c14c7a9b9
--- /dev/null
+++ b/analytics/src/main/java/com/mixpanel/android/autocapture/WindowSpy.java
@@ -0,0 +1,133 @@
+package com.mixpanel.android.autocapture;
+
+import android.view.View;
+
+import androidx.annotation.NonNull;
+
+import com.mixpanel.android.util.MPLog;
+
+import java.util.List;
+import java.util.concurrent.CopyOnWriteArrayList;
+
+import curtains.Curtains;
+import curtains.OnRootViewsChangedListener;
+
+/**
+ * Adapter over Square's Curtains library for tracking root views (windows).
+ *
+ * <p>Delegates to {@link Curtains#getOnRootViewsChangedListeners()} for window
+ * add/remove notifications. This enables autocapture to intercept touch events
+ * on all windows including dialogs, popups, menus, and spinners.
+ *
+ * <p>Using Curtains instead of custom reflection ensures compatibility with
+ * other libraries that also observe root views (e.g., Mixpanel Session Replay).
+ */
+final class WindowSpy {
+
+    private static final String TAG = "MP.WindowSpy";
+
+    private static final List<OnRootViewChangedListener> sListeners = new CopyOnWriteArrayList<>();
+    private static volatile boolean sInstalled = false;
+    private static OnRootViewsChangedListener sCurtainsListener;
+
+    /**
+     * Listener interface for root view changes.
+     */
+    interface OnRootViewChangedListener {
+        /**
+         * Called when a root view is added or removed.
+         *
+         * @param view  The root view that changed.
+         * @param added {@code true} if the view was added, {@code false} if removed.
+         */
+        void onRootViewChanged(@NonNull View view, boolean added);
+    }
+
+    /**
+     * Installs the WindowSpy hook via Curtains.
+     *
+     * <p>This method is safe to call multiple times; subsequent calls are no-ops.
+     * Curtains handles the underlying WindowManagerGlobal reflection and is
+     * compatible with other Curtains consumers (e.g., Session Replay SDK).
+     */
+    static void install() {
+        if (sInstalled) {
+            return;
+        }
+
+        synchronized (WindowSpy.class) {
+            if (sInstalled) {
+                return;
+            }
+
+            try {
+                sCurtainsListener = (view, added) -> notifyListeners(view, added);
+                Curtains.getOnRootViewsChangedListeners().add(sCurtainsListener);
+                sInstalled = true;
+                MPLog.d(TAG, "WindowSpy installed via Curtains");
+            } catch (Exception e) {
+                // Defensive: Curtains relies on WindowManagerGlobal.mViews reflection
+                // which has been stable since API 17 but the library is no longer
+                // actively maintained. If a future Android version restricts this
+                // internal API, we degrade gracefully — activity windows still work
+                // via lifecycle callbacks, only dialogs/popups lose coverage.
+                MPLog.e(TAG, "Failed to install WindowSpy via Curtains, "
+                        + "only Activity windows will be tracked", e);
+            }
+        }
+    }
+
+    /**
+     * Uninstalls the WindowSpy hook, removing the Curtains listener.
+     */
+    static void uninstall() {
+        synchronized (WindowSpy.class) {
+            if (sCurtainsListener != null) {
+                try {
+                    Curtains.getOnRootViewsChangedListeners().remove(sCurtainsListener);
+                } catch (Exception e) {
+                    MPLog.e(TAG, "Failed to remove Curtains listener", e);
+                }
+                sCurtainsListener = null;
+            }
+            sInstalled = false;
+        }
+    }
+
+    /**
+     * Adds a listener to be notified of root view changes.
+     *
+     * @param listener The listener to add.
+     */
+    static void addListener(@NonNull OnRootViewChangedListener listener) {
+        if (!sListeners.contains(listener)) {
+            sListeners.add(listener);
+        }
+    }
+
+    /**
+     * Removes a previously added listener.
+     *
+     * @param listener The listener to remove.
+     */
+    static void removeListener(@NonNull OnRootViewChangedListener listener) {
+        sListeners.remove(listener);
+    }
+
+    /**
+     * Notifies all registered listeners of a root view change.
+     */
+    private static void notifyListeners(@NonNull View view, boolean added) {
+        for (OnRootViewChangedListener listener : sListeners) {
+            try {
+                listener.onRootViewChanged(view, added);
+            } catch (Exception e) {
+                MPLog.e(TAG, "Error notifying WindowSpy listener", e);
+            }
+        }
+    }
+
+    private WindowSpy() {
+        // Prevent instantiation
+    }
+}
diff --git a/analytics/src/main/java/com/mixpanel/android/mpmetrics/AutocaptureOptions.java b/analytics/src/main/java/com/mixpanel/android/mpmetrics/AutocaptureOptions.java
new file mode 100644
index 000000000..e9c936b42
--- /dev/null
+++ b/analytics/src/main/java/com/mixpanel/android/mpmetrics/AutocaptureOptions.java
@@ -0,0 +1,174 @@
+package com.mixpanel.android.mpmetrics;
+
+import androidx.annotation.NonNull;
+
+/**
+ * Configuration options for Mixpanel autocapture.
+ *
+ * <p>Autocapture automatically tracks user interactions without requiring manual instrumentation.
+ * Phase 1 supports click events, rage clicks, and dead clicks.
+ *
+ * <p>Autocapture is <b>disabled by default</b>. To enable, create an AutocaptureOptions instance
+ * and pass it to {@link MixpanelOptions.Builder#autocaptureOptions(AutocaptureOptions)}.
+ *
+ * <pre>{@code
+ * // Enable all autocapture with defaults
+ * AutocaptureOptions autocaptureOptions = new AutocaptureOptions.Builder().build();
+ *
+ * // Or customize individual event types
+ * AutocaptureOptions autocaptureOptions = new AutocaptureOptions.Builder()
+ *     .clickOptions(new ClickOptions.Builder().enabled(true).build())
+ *     .rageClickOptions(new RageClickOptions.Builder()
+ *         .enabled(true)
+ *         .clickThreshold(5)
+ *         .build())
+ *     .deadClickOptions(new DeadClickOptions.Builder()
+ *         .enabled(false)  // Disable dead click detection
+ *         .build())
+ *     .build();
+ *
+ * MixpanelOptions options = new MixpanelOptions.Builder()
+ *     .autocaptureOptions(autocaptureOptions)
+ *     .build();
+ *
+ * MixpanelAPI mixpanel = MixpanelAPI.getInstance(context, "YOUR_TOKEN", true, options);
+ * }</pre>
+ *
+ * @see MixpanelOptions.Builder#autocaptureOptions(AutocaptureOptions)
+ * @see ClickOptions
+ * @see RageClickOptions
+ * @see DeadClickOptions
+ */
+public class AutocaptureOptions {
+
+    private final ClickOptions mClickOptions;
+    private final RageClickOptions mRageClickOptions;
+    private final DeadClickOptions mDeadClickOptions;
+    private AutocaptureOptions(Builder builder) {
+        this.mClickOptions = builder.mClickOptions;
+        this.mRageClickOptions = builder.mRageClickOptions;
+        this.mDeadClickOptions = builder.mDeadClickOptions;
+    }
+
+    /**
+     * Returns whether any autocapture feature is enabled.
+     *
+     * <p>This returns {@code true} if at least one of click, rage click, or dead click
+     * detection is enabled.
+     *
+     * @return {@code true} if any autocapture feature is enabled, {@code false} otherwise.
+     */
+    public boolean isEnabled() {
+        return mClickOptions.isEnabled() ||
+               mRageClickOptions.isEnabled() ||
+               mDeadClickOptions.isEnabled();
+    }
+
+    /**
+     * Returns the click options configuration.
+     *
+     * @return The {@link ClickOptions} for click event tracking.
+     */
+    @NonNull
+    public ClickOptions getClickOptions() {
+        return mClickOptions;
+    }
+
+    /**
+     * Returns the rage click options configuration.
+     *
+     * @return The {@link RageClickOptions} for rage click detection.
+     */
+    @NonNull
+    public RageClickOptions getRageClickOptions() {
+        return mRageClickOptions;
+    }
+
+    /**
+     * Returns the dead click options configuration.
+     *
+     * @return The {@link DeadClickOptions} for dead click detection.
+     */
+    @NonNull
+    public DeadClickOptions getDeadClickOptions() {
+        return mDeadClickOptions;
+    }
+
+    /**
+     * Builder for creating {@link AutocaptureOptions} instances.
+     *
+     * <p>When built, all event types are enabled by default with their respective default settings.
+     * Use the individual options builders to customize or disable specific event types.
+     */
+    public static class Builder {
+        private ClickOptions mClickOptions = new ClickOptions.Builder().build();
+        private RageClickOptions mRageClickOptions = new RageClickOptions.Builder().build();
+        private DeadClickOptions mDeadClickOptions = new DeadClickOptions.Builder().build();
+
+        /**
+         * Creates a Builder with all event types enabled by default.
+         *
+         * <p>{@code new AutocaptureOptions.Builder().build()} enables click, rage click,
+         * and dead click tracking with default settings. Use the individual setters
+         * only to customize or disable specific event types.
+         */
+        public Builder() {
+        }
+
+        /**
+         * Creates a Builder pre-populated with values from an existing {@link AutocaptureOptions}.
+         *
+         * @param source The AutocaptureOptions to copy values from.
+         */
+        public Builder(AutocaptureOptions source) {
+            this.mClickOptions = source.mClickOptions;
+            this.mRageClickOptions = source.mRageClickOptions;
+            this.mDeadClickOptions = source.mDeadClickOptions;
+        }
+
+        /**
+         * Sets the click options for autocapture.
+         *
+         * @param clickOptions The {@link ClickOptions} configuration.
+         * @return This Builder instance for chaining.
+         */
+        public Builder clickOptions(@NonNull ClickOptions clickOptions) {
+            if (clickOptions == null) return this;
+            this.mClickOptions = clickOptions;
+            return this;
+        }
+
+        /**
+         * Sets the rage click options for autocapture.
+         *
+         * @param rageClickOptions The {@link RageClickOptions} configuration.
+         * @return This Builder instance for chaining.
+         */
+        public Builder rageClickOptions(@NonNull RageClickOptions rageClickOptions) {
+            if (rageClickOptions == null) return this;
+            this.mRageClickOptions = rageClickOptions;
+            return this;
+        }
+
+        /**
+         * Sets the dead click options for autocapture.
+         *
+         * @param deadClickOptions The {@link DeadClickOptions} configuration.
+         * @return This Builder instance for chaining.
+         */
+        public Builder deadClickOptions(@NonNull DeadClickOptions deadClickOptions) {
+            if (deadClickOptions == null) return this;
+            this.mDeadClickOptions = deadClickOptions;
+            return this;
+        }
+
+        /**
+         * Builds and returns an {@link AutocaptureOptions} instance with the configured settings.
+         *
+         * @return A new {@link AutocaptureOptions} instance.
+         */
+        public AutocaptureOptions build() {
+            return new AutocaptureOptions(this);
+        }
+    }
+}
diff --git a/analytics/src/main/java/com/mixpanel/android/mpmetrics/ClickOptions.java b/analytics/src/main/java/com/mixpanel/android/mpmetrics/ClickOptions.java
new file mode 100644
index 000000000..5cc5c429f
--- /dev/null
+++ b/analytics/src/main/java/com/mixpanel/android/mpmetrics/ClickOptions.java
@@ -0,0 +1,77 @@
+package com.mixpanel.android.mpmetrics;
+
+/**
+ * Configuration options for click event autocapture.
+ *
+ * <p>Use this class to enable or disable click event tracking when autocapture is enabled.
+ *
+ * <pre>{@code
+ * ClickOptions clickOptions = new ClickOptions.Builder()
+ *     .enabled(true)
+ *     .build();
+ * }</pre>
+ *
+ * @see AutocaptureOptions.Builder#clickOptions(ClickOptions)
+ */
+public class ClickOptions {
+
+    private final boolean mEnabled;
+
+    private ClickOptions(Builder builder) {
+        this.mEnabled = builder.mEnabled;
+    }
+
+    /**
+     * Returns whether click event tracking is enabled.
+     *
+     * @return {@code true} if click events are tracked, {@code false} otherwise.
+     *         Defaults to {@code true} when autocapture is enabled.
+     */
+    public boolean isEnabled() {
+        return mEnabled;
+    }
+
+    /**
+     * Builder for creating {@link ClickOptions} instances.
+     *
+     * <p>Default values:
+     * <ul>
+     *   <li>{@code enabled} = {@code true}</li>
+     * </ul>
+     */
+    public static class Builder {
+        private boolean mEnabled = true;
+
+        public Builder() {
+        }
+
+        /**
+         * Creates a Builder pre-populated with values from an existing {@link ClickOptions}.
+         *
+         * @param source The ClickOptions to copy values from.
+         */
+        public Builder(ClickOptions source) {
+            this.mEnabled = source.mEnabled;
+        }
+
+        /**
+         * Enables or disables click event tracking.
+         *
+         * @param enabled {@code true} to track click events, {@code false} to disable.
+         * @return This Builder instance for chaining.
+         */
+        public Builder enabled(boolean enabled) {
+            this.mEnabled = enabled;
+            return this;
+        }
+
+        /**
+         * Builds and returns a {@link ClickOptions} instance with the configured settings.
+         *
+         * @return A new {@link ClickOptions} instance.
+         */
+        public ClickOptions build() {
+            return new ClickOptions(this);
+        }
+    }
+}
diff --git a/analytics/src/main/java/com/mixpanel/android/mpmetrics/DeadClickOptions.java b/analytics/src/main/java/com/mixpanel/android/mpmetrics/DeadClickOptions.java
new file mode 100644
index 000000000..8517ae185
--- /dev/null
+++ b/analytics/src/main/java/com/mixpanel/android/mpmetrics/DeadClickOptions.java
@@ -0,0 +1,106 @@
+package com.mixpanel.android.mpmetrics;
+
+/**
+ * Configuration options for dead click detection in autocapture.
+ *
+ * <p>Dead clicks are detected when a user clicks on an element that appears to be interactive
+ * but produces no UI response within a configured timeout period.
+ *
+ * <pre>{@code
+ * DeadClickOptions deadClickOptions = new DeadClickOptions.Builder()
+ *     .enabled(true)
+ *     .timeoutMs(600)         // Wait 600ms for UI response
+ *     .build();
+ * }</pre>
+ *
+ * @see AutocaptureOptions.Builder#deadClickOptions(DeadClickOptions)
+ */
+public class DeadClickOptions {
+
+    private final boolean mEnabled;
+    private final long mTimeoutMs;
+
+    private DeadClickOptions(Builder builder) {
+        this.mEnabled = builder.mEnabled;
+        this.mTimeoutMs = builder.mTimeoutMs;
+    }
+
+    /**
+     * Returns whether dead click detection is enabled.
+     *
+     * @return {@code true} if dead clicks are tracked, {@code false} otherwise.
+     *         Defaults to {@code true} when autocapture is enabled.
+     */
+    public boolean isEnabled() {
+        return mEnabled;
+    }
+
+    /**
+     * Returns the timeout in milliseconds to wait for a UI response after a click.
+     *
+     * <p>If no UI change is detected within this time, a dead click event is emitted.
+     *
+     * @return The timeout in milliseconds. Defaults to 500.
+     */
+    public long getTimeoutMs() {
+        return mTimeoutMs;
+    }
+
+    /**
+     * Builder for creating {@link DeadClickOptions} instances.
+     *
+     * <p>Default values:
+     * <ul>
+     *   <li>{@code enabled} = {@code true}</li>
+     *   <li>{@code timeoutMs} = 500</li>
+     * </ul>
+     */
+    public static class Builder {
+        private boolean mEnabled = true;
+        private long mTimeoutMs = 500;
+
+        public Builder() {
+        }
+
+        /**
+         * Creates a Builder pre-populated with values from an existing {@link DeadClickOptions}.
+         *
+         * @param source The DeadClickOptions to copy values from.
+         */
+        public Builder(DeadClickOptions source) {
+            this.mEnabled = source.mEnabled;
+            this.mTimeoutMs = source.mTimeoutMs;
+        }
+
+        /**
+         * Enables or disables dead click detection.
+         *
+         * @param enabled {@code true} to detect dead clicks, {@code false} to disable.
+         * @return This Builder instance for chaining.
+         */
+        public Builder enabled(boolean enabled) {
+            this.mEnabled = enabled;
+            return this;
+        }
+
+        /**
+         * Sets the timeout in milliseconds to wait for a UI response.
+         *
+         * @param timeoutMs The timeout in milliseconds. Must be positive.
+         * @return This Builder instance for chaining.
+         */
+        public Builder timeoutMs(long timeoutMs) {
+            this.mTimeoutMs = Math.max(1, timeoutMs);
+            return this;
+        }
+
+        /**
+         * Builds and returns a {@link DeadClickOptions} instance with the configured settings.
+         *
+         * @return A new {@link DeadClickOptions} instance.
+         */
+        public DeadClickOptions build() {
+            return new DeadClickOptions(this);
+        }
+    }
+}
diff --git a/analytics/src/main/java/com/mixpanel/android/mpmetrics/MixpanelAPI.java b/analytics/src/main/java/com/mixpanel/android/mpmetrics/MixpanelAPI.java
index ad4c13e3a..e14169cb0 100644
--- a/analytics/src/main/java/com/mixpanel/android/mpmetrics/MixpanelAPI.java
+++ b/analytics/src/main/java/com/mixpanel/android/mpmetrics/MixpanelAPI.java
@@ -14,6 +14,7 @@
 import android.os.Bundle;
 import android.os.Handler;
 import android.os.Looper;
+
 import androidx.annotation.NonNull;
 import androidx.annotation.Nullable;
 import androidx.core.content.ContextCompat;
@@ -21,11 +22,19 @@
 import androidx.lifecycle.Lifecycle;
 import androidx.lifecycle.LifecycleOwner;
 import androidx.lifecycle.ProcessLifecycleOwner;
+
+import com.mixpanel.android.autocapture.AutocaptureManager;
+import com.mixpanel.android.autocapture.ClickEvent;
 import com.mixpanel.android.util.HttpService;
 import com.mixpanel.android.util.MPLog;
 import com.mixpanel.android.util.MixpanelNetworkErrorListener;
 import com.mixpanel.android.util.ProxyServerInteractor;
 import com.mixpanel.android.util.RemoteService;
+
+import org.json.JSONArray;
+import org.json.JSONException;
+import org.json.JSONObject;
+
 import java.io.File;
 import java.lang.reflect.InvocationTargetException;
 import java.lang.reflect.Method;
@@ -44,9 +53,6 @@
 import java.util.TimeZone;
 import java.util.concurrent.Future;
 import java.util.concurrent.atomic.AtomicBoolean;
-import org.json.JSONArray;
-import org.json.JSONException;
-import org.json.JSONObject;
 
 /**
  * Core class for interacting with Mixpanel Analytics.
@@ -310,6 +316,20 @@ public class MixpanelAPI implements FeatureFlagDelegate {
                     SessionReplayBroadcastReceiver.INTENT_FILTER,
                     ContextCompat.RECEIVER_NOT_EXPORTED);
         }
+
+        // Initialize autocapture if enabled and tracking is not opted out.
+        // Null check is the primary gate — null means the caller never opted in.
+        // isEnabled() is a secondary check to avoid initializing the machinery
+        // when all sub-options (click, rage, dead) are individually disabled.
+        AutocaptureOptions autocaptureOptions = options.getAutocaptureOptions();
+        if (autocaptureOptions != null && autocaptureOptions.isEnabled()) {
+            mAutocaptureOptions = autocaptureOptions;
+            if (hasOptedOutTracking()) {
+                MPLog.i(LOGTAG, "Autocapture disabled: tracking is opted out");
+            } else {
+                initializeAutocapture(autocaptureOptions);
+            }
+        }
     }
 
     /**
@@ -1033,96 +1053,32 @@ public Autocapture getAutocapture() {
     }
 
     /**
-     * Provides methods for tracking autocapture events. Events tracked through this class
-     * are automatically tagged with the {@code $mp_autocapture} property, which causes them
-     * to appear with an "[Auto]" prefix in the Mixpanel web app.
-     *
-     * <p>Access this via {@link MixpanelAPI#getAutocapture()}.
+     * Returns the AutocaptureManager instance, or null if autocapture is not configured.
+     * Package-private for testing.
      */
-    public class Autocapture {
-
-        /**
-         * Track a screen view event. This is a convenience method for tracking when users view
-         * a screen/page in your application.
-         *
-         * @param screenName The name of the screen/page being viewed
-         * @param properties A JSONObject containing additional properties to include with this event.
-         *                   Pass null if no extra properties exist.
-         */
-        public void trackScreenView(@NonNull String screenName, JSONObject properties) {
-            if (screenName.trim().isEmpty()) {
-                MPLog.w(LOGTAG, "trackScreenView called with empty screenName, ignoring event");
-                return;
-            }
-            JSONObject mergedProperties = new JSONObject();
-            try {
-                if (properties != null) {
-                    Iterator<String> keys = properties.keys();
-                    while (keys.hasNext()) {
-                        String key = keys.next();
-                        mergedProperties.put(key, properties.get(key));
-                    }
-                }
-
-                // SDK properties set after caller properties to prevent overrides
-                mergedProperties.put("current_page_title", screenName);
-                mergedProperties.put("$mp_autocapture", true);
-            } catch (JSONException e) {
-                MPLog.e(LOGTAG, "Exception merging properties for trackScreenView", e);
-            }
-
-            track("$mp_page_view", mergedProperties);
-        }
-
-        /**
-         * Track a screen view event without additional properties.
-         *
-         * @param screenName The name of the screen/page being viewed
-         */
-        public void trackScreenView(@NonNull String screenName) {
-            trackScreenView(screenName, null);
-        }
-
-        /**
-         * Track a screen leave event. This is a convenience method for tracking when users leave
-         * a screen/page in your application.
-         *
-         * @param screenName The name of the screen/page being left
-         * @param properties A JSONObject containing additional properties to include with this event.
-         *                   Pass null if no extra properties exist.
-         */
-        public void trackScreenLeave(@NonNull String screenName, JSONObject properties) {
-            if (screenName.trim().isEmpty()) {
-                MPLog.w(LOGTAG, "trackScreenLeave called with empty screenName, ignoring event");
-                return;
-            }
-            JSONObject mergedProperties = new JSONObject();
-            try {
-                if (properties != null) {
-                    Iterator<String> keys = properties.keys();
-                    while (keys.hasNext()) {
-                        String key = keys.next();
-                        mergedProperties.put(key, properties.get(key));
-                    }
-                }
-
-                // SDK properties set after caller properties to prevent overrides
-                mergedProperties.put("current_page_title", screenName);
-                mergedProperties.put("$mp_autocapture", true);
-            } catch (JSONException e) {
-                MPLog.e(LOGTAG, "Exception merging properties for trackScreenLeave", e);
-            }
-
-            track("$mp_page_leave", mergedProperties);
-        }
+    AutocaptureManager getAutocaptureManager() {
+        return mAutocaptureManager;
+    }
 
-        /**
-         * Track a screen leave event without additional properties.
-         *
-         * @param screenName The name of the screen/page being left
-         */
-        public void trackScreenLeave(@NonNull String screenName) {
-            trackScreenLeave(screenName, null);
+    /**
+     * Initializes the autocapture functionality with the provided options.
+     *
+     * <p>Autocapture automatically tracks user interactions (clicks, rage clicks, dead clicks)
+     * without requiring manual instrumentation.
+     *
+     * @param options The autocapture configuration options.
+     */
+    private void initializeAutocapture(AutocaptureOptions options) {
+        try {
+            mAutocaptureManager = new AutocaptureManager(
+                    mContext,
+                    options,
+                mAutocapture
+            );
+            mAutocaptureManager.start();
+            MPLog.d(LOGTAG, "Autocapture initialized");
+        } catch (Exception e) {
+            MPLog.e(LOGTAG, "Failed to initialize autocapture", e);
         }
     }
 
@@ -1571,6 +1527,10 @@ public void optOutTracking() {
         // Drop in-memory feature flag state (and any persisted variants) so the prior user's
         // variants can't be served via getVariant after they've opted out.
         mFeatureFlagManager.reset();
+
+        if (mAutocaptureManager != null) {
+            mAutocaptureManager.stop();
+        }
     }
 
     /**
@@ -1616,6 +1576,15 @@ public void optInTracking(String distinctId, JSONObject properties) {
             identify(distinctId);
         }
         track("$opt_in", properties);
+
+        // Restart autocapture if it was configured but stopped due to opt-out
+        if (mAutocaptureOptions != null && mAutocaptureOptions.isEnabled()) {
+            if (mAutocaptureManager == null) {
+                initializeAutocapture(mAutocaptureOptions);
+            } else {
+                mAutocaptureManager.start();
+            }
+        }
     }
 
     /**
@@ -2295,6 +2264,207 @@ void isEnabled(
         }
     }
 
+    /**
+     * Provides methods for tracking autocapture events. Events tracked through this class
+     * are automatically tagged with the {@code $mp_autocapture} property, which causes them
+     * to appear with an "[Auto]" prefix in the Mixpanel web app.
+     *
+     * <p>Access this via {@link MixpanelAPI#getAutocapture()}.
+     */
+    public class Autocapture {
+
+        /**
+         * Track a screen view event. This is a convenience method for tracking when users view
+         * a screen/page in your application.
+         *
+         * @param screenName The name of the screen/page being viewed
+         * @param properties A JSONObject containing additional properties to include with this event.
+         *                   Pass null if no extra properties exist.
+         */
+        public void trackScreenView(@NonNull String screenName, @Nullable JSONObject properties) {
+            if (screenName == null || screenName.trim().isEmpty()) {
+                MPLog.w(LOGTAG, "trackScreenView called with null or empty screenName, ignoring event");
+                return;
+            }
+            JSONObject mergedProperties = new JSONObject();
+            try {
+                mergeProperties(mergedProperties, properties);
+                // SDK properties set after caller properties to prevent overrides
+                mergedProperties.put("current_page_title", screenName);
+            } catch (JSONException e) {
+                MPLog.e(LOGTAG, "Exception merging properties for trackScreenView", e);
+            }
+
+            trackAutocaptureEvent("$mp_page_view", mergedProperties);
+        }
+
+        /**
+         * Track a screen view event without additional properties.
+         *
+         * @param screenName The name of the screen/page being viewed
+         */
+        public void trackScreenView(@NonNull String screenName) {
+            trackScreenView(screenName, null);
+        }
+
+        /**
+         * Track a screen leave event. This is a convenience method for tracking when users leave
+         * a screen/page in your application.
+         *
+         * @param screenName The name of the screen/page being left
+         * @param properties A JSONObject containing additional properties to include with this event.
+         *                   Pass null if no extra properties exist.
+         */
+        public void trackScreenLeave(@NonNull String screenName, @Nullable JSONObject properties) {
+            if (screenName == null || screenName.trim().isEmpty()) {
+                MPLog.w(LOGTAG, "trackScreenLeave called with null or empty screenName, ignoring event");
+                return;
+            }
+            JSONObject mergedProperties = new JSONObject();
+            try {
+                mergeProperties(mergedProperties, properties);
+                // SDK properties set after caller properties to prevent overrides
+                mergedProperties.put("current_page_title", screenName);
+            } catch (JSONException e) {
+                MPLog.e(LOGTAG, "Exception merging properties for trackScreenLeave", e);
+            }
+
+            trackAutocaptureEvent("$mp_page_leave", mergedProperties);
+        }
+
+        /**
+         * Track a screen leave event without additional properties.
+         *
+         * @param screenName The name of the screen/page being left
+         */
+        public void trackScreenLeave(@NonNull String screenName) {
+            trackScreenLeave(screenName, null);
+        }
+
+        // ==================== Click Tracking ====================
+
+        /**
+         * Track a click event from a ClickEvent object. Use this for full control over
+         * click metadata when your app handles its own click detection.
+         *
+         * @param clickEvent The click event containing element metadata.
+         */
+        public void trackClick(@NonNull ClickEvent clickEvent) {
+            trackClick(clickEvent, null);
+        }
+
+        /**
+         * Track a click event from a ClickEvent object with additional properties.
+         *
+         * @param clickEvent The click event containing element metadata.
+         * @param properties Additional properties to include with this event. Pass null if none.
+         */
+        public void trackClick(@NonNull ClickEvent clickEvent,
+                               @Nullable JSONObject properties) {
+            if (clickEvent == null) {
+                MPLog.w(LOGTAG, "trackClick called with null clickEvent, ignoring event");
+                return;
+            }
+            JSONObject clickProperties = clickEvent.toProperties();
+            mergeProperties(clickProperties, properties);
+            trackAutocaptureEvent("$mp_click", clickProperties);
+        }
+
+        // ==================== Rage Click Tracking ====================
+
+        /**
+         * Track a rage click event from a ClickEvent object. Use this for full control over
+         * click metadata when your app handles its own rage click detection.
+         *
+         * @param clickEvent The click event containing element metadata.
+         */
+        public void trackRageClick(@NonNull ClickEvent clickEvent) {
+            trackRageClick(clickEvent, null);
+        }
+
+        /**
+         * Track a rage click event from a ClickEvent object with additional properties.
+         *
+         * @param clickEvent The click event containing element metadata.
+         * @param properties Additional properties to include with this event. Pass null if none.
+         */
+        public void trackRageClick(@NonNull ClickEvent clickEvent,
+                                   @Nullable JSONObject properties) {
+            if (clickEvent == null) {
+                MPLog.w(LOGTAG, "trackRageClick called with null clickEvent, ignoring event");
+                return;
+            }
+            JSONObject clickProperties = clickEvent.toProperties();
+            mergeProperties(clickProperties, properties);
+            trackAutocaptureEvent("$mp_rage_click", clickProperties);
+        }
+
+        // ==================== Dead Click Tracking ====================
+
+        /**
+         * Track a dead click event from a ClickEvent object. Use this for full control over
+         * click metadata when your app handles its own dead click detection.
+         *
+         * @param clickEvent The click event containing element metadata.
+         */
+        public void trackDeadClick(@NonNull ClickEvent clickEvent) {
+            trackDeadClick(clickEvent, null);
+        }
+
+        /**
+         * Track a dead click event from a ClickEvent object with additional properties.
+         *
+         * @param clickEvent The click event containing element metadata.
+         * @param properties Additional properties to include with this event. Pass null if none.
+         */
+        public void trackDeadClick(@NonNull ClickEvent clickEvent,
+                                   @Nullable JSONObject properties) {
+            if (clickEvent == null) {
+                MPLog.w(LOGTAG, "trackDeadClick called with null clickEvent, ignoring event");
+                return;
+            }
+            JSONObject clickProperties = clickEvent.toProperties();
+            mergeProperties(clickProperties, properties);
+            trackAutocaptureEvent("$mp_dead_click", clickProperties);
+        }
+
+        // ==================== Private Helpers ====================
+
+        /**
+         * Copies all key-value pairs from source into target.
+         * If source is null, this is a no-op.
+         */
+        private void mergeProperties(@NonNull JSONObject target,
+                                     @Nullable JSONObject source) {
+            if (source != null) {
+                try {
+                    Iterator<String> keys = source.keys();
+                    while (keys.hasNext()) {
+                        String key = keys.next();
+                        target.put(key, source.get(key));
+                    }
+                } catch (JSONException e) {
+                    // Should not happen with get/put of existing keys
+                }
+            }
+        }
+
+        /**
+         * Adds the $mp_autocapture flag and tracks the event.
+         * All autocapture events (screen view, screen leave, click, rage click, dead click)
+         * are routed through this method.
+         */
+        private void trackAutocaptureEvent(@NonNull String eventName,
+                                           @NonNull JSONObject properties) {
+            try {
+                properties.put("$mp_autocapture", true);
+            } catch (JSONException e) {
+                MPLog.e(LOGTAG, "Exception setting autocapture flag for " + eventName, e);
+            }
+            track(eventName, properties);
+        }
+    }
+
     /**
      * Based on the application's event lifecycle this method will determine whether the app is
      * running in the foreground or not.
@@ -3137,6 +3307,8 @@ RemoteService getHttpService() {
     private final FeatureFlagOptions mFeatureFlagOptions;
     private final Set<String> mExcludeProperties;
     private FeatureFlagManager mFeatureFlagManager;
+    private AutocaptureManager mAutocaptureManager;
+    private AutocaptureOptions mAutocaptureOptions;
     private RemoteService mHttpService;
     // Flag to track if app has entered foreground
     private final AtomicBoolean mHasAppForegrounded = new AtomicBoolean(false);
diff --git a/analytics/src/main/java/com/mixpanel/android/mpmetrics/MixpanelOptions.java b/analytics/src/main/java/com/mixpanel/android/mpmetrics/MixpanelOptions.java
index 04d1759a2..a1cc28108 100644
--- a/analytics/src/main/java/com/mixpanel/android/mpmetrics/MixpanelOptions.java
+++ b/analytics/src/main/java/com/mixpanel/android/mpmetrics/MixpanelOptions.java
@@ -31,6 +31,7 @@ public class MixpanelOptions {
     private final boolean optOutTrackingDefault;
     private final JSONObject superProperties;
     private final FeatureFlagOptions mFeatureFlagOptions;
+    private final AutocaptureOptions mAutocaptureOptions;
     private final DeviceIdProvider deviceIdProvider;
     private final String serverURL;
     private final ProxyServerInteractor proxyServerInteractor;
@@ -44,6 +45,7 @@ private MixpanelOptions(Builder builder) {
         this.serverURL = builder.serverURL;
         this.proxyServerInteractor = builder.proxyServerInteractor;
         this.mFeatureFlagOptions = builder.mFeatureFlagOptions;
+        this.mAutocaptureOptions = builder.mAutocaptureOptions;
         this.excludeProperties = builder.excludeProperties;
     }
 
@@ -84,6 +86,21 @@ public FeatureFlagOptions getFeatureFlagOptions() {
         return mFeatureFlagOptions;
     }
 
+    /**
+     * Returns the autocapture options for this Mixpanel instance, or null if autocapture
+     * is not enabled.
+     *
+     * <p>Autocapture is disabled by default. It is only enabled when the caller
+     * explicitly passes an {@link AutocaptureOptions} instance via
+     * {@link Builder#autocaptureOptions(AutocaptureOptions)}.
+     *
+     * @return The {@link AutocaptureOptions} configuration, or null if not enabled.
+     */
+    @Nullable
+    public AutocaptureOptions getAutocaptureOptions() {
+        return mAutocaptureOptions;
+    }
+
     /**
      * Returns the custom device ID provider, or null if not set.
      *
@@ -129,6 +146,9 @@ public static class Builder {
         private boolean optOutTrackingDefault = false;
         private JSONObject superProperties;
         private FeatureFlagOptions mFeatureFlagOptions = new FeatureFlagOptions.Builder().build();
+        // Autocapture is disabled by default — null means disabled.
+        // Users opt in by passing an AutocaptureOptions instance.
+        private AutocaptureOptions mAutocaptureOptions = null;
         private DeviceIdProvider deviceIdProvider = null;
         private String serverURL;
         private ProxyServerInteractor proxyServerInteractor;
@@ -226,6 +246,41 @@ public Builder featureFlagOptions(FeatureFlagOptions featureFlagOptions) {
             return this;
         }
 
+        /**
+         * Sets the autocapture options for this Mixpanel instance.
+         *
+         * <p>Autocapture is disabled by default. Passing an {@link AutocaptureOptions} instance
+         * enables autocapture with the specified configuration. When enabled, the SDK automatically
+         * tracks user interactions (clicks, rage clicks, dead clicks) without manual instrumentation.
+         *
+         * <pre>{@code
+         * // Enable all autocapture with defaults
+         * .autocaptureOptions(new AutocaptureOptions.Builder().build())
+         *
+         * // Enable with custom configuration
+         * .autocaptureOptions(new AutocaptureOptions.Builder()
+         *     .rageClickOptions(new RageClickOptions.Builder()
+         *         .clickThreshold(5)
+         *         .build())
+         *     .deadClickOptions(new DeadClickOptions.Builder()
+         *         .enabled(false)
+         *         .build())
+         *     .build())
+         * }</pre>
+         *
+         * @param autocaptureOptions The AutocaptureOptions configuration.
+         * @return This Builder instance for chaining.
+         * @see AutocaptureOptions
+         */
+        public Builder autocaptureOptions(@NonNull AutocaptureOptions autocaptureOptions) {
+            if (autocaptureOptions == null) {
+                MPLog.w(LOGTAG, "autocaptureOptions must not be null, ignoring");
+                return this;
+            }
+            this.mAutocaptureOptions = autocaptureOptions;
+            return this;
+        }
+
         /**
          * Sets a custom device ID provider.
          *
diff --git a/analytics/src/main/java/com/mixpanel/android/mpmetrics/RageClickOptions.java b/analytics/src/main/java/com/mixpanel/android/mpmetrics/RageClickOptions.java
new file mode 100644
index 000000000..956c48421
--- /dev/null
+++ b/analytics/src/main/java/com/mixpanel/android/mpmetrics/RageClickOptions.java
@@ -0,0 +1,162 @@
+package com.mixpanel.android.mpmetrics;
+
+/**
+ * Configuration options for rage click detection in autocapture.
+ *
+ * <p>Rage clicks are detected when a user rapidly clicks multiple times in the same area,
+ * indicating frustration with an unresponsive UI element.
+ *
+ * <pre>{@code
+ * RageClickOptions rageClickOptions = new RageClickOptions.Builder()
+ *     .enabled(true)
+ *     .clickThreshold(5)      // Require 5 clicks instead of default 4
+ *     .timeWindowMs(800)      // Shorter time window
+ *     .radius(50f)            // Larger click radius
+ *     .build();
+ * }</pre>
+ *
+ * @see AutocaptureOptions.Builder#rageClickOptions(RageClickOptions)
+ */
+public class RageClickOptions {
+
+    private final boolean mEnabled;
+    private final int mClickThreshold;
+    private final long mTimeWindowMs;
+    private final float mRadius;
+
+    private RageClickOptions(Builder builder) {
+        this.mEnabled = builder.mEnabled;
+        this.mClickThreshold = builder.mClickThreshold;
+        this.mTimeWindowMs = builder.mTimeWindowMs;
+        this.mRadius = builder.mRadius;
+    }
+
+    /**
+     * Returns whether rage click detection is enabled.
+     *
+     * @return {@code true} if rage clicks are tracked, {@code false} otherwise.
+     *         Defaults to {@code true} when autocapture is enabled.
+     */
+    public boolean isEnabled() {
+        return mEnabled;
+    }
+
+    /**
+     * Returns the number of clicks required to trigger a rage click event.
+     *
+     * @return The click threshold. Defaults to 4.
+     */
+    public int getClickThreshold() {
+        return mClickThreshold;
+    }
+
+    /**
+     * Returns the time window in milliseconds within which clicks must occur
+     * to be considered a rage click.
+     *
+     * @return The time window in milliseconds. Defaults to 1000.
+     */
+    public long getTimeWindowMs() {
+        return mTimeWindowMs;
+    }
+
+    /**
+     * Returns the spatial threshold for rage click detection.
+     *
+     * <p>Clicks within this radius (in dp) are considered to be in the "same location".
+     *
+     * @return The radius in density-independent pixels (dp). Defaults to 44.
+     */
+    public float getRadius() {
+        return mRadius;
+    }
+
+    /**
+     * Builder for creating {@link RageClickOptions} instances.
+     *
+     * <p>Default values:
+     * <ul>
+     *   <li>{@code enabled} = {@code true}</li>
+     *   <li>{@code clickThreshold} = 4</li>
+     *   <li>{@code timeWindowMs} = 1000</li>
+     *   <li>{@code radius} = 44 (dp)</li>
+     * </ul>
+     */
+    public static class Builder {
+        private boolean mEnabled = true;
+        private int mClickThreshold = 4;
+        private long mTimeWindowMs = 1000;
+        private float mRadius = 44f;
+
+        public Builder() {
+        }
+
+        /**
+         * Creates a Builder pre-populated with values from an existing {@link RageClickOptions}.
+         *
+         * @param source The RageClickOptions to copy values from.
+         */
+        public Builder(RageClickOptions source) {
+            this.mEnabled = source.mEnabled;
+            this.mClickThreshold = source.mClickThreshold;
+            this.mTimeWindowMs = source.mTimeWindowMs;
+            this.mRadius = source.mRadius;
+        }
+
+        /**
+         * Enables or disables rage click detection.
+         *
+         * @param enabled {@code true} to detect rage clicks, {@code false} to disable.
+         * @return This Builder instance for chaining.
+         */
+        public Builder enabled(boolean enabled) {
+            this.mEnabled = enabled;
+            return this;
+        }
+
+        /**
+         * Sets the number of clicks required to trigger a rage click event.
+         *
+         * @param clickThreshold The number of clicks required. Must be at least 2.
+         * @return This Builder instance for chaining.
+         */
+        public Builder clickThreshold(int clickThreshold) {
+            this.mClickThreshold = Math.max(2, clickThreshold);
+            return this;
+        }
+
+        /**
+         * Sets the time window in milliseconds within which clicks must occur.
+         *
+         * @param timeWindowMs The time window in milliseconds. Must be positive.
+         * @return This Builder instance for chaining.
+         */
+        public Builder timeWindowMs(long timeWindowMs) {
+            this.mTimeWindowMs = Math.max(1, timeWindowMs);
+            return this;
+        }
+
+        /**
+         * Sets the spatial threshold for rage click detection.
+         *
+         * <p>Clicks within this radius are considered to be in the "same location".
+         * Unit: dp (density-independent pixels) on Android.
+         *
+         * @param radius The radius in dp within which clicks are considered "same location".
+         * @return This Builder instance for chaining.
+         */
+        public Builder radius(float radius) {
+            this.mRadius = Math.max(0, radius);
+            return this;
+        }
+
+        /**
+         * Builds and returns a {@link RageClickOptions} instance with the configured settings.
+         *
+         * @return A new {@link RageClickOptions} instance.
+         */
+        public RageClickOptions build() {
+            return new RageClickOptions(this);
+        }
+    }
+}