From 24584d820f16d38e8efc79fbc9675b7d5e64e5c4 Mon Sep 17 00:00:00 2001 From: Alan Silva Date: Fri, 16 Oct 2026 02:04:30 +0100 Subject: [PATCH 1/9] Give run status an app-owned palette with correct hues Run status was mapped onto Material roles, so a succeeded run read amber (tertiary) and a running run read mint (primary). Replace that mapping with an app-owned RunStatusPalette: Running/Active blue, Succeeded green, Failed the app error red, Interrupted amber, Canceled muted grey, Queued neutral grey and Unknown a low-key surface grey, each with a one-line rationale. runStateColor is now a pure lookup over the palette. Keep each state's distinct material glyph and text label so status is never colour-only, and add a WCAG-AA contrast test for every status colour against the dark surface plus hue-specific assertions. Leave the graph's stage-outcome palette untouched. The timeline's step chips are a stage outcome, not a run status, so point them at the shared graphColors/ outcomeColor factory (extracted from WorkflowGraph) to agree with the graph, and factor the shared ColoredChip pill out of StatusChip so neither repeats the layout. Document the change and its evidence in android/README.md. --- android/README.md | 78 +++++++++++++++++++ .../awan/pipelines/ui/components/RunStatus.kt | 52 +++++++++---- .../ui/components/RunStatusPalette.kt | 70 +++++++++++++++++ .../awan/pipelines/ui/graph/WorkflowGraph.kt | 60 +++++++------- .../pipelines/ui/screens/RunDetailScreen.kt | 14 +++- .../ui/components/RunStatusPaletteTest.kt | 73 +++++++++++++++++ 6 files changed, 305 insertions(+), 42 deletions(-) create mode 100644 android/app/src/main/java/net/awan/pipelines/ui/components/RunStatusPalette.kt create mode 100644 android/app/src/test/java/net/awan/pipelines/ui/components/RunStatusPaletteTest.kt diff --git a/android/README.md b/android/README.md index 49c9221e..5a65597a 100644 --- a/android/README.md +++ b/android/README.md @@ -1268,3 +1268,81 @@ has exactly three pane levels (`MasterPane.List/Detail/Stage`, `MAX_PANE_DEPTH = `SlidingPaneStackTest` cases instead; a long covered detail title wraps to three centred lines and ellipsizes (e.g. `Pipelines maintenance - plan implem…`) rather than being rotated. + +## An app-owned run-status palette (16 Oct 2026) + +Run status had the wrong hue for its two most important states because it was +mapped onto Material roles: `primary` (mint) made a **running** run read green and +`tertiary` (amber) made a **succeeded** run read yellow. `android/` only; nothing +in the Pipelines server, its Go source, the Docker/compose files or the installer +was touched, no dependency was added, no run was started from the app, and the +attached Pixel 10 Pro Fold was never installed on or driven (every `adb`/emulator +command targeted `emulator-5556`; lane A's `emulator-5554` was not used). + +- **A new app-owned palette.** `ui/components/RunStatusPalette.kt` defines one + `Entry(colour, rationale)` per status, fixed (not scheme-derived) so a status + reads the same on every device, with a one-line reason each: Running/Active + blue, Succeeded green, Failed the app error red, Interrupted amber, Canceled + muted grey, Queued neutral grey, Unknown the low-key surface grey. + `runStateColor` is now a pure function over this palette (no `MaterialTheme`), so + it is asserted in a plain JVM test. Each state keeps its distinct material glyph + and text label, so status is never colour alone. +- **The graph outcome palette is unchanged.** `GraphPalette` and the terminal + `success`/`error` roles are untouched; run status and stage outcome stay + different vocabularies. The runs-list **Timeline** step chips (and their leading + glyphs) previously rendered through `runStateOf`/`StatusChip`, i.e. the run-status + mapping, so they were pointed at the graph's outcome palette instead: they now + call the shared `graphColors(scheme)` factory (extracted from `WorkflowGraph`, + which uses it too) and `outcomeColor`, so a step chip agrees with the graph. + The run header and runs-list cards keep the run-status palette. +- **Shared helper.** `ui/components/RunStatus.kt` gained `ColoredChip(label, + colour, icon, …)` — the single pill layout now used by both `StatusChip` (run + status) and the Timeline's outcome chip, instead of a second copy. + +Evidence (macOS, JDK 17 from Homebrew `openjdk@17`, Gradle 8.11.1, +`ANDROID_HOME=/Users/alan/Library/Android/sdk`, `ANDROID_SDK_ROOT` set, +`--offline`): + +- `gradle :app:testDebugUnitTest` reported **143 tests, 0 failures, 0 errors** + (new `RunStatusPaletteTest`: WCAG-AA contrast ≥ 4.5:1 for every status colour + against `DarkSurface 0xFF0E1513`, Succeeded green and ≠ `DarkTertiary`, Running/ + Active blue and ≠ `DarkPrimary`, Failed = `DarkError`, Interrupted amber and ≠ + Failed, Queued near-grey and ≠ Running, and a non-blank rationale per status). + `gradle :app:assembleDebug` succeeded (18,009,527-byte debug APK, sha256 + `17f52f23e40f4ba0c524ac2929adfd6a8f39353e68ccdeedb2e029019225e350`). +- On `emulator-5556` (`FoldB_API_36`, 2208x1840, density 420) in dark mode + (`adb shell cmd uimode night yes`) against the live server + `ws://10.0.2.2:8080/connect`, driven with `adb shell input` and `uiautomator + dump`. Every capture below was written with `android/scripts/capture_png.sh -s + emulator-5556` (which names the SurfaceFlinger display id and validates the PNG + magic bytes), and a validated screenshot was pixel-sampled to read the rendered + colour back: + - **Before** (pre-change tree, `git stash` build): runs-list usage values were + Succeeded `#F2C879` (amber), Running card `#6FD3B8` (mint); a run header read + `#F2C879` (succeeded) and `#6FD3B8` (running) — the reported bug, `captures` in + `runs_list_before.png`, `run_header_before.png`, `run_header_running_before.png`. + - **After**: runs-list usage values were Succeeded `#7FE0A8` (green), Failed + `#FFB4AB` (error red), Canceled `#889391` (muted), Interrupted `#E8C06A` + (amber), Active `#7FB2F0` (blue); the running card was `#7FB2F0` and the + succeeded card `#7FE0A8` (`runs_list_after.png`). A run header read `#7FE0A8` + (succeeded) and `#7FB2F0` (running) (`run_header_after.png`, + `run_header_running_after.png`). + - **Timeline agrees with the graph**: before, a graph-only outcome still went + through the run-status mapping — an `approved` step chip sampled `#BEC9C5` + (the run-status `Unknown` grey). After, the `success` step chip sampled + `#F2C879` (the graph's tertiary terminal role) and the `approved` chip + `#C0A3F5` (`GraphPalette` index 5), both equal to the graph's `outcomeColor` + (`run_timeline_before.png`, `run_timeline_after.png`). + - `adb -s emulator-5556 logcat -d` contained 0 `FATAL EXCEPTION` / `E + AndroidRuntime` lines (the only app-matched lines were expected + `InputDispatcher … Consumer closed input channel` warnings from the + force-stop/reinstall). +- **APK publish.** `app/build/outputs/apk/debug/app-debug.apk` was copied to + `…/artifacts/69/1/pipelines-debug-wip-cd85f69.apk` (`cd85f69` = `git rev-parse + --short HEAD`); `shasum -a 256` matched. `curl -I + http://10.0.0.249:8080/artifacts/69/1/pipelines-debug-wip-cd85f69.apk` (LAN + address from `ipconfig getifaddr en0`) returned `HTTP/1.1 200 OK`, + `Content-Type: application/vnd.android.package-archive`, `Content-Length: + 18009527`; a streamed `GET | shasum -a 256` equalled the local file. At 17.2 MiB + it exceeds the server's 8 MiB per-file inventory cap, so it is served by direct + URL only. diff --git a/android/app/src/main/java/net/awan/pipelines/ui/components/RunStatus.kt b/android/app/src/main/java/net/awan/pipelines/ui/components/RunStatus.kt index 2c4a6920..e9259d18 100644 --- a/android/app/src/main/java/net/awan/pipelines/ui/components/RunStatus.kt +++ b/android/app/src/main/java/net/awan/pipelines/ui/components/RunStatus.kt @@ -16,7 +16,6 @@ import androidx.compose.material.icons.filled.Error import androidx.compose.material.icons.filled.PauseCircle import androidx.compose.material.icons.filled.Schedule import androidx.compose.material3.Icon -import androidx.compose.material3.MaterialTheme import androidx.compose.material3.Text import androidx.compose.runtime.Composable import androidx.compose.ui.Alignment @@ -63,15 +62,12 @@ fun runStateOf(status: String): RunState = when (status.trim().lowercase()) { else -> RunState.Unknown } -/** Colour family for a state, sourced from the app-owned scheme (never colour-only). */ -@Composable -fun runStateColor(state: RunState): Color = when (state) { - RunState.Running, RunState.Active -> MaterialTheme.colorScheme.primary - RunState.Queued -> MaterialTheme.colorScheme.secondary - RunState.Succeeded -> MaterialTheme.colorScheme.tertiary - RunState.Failed, RunState.Interrupted -> MaterialTheme.colorScheme.error - RunState.Canceled, RunState.Unknown -> MaterialTheme.colorScheme.onSurfaceVariant -} +/** + * Colour family for a state, from the app-owned [RunStatusPalette] (never + * colour-only: every chip also carries its glyph and label). Pure, so it can be + * asserted in a plain JVM unit test. + */ +fun runStateColor(state: RunState): Color = RunStatusPalette.of(state).color /** A distinct glyph per state, all from the standard filled material icon set. */ fun runStateIcon(state: RunState): ImageVector = when (state) { @@ -106,14 +102,20 @@ fun RunStatusIcon( ) } -/** A colour-coded chip pairing a state glyph with its text label. */ +/** + * A pill pairing a glyph with its text label, coloured by the caller. Shared by + * the run-status chip and the timeline's step-outcome chip so both render one + * shape and neither repeats the layout. The glyph always carries a + * [contentDescription], so state/outcome is never colour alone. + */ @Composable -fun StatusChip( +internal fun ColoredChip( label: String, - state: RunState, + color: Color, + icon: ImageVector, + contentDescription: String? = label, modifier: Modifier = Modifier, ) { - val color = runStateColor(state) Row( modifier = modifier .clip(RoundedCornerShape(50)) @@ -122,7 +124,12 @@ fun StatusChip( verticalAlignment = Alignment.CenterVertically, horizontalArrangement = Arrangement.spacedBy(4.dp), ) { - RunStatusIcon(state, contentDescription = label, modifier = Modifier.size(14.dp), tint = color) + Icon( + imageVector = icon, + contentDescription = contentDescription, + tint = color, + modifier = Modifier.size(14.dp), + ) Text( text = label, color = color, @@ -132,6 +139,21 @@ fun StatusChip( } } +/** A colour-coded chip pairing a state glyph with its text label. */ +@Composable +fun StatusChip( + label: String, + state: RunState, + modifier: Modifier = Modifier, +) { + ColoredChip( + label = label, + color = runStateColor(state), + icon = runStateIcon(state), + modifier = modifier, + ) +} + /** Convenience: the run's own status word plus its colour-coded chip. */ @Composable fun RunStatusChip(state: RunState, modifier: Modifier = Modifier) { diff --git a/android/app/src/main/java/net/awan/pipelines/ui/components/RunStatusPalette.kt b/android/app/src/main/java/net/awan/pipelines/ui/components/RunStatusPalette.kt new file mode 100644 index 00000000..5c6d973b --- /dev/null +++ b/android/app/src/main/java/net/awan/pipelines/ui/components/RunStatusPalette.kt @@ -0,0 +1,70 @@ +package net.awan.pipelines.ui.components + +import androidx.compose.ui.graphics.Color +import net.awan.pipelines.ui.theme.DarkError + +/** + * The app-owned run-status palette. + * + * Run status is a *different vocabulary* from the graph's stage outcomes + * ([net.awan.pipelines.ui.graph.GraphPalette]): a run that is `running` is not a + * `skipped` stage, and a `succeeded` run is not the amber the theme uses for a + * positive *stage* outcome. Borrowing Material roles therefore put the wrong hue + * on the two states that matter most — `primary` (mint) made a *running* run read + * green and `tertiary` (amber) made a *succeeded* run read yellow. + * + * Every entry below is instead a deliberate, fixed colour with an explicit + * meaning, tuned for the dark Pipelines surface (`DarkSurface 0xFF0E1513`, + * over which the chip label is drawn). The contrast of each colour against that + * surface is *measured* by `RunStatusPaletteTest`, never judged by eye. Status is + * never colour-only: every entry keeps its own material glyph ([runStateIcon]) + * and its text label ([RunState.label]). + */ +internal object RunStatusPalette { + + /** One status colour plus the one-line reason it is that hue. */ + data class Entry(val color: Color, val rationale: String) + + /** In progress: the conventional blue. Green would read as already finished. */ + private val Running = + Entry(Color(0xFF7FB2F0), "blue: in progress; green would read as already finished") + + /** Finished well: the conventional green. Amber/tertiary would read as a warning. */ + private val Succeeded = + Entry(Color(0xFF7FE0A8), "green: completed successfully; amber would read as a warning") + + /** Failure: the app's error red, the one alarm colour the scheme already owns. */ + private val Failed = + Entry(DarkError, "the app error red: an explicit failure, never a soft warning hue") + + /** Stopped by the operator mid-flight: amber, a warning that is not a failure. */ + private val Interrupted = + Entry(Color(0xFFE8C06A), "amber: stopped by the operator, a warning distinct from failure red") + + /** Operator-cancelled: muted grey so a deliberate stop is quiet, not alarming. */ + private val Canceled = + Entry(Color(0xFF889391), "muted grey: an operator cancel is quiet, not the failure red") + + /** Waiting to start: neutral grey, deliberately not a hue that reads as running. */ + private val Queued = + Entry(Color(0xFF9AA6A2), "neutral grey: waiting, clearly not the in-progress blue") + + /** Unknown/blank status: the safe, low-key fallback. */ + private val Unknown = + Entry(Color(0xFFBEC9C5), "neutral surface grey: an unrecognised status stays low-key") + + /** + * The entry for [state]. [RunState.Active] shares [Running] (it is the server's + * `active` usage bucket, i.e. work in progress). Pure, so the palette is + * unit-testable without the Compose runtime. + */ + fun of(state: RunState): Entry = when (state) { + RunState.Running, RunState.Active -> Running + RunState.Succeeded -> Succeeded + RunState.Failed -> Failed + RunState.Interrupted -> Interrupted + RunState.Canceled -> Canceled + RunState.Queued -> Queued + RunState.Unknown -> Unknown + } +} diff --git a/android/app/src/main/java/net/awan/pipelines/ui/graph/WorkflowGraph.kt b/android/app/src/main/java/net/awan/pipelines/ui/graph/WorkflowGraph.kt index 89becda9..2b72c411 100644 --- a/android/app/src/main/java/net/awan/pipelines/ui/graph/WorkflowGraph.kt +++ b/android/app/src/main/java/net/awan/pipelines/ui/graph/WorkflowGraph.kt @@ -18,6 +18,7 @@ import androidx.compose.material.icons.Icons import androidx.compose.material.icons.filled.FitScreen import androidx.compose.material.icons.filled.Fullscreen import androidx.compose.material.icons.filled.FullscreenExit +import androidx.compose.material3.ColorScheme import androidx.compose.material3.Icon import androidx.compose.material3.IconButton import androidx.compose.material3.MaterialTheme @@ -166,32 +167,7 @@ fun WorkflowGraph( val description = remember(graph, runState) { graphDescription(graph, runState) } val scheme = MaterialTheme.colorScheme - val colors = remember(scheme) { - GraphColors( - // The two terminal roles stay scheme roles so their meaning is kept. - success = scheme.tertiary, - error = scheme.error, - // Every other outcome uses the one curated, legible palette for both - // its stroke and its label text, so a curve and its label always agree. - palette = GraphPalette.colors, - // Node fills differ by kind (see [GraphNodeKind]): model (neutral), - // ntfy (amber), other/custom (green), and the two terminals. - nodeFill = scheme.surfaceVariant, - nodeNtfyFill = scheme.tertiaryContainer, - nodeCustomFill = scheme.primaryContainer, - // A selected node inverts (light fill / dark text) plus a 4px border, - // so selection reads in either appearance and never relies on colour. - nodeFillActive = scheme.inverseSurface, - nodeTextActive = scheme.inverseOnSurface, - nodeBorder = scheme.outline, - nodeBorderActive = scheme.primary, - nodeText = scheme.onSurface, - terminalFill = scheme.secondaryContainer, - terminalErrorFill = scheme.errorContainer, - labelBackground = scheme.surface, - labelText = scheme.onSurfaceVariant, - ) - } + val colors = remember(scheme) { graphColors(scheme) } // node key -> stage type, derived once per graph (never per frame) so node // kind/colour and the spoken description share one lookup. val stageTypeByKey = remember(graph) { graph.stages.associate { it.key to it.type } } @@ -381,6 +357,38 @@ internal class GraphColors( val labelText: Color, ) +/** + * The graph's colours for [scheme], built in one place so every surface that must + * agree with the graph (the graph itself and the timeline's step-outcome chips) + * uses the same palette. The two terminal roles stay scheme roles so their + * meaning is kept; every other outcome uses the one curated, legible + * [GraphPalette] for both a stroke and its label text. + */ +internal fun graphColors(scheme: ColorScheme): GraphColors = GraphColors( + // The two terminal roles stay scheme roles so their meaning is kept. + success = scheme.tertiary, + error = scheme.error, + // Every other outcome uses the one curated, legible palette for both its + // stroke and its label text, so a curve and its label always agree. + palette = GraphPalette.colors, + // Node fills differ by kind (see [GraphNodeKind]): model (neutral), ntfy + // (amber), other/custom (green), and the two terminals. + nodeFill = scheme.surfaceVariant, + nodeNtfyFill = scheme.tertiaryContainer, + nodeCustomFill = scheme.primaryContainer, + // A selected node inverts (light fill / dark text) plus a 4px border, so + // selection reads in either appearance and never relies on colour. + nodeFillActive = scheme.inverseSurface, + nodeTextActive = scheme.inverseOnSurface, + nodeBorder = scheme.outline, + nodeBorderActive = scheme.primary, + nodeText = scheme.onSurface, + terminalFill = scheme.secondaryContainer, + terminalErrorFill = scheme.errorContainer, + labelBackground = scheme.surface, + labelText = scheme.onSurfaceVariant, +) + /** The accessibility label for one node, naming its type when it is a stage. */ private fun nodeDescription(node: NodeLayout, type: String?): String { if (node.terminal) return "Terminal ${node.label}, tap for details" diff --git a/android/app/src/main/java/net/awan/pipelines/ui/screens/RunDetailScreen.kt b/android/app/src/main/java/net/awan/pipelines/ui/screens/RunDetailScreen.kt index 21de11a4..1c879a9a 100644 --- a/android/app/src/main/java/net/awan/pipelines/ui/screens/RunDetailScreen.kt +++ b/android/app/src/main/java/net/awan/pipelines/ui/screens/RunDetailScreen.kt @@ -51,6 +51,7 @@ import net.awan.pipelines.data.protocol.SessionEvidence import net.awan.pipelines.ui.AppViewModel import net.awan.pipelines.ui.LoadState import net.awan.pipelines.ui.components.CodeBlock +import net.awan.pipelines.ui.components.ColoredChip import net.awan.pipelines.ui.components.DetailTabBody import net.awan.pipelines.ui.components.DetailTabs import net.awan.pipelines.ui.components.ErrorState @@ -62,12 +63,15 @@ import net.awan.pipelines.ui.components.StatusChip import net.awan.pipelines.ui.components.collapsibleSection import net.awan.pipelines.ui.components.rememberSectionExpansion import net.awan.pipelines.ui.components.runDetailTabs +import net.awan.pipelines.ui.components.runStateIcon import net.awan.pipelines.ui.components.runStateOf import net.awan.pipelines.ui.displayText import net.awan.pipelines.ui.formatDuration import net.awan.pipelines.ui.artifactsEmptyMessage import net.awan.pipelines.ui.graph.ArtifactGallery import net.awan.pipelines.ui.graph.WorkflowGraph +import net.awan.pipelines.ui.graph.graphColors +import net.awan.pipelines.ui.graph.outcomeColor import net.awan.pipelines.ui.runArtifactGroups import net.awan.pipelines.ui.theme.pipelinesText import net.awan.pipelines.ui.visitCount @@ -615,6 +619,13 @@ private fun TimelineRow(entry: TimelineEntry, onClick: () -> Unit) { val text = pipelinesText() val state = runStateOf(entry.step.outcome.ifBlank { entry.step.status }) val chipLabel = entry.outcomeLabel.ifBlank { state.label } + // A visit's chip and glyph are a *stage outcome*, not the run status, so they + // take the graph's outcome palette and agree with the workflow graph instead + // of being mapped through the run-status colours (the two are different + // vocabularies). Built once per scheme, from the same factory the graph uses. + val scheme = MaterialTheme.colorScheme + val outcomeColors = remember(scheme) { graphColors(scheme) } + val outcomeTint = outcomeColor(entry.step.outcome.ifBlank { entry.step.status }, outcomeColors) Row( modifier = Modifier .fillMaxWidth() @@ -627,6 +638,7 @@ private fun TimelineRow(entry: TimelineEntry, onClick: () -> Unit) { state = state, contentDescription = "Visit ${entry.visit} ${entry.stageKey}: ${state.label}", modifier = Modifier.size(18.dp), + tint = outcomeTint, ) Column(Modifier.weight(1f), verticalArrangement = Arrangement.spacedBy(2.dp)) { Row( @@ -640,7 +652,7 @@ private fun TimelineRow(entry: TimelineEntry, onClick: () -> Unit) { overflow = TextOverflow.Ellipsis, modifier = Modifier.weight(1f), ) - StatusChip(label = chipLabel, state = state) + ColoredChip(label = chipLabel, color = outcomeTint, icon = runStateIcon(state)) if (hasArtifacts(entry.step)) { Icon( imageVector = Icons.Default.AttachFile, diff --git a/android/app/src/test/java/net/awan/pipelines/ui/components/RunStatusPaletteTest.kt b/android/app/src/test/java/net/awan/pipelines/ui/components/RunStatusPaletteTest.kt new file mode 100644 index 00000000..831dd106 --- /dev/null +++ b/android/app/src/test/java/net/awan/pipelines/ui/components/RunStatusPaletteTest.kt @@ -0,0 +1,73 @@ +package net.awan.pipelines.ui.components + +import androidx.compose.ui.graphics.Color +import net.awan.pipelines.ui.graph.contrastRatio +import net.awan.pipelines.ui.theme.DarkError +import net.awan.pipelines.ui.theme.DarkPrimary +import net.awan.pipelines.ui.theme.DarkTertiary +import org.junit.Assert.assertEquals +import org.junit.Assert.assertNotEquals +import org.junit.Assert.assertTrue +import org.junit.Test + +class RunStatusPaletteTest { + + /** The dark Pipelines surface every status chip/label is drawn on. */ + private val darkSurface = Color(0xFF0E1513) + + @Test + fun everyStatusColourMeetsWcagAaOnTheDarkSurface() { + RunState.entries.forEach { state -> + val ratio = contrastRatio(runStateColor(state), darkSurface) + assertTrue("$state contrast $ratio < 4.5", ratio >= 4.5) + } + } + + @Test + fun succeededIsGreenNotTheOldAmberTertiary() { + val green = runStateColor(RunState.Succeeded) + assertTrue("green must dominate: $green", green.green > green.red && green.green > green.blue) + assertNotEquals(DarkTertiary, green) + } + + @Test + fun runningAndActiveAreTheSameBlueNotTheOldMintPrimary() { + listOf(RunState.Running, RunState.Active).forEach { state -> + val blue = runStateColor(state) + assertTrue("blue must dominate: $blue", blue.blue > blue.red && blue.blue > blue.green) + assertNotEquals(DarkPrimary, blue) + } + assertEquals(runStateColor(RunState.Running), runStateColor(RunState.Active)) + } + + @Test + fun failedIsTheAppErrorRed() { + assertEquals(DarkError, runStateColor(RunState.Failed)) + } + + @Test + fun interruptedIsAmberAndDistinctFromFailure() { + val amber = runStateColor(RunState.Interrupted) + assertTrue( + "amber needs red>blue and green>blue: $amber", + amber.red > amber.blue && amber.green > amber.blue, + ) + assertNotEquals(DarkError, amber) + } + + @Test + fun queuedIsNeutralNotRunningBlue() { + val queued = runStateColor(RunState.Queued) + assertNotEquals(runStateColor(RunState.Running), queued) + val spread = maxOf(queued.red, queued.green, queued.blue) - + minOf(queued.red, queued.green, queued.blue) + assertTrue("queued should be near-grey: $queued", spread < 0.1f) + } + + @Test + fun everyEntryHasARationale() { + RunState.entries.forEach { state -> + assertTrue("$state needs a rationale", RunStatusPalette.of(state).rationale.isNotBlank()) + } + } +} From 54443903ae73d36a51bf7b309bc2daa616afd174 Mon Sep 17 00:00:00 2001 From: Alan Silva Date: Fri, 16 Oct 2026 02:23:03 +0100 Subject: [PATCH 2/9] Record re-verification evidence for the run-status palette Add a README evidence subsection for the committed run-status colour change at 24584d8: the unit suite (143 tests, RunStatusPaletteTest 7/7 incl. contrast), assembleDebug with the published APK size and sha256, before/after pixel-sampled captures on emulator-5556, and the APK publish location and LAN URL. --- android/README.md | 30 ++++++++++++++++++++++++++++++ 1 file changed, 30 insertions(+) diff --git a/android/README.md b/android/README.md index 5a65597a..390a9d7c 100644 --- a/android/README.md +++ b/android/README.md @@ -1346,3 +1346,33 @@ Evidence (macOS, JDK 17 from Homebrew `openjdk@17`, Gradle 8.11.1, 18009527`; a streamed `GET | shasum -a 256` equalled the local file. At 17.2 MiB it exceeds the server's 8 MiB per-file inventory cap, so it is served by direct URL only. + +### Re-verified against the committed tree (run 72, 16 Oct 2026) + +The change above is committed at `24584d8`; re-checked independently on that exact +tree (JDK 17 from Homebrew `openjdk@17`, Gradle 8.11.1, `--offline`): + +- `gradle --offline :app:testDebugUnitTest --rerun` → **143 tests, 0 failures, 0 + errors** (`RunStatusPaletteTest` 7/7, including the per-status WCAG-AA contrast + check). `gradle --offline :app:assembleDebug` succeeded; the APK is 18,009,527 + bytes, sha256 `17f52f23e40f4ba0c524ac2929adfd6a8f39353e68ccdeedb2e029019225e350`. +- Before/after captured on `emulator-5556` (`sdk_gphone16k_arm64`, 2208x1840, + density 420, dark mode) with `android/scripts/capture_png.sh -s emulator-5556`. + The pre-change build was produced from a clean `git archive cd85f69` tree (never + a working-tree stash), and each capture was pixel-sampled to read the rendered + colour back: + - **Before**: runs-list usage Succeeded `#F2C879` (amber) and Active `#6FD3B8` + (mint); run 69 header `#F2C879`, run 72 header `#6FD3B8`; the `approved` + Timeline chip `#BEC9C5` (run-status `Unknown` grey). + - **After**: Succeeded `#7FE0A8` (green), Failed `#FFB4AB`, Canceled `#889391`, + Interrupted `#E8C06A`, Active `#7FB2F0`; run 69 header `#7FE0A8`, run 72 header + `#7FB2F0`; the `approved` Timeline chip `#C0A3F5` (graph palette index 5) while + the `success` chip stays `#F2C879` (the graph's tertiary role), so a step chip + agrees with the graph. `logcat` after a fresh launch had 0 `FATAL EXCEPTION` / + `E AndroidRuntime` lines. +- **APK publish.** `app/build/outputs/apk/debug/app-debug.apk` copied to + `…/artifacts/72/1/pipelines-debug-wip-24584d8.apk` (`24584d8` = `git rev-parse + --short HEAD`); `curl -I + http://10.0.0.249:8080/artifacts/72/1/pipelines-debug-wip-24584d8.apk` returned + `HTTP/1.1 200 OK`, `Content-Type: application/vnd.android.package-archive`, + `Content-Length: 18009527`, and a streamed `GET | shasum -a 256` matched. From 3480461ffb406f74bfc6633b72d53e89aeab14e2 Mon Sep 17 00:00:00 2001 From: Alan Silva Date: Fri, 16 Oct 2026 03:43:29 +0100 Subject: [PATCH 3/9] Show the last run on every pipeline row MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Each pipeline row in the Android list now renders its most recent run: the status chip, how long ago it started, its recorded duration and its run id. Pipelines that have never run say "no runs recorded" instead of leaving a blank line, and the line is withheld until the run history has loaded so a missing history is never reported as "no runs". The list_runs history already arrives whole (id DESC), so the join is client-side: PipelineLastRun.kt folds it onto a Map keyed by pipeline id, recency decided from the timestamps with the higher run id breaking an exact tie, and formats "ago · duration · run N", omitting any genuinely absent fragment. The change is android/-only, adds no server field or dependency, keeps the existing title/secondary structure and selected-row highlight, and never starts a run. PipelineLastRunTest covers most-recent-wins, no runs, unknown pipeline id, equal timestamps, a bad timestamp, an unknown status word, the formatRanAgo scales and the "no runs recorded" wording. README records the verification: :app:testDebugUnitTest (153 tests, 0 failures) and a full --rerun-tasks assembleDebug (17,863,337 bytes, sha256 b2255066…). --- android/README.md | 59 +++++++++ .../pipelines/ui/screens/PipelineLastRun.kt | 96 ++++++++++++++ .../ui/screens/PipelineListScreen.kt | 70 +++++++++- .../ui/screens/PipelineLastRunTest.kt | 123 ++++++++++++++++++ 4 files changed, 343 insertions(+), 5 deletions(-) create mode 100644 android/app/src/main/java/net/awan/pipelines/ui/screens/PipelineLastRun.kt create mode 100644 android/app/src/test/java/net/awan/pipelines/ui/screens/PipelineLastRunTest.kt diff --git a/android/README.md b/android/README.md index 390a9d7c..84fe1c87 100644 --- a/android/README.md +++ b/android/README.md @@ -1376,3 +1376,62 @@ tree (JDK 17 from Homebrew `openjdk@17`, Gradle 8.11.1, `--offline`): http://10.0.0.249:8080/artifacts/72/1/pipelines-debug-wip-24584d8.apk` returned `HTTP/1.1 200 OK`, `Content-Type: application/vnd.android.package-archive`, `Content-Length: 18009527`, and a streamed `GET | shasum -a 256` matched. + +## Last-run facts on every pipeline row (16 Oct 2026) + +`android/` only. No server field was added: the whole run history already arrives +from `list_runs` (`internal/pipeline/runs.go`, id DESC), so the join is +client-side. + +- **Pure join.** `ui/screens/PipelineLastRun.kt` adds `pipelineRunBadges(runs, now)`, + which folds the history onto a `Map` keyed by + pipeline id with `runId`, `state` (`runStateOf`), `ranAgo` and `duration`. + Recency comes from the run timestamps, not the input order — the higher run id + breaks an exact tie (or a missing/blank `created_at`), so an unsorted or + partial response is still correct. `PipelineRunBadge.metaLine()` formats + `ago · duration · run N` and drops any fragment that is genuinely absent (a + still-running run has no `finished_at`); it never prints a blank separator. + `formatRanAgo` mirrors the `formatDuration` integer rhythm (`just now`, then + `Nm ago`/`Nh ago`/`Nd ago`) and clamps clock skew to `just now`. A pipeline with + no run is simply absent from the map and the row prints the explicit + `NO_RUNS_RECORDED` + ("no runs recorded") instead of a blank line. The last-run line is withheld + until `runsState.data != null` (`runsKnown`), so a not-yet-loaded history never + makes the false "no runs recorded" claim. +- **Row.** `PipelineListScreen.kt` refreshes runs alongside pipelines, anchors + "now" once per composition (`remember`), and renders the chip + meta line in a + `Row` under the unchanged title/secondary lines; the selected-row highlight is + untouched. +- **Tests.** `test/.../PipelineLastRunTest.kt` (10 cases) covers most-recent-wins + on unsorted input, no runs, unknown pipeline id, equal timestamps, an + unparseable timestamp, an unknown status word (`RunState.Unknown`, id still + rendered), each `formatRanAgo` scale plus blank/bad input, and the + `NO_RUNS_RECORDED` wording. + +Verified on this tree (macOS, JDK 17 from Homebrew `openjdk@17`, Gradle 9.7.1, +`ANDROID_HOME=/Users/alan/Library/Android/sdk`): + +- `gradle :app:testDebugUnitTest` → **153 tests, 0 failures, 0 errors, 0 + skipped** (`PipelineLastRunTest` 10/10). +- `gradle :app:assembleDebug --rerun-tasks --no-build-cache` succeeded → + `app-debug.apk` **17,863,337 bytes**, sha256 + `b22550660c1ce9f42719eb5a32a296055d9f3df97fa0fd94bb26fa3868730506`. This is a + full rebuild of the current tree; the review's blocker was that the earlier + published `artifacts/83/1/pipelines-debug-wip-5444390.apk` (17,997,811 bytes, + sha256 `0fb07207…`) was a different revision of `PipelineListScreen.kt`, so it + has been rebuilt and republished (see below). +- Screenshots on `emulator-5556` (`FoldB_API_36`, 2208x1840, density 420, dark + mode) with `android/scripts/capture_png.sh -s emulator-5556`: the narrow window + via `adb shell wm size 1080x2340`, the wide window at the default 2208x1840 + (`wm size reset`). Both show the running run omitting its duration, the failed + and canceled rows carrying `ago · duration · run N`, and pipeline id 3 "Plan, + implement, review" printing `no runs recorded`. +- **APK publish.** Copied to + `…/artifacts/83/3/pipelines-debug-wip-5444390.apk` (`5444390` = `git rev-parse + --short HEAD`). `curl -I + http://10.0.0.249:8080/artifacts/83/3/pipelines-debug-wip-5444390.apk` returned + `HTTP/1.1 200 OK`, `Content-Type: application/vnd.android.package-archive`, + `Content-Length: 17863337`, and a streamed `GET | shasum -a 256` returned the + same `b2255066…` as the local file. The same APK was installed on the emulator + and the pulled installed `base.apk` hashed to `b2255066…`, so the reviewed + source is what was actually rendered. diff --git a/android/app/src/main/java/net/awan/pipelines/ui/screens/PipelineLastRun.kt b/android/app/src/main/java/net/awan/pipelines/ui/screens/PipelineLastRun.kt new file mode 100644 index 00000000..26cca427 --- /dev/null +++ b/android/app/src/main/java/net/awan/pipelines/ui/screens/PipelineLastRun.kt @@ -0,0 +1,96 @@ +package net.awan.pipelines.ui.screens + +import java.time.Duration +import java.time.OffsetDateTime +import net.awan.pipelines.data.protocol.RunSummary +import net.awan.pipelines.ui.components.RunState +import net.awan.pipelines.ui.components.runStateOf +import net.awan.pipelines.ui.formatDuration + +/** Shown for a pipeline that appears in list_runs but has recorded no run. */ +const val NO_RUNS_RECORDED = "no runs recorded" + +/** + * The last-run facts one pipeline row shows: the status chip's [state], how long + * ago the run started, its recorded duration and its run id. Kept as a plain data + * class so the join and its edge cases (no runs, ties, unknown status) are + * unit-testable without composing anything. + */ +internal data class PipelineRunBadge( + val runId: Long, + val state: RunState, + val ranAgo: String?, + val duration: String?, +) + +/** + * The last-run secondary line, e.g. `2h ago · 1m 5s · run 42`. Missing fragments + * (an unparseable start, a run still executing) are omitted so no blank separator + * is ever printed; the run id is always present. + */ +internal fun PipelineRunBadge.metaLine(): String = buildList { + ranAgo?.let(::add) + duration?.let(::add) + add("run $runId") +}.joinToString(" · ") + +/** + * Joins list_runs (the whole history, delivered newest-first) onto pipelines by + * pipeline id: one badge per pipeline that has run, the most recent run winning. + * The input order never matters — recency is decided from the timestamps, with the + * higher run id breaking an exact tie — so a pipeline with no runs is simply + * absent from the result (the caller renders [NO_RUNS_RECORDED] for it). No server + * field is involved; this is a pure client-side join. + */ +internal fun pipelineRunBadges( + runs: List, + now: OffsetDateTime, +): Map { + val latest = HashMap() + for (run in runs) { + val current = latest[run.pipelineId] + if (current == null || isMoreRecent(run, current)) latest[run.pipelineId] = run + } + return latest.mapValues { (_, run) -> + PipelineRunBadge( + runId = run.id, + state = runStateOf(run.status), + ranAgo = formatRanAgo(run.createdAt, now), + duration = formatDuration(run.createdAt, run.finishedAt), + ) + } +} + +/** Timestamps decide recency; the higher run id breaks an exact tie (or a bad timestamp). */ +private fun isMoreRecent(candidate: RunSummary, current: RunSummary): Boolean { + val a = parseInstant(candidate.createdAt) + val b = parseInstant(current.createdAt) + if (a != null && b != null) { + val order = a.compareTo(b) + if (order != 0) return order > 0 + } + return candidate.id > current.id +} + +/** + * A compact "how long ago" for a run's start: `just now` under a minute, then + * `Nm ago`/`Nh ago`/`Nd ago`, the same integer rhythm as [formatDuration]. Null + * when the timestamp is blank or unparseable, so the caller omits the fragment + * instead of printing a blank. A future start (clock skew) reads as `just now`, + * never a negative age. + */ +internal fun formatRanAgo(createdAt: String, now: OffsetDateTime): String? { + val start = parseInstant(createdAt) ?: return null + val seconds = Duration.between(start, now).seconds.coerceAtLeast(0) + return when { + seconds < 60 -> "just now" + seconds < 3600 -> "${seconds / 60}m ago" + seconds < 86_400 -> "${seconds / 3600}h ago" + else -> "${seconds / 86_400}d ago" + } +} + +private fun parseInstant(text: String): OffsetDateTime? { + if (text.isBlank()) return null + return runCatching { OffsetDateTime.parse(text) }.getOrNull() +} diff --git a/android/app/src/main/java/net/awan/pipelines/ui/screens/PipelineListScreen.kt b/android/app/src/main/java/net/awan/pipelines/ui/screens/PipelineListScreen.kt index 8b8efac9..96664a6a 100644 --- a/android/app/src/main/java/net/awan/pipelines/ui/screens/PipelineListScreen.kt +++ b/android/app/src/main/java/net/awan/pipelines/ui/screens/PipelineListScreen.kt @@ -1,7 +1,9 @@ package net.awan.pipelines.ui.screens +import androidx.compose.foundation.layout.Arrangement import androidx.compose.foundation.layout.Column import androidx.compose.foundation.layout.PaddingValues +import androidx.compose.foundation.layout.Row import androidx.compose.foundation.layout.fillMaxSize import androidx.compose.foundation.layout.fillMaxWidth import androidx.compose.foundation.layout.padding @@ -25,10 +27,12 @@ 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.text.style.TextOverflow import androidx.compose.ui.unit.dp import androidx.lifecycle.compose.collectAsStateWithLifecycle +import java.time.OffsetDateTime import net.awan.pipelines.data.protocol.PipelineSummary import net.awan.pipelines.ui.AppViewModel import net.awan.pipelines.ui.components.EmptyState @@ -36,6 +40,7 @@ import net.awan.pipelines.ui.components.ErrorState import net.awan.pipelines.ui.components.ListRow import net.awan.pipelines.ui.components.LoadingState import net.awan.pipelines.ui.components.PaneIdentity +import net.awan.pipelines.ui.components.RunStatusChip import net.awan.pipelines.ui.theme.pipelinesText @OptIn(ExperimentalMaterial3Api::class) @@ -48,9 +53,24 @@ fun PipelineListScreen( covered: Boolean = false, ) { val state by vm.pipelines.collectAsStateWithLifecycle() + val runsState by vm.runs.collectAsStateWithLifecycle() var query by remember { mutableStateOf("") } - LaunchedEffect(Unit) { vm.refreshPipelines() } + // The last-run line joins list_runs onto the pipelines client-side; runs are + // fetched here too so a pipeline list opened first still shows its history. + LaunchedEffect(Unit) { + vm.refreshPipelines() + vm.refreshRuns() + } + + // "How long ago" is anchored once per composition, not recomputed per row. + val now = remember { OffsetDateTime.now() } + val badges = remember(runsState.data, now) { + runsState.data?.let { pipelineRunBadges(it.runs, now) }.orEmpty() + } + // Until the run history has loaded, a missing badge is "not known yet", never + // the explicit "no runs recorded" claim. + val runsKnown = runsState.data != null // A covered pane shows its compact identity only; the search field and list // must never be drawn squeezed into the peek strip. @@ -70,7 +90,12 @@ fun PipelineListScreen( TopAppBar( title = { Text("Pipelines") }, actions = { - IconButton(onClick = vm::refreshPipelines) { + IconButton( + onClick = { + vm.refreshPipelines() + vm.refreshRuns() + }, + ) { Icon(Icons.Default.Refresh, contentDescription = "Refresh pipelines") } }, @@ -106,6 +131,8 @@ fun PipelineListScreen( PipelineRow( pipeline = pipeline, selected = pipeline.id == selectedId, + badge = badges[pipeline.id], + runsKnown = runsKnown, onClick = { onOpen(pipeline.id, pipeline.version) }, ) } @@ -126,11 +153,20 @@ fun PipelineListScreen( /** * One pipeline as a row of the shared real list: a leading workflow glyph, the - * name as the title and the id/version/stage-count as the secondary line. The - * row is selected when its pipeline is the one open in the detail pane. + * name as the title, the id/version/stage-count as the secondary line and the + * last-run facts (status chip, how long ago, duration, run id) below. The row is + * selected when its pipeline is the one open in the detail pane. Before the run + * history has loaded the last-run line is omitted; once it has, a pipeline with + * no recorded run says so explicitly. */ @Composable -private fun PipelineRow(pipeline: PipelineSummary, selected: Boolean, onClick: () -> Unit) { +private fun PipelineRow( + pipeline: PipelineSummary, + selected: Boolean, + badge: PipelineRunBadge?, + runsKnown: Boolean, + onClick: () -> Unit, +) { val text = pipelinesText() ListRow( selected = selected, @@ -163,5 +199,29 @@ private fun PipelineRow(pipeline: PipelineSummary, selected: Boolean, onClick: ( overflow = TextOverflow.Ellipsis, ) } + if (runsKnown) { + if (badge == null) { + Text( + NO_RUNS_RECORDED, + style = text.meta, + color = MaterialTheme.colorScheme.onSurfaceVariant, + maxLines = 1, + overflow = TextOverflow.Ellipsis, + ) + } else { + Row( + verticalAlignment = Alignment.CenterVertically, + horizontalArrangement = Arrangement.spacedBy(8.dp), + ) { + RunStatusChip(badge.state) + Text( + badge.metaLine(), + style = text.meta, + maxLines = 1, + overflow = TextOverflow.Ellipsis, + ) + } + } + } } } diff --git a/android/app/src/test/java/net/awan/pipelines/ui/screens/PipelineLastRunTest.kt b/android/app/src/test/java/net/awan/pipelines/ui/screens/PipelineLastRunTest.kt new file mode 100644 index 00000000..0ae593a5 --- /dev/null +++ b/android/app/src/test/java/net/awan/pipelines/ui/screens/PipelineLastRunTest.kt @@ -0,0 +1,123 @@ +package net.awan.pipelines.ui.screens + +import java.time.OffsetDateTime +import net.awan.pipelines.data.protocol.RunSummary +import net.awan.pipelines.ui.components.RunState +import org.junit.Assert.assertEquals +import org.junit.Assert.assertNull +import org.junit.Assert.assertTrue +import org.junit.Test + +class PipelineLastRunTest { + + private val now = OffsetDateTime.parse("2026-10-16T12:00:00Z") + + private fun run( + id: Long, + pipelineId: Long, + createdAt: String, + finishedAt: String = createdAt, + status: String = "succeeded", + ) = RunSummary( + id = id, + pipelineId = pipelineId, + createdAt = createdAt, + finishedAt = finishedAt, + status = status, + ) + + @Test + fun mostRecentRunWinsEvenWhenTheInputIsNotNewestFirst() { + // Deliberately unsorted: the newer start must win regardless of order. + val badges = pipelineRunBadges( + listOf( + run(7, 10, "2026-10-16T09:00:00Z"), + run(2, 10, "2026-10-16T11:00:00Z"), + run(5, 11, "2026-10-16T08:00:00Z"), + ), + now, + ) + assertEquals(2L, badges.getValue(10L).runId) + assertEquals(5L, badges.getValue(11L).runId) + } + + @Test + fun noRunsYieldsNoBadges() { + assertTrue(pipelineRunBadges(emptyList(), now).isEmpty()) + } + + @Test + fun unknownPipelineIdIsAbsentFromTheJoin() { + val badges = pipelineRunBadges(listOf(run(1, 10, "2026-10-16T10:00:00Z")), now) + assertEquals(1L, badges.getValue(10L).runId) + assertNull(badges[99L]) + } + + @Test + fun equalTimestampsBreakTheTieByTheHigherRunId() { + val badges = pipelineRunBadges( + listOf( + run(4, 10, "2026-10-16T10:00:00Z"), + run(9, 10, "2026-10-16T10:00:00Z"), + ), + now, + ) + assertEquals(9L, badges.getValue(10L).runId) + } + + @Test + fun unparseableTimestampsFallBackToRunIdWithoutCrashing() { + val badges = pipelineRunBadges( + listOf(run(3, 10, ""), run(8, 10, "not-a-date")), + now, + ) + assertEquals(8L, badges.getValue(10L).runId) + assertNull(badges.getValue(10L).ranAgo) + } + + @Test + fun unknownStatusWordYieldsAnUnknownStateNotACrash() { + val badge = pipelineRunBadges( + listOf(run(1, 10, "2026-10-16T10:00:00Z", status = "something-new")), + now, + ).getValue(10L) + assertEquals(RunState.Unknown, badge.state) + // The id still renders even when only the status word is unrecognised. + assertTrue(badge.metaLine().endsWith("run 1")) + } + + @Test + fun metaLineCarriesAgoDurationAndRunId() { + val badge = pipelineRunBadges( + listOf(run(42, 10, "2026-10-16T11:00:00Z", finishedAt = "2026-10-16T11:01:05Z")), + now, + ).getValue(10L) + assertEquals("1h ago · 1m 5s · run 42", badge.metaLine()) + } + + @Test + fun metaLineOmitsAMissingDuration() { + // A running run has no finished_at, so the duration fragment is dropped. + val badge = pipelineRunBadges( + listOf(run(42, 10, "2026-10-16T11:00:00Z", finishedAt = "", status = "running")), + now, + ).getValue(10L) + assertEquals("1h ago · run 42", badge.metaLine()) + } + + @Test + fun formatRanAgoCoversEachScaleAndRejectsBadInput() { + assertEquals("just now", formatRanAgo("2026-10-16T11:59:30Z", now)) + assertEquals("just now", formatRanAgo("2026-10-16T12:05:00Z", now)) + assertEquals("5m ago", formatRanAgo("2026-10-16T11:55:00Z", now)) + assertEquals("3h ago", formatRanAgo("2026-10-16T09:00:00Z", now)) + assertEquals("2d ago", formatRanAgo("2026-10-14T12:00:00Z", now)) + assertNull(formatRanAgo("", now)) + assertNull(formatRanAgo("not-a-date", now)) + } + + @Test + fun noRunsWordingIsTheExplicitConstant() { + assertEquals("no runs recorded", NO_RUNS_RECORDED) + } +} From 1c925d72f70089f6781cb57915254ffb60762b74 Mon Sep 17 00:00:00 2001 From: Alan Silva Date: Fri, 16 Oct 2026 04:57:53 +0100 Subject: [PATCH 4/9] Remember sort options for the pipelines and runs lists Add a per-list sort control to each top bar and persist the choice in SharedPreferences so it survives restarts. - ui/screens/ListSort.kt: PipelineSort and RunSort enums plus pure comparators with explicit tie-breaks, and sortPipelines/sortRuns. ServerOrder/NewestFirst remain the defaults; a still-executing or unparseable-timestamp run sorts last. - ui/components/SortMenu.kt: the shared top-bar control, a distinct IconButton opening a Material 3 DropdownMenu of every option plus a divider and Reset, with the active choice checked. - data/SettingsRepository.kt + ui/AppViewModel.kt: store the sort key per list as a StateFlow; fromStorage falls back to the default for a stale/unknown/blank value. - ui/Format.kt: share parseInstant and durationSeconds so the printed duration and the sort key cannot disagree; PipelineLastRun.kt reuses the shared latest-run fold. - PipelineListScreen.kt/RunHistoryScreen.kt wire the control and sort; groupRunsByDay preserves the comparator's order. - ListSortTest.kt covers the comparators and storage fallback; RunGroupingTest.kt gains an explicit-order case. Verified on this tree with :app:testDebugUnitTest (167 tests, 0 failures), assembleDebug, and emulator-5556 persistence, the sort control, and Reset; captured in android/README.md. --- android/README.md | 123 ++++++++++++ .../awan/pipelines/data/SettingsRepository.kt | 21 ++ .../net/awan/pipelines/ui/AppViewModel.kt | 8 + .../main/java/net/awan/pipelines/ui/Format.kt | 31 ++- .../awan/pipelines/ui/components/SortMenu.kt | 70 +++++++ .../net/awan/pipelines/ui/screens/ListSort.kt | 123 ++++++++++++ .../pipelines/ui/screens/PipelineLastRun.kt | 35 ++-- .../ui/screens/PipelineListScreen.kt | 26 ++- .../pipelines/ui/screens/RunHistoryScreen.kt | 42 ++-- .../awan/pipelines/ui/screens/ListSortTest.kt | 183 ++++++++++++++++++ .../pipelines/ui/screens/RunGroupingTest.kt | 15 ++ 11 files changed, 639 insertions(+), 38 deletions(-) create mode 100644 android/app/src/main/java/net/awan/pipelines/ui/components/SortMenu.kt create mode 100644 android/app/src/main/java/net/awan/pipelines/ui/screens/ListSort.kt create mode 100644 android/app/src/test/java/net/awan/pipelines/ui/screens/ListSortTest.kt diff --git a/android/README.md b/android/README.md index 84fe1c87..ccfdb538 100644 --- a/android/README.md +++ b/android/README.md @@ -1435,3 +1435,126 @@ Verified on this tree (macOS, JDK 17 from Homebrew `openjdk@17`, Gradle 9.7.1, same `b2255066…` as the local file. The same APK was installed on the emulator and the pulled installed `base.apk` hashed to `b2255066…`, so the reviewed source is what was actually rendered. + +## Remembered sort options for the pipelines and runs lists (16 Oct 2026) + +Both list top bars gained a sort control that opens the choices plus a Reset, and +the choice is remembered per list across restarts. `android/` only; nothing in +the Pipelines server, its Go source, the Docker/compose files or the installer was +touched, no dependency was added (the icons come from the already-declared +`material-icons-extended`), no run was started from the app, and the attached +Pixel 10 Pro Fold was never installed on or driven (every `adb`/emulator command +targeted `emulator-5556`). + +- **Pure comparators.** `ui/screens/ListSort.kt` defines the `PipelineSort` + (`ServerOrder` default, `NameAsc`, `NameDesc`, `RecentRun`, `FewestStages`, + `MostStages`) and `RunSort` (`NewestFirst` default, `OldestFirst`, + `LongestDuration`, `ShortestDuration`, `PipelineName`, `Status`) enums plus one + pure `pipelineComparator`/`runComparator` per sort and the `sortPipelines`/ + `sortRuns` helpers. Every comparator ends in an explicit tie-break, so equal + primary keys always order the same way; a blank/unparseable timestamp and a run + with no recorded duration (still executing) sort last regardless of direction + instead of crashing. `ServerOrder` is a zero comparator, so the stable sort + preserves the server's own order exactly. `RecentRun` uses the shared + per-pipeline latest-run fold (`latestRunByPipeline`, extracted from the + last-run badge join in `PipelineLastRun.kt`) rather than folding the history + twice. +- **Shared time helpers.** `ui/Format.kt` gained `parseInstant` (moved out of + `PipelineLastRun.kt`) and `durationSeconds`; the existing `formatDuration` now + delegates to `durationSeconds`, so the printed duration and the sort key can + never disagree. +- **Shared control.** `ui/components/SortMenu.kt` is the one top-bar control both + screens use: an `IconButton` (its own glyph and content description, so it + cannot collide with the adjacent Refresh action or a future search entry point) + opening a `DropdownMenu` of the options — the active one carries a leading + check glyph, not colour alone — then a divider and Reset. It has no geometry + literals and anchors correctly at both window widths. The glyph is + `Icons.AutoMirrored.Filled.Sort` (the RTL-aware form, so no `Icons.Default.Sort` + deprecation warning at build time and the arrow mirrors correctly). +- **Persistence.** `data/SettingsRepository.kt` stores each choice as its stable + storage key (`pipeline_sort`, `run_sort`) with a `StateFlow`, exactly like the + server URL/workspace; `AppViewModel` exposes them and their setters. The list + screens resolve the stored string with `PipelineSort.fromStorage`/ + `RunSort.fromStorage`, which fall back to the default for a stale, unknown or + blank value (the repository stays unaware of the UI enums). +- **Grouping.** `groupRunsByDay` now takes the ordering comparator and preserves + the order it produces (the default is still newest first, so the default output + is unchanged); the run list groups by day in that order and sorts within a day + by the same comparator. + +Verified on this tree (macOS, Homebrew JDK 25 (`openjdk@25`), Gradle 9.7.1, +`ANDROID_HOME=/Users/alan/Library/Android/sdk`, `--offline`): + +- `gradle --offline :app:testDebugUnitTest --rerun-tasks` → the 21 test-result XMLs + aggregate to **167 tests, 0 failures, 0 errors, 0 skipped** (the new + `ListSortTest` has 13 cases covering the storage fallback for both enums, server + order, case-insensitive name/stage sorts with their id/name tie-breaks, + recent-run no-run-last and run-id tie-breaks, newest/oldest with unparseable + timestamps last, duration longest/shortest with a still-executing run last and + equal-duration tie-break, pipeline-name/status sorts, and that equal keys order + identically whatever the input order; `RunGroupingTest` gained an explicit-order + case). `compileDebugKotlin` emits no warnings. +- `gradle --offline :app:assembleDebug --rerun-tasks --no-build-cache` (a full + rebuild, so the published binary is exactly this tree) succeeded → + `app-debug.apk` **17,879,721 bytes**, sha256 + `cb68fbb13e469e81c15837ba95314a2ab40f1f29f4769e4a615bbc0ce4636a30`. +- On `emulator-5556` (`FoldB_API_36`, 2208x1840, density 420, dark mode) against + the live server `ws://10.0.2.2:8080/connect`, driven with `adb shell input` and + `uiautomator dump`; every capture below was written with + `android/scripts/capture_png.sh -s emulator-5556` (validated PNG, named display + id) into `…/artifacts/87/1/`. The live server's pipeline set churns while the + maintenance workflow runs, so the concrete names differ between captures, but + each ordering was read back from the accessibility tree: + - Wide (2208x1840 ≈ 841dp): tapping `Sort pipelines` opened the six options plus + `Reset` (`01_wide_pipelines_sort_open.png`); choosing `Name Z–A` reordered the + list to descending names and stored `pipeline_sort=name_desc` + (`02_wide_pipelines_name_za.png`). `Sort runs` opened the six run options plus + `Reset` (`03_wide_runs_sort_open.png`); `Oldest first` showed run 1 → 2 → 3 and + stored `run_sort=oldest_first` (`04_wide_runs_oldest_first.png`). The sort icon + and the adjacent `Refresh` stay separate actions at both widths (the icon's own + `Sort pipelines`/`Sort runs` content description sits left of `Refresh …`). + - **Persistence proof.** After setting pipelines `Name Z–A` and runs + `Oldest first`, `run-as net.awan.pipelines cat shared_prefs/pipelines_settings.xml` + showed `pipeline_sort=name_desc`, `run_sort=oldest_first`. `am force-stop + net.awan.pipelines` (verified `pidof` empty) then `am start` and a fresh + `uiautomator dump` showed the pipelines list still in descending-name order + (`05_wide_pipelines_name_za_after_relaunch.png`) and the runs list still oldest + first, run 1 → 2 → 3 (`06_wide_runs_oldest_first_after_relaunch.png`), with no + interaction. + - `Reset` on the pipelines menu restored the server order (id 1 → 5 → 11 → 6 → + 4 → 9 → 3) and stored `pipeline_sort=server_order`; `Reset` on the runs menu + restored `run_sort=newest_first` and run 87 → 86 → 85 → 84 → 83 → 82 + (`10_narrow_runs_reset_newest_first.png`). + - Narrow (`adb shell wm size 1080x2340` ≈ 411dp; `wm size reset` afterwards): + both `Sort pipelines` and `Sort runs` opened their menus + (`07_narrow_runs_sort_open.png`); `Status` ordered Canceled → Failed → Failed … + and stored `run_sort=status` (`08_narrow_runs_status_sort.png`); `Most recent + run` ordered the rows by recency 10h → 3d → 3d → 4d → 4d → 5d and put the + runless pipeline (`no runs recorded`) last, storing `pipeline_sort=recent_run` + (`09_narrow_pipelines_recent_run.png`). + - **Stale-key tolerance on device.** With `pipeline_sort` and `run_sort` set to + `garbage_key` in `shared_prefs/pipelines_settings.xml` (verified via `run-as … + cat`, then replaced by push + `run-as … cp`) and the app force-stopped and + relaunched, the pipelines list came back in the server's order (id 1 → 5 → 11 → + 6 → 4 → 9 → 3, `11_narrow_pipelines_stale_key_falls_back_to_server_order.png`) + and the runs list in newest-first (run 87 → 86 → 85), with no crash. + - `adb -s emulator-5556 logcat -d | grep -c 'FATAL EXCEPTION'` and `… | grep -c + 'E AndroidRuntime'` each returned 0; no run was started from the app. +- **APK publish.** `app-debug.apk` was copied to + `~/.local/share/pipelines/data/artifacts/87/1/pipelines-debug-wip-3480461.apk` + (`3480461` = `git rev-parse --short HEAD`); `shasum -a 256` matched. `curl -I + http://10.0.0.249:8080/artifacts/87/1/pipelines-debug-wip-3480461.apk` returned + `HTTP/1.1 200 OK`, `Content-Type: application/vnd.android.package-archive`, + `Content-Length: 17879721`, and a streamed `GET | shasum -a 256` returned the + same `cb68fbb1…` as the local file. The deterministic full-rebuild APK was + installed on `emulator-5556` (`adb -s emulator-5556 install -r`) and the pulled + installed `base.apk` hashed to `cb68fbb1…`, so the reviewed source is what was + actually rendered. At 17.1 MiB it exceeds the server's 8 MiB per-file inventory + cap, so it is served by direct URL only. + +Not verified in this pass: `:app:lintDebug` was not run (its only reported issues +are the two pre-existing `NewApi` errors for `android:windowLightNavigationBar`); +a real hardware fold to the cover display was not exercised (narrow was produced +with `wm size`); no before/after baseline build was captured, since the change is +additive and the default orders are asserted unchanged by the `ServerOrder`/ +`NewestFirst` unit tests. diff --git a/android/app/src/main/java/net/awan/pipelines/data/SettingsRepository.kt b/android/app/src/main/java/net/awan/pipelines/data/SettingsRepository.kt index f29a9c8e..dafb4fbf 100644 --- a/android/app/src/main/java/net/awan/pipelines/data/SettingsRepository.kt +++ b/android/app/src/main/java/net/awan/pipelines/data/SettingsRepository.kt @@ -21,6 +21,15 @@ class SettingsRepository(context: Context) { private val _workspace = MutableStateFlow(prefs.getString(KEY_WORKSPACE, "").orEmpty()) val workspace: StateFlow = _workspace.asStateFlow() + // The chosen list orderings, stored as their stable storage keys. The value + // is resolved (with a default fallback for a stale/unknown key) by the list + // screens, so this repository stays unaware of the UI's sort enums. + private val _pipelineSort = MutableStateFlow(prefs.getString(KEY_PIPELINE_SORT, "").orEmpty()) + val pipelineSort: StateFlow = _pipelineSort.asStateFlow() + + private val _runSort = MutableStateFlow(prefs.getString(KEY_RUN_SORT, "").orEmpty()) + val runSort: StateFlow = _runSort.asStateFlow() + fun setServerUrl(value: String) { val trimmed = value.trim() _serverUrl.value = trimmed @@ -33,11 +42,23 @@ class SettingsRepository(context: Context) { prefs.edit().putString(KEY_WORKSPACE, trimmed).apply() } + fun setPipelineSort(value: String) { + _pipelineSort.value = value + prefs.edit().putString(KEY_PIPELINE_SORT, value).apply() + } + + fun setRunSort(value: String) { + _runSort.value = value + prefs.edit().putString(KEY_RUN_SORT, value).apply() + } + /** True only when the user has explicitly supplied both required values. */ fun isConfigured(): Boolean = _serverUrl.value.isNotBlank() && _workspace.value.isNotBlank() private companion object { const val KEY_SERVER_URL = "server_url" const val KEY_WORKSPACE = "workspace" + const val KEY_PIPELINE_SORT = "pipeline_sort" + const val KEY_RUN_SORT = "run_sort" } } diff --git a/android/app/src/main/java/net/awan/pipelines/ui/AppViewModel.kt b/android/app/src/main/java/net/awan/pipelines/ui/AppViewModel.kt index 37b1a14a..e2c00e3e 100644 --- a/android/app/src/main/java/net/awan/pipelines/ui/AppViewModel.kt +++ b/android/app/src/main/java/net/awan/pipelines/ui/AppViewModel.kt @@ -48,6 +48,10 @@ class AppViewModel( val configuredServerUrl: StateFlow = settings.serverUrl val configuredWorkspace: StateFlow = settings.workspace + /** The stored pipeline/run sort keys; the list screens resolve them to a sort. */ + val pipelineSort: StateFlow = settings.pipelineSort + val runSort: StateFlow = settings.runSort + private val _serverUrlDraft = MutableStateFlow(settings.serverUrl.value) val serverUrlDraft: StateFlow = _serverUrlDraft.asStateFlow() @@ -153,6 +157,10 @@ class AppViewModel( fun disconnect() = repository.disconnect() + fun setPipelineSort(storageKey: String) = settings.setPipelineSort(storageKey) + + fun setRunSort(storageKey: String) = settings.setRunSort(storageKey) + private fun awaitConnected() { viewModelScope.launch { val connected = withTimeoutOrNull(CONNECT_TIMEOUT_MILLIS) { diff --git a/android/app/src/main/java/net/awan/pipelines/ui/Format.kt b/android/app/src/main/java/net/awan/pipelines/ui/Format.kt index 3556c023..4c9bcb24 100644 --- a/android/app/src/main/java/net/awan/pipelines/ui/Format.kt +++ b/android/app/src/main/java/net/awan/pipelines/ui/Format.kt @@ -12,15 +12,32 @@ import net.awan.pipelines.data.protocol.RunStep import net.awan.pipelines.data.protocol.StageArtifact import net.awan.pipelines.data.protocol.StageFileChanges -/** Human duration between two RFC3339 timestamps, or null when unavailable. */ -fun formatDuration(start: String, end: String): String? { - if (start.isBlank() || end.isBlank()) return null - return runCatching { - val seconds = Duration.between(OffsetDateTime.parse(start), OffsetDateTime.parse(end)).seconds - if (seconds < 0) null else formatDuration(seconds) - }.getOrNull() +/** + * Parses an RFC3339 timestamp, or null when blank or unparseable. The single + * parser every time-reading the UI shares, so a bad timestamp is handled the + * same way everywhere. + */ +internal fun parseInstant(text: String): OffsetDateTime? { + if (text.isBlank()) return null + return runCatching { OffsetDateTime.parse(text) }.getOrNull() } +/** + * Non-negative whole seconds between two RFC3339 timestamps, or null when either + * is blank/unparseable or the end precedes the start. The numeric counterpart of + * [formatDuration] (which delegates here), so a sort key and the printed + * duration can never disagree. + */ +internal fun durationSeconds(start: String, end: String): Long? { + val from = parseInstant(start) ?: return null + val to = parseInstant(end) ?: return null + return Duration.between(from, to).seconds.takeIf { it >= 0 } +} + +/** Human duration between two RFC3339 timestamps, or null when unavailable. */ +fun formatDuration(start: String, end: String): String? = + durationSeconds(start, end)?.let(::formatDuration) + /** * Human duration for a whole number of seconds. The single formatting rule for * every duration the UI shows (list meta, usage average, run summary, step diff --git a/android/app/src/main/java/net/awan/pipelines/ui/components/SortMenu.kt b/android/app/src/main/java/net/awan/pipelines/ui/components/SortMenu.kt new file mode 100644 index 00000000..9f3b5436 --- /dev/null +++ b/android/app/src/main/java/net/awan/pipelines/ui/components/SortMenu.kt @@ -0,0 +1,70 @@ +package net.awan.pipelines.ui.components + +import androidx.compose.foundation.layout.Box +import androidx.compose.material.icons.Icons +import androidx.compose.material.icons.automirrored.filled.Sort +import androidx.compose.material.icons.filled.Check +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.getValue +import androidx.compose.runtime.mutableStateOf +import androidx.compose.runtime.remember +import androidx.compose.runtime.setValue +import androidx.compose.ui.Modifier + +/** + * The shared list-sort control: a top-bar icon that opens [options] plus a + * divider and a Reset entry. It is deliberately its own action with a distinct + * glyph and content description, so it cannot collide with the adjacent Refresh + * action or a future top-bar search entry point; a `DropdownMenu` anchors to the + * icon and works at both window widths (it is not width-dependent geometry). + * + * [selected] draws a leading check on its row, so the active choice is conveyed + * by a glyph as well as by text, never by colour alone. + */ +@Composable +fun SortMenu( + options: List, + selected: T, + label: (T) -> String, + contentDescription: String, + onSelect: (T) -> Unit, + onReset: () -> Unit, + modifier: Modifier = Modifier, +) { + var expanded by remember { mutableStateOf(false) } + Box(modifier) { + IconButton(onClick = { expanded = true }) { + Icon(Icons.AutoMirrored.Filled.Sort, contentDescription = contentDescription) + } + DropdownMenu(expanded = expanded, onDismissRequest = { expanded = false }) { + options.forEach { option -> + DropdownMenuItem( + text = { Text(label(option)) }, + onClick = { + onSelect(option) + expanded = false + }, + leadingIcon = { + if (option == selected) { + Icon(Icons.Default.Check, contentDescription = null) + } + }, + ) + } + HorizontalDivider() + DropdownMenuItem( + text = { Text("Reset") }, + onClick = { + onReset() + expanded = false + }, + ) + } + } +} diff --git a/android/app/src/main/java/net/awan/pipelines/ui/screens/ListSort.kt b/android/app/src/main/java/net/awan/pipelines/ui/screens/ListSort.kt new file mode 100644 index 00000000..62536273 --- /dev/null +++ b/android/app/src/main/java/net/awan/pipelines/ui/screens/ListSort.kt @@ -0,0 +1,123 @@ +package net.awan.pipelines.ui.screens + +import java.time.OffsetDateTime +import net.awan.pipelines.data.protocol.PipelineSummary +import net.awan.pipelines.data.protocol.RunSummary +import net.awan.pipelines.ui.durationSeconds +import net.awan.pipelines.ui.parseInstant + +/** + * The pipeline-list orderings offered by the top-bar sort control. [storageKey] + * is the stable value persisted in SharedPreferences; [fromStorage] tolerates a + * stale, unknown or blank stored value by returning [Default] — the server's own + * order, which the default comparator preserves exactly. + */ +enum class PipelineSort(val label: String, val storageKey: String) { + ServerOrder("Server order", "server_order"), + NameAsc("Name A\u2013Z", "name_asc"), + NameDesc("Name Z\u2013A", "name_desc"), + RecentRun("Most recent run", "recent_run"), + FewestStages("Fewest stages", "fewest_stages"), + MostStages("Most stages", "most_stages"); + + companion object { + val Default = ServerOrder + + fun fromStorage(value: String?): PipelineSort = + entries.firstOrNull { it.storageKey == value } ?: Default + } +} + +/** + * The run-list orderings offered by the top-bar sort control. [storageKey] is + * persisted like [PipelineSort]'s; an unknown or stale value resolves to + * [Default] ("newest first"). + */ +enum class RunSort(val label: String, val storageKey: String) { + NewestFirst("Newest first", "newest_first"), + OldestFirst("Oldest first", "oldest_first"), + LongestDuration("Longest duration", "longest_duration"), + ShortestDuration("Shortest duration", "shortest_duration"), + PipelineName("Pipeline name", "pipeline_name"), + Status("Status", "status"); + + companion object { + val Default = NewestFirst + + fun fromStorage(value: String?): RunSort = + entries.firstOrNull { it.storageKey == value } ?: Default + } +} + +/** The identity comparator used by "server order": a stable sort then keeps the input untouched. */ +private val SERVER_ORDER = Comparator { _, _ -> 0 } + +/** + * The pure pipeline comparator for [sort]. Every case ends in an explicit + * tie-break (`id` is unique), so pipelines that compare equal on the primary key + * always order the same way rather than depending on the input order. + * + * [latestRuns] maps a pipeline id to that pipeline's most recent run + * (see [latestRunByPipeline]); only [PipelineSort.RecentRun] uses it but it is + * passed in once so the fold is never repeated per comparison. + */ +internal fun pipelineComparator( + sort: PipelineSort, + latestRuns: Map = emptyMap(), +): Comparator = when (sort) { + PipelineSort.ServerOrder -> SERVER_ORDER + PipelineSort.NameAsc -> compareBy(String.CASE_INSENSITIVE_ORDER) { it.name } + .thenBy { it.name } + .thenBy { it.id } + PipelineSort.NameDesc -> compareByDescending(String.CASE_INSENSITIVE_ORDER) { it.name } + .thenBy { it.name } + .thenBy { it.id } + PipelineSort.RecentRun -> compareBy { latestRuns[it.id] == null } + .thenByDescending { latestRuns[it.id]?.let { run -> parseInstant(run.createdAt) } ?: OffsetDateTime.MIN } + .thenByDescending { latestRuns[it.id]?.id ?: Long.MIN_VALUE } + .thenBy { it.id } + PipelineSort.FewestStages -> compareBy { it.stages } + .thenBy(String.CASE_INSENSITIVE_ORDER) { it.name } + .thenBy { it.id } + PipelineSort.MostStages -> compareByDescending { it.stages } + .thenBy(String.CASE_INSENSITIVE_ORDER) { it.name } + .thenBy { it.id } +} + +/** Orders [pipelines] by [sort], folding the run history once for the recent-run key. */ +internal fun sortPipelines( + pipelines: List, + sort: PipelineSort, + latestRuns: Map = emptyMap(), +): List = pipelines.sortedWith(pipelineComparator(sort, latestRuns)) + +/** + * The pure run comparator for [sort]. As with [pipelineComparator], every case + * ends in an explicit tie-break so equal keys always order the same way. A blank + * or unparseable timestamp, and a run with no recorded duration (still + * executing), sort last regardless of direction and never crash. + */ +internal fun runComparator(sort: RunSort): Comparator = when (sort) { + RunSort.NewestFirst -> compareByDescending { parseInstant(it.createdAt) ?: OffsetDateTime.MIN } + .thenByDescending { it.id } + RunSort.OldestFirst -> compareBy { parseInstant(it.createdAt) ?: OffsetDateTime.MAX } + .thenBy { it.id } + RunSort.LongestDuration -> compareBy { durationSeconds(it.createdAt, it.finishedAt) == null } + .thenByDescending { durationSeconds(it.createdAt, it.finishedAt) ?: Long.MIN_VALUE } + .thenByDescending { parseInstant(it.createdAt) ?: OffsetDateTime.MIN } + .thenByDescending { it.id } + RunSort.ShortestDuration -> compareBy { durationSeconds(it.createdAt, it.finishedAt) == null } + .thenBy { durationSeconds(it.createdAt, it.finishedAt) ?: Long.MAX_VALUE } + .thenByDescending { parseInstant(it.createdAt) ?: OffsetDateTime.MIN } + .thenByDescending { it.id } + RunSort.PipelineName -> compareBy(String.CASE_INSENSITIVE_ORDER) { it.name } + .thenByDescending { parseInstant(it.createdAt) ?: OffsetDateTime.MIN } + .thenByDescending { it.id } + RunSort.Status -> compareBy(String.CASE_INSENSITIVE_ORDER) { it.status } + .thenByDescending { parseInstant(it.createdAt) ?: OffsetDateTime.MIN } + .thenByDescending { it.id } +} + +/** Orders [runs] by [sort]. */ +internal fun sortRuns(runs: List, sort: RunSort): List = + runs.sortedWith(runComparator(sort)) diff --git a/android/app/src/main/java/net/awan/pipelines/ui/screens/PipelineLastRun.kt b/android/app/src/main/java/net/awan/pipelines/ui/screens/PipelineLastRun.kt index 26cca427..e56e15e8 100644 --- a/android/app/src/main/java/net/awan/pipelines/ui/screens/PipelineLastRun.kt +++ b/android/app/src/main/java/net/awan/pipelines/ui/screens/PipelineLastRun.kt @@ -6,6 +6,7 @@ import net.awan.pipelines.data.protocol.RunSummary import net.awan.pipelines.ui.components.RunState import net.awan.pipelines.ui.components.runStateOf import net.awan.pipelines.ui.formatDuration +import net.awan.pipelines.ui.parseInstant /** Shown for a pipeline that appears in list_runs but has recorded no run. */ const val NO_RUNS_RECORDED = "no runs recorded" @@ -45,22 +46,33 @@ internal fun PipelineRunBadge.metaLine(): String = buildList { internal fun pipelineRunBadges( runs: List, now: OffsetDateTime, -): Map { +): Map = + latestRunByPipeline(runs).mapValues { (_, run) -> runBadge(run, now) } + +/** + * The most recent run of each pipeline, decided from the timestamps (the higher + * run id breaking an exact tie or a bad timestamp), independent of the input + * order. The one fold shared by the last-run badge join above and the "most + * recent run" pipeline sort, so both agree on which run is the latest. + */ +internal fun latestRunByPipeline(runs: List): Map { val latest = HashMap() for (run in runs) { val current = latest[run.pipelineId] if (current == null || isMoreRecent(run, current)) latest[run.pipelineId] = run } - return latest.mapValues { (_, run) -> - PipelineRunBadge( - runId = run.id, - state = runStateOf(run.status), - ranAgo = formatRanAgo(run.createdAt, now), - duration = formatDuration(run.createdAt, run.finishedAt), - ) - } + return latest } +/** The display facts one pipeline row shows for [run], anchored to [now]. */ +internal fun runBadge(run: RunSummary, now: OffsetDateTime): PipelineRunBadge = + PipelineRunBadge( + runId = run.id, + state = runStateOf(run.status), + ranAgo = formatRanAgo(run.createdAt, now), + duration = formatDuration(run.createdAt, run.finishedAt), + ) + /** Timestamps decide recency; the higher run id breaks an exact tie (or a bad timestamp). */ private fun isMoreRecent(candidate: RunSummary, current: RunSummary): Boolean { val a = parseInstant(candidate.createdAt) @@ -89,8 +101,3 @@ internal fun formatRanAgo(createdAt: String, now: OffsetDateTime): String? { else -> "${seconds / 86_400}d ago" } } - -private fun parseInstant(text: String): OffsetDateTime? { - if (text.isBlank()) return null - return runCatching { OffsetDateTime.parse(text) }.getOrNull() -} diff --git a/android/app/src/main/java/net/awan/pipelines/ui/screens/PipelineListScreen.kt b/android/app/src/main/java/net/awan/pipelines/ui/screens/PipelineListScreen.kt index 96664a6a..0113f52d 100644 --- a/android/app/src/main/java/net/awan/pipelines/ui/screens/PipelineListScreen.kt +++ b/android/app/src/main/java/net/awan/pipelines/ui/screens/PipelineListScreen.kt @@ -41,6 +41,7 @@ import net.awan.pipelines.ui.components.ListRow import net.awan.pipelines.ui.components.LoadingState import net.awan.pipelines.ui.components.PaneIdentity import net.awan.pipelines.ui.components.RunStatusChip +import net.awan.pipelines.ui.components.SortMenu import net.awan.pipelines.ui.theme.pipelinesText @OptIn(ExperimentalMaterial3Api::class) @@ -54,6 +55,8 @@ fun PipelineListScreen( ) { val state by vm.pipelines.collectAsStateWithLifecycle() val runsState by vm.runs.collectAsStateWithLifecycle() + val sortKey by vm.pipelineSort.collectAsStateWithLifecycle() + val sort = PipelineSort.fromStorage(sortKey) var query by remember { mutableStateOf("") } // The last-run line joins list_runs onto the pipelines client-side; runs are @@ -65,8 +68,13 @@ fun PipelineListScreen( // "How long ago" is anchored once per composition, not recomputed per row. val now = remember { OffsetDateTime.now() } - val badges = remember(runsState.data, now) { - runsState.data?.let { pipelineRunBadges(it.runs, now) }.orEmpty() + // The history is folded to one latest run per pipeline once, feeding both the + // row badges and the "most recent run" ordering rather than folding twice. + val latestRuns = remember(runsState.data) { + runsState.data?.let { latestRunByPipeline(it.runs) }.orEmpty() + } + val badges = remember(latestRuns, now) { + latestRuns.mapValues { (_, run) -> runBadge(run, now) } } // Until the run history has loaded, a missing badge is "not known yet", never // the explicit "no runs recorded" claim. @@ -90,6 +98,14 @@ fun PipelineListScreen( TopAppBar( title = { Text("Pipelines") }, actions = { + SortMenu( + options = PipelineSort.entries, + selected = sort, + label = { it.label }, + contentDescription = "Sort pipelines", + onSelect = { vm.setPipelineSort(it.storageKey) }, + onReset = { vm.setPipelineSort(PipelineSort.Default.storageKey) }, + ) IconButton( onClick = { vm.refreshPipelines() @@ -115,8 +131,10 @@ fun PipelineListScreen( state.loading && state.data == null -> LoadingState("Loading pipelines…") state.error != null && state.data == null -> ErrorState(state.error!!, onRetry = vm::refreshPipelines) else -> { - val items = (state.data ?: emptyList()) - .filter { it.name.contains(query, ignoreCase = true) } + val items = remember(state.data, query, sort, latestRuns) { + sortPipelines(state.data ?: emptyList(), sort, latestRuns) + .filter { it.name.contains(query, ignoreCase = true) } + } if (items.isEmpty()) { EmptyState( if (query.isBlank()) "No pipelines are defined on this server." diff --git a/android/app/src/main/java/net/awan/pipelines/ui/screens/RunHistoryScreen.kt b/android/app/src/main/java/net/awan/pipelines/ui/screens/RunHistoryScreen.kt index 8455b8d3..0606a900 100644 --- a/android/app/src/main/java/net/awan/pipelines/ui/screens/RunHistoryScreen.kt +++ b/android/app/src/main/java/net/awan/pipelines/ui/screens/RunHistoryScreen.kt @@ -51,6 +51,7 @@ import net.awan.pipelines.ui.components.ErrorState import net.awan.pipelines.ui.components.ListRow import net.awan.pipelines.ui.components.LoadingState import net.awan.pipelines.ui.components.PaneIdentity +import net.awan.pipelines.ui.components.SortMenu import net.awan.pipelines.ui.components.runStateColor import net.awan.pipelines.ui.components.runStateOf import net.awan.pipelines.ui.formatDuration @@ -69,6 +70,8 @@ fun RunHistoryScreen( covered: Boolean = false, ) { val state by vm.runs.collectAsStateWithLifecycle() + val sortKey by vm.runSort.collectAsStateWithLifecycle() + val sort = RunSort.fromStorage(sortKey) LaunchedEffect(Unit) { vm.refreshRuns() } // A covered pane shows its compact identity only; the usage block, sticky day @@ -89,6 +92,14 @@ fun RunHistoryScreen( TopAppBar( title = { Text(if (filterPipelineId == null) "Runs" else "Runs for this pipeline") }, actions = { + SortMenu( + options = RunSort.entries, + selected = sort, + label = { it.label }, + contentDescription = "Sort runs", + onSelect = { vm.setRunSort(it.storageKey) }, + onReset = { vm.setRunSort(RunSort.Default.storageKey) }, + ) IconButton(onClick = vm::refreshRuns) { Icon(Icons.Default.Refresh, contentDescription = "Refresh runs") } @@ -108,6 +119,7 @@ fun RunHistoryScreen( runs = state.data?.runs.orEmpty(), filterPipelineId = filterPipelineId, selectedRunId = selectedRunId, + sort = sort, error = state.error, onOpenRun = onOpenRun, modifier = Modifier.padding(padding), @@ -123,20 +135,22 @@ private fun RunHistoryContent( runs: List, filterPipelineId: Long?, selectedRunId: Long?, + sort: RunSort, error: String?, onOpenRun: (Long) -> Unit, modifier: Modifier = Modifier, ) { - // Day-grouping is derived once per data change (single pass, keyed on the - // stable source list), not per recomposition. - val groups = remember(runs, filterPipelineId) { + // Day-grouping is derived once per data/order change (single pass, keyed on + // the stable source list), not per recomposition. The chosen comparator orders + // the runs first; the groups then follow the order their first run appears in. + val groups = remember(runs, filterPipelineId, sort) { val filtered = if (filterPipelineId == null) { runs } else { runs.filter { it.pipelineId == filterPipelineId } } val zone = ZoneId.systemDefault() - groupRunsByDay(filtered, LocalDate.now(zone), zone) + groupRunsByDay(filtered, LocalDate.now(zone), zone, runComparator(sort)) } LazyColumn( @@ -343,17 +357,19 @@ private fun formatRunStart(createdAt: String): String? { internal data class RunDayGroup(val label: String, val runs: List) /** - * Groups runs by calendar day in the device timezone, newest first, preserving - * the order within a day. A blank/unparseable timestamp gets a safe "Unknown - * date" group instead of crashing. + * Groups runs by calendar day in the device timezone, preserving the order + * [order] puts them in (the default is newest first, so the groups come out + * newest day first), and preserving the order within a day. A blank/unparseable + * timestamp gets a safe "Unknown date" group instead of crashing. */ -internal fun groupRunsByDay(runs: List, today: LocalDate, zone: ZoneId): List { - val ordered = runs.sortedWith( - compareByDescending { runDate(it.createdAt, zone) } - .thenByDescending { it.createdAt }, - ) +internal fun groupRunsByDay( + runs: List, + today: LocalDate, + zone: ZoneId, + order: Comparator = runComparator(RunSort.NewestFirst), +): List { val groups = LinkedHashMap>() - for (run in ordered) { + for (run in runs.sortedWith(order)) { groups.getOrPut(dayLabel(run.createdAt, today, zone)) { mutableListOf() } += run } return groups.map { (label, list) -> RunDayGroup(label, list) } diff --git a/android/app/src/test/java/net/awan/pipelines/ui/screens/ListSortTest.kt b/android/app/src/test/java/net/awan/pipelines/ui/screens/ListSortTest.kt new file mode 100644 index 00000000..20779337 --- /dev/null +++ b/android/app/src/test/java/net/awan/pipelines/ui/screens/ListSortTest.kt @@ -0,0 +1,183 @@ +package net.awan.pipelines.ui.screens + +import net.awan.pipelines.data.protocol.PipelineSummary +import net.awan.pipelines.data.protocol.RunSummary +import org.junit.Assert.assertEquals +import org.junit.Test + +class ListSortTest { + + private fun pipeline( + id: Long, + name: String, + stages: Int = 1, + createdAt: String = "2026-10-01T00:00:00Z", + ) = PipelineSummary(id = id, name = name, version = 1, stages = stages, createdAt = createdAt) + + private fun run( + id: Long, + pipelineId: Long = id, + name: String = "p$id", + status: String = "succeeded", + createdAt: String = "2026-10-16T10:00:00Z", + finishedAt: String = "2026-10-16T10:00:10Z", + ) = RunSummary( + id = id, + pipelineId = pipelineId, + name = name, + status = status, + createdAt = createdAt, + finishedAt = finishedAt, + ) + + // --- stored-value tolerance ------------------------------------------------- + + @Test + fun pipelineSortFromStorageFallsBackToTheDefaultForStaleOrUnknownValues() { + assertEquals(PipelineSort.Default, PipelineSort.ServerOrder) + for (option in PipelineSort.entries) { + assertEquals(option, PipelineSort.fromStorage(option.storageKey)) + } + assertEquals(PipelineSort.ServerOrder, PipelineSort.fromStorage(null)) + assertEquals(PipelineSort.ServerOrder, PipelineSort.fromStorage("")) + assertEquals(PipelineSort.ServerOrder, PipelineSort.fromStorage("no_such_sort")) + } + + @Test + fun runSortFromStorageFallsBackToTheDefaultForStaleOrUnknownValues() { + assertEquals(RunSort.Default, RunSort.NewestFirst) + for (option in RunSort.entries) { + assertEquals(option, RunSort.fromStorage(option.storageKey)) + } + assertEquals(RunSort.NewestFirst, RunSort.fromStorage(null)) + assertEquals(RunSort.NewestFirst, RunSort.fromStorage("")) + assertEquals(RunSort.NewestFirst, RunSort.fromStorage("whatever")) + } + + // --- pipelines -------------------------------------------------------------- + + @Test + fun serverOrderKeepsTheInputUntouched() { + val input = listOf(pipeline(7, "Zeta"), pipeline(3, "alpha"), pipeline(5, "Beta")) + assertEquals(listOf(7L, 3L, 5L), sortPipelines(input, PipelineSort.ServerOrder).map { it.id }) + } + + @Test + fun nameSortsAreCaseInsensitiveAndBreakTiesByTheUniqueId() { + val input = listOf(pipeline(7, "Zebra"), pipeline(3, "apple"), pipeline(9, "APPLE")) + assertEquals(listOf(9L, 3L, 7L), sortPipelines(input, PipelineSort.NameAsc).map { it.id }) + // Descending keeps the id tie-break ascending: APPLE(9) before apple(3). + assertEquals(listOf(7L, 9L, 3L), sortPipelines(input, PipelineSort.NameDesc).map { it.id }) + } + + @Test + fun stageCountSortsBreakTiesByNameThenId() { + // Ids deliberately disagree with name/stage order so the tie-breaks show. + val input = listOf( + pipeline(7, "Alpha", stages = 2), + pipeline(3, "beta", stages = 2), + pipeline(5, "Gamma", stages = 1), + ) + assertEquals(listOf(5L, 7L, 3L), sortPipelines(input, PipelineSort.FewestStages).map { it.id }) + assertEquals(listOf(7L, 3L, 5L), sortPipelines(input, PipelineSort.MostStages).map { it.id }) + } + + @Test + fun recentRunSortPutsPipelinesWithoutRunsLastAndNewerRunsFirst() { + val runs = listOf( + run(5, pipelineId = 1, createdAt = "2026-10-16T09:00:00Z"), + run(9, pipelineId = 2, createdAt = "2026-10-16T11:00:00Z"), + ) + val latest = latestRunByPipeline(runs) + val input = listOf(pipeline(3, "NoRun"), pipeline(1, "Older"), pipeline(2, "Newer")) + assertEquals( + listOf(2L, 1L, 3L), + sortPipelines(input, PipelineSort.RecentRun, latest).map { it.id }, + ) + } + + @Test + fun recentRunSortBreaksExactTimestampTiesByTheHigherRunId() { + val runs = listOf( + run(4, pipelineId = 1, createdAt = "2026-10-16T10:00:00Z"), + run(8, pipelineId = 2, createdAt = "2026-10-16T10:00:00Z"), + ) + val latest = latestRunByPipeline(runs) + val input = listOf(pipeline(1, "A"), pipeline(2, "B")) + assertEquals( + listOf(2L, 1L), + sortPipelines(input, PipelineSort.RecentRun, latest).map { it.id }, + ) + } + + @Test + fun recentRunSortBreaksRunlessPipelinesByTheirOwnId() { + val input = listOf(pipeline(3, "C"), pipeline(1, "A"), pipeline(2, "B")) + assertEquals( + listOf(1L, 2L, 3L), + sortPipelines(input, PipelineSort.RecentRun).map { it.id }, + ) + } + + // --- runs ------------------------------------------------------------------- + + @Test + fun newestAndOldestFirstPutUnparseableTimestampsLast() { + val input = listOf( + run(3, createdAt = ""), + run(1, createdAt = "2026-10-16T10:00:00Z"), + run(2, createdAt = "2026-10-16T12:00:00Z"), + ) + assertEquals(listOf(2L, 1L, 3L), sortRuns(input, RunSort.NewestFirst).map { it.id }) + assertEquals(listOf(1L, 2L, 3L), sortRuns(input, RunSort.OldestFirst).map { it.id }) + } + + @Test + fun durationSortsPutRunsWithoutADurationLastInBothDirections() { + val input = listOf( + run(1, createdAt = "2026-10-16T10:00:00Z", finishedAt = "2026-10-16T10:00:10Z"), + run(2, createdAt = "2026-10-16T10:00:00Z", finishedAt = "2026-10-16T10:10:00Z"), + // Still executing: no finished_at, so no duration. + run(3, createdAt = "2026-10-16T10:00:00Z", finishedAt = ""), + ) + assertEquals(listOf(2L, 1L, 3L), sortRuns(input, RunSort.LongestDuration).map { it.id }) + assertEquals(listOf(1L, 2L, 3L), sortRuns(input, RunSort.ShortestDuration).map { it.id }) + } + + @Test + fun durationSortsBreakTiesByNewestStartThenId() { + val input = listOf( + run(1, createdAt = "2026-10-16T09:00:00Z", finishedAt = "2026-10-16T09:00:30Z"), + run(2, createdAt = "2026-10-16T11:00:00Z", finishedAt = "2026-10-16T11:00:30Z"), + ) + // Equal 30s durations: newer start (id 2) first. + assertEquals(listOf(2L, 1L), sortRuns(input, RunSort.LongestDuration).map { it.id }) + assertEquals(listOf(2L, 1L), sortRuns(input, RunSort.ShortestDuration).map { it.id }) + } + + @Test + fun pipelineNameAndStatusSortsAreCaseInsensitiveWithExplicitTieBreaks() { + val byName = listOf( + run(1, name = "beta", createdAt = "2026-10-16T10:00:00Z"), + run(2, name = "Alpha", createdAt = "2026-10-16T09:00:00Z"), + ) + assertEquals(listOf(2L, 1L), sortRuns(byName, RunSort.PipelineName).map { it.id }) + + val byStatus = listOf( + run(1, status = "running"), + run(2, status = "failed"), + ) + assertEquals(listOf(2L, 1L), sortRuns(byStatus, RunSort.Status).map { it.id }) + } + + @Test + fun equalKeysAlwaysOrderTheSameWay() { + // Same status and same timestamp: the id descends, so the order is fixed. + val input = listOf( + run(3, status = "succeeded", createdAt = "2026-10-16T10:00:00Z"), + run(1, status = "succeeded", createdAt = "2026-10-16T10:00:00Z"), + ) + assertEquals(listOf(3L, 1L), sortRuns(input, RunSort.Status).map { it.id }) + assertEquals(listOf(3L, 1L), sortRuns(input.reversed(), RunSort.Status).map { it.id }) + } +} diff --git a/android/app/src/test/java/net/awan/pipelines/ui/screens/RunGroupingTest.kt b/android/app/src/test/java/net/awan/pipelines/ui/screens/RunGroupingTest.kt index c735f742..487cd76e 100644 --- a/android/app/src/test/java/net/awan/pipelines/ui/screens/RunGroupingTest.kt +++ b/android/app/src/test/java/net/awan/pipelines/ui/screens/RunGroupingTest.kt @@ -43,4 +43,19 @@ class RunGroupingTest { val unknown = groups.first { it.label == "Unknown date" } assertEquals(setOf(1L, 2L), unknown.runs.map { it.id }.toSet()) } + + @Test + fun anExplicitOrderDrivesBothTheGroupOrderAndTheOrderWithinADay() { + val today = LocalDate.of(2026, 10, 15) + val zone = ZoneOffset.UTC + val runs = listOf( + run(3, "2026-10-14T09:00:00Z"), + run(1, "2026-10-15T10:00:00Z"), + run(2, "2026-10-15T08:00:00Z"), + ) + val groups = groupRunsByDay(runs, today, zone, runComparator(RunSort.OldestFirst)) + // Oldest day first, and within "Today" the earlier start comes first. + assertEquals(listOf("Yesterday", "Today"), groups.take(2).map { it.label }) + assertEquals(listOf(2L, 1L), groups[1].runs.map { it.id }) + } } From 54af4535d750814762556c702747dc09a8c6e9e1 Mon Sep 17 00:00:00 2001 From: Alan Silva Date: Fri, 16 Oct 2026 06:01:18 +0100 Subject: [PATCH 5/9] Add remembered filters to the runs and pipelines lists Give each list a filter control, remembered per list across restarts like the sort, combined with AND. Filters narrow; the (later) omni search will find, so they are kept distinct. - ui/screens/ListFilter.kt: RunTimeRange (AnyTime default, Today, Last7Days, Last30Days), RunPresence (Any default, HasRuns, NoRuns) and the RunFilters/PipelineFilters data classes, with one pure predicate per facet (runMatchesStatuses, runMatchesPipeline, runMatchesTimeRange, pipelineMatchesPresence, pipelineMatchesLastRunStatus) and the AND-combining filterRuns/filterPipelines. A default narrows nothing; an empty status set means "any"; the time windows are inclusive calendar days; a blank, unparseable or future timestamp never matches a finite window; a runless pipeline has no last-run status; fromStorage tolerates stale/unknown/blank values; encodeRunStates/decodeRunStates round-trip the status set. - ui/components/FilterMenu.kt: the shared top-bar control both screens use - an IconButton with a numeric active-filter count badge opening the caller's sections plus one Clear filters action (disabled when nothing is active), the count folded into the icon description, and a menu capped to the window and clear of the navigation inset so it stays scrollable rather than clipping. - PipelineListScreen.kt/RunHistoryScreen.kt wire the control and predicates; the existing name search on pipelines stays a separate field, and the new pipeline facets depend on the run history. - ui/components/States.kt: EmptyState gains optional actionLabel/onAction so both lists distinguish "nothing exists" from "nothing matches the current filters" and offer Clear filters only in the latter. - data/SettingsRepository.kt + ui/AppViewModel.kt: store each facet under its own stable key as a StateFlow, exactly like the sort keys; the screens resolve the stored strings so the repository stays unaware of the UI enums. Verified on this tree with :app:testDebugUnitTest, assembleDebug, and emulator-5556 persistence and captures; recorded in android/README.md. --- android/README.md | 199 ++++++++++++++ .../awan/pipelines/data/SettingsRepository.kt | 49 ++++ .../net/awan/pipelines/ui/AppViewModel.kt | 17 ++ .../pipelines/ui/components/FilterMenu.kt | 178 +++++++++++++ .../awan/pipelines/ui/components/States.kt | 17 +- .../awan/pipelines/ui/screens/ListFilter.kt | 246 ++++++++++++++++++ .../ui/screens/PipelineListScreen.kt | 88 ++++++- .../pipelines/ui/screens/RunHistoryScreen.kt | 128 +++++++-- .../pipelines/ui/components/FilterMenuTest.kt | 29 +++ .../pipelines/ui/screens/ListFilterTest.kt | 231 ++++++++++++++++ 10 files changed, 1152 insertions(+), 30 deletions(-) create mode 100644 android/app/src/main/java/net/awan/pipelines/ui/components/FilterMenu.kt create mode 100644 android/app/src/main/java/net/awan/pipelines/ui/screens/ListFilter.kt create mode 100644 android/app/src/test/java/net/awan/pipelines/ui/components/FilterMenuTest.kt create mode 100644 android/app/src/test/java/net/awan/pipelines/ui/screens/ListFilterTest.kt diff --git a/android/README.md b/android/README.md index ccfdb538..9fabf032 100644 --- a/android/README.md +++ b/android/README.md @@ -1558,3 +1558,202 @@ a real hardware fold to the cover display was not exercised (narrow was produced with `wm size`); no before/after baseline build was captured, since the change is additive and the default orders are asserted unchanged by the `ServerOrder`/ `NewestFirst` unit tests. + +## Filters for the runs and pipelines lists (16 Oct 2026) + +Both list top bars gained a filter control, remembered per list across restarts +like the sort. `android/` only; nothing in the Pipelines server, its Go source, +the Docker/compose files or the installer was touched, no dependency was added +(the one new glyph, `Icons.Default.FilterList`, is from the already-declared +`material-icons-extended`), no run was started from the app, and the attached +Pixel 10 Pro Fold was never installed on or driven (every `adb`/emulator command +targeted `emulator-5556`). + +- **Pure predicates.** `ui/screens/ListFilter.kt` defines `RunTimeRange` + (`AnyTime` default, `Today`, `Last7Days`, `Last30Days`), `RunPresence` + (`Any` default, `HasRuns`, `NoRuns`) and the `RunFilters`/`PipelineFilters` + data classes plus one pure predicate per facet (`runMatchesStatuses`, + `runMatchesPipeline`, `runMatchesTimeRange`, `pipelineMatchesPresence`, + `pipelineMatchesLastRunStatus`) and the AND-combining `filterRuns`/ + `filterPipelines`. A default filter narrows nothing; an empty status set means + "any status". The status options are the server's own run vocabulary + (queued/running/succeeded/failed/canceled/interrupted), not the app-only + `active`/`unknown` buckets. A time window is inclusive calendar days ending + today (last 7 = today + the six days before), and a blank, unparseable or + future-dated timestamp never matches a finite window. A pipeline with no run + has no last-run status, so a selected status never matches it. `fromStorage` + tolerates stale/unknown/blank values by returning the default, and + `encodeRunStates`/`decodeRunStates` round-trip the status set as the server + status words in ordinal order. +- **Runs list.** Status (multi-select), pipeline (single-select from the + distinct pipelines already present in the run history, named by their runs, so + no extra fetch) and the time range, combined with AND. +- **Pipelines list.** The existing name search stays a separate field; the new + filter adds has-runs / no-runs and the most-recent run's status (multi-select). + Both pipeline facets depend on the run history, so `filterPipelines` leaves the + list unfiltered until that history is known rather than briefly hiding every + row. +- **Shared control.** `ui/components/FilterMenu.kt` is the one top-bar control + both screens use: an `IconButton` carrying a numeric active-filter count badge + (so "filters active" is never colour alone) opening the caller's sections plus + a divider and one Clear filters action (disabled when nothing is active). Its + `optionContent` slot receives a `dismiss` callback, so single-select entries + close the menu while multi-select toggles keep it open; `FilterCheckItem` is + the shared leading-check row. It has no geometry literals and anchors + correctly at both window widths. +- **Empty states.** `ui/components/States.kt`'s `EmptyState` gained optional + `actionLabel`/`onAction`. Both lists now distinguish "nothing exists" (no + action) from "nothing matches the current filters" (a Clear filters action); + the pipelines list also says when the name search and the filters together + match nothing. The clear action resets that list's filters (and, on Pipelines, + the search) without touching the other list. +- **Persistence.** `data/SettingsRepository.kt` stores each facet under its own + stable key (`run_filter_statuses`, `run_filter_pipeline`, + `run_filter_time_range`, `pipeline_filter_presence`, + `pipeline_filter_run_statuses`) with a `StateFlow`, exactly like the sorts; + `AppViewModel` exposes them and their setters. The screens resolve the stored + strings with `RunFilters.fromStorage`/`PipelineFilters.fromStorage` (the + repository stays unaware of the UI enums). +- **Shared time helper.** The run screen's file-private `runDate` was removed in + favour of `ListFilter.kt`'s `runLocalDate`, so the day-grouping label and the + time-range predicate share one parse. `groupRunsByDay` is unchanged. + +Verified on this tree (macOS, Homebrew JDK 25 (`openjdk@25`), Gradle 9.7.1, +`ANDROID_HOME=/Users/alan/Library/Android/sdk`, `--offline`): + +- `gradle --offline :app:testDebugUnitTest --rerun-tasks` → the 22 test-result + XMLs aggregate to **183 tests, 0 failures, 0 errors, 0 skipped** (up from 167; + the new `ListFilterTest` has 16 cases covering stored-value parsing/fallback, + encode/decode round-trip and garbage tolerance, empty-status "any", the status + union, pipeline id vs any, the inclusive time windows and blank/future + timestamps, the AND combination of every facet, presence has/no-runs, last-run + status excluding runless pipelines, the `runsKnown` guard, and the + distinct/sorted pipeline options). +- `gradle --offline :app:assembleDebug --rerun-tasks --no-build-cache` (a full + rebuild, so the published binary is exactly this tree) succeeded → + `app-debug.apk` **17,912,489 bytes**, sha256 + `eaa34c0b030511c2e4de1964dc4e905e62e822e876b5c0128bfff4d918933fc5`. +- On `emulator-5556` (`sdk_gphone16k_arm64`, 2208x1840, dark mode) against the + live server `ws://10.0.2.2:8080/connect`, driven with `adb shell input` and + `uiautomator dump`; every capture below was written with + `android/scripts/capture_png.sh -s emulator-5556` (validated PNG, named display + id) into `…/artifacts/89/1/`: + - Selecting status `failed` narrowed the runs list to the failed runs and + showed the badge `1` (`01_runs_filtered_failed.png`), read back from the + accessibility tree. + - The runs `Filter runs` menu opened with its Status, Pipeline and Time range + sections, the active-count badge and `Clear filters` + (`02_runs_filter_menu_open.png`). + - **Filtered-empty state.** Adding pipeline `Complete a Task` to the `failed` + status matched run 43, but the contradictory `running` status (no `Complete + a Task` run is running) yielded no match: the list showed `No runs match the + current filters.` with a `Clear filters` button and badge `2` + (`03_runs_filtered_empty.png`); the button restored the full list and removed + the badge. + - The pipelines `Filter pipelines` menu carries the Runs (Any/Has runs/No runs) + and Last run status sections, the badge and `Clear filters` + (`05_pipelines_filter_menu_open.png`). `Has runs` + last-run status + `succeeded` narrowed the list to its succeeded-last-run pipelines + (`04_pipelines_filtered_has_runs_succeeded.png`); `No runs` + last-run status + `succeeded` is contradictory and showed `No pipelines match the current + filters.` with `Clear filters` and badge `2` + (`06_pipelines_filtered_empty.png`); the button restored the list and cleared + only the pipelines filter (the runs filter was left intact). + - **Persistence proof.** With runs status `failed` and pipelines `has_runs` + + last-run status `succeeded`, `run-as net.awan.pipelines cat + shared_prefs/pipelines_settings.xml` showed `run_filter_statuses=failed`, + `pipeline_filter_presence=has_runs`, `pipeline_filter_run_statuses=succeeded`. + `am force-stop net.awan.pipelines` (verified `pidof` empty) then `am start` + and a fresh `uiautomator dump` showed the pipelines list still narrowed with + badge `2` (`07_pipelines_filtered_after_relaunch.png`) and the runs list still + filtered to `failed` with badge `1` + (`08_runs_filtered_after_relaunch.png`), with no interaction. + - `adb -s emulator-5556 logcat -d | grep -c 'FATAL EXCEPTION'` and `… | grep -c + 'E AndroidRuntime'` each returned 0; no run was started from the app. +- **APK publish.** `app-debug.apk` was copied to + `~/.local/share/pipelines/data/artifacts/89/1/pipelines-debug-wip-1c925d7.apk` + (`1c925d7` = `git rev-parse --short HEAD`); `shasum -a 256` matched. `curl -I + http://10.0.0.249:8080/artifacts/89/1/pipelines-debug-wip-1c925d7.apk` + returned `HTTP/1.1 200 OK`, `Content-Type: + application/vnd.android.package-archive`, `Content-Length: 17912489`, and a + streamed `GET | shasum -a 256` returned the same `eaa34c0b…` as the local file. + The deterministic full-rebuild APK was installed on `emulator-5556` + (`adb -s emulator-5556 install -r`) and the pulled installed `base.apk` hashed + to `eaa34c0b…`, so the reviewed source is what was actually rendered. At + 17.1 MiB it exceeds the server's 8 MiB per-file inventory cap, so it is served + by direct URL only. + +Not verified in this pass: `:app:lintDebug` was not run; a real hardware fold to +the cover display was not exercised (all captures were at the inner panel's +2208x1840 width, so no narrow-width capture of the filter menu was taken); the +time-range facet was unit-tested but not exercised on device, and no before/after +baseline build was captured, since the change is additive and the default filters +are asserted to narrow nothing by the unit tests. + +### Filter menu overflow and accessibility (16 Oct 2026) + +A UI review of the pass above found the runs `DropdownMenu` grew unbounded with +the distinct-pipeline count (N=8 made it fill the whole window), clipping the +`Clear filters` item under the bottom gesture inset, and that neither the +active-filter count nor the checked facets were exposed to accessibility. Fixed +in `ui/components/FilterMenu.kt` only (`android/`, no new dependency): + +- **Bounded menu.** `filterMenuMaxHeight(screenHeightDp)` caps the menu at + `0.85 ×` the window height (window-derived, like the graph's height helpers, so + no new geometry literal), so the menu scrolls internally instead of growing + past the window as `N` rises. +- **Reset always visible.** The single `Clear filters` action is now a leading + header row (`Filters` + the reset `TextButton`, disabled when nothing is + active), so it is fully in view on open and never below the fold or clipped. +- **Above the navigation inset.** A trailing spacer of + `WindowInsets.navigationBars` bottom padding keeps the last option clear of the + gesture area at maximum scroll. +- **Accessible state.** The icon's description now folds in the count + (`filterMenuDescription`, e.g. "Filter runs, 2 filters active"), and + `FilterCheckItem` exposes `toggleableState` plus `Role.Checkbox`, so TalkBack + announces the count and which facet is checked. + +Re-verified on this tree (Homebrew JDK 25, Gradle 9.7.1, +`ANDROID_HOME=/Users/alan/Library/Android/sdk`, `--offline`): + +- `gradle --offline :app:testDebugUnitTest --rerun-tasks` → **185 tests, 0 + failures** (new `FilterMenuTest`: the height helper's proportional/positive + growth and the description's 0/1/2/negative wording). +- `gradle --offline :app:assembleDebug` succeeded → `app-debug.apk` **18,005,500 + bytes**, sha256 `7351c13b…`. +- On `emulator-5556` (2208x1840, density 420, dark mode) against + `ws://10.0.2.2:8080/connect`, captured with `android/scripts/capture_png.sh -s + emulator-5556` into `…/artifacts/89/4/`: + - The runs menu now has window `[1210,75]–[1945,1639]` (1564px = the 596dp cap), + ending ~138px above the gesture exclusion (y=1777); `Filters`/`Clear filters` + sit at the top (y=133–186) and after four swipes the last item `Last 30 days` + is at y=1466–1519, fully visible with the nav spacer below it + (`02_runs_filter_menu.png`). + - `uiautomator dump` reports the runs filter rows `checkable=true` with the + selected row `checked=true` (`Any time`), and the icon `content-desc` is + `Filter runs, 2 filters active` / `Filter runs, 1 filter active` matching + the badge (`03_runs_filtered_failed.png`, `01_runs_filtered_empty.png`). + - The pipelines menu (`Filters`/`Clear filters` at the top, `Runs` and `Last run + status` sections) is `[1542,93]–[1945,1622]`, also above the inset + (`04_pipelines_filter_menu.png`); `Has runs` + last-run `succeeded` filtered + the list (`05_…png`), `No runs` + `succeeded` showed `No pipelines match the + current filters.` with `Clear filters` (`06_…png`). + - **Persistence proof.** `am force-stop net.awan.pipelines` (verified `pidof` + empty) then `am start` and a fresh dump showed the pipelines screen still + filtered (badge `2`) and the runs list still `Filter runs, 1 filter active` + (`07_…png`, `08_…png`), with no interaction. + - `adb -s emulator-5556 logcat -d | grep -c 'FATAL EXCEPTION'` and `… | grep -c + 'E AndroidRuntime'` each returned 0. +- **APK publish.** `app-debug.apk` copied to + `…/artifacts/89/4/pipelines-debug-wip-1c925d7.apk` (`1c925d7` = `git rev-parse + --short HEAD`); `shasum -a 256` matched. `curl` against + `http://10.0.0.75:8080/artifacts/89/4/pipelines-debug-wip-1c925d7.apk` returned + `HTTP 200`, `Content-Type: application/vnd.android.package-archive`, + `Content-Length: 18005500`. + +Not verified: the **"nothing exists"** variants (`No pipelines are defined on this +server.` / `No runs have been recorded yet.`) were not captured — the live server +has both pipelines and runs, `list_runs` is not workspace-scoped, and the task +forbids touching the server's data, so there was no empty source to render them +against; the branch is unit-covered only indirectly. A real hardware fold and +`:app:lintDebug` were again not exercised. diff --git a/android/app/src/main/java/net/awan/pipelines/data/SettingsRepository.kt b/android/app/src/main/java/net/awan/pipelines/data/SettingsRepository.kt index dafb4fbf..230761d9 100644 --- a/android/app/src/main/java/net/awan/pipelines/data/SettingsRepository.kt +++ b/android/app/src/main/java/net/awan/pipelines/data/SettingsRepository.kt @@ -30,6 +30,25 @@ class SettingsRepository(context: Context) { private val _runSort = MutableStateFlow(prefs.getString(KEY_RUN_SORT, "").orEmpty()) val runSort: StateFlow = _runSort.asStateFlow() + // The chosen list filters, stored as their stable storage keys/encodings and + // resolved (with a default fallback for a stale/unknown value) by the list + // screens, so this repository stays unaware of the UI's filter enums. + private val _runFilterStatuses = MutableStateFlow(prefs.getString(KEY_RUN_FILTER_STATUSES, "").orEmpty()) + val runFilterStatuses: StateFlow = _runFilterStatuses.asStateFlow() + + private val _runFilterPipeline = MutableStateFlow(prefs.getString(KEY_RUN_FILTER_PIPELINE, "").orEmpty()) + val runFilterPipeline: StateFlow = _runFilterPipeline.asStateFlow() + + private val _runFilterTimeRange = MutableStateFlow(prefs.getString(KEY_RUN_FILTER_TIME_RANGE, "").orEmpty()) + val runFilterTimeRange: StateFlow = _runFilterTimeRange.asStateFlow() + + private val _pipelineFilterPresence = MutableStateFlow(prefs.getString(KEY_PIPELINE_FILTER_PRESENCE, "").orEmpty()) + val pipelineFilterPresence: StateFlow = _pipelineFilterPresence.asStateFlow() + + private val _pipelineFilterRunStatuses = + MutableStateFlow(prefs.getString(KEY_PIPELINE_FILTER_RUN_STATUSES, "").orEmpty()) + val pipelineFilterRunStatuses: StateFlow = _pipelineFilterRunStatuses.asStateFlow() + fun setServerUrl(value: String) { val trimmed = value.trim() _serverUrl.value = trimmed @@ -52,6 +71,31 @@ class SettingsRepository(context: Context) { prefs.edit().putString(KEY_RUN_SORT, value).apply() } + fun setRunFilterStatuses(value: String) { + _runFilterStatuses.value = value + prefs.edit().putString(KEY_RUN_FILTER_STATUSES, value).apply() + } + + fun setRunFilterPipeline(value: String) { + _runFilterPipeline.value = value + prefs.edit().putString(KEY_RUN_FILTER_PIPELINE, value).apply() + } + + fun setRunFilterTimeRange(value: String) { + _runFilterTimeRange.value = value + prefs.edit().putString(KEY_RUN_FILTER_TIME_RANGE, value).apply() + } + + fun setPipelineFilterPresence(value: String) { + _pipelineFilterPresence.value = value + prefs.edit().putString(KEY_PIPELINE_FILTER_PRESENCE, value).apply() + } + + fun setPipelineFilterRunStatuses(value: String) { + _pipelineFilterRunStatuses.value = value + prefs.edit().putString(KEY_PIPELINE_FILTER_RUN_STATUSES, value).apply() + } + /** True only when the user has explicitly supplied both required values. */ fun isConfigured(): Boolean = _serverUrl.value.isNotBlank() && _workspace.value.isNotBlank() @@ -60,5 +104,10 @@ class SettingsRepository(context: Context) { const val KEY_WORKSPACE = "workspace" const val KEY_PIPELINE_SORT = "pipeline_sort" const val KEY_RUN_SORT = "run_sort" + const val KEY_RUN_FILTER_STATUSES = "run_filter_statuses" + const val KEY_RUN_FILTER_PIPELINE = "run_filter_pipeline" + const val KEY_RUN_FILTER_TIME_RANGE = "run_filter_time_range" + const val KEY_PIPELINE_FILTER_PRESENCE = "pipeline_filter_presence" + const val KEY_PIPELINE_FILTER_RUN_STATUSES = "pipeline_filter_run_statuses" } } diff --git a/android/app/src/main/java/net/awan/pipelines/ui/AppViewModel.kt b/android/app/src/main/java/net/awan/pipelines/ui/AppViewModel.kt index e2c00e3e..d29e9ea8 100644 --- a/android/app/src/main/java/net/awan/pipelines/ui/AppViewModel.kt +++ b/android/app/src/main/java/net/awan/pipelines/ui/AppViewModel.kt @@ -52,6 +52,13 @@ class AppViewModel( val pipelineSort: StateFlow = settings.pipelineSort val runSort: StateFlow = settings.runSort + /** The stored pipeline/run filter keys; the list screens resolve them to filters. */ + val runFilterStatuses: StateFlow = settings.runFilterStatuses + val runFilterPipeline: StateFlow = settings.runFilterPipeline + val runFilterTimeRange: StateFlow = settings.runFilterTimeRange + val pipelineFilterPresence: StateFlow = settings.pipelineFilterPresence + val pipelineFilterRunStatuses: StateFlow = settings.pipelineFilterRunStatuses + private val _serverUrlDraft = MutableStateFlow(settings.serverUrl.value) val serverUrlDraft: StateFlow = _serverUrlDraft.asStateFlow() @@ -161,6 +168,16 @@ class AppViewModel( fun setRunSort(storageKey: String) = settings.setRunSort(storageKey) + fun setRunFilterStatuses(value: String) = settings.setRunFilterStatuses(value) + + fun setRunFilterPipeline(value: String) = settings.setRunFilterPipeline(value) + + fun setRunFilterTimeRange(value: String) = settings.setRunFilterTimeRange(value) + + fun setPipelineFilterPresence(value: String) = settings.setPipelineFilterPresence(value) + + fun setPipelineFilterRunStatuses(value: String) = settings.setPipelineFilterRunStatuses(value) + private fun awaitConnected() { viewModelScope.launch { val connected = withTimeoutOrNull(CONNECT_TIMEOUT_MILLIS) { diff --git a/android/app/src/main/java/net/awan/pipelines/ui/components/FilterMenu.kt b/android/app/src/main/java/net/awan/pipelines/ui/components/FilterMenu.kt new file mode 100644 index 00000000..7e6cca69 --- /dev/null +++ b/android/app/src/main/java/net/awan/pipelines/ui/components/FilterMenu.kt @@ -0,0 +1,178 @@ +package net.awan.pipelines.ui.components + +import androidx.compose.foundation.layout.Arrangement +import androidx.compose.foundation.layout.Box +import androidx.compose.foundation.layout.Row +import androidx.compose.foundation.layout.Spacer +import androidx.compose.foundation.layout.WindowInsets +import androidx.compose.foundation.layout.asPaddingValues +import androidx.compose.foundation.layout.fillMaxWidth +import androidx.compose.foundation.layout.height +import androidx.compose.foundation.layout.heightIn +import androidx.compose.foundation.layout.navigationBars +import androidx.compose.foundation.layout.padding +import androidx.compose.material.icons.Icons +import androidx.compose.material.icons.filled.Check +import androidx.compose.material.icons.filled.FilterList +import androidx.compose.material3.Badge +import androidx.compose.material3.BadgedBox +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.MaterialTheme +import androidx.compose.material3.Text +import androidx.compose.material3.TextButton +import androidx.compose.runtime.Composable +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.platform.LocalConfiguration +import androidx.compose.ui.semantics.Role +import androidx.compose.ui.semantics.role +import androidx.compose.ui.semantics.semantics +import androidx.compose.ui.semantics.toggleableState +import androidx.compose.ui.state.ToggleableState +import androidx.compose.ui.unit.Dp +import androidx.compose.ui.unit.dp +import net.awan.pipelines.ui.theme.pipelinesText + +/** + * The tallest a list-filter menu may grow, as a fraction of the window height. + * Derived from the window rather than a fixed row count so the menu stays inside + * the window and clear of the navigation inset no matter how many distinct + * pipelines the runs list contributes (N made the old menu unbounded); beyond + * this the menu scrolls internally. + */ +internal fun filterMenuMaxHeight(screenHeightDp: Int): Dp = (screenHeightDp * 0.85f).dp + +/** + * The filter icon's content description. With active filters the count is spoken + * ("Filter runs, 2 filters active") so the badge is not a purely visual signal; + * with none the plain [base] stands. + */ +internal fun filterMenuDescription(base: String, activeCount: Int): String = when { + activeCount <= 0 -> base + activeCount == 1 -> "$base, 1 filter active" + else -> "$base, $activeCount filters active" +} + +/** + * The shared list-filter control: a top-bar icon carrying an active-filter count + * badge, opening the caller's [optionContent] plus one [resetLabel] action. It is + * its own action with a distinct glyph and content description, so it cannot + * collide with the adjacent sort or refresh actions, and the same control serves + * both list widths (a `DropdownMenu` is not width-dependent geometry). + * + * [activeCount] is drawn as a numeric badge (0 hides it) and folded into the + * icon's description, so "filters are active" is never colour alone and the + * count is announced. The menu is capped at a window-derived [filterMenuMaxHeight] + * and the reset action is the first item, so the reset is always in view on open + * and the last option is reachable by scrolling rather than clipped; a trailing + * navigation-bar spacer keeps the final option above the gesture inset. + * [optionContent] receives a `dismiss` callback: a single-select entry calls it to + * close the menu, while a multi-select toggle simply omits it to keep the menu + * open. + */ +@Composable +fun FilterMenu( + activeCount: Int, + contentDescription: String, + resetLabel: String, + onReset: () -> Unit, + modifier: Modifier = Modifier, + optionContent: @Composable (dismiss: () -> Unit) -> Unit, +) { + var expanded by remember { mutableStateOf(false) } + val maxMenuHeight = filterMenuMaxHeight(LocalConfiguration.current.screenHeightDp) + val bottomInset = WindowInsets.navigationBars.asPaddingValues().calculateBottomPadding() + Box(modifier) { + BadgedBox( + badge = { + if (activeCount > 0) { + Badge { Text(activeCount.toString()) } + } + }, + ) { + IconButton(onClick = { expanded = true }) { + Icon( + Icons.Default.FilterList, + contentDescription = filterMenuDescription(contentDescription, activeCount), + ) + } + } + DropdownMenu( + expanded = expanded, + onDismissRequest = { expanded = false }, + modifier = Modifier.heightIn(max = maxMenuHeight), + ) { + Row( + modifier = Modifier.fillMaxWidth().padding(start = 16.dp, end = 4.dp), + verticalAlignment = Alignment.CenterVertically, + horizontalArrangement = Arrangement.SpaceBetween, + ) { + Text( + text = "Filters", + style = pipelinesText().label, + color = MaterialTheme.colorScheme.primary, + ) + TextButton( + onClick = { + onReset() + expanded = false + }, + enabled = activeCount > 0, + ) { + Text(resetLabel) + } + } + HorizontalDivider() + optionContent { expanded = false } + Spacer(Modifier.height(bottomInset)) + } + } +} + +/** + * One checkable filter entry, sharing the sort menu's leading-check idiom so the + * active value is conveyed by a glyph as well as by text, and exposing the + * checked state to accessibility ([toggleableState] plus [Role.Checkbox]) so + * TalkBack announces which facet is selected rather than only the label. The + * caller decides whether to dismiss: a single-select option closes the menu, a + * multi-select toggle leaves it open so several values can be gathered. + */ +@Composable +fun FilterCheckItem( + label: String, + checked: Boolean, + onClick: () -> Unit, +) { + DropdownMenuItem( + text = { Text(label) }, + onClick = onClick, + modifier = Modifier.semantics { + role = Role.Checkbox + toggleableState = if (checked) ToggleableState.On else ToggleableState.Off + }, + leadingIcon = { + if (checked) { + Icon(Icons.Default.Check, contentDescription = null) + } + }, + ) +} + +/** A small section caption inside a filter menu (Status/Pipeline/Time range). */ +@Composable +fun FilterSectionHeader(label: String) { + Text( + text = label, + style = pipelinesText().label, + color = MaterialTheme.colorScheme.primary, + modifier = Modifier.padding(horizontal = 12.dp, vertical = 8.dp), + ) +} diff --git a/android/app/src/main/java/net/awan/pipelines/ui/components/States.kt b/android/app/src/main/java/net/awan/pipelines/ui/components/States.kt index b7b4cd86..654df676 100644 --- a/android/app/src/main/java/net/awan/pipelines/ui/components/States.kt +++ b/android/app/src/main/java/net/awan/pipelines/ui/components/States.kt @@ -49,8 +49,18 @@ fun ErrorState(message: String, onRetry: (() -> Unit)? = null, modifier: Modifie } } +/** + * An empty-list message. [actionLabel]/[onAction] add one recovery action (the + * "nothing matches the current filters" case offers Clear filters); both are + * omitted for the "nothing exists" case, where there is nothing to clear. + */ @Composable -fun EmptyState(message: String, modifier: Modifier = Modifier) { +fun EmptyState( + message: String, + modifier: Modifier = Modifier, + actionLabel: String? = null, + onAction: (() -> Unit)? = null, +) { Column( modifier = modifier.fillMaxSize().padding(24.dp), horizontalAlignment = Alignment.CenterHorizontally, @@ -62,6 +72,11 @@ fun EmptyState(message: String, modifier: Modifier = Modifier) { style = MaterialTheme.typography.bodyLarge, color = MaterialTheme.colorScheme.onSurfaceVariant, ) + if (actionLabel != null && onAction != null) { + Button(onClick = onAction, modifier = Modifier.padding(top = 16.dp)) { + Text(actionLabel) + } + } } } diff --git a/android/app/src/main/java/net/awan/pipelines/ui/screens/ListFilter.kt b/android/app/src/main/java/net/awan/pipelines/ui/screens/ListFilter.kt new file mode 100644 index 00000000..29924d7b --- /dev/null +++ b/android/app/src/main/java/net/awan/pipelines/ui/screens/ListFilter.kt @@ -0,0 +1,246 @@ +package net.awan.pipelines.ui.screens + +import java.time.LocalDate +import java.time.ZoneId +import net.awan.pipelines.data.protocol.PipelineSummary +import net.awan.pipelines.data.protocol.RunSummary +import net.awan.pipelines.ui.components.RunState +import net.awan.pipelines.ui.components.runStateOf +import net.awan.pipelines.ui.parseInstant + +/** + * The run-list time windows offered by the filter control. [storageKey] is the + * stable value persisted in SharedPreferences; [fromStorage] tolerates a stale, + * unknown or blank stored value by returning [Default] ("any time"). + */ +enum class RunTimeRange(val label: String, val storageKey: String) { + AnyTime("Any time", "any_time"), + Today("Today", "today"), + Last7Days("Last 7 days", "last_7_days"), + Last30Days("Last 30 days", "last_30_days"); + + companion object { + val Default = AnyTime + + fun fromStorage(value: String?): RunTimeRange = + entries.firstOrNull { it.storageKey == value } ?: Default + } +} + +/** + * Whether the pipeline list only shows pipelines that have (or have not) + * recorded a run, persisted like [RunTimeRange]. [Default] is no narrowing. + */ +enum class RunPresence(val label: String, val storageKey: String) { + Any("Any", "any"), + HasRuns("Has runs", "has_runs"), + NoRuns("No runs", "no_runs"); + + companion object { + val Default = Any + + fun fromStorage(value: String?): RunPresence = + entries.firstOrNull { it.storageKey == value } ?: Default + } +} + +/** + * The statuses a run filter can select. The server's own run vocabulary + * (internal/pipeline/runs.go: queued/running/succeeded/failed/canceled/ + * interrupted); the app-only `active` usage bucket and the `unknown` fallback + * are deliberately not offered, so a status filter always names a real state. + */ +internal val RUN_STATUS_FILTERS: List = listOf( + RunState.Queued, + RunState.Running, + RunState.Succeeded, + RunState.Failed, + RunState.Canceled, + RunState.Interrupted, +) + +/** Adds [state] when absent, removes it when present — the multi-select toggle. */ +internal fun Set.toggle(state: RunState): Set = + if (state in this) this - state else this + state + +/** + * The stable stored form of a status set: the states' server status words in + * ordinal order, comma-joined. [RunState.label] is that word and is unique per + * state, so the encoding round-trips and stays meaningful in the prefs file. + */ +internal fun encodeRunStates(states: Set): String = + states.sortedBy { it.ordinal }.joinToString(",") { it.label } + +/** Decodes [encodeRunStates], dropping unknown or blank tokens rather than crashing. */ +internal fun decodeRunStates(value: String?): Set = + value.orEmpty().split(',').mapNotNull { token -> + val word = token.trim() + RunState.entries.firstOrNull { it.label == word } + }.toSet() + +/** + * The runs-list filters, each defaulting to "no narrowing" so the default value + * filters nothing. [activeCount] is the number of active facets (one per + * status/pipeline/time choice), used for the control's badge. + */ +data class RunFilters( + val statuses: Set = emptySet(), + val pipelineId: Long? = null, + val timeRange: RunTimeRange = RunTimeRange.Default, +) { + val activeCount: Int + get() = (if (statuses.isNotEmpty()) 1 else 0) + + (if (pipelineId != null) 1 else 0) + + (if (timeRange != RunTimeRange.Default) 1 else 0) + + val isActive: Boolean get() = activeCount > 0 + + companion object { + val Default = RunFilters() + + fun fromStorage(statuses: String?, pipelineId: String?, timeRange: String?): RunFilters = + RunFilters( + statuses = decodeRunStates(statuses), + pipelineId = pipelineId?.trim()?.takeIf { it.isNotEmpty() }?.toLongOrNull(), + timeRange = RunTimeRange.fromStorage(timeRange), + ) + } +} + +/** + * The pipelines-list run filters: whether a pipeline has any recorded run and + * the status of its most recent one. The name search stays a separate control + * (it narrows by text, not by run facts); these two are persisted per list. + */ +data class PipelineFilters( + val presence: RunPresence = RunPresence.Default, + val lastRunStatuses: Set = emptySet(), +) { + val activeCount: Int + get() = (if (presence != RunPresence.Default) 1 else 0) + + (if (lastRunStatuses.isNotEmpty()) 1 else 0) + + val isActive: Boolean get() = activeCount > 0 + + companion object { + val Default = PipelineFilters() + + fun fromStorage(presence: String?, lastRunStatuses: String?): PipelineFilters = + PipelineFilters( + presence = RunPresence.fromStorage(presence), + lastRunStatuses = decodeRunStates(lastRunStatuses), + ) + } +} + +/** True when [run] is in [statuses]; an empty set means "any status". */ +internal fun runMatchesStatuses(run: RunSummary, statuses: Set): Boolean = + statuses.isEmpty() || runStateOf(run.status) in statuses + +/** True when [run] belongs to [pipelineId]; null means "any pipeline". */ +internal fun runMatchesPipeline(run: RunSummary, pipelineId: Long?): Boolean = + pipelineId == null || run.pipelineId == pipelineId + +/** The run's start date in [zone], or null when blank/unparseable. */ +internal fun runLocalDate(createdAt: String, zone: ZoneId): LocalDate? = + parseInstant(createdAt)?.atZoneSameInstant(zone)?.toLocalDate() + +/** + * True when [run] falls inside [range] relative to [today]. A blank/unparseable + * timestamp and a future-dated run (clock skew) never match a finite window; + * [RunTimeRange.AnyTime] matches everything. The window is inclusive calendar + * days ending today: "last 7 days" covers today and the six days before it. + */ +internal fun runMatchesTimeRange( + run: RunSummary, + range: RunTimeRange, + today: LocalDate, + zone: ZoneId, +): Boolean { + if (range == RunTimeRange.AnyTime) return true + val date = runLocalDate(run.createdAt, zone) ?: return false + if (date.isAfter(today)) return false + return when (range) { + RunTimeRange.Today -> date == today + RunTimeRange.Last7Days -> !date.isBefore(today.minusDays(6)) + RunTimeRange.Last30Days -> !date.isBefore(today.minusDays(29)) + RunTimeRange.AnyTime -> true + } +} + +/** Every run facet combined with AND. */ +internal fun runMatchesFilters( + run: RunSummary, + filters: RunFilters, + today: LocalDate, + zone: ZoneId, +): Boolean = + runMatchesStatuses(run, filters.statuses) && + runMatchesPipeline(run, filters.pipelineId) && + runMatchesTimeRange(run, filters.timeRange, today, zone) + +/** Narrows [runs] by [filters]; the default filters change nothing. */ +internal fun filterRuns( + runs: List, + filters: RunFilters, + today: LocalDate, + zone: ZoneId, +): List = + if (!filters.isActive) runs else runs.filter { runMatchesFilters(it, filters, today, zone) } + +/** True when [presence] is satisfied by whether the pipeline [hasRun]. */ +internal fun pipelineMatchesPresence(presence: RunPresence, hasRun: Boolean): Boolean = when (presence) { + RunPresence.Any -> true + RunPresence.HasRuns -> hasRun + RunPresence.NoRuns -> !hasRun +} + +/** + * True when [latestRun]'s status is in [statuses]; an empty set means "any + * status" and a pipeline with no run never matches a selected status (there is + * no last-run status to compare), so the filter genuinely narrows. + */ +internal fun pipelineMatchesLastRunStatus(latestRun: RunSummary?, statuses: Set): Boolean = + statuses.isEmpty() || (latestRun != null && runStateOf(latestRun.status) in statuses) + +/** Every pipeline run facet combined with AND. */ +internal fun pipelineMatchesFilters(filters: PipelineFilters, latestRun: RunSummary?): Boolean = + pipelineMatchesPresence(filters.presence, latestRun != null) && + pipelineMatchesLastRunStatus(latestRun, filters.lastRunStatuses) + +/** + * Narrows [pipelines] by [filters]. Both facets depend on the run history, so + * while that history is still unknown (`runsKnown == false`) the list is left + * unfiltered rather than briefly hiding every pipeline. + */ +internal fun filterPipelines( + pipelines: List, + filters: PipelineFilters, + latestRuns: Map, + runsKnown: Boolean = true, +): List { + if (!filters.isActive || !runsKnown) return pipelines + return pipelines.filter { pipelineMatchesFilters(filters, latestRuns[it.id]) } +} + +/** One selectable pipeline in the run filter, named from its runs. */ +internal data class PipelineFilterOption(val id: Long, val name: String) + +/** + * The distinct pipelines present in [runs], each named by its most recent + * non-blank run name and ordered case-insensitively by name then id, so the + * run-list pipeline filter needs no separate pipeline fetch. A blank name falls + * back to the id so the entry is never unlabelled. + */ +internal fun pipelineFilterOptions(runs: List): List { + val names = LinkedHashMap() + for (run in runs) { + val current = names[run.pipelineId] + if (current == null || current.isBlank()) names[run.pipelineId] = run.name + } + return names.map { (id, name) -> PipelineFilterOption(id, name.ifBlank { "Pipeline $id" }) } + .sortedWith( + compareBy(String.CASE_INSENSITIVE_ORDER) { it.name } + .thenBy { it.id }, + ) +} diff --git a/android/app/src/main/java/net/awan/pipelines/ui/screens/PipelineListScreen.kt b/android/app/src/main/java/net/awan/pipelines/ui/screens/PipelineListScreen.kt index 0113f52d..04bd734a 100644 --- a/android/app/src/main/java/net/awan/pipelines/ui/screens/PipelineListScreen.kt +++ b/android/app/src/main/java/net/awan/pipelines/ui/screens/PipelineListScreen.kt @@ -14,6 +14,7 @@ import androidx.compose.material.icons.filled.AccountTree import androidx.compose.material.icons.filled.Refresh import androidx.compose.material.icons.filled.Search import androidx.compose.material3.ExperimentalMaterial3Api +import androidx.compose.material3.HorizontalDivider import androidx.compose.material3.Icon import androidx.compose.material3.IconButton import androidx.compose.material3.MaterialTheme @@ -37,9 +38,13 @@ import net.awan.pipelines.data.protocol.PipelineSummary import net.awan.pipelines.ui.AppViewModel import net.awan.pipelines.ui.components.EmptyState import net.awan.pipelines.ui.components.ErrorState +import net.awan.pipelines.ui.components.FilterCheckItem +import net.awan.pipelines.ui.components.FilterMenu +import net.awan.pipelines.ui.components.FilterSectionHeader import net.awan.pipelines.ui.components.ListRow import net.awan.pipelines.ui.components.LoadingState import net.awan.pipelines.ui.components.PaneIdentity +import net.awan.pipelines.ui.components.RunState import net.awan.pipelines.ui.components.RunStatusChip import net.awan.pipelines.ui.components.SortMenu import net.awan.pipelines.ui.theme.pipelinesText @@ -57,6 +62,9 @@ fun PipelineListScreen( val runsState by vm.runs.collectAsStateWithLifecycle() val sortKey by vm.pipelineSort.collectAsStateWithLifecycle() val sort = PipelineSort.fromStorage(sortKey) + val presenceKey by vm.pipelineFilterPresence.collectAsStateWithLifecycle() + val runStatusKey by vm.pipelineFilterRunStatuses.collectAsStateWithLifecycle() + val filters = PipelineFilters.fromStorage(presenceKey, runStatusKey) var query by remember { mutableStateOf("") } // The last-run line joins list_runs onto the pipelines client-side; runs are @@ -80,6 +88,12 @@ fun PipelineListScreen( // the explicit "no runs recorded" claim. val runsKnown = runsState.data != null + val onClearFilters: () -> Unit = { + vm.setPipelineFilterPresence("") + vm.setPipelineFilterRunStatuses("") + query = "" + } + // A covered pane shows its compact identity only; the search field and list // must never be drawn squeezed into the peek strip. if (covered) { @@ -98,6 +112,12 @@ fun PipelineListScreen( TopAppBar( title = { Text("Pipelines") }, actions = { + PipelineFilterControl( + filters = filters, + onPresence = { vm.setPipelineFilterPresence(it.storageKey) }, + onRunStatuses = { vm.setPipelineFilterRunStatuses(encodeRunStates(it)) }, + onClear = onClearFilters, + ) SortMenu( options = PipelineSort.entries, selected = sort, @@ -131,15 +151,34 @@ fun PipelineListScreen( state.loading && state.data == null -> LoadingState("Loading pipelines…") state.error != null && state.data == null -> ErrorState(state.error!!, onRetry = vm::refreshPipelines) else -> { - val items = remember(state.data, query, sort, latestRuns) { - sortPipelines(state.data ?: emptyList(), sort, latestRuns) - .filter { it.name.contains(query, ignoreCase = true) } + val all = state.data ?: emptyList() + val items = remember(all, query, sort, latestRuns, filters, runsKnown) { + filterPipelines( + sortPipelines(all, sort, latestRuns), + filters, + latestRuns, + runsKnown, + ).filter { it.name.contains(query, ignoreCase = true) } } if (items.isEmpty()) { - EmptyState( - if (query.isBlank()) "No pipelines are defined on this server." - else "No pipelines match \"$query\".", - ) + if (all.isEmpty()) { + // Nothing exists: neither the search nor the filters can + // reveal a pipeline, so there is no clear action. + EmptyState("No pipelines are defined on this server.") + } else { + val queryActive = query.isNotBlank() + val filtersActive = filters.isActive && runsKnown + EmptyState( + message = when { + queryActive && filtersActive -> + "No pipelines match the current search and filters." + queryActive -> "No pipelines match \"$query\"." + else -> "No pipelines match the current filters." + }, + actionLabel = "Clear filters", + onAction = onClearFilters, + ) + } } else { LazyColumn( modifier = Modifier.fillMaxSize(), @@ -169,6 +208,41 @@ fun PipelineListScreen( } } +/** + * The pipelines-list run filter control: presence (has/no runs) and the + * most-recent run's status (multi-select), with the shared active-count badge + * and one Clear filters action. The name search stays a separate field. + */ +@Composable +private fun PipelineFilterControl( + filters: PipelineFilters, + onPresence: (RunPresence) -> Unit, + onRunStatuses: (Set) -> Unit, + onClear: () -> Unit, +) { + FilterMenu( + activeCount = filters.activeCount, + contentDescription = "Filter pipelines", + resetLabel = "Clear filters", + onReset = onClear, + ) { dismiss -> + FilterSectionHeader("Runs") + RunPresence.entries.forEach { presence -> + FilterCheckItem(presence.label, filters.presence == presence) { + onPresence(presence) + dismiss() + } + } + HorizontalDivider() + FilterSectionHeader("Last run status") + RUN_STATUS_FILTERS.forEach { state -> + FilterCheckItem(state.label, state in filters.lastRunStatuses) { + onRunStatuses(filters.lastRunStatuses.toggle(state)) + } + } + } +} + /** * One pipeline as a row of the shared real list: a leading workflow glyph, the * name as the title, the id/version/stage-count as the secondary line and the diff --git a/android/app/src/main/java/net/awan/pipelines/ui/screens/RunHistoryScreen.kt b/android/app/src/main/java/net/awan/pipelines/ui/screens/RunHistoryScreen.kt index 0606a900..e90c6fc5 100644 --- a/android/app/src/main/java/net/awan/pipelines/ui/screens/RunHistoryScreen.kt +++ b/android/app/src/main/java/net/awan/pipelines/ui/screens/RunHistoryScreen.kt @@ -20,6 +20,7 @@ import androidx.compose.material.icons.filled.Refresh import androidx.compose.material3.Card import androidx.compose.material3.CircularProgressIndicator import androidx.compose.material3.ExperimentalMaterial3Api +import androidx.compose.material3.HorizontalDivider import androidx.compose.material3.Icon import androidx.compose.material3.IconButton import androidx.compose.material3.MaterialTheme @@ -47,7 +48,11 @@ import net.awan.pipelines.ui.AppViewModel import net.awan.pipelines.ui.components.RunState import net.awan.pipelines.ui.components.RunStatusChip import net.awan.pipelines.ui.components.RunStatusIcon +import net.awan.pipelines.ui.components.EmptyState import net.awan.pipelines.ui.components.ErrorState +import net.awan.pipelines.ui.components.FilterCheckItem +import net.awan.pipelines.ui.components.FilterMenu +import net.awan.pipelines.ui.components.FilterSectionHeader import net.awan.pipelines.ui.components.ListRow import net.awan.pipelines.ui.components.LoadingState import net.awan.pipelines.ui.components.PaneIdentity @@ -72,8 +77,23 @@ fun RunHistoryScreen( val state by vm.runs.collectAsStateWithLifecycle() val sortKey by vm.runSort.collectAsStateWithLifecycle() val sort = RunSort.fromStorage(sortKey) + val statusFilterKey by vm.runFilterStatuses.collectAsStateWithLifecycle() + val pipelineFilterKey by vm.runFilterPipeline.collectAsStateWithLifecycle() + val timeRangeKey by vm.runFilterTimeRange.collectAsStateWithLifecycle() + val filters = RunFilters.fromStorage(statusFilterKey, pipelineFilterKey, timeRangeKey) LaunchedEffect(Unit) { vm.refreshRuns() } + val onClearFilters: () -> Unit = { + vm.setRunFilterStatuses("") + vm.setRunFilterPipeline("") + vm.setRunFilterTimeRange("") + } + // The pipeline filter choices come from the runs already in hand, folded once + // per history load rather than rebuilt on every recomposition. + val pipelineOptions = remember(state.data) { + pipelineFilterOptions(state.data?.runs.orEmpty()) + } + // A covered pane shows its compact identity only; the usage block, sticky day // headers and run rows must never be drawn squeezed into the peek strip. if (covered) { @@ -92,6 +112,14 @@ fun RunHistoryScreen( TopAppBar( title = { Text(if (filterPipelineId == null) "Runs" else "Runs for this pipeline") }, actions = { + RunFilterControl( + filters = filters, + pipelines = pipelineOptions, + onStatuses = { vm.setRunFilterStatuses(encodeRunStates(it)) }, + onPipeline = { vm.setRunFilterPipeline(it?.toString().orEmpty()) }, + onTimeRange = { vm.setRunFilterTimeRange(it.storageKey) }, + onClear = onClearFilters, + ) SortMenu( options = RunSort.entries, selected = sort, @@ -120,14 +148,65 @@ fun RunHistoryScreen( filterPipelineId = filterPipelineId, selectedRunId = selectedRunId, sort = sort, + filters = filters, error = state.error, onOpenRun = onOpenRun, + onClearFilters = onClearFilters, modifier = Modifier.padding(padding), ) } } } +/** + * The runs-list filter control: status (multi-select), pipeline (single-select) + * and time range, each section labelled inside one menu, with the shared + * active-count badge and one Clear filters action. + */ +@Composable +private fun RunFilterControl( + filters: RunFilters, + pipelines: List, + onStatuses: (Set) -> Unit, + onPipeline: (Long?) -> Unit, + onTimeRange: (RunTimeRange) -> Unit, + onClear: () -> Unit, +) { + FilterMenu( + activeCount = filters.activeCount, + contentDescription = "Filter runs", + resetLabel = "Clear filters", + onReset = onClear, + ) { dismiss -> + FilterSectionHeader("Status") + RUN_STATUS_FILTERS.forEach { state -> + FilterCheckItem(state.label, state in filters.statuses) { + onStatuses(filters.statuses.toggle(state)) + } + } + HorizontalDivider() + FilterSectionHeader("Pipeline") + FilterCheckItem("Any pipeline", filters.pipelineId == null) { + onPipeline(null) + dismiss() + } + pipelines.forEach { option -> + FilterCheckItem(option.name, filters.pipelineId == option.id) { + onPipeline(option.id) + dismiss() + } + } + HorizontalDivider() + FilterSectionHeader("Time range") + RunTimeRange.entries.forEach { range -> + FilterCheckItem(range.label, filters.timeRange == range) { + onTimeRange(range) + dismiss() + } + } + } +} + @OptIn(ExperimentalFoundationApi::class) @Composable private fun RunHistoryContent( @@ -136,21 +215,26 @@ private fun RunHistoryContent( filterPipelineId: Long?, selectedRunId: Long?, sort: RunSort, + filters: RunFilters, error: String?, onOpenRun: (Long) -> Unit, + onClearFilters: () -> Unit, modifier: Modifier = Modifier, ) { + val zone = ZoneId.systemDefault() + val today = LocalDate.now(zone) + // The structural pipeline scope (a run list opened for one pipeline) and the + // user's filters both narrow, with AND semantics; the run history is folded + // once here, not per recomposition. + val scoped = remember(runs, filterPipelineId) { + if (filterPipelineId == null) runs else runs.filter { it.pipelineId == filterPipelineId } + } + val matched = remember(scoped, filters, today, zone) { filterRuns(scoped, filters, today, zone) } // Day-grouping is derived once per data/order change (single pass, keyed on // the stable source list), not per recomposition. The chosen comparator orders // the runs first; the groups then follow the order their first run appears in. - val groups = remember(runs, filterPipelineId, sort) { - val filtered = if (filterPipelineId == null) { - runs - } else { - runs.filter { it.pipelineId == filterPipelineId } - } - val zone = ZoneId.systemDefault() - groupRunsByDay(filtered, LocalDate.now(zone), zone, runComparator(sort)) + val groups = remember(matched, today, zone, sort) { + groupRunsByDay(matched, today, zone, runComparator(sort)) } LazyColumn( @@ -162,13 +246,20 @@ private fun RunHistoryContent( UsageMetrics(usage, Modifier.padding(horizontal = 16.dp, vertical = 8.dp)) } } - if (groups.isEmpty()) { + if (scoped.isEmpty()) { + // Nothing exists at all: no filter could reveal a run, so there is no + // clear action. item(key = "runs-empty") { - Text( - "No runs have been recorded yet.", - style = pipelinesText().body, - color = MaterialTheme.colorScheme.onSurfaceVariant, - modifier = Modifier.padding(24.dp), + EmptyState("No runs have been recorded yet.") + } + } else if (matched.isEmpty()) { + // Runs exist but every one is filtered out: distinguish this from the + // "nothing exists" case and offer the one clear action. + item(key = "runs-filtered-empty") { + EmptyState( + message = "No runs match the current filters.", + actionLabel = "Clear filters", + onAction = onClearFilters, ) } } else { @@ -376,7 +467,7 @@ internal fun groupRunsByDay( } internal fun dayLabel(createdAt: String, today: LocalDate, zone: ZoneId): String { - val date = runDate(createdAt, zone) ?: return "Unknown date" + val date = runLocalDate(createdAt, zone) ?: return "Unknown date" return when (date) { today -> "Today" today.minusDays(1) -> "Yesterday" @@ -384,12 +475,5 @@ internal fun dayLabel(createdAt: String, today: LocalDate, zone: ZoneId): String } } -private fun runDate(createdAt: String, zone: ZoneId): LocalDate? { - if (createdAt.isBlank()) return null - return runCatching { - OffsetDateTime.parse(createdAt).atZoneSameInstant(zone).toLocalDate() - }.getOrNull() -} - private val DAY_FORMAT: DateTimeFormatter = DateTimeFormatter.ofPattern("d MMM yyyy") private val START_FORMAT: DateTimeFormatter = DateTimeFormatter.ofPattern("d MMM HH:mm") diff --git a/android/app/src/test/java/net/awan/pipelines/ui/components/FilterMenuTest.kt b/android/app/src/test/java/net/awan/pipelines/ui/components/FilterMenuTest.kt new file mode 100644 index 00000000..567c306d --- /dev/null +++ b/android/app/src/test/java/net/awan/pipelines/ui/components/FilterMenuTest.kt @@ -0,0 +1,29 @@ +package net.awan.pipelines.ui.components + +import androidx.compose.ui.unit.dp +import org.junit.Assert.assertEquals +import org.junit.Assert.assertTrue +import org.junit.Test + +class FilterMenuTest { + + // --- menu height ------------------------------------------------------------ + + @Test + fun menuHeightGrowsWithTheWindowAndStaysPositive() { + assertEquals(0.85f * 700f, filterMenuMaxHeight(700).value, 0.01f) + assertTrue(filterMenuMaxHeight(360) > 0.dp) + assertTrue(filterMenuMaxHeight(700) > filterMenuMaxHeight(360)) + } + + // --- accessibility description --------------------------------------------- + + @Test + fun descriptionAnnouncesTheActiveCount() { + assertEquals("Filter runs", filterMenuDescription("Filter runs", 0)) + assertEquals("Filter runs, 1 filter active", filterMenuDescription("Filter runs", 1)) + assertEquals("Filter runs, 2 filters active", filterMenuDescription("Filter runs", 2)) + // A negative count (defensive) is treated as no filters, never "-1 filters". + assertEquals("Filter pipelines", filterMenuDescription("Filter pipelines", -1)) + } +} diff --git a/android/app/src/test/java/net/awan/pipelines/ui/screens/ListFilterTest.kt b/android/app/src/test/java/net/awan/pipelines/ui/screens/ListFilterTest.kt new file mode 100644 index 00000000..d07e6d80 --- /dev/null +++ b/android/app/src/test/java/net/awan/pipelines/ui/screens/ListFilterTest.kt @@ -0,0 +1,231 @@ +package net.awan.pipelines.ui.screens + +import java.time.LocalDate +import java.time.ZoneOffset +import net.awan.pipelines.data.protocol.PipelineSummary +import net.awan.pipelines.data.protocol.RunSummary +import net.awan.pipelines.ui.components.RunState +import org.junit.Assert.assertEquals +import org.junit.Assert.assertFalse +import org.junit.Assert.assertTrue +import org.junit.Test + +class ListFilterTest { + + private val today = LocalDate.of(2026, 10, 16) + private val zone = ZoneOffset.UTC + + private fun pipeline(id: Long, name: String = "p$id") = + PipelineSummary(id = id, name = name, version = 1, stages = 1) + + private fun run( + id: Long, + pipelineId: Long = 1, + name: String = "p$pipelineId", + status: String = "succeeded", + createdAt: String = "2026-10-16T10:00:00Z", + finishedAt: String = "2026-10-16T10:00:10Z", + ) = RunSummary( + id = id, + pipelineId = pipelineId, + name = name, + status = status, + createdAt = createdAt, + finishedAt = finishedAt, + ) + + // --- stored-value tolerance ------------------------------------------------- + + @Test + fun runFiltersFromStorageParsesEveryFacetAndFallsBackForStaleValues() { + assertEquals( + RunFilters(setOf(RunState.Succeeded, RunState.Failed), 7L, RunTimeRange.Last7Days), + RunFilters.fromStorage("succeeded,failed", "7", "last_7_days"), + ) + // An unknown status token is dropped rather than crashing. + assertEquals( + setOf(RunState.Succeeded), + RunFilters.fromStorage("succeeded,bogus", null, null).statuses, + ) + // Stale/blank/unknown values fall back to the defaults. + assertEquals(RunFilters.Default, RunFilters.fromStorage(null, null, null)) + assertEquals(RunFilters.Default, RunFilters.fromStorage("", "", "")) + assertEquals(RunFilters.Default, RunFilters.fromStorage("nope", "not-a-number", "no_such_range")) + } + + @Test + fun pipelineFiltersFromStorageParsesAndFallsBack() { + assertEquals( + PipelineFilters(RunPresence.NoRuns, setOf(RunState.Failed)), + PipelineFilters.fromStorage("no_runs", "failed"), + ) + assertEquals(PipelineFilters.Default, PipelineFilters.fromStorage(null, null)) + assertEquals(PipelineFilters.Default, PipelineFilters.fromStorage("garbage", "garbage")) + } + + @Test + fun encodeDecodeRoundTripsAndToleratesGarbage() { + val states = setOf(RunState.Failed, RunState.Queued) + assertEquals(states, decodeRunStates(encodeRunStates(states))) + // Ordinal order, so the stored string is stable whatever the set order. + assertEquals("queued,failed", encodeRunStates(states)) + assertEquals(emptySet(), decodeRunStates("")) + assertEquals(emptySet(), decodeRunStates(null)) + assertEquals(setOf(RunState.Running), decodeRunStates("bogus,running,,")) + } + + // --- run status ------------------------------------------------------------- + + @Test + fun anEmptyStatusSetMatchesAnyStatus() { + assertTrue(runMatchesStatuses(run(1, status = "running"), emptySet())) + assertTrue(runMatchesStatuses(run(1, status = ""), emptySet())) + } + + @Test + fun statusFilterIsTheUnionOfTheSelectedStates() { + val statuses = setOf(RunState.Failed, RunState.Canceled) + assertTrue(runMatchesStatuses(run(1, status = "failed"), statuses)) + assertTrue(runMatchesStatuses(run(2, status = "canceled"), statuses)) + assertFalse(runMatchesStatuses(run(3, status = "succeeded"), statuses)) + // The app-only buckets are not offered, so they never match a selection. + assertFalse(runMatchesStatuses(run(4, status = "active"), statuses)) + assertFalse(runMatchesStatuses(run(5, status = "made-up"), statuses)) + } + + // --- run pipeline ----------------------------------------------------------- + + @Test + fun pipelineFilterMatchesOnlyThatPipelineAndNullMeansAny() { + assertTrue(runMatchesPipeline(run(1, pipelineId = 5), 5)) + assertFalse(runMatchesPipeline(run(1, pipelineId = 5), 6)) + assertTrue(runMatchesPipeline(run(1, pipelineId = 5), null)) + } + + // --- run time range --------------------------------------------------------- + + @Test + fun timeRangeWindowsAreInclusiveCalendarDaysEndingToday() { + fun at(date: String) = run(1, createdAt = "${date}T09:00:00Z") + // Today. + assertTrue(runMatchesTimeRange(at("2026-10-16"), RunTimeRange.Today, today, zone)) + assertFalse(runMatchesTimeRange(at("2026-10-15"), RunTimeRange.Today, today, zone)) + // Last 7 days covers today and the six days before it. + assertTrue(runMatchesTimeRange(at("2026-10-16"), RunTimeRange.Last7Days, today, zone)) + assertTrue(runMatchesTimeRange(at("2026-10-10"), RunTimeRange.Last7Days, today, zone)) + assertFalse(runMatchesTimeRange(at("2026-10-09"), RunTimeRange.Last7Days, today, zone)) + // Last 30 days covers today and the twenty-nine days before it. + assertTrue(runMatchesTimeRange(at("2026-09-17"), RunTimeRange.Last30Days, today, zone)) + assertFalse(runMatchesTimeRange(at("2026-09-16"), RunTimeRange.Last30Days, today, zone)) + // Any time matches an old run and a blank timestamp alike. + assertTrue(runMatchesTimeRange(at("2020-01-01"), RunTimeRange.AnyTime, today, zone)) + assertTrue(runMatchesTimeRange(run(1, createdAt = ""), RunTimeRange.AnyTime, today, zone)) + } + + @Test + fun blankOrFutureTimestampsNeverMatchAFiniteRange() { + assertFalse(runMatchesTimeRange(run(1, createdAt = ""), RunTimeRange.Today, today, zone)) + assertFalse(runMatchesTimeRange(run(1, createdAt = "not-a-date"), RunTimeRange.Last7Days, today, zone)) + // A future-dated run (clock skew) is outside every past window. + assertFalse(runMatchesTimeRange(run(1, createdAt = "2026-10-17T09:00:00Z"), RunTimeRange.Today, today, zone)) + assertFalse(runMatchesTimeRange(run(1, createdAt = "2026-10-17T09:00:00Z"), RunTimeRange.Last7Days, today, zone)) + } + + // --- run combination -------------------------------------------------------- + + @Test + fun defaultRunFiltersNarrowNothing() { + val runs = listOf(run(1, status = "running", createdAt = ""), run(2, status = "failed")) + assertEquals(runs, filterRuns(runs, RunFilters.Default, today, zone)) + } + + @Test + fun runFacetsCombineWithAnd() { + val filters = RunFilters( + statuses = setOf(RunState.Succeeded), + pipelineId = 2L, + timeRange = RunTimeRange.Today, + ) + val runs = listOf( + // Right status but wrong pipeline. + run(1, pipelineId = 1, status = "succeeded", createdAt = "2026-10-16T08:00:00Z"), + // Right pipeline but wrong status. + run(2, pipelineId = 2, status = "failed", createdAt = "2026-10-16T08:00:00Z"), + // Right pipeline/status but outside today. + run(3, pipelineId = 2, status = "succeeded", createdAt = "2026-10-10T08:00:00Z"), + // The one match. + run(4, pipelineId = 2, status = "succeeded", createdAt = "2026-10-16T08:00:00Z"), + ) + assertEquals(listOf(4L), filterRuns(runs, filters, today, zone).map { it.id }) + } + + // --- pipeline run facets ---------------------------------------------------- + + @Test + fun presenceSplitsPipelinesByWhetherTheyHaveARecordedRun() { + assertTrue(pipelineMatchesPresence(RunPresence.Any, hasRun = false)) + assertTrue(pipelineMatchesPresence(RunPresence.HasRuns, hasRun = true)) + assertFalse(pipelineMatchesPresence(RunPresence.HasRuns, hasRun = false)) + assertTrue(pipelineMatchesPresence(RunPresence.NoRuns, hasRun = false)) + assertFalse(pipelineMatchesPresence(RunPresence.NoRuns, hasRun = true)) + } + + @Test + fun lastRunStatusExcludesRunlessPipelinesAndEmptyMeansAny() { + val failed = setOf(RunState.Failed) + assertTrue(pipelineMatchesLastRunStatus(run(1, status = "failed"), failed)) + assertFalse(pipelineMatchesLastRunStatus(run(1, status = "succeeded"), failed)) + // No run at all: there is no last-run status, so a selection never matches. + assertFalse(pipelineMatchesLastRunStatus(null, failed)) + // An empty selection matches a runless pipeline and any status. + assertTrue(pipelineMatchesLastRunStatus(null, emptySet())) + assertTrue(pipelineMatchesLastRunStatus(run(1, status = "running"), emptySet())) + } + + @Test + fun defaultPipelineFiltersNarrowNothing() { + val pipelines = listOf(pipeline(1), pipeline(2)) + assertEquals(pipelines, filterPipelines(pipelines, PipelineFilters.Default, emptyMap())) + } + + @Test + fun pipelineFiltersCombineWithAnd() { + val filters = PipelineFilters( + presence = RunPresence.HasRuns, + lastRunStatuses = setOf(RunState.Failed), + ) + val latest = mapOf( + 1L to run(1, pipelineId = 1, status = "succeeded"), + 2L to run(2, pipelineId = 2, status = "failed"), + ) + val pipelines = listOf(pipeline(1), pipeline(2), pipeline(3)) + // No runs (3) fails presence; succeeded last run (1) fails the status. + assertEquals(listOf(2L), filterPipelines(pipelines, filters, latest).map { it.id }) + } + + @Test + fun pipelineFiltersLeaveTheListUnfilteredUntilRunsAreKnown() { + val filters = PipelineFilters(presence = RunPresence.NoRuns) + val pipelines = listOf(pipeline(1)) + // Runs not loaded yet: filtering by them would briefly hide everything. + assertEquals(pipelines, filterPipelines(pipelines, filters, emptyMap(), runsKnown = false)) + // Once known, the filter applies (pipeline 1 has no run). + assertEquals(pipelines, filterPipelines(pipelines, filters, emptyMap(), runsKnown = true)) + } + + // --- pipeline options ------------------------------------------------------- + + @Test + fun pipelineFilterOptionsAreDistinctNamedFromRunsAndSorted() { + val runs = listOf( + run(1, pipelineId = 7, name = "Zeta"), + run(2, pipelineId = 3, name = "alpha"), + run(3, pipelineId = 7, name = "Zeta"), + run(4, pipelineId = 9, name = ""), + ) + val options = pipelineFilterOptions(runs) + assertEquals(listOf(3L, 9L, 7L), options.map { it.id }) + assertEquals(listOf("alpha", "Pipeline 9", "Zeta"), options.map { it.name }) + assertEquals(3, options.size) + } +} From 9c47527def238af76aa5b201ed051ee7a758ec85 Mon Sep 17 00:00:00 2001 From: Alan Silva Date: Fri, 16 Oct 2026 07:04:48 +0100 Subject: [PATCH 6/9] Make executed vs not-executed unmistakable in the run graph Carry the two states structurally instead of by fading, so the difference survives a screenshot, a dim screen and a colour-blind reader. - Executed edges: solid full-colour stroke plus an arrowhead. - Not-executed edges: dashed muted stroke (INACTIVE_DASH_EFFECT), no arrowhead. - Executed nodes: keep their fill and normal border. - Not-executed nodes: no fill, dashed muted border and a muted but legible label. - Add a one-line legend (GRAPH_LEGEND / GraphLegendEntry / LegendSwatch) pinned TopStart, rendered only when a run is selected. - Replace the private EdgeLayout.isExecuted/inline visited check with the shared edgeIsExecuted/stageIsExecuted predicates and remove the alpha-based dimming. - Update the KDoc and the run Graph tab help text ("solid ... dashed and outlined"). Tests: executed/inactive predicates over the definition view and a RunGraphState, the dash pattern as a positive even-length rhythm, and the legend naming both states with executed first. --- android/README.md | 108 ++++++++- .../awan/pipelines/ui/graph/WorkflowGraph.kt | 220 ++++++++++++++---- .../pipelines/ui/screens/RunDetailScreen.kt | 2 +- .../pipelines/ui/graph/WorkflowGraphTest.kt | 58 +++++ 4 files changed, 340 insertions(+), 48 deletions(-) diff --git a/android/README.md b/android/README.md index 9fabf032..1a5ac8db 100644 --- a/android/README.md +++ b/android/README.md @@ -108,8 +108,12 @@ stops it. 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. Edges are drawn as + fallback), loops and branches, pan/zoom, and run highlighting (under a run the + executed stage/route is a solid full-colour stroke with an arrowhead and a + filled, normal-bordered node, while a not-executed one is a dashed, arrowless + muted stroke with a hollow, dashed-bordered node and a muted label, plus a + one-line legend; the definition-only view is unchanged) plus a screen-reader + description. Edges are drawn as axis-aligned orthogonal polylines like the TUI (`routePoints` computes the path once per layout and stores it on `EdgeLayout.points`), and each arrowhead points along its route's final segment rather than the from-to chord. Pinch @@ -1757,3 +1761,103 @@ has both pipelines and runs, `list_runs` is not workspace-scoped, and the task forbids touching the server's data, so there was no empty source to render them against; the branch is unit-covered only indirectly. A real hardware fold and `:app:lintDebug` were again not exercised. + +## Executed vs not-executed is structural, with a legend (16 Oct 2026) + +`android/` only. Nothing in the Pipelines server, its Go source, the Docker/ +compose files or the installer was touched, no dependency was added, no run was +started from the app, and every `adb`/emulator command targeted `emulator-5556` +(lane A's `emulator-5554` was never used; the attached Pixel was never installed +on or driven). + +- **The two states differ by shape, fill and border style, not by a faded tint.** + `ui/graph/WorkflowGraph.kt` now draws an executed route as a solid full-colour + stroke **with** its arrowhead, and a not-executed route as a dashed muted + stroke **without** an arrowhead. A node the run visited is filled with its + normal border; a node it did not is hollow (no fill) with a dashed muted border + and a muted-but-legible `onSurfaceVariant` label. The old `alpha = 0.25f` / + `0.3f` dimming is gone, so the distinction survives a screenshot, a dim screen + and a colour-blind reader. +- **Shared, testable predicates.** `stageIsExecuted(key, runState)` and + `edgeIsExecuted(edge, runState)` (both `runState == null` ⇒ executed) replace + the private `EdgeLayout.isExecuted` and the inline `visitedStages` check, so + drawing and the screen-reader `graphDescription` share one definition. +- **Dash token.** `INACTIVE_DASH_INTERVALS = floatArrayOf(14f, 10f)` is the one + line-style token; `INACTIVE_DASH_EFFECT` is the lazily-built `PathEffect` used + by both the not-executed edges and the not-executed node borders, so it is + never rebuilt per frame. Node/edge geometry keeps the existing layout + tokens/insets — the only new literals are the dash rhythm and the compact + legend swatch, not graph geometry. +- **Compact legend.** `GRAPH_LEGEND` (a solid, arrowed swatch labelled + `Executed`; a dashed, arrowless swatch labelled `Not executed`) is drawn as a + one-line `Row` pinned to the graph's top-start, opposite the Fit/expand + controls, so it stays visible with the top of the panel even on a short/narrow + window. It renders only when a run is selected. +- **The definition-only view is untouched.** With no `runState` every + stage/route is executed, so the graph renders exactly as before (solid, filled, + arrowed) and the legend is not composed — confirmed against the pipeline Graph + tab. +- The run-detail Graph tab's help line was updated from "highlighted … dimmed" to + "solid … dashed and outlined". + +Verification (macOS; Homebrew `openjdk@17` at +`JAVA_HOME=/opt/homebrew/opt/openjdk@17/libexec/openjdk.jdk/Contents/Home`, +Gradle 8.11.1, `ANDROID_HOME=/Users/alan/Library/Android/sdk`, `--offline`): + +- `gradle --offline clean :app:testDebugUnitTest :app:assembleDebug` → + **188 tests, 0 failures, 0 errors**; `WorkflowGraphTest` **34** tests (3 new: + the executed predicates over the definition view and a `RunGraphState`, the + dash pattern being a positive even-length rhythm, and the legend naming both + states with executed first). The clean `:app:assembleDebug` produced + `app-debug.apk` **17,912,489 bytes**, sha256 + `49631a3a2763bf1d9232eb9e7c8f9ff3edd719355ac0a99b7c91f7f40c3a1cc5` (two clean + rebuilds were byte-identical; this is the published artifact). +- A partly-executed run (run 77, pipeline id 11 "Focused tweak - implement review + commit": `implementer`, `reviewer`, `ui_reviewer` ran, `committer` did not) was + opened in the app against the live server `ws://10.0.2.2:8080/connect` in dark + mode, driven with `adb shell input`, and every capture below was written with + `android/scripts/capture_png.sh -s emulator-5556` (validated PNG magic bytes; + the fold emulator has two displays, so a `screencap` redirect must never be + used). Captures are in `…/artifacts/93/1/`: + - **Narrow** 1080x1920 @ density 480 (≈360dp): `[implementer]`, `[reviewer]`, + `[ui_reviewer]` and `[FAILURE]` are filled with solid, arrowed routes between + the visited stages and into `#failure`; `[committer]` and `[SUCCESS]` are + hollow with dashed borders, and every other route is dashed with no arrowhead + (`graph_partly_exec_narrow_1x.png`). + - **Narrow, 2x** at 2160x3840 @ density 960 (same 360dp): the same graph at + double the pixel density, dashes and arrowheads clearly resolved + (`graph_partly_exec_narrow_2x.png`). + - **Wide** 2208x1840 @ density 420 (≈841dp): `graph_partly_exec_wide_1x.png`; + **wide 2x** at 4416x3680 @ density 840: `graph_partly_exec_wide_2x.png`; a + colour 2x crop of the graph and legend `graph_partly_exec_wide_1x_zoom.png`. + - **Grayscale check.** Greyscale conversions (`PIL` `Image.convert('L')`) of + the narrow-2x and wide-1x captures, plus a 2x greyscale crop, keep the + distinction: the executed routes are continuous solid lines with arrowheads + and the nodes fill, while the not-executed routes are broken dashed lines and + the nodes are hollow outlines (`graph_partly_exec_narrow_2x_gray.png`, + `graph_partly_exec_wide_1x_gray.png`, + `graph_partly_exec_wide_1x_gray_zoom.png`). + - **Definition-only view unchanged.** Captured the pipeline Graph tab (no run) + on a pre-change build (a `54af453` worktree) and on this build; the graph pane + is pixel-identical (no legend on either side). A + `PIL ImageChops.difference` over the graph pane (`x 1150–2208, y 150–1500`) + reported `bbox None` / `0` differing pixels of 1,428,300 / max channel diff + `0`. Before/after pair: `def_before_p8.png` / `def_after_p8.png` (pipeline 8 + Graph tab); the same source's pipeline-11 Graph tab after is + `graph_definition_only_wide_1x.png`. + - `adb -s emulator-5556 logcat -d` contained 0 `FATAL EXCEPTION` and 0 + `E AndroidRuntime` lines. +- **APK publish.** `app-debug.apk` copied to + `…/artifacts/93/1/pipelines-debug-wip-54af453.apk` (`54af453` = `git rev-parse + --short HEAD`); `shasum -a 256` matched. `curl -I + http://10.0.0.249:8080/artifacts/93/1/pipelines-debug-wip-54af453.apk` (`10.0.0.249` + from `ipconfig getifaddr en0`) returned `HTTP/1.1 200 OK`, + `Content-Type: application/vnd.android.package-archive`, `Content-Length: + 17912489`, and a streamed `GET | shasum -a 256` equalled the local file. At + ~17.1 MiB the APK exceeds the server's 8 MiB per-file inventory cap, so it is + served by direct URL only. + +Not verified in this pass: `:app:lintDebug`, the light theme, and a real hardware +fold (the wide/narrow layouts were produced with `wm size`/`wm density`); the +on-device captures used the debug build of this source, while the published APK +is a clean rebuild of the same source. diff --git a/android/app/src/main/java/net/awan/pipelines/ui/graph/WorkflowGraph.kt b/android/app/src/main/java/net/awan/pipelines/ui/graph/WorkflowGraph.kt index 2b72c411..84940fcc 100644 --- a/android/app/src/main/java/net/awan/pipelines/ui/graph/WorkflowGraph.kt +++ b/android/app/src/main/java/net/awan/pipelines/ui/graph/WorkflowGraph.kt @@ -5,6 +5,7 @@ import androidx.compose.foundation.ExperimentalFoundationApi import androidx.compose.foundation.background import androidx.compose.foundation.gestures.detectTapGestures import androidx.compose.foundation.gestures.detectTransformGestures +import androidx.compose.foundation.layout.Arrangement import androidx.compose.foundation.layout.Box import androidx.compose.foundation.layout.Row import androidx.compose.foundation.layout.fillMaxSize @@ -22,6 +23,7 @@ import androidx.compose.material3.ColorScheme import androidx.compose.material3.Icon import androidx.compose.material3.IconButton import androidx.compose.material3.MaterialTheme +import androidx.compose.material3.Text import androidx.compose.runtime.Composable import androidx.compose.runtime.LaunchedEffect import androidx.compose.runtime.getValue @@ -39,6 +41,7 @@ import androidx.compose.ui.geometry.Offset import androidx.compose.ui.geometry.Size import androidx.compose.ui.graphics.Color import androidx.compose.ui.graphics.Path +import androidx.compose.ui.graphics.PathEffect import androidx.compose.ui.graphics.TransformOrigin import androidx.compose.ui.graphics.drawscope.DrawScope import androidx.compose.ui.graphics.drawscope.Stroke @@ -137,8 +140,13 @@ internal data class ZoomResult(val offset: Offset, val scale: Float) * Node/edge/outcome semantics come from [GraphSemantics] and [edges], mirroring * internal/tui/graph.go: content-sized stage nodes, labelled outcome edges with * the `error*` fallback marker, `#success`/`#failure` terminals and loop routes. - * When [runState] is supplied, executed stages/routes are highlighted and the - * rest dimmed; when it is null the full definition is shown. + * When [runState] is supplied, an executed stage/route is drawn solid and + * full-colour with an arrowhead (nodes filled with a normal border) while a + * not-executed one is dashed and arrowless (nodes hollow with a muted, legible + * label), so the two states differ in shape, fill and border style rather than + * by a faded tint and survive a screenshot, a dim screen and a colour-blind + * reader; a one-line legend names both states. When [runState] is null the full + * definition is shown, unchanged. * * A tap that lands inside a node (stage or terminal) calls [onStageTap] with the * node key; tapping empty space does nothing. Pan/zoom keep working because the @@ -302,6 +310,33 @@ fun WorkflowGraph( ) } } + // A compact one-line legend, only under a run (never the definition-only + // view): a solid, arrowed swatch means "executed", a dashed, arrowless + // one means "not executed", matching what the graph draws. It is pinned + // to the top-start (opposite the Fit/expand controls) so it stays visible + // with the top of the panel on a short/narrow window, and its surface + // background keeps it legible wherever the panned/zoomed graph sits. + if (runState != null) { + Row( + modifier = Modifier + .align(Alignment.TopStart) + .padding(4.dp) + .background(MaterialTheme.colorScheme.surface.copy(alpha = 0.85f)) + .padding(horizontal = 6.dp, vertical = 3.dp), + verticalAlignment = Alignment.CenterVertically, + horizontalArrangement = Arrangement.spacedBy(10.dp), + ) { + GRAPH_LEGEND.forEach { entry -> + Row( + verticalAlignment = Alignment.CenterVertically, + horizontalArrangement = Arrangement.spacedBy(4.dp), + ) { + LegendSwatch(entry.executed, colors) + Text(entry.label, style = MaterialTheme.typography.labelSmall) + } + } + } + } Row( modifier = Modifier.align(Alignment.TopEnd).padding(4.dp), ) { @@ -339,6 +374,41 @@ fun WorkflowGraph( } } +/** + * One legend entry: the [label] a reader sees and whether it names the executed + * state. Pure data so the legend's content is asserted in a plain JVM test. + */ +internal data class GraphLegendEntry(val label: String, val executed: Boolean) + +/** The two execution states the legend names, executed first. */ +internal val GRAPH_LEGEND: List = listOf( + GraphLegendEntry("Executed", executed = true), + GraphLegendEntry("Not executed", executed = false), +) + +/** + * A small line swatch for one legend entry, drawn with the same stroke style the + * graph uses: a solid, arrowed line when [executed], a dashed, arrowless line + * otherwise. + */ +@Composable +private fun LegendSwatch(executed: Boolean, colors: GraphColors) { + Canvas(Modifier.size(LEGEND_SWATCH_WIDTH, LEGEND_SWATCH_HEIGHT)) { + val y = size.height / 2f + val from = Offset(0f, y) + val to = Offset(size.width, y) + val color = if (executed) colors.nodeText else colors.labelText + drawLine( + color = color, + start = from, + end = to, + strokeWidth = EDGE_STROKE, + pathEffect = if (executed) null else INACTIVE_DASH_EFFECT, + ) + if (executed) drawArrowHead(listOf(from, to), color) + } +} + internal class GraphColors( val success: Color, val error: Color, @@ -992,9 +1062,6 @@ private fun DrawScope.drawEdgePaths( runState: RunGraphState?, ) { for (edge in layout.edges) { - val executed = edge.isExecuted(runState) - val color = outcomeColor(edge.edge.outcome, colors) - val alpha = if (executed) 1f else 0.25f // Routing already happened once in layoutGraph; drawing only replays the // stored polyline, so there is no per-frame recompute. val points = if (edge.points.isEmpty()) routePoints(edge) else edge.points @@ -1004,8 +1071,21 @@ private fun DrawScope.drawEdgePaths( for (i in 1 until points.size) { path.lineTo(points[i].x, points[i].y) } - drawPath(path, color = color.copy(alpha = alpha), style = Stroke(width = 3f)) - drawArrowHead(points, color.copy(alpha = alpha)) + // Executed = solid full-colour stroke plus an arrowhead; not executed = + // dashed muted stroke with no arrowhead. The difference is carried by line + // style and arrowhead presence, never by opacity alone, so it survives a + // screenshot, a dim screen and a colour-blind reader. + if (edgeIsExecuted(edge.edge, runState)) { + val color = outcomeColor(edge.edge.outcome, colors) + drawPath(path, color = color, style = Stroke(width = EDGE_STROKE)) + drawArrowHead(points, color) + } else { + drawPath( + path, + color = colors.labelText, + style = Stroke(width = EDGE_STROKE, pathEffect = INACTIVE_DASH_EFFECT), + ) + } } } @@ -1013,10 +1093,10 @@ private fun DrawScope.drawEdgePaths( * Draws every outcome label in a second pass, after all curves, so a * neighbouring edge can never be drawn across a label. Each label sits on its * own edge's stored [EdgeLayout.labelPoint] (the edge's own lane/track), so - * distinct outcomes never overprint. Executed edges use a legible on-surface - * variant of their outcome colour (see [outcomeLabelColor]); dimmed edges use a - * muted colour on a near-opaque background instead of inheriting the curve's - * 0.25 alpha, which left the text unreadable. + * distinct outcomes never overprint. An executed edge's label uses its legible + * outcome colour (see [outcomeColor]); a not-executed edge's label uses a muted + * colour on a near-opaque background, matching its dashed stroke rather than + * inheriting a faded curve alpha, which left the text unreadable. */ private fun DrawScope.drawEdgeLabels( layout: GraphLayout, @@ -1025,7 +1105,7 @@ private fun DrawScope.drawEdgeLabels( textMeasurer: TextMeasurer, ) { for (edge in layout.edges) { - val executed = edge.isExecuted(runState) + val executed = edgeIsExecuted(edge.edge, runState) val textColor = if (executed) outcomeColor(edge.edge.outcome, colors) else colors.labelText val measured = textMeasurer.measure(edge.edge.label, TextStyle(fontSize = 11.sp, color = textColor)) val labelTopLeft = Offset( @@ -1085,42 +1165,61 @@ private fun DrawScope.drawNodes( textMeasurer: TextMeasurer, ) { for (node in layout.nodes) { - val executed = runState == null || node.key in runState.visitedStages + val executed = stageIsExecuted(node.key, runState) val selected = node.key == selectedStage - val alpha = if (executed) 1f else 0.3f val kind = graphNodeKind(node.terminal, node.key, stageTypeByKey[node.key]) - val fill = when { - kind == GraphNodeKind.TerminalFailure -> colors.terminalErrorFill - kind == GraphNodeKind.TerminalSuccess -> colors.terminalFill - selected -> colors.nodeFillActive - kind == GraphNodeKind.Ntfy -> colors.nodeNtfyFill - kind == GraphNodeKind.Custom -> colors.nodeCustomFill - else -> colors.nodeFill - }.copy(alpha = alpha) - val border = when (kind) { - GraphNodeKind.TerminalFailure -> colors.error - GraphNodeKind.TerminalSuccess -> colors.success - else -> if (selected) colors.nodeBorderActive else colors.nodeBorder - }.copy(alpha = alpha) - val textColor = if (!node.terminal && selected) colors.nodeTextActive else colors.nodeText val topLeft = Offset(node.x, node.y) - drawRoundRect( - color = fill, - topLeft = topLeft, - size = Size(node.width, node.height), - cornerRadius = androidx.compose.ui.geometry.CornerRadius(14f, 14f), - ) - drawRoundRect( - color = border, - topLeft = topLeft, - size = Size(node.width, node.height), - cornerRadius = androidx.compose.ui.geometry.CornerRadius(14f, 14f), - style = Stroke(width = if (selected && !node.terminal) 4f else 2f), - ) + val corner = androidx.compose.ui.geometry.CornerRadius(14f, 14f) + val borderWidth = if (selected && !node.terminal) 4f else 2f + val textColor: Color + if (executed) { + // Filled with a normal border, exactly as the definition-only view. + val fill = when { + kind == GraphNodeKind.TerminalFailure -> colors.terminalErrorFill + kind == GraphNodeKind.TerminalSuccess -> colors.terminalFill + selected -> colors.nodeFillActive + kind == GraphNodeKind.Ntfy -> colors.nodeNtfyFill + kind == GraphNodeKind.Custom -> colors.nodeCustomFill + else -> colors.nodeFill + } + val border = when (kind) { + GraphNodeKind.TerminalFailure -> colors.error + GraphNodeKind.TerminalSuccess -> colors.success + else -> if (selected) colors.nodeBorderActive else colors.nodeBorder + } + drawRoundRect( + color = fill, + topLeft = topLeft, + size = Size(node.width, node.height), + cornerRadius = corner, + ) + drawRoundRect( + color = border, + topLeft = topLeft, + size = Size(node.width, node.height), + cornerRadius = corner, + style = Stroke(width = borderWidth), + ) + textColor = if (!node.terminal && selected) colors.nodeTextActive else colors.nodeText + } else { + // Hollow and outlined: no fill (the surface shows through), a dashed + // muted border and a muted but legible label, so "not executed" is a + // shape and border-style difference rather than a faded node. A + // selected not-executed node keeps the stronger border colour. + val border = if (selected && !node.terminal) colors.nodeBorderActive else colors.labelText + drawRoundRect( + color = border, + topLeft = topLeft, + size = Size(node.width, node.height), + cornerRadius = corner, + style = Stroke(width = borderWidth, pathEffect = INACTIVE_DASH_EFFECT), + ) + textColor = colors.labelText + } val label = "[" + node.label + "]" val measured = textMeasurer.measure( label, - TextStyle(fontSize = 13.sp, fontWeight = FontWeight.Medium, color = textColor.copy(alpha = alpha)), + TextStyle(fontSize = 13.sp, fontWeight = FontWeight.Medium, color = textColor), ) // Pre-measured layout avoids the scope-relative width constraint crash and // the redundant re-measure of the string overload. @@ -1148,8 +1247,20 @@ internal fun outcomeColor(outcome: String, colors: GraphColors): Color = when (o else -> colors.palette[GraphPalette.outcomeColorIndex(outcome)] } -/** True when [runState] is null (definition view) or recorded this edge's route. */ -private fun EdgeLayout.isExecuted(runState: RunGraphState?): Boolean = +/** + * True when no run is selected (the definition-only view) or [key] was visited + * by the selected run. Pure, so graph drawing and the unit tests share one + * definition of "executed". + */ +internal fun stageIsExecuted(key: String, runState: RunGraphState?): Boolean = + runState == null || key in runState.visitedStages + +/** + * True when no run is selected (the definition-only view) or the selected run + * recorded [edge]'s route. Pure, so graph drawing and the unit tests share one + * definition of "executed". + */ +internal fun edgeIsExecuted(edge: GraphEdge, runState: RunGraphState?): Boolean = runState == null || GraphRoute(edge.source, edge.outcome, edge.target) in runState.takenRoutes /** A screen-reader description so meaning is never conveyed by colour alone. */ @@ -1157,7 +1268,7 @@ private fun graphDescription(graph: Graph, runState: RunGraphState?): String { if (graph.stages.isEmpty()) return "Empty workflow graph" val builder = StringBuilder("Workflow graph with ${graph.stages.size} stages. ") for (stage in graph.stages) { - val executed = runState == null || stage.key in runState.visitedStages + val executed = stageIsExecuted(stage.key, runState) builder.append("Stage ${stage.key}") if (runState != null) builder.append(if (executed) ", executed" else ", not executed") builder.append(". ") @@ -1178,6 +1289,25 @@ private const val MAX_SCALE = 3f private val FIT_PADDING = 16.dp private val MIN_VISIBLE = 48.dp +/** + * Line-style tokens shared by the graph and its legend. An executed stroke is + * solid; a not-executed stroke is dashed with [INACTIVE_DASH_INTERVALS] on/off + * pixels, so the two states differ by shape, not by a faded tint. + */ +private const val EDGE_STROKE = 3f + +/** The dash pattern (on/off, px) for every not-executed stroke; pure data. */ +internal val INACTIVE_DASH_INTERVALS = floatArrayOf(14f, 10f) + +/** The dashed effect for not-executed strokes, built once, never per frame. */ +private val INACTIVE_DASH_EFFECT: PathEffect by lazy { + PathEffect.dashPathEffect(INACTIVE_DASH_INTERVALS) +} + +/** Legend swatch geometry: a compact line, not a graph-layout token. */ +private val LEGEND_SWATCH_WIDTH = 22.dp +private val LEGEND_SWATCH_HEIGHT = 10.dp + /** * Collapsed graph-panel height, shared by both detail screens (one source for * the former 360.dp / 340.dp literals). ~58% of the window height so the graph diff --git a/android/app/src/main/java/net/awan/pipelines/ui/screens/RunDetailScreen.kt b/android/app/src/main/java/net/awan/pipelines/ui/screens/RunDetailScreen.kt index 1c879a9a..fb1cb472 100644 --- a/android/app/src/main/java/net/awan/pipelines/ui/screens/RunDetailScreen.kt +++ b/android/app/src/main/java/net/awan/pipelines/ui/screens/RunDetailScreen.kt @@ -385,7 +385,7 @@ private fun RunGraphTab( Text("This server did not include the run graph.", style = text.meta) } else { Text( - "Executed stages and routes are highlighted; the rest are dimmed. Pinch to zoom, drag to pan, tap a stage for details.", + "Executed stages and routes are solid; not-executed ones are dashed and outlined. Pinch to zoom, drag to pan, tap a stage for details.", style = text.meta, ) WorkflowGraph( diff --git a/android/app/src/test/java/net/awan/pipelines/ui/graph/WorkflowGraphTest.kt b/android/app/src/test/java/net/awan/pipelines/ui/graph/WorkflowGraphTest.kt index f75ca759..aa643456 100644 --- a/android/app/src/test/java/net/awan/pipelines/ui/graph/WorkflowGraphTest.kt +++ b/android/app/src/test/java/net/awan/pipelines/ui/graph/WorkflowGraphTest.kt @@ -4,9 +4,13 @@ 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.GraphRoute import net.awan.pipelines.data.protocol.Protocol +import net.awan.pipelines.data.protocol.RunGraphState import net.awan.pipelines.data.protocol.Stage +import net.awan.pipelines.data.protocol.edges import org.junit.Assert.assertEquals +import org.junit.Assert.assertFalse import org.junit.Assert.assertNull import org.junit.Assert.assertTrue import org.junit.Test @@ -484,6 +488,60 @@ class WorkflowGraphTest { } } + /** + * The executed/inactive predicates are the one definition of the two states: + * the definition-only view (no run) is entirely executed, and under a run + * only the visited stages and recorded routes are. + */ + @Test + fun executedPredicatesSeparateDefinitionViewFromaRun() { + val graph = sampleGraph() + val taken = graph.edges().first { it.source == "planner" && it.outcome == "success" } + val notTaken = graph.edges().first { it.source == "planner" && it.outcome == "error" } + + // No run selected: every stage and route is executed (definition view, + // unchanged today). + assertTrue(stageIsExecuted("planner", null)) + assertTrue(stageIsExecuted("ui_reviewer", null)) + assertTrue(edgeIsExecuted(taken, null)) + + val runState = RunGraphState( + visitedStages = setOf("planner", "implementer"), + takenRoutes = setOf(GraphRoute("planner", "success", "implementer")), + currentStage = "implementer", + ) + assertTrue(stageIsExecuted("planner", runState)) + assertTrue(stageIsExecuted("implementer", runState)) + assertFalse(stageIsExecuted("reviewer", runState)) + assertFalse(stageIsExecuted("#success", runState)) + assertTrue(edgeIsExecuted(taken, runState)) + assertFalse(edgeIsExecuted(notTaken, runState)) + } + + /** + * The not-executed dash pattern is a real on/off rhythm, not a faded tint: a + * positive, even-length interval list so a dashed stroke reads differently + * from the solid executed one. + */ + @Test + fun inactiveDashPatternIsARealDashRhythm() { + assertTrue(INACTIVE_DASH_INTERVALS.isNotEmpty()) + assertEquals(0, INACTIVE_DASH_INTERVALS.size % 2) + assertTrue(INACTIVE_DASH_INTERVALS.all { it > 0f && it.isFinite() }) + } + + /** + * The one-line legend names both states, executed first, with exactly one + * entry flagged executed so the two swatches cannot both claim solid. + */ + @Test + fun legendNamesBothStatesWithExecutedFirst() { + assertEquals(listOf("Executed", "Not executed"), GRAPH_LEGEND.map { it.label }) + assertTrue(GRAPH_LEGEND.first().executed) + assertFalse(GRAPH_LEGEND.last().executed) + assertEquals(1, GRAPH_LEGEND.count { it.executed }) + } + private fun assertNoSharedRuns(layout: GraphLayout) { val edges = layout.edges for (i in edges.indices) { From 1e7862e7c9889f01ebea78dcb60b455a68813a5d Mon Sep 17 00:00:00 2001 From: Alan Silva Date: Fri, 16 Oct 2026 08:06:34 +0100 Subject: [PATCH 7/9] Make pass/fail edges the loudest lines in the run graph Treat `success` and `error` as the emphasised outcomes so pass/fail is obvious at a glance and from a distance. An executed pass/fail edge now uses PASSFAIL_EDGE_STROKE=7f (was 3f), a same-hue, more saturated stroke (PASSFAIL_SATURATION=1.6f via the new pure boostSaturation helper) and a matched PASSFAIL_ARROW_HEAD_SIZE=20f arrowhead. Other executed outcomes keep EDGE_STROKE=3f and not-executed routes the finer INACTIVE_EDGE_STROKE=2.5f, so the two decisive outcomes dominate. All widths, the arrowhead size and the saturation factor are named tokens chosen by edgeStrokeWidth/edgeArrowHeadSize/edgeStrokeColor; the old 12f arrowhead literal at the call site is gone (drawArrowHead now takes the size as a parameter). Outcome hues are unchanged; the boosted stroke keeps the original hue and value. The run Graph tab help line notes that executed success and failure routes are drawn thickest, and the definition-only view gets the same emphasis since every route counts as executed there. New unit tests cover the saturation maths (hue/value/alpha preserved, safe and clamped) and the per-edge width/arrowhead/colour choices. --- android/README.md | 97 +++++++++++++++- .../awan/pipelines/ui/graph/GraphPalette.kt | 30 +++++ .../awan/pipelines/ui/graph/WorkflowGraph.kt | 109 +++++++++++++++--- .../pipelines/ui/screens/RunDetailScreen.kt | 2 +- .../pipelines/ui/graph/GraphPaletteTest.kt | 84 ++++++++++++++ .../pipelines/ui/graph/WorkflowGraphTest.kt | 50 ++++++++ 6 files changed, 353 insertions(+), 19 deletions(-) diff --git a/android/README.md b/android/README.md index 1a5ac8db..b120e449 100644 --- a/android/README.md +++ b/android/README.md @@ -111,8 +111,10 @@ stops it. fallback), loops and branches, pan/zoom, and run highlighting (under a run the executed stage/route is a solid full-colour stroke with an arrowhead and a filled, normal-bordered node, while a not-executed one is a dashed, arrowless - muted stroke with a hollow, dashed-bordered node and a muted label, plus a - one-line legend; the definition-only view is unchanged) plus a screen-reader + muted stroke with a hollow, dashed-bordered node and a muted label; an executed + `success`/`error` route is drawn noticeably heavier with a stronger same-hue + stroke and a larger arrowhead so pass/fail dominates; a one-line legend names + both states) plus a screen-reader description. Edges are drawn as axis-aligned orthogonal polylines like the TUI (`routePoints` computes the path once per layout and stores it on `EdgeLayout.points`), and each arrowhead @@ -1796,7 +1798,8 @@ on or driven). - **The definition-only view is untouched.** With no `runState` every stage/route is executed, so the graph renders exactly as before (solid, filled, arrowed) and the legend is not composed — confirmed against the pipeline Graph - tab. + tab. (Superseded later the same day: the pass/fail change below now widens an + executed `success`/`error` route in this view too.) - The run-detail Graph tab's help line was updated from "highlighted … dimmed" to "solid … dashed and outlined". @@ -1861,3 +1864,91 @@ Not verified in this pass: `:app:lintDebug`, the light theme, and a real hardwar fold (the wide/narrow layouts were produced with `wm size`/`wm density`); the on-device captures used the debug build of this source, while the published APK is a clean rebuild of the same source. + +## Pass/fail edges are the loudest lines (16 Oct 2026) + +`android/` only. Nothing outside `android/` was touched, no dependency was added, +no run was started from the app, and every `adb`/emulator command targeted +`emulator-5556` (lane A's `emulator-5554` was never used; the attached device was +never installed on or driven). + +- **Two decisive outcomes, drawn heavier.** `ui/graph/WorkflowGraph.kt` now + treats `success` (pass) and `error` (fail) as the emphasised outcomes + (`isPassFailOutcome`). An executed pass/fail edge is drawn at + `PASSFAIL_EDGE_STROKE = 7f` — noticeably heavier than the previous `3f` — with + a stronger, more saturated stroke and a matching `PASSFAIL_ARROW_HEAD_SIZE = + 20f` arrowhead, so pass/fail is obvious at a glance and from a distance. +- **Other lines stay finer.** Every other executed outcome keeps `EDGE_STROKE = + 3f`, and a not-executed edge uses the finer `INACTIVE_EDGE_STROKE = 2.5f`, so + the two emphasised outcomes dominate. No outcome hue changed. +- **Stronger, same-hue stroke.** `boostSaturation(color, factor)` in + `ui/graph/GraphPalette.kt` scales HSV saturation by `PASSFAIL_SATURATION = + 1.6f`, clamping at 1 while preserving hue, value and alpha. On the dark theme + the executed `success` stroke moves from `#F2C879` (hue 39.2°) to a vivid + `#F2AF30`-ish core (hue 39.3°, measured pixel `(242,175,48)`) and the executed + `error` stroke from `#FFB4AB` (hue 6.4°) to a stronger `(255,135,121)` (hue + 6.3°); the measured pixel hues match their unboosted originals, so meaning is + not conveyed by a new colour. A non-pass/fail or not-executed edge keeps its + exact outcome colour. +- **Widths come from named tokens, not call sites.** `edgeStrokeWidth`, + `edgeArrowHeadSize` and `edgeStrokeColor` pick the token for an edge; the old + `12f` arrowhead literal is gone (the draw scope takes the size as a + parameter). The legend swatch keeps the base `EDGE_STROKE`/`ARROW_HEAD_SIZE` + because it names the generic executed/not-executed states, not pass/fail. +- **Definition-only view.** With no run selected every route counts as executed, + so the definition graph now shows the same pass/fail emphasis (still no + legend). The run Graph tab help line now adds "Executed success and failure + routes are drawn thickest." + +Verification (macOS; Homebrew `openjdk@17`, +`JAVA_HOME=/opt/homebrew/opt/openjdk@17/libexec/openjdk.jdk/Contents/Home`, +Gradle 8.11.1 at +`~/.gradle/wrapper/dists/gradle-8.11.1-bin/…/gradle-8.11.1/bin/gradle`, +`ANDROID_HOME=/Users/alan/Library/Android/sdk`, `--offline`): + +- `gradle --offline clean :app:testDebugUnitTest :app:assembleDebug` → + **193 tests, 0 failures, 0 errors**; `WorkflowGraphTest` **36** (2 new: the + executed pass/fail edge is the widest and its arrowhead scales, and only + `success`/`error` are pass/fail outcomes) and `GraphPaletteTest` **10** (3 new: + `boostSaturation` raises saturation while keeping hue/value/alpha, is safe and + clamped at the edges, and only executed pass/fail strokes are saturated + further). The clean `:app:assembleDebug` produced `app-debug.apk` + **17,912,489 bytes**, sha256 + `ce63722b851ce26322da69fa47bdc91958c3d7db3e339c1340efc3e04b6780f8`. +- **Before/after on a run with both a success and an error edge.** Run 77 + (pipeline 11 "Focused tweak - implement review commit", failed at `ui_reviewer` + with `error`) was opened in the app against the live server + `ws://10.0.2.2:8080/connect` in dark mode; its taken routes include a `success` + and an `error` edge. "Before" is HEAD `9c47527` (the six edited files stashed, + rebuilt, installed; verified by the help line without "thickest"); "after" is + this change. Captures were written with + `android/scripts/capture_png.sh -s emulator-5556`: + - **Wide** 2208x1840 @ density 420 (≈841dp): `before_wide_1x.png` / + `after_wide_1x.png`. At the panel's fit scale the executed success/error + stroke's saturated core measures **1px before, 3px after** (sampled at the + same x), while the dashed non-pass/fail routes stay ~1px. + - **Wide 2x** 4416x3680 @ density 840: `before_wide_2x.png` / + `after_wide_2x.png`. + - Cropped graph panes `before_wide_{1x,2x}_graphcrop.png` / + `after_wide_{1x,2x}_graphcrop.png` and stacked before/after sheets + `compare_wide_1x.png` / `compare_wide_2x.png` show the two amber `success` + edges and the red `error` edge as the boldest lines after the change, with + the dashed `blocked`/`rejected`/`approved`/`skipped` routes and the + not-executed `committer`/`SUCCESS` edges unchanged. + - `adb -s emulator-5556 logcat -d` contained 0 `FATAL EXCEPTION` and 0 + `E AndroidRuntime` lines. +- **APK publish.** `app-debug.apk` copied to + `…/artifacts/98/1/pipelines-debug-wip-9c47527.apk` (`9c47527` = `git rev-parse + --short HEAD`); `shasum -a 256` matched. `curl -I + http://10.0.0.249:8080/artifacts/98/1/pipelines-debug-wip-9c47527.apk` (`10.0.0.249` + from `ipconfig getifaddr en0`) returned `HTTP/1.1 200 OK`, + `Content-Type: application/vnd.android.package-archive`, `Content-Length: + 17912489`, and a streamed `GET | shasum -a 256` equalled the local file. The + APK exceeds the server's per-file inventory cap, so it is served by direct URL + only. + +Not verified in this pass: `:app:lintDebug`, the light theme, and a real hardware +fold (the wide layout was produced with `wm size`/`wm density`); the on-device +captures used the debug build of this source, while the published APK is a clean +rebuild of the same source. + diff --git a/android/app/src/main/java/net/awan/pipelines/ui/graph/GraphPalette.kt b/android/app/src/main/java/net/awan/pipelines/ui/graph/GraphPalette.kt index cf5d5b9c..b15bfca8 100644 --- a/android/app/src/main/java/net/awan/pipelines/ui/graph/GraphPalette.kt +++ b/android/app/src/main/java/net/awan/pipelines/ui/graph/GraphPalette.kt @@ -94,6 +94,36 @@ internal fun graphNodeKind(terminal: Boolean, key: String, type: String?): Graph else -> GraphNodeKind.Custom } +/** + * A more vivid version of [color] with the same hue, value and alpha: the HSV + * saturation is scaled by [factor] and clamped to 1. Used to make an executed + * pass/fail edge stroke stronger without changing its outcome hue, so both + * terminal colours get more punch while staying recognisably success/failure. + * + * Pure sRGB maths. A non-finite/non-positive [factor], an achromatic colour or + * one already at full saturation returns [color] unchanged, so callers never get + * NaN and every input is safe. + */ +internal fun boostSaturation(color: Color, factor: Float): Color { + if (!factor.isFinite() || factor <= 0f) return color + val r = color.red + val g = color.green + val b = color.blue + val max = maxOf(r, g, b) + val min = minOf(r, g, b) + val delta = max - min + if (max <= 0f || delta <= 0f) return color + val current = delta / max + val saturation = (current * factor).coerceAtMost(1f) + if (saturation <= current) return color + val hue = (when (max) { + r -> ((g - b) / delta + 6f) % 6f + g -> (b - r) / delta + 2f + else -> (r - g) / delta + 4f + }) * 60f + return Color.hsv(hue, saturation, max, color.alpha) +} + /** * WCAG relative luminance of [color] (sRGB), the building block of the WCAG * contrast ratio. Pure so the palette's legibility is measured in a unit test diff --git a/android/app/src/main/java/net/awan/pipelines/ui/graph/WorkflowGraph.kt b/android/app/src/main/java/net/awan/pipelines/ui/graph/WorkflowGraph.kt index 84940fcc..36030c23 100644 --- a/android/app/src/main/java/net/awan/pipelines/ui/graph/WorkflowGraph.kt +++ b/android/app/src/main/java/net/awan/pipelines/ui/graph/WorkflowGraph.kt @@ -145,8 +145,11 @@ internal data class ZoomResult(val offset: Offset, val scale: Float) * not-executed one is dashed and arrowless (nodes hollow with a muted, legible * label), so the two states differ in shape, fill and border style rather than * by a faded tint and survive a screenshot, a dim screen and a colour-blind - * reader; a one-line legend names both states. When [runState] is null the full - * definition is shown, unchanged. + * reader; a one-line legend names both states. An executed `success`/`error` + * edge is drawn noticeably heavier with a stronger, same-hue stroke and a larger + * arrowhead, so the two decisive outcomes are the loudest lines in the graph. + * When [runState] is null the full definition is shown, with the same pass/fail + * emphasis (every route counts as executed) and no legend. * * A tap that lands inside a node (stage or terminal) calls [onStageTap] with the * node key; tapping empty space does nothing. Pan/zoom keep working because the @@ -405,7 +408,7 @@ private fun LegendSwatch(executed: Boolean, colors: GraphColors) { strokeWidth = EDGE_STROKE, pathEffect = if (executed) null else INACTIVE_DASH_EFFECT, ) - if (executed) drawArrowHead(listOf(from, to), color) + if (executed) drawArrowHead(listOf(from, to), color, ARROW_HEAD_SIZE) } } @@ -1074,16 +1077,25 @@ private fun DrawScope.drawEdgePaths( // Executed = solid full-colour stroke plus an arrowhead; not executed = // dashed muted stroke with no arrowhead. The difference is carried by line // style and arrowhead presence, never by opacity alone, so it survives a - // screenshot, a dim screen and a colour-blind reader. + // screenshot, a dim screen and a colour-blind reader. An executed + // `success`/`error` edge uses the heavier pass/fail width, a stronger + // (same-hue) stroke and a matched arrowhead, so pass/fail dominates. if (edgeIsExecuted(edge.edge, runState)) { - val color = outcomeColor(edge.edge.outcome, colors) - drawPath(path, color = color, style = Stroke(width = EDGE_STROKE)) - drawArrowHead(points, color) + val color = edgeStrokeColor(edge.edge, runState, colors) + drawPath( + path, + color = color, + style = Stroke(width = edgeStrokeWidth(edge.edge, runState)), + ) + drawArrowHead(points, color, edgeArrowHeadSize(edge.edge, runState)) } else { drawPath( path, color = colors.labelText, - style = Stroke(width = EDGE_STROKE, pathEffect = INACTIVE_DASH_EFFECT), + style = Stroke( + width = edgeStrokeWidth(edge.edge, runState), + pathEffect = INACTIVE_DASH_EFFECT, + ), ) } } @@ -1128,17 +1140,18 @@ private fun DrawScope.drawEdgeLabels( } /** - * Draws an arrowhead at the tip of [points], oriented along the final segment's - * direction (see [arrowDirection]) instead of the from-to chord, so a route that - * turns a corner still gets an arrow pointing the way it actually travels. + * Draws an arrowhead of length [size] at the tip of [points], oriented along the + * final segment's direction (see [arrowDirection]) instead of the from-to chord, + * so a route that turns a corner still gets an arrow pointing the way it + * actually travels. [size] is passed by the caller from the matching named token + * (see [edgeArrowHeadSize]) rather than written here. */ -private fun DrawScope.drawArrowHead(points: List, color: Color) { +private fun DrawScope.drawArrowHead(points: List, color: Color, size: Float) { if (points.size < 2) return val to = points.last() val direction = arrowDirection(points) if (direction.x == 0f && direction.y == 0f) return val angle = kotlin.math.atan2(direction.y.toDouble(), direction.x.toDouble()) - val size = 12f val left = Offset( x = to.x - size * kotlin.math.cos(angle - 0.5).toFloat(), y = to.y - size * kotlin.math.sin(angle - 0.5).toFloat(), @@ -1263,6 +1276,46 @@ internal fun stageIsExecuted(key: String, runState: RunGraphState?): Boolean = internal fun edgeIsExecuted(edge: GraphEdge, runState: RunGraphState?): Boolean = runState == null || GraphRoute(edge.source, edge.outcome, edge.target) in runState.takenRoutes +/** + * True for the two decisive outcomes the graph emphasises: `success` (pass) and + * `error` (fail). These are the protocol's terminal outcomes, the only two whose + * stroke is widened. Pure, so drawing and the tests share one definition. + */ +internal fun isPassFailOutcome(outcome: String): Boolean = + outcome == "success" || outcome == "error" + +/** True for an executed pass/fail edge: the edges drawn heaviest. */ +internal fun isEmphasizedEdge(edge: GraphEdge, runState: RunGraphState?): Boolean = + isPassFailOutcome(edge.outcome) && edgeIsExecuted(edge, runState) + +/** + * The named stroke-width token for [edge]: the heavier pass/fail width for an + * executed `success`/`error`, the base width for any other executed outcome, and + * the finest width for a not-executed edge. Pure, so the widths are asserted in a + * unit test and no call site writes a stroke literal. + */ +internal fun edgeStrokeWidth(edge: GraphEdge, runState: RunGraphState?): Float = when { + !edgeIsExecuted(edge, runState) -> INACTIVE_EDGE_STROKE + isPassFailOutcome(edge.outcome) -> PASSFAIL_EDGE_STROKE + else -> EDGE_STROKE +} + +/** The named arrowhead-size token for [edge], scaled to match [edgeStrokeWidth]. */ +internal fun edgeArrowHeadSize(edge: GraphEdge, runState: RunGraphState?): Float = + if (isEmphasizedEdge(edge, runState)) PASSFAIL_ARROW_HEAD_SIZE else ARROW_HEAD_SIZE + +/** + * The stroke colour for an executed [edge]: its outcome colour, made more + * saturated when pass/fail so it is stronger without changing its hue (see + * [boostSaturation]). A not-executed edge is drawn muted elsewhere. + */ +internal fun edgeStrokeColor(edge: GraphEdge, runState: RunGraphState?, colors: GraphColors): Color = + if (isEmphasizedEdge(edge, runState)) { + boostSaturation(outcomeColor(edge.outcome, colors), PASSFAIL_SATURATION) + } else { + outcomeColor(edge.outcome, colors) + } + /** A screen-reader description so meaning is never conveyed by colour alone. */ private fun graphDescription(graph: Graph, runState: RunGraphState?): String { if (graph.stages.isEmpty()) return "Empty workflow graph" @@ -1290,12 +1343,38 @@ private val FIT_PADDING = 16.dp private val MIN_VISIBLE = 48.dp /** - * Line-style tokens shared by the graph and its legend. An executed stroke is - * solid; a not-executed stroke is dashed with [INACTIVE_DASH_INTERVALS] on/off + * Line-style tokens shared by the graph and its legend. Widths and the arrowhead + * size are named here so no call site writes a stroke literal. An executed route + * is solid; a not-executed route is dashed with [INACTIVE_DASH_INTERVALS] on/off * pixels, so the two states differ by shape, not by a faded tint. + * + * The two decisive outcomes (`success`/`error`) use the heavier + * [PASSFAIL_EDGE_STROKE] with the matching [PASSFAIL_ARROW_HEAD_SIZE] and a + * stronger [PASSFAIL_SATURATION] stroke, so pass/fail reads at a glance and from + * a distance, while every other outcome keeps the finer [EDGE_STROKE] and a + * not-executed route the finer still [INACTIVE_EDGE_STROKE]. */ private const val EDGE_STROKE = 3f +/** Stroke width for an executed `success`/`error` edge; heavier than [EDGE_STROKE]. */ +private const val PASSFAIL_EDGE_STROKE = 7f + +/** Stroke width for a not-executed edge; finer than either executed width. */ +private const val INACTIVE_EDGE_STROKE = 2.5f + +/** Arrowhead length for a normal executed edge. */ +private const val ARROW_HEAD_SIZE = 12f + +/** Arrowhead length for an executed pass/fail edge, scaled with its heavier stroke. */ +private const val PASSFAIL_ARROW_HEAD_SIZE = 20f + +/** + * How much more saturated an executed pass/fail stroke is than its outcome + * colour: hue and value are preserved (see [boostSaturation]) so the meaning of + * the colour does not change. + */ +private const val PASSFAIL_SATURATION = 1.6f + /** The dash pattern (on/off, px) for every not-executed stroke; pure data. */ internal val INACTIVE_DASH_INTERVALS = floatArrayOf(14f, 10f) diff --git a/android/app/src/main/java/net/awan/pipelines/ui/screens/RunDetailScreen.kt b/android/app/src/main/java/net/awan/pipelines/ui/screens/RunDetailScreen.kt index fb1cb472..090ad2ab 100644 --- a/android/app/src/main/java/net/awan/pipelines/ui/screens/RunDetailScreen.kt +++ b/android/app/src/main/java/net/awan/pipelines/ui/screens/RunDetailScreen.kt @@ -385,7 +385,7 @@ private fun RunGraphTab( Text("This server did not include the run graph.", style = text.meta) } else { Text( - "Executed stages and routes are solid; not-executed ones are dashed and outlined. Pinch to zoom, drag to pan, tap a stage for details.", + "Executed stages and routes are solid; not-executed ones are dashed and outlined. Executed success and failure routes are drawn thickest. Pinch to zoom, drag to pan, tap a stage for details.", style = text.meta, ) WorkflowGraph( diff --git a/android/app/src/test/java/net/awan/pipelines/ui/graph/GraphPaletteTest.kt b/android/app/src/test/java/net/awan/pipelines/ui/graph/GraphPaletteTest.kt index 9d237e56..7201cf25 100644 --- a/android/app/src/test/java/net/awan/pipelines/ui/graph/GraphPaletteTest.kt +++ b/android/app/src/test/java/net/awan/pipelines/ui/graph/GraphPaletteTest.kt @@ -1,7 +1,10 @@ package net.awan.pipelines.ui.graph import androidx.compose.ui.graphics.Color +import net.awan.pipelines.data.protocol.GraphEdge +import net.awan.pipelines.data.protocol.GraphRoute import net.awan.pipelines.data.protocol.Protocol +import net.awan.pipelines.data.protocol.RunGraphState import org.junit.Assert.assertEquals import org.junit.Assert.assertFalse import org.junit.Assert.assertTrue @@ -98,6 +101,87 @@ class GraphPaletteTest { assertTrue(contrastRatio(errorRole, darkSurface) >= 4.5) } + /** + * The emphasis helper keeps the outcome hue and value and only raises + * saturation, so a stronger pass/fail stroke is still recognisably the same + * success/failure colour. + */ + @Test + fun boostSaturationRaisesSaturationButKeepsHueValueAndAlpha() { + val base = successRole + val boosted = boostSaturation(base, 1.6f) + assertTrue(saturationOf(boosted) > saturationOf(base)) + assertEquals(hueOf(base), hueOf(boosted), 1f) + assertEquals(valueOf(base), valueOf(boosted), 0.001f) + assertEquals(base.alpha, boosted.alpha, 0.001f) + // A second hue is left on its own hue, not shifted toward the first. + val red = errorRole + assertEquals(hueOf(red), hueOf(boostSaturation(red, 1.6f)), 1f) + } + + @Test + fun boostSaturationIsSafeAndClampedAtTheEdges() { + val base = successRole + // A no-op factor, and invalid factors, return the colour unchanged. + assertEquals(base, boostSaturation(base, 1f)) + assertEquals(base, boostSaturation(base, 0f)) + assertEquals(base, boostSaturation(base, -1f)) + assertEquals(base, boostSaturation(base, Float.NaN)) + // Achromatic colours have no saturation to raise. + assertEquals(Color.Gray, boostSaturation(Color.Gray, 2f)) + // An already fully-saturated colour clamps at 1 instead of overshooting. + assertEquals(Color.Red, boostSaturation(Color.Red, 2f)) + } + + /** + * Only an executed pass/fail edge is emphasised: its stroke is the stronger + * same-hue colour, while a non-pass/fail edge and a not-executed edge keep + * their exact outcome colour. + */ + @Test + fun onlyExecutedPassFailStrokesAreSaturatedFurther() { + val colors = colors() + val success = GraphEdge(1, "a", "success", Protocol.SUCCESS_END, "success") + val blocked = GraphEdge(2, "a", "blocked", Protocol.FAILURE_END, "blocked") + val error = GraphEdge(3, "b", "error", Protocol.FAILURE_END, "error") + val executed = RunGraphState( + visitedStages = setOf("a"), + takenRoutes = setOf(GraphRoute("a", "success", Protocol.SUCCESS_END)), + currentStage = "a", + ) + + val baseSuccess = outcomeColor("success", colors) + val strokeSuccess = edgeStrokeColor(success, executed, colors) + assertEquals(hueOf(baseSuccess), hueOf(strokeSuccess), 1f) + assertTrue(saturationOf(strokeSuccess) > saturationOf(baseSuccess)) + + // A non-pass/fail edge and a not-executed pass/fail edge are untouched. + assertEquals(outcomeColor("blocked", colors), edgeStrokeColor(blocked, executed, colors)) + assertEquals(outcomeColor("error", colors), edgeStrokeColor(error, executed, colors)) + } + + /** Hue in degrees, matching the conversion [boostSaturation] uses. */ + private fun hueOf(color: Color): Float { + val max = maxOf(color.red, color.green, color.blue) + val min = minOf(color.red, color.green, color.blue) + val delta = max - min + if (delta == 0f) return 0f + val h = when (max) { + color.red -> ((color.green - color.blue) / delta + 6f) % 6f + color.green -> (color.blue - color.red) / delta + 2f + else -> (color.red - color.green) / delta + 4f + } + return h * 60f + } + + private fun saturationOf(color: Color): Float { + val max = maxOf(color.red, color.green, color.blue) + val min = minOf(color.red, color.green, color.blue) + return if (max <= 0f) 0f else (max - min) / max + } + + private fun valueOf(color: Color): Float = maxOf(color.red, color.green, color.blue) + @Test fun nodeKindIsDeterministicAndCoversEveryKind() { assertEquals(GraphNodeKind.Model, graphNodeKind(false, "planner", null)) diff --git a/android/app/src/test/java/net/awan/pipelines/ui/graph/WorkflowGraphTest.kt b/android/app/src/test/java/net/awan/pipelines/ui/graph/WorkflowGraphTest.kt index aa643456..47ff4463 100644 --- a/android/app/src/test/java/net/awan/pipelines/ui/graph/WorkflowGraphTest.kt +++ b/android/app/src/test/java/net/awan/pipelines/ui/graph/WorkflowGraphTest.kt @@ -518,6 +518,56 @@ class WorkflowGraphTest { assertFalse(edgeIsExecuted(notTaken, runState)) } + /** + * The emphasis contract: an executed `success`/`error` edge uses the widest + * named stroke token, every other executed outcome a finer one and a + * not-executed edge the finest, with the arrowhead scaled to match. The + * definition-only view applies the same pass/fail emphasis. + */ + @Test + fun executedPassFailEdgesAreTheWidest() { + val graph = sampleGraph() + val success = graph.edges().first { it.outcome == "success" } + val error = graph.edges().first { it.outcome == "error" } + val other = graph.edges().first { it.outcome == "blocked" } + val untaken = graph.edges().first { it.outcome == "rejected" } + val runState = RunGraphState( + visitedStages = setOf("planner", "implementer", "reviewer"), + takenRoutes = setOf( + GraphRoute(success.source, success.outcome, success.target), + GraphRoute(error.source, error.outcome, error.target), + GraphRoute(other.source, other.outcome, other.target), + ), + currentStage = "reviewer", + ) + + val passFailWidth = edgeStrokeWidth(success, runState) + assertEquals(passFailWidth, edgeStrokeWidth(error, runState), 0.001f) + assertTrue(edgeStrokeWidth(other, runState) < passFailWidth) + assertTrue(edgeStrokeWidth(untaken, runState) < edgeStrokeWidth(other, runState)) + assertTrue(edgeStrokeWidth(untaken, runState) > 0f) + + // The arrowhead scales with the heavier stroke. + assertEquals(edgeArrowHeadSize(success, runState), edgeArrowHeadSize(error, runState), 0.001f) + assertTrue(edgeArrowHeadSize(success, runState) > edgeArrowHeadSize(other, runState)) + + // The definition-only view emphasises the same pass/fail edges. + assertEquals(passFailWidth, edgeStrokeWidth(success, null), 0.001f) + assertTrue(isEmphasizedEdge(success, runState)) + assertFalse(isEmphasizedEdge(other, runState)) + assertFalse(isEmphasizedEdge(untaken, runState)) + } + + /** Only `success` and `error` are the decisive, emphasised outcomes. */ + @Test + fun onlySuccessAndErrorArePassFailOutcomes() { + assertTrue(isPassFailOutcome("success")) + assertTrue(isPassFailOutcome("error")) + for (outcome in listOf("blocked", "rejected", "skipped", "exhausted", "approved", "done", "")) { + assertFalse(outcome, isPassFailOutcome(outcome)) + } + } + /** * The not-executed dash pattern is a real on/off rhythm, not a faded tint: a * positive, even-length interval list so a dashed stroke reads differently From 8b39c087fd1c74dc0fb88aedfd0e261e602c13b1 Mon Sep 17 00:00:00 2001 From: Alan Silva Date: Fri, 16 Oct 2026 09:52:57 +0100 Subject: [PATCH 8/9] Animate the active stage and executed edges in the run graph Show what is happening while a run is live. The executing stage now carries a subtle pulsing halo (replacing the blink) and a live ticking elapsed badge derived from the run's current visit start. Executed edges carry a directional flow of light dots along the path; a finished stage settles into its static colour. A finished run never animates, the animation pauses when the graph is off screen, and with the system animation setting disabled it falls back to a static but clearly marked running state. The per-frame visual state and should-animate decision live in pure functions (GraphMotion.kt, Format.kt secondsSince; GraphSemantics exposes executing and currentStageStartedAt) with unit tests and no frame-timing assertions. Adds GraphMotionTest and extends GraphSemanticsTest and FormatTest. --- .../pipelines/data/protocol/GraphSemantics.kt | 23 +- .../main/java/net/awan/pipelines/ui/Format.kt | 11 + .../awan/pipelines/ui/graph/GraphMotion.kt | 99 +++++++ .../awan/pipelines/ui/graph/WorkflowGraph.kt | 264 +++++++++++++++++- .../pipelines/ui/screens/RunDetailScreen.kt | 8 +- .../data/protocol/GraphSemanticsTest.kt | 30 ++ .../java/net/awan/pipelines/ui/FormatTest.kt | 13 + .../pipelines/ui/graph/GraphMotionTest.kt | 147 ++++++++++ 8 files changed, 581 insertions(+), 14 deletions(-) create mode 100644 android/app/src/main/java/net/awan/pipelines/ui/graph/GraphMotion.kt create mode 100644 android/app/src/test/java/net/awan/pipelines/ui/graph/GraphMotionTest.kt diff --git a/android/app/src/main/java/net/awan/pipelines/data/protocol/GraphSemantics.kt b/android/app/src/main/java/net/awan/pipelines/data/protocol/GraphSemantics.kt index 6e09e422..7cd5066a 100644 --- a/android/app/src/main/java/net/awan/pipelines/data/protocol/GraphSemantics.kt +++ b/android/app/src/main/java/net/awan/pipelines/data/protocol/GraphSemantics.kt @@ -75,6 +75,17 @@ data class RunGraphState( val visitedStages: Set, val takenRoutes: Set, val currentStage: String?, + /** + * True while the server still reports the run as executing. The graph only + * animates a live run; a finished one is drawn settled and static. + */ + val executing: Boolean = false, + /** + * RFC3339 start of the visit currently running for [currentStage], or null + * when the run is not live or that visit's start is unknown. The graph uses + * it for the live ticking elapsed time on the active node. + */ + val currentStageStartedAt: String? = null, ) { companion object { fun from(run: RunDetail): RunGraphState { @@ -91,7 +102,17 @@ data class RunGraphState( val current = run.currentStage.ifEmpty { run.steps.lastOrNull()?.stage ?: "" } - return RunGraphState(stages, routes, current.ifEmpty { null }) + val stage = current.ifEmpty { null } + // Only a live run carries a ticking active stage; the matching running + // step's start keeps the timer on the same node as the halo. + val runningSince = if (run.executing && stage != null) { + run.steps.lastOrNull { it.stage == stage && it.status == "running" } + ?.startedAt + ?.takeIf { it.isNotBlank() } + } else { + null + } + return RunGraphState(stages, routes, stage, run.executing, runningSince) } } } diff --git a/android/app/src/main/java/net/awan/pipelines/ui/Format.kt b/android/app/src/main/java/net/awan/pipelines/ui/Format.kt index 4c9bcb24..eccc2799 100644 --- a/android/app/src/main/java/net/awan/pipelines/ui/Format.kt +++ b/android/app/src/main/java/net/awan/pipelines/ui/Format.kt @@ -38,6 +38,17 @@ internal fun durationSeconds(start: String, end: String): Long? { fun formatDuration(start: String, end: String): String? = durationSeconds(start, end)?.let(::formatDuration) +/** + * Non-negative whole seconds from a [start] RFC3339 timestamp to [nowMillis] + * (wall-clock epoch millis), or null when [start] is blank/unparseable. Clamps a + * future/unparseable elapsed to 0 so a live timer never prints a negative or a + * nonsensical value. The one derivation behind the run graph's ticking elapsed + * time, so it is pure and testable without the Compose runtime. + */ +internal fun secondsSince(start: String, nowMillis: Long): Long? = + parseInstant(start)?.let { ((nowMillis - it.toInstant().toEpochMilli()) / 1000).coerceAtLeast(0) } + + /** * Human duration for a whole number of seconds. The single formatting rule for * every duration the UI shows (list meta, usage average, run summary, step diff --git a/android/app/src/main/java/net/awan/pipelines/ui/graph/GraphMotion.kt b/android/app/src/main/java/net/awan/pipelines/ui/graph/GraphMotion.kt new file mode 100644 index 00000000..d18ab670 --- /dev/null +++ b/android/app/src/main/java/net/awan/pipelines/ui/graph/GraphMotion.kt @@ -0,0 +1,99 @@ +package net.awan.pipelines.ui.graph + +import net.awan.pipelines.data.protocol.GraphEdge +import net.awan.pipelines.data.protocol.RunGraphState +import kotlin.math.PI +import kotlin.math.sin + +/** + * How a stage node is drawn under a run: + * + * - [Active]: the stage the live run is executing right now; it carries a + * pulsing halo, and its live elapsed time is drawn under its label. + * - [Visited]: a stage the run already visited (or any stage in the + * definition-only view); it settles into its static fill/border. + * - [Unvisited]: a stage the run did not reach; drawn hollow, never animating. + * + * A finished run has no [Active] node, so nothing animates once it stops. + */ +internal enum class NodeMotion { Active, Visited, Unvisited } + +/** + * How an edge is drawn under a run: + * + * - [Flowing]: an executed route while the run is live; its stroke carries a + * moving dot that reads the direction of travel. + * - [Settled]: an executed route under a finished run; a plain static stroke. + * - [Unvisited]: a route the run did not take; dashed and arrowless. + */ +internal enum class EdgeMotion { Flowing, Settled, Unvisited } + +/** + * Whether the graph may animate at all, from the three independent gates: + * the run must still be executing (never animate a finished run), the system + * must have animations enabled (honour the OS/animation-scale setting), and the + * graph must be on screen (a backgrounded graph is paused). Pure, so the + * decision is asserted in a unit test rather than inferred from a frame clock. + * + * When this is false while the run is live, the graph still marks the active + * stage statically (see [ACTIVE_HALO_STATIC_ALPHA] and the drawn elapsed time), + * so "animations off" is a static but unmistakable running state, not a blank. + */ +internal fun graphShouldAnimate( + runState: RunGraphState?, + animationsEnabled: Boolean, + onScreen: Boolean, +): Boolean = runState?.executing == true && animationsEnabled && onScreen + +/** + * The motion state of the stage [key] under [runState]. Pure and the single + * definition the drawing and the tests share: the definition-only view + * ([runState] == null) is entirely visited/static, an unvisited key is idle, and + * only the stage the live run is on is [NodeMotion.Active]. The live stage wins + * over the visited check, so it is unmistakably active even in the brief window + * before its step has been recorded in [RunGraphState.visitedStages]. + */ +internal fun nodeMotion(key: String, runState: RunGraphState?): NodeMotion = when { + runState == null -> NodeMotion.Visited + runState.executing && key == runState.currentStage -> NodeMotion.Active + key !in runState.visitedStages -> NodeMotion.Unvisited + else -> NodeMotion.Visited +} + +/** + * The motion state of [edge] under [runState]: an executed route flows while the + * run is live and settles once it finishes, and an untaken route is idle. The + * definition-only view ([runState] == null) is settled (static), as before. + */ +internal fun edgeMotion(edge: GraphEdge, runState: RunGraphState?): EdgeMotion = when { + !edgeIsExecuted(edge, runState) -> EdgeMotion.Unvisited + runState?.executing == true -> EdgeMotion.Flowing + else -> EdgeMotion.Settled +} + +/** + * The active-node halo strength for a 0..1 animation [phase]: a smooth + * sinusoid that rises and falls once per cycle, never stepping between two + * values (a pulse, not a blink). Bounded to `[PULSE_MIN, PULSE_MAX]` so the + * halo is always visible and never fully transparent, and periodic in [phase] + * so it is seamless at the wrap. Pure, so the rhythm is asserted without any + * frame-timing. + */ +internal fun pulseAlpha(phase: Float): Float { + val t = ((phase % 1f) + 1f) % 1f + val wave = (sin(t * 2.0 * PI) + 1.0) / 2.0 + return (PULSE_MIN + (PULSE_MAX - PULSE_MIN) * wave).toFloat() +} + +/** Faintest the active halo ever gets; never invisible, never a blink-off. */ +private const val PULSE_MIN = 0.35f + +/** Strongest the active halo gets at the peak of a pulse. */ +private const val PULSE_MAX = 0.9f + +/** + * The fixed active-halo strength drawn when animation is off (the system + * setting, or a paused graph): clearly marked, just not moving. Within the + * [pulseAlpha] range so the static state looks like a frozen pulse. + */ +internal const val ACTIVE_HALO_STATIC_ALPHA = 0.85f diff --git a/android/app/src/main/java/net/awan/pipelines/ui/graph/WorkflowGraph.kt b/android/app/src/main/java/net/awan/pipelines/ui/graph/WorkflowGraph.kt index 36030c23..a5f14356 100644 --- a/android/app/src/main/java/net/awan/pipelines/ui/graph/WorkflowGraph.kt +++ b/android/app/src/main/java/net/awan/pipelines/ui/graph/WorkflowGraph.kt @@ -1,5 +1,12 @@ package net.awan.pipelines.ui.graph +import android.animation.ValueAnimator +import androidx.compose.animation.core.LinearEasing +import androidx.compose.animation.core.RepeatMode +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.Canvas import androidx.compose.foundation.ExperimentalFoundationApi import androidx.compose.foundation.background @@ -29,6 +36,7 @@ import androidx.compose.runtime.LaunchedEffect import androidx.compose.runtime.getValue import androidx.compose.runtime.mutableFloatStateOf import androidx.compose.runtime.mutableIntStateOf +import androidx.compose.runtime.mutableLongStateOf import androidx.compose.runtime.mutableStateOf import androidx.compose.runtime.remember import androidx.compose.runtime.rememberCoroutineScope @@ -37,6 +45,7 @@ import androidx.compose.runtime.setValue import androidx.compose.ui.Alignment import androidx.compose.ui.Modifier import androidx.compose.ui.draw.clipToBounds +import androidx.compose.ui.geometry.CornerRadius import androidx.compose.ui.geometry.Offset import androidx.compose.ui.geometry.Size import androidx.compose.ui.graphics.Color @@ -56,6 +65,7 @@ import androidx.compose.ui.semantics.contentDescription import androidx.compose.ui.semantics.onClick import androidx.compose.ui.semantics.role import androidx.compose.ui.semantics.semantics +import androidx.compose.ui.text.TextLayoutResult import androidx.compose.ui.text.TextMeasurer import androidx.compose.ui.text.TextStyle import androidx.compose.ui.text.drawText @@ -66,8 +76,13 @@ import androidx.compose.ui.unit.IntOffset import androidx.compose.ui.unit.IntSize import androidx.compose.ui.unit.dp import androidx.compose.ui.unit.sp +import androidx.lifecycle.Lifecycle +import androidx.lifecycle.compose.LocalLifecycleOwner +import androidx.lifecycle.compose.currentStateAsState import kotlin.math.abs +import kotlin.math.hypot import kotlin.math.roundToInt +import kotlinx.coroutines.delay import kotlinx.coroutines.launch import net.awan.pipelines.data.protocol.Graph import net.awan.pipelines.data.protocol.GraphEdge @@ -76,6 +91,8 @@ import net.awan.pipelines.data.protocol.GraphSemantics import net.awan.pipelines.data.protocol.Protocol import net.awan.pipelines.data.protocol.RunGraphState import net.awan.pipelines.data.protocol.edges +import net.awan.pipelines.ui.formatDuration +import net.awan.pipelines.ui.secondsSince internal data class NodeLayout( val key: String, @@ -218,6 +235,48 @@ fun WorkflowGraph( ) } + // Motion gates, all pure and testable (see GraphMotion.kt): only a live run, + // with animations enabled and the graph on screen, animates. Never animate a + // finished run; pause when the graph is off screen or when the OS animation + // setting is off. ValueAnimator.areAnimatorsEnabled() reflects the system + // "Remove animations"/animation-scale setting; it is re-read on resume. + val lifecycleState by LocalLifecycleOwner.current.lifecycle.currentStateAsState() + val onScreen = lifecycleState.isAtLeast(Lifecycle.State.RESUMED) + val animationsEnabled = remember(onScreen) { ValueAnimator.areAnimatorsEnabled() } + val animate = graphShouldAnimate(runState, animationsEnabled, onScreen) + val phase = rememberPulsePhase(animate) + + // The active stage's live ticking elapsed time. The loop only runs while + // animating, so a finished run, a paused/off-screen graph and an + // animations-disabled device never wake up once a second; in those cases the + // value is a static snapshot for a clearly marked running state. + val activeStartedAt = runState?.currentStageStartedAt + var nowMillis by remember { mutableLongStateOf(System.currentTimeMillis()) } + LaunchedEffect(animate, activeStartedAt) { + if (!animate || activeStartedAt.isNullOrBlank()) return@LaunchedEffect + while (true) { + nowMillis = System.currentTimeMillis() + delay(ELAPSED_TICK_MILLIS) + } + } + // Measured once per second (never per frame) so the canvas draw adds no + // allocation for the timer. + val elapsedLayout = remember(activeStartedAt, nowMillis, scheme, density) { + secondsSince(activeStartedAt.orEmpty(), nowMillis) + ?.let(::formatDuration) + ?.let { + textMeasurer.measure( + it, + TextStyle(fontSize = 11.sp, fontWeight = FontWeight.Medium, color = colors.nodeText), + ) + } + } + // Halo and badge geometry as dp tokens (like the node layout), so they scale + // with the device rather than sitting at a raw pixel size. + val haloGapPx = with(density) { ACTIVE_HALO_GAP.toPx() } + val haloStrokePx = with(density) { ACTIVE_HALO_STROKE.toPx() } + val elapsedInsetPx = with(density) { ELAPSED_INSET.toPx() } + Box( modifier = modifier // Let an expand scroll the (now taller) panel back into the visible @@ -275,9 +334,22 @@ fun WorkflowGraph( }) { // Labels are drawn only after every curve so they always sit on // top of a neighbouring edge instead of being crossed by it. - drawEdgePaths(layout, colors, runState) + drawEdgePaths(layout, colors, runState, animate, phase) drawEdgeLabels(layout, colors, runState, textMeasurer) - drawNodes(layout, colors, runState, selectedStage, stageTypeByKey, textMeasurer) + drawNodes( + layout, + colors, + runState, + selectedStage, + stageTypeByKey, + textMeasurer, + animate, + phase, + elapsedLayout, + haloGapPx, + haloStrokePx, + elapsedInsetPx, + ) } } // Accessibility overlay: invisible nodes carrying a click action and a @@ -1063,6 +1135,8 @@ private fun DrawScope.drawEdgePaths( layout: GraphLayout, colors: GraphColors, runState: RunGraphState?, + animate: Boolean, + phase: Float, ) { for (edge in layout.edges) { // Routing already happened once in layoutGraph; drawing only replays the @@ -1080,14 +1154,18 @@ private fun DrawScope.drawEdgePaths( // screenshot, a dim screen and a colour-blind reader. An executed // `success`/`error` edge uses the heavier pass/fail width, a stronger // (same-hue) stroke and a matched arrowhead, so pass/fail dominates. - if (edgeIsExecuted(edge.edge, runState)) { + val motion = edgeMotion(edge.edge, runState) + if (motion != EdgeMotion.Unvisited) { val color = edgeStrokeColor(edge.edge, runState, colors) - drawPath( - path, - color = color, - style = Stroke(width = edgeStrokeWidth(edge.edge, runState)), - ) + val width = edgeStrokeWidth(edge.edge, runState) + drawPath(path, color = color, style = Stroke(width = width)) drawArrowHead(points, color, edgeArrowHeadSize(edge.edge, runState)) + // While the run is live, an executed route carries a dot travelling + // source -> target so its direction reads at a glance. A settled or + // off-screen graph draws no dot. + if (animate && motion == EdgeMotion.Flowing) { + drawFlowDots(points, width, colors.nodeText, phase) + } } else { drawPath( path, @@ -1101,6 +1179,51 @@ private fun DrawScope.drawEdgePaths( } } +/** + * Draws [FLOW_DOT_COUNT] dots travelling along [points] from start to end, + * spaced evenly and advanced by [phase] (0..1), so the executed route reads its + * direction. Allocation-free: it walks the stored polyline with scalars only, so + * it is safe to call on every animation frame. The dot radius scales with the + * edge's own [strokeWidth] so it matches a pass/fail or normal route. + */ +private fun DrawScope.drawFlowDots( + points: List, + strokeWidth: Float, + color: Color, + phase: Float, +) { + var total = 0f + for (i in 1 until points.size) { + total += hypot(points[i].x - points[i - 1].x, points[i].y - points[i - 1].y) + } + if (total <= 0f) return + val radius = strokeWidth * FLOW_DOT_SCALE + for (dot in 0 until FLOW_DOT_COUNT) { + val fraction = ((phase + dot.toFloat() / FLOW_DOT_COUNT) % 1f + 1f) % 1f + val center = pointAlong(points, fraction * total) ?: continue + drawCircle(color = color, radius = radius, center = center) + } +} + +/** + * The point [distance] along the polyline [points], or null when there is no + * segment. Pure scalar interpolation with no allocation. + */ +private fun pointAlong(points: List, distance: Float): Offset? { + var remaining = distance + for (i in 1 until points.size) { + val a = points[i - 1] + val b = points[i] + val length = hypot(b.x - a.x, b.y - a.y) + if (remaining <= length) { + val t = if (length <= 0f) 0f else remaining / length + return Offset(a.x + (b.x - a.x) * t, a.y + (b.y - a.y) * t) + } + remaining -= length + } + return points.lastOrNull() +} + /** * Draws every outcome label in a second pass, after all curves, so a * neighbouring edge can never be drawn across a label. Each label sits on its @@ -1176,14 +1299,27 @@ private fun DrawScope.drawNodes( selectedStage: String?, stageTypeByKey: Map, textMeasurer: TextMeasurer, + animate: Boolean, + phase: Float, + elapsedLayout: TextLayoutResult?, + haloGapPx: Float, + haloStrokePx: Float, + elapsedInsetPx: Float, ) { for (node in layout.nodes) { - val executed = stageIsExecuted(node.key, runState) + val motion = nodeMotion(node.key, runState) + val executed = motion != NodeMotion.Unvisited val selected = node.key == selectedStage val kind = graphNodeKind(node.terminal, node.key, stageTypeByKey[node.key]) val topLeft = Offset(node.x, node.y) - val corner = androidx.compose.ui.geometry.CornerRadius(14f, 14f) + val corner = CornerRadius(NODE_CORNER_RADIUS, NODE_CORNER_RADIUS) val borderWidth = if (selected && !node.terminal) 4f else 2f + // The active stage carries a halo behind its fill: a pulse while + // animating, a fixed but clearly visible ring otherwise, so a live run's + // current stage is unmistakable with or without animation. + if (motion == NodeMotion.Active) { + drawActiveHalo(node, colors, animate, phase, corner, haloGapPx, haloStrokePx) + } val textColor: Color if (executed) { // Filled with a normal border, exactly as the definition-only view. @@ -1243,9 +1379,62 @@ private fun DrawScope.drawNodes( node.y + (node.height - measured.size.height) / 2f, ), ) + // The active stage's live elapsed time, drawn as a badge under its label + // from the pre-measured layout (so the draw pass adds no allocation), on + // a near-opaque surface chip so it stays legible over any node fill (the + // selected active node is filled light in the dark theme). Only the + // active node has one, and only while the run is live. + if (motion == NodeMotion.Active && elapsedLayout != null) { + val badgeTopLeft = Offset( + x = node.x + (node.width - elapsedLayout.size.width) / 2f, + y = node.y + node.height - elapsedLayout.size.height - elapsedInsetPx, + ) + drawRect( + color = colors.labelBackground.copy(alpha = 0.92f), + topLeft = Offset(badgeTopLeft.x - 3f, badgeTopLeft.y - 1f), + size = Size(elapsedLayout.size.width + 6f, elapsedLayout.size.height + 2f), + ) + drawText(textLayoutResult = elapsedLayout, topLeft = badgeTopLeft) + } } } +/** + * The halo that makes the active stage unmistakable: a rounded-rect ring drawn a + * little outside the node, behind its fill, plus a soft glow filling the ring so + * it reads even at a small fit scale. Its strength is the smooth [pulseAlpha] + * while animating and [ACTIVE_HALO_STATIC_ALPHA] when the graph is static + * (animations disabled or paused), so the active stage is clearly marked in both + * cases. Drawing it uses only primitives, so it allocates nothing. + */ +private fun DrawScope.drawActiveHalo( + node: NodeLayout, + colors: GraphColors, + animate: Boolean, + phase: Float, + corner: CornerRadius, + gap: Float, + strokeWidth: Float, +) { + val strength = if (animate) pulseAlpha(phase) else ACTIVE_HALO_STATIC_ALPHA + val topLeft = Offset(node.x - gap, node.y - gap) + val size = Size(node.width + gap * 2f, node.height + gap * 2f) + val haloCorner = CornerRadius(corner.x + gap, corner.y + gap) + drawRoundRect( + color = colors.nodeBorderActive.copy(alpha = strength * ACTIVE_HALO_GLOW), + topLeft = topLeft, + size = size, + cornerRadius = haloCorner, + ) + drawRoundRect( + color = colors.nodeBorderActive.copy(alpha = strength), + topLeft = topLeft, + size = size, + cornerRadius = haloCorner, + style = Stroke(width = strokeWidth), + ) +} + /** * The colour for an outcome: the theme error role for `error`, a clearly * positive theme colour for `success`, and the curated [GraphPalette] entry for @@ -1323,7 +1512,12 @@ private fun graphDescription(graph: Graph, runState: RunGraphState?): String { for (stage in graph.stages) { val executed = stageIsExecuted(stage.key, runState) builder.append("Stage ${stage.key}") - if (runState != null) builder.append(if (executed) ", executed" else ", not executed") + if (runState != null) { + builder.append(if (executed) ", executed" else ", not executed") + if (runState.executing && stage.key == runState.currentStage) { + builder.append(", currently running") + } + } builder.append(". ") for (outcome in GraphSemantics.outcomes(stage)) { val target = Protocol.resolveTarget(outcome, stage.edges[outcome] ?: continue) @@ -1342,6 +1536,54 @@ private const val MAX_SCALE = 3f private val FIT_PADDING = 16.dp private val MIN_VISIBLE = 48.dp +/** + * The active-node pulse: one full cycle per [PULSE_PERIOD_MILLIS], driven by a + * linear 0..1 phase and mapped to a smooth strength by [pulseAlpha]. A slow sine + * is a halo, never a blink. Only composed while [graphShouldAnimate] is true, so + * a finished, off-screen or animations-disabled graph has no animation clock. + */ +@Composable +private fun rememberPulsePhase(animate: Boolean): Float { + if (!animate) return 0f + val transition = rememberInfiniteTransition(label = "graph-pulse") + val phase by transition.animateFloat( + initialValue = 0f, + targetValue = 1f, + animationSpec = infiniteRepeatable( + animation = tween(durationMillis = PULSE_PERIOD_MILLIS, easing = LinearEasing), + repeatMode = RepeatMode.Restart, + ), + label = "graph-pulse-phase", + ) + return phase +} + +/** One pulse (and one full pass of the edge flow) per this many milliseconds. */ +private const val PULSE_PERIOD_MILLIS = 1_600 + +/** The active stage's elapsed time ticks once a second, never per frame. */ +private const val ELAPSED_TICK_MILLIS = 1_000L + +/** Corner radius of a node rect, shared by the fill/border and the active halo. */ +private const val NODE_CORNER_RADIUS = 14f + +/** + * The active halo: how far outside the node it sits, how thick its ring is, and + * how much of the pulse strength its soft glow carries. dp tokens (like the node + * layout) so they scale with the device; the raw node border/corner literals are + * pre-existing graph geometry. + */ +private val ACTIVE_HALO_GAP = 6.dp +private val ACTIVE_HALO_STROKE = 4.dp +private const val ACTIVE_HALO_GLOW = 0.28f + +/** Bottom inset of the active node's elapsed-time badge inside the node rect. */ +private val ELAPSED_INSET = 4.dp + +/** Executed-edge flow: this many dots per route, sized against the edge stroke. */ +private const val FLOW_DOT_COUNT = 2 +private const val FLOW_DOT_SCALE = 1.2f + /** * Line-style tokens shared by the graph and its legend. Widths and the arrowhead * size are named here so no call site writes a stroke literal. An executed route diff --git a/android/app/src/main/java/net/awan/pipelines/ui/screens/RunDetailScreen.kt b/android/app/src/main/java/net/awan/pipelines/ui/screens/RunDetailScreen.kt index 090ad2ab..07cf7c31 100644 --- a/android/app/src/main/java/net/awan/pipelines/ui/screens/RunDetailScreen.kt +++ b/android/app/src/main/java/net/awan/pipelines/ui/screens/RunDetailScreen.kt @@ -368,7 +368,11 @@ private fun RunGraphTab( onStageTap: (String, Int) -> Unit, ) { val text = pipelinesText() - val runState = remember(run.id, run.steps) { RunGraphState.from(run) } + // Keyed on the fields RunGraphState.from reads (steps, executing, current + // stage) so a run that finishes without a new step still stops animating. + val runState = remember(run.id, run.steps, run.executing, run.currentStage) { + RunGraphState.from(run) + } // Grouped once per step-list change; the sheet opened from the graph starts on // the most recent visit of the tapped stage. val timeline = remember(run.steps) { runTimeline(run.steps) } @@ -385,7 +389,7 @@ private fun RunGraphTab( Text("This server did not include the run graph.", style = text.meta) } else { Text( - "Executed stages and routes are solid; not-executed ones are dashed and outlined. Executed success and failure routes are drawn thickest. Pinch to zoom, drag to pan, tap a stage for details.", + "The running stage pulses with its elapsed time and executed routes flow; a finished run settles, and with animations off the running stage stays marked. Solid means executed, dashed and outlined not executed; executed success and failure routes are drawn thickest. Pinch to zoom, drag to pan, tap a stage for details.", style = text.meta, ) WorkflowGraph( diff --git a/android/app/src/test/java/net/awan/pipelines/data/protocol/GraphSemanticsTest.kt b/android/app/src/test/java/net/awan/pipelines/data/protocol/GraphSemanticsTest.kt index 0222fc6f..317e84b6 100644 --- a/android/app/src/test/java/net/awan/pipelines/data/protocol/GraphSemanticsTest.kt +++ b/android/app/src/test/java/net/awan/pipelines/data/protocol/GraphSemanticsTest.kt @@ -2,6 +2,7 @@ package net.awan.pipelines.data.protocol import org.junit.Assert.assertEquals import org.junit.Assert.assertFalse +import org.junit.Assert.assertNull import org.junit.Assert.assertTrue import org.junit.Test @@ -77,5 +78,34 @@ class GraphSemanticsTest { assertEquals(setOf("a", "b", "#failure", "#success"), state.visitedStages) assertTrue(GraphRoute("a", "error", "#failure") in state.takenRoutes) assertEquals("b", state.currentStage) + // A finished run animates nothing: no executing flag, no live start. + assertFalse(state.executing) + assertNull(state.currentStageStartedAt) + } + + @Test + fun runGraphStateCarriesTheLiveStageAndItsStart() { + val run = RunDetail( + id = 2, + name = "demo", + status = "running", + executing = true, + currentStage = "b", + steps = listOf( + RunStep( + sequence = 1, + stage = "a", + status = "succeeded", + startedAt = "2026-10-16T07:00:00Z", + finishedAt = "2026-10-16T07:01:00Z", + ), + RunStep(sequence = 2, stage = "b", status = "running", startedAt = "2026-10-16T07:01:00Z"), + ), + ) + val state = RunGraphState.from(run) + assertTrue(state.executing) + assertEquals("b", state.currentStage) + // The timer rides on the stage the run is on, from that visit's start. + assertEquals("2026-10-16T07:01:00Z", state.currentStageStartedAt) } } diff --git a/android/app/src/test/java/net/awan/pipelines/ui/FormatTest.kt b/android/app/src/test/java/net/awan/pipelines/ui/FormatTest.kt index dfd748f3..faa52a29 100644 --- a/android/app/src/test/java/net/awan/pipelines/ui/FormatTest.kt +++ b/android/app/src/test/java/net/awan/pipelines/ui/FormatTest.kt @@ -33,6 +33,19 @@ class FormatTest { assertNull(formatDuration("2026-10-15T02:05:00Z", "2026-10-15T02:00:00Z")) } + @Test + fun secondsSinceCountsFromTheStartAndIsSafe() { + // 2026-10-15T02:00:00Z in epoch millis, plus a minute and a bit. + val startMillis = parseInstant("2026-10-15T02:00:00Z")!!.toInstant().toEpochMilli() + assertEquals(0L, secondsSince("2026-10-15T02:00:00Z", startMillis)) + assertEquals(125L, secondsSince("2026-10-15T02:00:00Z", startMillis + 125_000)) + // A start in the future clamps to 0 rather than going negative. + assertEquals(0L, secondsSince("2026-10-15T02:00:00Z", startMillis - 5_000)) + // Blank or unparseable starts are "no elapsed", never a fabricated value. + assertNull(secondsSince("", startMillis)) + assertNull(secondsSince("not a timestamp", startMillis)) + } + @Test fun fileChangesSummaryOmitsBlankParts() { assertEquals("", fileChangesSummary(StageFileChanges())) diff --git a/android/app/src/test/java/net/awan/pipelines/ui/graph/GraphMotionTest.kt b/android/app/src/test/java/net/awan/pipelines/ui/graph/GraphMotionTest.kt new file mode 100644 index 00000000..69c5f5a5 --- /dev/null +++ b/android/app/src/test/java/net/awan/pipelines/ui/graph/GraphMotionTest.kt @@ -0,0 +1,147 @@ +package net.awan.pipelines.ui.graph + +import net.awan.pipelines.data.protocol.Graph +import net.awan.pipelines.data.protocol.GraphRoute +import net.awan.pipelines.data.protocol.RunGraphState +import net.awan.pipelines.data.protocol.Stage +import net.awan.pipelines.data.protocol.edges +import org.junit.Assert.assertEquals +import org.junit.Assert.assertFalse +import org.junit.Assert.assertTrue +import org.junit.Test +import kotlin.math.abs + +/** + * The graph's motion is a pure decision: which node/edge is in which visual + * state, and whether the graph animates at all, are functions of the run state + * only. These tests assert that policy directly, with no frame clock, so a + * finished run, a paused graph and the animations-off setting are all covered + * without timing a single frame. + */ +class GraphMotionTest { + + private fun stage(key: String, edges: Map) = Stage(key = key, edges = edges) + + private fun graph() = Graph( + stages = listOf( + stage("planner", mapOf("success" to "implementer", "error" to "#failure")), + stage("implementer", mapOf("success" to "reviewer", "error" to "#failure")), + stage("reviewer", mapOf("success" to "#success", "error" to "#failure")), + ), + ) + + private fun takenRoute() = graph().edges().first { it.source == "planner" && it.outcome == "success" } + + private fun untakenRoute() = graph().edges().first { it.source == "planner" && it.outcome == "error" } + + /** A live run paused on `implementer`, with a recorded start for the tick. */ + private fun liveRun(): RunGraphState { + val taken = takenRoute() + return RunGraphState( + visitedStages = setOf("planner", "implementer"), + takenRoutes = setOf(GraphRoute(taken.source, taken.outcome, taken.target)), + currentStage = "implementer", + executing = true, + currentStageStartedAt = "2026-10-16T07:36:56+01:00", + ) + } + + private fun finishedRun(): RunGraphState = + liveRun().copy(executing = false, currentStageStartedAt = null) + + @Test + fun graphAnimatesOnlyForALiveRunOnScreenWithAnimationsEnabled() { + val live = liveRun() + assertTrue(graphShouldAnimate(live, animationsEnabled = true, onScreen = true)) + // None of the three gates alone is enough. + assertFalse("finished runs never animate", graphShouldAnimate(finishedRun(), true, true)) + assertFalse("animations disabled", graphShouldAnimate(live, animationsEnabled = false, onScreen = true)) + assertFalse("off screen", graphShouldAnimate(live, animationsEnabled = true, onScreen = false)) + assertFalse("definition view", graphShouldAnimate(null, animationsEnabled = true, onScreen = true)) + } + + @Test + fun theRunningStageIsTheOnlyActiveNode() { + val live = liveRun() + assertEquals(NodeMotion.Active, nodeMotion("implementer", live)) + assertEquals(NodeMotion.Visited, nodeMotion("planner", live)) + assertEquals(NodeMotion.Unvisited, nodeMotion("reviewer", live)) + assertEquals(NodeMotion.Unvisited, nodeMotion("#success", live)) + } + + /** + * The live stage is active even before its step is recorded: [visitedStages] + * comes from the recorded steps, so a just-started stage can lag it. The halo + * must not depend on that ordering. + */ + @Test + fun theExecutingStageIsActiveEvenBeforeItsStepIsRecorded() { + val noStepsYet = RunGraphState( + visitedStages = emptySet(), + takenRoutes = emptySet(), + currentStage = "implementer", + executing = true, + currentStageStartedAt = "2026-10-16T07:36:56+01:00", + ) + assertEquals(NodeMotion.Active, nodeMotion("implementer", noStepsYet)) + } + + @Test + fun aFinishedRunHasNoActiveNode() { + val finished = finishedRun() + assertEquals(NodeMotion.Visited, nodeMotion("implementer", finished)) + assertEquals(NodeMotion.Visited, nodeMotion("planner", finished)) + assertEquals(NodeMotion.Unvisited, nodeMotion("reviewer", finished)) + } + + @Test + fun theDefinitionViewIsEntirelySettledAndStatic() { + for (key in listOf("planner", "implementer", "reviewer", "#success", "#failure")) { + assertEquals(key, NodeMotion.Visited, nodeMotion(key, null)) + } + } + + @Test + fun takenRoutesFlowOnlyWhileTheRunIsLive() { + assertEquals(EdgeMotion.Flowing, edgeMotion(takenRoute(), liveRun())) + assertEquals(EdgeMotion.Settled, edgeMotion(takenRoute(), finishedRun())) + assertEquals(EdgeMotion.Unvisited, edgeMotion(untakenRoute(), liveRun())) + assertEquals(EdgeMotion.Unvisited, edgeMotion(untakenRoute(), finishedRun())) + // Definition view: every route is executed, so settled/static (as before). + assertEquals(EdgeMotion.Settled, edgeMotion(takenRoute(), null)) + assertEquals(EdgeMotion.Settled, edgeMotion(untakenRoute(), null)) + } + + /** + * The active halo is a smooth pulse, not a blink: it stays visible, changes + * gradually between samples, both rises and falls, wraps seamlessly, and has + * a clear peak (not two alternating values). + */ + @Test + fun pulseAlphaIsABoundedSmoothNonBinaryRhythm() { + var previous = pulseAlpha(0f) + var sawIncrease = false + var sawDecrease = false + for (i in 1..100) { + val value = pulseAlpha(i / 100f) + assertTrue("in (0,1]: $value", value > 0f && value <= 1f) + assertTrue("always visible: $value", value > 0.2f) + if (value > previous) sawIncrease = true + if (value < previous) sawDecrease = true + assertTrue("continuous at $i ($value vs $previous)", abs(value - previous) < 0.1f) + previous = value + } + assertTrue("rises then falls", sawIncrease && sawDecrease) + // Periodic: the cycle wraps without a jump. + assertEquals(pulseAlpha(0f), pulseAlpha(1f), 0.0001f) + // A clear peak early in the cycle and a trough later; not a two-value blink. + assertTrue(pulseAlpha(0.25f) > pulseAlpha(0.75f)) + assertTrue(pulseAlpha(0.25f) - pulseAlpha(0.75f) > 0.2f) + } + + @Test + fun staticHaloIsClearlyVisible() { + assertTrue(ACTIVE_HALO_STATIC_ALPHA in 0.5f..1f) + assertTrue(ACTIVE_HALO_STATIC_ALPHA > 0f) + } +} From e5bde981eea75cf70c315c0f932e24dceaad0a62 Mon Sep 17 00:00:00 2001 From: Alan Silva Date: Fri, 16 Oct 2026 11:50:08 +0100 Subject: [PATCH 9/9] Modernise the workflow graph's visual language Replace the old terminal-diagram look on the Graph tab with a tonal surface language, keeping the same information and every outcome hue. - Nodes: stages are rounded rectangles from MaterialTheme.shapes.medium, terminals become pills (height/2). Fills are tonal surfaces via the new pure tonalFill(surface, accent, fraction) with a soft outlineVariant border instead of a flat fill plus hard outline. - Type: node names use the cardTitle role and outcome labels the label role, with theme line height/letter spacing; the [brackets] and all-caps are gone (nodeDisplayLabel renders Success/Failure title-cased in colour). - Edges: StrokeCap.Round/StrokeJoin.Round, bends rounded by one ROUTE_CORNER_RADIUS (cornerCutRadius clamps short segments), filled arrowheads scaled as edgeStrokeWidth * ARROW_HEAD_SCALE, and labels on a shared DrawScope tonal chip. - Spacing: named dp tokens instead of ad-hoc literals. Adds pure-logic unit tests (WorkflowGraphTest, GraphPaletteTest) and documents the change in android/README.md. Verified: :app:assembleDebug and :app:testDebugUnitTest both BUILD SUCCESSFUL (207 tests, 0 failures) with no Kotlin warnings. --- android/README.md | 281 ++++++++++++- .../awan/pipelines/ui/graph/WorkflowGraph.kt | 370 ++++++++++++++---- .../pipelines/ui/graph/GraphPaletteTest.kt | 21 + .../pipelines/ui/graph/WorkflowGraphTest.kt | 56 +++ 4 files changed, 644 insertions(+), 84 deletions(-) diff --git a/android/README.md b/android/README.md index b120e449..03a6d41e 100644 --- a/android/README.md +++ b/android/README.md @@ -122,7 +122,17 @@ stops it. zoom is anchored to the gesture centroid: the pure `zoomAbout` keeps the content point under the fingers fixed (clamped to `MIN_SCALE`/`MAX_SCALE`) and the existing pan clamp is applied afterwards, so the content no longer slides - away from the fingers. + away from the fingers. The visual language is a modern surface, not a terminal + diagram: a stage is a rounded rectangle (the theme's `shapes.medium`) and a + terminal a pill, both filled with a tonal surface tinted with the node's + semantic hue behind a soft border (not a flat fill plus hard outline); the node + name and the outcome labels use the app's type scale (`cardTitle`/`label`, no + ad-hoc sizes, no all-caps, terminal `Success`/`Failure` in their own colour); + edges draw with round caps/joins and every right-angle bend is rounded by one + `ROUTE_CORNER_RADIUS` control offset over the unchanged stored polyline, with a + filled arrowhead proportional to its stroke and the outcome label on a rounded + tonal chip rather than raw text over the canvas; node and per-edge-track spacing + are named dp tokens. - One shared graph-panel height (`collapsedGraphHeight`/`expandedGraphHeight`) replaces the former 360.dp and 340.dp literals, so both detail screens render the graph at the same size: about 58% of the window height floored at a height @@ -1876,8 +1886,10 @@ never installed on or driven). treats `success` (pass) and `error` (fail) as the emphasised outcomes (`isPassFailOutcome`). An executed pass/fail edge is drawn at `PASSFAIL_EDGE_STROKE = 7f` — noticeably heavier than the previous `3f` — with - a stronger, more saturated stroke and a matching `PASSFAIL_ARROW_HEAD_SIZE = - 20f` arrowhead, so pass/fail is obvious at a glance and from a distance. + a stronger, more saturated stroke and a filled arrowhead proportional to its + own width (`edgeArrowHeadSize`, i.e. `strokeWidth * ARROW_HEAD_SCALE` with + `ARROW_HEAD_SCALE = 4`: 28f for this 7f pass/fail stroke, 12f for a normal + executed route), so pass/fail is obvious at a glance and from a distance. - **Other lines stay finer.** Every other executed outcome keeps `EDGE_STROKE = 3f`, and a not-executed edge uses the finer `INACTIVE_EDGE_STROKE = 2.5f`, so the two emphasised outcomes dominate. No outcome hue changed. @@ -1952,3 +1964,266 @@ fold (the wide layout was produced with `wm size`/`wm density`); the on-device captures used the debug build of this source, while the published APK is a clean rebuild of the same source. +## A modern visual language for the workflow graph (16 Oct 2026) + +The graph read like an old terminal diagram (flat fills, hard outlines, sharp +right angles, `[bracketed]` all-caps labels, small arrowheads, raw text over the +canvas). This pass gives it a modern surface language without changing any +information or any hue. `android/` only; no dependency was added (the graph's +corner comes from the theme's own shape scale), no run was started from the app, +and every `adb`/emulator command targeted `emulator-5556` (lane A's +`emulator-5554` was never used; the attached Pixel was never installed on or +driven). The only modified tracked files are the four under `android/` shown in +`git status --short` below; the capture runs also leave untracked scratch +directories at the repo root (`.ui_review*/`), so a bare `git status --short` is +not clean and the "nothing outside `android/` touched" claim is only about the +change itself, not those untracked captures. + +- **Nodes are rounded and tonal, terminals are pills.** `WorkflowGraph.kt` reads + `MaterialTheme.shapes.medium` once per composition for a stage's corner and + gives a terminal a full pill (`height/2`), so a terminal is visibly not a stage. + The fill is a *tonal surface*: the new pure `tonalFill(surface, accent, + fraction)` blends a raised `surfaceContainerHigh` with a subtle fraction of the + node's semantic colour (`NEUTRAL_TINT`/`KIND_TINT` for a stage by kind, + `TERMINAL_TINT` for a terminal's success/error hue), and the hard outline is + replaced by a soft `outlineVariant` border (`NODE_BORDER`, strengthened for a + selected stage with `NODE_BORDER_SELECTED`). Every kind's hue survives; the + terminal fill now genuinely tints the outcome hue. +- **Type comes from the app's scale.** The node name uses the app's `cardTitle` + role and the outcome labels its `label` role (no ad-hoc `13.sp`/`11.sp`), with + the theme's own line height and letter spacing; the `[brackets]` and the + all-caps `SUCCESS`/`FAILURE` are gone — the graph shows `Success`/`Failure` in + the terminal's own colour (the new pure `nodeDisplayLabel`; the shared + `GraphSemantics.nodeLabel` the TUI-mirroring panes use is untouched). +- **Edges are smoother, with one control offset and matched arrowheads.** The + stored route is still the axis-aligned polyline (`routePoints`, and its layout + tests, are unchanged), but drawing now rounds every right-angle bend with the + single `ROUTE_CORNER_RADIUS` control offset (the pure `cornerCutRadius` clamps a + short adjacent segment to half its length so two cut-backs can never meet), + uses `StrokeCap.Round`/`StrokeJoin.Round`, and scales the filled arrowhead to + the line with one `ARROW_HEAD_SCALE` (`edgeArrowHeadSize = edgeStrokeWidth * + ARROW_HEAD_SCALE`). Labels sit on a rounded *tonal chip* (`tonalFill` of the + raised surface with the label's own colour) instead of raw text over the canvas. +- **More breathing room, from named tokens.** Node width/height, the horizontal + gap, the graph padding, the per-edge lane spacing and track step, and the + terminal-row gap are now named dp tokens (no inline geometry literals); the + values grew so nodes and the per-edge tracks have visibly more room, and the + collapsed-panel floor grew to `320.dp` to still fit a 4-stage graph with its + terminal row. +- **Nothing semantic changed.** The executed/not-executed structural split (solid + full-colour + arrowhead vs dashed muted + no arrowhead; filled vs hollow/dashed + node), the pass/fail emphasis (heavier, same-hue, more-saturated stroke with the + largest head), the selected-stage invert, ntfy/custom/model kind tints, the + `error*` fallback label, the legend, the active halo/elapsed badge, the flow + dots and the screen-reader description are all kept. `graphColors` and + `outcomeColor` keep their field names, so the Timeline step chips that share + them still agree with the graph. + +Verification (macOS, Homebrew JDK 25 `openjdk@25`, Gradle 9.7.1, +`ANDROID_HOME=/Users/alan/Library/Android/sdk`, `--offline`): + +- `gradle --offline :app:testDebugUnitTest --rerun-tasks` → `BUILD SUCCESSFUL`; + the test-result XMLs aggregate to **207 tests, 0 failures, 0 errors, 0 + skipped** (4 new: `WorkflowGraphTest` for the readable node labels, the + arrowhead proportional to its stroke and the corner-cut clamp, and + `GraphPaletteTest` for `tonalFill`). `compileDebugKotlin` emitted no warnings + (the deprecated `quadraticBezierTo` was replaced by `quadraticTo`). +- `gradle --offline :app:assembleDebug` → `BUILD SUCCESSFUL`; `app-debug.apk` is + **17,928,873 bytes**, sha256 + `ba5bcc467989425b69aad2ae70799c0cf4d9eaf54be30243b4631fb7e94916b3`. +- On `emulator-5556` (`FoldB_API_36`, dark mode) against the live server + `ws://10.0.2.2:8080/connect`, driven with `adb shell input` and `uiautomator + dump`. Every capture was written with `android/scripts/capture_png.sh -s + emulator-5556` (validated PNG magic bytes, named display id) into + `~/.local/share/pipelines/data/artifacts/108/1/`. The three cases are a + definition-only graph (pipeline 3 "Plan, implement, review", 4 stages), a + partly executed run (run 94, failed at `committer`: `implementer`/`reviewer`/ + `ui_reviewer` and the failed `committer` executed, `Success` not) and its + selected (current) stage. Widths: **wide** 2208x1840 @ density 420 (≈841dp) and **narrow** + 1080x1920 @ density 480 (≈360dp); **2x** doubles the pixel size and density + (4416x3680 @840 and 2160x3840 @960), so the same dp layout is rendered at + double the pixels. "Before" is a clean `git archive 8b39c08` tree (never a + working-tree stash) built and installed; "after" is this tree. + - `{before,after}_wide_1x_definition.png`, `{before,after}_wide_2x_definition.png`, + `{before,after}_narrow_1x_definition.png`, `{before,after}_narrow_2x_definition.png` + — the definition graph; before shows `[planner]`/`[FAILURE]` rectangular + nodes with hard 90° routes and raw labels, after shows rounded, tonal nodes, + pill terminals and chipped labels. + - `{before,after}_wide_1x_run.png`, `{before,after}_wide_2x_run.png`, + `{before,after}_narrow_1x_run.png`, `{before,after}_narrow_2x_run.png` — run + 94; `implementer`/`reviewer`/`ui_reviewer` were visited and the failed + `committer` was visited too (it was entered and then failed), so all four + stages are filled and the selected `committer` inverts (light `inverseSurface` + fill, solid primary border); the executed `success`/`error` routes are the + boldest lines, and the not-executed `Success` terminal is hollow with a dashed + border (the `Failure` terminal, reached by the executed `error` edge, is + filled). The invert applies only to an *executed* stage; a selected + *not-executed* stage is instead drawn hollow with a dashed primary border + (`drawNodes`' not-executed branch), so selection is legible in either state. + - `{before,after}_{wide,narrow}_{1x,2x}_selected.png` — a 2x crop of the + selected `committer` node (its primary border and rounded shape after vs the + sharper `[committer]` before). + - `compare_wide_1x_definition.png`, `compare_wide_1x_run.png`, + `compare_narrow_1x_definition.png`, `compare_narrow_1x_run.png` — stacked + before/after sheets for the 1x narrow and wide cases. + - `adb -s emulator-5556 logcat -d` contained 0 `FATAL EXCEPTION` and 0 `E + AndroidRuntime` lines after a fresh launch and a Runs/Graph sweep; no run was + started from the app. The emulator's display was reset to its native + 2208x1840 @420 afterwards. +- **APK publish.** `app-debug.apk` was copied to + `~/.local/share/pipelines/data/artifacts/108/1/pipelines-debug-wip-8b39c08.apk` + (`8b39c08` = `git rev-parse --short HEAD`); `shasum -a 256` matched. `curl -I + http://10.0.0.249:8080/artifacts/108/1/pipelines-debug-wip-8b39c08.apk` (LAN + address from `ipconfig getifaddr en0`) returned `HTTP/1.1 200 OK`, + `Content-Type: application/vnd.android.package-archive`, `Content-Length: + 17928873`, and a streamed `GET | shasum -a 256` returned the same `ba5bcc46…` + as the local file. At 17.1 MiB it exceeds the server's 8 MiB per-file inventory + cap, so it is served by direct URL only. + +Not verified in this pass: `:app:lintDebug` (its only reported issues are the two +pre-existing `NewApi` errors for `android:windowLightNavigationBar`); the light +theme; the active/animating halo, elapsed badge and flow dots (the run 94 graph +is a finished run, so it renders settled — those live-run visuals are unchanged +by this pass and are covered by `GraphMotionTest`); a real hardware fold +(narrow/wide were produced with `wm size`/`wm density`); and a greyscale pass (the +executed/not-executed distinction is still structural, but only colour captures +were taken). The crops are derived from the full captures with PIL; the +full-size PNGs above are the primary evidence. + +### Review follow-up and re-verification (16 Oct 2026) + +A follow-up pass addressed the review findings on the code above. The rendered +surface is unchanged (the token conversion maps the former pixel literals onto the +same device-scaled geometry), and `android/` is still the only modified tree; the +untracked `.ui_review*/` scratch captures at the repo root are not part of it. + +- **Duplication.** The two near-identical rounded tonal chips (the edge outcome + labels and the active-stage elapsed badge) are now one + `DrawScope.drawTonalChip(textTopLeft, textSize, color)` helper; both call sites + pass the accent tinted into `labelBackground`, so the chip geometry lives once. +- **Redundant geometry.** `cornerCutRadius` now takes the adjacent segment lengths + the caller has already measured (`cornerCutRadius(inLength, outLength, radius)`), + so `roundedRoutePath` computes each corner's two `hypot`s once instead of twice. +- **Redundant width.** The new pure `arrowHeadSizeFor(strokeWidth)` is the one + arrowhead-from-stroke mapping; `drawEdgePaths` passes the width it has just + computed (`arrowHeadSizeFor(width)`) instead of re-deriving it, and + `edgeArrowHeadSize` delegates to the same function. +- **Geometry tokens.** `ROUTE_CORNER_RADIUS` (`7.dp`) and the chip + `EDGE_CHIP_PAD_X`/`EDGE_CHIP_PAD_Y`/`EDGE_CHIP_CORNER` (`2.dp`/`1.dp`/`2.dp`) are + dp tokens like the rest of the new graph geometry, not raw pixel literals. + +Re-run checks (same environment as above): + +- `gradle --offline :app:testDebugUnitTest` → `BUILD SUCCESSFUL`; the test-result + XMLs aggregate to **207 tests, 0 failures, 0 errors, 0 skipped** (the + `cornerCutRadius` test now exercises the length-based clamp). +- `gradle --offline :app:compileDebugKotlin --rerun-tasks` → `BUILD SUCCESSFUL` + with no `w:` warnings. +- `gradle --offline :app:assembleDebug --rerun-tasks` → `BUILD SUCCESSFUL`; + `app-debug.apk` is **17,928,873 bytes**, sha256 + `ab99e734b0b190294ebfad8d342caf599286cefda23a0faf39f0244496e3af1a`. (A full + `--rerun-tasks` rebuild is byte-reproducible — two consecutive runs produced + this same hash — whereas incremental packaging is not, so the published APK is + the `--rerun-tasks` one.) +- Smoke captures on `emulator-5556` (native 2208x1840 @420) with the rebuilt APK + (`adb -s emulator-5556 install -r app/build/outputs/apk/debug/app-debug.apk`), + written via `android/scripts/capture_png.sh -s emulator-5556`: + `followup_wide_1x_definition.png` (the pipeline 3 definition graph) and + `followup_wide_1x_run106.png` (run 106, all four stages visited) in + `~/.local/share/pipelines/data/artifacts/108/3/`. Both render the rounded tonal + nodes, pill terminals and chipped labels; run 106 shows the executed stages + filled, the selected `committer` inverted (light fill, solid primary border) and + the not-executed `Failure` terminal hollow with a dashed border — the same + structural executed/not-executed split, unchanged. `adb -s emulator-5556 logcat + -d | grep -cE 'FATAL EXCEPTION|E AndroidRuntime'` is `0`; the display was not + resized (still native 2208x1840 @420). +- **APK publish (this pass).** The rebuilt APK was copied to + `~/.local/share/pipelines/data/artifacts/108/3/pipelines-debug-wip-8b39c08.apk` + (`8b39c08` = `git rev-parse --short HEAD`). `curl -I + http://10.0.0.249:8080/artifacts/108/3/pipelines-debug-wip-8b39c08.apk` returned + `HTTP/1.1 200 OK`, `Content-Type: application/vnd.android.package-archive`, + `Content-Length: 17928873`, and a streamed `GET | shasum -a 256` returned the + same `ab99e734…` as the local file. + +### Second review follow-up (16 Oct 2026) + +Two remaining findings on the modernised graph were fixed. The rendered surface is +unchanged — the first is a same-value refactor, the second a doc-only correction — +so the before/after captures above still describe the output. + +- **One label colour, not two.** `drawEdgeLabels` declared `accent` and + `textColor` holding the identical value (both `outcomeColor(...)` when the edge + executed, else `colors.labelText`); they are now the single `labelColor`, used for + both the label text and its chip tint. No pixel changes. +- **README cites the live arrowhead token.** The dated "Pass/fail edges" section + cited the removed `PASSFAIL_ARROW_HEAD_SIZE = 20f`; it now describes the current + mapping (`edgeArrowHeadSize` = `strokeWidth * ARROW_HEAD_SCALE`, i.e. 28f + pass/fail and 12f normal), matching `WorkflowGraph.kt`. + +Re-verified (Homebrew `openjdk@25`, Gradle 9.7.1, +`ANDROID_HOME=/Users/alan/Library/Android/sdk`, `--offline`): + +- `gradle --offline :app:compileDebugKotlin --rerun-tasks` → `BUILD SUCCESSFUL` + with no `w:` warnings. +- `gradle --offline :app:testDebugUnitTest --rerun-tasks` → `BUILD SUCCESSFUL`; + the test-result XMLs aggregate to **207 tests, 0 failures, 0 errors, 0 skipped**. +- `gradle --offline :app:assembleDebug --rerun-tasks` → `BUILD SUCCESSFUL`; + `app-debug.apk` is **17,928,873 bytes**, sha256 + `c95fab884d392a2b3df6170ec2e16ccc4fdf6f1fef4e946425f5dcda56c881a7`, reproducibly + (two consecutive `--rerun-tasks` rebuilds matched). +- Smoke captures on `emulator-5556` (native 2208x1840 @420) with this APK, written + via `android/scripts/capture_png.sh -s emulator-5556`: + `followup2_wide_1x_launch.png`, `followup2_wide_1x_definition.png` (pipeline 3) + and `followup2_wide_1x_run.png` (run 109, partly executed) in + `~/.local/share/pipelines/data/artifacts/108/5/`. The definition graph renders + rounded tonal stages, pill terminals (filled `Failure`/`Success`) and chipped + labels; run 109 fills the visited stages, inverts the selected `committer` + (light fill, solid primary border) and leaves the not-executed `Failure` terminal + hollow with a dashed border. `adb -s emulator-5556 logcat -d | grep -cE 'FATAL + EXCEPTION|E AndroidRuntime'` is `0`. +- **APK publish (this pass).** The rebuilt APK was copied to + `~/.local/share/pipelines/data/artifacts/108/5/pipelines-debug-wip-8b39c08.apk` + (`8b39c08` = `git rev-parse --short HEAD`); `curl -I + http://10.0.0.249:8080/artifacts/108/5/pipelines-debug-wip-8b39c08.apk` returned + `HTTP/1.1 200 OK`, `Content-Type: application/vnd.android.package-archive`, + `Content-Length: 17928873`. + +### Re-verification with a fresh before/after capture set (run 117, 16 Oct 2026) + +The source is unchanged from the sections above; this pass re-ran every check on +it and produced a fresh, complete before/after capture set in +`~/.local/share/pipelines/data/artifacts/117/1/`. `android/` remains the only +modified tree (the untracked `.caps117/` scratch captures at the repo root and the +older `.ui_review*/` directories are not part of the change). No run was started +from the app, only `emulator-5556` was ever addressed, and its display was reset to +native 2208x1840 @420 at the end. + +- `gradle --offline :app:assembleDebug --rerun-tasks` → `BUILD SUCCESSFUL`; + `app-debug.apk` is **17,928,873 bytes**, sha256 + `c95fab884d392a2b3df6170ec2e16ccc4fdf6f1fef4e946425f5dcda56c881a7` (identical to + the "Second review follow-up" build above). +- `gradle --offline :app:testDebugUnitTest --rerun-tasks` → `BUILD SUCCESSFUL`; + the test-result XMLs aggregate to **207 tests, 0 failures, 0 errors, 0 skipped** + (the new `tonalFill`, `nodeDisplayLabel`, `arrowHeadScalesWithTheStrokeItTerminates` + and `cornerCutNeverExceedsHalfTheShorterSegment` tests included). +- **Captures.** The same four display configurations as the first pass + (`wm size`/`wm density`: wide 2208x1840 @420 and its 2x 4416x3680 @840; narrow + 1080x1920 @420 and its 2x 2160x3840 @840), each for the pipeline 3 + definition-only graph and the partly executed run 109 (the selected `committer`), + written with `android/scripts/capture_png.sh -s emulator-5556`: + `{before,after}_{wide,narrow}_{1x,2x}_{definition,run}.png`, the 2x-upscaled + `{before,after}_{wide,narrow}_{1x,2x}_selected.png` node crops, and the stacked + `compare_{wide,narrow}_1x_{definition,run}.png` sheets. The `before` images were + rebuilt from `HEAD` (the four tracked files stashed, `assembleDebug`, captured, + then the stash popped and the after build reproduced the same sha256); they show + the sharp-cornered flat fills, `[bracketed]` all-caps labels and thin raw-text + routes, while the `after` images show the rounded tonal stages, pill terminals + (`Failure` hollow/dashed when not executed, `Success` filled) and chipped labels. + `adb -s emulator-5556 logcat -d | grep -cE 'FATAL EXCEPTION|E AndroidRuntime'` + is `0`. +- **APK publish (this pass).** Copied to + `~/.local/share/pipelines/data/artifacts/117/1/pipelines-debug-wip-8b39c08.apk`; + `curl -I http://10.0.0.249:8080/artifacts/117/1/pipelines-debug-wip-8b39c08.apk` + returned `HTTP/1.1 200 OK`, `Content-Type: application/vnd.android.package-archive`, + `Content-Length: 17928873`. + diff --git a/android/app/src/main/java/net/awan/pipelines/ui/graph/WorkflowGraph.kt b/android/app/src/main/java/net/awan/pipelines/ui/graph/WorkflowGraph.kt index a5f14356..4ac392f8 100644 --- a/android/app/src/main/java/net/awan/pipelines/ui/graph/WorkflowGraph.kt +++ b/android/app/src/main/java/net/awan/pipelines/ui/graph/WorkflowGraph.kt @@ -51,6 +51,8 @@ import androidx.compose.ui.geometry.Size 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.TransformOrigin import androidx.compose.ui.graphics.drawscope.DrawScope import androidx.compose.ui.graphics.drawscope.Stroke @@ -67,15 +69,12 @@ import androidx.compose.ui.semantics.role import androidx.compose.ui.semantics.semantics import androidx.compose.ui.text.TextLayoutResult import androidx.compose.ui.text.TextMeasurer -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.unit.Dp import androidx.compose.ui.unit.IntOffset import androidx.compose.ui.unit.IntSize import androidx.compose.ui.unit.dp -import androidx.compose.ui.unit.sp import androidx.lifecycle.Lifecycle import androidx.lifecycle.compose.LocalLifecycleOwner import androidx.lifecycle.compose.currentStateAsState @@ -93,6 +92,8 @@ import net.awan.pipelines.data.protocol.RunGraphState import net.awan.pipelines.data.protocol.edges import net.awan.pipelines.ui.formatDuration import net.awan.pipelines.ui.secondsSince +import net.awan.pipelines.ui.theme.PipelinesTextStyles +import net.awan.pipelines.ui.theme.pipelinesText internal data class NodeLayout( val key: String, @@ -196,6 +197,13 @@ fun WorkflowGraph( val scheme = MaterialTheme.colorScheme val colors = remember(scheme) { graphColors(scheme) } + // The graph's type roles come from the app's one type scale (never ad-hoc + // sizes), and the corner radius from the app's shape scale rather than a raw + // literal; a terminal overrides it with a full pill in drawNodes. + val text = pipelinesText() + val nodeCornerPx = with(density) { MaterialTheme.shapes.medium.topStart.toPx(Size.Zero, this) } + val nodeBorderPx = with(density) { NODE_BORDER.toPx() } + val nodeBorderSelectedPx = with(density) { NODE_BORDER_SELECTED.toPx() } // node key -> stage type, derived once per graph (never per frame) so node // kind/colour and the spoken description share one lookup. val stageTypeByKey = remember(graph) { graph.stages.associate { it.key to it.type } } @@ -261,13 +269,13 @@ fun WorkflowGraph( } // Measured once per second (never per frame) so the canvas draw adds no // allocation for the timer. - val elapsedLayout = remember(activeStartedAt, nowMillis, scheme, density) { + val elapsedLayout = remember(activeStartedAt, nowMillis, scheme, density, text) { secondsSince(activeStartedAt.orEmpty(), nowMillis) ?.let(::formatDuration) ?.let { textMeasurer.measure( it, - TextStyle(fontSize = 11.sp, fontWeight = FontWeight.Medium, color = colors.nodeText), + text.label.copy(color = colors.nodeText), ) } } @@ -335,7 +343,7 @@ fun WorkflowGraph( // Labels are drawn only after every curve so they always sit on // top of a neighbouring edge instead of being crossed by it. drawEdgePaths(layout, colors, runState, animate, phase) - drawEdgeLabels(layout, colors, runState, textMeasurer) + drawEdgeLabels(layout, colors, runState, textMeasurer, text) drawNodes( layout, colors, @@ -343,6 +351,10 @@ fun WorkflowGraph( selectedStage, stageTypeByKey, textMeasurer, + text, + nodeCornerPx, + nodeBorderPx, + nodeBorderSelectedPx, animate, phase, elapsedLayout, @@ -478,6 +490,7 @@ private fun LegendSwatch(executed: Boolean, colors: GraphColors) { start = from, end = to, strokeWidth = EDGE_STROKE, + cap = StrokeCap.Round, pathEffect = if (executed) null else INACTIVE_DASH_EFFECT, ) if (executed) drawArrowHead(listOf(from, to), color, ARROW_HEAD_SIZE) @@ -508,6 +521,11 @@ internal class GraphColors( * uses the same palette. The two terminal roles stay scheme roles so their * meaning is kept; every other outcome uses the one curated, legible * [GraphPalette] for both a stroke and its label text. + * + * Node and label surfaces are *tonal*: a raised surface tone ([scheme]'s + * `surfaceContainerHigh`/`surfaceContainerHighest`) blended with a subtle tint of + * the node's semantic colour (see [tonalFill]) rather than a flat fill, so a node + * reads as raised card, not a terminal cell. */ internal fun graphColors(scheme: ColorScheme): GraphColors = GraphColors( // The two terminal roles stay scheme roles so their meaning is kept. @@ -517,23 +535,60 @@ internal fun graphColors(scheme: ColorScheme): GraphColors = GraphColors( // stroke and its label text, so a curve and its label always agree. palette = GraphPalette.colors, // Node fills differ by kind (see [GraphNodeKind]): model (neutral), ntfy - // (amber), other/custom (green), and the two terminals. - nodeFill = scheme.surfaceVariant, - nodeNtfyFill = scheme.tertiaryContainer, - nodeCustomFill = scheme.primaryContainer, - // A selected node inverts (light fill / dark text) plus a 4px border, so + // (amber), other/custom (green), and the two terminals (success/error). Each + // is a tonal surface carrying a subtle tint of that kind's semantic hue. + nodeFill = tonalFill(scheme.surfaceContainerHigh, scheme.onSurfaceVariant, NEUTRAL_TINT), + nodeNtfyFill = tonalFill(scheme.surfaceContainerHigh, scheme.tertiary, KIND_TINT), + nodeCustomFill = tonalFill(scheme.surfaceContainerHigh, scheme.primary, KIND_TINT), + // A selected node inverts (light fill / dark text) plus a stronger border, so // selection reads in either appearance and never relies on colour. nodeFillActive = scheme.inverseSurface, nodeTextActive = scheme.inverseOnSurface, - nodeBorder = scheme.outline, + // The stage border is deliberately soft (a low-contrast outline variant), not + // the hard original outline; terminals carry their outcome hue instead. + nodeBorder = scheme.outlineVariant, nodeBorderActive = scheme.primary, nodeText = scheme.onSurface, - terminalFill = scheme.secondaryContainer, - terminalErrorFill = scheme.errorContainer, - labelBackground = scheme.surface, + terminalFill = tonalFill(scheme.surfaceContainerHigh, scheme.tertiary, TERMINAL_TINT), + terminalErrorFill = tonalFill(scheme.surfaceContainerHigh, scheme.error, TERMINAL_TINT), + // Edge outcome labels sit on a tonal chip (drawn as a rounded rect) rather than + // raw text over the canvas. + labelBackground = scheme.surfaceContainerHighest, labelText = scheme.onSurfaceVariant, ) +/** + * [surface] blended with a [fraction] (0..1) of [accent], so a node/label fill + * carries a subtle tint of its semantic colour while staying a legible surface. + * Pure sRGB per-channel interpolation; a fraction outside `[0, 1]` is clamped so + * callers never overshoot the two colours. + */ +internal fun tonalFill(surface: Color, accent: Color, fraction: Float): Color { + val t = fraction.coerceIn(0f, 1f) + return Color( + red = surface.red + (accent.red - surface.red) * t, + green = surface.green + (accent.green - surface.green) * t, + blue = surface.blue + (accent.blue - surface.blue) * t, + alpha = surface.alpha + (accent.alpha - surface.alpha) * t, + ) +} + +/** + * The label a node shows in the graph: a stage keeps its declared key, while a + * terminal's all-caps `SUCCESS`/`FAILURE` becomes the readable `Success`/ + * `Failure` (the graph type has no unnecessary all-caps). Pure, so the display + * form is unit-tested and the shared [GraphSemantics.nodeLabel] the + * TUI-mirroring panes still use is left untouched. + */ +internal fun nodeDisplayLabel(key: String): String { + val label = GraphSemantics.nodeLabel(key) + return if (Protocol.isTerminal(key)) { + label.lowercase().replaceFirstChar { it.uppercase() } + } else { + label + } +} + /** The accessibility label for one node, naming its type when it is a stage. */ private fun nodeDescription(node: NodeLayout, type: String?): String { if (node.terminal) return "Terminal ${node.label}, tap for details" @@ -714,14 +769,14 @@ private fun forwardAdjacent(edge: GraphEdge, rank: Map): Boolean = 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 portSpacing = with(density) { 12.dp.toPx() } - val hGap = with(density) { 132.dp.toPx() } - val pad = with(density) { 32.dp.toPx() } - val laneSpacing = with(density) { 26.dp.toPx() } - val terminalGap = with(density) { 64.dp.toPx() } - val trackStep = with(density) { 18.dp.toPx() } - val minNodeHeight = with(density) { 56.dp.toPx() } + val nodeWidth = with(density) { NODE_WIDTH.toPx() } + val portSpacing = with(density) { NODE_PORT_SPACING.toPx() } + val hGap = with(density) { NODE_H_GAP.toPx() } + val pad = with(density) { GRAPH_PAD.toPx() } + val laneSpacing = with(density) { EDGE_LANE_SPACING.toPx() } + val terminalGap = with(density) { TERMINAL_ROW_GAP.toPx() } + val trackStep = with(density) { EDGE_TRACK_STEP.toPx() } + val minNodeHeight = with(density) { NODE_MIN_HEIGHT.toPx() } val ranks = rankStages(graph) val edges = graph.edges() @@ -770,7 +825,7 @@ internal fun layoutGraph(graph: Graph, density: androidx.compose.ui.unit.Density graph.stages.forEachIndexed { index, stage -> positions[stage.key] = NodeLayout( key = stage.key, - label = GraphSemantics.nodeLabel(stage.key), + label = nodeDisplayLabel(stage.key), x = stageX(index), y = pad, width = nodeWidth, @@ -807,7 +862,7 @@ internal fun layoutGraph(graph: Graph, density: androidx.compose.ui.unit.Density val successX = failureX + failureWidth + hGap positions[Protocol.FAILURE_END] = NodeLayout( key = Protocol.FAILURE_END, - label = GraphSemantics.nodeLabel(Protocol.FAILURE_END), + label = nodeDisplayLabel(Protocol.FAILURE_END), x = failureX, y = terminalY, width = failureWidth, @@ -816,7 +871,7 @@ internal fun layoutGraph(graph: Graph, density: androidx.compose.ui.unit.Density ) positions[Protocol.SUCCESS_END] = NodeLayout( key = Protocol.SUCCESS_END, - label = GraphSemantics.nodeLabel(Protocol.SUCCESS_END), + label = nodeDisplayLabel(Protocol.SUCCESS_END), x = successX, y = terminalY, width = successWidth, @@ -1118,6 +1173,56 @@ internal fun arrowDirection(points: List): Offset { return Offset.Zero } +/** + * The clamped cut-back used at one bend of an axis-aligned route: the shared + * [radius], floored to half of the shorter adjacent segment ([inLength] into the + * corner, [outLength] out of it) so the two cut-backs can never meet or cross on + * a short run. It takes the lengths the caller already measured, so a bend's + * geometry is computed once. Pure, so the clamp is unit-tested without a Canvas. + */ +internal fun cornerCutRadius(inLength: Float, outLength: Float, radius: Float): Float = + minOf(radius, inLength / 2f, outLength / 2f).coerceAtLeast(0f) + +/** + * The path an axis-aligned route [points] is drawn along: each interior right + * angle is replaced by a quadratic curve with the one consistent [radius] control + * offset (clamped per corner by [cornerCutRadius]), so the tracks read as smooth + * curves. The route's own endpoints and its stored polyline are unchanged, so + * hit-testing, the arrowheads and every layout test keep using the same geometry; + * only the rendered bends soften. Each corner's segment lengths are measured once + * and reused for both the clamp and the cut points; a degenerate route falls back + * to straight segments rather than dividing by zero. + */ +private fun roundedRoutePath(points: List, radius: Float): Path { + val path = Path() + if (points.isEmpty()) return path + path.moveTo(points.first().x, points.first().y) + for (i in 1 until points.size - 1) { + val previous = points[i - 1] + val corner = points[i] + val next = points[i + 1] + val inLength = hypot(corner.x - previous.x, corner.y - previous.y) + val outLength = hypot(next.x - corner.x, next.y - corner.y) + val cut = cornerCutRadius(inLength, outLength, radius) + if (cut <= 0f) { + path.lineTo(corner.x, corner.y) + continue + } + val start = Offset( + corner.x + (previous.x - corner.x) / inLength * cut, + corner.y + (previous.y - corner.y) / inLength * cut, + ) + val end = Offset( + corner.x + (next.x - corner.x) / outLength * cut, + corner.y + (next.y - corner.y) / outLength * cut, + ) + path.lineTo(start.x, start.y) + path.quadraticTo(corner.x, corner.y, end.x, end.y) + } + path.lineTo(points.last().x, points.last().y) + return path +} + /** * Column rank for every stage in declaration order, mirroring * tui.layoutSingleRowGraph: `graph.Stages` is the source order, so stages keep @@ -1143,23 +1248,29 @@ private fun DrawScope.drawEdgePaths( // stored polyline, so there is no per-frame recompute. val points = if (edge.points.isEmpty()) routePoints(edge) else edge.points if (points.size < 2) continue - val path = Path() - path.moveTo(points.first().x, points.first().y) - for (i in 1 until points.size) { - path.lineTo(points[i].x, points[i].y) - } + // The stored route stays the axis-aligned polyline (the layout/tests + // contract); drawing only rounds its corners with the one shared + // [ROUTE_CORNER_RADIUS] control offset, so the tracks read as smooth curves + // without changing any routing. + val path = roundedRoutePath(points, ROUTE_CORNER_RADIUS.toPx()) // Executed = solid full-colour stroke plus an arrowhead; not executed = // dashed muted stroke with no arrowhead. The difference is carried by line // style and arrowhead presence, never by opacity alone, so it survives a // screenshot, a dim screen and a colour-blind reader. An executed // `success`/`error` edge uses the heavier pass/fail width, a stronger - // (same-hue) stroke and a matched arrowhead, so pass/fail dominates. + // (same-hue) stroke and a matching arrowhead, so pass/fail dominates. val motion = edgeMotion(edge.edge, runState) if (motion != EdgeMotion.Unvisited) { val color = edgeStrokeColor(edge.edge, runState, colors) val width = edgeStrokeWidth(edge.edge, runState) - drawPath(path, color = color, style = Stroke(width = width)) - drawArrowHead(points, color, edgeArrowHeadSize(edge.edge, runState)) + drawPath( + path, + color = color, + style = Stroke(width = width, cap = StrokeCap.Round, join = StrokeJoin.Round), + ) + // Reuse the width just computed for the stroke's own head (never + // re-deriving it), so the head always matches the line it terminates. + drawArrowHead(points, color, arrowHeadSizeFor(width)) // While the run is live, an executed route carries a dot travelling // source -> target so its direction reads at a glance. A settled or // off-screen graph draws no dot. @@ -1172,6 +1283,8 @@ private fun DrawScope.drawEdgePaths( color = colors.labelText, style = Stroke( width = edgeStrokeWidth(edge.edge, runState), + cap = StrokeCap.Round, + join = StrokeJoin.Round, pathEffect = INACTIVE_DASH_EFFECT, ), ) @@ -1224,33 +1337,57 @@ private fun pointAlong(points: List, distance: Float): Offset? { return points.lastOrNull() } +/** + * Draws the rounded tonal chip behind a measured label: the shared chip paddings + * and corner ([EDGE_CHIP_PAD_X]/[EDGE_CHIP_PAD_Y]/[EDGE_CHIP_CORNER], dp tokens so + * they scale with the device), filled with [color]. Both the edge outcome labels + * and the active stage's elapsed badge use it, so the two chip call sites keep one + * geometry instead of repeating the same rounded rect. The caller draws the + * pre-measured text at [textTopLeft] afterwards. + */ +private fun DrawScope.drawTonalChip(textTopLeft: Offset, textSize: IntSize, color: Color) { + val padX = EDGE_CHIP_PAD_X.toPx() + val padY = EDGE_CHIP_PAD_Y.toPx() + val corner = EDGE_CHIP_CORNER.toPx() + drawRoundRect( + color = color, + topLeft = Offset(textTopLeft.x - padX, textTopLeft.y - padY), + size = Size(textSize.width + padX * 2f, textSize.height + padY * 2f), + cornerRadius = CornerRadius(corner, corner), + ) +} + /** * Draws every outcome label in a second pass, after all curves, so a * neighbouring edge can never be drawn across a label. Each label sits on its * own edge's stored [EdgeLayout.labelPoint] (the edge's own lane/track), so - * distinct outcomes never overprint. An executed edge's label uses its legible - * outcome colour (see [outcomeColor]); a not-executed edge's label uses a muted - * colour on a near-opaque background, matching its dashed stroke rather than - * inheriting a faded curve alpha, which left the text unreadable. + * distinct outcomes never overprint. The label is drawn on a tonal rounded chip + * (not raw text over the canvas): the chip is the raised surface tone tinted with + * the label's own colour, so an executed edge's label keeps its legible outcome + * colour and a not-executed one stays muted but readable. The text uses the app's + * type scale ([text]'s label role), never an ad-hoc size. */ private fun DrawScope.drawEdgeLabels( layout: GraphLayout, colors: GraphColors, runState: RunGraphState?, textMeasurer: TextMeasurer, + text: PipelinesTextStyles, ) { for (edge in layout.edges) { val executed = edgeIsExecuted(edge.edge, runState) - val textColor = if (executed) outcomeColor(edge.edge.outcome, colors) else colors.labelText - val measured = textMeasurer.measure(edge.edge.label, TextStyle(fontSize = 11.sp, color = textColor)) + // One colour serves both the label text and its chip tint: the outcome + // hue when the edge executed, otherwise the muted not-executed label tone. + val labelColor = if (executed) outcomeColor(edge.edge.outcome, colors) else colors.labelText + val measured = textMeasurer.measure(edge.edge.label, text.label.copy(color = labelColor)) val labelTopLeft = Offset( x = edge.labelPoint.x - measured.size.width / 2f, y = edge.labelPoint.y - measured.size.height - 2f, ) - drawRect( - color = colors.labelBackground.copy(alpha = if (executed) 0.92f else 0.86f), - topLeft = Offset(labelTopLeft.x - 3f, labelTopLeft.y - 1f), - size = Size(measured.size.width + 6f, measured.size.height + 2f), + drawTonalChip( + textTopLeft = labelTopLeft, + textSize = measured.size, + color = tonalFill(colors.labelBackground, labelColor, EDGE_CHIP_TINT), ) // Draw the pre-measured layout: the string overload re-derives its width // constraints from this DrawScope and throws when a label sits outside it @@ -1299,6 +1436,10 @@ private fun DrawScope.drawNodes( selectedStage: String?, stageTypeByKey: Map, textMeasurer: TextMeasurer, + text: PipelinesTextStyles, + nodeCornerPx: Float, + nodeBorderPx: Float, + nodeBorderSelectedPx: Float, animate: Boolean, phase: Float, elapsedLayout: TextLayoutResult?, @@ -1312,17 +1453,23 @@ private fun DrawScope.drawNodes( val selected = node.key == selectedStage val kind = graphNodeKind(node.terminal, node.key, stageTypeByKey[node.key]) val topLeft = Offset(node.x, node.y) - val corner = CornerRadius(NODE_CORNER_RADIUS, NODE_CORNER_RADIUS) - val borderWidth = if (selected && !node.terminal) 4f else 2f + // A stage is a rounded rectangle from the theme's shape scale; a terminal + // is a pill (fully rounded) so it is visibly not a stage. + val corner = if (node.terminal) { + CornerRadius(node.height / 2f, node.height / 2f) + } else { + CornerRadius(nodeCornerPx, nodeCornerPx) + } + val borderWidth = if (selected && !node.terminal) nodeBorderSelectedPx else nodeBorderPx // The active stage carries a halo behind its fill: a pulse while // animating, a fixed but clearly visible ring otherwise, so a live run's // current stage is unmistakable with or without animation. if (motion == NodeMotion.Active) { drawActiveHalo(node, colors, animate, phase, corner, haloGapPx, haloStrokePx) } - val textColor: Color if (executed) { - // Filled with a normal border, exactly as the definition-only view. + // A tonal surface fill carrying a subtle tint of the node's semantic + // colour, plus a soft border (or the outcome hue for a terminal). val fill = when { kind == GraphNodeKind.TerminalFailure -> colors.terminalErrorFill kind == GraphNodeKind.TerminalSuccess -> colors.terminalFill @@ -1349,11 +1496,10 @@ private fun DrawScope.drawNodes( cornerRadius = corner, style = Stroke(width = borderWidth), ) - textColor = if (!node.terminal && selected) colors.nodeTextActive else colors.nodeText } else { - // Hollow and outlined: no fill (the surface shows through), a dashed - // muted border and a muted but legible label, so "not executed" is a - // shape and border-style difference rather than a faded node. A + // Hollow and outlined: no fill (the tonal surface shows through), a + // dashed muted border and a muted but legible label, so "not executed" + // is a shape and border-style difference rather than a faded node. A // selected not-executed node keeps the stronger border colour. val border = if (selected && !node.terminal) colors.nodeBorderActive else colors.labelText drawRoundRect( @@ -1363,13 +1509,17 @@ private fun DrawScope.drawNodes( cornerRadius = corner, style = Stroke(width = borderWidth, pathEffect = INACTIVE_DASH_EFFECT), ) - textColor = colors.labelText } - val label = "[" + node.label + "]" - val measured = textMeasurer.measure( - label, - TextStyle(fontSize = 13.sp, fontWeight = FontWeight.Medium, color = textColor), - ) + // A terminal names its state in its own colour; a stage names itself in the + // node text colour (inverted when selected). No all-caps, no brackets. + val textColor: Color = when { + node.terminal && kind == GraphNodeKind.TerminalSuccess -> colors.success + node.terminal && kind == GraphNodeKind.TerminalFailure -> colors.error + selected && !node.terminal -> colors.nodeTextActive + executed -> colors.nodeText + else -> colors.labelText + } + val measured = textMeasurer.measure(node.label, text.cardTitle.copy(color = textColor)) // Pre-measured layout avoids the scope-relative width constraint crash and // the redundant re-measure of the string overload. drawText( @@ -1381,7 +1531,7 @@ private fun DrawScope.drawNodes( ) // The active stage's live elapsed time, drawn as a badge under its label // from the pre-measured layout (so the draw pass adds no allocation), on - // a near-opaque surface chip so it stays legible over any node fill (the + // an opaque tonal chip so it stays legible over any node fill (the // selected active node is filled light in the dark theme). Only the // active node has one, and only while the run is live. if (motion == NodeMotion.Active && elapsedLayout != null) { @@ -1389,10 +1539,10 @@ private fun DrawScope.drawNodes( x = node.x + (node.width - elapsedLayout.size.width) / 2f, y = node.y + node.height - elapsedLayout.size.height - elapsedInsetPx, ) - drawRect( - color = colors.labelBackground.copy(alpha = 0.92f), - topLeft = Offset(badgeTopLeft.x - 3f, badgeTopLeft.y - 1f), - size = Size(elapsedLayout.size.width + 6f, elapsedLayout.size.height + 2f), + drawTonalChip( + textTopLeft = badgeTopLeft, + textSize = elapsedLayout.size, + color = tonalFill(colors.labelBackground, colors.nodeText, ELAPSED_CHIP_TINT), ) drawText(textLayoutResult = elapsedLayout, topLeft = badgeTopLeft) } @@ -1489,9 +1639,22 @@ internal fun edgeStrokeWidth(edge: GraphEdge, runState: RunGraphState?): Float = else -> EDGE_STROKE } -/** The named arrowhead-size token for [edge], scaled to match [edgeStrokeWidth]. */ +/** + * Arrowhead length for a stroke of [strokeWidth]: one [ARROW_HEAD_SCALE] multiple + * of the width. This is the single mapping both an edge and the legend share, and + * drawing passes the width it has just computed rather than re-deriving it, so a + * heavier line always carries a proportionally larger filled head. + */ +internal fun arrowHeadSizeFor(strokeWidth: Float): Float = strokeWidth * ARROW_HEAD_SCALE + +/** + * The arrowhead length for [edge]: [arrowHeadSizeFor] of its own + * [edgeStrokeWidth], so a heavier line always carries a proportionally larger + * head and the two can never disagree. The pass/fail width is the heaviest, so + * its head is the largest; a not-executed edge draws no head at all. + */ internal fun edgeArrowHeadSize(edge: GraphEdge, runState: RunGraphState?): Float = - if (isEmphasizedEdge(edge, runState)) PASSFAIL_ARROW_HEAD_SIZE else ARROW_HEAD_SIZE + arrowHeadSizeFor(edgeStrokeWidth(edge, runState)) /** * The stroke colour for an executed [edge]: its outcome colour, made more @@ -1522,7 +1685,7 @@ private fun graphDescription(graph: Graph, runState: RunGraphState?): String { for (outcome in GraphSemantics.outcomes(stage)) { val target = Protocol.resolveTarget(outcome, stage.edges[outcome] ?: continue) val label = GraphSemantics.edgeLabel(stage, outcome) - builder.append("Outcome $label goes to ${GraphSemantics.nodeLabel(target)}. ") + builder.append("Outcome $label goes to ${nodeDisplayLabel(target)}. ") } } builder.append("Stages can be tapped for details.") @@ -1564,19 +1727,33 @@ private const val PULSE_PERIOD_MILLIS = 1_600 /** The active stage's elapsed time ticks once a second, never per frame. */ private const val ELAPSED_TICK_MILLIS = 1_000L -/** Corner radius of a node rect, shared by the fill/border and the active halo. */ -private const val NODE_CORNER_RADIUS = 14f - /** * The active halo: how far outside the node it sits, how thick its ring is, and * how much of the pulse strength its soft glow carries. dp tokens (like the node - * layout) so they scale with the device; the raw node border/corner literals are - * pre-existing graph geometry. + * layout) so they scale with the device. */ private val ACTIVE_HALO_GAP = 6.dp private val ACTIVE_HALO_STROKE = 4.dp private const val ACTIVE_HALO_GLOW = 0.28f +/** + * Node geometry, spacing and border tokens. A node's corner radius comes from the + * app's shape scale (`MaterialTheme.shapes.medium`, read once in [WorkflowGraph]); + * a terminal overrides it with a full pill. Everything else is a named dp token so + * no call site writes a geometry literal, the gaps are deliberately generous so + * the graph breathes, and the values scale with the device. + */ +private val NODE_WIDTH = 150.dp +private val NODE_MIN_HEIGHT = 76.dp +private val NODE_PORT_SPACING = 14.dp +private val NODE_H_GAP = 168.dp +private val GRAPH_PAD = 40.dp +private val EDGE_LANE_SPACING = 34.dp +private val TERMINAL_ROW_GAP = 88.dp +private val EDGE_TRACK_STEP = 26.dp +private val NODE_BORDER = 1.dp +private val NODE_BORDER_SELECTED = 3.dp + /** Bottom inset of the active node's elapsed-time badge inside the node rect. */ private val ELAPSED_INSET = 4.dp @@ -1591,10 +1768,11 @@ private const val FLOW_DOT_SCALE = 1.2f * pixels, so the two states differ by shape, not by a faded tint. * * The two decisive outcomes (`success`/`error`) use the heavier - * [PASSFAIL_EDGE_STROKE] with the matching [PASSFAIL_ARROW_HEAD_SIZE] and a - * stronger [PASSFAIL_SATURATION] stroke, so pass/fail reads at a glance and from - * a distance, while every other outcome keeps the finer [EDGE_STROKE] and a - * not-executed route the finer still [INACTIVE_EDGE_STROKE]. + * [PASSFAIL_EDGE_STROKE] with a proportionally larger arrowhead (see + * [edgeArrowHeadSize]) and a stronger [PASSFAIL_SATURATION] stroke, so pass/fail + * reads at a glance and from a distance, while every other outcome keeps the + * finer [EDGE_STROKE] and a not-executed route the finer still + * [INACTIVE_EDGE_STROKE]. */ private const val EDGE_STROKE = 3f @@ -1604,11 +1782,41 @@ private const val PASSFAIL_EDGE_STROKE = 7f /** Stroke width for a not-executed edge; finer than either executed width. */ private const val INACTIVE_EDGE_STROKE = 2.5f -/** Arrowhead length for a normal executed edge. */ -private const val ARROW_HEAD_SIZE = 12f +/** + * A route's corner radius, a dp token like the rest of the graph geometry: the + * one consistent control offset every right-angle bend of an orthogonal route is + * rounded by, so all tracks share a single curve language (and scale with the + * device) without changing the stored routing. + */ +private val ROUTE_CORNER_RADIUS = 7.dp -/** Arrowhead length for an executed pass/fail edge, scaled with its heavier stroke. */ -private const val PASSFAIL_ARROW_HEAD_SIZE = 20f +/** + * Arrowhead length as a multiple of the edge's own stroke width, so a heavier line + * always carries a proportionally larger filled head (base `3 * 4 = 12`, + * pass/fail `7 * 4 = 28`). [ARROW_HEAD_SIZE] is the base length, used by the + * legend swatch, which names the generic executed state rather than pass/fail. + */ +private const val ARROW_HEAD_SCALE = 4f +private const val ARROW_HEAD_SIZE = EDGE_STROKE * ARROW_HEAD_SCALE + +/** + * Tonal tints: the fraction of a node's/edge's semantic colour blended into the + * raised surface for its fill or chip. Small enough to read as a tint, large + * enough to tell the node kinds and outcome labels apart. + */ +private const val NEUTRAL_TINT = 0.10f +private const val KIND_TINT = 0.22f +private const val TERMINAL_TINT = 0.30f +private const val EDGE_CHIP_TINT = 0.20f +private const val ELAPSED_CHIP_TINT = 0.14f + +/** + * The tonal chip's padding and corner, dp tokens like the other graph geometry + * (so a chip scales with the device rather than sitting at a raw pixel size). + */ +private val EDGE_CHIP_PAD_X = 2.dp +private val EDGE_CHIP_PAD_Y = 1.dp +private val EDGE_CHIP_CORNER = 2.dp /** * How much more saturated an executed pass/fail stroke is than its outcome @@ -1634,7 +1842,7 @@ private val LEGEND_SWATCH_HEIGHT = 10.dp * the former 360.dp / 340.dp literals). ~58% of the window height so the graph * is a substantial share of the screen, floored at a height that still fits a * 4-stage layout plus its lower terminal row: pad*2 + node + terminal gap + node - * = 32*2 + 56 + 72 + 56 = 248px at density 1. + * = 40*2 + 76 + 88 + 76 = 320px at density 1. */ internal fun collapsedGraphHeight(screenHeightDp: Int): Dp = (screenHeightDp * 0.58f).dp.coerceAtLeast(GRAPH_PANEL_MIN_HEIGHT) @@ -1643,4 +1851,4 @@ internal fun collapsedGraphHeight(screenHeightDp: Int): Dp = internal fun expandedGraphHeight(screenHeightDp: Int): Dp = (screenHeightDp * 0.92f).dp /** Floor that still fits a 4-stage graph with its terminal row (see above). */ -internal val GRAPH_PANEL_MIN_HEIGHT = 260.dp +internal val GRAPH_PANEL_MIN_HEIGHT = 320.dp diff --git a/android/app/src/test/java/net/awan/pipelines/ui/graph/GraphPaletteTest.kt b/android/app/src/test/java/net/awan/pipelines/ui/graph/GraphPaletteTest.kt index 7201cf25..d52555ba 100644 --- a/android/app/src/test/java/net/awan/pipelines/ui/graph/GraphPaletteTest.kt +++ b/android/app/src/test/java/net/awan/pipelines/ui/graph/GraphPaletteTest.kt @@ -182,6 +182,27 @@ class GraphPaletteTest { private fun valueOf(color: Color): Float = maxOf(color.red, color.green, color.blue) + /** + * [tonalFill] blends a raised surface toward the accent by the given fraction, + * so a node/label fill carries a subtle tint of its semantic colour while + * staying a surface; the fraction is clamped so a caller never overshoots. + */ + @Test + fun tonalFillBlendsTowardTheAccentAndClampsTheFraction() { + val surface = darkSurface + val accent = Color(0xFFFF0000) + // Both endpoints are reproduced exactly on the channel. + assertEquals(surface.red, tonalFill(surface, accent, 0f).red, 0.0001f) + assertEquals(accent.red, tonalFill(surface, accent, 1f).red, 0.0001f) + // A mid tint sits strictly between the two and keeps the surface's alpha. + val mid = tonalFill(surface, accent, 0.2f) + assertTrue(mid.red > surface.red && mid.red < accent.red) + assertEquals(surface.alpha, mid.alpha, 0.0001f) + // Out-of-range fractions clamp to the endpoints instead of overshooting. + assertEquals(surface.red, tonalFill(surface, accent, -1f).red, 0.0001f) + assertEquals(accent.red, tonalFill(surface, accent, 2f).red, 0.0001f) + } + @Test fun nodeKindIsDeterministicAndCoversEveryKind() { assertEquals(GraphNodeKind.Model, graphNodeKind(false, "planner", null)) diff --git a/android/app/src/test/java/net/awan/pipelines/ui/graph/WorkflowGraphTest.kt b/android/app/src/test/java/net/awan/pipelines/ui/graph/WorkflowGraphTest.kt index 47ff4463..43206f00 100644 --- a/android/app/src/test/java/net/awan/pipelines/ui/graph/WorkflowGraphTest.kt +++ b/android/app/src/test/java/net/awan/pipelines/ui/graph/WorkflowGraphTest.kt @@ -592,6 +592,62 @@ class WorkflowGraphTest { assertEquals(1, GRAPH_LEGEND.count { it.executed }) } + /** + * The node label the graph shows is readable: a terminal's all-caps keyword + * becomes title case (no unnecessary all-caps), while a stage keeps its + * declared key. + */ + @Test + fun nodeDisplayLabelsAreReadableAndKeepStageKeys() { + assertEquals("Success", nodeDisplayLabel(Protocol.SUCCESS_END)) + assertEquals("Failure", nodeDisplayLabel(Protocol.FAILURE_END)) + assertEquals("ui_reviewer", nodeDisplayLabel("ui_reviewer")) + assertEquals("planner", nodeDisplayLabel("planner")) + } + + /** + * A heavier line always carries a proportionally larger filled arrowhead: one + * consistent scale ties the head length to the stroke width, so the pass/fail + * head dominates exactly as its stroke does. + */ + @Test + fun arrowHeadScalesWithTheStrokeItTerminates() { + val graph = sampleGraph() + val success = graph.edges().first { it.outcome == "success" } + val other = graph.edges().first { it.outcome == "blocked" } + val runState = RunGraphState( + visitedStages = setOf(success.source, other.source), + takenRoutes = setOf( + GraphRoute(success.source, success.outcome, success.target), + GraphRoute(other.source, other.outcome, other.target), + ), + currentStage = success.source, + ) + val successRatio = edgeArrowHeadSize(success, runState) / edgeStrokeWidth(success, runState) + val otherRatio = edgeArrowHeadSize(other, runState) / edgeStrokeWidth(other, runState) + assertEquals(successRatio, otherRatio, 0.001f) + assertTrue(edgeArrowHeadSize(success, runState) > edgeArrowHeadSize(other, runState)) + } + + /** + * The rounded-corner cut at a route bend is the shared radius, floored to half + * the shorter adjacent segment so two cut-backs can never meet or cross; a + * degenerate adjacent segment yields no cut instead of dividing by zero. It + * works on the already-measured segment lengths, so a bend measures them once. + */ + @Test + fun cornerCutNeverExceedsHalfTheShorterSegment() { + val radius = 18f + // Both adjacent segments are long enough to take the full radius. + assertEquals(radius, cornerCutRadius(100f, 100f, radius), 0.001f) + // A short incoming segment halves the cut. + assertEquals(10f, cornerCutRadius(20f, 100f, radius), 0.001f) + // A short outgoing segment halves the cut. + assertEquals(15f, cornerCutRadius(100f, 30f, radius), 0.001f) + // A degenerate adjacent segment yields no cut. + assertEquals(0f, cornerCutRadius(0f, 100f, radius), 0.001f) + } + private fun assertNoSharedRuns(layout: GraphLayout) { val edges = layout.edges for (i in edges.indices) {