capacitor-plugin-playlist 0.11.2 → 0.13.0

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

@@ -0,0 +1,282 @@
+package org.dwbn.plugins.playlist.service
+
+import androidx.media3.common.Player
+import org.dwbn.plugins.playlist.handoff.VideoPlayerBridge
+import org.junit.After
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertFalse
+import org.junit.Assert.assertTrue
+import org.junit.Test
+import java.lang.reflect.Proxy
+
+class HandoffForwardingPlayerTest {
+
+    @After
+    fun tearDown() {
+        VideoPlayerBridge.clearForTests()
+    }
+
+    @Test
+    fun retain_playAndSetPlayWhenReadyAreNoOps() {
+        val recording = RecordingPlayer()
+        val forwarding = HandoffForwardingPlayer(recording.proxy, retain = { true })
+
+        forwarding.play()
+        forwarding.setPlayWhenReady(true)
+
+        assertEquals(0, recording.playCount)
+        assertTrue(recording.setPlayWhenReadyCalls.isEmpty())
+    }
+
+    @Test
+    fun afterRetainCleared_playReachesPlayer() {
+        var retain = true
+        val recording = RecordingPlayer()
+        val forwarding = HandoffForwardingPlayer(recording.proxy, retain = { retain })
+
+        forwarding.setPlayWhenReady(true)
+        assertTrue(recording.setPlayWhenReadyCalls.isEmpty())
+
+        retain = false
+        forwarding.setPlayWhenReady(true)
+
+        assertEquals(listOf(true), recording.setPlayWhenReadyCalls)
+    }
+
+    @Test
+    fun seekToNextMediaItem_delegatesToCallback() {
+        var skipNextCount = 0
+        val recording = RecordingPlayer()
+        val forwarding = HandoffForwardingPlayer(
+            recording.proxy,
+            retain = { false },
+            onSkipToNext = { skipNextCount++ }
+        )
+
+        forwarding.seekToNextMediaItem()
+
+        assertEquals(1, skipNextCount)
+        assertEquals(0, recording.seekToNextCount)
+    }
+
+    @Test
+    fun seekToPreviousMediaItem_delegatesToCallback() {
+        var skipPreviousCount = 0
+        val recording = RecordingPlayer()
+        val forwarding = HandoffForwardingPlayer(
+            recording.proxy,
+            retain = { false },
+            onSkipToPrevious = { skipPreviousCount++ }
+        )
+
+        forwarding.seekToPreviousMediaItem()
+
+        assertEquals(1, skipPreviousCount)
+        assertEquals(0, recording.seekToPreviousCount)
+    }
+
+    @Test
+    fun retainWithVideoAttached_playReachesVideoPlayer() {
+        val audio = RecordingPlayer()
+        val video = RecordingPlayer()
+        VideoPlayerBridge.attach(video.proxy)
+        val forwarding = HandoffForwardingPlayer(audio.proxy, retain = { true })
+
+        forwarding.play()
+
+        assertEquals(0, audio.playCount)
+        assertEquals(1, video.playCount)
+    }
+
+    @Test
+    fun retainWithVideoAttached_isPlayingReflectsVideo() {
+        val audio = RecordingPlayer()
+        val video = RecordingPlayer(playWhenReady = true, playbackState = Player.STATE_READY)
+        VideoPlayerBridge.attach(video.proxy)
+        val forwarding = HandoffForwardingPlayer(audio.proxy, retain = { true })
+
+        assertTrue(forwarding.isPlaying())
+    }
+
+    @Test
+    fun retainWithVideoAttached_notPlayingWhileBufferingEvenIfPlayWhenReady() {
+        val audio = RecordingPlayer()
+        val video = RecordingPlayer(playWhenReady = true, playbackState = Player.STATE_BUFFERING)
+        VideoPlayerBridge.attach(video.proxy)
+        val forwarding = HandoffForwardingPlayer(audio.proxy, retain = { true })
+
+        assertFalse(forwarding.isPlaying())
+    }
+
+    @Test
+    fun retainWithVideoAttached_pauseAndSeekHitVideo() {
+        val audio = RecordingPlayer()
+        val video = RecordingPlayer()
+        VideoPlayerBridge.attach(video.proxy)
+        val forwarding = HandoffForwardingPlayer(audio.proxy, retain = { true })
+
+        forwarding.pause()
+        forwarding.setPlayWhenReady(false)
+        forwarding.seekTo(99_000L)
+
+        assertEquals(1, video.pauseCount)
+        assertEquals(listOf(false), video.setPlayWhenReadyCalls)
+        assertEquals(listOf(99_000L), video.seekToPositionMsCalls)
+        assertEquals(0, audio.pauseCount)
+    }
+
+    @Test
+    fun retainWithVideoAttached_positionAndDurationFromVideo() {
+        val audio = RecordingPlayer(currentPosition = 1L, duration = 2L, contentPosition = 3L)
+        val video = RecordingPlayer(currentPosition = 50L, duration = 100L, contentPosition = 55L)
+        VideoPlayerBridge.attach(video.proxy)
+        val forwarding = HandoffForwardingPlayer(audio.proxy, retain = { true })
+
+        assertEquals(50L, forwarding.getCurrentPosition())
+        assertEquals(100L, forwarding.getDuration())
+        assertEquals(55L, forwarding.getContentPosition())
+    }
+
+    @Test
+    fun retainWithVideoAttached_skipMediaItemsAreNoOps() {
+        var skipNextCount = 0
+        var skipPreviousCount = 0
+        val audio = RecordingPlayer()
+        val video = RecordingPlayer()
+        VideoPlayerBridge.attach(video.proxy)
+        val forwarding = HandoffForwardingPlayer(
+            audio.proxy,
+            retain = { true },
+            onSkipToNext = { skipNextCount++ },
+            onSkipToPrevious = { skipPreviousCount++ }
+        )
+
+        forwarding.seekToNextMediaItem()
+        forwarding.seekToPreviousMediaItem()
+
+        assertEquals(0, skipNextCount)
+        assertEquals(0, skipPreviousCount)
+        assertEquals(0, video.seekToNextCount)
+    }
+
+    @Test
+    fun afterVideoDetach_skipCallbacksWorkAgainWhileRetainStillOn() {
+        var skipNextCount = 0
+        val audio = RecordingPlayer()
+        val video = RecordingPlayer()
+        VideoPlayerBridge.attach(video.proxy)
+        val forwarding = HandoffForwardingPlayer(
+            audio.proxy,
+            retain = { true },
+            onSkipToNext = { skipNextCount++ }
+        )
+
+        forwarding.seekToNextMediaItem()
+        assertEquals(0, skipNextCount)
+
+        VideoPlayerBridge.detach(video.proxy)
+        forwarding.seekToNextMediaItem()
+        assertEquals(1, skipNextCount)
+    }
+
+    @Test
+    fun afterVideoDetach_playStillIgnoredWhileRetainOn() {
+        val audio = RecordingPlayer()
+        val video = RecordingPlayer()
+        VideoPlayerBridge.attach(video.proxy)
+        val forwarding = HandoffForwardingPlayer(audio.proxy, retain = { true })
+
+        VideoPlayerBridge.detach(video.proxy)
+        forwarding.play()
+
+        assertEquals(0, audio.playCount)
+        assertEquals(0, video.playCount)
+    }
+
+    @Test
+    fun retainWithVideoAttached_notifiesSessionWhenVideoAttaches() {
+        val audio = RecordingPlayer()
+        val video = RecordingPlayer(playWhenReady = true, playbackState = Player.STATE_READY)
+        val forwarding = HandoffForwardingPlayer(audio.proxy, retain = { true })
+        var playingUpdates = 0
+        forwarding.addListener(object : Player.Listener {
+            override fun onIsPlayingChanged(isPlaying: Boolean) {
+                if (isPlaying) {
+                    playingUpdates++
+                }
+            }
+        })
+
+        VideoPlayerBridge.attach(video.proxy)
+
+        assertTrue(playingUpdates > 0)
+    }
+
+    private class RecordingPlayer(
+        private var playWhenReady: Boolean = false,
+        private val playbackState: Int = Player.STATE_IDLE,
+        private val isPlayingValue: Boolean = false,
+        private val currentPosition: Long = 0L,
+        private val duration: Long = 0L,
+        private val contentPosition: Long = 0L
+    ) {
+        var playCount = 0
+        var pauseCount = 0
+        var seekToNextCount = 0
+        var seekToPreviousCount = 0
+        val seekToPositionMsCalls = mutableListOf<Long>()
+        val setPlayWhenReadyCalls = mutableListOf<Boolean>()
+        val proxy: Player = Proxy.newProxyInstance(
+            Player::class.java.classLoader,
+            arrayOf(Player::class.java)
+        ) { _, method, args ->
+            when (method.name) {
+                "play" -> {
+                    playCount++
+                    null
+                }
+                "pause" -> {
+                    pauseCount++
+                    null
+                }
+                "setPlayWhenReady" -> {
+                    val ready = args[0] as Boolean
+                    playWhenReady = ready
+                    setPlayWhenReadyCalls.add(ready)
+                    null
+                }
+                "seekTo" -> when (args?.size) {
+                    1 -> {
+                        seekToPositionMsCalls.add(args[0] as Long)
+                        null
+                    }
+                    else -> defaultValue(method.returnType)
+                }
+                "seekToNextMediaItem" -> {
+                    seekToNextCount++
+                    null
+                }
+                "seekToPreviousMediaItem" -> {
+                    seekToPreviousCount++
+                    null
+                }
+                "isPlaying", "getIsPlaying" -> isPlayingValue
+                "isPlayWhenReady", "getPlayWhenReady" -> playWhenReady
+                "getPlaybackState" -> playbackState
+                "getCurrentPosition" -> currentPosition
+                "getDuration" -> duration
+                "getContentPosition" -> contentPosition
+                else -> defaultValue(method.returnType)
+            }
+        } as Player
+
+        private fun defaultValue(returnType: Class<*>): Any? = when (returnType) {
+            java.lang.Boolean.TYPE, java.lang.Boolean::class.java -> false
+            java.lang.Integer.TYPE, java.lang.Integer::class.java -> 0
+            java.lang.Long.TYPE, java.lang.Long::class.java -> 0L
+            java.lang.Float.TYPE, java.lang.Float::class.java -> 0f
+            java.lang.Double.TYPE, java.lang.Double::class.java -> 0.0
+            else -> null
+        }
+    }
+}

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

