Skip to content
Open
Show file tree
Hide file tree
Changes from all commits
Commits
File filter

Filter by extension

Filter by extension

Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
Original file line number Diff line number Diff line change
Expand Up @@ -95,8 +95,10 @@ public sealed interface PlaybackContent {
val fileType: PutioFileType,
) : PlaybackContent

/** [conversionStart] marks a refused request to start converting, not a failure to play. */
public data class Failed(
val failure: PlaybackFailure,
val conversionStart: Boolean = false,
) : PlaybackContent
}

Expand Down Expand Up @@ -463,12 +465,12 @@ private fun PlaybackState.resolveFailed(event: PlaybackEvent.ResolveFailed): Pla
if (!isLoading(event.requestId)) {
return PlaybackTransition(this, consumed = false)
}
val conversion = (content as? PlaybackContent.Conversion)
?.takeIf { it.readsStatus && event.failure.lostConnection }
val conversion = content as? PlaybackContent.Conversion
val statusRead = conversion?.takeIf { it.readsStatus && event.failure.lostConnection }
return PlaybackTransition(
copy(
content = conversion?.copy(refreshRequestId = null, statusCheckFailed = true)
?: PlaybackContent.Failed(event.failure),
content = statusRead?.copy(refreshRequestId = null, statusCheckFailed = true)
?: PlaybackContent.Failed(event.failure, conversionStart = conversion?.readsStatus == false),
),
)
}
Expand Down
Original file line number Diff line number Diff line change
@@ -0,0 +1,155 @@
package io.putdotio.android.playback

import androidx.media3.common.C
import androidx.media3.common.MediaItem
import androidx.media3.common.MimeTypes
import androidx.media3.common.PlaybackException
import androidx.media3.common.Player
import androidx.media3.common.TrackSelectionParameters
import androidx.media3.common.util.UnstableApi
import androidx.media3.datasource.HttpDataSource
import androidx.media3.exoplayer.ExoPlaybackException
import androidx.media3.exoplayer.hls.HlsManifest

public sealed interface PlaybackTrackRecoveryStep {
public data class DropSubtitles(
public val uris: Set<String>,
public val notify: Boolean,
) : PlaybackTrackRecoveryStep

public data class RestoreAudio(public val switch: PlaybackAudioSwitch) : PlaybackTrackRecoveryStep
}

public class PlaybackTrackFailure(
public val code: Int,
public val uri: String? = null,
public val audioRenderer: Boolean? = null,
)

@androidx.annotation.OptIn(markerClass = [UnstableApi::class])
public fun PlaybackException.toTrackFailure(): PlaybackTrackFailure =
PlaybackTrackFailure(
code = errorCode,
uri = (cause as? HttpDataSource.HttpDataSourceException)?.dataSpec?.uri?.toString(),
audioRenderer = (this as? ExoPlaybackException)
?.takeIf { it.type == ExoPlaybackException.TYPE_RENDERER }
?.rendererFormat?.sampleMimeType?.let(MimeTypes::isAudio),
)

public class PlaybackAudioSwitch(
public val parameters: TrackSelectionParameters,
public val selection: AudioSelection,
)

public class PlaybackTrackRecovery(
private val sidecarUris: () -> Set<String>,
private val manifestSubtitleUris: () -> Set<String> = { emptySet() },
) {
public constructor(
sidecarUris: Set<String>,
manifestSubtitleUris: () -> Set<String> = { emptySet() },
) : this({ sidecarUris }, manifestSubtitleUris)

private val failingSubtitles = mutableMapOf<String, Long>()
private var droppedAtMillis: Long? = null
private var droppedUris = emptySet<String>()
private var audioSwitch: PlaybackAudioSwitch? = null
private var audioSwitchedAtMillis = 0L

public fun loadFailed(
trackType: Int,
uri: String,
gaveUp: Boolean,
atMillis: Long,
): PlaybackTrackRecoveryStep.DropSubtitles? {
if (!isSubtitle(trackType, uri)) return null
forgetBefore(atMillis)
failingSubtitles[uri] = atMillis
return if (gaveUp) drop(atMillis) else null
}

public fun loadCompleted(uri: String) {
failingSubtitles -= uri
}

public fun audioSwitching(from: PlaybackAudioSwitch, atMillis: Long) {
audioSwitch = from
audioSwitchedAtMillis = atMillis
}

public fun audioPlaying() {
audioSwitch = null
}

public fun recover(failure: PlaybackTrackFailure, atMillis: Long): PlaybackTrackRecoveryStep? {
val switch = audioSwitch?.takeIf { atMillis - audioSwitchedAtMillis <= TRACK_FAILURE_WINDOW_MILLIS }
forgetBefore(atMillis)
val justDropped = droppedAtMillis?.let { atMillis - it <= TRACK_FAILURE_WINDOW_MILLIS } == true
val dropped = droppedUris.takeIf { justDropped }.orEmpty()
droppedAtMillis = null
droppedUris = emptySet()
val subtitleLoad = failure.uri
?.let { it in failingSubtitles || it in dropped || isSubtitle(C.TRACK_TYPE_UNKNOWN, it) } != false
return when {
switch != null && failure.code in AUDIO_FAILURES && failure.audioRenderer != false -> {
audioSwitch = null
PlaybackTrackRecoveryStep.RestoreAudio(switch)
}
failure.code in LOAD_FAILURES && subtitleLoad && (failingSubtitles.isNotEmpty() || justDropped) ->
drop(atMillis = null)
else -> null
}
}

private fun drop(atMillis: Long?): PlaybackTrackRecoveryStep.DropSubtitles {
val step = PlaybackTrackRecoveryStep.DropSubtitles(
uris = failingSubtitles.keys intersect sidecarUris(),
notify = failingSubtitles.isNotEmpty(),
)
droppedUris = failingSubtitles.keys.toSet()
failingSubtitles.clear()
droppedAtMillis = atMillis
return step
}

private fun forgetBefore(atMillis: Long) {
failingSubtitles.values.removeAll { atMillis - it > TRACK_FAILURE_WINDOW_MILLIS }
}

private fun isSubtitle(trackType: Int, uri: String): Boolean =
trackType == C.TRACK_TYPE_TEXT || uri in sidecarUris() || uri in manifestSubtitleUris()
}

