capacitor-plugin-playlist 0.13.0 → 0.13.2

package/android/src/main/java/org/dwbn/plugins/playlist/manager/PlaylistManager.kt

@@ -216,6 +216,7 @@ class PlaylistManager(private val application: Application) {
         }
 
         beginPlayback(seekStart, options.startPaused)
+        mediaServiceRef.get()?.refreshSkipAvailability()
     }
 
     fun addItem(item: AudioTrack?, index: Int = -1) {
@@ -441,6 +442,13 @@ class PlaylistManager(private val application: Application) {
                 return
             }
             val index = currentPosition.coerceIn(0, audioTracks.size - 1)
+            // Snapshot the position of whatever track is being switched away from — covers the
+            // JS "tap a different playlist item" path (playTrackById), not just native skip, so a
+            // later native skip back to that track resumes correctly regardless of how it was left.
+            val fromIndex = exoPlayer.currentMediaItemIndex
+            if (fromIndex != index) {
+                audioTracks.getOrNull(fromIndex)?.startPositionMs = exoPlayer.currentPosition
+            }
             currentPosition = index
             exoPlayer.repeatMode = PlaylistPlaybackPolicy.repeatMode(loop, audioTracks.size)
             exoPlayer.seekTo(index, seekPosition)
@@ -546,6 +554,7 @@ class PlaylistManager(private val application: Application) {
                 isNextAvailable,
                 isPreviousAvailable
             )
+            mediaServiceRef.get()?.refreshSkipAvailability()
         }
 
         override fun onPositionDiscontinuity(

package/android/src/main/java/org/dwbn/plugins/playlist/service/HandoffForwardingPlayer.kt

@@ -123,6 +123,27 @@ internal class HandoffForwardingPlayer(
         onSkipToPrevious?.invoke() ?: super.seekToPreviousMediaItem()
     }
 
+    /**
+     * The system media notification and hardware media buttons invoke this — Player's "smart"
+     * seek, not [seekToNextMediaItem] — so without this override they fall through to
+     * [ForwardingPlayer]'s default (the wrapped ExoPlayer's own seekToNext), bypassing
+     * [onSkipToNext] and its saved-position resume entirely.
+     */
+    override fun seekToNext() {
+        if (videoPlayer() != null) {
+            return
+        }
+        onSkipToNext?.invoke() ?: super.seekToNext()
+    }
+
+    /** See [seekToNext] — the system-control counterpart of [seekToPreviousMediaItem]. */
+    override fun seekToPrevious() {
+        if (videoPlayer() != null) {
+            return
+        }
+        onSkipToPrevious?.invoke() ?: super.seekToPrevious()
+    }
+
     override fun getAvailableCommands(): Player.Commands {
         val previous = previousAvailable
         val next = nextAvailable

package/android/src/main/java/org/dwbn/plugins/playlist/service/MediaService.kt

@@ -219,6 +219,36 @@ class MediaService : MediaSessionService() {
         triggerNotificationUpdate()
     }
 
+    /**
+     * Re-grants the media notification controller's skip commands to match current queue state.
+     * [PlaylistMediaSessionCallback.onConnect] only runs once per connection (typically before any
+     * track is loaded), so without this the system notification and hardware media buttons stay
+     * permanently frozen at whatever previous/next availability existed at connect time.
+     */
+    fun refreshSkipAvailability() {
+        val session = mediaSession ?: return
+        val controller = session.mediaNotificationControllerInfo ?: return
+        val retain = playlistManager.videoHandoffForegroundRetain
+        val videoAttached = VideoPlayerBridge.hasActivePlayer()
+        session.setAvailableCommands(
+            controller,
+            MediaSession.ConnectionResult.DEFAULT_SESSION_COMMANDS,
+            MediaNotificationPolicy.playerCommandsForMediaNotification(
+                MediaSession.ConnectionResult.DEFAULT_PLAYER_COMMANDS,
+                MediaNotificationPolicy.mediaNotificationSkipPreviousEnabled(
+                    playlistManager.isPreviousAvailable,
+                    retain,
+                    videoAttached
+                ),
+                MediaNotificationPolicy.mediaNotificationSkipNextEnabled(
+                    playlistManager.isNextAvailable,
+                    retain,
+                    videoAttached
+                )
+            )
+        )
+    }
+
     /** Re-reads `options.icon` after `setOptions` so a running service picks up the app's icon. */
     fun applyNotificationIcon() {
         notificationProvider?.setSmallIcon(smallIconRes())

package/android/src/test/java/org/dwbn/plugins/playlist/service/HandoffForwardingPlayerTest.kt

@@ -75,6 +75,44 @@ class HandoffForwardingPlayerTest {
         assertEquals(0, recording.seekToPreviousCount)
     }
 
+    /**
+     * seekToNext/seekToPrevious (not the MediaItem variants) are what the system media
+     * notification and hardware media buttons actually invoke — regression coverage for the
+     * bug where these fell through to the wrapped player's own default and bypassed the
+     * playlist's skip/position-resume logic entirely.
+     */
+    @Test
+    fun seekToNext_delegatesToCallback() {
+        var skipNextCount = 0
+        val recording = RecordingPlayer()
+        val forwarding = HandoffForwardingPlayer(
+            recording.proxy,
+            retain = { false },
+            onSkipToNext = { skipNextCount++ }
+        )
+
+        forwarding.seekToNext()
+
+        assertEquals(1, skipNextCount)
+        assertEquals(0, recording.seekToNextSmartCount)
+    }
+
+    @Test
+    fun seekToPrevious_delegatesToCallback() {
+        var skipPreviousCount = 0
+        val recording = RecordingPlayer()
+        val forwarding = HandoffForwardingPlayer(
+            recording.proxy,
+            retain = { false },
+            onSkipToPrevious = { skipPreviousCount++ }
+        )
+
+        forwarding.seekToPrevious()
+
+        assertEquals(1, skipPreviousCount)
+        assertEquals(0, recording.seekToPreviousSmartCount)
+    }
+
     @Test
     fun retainWithVideoAttached_playReachesVideoPlayer() {
         val audio = RecordingPlayer()
@@ -153,10 +191,13 @@ class HandoffForwardingPlayerTest {
 
         forwarding.seekToNextMediaItem()
         forwarding.seekToPreviousMediaItem()
+        forwarding.seekToNext()
+        forwarding.seekToPrevious()
 
         assertEquals(0, skipNextCount)
         assertEquals(0, skipPreviousCount)
         assertEquals(0, video.seekToNextCount)
+        assertEquals(0, video.seekToNextSmartCount)
     }
 
     @Test
@@ -224,6 +265,8 @@ class HandoffForwardingPlayerTest {
         var pauseCount = 0
         var seekToNextCount = 0
         var seekToPreviousCount = 0
+        var seekToNextSmartCount = 0
+        var seekToPreviousSmartCount = 0
         val seekToPositionMsCalls = mutableListOf<Long>()
         val setPlayWhenReadyCalls = mutableListOf<Boolean>()
         val proxy: Player = Proxy.newProxyInstance(
@@ -260,6 +303,14 @@ class HandoffForwardingPlayerTest {
                     seekToPreviousCount++
                     null
                 }
+                "seekToNext" -> {
+                    seekToNextSmartCount++
+                    null
+                }
+                "seekToPrevious" -> {
+                    seekToPreviousSmartCount++
+                    null
+                }
                 "isPlaying", "getIsPlaying" -> isPlayingValue
                 "isPlayWhenReady", "getPlayWhenReady" -> playWhenReady
                 "getPlaybackState" -> playbackState

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "capacitor-plugin-playlist",
-  "version": "0.13.0",
+  "version": "0.13.2",
   "description": "Playlist ",
   "main": "dist/plugin.cjs.js",
   "module": "dist/esm/index.js",