catalyst-core-internal 0.0.1-beta.47 → 0.0.1-beta.49

package/dist/native/androidProject/app/src/main/AndroidManifest.xml

@@ -1,28 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<manifest xmlns:android="http://schemas.android.com/apk/res/android"
-    xmlns:tools="http://schemas.android.com/tools">
-    <uses-permission android:name="android.permission.INTERNET" />
-    <uses-permission android:name="android.permission.ACCESS_NETWORK_STATE" />
-    <application
-        android:usesCleartextTraffic="${allowCleartextTraffic}"
-        android:allowBackup="true"
-        android:dataExtractionRules="@xml/data_extraction_rules"
-        android:fullBackupContent="@xml/backup_rules"
-        android:icon="@mipmap/ic_launcher"
-        android:label="@string/app_name"
-        android:roundIcon="@mipmap/ic_launcher_round"
-        android:supportsRtl="true"
-        android:theme="@style/Theme.AndroidProject"
-        tools:targetApi="31">
-        <activity
-            android:name=".MainActivity"
-            android:exported="true">
-            <intent-filter>
-                <action android:name="android.intent.action.MAIN" />
-
-                <category android:name="android.intent.category.LAUNCHER" />
-            </intent-filter>
-        </activity>
-    </application>
-
-</manifest>

package/dist/native/androidProject/app/src/main/assets/webview_config.properties

