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

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

@@ -11,16 +11,17 @@ import com.margelo.nitro.nitroplayer.TrackItem
 
 // ── Playlist loading ──────────────────────────────────────────────────────
 
-suspend fun TrackPlayerCore.loadPlaylist(playlistId: String) = withPlayerContext {
-    playNextStack.clear()
-    upNextQueue.clear()
-    currentTemporaryType = TrackPlayerCore.TemporaryType.NONE
-    val playlist = playlistManager.getPlaylist(playlistId) ?: return@withPlayerContext
-    currentPlaylistId = playlistId
-    updatePlayerQueue(playlist.tracks)
-    checkUpcomingTracksForUrls(lookaheadCount)
-    notifyTemporaryQueueChange()
-}
+suspend fun TrackPlayerCore.loadPlaylist(playlistId: String) =
+    withPlayerContext {
+        playNextStack.clear()
+        upNextQueue.clear()
+        currentTemporaryType = TrackPlayerCore.TemporaryType.NONE
+        val playlist = playlistManager.getPlaylist(playlistId) ?: return@withPlayerContext
+        currentPlaylistId = playlistId
+        updatePlayerQueue(playlist.tracks)
+        checkUpcomingTracksForUrls(lookaheadCount)
+        notifyTemporaryQueueChange()
+    }
 
 /**
  * Debounced update — coalesces rapid back-to-back mutations into one player rebuild.
@@ -37,8 +38,9 @@ fun TrackPlayerCore.updatePlaylist(playlistId: String) {
 suspend fun TrackPlayerCore.playNext(trackId: String) = withPlayerContext { playNextInternal(trackId) }
 
 internal fun TrackPlayerCore.playNextInternal(trackId: String) {
-    val track = findTrackById(trackId)
-        ?: throw IllegalArgumentException("Track $trackId not found")
+    val track =
+        findTrackById(trackId)
+            ?: throw IllegalArgumentException("Track $trackId not found")
     playNextStack.add(0, track)
     if (isExoInitialized && exo.currentMediaItem != null) rebuildQueueFromCurrentPosition()
     notifyTemporaryQueueChange()
@@ -49,8 +51,9 @@ internal fun TrackPlayerCore.playNextInternal(trackId: String) {
 suspend fun TrackPlayerCore.addToUpNext(trackId: String) = withPlayerContext { addToUpNextInternal(trackId) }
 
 internal fun TrackPlayerCore.addToUpNextInternal(trackId: String) {
-    val track = findTrackById(trackId)
-        ?: throw IllegalArgumentException("Track $trackId not found")
+    val track =
+        findTrackById(trackId)
+            ?: throw IllegalArgumentException("Track $trackId not found")
     upNextQueue.add(track)
     if (isExoInitialized && exo.currentMediaItem != null) rebuildQueueFromCurrentPosition()
     notifyTemporaryQueueChange()
@@ -58,35 +61,39 @@ internal fun TrackPlayerCore.addToUpNextInternal(trackId: String) {
 
 // ── Remove / clear ────────────────────────────────────────────────────────
 
-suspend fun TrackPlayerCore.removeFromPlayNext(trackId: String): Boolean = withPlayerContext {
-    val idx = playNextStack.indexOfFirst { it.id == trackId }
-    if (idx < 0) return@withPlayerContext false
-    playNextStack.removeAt(idx)
-    if (isExoInitialized && exo.currentMediaItem != null) rebuildQueueFromCurrentPosition()
-    notifyTemporaryQueueChange()
-    true
-}
-
-suspend fun TrackPlayerCore.removeFromUpNext(trackId: String): Boolean = withPlayerContext {
-    val idx = upNextQueue.indexOfFirst { it.id == trackId }
-    if (idx < 0) return@withPlayerContext false
-    upNextQueue.removeAt(idx)
-    if (isExoInitialized && exo.currentMediaItem != null) rebuildQueueFromCurrentPosition()
-    notifyTemporaryQueueChange()
-    true
-}
-
-suspend fun TrackPlayerCore.clearPlayNext() = withPlayerContext {
-    playNextStack.clear()
-    if (isExoInitialized && exo.currentMediaItem != null) rebuildQueueFromCurrentPosition()
-    notifyTemporaryQueueChange()
-}
-
-suspend fun TrackPlayerCore.clearUpNext() = withPlayerContext {
-    upNextQueue.clear()
-    if (isExoInitialized && exo.currentMediaItem != null) rebuildQueueFromCurrentPosition()
-    notifyTemporaryQueueChange()
-}
+suspend fun TrackPlayerCore.removeFromPlayNext(trackId: String): Boolean =
+    withPlayerContext {
+        val idx = playNextStack.indexOfFirst { it.id == trackId }
+        if (idx < 0) return@withPlayerContext false
+        playNextStack.removeAt(idx)
+        if (isExoInitialized && exo.currentMediaItem != null) rebuildQueueFromCurrentPosition()
+        notifyTemporaryQueueChange()
+        true
+    }
+
+suspend fun TrackPlayerCore.removeFromUpNext(trackId: String): Boolean =
+    withPlayerContext {
+        val idx = upNextQueue.indexOfFirst { it.id == trackId }
+        if (idx < 0) return@withPlayerContext false
+        upNextQueue.removeAt(idx)
+        if (isExoInitialized && exo.currentMediaItem != null) rebuildQueueFromCurrentPosition()
+        notifyTemporaryQueueChange()
+        true
+    }
+
+suspend fun TrackPlayerCore.clearPlayNext() =
+    withPlayerContext {
+        playNextStack.clear()
+        if (isExoInitialized && exo.currentMediaItem != null) rebuildQueueFromCurrentPosition()
+        notifyTemporaryQueueChange()
+    }
+
+suspend fun TrackPlayerCore.clearUpNext() =
+    withPlayerContext {
+        upNextQueue.clear()
+        if (isExoInitialized && exo.currentMediaItem != null) rebuildQueueFromCurrentPosition()
+        notifyTemporaryQueueChange()
+    }
 
 // ── Reorder ───────────────────────────────────────────────────────────────
 
@@ -94,25 +101,29 @@ suspend fun TrackPlayerCore.clearUpNext() = withPlayerContext {
  * Reorder within the combined virtual list [playNextStack + upNextQueue].
  * newIndex is 0-based within that combined list.
  */
