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

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

@@ -0,0 +1,200 @@
+@file:Suppress("ktlint:standard:max-line-length")
+
+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.os.Build
+import android.os.Bundle
+import android.util.LruCache
+import android.view.KeyEvent
+import androidx.core.app.NotificationCompat
+import androidx.media3.common.util.UnstableApi
+import androidx.media3.session.CommandButton
+import androidx.media3.session.MediaNotification
+import androidx.media3.session.MediaSession
+import com.google.common.collect.ImmutableList
+import com.margelo.nitro.nitroplayer.core.NitroPlayerLogger
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.SupervisorJob
+import kotlinx.coroutines.launch
+import kotlinx.coroutines.withContext
+import java.net.URL
+
+/**
+ * Custom notification provider that manually builds a [MediaStyle][androidx.media.app.NotificationCompat.MediaStyle]
+ * notification with artwork, title, artist, and transport controls — matching
+ * the proven approach from the main branch.
+ */
+@UnstableApi
+class NitroPlayerNotificationProvider(
+    private val context: Context,
+) : MediaNotification.Provider {
+    private val scope = CoroutineScope(SupervisorJob() + Dispatchers.Main)
+    private val notificationManager =
+        context.getSystemService(Context.NOTIFICATION_SERVICE) as NotificationManager
+    private val artworkCache =
+        object : LruCache<String, Bitmap>(20) {
+            override fun sizeOf(key: String, value: Bitmap): Int = 1
+        }
+
+    companion object {
+        const val NOTIFICATION_ID = 1001
+        private const val CHANNEL_ID = "nitro_player_channel"
+        private const val CHANNEL_NAME = "Music Player"
+    }
+
+    init {
+        createNotificationChannel()
+    }
+
+    override fun createNotification(
+        mediaSession: MediaSession,
+        customLayout: ImmutableList<CommandButton>,
+        actionFactory: MediaNotification.ActionFactory,
+        onNotificationChangedCallback: MediaNotification.Provider.Callback,
+    ): MediaNotification {
+        val player = mediaSession.player
+        val metadata = player.mediaMetadata
+        val isPlaying = player.isPlaying
+
+        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(metadata.title ?: "Unknown Title")
+                .setContentText(metadata.artist ?: "Unknown Artist")
+                .setSubText(metadata.albumTitle ?: "")
+                .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)
+
+        // MediaStyle with session token
+        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("NotificationProvider") { "Failed to set media session token: ${e.message}" }
+        }
+
+        // Transport actions using media button PendingIntents
+        builder.addAction(
+            android.R.drawable.ic_media_previous,
+            "Previous",
+            buildMediaButtonIntent(KeyEvent.KEYCODE_MEDIA_PREVIOUS, 0),
+        )
+
+        if (isPlaying) {
+            builder.addAction(
+                android.R.drawable.ic_media_pause,
+                "Pause",
+                buildMediaButtonIntent(KeyEvent.KEYCODE_MEDIA_PAUSE, 1),
+            )
+        } else {
+            builder.addAction(
+                android.R.drawable.ic_media_play,
+                "Play",
+                buildMediaButtonIntent(KeyEvent.KEYCODE_MEDIA_PLAY, 1),
+            )
+        }
+
+        builder.addAction(
+            android.R.drawable.ic_media_next,
+            "Next",
+            buildMediaButtonIntent(KeyEvent.KEYCODE_MEDIA_NEXT, 2),
+        )
+
+        // Load artwork async and update notification
+        metadata.artworkUri?.toString()?.let { artworkUrl ->
+            val cached = artworkCache.get(artworkUrl)
+            if (cached != null) {
+                builder.setLargeIcon(cached)
+            } else {
+                scope.launch {
+                    val bitmap = loadArtworkBitmap(artworkUrl)
+                    if (bitmap != null) {
+                        builder.setLargeIcon(bitmap)
+                        onNotificationChangedCallback.onNotificationChanged(
+                            MediaNotification(NOTIFICATION_ID, builder.build()),
+                        )
+                    }
+                }
+            }
+        }
+
+        return MediaNotification(NOTIFICATION_ID, builder.build())
+    }
+
+    override fun handleCustomCommand(
+        session: MediaSession,
+        action: String,
+        extras: Bundle,
+    ): Boolean = false
+
+    private fun buildMediaButtonIntent(keyCode: Int, requestCode: Int): PendingIntent {
+        val intent =
+            Intent(Intent.ACTION_MEDIA_BUTTON).apply {
+                putExtra(Intent.EXTRA_KEY_EVENT, KeyEvent(KeyEvent.ACTION_DOWN, keyCode))
+                setPackage(context.packageName)
+            }
+        return PendingIntent.getBroadcast(
+            context,
+            requestCode,
+            intent,
+            PendingIntent.FLAG_UPDATE_CURRENT or PendingIntent.FLAG_IMMUTABLE,
+        )
+    }
+
+    private fun createNotificationChannel() {
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
+            val channel =
+                NotificationChannel(
+                    CHANNEL_ID,
+                    CHANNEL_NAME,
+                    NotificationManager.IMPORTANCE_LOW,
+                ).apply {
+                    description = "Media playback controls"
+                    setShowBadge(false)
+                    lockscreenVisibility = Notification.VISIBILITY_PUBLIC
+                }
+            notificationManager.createNotificationChannel(channel)
+        }
+    }
+
+    private suspend fun loadArtworkBitmap(artworkUrl: String): Bitmap? {
+        artworkCache.get(artworkUrl)?.let { return it }
+        return try {
+            withContext(Dispatchers.IO) {
+                val url = URL(artworkUrl)
+                BitmapFactory.decodeStream(url.openConnection().getInputStream())
+            }?.also { artworkCache.put(artworkUrl, it) }
+        } catch (_: Exception) {
+            null
+        }
+    }
+}

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

