pakstr 0.4.0 → 0.6.0

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

@@ -11,6 +11,8 @@ object DebugLogStorage {
     private const val MAX_FILE_SIZE =
         1024 * 1024 // 1 MB
 
+    private const val MAX_LINES = 5000
+
     fun append(
         context: Context,
         entry: String
@@ -26,9 +28,13 @@ object DebugLogStorage {
 
 
             file.appendText(
+
                 entry + "\n"
+
             )
 
+            trimFile(file)
+
         } catch (_: Exception) {
 
             // Logging must never crash the app
@@ -38,27 +44,21 @@ object DebugLogStorage {
 
     fun read(
         context: Context
-    ): String {
+    ): List<String> {
 
         return try {
 
-            val file =
-                getFile(context)
-
+            val file = getFile(context)
 
             if (file.exists()) {
-
-                file.readText()
-
+                file.readLines()
             } else {
-
-                ""
-
+                emptyList()
             }
 
         } catch (_: Exception) {
 
-            ""
+            emptyList()
 
         }
     }
@@ -104,4 +104,36 @@ object DebugLogStorage {
         )
 
     }
+
+    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()
+
+    }
+}

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

@@ -38,7 +38,7 @@ object DebugReportExporter {
         val file =
             File(
                 context.cacheDir,
-                "pakstr-debug-report.txt"
+                "pakstr-debug-report-${DebugSession.sessionId}.txt"
             )
 
 
@@ -57,19 +57,8 @@ object DebugReportExporter {
 
 
         val rawLogs =
-            if (debugEnabled) {
-
-                DebugLogStorage.read(context)
-
-            } else {
-
-                DebugLogStorage.read(context)
-                    .lines()
-                    .filter {
-                        it.contains("[ERROR]")
-                    }
-                    .joinToString("\n")
-            }
+            DebugLogStorage.read(context)
+                .joinToString("\n")
 
 
         val logs =
@@ -77,32 +66,53 @@ object DebugReportExporter {
 
 
         return """
-            Pakstr Debug Report
-            ===================
+        Pakstr Debug Report
+        ===================
+
+        Session:
+        -------------------
+        ID:
+        ${DebugSession.sessionId}
+
+        Started:
+        ${java.util.Date(DebugSession.startedAt)}
+
+        Uptime:
+        ${DebugSession.uptime()} ms
+
+
+        Application:
+        -------------------
+        ${BuildConfig.APPLICATION_ID}
+
+
+        Version:
+        ${BuildConfig.VERSION_NAME} (${BuildConfig.VERSION_CODE})
+
+
+        Device:
+        ${Build.MANUFACTURER} ${Build.MODEL}
+
 
-            Application:
-            ${BuildConfig.APPLICATION_ID}
+        Android:
+        ${Build.VERSION.RELEASE}
 
-            Version:
-            ${BuildConfig.VERSION_NAME} (${BuildConfig.VERSION_CODE})
 
-            Device:
-            ${Build.MANUFACTURER} ${Build.MODEL}
+        Debug:
+        $debugEnabled
 
-            Android:
-            ${Build.VERSION.RELEASE}
 
-            Debug:
-            $debugEnabled
+        API Enabled:
+        ${RuntimeConfig.apiEnabled(context)}
 
-            API Enabled:
-            ${RuntimeConfig.apiEnabled(context)}
+        WebView Debug:
+        ${BuildConfig.DEBUG || RuntimeConfig.debugEnabled(context)}
 
-            Logs:
-            -------------------
-            $logs
+        Logs:
+        -------------------
+        $logs
 
-        """.trimIndent()
+    """.trimIndent()
     }
 
 

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

@@ -1,29 +1,55 @@
 package com.pakstr.app.debug
 
+import android.content.Context
+
+
 object DebugRuntimeOverride {
 
-    private var overrideConfig: DebugConfig? = null
+
+    private var overrideConfig:
+            DebugConfig? = null
 
 
     fun set(
+        context: Context,
         config: DebugConfig
     ) {
 
         overrideConfig = config
 
+        DebugPreferences.save(
+            context,
+            config
+        )
     }
 
 
-    fun clear() {
+    fun clear(
+        context: Context
+    ) {
 
         overrideConfig = null
 
+        DebugPreferences.clear(
+            context
+        )
     }
 
 
-    fun get(): DebugConfig? {
+    fun get(
+        context: Context
+    ): DebugConfig? {
 
-        return overrideConfig
+        if (overrideConfig == null) {
+
+            val saved =
+                DebugPreferences.load(context)
 
+            if (saved.enabled) {
+                overrideConfig = saved
+            }
+        }
+
+        return overrideConfig
     }
 }

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

@@ -0,0 +1,16 @@
+package com.pakstr.app.debug
+
+import java.util.UUID
+
+object DebugSession {
+
+    val sessionId: String =
+        UUID.randomUUID().toString()
+
+    val startedAt: Long =
+        System.currentTimeMillis()
+
+    fun uptime(): Long {
+        return System.currentTimeMillis() - startedAt
+    }
+}

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

@@ -0,0 +1,234 @@
+package com.pakstr.app.debug
+
+import android.content.ActivityNotFoundException
+import android.content.Intent
+import android.graphics.Typeface
+import android.net.Uri
+import android.os.Build
+import android.os.Bundle
+import android.os.Handler
+import android.os.Looper
+import android.text.format.DateUtils
+import android.view.ViewGroup
+import android.widget.ScrollView
+import android.widget.TextView
+import android.widget.Toast
+import androidx.activity.enableEdgeToEdge
+import androidx.appcompat.app.AppCompatActivity
+import com.google.android.material.appbar.MaterialToolbar
+import com.google.android.material.button.MaterialButton
+import com.google.android.material.dialog.MaterialAlertDialogBuilder
+import com.google.android.material.switchmaterial.SwitchMaterial
+import com.pakstr.app.BuildConfig
+import com.pakstr.app.R
+import com.pakstr.app.RuntimeConfig
+
+class DeveloperToolsActivity : AppCompatActivity() {
+
+    private val uptimeHandler = Handler(Looper.getMainLooper())
+
+    private lateinit var uptimeValue: TextView
+    private lateinit var debugModeSwitch: SwitchMaterial
+    private lateinit var apiSwitch: SwitchMaterial
+    private lateinit var debugWebViewStatus: TextView
+    private lateinit var webViewStatus: TextView
+
+    private val uptimeUpdater = object : Runnable {
+        override fun run() {
+            uptimeValue.text = DateUtils.formatElapsedTime(DebugSession.uptime() / 1000)
+            uptimeHandler.postDelayed(this, UPTIME_REFRESH_INTERVAL_MS)
+        }
+    }
+
+    override fun onCreate(savedInstanceState: Bundle?) {
+        enableEdgeToEdge()
+        super.onCreate(savedInstanceState)
+        setContentView(R.layout.activity_developer_tools)
+
+        setupToolbar()
+        bindViews()
+        populateRuntimeDetails()
+        setupDebugControls()
+        setupLogActions()
+        setupCrashTesting()
+        setupWebViewActions()
+    }
+
+    override fun onStart() {
+        super.onStart()
+        refreshStatuses()
+        uptimeHandler.post(uptimeUpdater)
+    }
+
+    override fun onStop() {
+        uptimeHandler.removeCallbacks(uptimeUpdater)
+        super.onStop()
+    }
+
+    private fun setupToolbar() {
+        findViewById<MaterialToolbar>(R.id.developerToolsToolbar).setNavigationOnClickListener {
+            finish()
+        }
+    }
+
+    private fun bindViews() {
+        uptimeValue = findViewById(R.id.runtimeUptimeValue)
+        debugModeSwitch = findViewById(R.id.debugModeSwitch)
+        apiSwitch = findViewById(R.id.apiEnabledSwitch)
+        debugWebViewStatus = findViewById(R.id.debugWebViewStatus)
+        webViewStatus = findViewById(R.id.webViewStatus)
+    }
+
+    private fun populateRuntimeDetails() {
+        findViewById<TextView>(R.id.runtimeSessionIdValue).text = DebugSession.sessionId
+        findViewById<TextView>(R.id.runtimeAppVersionValue).text = getString(
+            R.string.developer_tools_version_value,
+            BuildConfig.VERSION_NAME,
+            BuildConfig.VERSION_CODE
+        )
+        findViewById<TextView>(R.id.runtimeAndroidVersionValue).text = Build.VERSION.RELEASE
+        findViewById<TextView>(R.id.runtimeDeviceModelValue).text = getString(
+            R.string.developer_tools_device_value,
+            Build.MANUFACTURER,
+            Build.MODEL
+        )
+    }
+
+    private fun setupDebugControls() {
+        apiSwitch.isChecked = RuntimeConfig.apiEnabled(this)
+
+        debugModeSwitch.setOnCheckedChangeListener { _, isChecked ->
+            if (isChecked) {
+                DeveloperToolsManager.enableDebug(this)
+            } else {
+                DeveloperToolsManager.disableDebug(this)
+            }
+
+            WebViewDebugManager.enable(this)
+            refreshStatuses()
+        }
+    }
+
+    private fun refreshStatuses() {
+        debugModeSwitch.isChecked = DeveloperToolsManager.isEnabled(this)
+        apiSwitch.isChecked = RuntimeConfig.apiEnabled(this)
+
+        val status = if (isWebViewDebugEnabled()) {
+            R.string.developer_tools_enabled
+        } else {
+            R.string.developer_tools_disabled
+        }
+        debugWebViewStatus.setText(status)
+        webViewStatus.setText(status)
+    }
+
+    private fun isWebViewDebugEnabled(): Boolean {
+        return BuildConfig.DEBUG || RuntimeConfig.debugEnabled(this)
+    }
+
+    private fun setupLogActions() {
+        findViewById<MaterialButton>(R.id.viewLogsButton).setOnClickListener {
+            showLogs()
+        }
+        findViewById<MaterialButton>(R.id.clearLogsButton).setOnClickListener {
+            confirmClearLogs()
+        }
+        findViewById<MaterialButton>(R.id.exportDebugReportButton).setOnClickListener {
+            exportDebugReport()
+        }
+        findViewById<MaterialButton>(R.id.shareReportButton).setOnClickListener {
+            DebugReportShare.share(this)
+        }
+    }
+
+    private fun showLogs() {
+        val logs = DebugLogStorage.read(this)
+        val content = if (logs.isEmpty()) {
+            getString(R.string.developer_tools_no_logs)
+        } else {
+            logs.joinToString("\n")
+        }
+
+        val textView = TextView(this).apply {
+            text = content
+            typeface = Typeface.MONOSPACE
+            setTextIsSelectable(true)
+            val padding = resources.getDimensionPixelSize(
+                R.dimen.developer_tools_dialog_padding
+            )
+            setPadding(padding, padding, padding, padding)
+        }
+
+        val scrollView = ScrollView(this).apply {
+            addView(textView)
+        }
+
+        MaterialAlertDialogBuilder(this)
+            .setTitle(R.string.developer_tools_view_logs)
+            .setView(scrollView)
+            .setPositiveButton(android.R.string.ok, null)
+            .show()
+            .window
+            ?.setLayout(ViewGroup.LayoutParams.MATCH_PARENT, ViewGroup.LayoutParams.WRAP_CONTENT)
+    }
+
+    private fun confirmClearLogs() {
+        MaterialAlertDialogBuilder(this)
+            .setTitle(R.string.developer_tools_clear_logs)
+            .setMessage(R.string.developer_tools_clear_logs_confirmation)
+            .setNegativeButton(android.R.string.cancel, null)
+            .setPositiveButton(R.string.developer_tools_clear) { _, _ ->
+                AppDebugLogger.clear(this)
+                showMessage(R.string.developer_tools_logs_cleared)
+            }
+            .show()
+    }
+
+    private fun exportDebugReport() {
+        runCatching {
+            DebugReportExporter.export(this)
+        }.onSuccess { report ->
+            Toast.makeText(
+                this,
+                getString(R.string.developer_tools_report_exported, report.absolutePath),
+                Toast.LENGTH_LONG
+            ).show()
+        }.onFailure {
+            showMessage(R.string.developer_tools_report_export_failed)
+        }
+    }
+
+    private fun setupCrashTesting() {
+        findViewById<MaterialButton>(R.id.throwTestExceptionButton).setOnClickListener {
+            MaterialAlertDialogBuilder(this)
+                .setTitle(R.string.developer_tools_crash_confirmation_title)
+                .setMessage(R.string.developer_tools_crash_confirmation_message)
+                .setNegativeButton(android.R.string.cancel, null)
+                .setPositiveButton(R.string.developer_tools_crash) { _, _ ->
+                    throw RuntimeException(TEST_EXCEPTION_MESSAGE)
+                }
+                .show()
+        }
+    }
+
+    private fun setupWebViewActions() {
+        findViewById<MaterialButton>(R.id.openChromeInspectDocsButton).setOnClickListener {
+            try {
+                startActivity(Intent(Intent.ACTION_VIEW, Uri.parse(CHROME_INSPECT_DOCS_URL)))
+            } catch (_: ActivityNotFoundException) {
+                showMessage(R.string.developer_tools_browser_unavailable)
+            }
+        }
+    }
+
+    private fun showMessage(message: Int) {
+        Toast.makeText(this, message, Toast.LENGTH_SHORT).show()
+    }
+
+    private companion object {
+        const val UPTIME_REFRESH_INTERVAL_MS = 1000L
+        const val TEST_EXCEPTION_MESSAGE = "Developer Tools test exception"
+        const val CHROME_INSPECT_DOCS_URL =
+            "https://developer.chrome.com/docs/devtools/remote-debugging/webviews/"
+    }
+}

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

@@ -1,34 +1,63 @@
 package com.pakstr.app.debug
+
+import android.content.Context
+
+
 object DeveloperToolsManager {
 
-    fun enableDebug() {
 
-        DebugRuntimeOverride.set(
+    fun enableDebug(
+        context: Context
+    ) {
 
-            DebugConfig(
+        val config = DebugConfig(
 
-                enabled = true,
+            enabled = true,
 
-                networkLogs = true,
+            networkLogs = true,
 
-                webViewLogs = true,
+            webViewLogs = true
+
+        )
+
+
+
+        DebugRuntimeOverride.set(context,
+            config
+        )
 
-                )
+        DebugPreferences.save(
+            context,
+            config
         )
 
     }
 
-    fun disableDebug() {
 
-        DebugRuntimeOverride.clear()
+    fun disableDebug(
+        context: Context
+    ) {
+
+
+        DebugRuntimeOverride.clear(context)
+
+
+        DebugPreferences.clear(
+            context
+        )
 
     }
 
-    fun isEnabled(): Boolean {
 
-        return DebugRuntimeOverride.get()
-            ?.enabled
-            ?: false
+    fun isEnabled(
+        context: Context
+    ): Boolean {
+
+
+        return DebugPreferences
+            .load(context)
+            .enabled
 
     }
+
 }

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

@@ -0,0 +1,30 @@
+package com.pakstr.app.debug
+
+import android.R.attr.enabled
+import android.content.Context
+import android.webkit.WebView
+import com.pakstr.app.BuildConfig
+import com.pakstr.app.RuntimeConfig
+
+object WebViewDebugManager {
+
+
+    fun enable(
+        context: Context
+    ) {
+
+        WebView.setWebContentsDebuggingEnabled(
+            BuildConfig.DEBUG ||
+                    RuntimeConfig.debugEnabled(context)
+        )
+        AppDebugLogger.log(
+
+            context,
+
+            "WEBVIEW",
+
+            "WebView debugging enabled: $enabled"
+
+        )
+    }
+}