Give the Android client a dark-first Material 3 look and TUI-style graph terminals

Three UI changes requested after reviewing the first on-device screenshots:

- Dark-first theme: the app now owns its colour scheme instead of following the
  system wallpaper. Theme.kt defaults to a deliberate darkColorScheme built from
  a mint/teal seed with an amber tertiary (new Color.kt) so it matches the dark
  Pipelines TUI; dynamic colour is gone and a complete light scheme is retained
  for when it is explicitly requested. themes.xml/colors.xml give the app a dark
  window background and dark system bars with light icons, so launching never
  flashes light.
- Workflow graph matches the TUI: the #success/#failure terminals now share a
  lower row under the stage row, with arrows entering their top borders and the
  error -> #failure route leaving the bottom of its source stage, mirroring
  internal/tui/graph_layout.go ('Terminals share a lower row...') and graph.go's
  '[FAILURE]   [SUCCESS]' bottom row. Fit-to-content, pan clamping, the Fit
  action, run highlighting and the TalkBack description are preserved.
- More style: consistent Material 3 top app bars for Pipelines, Runs and
  Settings, the new colour scheme applied across the screens and state
  components, and monospace retained for hashes, source and run input/output.

Verified on the host and on the device: :app:compileDebugKotlin, :app:assembleDebug
and :app:testDebugUnitTest succeed offline with 34 tests and 0 failures
(WorkflowGraphTest grew to 15 tests covering the terminal row, bottom exits and
fit/clamp), and the app was run on the Pixel_Fold_API_36 emulator in dark mode
against the live server: the whole 4-stage graph renders with its terminal row,
and the list, detail and settings screens use the new theme.
This commit is contained in:
2026-10-14 12:36:58 +01:00
parent cee9fb2f79
commit 9ca775291b
12 changed files with 466 additions and 115 deletions
+25 -11
View File
@@ -81,10 +81,18 @@ stops it.
- Pipeline list (search/refresh, empty/error/loading states), pipeline details
(version list, content hash, source) and the workflow graph.
- Workflow graph composable: content-sized nodes, labelled outcome edges
(`error*` marks the implicit fallback), `#success`/`#failure` terminals, loops
and branches, pan/zoom, and run highlighting (executed routes highlighted,
others dimmed) plus a screen-reader description.
- Workflow graph composable: content-sized stage nodes laid out in one row in
declaration order, with `#failure`/`#success` terminals sharing a lower row and
arrows entering their top borders (an `error -> #failure` route leaves its
source's bottom); labelled outcome edges (`error*` marks the implicit
fallback), loops and branches, pan/zoom, and run highlighting (executed routes
highlighted, others dimmed) plus a screen-reader description.
- Dark-first Material 3 theme with an app-owned colour scheme (no dynamic/
wallpaper colour): the dark scheme is the default and the window background and
system bars are dark so launching shows no light flash; a complete light scheme
is retained for when it is explicitly requested.
- Consistent Material 3 top app bars on Pipelines, Runs and Settings (and the
existing back/refresh/start/cancel/retry bars on the detail screens).
- Run history with server `usage` aggregates, and run details with steps
(status/outcome/diagnostic/session/transcript/file changes/notifications/
control evidence). Session evidence is scoped to the selected run and each
@@ -121,13 +129,15 @@ Verified on macOS with the host toolchain (JDK 17 from Android Studio,
`ANDROID_HOME=/Users/alan/Library/Android/sdk`, Gradle 8.11.1 `--offline`):
- `:app:compileDebugKotlin`, `:app:assembleDebug` and `:app:testDebugUnitTest`
all succeed; **20 unit tests, 0 failures** (protocol model, graph semantics,
server URL, workflow-graph layout). Re-run with `--rerun-tasks` to confirm.
all succeed; **34 unit tests, 0 failures** (protocol model, graph semantics,
server URL, workflow-graph layout including the terminal row, bottom exits and
back edges). Re-run with `--rerun-tasks` to confirm.
- The debug APK was installed and driven on the `Pixel_Fold_API_36` emulator
(Android 16) against a live server at `ws://10.0.2.2:8080/connect` with
workspace `/Users/alan`. Settings, pipeline list (all 9 pipelines), pipeline
detail, the workflow graph, run history, run detail and the disconnected/
reconnect states were captured to `captures/` (git-ignored) and reviewed.
(Android 16, `adb shell cmd uimode night yes`) against a live server at
`ws://10.0.2.2:8080/connect` with workspace `/Users/alan/repos/pipelines`.
Settings, pipeline list (all 9 pipelines), pipeline detail, the workflow graph,
run history and run detail were captured to `captures/` and
`captures/style_pass/` (both git-ignored) and reviewed.
- `adb logcat` for the app package contained no `FATAL EXCEPTION`, Compose or
other runtime exception during the sweep.
@@ -138,4 +148,8 @@ cannot leave the view, added a "Fit graph to view" action, connected on launch
when a server URL is already saved, and made the completed/recorded visit wording
and the outcome-label contrast consistent. The fitted graph still sits slightly
above the box's vertical centre, because the layout box includes padding that is
not drawn.
not drawn. A later style pass made the theme dark-first (app-owned scheme; the
launch window/bar colours match it) and moved the `#failure`/`#success` terminals
to a lower row beneath the stage row; before/after captures for the theme, graph
and app bar/style are under `captures/style_pass/` (`*_before.png` are the
pre-change baseline referenced by the task, `*_after.png` are the new build).
@@ -14,6 +14,7 @@ import androidx.compose.ui.Alignment
import androidx.compose.ui.Modifier
import androidx.compose.ui.semantics.contentDescription
import androidx.compose.ui.semantics.semantics
import androidx.compose.ui.text.font.FontFamily
import androidx.compose.ui.text.style.TextAlign
import androidx.compose.ui.unit.dp
@@ -66,10 +67,19 @@ fun EmptyState(message: String, modifier: Modifier = Modifier) {
/** Renders a labelled key/value row used across detail screens. */
@Composable
fun KeyValueRow(label: String, value: String, modifier: Modifier = Modifier) {
fun KeyValueRow(
label: String,
value: String,
modifier: Modifier = Modifier,
monospace: Boolean = false,
) {
if (value.isBlank()) return
Column(modifier = modifier.fillMaxWidth().padding(vertical = 4.dp)) {
Text(label, style = MaterialTheme.typography.labelMedium, color = MaterialTheme.colorScheme.primary)
Text(value, style = MaterialTheme.typography.bodyMedium)
Text(
value,
style = MaterialTheme.typography.bodyMedium,
fontFamily = if (monospace) FontFamily.Monospace else null,
)
}
}
@@ -51,7 +51,7 @@ import net.awan.pipelines.data.protocol.Protocol
import net.awan.pipelines.data.protocol.RunGraphState
import net.awan.pipelines.data.protocol.edges
private data class NodeLayout(
internal data class NodeLayout(
val key: String,
val label: String,
val x: Float,
@@ -61,11 +61,16 @@ private data class NodeLayout(
val terminal: Boolean,
)
private data class EdgeLayout(
internal data class EdgeLayout(
val edge: GraphEdge,
val from: Offset,
val to: Offset,
val backEdge: Boolean,
// Terminals sit on a lower row and receive arrows entering their top border,
// while an error->#failure route drops out of its source's bottom, mirroring
// tui.graphEdge.topEntry/bottomExit.
val topEntry: Boolean,
val bottomExit: Boolean,
val sourceRank: Int,
val targetRank: Int,
// Index of this edge among the outgoing edges of its source plus how many
@@ -74,7 +79,7 @@ private data class EdgeLayout(
val labelCount: Int,
)
private data class GraphLayout(
internal data class GraphLayout(
val nodes: List<NodeLayout>,
val edges: List<EdgeLayout>,
val width: Float,
@@ -126,6 +131,7 @@ fun WorkflowGraph(
nodeBorder = scheme.outline,
nodeText = scheme.onSurface,
terminalFill = scheme.secondaryContainer,
terminalErrorFill = scheme.errorContainer,
labelBackground = scheme.surface,
labelText = scheme.onSurfaceVariant,
)
@@ -225,6 +231,7 @@ private class GraphColors(
val nodeBorder: Color,
val nodeText: Color,
val terminalFill: Color,
val terminalErrorFill: Color,
val labelBackground: Color,
val labelText: Color,
)
@@ -267,65 +274,62 @@ internal fun clampOffset(offset: Offset, content: Size, viewport: Size, minVisib
return Offset(x, y)
}
private fun layoutGraph(graph: Graph, density: androidx.compose.ui.unit.Density): GraphLayout {
internal fun layoutGraph(graph: Graph, density: androidx.compose.ui.unit.Density): GraphLayout {
if (graph.stages.isEmpty()) return GraphLayout(emptyList(), emptyList(), 0f, 0f)
val nodeWidth = with(density) { 132.dp.toPx() }
val nodeHeight = with(density) { 56.dp.toPx() }
val hGap = with(density) { 88.dp.toPx() }
val vGap = with(density) { 28.dp.toPx() }
val pad = with(density) { 32.dp.toPx() }
val terminalRowGap = with(density) { 72.dp.toPx() }
val ranks = rankStages(graph)
val maxRank = ranks.values.maxOrNull() ?: 0
val terminalRank = maxRank + 1
val columns = HashMap<Int, MutableList<String>>()
for (stage in graph.stages) {
val rank = ranks[stage.key] ?: 0
columns.getOrPut(rank) { mutableListOf() } += stage.key
}
val terminalKeys = mutableListOf<String>()
if (graph.stages.any { stage -> stage.edges.values.any { Protocol.isTerminal(it) || it == "#" } }) {
terminalKeys += Protocol.SUCCESS_END
terminalKeys += Protocol.FAILURE_END
val hasTerminal = graph.stages.any { stage ->
stage.edges.values.any { Protocol.isTerminal(it) || it == "#" }
}
val columnHeights = HashMap<Int, Float>()
for ((rank, keys) in columns) {
columnHeights[rank] = keys.size * nodeHeight + (keys.size - 1).coerceAtLeast(0) * vGap
}
columnHeights[terminalRank] = terminalKeys.size * nodeHeight + (terminalKeys.size - 1).coerceAtLeast(0) * vGap
val tallest = columnHeights.values.maxOrNull() ?: nodeHeight
// Stages occupy a single top row in declaration order, exactly like
// tui.layoutSingleRowGraph: x grows with the declared stage index and every
// stage shares the same y.
val positions = HashMap<String, NodeLayout>()
val sortedRanks = columns.keys.sorted()
for ((columnIndex, rank) in sortedRanks.withIndex()) {
val keys = columns.getValue(rank)
val columnHeight = columnHeights.getValue(rank)
var y = (tallest - columnHeight) / 2f
val x = pad + columnIndex * (nodeWidth + hGap)
for (key in keys) {
positions[key] = NodeLayout(
key = key,
label = GraphSemantics.nodeLabel(key),
x = x,
y = y,
width = nodeWidth,
height = nodeHeight,
terminal = false,
)
y += nodeHeight + vGap
}
graph.stages.forEachIndexed { index, stage ->
positions[stage.key] = NodeLayout(
key = stage.key,
label = GraphSemantics.nodeLabel(stage.key),
x = pad + index * (nodeWidth + hGap),
y = pad,
width = nodeWidth,
height = nodeHeight,
terminal = false,
)
}
terminalKeys.forEachIndexed { index, key ->
val columnHeight = columnHeights.getValue(terminalRank)
val x = pad + sortedRanks.size * (nodeWidth + hGap)
val y = (tallest - columnHeight) / 2f + index * (nodeHeight + vGap)
positions[key] = NodeLayout(
key = key,
label = GraphSemantics.nodeLabel(key),
x = x,
y = y,
val stageRowInner = graph.stages.size * nodeWidth +
(graph.stages.size - 1).coerceAtLeast(0) * hGap
val terminalPairInner = 2 * nodeWidth + hGap
val contentInner = if (hasTerminal) maxOf(stageRowInner, terminalPairInner) else stageRowInner
val width = pad * 2 + contentInner
if (hasTerminal) {
// Both terminals share one lower row, FAILURE left of SUCCESS, the pair
// centred on the content width, so incoming arrows enter their top border.
val terminalY = pad + nodeHeight + terminalRowGap
val failureX = pad + (contentInner - terminalPairInner) / 2f
val successX = failureX + nodeWidth + hGap
positions[Protocol.FAILURE_END] = NodeLayout(
key = Protocol.FAILURE_END,
label = GraphSemantics.nodeLabel(Protocol.FAILURE_END),
x = failureX,
y = terminalY,
width = nodeWidth,
height = nodeHeight,
terminal = true,
)
positions[Protocol.SUCCESS_END] = NodeLayout(
key = Protocol.SUCCESS_END,
label = GraphSemantics.nodeLabel(Protocol.SUCCESS_END),
x = successX,
y = terminalY,
width = nodeWidth,
height = nodeHeight,
terminal = true,
@@ -339,14 +343,26 @@ private fun layoutGraph(graph: Graph, density: androidx.compose.ui.unit.Density)
val source = positions[edge.source] ?: return@mapNotNull null
val target = positions[edge.target] ?: return@mapNotNull null
val sourceRank = ranks[edge.source] ?: 0
val targetRank = if (Protocol.isTerminal(edge.target)) terminalRank else (ranks[edge.target] ?: 0)
val targetIsTerminal = Protocol.isTerminal(edge.target)
val targetRank = if (targetIsTerminal) graph.stages.size else (ranks[edge.target] ?: 0)
val bottomExit = edge.outcome == "error" && edge.target == Protocol.FAILURE_END
val labelSlot = slotsBySource.getOrDefault(edge.source, 0)
slotsBySource[edge.source] = labelSlot + 1
EdgeLayout(
edge = edge,
from = Offset(source.x + source.width, source.y + source.height / 2f),
to = Offset(target.x, target.y + target.height / 2f),
backEdge = targetRank <= sourceRank,
from = if (bottomExit) {
Offset(source.x + source.width / 2f, source.y + source.height)
} else {
Offset(source.x + source.width, source.y + source.height / 2f)
},
to = if (targetIsTerminal) {
Offset(target.x + target.width / 2f, target.y)
} else {
Offset(target.x, target.y + target.height / 2f)
},
backEdge = !targetIsTerminal && targetRank <= sourceRank,
topEntry = targetIsTerminal,
bottomExit = bottomExit,
sourceRank = sourceRank,
targetRank = targetRank,
labelSlot = labelSlot,
@@ -354,8 +370,7 @@ private fun layoutGraph(graph: Graph, density: androidx.compose.ui.unit.Density)
)
}
val width = pad * 2 + (sortedRanks.size + 1) * nodeWidth + sortedRanks.size * hGap
val height = pad * 2 + tallest
val height = pad * 2 + nodeHeight + (if (hasTerminal) terminalRowGap + nodeHeight else 0f)
return GraphLayout(positions.values.toList(), edgeLayouts, width, height)
}
@@ -383,12 +398,29 @@ private fun DrawScope.drawEdgePaths(
val alpha = if (executed) 1f else 0.25f
val path = Path()
path.moveTo(edge.from.x, edge.from.y)
if (edge.backEdge) {
val dip = maxOf(edge.from.y, edge.to.y) + 64f
path.cubicTo(edge.from.x + 24f, dip, edge.to.x - 24f, dip, edge.to.x, edge.to.y)
} else {
val midX = (edge.from.x + edge.to.x) / 2f
path.cubicTo(midX, edge.from.y, midX, edge.to.y, edge.to.x, edge.to.y)
when {
// An error->#failure route drops out of the source bottom, runs down
// and across, then rises into the terminal top border.
edge.bottomExit -> {
val approachY = edge.to.y - BOTTOM_EXIT_APPROACH
path.lineTo(edge.from.x, approachY)
path.lineTo(edge.to.x, approachY)
path.lineTo(edge.to.x, edge.to.y)
}
// Terminal edges leave the source's right edge and curve down/right
// into the terminal's top border.
edge.topEntry -> {
val midX = (edge.from.x + edge.to.x) / 2f
path.cubicTo(midX, edge.from.y, midX, edge.to.y, edge.to.x, edge.to.y)
}
edge.backEdge -> {
val dip = maxOf(edge.from.y, edge.to.y) + BACK_EDGE_DIP
path.cubicTo(edge.from.x + 24f, dip, edge.to.x - 24f, dip, edge.to.x, edge.to.y)
}
else -> {
val midX = (edge.from.x + edge.to.x) / 2f
path.cubicTo(midX, edge.from.y, midX, edge.to.y, edge.to.x, edge.to.y)
}
}
drawPath(path, color = color.copy(alpha = alpha), style = Stroke(width = 3f))
drawArrowHead(edge.from, edge.to, color.copy(alpha = alpha))
@@ -469,12 +501,15 @@ private fun DrawScope.drawNodes(
val executed = runState == null || node.key in runState.visitedStages
val selected = node.key == selectedStage
val alpha = if (executed) 1f else 0.3f
val failureTerminal = node.key == Protocol.FAILURE_END
val fill = when {
node.terminal && failureTerminal -> colors.terminalErrorFill
node.terminal -> colors.terminalFill
selected -> colors.nodeFillActive
else -> colors.nodeFill
}.copy(alpha = alpha)
val border = when {
node.terminal && failureTerminal -> colors.error
node.terminal -> colors.success
else -> colors.nodeBorder
}.copy(alpha = alpha)
@@ -552,6 +587,12 @@ private fun graphDescription(graph: Graph, runState: RunGraphState?): String {
private const val MIN_SCALE = 0.3f
private const val MAX_SCALE = 3f
/** How far below the stage row a loop route dips before curving back. */
private const val BACK_EDGE_DIP = 64f
/** How far above a terminal's top border the bottom-exit route levels off. */
private const val BOTTOM_EXIT_APPROACH = 32f
/** Breathing room left around a fitted graph, and the least content kept visible. */
private val FIT_PADDING = 16.dp
private val MIN_VISIBLE = 48.dp
@@ -120,7 +120,7 @@ private fun PipelineDetailContent(detail: PipelineDetail, modifier: Modifier = M
"id ${detail.id} · v${detail.version} · ${detail.graph.stages.size} stages",
style = MaterialTheme.typography.bodyMedium,
)
KeyValueRow("Content hash", detail.contentHash)
KeyValueRow("Content hash", detail.contentHash, monospace = true)
KeyValueRow("Latest version", if (detail.latestVersion > 0) "v${detail.latestVersion}" else "")
KeyValueRow("Version created", detail.versionCreatedAt)
KeyValueRow("Pipeline created", detail.createdAt)
@@ -223,7 +223,7 @@ private fun RunDetailContent(
)
KeyValueRow("Pipeline", "id ${run.pipelineId} · v${run.version}")
KeyValueRow("Workspace", run.workspace)
KeyValueRow("Content hash", run.contentHash)
KeyValueRow("Content hash", run.contentHash, monospace = true)
KeyValueRow("Started", run.createdAt)
KeyValueRow("Finished", run.finishedAt)
KeyValueRow("Duration", formatDuration(run.createdAt, run.finishedAt) ?: "")
@@ -13,10 +13,13 @@ import androidx.compose.material3.Button
import androidx.compose.material3.Card
import androidx.compose.material3.CardDefaults
import androidx.compose.material3.CircularProgressIndicator
import androidx.compose.material3.ExperimentalMaterial3Api
import androidx.compose.material3.MaterialTheme
import androidx.compose.material3.OutlinedButton
import androidx.compose.material3.OutlinedTextField
import androidx.compose.material3.Scaffold
import androidx.compose.material3.Text
import androidx.compose.material3.TopAppBar
import androidx.compose.runtime.Composable
import androidx.compose.runtime.getValue
import androidx.compose.ui.Modifier
@@ -26,6 +29,7 @@ import androidx.lifecycle.compose.collectAsStateWithLifecycle
import net.awan.pipelines.data.transport.ConnectionState
import net.awan.pipelines.ui.AppViewModel
@OptIn(ExperimentalMaterial3Api::class)
@Composable
fun SettingsScreen(vm: AppViewModel, modifier: Modifier = Modifier) {
val serverUrl by vm.serverUrlDraft.collectAsStateWithLifecycle()
@@ -37,18 +41,62 @@ fun SettingsScreen(vm: AppViewModel, modifier: Modifier = Modifier) {
val configuredWorkspace by vm.configuredWorkspace.collectAsStateWithLifecycle()
val workspaceError by vm.workspaceError.collectAsStateWithLifecycle()
Scaffold(
modifier = modifier,
topBar = { TopAppBar(title = { Text("Settings") }) },
) { padding ->
SettingsContent(
padding = Modifier.padding(padding),
serverUrl = serverUrl,
onServerUrlChange = vm::updateServerUrlDraft,
urlError = urlError,
state = state,
buildVersion = build?.version,
buildCommit = build?.commit,
serverTime = serverTime,
workspace = workspace,
onWorkspaceChange = vm::updateWorkspaceDraft,
workspaceError = workspaceError,
configuredWorkspace = configuredWorkspace,
onConnect = vm::connect,
onDisconnect = vm::disconnect,
onReconnect = vm::reconnect,
onSaveWorkspace = vm::saveWorkspace,
)
}
}
@Composable
private fun SettingsContent(
padding: Modifier,
serverUrl: String,
onServerUrlChange: (String) -> Unit,
urlError: String?,
state: ConnectionState,
buildVersion: String?,
buildCommit: String?,
serverTime: String?,
workspace: String,
onWorkspaceChange: (String) -> Unit,
workspaceError: String?,
configuredWorkspace: String,
onConnect: () -> Unit,
onDisconnect: () -> Unit,
onReconnect: () -> Unit,
onSaveWorkspace: () -> Unit,
) {
Column(
modifier = modifier
modifier = padding
.fillMaxSize()
.verticalScroll(rememberScrollState())
.padding(16.dp),
verticalArrangement = Arrangement.spacedBy(12.dp),
) {
Text("Connection", style = MaterialTheme.typography.headlineSmall)
Text("Connection", style = MaterialTheme.typography.titleMedium)
OutlinedTextField(
value = serverUrl,
onValueChange = vm::updateServerUrlDraft,
onValueChange = onServerUrlChange,
label = { Text("Server URL") },
placeholder = { Text("ws://192.168.1.20:8081/connect") },
singleLine = true,
@@ -61,15 +109,15 @@ fun SettingsScreen(vm: AppViewModel, modifier: Modifier = Modifier) {
)
Row(horizontalArrangement = Arrangement.spacedBy(8.dp)) {
Button(onClick = vm::connect) { Text("Connect") }
Button(onClick = onConnect) { Text("Connect") }
if (state is ConnectionState.Connected || state is ConnectionState.Connecting) {
OutlinedButton(onClick = vm::disconnect) { Text("Disconnect") }
OutlinedButton(onClick = onDisconnect) { Text("Disconnect") }
} else {
OutlinedButton(onClick = vm::reconnect) { Text("Reconnect") }
OutlinedButton(onClick = onReconnect) { Text("Reconnect") }
}
}
ConnectionStatusCard(state, build?.version, build?.commit, serverTime)
ConnectionStatusCard(state, buildVersion, buildCommit, serverTime)
Card(colors = CardDefaults.cardColors(containerColor = MaterialTheme.colorScheme.errorContainer)) {
Text(
@@ -82,11 +130,11 @@ fun SettingsScreen(vm: AppViewModel, modifier: Modifier = Modifier) {
)
}
Text("Workspace", style = MaterialTheme.typography.headlineSmall)
Text("Workspace", style = MaterialTheme.typography.titleMedium)
OutlinedTextField(
value = workspace,
onValueChange = vm::updateWorkspaceDraft,
onValueChange = onWorkspaceChange,
label = { Text("Workspace path (on the server)") },
placeholder = { Text("/Users/you/repos/pipelines") },
singleLine = true,
@@ -101,7 +149,7 @@ fun SettingsScreen(vm: AppViewModel, modifier: Modifier = Modifier) {
},
modifier = Modifier.fillMaxWidth(),
)
Button(onClick = vm::saveWorkspace, enabled = workspaceError == null) { Text("Save workspace") }
Button(onClick = onSaveWorkspace, enabled = workspaceError == null) { Text("Save workspace") }
Text("Saved workspace: ${configuredWorkspace.ifBlank { "(none)" }}")
}
}
@@ -0,0 +1,81 @@
package net.awan.pipelines.ui.theme
import androidx.compose.ui.graphics.Color
/**
* The app's own colour identity, deliberately dark-first so it matches the dark
* Pipelines TUI instead of the device wallpaper. The brand leans on a cool
* mint/teal seed with an amber tertiary, which also gives the workflow graph a
* clear success (tertiary) vs failure (error) distinction.
*
* Every on-colour is chosen for high contrast against its paired container in
* its own scheme, so text stays legible in both appearances.
*/
// Dark scheme roles.
internal val DarkPrimary = Color(0xFF6FD3B8)
internal val DarkOnPrimary = Color(0xFF00382E)
internal val DarkPrimaryContainer = Color(0xFF005143)
internal val DarkOnPrimaryContainer = Color(0xFF8BF0D4)
internal val DarkSecondary = Color(0xFF7FC8D8)
internal val DarkOnSecondary = Color(0xFF00363F)
internal val DarkSecondaryContainer = Color(0xFF064E5A)
internal val DarkOnSecondaryContainer = Color(0xFFA9E9F5)
internal val DarkTertiary = Color(0xFFF2C879)
internal val DarkOnTertiary = Color(0xFF3F2E00)
internal val DarkTertiaryContainer = Color(0xFF5B4300)
internal val DarkOnTertiaryContainer = Color(0xFFFFE0A3)
internal val DarkError = Color(0xFFFFB4AB)
internal val DarkOnError = Color(0xFF690005)
internal val DarkErrorContainer = Color(0xFF93000A)
internal val DarkOnErrorContainer = Color(0xFFFFDAD6)
internal val DarkBackground = Color(0xFF0E1513)
internal val DarkOnBackground = Color(0xFFDEE4E1)
internal val DarkSurface = Color(0xFF0E1513)
internal val DarkOnSurface = Color(0xFFDEE4E1)
internal val DarkSurfaceVariant = Color(0xFF3F4946)
internal val DarkOnSurfaceVariant = Color(0xFFBEC9C5)
internal val DarkOutline = Color(0xFF889391)
internal val DarkOutlineVariant = Color(0xFF3F4946)
internal val DarkInverseSurface = Color(0xFFDEE4E1)
internal val DarkInverseOnSurface = Color(0xFF2B3230)
internal val DarkScrim = Color(0xFF000000)
internal val DarkSurfaceContainerLowest = Color(0xFF090F0E)
internal val DarkSurfaceContainerLow = Color(0xFF161D1B)
internal val DarkSurfaceContainer = Color(0xFF1A211F)
internal val DarkSurfaceContainerHigh = Color(0xFF252C2A)
internal val DarkSurfaceContainerHighest = Color(0xFF2F3634)
// Light scheme roles.
internal val LightPrimary = Color(0xFF006B5B)
internal val LightOnPrimary = Color(0xFFFFFFFF)
internal val LightPrimaryContainer = Color(0xFF74F8DD)
internal val LightOnPrimaryContainer = Color(0xFF00201A)
internal val LightSecondary = Color(0xFF4A6368)
internal val LightOnSecondary = Color(0xFFFFFFFF)
internal val LightSecondaryContainer = Color(0xFFCCE8EF)
internal val LightOnSecondaryContainer = Color(0xFF051F23)
internal val LightTertiary = Color(0xFF7A5900)
internal val LightOnTertiary = Color(0xFFFFFFFF)
internal val LightTertiaryContainer = Color(0xFFFFDF9E)
internal val LightOnTertiaryContainer = Color(0xFF261A00)
internal val LightError = Color(0xFFBA1A1A)
internal val LightOnError = Color(0xFFFFFFFF)
internal val LightErrorContainer = Color(0xFFFFDAD6)
internal val LightOnErrorContainer = Color(0xFF410002)
internal val LightBackground = Color(0xFFF5FBF8)
internal val LightOnBackground = Color(0xFF171D1B)
internal val LightSurface = Color(0xFFF5FBF8)
internal val LightOnSurface = Color(0xFF171D1B)
internal val LightSurfaceVariant = Color(0xFFDAE5E1)
internal val LightOnSurfaceVariant = Color(0xFF3F4946)
internal val LightOutline = Color(0xFF6F7976)
internal val LightOutlineVariant = Color(0xFFBEC9C5)
internal val LightInverseSurface = Color(0xFF2B3230)
internal val LightInverseOnSurface = Color(0xFFECF2EF)
internal val LightScrim = Color(0xFF000000)
internal val LightSurfaceContainerLowest = Color(0xFFFFFFFF)
internal val LightSurfaceContainerLow = Color(0xFFEFF5F2)
internal val LightSurfaceContainer = Color(0xFFE9EFEC)
internal val LightSurfaceContainerHigh = Color(0xFFE3EAE7)
internal val LightSurfaceContainerHighest = Color(0xFFDDE4E1)
@@ -1,29 +1,93 @@
package net.awan.pipelines.ui.theme
import android.os.Build
import androidx.compose.foundation.isSystemInDarkTheme
import androidx.compose.material3.MaterialTheme
import androidx.compose.material3.darkColorScheme
import androidx.compose.material3.dynamicDarkColorScheme
import androidx.compose.material3.dynamicLightColorScheme
import androidx.compose.material3.lightColorScheme
import androidx.compose.runtime.Composable
import androidx.compose.ui.platform.LocalContext
/** Material 3 theming with optional dynamic color and dark-mode support. */
/**
* Material 3 theming. Dark is the default appearance so the app matches the dark
* Pipelines TUI on launch; the light scheme is retained for when it is
* explicitly requested. Dynamic (wallpaper) colour is deliberately not used so
* the app keeps its own identity.
*/
@Composable
fun PipelinesTheme(
darkTheme: Boolean = isSystemInDarkTheme(),
dynamicColor: Boolean = true,
darkTheme: Boolean = true,
content: @Composable () -> Unit,
) {
val context = LocalContext.current
val colorScheme = when {
dynamicColor && Build.VERSION.SDK_INT >= Build.VERSION_CODES.S -> {
if (darkTheme) dynamicDarkColorScheme(context) else dynamicLightColorScheme(context)
}
darkTheme -> darkColorScheme()
else -> lightColorScheme()
}
MaterialTheme(colorScheme = colorScheme, content = content)
MaterialTheme(
colorScheme = if (darkTheme) PipelinesDarkColors else PipelinesLightColors,
content = content,
)
}
internal val PipelinesDarkColors = darkColorScheme(
primary = DarkPrimary,
onPrimary = DarkOnPrimary,
primaryContainer = DarkPrimaryContainer,
onPrimaryContainer = DarkOnPrimaryContainer,
secondary = DarkSecondary,
onSecondary = DarkOnSecondary,
secondaryContainer = DarkSecondaryContainer,
onSecondaryContainer = DarkOnSecondaryContainer,
tertiary = DarkTertiary,
onTertiary = DarkOnTertiary,
tertiaryContainer = DarkTertiaryContainer,
onTertiaryContainer = DarkOnTertiaryContainer,
error = DarkError,
onError = DarkOnError,
errorContainer = DarkErrorContainer,
onErrorContainer = DarkOnErrorContainer,
background = DarkBackground,
onBackground = DarkOnBackground,
surface = DarkSurface,
onSurface = DarkOnSurface,
surfaceVariant = DarkSurfaceVariant,
onSurfaceVariant = DarkOnSurfaceVariant,
outline = DarkOutline,
outlineVariant = DarkOutlineVariant,
inverseSurface = DarkInverseSurface,
inverseOnSurface = DarkInverseOnSurface,
scrim = DarkScrim,
surfaceContainerLowest = DarkSurfaceContainerLowest,
surfaceContainerLow = DarkSurfaceContainerLow,
surfaceContainer = DarkSurfaceContainer,
surfaceContainerHigh = DarkSurfaceContainerHigh,
surfaceContainerHighest = DarkSurfaceContainerHighest,
)
internal val PipelinesLightColors = lightColorScheme(
primary = LightPrimary,
onPrimary = LightOnPrimary,
primaryContainer = LightPrimaryContainer,
onPrimaryContainer = LightOnPrimaryContainer,
secondary = LightSecondary,
onSecondary = LightOnSecondary,
secondaryContainer = LightSecondaryContainer,
onSecondaryContainer = LightOnSecondaryContainer,
tertiary = LightTertiary,
onTertiary = LightOnTertiary,
tertiaryContainer = LightTertiaryContainer,
onTertiaryContainer = LightOnTertiaryContainer,
error = LightError,
onError = LightOnError,
errorContainer = LightErrorContainer,
onErrorContainer = LightOnErrorContainer,
background = LightBackground,
onBackground = LightOnBackground,
surface = LightSurface,
onSurface = LightOnSurface,
surfaceVariant = LightSurfaceVariant,
onSurfaceVariant = LightOnSurfaceVariant,
outline = LightOutline,
outlineVariant = LightOutlineVariant,
inverseSurface = LightInverseSurface,
inverseOnSurface = LightInverseOnSurface,
scrim = LightScrim,
surfaceContainerLowest = LightSurfaceContainerLowest,
surfaceContainerLow = LightSurfaceContainerLow,
surfaceContainer = LightSurfaceContainer,
surfaceContainerHigh = LightSurfaceContainerHigh,
surfaceContainerHighest = LightSurfaceContainerHighest,
)
@@ -1,6 +1,12 @@
<?xml version="1.0" encoding="utf-8"?>
<resources>
<!-- Mirrors the default theme so night mode launches with the same dark
window background and bars; the app is dark-first by design. -->
<style name="Theme.Pipelines" parent="android:Theme.Material.NoActionBar">
<item name="android:windowBackground">@android:color/black</item>
<item name="android:windowBackground">@color/pipelines_window_background</item>
<item name="android:statusBarColor">@color/pipelines_window_background</item>
<item name="android:navigationBarColor">@color/pipelines_window_background</item>
<item name="android:windowLightStatusBar">false</item>
<item name="android:windowLightNavigationBar">false</item>
</style>
</resources>
@@ -0,0 +1,7 @@
<?xml version="1.0" encoding="utf-8"?>
<resources>
<!-- Brand dark surface, kept in sync with PipelinesDarkColors.surface so the
window background matches the Compose theme and there is no light flash
before the first frame is drawn. -->
<color name="pipelines_window_background">#0E1513</color>
</resources>
+10 -2
View File
@@ -1,6 +1,14 @@
<?xml version="1.0" encoding="utf-8"?>
<resources>
<style name="Theme.Pipelines" parent="android:Theme.Material.Light.NoActionBar">
<item name="android:windowBackground">@android:color/white</item>
<!-- The app owns its dark-first look: a dark window background and dark
system bars with light icons, regardless of the system setting, so
launching never shows a light flash. The app draws its own top app bar,
so NoActionBar is kept. -->
<style name="Theme.Pipelines" parent="android:Theme.Material.NoActionBar">
<item name="android:windowBackground">@color/pipelines_window_background</item>
<item name="android:statusBarColor">@color/pipelines_window_background</item>
<item name="android:navigationBarColor">@color/pipelines_window_background</item>
<item name="android:windowLightStatusBar">false</item>
<item name="android:windowLightNavigationBar">false</item>
</style>
</resources>
@@ -2,7 +2,9 @@ package net.awan.pipelines.ui.graph
import androidx.compose.ui.geometry.Offset
import androidx.compose.ui.geometry.Size
import androidx.compose.ui.unit.Density
import net.awan.pipelines.data.protocol.Graph
import net.awan.pipelines.data.protocol.Protocol
import net.awan.pipelines.data.protocol.Stage
import org.junit.Assert.assertEquals
import org.junit.Assert.assertTrue
@@ -12,6 +14,15 @@ class WorkflowGraphTest {
private fun stage(key: String, edges: Map<String, String>) = Stage(key = key, edges = edges)
private fun sampleGraph() = Graph(
stages = listOf(
stage("planner", mapOf("success" to "implementer", "error" to "#failure")),
stage("implementer", mapOf("success" to "reviewer", "blocked" to "#failure", "error" to "#failure")),
stage("reviewer", mapOf("success" to "ui_reviewer", "rejected" to "implementer", "error" to "#failure")),
stage("ui_reviewer", mapOf("approved" to "#success", "blocked" to "#failure", "rejected" to "implementer", "skipped" to "#success")),
),
)
/**
* Regression for the back-edge ordering defect: `reviewer rejected -> implementer`
* used to feed the longest-path relaxation and push `implementer` past
@@ -20,14 +31,7 @@ class WorkflowGraphTest {
*/
@Test
fun ranksFollowDeclarationOrderEvenWithBackEdges() {
val graph = Graph(
stages = listOf(
stage("planner", mapOf("success" to "implementer", "error" to "#failure")),
stage("implementer", mapOf("success" to "reviewer", "blocked" to "#failure", "error" to "#failure")),
stage("reviewer", mapOf("success" to "ui_reviewer", "rejected" to "implementer", "error" to "#failure")),
stage("ui_reviewer", mapOf("approved" to "#success", "blocked" to "#failure", "rejected" to "implementer", "skipped" to "#success")),
),
)
val graph = sampleGraph()
val ranks = rankStages(graph)
assertEquals(listOf("planner", "implementer", "reviewer", "ui_reviewer"), graph.stages.map { it.key })
assertEquals(0, ranks["planner"])
@@ -115,4 +119,72 @@ class WorkflowGraphTest {
assertEquals(Offset.Zero, clampOffset(Offset.Zero, Size(0f, 0f), viewport, 40f))
assertTrue(clampOffset(Offset(1f, 2f), content, Size(10f, 10f), 40f).x.isFinite())
}
@Test
fun terminalsShareALowerRowBelowEveryStage() {
val layout = layoutGraph(sampleGraph(), Density(1f))
val failure = layout.nodes.single { it.key == Protocol.FAILURE_END }
val success = layout.nodes.single { it.key == Protocol.SUCCESS_END }
assertEquals(failure.y, success.y, 0.001f)
assertTrue(layout.nodes.filterNot { it.terminal }
.all { failure.y > it.y + it.height })
}
@Test
fun failureTerminalIsLeftOfSuccess() {
val layout = layoutGraph(sampleGraph(), Density(1f))
val failure = layout.nodes.single { it.key == Protocol.FAILURE_END }
val success = layout.nodes.single { it.key == Protocol.SUCCESS_END }
assertTrue(failure.x < success.x)
}
@Test
fun successEdgesEnterTheTerminalTopFromTheSourceRightEdge() {
val layout = layoutGraph(sampleGraph(), Density(1f))
val success = layout.nodes.single { it.key == Protocol.SUCCESS_END }
val edge = layout.edges.first { it.edge.target == Protocol.SUCCESS_END }
val source = layout.nodes.single { it.key == edge.edge.source }
assertTrue(edge.topEntry)
assertTrue(!edge.bottomExit)
assertEquals(success.y, edge.to.y, 0.001f)
assertEquals(success.x + success.width / 2f, edge.to.x, 0.001f)
assertEquals(source.x + source.width, edge.from.x, 0.001f)
assertEquals(source.y + source.height / 2f, edge.from.y, 0.001f)
}
@Test
fun errorToFailureDropsOutOfTheSourceBottomIntoTheTerminalTop() {
val layout = layoutGraph(sampleGraph(), Density(1f))
val failure = layout.nodes.single { it.key == Protocol.FAILURE_END }
val planner = layout.nodes.single { it.key == "planner" }
val edge = layout.edges.first { it.edge.source == "planner" && it.edge.outcome == "error" }
assertTrue(edge.bottomExit)
assertTrue(edge.topEntry)
assertEquals(planner.y + planner.height, edge.from.y, 0.001f)
assertEquals(planner.x + planner.width / 2f, edge.from.x, 0.001f)
assertEquals(failure.x + failure.width / 2f, edge.to.x, 0.001f)
assertEquals(failure.y, edge.to.y, 0.001f)
}
@Test
fun backEdgesKeepTheirFlagAndDeclarationOrderX() {
val layout = layoutGraph(sampleGraph(), Density(1f))
val back = layout.edges.first { it.edge.source == "reviewer" && it.edge.outcome == "rejected" }
assertTrue(back.backEdge)
val reviewer = layout.nodes.single { it.key == "reviewer" }
val implementer = layout.nodes.single { it.key == "implementer" }
assertTrue(reviewer.x > implementer.x)
}
@Test
fun smallGraphsProduceFiniteNonNegativeExtents() {
val empty = layoutGraph(Graph(), Density(1f))
assertTrue(empty.width >= 0f && empty.height >= 0f)
assertTrue(empty.width.isFinite() && empty.height.isFinite())
val single = layoutGraph(Graph(stages = listOf(stage("only", emptyMap()))), Density(1f))
assertTrue(single.width > 0f && single.height > 0f)
assertTrue(single.width.isFinite() && single.height.isFinite())
assertTrue(single.nodes.single().terminal.not())
}
}