feat: Add gorgeous per-provider block settings UI and stack trace mapping

Author: errorcodeQQ

CSGuard/src/main/kotlin/com/csguard/AllowlistStore.kt

@@ -28,6 +28,7 @@ object AllowlistStore {
     private const val TAG = "CSGuard"
     private const val PREFS_NAME = "csguard_allowlist"
     private const val KEY_ALWAYS = "always_allow_hosts"
+    private const val KEY_BLOCKED_PROVIDERS = "blocked_providers"
     private const val KEY_BLOCKED = "blocked_attempts_log"
     private const val MAX_BLOCKED_LOG = 200
 
@@ -71,6 +72,35 @@ object AllowlistStore {
         return true
     }
 
+    // ───────────────────── Blocked Providers (Per-Provider Blocklist) ─────────────────────
+
+    fun blockedProviders(): Set<String> {
+        val raw = prefs?.getString(KEY_BLOCKED_PROVIDERS, "[]") ?: "[]"
+        return try {
+            val arr = JSONArray(raw)
+            (0 until arr.length()).map { arr.getString(it).trim() }.toSet()
+        } catch (_: Throwable) { emptySet() }
+    }
+
+    fun addBlockedProvider(providerName: String): Boolean {
+        val normalized = providerName.trim()
+        if (normalized.isEmpty()) return false
+        val current = blockedProviders().toMutableSet()
+        if (!current.add(normalized)) return false
+        prefs?.edit()?.putString(KEY_BLOCKED_PROVIDERS, JSONArray(current.toList()).toString())?.apply()
+        Log.i(TAG, "AllowlistStore: added blocked provider → $normalized")
+        return true
+    }
+
+    fun removeBlockedProvider(providerName: String): Boolean {
+        val normalized = providerName.trim()
+        val current = blockedProviders().toMutableSet()
+        if (!current.remove(normalized)) return false
+        prefs?.edit()?.putString(KEY_BLOCKED_PROVIDERS, JSONArray(current.toList()).toString())?.apply()
+        Log.i(TAG, "AllowlistStore: removed blocked provider → $normalized")
+        return true
+    }
+
     // ───────────────────── Allow-once (session-only) ─────────────────────
 
     fun allowOnce(host: String) {

CSGuard/src/main/kotlin/com/csguard/GuardSettingsDialog.kt

@@ -2,32 +2,16 @@ package com.csguard
 
 import android.app.AlertDialog
 import android.content.Context
-import android.text.InputType
-import android.view.ViewGroup
-import android.widget.CheckBox
-import android.widget.EditText
+import android.graphics.Color
+import android.graphics.Typeface
+import android.graphics.drawable.GradientDrawable
+import android.view.Gravity
 import android.widget.LinearLayout
-import android.widget.RadioButton
-import android.widget.RadioGroup
 import android.widget.ScrollView
+import android.widget.Switch
 import android.widget.TextView
-import android.widget.Toast
-import java.text.DateFormat
-import java.util.Date
-
-/**
- * Settings UI for CSGuard.
- *
- * Three sections:
- *   1. **Policy presets** — Strict / Strict-Verbose / Balanced / Permissive
- *   2. **Allowlist management** — view/add/remove always-allow hosts
- *   3. **Blocked log review** — see what CSGuard voided, with tap-to-approve
- *
- * The aggressive default is STRICT (silent void). The blocked-log section is
- * the user's main tool for tuning: when something legit stops working (e.g.
- * a CloudStream repo install URL got voided), they can find it in the log
- * and tap "Allow always" to whitelist the host going forward.
- */
+import com.lagradost.cloudstream3.APIHolder
+
 class GuardSettingsDialog(
     private val context: Context,
     private val current: GuardPolicy,
@@ -36,216 +20,139 @@ class GuardSettingsDialog(
     fun show() {
         val container = LinearLayout(context).apply {
             orientation = LinearLayout.VERTICAL
-            setPadding(48, 32, 48, 32)
+            setPadding(48, 48, 48, 48)
+            setBackgroundColor(Color.parseColor("#121212")) // Sleek Dark Mode
         }
 
-        // ── Section 1: Policy preset ────────────────────────────────────
+        // Title
         container.addView(TextView(context).apply {
-            text = "Protection Level"
-            textSize = 16f
+            text = "🛡 CSGuard Protection"
+            textSize = 24f
+            typeface = Typeface.DEFAULT_BOLD
+            setTextColor(Color.WHITE)
             setPadding(0, 0, 0, 16)
         })
 
-        val radioGroup = RadioGroup(context).apply { orientation = RadioGroup.VERTICAL }
-        val strictRb = RadioButton(context).apply {
-            id = 1
-            text = "Strict (silent) — block ALL external launches except allowlist\n[DEFAULT — the void is silent]"
-            isChecked = current == GuardPolicy.STRICT
-        }
-        val strictVerboseRb = RadioButton(context).apply {
-            id = 2
-            text = "Strict (verbose) — same as Strict, but show a toast on each block\n[for tuning your allowlist]"
-            isChecked = current == GuardPolicy.STRICT_VERBOSE
-        }
-        val balancedRb = RadioButton(context).apply {
-            id = 3
-            text = "Balanced — block known ad hosts + ad-pattern paths\n(allow other external launches)"
-            isChecked = current == GuardPolicy.DEFAULT && current != GuardPolicy.STRICT && current != GuardPolicy.STRICT_VERBOSE
-        }
-        val permissiveRb = RadioButton(context).apply {
-            id = 4
-            text = "Permissive — block only known ad-network hosts"
-            isChecked = current == GuardPolicy.PERMISSIVE
-        }
-        radioGroup.addView(strictRb)
-        radioGroup.addView(strictVerboseRb)
-        radioGroup.addView(balancedRb)
-        radioGroup.addView(permissiveRb)
-        container.addView(radioGroup)
-
-        // ── Section 2: Allowlist management ─────────────────────────────
+        // Subtitle
         container.addView(TextView(context).apply {
-            text = "\nAllowlist (hosts that bypass the block)"
-            textSize = 16f
-            setPadding(0, 16, 0, 8)
+            text = "Select which providers are forbidden from launching external browser intents. CSGuard will silently void their ads."
+            textSize = 14f
+            setTextColor(Color.parseColor("#B0B0B0"))
+            setPadding(0, 0, 0, 32)
         })
 
-        val alwaysAllow = AllowlistStore.alwaysAllow().sorted()
-        val allowlistInfo = TextView(context).apply {
-            text = if (alwaysAllow.isEmpty()) {
-                "• (empty — relying on built-in SAFE_HOSTS baseline)"
-            } else {
-                alwaysAllow.joinToString(prefix = "• ", separator = "\n• ")
-            }
-            textSize = 12f
-            setPadding(16, 0, 16, 8)
-        }
-        container.addView(allowlistInfo)
-
-        val addHostBtn = android.widget.Button(context).apply {
-            text = "+ Add host to allowlist"
-            setOnClickListener { showAddHostDialog(context, allowlistInfo) }
-        }
-        container.addView(addHostBtn)
+        var isGlobalStrict = current.blockAllUnknown
 
-        val removeHostBtn = android.widget.Button(context).apply {
-            text = "− Remove host from allowlist"
-            setOnClickListener { showRemoveHostDialog(context, allowlistInfo) }
+        // Master Toggle: Global Strict Mode
+        val masterRow = createRow("Global Strict Mode", "Block ALL unknown external intents across the entire app.", isGlobalStrict) { checked ->
+            isGlobalStrict = checked
         }
-        container.addView(removeHostBtn)
+        container.addView(masterRow)
 
-        // ── Section 3: Blocked log review ───────────────────────────────
+        // Section Title
         container.addView(TextView(context).apply {
-            text = "\nRecent Blocks (tap to approve)"
-            textSize = 16f
-            setPadding(0, 16, 0, 8)
+            text = "Per-Provider Blocks"
+            textSize = 18f
+            typeface = Typeface.DEFAULT_BOLD
+            setTextColor(Color.parseColor("#E0E0E0"))
+            setPadding(0, 32, 0, 16)
         })
 
-        val blockedLog = AllowlistStore.blockedLog()
-        val logInfo = TextView(context).apply {
-            text = if (blockedLog.isEmpty()) {
-                "• (no blocks recorded yet — try playing a video)"
-            } else {
-                val df = DateFormat.getDateTimeInstance(DateFormat.SHORT, DateFormat.MEDIUM)
-                buildString {
-                    blockedLog.take(10).forEach { entry ->
-                        val host = try { android.net.Uri.parse(entry.url).host ?: "?" } catch (_: Throwable) { "?" }
-                        append("• [${df.format(Date(entry.timestamp))}]\n")
-                        append("  host: $host\n")
-                        append("  caller: ${entry.caller}\n")
-                        append("  url: ${entry.url.take(80)}${if (entry.url.length > 80) "..." else ""}\n\n")
-                    }
-                    if (blockedLog.size > 10) {
-                        append("… and ${blockedLog.size - 10} more (showing 10 most recent)")
-                    }
+        val blockedSet = AllowlistStore.blockedProviders().toMutableSet()
+
+        // Fetch all providers
+        val providers = try {
+            APIHolder.allProviders.sortedBy { it.name }
+        } catch (_: Throwable) { emptyList() }
+
+        if (providers.isEmpty()) {
+            container.addView(TextView(context).apply {
+                text = "No providers loaded yet."
+                setTextColor(Color.RED)
+            })
+        } else {
+            providers.forEach { provider ->
+                val row = createRow(provider.name, "Plugin: ${provider.javaClass.simpleName}", blockedSet.contains(provider.name)) { checked ->
+                    if (checked) blockedSet.add(provider.name) else blockedSet.remove(provider.name)
                 }
+                container.addView(row)
             }
-            textSize = 11f
-            setPadding(16, 0, 16, 8)
         }
-        container.addView(logInfo)
 
-        val approveFromLogBtn = android.widget.Button(context).apply {
-            text = "✓ Approve host from blocked log"
-            setOnClickListener { showApproveFromLogDialog(context, allowlistInfo) }
+        val scroll = ScrollView(context).apply {
+            addView(container)
         }
-        container.addView(approveFromLogBtn)
-
-        val clearLogBtn = android.widget.Button(context).apply {
-            text = "🗑 Clear blocked log"
-            setOnClickListener {
-                AllowlistStore.clearBlockedLog()
-                logInfo.text = "• (log cleared)"
-                Toast.makeText(context, "Blocked log cleared", Toast.LENGTH_SHORT).show()
-            }
-        }
-        container.addView(clearLogBtn)
-
-        // ── Wrap in scroll view (might be tall) ─────────────────────────
-        val scroll = ScrollView(context).apply { addView(container) }
 
-        AlertDialog.Builder(context)
-            .setTitle("CSGuard Settings")
+        AlertDialog.Builder(context, android.R.style.Theme_DeviceDefault_Dialog_Alert)
             .setView(scroll)
-            .setPositiveButton("Apply") { _, _ ->
-                val newPolicy = when (radioGroup.checkedRadioButtonId) {
-                    1 -> GuardPolicy.STRICT
-                    2 -> GuardPolicy.STRICT_VERBOSE
-                    3 -> GuardPolicy.DEFAULT
-                    4 -> GuardPolicy.PERMISSIVE
-                    else -> GuardPolicy.STRICT
-                }
+            .setPositiveButton("Save Settings") { _, _ ->
+                // Apply blocked providers
+                val currentBlocks = AllowlistStore.blockedProviders()
+                currentBlocks.forEach { AllowlistStore.removeBlockedProvider(it) }
+                blockedSet.forEach { AllowlistStore.addBlockedProvider(it) }
+
+                // Create new policy
+                val newPolicy = GuardPolicy(
+                    blockKnownAdHosts = true,
+                    blockAdPaths = true,
+                    blockAllUnknown = isGlobalStrict,
+                    showToast = current.showToast
+                )
                 onApply(newPolicy)
-                Toast.makeText(context, "CSGuard: $newPolicy", Toast.LENGTH_SHORT).show()
             }
             .setNegativeButton("Cancel", null)
             .show()
     }
 
-    private fun showAddHostDialog(ctx: Context, allowlistInfo: TextView) {
-        val input = EditText(ctx).apply {
-            hint = "e.g. example.com (no scheme, no path)"
-            inputType = InputType.TYPE_CLASS_TEXT or InputType.TYPE_TEXT_VARIATION_URI
+    private fun createRow(title: String, subtitle: String, isChecked: Boolean, onToggle: (Boolean) -> Unit): LinearLayout {
+        val row = LinearLayout(context).apply {
+            orientation = LinearLayout.HORIZONTAL
+            gravity = Gravity.CENTER_VERTICAL
+            setPadding(32, 32, 32, 32)
+            
+            val shape = GradientDrawable()
+            shape.shape = GradientDrawable.RECTANGLE
+            shape.cornerRadius = 24f
+            shape.setColor(Color.parseColor("#1E1E1E"))
+            background = shape
+
+            val params = LinearLayout.LayoutParams(
+                LinearLayout.LayoutParams.MATCH_PARENT,
+                LinearLayout.LayoutParams.WRAP_CONTENT
+            )
+            params.setMargins(0, 0, 0, 16)
+            layoutParams = params
         }
-        AlertDialog.Builder(ctx)
-            .setTitle("Add host to allowlist")
-            .setView(input)
-            .setPositiveButton("Add") { _, _ ->
-                val host = input.text.toString().trim()
-                if (host.isNotEmpty()) {
-                    AllowlistStore.addAlwaysAllow(host)
-                    refreshAllowlistView(allowlistInfo)
-                    Toast.makeText(ctx, "Added: $host", Toast.LENGTH_SHORT).show()
-                }
-            }
-            .setNegativeButton("Cancel", null)
-            .show()
-    }
 
-    private fun showRemoveHostDialog(ctx: Context, allowlistInfo: TextView) {
-        val hosts = AllowlistStore.alwaysAllow().sorted()
-        if (hosts.isEmpty()) {
-            Toast.makeText(ctx, "Allowlist is empty", Toast.LENGTH_SHORT).show()
-            return
+        val textLayout = LinearLayout(context).apply {
+            orientation = LinearLayout.VERTICAL
+            layoutParams = LinearLayout.LayoutParams(0, LinearLayout.LayoutParams.WRAP_CONTENT, 1f)
         }
-        val items = hosts.toTypedArray()
-        val checked = BooleanArray(items.size) { false }
-        AlertDialog.Builder(ctx)
-            .setTitle("Remove hosts from allowlist")
-            .setMultiChoiceItems(items, checked) { _, which, isChecked ->
-                checked[which] = isChecked
-            }
-            .setPositiveButton("Remove selected") { _, _ ->
-                items.indices.filter { checked[it] }.forEach { AllowlistStore.removeAlwaysAllow(items[it]) }
-                refreshAllowlistView(allowlistInfo)
-            }
-            .setNegativeButton("Cancel", null)
-            .show()
-    }
 
-    private fun showApproveFromLogDialog(ctx: Context, allowlistInfo: TextView) {
-        val log = AllowlistStore.blockedLog()
-        if (log.isEmpty()) {
-            Toast.makeText(ctx, "Blocked log is empty", Toast.LENGTH_SHORT).show()
-            return
+        val titleView = TextView(context).apply {
+            text = title
+            textSize = 16f
+            setTextColor(Color.WHITE)
+            typeface = Typeface.DEFAULT_BOLD
+        }
+        
+        val subtitleView = TextView(context).apply {
+            text = subtitle
+            textSize = 12f
+            setTextColor(Color.parseColor("#888888"))
+            setPadding(0, 4, 0, 0)
         }
-        // Group by host, show distinct hosts
-        val hosts = log.mapNotNull { entry ->
-            try { android.net.Uri.parse(entry.url).host } catch (_: Throwable) { null }
-        }.distinct()
-
-        val items = hosts.toTypedArray()
-        val checked = BooleanArray(items.size) { false }
-        AlertDialog.Builder(ctx)
-            .setTitle("Approve hosts from blocked log")
-            .setMultiChoiceItems(items, checked) { _, which, isChecked ->
-                checked[which] = isChecked
-            }
-            .setPositiveButton("Add to allowlist") { _, _ ->
-                items.indices.filter { checked[it] }.forEach { AllowlistStore.addAlwaysAllow(items[it]) }
-                refreshAllowlistView(allowlistInfo)
-                Toast.makeText(ctx, "Added ${checked.count { it }} hosts", Toast.LENGTH_SHORT).show()
-            }
-            .setNegativeButton("Cancel", null)
-            .show()
-    }
 
-    private fun refreshAllowlistView(view: TextView) {
-        val alwaysAllow = AllowlistStore.alwaysAllow().sorted()
-        view.text = if (alwaysAllow.isEmpty()) {
-            "• (empty — relying on built-in SAFE_HOSTS baseline)"
-        } else {
-            alwaysAllow.joinToString(prefix = "• ", separator = "\n• ")
+        textLayout.addView(titleView)
+        textLayout.addView(subtitleView)
+
+        val toggle = Switch(context).apply {
+            this.isChecked = isChecked
+            setOnCheckedChangeListener { _, checked -> onToggle(checked) }
         }
+
+        row.addView(textLayout)
+        row.addView(toggle)
+        return row
     }
 }