@@ -1,10 +0,0 @@
-#WebView Configuration
-#Mon Dec 16 17:25:39 IST 2024
-LOCAL_IP=192.168.0.100
-android={\n      "projectPath"\: "./androidProject
-buildCommands={\n        "debug"\: "./gradlew assembleDebug
-buildType=debug
-domain=192.168.0.100
-port=3005
-release=./gradlew assembleRelease
-url=http\://192.168.0.100\:3005

package/dist/native/androidProject/app/src/main/cpp/CMakeLists.txt

@@ -1,41 +0,0 @@
-# For more information about using CMake with Android Studio, read the
-# documentation: https://d.android.com/studio/projects/add-native-code.html.
-# For more examples on how to use CMake, see https://github.com/android/ndk-samples.
-
-# Sets the minimum CMake version required for this project.
-cmake_minimum_required(VERSION 3.22.1)
-
-# Declares the project name. The project name can be accessed via ${ PROJECT_NAME},
-# Since this is the top level CMakeLists.txt, the project name is also accessible
-# with ${CMAKE_PROJECT_NAME} (both CMake variables are in-sync within the top level
-# build script scope).
-project("androidProject")
-
-# Creates and names a library, sets it as either STATIC
-# or SHARED, and provides the relative paths to its source code.
-# You can define multiple libraries, and CMake builds them for you.
-# Gradle automatically packages shared libraries with your APK.
-#
-# In this top level CMakeLists.txt, ${CMAKE_PROJECT_NAME} is used to define
-# the target library name; in the sub-module's CMakeLists.txt, ${PROJECT_NAME}
-# is preferred for the same purpose.
-#
-# In order to load a library into your app from Java/Kotlin, you must call
-# System.loadLibrary() and pass the name of the library defined here;
-# for GameActivity/NativeActivity derived applications, the same library name must be
-# used in the AndroidManifest.xml file.
-add_library(native-lib SHARED
-        # List C/C++ source files with relative paths to this CMakeLists.txt.
-        native-lib.cpp)
-
-find_library(
-        log-lib
-        log)
-
-# Specifies libraries CMake should link to your target library. You
-# can link libraries from various origins, such as libraries defined in this
-# build script, prebuilt third-party libraries, or Android system libraries.
-target_link_libraries(native-lib
-        # List libraries link to the target library
-        android
-        log)

package/dist/native/androidProject/app/src/main/cpp/native-lib.cpp

@@ -1,22 +0,0 @@
-#include <jni.h>
-#include <string>
-
-extern "C" JNIEXPORT void JNICALL
-Java_com_example_androidnativewebview_MainActivity_loadWebViewFromNative(
-        JNIEnv* env,
-        jobject thiz,
-        jobject webView,
-        jstring url
-){
-//    jclass activityClass = env->GetObjectClass(thiz);
-    jclass  webViewInstance = env->GetObjectClass(webView);
-
-    jmethodID loadUrlMethod = env->GetMethodID(webViewInstance, "loadUrl", "(Ljava/lang/String;)V");
-//    jstring url = env->NewStringUTF("http://20.20.0.111:3005");
-    // Get the method ID for the Java method that creates and loads the WebView
-//    jmethodID loadWebViewMethod = env->GetMethodID(activityClass, "loadWebView", "(Ljava/lang/String;)V");
-
-    // Call the Java method
-    env->CallVoidMethod(webView, loadUrlMethod, url);
-}
-

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

@@ -1,223 +0,0 @@
-package com.example.androidProject
-
-import android.annotation.SuppressLint
-import android.graphics.Bitmap
-import android.os.Bundle
-import android.util.Log
-import android.view.View
-import android.webkit.*
-import androidx.appcompat.app.AppCompatActivity
-import androidx.webkit.WebViewAssetLoader
-import java.util.Properties
-import com.example.androidProject.databinding.ActivityMainBinding
-import com.example.myapplication.WebCacheManager
-import kotlinx.coroutines.CoroutineScope
-import kotlinx.coroutines.Dispatchers
-import kotlinx.coroutines.launch
-import kotlinx.coroutines.MainScope
-import kotlinx.coroutines.runBlocking
-import java.net.URL                 
-import java.net.HttpURLConnection
-
-class MainActivity : AppCompatActivity(), CoroutineScope by MainScope() {
-
-    private val TAG = "WebViewDebug"
-    private lateinit var binding: ActivityMainBinding
-    private lateinit var myWebView: WebView
-    private lateinit var cacheManager: WebCacheManager
-
-    override fun onCreate(savedInstanceState: Bundle?) {
-        super.onCreate(savedInstanceState)
-
-        val properties = Properties()
-        assets.open("webview_config.properties").use {
-            properties.load(it)
-        }
-
-        binding = ActivityMainBinding.inflate(layoutInflater)
-        supportActionBar?.hide()
-        setContentView(binding.root)
-
-        cacheManager = WebCacheManager(applicationContext)
-
-        // Clean up expired cache entries
-        launch(Dispatchers.IO) {
-            cacheManager.cleanup()
-        }
-
-        myWebView = binding.webview
-
-        // Clear any existing WebView data if this is a fresh start
-        if (savedInstanceState == null) {
-            myWebView.clearCache(false) // false means we keep files marked as "cache-control: no-cache"
-            myWebView.clearHistory()
-        } else {
-            myWebView.restoreState(savedInstanceState)
-        }
-
-        setupWebView(properties)
-
-        val local_ip = properties.getProperty("LOCAL_IP" , "localhost")
-        val port = properties.getProperty("port" , "3005")
-        val loadUrl = "http://$local_ip:$port"
-        makeRequest(loadUrl)
-    }
-
-    override fun onSaveInstanceState(outState: Bundle) {
-        super.onSaveInstanceState(outState)
-        myWebView.saveState(outState)
-    }
-
-    @SuppressLint("SetJavaScriptEnabled")
-    private fun setupWebView(properties: Properties) {
-        myWebView.settings.apply {
-            javaScriptEnabled = true
-            loadsImagesAutomatically = true
-            mixedContentMode = if (BuildConfig.ALLOW_MIXED_CONTENT) {
-                WebSettings.MIXED_CONTENT_ALWAYS_ALLOW
-            } else {
-                WebSettings.MIXED_CONTENT_NEVER_ALLOW
-            }
-
-            // Enable standard caching
-            cacheMode = WebSettings.LOAD_DEFAULT // This will use both RAM and disk cache
-            databaseEnabled = true
-            domStorageEnabled = true
-
-            // Enable file access
-            allowFileAccess = true
-            allowContentAccess = true
-        }
-
-        myWebView.webViewClient = object : WebViewClient() {
-
-            override fun shouldOverrideUrlLoading(view: WebView?, request: WebResourceRequest?): Boolean {
-                request?.url?.let { url ->
-                    if (url.scheme in listOf("http", "https")) {
-                        view?.loadUrl(url.toString())
-                        return true
-                    }
-                }
-                return false
-            }
-
-            override fun shouldInterceptRequest(
-                view: WebView,
-                request: WebResourceRequest
-            ): 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") {
-                    return null
-                }
-
-                return runBlocking {
-                    try {
-                        // Add cache control headers
-                        val headers = request.requestHeaders.toMutableMap().apply {
-                            if (!containsKey("Cache-Control")) {
-                                put("Cache-Control", "max-age=86400") // 24 hours
-                            }
-                            if (!containsKey("Pragma")) {
-                                put("Pragma", "cache")
-                            }
-                        }
-
-                        // Try to get from cache first
-                        var response = cacheManager.getCachedResponse(originalUrl, headers)
-
-                        if (response != null) {
-                            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")
-                            null
-                        }
-                    } catch (e: Exception) {
-                        Log.e(TAG, "❌ Error processing request for URL: $originalUrl", e)
-                        e.printStackTrace()
-                        null
-                    }
-                }
-            }
-
-            override fun onPageStarted(view: WebView?, url: String?, favicon: Bitmap?) {
-                super.onPageStarted(view, url, favicon)
-                binding.progress.visibility = View.VISIBLE
-                Log.d(TAG, "⏳ Page started loading: $url")
-            }
-
-            override fun onPageFinished(view: WebView?, url: String?) {
-                binding.progress.visibility = View.GONE
-                Log.d(TAG, "✅ Page finished loading: $url")
-                // Save to WebView's back/forward list
-                view?.clearHistory()
-                view?.saveState(Bundle())
-                super.onPageFinished(view, url)
-            }
-
-            override fun onReceivedError(view: WebView?, request: WebResourceRequest?, error: WebResourceError?) {
-                error?.let {
-                    Log.e(TAG, "❌ Error loading ${request?.url}: ${it.errorCode} ${it.description}")
-                }
-                super.onReceivedError(view, request, error)
-            }
-        }
-
-        myWebView.webChromeClient = object : WebChromeClient() {
-            override fun onProgressChanged(view: WebView, progress: Int) {
-                binding.progress.progress = progress
-                if (progress == 100) {
-                    binding.progress.visibility = View.GONE
-                }
-            }
-
-            override fun onConsoleMessage(consoleMessage: ConsoleMessage?): Boolean {
-                Log.d(TAG, "Console: ${consoleMessage?.message()} -- From line ${consoleMessage?.lineNumber()} of ${consoleMessage?.sourceId()}")
-                return true
-            }
-        }
-
-        WebView.setWebContentsDebuggingEnabled(true)
-    }
-
-    private fun makeRequest(url: String?) {
-        binding.webview.scrollBarStyle = View.SCROLLBARS_INSIDE_OVERLAY
-        url?.let { myWebView.loadUrl(it) }
-    }
-
-    override fun onBackPressed() {
-        if (myWebView.canGoBack()) {
-            myWebView.goBack()
-        } else {
-            super.onBackPressed()
-        }
-    }
-
-    override fun onPause() {
-        super.onPause()
-        myWebView.onPause()
-    }
-
-    override fun onResume() {
-        super.onResume()
-        myWebView.onResume()
-    }
-
-    override fun onDestroy() {
-        super.onDestroy()
-        myWebView.destroy()
-    }
-
-//    external fun stringFromJNI(): String
-
-//    companion object {
-//        init {
-//            System.loadLibrary("native-lib")
-//        }
-//    }
-}

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

