From cd85f6954bb53553fd44cdea0cd31368a3953a12 Mon Sep 17 00:00:00 2001 From: Alan Silva Date: Fri, 16 Oct 2026 01:40:44 +0100 Subject: [PATCH] Render artifact thumbnails with an honest loading/failure state MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit The artifact grid could show failure placeholders that were never earned: a server-relative artifact url that failed to resolve against the configured server was fetched anyway and blamed with the "!" failure mark, and the loading state was a bare "…" text. - Pass the resolved url (nullable) into ArtifactImage; a null short-circuits to a new distinct Unavailable state (LinkOff glyph) and issues no request, so a fetch that was never attempted is never drawn as a failure. - Reserve Error/"!" for a fetch or decode that was actually attempted. - Replace the "…" text with a real Material 3 CircularProgressIndicator. - Resolve gallery artifact urls in one shared helper (resolvedArtifactUrl) so the image tile and the non-image row cannot disagree; non-image artifacts keep their file-type icon. - Add unit tests covering resolution against the configured server and the null (unconfigured) case. --- .../awan/pipelines/ui/graph/ArtifactImage.kt | 46 ++++++++++++++++--- .../net/awan/pipelines/ui/graph/Artifacts.kt | 20 ++++++-- .../pipelines/ui/graph/ArtifactGalleryTest.kt | 23 ++++++++++ 3 files changed, 79 insertions(+), 10 deletions(-) diff --git a/android/app/src/main/java/net/awan/pipelines/ui/graph/ArtifactImage.kt b/android/app/src/main/java/net/awan/pipelines/ui/graph/ArtifactImage.kt index 9a594b46..b8e7aa76 100644 --- a/android/app/src/main/java/net/awan/pipelines/ui/graph/ArtifactImage.kt +++ b/android/app/src/main/java/net/awan/pipelines/ui/graph/ArtifactImage.kt @@ -6,6 +6,10 @@ import android.util.LruCache import androidx.compose.foundation.Image import androidx.compose.foundation.layout.Box import androidx.compose.foundation.layout.size +import androidx.compose.material.icons.Icons +import androidx.compose.material.icons.filled.LinkOff +import androidx.compose.material3.CircularProgressIndicator +import androidx.compose.material3.Icon import androidx.compose.material3.MaterialTheme import androidx.compose.material3.Text import androidx.compose.runtime.Composable @@ -52,21 +56,31 @@ private val artifactBitmapCache = object : LruCache(MAX_CACHED_B private const val MAX_CACHED_BITMAPS = 24 -/** Nothing is shown until the bytes arrive, and a failure is shown, not crashed. */ +/** + * One inline preview's state. [Unavailable] is deliberately separate from + * [Error]: it means no fetch was attempted because the artifact url could not be + * resolved against a configured server, so it must never be drawn with the + * 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 { data object Loading : ArtifactImageState + data object Unavailable : ArtifactImageState data object Error : ArtifactImageState data class Ready(val bitmap: Bitmap) : ArtifactImageState } /** - * An inline artifact preview. Fetching and decoding happen off the main thread - * and are cached; [maxDim] requests a thumbnail-sized decode (a full-resolution - * bitmap is only used for the explicit full-size view, [maxDim] <= 0). + * An inline artifact preview. [url] is the resolved, absolute http(s) url, or + * null when the artifact could not be resolved (no configured server): a null url + * shows [ArtifactImageState.Unavailable] and issues no request at all. Fetching + * and decoding happen off the main thread and are cached; [maxDim] requests a + * thumbnail-sized decode (a full-resolution bitmap is only used for the explicit + * full-size view, [maxDim] <= 0). */ @Composable internal fun ArtifactImage( - url: String, + url: String?, contentDescription: String?, maxDim: Int, fetchBytes: suspend (String) -> ByteArray?, @@ -82,7 +96,20 @@ internal fun ArtifactImage( contentScale = ContentScale.Fit, modifier = Modifier.size(size), ) - ArtifactImageState.Loading -> Text("…", style = MaterialTheme.typography.bodySmall) + // A real, visible loading state: distinct from both the failure mark + // and the non-image file glyph. + ArtifactImageState.Loading -> CircularProgressIndicator( + modifier = Modifier.size(ARTIFACT_PROGRESS_DP), + strokeWidth = ARTIFACT_PROGRESS_STROKE_DP, + ) + // No fetch was attempted (unresolved url): a link-off glyph, never + // the failure mark, and never the file-type icon of a non-image. + ArtifactImageState.Unavailable -> Icon( + imageVector = Icons.Filled.LinkOff, + contentDescription = contentDescription?.let { "$it unavailable" } + ?: "Preview unavailable", + tint = MaterialTheme.colorScheme.onSurfaceVariant, + ) ArtifactImageState.Error -> Text( "!", style = MaterialTheme.typography.bodySmall, @@ -94,10 +121,11 @@ internal fun ArtifactImage( @Composable private fun rememberArtifactBitmap( - url: String, + url: String?, maxDim: Int, fetchBytes: suspend (String) -> ByteArray?, ): ArtifactImageState { + if (url == null) return ArtifactImageState.Unavailable val key = "$url@$maxDim" var state by remember(key) { mutableStateOf(ArtifactImageState.Loading) } LaunchedEffect(key) { @@ -145,3 +173,7 @@ private fun decodeSampled(bytes: ByteArray, maxDim: Int): Bitmap? = try { } catch (_: Throwable) { null } + +/** The loading indicator's size and stroke, a small inline spinner. */ +private val ARTIFACT_PROGRESS_DP = 24.dp +private val ARTIFACT_PROGRESS_STROKE_DP = 2.dp 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 1577ed2f..98919f8a 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 @@ -163,6 +163,17 @@ internal fun artifactTileDp(availableWidth: Dp, columns: Int, spacing: Dp, prefe return fit.coerceIn(0.dp, preferred) } +/** + * 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 + * place a gallery artifact url is resolved, shared by the image tile and the + * non-image row so the two can never disagree. A null must never reach a fetch: + * a server-relative url has no scheme and can never load, so the tile renders the + * distinct "unavailable" state instead of the failure mark. + */ +internal fun resolvedArtifactUrl(artifact: StageArtifact, configuredServerUrl: String): String? = + ServerUrl.resolveArtifactUrl(configuredServerUrl, artifact.url) + /** One image artifact as a square thumbnail that opens the full-size view. */ @Composable private fun ArtifactTile( @@ -173,7 +184,7 @@ private fun ArtifactTile( ) { // Resolve once per (url, configuration), not on every recomposition. val resolved = remember(artifact.url, configuredServerUrl) { - ServerUrl.resolveArtifactUrl(configuredServerUrl, artifact.url) + resolvedArtifactUrl(artifact, configuredServerUrl) } var showFull by remember(artifact.url) { mutableStateOf(false) } @@ -183,8 +194,11 @@ private fun ArtifactTile( .clip(RoundedCornerShape(12.dp)) .clickable(enabled = resolved != null) { showFull = true }, ) { + // Pass the resolved url (null when there is no configured server): a + // null never triggers a relative-url fetch, it shows the distinct + // "unavailable" state instead of the failure mark. ArtifactImage( - url = resolved ?: artifact.url, + url = resolved, contentDescription = "Preview of ${artifact.name}", maxDim = THUMBNAIL_MAX_DIM, fetchBytes = fetchArtifactBytes, @@ -213,7 +227,7 @@ private fun ArtifactRow( val clipboard = LocalClipboardManager.current // Resolve/format once per (url, configuration), not on every recomposition. val resolved = remember(artifact.url, configuredServerUrl) { - ServerUrl.resolveArtifactUrl(configuredServerUrl, artifact.url) + resolvedArtifactUrl(artifact, configuredServerUrl) } val metaLine = remember(artifact) { artifactMetaLine(artifact) } diff --git a/android/app/src/test/java/net/awan/pipelines/ui/graph/ArtifactGalleryTest.kt b/android/app/src/test/java/net/awan/pipelines/ui/graph/ArtifactGalleryTest.kt index cd67f7f8..94d76c2a 100644 --- a/android/app/src/test/java/net/awan/pipelines/ui/graph/ArtifactGalleryTest.kt +++ b/android/app/src/test/java/net/awan/pipelines/ui/graph/ArtifactGalleryTest.kt @@ -1,7 +1,9 @@ package net.awan.pipelines.ui.graph import androidx.compose.ui.unit.dp +import net.awan.pipelines.data.protocol.StageArtifact import org.junit.Assert.assertEquals +import org.junit.Assert.assertNull import org.junit.Assert.assertTrue import org.junit.Test @@ -10,6 +12,27 @@ class ArtifactGalleryTest { private val spacing = 8.dp private val preferred = 96.dp + @Test + fun resolvedArtifactUrlUsesTheConfiguredServer() { + val shot = StageArtifact( + name = "00_start.png", + sizeBytes = 239275, + contentType = "image/png", + url = "/artifacts/60/4/00_start.png", + ) + assertEquals( + "http://192.168.1.20:8081/artifacts/60/4/00_start.png", + resolvedArtifactUrl(shot, "ws://192.168.1.20:8081/connect"), + ) + } + + @Test + fun resolvedArtifactUrlIsNullWhenUnconfiguredSoNoFetchIsAttempted() { + val shot = StageArtifact(url = "/artifacts/60/4/00_start.png") + assertNull(resolvedArtifactUrl(shot, "")) + assertNull(resolvedArtifactUrl(shot, "http://host:8080/connect")) + } + @Test fun narrowWidthShrinksTilesSoTheRowNeverOverflows() { // A depth-2 phone stage pane is ~360dp less two 56dp peeks and the 16dp