Kaleido/app/src/main/java/tv/kaleido/app/PlayerControls.kt
Elijah a2c72704f5
All checks were successful
Validate and publish Kaleido / android (push) Successful in 3m9s
Release Kaleido 0.4.0 with artwork categories, TV framing and compact skip cues
2026-10-28 10:16:23 -07:00

318 lines
24 KiB
Kotlin
Raw Blame History

This file contains ambiguous Unicode characters

This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.

package tv.kaleido.app
import androidx.activity.compose.BackHandler
import androidx.activity.compose.LocalActivity
import androidx.compose.animation.AnimatedVisibility
import androidx.compose.animation.fadeIn
import androidx.compose.animation.fadeOut
import androidx.compose.animation.scaleIn
import androidx.compose.animation.scaleOut
import androidx.compose.animation.slideInVertically
import androidx.compose.animation.slideOutVertically
import androidx.compose.animation.core.tween
import androidx.compose.foundation.*
import androidx.compose.foundation.layout.*
import androidx.compose.foundation.lazy.LazyColumn
import androidx.compose.foundation.lazy.rememberLazyListState
import androidx.compose.ui.platform.LocalContext
import androidx.media3.ui.CaptionStyleCompat
import androidx.media3.ui.SubtitleView
import androidx.compose.foundation.shape.RoundedCornerShape
import androidx.compose.material.icons.Icons
import androidx.compose.material.icons.filled.*
import androidx.compose.material.icons.outlined.*
import androidx.compose.material.icons.automirrored.outlined.ArrowBack
import androidx.compose.material.icons.automirrored.outlined.VolumeUp
import androidx.compose.material3.*
import androidx.compose.runtime.*
import androidx.compose.ui.Alignment
import androidx.compose.ui.Modifier
import androidx.compose.ui.draw.clip
import androidx.compose.ui.focus.*
import androidx.compose.ui.geometry.Offset
import androidx.compose.ui.graphics.Brush
import androidx.compose.ui.graphics.Color
import androidx.compose.ui.graphics.graphicsLayer
import androidx.compose.ui.graphics.StrokeCap
import androidx.compose.ui.input.key.*
import androidx.compose.ui.platform.LocalDensity
import androidx.compose.ui.semantics.*
import androidx.compose.ui.text.font.FontWeight
import androidx.compose.ui.text.style.TextOverflow
import androidx.compose.ui.unit.IntOffset
import androidx.compose.ui.unit.dp
import androidx.compose.ui.unit.sp
import androidx.compose.ui.viewinterop.AndroidView
import androidx.compose.ui.window.Popup
import androidx.compose.ui.window.PopupProperties
import androidx.lifecycle.Lifecycle
import androidx.lifecycle.LifecycleEventObserver
import androidx.lifecycle.compose.LocalLifecycleOwner
import androidx.media3.common.C
import androidx.media3.ui.PlayerView
import android.view.ViewGroup
import android.view.WindowManager
import kotlinx.coroutines.delay
@androidx.annotation.OptIn(androidx.media3.common.util.UnstableApi::class)
@Composable fun PlaybackScreen(vm:KaleidoViewModel,item:Title) {
val controller=remember{PlaybackController(vm,item)}
val activity=LocalActivity.current as MainActivity
val owner=LocalLifecycleOwner.current
var controls by remember{mutableStateOf(true)}
var interaction by remember{mutableLongStateOf(0)}
var trackMenu by remember{mutableIntStateOf(0)}
var postPlay by remember{mutableStateOf(false)}
var seekFocus by remember{mutableStateOf(false)}
// Set once the timeline takes focus for this reveal, so Play's initial focus can't take it back.
var timelineReveal by remember{mutableStateOf(false)}
var restoreMenuFocus by remember{mutableIntStateOf(0)}
var skipSeconds by remember(item.id){mutableIntStateOf(0)}
var skipPulse by remember(item.id){mutableIntStateOf(0)}
var skipForward by remember(item.id){mutableStateOf(true)}
LaunchedEffect(skipPulse){if(skipPulse>0){delay(1000);skipSeconds=0}}
fun quickSkip(delta:Long){
val before=controller.scrubPosition ?: controller.position
controller.scrubBy(delta,settle=350)
val actual=((controller.scrubPosition ?: before)-before).toInt()/1000
skipSeconds=if(skipSeconds*actual>0)skipSeconds+actual else actual
skipForward=delta>0
skipPulse++
}
val rootFocus=remember{FocusRequester()}
val timelineFocus=remember{FocusRequester()}
val playFocus=remember{FocusRequester()}
val audioFocus=remember{FocusRequester()}
val subtitleFocus=remember{FocusRequester()}
val optionsFocus=remember{FocusRequester()}
fun interacted(){interaction=System.currentTimeMillis()}
fun closeTracks(){restoreMenuFocus=trackMenu;trackMenu=0;interacted()}
LaunchedEffect(item.id){vm.loadEpisodeContext(item)}
LaunchedEffect(controller.ended){
if(!controller.ended)return@LaunchedEffect
if(item.type=="episode"){android.util.Log.i("KaleidoPlayback","POSTPLAY item=${item.id} reason=ended");postPlay=true}
// A finished movie or extra returns to its details instead of resting on the last frame.
else vm.stopPlayback()
}
// Derived: the player only recomposes when a marker starts or ends, not on every position tick.
val marker by remember{derivedStateOf{item.markers.firstOrNull{controller.position>=it.start&&controller.position<it.end&&it.type in listOf("intro","credits")}}}
fun skip(marker:Marker){
if(marker.type=="credits"&&item.type=="episode"){controller.pause();android.util.Log.i("KaleidoPlayback","POSTPLAY item=${item.id} reason=skip-credits");postPlay=true}
else controller.seekTo(marker.end)
}
// Each marker is skipped automatically once, so seeking back into it plays it.
val autoSkipped=remember{mutableSetOf<Marker>()}
LaunchedEffect(marker,controller.loading) {
val m=marker ?: return@LaunchedEffect
if(controller.loading||postPlay||m in autoSkipped)return@LaunchedEffect
if(m.type=="intro"&&vm.autoSkipIntro||m.type=="credits"&&vm.autoSkipCredits){autoSkipped+=m;android.util.Log.i("KaleidoPlayback","AUTOSKIP ${m.type} item=${item.id}");skip(m)}
}
DisposableEffect(controller) {
activity.window.addFlags(WindowManager.LayoutParams.FLAG_KEEP_SCREEN_ON)
val observer=LifecycleEventObserver{_,event->if(event==Lifecycle.Event.ON_STOP)controller.pause()}
owner.lifecycle.addObserver(observer)
onDispose{owner.lifecycle.removeObserver(observer);activity.window.clearFlags(WindowManager.LayoutParams.FLAG_KEEP_SCREEN_ON);controller.close()}
}
LaunchedEffect(controls,interaction,controller.isPlaying,trackMenu) {
if(controls&&controller.isPlaying&&trackMenu==0){delay(5000);controls=false}
}
LaunchedEffect(controls) {if(!controls){timelineReveal=false;delay(210);runCatching{rootFocus.requestFocus()}}}
LaunchedEffect(seekFocus,controls) {if(seekFocus&&controls){delay(220);runCatching{timelineFocus.requestFocus()};timelineReveal=true;seekFocus=false}}
LaunchedEffect(restoreMenuFocus,trackMenu) {if(restoreMenuFocus!=0&&trackMenu==0){delay(16);runCatching{(when(restoreMenuFocus){1->audioFocus;2->subtitleFocus;else->optionsFocus}).requestFocus()};restoreMenuFocus=0}}
fun goBack(){if(postPlay)postPlay=false else if(trackMenu!=0)closeTracks()else if(controls)controls=false else vm.stopPlayback()}
BackHandler(onBack=::goBack)
val visible=controls&&!postPlay
Box(Modifier.fillMaxSize().background(Color.Black).focusRequester(rootFocus).onPreviewKeyEvent{event->
if(event.key==Key.Back){if(event.type==KeyEventType.KeyDown)goBack();true}
else if(event.type!=KeyEventType.KeyDown||postPlay)false else {
interacted()
when(event.nativeKeyEvent.keyCode) {
android.view.KeyEvent.KEYCODE_MEDIA_PLAY_PAUSE->{controller.toggle();controls=true;true}
android.view.KeyEvent.KEYCODE_MEDIA_PLAY->{controller.player.play();controls=true;true}
android.view.KeyEvent.KEYCODE_MEDIA_PAUSE->{controller.pause();controls=true;true}
android.view.KeyEvent.KEYCODE_MEDIA_FAST_FORWARD->{controller.seekTo(controller.position+30000);controls=true;seekFocus=true;true}
android.view.KeyEvent.KEYCODE_MEDIA_REWIND->{controller.seekTo(controller.position-10000);controls=true;seekFocus=true;true}
// With the controls hidden, OK takes a visible Skip intro/credits; otherwise it reveals them.
android.view.KeyEvent.KEYCODE_DPAD_CENTER,android.view.KeyEvent.KEYCODE_ENTER->{if(!visible){marker?.let(::skip) ?: run{controls=true};true}else false}
android.view.KeyEvent.KEYCODE_DPAD_LEFT,android.view.KeyEvent.KEYCODE_DPAD_RIGHT->{
val delta=if(event.nativeKeyEvent.keyCode==android.view.KeyEvent.KEYCODE_DPAD_LEFT)-10000L else 10000L
when {
// Quick taps accumulate a seek and show a brief directional cue.
!visible&&event.nativeKeyEvent.repeatCount==0->{quickSkip(delta);true}
// Holding reveals the timeline and keeps scrubbing until it takes focus.
!visible||seekFocus->{controller.scrubBy(delta);controls=true;seekFocus=true;true}
else->false
}
}
android.view.KeyEvent.KEYCODE_DPAD_UP,android.view.KeyEvent.KEYCODE_DPAD_DOWN->{if(!visible){controls=true;seekFocus=event.nativeKeyEvent.keyCode==android.view.KeyEvent.KEYCODE_DPAD_UP;true}else false}
else->false
}
}
}.focusable()) {
AndroidView(factory={context->PlayerView(context).apply {
setEnableComposeSurfaceSyncWorkaround(true)
player=controller.player
useController=false
isFocusable=false
descendantFocusability=ViewGroup.FOCUS_BLOCK_DESCENDANTS
setShowBuffering(PlayerView.SHOW_BUFFERING_NEVER)
setKeepContentOnPlayerReset(true)
}},update={view->view.subtitleView?.let{applySubtitleStyle(it,vm.subtitleSize,vm.subtitleStyle)}},modifier=Modifier.fillMaxSize(),onRelease={it.player=null})
if(controller.loading)CircularProgressIndicator(color=Accent,strokeWidth=2.dp,modifier=Modifier.align(Alignment.Center).size(30.dp))
QuickSkipFeedback(skipSeconds,skipPulse,!visible&&!postPlay,Modifier.align(if(skipForward)Alignment.CenterEnd else Alignment.CenterStart).padding(horizontal=32.dp))
AnimatedVisibility(visible=visible,enter=fadeIn(tween(190))+slideInVertically(tween(190)){it/8},exit=fadeOut(tween(190))+slideOutVertically(tween(190)){it/10},modifier=Modifier.align(Alignment.BottomCenter)) {
Column(Modifier.fillMaxWidth().background(Brush.verticalGradient(0f to Color.Transparent,.42f to Color.Black.copy(alpha=.46f),1f to Color.Black.copy(alpha=.79f))).padding(start=Cinema.gutter,end=Cinema.gutter,top=31.dp,bottom=16.dp)) {
Row(Modifier.fillMaxWidth().padding(bottom=7.dp),verticalAlignment=Alignment.Bottom) {
Text(item.displayTitle,color=Accent,fontSize=18.sp,lineHeight=23.sp,fontWeight=FontWeight.SemiBold,maxLines=1,overflow=TextOverflow.Ellipsis,modifier=Modifier.weight(1f))
Spacer(Modifier.width(18.dp))
Text(if(item.type=="episode")"S${item.parentIndex} · E${item.index} ${item.title}"else controller.qualityLabel,color=Color.White.copy(alpha=.72f),fontSize=12.sp,lineHeight=16.sp,maxLines=1,overflow=TextOverflow.Ellipsis,modifier=Modifier.widthIn(max=420.dp))
}
SeekTimeline(controller,item,Modifier.fillMaxWidth().focusRequester(timelineFocus).focusProperties{down=playFocus},::interacted)
Box(Modifier.fillMaxWidth().height(40.dp)) {
Row(Modifier.align(Alignment.CenterStart),verticalAlignment=Alignment.CenterVertically,horizontalArrangement=Arrangement.spacedBy(7.dp)) {
IconControl(Icons.AutoMirrored.Outlined.ArrowBack,"Exit playback",size=30.dp,iconSize=18.dp,onFocused=::interacted){vm.stopPlayback()}
Text(clockTime(controller.position),color=Color.White.copy(alpha=.78f),fontSize=10.sp,lineHeight=14.sp)
}
Row(Modifier.align(Alignment.Center),verticalAlignment=Alignment.CenterVertically,horizontalArrangement=Arrangement.spacedBy(16.dp)) {
IconControl(Icons.Outlined.Replay10,"Back 10 seconds",size=32.dp,iconSize=22.dp,modifier=Modifier.focusProperties{up=timelineFocus},onFocused=::interacted){controller.seekTo(controller.position-10000);interacted()}
IconControl(if(controller.isPlaying)Icons.Filled.Pause else Icons.Filled.PlayArrow,if(controller.isPlaying)"Pause"else "Play",size=38.dp,iconSize=28.dp,requester=playFocus,initialFocus=controls&&!seekFocus&&!timelineReveal,modifier=Modifier.focusProperties{up=timelineFocus},onFocused=::interacted){controller.toggle();controls=true;interacted()}
IconControl(Icons.Outlined.Forward30,"Forward 30 seconds",size=32.dp,iconSize=22.dp,modifier=Modifier.focusProperties{up=timelineFocus},onFocused=::interacted){controller.seekTo(controller.position+30000);interacted()}
}
Row(Modifier.align(Alignment.CenterEnd),verticalAlignment=Alignment.CenterVertically,horizontalArrangement=Arrangement.spacedBy(10.dp)) {
Text("−"+clockTime(controller.duration-controller.position)+" · Ends "+endsAt(controller),color=Color.White.copy(alpha=.58f),fontSize=10.sp,lineHeight=14.sp,modifier=Modifier.padding(end=8.dp))
if(item.type=="episode")IconControl(Icons.Outlined.SkipNext,"Next episode",size=30.dp,iconSize=21.dp,onFocused=::interacted){vm.nextEpisode(item)}
IconControl(Icons.AutoMirrored.Outlined.VolumeUp,"Audio tracks",size=30.dp,iconSize=21.dp,requester=audioFocus,selected=trackMenu==1,modifier=Modifier.focusProperties{up=timelineFocus},onFocused=::interacted){trackMenu=1;interacted()}
IconControl(Icons.Outlined.Subtitles,"Subtitles",size=30.dp,iconSize=21.dp,requester=subtitleFocus,selected=trackMenu==2,modifier=Modifier.focusProperties{up=timelineFocus},onFocused=::interacted){trackMenu=2;interacted()}
IconControl(Icons.Outlined.Settings,"Playback options",size=30.dp,iconSize=21.dp,requester=optionsFocus,selected=trackMenu>=3,modifier=Modifier.focusProperties{up=timelineFocus},onFocused=::interacted){trackMenu=3;interacted()}
}
}
}
}
marker?.let{marker->if(!postPlay)Box(Modifier.align(Alignment.BottomEnd).padding(end=Cinema.gutter,bottom=if(visible)130.dp else 45.dp)) {
ActionButton(if(marker.type=="intro")"Skip intro"else "Skip credits",Icons.Outlined.ChevronRight,modifier=Modifier.background(Color.Black.copy(alpha=.9f),RoundedCornerShape(5.dp)).border(1.dp,Color.White.copy(alpha=.75f),RoundedCornerShape(5.dp))){skip(marker);interacted()}
}}
if(postPlay)PostPlayScreen(vm,item,{postPlay=false;controls=true},{vm.nextEpisode(item)})
controller.error?.let{ErrorDialog(it,{vm.stopPlayback()},{controller.retry()})}
if(trackMenu in 1..2) {
val type=if(trackMenu==1)C.TRACK_TYPE_AUDIO else C.TRACK_TYPE_TEXT
val streams=controller.part.streams.filter{it.type==(if(trackMenu==1)2 else 3)}
val options=(if(trackMenu==2)listOf("Off")else emptyList())+streams.map{it.title}
val active=controller.currentStream(if(trackMenu==1)controller.activeAudio else controller.activeSubtitle)
val selected=streams.indexOfFirst{it.id==active?.id}+if(trackMenu==2)1 else 0
TrackPanel(if(trackMenu==1)"Audio"else "Subtitles",options,selected,::closeTracks){index->
val stream=if(trackMenu==2)streams.getOrNull(index-1)else streams.getOrNull(index)
if(options.isNotEmpty())controller.selectServerStream(stream,type)
closeTracks()
}
}
if(trackMenu>=3)PlaybackOptions(vm,controller,item,trackMenu,{trackMenu=it;interacted()},::closeTracks)
}
}
/** A short, non-focusable cue leaves the picture and remote focus undisturbed. */
@Composable private fun QuickSkipFeedback(seconds:Int,pulse:Int,allowed:Boolean,modifier:Modifier) {
// Keep the final label while the cue fades out.
var last by remember{mutableIntStateOf(10)}
if(seconds!=0)last=seconds
AnimatedVisibility(visible=seconds!=0&&allowed,enter=fadeIn(tween(100))+scaleIn(tween(150),initialScale=.88f),exit=fadeOut(tween(180))+scaleOut(tween(180),targetScale=.96f),modifier=modifier) {
Column(Modifier.size(width=56.dp,height=64.dp).background(Brush.radialGradient(listOf(Color.Black.copy(alpha=.4f),Color.Transparent)))
.semantics(mergeDescendants=true){contentDescription=if(last<0)"Back ${-last} seconds"else "Forward $last seconds"},horizontalAlignment=Alignment.CenterHorizontally) {
Spacer(Modifier.height(9.dp))
key(pulse){
val opacity=remember{androidx.compose.animation.core.Animatable(.6f)}
LaunchedEffect(Unit){opacity.animateTo(1f,tween(180))}
Icon(if(last<0)Icons.Filled.FastRewind else Icons.Filled.FastForward,null,tint=Color.White,modifier=Modifier.size(22.dp).graphicsLayer{alpha=opacity.value})
}
Text((if(last>0)"+"else "−")+kotlin.math.abs(last)+" s",color=Color.White,fontSize=12.sp,lineHeight=16.sp,fontWeight=FontWeight.Medium,style=LocalTextStyle.current.copy(shadow=androidx.compose.ui.graphics.Shadow(Color.Black,Offset(0f,1f),4f)),modifier=Modifier.padding(top=3.dp))
}
}
}
/** Wall-clock time the title finishes at the current speed, in the TV's 12/24-hour format. */
@Composable private fun endsAt(controller:PlaybackController):String {
val format=android.text.format.DateFormat.getTimeFormat(LocalContext.current)
val remaining=((controller.duration-controller.position).coerceAtLeast(0)/controller.playbackRate.coerceAtLeast(.25f)).toLong()
return format.format(java.util.Date(System.currentTimeMillis()+remaining))
}
@androidx.annotation.OptIn(androidx.media3.common.util.UnstableApi::class)
/** [screenHeight]: size text against a full-screen frame, for a preview smaller than the video. */
internal fun applySubtitleStyle(view:SubtitleView,size:SubtitleSize,style:SubtitleStyle,screenHeight:Int?=null) {
val black=android.graphics.Color.BLACK;val white=android.graphics.Color.WHITE;val clear=android.graphics.Color.TRANSPARENT
var scale=size.scale
val caption=when(style) {
SubtitleStyle.Box->CaptionStyleCompat.DEFAULT
SubtitleStyle.Shadow->CaptionStyleCompat(white,clear,clear,CaptionStyleCompat.EDGE_TYPE_DROP_SHADOW,black,null)
SubtitleStyle.Outline->CaptionStyleCompat(white,clear,clear,CaptionStyleCompat.EDGE_TYPE_OUTLINE,black,null)
SubtitleStyle.Yellow->CaptionStyleCompat(0xFFFFE14D.toInt(),clear,clear,CaptionStyleCompat.EDGE_TYPE_OUTLINE,black,null)
SubtitleStyle.System->{
val captioning=view.context.getSystemService(android.view.accessibility.CaptioningManager::class.java)
scale*=captioning?.fontScale ?: 1f
captioning?.let{CaptionStyleCompat.createFromCaptionStyle(it.userStyle)} ?: CaptionStyleCompat.DEFAULT
}
}
view.setStyle(caption)
// Embedded ASS/SSA colours and positions still apply; the chosen size always does.
view.setApplyEmbeddedFontSizes(false)
if(screenHeight!=null)view.setFixedTextSize(android.util.TypedValue.COMPLEX_UNIT_PX,screenHeight*SubtitleView.DEFAULT_TEXT_SIZE_FRACTION*scale)
else view.setFractionalTextSize(SubtitleView.DEFAULT_TEXT_SIZE_FRACTION*scale)
}
@Composable private fun SeekTimeline(controller:PlaybackController,item:Title,modifier:Modifier,onInteraction:()->Unit) {
var focused by remember{mutableStateOf(false)}
val displayed=controller.scrubPosition ?: controller.position
val progress=if(controller.duration>0)(displayed.toFloat()/controller.duration).coerceIn(0f,1f)else 0f
val buffered=if(controller.duration>0)(controller.bufferedPosition.toFloat()/controller.duration).coerceIn(0f,1f)else 0f
BoxWithConstraints(modifier.height(18.dp).navigationSound().onFocusChanged{focused=it.isFocused;if(it.isFocused)onInteraction()else controller.commitScrub()}.onPreviewKeyEvent{event->
if(event.type!=KeyEventType.KeyDown)false else when(event.key) {
Key.DirectionLeft,Key.DirectionRight->{val delta=if(event.nativeKeyEvent.repeatCount>5)30000L else 10000L;controller.scrubBy(if(event.key==Key.DirectionLeft)-delta else delta);onInteraction();true}
Key.DirectionCenter,Key.Enter->{if(controller.scrubPosition!=null)controller.commitScrub()else controller.toggle();onInteraction();true}
else->false
}
}.semantics{contentDescription="Playback timeline";stateDescription=clockTime(displayed)+"; buffered "+clockTime(controller.bufferedPosition);progressBarRangeInfo=ProgressBarRangeInfo(progress,0f..1f)}.focusable()) {
Canvas(Modifier.fillMaxSize()) {
val y=size.height/2
val thickness=if(focused)3.dp.toPx()else 2.dp.toPx()
drawLine(Color.White.copy(alpha=.24f),Offset(0f,y),Offset(size.width,y),thickness,StrokeCap.Round)
drawLine(Color.White.copy(alpha=.48f),Offset(0f,y),Offset(size.width*buffered,y),thickness,StrokeCap.Round)
drawLine(Accent,Offset(0f,y),Offset(size.width*progress,y),thickness,StrokeCap.Round)
drawCircle(Accent,if(focused)4.dp.toPx()else 2.dp.toPx(),Offset(size.width*progress,y))
}
if(focused) {
val path=controller.api.previewPath(item,displayed)
Column(Modifier.offset(x=(maxWidth-146.dp)*progress,y=(-109).dp).wrapContentSize(Alignment.TopStart,unbounded=true).width(146.dp).height(104.dp).clip(RoundedCornerShape(6.dp)).background(Color(0xF0202020)).border(1.dp,Color.White.copy(alpha=.4f),RoundedCornerShape(6.dp)).semantics{contentDescription="Scrub preview"}.padding(3.dp),horizontalAlignment=Alignment.CenterHorizontally) {
if(path!=null)Artwork(controller.api,path,Modifier.fillMaxWidth().aspectRatio(16f/9f),320,180,animate=false)
else Text("No preview available",color=Muted,fontSize=10.sp,modifier=Modifier.padding(12.dp))
Text(clockTime(displayed),color=Accent,fontSize=10.sp,lineHeight=14.sp)
}
}
}
}
/** [selected] shows a checkmark; [focusIndex] only places focus, e.g. in a menu without a selection. */
@Composable internal fun TrackPanel(title:String,options:List<String>,selected:Int,dismiss:()->Unit,focusIndex:Int=selected,choose:(Int)->Unit) {
val density=LocalDensity.current
val initial=(if(focusIndex>=0)focusIndex else 0).coerceIn(0,(options.size-1).coerceAtLeast(0))
// Start scrolled near the focused row: a lazy row that isn't composed can't take focus.
val list=rememberLazyListState(initialFirstVisibleItemIndex=(initial-2).coerceAtLeast(0))
val offset=with(density){IntOffset(-44.dp.roundToPx(),-108.dp.roundToPx())}
Popup(alignment=Alignment.BottomEnd,offset=offset,onDismissRequest=dismiss,properties=PopupProperties(focusable=true)) {
Column(Modifier.width(280.dp).heightIn(max=330.dp).clip(RoundedCornerShape(10.dp)).background(Color(0xF5222222)).padding(13.dp).onPreviewKeyEvent{if(it.key==Key.Back){if(it.type==KeyEventType.KeyDown)dismiss();true}else if(it.type==KeyEventType.KeyDown&&it.key==Key.DirectionLeft){dismiss();true}else false}) {
Text(title,color=Accent,fontSize=15.sp,lineHeight=20.sp,fontWeight=FontWeight.SemiBold,modifier=Modifier.padding(start=9.dp,top=5.dp,bottom=10.dp))
if(options.isEmpty())Text("No tracks available",color=Muted,fontSize=12.sp,modifier=Modifier.padding(10.dp))
LazyColumn(state=list,verticalArrangement=Arrangement.spacedBy(2.dp)) {
items(options.size){index->TrackOption(options[index],index==selected,index==initial){choose(index)}}
}
}
}
}
@Composable private fun TrackOption(label:String,selected:Boolean,initialFocus:Boolean,onClick:()->Unit) {
var focused by remember{mutableStateOf(false)}
val requester=remember{FocusRequester()}
LaunchedEffect(initialFocus){if(initialFocus){delay(80);runCatching{requester.requestFocus()}}}
Row(Modifier.fillMaxWidth().heightIn(min=35.dp).focusRequester(requester).navigationSound().onFocusChanged{focused=it.isFocused}.clip(RoundedCornerShape(5.dp)).background(if(focused)Color.White.copy(alpha=.14f)else Color.Transparent).clickable(onClick=onClick).padding(horizontal=9.dp,vertical=8.dp),verticalAlignment=Alignment.CenterVertically,horizontalArrangement=Arrangement.spacedBy(9.dp)) {
if(selected)Icon(Icons.Outlined.Check,null,tint=Accent,modifier=Modifier.size(15.dp))else Spacer(Modifier.width(15.dp))
Text(label,color=if(focused||selected)Accent else Muted,fontSize=12.sp,lineHeight=16.sp,maxLines=2,overflow=TextOverflow.Ellipsis)
}
}