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

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

@@ -12,62 +12,65 @@ import com.margelo.nitro.nitroplayer.TrackItem
 
 // ── Track updates (URL resolution) ────────────────────────────────────────
 
-suspend fun TrackPlayerCore.updateTracks(tracks: List<TrackItem>) = withPlayerContext {
-    val currentTrack = getCurrentTrack()
-    val currentTrackId = currentTrack?.id
-    val currentTrackIsEmpty = currentTrack?.url.isNullOrEmpty()
-    val currentTrackUpdate = if (currentTrackId != null) tracks.find { it.id == currentTrackId } else null
-
-    val safeTracks = tracks.filter { track ->
-        when {
-            track.id == currentTrackId && !currentTrackIsEmpty -> false // preserve gapless
-            track.id == currentTrackId && currentTrackIsEmpty -> track.url.isNotEmpty()
-            track.url.isEmpty() -> false
-            else -> true
-        }
-    }
-    if (safeTracks.isEmpty()) return@withPlayerContext
-
-    val affectedPlaylists: Map<String, Int> = playlistManager.updateTracks(safeTracks)
-
-    // Replace current track's MediaItem if it was empty-URL and now has a URL
-    if (currentTrackUpdate != null && currentTrackIsEmpty && currentTrackUpdate.url.isNotEmpty()) {
-        val exoIndex = exo.currentMediaItemIndex
-        if (exoIndex >= 0) {
-            val playlistId = currentPlaylistId ?: ""
-            val mediaId = if (playlistId.isNotEmpty()) "$playlistId:${currentTrackUpdate.id}" else currentTrackUpdate.id
-            exo.replaceMediaItem(exoIndex, makeMediaItem(currentTrackUpdate, mediaId))
-            if (exo.playbackState == Player.STATE_IDLE) exo.prepare()
+suspend fun TrackPlayerCore.updateTracks(tracks: List<TrackItem>) =
+    withPlayerContext {
+        val currentTrack = getCurrentTrack()
+        val currentTrackId = currentTrack?.id
+        val currentTrackIsEmpty = currentTrack?.url.isNullOrEmpty()
+        val currentTrackUpdate = if (currentTrackId != null) tracks.find { it.id == currentTrackId } else null
+
+        val safeTracks =
+            tracks.filter { track ->
+                when {
+                    track.id == currentTrackId && !currentTrackIsEmpty -> false
+
+                    // preserve gapless
+                    track.id == currentTrackId && currentTrackIsEmpty -> track.url.isNotEmpty()
+
+                    track.url.isEmpty() -> false
+
+                    else -> true
+                }
+            }
+        if (safeTracks.isEmpty()) return@withPlayerContext
+
+        val affectedPlaylists: Map<String, Int> = playlistManager.updateTracks(safeTracks)
+
+        // Replace current track's MediaItem if it was empty-URL and now has a URL
+        if (currentTrackUpdate != null && currentTrackIsEmpty && currentTrackUpdate.url.isNotEmpty()) {
+            val exoIndex = exo.currentMediaItemIndex
+            if (exoIndex >= 0) {
+                val playlistId = currentPlaylistId ?: ""
+                val mediaId = if (playlistId.isNotEmpty()) "$playlistId:${currentTrackUpdate.id}" else currentTrackUpdate.id
+                exo.replaceMediaItem(exoIndex, makeMediaItem(currentTrackUpdate, mediaId))
+                if (exo.playbackState == Player.STATE_IDLE) exo.prepare()
+            }
         }
-    }
 
-    if (currentPlaylistId != null && affectedPlaylists.containsKey(currentPlaylistId)) {
-        val refreshedPlaylist = playlistManager.getPlaylist(currentPlaylistId!!)
-        if (refreshedPlaylist != null) {
-            currentTracks = refreshedPlaylist.tracks
-            val updatedById = currentTracks.associateBy { it.id }
-            playNextStack.forEachIndexed { i, t -> updatedById[t.id]?.let { if (it !== t) playNextStack[i] = it } }
-            upNextQueue.forEachIndexed { i, t -> updatedById[t.id]?.let { if (it !== t) upNextQueue[i] = it } }
+        if (currentPlaylistId != null && affectedPlaylists.containsKey(currentPlaylistId)) {
+            val refreshedPlaylist = playlistManager.getPlaylist(currentPlaylistId!!)
+            if (refreshedPlaylist != null) {
+                currentTracks = refreshedPlaylist.tracks
+                val updatedById = currentTracks.associateBy { it.id }
+                playNextStack.forEachIndexed { i, t -> updatedById[t.id]?.let { if (it !== t) playNextStack[i] = it } }
+                upNextQueue.forEachIndexed { i, t -> updatedById[t.id]?.let { if (it !== t) upNextQueue[i] = it } }
+            }
+            rebuildQueueFromCurrentPosition()
         }
-        rebuildQueueFromCurrentPosition()
     }
-}
 
 // ── Track queries ─────────────────────────────────────────────────────────
 
-suspend fun TrackPlayerCore.getTracksById(trackIds: List<String>): List<TrackItem> =
-    withPlayerContext { playlistManager.getTracksById(trackIds) as List<TrackItem> }
+suspend fun TrackPlayerCore.getTracksById(trackIds: List<String>): List<TrackItem> = withPlayerContext { playlistManager.getTracksById(trackIds) as List<TrackItem> }
 
-suspend fun TrackPlayerCore.getTracksNeedingUrls(): List<TrackItem> =
-    withPlayerContext { getTracksNeedingUrlsInternal() }
+suspend fun TrackPlayerCore.getTracksNeedingUrls(): List<TrackItem> = withPlayerContext { getTracksNeedingUrlsInternal() }
 
 internal fun TrackPlayerCore.getTracksNeedingUrlsInternal(): List<TrackItem> {
     val pid = currentPlaylistId ?: return emptyList()
     return playlistManager.getPlaylist(pid)?.tracks?.filter { it.url.isEmpty() } ?: emptyList()
 }
 
-suspend fun TrackPlayerCore.getNextTracks(count: Int): List<TrackItem> =
-    withPlayerContext { getNextTracksInternal(count) }
+suspend fun TrackPlayerCore.getNextTracks(count: Int): List<TrackItem> = withPlayerContext { getNextTracksInternal(count) }
 
 internal fun TrackPlayerCore.getNextTracksInternal(count: Int): List<TrackItem> {
     val actualQueue = getActualQueueInternal()
@@ -84,15 +87,15 @@ suspend fun TrackPlayerCore.getCurrentTrackIndex(): Int = withPlayerContext { cu
 // ── URL lookahead ─────────────────────────────────────────────────────────
 
 internal fun TrackPlayerCore.checkUpcomingTracksForUrls(lookahead: Int = 5) {
-    val upcomingTracks = if (currentTrackIndex < 0) {
-        currentTracks.take(lookahead)
-    } else {
-        getNextTracksInternal(lookahead)
-    }
+    val upcomingTracks =
+        if (currentTrackIndex < 0) {
+            currentTracks.take(lookahead)
+        } else {
+            getNextTracksInternal(lookahead)
+        }
     val currentTrack = getCurrentTrack()
     val currentNeedsUrl = currentTrack != null && currentTrack.url.isEmpty()
     val candidates = if (currentNeedsUrl) listOf(currentTrack!!) + upcomingTracks else upcomingTracks
     val needUrls = candidates.filter { it.url.isEmpty() }
     if (needUrls.isNotEmpty()) notifyTracksNeedUpdate(needUrls, lookahead)
 }
-

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

@@ -7,13 +7,13 @@ import com.margelo.nitro.nitroplayer.*
 import com.margelo.nitro.nitroplayer.core.NitroPlayerLogger
 import com.margelo.nitro.nitroplayer.playlist.PlaylistManager
 import com.margelo.nitro.nitroplayer.storage.NitroPlayerStorage
-import org.json.JSONArray
-import org.json.JSONObject
-import java.io.File
 import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.SupervisorJob
 import kotlinx.coroutines.launch
+import org.json.JSONArray
+import org.json.JSONObject
+import java.io.File
 
 /**
  * Manages persistence of downloaded track metadata using file storage

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

@@ -236,9 +236,18 @@ class DownloadManagerCore private constructor(
 
         for (m in activeTasks.values) {
             when (m.state) {
-                DownloadState.PENDING -> pendingCount++
-                DownloadState.DOWNLOADING -> activeCount++
-                DownloadState.FAILED -> failedCount++
+                DownloadState.PENDING -> {
+                    pendingCount++
+                }
+
+                DownloadState.DOWNLOADING -> {
+                    activeCount++
+                }
+
+                DownloadState.FAILED -> {
+                    failedCount++
+                }
+
                 else -> {}
             }
             totalBytes += m.totalBytes ?: 0.0

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

@@ -13,10 +13,10 @@ import com.margelo.nitro.nitroplayer.EqualizerState
 import com.margelo.nitro.nitroplayer.GainRange
 import com.margelo.nitro.nitroplayer.PresetType
 import com.margelo.nitro.nitroplayer.Variant_NullType_String
+import com.margelo.nitro.nitroplayer.core.ListenerRegistry
 import com.margelo.nitro.nitroplayer.core.NitroPlayerLogger
 import org.json.JSONArray
 import org.json.JSONObject
-import com.margelo.nitro.nitroplayer.core.ListenerRegistry
 
 class EqualizerCore private constructor(
     private val context: Context,
@@ -95,9 +95,10 @@ class EqualizerCore private constructor(
                 initDynamicsProcessing(audioSessionId)
                 usingDynamicsProcessing = true
             } else {
-                equalizer = Equalizer(0, audioSessionId).apply {
-                    enabled = false
-                }
+                equalizer =
+                    Equalizer(0, audioSessionId).apply {
+                        enabled = false
+                    }
                 usingDynamicsProcessing = false
                 setupBandMapping()
             }
@@ -109,14 +110,19 @@ class EqualizerCore private constructor(
 
     @RequiresApi(Build.VERSION_CODES.P)
     private fun initDynamicsProcessing(sessionId: Int) {
-        val config = DynamicsProcessing.Config.Builder(
-            DynamicsProcessing.VARIANT_FAVOR_FREQUENCY_RESOLUTION,
-            1,       // channelCount (stereo handled internally)
-            true, 10, // Pre-EQ enabled, 10 bands
-            false, 0, // MBC disabled
-            false, 0, // Post-EQ disabled
-            false     // Limiter disabled
-        ).build()
+        val config =
+            DynamicsProcessing.Config
+                .Builder(
+                    DynamicsProcessing.VARIANT_FAVOR_FREQUENCY_RESOLUTION,
+                    1, // channelCount (stereo handled internally)
+                    true,
+                    10, // Pre-EQ enabled, 10 bands
+                    false,
+                    0, // MBC disabled
+                    false,
+                    0, // Post-EQ disabled
+                    false, // Limiter disabled
+                ).build()
         dynamicsProcessing = DynamicsProcessing(0, sessionId, config).apply { enabled = false }
         for (i in 0 until 10) {
             val band = DynamicsProcessing.EqBand(true, frequencies[i].toFloat(), 0f)
@@ -155,8 +161,8 @@ class EqualizerCore private constructor(
         }
     }
 
-    fun setEnabled(enabled: Boolean): Boolean {
-        return try {
+    fun setEnabled(enabled: Boolean): Boolean =
+        try {
             if (usingDynamicsProcessing && Build.VERSION.SDK_INT >= Build.VERSION_CODES.P) {
                 dynamicsProcessing?.enabled = enabled
             } else {
@@ -170,12 +176,11 @@ class EqualizerCore private constructor(
             NitroPlayerLogger.log("EqualizerCore", "Failed to set enabled: ${e.message}")
             false
         }
-    }
 
     fun isEnabled(): Boolean = isEqualizerEnabled
 
-    fun getBands(): Array<EqualizerBand> {
-        return (0 until 10)
+    fun getBands(): Array<EqualizerBand> =
+        (0 until 10)
             .map { i ->
                 val gainDb = getCurrentBandGain(i)
                 EqualizerBand(
@@ -185,7 +190,6 @@ class EqualizerCore private constructor(
                     frequencyLabel = frequencyLabels[i],
                 )
             }.toTypedArray()
-    }
 
     private fun getCurrentBandGain(bandIndex: Int): Double = currentGainsArray[bandIndex]
 
@@ -217,7 +221,10 @@ class EqualizerCore private constructor(
     }
 
     @RequiresApi(Build.VERSION_CODES.P)
-    private fun setDPBandGain(bandIndex: Int, gainDb: Float) {
+    private fun setDPBandGain(
+        bandIndex: Int,
+        gainDb: Float,
+    ) {
         val band = DynamicsProcessing.EqBand(true, frequencies[bandIndex].toFloat(), gainDb)
         dynamicsProcessing?.setPreEqBandAllChannelsTo(bandIndex, band)
     }
@@ -249,12 +256,10 @@ class EqualizerCore private constructor(
         }
     }
 
-    private fun getAllGains(): List<Double> {
-        return (0 until 10).map { i -> getCurrentBandGain(i) }
-    }
+    private fun getAllGains(): List<Double> = (0 until 10).map { i -> getCurrentBandGain(i) }
 
-    fun getBandRange(): GainRange {
-        return if (usingDynamicsProcessing) {
+    fun getBandRange(): GainRange =
+        if (usingDynamicsProcessing) {
             GainRange(min = -12.0, max = 12.0)
         } else {
             val eq = equalizer
@@ -268,7 +273,6 @@ class EqualizerCore private constructor(
                 GainRange(min = -12.0, max = 12.0)
             }
         }
-    }
 
     fun getPresets(): Array<EqualizerPreset> {
         val builtIn = getBuiltInPresets()
@@ -418,17 +422,22 @@ class EqualizerCore private constructor(
         }
     }
 
-    private fun saveBandGainsAndPreset(gains: List<Double>, presetName: String?) {
+    private fun saveBandGainsAndPreset(
+        gains: List<Double>,
+        presetName: String?,
+    ) {
         val json = JSONArray()
         gains.forEach { json.put(it) }
-        prefs.edit().apply {
-            putString("eq_band_gains", json.toString())
-            if (presetName != null) {
-                putString("eq_current_preset", presetName)
-            } else {
-                remove("eq_current_preset")
-            }
-        }.apply()
+        prefs
+            .edit()
+            .apply {
+                putString("eq_band_gains", json.toString())
+                if (presetName != null) {
+                    putString("eq_current_preset", presetName)
+                } else {
+                    remove("eq_current_preset")
+                }
+            }.apply()
     }
 
     private fun restoreSettings() {

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

@@ -3,22 +3,14 @@ package com.margelo.nitro.nitroplayer.media
 import android.app.Notification
 import android.app.NotificationChannel
 import android.app.NotificationManager
-import android.app.PendingIntent
 import android.content.Context
 import android.content.Intent
-import android.graphics.Bitmap
-import android.graphics.BitmapFactory
 import android.net.Uri
 import android.os.Build
-import android.util.Log
-import android.util.LruCache
-import androidx.core.app.NotificationCompat
 import androidx.media3.common.MediaItem
 import androidx.media3.common.MediaMetadata
-import androidx.media3.common.Player
 import androidx.media3.exoplayer.ExoPlayer
 import androidx.media3.session.MediaSession
-import androidx.media3.session.MediaSessionService
 import androidx.media3.session.SessionCommand
 import androidx.media3.session.SessionResult
 import com.google.common.util.concurrent.Futures
@@ -27,14 +19,11 @@ import com.margelo.nitro.nitroplayer.TrackItem
 import com.margelo.nitro.nitroplayer.core.NitroPlayerLogger
 import com.margelo.nitro.nitroplayer.core.TrackPlayerCore
 import com.margelo.nitro.nitroplayer.core.loadPlaylist
-import com.margelo.nitro.nitroplayer.media.NitroPlayerMediaBrowserService
 import com.margelo.nitro.nitroplayer.playlist.PlaylistManager
 import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.SupervisorJob
 import kotlinx.coroutines.launch
-import kotlinx.coroutines.withContext
-import java.net.URL
 
 class MediaSessionManager(
     private val context: Context,
@@ -49,26 +38,19 @@ class MediaSessionManager(
 
     var mediaSession: MediaSession? = null // Make public so MediaBrowserService can access it
         private set
-    private var notificationManager: NotificationManager? = null
     private val scope = CoroutineScope(SupervisorJob() + Dispatchers.Main)
+
     @Volatile private var currentTrack: TrackItem? = null
+
     @Volatile private var isPlaying: Boolean = false
-    private val artworkCache = object : LruCache<String, Bitmap>(20) {
-        override fun sizeOf(key: String, value: Bitmap): Int = 1
-    }
 
     private var androidAutoEnabled: Boolean = false
     private var carPlayEnabled: Boolean = false
     private var showInNotification: Boolean = true
 
     companion object {
-        private const val NOTIFICATION_ID = 1001
         private const val CHANNEL_ID = "nitro_player_channel"
         private const val CHANNEL_NAME = "Music Player"
-        const val ACTION_PLAY = "com.margelo.nitro.nitroplayer.PLAY"
-        const val ACTION_PAUSE = "com.margelo.nitro.nitroplayer.PAUSE"
-        const val ACTION_NEXT = "com.margelo.nitro.nitroplayer.NEXT"
-        const val ACTION_PREVIOUS = "com.margelo.nitro.nitroplayer.PREVIOUS"
     }
 
     init {
@@ -85,10 +67,8 @@ class MediaSessionManager(
         carPlayEnabled?.let { this.carPlayEnabled = it }
         showInNotification?.let {
             this.showInNotification = it
-            if (it) {
-                updateNotification()
-            } else {
-                hideNotification()
+            if (!it) {
+                stopPlaybackService()
             }
         }
     }
@@ -273,45 +253,17 @@ class MediaSessionManager(
                             }
                         },
                     ).build()
-            // MediaSession is active by default in Media3
-            updateMediaSessionMetadata()
-        } catch (e: Exception) {
-            e.printStackTrace()
-        }
-    }
-
-    private fun updateMediaSessionMetadata() {
-        // MediaSession will automatically use the metadata from player's current MediaItem
-        // No need to manually update here as TrackPlayerCore already sets metadata
-    }
-
-    private suspend fun loadArtworkBitmap(artworkUrl: String?): Bitmap? {
-        if (artworkUrl.isNullOrEmpty()) return null
 
-        // Check cache first
-        artworkCache.get(artworkUrl)?.let { return it }
-
-        return try {
-            val bitmap =
-                withContext(Dispatchers.IO) {
-                    val url = URL(artworkUrl)
-                    BitmapFactory.decodeStream(url.openConnection().getInputStream())
-                }
-            // Cache the bitmap
-            if (bitmap != null) {
-                artworkCache.put(artworkUrl, bitmap)
-            }
-            bitmap
+            // Wire the session into the PlaybackService so it can be promoted to foreground
+            NitroPlayerPlaybackService.mediaSession = mediaSession
         } catch (e: Exception) {
             e.printStackTrace()
-            null
         }
     }
 
     private fun createNotificationChannel() {
-        notificationManager = context.getSystemService(Context.NOTIFICATION_SERVICE) as NotificationManager
-
         if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
+            val manager = context.getSystemService(Context.NOTIFICATION_SERVICE) as NotificationManager
             val channel =
                 NotificationChannel(
                     CHANNEL_ID,
@@ -322,150 +274,50 @@ class MediaSessionManager(
                     setShowBadge(false)
                     lockscreenVisibility = Notification.VISIBILITY_PUBLIC
                 }
-
-            notificationManager?.createNotificationChannel(channel)
+            manager.createNotificationChannel(channel)
         }
     }
 
-    private fun getCurrentTrack(): TrackItem? = currentTrack
-
-    private fun updateNotification() {
-        if (!showInNotification) return
-
-        val currentTrack = getCurrentTrack()
-        val notification = buildNotification(currentTrack)
-        notificationManager?.notify(NOTIFICATION_ID, notification)
-    }
-
-    private fun buildNotification(track: TrackItem?): Notification {
-        val mediaSession = this.mediaSession ?: return createEmptyNotification()
-
-        // Launch intent
-        val contentIntent =
-            PendingIntent.getActivity(
-                context,
-                0,
-                context.packageManager.getLaunchIntentForPackage(context.packageName),
-                PendingIntent.FLAG_UPDATE_CURRENT or PendingIntent.FLAG_IMMUTABLE,
-            )
-
-        val builder =
-            NotificationCompat
-                .Builder(context, CHANNEL_ID)
-                .setContentTitle(track?.title ?: "Unknown Title")
-                .setContentText(track?.artist ?: "Unknown Artist")
-                .setSubText(track?.album ?: "")
-                .setSmallIcon(android.R.drawable.ic_media_play)
-                .setContentIntent(contentIntent)
-                .setVisibility(NotificationCompat.VISIBILITY_PUBLIC)
-                .setOngoing(isPlaying)
-                .setShowWhen(false)
-                .setPriority(NotificationCompat.PRIORITY_LOW)
-                .setCategory(NotificationCompat.CATEGORY_TRANSPORT)
+    private fun startPlaybackService() {
         try {
-            val compatToken =
-                android.support.v4.media.session.MediaSessionCompat.Token
-                    .fromToken(mediaSession.platformToken)
-            builder.setStyle(
-                androidx.media.app.NotificationCompat
-                    .MediaStyle()
-                    .setMediaSession(compatToken)
-                    .setShowActionsInCompactView(0, 1, 2),
-            )
-        } catch (e: Exception) {
-            NitroPlayerLogger.log("MediaSessionManager") { "Failed to set media session token: ${e.message}" }
-        }
-
-        // Add action buttons
-        builder.addAction(
-            android.R.drawable.ic_media_previous,
-            "Previous",
-            createMediaAction(ACTION_PREVIOUS),
-        )
-
-        if (isPlaying) {
-            builder.addAction(
-                android.R.drawable.ic_media_pause,
-                "Pause",
-                createMediaAction(ACTION_PAUSE),
-            )
-        } else {
-            builder.addAction(
-                android.R.drawable.ic_media_play,
-                "Play",
-                createMediaAction(ACTION_PLAY),
-            )
-        }
-
-        builder.addAction(
-            android.R.drawable.ic_media_next,
-            "Next",
-            createMediaAction(ACTION_NEXT),
-        )
-
-        // Load artwork asynchronously and update notification
-        track?.artwork?.asSecondOrNull()?.let { artworkUrl ->
-            scope.launch {
-                val bitmap = loadArtworkBitmap(artworkUrl)
-                if (bitmap != null) {
-                    builder.setLargeIcon(bitmap)
-                    notificationManager?.notify(NOTIFICATION_ID, builder.build())
-                }
+            val intent = Intent(context, NitroPlayerPlaybackService::class.java)
+            if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
+                context.startForegroundService(intent)
+            } else {
+                context.startService(intent)
             }
+        } catch (e: Exception) {
+            NitroPlayerLogger.log("MediaSessionManager") { "Failed to start PlaybackService: ${e.message}" }
         }
-
-        return builder.build()
-    }
-
-    private fun createEmptyNotification(): Notification =
-        NotificationCompat
-            .Builder(context, CHANNEL_ID)
-            .setContentTitle("Music Player")
-            .setSmallIcon(android.R.drawable.ic_media_play)
-            .build()
-
-    private fun createMediaAction(action: String): PendingIntent {
-        val intent =
-            Intent(action).apply {
-                setPackage(context.packageName)
-            }
-        return PendingIntent.getBroadcast(
-            context,
-            0,
-            intent,
-            PendingIntent.FLAG_UPDATE_CURRENT or PendingIntent.FLAG_IMMUTABLE,
-        )
     }
 
-    private fun hideNotification() {
-        notificationManager?.cancel(NOTIFICATION_ID)
+    private fun stopPlaybackService() {
+        try {
+            val intent = Intent(context, NitroPlayerPlaybackService::class.java)
+            context.stopService(intent)
+        } catch (e: Exception) {
+            NitroPlayerLogger.log("MediaSessionManager") { "Failed to stop PlaybackService: ${e.message}" }
+        }
     }
 
     fun onTrackChanged(track: TrackItem?) {
         currentTrack = track
-        // Preload artwork for better notification display
-        if (track != null) {
-            scope.launch {
-                track.artwork?.asSecondOrNull()?.let { artworkUrl ->
-                    loadArtworkBitmap(artworkUrl)
-                }
-                updateNotification()
-            }
-        } else {
-            updateNotification()
-        }
     }
 
     fun onPlaybackStateChanged(playing: Boolean) {
         isPlaying = playing
-        updateNotification()
+        if (playing && showInNotification) {
+            startPlaybackService()
+        } else if (!playing) {
+            stopPlaybackService()
+        }
     }
 
     fun release() {
-        hideNotification()
+        stopPlaybackService()
+        NitroPlayerPlaybackService.mediaSession = null
         mediaSession?.release()
         mediaSession = null
-        artworkCache.evictAll()
     }
 
     private fun createMediaItem(

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

@@ -0,0 +1,40 @@
+package com.margelo.nitro.nitroplayer.media
+
+import android.content.Intent
+import androidx.media3.session.MediaSession
+import androidx.media3.session.MediaSessionService
+import com.margelo.nitro.nitroplayer.core.NitroPlayerLogger
+
+/**
+ * Foreground service that keeps playback alive when the app is backgrounded or the screen is locked.
+ *
+ * Media3's [MediaSessionService] automatically:
+ * - Promotes to a foreground service (with notification) when playback starts
+ * - Demotes / stops when playback stops
+ * - Posts a media-style notification with transport controls
+ * - Handles media-button intents
+ */
+class NitroPlayerPlaybackService : MediaSessionService() {
+
+    companion object {
+        @Volatile
+        var mediaSession: MediaSession? = null
+    }
+
+    override fun onGetSession(controllerInfo: MediaSession.ControllerInfo): MediaSession? {
+        return mediaSession
+    }
+
+    override fun onTaskRemoved(rootIntent: Intent?) {
+        val session = mediaSession
+        if (session == null || !session.player.playWhenReady) {
+            stopSelf()
+        }
+        super.onTaskRemoved(rootIntent)
+    }
+
+    override fun onDestroy() {
+        NitroPlayerLogger.log("PlaybackService") { "Service destroyed" }
+        super.onDestroy()
+    }
+}