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

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) }
 }
 

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

@@ -16,80 +16,99 @@ import com.margelo.nitro.nitroplayer.media.NitroPlayerMediaBrowserService
 
 suspend fun TrackPlayerCore.play() = withPlayerContext { exo.play() }
 
-
 suspend fun TrackPlayerCore.pause() = withPlayerContext { exo.pause() }
 
-suspend fun TrackPlayerCore.seek(position: Double) = withPlayerContext {
-    isManuallySeeked = true
-    exo.seekTo((position * 1000).toLong())
-}
+suspend fun TrackPlayerCore.seek(position: Double) =
+    withPlayerContext {
+        isManuallySeeked = true
+        exo.seekTo((position * 1000).toLong())
+    }
 
-suspend fun TrackPlayerCore.skipToNext() = withPlayerContext {
-    if (exo.hasNextMediaItem()) {
-        exo.seekToNext()
-        checkUpcomingTracksForUrls(lookaheadCount)
+suspend fun TrackPlayerCore.skipToNext() =
+    withPlayerContext {
+        if (exo.hasNextMediaItem()) {
+            exo.seekToNext()
+            checkUpcomingTracksForUrls(lookaheadCount)
+        }
     }
-}
 
-suspend fun TrackPlayerCore.skipToPrevious() = withPlayerContext {
-    val currentPosition = exo.currentPosition
-    when {
-        currentPosition > 2000 -> exo.seekTo(0)
-
-        currentTemporaryType != TrackPlayerCore.TemporaryType.NONE -> {
-            val trackId = exo.currentMediaItem?.mediaId?.let { extractTrackId(it) }
-            if (trackId != null) {
-                when (currentTemporaryType) {
-                    TrackPlayerCore.TemporaryType.PLAY_NEXT -> {
-                        val idx = playNextStack.indexOfFirst { it.id == trackId }
-                        if (idx >= 0) playNextStack.removeAt(idx)
-                    }
-                    TrackPlayerCore.TemporaryType.UP_NEXT -> {
-                        val idx = upNextQueue.indexOfFirst { it.id == trackId }
-                        if (idx >= 0) upNextQueue.removeAt(idx)
+suspend fun TrackPlayerCore.skipToPrevious() =
+    withPlayerContext {
+        val currentPosition = exo.currentPosition
+        when {
+            currentPosition > 2000 -> {
+                exo.seekTo(0)
+            }
+
+            currentTemporaryType != TrackPlayerCore.TemporaryType.NONE -> {
+                val trackId = exo.currentMediaItem?.mediaId?.let { extractTrackId(it) }
+                if (trackId != null) {
+                    when (currentTemporaryType) {
+                        TrackPlayerCore.TemporaryType.PLAY_NEXT -> {
+                            val idx = playNextStack.indexOfFirst { it.id == trackId }
+                            if (idx >= 0) playNextStack.removeAt(idx)
+                        }
+
+                        TrackPlayerCore.TemporaryType.UP_NEXT -> {
+                            val idx = upNextQueue.indexOfFirst { it.id == trackId }
+                            if (idx >= 0) upNextQueue.removeAt(idx)
+                        }
+
+                        else -> {}
                     }
-                    else -> {}
                 }
+                currentTemporaryType = TrackPlayerCore.TemporaryType.NONE
+                playFromIndexInternal(currentTrackIndex)
             }
-            currentTemporaryType = TrackPlayerCore.TemporaryType.NONE
-            playFromIndexInternal(currentTrackIndex)
-        }
 
-        currentTrackIndex > 0 -> playFromIndexInternal(currentTrackIndex - 1)
+            currentTrackIndex > 0 -> {
+                playFromIndexInternal(currentTrackIndex - 1)
+            }
 
-        else -> exo.seekTo(0)
+            else -> {
+                exo.seekTo(0)
+            }
+        }
+        checkUpcomingTracksForUrls(lookaheadCount)
     }
-    checkUpcomingTracksForUrls(lookaheadCount)
-}
 
-suspend fun TrackPlayerCore.setRepeatMode(mode: RepeatMode) = withPlayerContext {
-    currentRepeatMode = mode
-    exo.setRepeatMode(
-        when (mode) {
-            RepeatMode.TRACK -> Player.REPEAT_MODE_ONE
-            else -> Player.REPEAT_MODE_OFF
-        }
-    )
-}
+suspend fun TrackPlayerCore.setRepeatMode(mode: RepeatMode) =
+    withPlayerContext {
+        currentRepeatMode = mode
+        exo.setRepeatMode(
+            when (mode) {
+                RepeatMode.TRACK -> Player.REPEAT_MODE_ONE
+                else -> Player.REPEAT_MODE_OFF
+            },
+        )
+    }
 
 fun TrackPlayerCore.getRepeatMode(): RepeatMode = currentRepeatMode
 
-suspend fun TrackPlayerCore.setVolume(volume: Double) = withPlayerContext {
-    val clamped = volume.coerceIn(0.0, 100.0) 
-    exo.setVolume((clamped / 100.0).toFloat())
-}
+suspend fun TrackPlayerCore.setVolume(volume: Double) =
+    withPlayerContext {
+        val clamped = volume.coerceIn(0.0, 100.0)
+        exo.setVolume((clamped / 100.0).toFloat())
+    }
 
-suspend fun TrackPlayerCore.configure(config: PlayerConfig) = withPlayerContext {
-    config.androidAutoEnabled?.let { NitroPlayerMediaBrowserService.isAndroidAutoEnabled = it }
-    config.lookaheadCount?.let { lookaheadCount = it.toInt() }
-    mediaSessionManager?.configure(config.androidAutoEnabled, config.carPlayEnabled, config.showInNotification)
-}
+suspend fun TrackPlayerCore.configure(config: PlayerConfig) =
+    withPlayerContext {
+        config.androidAutoEnabled?.let { NitroPlayerMediaBrowserService.isAndroidAutoEnabled = it }
+        config.lookaheadCount?.let { lookaheadCount = it.toInt() }
+        mediaSessionManager?.configure(config.androidAutoEnabled, config.carPlayEnabled, config.showInNotification)
+    }
 
-suspend fun TrackPlayerCore.playSong(songId: String, fromPlaylist: String?) = withPlayerContext {
+suspend fun TrackPlayerCore.playSong(
+    songId: String,
+    fromPlaylist: String?,
+) = withPlayerContext {
     playSongInternal(songId, fromPlaylist)
 }
 
-internal fun TrackPlayerCore.playSongInternal(songId: String, fromPlaylist: String?) {
+internal fun TrackPlayerCore.playSongInternal(
+    songId: String,
+    fromPlaylist: String?,
+) {
     playNextStack.clear()
     upNextQueue.clear()
     currentTemporaryType = TrackPlayerCore.TemporaryType.NONE
@@ -102,7 +121,9 @@ internal fun TrackPlayerCore.playSongInternal(songId: String, fromPlaylist: Stri
         if (playlist != null) {
             songIndex = playlist.tracks.indexOfFirst { it.id == songId }
             if (songIndex >= 0) targetPlaylistId = fromPlaylist else return
-        } else return
+        } else {
+            return
+        }
     } else {
         if (currentPlaylistId != null) {
             val cp = playlistManager.getPlaylist(currentPlaylistId!!)
@@ -114,12 +135,18 @@ internal fun TrackPlayerCore.playSongInternal(songId: String, fromPlaylist: Stri
         if (songIndex == -1) {
             for (playlist in playlistManager.getAllPlaylists()) {
                 songIndex = playlist.tracks.indexOfFirst { it.id == songId }
-                if (songIndex >= 0) { targetPlaylistId = playlist.id; break }
+                if (songIndex >= 0) {
+                    targetPlaylistId = playlist.id
+                    break
+                }
             }
         }
         if (songIndex == -1) {
             val all = playlistManager.getAllPlaylists()
-            if (all.isNotEmpty()) { targetPlaylistId = all[0].id; songIndex = 0 }
+            if (all.isNotEmpty()) {
+                targetPlaylistId = all[0].id
+                songIndex = 0
+            }
         }
     }
 
@@ -137,26 +164,28 @@ internal fun TrackPlayerCore.playSongInternal(songId: String, fromPlaylist: Stri
 
 internal fun TrackPlayerCore.emitStateChange(reason: Reason? = null) {
     if (!isExoInitialized) return
-    val state = when (exo.playbackState) {
-        Player.STATE_IDLE -> TrackPlayerState.STOPPED
-        Player.STATE_BUFFERING -> if (exo.playWhenReady) TrackPlayerState.PLAYING else TrackPlayerState.PAUSED
-        Player.STATE_READY -> if (exo.isPlaying) TrackPlayerState.PLAYING else TrackPlayerState.PAUSED
-        Player.STATE_ENDED -> TrackPlayerState.STOPPED
-        else -> TrackPlayerState.STOPPED
-    }
+    val state =
+        when (exo.playbackState) {
+            Player.STATE_IDLE -> TrackPlayerState.STOPPED
+            Player.STATE_BUFFERING -> if (exo.playWhenReady) TrackPlayerState.PLAYING else TrackPlayerState.PAUSED
+            Player.STATE_READY -> if (exo.isPlaying) TrackPlayerState.PLAYING else TrackPlayerState.PAUSED
+            Player.STATE_ENDED -> TrackPlayerState.STOPPED
+            else -> TrackPlayerState.STOPPED
+        }
     val actualReason = reason ?: if (exo.playbackState == Player.STATE_ENDED) Reason.END else null
     notifyPlaybackStateChange(state, actualReason)
     mediaSessionManager?.onPlaybackStateChanged(state == TrackPlayerState.PLAYING)
 }
 
-
 // ── Playback speed ────────────────────────────────────────────────────────
 
-suspend fun TrackPlayerCore.setPlayBackSpeed(speed: Double) = withPlayerContext {
-    if (speed <= 0.0) throw IllegalArgumentException("Speed must be greater than 0")
-    if (isExoInitialized) exo.setPlaybackSpeed(speed.toFloat())
-}
+suspend fun TrackPlayerCore.setPlayBackSpeed(speed: Double) =
+    withPlayerContext {
+        if (speed <= 0.0) throw IllegalArgumentException("Speed must be greater than 0")
+        if (isExoInitialized) exo.setPlaybackSpeed(speed.toFloat())
+    }
 
-suspend fun TrackPlayerCore.getPlayBackSpeed(): Double = withPlayerContext {
-    if (isExoInitialized) exo.getPlaybackSpeed().toDouble() else 1.0
-}
+suspend fun TrackPlayerCore.getPlayBackSpeed(): Double =
+    withPlayerContext {
+        if (isExoInitialized) exo.getPlaybackSpeed().toDouble() else 1.0
+    }