capacitor-plugin-playlist 0.11.4 → 0.13.0

package/android/src/test/java/org/dwbn/plugins/playlist/handoff/VideoPlayerBridgeTest.kt

@@ -0,0 +1,84 @@
+package org.dwbn.plugins.playlist.handoff
+
+import androidx.media3.common.Player
+import org.junit.After
+import org.junit.Assert.assertFalse
+import org.junit.Assert.assertSame
+import org.junit.Assert.assertTrue
+import org.junit.Test
+import java.lang.reflect.Proxy
+
+class VideoPlayerBridgeTest {
+
+    @After
+    fun tearDown() {
+        VideoPlayerBridge.clearForTests()
+    }
+
+    @Test
+    fun attachAndDetach_trackActivePlayer() {
+        val player = dummyPlayer()
+        VideoPlayerBridge.attach(player)
+        assertSame(player, VideoPlayerBridge.activePlayer())
+        assertTrue(VideoPlayerBridge.hasActivePlayer())
+
+        VideoPlayerBridge.detach(player)
+        assertFalse(VideoPlayerBridge.hasActivePlayer())
+    }
+
+    @Test
+    fun detach_ignoresDifferentPlayerInstance() {
+        val attached = dummyPlayer()
+        val other = dummyPlayer()
+        VideoPlayerBridge.attach(attached)
+        VideoPlayerBridge.detach(other)
+        assertTrue(VideoPlayerBridge.hasActivePlayer())
+        VideoPlayerBridge.detach(attached)
+        assertFalse(VideoPlayerBridge.hasActivePlayer())
+    }
+
+    @Test
+    fun attach_notifiesPlaybackChangedListeners() {
+        var notifications = 0
+        VideoPlayerBridge.addPlaybackChangedListener { notifications++ }
+        VideoPlayerBridge.attach(dummyPlayer())
+        assertTrue(notifications > 0)
+    }
+
+    @Test
+    fun reAttach_replacesPreviousPlayer() {
+        val first = dummyPlayer()
+        val second = dummyPlayer()
+        VideoPlayerBridge.attach(first)
+        VideoPlayerBridge.attach(second)
+        assertSame(second, VideoPlayerBridge.activePlayer())
+    }
+
+    @Test
+    fun detach_notifiesPlaybackChangedListeners() {
+        val player = dummyPlayer()
+        var notifications = 0
+        VideoPlayerBridge.addPlaybackChangedListener { notifications++ }
+        VideoPlayerBridge.attach(player)
+        val afterAttach = notifications
+        VideoPlayerBridge.detach(player)
+        assertTrue(notifications > afterAttach)
+    }
+
+    @Test
+    fun detachNull_clearsActivePlayer() {
+        VideoPlayerBridge.attach(dummyPlayer())
+        VideoPlayerBridge.detach(null)
+        assertFalse(VideoPlayerBridge.hasActivePlayer())
+    }
+
+    private fun dummyPlayer(): Player =
+        Proxy.newProxyInstance(Player::class.java.classLoader, arrayOf(Player::class.java)) { _, method, _ ->
+            when (method.returnType) {
+                java.lang.Boolean.TYPE -> false
+                java.lang.Integer.TYPE -> Player.STATE_IDLE
+                java.lang.Long.TYPE -> 0L
+                else -> null
+            }
+        } as Player
+}

package/android/src/test/java/org/dwbn/plugins/playlist/manager/PlaylistPlaybackPolicyTest.kt

