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

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

@@ -5,7 +5,9 @@ import android.util.Log
 import android.util.LruCache
 import android.webkit.WebResourceResponse
 import io.yourname.androidproject.BuildConfig
+import io.yourname.androidproject.utils.PerfEventBuffer
 import kotlinx.coroutines.*
+import org.json.JSONObject
 import java.io.*
 import java.net.HttpURLConnection
 import java.net.URL
@@ -14,6 +16,7 @@ import java.util.concurrent.TimeUnit
 
 class WebCacheManager(private val context: Context, private val properties: java.util.Properties? = null) {
     private val TAG = "WebCacheManager"
+    private val FLOW_TAG = "CatalystOfflineFlow"
     private val cacheDir = File(context.cacheDir, "webview_cache")
     private val scope = CoroutineScope(Dispatchers.IO + SupervisorJob())
     private val BUFFER_SIZE = 32 * 1024 
@@ -35,6 +38,24 @@ class WebCacheManager(private val context: Context, private val properties: java
         (Runtime.getRuntime().maxMemory() / 1024 / memoryFraction).toInt()
     )
 
+    private fun emitCachePerfEvent(type: String, url: String, startMs: Long, statusCode: Int? = null) {
+        if (!BuildConfig.DEBUG) return
+        PerfEventBuffer.add(JSONObject().apply {
+            put("type", type)
+            put("url", url)
+            put("nativeStartMs", startMs)
+            put("durationMs", android.os.SystemClock.elapsedRealtime() - startMs)
+            put("resourceType", when {
+                url.endsWith(".js") -> "script"
+                url.endsWith(".css") -> "stylesheet"
+                url.endsWith(".png") || url.endsWith(".jpg") || url.endsWith(".jpeg") || url.endsWith(".svg") -> "image"
+                else -> "other"
+            })
+            put("thread", Thread.currentThread().name)
+            statusCode?.let { put("statusCode", it) }
+        })
+    }
+
     init {
         try {
             cacheDir.mkdirs()
@@ -51,20 +72,36 @@ class WebCacheManager(private val context: Context, private val properties: java
         }
     }
 
-    data class CacheEntry(
-        val response: WebResourceResponse,
+    private data class CacheEntry(
+        val data: ByteArray,
+        val mimeType: String,
+        val encoding: String,
+        val responseHeaders: Map<String, String> = emptyMap(),
         val timestamp: Long = System.currentTimeMillis(),
         val eTag: String? = null,
         val lastModified: String? = null
-    )
+    ) {
+        fun toResponse(): WebResourceResponse {
+            return WebResourceResponse(
+                mimeType,
+                encoding,
+                200,
+                "OK",
+                responseHeaders.ifEmpty { null },
+                ByteArrayInputStream(data)
+            )
+        }
+    }
 
     /**
      * Synchronous cache check - only returns cached content if immediately available
      * Does not perform network requests or background revalidation
      * Used by ServiceWorker to avoid blocking
      */
+    @Suppress("UNUSED_PARAMETER")
     fun getCachedResponseSync(url: String, headers: Map<String, String>): WebResourceResponse? {
         return try {
+            val startMs = android.os.SystemClock.elapsedRealtime()
             val cacheKey = generateCacheKey(url)
             val currentTime = System.currentTimeMillis()
 
@@ -76,8 +113,13 @@ class WebCacheManager(private val context: Context, private val properties: java
                 if (age <= maxAge + staleWhileRevalidate) {
                     if (BuildConfig.DEBUG) {
                         Log.d(TAG, "✅ Serving from memory cache (sync): $url")
+                        Log.d(FLOW_TAG, "ASSET cache-hit source=memory ageMs=$age url=$url")
                     }
-                    return memoryCacheEntry.response
+                    emitCachePerfEvent("cache-hit-memory", url, startMs)
+                    return memoryCacheEntry.toResponse()
+                }
+                if (BuildConfig.DEBUG) {
+                    Log.d(FLOW_TAG, "ASSET cache-expired source=memory ageMs=$age url=$url")
                 }
             }
 
@@ -88,20 +130,50 @@ class WebCacheManager(private val context: Context, private val properties: java
                 if (fileAge <= maxAge + staleWhileRevalidate) {
                     val metadata = loadMetadata(cacheKey)
                     val response = createResponseFromCache(cacheFile, metadata)
+                    memoryCache.put(cacheKey, createEntryFromCache(cacheFile, metadata, cacheFile.lastModified()))
                     if (BuildConfig.DEBUG) {
                         Log.d(TAG, "✅ Serving from disk cache (sync): $url")
+                        Log.d(FLOW_TAG, "ASSET cache-hit source=disk ageMs=$fileAge bytes=${cacheFile.length()} mime=${metadata.mimeType} encoding=${metadata.encoding} url=$url")
                     }
+                    emitCachePerfEvent("cache-hit-disk", url, startMs)
                     return response
                 }
+                if (BuildConfig.DEBUG) {
+                    Log.d(FLOW_TAG, "ASSET cache-expired source=disk ageMs=$fileAge bytes=${cacheFile.length()} url=$url")
+                }
             }
 
             // No valid cache available
             if (BuildConfig.DEBUG) {
                 Log.d(TAG, "❌ No valid cache available (sync): $url")
+                Log.d(FLOW_TAG, "ASSET cache-miss url=$url")
             }
+            emitCachePerfEvent("cache-miss-fetch", url, startMs)
             null
         } catch (e: Exception) {
             Log.e(TAG, "Error in getCachedResponseSync for URL: $url: ${e.message}")
+            if (BuildConfig.DEBUG) {
+                Log.e(FLOW_TAG, "ASSET cache-error phase=read url=$url error=${e.message}", e)
+            }
+            null
+        }
+    }
+
+    /**
+     * Synchronous cache-or-network path for WebView interception.
+     *
+     * shouldInterceptRequest runs off the UI thread, so it is safe to block here.
+     * Returning the fetched response from this method guarantees that the same
+     * request which populated the cache also succeeds in the WebView.
+     */
+    fun getCachedResponseOrFetchSync(url: String, headers: Map<String, String>): WebResourceResponse? {
+        return try {
+            getCachedResponseSync(url, headers) ?: fetchAndCacheResourceBlocking(url, headers, generateCacheKey(url))
+        } catch (e: Exception) {
+            Log.e(TAG, "Error in getCachedResponseOrFetchSync for URL: $url: ${e.message}")
+            if (BuildConfig.DEBUG) {
+                Log.e(FLOW_TAG, "ASSET cache-error phase=cache-or-fetch url=$url error=${e.message}", e)
+            }
             null
         }
     }
@@ -123,7 +195,7 @@ class WebCacheManager(private val context: Context, private val properties: java
                             if (BuildConfig.DEBUG) {
                                 Log.d(TAG, "Serving fresh content from memory cache: $url")
                             }
-                            return@withContext memoryCacheEntry.response
+                            return@withContext memoryCacheEntry.toResponse()
                         }
                         age <= maxAge + staleWhileRevalidate -> {
                             // Stale content, but within revalidate window
@@ -131,7 +203,7 @@ class WebCacheManager(private val context: Context, private val properties: java
                                 Log.d(TAG, "Serving stale content while revalidating: $url")
                             }
                             revalidateInBackground(url, headers, cacheKey, memoryCacheEntry)
-                            return@withContext memoryCacheEntry.response
+                            return@withContext memoryCacheEntry.toResponse()
                         }
                     }
                 }