-suspend fun TrackPlayerCore.reorderTemporaryTrack(trackId: String, newIndex: Int): Boolean = withPlayerContext {
-    val combined = (playNextStack + upNextQueue).toMutableList()
-    val fromIdx = combined.indexOfFirst { it.id == trackId }
-    if (fromIdx < 0) return@withPlayerContext false
-    val track = combined.removeAt(fromIdx)
-    val clampedIndex = newIndex.coerceIn(0, combined.size)
-    combined.add(clampedIndex, track)
-
-    // Split back at original playNextStack.size boundary (reduced if an item was moved out)
-    val pnSize = playNextStack.size
-    playNextStack.clear()
-    upNextQueue.clear()
-    playNextStack.addAll(combined.take(pnSize))
-    upNextQueue.addAll(combined.drop(pnSize))
-
-    if (isExoInitialized && exo.currentMediaItem != null) rebuildQueueFromCurrentPosition()
-    notifyTemporaryQueueChange()
-    true
-}
+suspend fun TrackPlayerCore.reorderTemporaryTrack(
+    trackId: String,
+    newIndex: Int,
+): Boolean =
+    withPlayerContext {
+        val combined = (playNextStack + upNextQueue).toMutableList()
+        val fromIdx = combined.indexOfFirst { it.id == trackId }
+        if (fromIdx < 0) return@withPlayerContext false
+        val track = combined.removeAt(fromIdx)
+        val clampedIndex = newIndex.coerceIn(0, combined.size)
+        combined.add(clampedIndex, track)
+
+        // Split back at original playNextStack.size boundary (reduced if an item was moved out)
+        val pnSize = playNextStack.size
+        playNextStack.clear()
+        upNextQueue.clear()
+        playNextStack.addAll(combined.take(pnSize))
+        upNextQueue.addAll(combined.drop(pnSize))
+
+        if (isExoInitialized && exo.currentMediaItem != null) rebuildQueueFromCurrentPosition()
+        notifyTemporaryQueueChange()
+        true
+    }
 
 // ── Read-only accessors ────────────────────────────────────────────────────
 

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

