Open artifact images in a full-screen zoomable viewer

Tapping an image artifact (run summary grid, per-visit list or stage pane,
all rendered through ArtifactGallery) now opens a new scrim-backed
full-screen viewer instead of the former small centred dialog, which is
removed rather than stacked.

- ArtifactViewer.kt renders a full-bleed Dialog (usePlatformDefaultWidth =
  false, decorFitsSystemWindows = false) whose content re-applies
  paneSafeArea() so the dark backdrop reaches the edges while respecting
  status bar, cutout and navigation bar. A top-right row keeps the
  open-in-new and copy-link actions and adds a close button over a
  translucent scrim capsule.
- Gestures: pinch zooms about the centroid, drag pans via the existing
  graph zoomAbout, double-tap toggles fit <-> 2.5x, and a downward swipe at
  fit dismisses; a plain tap does nothing. Zoom clamps to [1x, 5x] and the
  new pure clampImageOffset keeps pan inside the scaled image. Zoom state is
  keyed on the url, so closing the viewer or opening another image resets to
  fit/centred. System Back and the close button dismiss the viewer without
  closing the pane behind it.
- Loading goes through the existing cached, off-main-thread
  rememberArtifactBitmap/ArtifactImageState path with distinct loading and
  error states, drawn in the light inverseSurface role that contrasts with
  the always-black scrim.
- Pure helpers fitImageSize, clampImageOffset and toggleZoomScale are
  covered by the new ArtifactViewerTest. ArtifactImage.kt widens
  rememberArtifactBitmap/ArtifactImageState to internal and Artifacts.kt
  replaces FullSizeArtifactDialog with ArtifactViewer (openArtifact made
  internal).
- android/README.md documents the viewer, its gestures and the evidence
  gathered on emulator-5554.
This commit is contained in:
2026-10-16 06:35:08 +01:00
parent 7b61906e1b
commit d339827b5f
5 changed files with 575 additions and 45 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
@@ -214,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,
@@ -289,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))) }
}
@@ -335,9 +300,6 @@ 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
@@ -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)
}
}