Redesign the app

New look based on the SparkleDNS concept: a dark theme, a floating
bottom panel with Home, Activity and Settings, and pages for the
blocklists, apps and About.

- Home: big ON/OFF switch, the current server, 24-hour stats and chart
- Activity: requests, blocked, average time and cache share for 24 hours
  or 7 days, company dominance, and the live log with search and filter
- Blocklists: HaGeZi Pro preset next to Pro++ and TIF, lists can be
  switched off without deleting them, automatic updates (daily or
  weekly, optionally Wi-Fi only) through JobScheduler
- Settings: server list, custom server, server test and per-app DNS
- Hourly numbers for the charts are kept on the device, without domains

The server list now ships with the app; it is no longer downloaded
from the repository.
This commit is contained in:
2026-10-30 19:58:08 +02:00
parent 43f0d42d65
commit 1db29ee44a
37 changed files with 3060 additions and 1532 deletions
@@ -0,0 +1,490 @@
package cc.skysparkle.sparkledns
import android.content.ClipData
import android.content.ClipboardManager
import android.widget.Toast
import androidx.annotation.StringRes
import androidx.compose.foundation.Canvas
import androidx.compose.foundation.background
import androidx.compose.foundation.border
import androidx.compose.foundation.clickable
import androidx.compose.foundation.layout.Arrangement
import androidx.compose.foundation.layout.Box
import androidx.compose.foundation.layout.Column
import androidx.compose.foundation.layout.PaddingValues
import androidx.compose.foundation.layout.Row
import androidx.compose.foundation.layout.Spacer
import androidx.compose.foundation.layout.fillMaxWidth
import androidx.compose.foundation.layout.heightIn
import androidx.compose.foundation.layout.padding
import androidx.compose.foundation.layout.size
import androidx.compose.foundation.layout.width
import androidx.compose.foundation.lazy.LazyColumn
import androidx.compose.foundation.lazy.itemsIndexed
import androidx.compose.foundation.shape.CircleShape
import androidx.compose.foundation.shape.RoundedCornerShape
import androidx.compose.material3.DropdownMenu
import androidx.compose.material3.DropdownMenuItem
import androidx.compose.material3.HorizontalDivider
import androidx.compose.material3.Icon
import androidx.compose.material3.IconButton
import androidx.compose.material3.Text
import androidx.compose.runtime.Composable
import androidx.compose.runtime.LaunchedEffect
import androidx.compose.runtime.getValue
import androidx.compose.runtime.mutableStateOf
import androidx.compose.runtime.remember
import androidx.compose.runtime.rememberCoroutineScope
import androidx.compose.runtime.saveable.rememberSaveable
import androidx.compose.runtime.setValue
import androidx.compose.ui.Alignment
import androidx.compose.ui.Modifier
import androidx.compose.ui.draw.clip
import androidx.compose.ui.geometry.Offset
import androidx.compose.ui.geometry.Size
import androidx.compose.ui.graphics.Color
import androidx.compose.ui.graphics.drawscope.Stroke
import androidx.compose.ui.platform.LocalContext
import androidx.compose.ui.res.painterResource
import androidx.compose.ui.res.stringResource
import androidx.compose.ui.text.font.FontWeight
import androidx.compose.ui.text.style.TextOverflow
import androidx.compose.ui.unit.Dp
import androidx.compose.ui.unit.dp
import androidx.compose.ui.unit.sp
import androidx.lifecycle.compose.collectAsStateWithLifecycle
import kotlinx.coroutines.Dispatchers
import kotlinx.coroutines.launch
import kotlinx.coroutines.withContext
import java.text.SimpleDateFormat
import java.util.Date
import java.util.Locale
private enum class ActivityFilter(@StringRes val label: Int) {
ALL(R.string.mon_all),
BLOCKED(R.string.status_blocked),
CACHED(R.string.status_cached),
ERRORS(R.string.mon_errors),
}
private enum class Period(val hours: Int, @StringRes val label: Int) {
DAY(24, R.string.period_24h),
WEEK(24 * 7, R.string.period_7d),
}
private val TimeFormat = SimpleDateFormat("HH:mm:ss", Locale.ROOT)
// Colors of the company slices, then the rest
private val SliceColors = listOf(Palette.Accent, Color(0xFFE6E8EE), Color(0xFF7C69E8), Color(0xFFC9A36A))
private val OtherColor = Palette.Track
private class Slice(val label: String, val share: Float, val color: Color)
@Composable
fun ActivityScreen(bottomPadding: Dp, modifier: Modifier = Modifier) {
val context = LocalContext.current
val scope = rememberCoroutineScope()
val custom by Blocklist.custom.collectAsStateWithLifecycle()
val customSet = remember(custom) { custom.toHashSet() }
var period by rememberSaveable { mutableStateOf(Period.DAY) }
var entries by remember { mutableStateOf(QueryLog.snapshot()) }
var summary by remember { mutableStateOf(StatsStore.summary(period.hours)) }
var filter by rememberSaveable { mutableStateOf(ActivityFilter.ALL) }
var search by rememberSaveable { mutableStateOf("") }
var filterMenu by remember { mutableStateOf(false) }
OnQueryLogChange {
entries = QueryLog.snapshot()
summary = StatsStore.summary(period.hours)
}
val statsVersion by StatsStore.version.collectAsStateWithLifecycle()
LaunchedEffect(period, statsVersion) { summary = StatsStore.summary(period.hours) }
val visible = remember(entries, filter, search) {
val term = search.trim()
entries.filter { e ->
val matchesFilter = when (filter) {
ActivityFilter.ALL -> true
ActivityFilter.BLOCKED -> e.status == QueryStatus.BLOCKED
ActivityFilter.CACHED -> e.status == QueryStatus.CACHED
ActivityFilter.ERRORS -> e.status == QueryStatus.FAILED
}
matchesFilter && (term.isEmpty() || e.domain.contains(term, ignoreCase = true))
}
}
fun toggleBlock(domain: String, unblock: Boolean) {
scope.launch {
val result = withContext(Dispatchers.IO) {
tryEdit {
if (unblock) {
Blocklist.removeCustom(context, domain)
true
} else {
Blocklist.addCustom(context, domain)
}
}
}
val ok = result.getOrElse {
showEditError(context, it)
return@launch
}
val message = when {
!ok -> context.getString(R.string.bl_invalid)
unblock -> context.getString(R.string.mon_unblocked, domain)
else -> context.getString(R.string.mon_blocked_added, domain)
}
Toast.makeText(context, message, Toast.LENGTH_SHORT).show()
}
}
fun copy(domain: String) {
context.getSystemService(ClipboardManager::class.java)
.setPrimaryClip(ClipData.newPlainText("domain", domain))
}
LazyColumn(
modifier = modifier,
contentPadding = PaddingValues(start = 20.dp, end = 20.dp, top = 16.dp, bottom = bottomPadding),
) {
item(key = "header") {
Row(
modifier = Modifier
.fillMaxWidth()
.heightIn(min = 44.dp),
verticalAlignment = Alignment.CenterVertically,
) {
ScreenTitle(stringResource(R.string.tab_activity), Modifier.weight(1f))
PeriodChip(stringResource(period.label)) {
period = if (period == Period.DAY) Period.WEEK else Period.DAY
}
}
}
item(key = "stats") {
Row(
modifier = Modifier
.fillMaxWidth()
.padding(top = 20.dp, start = 4.dp, end = 4.dp),
horizontalArrangement = Arrangement.spacedBy(6.dp),
) {
StatBlock(formatCompact(summary.total), stringResource(R.string.stat_requests), Modifier.weight(1f))
StatBlock(formatCompact(summary.blocked), stringResource(R.string.mon_blocked), Modifier.weight(1f))
StatBlock(stringResource(R.string.mon_ms, summary.avgLatencyMs), stringResource(R.string.stat_avg), Modifier.weight(1f))
val cache = if (summary.total == 0L) 0 else summary.cached * 100 / summary.total
StatBlock("$cache%", stringResource(R.string.mon_cached), Modifier.weight(1f))
}
}
item(key = "companies") {
CompanyCard(summary, Modifier.padding(top = 20.dp))
}
item(key = "recent") {
Row(
modifier = Modifier
.fillMaxWidth()
.padding(top = 24.dp),
verticalAlignment = Alignment.CenterVertically,
) {
Text(
stringResource(R.string.recent_title),
color = Palette.Fg,
fontSize = 17.sp,
fontWeight = FontWeight.ExtraBold,
modifier = Modifier.weight(1f),
)
IconButton(
onClick = {
QueryLog.clear()
entries = emptyList()
},
enabled = entries.isNotEmpty(),
) {
Icon(
painterResource(R.drawable.ic_delete),
contentDescription = stringResource(R.string.mon_clear),
tint = Palette.Fg2,
modifier = Modifier.size(20.dp),
)
}
}
}
item(key = "search") {
SearchField(
value = search,
onValueChange = { search = it },
placeholder = stringResource(R.string.mon_search),
modifier = Modifier.padding(top = 6.dp, bottom = 4.dp),
trailing = {
Box {
IconButton(onClick = { filterMenu = true }) {
Icon(
painterResource(R.drawable.ic_tab_settings),
contentDescription = stringResource(R.string.filter),
tint = if (filter == ActivityFilter.ALL) Palette.Fg2 else Palette.Accent,
modifier = Modifier.size(18.dp),
)
}
DropdownMenu(expanded = filterMenu, onDismissRequest = { filterMenu = false }) {
ActivityFilter.entries.forEach { option ->
DropdownMenuItem(
text = {
Text(
stringResource(option.label),
color = if (option == filter) Palette.Accent else Palette.Fg,
fontWeight = if (option == filter) FontWeight.Bold else FontWeight.Normal,
)
},
onClick = {
filter = option
filterMenu = false
},
)
}
}
}
},
)
}
if (visible.isEmpty()) {
item(key = "empty") {
EmptyState(
R.drawable.ic_tab_monitor,
stringResource(if (entries.isEmpty()) R.string.mon_empty else R.string.mon_no_match),
)
}
}
itemsIndexed(visible, key = { _, entry -> entry.id }, contentType = { _, _ -> "query" }) { index, entry ->
val blockedByMe = entry.domain in customSet
QueryRow(
modifier = Modifier.animateItem(),
entry = entry,
first = index == 0,
blockedByMe = blockedByMe,
onBlock = { toggleBlock(entry.domain, unblock = false) },
onUnblock = { toggleBlock(entry.domain, unblock = true) },
onCopy = { copy(entry.domain) },
)
}
}
}
@Composable
private fun PeriodChip(text: String, onClick: () -> Unit) {
Row(
modifier = Modifier
.clip(RoundedCornerShape(18.dp))
.border(1.dp, Palette.Track, RoundedCornerShape(18.dp))
.clickable(onClick = onClick)
.padding(start = 14.dp, end = 10.dp, top = 8.dp, bottom = 8.dp),
verticalAlignment = Alignment.CenterVertically,
) {
Text(text, color = Palette.Fg, fontSize = 12.sp, fontWeight = FontWeight.Bold)
Spacer(Modifier.width(4.dp))
Icon(painterResource(R.drawable.ic_expand), contentDescription = null, tint = Palette.Fg2, modifier = Modifier.size(14.dp))
}
}
@Composable
private fun CompanyCard(summary: StatsSummary, modifier: Modifier = Modifier) {
val other = stringResource(R.string.companies_other)
val slices = remember(summary, other) { companySlices(summary, other) }
Column(
modifier = modifier
.fillMaxWidth()
.appCard()
.padding(16.dp),
verticalArrangement = Arrangement.spacedBy(4.dp),
) {
Text(stringResource(R.string.companies_title), color = Palette.Fg, fontSize = 15.sp, fontWeight = FontWeight.Bold)
Text(stringResource(R.string.companies_desc), color = Palette.Fg2, fontSize = 12.sp, lineHeight = 17.sp)
Spacer(Modifier.size(10.dp))
if (summary.total == 0L) {
Text(
stringResource(R.string.no_data),
color = Palette.Fg3,
fontSize = 13.sp,
modifier = Modifier.padding(vertical = 12.dp),
)
} else {
Row(verticalAlignment = Alignment.CenterVertically) {
Donut(slices, Modifier.size(104.dp))
Spacer(Modifier.width(20.dp))
Column(Modifier.weight(1f), verticalArrangement = Arrangement.spacedBy(8.dp)) {
slices.forEach { slice ->
Row(verticalAlignment = Alignment.CenterVertically) {
Box(
Modifier
.size(8.dp)
.clip(CircleShape)
.background(slice.color)
)
Spacer(Modifier.width(8.dp))
Text(
slice.label,
color = Palette.Fg,
fontSize = 12.sp,
maxLines = 1,
overflow = TextOverflow.Ellipsis,
modifier = Modifier.weight(1f),
)
Text(
String.format(Locale.getDefault(), "%.1f%%", slice.share * 100f),
color = Palette.Fg,
fontSize = 12.sp,
fontWeight = FontWeight.Bold,
)
}
}
}
}
}
}
}
// The four companies with most requests, then everything else
private fun companySlices(summary: StatsSummary, otherLabel: String): List<Slice> {
if (summary.total == 0L) return emptyList()
val top = Company.entries
.map { it to summary.companies[it.ordinal] }
.filter { it.second > 0 }
.sortedByDescending { it.second }
.take(SliceColors.size)
val slices = top.mapIndexed { index, (company, count) ->
Slice(company.label, count.toFloat() / summary.total, SliceColors[index])
}
val rest = (1f - slices.sumOf { it.share.toDouble() }.toFloat()).coerceAtLeast(0f)
return slices + Slice(otherLabel, rest, OtherColor)
}
@Composable
private fun Donut(slices: List<Slice>, modifier: Modifier = Modifier) {
Canvas(modifier) {
val stroke = 14.dp.toPx()
val diameter = size.minDimension - stroke
val topLeft = Offset((size.width - diameter) / 2f, (size.height - diameter) / 2f)
val arcSize = Size(diameter, diameter)
drawArc(OtherColor, 0f, 360f, useCenter = false, topLeft = topLeft, size = arcSize, style = Stroke(width = stroke))
var start = -90f
slices.forEach { slice ->
val sweep = slice.share * 360f
if (sweep > 0f) {
drawArc(slice.color, start, sweep, useCenter = false, topLeft = topLeft, size = arcSize, style = Stroke(width = stroke))
}
start += sweep
}
}
}
@Composable
private fun QueryRow(
modifier: Modifier,
entry: QueryEntry,
first: Boolean,
blockedByMe: Boolean,
onBlock: () -> Unit,
onUnblock: () -> Unit,
onCopy: () -> Unit,
) {
var menu by remember { mutableStateOf(false) }
val (avatarBackground, avatarColor) = when (entry.status) {
QueryStatus.BLOCKED -> Palette.Blocked.copy(alpha = 0.14f) to Palette.Blocked
QueryStatus.CACHED -> CachedColor.copy(alpha = 0.14f) to CachedColor
QueryStatus.FAILED -> WarningColor.copy(alpha = 0.14f) to WarningColor
QueryStatus.OK -> Color(0xFF2A2C33) to Palette.Fg
}
val detail = when (entry.status) {
QueryStatus.OK -> stringResource(R.string.mon_ms, entry.latencyMs)
QueryStatus.CACHED -> stringResource(R.string.status_cached)
QueryStatus.BLOCKED -> stringResource(if (blockedByMe) R.string.bl_my else R.string.tab_blocklist)
QueryStatus.FAILED -> stringResource(R.string.status_failed)
}
Box(modifier.fillMaxWidth()) {
Column {
if (!first) HorizontalDivider(color = Palette.Line)
Row(
modifier = Modifier
.fillMaxWidth()
.clickable { menu = true }
.padding(vertical = 10.dp),
verticalAlignment = Alignment.CenterVertically,
) {
Box(
modifier = Modifier
.size(34.dp)
.clip(CircleShape)
.background(avatarBackground),
contentAlignment = Alignment.Center,
) {
Text(initialOf(entry.domain), color = avatarColor, fontSize = 13.sp, fontWeight = FontWeight.ExtraBold)
}
Spacer(Modifier.width(12.dp))
Column(Modifier.weight(1f)) {
Text(
entry.domain,
color = Palette.Fg,
fontSize = 14.sp,
fontWeight = FontWeight.Bold,
maxLines = 1,
overflow = TextOverflow.Ellipsis,
)
Text(
"${DnsMessage.typeName(entry.type)} · $detail",
color = Palette.Fg3,
fontSize = 12.sp,
maxLines = 1,
overflow = TextOverflow.Ellipsis,
)
}
Spacer(Modifier.width(8.dp))
Column(horizontalAlignment = Alignment.End) {
if (entry.status == QueryStatus.BLOCKED) {
Text(stringResource(R.string.status_blocked), color = Palette.Blocked, fontSize = 12.sp, fontWeight = FontWeight.Bold)
} else if (entry.status == QueryStatus.FAILED) {
Text(stringResource(R.string.status_failed), color = WarningColor, fontSize = 12.sp, fontWeight = FontWeight.Bold)
}
Text(TimeFormat.format(Date(entry.time)), color = Palette.Fg3, fontSize = 12.sp)
}
}
}
DropdownMenu(expanded = menu, onDismissRequest = { menu = false }) {
if (blockedByMe) {
DropdownMenuItem(
text = { Text(stringResource(R.string.mon_unblock)) },
onClick = {
menu = false
onUnblock()
},
)
} else if (entry.status != QueryStatus.BLOCKED) {
DropdownMenuItem(
text = { Text(stringResource(R.string.mon_block)) },
onClick = {
menu = false
onBlock()
},
)
}
DropdownMenuItem(
text = { Text(stringResource(R.string.copy)) },
onClick = {
menu = false
onCopy()
},
)
}
}
}
// First letter of the main part of a domain: "a" for app-measurement.com, "g" for www.google.com
private fun initialOf(domain: String): String {
val parts = domain.split('.').filter { it.isNotEmpty() }
val main = if (parts.size >= 2) parts[parts.size - 2] else parts.firstOrNull().orEmpty()
return main.firstOrNull { it.isLetterOrDigit() }?.toString() ?: "·"
}
@@ -4,84 +4,185 @@ import androidx.activity.compose.BackHandler
import androidx.annotation.DrawableRes
import androidx.annotation.StringRes
import androidx.compose.animation.AnimatedContent
import androidx.compose.animation.AnimatedVisibility
import androidx.compose.animation.animateColorAsState
import androidx.compose.animation.fadeIn
import androidx.compose.animation.fadeOut
import androidx.compose.animation.slideInHorizontally
import androidx.compose.animation.slideOutHorizontally
import androidx.compose.animation.togetherWith
import androidx.compose.foundation.layout.consumeWindowInsets
import androidx.compose.foundation.background
import androidx.compose.foundation.border
import androidx.compose.foundation.layout.Arrangement
import androidx.compose.foundation.layout.Box
import androidx.compose.foundation.layout.Row
import androidx.compose.foundation.layout.WindowInsets
import androidx.compose.foundation.layout.asPaddingValues
import androidx.compose.foundation.layout.fillMaxSize
import androidx.compose.foundation.layout.fillMaxWidth
import androidx.compose.foundation.layout.height
import androidx.compose.foundation.layout.imePadding
import androidx.compose.foundation.layout.navigationBars
import androidx.compose.foundation.layout.navigationBarsPadding
import androidx.compose.foundation.layout.padding
import androidx.compose.foundation.layout.size
import androidx.compose.foundation.layout.statusBarsPadding
import androidx.compose.foundation.selection.selectable
import androidx.compose.foundation.selection.selectableGroup
import androidx.compose.foundation.shape.RoundedCornerShape
import androidx.compose.material3.Icon
import androidx.compose.material3.NavigationBar
import androidx.compose.material3.NavigationBarItem
import androidx.compose.material3.Scaffold
import androidx.compose.material3.Text
import androidx.compose.runtime.Composable
import androidx.compose.runtime.getValue
import androidx.compose.runtime.mutableStateOf
import androidx.compose.runtime.saveable.rememberSaveable
import androidx.compose.runtime.setValue
import androidx.compose.ui.Alignment
import androidx.compose.ui.Modifier
import androidx.compose.ui.draw.clip
import androidx.compose.ui.draw.shadow
import androidx.compose.ui.graphics.Brush
import androidx.compose.ui.graphics.Color
import androidx.compose.ui.res.painterResource
import androidx.compose.ui.res.stringResource
import androidx.compose.ui.text.style.TextOverflow
import androidx.compose.ui.semantics.Role
import androidx.compose.ui.semantics.contentDescription
import androidx.compose.ui.semantics.semantics
import androidx.compose.ui.unit.dp
private enum class Tab(@StringRes val label: Int, @DrawableRes val icon: Int) {
HOME(R.string.tab_home, R.drawable.ic_tab_home),
MONITOR(R.string.tab_monitor, R.drawable.ic_tab_monitor),
APPS(R.string.tab_apps, R.drawable.ic_tab_apps),
BLOCKLIST(R.string.tab_blocklist, R.drawable.ic_tab_block),
ABOUT(R.string.tab_about, R.drawable.ic_tab_info),
// The three tabs of the bottom panel, then the pages opened from them
private enum class Screen(@StringRes val label: Int, @DrawableRes val icon: Int, val isTab: Boolean) {
HOME(R.string.tab_home, R.drawable.ic_tab_home, true),
ACTIVITY(R.string.tab_activity, R.drawable.ic_tab_monitor, true),
SETTINGS(R.string.tab_settings, R.drawable.ic_tab_settings, true),
BLOCKLIST(R.string.blocklist_title, R.drawable.ic_tab_block, false),
APPS(R.string.settings_apps, R.drawable.ic_tab_apps, false),
ABOUT(R.string.tab_about, R.drawable.ic_tab_info, false),
}
@Composable
fun AppShell() {
var tab by rememberSaveable { mutableStateOf(Tab.HOME) }
var tab by rememberSaveable { mutableStateOf(Screen.HOME) }
var page by rememberSaveable { mutableStateOf<Screen?>(null) }
val current = page ?: tab
// Back leads to Home first; only Home closes the app
BackHandler(enabled = tab != Tab.HOME) { tab = Tab.HOME }
// Back closes an open page first, then leads to Home; only Home closes the app
BackHandler(enabled = page == null && tab != Screen.HOME) { tab = Screen.HOME }
BackHandler(enabled = page != null) { page = null }
Scaffold(
bottomBar = {
NavigationBar {
Tab.entries.forEach { item ->
NavigationBarItem(
selected = tab == item,
onClick = { tab = item },
icon = { Icon(painterResource(item.icon), contentDescription = null) },
label = {
Text(stringResource(item.label), maxLines = 1, overflow = TextOverflow.Ellipsis)
},
)
}
}
},
) { padding ->
// Screens drift a little in the direction of the tab that was picked and cross-fade
val navInset = WindowInsets.navigationBars.asPaddingValues().calculateBottomPadding()
// Room under the last item of a tab, so it can scroll clear of the floating panel
val tabBottom = navInset + 112.dp
val pageBottom = navInset + 24.dp
Box(
Modifier
.fillMaxSize()
.background(Palette.Bg)
) {
AnimatedContent(
targetState = tab,
targetState = current,
transitionSpec = {
val forward = targetState.ordinal > initialState.ordinal
val shift = { width: Int -> if (forward) width / 8 else -width / 8 }
// Pages slide in from the side; tabs drift a little towards the tab that was picked
val pageMove = targetState.isTab != initialState.isTab
val forward = if (pageMove) !targetState.isTab else targetState.ordinal > initialState.ordinal
val divisor = if (pageMove) 3 else 8
val shift = { width: Int -> if (forward) width / divisor else -width / divisor }
(fadeIn(Motion.enterFade) + slideInHorizontally(Motion.slide) { shift(it) }) togetherWith
(fadeOut(Motion.exitFade) + slideOutHorizontally(Motion.slide) { -shift(it) })
},
modifier = Modifier
.fillMaxSize()
.padding(padding)
.consumeWindowInsets(padding)
.statusBarsPadding()
.imePadding(),
label = "tabs",
) { current ->
label = "screens",
) { screen ->
val modifier = Modifier.fillMaxSize()
when (current) {
Tab.HOME -> HomeScreen(modifier)
Tab.MONITOR -> MonitorScreen(modifier)
Tab.APPS -> AppsScreen(modifier)
Tab.BLOCKLIST -> BlocklistScreen(modifier)
Tab.ABOUT -> AboutScreen(modifier)
when (screen) {
Screen.HOME -> HomeScreen(
bottomPadding = tabBottom,
onOpenBlocklist = { page = Screen.BLOCKLIST },
modifier = modifier,
)
Screen.ACTIVITY -> ActivityScreen(bottomPadding = tabBottom, modifier = modifier)
Screen.SETTINGS -> SettingsScreen(
bottomPadding = tabBottom,
onOpenApps = { page = Screen.APPS },
onOpenAbout = { page = Screen.ABOUT },
modifier = modifier,
)
Screen.BLOCKLIST -> BlocklistScreen(bottomPadding = pageBottom, onBack = { page = null }, modifier = modifier)
Screen.APPS -> SubPage(stringResource(R.string.settings_apps), onBack = { page = null }, modifier = modifier) {
AppsScreen(Modifier.fillMaxSize())
}
Screen.ABOUT -> SubPage(stringResource(R.string.tab_about), onBack = { page = null }, modifier = modifier) {
AboutScreen(Modifier.fillMaxSize())
}
}
}
AnimatedVisibility(
visible = page == null,
enter = fadeIn(Motion.enterFade),
exit = fadeOut(Motion.exitFade),
modifier = Modifier.align(Alignment.BottomCenter),
) {
Box(contentAlignment = Alignment.BottomCenter) {
// Content scrolling under the panel fades out instead of being cut off
Box(
Modifier
.fillMaxWidth()
.height(120.dp + navInset)
.background(Brush.verticalGradient(0f to Color.Transparent, 0.7f to Palette.Bg))
)
NavPill(
current = tab,
onSelect = { tab = it },
modifier = Modifier
.navigationBarsPadding()
.padding(bottom = 20.dp),
)
}
}
}
}
// Floating bottom panel: dark, with the picked tab lit in the accent color
@Composable
private fun NavPill(current: Screen, onSelect: (Screen) -> Unit, modifier: Modifier = Modifier) {
val shape = RoundedCornerShape(30.dp)
Row(
modifier = modifier
.shadow(18.dp, shape)
.clip(shape)
.background(Palette.Nav)
.border(1.dp, Color.White.copy(alpha = 0.07f), shape)
.padding(6.dp)
.selectableGroup(),
horizontalArrangement = Arrangement.spacedBy(4.dp),
) {
Screen.entries.filter { it.isTab }.forEach { item ->
val selected = item == current
val background by animateColorAsState(
if (selected) Palette.AccentSoft else Color.Transparent,
animationSpec = Motion.color,
label = "navBackground",
)
val tint by animateColorAsState(
if (selected) Palette.Accent else Palette.NavIcon,
animationSpec = Motion.color,
label = "navTint",
)
val label = stringResource(item.label)
Box(
modifier = Modifier
.size(width = 58.dp, height = 44.dp)
.clip(RoundedCornerShape(22.dp))
.background(background)
.selectable(selected = selected, onClick = { onSelect(item) }, role = Role.Tab)
.semantics { contentDescription = label },
contentAlignment = Alignment.Center,
) {
Icon(painterResource(item.icon), contentDescription = null, tint = tint, modifier = Modifier.size(22.dp))
}
}
}
@@ -338,7 +338,7 @@ private fun AppRow(modifier: Modifier, app: AppItem, enabled: Boolean, last: Boo
)
}
Spacer(Modifier.width(12.dp))
Switch(checked = enabled, onCheckedChange = null)
Switch(checked = enabled, onCheckedChange = null, colors = appSwitchColors())
}
}
}
@@ -0,0 +1,66 @@
package cc.skysparkle.sparkledns
import android.app.job.JobInfo
import android.app.job.JobParameters
import android.app.job.JobScheduler
import android.app.job.JobService
import android.content.ComponentName
import android.content.Context
import android.util.Log
import java.util.concurrent.TimeUnit
enum class UpdateInterval(val days: Long) { OFF(0), DAILY(1), WEEKLY(7) }
// Downloads newer versions of the user's blocklists in the background. Uses the system
// JobScheduler, so the app needs no extra library and nothing runs while the conditions are not met.
object AutoUpdate {
private const val JOB_ID = 4201
// JobInfo.networkType is deprecated in favour of NetworkRequest, which needs API 28
@Suppress("DEPRECATION")
fun apply(context: Context) {
val prefs = Prefs(context)
val scheduler = context.getSystemService(JobScheduler::class.java) ?: return
val interval = prefs.updateInterval
if (interval == UpdateInterval.OFF) {
scheduler.cancel(JOB_ID)
return
}
val period = TimeUnit.DAYS.toMillis(interval.days)
val network = if (prefs.updateWifiOnly) JobInfo.NETWORK_TYPE_UNMETERED else JobInfo.NETWORK_TYPE_ANY
// Scheduling the same job again would start its period over, so an unchanged one is kept
val existing = scheduler.getPendingJob(JOB_ID)
if (existing != null && existing.intervalMillis == period && existing.networkType == network) return
val job = JobInfo.Builder(JOB_ID, ComponentName(context, BlocklistUpdateJob::class.java))
.setPeriodic(period)
.setRequiredNetworkType(network)
.setRequiresBatteryNotLow(true)
.setPersisted(true)
.build()
try {
scheduler.schedule(job)
} catch (e: RuntimeException) {
Log.w("SparkleDNS", "Cannot schedule blocklist updates", e)
}
}
}
class BlocklistUpdateJob : JobService() {
override fun onStartJob(params: JobParameters): Boolean {
Thread({
val ok = try {
Blocklist.updateAllNow(applicationContext)
} catch (e: Exception) {
Log.w("SparkleDNS", "Blocklist update failed", e)
false
}
// A failed run is retried later with the system's back-off
jobFinished(params, !ok)
}, "blocklist-update").start()
return true
}
// Downloads cannot be cut short halfway; the next run picks up where this one stopped
override fun onStopJob(params: JobParameters): Boolean = true
}
@@ -24,7 +24,8 @@ import java.nio.channels.FileChannel
import java.security.MessageDigest
import java.util.concurrent.TimeUnit
data class RemoteList(val url: String, val count: Int, val updated: Long)
// A switched-off list keeps its file, so switching it on again needs no download
data class RemoteList(val url: String, val count: Int, val updated: Long, val enabled: Boolean = true)
// Blocks a domain together with all its subdomains. Changes apply instantly, no reconnect needed.
// Domains are kept as sorted 64-bit hashes: about 8 bytes per entry, so million-entry lists fit easily.
@@ -104,6 +105,15 @@ object Blocklist {
reloadListHashes(store)
}
fun setListEnabled(context: Context, url: String, value: Boolean) = synchronized(lock) {
val store = BlocklistStore(context)
ensureLoaded(store)
val updated = _lists.value.map { if (it.url == url) it.copy(enabled = value) else it }
store.saveLists(updated)
_lists.value = updated
reloadListHashes(store)
}
// Downloads run in the background, outside the lock, so editing own domains never waits for them.
// Returns false when another download is already running.
fun download(context: Context, url: String): Boolean {
@@ -125,11 +135,12 @@ object Blocklist {
return true
}
// Switched-off lists are skipped: nobody uses them until they are switched on again
fun updateAll(context: Context): Boolean {
if (_lists.value.isEmpty() || !_busy.compareAndSet(null, ALL_LISTS)) return false
val current = _lists.value.filter { it.enabled }
if (current.isEmpty() || !_busy.compareAndSet(null, ALL_LISTS)) return false
_error.value = null
val store = BlocklistStore(context.applicationContext)
val current = _lists.value
scope.launch {
try {
val fresh = current.mapNotNull { list ->
@@ -150,10 +161,38 @@ object Blocklist {
return true
}
// Blocking, for the background update job. Returns false when a list could not be downloaded.
fun updateAllNow(context: Context): Boolean {
val store = BlocklistStore(context.applicationContext)
synchronized(lock) { ensureLoaded(store) }
val current = _lists.value.filter { it.enabled }
// Nothing to do, or the user is updating right now
if (current.isEmpty() || !_busy.compareAndSet(null, ALL_LISTS)) return true
var ok = true
try {
val fresh = current.mapNotNull { list ->
try {
store.download(list.url, list)
} catch (e: Exception) {
Log.w("SparkleDNS", "Cannot update ${list.url}", e)
ok = false
null
}
}
commit(store, fresh)
} catch (e: IOException) {
Log.w("SparkleDNS", "Cannot save updated lists", e)
ok = false
} finally {
_busy.value = null
}
return ok
}
private fun commit(store: BlocklistStore, fresh: List<RemoteList>) = synchronized(lock) {
ensureLoaded(store)
val byUrl = fresh.associateBy { it.url }
val kept = _lists.value.map { byUrl[it.url] ?: it }
val kept = _lists.value.map { old -> byUrl[old.url]?.copy(enabled = old.enabled) ?: old }
val added = fresh.filter { new -> kept.none { it.url == new.url } }
val updated = kept + added
store.saveLists(updated)
@@ -176,7 +215,7 @@ object Blocklist {
}
private fun reloadListHashes(store: BlocklistStore) {
listHashes = mergeSorted(_lists.value.map { store.loadListHashes(it.url) })
listHashes = mergeSorted(_lists.value.filter { it.enabled }.map { store.loadListHashes(it.url) })
_total.value = unionSize(listHashes, customHashes)
}
@@ -301,7 +340,7 @@ private class BlocklistStore(context: Context) {
val array = JSONArray(raw)
(0 until array.length()).map {
val o = array.getJSONObject(it)
RemoteList(o.getString("url"), o.getInt("count"), o.getLong("updated"))
RemoteList(o.getString("url"), o.getInt("count"), o.getLong("updated"), o.optBoolean("enabled", true))
}
}.getOrDefault(emptyList())
}
@@ -309,7 +348,9 @@ private class BlocklistStore(context: Context) {
fun saveLists(lists: List<RemoteList>) {
val array = JSONArray()
lists.forEach {
array.put(JSONObject().put("url", it.url).put("count", it.count).put("updated", it.updated))
array.put(
JSONObject().put("url", it.url).put("count", it.count).put("updated", it.updated).put("enabled", it.enabled)
)
}
sp.edit().putString("lists", array.toString()).commit()
}
@@ -2,38 +2,42 @@ package cc.skysparkle.sparkledns
import android.content.Context
import android.net.Uri
import android.text.format.DateUtils
import android.widget.Toast
import androidx.annotation.StringRes
import androidx.compose.animation.AnimatedVisibility
import androidx.compose.animation.animateContentSize
import androidx.compose.animation.core.animateFloatAsState
import androidx.compose.foundation.background
import androidx.compose.foundation.horizontalScroll
import androidx.compose.foundation.border
import androidx.compose.foundation.clickable
import androidx.compose.foundation.layout.Arrangement
import androidx.compose.foundation.layout.Box
import androidx.compose.foundation.layout.Column
import androidx.compose.foundation.layout.PaddingValues
import androidx.compose.foundation.layout.Row
import androidx.compose.foundation.layout.Spacer
import androidx.compose.foundation.layout.fillMaxSize
import androidx.compose.foundation.layout.fillMaxWidth
import androidx.compose.foundation.layout.height
import androidx.compose.foundation.layout.heightIn
import androidx.compose.foundation.layout.padding
import androidx.compose.foundation.layout.size
import androidx.compose.foundation.layout.width
import androidx.compose.foundation.lazy.LazyColumn
import androidx.compose.foundation.lazy.items
import androidx.compose.foundation.lazy.itemsIndexed
import androidx.compose.foundation.rememberScrollState
import androidx.compose.foundation.shape.ZeroCornerSize
import androidx.compose.foundation.selection.selectable
import androidx.compose.foundation.selection.toggleable
import androidx.compose.foundation.shape.RoundedCornerShape
import androidx.compose.foundation.text.KeyboardActions
import androidx.compose.foundation.text.KeyboardOptions
import androidx.compose.material3.AssistChip
import androidx.compose.material3.Card
import androidx.compose.material3.CardDefaults
import androidx.compose.material3.FilledTonalButton
import androidx.compose.material3.AlertDialog
import androidx.compose.material3.Button
import androidx.compose.material3.HorizontalDivider
import androidx.compose.material3.Icon
import androidx.compose.material3.IconButton
import androidx.compose.material3.LinearProgressIndicator
import androidx.compose.material3.MaterialTheme
import androidx.compose.material3.OutlinedTextField
import androidx.compose.material3.Switch
import androidx.compose.material3.RadioButton
import androidx.compose.material3.Text
import androidx.compose.material3.TextButton
import androidx.compose.runtime.Composable
@@ -45,50 +49,72 @@ import androidx.compose.runtime.saveable.rememberSaveable
import androidx.compose.runtime.setValue
import androidx.compose.ui.Alignment
import androidx.compose.ui.Modifier
import androidx.compose.ui.draw.clip
import androidx.compose.ui.graphics.RectangleShape
import androidx.compose.ui.graphics.Shape
import androidx.compose.ui.graphics.graphicsLayer
import androidx.compose.ui.platform.LocalContext
import androidx.compose.ui.res.painterResource
import androidx.compose.ui.res.stringResource
import androidx.compose.ui.semantics.Role
import androidx.compose.ui.text.font.FontWeight
import androidx.compose.ui.text.input.ImeAction
import androidx.compose.ui.text.input.KeyboardType
import androidx.compose.ui.text.style.TextOverflow
import androidx.compose.ui.unit.Dp
import androidx.compose.ui.unit.dp
import androidx.compose.ui.unit.sp
import androidx.lifecycle.compose.collectAsStateWithLifecycle
import kotlinx.coroutines.CoroutineScope
import kotlinx.coroutines.Dispatchers
import kotlinx.coroutines.launch
import kotlinx.coroutines.withContext
import java.io.IOException
import java.text.DateFormat
import java.util.Date
private class Preset(val name: String, val url: String, @StringRes val description: Int)
private const val HAGEZI_HOME = "https://github.com/hagezi/dns-blocklists"
private val Presets = listOf(
"HaGeZi Pro++" to "https://raw.githubusercontent.com/hagezi/dns-blocklists/main/adblock/pro.plus.txt",
"HaGeZi TIF" to "https://raw.githubusercontent.com/hagezi/dns-blocklists/main/adblock/tif.txt",
Preset("HaGeZi Pro", "https://raw.githubusercontent.com/hagezi/dns-blocklists/main/adblock/pro.txt", R.string.preset_pro_desc),
Preset("HaGeZi Pro++", "https://raw.githubusercontent.com/hagezi/dns-blocklists/main/adblock/pro.plus.txt", R.string.preset_proplus_desc),
Preset("HaGeZi TIF", "https://raw.githubusercontent.com/hagezi/dns-blocklists/main/adblock/tif.txt", R.string.preset_tif_desc),
)
private val TopShape = RoundedCornerShape(topStart = 20.dp, topEnd = 20.dp)
private val BottomShape = RoundedCornerShape(bottomStart = 20.dp, bottomEnd = 20.dp)
@Composable
fun BlocklistScreen(modifier: Modifier = Modifier) {
fun BlocklistScreen(bottomPadding: Dp, onBack: () -> Unit, modifier: Modifier = Modifier) {
val context = LocalContext.current
val scope = rememberCoroutineScope()
val prefs = remember { Prefs(context) }
var showNote by remember { mutableStateOf(!prefs.isHintDismissed(HINT_BLOCKLIST)) }
val enabled by Blocklist.enabled.collectAsStateWithLifecycle()
val total by Blocklist.total.collectAsStateWithLifecycle()
val custom by Blocklist.custom.collectAsStateWithLifecycle()
val lists by Blocklist.lists.collectAsStateWithLifecycle()
var domainInput by rememberSaveable { mutableStateOf("") }
var domainError by remember { mutableStateOf(false) }
var urlInput by rememberSaveable { mutableStateOf("") }
// Downloads live in Blocklist, so they keep running and stay visible across tab switches
// Downloads live in Blocklist, so they keep running and stay visible when the page is closed
val busy by Blocklist.busy.collectAsStateWithLifecycle()
val error by Blocklist.error.collectAsStateWithLifecycle()
val lastError = remember { arrayOf("") } // kept while the card animates out
error?.let { lastError[0] = it }
var search by rememberSaveable { mutableStateOf("") }
var domainsOpen by rememberSaveable { mutableStateOf(false) }
var domainInput by rememberSaveable { mutableStateOf("") }
var domainError by remember { mutableStateOf(false) }
var showAddList by rememberSaveable { mutableStateOf(false) }
var showUpdates by rememberSaveable { mutableStateOf(false) }
var interval by remember { mutableStateOf(prefs.updateInterval) }
var wifiOnly by remember { mutableStateOf(prefs.updateWifiOnly) }
val term = search.trim()
fun matches(vararg texts: String) = term.isEmpty() || texts.any { it.contains(term, ignoreCase = true) }
val presetUrls = remember { Presets.map { it.url }.toSet() }
val ownLists = lists.filter { it.url !in presetUrls }
val shownDomains = if (term.isEmpty()) custom else custom.filter { it.contains(term, ignoreCase = true) }
fun addDomain() {
val input = domainInput
if (input.isBlank()) return
@@ -101,74 +127,111 @@ fun BlocklistScreen(modifier: Modifier = Modifier) {
}
}
fun addList() {
val url = urlInput.trim()
if (url.isNotEmpty() && Blocklist.download(context, url)) urlInput = ""
}
// Own domains are lazy rows, so hundreds of them are not all composed when the tab opens.
// Together they look like the card they used to be in: same color and shape, split per row.
val cardColor = CardDefaults.cardColors().containerColor
val cardShape = MaterialTheme.shapes.medium
val cardTop = cardShape.copy(bottomStart = ZeroCornerSize, bottomEnd = ZeroCornerSize)
val cardBottom = cardShape.copy(topStart = ZeroCornerSize, topEnd = ZeroCornerSize)
LazyColumn(
modifier = modifier.fillMaxSize(),
contentPadding = PaddingValues(16.dp),
modifier = modifier,
contentPadding = PaddingValues(start = 20.dp, end = 20.dp, bottom = bottomPadding),
) {
item(key = "summary") {
Column(verticalArrangement = Arrangement.spacedBy(12.dp)) {
Card(Modifier.fillMaxWidth()) {
Row(Modifier.padding(16.dp), verticalAlignment = Alignment.CenterVertically) {
IconBadge(
R.drawable.ic_tab_block,
tint = if (enabled) MaterialTheme.colorScheme.error else MaterialTheme.colorScheme.outline,
size = 52.dp,
)
Spacer(Modifier.width(16.dp))
Column(Modifier.weight(1f)) {
Text(stringResource(R.string.bl_title), style = MaterialTheme.typography.titleMedium)
Text(
formatCount(total.toLong()),
style = MaterialTheme.typography.headlineSmall,
fontWeight = FontWeight.SemiBold,
)
Text(
stringResource(R.string.bl_total_label),
style = MaterialTheme.typography.bodySmall,
color = MaterialTheme.colorScheme.onSurfaceVariant,
)
}
Switch(checked = enabled, onCheckedChange = { Blocklist.setEnabled(context, it) })
}
}
item(key = "header") {
PageHeader(
title = stringResource(R.string.blocklist_title),
onBack = onBack,
action = {
AppSwitch(checked = enabled, onCheckedChange = { Blocklist.setEnabled(context, it) })
},
)
}
AnimatedVisibility(visible = showNote, enter = Motion.expandIn, exit = Motion.collapseOut) {
item(key = "search") {
SearchField(
value = search,
onValueChange = { search = it },
placeholder = stringResource(R.string.bl_search),
modifier = Modifier.padding(top = 4.dp),
)
}
item(key = "updates") {
UpdatesRow(
interval = interval,
wifiOnly = wifiOnly,
onClick = { showUpdates = true },
modifier = Modifier.padding(top = 12.dp),
)
}
item(key = "error") {
AnimatedVisibility(visible = error != null, enter = Motion.expandIn, exit = Motion.collapseOut) {
Box(Modifier.padding(top = 12.dp)) {
HintCard(
stringResource(R.string.bl_note),
icon = R.drawable.ic_tab_info,
onDismiss = {
showNote = false
prefs.dismissHint(HINT_BLOCKLIST)
},
stringResource(R.string.bl_download_failed, lastError[0]),
icon = R.drawable.ic_alert,
tint = Palette.Blocked,
)
}
SectionHeader(stringResource(R.string.bl_my), icon = R.drawable.ic_tab_block)
}
}
item(key = "custom") {
Column(
Modifier
.padding(top = 12.dp)
.fillMaxWidth()
.background(cardColor, if (custom.isEmpty()) cardShape else cardTop)
.padding(top = 8.dp, bottom = if (custom.isEmpty()) 8.dp else 0.dp)
items(Presets.filter { matches(it.name) }, key = { "preset:${it.url}" }) { preset ->
val list = lists.firstOrNull { it.url == preset.url }
val downloading = busy == preset.url || (busy == Blocklist.ALL_LISTS && list?.enabled == true)
BlocklistCard(
title = preset.name,
description = stringResource(preset.description),
source = "hagezi",
sourceUrl = HAGEZI_HOME,
info = listInfo(list, downloading),
checked = list?.enabled == true || busy == preset.url,
// A list that is not downloaded yet waits for a running download to finish
switchEnabled = list != null || busy == null,
progress = downloading,
onCheckedChange = { on ->
if (list == null) {
if (on) Blocklist.download(context, preset.url)
} else {
scope.editBlocklist(context) { Blocklist.setListEnabled(context, preset.url, on) }
}
},
modifier = Modifier
.animateItem()
.padding(top = 12.dp),
)
}
items(ownLists.filter { matches(it.url) }, key = { "list:${it.url}" }) { list ->
val uri = remember(list.url) { Uri.parse(list.url) }
val downloading = busy == list.url || (busy == Blocklist.ALL_LISTS && list.enabled)
BlocklistCard(
title = uri.lastPathSegment ?: uri.host ?: list.url,
description = stringResource(R.string.list_added_by_you),
source = uri.host ?: "",
sourceUrl = null,
info = listInfo(list, downloading),
checked = list.enabled,
switchEnabled = true,
progress = downloading,
onCheckedChange = { on -> scope.editBlocklist(context) { Blocklist.setListEnabled(context, list.url, on) } },
onDelete = if (busy == null) {
{ scope.editBlocklist(context) { Blocklist.removeList(context, list.url) } }
} else {
null
},
modifier = Modifier
.animateItem()
.padding(top = 12.dp),
)
}
item(key = "domains") {
MyDomainsHeader(
count = custom.size,
open = domainsOpen,
onToggle = { domainsOpen = !domainsOpen },
shape = if (domainsOpen) TopShape else CardShape,
modifier = Modifier.padding(top = 12.dp),
) {
// Input to add a domain; the accent button matches the rest of the app
Row(
modifier = Modifier.padding(horizontal = 12.dp, vertical = 4.dp),
modifier = Modifier.padding(start = 16.dp, end = 16.dp, bottom = 12.dp),
verticalAlignment = Alignment.CenterVertically,
) {
OutlinedTextField(
@@ -177,223 +240,433 @@ fun BlocklistScreen(modifier: Modifier = Modifier) {
placeholder = { Text(stringResource(R.string.bl_domain_hint), maxLines = 1) },
singleLine = true,
isError = domainError,
shape = RoundedCornerShape(14.dp),
keyboardOptions = KeyboardOptions(keyboardType = KeyboardType.Uri, imeAction = ImeAction.Done),
keyboardActions = KeyboardActions(onDone = { addDomain() }),
modifier = Modifier.weight(1f),
)
Spacer(Modifier.width(8.dp))
FilledTonalButton(onClick = ::addDomain, enabled = domainInput.isNotBlank()) {
Icon(painterResource(R.drawable.ic_add_domain), contentDescription = null, modifier = Modifier.size(18.dp))
Button(
onClick = ::addDomain,
enabled = domainInput.isNotBlank(),
shape = RoundedCornerShape(14.dp),
contentPadding = PaddingValues(horizontal = 18.dp),
modifier = Modifier.height(56.dp),
) {
Icon(painterResource(R.drawable.ic_add), contentDescription = null, modifier = Modifier.size(18.dp))
Spacer(Modifier.width(6.dp))
Text(stringResource(R.string.add))
Text(stringResource(R.string.add), fontWeight = FontWeight.Bold)
}
}
AnimatedVisibility(visible = domainError, enter = Motion.expandIn, exit = Motion.collapseOut) {
Text(
stringResource(R.string.bl_invalid),
style = MaterialTheme.typography.bodySmall,
color = MaterialTheme.colorScheme.error,
modifier = Modifier.padding(horizontal = 16.dp),
color = Palette.Blocked,
fontSize = 12.sp,
modifier = Modifier.padding(start = 16.dp, end = 16.dp, bottom = 8.dp),
)
}
if (custom.isEmpty()) {
Text(
stringResource(R.string.bl_empty_custom),
style = MaterialTheme.typography.bodySmall,
color = MaterialTheme.colorScheme.onSurfaceVariant,
modifier = Modifier.padding(horizontal = 16.dp, vertical = 8.dp),
color = Palette.Fg3,
fontSize = 13.sp,
modifier = Modifier.padding(start = 16.dp, end = 16.dp, bottom = 8.dp),
)
}
}
}
itemsIndexed(custom, key = { _, domain -> "domain:$domain" }, contentType = { _, _ -> "domain" }) { index, domain ->
val last = index == custom.lastIndex
Column(
Modifier
.animateItem()
.fillMaxWidth()
.background(cardColor, if (last) cardBottom else RectangleShape)
.padding(bottom = if (last) 8.dp else 0.dp)
) {
InsetDivider(16)
Row(
modifier = Modifier.padding(start = 16.dp, end = 4.dp),
verticalAlignment = Alignment.CenterVertically,
) {
Text(domain, modifier = Modifier.weight(1f), maxLines = 1, overflow = TextOverflow.Ellipsis)
IconButton(onClick = { scope.editBlocklist(context) { Blocklist.removeCustom(context, domain) } }) {
Icon(painterResource(R.drawable.ic_delete), stringResource(R.string.delete), Modifier.size(20.dp))
}
}
}
}
item(key = "lists") {
Column(Modifier.padding(top = 12.dp), verticalArrangement = Arrangement.spacedBy(12.dp)) {
SectionHeader(
stringResource(R.string.bl_lists),
icon = R.drawable.ic_list,
action = {
TextButton(
onClick = { Blocklist.updateAll(context) },
enabled = lists.isNotEmpty() && busy == null,
) {
Icon(painterResource(R.drawable.ic_refresh), contentDescription = null, modifier = Modifier.size(18.dp))
Spacer(Modifier.width(6.dp))
Text(stringResource(if (busy == Blocklist.ALL_LISTS) R.string.bl_updating else R.string.bl_update_all))
}
},
// Own domains are lazy rows, so hundreds of them are not all composed at once.
// Together with the header above they look like one card.
if (domainsOpen) {
itemsIndexed(shownDomains, key = { _, domain -> "domain:$domain" }, contentType = { _, _ -> "domain" }) { index, domain ->
val last = index == shownDomains.lastIndex
DomainRow(
domain = domain,
shape = if (last) BottomShape else RectangleShape,
onDelete = { scope.editBlocklist(context) { Blocklist.removeCustom(context, domain) } },
modifier = Modifier.animateItem(),
)
Card(Modifier.fillMaxWidth()) {
Column(
}
if (shownDomains.isEmpty()) {
item(key = "domains-end") {
Box(
Modifier
.animateContentSize(Motion.size)
.padding(vertical = 8.dp)
) {
lists.forEachIndexed { index, list ->
if (index > 0) InsetDivider(68)
ListRow(
list = list,
updating = busy == list.url || busy == Blocklist.ALL_LISTS,
actionsEnabled = busy == null,
onRefresh = { Blocklist.download(context, list.url) },
onDelete = { scope.editBlocklist(context) { Blocklist.removeList(context, list.url) } },
)
}
if (lists.isNotEmpty()) InsetDivider(16)
Row(
modifier = Modifier.padding(horizontal = 12.dp, vertical = 8.dp),
verticalAlignment = Alignment.CenterVertically,
) {
OutlinedTextField(
value = urlInput,
onValueChange = { urlInput = it },
placeholder = { Text(stringResource(R.string.bl_list_url), maxLines = 1) },
singleLine = true,
keyboardOptions = KeyboardOptions(keyboardType = KeyboardType.Uri, imeAction = ImeAction.Done),
keyboardActions = KeyboardActions(onDone = { if (busy == null) addList() }),
modifier = Modifier.weight(1f),
)
Spacer(Modifier.width(8.dp))
FilledTonalButton(
onClick = ::addList,
enabled = urlInput.isNotBlank() && busy == null,
) {
Icon(painterResource(R.drawable.ic_add), contentDescription = null, modifier = Modifier.size(18.dp))
Spacer(Modifier.width(6.dp))
Text(stringResource(R.string.add))
}
}
// A new list being added has no row yet, so its progress shows under the input
val addingNew = busy != null && busy != Blocklist.ALL_LISTS && lists.none { it.url == busy }
AnimatedVisibility(visible = addingNew, enter = Motion.expandIn, exit = Motion.collapseOut) {
LinearProgressIndicator(
modifier = Modifier
.fillMaxWidth()
.padding(horizontal = 16.dp, vertical = 4.dp),
)
}
}
}
val missingPresets = Presets.filter { (_, url) -> lists.none { it.url == url } }
AnimatedVisibility(visible = missingPresets.isNotEmpty(), enter = Motion.expandIn, exit = Motion.collapseOut) {
Column(verticalArrangement = Arrangement.spacedBy(12.dp)) {
SectionHeader(stringResource(R.string.bl_presets))
Row(
modifier = Modifier.horizontalScroll(rememberScrollState()),
horizontalArrangement = Arrangement.spacedBy(8.dp),
) {
missingPresets.forEach { (name, url) ->
AssistChip(
onClick = { Blocklist.download(context, url) },
enabled = busy == null,
leadingIcon = {
Icon(painterResource(R.drawable.ic_add), contentDescription = null, modifier = Modifier.size(18.dp))
},
label = { Text(if (busy == url) stringResource(R.string.bl_updating) else name) },
)
}
}
}
}
AnimatedVisibility(visible = error != null, enter = Motion.expandIn, exit = Motion.collapseOut) {
HintCard(
stringResource(R.string.bl_download_failed, lastError[0]),
icon = R.drawable.ic_alert,
tint = MaterialTheme.colorScheme.error,
.fillMaxWidth()
.height(8.dp)
.clip(BottomShape)
.background(Palette.Card)
)
}
}
}
item(key = "add") {
Box(
Modifier
.fillMaxWidth()
.padding(top = 24.dp),
contentAlignment = Alignment.Center,
) {
Button(
onClick = { showAddList = true },
enabled = busy == null,
shape = RoundedCornerShape(24.dp),
contentPadding = PaddingValues(start = 16.dp, end = 22.dp),
modifier = Modifier.height(48.dp),
) {
Icon(painterResource(R.drawable.ic_add), contentDescription = null, modifier = Modifier.size(20.dp))
Spacer(Modifier.width(8.dp))
Text(stringResource(R.string.bl_add_list), fontWeight = FontWeight.ExtraBold)
}
}
}
}
if (showAddList) {
AddListDialog(
busy = busy != null,
onAdd = { url -> Blocklist.download(context, url) },
onDismiss = { showAddList = false },
)
}
if (showUpdates) {
UpdatesDialog(
interval = interval,
wifiOnly = wifiOnly,
canUpdateNow = busy == null && lists.any { it.enabled },
onInterval = {
interval = it
prefs.updateInterval = it
AutoUpdate.apply(context)
},
onWifiOnly = {
wifiOnly = it
prefs.updateWifiOnly = it
AutoUpdate.apply(context)
},
onUpdateNow = {
Blocklist.updateAll(context)
showUpdates = false
},
onDismiss = { showUpdates = false },
)
}
}
@Composable
private fun InsetDivider(start: Int) {
HorizontalDivider(
modifier = Modifier.padding(start = start.dp),
color = MaterialTheme.colorScheme.outlineVariant.copy(alpha = 0.5f),
private fun listInfo(list: RemoteList?, downloading: Boolean): String = when {
downloading -> stringResource(R.string.bl_updating)
list == null -> stringResource(R.string.list_not_downloaded)
else -> stringResource(
R.string.bl_list_info,
formatCount(list.count.toLong()),
DateUtils.getRelativeTimeSpanString(list.updated, System.currentTimeMillis(), DateUtils.MINUTE_IN_MILLIS).toString(),
)
}
@Composable
private fun ListRow(
list: RemoteList,
updating: Boolean,
actionsEnabled: Boolean,
onRefresh: () -> Unit,
onDelete: () -> Unit,
) {
val uri = remember(list.url) { Uri.parse(list.url) }
val title = uri.lastPathSegment ?: list.url
val updated = remember(list.updated) {
DateFormat.getDateTimeInstance(DateFormat.SHORT, DateFormat.SHORT).format(Date(list.updated))
private fun UpdatesRow(interval: UpdateInterval, wifiOnly: Boolean, onClick: () -> Unit, modifier: Modifier = Modifier) {
val shape = RoundedCornerShape(16.dp)
val label = stringResource(intervalLabel(interval))
val wifi = stringResource(R.string.auto_wifi)
val summary = if (interval != UpdateInterval.OFF && wifiOnly) "$label · $wifi" else label
Row(
modifier = modifier
.fillMaxWidth()
.clip(shape)
.border(1.dp, Palette.Line, shape)
.clickable(onClick = onClick)
.padding(horizontal = 14.dp, vertical = 10.dp),
verticalAlignment = Alignment.CenterVertically,
) {
Icon(painterResource(R.drawable.ic_refresh), contentDescription = null, tint = Palette.Accent, modifier = Modifier.size(20.dp))
Spacer(Modifier.width(12.dp))
Column(Modifier.weight(1f)) {
Text(stringResource(R.string.auto_update), color = Palette.Fg, fontSize = 14.sp, fontWeight = FontWeight.Bold)
Text(summary, color = Palette.Fg2, fontSize = 12.sp)
}
Chevron()
}
}
Column {
@StringRes
private fun intervalLabel(interval: UpdateInterval): Int = when (interval) {
UpdateInterval.OFF -> R.string.auto_off
UpdateInterval.DAILY -> R.string.auto_daily
UpdateInterval.WEEKLY -> R.string.auto_weekly
}
@Composable
private fun BlocklistCard(
title: String,
description: String,
source: String,
sourceUrl: String?,
info: String,
checked: Boolean,
switchEnabled: Boolean,
progress: Boolean,
onCheckedChange: (Boolean) -> Unit,
modifier: Modifier = Modifier,
onDelete: (() -> Unit)? = null,
) {
val context = LocalContext.current
Column(
modifier = modifier
.fillMaxWidth()
.appCard()
.padding(start = 16.dp, end = 10.dp, top = 6.dp, bottom = 14.dp),
) {
Row(verticalAlignment = Alignment.CenterVertically, modifier = Modifier.heightIn(min = 48.dp)) {
Text(
title,
color = Palette.Fg,
fontSize = 15.sp,
fontWeight = FontWeight.ExtraBold,
maxLines = 1,
overflow = TextOverflow.Ellipsis,
modifier = Modifier.weight(1f),
)
if (onDelete != null) {
IconButton(onClick = onDelete) {
Icon(
painterResource(R.drawable.ic_delete),
contentDescription = stringResource(R.string.delete),
tint = Palette.Fg3,
modifier = Modifier.size(20.dp),
)
}
}
AppSwitch(checked = checked, onCheckedChange = onCheckedChange, enabled = switchEnabled)
}
Text(
description,
color = Palette.Fg2,
fontSize = 12.sp,
lineHeight = 17.sp,
maxLines = 2,
overflow = TextOverflow.Ellipsis,
modifier = Modifier.padding(end = 6.dp),
)
Row(
modifier = Modifier.padding(start = 16.dp, end = 4.dp, top = 8.dp, bottom = 8.dp),
modifier = Modifier.padding(top = 6.dp, end = 6.dp),
verticalAlignment = Alignment.CenterVertically,
) {
IconBadge(R.drawable.ic_list, size = 40.dp)
Spacer(Modifier.width(12.dp))
Column(Modifier.weight(1f)) {
Text(title, style = MaterialTheme.typography.titleSmall, maxLines = 1, overflow = TextOverflow.Ellipsis)
if (source.isNotEmpty()) {
Text(
uri.host ?: "",
style = MaterialTheme.typography.bodySmall,
color = MaterialTheme.colorScheme.onSurfaceVariant,
source,
color = Palette.Accent,
fontSize = 12.sp,
fontWeight = FontWeight.Bold,
maxLines = 1,
overflow = TextOverflow.Ellipsis,
)
Text(
if (updating) stringResource(R.string.bl_updating)
else stringResource(R.string.bl_list_info, formatCount(list.count.toLong()), updated),
style = MaterialTheme.typography.bodySmall,
color = MaterialTheme.colorScheme.onSurfaceVariant,
modifier = if (sourceUrl != null) Modifier.clickable { openUrl(context, sourceUrl) } else Modifier,
)
Text(" · ", color = Palette.Fg3, fontSize = 12.sp)
}
IconButton(onClick = onRefresh, enabled = actionsEnabled) {
Icon(painterResource(R.drawable.ic_refresh), stringResource(R.string.bl_update_all), Modifier.size(20.dp))
}
IconButton(onClick = onDelete, enabled = actionsEnabled) {
Icon(painterResource(R.drawable.ic_delete), stringResource(R.string.delete), Modifier.size(20.dp))
}
Text(info, color = Palette.Fg3, fontSize = 12.sp, maxLines = 1, overflow = TextOverflow.Ellipsis)
}
AnimatedVisibility(visible = updating, enter = Motion.expandIn, exit = Motion.collapseOut) {
AnimatedVisibility(visible = progress, enter = Motion.expandIn, exit = Motion.collapseOut) {
LinearProgressIndicator(
modifier = Modifier
.fillMaxWidth()
.padding(start = 68.dp, end = 16.dp, bottom = 8.dp),
.padding(top = 10.dp, end = 6.dp),
color = Palette.Accent,
trackColor = Palette.Track,
)
}
}
}
@Composable
private fun MyDomainsHeader(
count: Int,
open: Boolean,
onToggle: () -> Unit,
shape: Shape,
modifier: Modifier = Modifier,
content: @Composable () -> Unit,
) {
val chevron by animateFloatAsState(if (open) 180f else 0f, Motion.rotation, label = "chevron")
Column(
modifier = modifier
.fillMaxWidth()
.clip(shape)
.background(Palette.Card),
) {
Row(
modifier = Modifier
.fillMaxWidth()
.clickable(onClick = onToggle)
.padding(start = 16.dp, end = 14.dp, top = 14.dp, bottom = 14.dp),
verticalAlignment = Alignment.CenterVertically,
) {
Column(Modifier.weight(1f)) {
Text(stringResource(R.string.bl_my), color = Palette.Fg, fontSize = 15.sp, fontWeight = FontWeight.ExtraBold)
Text(
stringResource(R.string.my_domains_desc),
color = Palette.Fg2,
fontSize = 12.sp,
lineHeight = 17.sp,
)
}
Spacer(Modifier.width(10.dp))
Text(
formatCount(count.toLong()),
color = Palette.Accent,
fontSize = 12.sp,
fontWeight = FontWeight.Bold,
modifier = Modifier
.clip(RoundedCornerShape(10.dp))
.background(Palette.AccentSoft)
.padding(horizontal = 8.dp, vertical = 3.dp),
)
Spacer(Modifier.width(6.dp))
Icon(
painterResource(R.drawable.ic_expand),
contentDescription = null,
tint = Palette.Fg3,
modifier = Modifier
.size(20.dp)
.graphicsLayer { rotationZ = chevron },
)
}
AnimatedVisibility(visible = open, enter = Motion.expandIn, exit = Motion.collapseOut) {
Column { content() }
}
}
}
@Composable
private fun DomainRow(domain: String, shape: Shape, onDelete: () -> Unit, modifier: Modifier = Modifier) {
Column(
modifier
.fillMaxWidth()
.clip(shape)
.background(Palette.Card)
) {
HorizontalDivider(modifier = Modifier.padding(horizontal = 16.dp), color = Palette.Line)
Row(
modifier = Modifier.padding(start = 16.dp, end = 4.dp),
verticalAlignment = Alignment.CenterVertically,
) {
Text(
domain,
color = Palette.Fg,
fontSize = 14.sp,
maxLines = 1,
overflow = TextOverflow.Ellipsis,
modifier = Modifier.weight(1f),
)
IconButton(onClick = onDelete) {
Icon(
painterResource(R.drawable.ic_delete),
contentDescription = stringResource(R.string.delete),
tint = Palette.Fg3,
modifier = Modifier.size(20.dp),
)
}
}
}
}
@Composable
private fun AddListDialog(busy: Boolean, onAdd: (String) -> Boolean, onDismiss: () -> Unit) {
var url by rememberSaveable { mutableStateOf("") }
fun submit() {
if (url.isNotBlank() && onAdd(url.trim())) onDismiss()
}
AlertDialog(
onDismissRequest = onDismiss,
title = { Text(stringResource(R.string.bl_add_list)) },
text = {
Column(verticalArrangement = Arrangement.spacedBy(12.dp)) {
Text(stringResource(R.string.bl_note), color = Palette.Fg2, fontSize = 13.sp)
OutlinedTextField(
value = url,
onValueChange = { url = it },
label = { Text(stringResource(R.string.bl_list_url)) },
placeholder = { Text("https://", maxLines = 1) },
singleLine = true,
shape = RoundedCornerShape(14.dp),
keyboardOptions = KeyboardOptions(keyboardType = KeyboardType.Uri, imeAction = ImeAction.Done),
keyboardActions = KeyboardActions(onDone = { submit() }),
modifier = Modifier.fillMaxWidth(),
)
}
},
confirmButton = {
Button(onClick = ::submit, enabled = url.isNotBlank() && !busy, shape = RoundedCornerShape(14.dp)) {
Text(stringResource(R.string.add), fontWeight = FontWeight.Bold)
}
},
dismissButton = {
TextButton(onClick = onDismiss) { Text(stringResource(R.string.cancel)) }
},
containerColor = Palette.CardHigh,
)
}
@Composable
private fun UpdatesDialog(
interval: UpdateInterval,
wifiOnly: Boolean,
canUpdateNow: Boolean,
onInterval: (UpdateInterval) -> Unit,
onWifiOnly: (Boolean) -> Unit,
onUpdateNow: () -> Unit,
onDismiss: () -> Unit,
) {
AlertDialog(
onDismissRequest = onDismiss,
title = { Text(stringResource(R.string.auto_update)) },
text = {
Column {
UpdateInterval.entries.forEach { option ->
Row(
modifier = Modifier
.fillMaxWidth()
.clip(RoundedCornerShape(12.dp))
.selectable(selected = option == interval, onClick = { onInterval(option) }, role = Role.RadioButton)
.padding(vertical = 4.dp),
verticalAlignment = Alignment.CenterVertically,
) {
RadioButton(selected = option == interval, onClick = null)
Spacer(Modifier.width(12.dp))
Text(stringResource(intervalLabel(option)), color = Palette.Fg, fontSize = 15.sp)
}
}
HorizontalDivider(modifier = Modifier.padding(vertical = 8.dp), color = Palette.Line)
val wifiEnabled = interval != UpdateInterval.OFF
Row(
modifier = Modifier
.fillMaxWidth()
.toggleable(value = wifiOnly, enabled = wifiEnabled, role = Role.Switch, onValueChange = onWifiOnly)
.graphicsLayer { alpha = if (wifiEnabled) 1f else 0.45f }
.padding(vertical = 6.dp),
verticalAlignment = Alignment.CenterVertically,
) {
Column(Modifier.weight(1f)) {
Text(stringResource(R.string.auto_wifi), color = Palette.Fg, fontSize = 15.sp)
Text(stringResource(R.string.auto_wifi_desc), color = Palette.Fg3, fontSize = 12.sp)
}
Spacer(Modifier.width(12.dp))
AppSwitch(checked = wifiOnly, onCheckedChange = null, enabled = wifiEnabled)
}
}
},
confirmButton = {
TextButton(onClick = onDismiss) { Text(stringResource(R.string.done)) }
},
dismissButton = {
TextButton(onClick = onUpdateNow, enabled = canUpdateNow) { Text(stringResource(R.string.auto_update_now)) }
},
containerColor = Palette.CardHigh,
)
}
// Blocklist edits write to storage, which can fail (a full disk, for one)
internal inline fun <T> tryEdit(action: () -> T): Result<T> =
try {
@@ -410,5 +683,3 @@ internal fun showEditError(context: Context, error: Throwable) {
val reason = error.message ?: error.javaClass.simpleName
Toast.makeText(context, context.getString(R.string.test_fail, reason), Toast.LENGTH_LONG).show()
}
private const val HINT_BLOCKLIST = "blocklist"
@@ -0,0 +1,79 @@
package cc.skysparkle.sparkledns
// The position of each company is saved in StatsStore: add new ones at the end only
enum class Company(val label: String) {
GOOGLE("Google"),
APPLE("Apple"),
META("Meta"),
AMAZON("Amazon"),
MICROSOFT("Microsoft"),
BYTEDANCE("ByteDance"),
X("X"),
YANDEX("Yandex"),
SAMSUNG("Samsung"),
XIAOMI("Xiaomi"),
}
// Tells which big company a domain belongs to, for the Company dominance card.
// Matches the domain and every parent of it against a small built-in table.
object Companies {
private val bySuffix = HashMap<String, Company>().apply {
fun add(company: Company, vararg domains: String) = domains.forEach { put(it, company) }
add(
Company.GOOGLE,
"google.com", "googleapis.com", "gstatic.com", "googleusercontent.com", "googlevideo.com",
"youtube.com", "youtu.be", "ytimg.com", "ggpht.com", "gvt1.com", "gvt2.com", "1e100.net",
"android.com", "googlesyndication.com", "googleadservices.com", "doubleclick.net",
"google-analytics.com", "googletagmanager.com", "googletagservices.com", "app-measurement.com",
"firebaseio.com", "firebase.com", "crashlytics.com", "withgoogle.com", "googlemail.com",
"gmail.com", "blogspot.com", "admob.com", "goo.gl",
)
add(
Company.APPLE,
"apple.com", "icloud.com", "icloud-content.com", "mzstatic.com", "apple-dns.net", "aaplimg.com",
"cdn-apple.com", "itunes.com", "me.com", "apple.news", "apple-cloudkit.com", "appleid.com",
)
add(
Company.META,
"facebook.com", "facebook.net", "fbcdn.net", "fbsbx.com", "fb.com", "instagram.com",
"cdninstagram.com", "whatsapp.com", "whatsapp.net", "messenger.com", "meta.com", "oculus.com",
"threads.net", "graph.facebook.com",
)
add(
Company.AMAZON,
"amazon.com", "amazonaws.com", "media-amazon.com", "ssl-images-amazon.com", "cloudfront.net",
"amazon-adsystem.com", "a2z.com", "primevideo.com", "aiv-cdn.net", "twitch.tv", "ttvnw.net",
"amazon.de", "amazon.co.uk", "amazontrust.com",
)
add(
Company.MICROSOFT,
"microsoft.com", "live.com", "outlook.com", "office.com", "office.net", "office365.com", "msn.com",
"bing.com", "windows.com", "windows.net", "windowsupdate.com", "azure.com", "azureedge.net",
"skype.com", "xbox.com", "xboxlive.com", "linkedin.com", "licdn.com", "github.com",
"githubusercontent.com", "msftncsi.com", "msedge.net", "microsoftonline.com", "sharepoint.com",
)
add(
Company.BYTEDANCE,
"tiktok.com", "tiktokv.com", "tiktokcdn.com", "tiktokcdn-us.com", "byteoversea.com",
"ibytedtos.com", "bytedance.com", "capcut.com", "byteimg.com",
)
add(Company.X, "twitter.com", "x.com", "twimg.com", "t.co")
add(Company.YANDEX, "yandex.ru", "yandex.net", "yandex.com", "ya.ru", "yastatic.net", "yandex.by", "yandex.kz")
add(Company.SAMSUNG, "samsung.com", "samsungapps.com", "samsungcloud.com", "samsungqbe.com", "samsungosp.com")
add(Company.XIAOMI, "xiaomi.com", "xiaomi.net", "mi.com", "miui.com", "mi-img.com")
}
fun of(name: String): Company? {
var domain = name.lowercase().trimEnd('.')
while (domain.isNotEmpty()) {
bySuffix[domain]?.let { return it }
// Google's country sites: google.de, google.co.uk, google.com.br
if (domain.startsWith("google.") && domain.length - "google.".length <= 6) return Company.GOOGLE
val dot = domain.indexOf('.')
if (dot < 0) return null
domain = domain.substring(dot + 1)
}
return null
}
}
@@ -18,6 +18,10 @@ class SparkleApp : Application() {
// Reads what the first screen needs before it asks, so its first frame does not wait on storage
Prefs(this).providerId
CrashLog.preload(this)
StatsStore.init(this)
// Older versions cached a server list downloaded from the repository
File(filesDir, "servers.txt").delete()
AutoUpdate.apply(this)
// Lists can hold millions of entries; loading them should not take CPU from the first frames
Process.setThreadPriority(Process.THREAD_PRIORITY_BACKGROUND)
runCatching { Blocklist.reload(this) }
@@ -87,6 +87,7 @@ class DohVpnService : VpnService() {
override fun onDestroy() {
stopSession()
StatsStore.flush()
super.onDestroy()
}
@@ -0,0 +1,556 @@
package cc.skysparkle.sparkledns
import android.Manifest
import android.app.Activity
import android.content.ClipData
import android.content.ClipboardManager
import android.content.pm.PackageManager
import android.net.VpnService
import android.os.Build
import androidx.activity.compose.rememberLauncherForActivityResult
import androidx.activity.result.contract.ActivityResultContracts
import androidx.compose.animation.AnimatedContent
import androidx.compose.animation.AnimatedVisibility
import androidx.compose.animation.animateColorAsState
import androidx.compose.animation.core.animateDpAsState
import androidx.compose.animation.core.animateFloatAsState
import androidx.compose.animation.core.tween
import androidx.compose.animation.fadeIn
import androidx.compose.animation.fadeOut
import androidx.compose.animation.togetherWith
import androidx.compose.foundation.Canvas
import androidx.compose.foundation.Image
import androidx.compose.foundation.background
import androidx.compose.foundation.clickable
import androidx.compose.foundation.layout.Arrangement
import androidx.compose.foundation.layout.Box
import androidx.compose.foundation.layout.Column
import androidx.compose.foundation.layout.Row
import androidx.compose.foundation.layout.Spacer
import androidx.compose.foundation.layout.fillMaxSize
import androidx.compose.foundation.layout.fillMaxWidth
import androidx.compose.foundation.layout.height
import androidx.compose.foundation.layout.offset
import androidx.compose.foundation.layout.padding
import androidx.compose.foundation.layout.size
import androidx.compose.foundation.layout.width
import androidx.compose.foundation.rememberScrollState
import androidx.compose.foundation.selection.toggleable
import androidx.compose.foundation.shape.CircleShape
import androidx.compose.foundation.shape.RoundedCornerShape
import androidx.compose.foundation.verticalScroll
import androidx.compose.material3.Icon
import androidx.compose.material3.Text
import androidx.compose.material3.TextButton
import androidx.compose.runtime.Composable
import androidx.compose.runtime.LaunchedEffect
import androidx.compose.runtime.getValue
import androidx.compose.runtime.mutableStateOf
import androidx.compose.runtime.remember
import androidx.compose.runtime.setValue
import androidx.compose.ui.Alignment
import androidx.compose.ui.Modifier
import androidx.compose.ui.draw.clip
import androidx.compose.ui.draw.drawBehind
import androidx.compose.ui.geometry.Offset
import androidx.compose.ui.graphics.Brush
import androidx.compose.ui.graphics.Color
import androidx.compose.ui.graphics.Path
import androidx.compose.ui.graphics.PathEffect
import androidx.compose.ui.graphics.StrokeCap
import androidx.compose.ui.graphics.StrokeJoin
import androidx.compose.ui.graphics.drawscope.Stroke
import androidx.compose.ui.graphics.graphicsLayer
import androidx.compose.ui.platform.LocalContext
import androidx.compose.ui.res.painterResource
import androidx.compose.ui.res.stringResource
import androidx.compose.ui.semantics.Role
import androidx.compose.ui.semantics.contentDescription
import androidx.compose.ui.semantics.semantics
import androidx.compose.ui.text.TextStyle
import androidx.compose.ui.text.drawText
import androidx.compose.ui.text.font.FontWeight
import androidx.compose.ui.text.rememberTextMeasurer
import androidx.compose.ui.text.style.TextAlign
import androidx.compose.ui.text.style.TextOverflow
import androidx.compose.ui.unit.Dp
import androidx.compose.ui.unit.dp
import androidx.compose.ui.unit.sp
import androidx.lifecycle.compose.collectAsStateWithLifecycle
import kotlinx.coroutines.delay
import okhttp3.HttpUrl.Companion.toHttpUrlOrNull
import java.text.SimpleDateFormat
import java.util.Date
import java.util.Locale
private const val CHART_HOURS = 24
@Composable
fun HomeScreen(bottomPadding: Dp, onOpenBlocklist: () -> Unit, modifier: Modifier = Modifier) {
val context = LocalContext.current
val prefs = remember { Prefs(context) }
val active by DohVpnService.active.collectAsStateWithLifecycle()
val running = active != null
val lists by Blocklist.lists.collectAsStateWithLifecycle()
val total by Blocklist.total.collectAsStateWithLifecycle()
val blocking by Blocklist.enabled.collectAsStateWithLifecycle()
var summary by remember { mutableStateOf(StatsStore.summary(CHART_HOURS)) }
var points by remember { mutableStateOf(StatsStore.hourly(CHART_HOURS)) }
fun refreshStats() {
summary = StatsStore.summary(CHART_HOURS)
points = StatsStore.hourly(CHART_HOURS)
}
OnQueryLogChange { refreshStats() }
val statsVersion by StatsStore.version.collectAsStateWithLifecycle()
LaunchedEffect(statsVersion) { refreshStats() }
// The server is picked in Settings; this screen is composed anew each time it is shown
val selected = remember { prefs.resolve() }
val canConnect = selected.id != Providers.CUSTOM_ID || selected.url.toHttpUrlOrNull()?.isHttps == true
val shown = active ?: selected
val usesHttp3 = shown.http3 && Build.VERSION.SDK_INT >= Build.VERSION_CODES.UPSIDE_DOWN_CAKE
val crashReport = remember { CrashLog.read(context) }
var crashVisible by remember { mutableStateOf(crashReport != null) }
// Strict Private DNS makes Android ignore the VPN's DNS server; followed while Home is visible
val privateDnsHost by remember { privateDnsHosts(context) }.collectAsStateWithLifecycle(initialValue = null)
// Set by a tap until the VPN state changes or the attempt gives up, so a double tap neither
// starts two connections nor switches the VPN back on right after turning it off
var busy by remember { mutableStateOf(false) }
LaunchedEffect(active) { busy = false }
LaunchedEffect(busy) {
if (busy) {
delay(BUSY_TIMEOUT_MS)
busy = false
}
}
val vpnPermission = rememberLauncherForActivityResult(
ActivityResultContracts.StartActivityForResult()
) {
if (it.resultCode == Activity.RESULT_OK) sendAction(context, DohVpnService.ACTION_START)
else busy = false
}
fun connectVpn() {
val permission = VpnService.prepare(context)
if (permission != null) vpnPermission.launch(permission)
else sendAction(context, DohVpnService.ACTION_START)
}
// The status notification is optional: connect whatever the user answers
val notificationPermission = rememberLauncherForActivityResult(
ActivityResultContracts.RequestPermission()
) { connectVpn() }
fun toggle() {
if (busy) return
busy = true
if (running) {
sendAction(context, DohVpnService.ACTION_STOP)
return
}
val needsNotificationPermission = Build.VERSION.SDK_INT >= Build.VERSION_CODES.TIRAMISU &&
context.checkSelfPermission(Manifest.permission.POST_NOTIFICATIONS) != PackageManager.PERMISSION_GRANTED
if (needsNotificationPermission) notificationPermission.launch(Manifest.permission.POST_NOTIFICATIONS)
else connectVpn()
}
val glow by animateFloatAsState(if (running) 1f else 0f, tween(600), label = "glow")
Column(
modifier = modifier
.verticalScroll(rememberScrollState())
.drawBehind {
// Soft light behind the logo while protected
if (glow > 0f) {
drawCircle(
brush = Brush.radialGradient(
colors = listOf(Palette.Accent.copy(alpha = 0.22f * glow), Color.Transparent),
center = Offset(size.width / 2f, 0f),
radius = size.width * 0.65f,
),
radius = size.width * 0.65f,
center = Offset(size.width / 2f, 0f),
)
}
}
.padding(top = 16.dp, bottom = bottomPadding),
verticalArrangement = Arrangement.spacedBy(20.dp),
) {
Image(
painterResource(R.drawable.app_logo),
contentDescription = null,
modifier = Modifier
.size(44.dp)
.align(Alignment.CenterHorizontally),
)
AnimatedVisibility(visible = crashVisible, enter = Motion.expandIn, exit = Motion.collapseOut) {
val report = crashReport.orEmpty()
Box(Modifier.padding(horizontal = 20.dp)) {
CrashCard(
report = report,
onCopy = {
context.getSystemService(ClipboardManager::class.java)
.setPrimaryClip(ClipData.newPlainText("SparkleDNS crash", report))
},
onDismiss = { CrashLog.clear(context); crashVisible = false },
)
}
}
StatusCard(
running = running,
providerName = shown.displayName(context),
http3 = usesHttp3,
enabled = !busy && (running || canConnect),
onToggle = ::toggle,
modifier = Modifier.padding(horizontal = 20.dp),
)
PrivateDnsWarning(privateDnsHost, prefs, Modifier.padding(horizontal = 20.dp))
Row(
modifier = Modifier
.fillMaxWidth()
.padding(horizontal = 24.dp),
horizontalArrangement = Arrangement.spacedBy(8.dp),
) {
StatBlock(formatCompact(summary.total), stringResource(R.string.stat_requests), Modifier.weight(1f))
StatBlock(
formatCompact(summary.blocked),
stringResource(R.string.mon_blocked),
Modifier.weight(1f),
valueColor = Palette.Accent,
)
StatBlock(stringResource(R.string.mon_ms, summary.avgLatencyMs), stringResource(R.string.stat_avg), Modifier.weight(1f))
}
Column(verticalArrangement = Arrangement.spacedBy(6.dp)) {
Row(
modifier = Modifier
.fillMaxWidth()
.padding(horizontal = 20.dp),
horizontalArrangement = Arrangement.spacedBy(14.dp, Alignment.End),
) {
LegendItem(stringResource(R.string.stat_requests), Palette.Accent)
LegendItem(stringResource(R.string.mon_blocked), Palette.Muted)
}
TrafficChart(
points,
Modifier
.fillMaxWidth()
.height(150.dp),
)
val startLabel = remember(points) {
val start = System.currentTimeMillis() - (CHART_HOURS - 1) * 3_600_000L
SimpleDateFormat("HH:00", Locale.getDefault()).format(Date(start))
}
Row(
modifier = Modifier
.fillMaxWidth()
.padding(horizontal = 20.dp),
verticalAlignment = Alignment.CenterVertically,
) {
Text(startLabel, color = Palette.Fg3, fontSize = 11.sp, modifier = Modifier.weight(1f))
Text(
stringResource(R.string.period_24h),
color = Palette.Fg2,
fontSize = 12.sp,
fontWeight = FontWeight.Bold,
modifier = Modifier
.clip(RoundedCornerShape(16.dp))
.background(Palette.Card)
.padding(horizontal = 12.dp, vertical = 6.dp),
)
Text(
stringResource(R.string.chart_now),
color = Palette.Fg3,
fontSize = 11.sp,
textAlign = TextAlign.End,
modifier = Modifier.weight(1f),
)
}
}
BlocklistRow(
info = if (blocking) {
stringResource(R.string.home_lists_info, lists.count { it.enabled }, formatCount(total.toLong()))
} else {
stringResource(R.string.blocking_off)
},
onClick = onOpenBlocklist,
modifier = Modifier.padding(horizontal = 20.dp),
)
}
}
@Composable
private fun StatusCard(
running: Boolean,
providerName: String,
http3: Boolean,
enabled: Boolean,
onToggle: () -> Unit,
modifier: Modifier = Modifier,
) {
Column(
modifier = modifier
.fillMaxWidth()
.appCard()
.padding(horizontal = 20.dp, vertical = 24.dp),
horizontalAlignment = Alignment.CenterHorizontally,
verticalArrangement = Arrangement.spacedBy(8.dp),
) {
AnimatedContent(
targetState = running,
transitionSpec = { fadeIn(Motion.enterFade) togetherWith fadeOut(Motion.exitFade) },
label = "status",
) { on ->
Text(
stringResource(if (on) R.string.home_protected else R.string.home_unprotected),
color = Palette.Fg,
fontSize = 24.sp,
fontWeight = FontWeight.ExtraBold,
letterSpacing = (-0.3).sp,
textAlign = TextAlign.Center,
)
}
val dot by animateColorAsState(if (running) Palette.Accent else Palette.Track, Motion.color, label = "dot")
Row(verticalAlignment = Alignment.CenterVertically) {
Box(
Modifier
.size(7.dp)
.clip(CircleShape)
.background(dot)
)
Spacer(Modifier.width(8.dp))
val via = stringResource(R.string.home_via, providerName) + if (http3) " · HTTP/3" else ""
Text(
if (running) via else stringResource(R.string.home_off_desc),
color = Palette.Fg2,
fontSize = 13.sp,
maxLines = 2,
overflow = TextOverflow.Ellipsis,
textAlign = TextAlign.Center,
)
}
Spacer(Modifier.height(10.dp))
PowerToggle(on = running, enabled = enabled, onToggle = onToggle)
}
}
// The big ON / OFF switch; the white knob slides across
@Composable
private fun PowerToggle(on: Boolean, enabled: Boolean, onToggle: () -> Unit) {
val track by animateColorAsState(if (on) Palette.Accent else Palette.Track, Motion.color, label = "track")
val knob by animateDpAsState(if (on) 70.dp else 0.dp, tween(320, easing = Motion.Emphasized), label = "knob")
val description = stringResource(if (on) R.string.disconnect else R.string.connect)
Box(
modifier = Modifier
.size(width = 120.dp, height = 50.dp)
.graphicsLayer { alpha = if (enabled) 1f else 0.5f }
.clip(RoundedCornerShape(25.dp))
.background(track)
.toggleable(value = on, enabled = enabled, role = Role.Switch, onValueChange = { onToggle() })
.semantics { contentDescription = description }
.padding(5.dp),
) {
Text(
stringResource(if (on) R.string.toggle_on else R.string.toggle_off),
color = if (on) Palette.AccentInk else Palette.Fg2,
fontSize = 15.sp,
fontWeight = FontWeight.ExtraBold,
letterSpacing = 0.6.sp,
modifier = Modifier
.align(if (on) Alignment.CenterStart else Alignment.CenterEnd)
.padding(horizontal = 12.dp),
)
Box(
modifier = Modifier
.offset(x = knob)
.size(40.dp)
.clip(CircleShape)
.background(Color.White),
contentAlignment = Alignment.Center,
) {
Canvas(Modifier.size(14.dp)) {
val stroke = 1.6.dp.toPx()
listOf(0.29f, 0.5f, 0.71f).forEach { fraction ->
drawLine(
color = Palette.Fg3,
start = Offset(size.width * fraction, size.height * 0.21f),
end = Offset(size.width * fraction, size.height * 0.79f),
strokeWidth = stroke,
cap = StrokeCap.Round,
)
}
}
}
}
}
@Composable
private fun PrivateDnsWarning(privateDnsHost: String?, prefs: Prefs, modifier: Modifier = Modifier) {
val context = LocalContext.current
val lastHost = remember { arrayOf("") }
privateDnsHost?.let { lastHost[0] = it }
var dismissedHost by remember { mutableStateOf(prefs.dismissedPrivateDns) }
AnimatedVisibility(
visible = privateDnsHost != null && privateDnsHost != dismissedHost,
enter = Motion.expandIn,
exit = Motion.collapseOut,
modifier = modifier,
) {
HintCard(
text = stringResource(R.string.hint, lastHost[0]),
icon = R.drawable.ic_alert,
tint = WarningColor,
action = {
TextButton(onClick = { openNetworkSettings(context) }) { Text(stringResource(R.string.open_settings)) }
},
onDismiss = {
dismissedHost = lastHost[0]
prefs.dismissedPrivateDns = lastHost[0]
},
)
}
}
@Composable
fun StatBlock(value: String, label: String, modifier: Modifier = Modifier, valueColor: Color = Palette.Fg) {
Column(modifier, verticalArrangement = Arrangement.spacedBy(3.dp)) {
Text(value, color = valueColor, fontSize = 21.sp, fontWeight = FontWeight.ExtraBold, maxLines = 1)
Text(label, color = Palette.Fg2, fontSize = 12.sp, maxLines = 1, overflow = TextOverflow.Ellipsis)
}
}
@Composable
private fun LegendItem(label: String, color: Color) {
Row(verticalAlignment = Alignment.CenterVertically) {
Box(
Modifier
.size(width = 12.dp, height = 3.dp)
.clip(RoundedCornerShape(2.dp))
.background(color)
)
Spacer(Modifier.width(6.dp))
Text(label, color = Palette.Fg2, fontSize = 11.sp)
}
}
// Requests (accent line with a soft fill) and blocked queries (grey line) per hour
@Composable
private fun TrafficChart(points: List<HourPoint>, modifier: Modifier = Modifier) {
val measurer = rememberTextMeasurer()
val labelStyle = TextStyle(color = Palette.Fg3, fontSize = 10.sp)
Canvas(modifier) {
val n = points.size
if (n < 2) return@Canvas
val maxValue = niceCeiling(points.maxOf { it.total }.coerceAtLeast(1L))
val inset = 6.dp.toPx()
val top = 14.dp.toPx()
val base = size.height - 8.dp.toPx()
val span = base - top
val step = (size.width - 2 * inset) / (n - 1)
fun x(index: Int) = inset + index * step
fun y(value: Long) = base - value.toFloat() / maxValue * span
listOf(maxValue / 2, maxValue).forEach { value ->
val gridY = y(value)
drawLine(
color = Palette.Line,
start = Offset(0f, gridY),
end = Offset(size.width, gridY),
strokeWidth = 1.dp.toPx(),
pathEffect = PathEffect.dashPathEffect(floatArrayOf(3.dp.toPx(), 4.dp.toPx())),
)
drawText(
textMeasurer = measurer,
text = formatCompact(value),
topLeft = Offset(20.dp.toPx(), gridY - 15.dp.toPx()),
style = labelStyle,
)
}
val line = Path()
val area = Path()
val blocked = Path()
points.forEachIndexed { index, point ->
val px = x(index)
if (index == 0) {
line.moveTo(px, y(point.total))
area.moveTo(px, base)
area.lineTo(px, y(point.total))
blocked.moveTo(px, y(point.blocked))
} else {
line.lineTo(px, y(point.total))
area.lineTo(px, y(point.total))
blocked.lineTo(px, y(point.blocked))
}
}
area.lineTo(x(n - 1), base)
area.close()
drawPath(area, Palette.Accent.copy(alpha = 0.14f))
drawPath(
blocked,
Palette.Muted,
style = Stroke(width = 1.6.dp.toPx(), cap = StrokeCap.Round, join = StrokeJoin.Round),
)
drawPath(
line,
Palette.Accent,
style = Stroke(width = 2.4.dp.toPx(), cap = StrokeCap.Round, join = StrokeJoin.Round),
)
val end = Offset(x(n - 1), y(points.last().total))
drawCircle(Palette.Bg, radius = 5.dp.toPx(), center = end)
drawCircle(Palette.Accent, radius = 5.dp.toPx(), center = end, style = Stroke(width = 2.4.dp.toPx()))
}
}
// 1, 2 or 5 times a power of ten, at least [value]: keeps the grid labels round
private fun niceCeiling(value: Long): Long {
var magnitude = 1L
while (magnitude * 10 <= value) magnitude *= 10
for (factor in longArrayOf(1, 2, 5)) {
if (factor * magnitude >= value) return factor * magnitude
}
return 10 * magnitude
}
@Composable
private fun BlocklistRow(info: String, onClick: () -> Unit, modifier: Modifier = Modifier) {
Row(
modifier = modifier
.fillMaxWidth()
.appCard()
.clickable(onClick = onClick)
.padding(16.dp),
verticalAlignment = Alignment.CenterVertically,
) {
Box(
modifier = Modifier
.size(40.dp)
.clip(CircleShape)
.background(Palette.Accent),
contentAlignment = Alignment.Center,
) {
Icon(
painterResource(R.drawable.ic_privacy),
contentDescription = null,
tint = Palette.AccentInk,
modifier = Modifier.size(22.dp),
)
}
Spacer(Modifier.width(14.dp))
Column(Modifier.weight(1f), verticalArrangement = Arrangement.spacedBy(3.dp)) {
Text(stringResource(R.string.blocklist_title), color = Palette.Fg, fontSize = 15.sp, fontWeight = FontWeight.Bold)
Text(info, color = Palette.Fg2, fontSize = 12.sp, maxLines = 1, overflow = TextOverflow.Ellipsis)
}
Chevron()
}
}
@@ -1,105 +1,47 @@
package cc.skysparkle.sparkledns
import android.Manifest
import android.app.Activity
import android.content.ClipData
import android.content.ClipboardManager
import android.content.Context
import android.content.Intent
import android.content.pm.PackageManager
import android.net.ConnectivityManager
import android.net.LinkProperties
import android.net.Network
import android.net.Uri
import android.net.VpnService
import android.os.Build
import android.os.Bundle
import android.os.SystemClock
import android.provider.Settings
import androidx.activity.ComponentActivity
import androidx.activity.compose.rememberLauncherForActivityResult
import androidx.activity.compose.setContent
import androidx.activity.enableEdgeToEdge
import androidx.activity.result.contract.ActivityResultContracts
import androidx.compose.animation.AnimatedContent
import androidx.compose.animation.AnimatedVisibility
import androidx.compose.animation.animateColorAsState
import androidx.compose.animation.fadeIn
import androidx.compose.animation.fadeOut
import androidx.compose.animation.togetherWith
import androidx.compose.animation.core.LinearEasing
import androidx.compose.animation.core.animateFloatAsState
import androidx.compose.animation.core.animateFloat
import androidx.compose.animation.core.infiniteRepeatable
import androidx.compose.animation.core.rememberInfiniteTransition
import androidx.compose.animation.core.tween
import androidx.compose.foundation.background
import androidx.compose.foundation.layout.Arrangement
import androidx.compose.foundation.layout.Box
import androidx.compose.foundation.layout.Column
import androidx.compose.foundation.layout.Row
import androidx.compose.foundation.layout.Spacer
import androidx.compose.foundation.layout.fillMaxSize
import androidx.compose.foundation.layout.fillMaxWidth
import androidx.compose.foundation.layout.height
import androidx.compose.foundation.layout.padding
import androidx.compose.foundation.layout.size
import androidx.compose.foundation.layout.width
import androidx.compose.foundation.rememberScrollState
import androidx.compose.foundation.selection.selectable
import androidx.compose.foundation.selection.toggleable
import androidx.compose.foundation.shape.CircleShape
import androidx.compose.foundation.text.KeyboardOptions
import androidx.compose.foundation.verticalScroll
import androidx.compose.material3.Button
import androidx.compose.foundation.shape.RoundedCornerShape
import androidx.compose.material3.Card
import androidx.compose.material3.CardDefaults
import androidx.compose.material3.HorizontalDivider
import androidx.compose.material3.CircularProgressIndicator
import androidx.compose.material3.Icon
import androidx.compose.material3.IconButton
import androidx.compose.material3.MaterialTheme
import androidx.compose.material3.OutlinedButton
import androidx.compose.material3.OutlinedTextField
import androidx.compose.material3.RadioButton
import androidx.compose.material3.Switch
import androidx.compose.material3.Text
import androidx.compose.material3.TextButton
import androidx.compose.material3.darkColorScheme
import androidx.compose.runtime.Composable
import androidx.compose.runtime.LaunchedEffect
import androidx.compose.runtime.getValue
import androidx.compose.runtime.mutableStateOf
import androidx.compose.runtime.remember
import androidx.compose.runtime.saveable.Saver
import androidx.compose.runtime.saveable.rememberSaveable
import androidx.compose.runtime.rememberCoroutineScope
import androidx.compose.runtime.setValue
import androidx.compose.ui.Alignment
import androidx.compose.ui.Modifier
import androidx.compose.ui.draw.clip
import androidx.compose.ui.graphics.Color
import androidx.compose.ui.graphics.graphicsLayer
import androidx.compose.ui.platform.LocalContext
import androidx.compose.ui.res.painterResource
import androidx.compose.ui.res.stringResource
import androidx.compose.ui.semantics.Role
import androidx.compose.ui.text.font.FontFamily
import androidx.compose.ui.text.input.ImeAction
import androidx.compose.ui.text.input.KeyboardType
import androidx.compose.ui.text.style.TextOverflow
import androidx.compose.ui.unit.dp
import androidx.lifecycle.compose.collectAsStateWithLifecycle
import kotlinx.coroutines.Dispatchers
import kotlinx.coroutines.channels.awaitClose
import kotlinx.coroutines.delay
import kotlinx.coroutines.flow.Flow
import kotlinx.coroutines.flow.callbackFlow
import kotlinx.coroutines.flow.distinctUntilChanged
import kotlinx.coroutines.flow.flowOf
import kotlinx.coroutines.launch
import kotlinx.coroutines.withContext
import okhttp3.HttpUrl.Companion.toHttpUrlOrNull
class MainActivity : ComponentActivity() {
override fun onCreate(savedInstanceState: Bundle?) {
@@ -111,473 +53,22 @@ class MainActivity : ComponentActivity() {
}
}
private val AppColors = darkColorScheme(
primary = Color(0xFF7FB2FF),
onPrimary = Color(0xFF00285C),
background = Color(0xFF0F1115),
surface = Color(0xFF0F1115),
)
private val ProtectedContainer = Color(0xFF16233A)
private class TestResult(val ok: Boolean, val text: String)
internal class TestResult(val ok: Boolean, val text: String)
// How long a tap on Connect, Disconnect or Switch blocks further taps if the VPN state never changes
private const val BUSY_TIMEOUT_MS = 5000L
internal const val BUSY_TIMEOUT_MS = 5000L
// Keeps test and sync results across rotation and process death
private val TestResultSaver = Saver<TestResult?, String>(
// Keeps test results across rotation and process death
internal val TestResultSaver = Saver<TestResult?, String>(
save = { result -> result?.let { (if (it.ok) "1" else "0") + it.text } },
restore = { saved -> TestResult(saved.startsWith("1"), saved.drop(1)) },
)
@Composable
fun HomeScreen(modifier: Modifier = Modifier) {
val context = LocalContext.current
val prefs = remember { Prefs(context) }
val active by DohVpnService.active.collectAsStateWithLifecycle()
val running = active != null
val scope = rememberCoroutineScope()
val stats = rememberLiveStats()
var selected by remember { mutableStateOf(prefs.providerId) }
val servers by ServerList.servers.collectAsStateWithLifecycle()
var syncing by remember { mutableStateOf(false) }
var syncResult by rememberSaveable(stateSaver = TestResultSaver) { mutableStateOf<TestResult?>(null) }
var shownSync by rememberSaveable(stateSaver = TestResultSaver) { mutableStateOf<TestResult?>(null) }
var customUrl by remember { mutableStateOf(prefs.customUrl) }
var customBootstrap by remember { mutableStateOf(prefs.customBootstrap) }
var customHttp3 by remember { mutableStateOf(prefs.customHttp3) }
var testResult by rememberSaveable(stateSaver = TestResultSaver) { mutableStateOf<TestResult?>(null) }
var shownResult by rememberSaveable(stateSaver = TestResultSaver) { mutableStateOf<TestResult?>(null) } // kept while the card animates out
var testing by remember { mutableStateOf(false) }
val crashReport = remember { CrashLog.read(context) }
// Strict Private DNS makes Android ignore the VPN's DNS server; followed while Home is visible
val privateDnsHost by remember { privateDnsHosts(context) }.collectAsStateWithLifecycle(initialValue = null)
var crashVisible by remember { mutableStateOf(crashReport != null) }
val isCustom = selected == Providers.CUSTOM_ID
val customValid = remember(customUrl) { customUrl.trim().toHttpUrlOrNull()?.isHttps == true }
val canConnect = !isCustom || customValid
val selectedProvider = remember(selected, customUrl, customBootstrap, customHttp3, servers) { prefs.resolve() }
val customName = stringResource(R.string.custom)
fun nameOf(p: DohProvider) = if (p.id == Providers.CUSTOM_ID) customName else p.name
val shownProvider = active ?: selectedProvider
val usesHttp3 = shownProvider.http3 && Build.VERSION.SDK_INT >= Build.VERSION_CODES.UPSIDE_DOWN_CAKE
// Picking a server never touches a live connection; switching is an explicit action
val pendingSwitch = active?.let { it != selectedProvider && canConnect } == true
// Set by a tap until the VPN state changes or the attempt gives up, so a double tap neither
// starts two connections nor switches the VPN back on right after turning it off
var busy by remember { mutableStateOf(false) }
LaunchedEffect(active) { busy = false }
LaunchedEffect(busy) {
if (busy) {
delay(BUSY_TIMEOUT_MS)
busy = false
}
}
val vpnPermission = rememberLauncherForActivityResult(
ActivityResultContracts.StartActivityForResult()
) {
if (it.resultCode == Activity.RESULT_OK) sendAction(context, DohVpnService.ACTION_START)
else busy = false
}
fun connectVpn() {
val permission = VpnService.prepare(context)
if (permission != null) vpnPermission.launch(permission)
else sendAction(context, DohVpnService.ACTION_START)
}
// The status notification is optional: connect whatever the user answers
val notificationPermission = rememberLauncherForActivityResult(
ActivityResultContracts.RequestPermission()
) { connectVpn() }
fun toggle() {
if (busy) return
busy = true
if (running) {
sendAction(context, DohVpnService.ACTION_STOP)
return
}
val needsNotificationPermission = Build.VERSION.SDK_INT >= Build.VERSION_CODES.TIRAMISU &&
context.checkSelfPermission(Manifest.permission.POST_NOTIFICATIONS) != PackageManager.PERMISSION_GRANTED
if (needsNotificationPermission) notificationPermission.launch(Manifest.permission.POST_NOTIFICATIONS)
else connectVpn()
}
fun select(id: String) {
selected = id
prefs.providerId = id
testResult = null
}
// A server removed from the list falls back to the default one
LaunchedEffect(servers) {
if (selected != Providers.CUSTOM_ID && servers.none { it.id == selected }) select(Providers.default.id)
}
val syncOk = stringResource(R.string.servers_updated)
val syncFail = stringResource(R.string.servers_update_failed)
fun syncServers() {
syncing = true
syncResult = null
scope.launch {
val result = withContext(Dispatchers.IO) {
runCatching { ServerList.sync(context) }
.fold(
onSuccess = { TestResult(true, syncOk) },
onFailure = { TestResult(false, syncFail.format(it.message ?: it.javaClass.simpleName)) },
)
}
shownSync = result
syncResult = result
syncing = false
}
}
fun runTest() {
val provider = prefs.resolve()
testing = true
testResult = null
scope.launch {
val result = withContext(Dispatchers.IO) { testProvider(context, provider) }
shownResult = result
testResult = result
testing = false
}
}
Column(
modifier = modifier
.fillMaxSize()
.verticalScroll(rememberScrollState())
.padding(horizontal = 16.dp, vertical = 12.dp),
verticalArrangement = Arrangement.spacedBy(12.dp),
) {
AnimatedVisibility(visible = crashVisible, enter = Motion.expandIn, exit = Motion.collapseOut) {
val report = crashReport.orEmpty()
CrashCard(
report = report,
onCopy = {
context.getSystemService(ClipboardManager::class.java)
.setPrimaryClip(ClipData.newPlainText("SparkleDNS crash", report))
},
onDismiss = { CrashLog.clear(context); crashVisible = false },
)
}
StatusHero(
running = running,
providerName = nameOf(shownProvider),
http3 = usesHttp3,
stats = stats,
canConnect = canConnect,
busy = busy,
switchTo = if (pendingSwitch) nameOf(selectedProvider) else null,
onToggle = ::toggle,
onSwitch = {
if (!busy) {
busy = true
sendAction(context, DohVpnService.ACTION_START)
}
},
)
SectionHeader(stringResource(R.string.servers)) {
if (syncing) {
Box(Modifier.size(48.dp), contentAlignment = Alignment.Center) {
CircularProgressIndicator(Modifier.size(20.dp), strokeWidth = 2.dp)
}
} else {
IconButton(onClick = ::syncServers) {
Icon(
painterResource(R.drawable.ic_refresh),
contentDescription = stringResource(R.string.servers_update),
modifier = Modifier.size(20.dp),
)
}
}
}
AnimatedVisibility(visible = syncResult != null, enter = Motion.expandIn, exit = Motion.collapseOut) {
shownSync?.let { result ->
HintCard(
text = result.text,
icon = if (result.ok) R.drawable.ic_check else R.drawable.ic_alert,
tint = if (result.ok) CachedColor else MaterialTheme.colorScheme.error,
onDismiss = { syncResult = null },
)
}
}
Card(Modifier.fillMaxWidth()) {
Column(Modifier.padding(vertical = 6.dp)) {
servers.forEachIndexed { index, p ->
if (index > 0) RowDivider()
ProviderRow(
title = p.name,
subtitle = hostOf(p.url),
selected = selected == p.id,
onPolicy = p.policy?.let { url -> { openUrl(context, url) } },
onDonate = p.donate?.let { url -> { openUrl(context, url) } },
) { select(p.id) }
}
RowDivider()
ProviderRow(
title = stringResource(R.string.custom),
subtitle = hostOf(customUrl),
selected = isCustom,
) { select(Providers.CUSTOM_ID) }
}
}
AnimatedVisibility(visible = isCustom, enter = Motion.expandIn, exit = Motion.collapseOut) {
Card(Modifier.fillMaxWidth()) {
Column(Modifier.padding(16.dp), verticalArrangement = Arrangement.spacedBy(8.dp)) {
OutlinedTextField(
value = customUrl,
onValueChange = { customUrl = it; prefs.customUrl = it },
label = { Text(stringResource(R.string.custom_url)) },
singleLine = true,
isError = !customValid,
keyboardOptions = KeyboardOptions(keyboardType = KeyboardType.Uri, imeAction = ImeAction.Next),
modifier = Modifier.fillMaxWidth(),
)
if (!customValid) {
Text(
stringResource(R.string.invalid_url),
style = MaterialTheme.typography.bodySmall,
color = MaterialTheme.colorScheme.error,
)
}
OutlinedTextField(
value = customBootstrap,
onValueChange = { customBootstrap = it; prefs.customBootstrap = it },
label = { Text(stringResource(R.string.custom_bootstrap)) },
singleLine = true,
keyboardOptions = KeyboardOptions(keyboardType = KeyboardType.Uri, imeAction = ImeAction.Done),
modifier = Modifier.fillMaxWidth(),
)
Row(
modifier = Modifier
.fillMaxWidth()
.toggleable(
value = customHttp3,
role = Role.Switch,
onValueChange = { customHttp3 = it; prefs.customHttp3 = it },
)
.padding(vertical = 4.dp),
verticalAlignment = Alignment.CenterVertically,
) {
Column(Modifier.weight(1f)) {
Text(stringResource(R.string.http3), style = MaterialTheme.typography.bodyLarge)
Text(
stringResource(R.string.http3_note),
style = MaterialTheme.typography.bodySmall,
color = MaterialTheme.colorScheme.onSurfaceVariant,
)
}
Spacer(Modifier.width(12.dp))
Switch(checked = customHttp3, onCheckedChange = null)
}
}
}
}
OutlinedButton(
onClick = ::runTest,
enabled = !testing && canConnect,
modifier = Modifier
.fillMaxWidth()
.height(48.dp),
) { Text(stringResource(if (testing) R.string.testing else R.string.test)) }
AnimatedVisibility(visible = testResult != null, enter = Motion.expandIn, exit = Motion.collapseOut) {
shownResult?.let { result ->
HintCard(
text = result.text,
icon = if (result.ok) R.drawable.ic_check else R.drawable.ic_alert,
tint = if (result.ok) CachedColor else MaterialTheme.colorScheme.error,
onDismiss = { testResult = null },
)
}
}
val lastHost = remember { arrayOf("") }
privateDnsHost?.let { lastHost[0] = it }
var dismissedDnsHost by remember { mutableStateOf(prefs.dismissedPrivateDns) }
AnimatedVisibility(
visible = privateDnsHost != null && privateDnsHost != dismissedDnsHost,
enter = Motion.expandIn,
exit = Motion.collapseOut,
) {
HintCard(
text = stringResource(R.string.hint, lastHost[0]),
icon = R.drawable.ic_alert,
tint = WarningColor,
action = {
TextButton(onClick = { openNetworkSettings(context) }) { Text(stringResource(R.string.open_settings)) }
},
onDismiss = {
dismissedDnsHost = lastHost[0]
prefs.dismissedPrivateDns = lastHost[0]
},
)
}
}
}
@Composable
private fun StatusHero(
running: Boolean,
providerName: String,
http3: Boolean,
stats: QueryStats,
canConnect: Boolean,
busy: Boolean,
switchTo: String?,
onToggle: () -> Unit,
onSwitch: () -> Unit,
) {
val accent by animateColorAsState(
if (running) MaterialTheme.colorScheme.primary else MaterialTheme.colorScheme.outline,
animationSpec = Motion.color,
label = "accent",
)
val container by animateColorAsState(
if (running) ProtectedContainer else MaterialTheme.colorScheme.surfaceContainerHighest,
animationSpec = Motion.color,
label = "container",
)
val ringAlpha by animateFloatAsState(if (running) 1f else 0f, Motion.rotation, label = "ring")
Card(
modifier = Modifier.fillMaxWidth(),
colors = CardDefaults.cardColors(containerColor = container),
) {
Column(
modifier = Modifier
.fillMaxWidth()
.padding(20.dp),
horizontalAlignment = Alignment.CenterHorizontally,
verticalArrangement = Arrangement.spacedBy(12.dp),
) {
Box(Modifier.size(124.dp), contentAlignment = Alignment.Center) {
if (ringAlpha > 0f) PulseRing(accent, ringAlpha)
Box(
modifier = Modifier
.size(92.dp)
.clip(CircleShape)
.background(accent.copy(alpha = 0.18f)),
contentAlignment = Alignment.Center,
) {
Icon(
painterResource(R.drawable.ic_privacy),
contentDescription = null,
tint = accent,
modifier = Modifier.size(52.dp),
)
}
}
AnimatedContent(
targetState = running,
transitionSpec = { fadeIn(Motion.enterFade) togetherWith fadeOut(Motion.exitFade) },
label = "status",
) { on ->
Text(
stringResource(if (on) R.string.status_on else R.string.status_off),
style = MaterialTheme.typography.headlineSmall,
)
}
Row(verticalAlignment = Alignment.CenterVertically) {
Text(
stringResource(R.string.via, providerName),
style = MaterialTheme.typography.bodyMedium,
color = MaterialTheme.colorScheme.onSurfaceVariant,
)
if (http3) {
Spacer(Modifier.width(8.dp))
Pill("HTTP/3", accent)
}
}
AnimatedVisibility(visible = running, enter = Motion.expandIn, exit = Motion.collapseOut) {
Row(
modifier = Modifier
.fillMaxWidth()
.padding(vertical = 4.dp),
verticalAlignment = Alignment.CenterVertically,
) {
StatColumn(formatCount(stats.total), stringResource(R.string.mon_queries), Modifier.weight(1f))
StatDivider()
StatColumn(formatCount(stats.blocked), stringResource(R.string.mon_blocked), Modifier.weight(1f))
StatDivider()
StatColumn(cachePercent(stats), stringResource(R.string.mon_cached), Modifier.weight(1f))
}
}
Button(
onClick = onToggle,
enabled = (running || canConnect) && !busy,
modifier = Modifier
.fillMaxWidth()
.height(52.dp),
) {
AnimatedContent(
targetState = running,
transitionSpec = { fadeIn(Motion.enterFade) togetherWith fadeOut(Motion.exitFade) },
label = "toggle",
) { on -> Text(stringResource(if (on) R.string.disconnect else R.string.connect)) }
}
// Remembers the last name so the button keeps its label while it animates out
val lastSwitch = remember { arrayOf("") }
if (switchTo != null) lastSwitch[0] = switchTo
AnimatedVisibility(visible = switchTo != null, enter = Motion.expandIn, exit = Motion.collapseOut) {
OutlinedButton(onClick = onSwitch, enabled = !busy, modifier = Modifier.fillMaxWidth()) {
Icon(painterResource(R.drawable.ic_switch), contentDescription = null, modifier = Modifier.size(18.dp))
Spacer(Modifier.width(8.dp))
Text(stringResource(R.string.switch_to, lastSwitch[0]))
}
}
}
}
}
@Composable
private fun PulseRing(color: Color, visibility: Float) {
val transition = rememberInfiniteTransition(label = "pulse")
val progress by transition.animateFloat(
initialValue = 0f,
targetValue = 1f,
animationSpec = infiniteRepeatable(tween(1800, easing = LinearEasing)),
label = "progress",
)
Box(
Modifier
.size(124.dp)
.graphicsLayer {
val scale = 0.74f + 0.26f * progress
scaleX = scale
scaleY = scale
alpha = (1f - progress) * visibility
}
.clip(CircleShape)
.background(color.copy(alpha = 0.28f))
)
}
@Composable
private fun CrashCard(report: String, onCopy: () -> Unit, onDismiss: () -> Unit) {
internal fun CrashCard(report: String, onCopy: () -> Unit, onDismiss: () -> Unit) {
Card(
modifier = Modifier.fillMaxWidth(),
shape = RoundedCornerShape(20.dp),
colors = CardDefaults.cardColors(containerColor = MaterialTheme.colorScheme.errorContainer),
) {
Column(Modifier.padding(16.dp), verticalArrangement = Arrangement.spacedBy(8.dp)) {
@@ -601,74 +92,9 @@ private fun CrashCard(report: String, onCopy: () -> Unit, onDismiss: () -> Unit)
}
}
@Composable
private fun ProviderRow(
title: String,
subtitle: String,
selected: Boolean,
onPolicy: (() -> Unit)? = null,
onDonate: (() -> Unit)? = null,
onClick: () -> Unit,
) {
val highlight by animateColorAsState(
if (selected) MaterialTheme.colorScheme.primary.copy(alpha = 0.08f) else Color.Transparent,
animationSpec = Motion.color,
label = "highlight",
)
Row(
modifier = Modifier
.fillMaxWidth()
.background(highlight)
.selectable(selected = selected, onClick = onClick, role = Role.RadioButton)
.padding(horizontal = 12.dp, vertical = 10.dp),
verticalAlignment = Alignment.CenterVertically,
) {
RadioButton(selected = selected, onClick = null)
Spacer(Modifier.width(12.dp))
Column(Modifier.weight(1f)) {
Text(title, style = MaterialTheme.typography.bodyLarge)
Text(
subtitle,
style = MaterialTheme.typography.bodySmall,
color = MaterialTheme.colorScheme.onSurfaceVariant,
maxLines = 1,
overflow = TextOverflow.Ellipsis,
)
}
if (onDonate != null) {
IconButton(onClick = onDonate, modifier = Modifier.size(40.dp)) {
Icon(
painterResource(R.drawable.ic_donate),
contentDescription = stringResource(R.string.donate),
tint = MaterialTheme.colorScheme.onSurfaceVariant,
modifier = Modifier.size(18.dp),
)
}
}
if (onPolicy != null) {
IconButton(onClick = onPolicy, modifier = Modifier.size(40.dp)) {
Icon(
painterResource(R.drawable.ic_policy),
contentDescription = stringResource(R.string.about_privacy_policy),
tint = MaterialTheme.colorScheme.onSurfaceVariant,
modifier = Modifier.size(18.dp),
)
}
}
}
}
@Composable
private fun RowDivider() {
HorizontalDivider(
modifier = Modifier.padding(start = 60.dp),
color = MaterialTheme.colorScheme.outlineVariant.copy(alpha = 0.5f),
)
}
// Hostname of strict Private DNS (DNS-over-TLS) on the current network, null when it is Automatic or Off.
// Android reports the current state on registration and every change after it.
private fun privateDnsHosts(context: Context): Flow<String?> {
internal fun privateDnsHosts(context: Context): Flow<String?> {
if (Build.VERSION.SDK_INT < Build.VERSION_CODES.P) return flowOf(null)
val cm = context.applicationContext.getSystemService(ConnectivityManager::class.java) ?: return flowOf(null)
return callbackFlow {
@@ -686,13 +112,13 @@ private fun privateDnsHosts(context: Context): Flow<String?> {
}.distinctUntilChanged()
}
private fun openNetworkSettings(context: Context) {
internal fun openNetworkSettings(context: Context) {
runCatching {
context.startActivity(Intent(Settings.ACTION_WIRELESS_SETTINGS).addFlags(Intent.FLAG_ACTIVITY_NEW_TASK))
}
}
private fun hostOf(url: String): String =
internal fun hostOf(url: String): String =
runCatching { Uri.parse(url.trim()).host }.getOrNull()?.takeIf { it.isNotEmpty() } ?: url
internal fun sendAction(context: Context, action: String) {
@@ -700,7 +126,7 @@ internal fun sendAction(context: Context, action: String) {
}
// Runs from the app process, which is excluded from the VPN, so it tests the server directly
private fun testProvider(context: Context, provider: DohProvider): TestResult {
internal fun testProvider(context: Context, provider: DohProvider): TestResult {
val client = DohClient(context, provider)
return try {
val t0 = SystemClock.elapsedRealtime()
@@ -1,303 +0,0 @@
package cc.skysparkle.sparkledns
import android.widget.Toast
import androidx.compose.foundation.background
import androidx.compose.foundation.horizontalScroll
import androidx.compose.foundation.layout.Arrangement
import androidx.compose.foundation.layout.Box
import androidx.compose.foundation.layout.Column
import androidx.compose.foundation.layout.PaddingValues
import androidx.compose.foundation.layout.Row
import androidx.compose.foundation.layout.Spacer
import androidx.compose.foundation.layout.fillMaxSize
import androidx.compose.foundation.layout.fillMaxWidth
import androidx.compose.foundation.layout.height
import androidx.compose.foundation.layout.padding
import androidx.compose.foundation.layout.size
import androidx.compose.foundation.layout.width
import androidx.compose.foundation.lazy.LazyColumn
import androidx.compose.foundation.lazy.itemsIndexed
import androidx.compose.foundation.rememberScrollState
import androidx.compose.foundation.shape.RoundedCornerShape
import androidx.compose.material3.Card
import androidx.compose.material3.FilterChip
import androidx.compose.material3.HorizontalDivider
import androidx.compose.material3.Icon
import androidx.compose.material3.IconButton
import androidx.compose.material3.MaterialTheme
import androidx.compose.material3.OutlinedTextField
import androidx.compose.material3.Text
import androidx.compose.runtime.Composable
import androidx.compose.runtime.getValue
import androidx.compose.runtime.mutableStateOf
import androidx.compose.runtime.remember
import androidx.compose.runtime.rememberCoroutineScope
import androidx.compose.runtime.saveable.rememberSaveable
import androidx.compose.runtime.setValue
import androidx.compose.ui.Alignment
import androidx.compose.ui.Modifier
import androidx.compose.ui.graphics.Color
import androidx.compose.ui.platform.LocalContext
import androidx.compose.ui.res.painterResource
import androidx.compose.ui.res.stringResource
import androidx.compose.ui.text.style.TextAlign
import androidx.compose.ui.text.style.TextOverflow
import androidx.compose.ui.unit.dp
import androidx.lifecycle.compose.collectAsStateWithLifecycle
import kotlinx.coroutines.Dispatchers
import kotlinx.coroutines.launch
import kotlinx.coroutines.withContext
import java.text.SimpleDateFormat
import java.util.Date
import java.util.Locale
private enum class MonitorFilter { ALL, BLOCKED, ERRORS }
private val TimeFormat = SimpleDateFormat("HH:mm:ss", Locale.ROOT)
@Composable
fun MonitorScreen(modifier: Modifier = Modifier) {
val context = LocalContext.current
val scope = rememberCoroutineScope()
val custom by Blocklist.custom.collectAsStateWithLifecycle()
val customSet = remember(custom) { custom.toHashSet() }
var entries by remember { mutableStateOf(QueryLog.snapshot()) }
var stats by remember { mutableStateOf(QueryLog.stats()) }
var filter by rememberSaveable { mutableStateOf(MonitorFilter.ALL) }
var search by rememberSaveable { mutableStateOf("") }
OnQueryLogChange {
entries = QueryLog.snapshot()
stats = QueryLog.stats()
}
val visible = remember(entries, filter, search) {
val term = search.trim()
entries.filter { e ->
val matchesFilter = when (filter) {
MonitorFilter.ALL -> true
MonitorFilter.BLOCKED -> e.status == QueryStatus.BLOCKED
MonitorFilter.ERRORS -> e.status == QueryStatus.FAILED
}
matchesFilter && (term.isEmpty() || e.domain.contains(term, ignoreCase = true))
}
}
fun toggleBlock(domain: String, unblock: Boolean) {
scope.launch {
val result = withContext(Dispatchers.IO) {
tryEdit {
if (unblock) {
Blocklist.removeCustom(context, domain)
true
} else {
Blocklist.addCustom(context, domain)
}
}
}
val ok = result.getOrElse {
showEditError(context, it)
return@launch
}
val message = when {
!ok -> context.getString(R.string.bl_invalid)
unblock -> context.getString(R.string.mon_unblocked, domain)
else -> context.getString(R.string.mon_blocked_added, domain)
}
Toast.makeText(context, message, Toast.LENGTH_SHORT).show()
}
}
LazyColumn(
modifier = modifier.fillMaxSize(),
contentPadding = PaddingValues(16.dp),
) {
item {
Card(Modifier.fillMaxWidth()) {
Row(
modifier = Modifier.padding(vertical = 16.dp),
verticalAlignment = Alignment.CenterVertically,
) {
StatColumn(formatCount(stats.total), stringResource(R.string.mon_queries), Modifier.weight(1f))
StatDivider()
StatColumn(cachePercent(stats), stringResource(R.string.mon_cached), Modifier.weight(1f))
StatDivider()
StatColumn(formatCount(stats.blocked), stringResource(R.string.mon_blocked), Modifier.weight(1f))
StatDivider()
StatColumn(
stringResource(R.string.mon_ms, stats.avgLatencyMs),
stringResource(R.string.mon_latency),
Modifier.weight(1f),
)
}
}
}
item {
Row(
modifier = Modifier.padding(top = 12.dp),
verticalAlignment = Alignment.CenterVertically,
) {
// Chips scroll sideways on narrow screens instead of squeezing the clear button
Row(
modifier = Modifier
.weight(1f)
.horizontalScroll(rememberScrollState()),
horizontalArrangement = Arrangement.spacedBy(8.dp),
) {
FilterChip(
selected = filter == MonitorFilter.ALL,
onClick = { filter = MonitorFilter.ALL },
label = { Text(stringResource(R.string.mon_all)) },
)
FilterChip(
selected = filter == MonitorFilter.BLOCKED,
onClick = { filter = MonitorFilter.BLOCKED },
label = { Text(stringResource(R.string.status_blocked)) },
leadingIcon = { ChipIcon(R.drawable.ic_tab_block) },
)
FilterChip(
selected = filter == MonitorFilter.ERRORS,
onClick = { filter = MonitorFilter.ERRORS },
label = { Text(stringResource(R.string.mon_errors)) },
leadingIcon = { ChipIcon(R.drawable.ic_alert) },
)
}
IconButton(
onClick = {
QueryLog.clear()
entries = emptyList()
stats = QueryLog.stats()
},
enabled = entries.isNotEmpty() || stats.total > 0,
) {
Icon(painterResource(R.drawable.ic_clear), stringResource(R.string.mon_clear), Modifier.size(22.dp))
}
}
}
item {
OutlinedTextField(
value = search,
onValueChange = { search = it },
placeholder = { Text(stringResource(R.string.mon_search)) },
leadingIcon = { Icon(painterResource(R.drawable.ic_search), contentDescription = null) },
singleLine = true,
shape = RoundedCornerShape(50),
modifier = Modifier
.fillMaxWidth()
.padding(vertical = 12.dp),
)
}
if (visible.isEmpty()) {
item(key = "empty") {
val text = stringResource(if (entries.isEmpty()) R.string.mon_empty else R.string.mon_no_match)
Box(Modifier.animateItem()) { EmptyState(R.drawable.ic_tab_monitor, text) }
}
}
itemsIndexed(visible, key = { _, e -> e.id }, contentType = { _, _ -> "query" }) { index, entry ->
val inCustom = entry.domain in customSet
QueryRow(
modifier = Modifier.animateItem(),
entry = entry,
first = index == 0,
last = index == visible.lastIndex,
showBlock = !inCustom && entry.status != QueryStatus.BLOCKED,
showUnblock = inCustom,
onBlock = { toggleBlock(entry.domain, unblock = false) },
onUnblock = { toggleBlock(entry.domain, unblock = true) },
)
}
}
}
@Composable
private fun ChipIcon(icon: Int) {
Icon(painterResource(icon), contentDescription = null, modifier = Modifier.size(18.dp))
}
@Composable
fun EmptyState(icon: Int, text: String) {
Column(
modifier = Modifier
.fillMaxWidth()
.padding(vertical = 40.dp),
horizontalAlignment = Alignment.CenterHorizontally,
) {
IconBadge(icon, MaterialTheme.colorScheme.onSurfaceVariant, size = 64.dp)
Spacer(Modifier.height(12.dp))
Text(
text,
style = MaterialTheme.typography.bodyMedium,
color = MaterialTheme.colorScheme.onSurfaceVariant,
textAlign = TextAlign.Center,
)
}
}
@Composable
private fun QueryRow(
modifier: Modifier,
entry: QueryEntry,
first: Boolean,
last: Boolean,
showBlock: Boolean,
showUnblock: Boolean,
onBlock: () -> Unit,
onUnblock: () -> Unit,
) {
val (icon, color: Color) = when (entry.status) {
QueryStatus.OK -> R.drawable.ic_check to MaterialTheme.colorScheme.primary
QueryStatus.CACHED -> R.drawable.ic_check to CachedColor
QueryStatus.BLOCKED -> R.drawable.ic_tab_block to MaterialTheme.colorScheme.error
QueryStatus.FAILED -> R.drawable.ic_alert to WarningColor
}
val label = when (entry.status) {
QueryStatus.OK -> stringResource(R.string.mon_ms, entry.latencyMs)
QueryStatus.CACHED -> stringResource(R.string.status_cached)
QueryStatus.BLOCKED -> stringResource(R.string.status_blocked)
QueryStatus.FAILED -> stringResource(R.string.status_failed)
}
Column(
modifier
.fillMaxWidth()
.background(groupedBackground, groupedShape(first, last))
) {
if (!first) {
HorizontalDivider(
modifier = Modifier.padding(start = 60.dp),
color = MaterialTheme.colorScheme.outlineVariant.copy(alpha = 0.5f),
)
}
Row(
modifier = Modifier.padding(start = 12.dp, end = 4.dp, top = 8.dp, bottom = 8.dp),
verticalAlignment = Alignment.CenterVertically,
) {
IconBadge(icon, color, size = 36.dp)
Spacer(Modifier.width(12.dp))
Column(Modifier.weight(1f)) {
Text(entry.domain, style = MaterialTheme.typography.bodyMedium, maxLines = 1, overflow = TextOverflow.Ellipsis)
Text(
"${TimeFormat.format(Date(entry.time))} · ${DnsMessage.typeName(entry.type)}",
style = MaterialTheme.typography.bodySmall,
color = MaterialTheme.colorScheme.onSurfaceVariant,
)
}
Spacer(Modifier.width(8.dp))
Pill(label, color)
when {
showBlock -> IconButton(onClick = onBlock) {
Icon(painterResource(R.drawable.ic_tab_block), stringResource(R.string.mon_block), Modifier.size(20.dp))
}
showUnblock -> IconButton(onClick = onUnblock) {
Icon(painterResource(R.drawable.ic_check), stringResource(R.string.mon_unblock), Modifier.size(20.dp))
}
else -> Spacer(Modifier.width(48.dp))
}
}
}
}
@@ -5,10 +5,6 @@ import android.content.Context
class Prefs(context: Context) {
private val sp = context.applicationContext.getSharedPreferences("doh", Context.MODE_PRIVATE)
init {
ServerList.ensureLoaded(context.applicationContext)
}
var providerId: String
get() = sp.getString(KEY_PROVIDER, null) ?: Providers.default.id
set(value) = sp.edit().putString(KEY_PROVIDER, value).apply()
@@ -29,6 +25,15 @@ class Prefs(context: Context) {
get() = sp.getStringSet(KEY_EXCLUDED, null)?.toSet() ?: emptySet()
set(value) = sp.edit().putStringSet(KEY_EXCLUDED, value).apply()
var updateInterval: UpdateInterval
get() = UpdateInterval.entries.getOrNull(sp.getInt(KEY_UPDATE_INTERVAL, UpdateInterval.DAILY.ordinal))
?: UpdateInterval.DAILY
set(value) = sp.edit().putInt(KEY_UPDATE_INTERVAL, value.ordinal).apply()
var updateWifiOnly: Boolean
get() = sp.getBoolean(KEY_UPDATE_WIFI_ONLY, true)
set(value) = sp.edit().putBoolean(KEY_UPDATE_WIFI_ONLY, value).apply()
// Hint cards the user closed with the X
fun isHintDismissed(key: String): Boolean =
sp.getStringSet(KEY_HINTS, null)?.contains(key) == true
@@ -58,5 +63,7 @@ class Prefs(context: Context) {
const val KEY_EXCLUDED = "excluded_apps"
const val KEY_HINTS = "dismissed_hints"
const val KEY_PRIVATE_DNS = "dismissed_private_dns"
const val KEY_UPDATE_INTERVAL = "update_interval"
const val KEY_UPDATE_WIFI_ONLY = "update_wifi_only"
}
}
@@ -1,13 +1,6 @@
package cc.skysparkle.sparkledns
import android.content.Context
import kotlinx.coroutines.flow.MutableStateFlow
import kotlinx.coroutines.flow.StateFlow
import okhttp3.HttpUrl.Companion.toHttpUrlOrNull
import okhttp3.Request
import java.io.File
import java.io.IOException
import java.util.concurrent.TimeUnit
data class DohProvider(
val id: String,
@@ -23,7 +16,7 @@ object Providers {
const val CUSTOM_ID = "custom"
const val DEFAULT_ID = "skysparkle"
// Shipped with the app and used until the list from the repository is downloaded
// Servers ship with the app; new ones arrive with app updates
val builtIn = listOf(
DohProvider(
"skysparkle", "SkySparkle", "https://blog.skysparkle.cc/dns-query",
@@ -52,7 +45,7 @@ object Providers {
),
)
val list: List<DohProvider> get() = ServerList.servers.value
val list: List<DohProvider> get() = builtIn
// The project's own server stays the default whatever order the list uses
val default: DohProvider get() = list.firstOrNull { it.id == DEFAULT_ID } ?: list.first()
@@ -60,103 +53,6 @@ object Providers {
fun byId(id: String): DohProvider = list.firstOrNull { it.id == id } ?: default
}
// The server list kept in the project repository, so servers can change without an app update
object ServerList {
const val SOURCE = "https://git.skysparkle.cc/kalarina/Sparkledns/raw/branch/main/servers/servers.txt"
private const val FILE = "servers.txt"
private const val MAX_BYTES = 64 * 1024
private const val MAX_SERVERS = 50
private val _servers = MutableStateFlow(Providers.builtIn)
val servers: StateFlow<List<DohProvider>> = _servers
@Volatile private var loaded = false
private val client by lazy {
Http.client.newBuilder()
.readTimeout(30, TimeUnit.SECONDS)
.build()
}
fun ensureLoaded(context: Context) {
if (loaded) return
synchronized(this) {
if (loaded) return
val cached = runCatching { File(context.filesDir, FILE).readText() }.getOrNull()
cached?.let(::parse)?.takeIf { it.isNotEmpty() }?.let { _servers.value = it }
loaded = true
}
}
// Blocking: call off the main thread. Returns the number of servers in the new list.
fun sync(context: Context): Int {
val request = Request.Builder().url(SOURCE).build()
val text = client.newCall(request).execute().use { response ->
if (!response.isSuccessful) throw IOException("HTTP ${response.code}")
val body = response.body ?: throw IOException("Empty response")
if (body.contentLength() > MAX_BYTES) throw IOException("List too large")
val bytes = body.byteStream().readNBytesCompat(MAX_BYTES + 1)
if (bytes.size > MAX_BYTES) throw IOException("List too large")
String(bytes, Charsets.UTF_8)
}
val parsed = parse(text)
if (parsed.isEmpty()) throw IOException("No servers found")
val file = File(context.filesDir, FILE)
val tmp = File(context.filesDir, "$FILE.tmp")
tmp.writeText(text)
if (!tmp.renameTo(file)) {
tmp.delete()
throw IOException("Cannot save list")
}
_servers.value = parsed
loaded = true
return parsed.size
}
// Format per line: Name | DoH URL | privacy policy URL | h3 (optional) | donation URL (optional).
// The optional columns are recognised by content, so either can be left out. See CONTRIBUTING.md.
fun parse(text: String): List<DohProvider> {
val builtInByHost = Providers.builtIn.associateBy { it.url.toHttpUrlOrNull()?.host }
val seen = HashSet<String>()
val result = ArrayList<DohProvider>()
for (raw in text.lineSequence()) {
val line = raw.trim()
if (line.isEmpty() || line.startsWith("#")) continue
val cols = line.split('|').map { it.trim() }
if (cols.size < 3) continue
val name = cols[0].take(40)
val url = cols[1].toHttpUrlOrNull()
val policy = cols[2].takeIf { it.toHttpUrlOrNull()?.isHttps == true }
if (name.isEmpty() || url == null || !url.isHttps) continue
val extras = cols.drop(3)
val http3 = extras.any { it.equals("h3", ignoreCase = true) }
val donate = extras.firstOrNull { it.toHttpUrlOrNull()?.isHttps == true }
// Shipped servers keep their address, id and links, so an edited list cannot redirect them
val pinned = builtInByHost[url.host]
val server = pinned
?: if (policy == null) continue
else DohProvider(url.host, name, cols[1], http3 = http3, policy = policy, donate = donate)
if (!seen.add(server.id)) continue
result += server
if (result.size >= MAX_SERVERS) break
}
return result
}
}
private fun java.io.InputStream.readNBytesCompat(limit: Int): ByteArray {
val out = java.io.ByteArrayOutputStream()
val buffer = ByteArray(8192)
var total = 0
while (total < limit) {
val read = read(buffer, 0, minOf(buffer.size, limit - total))
if (read < 0) break
out.write(buffer, 0, read)
total += read
}
return out.toByteArray()
}
fun parseIps(raw: String): List<String> =
raw.split(',', ';', ' ').map { it.trim() }.filter { it.isNotEmpty() }
@@ -24,7 +24,8 @@ data class QueryStats(
val avgLatencyMs: Int,
)
// In-memory only: nothing is written to disk or sent anywhere
// In-memory only: nothing is written to disk or sent anywhere. StatsStore keeps hourly
// numbers without domains for the charts.
object QueryLog {
private const val MAX_ENTRIES = 500
@@ -61,6 +62,8 @@ object QueryLog {
}
version.value++
}
// Hourly numbers for the charts; outside the lock above, as it takes a lock of its own
StatsStore.record(status, latencyMs, Companies.of(question.name))
}
// Newest first. Builds a real copy: on API 35+ List.reversed() resolves to a live JDK view,
@@ -0,0 +1,340 @@
package cc.skysparkle.sparkledns
import androidx.compose.animation.AnimatedVisibility
import androidx.compose.animation.animateColorAsState
import androidx.compose.foundation.background
import androidx.compose.foundation.clickable
import androidx.compose.foundation.layout.Arrangement
import androidx.compose.foundation.layout.Column
import androidx.compose.foundation.layout.Row
import androidx.compose.foundation.layout.Spacer
import androidx.compose.foundation.layout.fillMaxWidth
import androidx.compose.foundation.layout.height
import androidx.compose.foundation.layout.heightIn
import androidx.compose.foundation.layout.padding
import androidx.compose.foundation.layout.size
import androidx.compose.foundation.layout.width
import androidx.compose.foundation.rememberScrollState
import androidx.compose.foundation.selection.selectable
import androidx.compose.foundation.selection.toggleable
import androidx.compose.foundation.shape.RoundedCornerShape
import androidx.compose.foundation.text.KeyboardOptions
import androidx.compose.foundation.verticalScroll
import androidx.compose.material3.Button
import androidx.compose.material3.Icon
import androidx.compose.material3.IconButton
import androidx.compose.material3.OutlinedButton
import androidx.compose.material3.OutlinedTextField
import androidx.compose.material3.Text
import androidx.compose.runtime.Composable
import androidx.compose.runtime.LaunchedEffect
import androidx.compose.runtime.getValue
import androidx.compose.runtime.mutableStateOf
import androidx.compose.runtime.remember
import androidx.compose.runtime.rememberCoroutineScope
import androidx.compose.runtime.saveable.rememberSaveable
import androidx.compose.runtime.setValue
import androidx.compose.ui.Alignment
import androidx.compose.ui.Modifier
import androidx.compose.ui.graphics.Color
import androidx.compose.ui.platform.LocalContext
import androidx.compose.ui.res.painterResource
import androidx.compose.ui.res.stringResource
import androidx.compose.ui.semantics.Role
import androidx.compose.ui.text.font.FontWeight
import androidx.compose.ui.text.input.ImeAction
import androidx.compose.ui.text.input.KeyboardType
import androidx.compose.ui.text.style.TextOverflow
import androidx.compose.ui.unit.Dp
import androidx.compose.ui.unit.dp
import androidx.compose.ui.unit.sp
import androidx.lifecycle.compose.collectAsStateWithLifecycle
import kotlinx.coroutines.Dispatchers
import kotlinx.coroutines.delay
import kotlinx.coroutines.launch
import kotlinx.coroutines.withContext
import okhttp3.HttpUrl.Companion.toHttpUrlOrNull
@Composable
fun SettingsScreen(
bottomPadding: Dp,
onOpenApps: () -> Unit,
onOpenAbout: () -> Unit,
modifier: Modifier = Modifier,
) {
val context = LocalContext.current
val prefs = remember { Prefs(context) }
val scope = rememberCoroutineScope()
val active by DohVpnService.active.collectAsStateWithLifecycle()
var selected by remember { mutableStateOf(prefs.providerId) }
var customUrl by remember { mutableStateOf(prefs.customUrl) }
var customBootstrap by remember { mutableStateOf(prefs.customBootstrap) }
var customHttp3 by remember { mutableStateOf(prefs.customHttp3) }
var testResult by rememberSaveable(stateSaver = TestResultSaver) { mutableStateOf<TestResult?>(null) }
var shownResult by rememberSaveable(stateSaver = TestResultSaver) { mutableStateOf<TestResult?>(null) } // kept while the card animates out
var testing by remember { mutableStateOf(false) }
val excludedCount = remember { prefs.excludedApps.size }
val isCustom = selected == Providers.CUSTOM_ID
val customValid = remember(customUrl) { customUrl.trim().toHttpUrlOrNull()?.isHttps == true }
val canConnect = !isCustom || customValid
val selectedProvider = remember(selected, customUrl, customBootstrap, customHttp3) { prefs.resolve() }
// Picking a server never touches a live connection; switching is an explicit action
val pendingSwitch = active?.let { it != selectedProvider && canConnect } == true
var busy by remember { mutableStateOf(false) }
LaunchedEffect(active) { busy = false }
LaunchedEffect(busy) {
if (busy) {
delay(BUSY_TIMEOUT_MS)
busy = false
}
}
fun select(id: String) {
selected = id
prefs.providerId = id
testResult = null
}
fun runTest() {
val provider = prefs.resolve()
testing = true
testResult = null
scope.launch {
val result = withContext(Dispatchers.IO) { testProvider(context, provider) }
shownResult = result
testResult = result
testing = false
}
}
Column(
modifier = modifier
.verticalScroll(rememberScrollState())
.padding(start = 20.dp, end = 20.dp, top = 16.dp, bottom = bottomPadding),
verticalArrangement = Arrangement.spacedBy(10.dp),
) {
ScreenTitle(stringResource(R.string.tab_settings), Modifier.heightIn(min = 44.dp))
SectionLabel(stringResource(R.string.servers), Modifier.padding(top = 8.dp))
Column(Modifier.fillMaxWidth().appCard()) {
Providers.list.forEachIndexed { index, provider ->
if (index > 0) ListDivider()
ServerRow(
title = provider.name,
subtitle = hostOf(provider.url) + if (provider.http3) " · HTTP/3" else "",
selected = selected == provider.id,
onPolicy = provider.policy?.let { url -> { openUrl(context, url) } },
onDonate = provider.donate?.let { url -> { openUrl(context, url) } },
onClick = { select(provider.id) },
)
}
ListDivider()
ServerRow(
title = stringResource(R.string.custom),
subtitle = if (customUrl.trim() == "https://" || customUrl.isBlank()) "DNS-over-HTTPS (RFC 8484)" else hostOf(customUrl),
selected = isCustom,
onClick = { select(Providers.CUSTOM_ID) },
)
AnimatedVisibility(visible = isCustom, enter = Motion.expandIn, exit = Motion.collapseOut) {
Column(
Modifier.padding(start = 16.dp, end = 16.dp, bottom = 16.dp),
verticalArrangement = Arrangement.spacedBy(8.dp),
) {
OutlinedTextField(
value = customUrl,
onValueChange = { customUrl = it; prefs.customUrl = it },
label = { Text(stringResource(R.string.custom_url)) },
singleLine = true,
isError = !customValid,
shape = RoundedCornerShape(14.dp),
keyboardOptions = KeyboardOptions(keyboardType = KeyboardType.Uri, imeAction = ImeAction.Next),
modifier = Modifier.fillMaxWidth(),
)
if (!customValid) {
Text(stringResource(R.string.invalid_url), color = Palette.Blocked, fontSize = 12.sp)
}
OutlinedTextField(
value = customBootstrap,
onValueChange = { customBootstrap = it; prefs.customBootstrap = it },
label = { Text(stringResource(R.string.custom_bootstrap)) },
singleLine = true,
shape = RoundedCornerShape(14.dp),
keyboardOptions = KeyboardOptions(keyboardType = KeyboardType.Uri, imeAction = ImeAction.Done),
modifier = Modifier.fillMaxWidth(),
)
Row(
modifier = Modifier
.fillMaxWidth()
.toggleable(
value = customHttp3,
role = Role.Switch,
onValueChange = { customHttp3 = it; prefs.customHttp3 = it },
)
.padding(vertical = 4.dp),
verticalAlignment = Alignment.CenterVertically,
) {
Column(Modifier.weight(1f)) {
Text(stringResource(R.string.http3), color = Palette.Fg, fontSize = 15.sp)
Text(stringResource(R.string.http3_note), color = Palette.Fg3, fontSize = 12.sp)
}
Spacer(Modifier.width(12.dp))
AppSwitch(checked = customHttp3, onCheckedChange = null)
}
}
}
}
Row(horizontalArrangement = Arrangement.spacedBy(10.dp)) {
OutlinedButton(
onClick = ::runTest,
enabled = !testing && canConnect,
shape = RoundedCornerShape(16.dp),
modifier = Modifier
.weight(1f)
.height(48.dp),
) { Text(stringResource(if (testing) R.string.testing else R.string.test), maxLines = 1) }
// Remembers the last name so the button keeps its label while it animates out
val lastSwitch = remember { arrayOf("") }
if (pendingSwitch) lastSwitch[0] = selectedProvider.displayName(context)
AnimatedVisibility(visible = pendingSwitch, modifier = Modifier.weight(1f)) {
Button(
onClick = {
if (!busy) {
busy = true
sendAction(context, DohVpnService.ACTION_START)
}
},
enabled = !busy,
shape = RoundedCornerShape(16.dp),
modifier = Modifier
.fillMaxWidth()
.height(48.dp),
) {
Text(
stringResource(R.string.switch_to, lastSwitch[0]),
maxLines = 1,
overflow = TextOverflow.Ellipsis,
)
}
}
}
AnimatedVisibility(visible = testResult != null, enter = Motion.expandIn, exit = Motion.collapseOut) {
shownResult?.let { result ->
HintCard(
text = result.text,
icon = if (result.ok) R.drawable.ic_check else R.drawable.ic_alert,
tint = if (result.ok) CachedColor else Palette.Blocked,
onDismiss = { testResult = null },
)
}
}
SectionLabel(stringResource(R.string.settings_general), Modifier.padding(top = 8.dp))
Column(Modifier.fillMaxWidth().appCard()) {
NavRow(
title = stringResource(R.string.settings_apps),
subtitle = if (excludedCount > 0) stringResource(R.string.apps_count, excludedCount)
else stringResource(R.string.settings_apps_desc),
onClick = onOpenApps,
)
ListDivider()
NavRow(
title = stringResource(R.string.tab_about),
subtitle = "${stringResource(R.string.about_version)} ${BuildConfig.VERSION_NAME}",
onClick = onOpenAbout,
)
}
}
}
@Composable
private fun ServerRow(
title: String,
subtitle: String,
selected: Boolean,
onPolicy: (() -> Unit)? = null,
onDonate: (() -> Unit)? = null,
onClick: () -> Unit,
) {
val highlight by animateColorAsState(
if (selected) Palette.Accent.copy(alpha = 0.06f) else Color.Transparent,
animationSpec = Motion.color,
label = "highlight",
)
Row(
modifier = Modifier
.fillMaxWidth()
.background(highlight)
.selectable(selected = selected, onClick = onClick, role = Role.RadioButton)
.heightIn(min = 60.dp)
.padding(start = 16.dp, end = 8.dp, top = 8.dp, bottom = 8.dp),
verticalAlignment = Alignment.CenterVertically,
) {
Column(Modifier.weight(1f)) {
Text(
title,
color = Palette.Fg,
fontSize = 15.sp,
fontWeight = FontWeight.Bold,
maxLines = 1,
overflow = TextOverflow.Ellipsis,
)
Text(subtitle, color = Palette.Fg3, fontSize = 12.sp, maxLines = 1, overflow = TextOverflow.Ellipsis)
}
if (onDonate != null) {
IconButton(onClick = onDonate, modifier = Modifier.size(40.dp)) {
Icon(
painterResource(R.drawable.ic_donate),
contentDescription = stringResource(R.string.donate),
tint = Palette.Fg3,
modifier = Modifier.size(18.dp),
)
}
}
if (onPolicy != null) {
IconButton(onClick = onPolicy, modifier = Modifier.size(40.dp)) {
Icon(
painterResource(R.drawable.ic_policy),
contentDescription = stringResource(R.string.about_privacy_policy),
tint = Palette.Fg3,
modifier = Modifier.size(18.dp),
)
}
}
Spacer(Modifier.width(4.dp))
if (selected) {
Icon(
painterResource(R.drawable.ic_check),
contentDescription = null,
tint = Palette.Accent,
modifier = Modifier.size(22.dp),
)
} else {
Spacer(Modifier.size(22.dp))
}
Spacer(Modifier.width(6.dp))
}
}
@Composable
private fun NavRow(title: String, subtitle: String, onClick: () -> Unit) {
Row(
modifier = Modifier
.fillMaxWidth()
.clickable(onClick = onClick)
.heightIn(min = 60.dp)
.padding(start = 16.dp, end = 12.dp, top = 10.dp, bottom = 10.dp),
verticalAlignment = Alignment.CenterVertically,
) {
Column(Modifier.weight(1f)) {
Text(title, color = Palette.Fg, fontSize = 15.sp, fontWeight = FontWeight.Bold)
Text(subtitle, color = Palette.Fg3, fontSize = 12.sp, maxLines = 1, overflow = TextOverflow.Ellipsis)
}
Chevron()
}
}
@@ -0,0 +1,210 @@
package cc.skysparkle.sparkledns
import android.content.Context
import android.util.Log
import kotlinx.coroutines.flow.MutableStateFlow
import kotlinx.coroutines.flow.StateFlow
import java.io.BufferedInputStream
import java.io.ByteArrayOutputStream
import java.io.DataInputStream
import java.io.DataOutputStream
import java.io.File
import java.io.FileInputStream
import java.util.concurrent.Executors
class StatsSummary(
val total: Long,
val blocked: Long,
val cached: Long,
val avgLatencyMs: Int,
// Requests per company, indexed by Company.ordinal
val companies: LongArray,
)
class HourPoint(val total: Long, val blocked: Long)
// Hourly counters of the last 7 days for the charts. Only numbers are kept, never domains,
// and they never leave the device.
object StatsStore {
private const val HOURS = 24 * 7
private const val HOUR_MS = 3_600_000L
private const val FORMAT = 1
private const val FILE = "stats.bin"
private const val SAVE_INTERVAL_MS = 60_000L
// Per hour: total, blocked, cached, latency sum and count, then one counter per company
private const val TOTAL = 0
private const val BLOCKED = 1
private const val CACHED = 2
private const val LATENCY_SUM = 3
private const val LATENCY_COUNT = 4
private const val FIRST_COMPANY = 5
private val FIELDS = FIRST_COMPANY + Company.entries.size
// A ring of slots; each remembers which hour (since the epoch) it currently holds
private val hourIds = LongArray(HOURS) { -1L }
private val counters = Array(HOURS) { LongArray(FIELDS) }
private var file: File? = null
// Bumped when the numbers change without a new query: loaded from disk or cleared
private val _version = MutableStateFlow(0)
val version: StateFlow<Int> = _version
private var lastSave = 0L
private var dirty = false
// Saves happen off the VPN threads, one at a time
private val writer = Executors.newSingleThreadExecutor { Thread(it, "stats-writer").apply { isDaemon = true } }
fun init(context: Context) {
val target = File(context.filesDir, FILE)
synchronized(this) {
file = target
load(target)
}
_version.value++
}
fun record(status: QueryStatus, latencyMs: Int, company: Company?, now: Long = System.currentTimeMillis()) {
val snapshot = synchronized(this) {
val row = row(now / HOUR_MS)
row[TOTAL]++
when (status) {
QueryStatus.BLOCKED -> row[BLOCKED]++
QueryStatus.CACHED -> row[CACHED]++
QueryStatus.OK -> {
row[LATENCY_SUM] += latencyMs.toLong()
row[LATENCY_COUNT]++
}
QueryStatus.FAILED -> Unit
}
if (company != null) row[FIRST_COMPANY + company.ordinal]++
dirty = true
if (file != null && now - lastSave >= SAVE_INTERVAL_MS) {
lastSave = now
dirty = false
encode()
} else {
null
}
}
snapshot?.let(::save)
}
// Totals of the last [hours] hours, the current one included
fun summary(hours: Int, now: Long = System.currentTimeMillis()): StatsSummary = synchronized(this) {
val current = now / HOUR_MS
val sums = LongArray(FIELDS)
for (back in 0 until hours.coerceIn(1, HOURS)) {
val id = current - back
val index = slot(id)
if (hourIds[index] != id) continue
val row = counters[index]
for (field in 0 until FIELDS) sums[field] += row[field]
}
StatsSummary(
total = sums[TOTAL],
blocked = sums[BLOCKED],
cached = sums[CACHED],
avgLatencyMs = if (sums[LATENCY_COUNT] == 0L) 0 else (sums[LATENCY_SUM] / sums[LATENCY_COUNT]).toInt(),
companies = sums.copyOfRange(FIRST_COMPANY, FIELDS),
)
}
// One point per hour, oldest first, ending with the current hour
fun hourly(hours: Int, now: Long = System.currentTimeMillis()): List<HourPoint> = synchronized(this) {
val count = hours.coerceIn(1, HOURS)
val current = now / HOUR_MS
List(count) { position ->
val id = current - (count - 1 - position)
val index = slot(id)
if (hourIds[index] == id) HourPoint(counters[index][TOTAL], counters[index][BLOCKED]) else HourPoint(0, 0)
}
}
fun clear() {
val snapshot = synchronized(this) {
hourIds.fill(-1L)
counters.forEach { it.fill(0L) }
dirty = false
lastSave = System.currentTimeMillis()
if (file != null) encode() else null
}
snapshot?.let(::save)
_version.value++
}
// Saves what is not on disk yet; called when the VPN stops
fun flush() {
val snapshot = synchronized(this) {
if (file != null && dirty) {
dirty = false
lastSave = System.currentTimeMillis()
encode()
} else {
null
}
}
snapshot?.let(::save)
}
private fun slot(id: Long): Int = (((id % HOURS) + HOURS) % HOURS).toInt()
private fun row(id: Long): LongArray {
val index = slot(id)
if (hourIds[index] != id) {
hourIds[index] = id
counters[index].fill(0L)
}
return counters[index]
}
private fun encode(): ByteArray {
val bytes = ByteArrayOutputStream()
DataOutputStream(bytes).use { out ->
out.writeInt(FORMAT)
out.writeInt(FIELDS)
out.writeInt(HOURS)
for (index in 0 until HOURS) {
out.writeLong(hourIds[index])
counters[index].forEach { out.writeLong(it) }
}
}
return bytes.toByteArray()
}
private fun save(bytes: ByteArray) {
val target = file ?: return
writer.execute {
try {
val tmp = File(target.parentFile, "$FILE.tmp")
tmp.writeBytes(bytes)
if (!tmp.renameTo(target)) tmp.delete()
} catch (e: Exception) {
Log.w("SparkleDNS", "Cannot save statistics", e)
}
}
}
// Files from a version with fewer companies load fine: the new counters start at zero
private fun load(source: File) {
if (!source.exists()) return
try {
DataInputStream(BufferedInputStream(FileInputStream(source))).use { input ->
if (input.readInt() != FORMAT) return
val fields = input.readInt()
if (input.readInt() != HOURS || fields < FIRST_COMPANY) return
for (index in 0 until HOURS) {
hourIds[index] = input.readLong()
for (field in 0 until fields) {
val value = input.readLong()
if (field < FIELDS) counters[index][field] = value
}
}
}
} catch (e: Exception) {
Log.w("SparkleDNS", "Cannot read statistics", e)
hourIds.fill(-1L)
counters.forEach { it.fill(0L) }
}
}
}
@@ -0,0 +1,245 @@
package cc.skysparkle.sparkledns
import androidx.compose.foundation.background
import androidx.compose.foundation.layout.Box
import androidx.compose.foundation.layout.BoxScope
import androidx.compose.foundation.layout.Column
import androidx.compose.foundation.layout.Row
import androidx.compose.foundation.layout.Spacer
import androidx.compose.foundation.layout.fillMaxSize
import androidx.compose.foundation.layout.fillMaxWidth
import androidx.compose.foundation.layout.height
import androidx.compose.foundation.layout.heightIn
import androidx.compose.foundation.layout.navigationBarsPadding
import androidx.compose.foundation.layout.padding
import androidx.compose.foundation.layout.size
import androidx.compose.foundation.layout.width
import androidx.compose.foundation.shape.RoundedCornerShape
import androidx.compose.foundation.text.BasicTextField
import androidx.compose.material3.HorizontalDivider
import androidx.compose.material3.Icon
import androidx.compose.material3.IconButton
import androidx.compose.material3.Switch
import androidx.compose.material3.SwitchDefaults
import androidx.compose.material3.Text
import androidx.compose.material3.darkColorScheme
import androidx.compose.runtime.Composable
import androidx.compose.ui.Alignment
import androidx.compose.ui.Modifier
import androidx.compose.ui.draw.clip
import androidx.compose.ui.graphics.Color
import androidx.compose.ui.graphics.SolidColor
import androidx.compose.ui.res.painterResource
import androidx.compose.ui.res.stringResource
import androidx.compose.ui.text.TextStyle
import androidx.compose.ui.text.font.FontWeight
import androidx.compose.ui.text.style.TextOverflow
import androidx.compose.ui.unit.dp
import androidx.compose.ui.unit.sp
// One dark palette for the whole app
object Palette {
val Bg = Color(0xFF08090B)
val Card = Color(0xFF17181C)
val CardHigh = Color(0xFF1E2026)
val Line = Color(0xFF24262C)
val Track = Color(0xFF3A3C44)
val Muted = Color(0xFF5B5F6B)
val Fg = Color(0xFFF2F3F5)
val Fg2 = Color(0xFF9A9DA6)
val Fg3 = Color(0xFF7E828C)
val Accent = Color(0xFF7FB2FF)
val AccentSoft = Color(0x297FB2FF)
val AccentInk = Color(0xFF0A0B0D)
val Blocked = Color(0xFFFF6B7D)
val Nav = Color(0xEB1E2026)
val NavIcon = Color(0xFF8A8E98)
}
internal val AppColors = darkColorScheme(
primary = Palette.Accent,
onPrimary = Palette.AccentInk,
primaryContainer = Color(0xFF22324A),
onPrimaryContainer = Palette.Accent,
secondary = Palette.Accent,
onSecondary = Palette.AccentInk,
secondaryContainer = Color(0xFF22324A),
onSecondaryContainer = Palette.Accent,
background = Palette.Bg,
onBackground = Palette.Fg,
surface = Palette.Bg,
onSurface = Palette.Fg,
surfaceVariant = Palette.Card,
onSurfaceVariant = Palette.Fg2,
surfaceContainerLowest = Palette.Bg,
surfaceContainerLow = Palette.Card,
surfaceContainer = Palette.Card,
surfaceContainerHigh = Palette.CardHigh,
surfaceContainerHighest = Palette.Card,
outline = Palette.Track,
outlineVariant = Palette.Line,
error = Palette.Blocked,
onError = Palette.AccentInk,
errorContainer = Color(0xFF3A1C22),
onErrorContainer = Color(0xFFFFD9DE),
)
val CardShape = RoundedCornerShape(20.dp)
fun Modifier.appCard(): Modifier = clip(CardShape).background(Palette.Card)
@Composable
fun AppSwitch(
checked: Boolean,
onCheckedChange: ((Boolean) -> Unit)?,
modifier: Modifier = Modifier,
enabled: Boolean = true,
) {
Switch(
checked = checked,
onCheckedChange = onCheckedChange,
modifier = modifier,
enabled = enabled,
colors = appSwitchColors(),
)
}
@Composable
fun appSwitchColors() = SwitchDefaults.colors(
checkedThumbColor = Color.White,
checkedTrackColor = Palette.Accent,
checkedBorderColor = Palette.Accent,
uncheckedThumbColor = Palette.Fg2,
uncheckedTrackColor = Palette.Track,
uncheckedBorderColor = Palette.Track,
)
// Big bold title of a main tab
@Composable
fun ScreenTitle(text: String, modifier: Modifier = Modifier) {
Text(
text,
modifier = modifier,
color = Palette.Fg,
fontSize = 24.sp,
fontWeight = FontWeight.ExtraBold,
letterSpacing = (-0.3).sp,
maxLines = 1,
overflow = TextOverflow.Ellipsis,
)
}
@Composable
fun SectionLabel(text: String, modifier: Modifier = Modifier) {
Text(
text,
modifier = modifier.padding(start = 4.dp, top = 8.dp, bottom = 2.dp),
color = Palette.Fg2,
fontSize = 13.sp,
fontWeight = FontWeight.Bold,
)
}
// Back arrow and title of a page opened from a tab
@Composable
fun PageHeader(
title: String,
onBack: () -> Unit,
modifier: Modifier = Modifier,
action: (@Composable () -> Unit)? = null,
) {
Row(
modifier = modifier
.fillMaxWidth()
.heightIn(min = 56.dp)
.padding(start = 4.dp, end = 12.dp),
verticalAlignment = Alignment.CenterVertically,
) {
IconButton(onClick = onBack) {
Icon(painterResource(R.drawable.ic_back), contentDescription = stringResource(R.string.back), tint = Palette.Fg)
}
Text(
title,
modifier = Modifier.weight(1f),
color = Palette.Fg,
fontSize = 20.sp,
fontWeight = FontWeight.ExtraBold,
maxLines = 1,
overflow = TextOverflow.Ellipsis,
)
action?.invoke()
}
}
// A page with a back header around content that is not built for one
@Composable
fun SubPage(title: String, onBack: () -> Unit, modifier: Modifier = Modifier, content: @Composable BoxScope.() -> Unit) {
Column(modifier) {
PageHeader(title, onBack)
Box(
Modifier
.weight(1f)
.fillMaxSize()
.navigationBarsPadding(),
content = content,
)
}
}
@Composable
fun SearchField(
value: String,
onValueChange: (String) -> Unit,
placeholder: String,
modifier: Modifier = Modifier,
trailing: (@Composable () -> Unit)? = null,
) {
Row(
modifier = modifier
.fillMaxWidth()
.height(48.dp)
.clip(RoundedCornerShape(16.dp))
.background(Palette.Card)
.padding(start = 14.dp, end = if (trailing != null) 2.dp else 14.dp),
verticalAlignment = Alignment.CenterVertically,
) {
Icon(
painterResource(R.drawable.ic_search),
contentDescription = null,
tint = Palette.Fg3,
modifier = Modifier.size(18.dp),
)
Spacer(Modifier.width(10.dp))
Box(Modifier.weight(1f), contentAlignment = Alignment.CenterStart) {
if (value.isEmpty()) {
Text(placeholder, color = Palette.Fg3, fontSize = 14.sp, maxLines = 1, overflow = TextOverflow.Ellipsis)
}
BasicTextField(
value = value,
onValueChange = onValueChange,
modifier = Modifier.fillMaxWidth(),
singleLine = true,
textStyle = TextStyle(color = Palette.Fg, fontSize = 14.sp),
cursorBrush = SolidColor(Palette.Accent),
)
}
trailing?.invoke()
}
}
// Thin line between the rows of a card
@Composable
fun ListDivider(modifier: Modifier = Modifier) {
HorizontalDivider(modifier = modifier.padding(horizontal = 16.dp), color = Palette.Line)
}
// The arrow at the end of a row that opens something
@Composable
fun Chevron(modifier: Modifier = Modifier) {
Icon(
painterResource(R.drawable.ic_chevron),
contentDescription = null,
tint = Palette.Fg3,
modifier = modifier.size(20.dp),
)
}
@@ -13,6 +13,7 @@ import androidx.compose.foundation.layout.Column
import androidx.compose.foundation.layout.Row
import androidx.compose.foundation.layout.Spacer
import androidx.compose.foundation.layout.fillMaxWidth
import androidx.compose.foundation.layout.height
import androidx.compose.foundation.layout.heightIn
import androidx.compose.foundation.layout.padding
import androidx.compose.foundation.layout.size
@@ -238,3 +239,34 @@ fun groupedShape(first: Boolean, last: Boolean, radius: Dp = 16.dp) = RoundedCor
val groupedBackground: Color
@Composable get() = MaterialTheme.colorScheme.surfaceContainerHighest
// Short numbers for stat tiles: 812, 7.27k, 48.1k, 312k, 1.2M (decimal separator of the locale)
fun formatCompact(value: Long): String {
val locale = Locale.getDefault()
return when {
value < 1_000 -> formatCount(value)
value < 10_000 -> String.format(locale, "%.2fk", value / 1_000.0)
value < 100_000 -> String.format(locale, "%.1fk", value / 1_000.0)
value < 1_000_000 -> String.format(locale, "%.0fk", value / 1_000.0)
else -> String.format(locale, "%.1fM", value / 1_000_000.0)
}
}
@Composable
fun EmptyState(icon: Int, text: String) {
Column(
modifier = Modifier
.fillMaxWidth()
.padding(vertical = 40.dp),
horizontalAlignment = Alignment.CenterHorizontally,
) {
IconBadge(icon, MaterialTheme.colorScheme.onSurfaceVariant, size = 64.dp)
Spacer(Modifier.height(12.dp))
Text(
text,
style = MaterialTheme.typography.bodyMedium,
color = MaterialTheme.colorScheme.onSurfaceVariant,
textAlign = TextAlign.Center,
)
}
}