pakstr 0.3.4 → 0.5.0

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
@@ -84,18 +85,107 @@ class WebViewController(
             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()
 
                     }
+                    injectDebugLogger()
+                }
+
+                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"
+
+                        )
+                    }
                 }
 
                 override fun shouldInterceptRequest(
@@ -110,22 +200,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
+
+                }
+
             }
         }
 
@@ -139,7 +267,7 @@ class WebViewController(
 
                 webView = webView,
 
-            ),
+                ),
 
             "AndroidBridge"
 
@@ -199,23 +327,155 @@ 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
         }
     }
+
+    private fun injectDebugLogger() {
+
+        val js = """
+        (function(){
+
+            if (!window.AndroidBridge) {
+                return;
+            }
+
+
+            const oldLog = console.log;
+            const oldWarn = console.warn;
+            const oldError = console.error;
+
+
+            function send(level, args){
+
+                try {
+
+                    const message =
+                        Array.from(args)
+                        .map(item => {
+
+                            if(typeof item === 'object'){
+                                return JSON.stringify(item);
+                            }
+
+                            return String(item);
+
+                        })
+                        .join(" ");
+
+                    window.AndroidBridge.debugLog(
+                        level,
+                        message
+                    );
+
+                } catch(e){
+
+                }
+            }
+
+
+            console.log = function(){
+
+                send(
+                    "LOG",
+                    arguments
+                );
+
+                oldLog.apply(
+                    console,
+                    arguments
+                );
+            };
+
+
+            console.warn = function(){
+
+                send(
+                    "WARN",
+                    arguments
+                );
+
+                oldWarn.apply(
+                    console,
+                    arguments
+                );
+            };
+
+
+            console.error = function(){
+
+                send(
+                    "ERROR",
+                    arguments
+                );
+
+                oldError.apply(
+                    console,
+                    arguments
+                );
+            };
+
+
+            window.onerror =
+                function(
+                    message,
+                    source,
+                    line,
+                    column,
+                    error
+                ){
+
+                    send(
+                        "ERROR",
+                        [
+                            "JS ERROR:",
+                            message,
+                            source,
+                            line,
+                            column,
+                            error?.stack
+                        ]
+                    );
+
+                    return false;
+                };
+
+
+            window.onunhandledrejection =
+                function(event){
+
+                    send(
+                        "ERROR",
+                        [
+                            "PROMISE ERROR:",
+                            event.reason
+                        ]
+                    );
+
+                };
+
+
+        })();
+    """.trimIndent()
+
+
+        webView.evaluateJavascript(
+            js,
+            null
+        )
+    }
 }

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
 
         }