package tv.tivilux.nativeplayer.ui.components import android.net.Uri import androidx.media3.common.MediaItem import androidx.media3.common.util.UnstableApi import androidx.media3.datasource.DataSource import androidx.media3.datasource.DataSpec import androidx.media3.datasource.TransferListener import androidx.media3.exoplayer.drm.DrmSessionManagerProvider import androidx.media3.exoplayer.source.DefaultMediaSourceFactory import androidx.media3.exoplayer.source.MediaSource import androidx.media3.exoplayer.upstream.LoadErrorHandlingPolicy import tv.tivilux.nativeplayer.data.LiveStreamTrace /** Same configured HTTP factory; a fixed trace session follows every request of one MediaSource. */ @androidx.annotation.OptIn(UnstableApi::class) internal class DiagnosticMediaSourceFactory( private val upstream: DataSource.Factory, ) : MediaSource.Factory { private val normal = DefaultMediaSourceFactory(upstream) private var drm: DrmSessionManagerProvider? = null private var errors: LoadErrorHandlingPolicy? = null override fun setDrmSessionManagerProvider(provider: DrmSessionManagerProvider): MediaSource.Factory { drm = provider normal.setDrmSessionManagerProvider(provider) return this } override fun setLoadErrorHandlingPolicy(policy: LoadErrorHandlingPolicy): MediaSource.Factory { errors = policy normal.setLoadErrorHandlingPolicy(policy) return this } override fun getSupportedTypes(): IntArray = normal.supportedTypes override fun createMediaSource(mediaItem: MediaItem): MediaSource { val session = LiveStreamTrace.find(mediaItem.mediaId) ?: return normal.createMediaSource(mediaItem) val traced = DataSource.Factory { DiagnosticDataSource(upstream.createDataSource(), session) } val factory = DefaultMediaSourceFactory(traced) drm?.let { factory.setDrmSessionManagerProvider(it) } errors?.let { factory.setLoadErrorHandlingPolicy(it) } return factory.createMediaSource(mediaItem) } } @androidx.annotation.OptIn(UnstableApi::class) private class DiagnosticDataSource( private val upstream: DataSource, private val session: LiveStreamTrace.Session, ) : DataSource { private var request: LiveStreamTrace.Request? = null override fun addTransferListener(transferListener: TransferListener) = upstream.addTransferListener(transferListener) override fun getUri(): Uri? = upstream.uri override fun getResponseHeaders(): Map> = upstream.responseHeaders override fun open(dataSpec: DataSpec): Long { // Only the resource kind is retained. Never record paths, tokens, redirects or headers. val path = dataSpec.uri.path.orEmpty() val kind = when { path.endsWith(".m3u8", true) -> "PLAYLIST" path.endsWith(".ts", true) -> "TS_RESOURCE" path.endsWith(".m4s", true) -> "SEGMENT" else -> "RESOURCE" } request = session.open(kind) return try { upstream.open(dataSpec).also { request?.opened() } } catch (e: Exception) { request?.error("OPEN") throw e } } override fun read(buffer: ByteArray, offset: Int, length: Int): Int = try { upstream.read(buffer, offset, length).also { request?.read(it) } } catch (e: Exception) { request?.error("READ") throw e } override fun close() { val closing = request closing?.closing() var success = false try { upstream.close() success = true } finally { closing?.closed(success) request = null } } }