@scalebun/react-native 1.0.1 → 1.0.2

package/android/src/main/java/com/scalebun/replaysdk/tracking/InteractionTracker.kt

@@ -1,419 +1,419 @@
-package com.scalebun.replaysdk.tracking
-
-import android.app.Activity
-import android.os.Handler
-import android.os.Looper
-import android.view.MotionEvent
-import android.view.View
-import android.view.Window
-import android.view.WindowManager
-import java.lang.ref.WeakReference
-import java.util.WeakHashMap
-import com.facebook.react.bridge.Arguments
-import com.facebook.react.bridge.ReactApplicationContext
-import com.facebook.react.modules.core.DeviceEventManagerModule
-import com.scalebun.replaysdk.core.ReplayLogger
-
-/**
- * Native interaction tracker.
- *
- * Intercepts MotionEvents at the Window.Callback level (highest safe intercept point).
- * Captures touch start/end in the SAME coordinate space as FrameCaptureManager screenshots
- * (android.R.id.content view), so normalizedX/Y map exactly to screenshot pixels.
- *
- * Emits ScaleBunNativeInteraction events to JS with confidence:"high".
- */
-class InteractionTracker(private val reactContext: ReactApplicationContext) {
-
-    private var nativeInterceptor: NativeTouchInterceptor? = null
-    private var attachedWindow: android.view.Window? = null
-    private var dialogObserver: DialogTouchObserver? = null
-    var isNativeActive = false
-        private set
-
-    private var touchDownX = 0f
-    private var touchDownY = 0f
-    private var touchDownTs = 0L
-    private var lastEmitTs = 0L
-    private val THROTTLE_MS = 150L
-    private val mainHandler = Handler(Looper.getMainLooper())
-
-    fun attach(activity: Activity) {
-        if (isNativeActive) return
-        mainHandler.post {
-            try {
-                val window = activity.window ?: return@post
-                val original = window.callback ?: return@post
-
-                // CRITICAL: We do NOT cache contentView at attach time.
-                // R.id.content may be zero-sized during attach (pre-layout). Caching the
-                // decorView fallback at attach used to silently keep normalizing against
-                // decorView dims while FrameCaptureManager captured the smaller content
-                // view — producing markers offset toward the top by ~status-bar fraction.
-                // We resolve the capture view fresh per touch, identically to
-                // FrameCaptureManager.capture(), so denominators always match the screenshot.
-                val interceptor = NativeTouchInterceptor(
-                    original = original,
-                    onDown = { rawX, rawY, ts ->
-                        touchDownX = rawX
-                        touchDownY = rawY
-                        touchDownTs = ts
-                    },
-                    onUp = { rawX, rawY, ts ->
-                        handleTouchUp(rawX, rawY, ts, resolveCaptureView(window))
-                    }
-                )
-                window.callback = interceptor
-                nativeInterceptor = interceptor
-                attachedWindow = window
-                isNativeActive = true
-                ReplayLogger.info("Native touch tracking attached (per-touch view resolution)")
-
-                // Also observe extra dialog windows (Alert.alert → native AlertDialog
-                // lives in a separate Window not covered by the activity-window callback).
-                // Dialog taps reuse the SAME onDown/onUp → handleTouchUp path so they
-                // normalize against the main activity's R.id.content, identical to the
-                // screenshot compositing base.
-                dialogObserver = DialogTouchObserver(
-                    mainHandler = mainHandler,
-                    getMainRootView = { attachedWindow?.decorView?.rootView },
-                    onDown = { rawX, rawY, ts ->
-                        touchDownX = rawX
-                        touchDownY = rawY
-                        touchDownTs = ts
-                    },
-                    onUp = { rawX, rawY, ts ->
-                        val main = attachedWindow ?: return@DialogTouchObserver
-                        handleTouchUp(rawX, rawY, ts, resolveCaptureView(main), onDialogWindow = true)
-                    }
-                ).also { it.start() }
-            } catch (e: Exception) {
-                ReplayLogger.error("Failed to attach native touch tracker: ${e.message}")
-            }
-        }
-    }
-
-    /**
-     * Resolve the capture view fresh — matches FrameCaptureManager.capture() exactly.
-     * Returns R.id.content ONLY. Never falls back to decorView — decorView includes
-     * status bar / navigation bar area, so normalizing against it produces a larger
-     * denominator than the PixelCopy screenshot, shifting markers upward by the
-     * status-bar fraction. Returns null if R.id.content is unusable, causing the
-     * event to be dropped rather than emitted with wrong coordinates.
-     */
-    private fun resolveCaptureView(window: android.view.Window): View? {
-        return try {
-            val decorView = window.decorView ?: return null
-            decorView.rootView
-                ?.findViewById<View>(android.R.id.content)
-                ?.takeIf { it.width > 0 && it.height > 0 }
-        } catch (e: Exception) {
-            null
-        }
-    }
-
-    fun detach(activity: Activity) {
-        val interceptor = nativeInterceptor ?: return
-        try {
-            dialogObserver?.stop()
-            dialogObserver = null
-            activity.window?.callback = interceptor.original
-            nativeInterceptor = null
-            attachedWindow = null
-            isNativeActive = false
-            ReplayLogger.info("Native touch tracking detached")
-        } catch (e: Exception) {
-            ReplayLogger.error("Failed to detach native touch tracker: ${e.message}")
-        }
-    }
-
-    private fun handleTouchUp(rawX: Float, rawY: Float, ts: Long, captureView: View?, onDialogWindow: Boolean = false) {
-        if (captureView == null) {
-            ReplayLogger.debug("Native touch up dropped: no usable capture view")
-            return
-        }
-        val now = System.currentTimeMillis()
-        if (now - lastEmitTs < THROTTLE_MS) return
-        lastEmitTs = now
-
-        val durationMs = ts - touchDownTs
-        val dx = rawX - touchDownX
-        val dy = rawY - touchDownY
-        val dist = Math.sqrt((dx * dx + dy * dy).toDouble())
-
-        val gestureType = when {
-            dist > 40.0 -> if (Math.abs(dy) > Math.abs(dx)) "scroll" else "swipe"
-            durationMs > 500L -> "long_press"
-            else -> "tap"
-        }
-
-        val viewW = captureView.width.toFloat()
-        val viewH = captureView.height.toFloat()
-        if (viewW <= 0 || viewH <= 0) return
-
-        // Convert raw screen coordinates to captureView-local coordinates.
-        // Use getLocationInWindow() — the SAME coordinate system FrameCaptureManager
-        // uses for the PixelCopy srcRect. This eliminates any mismatch between
-        // screen-space and window-space that can occur on devices with non-zero
-        // window origin (edge-to-edge, multi-window, display cutout modes).
-        //
-        // To convert screen-space rawX/rawY to window-space, we subtract the
-        // window's own screen position first, then subtract the view's window
-        // position — equivalent to getLocationOnScreen but using the same
-        // coordinate system as PixelCopy.
-        val windowLoc = IntArray(2)
-        val screenLoc = IntArray(2)
-        try {
-            captureView.getLocationInWindow(windowLoc)
-            captureView.getLocationOnScreen(screenLoc)
-        } catch (e: Exception) {
-            ReplayLogger.error("getLocation failed: ${e.message}")
-            return
-        }
-        // Window's screen offset = screenLoc - windowLoc
-        val windowOffsetX = screenLoc[0] - windowLoc[0]
-        val windowOffsetY = screenLoc[1] - windowLoc[1]
-        // Convert rawX/rawY (screen-space) → window-space → view-local
-        val viewLeft = windowLoc[0].toFloat()
-        val viewTop = windowLoc[1].toFloat()
-
-        val localDownX = (touchDownX - windowOffsetX) - viewLeft
-        val localDownY = (touchDownY - windowOffsetY) - viewTop
-        val localUpX = (rawX - windowOffsetX) - viewLeft
-        val localUpY = (rawY - windowOffsetY) - viewTop
-
-        val normalizedX = (localDownX / viewW).coerceIn(0f, 1f)
-        val normalizedY = (localDownY / viewH).coerceIn(0f, 1f)
-        val normalizedEndX = (localUpX / viewW).coerceIn(0f, 1f)
-        val normalizedEndY = (localUpY / viewH).coerceIn(0f, 1f)
-
-        emitNativeInteraction(
-            gestureType = gestureType,
-            rawX = localDownX,
-            rawY = localDownY,
-            normalizedX = normalizedX,
-            normalizedY = normalizedY,
-            normalizedEndX = normalizedEndX,
-            normalizedEndY = normalizedEndY,
-            screenshotW = viewW,
-            screenshotH = viewH,
-            durationMs = durationMs,
-            onDialogWindow = onDialogWindow
-        )
-    }
-
-    private fun emitNativeInteraction(
-        gestureType: String,
-        rawX: Float, rawY: Float,
-        normalizedX: Float, normalizedY: Float,
-        normalizedEndX: Float, normalizedEndY: Float,
-        screenshotW: Float, screenshotH: Float,
-        durationMs: Long,
-        onDialogWindow: Boolean = false
-    ) {
-        try {
-            val params = Arguments.createMap().apply {
-                putString("gestureType", gestureType)
-                putDouble("rawX", rawX.toDouble())
-                putDouble("rawY", rawY.toDouble())
-                putDouble("normalizedX", normalizedX.toDouble())
-                putDouble("normalizedY", normalizedY.toDouble())
-                putDouble("normalizedEndX", normalizedEndX.toDouble())
-                putDouble("normalizedEndY", normalizedEndY.toDouble())
-                putDouble("screenshotWidthPx", screenshotW.toDouble())
-                putDouble("screenshotHeightPx", screenshotH.toDouble())
-                putString("coordinateSpace", "android-content-view-px")
-                putDouble("timestamp", System.currentTimeMillis().toDouble())
-                putString("confidence", "high")
-                putString("source", "native-interaction-tracker")
-                putDouble("durationMs", durationMs.toDouble())
-                putString("platform", "android")
-                putBoolean("onDialogWindow", onDialogWindow)
-            }
-            reactContext.getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter::class.java)
-                .emit("ScaleBunNativeInteraction", params)
-            ReplayLogger.debug(
-                "[TapAccuracy] platform=android type=$gestureType " +
-                "rawLocalPx=($rawX,$rawY) normalized=($normalizedX,$normalizedY) " +
-                "captureViewPx=(${screenshotW}x${screenshotH}) space=android-content-view-px"
-            )
-        } catch (e: Exception) {
-            ReplayLogger.error("Native interaction emit failed: ${e.message}")
-        }
-    }
-
-    // ── JS-reported fallback (backward compat when native tracker unavailable) ──
-
-    private var lastInteractionMs: Long = 0
-    private val debounceMs: Long = 300
-
-    fun reportInteraction(type: String, x: Int, y: Int, timestamp: Long): Boolean {
-        if (isNativeActive) return false
-        val now = System.currentTimeMillis()
-        if (now - lastInteractionMs < debounceMs) return false
-        lastInteractionMs = now
-        ReplayLogger.debug("JS interaction: $type at ($x, $y)")
-        return true
-    }
-
-    fun reset() {
-        lastInteractionMs = 0
-        lastEmitTs = 0
-        touchDownTs = 0
-    }
-}
-
-/**
- * Window.Callback delegate that intercepts touch events without consuming them.
- * Only observes ACTION_DOWN and ACTION_UP — all other events pass through unchanged.
- */
-class NativeTouchInterceptor(
-    val original: Window.Callback,
-    private val onDown: (rawX: Float, rawY: Float, ts: Long) -> Unit,
-    private val onUp: (rawX: Float, rawY: Float, ts: Long) -> Unit
-) : Window.Callback by original {
-
-    override fun dispatchTouchEvent(event: MotionEvent?): Boolean {
-        event?.let { e ->
-            when (e.actionMasked) {
-                MotionEvent.ACTION_DOWN -> onDown(e.rawX, e.rawY, e.eventTime)
-                MotionEvent.ACTION_UP -> onUp(e.rawX, e.rawY, e.eventTime)
-            }
-        }
-        return original.dispatchTouchEvent(event)
-    }
-}
-
-/**
- * Observes touches on extra dialog windows (e.g. RN Alert.alert → native AlertDialog),
- * which live in their own Window and are NOT covered by the activity-window callback.
- *
- * Discovery mirrors FrameCaptureManager.compositeExtraWindows EXACTLY: reflect on
- * android.view.WindowManagerGlobal.mViews and apply the same filtering (skip the main
- * activity root, non-visible / detached / zero-size, and FLAG_SECURE windows). This keeps
- * the set of observed windows identical to the set composited into the screenshot.
- *
- * Each qualifying dialog window has its Window.callback wrapped with a non-consuming
- * NativeTouchInterceptor (returns the original dispatchTouchEvent result, never swallows
- * the touch). Coordinates use MotionEvent.rawX/rawY (screen-space), so the shared onUp
- * handler can normalize them against the MAIN activity's R.id.content — the same base the
- * screenshot uses — without any per-window math.
- *
- * All reflection is wrapped in try/catch and silently no-ops on failure. Dialogs that
- * appear after tracking starts are caught by a periodic rescan posted on the main handler
- * (not a busy loop). Hooked windows are tracked weakly to avoid leaking dismissed dialogs.
- */
-class DialogTouchObserver(
-    private val mainHandler: Handler,
-    private val getMainRootView: () -> View?,
-    private val onDown: (rawX: Float, rawY: Float, ts: Long) -> Unit,
-    private val onUp: (rawX: Float, rawY: Float, ts: Long) -> Unit
-) {
-    private val hookedWindows = WeakHashMap<Window, WeakReference<NativeTouchInterceptor>>()
-    private var rescanRunnable: Runnable? = null
-    private val RESCAN_MS = 400L
-
-    fun start() {
-        stop()
-        val runnable = object : Runnable {
-            override fun run() {
-                rescan()
-                mainHandler.postDelayed(this, RESCAN_MS)
-            }
-        }
-        rescanRunnable = runnable
-        mainHandler.postDelayed(runnable, RESCAN_MS)
-    }
-
-    fun stop() {
-        rescanRunnable?.let { mainHandler.removeCallbacks(it) }
-        rescanRunnable = null
-        unhookAll()
-    }
-
-    private fun rescan() {
-        try {
-            val mainRoot = getMainRootView()
-            val wmgClass = Class.forName("android.view.WindowManagerGlobal")
-            val wmgInstance = wmgClass.getMethod("getInstance").invoke(null)
-            val viewsField = wmgClass.getDeclaredField("mViews")
-            viewsField.isAccessible = true
-
-            @Suppress("UNCHECKED_CAST")
-            val views = viewsField.get(wmgInstance) as? java.util.ArrayList<View> ?: return
-
-            // Snapshot copy — mViews can mutate while we iterate (dialogs added/removed).
-            for (view in ArrayList(views)) {
-                if (view === mainRoot) continue
-                if (view.visibility != View.VISIBLE || view.windowToken == null ||
-                    view.width <= 0 || view.height <= 0
-                ) continue
-
-                val lp = view.layoutParams as? WindowManager.LayoutParams
-                if (lp != null && (lp.flags and WindowManager.LayoutParams.FLAG_SECURE) != 0) {
-                    continue
-                }
-
-                val window = resolveWindow(view) ?: continue
-                if (hookedWindows.containsKey(window)) continue
-                hookWindow(window)
-            }
-        } catch (e: Exception) {
-            ReplayLogger.debug("Dialog window rescan failed: ${e.message}")
-        }
-    }
-
-    private fun hookWindow(window: Window) {
-        try {
-            val original = window.callback ?: return
-            // Never double-wrap our own interceptor.
-            if (original is NativeTouchInterceptor) {
-                hookedWindows[window] = WeakReference(original)
-                return
-            }
-            val interceptor = NativeTouchInterceptor(original, onDown, onUp)
-            window.callback = interceptor
-            hookedWindows[window] = WeakReference(interceptor)
-            ReplayLogger.debug("Hooked dialog window touch callback")
-        } catch (e: Exception) {
-            ReplayLogger.debug("Hook dialog window failed: ${e.message}")
-        }
-    }
-
-    private fun unhookAll() {
-        try {
-            for ((window, ref) in hookedWindows) {
-                try {
-                    val interceptor = ref.get() ?: continue
-                    if (window.callback === interceptor) {
-                        window.callback = interceptor.original
-                    }
-                } catch (_: Exception) { /* window may already be torn down */ }
-            }
-        } catch (_: Exception) { /* no-throw */ }
-        hookedWindows.clear()
-    }
-
-    /**
-     * Resolve the Window backing a top-level (decor) view via reflection.
-     * DecorView holds its PhoneWindow in a field of type android.view.Window.
-     * Returns null (causing the window to be skipped) if not reachable.
-     */
-    private fun resolveWindow(decorView: View): Window? {
-        var clazz: Class<*>? = decorView.javaClass
-        while (clazz != null) {
-            for (f in clazz.declaredFields) {
-                if (Window::class.java.isAssignableFrom(f.type)) {
-                    return try {
-                        f.isAccessible = true
-                        f.get(decorView) as? Window
-                    } catch (_: Exception) {
-                        null
-                    }
-                }
-            }
-            clazz = clazz.superclass
-        }
-        return null
-    }
-}
+package com.scalebun.replaysdk.tracking
+
+import android.app.Activity
+import android.os.Handler
+import android.os.Looper
+import android.view.MotionEvent
+import android.view.View
+import android.view.Window
+import android.view.WindowManager
+import java.lang.ref.WeakReference
+import java.util.WeakHashMap
+import com.facebook.react.bridge.Arguments
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.modules.core.DeviceEventManagerModule
+import com.scalebun.replaysdk.core.ReplayLogger
+
+/**
+ * Native interaction tracker.
+ *
+ * Intercepts MotionEvents at the Window.Callback level (highest safe intercept point).
+ * Captures touch start/end in the SAME coordinate space as FrameCaptureManager screenshots
+ * (android.R.id.content view), so normalizedX/Y map exactly to screenshot pixels.
+ *
+ * Emits ScaleBunNativeInteraction events to JS with confidence:"high".
+ */
+class InteractionTracker(private val reactContext: ReactApplicationContext) {
+
+    private var nativeInterceptor: NativeTouchInterceptor? = null
+    private var attachedWindow: android.view.Window? = null
+    private var dialogObserver: DialogTouchObserver? = null
+    var isNativeActive = false
+        private set
+
+    private var touchDownX = 0f
+    private var touchDownY = 0f
+    private var touchDownTs = 0L
+    private var lastEmitTs = 0L
+    private val THROTTLE_MS = 150L
+    private val mainHandler = Handler(Looper.getMainLooper())
+
+    fun attach(activity: Activity) {
+        if (isNativeActive) return
+        mainHandler.post {
+            try {
+                val window = activity.window ?: return@post
+                val original = window.callback ?: return@post
+
+                // CRITICAL: We do NOT cache contentView at attach time.
+                // R.id.content may be zero-sized during attach (pre-layout). Caching the
+                // decorView fallback at attach used to silently keep normalizing against
+                // decorView dims while FrameCaptureManager captured the smaller content
+                // view — producing markers offset toward the top by ~status-bar fraction.
+                // We resolve the capture view fresh per touch, identically to
+                // FrameCaptureManager.capture(), so denominators always match the screenshot.
+                val interceptor = NativeTouchInterceptor(
+                    original = original,
+                    onDown = { rawX, rawY, ts ->
+                        touchDownX = rawX
+                        touchDownY = rawY
+                        touchDownTs = ts
+                    },
+                    onUp = { rawX, rawY, ts ->
+                        handleTouchUp(rawX, rawY, ts, resolveCaptureView(window))
+                    }
+                )
+                window.callback = interceptor
+                nativeInterceptor = interceptor
+                attachedWindow = window
+                isNativeActive = true
+                ReplayLogger.info("Native touch tracking attached (per-touch view resolution)")
+
+                // Also observe extra dialog windows (Alert.alert → native AlertDialog
+                // lives in a separate Window not covered by the activity-window callback).
+                // Dialog taps reuse the SAME onDown/onUp → handleTouchUp path so they
+                // normalize against the main activity's R.id.content, identical to the
+                // screenshot compositing base.
+                dialogObserver = DialogTouchObserver(
+                    mainHandler = mainHandler,
+                    getMainRootView = { attachedWindow?.decorView?.rootView },
+                    onDown = { rawX, rawY, ts ->
+                        touchDownX = rawX
+                        touchDownY = rawY
+                        touchDownTs = ts
+                    },
+                    onUp = { rawX, rawY, ts ->
+                        val main = attachedWindow ?: return@DialogTouchObserver
+                        handleTouchUp(rawX, rawY, ts, resolveCaptureView(main), onDialogWindow = true)
+                    }
+                ).also { it.start() }
+            } catch (e: Exception) {
+                ReplayLogger.error("Failed to attach native touch tracker: ${e.message}")
+            }
+        }
+    }
+
+    /**
+     * Resolve the capture view fresh — matches FrameCaptureManager.capture() exactly.
+     * Returns R.id.content ONLY. Never falls back to decorView — decorView includes
+     * status bar / navigation bar area, so normalizing against it produces a larger
+     * denominator than the PixelCopy screenshot, shifting markers upward by the
+     * status-bar fraction. Returns null if R.id.content is unusable, causing the
+     * event to be dropped rather than emitted with wrong coordinates.
+     */
+    private fun resolveCaptureView(window: android.view.Window): View? {
+        return try {
+            val decorView = window.decorView ?: return null
+            decorView.rootView
+                ?.findViewById<View>(android.R.id.content)
+                ?.takeIf { it.width > 0 && it.height > 0 }
+        } catch (e: Exception) {
+            null
+        }
+    }
+
+    fun detach(activity: Activity) {
+        val interceptor = nativeInterceptor ?: return
+        try {
+            dialogObserver?.stop()
+            dialogObserver = null
+            activity.window?.callback = interceptor.original
+            nativeInterceptor = null
+            attachedWindow = null
+            isNativeActive = false
+            ReplayLogger.info("Native touch tracking detached")
+        } catch (e: Exception) {
+            ReplayLogger.error("Failed to detach native touch tracker: ${e.message}")
+        }
+    }
+
+    private fun handleTouchUp(rawX: Float, rawY: Float, ts: Long, captureView: View?, onDialogWindow: Boolean = false) {
+        if (captureView == null) {
+            ReplayLogger.debug("Native touch up dropped: no usable capture view")
+            return
+        }
+        val now = System.currentTimeMillis()
+        if (now - lastEmitTs < THROTTLE_MS) return
+        lastEmitTs = now
+
+        val durationMs = ts - touchDownTs
+        val dx = rawX - touchDownX
+        val dy = rawY - touchDownY
+        val dist = Math.sqrt((dx * dx + dy * dy).toDouble())
+
+        val gestureType = when {
+            dist > 40.0 -> if (Math.abs(dy) > Math.abs(dx)) "scroll" else "swipe"
+            durationMs > 500L -> "long_press"
+            else -> "tap"
+        }
+
+        val viewW = captureView.width.toFloat()
+        val viewH = captureView.height.toFloat()
+        if (viewW <= 0 || viewH <= 0) return
+
+        // Convert raw screen coordinates to captureView-local coordinates.
+        // Use getLocationInWindow() — the SAME coordinate system FrameCaptureManager
+        // uses for the PixelCopy srcRect. This eliminates any mismatch between
+        // screen-space and window-space that can occur on devices with non-zero
+        // window origin (edge-to-edge, multi-window, display cutout modes).
+        //
+        // To convert screen-space rawX/rawY to window-space, we subtract the
+        // window's own screen position first, then subtract the view's window
+        // position — equivalent to getLocationOnScreen but using the same
+        // coordinate system as PixelCopy.
+        val windowLoc = IntArray(2)
+        val screenLoc = IntArray(2)
+        try {
+            captureView.getLocationInWindow(windowLoc)
+            captureView.getLocationOnScreen(screenLoc)
+        } catch (e: Exception) {
+            ReplayLogger.error("getLocation failed: ${e.message}")
+            return
+        }
+        // Window's screen offset = screenLoc - windowLoc
+        val windowOffsetX = screenLoc[0] - windowLoc[0]
+        val windowOffsetY = screenLoc[1] - windowLoc[1]
+        // Convert rawX/rawY (screen-space) → window-space → view-local
+        val viewLeft = windowLoc[0].toFloat()
+        val viewTop = windowLoc[1].toFloat()
+
+        val localDownX = (touchDownX - windowOffsetX) - viewLeft
+        val localDownY = (touchDownY - windowOffsetY) - viewTop
+        val localUpX = (rawX - windowOffsetX) - viewLeft
+        val localUpY = (rawY - windowOffsetY) - viewTop
+
+        val normalizedX = (localDownX / viewW).coerceIn(0f, 1f)
+        val normalizedY = (localDownY / viewH).coerceIn(0f, 1f)
+        val normalizedEndX = (localUpX / viewW).coerceIn(0f, 1f)
+        val normalizedEndY = (localUpY / viewH).coerceIn(0f, 1f)
+
+        emitNativeInteraction(
+            gestureType = gestureType,
+            rawX = localDownX,
+            rawY = localDownY,
+            normalizedX = normalizedX,
+            normalizedY = normalizedY,
+            normalizedEndX = normalizedEndX,
+            normalizedEndY = normalizedEndY,
+            screenshotW = viewW,
+            screenshotH = viewH,
+            durationMs = durationMs,
+            onDialogWindow = onDialogWindow
+        )
+    }
+
+    private fun emitNativeInteraction(
+        gestureType: String,
+        rawX: Float, rawY: Float,
+        normalizedX: Float, normalizedY: Float,
+        normalizedEndX: Float, normalizedEndY: Float,
+        screenshotW: Float, screenshotH: Float,
+        durationMs: Long,
+        onDialogWindow: Boolean = false
+    ) {
+        try {
+            val params = Arguments.createMap().apply {
+                putString("gestureType", gestureType)
+                putDouble("rawX", rawX.toDouble())
+                putDouble("rawY", rawY.toDouble())
+                putDouble("normalizedX", normalizedX.toDouble())
+                putDouble("normalizedY", normalizedY.toDouble())
+                putDouble("normalizedEndX", normalizedEndX.toDouble())
+                putDouble("normalizedEndY", normalizedEndY.toDouble())
+                putDouble("screenshotWidthPx", screenshotW.toDouble())
+                putDouble("screenshotHeightPx", screenshotH.toDouble())
+                putString("coordinateSpace", "android-content-view-px")
+                putDouble("timestamp", System.currentTimeMillis().toDouble())
+                putString("confidence", "high")
+                putString("source", "native-interaction-tracker")
+                putDouble("durationMs", durationMs.toDouble())
+                putString("platform", "android")
+                putBoolean("onDialogWindow", onDialogWindow)
+            }
+            reactContext.getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter::class.java)
+                .emit("ScaleBunNativeInteraction", params)
+            ReplayLogger.debug(
+                "[TapAccuracy] platform=android type=$gestureType " +
+                "rawLocalPx=($rawX,$rawY) normalized=($normalizedX,$normalizedY) " +
+                "captureViewPx=(${screenshotW}x${screenshotH}) space=android-content-view-px"
+            )
+        } catch (e: Exception) {
+            ReplayLogger.error("Native interaction emit failed: ${e.message}")
+        }
+    }
+
+    // ── JS-reported fallback (backward compat when native tracker unavailable) ──
+
+    private var lastInteractionMs: Long = 0
+    private val debounceMs: Long = 300
+
+    fun reportInteraction(type: String, x: Int, y: Int, timestamp: Long): Boolean {
+        if (isNativeActive) return false
+        val now = System.currentTimeMillis()
+        if (now - lastInteractionMs < debounceMs) return false
+        lastInteractionMs = now
+        ReplayLogger.debug("JS interaction: $type at ($x, $y)")
+        return true
+    }
+
+    fun reset() {
+        lastInteractionMs = 0
+        lastEmitTs = 0
+        touchDownTs = 0
+    }
+}
+
+/**
+ * Window.Callback delegate that intercepts touch events without consuming them.
+ * Only observes ACTION_DOWN and ACTION_UP — all other events pass through unchanged.
+ */
+class NativeTouchInterceptor(
+    val original: Window.Callback,
+    private val onDown: (rawX: Float, rawY: Float, ts: Long) -> Unit,
+    private val onUp: (rawX: Float, rawY: Float, ts: Long) -> Unit
+) : Window.Callback by original {
+
+    override fun dispatchTouchEvent(event: MotionEvent?): Boolean {
+        event?.let { e ->
+            when (e.actionMasked) {
+                MotionEvent.ACTION_DOWN -> onDown(e.rawX, e.rawY, e.eventTime)
+                MotionEvent.ACTION_UP -> onUp(e.rawX, e.rawY, e.eventTime)
+            }
+        }
+        return original.dispatchTouchEvent(event)
+    }
+}
+
+/**
+ * Observes touches on extra dialog windows (e.g. RN Alert.alert → native AlertDialog),
+ * which live in their own Window and are NOT covered by the activity-window callback.
+ *
+ * Discovery mirrors FrameCaptureManager.compositeExtraWindows EXACTLY: reflect on
+ * android.view.WindowManagerGlobal.mViews and apply the same filtering (skip the main
+ * activity root, non-visible / detached / zero-size, and FLAG_SECURE windows). This keeps
+ * the set of observed windows identical to the set composited into the screenshot.
+ *
+ * Each qualifying dialog window has its Window.callback wrapped with a non-consuming
+ * NativeTouchInterceptor (returns the original dispatchTouchEvent result, never swallows
+ * the touch). Coordinates use MotionEvent.rawX/rawY (screen-space), so the shared onUp
+ * handler can normalize them against the MAIN activity's R.id.content — the same base the
+ * screenshot uses — without any per-window math.
+ *
+ * All reflection is wrapped in try/catch and silently no-ops on failure. Dialogs that
+ * appear after tracking starts are caught by a periodic rescan posted on the main handler
+ * (not a busy loop). Hooked windows are tracked weakly to avoid leaking dismissed dialogs.
+ */
+class DialogTouchObserver(
+    private val mainHandler: Handler,
+    private val getMainRootView: () -> View?,
+    private val onDown: (rawX: Float, rawY: Float, ts: Long) -> Unit,
+    private val onUp: (rawX: Float, rawY: Float, ts: Long) -> Unit
+) {
+    private val hookedWindows = WeakHashMap<Window, WeakReference<NativeTouchInterceptor>>()
+    private var rescanRunnable: Runnable? = null
+    private val RESCAN_MS = 400L
+
+    fun start() {
+        stop()
+        val runnable = object : Runnable {
+            override fun run() {
+                rescan()
+                mainHandler.postDelayed(this, RESCAN_MS)
+            }
+        }
+        rescanRunnable = runnable
+        mainHandler.postDelayed(runnable, RESCAN_MS)
+    }
+
+    fun stop() {
+        rescanRunnable?.let { mainHandler.removeCallbacks(it) }
+        rescanRunnable = null
+        unhookAll()
+    }
+
+    private fun rescan() {
+        try {
+            val mainRoot = getMainRootView()
+            val wmgClass = Class.forName("android.view.WindowManagerGlobal")
+            val wmgInstance = wmgClass.getMethod("getInstance").invoke(null)
+            val viewsField = wmgClass.getDeclaredField("mViews")
+            viewsField.isAccessible = true
+
+            @Suppress("UNCHECKED_CAST")
+            val views = viewsField.get(wmgInstance) as? java.util.ArrayList<View> ?: return
+
+            // Snapshot copy — mViews can mutate while we iterate (dialogs added/removed).
+            for (view in ArrayList(views)) {
+                if (view === mainRoot) continue
+                if (view.visibility != View.VISIBLE || view.windowToken == null ||
+                    view.width <= 0 || view.height <= 0
+                ) continue
+
+                val lp = view.layoutParams as? WindowManager.LayoutParams
+                if (lp != null && (lp.flags and WindowManager.LayoutParams.FLAG_SECURE) != 0) {
+                    continue
+                }
+
+                val window = resolveWindow(view) ?: continue
+                if (hookedWindows.containsKey(window)) continue
+                hookWindow(window)
+            }
+        } catch (e: Exception) {
+            ReplayLogger.debug("Dialog window rescan failed: ${e.message}")
+        }
+    }
+
+    private fun hookWindow(window: Window) {
+        try {
+            val original = window.callback ?: return
+            // Never double-wrap our own interceptor.
+            if (original is NativeTouchInterceptor) {
+                hookedWindows[window] = WeakReference(original)
+                return
+            }
+            val interceptor = NativeTouchInterceptor(original, onDown, onUp)
+            window.callback = interceptor
+            hookedWindows[window] = WeakReference(interceptor)
+            ReplayLogger.debug("Hooked dialog window touch callback")
+        } catch (e: Exception) {
+            ReplayLogger.debug("Hook dialog window failed: ${e.message}")
+        }
+    }
+
+    private fun unhookAll() {
+        try {
+            for ((window, ref) in hookedWindows) {
+                try {
+                    val interceptor = ref.get() ?: continue
+                    if (window.callback === interceptor) {
+                        window.callback = interceptor.original
+                    }
+                } catch (_: Exception) { /* window may already be torn down */ }
+            }
+        } catch (_: Exception) { /* no-throw */ }
+        hookedWindows.clear()
+    }
+
+    /**
+     * Resolve the Window backing a top-level (decor) view via reflection.
+     * DecorView holds its PhoneWindow in a field of type android.view.Window.
+     * Returns null (causing the window to be skipped) if not reachable.
+     */
+    private fun resolveWindow(decorView: View): Window? {
+        var clazz: Class<*>? = decorView.javaClass
+        while (clazz != null) {
+            for (f in clazz.declaredFields) {
+                if (Window::class.java.isAssignableFrom(f.type)) {
+                    return try {
+                        f.isAccessible = true
+                        f.get(decorView) as? Window
+                    } catch (_: Exception) {
+                        null
+                    }
+                }
+            }
+            clazz = clazz.superclass
+        }
+        return null
+    }
+}