Files
AudioManagerClient/composeApp/src/desktopMain/kotlin/win/taptap/musicmanager/client/DesktopAudioPlayer.kt
T
TapTap 43bd9629d3
CI / build (push) Successful in 2m1s
fix: harden playback, sync, downloads and mood state
Playback:
- Persist the playhead in the playback snapshot and resume from it; restored
  longform progress is no longer overwritten with 0 on first play.
- Previous compares elapsed playtime since the track start, so resuming at
  1:00:00 and pressing previous goes back instead of restarting the book.
- Auto-advance no longer overwrites completed=true with false, longform PUTs
  are serialized, and playing rows/search results resume saved positions.
- Pause cancels the 400 ms poll; seek errors are reported instead of crashing.

Sync and state:
- First-sync snapshots keep the first page revision; cached revisions are only
  trusted for the same server/user.
- Refresh re-reads /me, merges local and server longform progress by timestamp,
  replays newer local positions, and keeps cached longform after deltas.
- Logout cancels refresh jobs, suppresses late progress writes, clears after
  playback teardown, and closes the HTTP client on release.
- Failed/racing mood opens clear the previous mood; stale responses cannot
  replace a newer selection. Mood drafts survive background refreshes.

Downloads and storage:
- Stream downloads to a .part file and atomically rename on Android/desktop,
  with a download-specific timeout and no whole-file buffering.
- Cache writes are best-effort and atomic; blocked/full web storage no longer
  leaves the app on the splash screen or blocks playback.
- Artwork failures do not fail audio downloads; failed downloads refresh the
  download index.
- Android queues sleep-timer commands before the controller connects.

UI:
- Music search is wired, debounced and kept separate from mood search.
- Player bar respects navigation-bar insets and hides music-only mood actions
  for longform. Mood gradient handles Int.MIN_VALUE.
2026-11-15 18:18:30 +00:00

238 lines
7.9 KiB
Kotlin

