catalyst-core 0.2.0-beta.2 → 0.2.0-beta.3

package/dist/native/androidProject/app/build.gradle.kts

@@ -110,6 +110,7 @@ android {
             applicationIdSuffix = ".debug"
             versionNameSuffix = "-debug"
             isMinifyEnabled = false
+            enableUnitTestCoverage = true
             buildConfigField("Boolean", "ALLOW_MIXED_CONTENT", "true")
             buildConfigField("String", "LOCAL_IP", "\"${getLocalIpAddress()}\"")
         }

package/dist/native/androidProject/app/src/main/java/io/yourname/androidproject/CustomWebview.kt

@@ -7,18 +7,26 @@ import android.graphics.Bitmap
 import android.net.Uri
 import android.os.Bundle
 import android.util.Log
+import android.view.GestureDetector
+import android.view.MotionEvent
 import android.view.View
 import android.webkit.*
 import androidx.webkit.ServiceWorkerClientCompat
 import androidx.webkit.ServiceWorkerControllerCompat
+import androidx.webkit.WebViewCompat
+import androidx.webkit.WebViewFeature
 import androidx.webkit.WebResourceRequestCompat
 import android.widget.ProgressBar
 import androidx.webkit.WebViewAssetLoader
 import io.yourname.androidproject.WebCacheManager
 import io.yourname.androidproject.URLWhitelistManager
 import io.yourname.androidproject.matchesCachePattern
+import io.yourname.androidproject.utils.BridgeUtils
 import io.yourname.androidproject.utils.CameraUtils
 import io.yourname.androidproject.utils.NetworkUtils
+import io.yourname.androidproject.utils.PerfEventBuffer
+import io.yourname.androidproject.utils.ProfilerNavigationState
+import org.json.JSONObject
 import kotlinx.coroutines.*
 import java.io.FileNotFoundException
 import java.util.Properties
