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

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

@@ -21,8 +21,9 @@ class HybridPlayerQueue : HybridPlayerQueueSpec() {
     private val playlistManager: PlaylistManager
 
     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)
         playlistManager = core.getPlaylistManager()
     }
@@ -32,87 +33,125 @@ class HybridPlayerQueue : HybridPlayerQueueSpec() {
 
     // ── Playlist CRUD ─────────────────────────────────────────────────────────
 
-    override fun createPlaylist(name: String, description: String?, artwork: String?): Promise<String> =
-        Promise.async { playlistManager.createPlaylist(name, description, artwork) }
+    override fun createPlaylist(
+        name: String,
+        description: String?,
+        artwork: String?,
+    ): Promise<String> = Promise.async { playlistManager.createPlaylist(name, description, artwork) }
 
-    override fun deletePlaylist(playlistId: String): Promise<Unit> = Promise.async {
-        playlistManager.deletePlaylist(playlistId)
-    }
+    override fun deletePlaylist(playlistId: String): Promise<Unit> =
+        Promise.async {
+            playlistManager.deletePlaylist(playlistId)
+        }
 
-    override fun updatePlaylist(playlistId: String, name: String?, description: String?, artwork: String?): Promise<Unit> = Promise.async {
-        playlistManager.updatePlaylist(playlistId, name, description, artwork)
-        core.updatePlaylist(playlistId)
-    }
+    override fun updatePlaylist(
+        playlistId: String,
+        name: String?,
+        description: String?,
+        artwork: String?,
+    ): Promise<Unit> =
+        Promise.async {
+            playlistManager.updatePlaylist(playlistId, name, description, artwork)
+            core.updatePlaylist(playlistId)
+        }
 
     override fun getPlaylist(playlistId: String): Variant_NullType_Playlist {
         val playlist = playlistManager.getPlaylist(playlistId)
-        return if (playlist != null) Variant_NullType_Playlist.create(playlist.toPlaylist())
-        else Variant_NullType_Playlist.create(NullType.NULL)
+        return if (playlist != null) {
+            Variant_NullType_Playlist.create(playlist.toPlaylist())
+        } else {
+            Variant_NullType_Playlist.create(NullType.NULL)
+        }
     }
 
-    override fun getAllPlaylists(): Array<Playlist> =
-        playlistManager.getAllPlaylists().map { it.toPlaylist() }.toTypedArray()
+    override fun getAllPlaylists(): Array<Playlist> = playlistManager.getAllPlaylists().map { it.toPlaylist() }.toTypedArray()
 
     // ── Track mutations ───────────────────────────────────────────────────────
 
-    override fun addTrackToPlaylist(playlistId: String, track: TrackItem, index: Double?): Promise<Unit> = Promise.async {
-        playlistManager.addTrackToPlaylist(playlistId, track, index?.toInt())
-        core.updatePlaylist(playlistId)
-    }
+    override fun addTrackToPlaylist(
+        playlistId: String,
+        track: TrackItem,
+        index: Double?,
+    ): Promise<Unit> =
+        Promise.async {
+            playlistManager.addTrackToPlaylist(playlistId, track, index?.toInt())
+            core.updatePlaylist(playlistId)
+        }
 
-    override fun addTracksToPlaylist(playlistId: String, tracks: Array<TrackItem>, index: Double?): Promise<Unit> = Promise.async {
-        playlistManager.addTracksToPlaylist(playlistId, tracks.toList(), index?.toInt())
-        core.updatePlaylist(playlistId)
-    }
+    override fun addTracksToPlaylist(
+        playlistId: String,
+        tracks: Array<TrackItem>,
+        index: Double?,
+    ): Promise<Unit> =
+        Promise.async {
+            playlistManager.addTracksToPlaylist(playlistId, tracks.toList(), index?.toInt())
+            core.updatePlaylist(playlistId)
+        }
 
-    override fun removeTrackFromPlaylist(playlistId: String, trackId: String): Promise<Unit> = Promise.async {
-        playlistManager.removeTrackFromPlaylist(playlistId, trackId)
-        core.updatePlaylist(playlistId)
-    }
+    override fun removeTrackFromPlaylist(
+        playlistId: String,
+        trackId: String,
+    ): Promise<Unit> =
+        Promise.async {
+            playlistManager.removeTrackFromPlaylist(playlistId, trackId)
+            core.updatePlaylist(playlistId)
+        }
 
-    override fun reorderTrackInPlaylist(playlistId: String, trackId: String, newIndex: Double): Promise<Unit> = Promise.async {
-        playlistManager.reorderTrackInPlaylist(playlistId, trackId, newIndex.toInt())
-        core.updatePlaylist(playlistId)
-    }
+    override fun reorderTrackInPlaylist(
+        playlistId: String,
+        trackId: String,
+        newIndex: Double,
+    ): Promise<Unit> =
+        Promise.async {
+            playlistManager.reorderTrackInPlaylist(playlistId, trackId, newIndex.toInt())
+            core.updatePlaylist(playlistId)
+        }
 
     // ── Playback control ──────────────────────────────────────────────────────
 
-    override fun loadPlaylist(playlistId: String): Promise<Unit> = Promise.async {
-        core.loadPlaylist(playlistId)
-    }
+    override fun loadPlaylist(playlistId: String): Promise<Unit> =
+        Promise.async {
+            core.loadPlaylist(playlistId)
+        }
 
     override fun getCurrentPlaylistId(): Variant_NullType_String {
         val id = core.getCurrentPlaylistId()
-        return if (id != null) Variant_NullType_String.create(id)
-        else Variant_NullType_String.create(NullType.NULL)
+        return if (id != null) {
+            Variant_NullType_String.create(id)
+        } else {
+            Variant_NullType_String.create(NullType.NULL)
+        }
     }
 
     // ── Events ────────────────────────────────────────────────────────────────
 
     override fun onPlaylistsChanged(callback: (playlists: Array<Playlist>, operation: QueueOperation?) -> Unit) {
-        val removeListener = playlistManager.addPlaylistsChangeListener { playlists, operation ->
-            callback(playlists.map { it.toPlaylist() }.toTypedArray(), operation)
-        }
+        val removeListener =
+            playlistManager.addPlaylistsChangeListener { playlists, operation ->
+                callback(playlists.map { it.toPlaylist() }.toTypedArray(), operation)
+            }
         playlistsChangeListeners.add(removeListener)
     }
 
     override fun onPlaylistChanged(callback: (playlistId: String, playlist: Playlist, operation: QueueOperation?) -> Unit) {
         val listenerId = UUID.randomUUID().toString()
         playlistManager.getAllPlaylists().forEach { internalPlaylist ->
-            val removeListener = playlistManager.addPlaylistChangeListener(internalPlaylist.id) { playlist, operation ->
-                callback(playlist.id, playlist.toPlaylist(), operation)
-            }
+            val removeListener =
+                playlistManager.addPlaylistChangeListener(internalPlaylist.id) { playlist, operation ->
+                    callback(playlist.id, playlist.toPlaylist(), operation)
+                }
             playlistChangeListeners[listenerId] = removeListener
         }
     }
 
     // ── Helper ────────────────────────────────────────────────────────────────
 
-    private fun InternalPlaylist.toPlaylist(): Playlist = Playlist(
-        id = this.id,
-        name = this.name,
-        description = this.description?.let { Variant_NullType_String.create(it) },
-        artwork = this.artwork?.let { Variant_NullType_String.create(it) },
-        tracks = this.tracks.toTypedArray(),
-    )
+    private fun InternalPlaylist.toPlaylist(): Playlist =
+        Playlist(
+            id = this.id,
+            name = this.name,
+            description = this.description?.let { Variant_NullType_String.create(it) },
+            artwork = this.artwork?.let { Variant_NullType_String.create(it) },
+            tracks = this.tracks.toTypedArray(),
+        )
 }

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