@@ -0,0 +1,285 @@
+package org.dwbn.plugins.playlist.service
+
+import android.content.Intent
+import androidx.media3.session.DefaultMediaNotificationProvider
+import androidx.media3.session.MediaSessionService
+import org.dwbn.plugins.playlist.manager.PlaylistManager
+import org.dwbn.plugins.playlist.playlist.AudioPlaylistHandler
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertFalse
+import org.junit.Assert.assertTrue
+import org.junit.Test
+
+class MediaNotificationPolicyTest {
+
+    @Test
+    fun backgroundPlay_usesDefaultMediaNotificationProviderOnMediaSessionService() {
+        assertEquals(
+            DefaultMediaNotificationProvider::class.java,
+            MediaNotificationPolicy.mediaNotificationProviderClass
+        )
+        assertTrue(MediaSessionService::class.java.isAssignableFrom(MediaService::class.java))
+        assertFalse(MediaNotificationPolicy.shouldStartForegroundOnPromote())
+        assertFalse(MediaNotificationPolicy.ALLOW_START_FOREGROUND_ON_PROMOTE)
+        assertEquals(
+            MediaSessionService.SHOW_NOTIFICATION_FOR_IDLE_PLAYER_ALWAYS,
+            MediaNotificationPolicy.SHOW_NOTIFICATION_WHEN_IDLE
+        )
+    }
+
+    @Test
+    fun artworkPresent_loadsRemoteArtwork() {
+        val uri = "https://example.com/art.jpg"
+        assertTrue(MediaNotificationPolicy.shouldLoadRemoteArtwork(uri))
+        assertFalse(MediaNotificationPolicy.hasNoLargeArtwork(null, uri))
+    }
+
+    @Test
+    fun artworkMissing_hasNoLargeArt() {
+        assertTrue(MediaNotificationPolicy.hasNoLargeArtwork(null, null))
+        assertTrue(MediaNotificationPolicy.hasNoLargeArtwork(null, ""))
+        assertTrue(MediaNotificationPolicy.hasNoLargeArtwork(ByteArray(0), null))
+        assertFalse(MediaNotificationPolicy.hasNoLargeArtwork(ByteArray(0), "https://example.com/art.jpg"))
+        assertFalse(MediaNotificationPolicy.shouldLoadRemoteArtwork(null))
+        assertFalse(MediaNotificationPolicy.shouldLoadRemoteArtwork(""))
+    }
+
+    @Test
+    fun focusLoss_media3HandlesFocusWithoutAudioManagerApi() {
+        assertTrue(MediaNotificationPolicy.HANDLE_AUDIO_FOCUS)
+        assertFalse(MediaNotificationPolicy.shouldRequestLegacyAudioFocus())
+        val managerMethods = PlaylistManager::class.java.methods.map { it.name }
+        assertFalse(managerMethods.contains("requestAudioFocus"))
+        assertFalse(managerMethods.contains("abandonAudioFocus"))
+        val handlerMethods = AudioPlaylistHandler::class.java.methods.map { it.name }
+        assertFalse(handlerMethods.contains("requestAudioFocus"))
+        assertFalse(handlerMethods.contains("abandonAudioFocus"))
+    }
+
+    @Test
+    fun notificationTap_usesHostLaunchReorderFlags() {
+        val flags = MediaNotificationPolicy.sessionLaunchIntentFlags()
+        assertEquals(
+            Intent.FLAG_ACTIVITY_REORDER_TO_FRONT or Intent.FLAG_ACTIVITY_SINGLE_TOP,
+            flags
+        )
+    }
+
+    @Test
+    fun handoffRetain_skipsEndForeground() {
+        assertTrue(MediaNotificationPolicy.shouldSkipEndForeground(true))
+        assertFalse(MediaNotificationPolicy.shouldSkipEndForeground(false))
+    }
+
+    @Test
+    fun prepareForVideoHandoff_pausesRegardlessOfIsPlaying() {
+        assertTrue(MediaNotificationPolicy.shouldPauseForVideoHandoff(true))
+        assertTrue(MediaNotificationPolicy.shouldPauseForVideoHandoff(false))
+    }
+
+    @Test
+    fun foregroundStartFailure_securityExceptionIsRecoverable() {
+        assertTrue(MediaNotificationPolicy.isForegroundStartSecurityBlocked(SecurityException("denied")))
+        assertFalse(MediaNotificationPolicy.isForegroundStartSecurityBlocked(IllegalStateException()))
+    }
+
+    @Test
+    fun prepareForVideoHandoff_retainsForeground() {
+        val retainCalls = mutableListOf<Boolean>()
+        MediaNotificationPolicy.applyForegroundRetainOnPrepare { retainCalls.add(true) }
+        assertEquals(listOf(true), retainCalls)
+    }
+
+    @Test
+    fun retain_forcesNotificationForegroundPastMedia3Timeout() {
+        assertTrue(MediaNotificationPolicy.shouldForceNotificationForeground(true))
+        assertFalse(MediaNotificationPolicy.shouldForceNotificationForeground(false))
+        assertTrue(
+            MediaNotificationPolicy.startInForegroundRequired(
+                videoHandoffForegroundRetain = true,
+                media3Requested = false
+            )
+        )
+        assertTrue(
+            MediaNotificationPolicy.startInForegroundRequired(
+                videoHandoffForegroundRetain = true,
+                media3Requested = true
+            )
+        )
+        assertFalse(
+            MediaNotificationPolicy.startInForegroundRequired(
+                videoHandoffForegroundRetain = false,
+                media3Requested = false
+            )
+        )
+        assertTrue(
+            MediaNotificationPolicy.startInForegroundRequired(
+                videoHandoffForegroundRetain = false,
+                media3Requested = true
+            )
+        )
+        assertTrue(MediaService.resolveHandoffNotificationForeground(true, false))
+        assertFalse(MediaService.resolveHandoffNotificationForeground(false, false))
+    }
+
+    @Test
+    fun retain_playWhenReadyTrue_forcesPause() {
+        val pauses = mutableListOf<Boolean>()
+        MediaNotificationPolicy.applyRetainPlayWhenReadyGuard(
+            playWhenReady = true,
+            videoHandoffForegroundRetain = true,
+            videoHandoffPlayerAttached = false
+        ) { pauses.add(true) }
+        assertEquals(listOf(true), pauses)
+    }
+
+    @Test
+    fun retain_playWhenReadyFalse_doesNotForcePause() {
+        val pauses = mutableListOf<Boolean>()
+        MediaNotificationPolicy.applyRetainPlayWhenReadyGuard(
+            playWhenReady = false,
+            videoHandoffForegroundRetain = true,
+            videoHandoffPlayerAttached = false
+        ) { pauses.add(true) }
+        assertTrue(pauses.isEmpty())
+    }
+
+    @Test
+    fun retainWithVideoAttached_playWhenReadyTrue_doesNotForcePause() {
+        val pauses = mutableListOf<Boolean>()
+        MediaNotificationPolicy.applyRetainPlayWhenReadyGuard(
+            playWhenReady = true,
+            videoHandoffForegroundRetain = true,
+            videoHandoffPlayerAttached = true
+        ) { pauses.add(true) }
+        assertTrue(pauses.isEmpty())
+    }
+
+    @Test
+    fun retain_ignoresSessionPlay() {
+        assertTrue(MediaNotificationPolicy.shouldIgnoreSessionPlay(true))
+        assertFalse(MediaNotificationPolicy.shouldIgnoreSessionPlay(false))
+    }
+
+    @Test
+    fun audibleResume_playsThenSeeks() {
+        assertTrue(MediaNotificationPolicy.shouldPlayThenSeekOnResume())
+    }
+
+    @Test
+    fun lastKnownPosition_isHandoffSnapshot() {
+        assertEquals(42.5f, MediaNotificationPolicy.lastKnownPositionSec(42.5f), 0f)
+        assertEquals(0f, MediaNotificationPolicy.lastKnownPositionSec(0f), 0f)
+    }
+
+    @Test
+    fun resume_reportsInPlaceOnlyWhenForegroundUp() {
+        assertTrue(
+            MediaNotificationPolicy.shouldReportInPlaceResumed(
+                prewarm = false,
+                play = true,
+                retain = true,
+                serviceInForeground = true
+            )
+        )
+        assertFalse(
+            MediaNotificationPolicy.shouldReportInPlaceResumed(
+                prewarm = true,
+                play = true,
+                retain = true,
+                serviceInForeground = true
+            )
+        )
+        assertFalse(
+            MediaNotificationPolicy.shouldReportInPlaceResumed(
+                prewarm = false,
+                play = true,
+                retain = true,
+                serviceInForeground = false
+            )
+        )
+        assertFalse(
+            MediaNotificationPolicy.shouldReportInPlaceResumed(
+                prewarm = false,
+                play = false,
+                retain = true,
+                serviceInForeground = true
+            )
+        )
+    }
+
+    @Test
+    fun failedInPlaceResume_doesNotBeginPlayback() {
+        val beginPlaybackCalls = mutableListOf<String>()
+        MediaNotificationPolicy.applyBeginPlaybackWhenInPlaceUnavailable {
+            beginPlaybackCalls.add("beginPlayback")
+        }
+        assertTrue(beginPlaybackCalls.isEmpty())
+        assertFalse(MediaNotificationPolicy.shouldBeginPlaybackWhenInPlaceUnavailable())
+    }
+
+    @Test
+    fun pausedVideoExit_doesNotClaimInPlaceResume() {
+        assertFalse(
+            MediaNotificationPolicy.shouldReportInPlaceResumed(
+                prewarm = false,
+                play = false,
+                retain = true,
+                serviceInForeground = true
+            )
+        )
+        assertFalse(MediaNotificationPolicy.shouldBeginPlaybackWhenInPlaceUnavailable())
+    }
+
+    @Test
+    fun retainMustClearBeforeAudiblePlay() {
+        assertTrue(MediaNotificationPolicy.shouldIgnoreSessionPlay(true))
+        assertFalse(MediaNotificationPolicy.shouldIgnoreSessionPlay(false))
+    }
+
+    @Test
+    fun mediaSessionId_isDistinctFromEmptyDefault() {
+        assertEquals("org.dwbn.playlist", MediaNotificationPolicy.MEDIA_SESSION_ID)
+        assertFalse(MediaNotificationPolicy.MEDIA_SESSION_ID.isEmpty())
+    }
+
+    @Test
+    fun ensureService_skipsWhenAlreadyCreated() {
+        assertFalse(MediaNotificationPolicy.shouldStartForegroundService(true))
+        assertTrue(MediaNotificationPolicy.shouldStartForegroundService(false))
+    }
+
+    @Test
+    fun mediaNotificationSkipFlags_followPlaylistAvailability() {
+        assertFalse(MediaNotificationPolicy.mediaNotificationSkipPreviousEnabled(false))
+        assertTrue(MediaNotificationPolicy.mediaNotificationSkipPreviousEnabled(true))
+        assertFalse(MediaNotificationPolicy.mediaNotificationSkipNextEnabled(false))
+        assertTrue(MediaNotificationPolicy.mediaNotificationSkipNextEnabled(true))
+    }
+
+    @Test
+    fun onStartCommand_doesNotOverwriteMedia3Notification() {
+        assertFalse(MediaNotificationPolicy.shouldOverwriteMedia3NotificationOnStartCommand())
+        assertFalse(MediaNotificationPolicy.shouldAllowTitleOnlyNotificationAfterSession())
+        val methodNames = MediaService::class.java.declaredMethods.map { it.name }
+        assertTrue(methodNames.contains("startForegroundImmediately"))
+        assertTrue(methodNames.contains("startForegroundWithMedia3Notification"))
+        assertTrue(methodNames.contains("onUpdateNotificationAsync"))
+        assertTrue(methodNames.contains("onStartCommand"))
+    }
+
+    @Test
+    fun playback_holdsNetworkWakeLockLikePlaylistCore() {
+        assertEquals(androidx.media3.common.C.WAKE_MODE_NETWORK, MediaNotificationPolicy.WAKE_MODE)
+    }
+
+    @Test
+    fun smallIcon_usesAppDrawableFromOptions() {
+        assertEquals(0x7f080001, MediaNotificationPolicy.smallIconRes(0x7f080001))
+    }
+
+    @Test
+    fun smallIcon_missingDrawable_fallsBackToPlatformPlayGlyph() {
+        assertEquals(android.R.drawable.ic_media_play, MediaNotificationPolicy.smallIconRes(0))
+    }
+}

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

