Release 0.1.3 with the aperture startup animation

The cold-start splash is now an iris: the closed aperture gathers light,
twists open with light leaking through its gaps, a sheen crosses the mark
and the wordmark slides out from behind it. The exit flies through the
aperture's center into the app instead of crossfading. The iris holds while
startup data arrives so cold-start hitches never land mid-motion.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
This commit is contained in:
Elijah 2026-10-24 10:58:15 -07:00
parent 430616330b
commit b2592d69e1
9 changed files with 256 additions and 73 deletions

View file

@ -1,5 +1,11 @@
# Kaleido releases
## 0.1.3
- Redesign the startup animation: the six-facet aperture opens like a camera iris with light leaking through its gaps, a sheen crosses the mark, and the wordmark slides out from behind it.
- Fly through the aperture's center into Home instead of crossfading, with the app settling into place behind it.
- Hold the closed iris briefly while startup data arrives, so cold-start loading no longer stutters the animation.
## 0.1.2
- Add navigation tap sounds with a persistent On/Off setting under Settings > Interface. Sounds default to On and follow the TV's system sound-effects setting.

View file

@ -4,6 +4,7 @@ package tv.kaleido.app
import androidx.activity.compose.BackHandler
import androidx.compose.animation.Crossfade
import androidx.compose.animation.core.Animatable
import androidx.compose.animation.core.LinearEasing
import androidx.compose.animation.core.tween
import androidx.compose.animation.core.animateFloatAsState
import androidx.compose.foundation.*
@ -64,11 +65,11 @@ import java.io.File
// A restored Activity after process eviction still needs the cold-start cover.
var startup by remember{mutableStateOf(true)}
var brandReady by remember{mutableStateOf(false)}
val splash=remember{Animatable(1f)}
val splashExit=remember{Animatable(0f)}
LaunchedEffect(brandReady){
if(startup&&brandReady){
withTimeoutOrNull(600){snapshotFlow{!vm.busy}.first{it}}
splash.animateTo(0f,tween(360));startup=false
splashExit.animateTo(1f,tween(StartupExitMillis,easing=LinearEasing));startup=false
}
}
BackHandler(enabled=vm.linkingAccount||vm.playing!=null||vm.pages.size>1||vm.page.kind!="home"){
@ -76,6 +77,8 @@ import java.io.File
}
NavigationSounds(vm.navigationSounds&&!startup) {
Box(Modifier.fillMaxSize().background(Ink).onPreviewKeyEvent{startup}) {
// The app settles into place behind the splash as its aperture opens.
Box(Modifier.fillMaxSize().then(if(startup)Modifier.graphicsLayer{val s=startupArrivalScale(splashExit.value);scaleX=s;scaleY=s}else Modifier)) {
if(vm.servers.isNotEmpty()) ServerPicker(vm) else if(vm.session==null||vm.linkingAccount) SignIn(vm) else {
Column(Modifier.fillMaxSize().graphicsLayer{
alpha=.18f+.82f*entrance.value
@ -94,10 +97,11 @@ import java.io.File
}
if(immersive)TopBar(vm,discoveryFocus)
}
}
if(vm.busy) LinearProgressIndicator(Modifier.fillMaxWidth().height(2.dp).align(Alignment.TopCenter),color=Accent,trackColor=Color.Transparent)
if(vm.error!=null) ErrorDialog(vm.error!!,{vm.dismissError()},{vm.retry()})
vm.playing?.let {item-> androidx.compose.runtime.key(item.id) {PlaybackScreen(vm,item)} }
if(startup)StartupSplash(splash.value){brandReady=true}
if(startup)StartupSplash({splashExit.value},{!vm.busy}){brandReady=true}
}
}
}

View file

