justinzeus/wolfskin
1
0
Fork 0
Code Issues 2 Pull requests 4 Releases 3 Packages Activity

Round 2 release candidate: Home, Discover, trailer, crash fix and stock screens #64

Merged
justinzeus merged 25 commits from fm/tv-round2-rc into fm/tv-round2 2026-11-07 21:14:15 +01:00
Conversation 0 Commits 25 Files changed 84 +1023 -102
20 changed files with 1023 additions and 102 deletions
Download patch file Download diff file Expand all files Collapse all files
Showing only changes of commit abebd52850 - Show all commits

115
app/src/test/java/org/justinvisser/wolfskin/tv/DiscoverRefreshMotionTest.kt Normal file
View file

@ -0,0 +1,115 @@
package org.justinvisser.wolfskin.tv
import android.app.Application
import android.graphics.Bitmap
import android.graphics.BitmapFactory
import android.view.View
import android.view.WindowManager
import androidx.activity.ComponentActivity
import androidx.compose.foundation.layout.requiredSize
import androidx.compose.runtime.CompositionLocalProvider
import androidx.compose.ui.Modifier
import androidx.compose.ui.geometry.Rect
import androidx.compose.ui.graphics.asImageBitmap
import androidx.compose.ui.test.junit4.createAndroidComposeRule
import androidx.compose.ui.test.onNodeWithTag
import androidx.compose.ui.test.onRoot
import androidx.lifecycle.viewModelScope
import com.github.damontecres.wholphin.preferences.AppPreferences
import com.github.damontecres.wholphin.preferences.UserPreferences
import com.github.damontecres.wholphin.services.NavigationManager
import com.github.takahirom.roborazzi.captureRoboImage
import io.mockk.coEvery
import io.mockk.mockk
import kotlinx.coroutines.CompletableDeferred
import kotlinx.coroutines.cancel
import kotlinx.coroutines.runBlocking
import org.junit.Assert.*
import org.junit.Rule
import org.junit.Test
import org.junit.runner.RunWith
import org.justinvisser.wolfskin.conductarr.MemoryCacheStore
import org.justinvisser.wolfskin.design.*
import org.justinvisser.wolfskin.tv.read.TitleReadFacade
import org.robolectric.RobolectricTestRunner
import org.robolectric.Shadows
import org.robolectric.annotation.Config
import org.robolectric.annotation.GraphicsMode
import java.io.File
/** Refreshing a loaded Discover title must preserve its real header instead of rebuilding a skeleton. */
@RunWith(RobolectricTestRunner::class)
@Config(sdk = [34], application = Application::class, qualifiers = "w960dp-h540dp-xhdpi")
@GraphicsMode(GraphicsMode.Mode.NATIVE)
class DiscoverRefreshMotionTest {
@get:Rule val rule = createAndroidComposeRule<ComponentActivity>()
@Test fun loadedCatalogueRefreshKeepsReadyActionsOpaqueAndStationary() {
rule.activity.window.setFlags(WindowManager.LayoutParams.FLAG_FULLSCREEN, WindowManager.LayoutParams.FLAG_FULLSCREEN)
@Suppress("DEPRECATION")
rule.activity.window.decorView.systemUiVisibility = View.SYSTEM_UI_FLAG_FULLSCREEN or View.SYSTEM_UI_FLAG_HIDE_NAVIGATION or View.SYSTEM_UI_FLAG_IMMERSIVE_STICKY
rule.mainClock.autoAdvance = false
FakeConductarr().use { fake ->
fake.localArt = true
ConductarrSession(MemoryCacheStore()).use { session ->
session.select("server:shared", SHARED_TOKEN, fake.url)
runBlocking { session.authenticate() }
val facade = mockk<TitleReadFacade>()
coEvery { facade.findHeld(any(), any()) } returns null
val model = WolfskinTitleViewModel(rule.activity, facade, mockk(), NavigationManager(), session, mockk(relaxed = true))
val person = ShellPerson("shared", "Shared", "S", false)
val route = titleRoute("tv:44")
val shell = ShellState(listOf(person), person.key).apply { pickerVisible = false; enterDestination("discover"); enterDestination(route) }
val preferences = UserPreferences(AppPreferences.getDefaultInstance(), null)
val art = Bitmap.createBitmap(8, 8, Bitmap.Config.ARGB_8888).apply { eraseColor(android.graphics.Color.DKGRAY) }.asImageBitmap()
val refreshLookup = CompletableDeferred<java.util.UUID?>()
try {
rule.setContent { WolfskinTheme {
model.title?.let { state ->
val bitmaps = listOfNotNull(state.data.item.poster, state.data.item.backdrop).associateWith { art }
CompositionLocalProvider(LocalTitleBitmaps provides bitmaps) {
TitleSurface(state, shell, Modifier.requiredSize(WolfskinTokens.Shell.stageWidth, WolfskinTokens.Shell.stageHeight))
}
}
} }
rule.runOnIdle { model.load(route, person, preferences, fixtures = false) }
rule.waitUntil(30_000) {
Shadows.shadowOf(android.os.Looper.getMainLooper()).idle()
model.title?.data?.status == TitleReadStatus.Ready && model.title?.data?.cast?.isNotEmpty() == true && model.title?.data?.related?.isNotEmpty() == true
}
rule.mainClock.advanceTimeBy(640)
val directory = File(System.getProperty("wolfskin.captureDirectory"), "discover-refresh").apply { mkdirs() }
val bounds = rule.onNodeWithTag("title-actions").fetchSemanticsNode().boundsInRoot
val pixels = IntArray(bounds.width.toInt() * bounds.height.toInt())
val baseline = brightness(File(directory, "loaded.png"), bounds, pixels)
coEvery { facade.findHeld(any(), any()) } coAnswers { refreshLookup.await() }
rule.runOnIdle {
model.load(route, person, preferences, fixtures = false, force = true)
assertEquals("An already-loaded catalogue title must never emit Loading on refresh", TitleReadStatus.Ready, model.title!!.data.status)
}
repeat(12) { index ->
rule.mainClock.advanceTimeBy(16)
assertEquals(TitleReadStatus.Ready, model.title!!.data.status)
assertFalse("A refresh cannot focus the root navigation", shell.navFocused)
assertEquals("Loaded actions cannot replay their rise", bounds, rule.onNodeWithTag("title-actions").fetchSemanticsNode().boundsInRoot)
assertEquals("Loaded actions cannot replay their fade", baseline, brightness(File(directory, "refresh-${index.toString().padStart(2, '0')}.png"), bounds, pixels))
}
} finally {
model.viewModelScope.cancel()
refreshLookup.complete(null)
}
}
}
}
private fun brightness(file: File, bounds: Rect, pixels: IntArray): Long {
rule.onRoot().captureRoboImage(file.absolutePath)
val bitmap = BitmapFactory.decodeFile(file.absolutePath)
return try {
val width = bounds.width.toInt()
val height = bounds.height.toInt()
bitmap.getPixels(pixels, 0, width, bounds.left.toInt(), bounds.top.toInt(), width, height)
pixels.sumOf { (android.graphics.Color.red(it) + android.graphics.Color.green(it) + android.graphics.Color.blue(it)).toLong() }
} finally { bitmap.recycle() }
}
}

17
app/src/test/java/org/justinvisser/wolfskin/tv/TitleAsyncFocusTest.kt
View file

