All checks were successful
Validate and publish Kaleido / android (push) Successful in 3m9s
318 lines
24 KiB
Kotlin
318 lines
24 KiB
Kotlin
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)
|
||
}
|
||
}
|