@@ -0,0 +1,54 @@
+package org.dwbn.plugins.playlist.service
+
+import androidx.media3.common.Player
+import org.junit.Assert.assertFalse
+import org.junit.Assert.assertTrue
+import org.junit.Test
+import org.junit.runner.RunWith
+import org.robolectric.RobolectricTestRunner
+import org.robolectric.annotation.Config
+
+@RunWith(RobolectricTestRunner::class)
+@Config(sdk = [28])
+class VideoHandoffNotificationCommandsTest {
+
+    @Test
+    fun videoHandoff_playerCommandsHideSkipButKeepPlayPause() {
+        val commands = MediaNotificationPolicy.playerCommandsForMediaNotification(
+            Player.Commands.EMPTY,
+            MediaNotificationPolicy.mediaNotificationSkipPreviousEnabled(
+                previousAvailable = true,
+                videoHandoffForegroundRetain = true,
+                videoHandoffPlayerAttached = true
+            ),
+            MediaNotificationPolicy.mediaNotificationSkipNextEnabled(
+                nextAvailable = true,
+                videoHandoffForegroundRetain = true,
+                videoHandoffPlayerAttached = true
+            )
+        )
+        assertTrue(commands.contains(Player.COMMAND_PLAY_PAUSE))
+        assertFalse(commands.contains(Player.COMMAND_SEEK_TO_NEXT_MEDIA_ITEM))
+        assertFalse(commands.contains(Player.COMMAND_SEEK_TO_PREVIOUS_MEDIA_ITEM))
+    }
+
+    @Test
+    fun retainWithoutVideo_playerCommandsExposeSkipWhenAvailable() {
+        val commands = MediaNotificationPolicy.playerCommandsForMediaNotification(
+            Player.Commands.EMPTY,
+            MediaNotificationPolicy.mediaNotificationSkipPreviousEnabled(
+                previousAvailable = true,
+                videoHandoffForegroundRetain = true,
+                videoHandoffPlayerAttached = false
+            ),
+            MediaNotificationPolicy.mediaNotificationSkipNextEnabled(
+                nextAvailable = true,
+                videoHandoffForegroundRetain = true,
+                videoHandoffPlayerAttached = false
+            )
+        )
+        assertTrue(commands.contains(Player.COMMAND_PLAY_PAUSE))
+        assertTrue(commands.contains(Player.COMMAND_SEEK_TO_NEXT_MEDIA_ITEM))
+        assertTrue(commands.contains(Player.COMMAND_SEEK_TO_PREVIOUS_MEDIA_ITEM))
+    }
+}

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

