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

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

@@ -136,6 +136,7 @@ class MainActivity : AppCompatActivity(), CoroutineScope by MainScope() {
         "X-Safe-Area-Right" to latestSafeAreaInsets.right.toString(),
         "X-Safe-Area-Bottom" to latestSafeAreaInsets.bottom.toString(),
         "X-Safe-Area-Left" to latestSafeAreaInsets.left.toString(),
+        "X-Catalyst-Native-WebView" to "1",
         // Prevent caching of SSR response so updated headers are always used
         "Cache-Control" to "no-cache, no-store, must-revalidate",
         "Pragma" to "no-cache"
@@ -273,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()
 
@@ -285,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
@@ -350,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
@@ -385,12 +408,9 @@ class MainActivity : AppCompatActivity(), CoroutineScope by MainScope() {
                     if (BuildConfig.DEBUG) {
                         Log.w(TAG, "📴 Device offline on launch, showing offline page")
                     }
-                    customWebView.showOfflinePage()
+                    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
@@ -452,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...")
@@ -533,7 +554,7 @@ class MainActivity : AppCompatActivity(), CoroutineScope by MainScope() {
                 loadUrlWithSafeArea(url)
             } else {
                 Log.w(TAG, "📴 Offline during notification click, showing offline page")
-                customWebView.showOfflinePage()
+                customWebView.showOfflineRouteOrOfflinePage(url)
             }
 
         } catch (e: Exception) {

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

@@ -213,7 +213,7 @@ class NativeBridge(
                 .filter { it.isNotEmpty() }
 
             accessControlEnabled = properties
-                .getProperty("accessControl.enabled", "true")
+                .getProperty("accessControl.enabled", "false")
                 .equals("true", ignoreCase = true)
 
             if (accessControlEnabled && allowedUrls.isNotEmpty()) {
@@ -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())
             }
         }