Merge branch 'main' into lane-go

This commit is contained in:
2026-10-16 06:35:43 +01:00
7 changed files with 665 additions and 109 deletions
+87
View File
@@ -1673,3 +1673,90 @@ image validated):
http://10.0.0.249:8080/artifacts/86/1/pipelines-debug-wip-5ad4b58.apk` returned
`HTTP/1.1 200 OK`, `Content-Type: application/vnd.android.package-archive`,
`Content-Length: 18029402`.
## Full-screen artifact image viewer (16 Oct 2026)
Tapping an image artifact now opens a full-screen viewer (in the run summary
grid, the per-visit artifacts list and the stage pane, which all render through
`ArtifactGallery`), replacing the former small centred dialog rather than stacking
on it. `android/` only; no dependency was added, no run was started from the app,
and every device command targeted `emulator-5554` (never the attached Pixel, never
`emulator-5556`).
- **Viewer.** New `ui/graph/ArtifactViewer.kt` renders a scrim-backed full-screen
`Dialog` (`usePlatformDefaultWidth = false`, `decorFitsSystemWindows = false`);
a `SideEffect` stretches the dialog window to `MATCH_PARENT`, fits no system
insets and draws into the display cutout (each API-guarded), so the dark backdrop
reaches every edge while the content re-applies `paneSafeArea()` (status bar,
cutout, navigation bar) itself. A top-right row keeps the open-in-new and
copy-link actions and adds a close button, backed by a translucent scrim
capsule so the light icons stay legible over a bright image. `dumpsys window`
confirms the dialog
window frame is `[0,0][2076,2152]` (previously inset to `[0,136][2076,2074]`).
- **Gestures.** Pinch zooms about the centroid and a drag pans via the existing
graph `zoomAbout`; a double-tap toggles between fit and 2.5x; a downward swipe at
fit dismisses; a plain tap does nothing. Zoom is clamped to `[1x, 5x]` of fit and
pan is clamped by the new pure `clampImageOffset` so the scaled image can never
be dragged off screen (each axis centred when smaller than the viewport, pinned
to `[viewport - content, 0]` when larger). Zoom state is remembered on the url,
so closing the viewer or opening another image starts again at fit/centred.
System Back and the close button dismiss the viewer without closing the pane
behind it (verified: 0 `Close viewer` nodes and the run detail still shown after
Back). The image loads through the existing cached, off-main-thread
`rememberArtifactBitmap` (now `internal`, reusing the shared fetch/decode path),
with a "Loading image…" spinner and a distinct "Couldn't load image." state. The
loading/error/unavailable message is drawn in the light `inverseSurface` role,
which contrasts with the always-black scrim (the previous `inverseOnSurface`
was a dark colour on the scrim, measured ~1.6:1).
- **Pure helpers.** `fitImageSize`, `clampImageOffset` and `toggleZoomScale` in
`ArtifactViewer.kt`; `ArtifactViewerTest` covers them (fitting, centre/edge
clamping, the toggle, and an anchored-zoom-then-clamp invariant). `zoomAbout`
and the loading path are the existing shared ones, not copies.
Evidence obtained in this pass (macOS, JDK 17 from Homebrew `openjdk@17`, Gradle
8.11.1 from the wrapper cache, `ANDROID_HOME=/Users/alan/Library/Android/sdk`):
- `gradle :app:testDebugUnitTest :app:assembleDebug --console=plain` →
`BUILD SUCCESSFUL`; the result XMLs aggregate to **149 tests, 0 failures, 0
errors, 0 skipped** (up from 140: the new `ArtifactViewerTest`).
`app/build/outputs/apk/debug/app-debug.apk` is 18,043,579 bytes, sha256
`1b3653dbdce9d62fc8dcfdcb986635829b70db38437d6769c77f91d16b7d6b3a`.
- `gradle :app:lintDebug` → only the two **pre-existing** `windowLightNavigationBar`
NewApi errors (`values/themes.xml`, `values-night/themes.xml`); no new lint
finding is attributed to `ArtifactViewer.kt` (39 warnings, down from 40 once the
cutout constant was API-guarded).
- On `emulator-5554` against the live server, the run 90 summary artifacts grid
was opened and `captures/viewer/` (git-ignored, every PNG validated by
`scripts/capture_png.sh -s emulator-5554`) holds: `01_viewer_open`,
`02_doubletap_zoom`, `03_pinch_zoom`, `04_pan`, `05_clamp_1..3`,
`06_fit_reset`, `07_swipedown_dismissed`, `08_back_dismissed`, `09_loading`,
`10_error`, `contact_sheet.png` and `viewer_gestures.mp4` (29 s). Pairwise
pixel diffs (`captures/imgdiff.py`): open→double-tap 19.72, double-tap→pinch
6.72, pinch→pan 5.29, and `05_clamp_1→2` 0.75 → `05_clamp_2→3` **0.0** (the
image is pinned at its bound and cannot be panned further off screen);
fit-reset diff 0.01 (double-tap restores fit exactly). After a swipe-down and
after Back the UI dump has 0 `Close viewer` nodes and the run detail is shown;
a single tap leaves the viewer open (diff 0.02). `Loading image…` and
`Couldn't load image.` were produced against a hanging and a 404 endpoint.
- `adb shell input` cannot synthesise a two-finger pinch (it injects one pointer)
and the shell cannot write `/dev/input` (`sendevent` is permission-denied on
this production image), so pinch and the timed double-tap were driven with a
test-only `app_process` injector (`captures/viewer/tools/Injector.java` →
`Injector.jar`) that injects multi-pointer `MotionEvent`s via the hidden
`InputManager.injectInputEvent`, the same mechanism the platform `input` command
uses. It is verification tooling only, not part of the app or its dependencies.
- `adb -s emulator-5554 logcat -d` held 0 `FATAL EXCEPTION` / 0 `E AndroidRuntime`
lines.
- **APK publish.** Copied to
`~/.local/share/pipelines/data/artifacts/91/1/pipelines-debug-wip-7b61906.apk`
(`7b61906` = `git rev-parse --short HEAD`). `curl -I
http://10.0.0.249:8080/artifacts/91/1/pipelines-debug-wip-7b61906.apk` returned
`HTTP/1.1 200 OK`, `Content-Type: application/vnd.android.package-archive`,
`Content-Length: 18043579`, and a streamed `GET | shasum -a 256` equalled the
local file's `1b3653db…`. At 17.2 MiB it exceeds the 8 MiB per-file inventory
cap, so it is served by direct URL only.
Not verified in this pass: a real hardware fold (the emulator is the 2076x2152
inner display at 390 dpi); an Android 8/9 device branch (the `layoutInDisplayCutout
Mode = SHORT_EDGES` fallback is compiled and lint-guarded but only the API 36 path
ran).
@@ -63,7 +63,7 @@ private const val MAX_CACHED_BITMAPS = 24
* failure mark (that would blame a load that never happened). [Error] is reserved
* for a fetch or decode that was actually attempted and failed.
*/
private sealed interface ArtifactImageState {
internal sealed interface ArtifactImageState {
data object Loading : ArtifactImageState
data object Unavailable : ArtifactImageState
data object Error : ArtifactImageState
@@ -120,7 +120,7 @@ internal fun ArtifactImage(
}
@Composable
private fun rememberArtifactBitmap(
internal fun rememberArtifactBitmap(
url: String?,
maxDim: Int,
fetchBytes: suspend (String) -> ByteArray?,
@@ -0,0 +1,360 @@
package net.awan.pipelines.ui.graph
import android.graphics.Bitmap
import android.os.Build
import android.view.WindowManager
import androidx.compose.foundation.Image
import androidx.compose.foundation.background
import androidx.compose.foundation.gestures.detectTapGestures
import androidx.compose.foundation.gestures.detectTransformGestures
import androidx.compose.foundation.layout.Arrangement
import androidx.compose.foundation.layout.Box
import androidx.compose.foundation.layout.BoxWithConstraints
import androidx.compose.foundation.layout.Column
import androidx.compose.foundation.layout.Row
import androidx.compose.foundation.layout.fillMaxSize
import androidx.compose.foundation.layout.padding
import androidx.compose.foundation.layout.size
import androidx.compose.foundation.layout.windowInsetsPadding
import androidx.compose.foundation.shape.CircleShape
import androidx.compose.material.icons.Icons
import androidx.compose.material.icons.automirrored.filled.OpenInNew
import androidx.compose.material.icons.filled.Close
import androidx.compose.material.icons.filled.ContentCopy
import androidx.compose.material3.CircularProgressIndicator
import androidx.compose.material3.Icon
import androidx.compose.material3.IconButton
import androidx.compose.material3.MaterialTheme
import androidx.compose.material3.Text
import androidx.compose.runtime.Composable
import androidx.compose.runtime.LaunchedEffect
import androidx.compose.runtime.SideEffect
import androidx.compose.runtime.getValue
import androidx.compose.runtime.mutableFloatStateOf
import androidx.compose.runtime.mutableStateOf
import androidx.compose.runtime.remember
import androidx.compose.runtime.setValue
import androidx.compose.ui.Alignment
import androidx.compose.ui.Modifier
import androidx.compose.ui.draw.clipToBounds
import androidx.compose.ui.geometry.Offset
import androidx.compose.ui.geometry.Size
import androidx.compose.ui.graphics.TransformOrigin
import androidx.compose.ui.graphics.asImageBitmap
import androidx.compose.ui.graphics.graphicsLayer
import androidx.compose.ui.input.pointer.pointerInput
import androidx.compose.ui.layout.ContentScale
import androidx.compose.ui.platform.LocalClipboardManager
import androidx.compose.ui.platform.LocalContext
import androidx.compose.ui.platform.LocalDensity
import androidx.compose.ui.platform.LocalView
import androidx.compose.ui.text.AnnotatedString
import androidx.compose.ui.text.style.TextAlign
import androidx.compose.ui.unit.dp
import androidx.compose.ui.window.Dialog
import androidx.compose.ui.window.DialogProperties
import androidx.compose.ui.window.DialogWindowProvider
import net.awan.pipelines.ui.components.paneSafeArea
import net.awan.pipelines.ui.theme.pipelinesText
import kotlin.math.abs
/**
* The full-screen image viewer opened by tapping a gallery thumbnail (the run
* summary grid, the per-visit artifacts list and the stage pane all render
* through [ArtifactGallery], so they all open this). It replaces the former
* small centred dialog rather than stacking on top of it.
*
* It is a [Dialog] whose window is laid out edge to edge (`decorFitsSystemWindows
* = false`): the dark [MaterialTheme.colorScheme.scrim] backdrop fills the whole
* screen, while the interactive content clears the pane safe area
* ([paneSafeArea]) so nothing sits under the status bar, a cutout or the
* navigation bar. As a dialog it is drawn above every pane of the stack, and the
* platform routes Back to it ([DialogProperties.dismissOnBackPress]) so system
* Back closes the viewer and not the screen behind it.
*
* The image loads through the same cached, off-main-thread path as the inline
* preview ([rememberArtifactBitmap]); while it downloads a spinner is shown and a
* failed fetch/decode shows a distinct error message. The open-in-new and
* copy-link actions are kept from the artifact rows, and a tap on the image is
* deliberately not a dismissal (only the close button, a downward swipe at fit
* scale, or Back close it).
*/
@Composable
internal fun ArtifactViewer(
url: String,
name: String,
fetchBytes: suspend (String) -> ByteArray?,
onDismiss: () -> Unit,
) {
Dialog(
onDismissRequest = onDismiss,
properties = DialogProperties(
usePlatformDefaultWidth = false,
decorFitsSystemWindows = false,
// A tap on the backdrop/image is not a gesture, so it must never
// close the viewer.
dismissOnClickOutside = false,
),
) {
// Stretch the dialog window over the whole display (behind the status
// bar, cutout and navigation bar) so the dark backdrop is truly full
// screen; the content below then applies the safe-area insets itself.
val dialogWindow = (LocalView.current.parent as? DialogWindowProvider)?.window
SideEffect {
dialogWindow?.let { window ->
window.setLayout(
WindowManager.LayoutParams.MATCH_PARENT,
WindowManager.LayoutParams.MATCH_PARENT,
)
val attrs = window.attributes
// Fit no system insets and draw into the display cutout too, so
// the backdrop reaches every edge; the content re-applies the
// safe area itself with windowInsetsPadding. Each field/constant
// is guarded by its own API level (fitInsetsTypes and
// CUTOUT_MODE_ALWAYS are API 30, SHORT_EDGES is API 28).
if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.R) {
attrs.fitInsetsTypes = 0
attrs.layoutInDisplayCutoutMode =
WindowManager.LayoutParams.LAYOUT_IN_DISPLAY_CUTOUT_MODE_ALWAYS
} else if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.P) {
attrs.layoutInDisplayCutoutMode =
WindowManager.LayoutParams.LAYOUT_IN_DISPLAY_CUTOUT_MODE_SHORT_EDGES
}
window.attributes = attrs
}
}
Box(
modifier = Modifier
.fillMaxSize()
.background(MaterialTheme.colorScheme.scrim)
.windowInsetsPadding(paneSafeArea()),
) {
when (val state = rememberArtifactBitmap(url, FULL_RESOLUTION, fetchBytes)) {
is ArtifactImageState.Ready -> ZoomableArtifact(state.bitmap, name, url, onDismiss)
ArtifactImageState.Loading -> ViewerMessage("Loading image…", spinner = true)
ArtifactImageState.Error -> ViewerMessage("Couldn't load image.")
ArtifactImageState.Unavailable -> ViewerMessage("Image unavailable.")
}
ArtifactViewerActions(
name = name,
url = url,
onDismiss = onDismiss,
modifier = Modifier.align(Alignment.TopEnd),
)
}
}
}
/**
* The loaded bitmap, pannable and zoomable. The image is first fitted into the
* measured viewport ([fitImageSize]); [scale] and [offset] are then the live
* gesture transform, drawn with a top-left [TransformOrigin] so
* `displayed = point * scale + offset` and [clampImageOffset] can keep the
* scaled image inside the viewport on every axis — when it is larger than the
* viewport its edges never move inside it, and when it is smaller the axis is
* centred, so the image can never be dragged off screen.
*
* A pinch zooms about the gesture centroid and a drag pans (both through the
* shared [zoomAbout]); a double-tap toggles between fit and [DOUBLE_TAP_SCALE]; a
* downward swipe while at fit dismisses. All zoom state is remembered on [url],
* so closing the viewer or opening another image starts again at fit/centred.
*/
@Composable
private fun ZoomableArtifact(
bitmap: Bitmap,
name: String,
url: String,
onDismiss: () -> Unit,
) {
// Clip the zoom/pan transform to the safe-area viewport: Compose does not clip
// children by default, so a zoomed image would otherwise draw over the status
// bar / cutout the backdrop clears.
BoxWithConstraints(Modifier.fillMaxSize().clipToBounds()) {
val density = LocalDensity.current
val viewport = Size(with(density) { maxWidth.toPx() }, with(density) { maxHeight.toPx() })
val base = remember(viewport, bitmap) {
fitImageSize(viewport, Size(bitmap.width.toFloat(), bitmap.height.toFloat()))
}
var scale by remember(url) { mutableFloatStateOf(FIT_SCALE) }
var offset by remember(url) { mutableStateOf(Offset.Zero) }
var swipeDown by remember(url) { mutableFloatStateOf(0f) }
// Centre the fitted image on first layout and re-clamp it whenever the
// fitted geometry changes; scale changes are handled by the gestures.
LaunchedEffect(url, viewport, base) {
offset = clampImageOffset(offset, scaled(base, scale), viewport)
}
if (base.width > 0f && base.height > 0f) {
val imageModifier = Modifier
.size(with(density) { base.width.toDp() }, with(density) { base.height.toDp() })
.graphicsLayer {
transformOrigin = TransformOrigin(0f, 0f)
scaleX = scale
scaleY = scale
translationX = offset.x
translationY = offset.y
}
.pointerInput(url, viewport, base) {
detectTransformGestures { centroid, pan, zoom, _ ->
val zoomed = zoomAbout(offset, scale, centroid, zoom, MIN_ZOOM, MAX_ZOOM)
scale = zoomed.scale
offset = clampImageOffset(zoomed.offset + pan, scaled(base, scale), viewport)
// Swipe down to dismiss only at fit (a drag while zoomed
// pans); a mostly-horizontal or pinch gesture is ignored.
if (scale <= FIT_SCALE + ZOOM_EPSILON && zoom == 1f &&
pan.y > 0f && pan.y >= abs(pan.x)
) {
swipeDown += pan.y
if (swipeDown >= viewport.height * SWIPE_DISMISS_FRACTION) onDismiss()
} else {
swipeDown = 0f
}
}
}
.pointerInput(url) {
detectTapGestures(
// A plain tap is not a gesture: it never closes.
onTap = { },
onDoubleTap = { position ->
val zoomed = zoomAbout(
offset,
scale,
position,
toggleZoomScale(scale) / scale,
MIN_ZOOM,
MAX_ZOOM,
)
scale = zoomed.scale
offset = clampImageOffset(zoomed.offset, scaled(base, scale), viewport)
},
)
}
Image(
bitmap = bitmap.asImageBitmap(),
contentDescription = name,
contentScale = ContentScale.Fit,
modifier = imageModifier,
)
}
}
}
/**
* The viewer's loading/error/unavailable message, centred on the backdrop. The
* backdrop is the always-black scrim, so the message uses the light
* [androidx.compose.material3.ColorScheme.inverseSurface] rather than
* `inverseOnSurface` (a dark colour on the scrim, previously illegible).
*/
@Composable
private fun ViewerMessage(text: String, spinner: Boolean = false) {
Box(Modifier.fillMaxSize(), contentAlignment = Alignment.Center) {
Column(
modifier = Modifier.padding(24.dp),
horizontalAlignment = Alignment.CenterHorizontally,
verticalArrangement = Arrangement.spacedBy(12.dp),
) {
if (spinner) CircularProgressIndicator()
Text(
text = text,
style = pipelinesText().meta,
color = MaterialTheme.colorScheme.inverseSurface,
textAlign = TextAlign.Center,
)
}
}
}
/** The viewer's kept open-in-new and copy-link actions plus the close affordance. */
@Composable
private fun ArtifactViewerActions(
name: String,
url: String,
onDismiss: () -> Unit,
modifier: Modifier = Modifier,
) {
val context = LocalContext.current
val clipboard = LocalClipboardManager.current
// A translucent scrim capsule behind the row keeps the light action icons
// legible over a bright image; over the black backdrop it is invisible.
Row(
modifier = modifier.background(
color = MaterialTheme.colorScheme.scrim.copy(alpha = ACTION_SCRIM_ALPHA),
shape = CircleShape,
),
horizontalArrangement = Arrangement.spacedBy(4.dp),
) {
IconButton(onClick = { openArtifact(context, url) }) {
Icon(Icons.AutoMirrored.Filled.OpenInNew, contentDescription = "Open $name externally")
}
IconButton(onClick = { clipboard.setText(AnnotatedString(url)) }) {
Icon(Icons.Default.ContentCopy, contentDescription = "Copy link to $name")
}
IconButton(onClick = onDismiss) {
Icon(Icons.Default.Close, contentDescription = "Close viewer")
}
}
}
/** The fitted base size scaled by the current [scale], in pixels. */
private fun scaled(base: Size, scale: Float): Size = Size(base.width * scale, base.height * scale)
/** Full resolution for the explicit viewer (the inline previews downsample). */
private const val FULL_RESOLUTION = 0
/** Fit scale (the image fits the viewport) and the double-tap zoomed level. */
private const val FIT_SCALE = 1f
private const val DOUBLE_TAP_SCALE = 2.5f
/** Zoom limits for the viewer, as multiples of the fitted image. */
private const val MIN_ZOOM = 1f
private const val MAX_ZOOM = 5f
/** Tolerance for deciding the image is back at fit. */
private const val ZOOM_EPSILON = 0.01f
/** Fraction of the viewport height a downward swipe must cross to dismiss. */
private const val SWIPE_DISMISS_FRACTION = 0.22f
/** Opacity of the scrim capsule that backs the top action row over the image. */
private const val ACTION_SCRIM_ALPHA = 0.5f
/**
* The size [image] is drawn at to fit inside [viewport] with its aspect ratio
* preserved, never upscaling past 1:1 (a small image keeps its native size).
* Degenerate (zero/negative) sizes return [Size.Zero] rather than dividing by
* zero, so callers never see NaN. Pure, so the fitting is unit tested.
*/
internal fun fitImageSize(viewport: Size, image: Size): Size {
if (image.width <= 0f || image.height <= 0f || viewport.width <= 0f || viewport.height <= 0f) {
return Size.Zero
}
val scale = minOf(1f, viewport.width / image.width, viewport.height / image.height)
return Size(image.width * scale, image.height * scale)
}
/**
* Bounds a pan [offset] of the scaled [content] inside [viewport]: on an axis
* where the content is larger than the viewport the offset stays in
* `[viewport - content, 0]` (its edges never move inside the viewport, so the
* image cannot be dragged off screen); on an axis where it is smaller the offset
* is the centred value. Degenerate content is returned unchanged. Pure, so the
* clamping is unit tested without a device.
*/
internal fun clampImageOffset(offset: Offset, content: Size, viewport: Size): Offset {
if (content.width <= 0f || content.height <= 0f) return offset
return Offset(
x = clampImageAxis(offset.x, content.width, viewport.width),
y = clampImageAxis(offset.y, content.height, viewport.height),
)
}
private fun clampImageAxis(value: Float, content: Float, viewport: Float): Float =
if (content <= viewport) (viewport - content) / 2f else value.coerceIn(viewport - content, 0f)
/**
* The scale a double-tap toggles to: back to [fit] when already zoomed in,
* otherwise the [zoomed] level. Pure, so the toggle is unit tested.
*/
internal fun toggleZoomScale(current: Float, fit: Float = FIT_SCALE, zoomed: Float = DOUBLE_TAP_SCALE): Float =
if (current > fit + ZOOM_EPSILON) fit else zoomed
@@ -36,7 +36,6 @@ import androidx.compose.ui.text.AnnotatedString
import androidx.compose.ui.text.style.TextOverflow
import androidx.compose.ui.unit.Dp
import androidx.compose.ui.unit.dp
import androidx.compose.ui.window.Dialog
import net.awan.pipelines.data.protocol.RunStep
import net.awan.pipelines.data.protocol.StageArtifact
import net.awan.pipelines.data.transport.ServerUrl
@@ -99,9 +98,10 @@ internal fun ArtifactsSection(
* hardcodes a host. The grid is built from non-lazy chunked [Row]s, so it never
* nests a scrollable inside the Summary [LazyColumn] or the pane's scroll.
*
* The tile side is derived from the measured width (one [BoxWithConstraints]):
* a fixed tile would overflow a narrow phone pane, so each tile is the widest
* that fits the row up to the preferred [ARTIFACT_TILE_DP].
* The grid geometry is derived from the measured width (one [BoxWithConstraints],
* see [artifactGrid]): as many cells as fit at the preferred [ARTIFACT_TILE_DP]
* shape, stretched to fill the row, so a wide window shows several thumbnails per
* row and a narrow one shows fewer, larger ones — never a fixed column count.
*/
@Composable
internal fun ArtifactGallery(
@@ -113,11 +113,10 @@ internal fun ArtifactGallery(
) {
val text = pipelinesText()
BoxWithConstraints(modifier.fillMaxWidth()) {
val tile = artifactTileDp(
val grid = artifactGrid(
availableWidth = maxWidth,
columns = ARTIFACT_GRID_COLUMNS,
spacing = ARTIFACT_TILE_SPACING_DP,
preferred = ARTIFACT_TILE_DP,
spacing = ARTIFACT_TILE_SPACING_DP,
)
Column(Modifier.fillMaxWidth(), verticalArrangement = Arrangement.spacedBy(8.dp)) {
groups.forEach { group ->
@@ -129,17 +128,17 @@ internal fun ArtifactGallery(
}
val images = group.artifacts.filter { isImageContentType(it.contentType) }
val others = group.artifacts.filterNot { isImageContentType(it.contentType) }
images.chunked(ARTIFACT_GRID_COLUMNS).forEach { rowArtifacts ->
images.chunked(grid.columns).forEach { rowArtifacts ->
Row(
modifier = Modifier.fillMaxWidth(),
horizontalArrangement = Arrangement.spacedBy(ARTIFACT_TILE_SPACING_DP),
) {
rowArtifacts.forEach { artifact ->
ArtifactTile(artifact, configuredServerUrl, fetchArtifactBytes, tile)
ArtifactTile(artifact, configuredServerUrl, fetchArtifactBytes, grid.cell)
}
// Keep a partial last row's tiles aligned to the grid.
repeat(ARTIFACT_GRID_COLUMNS - rowArtifacts.size) {
Box(Modifier.size(tile))
repeat(grid.columns - rowArtifacts.size) {
Box(Modifier.size(grid.cell))
}
}
}
@@ -152,15 +151,23 @@ internal fun ArtifactGallery(
}
/**
* The side of one square gallery tile: the widest that fits [columns] tiles and
* their gaps in [availableWidth], capped at the preferred [preferred] so a wide
* window keeps compact thumbnails and a narrow one keeps every tile fully on
* screen. Pure, so the fitting is unit-tested without a device.
* One gallery row's geometry: the number of cells that fit the measured width at
* the preferred tile shape and the side each cell is stretched to. Pure, so the
* fitting is unit-tested without a device.
*/
internal fun artifactTileDp(availableWidth: Dp, columns: Int, spacing: Dp, preferred: Dp): Dp {
if (columns <= 0) return preferred
val fit = (availableWidth - spacing * (columns - 1)) / columns
return fit.coerceIn(0.dp, preferred)
internal data class ArtifactGrid(val columns: Int, val cell: Dp)
/**
* The gallery geometry for [availableWidth]: the most [preferred]-shaped cells
* that fit with their [spacing] gaps, and each cell widened to fill the row
* exactly. A window narrower than one preferred cell falls back to a single,
* narrower cell; a non-positive preferred token never divides by zero. Pure.
*/
internal fun artifactGrid(availableWidth: Dp, preferred: Dp, spacing: Dp): ArtifactGrid {
if (preferred <= 0.dp) return ArtifactGrid(columns = 1, cell = availableWidth.coerceAtLeast(0.dp))
val columns = ((availableWidth + spacing) / (preferred + spacing)).toInt().coerceAtLeast(1)
val cell = ((availableWidth - spacing * (columns - 1)) / columns).coerceAtLeast(0.dp)
return ArtifactGrid(columns = columns, cell = cell)
}
/**
@@ -206,8 +213,11 @@ private fun ArtifactTile(
)
}
// The tap opens the full-screen viewer (one shared instance across the run
// summary grid, the per-visit list and the stage pane, so they never
// disagree); there is no separate smaller preview to stack on top of it.
if (showFull && resolved != null) {
FullSizeArtifactDialog(
ArtifactViewer(
url = resolved,
name = artifact.name,
fetchBytes = fetchArtifactBytes,
@@ -281,45 +291,8 @@ private fun ArtifactRow(
}
}
/** The explicit full-resolution view, opened by tapping an image thumbnail. */
@Composable
private fun FullSizeArtifactDialog(
url: String,
name: String,
fetchBytes: suspend (String) -> ByteArray?,
onDismiss: () -> Unit,
) {
val text = pipelinesText()
Dialog(onDismissRequest = onDismiss) {
Surface(
shape = RoundedCornerShape(16.dp),
color = MaterialTheme.colorScheme.surfaceContainerHighest,
) {
Column(
modifier = Modifier.padding(12.dp),
horizontalAlignment = Alignment.CenterHorizontally,
verticalArrangement = Arrangement.spacedBy(8.dp),
) {
Text(
name.ifBlank { "Artifact" },
style = text.cardTitle,
maxLines = 2,
overflow = TextOverflow.Ellipsis,
)
ArtifactImage(
url = url,
contentDescription = name,
maxDim = 0,
fetchBytes = fetchBytes,
size = FULL_SIZE_PREVIEW_DP.dp,
)
}
}
}
}
/** Opens the resolved artifact url externally, tolerating a missing handler. */
private fun openArtifact(context: Context, url: String?) {
internal fun openArtifact(context: Context, url: String?) {
if (url == null) return
runCatching { context.startActivity(Intent(Intent.ACTION_VIEW, Uri.parse(url))) }
}
@@ -327,14 +300,8 @@ private fun openArtifact(context: Context, url: String?) {
/** Longest edge of a list thumbnail decode. */
private const val THUMBNAIL_MAX_DIM = 160
/** Fixed box for the full-size preview. */
private const val FULL_SIZE_PREVIEW_DP = 320
/** Preferred side of one square gallery thumbnail tile (the named size token). */
private val ARTIFACT_TILE_DP = 96.dp
/** Gap between gallery thumbnails; shared by the row arrangement and the fitting. */
private val ARTIFACT_TILE_SPACING_DP = 8.dp
/** Image thumbnails per gallery row. */
private const val ARTIFACT_GRID_COLUMNS = 3
@@ -301,6 +301,26 @@ private fun RunSummaryTab(
modifier = columnModifier,
contentPadding = PaddingValues(vertical = 16.dp),
) {
// The artifacts gallery leads the summary: the captured screenshots
// are the first thing the operator sees, with the run's own facts
// below it.
item(key = "run-artifacts") {
Column(
modifier = Modifier.fillMaxWidth().padding(horizontal = 16.dp, vertical = 8.dp),
verticalArrangement = Arrangement.spacedBy(8.dp),
) {
Text("Artifacts", style = text.sectionHeader)
if (artifactGroups.isEmpty()) {
Text(artifactsEmptyMessage(run.executing), style = text.meta)
} else {
ArtifactGallery(
groups = artifactGroups,
configuredServerUrl = configuredServerUrl,
fetchArtifactBytes = fetchArtifactBytes,
)
}
}
}
item(key = "run-summary") {
Column(
modifier = Modifier.fillMaxWidth().padding(horizontal = 16.dp),
@@ -336,23 +356,6 @@ private fun RunSummaryTab(
CodeBlock("Diagnostic", run.diagnostic, Modifier.padding(top = 8.dp))
}
}
item(key = "run-artifacts") {
Column(
modifier = Modifier.fillMaxWidth().padding(horizontal = 16.dp, vertical = 8.dp),
verticalArrangement = Arrangement.spacedBy(8.dp),
) {
Text("Artifacts", style = text.sectionHeader)
if (artifactGroups.isEmpty()) {
Text(artifactsEmptyMessage(run.executing), style = text.meta)
} else {
ArtifactGallery(
groups = artifactGroups,
configuredServerUrl = configuredServerUrl,
fetchArtifactBytes = fetchArtifactBytes,
)
}
}
}
}
}
}
@@ -1,5 +1,6 @@
package net.awan.pipelines.ui.graph
import androidx.compose.ui.unit.Dp
import androidx.compose.ui.unit.dp
import net.awan.pipelines.data.protocol.StageArtifact
import org.junit.Assert.assertEquals
@@ -34,43 +35,60 @@ class ArtifactGalleryTest {
}
@Test
fun narrowWidthShrinksTilesSoTheRowNeverOverflows() {
// A depth-2 phone stage pane is ~360dp less two 56dp peeks and the 16dp
// side paddings ≈216dp; three preferred 96dp tiles would overflow, so the
// tile shrinks to the widest that fits.
val tile = artifactTileDp(availableWidth = 216.dp, columns = 3, spacing = spacing, preferred = preferred)
assertEquals((216f - 2 * 8f) / 3f, tile.value, 0.001f)
assertTrue(tile < preferred)
assertTrue(tile.value * 3 + 2 * 8f <= 216f)
fun aNarrowPaneShowsFewerLargerCellsRatherThanAFixedCount() {
// A depth-2 phone stage pane is ~360dp less the peeks and side paddings
// ≈216dp: the grid fits two preferred-shaped cells (not a forced three)
// and stretches each to fill the row.
val grid = artifactGrid(availableWidth = 216.dp, preferred = preferred, spacing = spacing)
assertEquals(2, grid.columns)
assertEquals((216f - 8f) / 2f, grid.cell.value, 0.001f)
assertTrue(grid.cell >= preferred)
assertRowFits(grid, availableWidth = 216.dp)
}
@Test
fun widthThatFitsThreePreferredTilesKeepsThePreferredTile() {
// 328dp fits 3x96 + 2x8 with room to spare, so tiles stay compact and the
// row does not overflow.
val tile = artifactTileDp(availableWidth = 328.dp, columns = 3, spacing = spacing, preferred = preferred)
assertEquals(preferred, tile)
assertTrue(tile.value * 3 + 2 * 8f <= 328f)
fun aWiderWindowFitsMoreColumnsOfThePreferredShape() {
// 328dp fits three preferred 96dp cells plus their gaps, so the grid adds
// a column instead of inflating the cells.
val grid = artifactGrid(availableWidth = 328.dp, preferred = preferred, spacing = spacing)
assertEquals(3, grid.columns)
assertEquals((328f - 2 * 8f) / 3f, grid.cell.value, 0.001f)
assertRowFits(grid, availableWidth = 328.dp)
}
@Test
fun wideWidthKeepsThePreferredCompactTile() {
val tile = artifactTileDp(availableWidth = 1200.dp, columns = 3, spacing = spacing, preferred = preferred)
assertEquals(preferred, tile)
fun aVeryWideWindowKeepsCellsNearThePreferredShape() {
// The cell never grows far past the preferred token; the width becomes
// more columns instead.
val grid = artifactGrid(availableWidth = 1200.dp, preferred = preferred, spacing = spacing)
assertTrue(grid.columns > 3)
assertTrue(grid.cell.value in preferred.value..(preferred.value + spacing.value))
assertRowFits(grid, availableWidth = 1200.dp)
}
@Test
fun exactFitKeepsThePreferredTile() {
val available = preferred * 3 + spacing * 2
val tile = artifactTileDp(availableWidth = available, columns = 3, spacing = spacing, preferred = preferred)
assertEquals(preferred, tile)
fun aHostNarrowerThanOnePreferredCellFallsBackToASingleCell() {
val grid = artifactGrid(availableWidth = 60.dp, preferred = preferred, spacing = spacing)
assertEquals(1, grid.columns)
assertEquals(60.dp, grid.cell)
assertRowFits(grid, availableWidth = 60.dp)
}
@Test
fun degenerateInputsReturnValidTiles() {
// A zero/negative column count or a host narrower than the gaps never
// yields a negative tile.
assertEquals(preferred, artifactTileDp(availableWidth = 300.dp, columns = 0, spacing = spacing, preferred = preferred))
assertEquals(0.dp, artifactTileDp(availableWidth = 4.dp, columns = 3, spacing = spacing, preferred = preferred))
fun degenerateInputsReturnAValidGrid() {
// A tiny or zero host, or a non-positive preferred token, never yields a
// zero/negative column count or a negative cell.
assertEquals(1, artifactGrid(availableWidth = 4.dp, preferred = preferred, spacing = spacing).columns)
assertEquals(4.dp, artifactGrid(availableWidth = 4.dp, preferred = preferred, spacing = spacing).cell)
assertEquals(0.dp, artifactGrid(availableWidth = 0.dp, preferred = preferred, spacing = spacing).cell)
val noPreferred = artifactGrid(availableWidth = 300.dp, preferred = 0.dp, spacing = spacing)
assertEquals(1, noPreferred.columns)
assertEquals(300.dp, noPreferred.cell)
}
/** The one invariant every grid must hold: the row never overflows the host. */
private fun assertRowFits(grid: ArtifactGrid, availableWidth: Dp) {
val used = grid.columns * grid.cell.value + (grid.columns - 1) * spacing.value
assertTrue("row $used wider than $availableWidth", used <= availableWidth.value + 0.001f)
}
}
@@ -0,0 +1,121 @@
package net.awan.pipelines.ui.graph
import androidx.compose.ui.geometry.Offset
import androidx.compose.ui.geometry.Size
import androidx.compose.ui.graphics.Color
import net.awan.pipelines.ui.theme.PipelinesDarkColors
import org.junit.Assert.assertEquals
import org.junit.Assert.assertTrue
import org.junit.Test
class ArtifactViewerTest {
@Test
fun fitImageSizePreservesAspectAndFitsInsideTheViewport() {
// A wide image in a tall viewport is limited by width; the height follows
// the aspect ratio, so the whole image fits without distortion.
val fitted = fitImageSize(viewport = Size(400f, 800f), image = Size(2000f, 1000f))
assertEquals(400f, fitted.width, 0.001f)
assertEquals(200f, fitted.height, 0.001f)
assertTrue(fitted.width <= 400f && fitted.height <= 800f)
}
@Test
fun fitImageSizeUsesTheTighterAxis() {
val fitted = fitImageSize(viewport = Size(1000f, 600f), image = Size(500f, 1000f))
assertEquals(300f, fitted.width, 0.001f)
assertEquals(600f, fitted.height, 0.001f)
}
@Test
fun fitImageSizeNeverUpscalesAnImageSmallerThanTheViewport() {
val fitted = fitImageSize(viewport = Size(1000f, 800f), image = Size(200f, 100f))
assertEquals(200f, fitted.width, 0.001f)
assertEquals(100f, fitted.height, 0.001f)
}
@Test
fun fitImageSizeIsZeroForDegenerateInputs() {
assertEquals(Size.Zero, fitImageSize(Size(0f, 100f), Size(50f, 50f)))
assertEquals(Size.Zero, fitImageSize(Size(100f, 100f), Size(0f, 50f)))
}
@Test
fun clampImageOffsetCentresAnAxisSmallerThanTheViewport() {
// The content is wider but shorter than the viewport: the overflowing x is
// clamped to the viewport edge, the short y is centred.
val clamped = clampImageOffset(
offset = Offset(x = 9999f, y = 9999f),
content = Size(1000f, 500f),
viewport = Size(400f, 800f),
)
assertEquals(0f, clamped.x, 0.001f)
assertEquals(150f, clamped.y, 0.001f)
}
@Test
fun clampImageOffsetNeverLetsTheScaledImageLeaveTheViewport() {
val content = Size(1000f, 500f)
val viewport = Size(400f, 800f)
// Dragging far in either direction stays within [viewport - content, 0] on
// the overflowing axis: the image edge can never move inside the viewport.
assertEquals(-600f, clampImageOffset(Offset(-9999f, 0f), content, viewport).x, 0.001f)
assertEquals(0f, clampImageOffset(Offset(9999f, 0f), content, viewport).x, 0.001f)
}
@Test
fun clampImageOffsetReturnsDegenerateContentUnchanged() {
val offset = Offset(12f, -34f)
assertEquals(offset, clampImageOffset(offset, Size(0f, 100f), Size(400f, 800f)))
assertEquals(offset, clampImageOffset(offset, Size(100f, 0f), Size(400f, 800f)))
}
@Test
fun toggleZoomScaleTogglesBetweenFitAndTheZoomedLevel() {
// At fit, a double-tap zooms to the declared level; zoomed in, it returns
// to fit.
val zoomed = toggleZoomScale(current = 1f)
assertTrue(zoomed > 1f)
assertEquals(1f, toggleZoomScale(current = zoomed), 0.0001f)
// A value within the fit tolerance still counts as fit, so it zooms.
assertEquals(zoomed, toggleZoomScale(current = 1.0001f), 0.0001f)
}
/**
* A zoom anchored off-centre followed by the clamp still cannot push the
* scaled image past a viewport edge: the invariant the pan clamp exists for.
*/
@Test
fun anAnchoredZoomThenClampStaysWithinTheImageViewport() {
val base = Size(300f, 200f)
val viewport = Size(300f, 600f)
val zoomed = zoomAbout(
offset = Offset(0f, 200f),
scale = 1f,
centroid = Offset(280f, 20f),
zoom = 2.5f,
1f,
5f,
)
val content = Size(base.width * zoomed.scale, base.height * zoomed.scale)
val clamped = clampImageOffset(zoomed.offset, content, viewport)
// Wider than the viewport: the image still covers it horizontally (no gap
// at either edge). Shorter than the viewport: the axis is centred.
assertTrue(content.width > viewport.width)
assertTrue(clamped.x <= 0f && clamped.x + content.width >= viewport.width)
assertEquals((viewport.height - content.height) / 2f, clamped.y, 0.001f)
}
/**
* [ViewerMessage] draws on the always-black scrim, so its foreground must be
* the light `inverseSurface` role (the previous `inverseOnSurface` was a dark
* colour on the scrim and measured 1.60:1). This guards that pairing against
* the shipped dark scheme.
*/
@Test
fun theViewerMessageContrastsWithTheScrimItIsDrawnOn() {
val scheme = PipelinesDarkColors
assertEquals(Color(0xFF000000), scheme.scrim)
assertTrue(contrastRatio(scheme.inverseSurface, scheme.scrim) >= 4.5)
}
}