@androidx.annotation.OptIn(markerClass = [UnstableApi::class])
public fun TrackSelectionParameters.withAudioOf(before: TrackSelectionParameters): TrackSelectionParameters {
val builder = buildUpon()
.clearOverridesOfType(C.TRACK_TYPE_AUDIO)
.setTrackTypeDisabled(C.TRACK_TYPE_AUDIO, C.TRACK_TYPE_AUDIO in before.disabledTrackTypes)
before.overrides.values.filter { it.type == C.TRACK_TYPE_AUDIO }.forEach(builder::addOverride)
return builder.build()
}

@androidx.annotation.OptIn(markerClass = [UnstableApi::class])
public fun Player.manifestSubtitleUris(): Set<String> =
(currentManifest as? HlsManifest)?.multivariantPlaylist?.subtitles.orEmpty().map { it.url.toString() }.toSet()

public fun MediaItem.sidecarSubtitleUris(): Set<String> =
localConfiguration?.subtitleConfigurations.orEmpty().map { it.uri.toString() }.toSet()

public fun Player.continueWithout(step: PlaybackTrackRecoveryStep.DropSubtitles) {
val positionMillis = currentPosition.coerceAtLeast(0L)
trackSelectionParameters = trackSelectionParameters.withSubtitleSelection(SubtitleSelection.Off, emptyList())
val item = currentMediaItem
if (step.uris.isNotEmpty() && item != null) {
val kept = item.localConfiguration?.subtitleConfigurations.orEmpty()
.filterNot { it.uri.toString() in step.uris }
setMediaItem(item.buildUpon().setSubtitleConfigurations(kept).build(), positionMillis)
}
prepare()
}

private const val TRACK_FAILURE_WINDOW_MILLIS = 10_000L
private val LOAD_FAILURES =
PlaybackException.ERROR_CODE_IO_UNSPECIFIED until PlaybackException.ERROR_CODE_DECODER_INIT_FAILED
private val AUDIO_FAILURES =
PlaybackException.ERROR_CODE_DECODER_INIT_FAILED until PlaybackException.ERROR_CODE_DRM_UNSPECIFIED
Original file line number Diff line number Diff line change
Expand Up @@ -249,6 +249,22 @@ class PlaybackConversionReducerTest {
assertEquals(PlaybackContent.Failed(failure), failed.state.content)
}

@Test
fun aRefusedConversionStartFailsAsAConversionStartAndAStatusReadDoesNot() {
val failure = PlaybackFailure.Putio(PutioFailure.ServerUnavailable(503, PutioConfigurationException("down")))
val opening = conversion(PlaybackConversionState.NotAvailable)
val again = PlaybackReducer.reduce(conversion(PlaybackConversionState.Failed), PlaybackEvent.StartConversion)
assertEquals(PlaybackEffect.StartConversion(Target, PlaybackRequestId(2L)), again.effect)
listOf(opening, again.state).forEach { starting ->
val failed = PlaybackReducer.reduce(starting, PlaybackEvent.ResolveFailed(PlaybackRequestId(2L), failure))
assertEquals(PlaybackContent.Failed(failure, conversionStart = true), failed.state.content)
}

val read = PlaybackReducer.reduce(conversion(PlaybackConversionState.Queued), PlaybackEvent.RefreshConversion)
val readFailed = PlaybackReducer.reduce(read.state, PlaybackEvent.ResolveFailed(PlaybackRequestId(2L), failure))
assertEquals(PlaybackContent.Failed(failure, conversionStart = false), readFailed.state.content)
}

private fun conversion(state: PlaybackConversionState): PlaybackState =
PlaybackReducer.reduce(
PlaybackReducer.start(Target).state,
Expand Down
Loading