react-native-nitro-player 1.6.0 → 1.7.0-alpha.0

package/android/src/main/java/com/margelo/nitro/nitroplayer/download/DownloadManagerCore.kt

@@ -7,6 +7,7 @@ import android.util.Log
 import androidx.work.*
 import com.margelo.nitro.core.NullType
 import com.margelo.nitro.nitroplayer.*
+import com.margelo.nitro.nitroplayer.core.ListenerRegistry
 import com.margelo.nitro.nitroplayer.core.NitroPlayerLogger
 import java.util.*
 import java.util.concurrent.ConcurrentHashMap
@@ -52,10 +53,11 @@ class DownloadManagerCore private constructor(
     private val trackMetadata = ConcurrentHashMap<String, TrackItem>()
     private val playlistAssociations = ConcurrentHashMap<String, String>()
 
-    // Callbacks
-    private val progressCallbacks = CopyOnWriteArrayList<(DownloadProgress) -> Unit>()
-    private val stateChangeCallbacks = CopyOnWriteArrayList<(String, String, DownloadState, DownloadError?) -> Unit>()
-    private val completeCallbacks = CopyOnWriteArrayList<(DownloadedTrack) -> Unit>()
+    // Callbacks — ListenerRegistry so HybridDownloadManager.dispose can remove
+    // them instead of leaking closures into dead JS runtimes across reloads
+    private val progressCallbacks = ListenerRegistry<(DownloadProgress) -> Unit>()
+    private val stateChangeCallbacks = ListenerRegistry<(String, String, DownloadState, DownloadError?) -> Unit>()
+    private val completeCallbacks = ListenerRegistry<(DownloadedTrack) -> Unit>()
 
     private val mainHandler = Handler(Looper.getMainLooper())
     private val database = DownloadDatabase.getInstance(context)
@@ -98,7 +100,34 @@ class DownloadManagerCore private constructor(
             )
         activeTasks[downloadId] = metadata
 
-        // Create WorkManager request
+        // Gate on maxConcurrentDownloads — excess requests wait in FIFO order
+        synchronized(launchGate) {
+            if (runningDownloads.size >= maxConcurrent()) {
+                pendingLaunchQueue.add(downloadId)
+            } else {
+                runningDownloads.add(downloadId)
+                enqueueDownloadWork(downloadId, track, playlistId)
+            }
+        }
+
+        // Update state
+        activeTasks[downloadId]?.state = DownloadState.PENDING
+        notifyStateChange(downloadId, track.id, DownloadState.PENDING, null)
+
+        return downloadId
+    }
+
+    private val launchGate = Any()
+    private val pendingLaunchQueue = ArrayDeque<String>()
+    private val runningDownloads = mutableSetOf<String>()
+
+    private fun maxConcurrent(): Int = (config.maxConcurrentDownloads?.toInt() ?: 3).coerceAtLeast(1)
+
+    private fun enqueueDownloadWork(
+        downloadId: String,
+        track: TrackItem,
+        playlistId: String?,
+    ) {
         val constraints =
             Constraints
                 .Builder()
@@ -115,6 +144,7 @@ class DownloadManagerCore private constructor(
                 DownloadWorker.KEY_URL to track.url,
                 DownloadWorker.KEY_PLAYLIST_ID to (playlistId ?: ""),
                 DownloadWorker.KEY_STORAGE_LOCATION to (config.storageLocation?.name ?: StorageLocation.PRIVATE.name),
+                DownloadWorker.KEY_TRACK_JSON to TrackItemJson.toJson(track),
             )
 
         val downloadRequest =
@@ -125,13 +155,25 @@ class DownloadManagerCore private constructor(
                 .addTag("track_${track.id}")
                 .build()
 
-        workManager.enqueue(downloadRequest)
-
-        // Update state
-        activeTasks[downloadId]?.state = DownloadState.PENDING
-        notifyStateChange(downloadId, track.id, DownloadState.PENDING, null)
+        workManager.enqueueUniqueWork("download_$downloadId", ExistingWorkPolicy.KEEP, downloadRequest)
+    }
 
-        return downloadId
+    // Frees this download's concurrency slot and launches the next queued one
+    private fun releaseDownloadSlot(downloadId: String) {
+        var next: String? = null
+        synchronized(launchGate) {
+            runningDownloads.remove(downloadId)
+            pendingLaunchQueue.remove(downloadId)
+            if (runningDownloads.size < maxConcurrent()) {
+                next = pendingLaunchQueue.removeFirstOrNull()
+                next?.let { runningDownloads.add(it) }
+            }
+        }
+        next?.let { nextId ->
+            val meta = activeTasks[nextId] ?: return
+            val track = trackMetadata[meta.trackId] ?: return
+            enqueueDownloadWork(nextId, track, playlistAssociations[nextId])
+        }
     }
 
     fun downloadPlaylist(
@@ -150,6 +192,7 @@ class DownloadManagerCore private constructor(
             metadata.state = DownloadState.PAUSED
             notifyStateChange(downloadId, metadata.trackId, DownloadState.PAUSED, null)
         }
+        releaseDownloadSlot(downloadId)
     }
 
     fun resumeDownload(downloadId: String) {
@@ -157,34 +200,16 @@ class DownloadManagerCore private constructor(
             val track = trackMetadata[metadata.trackId] ?: return
             val playlistId = playlistAssociations[downloadId]
 
-            // Re-create work request
-            val constraints =
-                Constraints
-                    .Builder()
-                    .setRequiredNetworkType(
-                        if (config.wifiOnlyDownloads == true) NetworkType.UNMETERED else NetworkType.CONNECTED,
-                    ).setRequiresStorageNotLow(true)
-                    .build()
-
-            val inputData =
-                workDataOf(
-                    DownloadWorker.KEY_DOWNLOAD_ID to downloadId,
-                    DownloadWorker.KEY_TRACK_ID to track.id,
-                    DownloadWorker.KEY_TRACK_TITLE to track.title,
-                    DownloadWorker.KEY_URL to track.url,
-                    DownloadWorker.KEY_PLAYLIST_ID to (playlistId ?: ""),
-                    DownloadWorker.KEY_STORAGE_LOCATION to (config.storageLocation?.name ?: StorageLocation.PRIVATE.name),
-                )
-
-            val downloadRequest =
-                OneTimeWorkRequestBuilder<DownloadWorker>()
-                    .setConstraints(constraints)
-                    .setInputData(inputData)
-                    .addTag("download_$downloadId")
-                    .addTag("track_${track.id}")
-                    .build()
-
-            workManager.enqueue(downloadRequest)
+            synchronized(launchGate) {
+                if (runningDownloads.size >= maxConcurrent() && downloadId !in runningDownloads) {
+                    pendingLaunchQueue.add(downloadId)
+                    metadata.state = DownloadState.PENDING
+                    notifyStateChange(downloadId, metadata.trackId, DownloadState.PENDING, null)
+                    return
+                }
+                runningDownloads.add(downloadId)
+            }
+            enqueueDownloadWork(downloadId, track, playlistId)
 
             metadata.state = DownloadState.DOWNLOADING
             notifyStateChange(downloadId, metadata.trackId, DownloadState.DOWNLOADING, null)
@@ -197,7 +222,13 @@ class DownloadManagerCore private constructor(
             metadata.state = DownloadState.CANCELLED
             notifyStateChange(downloadId, metadata.trackId, DownloadState.CANCELLED, null)
             activeTasks.remove(downloadId)
+            // Drop the partial file (pause keeps it for Range resume), but never
+            // a previously completed download's file
+            if (!database.isTrackDownloaded(metadata.trackId)) {
+                fileManager.getLocalPath(metadata.trackId)?.let { fileManager.deleteFile(it) }
+            }
         }
+        releaseDownloadSlot(downloadId)
     }
 
     fun retryDownload(downloadId: String) {
@@ -256,7 +287,7 @@ class DownloadManagerCore private constructor(
             downloadedBytes += m.bytesDownloaded
         }
 
-        val completedCount = database.getAllDownloadedTracks().size
+        val completedCount = database.countDownloadedTracks()
 
         return DownloadQueueStatus(
             pendingCount = pendingCount.toDouble(),
@@ -331,17 +362,17 @@ class DownloadManagerCore private constructor(
         }
 
     // Callbacks
-    fun addProgressCallback(callback: (DownloadProgress) -> Unit) {
-        progressCallbacks.add(callback)
-    }
+    fun addProgressCallback(callback: (DownloadProgress) -> Unit): Long = progressCallbacks.add(callback)
 
-    fun addStateChangeCallback(callback: (String, String, DownloadState, DownloadError?) -> Unit) {
-        stateChangeCallbacks.add(callback)
-    }
+    fun removeProgressCallback(id: Long): Boolean = progressCallbacks.remove(id)
 
-    fun addCompleteCallback(callback: (DownloadedTrack) -> Unit) {
-        completeCallbacks.add(callback)
-    }
+    fun addStateChangeCallback(callback: (String, String, DownloadState, DownloadError?) -> Unit): Long = stateChangeCallbacks.add(callback)
+
+    fun removeStateChangeCallback(id: Long): Boolean = stateChangeCallbacks.remove(id)
+
+    fun addCompleteCallback(callback: (DownloadedTrack) -> Unit): Long = completeCallbacks.add(callback)
+
+    fun removeCompleteCallback(id: Long): Boolean = completeCallbacks.remove(id)
 
     // Internal callbacks from DownloadWorker
     internal fun onProgress(
@@ -375,8 +406,11 @@ class DownloadManagerCore private constructor(
         downloadId: String,
         trackId: String,
         localPath: String,
+        fallbackTrack: TrackItem? = null,
     ) {
-        val track = trackMetadata[trackId] ?: return
+        // fallbackTrack comes from the worker's persisted inputData — the
+        // in-memory maps are empty when the worker completes in a fresh process.
+        val track = trackMetadata[trackId] ?: fallbackTrack ?: return
         val playlistId = playlistAssociations[downloadId]
         val storageLocation = config.storageLocation ?: StorageLocation.PRIVATE
         val fileSize = fileManager.getFileSize(localPath)
@@ -399,6 +433,7 @@ class DownloadManagerCore private constructor(
             metadata.completedAt = System.currentTimeMillis().toDouble()
         }
         activeTasks.remove(downloadId)
+        releaseDownloadSlot(downloadId)
 
         notifyStateChange(downloadId, trackId, DownloadState.COMPLETED, null)
 
@@ -407,26 +442,31 @@ class DownloadManagerCore private constructor(
         }
     }
 
+    // Retries are owned by WorkManager (Result.retry in DownloadWorker); this
+    // only records state so a second, competing worker is never scheduled here.
     internal fun onError(
         downloadId: String,
         trackId: String,
         error: DownloadError,
+        willRetry: Boolean = false,
     ) {
         activeTasks[downloadId]?.let { metadata ->
-            metadata.state = DownloadState.FAILED
             metadata.error = error
 
-            // Auto-retry if enabled
-            if (config.autoRetry == true && error.isRetryable && metadata.retryCount < (config.maxRetryAttempts?.toInt() ?: 3)) {
-                mainHandler.postDelayed({
-                    retryDownload(downloadId)
-                }, 2000)
+            if (willRetry) {
+                metadata.retryCount++
+                metadata.state = DownloadState.PENDING
             } else {
+                metadata.state = DownloadState.FAILED
                 notifyStateChange(downloadId, trackId, DownloadState.FAILED, error)
+                releaseDownloadSlot(downloadId)
             }
         }
     }
 
+    internal fun maxWorkerRetryAttempts(): Int =
+        if (config.autoRetry == true) (config.maxRetryAttempts?.toInt() ?: 3) else 0
+
     private fun notifyStateChange(
         downloadId: String,
         trackId: String,

package/android/src/main/java/com/margelo/nitro/nitroplayer/download/DownloadWorker.kt

@@ -10,11 +10,14 @@ import androidx.work.CoroutineWorker
 import androidx.work.ForegroundInfo
 import androidx.work.WorkerParameters
 import com.margelo.nitro.nitroplayer.*
+import kotlinx.coroutines.CancellationException
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.TimeoutCancellationException
+import kotlinx.coroutines.ensureActive
 import kotlinx.coroutines.withContext
 import kotlinx.coroutines.withTimeout
 import java.io.BufferedInputStream
+import java.io.File
 import java.io.FileOutputStream
 import java.net.HttpURLConnection
 import java.net.URL
@@ -33,6 +36,7 @@ class DownloadWorker(
         const val KEY_URL = "url"
         const val KEY_PLAYLIST_ID = "playlist_id"
         const val KEY_STORAGE_LOCATION = "storage_location"
+        const val KEY_TRACK_JSON = "track_json"
 
         private const val NOTIFICATION_CHANNEL_ID = "nitro_player_downloads"
         private const val BASE_NOTIFICATION_ID = 2001
@@ -63,7 +67,7 @@ class DownloadWorker(
             val urlString = inputData.getString(KEY_URL) ?: return@withContext Result.failure()
             val storageLocationStr = inputData.getString(KEY_STORAGE_LOCATION) ?: StorageLocation.PRIVATE.name
 
-            notificationId = BASE_NOTIFICATION_ID + trackId.hashCode().and(0xFFFF)
+            notificationId = BASE_NOTIFICATION_ID + trackId.hashCode().and(0x7FFFFF)
 
             val storageLocation =
                 try {
@@ -90,7 +94,8 @@ class DownloadWorker(
                     }
 
                 if (localPath != null) {
-                    downloadManager.onComplete(downloadId, trackId, localPath)
+                    val fallbackTrack = inputData.getString(KEY_TRACK_JSON)?.let { TrackItemJson.fromJson(it) }
+                    downloadManager.onComplete(downloadId, trackId, localPath, fallbackTrack)
                     showCompletionNotification(trackTitle)
                     Result.success()
                 } else {
@@ -101,9 +106,7 @@ class DownloadWorker(
                             reason = DownloadErrorReason.UNKNOWN,
                             isRetryable = true,
                         )
-                    downloadManager.onError(downloadId, trackId, error)
-                    showErrorNotification(trackTitle)
-                    Result.retry()
+                    handleError(downloadId, trackId, trackTitle, error)
                 }
             } catch (e: TimeoutCancellationException) {
                 val error =
@@ -113,9 +116,11 @@ class DownloadWorker(
                         reason = DownloadErrorReason.TIMEOUT,
                         isRetryable = true,
                     )
-                downloadManager.onError(downloadId, trackId, error)
-                showErrorNotification(trackTitle)
-                Result.retry()
+                handleError(downloadId, trackId, trackTitle, error)
+            } catch (e: CancellationException) {
+                // Worker stopped (pause/cancel) — state was already set by the
+                // manager; don't overwrite it with FAILED.
+                throw e
             } catch (e: Exception) {
                 val errorReason =
                     when {
@@ -132,17 +137,24 @@ class DownloadWorker(
                         reason = errorReason,
                         isRetryable = errorReason in listOf(DownloadErrorReason.NETWORK_ERROR, DownloadErrorReason.TIMEOUT),
                     )
-                downloadManager.onError(downloadId, trackId, error)
-                showErrorNotification(trackTitle)
-
-                if (error.isRetryable) {
-                    Result.retry()
-                } else {
-                    Result.failure()
-                }
+                handleError(downloadId, trackId, trackTitle, error)
             }
         }
 
+    // Single retry owner: WorkManager reschedules via Result.retry(); the manager
+    // only records state, never enqueues a competing request.
+    private fun handleError(
+        downloadId: String,
+        trackId: String,
+        trackTitle: String,
+        error: DownloadError,
+    ): Result {
+        val willRetry = error.isRetryable && runAttemptCount < downloadManager.maxWorkerRetryAttempts()
+        downloadManager.onError(downloadId, trackId, error, willRetry)
+        showErrorNotification(trackTitle)
+        return if (willRetry) Result.retry() else Result.failure()
+    }
+
     private suspend fun downloadFile(
         downloadId: String,
         trackId: String,
@@ -154,18 +166,31 @@ class DownloadWorker(
             var connection: HttpURLConnection? = null
             var inputStream: BufferedInputStream? = null
             var outputStream: FileOutputStream? = null
+            var destinationFile: File? = null
 
             try {
+                val partialPath = fileManager.getLocalPath(trackId)
+                val existingBytes = partialPath?.let { File(it).length() } ?: 0L
+
                 val url = URL(urlString)
                 connection = url.openConnection() as HttpURLConnection
                 connection.connectTimeout = 30000
                 connection.readTimeout = 30000
+                if (existingBytes > 0) {
+                    connection.setRequestProperty("Range", "bytes=$existingBytes-")
+                }
                 connection.connect()
 
                 val responseCode = connection.responseCode
-                if (responseCode != HttpURLConnection.HTTP_OK) {
+                if (responseCode == 416) {
+                    // Partial file is at or past the server's length — start clean next attempt
+                    partialPath?.let { File(it).delete() }
+                    throw Exception("Server returned HTTP 416 for resume, restarting download")
+                }
+                if (responseCode != HttpURLConnection.HTTP_OK && responseCode != HttpURLConnection.HTTP_PARTIAL) {
                     throw Exception("Server returned HTTP $responseCode")
                 }
+                val resuming = responseCode == HttpURLConnection.HTTP_PARTIAL && existingBytes > 0 && partialPath != null
                 // Determine extension
                 var extension = MimeTypeMap.getFileExtensionFromUrl(urlString)
 
@@ -192,20 +217,31 @@ class DownloadWorker(
 
                 val finalExtension = if (extension.isNullOrEmpty()) "mp3" else extension
 
-                // Create destination file
-                val destinationFile = fileManager.createDownloadFile(trackId, storageLocation, finalExtension)
+                // Create destination file — appending to the partial file when the
+                // server honored the Range request, truncating otherwise
+                destinationFile =
+                    if (resuming) {
+                        File(partialPath!!)
+                    } else {
+                        fileManager.createDownloadFile(trackId, storageLocation, finalExtension)
+                    }
 
                 inputStream = BufferedInputStream(connection.inputStream)
-                outputStream = FileOutputStream(destinationFile)
+                outputStream = FileOutputStream(destinationFile, resuming)
 
-                val totalBytes = connection.contentLengthLong
-                var bytesDownloaded: Long = 0
+                val startOffset = if (resuming) existingBytes else 0L
+                val totalBytes =
+                    if (connection.contentLengthLong > 0) connection.contentLengthLong + startOffset else -1L
+                var bytesDownloaded: Long = startOffset
 
                 val buffer = ByteArray(BUFFER_SIZE)
                 var bytesRead: Int
                 var lastProgressUpdate = System.currentTimeMillis()
 
                 while (inputStream.read(buffer).also { bytesRead = it } != -1) {
+                    // Blocking reads never suspend, so cancellation (pause/cancel,
+                    // withTimeout, worker stop) must be checked explicitly here.
+                    coroutineContext.ensureActive()
                     outputStream.write(buffer, 0, bytesRead)
                     bytesDownloaded += bytesRead
 
@@ -225,6 +261,10 @@ class DownloadWorker(
                 downloadManager.onProgress(downloadId, trackId, bytesDownloaded, totalBytes)
 
                 destinationFile.absolutePath
+            } catch (e: CancellationException) {
+                // Keep the partial file — pause resumes from this offset via Range;
+                // an explicit cancel deletes it in DownloadManagerCore.cancelDownload
+                throw e
             } catch (e: Exception) {
                 throw e
             } finally {

package/android/src/main/java/com/margelo/nitro/nitroplayer/download/TrackItemJson.kt

@@ -0,0 +1,60 @@
+package com.margelo.nitro.nitroplayer.download
+
+import com.margelo.nitro.core.AnyMap
+import com.margelo.nitro.nitroplayer.TrackItem
+import com.margelo.nitro.nitroplayer.Variant_NullType_String
+import org.json.JSONObject
+
+// Survives process death inside the worker's inputData so a completed
+// download can be recorded even when the in-memory metadata maps are gone.
+internal object TrackItemJson {
+    fun toJson(track: TrackItem): String =
+        JSONObject()
+            .apply {
+                put("id", track.id)
+                put("title", track.title)
+                put("artist", track.artist)
+                put("album", track.album)
+                put("duration", track.duration)
+                put("url", track.url)
+                track.artwork?.asSecondOrNull()?.let { put("artwork", it) }
+                track.extraPayload?.let { payload ->
+                    put("extraPayload", JSONObject(payload.toHashMap()))
+                }
+            }.toString()
+
+    fun fromJson(json: String): TrackItem? =
+        try {
+            val obj = JSONObject(json)
+            val artworkStr = obj.optString("artwork")
+            val extraPayload: AnyMap? =
+                if (obj.has("extraPayload")) {
+                    val extraObj = obj.getJSONObject("extraPayload")
+                    val map = AnyMap()
+                    val keys = extraObj.keys()
+                    while (keys.hasNext()) {
+                        val key = keys.next()
+                        when (val value = extraObj.get(key)) {
+                            is String -> map.setString(key, value)
+                            is Number -> map.setDouble(key, value.toDouble())
+                            is Boolean -> map.setBoolean(key, value)
+                        }
+                    }
+                    map
+                } else {
+                    null
+                }
+            TrackItem(
+                id = obj.getString("id"),
+                title = obj.getString("title"),
+                artist = obj.getString("artist"),
+                album = obj.getString("album"),
+                duration = obj.getDouble("duration"),
+                url = obj.getString("url"),
+                artwork = if (artworkStr.isNullOrEmpty()) null else Variant_NullType_String.create(artworkStr),
+                extraPayload = extraPayload,
+            )
+        } catch (e: Exception) {
+            null
+        }
+}

package/android/src/main/java/com/margelo/nitro/nitroplayer/equalizer/EqualizerCore.kt

@@ -475,17 +475,17 @@ class EqualizerCore private constructor(
 
     // === Callback management ===
 
-    fun addOnEnabledChangeListener(callback: (Boolean) -> Unit) {
-        onEnabledChangeListeners.add(callback)
-    }
+    fun addOnEnabledChangeListener(callback: (Boolean) -> Unit): Long = onEnabledChangeListeners.add(callback)
 
-    fun addOnBandChangeListener(callback: (Array<EqualizerBand>) -> Unit) {
-        onBandChangeListeners.add(callback)
-    }
+    fun removeOnEnabledChangeListener(id: Long): Boolean = onEnabledChangeListeners.remove(id)
 
-    fun addOnPresetChangeListener(callback: (Variant_NullType_String?) -> Unit) {
-        onPresetChangeListeners.add(callback)
-    }
+    fun addOnBandChangeListener(callback: (Array<EqualizerBand>) -> Unit): Long = onBandChangeListeners.add(callback)
+
+    fun removeOnBandChangeListener(id: Long): Boolean = onBandChangeListeners.remove(id)
+
+    fun addOnPresetChangeListener(callback: (Variant_NullType_String?) -> Unit): Long = onPresetChangeListeners.add(callback)
+
+    fun removeOnPresetChangeListener(id: Long): Boolean = onPresetChangeListeners.remove(id)
 
     private fun notifyEnabledChange(enabled: Boolean) {
         onEnabledChangeListeners.forEach { it(enabled) }

package/android/src/main/java/com/margelo/nitro/nitroplayer/media/AuthAwareHttpDataSourceFactory.kt

@@ -4,7 +4,6 @@ import androidx.media3.common.util.UnstableApi
 import androidx.media3.datasource.DataSource
 import androidx.media3.datasource.DefaultHttpDataSource
 import androidx.media3.datasource.ResolvingDataSource
-import java.util.concurrent.ConcurrentHashMap
 
 /**
  * HTTP [DataSource.Factory] that injects per-URL request headers (e.g. `Authorization`)
@@ -13,7 +12,7 @@ import java.util.concurrent.ConcurrentHashMap
  * Headers are registered per effective URL via [setHeadersForUrl] during MediaItem
  * construction and applied through a [ResolvingDataSource] just before each request opens.
  *
- * The registry is a [ConcurrentHashMap] because it is written on the player thread but
+ * The registry is a synchronized LRU map because it is written on the player thread but
  * read on ExoPlayer's loader threads.
  */
 @UnstableApi
@@ -34,7 +33,17 @@ class AuthAwareHttpDataSourceFactory : DataSource.Factory {
     override fun createDataSource(): DataSource = factory.createDataSource()
 
     companion object {
-        private val headersMap = ConcurrentHashMap<String, Map<String, String>>()
+        // LRU-bounded: rotating signed URLs would otherwise add an entry per
+        // playback for the process lifetime (destroy() has no callers today)
+        private const val MAX_HEADER_ENTRIES = 500
+
+        private val headersMap: MutableMap<String, Map<String, String>> =
+            java.util.Collections.synchronizedMap(
+                object : LinkedHashMap<String, Map<String, String>>(16, 0.75f, true) {
+                    override fun removeEldestEntry(eldest: MutableMap.MutableEntry<String, Map<String, String>>) =
+                        size > MAX_HEADER_ENTRIES
+                },
+            )
 
         fun setHeadersForUrl(url: String, headers: Map<String, String>) {
             headersMap[url] = headers

package/android/src/main/java/com/margelo/nitro/nitroplayer/media/ExoPlayerBuilder.kt

@@ -16,6 +16,8 @@ import androidx.media3.exoplayer.source.DefaultMediaSourceFactory
  */
 @UnstableApi
 object ExoPlayerBuilder {
+    const val DEFAULT_REMOTE_SKIP_INTERVAL_MS = 15_000L
+
     fun build(context: Context): ExoPlayer {
         val loadControl =
             DefaultLoadControl
@@ -50,6 +52,8 @@ object ExoPlayerBuilder {
             .Builder(context)
             .setLoadControl(loadControl)
             .setMediaSourceFactory(mediaSourceFactory)
+            .setSeekBackIncrementMs(DEFAULT_REMOTE_SKIP_INTERVAL_MS)
+            .setSeekForwardIncrementMs(DEFAULT_REMOTE_SKIP_INTERVAL_MS)
             .setAudioAttributes(audioAttrs, /* handleAudioFocus */ true)
             .setHandleAudioBecomingNoisy(true)
             .setWakeMode(C.WAKE_MODE_NETWORK)