@@ -0,0 +1,128 @@
+package org.dwbn.plugins.playlist.manager
+
+import androidx.media3.common.Player
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertFalse
+import org.junit.Assert.assertTrue
+import org.junit.Test
+
+/** Parity with the former PlaylistCore stack (loop, completion, error skip, play recovery). */
+class PlaylistPlaybackPolicyTest {
+
+    @Test
+    fun repeatMode_loopWithSeveralItems_repeatsAll() {
+        assertEquals(Player.REPEAT_MODE_ALL, PlaylistPlaybackPolicy.repeatMode(loop = true, itemCount = 3))
+    }
+
+    @Test
+    fun repeatMode_loopWithSingleItem_stopsAtEndLikePlaylistCore() {
+        assertEquals(Player.REPEAT_MODE_OFF, PlaylistPlaybackPolicy.repeatMode(loop = true, itemCount = 1))
+    }
+
+    @Test
+    fun repeatMode_noLoop_isOff() {
+        assertEquals(Player.REPEAT_MODE_OFF, PlaylistPlaybackPolicy.repeatMode(loop = false, itemCount = 3))
+    }
+
+    @Test
+    fun nextAvailable_matchesFormerPlaylistManager() {
+        assertFalse(PlaylistPlaybackPolicy.nextAvailable(0, 1, loop = true))
+        assertTrue(PlaylistPlaybackPolicy.nextAvailable(0, 3, loop = false))
+        assertFalse(PlaylistPlaybackPolicy.nextAvailable(2, 3, loop = false))
+        assertTrue(PlaylistPlaybackPolicy.nextAvailable(2, 3, loop = true))
+    }
+
+    @Test
+    fun previousAvailable_atStartOnlyWhenLooping() {
+        assertFalse(PlaylistPlaybackPolicy.previousAvailable(0, loop = false, itemCount = 3))
+        assertTrue(PlaylistPlaybackPolicy.previousAvailable(0, loop = true, itemCount = 3))
+        assertTrue(PlaylistPlaybackPolicy.previousAvailable(1, loop = false, itemCount = 3))
+    }
+
+    @Test
+    fun previousAvailable_emptyPlaylist_isFalse() {
+        assertFalse(PlaylistPlaybackPolicy.previousAvailable(0, loop = true, itemCount = 0))
+    }
+
+    @Test
+    fun naturalItemEnd_isAutoOrRepeatTransitionOnly() {
+        assertTrue(PlaylistPlaybackPolicy.isNaturalItemEnd(Player.MEDIA_ITEM_TRANSITION_REASON_AUTO))
+        assertTrue(PlaylistPlaybackPolicy.isNaturalItemEnd(Player.MEDIA_ITEM_TRANSITION_REASON_REPEAT))
+        assertFalse(PlaylistPlaybackPolicy.isNaturalItemEnd(Player.MEDIA_ITEM_TRANSITION_REASON_SEEK))
+        assertFalse(PlaylistPlaybackPolicy.isNaturalItemEnd(Player.MEDIA_ITEM_TRANSITION_REASON_PLAYLIST_CHANGED))
+    }
+
+    @Test
+    fun errorSkip_upToThreeSequentialErrorsWhenNextExists() {
+        assertTrue(PlaylistPlaybackPolicy.shouldSkipAfterError(1, nextAvailable = true))
+        assertTrue(PlaylistPlaybackPolicy.shouldSkipAfterError(3, nextAvailable = true))
+        assertFalse(PlaylistPlaybackPolicy.shouldSkipAfterError(4, nextAvailable = true))
+        assertFalse(PlaylistPlaybackPolicy.shouldSkipAfterError(1, nextAvailable = false))
+    }
+
+    @Test
+    fun errorSkip_keepsPlayingUnlessFirstAutoBufferedItemFailed() {
+        assertTrue(PlaylistPlaybackPolicy.playWhenReadyAfterErrorSkip(playWhenReady = true, failedIndex = 0))
+        assertFalse(PlaylistPlaybackPolicy.playWhenReadyAfterErrorSkip(playWhenReady = false, failedIndex = 0))
+        assertTrue(PlaylistPlaybackPolicy.playWhenReadyAfterErrorSkip(playWhenReady = false, failedIndex = 2))
+    }
+
+    @Test
+    fun playRecovery_preparesIdleAndRewindsEnded() {
+        assertTrue(PlaylistPlaybackPolicy.needsPrepareBeforePlay(Player.STATE_IDLE))
+        assertFalse(PlaylistPlaybackPolicy.needsPrepareBeforePlay(Player.STATE_READY))
+        assertTrue(PlaylistPlaybackPolicy.needsRewindBeforePlay(Player.STATE_ENDED))
+        assertFalse(PlaylistPlaybackPolicy.needsRewindBeforePlay(Player.STATE_BUFFERING))
+    }
+
+    @Test
+    fun liveEdge_onlyForLiveStreamsWithResetEnabled() {
+        assertTrue(PlaylistPlaybackPolicy.shouldJumpToLiveEdge(true, isStream = true, isLive = true))
+        assertFalse(PlaylistPlaybackPolicy.shouldJumpToLiveEdge(true, isStream = true, isLive = false))
+        assertFalse(PlaylistPlaybackPolicy.shouldJumpToLiveEdge(false, isStream = true, isLive = true))
+        assertFalse(PlaylistPlaybackPolicy.shouldJumpToLiveEdge(true, isStream = false, isLive = true))
+    }
+
+    @Test
+    fun errorSkipWindowIndex_midListAndWrapToStart() {
+        assertEquals(2, PlaylistPlaybackPolicy.errorSkipWindowIndex(failedIndex = 1, itemCount = 5))
+        assertEquals(0, PlaylistPlaybackPolicy.errorSkipWindowIndex(failedIndex = 4, itemCount = 5))
+    }
+
+    @Test
+    fun errorSkipWindowIndex_emptyListReturnsZero() {
+        assertEquals(0, PlaylistPlaybackPolicy.errorSkipWindowIndex(failedIndex = 0, itemCount = 0))
+    }
+
+    @Test
+    fun nextAvailable_emptyPlaylist_isFalse() {
+        assertFalse(PlaylistPlaybackPolicy.nextAvailable(0, itemCount = 0, loop = true))
+    }
+
+    @Test
+    fun repeatMode_emptyPlaylist_isOff() {
+        assertEquals(Player.REPEAT_MODE_OFF, PlaylistPlaybackPolicy.repeatMode(loop = true, itemCount = 0))
+    }
+
+    @Test
+    fun nextSkipIndex_midListAdvancesByOne() {
+        assertEquals(2, PlaylistPlaybackPolicy.nextSkipIndex(fromIndex = 1, itemCount = 5, loop = false))
+    }
+
+    @Test
+    fun nextSkipIndex_atEnd_wrapsToStartOnlyWhenLooping() {
+        assertEquals(3, PlaylistPlaybackPolicy.nextSkipIndex(fromIndex = 2, itemCount = 3, loop = false))
+        assertEquals(0, PlaylistPlaybackPolicy.nextSkipIndex(fromIndex = 2, itemCount = 3, loop = true))
+    }
+
+    @Test
+    fun previousSkipIndex_midListGoesBackByOne() {
+        assertEquals(1, PlaylistPlaybackPolicy.previousSkipIndex(fromIndex = 2, itemCount = 5, loop = false))
+    }
+
+    @Test
+    fun previousSkipIndex_atStart_wrapsToLastOnlyWhenLooping() {
+        assertEquals(-1, PlaylistPlaybackPolicy.previousSkipIndex(fromIndex = 0, itemCount = 3, loop = false))
+        assertEquals(2, PlaylistPlaybackPolicy.previousSkipIndex(fromIndex = 0, itemCount = 3, loop = true))
+    }
+}

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