@@ -0,0 +1,101 @@
+package com.margelo.nitro.nitroplayer.media
+
+import android.content.Intent
+import android.os.Binder
+import android.os.Handler
+import android.os.IBinder
+import android.os.Looper
+import androidx.media3.common.util.UnstableApi
+import androidx.media3.exoplayer.ExoPlayer
+import androidx.media3.session.MediaSession
+import androidx.media3.session.MediaSessionService
+import com.margelo.nitro.nitroplayer.core.NitroPlayerLogger
+import com.margelo.nitro.nitroplayer.core.TrackPlayerCore
+import com.margelo.nitro.nitroplayer.playlist.PlaylistManager
+
+/**
+ * Foreground service that **owns** the ExoPlayer and MediaSession.
+ *
+ * The player runs on the **main looper** so that Media3's
+ * [MediaSessionService] can access it directly for automatic notification
+ * management (foreground promotion, media-style notification, demotion).
+ *
+ * ExoPlayer does all heavy work (decoding, buffering, network I/O) on its
+ * own internal threads — the application looper only handles lightweight
+ * callbacks and control calls.
+ */
+@UnstableApi
+class NitroPlayerPlaybackService : MediaSessionService() {
+
+    companion object {
+        const val ACTION_LOCAL_BIND = "com.margelo.nitro.nitroplayer.LOCAL_BIND"
+    }
+
+    // ── Created in onCreate ────────────────────────────────────────────────
+    private lateinit var player: ExoPlayer
+    private var mediaSession: MediaSession? = null
+    private val mainHandler = Handler(Looper.getMainLooper())
+
+    @Volatile
+    var trackPlayerCore: TrackPlayerCore? = null
+
+    // ── Binder exposed to TrackPlayerCore ──────────────────────────────────
+    inner class LocalBinder : Binder() {
+        val service: NitroPlayerPlaybackService get() = this@NitroPlayerPlaybackService
+        val exoPlayer: ExoPlayer get() = player
+        val session: MediaSession get() = mediaSession!!
+        val handler: Handler get() = mainHandler
+    }
+
+    private val localBinder = lazy { LocalBinder() }
+
+    // ── Lifecycle ───────────────────────────────────────────────────────────
+
+    override fun onCreate() {
+        super.onCreate()
+        NitroPlayerLogger.log("PlaybackService") { "onCreate" }
+
+        // Build ExoPlayer on main looper (default)
+        player = ExoPlayerBuilder.build(this)
+
+        // Build MediaSession
+        val playlistManager = PlaylistManager.getInstance(this)
+        mediaSession = MediaSession
+            .Builder(this, player)
+            .setCallback(MediaSessionCallbackFactory.create(this, playlistManager))
+            .build()
+
+        // Explicitly register the session with the service so that
+        // MediaNotificationManager (created in super.onCreate()) can
+        // connect its internal MediaController and post notifications.
+        addSession(mediaSession!!)
+
+        // Media3 automatically handles the notification via DefaultMediaNotificationProvider.
+    }
+
+    override fun onGetSession(controllerInfo: MediaSession.ControllerInfo): MediaSession? =
+        mediaSession
+
+    override fun onBind(intent: Intent?): IBinder? {
+        if (intent?.action == ACTION_LOCAL_BIND) {
+            return localBinder.value
+        }
+        return super.onBind(intent)
+    }
+
+    override fun onTaskRemoved(rootIntent: Intent?) {
+        val session = mediaSession
+        if (session == null || !session.player.playWhenReady) {
+            stopSelf()
+        }
+        super.onTaskRemoved(rootIntent)
+    }
+
+    override fun onDestroy() {
+        NitroPlayerLogger.log("PlaybackService") { "onDestroy" }
+        mediaSession?.release()
+        mediaSession = null
+        player.release()
+        super.onDestroy()
+    }
+}

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

