diff --git a/CHANGELOG.md b/CHANGELOG.md
index 8098db5..69d4c0d 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,5 +1,10 @@
# Kaleido releases
+## 0.4.1
+
+- Make Categories about the genre: large centered labels over dim artwork with subdued natural color, a compact four-column grid and a restrained focus outline. Remove title captions and FILM/SERIES badges from category cards.
+- Give every movie and TV category a distinct artwork source. Match overlapping genres together, preserve scarce choices, and fetch more candidates when needed instead of reusing a background.
+
## 0.4.0
- Frame TV show, season and episode background artwork against the full page, preserving the top of the scene instead of cropping it into a short season header, with no gap above the artwork.
diff --git a/app/src/main/java/tv/kaleido/app/BrowseScreens.kt b/app/src/main/java/tv/kaleido/app/BrowseScreens.kt
index 45340e4..43e8030 100644
--- a/app/src/main/java/tv/kaleido/app/BrowseScreens.kt
+++ b/app/src/main/java/tv/kaleido/app/BrowseScreens.kt
@@ -26,6 +26,8 @@ import androidx.compose.ui.geometry.Size
import androidx.compose.ui.focus.*
import androidx.compose.ui.graphics.Brush
import androidx.compose.ui.graphics.Color
+import androidx.compose.ui.graphics.ColorFilter
+import androidx.compose.ui.graphics.ColorMatrix
import androidx.compose.ui.graphics.graphicsLayer
import androidx.compose.ui.input.key.*
import androidx.compose.ui.text.font.FontWeight
@@ -176,7 +178,8 @@ internal fun anticipateTileMove(vm:KaleidoViewModel,items:List
,index:Int,
else if(vm.genres.isEmpty())EmptyState("No categories available","This Plex library has no genre categories.")
else {
val categoryRequesters=remember(vm.section?.id,vm.genres,categoryEntryFocus){vm.genres.mapIndexed{i,entry->entry.first to if(i==0)categoryEntryFocus else FocusRequester()}.toMap()}
- LazyVerticalGrid(GridCells.Fixed(3),contentPadding=PaddingValues(start=Cinema.gutter,end=Cinema.gutter,top=18.dp,bottom=30.dp),horizontalArrangement=Arrangement.spacedBy(13.dp),verticalArrangement=Arrangement.spacedBy(12.dp),modifier=Modifier.fillMaxSize()) {
+ val categoryColor=remember{ColorFilter.colorMatrix(ColorMatrix().apply{setToSaturation(.65f)})}
+ LazyVerticalGrid(GridCells.Fixed(4),contentPadding=PaddingValues(start=Cinema.gutter,end=Cinema.gutter,top=18.dp,bottom=30.dp),horizontalArrangement=Arrangement.spacedBy(13.dp),verticalArrangement=Arrangement.spacedBy(13.dp),modifier=Modifier.fillMaxSize()) {
itemsIndexed(vm.genres,key={_,it->it.first}){index,entry->
val requester=categoryRequesters.getValue(entry.first)
val sample=vm.categoryArtwork[entry.first]
@@ -184,21 +187,15 @@ internal fun anticipateTileMove(vm:KaleidoViewModel,items:List,index:Int,
var focused by remember(entry.first,vm.section?.id){mutableStateOf(false)}
val shape=RoundedCornerShape(Cinema.radius)
Box(Modifier.fillMaxWidth().aspectRatio(16f/9f).focusRequester(requester).focusProperties {
- left=if(index%3==0)FocusRequester.Cancel else categoryRequesters.getValue(vm.genres[index-1].first)
- right=if(index%3==2||index==vm.genres.lastIndex)FocusRequester.Cancel else categoryRequesters.getValue(vm.genres[index+1].first)
- up=if(index<3)categoriesFocus else categoryRequesters.getValue(vm.genres[index-3].first)
- down=if(index+3>=vm.genres.size)FocusRequester.Cancel else categoryRequesters.getValue(vm.genres[index+3].first)
- }.onFocusChanged{focused=it.isFocused;if(it.isFocused)vm.focusId="category:${entry.first}"}.navigationSound().clip(shape).background(Color(0xFF171717)).border(1.dp,Color.White.copy(alpha=if(focused).9f else .09f),shape).clickable{vm.selectCategory(entry.first)}) {
- if(artworkPath.isNotBlank())Artwork(vm.api,artworkPath,Modifier.fillMaxSize(),540,304)
- Box(Modifier.fillMaxSize().background(Brush.verticalGradient(listOf(Color.Black.copy(alpha=.08f),Color.Black.copy(alpha=.12f),Color.Black.copy(alpha=.9f)))))
- Box(Modifier.align(Alignment.TopStart).padding(9.dp).background(Color.Black.copy(alpha=.6f),RoundedCornerShape(3.dp)).padding(horizontal=7.dp,vertical=4.dp)) {
- Text(if(vm.section?.type=="movie")"FILM"else"SERIES",color=Color.White.copy(alpha=.88f),fontSize=8.sp,lineHeight=10.sp,fontWeight=FontWeight.SemiBold,letterSpacing=1.sp,maxLines=1)
- }
- Column(Modifier.align(Alignment.BottomStart).fillMaxWidth().padding(horizontal=17.dp,vertical=15.dp)) {
- if(sample!=null)Text(sample.title,color=Color.White.copy(alpha=.78f),fontSize=11.sp,lineHeight=12.sp,fontWeight=FontWeight.Medium,maxLines=1,overflow=TextOverflow.Ellipsis)
- Text(entry.second,color=Color.White,fontSize=16.sp,lineHeight=19.sp,fontWeight=FontWeight.SemiBold,maxLines=1,overflow=TextOverflow.Ellipsis)
- }
- if(focused)Box(Modifier.fillMaxSize().padding(3.dp).border(1.dp,Color.White.copy(alpha=.85f),shape))
+ left=if(index%4==0)FocusRequester.Cancel else categoryRequesters.getValue(vm.genres[index-1].first)
+ right=if(index%4==3||index==vm.genres.lastIndex)FocusRequester.Cancel else categoryRequesters.getValue(vm.genres[index+1].first)
+ up=if(index<4)categoriesFocus else categoryRequesters.getValue(vm.genres[index-4].first)
+ down=if(index+4>=vm.genres.size)FocusRequester.Cancel else categoryRequesters.getValue(vm.genres[index+4].first)
+ }.onFocusChanged{focused=it.isFocused;if(it.isFocused)vm.focusId="category:${entry.first}"}.navigationSound().clip(shape).background(Color(0xFF171717)).border(if(focused)2.dp else 1.dp,Color.White.copy(alpha=if(focused).9f else .1f),shape).clickable{vm.selectCategory(entry.first)}) {
+ if(artworkPath.isNotBlank())Artwork(vm.api,artworkPath,Modifier.fillMaxSize(),540,304,colorFilter=categoryColor)
+ Box(Modifier.fillMaxSize().background(Color.Black.copy(alpha=if(focused).48f else .62f)))
+ Text(entry.second,color=Color.White,fontSize=22.sp,lineHeight=26.sp,fontWeight=FontWeight.SemiBold,maxLines=2,overflow=TextOverflow.Ellipsis,textAlign=androidx.compose.ui.text.style.TextAlign.Center,
+ style=LocalTextStyle.current.copy(shadow=androidx.compose.ui.graphics.Shadow(Color.Black,androidx.compose.ui.geometry.Offset(0f,1f),5f)),modifier=Modifier.align(Alignment.Center).fillMaxWidth().padding(horizontal=16.dp))
}
LaunchedEffect(vm.focusId,index){if((vm.focusId=="categories-entry"&&index==0)||vm.focusId=="category:${entry.first}"){withFrameNanos{};runCatching{requester.requestFocus()}}}
}
diff --git a/app/src/main/java/tv/kaleido/app/CategoryArtwork.kt b/app/src/main/java/tv/kaleido/app/CategoryArtwork.kt
new file mode 100644
index 0000000..c5da294
--- /dev/null
+++ b/app/src/main/java/tv/kaleido/app/CategoryArtwork.kt
@@ -0,0 +1,29 @@
+package tv.kaleido.app
+
+/** Match genres to distinct artwork sources, moving an earlier choice when a later genre needs it. */
+internal fun selectCategoryArtwork(candidates:Map>,identity:(T)->String):Map {
+ val options=candidates.mapValues{(_,items)->items.filter{identity(it).isNotBlank()}.distinctBy(identity)}
+ val owners=mutableMapOf()
+ val selected=mutableMapOf()
+ fun assign(genre:String,visited:MutableSet):Boolean {
+ // Keep preferred choices where possible; try free sources before moving another genre.
+ val choices=options.getValue(genre)
+ choices.firstOrNull{identity(it) !in owners&&identity(it) !in visited}?.let {
+ owners[identity(it)]=genre;selected[genre]=it;return true
+ }
+ for(item in choices) {
+ val key=identity(item)
+ if(!visited.add(key))continue
+ val previous=owners[key] ?: continue
+ if(assign(previous,visited)){owners[key]=genre;selected[genre]=item;return true}
+ }
+ return false
+ }
+ // Give narrow genres first choice, so a broad category cannot exhaust their only source.
+ options.keys.sortedBy{options.getValue(it).size}.forEach{assign(it,mutableSetOf())}
+ return candidates.keys.mapNotNull{genre->selected[genre]?.let{genre to it}}.toMap()
+}
+
+/** Plex timestamps/query strings do not make a refreshed image a different artwork source. */
+private val artworkVersion=Regex("(/(?:art|thumb))/[0-9]+$")
+internal fun categoryArtworkIdentity(path:String):String = path.substringBefore('?').replace(artworkVersion,"\$1")
diff --git a/app/src/main/java/tv/kaleido/app/KaleidoViewModel.kt b/app/src/main/java/tv/kaleido/app/KaleidoViewModel.kt
index 2b93995..e0dcc4a 100644
--- a/app/src/main/java/tv/kaleido/app/KaleidoViewModel.kt
+++ b/app/src/main/java/tv/kaleido/app/KaleidoViewModel.kt
@@ -126,6 +126,8 @@ class KaleidoViewModel(app: Application): AndroidViewModel(app) {
private var categoryArtworkJob: Job? = null
private var categoryArtworkSectionId = ""
private var categoryArtworkGeneration = 0
+ private var categoryArtworkGenres=emptyList>()
+ private var categoryArtworkComplete=false
private val detailsCache = mutableMapOf()
private val sectionCache=mutableMapOf()
private val characterOffsetCache=mutableMapOf>()
@@ -272,6 +274,7 @@ class KaleidoViewModel(app: Application): AndroidViewModel(app) {
categoryArtworkJob?.cancel();categoryArtworkJob=null
categoryArtworkSectionId=sectionId.orEmpty()
categoryArtwork=emptyMap()
+ categoryArtworkGenres=emptyList();categoryArtworkComplete=false
}
override fun onCleared(){cancelAnticipation();artworkPrefetchDispatcher.close();super.onCleared()}
fun linkAccount() {
@@ -421,38 +424,84 @@ class KaleidoViewModel(app: Application): AndroidViewModel(app) {
fun loadCategoryArtworks() {
val selectedSection=section ?: return
if(!categories||genre.isNotBlank()||genres.isEmpty())return
- if(categoryArtworkSectionId!=selectedSection.id)resetCategoryArtwork(selectedSection.id)
- val localSamples=genres.mapNotNull{entry->
- val hint=categoryArtworkHint(selectedSection,entry.second)
- val sample=library.firstOrNull{item->
- item.type==selectedSection.type&&item.genres.any{it.equals(entry.second,ignoreCase=true)}&&
- item.artworkPath().isNotBlank()&&(hint==null||item.title.contains(hint,ignoreCase=true))
- }
- sample?.let{entry.first to it}
- }.toMap()
- if(localSamples.isNotEmpty())categoryArtwork=categoryArtwork+localSamples
- val missing=genres.filter{entry->entry.first !in categoryArtwork}
- if(missing.isEmpty()||categoryArtworkJob?.isActive==true)return
+ if(categoryArtworkSectionId!=selectedSection.id||categoryArtworkGenres!=genres)resetCategoryArtwork(selectedSection.id)
+ categoryArtworkGenres=genres.toList()
+ if(categoryArtworkComplete||categoryArtworkJob?.isActive==true)return
val sectionId=selectedSection.id
val sectionType=selectedSection.type
val generation=categoryArtworkGeneration
+ val entries=genres.toList()
+ fun ordered(entry:Pair,items:List):List {
+ val hint=categoryArtworkHint(selectedSection,entry.second)
+ return items.filter{it.type==sectionType&&it.artworkPath().isNotBlank()}.distinctBy{it.id}
+ .sortedBy{if(hint!=null&&it.title.contains(hint,ignoreCase=true))0 else 1}
+ }
+ val candidates=entries.associate{entry->entry.first to ordered(entry,library.filter{item->item.genres.any{it.equals(entry.second,ignoreCase=true)}})}.toMutableMap()
+ fun choose()=selectCategoryArtwork(candidates){categoryArtworkIdentity(it.artworkPath())}
+ // The initial cached samples follow the same uniqueness rule as network results.
+ if(categoryArtwork.isEmpty())categoryArtwork=choose()
categoryArtworkJob=viewModelScope.launch {
val requestGate=Semaphore(3)
- coroutineScope {
- missing.map{entry->async {
+ val offsets=mutableMapOf()
+ val totals=mutableMapOf()
+ var failed=false
+ fun current()=generation==categoryArtworkGeneration&&categoryArtworkSectionId==sectionId&§ion?.id==sectionId
+ suspend fun fetch(batch:List>,first:Boolean=false) {
+ val pages=coroutineScope {batch.map{entry->async {
requestGate.withPermit {
val hint=categoryArtworkHint(selectedSection,entry.second)
- val results=try {
- api.library(sectionId,sort="titleSort:asc",genre=entry.first,size=if(hint!=null)80 else 12,type=plexLibraryType(sectionType)).items
- }catch(e:CancellationException){throw e}catch(_:Exception){emptyList()}
- val matching=results.filter{it.type==sectionType}
- val sample=matching.firstOrNull{hint!=null&&it.title.contains(hint,ignoreCase=true)&&it.artworkPath().isNotBlank()}
- ?:matching.firstOrNull{it.artworkPath().isNotBlank()}
- if(sample!=null&&generation==categoryArtworkGeneration&&categoryArtworkSectionId==sectionId&§ion?.id==sectionId)
- categoryArtwork=categoryArtwork+(entry.first to sample)
+ entry to try {
+ api.library(sectionId,start=offsets[entry.first] ?: 0,sort="titleSort:asc",genre=entry.first,size=if(first&&hint!=null)80 else 32,type=plexLibraryType(sectionType))
+ }catch(e:CancellationException){throw e}catch(_:Exception){null}
}
- }}.awaitAll()
+ }}.awaitAll()}
+ for((entry,page) in pages) {
+ if(page==null){failed=true;totals[entry.first]=offsets[entry.first] ?: 0;continue}
+ offsets[entry.first]=(offsets[entry.first] ?: 0)+page.items.size
+ totals[entry.first]=if(page.items.isEmpty())offsets.getValue(entry.first)else page.total
+ candidates[entry.first]=ordered(entry,candidates[entry.first].orEmpty()+page.items)
+ }
}
+ fetch(entries,first=true)
+ if(!current())return@launch
+ var chosen=choose()
+ categoryArtwork=chosen
+ // Expand only overlapping candidate groups that could free a missing genre.
+ while(chosen.sizeif(items.any{categoryArtworkIdentity(it.artworkPath()) in sources})needed+=genre}
+ expanded=needed.size>count
+ }
+ val more=entries.filter{it.first in needed&&(offsets[it.first] ?: 0)<(totals[it.first] ?: 0)}
+ if(more.isEmpty())break
+ fetch(more)
+ if(!current())return@launch
+ chosen=choose();categoryArtwork=chosen
+ }
+ if(chosen.sizeasync {
+ val variants=mutableListOf()
+ for(item in candidates[entry.first].orEmpty()) {
+ val paths=try {requestGate.withPermit{api.categoryArtAlternatives(item.id)}}
+ catch(e:CancellationException){throw e}catch(_:Exception){failed=true;emptyList()}
+ variants+=paths.filter{categoryArtworkIdentity(it) !in used}.map{item.copy(art=it)}
+ if(variants.size>=remaining.size)break
+ }
+ entry.first to variants
+ }}.awaitAll().toMap()}
+ if(!current())return@launch
+ chosen=chosen+selectCategoryArtwork(alternatives){categoryArtworkIdentity(it.artworkPath())}
+ categoryArtwork=chosen
+ }
+ categoryArtworkComplete=!failed
}
}
fun selectCategory(value:String){if(value.isBlank())return;categories=true;allTitles=true;genre=value;sort="titleSort:asc";focusId="category-grid";libraryJumpIndex=-1;libraryJumpLetter=null;refreshLibrary()}
diff --git a/app/src/main/java/tv/kaleido/app/PlexApi.kt b/app/src/main/java/tv/kaleido/app/PlexApi.kt
index d3c4d19..35608ad 100644
--- a/app/src/main/java/tv/kaleido/app/PlexApi.kt
+++ b/app/src/main/java/tv/kaleido/app/PlexApi.kt
@@ -75,6 +75,11 @@ class PlexApi(val clientId: String) {
val seasons=container("/library/sections/$section/all",mapOf("type" to "3","sort" to "addedAt:desc","X-Plex-Container-Size" to "100")).optJSONArray("Metadata").objects().map(Title::parse)
groupRecentSeasons(seasons,::details)
}
+ /** Alternative landscape art, used when two narrow genres only contain the same title. */
+ suspend fun categoryArtAlternatives(id:String):List = container("/library/metadata/$id/arts")
+ .optJSONArray("Metadata").objects().filterNot{it.optBoolean("selected")}
+ .map{it.optString("key")}.filter{it.startsWith('/')||it.startsWith("https://")}.distinct()
+
suspend fun library(section: String, start: Int = 0, sort: String = "titleSort:asc", genre: String = "", unwatched: Boolean = false, size:Int=100, type:String=""): LibraryPage = withContext(Dispatchers.Default){
val p=mutableMapOf("X-Plex-Container-Start" to start.toString(),"X-Plex-Container-Size" to size.coerceAtLeast(1).toString(),"sort" to sort)
p.putAll(libraryFilterParameters(genre,unwatched,type))
diff --git a/app/src/main/java/tv/kaleido/app/Screens.kt b/app/src/main/java/tv/kaleido/app/Screens.kt
index 53663f0..6dbe972 100644
--- a/app/src/main/java/tv/kaleido/app/Screens.kt
+++ b/app/src/main/java/tv/kaleido/app/Screens.kt
@@ -49,12 +49,12 @@ import androidx.compose.ui.node.ModifierNodeElement
import androidx.compose.material.icons.automirrored.outlined.ArrowBack
import java.io.File
-@Composable fun Artwork(api: PlexApi,path: String,modifier: Modifier=Modifier,width: Int=600,height: Int=900,animate:Boolean=true,contentScale:ContentScale=ContentScale.Crop) {
+@Composable fun Artwork(api: PlexApi,path: String,modifier: Modifier=Modifier,width: Int=600,height: Int=900,animate:Boolean=true,contentScale:ContentScale=ContentScale.Crop,colorFilter:androidx.compose.ui.graphics.ColorFilter?=null) {
val context=LocalContext.current
// The server already scales to width × height. Stating that size lets Coil resolve cache
// hits while composing, instead of each painter waiting for layout to measure it.
val model=remember(path,api.session?.server,width,height,animate){api.image(path,width,height)?.let {u -> ImageRequest.Builder(context).data(u).apply {api.headers().forEach{(k,v)->addHeader(k,v)}}.size(width,height).precision(Precision.INEXACT).crossfade(if(animate)180 else 0).build()}}
- AsyncImage(model=model,contentDescription=null,contentScale=contentScale,modifier=modifier.background(Panel))
+ AsyncImage(model=model,contentDescription=null,contentScale=contentScale,colorFilter=colorFilter,modifier=modifier.background(Panel))
}
@Composable fun KaleidoApp(vm: KaleidoViewModel,install: (File)->Unit) {
KaleidoTheme {
diff --git a/app/src/test/java/tv/kaleido/app/CategoryArtworkTest.kt b/app/src/test/java/tv/kaleido/app/CategoryArtworkTest.kt
new file mode 100644
index 0000000..8b0a3a1
--- /dev/null
+++ b/app/src/test/java/tv/kaleido/app/CategoryArtworkTest.kt
@@ -0,0 +1,55 @@
+package tv.kaleido.app
+
+import org.junit.Assert.*
+import org.junit.Assume.assumeTrue
+import org.junit.Test
+import java.io.File
+
+class CategoryArtworkTest {
+ @Test fun overlappingGenresUseDifferentShows() {
+ val chosen=selectCategoryArtwork(linkedMapOf("Adventure" to listOf("Adventure Time","Silo"),"Children" to listOf("Adventure Time","Bluey"))){it}
+ assertEquals(2,chosen.values.toSet().size)
+ assertEquals("Adventure Time",chosen["Adventure"])
+ assertEquals("Bluey",chosen["Children"])
+ }
+
+ @Test fun narrowGenresKeepTheirOnlySource() {
+ val chosen=selectCategoryArtwork(linkedMapOf("Action" to listOf("Shared","Action only"),"Children" to listOf("Shared"))){it}
+ assertEquals(mapOf("Action" to "Action only","Children" to "Shared"),chosen)
+ }
+
+ @Test fun unavailableUniqueSourcesNeverProduceDuplicates() {
+ val chosen=selectCategoryArtwork(mapOf("A" to listOf("Same","Same"),"B" to listOf("Same"),"Empty" to listOf(""))){it}
+ assertEquals(1,chosen.size)
+ assertEquals(1,chosen.values.toSet().size)
+ assertFalse(chosen.containsKey("Empty"))
+ assertEquals("/library/metadata/12/art",categoryArtworkIdentity("/library/metadata/12/art/123?cache=1"))
+ }
+
+ @Test fun matchingFindsEveryAvailableAssignmentInSmallOverlappingCatalogs() {
+ // Exhaust all 512 three-genre/three-source graphs against a brute-force reference.
+ for(mask in 0 until 512) {
+ val candidates=(0..2).associate{i->i.toString() to (0..2).filter{j->mask and (1 shl (i*3+j))!=0}.map(Int::toString)}
+ fun maximum(index:Int,used:Set):Int = if(index==3)0 else maxOf(
+ maximum(index+1,used),candidates.getValue(index.toString()).filter{it !in used}.maxOfOrNull{1+maximum(index+1,used+it)} ?: 0)
+ val selected=selectCategoryArtwork(candidates){it}
+ assertEquals("catalog $mask",maximum(0,emptySet()),selected.size)
+ assertEquals(selected.size,selected.values.toSet().size)
+ }
+ }
+
+ @Test fun realPlexCategoryCandidatesHaveCompleteUniqueAssignments() {
+ val path=System.getenv("KALEIDO_CATEGORY_FIXTURE")
+ assumeTrue("Optional private, read-only Plex fixture",!path.isNullOrBlank())
+ val rows=File(path!!).readLines().map{it.split('\t',limit=5)}
+ for((kind,section) in rows.groupBy{it[0]}) {
+ val candidates=section.groupBy{it[1]}.mapValues{(_,items)->items}
+ val selected=selectCategoryArtwork(candidates){categoryArtworkIdentity(it[3])}
+ assertEquals("Every $kind category needs artwork",candidates.size,selected.size)
+ val distinctTitles=selectCategoryArtwork(candidates){it[2]}.size
+ assertEquals("Use as many distinct titles as the library allows",distinctTitles,selected.values.map{it[2]}.toSet().size)
+ assertEquals(selected.size,selected.values.map{categoryArtworkIdentity(it[3])}.toSet().size)
+ println("PASS $kind: ${selected.size} distinct backgrounds from $distinctTitles different titles")
+ }
+ }
+}
diff --git a/distribution/Kaleido.apk b/distribution/Kaleido.apk
index b9f58dc..0dea512 100644
Binary files a/distribution/Kaleido.apk and b/distribution/Kaleido.apk differ
diff --git a/distribution/Kaleido.apk.sha256 b/distribution/Kaleido.apk.sha256
index ad022fa..c25d9fa 100644
--- a/distribution/Kaleido.apk.sha256
+++ b/distribution/Kaleido.apk.sha256
@@ -1 +1 @@
-ed81fd04d09650c9ff43aae39d8638f5015048d608d10fd67e939124e8b1548e Kaleido.apk
+6644676bc7c84caf8b3a917bb2f48c088ae6ad5871c3681308713eece3442d6a Kaleido.apk
diff --git a/distribution/latest.json b/distribution/latest.json
index 9acc770..c889078 100644
--- a/distribution/latest.json
+++ b/distribution/latest.json
@@ -1,7 +1,7 @@
{
- "version": "0.4.0",
- "versionCode": 17,
- "url": "https://git.elijahkuntz.com/Elijah/Kaleido/raw/tag/v0.4.0/distribution/Kaleido.apk",
- "checksumUrl": "https://git.elijahkuntz.com/Elijah/Kaleido/raw/tag/v0.4.0/distribution/Kaleido.apk.sha256",
- "notes": "- Frame TV show, season and episode background artwork against the full page, preserving the top of the scene instead of cropping it into a short season header, with no gap above the artwork.\n- Redesign Movie and TV Categories with large artwork cards drawn from titles in each Plex genre, with clear remote focus and category return navigation.\n- Show a brief animated direction and seconds cue when tapping Left or Right during playback. Repeated taps accumulate and holding still opens the timeline.\n- Remove the broken in-app voice search button. Android TV keyboard voice input remains available. Add a Clear button that empties the query and results and returns focus to the search field."
+ "version": "0.4.1",
+ "versionCode": 18,
+ "url": "https://git.elijahkuntz.com/Elijah/Kaleido/raw/tag/v0.4.1/distribution/Kaleido.apk",
+ "checksumUrl": "https://git.elijahkuntz.com/Elijah/Kaleido/raw/tag/v0.4.1/distribution/Kaleido.apk.sha256",
+ "notes": "- Make Categories about the genre: large centered labels over dim artwork with subdued natural color, a compact four-column grid and a restrained focus outline. Remove title captions and FILM/SERIES badges from category cards.\n- Give every movie and TV category a distinct artwork source. Match overlapping genres together, preserve scarce choices, and fetch more candidates when needed instead of reusing a background."
}
diff --git a/docs/runtime-verification.md b/docs/runtime-verification.md
index 6ec3d74..b08348c 100644
--- a/docs/runtime-verification.md
+++ b/docs/runtime-verification.md
@@ -4,6 +4,13 @@ For the 2026-10-26 codec/HDR sweep and its native-versus-converted playback find
Target: the authorized onn at `192.168.50.195:5555`, package `tv.kaleido.app`. Other applications and the launcher were not modified. Screenshots, traces, UI dumps and server-specific logs stay in ignored `evidence/private/`.
+## 2026-10-28 genre-led category revision (0.4.1)
+
+- The user requested a genre-led page instead of title-led cards: four columns, centered 22 sp genre labels, no title captions or FILM/SERIES badges, and dim artwork in the background. Natural artwork color is retained at 65% saturation after a monochrome preview was rejected. There are no added genre color tints.
+- Release build/lint and the focused Movie/TV category navigation, selection and Back-restoration checks passed. The final build was installed/profile-compiled on the onn; final screenshots are `evidence/private/041-movies-unique.png`, `041-tv-unique.png` and `041-tv-lower-unique.png`. Verified different Adventure/Children shows and distinct Talk/Talk Show landscape images on the actual TV UI, traversed lower rows, and returned the signed release to Home.
+- After reviewing the color preview, the user authorized publication once duplicate backgrounds were fixed. Artwork candidates are now matched across the whole selected library so categories cannot reuse a source; narrow genres get priority and overlapping groups can fetch additional pages. Selection is deterministic and applied atomically after the candidate requests, with the existing section/generation guards. The earlier 0.4.0 public APK/checksum were also verified.
+- Five focused `CategoryArtworkTest` checks passed, including every three-genre/three-source overlap graph and a private read-only Plex fixture: 31 movie backgrounds from 31 titles, and 37 TV backgrounds from 36 titles. Talk and Talk Show each contain only The Grand Tour, so the remaining tile uses a different landscape from Plex's artwork list. Both images were downloaded through Plex and their SHA-256 values differ. Initial independent selection reproduced six repeated movie sources and fourteen repeated TV sources. No Plex metadata or artwork selection was changed.
+
## 2026-10-28 artwork, category cards, quick skips and search (0.4.0)
- Started from the latest published 0.3.1 history, retaining its episode-row reentry fix and regression script.
diff --git a/scripts/verify_040.py b/scripts/verify_040.py
index 067db0e..a1b22a7 100644
--- a/scripts/verify_040.py
+++ b/scripts/verify_040.py
@@ -56,8 +56,9 @@ def categories_check():
launch(); key(22, moves); focused(name); key(20); focused('Discover')
key(22, 2); focused('Categories'); key(23)
wait(lambda r:focus(r) not in ('','Categories'), 'Category entry')
- # Artwork metadata labels prove a matching Plex sample has loaded.
- wait(lambda r:any(x in labels(r) for x in ['FILM','SERIES']), 'Artwork cards loaded')
+ root=snapshot()
+ assert not any(x in labels(root) for x in ['FILM','SERIES']), 'Categories must only label genres'
+ assert not any(x in labels(root) for x in ['The Batman','Hazbin Hotel']), 'Artwork titles must not appear on categories'
time.sleep(2); screenshot('040-'+name.lower().replace(' ','-')+'-categories')
first=focus(snapshot()); key(22); second=focus(snapshot())
assert first!=second
diff --git a/version.properties b/version.properties
index daf6acf..5ef78b2 100644
--- a/version.properties
+++ b/version.properties
@@ -1,2 +1,2 @@
-versionName=0.4.0
-versionCode=17
+versionName=0.4.1
+versionCode=18