pakstr 0.3.4 → 0.5.0

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

@@ -1,21 +1,366 @@
 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.Collections
+import java.util.Date
+import java.util.Locale
 
 object AppDebugLogger {
 
+    private const val TAG = "PakstrDebug"
+
+    private const val MAX_LOGS = 500
+
+    private val logs =
+
+        Collections.synchronizedList(
+
+            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(
+        context: Context
+    ) {
+
+        logs.clear()
+
+        DebugLogStorage.clear(context)
+
+    }
+
+    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 {
+
+
+        val runtime =
+            DebugRuntimeOverride.get(context)
+
+
+        if (runtime != null) {
+            return runtime
+        }
+
+
+        val stored =
+            DebugPreferences.load(
+                context
+            )
+
+
+        if (stored.enabled) {
+            return stored
+        }
+
+
+        return RuntimeConfig.debugConfig(
+            context
+        )
+
+    }
+
+    fun exportLogs(
+        context: Context
+    ): String {
+
+        return buildString {
+
+            appendLine(
+                "===== PAKSTR DEBUG LOG ====="
+            )
+
+            appendLine(
+                "Version: ${BuildConfig.VERSION_NAME}"
+            )
+
+            appendLine(
+                "Debug: ${isDebugEnabled(context)}"
+            )
+
+            appendLine()
+
+
+            getLogs().forEach {
+                appendLine(it)
+            }
+
+        }
+    }
+
+    fun load(
+
+        context: Context
+
+    ) {
+
+        logs.clear()
+
+        logs.addAll(
+
+            DebugLogStorage.read(context)
+
+        )
+
     }
 }

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

@@ -0,0 +1,32 @@
+package com.pakstr.app.debug
+
+import android.content.Context
+
+object CrashHandler {
+
+    fun install(
+        context: Context
+    ) {
+
+        val defaultHandler =
+            Thread.getDefaultUncaughtExceptionHandler()
+
+
+        Thread.setDefaultUncaughtExceptionHandler { thread, throwable ->
+
+
+            AppDebugLogger.error(
+                context,
+                "CRASH",
+                "Unhandled exception in ${thread.name}",
+                throwable
+            )
+
+
+            defaultHandler?.uncaughtException(
+                thread,
+                throwable
+            )
+        }
+    }
+}

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

@@ -0,0 +1,11 @@
+package com.pakstr.app.debug
+
+data class DebugConfig(
+
+    val enabled: Boolean = false,
+
+    val networkLogs: Boolean = false,
+
+    val webViewLogs: Boolean = false,
+
+)

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

@@ -0,0 +1,36 @@
+package com.pakstr.app.debug
+
+import org.json.JSONObject
+
+object DebugConfigLoader {
+
+    fun load(
+        manifest: JSONObject
+    ): DebugConfig {
+
+        val debug =
+            manifest.optJSONObject("debug")
+                ?: return DebugConfig()
+
+        return DebugConfig(
+
+            enabled =
+                debug.optBoolean(
+                    "enabled",
+                    false
+                ),
+
+            networkLogs =
+                debug.optBoolean(
+                    "networkLogs",
+                    false
+                ),
+
+            webViewLogs =
+                debug.optBoolean(
+                    "webViewLogs",
+                    false
+                )
+        )
+    }
+}

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

@@ -0,0 +1,29 @@
+package com.pakstr.app.debug
+
+import android.content.Context
+
+object DebugConfigProvider {
+
+    private var manifestConfig =
+        DebugConfig()
+
+
+    fun initialize(
+        config: DebugConfig
+    ) {
+
+        manifestConfig = config
+
+    }
+
+
+    fun current(
+        context: Context
+    ): DebugConfig {
+
+        return DebugRuntimeOverride.get(context)
+            ?: manifestConfig
+
+    }
+
+}

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

@@ -0,0 +1,139 @@
+package com.pakstr.app.debug
+
+import android.content.Context
+import java.io.File
+
+object DebugLogStorage {
+
+    private const val FILE_NAME =
+        "pakstr-debug.log"
+
+    private const val MAX_FILE_SIZE =
+        1024 * 1024 // 1 MB
+
+    private const val MAX_LINES = 5000
+
+    fun append(
+        context: Context,
+        entry: String
+    ) {
+
+        try {
+
+            val file =
+                getFile(context)
+
+
+            rotateIfNeeded(file)
+
+
+            file.appendText(
+
+                entry + "\n"
+
+            )
+
+            trimFile(file)
+
+        } catch (_: Exception) {
+
+            // Logging must never crash the app
+
+        }
+    }
+
+    fun read(
+        context: Context
+    ): List<String> {
+
+        return try {
+
+            val file = getFile(context)
+
+            if (file.exists()) {
+                file.readLines()
+            } else {
+                emptyList()
+            }
+
+        } catch (_: Exception) {
+
+            emptyList()
+
+        }
+    }
+
+    fun clear(
+        context: Context
+    ) {
+
+        try {
+
+            getFile(context)
+                .delete()
+
+        } catch (_: Exception) {
+
+        }
+    }
+
+    private fun rotateIfNeeded(
+        file: File
+    ) {
+
+        if (!file.exists()) {
+            return
+        }
+
+
+        if (file.length() >= MAX_FILE_SIZE) {
+
+            file.writeText("")
+
+        }
+
+    }
+
+    private fun getFile(
+        context: Context
+    ): File {
+
+        return File(
+            context.cacheDir,
+            FILE_NAME
+        )
+
+    }
+
+    private fun trimFile(
+
+        file: File
+
+    ) {
+
+        try {
+
+            val lines =
+
+                file.readLines()
+
+            if (lines.size > MAX_LINES) {
+
+                file.writeText(
+
+                    lines
+
+                        .takeLast(MAX_LINES)
+
+                        .joinToString("\n") + "\n"
+
+                )
+
+            }
+
+        } catch (_: Exception) {
+
+        }
+
+    }
+}

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

@@ -0,0 +1,85 @@
+package com.pakstr.app.debug
+
+import android.content.Context
+
+object DebugPreferences {
+
+    private const val PREFS_NAME = "pakstr_debug"
+
+    private const val KEY_ENABLED = "enabled"
+    private const val KEY_NETWORK = "networkLogs"
+    private const val KEY_WEBVIEW = "webViewLogs"
+
+
+    private fun prefs(context: Context) =
+        context.getSharedPreferences(
+            PREFS_NAME,
+            Context.MODE_PRIVATE
+        )
+
+
+    fun save(
+        context: Context,
+        config: DebugConfig
+    ) {
+
+        prefs(context)
+            .edit()
+            .putBoolean(
+                KEY_ENABLED,
+                config.enabled
+            )
+            .putBoolean(
+                KEY_NETWORK,
+                config.networkLogs
+            )
+            .putBoolean(
+                KEY_WEBVIEW,
+                config.webViewLogs
+            )
+            .apply()
+
+    }
+
+
+    fun load(
+        context: Context
+    ): DebugConfig {
+
+        val prefs = prefs(context)
+
+        return DebugConfig(
+
+            enabled =
+                prefs.getBoolean(
+                    KEY_ENABLED,
+                    false
+                ),
+
+            networkLogs =
+                prefs.getBoolean(
+                    KEY_NETWORK,
+                    false
+                ),
+
+            webViewLogs =
+                prefs.getBoolean(
+                    KEY_WEBVIEW,
+                    false
+                )
+
+        )
+    }
+
+
+    fun clear(
+        context: Context
+    ) {
+
+        prefs(context)
+            .edit()
+            .clear()
+            .apply()
+
+    }
+}