From b69a48407b7f5283a88b4f1bfeaff5dbf10a2473 Mon Sep 17 00:00:00 2001 From: Damontecres Date: Mon, 22 Sep 2025 20:09:12 -0400 Subject: [PATCH] Add playback controls --- .../github/damontecres/dolphin/Extensions.kt | 61 ++ .../damontecres/dolphin/ui/UiConstants.kt | 16 + .../ui/playback/ControllerViewState.kt | 48 ++ .../dolphin/ui/playback/KeyIdentifier.kt | 44 ++ .../dolphin/ui/playback/PlaybackConstants.kt | 14 + .../dolphin/ui/playback/PlaybackContent.kt | 138 +++- .../dolphin/ui/playback/PlaybackControls.kt | 597 ++++++++++++++++++ .../dolphin/ui/playback/PlaybackKeyHandler.kt | 81 +++ .../dolphin/ui/playback/PlaybackOverlay.kt | 89 +++ .../dolphin/ui/playback/PlaybackViewModel.kt | 17 +- .../dolphin/ui/playback/SeekBar.kt | 144 +++++ .../dolphin/ui/playback/SeekBarState.kt | 59 ++ .../dolphin/ui/playback/SkipIndicator.kt | 67 ++ .../dolphin/ui/playback/TrackSupport.kt | 147 +++++ .../res/drawable/baseline_fast_forward_24.xml | 10 + .../res/drawable/baseline_fast_rewind_24.xml | 10 + .../res/drawable/baseline_more_vert_96.xml | 5 + .../main/res/drawable/baseline_pause_24.xml | 10 + .../res/drawable/baseline_play_arrow_24.xml | 10 + .../res/drawable/baseline_skip_next_24.xml | 10 + .../drawable/baseline_skip_previous_24.xml | 10 + .../main/res/drawable/baseline_stop_24.xml | 10 + .../main/res/drawable/baseline_undo_24.xml | 5 + .../res/drawable/captions_svgrepo_com.xml | 7 + .../res/drawable/circular_arrow_right.xml | 10 + app/src/main/res/drawable/vector_settings.xml | 5 + app/src/main/res/font/fa_solid_900.ttf | Bin 0 -> 419720 bytes 27 files changed, 1618 insertions(+), 6 deletions(-) create mode 100644 app/src/main/java/com/github/damontecres/dolphin/ui/UiConstants.kt create mode 100644 app/src/main/java/com/github/damontecres/dolphin/ui/playback/ControllerViewState.kt create mode 100644 app/src/main/java/com/github/damontecres/dolphin/ui/playback/KeyIdentifier.kt create mode 100644 app/src/main/java/com/github/damontecres/dolphin/ui/playback/PlaybackConstants.kt create mode 100644 app/src/main/java/com/github/damontecres/dolphin/ui/playback/PlaybackControls.kt create mode 100644 app/src/main/java/com/github/damontecres/dolphin/ui/playback/PlaybackKeyHandler.kt create mode 100644 app/src/main/java/com/github/damontecres/dolphin/ui/playback/PlaybackOverlay.kt create mode 100644 app/src/main/java/com/github/damontecres/dolphin/ui/playback/SeekBar.kt create mode 100644 app/src/main/java/com/github/damontecres/dolphin/ui/playback/SeekBarState.kt create mode 100644 app/src/main/java/com/github/damontecres/dolphin/ui/playback/SkipIndicator.kt create mode 100644 app/src/main/java/com/github/damontecres/dolphin/ui/playback/TrackSupport.kt create mode 100644 app/src/main/res/drawable/baseline_fast_forward_24.xml create mode 100644 app/src/main/res/drawable/baseline_fast_rewind_24.xml create mode 100644 app/src/main/res/drawable/baseline_more_vert_96.xml create mode 100644 app/src/main/res/drawable/baseline_pause_24.xml create mode 100644 app/src/main/res/drawable/baseline_play_arrow_24.xml create mode 100644 app/src/main/res/drawable/baseline_skip_next_24.xml create mode 100644 app/src/main/res/drawable/baseline_skip_previous_24.xml create mode 100644 app/src/main/res/drawable/baseline_stop_24.xml create mode 100644 app/src/main/res/drawable/baseline_undo_24.xml create mode 100644 app/src/main/res/drawable/captions_svgrepo_com.xml create mode 100644 app/src/main/res/drawable/circular_arrow_right.xml create mode 100644 app/src/main/res/drawable/vector_settings.xml create mode 100644 app/src/main/res/font/fa_solid_900.ttf diff --git a/app/src/main/java/com/github/damontecres/dolphin/Extensions.kt b/app/src/main/java/com/github/damontecres/dolphin/Extensions.kt index b64f8fa6..3e2ae086 100644 --- a/app/src/main/java/com/github/damontecres/dolphin/Extensions.kt +++ b/app/src/main/java/com/github/damontecres/dolphin/Extensions.kt @@ -1,6 +1,9 @@ package com.github.damontecres.dolphin +import android.view.KeyEvent +import androidx.compose.ui.Modifier import androidx.compose.ui.focus.FocusRequester +import androidx.compose.ui.input.key.onPreviewKeyEvent import timber.log.Timber import kotlin.contracts.ExperimentalContracts import kotlin.contracts.contract @@ -24,3 +27,61 @@ fun FocusRequester.tryRequestFocus(): Boolean = Timber.w(ex, "Failed to request focus") false } + +/** + * Used to apply modifiers conditionally. + */ +fun Modifier.ifElse( + condition: () -> Boolean, + ifTrueModifier: Modifier, + ifFalseModifier: Modifier = Modifier, +): Modifier = then(if (condition()) ifTrueModifier else ifFalseModifier) + +/** + * Used to apply modifiers conditionally. + */ +fun Modifier.ifElse( + condition: Boolean, + ifTrueModifier: Modifier, + ifFalseModifier: Modifier = Modifier, +): Modifier = ifElse({ condition }, ifTrueModifier, ifFalseModifier) + +/** + * Handles horizontal (Left & Right) D-Pad Keys and consumes the event(s) so that the focus doesn't + * accidentally move to another element. + * */ +fun Modifier.handleDPadKeyEvents( + onLeft: (() -> Unit)? = null, + onRight: (() -> Unit)? = null, + onCenter: (() -> Unit)? = null, + triggerOnAction: Int = KeyEvent.ACTION_UP, +) = onPreviewKeyEvent { + fun onActionUp(block: () -> Unit) { + if (it.nativeKeyEvent.action == triggerOnAction) block() + } + + when (it.nativeKeyEvent.keyCode) { + KeyEvent.KEYCODE_DPAD_LEFT, KeyEvent.KEYCODE_SYSTEM_NAVIGATION_LEFT -> { + onLeft?.apply { + onActionUp(::invoke) + return@onPreviewKeyEvent true + } + } + + KeyEvent.KEYCODE_DPAD_RIGHT, KeyEvent.KEYCODE_SYSTEM_NAVIGATION_RIGHT -> { + onRight?.apply { + onActionUp(::invoke) + return@onPreviewKeyEvent true + } + } + + KeyEvent.KEYCODE_DPAD_CENTER, KeyEvent.KEYCODE_ENTER, KeyEvent.KEYCODE_NUMPAD_ENTER -> { + onCenter?.apply { + onActionUp(::invoke) + return@onPreviewKeyEvent true + } + } + } + + false +} diff --git a/app/src/main/java/com/github/damontecres/dolphin/ui/UiConstants.kt b/app/src/main/java/com/github/damontecres/dolphin/ui/UiConstants.kt new file mode 100644 index 00000000..0c30c8a4 --- /dev/null +++ b/app/src/main/java/com/github/damontecres/dolphin/ui/UiConstants.kt @@ -0,0 +1,16 @@ +package com.github.damontecres.dolphin.ui + +import androidx.compose.ui.graphics.Color +import androidx.compose.ui.text.font.Font +import androidx.compose.ui.text.font.FontFamily +import com.github.damontecres.dolphin.R + +val FontAwesome = FontFamily(Font(resId = R.font.fa_solid_900)) + +sealed class AppColors private constructor() { + companion object { + val TransparentBlack25 = Color(0x40000000) + val TransparentBlack50 = Color(0x80000000) + val TransparentBlack75 = Color(0xBF000000) + } +} diff --git a/app/src/main/java/com/github/damontecres/dolphin/ui/playback/ControllerViewState.kt b/app/src/main/java/com/github/damontecres/dolphin/ui/playback/ControllerViewState.kt new file mode 100644 index 00000000..301abd80 --- /dev/null +++ b/app/src/main/java/com/github/damontecres/dolphin/ui/playback/ControllerViewState.kt @@ -0,0 +1,48 @@ +package com.github.damontecres.dolphin.ui.playback + +import androidx.annotation.IntRange +import androidx.compose.runtime.getValue +import androidx.compose.runtime.mutableStateOf +import androidx.compose.runtime.setValue +import kotlinx.coroutines.FlowPreview +import kotlinx.coroutines.channels.Channel +import kotlinx.coroutines.channels.Channel.Factory.CONFLATED +import kotlinx.coroutines.flow.consumeAsFlow +import kotlinx.coroutines.flow.debounce + +class ControllerViewState internal constructor( + @IntRange(from = 0) + private val hideMilliseconds: Int, + val controlsEnabled: Boolean, +) { + private val channel = Channel(CONFLATED) + private var _controlsVisible by mutableStateOf(false) + val controlsVisible get() = _controlsVisible + + fun showControls(milliseconds: Int = hideMilliseconds) { + if (controlsEnabled) { + _controlsVisible = true + } + pulseControls(milliseconds) + } + + fun hideControls() { + _controlsVisible = false + } + + fun pulseControls(milliseconds: Int = hideMilliseconds) { +// Log.i("PlaybackPageContent", "pulseControls=$milliseconds") + channel.trySend(milliseconds) + } + + @OptIn(FlowPreview::class) + suspend fun observe() { + channel + .consumeAsFlow() + .debounce { it.toLong() } + .collect { +// Log.i("PlaybackPageContent", "collect") + _controlsVisible = false + } + } +} diff --git a/app/src/main/java/com/github/damontecres/dolphin/ui/playback/KeyIdentifier.kt b/app/src/main/java/com/github/damontecres/dolphin/ui/playback/KeyIdentifier.kt new file mode 100644 index 00000000..1f911e4d --- /dev/null +++ b/app/src/main/java/com/github/damontecres/dolphin/ui/playback/KeyIdentifier.kt @@ -0,0 +1,44 @@ +package com.github.damontecres.dolphin.ui.playback + +import androidx.compose.ui.input.key.Key +import androidx.compose.ui.input.key.KeyEvent +import androidx.compose.ui.input.key.key + +fun isDirectionalDpad(event: KeyEvent): Boolean = + event.key == Key.DirectionUp || + event.key == Key.DirectionDown || + event.key == Key.DirectionLeft || + event.key == Key.DirectionRight || + event.key == Key.DirectionUpRight || + event.key == Key.DirectionUpLeft || + event.key == Key.DirectionDownRight || + event.key == Key.DirectionDownLeft + +fun isDpad(event: KeyEvent): Boolean = event.key == Key.DirectionCenter || isDirectionalDpad(event) + +fun isEnterKey(event: KeyEvent) = event.key == Key.DirectionCenter || event.key == Key.Enter || event.key == Key.NumPadEnter + +fun isMedia(event: KeyEvent): Boolean = + event.key == Key.MediaPlay || + event.key == Key.MediaPause || + event.key == Key.MediaPlayPause || + event.key == Key.MediaFastForward || + event.key == Key.MediaSkipForward || + event.key == Key.MediaRewind || + event.key == Key.MediaSkipBackward || + event.key == Key.MediaNext || + event.key == Key.MediaPrevious + +fun isBackwardButton(event: KeyEvent): Boolean = + event.key == Key.PageUp || + event.key == Key.ChannelUp || + event.key == Key.MediaPrevious || + event.key == Key.MediaRewind || + event.key == Key.MediaSkipBackward + +fun isForwardButton(event: KeyEvent): Boolean = + event.key == Key.PageDown || + event.key == Key.ChannelDown || + event.key == Key.MediaNext || + event.key == Key.MediaFastForward || + event.key == Key.MediaSkipForward diff --git a/app/src/main/java/com/github/damontecres/dolphin/ui/playback/PlaybackConstants.kt b/app/src/main/java/com/github/damontecres/dolphin/ui/playback/PlaybackConstants.kt new file mode 100644 index 00000000..b1779ee6 --- /dev/null +++ b/app/src/main/java/com/github/damontecres/dolphin/ui/playback/PlaybackConstants.kt @@ -0,0 +1,14 @@ +package com.github.damontecres.dolphin.ui.playback + +import androidx.compose.ui.layout.ContentScale + +val playbackScaleOptions = + mapOf( + ContentScale.Fit to "Fit", + ContentScale.None to "None", + ContentScale.Crop to "Crop", +// ContentScale.Inside to "Inside", + ContentScale.FillBounds to "Fill", + ContentScale.FillWidth to "Fill Width", + ContentScale.FillHeight to "Fill Height", + ) diff --git a/app/src/main/java/com/github/damontecres/dolphin/ui/playback/PlaybackContent.kt b/app/src/main/java/com/github/damontecres/dolphin/ui/playback/PlaybackContent.kt index 4af5631c..439d02e4 100644 --- a/app/src/main/java/com/github/damontecres/dolphin/ui/playback/PlaybackContent.kt +++ b/app/src/main/java/com/github/damontecres/dolphin/ui/playback/PlaybackContent.kt @@ -1,33 +1,55 @@ package com.github.damontecres.dolphin.ui.playback import androidx.annotation.OptIn +import androidx.compose.animation.AnimatedVisibility +import androidx.compose.animation.slideInVertically +import androidx.compose.animation.slideOutVertically import androidx.compose.foundation.background import androidx.compose.foundation.focusable import androidx.compose.foundation.layout.Box +import androidx.compose.foundation.layout.WindowInsets +import androidx.compose.foundation.layout.asPaddingValues +import androidx.compose.foundation.layout.fillMaxSize +import androidx.compose.foundation.layout.fillMaxWidth +import androidx.compose.foundation.layout.height +import androidx.compose.foundation.layout.padding +import androidx.compose.foundation.layout.systemBars import androidx.compose.runtime.Composable import androidx.compose.runtime.LaunchedEffect import androidx.compose.runtime.getValue import androidx.compose.runtime.livedata.observeAsState import androidx.compose.runtime.mutableFloatStateOf +import androidx.compose.runtime.mutableLongStateOf import androidx.compose.runtime.mutableStateOf import androidx.compose.runtime.remember +import androidx.compose.runtime.rememberCoroutineScope import androidx.compose.runtime.setValue +import androidx.compose.ui.Alignment import androidx.compose.ui.Modifier +import androidx.compose.ui.draw.clip import androidx.compose.ui.focus.FocusRequester import androidx.compose.ui.focus.focusRequester import androidx.compose.ui.graphics.Color +import androidx.compose.ui.graphics.RectangleShape import androidx.compose.ui.input.key.onKeyEvent import androidx.compose.ui.layout.ContentScale +import androidx.compose.ui.unit.dp import androidx.hilt.lifecycle.viewmodel.compose.hiltViewModel import androidx.media3.common.util.UnstableApi import androidx.media3.ui.compose.PlayerSurface import androidx.media3.ui.compose.SURFACE_TYPE_SURFACE_VIEW import androidx.media3.ui.compose.modifiers.resizeWithContentScale +import androidx.media3.ui.compose.state.rememberNextButtonState +import androidx.media3.ui.compose.state.rememberPlayPauseButtonState import androidx.media3.ui.compose.state.rememberPresentationState +import androidx.media3.ui.compose.state.rememberPreviousButtonState +import androidx.tv.material3.MaterialTheme import com.github.damontecres.dolphin.preferences.UserPreferences import com.github.damontecres.dolphin.tryRequestFocus import com.github.damontecres.dolphin.ui.nav.Destination import com.github.damontecres.dolphin.ui.nav.NavigationManager +import com.github.damontecres.stashapp.ui.components.playback.SkipIndicator +import com.github.damontecres.stashapp.ui.components.playback.rememberSeekBarState @OptIn(UnstableApi::class) @Composable @@ -38,11 +60,17 @@ fun PlaybackContent( modifier: Modifier = Modifier, viewModel: PlaybackViewModel = hiltViewModel(), ) { + val scope = rememberCoroutineScope() LaunchedEffect(destination.itemId) { - viewModel.init(destination.itemId) + viewModel.init(destination.itemId, destination.item) } val player = viewModel.player val stream by viewModel.stream.observeAsState(null) + + val title by viewModel.title.observeAsState(null) + val subtitle by viewModel.subtitle.observeAsState(null) + val duration by viewModel.duration.observeAsState(null) + if (stream == null) { // TODO loading } else { @@ -55,16 +83,52 @@ fun PlaybackContent( val scaledModifier = Modifier.resizeWithContentScale(contentScale, presentationState.videoSizeDp) val focusRequester = remember { FocusRequester() } + val playPauseState = rememberPlayPauseButtonState(player) + val previousState = rememberPreviousButtonState(player) + val nextState = rememberNextButtonState(player) + val seekBarState = rememberSeekBarState(player, scope) + LaunchedEffect(Unit) { focusRequester.tryRequestFocus() } + val controllerViewState = + remember { + ControllerViewState( + 5_000, + true, + ) + }.also { + LaunchedEffect(it) { + it.observe() + } + } + var skipIndicatorDuration by remember { mutableLongStateOf(0L) } + LaunchedEffect(controllerViewState.controlsVisible) { + // If controller shows/hides, immediately cancel the skip indicator + skipIndicatorDuration = 0L + } + var skipPosition by remember { mutableLongStateOf(0L) } + val updateSkipIndicator = { delta: Long -> + if (skipIndicatorDuration > 0 && delta < 0 || skipIndicatorDuration < 0 && delta > 0) { + skipIndicatorDuration = 0 + } + skipIndicatorDuration += delta + skipPosition = player.currentPosition + } + val keyHandler = + PlaybackKeyHandler( + player = player, + controlsEnabled = true, + skipWithLeftRight = true, + controllerViewState = controllerViewState, + updateSkipIndicator = updateSkipIndicator, + ) + Box( modifier .background(Color.Black) - .onKeyEvent { - // TODO handle key events for playback controls - false - }.focusRequester(focusRequester) + .onKeyEvent(keyHandler::onKeyEvent) + .focusRequester(focusRequester) .focusable(), ) { PlayerSurface( @@ -79,6 +143,70 @@ fun PlaybackContent( .background(Color.Black), ) } + + if (!controllerViewState.controlsVisible && skipIndicatorDuration != 0L) { + SkipIndicator( + durationMs = skipIndicatorDuration, + onFinish = { + skipIndicatorDuration = 0L + }, + modifier = + Modifier + .align(Alignment.BottomCenter) + .padding(bottom = 70.dp), + ) + val showSkipProgress = true // TODO get from preferences + if (showSkipProgress) { + duration?.let { + val percent = + skipPosition.toFloat() / (it.inWholeMilliseconds).toFloat() + Box( + modifier = + Modifier + .align(Alignment.BottomStart) + .background(MaterialTheme.colorScheme.border) + .clip(RectangleShape) + .height(3.dp) + .fillMaxWidth(percent), + ) { + // No-op + } + } + } + } + + AnimatedVisibility( + controllerViewState.controlsVisible, + Modifier, + slideInVertically { it }, + slideOutVertically { it }, + ) { + PlaybackOverlay( + modifier = + Modifier + .padding(WindowInsets.systemBars.asPaddingValues()) + .fillMaxSize() + .background(Color.Transparent), + title = title, + subtitle = subtitle, + captions = listOf(), + playerControls = player, + controllerViewState = controllerViewState, + showPlay = playPauseState.showPlay, + previousEnabled = previousState.isEnabled, + nextEnabled = nextState.isEnabled, + seekEnabled = true, + onPlaybackActionClick = {}, + onSeekBarChange = seekBarState::onValueChange, + showDebugInfo = false, + scale = contentScale, + playbackSpeed = playbackSpeed, + moreButtonOptions = MoreButtonOptions(mapOf()), + subtitleIndex = null, + audioIndex = null, + audioOptions = listOf(), + ) + } } } } diff --git a/app/src/main/java/com/github/damontecres/dolphin/ui/playback/PlaybackControls.kt b/app/src/main/java/com/github/damontecres/dolphin/ui/playback/PlaybackControls.kt new file mode 100644 index 00000000..825c6dfb --- /dev/null +++ b/app/src/main/java/com/github/damontecres/dolphin/ui/playback/PlaybackControls.kt @@ -0,0 +1,597 @@ +@file:kotlin.OptIn(ExperimentalMaterial3Api::class) + +package com.github.damontecres.dolphin.ui.playback + +import android.view.Gravity +import androidx.annotation.DrawableRes +import androidx.annotation.OptIn +import androidx.compose.foundation.background +import androidx.compose.foundation.focusGroup +import androidx.compose.foundation.interaction.MutableInteractionSource +import androidx.compose.foundation.interaction.collectIsFocusedAsState +import androidx.compose.foundation.layout.Arrangement +import androidx.compose.foundation.layout.Box +import androidx.compose.foundation.layout.Column +import androidx.compose.foundation.layout.PaddingValues +import androidx.compose.foundation.layout.Row +import androidx.compose.foundation.layout.fillMaxSize +import androidx.compose.foundation.layout.fillMaxWidth +import androidx.compose.foundation.layout.padding +import androidx.compose.foundation.layout.size +import androidx.compose.foundation.layout.wrapContentSize +import androidx.compose.foundation.layout.wrapContentWidth +import androidx.compose.foundation.relocation.BringIntoViewRequester +import androidx.compose.foundation.relocation.bringIntoViewRequester +import androidx.compose.foundation.shape.CircleShape +import androidx.compose.material3.ExperimentalMaterial3Api +import androidx.compose.runtime.Composable +import androidx.compose.runtime.LaunchedEffect +import androidx.compose.runtime.getValue +import androidx.compose.runtime.mutableFloatStateOf +import androidx.compose.runtime.mutableLongStateOf +import androidx.compose.runtime.mutableStateOf +import androidx.compose.runtime.remember +import androidx.compose.runtime.rememberCoroutineScope +import androidx.compose.runtime.setValue +import androidx.compose.ui.Alignment +import androidx.compose.ui.Modifier +import androidx.compose.ui.draw.clip +import androidx.compose.ui.focus.FocusRequester +import androidx.compose.ui.focus.focusRequester +import androidx.compose.ui.focus.onFocusChanged +import androidx.compose.ui.graphics.Color +import androidx.compose.ui.layout.ContentScale +import androidx.compose.ui.platform.LocalContext +import androidx.compose.ui.platform.LocalView +import androidx.compose.ui.res.painterResource +import androidx.compose.ui.unit.dp +import androidx.compose.ui.window.Dialog +import androidx.compose.ui.window.DialogProperties +import androidx.compose.ui.window.DialogWindowProvider +import androidx.media3.common.Player +import androidx.media3.common.util.UnstableApi +import androidx.tv.material3.Button +import androidx.tv.material3.ButtonDefaults +import androidx.tv.material3.Icon +import androidx.tv.material3.ListItem +import androidx.tv.material3.MaterialTheme +import androidx.tv.material3.Text +import com.github.damontecres.dolphin.R +import com.github.damontecres.dolphin.tryRequestFocus +import com.github.damontecres.dolphin.ui.AppColors +import com.github.damontecres.stashapp.ui.components.playback.SeekBarImpl +import kotlinx.coroutines.delay +import kotlinx.coroutines.isActive +import kotlinx.coroutines.launch +import timber.log.Timber +import kotlin.time.Duration.Companion.seconds + +sealed interface PlaybackAction { + data object ShowDebug : PlaybackAction + + data object ShowPlaylist : PlaybackAction + + data object ShowVideoFilterDialog : PlaybackAction + + data class ToggleCaptions( + val index: Int, + ) : PlaybackAction + + data class ToggleAudio( + val index: Int, + ) : PlaybackAction + + data class PlaybackSpeed( + val value: Float, + ) : PlaybackAction + + data class Scale( + val scale: ContentScale, + ) : PlaybackAction +} + +@OptIn(UnstableApi::class) +@Composable +fun PlaybackControls( + captions: List, + playerControls: Player, + controllerViewState: ControllerViewState, + onPlaybackActionClick: (PlaybackAction) -> Unit, + showDebugInfo: Boolean, + onSeekProgress: (Float) -> Unit, + showPlay: Boolean, + previousEnabled: Boolean, + nextEnabled: Boolean, + seekEnabled: Boolean, + moreButtonOptions: MoreButtonOptions, + subtitleIndex: Int?, + audioIndex: Int?, + audioOptions: List, + playbackSpeed: Float, + scale: ContentScale, + seekBarIntervals: Int, + modifier: Modifier = Modifier, + initialFocusRequester: FocusRequester = remember { FocusRequester() }, + seekBarInteractionSource: MutableInteractionSource = remember { MutableInteractionSource() }, +) { + val scope = rememberCoroutineScope() + + val bringIntoViewRequester = remember { BringIntoViewRequester() } + val onControllerInteraction = { + scope.launch { + bringIntoViewRequester.bringIntoView() + } + controllerViewState.pulseControls() + } + val onControllerInteractionForDialog = { + scope.launch { + bringIntoViewRequester.bringIntoView() + } + controllerViewState.pulseControls(Int.MAX_VALUE) + } + LaunchedEffect(controllerViewState.controlsVisible) { + if (controllerViewState.controlsVisible) { + initialFocusRequester.tryRequestFocus() + } + } + Column( + modifier = modifier.bringIntoViewRequester(bringIntoViewRequester), + horizontalAlignment = Alignment.CenterHorizontally, + ) { + SeekBar( + player = playerControls, + controllerViewState = controllerViewState, + onSeekProgress = onSeekProgress, + interactionSource = seekBarInteractionSource, + isEnabled = seekEnabled, + intervals = seekBarIntervals, + modifier = + Modifier + .padding(vertical = 8.dp) + .fillMaxWidth(.95f), + ) + Box( + modifier = + Modifier + .padding(horizontal = 8.dp) + .fillMaxWidth(), + ) { + LeftPlaybackButtons( + onControllerInteraction = onControllerInteraction, + onPlaybackActionClick = onPlaybackActionClick, + showDebugInfo = showDebugInfo, + moreButtonOptions = moreButtonOptions, + modifier = Modifier.align(Alignment.CenterStart), + ) + PlaybackButtons( + player = playerControls, + initialFocusRequester = initialFocusRequester, + onControllerInteraction = onControllerInteraction, + showPlay = showPlay, + previousEnabled = previousEnabled, + nextEnabled = nextEnabled, + modifier = Modifier.align(Alignment.Center), + ) + RightPlaybackButtons( + captions = captions, + onControllerInteraction = onControllerInteraction, + onControllerInteractionForDialog = onControllerInteractionForDialog, + onPlaybackActionClick = onPlaybackActionClick, + subtitleIndex = subtitleIndex, + audioOptions = audioOptions, + audioIndex = audioIndex, + playbackSpeed = playbackSpeed, + scale = scale, + modifier = Modifier.align(Alignment.CenterEnd), + ) + } + } +} + +@OptIn(UnstableApi::class, ExperimentalMaterial3Api::class) +@Composable +fun SeekBar( + player: Player, + isEnabled: Boolean, + intervals: Int, + controllerViewState: ControllerViewState, + onSeekProgress: (Float) -> Unit, + modifier: Modifier = Modifier, + interactionSource: MutableInteractionSource = remember { MutableInteractionSource() }, +) { + var bufferedProgress by remember(player) { mutableFloatStateOf(player.bufferedPosition.toFloat() / player.duration) } + var position by remember(player) { mutableLongStateOf(player.currentPosition) } + var progress by remember(player) { mutableFloatStateOf(player.currentPosition.toFloat() / player.duration) } + LaunchedEffect(player) { + while (isActive) { + bufferedProgress = player.bufferedPosition.toFloat() / player.duration + position = player.currentPosition + progress = player.currentPosition.toFloat() / player.duration + delay(250L) + } + } + Column( + modifier = modifier, + horizontalAlignment = Alignment.CenterHorizontally, + ) { + SeekBarImpl( + progress = progress, + bufferedProgress = bufferedProgress, + onSeek = { + onSeekProgress(it) + }, + controllerViewState = controllerViewState, + intervals = intervals, + modifier = Modifier.fillMaxWidth(), + interactionSource = interactionSource, + enabled = isEnabled, + ) + Row( + modifier = Modifier.fillMaxWidth(), + horizontalArrangement = Arrangement.SpaceBetween, + ) { + Text( + text = (position / 1000).seconds.toString(), + color = MaterialTheme.colorScheme.onSurface, + style = MaterialTheme.typography.labelLarge, + modifier = + Modifier + .padding(8.dp), + ) + Text( + text = "-" + ((player.duration - position) / 1000).seconds.toString(), + color = MaterialTheme.colorScheme.onSurface, + style = MaterialTheme.typography.labelLarge, + modifier = + Modifier + .padding(8.dp), + ) + } + } +} + +private val buttonSpacing = 4.dp + +@Composable +fun LeftPlaybackButtons( + onControllerInteraction: () -> Unit, + onPlaybackActionClick: (PlaybackAction) -> Unit, + showDebugInfo: Boolean, + moreButtonOptions: MoreButtonOptions, + modifier: Modifier = Modifier, +) { + var showMoreOptions by remember { mutableStateOf(false) } + Row( + modifier = modifier.focusGroup(), + horizontalArrangement = Arrangement.spacedBy(buttonSpacing), + ) { + // More options + PlaybackButton( + iconRes = R.drawable.baseline_more_vert_96, + onClick = { + onControllerInteraction.invoke() + showMoreOptions = true + }, + enabled = true, + onControllerInteraction = onControllerInteraction, + ) + } + if (showMoreOptions) { + // TODO options need context about what to display + val options = + buildList { + addAll(moreButtonOptions.options.keys) + add(if (showDebugInfo) "Hide transcode info" else "Show transcode info") + } + BottomDialog( + choices = options, + onDismissRequest = { showMoreOptions = false }, + onSelectChoice = { index, choice -> + val action = moreButtonOptions.options[choice] ?: PlaybackAction.ShowDebug + onPlaybackActionClick.invoke(action) + }, + gravity = Gravity.START, + ) + } +} + +private val speedOptions = listOf(".25", ".5", ".75", "1.0", "1.25", "1.5", "2.0") + +@Composable +fun RightPlaybackButtons( + captions: List, + onControllerInteraction: () -> Unit, + onControllerInteractionForDialog: () -> Unit, + onPlaybackActionClick: (PlaybackAction) -> Unit, + subtitleIndex: Int?, + audioOptions: List, + audioIndex: Int?, + playbackSpeed: Float, + scale: ContentScale, + modifier: Modifier = Modifier, +) { + var showCaptionDialog by remember { mutableStateOf(false) } + var showOptionsDialog by remember { mutableStateOf(false) } + var showAudioDialog by remember { mutableStateOf(false) } + var showSpeedDialog by remember { mutableStateOf(false) } + var showScaleDialog by remember { mutableStateOf(false) } + Row( + modifier = modifier.focusGroup(), + horizontalArrangement = Arrangement.spacedBy(buttonSpacing), + ) { + // Captions + PlaybackButton( + enabled = captions.isNotEmpty(), + iconRes = R.drawable.captions_svgrepo_com, + onClick = { + onControllerInteractionForDialog.invoke() + showCaptionDialog = true + }, + onControllerInteraction = onControllerInteraction, + ) + // Playback speed, etc + PlaybackButton( + iconRes = R.drawable.vector_settings, + onClick = { + onControllerInteractionForDialog.invoke() + showOptionsDialog = true + }, + enabled = true, + onControllerInteraction = onControllerInteraction, + ) + } + if (showCaptionDialog) { + val context = LocalContext.current + val options = captions.map { it.displayString(context) } + Timber.v("subtitleIndex=$subtitleIndex, options=$options") + BottomDialog( + choices = options, + currentChoice = subtitleIndex, + onDismissRequest = { + onControllerInteraction.invoke() + showCaptionDialog = false + }, + onSelectChoice = { index, _ -> + onPlaybackActionClick.invoke(PlaybackAction.ToggleCaptions(index)) + }, + gravity = Gravity.END, + ) + } + if (showOptionsDialog) { + val options = listOf("Audio Track", "Playback Speed", "Video Scale") + BottomDialog( + choices = options, + currentChoice = null, + onDismissRequest = { + onControllerInteraction.invoke() + showOptionsDialog = false + }, + onSelectChoice = { index, _ -> + when (index) { + 0 -> showAudioDialog = true + 1 -> showSpeedDialog = true + 2 -> showScaleDialog = true + } + }, + gravity = Gravity.END, + ) + } + if (showAudioDialog) { + BottomDialog( + choices = audioOptions, + currentChoice = audioIndex, + onDismissRequest = { + onControllerInteraction.invoke() + showAudioDialog = false + }, + onSelectChoice = { index, _ -> + onPlaybackActionClick.invoke(PlaybackAction.ToggleAudio(index)) + }, + gravity = Gravity.END, + ) + } + if (showSpeedDialog) { + BottomDialog( + choices = speedOptions, + currentChoice = speedOptions.indexOf(playbackSpeed.toString()), + onDismissRequest = { + onControllerInteraction.invoke() + showSpeedDialog = false + }, + onSelectChoice = { _, value -> + onPlaybackActionClick.invoke(PlaybackAction.PlaybackSpeed(value.toFloat())) + }, + gravity = Gravity.END, + ) + } + if (showScaleDialog) { + BottomDialog( + choices = playbackScaleOptions.values.toList(), + currentChoice = playbackScaleOptions.keys.toList().indexOf(scale), + onDismissRequest = { + onControllerInteraction.invoke() + showScaleDialog = false + }, + onSelectChoice = { index, _ -> + onPlaybackActionClick.invoke(PlaybackAction.Scale(playbackScaleOptions.keys.toList()[index])) + }, + gravity = Gravity.END, + ) + } +} + +@OptIn(UnstableApi::class) +@Composable +fun PlaybackButtons( + player: Player, + initialFocusRequester: FocusRequester, + onControllerInteraction: () -> Unit, + showPlay: Boolean, + previousEnabled: Boolean, + nextEnabled: Boolean, + modifier: Modifier = Modifier, +) { + Row( + modifier = modifier.focusGroup(), + horizontalArrangement = Arrangement.spacedBy(buttonSpacing), + ) { + PlaybackButton( + iconRes = R.drawable.baseline_skip_previous_24, + onClick = { + onControllerInteraction.invoke() + player.seekToPrevious() + }, + enabled = previousEnabled, + onControllerInteraction = onControllerInteraction, + ) + PlaybackButton( + iconRes = R.drawable.baseline_fast_rewind_24, + onClick = { + onControllerInteraction.invoke() + player.seekBack() + }, + onControllerInteraction = onControllerInteraction, + ) + PlaybackButton( + modifier = Modifier.focusRequester(initialFocusRequester), + iconRes = if (showPlay) R.drawable.baseline_play_arrow_24 else R.drawable.baseline_pause_24, + onClick = { + onControllerInteraction.invoke() + if (showPlay) player.play() else player.pause() + }, + onControllerInteraction = onControllerInteraction, + ) + PlaybackButton( + iconRes = R.drawable.baseline_fast_forward_24, + onClick = { + onControllerInteraction.invoke() + player.seekForward() + }, + onControllerInteraction = onControllerInteraction, + ) + PlaybackButton( + iconRes = R.drawable.baseline_skip_next_24, + onClick = { + onControllerInteraction.invoke() + player.seekToNext() + }, + enabled = nextEnabled, + onControllerInteraction = onControllerInteraction, + ) + } +} + +@Composable +fun PlaybackButton( + @DrawableRes iconRes: Int, + onClick: () -> Unit, + onControllerInteraction: () -> Unit, + modifier: Modifier = Modifier, + enabled: Boolean = true, +) { + val selectedColor = MaterialTheme.colorScheme.border + Button( + enabled = enabled, + onClick = onClick, + shape = ButtonDefaults.shape(CircleShape), + colors = + ButtonDefaults.colors( + containerColor = AppColors.TransparentBlack25, + focusedContainerColor = selectedColor, + ), + contentPadding = PaddingValues(8.dp), + modifier = + modifier + .padding(8.dp) + .size(56.dp, 56.dp) + .onFocusChanged { onControllerInteraction.invoke() }, + ) { + Icon( + modifier = Modifier.fillMaxSize(), + painter = painterResource(iconRes), + contentDescription = "", + tint = MaterialTheme.colorScheme.onSurface, + ) + } +} + +@Composable +private fun BottomDialog( + choices: List, + onDismissRequest: () -> Unit, + onSelectChoice: (Int, String) -> Unit, + gravity: Int, + currentChoice: Int? = null, +) { + // TODO enforcing a width ends up ignore the gravity + Dialog( + onDismissRequest = onDismissRequest, + properties = DialogProperties(usePlatformDefaultWidth = true), + ) { + val dialogWindowProvider = LocalView.current.parent as? DialogWindowProvider + dialogWindowProvider?.window?.let { window -> + window.setGravity(Gravity.BOTTOM or gravity) // Move down, by default dialogs are in the centre + window.setDimAmount(0f) // Remove dimmed background of ongoing playback + } + + Box( + modifier = + Modifier + .wrapContentSize() + .padding(8.dp) + .background(Color.DarkGray), + ) { + Column( + modifier = + Modifier + .fillMaxWidth() +// .widthIn(max = 240.dp) + .wrapContentWidth(), + verticalArrangement = Arrangement.Center, + horizontalAlignment = Alignment.CenterHorizontally, + ) { + choices.forEachIndexed { index, choice -> + val interactionSource = remember { MutableInteractionSource() } + val focused = interactionSource.collectIsFocusedAsState().value + val color = + if (focused) { + MaterialTheme.colorScheme.inverseOnSurface + } else { + MaterialTheme.colorScheme.onSurface + } + ListItem( + selected = index == currentChoice, + onClick = { + onDismissRequest() + onSelectChoice(index, choice) + }, + leadingContent = { + if (index == currentChoice) { + Box( + modifier = + Modifier + .padding(horizontal = 4.dp) + .clip(CircleShape) + .align(Alignment.Center) + .background(color) + .size(8.dp), + ) + } + }, + headlineContent = { + Text( + text = choice, + color = color, + ) + }, + interactionSource = interactionSource, + ) + } + } + } + } +} + +data class MoreButtonOptions( + val options: Map, +) diff --git a/app/src/main/java/com/github/damontecres/dolphin/ui/playback/PlaybackKeyHandler.kt b/app/src/main/java/com/github/damontecres/dolphin/ui/playback/PlaybackKeyHandler.kt new file mode 100644 index 00000000..2d4b7962 --- /dev/null +++ b/app/src/main/java/com/github/damontecres/dolphin/ui/playback/PlaybackKeyHandler.kt @@ -0,0 +1,81 @@ +package com.github.damontecres.dolphin.ui.playback + +import androidx.compose.ui.input.key.Key +import androidx.compose.ui.input.key.KeyEvent +import androidx.compose.ui.input.key.KeyEventType +import androidx.compose.ui.input.key.key +import androidx.compose.ui.input.key.type +import androidx.media3.common.Player +import androidx.media3.common.util.Util + +class PlaybackKeyHandler( + private val player: Player, + private val controlsEnabled: Boolean, + private val skipWithLeftRight: Boolean, + private val controllerViewState: ControllerViewState, + private val updateSkipIndicator: (Long) -> Unit, +) { + fun onKeyEvent(it: KeyEvent): Boolean { + var result = true + if (!controlsEnabled) { + result = false + } else if (it.type != KeyEventType.KeyUp) { + result = false + } else if (isDpad(it)) { + if (!controllerViewState.controlsVisible) { + if (skipWithLeftRight && it.key == Key.DirectionLeft) { + updateSkipIndicator(-player.seekBackIncrement) + player.seekBack() + } else if (skipWithLeftRight && it.key == Key.DirectionRight) { + player.seekForward() + updateSkipIndicator(player.seekForwardIncrement) + } else { + controllerViewState.showControls() + } + } else { + // When controller is visible, its buttons will handle pulsing + } + } else if (isMedia(it)) { + when (it.key) { + Key.MediaPlay -> { + Util.handlePlayButtonAction(player) + } + + Key.MediaPause -> { + Util.handlePauseButtonAction(player) + controllerViewState.showControls() + } + + Key.MediaPlayPause -> { + Util.handlePlayPauseButtonAction(player) + if (!player.isPlaying) { + controllerViewState.showControls() + } + } + + Key.MediaFastForward, Key.MediaSkipForward -> { + player.seekForward() + updateSkipIndicator(player.seekForwardIncrement) + } + + Key.MediaRewind, Key.MediaSkipBackward -> { + player.seekBack() + updateSkipIndicator(-player.seekBackIncrement) + } + + Key.MediaNext -> if (player.isCommandAvailable(Player.COMMAND_SEEK_TO_NEXT)) player.seekToNext() + Key.MediaPrevious -> if (player.isCommandAvailable(Player.COMMAND_SEEK_TO_PREVIOUS)) player.seekToPrevious() + else -> result = false + } + } else if (it.key == Key.Enter && !controllerViewState.controlsVisible) { + controllerViewState.showControls() + } else if (it.key == Key.Back && controllerViewState.controlsVisible) { + // TODO change this to a BackHandler? + controllerViewState.hideControls() + } else { + controllerViewState.pulseControls() + result = false + } + return result + } +} diff --git a/app/src/main/java/com/github/damontecres/dolphin/ui/playback/PlaybackOverlay.kt b/app/src/main/java/com/github/damontecres/dolphin/ui/playback/PlaybackOverlay.kt new file mode 100644 index 00000000..aed56cf3 --- /dev/null +++ b/app/src/main/java/com/github/damontecres/dolphin/ui/playback/PlaybackOverlay.kt @@ -0,0 +1,89 @@ +package com.github.damontecres.dolphin.ui.playback + +import androidx.compose.foundation.interaction.MutableInteractionSource +import androidx.compose.foundation.interaction.collectIsFocusedAsState +import androidx.compose.foundation.layout.Box +import androidx.compose.foundation.layout.Column +import androidx.compose.foundation.layout.fillMaxWidth +import androidx.compose.runtime.Composable +import androidx.compose.runtime.getValue +import androidx.compose.runtime.mutableFloatStateOf +import androidx.compose.runtime.mutableStateOf +import androidx.compose.runtime.remember +import androidx.compose.runtime.setValue +import androidx.compose.ui.Alignment +import androidx.compose.ui.Modifier +import androidx.compose.ui.layout.ContentScale +import androidx.media3.common.Player +import androidx.tv.material3.Text + +@Composable +fun PlaybackOverlay( + title: String?, + captions: List, + playerControls: Player, + controllerViewState: ControllerViewState, + showPlay: Boolean, + previousEnabled: Boolean, + nextEnabled: Boolean, + seekEnabled: Boolean, + onPlaybackActionClick: (PlaybackAction) -> Unit, + onSeekBarChange: (Float) -> Unit, + showDebugInfo: Boolean, + scale: ContentScale, + playbackSpeed: Float, + moreButtonOptions: MoreButtonOptions, + subtitleIndex: Int?, + audioIndex: Int?, + audioOptions: List, + modifier: Modifier = Modifier, + subtitle: String? = null, + seekBarInteractionSource: MutableInteractionSource = remember { MutableInteractionSource() }, +) { + // Will be used for preview/trick play images + var seekProgress by remember { mutableFloatStateOf(-1f) } + val seekBarFocused by seekBarInteractionSource.collectIsFocusedAsState() + var seekBarDragging by remember { mutableStateOf(false) } + + Box( + modifier = modifier, + contentAlignment = Alignment.BottomCenter, + ) { + Column { + title?.let { + Text( + text = it, + ) + } + subtitle?.let { + Text( + text = it, + ) + } + PlaybackControls( + modifier = Modifier.fillMaxWidth(), + captions = captions, + playerControls = playerControls, + onPlaybackActionClick = onPlaybackActionClick, + controllerViewState = controllerViewState, + showDebugInfo = showDebugInfo, + onSeekProgress = { + seekProgress = it + onSeekBarChange(it) + }, + showPlay = showPlay, + previousEnabled = previousEnabled, + nextEnabled = nextEnabled, + seekEnabled = seekEnabled, + seekBarInteractionSource = seekBarInteractionSource, + moreButtonOptions = moreButtonOptions, + subtitleIndex = subtitleIndex, + audioIndex = audioIndex, + audioOptions = audioOptions, + playbackSpeed = playbackSpeed, + scale = scale, + seekBarIntervals = 16, + ) + } + } +} diff --git a/app/src/main/java/com/github/damontecres/dolphin/ui/playback/PlaybackViewModel.kt b/app/src/main/java/com/github/damontecres/dolphin/ui/playback/PlaybackViewModel.kt index bbd217f1..3cff2a34 100644 --- a/app/src/main/java/com/github/damontecres/dolphin/ui/playback/PlaybackViewModel.kt +++ b/app/src/main/java/com/github/damontecres/dolphin/ui/playback/PlaybackViewModel.kt @@ -15,9 +15,12 @@ import kotlinx.coroutines.withContext import org.jellyfin.sdk.api.client.ApiClient import org.jellyfin.sdk.api.client.extensions.mediaInfoApi import org.jellyfin.sdk.api.client.extensions.videosApi +import org.jellyfin.sdk.model.api.BaseItemDto import org.jellyfin.sdk.model.api.PlaybackInfoDto import java.util.UUID import javax.inject.Inject +import kotlin.time.Duration +import kotlin.time.Duration.Companion.nanoseconds enum class TranscodeType { DIRECT_PLAY, @@ -56,11 +59,22 @@ class PlaybackViewModel val stream = MutableLiveData(null) + val title = MutableLiveData(null) + val subtitle = MutableLiveData(null) + val duration = MutableLiveData(null) + init { addCloseable { player.release() } } - fun init(itemId: UUID) { + fun init( + itemId: UUID, + item: BaseItemDto?, + ) { + if (item != null) { + title.value = item.name + subtitle.value = item.episodeTitle + } viewModelScope.launch(Dispatchers.IO) { val response = api.mediaInfoApi @@ -105,6 +119,7 @@ class PlaybackViewModel } val decision = StreamDecision(itemId, mediaUrl, transcodeType) withContext(Dispatchers.Main) { + duration.value = source.runTimeTicks?.nanoseconds stream.value = decision player.setMediaItem(decision.mediaItem) player.prepare() diff --git a/app/src/main/java/com/github/damontecres/dolphin/ui/playback/SeekBar.kt b/app/src/main/java/com/github/damontecres/dolphin/ui/playback/SeekBar.kt new file mode 100644 index 00000000..7be6f874 --- /dev/null +++ b/app/src/main/java/com/github/damontecres/dolphin/ui/playback/SeekBar.kt @@ -0,0 +1,144 @@ +package com.github.damontecres.stashapp.ui.components.playback + +/* + * Modified from https://github.com/android/tv-samples + * + * Copyright 2023 Google LLC + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * https://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +import androidx.compose.animation.core.animateDpAsState +import androidx.compose.foundation.Canvas +import androidx.compose.foundation.focusable +import androidx.compose.foundation.interaction.MutableInteractionSource +import androidx.compose.foundation.interaction.collectIsFocusedAsState +import androidx.compose.foundation.layout.Arrangement +import androidx.compose.foundation.layout.Column +import androidx.compose.foundation.layout.fillMaxWidth +import androidx.compose.foundation.layout.height +import androidx.compose.foundation.layout.padding +import androidx.compose.runtime.Composable +import androidx.compose.runtime.LaunchedEffect +import androidx.compose.runtime.getValue +import androidx.compose.runtime.mutableFloatStateOf +import androidx.compose.runtime.mutableStateOf +import androidx.compose.runtime.remember +import androidx.compose.runtime.setValue +import androidx.compose.ui.Modifier +import androidx.compose.ui.geometry.Offset +import androidx.compose.ui.graphics.Color +import androidx.compose.ui.graphics.StrokeCap +import androidx.compose.ui.unit.dp +import androidx.tv.material3.MaterialTheme +import com.github.damontecres.dolphin.handleDPadKeyEvents +import com.github.damontecres.dolphin.ui.playback.ControllerViewState + +@Composable +fun SeekBarImpl( + progress: Float, + bufferedProgress: Float, + onSeek: (seekProgress: Float) -> Unit, + controllerViewState: ControllerViewState, + modifier: Modifier = Modifier, + intervals: Int = 10, + interactionSource: MutableInteractionSource = remember { MutableInteractionSource() }, + enabled: Boolean = true, +) { + val isFocused by interactionSource.collectIsFocusedAsState() + val color = MaterialTheme.colorScheme.border + val animatedIndicatorHeight by animateDpAsState( + targetValue = 6.dp.times((if (isFocused) 2f else 1f)), + ) + var hasSeeked by remember { mutableStateOf(false) } + var seekProgress by remember { mutableFloatStateOf(progress) } + val progressToUse = if (isFocused && hasSeeked) seekProgress else progress + LaunchedEffect(isFocused) { + if (!isFocused) hasSeeked = false + } + + val offset = 1f / intervals + + val handleSeekEventModifier = + Modifier.handleDPadKeyEvents( + onCenter = { + controllerViewState.pulseControls() + onSeek(seekProgress) + }, + onLeft = { + controllerViewState.pulseControls() + seekProgress = (progressToUse - offset).coerceAtLeast(0f) + hasSeeked = true + onSeek(seekProgress) + }, + onRight = { + controllerViewState.pulseControls() + seekProgress = (progressToUse + offset).coerceAtMost(1f) + hasSeeked = true + onSeek(seekProgress) + }, + ) + + Column( + modifier = modifier, + verticalArrangement = Arrangement.spacedBy(16.dp), + ) { + Canvas( + modifier = + Modifier + .fillMaxWidth() + .height(animatedIndicatorHeight) + .padding(horizontal = 4.dp) + .then(handleSeekEventModifier) + .focusable(enabled = enabled, interactionSource = interactionSource), + onDraw = { + val yOffset = size.height.div(2) + drawLine( + color = color.copy(alpha = 0.15f), + start = Offset(x = 0f, y = yOffset), + end = Offset(x = size.width, y = yOffset), + strokeWidth = size.height, + cap = StrokeCap.Round, + ) + drawLine( + color = color.copy(alpha = 0.50f), + start = Offset(x = 0f, y = yOffset), + end = + Offset( + x = size.width.times(bufferedProgress), + y = yOffset, + ), + strokeWidth = size.height, + cap = StrokeCap.Round, + ) + drawLine( + color = color, + start = Offset(x = 0f, y = yOffset), + end = + Offset( +// x = size.width.times(if (isSelected) seekProgress else progress), + x = size.width.times(progressToUse), + y = yOffset, + ), + strokeWidth = size.height, + cap = StrokeCap.Round, + ) + drawCircle( + color = Color.White, + radius = size.height + 2, + center = Offset(x = size.width.times(progressToUse), y = yOffset), + ) + }, + ) + } +} diff --git a/app/src/main/java/com/github/damontecres/dolphin/ui/playback/SeekBarState.kt b/app/src/main/java/com/github/damontecres/dolphin/ui/playback/SeekBarState.kt new file mode 100644 index 00000000..cf84a01c --- /dev/null +++ b/app/src/main/java/com/github/damontecres/dolphin/ui/playback/SeekBarState.kt @@ -0,0 +1,59 @@ +package com.github.damontecres.stashapp.ui.components.playback + +import androidx.compose.runtime.Composable +import androidx.compose.runtime.LaunchedEffect +import androidx.compose.runtime.getValue +import androidx.compose.runtime.mutableStateOf +import androidx.compose.runtime.remember +import androidx.compose.runtime.setValue +import androidx.media3.common.Player +import androidx.media3.common.listen +import androidx.media3.common.util.UnstableApi +import kotlinx.coroutines.CoroutineScope +import kotlinx.coroutines.Dispatchers +import kotlinx.coroutines.Job +import kotlinx.coroutines.delay +import kotlinx.coroutines.launch +import kotlinx.coroutines.withContext + +@UnstableApi +@Composable +fun rememberSeekBarState( + player: Player, + scope: CoroutineScope, +): SeekBarState { + val seekBarState = remember(player) { SeekBarState(player, scope) } + LaunchedEffect(player) { + seekBarState.observe() + } + return seekBarState +} + +@UnstableApi +class SeekBarState( + private val player: Player, + private val scope: CoroutineScope, +) { + var isEnabled by mutableStateOf(player.isCommandAvailable(Player.COMMAND_SEEK_FORWARD)) + private set + + private var job: Job? = null + + fun onValueChange(progress: Float) { + job?.cancel() + job = + scope.launch(Dispatchers.IO) { + delay(750L) + withContext(Dispatchers.Main) { + player.seekTo((player.duration * progress).toLong()) + } + } + } + + suspend fun observe(): Nothing = + player.listen { events -> + if (events.contains(Player.EVENT_AVAILABLE_COMMANDS_CHANGED)) { + isEnabled = isCommandAvailable(Player.COMMAND_SEEK_FORWARD) + } + } +} diff --git a/app/src/main/java/com/github/damontecres/dolphin/ui/playback/SkipIndicator.kt b/app/src/main/java/com/github/damontecres/dolphin/ui/playback/SkipIndicator.kt new file mode 100644 index 00000000..15f110f9 --- /dev/null +++ b/app/src/main/java/com/github/damontecres/dolphin/ui/playback/SkipIndicator.kt @@ -0,0 +1,67 @@ +package com.github.damontecres.stashapp.ui.components.playback + +import androidx.compose.animation.core.Animatable +import androidx.compose.animation.core.tween +import androidx.compose.foundation.Image +import androidx.compose.foundation.layout.Box +import androidx.compose.foundation.layout.fillMaxSize +import androidx.compose.foundation.layout.size +import androidx.compose.runtime.Composable +import androidx.compose.runtime.LaunchedEffect +import androidx.compose.runtime.getValue +import androidx.compose.runtime.mutableFloatStateOf +import androidx.compose.runtime.remember +import androidx.compose.runtime.setValue +import androidx.compose.ui.Alignment +import androidx.compose.ui.Modifier +import androidx.compose.ui.draw.rotate +import androidx.compose.ui.draw.scale +import androidx.compose.ui.res.painterResource +import androidx.compose.ui.unit.dp +import androidx.compose.ui.unit.sp +import androidx.tv.material3.MaterialTheme +import androidx.tv.material3.Text +import com.github.damontecres.dolphin.R +import com.github.damontecres.dolphin.ifElse +import kotlin.math.abs + +@Composable +fun SkipIndicator( + durationMs: Long, + onFinish: () -> Unit, + modifier: Modifier = Modifier, +) { + val backward = durationMs < 0 + var currentRotation by remember { mutableFloatStateOf(0f) } + val rotation = remember { Animatable(currentRotation) } + LaunchedEffect(durationMs, backward, onFinish) { + rotation.animateTo( + targetValue = currentRotation + if (backward) -270f else 270f, + animationSpec = + tween( + durationMillis = 800, + ), + ) { + currentRotation = value + } + onFinish() + } + + Box(modifier = modifier.size(55.dp, 55.dp)) { + Image( + modifier = + Modifier + .fillMaxSize() + .rotate(currentRotation) + .ifElse(backward, Modifier.scale(scaleX = -1f, scaleY = 1f)), + painter = painterResource(id = R.drawable.circular_arrow_right), + contentDescription = null, + ) + Text( + modifier = Modifier.align(Alignment.Center), + color = MaterialTheme.colorScheme.onBackground, + fontSize = 13.sp, + text = abs(durationMs / 1000).toString(), + ) + } +} diff --git a/app/src/main/java/com/github/damontecres/dolphin/ui/playback/TrackSupport.kt b/app/src/main/java/com/github/damontecres/dolphin/ui/playback/TrackSupport.kt new file mode 100644 index 00000000..282b0d06 --- /dev/null +++ b/app/src/main/java/com/github/damontecres/dolphin/ui/playback/TrackSupport.kt @@ -0,0 +1,147 @@ +package com.github.damontecres.dolphin.ui.playback + +import android.content.Context +import androidx.annotation.OptIn +import androidx.media3.common.C +import androidx.media3.common.Format +import androidx.media3.common.MimeTypes +import androidx.media3.common.Tracks +import androidx.media3.common.util.UnstableApi +import timber.log.Timber +import java.util.Locale + +data class TrackSupport( + val id: String?, + val type: TrackType, + val supported: TrackSupportReason, + val selected: Boolean, + val labels: List, + val codecs: String?, + val format: Format, +) { + @OptIn(UnstableApi::class) + fun displayString(context: Context): String = + if (labels.isNotEmpty()) { + labels.joinToString(", ") + } else { + val type = + when (codecs) { + MimeTypes.TEXT_VTT -> "vtt" + MimeTypes.APPLICATION_VOBSUB -> "vobsub" + MimeTypes.APPLICATION_SUBRIP -> "srt" + MimeTypes.TEXT_SSA -> "ssa" + MimeTypes.APPLICATION_PGS -> "pgs" + MimeTypes.APPLICATION_DVBSUBS -> "dvd" + MimeTypes.APPLICATION_TTML -> "ttml" + MimeTypes.TEXT_UNKNOWN -> "unknown" + null -> "unknown" + else -> { + val split = codecs.split("/") + if (split.size > 1) split[1] else codecs + } + } + val language = languageName(context, format.language) + "$language ($type)" + } +} + +enum class TrackSupportReason { + HANDLED, + EXCEEDS_CAPABILITIES, + UNSUPPORTED_DRM, + UNSUPPORTED_SUBTYPE, + UNSUPPORTED_TYPE, + UNKNOWN, + ; + + companion object { + @OptIn(UnstableApi::class) + fun fromInt( + @C.FormatSupport value: Int, + ): TrackSupportReason = + when (value) { + C.FORMAT_HANDLED -> HANDLED + C.FORMAT_EXCEEDS_CAPABILITIES -> EXCEEDS_CAPABILITIES + C.FORMAT_UNSUPPORTED_DRM -> UNSUPPORTED_DRM + C.FORMAT_UNSUPPORTED_SUBTYPE -> UNSUPPORTED_SUBTYPE + C.FORMAT_UNSUPPORTED_TYPE -> UNSUPPORTED_TYPE + else -> UNKNOWN + } + } +} + +enum class TrackType { + UNKNOWN, + DEFAULT, + AUDIO, + VIDEO, + TEXT, + IMAGE, + METADATA, + CAMERA_MOTION, + NONE, + ; + + companion object { + @OptIn(UnstableApi::class) + fun fromInt(value: Int): TrackType = + when (value) { + C.TRACK_TYPE_UNKNOWN -> UNKNOWN + C.TRACK_TYPE_DEFAULT -> DEFAULT + C.TRACK_TYPE_AUDIO -> AUDIO + C.TRACK_TYPE_VIDEO -> VIDEO + C.TRACK_TYPE_TEXT -> TEXT + C.TRACK_TYPE_IMAGE -> IMAGE + C.TRACK_TYPE_METADATA -> METADATA + C.TRACK_TYPE_CAMERA_MOTION -> CAMERA_MOTION + C.TRACK_TYPE_NONE -> NONE + else -> UNKNOWN + } + } +} + +@OptIn(UnstableApi::class) +fun checkForSupport(tracks: Tracks): List = + tracks.groups.flatMap { + buildList { + val type = TrackType.fromInt(it.type) + for (i in 0.. + + diff --git a/app/src/main/res/drawable/baseline_fast_rewind_24.xml b/app/src/main/res/drawable/baseline_fast_rewind_24.xml new file mode 100644 index 00000000..81f79b32 --- /dev/null +++ b/app/src/main/res/drawable/baseline_fast_rewind_24.xml @@ -0,0 +1,10 @@ + + + diff --git a/app/src/main/res/drawable/baseline_more_vert_96.xml b/app/src/main/res/drawable/baseline_more_vert_96.xml new file mode 100644 index 00000000..35a0b1d2 --- /dev/null +++ b/app/src/main/res/drawable/baseline_more_vert_96.xml @@ -0,0 +1,5 @@ + + + + + diff --git a/app/src/main/res/drawable/baseline_pause_24.xml b/app/src/main/res/drawable/baseline_pause_24.xml new file mode 100644 index 00000000..13d6d2ec --- /dev/null +++ b/app/src/main/res/drawable/baseline_pause_24.xml @@ -0,0 +1,10 @@ + + + diff --git a/app/src/main/res/drawable/baseline_play_arrow_24.xml b/app/src/main/res/drawable/baseline_play_arrow_24.xml new file mode 100644 index 00000000..13c137a9 --- /dev/null +++ b/app/src/main/res/drawable/baseline_play_arrow_24.xml @@ -0,0 +1,10 @@ + + + diff --git a/app/src/main/res/drawable/baseline_skip_next_24.xml b/app/src/main/res/drawable/baseline_skip_next_24.xml new file mode 100644 index 00000000..4fff2475 --- /dev/null +++ b/app/src/main/res/drawable/baseline_skip_next_24.xml @@ -0,0 +1,10 @@ + + + diff --git a/app/src/main/res/drawable/baseline_skip_previous_24.xml b/app/src/main/res/drawable/baseline_skip_previous_24.xml new file mode 100644 index 00000000..1805b7d1 --- /dev/null +++ b/app/src/main/res/drawable/baseline_skip_previous_24.xml @@ -0,0 +1,10 @@ + + + diff --git a/app/src/main/res/drawable/baseline_stop_24.xml b/app/src/main/res/drawable/baseline_stop_24.xml new file mode 100644 index 00000000..d099f1aa --- /dev/null +++ b/app/src/main/res/drawable/baseline_stop_24.xml @@ -0,0 +1,10 @@ + + + diff --git a/app/src/main/res/drawable/baseline_undo_24.xml b/app/src/main/res/drawable/baseline_undo_24.xml new file mode 100644 index 00000000..073aa3b7 --- /dev/null +++ b/app/src/main/res/drawable/baseline_undo_24.xml @@ -0,0 +1,5 @@ + + + + + diff --git a/app/src/main/res/drawable/captions_svgrepo_com.xml b/app/src/main/res/drawable/captions_svgrepo_com.xml new file mode 100644 index 00000000..59ed3842 --- /dev/null +++ b/app/src/main/res/drawable/captions_svgrepo_com.xml @@ -0,0 +1,7 @@ + + + + + + + diff --git a/app/src/main/res/drawable/circular_arrow_right.xml b/app/src/main/res/drawable/circular_arrow_right.xml new file mode 100644 index 00000000..0b178d84 --- /dev/null +++ b/app/src/main/res/drawable/circular_arrow_right.xml @@ -0,0 +1,10 @@ + + + + diff --git a/app/src/main/res/drawable/vector_settings.xml b/app/src/main/res/drawable/vector_settings.xml new file mode 100644 index 00000000..584de10c --- /dev/null +++ b/app/src/main/res/drawable/vector_settings.xml @@ -0,0 +1,5 @@ + + + diff --git a/app/src/main/res/font/fa_solid_900.ttf b/app/src/main/res/font/fa_solid_900.ttf new file mode 100644 index 0000000000000000000000000000000000000000..ec24749db906da77229dcecd61d37b6489d02140 GIT binary patch literal 419720 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
  • cz79Gn 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

    eQe!f9^EZa-f?l`)yEPE++Aqekb=! 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 literal 0 HcmV?d00001