diff --git a/android/README.md b/android/README.md index cf92f26d..27f037cf 100644 --- a/android/README.md +++ b/android/README.md @@ -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 diff --git a/android/app/src/main/java/net/awan/pipelines/ui/graph/ArtifactViewer.kt b/android/app/src/main/java/net/awan/pipelines/ui/graph/ArtifactViewer.kt index f32013ce..78de5493 100644 --- a/android/app/src/main/java/net/awan/pipelines/ui/graph/ArtifactViewer.kt +++ b/android/app/src/main/java/net/awan/pipelines/ui/graph/ArtifactViewer.kt @@ -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,19 +56,30 @@ 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.isImageContentType 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 image viewer opened by tapping a gallery thumbnail (the run + * 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. @@ -74,20 +92,34 @@ import kotlin.math.abs * 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. + * * 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). + * failed fetch/decode shows a distinct error message, and paging keeps working + * (the neighbours stay reachable) 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( - url: String, - name: String, + artifacts: List, + index: Int, + configuredServerUrl: String, fetchBytes: suspend (String) -> ByteArray?, + onIndexChange: (Int) -> Unit, onDismiss: () -> Unit, ) { + val count = artifacts.size Dialog( onDismissRequest = onDismiss, properties = DialogProperties( @@ -131,89 +163,110 @@ internal fun ArtifactViewer( .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, + 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 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 imageState = 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. @@ -231,14 +284,96 @@ 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("Loading image…", spinner = true) + ArtifactImageState.Error -> ViewerMessage("Couldn't load image.") + ArtifactImageState.Unavailable -> ViewerMessage("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, + ) } } @@ -267,37 +402,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) @@ -318,6 +649,56 @@ 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 image artifacts [groups] hold, in the exact order the gallery draws them + * (group by group, each group's images in recorded order): the neighbours the + * full-screen viewer pages through, so a swipe visits the same list the grid + * showed. Non-image 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): List = + groups.flatMap { group -> group.artifacts.filter { isImageContentType(it.contentType) } } + +/** + * Each gallery image 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): Map { + val indices = LinkedHashMap() + 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). diff --git a/android/app/src/main/java/net/awan/pipelines/ui/graph/Artifacts.kt b/android/app/src/main/java/net/awan/pipelines/ui/graph/Artifacts.kt index 5066b7f7..575d42a2 100644 --- a/android/app/src/main/java/net/awan/pipelines/ui/graph/Artifacts.kt +++ b/android/app/src/main/java/net/awan/pipelines/ui/graph/Artifacts.kt @@ -29,11 +29,9 @@ import androidx.compose.material3.MaterialTheme import androidx.compose.material3.Surface 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 @@ -136,6 +134,16 @@ internal fun ArtifactGallery( onSelectionChange: (ArtifactSelection) -> Unit = {}, ) { val text = pipelinesText() + // The image 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 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, @@ -165,6 +173,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. @@ -185,8 +194,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 @@ -199,13 +223,13 @@ internal fun resolvedArtifactUrl(artifact: StageArtifact, configuredServerUrl: S ServerUrl.resolveArtifactUrl(configuredServerUrl, artifact.url) /** - * One image artifact as a square thumbnail that opens the full-size view. A - * long-press enters artifact selection on this item; while selection mode is - * active a tap toggles it instead of opening, and the selected cell gets the - * app's selected treatment (a tonal ring + check badge in the shared - * secondaryContainer/onSecondaryContainer roles, and the `selected` semantics - * state). The per-item share control is hidden while selecting so the whole cell - * is the toggle target. + * One image artifact as a square thumbnail that opens the gallery's full-size + * viewer ([onOpen]). A long-press enters artifact selection on this item; while + * selection mode is active a tap toggles it instead of opening, and the selected + * cell gets the app's selected treatment (a tonal ring + check badge in the + * shared secondaryContainer/onSecondaryContainer roles, and the `selected` + * semantics state). The per-item share control is hidden while selecting so the + * whole cell is the toggle target. */ @OptIn(ExperimentalFoundationApi::class) @Composable @@ -216,12 +240,12 @@ private fun ArtifactTile( tile: Dp, selection: ArtifactSelection, onSelectionChange: (ArtifactSelection) -> Unit, + onOpen: () -> Unit, ) { // Resolve once per (url, configuration), not on every recomposition. val resolved = remember(artifact.url, configuredServerUrl) { resolvedArtifactUrl(artifact, configuredServerUrl) } - var showFull by remember(artifact.url) { mutableStateOf(false) } val selected = selection.contains(artifact.url) Box( @@ -240,7 +264,7 @@ private fun ArtifactTile( if (selection.active) { onSelectionChange(selection.toggle(artifact.url)) } else if (resolved != null) { - showFull = true + onOpen() } }, onLongClick = { onSelectionChange(selection.enter(artifact.url)) }, @@ -291,18 +315,6 @@ 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) { - ArtifactViewer( - url = resolved, - name = artifact.name, - fetchBytes = fetchArtifactBytes, - onDismiss = { showFull = false }, - ) - } } /** diff --git a/android/app/src/test/java/net/awan/pipelines/ui/graph/ArtifactViewerTest.kt b/android/app/src/test/java/net/awan/pipelines/ui/graph/ArtifactViewerTest.kt index 590e5aff..a512ffe2 100644 --- a/android/app/src/test/java/net/awan/pipelines/ui/graph/ArtifactViewerTest.kt +++ b/android/app/src/test/java/net/awan/pipelines/ui/graph/ArtifactViewerTest.kt @@ -3,8 +3,12 @@ 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.isImageContentType 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 +122,124 @@ 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 pagedArtifactsAreTheGalleryImagesInGridOrder() { + // Each group contributes its images in recorded order, and the groups + // follow each other; non-image 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"), + ), + ), + ArtifactGroup( + stageKey = "test", + visit = 1, + artifacts = listOf( + artifact("report.pdf", "application/pdf"), + artifact("shot3.png", "image/png"), + ), + ), + ) + assertEquals( + listOf("shot1.png", "shot2.jpg", "shot3.png"), + pagedArtifacts(groups).map { it.name }, + ) + } + + @Test + fun pagedArtifactsIsEmptyWithoutImages() { + val groups = listOf( + ArtifactGroup("build", 1, listOf(artifact("log.txt", "text/plain"))), + ) + assertTrue(pagedArtifacts(groups).isEmpty()) + } + + /** + * The gallery draws each group's images in recorded order; walking that draw + * order independently and resolving every 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"), + ), + ), + 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 { isImageContentType(it.contentType) }.forEach { image -> + assertEquals(expected++, indices[image.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") }