@@ -45,11 +53,15 @@ class CustomWebView(
     private var isInitialApiCalled: Boolean = false  // Flag to track initial page load
     private var isInitialPageLoaded: Boolean = false
     private var buildOptimisation: Boolean = false // Added property for build optimization
+    private var profilerEnabled: Boolean = false
+    private val profilerNavigationState = ProfilerNavigationState()
     private lateinit var assetLoader: WebViewAssetLoader
     private var allowedUrls: List<String> = emptyList()
     private var accessControlEnabled: Boolean = false
     private val offlineAssetPath = "offline/offline.html"
     private val offlineAssetUrl = "file:///android_asset/$offlineAssetPath"
+    private var scrollSessionOpen = false
+    private lateinit var scrollGestureDetector: GestureDetector
     private var offlinePageVisible = false
     private var lastTargetUrl: String? = null
     private var activeOfflineRouteOrigin: String? = null
@@ -62,8 +74,16 @@ class CustomWebView(
     private var assetLoadFailures = 0
 
     init {
+        if (BuildConfig.DEBUG) {
+            PerfEventBuffer.add(JSONObject().apply {
+                put("type", "boot-webview-constructed")
+                put("nativeTime", android.os.SystemClock.elapsedRealtime())
+                put("thread", Thread.currentThread().name)
+            })
+        }
         setupFromProperties()
         cacheManager = WebCacheManager(context, properties)
+        if (profilerEnabled) metricsMonitor.attachWebView(webView)
         offlineCacheService = OfflineCacheService(context)
         setupWebView()
     }
@@ -90,6 +110,7 @@ class CustomWebView(
 
         // Parse buildOptimisation property
         buildOptimisation = properties.getProperty("buildOptimisation", "false").toBoolean()
+        profilerEnabled = PerfEventBuffer.isEnabled()
 
         // Load allowed URLs from properties
         allowedUrls = properties.getProperty("accessControl.allowedUrls", "")
@@ -162,12 +183,26 @@ class CustomWebView(
         }
     }
 
+    private fun loadTopLevelUrl(url: String) {
+        if (BuildConfig.DEBUG) {
+            val navigation = profilerNavigationState.begin(url)
+            if (navigation.shouldReset) PerfEventBuffer.reset()
+            PerfEventBuffer.add(JSONObject().apply {
+                put("type", "boot-load-url")
+                put("nativeTime", android.os.SystemClock.elapsedRealtime())
+                put("url", navigation.url)
+                put("thread", Thread.currentThread().name)
+            })
+        }
+        loadUrlInternal(url)
+    }
+
     fun loadUrl(url: String) {
         lastTargetUrl = url
         offlinePageVisible = false
         visibleOfflineSnapshotUrl = null
         activeOfflineRouteOrigin = null
-        loadUrlInternal(url)
+        loadTopLevelUrl(url)
     }
 
     fun updateLastTargetUrl(url: String) {
@@ -185,7 +220,7 @@ class CustomWebView(
             offlinePageVisible = true
             visibleOfflineSnapshotUrl = null
             activeOfflineRouteOrigin = null
-            loadUrlInternal(offlineAssetUrl)
+            loadTopLevelUrl(offlineAssetUrl)
             if (BuildConfig.DEBUG) {
                 Log.d(TAG, "📴 Showing offline page from assets: $offlineAssetPath")
             }
@@ -228,7 +263,7 @@ class CustomWebView(
             offlinePageVisible = false
             visibleOfflineSnapshotUrl = snapshotUrl
             updateActiveOfflineRoute(url, true)
-            loadUrlInternal(url)
+            loadTopLevelUrl(url)
             if (BuildConfig.DEBUG) {
                 Log.d(TAG, "📴 Loading cached offline route through request interceptor: $url")
             }
@@ -304,6 +339,7 @@ class CustomWebView(
 
     fun destroy() {
         job.cancel()
+        metricsMonitor.detachWebView()
         webView.destroy()
     }
 
@@ -335,6 +371,13 @@ class CustomWebView(
             if (BuildConfig.DEBUG) {
                 Log.d(TAG, "🚀 Hardware acceleration enabled - Thread: ${Thread.currentThread().name}")
             }
+            BridgeUtils.emitPerfEvent(webView, JSONObject().apply {
+                put("type", "hw-accel-change")
+                put("state", "on")
+                put("trigger", "cleanup")
+                put("thread", Thread.currentThread().name)
+                put("nativeTime", android.os.SystemClock.elapsedRealtime())
+            })
         }
     }
 
@@ -345,6 +388,13 @@ class CustomWebView(
             if (BuildConfig.DEBUG) {
                 Log.d(TAG, "⚫ Hardware acceleration disabled - Thread: ${Thread.currentThread().name}")
             }
+            BridgeUtils.emitPerfEvent(webView, JSONObject().apply {
+                put("type", "hw-accel-change")
+                put("state", "off")
+                put("trigger", "cache-serve")
+                put("thread", Thread.currentThread().name)
+                put("nativeTime", android.os.SystemClock.elapsedRealtime())
+            })
         }
     }
 
@@ -472,7 +522,7 @@ class CustomWebView(
                     }
                     offlinePageVisible = false
                     lastTargetUrl = target
-                    loadUrlInternal(target)
+                    loadTopLevelUrl(target)
                 } else if (BuildConfig.DEBUG) {
                     Log.w(TAG, "🔄 Retry requested but no target URL is known")
                 }
@@ -718,6 +768,13 @@ class CustomWebView(
 
     @SuppressLint("SetJavaScriptEnabled")
     private fun setupWebView() {
+        if (profilerEnabled && WebViewFeature.isFeatureSupported(WebViewFeature.DOCUMENT_START_SCRIPT)) {
+            WebViewCompat.addDocumentStartJavaScript(
+                webView,
+                "window.__CATALYST_PROFILER_ENABLED = true;",
+                setOf("*")
+            )
+        }
         if (BuildConfig.DEBUG) {
             Log.d(TAG, "🌐 Setting up WebView on thread: ${Thread.currentThread().name}")
         }
@@ -1057,14 +1114,53 @@ class CustomWebView(
                     Log.d(TAG, "⏳ Page load started for: $url - Hardware Acceleration: $isHardwareAccelerationEnabled")
                     Log.d(FLOW_TAG, "PAGE started url=$url online=${NetworkUtils.getCurrentStatus(context).isOnline} offlinePageVisible=$offlinePageVisible visibleSnapshot=${visibleOfflineSnapshotUrl ?: "none"} activeOrigin=${activeOfflineRouteOrigin ?: "none"}")
                 }
+
+                if (profilerEnabled) {
+                    val nativeNow = android.os.SystemClock.elapsedRealtime()
+                    view?.evaluateJavascript(
+                        "window.__CATALYST_PROFILER_ENABLED = true; window.__NATIVE_TIME_OFFSET = $nativeNow - performance.now();",
+                        null
+                    )
+                }
+                if (profilerEnabled && url != null) {
+                    val nativeNow = android.os.SystemClock.elapsedRealtime()
+                    PerfEventBuffer.add(JSONObject().apply {
+                        put("type", "boot-page-started")
+                        put("nativeTime", nativeNow)
+                        put("url", url)
+                    })
+                    PerfEventBuffer.add(JSONObject().apply {
+                        put("type", "page-load-start")
+                        put("nativeTime", nativeNow)
+                        put("url", url)
+                    })
+                }
             }
 
             override fun onPageFinished(view: WebView?, url: String?) {
                 progressBar.visibility = View.GONE
                 if(!isInitialPageLoaded){
                     isInitialPageLoaded = true
+                    metricsMonitor.markAppStartComplete()
                 }
                 url?.let { metricsMonitor.trackPageLoadEnd(it) }
+
+                val pageFinishedNative = android.os.SystemClock.elapsedRealtime()
+                if (profilerEnabled && url != null) {
+                    PerfEventBuffer.add(JSONObject().apply {
+                        put("type", "boot-page-finished")
+                        put("nativeTime", pageFinishedNative)
+                        put("url", url)
+                    })
+                    val pageStart = view?.tag as? Long
+                    PerfEventBuffer.add(JSONObject().apply {
+                        put("type", "page-load-end")
+                        put("nativeTime", pageFinishedNative)
+                        put("url", url)
+                        put("durationMs", if (pageStart != null) System.currentTimeMillis() - pageStart else 0L)
+                    })
+                    if (view != null) PerfEventBuffer.scheduleFlush(view)
+                }
                 if (BuildConfig.DEBUG) {
                     val startTime = view?.tag as? Long ?: return
                     val loadTime = System.currentTimeMillis() - startTime
@@ -1095,6 +1191,15 @@ class CustomWebView(
                     if (BuildConfig.DEBUG) {
                         Log.e(FLOW_TAG, "PAGE resource-error mainFrame=${request?.isForMainFrame} method=${request?.method} code=${error.errorCode} description=${error.description} url=${request?.url}")
                     }
+                    if (view != null && request?.isForMainFrame == true) {
+                        BridgeUtils.emitPerfEvent(view, JSONObject().apply {
+                            put("type", "page-load-error")
+                            put("nativeTime", android.os.SystemClock.elapsedRealtime())
+                            put("url", request.url?.toString() ?: "")
+                            put("errorCode", error.errorCode)
+                            put("description", error.description?.toString() ?: "")
+                        })
+                    }
                 }
 
                 val failedUrl = request?.url?.toString()
@@ -1204,5 +1309,39 @@ class CustomWebView(
 
         // Only enable WebView debugging in debug builds
         WebView.setWebContentsDebuggingEnabled(BuildConfig.DEBUG)
+
+        if (profilerEnabled) {
+            scrollGestureDetector = GestureDetector(context,
+                object : GestureDetector.SimpleOnGestureListener() {
+                    override fun onScroll(
+                        e1: MotionEvent?,
+                        e2: MotionEvent,
+                        distanceX: Float,
+                        distanceY: Float
+                    ): Boolean {
+                        if (!scrollSessionOpen) {
+                            scrollSessionOpen = true
+                            BridgeUtils.emitPerfEvent(webView, JSONObject().apply {
+                                put("type", "scroll-start")
+                                put("nativeTime", android.os.SystemClock.elapsedRealtime())
+                            })
+                        }
+                        return false
+                    }
+                }
+            )
+            webView.setOnTouchListener { _, event ->
+                scrollGestureDetector.onTouchEvent(event)
+                if (scrollSessionOpen &&
+                    (event.action == MotionEvent.ACTION_UP || event.action == MotionEvent.ACTION_CANCEL)) {
+                    scrollSessionOpen = false
+                    BridgeUtils.emitPerfEvent(webView, JSONObject().apply {
+                        put("type", "scroll-end")
+                        put("nativeTime", android.os.SystemClock.elapsedRealtime())
+                    })
+                }
+                false
+            }
+        }
     }
 }

package/dist/native/androidProject/app/src/main/java/io/yourname/androidproject/MainActivity.kt

@@ -274,6 +274,9 @@ class MainActivity : AppCompatActivity(), CoroutineScope by MainScope() {
             properties.setProperty("buildType", if (BuildConfig.DEBUG) "debug" else "release")
             properties.setProperty("buildOptimisation", (!BuildConfig.DEBUG).toString())
         }
+        io.yourname.androidproject.utils.PerfEventBuffer.configure(
+            properties.getProperty("profiler.enabled", "false").toBoolean()
+        )
 
         configureEdgeToEdge()
 
@@ -286,16 +289,29 @@ class MainActivity : AppCompatActivity(), CoroutineScope by MainScope() {
             })
         }
 
-        // Initialize MetricsMonitor
+        // Initialize MetricsMonitor — recordAppStart() resets the cold-start clock for this
+        // Activity lifecycle. The singleton may have been constructed in a previous session
+        // (hot restart / Activity recreation), so appStartTime would be stale without this.
         metricsMonitor = MetricsMonitor.getInstance(this)
+        metricsMonitor.recordAppStart()
+
+        // Boot timing: record activity onCreate as the earliest boot event
+        if (BuildConfig.DEBUG) {
+            io.yourname.androidproject.utils.PerfEventBuffer.reset()
+            io.yourname.androidproject.utils.PerfEventBuffer.add(org.json.JSONObject().apply {
+                put("type", "boot-activity-created")
+                put("nativeTime", android.os.SystemClock.elapsedRealtime())
+                put("thread", Thread.currentThread().name)
+            })
+        }
 
         // Setup UI
         binding = ActivityMainBinding.inflate(layoutInflater)
         supportActionBar?.hide()
         setContentView(binding.root)
         
-        // Initialize keyboard utility
-        keyboardUtil = KeyboardUtil(this, binding.webviewContainer)
+        // Initialize keyboard utility (pass webView so keyboard events reach WebPerfCollector)
+        keyboardUtil = KeyboardUtil(this, binding.webviewContainer, binding.webview)
         keyboardUtil.initialize()
         
         // Enable hardware acceleration for the window
@@ -351,6 +367,12 @@ class MainActivity : AppCompatActivity(), CoroutineScope by MainScope() {
         onBackPressedDispatcher.addCallback(this, object : OnBackPressedCallback(true) {
             override fun handleOnBackPressed() {
                 if (customWebView.canGoBack()) {
+                    if (BuildConfig.DEBUG) {
+                        BridgeUtils.emitPerfEvent(customWebView.getWebView(), org.json.JSONObject().apply {
+                            put("type", "navigation-back")
+                            put("nativeTime", android.os.SystemClock.elapsedRealtime())
+                        })
+                    }
                     customWebView.goBack()
                 } else {
                     // Disable this callback and let the system handle back press
@@ -389,9 +411,6 @@ class MainActivity : AppCompatActivity(), CoroutineScope by MainScope() {
                     customWebView.showOfflineRouteOrOfflinePage(currentUrl)
                 }
             }
-
-            metricsMonitor.markAppStartComplete()
-
         } catch (e: Exception) {
             Log.e(TAG, "Failed to load initial URL: ${e.message}")
             // TODO: Add HTML file workflow - error.html not available yet
@@ -453,6 +472,7 @@ class MainActivity : AppCompatActivity(), CoroutineScope by MainScope() {
     }
 
     override fun onDestroy() {
+        io.yourname.androidproject.utils.PerfEventBuffer.reset()
         // Log all performance metrics before destroying
         if (BuildConfig.DEBUG) {
             Log.d(TAG, "🏁 App shutting down - logging final metrics...")

package/dist/native/androidProject/app/src/main/java/io/yourname/androidproject/MetricsMonitor.kt

@@ -5,6 +5,10 @@ import android.os.Debug
 import android.os.SystemClock
 import android.util.Log
 import android.view.Choreographer
+import android.webkit.WebView
+import io.yourname.androidproject.utils.BridgeUtils
+import io.yourname.androidproject.utils.PerfEventBuffer
+import org.json.JSONObject
 import java.util.concurrent.TimeUnit
 import java.util.concurrent.atomic.AtomicInteger
 
@@ -13,11 +17,29 @@ import java.util.concurrent.atomic.AtomicInteger
  * Tracks key performance metrics and logs them on app destroy.
  */
 class MetricsMonitor(private val context: Context) {
+
+    // WebView reference for emitting perf events — set via attachWebView()
+    @Volatile private var webView: WebView? = null
+
+    fun attachWebView(wv: WebView) {
+        webView = wv
+    }
+
+    fun detachWebView() {
+        // Flush any open fps-drop episode before losing the WebView reference
+        if (inFpsDropEpisode) emitFpsDropEpisode(endTime = SystemClock.elapsedRealtime())
+        webView = null
+    }
+
+    private fun emitPerf(payload: JSONObject) {
+        webView?.let { BridgeUtils.emitPerfEvent(it, payload) }
+    }
     private val TAG = "MetricsMonitor"
 
     // App Startup metrics
     private var appStartTime: Long = SystemClock.elapsedRealtime()
     private var coldStartDuration: Long = 0
+    private var coldStartCompleted = false
 
     // Page Load metrics
     private val pageLoadTimes = mutableMapOf<String, Long>()
@@ -34,6 +56,15 @@ class MetricsMonitor(private val context: Context) {
     private var avgFps = 0.0
     private var fpsReadings = 0
 
+    // fps-drop episode tracking
+    private var inFpsDropEpisode = false
+    private var episodeStartNativeTime: Long = 0
+    private var episodeMinFps = Double.MAX_VALUE
+    private var episodeFpsSum = 0.0
+    private var episodeSampleCount = 0
+    private val FPS_EPISODE_MAX_MS = 10_000L  // force-close after 10s
+    private var lastStableFps = 60.0          // fps reading just before episode started — used to compute deltaFps
+
     // Memory metrics
     private var initialMemory: Long = getMemoryUsage()
     private var peakMemory: Long = initialMemory
@@ -74,8 +105,18 @@ class MetricsMonitor(private val context: Context) {
     }
 
     fun markAppStartComplete() {
+        if (coldStartCompleted) return
+        coldStartCompleted = true
         coldStartDuration = SystemClock.elapsedRealtime() - appStartTime
         Log.d(TAG, "App cold start completed in: $coldStartDuration ms")
+        // Buffer so it is delivered with the post-load batch flush when JS is ready.
+        // emitPerf (live path) would be a no-op here — JS may not have loaded yet.
+        PerfEventBuffer.add(JSONObject().apply {
+            put("type", "cold-start")
+            put("nativeTime", SystemClock.elapsedRealtime())
+            put("durationMs", coldStartDuration)
+            put("thread", Thread.currentThread().name)
+        })
     }
 
     fun trackPageLoadStart(url: String) {
@@ -144,8 +185,14 @@ class MetricsMonitor(private val context: Context) {
         uiBlockingEvents++
     }
 
-    fun recordLongTask() {
+    fun recordLongTask(durationMs: Long = longTaskThreshold) {
         longTasksDetected++
+        emitPerf(JSONObject().apply {
+            put("type", "long-task")
+            put("nativeTime", SystemClock.elapsedRealtime())
+            put("durationMs", durationMs)
+            put("thread", Thread.currentThread().name)
+        })
     }
 
     private fun startFrameMonitoring() {
@@ -173,27 +220,106 @@ class MetricsMonitor(private val context: Context) {
         val timeSpan = now - lastFpsCheckTime
         lastFpsCheckTime = now
 
-        if (timeSpan > 0) {
-            currentFps = frames * 1000.0 / timeSpan
-
-            // Update min/max/avg
-            if (minFps == Double.MAX_VALUE) minFps = currentFps
-            minFps = minFps.coerceAtMost(currentFps)
-            maxFps = maxFps.coerceAtLeast(currentFps)
-
-            val totalFps = avgFps * fpsReadings + currentFps
-            fpsReadings++
-            avgFps = totalFps / fpsReadings
+        if (timeSpan <= 0) return
+
+        currentFps = frames * 1000.0 / timeSpan
+
+        // Update session-level min/max/avg
+        if (minFps == Double.MAX_VALUE) minFps = currentFps
+        minFps = minFps.coerceAtMost(currentFps)
+        maxFps = maxFps.coerceAtLeast(currentFps)
+        val totalFps = avgFps * fpsReadings + currentFps
+        fpsReadings++
+        avgFps = totalFps / fpsReadings
+
+        if (currentFps < 55.0) {
+            if (!inFpsDropEpisode) {
+                // Start new episode — capture the last stable fps as baseline for deltaFps
+                inFpsDropEpisode = true
+                episodeStartNativeTime = now - timeSpan  // start of the measured window
+                episodeMinFps = currentFps
+                episodeFpsSum = currentFps
+                episodeSampleCount = 1
+                // lastStableFps already holds the previous reading (set in the else branch below)
+            } else {
+                // Accumulate into current episode
+                episodeMinFps = episodeMinFps.coerceAtMost(currentFps)
+                episodeFpsSum += currentFps
+                episodeSampleCount++
+
+                // Force-close if episode has run for >= 10s
+                val episodeDuration = now - episodeStartNativeTime
+                if (episodeDuration >= FPS_EPISODE_MAX_MS) {
+                    emitFpsDropEpisode(endTime = now)
+                    // Immediately start a new episode for the continuing drop
+                    inFpsDropEpisode = true
+                    episodeStartNativeTime = now
+                    episodeMinFps = currentFps
+                    episodeFpsSum = currentFps
+                    episodeSampleCount = 1
+                }
+            }
+        } else {
+            // FPS is good — update lastStableFps and close episode if one was open
+            lastStableFps = currentFps
+            if (inFpsDropEpisode) {
+                emitFpsDropEpisode(endTime = now)
+            }
         }
     }
 
+    private fun emitFpsDropEpisode(endTime: Long) {
+        if (!inFpsDropEpisode) return
+        val durationMs = endTime - episodeStartNativeTime
+        val avgEpisodeFps = if (episodeSampleCount > 0) episodeFpsSum / episodeSampleCount else episodeMinFps
+        // deltaFps = how far FPS fell from the last stable reading before the episode
+        val deltaFps = lastStableFps - episodeMinFps
+        emitPerf(JSONObject().apply {
+            put("type", "fps-drop-episode")
+            put("startNativeTime", episodeStartNativeTime)
+            put("endNativeTime", endTime)
+            put("durationMs", durationMs)
+            put("minFps", episodeMinFps)
+            put("avgFps", avgEpisodeFps)
+            put("deltaFps", deltaFps)     // drop magnitude from last stable fps
+            put("baselineFps", lastStableFps)
+            put("thread", Thread.currentThread().name)
+        })
+        inFpsDropEpisode = false
+        episodeMinFps = Double.MAX_VALUE
+        episodeFpsSum = 0.0
+        episodeSampleCount = 0
+    }
+
     private fun monitorMemoryPeriodically() {
         Thread {
             while (!Thread.interrupted()) {
                 try {
-                    currentMemory = getMemoryUsage()
-                    peakMemory = peakMemory.coerceAtLeast(currentMemory)
-                    Thread.sleep(5000) // Check every 5 seconds
+                    val memInfo = Debug.MemoryInfo()
+                    Debug.getMemoryInfo(memInfo)
+
+                    // PSS breakdown — all values in KB, convert to MB
+                    val jvmMb     = memInfo.dalvikPss  / 1024.0  // Kotlin/Java heap
+                    val webviewMb = memInfo.nativePss  / 1024.0  // V8 + Blink + JNI (WebView proxy)
+                    val otherMb   = memInfo.otherPss   / 1024.0  // graphics buffers, code, stack
+                    val totalMb   = memInfo.totalPss   / 1024.0  // what Android OOM killer sees
+
+                    currentMemory = memInfo.totalPss.toLong()
+                    peakMemory    = peakMemory.coerceAtLeast(currentMemory)
+
+                    val now = SystemClock.elapsedRealtime()
+                    emitPerf(JSONObject().apply {
+                        put("type",         "memory-snapshot")
+                        put("nativeTime",    now)
+                        put("jvmMb",        jvmMb)
+                        put("webviewMb",    webviewMb)
+                        put("otherMb",      otherMb)
+                        put("totalMb",      totalMb)
+                        put("peakMb",       peakMemory / 1024.0)
+                        put("thread",       Thread.currentThread().name)
+                        if (coldStartDuration > 0) put("coldStartMs", coldStartDuration)
+                    })
+                    Thread.sleep(5000)
                 } catch (e: InterruptedException) {
                     break
                 }
@@ -324,7 +450,7 @@ class MetricsMonitor(private val context: Context) {
     }
 
     fun cleanup() {
-        // Remove frame callback
+        if (inFpsDropEpisode) emitFpsDropEpisode(endTime = SystemClock.elapsedRealtime())
         Choreographer.getInstance().removeFrameCallback(frameCallback)
     }
 
@@ -338,4 +464,4 @@ class MetricsMonitor(private val context: Context) {
             }
         }
     }
-}
+}

package/dist/native/androidProject/app/src/main/java/io/yourname/androidproject/NativeBridge.kt

@@ -332,8 +332,11 @@ class NativeBridge(
 
     @JavascriptInterface
     fun openCamera(options: String?) {
+        val callId = "openCamera:${android.os.SystemClock.elapsedRealtime()}"
+        BridgeUtils.bridgeCallReceived(callId, "openCamera")
         BridgeUtils.safeExecute(webView, BridgeUtils.WebEvents.ON_CAMERA_ERROR, "open camera") {
             mainActivity.runOnUiThread {
+                BridgeUtils.bridgeCallDispatched(callId)
                 if (CameraUtils.hasCameraPermission(mainActivity)) {
                     launchCamera()
                 } else {
@@ -492,10 +495,13 @@ class NativeBridge(
 
     @JavascriptInterface
     fun getDeviceInfo(options: String?) {
+        val callId = "getDeviceInfo:${android.os.SystemClock.elapsedRealtime()}"
+        BridgeUtils.bridgeCallReceived(callId, "getDeviceInfo")
         BridgeUtils.safeExecute(webView, BridgeUtils.WebEvents.ON_DEVICE_INFO_ERROR, "get device info") {
             mainActivity.runOnUiThread {
                 val deviceInfo = DeviceInfoUtils.getDeviceInfo(mainActivity, properties)
                 BridgeUtils.logDebug(TAG, "Device info retrieved: $deviceInfo")
+                BridgeUtils.bridgeCallDispatched(callId)
                 BridgeUtils.notifyWeb(webView, BridgeUtils.WebEvents.ON_DEVICE_INFO_SUCCESS, deviceInfo.toString())
             }
         }