capacitor-plugin-playlist 0.11.2 → 0.13.0

package/android/src/main/java/org/dwbn/plugins/playlist/data/AudioTrack.kt

@@ -1,32 +1,40 @@
 package org.dwbn.plugins.playlist.data
 
-import com.devbrackets.android.playlistcore.annotation.SupportedMediaType
-import com.devbrackets.android.playlistcore.api.PlaylistItem
-import com.devbrackets.android.playlistcore.manager.BasePlaylistManager
 import org.json.JSONException
 import org.json.JSONObject
 import java.util.concurrent.atomic.AtomicLong
 
-class AudioTrack (private val config: JSONObject) : PlaylistItem {
+class AudioTrack(private val config: JSONObject) {
     companion object {
         private val nextPlaylistId = AtomicLong(1)
     }
 
-    override val id: Long = nextPlaylistId.getAndIncrement()
+    val id: Long = nextPlaylistId.getAndIncrement()
 
     var bufferPercentFloat = 0f
         set(buff) {
             // There is a bug in MediaProgress where if bufferPercent == 100 it sets bufferPercentFloat
             // to 100 instead of to 1.
-            field = Math.min(Math.max(bufferPercentFloat, buff), 1f)
+            field = minOf(maxOf(bufferPercentFloat, buff), 1f)
         }
     var bufferPercent = 0
         set(buff) {
-            field = Math.max(bufferPercent, buff)
+            field = maxOf(bufferPercent, buff)
         }
     var duration: Long = 0
         set(dur) {
-            field = Math.max(0, dur)
+            field = maxOf(0, dur)
+        }
+
+    /**
+     * Last known playback position for this track, in ms. Seeded from the JS-supplied
+     * `startPosition` (seconds) at construction, and kept fresh by [org.dwbn.plugins.playlist.manager.PlaylistManager]
+     * whenever the player skips away from this track, so a later skip back within the same
+     * session resumes correctly instead of restarting at 0.
+     */
+    var startPositionMs: Long = (config.optDouble("startPosition", 0.0) * 1000.0).toLong()
+        set(value) {
+            field = maxOf(0, value)
         }
 
     fun toDict(): JSONObject {
@@ -39,7 +47,7 @@ class AudioTrack (private val config: JSONObject) : PlaylistItem {
             info.put("artist", artist)
             info.put("album", album)
             info.put("title", title)
-        } catch (e: JSONException) {
+        } catch (_: JSONException) {
             // I can think of no reason this would ever fail
         }
         return info
@@ -56,40 +64,32 @@ class AudioTrack (private val config: JSONObject) : PlaylistItem {
             } else trackId
         }
 
-    // Would really like to set this to true once the cache has it...
-    override val downloaded: Boolean
-        get() = false // Would really like to set this to true once the cache has it...
+    val downloaded: Boolean
+        get() = false
 
-    // ... at which point we can return a value here.
-    override val downloadedMediaUri: String?
-        get() = null // ... at which point we can return a value here.
+    val downloadedMediaUri: String?
+        get() = null
 
-    @get:SupportedMediaType
-    override val mediaType: Int
-        get() = BasePlaylistManager.AUDIO
-
-    override val mediaUrl: String
+    val mediaUrl: String
         get() = config.optString("assetUrl", "")
 
-    // we should have a good default here.
-    override val thumbnailUrl: String?
+    val thumbnailUrl: String?
         get() {
             val albumArt = config.optString("albumArt")
             return if (albumArt == "") {
                 null
-            } else albumArt // we should have a good default here.
+            } else albumArt
         }
 
-    override val artworkUrl: String?
+    val artworkUrl: String?
         get() = thumbnailUrl
 
-    override val title: String
+    val title: String
         get() = config.optString("title")
 
-    override val album: String
+    val album: String
         get() = config.optString("album")
 
-    override val artist: String
+    val artist: String
         get() = config.optString("artist")
-
 }

package/android/src/main/java/org/dwbn/plugins/playlist/handoff/VideoPlayerBridge.kt

@@ -0,0 +1,102 @@
+package org.dwbn.plugins.playlist.handoff
+
+import androidx.annotation.OptIn
+import androidx.media3.common.Player
+import androidx.media3.common.util.UnstableApi
+import org.dwbn.plugins.playlist.service.MediaService
+import java.util.concurrent.CopyOnWriteArrayList
+
+/**
+ * Process-local link from the video plugin ExoPlayer to the playlist [MediaService] session.
+ * Video attaches via reflection so the video module does not depend on the playlist module.
+ */
+@OptIn(UnstableApi::class)
+object VideoPlayerBridge {
+    @Volatile
+    private var activePlayer: Player? = null
+
+    private var playbackListener: Player.Listener? = null
+
+    private val playbackChangedListeners = CopyOnWriteArrayList<() -> Unit>()
+
+    @JvmStatic
+    fun attach(player: Player) {
+        detach(player)
+        activePlayer = player
+        val listener = object : Player.Listener {
+            override fun onEvents(player: Player, events: Player.Events) {
+                if (events.containsAny(
+                        Player.EVENT_PLAY_WHEN_READY_CHANGED,
+                        Player.EVENT_PLAYBACK_STATE_CHANGED,
+                        Player.EVENT_IS_PLAYING_CHANGED,
+                        Player.EVENT_MEDIA_METADATA_CHANGED,
+                        Player.EVENT_TIMELINE_CHANGED,
+                        Player.EVENT_POSITION_DISCONTINUITY
+                    )
+                ) {
+                    notifyPlaybackChanged()
+                }
+            }
+        }
+        playbackListener = listener
+        player.addListener(listener)
+        notifyPlaybackChanged()
+    }
+
+    @JvmStatic
+    fun detach(player: Player?) {
+        if (player == null) {
+            detachInternal()
+            notifyPlaybackChanged()
+            return
+        }
+        if (activePlayer !== player) {
+            return
+        }
+        detachInternal()
+        notifyPlaybackChanged()
+    }
+
+    @JvmStatic
+    fun activePlayer(): Player? = activePlayer
+
+    @JvmStatic
+    fun hasActivePlayer(): Boolean = activePlayer != null
+
+    @JvmStatic
+    fun addPlaybackChangedListener(listener: () -> Unit) {
+        playbackChangedListeners.addIfAbsent(listener)
+    }
+
+    @JvmStatic
+    fun removePlaybackChangedListener(listener: () -> Unit) {
+        playbackChangedListeners.remove(listener)
+    }
+
+    @JvmStatic
+    fun requestNotificationRefresh() {
+        MediaService.instance?.triggerNotificationUpdate()
+    }
+
+    /** Test-only reset. */
+    @JvmStatic
+    internal fun clearForTests() {
+        detachInternal()
+        playbackChangedListeners.clear()
+    }
+
+    private fun notifyPlaybackChanged() {
+        playbackChangedListeners.forEach { it() }
+        requestNotificationRefresh()
+    }
+
+    private fun detachInternal() {
+        val player = activePlayer
+        val listener = playbackListener
+        if (player != null && listener != null) {
+            player.removeListener(listener)
+        }
+        activePlayer = null
+        playbackListener = null
+    }
+}

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

@@ -0,0 +1,8 @@
+package org.dwbn.plugins.playlist.manager
+
+data class PlaybackProgress(
+    val position: Long,
+    val duration: Long,
+    val bufferPercent: Int,
+    val bufferPercentFloat: Float
+)