pakstr 0.3.3 → 0.4.0

package/android-template/app/src/main/java/com/pakstr/app/ShellRuntime.kt

@@ -26,6 +26,12 @@ class ShellRuntime(
 
     fun start() {
 
+        AppDebugLogger.log(
+            context,
+            "RUNTIME",
+            "Starting ShellRuntime"
+        )
+
         controller = WebViewController(
             context,
             webView,
@@ -34,14 +40,28 @@ class ShellRuntime(
             permissionHandler
         )
 
+        AppDebugLogger.log(
+            context,
+            "RUNTIME",
+            "WebViewController created"
+        )
+
+
         CoroutineScope(Dispatchers.IO).launch {
 
+            AppDebugLogger.log(
+                context,
+                "RUNTIME",
+                "Starting background initialization"
+            )
+
             val ok = startServer()
 
 
             if (!ok) {
 
-                AppDebugLogger.log(
+                AppDebugLogger.error(
+                    context,
                     "RUNTIME",
                     "Server failed"
                 )
@@ -51,22 +71,53 @@ class ShellRuntime(
             }
 
 
+            AppDebugLogger.log(
+                context,
+                "RUNTIME",
+                "Server ready, switching to main thread"
+            )
+
+
             withContext(Dispatchers.Main) {
 
+                AppDebugLogger.log(
+                    context,
+                    "WEBVIEW",
+                    "Setting up WebView controller"
+                )
+
                 controller.setup()
 
+                AppDebugLogger.log(
+                    context,
+                    "WEBVIEW",
+                    "WebView controller setup completed"
+                )
+
             }
 
         }
 
     }
 
-
     private fun startServer(): Boolean {
 
-        if (server != null)
+        if (server != null) {
+
+            AppDebugLogger.log(
+
+                context,
+
+                "SERVER",
+
+                "Already running"
+
+            )
+
             return true
 
+        }
+
         return try {
 
             server = LocalServer(
@@ -80,32 +131,72 @@ class ShellRuntime(
             )
 
             AppDebugLogger.log(
+
+                context,
+
                 "SERVER",
-                "Started OK"
+
+                "Starting NanoHTTPD on port $port"
+
             )
 
             true
 
         } catch (e: Exception) {
 
-            AppDebugLogger.log(
+            AppDebugLogger.error(
+
+                context,
+
                 "SERVER",
-                "Failed to start: ${e.message}"
+
+                "Failed to start",
+
+                e
+
             )
 
             false
         }
     }
 
-
     fun stop() {
 
+        AppDebugLogger.log(
+
+            context,
+
+            "RUNTIME",
+
+            "Stopping ShellRuntime"
+
+        )
+
         server?.stop()
 
+        AppDebugLogger.log(
+
+            context,
+
+            "SERVER",
+
+            "Server stopped"
+
+        )
+
         controller.destroy()
 
-    }
+        AppDebugLogger.log(
+
+            context,
+
+            "WEBVIEW",
 
+            "WebView destroyed"
+
+        )
+
+    }
 
     fun getWebview(): WebView {
 

package/android-template/app/src/main/java/com/pakstr/app/WebViewController.kt

@@ -43,6 +43,7 @@ class WebViewController(
     private val loadRunnable = Runnable {
         webView.loadUrl("http://127.0.0.1:$port/")
         //webView.loadUrl("https://sigit.io")
+        //webView.loadUrl("http://127.0.0.1:$port/not-found.html")
     }
 
     private var nip07Injected = false
@@ -73,23 +74,116 @@ class WebViewController(
                 displayZoomControls = false
 
                 mixedContentMode = android.webkit.WebSettings.MIXED_CONTENT_NEVER_ALLOW
+
+                // Better mobile rendering
+                useWideViewPort = true
+                loadWithOverviewMode = true
+                textZoom = 100
             }
 
             // Standard clients are enough since overriding URL loading isn't required
             webViewClient = object : WebViewClient() {
 
                 override fun onPageFinished(
-                    view: WebView?,
-                    url: String?
+                    view: WebView?, url: String?
                 ) {
                     super.onPageFinished(view, url)
 
                     hideLoader()
 
                     if (!nip07Injected) {
-                        nip07Injected =
-                            injectNip07()
+                        nip07Injected = injectNip07()
+
+                    }
+                }
+
+                override fun onReceivedHttpError(
+
+                    view: WebView?,
+
+                    request: WebResourceRequest?,
+
+                    errorResponse: WebResourceResponse?
+
+                ) {
+
+                    super.onReceivedHttpError(
+
+                        view,
+
+                        request,
+
+                        errorResponse
+
+                    )
+
+                    val url =
+
+                        request?.url?.toString()
+
+                            ?: return
 
+                    if (url.endsWith("favicon.ico")) {
+
+                        return
+
+                    }
+                    if (AppDebugLogger.isWebViewLoggingEnabled(context)) {
+                        AppDebugLogger.error(
+
+                            context,
+
+                            "WEBVIEW",
+
+                            "HTTP error: $url status=${errorResponse?.statusCode}"
+
+                        )
+                    }
+                }
+
+                override fun onReceivedError(
+
+                    view: WebView?,
+
+                    request: WebResourceRequest?,
+
+                    error: android.webkit.WebResourceError?
+
+                ) {
+
+                    super.onReceivedError(
+
+                        view,
+
+                        request,
+
+                        error
+
+                    )
+
+                    val url =
+
+                        request?.url?.toString()
+
+                            ?: "unknown"
+
+                    val message =
+
+                        error?.description
+
+                            ?.toString()
+
+                            ?: "unknown error"
+                    if (AppDebugLogger.isWebViewLoggingEnabled(context)) {
+                        AppDebugLogger.error(
+
+                            context,
+
+                            "WEBVIEW",
+
+                            "Load error: $url - $message"
+
+                        )
                     }
                 }
 
@@ -105,22 +199,60 @@ class WebViewController(
                 }
 
                 override fun shouldOverrideUrlLoading(
-                    view: WebView?,
-                    request: WebResourceRequest?
+                    view: WebView?, request: WebResourceRequest?
                 ): Boolean {
                     val url = request?.url ?: return true
                     return url.host != "127.0.0.1"
                 }
 
-
             }
             webChromeClient = object : WebChromeClient() {
 
-                override fun onPermissionRequest(request: PermissionRequest) {
+                override fun onPermissionRequest(
+
+                    request: PermissionRequest
+
+                ) {
 
                     permissionHandler.onPermissionRequest(request)
 
                 }
+
+                override fun onConsoleMessage(
+
+                    consoleMessage: android.webkit.ConsoleMessage
+
+                ): Boolean {
+
+                    val level =
+
+                        when (consoleMessage.messageLevel()) {
+
+                            android.webkit.ConsoleMessage.MessageLevel.ERROR -> "ERROR"
+
+                            android.webkit.ConsoleMessage.MessageLevel.WARNING -> "WARN"
+
+                            android.webkit.ConsoleMessage.MessageLevel.LOG -> "LOG"
+
+                            else -> "DEBUG"
+                        }
+                    if (AppDebugLogger.isWebViewLoggingEnabled(context)) {
+                        AppDebugLogger.log(
+
+                            context,
+
+                            "WEBVIEW",
+
+                            "$level: ${consoleMessage.message()} " +
+
+                                    "(${consoleMessage.sourceId()}:${consoleMessage.lineNumber()})"
+
+                        )
+                    }
+                    return true
+
+                }
+
             }
         }
 
@@ -134,7 +266,7 @@ class WebViewController(
 
                 webView = webView,
 
-            ),
+                ),
 
             "AndroidBridge"
 
@@ -194,22 +326,20 @@ class WebViewController(
     private fun injectNip07(): Boolean {
 
         return try {
-            val js =
-                context.assets
-                    .open("nip07.js")
-                    .bufferedReader()
-                    .readText()
+            val js = context.assets.open("nip07.js")
+                .bufferedReader()
+                .readText()
 
             webView.evaluateJavascript(
-                js,
-                null
+                js, null
             )
             true
         } catch (e: Exception) {
-            AppDebugLogger.log(
-                "WEBVIEW",
-                "Failed loading nip07.js: ${e.message}"
-            )
+            if (AppDebugLogger.isWebViewLoggingEnabled(context)) {
+                AppDebugLogger.log(
+                    context, "WebViewController - WEBVIEW", "Failed loading nip07.js: ${e.message}"
+                )
+            }
             false
         }
     }

package/android-template/app/src/main/java/com/pakstr/app/crypto/Bip340Verifier.kt

@@ -146,11 +146,6 @@ object Bip340Verifier {
 
         } catch (e: Exception) {
 
-            AppDebugLogger.log(
-                "BIP340",
-                "Verification failed: ${e.message}"
-            )
-
             false
 
         }

package/android-template/app/src/main/java/com/pakstr/app/debug/AppDebugLogger.kt

@@ -1,21 +1,293 @@
 package com.pakstr.app.debug
 
+import android.content.Context
 import android.util.Log
 import com.pakstr.app.BuildConfig
+import com.pakstr.app.RuntimeConfig
+import java.text.SimpleDateFormat
+import java.util.Date
+import java.util.Locale
 
 object AppDebugLogger {
 
+    private const val TAG = "PakstrDebug"
+
+    private const val MAX_LOGS = 500
+
+    private val logs =
+        mutableListOf<String>()
+
     fun log(
+        context: Context,
         tag: String,
         message: String
     ) {
 
-        if (BuildConfig.DEBUG) {
+        if (!isDebugEnabled(context)) {
+            return
+        }
 
-            Log.d(
-                tag,
+        save(
+            context,
+            "DEBUG",
+            tag,
+            message
+        )
+
+        Log.d(
+            TAG,
+            "[$tag] $message"
+        )
+    }
+
+    fun error(
+        context: Context,
+        tag: String,
+        message: String,
+        throwable: Throwable? = null
+    ) {
+        if (!isDebugEnabled(context)) {
+            return
+        }
+        val fullMessage =
+            if (throwable != null) {
+                "$message\n${Log.getStackTraceString(throwable)}"
+            } else {
                 message
+            }
+
+
+        save(
+            context,
+            "ERROR",
+            tag,
+            fullMessage
+        )
+
+
+        Log.e(
+            TAG,
+            "[$tag] $message",
+            throwable
+        )
+    }
+
+    private fun save(
+        context: Context,
+        level: String,
+        tag: String,
+        message: String
+    ) {
+
+        val sanitized =
+            sanitize(message)
+
+        val entry =
+            format(
+                level,
+                tag,
+                sanitized
             )
+
+
+        logs.add(entry)
+
+
+        DebugLogStorage.append(
+            context,
+            entry
+        )
+
+
+        trim()
+    }
+
+    fun getLogs(): List<String> {
+
+        return logs.toList()
+
+    }
+
+    fun clear() {
+
+        logs.clear()
+
+    }
+
+    private fun isDebugEnabled(
+
+        context: Context
+
+    ): Boolean {
+
+        return BuildConfig.DEBUG ||
+
+                config(context).enabled
+
+    }
+
+    private fun sanitize(
+        message: String
+    ): String {
+
+        // Debug build može vidjeti sve
+        if (BuildConfig.DEBUG) {
+            return message
         }
+
+        // Release build uvijek sanitizira
+        return message
+            .replace(
+                Regex(
+                    "\"plaintext\"\\s*:\\s*\".*?\""
+                ),
+                "\"plaintext\":\"***\""
+            )
+            .replace(
+                Regex(
+                    "\"ciphertext\"\\s*:\\s*\".*?\""
+                ),
+                "\"ciphertext\":\"***\""
+            )
+            .replace(
+                Regex(
+                    "\"sig\"\\s*:\\s*\".*?\""
+                ),
+                "\"sig\":\"***\""
+            )
+            .replace(
+                Regex(
+                    "\"event\"\\s*:\\s*\".*?\""
+                ),
+                "\"event\":\"***\""
+            )
+            .replace(
+                Regex(
+                    "(?i)authorization: .*"
+                ),
+                "authorization: ***"
+            )
+            .replace(
+                Regex(
+                    "(?i)bearer\\s+[A-Za-z0-9._-]+"
+                ),
+                "Bearer ***"
+            )
+            .replace(
+                Regex(
+                    "(?i)token=[^\\s&]+"
+                ),
+                "token=***"
+            )
+            .replace(
+                Regex(
+                    "(?i)password=[^\\s&]+"
+                ),
+                "password=***"
+            )
+    }
+
+    private fun format(
+        level: String,
+        tag: String,
+        message: String
+    ): String {
+
+        val time =
+            SimpleDateFormat(
+                "yyyy-MM-dd HH:mm:ss",
+                Locale.US
+            )
+                .format(Date())
+
+
+        return "$time [$level] $tag: $message"
+
+    }
+
+    private fun trim() {
+
+        while (logs.size > MAX_LOGS) {
+
+            logs.removeAt(0)
+
+        }
+
+    }
+
+    private fun isDevelopmentBuild(): Boolean {
+        return BuildConfig.DEBUG
+    }
+
+    private fun isProductionDebug(context: Context): Boolean {
+        return !BuildConfig.DEBUG &&
+                RuntimeConfig.debugEnabled(context)
+    }
+
+    fun isNetworkLoggingEnabled(
+
+        context: Context
+
+    ): Boolean {
+
+        return BuildConfig.DEBUG ||
+
+                config(context).networkLogs
+
+    }
+
+    fun isWebViewLoggingEnabled(
+
+        context: Context
+
+    ): Boolean {
+
+        return BuildConfig.DEBUG ||
+
+                config(context).webViewLogs
+
+    }
+
+    fun network(
+        context: Context,
+        message: String
+    ) {
+        if (!isNetworkLoggingEnabled(context)) {
+            return
+        }
+
+        log(
+            context,
+            "HTTP",
+            message
+        )
+    }
+
+
+    fun webView(
+        context: Context,
+        message: String
+    ) {
+        if (!isWebViewLoggingEnabled(context)) {
+            return
+        }
+
+        log(
+            context,
+            "WEBVIEW",
+            message
+        )
+    }
+
+    private fun config(
+
+        context: Context
+
+    ): DebugConfig {
+
+        return DebugRuntimeOverride.get()
+
+            ?: RuntimeConfig.debugConfig(context)
+
     }
 }