@@ -111,6 +111,7 @@ class DownloadManagerCore private constructor(
             workDataOf(
                 DownloadWorker.KEY_DOWNLOAD_ID to downloadId,
                 DownloadWorker.KEY_TRACK_ID to track.id,
+                DownloadWorker.KEY_TRACK_TITLE to track.title,
                 DownloadWorker.KEY_URL to track.url,
                 DownloadWorker.KEY_PLAYLIST_ID to (playlistId ?: ""),
                 DownloadWorker.KEY_STORAGE_LOCATION to (config.storageLocation?.name ?: StorageLocation.PRIVATE.name),
@@ -169,6 +170,7 @@ class DownloadManagerCore private constructor(
                 workDataOf(
                     DownloadWorker.KEY_DOWNLOAD_ID to downloadId,
                     DownloadWorker.KEY_TRACK_ID to track.id,
+                    DownloadWorker.KEY_TRACK_TITLE to track.title,
                     DownloadWorker.KEY_URL to track.url,
                     DownloadWorker.KEY_PLAYLIST_ID to (playlistId ?: ""),
                     DownloadWorker.KEY_STORAGE_LOCATION to (config.storageLocation?.name ?: StorageLocation.PRIVATE.name),
@@ -236,9 +238,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/download/DownloadWorker.kt

@@ -13,7 +13,6 @@ import com.margelo.nitro.nitroplayer.*
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.withContext
 import java.io.BufferedInputStream
-import java.io.File
 import java.io.FileOutputStream
 import java.net.HttpURLConnection
 import java.net.URL
@@ -28,26 +27,34 @@ class DownloadWorker(
     companion object {
         const val KEY_DOWNLOAD_ID = "download_id"
         const val KEY_TRACK_ID = "track_id"
+        const val KEY_TRACK_TITLE = "track_title"
         const val KEY_URL = "url"
         const val KEY_PLAYLIST_ID = "playlist_id"
         const val KEY_STORAGE_LOCATION = "storage_location"
 
         private const val NOTIFICATION_CHANNEL_ID = "nitro_player_downloads"
-        private const val NOTIFICATION_ID = 2001
+        private const val BASE_NOTIFICATION_ID = 2001
         private const val BUFFER_SIZE = 8192
         private val CONTENT_DISPOSITION_REGEX = Regex("filename=\"?([^\";]+)\"?")
     }
 
     private val downloadManager = DownloadManagerCore.getInstance(context)
     private val fileManager = DownloadFileManager.getInstance(context)
+    private val notificationManager =
+        context.getSystemService(Context.NOTIFICATION_SERVICE) as NotificationManager
+    /** Stable notification ID per download — derived from trackId hash. */
+    private var notificationId = BASE_NOTIFICATION_ID
 
     override suspend fun doWork(): Result =
         withContext(Dispatchers.IO) {
             val downloadId = inputData.getString(KEY_DOWNLOAD_ID) ?: return@withContext Result.failure()
             val trackId = inputData.getString(KEY_TRACK_ID) ?: return@withContext Result.failure()
+            val trackTitle = inputData.getString(KEY_TRACK_TITLE) ?: "Unknown track"
             val urlString = inputData.getString(KEY_URL) ?: return@withContext Result.failure()
             val storageLocationStr = inputData.getString(KEY_STORAGE_LOCATION) ?: StorageLocation.PRIVATE.name
 
+            notificationId = BASE_NOTIFICATION_ID + trackId.hashCode().and(0xFFFF)
+
             val storageLocation =
                 try {
                     StorageLocation.valueOf(storageLocationStr)
@@ -56,14 +63,21 @@ class DownloadWorker(
                 }
 
             try {
-                // Set foreground notification
-                setForeground(createForegroundInfo(trackId))
+                // Set foreground notification — if POST_NOTIFICATIONS is denied,
+                // WorkManager still runs the task; the notification just won't show.
+                try {
+                    setForeground(createForegroundInfo(trackTitle, 0, true))
+                } catch (_: Exception) {
+                    // Foreground promotion failed (e.g. missing permission on some OEMs).
+                    // Download continues in background.
+                }
 
                 // Perform download
-                val localPath = downloadFile(downloadId, trackId, urlString, storageLocation)
+                val localPath = downloadFile(downloadId, trackId, trackTitle, urlString, storageLocation)
 
                 if (localPath != null) {
                     downloadManager.onComplete(downloadId, trackId, localPath)
+                    showCompletionNotification(trackTitle)
                     Result.success()
                 } else {
                     val error =
@@ -74,6 +88,7 @@ class DownloadWorker(
                             isRetryable = true,
                         )
                     downloadManager.onError(downloadId, trackId, error)
+                    showErrorNotification(trackTitle)
                     Result.retry()
                 }
             } catch (e: Exception) {
@@ -93,6 +108,7 @@ class DownloadWorker(
                         isRetryable = errorReason in listOf(DownloadErrorReason.NETWORK_ERROR, DownloadErrorReason.TIMEOUT),
                     )
                 downloadManager.onError(downloadId, trackId, error)
+                showErrorNotification(trackTitle)
 
                 if (error.isRetryable) {
                     Result.retry()
@@ -105,6 +121,7 @@ class DownloadWorker(
     private suspend fun downloadFile(
         downloadId: String,
         trackId: String,
+        trackTitle: String,
         urlString: String,
         storageLocation: StorageLocation,
     ): String? =
@@ -167,10 +184,12 @@ class DownloadWorker(
                     outputStream.write(buffer, 0, bytesRead)
                     bytesDownloaded += bytesRead
 
-                    // Update progress every 250ms
+                    // Update progress every 250ms — both the callback and the notification
                     val now = System.currentTimeMillis()
                     if (now - lastProgressUpdate >= 250) {
                         downloadManager.onProgress(downloadId, trackId, bytesDownloaded, totalBytes)
+                        val percent = if (totalBytes > 0) ((bytesDownloaded * 100) / totalBytes).toInt() else 0
+                        updateProgressNotification(trackTitle, percent)
                         lastProgressUpdate = now
                     }
                 }
@@ -194,31 +213,85 @@ class DownloadWorker(
             }
         }
 
-    private fun createForegroundInfo(trackId: String): ForegroundInfo {
-        createNotificationChannel()
+    // ── Notification helpers ──────────────────────────────────────────────
+
+    private fun createForegroundInfo(
+        trackTitle: String,
+        percent: Int,
+        indeterminate: Boolean,
+    ): ForegroundInfo {
+        ensureNotificationChannel()
 
-        val notification =
-            NotificationCompat
-                .Builder(context, NOTIFICATION_CHANNEL_ID)
-                .setContentTitle("Downloading")
-                .setContentText("Downloading track...")
-                .setSmallIcon(android.R.drawable.stat_sys_download)
-                .setOngoing(true)
-                .setProgress(100, 0, true)
-                .build()
+        val notification = buildProgressNotification(trackTitle, percent, indeterminate)
 
         return if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.UPSIDE_DOWN_CAKE) {
             ForegroundInfo(
-                NOTIFICATION_ID,
+                notificationId,
                 notification,
                 android.content.pm.ServiceInfo.FOREGROUND_SERVICE_TYPE_DATA_SYNC,
             )
         } else {
-            ForegroundInfo(NOTIFICATION_ID, notification)
+            ForegroundInfo(notificationId, notification)
+        }
+    }
+
+    private fun buildProgressNotification(
+        trackTitle: String,
+        percent: Int,
+        indeterminate: Boolean,
+    ) = NotificationCompat
+        .Builder(context, NOTIFICATION_CHANNEL_ID)
+        .setContentTitle("Downloading")
+        .setContentText(trackTitle)
+        .setSubText(if (!indeterminate) "$percent%" else null)
+        .setSmallIcon(android.R.drawable.stat_sys_download)
+        .setOngoing(true)
+        .setOnlyAlertOnce(true)
+        .setProgress(100, percent, indeterminate)
+        .build()
+
+    private fun updateProgressNotification(trackTitle: String, percent: Int) {
+        try {
+            notificationManager.notify(
+                notificationId,
+                buildProgressNotification(trackTitle, percent, false),
+            )
+        } catch (_: SecurityException) {
+            // POST_NOTIFICATIONS not granted — download continues silently
         }
     }
 
-    private fun createNotificationChannel() {
+    private fun showCompletionNotification(trackTitle: String) {
+        try {
+            notificationManager.notify(
+                notificationId,
+                NotificationCompat
+                    .Builder(context, NOTIFICATION_CHANNEL_ID)
+                    .setContentTitle("Download complete")
+                    .setContentText(trackTitle)
+                    .setSmallIcon(android.R.drawable.stat_sys_download_done)
+                    .setAutoCancel(true)
+                    .build(),
+            )
+        } catch (_: SecurityException) { }
+    }
+
+    private fun showErrorNotification(trackTitle: String) {
+        try {
+            notificationManager.notify(
+                notificationId,
+                NotificationCompat
+                    .Builder(context, NOTIFICATION_CHANNEL_ID)
+                    .setContentTitle("Download failed")
+                    .setContentText(trackTitle)
+                    .setSmallIcon(android.R.drawable.stat_notify_error)
+                    .setAutoCancel(true)
+                    .build(),
+            )
+        } catch (_: SecurityException) { }
+    }
+
+    private fun ensureNotificationChannel() {
         if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
             val channel =
                 NotificationChannel(
@@ -228,9 +301,7 @@ class DownloadWorker(
                 ).apply {
                     description = "Download progress notifications"
                 }
-
-            val notificationManager = context.getSystemService(NotificationManager::class.java)
-            notificationManager?.createNotificationChannel(channel)
+            notificationManager.createNotificationChannel(channel)
         }
     }
 }