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

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

@@ -1,28 +1,86 @@
 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 keeps playback alive when the app is backgrounded or the screen is locked.
+ * Foreground service that **owns** the ExoPlayer and MediaSession.
  *
- * 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
+ * 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 {
-        @Volatile
-        var mediaSession: MediaSession? = null
+        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
     }
 
-    override fun onGetSession(controllerInfo: MediaSession.ControllerInfo): MediaSession? {
-        return mediaSession
+    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?) {
@@ -34,7 +92,10 @@ class NitroPlayerPlaybackService : MediaSessionService() {
     }
 
     override fun onDestroy() {
-        NitroPlayerLogger.log("PlaybackService") { "Service destroyed" }
+        NitroPlayerLogger.log("PlaybackService") { "onDestroy" }
+        mediaSession?.release()
+        mediaSession = null
+        player.release()
         super.onDestroy()
     }
 }

package/ios/core/TrackPlayerListener.swift

@@ -79,14 +79,16 @@ extension TrackPlayerCore {
       currentItem.status == .readyToPlay else { return }
 
     let duration = currentItem.duration.seconds
-    guard duration > 0 && !duration.isNaN && !duration.isInfinite else { return }
-
     let interval: Double
-    if duration > Constants.twoHoursInSeconds { interval = Constants.boundaryIntervalLong }
-    else if duration > Constants.oneHourInSeconds { interval = Constants.boundaryIntervalMedium }
-    else { interval = Constants.boundaryIntervalDefault }
+    if duration > 0 && !duration.isNaN && !duration.isInfinite {
+      if duration > Constants.twoHoursInSeconds { interval = Constants.boundaryIntervalLong }
+      else if duration > Constants.oneHourInSeconds { interval = Constants.boundaryIntervalMedium }
+      else { interval = Constants.boundaryIntervalDefault }
+    } else {
+      interval = Constants.boundaryIntervalDefault
+    }
 
-    NitroPlayerLogger.log("TrackPlayerCore", "⏱️ Setting up periodic observer (interval: \(interval)s, duration: \(Int(duration))s)")
+    NitroPlayerLogger.log("TrackPlayerCore", "⏱️ Setting up periodic observer (interval: \(interval)s, duration: \(duration)s)")
 
     let cmInterval = CMTime(seconds: interval, preferredTimescale: CMTimeScale(NSEC_PER_SEC))
     // Deliver on playerQueue (not main)
@@ -104,20 +106,23 @@ extension TrackPlayerCore {
     guard player.rate > 0 else { return }
 
     let position = currentItem.currentTime().seconds
-    let duration = currentItem.duration.seconds
-    guard duration > 0 && !duration.isNaN && !duration.isInfinite else { return }
+    let rawDuration = currentItem.duration.seconds
+    let duration = (rawDuration > 0 && !rawDuration.isNaN && !rawDuration.isInfinite) ? rawDuration : 0.0
 
-    NitroPlayerLogger.log("TrackPlayerCore", "⏱️ Boundary crossed - position: \(Int(position))s / \(Int(duration))s")
+    NitroPlayerLogger.log("TrackPlayerCore", "⏱️ Boundary crossed - position: \(Int(position))s / duration: \(duration)s")
 
     notifyPlaybackProgress(position, duration, isManuallySeeked ? true : nil)
     isManuallySeeked = false
 
-    let remaining = duration - position
-    if remaining > 0 && remaining <= Constants.preferredForwardBufferDuration && !didRequestUrlsForCurrentItem {
-      didRequestUrlsForCurrentItem = true
-      NitroPlayerLogger.log("TrackPlayerCore",
-        "⏳ \(Int(remaining))s remaining — proactively checking upcoming URLs")
-      checkUpcomingTracksForUrls(lookahead: lookaheadCount)
+    // Only do remaining-time preload when duration is known
+    if duration > 0 {
+      let remaining = duration - position
+      if remaining > 0 && remaining <= Constants.preferredForwardBufferDuration && !didRequestUrlsForCurrentItem {
+        didRequestUrlsForCurrentItem = true
+        NitroPlayerLogger.log("TrackPlayerCore",
+          "⏳ \(Int(remaining))s remaining — proactively checking upcoming URLs")
+        checkUpcomingTracksForUrls(lookahead: lookaheadCount)
+      }
     }
   }
 

package/ios/core/TrackPlayerPlayback.swift

@@ -7,6 +7,7 @@
 
 import AVFoundation
 import Foundation
+import MediaPlayer
 
 extension TrackPlayerCore {
 
@@ -115,8 +116,15 @@ extension TrackPlayerCore {
     self.isManuallySeeked = true
     let time = CMTime(seconds: position, preferredTimescale: CMTimeScale(NSEC_PER_SEC))
     player.seek(to: time) { [weak self] completed in
-      // Update now playing info to restore playback rate after seek
-      DispatchQueue.main.async { self?.mediaSessionManager?.refresh() }
+       // HackFix I dont know how to fix this, but it works.
+      let rate = Double(player.rate)
+      DispatchQueue.main.async {
+        if var info = MPNowPlayingInfoCenter.default().nowPlayingInfo {
+          info[MPNowPlayingInfoPropertyElapsedPlaybackTime] = position
+          info[MPNowPlayingInfoPropertyPlaybackRate] = rate
+          MPNowPlayingInfoCenter.default().nowPlayingInfo = info
+        }
+      }
       if completed {
         let duration = player.currentItem?.duration.seconds ?? 0.0
         self?.notifySeek(position, duration)

package/ios/core/TrackPlayerQueue.swift

@@ -43,7 +43,8 @@ extension TrackPlayerCore {
     }
     let currentTrack = getCurrentTrack()
     let currentPosition = player.currentTime().seconds
-    let totalDuration = player.currentItem?.duration.seconds ?? 0.0
+    let rawDuration = player.currentItem?.duration.seconds ?? 0.0
+    let totalDuration = (rawDuration > 0 && !rawDuration.isNaN && !rawDuration.isInfinite) ? rawDuration : 0.0
 
     let state: TrackPlayerState
     if player.rate == 0 { state = .paused }

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.2",
+  "version": "1.0.1",
   "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",