@@ -1,236 +0,0 @@
-package com.example.myapplication
-
-import android.content.Context
-import android.util.Log
-import android.util.LruCache
-import android.webkit.WebResourceResponse
-import kotlinx.coroutines.*
-import java.io.*
-import java.net.HttpURLConnection
-import java.net.URL
-import java.security.MessageDigest
-import java.util.concurrent.TimeUnit
-
-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
-
-    // Memory cache
-    private val memoryCache: LruCache<String, CacheEntry> = LruCache<String, CacheEntry>(
-        (Runtime.getRuntime().maxMemory() / 1024 / 8).toInt() // Use 1/8th of available memory
-    )
-
-    init {
-        cacheDir.mkdirs()
-    }
-
-    data class CacheEntry(
-        val response: WebResourceResponse,
-        val timestamp: Long = System.currentTimeMillis()
-    )
-
-    fun cleanup() {
-        scope.launch {
-            try {
-                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)
-                        }
-                    }
-                }
-                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()
-                    }
-                }
-            } catch (e: Exception) {
-                Log.e(TAG, "Error during cleanup", e)
-            }
-        }
-    }
-
-    suspend fun getCachedResponse(url: String, headers: Map<String, String>): WebResourceResponse? =
-        withContext(Dispatchers.IO) {
-            try {
-                val cacheKey = generateCacheKey(url)
-
-                // 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)
-                    }
-                }
-
-                // 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 not in cache, fetch and store
-                Log.d(TAG, "❌ Cache miss for: $url")
-                fetchAndCacheResource(url, headers, cacheKey)
-            } catch (e: Exception) {
-                Log.e(TAG, "Error in getCachedResponse for URL: $url", e)
-                null
-            }
-        }
-
-    private suspend fun fetchAndCacheResource(
-        url: String,
-        headers: Map<String, String>,
-        cacheKey: String
-    ): WebResourceResponse? = withContext(Dispatchers.IO) {
-        var connection: HttpURLConnection? = null
-        try {
-            connection = URL(url).openConnection() as HttpURLConnection
-            headers.forEach { (key, value) ->
-                connection.setRequestProperty(key, value)
-            }
-
-            connection.connectTimeout = 15000 // 15 seconds
-            connection.readTimeout = 15000 // 15 seconds
-            connection.connect()
-
-            val responseCode = connection.responseCode
-            Log.d(TAG, "Response code for $url: $responseCode")
-
-            if (responseCode == HttpURLConnection.HTTP_OK) {
-                val mimeType = connection.contentType ?: "application/octet-stream"
-                val encoding = connection.contentEncoding ?: "utf-8"
-
-                // Read the response into memory
-                val responseBytes = connection.inputStream.use { it.readBytes() }
-                if (responseBytes.isEmpty()) {
-                    Log.e(TAG, "Empty response received for $url")
-                    return@withContext null
-                }
-
-                // Create WebResourceResponse 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)
-                        }
-                    }
-                } 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 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")) {
-                val content = String(responseBytes)
-                if (content.isBlank()) return false
-            }
-
-            true
-        } catch (e: Exception) {
-            Log.e(TAG, "Error validating response", e)
-            false
-        }
-    }
-
-    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 {
-            it.writeObject(metadata)
-        }
-    }
-
-    private fun loadMetadata(cacheKey: String): CacheMetadata {
-        val metadataFile = File(cacheDir, "${cacheKey}.meta")
-        return ObjectInputStream(FileInputStream(metadataFile)).use {
-            it.readObject() as CacheMetadata
-        }
-    }
-}