react-native-nitro-player 0.7.1-alpha.1 → 0.7.1-alpha.2

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

@@ -46,22 +46,33 @@ class HybridTrackPlayer : HybridTrackPlayerSpec() {
     private val listenerIds = mutableListOf<Pair<String, Long>>()
 
     init {
-        val context = NitroModules.applicationContext
-            ?: throw IllegalStateException("React Context is not initialized")
+        val context =
+            NitroModules.applicationContext
+                ?: throw IllegalStateException("React Context is not initialized")
         core = TrackPlayerCore.getInstance(context)
     }
 
     // ── Playback ─────────────────────────────────────────────────────────────
 
     override fun play(): Promise<Unit> = Promise.async { core.play() }
+
     override fun pause(): Promise<Unit> = Promise.async { core.pause() }
+
     override fun seek(position: Double): Promise<Unit> = Promise.async { core.seek(position) }
+
     override fun skipToNext(): Promise<Unit> = Promise.async { core.skipToNext() }
+
     override fun skipToPrevious(): Promise<Unit> = Promise.async { core.skipToPrevious() }
-    override fun playSong(songId: String, fromPlaylist: String?): Promise<Unit> = Promise.async { core.playSong(songId, fromPlaylist) }
+
+    override fun playSong(
+        songId: String,
+        fromPlaylist: String?,
+    ): Promise<Unit> = Promise.async { core.playSong(songId, fromPlaylist) }
+
     override fun skipToIndex(index: Double): Promise<Boolean> = Promise.async { core.skipToIndex(index.toInt()) }
 
     override fun setRepeatMode(mode: RepeatMode): Promise<Unit> = Promise.async { core.setRepeatMode(mode) }
+
     override fun getRepeatMode(): RepeatMode = core.getRepeatMode()
 
     override fun setVolume(volume: Double): Promise<Unit> = Promise.async { core.setVolume(volume) }
@@ -71,10 +82,15 @@ class HybridTrackPlayer : HybridTrackPlayerSpec() {
     // ── Queue / state reads ───────────────────────────────────────────────────
 
     override fun getActualQueue(): Promise<Array<TrackItem>> = Promise.async { core.getActualQueue().toTypedArray() }
+
     override fun getState(): Promise<PlayerState> = Promise.async { core.getState() }
+
     override fun getTracksById(trackIds: Array<String>): Promise<Array<TrackItem>> = Promise.async { core.getTracksById(trackIds.toList()).toTypedArray() }
+
     override fun getTracksNeedingUrls(): Promise<Array<TrackItem>> = Promise.async { core.getTracksNeedingUrls().toTypedArray() }
+
     override fun getNextTracks(count: Double): Promise<Array<TrackItem>> = Promise.async { core.getNextTracks(count.toInt()).toTypedArray() }
+
     override fun getCurrentTrackIndex(): Promise<Double> = Promise.async { core.getCurrentTrackIndex().toDouble() }
 
     // ── URL updates ───────────────────────────────────────────────────────────
@@ -84,18 +100,30 @@ class HybridTrackPlayer : HybridTrackPlayerSpec() {
     // ── Temporary queue ───────────────────────────────────────────────────────
 
     override fun addToUpNext(trackId: String): Promise<Unit> = Promise.async { core.addToUpNext(trackId) }
+
     override fun playNext(trackId: String): Promise<Unit> = Promise.async { core.playNext(trackId) }
+
     override fun removeFromPlayNext(trackId: String): Promise<Boolean> = Promise.async { core.removeFromPlayNext(trackId) }
+
     override fun removeFromUpNext(trackId: String): Promise<Boolean> = Promise.async { core.removeFromUpNext(trackId) }
+
     override fun clearPlayNext(): Promise<Unit> = Promise.async { core.clearPlayNext() }
+
     override fun clearUpNext(): Promise<Unit> = Promise.async { core.clearUpNext() }
-    override fun reorderTemporaryTrack(trackId: String, newIndex: Double): Promise<Boolean> = Promise.async { core.reorderTemporaryTrack(trackId, newIndex.toInt()) }
+
+    override fun reorderTemporaryTrack(
+        trackId: String,
+        newIndex: Double,
+    ): Promise<Boolean> = Promise.async { core.reorderTemporaryTrack(trackId, newIndex.toInt()) }
+
     override fun getPlayNextQueue(): Promise<Array<TrackItem>> = Promise.async { core.getPlayNextQueue().toTypedArray() }
+
     override fun getUpNextQueue(): Promise<Array<TrackItem>> = Promise.async { core.getUpNextQueue().toTypedArray() }
 
     // ── Playback speed ────────────────────────────────────────────────────────
 
     override fun setPlaybackSpeed(speed: Double): Promise<Unit> = Promise.async { core.setPlayBackSpeed(speed) }
+
     override fun getPlaybackSpeed(): Promise<Double> = Promise.async { core.getPlayBackSpeed() }
 
     // ── Android Auto ──────────────────────────────────────────────────────────
@@ -130,16 +158,18 @@ class HybridTrackPlayer : HybridTrackPlayerSpec() {
     }
 
     override fun onTracksNeedUpdate(callback: (tracks: Array<TrackItem>, lookahead: Double) -> Unit) {
-        val id = core.addOnTracksNeedUpdateListener { tracks, lookahead ->
-            callback(tracks.toTypedArray(), lookahead.toDouble())
-        }
+        val id =
+            core.addOnTracksNeedUpdateListener { tracks, lookahead ->
+                callback(tracks.toTypedArray(), lookahead.toDouble())
+            }
         listenerIds += "onTracksNeedUpdate" to id
     }
 
     override fun onTemporaryQueueChange(callback: (playNextQueue: Array<TrackItem>, upNextQueue: Array<TrackItem>) -> Unit) {
-        val id = core.addOnTemporaryQueueChangeListener { pn, un ->
-            callback(pn.toTypedArray(), un.toTypedArray())
-        }
+        val id =
+            core.addOnTemporaryQueueChangeListener { pn, un ->
+                callback(pn.toTypedArray(), un.toTypedArray())
+            }
         listenerIds += "onTemporaryQueueChange" to id
     }
 

package/android/src/main/java/com/margelo/nitro/nitroplayer/core/ExoPlayerCore.kt

@@ -1,7 +1,7 @@
 package com.margelo.nitro.nitroplayer.core
 
-import android.os.HandlerThread
 import android.content.Context
+import android.os.HandlerThread
 import androidx.media3.common.AudioAttributes
 import androidx.media3.common.C
 import androidx.media3.common.MediaItem
@@ -9,63 +9,102 @@ import androidx.media3.common.Player
 import androidx.media3.exoplayer.DefaultLoadControl
 import androidx.media3.exoplayer.ExoPlayer
 
-
-class ExoPlayerCore(context: Context, playerThread: HandlerThread) {
-
+class ExoPlayerCore(
+    context: Context,
+    playerThread: HandlerThread,
+) {
     /** The underlying ExoPlayer instance — accessible for MediaSessionManager wiring. */
     internal val player: ExoPlayer = build(context, playerThread)
 
-    private fun build(context: Context, playerThread: HandlerThread): ExoPlayer {
-        val loadControl = DefaultLoadControl.Builder()
-            .setBufferDurationsMs(
-                /* minBufferMs        */ 30_000,
-                /* maxBufferMs        */ 120_000,
-                /* bufferForPlayback  */ 2_500,
-                /* bufferForRebuffer  */ 5_000,
-            )
-            .setBackBuffer(30_000, /* retainBackBufferFromKeyframe */ true)
-            .setTargetBufferBytes(C.LENGTH_UNSET)
-            .setPrioritizeTimeOverSizeThresholds(true)
-            .build()
+    private fun build(
+        context: Context,
+        playerThread: HandlerThread,
+    ): ExoPlayer {
+        val loadControl =
+            DefaultLoadControl
+                .Builder()
+                .setBufferDurationsMs(
+                    // minBufferMs
+                    30_000,
+                    // maxBufferMs
+                    120_000,
+                    // bufferForPlayback
+                    2_500,
+                    // bufferForRebuffer
+                    5_000,
+                ).setBackBuffer(30_000, /* retainBackBufferFromKeyframe */ true)
+                .setTargetBufferBytes(C.LENGTH_UNSET)
+                .setPrioritizeTimeOverSizeThresholds(true)
+                .build()
 
-        val audioAttrs = AudioAttributes.Builder()
-            .setUsage(C.USAGE_MEDIA)
-            .setContentType(C.AUDIO_CONTENT_TYPE_MUSIC)
-            .build()
+        val audioAttrs =
+            AudioAttributes
+                .Builder()
+                .setUsage(C.USAGE_MEDIA)
+                .setContentType(C.AUDIO_CONTENT_TYPE_MUSIC)
+                .build()
 
-        return ExoPlayer.Builder(context)
+        return ExoPlayer
+            .Builder(context)
             .setLooper(playerThread.looper)
             .setLoadControl(loadControl)
             .setAudioAttributes(audioAttrs, /* handleAudioFocus */ true)
             .setHandleAudioBecomingNoisy(true)
+            .setWakeMode(C.WAKE_MODE_NETWORK)
             .setPauseAtEndOfMediaItems(false)
             .build()
     }
 
     // ── Playback ───────────────────────────────────────────────────────────
     fun play() = player.play()
+
     fun pause() = player.pause()
+
     fun seekTo(positionMs: Long) = player.seekTo(positionMs)
+
     fun seekToNext() = player.seekToNextMediaItem()
+
     fun hasNextMediaItem(): Boolean = player.hasNextMediaItem()
-    fun setRepeatMode(mode: Int) { player.repeatMode = mode }
-    fun setVolume(volume: Float) { player.volume = volume }
+
+    fun setRepeatMode(mode: Int) {
+        player.repeatMode = mode
+    }
+
+    fun setVolume(volume: Float) {
+        player.volume = volume
+    }
+
     fun setPlaybackSpeed(speed: Float) = player.setPlaybackSpeed(speed)
+
     fun getPlaybackSpeed(): Float = player.playbackParameters.speed
 
     // ── Queue mutations ────────────────────────────────────────────────────
     fun prepare() = player.prepare()
+
     fun seekToDefaultPosition(windowIndex: Int) = player.seekToDefaultPosition(windowIndex)
+
     fun clearMediaItems() = player.clearMediaItems()
-    fun setMediaItems(items: List<MediaItem>, resetPosition: Boolean = false) =
-        player.setMediaItems(items, resetPosition)
+
+    fun setMediaItems(
+        items: List<MediaItem>,
+        resetPosition: Boolean = false,
+    ) = player.setMediaItems(items, resetPosition)
+
     fun addMediaItems(items: List<MediaItem>) = player.addMediaItems(items)
-    fun removeMediaItems(fromIndex: Int, toIndex: Int) =
-        player.removeMediaItems(fromIndex, toIndex)
-    fun replaceMediaItem(index: Int, item: MediaItem) = player.replaceMediaItem(index, item)
+
+    fun removeMediaItems(
+        fromIndex: Int,
+        toIndex: Int,
+    ) = player.removeMediaItems(fromIndex, toIndex)
+
+    fun replaceMediaItem(
+        index: Int,
+        item: MediaItem,
+    ) = player.replaceMediaItem(index, item)
 
     // ── Listener wiring ────────────────────────────────────────────────────
     fun addListener(listener: Player.Listener) = player.addListener(listener)
+
     fun removeListener(listener: Player.Listener) = player.removeListener(listener)
 
     // ── State reads ────────────────────────────────────────────────────────
@@ -73,7 +112,9 @@ class ExoPlayerCore(context: Context, playerThread: HandlerThread) {
     val isPlaying: Boolean get() = player.isPlaying
     var playWhenReady: Boolean
         get() = player.playWhenReady
-        set(value) { player.playWhenReady = value }
+        set(value) {
+            player.playWhenReady = value
+        }
     val currentMediaItem: MediaItem? get() = player.currentMediaItem
     val currentMediaItemIndex: Int get() = player.currentMediaItemIndex
     val currentPosition: Long get() = player.currentPosition

package/android/src/main/java/com/margelo/nitro/nitroplayer/core/ListenerRegistry.kt

@@ -8,7 +8,10 @@ import java.util.concurrent.atomic.AtomicLong
  * Uses CopyOnWriteArrayList for lock-free iteration and AtomicLong for ID generation.
  */
 class ListenerRegistry<T> {
-    private data class Entry<T>(val id: Long, val callback: T)
+    private data class Entry<T>(
+        val id: Long,
+        val callback: T,
+    )
 
     private val entries = CopyOnWriteArrayList<Entry<T>>()
     private val nextId = AtomicLong(0)

package/android/src/main/java/com/margelo/nitro/nitroplayer/core/TrackPlayerAndroidAuto.kt

@@ -13,50 +13,56 @@ import com.margelo.nitro.nitroplayer.media.NitroPlayerMediaBrowserService
 
 /** Called on the main thread from TrackPlayerCore.init via handler.post. */
 internal fun TrackPlayerCore.setupAndroidAutoDetector() {
-    androidAutoConnectionDetector = AndroidAutoConnectionDetector(context).apply {
-        onConnectionChanged = { connected, _ ->
-            handler.post {
-                isAndroidAutoConnectedField = connected
-                NitroPlayerMediaBrowserService.isAndroidAutoConnected = connected
-                notifyAndroidAutoConnection(connected)
+    androidAutoConnectionDetector =
+        AndroidAutoConnectionDetector(context).apply {
+            onConnectionChanged = { connected, _ ->
+                handler.post {
+                    isAndroidAutoConnectedField = connected
+                    NitroPlayerMediaBrowserService.isAndroidAutoConnected = connected
+                    notifyAndroidAutoConnection(connected)
+                }
             }
+            registerCarConnectionReceiver()
         }
-        registerCarConnectionReceiver()
-    }
 }
 
 /** Called by MediaBrowserService when the user picks a track in Android Auto. */
-suspend fun TrackPlayerCore.playFromPlaylistTrack(mediaId: String) = withPlayerContext {
-    try {
-        val colonIndex = mediaId.indexOf(':')
-        if (colonIndex <= 0 || colonIndex >= mediaId.length - 1) return@withPlayerContext
-        val playlistId = mediaId.substring(0, colonIndex)
-        val trackId = mediaId.substring(colonIndex + 1)
-        val playlist = playlistManager.getPlaylist(playlistId) ?: return@withPlayerContext
-        val trackIndex = playlist.tracks.indexOfFirst { it.id == trackId }
-        if (trackIndex < 0) return@withPlayerContext
-        if (currentPlaylistId != playlistId) {
-            loadPlaylistInternal(playlistId)
+suspend fun TrackPlayerCore.playFromPlaylistTrack(mediaId: String) =
+    withPlayerContext {
+        try {
+            val colonIndex = mediaId.indexOf(':')
+            if (colonIndex <= 0 || colonIndex >= mediaId.length - 1) return@withPlayerContext
+            val playlistId = mediaId.substring(0, colonIndex)
+            val trackId = mediaId.substring(colonIndex + 1)
+            val playlist = playlistManager.getPlaylist(playlistId) ?: return@withPlayerContext
+            val trackIndex = playlist.tracks.indexOfFirst { it.id == trackId }
+            if (trackIndex < 0) return@withPlayerContext
+            if (currentPlaylistId != playlistId) {
+                loadPlaylistInternal(playlistId)
+            }
+            playFromIndexInternal(trackIndex)
+        } catch (_: Exception) {
         }
-        playFromIndexInternal(trackIndex)
-    } catch (_: Exception) {}
-}
+    }
 
 private fun TrackPlayerCore.loadPlaylistInternal(playlistId: String) {
-    playNextStack.clear(); upNextQueue.clear()
+    playNextStack.clear()
+    upNextQueue.clear()
     currentTemporaryType = TrackPlayerCore.TemporaryType.NONE
     val playlist = playlistManager.getPlaylist(playlistId) ?: return
     currentPlaylistId = playlistId
     updatePlayerQueue(playlist.tracks)
 }
 
-suspend fun TrackPlayerCore.setAndroidAutoMediaLibrary(libraryJson: String) = withPlayerContext {
-    val library = MediaLibraryParser.fromJson(libraryJson)
-    mediaLibraryManager.setMediaLibrary(library)
-    NitroPlayerMediaBrowserService.getInstance()?.onPlaylistsUpdated()
-}
+suspend fun TrackPlayerCore.setAndroidAutoMediaLibrary(libraryJson: String) =
+    withPlayerContext {
+        val library = MediaLibraryParser.fromJson(libraryJson)
+        mediaLibraryManager.setMediaLibrary(library)
+        NitroPlayerMediaBrowserService.getInstance()?.onPlaylistsUpdated()
+    }
 
-suspend fun TrackPlayerCore.clearAndroidAutoMediaLibrary() = withPlayerContext {
-    mediaLibraryManager.clear()
-    NitroPlayerMediaBrowserService.getInstance()?.onPlaylistsUpdated()
-}
+suspend fun TrackPlayerCore.clearAndroidAutoMediaLibrary() =
+    withPlayerContext {
+        mediaLibraryManager.clear()
+        NitroPlayerMediaBrowserService.getInstance()?.onPlaylistsUpdated()
+    }

package/android/src/main/java/com/margelo/nitro/nitroplayer/core/TrackPlayerCore.kt

@@ -22,8 +22,9 @@ import kotlinx.coroutines.suspendCancellableCoroutine
 import kotlin.coroutines.resume
 import kotlin.coroutines.resumeWithException
 
-class TrackPlayerCore private constructor(internal val context: Context) {
-
+class TrackPlayerCore private constructor(
+    internal val context: Context,
+) {
     // ── Thread infrastructure ──────────────────────────────────────────────
     /** Main-looper handler — only for Android Auto connection callbacks */
     internal val handler = Handler(Looper.getMainLooper())
@@ -33,6 +34,7 @@ class TrackPlayerCore private constructor(internal val context: Context) {
 
     // ── ExoPlayer wrapper (created on player thread inside initExoAndMedia) ──
     internal lateinit var exo: ExoPlayerCore
+
     /** Safe initialized check — backing field can only be read from the declaring class. */
     internal val isExoInitialized: Boolean get() = ::exo.isInitialized
 
@@ -45,9 +47,11 @@ class TrackPlayerCore private constructor(internal val context: Context) {
     // ── Playback state ─────────────────────────────────────────────────────
     @Volatile internal var currentPlaylistId: String? = null
     internal var isManuallySeeked = false
+
     @Volatile internal var isAndroidAutoConnectedField: Boolean = false
     internal var androidAutoConnectionDetector: AndroidAutoConnectionDetector? = null
     internal var previousMediaItem: androidx.media3.common.MediaItem? = null
+
     @Volatile internal var currentRepeatMode: RepeatMode = RepeatMode.OFF
     internal var lookaheadCount: Int = 5
     internal var playerListener: androidx.media3.common.Player.Listener? = null
@@ -78,33 +82,35 @@ class TrackPlayerCore private constructor(internal val context: Context) {
         ListenerRegistry<(Boolean) -> Unit>()
 
     // ── Progress & playlist-update runnables ───────────────────────────────
-    internal val progressUpdateRunnable = object : Runnable {
-        override fun run() {
-            if (::exo.isInitialized &&
-                exo.playbackState != androidx.media3.common.Player.STATE_IDLE
-            ) {
-                val pos = exo.currentPosition / 1000.0
-                val dur = if (exo.duration > 0) exo.duration / 1000.0 else 0.0
-                notifyPlaybackProgress(pos, dur, if (isManuallySeeked) true else null)
-                isManuallySeeked = false
+    internal val progressUpdateRunnable =
+        object : Runnable {
+            override fun run() {
+                if (::exo.isInitialized &&
+                    exo.playbackState != androidx.media3.common.Player.STATE_IDLE
+                ) {
+                    val pos = exo.currentPosition / 1000.0
+                    val dur = if (exo.duration > 0) exo.duration / 1000.0 else 0.0
+                    notifyPlaybackProgress(pos, dur, if (isManuallySeeked) true else null)
+                    isManuallySeeked = false
+                }
+                playerHandler.postDelayed(this, 250)
             }
-            playerHandler.postDelayed(this, 250)
         }
-    }
 
-    internal val updateCurrentPlaylistRunnable = Runnable {
-        val id = currentPlaylistId ?: return@Runnable
-        val playlist = playlistManager.getPlaylist(id) ?: return@Runnable
-        currentTracks = playlist.tracks
-        if (::exo.isInitialized &&
-            exo.currentMediaItem != null &&
-            exo.currentMediaItemIndex >= 0
-        ) {
-            rebuildQueueFromCurrentPosition()
-        } else {
-            updatePlayerQueue(playlist.tracks)
+    internal val updateCurrentPlaylistRunnable =
+        Runnable {
+            val id = currentPlaylistId ?: return@Runnable
+            val playlist = playlistManager.getPlaylist(id) ?: return@Runnable
+            currentTracks = playlist.tracks
+            if (::exo.isInitialized &&
+                exo.currentMediaItem != null &&
+                exo.currentMediaItemIndex >= 0
+            ) {
+                rebuildQueueFromCurrentPosition()
+            } else {
+                updatePlayerQueue(playlist.tracks)
+            }
         }
-    }
 
     // ── Singleton ──────────────────────────────────────────────────────────
     companion object {
@@ -130,10 +136,14 @@ class TrackPlayerCore private constructor(internal val context: Context) {
     internal suspend fun <T> withPlayerContext(block: () -> T): T {
         if (Looper.myLooper() == playerThread.looper) return block()
         return suspendCancellableCoroutine { cont ->
-            val r = Runnable {
-                try { cont.resume(block()) }
-                catch (e: Exception) { cont.resumeWithException(e) }
-            }
+            val r =
+                Runnable {
+                    try {
+                        cont.resume(block())
+                    } catch (e: Exception) {
+                        cont.resumeWithException(e)
+                    }
+                }
             playerHandler.post(r)
             cont.invokeOnCancellation { playerHandler.removeCallbacks(r) }
         }
@@ -157,45 +167,40 @@ class TrackPlayerCore private constructor(internal val context: Context) {
     // ── Simple read-only accessors ─────────────────────────────────────────
 
     fun isAndroidAutoConnected(): Boolean = isAndroidAutoConnectedField
+
     fun getCurrentPlaylistId(): String? = currentPlaylistId
+
     fun getPlaylistManager(): PlaylistManager = playlistManager
-    fun getAllPlaylists(): List<com.margelo.nitro.nitroplayer.playlist.Playlist> =
-        playlistManager.getAllPlaylists()
+
+    fun getAllPlaylists(): List<com.margelo.nitro.nitroplayer.playlist.Playlist> = playlistManager.getAllPlaylists()
 
     // ── Listener add/remove (returns stable ID for cleanup) ───────────────
 
-    fun addOnChangeTrackListener(cb: (TrackItem, Reason?) -> Unit): Long =
-        onChangeTrackListeners.add(cb)
-    fun removeOnChangeTrackListener(id: Long): Boolean =
-        onChangeTrackListeners.remove(id)
-
-    fun addOnPlaybackStateChangeListener(cb: (TrackPlayerState, Reason?) -> Unit): Long =
-        onPlaybackStateChangeListeners.add(cb)
-    fun removeOnPlaybackStateChangeListener(id: Long): Boolean =
-        onPlaybackStateChangeListeners.remove(id)
-
-    fun addOnSeekListener(cb: (Double, Double) -> Unit): Long =
-        onSeekListeners.add(cb)
-    fun removeOnSeekListener(id: Long): Boolean =
-        onSeekListeners.remove(id)
-
-    fun addOnPlaybackProgressChangeListener(cb: (Double, Double, Boolean?) -> Unit): Long =
-        onProgressListeners.add(cb)
-    fun removeOnPlaybackProgressChangeListener(id: Long): Boolean =
-        onProgressListeners.remove(id)
-
-    fun addOnTracksNeedUpdateListener(cb: (List<TrackItem>, Int) -> Unit): Long =
-        onTracksNeedUpdateListeners.add(cb)
-    fun removeOnTracksNeedUpdateListener(id: Long): Boolean =
-        onTracksNeedUpdateListeners.remove(id)
-
-    fun addOnTemporaryQueueChangeListener(cb: (List<TrackItem>, List<TrackItem>) -> Unit): Long =
-        onTemporaryQueueChangeListeners.add(cb)
-    fun removeOnTemporaryQueueChangeListener(id: Long): Boolean =
-        onTemporaryQueueChangeListeners.remove(id)
-
-    fun addOnAndroidAutoConnectionListener(cb: (Boolean) -> Unit): Long =
-        onAndroidAutoConnectionListeners.add(cb)
-    fun removeOnAndroidAutoConnectionListener(id: Long): Boolean =
-        onAndroidAutoConnectionListeners.remove(id)
+    fun addOnChangeTrackListener(cb: (TrackItem, Reason?) -> Unit): Long = onChangeTrackListeners.add(cb)
+
+    fun removeOnChangeTrackListener(id: Long): Boolean = onChangeTrackListeners.remove(id)
+
+    fun addOnPlaybackStateChangeListener(cb: (TrackPlayerState, Reason?) -> Unit): Long = onPlaybackStateChangeListeners.add(cb)
+
+    fun removeOnPlaybackStateChangeListener(id: Long): Boolean = onPlaybackStateChangeListeners.remove(id)
+
+    fun addOnSeekListener(cb: (Double, Double) -> Unit): Long = onSeekListeners.add(cb)
+
+    fun removeOnSeekListener(id: Long): Boolean = onSeekListeners.remove(id)
+
+    fun addOnPlaybackProgressChangeListener(cb: (Double, Double, Boolean?) -> Unit): Long = onProgressListeners.add(cb)
+
+    fun removeOnPlaybackProgressChangeListener(id: Long): Boolean = onProgressListeners.remove(id)
+
+    fun addOnTracksNeedUpdateListener(cb: (List<TrackItem>, Int) -> Unit): Long = onTracksNeedUpdateListeners.add(cb)
+
+    fun removeOnTracksNeedUpdateListener(id: Long): Boolean = onTracksNeedUpdateListeners.remove(id)
+
+    fun addOnTemporaryQueueChangeListener(cb: (List<TrackItem>, List<TrackItem>) -> Unit): Long = onTemporaryQueueChangeListeners.add(cb)
+
+    fun removeOnTemporaryQueueChangeListener(id: Long): Boolean = onTemporaryQueueChangeListeners.remove(id)
+
+    fun addOnAndroidAutoConnectionListener(cb: (Boolean) -> Unit): Long = onAndroidAutoConnectionListeners.add(cb)
+
+    fun removeOnAndroidAutoConnectionListener(id: Long): Boolean = onAndroidAutoConnectionListeners.remove(id)
 }

package/android/src/main/java/com/margelo/nitro/nitroplayer/core/TrackPlayerListener.kt

@@ -17,15 +17,19 @@ import com.margelo.nitro.nitroplayer.media.NitroPlayerMediaBrowserService
 internal class TrackPlayerEventListener(
     private val core: TrackPlayerCore,
 ) : Player.Listener {
-
-    override fun onMediaItemTransition(mediaItem: MediaItem?, reason: Int) {
+    override fun onMediaItemTransition(
+        mediaItem: MediaItem?,
+        reason: Int,
+    ) {
         with(core) {
             // TRACK repeat: REPEAT_MODE_ONE fires this every loop — not a real track change
             if (reason == Player.MEDIA_ITEM_TRANSITION_REASON_REPEAT) return
 
             // Remove the track that just finished/was skipped from temp lists
-            if ((reason == Player.MEDIA_ITEM_TRANSITION_REASON_AUTO ||
-                        reason == Player.MEDIA_ITEM_TRANSITION_REASON_SEEK) &&
+            if ((
+                    reason == Player.MEDIA_ITEM_TRANSITION_REASON_AUTO ||
+                        reason == Player.MEDIA_ITEM_TRANSITION_REASON_SEEK
+                ) &&
                 previousMediaItem != null
             ) {
                 previousMediaItem?.mediaId?.let { mediaId ->
@@ -54,12 +58,13 @@ internal class TrackPlayerEventListener(
             }
 
             val track = getCurrentTrack() ?: return
-            val r = when (reason) {
-                Player.MEDIA_ITEM_TRANSITION_REASON_AUTO -> Reason.END
-                Player.MEDIA_ITEM_TRANSITION_REASON_SEEK -> Reason.USER_ACTION
-                Player.MEDIA_ITEM_TRANSITION_REASON_PLAYLIST_CHANGED -> Reason.USER_ACTION
-                else -> null
-            }
+            val r =
+                when (reason) {
+                    Player.MEDIA_ITEM_TRANSITION_REASON_AUTO -> Reason.END
+                    Player.MEDIA_ITEM_TRANSITION_REASON_SEEK -> Reason.USER_ACTION
+                    Player.MEDIA_ITEM_TRANSITION_REASON_PLAYLIST_CHANGED -> Reason.USER_ACTION
+                    else -> null
+                }
             notifyTrackChange(track, r)
             mediaSessionManager?.onTrackChanged(track)
             checkUpcomingTracksForUrls(lookaheadCount)
@@ -67,13 +72,19 @@ internal class TrackPlayerEventListener(
         }
     }
 
-    override fun onTimelineChanged(timeline: androidx.media3.common.Timeline, reason: Int) {
+    override fun onTimelineChanged(
+        timeline: androidx.media3.common.Timeline,
+        reason: Int,
+    ) {
         if (reason == Player.TIMELINE_CHANGE_REASON_PLAYLIST_CHANGED) {
             NitroPlayerMediaBrowserService.getInstance()?.onPlaylistsUpdated()
         }
     }
 
-    override fun onPlayWhenReadyChanged(playWhenReady: Boolean, reason: Int) {
+    override fun onPlayWhenReadyChanged(
+        playWhenReady: Boolean,
+        reason: Int,
+    ) {
         val r = if (reason == Player.PLAY_WHEN_READY_CHANGE_REASON_USER_REQUEST) Reason.USER_ACTION else null
         core.emitStateChange(r)
     }

package/android/src/main/java/com/margelo/nitro/nitroplayer/core/TrackPlayerNotify.kt

@@ -9,15 +9,24 @@ import com.margelo.nitro.nitroplayer.TrackPlayerState
  * All methods must be called from the player thread (already serialised).
  */
 
-internal fun TrackPlayerCore.notifyTrackChange(track: TrackItem, reason: Reason?) {
+internal fun TrackPlayerCore.notifyTrackChange(
+    track: TrackItem,
+    reason: Reason?,
+) {
     onChangeTrackListeners.forEach { it(track, reason) }
 }
 
-internal fun TrackPlayerCore.notifyPlaybackStateChange(state: TrackPlayerState, reason: Reason?) {
+internal fun TrackPlayerCore.notifyPlaybackStateChange(
+    state: TrackPlayerState,
+    reason: Reason?,
+) {
     onPlaybackStateChangeListeners.forEach { it(state, reason) }
 }
 
-internal fun TrackPlayerCore.notifySeek(position: Double, duration: Double) {
+internal fun TrackPlayerCore.notifySeek(
+    position: Double,
+    duration: Double,
+) {
     onSeekListeners.forEach { it(position, duration) }
 }
 
@@ -29,7 +38,10 @@ internal fun TrackPlayerCore.notifyPlaybackProgress(
     onProgressListeners.forEach { it(position, duration, isManuallySeeked) }
 }
 
-internal fun TrackPlayerCore.notifyTracksNeedUpdate(tracks: List<TrackItem>, lookahead: Int) {
+internal fun TrackPlayerCore.notifyTracksNeedUpdate(
+    tracks: List<TrackItem>,
+    lookahead: Int,
+) {
     onTracksNeedUpdateListeners.forEach { it(tracks, lookahead) }
 }