@@ -7,17 +7,17 @@ import com.margelo.nitro.nitroplayer.TrackItem
 import com.margelo.nitro.nitroplayer.Variant_NullType_String
 import com.margelo.nitro.nitroplayer.media.NitroPlayerMediaBrowserService
 import com.margelo.nitro.nitroplayer.storage.NitroPlayerStorage
-import org.json.JSONArray
-import org.json.JSONObject
-import java.util.UUID
-import java.util.concurrent.ConcurrentHashMap
-import java.util.concurrent.CopyOnWriteArrayList
 import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.Job
 import kotlinx.coroutines.SupervisorJob
 import kotlinx.coroutines.delay
 import kotlinx.coroutines.launch
+import org.json.JSONArray
+import org.json.JSONObject
+import java.util.UUID
+import java.util.concurrent.ConcurrentHashMap
+import java.util.concurrent.CopyOnWriteArrayList
 
 /**
  * Manages multiple playlists using ExoPlayer's native playlist functionality
@@ -36,10 +36,11 @@ class PlaylistManager private constructor(
 
     private fun scheduleSave() {
         saveJob?.cancel()
-        saveJob = saveScope.launch {
-            delay(300)
-            saveToFile()
-        }
+        saveJob =
+            saveScope.launch {
+                delay(300)
+                saveToFile()
+            }
     }
 
     companion object {
@@ -357,32 +358,33 @@ class PlaylistManager private constructor(
         try {
             val jsonArray = JSONArray()
             playlists.values.forEach { playlist ->
-                val jsonObject = JSONObject().apply {
-                    put("id", playlist.id)
-                    put("name", playlist.name)
-                    put("description", playlist.description ?: "")
-                    put("artwork", playlist.artwork ?: "")
-                    val tracksArray = JSONArray()
-                    playlist.tracks.forEach { track ->
-                        tracksArray.put(
-                            JSONObject().apply {
-                                put("id", track.id)
-                                put("title", track.title)
-                                put("artist", track.artist)
-                                put("album", track.album)
-                                put("duration", track.duration)
-                                put("url", track.url)
-                                track.artwork?.let { put("artwork", it) }
-                                track.extraPayload?.let { payload ->
-                                    val extraPayloadMap = payload.toHashMap()
-                                    val extraPayloadJson = JSONObject(extraPayloadMap)
-                                    put("extraPayload", extraPayloadJson)
-                                }
-                            },
-                        )
+                val jsonObject =
+                    JSONObject().apply {
+                        put("id", playlist.id)
+                        put("name", playlist.name)
+                        put("description", playlist.description ?: "")
+                        put("artwork", playlist.artwork ?: "")
+                        val tracksArray = JSONArray()
+                        playlist.tracks.forEach { track ->
+                            tracksArray.put(
+                                JSONObject().apply {
+                                    put("id", track.id)
+                                    put("title", track.title)
+                                    put("artist", track.artist)
+                                    put("album", track.album)
+                                    put("duration", track.duration)
+                                    put("url", track.url)
+                                    track.artwork?.let { put("artwork", it) }
+                                    track.extraPayload?.let { payload ->
+                                        val extraPayloadMap = payload.toHashMap()
+                                        val extraPayloadJson = JSONObject(extraPayloadMap)
+                                        put("extraPayload", extraPayloadJson)
+                                    }
+                                },
+                            )
+                        }
+                        put("tracks", tracksArray)
                     }
-                    put("tracks", tracksArray)
-                }
                 jsonArray.put(jsonObject)
             }
 
@@ -445,59 +447,59 @@ class PlaylistManager private constructor(
     private fun parseAndLoadPlaylists(jsonArray: JSONArray) {
         playlists.clear()
         for (i in 0 until jsonArray.length()) {
-                val jsonObject = jsonArray.getJSONObject(i)
-                val tracks = mutableListOf<TrackItem>()
-                val tracksArray = jsonObject.getJSONArray("tracks")
-                for (j in 0 until tracksArray.length()) {
-                    val trackObj = tracksArray.getJSONObject(j)
-                    val artworkStr = trackObj.optString("artwork")
-                    val artwork: Variant_NullType_String? =
-                        if (!artworkStr.isNullOrEmpty()) {
-                            Variant_NullType_String.create(artworkStr)
-                        } else {
-                            null
-                        }
-                    val extraPayload: AnyMap? =
-                        if (trackObj.has("extraPayload")) {
-                            val extraPayloadJson = trackObj.getJSONObject("extraPayload")
-                            val map = AnyMap()
-                            val keyIterator = extraPayloadJson.keys()
-                            while (keyIterator.hasNext()) {
-                                val key = keyIterator.next()
-                                when (val value = extraPayloadJson.get(key)) {
-                                    is String -> map.setString(key, value)
-                                    is Number -> map.setDouble(key, value.toDouble())
-                                    is Boolean -> map.setBoolean(key, value)
-                                }
+            val jsonObject = jsonArray.getJSONObject(i)
+            val tracks = mutableListOf<TrackItem>()
+            val tracksArray = jsonObject.getJSONArray("tracks")
+            for (j in 0 until tracksArray.length()) {
+                val trackObj = tracksArray.getJSONObject(j)
+                val artworkStr = trackObj.optString("artwork")
+                val artwork: Variant_NullType_String? =
+                    if (!artworkStr.isNullOrEmpty()) {
+                        Variant_NullType_String.create(artworkStr)
+                    } else {
+                        null
+                    }
+                val extraPayload: AnyMap? =
+                    if (trackObj.has("extraPayload")) {
+                        val extraPayloadJson = trackObj.getJSONObject("extraPayload")
+                        val map = AnyMap()
+                        val keyIterator = extraPayloadJson.keys()
+                        while (keyIterator.hasNext()) {
+                            val key = keyIterator.next()
+                            when (val value = extraPayloadJson.get(key)) {
+                                is String -> map.setString(key, value)
+                                is Number -> map.setDouble(key, value.toDouble())
+                                is Boolean -> map.setBoolean(key, value)
                             }
-                            map
-                        } else {
-                            null
                         }
-                    tracks.add(
-                        TrackItem(
-                            id = trackObj.getString("id"),
-                            title = trackObj.getString("title"),
-                            artist = trackObj.getString("artist"),
-                            album = trackObj.getString("album"),
-                            duration = trackObj.getDouble("duration"),
-                            url = trackObj.getString("url"),
-                            artwork = artwork,
-                            extraPayload = extraPayload,
-                        ),
-                    )
-                }
-                val descriptionStr = jsonObject.optString("description")
-                val artworkStr = jsonObject.optString("artwork")
-                val playlist =
-                    Playlist(
-                        id = jsonObject.getString("id"),
-                        name = jsonObject.getString("name"),
-                        description = if (!descriptionStr.isNullOrEmpty()) descriptionStr else null,
-                        artwork = if (!artworkStr.isNullOrEmpty()) artworkStr else null,
-                        tracks = tracks,
-                    )
-                playlists[playlist.id] = playlist
+                        map
+                    } else {
+                        null
+                    }
+                tracks.add(
+                    TrackItem(
+                        id = trackObj.getString("id"),
+                        title = trackObj.getString("title"),
+                        artist = trackObj.getString("artist"),
+                        album = trackObj.getString("album"),
+                        duration = trackObj.getDouble("duration"),
+                        url = trackObj.getString("url"),
+                        artwork = artwork,
+                        extraPayload = extraPayload,
+                    ),
+                )
+            }
+            val descriptionStr = jsonObject.optString("description")
+            val artworkStr = jsonObject.optString("artwork")
+            val playlist =
+                Playlist(
+                    id = jsonObject.getString("id"),
+                    name = jsonObject.getString("name"),
+                    description = if (!descriptionStr.isNullOrEmpty()) descriptionStr else null,
+                    artwork = if (!artworkStr.isNullOrEmpty()) artworkStr else null,
+                    tracks = tracks,
+                )
+            playlists[playlist.id] = playlist
         }
     }
 }

package/ios/core/TrackPlayerQueueBuild.swift

@@ -216,13 +216,19 @@ extension TrackPlayerCore {
     guard let player = self.player else { return }
 
     let currentItem = player.currentItem
+
+    guard let playingTrackId = currentItem?.trackId else {
+      NitroPlayerLogger.log("TrackPlayerCore", "❌ No current item or track ID found during queue rebuild")
+      return
+    }
+
     let playingItems = player.items()
 
     // If the currently playing AVPlayerItem is no longer in currentTracks,
     // delegate to rebuildQueueFromPlaylistIndex so the player immediately
     // starts what is now at currentTrackIndex in the updated list.
-    if let playingTrackId = currentItem?.trackId,
-      !currentTracks.contains(where: { $0.id == playingTrackId }) {
+    if !currentTracks.contains(where: { $0.id == playingTrackId }) &&
+      currentTemporaryType == .none {
       let targetIndex = currentTrackIndex < currentTracks.count
         ? currentTrackIndex : currentTracks.count - 1
       if targetIndex >= 0 {
@@ -231,6 +237,14 @@ extension TrackPlayerCore {
       return
     }
 
+    // Sync currentTrackIndex to the track's actual position after a playlist mutation
+    // (e.g. reorder). Without this, the remaining-tracks slice uses the stale index,
+    // causing wrong tracks to play after skip/next.
+    if currentTemporaryType == .none,
+      let newIndex = currentTracks.firstIndex(where: { $0.id == playingTrackId }) {
+      currentTrackIndex = newIndex
+    }
+
     // Build the desired upcoming track list
     var newQueueTracks: [TrackItem] = []
     let currentId = currentItem?.trackId

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "react-native-nitro-player",
-  "version": "0.7.1-alpha.1",
+  "version": "0.7.1-alpha.3",
   "description": "A powerful audio player library for React Native with playlist management, playback controls, and support for Android Auto and CarPlay",
   "main": "lib/index",
   "module": "lib/index",

package/src/hooks/useEqualizer.ts

@@ -142,18 +142,21 @@ export function useEqualizer(): UseEqualizerResult {
     []
   )
 
-  const setAllBandGains = useCallback(async (gains: number[]): Promise<boolean> => {
-    setBands((prevBands) =>
-      prevBands.map((b, i) => ({ ...b, gainDb: gains[i] ?? b.gainDb }))
-    )
-    try {
-      await Equalizer.setAllBandGains(gains)
-      return true
-    } catch (error) {
-      console.error('[useEqualizer] Error setting all band gains:', error)
-      return false
-    }
-  }, [])
+  const setAllBandGains = useCallback(
+    async (gains: number[]): Promise<boolean> => {
+      setBands((prevBands) =>
+        prevBands.map((b, i) => ({ ...b, gainDb: gains[i] ?? b.gainDb }))
+      )
+      try {
+        await Equalizer.setAllBandGains(gains)
+        return true
+      } catch (error) {
+        console.error('[useEqualizer] Error setting all band gains:', error)
+        return false
+      }
+    },
+    []
+  )
 
   const reset = useCallback(async () => {
     setBands((prevBands) => prevBands.map((b) => ({ ...b, gainDb: 0 })))

package/src/specs/AndroidAutoMediaLibrary.nitro.ts

@@ -4,8 +4,9 @@ import type { HybridObject } from 'react-native-nitro-modules'
  * Android Auto Media Library Manager
  * Android-only HybridObject for managing Android Auto media browser structure
  */