@@ -146,18 +218,13 @@ class WebCacheManager(private val context: Context, private val properties: java
                         fileAge <= maxAge -> {
                             // Fresh content from disk
                             val response = createResponseFromCache(cacheFile, metadata)
-                            memoryCache.put(cacheKey, CacheEntry(response))
+                            memoryCache.put(cacheKey, createEntryFromCache(cacheFile, metadata, cacheFile.lastModified()))
                             return@withContext response
                         }
                         fileAge <= maxAge + staleWhileRevalidate -> {
                             // Stale content from disk, revalidate in background
                             val response = createResponseFromCache(cacheFile, metadata)
-                            val cacheEntry = CacheEntry(
-                                response = response,
-                                timestamp = cacheFile.lastModified(),
-                                eTag = metadata.eTag,
-                                lastModified = metadata.lastModified
-                            )
+                            val cacheEntry = createEntryFromCache(cacheFile, metadata, cacheFile.lastModified())
                             revalidateInBackground(url, headers, cacheKey, cacheEntry)
                             return@withContext response
                         }
@@ -168,7 +235,7 @@ class WebCacheManager(private val context: Context, private val properties: java
                 if (BuildConfig.DEBUG) {
                     Log.d(TAG, "❌ Cache miss, fetching fresh content: $url")
                 }
-                fetchAndCacheResource(url, headers, cacheKey)
+                fetchAndCacheResourceBlocking(url, headers, cacheKey)
             } catch (e: Exception) {
                 Log.e(TAG, "Error in getCachedResponse for URL: $url: ${e.message}")
                 if (BuildConfig.DEBUG) {
@@ -282,7 +349,7 @@ class WebCacheManager(private val context: Context, private val properties: java
                         if (BuildConfig.DEBUG) {
                             Log.d(TAG, "⚡ Content changed, updating cache: $url")
                         }
-                        fetchAndCacheResource(url, headers, cacheKey)
+                        fetchAndCacheResourceBlocking(url, headers, cacheKey)
                     }
                 }
             } catch (e: Exception) {
@@ -308,25 +375,33 @@ class WebCacheManager(private val context: Context, private val properties: java
         }
     }
 
-    private suspend fun fetchAndCacheResource(
+    private fun fetchAndCacheResourceBlocking(
         url: String,
         headers: Map<String, String>,
         cacheKey: String
-    ): WebResourceResponse? = withContext(Dispatchers.IO) {
+    ): WebResourceResponse? {
         var connection: HttpURLConnection? = null
+        val startMs = android.os.SystemClock.elapsedRealtime()
         try {
             connection = URL(url).openConnection() as HttpURLConnection
             headers.forEach { (key, value) ->
-                connection.setRequestProperty(key, value)
+                if (!key.equals("Accept-Encoding", ignoreCase = true)) {
+                    connection.setRequestProperty(key, value)
+                }
             }
+            connection.setRequestProperty("Accept-Encoding", "identity")
 
             connection.connectTimeout = 15000
             connection.readTimeout = 15000
+            if (BuildConfig.DEBUG) {
+                Log.d(FLOW_TAG, "ASSET network-fetch start url=$url headers=${headers.keys.sorted()}")
+            }
             connection.connect()
 
             if (connection.responseCode == HttpURLConnection.HTTP_OK) {
-                val mimeType = connection.contentType ?: "application/octet-stream"
-                val encoding = connection.contentEncoding ?: "utf-8"
+                val contentType = connection.contentType ?: "application/octet-stream"
+                val mimeType = mimeTypeFromContentType(contentType)
+                val encoding = charsetFromContentType(contentType)
                 val eTag = connection.getHeaderField("ETag")
                 val lastModified = connection.getHeaderField("Last-Modified")
 
@@ -336,13 +411,17 @@ class WebCacheManager(private val context: Context, private val properties: java
                 while (true) {
                     val key = connection.getHeaderFieldKey(i) ?: break
                     val value = connection.getHeaderField(i)
-                    if (key.isNotEmpty()) savedHeaders[key] = value
+                    if (key.isNotEmpty() && shouldReplayHeader(key)) savedHeaders[key] = value
                     i++
                 }
+                savedHeaders["Content-Type"] = contentType
 
                 val responseBytes = connection.inputStream.use { it.readBytes() }
                 if (!isValidResponse(mimeType, responseBytes)) {
-                    return@withContext null
+                    if (BuildConfig.DEBUG) {
+                        Log.w(FLOW_TAG, "ASSET network-fetch invalid-response status=${connection.responseCode} contentType=$contentType bytes=${responseBytes.size} url=$url")
+                    }
+                    return null
                 }
 
                 // Create response for immediate use
@@ -350,7 +429,10 @@ class WebCacheManager(private val context: Context, private val properties: java
 
                 // Cache the response
                 val cacheEntry = CacheEntry(
-                    response = WebResourceResponse(mimeType, encoding, 200, "OK", savedHeaders, ByteArrayInputStream(responseBytes.copyOf())),
+                    data = responseBytes.copyOf(),
+                    mimeType = mimeType,
+                    encoding = encoding,
+                    responseHeaders = savedHeaders,
                     eTag = eTag,
                     lastModified = lastModified
                 )
@@ -370,21 +452,35 @@ class WebCacheManager(private val context: Context, private val properties: java
                         ))
                         if (BuildConfig.DEBUG) {
                             Log.d(TAG, "✅ Successfully cached response for: $url")
+                            Log.d(FLOW_TAG, "ASSET stored bytes=${responseBytes.size} mime=$mimeType encoding=$encoding url=$url")
                         }
                     } catch (e: Exception) {
                         Log.e(TAG, "Error saving to disk cache for URL: $url: ${e.message}")
+                        if (BuildConfig.DEBUG) {
+                            Log.e(FLOW_TAG, "ASSET store-error url=$url error=${e.message}", e)
+                        }
                     }
                 }
 
-                return@withContext response
+                if (BuildConfig.DEBUG) {
+                    Log.d(FLOW_TAG, "ASSET network-fetch success status=${connection.responseCode} bytes=${responseBytes.size} contentType=$contentType replayMime=$mimeType replayEncoding=$encoding url=$url")
+                }
+                emitCachePerfEvent("network-fetch-complete", url, startMs, connection.responseCode)
+                return response
+            }
+            if (BuildConfig.DEBUG) {
+                Log.w(FLOW_TAG, "ASSET network-fetch non-200 status=${connection.responseCode} contentType=${connection.contentType} url=$url")
             }
-            return@withContext null
+            return null
         } catch (e: Exception) {
             Log.e(TAG, "Error fetching resource: ${e.message}")
+            if (BuildConfig.DEBUG) {
+                Log.e(FLOW_TAG, "ASSET network-fetch error url=$url error=${e.message}", e)
+            }
             if (BuildConfig.DEBUG) {
                 e.printStackTrace()
             }
-            return@withContext null
+            return null
         } finally {
             connection?.disconnect()
         }
@@ -409,6 +505,46 @@ class WebCacheManager(private val context: Context, private val properties: java
         )
     }
 
+    private fun mimeTypeFromContentType(contentType: String): String {
+        return contentType.substringBefore(";").trim().ifEmpty { "application/octet-stream" }
+    }
+
+    private fun charsetFromContentType(contentType: String): String {
+        val charsetPart = contentType
+            .split(";")
+            .map { it.trim() }
+            .firstOrNull { it.startsWith("charset=", ignoreCase = true) }
+        return charsetPart
+            ?.substringAfter("=")
+            ?.trim()
+            ?.trim('"')
+            ?.ifEmpty { null }
+            ?: "utf-8"
+    }
+
+    private fun shouldReplayHeader(header: String): Boolean {
+        return !header.equals("Content-Encoding", ignoreCase = true) &&
+            !header.equals("Transfer-Encoding", ignoreCase = true) &&
+            !header.equals("Content-Length", ignoreCase = true) &&
+            !header.equals("Connection", ignoreCase = true)
+    }
+
+    private fun createEntryFromCache(
+        cacheFile: File,
+        metadata: CacheMetadata,
+        timestamp: Long
+    ): CacheEntry {
+        return CacheEntry(
+            data = cacheFile.readBytes(),
+            mimeType = metadata.mimeType,
+            encoding = metadata.encoding,
+            responseHeaders = metadata.responseHeaders,
+            timestamp = timestamp,
+            eTag = metadata.eTag,
+            lastModified = metadata.lastModified
+        )
+    }
+
     private fun generateCacheKey(url: String): String {
         try {
             val md = MessageDigest.getInstance("SHA-256")

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

@@ -5,6 +5,8 @@ import android.webkit.WebView
 import io.yourname.androidproject.CatalystConstants
 import org.json.JSONObject
 import android.os.Looper
+import android.os.SystemClock
+import io.yourname.androidproject.BuildConfig
 
 /**
  * Common utilities for native bridge operations
@@ -95,11 +97,64 @@ object BridgeUtils {
         ON_TRANSITION_CANCELLED("ON_TRANSITION_CANCELLED"),
         ON_TRANSITION_TIMEOUT("ON_TRANSITION_TIMEOUT"),
 
+        // Perf telemetry
+        CATALYST_PERF_EVENT("CATALYST_PERF_EVENT"),
     }
     
+    /**
+     * Emit a performance event directly to WebPerfCollector via
+     * window.__catalystPerfEvent(). Bypasses the WebBridge callback system
+     * to keep perf overhead minimal — no JS parsing, no handler lookup.
+     *
+     * Must be called from any thread — posts to main thread automatically.
+     *
+     * @param webView The WebView instance
+     * @param payload JSONObject with at minimum a "type" field
+     */
+    fun emitPerfEvent(webView: WebView, payload: JSONObject) {
+        if (!PerfEventBuffer.isEnabled()) return
+        if (Looper.myLooper() != Looper.getMainLooper()) {
+            // Capture caller thread name before marshalling to main thread
+            if (!payload.has("emitThread")) {
+                payload.put("emitThread", Thread.currentThread().name)
+            }
+            webView.post { emitPerfEvent(webView, payload) }
+            return
+        }
+        try {
+            // Use JSON.parse inside the JS call so we never deal with quote escaping
+            val jsonStr = payload.toString().replace("\\", "\\\\").replace("'", "\\'")
+            webView.evaluateJavascript("window.__catalystPerfEvent && window.__catalystPerfEvent('$jsonStr')", null)
+        } catch (e: Exception) {
+            Log.e(TAG, "emitPerfEvent failed: ${e.message}")
+        }
+    }
+
+    /**
+     * Record that a @JavascriptInterface method was invoked (t0).
+     * Pair with bridgeCallDispatched() at notifyWeb() call site.
+     * No-op in release builds.
+     *
+     * @param callId  Unique identifier for this call (e.g. "getDeviceInfo:<timestamp>")
+     * @param method  Human-readable method name for ApiCollector.js
+     */
+    fun bridgeCallReceived(callId: String, method: String) {
+        if (!BuildConfig.DEBUG) return
+        PerfEventBuffer.bridgeCallReceived(callId, method)
+    }
+
+    /**
+     * Record that native dispatched the callback back to JS (t1).
+     * Must be called just before (or just after) notifyWeb().
+     */
+    fun bridgeCallDispatched(callId: String) {
+        if (!BuildConfig.DEBUG) return
+        PerfEventBuffer.bridgeCallDispatched(callId)
+    }
+
     /**
      * Send a callback to the web layer
-     * 
+     *
      * @param webView The WebView instance
      * @param event The web event to send
      * @param data The data to send (can be null)

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

@@ -2,27 +2,34 @@ package io.yourname.androidproject.utils
 
 import android.app.Activity
 import android.graphics.Rect
+import android.os.SystemClock
 import android.util.TypedValue
 import android.view.View
 import android.view.ViewGroup
 import android.view.ViewTreeObserver
+import android.webkit.WebView
 import androidx.constraintlayout.widget.ConstraintLayout
+import org.json.JSONObject
 
 class KeyboardUtil(
     private val activity: Activity,
-    private val webViewContainer: View
+    private val webViewContainer: View,
+    private val webView: WebView? = null,
 ) {
     private var originalHeight: Int = 0
     private var listener: ViewTreeObserver.OnGlobalLayoutListener? = null
-    
+
     // Keyboard detection threshold in dp - commonly used values are 120-150dp
     private val keyboardThresholdDp = 120f
-    
+
     // Calculate minimum keyboard height in pixels based on device density
     private val keyboardThresholdPx: Int by lazy {
         dpToPx(keyboardThresholdDp)
     }
-    
+
+    // Track keyboard state to avoid spamming events on every layout pass
+    private var keyboardVisible = false
+
     /**
      * Convert density-independent pixels to pixels
      */
@@ -33,7 +40,7 @@ class KeyboardUtil(
             activity.resources.displayMetrics
         ).toInt()
     }
-    
+
     /**
      * Convert pixels to density-independent pixels
      */
@@ -43,7 +50,7 @@ class KeyboardUtil(
 
     fun initialize() {
         val rootView = activity.findViewById<ViewGroup>(android.R.id.content)
-        
+
         webViewContainer.post {
             originalHeight = webViewContainer.height
         }
@@ -53,21 +60,33 @@ class KeyboardUtil(
             val screenHeight = activity.resources.displayMetrics.heightPixels
             val visibleHeight = rect.height()
             val keyboardHeight = screenHeight - visibleHeight
-            
+
             // Use density-independent threshold and consider screen size
             // Also add a minimum percentage of screen height as additional validation
             val minScreenPercentage = (screenHeight * 0.15).toInt() // 15% of screen height
             val effectiveThreshold = maxOf(keyboardThresholdPx, minScreenPercentage)
-            if (keyboardHeight > effectiveThreshold) {
+            val isNowVisible = keyboardHeight > effectiveThreshold
+
+            if (isNowVisible) {
                 // Keyboard visible - resize
                 val params = webViewContainer.layoutParams as ConstraintLayout.LayoutParams
                 params.height = originalHeight - keyboardHeight
                 webViewContainer.layoutParams = params
+
+                if (!keyboardVisible) {
+                    keyboardVisible = true
+                    emitKeyboardEvent("keyboard-show", keyboardHeight)
+                }
             } else {
                 // Keyboard hidden - restore
                 val params = webViewContainer.layoutParams as ConstraintLayout.LayoutParams
                 params.height = originalHeight
                 webViewContainer.layoutParams = params
+
+                if (keyboardVisible) {
+                    keyboardVisible = false
+                    emitKeyboardEvent("keyboard-hide", 0)
+                }
             }
         }
         rootView.viewTreeObserver.addOnGlobalLayoutListener(listener)
@@ -79,4 +98,25 @@ class KeyboardUtil(
             rootView.viewTreeObserver.removeOnGlobalLayoutListener(it)
         }
     }
+
+    // ─── Perf telemetry ──────────────────────────────────────────────────────
+
+    /**
+     * Emit keyboard show/hide event to WebPerfCollector.
+     * Uses SystemClock.elapsedRealtime() so the timestamp is alignable with
+     * native Perfetto traces via window.__NATIVE_TIME_OFFSET.
+     */
+    private fun emitKeyboardEvent(type: String, keyboardHeight: Int) {
+        val wv = webView ?: return
+        try {
+            val payload = JSONObject().apply {
+                put("type", type)
+                put("nativeTime", SystemClock.elapsedRealtime())
+                put("keyboardHeight", keyboardHeight)
+            }
+            BridgeUtils.emitPerfEvent(wv, payload)
+        } catch (e: Exception) {
+            // Non-critical — swallow silently
+        }
+    }
 }

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

@@ -0,0 +1,36 @@
+package io.yourname.androidproject.utils
+
+internal class PerfDeliveryState<T> {
+    data class Batch<T>(val id: String, val payload: T, val generation: Long, val retryCount: Int = 0)
+
+    private var generation = 0L
+    private var sequence = 0L
+    private var inFlight: Batch<T>? = null
+
+    fun hasInFlight(): Boolean = inFlight != null
+
+    fun current(): Batch<T>? = inFlight
+
+    fun begin(payload: T): Batch<T>? {
+        if (inFlight != null) return null
+        return Batch("catalyst-${++sequence}", payload, generation).also { inFlight = it }
+    }
+
+    fun isCurrent(batch: Batch<T>): Boolean = inFlight?.id == batch.id && batch.generation == generation
+
+    fun acknowledge(batch: Batch<T>): Boolean {
+        if (!isCurrent(batch)) return false
+        inFlight = null
+        return true
+    }
+
+    fun retry(batch: Batch<T>, maxRetries: Int): Batch<T>? {
+        if (!isCurrent(batch) || batch.retryCount >= maxRetries) return null
+        return batch.copy(retryCount = batch.retryCount + 1).also { inFlight = it }
+    }
+
+    fun reset() {
+        generation++
+        inFlight = null
+    }
+}