catalyst-core 0.0.3-canary.0 → 0.0.3-canary.1

package/README.md

@@ -14,7 +14,7 @@
 
 Catalyst offers a comprehensive suite of features designed for modern web development. It includes isomorphic rendering for optimal performance, an extendable server with full-stack capabilities, and configurable state management. The framework employs smart prefetching of data and chunks, allows easy configuration of global styles and layouts, and provides SEO optimization at both global and page levels.
 
-This version adds support for Universal app for both Android and iOS. Please checkout [Universal App Documentaion](https://catalyst.1mg.com/content/Universal%20App/RunUniversalApp)
+This version adds support for Universal app for both Android and iOS. Please checkout [Universal App Documentaion](https://catalyst.1mg.com/public_docs/content/Universal%20App/RunUniversalApp)
 
 
 ## Installation

package/changelog.md

@@ -1,9 +1,36 @@
 # Changelog
 
-## [0.0.3-canary.0] - 27-12-2024
+## [0.0.3-canary.1] - 31-01-2025
 
 ### Changes
 
-- Introduced initial universal app support for Android and iOS 
-- Introduced support for Catalyst build and run app for Android and iOS app
-- Updated webview configuration for enhanced performance 
+# Native WebView Implementation and Cache Management Updates
+
+## Overview
+This PR introduces native WebView implementations for both Android and iOS platforms, along with significant cache management improvements and bug fixes.
+
+## Changes
+
+### New Features
+- Implemented native Android WebView with cache management functionality
+- Added iOS native WebView implementation with custom cache handling
+- Introduced new cache pattern management system
+
+### Technical Implementation Details
+- Android:
+  - Added complete Android project structure with WebView implementation
+  - Implemented `WebCacheManager.kt` for handling cache operations
+  - Set up Gradle configuration and project dependencies
+
+- iOS:
+  - Created iOS native WebView project with Swift
+  - Implemented `CacheManager.swift` and `ResourceURLProtocol.swift` for cache handling
+  - Added WebView navigation and view model components
+
+
+### Other Changes
+- Enhanced terminal progress reporting
+- Updated documentation and README
+
+## Version
+- Target version: 0.0.3-canary.1

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

@@ -74,6 +74,7 @@ dependencies {
     androidTestImplementation(libs.androidx.junit)
     androidTestImplementation(libs.androidx.espresso.core)
     implementation("androidx.webkit:webkit:1.12.1")
+    implementation("org.json:json:20231013")
 }
 
 // Task to verify local IP
@@ -123,30 +124,42 @@ tasks.register("generateWebViewConfig") {
         )
 
         val configJsonFile = File(configJsonPath)
-
         if (!configJsonFile.exists()) {
             throw GradleException("Config file not found at: $configJsonPath")
         }
-        // Read the config file
-        val configContent = configJsonFile.readText()
-            .trim()
-            .removeSurrounding("{", "}")
 
-        // Parse config content
-        val configs = mutableMapOf<String, String>()
+        val configContent = configJsonFile.readText()
 
         // Extract WEBVIEW_CONFIG section
         val webviewConfigRegex = """"WEBVIEW_CONFIG"\s*:\s*\{([^}]*)\}""".toRegex()
         val webviewConfigMatch = webviewConfigRegex.find(configContent)
         val webviewConfigContent = webviewConfigMatch?.groupValues?.get(1)
 
-        // Parse WEBVIEW_CONFIG content if found
-        webviewConfigContent?.split(",")?.forEach { pair ->
-            val keyValue = pair.split(":", limit = 2)
-            if (keyValue.size == 2) {
-                val key = keyValue[0].trim().trim('"')
-                val value = keyValue[1].trim().trim('"')
-                configs[key] = value
+        val properties = Properties()
+        properties.setProperty("LOCAL_IP", getLocalIpAddress())
+
+        // Parse top-level properties
+        val topLevelRegex = """"([^"]+)"\s*:\s*"([^"]+)"""".toRegex()
+        webviewConfigContent?.let {
+            topLevelRegex.findAll(it).forEach { matchResult ->
+                val (key, value) = matchResult.destructured
+                if (key != "android") {
+                    properties.setProperty(key, value)
+                }
+            }
+        }
+
+        // Parse android object specifically
+        val androidRegex = """"android"\s*:\s*\{([^}]*)\}""".toRegex()
+        val androidMatch = androidRegex.find(webviewConfigContent ?: "")
+        val androidContent = androidMatch?.groupValues?.get(1)
+
+        // Parse android object properties
+        val androidPropsRegex = """"([^"]+)"\s*:\s*"([^"]+)"""".toRegex()
+        androidContent?.let {
+            androidPropsRegex.findAll(it).forEach { matchResult ->
+                val (key, value) = matchResult.destructured
+                properties.setProperty("android.$key", value)
             }
         }
 
@@ -157,18 +170,11 @@ tasks.register("generateWebViewConfig") {
             println("Created assets directory at ${assetsDir.absolutePath}")
         }
 
-        // Create and write to properties file
-        val properties = Properties()
-        properties.setProperty("LOCAL_IP", getLocalIpAddress())
-        configs.forEach { (key, value) ->
-            properties.setProperty(key, value)
-        }
-
+        // Write to properties file
         File(assetsDir, "webview_config.properties").outputStream().use {
             properties.store(it, "WebView Configuration")
         }
 
         println("WebView config generated at ${assetsDir.absolutePath}/webview_config.properties")
     }
-}
-
+}

package/dist/native/androidProject/app/src/main/java/com/example/myapplication/MainActivity.kt

@@ -16,6 +16,7 @@ import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.launch
 import kotlinx.coroutines.MainScope
 import kotlinx.coroutines.runBlocking
+import org.json.JSONObject
 import java.net.URL                 
 import java.net.HttpURLConnection
 
@@ -25,6 +26,15 @@ class MainActivity : AppCompatActivity(), CoroutineScope by MainScope() {
     private lateinit var binding: ActivityMainBinding
     private lateinit var myWebView: WebView
     private lateinit var cacheManager: WebCacheManager
+    private var buildType: String = "debug"  // Default to debug
+    private var cachePatterns: List<String> = emptyList()
+
+    data class AndroidConfig(
+        val buildType: String = "debug",
+        val cachePattern: String = "",
+        val emulatorName: String = "",
+        val sdkPath: String = ""
+    )
 
     override fun onCreate(savedInstanceState: Bundle?) {
         super.onCreate(savedInstanceState)
@@ -34,6 +44,30 @@ class MainActivity : AppCompatActivity(), CoroutineScope by MainScope() {
             properties.load(it)
         }
 
+        // Parse android config from JSON string
+        val androidConfigJson = properties.getProperty("android", "{}")
+        val androidConfig = try {
+            val jsonObject = JSONObject(androidConfigJson)
+            AndroidConfig(
+                buildType = jsonObject.optString("buildType", "debug"),
+                cachePattern = jsonObject.optString("cachePattern", ""),
+                emulatorName = jsonObject.optString("emulatorName", ""),
+                sdkPath = jsonObject.optString("sdkPath", "")
+            )
+        } catch (e: Exception) {
+            Log.e(TAG, "Error parsing android config", e)
+            AndroidConfig()
+        }
+        Log.d(TAG, "android config parsed: $androidConfig")
+        buildType = androidConfig.buildType
+        cachePatterns = androidConfig.cachePattern
+            .split(",")
+            .map { it.trim() }
+            .filter { it.isNotEmpty() }
+
+        Log.d(TAG, "Build type: $buildType")
+        Log.d(TAG, "Cache Pattern: $cachePatterns ")
+
         binding = ActivityMainBinding.inflate(layoutInflater)
         supportActionBar?.hide()
         setContentView(binding.root)
@@ -63,6 +97,24 @@ class MainActivity : AppCompatActivity(), CoroutineScope by MainScope() {
         makeRequest(loadUrl)
     }
 
+    private fun shouldCacheUrl(url: String): Boolean {
+        // If no patterns specified, don't cache anything
+        if (cachePatterns.isEmpty()) return false
+
+        // Convert the wildcard pattern to a regex pattern
+        fun String.wildcardToRegex(): String {
+            return this.replace(".", "\\.")  // Escape dots
+                .replace("*", ".*")   // Convert * to .*
+                .let { "^$it$" }      // Anchor pattern
+        }
+
+        // Check if URL matches any of the patterns
+        return cachePatterns.any { pattern ->
+            val regex = pattern.wildcardToRegex().toRegex(RegexOption.IGNORE_CASE)
+            regex.matches(url) || url.endsWith(pattern.removePrefix("*"))
+        }
+    }
+
     override fun onSaveInstanceState(outState: Bundle) {
         super.onSaveInstanceState(outState)
         myWebView.saveState(outState)
@@ -107,9 +159,14 @@ class MainActivity : AppCompatActivity(), CoroutineScope by MainScope() {
             ): WebResourceResponse? {
                 val originalUrl = request.url.toString()
                 Log.d(TAG, "Intercepting request for: $originalUrl")
-                return null
-                // Don't cache if it's not a GET request
-                if (request.method != "GET") {
+
+                if ( buildType == "debug" || request.method != "GET") {
+                    return null
+                }
+
+                // Check if URL matches patterns
+                if (!shouldCacheUrl(originalUrl)) {
+                    Log.d(TAG, "URL doesn't match cache patterns, skipping cache: $originalUrl")
                     return null
                 }
 
@@ -132,9 +189,7 @@ class MainActivity : AppCompatActivity(), CoroutineScope by MainScope() {
                             Log.d(TAG, "📱 Serving from cache: $originalUrl")
                             response
                         } else {
-                            // If not in cache, let WebView handle the request
-                            // The cacheManager will intercept and cache the response
-                            Log.d(TAG, "💾 Cache miss, fetching and caching: $originalUrl")
+                            Log.d(TAG, "Cache Manager unable to return response : $originalUrl")
                             null
                         }
                     } catch (e: Exception) {

package/dist/native/androidProject/app/src/main/java/com/example/myapplication/WebCacheManager.kt

@@ -15,11 +15,17 @@ class WebCacheManager(private val context: Context) {
     private val TAG = "WebCacheManager"
     private val cacheDir = File(context.cacheDir, "webview_cache")
     private val scope = CoroutineScope(Dispatchers.IO + SupervisorJob())
-    private val cacheExpiration = TimeUnit.HOURS.toMillis(24) // 24 hour cache
+
+    // Cache timing configurations
+    private val maxAge = TimeUnit.HOURS.toMillis(24) // Time until content becomes stale
+    private val staleWhileRevalidate = TimeUnit.HOURS.toMillis(1) // Additional time content can be served while revalidating
+
+    // Track ongoing revalidations to prevent duplicate requests
+    private val ongoingRevalidations = mutableSetOf<String>()
 
     // Memory cache
     private val memoryCache: LruCache<String, CacheEntry> = LruCache<String, CacheEntry>(
-        (Runtime.getRuntime().maxMemory() / 1024 / 8).toInt() // Use 1/8th of available memory
+        (Runtime.getRuntime().maxMemory() / 1024 / 8).toInt()
     )
 
     init {
@@ -28,81 +34,175 @@ class WebCacheManager(private val context: Context) {
 
     data class CacheEntry(
         val response: WebResourceResponse,
-        val timestamp: Long = System.currentTimeMillis()
+        val timestamp: Long = System.currentTimeMillis(),
+        val eTag: String? = null,
+        val lastModified: String? = null
     )
 
-    fun cleanup() {
-        scope.launch {
+    suspend fun getCachedResponse(url: String, headers: Map<String, String>): WebResourceResponse? =
+        withContext(Dispatchers.IO) {
             try {
+                val cacheKey = generateCacheKey(url)
                 val currentTime = System.currentTimeMillis()
-                // Clean memory cache
-                val keysToRemove = mutableListOf<String>()
-                for (key in memoryCache.snapshot().keys) {
-                    memoryCache.get(key)?.let { entry ->
-                        if (currentTime - entry.timestamp > cacheExpiration) {
-                            keysToRemove.add(key)
+
+                // Check memory cache first
+                val memoryCacheEntry = memoryCache.get(cacheKey)
+                if (memoryCacheEntry != null) {
+                    val age = currentTime - memoryCacheEntry.timestamp
+
+                    when {
+                        age <= maxAge -> {
+                            // Fresh content
+                            Log.d(TAG, "Serving fresh content from memory cache: $url")
+                            return@withContext memoryCacheEntry.response
+                        }
+                        age <= maxAge + staleWhileRevalidate -> {
+                            // Stale content, but within revalidate window
+                            Log.d(TAG, "Serving stale content while revalidating: $url")
+                            revalidateInBackground(url, headers, cacheKey, memoryCacheEntry)
+                            return@withContext memoryCacheEntry.response
                         }
                     }
                 }
-                keysToRemove.forEach { memoryCache.remove(it) }
 
-                // Clean disk cache
-                cacheDir.listFiles()?.forEach { file ->
-                    if (currentTime - file.lastModified() > cacheExpiration) {
-                        file.delete()
-                        File(cacheDir, "${file.nameWithoutExtension}.meta").delete()
+                // Check disk cache
+                val cacheFile = File(cacheDir, cacheKey)
+                if (cacheFile.exists()) {
+                    val fileAge = currentTime - cacheFile.lastModified()
+                    val metadata = loadMetadata(cacheKey)
+
+                    when {
+                        fileAge <= maxAge -> {
+                            // Fresh content from disk
+                            val response = createResponseFromCache(cacheFile, metadata)
+                            memoryCache.put(cacheKey, CacheEntry(response))
+                            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
+                            )
+                            revalidateInBackground(url, headers, cacheKey, cacheEntry)
+                            return@withContext response
+                        }
                     }
                 }
+
+                // No cache or cache too old, fetch fresh content
+                Log.d(TAG, "❌ Cache miss, fetching fresh content: $url")
+                fetchAndCacheResource(url, headers, cacheKey)
             } catch (e: Exception) {
-                Log.e(TAG, "Error during cleanup", e)
+                Log.e(TAG, "Error in getCachedResponse for URL: $url", e)
+                null
             }
         }
-    }
 
-    suspend fun getCachedResponse(url: String, headers: Map<String, String>): WebResourceResponse? =
+    suspend fun cleanup() {
         withContext(Dispatchers.IO) {
             try {
-                val cacheKey = generateCacheKey(url)
+                val currentTime = System.currentTimeMillis()
+                val maxCacheSize = 100 * 1024 * 1024 // 100MB max cache size
+                var totalSize = 0L
+
+                // Get all cache files sorted by last modified time (oldest first)
+                val cacheFiles = cacheDir.listFiles()?.sortedBy { it.lastModified() } ?: return@withContext
 
-                // Try memory cache first
-                memoryCache.get(cacheKey)?.let { entry ->
-                    if (!isCacheExpired(entry.timestamp)) {
-                        Log.d(TAG, "✅ Memory cache hit for: $url")
-                        return@withContext entry.response
-                    } else {
-                        memoryCache.remove(cacheKey)
+                for (file in cacheFiles) {
+                    val age = currentTime - file.lastModified()
+
+                    // Delete if expired (older than maxAge + staleWhileRevalidate)
+                    if (age > maxAge + staleWhileRevalidate) {
+                        file.delete()
+                        // Also delete corresponding metadata file if it exists
+                        val metaFile = File(cacheDir, "${file.name}.meta")
+                        if (metaFile.exists()) {
+                            metaFile.delete()
+                        }
+                        continue
                     }
+
+                    totalSize += file.length()
                 }
 
-                // Try disk cache
-                val cacheFile = File(cacheDir, cacheKey)
-                if (cacheFile.exists() && !isCacheExpired(cacheFile.lastModified())) {
-                    try {
-                        val metadata = loadMetadata(cacheKey)
-                        val response = WebResourceResponse(
-                            metadata.mimeType,
-                            metadata.encoding,
-                            BufferedInputStream(FileInputStream(cacheFile))
-                        )
-                        // Add to memory cache
-                        memoryCache.put(cacheKey, CacheEntry(response))
-                        Log.d(TAG, "✅ Disk cache hit for: $url")
-                        return@withContext response
-                    } catch (e: Exception) {
-                        Log.e(TAG, "Error reading from disk cache", e)
-                        cacheFile.delete() // Delete corrupted cache file
-                        File(cacheDir, "${cacheKey}.meta").delete()
+                // If cache is too large, remove oldest files until under limit
+                if (totalSize > maxCacheSize) {
+                    val sortedFiles = cacheDir.listFiles()?.sortedBy { it.lastModified() } ?: return@withContext
+                    for (file in sortedFiles) {
+                        if (totalSize <= maxCacheSize) break
+
+                        totalSize -= file.length()
+                        file.delete()
+                        // Delete corresponding metadata file
+                        val metaFile = File(cacheDir, "${file.name}.meta")
+                        if (metaFile.exists()) {
+                            metaFile.delete()
+                        }
                     }
                 }
 
-                // If not in cache, fetch and store
-                Log.d(TAG, "❌ Cache miss for: $url")
-                fetchAndCacheResource(url, headers, cacheKey)
+                Log.d(TAG, "Cache cleanup completed. Current size: ${totalSize / 1024}KB")
             } catch (e: Exception) {
-                Log.e(TAG, "Error in getCachedResponse for URL: $url", e)
-                null
+                Log.e(TAG, "Error during cache cleanup", e)
+            }
+        }
+    }
+
+    private fun revalidateInBackground(
+        url: String,
+        headers: Map<String, String>,
+        cacheKey: String,
+        cacheEntry: CacheEntry
+    ) {
+        if (!ongoingRevalidations.add(cacheKey)) {
+            // Revalidation already in progress
+            return
+        }
+
+        scope.launch {
+            try {
+                val revalidationHeaders = headers.toMutableMap()
+                cacheEntry.eTag?.let { revalidationHeaders["If-None-Match"] = it }
+                cacheEntry.lastModified?.let { revalidationHeaders["If-Modified-Since"] = it }
+
+                val connection = URL(url).openConnection() as HttpURLConnection
+                revalidationHeaders.forEach { (key, value) ->
+                    connection.setRequestProperty(key, value)
+                }
+
+                when (connection.responseCode) {
+                    HttpURLConnection.HTTP_NOT_MODIFIED -> {
+                        // Content still valid, update timestamp
+                        val updatedEntry = cacheEntry.copy(timestamp = System.currentTimeMillis())
+                        memoryCache.put(cacheKey, updatedEntry)
+                        updateCacheFileTimestamp(cacheKey)
+                        Log.d(TAG, "✅ Content revalidated, not modified: $url")
+                    }
+                    HttpURLConnection.HTTP_OK -> {
+                        // Content changed, update cache
+                        Log.d(TAG, "⚡ Content changed, updating cache: $url")
+                        fetchAndCacheResource(url, headers, cacheKey)
+                    }
+                }
+            } catch (e: Exception) {
+                Log.e(TAG, "Error during revalidation for URL: $url", e)
+            } finally {
+                ongoingRevalidations.remove(cacheKey)
             }
         }
+    }
+
+    private fun updateCacheFileTimestamp(cacheKey: String) {
+        val cacheFile = File(cacheDir, cacheKey)
+        if (cacheFile.exists()) {
+            cacheFile.setLastModified(System.currentTimeMillis())
+            File(cacheDir, "${cacheKey}.meta").setLastModified(System.currentTimeMillis())
+        }
+    }
 
     private suspend fun fetchAndCacheResource(
         url: String,
@@ -116,88 +216,98 @@ class WebCacheManager(private val context: Context) {
                 connection.setRequestProperty(key, value)
             }
 
-            connection.connectTimeout = 15000 // 15 seconds
-            connection.readTimeout = 15000 // 15 seconds
+            connection.connectTimeout = 15000
+            connection.readTimeout = 15000
             connection.connect()
 
-            val responseCode = connection.responseCode
-            Log.d(TAG, "Response code for $url: $responseCode")
-
-            if (responseCode == HttpURLConnection.HTTP_OK) {
+            if (connection.responseCode == HttpURLConnection.HTTP_OK) {
                 val mimeType = connection.contentType ?: "application/octet-stream"
                 val encoding = connection.contentEncoding ?: "utf-8"
+                val eTag = connection.getHeaderField("ETag")
+                val lastModified = connection.getHeaderField("Last-Modified")
 
-                // Read the response into memory
                 val responseBytes = connection.inputStream.use { it.readBytes() }
-                if (responseBytes.isEmpty()) {
-                    Log.e(TAG, "Empty response received for $url")
+                if (!isValidResponse(mimeType, responseBytes)) {
                     return@withContext null
                 }
 
-                // Create WebResourceResponse for immediate use
+                // Create response for immediate use
                 val response = WebResourceResponse(
                     mimeType,
                     encoding,
                     ByteArrayInputStream(responseBytes)
                 )
 
-                // Cache only if response is valid
-                if (isValidResponse(mimeType, responseBytes)) {
-                    // Save to memory cache
-                    memoryCache.put(cacheKey, CacheEntry(
-                        WebResourceResponse(
-                            mimeType,
-                            encoding,
-                            ByteArrayInputStream(responseBytes.clone())
-                        )
-                    ))
-
-                    // Save to disk cache asynchronously
-                    scope.launch {
-                        try {
-                            val cacheFile = File(cacheDir, cacheKey)
-                            FileOutputStream(cacheFile).use { fileOut ->
-                                fileOut.write(responseBytes)
-                            }
-                            saveMetadata(cacheKey, CacheMetadata(mimeType, encoding))
-                            Log.d(TAG, "✅ Successfully cached response for: $url")
-                        } catch (e: Exception) {
-                            Log.e(TAG, "Error saving to disk cache for URL: $url", e)
-                        }
+                // Cache the response
+                val cacheEntry = CacheEntry(
+                    response = WebResourceResponse(
+                        mimeType,
+                        encoding,
+                        ByteArrayInputStream(responseBytes.clone())
+                    ),
+                    eTag = eTag,
+                    lastModified = lastModified
+                )
+                memoryCache.put(cacheKey, cacheEntry)
+
+                // Save to disk cache
+                scope.launch {
+                    try {
+                        val cacheFile = File(cacheDir, cacheKey)
+                        FileOutputStream(cacheFile).use { it.write(responseBytes) }
+                        saveMetadata(cacheKey, CacheMetadata(
+                            mimeType = mimeType,
+                            encoding = encoding,
+                            eTag = eTag,
+                            lastModified = lastModified
+                        ))
+                        Log.d(TAG, "✅ Successfully cached response for: $url")
+                    } catch (e: Exception) {
+                        Log.e(TAG, "Error saving to disk cache for URL: $url", e)
                     }
-                } else {
-                    Log.d(TAG, "⚠️ Invalid response not cached for: $url")
                 }
 
                 return@withContext response
-            } else {
-                Log.e(TAG, "HTTP Error $responseCode for URL: $url")
-                return@withContext null
             }
-        } catch (e: Exception) {
-            Log.e(TAG, "Error fetching resource for URL: $url", e)
             return@withContext null
         } finally {
             connection?.disconnect()
         }
     }
 
+    private data class CacheMetadata(
+        val mimeType: String,
+        val encoding: String,
+        val eTag: String? = null,
+        val lastModified: String? = null
+    ) : Serializable
+
+    private fun createResponseFromCache(cacheFile: File, metadata: CacheMetadata): WebResourceResponse {
+        return WebResourceResponse(
+            metadata.mimeType,
+            metadata.encoding,
+            BufferedInputStream(FileInputStream(cacheFile))
+        )
+    }
+
+    private fun generateCacheKey(url: String): String {
+        val md = MessageDigest.getInstance("MD5")
+        val digest = md.digest(url.toByteArray())
+        return digest.joinToString("") { "%02x".format(it) }
+    }
+
     private fun isValidResponse(mimeType: String, responseBytes: ByteArray): Boolean {
         return try {
-            // Check if response is not empty
             if (responseBytes.isEmpty()) return false
-
-            // Check if mime type is valid
             if (mimeType.isEmpty()) return false
 
-            // For text-based responses, check if it's valid text
             if (mimeType.startsWith("text/") ||
                 mimeType.contains("json") ||
-                mimeType.contains("javascript")) {
+                mimeType.contains("javascript")
+            ) {
                 val content = String(responseBytes)
                 if (content.isBlank()) return false
             }
-
             true
         } catch (e: Exception) {
             Log.e(TAG, "Error validating response", e)
@@ -205,21 +315,6 @@ class WebCacheManager(private val context: Context) {
         }
     }
 
-    private fun generateCacheKey(url: String): String {
-        val md = MessageDigest.getInstance("MD5")
-        val digest = md.digest(url.toByteArray())
-        return digest.joinToString("") { "%02x".format(it) }
-    }
-
-    private fun isCacheExpired(timestamp: Long): Boolean {
-        return System.currentTimeMillis() - timestamp > cacheExpiration
-    }
-
-    private data class CacheMetadata(
-        val mimeType: String,
-        val encoding: String
-    ) : Serializable
-
     private fun saveMetadata(cacheKey: String, metadata: CacheMetadata) {
         val metadataFile = File(cacheDir, "${cacheKey}.meta")
         ObjectOutputStream(FileOutputStream(metadataFile)).use {
@@ -233,4 +328,4 @@ class WebCacheManager(private val context: Context) {
             it.readObject() as CacheMetadata
         }
     }
-}
+}