-export interface AndroidAutoMediaLibrary
-  extends HybridObject<{ android: 'kotlin' }> {
+export interface AndroidAutoMediaLibrary extends HybridObject<{
+  android: 'kotlin'
+}> {
   /**
    * Set the Android Auto media library structure
    * This defines what folders and playlists appear in Android Auto

package/src/specs/DownloadManager.nitro.ts

@@ -13,8 +13,10 @@ import type {
   PlaybackSource,
 } from '../types/DownloadTypes'
 
-export interface DownloadManager
-  extends HybridObject<{ android: 'kotlin'; ios: 'swift' }> {
+export interface DownloadManager extends HybridObject<{
+  android: 'kotlin'
+  ios: 'swift'
+}> {
   /**
    * Configure the download manager
    */

package/src/specs/Equalizer.nitro.ts

@@ -6,8 +6,10 @@ import type {
   GainRange,
 } from '../types/EqualizerTypes'
 
-export interface Equalizer
-  extends HybridObject<{ android: 'kotlin'; ios: 'swift' }> {
+export interface Equalizer extends HybridObject<{
+  android: 'kotlin'
+  ios: 'swift'
+}> {
   // === Enable/Disable ===
   /** Enable or disable the equalizer */
   setEnabled(enabled: boolean): Promise<void>