@@ -0,0 +1,145 @@
+package org.dwbn.plugins.playlist.playlist
+
+import androidx.media3.common.Player
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertFalse
+import org.junit.Test
+import java.lang.reflect.Proxy
+
+class AudioPlaylistHandlerTest {
+
+    @Test
+    fun pauseForVideoHandoff_setsPlayWhenReadyFalseWhenNotPlaying() {
+        val recording = RecordingPlayer(isPlaying = false)
+        assertFalse(recording.proxy.isPlaying)
+
+        AudioPlaylistHandler.pauseForVideoHandoff(recording.proxy)
+
+        assertEquals(listOf(false), recording.setPlayWhenReadyCalls)
+    }
+
+    @Test
+    fun audibleResume_playsBeforeSeekSoAudioIsNotSilent() {
+        val recording = RecordingPlayer(isPlaying = false)
+
+        AudioPlaylistHandler.applyAudibleResume(recording.proxy, 175_000L)
+
+        assertEquals(listOf("playWhenReady:true", "seek:175000"), recording.calls)
+    }
+
+    @Test
+    fun audibleResume_atZero_playsWithoutSeek() {
+        val recording = RecordingPlayer(isPlaying = false)
+
+        AudioPlaylistHandler.applyAudibleResume(recording.proxy, 0L)
+
+        assertEquals(listOf("playWhenReady:true"), recording.calls)
+    }
+
+    @Test
+    fun play_onIdlePlayer_preparesBeforePlaying() {
+        val recording = RecordingPlayer(isPlaying = false, playbackState = Player.STATE_IDLE)
+
+        AudioPlaylistHandler.startAudible(recording.proxy)
+
+        assertEquals(listOf("prepare", "playWhenReady:true"), recording.calls)
+    }
+
+    @Test
+    fun play_onEndedPlayer_rewindsCurrentItemBeforePlaying() {
+        val recording = RecordingPlayer(isPlaying = false, playbackState = Player.STATE_ENDED, currentIndex = 2)
+
+        AudioPlaylistHandler.startAudible(recording.proxy)
+
+        assertEquals(listOf("seekToDefault:2", "playWhenReady:true"), recording.calls)
+    }
+
+    @Test
+    fun play_onReadyPlayer_onlyPlays() {
+        val recording = RecordingPlayer(isPlaying = false, playbackState = Player.STATE_READY)
+
+        AudioPlaylistHandler.startAudible(recording.proxy)
+
+        assertEquals(listOf("playWhenReady:true"), recording.calls)
+    }
+
+    @Test
+    fun resetStreamOnPause_liveStream_resumesAtLiveEdge() {
+        val recording = RecordingPlayer(isPlaying = false, isLive = true)
+
+        AudioPlaylistHandler.jumpToLiveEdgeIfReset(recording.proxy, true, true)
+
+        assertEquals(listOf("seekToDefault:current"), recording.calls)
+    }
+
+    @Test
+    fun resetStreamOnPause_vodHlsLecture_keepsPosition() {
+        val recording = RecordingPlayer(isPlaying = false, isLive = false)
+
+        AudioPlaylistHandler.jumpToLiveEdgeIfReset(recording.proxy, true, true)
+
+        assertEquals(emptyList<String>(), recording.calls)
+    }
+
+    @Test
+    fun resetStreamOnPauseOff_liveStream_keepsPosition() {
+        val recording = RecordingPlayer(isPlaying = false, isLive = true)
+
+        AudioPlaylistHandler.jumpToLiveEdgeIfReset(recording.proxy, false, true)
+
+        assertEquals(emptyList<String>(), recording.calls)
+    }
+
+    private class RecordingPlayer(
+        private val isPlaying: Boolean,
+        private val playbackState: Int = Player.STATE_READY,
+        private val currentIndex: Int = 0,
+        private val isLive: Boolean = false
+    ) {
+        val setPlayWhenReadyCalls = mutableListOf<Boolean>()
+        val calls = mutableListOf<String>()
+        val proxy: Player = Proxy.newProxyInstance(
+            Player::class.java.classLoader,
+            arrayOf(Player::class.java)
+        ) { _, method, args ->
+            when (method.name) {
+                "isPlaying" -> isPlaying
+                "getPlaybackState" -> playbackState
+                "getCurrentMediaItemIndex" -> currentIndex
+                "isCurrentMediaItemLive" -> isLive
+                "prepare" -> {
+                    calls.add("prepare")
+                    null
+                }
+                "seekToDefaultPosition" -> {
+                    calls.add("seekToDefault:" + (args?.getOrNull(0) ?: "current"))
+                    null
+                }
+                "setPlayWhenReady" -> {
+                    val ready = args[0] as Boolean
+                    setPlayWhenReadyCalls.add(ready)
+                    calls.add("playWhenReady:$ready")
+                    null
+                }
+                "seekTo" -> {
+                    val pos = when (args.size) {
+                        1 -> args[0] as Long
+                        else -> args[1] as Long
+                    }
+                    calls.add("seek:$pos")
+                    null
+                }
+                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/GlideBitmapLoaderTest.kt

@@ -0,0 +1,76 @@
+package org.dwbn.plugins.playlist.service
+
+import androidx.media3.common.MediaMetadata
+import java.util.concurrent.ExecutionException
+import java.util.concurrent.TimeUnit
+import org.junit.Assert.assertFalse
+import org.junit.Assert.assertNull
+import org.junit.Assert.assertTrue
+import org.junit.Test
+import org.junit.runner.RunWith
+import org.robolectric.RobolectricTestRunner
+import org.robolectric.RuntimeEnvironment
+import org.robolectric.annotation.Config
+
+@RunWith(RobolectricTestRunner::class)
+@Config(sdk = [28])
+class GlideBitmapLoaderTest {
+
+    private val loader: GlideBitmapLoader
+        get() = GlideBitmapLoader(RuntimeEnvironment.getApplication())
+
+    @Test
+    fun imageJpeg_isSupportedMimeType() {
+        assertTrue(GlideBitmapLoader.isSupportedImageMimeType("image/jpeg"))
+    }
+
+    @Test
+    fun imagePng_isSupportedMimeType() {
+        assertTrue(GlideBitmapLoader.isSupportedImageMimeType("IMAGE/PNG"))
+    }
+
+    @Test
+    fun audioMpeg_isNotSupportedMimeType() {
+        assertFalse(GlideBitmapLoader.isSupportedImageMimeType("audio/mpeg"))
+    }
+
+    @Test
+    fun nullMimeType_isNotSupported() {
+        assertFalse(GlideBitmapLoader.isSupportedImageMimeType(null))
+    }
+
+    @Test
+    fun artworkUri_loadsRemoteArtwork() {
+        assertTrue(GlideBitmapLoader.shouldLoadRemoteArtwork("https://example.com/art.jpg"))
+    }
+
+    @Test
+    fun missingArtwork_doesNotLoadRemote() {
+        assertFalse(GlideBitmapLoader.shouldLoadRemoteArtwork(null))
+        assertFalse(GlideBitmapLoader.shouldLoadRemoteArtwork(""))
+    }
+
+    @Test
+    fun loadBitmapFromMetadata_returnsNullWhenNoArtwork() {
+        val metadata = MediaMetadata.Builder().setTitle("Lecture").build()
+        assertNull(loader.loadBitmapFromMetadata(metadata))
+    }
+
+    @Test
+    fun loadBitmapFromMetadata_returnsNullForEmptyArtworkBytes() {
+        val metadata = MediaMetadata.Builder()
+            .setArtworkData(ByteArray(0), MediaMetadata.PICTURE_TYPE_FRONT_COVER)
+            .build()
+        assertNull(loader.loadBitmapFromMetadata(metadata))
+    }
+
+    @Test
+    fun decodeBitmap_nonImageBytes_completesWithoutHanging() {
+        val future = loader.decodeBitmap(byteArrayOf(1, 2, 3, 4))
+        try {
+            future.get(2, TimeUnit.SECONDS)
+        } catch (e: ExecutionException) {
+            assertTrue(e.cause is IllegalStateException)
+        }
+    }
+}