@ -6,6 +6,7 @@ import androidx.activity.ComponentActivity
import androidx.compose.ui.input.key.Key
import androidx.compose.ui.test.junit4.createAndroidComposeRule
import androidx.compose.ui.test.assertIsDisplayed
import androidx.compose.ui.test.assertIsFocused
import androidx.compose.ui.test.onNodeWithTag
import androidx.compose.ui.test.onRoot
import androidx.compose.ui.test.performKeyInput
@ -69,9 +70,12 @@ class TitleAsyncFocusTest {
rule.setContent { WolfskinTheme { TitleDestination(route, shell, preferences, viewModel = viewModel) } }
rule.waitUntil { viewModel.title?.data?.status == TitleReadStatus.Loading }
rule.waitForIdle()
assertTrue(shell.navFocused)
assertFalse("Loading retains destination focus instead of focusing the root nav", shell.navFocused)
rule.onNodeWithTag("title-page").assertIsFocused()
press(Key.DirectionDown)
assertTrue("The initial skeleton cannot receive nav Down", shell.navFocused)
assertFalse("Down cannot transfer focus to nav or an initial skeleton", shell.navFocused)
assertEquals("header", viewModel.title!!.row)
assertEquals(0, viewModel.title!!.column)
val source = TitleVersion("first", "Original", "1080p", "", "", "MKV", listOf(TitleTrack(3, "English", true)), emptyList())
rule.runOnIdle {
@ -109,9 +113,12 @@ class TitleAsyncFocusTest {
} }
rule.waitUntil { viewModel.title?.data?.status == TitleReadStatus.Loading }
rule.waitForIdle()
assertTrue(shell.navFocused)
assertFalse(shell.navFocused)
rule.onNodeWithTag("title-page").assertIsFocused()
press(Key.DirectionDown)
assertTrue(shell.navFocused)
assertFalse("Down cannot enter a pending person skeleton", shell.navFocused)
assertEquals("header", viewModel.title!!.row)
assertEquals(0, viewModel.title!!.column)
rule.runOnIdle {
reply.complete(org.justinvisser.wolfskin.tv.read.PersonRead(
org.justinvisser.wolfskin.design.TitlePerson(id.toString(), "Actor"),
@ -121,7 +128,7 @@ class TitleAsyncFocusTest {
rule.waitUntil(timeoutMillis = 5000) { viewModel.person != null || viewModel.title?.data?.status == TitleReadStatus.Unavailable }
assertNotNull("A real person reply must populate the performer destination", viewModel.person)
rule.waitForIdle()
assertFalse("The loaded person must transfer nav ownership to its first credit", shell.navFocused)
assertFalse("The loaded person retains destination focus on its first credit", shell.navFocused)
assertEquals(0, viewModel.person!!.index)
press(Key.DirectionRight)
assertEquals(1, viewModel.person!!.index)

7
app/src/test/java/org/justinvisser/wolfskin/tv/TitleKeysTest.kt
View file

@ -12,6 +12,7 @@ import androidx.compose.ui.test.onNodeWithTag
import androidx.compose.ui.test.performMouseInput
import androidx.compose.ui.test.onNodeWithText
import androidx.compose.ui.test.assertIsDisplayed
import androidx.compose.ui.test.assertIsFocused
import androidx.compose.ui.test.hasClickAction
import androidx.compose.ui.test.hasText
import org.justinvisser.wolfskin.design.WolfskinTokens
@ -285,10 +286,14 @@ class TitleKeysTest {
render(transform = { it.copy(status = TitleReadStatus.Loading) })
rule.onNodeWithText("Cast").assertDoesNotExist()
press(Key.DirectionDown)
assertTrue(shell.navFocused)
assertFalse(shell.navFocused)
rule.onNodeWithTag("title-page").assertIsFocused()
assertEquals("header", state.row)
assertEquals(0, state.column)
assertFalse(shell.pickerVisible)
rule.runOnIdle { rule.activity.onBackPressedDispatcher.onBackPressed() }
assertEquals(listOf(TitleAction.Pop), effects)
assertFalse(shell.pickerVisible)
}

2
app/src/wolfskin/java/org/justinvisser/wolfskin/tv/TitleDestination.kt
View file

@ -91,7 +91,7 @@ class WolfskinTitleViewModel @Inject constructor(
fun load(destination: String, selected: ShellPerson, userPreferences: UserPreferences, fixtures: Boolean = BuildConfig.DEBUG, force: Boolean = false) {
if (!force && route == destination && ::viewer.isInitialized && viewer.key == selected.key) return
if (force && route == destination && ::viewer.isInitialized && viewer.key == selected.key &&
title?.data?.status == TitleReadStatus.Ready && title?.data?.item?.held == true &&
title?.data?.status == TitleReadStatus.Ready &&
(title?.data?.connection != TitleConnection.SignedIn || conductarr.identity.value?.signedIn == true) &&
!destination.startsWith("person/") && fixture == null) {
loadJob?.cancel()

15
data/tv-spec/spec.md
View file

@ -79,6 +79,8 @@ Read-only source measurement: Desperate Housewives has a 2732×1536 Backdrop. Wi
Every Discover lane, including Movies for you, Series for you, service entries, service-specific lanes and Hidden picks, uses a **104 px heading band**: heading line plus **60 px heading-to-card gap**, up from 40 px. This is a consistent Level 2 extension, not a Series-only exception. Poster shelves become 652 px high and service-entry shelves 316 px. Captions and frame scroll offsets use the same heading band. Home headings remain unchanged.
Round-2 Discover navigation amendment: Up/Down into an untouched lane starts at its leftmost item, not the previous lane's nearest column. A moved lane restores its own selected item and horizontal track for this visit. Pushed titles and service/collection pages preserve that visit; selecting another root tab or rebuilding Discover clears its lane positions. Root vertical position, filters and hero selection retain their existing shell policy. Home's nearest-centre shelves and Library's column-preserving continuous grids are unchanged pending a separate behavior decision.
## Motion and loading — revision 6
Home heroes and shelves, Library rows, Discover hero/lanes, title headers, episodes and cast, and person headers/filmography use shaped placeholders without loading sentences. The placeholder fill is `surface2` (`#1b1b25`). A complete shelf shares **one** alpha layer: **0.55 → 1 → 0.55 over 1400 ms**, CSS ease-in-out (`.42,0,.58,1`), 700 ms each way. All loading shelves under the screen's theme share one clock, so late arrivals join the current phase. The clock stops when the last loading shelf leaves. No per-card clocks, staggered pulse phases, shimmer, moving gradient, or animated blur.
@ -89,17 +91,18 @@ Home heroes and shelves, Library rows, Discover hero/lanes, title headers, episo
| Poster caption in / out | 60 ms delay + 180 ms ease-out / 100 ms ease-out | 10 px rise on entry only; exit holds its position, including when entry was interrupted |
| Network artwork only | 160 ms, Coil painter alpha | None; memory, disk and local hits are instant |
| Row/tab content reveal | 180 ms, ease-out | One layer per row, 24 px rise |
| Initial hero/title copy | 180 ms, ease-out | 16 px rise |
| Initial hero/title copy | 180 ms, ease-out | 16 px rise (`copyEntryRise`); saved hero entry state suppresses replay on remount, not first appearance |
| Hero backdrop hand-off | 320 ms, ease-in-out (`.65,0,.35,1`) | Alpha only; retain previous art until incoming art or its final fallback is ready |
| Hero copy hand-off | Old copy out 120 ms ease (`.25,.1,.25,1`); new copy starts at 140 ms and enters over 200 ms ease-out | 14 px rise on entry |
| Hero copy hand-off | Outgoing 120 ms ease (`.25,.1,.25,1`); incoming starts after 140 ms and enters over 200 ms ease-out, gated on artwork or final fallback readiness | One copy slot: no overlapping text; 14 px incoming rise, outgoing translation held where entry stopped |
| Late ratings, genres, overview and readiness | 200 ms, ease | Alpha only, inside existing measured slots; rating plates keep their existing plate fade rather than adding a nested fade |
| Horizontal / vertical focus-follow scroll | 160 ms ease / 180 ms ease-out | Existing scroll geometry |
| Discover pager | 180 ms, ease-out, retargeting current width and opacity | Buttons and pager remain outside the copy transition; reduced motion snaps width and caps opacity fades at 80 ms |
Row reveals are grouped rather than the browser prototype's per-card staging: the armv7 frame budget permits one animated layer per shelf, not one per card. Tabs have no full-screen transition layer. The upper Home hero blend is bounded to **1920×820 px**, Discover to **1920×740 px**; the lower backdrop changes without an animated screen-sized layer. Hero copy is a separate bounded block. Image reveal uses Coil's painter, not a new full-screen compositing layer. Existing poster-only blur is static.
Row reveals are grouped rather than the browser prototype's per-card staging: the armv7 frame budget permits one animated layer per shelf, not one per card. Tabs have no full-screen transition layer. The upper Home hero blend is bounded to **1920×820 px**, Discover to **1920×740 px**; the entire painted backdrop stays static while incoming artwork loads, and the lower backdrop changes only when artwork or its final fallback is ready, without an animated screen-sized layer. Hero copy is a separate bounded block with stationary action controls. Ordinary image reveal uses Coil's painter; hero-controlled requests bypass that independent fade so only the token-backed hero blend owns the transition. Existing poster-only blur is static.
The title page's scroll dim is a draw-only colour overlay, not an alpha-animated full-screen layer. Discover scrolls its backdrop through placement offsets rather than a full-screen translation layer. Initial loading animated layers are Home **2**, Library **up to 3** lazy rows, Discover **2**, title header **1**, person **2**; pending title episode/cast shelves add **1 each**, and each pending Discover lane owns **1**. Deep Home loading is bounded to **4** visible shelf layers. These are animated layers, not independent pulse clocks or every static display-list node: one shared pulse clock drives the loading screen without adding a layer. A hero hand-off adds at most **2** bounded owners (outgoing art and copy). Focus changes can animate **2** card transforms, **1** caption and at most **2** rating plates; artwork fades are painter draws without additional compositing layers. Late title metadata adds at most **4** bounded alpha layers: title ratings, play-target ratings, genres and overview. No animated owner is full-screen.
The title page's scroll dim is a draw-only colour overlay, not an alpha-animated full-screen layer. Discover scrolls its backdrop through placement offsets rather than a full-screen translation layer. Initial loading animated layers are Home **2**, Library **up to 3** lazy rows, Discover **2**, title header **1**, person **2**; pending title episode/cast shelves add **1 each**, and each pending Discover lane owns **1**. Deep Home loading is bounded to **4** visible shelf layers. These are animated layers, not independent pulse clocks or every static display-list node: one shared pulse clock drives the loading screen without adding a layer. An ordinary hero hand-off animates **2** bounded owners (outgoing art and one sequential copy block) above an opaque artwork base. Art interruptions retain the painted composite without resetting alpha; each outgoing art owner keeps its original 320 ms lifetime. Copy retargets its current alpha, fades out before replacing text, then uses the approved delay/entry tokens; never two copy layers are visible together. Focus changes can animate **2** card transforms, **1** caption and at most **2** rating plates; ordinary artwork fades are painter draws without additional compositing layers. Late title metadata adds at most **4** bounded alpha layers: title ratings, play-target ratings, genres and overview. No animated owner is full-screen.
The approved title follow-up (2026-11-07) supersedes the fixed readiness reservation: an absent readiness line occupies **0 px**, while a present line occupies **56 px (28 dp)**. Late arrival/removal animates that height over the **200 ms late-line duration with token ease-out**; reduced motion snaps. Overview, actions and following rows move monotonically with that band; an already-pinned focused row stays pinned through same-remeasure scroll compensation. Ratings remain inside the fixed-height facts band and appear once: an explicit episode page uses its opened episode's own set, including the episode score, rather than the series-only set. Series and episode pages have no redundant Seasons shortcut; Down reaches the season chips. Skeletons have no click/hover focus targets; pending episode/cast rows remain absent from the key-navigation state until real cards exist. Initial loading keeps nav focus and Back still pops the title/person route.
The approved title follow-up (2026-11-07) supersedes the fixed readiness reservation: an absent readiness line occupies **0 px**, while a present line occupies **56 px (28 dp)**. Late arrival/removal animates that height over the **200 ms late-line duration with token ease-out**; reduced motion snaps. Overview, actions and following rows move monotonically with that band; an already-pinned focused row stays pinned through same-remeasure scroll compensation. Ratings remain inside the fixed-height facts band and appear once: an explicit episode page uses its opened episode's own set, including the episode score, rather than the series-only set. Series and episode pages have no redundant Seasons shortcut; Down reaches the season chips. Skeletons have no click/hover focus targets; pending episode/cast rows remain absent from the key-navigation state until real cards exist. Initial title/person loading retains destination focus rather than focusing the root nav; Down cannot enter a skeleton, and Back still pops the route without opening the picker. An already-ready catalogue or held title stays Ready while a same-route, same-person refresh reads new data; the existing signed-in authentication guard remains authoritative, and loaded copy/rows do not remount or replay their entry motion.
Discover key traversal skips pending lanes in both directions. If every remaining lane is pending, Down stays on the real filter chips and Back returns to nav; a skeleton must never create an empty-column focus range.
@ -107,6 +110,8 @@ Discover key traversal skips pending lanes in both directions. If every remainin
Native **1920×1080** before/after frames and the frame-budget inventory are published at [the motion build proof](https://pages.justinvisser.org/wolfskin/tv-motion-build/). Before frames use the pre-change surface sources in this same isolated worktree; after frames use the shipped Compose surfaces. No device access, installation or optimized APK is part of this lane. On-box acceptance remains: no series layout change after first content, Home scrolling no worse than **39.6% janky / p90 65 ms**. Native JVM rendering does not measure that GPU/frame-timing target.
The [round-2 Discover native proof](https://pages.justinvisser.org/wolfskin/tv-round2-discover/) publishes paired 1920×1080 frame strips and exact 16 ms alpha/translation/position series for ready, slow, failed, sustained rapid-selection and reduced-motion scenarios. The reviewed counter-fade remains available separately for comparison with the corrected sequential copy; initial-entry/remount and Home hero series are also published. The regression suite checks an opaque artwork base, at most one visible copy, monotonic per-phase motion, stationary controls and token-bounded outgoing artwork lifetimes. The approved fade-through may briefly have no visible copy; it never paints overlapping titles. These are native-rendering proofs, not on-box frame-pacing measurements.
## Card metadata and bottom state line — revision 6, option B

7
wolfskin-design/src/main/java/org/justinvisser/wolfskin/design/DiscoverArtwork.kt
View file

@ -33,6 +33,8 @@ import androidx.compose.ui.platform.LocalContext
import androidx.compose.ui.platform.testTag
import coil3.compose.AsyncImage
import org.justinvisser.wolfskin.design.WolfskinTokens.Color as C
import coil3.request.transitionFactory
import coil3.transition.Transition
import org.justinvisser.wolfskin.design.WolfskinTokens.Discover as D
import org.justinvisser.wolfskin.design.WolfskinTokens.Layout as L
@ -50,13 +52,14 @@ fun DiscoverArtwork(path: String?, modifier: Modifier, poster: Boolean = false,
this *= ColorMatrix().apply { setToScale(D.ambientBrightness, D.ambientBrightness, D.ambientBrightness, 1f) }
}) else null }
val context = LocalContext.current
val request = remember(context, path, poster, dim) {
val heroReady = LocalHeroArtReady.current
val request = remember(context, path, poster, dim, heroReady != null) {
val upright = poster || dim
WolfskinImages.request(context, path,
if (upright) WolfskinTokens.Image.heroPosterRequestWidth else WolfskinTokens.Image.heroRequestWidth,
if (upright) WolfskinTokens.Image.heroPosterRequestHeight else WolfskinTokens.Image.heroRequestHeight, upright)
.let { if (heroReady != null) it.newBuilder().transitionFactory(Transition.Factory.NONE).build() else it }
}
val heroReady = LocalHeroArtReady.current
if (painter != null) {
androidx.compose.runtime.SideEffect { heroReady?.invoke() }
Image(painter, null, modifier, contentScale = ContentScale.Crop, colorFilter = filter)

31
wolfskin-design/src/main/java/org/justinvisser/wolfskin/design/DiscoverScreen.kt
View file

@ -1,6 +1,8 @@
// SPDX-License-Identifier: GPL-2.0-only
package org.justinvisser.wolfskin.design
import androidx.compose.animation.core.Animatable
import androidx.compose.animation.core.tween
import kotlinx.coroutines.coroutineScope
import kotlinx.coroutines.launch
@ -49,7 +51,10 @@ fun DiscoverScreen(state: DiscoverState, modifier: Modifier = Modifier) {
val focus = remember(state) { object : ShellContentFocus by state {} }
DisposableEffect(focus, entryActive) {
if (entryActive) shell.contentFocus = focus
onDispose { if (shell.contentFocus === focus) { shell.contentFocus = null; shell.contentOverlayVisible = false } }
onDispose {
if (shell.tabs.getOrNull(shell.currentTab) != "discover") state.resetLaneMemory()
if (shell.contentFocus === focus) { shell.contentFocus = null; shell.contentOverlayVisible = false }
}
}
LaunchedEffect(view, state.snapshot.savedAt) { view.savedAt = state.snapshot.savedAt }
LaunchedEffect(state.toast) { if (state.toast != null) { kotlinx.coroutines.delay(WolfskinTokens.Motion.toast.toLong()); state.toast = null } }
@ -105,6 +110,7 @@ fun DiscoverScreen(state: DiscoverState, modifier: Modifier = Modifier) {
animateFrameScroll(list, target - with(density) { current.toPx() } - list.firstVisibleItemScrollOffset)
}
}
HeroMotionScope {
Box(modifier.fillMaxSize().testTag("discover-screen")) {
if (state.hasHero && state.service == null && list.firstVisibleItemIndex == 0) state.hero?.let { title ->
HeroArtCrossfade(title.key, title, L.row_phero, Modifier.offset { IntOffset(0, -list.firstVisibleItemScrollOffset) }) { DiscoverBackdrop(it) }
@ -131,13 +137,15 @@ fun DiscoverScreen(state: DiscoverState, modifier: Modifier = Modifier) {
}
}
}
}
}
@Composable
private fun DiscoverHero(state: DiscoverState) {
val title = state.hero ?: return
HeroCopyHandoff(title.key, title) { copy ->
Column(Modifier.fillMaxWidth().height(L.row_phero).padding(start = L.safeSide, bottom = L.heroCopyBottom), verticalArrangement = Arrangement.Bottom) {
Column(Modifier.fillMaxWidth().height(L.row_phero).padding(start = L.safeSide, bottom = L.heroCopyBottom), verticalArrangement = Arrangement.Bottom) {
HeroCopyHandoff(title.key, title) { copy ->
Column {
Row(horizontalArrangement = Arrangement.spacedBy(WolfskinTokens.Card.posterGap), verticalAlignment = Alignment.CenterVertically) {
Glyph("seerr", C.accentText, Modifier.size(L.buttonIcon))
Text(if (state.snapshot.status == DiscoverStatus.Ready) "For you" else "Trending", color = C.accentText, style = DiscoverType.label)
@ -153,17 +161,32 @@ private fun DiscoverHero(state: DiscoverState) {
}
Spacer(Modifier.height(D.heroMetaGap))
Text(copy.overview, Modifier.width(L.heroOverviewMax), color = C.muted, style = DiscoverType.body, maxLines = 2, overflow = TextOverflow.Ellipsis)
}
}
Spacer(Modifier.height(D.heroOverviewGap))
Row(verticalAlignment = Alignment.CenterVertically) {
DiscoverButton("Details", state.contentFocused && state.focusedRow == 0, "about") { state.openTitle(title) }
Row(Modifier.padding(start = D.dotMargin), horizontalArrangement = Arrangement.spacedBy(D.dotGap), verticalAlignment = Alignment.CenterVertically) {
Glyph("left", C.fg.copy(alpha = if (state.contentFocused && state.focusedRow == 0) 1f else 0f), Modifier.size(D.dotChevron))
state.heroes.forEachIndexed { index, _ -> Box(Modifier.size(if (index == state.slide) D.dotActive else D.dotSize, D.dotSize).background(if (index == state.slide) C.fg else C.fg.copy(alpha = .3f), CircleShape)) }
state.heroes.forEachIndexed { index, _ -> DiscoverHeroDot(index, index == state.slide) }
Glyph("right", C.fg.copy(alpha = if (state.contentFocused && state.focusedRow == 0) 1f else 0f), Modifier.size(D.dotChevron))
}
}
}
}
/** Pager geometry retargets from its current value independently of artwork loading. */
@Composable
private fun DiscoverHeroDot(index: Int, selected: Boolean) {
val progress = remember { Animatable(if (selected) 1f else 0f) }
val reduced = reducedMotion()
LaunchedEffect(selected, reduced) {
progress.animateTo(if (selected) 1f else 0f,
tween(motionDuration(WolfskinTokens.Motion.focusMove, reduced), easing = WolfskinTokens.Motion.easeOut))
}
val widthProgress = if (reduced) { if (selected) 1f else 0f } else progress.value
Box(Modifier.testTag("hero-dot-$index").size(D.dotSize + (D.dotActive - D.dotSize) * widthProgress, D.dotSize)
.background(C.fg.copy(alpha = .3f + .7f * progress.value), CircleShape))
}
@Composable

8
wolfskin-design/src/main/java/org/justinvisser/wolfskin/design/DiscoverShelf.kt
View file

@ -40,14 +40,14 @@ fun DiscoverShelf(state: DiscoverState, lane: DiscoverLane, row: Int) {
val height = if (services) K.entryH else K.posterH
val cards = rememberLazyListState()
val count = if (services) state.snapshot.services.size else lane.titles.size + if (lane.tail == DiscoverTail.None) 0 else 1
val column = (state.shell.view.cards[lane.id] ?: 0).coerceIn(0, (count - 1).coerceAtLeast(0))
val column = state.laneColumn(lane.id).coerceIn(0, (count - 1).coerceAtLeast(0))
val active = state.contentFocused && state.focusedRow == row
val slots = K.posterSlots
val first = state.shell.view.cards["first:${lane.id}"] ?: 0
val first = state.laneFirsts[lane.id] ?: 0
val density = LocalDensity.current
LaunchedEffect(column, count, active) {
LaunchedEffect(state.service?.id, column, count, active) {
val target = shelfFirst(column, first, slots, count)
state.shell.view.cards["first:${lane.id}"] = target
state.laneFirsts[lane.id] = target
cards.scrollShelfTo(target, with(density) { K.posterPitch.toPx() })
}
Box(Modifier.fillMaxWidth().height(D.shelfHeadingBand + height + (if (services) WolfskinTokens.Shell.zero else K.posterCaptionBand) + L.rowGapAfter).testTag("discover-lane-${lane.id}")) {

35
wolfskin-design/src/main/java/org/justinvisser/wolfskin/design/DiscoverState.kt
View file

@ -10,7 +10,7 @@ import kotlinx.coroutines.launch
import kotlinx.coroutines.sync.Mutex
import kotlinx.coroutines.sync.withLock
/** One person owns a Discover view; the shell retains its root list and card memory. */
/** Each person retains the root viewport; lane movement belongs only to this Discover visit. */
class DiscoverState(
val shell: ShellState,
initial: DiscoverSnapshot,
@ -75,6 +75,20 @@ class DiscoverState(
private val pendingDismissals = mutableMapOf<String, DiscoverTitle?>()
private var rootFilter = "all"
private val rootLaneMemory = DiscoverLaneMemory()
private val serviceLaneMemory = mutableMapOf<Long, DiscoverLaneMemory>()
private val laneMemory get() = service?.let { serviceLaneMemory.getValue(it.id) } ?: rootLaneMemory
private val laneColumns get() = laneMemory.columns
internal val laneFirsts get() = laneMemory.firsts
internal fun laneColumn(id: String): Int = laneColumns[id] ?: 0
/** Pushed titles preserve this visit; selecting another root tab discards lane movement. */
internal fun resetLaneMemory() {
rootLaneMemory.clear()
serviceLaneMemory.values.forEach { it.clear() }
}
fun updateSnapshot(value: DiscoverSnapshot) {
snapshot = value
if (value.savedAt == null && value.status in setOf(DiscoverStatus.Ready, DiscoverStatus.NoSeeds, DiscoverStatus.PicksUnavailable)) savedTime = formatSavedTime()
@ -139,7 +153,7 @@ class DiscoverState(
val rowCount: Int get() = firstShelf + lanes.size
val focusedRow: Int get() = shell.view.row.coerceIn(0, (rowCount - 1).coerceAtLeast(0))
val focusedLane: DiscoverLane? get() = lanes.getOrNull(focusedRow - firstShelf)
val column: Int get() = shell.view.cards[rowKey].orZero().coerceAtMost(maxColumn())
val column: Int get() = (if (focusedRow >= firstShelf) laneColumn(rowKey) else shell.view.cards[rowKey].orZero()).coerceAtMost(maxColumn())
val rowKey: String get() = when (focusedRow) { 0 -> "phero"; 1 -> "dchips"; else -> focusedLane?.id.orEmpty() }
val isCard: Boolean get() = title == null && focusedRow >= firstShelf && focusedLane != null && focusedLane?.pending != true
val contentFocused: Boolean get() = !shell.navFocused && !shell.pickerVisible && overlay == null
@ -152,7 +166,8 @@ class DiscoverState(
fun focus(row: Int, column: Int = 0) {
shell.navFocused = false; shell.view.row = row
shell.view.cards[rowKey] = column.coerceIn(0, maxColumn())
val selected = column.coerceIn(0, maxColumn())
if (focusedRow >= firstShelf) laneColumns[rowKey] = selected else shell.view.cards[rowKey] = selected
}
private fun moveRow(direction: Int) {
@ -161,10 +176,7 @@ class DiscoverState(
if (target < if (hasHero) 0 else 1) { shell.focusNav(shell.currentTab); return }
if (target >= rowCount) return
val key = when (target) { 0 -> "phero"; 1 -> "dchips"; else -> lanes[target - firstShelf].id }
val nearest = if (focusedRow >= firstShelf && target >= firstShelf)
column - shell.view.cards["first:$rowKey"].orZero() + shell.view.cards["first:$key"].orZero()
else 0
focus(target, shell.view.cards[key] ?: nearest.coerceAtLeast(0))
focus(target, if (target >= firstShelf) laneColumn(key) else shell.view.cards[key].orZero())
}
fun openTitle(item: DiscoverTitle) {
@ -225,12 +237,14 @@ class DiscoverState(
fun isPick(item: DiscoverTitle): Boolean = snapshot.picks.any { it.key == item.key } || isHidden(item)
fun openService(item: DiscoverService) {
serviceLaneMemory.getOrPut(item.id) { DiscoverLaneMemory() }
rootFilter = filter; service = item; filter = "movie"; revision++
onPush("discover-service/${item.id}")
focus(firstShelf)
}
fun enterRoute(route: String) {
if (route in shell.tabs && route != "discover") resetLaneMemory()
if (route == "discover") { title = null; collection = null; if (service != null) filter = rootFilter; service = null }
else if (route.startsWith("discover-service") || route.startsWith("discover-see-all")) title = null
}
@ -261,6 +275,7 @@ class DiscoverState(
ShellKey.Left, ShellKey.Right -> {
val direction = if (key == ShellKey.Left) -1 else 1
if (focusedRow == 0) slide = (slide + direction).coerceIn(0, (heroes.size - 1).coerceAtLeast(0))
else if (focusedRow >= firstShelf) laneColumns[rowKey] = (column + direction).coerceIn(0, maxColumn())
else shell.view.cards[rowKey] = (column + direction).coerceIn(0, maxColumn())
}
ShellKey.Ok -> when {
@ -417,6 +432,12 @@ class DiscoverState(
}
}
private class DiscoverLaneMemory {
val columns = mutableStateMapOf<String, Int>()
val firsts = mutableStateMapOf<String, Int>()
fun clear() { columns.clear(); firsts.clear() }
}
private fun Int?.orZero(): Int = this ?: 0
private val DISCOVER_FILTERS = listOf("all", "movie", "tv")

187
wolfskin-design/src/main/java/org/justinvisser/wolfskin/design/HeroMotion.kt
View file

@ -6,95 +6,156 @@ import androidx.compose.foundation.layout.Box
import androidx.compose.foundation.layout.requiredSize
import androidx.compose.foundation.layout.wrapContentSize
import androidx.compose.runtime.Composable
import androidx.compose.runtime.CompositionLocalProvider
import androidx.compose.runtime.LaunchedEffect
import androidx.compose.runtime.SideEffect
import androidx.compose.runtime.compositionLocalOf
import androidx.compose.runtime.getValue
import androidx.compose.runtime.key
import androidx.compose.runtime.mutableStateListOf
import androidx.compose.runtime.mutableStateOf
import androidx.compose.runtime.remember
import androidx.compose.runtime.rememberUpdatedState
import androidx.compose.runtime.saveable.rememberSaveable
import androidx.compose.runtime.setValue
import androidx.compose.runtime.snapshotFlow
import androidx.compose.ui.Alignment
import androidx.compose.ui.Modifier
import androidx.compose.ui.graphics.graphicsLayer
import androidx.compose.ui.unit.Dp
import androidx.compose.ui.platform.LocalDensity
import androidx.compose.ui.platform.testTag
import org.justinvisser.wolfskin.design.WolfskinTokens.Motion as M
import kotlinx.coroutines.launch
import androidx.compose.runtime.CompositionLocalProvider
import androidx.compose.runtime.compositionLocalOf
import androidx.compose.runtime.rememberUpdatedState
import androidx.compose.runtime.snapshotFlow
import androidx.compose.ui.semantics.SemanticsPropertyKey
import androidx.compose.ui.semantics.semantics
import androidx.compose.ui.unit.Dp
import kotlinx.coroutines.coroutineScope
import kotlinx.coroutines.flow.first
import kotlinx.coroutines.flow.collectLatest
import kotlinx.coroutines.flow.distinctUntilChangedBy
import kotlinx.coroutines.flow.filterNotNull
import kotlinx.coroutines.launch
import org.justinvisser.wolfskin.design.WolfskinTokens.Motion as M
/** Artwork success or its final fallback releases a pending hero hand-off. */
internal val LocalHeroArtReady = compositionLocalOf<(() -> Unit)?> { null }
internal val HeroLayerAlpha = SemanticsPropertyKey<Float>("HeroLayerAlpha")
internal val HeroLayerTranslation = SemanticsPropertyKey<Float>("HeroLayerTranslation")
internal val HeroLayerIdentity = SemanticsPropertyKey<String>("HeroLayerIdentity")
/** Only the upper hero region blends; the lower backdrop changes without an animated screen layer. */
private class HeroPresentation {
var identity by mutableStateOf<Any?>(null)
}
private val LocalHeroPresentation = compositionLocalOf<HeroPresentation?> { null }
/** Artwork and copy share readiness without coupling either layer to a screen's selection state. */
@Composable
internal fun HeroMotionScope(content: @Composable () -> Unit) {
val presentation = remember { HeroPresentation() }
CompositionLocalProvider(LocalHeroPresentation provides presentation, content = content)
}
private class HeroLayer<T>(val identity: Any, var target: T, initialAlpha: Float) {
val alpha = Animatable(initialAlpha)
var ready by mutableStateOf(false)
var presented = false
var outgoing by mutableStateOf(false)
}
private class HeroCopyTarget<T>(val identity: Any, var target: T)
/** Keep the painted composite while loading; interruptions fade each retained layer from its current alpha. */
@Composable
fun <T> HeroArtCrossfade(identity: Any, target: T, height: Dp, modifier: Modifier = Modifier, content: @Composable (T) -> Unit) {
var displayed by remember { mutableStateOf(target) }
var displayedIdentity by remember { mutableStateOf(identity) }
var outgoing by remember { mutableStateOf<T?>(null) }
val alpha = remember { Animatable(0f) }
val initial = remember { HeroLayer(identity, target, 1f).apply { presented = true } }
val layers = remember { mutableStateListOf(initial) }
val selected = remember(identity) { layers.firstOrNull { it.identity == identity && it.presented && !it.outgoing } ?: HeroLayer(identity, target, 1f) }
val reduced = reducedMotion()
var readyIdentity by remember { mutableStateOf(identity) }
val latestIdentity by rememberUpdatedState(identity)
val onReady = remember(identity) { { if (latestIdentity == identity) readyIdentity = identity } }
LaunchedEffect(identity, reduced) {
if (displayedIdentity != identity) {
outgoing = displayed
alpha.snapTo(1f)
snapshotFlow { readyIdentity == identity }.first { it }
displayed = target
displayedIdentity = identity
}
if (outgoing != null) {
alpha.animateTo(0f, tween(motionDuration(M.heroFade, reduced), easing = M.easeInOut))
outgoing = null
}
val presentation = LocalHeroPresentation.current
LaunchedEffect(selected, reduced) {
layers.removeAll { it !== selected && !it.presented }
if (selected !in layers) layers.add(0, selected)
snapshotFlow { selected.ready }.first { it }
selected.presented = true
presentation?.identity = identity
layers.forEach { if (it !== selected) it.outgoing = true }
}
Box(modifier) {
CompositionLocalProvider(LocalHeroArtReady provides onReady) { content(target) }
outgoing?.let { old ->
Box(Modifier.requiredSize(WolfskinTokens.Shell.stageWidth, height).graphicsLayer { this.alpha = alpha.value; clip = true }.testTag("hero-outgoing")) {
Box(Modifier.wrapContentSize(Alignment.TopStart, unbounded = true).requiredSize(WolfskinTokens.Shell.stageWidth, WolfskinTokens.Shell.stageHeight)) { content(old) }
layers.forEach { layer -> key(layer) {
SideEffect { if (layer.identity == identity) layer.target = target }
LaunchedEffect(layer.outgoing, reduced) {
if (layer.outgoing) {
layer.alpha.animateTo(0f, tween(motionDuration(M.heroFade, reduced), easing = M.easeInOut))
layers.remove(layer)
}
}
}
val outgoing = layer.outgoing
val onReady = remember(layer) { { layer.ready = true } }
val bounds = if (outgoing) Modifier.requiredSize(WolfskinTokens.Shell.stageWidth, height) else Modifier
Box(bounds.graphicsLayer { alpha = layer.alpha.value; clip = outgoing }
.testTag(if (outgoing) "hero-outgoing" else "hero-incoming")
.semantics { this[HeroLayerAlpha] = layer.alpha.value; this[HeroLayerTranslation] = 0f; this[HeroLayerIdentity] = layer.identity.toString() }) {
CompositionLocalProvider(LocalHeroArtReady provides onReady) {
Box(Modifier.wrapContentSize(Alignment.TopStart, unbounded = true).requiredSize(WolfskinTokens.Shell.stageWidth, WolfskinTokens.Shell.stageHeight)) {
content(if (layer.identity == identity) target else layer.target)
}
}
}
} }
}
}
/** One bounded copy layer fades out, hands off, then rises; controls keep their logical owner. */
/** One copy slot fades through after artwork readiness; no two titles can be painted together. */
@Composable
fun <T> HeroCopyHandoff(identity: Any, target: T, modifier: Modifier = Modifier, content: @Composable (T) -> Unit) {
val reduced = reducedMotion()
val alpha = remember { Animatable(0f) }
val progress = remember { Animatable(0f) }
var displayed by remember { mutableStateOf(target) }
var previous by remember { mutableStateOf(identity) }
var entered by rememberSaveable { mutableStateOf(false) }
val selected = remember(identity) { HeroCopyTarget(identity, target) }
val currentSelected by rememberUpdatedState(selected)
var displayed by remember { mutableStateOf(selected) }
val alpha = remember { Animatable(if (entered) 1f else 0f) }
val progress = remember { Animatable(if (entered) 1f else 0f) }
var initialEntry by remember { mutableStateOf(!entered) }
var handingOff by remember { mutableStateOf(false) }
var entered by remember { mutableStateOf(false) }
val rise = with(androidx.compose.ui.platform.LocalDensity.current) { (if (entered) M.copyRise else M.copyEntryRise).toPx() }
LaunchedEffect(identity, reduced) {
if (previous != identity || handingOff) {
handingOff = true
alpha.animateTo(0f, tween(motionDuration(M.heroCopyOut, reduced), easing = M.ease))
displayed = target
previous = identity
progress.snapTo(0f)
if (!reduced) kotlinx.coroutines.delay((M.heroCopyDelay - M.heroCopyOut).toLong())
kotlinx.coroutines.coroutineScope {
launch { alpha.animateTo(1f, tween(motionDuration(M.heroCopyIn, reduced), easing = M.easeOut)) }
launch { progress.animateTo(1f, tween(motionDuration(M.heroCopyIn, reduced), easing = M.easeOut)) }
var outgoing by remember { mutableStateOf(false) }
val reduced = reducedMotion()
val presentation = LocalHeroPresentation.current
val rise = with(LocalDensity.current) { (if (initialEntry) M.copyEntryRise else M.copyRise).toPx() }
SideEffect { selected.target = target }
LaunchedEffect(presentation, reduced) {
snapshotFlow { currentSelected.takeIf { presentation == null || presentation.identity == it.identity } }
.filterNotNull()
.distinctUntilChangedBy { it.identity }
.collectLatest { next ->
if (!entered) {
displayed = next
entered = true
} else if (displayed.identity != next.identity || handingOff) {
handingOff = true
outgoing = true
coroutineScope {
val fade = if (alpha.value > 0f) launch {
alpha.animateTo(0f, tween(motionDuration(M.heroCopyOut, reduced), easing = M.ease))
} else null
if (!reduced) kotlinx.coroutines.delay(M.heroCopyDelay.toLong())
fade?.join()
}
outgoing = false
displayed = next
initialEntry = false
progress.snapTo(0f)
}
if (alpha.value != 1f || progress.value != 1f) coroutineScope {
val duration = motionDuration(if (initialEntry) M.rowEnter else M.heroCopyIn, reduced)
launch { alpha.animateTo(1f, tween(duration, easing = M.easeOut)) }
launch { progress.animateTo(1f, tween(duration, easing = M.easeOut)) }
}
handingOff = false
}
handingOff = false
} else if (!entered) {
kotlinx.coroutines.coroutineScope {
launch { alpha.animateTo(1f, tween(motionDuration(M.rowEnter, reduced), easing = M.easeOut)) }
launch { progress.animateTo(1f, tween(motionDuration(M.rowEnter, reduced), easing = M.easeOut)) }
}
}
entered = true
displayed = target
}
Box(modifier.graphicsLayer { this.alpha = alpha.value; translationY = if (reduced) 0f else rise * (1f - progress.value) }) {
content(if (handingOff || previous != identity) displayed else target)
}
Box(modifier.graphicsLayer {
this.alpha = alpha.value
translationY = if (reduced) 0f else rise * (1f - progress.value)
}.testTag(if (outgoing) "hero-copy-outgoing" else "hero-copy").semantics {
this[HeroLayerAlpha] = alpha.value
this[HeroLayerTranslation] = if (reduced) 0f else rise * (1f - progress.value)
this[HeroLayerIdentity] = displayed.identity.toString()
}) { content(if (displayed.identity == identity) target else displayed.target) }
}

8
wolfskin-design/src/main/java/org/justinvisser/wolfskin/design/HomeHeader.kt
View file

@ -20,6 +20,7 @@ import org.justinvisser.wolfskin.design.HomeType as T
/** The hero occupies one row while its backdrop extends beneath the first shelves. */
@Composable
fun HomeHero(row: HomeRow, focused: Boolean, column: Int, ratings: List<HomeRating>, onButton: (Int) -> Unit, onHover: (Int) -> Unit) {
HeroMotionScope {
Box(Modifier.fillMaxWidth().height(L.row_hero)) {
if (!row.skeleton) {
val title = row.cards.first()
@ -29,7 +30,8 @@ fun HomeHero(row: HomeRow, focused: Boolean, column: Int, ratings: List<HomeRati
}
Box(artModifier.background(Brush.verticalGradient(0f to C.bg.copy(alpha = 0f), .52f to C.bg.copy(alpha = 0f), .74f to C.bg.copy(alpha = .6f), 1f to C.bg)))
Box(artModifier.background(Brush.horizontalGradient(0f to C.bg.copy(alpha = .92f), .42f to C.bg.copy(alpha = .55f), .70f to C.bg.copy(alpha = 0f))))
HeroCopyHandoff(title.id, title, Modifier.align(Alignment.BottomStart).padding(start = L.safeSide, bottom = L.heroCopyBottom).width(L.heroCopyWidth)) { copy ->
Column(Modifier.align(Alignment.BottomStart).padding(start = L.safeSide, bottom = L.heroCopyBottom).width(L.heroCopyWidth)) {
HeroCopyHandoff(title.id, title) { copy ->
Column {
Row(verticalAlignment = Alignment.CenterVertically, horizontalArrangement = Arrangement.spacedBy(H.kickerGap)) {
Glyph(if (row.heroKind == "pick") "seerr" else "playback", C.accentText, Modifier.size(L.buttonIcon * (28f / 30f)))
@ -45,6 +47,8 @@ fun HomeHero(row: HomeRow, focused: Boolean, column: Int, ratings: List<HomeRati
}
Spacer(Modifier.height(H.factsBottom))
Text(copy.overview, color = C.muted, style = T.body, maxLines = 2, overflow = TextOverflow.Ellipsis, modifier = Modifier.width(L.heroOverviewMax).exactLineBox(T.body))
}
}
Spacer(Modifier.height(H.overviewBottom))
Row(horizontalArrangement = Arrangement.spacedBy(L.buttonGap)) {
val detailsOnly = row.heroKind == "pick"
@ -64,7 +68,6 @@ fun HomeHero(row: HomeRow, focused: Boolean, column: Int, ratings: List<HomeRati
PickerButton("Details", focused && column == detailsColumn, detailsOnly, "about", onFocus = { onHover(detailsColumn) }, textStyle = T.button) { onButton(detailsColumn) }
}
}
}
} else {
HomeAmbient(Modifier.wrapContentSize(Alignment.TopStart, unbounded = true).requiredSize(WolfskinTokens.Shell.stageWidth, WolfskinTokens.Shell.stageHeight))
Column(Modifier.align(Alignment.BottomStart).padding(start = L.safeSide, bottom = L.heroCopyBottom).skeletonPulse()) {
@ -76,6 +79,7 @@ fun HomeHero(row: HomeRow, focused: Boolean, column: Int, ratings: List<HomeRati
}
}
}
}
}
/** Discover continues in the same scroller, under the active person's identity. */

5
wolfskin-design/src/main/java/org/justinvisser/wolfskin/design/TitleArtwork.kt
View file

@ -37,6 +37,8 @@ import androidx.compose.ui.text.style.TextAlign
import androidx.compose.ui.text.style.TextOverflow
import androidx.tv.material3.Text
import coil3.compose.AsyncImage
import coil3.request.transitionFactory
import coil3.transition.Transition
import org.justinvisser.wolfskin.design.WolfskinTokens.Color as C
import org.justinvisser.wolfskin.design.WolfskinTokens.Layout as L
import org.justinvisser.wolfskin.design.WolfskinTokens.Title as D
@ -55,8 +57,9 @@ fun TitleArtwork(path: String?, width: Int, height: Int, modifier: Modifier = Mo
}
else if (path != null) {
val context = LocalContext.current
val request = remember(context, path, width, height, poster) {
val request = remember(context, path, width, height, poster, heroReady != null) {
WolfskinImages.request(context, path, width, height, poster)
.let { if (heroReady != null) it.newBuilder().transitionFactory(Transition.Factory.NONE).build() else it }
}
AsyncImage(model = request, imageLoader = WolfskinImages.loader(context),
contentDescription = null, modifier = modifier, contentScale = ContentScale.Crop, colorFilter = colorFilter,

3
wolfskin-design/src/main/java/org/justinvisser/wolfskin/design/TitlePage.kt
View file

@ -54,7 +54,7 @@ fun TitleSurface(state: TitleState, shell: ShellState, modifier: Modifier = Modi
val view = screenView(shell)
LaunchedEffect(view, state.data.savedAt) { view.savedAt = state.data.savedAt }
Box(modifier.fillMaxSize().onPreviewKeyEvent { event ->
// No content target exists during an initial load; nav Down must not enter a skeleton.
// No content target exists during an initial load; Down must not enter a skeleton.
if (state.data.status != TitleReadStatus.Loading || shell.pickerVisible || shell.requestsVisible) false
else when (readShellKey(event)) {
ShellKey.Down -> true
@ -133,7 +133,6 @@ fun TitlePage(state: TitleState, shell: ShellState, modifier: Modifier = Modifie
}
LaunchedEffect(state.row, shell.navFocused, state.data.status, displayedRows, rowOffsets) {
if (compensateHeader) return@LaunchedEffect
if (state.data.status == TitleReadStatus.Loading) shell.focusNav(shell.currentTab)
val index = if (shell.navFocused) 0 else displayedRows.indexOf(state.row).coerceAtLeast(0)
val y = rowOffsets[index]
val height = with(density) { titleRowHeight(state.row, headerHeight).toPx() }

65
wolfskin-design/src/test/java/org/justinvisser/wolfskin/design/DiscoverDetailsFocusTest.kt Normal file
View file

@ -0,0 +1,65 @@
package org.justinvisser.wolfskin.design
import android.app.Application
import androidx.activity.ComponentActivity
import androidx.compose.foundation.layout.requiredSize
import androidx.compose.runtime.CompositionLocalProvider
import androidx.compose.ui.graphics.asImageBitmap
import androidx.compose.ui.Modifier
import androidx.compose.ui.input.key.Key
import androidx.compose.ui.test.*
import androidx.compose.ui.test.junit4.createAndroidComposeRule
import kotlinx.coroutines.CoroutineScope
import kotlinx.coroutines.Dispatchers
import org.junit.Assert.*
import org.junit.Rule
import org.junit.Test
import org.junit.runner.RunWith
import org.robolectric.RobolectricTestRunner
import org.robolectric.annotation.GraphicsMode
import org.robolectric.annotation.Config
/** A catalogue read has no right to move the destination's focus into the root navigation. */
@RunWith(RobolectricTestRunner::class)
@Config(sdk = [34], application = Application::class, qualifiers = "w960dp-h540dp-xhdpi")
@GraphicsMode(GraphicsMode.Mode.NATIVE)
class DiscoverDetailsFocusTest {
@get:Rule val rule = createAndroidComposeRule<ComponentActivity>()
@Test fun heroDetailsRetainsDestinationFocusDuringLoadingAndLateMetadata() {
rule.mainClock.autoAdvance = false
val shell = ShellState(fixturePeople(), "justin").apply { pickerVisible = false; enterDestination("discover") }
val snapshot = discoverTestFixture().snapshot("justin")
val discover = DiscoverState(shell, snapshot, RecordingDiscoverOperations(snapshot, "justin"), CoroutineScope(Dispatchers.Main.immediate), shell::enterDestination)
val selected = requireNotNull(discover.hero)
val title = TitleState(TitlePageData(TitleItem(selected.key, selected.title, selected.type), status = TitleReadStatus.Loading), shell.person) {}
val art = android.graphics.Bitmap.createBitmap(8, 8, android.graphics.Bitmap.Config.ARGB_8888).apply { eraseColor(android.graphics.Color.DKGRAY) }.asImageBitmap()
rule.setContent { WolfskinTheme {
CompositionLocalProvider(LocalDiscoverArt provides { art }) {
val modifier = Modifier.requiredSize(WolfskinTokens.Shell.stageWidth, WolfskinTokens.Shell.stageHeight)
if (shell.route.startsWith("title/")) TitleSurface(title, shell, modifier)
else ShellSurface(shell, modifier) { DiscoverScreen(discover, it) }
}
} }
rule.mainClock.advanceTimeBy(640)
rule.onNodeWithTag("wolfskin-shell").performKeyInput { pressKey(Key.DirectionCenter) }
repeat(6) {
rule.mainClock.advanceTimeBy(16)
rule.waitForIdle()
assertFalse("Loading cannot steal destination focus on a later frame", shell.navFocused)
}
assertEquals("title/${android.net.Uri.encode(selected.key)}", shell.route)
assertFalse("The destination owns focus even while its read is pending", shell.navFocused)
rule.onRoot().performKeyInput { pressKey(Key.DirectionDown) }
assertFalse("Down on a loading title must not enter nav or a skeleton", shell.navFocused)
rule.runOnIdle { title.update(title.data.copy(status = TitleReadStatus.Ready)) }
rule.mainClock.advanceTimeBy(640)
val before = rule.onNodeWithTag("title-actions").fetchSemanticsNode().boundsInRoot
rule.runOnIdle { title.update(title.data.copy(item = title.data.item.copy(overview = "Late overview", ratings = listOf(LibraryRating("rt", 88.0))))) }
repeat(24) {
rule.mainClock.advanceTimeBy(16)
assertFalse(shell.navFocused)
assertEquals("Loaded actions cannot replay their entry or move after late metadata", before, rule.onNodeWithTag("title-actions").fetchSemanticsNode().boundsInRoot)
}
}
}

272
wolfskin-design/src/test/java/org/justinvisser/wolfskin/design/DiscoverHeroSequenceTest.kt Normal file
View file

@ -0,0 +1,272 @@
package org.justinvisser.wolfskin.design
import android.app.Application
import android.graphics.Bitmap
import android.graphics.BitmapFactory
import android.view.View
import android.view.WindowManager
import androidx.activity.ComponentActivity
import androidx.compose.foundation.layout.requiredSize
import androidx.compose.runtime.CompositionLocalProvider
import androidx.compose.runtime.mutableStateOf
import androidx.compose.runtime.saveable.rememberSaveableStateHolder
import androidx.compose.ui.Modifier
import androidx.compose.ui.graphics.asImageBitmap
import androidx.compose.ui.input.key.Key
import androidx.compose.ui.semantics.SemanticsProperties
import androidx.compose.ui.test.*
import androidx.compose.ui.test.junit4.createAndroidComposeRule
import coil3.intercept.Interceptor
import coil3.request.ErrorResult
import com.github.takahirom.roborazzi.captureRoboImage
import kotlinx.coroutines.CoroutineScope
import kotlinx.coroutines.Dispatchers
import kotlinx.coroutines.awaitCancellation
import org.json.JSONArray
import org.json.JSONObject
import org.junit.Assert.*
import org.junit.Rule
import org.junit.Test
import org.junit.runner.RunWith
import org.robolectric.RobolectricTestRunner
import org.robolectric.annotation.Config
import org.robolectric.annotation.GraphicsMode
import java.io.File
import java.io.IOException
/** Real Discover artwork, copy and pager are sampled on every manually advanced native frame. */
@RunWith(RobolectricTestRunner::class)
@Config(sdk = [34], application = Application::class, qualifiers = "w960dp-h540dp-xhdpi")
@GraphicsMode(GraphicsMode.Mode.NATIVE)
class DiscoverHeroSequenceTest {
@get:Rule val rule = createAndroidComposeRule<ComponentActivity>()
private val samples = JSONArray()
private lateinit var directory: File
private lateinit var state: DiscoverState
private lateinit var shell: ShellState
private val artAvailable = mutableStateOf(true)
private val reduced = mutableStateOf(false)
private var previousPixel: Int? = null
private val mounted = mutableStateOf(true)
private var lowerPixel = 0
private var largestJump = 0
private var previousLayers = emptyMap<String, Pair<Float, Float>>()
private val previousDotWidths = mutableMapOf<Int, Float>()
private var previousSelection: Int? = null
private fun launch(scenario: String, failedArt: Boolean = false, settle: Boolean = true) {
directory = File(System.getProperty("wolfskin.captureDirectory"), "discover-hero/$scenario").apply { mkdirs() }
rule.activity.window.setFlags(WindowManager.LayoutParams.FLAG_FULLSCREEN, WindowManager.LayoutParams.FLAG_FULLSCREEN)
@Suppress("DEPRECATION")
rule.activity.window.decorView.systemUiVisibility = View.SYSTEM_UI_FLAG_FULLSCREEN or View.SYSTEM_UI_FLAG_HIDE_NAVIGATION or View.SYSTEM_UI_FLAG_IMMERSIVE_STICKY
rule.mainClock.autoAdvance = false
WolfskinImages.configureNetwork(rule.activity) { add(Interceptor { chain ->
if (chain.request.data.toString().startsWith("sequence:")) {
if (failedArt) ErrorResult(image = null, request = chain.request, throwable = IOException("Controlled artwork failure")) else awaitCancellation()
} else chain.proceed()
}) }
val fixture = discoverTestFixture()
val colors = listOf(android.graphics.Color.RED, android.graphics.Color.BLUE, android.graphics.Color.GREEN)
val titles = fixture.snapshot("justin").picks.take(3).mapIndexed { index, title ->
title.copy(backdrop = "sequence:$index", poster = null, posterOnly = false, score = 100.0 - index)
}
val art = colors.map { color -> Bitmap.createBitmap(8, 8, Bitmap.Config.ARGB_8888).apply { eraseColor(color) }.asImageBitmap() }
val snapshot = fixture.snapshot("justin").copy(picks = titles)
shell = ShellState(fixturePeople(), "justin").apply { pickerVisible = false; enterDestination("discover") }
state = DiscoverState(shell, snapshot, RecordingDiscoverOperations(snapshot, "justin"), CoroutineScope(Dispatchers.Main.immediate), shell::enterDestination)
rule.setContent { WolfskinTheme {
val saved = rememberSaveableStateHolder()
CompositionLocalProvider(LocalReducedMotion provides reduced.value, LocalDiscoverArt provides { path ->
path.removePrefix("sequence:").toIntOrNull()?.let { if (it != 1 || artAvailable.value) art[it] else null }
}) {
ShellSurface(shell, Modifier.requiredSize(WolfskinTokens.Shell.stageWidth, WolfskinTokens.Shell.stageHeight)) { modifier ->
if (mounted.value) saved.SaveableStateProvider("discover") { DiscoverScreen(state, modifier) }
}
}
} }
if (settle) rule.mainClock.advanceTimeBy(640) else rule.mainClock.advanceTimeByFrame()
}
@Test fun initialCopyEntersOnceAndDoesNotReplayOnDestinationRemount() {
launch("initial", settle = false)
sample("initial", 0)
fun copy() = rule.onAllNodes(SemanticsMatcher.keyIsDefined(HeroLayerAlpha), useUnmergedTree = true)
.fetchSemanticsNodes().single { it.config[SemanticsProperties.TestTag].startsWith("hero-copy") }
assertEquals(0f, copy().config[HeroLayerAlpha], .001f)
assertEquals(with(rule.density) { WolfskinTokens.Motion.copyEntryRise.toPx() }, copy().config[HeroLayerTranslation], .001f)
frames("entry", 16)
assertEquals(1f, copy().config[HeroLayerAlpha], .001f)
rule.runOnIdle { mounted.value = false }
frames("absent", 1)
rule.runOnIdle { mounted.value = true }
repeat(8) { frame ->
rule.mainClock.advanceTimeBy(16)
sample("remount", frame)
assertEquals("Returning to a saved destination cannot replay its entrance", 1f, copy().config[HeroLayerAlpha], .001f)
assertEquals(0f, copy().config[HeroLayerTranslation], .001f)
}
finish()
}
@Test fun interruptedHeroNeverSnapsToAnIntermediateSelection() {
launch("interrupted")
sample("settled", 0)
press(Key.DirectionRight)
frames("first", 12)
press(Key.DirectionRight)
frames("interrupted", 28)
press(Key.DirectionLeft)
frames("reverse", 28)
finish()
assertSmoothPixels()
assertEquals(1, state.slide)
}
@Test fun slowArtRetainsBothThePaintedHeroAndItsCopyUntilReady() {
launch("slow")
sample("settled", 0)
val original = previousPixel
val originalLower = lowerPixel
rule.runOnIdle { artAvailable.value = false }
press(Key.DirectionRight)
repeat(24) { frame ->
rule.mainClock.advanceTimeBy(16)
sample("pending", frame)
assertEquals("Pending art cannot expose a placeholder beneath the hero", originalLower, lowerPixel)
}
assertEquals("Pending art must not replace the painted backdrop", original, previousPixel)
assertEquals(state.heroes.first().key, copyIdentities().single())
rule.runOnIdle { artAvailable.value = true }
frames("ready", 28)
finish()
assertSmoothPixels()
assertEquals(state.hero!!.key, copyIdentities().single())
}
@Test fun failedArtBlendsToItsFinalFallbackWithoutErasingThePreviousHero() {
launch("failed", failedArt = true)
sample("settled", 0)
rule.runOnIdle { artAvailable.value = false }
press(Key.DirectionRight)
frames("fallback", 28)
rule.onNodeWithTag("discover-missing-art").assertExists()
finish()
assertSmoothPixels()
assertEquals(state.hero!!.key, copyIdentities().single())
}
@Test fun repeatedPressesRetargetTheCurrentCompositeWithoutSnapBack() {
launch("rapid")
sample("settled", 0)
listOf(Key.DirectionRight, Key.DirectionRight, Key.DirectionLeft, Key.DirectionLeft, Key.DirectionRight, Key.DirectionRight).forEachIndexed { index, key ->
press(key)
frames("press-$index", 3)
}
repeat(48) { index ->
press(if (index % 2 == 0) Key.DirectionLeft else Key.DirectionRight)
frames("burst-$index", 1)
}
frames("settled-latest", 28)
finish()
assertSmoothPixels()
assertEquals(state.hero!!.key, copyIdentities().single())
}
@Test fun reducedMotionKeepsTheBlendButRemovesCopyTranslation() {
launch("reduced")
rule.runOnIdle { reduced.value = true }
press(Key.DirectionRight)
frames("reduced", (WolfskinTokens.Motion.heroFade + 15) / 16)
finish()
assertEquals(state.hero!!.key, copyIdentities().single())
assertEquals(1, rule.onAllNodesWithTag("hero-incoming", useUnmergedTree = true).fetchSemanticsNodes().size)
assertTrue(rule.onAllNodesWithTag("hero-outgoing", useUnmergedTree = true).fetchSemanticsNodes().isEmpty())
val moving = (0 until samples.length()).map(samples::getJSONObject).filter { row ->
val layers = row.getJSONArray("layers")
(0 until layers.length()).map(layers::getJSONObject).any {
it.getString("kind") == "hero-outgoing" && it.getDouble("alpha") > 0.0 && it.getDouble("alpha") < 1.0
}
}.map { it.getLong("timeMs") }
assertTrue("Reduced artwork fade cannot retain the ordinary 320ms lifetime", moving.last() - moving.first() <= WolfskinTokens.Motion.reducedFade)
}
private fun copyIdentities() = rule.onAllNodesWithTag("hero-copy", useUnmergedTree = true).fetchSemanticsNodes().map { it.config[HeroLayerIdentity] }
private fun press(key: Key) = rule.onNodeWithTag("wolfskin-shell").performKeyInput { keyDown(key); keyUp(key) }
private fun frames(phase: String, count: Int) = repeat(count) { index -> rule.mainClock.advanceTimeBy(16); sample(phase, index) }
private fun finish() = File(directory, "series.json").writeText(samples.toString(2))
private fun assertSmoothPixels() = assertTrue("A 16ms hero frame cannot snap to a full intermediate selection; largest channel jump=$largestJump", largestJump <= 48)
private fun sample(phase: String, index: Int) {
rule.waitForIdle()
val file = File(directory, "$phase-${index.toString().padStart(2, '0')}.png")
rule.onRoot().captureRoboImage(file.absolutePath)
val bitmap = BitmapFactory.decodeFile(file.absolutePath)
val pixel = try {
lowerPixel = bitmap.getPixel(1600, 800)
bitmap.getPixel(1600, 200)
} finally { bitmap.recycle() }
val channels = channels(pixel)
previousPixel?.let { old -> largestJump = maxOf(largestJump, channels.zip(channels(old)).maxOf { (a, b) -> kotlin.math.abs(a - b) }) }
previousPixel = pixel
val copy = JSONArray()
state.heroes.forEach { title -> rule.onAllNodesWithText(title.title, useUnmergedTree = true).fetchSemanticsNodes().forEach { node ->
copy.put(JSONObject().put("title", title.key).put("x", node.boundsInRoot.left).put("y", node.boundsInRoot.top))
} }
val layers = layerSamples()
val dots = JSONArray()
state.heroes.indices.forEach { dot -> rule.onAllNodesWithTag("hero-dot-$dot", useUnmergedTree = true).fetchSemanticsNodes().forEach { node ->
previousDotWidths[dot]?.let { previous ->
val range = with(rule.density) { (WolfskinTokens.Discover.dotActive - WolfskinTokens.Discover.dotSize).toPx() }
if (!reduced.value) assertTrue("Pager retarget must not snap a full dot-width step", kotlin.math.abs(node.boundsInRoot.width - previous) <= range / 2)
if (reduced.value) {
val rest = with(rule.density) { WolfskinTokens.Discover.dotSize.toPx() }
assertTrue("Reduced motion snaps pager geometry instead of moving it", node.boundsInRoot.width == rest || node.boundsInRoot.width == rest + range)
}
if (previousSelection == state.slide) {
if (dot == state.slide) assertTrue("The selected pager dot cannot shrink backwards", node.boundsInRoot.width >= previous - .01f)
else assertTrue("An outgoing pager dot cannot grow backwards", node.boundsInRoot.width <= previous + .01f)
}
}
previousDotWidths[dot] = node.boundsInRoot.width
dots.put(JSONObject().put("index", dot).put("x", node.boundsInRoot.left).put("y", node.boundsInRoot.top).put("width", node.boundsInRoot.width))
} }
previousSelection = state.slide
samples.put(JSONObject().put("phase", phase).put("frame", index).put("timeMs", rule.mainClock.currentTime)
.put("selection", state.slide).put("mounted", mounted.value).put("rgb", JSONArray(channels)).put("lowerRgb", JSONArray(channels(lowerPixel))).put("copy", copy).put("layers", layers).put("dots", dots).put("navFocused", shell.navFocused))
}
private fun layerSamples(): JSONArray {
val result = JSONArray()
val current = mutableMapOf<String, Pair<Float, Float>>()
val nodes = rule.onAllNodes(SemanticsMatcher.keyIsDefined(HeroLayerAlpha), useUnmergedTree = true).fetchSemanticsNodes()
val unique = nodes.groupBy { it.config[SemanticsProperties.TestTag] + ":" + it.id }
if (mounted.value) assertTrue("The artwork composite always has an opaque base", nodes.any { it.config[SemanticsProperties.TestTag] == "hero-incoming" && it.config[HeroLayerAlpha] == 1f })
val visibleCopy = nodes.count { it.config[SemanticsProperties.TestTag].startsWith("hero-copy") && it.config[HeroLayerAlpha] > 0f }
assertTrue("Sequential copy cannot paint overlapping titles, including interruptions", visibleCopy <= 1)
val artCount = nodes.count { !it.config[SemanticsProperties.TestTag].startsWith("hero-copy") }
assertTrue("Sustained presses cannot extend outgoing art lifetimes", artCount <= (WolfskinTokens.Motion.heroFade + 15) / 16 + 3)
unique.forEach { (key, matching) -> matching.forEach { node ->
val alpha = node.config[HeroLayerAlpha]
val translation = node.config[HeroLayerTranslation]
val tag = node.config[SemanticsProperties.TestTag]
if (matching.size == 1) {
previousLayers[key]?.let { (previousAlpha, previousTranslation) ->
if (tag == "hero-outgoing" || tag == "hero-copy-outgoing") assertTrue("Outgoing layers cannot restart at full opacity: $key", alpha <= previousAlpha + .001f)
if (tag == "hero-copy-outgoing" && alpha > 0f) assertEquals("Visible outgoing copy must fade where its entry stopped", previousTranslation, translation, .001f)
if (tag == "hero-copy") {
assertTrue("Copy alpha cannot snap backwards: $key", alpha >= previousAlpha - .001f)
if (alpha > 0f && previousAlpha > 0f) assertTrue("Visible copy translation cannot snap backwards", translation <= previousTranslation + .001f)
}
}
current[key] = alpha to translation
}
if (reduced.value) assertEquals(0f, translation, .001f)
result.put(JSONObject().put("kind", tag).put("identity", node.config[HeroLayerIdentity]).put("layerId", node.id).put("alpha", alpha)
.put("translationY", translation).put("x", node.boundsInRoot.left).put("y", node.boundsInRoot.top))
} }
previousLayers = current
return result
}
private fun channels(pixel: Int) = listOf(android.graphics.Color.red(pixel), android.graphics.Color.green(pixel), android.graphics.Color.blue(pixel))
}

72
wolfskin-design/src/test/java/org/justinvisser/wolfskin/design/DiscoverKeysTest.kt
View file

@ -2,6 +2,9 @@
package org.justinvisser.wolfskin.design
import android.app.Application
import android.graphics.Bitmap
import androidx.compose.runtime.CompositionLocalProvider
import androidx.compose.ui.graphics.asImageBitmap
import android.view.KeyEvent as AndroidKeyEvent
import androidx.compose.ui.input.key.Key
import androidx.compose.ui.input.key.KeyEvent
@ -19,10 +22,12 @@ import org.junit.Test
import org.junit.runner.RunWith
import org.robolectric.RobolectricTestRunner
import org.robolectric.annotation.Config
import org.robolectric.annotation.GraphicsMode
/** Acceptance data drives real Android events through the shell's production focus adapter. */
@RunWith(RobolectricTestRunner::class)
@Config(sdk = [34], application = Application::class, qualifiers = "w960dp-h540dp-xhdpi")
@GraphicsMode(GraphicsMode.Mode.NATIVE)
class DiscoverKeysTest {
@get:Rule val rule = createComposeRule()
private val fixture = discoverTestFixture()
@ -33,11 +38,14 @@ class DiscoverKeysTest {
{ shell.enterDestination("discover") }, fixture::service)
private fun launch() {
val art = Bitmap.createBitmap(8, 8, Bitmap.Config.ARGB_8888).apply { eraseColor(android.graphics.Color.DKGRAY) }.asImageBitmap()
rule.setContent {
WolfskinTheme {
CompositionLocalProvider(LocalDiscoverArt provides { art }) {
ShellSurface(shell, overlay = { DiscoverOverlay(state) }) { modifier ->
if (shell.route == "discover" || shell.route.startsWith("discover-") || shell.route.startsWith("title/")) DiscoverScreen(state, modifier) else ShellPlaceholder(shell.route, modifier)
}
}
}
}
}
@ -256,7 +264,69 @@ class DiscoverKeysTest {
assertNull(state.collection)
assertSame(origin, shell.view)
assertEquals(3, shell.view.row)
assertEquals(2, shell.view.cards[state.rowKey])
assertEquals(2, state.column)
}
@Test fun firstEntryStartsLeftmostAndOnlyMovedLanesRememberTheirPosition() {
replay("Open Discover")
press(Key.DirectionDown, Key.DirectionDown)
assertEquals(0, state.column)
repeat(7) { press(Key.DirectionRight) }
val moved = state.column
assertTrue(moved > 0)
press(Key.DirectionDown)
assertEquals("An untouched lane starts at its own left edge, not the previous lane's column", 0, state.column)
press(Key.DirectionUp)
assertEquals(moved, state.column)
}
@Test fun leavingTheTabResetsLaneMovementButPushedTitlesDoNot() {
replay("Open Discover")
press(Key.DirectionDown, Key.DirectionDown)
press(Key.DirectionDown)
repeat(4) { press(Key.DirectionRight) }
val row = state.focusedRow
val moved = state.column
press(Key.DirectionCenter)
assertNotNull("This round trip must open a title, not a service lane", state.title)
press(Key.Back)
assertEquals(moved, state.column)
press(Key.Back)
press(Key.DirectionLeft, Key.DirectionCenter)
assertEquals("home", shell.route)
press(Key.DirectionUp, Key.DirectionRight)
press(Key.DirectionCenter)
assertEquals("discover", shell.route)
assertEquals(row, state.focusedRow)
assertEquals(0, state.column)
assertEquals(0, state.laneFirsts[state.rowKey] ?: 0)
}
@Test fun rebuildingDiscoverDoesNotReuseThePreviousInstancesLaneColumns() {
shell.pickerVisible = false
shell.enterDestination("discover")
state.focus(state.firstShelf, 4)
val rebuilt = DiscoverState(shell, snapshot, operations, CoroutineScope(Dispatchers.Main.immediate))
assertEquals(0, rebuilt.column)
}
@Test fun serviceLanesKeepIndependentPositionsAndResetWithTheRootVisit() {
shell.pickerVisible = false
shell.enterDestination("discover")
state.focus(state.firstShelf + 1, 3)
state.openService(snapshot.services[0])
state.focus(state.firstShelf + 1, 4)
state.key(ShellKey.Back)
assertEquals("A service must not overwrite the root lane", 3, state.column)
state.openService(snapshot.services[1])
state.key(ShellKey.Down)
assertEquals("Different services can reuse lane ids without sharing columns", 0, state.column)
state.key(ShellKey.Back)
state.openService(snapshot.services[0])
state.key(ShellKey.Down)
assertEquals(4, state.column)
state.enterRoute("home")
assertEquals("Leaving Discover clears service positions too", 0, state.column)
}
@Test

91
wolfskin-design/src/test/java/org/justinvisser/wolfskin/design/DiscoverNetworkHeroTest.kt Normal file
View file

@ -0,0 +1,91 @@
package org.justinvisser.wolfskin.design
import android.app.Application
import android.graphics.Bitmap
import android.graphics.BitmapFactory
import android.view.View
import android.view.WindowManager
import androidx.activity.ComponentActivity
import androidx.compose.foundation.layout.requiredSize
import androidx.compose.runtime.CompositionLocalProvider
import androidx.compose.ui.Modifier
import androidx.compose.ui.graphics.asImageBitmap
import androidx.compose.ui.input.key.Key
import androidx.compose.ui.test.*
import androidx.compose.ui.test.junit4.createAndroidComposeRule
import coil3.asImage
import coil3.decode.DataSource
import coil3.intercept.Interceptor
import coil3.request.SuccessResult
import com.github.takahirom.roborazzi.captureRoboImage
import kotlinx.coroutines.CompletableDeferred
import kotlinx.coroutines.CoroutineScope
import kotlinx.coroutines.Dispatchers
import org.json.JSONArray
import org.json.JSONObject
import org.junit.Assert.*
import org.junit.Rule
import org.junit.Test
import org.junit.runner.RunWith
import org.robolectric.RobolectricTestRunner
import org.robolectric.annotation.Config
import org.robolectric.annotation.GraphicsMode
import java.io.File
/** Network-success artwork must not add Coil's independent alpha ramp beneath the hero blend. */
@RunWith(RobolectricTestRunner::class)
@Config(sdk = [34], application = Application::class, qualifiers = "w960dp-h540dp-xhdpi")
@GraphicsMode(GraphicsMode.Mode.NATIVE)
class DiscoverNetworkHeroTest {
@get:Rule val rule = createAndroidComposeRule<ComponentActivity>()
@Test fun delayedNetworkSuccessCannotDipThePaintedHeroOpacity() {
rule.activity.window.setFlags(WindowManager.LayoutParams.FLAG_FULLSCREEN, WindowManager.LayoutParams.FLAG_FULLSCREEN)
@Suppress("DEPRECATION")
rule.activity.window.decorView.systemUiVisibility = View.SYSTEM_UI_FLAG_FULLSCREEN or View.SYSTEM_UI_FLAG_HIDE_NAVIGATION or View.SYSTEM_UI_FLAG_IMMERSIVE_STICKY
rule.mainClock.autoAdvance = false
val red = Bitmap.createBitmap(8, 8, Bitmap.Config.ARGB_8888).apply { eraseColor(android.graphics.Color.RED) }.asImageBitmap()
val blue = Bitmap.createBitmap(8, 8, Bitmap.Config.ARGB_8888).apply { eraseColor(android.graphics.Color.BLUE) }.asImage()
val release = CompletableDeferred<Unit>()
WolfskinImages.configureNetwork(rule.activity) { add(Interceptor { chain ->
if (chain.request.data == "network:blue") {
release.await()
SuccessResult(blue, chain.request, DataSource.NETWORK)
} else chain.proceed()
}) }
val fixture = discoverTestFixture()
val titles = fixture.snapshot("justin").picks.take(2).mapIndexed { index, title ->
title.copy(backdrop = if (index == 0) "network:red" else "network:blue", poster = null, posterOnly = false, score = 100.0 - index)
}
val snapshot = fixture.snapshot("justin").copy(picks = titles)
val shell = ShellState(fixturePeople(), "justin").apply { pickerVisible = false; enterDestination("discover") }
val state = DiscoverState(shell, snapshot, RecordingDiscoverOperations(snapshot, "justin"), CoroutineScope(Dispatchers.Main.immediate))
rule.setContent { WolfskinTheme {
CompositionLocalProvider(LocalDiscoverArt provides { path -> if (path == "network:red") red else null }) {
ShellSurface(shell, Modifier.requiredSize(WolfskinTokens.Shell.stageWidth, WolfskinTokens.Shell.stageHeight)) { DiscoverScreen(state, it) }
}
} }
rule.mainClock.advanceTimeBy(640)
rule.onNodeWithTag("wolfskin-shell").performKeyInput { keyDown(Key.DirectionRight); keyUp(Key.DirectionRight) }
rule.mainClock.advanceTimeBy(192)
rule.onNodeWithText(titles.first().title).assertIsDisplayed()
val directory = File(System.getProperty("wolfskin.captureDirectory"), "discover-network-hero").apply { mkdirs() }
val samples = JSONArray()
rule.runOnIdle { release.complete(Unit) }
var lastPixel = 0
repeat(40) { index ->
rule.mainClock.advanceTimeBy(16)
val file = File(directory, "network-${index.toString().padStart(2, '0')}.png")
rule.onRoot().captureRoboImage(file.absolutePath)
val bitmap = BitmapFactory.decodeFile(file.absolutePath)
lastPixel = try { bitmap.getPixel(1600, 200) } finally { bitmap.recycle() }
val redChannel = android.graphics.Color.red(lastPixel)
val blueChannel = android.graphics.Color.blue(lastPixel)
samples.put(JSONObject().put("timeMs", rule.mainClock.currentTime).put("red", redChannel).put("blue", blueChannel))
assertTrue("A second network-image fade exposes the dark placeholder beneath both heroes at frame $index: red=$redChannel blue=$blueChannel", redChannel + blueChannel >= 250)
}
File(directory, "series.json").writeText(samples.toString(2))
assertEquals(android.graphics.Color.BLUE, lastPixel)
rule.onNodeWithText(titles.last().title).assertIsDisplayed()
}
}

44
wolfskin-design/src/test/java/org/justinvisser/wolfskin/design/HeroMotionTest.kt
View file

@ -13,6 +13,9 @@ import androidx.compose.runtime.mutableStateOf
import androidx.compose.ui.Modifier
import androidx.compose.ui.graphics.Color
import androidx.compose.ui.graphics.toArgb
import androidx.compose.ui.graphics.asImageBitmap
import androidx.compose.ui.test.onNodeWithText
import androidx.compose.ui.test.assertIsDisplayed
import androidx.compose.ui.test.junit4.createAndroidComposeRule
import androidx.compose.ui.test.onRoot
import androidx.compose.ui.test.onNodeWithTag
@ -59,16 +62,22 @@ class HeroMotionTest {
val probe = BitmapFactory.decodeFile(probeFile.absolutePath)
try {
for (y in listOf(380, 400, 420, 600, 800)) {
assertEquals("The outgoing hero must stop at its 400px boundary: y=$y",
(if (y < 400) Color.Red else Color.Blue).toArgb(), probe.getPixel(100, y))
assertEquals("Pending artwork cannot replace any part of the painted backdrop: y=$y",
Color.Red.toArgb(), probe.getPixel(100, y))
}
assertEquals(400f, rule.onNodeWithTag("hero-outgoing").fetchSemanticsNode().boundsInRoot.height, .01f)
} finally { probe.recycle() }
update { ready.value = true }
rule.mainClock.advanceTimeBy(176)
val mixed = pixel(directory, 100)
assertNotEquals(Color.Red.toArgb(), mixed)
assertNotEquals(Color.Blue.toArgb(), mixed)
val blendedProbe = BitmapFactory.decodeFile(probeFile.absolutePath)
try {
assertEquals("Only the outgoing blend is clipped at its 400px boundary",
400f, rule.onNodeWithTag("hero-outgoing").fetchSemanticsNode().boundsInRoot.height, .01f)
assertEquals(Color.Blue.toArgb(), blendedProbe.getPixel(100, 400))
assertEquals(Color.Blue.toArgb(), blendedProbe.getPixel(100, 800))
} finally { blendedProbe.recycle() }
rule.mainClock.advanceTimeBy(400)
assertEquals(Color.Blue.toArgb(), pixel(directory, 100))
update { selected.value = "green"; ready.value = false }
@ -82,6 +91,35 @@ class HeroMotionTest {
} finally { directory.deleteRecursively() }
}
@Test fun homeHeroRetainsTheOutgoingCopyAnchorWhenTheNextTitleWraps() {
rule.mainClock.autoAdvance = false
val first = HomeTitle("first", "Short title", "movie", backdrop = "red")
val next = HomeTitle("next", "A much longer title that must wrap onto a second line in this hero", "movie", backdrop = "blue")
val selected = mutableStateOf(first)
val art = mapOf("red" to Color.Red, "blue" to Color.Blue).mapValues { (_, color) ->
android.graphics.Bitmap.createBitmap(8, 8, android.graphics.Bitmap.Config.ARGB_8888).apply { eraseColor(color.toArgb()) }.asImageBitmap()
}
rule.setContent { WolfskinTheme {
CompositionLocalProvider(LocalTitleBitmaps provides art) {
Box(Modifier.requiredSize(960.dp, 540.dp)) {
HomeHero(HomeRow("hero", HomeRowKind.Hero, cards = listOf(selected.value)), true, 0, emptyList(), {}, {})
}
}
} }
rule.mainClock.advanceTimeBy(640)
val anchor = rule.onNodeWithText(first.title).fetchSemanticsNode().boundsInRoot
val actionAnchor = rule.onNodeWithText("Play").fetchSemanticsNode().boundsInRoot
update { selected.value = next }
repeat(WolfskinTokens.Motion.heroCopyOut / 16) {
rule.mainClock.advanceTimeBy(16)
assertEquals("A taller incoming copy cannot move the outgoing title", anchor, rule.onNodeWithText(first.title).fetchSemanticsNode().boundsInRoot)
assertEquals("Hero actions remain stationary outside the copy handoff", actionAnchor, rule.onNodeWithText("Play").fetchSemanticsNode().boundsInRoot)
}
rule.mainClock.advanceTimeBy(320)
rule.onNodeWithText(first.title).assertDoesNotExist()
rule.onNodeWithText(next.title).assertIsDisplayed()
}
private fun update(block: () -> Unit) {
rule.runOnIdle { block(); androidx.compose.runtime.snapshots.Snapshot.sendApplyNotifications() }
rule.mainClock.advanceTimeByFrame()

132
wolfskin-design/src/test/java/org/justinvisser/wolfskin/design/HomeHeroSequenceTest.kt Normal file
View file

@ -0,0 +1,132 @@
package org.justinvisser.wolfskin.design
import android.app.Application
import android.graphics.Bitmap
import android.graphics.BitmapFactory
import android.view.View
import android.view.WindowManager
import androidx.activity.ComponentActivity
import androidx.compose.foundation.background
import androidx.compose.foundation.layout.Box
import androidx.compose.foundation.layout.requiredSize
import androidx.compose.runtime.CompositionLocalProvider
import androidx.compose.runtime.mutableStateOf
import androidx.compose.runtime.saveable.rememberSaveableStateHolder
import androidx.compose.ui.Modifier
import androidx.compose.ui.geometry.Rect
import androidx.compose.ui.graphics.asImageBitmap
import androidx.compose.ui.semantics.SemanticsProperties
import androidx.compose.ui.test.*
import androidx.compose.ui.test.junit4.createAndroidComposeRule
import com.github.takahirom.roborazzi.captureRoboImage
import org.json.JSONArray
import org.json.JSONObject
import org.junit.Assert.*
import org.junit.Rule
import org.junit.Test
import org.junit.runner.RunWith
import org.robolectric.RobolectricTestRunner
import org.robolectric.annotation.Config
import org.robolectric.annotation.GraphicsMode
import java.io.File
/** Real Home hero entry, interrupted fade-through and saved remount sampled at native 16 ms steps. */
@RunWith(RobolectricTestRunner::class)
@Config(sdk = [34], application = Application::class, qualifiers = "w960dp-h540dp-xhdpi")
@GraphicsMode(GraphicsMode.Mode.NATIVE)
class HomeHeroSequenceTest {
@get:Rule val rule = createAndroidComposeRule<ComponentActivity>()
private val first = HomeTitle("first", "Short title", "movie", backdrop = "red")
private val next = HomeTitle("next", "A much longer title that must wrap onto a second line in this hero", "movie", backdrop = "blue")
private val third = HomeTitle("third", "The final selected title", "movie", backdrop = "green")
private val selected = mutableStateOf(first)
private val reduced = mutableStateOf(false)
private val mounted = mutableStateOf(true)
private val samples = JSONArray()
private lateinit var directory: File
private lateinit var actionBounds: Rect
@Test fun initialSequentialBurstAndRemountKeepHomeCopyReadable() {
rule.activity.window.setFlags(WindowManager.LayoutParams.FLAG_FULLSCREEN, WindowManager.LayoutParams.FLAG_FULLSCREEN)
@Suppress("DEPRECATION")
rule.activity.window.decorView.systemUiVisibility = View.SYSTEM_UI_FLAG_FULLSCREEN or View.SYSTEM_UI_FLAG_HIDE_NAVIGATION or View.SYSTEM_UI_FLAG_IMMERSIVE_STICKY
rule.mainClock.autoAdvance = false
directory = File(System.getProperty("wolfskin.captureDirectory"), "home-hero-copy").apply { mkdirs() }
val art = mapOf("red" to android.graphics.Color.RED, "blue" to android.graphics.Color.BLUE, "green" to android.graphics.Color.GREEN).mapValues { (_, color) ->
Bitmap.createBitmap(8, 8, Bitmap.Config.ARGB_8888).apply { eraseColor(color) }.asImageBitmap()
}
rule.setContent { WolfskinTheme {
val saved = rememberSaveableStateHolder()
CompositionLocalProvider(LocalReducedMotion provides reduced.value, LocalTitleBitmaps provides art) {
Box(Modifier.requiredSize(WolfskinTokens.Shell.stageWidth, WolfskinTokens.Shell.stageHeight).background(WolfskinTokens.Color.bg)) {
if (mounted.value) saved.SaveableStateProvider("home-hero") {
HomeHero(HomeRow("hero", HomeRowKind.Hero, cards = listOf(selected.value)), true, 0, emptyList(), {}, {})
}
}
}
} }
rule.mainClock.advanceTimeByFrame()
actionBounds = rule.onNodeWithText("Play").fetchSemanticsNode().boundsInRoot
sample("initial", 0)
assertEquals(0f, copy().config[HeroLayerAlpha], .001f)
assertEquals(with(rule.density) { WolfskinTokens.Motion.copyEntryRise.toPx() }, copy().config[HeroLayerTranslation], .001f)
frames("entry", 16)
assertEquals(1f, copy().config[HeroLayerAlpha], .001f)
rule.runOnIdle { selected.value = next }
frames("handoff", 26)
assertEquals(next.id, copy().config[HeroLayerIdentity])
assertEquals(1f, copy().config[HeroLayerAlpha], .001f)
repeat(24) { index ->
rule.runOnIdle { selected.value = if (index % 2 == 0) first else third }
frames("burst-$index", 1)
}
frames("settled", 28)
assertEquals(third.id, copy().config[HeroLayerIdentity])
assertEquals(1f, copy().config[HeroLayerAlpha], .001f)
rule.runOnIdle { reduced.value = true; selected.value = next }
frames("reduced", 20)
assertEquals(next.id, copy().config[HeroLayerIdentity])
assertEquals(1f, copy().config[HeroLayerAlpha], .001f)
rule.runOnIdle { mounted.value = false }
frames("absent", 1)
rule.runOnIdle { mounted.value = true }
repeat(8) { frame ->
rule.mainClock.advanceTimeBy(16)
sample("remount", frame)
assertEquals("Returning Home cannot replay the initial entrance", 1f, copy().config[HeroLayerAlpha], .001f)
assertEquals(0f, copy().config[HeroLayerTranslation], .001f)
}
File(directory, "series.json").writeText(samples.toString(2))
}
private fun frames(phase: String, count: Int) = repeat(count) { frame -> rule.mainClock.advanceTimeBy(16); sample(phase, frame) }
private fun copy() = rule.onAllNodes(SemanticsMatcher.keyIsDefined(HeroLayerAlpha), useUnmergedTree = true).fetchSemanticsNodes()
.single { it.config[SemanticsProperties.TestTag].startsWith("hero-copy") }
private fun sample(phase: String, frame: Int) {
rule.waitForIdle()
val file = File(directory, "$phase-${frame.toString().padStart(2, '0')}.png")
rule.onRoot().captureRoboImage(file.absolutePath)
val bitmap = BitmapFactory.decodeFile(file.absolutePath)
val pixel = try { bitmap.getPixel(1600, 200) } finally { bitmap.recycle() }
val nodes = rule.onAllNodes(SemanticsMatcher.keyIsDefined(HeroLayerAlpha), useUnmergedTree = true).fetchSemanticsNodes()
val copyNodes = nodes.filter { it.config[SemanticsProperties.TestTag].startsWith("hero-copy") }
assertTrue("Home must never overlap visible titles, even during bursts", copyNodes.count { it.config[HeroLayerAlpha] > 0f } <= 1)
if (mounted.value) {
assertTrue("Home artwork retains an opaque base", nodes.any { it.config[SemanticsProperties.TestTag] == "hero-incoming" && it.config[HeroLayerAlpha] == 1f })
assertEquals("Copy motion cannot move Home's controls", actionBounds, rule.onNodeWithText("Play").fetchSemanticsNode().boundsInRoot)
}
val layers = JSONArray()
nodes.forEach { node ->
val translation = node.config[HeroLayerTranslation]
if (reduced.value) assertEquals(0f, translation, .001f)
layers.put(JSONObject().put("kind", node.config[SemanticsProperties.TestTag]).put("identity", node.config[HeroLayerIdentity])
.put("layerId", node.id).put("alpha", node.config[HeroLayerAlpha]).put("translationY", translation)
.put("x", node.boundsInRoot.left).put("y", node.boundsInRoot.top))
}
samples.put(JSONObject().put("phase", phase).put("frame", frame).put("timeMs", rule.mainClock.currentTime)
.put("mounted", mounted.value).put("selection", selected.value.id).put("reduced", reduced.value)
.put("rgb", JSONArray(listOf(android.graphics.Color.red(pixel), android.graphics.Color.green(pixel), android.graphics.Color.blue(pixel))))
.put("actionX", actionBounds.left).put("actionY", actionBounds.top).put("layers", layers))
}
}

9
wolfskin-design/src/test/java/org/justinvisser/wolfskin/design/MotionSurfaceTest.kt
View file

@ -19,6 +19,7 @@ import androidx.compose.ui.Modifier
import androidx.compose.ui.input.key.Key
import androidx.compose.ui.platform.testTag
import androidx.compose.ui.test.junit4.createAndroidComposeRule
import androidx.compose.ui.test.assertIsFocused
import androidx.compose.ui.test.onNodeWithTag
import androidx.compose.ui.test.onNodeWithText
import androidx.compose.ui.test.onRoot
@ -66,7 +67,13 @@ class MotionSurfaceTest {
rule.setContent { WolfskinTheme { TitleSurface(state, shell) } }
rule.mainClock.advanceTimeBy(2100)
rule.onRoot().performKeyInput { pressKey(Key.DirectionDown) }
rule.runOnIdle { assertTrue(shell.navFocused); assertFalse(shell.pickerVisible) }
rule.onNodeWithTag("title-page").assertIsFocused()
rule.runOnIdle {
assertFalse(shell.navFocused)
assertFalse(shell.pickerVisible)
assertEquals("header", state.row)
assertEquals(0, state.column)
}
rule.onRoot().performKeyInput { pressKey(Key.Back) }
rule.runOnIdle { assertEquals(listOf(TitleAction.Pop), actions); assertFalse(shell.pickerVisible) }
}