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

Fix Home navigation ownership and merge watch lanes

Browse source
This commit is contained in:
justinzeus 2026-11-07 15:23:45 +01:00
parent c2f7ccc438
commit 12c201dc55
41 changed files with 671 additions and 307 deletions
Download patch file Download diff file Expand all files Collapse all files

6
wolfskin-design/home-tokens.json
View file

@ -50,9 +50,9 @@
},
"cardOverlayTop": {
"$type": "dimension",
"px": 54,
"dp": 27.0,
"source": "locked index.html:94-165,180-198,1014-1029,1276-1289"
"px": 36,
"dp": 18.0,
"source": "TV round 2: lower card bottom gradient; cover the state-line reserve"
},
"cardOverlayBottom": {
"$type": "dimension",

2
wolfskin-design/src/debug/java/org/justinvisser/wolfskin/design/HomeFixture.kt
View file

@ -99,6 +99,8 @@ class HomeFixture(context: Context) {
resumeSeconds = item.optDouble("resumeSeconds", 0.0).takeIf { it.isFinite() } ?: 0.0,
played = item.optBoolean("played"), addedAt = item.optString("addedAt", ""), genres = genres(item).toList(), ratings = ratings(item),
held = item.optString("availability") == "in_library", tmdbId = item.intOrNull("tmdbId"),
seriesId = item.stringOrNull("seriesId"),
lastPlayedAt = item.stringOrNull("lastPlayedAt")?.let { java.time.Instant.parse(it).toEpochMilli() },
)
private fun ratings(item: JSONObject): List<HomeRating> {

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

@ -44,12 +44,14 @@ import org.justinvisser.wolfskin.design.WolfskinTokens.Layout as L
@Composable
fun DiscoverScreen(state: DiscoverState, modifier: Modifier = Modifier) {
val shell = state.shell
val view = screenView(shell)
val entryActive = LocalScreenActive.current
val focus = remember(state) { object : ShellContentFocus by state {} }
DisposableEffect(focus) {
shell.contentFocus = focus
DisposableEffect(focus, entryActive) {
if (entryActive) shell.contentFocus = focus
onDispose { if (shell.contentFocus === focus) { shell.contentFocus = null; shell.contentOverlayVisible = false } }
}
LaunchedEffect(shell.route, state.snapshot.savedAt) { shell.view.savedAt = state.snapshot.savedAt }
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 } }
val focusedTitle = if (state.collection != null) null else state.focusedLane?.titles?.getOrNull(state.column)
val ratingsReader = LocalScreenRatings.current
@ -78,7 +80,7 @@ fun DiscoverScreen(state: DiscoverState, modifier: Modifier = Modifier) {
return
}
val density = LocalDensity.current
val list = shell.view.listState
val list = view.listState
val note = state.snapshot.status in setOf(DiscoverStatus.NoSeeds, DiscoverStatus.PicksUnavailable)
val heights = remember(state.hasHero, state.lanes, note, state.hasCatalogue) {
buildList {

2
wolfskin-design/src/main/java/org/justinvisser/wolfskin/design/HomeModel.kt
View file

@ -28,6 +28,8 @@ data class HomeTitle(
val held: Boolean = false,
val otherOwner: String? = null,
val tmdbId: Int? = null,
val seriesId: String? = null,
val lastPlayedAt: Long? = null,
) {
val isEpisode: Boolean get() = type == "episode"
val displayTitle: String get() = seriesTitle ?: title

32
wolfskin-design/src/main/java/org/justinvisser/wolfskin/design/HomeRows.kt
View file

@ -18,12 +18,13 @@ fun buildHomeRows(
): List<HomeRow> = buildList {
if (loading) {
add(HomeRow("hero-sk", HomeRowKind.Hero, skeleton = true))
listOf(HomeCardKind.Tile, HomeCardKind.Tile, HomeCardKind.Poster, HomeCardKind.Poster).forEachIndexed { index, kind ->
listOf(HomeCardKind.Tile, HomeCardKind.Tile, HomeCardKind.Poster).forEachIndexed { index, kind ->
add(HomeRow("sk$index", HomeRowKind.Shelf, cardKind = kind, skeleton = true))
}
return@buildList
}
val choice = when {
// Hero precedence remains independent of the merged shelf's recency order.
library.resume.isNotEmpty() -> "resume" to library.resume.first()
library.nextUp.isNotEmpty() -> "next" to library.nextUp.first()
library.newest.isNotEmpty() -> "new" to library.newest.first()
@ -34,10 +35,10 @@ fun buildHomeRows(
if (!libraryAvailable) {
add(HomeRow("jf-down", HomeRowKind.State, "Your library can’t be reached", text = "Jellyfin isn’t answering, so nothing can play right now."))
} else {
listOf(Triple("cw", "Continue watching", library.resume), Triple("nu", "Next up", library.nextUp), Triple("new", "New in your library", library.newest)).forEach { (id, title, source) ->
val cards = source.filter { it.id != hero?.id }
if (cards.isNotEmpty()) add(HomeRow(id, HomeRowKind.Shelf, title, cards, if (id == "cw") HomeCardKind.Wide else HomeCardKind.Tile))
}
val watching = continueWatching(library).filter { it.watchIdentity != hero?.watchIdentity }
if (watching.isNotEmpty()) add(HomeRow("cw", HomeRowKind.Shelf, "Continue watching", watching, HomeCardKind.Tile))
val newest = library.newest.filter { it.id != hero?.id }
if (newest.isNotEmpty()) add(HomeRow("new", HomeRowKind.Shelf, "New in your library", newest, HomeCardKind.Tile))
listOf("movies", "shows", "anime").forEach { destination ->
val titles = library.destinations[destination].orEmpty().sortedWith(compareBy<HomeTitle> { it.played }.thenByDescending { it.addedAt })
if (titles.isNotEmpty()) add(HomeRow("lib-$destination", HomeRowKind.Shelf, if (destination == "anime") "Anime" else "Your $destination", titles.take(WolfskinTokens.Behaviour.rowLimit.toInt()), total = library.destinationTotals[destination] ?: titles.size, target = destination))
@ -47,6 +48,27 @@ fun buildHomeRows(
addAll(continuation)
}
/** Prefer a resumable episode per series, then sort the chosen items by actual watch activity. */
internal fun continueWatching(library: HomeLibrary): List<HomeTitle> {
val chosen = linkedMapOf<String, HomeTitle>()
fun choose(source: List<HomeTitle>) {
for (title in source) {
val key = title.watchIdentity
val previous = chosen[key]
if (previous == null || (previous.resumeSeconds <= 0 && title.resumeSeconds > 0) ||
((previous.resumeSeconds > 0) == (title.resumeSeconds > 0) && (title.lastPlayedAt ?: Long.MIN_VALUE) > (previous.lastPlayedAt ?: Long.MIN_VALUE))) {
chosen[key] = title
}
}
}
choose(library.resume)
choose(library.nextUp)
return chosen.values.sortedByDescending { it.lastPlayedAt }
}
private val HomeTitle.watchIdentity: String
get() = if (isEpisode) seriesId?.let { "series:$it" } ?: seriesTitle?.let { "series-name:$it" } ?: id else id
/** Authentication failure is distinct from an unreachable signed-in catalogue. */
fun homeDiscoverState(status: HomeAvailability): HomeRow = if (status == HomeAvailability.SignedOut) {
HomeRow("signin", HomeRowKind.State, "Discover needs sign-in", text = "Sign this TV in to Conductarr to see picks and request titles. Your library plays as usual.", calm = true)

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

@ -29,11 +29,12 @@ fun HomeScreen(
onAction: (HomeAction) -> Unit,
) {
val view = shell.rememberedView("home")
val active = LocalScreenActive.current
LaunchedEffect(view, snapshot.savedAt) { view.savedAt = snapshot.savedAt }
val action by rememberUpdatedState(onAction)
val focus = remember(shell, snapshot.rows, view) { HomeFocus(shell, snapshot.rows) { action(it) } }
DisposableEffect(shell, focus) {
shell.contentFocus = focus
DisposableEffect(shell, focus, active) {
if (active) shell.contentFocus = focus
onDispose { if (shell.contentFocus === focus) shell.contentFocus = null }
}
LaunchedEffect(snapshot.rows, view) {

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

@ -86,9 +86,10 @@ fun HomeShelf(row: HomeRow, memory: HomeViewMemory, focused: Boolean, column: In
private fun TileOverlay(title: HomeTitle) {
Box(Modifier.fillMaxSize(), contentAlignment = Alignment.BottomStart) {
val metadata = WolfskinTokens.CardMetadata
Column(Modifier.padding(bottom = metadata.bottom + metadata.separator + metadata.resumeLine).fillMaxWidth()
.background(Brush.verticalGradient(listOf(C.bg.copy(alpha = 0f), C.bg.copy(alpha = .92f))))
.padding(start = H.cardPadding, end = H.cardPadding, top = H.cardOverlayTop, bottom = H.cardOverlayBottom)) {
Column(Modifier.fillMaxWidth()
.background(Brush.verticalGradient(listOf(C.bg.copy(alpha = 0f), C.bg.copy(alpha = WolfskinTokens.Title.cardOverlayOpacity))))
.padding(start = H.cardPadding, end = H.cardPadding, top = H.cardOverlayTop,
bottom = H.cardOverlayBottom + metadata.bottom + metadata.separator + metadata.resumeLine)) {
Text(title.displayTitle, modifier = Modifier.exactLineBox(metadata.titleFocus), color = C.fg, style = metadata.titleFocus, maxLines = 1, overflow = TextOverflow.Ellipsis)
}
}

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

@ -39,10 +39,11 @@ fun LibraryScreen(
cachedRatings: Set<String> = emptySet(),
ratingsReachable: Boolean = true,
offlineArt: ((String) -> ImageBitmap?)? = null,
view: RememberedView = shell.view,
view: RememberedView = screenView(shell),
registerFocus: Boolean = true,
) {
val density = LocalDensity.current
val entryActive = LocalScreenActive.current
val context = LocalContext.current
val active = !shell.navFocused && !shell.pickerVisible
val items = grid.items
@ -50,8 +51,8 @@ fun LibraryScreen(
val count = if (grid.catalogue) items.size else grid.source.size
var plateKey by remember { mutableStateOf<String?>(null) }
val ratingsReader = LocalScreenRatings.current
DisposableEffect(shell, grid, registerFocus) {
if (registerFocus) shell.contentFocus = grid
DisposableEffect(shell, grid, registerFocus, entryActive) {
if (registerFocus && entryActive) shell.contentFocus = grid
onDispose { if (registerFocus && shell.contentFocus === grid) shell.contentFocus = null }
}
LaunchedEffect(grid) {

10
wolfskin-design/src/main/java/org/justinvisser/wolfskin/design/PersonPage.kt
View file

@ -86,10 +86,11 @@ class PersonState(initialPerson: TitlePerson, initialCredits: List<TitleItem>, p
/** Portrait, biography and the full continuous grid use the shell's remembered frame. */
@Composable
fun PersonSurface(state: PersonState, shell: ShellState, modifier: Modifier = Modifier) {
val view = shell.view
val view = screenView(shell)
val entryActive = LocalScreenActive.current
LaunchedEffect(view, state.savedAt) { view.savedAt = state.savedAt }
val owner = androidx.compose.runtime.remember(shell) { { shell.navFocused = false } }
LaunchedEffect(state) { shell.navFocused = false }
LaunchedEffect(state, entryActive) { if (entryActive) shell.navFocused = false }
Box(modifier.fillMaxSize().background(C.bg)) {
androidx.compose.runtime.CompositionLocalProvider(LocalTitleFocusOwner provides owner) {
ShellSurface(shell, handlesContentKeys = false) { PersonPage(state, shell, it) }
@ -101,7 +102,8 @@ fun PersonSurface(state: PersonState, shell: ShellState, modifier: Modifier = Mo
@Composable
private fun PersonPage(state: PersonState, shell: ShellState, modifier: Modifier = Modifier) {
val density = LocalDensity.current
val list = shell.view.listState
val list = screenView(shell).listState
val entryActive = LocalScreenActive.current
var wheelPending by remember { mutableStateOf(false) }
val columns = WolfskinTokens.Behaviour.gridColumns.toInt()
LaunchedEffect(state.index / columns, shell.navFocused) {
@ -127,7 +129,7 @@ private fun PersonPage(state: PersonState, shell: ShellState, modifier: Modifier
if (key != ShellKey.Ok) return@onPreviewKeyEvent true
}
key?.let { state.key(it, event.type == KeyEventType.KeyDown, event.nativeKeyEvent.repeatCount, shell) } ?: false
}.focusable()) {
}.focusable(enabled = entryActive)) {
LazyColumn(state = list, modifier = Modifier.fillMaxSize()) {
item(key = "person-header", contentType = "header") {
Box(Modifier.height(L.row_phead)) {

20
wolfskin-design/src/main/java/org/justinvisser/wolfskin/design/ScreenEntry.kt Normal file
View file

@ -0,0 +1,20 @@
package org.justinvisser.wolfskin.design
import androidx.compose.runtime.Composable
import androidx.compose.runtime.CompositionLocalProvider
import androidx.compose.runtime.compositionLocalOf
import androidx.compose.runtime.remember
internal val LocalScreenView = compositionLocalOf<RememberedView?> { null }
internal val LocalScreenActive = compositionLocalOf { true }
/** Overlapping navigation entries retain their own viewport; only the current entry owns input. */
@Composable
fun ScreenEntry(shell: ShellState, route: String, active: Boolean, content: @Composable () -> Unit) {
remember(shell, shell.person.key, route) { shell.prepareDestinationView(route) }
CompositionLocalProvider(LocalScreenView provides shell.rememberedView(route), LocalScreenActive provides active, content = content)
}
/** Direct surface previews use the current view when no navigation entry is installed. */
@Composable
internal fun screenView(shell: ShellState): RememberedView = LocalScreenView.current ?: shell.view

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

@ -116,6 +116,9 @@ class ShellState(
fun rememberedView(destination: String): RememberedView =
views[person.key to destination] ?: RememberedView()
/** Register an entry before composition; rememberedView also serves read-only snapshot observers. */
internal fun prepareDestinationView(destination: String) { retainView(destination) }
/** External intents and upstream pops remain authoritative over the screen. */
fun enterDestination(destination: String) {
retainView(destination)

18
wolfskin-design/src/main/java/org/justinvisser/wolfskin/design/ShellSurface.kt
View file

@ -61,6 +61,8 @@ fun ShellSurface(
) {
val focus = remember { FocusRequester() }
val contentFocus = remember { FocusRequester() }
val active = LocalScreenActive.current
val view = screenView(state)
val focusManager = LocalFocusManager.current
LaunchedEffect(state.toast) {
val message = state.toast
@ -69,30 +71,32 @@ fun ShellSurface(
if (state.toast == message) state.toast = null
}
}
LaunchedEffect(state.pickerVisible, state.navFocused, handlesContentKeys) {
if (state.pickerVisible || state.navFocused || handlesContentKeys) focus.requestFocus()
else contentFocus.requestFocus()
LaunchedEffect(state.pickerVisible, state.navFocused, handlesContentKeys, active) {
if (active) {
if (state.pickerVisible || state.navFocused || handlesContentKeys) focus.requestFocus()
else contentFocus.requestFocus()
}
}
Box(modifier.fillMaxSize().background(if (handlesContentKeys || state.pickerVisible) C.bg else Color.Transparent).testTag("wolfskin-shell")
.semantics { stateDescription = "${state.person.key}:${state.route}:${if (state.pickerVisible) "picker" else if (state.navFocused) "nav-${state.navIndex}" else "content-${state.settingsRow}"}" }
.focusRequester(focus)
.onPreviewKeyEvent {
if (state.pickerVisible || state.navFocused || state.requestsVisible || handlesContentKeys) state.handleKey(it) else false
if (active && (state.pickerVisible || state.navFocused || state.requestsVisible || handlesContentKeys)) state.handleKey(it) else false
}
.onKeyEvent {
if (it.key == Key.DirectionUp && it.type == KeyEventType.KeyDown) {
if (active && it.key == Key.DirectionUp && it.type == KeyEventType.KeyDown) {
if (!focusManager.moveFocus(FocusDirection.Up)) {
state.navFocused = true
state.navIndex = state.currentTab
}
true
} else false
}.focusable()) {
}.focusable(enabled = active)) {
if (state.pickerVisible) {
WhosWatching(state)
} else {
if (state.route == "settings") SettingsList(state, requestCount = settingsRequestCount ?: state.requests.snapshot.requestCount) else content(Modifier.fillMaxSize().focusRequester(contentFocus).focusRestorer().focusGroup())
NavBar(state, state.view.listState.firstVisibleItemIndex > 0 || state.view.listState.firstVisibleItemScrollOffset > L.navSolidAfter.value * 2)
NavBar(state, view.listState.firstVisibleItemIndex > 0 || view.listState.firstVisibleItemScrollOffset > L.navSolidAfter.value * 2)
if (state.requestsVisible) ComingInSheet(state)
overlay()
}

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

@ -51,7 +51,7 @@ import org.justinvisser.wolfskin.design.WolfskinTokens.Title as D
/** The shared shell remains authoritative; title sheets overlay it and trap all input. */
@Composable
fun TitleSurface(state: TitleState, shell: ShellState, modifier: Modifier = Modifier) {
val view = shell.view
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.
@ -87,15 +87,16 @@ internal fun TitleNotice(message: String?, modifier: Modifier = Modifier, onDism
@Composable
fun TitlePage(state: TitleState, shell: ShellState, modifier: Modifier = Modifier) {
val density = LocalDensity.current
val list = shell.view.listState
val list = screenView(shell).listState
val entryActive = LocalScreenActive.current
var wheelPending by remember { mutableStateOf(false) }
val focus = remember { FocusRequester() }
var measuredHeaderHeight by remember(state.data.item.id) { mutableStateOf(L.row_dhead) }
val compactSeries = state.data.status == TitleReadStatus.Ready && state.data.item.held &&
state.data.item.kind == "tv" && state.data.item.seasons > 0
val headerHeight = if (compactSeries) measuredHeaderHeight else L.row_dhead
LaunchedEffect(state.sheet, shell.navFocused, shell.pickerVisible) {
if (state.sheet == null && !shell.navFocused && !shell.pickerVisible) focus.requestFocus()
LaunchedEffect(state.sheet, shell.navFocused, shell.pickerVisible, entryActive) {
if (entryActive && state.sheet == null && !shell.navFocused && !shell.pickerVisible) focus.requestFocus()
}
val displayedRows = remember(state.data) {
buildList {
@ -143,7 +144,7 @@ fun TitlePage(state: TitleState, shell: ShellState, modifier: Modifier = Modifie
if (key != ShellKey.Ok) return@onPreviewKeyEvent true
}
key != null && state.key(key, event.type == KeyEventType.KeyDown, event.nativeKeyEvent.repeatCount, shell)
}.focusable()) {
}.focusable(enabled = entryActive)) {
// This remains visible behind the scrolled rows; it is not an off-screen header image.
TitleBackdrop(state.data.item, Modifier.fillMaxSize())
Box(Modifier.fillMaxSize().drawBehind { drawRect(C.bg.copy(alpha = dim)) })

2
wolfskin-design/src/main/java/org/justinvisser/wolfskin/design/WolfskinTokens.kt
View file

@ -586,7 +586,7 @@ object WolfskinTokens {
val factsGap = 11.0.dp
val overviewBottom = 15.0.dp
val cardPadding = 11.0.dp
val cardOverlayTop = 27.0.dp
val cardOverlayTop = 18.0.dp
val cardOverlayBottom = 9.0.dp
val sectionTop = 20.0.dp
val sectionAvatar = 28.0.dp

6
wolfskin-design/src/test/java/org/justinvisser/wolfskin/design/HomeCaptureTest.kt
View file

@ -110,12 +110,12 @@ class HomeCaptureTest {
@Test fun st019_picksUnavailable() = capture("st-019", mode = "picks-unavailable", row = "trending")
@Test fun st020_missingArt() = capture("st-020", person = "shared", mode = "missing", row = "lib-movies")
@Test fun st096_widestTilePlate() = capture("st-096", person = "mindel", row = "new", column = 4)
@Test fun st100_episodePlate() = capture("st-100", person = "mindel", row = "nu")
@Test fun st100_episodePlate() = capture("st-100", person = "mindel", row = "cw")
@Test fun st099_posterPlate() = capture("st-099", row = "lib-movies", column = 1)
@Test fun st101_unratedEpisode() = capture("st-101", person = "mindel", row = "nu", column = 2)
@Test fun st101_unratedEpisode() = capture("st-101", person = "mindel", row = "cw", column = 2)
@Test fun st102_filmTile() = capture("st-102", person = "mindel", row = "new", column = 4)
@Test fun st103_heroRatings() = capture("st-103")
@Test fun spacingNextUpFirstFocused() = capture("spacing-next-up", row = "nu")
@Test fun spacingNextUpFirstFocused() = capture("spacing-next-up", row = "cw")
@Test fun focusHeroDetails() = capture("focus-hero-details", column = 1)
@Test fun xHomeDiscoverStart() = capture("x-home-discover-start", row = "pk-m")
}

68
wolfskin-design/src/test/java/org/justinvisser/wolfskin/design/HomeGradientTest.kt Normal file
View file

@ -0,0 +1,68 @@
package org.justinvisser.wolfskin.design
import android.app.Application
import android.graphics.Bitmap
import android.graphics.BitmapFactory
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.getValue
import androidx.compose.runtime.mutableStateOf
import androidx.compose.runtime.setValue
import androidx.compose.ui.Modifier
import androidx.compose.ui.graphics.asImageBitmap
import androidx.compose.ui.test.*
import androidx.compose.ui.test.junit4.createAndroidComposeRule
import com.github.takahirom.roborazzi.captureRoboImage
import java.io.File
import org.junit.Assert.assertTrue
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
/** Bright artwork cannot reappear between a landscape title scrim and the card's solid state edge. */
@RunWith(RobolectricTestRunner::class)
@Config(sdk = [34], application = Application::class, qualifiers = "w960dp-h540dp-xhdpi")
@GraphicsMode(GraphicsMode.Mode.NATIVE)
class HomeGradientTest {
@get:Rule val rule = createAndroidComposeRule<ComponentActivity>()
@Test fun focusedAndUnfocusedTileAndWideScrimsReachTheBottomWithoutDarkeningTheUpperImage() {
val bitmap = Bitmap.createBitmap(8, 8, Bitmap.Config.ARGB_8888).apply { eraseColor(android.graphics.Color.WHITE) }
val art = mapOf("solid" to bitmap.asImageBitmap())
val title = HomeTitle("episode", "Episode", "episode", backdrop = "solid", seriesTitle = "Series")
var row by mutableStateOf(HomeRow("gradient", HomeRowKind.Shelf, cards = listOf(title), cardKind = HomeCardKind.Tile))
var focused by mutableStateOf(false)
val memory = HomeViewMemory()
rule.setContent { WolfskinTheme { CompositionLocalProvider(LocalTitleBitmaps provides art) {
Box(Modifier.requiredSize(WolfskinTokens.Shell.stageWidth, WolfskinTokens.Shell.stageHeight).background(WolfskinTokens.Color.bg)) {
HomeShelf(row, memory, focused, 0, emptyList(), {}, {})
}
} } }
val directory = kotlin.io.path.createTempDirectory("wolfskin-gradient-").toFile()
try {
for (kind in listOf(HomeCardKind.Tile, HomeCardKind.Wide)) for (selected in listOf(false, true)) {
rule.runOnIdle { row = row.copy(cardKind = kind); focused = selected }
rule.mainClock.advanceTimeBy(1000)
rule.waitForIdle()
val bounds = rule.onNodeWithTag("home-card:gradient:0").fetchSemanticsNode().boundsInRoot
val file = File(directory, "$kind-$selected.png")
rule.onRoot().captureRoboImage(file.absolutePath)
val rendered = BitmapFactory.decodeFile(file.absolutePath)
try {
val scale = bounds.height / row.cardHeight.value
val x = (bounds.right - WolfskinTokens.Home.cardPadding.value * scale * 2).toInt()
val bottom = (bounds.bottom - WolfskinTokens.CardMetadata.bottom.value * scale - scale).toInt()
val upper = (bounds.top + bounds.height * .4f).toInt()
assertTrue("$kind/$selected image leaks below the scrim", android.graphics.Color.red(rendered.getPixel(x, bottom)) < 80)
assertTrue("$kind/$selected scrim starts too high", android.graphics.Color.red(rendered.getPixel(x, upper)) > 245)
} finally { rendered.recycle() }
}
} finally { directory.deleteRecursively() }
}
}

6
wolfskin-design/src/test/java/org/justinvisser/wolfskin/design/HomeKeysTest.kt
View file

@ -98,10 +98,10 @@ class HomeKeysTest {
var action: HomeAction? = null
rule.setContent { WolfskinTheme { ShellSurface(shell) { modifier -> HomeScreen(shell, snapshot, modifier) { action = it } } } }
press("DOWN")
rule.onNodeWithTag("home-card:nu:2").performMouseInput { enter(center) }
rule.onNodeWithTag("home-card:cw:2").performMouseInput { enter(center) }
rule.waitForIdle()
assertEquals("nu", snapshot.rows[shell.view.row].id)
assertEquals(2, shell.view.cards["nu"])
assertEquals("cw", snapshot.rows[shell.view.row].id)
assertEquals(2, shell.view.cards["cw"])
assertNull(action)
}

175
wolfskin-design/src/test/java/org/justinvisser/wolfskin/design/HomeNavigationTest.kt Normal file
View file

@ -0,0 +1,175 @@
package org.justinvisser.wolfskin.design
import android.app.Application
import androidx.activity.ComponentActivity
import androidx.compose.runtime.getValue
import androidx.compose.runtime.mutableStateOf
import androidx.compose.runtime.setValue
import androidx.compose.ui.input.key.Key
import androidx.compose.ui.test.*
import androidx.compose.ui.test.junit4.createAndroidComposeRule
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 androidx.compose.ui.MotionDurationScale
import com.github.takahirom.roborazzi.captureRoboImage
import java.io.File
/** Directional navigation follows stable rows through page returns and asynchronous replacement. */
@RunWith(RobolectricTestRunner::class)
@Config(sdk = [34], application = Application::class, qualifiers = "w960dp-h540dp-xhdpi")
class HomeNavigationTest {
private val motionScale = object : MotionDurationScale { override val scaleFactor = 1f }
@get:Rule val rule = createAndroidComposeRule<ComponentActivity>(effectContext = motionScale)
private val shell = ShellState(fixturePeople(), "justin").apply { pickerVisible = false }
private val cards = listOf(HomeTitle("episode", "Episode", "episode", seriesTitle = "Series", season = 1, episode = 2))
private val rows = listOf(
HomeRow("hero", HomeRowKind.Hero, cards = cards),
HomeRow("cw", HomeRowKind.Shelf, "Continue watching", cards, HomeCardKind.Wide),
HomeRow("nu", HomeRowKind.Shelf, "Next up", cards, HomeCardKind.Tile),
HomeRow("new", HomeRowKind.Shelf, "New in your library", cards, HomeCardKind.Tile),
HomeRow("pending", HomeRowKind.Shelf, skeleton = true),
HomeRow("section", HomeRowKind.Section),
) + (0..5).map { HomeRow("row-$it", HomeRowKind.Shelf, "Shelf $it", cards) }
private var snapshot by mutableStateOf(HomeSnapshot(rows))
private var title by mutableStateOf<TitleState?>(null)
private var outgoing by mutableStateOf<TitleState?>(null)
private var retainOutgoing = false
@Test fun downScrollAfterBackIsMonotonicAtSixteenMillisecondFrames() {
retainOutgoing = true
mount()
press(Key.DirectionDown)
press(Key.DirectionCenter)
press(Key.Back)
rule.runOnIdle { outgoing = null }
rule.waitForIdle()
rule.mainClock.autoAdvance = false
rule.onRoot().performKeyInput { pressKey(Key.DirectionDown) }
val directory = File(System.getProperty("wolfskin.captureDirectory"), "home-scroll-frames").apply { mkdirs() }
val series = mutableListOf<String>("milliseconds,index,offset")
var previousIndex = shell.view.listState.firstVisibleItemIndex
var previousOffset = shell.view.listState.firstVisibleItemScrollOffset
val start = previousIndex to previousOffset
repeat((WolfskinTokens.Motion.scroll + 64) / 16) { frame ->
rule.mainClock.advanceTimeBy(16)
rule.waitForIdle()
val list = shell.view.listState
val index = list.firstVisibleItemIndex
val offset = list.firstVisibleItemScrollOffset
assertTrue("Scroll must not snap backward at frame $frame", index > previousIndex || index == previousIndex && offset >= previousOffset)
series += "${(frame + 1) * 16},$index,$offset"
rule.onRoot().captureRoboImage(File(directory, "frame-${frame.toString().padStart(2, '0')}.png").absolutePath)
previousIndex = index
previousOffset = offset
}
File(directory, "position.csv").writeText(series.joinToString("\n"))
assertNotEquals("Down must actually scroll after Back", start, previousIndex to previousOffset)
assertEquals(2, shell.view.row)
rule.mainClock.autoAdvance = true
walkDown(start = 2)
}
@Test fun outgoingEpisodeDuringBackCannotTakeOverTheHomeScroller() {
retainOutgoing = true
mount()
press(Key.DirectionDown)
press(Key.DirectionDown)
press(Key.DirectionCenter)
rule.onNodeWithTag("title-page").assertIsDisplayed()
press(Key.Back)
rule.runOnIdle { outgoing = null }
rule.waitForIdle()
assertEquals(2, shell.view.row)
walkDown(start = 2)
}
@Test fun downAdvancesEveryRowAndScrollsAfterEpisodeBack() {
mount()
walkDown()
repeat(rows.count { it.focusable } - 1) { press(Key.DirectionUp) }
press(Key.DirectionDown)
val saved = shell.view
press(Key.DirectionCenter)
rule.onNodeWithTag("title-page").assertIsDisplayed()
press(Key.Back)
assertSame(saved, shell.view)
assertEquals(1, shell.view.row)
walkDown(start = 1)
}
@Test fun refreshReorderInsertionRemovalAndSkeletonReadyKeepDownProgress() {
mount()
press(Key.DirectionDown)
press(Key.DirectionDown)
assertEquals("nu", snapshot.rows[shell.view.row].id)
rule.runOnIdle { snapshot = snapshot.copy(rows = listOf(rows[0], rows[3], rows[1], rows[2]) + rows.drop(4)) }
rule.waitForIdle()
assertEquals("nu", snapshot.rows[shell.view.row].id)
rule.runOnIdle { snapshot = snapshot.copy(rows = snapshot.rows.map { if (it.id == "pending") it.copy(cards = cards, skeleton = false) else it }) }
press(Key.DirectionDown)
assertEquals("pending", snapshot.rows[shell.view.row].id)
rule.runOnIdle { snapshot = snapshot.copy(rows = listOf(HomeRow("insert", HomeRowKind.Shelf, cards = cards)) + snapshot.rows) }
rule.waitForIdle()
assertEquals("pending", snapshot.rows[shell.view.row].id)
rule.runOnIdle { snapshot = snapshot.copy(rows = snapshot.rows.filter { it.id != "pending" }) }
rule.waitForIdle()
assertFalse(shell.navFocused)
walkDown(start = shell.view.row)
}
@Test fun loadingToReadyThenRefreshDoesNotTrapFocusOnPendingRows() {
snapshot = HomeSnapshot(buildHomeRows(HomeLibrary(), emptyList(), loading = true))
mount()
assertTrue(shell.navFocused)
rule.runOnIdle { snapshot = HomeSnapshot(rows) }
rule.waitForIdle()
assertFalse(shell.navFocused)
walkDown()
}
private fun mount() {
rule.setContent { WolfskinTheme {
val page = title
if (page != null) ScreenEntry(shell, "title/episode", true) { TitleSurface(page, shell) }
else ScreenEntry(shell, "home", true) { ShellSurface(shell) { modifier -> HomeScreen(shell, snapshot, modifier) { action ->
if (action is HomeAction.Details) {
shell.enterDestination("title/episode")
title = TitleState(TitlePageData(TitleItem(action.title.id, action.title.title, "episode", held = true)), shell.person) { effect ->
if (effect == TitleAction.Pop) {
if (retainOutgoing) outgoing = title
shell.enterDestination("home")
title = null
}
}
}
} } }
outgoing?.let { ScreenEntry(shell, "title/episode", false) { TitleSurface(it, shell) } }
} }
rule.waitForIdle()
}
private fun walkDown(start: Int = 0) {
val indices = snapshot.rows.indices.filter { it >= start && snapshot.rows[it].focusable }
for (index in indices) {
if (index != start) press(Key.DirectionDown)
assertEquals("Down must advance to ${snapshot.rows[index].id}", index, shell.view.row)
if (snapshot.rows[index].kind == HomeRowKind.Shelf) {
val bounds = rule.onNodeWithTag("home-card:${snapshot.rows[index].id}:0").fetchSemanticsNode().boundsInRoot
assertTrue("Focused card must clear navigation: $bounds", bounds.top >= WolfskinTokens.Layout.navBand.value * rule.density.density)
assertTrue("Focused card must clear screen bottom: $bounds", bounds.bottom <= WolfskinTokens.Shell.stageHeight.value * rule.density.density)
}
}
press(Key.DirectionDown)
assertEquals(indices.last(), shell.view.row)
}
private fun press(key: Key) {
rule.onRoot().performKeyInput { pressKey(key) }
rule.mainClock.advanceTimeBy(1000)
rule.waitForIdle()
}
}

21
wolfskin-design/src/test/java/org/justinvisser/wolfskin/design/HomeRowsTest.kt
View file

@ -44,7 +44,26 @@ class HomeRowsTest {
@Test fun firstReadSkeletonHasNoFocusableContent() {
val rows = buildHomeRows(HomeLibrary(), continuation, loading = true)
assertEquals(listOf(HomeRowKind.Hero, HomeRowKind.Shelf, HomeRowKind.Shelf, HomeRowKind.Shelf, HomeRowKind.Shelf), rows.map { it.kind })
assertTrue(rows.all { !it.focusable })
}
@Test fun mergedWatchRowPrefersResumePerSeriesAndInterleavesByWatchRecency() {
val inProgress = next.copy(id = "resume-a", seriesId = "a", resumeSeconds = 40.0, lastPlayedAt = 30)
val olderResume = inProgress.copy(id = "older-a", lastPlayedAt = 10)
val nextSameSeries = next.copy(id = "next-a", seriesId = "a", lastPlayedAt = 50)
val nextOtherSeries = next.copy(id = "next-b", seriesId = "b", lastPlayedAt = 40)
val film = resume.copy(id = "film", resumeSeconds = 20.0, lastPlayedAt = 20)
val unknown = next.copy(id = "unknown", seriesId = "c")
val library = HomeLibrary(listOf(inProgress, olderResume, film), listOf(nextSameSeries, nextOtherSeries, nextOtherSeries, unknown))
assertEquals(listOf("next-b", "resume-a", "film", "unknown"), continueWatching(library).map { it.id })
val rows = buildHomeRows(library, continuation)
assertFalse(rows.any { it.id == "nu" })
assertEquals(listOf("next-b", "film", "unknown"), rows.single { it.id == "cw" }.cards.map { it.id })
}
@Test fun oldCachedEpisodesWithoutSeriesIdsDeduplicateBySeriesName() {
val checkpoint = next.copy(id = "resume", seriesTitle = "Same series", resumeSeconds = 10.0)
val following = next.copy(id = "next", seriesTitle = "Same series")
assertEquals(listOf(checkpoint), continueWatching(HomeLibrary(listOf(checkpoint), listOf(following))))
}
}

102
wolfskin-design/src/test/java/org/justinvisser/wolfskin/design/ScreenEntryNavigationTest.kt Normal file
View file

@ -0,0 +1,102 @@
package org.justinvisser.wolfskin.design
import android.app.Application
import androidx.activity.ComponentActivity
import androidx.compose.runtime.Composable
import androidx.compose.runtime.getValue
import androidx.compose.runtime.mutableStateOf
import androidx.compose.runtime.setValue
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.Config
/** A retained outgoing title cannot steal another screen's viewport or Android input on Back. */
@RunWith(RobolectricTestRunner::class)
@Config(sdk = [34], application = Application::class, qualifiers = "w960dp-h540dp-xhdpi")
class ScreenEntryNavigationTest {
@get:Rule val rule = createAndroidComposeRule<ComponentActivity>()
private val shell = ShellState(fixturePeople(), "justin").apply { pickerVisible = false }
private val credits = (0..35).map { TitleItem("credit-$it", "Credit $it", "movie") }
private val grid = LibraryGridState("Library", credits.map { LibraryTitle(it.id, it.name, "movie") }).apply { toolbar = false }
private val person = PersonState(TitlePerson("actor", "Actor"), credits, {})
private val title = TitleState(TitlePageData(TitleItem("parent", "Parent", "movie"), cast = listOf(TitlePerson("actor", "Actor")), related = credits.take(10)), shell.person) {}
private val fixture = discoverTestFixture()
private val snapshot = fixture.snapshot("justin")
private val discover = DiscoverState(shell, snapshot, RecordingDiscoverOperations(snapshot, "justin"), CoroutineScope(Dispatchers.Main.immediate), {}, {}, fixture::service)
private var childVisible by mutableStateOf(false)
private var outgoingVisible by mutableStateOf(false)
private lateinit var child: TitleState
@Test fun libraryBackRestoresCardAndDownReachesFinalGridRow() = verify("movies")
@Test fun discoverBackRestoresShelfAndDownReachesFinalShelf() = verify("discover")
@Test fun personBackRestoresCreditAndDownReachesFinalGridRow() = verify("person/actor")
@Test fun titleBackRestoresRowAndDownReachesRelatedShelf() = verify("title/parent")
private fun verify(route: String) {
shell.enterDestination(route)
if (route == "discover") discover.focus(discover.firstShelf, 0)
child = TitleState(TitlePageData(TitleItem("child", "Child episode", "episode", held = true)), shell.person) { action ->
if (action == TitleAction.Pop) {
shell.enterDestination(route)
childVisible = false
outgoingVisible = true
}
}
rule.setContent { WolfskinTheme {
if (!childVisible) ScreenEntry(shell, route, true) { host(route) }
if (childVisible || outgoingVisible) ScreenEntry(shell, "title/child", childVisible) { TitleSurface(child, shell) }
} }
rule.waitForIdle()
val view = shell.view
val before = position(route)
rule.runOnIdle { shell.enterDestination("title/child"); childVisible = true }
press(Key.Back)
rule.runOnIdle { outgoingVisible = false }
rule.waitForIdle()
assertSame(view, shell.view)
assertEquals(before, position(route))
repeat(maxOf(credits.size, discover.rowCount)) {
val previous = position(route)
press(Key.DirectionDown)
assertTrue("$route Down cannot move backward: $previous -> ${position(route)}", position(route) >= previous)
}
val expected = when {
route == "movies" -> (grid.items.lastIndex / grid.columns) * grid.columns
route == "discover" -> discover.rowCount - 1
route.startsWith("person/") -> (credits.lastIndex / WolfskinTokens.Behaviour.gridColumns.toInt()) * WolfskinTokens.Behaviour.gridColumns.toInt()
else -> title.rows.lastIndex
}
assertEquals("$route must reach its last row after Back", expected, position(route))
assertTrue("$route must scroll its last row into composition", view.listState.firstVisibleItemIndex > 0)
}
@Composable private fun host(route: String) {
when {
route == "movies" -> ShellSurface(shell) { LibraryScreen(shell, grid, it) }
route == "discover" -> ShellSurface(shell) { DiscoverScreen(discover, it) }
route.startsWith("person/") -> PersonSurface(person, shell)
else -> TitleSurface(title, shell)
}
}
private fun position(route: String): Int = when {
route == "movies" -> grid.index
route == "discover" -> discover.focusedRow
route.startsWith("person/") -> person.index
else -> title.rows.indexOf(title.row)
}
private fun press(key: Key) {
rule.onRoot().performKeyInput { pressKey(key) }
rule.mainClock.advanceTimeBy(1000)
rule.waitForIdle()
}
}

2
wolfskin-design/tokens.css
View file

@ -411,7 +411,7 @@
--home-factsGap: 22.0px;
--home-overviewBottom: 30.0px;
--home-cardPadding: 22.0px;
--home-cardOverlayTop: 54.0px;
--home-cardOverlayTop: 36.0px;
--home-cardOverlayBottom: 18.0px;
--home-sectionTop: 40.0px;
--home-sectionAvatar: 56.0px;

6
wolfskin-design/tokens.sha256
View file

@ -1,8 +1,8 @@
b3f096b692c395534177cc82ac68f5b801870bc7e28f0dd5cd7c17e2103920a3 discover-tokens.json
c29dc64f3c3ca900c747b3db8b270e25908948bf5f76388d2c627a612fc7c99d generate_tokens.py
eef4e9f8c91306362540eda617c9efad4e19ed688f205f6f486625a5918d8105 home-tokens.json
72b67ad9ba95e7bbc17cec29cc676b06b7e9d81c546022b5a100d6d4e2a27c64 home-tokens.json
192beb887fc34005db99c87ffbcbaf4a057ee2728475fc96224cf89445019b51 shell-tokens.json
3e2ad9a57c15c2ed4713abf383807bb567b27b38eddaaa36c00025e078864e12 src/main/java/org/justinvisser/wolfskin/design/WolfskinTokens.kt
695e086fd771ee463411a28e8f241637c3c86d13e9474995abaea27a1feff1b7 src/main/java/org/justinvisser/wolfskin/design/WolfskinTokens.kt
062597ea50dff9e6987485f9a83d412918dba3e10109524c26d3c2332a2f5b73 title-tokens.json
d7d6b17f8258083c879365f01e06729aa0fa12b69b7cd81e1bceabbbe6ab2a7d tokens.css
71905adcd89991f8ce41859cce7714fcf382a19de25538e5272a84e88f070b07 tokens.css
ba0da02b03047fbc2f29d538d980e87aa237f8ae36545aa4234600243fe14929 tokens.json