package win.taptap.musicmanager.client
import java.io.BufferedInputStream
import java.io.File
import java.io.FileInputStream
import java.io.InputStream
import java.net.URI
import javax.sound.sampled.AudioFormat
import javax.sound.sampled.AudioInputStream
import javax.sound.sampled.AudioSystem
import javax.sound.sampled.SourceDataLine
import kotlin.concurrent.thread
import win.taptap.musicmanager.client.api.Song
import win.taptap.musicmanager.client.playback.AudioPlayer
/**
* Desktop playback through the MP3SPI decoder and a PCM line. Pause/resume is a
* decoder loop gate, so no audio device is reopened.
*
* Seeking restarts the decoder at the requested position. Remote streams ask
* the server to transcode from that offset (`timeOffset`); local files skip the
* decoded PCM frames. Both keep the reported position aligned with the song.
*
* Java Sound cannot open a line for the compressed MP3 format itself; the
* decoded stream has to be converted to PCM_SIGNED first. Opening the encoded
* format fails with "No line matching interface SourceDataLine supporting
* format MPEG1L3 ...".
*/
class DesktopAudioPlayer : AudioPlayer {
private var input: InputStream? = null
private var stream: AudioInputStream? = null
private var line: SourceDataLine? = null
private var worker: Thread? = null
private val lock = Object()
private var currentSource: String? = null
private var currentSong: Song? = null
private var currentLocal = false
private var currentArtwork: String? = null
@Volatile private var paused = false
@Volatile private var stopped = false
@Volatile private var finished = false
@Volatile private var framesRead = 0L
@Volatile private var baseSeconds = 0.0
private var frameSize = 4
private var frameRate = 44_100f
private var duration = 0.0
override fun play(
source: String,
song: Song,
local: Boolean,
artworkUri: String?,
artworkBytes: ByteArray?,
) {
currentSource = source
currentSong = song
currentLocal = local
currentArtwork = artworkUri
start(source, song, local, startAtSeconds = 0.0)
}
private fun start(source: String, song: Song, local: Boolean, startAtSeconds: Double) {
stop()
finished = false
paused = false
stopped = false
framesRead = 0
baseSeconds = startAtSeconds.coerceAtLeast(0.0)
duration = song.duration.toDouble()
val requestSource = if (!local && startAtSeconds > 0) {
withTimeOffset(source, startAtSeconds)
} else {
source
}
val raw = if (local) {
FileInputStream(File(requestSource))
} else {
val connection = URI(requestSource).toURL().openConnection()
connection.connectTimeout = 15_000
connection.readTimeout = 30_000
connection.getInputStream()
}
val buffered = BufferedInputStream(raw, 128 * 1024)
input = buffered
val encoded = AudioSystem.getAudioInputStream(buffered)
val audio = decodeToPcm(encoded)
stream = audio
frameSize = audio.format.frameSize.takeIf { it > 0 } ?: 4
frameRate = audio.format.frameRate.takeIf { it > 0 } ?: 44_100f
// A remote stream already starts at the whole-second offset; local
// files and the fractional part are skipped in the decoded PCM.
val skipSeconds = if (local) startAtSeconds else startAtSeconds - kotlin.math.floor(startAtSeconds)
if (skipSeconds > 0) {
skipPcm(audio, skipSeconds)
}
val info = javax.sound.sampled.DataLine.Info(SourceDataLine::class.java, audio.format)
val dataLine = AudioSystem.getLine(info) as SourceDataLine
dataLine.open(audio.format)
dataLine.start()
line = dataLine
worker = thread(isDaemon = true, name = "audiomanager-player") {
val buffer = ByteArray(16 * 1024)
try {
while (!stopped) {
synchronized(lock) {
while (paused && !stopped) lock.wait()
}
if (stopped) break
val read = audio.read(buffer)
if (read < 0) {
finished = true
break
}
dataLine.write(buffer, 0, read)
framesRead += read.toLong()
}
dataLine.drain()
} catch (_: Throwable) {
// Stopping closes the stream; that is expected.
} finally {
runCatching { dataLine.close() }
runCatching { audio.close() }
runCatching { buffered.close() }
}
}
}
private fun skipPcm(audio: AudioInputStream, seconds: Double) {
var remaining = (seconds * frameRate * frameSize).toLong().coerceAtLeast(0L)
val buffer = ByteArray(16 * 1024)
while (remaining > 0 && !stopped) {
val skipped = runCatching { audio.skip(remaining) }.getOrDefault(0L)
if (skipped > 0) {
remaining -= skipped
} else {
val read = runCatching {
audio.read(buffer, 0, minOf(buffer.size.toLong(), remaining).toInt())
}.getOrDefault(-1)
if (read <= 0) break
remaining -= read
}
}
}
override fun pause() {
paused = true
}
override fun resume() {
synchronized(lock) {
paused = false
lock.notifyAll()
}
}
override fun stop() {
stopped = true
paused = false
synchronized(lock) { lock.notifyAll() }
runCatching { line?.stop() }
runCatching { line?.flush() }
worker?.interrupt()
runCatching { worker?.join(400) }
runCatching { stream?.close() }
runCatching { input?.close() }
line = null
stream = null
input = null
worker = null
}
override fun isPlaying(): Boolean =
!paused && !finished && worker?.isAlive == true
override fun isFinished(): Boolean = finished
override fun positionSeconds(): Double {
val seconds = baseSeconds + framesRead.toDouble() / frameSize / frameRate
return seconds.coerceIn(0.0, duration.takeIf { it > 0 } ?: seconds)
}
override fun durationSeconds(): Double = duration
override val canSeek: Boolean = true
override fun seekTo(seconds: Double) {
val source = currentSource ?: return
val song = currentSong ?: return
val wasPaused = paused
start(source, song, currentLocal, seconds.coerceAtLeast(0.0))
if (wasPaused) pause()
}
override fun release() {
stop()
}
/** Adds the server's `timeOffset` parameter, replacing an earlier one. */
private fun withTimeOffset(source: String, seconds: Double): String {
val cleaned = source.replace(Regex("[?&]timeOffset=\\d+"), "")
val separator = if (cleaned.contains('?')) "&" else "?"
return "$cleaned${separator}timeOffset=${seconds.toInt()}"
}
}
/**
* MP3SPI hands back a stream whose format is the compressed MPEG one. The audio
* device only understands uncompressed PCM, so convert to 16-bit signed PCM at
* the source sample rate before opening the line.
*/
internal fun decodeToPcm(encoded: AudioInputStream): AudioInputStream {
val pcm = encoded.format.toPcmFormat()
if (encoded.format.encoding == AudioFormat.Encoding.PCM_SIGNED) return encoded
return AudioSystem.getAudioInputStream(pcm, encoded)
}
internal fun AudioFormat.toPcmFormat(): AudioFormat {
val rate = sampleRate.takeIf { it > 0 } ?: 44_100f
val channelCount = channels.takeIf { it > 0 } ?: 2
return AudioFormat(
AudioFormat.Encoding.PCM_SIGNED,
rate,
16,
channelCount,
channelCount * 2,
rate,
false,
)
}