@@ -0,0 +1,47 @@
+package org.dwbn.plugins.playlist.service
+
+import org.junit.Assert.assertFalse
+import org.junit.Assert.assertTrue
+import org.junit.Test
+
+class VideoHandoffNotificationPolicyTest {
+
+    @Test
+    fun retainWithoutVideo_stillIgnoresSessionPlay() {
+        assertTrue(MediaNotificationPolicy.shouldIgnoreSessionPlay(true, videoHandoffPlayerAttached = false))
+    }
+
+    @Test
+    fun retainWithVideo_doesNotIgnoreSessionPlay() {
+        assertFalse(MediaNotificationPolicy.shouldIgnoreSessionPlay(true, videoHandoffPlayerAttached = true))
+    }
+
+    @Test
+    fun videoHandoff_hidesSkipCommandsEvenWhenPlaylistWouldAllow() {
+        assertFalse(
+            MediaNotificationPolicy.mediaNotificationSkipNextEnabled(
+                nextAvailable = true,
+                videoHandoffForegroundRetain = true,
+                videoHandoffPlayerAttached = true
+            )
+        )
+        assertFalse(
+            MediaNotificationPolicy.mediaNotificationSkipPreviousEnabled(
+                previousAvailable = true,
+                videoHandoffForegroundRetain = true,
+                videoHandoffPlayerAttached = true
+            )
+        )
+    }
+
+    @Test
+    fun playlistSkipRestoredWhenVideoDetached() {
+        assertTrue(
+            MediaNotificationPolicy.mediaNotificationSkipNextEnabled(
+                nextAvailable = true,
+                videoHandoffForegroundRetain = true,
+                videoHandoffPlayerAttached = false
+            )
+        )
+    }
+}