Merge lane-c: keep the lane's reviewed work

Combine the two reviewed versions of the Android artifact gallery/viewer.

- ArtifactViewer.kt: keep lane-c's gallery-wide paged full-screen viewer
  (artifacts/index/configuredServerUrl/onIndexChange overload with paging
  gestures, header, page buttons, share action and video-frame support) and
  re-add HEAD's single-artifact overload (url/name/fetchBytes/onDismiss/video)
  as a thin wrapper so StageVerdict still compiles and works.
- Artifacts.kt: keep lane-c's gallery-owned single viewer + onOpen callback and
  compose HEAD's all-artifacts-as-tiles grid (media tiles open the paged viewer,
  non-media open externally, selection and per-item share/copy preserved).

Checked: no conflict markers remain in any affected path. android/README.md
already carries the new "Page between artifacts in the full-screen viewer
(17 Oct 2026)" section documenting this change; the packaged templates, the
top-level README and topic docs, and the packaged authoring skill references
are not made stale by this Android-client UI change, so nothing further needs
updating.
This commit is contained in:
2026-10-17 02:35:42 +01:00
4 changed files with 731 additions and 121 deletions
+47
View File
@@ -1907,6 +1907,53 @@ inner display at 390 dpi); an Android 8/9 device branch (the `layoutInDisplayCut
Mode = SHORT_EDGES` fallback is compiled and lint-guarded but only the API 36 path
ran).
## Page between artifacts in the full-screen viewer (17 Oct 2026)
The full-screen viewer is now a pager: a horizontal drag or flick moves to the
previous/next image artifact in gallery order, and the header shows the open
artifact's position ("2 of 5", reloading that artifact's own name, content type,
image and actions). `ArtifactGallery` owns the one viewer instance over
`pagedArtifacts(groups)` (group by group, each group's images in recorded order —
the order the grid draws), and each tile resolves its viewer index through the new
`viewerIndexByUrl` from that same list, so the grid and the viewer cannot disagree
about which artifact a tap opens (previously a second, untested running counter).
- **Gesture.** The paging/dismiss drag sits on a single full-screen surface in
`ArtifactViewerBody`, not on the image, so a drag that starts on the letterbox
around a fitted image pages too. The rule is "page only at fit": a pinch, or any
drag once the image is zoomed (`canPageAtScale`), pans via the shared
`zoomAbout`/`clampImageOffset` exactly as before. At the first/last artifact the
drag is damped (`PAGE_RESISTANCE`) and never wraps; a one-artifact gallery is
inert; a downward drag at fit still dismisses. The previous/next `IconButton`s
(disabled at each end) keep both neighbours reachable without a swipe, and a
loading/error/unavailable artifact shows its own state while its neighbours stay
reachable. The header, actions and page buttons share one `viewerCapsule()`
scrim background.
- **Pure helpers.** `pagedArtifacts`, `viewerIndexByUrl`, `pagedIndex` (the one
clamp shared by the gesture and the buttons) and `canPageAtScale` in
`ArtifactViewer.kt`.
- **Checks.** `gradle :app:testDebugUnitTest :app:assembleDebug --no-daemon` →
`BUILD SUCCESSFUL`; **317 tests, 0 failures, 0 errors, 0 skipped**. The paging
tests are in `ArtifactViewerTest` (`pagedIndex` next/previous, clamping at both
ends, a single-item and an empty list; `aZoomedViewerDoesNotPage`;
`pagedArtifactsAreTheGalleryImagesInGridOrder`; and
`theGridTileViewerIndicesMatchTheViewerOrder`, which walks the grid's draw order
and asserts every tile resolves to its viewer position). `gradle
:app:lintDebug` → only the two pre-existing `windowLightNavigationBar` NewApi
errors (`values/themes.xml`, `values-night/themes.xml`); 0 findings attributed to
`ArtifactViewer.kt` or `Artifacts.kt`.
- **APK publish.** `~/.local/share/pipelines/data/artifacts/224/3/pipelines-debug-wip-18db2f9.apk`
(`18db2f9` = `git rev-parse --short HEAD`), 18,093,313 bytes, md5
`540168beaf3c7f5b7f19eaecd2c3099a`; `curl -I
http://10.0.0.75:8080/artifacts/224/3/pipelines-debug-wip-18db2f9.apk` returned
`HTTP/1.1 200 OK`, `Content-Type: application/vnd.android.package-archive`,
`Content-Length: 18093313`. Built with Gradle 8.11.1, AGP 8.7.2, JDK 17.0.10
(Android Studio JBR), `compileSdk 35`/`build-tools 35.0.0`, minSdk 26.
Not verified in this pass: the on-device swipe/zoom/back-gesture behaviour and the
narrow/wide covered-pane strip (the device is visual review's); this pass verified
only the build and the unit tests.
## Share every artifact, from the grid cells and the per-visit rows (16 Oct 2026)
Every artifact item now carries a real share action: each image cell in a gallery
@@ -1,10 +1,11 @@
package net.awan.pipelines.ui.graph
import android.graphics.Bitmap
import android.os.Build
import android.view.WindowManager
import androidx.compose.animation.core.animate
import androidx.compose.foundation.Image
import androidx.compose.foundation.background
import androidx.compose.foundation.gestures.awaitFirstDown
import androidx.compose.foundation.gestures.detectTapGestures
import androidx.compose.foundation.gestures.detectTransformGestures
import androidx.compose.foundation.layout.Arrangement
@@ -13,14 +14,18 @@ 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.fillMaxWidth
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.ArrowBack
import androidx.compose.material.icons.automirrored.filled.ArrowForward
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.material.icons.filled.Share
import androidx.compose.material3.CircularProgressIndicator
import androidx.compose.material3.Icon
import androidx.compose.material3.IconButton
@@ -33,6 +38,8 @@ import androidx.compose.runtime.getValue
import androidx.compose.runtime.mutableFloatStateOf
import androidx.compose.runtime.mutableStateOf
import androidx.compose.runtime.remember
import androidx.compose.runtime.rememberCoroutineScope
import androidx.compose.runtime.rememberUpdatedState
import androidx.compose.runtime.setValue
import androidx.compose.ui.Alignment
import androidx.compose.ui.Modifier
@@ -49,39 +56,36 @@ import androidx.compose.ui.platform.LocalContext
import androidx.compose.ui.platform.LocalDensity
import androidx.compose.ui.platform.LocalView
import androidx.compose.ui.text.style.TextAlign
import androidx.compose.ui.text.style.TextOverflow
import androidx.compose.ui.window.Dialog
import androidx.compose.ui.window.DialogProperties
import androidx.compose.ui.window.DialogWindowProvider
import kotlin.math.abs
import kotlinx.coroutines.CoroutineScope
import kotlinx.coroutines.Job
import kotlinx.coroutines.launch
import net.awan.pipelines.data.protocol.StageArtifact
import net.awan.pipelines.ui.ArtifactGroup
import net.awan.pipelines.ui.components.MotionQuick
import net.awan.pipelines.ui.components.copyText
import net.awan.pipelines.ui.components.paneSafeArea
import net.awan.pipelines.ui.components.spec
import net.awan.pipelines.ui.theme.SPACING_M
import net.awan.pipelines.ui.theme.SPACING_S
import net.awan.pipelines.ui.theme.SPACING_XL
import net.awan.pipelines.ui.theme.SPACING_XS
import net.awan.pipelines.ui.theme.SPACING_XXS
import net.awan.pipelines.ui.theme.pipelinesText
import kotlin.math.abs
/**
* The full-screen media viewer opened by tapping a gallery tile (the run summary
* grid, the per-visit artifacts section and the stage pane all render through
* [ArtifactGallery], so they all open this): an image at full size, or a video's
* poster frame (the platform retriever extracts it, [video] = true) with the
* external-open action to actually play it. It replaces the former small centred
* dialog rather than stacking on top of it.
* poster frame with the external-open action to actually play it. 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).
* A single-artifact shortcut ([url], [name], [video]) is kept for callers such as
* [net.awan.pipelines.ui.graph.StageVerdict] that already resolve one url.
*/
@Composable
internal fun ArtifactViewer(
@@ -91,6 +95,68 @@ internal fun ArtifactViewer(
onDismiss: () -> Unit,
video: Boolean = false,
) {
val artifact = remember(url) {
StageArtifact(
name = name,
contentType = if (video) "video/*" else "image/*",
url = url,
sizeBytes = 0,
)
}
val artifacts = remember(url) { listOf(artifact) }
ArtifactViewer(
artifacts = artifacts,
index = 0,
configuredServerUrl = "",
fetchBytes = fetchBytes,
onIndexChange = {},
onDismiss = onDismiss,
)
}
/**
* The full-screen artifact 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.
*
* It shows one [artifacts] entry at a time and pages horizontally through the
* neighbours in gallery order ([artifacts] is that order): a swipe left/right at
* fit moves to the next/previous artifact, and the position ("2 of 5"), name and
* content type of the open artifact are always shown. A horizontal drag is only
* a page while the image is at fit — a zoomed image still pans — because the
* viewer is zoomable and pannable; at the first/last artifact the drag is damped
* and never wraps. A one-artifact gallery is inert (no page, no resistance). The
* previous/next [IconButton]s keep both neighbours reachable without a swipe.
*
* Images load at full resolution through [rememberArtifactBitmap]; videos load
* their first sync frame through [rememberArtifactVideoFrame]. While the content
* loads a spinner is shown and a failed fetch/decode shows a distinct error
* message, and paging keeps working so a broken artifact never strands the
* viewer. The open-in-new, copy-link and share actions are kept from the
* artifact rows, a tap on the image is deliberately not a dismissal (only the
* close button, a downward swipe at fit, or Back close it), and each artifact
* reloads its own content, name and actions rather than reusing the previous
* one's.
*/
@Composable
internal fun ArtifactViewer(
artifacts: List<StageArtifact>,
index: Int,
configuredServerUrl: String,
fetchBytes: suspend (String) -> ByteArray?,
onIndexChange: (Int) -> Unit,
onDismiss: () -> Unit,
) {
val count = artifacts.size
Dialog(
onDismissRequest = onDismiss,
properties = DialogProperties(
@@ -134,101 +200,119 @@ internal fun ArtifactViewer(
.background(MaterialTheme.colorScheme.scrim)
.windowInsetsPadding(paneSafeArea()),
) {
val state = if (video) {
rememberArtifactVideoFrame(url, FULL_RESOLUTION, fetchBytes)
} else {
rememberArtifactBitmap(url, FULL_RESOLUTION, fetchBytes)
}
when (state) {
is ArtifactImageState.Ready -> ZoomableArtifact(state.bitmap, name, url, onDismiss)
ArtifactImageState.Loading -> ViewerMessage(
if (video) "Loading video frame…" else "Loading image…",
spinner = true,
)
ArtifactImageState.Error -> ViewerMessage(
if (video) "Couldn't load the video frame." else "Couldn't load image.",
)
ArtifactImageState.Unavailable -> ViewerMessage(
if (video) "Video unavailable." else "Image unavailable.",
)
}
ArtifactViewerActions(
name = name,
url = url,
val artifact = artifacts.getOrNull(index) ?: return@Box
ArtifactViewerBody(
artifact = artifact,
resolvedUrl = resolvedArtifactUrl(artifact, configuredServerUrl),
index = index,
count = count,
fetchBytes = fetchBytes,
// Clamp through the one paging rule, so a page attempt at an end
// resolves to the same index and the viewer never leaves range.
onPage = { delta -> onIndexChange(pagedIndex(index, delta, count)) },
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.
* One open artifact: the zoomable image or video poster frame (or its
* loading/error panel) plus the fixed position header and the action/page
* affordances. The paging/dismiss gesture and its animation live on the
* full-screen surface here, above the per-artifact content, so the swipe offset
* survives the artifact swap and the page slides rather than jumping — and so a
* drag that starts anywhere in the viewer, including the letterbox around a
* fitted image, reaches the page rule.
*
* 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.
* This one full-screen surface owns both gestures: a horizontal drag at fit pages
* (a downward drag at fit dismisses), while a pinch or a drag at any zoomed scale
* is the pan/zoom transform instead — the pan clamp leaves a fitted image
* centred, so the same drag is free to page. The image itself is drawn at its
* fitted size and transformed inside this surface; it carries no gesture of its
* own, so the loading/error/unavailable panel and the image share exactly one
* paging implementation.
*/
@Composable
private fun ZoomableArtifact(
bitmap: Bitmap,
name: String,
url: String,
private fun ArtifactViewerBody(
artifact: StageArtifact,
resolvedUrl: String?,
index: Int,
count: Int,
fetchBytes: suspend (String) -> ByteArray?,
onPage: (Int) -> Unit,
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.
val kind = remember(artifact.contentType, artifact.name) {
artifactKind(artifact.contentType, artifact.name)
}
val isVideo = kind == ArtifactKind.Video
val imageState = if (isVideo) {
rememberArtifactVideoFrame(resolvedUrl, FULL_RESOLUTION, fetchBytes)
} else {
rememberArtifactBitmap(resolvedUrl, FULL_RESOLUTION, fetchBytes)
}
// The two neighbours are derived through the same clamp the page commit
// uses, so an affordance and the gesture can never disagree about an end.
val hasPrevious = pagedIndex(index, -1, count) != index
val hasNext = pagedIndex(index, 1, count) != index
// Keying the zoom state on the open url means paging (a new url) starts the
// neighbour at fit/centred instead of inheriting the previous one's transform.
val url = resolvedUrl ?: artifact.url
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()))
val paging = rememberArtifactPaging(
viewport = { viewport },
pagingEnabled = { count > 1 },
hasPrevious = { hasPrevious },
hasNext = { hasNext },
onPage = onPage,
onDismiss = onDismiss,
)
// The fitted image size (zero until a bitmap is ready), kept on the bitmap
// so a decode does not re-fit on every recomposition.
val ready = imageState as? ArtifactImageState.Ready
val base = remember(viewport, ready?.bitmap) {
ready?.let { fitImageSize(viewport, Size(it.bitmap.width.toFloat(), it.bitmap.height.toFloat())) }
?: Size.Zero
}
// The fitted image's centred offset, so a freshly-opened (or freshly
// paged-to) artifact is drawn already centred rather than flashing at the
// origin for a frame before the effect below re-centres it.
val centredOffset = remember(url, viewport, base) {
clampImageOffset(Offset.Zero, scaled(base, FIT_SCALE), viewport)
}
var scale by remember(url) { mutableFloatStateOf(FIT_SCALE) }
var offset by remember(url) { mutableStateOf(Offset.Zero) }
var swipeDown by remember(url) { mutableFloatStateOf(0f) }
var offset by remember(url) { mutableStateOf(centredOffset) }
// 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
}
// The full-screen gesture surface. Its graphicsLayer carries the page
// offset, so the whole content (image and its letterbox) slides as one.
Box(
modifier = Modifier
.fillMaxSize()
.graphicsLayer { translationX = paging.offsetPx }
.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()
// Page/dismiss only at fit (a pinch has zoom != 1); while
// zoomed the pan below is the gesture instead.
if (canPageAtScale(scale) && zoom == 1f) {
paging.onPan(pan.x, pan.y, atFit = true)
} else {
swipeDown = 0f
val zoomed = zoomAbout(offset, scale, centroid, zoom, MIN_ZOOM, MAX_ZOOM)
scale = zoomed.scale
offset = clampImageOffset(zoomed.offset + pan, scaled(base, scale), viewport)
}
}
}
.settlePageDrag(paging)
.pointerInput(url) {
detectTapGestures(
// A plain tap is not a gesture: it never closes.
@@ -246,14 +330,103 @@ private fun ZoomableArtifact(
offset = clampImageOffset(zoomed.offset, scaled(base, scale), viewport)
},
)
}
Image(
bitmap = bitmap.asImageBitmap(),
contentDescription = name,
contentScale = ContentScale.Fit,
modifier = imageModifier,
},
) {
when (imageState) {
is ArtifactImageState.Ready ->
if (base.width > 0f && base.height > 0f) {
Image(
bitmap = imageState.bitmap.asImageBitmap(),
contentDescription = artifact.name,
contentScale = ContentScale.Fit,
modifier = 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
},
)
}
ArtifactImageState.Loading -> ViewerMessage(
if (isVideo) "Loading video frame…" else "Loading image…",
spinner = true,
)
ArtifactImageState.Error -> ViewerMessage(
if (isVideo) "Couldn't load the video frame." else "Couldn't load image.",
)
ArtifactImageState.Unavailable -> ViewerMessage(
if (isVideo) "Video unavailable." else "Image unavailable.",
)
}
}
// Name/position on the left and the actions on the right, in one bounded
// row so a long artifact name ellipsizes instead of running under the
// actions.
Row(
modifier = Modifier.align(Alignment.TopStart).fillMaxWidth().padding(SPACING_S),
horizontalArrangement = Arrangement.spacedBy(SPACING_S),
verticalAlignment = Alignment.Top,
) {
ArtifactViewerHeader(
artifact = artifact,
index = index,
count = count,
modifier = Modifier.weight(1f),
)
ArtifactViewerActions(
artifact = artifact,
resolvedUrl = resolvedUrl,
fetchBytes = fetchBytes,
onDismiss = onDismiss,
)
}
// A one-artifact gallery pages nowhere, so it shows no page affordances.
if (count > 1) {
ArtifactViewerPageButtons(
hasPrevious = hasPrevious,
hasNext = hasNext,
onPrevious = { paging.page(-1) },
onNext = { paging.page(1) },
modifier = Modifier.align(Alignment.BottomCenter).padding(SPACING_M),
)
}
}
}
/**
* The open artifact's name and position ("2 of 5") over the image, in the light
* [androidx.compose.material3.ColorScheme.inverseSurface] used by [ViewerMessage]
* (the backdrop is the always-dark scrim), on the same translucent capsule as the
* actions so it reads over a bright image.
*/
@Composable
private fun ArtifactViewerHeader(
artifact: StageArtifact,
index: Int,
count: Int,
modifier: Modifier = Modifier,
) {
val text = pipelinesText()
Column(
modifier = modifier.viewerCapsule().padding(horizontal = SPACING_M, vertical = SPACING_XS),
verticalArrangement = Arrangement.spacedBy(SPACING_XXS),
) {
Text(
artifact.name.ifBlank { "(unnamed artifact)" },
style = text.label,
color = MaterialTheme.colorScheme.inverseSurface,
maxLines = 1,
overflow = TextOverflow.Ellipsis,
)
Text(
artifactViewerPositionLabel(index, count, artifact.contentType),
style = text.meta,
color = MaterialTheme.colorScheme.inverseSurface,
)
}
}
@@ -282,37 +455,233 @@ private fun ViewerMessage(text: String, spinner: Boolean = false) {
}
}
/** The viewer's kept open-in-new and copy-link actions plus the close affordance. */
/**
* The open artifact's open-in-new, copy-link and share actions plus the close
* affordance. Each acts on the *open* artifact ([resolvedUrl]), so paging
* reloads the actions with the artifact rather than reusing the previous one's.
* A translucent scrim capsule behind the row keeps the light action icons legible
* over a bright image; over the black backdrop it is invisible.
*/
@Composable
private fun ArtifactViewerActions(
name: String,
url: String,
artifact: StageArtifact,
resolvedUrl: String?,
fetchBytes: suspend (String) -> ByteArray?,
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.
val scope = rememberCoroutineScope()
val name = artifact.name
Row(
modifier = modifier.background(
color = MaterialTheme.colorScheme.scrim.copy(alpha = ARTIFACT_ACTION_SCRIM_ALPHA),
shape = CircleShape,
),
modifier = modifier.viewerCapsule(),
horizontalArrangement = Arrangement.spacedBy(SPACING_XS),
) {
IconButton(onClick = { openArtifact(context, url) }) {
IconButton(onClick = { openArtifact(context, resolvedUrl) }, enabled = resolvedUrl != null) {
Icon(Icons.AutoMirrored.Filled.OpenInNew, contentDescription = "Open $name externally")
}
IconButton(onClick = { clipboard.copyText(url) }) {
IconButton(
onClick = { resolvedUrl?.let { clipboard.copyText(it) } },
enabled = resolvedUrl != null,
) {
Icon(Icons.Default.ContentCopy, contentDescription = "Copy link to $name")
}
IconButton(
onClick = {
resolvedUrl?.let { url ->
scope.launch { shareArtifact(context, url, name, artifact.contentType, fetchBytes) }
}
},
enabled = resolvedUrl != null,
) {
Icon(Icons.Default.Share, contentDescription = "Share ${name.ifBlank { "artifact" }}")
}
IconButton(onClick = onDismiss) {
Icon(Icons.Default.Close, contentDescription = "Close viewer")
}
}
}
/**
* The focusable previous/next affordances, so a person who cannot swipe can still
* reach both neighbours. Each is a 48dp [IconButton] disabled exactly when that
* neighbour does not exist (the first/last artifact).
*/
@Composable
private fun ArtifactViewerPageButtons(
hasPrevious: Boolean,
hasNext: Boolean,
onPrevious: () -> Unit,
onNext: () -> Unit,
modifier: Modifier = Modifier,
) {
Row(
modifier = modifier.viewerCapsule(),
horizontalArrangement = Arrangement.spacedBy(SPACING_XS),
) {
IconButton(onClick = onPrevious, enabled = hasPrevious) {
Icon(Icons.AutoMirrored.Filled.ArrowBack, contentDescription = "Previous artifact")
}
IconButton(onClick = onNext, enabled = hasNext) {
Icon(Icons.AutoMirrored.Filled.ArrowForward, contentDescription = "Next artifact")
}
}
}
/**
* The translucent scrim capsule behind the viewer's floating controls (the
* header, the action row and the page buttons): it keeps the light icons and
* text legible over a bright image and is invisible over the black backdrop.
*/
@Composable
private fun Modifier.viewerCapsule(): Modifier = background(
color = MaterialTheme.colorScheme.scrim.copy(alpha = ARTIFACT_ACTION_SCRIM_ALPHA),
shape = CircleShape,
)
/**
* The full-screen viewer's horizontal paging state, fed by the one full-screen
* gesture surface the viewer shows, so the page rule lives in exactly one place.
*
* A horizontal drag at fit follows the finger ([offsetPx]); at an end — or for a
* one-artifact gallery — it is damped ([PAGE_RESISTANCE]) and never wraps, and the
* drag springs back to rest when the pointers lift ([settle]). A predominantly
* downward drag at fit still dismisses, exactly as the single-artifact viewer
* did. Once the drag crosses [PAGE_SWIPE_FRACTION] of the viewport width it
* commits one page: the open content slides out, the index changes, and the
* neighbour slides in; while that runs further drags are ignored so an animation
* can never fight itself. All state is plain (only [offsetPx] is observable), so
* a drag schedules no recomposition beyond the translation it actually changes.
*/
private class ArtifactPaging(
private val viewport: () -> Size,
private val pagingEnabled: () -> Boolean,
private val hasPrevious: () -> Boolean,
private val hasNext: () -> Boolean,
private val onPage: (Int) -> Unit,
private val onDismiss: () -> Unit,
private val scope: CoroutineScope,
) {
/** The live page translation in pixels; positive drags the content right. */
var offsetPx by mutableFloatStateOf(0f)
private set
private var paging = false
private var swipeDown = 0f
private var settleJob: Job? = null
/** Feeds one pan event; [atFit] is false while zoomed or pinching. */
fun onPan(panX: Float, panY: Float, atFit: Boolean) {
if (!atFit || paging) {
swipeDown = 0f
return
}
if (abs(panX) > abs(panY)) {
swipeDown = 0f
if (!pagingEnabled()) return
// A leftward drag (negative x) advances to the next artifact.
val direction = if (panX < 0f) 1 else -1
val available = if (direction > 0) hasNext() else hasPrevious()
val proposed = offsetPx + panX
settleJob?.cancel()
offsetPx = if (available) proposed else proposed * PAGE_RESISTANCE
if (available && abs(offsetPx) >= viewport().width * PAGE_SWIPE_FRACTION) startPage(direction)
} else if (panY > 0f && panY >= abs(panX)) {
swipeDown += panY
if (swipeDown >= viewport().height * SWIPE_DISMISS_FRACTION) onDismiss()
} else {
swipeDown = 0f
}
}
/** Springs a resisted (uncommitted) drag back to rest when the fingers lift. */
fun settle() {
if (paging || offsetPx == 0f) return
settleJob?.cancel()
settleJob = scope.launch {
animate(offsetPx, 0f, animationSpec = MotionQuick.spec()) { value, _ -> offsetPx = value }
}
}
/** Commits one page in [direction] (+1 next, -1 previous) without a drag. */
fun page(direction: Int) {
if (!paging) startPage(direction)
}
private fun startPage(direction: Int) {
paging = true
swipeDown = 0f
settleJob?.cancel()
val width = viewport().width
scope.launch {
// Slide the open artifact out, swap in its neighbour, then slide that
// in from the opposite side — one page, in the drag's direction.
animate(offsetPx, -direction * width, animationSpec = MotionQuick.spec()) { value, _ ->
offsetPx = value
}
onPage(direction)
offsetPx = direction * width
animate(offsetPx, 0f, animationSpec = MotionQuick.spec()) { value, _ -> offsetPx = value }
paging = false
}
}
}
/**
* The one [ArtifactPaging] remembered across the artifact swaps of a viewer
* session, reading its latest viewport/availability/callbacks through
* [rememberUpdatedState] so the instance can outlive a composition that a page
* has already changed.
*/
@Composable
private fun rememberArtifactPaging(
viewport: () -> Size,
pagingEnabled: () -> Boolean,
hasPrevious: () -> Boolean,
hasNext: () -> Boolean,
onPage: (Int) -> Unit,
onDismiss: () -> Unit,
): ArtifactPaging {
val viewportState = rememberUpdatedState(viewport)
val enabledState = rememberUpdatedState(pagingEnabled)
val previousState = rememberUpdatedState(hasPrevious)
val nextState = rememberUpdatedState(hasNext)
val pageState = rememberUpdatedState(onPage)
val dismissState = rememberUpdatedState(onDismiss)
val scope = rememberCoroutineScope()
return remember {
ArtifactPaging(
viewport = { viewportState.value() },
pagingEnabled = { enabledState.value() },
hasPrevious = { previousState.value() },
hasNext = { nextState.value() },
onPage = { pageState.value(it) },
onDismiss = { dismissState.value() },
scope = scope,
)
}
}
/**
* Observes gesture ends without consuming the events (the zoom/pan detector
* above owns the drag), so a resisted page drag springs back to rest the moment
* the fingers lift. A committed page owns its own animation and is a no-op here.
*/
private fun Modifier.settlePageDrag(paging: ArtifactPaging): Modifier =
this.pointerInput(paging) {
awaitPointerEventScope {
while (true) {
awaitFirstDown(requireUnconsumed = false)
var pressed = true
while (pressed) {
pressed = awaitPointerEvent().changes.any { it.pressed }
}
paging.settle()
}
}
}
/** 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)
@@ -333,6 +702,62 @@ 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
/** Fraction of the viewport width a horizontal drag must cross to page. */
private const val PAGE_SWIPE_FRACTION = 0.18f
/** How far a drag past the first/last artifact moves before it is stopped. */
private const val PAGE_RESISTANCE = 0.35f
/**
* The media artifacts [groups] hold, in the exact order the gallery draws them
* (group by group, each group's images and videos in recorded order): the
* neighbours the full-screen viewer pages through, so a swipe visits the same
* list the grid showed. Non-media artifacts open externally instead of in the
* viewer and are not part of it. Pure, so the ordering is unit tested.
*/
internal fun pagedArtifacts(groups: List<ArtifactGroup>): List<StageArtifact> =
groups.flatMap { group ->
group.artifacts.filter { artifact ->
artifactKind(artifact.contentType, artifact.name).let {
it == ArtifactKind.Image || it == ArtifactKind.Video
}
}
}
/**
* Each gallery media artifact's url mapped to its position in [pagedArtifacts]
* — the same ordered list the viewer pages through. The grid's tiles resolve
* their viewer index here, so the tile and the viewer derive from one source and
* cannot drift. The first occurrence of a url wins. Pure, so the mapping is unit
* tested against the grid's draw order.
*/
internal fun viewerIndexByUrl(groups: List<ArtifactGroup>): Map<String, Int> {
val indices = LinkedHashMap<String, Int>()
pagedArtifacts(groups).forEachIndexed { index, artifact -> indices.putIfAbsent(artifact.url, index) }
return indices
}
/**
* The index paging from [current] by [delta] within a list of [count], clamped at
* both ends so a page never wraps (and an empty list is index 0). The one paging
* rule the gesture, the buttons and the commit all share. Pure.
*/
internal fun pagedIndex(current: Int, delta: Int, count: Int): Int =
if (count <= 0) 0 else (current + delta).coerceIn(0, count - 1)
/**
* Whether a horizontal drag at [scale] may page: only at the default fit scale,
* so a zoomed viewer pans instead. Pure, so the rule is unit tested.
*/
internal fun canPageAtScale(scale: Float, fit: Float = FIT_SCALE): Boolean =
scale <= fit + ZOOM_EPSILON
/** The viewer's position label, e.g. `2 of 5 · image/png`. Pure. */
internal fun artifactViewerPositionLabel(index: Int, count: Int, contentType: String): String {
val type = contentType.substringBefore(';').trim().ifBlank { "artifact" }
return "${index + 1} of $count · $type"
}
/**
* 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).
@@ -29,11 +29,9 @@ import androidx.compose.material3.IconButton
import androidx.compose.material3.MaterialTheme
import androidx.compose.material3.Text
import androidx.compose.runtime.Composable
import androidx.compose.runtime.getValue
import androidx.compose.runtime.mutableStateOf
import androidx.compose.runtime.mutableIntStateOf
import androidx.compose.runtime.remember
import androidx.compose.runtime.rememberCoroutineScope
import androidx.compose.runtime.setValue
import androidx.compose.ui.Alignment
import androidx.compose.ui.Modifier
import androidx.compose.ui.draw.clip
@@ -55,7 +53,6 @@ import net.awan.pipelines.ui.artifactsSummary
import net.awan.pipelines.ui.components.copyText
import net.awan.pipelines.ui.components.galleryGrid
import net.awan.pipelines.ui.humanBytes
import net.awan.pipelines.ui.isImageContentType
import net.awan.pipelines.ui.theme.ARTIFACT_BADGE_DP
import net.awan.pipelines.ui.theme.ARTIFACT_PLAY_BADGE_DP
import net.awan.pipelines.ui.theme.ARTIFACT_TILE_ACTION_DP
@@ -140,6 +137,16 @@ internal fun ArtifactGallery(
onSelectionChange: (ArtifactSelection) -> Unit = {},
) {
val text = pipelinesText()
// The media artifacts in the exact order the grid draws them: the neighbours
// the full-screen viewer pages through, so a swipe visits the same list the
// grid showed. Held once per data change, never per recomposition.
val viewable = remember(groups) { pagedArtifacts(groups) }
// Each media tile opens the viewer at the position it holds in [viewable],
// derived from that same ordered list rather than a second running counter,
// so the grid and the viewer can never disagree about which artifact is which.
val viewerIndexOf = remember(groups) { viewerIndexByUrl(groups) }
// The open viewer's index into [viewable], or [NO_VIEWER] when it is closed.
val viewerIndex = remember(groups) { mutableIntStateOf(NO_VIEWER) }
BoxWithConstraints(modifier.fillMaxWidth()) {
val grid = galleryGrid(
availableWidth = maxWidth,
@@ -167,6 +174,7 @@ internal fun ArtifactGallery(
tile = grid.cell,
selection = selection,
onSelectionChange = onSelectionChange,
onOpen = { viewerIndexOf[artifact.url]?.let { viewerIndex.intValue = it } },
)
}
// Keep a partial last row's tiles aligned to the grid.
@@ -178,8 +186,23 @@ internal fun ArtifactGallery(
}
}
}
// The one viewer instance the gallery owns, so a swipe pages through
// [viewable] rather than a per-tile viewer that has no neighbours.
if (viewerIndex.intValue in viewable.indices) {
ArtifactViewer(
artifacts = viewable,
index = viewerIndex.intValue,
configuredServerUrl = configuredServerUrl,
fetchBytes = fetchArtifactBytes,
onIndexChange = { viewerIndex.intValue = it },
onDismiss = { viewerIndex.intValue = NO_VIEWER },
)
}
}
/** No artifact is open in this gallery's viewer. */
private const val NO_VIEWER = -1
/**
* The absolute url a gallery artifact is previewed/opened at, or null when it
* cannot be resolved against the configured server (blank or invalid). The one
@@ -211,6 +234,7 @@ private fun ArtifactTile(
tile: Dp,
selection: ArtifactSelection,
onSelectionChange: (ArtifactSelection) -> Unit,
onOpen: () -> Unit,
) {
val context = LocalContext.current
// Resolve and classify once per data change, not on every recomposition.
@@ -221,7 +245,6 @@ private fun ArtifactTile(
artifactKind(artifact.contentType, artifact.name)
}
val media = kind == ArtifactKind.Image || kind == ArtifactKind.Video
var showFull by remember(artifact.url) { mutableStateOf(false) }
val selected = selection.contains(artifact.url)
Box(
@@ -248,7 +271,7 @@ private fun ArtifactTile(
selection.active -> onSelectionChange(selection.toggle(artifact.url))
// An image or video opens the full-screen viewer; any
// other type uses the existing open action.
media -> if (resolved != null) showFull = true
media -> if (resolved != null) onOpen()
else -> openArtifact(context, resolved)
}
},
@@ -299,19 +322,6 @@ private fun ArtifactTile(
)
}
}
// The tap opens the full-screen viewer (one shared instance across the run
// summary grid, the per-visit section and the stage pane, so they never
// disagree); there is no separate smaller preview to stack on top of it.
if (showFull && resolved != null) {
ArtifactViewer(
url = resolved,
name = artifact.name,
fetchBytes = fetchArtifactBytes,
onDismiss = { showFull = false },
video = kind == ArtifactKind.Video,
)
}
}
/**
@@ -3,8 +3,11 @@ 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.data.protocol.StageArtifact
import net.awan.pipelines.ui.ArtifactGroup
import net.awan.pipelines.ui.theme.PipelinesDarkColors
import org.junit.Assert.assertEquals
import org.junit.Assert.assertFalse
import org.junit.Assert.assertTrue
import org.junit.Test
@@ -118,4 +121,129 @@ class ArtifactViewerTest {
assertEquals(Color(0xFF000000), scheme.scrim)
assertTrue(contrastRatio(scheme.inverseSurface, scheme.scrim) >= 4.5)
}
@Test
fun pagedIndexMovesByOneWithinTheList() {
// Three artifacts: from the middle, next and previous move by exactly one.
assertEquals(2, pagedIndex(current = 1, delta = 1, count = 3))
assertEquals(0, pagedIndex(current = 1, delta = -1, count = 3))
}
@Test
fun pagedIndexClampsAtBothEndsWithoutWrapping() {
// At the first artifact a swipe back stays put (no wrap to the last), and
// at the last a swipe forward stays put (no wrap to the first).
assertEquals(0, pagedIndex(current = 0, delta = -1, count = 3))
assertEquals(2, pagedIndex(current = 2, delta = 1, count = 3))
}
@Test
fun pagedIndexIsZeroForASingleItemListAndAnEmptyList() {
assertEquals(0, pagedIndex(current = 0, delta = 1, count = 1))
assertEquals(0, pagedIndex(current = 0, delta = -1, count = 1))
assertEquals(0, pagedIndex(current = 4, delta = 1, count = 0))
}
@Test
fun aZoomedViewerDoesNotPage() {
// Only the fit scale pages; any zoomed-in scale pans instead.
assertTrue(canPageAtScale(scale = 1f))
assertTrue(canPageAtScale(scale = 1.0001f))
assertFalse(canPageAtScale(scale = 1.5f))
assertFalse(canPageAtScale(scale = 4f))
}
@Test
fun pagedArtifactsAreTheGalleryMediaInGridOrder() {
// Each group contributes its images and videos in recorded order, and the
// groups follow each other; non-media artifacts (opened externally) are
// not in the viewer's list.
val groups = listOf(
ArtifactGroup(
stageKey = "build",
visit = 1,
artifacts = listOf(
artifact("shot1.png", "image/png"),
artifact("log.txt", "text/plain"),
artifact("shot2.jpg", "image/jpeg"),
artifact("clip.mp4", "video/mp4"),
),
),
ArtifactGroup(
stageKey = "test",
visit = 1,
artifacts = listOf(
artifact("report.pdf", "application/pdf"),
artifact("shot3.png", "image/png"),
),
),
)
assertEquals(
listOf("shot1.png", "shot2.jpg", "clip.mp4", "shot3.png"),
pagedArtifacts(groups).map { it.name },
)
}
@Test
fun pagedArtifactsIsEmptyWithoutMedia() {
val groups = listOf(
ArtifactGroup("build", 1, listOf(artifact("log.txt", "text/plain"))),
)
assertTrue(pagedArtifacts(groups).isEmpty())
}
/**
* The gallery draws each group's media artifacts in recorded order; walking
* that draw order independently and resolving every media tile through
* [viewerIndexByUrl] must land on consecutive positions in [pagedArtifacts].
* This is the invariant that keeps a tile's tap opening the very artifact the
* viewer then shows — the grid and the viewer derive their index from one source now.
*/
@Test
fun theGridTileViewerIndicesMatchTheViewerOrder() {
val groups = listOf(
ArtifactGroup(
stageKey = "build",
visit = 1,
artifacts = listOf(
artifact("shot1.png", "image/png"),
artifact("log.txt", "text/plain"),
artifact("shot2.jpg", "image/jpeg"),
artifact("clip.mp4", "video/mp4"),
),
),
ArtifactGroup(
stageKey = "test",
visit = 1,
artifacts = listOf(
artifact("report.pdf", "application/pdf"),
artifact("shot3.png", "image/png"),
),
),
)
val indices = viewerIndexByUrl(groups)
var expected = 0
groups.forEach { group ->
group.artifacts.filter {
val kind = artifactKind(it.contentType, it.name)
kind == ArtifactKind.Image || kind == ArtifactKind.Video
}.forEach { media ->
assertEquals(expected++, indices[media.url])
}
}
assertEquals(pagedArtifacts(groups).size, expected)
}
@Test
fun thePositionLabelNamesTheOpenArtifactAndItsType() {
// One-based position, the count, and the artifact's own content type (a
// blank type falls back to "artifact") — what the viewer must reload per
// artifact rather than reusing the previous one's.
assertEquals("2 of 5 · image/png", artifactViewerPositionLabel(1, 5, "image/png"))
assertEquals("1 of 1 · image/jpeg", artifactViewerPositionLabel(0, 1, "image/jpeg; q=0.9"))
assertEquals("3 of 4 · artifact", artifactViewerPositionLabel(2, 4, ""))
}
private fun artifact(name: String, contentType: String): StageArtifact =
StageArtifact(name = name, sizeBytes = 1, contentType = contentType, url = "/artifacts/$name")
}