capacitor-plugin-playlist 0.11.2 → 0.13.0

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

@@ -1,117 +1,309 @@
 package org.dwbn.plugins.playlist.service
 
+import android.annotation.SuppressLint
 import android.app.Notification
-import android.app.Service
+import android.app.NotificationChannel
+import android.app.NotificationManager
+import android.app.PendingIntent
 import android.content.Intent
 import android.content.pm.ServiceInfo
 import android.os.Build
 import android.util.Log
-import com.devbrackets.android.playlistcore.components.playlisthandler.PlaylistHandler
-import com.devbrackets.android.playlistcore.service.BasePlaylistService
+import androidx.annotation.OptIn
+import androidx.annotation.RequiresApi
+import androidx.core.app.NotificationCompat
+import androidx.media3.common.AudioAttributes
+import androidx.media3.common.C
+import androidx.media3.common.util.UnstableApi
+import androidx.media3.exoplayer.ExoPlayer
+import androidx.media3.session.DefaultMediaNotificationProvider
+import androidx.media3.session.MediaSession
+import androidx.media3.session.MediaSessionService
+import androidx.media3.session.MediaStyleNotificationHelper
+import com.google.common.util.concurrent.Futures
+import com.google.common.util.concurrent.ListenableFuture
+import org.dwbn.plugins.playlist.FakeR
 import org.dwbn.plugins.playlist.PlaylistRuntime
-import org.dwbn.plugins.playlist.data.AudioTrack
+import org.dwbn.plugins.playlist.handoff.VideoPlayerBridge
 import org.dwbn.plugins.playlist.manager.PlaylistManager
-import org.dwbn.plugins.playlist.playlist.AudioApi
-import org.dwbn.plugins.playlist.playlist.AudioPlaylistHandler
-import org.dwbn.plugins.playlist.service.MediaImageProvider.OnImageUpdatedListener
 
 /**
- * A simple service that extends [BasePlaylistService] in order to provide
- * the application specific information required.
+ * Media3 [MediaSessionService] hosting one [ExoPlayer] and one [MediaSession] for audio playlists.
+ * Foreground notification is owned by [DefaultMediaNotificationProvider] after the session exists.
  */