@ -1,96 +1,261 @@
package tv.kaleido.app
import androidx.compose.animation.core.Animatable
import androidx.compose.animation.core.FastOutSlowInEasing
import androidx.compose.animation.core.CubicBezierEasing
import androidx.compose.animation.core.LinearEasing
import androidx.compose.animation.core.tween
import androidx.compose.foundation.Canvas
import androidx.compose.foundation.background
import androidx.compose.foundation.layout.*
import androidx.compose.material3.Text
import androidx.compose.foundation.layout.fillMaxSize
import androidx.compose.runtime.*
import androidx.compose.ui.Alignment
import androidx.compose.ui.Modifier
import androidx.compose.ui.geometry.Offset
import androidx.compose.ui.geometry.Rect
import androidx.compose.ui.geometry.Size
import androidx.compose.ui.graphics.BlendMode
import androidx.compose.ui.graphics.Brush
import androidx.compose.ui.graphics.Color
import androidx.compose.ui.graphics.Path
import androidx.compose.ui.graphics.PathFillType
import androidx.compose.ui.graphics.drawscope.clipPath
import androidx.compose.ui.graphics.drawscope.clipRect
import androidx.compose.ui.graphics.drawscope.withTransform
import androidx.compose.ui.graphics.graphicsLayer
import androidx.compose.ui.graphics.vector.PathParser
import androidx.compose.ui.platform.LocalDensity
import androidx.compose.ui.semantics.clearAndSetSemantics
import androidx.compose.ui.semantics.contentDescription
import androidx.compose.ui.text.TextStyle
import androidx.compose.ui.text.drawText
import androidx.compose.ui.text.font.FontWeight
import androidx.compose.ui.unit.dp
import androidx.compose.ui.text.rememberTextMeasurer
import androidx.compose.ui.unit.sp
import kotlinx.coroutines.flow.first
import kotlinx.coroutines.withTimeoutOrNull
import kotlin.math.PI
import kotlin.math.cos
import kotlin.math.exp
import kotlin.math.ln
import kotlin.math.sin
private data class ApertureFacet(val path:Path,val color:Color,val center:Offset)
private class ApertureFacet(val points:List<Offset>,val color:Color,val normal:Offset)
// Exact geometry and colors from brand_mark.xml. The six pieces move independently
// into the existing aperture; the completed mark is never rotated or redesigned.
// Exact geometry and colors from brand_mark.xml, centered on its 64-unit viewport.
// Each facet carries the outward normal of its hexagon edge for the iris motion.
private val apertureFacets=listOf(
Triple("M33,4 L55.5,17 L42.5,24.5 L33,19 Z",0xFFC3E8D3,Offset(43f,14f)),
Triple("M56.5,19 L56.5,45 L43.5,37.5 L43.5,26.5 Z",0xFF71B9B0,Offset(50f,32f)),
Triple("M55.5,47 L33,60 L33,45 L42.5,39.5 Z",0xFF3D7C7B,Offset(43f,50f)),
Triple("M31,60 L8.5,47 L21.5,39.5 L31,45 Z",0xFFD0A977,Offset(21f,50f)),
Triple("M7.5,45 L7.5,19 L20.5,26.5 L20.5,37.5 Z",0xFFE9D8AE,Offset(14f,32f)),
Triple("M8.5,17 L31,4 L31,19 L21.5,24.5 Z",0xFFEEF2DD,Offset(21f,14f))
).map{(path,color,center)->ApertureFacet(PathParser().parsePathString(path).toPath(),Color(color),center)}
floatArrayOf(33f,4f,55.5f,17f,42.5f,24.5f,33f,19f) to 0xFFC3E8D3,
floatArrayOf(56.5f,19f,56.5f,45f,43.5f,37.5f,43.5f,26.5f) to 0xFF71B9B0,
floatArrayOf(55.5f,47f,33f,60f,33f,45f,42.5f,39.5f) to 0xFF3D7C7B,
floatArrayOf(31f,60f,8.5f,47f,21.5f,39.5f,31f,45f) to 0xFFD0A977,
floatArrayOf(7.5f,45f,7.5f,19f,20.5f,26.5f,20.5f,37.5f) to 0xFFE9D8AE,
floatArrayOf(8.5f,17f,31f,4f,31f,19f,21.5f,24.5f) to 0xFFEEF2DD
).mapIndexed { index,(points,color) ->
val angle=(-60.0+60*index)*PI/180
ApertureFacet(points.toList().chunked(2){Offset(it[0]-32f,it[1]-32f)},Color(color),Offset(cos(angle).toFloat(),sin(angle).toFloat()))
}
// Inner hexagon traced by the facets' inner edges: the aperture the exit flies through.
private const val InnerRadius=13.6f
private const val InnerApothem=11.8f
private const val IntroBox=132f
// The settled lockup is the header Brand() scaled up, so it reads as the same mark.
private const val LockScale=2.75f
private const val LockBox=29f*LockScale
private const val LockGap=7f*LockScale
// Opening timeline in ms, paused at GatherEnd until startup is ready. Completion is reported at IntroEnd; the timeline keeps
// running to TimelineEnd only for the slow settle while the exit plays or startup loads.
private const val GatherEnd=260f
private const val IntroEnd=2260f
private const val TimelineEnd=2900f
const val StartupExitMillis=640
private val Emphasized=CubicBezierEasing(.2f,0f,0f,1f)
private val EmphasizedDecelerate=CubicBezierEasing(.05f,.7f,.1f,1f)
private val Standard=CubicBezierEasing(.4f,0f,.2f,1f)
private val InOut=CubicBezierEasing(.45f,0f,.55f,1f)
// A mechanical iris: the blades gather, snap open, and overshoot slightly as they lock.
private val IrisOpen=CubicBezierEasing(.55f,0f,.15f,1f)
private val IrisTwist=CubicBezierEasing(.5f,0f,.18f,1.1f)
// Applied in log space: a brief pull back, then an accelerating flight.
private val Flight=CubicBezierEasing(.55f,-.06f,.8f,.36f)
private val SeaGlass=Color(0xFF71B9B0)
private fun phase(time:Float,start:Float,end:Float)=((time-start)/(end-start)).coerceIn(0f,1f)
private fun mix(from:Float,to:Float,amount:Float)=from+(to-from)*amount
/** One finite brand sequence, followed by a settled mark while startup data loads. */
@Composable fun StartupSplash(alpha:Float,onComplete:()->Unit) {
private class Iris(val inward:Float,val theta:Float,val grow:Float)
private fun irisAt(time:Float):Iris {
val progress=phase(time,140f,1180f)
return Iris(InnerApothem*(1f-IrisOpen.transform(progress)),(-44f*(1f-IrisTwist.transform(progress))*PI/180).toFloat(),
mix(.64f,1f,Emphasized.transform(progress)))
}
private fun Path.facet(facet:ApertureFacet,iris:Iris,unit:Float,center:Offset) {
val c=cos(iris.theta);val s=sin(iris.theta);val k=unit*iris.grow
facet.points.forEachIndexed { index,point ->
val x=point.x-facet.normal.x*iris.inward;val y=point.y-facet.normal.y*iris.inward
val px=center.x+(x*c-y*s)*k;val py=center.y+(x*s+y*c)*k
if(index==0)moveTo(px,py)else lineTo(px,py)
}
close()
}
private fun Path.hexagon(center:Offset,radius:Float) {
for(index in 0 until 6) {
val angle=(-90.0+60*index)*PI/180
val x=center.x+cos(angle).toFloat()*radius;val y=center.y+sin(angle).toFloat()*radius
if(index==0)moveTo(x,y)else lineTo(x,y)
}
close()
}
/** Scale for the screen behind the splash, so it settles into place as the aperture opens. */
fun startupArrivalScale(exit:Float)=mix(1.14f,1f,EmphasizedDecelerate.transform(phase(exit,.25f,1f)))
/**
* The cold-start brand sequence: a closed iris lit from behind twists open once [ready], light catches
* the facets, and the wordmark slides out of the mark. [exit] (0–1, linear) then flies
* the camera through the aperture's dark center, revealing the app drawn beneath.
*/
@Composable fun StartupSplash(exit:()->Float,ready:()->Boolean,onComplete:()->Unit) {
val timeline=remember{Animatable(0f)}
val complete by rememberUpdatedState(onComplete)
LaunchedEffect(Unit){
// Animatable honors Android's animation duration scale, including animations off.
timeline.animateTo(1f,tween(2600,easing=LinearEasing))
// Light gathers on the closed iris straight away. It is nearly still, so the first
// cold-start frames can hitch there without being noticed.
timeline.animateTo(GatherEnd,tween(GatherEnd.toInt(),easing=LinearEasing))
// Startup data arriving composes the app beneath the splash in one long frame. Hold
// until that has happened and frames arrive steadily again (at most 700 ms), so
// the iris never opens through it.
withTimeoutOrNull(700){
snapshotFlow{ready()}.first{it}
var previous=withFrameNanos{it};var steady=0
while(steady<4){val now=withFrameNanos{it};steady=if(now-previous<24_000_000L)steady+1 else 0;previous=now}
}
timeline.animateTo(TimelineEnd,tween((TimelineEnd-GatherEnd).toInt(),easing=LinearEasing))
}
LaunchedEffect(Unit){
snapshotFlow{timeline.value>=IntroEnd}.first{it}
complete()
}
Box(Modifier.fillMaxSize().graphicsLayer{this.alpha=alpha}.background(Ink)
.clearAndSetSemantics{contentDescription="Kaleido starting"},contentAlignment=Alignment.Center) {
Canvas(Modifier.fillMaxSize()) {
val time=timeline.value
val origin=Offset(size.width/2,size.height/2-32.dp.toPx())
val unit=112.dp.toPx()/64f
val glow=sin(phase(time,0f,.88f)*Math.PI).toFloat().coerceAtLeast(0f)
drawCircle(Brush.radialGradient(listOf(Color(0xFF71B9B0).copy(alpha=.16f*glow),Color.Transparent),
center=origin,radius=230.dp.toPx()),radius=230.dp.toPx(),center=origin)
apertureFacets.forEachIndexed { index,facet ->
val start=.06f+index*.045f
val raw=phase(time,start,start+.34f)
val arrival=FastOutSlowInEasing.transform(raw)
val direction=(facet.center-Offset(32f,32f))/18f
val distance=190f*(1f-arrival)
// A tapered light trail leads each sea-glass/ivory facet inward.
if(raw>0f&&raw<1f) {
val head=origin+direction*((distance+23f)*unit)
val tail=head+direction*((20f+80f*(1f-arrival))*unit)
drawLine(Brush.linearGradient(listOf(facet.color.copy(alpha=.5f*sin(raw*Math.PI).toFloat()),Color.Transparent),head,tail),
head,tail,strokeWidth=1.3.dp.toPx())
}
withTransform({
translate(origin.x-32f*unit,origin.y-32f*unit)
scale(unit,unit,pivot=Offset.Zero)
translate(direction.x*distance,direction.y*distance)
scale(.72f+.28f*arrival,.72f+.28f*arrival,pivot=facet.center)
}) {
drawPath(facet.path,facet.color,alpha=phase(raw,0f,.42f))
val glint=sin(phase(time,.64f+index*.018f,.78f+index*.018f)*Math.PI).toFloat().coerceAtLeast(0f)
if(raw==1f)drawPath(facet.path,Color.White,alpha=.22f*glint)
val measurer=rememberTextMeasurer()
val density=LocalDensity.current
val style=TextStyle(color=Accent,fontSize=(19f*LockScale).sp,fontWeight=FontWeight.Bold)
val letters=remember(measurer,density){"KALEIDO".map{measurer.measure(it.toString(),style)}}
val letterX=remember(letters,density){
val tracking=with(density){(1.4f*LockScale).sp.toPx()}
letters.runningFold(0f){x,letter->x+letter.size.width+tracking}
}
val textWidth=letterX.last()-with(density){(1.4f*LockScale).sp.toPx()}
val capHeight=with(density){style.fontSize.toPx()}*.711f
val paths=remember{List(4){Path()}}
Canvas(Modifier.fillMaxSize().clearAndSetSemantics{contentDescription="Kaleido starting"}) {
val time=timeline.value
val q=exit()
val dp=density.density
val lockup=Emphasized.transform(phase(time,1250f,2000f))
val lockWidth=(LockBox+LockGap)*dp+textWidth
var box=mix(IntroBox,LockBox,lockup)*dp
// A slow push-in keeps the settled frame alive.
val drift=1f+.025f*InOut.transform(phase(time,1900f,2900f))
var cx=mix(center.x,center.x-lockWidth/2+LockBox*dp/2,lockup)
var cy=center.y
var zoom=1f;var textAlpha=1f;var textShift=0f;var hole=0f
if(q>0f) {
zoom=exp(ln(52f)*Flight.transform(q))
val recenter=Standard.transform((q/.75f).coerceAtMost(1f))
cx=mix(cx,center.x,recenter);cy=mix(cy,center.y,recenter)
textAlpha=1f-Standard.transform(phase(q,0f,.4f))
textShift=-14f*dp*Standard.transform(phase(q,0f,.4f))
hole=InOut.transform(phase(q,.12f,.5f))
}
val unit=box/64f*drift*zoom
val origin=Offset(cx,cy)
val (surface,aperture,facets,ray)=paths
// Splash surface: Ink everywhere, with the aperture's center cut away on exit.
if(hole<=0f)drawRect(Ink)
else {
surface.rewind();surface.fillType=PathFillType.EvenOdd
surface.addRect(Rect(Offset.Zero,size));surface.hexagon(origin,InnerRadius*unit)
drawPath(surface,Ink)
if(hole<1f){aperture.rewind();aperture.hexagon(origin,InnerRadius*unit);drawPath(aperture,Ink,alpha=1f-hole)}
}
val iris=irisAt(time)
val lightUp=EmphasizedDecelerate.transform(phase(time,0f,620f))
val light=lightUp*(1f-Standard.transform(phase(time,620f,1250f)))
val ambient=.03f*InOut.transform(phase(time,300f,900f))*(1f-Standard.transform(phase(time,1500f,2300f)))
// Light behind the blades: a soft bloom, a hot core, and rays leaking through
// the six gaps while the iris turns.
if(light>.001f||ambient>.001f) {
val bloom=250f*dp
drawCircle(Brush.radialGradient(0f to SeaGlass.copy(alpha=.16f*light+ambient),.45f to SeaGlass.copy(alpha=.04f*light+ambient*.3f),
1f to Color.Transparent,center=origin,radius=bloom),bloom,origin,blendMode=BlendMode.Plus)
val core=26f*unit/2.0625f*mix(.6f,1f,light)
if(light>.001f) {
drawCircle(Brush.radialGradient(0f to Color(1f,.98f,.925f,.95f*light),.35f to Color(0xFFEEF2DD).copy(alpha=.55f*light),
1f to Color.Transparent,center=origin,radius=core),core,origin,blendMode=BlendMode.Plus)
val rays=light*(IrisOpen.transform(phase(time,140f,1180f))*2.5f).coerceAtMost(1f)
for(index in 0 until 6) {
val angle=((-90.0+60*index)*PI/180).toFloat()+iris.theta
val length=mix(40f,250f,lightUp)*(.75f+.25f*sin(index*2.1f+1f))*dp
ray.rewind();ray.moveTo(origin.x,origin.y)
ray.lineTo(origin.x+cos(angle-.014f)*length,origin.y+sin(angle-.014f)*length)
ray.lineTo(origin.x+cos(angle+.014f)*length,origin.y+sin(angle+.014f)*length);ray.close()
drawPath(ray,Brush.linearGradient(0f to Color(1f,.973f,.902f,.42f*rays),.25f to Color(0xFFD6ECE2).copy(alpha=.12f*rays),
1f to Color.Transparent,start=origin,end=Offset(origin.x+cos(angle)*length,origin.y+sin(angle)*length)),blendMode=BlendMode.Plus)
}
}
}
Row(Modifier.offset(y=65.dp),horizontalArrangement=Arrangement.spacedBy(7.dp),verticalAlignment=Alignment.CenterVertically) {
"KALEIDO".forEachIndexed { index,letter ->
Text(letter.toString(),color=Color(0xFFEEF2DD),fontSize=28.sp,fontWeight=FontWeight.Medium,
modifier=Modifier.graphicsLayer {
val reveal=FastOutSlowInEasing.transform(phase(timeline.value,.48f+index*.025f,.66f+index*.025f))
this.alpha=reveal
translationY=14.dp.toPx()*(1f-reveal)
})
// Facets. Short echoes of earlier frames act as motion blur while the blades
// turn; they disappear beneath the facets once the iris is still.
fun facetAlpha(index:Int)=EmphasizedDecelerate.transform(phase(time,40f+index*34,380f+index*34))
if(time<1400f) for((delay,alpha) in listOf(84f to .07f,56f to .12f,28f to .2f)) {
val echo=irisAt(time-delay)
apertureFacets.forEachIndexed { index,facet ->
facets.rewind();facets.facet(facet,echo,unit,origin);drawPath(facets,facet.color,alpha=alpha*facetAlpha(index))
}
}
apertureFacets.forEachIndexed { index,facet ->
facets.rewind();facets.facet(facet,iris,unit,origin);drawPath(facets,facet.color,alpha=facetAlpha(index))
}
val sheen=phase(time,980f,1560f)
if(light>.01f||(sheen>0f&&sheen<1f)) {
facets.rewind();apertureFacets.forEach{facets.facet(it,iris,unit,origin)}
clipPath(facets) {
// Backlight tints the blades while the core is hot, so they read as glass.
if(light>.01f) {
val radius=36f*unit/2.0625f
drawCircle(Brush.radialGradient(0f to Color(1f,.988f,.94f,.26f*light),1f to Color.Transparent,center=origin,radius=radius),radius,origin)
}
// One diagonal band of light crosses the settled mark.
if(sheen>0f&&sheen<1f) {
val reach=34f*unit;val angle=36f*PI.toFloat()/180;val direction=Offset(cos(angle),sin(angle))
val position=mix(-1.25f,1.25f,InOut.transform(sheen))*reach;val width=10f*unit
val peak=.42f*sin((sheen*1.1f).coerceAtMost(1f)*PI.toFloat())
drawRect(Brush.linearGradient(0f to Color.Transparent,.5f to Color.White.copy(alpha=peak),1f to Color.Transparent,
start=origin+direction*(position-width),end=origin+direction*(position+width)),origin-Offset(reach,reach),Size(reach*2,reach*2))
}
}
}
// The wordmark slides out from behind the mark as it moves into the lockup.
if(time>=1400f&&textAlpha>0f) {
val scale=box/(LockBox*dp)*drift
val textLeft=cx-box*drift/2+(LockBox+LockGap)*dp*scale
val slide=EmphasizedDecelerate.transform(phase(time,1400f,2050f))
val baseline=cy+capHeight/2*scale
clipRect(left=cx+24.5f*unit+2f*dp*scale) {
letters.forEachIndexed { index,letter ->
val start=1460f+index*45
val reveal=Standard.transform(phase(time,start,start+320f))
if(reveal>0f) withTransform({
translate(textLeft+(letterX[index]-(1f-slide)*textWidth*.42f)*scale+textShift,baseline-letter.firstBaseline*scale)
scale(scale,scale,pivot=Offset.Zero)
}) {drawText(letter,alpha=reveal*textAlpha)}
}
}
}
}

Binary file not shown.

View file

@ -1 +1 @@
5cbfcb3048504ff7926850a46fc38a9a57118fe60fc2e1a356b508fe16a14da2 Kaleido.apk
881a1fb1d6a9fc6e1600ab8a7bcb5d53c79babf04b65c1c5b008e14d50ac57ee Kaleido.apk

View file

@ -1,7 +1,7 @@
{
"version": "0.1.2",
"versionCode": 3,
"url": "https://git.elijahkuntz.com/Elijah/Kaleido/raw/tag/v0.1.2/distribution/Kaleido.apk",
"checksumUrl": "https://git.elijahkuntz.com/Elijah/Kaleido/raw/tag/v0.1.2/distribution/Kaleido.apk.sha256",
"notes": "0.1.2\n\n- Add navigation tap sounds with a persistent On/Off setting under Settings > Interface. Sounds default to On and follow the TV's system sound-effects setting.\n- Reduce Home hero-to-Continue Watching stutter by preparing nearby rows and retaining them across return navigation.\n- Include the navigation-sound focus paths in the baseline profile for optimized release navigation.\n"
"version": "0.1.3",
"versionCode": 4,
"url": "https://git.elijahkuntz.com/Elijah/Kaleido/raw/tag/v0.1.3/distribution/Kaleido.apk",
"checksumUrl": "https://git.elijahkuntz.com/Elijah/Kaleido/raw/tag/v0.1.3/distribution/Kaleido.apk.sha256",
"notes": "0.1.3\n\n- Redesign the startup animation: the six-facet aperture opens like a camera iris with light leaking through its gaps, a sheen crosses the mark, and the wordmark slides out from behind it.\n- Fly through the aperture's center into Home instead of crossfading, with the app settling into place behind it.\n- Hold the closed iris briefly while startup data arrives, so cold-start loading no longer stutters the animation.\n"
}

View file

@ -12,7 +12,7 @@ The interface gives artwork priority. App chrome uses neutral near-black, charco
- Search uses three columns of landscape results. Episodes use their actual stills, preserving their native proportions instead of cropping them into posters.
- Features use original Plex clear-logo artwork within 264 × 80 dp, falling back to title text. Detail title: 34/37 sp. Library title: 29/34 sp. Discovery rail heading: 17/22 sp. Supporting information: 10/14 sp.
- Poster and thumbnail corners: 6 dp. Compact action corners: 5 dp. Cards have no idle border; a compact bottom-right check marks watched titles, or a number shows remaining episodes for a show/season when Plex provides counts. Unwatched movies have no badge. Resumed movies/episodes only show a check after the configured playback threshold (80 percent by default), even if Plex retains a historical watched flag. Completed titles with no resume position retain Plex's watched state. Progress uses a two-dp inset line.
- The abstract six-facet aperture mark is shared by the header, sign-in, app icon, TV banner, and a cold-start aperture assembly. It uses muted sea-glass and warm ivory facets around a dark center, with no letterform or sparkle.
- The abstract six-facet aperture mark is shared by the header, sign-in, app icon, TV banner, and the cold-start aperture sequence. It uses muted sea-glass and warm ivory facets around a dark center, with no letterform or sparkle.
- Audience ratings display Rotten Tomatoes as a percentage beside its official Popcornmeter artwork, and IMDb on its native ten-point scale beside the gold IMDb logo. Both appear when Plex exposes both; TVDB is retained as a fallback when neither is available. Critic scores and unsupported providers are omitted. Stable preview focus hydrates detail metadata, where Plex exposes the full provider list. The official red Hot mark appears at 60 percent or above and the green Stale mark below 60 percent; each fits a stable, font-scaled square without recoloring or distortion. Verified Hot is not inferred from a percentage. Asset provenance is in [brand-assets.md](brand-assets.md). The IMDb vector uses the official gold primary mark and supplied clear space from the [IMDb brand toolkit](https://brand.imdb.com/imdb).
## Focus and motion
@ -23,7 +23,7 @@ The interface gives artwork priority. App chrome uses neutral near-black, charco
- Navigation contrast comes from a gradient extending past the controls and fading to transparent. Home/Movies/TV activate on focus. Explicit row and column links prevent beyond-bounds focus searches when holding a remote direction.
- A D-pad move predicts the actual row/column destination before starting its scroll or focus change. The target backdrop is fetched and contrast-processed through the same Coil request/cache as the visible scene. Speculative artwork uses one low-priority worker so it cannot flood normal decode workers during a burst of input. Metadata starts in parallel; the visible preview and details page share that in-flight request. Rapid navigation replaces the queued metadata target and cancels superseded artwork prefetches. Full metadata uses a 64-item LRU with a 30-second lifetime, cleared on account/server changes and refreshed after watched updates. Neutral library/search grids prefetch metadata without fetching an unused full-screen backdrop.
- Home's vertical list prepares content within one viewport ahead and retains one viewport behind, using Compose's bounded lazy-layout cache window. This keeps the hero and nearby rows ready when moving between them, rather than repeatedly composing and measuring the exposed image cards during the animation. Movies/TV retain their existing list strategy. Card sizes, row targets and the large cinematic Home layout are unchanged.
- Section previews settle for 120 ms (Home artwork for 90 ms), overlapping the navigation animation, and retain previous artwork until replacement data is ready. Contrast gradients are baked into a cached bitmap on a worker thread, reducing GPU overdraw. Hero recommendation changes crossfade the artwork over 220 ms, including cache hits, and fade the title/summary out for 100 ms and back in over 180 ms. Rotation pauses on the information/next controls and preserves their focus. Vertical row changes animate to explicit row/column targets; page entrances fade and slide 28 dp over 280 ms. The cold-start sequence lasts 2.6 seconds: six light trails converge, the exact aperture facets assemble radially without spinning, a soft glow and facet glint settle, and the wordmark reveals letter by letter. Completion drives the cover dismissal, with up to 600 ms extra for loading followed by a 360 ms crossfade. Android animation duration scale is honored, including animations off. It does not replay when returning from background.
- Section previews settle for 120 ms (Home artwork for 90 ms), overlapping the navigation animation, and retain previous artwork until replacement data is ready. Contrast gradients are baked into a cached bitmap on a worker thread, reducing GPU overdraw. Hero recommendation changes crossfade the artwork over 220 ms, including cache hits, and fade the title/summary out for 100 ms and back in over 180 ms. Rotation pauses on the information/next controls and preserves their focus. Vertical row changes animate to explicit row/column targets; page entrances fade and slide 28 dp over 280 ms. The cold-start sequence lasts 2.9 seconds. The six exact facets begin as a closed, overlapping iris lit from behind; it holds there (at most 700 ms) until startup data has arrived and frames are steady, so cold-start hitches never interrupt the motion. The iris then twists 44° open and locks with a slight overshoot while light leaks through the six gaps, a single sheen crosses the settled mark, and the mark shrinks into a lockup scaled from the header brand as KALEIDO slides out from behind it. Once loading finishes (up to 600 ms extra) the camera flies through the aperture's dark center over 640 ms, revealing the app beneath as it settles from 114 percent scale. The completed mark itself is never redesigned. Android animation duration scale is honored, including animations off. It does not replay when returning from background.
- Returning from details restores the library's mode, scroll position, and previously focused title.
## Player

View file

@ -70,3 +70,11 @@ For a quiet device with system effects already enabled, run `python -c "import s
Private evidence includes `home-baseline-results.json`, `home-trace-baseline-atrace.txt`, `home-complete-results.json`, `home-complete-cold-results.json`, `navigation-audio-results.json`, `navigation-audio-off-atrace.txt`, `navigation-audio-on-atrace.txt`, and the On/Off setting screenshots. `Build.ps1 -Release -Test` passed with three unit tests and zero lint errors. These measurements were taken on the local optimized test build before versioning the changes as 0.1.2. The installed test build retains the existing session and was left on Home with navigation sounds On.
All six `verify_ui.py browse` checks passed with the sound setting and cache window, including focus restoration, separate Movies/TV layouts, A–Z grids and PIN cancellation preserving the session. The broader `repro_runtime.py browse` check initially failed at p95 42 ms (48 ms with tracing), with further card composition/measurement during rapid movement. Including the new sound modifier/controller in the app's baseline profile brought the final profiled release to median 15 ms / p95 36 ms, GPU p95 7 ms, and stable horizontal Y coordinates at 182 px. Some stress-test frames still miss 60 Hz. `browse --trace` now records this exact regression loop to `browse-regression-atrace.txt` for future diagnosis.
## Aperture startup animation - 2026-10-24
The cold-start splash was prototyped as a dp-accurate canvas page (ignored `evidence/private/splash/index.html`), approved, then ported to `StartupSplash.kt` with the same geometry, timings and cubic-bezier curves. The exit cuts the aperture's inner hexagon out of the splash surface with an even-odd path and zooms it about 52× in log space, so the real app beneath is revealed through the mark; the content layer scales from 1.14 to 1 only while the cover exists.
Frame statistics from three profiled release cold starts (`dumpsys gfxinfo framestats`, bucketed per 250 ms) first showed 100–125 ms frames about 0.3–0.7 s after launch: startup data arriving and Home composing beneath the splash, with high UI-thread time. Starting the animation a few frames late did not avoid them because they follow the data, not the first frame. Skipping the hidden app's draw until the exit made no measurable difference and was reverted. The final sequence instead runs a 260 ms light-gathering phase on the nearly still closed iris, then holds until `busy` clears and four consecutive frames arrive within 24 ms (capped at 700 ms). On the final build every frame from the iris opening through the start of the exit completed within 25 ms in all three runs, at 15 frames per 250 ms. Frames after the reveal include Home itself and show higher latency without dropping below 15 frames per bucket. These are device samples, not a guarantee.
The hold adds roughly 0.5 s before the iris opens when Plex data takes that long; loading previously overlapped the animation. `Build.ps1 -Release -Test` passed; `repro_runtime.py sections` passed and all six `verify_ui.py browse` checks passed on the final release. A screen recording of the actual cold start (`kaleido-aperture-startup.mp4`, contact sheet `aperture-sheet.png`) was inspected. The optimized release was left on Home.

View file

@ -1,2 +1,2 @@
versionName=0.1.2
versionCode=3
versionName=0.1.3
versionCode=4