diff --git a/android/README.md b/android/README.md index 9ad86191..d6928e66 100644 --- a/android/README.md +++ b/android/README.md @@ -256,6 +256,16 @@ stops it. clamped to two lines. The raw `resultPreview` is no longer printed, and progress is shown honestly (completed visits + current stage, with an indeterminate indicator while executing; no invented total). +- A run still in progress shows the time it has taken so far instead of a + finished duration, everywhere a run's time appears: the runs list meta row, + the pipeline list's last-run line and the run detail summary's Duration row. A + running value is live — recomputed once a second from the server's own + `created_at` (never from when the app loaded, so it stays correct after a + reconnect), using the shared `runDurationText` and a single ticking clock per + screen (`ui/components/LiveTime.kt`) that pauses while the app is backgrounded + and while no shown run is executing. Once the run finishes it keeps its stored + total duration; a missing start omits the value and a future start (clock skew) + reads as `0s` (`FormatTest`, `PipelineLastRunTest`). - One centralised type scale (`ui/theme/Typography.kt`, passed to `MaterialTheme` and exposed as named roles) defines the screen/app-bar title, section header, card title, subtitle/meta, body and monospace data, applied on @@ -945,6 +955,11 @@ frames and pinch-zoom (adb cannot drive a two-finger pinch). ## Adaptive pane navigation and a fixed peek budget (15 Oct 2026) +> **Superseded** by "The covered edge is measured, not budgeted" below: the fixed +> `PEEK_BUDGET_DP` (`224.dp`) is gone. The covered region is now measured from the +> compact identity a covered edge has to show, so the active pane is no longer +> charged a fixed `224dp` whatever the window width is. + The pane stack was made adaptive to the window width and its peek space changed from one peek per level to a single fixed budget shared between the covered panes. `android/` only; nothing in the Pipelines server, its Go source, the @@ -1210,6 +1225,11 @@ artifacts is a data issue in that run, not re-tested against a repaired copy. ## Covered panes show a compact identity, with a minimum peek width (16 Oct 2026) +> **Superseded** by "The covered edge is measured, not budgeted" below: the +> `MIN_COVERED_PANE_WIDTH_DP`/`PEEK_WIDTH_DP` split of a fixed budget no longer +> decides the layout. A covered edge is now as wide as the identity it has to +> show; the two tokens only bound which statistics that identity shows. + A wide-window stack no longer squeezes a full pane into each covered peek: a covered pane now renders only its compact identity (a title and at most one status/subtitle, centred in its strip) and its full body — tab rail, list, @@ -1294,6 +1314,101 @@ has exactly three pane levels (`MasterPane.List/Detail/Stage`, `MAX_PANE_DEPTH = centred lines and ellipsizes (e.g. `Pipelines maintenance - plan implem…`) rather than being rotated. +## Covered panes carry a compact statistics block (16 Oct 2026) + +A covered pane's compact identity is no longer a bare title/subtitle: it now +shows a small vertical block of labelled statistics, aggregated client-side from +the run history the app already receives, degrading with the strip's width. +`android/` only; nothing in the Pipelines server, its Go source, the +Docker/compose files or the installer was touched, no dependency was added (the +declared `material-icons-extended` is unchanged), no run was started from the app +and no server field was added. + +- **Pipeline statistics.** When the covered pane is a pipeline + (`PipelineDetailScreen`, and `RunDetailScreen` through its run's pipeline) the + block shows the run counts (`runs`/`succeeded`/`failed`/`active`), the last + run's status and how long ago it started, and the average duration over the + runs that finished. `ui/screens/PaneStats.kt` folds the history in one pass; the + counts mirror the server's own vocabulary (`active` = queued/running, per + `internal/pipeline/stats.go`) and a still-running run never drags the average. + A run pane whose run (and so whose pipeline) has not loaded yet stays + title-only: an absent pipeline id is "not known yet", never the whole history, + so it can never show the server-wide summary as if it were the run's pipeline. +- **List statistics.** When the covered pane is a list, `PipelineListScreen` and + `RunHistoryScreen` show the whole history's counts by status and the single most + recent run; a runs list scoped to one pipeline shows that pipeline's own + numbers. +- **Width degradation.** `PaneIdentity` measures its own strip and shows the title + only below one peek width, the run counts up to + `MIN_COVERED_PANE_WIDTH_DP + PEEK_WIDTH_DP`, and the full block above it, so a + thin peek drops whole labelled statistics instead of clipping a number or + printing an unlabelled figure. Each statistic is a label above its own value, so + the number never shares a line with a label that could clip it. The boundaries + reuse the named geometry tokens and the decision is the pure + `paneStatTier`/`visiblePaneStats` pair. +- **One recency rule.** The "most recent run" comparison is the shared + `isMoreRecent` helper, used by the single-pass `latestRunByPipeline` join and by + the covered summary's own fold, so the pipeline row's last-run badge, the "most + recent run" sort and the covered summary all agree on which run is the latest + without grouping the history into intermediate lists. +- **Two aggregation entry points.** `ui/screens/PaneStats.kt` exposes + `pipelineStatLines(runs, pipelineId, now)` for the pipeline-scoped panes and + `listStatLines(runs, now)` for the list panes, so "which statistics, from which + history, or none until it has loaded" lives in one place instead of at each + call site and a null pipeline id can never be mistaken for the whole history. + The fold is a single pass (`RunTally.add` tracks the counts, the finished-run + duration total and the most recent run together), so a scoped pipeline summary + never allocates a filtered list or walks the history twice. + +Evidence (macOS, JDK 17 from Homebrew `openjdk@17`, the cached Gradle 8.11.1 +distribution, `ANDROID_HOME=~/Library/Android/sdk`, `--offline`): + +- `:app:testDebugUnitTest :app:assembleDebug --offline --console=plain` → + `BUILD SUCCESSFUL in 2s` (41 actionable tasks: 8 executed, 33 up-to-date). The + result XMLs total **279 tests, 0 failures, 0 errors, 0 skipped** across 32 + files; `app/build/outputs/apk/debug/app-debug.apk` is 18,204,486 bytes, sha256 + `196c9d6f4acbcc75769fd52ecadac66378bad78994056895f26ff65da077718c`. The + `PaneStatsTest` (15 cases) covers the per-pipeline counts, queued as active, the + last run's state/age, the average over finished runs, zero-duration runs, a + pipeline with no runs, an unknown pipeline id, the whole-history list fold and + the labelled lines, and that an absent/unknown pipeline id yields no lines + rather than the list summary; the `PaneIdentityTest` (5 cases) pins the width + tiers, that the counts tier drops only the detail lines, and that every shown + statistic keeps its label and value. +- **APK publish.** `app-debug.apk` was copied to + `~/.local/share/pipelines/data/artifacts/142/3/pipelines-debug-wip-c700b28.apk` + (`c700b28` = `git rev-parse --short HEAD`; the tree is uncommitted WIP on top of + it); `shasum -a 256` matched the built file (`196c9d6f…`). `curl -I + http://10.0.0.249:8080/artifacts/142/3/pipelines-debug-wip-c700b28.apk` returned + `HTTP/1.1 200 OK`, `Content-Type: application/vnd.android.package-archive`, + `Content-Length: 18204486`. +- **Device evidence (emulator-5554).** The debug APK was installed with + `adb -s emulator-5554 install -r` (never the attached Pixel, never + `emulator-5556`) against the live LAN server, and the wide and narrow layouts + were captured with `adb -s emulator-5554 shell screencap -p /sdcard/cap.png` + then `adb -s emulator-5554 pull`. Captures are in the same artifacts directory: + `wide-1-level-runs-list.png`, `wide-2-levels-covered-list-stats.png`, + `wide-3-levels-covered-stats.png` (plus `…pane0…`/`…pane1…` crops) and + `narrow-runs-list.png`. OCR of the covered strips confirms the block: at two + levels the covered runs list reads `Runs / runs 145 / succeeded 90 / failed 39 / + active 6 / last running - 4m ago` (Full tier); at three levels its two covered + strips (82 dp and 112 dp wide) drop the `last` line and keep only the labelled + counts, and the covered run strip reads the run's own pipeline id 11 numbers + (`runs 60 / succeeded 37 / failed 14 / active 5`) — clearly not the server-wide + 145, so an unknown pipeline can no longer borrow the list summary. Four levels + remain unreachable: `MAX_PANE_DEPTH = 2` gives exactly three pane levels, so the + three-covered degradation is captured instead. +- **Device-instruction conflict.** The run's Constraints said use `emulator-5554` + exclusively and never the operator's physical device; an appended paragraph said + to use the attached Pixel and never an emulator. There is no path that satisfies + both, and installing this WIP build on the operator's own phone is forbidden by + the task, so the emulator named in the Constraints was used (with the + `device.lock` held) and the Pixel and `emulator-5556` were never touched. While + capturing, another lane repeatedly overwrote the installed APK on + `emulator-5554` (the installed hash reverted from this build to + `2adaf03e…`/`5912d38f…` at 16:18 and 16:20 until reinstalled), which is why the + APK hash was re-checked immediately before the captures that are reported here. + ## Run stage pane leads with the run's results (16 Oct 2026) A stage opened from a run no longer leads with its own definition. The pane now @@ -3441,3 +3556,201 @@ native 2208x1840 @420 at the end. returned `HTTP/1.1 200 OK`, `Content-Type: application/vnd.android.package-archive`, `Content-Length: 17928873`. + +## Remembering the list scroll position (16 Oct 2026) + +Returning from a pipeline or a run now restores the list to exactly where the +operator left it — the same item at the same offset, on either window width — and +the position also survives a configuration change, rotation and process death. +`android/` only; nothing in the Pipelines server, its Go source, the +Docker/compose files or the installer was touched, no dependency was added (the +declared `material-icons-extended` is unchanged), no run was started from the app +and no server field was added. + +- **Root cause.** A covered pane is a different composition from an open one: when + a detail opens on a wide window, pane 0 stops drawing its list and draws its + compact identity in a strip instead, so the list screen (and any scroll state it + owned) was discarded, and backing out rebuilt it at the top. The runs + destination is additionally recreated by the `NavHost` when the app-level runs + selection changes. The fix owns each list's scroll state at the app shell, above + the `NavHost` (`PipelinesApp`), and passes it into the list screens, so it is + never inside the pane that comes and goes. +- **One scroll state per list.** `PipelinesApp` holds + `pipelineListState`/`runListState` with `rememberSaveable(saver = LazyListState.Saver)` + and passes them to `PipelineDestination`/`RunsDestination` and on to + `PipelineListScreen`/`RunHistoryScreen` (and `RunHistoryContent`), whose + `LazyColumn` now takes that state. The same two screens serve both window widths + and both entry points, so the runs list reached from a pipeline gets the same + treatment as one opened normally. +- **Restore and clamp rule.** `ui/components/ListScroll.kt` holds the pure + `ListScrollAnchor(index, offset)` and `restoredScrollAnchor(anchor, itemCount)` + (the saved index clamped to the nearest valid item, the offset kept only for the + item that survived) plus the `RestoreListScroll(state, itemCount)` composable, + which is keyed on the item count so it runs once when the list's size settles + and never on the operator's own scrolling. A list that changed underneath (a + filter, a sort, a refresh, items removed) therefore clamps to the nearest + sensible item instead of jumping to the top or throwing, a scroll after coming + back is never overridden, and a list that has not loaded yet is left alone so a + restored position is not reset to the top while the data is still arriving. +- **Runs list before it has loaded (fixed 16 Oct 2026).** The runs list has no + pane-level empty state, so its first frame — before `LaunchedEffect { + vm.refreshRuns() }` has set `loading` — was data-less, not-loading and classified + as content. `RunHistoryContent` then composed an empty list whose only slot was + the "no runs" line, and `RestoreListScroll` clamped the restored index to 0 + before the real list arrived: the runs list always came back at the top after + process death (the pipelines list was spared only because its empty state was + classified as a distinct `LoadPhase.Empty`). `listLoadPhase` now takes the + pane's `loaded` signal (`LoadState.loaded`) and reads a data-less list that has + never loaded as loading rather than empty, so the list — and its restored + position — is not composed until the history is actually in hand. Both list + screens pass it. +- **One source for the runs list body.** `RunHistoryScreen` no longer maintains a + second, hand-written copy of the LazyColumn's item count. The pure + `runListEntries(...)` builds the slots (the usage block, the single + empty-or-grouped body and the optional inline error row) once, in layout order; + the column renders exactly that list and `RestoreListScroll` clamps to its size, + so the count can never drift from what is drawn. `RunListEntriesTest` pins the + slot order, the stable keys and the count. + +Evidence (macOS, JDK 17 from Homebrew `openjdk@17`, cached Gradle 8.11.1 +distribution, `ANDROID_HOME=~/Library/Android/sdk`, every Gradle command with +`--no-daemon --offline --console=plain`): + +- `:app:clean :app:testDebugUnitTest :app:assembleDebug` → `BUILD SUCCESSFUL`; + the tests were then re-executed with `:app:testDebugUnitTest --rerun-tasks` + (not served from the build cache). The result XMLs total **292 tests, 0 + failures, 0 errors, 0 skipped** across 34 files. `ListScrollTest` (6 cases) + pins the restore/clamp rule (in-range item keeps its index and offset, the last + item keeps its offset, a shrunken list clamps to its last item and drops the + offset, a negative index clamps to the top, an empty list stays at the top); the + two new `LoadPhaseTest` cases pin that a data-less list that has never loaded + reads as loading while the default keeps the old rule; and `RunListEntriesTest` + (5 cases) pins the runs body's slot order, stable keys and count. + `app/build/outputs/apk/debug/app-debug.apk` is 18,011,393 bytes, sha256 + `13b8d2871e9ad522e0d5a826642cdf467a95939408bed519d952e83d5c8dbb02`. +- `:app:lintDebug` aborts on only the two pre-existing `NewApi` errors for + `android:windowLightNavigationBar` (minSdk 26) in `res/values/themes.xml` and + `res/values-night/themes.xml`, which this change did not modify; no error or + warning points at the scroll change. +- **APK publish.** `app-debug.apk` was copied to + `~/.local/share/pipelines/data/artifacts/157/1/pipelines-debug-wip-c700b28.apk` + (`c700b28` = `git rev-parse --short HEAD`; the tree is uncommitted WIP on top of + it); `shasum -a 256` matched the built file (`13b8d287…`). `curl -I + http://10.0.0.249:8080/artifacts/157/1/pipelines-debug-wip-c700b28.apk` returned + `HTTP/1.1 200 OK`, `Content-Type: application/vnd.android.package-archive`, + `Content-Length: 18011393`. +- **Device evidence (operator's Pixel 10 Pro Fold, `adb -s 58281FDCG000JF`, inner + 2076x2152 at the 330 density override ≈1006dp; narrow override `wm size + 1080x1920`).** The build was installed with `adb -s 58281FDCG000JF install -r`, + driven against the live LAN server (`curl http://127.0.0.1:8080/healthz` → + `{"healthy":true}`), and captured with `android/scripts/capture_png.sh -s + 58281FDCG000JF` (device-side `screencap` to a file, then `pull` — never + `exec-out`), written to `~/.local/share/pipelines/data/artifacts/157/1/`. The + scroll position is read from `uiautomator dump` as the first `run «id» · …` line + (the runs list) or the first `id «n» · v…` line (the pipelines list): + + | case | how driven | result | + | --- | --- | --- | + | pipelines, wide, open→back | scroll down (first row `id 6`), tap the pipeline, Back | same first row; `01_list_scrolled.png` vs `03_list_restored.png` differ in **no pixel** (`bbox None`) | + | runs, wide, open→back | scroll down (first row `run 32 · 13 Oct 17:21`), tap the run, Back | same first row; `05_runs_scrolled.png` vs `06_runs_restored.png` differ in **no pixel** (`bbox None`) | + | **runs, process death** | HOME, `adb -s 58281FDCG000JF shell am kill net.awan.pipelines` (`pidof` empty), restore the task from Recents | back on the Runs destination with the same first row `run 41 · 15 Oct 14:35`; `30_runs_before_death.png` vs `31_runs_after_death.png` differ only in the status bar (`bbox (138,67)-(289,95)`) | + | runs, rotation | `user_rotation 1`, then `0` | same top row `run 10 · 11 Oct 16:01` after both | + | pipelines, rotation | `user_rotation 1`, then `0` | same top row in landscape; the first flip re-laid the anchor onto the adjacent row (`id 6`→`id 11`) and was stable on the second and later flips — the list never returned to the top | + | density, config change | `wm density 330`→`340`→`330` | same top row `run 10 · 11 Oct 16:01` | + | pipelines, narrow | `wm size 1080x1920`; scroll, open a pipeline, Back | same first row `id 4`; `70_narrow_pipelines_before.png` vs `72_narrow_pipelines_after.png` differ in **no pixel** (`bbox None`) | + | runs, narrow | `wm size 1080x1920`; scroll, open a run, Back | same first row `run 8 · 11 Oct 14:44`; only the status bar differs | + | list shrank while open | pipelines scrolled to the bottom, then search `quick` | the two matches (`id 9`, `id 10`) are shown — clamped, not blank and not reset to the top — and the process stayed alive with no `FATAL EXCEPTION` in `logcat` | + + For the open→back cases the top row and its pixel offset matched exactly (the + screenshot diff isolates only the status-bar clock); rotation, the density + change and process death restored the same destination and top row. `device.lock` + was held for every `adb` command and released afterwards, and no run was started + from the app. +- **Not exercised.** `onOpenRun` from a pipeline detail is only reached through + `StartRunDialog.onStarted` (after starting a run), which the task forbids, so the + runs list reached that way is kept compiling and functional but not driven; it + shares the one `runListState`, so it gets the same treatment as the normally + opened runs list. A real hardware fold to the cover display was not exercised + (narrow was produced with `wm size`). + +## The covered edge is measured, not budgeted (16 Oct 2026) + +The covered panes used to spend the fixed `PEEK_BUDGET_DP` (`224.dp`) whatever the +window width was, so on a folded window the covered area was over half the screen +and the active pane was left with a fixed, small width. The stack now derives the +covered region from what a covered edge actually has to show and takes the active +pane's width from what remains. `android/` only; no dependency was added, no run +was started from the app, the Pipelines server/Go source/installer/Docker files +were not touched, and the operator's Pixel 10 Pro Fold was not used at all +(implementation verified with the build and the unit tests, per the brief). + +- **The region is measured, not budgeted.** `rememberCompactIdentityWidth` + (`ui/components/PaneIdentity.kt`) measures the width one covered edge needs for + its compact identity — an icon plus the shortest label that identifies the pane + — at runtime, with the app's own type role and the platform's font metrics, and + floors it at the platform minimum touch target + (`LocalMinimumInteractiveComponentSize`). `SlidingPaneStack` adds the leading + system-gesture inset (`systemBars ∪ systemGestures`) and uses that as the whole + covered region. No percentage of the window, budget token or new dp constant + stands in for it; the only fixed values left are platform ones (the minimum + touch target and the leading gesture inset) plus the identity's own existing + `SPACING_S` padding and the icon's own default size. +- **The active pane's width is the same at every depth — the invariant.** + `coveredEdgesDp` (`ui/components/SlidingPaneStack.kt`) always returns edges that + sum to exactly the region, so `activeStart` is the region and the active pane + measures `hostWidth - region` at depth 1, 2, 3 and 4 alike. Opening another + level only adds an edge *inside* the region; it never widens the region or + resizes or reflows a pane already there. `SlidingPaneStackTest` asserts the sum + is constant across depths (`theCoveredRegionIsTheSameAtEveryDepthSoTheActiveWidthNeverChanges`). +- **The stack reads as a stack, and depth does not consume width.** The nearest + covered level shows its identity. One older level is shown as a thinner edge — + the platform minimum touch target, the thinnest edge that stays tappable after + the leading inset — and every level older than that folds into that edge's + count (`" more"`) instead of spending width on each. When the region cannot + fit the thin older edge as well as a full touch target for the nearest identity + (one identity width is usually less than two touch targets), the older levels + fold into the nearest edge's count rather than being squeezed: nothing is + derived below the platform minimum. Tapping an edge still calls the same + `onPopTo(level)`, closing everything above it. +- **The old token and what replaced it.** `PEEK_BUDGET_DP` was `224.dp` and is + removed, together with `MIN_ACTIVE_PANE_WIDTH_DP` (`320.dp`) and the + `peekBudgetDp`/`peekStripsDp` split of a fixed budget. What replaced it is the + measured compact-identity width above. `PEEK_WIDTH_DP` (`56.dp`) and + `MIN_COVERED_PANE_WIDTH_DP` (`112.dp`) no longer place anything either: they now + only bound which statistics a covered identity shows (see + `paneStatTier`/`visiblePaneStats`) and are documented as such in `Dimens.kt`. +- **The identity carries an icon.** `PaneIdentity` gained an `icon` parameter + drawn above the title at the vector's own default size, so the drawn identity + matches the width that was measured for it. The list, pipeline-detail, + run-detail and stage panes each pass their own glyph. + +Evidence (macOS, JDK 17 from Homebrew `openjdk@17`, the cached Gradle 8.11.1 +distribution, `ANDROID_HOME=~/Library/Android/sdk`, `--offline`, every command +with `--no-daemon`): + +- `gradle :app:testDebugUnitTest :app:assembleDebug --no-daemon --offline + --console=plain` → `BUILD SUCCESSFUL`. The result XMLs total **293 tests, 0 + failures, 0 errors, 0 skipped** across 34 files. The rewritten + `SlidingPaneStackTest` pins the invariant and the fold rules: a narrow window + spends nothing, the edges sum to the region at every depth (so the active width + is constant), one covered level keeps the whole identity edge, two covered + levels show the nearest identity plus one thinner older edge, beyond two the + older levels fold into one count edge, a region too small to fit both a thin + edge and the nearest touch target collapses to a single counted edge, the + nearest edge keeps its touch target after the gesture inset, and the edges stay + monotonic and deterministic. +- `app/build/outputs/apk/debug/app-debug.apk` is 18,247,412 bytes, sha256 + `77db131cdb2737da64286384e5f7387540b1c87588b89c36bf4c34821f091372`; it was + copied to `~/.local/share/pipelines/data/artifacts/166/1/pipelines-debug-wip-b003872.apk` + (`b003872` = `git rev-parse --short HEAD`; the tree is WIP on top of it). + `curl -I http://10.0.0.249:8080/artifacts/166/1/pipelines-debug-wip-b003872.apk` + returned `HTTP/1.1 200 OK`, `Content-Type: application/vnd.android.package-archive`, + `Content-Length: 18247412`. + +Not verified in this pass: the derived widths on a real window, the stacked look +and the identifiers on the left, the covered area's share of the window, and the +two- and four-level screenshots — all of that is runtime/visual evidence for the +review stages, and the device policy for this brief keeps the implementation to +the build and the unit tests. Four levels are also unreachable in the app itself +(`MasterPane.List/Detail/Stage`, `MAX_PANE_DEPTH = 2`), so the four-level fold is +covered by the pure `coveredEdgesDp` cases rather than by a screenshot. 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 eccc2799..a4e7e7ff 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 @@ -48,6 +48,24 @@ fun formatDuration(start: String, end: String): String? = internal fun secondsSince(start: String, nowMillis: Long): Long? = parseInstant(start)?.let { ((nowMillis - it.toInstant().toEpochMilli()) / 1000).coerceAtLeast(0) } +/** + * The time a run has taken so far: while it is still [executing], its live + * elapsed time from its server start timestamp to [nowMillis]; once it has + * finished, its stored total duration. The single rule the runs list's meta line, + * the pipeline last-run line and the run detail summary share, so the same run is + * never described differently in the three places. Null when the start (or, for a + * finished run, the end) is unusable, so the caller omits the value instead of + * printing a blank; a running run with a future start (clock skew) reads as `0s`, + * never a negative. + */ +internal fun runDurationText( + createdAt: String, + finishedAt: String, + executing: Boolean, + nowMillis: Long, +): String? = + if (executing) secondsSince(createdAt, nowMillis)?.let(::formatDuration) + else formatDuration(createdAt, finishedAt) /** * Human duration for a whole number of seconds. The single formatting rule for diff --git a/android/app/src/main/java/net/awan/pipelines/ui/PipelinesApp.kt b/android/app/src/main/java/net/awan/pipelines/ui/PipelinesApp.kt index 6b24fb90..174bf777 100644 --- a/android/app/src/main/java/net/awan/pipelines/ui/PipelinesApp.kt +++ b/android/app/src/main/java/net/awan/pipelines/ui/PipelinesApp.kt @@ -29,6 +29,7 @@ import androidx.compose.foundation.layout.only import androidx.compose.foundation.layout.padding import androidx.compose.foundation.layout.size import androidx.compose.foundation.layout.windowInsetsPadding +import androidx.compose.foundation.lazy.LazyListState import androidx.compose.foundation.selection.selectable import androidx.compose.foundation.shape.CircleShape import androidx.compose.foundation.shape.RoundedCornerShape @@ -183,6 +184,13 @@ fun PipelinesApp(vm: AppViewModel) { dismissSearch() } + // One list scroll position each, owned here above the NavHost so it survives + // the destination (and list screen) being recreated when a pane is covered or + // the runs selection changes, as well as a configuration change and process + // death. The list screens only clamp it when the list changed underneath. + val pipelineListState = rememberSaveable(saver = LazyListState.Saver) { LazyListState() } + val runListState = rememberSaveable(saver = LazyListState.Saver) { LazyListState() } + val onNavigate: (TopDestination) -> Unit = { destination -> if (currentRoute != destination.route) { navController.navigate(destination.route) { @@ -234,6 +242,7 @@ fun PipelinesApp(vm: AppViewModel) { wide = wide, selection = pipelineSelection, onSelectionChange = { pipelineSelection = it }, + listState = pipelineListState, onOpenRun = { runId -> runSelection = PaneSelection( pane = MasterPane.Detail, @@ -251,6 +260,7 @@ fun PipelinesApp(vm: AppViewModel) { onSelectionChange = { runSelection = it }, pendingNav = runSearchNav, onPendingNavResolved = { runSearchNav = null }, + listState = runListState, ) } composable("settings") { @@ -339,6 +349,7 @@ private fun PipelineDestination( wide: Boolean, selection: PaneSelection, onSelectionChange: (PaneSelection) -> Unit, + listState: LazyListState, onOpenRun: (Long) -> Unit, ) { val depth = selection.depth @@ -354,6 +365,8 @@ private fun PipelineDestination( depth = depth, wide = wide, onPopTo = { level -> onSelectionChange(popTo(selection, level)) }, + compactLabel = "Pipelines", + compactIcon = Icons.Filled.AccountTree, backContentDescription = { level -> if (level == 0) "Back to pipelines" else "Back to pipeline" }, pane = { level, covered, paneModifier -> when (level) { @@ -365,6 +378,7 @@ private fun PipelineDestination( modifier = paneModifier, selectedId = selection.itemId.takeIf { depth >= 1 }, covered = covered, + listState = listState, ) 1 -> rememberPaneContent( selection.itemId.takeIf { it != 0L }?.let { @@ -423,6 +437,7 @@ private fun RunsDestination( onSelectionChange: (PaneSelection) -> Unit, pendingNav: SearchTarget.Run?, onPendingNavResolved: () -> Unit, + listState: LazyListState, ) { val depth = selection.depth val onBack: () -> Unit = { onSelectionChange(backFrom(selection)) } @@ -448,6 +463,8 @@ private fun RunsDestination( depth = depth, wide = wide, onPopTo = { level -> onSelectionChange(popTo(selection, level)) }, + compactLabel = "Runs", + compactIcon = Icons.Filled.History, backContentDescription = { level -> if (level == 0) "Back to runs" else "Back to run" }, pane = { level, covered, paneModifier -> when (level) { @@ -457,6 +474,7 @@ private fun RunsDestination( modifier = paneModifier, selectedRunId = selection.itemId.takeIf { depth >= 1 }, covered = covered, + listState = listState, ) 1 -> rememberPaneContent( selection.itemId.takeIf { it != 0L }?.let { it to selection.sectionIndex }, diff --git a/android/app/src/main/java/net/awan/pipelines/ui/components/ListScroll.kt b/android/app/src/main/java/net/awan/pipelines/ui/components/ListScroll.kt new file mode 100644 index 00000000..a6d01b8e --- /dev/null +++ b/android/app/src/main/java/net/awan/pipelines/ui/components/ListScroll.kt @@ -0,0 +1,55 @@ +package net.awan.pipelines.ui.components + +import androidx.compose.foundation.lazy.LazyListState +import androidx.compose.runtime.Composable +import androidx.compose.runtime.LaunchedEffect + +/** + * A list's saved scroll position: the index of the first visible item and the + * pixel offset of that item from the viewport's top edge. Both are primitives, so + * the pair round-trips through a Bundle and survives a configuration change or + * process death; it is deliberately independent of any particular list, so the + * restore/clamp rule is pure and unit-testable without a device. + */ +internal data class ListScrollAnchor(val index: Int = 0, val offset: Int = 0) + +/** + * The anchor to restore into a list of [itemCount] items: the saved index clamped + * to the nearest valid item, because the list can have shrunk since the anchor was + * written (a filter, a sort, a refresh, items removed). An empty list has no valid + * index, so it stays at the top. The saved pixel offset is kept only when the + * saved item itself survived; a clamped index points at a different item, so it + * starts at its own top rather than part-way down an unrelated row. Never throws, + * and never falls back to the top while the saved item still exists. + */ +internal fun restoredScrollAnchor(anchor: ListScrollAnchor, itemCount: Int): ListScrollAnchor { + if (itemCount <= 0) return ListScrollAnchor() + val index = anchor.index.coerceIn(0, itemCount - 1) + val offset = if (index == anchor.index) anchor.offset else 0 + return ListScrollAnchor(index, offset) +} + +/** + * Reconciles the live [state] with a list that now has [itemCount] items, so a + * list that changed underneath the operator clamps to the nearest sensible item + * instead of staying past the end (which would draw nothing) or jumping to the + * top. Keyed on [itemCount], so it runs once when the size settles and never on + * the operator's own scrolling — a scroll after coming back is therefore never + * overridden — and an unloaded list ([itemCount] 0) is left alone so a restored + * position is not reset to the top while the data is still on its way. + */ +@Composable +internal fun RestoreListScroll(state: LazyListState, itemCount: Int) { + if (itemCount <= 0) return + LaunchedEffect(itemCount) { + val target = restoredScrollAnchor( + ListScrollAnchor(state.firstVisibleItemIndex, state.firstVisibleItemScrollOffset), + itemCount, + ) + if (target.index != state.firstVisibleItemIndex || + target.offset != state.firstVisibleItemScrollOffset + ) { + state.scrollToItem(target.index, target.offset) + } + } +} diff --git a/android/app/src/main/java/net/awan/pipelines/ui/components/LiveTime.kt b/android/app/src/main/java/net/awan/pipelines/ui/components/LiveTime.kt new file mode 100644 index 00000000..c15337d4 --- /dev/null +++ b/android/app/src/main/java/net/awan/pipelines/ui/components/LiveTime.kt @@ -0,0 +1,53 @@ +package net.awan.pipelines.ui.components + +import androidx.compose.runtime.Composable +import androidx.compose.runtime.LaunchedEffect +import androidx.compose.runtime.getValue +import androidx.compose.runtime.mutableLongStateOf +import androidx.compose.runtime.remember +import androidx.compose.runtime.setValue +import androidx.lifecycle.Lifecycle +import androidx.lifecycle.compose.LocalLifecycleOwner +import androidx.lifecycle.compose.currentStateAsState +import kotlinx.coroutines.delay + +/** A live value advances once a second, never per frame. */ +private const val LIVE_TICK_MILLIS = 1_000L + +/** + * Whether the host activity is resumed. The one background/focus gate every live + * ticking value shares, so a backgrounded app never keeps waking up once a second + * just to repaint a number nobody can see. + */ +@Composable +internal fun hostResumed(): Boolean { + val lifecycleState by LocalLifecycleOwner.current.lifecycle.currentStateAsState() + return lifecycleState.isAtLeast(Lifecycle.State.RESUMED) +} + +/** + * The device clock in epoch millis, advanced once a second while [ticking] is + * true and the host is resumed, and frozen at its last reading otherwise. The + * single ticker behind every live elapsed readout: callers derive their value + * from the server's own start timestamp and this clock, so the numbers stay + * correct after a reconnect (never anchored to when the app happened to load), + * a screen full of running rows runs one coroutine rather than one per row, and + * nothing ticks for a finished run or while the app is backgrounded. + * + * The clock is re-read as the loop (re)starts, so a value frozen while + * backgrounded jumps straight to the correct elapsed on the first frame back. + */ +@Composable +internal fun rememberLiveNowMillis(ticking: Boolean): Long { + var nowMillis by remember { mutableLongStateOf(System.currentTimeMillis()) } + val live = ticking && hostResumed() + LaunchedEffect(live) { + if (!live) return@LaunchedEffect + nowMillis = System.currentTimeMillis() + while (true) { + delay(LIVE_TICK_MILLIS) + nowMillis = System.currentTimeMillis() + } + } + return nowMillis +} diff --git a/android/app/src/main/java/net/awan/pipelines/ui/components/PaneIdentity.kt b/android/app/src/main/java/net/awan/pipelines/ui/components/PaneIdentity.kt index cd6644a5..083fb96d 100644 --- a/android/app/src/main/java/net/awan/pipelines/ui/components/PaneIdentity.kt +++ b/android/app/src/main/java/net/awan/pipelines/ui/components/PaneIdentity.kt @@ -1,40 +1,119 @@ package net.awan.pipelines.ui.components import androidx.compose.foundation.layout.Arrangement -import androidx.compose.foundation.layout.Box +import androidx.compose.foundation.layout.BoxWithConstraints import androidx.compose.foundation.layout.Column import androidx.compose.foundation.layout.fillMaxSize import androidx.compose.foundation.layout.padding +import androidx.compose.material3.Icon +import androidx.compose.material3.LocalMinimumInteractiveComponentSize import androidx.compose.material3.Text import androidx.compose.runtime.Composable +import androidx.compose.runtime.remember import androidx.compose.ui.Alignment import androidx.compose.ui.Modifier +import androidx.compose.ui.graphics.vector.ImageVector +import androidx.compose.ui.platform.LocalDensity +import androidx.compose.ui.text.AnnotatedString +import androidx.compose.ui.text.rememberTextMeasurer import androidx.compose.ui.text.style.TextAlign import androidx.compose.ui.text.style.TextOverflow +import androidx.compose.ui.unit.Dp +import androidx.compose.ui.unit.dp +import net.awan.pipelines.ui.theme.MIN_COVERED_PANE_WIDTH_DP +import net.awan.pipelines.ui.theme.PEEK_WIDTH_DP import net.awan.pipelines.ui.theme.SPACING_M import net.awan.pipelines.ui.theme.SPACING_S import net.awan.pipelines.ui.theme.SPACING_XS import net.awan.pipelines.ui.theme.pipelinesText /** - * A covered pane's compact identity: its title and, when there is one, a single - * status/subtitle line, both centred in the peek strip. A covered pane renders - * this instead of its full body, so its tab rail, list, gallery and scrollable - * body are never drawn squeezed into a sliver. + * One labelled statistic a covered pane shows: its [label] (e.g. `runs`) and its + * [value] (e.g. `11`). The label always travels with its value so a reader can + * tell what the number means, and a [detail] statistic is the kind dropped first + * when the strip is too thin. + */ +data class PaneStat( + val label: String, + val value: String, + val detail: Boolean = false, +) + +/** + * How much of a covered pane's statistics block fits at a given width: the title + * only ([Title]), the run counts ([Counts]) or the full block including the last + * run and the average duration ([Full]). + */ +internal enum class PaneStatTier { Title, Counts, Full } + +/** + * The statistics tier for a covered strip [widthDp]: a strip narrower than one + * tappable peek ([PEEK_WIDTH_DP]) is too thin even for a labelled number, so it + * keeps the title only; a strip at least one minimum covered pane wide plus one + * peek ([MIN_COVERED_PANE_WIDTH_DP] + [PEEK_WIDTH_DP]) has room for the longest + * line (the last run's status and age), so it shows the full block. The + * boundaries reuse the named identity-tier tokens rather than new literals, and + * the decision is pure so it is unit-testable without a device. + */ +internal fun paneStatTier(widthDp: Dp): PaneStatTier = when { + widthDp < PEEK_WIDTH_DP -> PaneStatTier.Title + widthDp < MIN_COVERED_PANE_WIDTH_DP + PEEK_WIDTH_DP -> PaneStatTier.Counts + else -> PaneStatTier.Full +} + +/** + * The statistics of [stats] that fit [tier]: nothing at [PaneStatTier.Title] + * (never a bare figure without its label), only the run counts at + * [PaneStatTier.Counts], and every line at [PaneStatTier.Full]. Pure, so the + * degradation rule is asserted in a unit test without composing anything. + */ +internal fun visiblePaneStats(stats: List, tier: PaneStatTier): List = when (tier) { + PaneStatTier.Title -> emptyList() + PaneStatTier.Counts -> stats.filterNot { it.detail } + PaneStatTier.Full -> stats +} + +/** + * A covered pane's compact identity: its title and, when there are any, a + * compact vertical statistics block, both centred in the peek strip. A covered + * pane renders this instead of its full body, so its tab rail, list, gallery and + * scrollable body are never drawn squeezed into a sliver. * * The strip is narrow but the identity is the whole point of it, so the title - * wraps onto a few centered lines rather than becoming an unreadable ellipsis; - * it is the one place a title may legitimately run over more than one line. + * wraps onto a few centered lines rather than becoming an unreadable ellipsis; it + * is the one place a title may legitimately run over more than one line. The + * statistics are secondary to it and degrade with the width ([paneStatTier]): + * each is a label above its own value, only whole statistics are shown, and a + * strip too thin for a labelled number keeps the title alone — never a number + * clipped mid-digit or a figure without its label. [subtitle] remains for the + * panes whose covered identity is a single status/type word (the stage pane) + * rather than statistics, and [icon] is the pane-kind glyph drawn above the + * title. */ @Composable -fun PaneIdentity(title: String, subtitle: String? = null, modifier: Modifier = Modifier) { +fun PaneIdentity( + title: String, + subtitle: String? = null, + stats: List = emptyList(), + icon: ImageVector? = null, + modifier: Modifier = Modifier, +) { val text = pipelinesText() - Box(modifier.fillMaxSize(), contentAlignment = Alignment.Center) { + // The strip's width is measured here so the statistics block can degrade with + // the space actually available, never from a fixed depth assumption. + BoxWithConstraints(modifier.fillMaxSize(), contentAlignment = Alignment.Center) { + val shown = visiblePaneStats(stats, paneStatTier(maxWidth)) Column( modifier = Modifier.padding(horizontal = SPACING_S, vertical = SPACING_M), horizontalAlignment = Alignment.CenterHorizontally, verticalArrangement = Arrangement.spacedBy(SPACING_XS), ) { + if (icon != null) { + // Drawn at the vector's own default size, which is exactly what + // [rememberCompactIdentityWidth] measures, so the measured width + // and the drawn identity agree without a new size token. + Icon(imageVector = icon, contentDescription = null) + } Text( text = title, style = text.cardTitle, @@ -51,6 +130,64 @@ fun PaneIdentity(title: String, subtitle: String? = null, modifier: Modifier = M overflow = TextOverflow.Ellipsis, ) } + if (shown.isNotEmpty()) { + Column( + horizontalAlignment = Alignment.CenterHorizontally, + verticalArrangement = Arrangement.spacedBy(SPACING_S), + ) { + shown.forEach { stat -> + // Each statistic is its own label above its value, so the + // number is on a line wide enough for it and never shares a + // line with a label that could push it into an ellipsis. + Column(horizontalAlignment = Alignment.CenterHorizontally) { + Text( + text = stat.label, + style = text.meta, + textAlign = TextAlign.Center, + maxLines = 1, + overflow = TextOverflow.Ellipsis, + ) + Text( + text = stat.value, + style = text.label, + textAlign = TextAlign.Center, + maxLines = 1, + overflow = TextOverflow.Ellipsis, + ) + } + } + } + } } } } + +/** + * The width one covered edge must have to show its compact identity: the wider of + * the identity [icon]'s own size and the measured width of [label] (the shortest + * label that identifies the pane, measured at runtime with the app's own type + * role and the platform's font metrics), plus the identity's own horizontal + * padding. The platform minimum touch target is the floor, so an edge is never + * derived below what can be tapped; no window percentage, budget or new dp token + * stands in for it. The caller passes this to `SlidingPaneStack`, which uses it as + * the whole covered region's width at every depth. + */ +@Composable +internal fun rememberCompactIdentityWidth(label: String, icon: ImageVector? = null): Dp { + val measurer = rememberTextMeasurer() + val text = pipelinesText() + val density = LocalDensity.current + val minTouch = LocalMinimumInteractiveComponentSize.current + return remember(measurer, label, icon, text, density, minTouch) { + val labelWidth = with(density) { + measurer.measure( + text = AnnotatedString(label), + style = text.cardTitle, + maxLines = 1, + overflow = TextOverflow.Ellipsis, + ).size.width.toDp() + } + val content = maxOf(labelWidth, icon?.defaultWidth ?: 0.dp) + maxOf(content + SPACING_S * 2, minTouch) + } +} diff --git a/android/app/src/main/java/net/awan/pipelines/ui/components/SlidingPaneStack.kt b/android/app/src/main/java/net/awan/pipelines/ui/components/SlidingPaneStack.kt index c2297c0b..627bc71b 100644 --- a/android/app/src/main/java/net/awan/pipelines/ui/components/SlidingPaneStack.kt +++ b/android/app/src/main/java/net/awan/pipelines/ui/components/SlidingPaneStack.kt @@ -11,16 +11,19 @@ import androidx.compose.foundation.layout.fillMaxHeight import androidx.compose.foundation.layout.fillMaxSize import androidx.compose.foundation.layout.height import androidx.compose.foundation.layout.offset +import androidx.compose.foundation.layout.padding import androidx.compose.foundation.layout.safeDrawing import androidx.compose.foundation.layout.systemGestures import androidx.compose.foundation.layout.union import androidx.compose.foundation.layout.width import androidx.compose.material3.LocalMinimumInteractiveComponentSize +import androidx.compose.material3.Text import androidx.compose.runtime.Composable import androidx.compose.runtime.getValue import androidx.compose.runtime.remember import androidx.compose.ui.Alignment import androidx.compose.ui.Modifier +import androidx.compose.ui.graphics.vector.ImageVector import androidx.compose.ui.input.pointer.PointerEventPass import androidx.compose.ui.input.pointer.pointerInput import androidx.compose.ui.platform.LocalLayoutDirection @@ -32,14 +35,15 @@ import androidx.compose.ui.semantics.semantics import androidx.compose.ui.unit.Dp import androidx.compose.ui.unit.dp import net.awan.pipelines.ui.MAX_PANE_DEPTH -import net.awan.pipelines.ui.theme.MIN_ACTIVE_PANE_WIDTH_DP -import net.awan.pipelines.ui.theme.MIN_COVERED_PANE_WIDTH_DP -import net.awan.pipelines.ui.theme.PEEK_BUDGET_DP -import net.awan.pipelines.ui.theme.PEEK_WIDTH_DP +import net.awan.pipelines.ui.theme.SPACING_XS +import net.awan.pipelines.ui.theme.pipelinesText -// The pane geometry tokens (peek width/budget and the minimum active/covered -// pane widths) live in ui/theme/Dimens.kt, the single source of truth for app -// geometry; this file only derives offsets and widths from them. +// The covered region's width is not a token: it is measured from the compact +// identity a covered pane actually has to show (an icon plus the shortest label +// that identifies it) plus the leading gesture inset, so no screen or constant +// decides how much of a folded window the stack spends. The only fixed values +// left are platform ones: the minimum touch target that keeps an edge tappable +// and the leading system gesture inset this file already reads from the window. /** * The one slide timing every pane shares: the [MotionStandard] token, whose @@ -74,87 +78,73 @@ internal fun paneSlideDelayMillis(level: Int, depth: Int, previousDepth: Int): I internal fun paneSlideSpec(level: Int, depth: Int, previousDepth: Int): TweenSpec = MotionStandard.spec(delayMillis = paneSlideDelayMillis(level, depth, previousDepth)) -/** - * The peek budget actually spent on a wide window: the fixed [PEEK_BUDGET_DP] - * token, reduced only when that would leave the active pane narrower than - * [MIN_ACTIVE_PANE_WIDTH_DP] on a small host. The budget never depends on the - * stack depth, so the active pane keeps a constant width as levels are added. - * Pure so the budget is unit-testable without a device. - */ -internal fun peekBudgetDp(hostWidth: Dp, requested: Dp = PEEK_BUDGET_DP): Dp = - requested.coerceAtMost((hostWidth - MIN_ACTIVE_PANE_WIDTH_DP).coerceAtLeast(0.dp)) - /** * The width of the pane whose open left edge is [offset] on a wide window: from - * that offset to the host's right edge. The active pane therefore measures - * `hostWidth - budget`; a narrow host can never yield a negative width. + * that offset to the host's right edge. The active pane therefore measures the + * host less the covered region; a narrow host can never yield a negative width. */ internal fun paneWidthDp(hostWidth: Dp, offset: Dp): Dp = maxOf(0.dp, hostWidth - offset) /** - * One covered strip of a wide-window stack, in left-to-right order. [level] is - * the pane whose compact identity it shows; a [folded] count greater than one - * marks a strip that stands in for that many older levels (one edge indicator - * with a count) instead of a single pane, so no covered pane is squeezed below - * the named minimum width. + * One covered pane's visible edge in a wide stack's covered region, in + * left-to-right order. [level] is the pane whose compact identity the edge shows + * (for a folded edge, the newest of the levels it stands in for). [folded] is the + * number of *additional* older levels that edge represents, so those levels + * collapse into its count instead of spending width on each of them. */ -internal data class PeekStrip( +internal data class PaneEdge( val level: Int, val start: Dp, val width: Dp, - val folded: Int = 1, + val folded: Int = 0, ) /** - * The covered strips of a wide stack for [covered] covered levels and the fixed - * [budget]. Every shown pane keeps at least `minCovered`; the leftmost strip is - * widened first so that after [startInset] it still leaves [minPeek] tappable, - * and the rest of the budget is then split evenly between the other strips. + * The covered edges of a wide stack for [covered] covered levels, laid out inside + * the one covered region [region]. The region is derived from the measured + * compact-identity width (see [rememberCompactIdentityWidth]) plus the leading + * gesture inset [startInset], and is **the same at every depth**: the nearest + * covered level keeps the whole region less, at most, one thinner edge. The active + * pane's left edge — and therefore its width — is the region, so it never changes + * as levels are added. That is the invariant: opening another level only ever adds + * its own thin edge inside the region, never widens the region. * - * When [covered] levels cannot each get `minCovered` out of [budget], one strip - * (the leftmost) is reserved as an edge indicator folding the oldest levels into - * a single count, and only the newest levels keep their own peek: the number of - * peeks shown shrinks rather than the width of each. The active pane's left edge - * is therefore still exactly the budget. Pure, so the shared-budget geometry and - * the fold rule need no device; an empty list means nothing is covered. + * The nearest covered level always shows its identity. One older level is shown + * as a thinner edge — the platform minimum touch target [minTouch], the thinnest + * an edge may be and stay tappable after [startInset] — and every level older than + * that collapses into that edge's [PaneEdge.folded] count rather than + * accumulating width. When the region cannot fit that thinner edge as well as a + * full [minTouch] identity, nothing is squeezed below the touch target: the older + * levels fold into the nearest edge's count instead. Pure, so the invariant, the + * thin edge and the fold rule need no device; an empty list means nothing is + * covered. */ -internal fun peekStripsDp( +internal fun coveredEdgesDp( covered: Int, - budget: Dp, + region: Dp, + minTouch: Dp, startInset: Dp, - minPeek: Dp, - minCovered: Dp = MIN_COVERED_PANE_WIDTH_DP, -): List { - if (covered <= 0 || budget <= 0.dp) return emptyList() - // How many covered panes the budget can show at the minimum width. When some - // levels have to fold, one of those slots is spent on the edge indicator. - val capacity = if (minCovered > 0.dp) (budget.value / minCovered.value).toInt() else covered - val fold = covered > capacity - val shown = if (fold) (capacity - 1).coerceAtLeast(0) else covered - val folded = covered - shown - val slots = shown + if (fold) 1 else 0 - val first = minOf(budget, maxOf(budget / slots, startInset + minPeek)) - val rest = budget - first - val steps = slots - 1 - val starts = ArrayList(slots + 1) - starts += 0.dp - starts += first - for (i in 1 until slots) { - starts += first + rest * i / steps +): List { + if (covered <= 0 || region <= 0.dp) return emptyList() + val nearest = covered - 1 + if (covered == 1) return listOf(PaneEdge(nearest, 0.dp, region)) + // The thinner older edge keeps one touch target after the leading inset; the + // nearest identity needs one too, or the older levels fold into its count. + val older = startInset + minTouch + return if (region >= older + minTouch) { + listOf( + PaneEdge( + level = (covered - 2).coerceAtLeast(0), + start = 0.dp, + width = older, + folded = (covered - 2).coerceAtLeast(0), + ), + PaneEdge(nearest, older, region - older), + ) + } else { + listOf(PaneEdge(nearest, 0.dp, region, folded = covered - 1)) } - val strips = ArrayList(slots) - var slot = 0 - if (fold) { - strips += PeekStrip(folded - 1, starts[0], starts[1] - starts[0], folded = folded) - slot = 1 - } - for (i in 0 until shown) { - val level = folded + i - val s = slot + i - strips += PeekStrip(level, starts[s], starts[s + 1] - starts[s]) - } - return strips } /** @@ -180,18 +170,21 @@ internal fun paneSafeArea(): WindowInsets = WindowInsets.safeDrawing * * On a **narrow** window ([wide] false) it is not a stack at all: there is no * peek and no leftover strip, and each opened pane is a full-window screen that - * slides in over the last. On a **wide** window ([wide] true) the panes stack, - * but the space spent on the covered panes is a single fixed budget shared - * between them: the active pane's left edge is always exactly the budget, so it - * keeps a constant width and the stack never consumes more than the budget - * however deep it gets. + * slides in over the last. On a **wide** window ([wide] true) the panes stack: + * the covered panes sit under the active one, each showing its left edge, and the + * covered region's width is not a constant but is measured from the compact + * identity a covered edge has to show ([compactLabel], see + * [rememberCompactIdentityWidth]) plus the leading gesture inset. The active + * pane's left edge is always exactly that region, so its width is the same at + * every depth: opening another level only adds its own thin edge inside the + * region and never resizes the panes already there. * * A covered pane shows a compact identity only (its pane composable is told * [covered] and is expected to render just a title/status), constrained to the - * visible strip, so its full body is never drawn into a sliver. When the budget - * cannot give every covered pane the named minimum width, the oldest levels - * fold into a single edge indicator carrying their count rather than being - * squeezed. + * visible edge, so its full body is never drawn into a sliver. The nearest + * covered level shows its identity; one older level is a thinner edge and every + * older level than that folds into that edge's count ([coveredEdgesDp]), so no + * level is ever squeezed below the platform minimum touch target. * * [depth] is the number of visible panes minus one (0..[MAX_PANE_DEPTH]); * [pane] composes the level's content. The stack mounts a level while it is open @@ -211,13 +204,15 @@ internal fun paneSafeArea(): WindowInsets = WindowInsets.safeDrawing * are retargeted in reverse, and several levels closing in one tap reverse in * order. A covered pane is hidden from accessibility and made non-interactive so * TalkBack focus follows the top pane and a tap can never leak through to a - * covered one; on a wide window only its peek strip stays tappable. + * covered one; on a wide window only its edge stays tappable. */ @Composable fun SlidingPaneStack( depth: Int, wide: Boolean, onPopTo: (Int) -> Unit, + compactLabel: String, + compactIcon: ImageVector? = null, modifier: Modifier = Modifier, backContentDescription: (Int) -> String = { "Back" }, pane: @Composable (level: Int, covered: Boolean, modifier: Modifier) -> Unit, @@ -236,48 +231,27 @@ fun SlidingPaneStack( // The strip/compact identity area: the host clear of the top/bottom insets. val stripHeight = maxOf(0.dp, maxHeight - topInset - bottomInset) - // Narrow: no peek at all (budget 0, every pane fills the host). Wide: one - // fixed budget shared between the covered panes, folded when it cannot - // give each the named minimum. The platform's minimum interactive size is - // the floor for a tappable strip, never a literal. - val minPeek = maxOf(PEEK_WIDTH_DP, LocalMinimumInteractiveComponentSize.current) - val budget = if (wide) peekBudgetDp(hostWidth) else 0.dp - val strips = peekStripsDp(depth, budget, startInset, minPeek) - val stripByLevel = strips.associateBy { it.level } - val folded = strips.firstOrNull()?.takeIf { it.folded > 1 }?.folded ?: 0 - // The active pane always opens at the whole budget (or 0 when narrow). - val activeStart = strips.fold(0.dp) { acc, strip -> acc + strip.width } + // Narrow: no peek at all, so every pane fills the host and the covered + // region is empty. Wide: the region is one measured compact identity plus + // the leading gesture inset; it is the same at every depth, so the active + // pane's width never depends on how deep the stack is. The platform's + // minimum interactive size is the floor for each tappable edge, never a + // literal. + val minTouch = LocalMinimumInteractiveComponentSize.current + val identityWidth = rememberCompactIdentityWidth(compactLabel, compactIcon) + val region = if (wide) identityWidth + startInset else 0.dp + val edges = coveredEdgesDp(depth, region, minTouch, startInset) + val edgeByLevel = edges.associateBy { it.level } + val shownCovered = edges.map { it.level }.toSet() + // The active pane always opens at exactly the covered region's width (0 + // when nothing is covered or the window is narrow, so it fills the host). + val activeStart = edges.fold(0.dp) { acc, edge -> acc + edge.width } // The depth just before the current one, so a pop knows how many levels // were open (to stagger their reversal). Held stable for a given depth so // the slide spec never changes part-way through a slide. val depthTrack = remember { PaneDepthTrack(depth) } val closingFrom = remember(depth) { depthTrack.previous.also { depthTrack.previous = depth } } - // The folded older levels as one edge indicator with a count, clear of the - // status/nav bars and of the left gesture area; tapping it jumps back to - // the newest folded level. - if (folded > 0) { - val strip = strips.first() - Box( - Modifier - .align(Alignment.TopStart) - .offset(x = startInset, y = topInset) - .width(maxOf(0.dp, strip.width - startInset)) - .height(stripHeight) - .clickable( - role = Role.Button, - onClickLabel = backContentDescription(folded - 1), - onClick = { onPopTo(folded - 1) }, - ) - .semantics { - contentDescription = backContentDescription(folded - 1) - role = Role.Button - }, - ) { - PaneIdentity("$folded more", null, Modifier.fillMaxSize()) - } - } - // Panes 0..MAX are always given their own long-lived animator, in order, // even while closed, so a retarget slides rather than jumps and the // animator stays warm; a level beyond the depth waits exactly off the @@ -285,20 +259,22 @@ fun SlidingPaneStack( // exact time-reverse of opening. for (level in 0..MAX_PANE_DEPTH) { val covered = level < depth - // A level folded into the edge indicator is not drawn on its own. - if (covered && level < folded) continue - val strip = if (covered) stripByLevel[level] else null + // A level folded into an older edge's count is not drawn on its own. + // A narrow window has no edges at all, so every covered level keeps + // composing its full body under the active one, as before. + if (covered && edges.isNotEmpty() && level !in shownCovered) continue + val edge = if (covered) edgeByLevel[level] else null - // An open pane sits at its shared-budget offset; a closed one waits - // exactly off the right edge. Its width is already the width it will - // have when open, so it slides rather than grows. + // An open pane sits at its edge's offset; a closed one waits exactly + // off the right edge. Its width is already the width it will have when + // open, so it slides rather than grows. val openOffset = when { level > depth -> hostWidth level == depth -> activeStart - strip != null -> strip.start + edge != null -> edge.start else -> 0.dp } - val openWidth = paneWidthDp(hostWidth, if (level <= depth) openOffset else budget) + val openWidth = paneWidthDp(hostWidth, if (level <= depth) openOffset else region) val offset by animateDpAsState( targetValue = openOffset, animationSpec = paneSlideSpec(level, depth, closingFrom), @@ -318,20 +294,30 @@ fun SlidingPaneStack( .fillMaxHeight() .then(if (level < depth) Modifier.blockPointerInput() else Modifier), ) { - if (strip != null) { - // Constrain the compact identity to the visible strip so it - // is centred in the space the covered pane actually has. It - // rides with the pane's own offset and slides in so it also - // slides back out with it. - val stripInset = if (level == 0) startInset else 0.dp + if (edge != null) { + // Constrain the compact identity to the visible edge so it + // is centred in the space the covered pane actually has, and + // carry this level's share of the folded older levels as a + // count. It rides with the pane's own offset and slides in so + // it also slides back out with it. + val edgeInset = if (edge === edges.first()) startInset else 0.dp Box( Modifier .align(Alignment.TopStart) - .offset(x = stripInset, y = topInset) - .width(maxOf(0.dp, strip.width - stripInset)) + .offset(x = edgeInset, y = topInset) + .width(maxOf(0.dp, edge.width - edgeInset)) .height(stripHeight), ) { pane(level, true, Modifier.fillMaxSize()) + if (edge.folded > 0) { + Text( + text = "${edge.folded} more", + style = pipelinesText().meta, + modifier = Modifier + .align(Alignment.TopEnd) + .padding(SPACING_XS), + ) + } } } else { pane(level, false, Modifier.fillMaxSize()) @@ -339,26 +325,26 @@ fun SlidingPaneStack( } } - // The covered pane's tappable peek (wide windows only): the strip + // The covered pane's tappable edge (wide windows only): the edge // between this pane's offset and the next pane's, clear of the // status/nav bars and of the left gesture area. It sits above the // pane's compact identity so tapping it closes every pane to its // right; it never overlaps the next pane. - if (strip != null) { - val stripInset = if (level == 0) startInset else 0.dp + if (edge != null) { + val edgeInset = if (edge === edges.first()) startInset else 0.dp Box( Modifier .align(Alignment.TopStart) - .offset(x = strip.start + stripInset, y = topInset) - .width(maxOf(0.dp, strip.width - stripInset)) + .offset(x = edge.start + edgeInset, y = topInset) + .width(maxOf(0.dp, edge.width - edgeInset)) .height(stripHeight) .clickable( role = Role.Button, - onClickLabel = backContentDescription(level), - onClick = { onPopTo(level) }, + onClickLabel = backContentDescription(edge.level), + onClick = { onPopTo(edge.level) }, ) .semantics { - contentDescription = backContentDescription(level) + contentDescription = backContentDescription(edge.level) role = Role.Button }, ) 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 4fb03154..54980655 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 @@ -115,11 +115,19 @@ sealed interface LoadPhase { /** * Classifies a list pane's [LoadPhase] from its load signals. A failed load with - * no data wins, then a load with no data, then an empty result; anything else is - * [LoadPhase.Content]. [emptyMessage] is non-null exactly when the pane is empty - * and is the text to show, captured so a fading-out empty branch never reads a - * changed query; [emptyActionLabel] labels the one recovery action offered with - * that text (both are captured at classification). + * no data wins, then a list with no data yet ([loaded] false, or a load in + * flight), then an empty result; anything else is [LoadPhase.Content]. + * [emptyMessage] is non-null exactly when the pane is empty and is the text to + * show, captured so a fading-out empty branch never reads a changed query; + * [emptyActionLabel] labels the one recovery action offered with that text (both + * are captured at classification). + * + * [loaded] is the pane's "data has arrived at least once" signal. Before the + * first load completes the initial state is both not-loading and data-less, and + * without this it would classify as content: a list that has never loaded must + * read as loading, not as an empty list, so a restored scroll position is never + * clamped against a list that is merely not there yet. It defaults to true so a + * pane that has no such signal keeps the previous behaviour. * * When stale data is present neither loading nor an error replaces it: the * screen keeps showing the data and surfaces the error inline, so [hasData] @@ -131,9 +139,10 @@ fun listLoadPhase( hasData: Boolean, emptyMessage: String?, emptyActionLabel: String? = null, + loaded: Boolean = true, ): LoadPhase = when { error != null && !hasData -> LoadPhase.Error(error) - loading && !hasData -> LoadPhase.Loading + !hasData && (loading || !loaded) -> LoadPhase.Loading emptyMessage != null -> LoadPhase.Empty(emptyMessage, emptyActionLabel) else -> LoadPhase.Content } diff --git a/android/app/src/main/java/net/awan/pipelines/ui/graph/StageDetailPane.kt b/android/app/src/main/java/net/awan/pipelines/ui/graph/StageDetailPane.kt index c3eccb93..5d24c710 100644 --- a/android/app/src/main/java/net/awan/pipelines/ui/graph/StageDetailPane.kt +++ b/android/app/src/main/java/net/awan/pipelines/ui/graph/StageDetailPane.kt @@ -11,6 +11,7 @@ import androidx.compose.foundation.rememberScrollState import androidx.compose.foundation.verticalScroll import androidx.compose.material.icons.Icons import androidx.compose.material.icons.automirrored.filled.ArrowBack +import androidx.compose.material.icons.filled.Hub import androidx.compose.material3.ExperimentalMaterial3Api import androidx.compose.material3.Icon import androidx.compose.material3.IconButton @@ -333,6 +334,7 @@ fun StageDetailPane( PaneIdentity( title = GraphSemantics.nodeLabel(stageKey), subtitle = if (stage != null) effectiveStageType(stage.type) else "terminal", + icon = Icons.Filled.Hub, modifier = modifier.fillMaxSize(), ) return 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 157e81c0..3218791a 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 @@ -36,7 +36,6 @@ 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 @@ -75,13 +74,9 @@ 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.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 @@ -90,6 +85,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.components.hostResumed +import net.awan.pipelines.ui.components.rememberLiveNowMillis import net.awan.pipelines.ui.formatDuration import net.awan.pipelines.ui.secondsSince import net.awan.pipelines.ui.theme.GRAPH_ACTIVE_HALO_GAP @@ -274,25 +271,18 @@ fun WorkflowGraph( // 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 onScreen = hostResumed() 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. + // The active stage's live ticking elapsed time, from the shared clock: it + // runs only while the graph is animating a live stage whose start is known, + // 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) - } - } + val nowMillis = rememberLiveNowMillis(animate && !activeStartedAt.isNullOrBlank()) // Measured once per second (never per frame) so the canvas draw adds no // allocation for the timer. val elapsedLayout = remember(activeStartedAt, nowMillis, scheme, density, text) { @@ -1746,9 +1736,6 @@ private fun rememberPulsePhase(animate: Boolean): Float { /** 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 - /** How much of the pulse strength the active halo's soft glow carries. */ private const val ACTIVE_HALO_GLOW = 0.28f diff --git a/android/app/src/main/java/net/awan/pipelines/ui/screens/PaneStats.kt b/android/app/src/main/java/net/awan/pipelines/ui/screens/PaneStats.kt new file mode 100644 index 00000000..da81b432 --- /dev/null +++ b/android/app/src/main/java/net/awan/pipelines/ui/screens/PaneStats.kt @@ -0,0 +1,179 @@ +package net.awan.pipelines.ui.screens + +import java.time.OffsetDateTime +import kotlin.math.roundToLong +import net.awan.pipelines.data.protocol.RunSummary +import net.awan.pipelines.ui.components.PaneStat +import net.awan.pipelines.ui.components.RunState +import net.awan.pipelines.ui.components.runStateOf +import net.awan.pipelines.ui.durationSeconds +import net.awan.pipelines.ui.formatDuration + +/** + * The compact statistics a covered pipeline pane shows, aggregated client-side + * from the run history the app already receives (never a server field). The + * counts mirror the server's own vocabulary (internal/pipeline/stats.go): active + * is a queued/running run, and the average is over the runs that have finished, + * so a still-running run never drags it down. + * + * [lastState]/[lastAgo] are null for a pipeline with no runs (or an id present in + * no history), and [averageSeconds] is null until at least one run has finished; + * the caller shows the rest and omits those lines rather than inventing a value. + */ +internal data class PipelinePeekStats( + val total: Int, + val succeeded: Int, + val failed: Int, + val active: Int, + val lastState: RunState?, + val lastAgo: String?, + val averageSeconds: Long?, +) { + /** The labelled lines, counts first then the last-run/average details. */ + fun lines(): List = buildList { + addAll(countStats(total, succeeded, failed, active)) + lastState?.let { add(PaneStat("last", lastLine(it, lastAgo), detail = true)) } + averageSeconds?.let { add(PaneStat("avg", formatDuration(it), detail = true)) } + } +} + +/** + * The compact statistics a covered list pane (the pipelines list or the runs + * list) shows: counts by status plus the single most recent run, aggregated + * client-side from the run history. A list has no single pipeline to average, so + * it carries no duration line. + */ +internal data class ListPeekStats( + val total: Int, + val succeeded: Int, + val failed: Int, + val active: Int, + val lastState: RunState?, + val lastAgo: String?, +) { + /** The labelled lines, counts first then the last-activity detail. */ + fun lines(): List = buildList { + addAll(countStats(total, succeeded, failed, active)) + lastState?.let { add(PaneStat("last", lastLine(it, lastAgo), detail = true)) } + } +} + +/** + * The whole history's labelled statistics, for a covered list pane (the pipelines + * list, or the runs list with no pipeline filter): counts by status plus the + * single most recent run. Empty until that history has loaded, never a zero-run + * claim before the data is in hand. + */ +internal fun listStatLines(runs: List?, now: OffsetDateTime): List = + runs?.let { listPeekStats(it, now).lines() }.orEmpty() + +/** + * One pipeline's labelled statistics, for a covered pipeline pane (a pipeline's + * detail, or a run open over its pipeline). Empty until both the history has + * loaded and the [pipelineId] is known: an unknown or absent id is "not known + * yet", never the whole history, so a covered run pane can never show the + * server-wide summary as if it were the run's own pipeline. The entry point the + * pipeline-scoped covered panes share, so the "which history, which pipeline" + * wiring lives here instead of at each call site. + */ +internal fun pipelineStatLines( + runs: List?, + pipelineId: Long?, + now: OffsetDateTime, +): List = when { + runs == null || pipelineId == null -> emptyList() + else -> pipelinePeekStats(runs, pipelineId, now).lines() +} + +/** One pipeline's statistics over the whole run history, anchored to [now]. */ +internal fun pipelinePeekStats( + runs: List, + pipelineId: Long, + now: OffsetDateTime, +): PipelinePeekStats { + val tally = RunTally() + for (run in runs) if (run.pipelineId == pipelineId) tally.add(run) + val newest = tally.newest + return PipelinePeekStats( + total = tally.total, + succeeded = tally.succeeded, + failed = tally.failed, + active = tally.active, + lastState = newest?.let { runStateOf(it.status) }, + lastAgo = newest?.let { formatRanAgo(it.createdAt, now) }, + averageSeconds = tally.averageSeconds, + ) +} + +/** The whole history's statistics, anchored to [now]. */ +internal fun listPeekStats(runs: List, now: OffsetDateTime): ListPeekStats { + val tally = RunTally() + for (run in runs) tally.add(run) + val newest = tally.newest + return ListPeekStats( + total = tally.total, + succeeded = tally.succeeded, + failed = tally.failed, + active = tally.active, + lastState = newest?.let { runStateOf(it.status) }, + lastAgo = newest?.let { formatRanAgo(it.createdAt, now) }, + ) +} + +/** + * The per-status counts, the completed-duration total and the most recent run, + * folded together in one pass over a history. [add] is called once per run, so a + * scoped summary ([pipelinePeekStats]) never allocates an intermediate filtered + * list or walks the history a second time for the last run. + */ +private class RunTally { + var total = 0 + private set + var succeeded = 0 + private set + var failed = 0 + private set + var active = 0 + private set + private var durationSeconds = 0L + private var durationCount = 0 + + /** The most recent run seen, by the shared [isMoreRecent] rule, or null. */ + var newest: RunSummary? = null + private set + + /** + * The rounded mean duration over the runs that finished, or null when none + * has. A zero-duration run is a real measurement and is included, not + * dropped. + */ + val averageSeconds: Long? + get() = if (durationCount > 0) (durationSeconds.toDouble() / durationCount).roundToLong() else null + + fun add(run: RunSummary) { + total++ + when (runStateOf(run.status)) { + RunState.Succeeded -> succeeded++ + RunState.Failed -> failed++ + RunState.Running, RunState.Queued -> active++ + else -> Unit + } + durationSeconds(run.createdAt, run.finishedAt)?.let { + durationSeconds += it + durationCount++ + } + val current = newest + if (current == null || isMoreRecent(run, current)) newest = run + } +} + +private fun countStats(total: Int, succeeded: Int, failed: Int, active: Int): List = listOf( + PaneStat("runs", total.toString()), + PaneStat("succeeded", succeeded.toString()), + PaneStat("failed", failed.toString()), + PaneStat("active", active.toString()), +) + +/** `succeeded · 2h ago`, or just the status when the timestamp is unusable. */ +private fun lastLine(state: RunState, ago: String?): String = + listOfNotNull(state.label, ago).joinToString(" · ") diff --git a/android/app/src/main/java/net/awan/pipelines/ui/screens/PipelineDetailScreen.kt b/android/app/src/main/java/net/awan/pipelines/ui/screens/PipelineDetailScreen.kt index 7c989fd4..e5b31088 100644 --- a/android/app/src/main/java/net/awan/pipelines/ui/screens/PipelineDetailScreen.kt +++ b/android/app/src/main/java/net/awan/pipelines/ui/screens/PipelineDetailScreen.kt @@ -15,6 +15,7 @@ import androidx.compose.foundation.layout.width import androidx.compose.foundation.lazy.LazyColumn import androidx.compose.material.icons.Icons import androidx.compose.material.icons.automirrored.filled.ArrowBack +import androidx.compose.material.icons.filled.AccountTree import androidx.compose.material.icons.filled.ContentCopy import androidx.compose.material.icons.filled.PlayArrow import androidx.compose.material.icons.filled.Refresh @@ -42,6 +43,7 @@ import androidx.compose.ui.Alignment import androidx.compose.ui.Modifier import androidx.compose.ui.platform.LocalClipboardManager import androidx.lifecycle.compose.collectAsStateWithLifecycle +import java.time.OffsetDateTime import net.awan.pipelines.data.ErrorMessages import net.awan.pipelines.data.protocol.PipelineDetail import net.awan.pipelines.data.protocol.VersionSummary @@ -89,6 +91,7 @@ fun PipelineDetailScreen( covered: Boolean = false, ) { val state by vm.pipelineDetail.collectAsStateWithLifecycle() + val runsState by vm.runs.collectAsStateWithLifecycle() var showStart by remember { mutableStateOf(false) } LaunchedEffect(pipelineId, version) { vm.loadPipeline(pipelineId, version) } @@ -101,11 +104,18 @@ fun PipelineDetailScreen( val shownDetail = rememberPaneContent(detail) // A covered pane shows its compact identity only; the tab rail and section - // body must never be drawn squeezed into the peek strip. + // body must never be drawn squeezed into the peek strip. When the run history + // is in hand the identity carries this pipeline's statistics (run counts, the + // last run and the average duration) instead of a bare version/stage line. if (covered) { + val now = remember { OffsetDateTime.now() } + val stats = remember(runsState.data, pipelineId, now) { + pipelineStatLines(runsState.data?.runs, pipelineId, now) + } PaneIdentity( title = detail?.name ?: "Pipeline", - subtitle = detail?.let { "v$version · ${it.graph.stages.size} stages" }, + stats = stats, + icon = Icons.Filled.AccountTree, modifier = modifier.fillMaxSize(), ) return 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 e56e15e8..9ac1c405 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 @@ -5,17 +5,18 @@ 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 import net.awan.pipelines.ui.parseInstant +import net.awan.pipelines.ui.runDurationText /** 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. + * ago the run started, its time so far ([duration]: the live elapsed while it is + * still running, the recorded total once finished) 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, @@ -52,8 +53,9 @@ internal fun pipelineRunBadges( /** * 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. + * order. One pass, reusing the shared [isMoreRecent] comparison, so it shares the + * "most recent" rule with the covered panes' last-run line without grouping the + * history into intermediate lists. */ internal fun latestRunByPipeline(runs: List): Map { val latest = HashMap() @@ -70,11 +72,22 @@ internal fun runBadge(run: RunSummary, now: OffsetDateTime): PipelineRunBadge = runId = run.id, state = runStateOf(run.status), ranAgo = formatRanAgo(run.createdAt, now), - duration = formatDuration(run.createdAt, run.finishedAt), + // A still-running run shows the time it has taken so far, recomputed from + // its start timestamp as [now] advances; a finished one its total duration. + duration = runDurationText( + createdAt = run.createdAt, + finishedAt = run.finishedAt, + executing = run.executing, + nowMillis = now.toInstant().toEpochMilli(), + ), ) -/** Timestamps decide recency; the higher run id breaks an exact tie (or a bad timestamp). */ -private fun isMoreRecent(candidate: RunSummary, current: RunSummary): Boolean { +/** + * Timestamps decide recency; the higher run id breaks an exact tie (or a bad + * timestamp). The one recency rule, shared by the per-pipeline last-run join and + * the covered panes' most-recent-run line. + */ +internal fun isMoreRecent(candidate: RunSummary, current: RunSummary): Boolean { val a = parseInstant(candidate.createdAt) val b = parseInstant(current.createdAt) if (a != null && b != null) { @@ -86,7 +99,8 @@ private fun isMoreRecent(candidate: RunSummary, current: RunSummary): Boolean { /** * 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 + * `Nm ago`/`Nh ago`/`Nd ago`, the same integer rhythm as the shared duration + * formatting. 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. 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 287204aa..911ca8c6 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 @@ -10,6 +10,7 @@ import androidx.compose.foundation.layout.fillMaxWidth import androidx.compose.foundation.layout.only import androidx.compose.foundation.layout.padding import androidx.compose.foundation.lazy.LazyColumn +import androidx.compose.foundation.lazy.LazyListState import androidx.compose.foundation.lazy.items import androidx.compose.material.icons.Icons import androidx.compose.material.icons.filled.AccountTree @@ -34,7 +35,9 @@ import androidx.compose.ui.Alignment import androidx.compose.ui.Modifier import androidx.compose.ui.text.style.TextOverflow import androidx.lifecycle.compose.collectAsStateWithLifecycle +import java.time.Instant import java.time.OffsetDateTime +import java.time.ZoneId import net.awan.pipelines.data.protocol.PipelineSummary import net.awan.pipelines.ui.AppViewModel import net.awan.pipelines.ui.components.EmptyState @@ -46,6 +49,7 @@ import net.awan.pipelines.ui.components.ListRow import net.awan.pipelines.ui.components.LoadPhase import net.awan.pipelines.ui.components.LoadingState import net.awan.pipelines.ui.components.PaneIdentity +import net.awan.pipelines.ui.components.RestoreListScroll import net.awan.pipelines.ui.components.RunState import net.awan.pipelines.ui.components.RunStatusChip import net.awan.pipelines.ui.components.SortMenu @@ -53,6 +57,7 @@ import net.awan.pipelines.ui.components.StateCrossfade import net.awan.pipelines.ui.components.animateListItem import net.awan.pipelines.ui.components.listLoadPhase import net.awan.pipelines.ui.components.paneSafeArea +import net.awan.pipelines.ui.components.rememberLiveNowMillis import net.awan.pipelines.ui.theme.SPACING_L import net.awan.pipelines.ui.theme.SPACING_S import net.awan.pipelines.ui.theme.pipelinesText @@ -65,6 +70,7 @@ fun PipelineListScreen( modifier: Modifier = Modifier, selectedId: Long? = null, covered: Boolean = false, + listState: LazyListState, ) { val state by vm.pipelines.collectAsStateWithLifecycle() val runsState by vm.runs.collectAsStateWithLifecycle() @@ -82,8 +88,40 @@ fun PipelineListScreen( vm.refreshRuns() } - // "How long ago" is anchored once per composition, not recomputed per row. - val now = remember { OffsetDateTime.now() } + // "How long ago" (and a running run's live elapsed) are anchored to a shared + // clock that ticks only while some run in the history is executing and the app + // is resumed, so the last-run line's elapsed advances and stays correct after + // a reconnect (derived from the server's own start timestamps) while a fully + // finished history costs no wakeups. + val live = runsState.data?.runs?.any { it.executing } == true + val nowMillis = rememberLiveNowMillis(live) + val now = remember(nowMillis) { + OffsetDateTime.ofInstant(Instant.ofEpochMilli(nowMillis), ZoneId.systemDefault()) + } + + // [listState] is owned by the destination, above the panes: a covered pane is a + // different composition (its compact identity is drawn in a strip), so a state + // held here would be discarded and reset the scroll when a detail closes. + // [RestoreListScroll] clamps it when the list changed underneath. + + // A covered pane shows its compact identity only; the search field and list + // must never be drawn squeezed into the peek strip. Its statistics are the + // run history's summary, folded once; before the history has loaded the + // identity stays title-only rather than claiming zero runs. Measured before + // the row badges below so the peek never pays for the unshown fold. + if (covered) { + val stats = remember(runsState.data, now) { + listStatLines(runsState.data?.runs, now) + } + PaneIdentity( + title = "Pipelines", + stats = stats, + icon = Icons.Filled.AccountTree, + modifier = modifier.fillMaxSize(), + ) + return + } + // 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) { @@ -102,18 +140,6 @@ fun PipelineListScreen( 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) { - val count = state.data?.size ?: 0 - PaneIdentity( - title = "Pipelines", - subtitle = if (count > 0) "$count on this server" else null, - modifier = modifier.fillMaxSize(), - ) - return - } - Scaffold( modifier = modifier, contentWindowInsets = paneSafeArea(), @@ -189,6 +215,11 @@ fun PipelineListScreen( null }, emptyActionLabel = if (items.isEmpty() && all.isNotEmpty()) "Clear filters" else null, + // Before the first load this frame is both data-less and not + // in flight; without [loaded] it would render the "no + // pipelines are defined" empty message against a server that + // has not answered yet. + loaded = state.loaded, ), ) { phase -> when (phase) { @@ -199,19 +230,25 @@ fun PipelineListScreen( actionLabel = phase.actionLabel, onAction = if (phase.actionLabel != null) onClearFilters else null, ) - LoadPhase.Content -> LazyColumn( - modifier = Modifier.fillMaxSize(), - contentPadding = PaddingValues(vertical = SPACING_S), - ) { - items(items, key = { it.id }) { pipeline -> - PipelineRow( - pipeline = pipeline, - selected = pipeline.id == selectedId, - badge = badges[pipeline.id], - runsKnown = runsKnown, - onClick = { onOpen(pipeline.id, pipeline.version) }, - modifier = animateListItem(), - ) + LoadPhase.Content -> { + // Restores the saved position (clamped to the current, + // possibly shrunken, list) without fighting a later scroll. + RestoreListScroll(listState, items.size) + LazyColumn( + state = listState, + modifier = Modifier.fillMaxSize(), + contentPadding = PaddingValues(vertical = SPACING_S), + ) { + items(items, key = { it.id }) { pipeline -> + PipelineRow( + pipeline = pipeline, + selected = pipeline.id == selectedId, + badge = badges[pipeline.id], + runsKnown = runsKnown, + onClick = { onOpen(pipeline.id, pipeline.version) }, + modifier = animateListItem(), + ) + } } } } 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 d6b1ef00..b6ecc908 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 @@ -16,6 +16,7 @@ import androidx.compose.foundation.lazy.LazyColumn import androidx.compose.foundation.lazy.items import androidx.compose.material.icons.Icons import androidx.compose.material.icons.automirrored.filled.ArrowBack +import androidx.compose.material.icons.automirrored.filled.DirectionsRun import androidx.compose.material.icons.filled.AttachFile import androidx.compose.material.icons.filled.Cancel import androidx.compose.material.icons.filled.Refresh @@ -44,6 +45,7 @@ import androidx.compose.ui.unit.dp import androidx.lifecycle.compose.collectAsStateWithLifecycle import kotlinx.coroutines.delay import kotlinx.serialization.json.JsonElement +import java.time.OffsetDateTime import net.awan.pipelines.data.ErrorMessages import net.awan.pipelines.data.protocol.RunDetail import net.awan.pipelines.data.protocol.RunGraphState @@ -69,13 +71,14 @@ import net.awan.pipelines.ui.components.clampTabIndex import net.awan.pipelines.ui.components.collapsibleSection import net.awan.pipelines.ui.components.detailLoadPhase import net.awan.pipelines.ui.components.paneSafeArea +import net.awan.pipelines.ui.components.rememberLiveNowMillis import net.awan.pipelines.ui.components.rememberPaneContent 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.runDurationText import net.awan.pipelines.ui.graph.ArtifactGallery import net.awan.pipelines.ui.graph.ArtifactSelection import net.awan.pipelines.ui.graph.ArtifactSelectionScaffold @@ -108,6 +111,7 @@ fun RunDetailScreen( covered: Boolean = false, ) { val state by vm.runDetail.collectAsStateWithLifecycle() + val runsState by vm.runs.collectAsStateWithLifecycle() val evidenceState by vm.evidence.collectAsStateWithLifecycle() val configuredServerUrl by vm.configuredServerUrl.collectAsStateWithLifecycle() var confirmCancel by remember { mutableStateOf(false) } @@ -156,11 +160,21 @@ fun RunDetailScreen( val summaryTab = runDetailTabs.getOrNull(clampTabIndex(selectedSection, runDetailTabs.size))?.key // A covered pane shows its compact identity only; the tab rail, timeline and - // graphs must never be drawn squeezed into the peek strip. + // graphs must never be drawn squeezed into the peek strip. The run belongs to + // a pipeline, so its identity carries that pipeline's statistics from the run + // history (counts, last run, average) once the history is in hand; until the + // run (and so its pipeline) has loaded the identity stays title-only rather + // than showing the server-wide summary as if it were this run's pipeline. if (covered) { + val now = remember { OffsetDateTime.now() } + val pipelineId = run?.pipelineId + val stats = remember(runsState.data, pipelineId, now) { + pipelineStatLines(runsState.data?.runs, pipelineId, now) + } PaneIdentity( title = run?.name ?: "Run", - subtitle = run?.status?.takeIf { it.isNotBlank() }, + stats = stats, + icon = Icons.AutoMirrored.Filled.DirectionsRun, modifier = modifier.fillMaxSize(), ) return @@ -408,7 +422,7 @@ private fun RunSummaryTab( KeyValueRow("Content hash", run.contentHash, monospace = true) KeyValueRow("Started", run.createdAt) KeyValueRow("Finished", run.finishedAt) - KeyValueRow("Duration", formatDuration(run.createdAt, run.finishedAt) ?: "") + RunDurationRow(run) KeyValueRow("Retry of", if (run.retryOf > 0) "run ${run.retryOf}" else "") CodeBlock("Diagnostic", run.diagnostic, Modifier.padding(top = SPACING_S)) } @@ -417,6 +431,20 @@ private fun RunSummaryTab( } } +/** + * The run summary's Duration row. A running run's value is live: the shared + * per-second clock is read here, in the row itself, so the tick recomposes only + * this row and never the artifacts gallery or the rest of the summary. The value + * is derived from the server's start timestamp (re-read on resume, so it stays + * correct after a reconnect) and is never frozen at load; a finished run shows + * its stored total duration. + */ +@Composable +private fun RunDurationRow(run: RunDetail) { + val nowMillis = rememberLiveNowMillis(run.executing) + KeyValueRow("Duration", runDurationText(run.createdAt, run.finishedAt, run.executing, nowMillis) ?: "") +} + /** * The graph tab on its own: the full-height [WorkflowGraph] panel with its Fit * and expand controls, given the whole content area. The tab's single LazyColumn 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 f6107d52..ab86f44c 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 @@ -15,9 +15,10 @@ import androidx.compose.foundation.layout.only import androidx.compose.foundation.layout.padding import androidx.compose.foundation.layout.size import androidx.compose.foundation.lazy.LazyColumn -import androidx.compose.foundation.lazy.items +import androidx.compose.foundation.lazy.LazyListState import androidx.compose.foundation.shape.RoundedCornerShape import androidx.compose.material.icons.Icons +import androidx.compose.material.icons.automirrored.filled.List import androidx.compose.material.icons.filled.Refresh import androidx.compose.material3.Card import androidx.compose.material3.CircularProgressIndicator @@ -56,6 +57,7 @@ import net.awan.pipelines.ui.components.ListRow import net.awan.pipelines.ui.components.LoadPhase import net.awan.pipelines.ui.components.LoadingState import net.awan.pipelines.ui.components.PaneIdentity +import net.awan.pipelines.ui.components.RestoreListScroll import net.awan.pipelines.ui.components.RunState import net.awan.pipelines.ui.components.RunStatusChip import net.awan.pipelines.ui.components.RunStatusIcon @@ -64,9 +66,11 @@ import net.awan.pipelines.ui.components.StateCrossfade import net.awan.pipelines.ui.components.animateListItem import net.awan.pipelines.ui.components.listLoadPhase import net.awan.pipelines.ui.components.paneSafeArea +import net.awan.pipelines.ui.components.rememberLiveNowMillis import net.awan.pipelines.ui.components.runStateColor import net.awan.pipelines.ui.components.runStateOf import net.awan.pipelines.ui.formatDuration +import net.awan.pipelines.ui.runDurationText import net.awan.pipelines.ui.theme.ICON_LIST_DP import net.awan.pipelines.ui.theme.ICON_STATUS_DP import net.awan.pipelines.ui.theme.PipelinesTextStyles @@ -86,6 +90,7 @@ fun RunHistoryScreen( filterPipelineId: Long? = null, selectedRunId: Long? = null, covered: Boolean = false, + listState: LazyListState, ) { val state by vm.runs.collectAsStateWithLifecycle() val sortKey by vm.runSort.collectAsStateWithLifecycle() @@ -107,13 +112,26 @@ fun RunHistoryScreen( pipelineFilterOptions(state.data?.runs.orEmpty()) } + // [listState] is owned by the destination, above the panes: a covered pane is a + // different composition (its compact identity is drawn in a strip), so a state + // held here would be discarded and reset the scroll when a detail closes. + // [RestoreListScroll] clamps it when the history changed underneath. + // 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. + // headers and run rows must never be drawn squeezed into the peek strip. Its + // statistics are the history's status counts and most recent run, folded + // once; a history scoped to one pipeline shows that pipeline's own numbers. if (covered) { - val count = state.data?.runs?.size ?: 0 + val now = remember { OffsetDateTime.now() } + val stats = remember(state.data, filterPipelineId, now) { + val pipelineId = filterPipelineId + if (pipelineId == null) listStatLines(state.data?.runs, now) + else pipelineStatLines(state.data?.runs, pipelineId, now) + } PaneIdentity( title = if (filterPipelineId == null) "Runs" else "Runs for this pipeline", - subtitle = if (count > 0) "$count recorded" else null, + stats = stats, + icon = Icons.AutoMirrored.Filled.List, modifier = modifier.fillMaxSize(), ) return @@ -159,6 +177,11 @@ fun RunHistoryScreen( // usage block and shows the "no runs" line inside the list, where // the item animation fades it in and out. emptyMessage = null, + // Before the first history load this frame has no data and no + // in-flight refresh yet; without [loaded] it would read as an + // empty list and the restore below would clamp a restored + // position to the top of the transient one-item list. + loaded = state.loaded, ), modifier = Modifier.fillMaxSize(), ) { phase -> @@ -179,6 +202,7 @@ fun RunHistoryScreen( error = state.error, onOpenRun = onOpenRun, onClearFilters = onClearFilters, + listState = listState, modifier = Modifier.padding(padding), ) } @@ -247,6 +271,7 @@ private fun RunHistoryContent( error: String?, onOpenRun: (Long) -> Unit, onClearFilters: () -> Unit, + listState: LazyListState, modifier: Modifier = Modifier, ) { val zone = ZoneId.systemDefault() @@ -265,59 +290,144 @@ private fun RunHistoryContent( groupRunsByDay(matched, today, zone, runComparator(sort)) } + // The list body built once, in layout order. It is the single source of both + // the LazyColumn's items and their count, so a restored position is clamped to + // the list the column actually draws rather than to a hand-maintained replica + // of it (see [RestoreListScroll]). + val entries = remember(usage, scoped, matched, groups, error) { + runListEntries( + usage = usage, + nothingRecorded = scoped.isEmpty(), + nothingMatched = matched.isEmpty(), + groups = groups, + error = error, + ) + } + RestoreListScroll(listState, entries.size) + + // One live clock for the whole list: it ticks only while a shown run is + // executing and the app is resumed, and each running row reads its elapsed + // from it rather than starting a coroutine of its own. Elapsed is derived + // from the server's start timestamp, never from when the list loaded, so it + // is still correct after a reconnect; a finished history never ticks. + val live = remember(matched) { matched.any { it.executing } } + val nowMillis = rememberLiveNowMillis(live) + LazyColumn( + state = listState, modifier = modifier.fillMaxSize(), contentPadding = PaddingValues(bottom = SPACING_L), ) { - if (usage != null) { - item(key = "usage") { - UsageMetrics(usage, Modifier.padding(horizontal = SPACING_L, vertical = SPACING_S)) - } - } - if (scoped.isEmpty()) { - // Nothing exists at all: no filter could reveal a run, so there is no - // clear action. - item(key = "runs-empty") { - EmptyState( - "No runs have been recorded yet.", - modifier = animateListItem(), - ) - } - } 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, - modifier = animateListItem(), - ) - } - } else { - groups.forEach { group -> - stickyHeader(key = "day-${group.label}") { DayHeader(group.label) } - items(group.runs, key = { "run-${it.id}" }) { run -> - RunRow( - run = run, - selected = run.id == selectedRunId, - onClick = { onOpenRun(run.id) }, + entries.forEach { entry -> + when (entry) { + is RunListEntry.Usage -> item(key = entry.key) { + UsageMetrics( + entry.usage, + Modifier.padding(horizontal = SPACING_L, vertical = SPACING_S), + ) + } + is RunListEntry.Empty -> item(key = entry.key) { + EmptyState( + message = entry.message, + actionLabel = entry.actionLabel, + // Only the filtered-empty case offers a clear action, which + // [runListEntries] encodes as a non-null label. + onAction = if (entry.actionLabel != null) onClearFilters else null, modifier = animateListItem(), ) } + is RunListEntry.Day -> stickyHeader(key = entry.key) { DayHeader(entry.label) } + is RunListEntry.Run -> item(key = entry.key) { + RunRow( + run = entry.run, + selected = entry.run.id == selectedRunId, + nowMillis = nowMillis, + onClick = { onOpenRun(entry.run.id) }, + modifier = animateListItem(), + ) + } + is RunListEntry.Error -> item(key = entry.key) { + Text( + entry.message, + color = MaterialTheme.colorScheme.error, + style = pipelinesText().body, + modifier = animateListItem(Modifier.padding(SPACING_L)), + ) + } } } - if (error != null) { - item(key = "runs-error") { - Text( - error, - color = MaterialTheme.colorScheme.error, - style = pipelinesText().body, - modifier = animateListItem(Modifier.padding(SPACING_L)), - ) - } + } +} + +/** + * One slot the runs list draws, in layout order: the usage block, the single + * empty-or-grouped body and the optional inline error row. [key] is the stable + * LazyColumn key the list has always used. [runListEntries] builds the whole + * list and both the column and the clamp consume it, so the count a restored + * position is clamped against can never drift from the items the column draws. + */ +internal sealed interface RunListEntry { + val key: String + + /** The usage aggregates block, present only when the history has a summary. */ + data class Usage(val usage: UsageStats) : RunListEntry { + override val key: String get() = "usage" + } + + /** + * The single "nothing recorded"/"nothing matches" line. [actionLabel] is + * non-null exactly when filters hid existing runs, the one case with a clear + * action. + */ + data class Empty(val message: String, val actionLabel: String?) : RunListEntry { + override val key: String + get() = if (actionLabel != null) "runs-filtered-empty" else "runs-empty" + } + + /** A sticky day header above a group's runs. */ + data class Day(val label: String) : RunListEntry { + override val key: String get() = "day-$label" + } + + /** One run row. */ + data class Run(val run: RunSummary) : RunListEntry { + override val key: String get() = "run-${run.id}" + } + + /** The last load's error, kept inline under the stale rows. */ + data class Error(val message: String) : RunListEntry { + override val key: String get() = "runs-error" + } +} + +/** + * The runs list's slots in layout order: the usage block when there is one, then + * either the single empty line (nothing recorded, or nothing matching the + * filters) or the day groups, then the inline error row when the last load + * failed over stale data. Pure and single-sourced with the LazyColumn, so its + * size is exactly the list's item count. + */ +internal fun runListEntries( + usage: UsageStats?, + nothingRecorded: Boolean, + nothingMatched: Boolean, + groups: List, + error: String?, +): List = buildList { + if (usage != null) add(RunListEntry.Usage(usage)) + when { + // Nothing exists at all: no filter could reveal a run, so there is no + // clear action. + nothingRecorded -> add(RunListEntry.Empty("No runs have been recorded yet.", null)) + // Runs exist but every one is filtered out: distinguish this from the + // "nothing exists" case and offer the one clear action. + nothingMatched -> add(RunListEntry.Empty("No runs match the current filters.", "Clear filters")) + else -> groups.forEach { group -> + add(RunListEntry.Day(group.label)) + group.runs.forEach { add(RunListEntry.Run(it)) } } } + if (error != null) add(RunListEntry.Error(error)) } /** A sticky day header ("Today"/"Yesterday"/date) above each group of runs. */ @@ -378,13 +488,15 @@ private fun Metric(label: String, value: String, color: Color, text: PipelinesTe /** * One run as a row of the shared real list: a leading status glyph, the run name * as the title with its version chip, and a secondary line carrying the status - * chip, progress and id/start/duration. The row is selected when its run is the - * one open in the detail pane. + * chip, progress and id/time. The row is selected when its run is the one open in + * the detail pane. [nowMillis] is the shared live clock, read only by a running + * row so its elapsed value advances. */ @Composable private fun RunRow( run: RunSummary, selected: Boolean, + nowMillis: Long, onClick: () -> Unit, modifier: Modifier = Modifier, ) { @@ -429,7 +541,7 @@ private fun RunRow( Text(progressText(run), style = text.meta, maxLines = 1, overflow = TextOverflow.Ellipsis) } - Text(metaText(run), style = text.meta, maxLines = 1, overflow = TextOverflow.Ellipsis) + Text(metaText(run, nowMillis), style = text.meta, maxLines = 1, overflow = TextOverflow.Ellipsis) if (run.diagnostic.isNotBlank()) { Text( @@ -466,13 +578,20 @@ private fun progressText(run: RunSummary): String = buildString { if (run.currentStage.isNotBlank()) append(" · stage ${run.currentStage}") } -/** Run id, start time and duration, all via formatDuration for the duration. */ -private fun metaText(run: RunSummary): String = buildString { +/** + * Run id and its time. A running run shows how long it has taken so far: a live + * elapsed value computed from its server start timestamp against [nowMillis], + * replacing the start time and advancing as the shared clock ticks. A finished + * run keeps its start time and total duration. + */ +private fun metaText(run: RunSummary, nowMillis: Long): String = buildString { append("run ${run.id}") - val start = formatRunStart(run.createdAt) - if (start != null) append(" · $start") - val duration = formatDuration(run.createdAt, run.finishedAt) - if (duration != null) append(" · $duration") + if (run.executing) { + runDurationText(run.createdAt, run.finishedAt, executing = true, nowMillis)?.let { append(" · $it") } + } else { + formatRunStart(run.createdAt)?.let { append(" · $it") } + runDurationText(run.createdAt, run.finishedAt, executing = false, nowMillis)?.let { append(" · $it") } + } } private fun formatRunStart(createdAt: String): String? { diff --git a/android/app/src/main/java/net/awan/pipelines/ui/theme/Dimens.kt b/android/app/src/main/java/net/awan/pipelines/ui/theme/Dimens.kt index f592ca24..52e1cfdc 100644 --- a/android/app/src/main/java/net/awan/pipelines/ui/theme/Dimens.kt +++ b/android/app/src/main/java/net/awan/pipelines/ui/theme/Dimens.kt @@ -58,29 +58,19 @@ internal val ICON_LIST_DP = 20.dp /** Wide detail-rail tab glyph size. */ internal val ICON_RAIL_DP = 24.dp -// ---- Pane geometry (ui/components/SlidingPaneStack.kt) --------------------- -// The sliding pane stack derives every offset and width from these plus the -// measured host width and the system insets; no screen hardcodes a peek or pane -// width. [PEEK_WIDTH_DP] is the minimum width of one covered pane's tappable -// peek (the "collapsed strip"). [PEEK_BUDGET_DP] is the fixed *total* peek -// budget a wide window may spend on all covered panes together, however deep the -// stack gets. [MIN_ACTIVE_PANE_WIDTH_DP] is the least width worth leaving to the -// active (topmost) pane before the budget has to be reduced. -// [MIN_COVERED_PANE_WIDTH_DP] is the least width a covered pane's compact -// identity needs to stay readable and tappable; when the budget cannot give -// every covered pane this much, the oldest levels are folded into one edge -// indicator instead of being squeezed below it. +// ---- Covered-pane identity tiers (ui/components/PaneIdentity.kt) ----------- +// The sliding pane stack no longer derives its width from a token: the covered +// region is measured from the compact identity a covered edge must show (see +// `rememberCompactIdentityWidth`), so there is no fixed peek budget and the +// active pane's width does not depend on the stack's depth. What remains here +// only bounds the *statistics* a covered identity shows once it is drawn: a +// strip narrower than one peek keeps the title alone, and a strip at least one +// minimum covered pane plus one peek wide has room for the full block. -/** Minimum width of one covered pane's tappable peek (the collapsed strip). */ +/** Least width a covered identity needs before it shows labelled statistics. */ internal val PEEK_WIDTH_DP = 56.dp -/** Fixed total peek budget a wide window may spend on all covered panes. */ -internal val PEEK_BUDGET_DP = 224.dp - -/** Least width left to the active (topmost) pane before the budget is reduced. */ -internal val MIN_ACTIVE_PANE_WIDTH_DP = 320.dp - -/** Least width a covered pane's compact identity needs to stay usable. */ +/** Width beyond which a covered identity has room for its full statistics. */ internal val MIN_COVERED_PANE_WIDTH_DP = 112.dp // ---- Destination pill (ui/PipelinesApp.kt) --------------------------------- 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 faa52a29..c1d49460 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 @@ -46,6 +46,36 @@ class FormatTest { assertNull(secondsSince("not a timestamp", startMillis)) } + @Test + fun runDurationTextIsLiveElapsedWhileRunningAndStoredDurationOnceFinished() { + val start = "2026-10-15T02:00:00Z" + val startMillis = parseInstant(start)!!.toInstant().toEpochMilli() + // A run that just started reads 0s, not a blank or a fabricated value. + assertEquals("0s", runDurationText(start, "", executing = true, nowMillis = startMillis)) + // Minute boundary: 59s is still seconds, 60s rolls over to a minute. + assertEquals("59s", runDurationText(start, "", executing = true, nowMillis = startMillis + 59_000)) + assertEquals("1m 0s", runDurationText(start, "", executing = true, nowMillis = startMillis + 60_000)) + // Hour boundary: 3599s is still minutes and seconds, 3600s rolls to hours. + assertEquals("59m 59s", runDurationText(start, "", executing = true, nowMillis = startMillis + 3_599_000)) + assertEquals("1h 0m", runDurationText(start, "", executing = true, nowMillis = startMillis + 3_600_000)) + // A missing start is "no value": never a fabricated 0s and never a crash. + assertNull(runDurationText("", "", executing = true, nowMillis = startMillis)) + // A future start (clock skew) clamps to 0s rather than going negative. + assertEquals("0s", runDurationText(start, "", executing = true, nowMillis = startMillis - 5_000)) + // A finished run ignores the clock and keeps its stored total duration. + assertEquals( + "2m 5s", + runDurationText( + start, + "2026-10-15T02:02:05Z", + executing = false, + nowMillis = startMillis + 9_999_000, + ), + ) + // A finished run with no end timestamp has no duration, not an elapsed. + assertNull(runDurationText(start, "", executing = false, nowMillis = startMillis + 9_999_000)) + } + @Test fun fileChangesSummaryOmitsBlankParts() { assertEquals("", fileChangesSummary(StageFileChanges())) diff --git a/android/app/src/test/java/net/awan/pipelines/ui/components/ListScrollTest.kt b/android/app/src/test/java/net/awan/pipelines/ui/components/ListScrollTest.kt new file mode 100644 index 00000000..356d25f4 --- /dev/null +++ b/android/app/src/test/java/net/awan/pipelines/ui/components/ListScrollTest.kt @@ -0,0 +1,66 @@ +package net.awan.pipelines.ui.components + +import org.junit.Assert.assertEquals +import org.junit.Test + +/** + * The list-scroll restore/clamp rule is pure, so it is checked here without a + * device: a saved position survives while its item is still in the list (the + * same index at the same offset), and a list that shrank underneath the operator + * clamps to the nearest valid item — the saved offset applies only to the saved + * item, an empty list stays at the top, and nothing throws. + */ +class ListScrollTest { + + @Test + fun keepsTheSavedIndexAndOffsetWhenTheItemSurvived() { + assertEquals( + ListScrollAnchor(4, 37), + restoredScrollAnchor(ListScrollAnchor(4, 37), itemCount = 9), + ) + } + + @Test + fun keepsTheOffsetAtTheLastItem() { + assertEquals( + ListScrollAnchor(8, 12), + restoredScrollAnchor(ListScrollAnchor(8, 12), itemCount = 9), + ) + } + + @Test + fun clampsAShrunkenListToItsLastItemAndDropsTheOffset() { + assertEquals( + ListScrollAnchor(2, 0), + restoredScrollAnchor(ListScrollAnchor(7, 90), itemCount = 3), + ) + } + + @Test + fun clampsANegativeIndexToTheTopWithoutTheOffset() { + assertEquals( + ListScrollAnchor(0, 0), + restoredScrollAnchor(ListScrollAnchor(-3, 25), itemCount = 5), + ) + } + + @Test + fun anEmptyListStaysAtTheTop() { + assertEquals( + ListScrollAnchor(0, 0), + restoredScrollAnchor(ListScrollAnchor(6, 40), itemCount = 0), + ) + } + + @Test + fun aSingleItemListClampsButKeepsTheOffsetOnlyForThatItem() { + assertEquals( + ListScrollAnchor(0, 15), + restoredScrollAnchor(ListScrollAnchor(0, 15), itemCount = 1), + ) + assertEquals( + ListScrollAnchor(0, 0), + restoredScrollAnchor(ListScrollAnchor(5, 15), itemCount = 1), + ) + } +} diff --git a/android/app/src/test/java/net/awan/pipelines/ui/components/LoadPhaseTest.kt b/android/app/src/test/java/net/awan/pipelines/ui/components/LoadPhaseTest.kt index c6754b4c..ccd838dd 100644 --- a/android/app/src/test/java/net/awan/pipelines/ui/components/LoadPhaseTest.kt +++ b/android/app/src/test/java/net/awan/pipelines/ui/components/LoadPhaseTest.kt @@ -6,10 +6,11 @@ import org.junit.Test /** * The load-phase classification is pure, so the rules the cross-fading screens * rely on are checked here without a device: a failed load with no data wins over - * loading, a load with no data is loading, an empty result is empty, and stale - * data always keeps the pane on content (the screen shows the error inline - * instead). Detail panes have no empty state, so absent data is an error or a - * load. The message-carrying phases keep the text captured at classification. + * loading, a list with no data yet (a load in flight, or one that has never + * loaded) is loading, an empty result is empty, and stale data always keeps the + * pane on content (the screen shows the error inline instead). Detail panes have + * no empty state, so absent data is an error or a load. The message-carrying + * phases keep the text captured at classification. */ class LoadPhaseTest { @@ -60,16 +61,48 @@ class LoadPhaseTest { ) } + @Test + fun listThatHasNeverLoadedReportsLoadingEvenBeforeTheRefreshStarts() { + // The runs pane has no pane-level empty state, so a data-less frame with + // no in-flight refresh would read as content unless the pane reports that + // it has never loaded. It must read as loading instead, so the restored + // scroll position is never clamped against the transient not-yet-loaded + // list (the empty line lives inside the loaded list). + assertEquals( + LoadPhase.Loading, + listLoadPhase( + loading = false, + error = null, + hasData = false, + emptyMessage = null, + loaded = false, + ), + ) + } + @Test fun listWithoutAnySignalStaysOnContent() { - // A runs pane deliberately has no pane-level empty state, so its initial - // no-data/no-error frame is content (the empty line lives in the list). + // A screen with no "has loaded" signal (the default) keeps the old rule. assertEquals( LoadPhase.Content, listLoadPhase(loading = false, error = null, hasData = false, emptyMessage = null), ) } + @Test + fun aLoadedButDataLessListWithoutAnEmptyMessageIsStillContent() { + assertEquals( + LoadPhase.Content, + listLoadPhase( + loading = false, + error = null, + hasData = false, + emptyMessage = null, + loaded = true, + ), + ) + } + // ---- detail panes ------------------------------------------------------- @Test diff --git a/android/app/src/test/java/net/awan/pipelines/ui/components/PaneIdentityTest.kt b/android/app/src/test/java/net/awan/pipelines/ui/components/PaneIdentityTest.kt new file mode 100644 index 00000000..d3dc10b6 --- /dev/null +++ b/android/app/src/test/java/net/awan/pipelines/ui/components/PaneIdentityTest.kt @@ -0,0 +1,63 @@ +package net.awan.pipelines.ui.components + +import androidx.compose.ui.unit.dp +import net.awan.pipelines.ui.theme.MIN_COVERED_PANE_WIDTH_DP +import net.awan.pipelines.ui.theme.PEEK_WIDTH_DP +import org.junit.Assert.assertEquals +import org.junit.Assert.assertTrue +import org.junit.Test + +/** + * The covered pane's statistics degrade by width through a pure decision, so + * which statistics show at which width is asserted here without a device: a thin + * strip keeps the title only, a medium strip the run counts, and a wide strip the + * full block. No tier ever shows a figure without its label. + */ +class PaneIdentityTest { + + private val counts = listOf( + PaneStat("runs", "11"), + PaneStat("succeeded", "9"), + PaneStat("failed", "2"), + PaneStat("active", "1"), + ) + private val details = listOf( + PaneStat("last", "succeeded · 2h ago", detail = true), + PaneStat("avg", "1m 5s", detail = true), + ) + + @Test + fun aStripThinnerThanOnePeekKeepsTheTitleOnly() { + assertEquals(PaneStatTier.Title, paneStatTier(PEEK_WIDTH_DP - 1.dp)) + assertTrue(visiblePaneStats(counts + details, PaneStatTier.Title).isEmpty()) + } + + @Test + fun aMinimumCoveredStripShowsTheRunCounts() { + assertEquals(PaneStatTier.Counts, paneStatTier(MIN_COVERED_PANE_WIDTH_DP)) + assertEquals(counts, visiblePaneStats(counts + details, PaneStatTier.Counts)) + } + + @Test + fun aStripWideEnoughForTheLongestLineShowsEveryStatistic() { + assertEquals(PaneStatTier.Full, paneStatTier(MIN_COVERED_PANE_WIDTH_DP + PEEK_WIDTH_DP)) + assertEquals(counts + details, visiblePaneStats(counts + details, PaneStatTier.Full)) + } + + @Test + fun theTierBoundariesAreMonotonic() { + val widths = listOf(0.dp, PEEK_WIDTH_DP, MIN_COVERED_PANE_WIDTH_DP, 400.dp) + val tiers = widths.map(::paneStatTier) + assertEquals(listOf(PaneStatTier.Title, PaneStatTier.Counts, PaneStatTier.Counts, PaneStatTier.Full), tiers) + } + + @Test + fun everyShownStatisticKeepsItsLabel() { + for (tier in PaneStatTier.entries) { + visiblePaneStats(counts + details, tier).forEach { + assertTrue("a statistic without a label at $tier: $it", it.label.isNotBlank()) + assertTrue("a statistic without a value at $tier: $it", it.value.isNotBlank()) + } + } + } +} diff --git a/android/app/src/test/java/net/awan/pipelines/ui/components/SlidingPaneStackTest.kt b/android/app/src/test/java/net/awan/pipelines/ui/components/SlidingPaneStackTest.kt index db5b048a..3d4d69ef 100644 --- a/android/app/src/test/java/net/awan/pipelines/ui/components/SlidingPaneStackTest.kt +++ b/android/app/src/test/java/net/awan/pipelines/ui/components/SlidingPaneStackTest.kt @@ -2,128 +2,119 @@ package net.awan.pipelines.ui.components import androidx.compose.ui.unit.Dp import androidx.compose.ui.unit.dp -import net.awan.pipelines.ui.theme.MIN_ACTIVE_PANE_WIDTH_DP -import net.awan.pipelines.ui.theme.MIN_COVERED_PANE_WIDTH_DP -import net.awan.pipelines.ui.theme.PEEK_BUDGET_DP -import net.awan.pipelines.ui.theme.PEEK_WIDTH_DP import org.junit.Assert.assertEquals import org.junit.Assert.assertTrue import org.junit.Test /** - * The pane geometry is pure, so the adaptive width and fold rules are checked - * here without a device: a narrow window spends no peek at all, a wide window - * spends one fixed budget shared between the covered panes however deep the - * stack gets, every shown peek keeps the named minimum covered width, and when - * the budget cannot give the whole stack that much the oldest levels fold into a - * single edge indicator rather than being squeezed. + * The pane geometry is pure, so the width invariant and the fold rules are + * checked here without a device: a narrow window spends no covered region at any + * depth, the covered region — and therefore the active pane's width — is the same + * at every depth, the nearest covered level keeps its identity edge, one older + * level is a thinner edge, and levels older than that fold into that edge's count + * rather than accumulating width. When the region cannot fit both a touch target + * for the thin edge and one for the nearest identity, the older levels fold into + * the nearest edge instead of being squeezed below the platform minimum. */ class SlidingPaneStackTest { private fun assertDp(expected: Dp, actual: Dp, delta: Float = 0.01f) = assertEquals(expected.value, actual.value, delta) - private fun totalWidth(strips: List): Dp = - strips.fold(0.dp) { acc, strip -> acc + strip.width } + private val minTouch = 48.dp + + private fun totalWidth(edges: List): Dp = + edges.fold(0.dp) { acc, edge -> acc + edge.width } @Test - fun narrowWindowSpendsNoPeekAtAnyDepth() { - // Budget 0 is the narrow model: no stack and no leftover strip, so there - // are no covered strips and every pane opens at the host's left edge. + fun narrowWindowSpendsNothingAtAnyDepth() { + // A region of 0 is the narrow model: no covered strip, so every pane opens + // at the host's left edge. for (covered in 0..4) { - assertTrue(peekStripsDp(covered, 0.dp, 30.dp, PEEK_WIDTH_DP).isEmpty()) + assertTrue(coveredEdgesDp(covered, 0.dp, minTouch, 30.dp).isEmpty()) } } @Test - fun wideActivePaneKeepsAConstantWidthAtEveryDepth() { + fun theCoveredRegionIsTheSameAtEveryDepthSoTheActiveWidthNeverChanges() { val host = 800.dp - val budget = peekBudgetDp(host) - assertDp(PEEK_BUDGET_DP, budget) - // The covered strips always sum to exactly the budget, so the active - // (topmost) pane's left edge — and its width — never depend on depth. - for (covered in 1..4) { - val strips = peekStripsDp(covered, budget, startInset = 0.dp, minPeek = PEEK_WIDTH_DP) - assertDp(budget, totalWidth(strips)) - assertDp(host - budget, paneWidthDp(host, totalWidth(strips))) + val region = 200.dp + // The edges always sum to exactly the region, so the active (topmost) + // pane's left edge — and its width — never depend on depth. That is the + // invariant: opening another level only adds an edge inside the region. + for (covered in 1..6) { + val edges = coveredEdgesDp(covered, region, minTouch, startInset = 30.dp) + assertDp(region, totalWidth(edges)) + assertDp(host - region, paneWidthDp(host, totalWidth(edges))) } } @Test - fun twoCoveredLevelsEachKeepTheMinimumCoveredWidth() { - val strips = peekStripsDp(2, PEEK_BUDGET_DP, startInset = 0.dp, minPeek = PEEK_WIDTH_DP) - // Three levels (list + detail + stage): two covered panes, no fold, and - // each has at least the named minimum so its compact identity reads. - assertEquals(2, strips.size) - assertEquals(listOf(0, 1), strips.map { it.level }) - strips.forEach { assertTrue("peek below the minimum: $it", it.width >= MIN_COVERED_PANE_WIDTH_DP) } - assertTrue(strips.all { it.folded == 1 }) + fun oneCoveredLevelKeepsTheWholeIdentityEdge() { + val edges = coveredEdgesDp(1, 200.dp, minTouch, startInset = 30.dp) + assertEquals(1, edges.size) + assertEquals(0, edges.first().level) + assertDp(200.dp, edges.first().width) + assertEquals(0, edges.first().folded) } @Test - fun aFourthLevelFoldsTheOldestIntoOneIndicator() { - // Four levels (three covered) with a budget of two minimums: the oldest - // levels collapse into one edge indicator carrying their count instead of - // squeezing all three, and one peek still shows the newest covered pane. - val strips = peekStripsDp(3, PEEK_BUDGET_DP, startInset = 0.dp, minPeek = PEEK_WIDTH_DP) - assertEquals(2, strips.size) - assertEquals(2, strips.first().folded) - assertEquals(1, strips.last().folded) - assertEquals(2, strips.last().level) - assertTrue(strips.all { it.width >= MIN_COVERED_PANE_WIDTH_DP }) - assertDp(PEEK_BUDGET_DP, totalWidth(strips)) + fun twoCoveredLevelsShowTheNearestIdentityAndOneThinnerOlderEdge() { + val edges = coveredEdgesDp(2, 200.dp, minTouch, startInset = 30.dp) + assertEquals(2, edges.size) + // The older level (0) is the thinner edge — one touch target after the + // leading gesture inset; the nearest level (1) keeps its identity and a + // full touch target of its own. + assertEquals(listOf(0, 1), edges.map { it.level }) + assertDp(30.dp + minTouch, edges.first().width) + assertTrue("nearest identity below the touch target: $edges", edges.last().width >= minTouch) + assertEquals(0, edges.last().folded) } @Test - fun foldedLevelsAreTheOldestAndTheNewestStillPeeks() { - val covered = 4 - val strips = peekStripsDp(covered, PEEK_BUDGET_DP, startInset = 0.dp, minPeek = PEEK_WIDTH_DP) - // The newest covered level keeps its own peek; all older ones fold. - assertEquals(covered - 1, strips.last().level) - assertEquals(3, strips.first().folded) + fun beyondTwoCoveredLevelsTheOlderOnesFoldIntoOneCountEdge() { + val edges = coveredEdgesDp(4, 260.dp, minTouch, startInset = 30.dp) + assertEquals(2, edges.size) + // Levels 0..2 collapse into the single older edge (showing its newest, + // level 2) carrying their count; the nearest level (3) keeps its identity. + assertEquals(listOf(2, 3), edges.map { it.level }) + assertEquals(2, edges.first().folded) + assertEquals(0, edges.last().folded) + assertDp(260.dp, totalWidth(edges)) } @Test - fun firstStripStaysTappableAfterTheGestureInset() { - val startInset = 30.dp - val strips = peekStripsDp(2, PEEK_BUDGET_DP, startInset, PEEK_WIDTH_DP) - // The leftmost strip is widened so the tappable part (after the inset) - // still measures at least the named minimum. - assertTrue(strips.first().width - startInset >= PEEK_WIDTH_DP) - // Even when the fold forces the smallest split, the widening holds. - val folded = peekStripsDp(4, PEEK_BUDGET_DP, 80.dp, PEEK_WIDTH_DP) - assertTrue(folded.first().width - 80.dp >= PEEK_WIDTH_DP) + fun whenThereIsNoRoomTheOlderLevelsFoldIntoTheNearestCount() { + // A region that cannot give the thin older edge and the nearest identity a + // touch target each collapses to a single edge carrying the count: nothing + // is squeezed below the platform minimum touch target. + val edges = coveredEdgesDp(3, 100.dp, minTouch, startInset = 30.dp) + assertEquals(1, edges.size) + assertEquals(2, edges.first().level) + assertEquals(2, edges.first().folded) + assertDp(100.dp, edges.first().width) } @Test - fun budgetShrinksSoTheActivePaneNeverCollapses() { - // A host narrower than the ideal leaves room for: the budget is clamped - // so the active pane keeps at least the named minimum width. - val host = 400.dp - val budget = peekBudgetDp(host) - assertTrue(budget >= 0.dp) - assertTrue(paneWidthDp(host, budget) >= MIN_ACTIVE_PANE_WIDTH_DP) + fun theNearestEdgeKeepsATouchTargetAfterTheGestureInset() { + val startInset = 40.dp + val region = 260.dp + for (covered in 1..5) { + val edges = coveredEdgesDp(covered, region, minTouch, startInset) + val nearest = edges.last() + // The first edge is inset past the left gesture area; any other edge + // is already clear of it. + val inset = if (edges.size == 1) startInset else 0.dp + assertTrue("nearest edge below the touch target: $edges", nearest.width - inset >= minTouch) + } } @Test - fun tinyHostNeverProducesNegativeGeometry() { - assertDp(0.dp, peekBudgetDp(100.dp)) - val empty = peekStripsDp(3, peekBudgetDp(100.dp), 0.dp, PEEK_WIDTH_DP) - assertTrue(empty.isEmpty()) - assertTrue(paneWidthDp(100.dp, 0.dp) >= 0.dp) - // A tiny non-zero budget still yields one usable strip, never negative. - val tiny = peekStripsDp(3, 40.dp, 0.dp, PEEK_WIDTH_DP) - assertEquals(1, tiny.size) - assertTrue(tiny.first().width >= 0.dp) - assertTrue(paneWidthDp(100.dp, totalWidth(tiny)) >= 0.dp) - } - - @Test - fun stripsAreMonotonicAndDeterministic() { - // Same inputs give the same strips (opening and closing are mirrors), - // the strips never overlap, and they never run past the budget. - val a = peekStripsDp(3, PEEK_BUDGET_DP, 30.dp, PEEK_WIDTH_DP) - val b = peekStripsDp(3, PEEK_BUDGET_DP, 30.dp, PEEK_WIDTH_DP) + fun edgesAreMonotonicAndDeterministic() { + // Same inputs give the same edges (opening and closing are mirrors), the + // edges never overlap, and they never run past the region. + val a = coveredEdgesDp(4, 260.dp, minTouch, 30.dp) + val b = coveredEdgesDp(4, 260.dp, minTouch, 30.dp) assertEquals(a, b) a.zipWithNext { x, y -> assertTrue(y.start >= x.start + x.width) } assertTrue(a.all { it.width >= 0.dp }) diff --git a/android/app/src/test/java/net/awan/pipelines/ui/screens/PaneStatsTest.kt b/android/app/src/test/java/net/awan/pipelines/ui/screens/PaneStatsTest.kt new file mode 100644 index 00000000..eec1f029 --- /dev/null +++ b/android/app/src/test/java/net/awan/pipelines/ui/screens/PaneStatsTest.kt @@ -0,0 +1,225 @@ +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 + +/** + * The covered-pane statistics are a pure fold of the run history the app already + * holds, so the counts, the last-run facts and the average duration are asserted + * here without a device: per-pipeline counts, a pipeline with no runs, an unknown + * pipeline id (which yields no lines, never the whole-history list summary), + * zero-duration runs and the whole-history list summary. + */ +class PaneStatsTest { + + private val now = OffsetDateTime.parse("2026-10-16T12:00:00Z") + + private fun run( + id: Long, + pipelineId: Long, + createdAt: String, + finishedAt: String = "", + status: String = "succeeded", + ) = RunSummary( + id = id, + pipelineId = pipelineId, + createdAt = createdAt, + finishedAt = finishedAt, + status = status, + ) + + @Test + fun pipelineStatsCountOnlyThatPipelineByStatus() { + val stats = pipelinePeekStats( + listOf( + run(1, 10, "2026-10-16T09:00:00Z", "2026-10-16T09:01:00Z"), + run(2, 10, "2026-10-16T10:00:00Z", "2026-10-16T10:01:00Z", status = "failed"), + run(3, 10, "2026-10-16T11:00:00Z", status = "running"), + run(4, 11, "2026-10-16T09:30:00Z", "2026-10-16T09:31:00Z"), + ), + pipelineId = 10, + now = now, + ) + assertEquals(3, stats.total) + assertEquals(1, stats.succeeded) + assertEquals(1, stats.failed) + assertEquals(1, stats.active) + } + + @Test + fun queuedRunsCountAsActive() { + val stats = pipelinePeekStats( + listOf(run(1, 10, "2026-10-16T11:00:00Z", status = "queued")), + pipelineId = 10, + now = now, + ) + assertEquals(1, stats.active) + assertEquals(1, stats.total) + } + + @Test + fun lastRunCarriesItsStateAndHowLongAgoItStarted() { + val stats = pipelinePeekStats( + listOf( + run(1, 10, "2026-10-16T09:00:00Z", "2026-10-16T09:01:00Z"), + run(2, 10, "2026-10-16T11:00:00Z", "2026-10-16T11:01:00Z", status = "failed"), + ), + pipelineId = 10, + now = now, + ) + // The newer run wins even though the input order is oldest-first. + assertEquals(RunState.Failed, stats.lastState) + assertEquals("1h ago", stats.lastAgo) + } + + @Test + fun averageDurationIsOverTheRunsThatFinished() { + val stats = pipelinePeekStats( + listOf( + run(1, 10, "2026-10-16T09:00:00Z", "2026-10-16T09:01:00Z"), + run(2, 10, "2026-10-16T10:00:00Z", "2026-10-16T10:02:00Z"), + // A still-running run has no finished_at and must not drag the average. + run(3, 10, "2026-10-16T11:00:00Z", status = "running"), + ), + pipelineId = 10, + now = now, + ) + assertEquals(90L, stats.averageSeconds) + } + + @Test + fun zeroDurationRunsAreRealMeasurementsInTheAverage() { + val stats = pipelinePeekStats( + listOf( + run(1, 10, "2026-10-16T09:00:00Z", "2026-10-16T09:00:00Z"), + run(2, 10, "2026-10-16T10:00:00Z", "2026-10-16T10:01:00Z"), + ), + pipelineId = 10, + now = now, + ) + // 0s and 60s average to 30s: the zero is counted, not skipped. + assertEquals(30L, stats.averageSeconds) + } + + @Test + fun aPipelineWithNoRunsIsAllZerosAndNoLastRun() { + val stats = pipelinePeekStats( + listOf(run(1, 11, "2026-10-16T09:00:00Z", "2026-10-16T09:01:00Z")), + pipelineId = 10, + now = now, + ) + assertEquals(0, stats.total) + assertEquals(0, stats.succeeded) + assertEquals(0, stats.failed) + assertEquals(0, stats.active) + assertNull(stats.lastState) + assertNull(stats.lastAgo) + assertNull(stats.averageSeconds) + } + + @Test + fun unknownPipelineIdIsAllZerosAndNoLastRun() { + val stats = pipelinePeekStats( + listOf(run(1, 10, "2026-10-16T09:00:00Z", "2026-10-16T09:01:00Z")), + pipelineId = 99, + now = now, + ) + assertEquals(0, stats.total) + assertNull(stats.lastState) + assertNull(stats.averageSeconds) + } + + @Test + fun emptyHistoryIsAllZerosAndNoLastRun() { + val stats = pipelinePeekStats(emptyList(), pipelineId = 10, now = now) + assertEquals(0, stats.total) + assertNull(stats.lastState) + assertNull(stats.averageSeconds) + } + + @Test + fun listStatsFoldTheWholeHistoryAndFindTheMostRecentRun() { + val stats = listPeekStats( + listOf( + run(1, 10, "2026-10-16T09:00:00Z", "2026-10-16T09:01:00Z"), + run(2, 11, "2026-10-16T11:30:00Z", status = "running"), + run(3, 11, "2026-10-16T08:00:00Z", status = "failed"), + ), + now = now, + ) + assertEquals(3, stats.total) + assertEquals(1, stats.succeeded) + assertEquals(1, stats.failed) + assertEquals(1, stats.active) + assertEquals(RunState.Running, stats.lastState) + assertEquals("30m ago", stats.lastAgo) + } + + @Test + fun linesKeepALabelWithEveryNumberAndMarkTheDetailLines() { + val lines = pipelinePeekStats( + listOf(run(1, 10, "2026-10-16T11:00:00Z", "2026-10-16T11:01:00Z")), + pipelineId = 10, + now = now, + ).lines() + assertEquals(listOf("runs", "succeeded", "failed", "active", "last", "avg"), lines.map { it.label }) + assertEquals(listOf("1", "1", "0", "0"), lines.take(4).map { it.value }) + assertTrue(lines.take(4).none { it.detail }) + assertTrue(lines.drop(4).all { it.detail }) + } + + @Test + fun aPipelineWithNoRunsShowsCountsButNoLastRunOrAverageLines() { + val lines = pipelinePeekStats(emptyList(), pipelineId = 10, now = now).lines() + assertEquals(listOf("runs", "succeeded", "failed", "active"), lines.map { it.label }) + } + + @Test + fun listLinesCarryNoAverage() { + val lines = listPeekStats(emptyList(), now).lines() + assertEquals(listOf("runs", "succeeded", "failed", "active"), lines.map { it.label }) + } + + @Test + fun anUnknownPipelineYieldsNoLinesInsteadOfTheWholeHistorySummary() { + val history = listOf( + run(1, 10, "2026-10-16T09:00:00Z", "2026-10-16T09:01:00Z"), + run(2, 11, "2026-10-16T09:30:00Z", "2026-10-16T09:31:00Z"), + ) + // A run pane whose pipeline is not known yet (the run has not loaded) must + // not borrow the server-wide list summary; it shows no statistics at all. + assertTrue(pipelineStatLines(history, null, now).isEmpty()) + // Nor before the history has loaded, even for a known pipeline. + assertTrue(pipelineStatLines(null, 10, now).isEmpty()) + } + + @Test + fun pipelineStatLinesFoldOnlyTheNamedPipeline() { + val history = listOf( + run(1, 10, "2026-10-16T09:00:00Z", "2026-10-16T09:01:00Z"), + run(2, 11, "2026-10-16T09:30:00Z", "2026-10-16T09:31:00Z"), + ) + val lines = pipelineStatLines(history, 10, now) + assertEquals(listOf("runs", "succeeded", "failed", "active", "last", "avg"), lines.map { it.label }) + assertEquals("1", lines.first().value) + } + + @Test + fun listStatLinesAreEmptyUntilLoadedThenFoldTheWholeHistory() { + assertTrue(listStatLines(null, now).isEmpty()) + val lines = listStatLines( + listOf( + run(1, 10, "2026-10-16T09:00:00Z", "2026-10-16T09:01:00Z"), + run(2, 11, "2026-10-16T09:30:00Z", status = "running"), + ), + now, + ) + assertEquals(listOf("runs", "succeeded", "failed", "active", "last"), lines.map { it.label }) + assertEquals("2", lines.first().value) + } +} 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 index 0ae593a5..e0a84f6a 100644 --- 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 @@ -18,12 +18,14 @@ class PipelineLastRunTest { createdAt: String, finishedAt: String = createdAt, status: String = "succeeded", + executing: Boolean = false, ) = RunSummary( id = id, pipelineId = pipelineId, createdAt = createdAt, finishedAt = finishedAt, status = status, + executing = executing, ) @Test @@ -96,10 +98,30 @@ class PipelineLastRunTest { } @Test - fun metaLineOmitsAMissingDuration() { - // A running run has no finished_at, so the duration fragment is dropped. + fun metaLineShowsTheLiveElapsedOfARunningRun() { + // A running run has no finished_at, so its time fragment is the elapsed + // from its start to the anchor, recomputed as the shared clock advances. val badge = pipelineRunBadges( - listOf(run(42, 10, "2026-10-16T11:00:00Z", finishedAt = "", status = "running")), + listOf( + run( + 42, + 10, + "2026-10-16T11:57:30Z", + finishedAt = "", + status = "running", + executing = true, + ), + ), + now, + ).getValue(10L) + assertEquals("2m ago · 2m 30s · run 42", badge.metaLine()) + } + + @Test + fun metaLineOmitsAMissingDuration() { + // A finished run with no end timestamp has no duration fragment. + val badge = pipelineRunBadges( + listOf(run(42, 10, "2026-10-16T11:00:00Z", finishedAt = "")), now, ).getValue(10L) assertEquals("1h ago · run 42", badge.metaLine()) diff --git a/android/app/src/test/java/net/awan/pipelines/ui/screens/RunListEntriesTest.kt b/android/app/src/test/java/net/awan/pipelines/ui/screens/RunListEntriesTest.kt new file mode 100644 index 00000000..2a267b64 --- /dev/null +++ b/android/app/src/test/java/net/awan/pipelines/ui/screens/RunListEntriesTest.kt @@ -0,0 +1,90 @@ +package net.awan.pipelines.ui.screens + +import net.awan.pipelines.data.protocol.RunSummary +import net.awan.pipelines.data.protocol.UsageStats +import org.junit.Assert.assertEquals +import org.junit.Test + +/** + * The runs list's slots are built in one pure place, so the count a restored + * scroll position is clamped against is exactly what the LazyColumn draws: the + * usage block, the single empty-or-grouped body and the optional inline error + * row, in that order, with the stable keys the layout has always used. + */ +class RunListEntriesTest { + + private fun run(id: Long) = RunSummary(id = id, name = "p$id") + + @Test + fun usageThenDayGroupsThenRunsInOrder() { + val groups = listOf( + RunDayGroup("Today", listOf(run(2), run(1))), + RunDayGroup("Yesterday", listOf(run(3))), + ) + val entries = runListEntries( + usage = UsageStats(total = 3), + nothingRecorded = false, + nothingMatched = false, + groups = groups, + error = null, + ) + assertEquals( + listOf("usage", "day-Today", "run-2", "run-1", "day-Yesterday", "run-3"), + entries.map { it.key }, + ) + assertEquals(6, entries.size) + } + + @Test + fun nothingRecordedIsOneEmptyLineWithoutAnAction() { + val entries = runListEntries( + usage = UsageStats(total = 0), + nothingRecorded = true, + nothingMatched = false, + groups = emptyList(), + error = null, + ) + assertEquals(listOf("usage", "runs-empty"), entries.map { it.key }) + val empty = entries.last() as RunListEntry.Empty + assertEquals("No runs have been recorded yet.", empty.message) + assertEquals(null, empty.actionLabel) + } + + @Test + fun nothingMatchedIsOneEmptyLineWithTheClearAction() { + val entries = runListEntries( + usage = null, + nothingRecorded = false, + nothingMatched = true, + groups = emptyList(), + error = null, + ) + assertEquals(listOf("runs-filtered-empty"), entries.map { it.key }) + assertEquals("Clear filters", (entries.single() as RunListEntry.Empty).actionLabel) + } + + @Test + fun theInlineErrorRowIsAppendedUnderTheRows() { + val entries = runListEntries( + usage = null, + nothingRecorded = false, + nothingMatched = false, + groups = listOf(RunDayGroup("Today", listOf(run(1)))), + error = "offline", + ) + assertEquals(listOf("day-Today", "run-1", "runs-error"), entries.map { it.key }) + assertEquals("offline", (entries.last() as RunListEntry.Error).message) + } + + @Test + fun aNotYetRecordedHistoryWinsOverAFilteredEmptyOne() { + val entries = runListEntries( + usage = null, + nothingRecorded = true, + nothingMatched = true, + groups = emptyList(), + error = null, + ) + assertEquals(listOf("runs-empty"), entries.map { it.key }) + } +}