-class MediaService : BasePlaylistService<AudioTrack, PlaylistManager>() {
+@OptIn(UnstableApi::class)
+class MediaService : MediaSessionService() {
     companion object {
         private const val TAG = "MediaService"
 
         @JvmStatic
         @Volatile
         var instance: MediaService? = null
+
+        /** Value [onUpdateNotificationAsync] must pass to super (retain forces FGS past Media3's 10-min cap). */
+        @JvmStatic
+        fun resolveHandoffNotificationForeground(retain: Boolean, media3Requested: Boolean): Boolean =
+            MediaNotificationPolicy.startInForegroundRequired(retain, media3Requested)
     }
 
+    private var exoPlayer: ExoPlayer? = null
+    private var mediaSession: MediaSession? = null
+    private var notificationProvider: DefaultMediaNotificationProvider? = null
+    private var inForeground = false
+
+    private val playlistManager: PlaylistManager
+        get() = PlaylistRuntime.getPlaylistManager(applicationContext)
+
     override fun onCreate() {
-        instance = this
         super.onCreate()
-        // Adds the audio player implementation, otherwise there's nothing to play media with
-        val newAudio = AudioApi(applicationContext)
-        newAudio.addErrorListener(playlistManager)
-        playlistManager.mediaPlayers.add(newAudio)
-    }
+        instance = this
+        // startForegroundService timeout starts before onCreate; player/session setup can exceed it.
+        startForegroundImmediately()
+        setListener(foregroundStartListener)
+        val notificationProvider = DefaultMediaNotificationProvider.Builder(this).build()
+        notificationProvider.setSmallIcon(smallIconRes())
+        this.notificationProvider = notificationProvider
+        setMediaNotificationProvider(notificationProvider)
+        setShowNotificationForIdlePlayer(MediaNotificationPolicy.SHOW_NOTIFICATION_WHEN_IDLE)
 
-    override fun onDestroy() {
-        instance = null
-        super.onDestroy()
+        val player = ExoPlayer.Builder(this)
+            .setAudioAttributes(
+                AudioAttributes.Builder()
+                    .setUsage(C.USAGE_MEDIA)
+                    .setContentType(C.AUDIO_CONTENT_TYPE_MUSIC)
+                    .build(),
+                MediaNotificationPolicy.HANDLE_AUDIO_FOCUS
+            )
+            .setHandleAudioBecomingNoisy(true)
+            .setWakeMode(MediaNotificationPolicy.WAKE_MODE)
+            .build()
+        exoPlayer = player
+        // Load items before the session is built so the notification controller sees a timeline.
+        playlistManager.attachPlayer(player)
 
-        // Releases and clears all the MediaPlayersMediaImageProvider
-        for (player in playlistManager.mediaPlayers) {
-            player.release()
-        }
-        playlistManager.mediaPlayers.clear()
+        val forwardingPlayer = HandoffForwardingPlayer(
+            player,
+            retain = { playlistManager.videoHandoffForegroundRetain },
+            onSkipToNext = { playlistManager.skipToNext() },
+            onSkipToPrevious = { playlistManager.skipToPrevious() },
+            previousAvailable = { playlistManager.isPreviousAvailable },
+            nextAvailable = { playlistManager.isNextAvailable }
+        )
+        val sessionBuilder = MediaSession.Builder(this, forwardingPlayer)
+            .setId(MediaNotificationPolicy.MEDIA_SESSION_ID)
+            .setBitmapLoader(GlideBitmapLoader(this))
+            .setCallback(
+                PlaylistMediaSessionCallback {
+                    val retain = playlistManager.videoHandoffForegroundRetain
+                    val videoAttached = VideoPlayerBridge.hasActivePlayer()
+                    PlaylistMediaSessionCallback.SkipAvailability(
+                        MediaNotificationPolicy.mediaNotificationSkipPreviousEnabled(
+                            playlistManager.isPreviousAvailable,
+                            retain,
+                            videoAttached
+                        ),
+                        MediaNotificationPolicy.mediaNotificationSkipNextEnabled(
+                            playlistManager.isNextAvailable,
+                            retain,
+                            videoAttached
+                        )
+                    )
+                }
+            )
+        sessionActivityPendingIntent()?.let { sessionBuilder.setSessionActivity(it) }
+        val session = sessionBuilder.build()
+        mediaSession = session
+        playlistManager.attachService(this)
+
+        startForegroundWithMedia3Notification(session)
+        // The app drives the player directly, so no MediaController ever connects through
+        // onGetSession. Without addSession, Media3 never manages this session's notification and
+        // the placeholder above keeps the first title forever (no artist, no track changes).
+        addSession(session)
+    }
+
+    override fun onGetSession(controllerInfo: MediaSession.ControllerInfo): MediaSession? {
+        return mediaSession
     }
 
+    @SuppressLint("NewApi")
     override fun onStartCommand(intent: Intent?, flags: Int, startId: Int): Int {
         return try {
             super.onStartCommand(intent, flags, startId)
-        } catch (e: android.app.ForegroundServiceStartNotAllowedException) {
-            // Android 12+ blocks foreground service start from background
-            // Log the error but don't crash - service can still function without foreground status
-            Log.w(TAG, "Cannot start foreground service: app is in background", e)
-            // Return START_NOT_STICKY so service won't be restarted if killed
-            // The service will continue as a regular service (may be killed by system)
-            Service.START_NOT_STICKY
+        } catch (e: SecurityException) {
+            onForegroundStartBlocked(e)
+            START_NOT_STICKY
+        } catch (e: IllegalStateException) {
+            if (MediaNotificationPolicy.isForegroundStartNotAllowedFromBackground(e)) {
+                onForegroundStartBlocked(e)
+                START_NOT_STICKY
+            } else {
+                throw e
+            }
         }
     }
 
-    override fun runAsForeground(notificationId: Int, notification: Notification) {
-        if (inForeground) {
-            playlistManager.mediaServiceInForeground = true
+    override fun onDestroy() {
+        clearListener()
+        playlistManager.detachPlayer()
+        mediaSession?.release()
+        mediaSession = null
+        exoPlayer?.release()
+        exoPlayer = null
+        instance = null
+        super.onDestroy()
+    }
+
+    fun isRunningInForeground(): Boolean = inForeground
+
+    /**
+     * Media3 owns FGS via [DefaultMediaNotificationProvider]. Do not call [startForeground] here:
+     * Android 12+ forbids restarting a foreground service from the background after video.
+     */
+    fun promoteToForeground() {
+        if (!MediaNotificationPolicy.shouldStartForegroundOnPromote()) {
             return
         }
+    }
 
-        inForeground = true
-        try {
-            if (Build.VERSION.SDK_INT < Build.VERSION_CODES.TIRAMISU) {
-                startForeground(notificationId, notification)
+    /**
+     * Media3 1.11.1 posts the MediaStyle notification from [onUpdateNotificationAsync].
+     * Overriding the 2-arg [onUpdateNotification] and calling it from onCreate does not.
+     */
+    override fun onUpdateNotificationAsync(
+        session: MediaSession,
+        startInForegroundRequired: Boolean
+    ): ListenableFuture<Void?> {
+        val required = resolveHandoffNotificationForeground(
+            playlistManager.videoHandoffForegroundRetain,
+            startInForegroundRequired
+        )
+        return try {
+            val result = super.onUpdateNotificationAsync(session, required)
+            inForeground = required
+            playlistManager.mediaServiceInForeground = required
+            result
+        } catch (e: SecurityException) {
+            onForegroundStartBlocked(e)
+            Futures.immediateFuture(null)
+        } catch (e: IllegalStateException) {
+            if (MediaNotificationPolicy.isForegroundStartNotAllowedFromBackground(e)) {
+                onForegroundStartBlocked(e)
+                Futures.immediateFuture(null)
             } else {
-                startForeground(notificationId, notification,
-                    ServiceInfo.FOREGROUND_SERVICE_TYPE_MEDIA_PLAYBACK)
+                throw e
             }
-            playlistManager.mediaServiceInForeground = true
-        } catch (e: android.app.ForegroundServiceStartNotAllowedException) {
-            // Android 12+ blocks foreground service start from background
-            // Log the error but don't crash - service can still function without foreground status
-            Log.w(TAG, "Cannot start foreground service: app is in background", e)
-            inForeground = false
-            playlistManager.mediaServiceInForeground = false
-            // Service will continue as a regular service (may be killed by system)
         }
     }
 
-    override fun endForeground(removeNotification: Boolean) {
-        if (playlistManager.videoHandoffForegroundRetain) {
+    private fun onForegroundStartBlocked(e: Throwable) {
+        Log.w(TAG, "Cannot start foreground service: app is in background", e)
+        inForeground = false
+        playlistManager.mediaServiceInForeground = false
+    }
+
+    fun endForeground(removeNotification: Boolean) {
+        if (MediaNotificationPolicy.shouldSkipEndForeground(playlistManager.videoHandoffForegroundRetain)) {
             return
         }
-        super.endForeground(removeNotification)
+        inForeground = false
         playlistManager.mediaServiceInForeground = false
+        if (removeNotification) {
+            stopForeground(STOP_FOREGROUND_REMOVE)
+        } else {
+            stopForeground(STOP_FOREGROUND_DETACH)
+        }
     }
 
-    fun isRunningInForeground(): Boolean = inForeground
+    fun updateForegroundNotification() {
+        triggerNotificationUpdate()
+    }
 
-    override val playlistManager: PlaylistManager
-        get() = PlaylistRuntime.getPlaylistManager(applicationContext)
+    /** Re-reads `options.icon` after `setOptions` so a running service picks up the app's icon. */
+    fun applyNotificationIcon() {
+        notificationProvider?.setSmallIcon(smallIconRes())
+        triggerNotificationUpdate()
+    }
 
-    override fun newPlaylistHandler(): PlaylistHandler<AudioTrack> {
-        val imageProvider = MediaImageProvider(applicationContext, object : OnImageUpdatedListener {
-            override fun onImageUpdated() {
-                playlistHandler.updateMediaControls()
-            }
-        }, playlistManager.options)
+    private fun smallIconRes(): Int =
+        MediaNotificationPolicy.smallIconRes(
+            FakeR.getId(this, "drawable", playlistManager.options.icon)
+        )
+
+    /** FGS within startForegroundService timeout; replaced by MediaStyle once the session exists. */
+    private fun startForegroundImmediately() {
+        startForegroundWith(buildImmediateNotification())
+    }
+
+    private fun buildImmediateNotification(): Notification {
+        return mediaNotificationBuilder().build()
+    }
+
+    /**
+     * Attach the Media3 session token so System UI shows play/pause/skip (API 33+ compact slots).
+     * Do not call [onUpdateNotification] here: Media3 1.11.1 only posts via [onUpdateNotificationAsync].
+     */
+    private fun startForegroundWithMedia3Notification(session: MediaSession) {
+        val notification = mediaNotificationBuilder()
+            .setStyle(MediaStyleNotificationHelper.MediaStyle(session))
+            .build()
+        startForegroundWith(notification)
+    }
+
+    private fun mediaNotificationBuilder(): NotificationCompat.Builder {
+        val channelId = DefaultMediaNotificationProvider.DEFAULT_CHANNEL_ID
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
+            val channel = NotificationChannel(
+                channelId,
+                "Audio playback",
+                NotificationManager.IMPORTANCE_LOW
+            )
+            getSystemService(NotificationManager::class.java).createNotificationChannel(channel)
+        }
+        val title = playlistManager.currentItem?.title?.takeIf { it.isNotEmpty() } ?: "Audio playback"
+        val builder = NotificationCompat.Builder(this, channelId)
+            .setSmallIcon(smallIconRes())
+            .setContentTitle(title)
+            .setOngoing(true)
+            .setOnlyAlertOnce(true)
+            .setForegroundServiceBehavior(NotificationCompat.FOREGROUND_SERVICE_IMMEDIATE)
+            .setVisibility(NotificationCompat.VISIBILITY_PUBLIC)
+        sessionActivityPendingIntent()?.let { builder.setContentIntent(it) }
+        return builder
+    }
+
+    private fun startForegroundWith(notification: Notification) {
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.Q) {
+            startForeground(
+                DefaultMediaNotificationProvider.DEFAULT_NOTIFICATION_ID,
+                notification,
+                ServiceInfo.FOREGROUND_SERVICE_TYPE_MEDIA_PLAYBACK
+            )
+        } else {
+            startForeground(DefaultMediaNotificationProvider.DEFAULT_NOTIFICATION_ID, notification)
+        }
+        inForeground = true
+        playlistManager.mediaServiceInForeground = true
+    }
 
-        return AudioPlaylistHandler.Builder(
-            applicationContext,
-            javaClass,
-            playlistManager,
-            imageProvider,
-            null
-        ).build()
+    private fun sessionActivityPendingIntent(): PendingIntent? {
+        val launchIntent = packageManager.getLaunchIntentForPackage(packageName) ?: return null
+        launchIntent.addFlags(MediaNotificationPolicy.sessionLaunchIntentFlags())
+        return PendingIntent.getActivity(
+            this,
+            0,
+            launchIntent,
+            PendingIntent.FLAG_UPDATE_CURRENT or PendingIntent.FLAG_IMMUTABLE
+        )
     }
-}
+
+    private val foregroundStartListener = object : Listener {
+        @RequiresApi(Build.VERSION_CODES.S)
+        override fun onForegroundServiceStartNotAllowedException() {
+            Log.w(TAG, "Cannot start foreground service: app is in background")
+            inForeground = false
+            playlistManager.mediaServiceInForeground = false
+        }
+    }
+
+}

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

@@ -0,0 +1,39 @@
+package org.dwbn.plugins.playlist.service
+
+import androidx.annotation.OptIn
+import androidx.media3.common.util.UnstableApi
+import androidx.media3.session.MediaSession
+
+/**
+ * Exposes play/pause and playlist skip commands to the system media notification controller
+ * without stripping Media3's default metadata commands.
+ */
+@OptIn(UnstableApi::class)
+internal class PlaylistMediaSessionCallback(
+    private val skipAvailability: () -> SkipAvailability
+) : MediaSession.Callback {
+
+    data class SkipAvailability(
+        val previousAvailable: Boolean,
+        val nextAvailable: Boolean
+    )
+
+    override fun onConnect(
+        session: MediaSession,
+        controller: MediaSession.ControllerInfo
+    ): MediaSession.ConnectionResult {
+        if (session.isMediaNotificationController(controller)) {
+            val availability = skipAvailability()
+            return MediaSession.ConnectionResult.AcceptedResultBuilder(session, controller)
+                .setAvailablePlayerCommands(
+                    MediaNotificationPolicy.playerCommandsForMediaNotification(
+                        MediaSession.ConnectionResult.DEFAULT_PLAYER_COMMANDS,
+                        availability.previousAvailable,
+                        availability.nextAvailable
+                    )
+                )
+                .build()
+        }
+        return super.onConnect(session, controller)
+    }
+}

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

@@ -0,0 +1,98 @@
+package org.dwbn.plugins.playlist
+
+import androidx.media3.common.MimeTypes
+import androidx.media3.common.PlaybackException
+import org.dwbn.plugins.playlist.data.AudioTrack
+import org.json.JSONObject
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertNull
+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 AudioMediaItemFactoryMimeTest {
+
+    @Test
+    fun extensionlessStream_setsHlsMimeOnMediaItem() {
+        val item = AudioMediaItemFactory.fromUrl("https://example.com/stream/audio", true)
+        assertEquals(MimeTypes.APPLICATION_M3U8, item.localConfiguration?.mimeType)
+    }
+
+    @Test
+    fun m3u8Url_setsHlsMimeOnMediaItem() {
+        val item = AudioMediaItemFactory.fromUrl("https://example.com/audio.m3u8", false)
+        assertEquals(MimeTypes.APPLICATION_M3U8, item.localConfiguration?.mimeType)
+    }
+
+    @Test
+    fun mp3Url_doesNotForceHlsMimeOnMediaItem() {
+        val item = AudioMediaItemFactory.fromUrl("https://example.com/lecture.mp3", false)
+        assertNull(item.localConfiguration?.mimeType)
+    }
+
+    @Test
+    fun fromAudioTrack_setsHlsMimeForExtensionlessStream() {
+        val json = JSONObject()
+        json.put("assetUrl", "https://example.com/stream/audio")
+        json.put("isStream", true)
+        val item = AudioMediaItemFactory.fromAudioTrack(AudioTrack(json))
+        assertEquals(MimeTypes.APPLICATION_M3U8, item.localConfiguration?.mimeType)
+    }
+
+    @Test
+    fun fromAudioTrack_emptyTitle_fallsBackToAudioPlayback() {
+        val json = JSONObject()
+        json.put("assetUrl", "https://example.com/lecture.mp3")
+        val item = AudioMediaItemFactory.fromAudioTrack(AudioTrack(json))
+        assertEquals("Audio playback", item.mediaMetadata.title.toString())
+    }
+
+    @Test
+    fun fromAudioTrack_setsArtworkUriFromAlbumArt() {
+        val json = JSONObject()
+        json.put("assetUrl", "https://example.com/lecture.mp3")
+        json.put("albumArt", "https://example.com/art.jpg")
+        json.put("title", "Lecture")
+        val item = AudioMediaItemFactory.fromAudioTrack(AudioTrack(json))
+        assertEquals("https://example.com/art.jpg", item.mediaMetadata.artworkUri.toString())
+        assertEquals("Lecture", item.mediaMetadata.title.toString())
+    }
+
+    @Test
+    fun nullUrl_doesNotThrow() {
+        val item = AudioMediaItemFactory.fromUrl(null, true)
+        assertNull(item.localConfiguration?.mimeType)
+    }
+}
+
+class RmxPlaybackErrorMapperTest {
+
+    @Test
+    fun decoderErrors_mapToDecode() {
+        assertEquals(
+            RmxAudioErrorType.RMXERR_DECODE,
+            RmxPlaybackErrorMapper.fromMedia3ErrorCode(PlaybackException.ERROR_CODE_DECODER_INIT_FAILED)
+        )
+        assertEquals(
+            RmxAudioErrorType.RMXERR_DECODE,
+            RmxPlaybackErrorMapper.fromMedia3ErrorCode(PlaybackException.ERROR_CODE_DECODING_FAILED)
+        )
+        assertEquals(
+            RmxAudioErrorType.RMXERR_DECODE,
+            RmxPlaybackErrorMapper.fromMedia3ErrorCode(PlaybackException.ERROR_CODE_DECODER_QUERY_FAILED)
+        )
+    }
+
+    @Test
+    fun ioErrors_mapToNoneSupported() {
+        assertEquals(
+            RmxAudioErrorType.RMXERR_NONE_SUPPORTED,
+            RmxPlaybackErrorMapper.fromMedia3ErrorCode(
+                PlaybackException.ERROR_CODE_IO_NETWORK_CONNECTION_FAILED
+            )
+        )
+    }
+}

package/android/src/test/java/org/dwbn/plugins/playlist/AudioMediaItemFactoryTest.java

@@ -0,0 +1,71 @@
+package org.dwbn.plugins.playlist;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertNull;
+import static org.junit.Assert.assertTrue;
+
+import org.dwbn.plugins.playlist.data.AudioTrack;
+import org.json.JSONObject;
+import org.junit.Test;
+
+public class AudioMediaItemFactoryTest {
+
+  @Test
+  public void m3u8Url_shouldUseHlsMimeType() {
+    assertTrue(AudioMediaItemFactory.shouldUseHlsMimeType("https://example.com/audio.m3u8", false));
+  }
+
+  @Test
+  public void extensionlessStream_shouldUseHlsMimeType() {
+    assertTrue(AudioMediaItemFactory.shouldUseHlsMimeType("https://example.com/stream/audio", true));
+  }
+
+  @Test
+  public void mp3Url_shouldNotForceHlsMimeType() {
+    assertFalse(AudioMediaItemFactory.shouldUseHlsMimeType("https://example.com/lecture.mp3", false));
+  }
+
+  @Test
+  public void albumArt_mapsToThumbnailUrlForArtworkUri() throws Exception {
+    JSONObject json = new JSONObject();
+    json.put("assetUrl", "https://example.com/lecture.mp3");
+    json.put("albumArt", "https://example.com/art.jpg");
+    json.put("title", "Lecture");
+    json.put("artist", "Lama Ole");
+    json.put("album", "Awareness");
+    AudioTrack track = new AudioTrack(json);
+
+    assertEquals("https://example.com/art.jpg", AudioMediaItemFactory.artworkUriString(track));
+    assertTrue(
+        org.dwbn.plugins.playlist.service.GlideBitmapLoader.shouldLoadRemoteArtwork(
+            AudioMediaItemFactory.artworkUriString(track)));
+  }
+
+  @Test
+  public void missingAlbumArt_doesNotLoadRemoteArtwork() throws Exception {
+    JSONObject json = new JSONObject();
+    json.put("assetUrl", "https://example.com/lecture.mp3");
+    json.put("title", "Lecture");
+    AudioTrack track = new AudioTrack(json);
+
+    assertNull(AudioMediaItemFactory.artworkUriString(track));
+    assertFalse(
+        org.dwbn.plugins.playlist.service.GlideBitmapLoader.shouldLoadRemoteArtwork(
+            AudioMediaItemFactory.artworkUriString(track)));
+  }
+
+  @Test
+  public void emptyAlbumArt_doesNotLoadRemoteArtwork() throws Exception {
+    JSONObject json = new JSONObject();
+    json.put("assetUrl", "https://example.com/lecture.mp3");
+    json.put("albumArt", "");
+    json.put("title", "Lecture");
+    AudioTrack track = new AudioTrack(json);
+
+    assertNull(AudioMediaItemFactory.artworkUriString(track));
+    assertFalse(org.dwbn.plugins.playlist.service.GlideBitmapLoader.shouldLoadRemoteArtwork(""));
+    assertFalse(org.dwbn.plugins.playlist.service.GlideBitmapLoader.shouldLoadRemoteArtwork(null));
+    assertNull(AudioMediaItemFactory.artworkUriString(null));
+  }
+}

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

@@ -0,0 +1,53 @@
+package org.dwbn.plugins.playlist.data
+
+import org.json.JSONObject
+import org.junit.Assert.assertEquals
+import org.junit.Test
+
+/** Coverage for [AudioTrack.startPositionMs] — the resume-position fix for skipToNext/Previous. */
+class AudioTrackTest {
+
+    private fun trackConfig(startPosition: Double? = null): JSONObject {
+        val json = JSONObject()
+        json.put("assetUrl", "https://example.com/a.mp3")
+        json.put("artist", "Artist")
+        json.put("album", "Album")
+        json.put("title", "Title")
+        if (startPosition != null) {
+            json.put("startPosition", startPosition)
+        }
+        return json
+    }
+
+    @Test
+    fun startPositionMs_parsesSecondsFromJsAsMilliseconds() {
+        val track = AudioTrack(trackConfig(startPosition = 58.294))
+
+        assertEquals(58294L, track.startPositionMs)
+    }
+
+    @Test
+    fun startPositionMs_defaultsToZeroWhenAbsent() {
+        val track = AudioTrack(trackConfig(startPosition = null))
+
+        assertEquals(0L, track.startPositionMs)
+    }
+
+    @Test
+    fun startPositionMs_canBeUpdatedAfterConstruction() {
+        val track = AudioTrack(trackConfig(startPosition = 10.0))
+
+        track.startPositionMs = 42_000L
+
+        assertEquals(42_000L, track.startPositionMs)
+    }
+
+    @Test
+    fun startPositionMs_clampsNegativeToZero() {
+        val track = AudioTrack(trackConfig(startPosition = 10.0))
+
+        track.startPositionMs = -5L
+
+        assertEquals(0L, track.startPositionMs)
+    }
+}