@mustafaj/capacitor-plugin-playlist 0.9.0

package/android/src/main/java/org/dwbn/plugins/playlist/RmxAudioPlayer.java

@@ -0,0 +1,487 @@
+package org.dwbn.plugins.playlist;
+
+import android.util.Log;
+
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+import androidx.annotation.OptIn;
+import androidx.media3.common.util.UnstableApi;
+import androidx.media3.exoplayer.ExoPlaybackException;
+
+import com.devbrackets.android.exomedia.listener.OnErrorListener;
+import com.devbrackets.android.playlistcore.data.MediaProgress;
+import com.devbrackets.android.playlistcore.data.PlaybackState;
+import com.devbrackets.android.playlistcore.data.PlaylistItemChange;
+import com.devbrackets.android.playlistcore.listener.PlaybackStatusListener;
+import com.devbrackets.android.playlistcore.listener.PlaylistListener;
+import com.devbrackets.android.playlistcore.listener.ProgressListener;
+
+import org.dwbn.plugins.playlist.data.AudioTrack;
+import org.dwbn.plugins.playlist.manager.MediaControlsListener;
+import org.dwbn.plugins.playlist.manager.Options;
+import org.dwbn.plugins.playlist.manager.PlaylistManager;
+import org.json.JSONException;
+import org.json.JSONObject;
+
+/**
+ * The implementation of this player borrows from ExoMedia's demo example
+ * and utilizes heavily those classes, basically because that is "the" way
+ * to actually use ExoMedia.
+ */
+public class RmxAudioPlayer implements PlaybackStatusListener<AudioTrack>,
+        PlaylistListener<AudioTrack>, ProgressListener, OnErrorListener, MediaControlsListener {
+
+    public static String TAG = "PlaylistRmxAudioPlayer";
+
+    // PlaylistCore requires this but we don't use it
+    // It would be used to switch between playlists. I guess we could
+    // support that in the future, might be cool.
+    private static final int PLAYLIST_ID = 32;
+    private PlaylistManager playlistManager;
+    private final OnStatusReportListener statusListener;
+
+    private int lastBufferPercent = 0;
+    private long lastDuration = 0;
+    private boolean trackLoaded = false;
+    private boolean resetStreamOnPause = true;
+    private String pendingSelectionTrackId = null;
+    private boolean suppressSelectionPlaybackEvents = false;
+    private final App app;
+
+    public RmxAudioPlayer(@NonNull OnStatusReportListener statusListener, App context) {
+        // AudioPlayerPlugin and RmxAudioPlayer are separate classes in order to increase
+        // the portability of this code.
+        // Because AudioPlayerPlugin itself holds a strong reference to this class,
+        // we can hold a strong reference to this shared callback. Normally not a good idea
+        // but these two objects will always live together (And the plugin couldn't function
+        // at all if this one gets garbage collected).
+        this.statusListener = statusListener;
+        this.app = context;
+
+        app.resetPlaylistManager();
+        getPlaylistManager();
+        playlistManager.setId(PLAYLIST_ID);
+        playlistManager.setPlaybackStatusListener(this);
+        playlistManager.setOnErrorListener(this);
+        playlistManager.setMediaControlsListener(this);
+    }
+
+    public PlaylistManager getPlaylistManager() {
+        playlistManager = app.getPlaylistManager();
+        return playlistManager;
+    }
+
+    public boolean getResetStreamOnPause() {
+        return resetStreamOnPause;
+    } 
+
+    public void setResetStreamOnPause(boolean val) {
+        resetStreamOnPause = val;
+        getPlaylistManager().setResetStreamOnPause(getResetStreamOnPause());
+    }
+
+    public void setOptions(JSONObject val) {
+        Options options = new Options(app, val);
+        getPlaylistManager().setOptions(options);
+    }
+
+    public void prepareForTrackSelection(@Nullable String trackId) {
+        pendingSelectionTrackId = trackId;
+        suppressSelectionPlaybackEvents = trackId != null;
+    }
+
+    public void clearTrackSelectionSuppression() {
+        pendingSelectionTrackId = null;
+        suppressSelectionPlaybackEvents = false;
+    }
+
+    private boolean isSuppressingSelection(@Nullable AudioTrack item) {
+        return suppressSelectionPlaybackEvents
+                && pendingSelectionTrackId != null
+                && item != null
+                && pendingSelectionTrackId.equals(item.getTrackId());
+    }
+
+    public float getVolume() {
+        return (getVolumeLeft() + getVolumeRight()) / 2f;
+    }
+
+    public float getVolumeLeft() {
+        return playlistManager.getVolumeLeft();
+    }
+
+    public float getVolumeRight() {
+        return playlistManager.getVolumeRight();
+    }
+
+    public void setVolume(float both) {
+        setVolume(both, both);
+    }
+
+    public void setVolume(float left, float right) {
+        playlistManager.setVolume(left, right);
+    }
+
+    public void onCompletion(AudioTrack item) {
+        if (item != null) {
+            String trackId = item.getTrackId();
+            JSONObject trackStatus = getPlayerStatus(item);
+            onStatus(RmxAudioStatusMessage.RMXSTATUS_COMPLETED, trackId, trackStatus);
+        }
+
+        if (!playlistManager.isNextAvailable()) {
+            onStatus(RmxAudioStatusMessage.RMXSTATUS_PLAYLIST_COMPLETED, "INVALID", null);
+        }
+    }
+
+    @Override
+    public void onPrevious(AudioTrack currentItem, int currentIndex) {
+        JSONObject param = new JSONObject();
+        String trackId = currentItem == null ? "NONE" : currentItem.getTrackId();
+
+        try {
+            param.put("currentIndex", currentIndex);
+            param.put("currentItem", currentItem != null ? currentItem.toDict() : null);
+        } catch (JSONException e) {
+            Log.i(TAG, "Error generating onPrevious status message: " + e.toString());
+        }
+
+        onStatus(RmxAudioStatusMessage.RMX_STATUS_SKIP_BACK, trackId, param);
+    }
+
+    @Override
+    public void onNext(AudioTrack currentItem, int currentIndex) {
+        JSONObject param = new JSONObject();
+        String trackId = currentItem == null ? "NONE" : currentItem.getTrackId();
+
+        try {
+            param.put("currentIndex", currentIndex);
+            param.put("currentItem", currentItem != null ? currentItem.toDict() : null);
+        } catch (JSONException e) {
+            Log.i(TAG, "Error generating onNext status message: " + e.toString());
+        }
+        onStatus(RmxAudioStatusMessage.RMX_STATUS_SKIP_FORWARD, trackId, param);
+    }
+
+    @OptIn(markerClass = UnstableApi.class) @Override
+    public boolean onError(Exception e) {
+        String errorMsg = e.toString();
+        RmxAudioErrorType errorType = RmxAudioErrorType.RMXERR_NONE_SUPPORTED;
+
+        if (e instanceof ExoPlaybackException) {
+            switch (((ExoPlaybackException) e).type) {
+                case ExoPlaybackException.TYPE_SOURCE:
+                    errorMsg = "ExoPlaybackException.TYPE_SOURCE: " + ((ExoPlaybackException) e).getSourceException().getMessage();
+                    break;
+                case ExoPlaybackException.TYPE_RENDERER:
+                    errorType = RmxAudioErrorType.RMXERR_DECODE;
+                    errorMsg = "ExoPlaybackException.TYPE_RENDERER: " + ((ExoPlaybackException) e).getRendererException().getMessage();
+                    break;
+                case ExoPlaybackException.TYPE_UNEXPECTED:
+                    errorType = RmxAudioErrorType.RMXERR_DECODE;
+                    errorMsg = "ExoPlaybackException.TYPE_UNEXPECTED: " + ((ExoPlaybackException) e).getUnexpectedException().getMessage();
+                    break;
+            }
+        }
+
+        AudioTrack errorItem = playlistManager.getCurrentErrorTrack();
+        String trackId = errorItem != null ? errorItem.getTrackId() : "INVALID";
+
+        Log.i(TAG, "Error playing audio track: [" + trackId + "]: " + errorMsg);
+        onError(errorType, trackId, errorMsg);
+        playlistManager.setCurrentErrorTrack(null);
+        return true;
+    }
+
+    @Override
+    public void onMediaPlaybackStarted(AudioTrack item, long currentPosition, long duration) {
+        Log.i(TAG, "onMediaPlaybackStarted: ==> " + item.getTitle() + ": " + currentPosition + "," + duration);
+        // this is the first place that valid duration is seen. Immediately before, we get the PLAYING status change,
+        // and before that, it announces PREPARING twice and all values are 0.
+        // Problem is, this method is only called if playback is already in progress when the track changes,
+        // which is useless in most cases. So, these values are actually handled in onProgressUpdated.
+    }
+
+    @Override
+    public void onItemPlaybackEnded(AudioTrack item) {
+        if (item != null) {
+            String trackId = item.getTrackId();
+            JSONObject trackStatus = getPlayerStatus(item);
+            onStatus(RmxAudioStatusMessage.RMXSTATUS_STOPPED, trackId, trackStatus);
+        }
+    }
+
+    @Override
+    public void onPlaylistEnded() {
+        Log.i(TAG, "onPlaylistEnded");
+        playlistManager.setShouldStopPlaylist(false);
+    }
+
+    @Override
+    public boolean onPlaylistItemChanged(@Nullable AudioTrack currentItem, boolean hasNext, boolean hasPrevious) {
+        JSONObject info = new JSONObject();
+        String trackId = currentItem == null ? "NONE" : currentItem.getTrackId();
+        try {
+            info.put("currentItem", currentItem != null ? currentItem.toDict() : null);
+            info.put("currentIndex", playlistManager.getCurrentPosition());
+            info.put("isAtEnd", !hasNext);
+            info.put("isAtBeginning", !hasPrevious);
+            info.put("hasNext", hasNext);
+            info.put("hasPrevious", hasPrevious);
+        } catch (JSONException e) {
+            Log.e(TAG, "Error creating onPlaylistItemChanged message: " + e.toString());
+        }
+
+        lastDuration = 0;
+        lastBufferPercent = 0;
+        trackLoaded = false;
+
+        onStatus(RmxAudioStatusMessage.RMXSTATUS_TRACK_CHANGED, trackId, info);
+        return true;
+    }
+
+    @Override
+    public boolean onPlaybackStateChanged(@NonNull PlaybackState playbackState) {
+        // in testing, I saw PREPARING, then PLAYING, and buffering happened
+        // during PLAYING. Tapping play/pause toggles PLAYING and PAUSED
+        // sending a seek command produces SEEKING here
+        // RETRIEVING is never sent.
+
+        AudioTrack currentItem = playlistManager.getCurrentItem();
+        JSONObject trackStatus = getPlayerStatus(currentItem);
+        boolean suppressSelection = isSuppressingSelection(currentItem);
+        Log.i("onPlaybackStateChanged", playbackState.toString() + ", " + trackStatus.toString() + ", " + currentItem);
+
+        switch (playbackState) {
+            case STOPPED:
+                if (suppressSelection) {
+                    clearTrackSelectionSuppression();
+                    break;
+                }
+                onStatus(RmxAudioStatusMessage.RMXSTATUS_STOPPED, "INVALID", null);
+                break;
+
+            case RETRIEVING: // these are all loading states
+            case PREPARING: {
+                if (currentItem != null && currentItem.getTrackId() != null) {
+                    onStatus(RmxAudioStatusMessage.RMXSTATUS_LOADING, currentItem.getTrackId(), trackStatus);
+                }
+                break;
+            }
+            case SEEKING: {
+                MediaProgress progress = playlistManager.getCurrentProgress();
+                if (currentItem != null && currentItem.getTrackId() != null && progress != null) {
+                    JSONObject info = new JSONObject();
+                    try {
+                        info.put("position", progress.getPosition() / 1000f);
+                        onStatus(RmxAudioStatusMessage.RMXSTATUS_SEEK, currentItem.getTrackId(), info);
+                    } catch (JSONException e) {
+                        Log.e(TAG, "Error generating seeking status message: " + e.toString());
+                    }
+                }
+                break;
+            }
+            case PLAYING:
+                if (suppressSelection) {
+                    break;
+                }
+                if (currentItem != null && currentItem.getTrackId() != null) {
+                    // Can also check here that duration == 0, because that is what happens on the first PLAYING invokation.
+                    // We'll leave this for now.
+                    if (!trackLoaded) {
+                        onStatus(RmxAudioStatusMessage.RMXSTATUS_CANPLAY, currentItem.getTrackId(), trackStatus);
+                        trackLoaded = true;
+                    }
+                    onStatus(RmxAudioStatusMessage.RMXSTATUS_PLAYING, currentItem.getTrackId(), trackStatus);
+                }
+                break;
+            case PAUSED:
+                if (suppressSelection) {
+                    clearTrackSelectionSuppression();
+                    break;
+                }
+                if (currentItem != null && currentItem.getTrackId() != null) {
+                    onStatus(RmxAudioStatusMessage.RMXSTATUS_PAUSE, currentItem.getTrackId(), trackStatus);
+                }
+                break;
+            // we'll handle error in the listener. ExoMedia only raises this in the case of catastrophic player failure.
+            case ERROR:
+                if (suppressSelection) {
+                    clearTrackSelectionSuppression();
+                }
+            default:
+                break;
+        }
+
+        return true;
+    }
+
+    @Override
+    public boolean onProgressUpdated(@NonNull MediaProgress progress) {
+        // Order matters here. We must update the item's duration and buffer before pulling the track status,
+        // because those values are adjusted to account for the buffering-reset in ExoPlayer.
+        AudioTrack currentItem = playlistManager.getCurrentItem();
+        PlaybackState playbackState = playlistManager.getCurrentPlaybackState();
+
+        if (currentItem != null) { // I mean, this call makes no sense otherwise..
+            currentItem.setDuration(progress.getDuration());
+            currentItem.setBufferPercent(progress.getBufferPercent());
+            currentItem.setBufferPercentFloat(progress.getBufferPercentFloat());
+
+            JSONObject trackStatus = getPlayerStatus(currentItem);
+            boolean suppressSelection = isSuppressingSelection(currentItem);
+
+            if (progress.getBufferPercent() != lastBufferPercent) {
+                if (progress.getBufferPercent() >= 100f) {
+                    // Unlike iOS this will get raised continuously.
+                    // Extracting the source event from playlistcore would be really hard.
+                    // The gate above should do the trick.
+                    onStatus(RmxAudioStatusMessage.RMXSTATUS_LOADED, currentItem.getTrackId(), trackStatus);
+                }
+
+                if (!trackLoaded) {
+                    onStatus(RmxAudioStatusMessage.RMXSTATUS_CANPLAY, currentItem.getTrackId(), trackStatus);
+                    trackLoaded = true;
+                }
+
+                onStatus(RmxAudioStatusMessage.RMXSTATUS_BUFFERING, currentItem.getTrackId(), trackStatus);
+                lastBufferPercent = progress.getBufferPercent();
+            }
+
+            if (lastDuration != progress.getDuration() && progress.getDuration() > 0) {
+                onStatus(RmxAudioStatusMessage.RMXSTATUS_DURATION, currentItem.getTrackId(), trackStatus);
+                lastDuration = progress.getDuration();
+            }
+
+            if (!suppressSelection
+                    && (playbackState == PlaybackState.PLAYING || playbackState == PlaybackState.SEEKING)) {
+                onStatus(RmxAudioStatusMessage.RMXSTATUS_PLAYBACK_POSITION, currentItem.getTrackId(), trackStatus);
+            }
+        }
+
+        return true;
+    }
+
+    public JSONObject getPlayerStatus(@Nullable AudioTrack statusItem) {
+        // TODO: Make this its own object.
+        AudioTrack currentItem = statusItem != null ? statusItem : playlistManager.getCurrentItem();
+        PlaybackState playbackState = playlistManager.getCurrentPlaybackState();
+        MediaProgress progress = playlistManager.getCurrentProgress();
+
+        String status = "unknown";
+        switch (playbackState) {
+            case STOPPED: {
+                status = "stopped";
+                break;
+            }
+            case ERROR: {
+                status = "error";
+                break;
+            }
+            case RETRIEVING:
+            case SEEKING: // { status = "seeking"; break; } // seeking === loading
+            case PREPARING: {
+                status = "loading";
+                break;
+            }
+            case PLAYING: {
+                status = "playing";
+                break;
+            }
+            case PAUSED: {
+                status = "paused";
+                break;
+            }
+            default:
+                break;
+        }
+
+        String trackId = "";
+        boolean isStream = false;
+        float bufferPercentFloat = 0;
+        int bufferPercent = 0;
+        long duration = 0;
+        long position = 0;
+
+        // The media players hold onto their current playback position between songs,
+        // despite my efforts to reset it. So we will just filter out this state.
+        if (progress != null && playbackState != PlaybackState.RETRIEVING && playbackState != PlaybackState.PREPARING) {
+            position = progress.getPosition();
+        }
+
+        // the position and duration vals are in milliseconds.
+        if (currentItem != null) {
+            isStream = currentItem.isStream();
+            trackId = currentItem.getTrackId();
+            bufferPercentFloat = currentItem.getBufferPercentFloat(); // progress.
+            bufferPercent = currentItem.getBufferPercent(); // progress.
+            duration = currentItem.getDuration(); // progress.
+        }
+
+        JSONObject trackStatus = new JSONObject();
+        try {
+            trackStatus.put("trackId", trackId);
+            trackStatus.put("isStream", isStream);
+            trackStatus.put("currentIndex", playlistManager.getCurrentPosition());
+            trackStatus.put("status", status);
+            trackStatus.put("currentPosition", position / 1000.0);
+            trackStatus.put("duration", duration / 1000.0);
+            trackStatus.put("playbackPercent", duration > 0 ? (((double) position / duration) * 100.0) : 0);
+            trackStatus.put("bufferPercent", bufferPercent);
+            trackStatus.put("bufferStart", 0.0);
+            trackStatus.put("bufferEnd", (bufferPercentFloat * duration) / 1000.0);
+        } catch (JSONException e) {
+            Log.e(TAG, "Error generating player status: " + e.toString());
+        }
+
+        return trackStatus;
+    }
+
+    public void pause() {
+        Log.i(TAG, "Pausing, removing event listeners");
+        removePlaylistListeners();
+    }
+
+    public void resume() {
+        Log.i(TAG, "Resumed, wiring up event listeners");
+        getPlaylistManager();
+        registerPlaylistListeners();
+        //Makes sure to retrieve the current playback information
+        updateCurrentPlaybackInformation();
+    }
+
+    private void updateCurrentPlaybackInformation() {
+        PlaylistItemChange<AudioTrack> itemChange = playlistManager.getCurrentItemChange();
+        if (itemChange != null) {
+            onPlaylistItemChanged(itemChange.getCurrentItem(), itemChange.getHasNext(), itemChange.getHasPrevious());
+        }
+
+        PlaybackState currentPlaybackState = playlistManager.getCurrentPlaybackState();
+        if (currentPlaybackState != PlaybackState.STOPPED) {
+            onPlaybackStateChanged(currentPlaybackState);
+        }
+
+        MediaProgress mediaProgress = playlistManager.getCurrentProgress();
+        if (mediaProgress != null) {
+            onProgressUpdated(mediaProgress);
+        }
+    }
+
+    private void registerPlaylistListeners() {
+        playlistManager.registerPlaylistListener(this);
+        playlistManager.registerProgressListener(this);
+    }
+
+    private void removePlaylistListeners() {
+        playlistManager.unRegisterPlaylistListener(this);
+        playlistManager.unRegisterProgressListener(this);
+    }
+
+    private void onError(RmxAudioErrorType errorCode, String trackId, String message) {
+        statusListener.onError(errorCode, trackId, message);
+    }
+
+    private void onStatus(RmxAudioStatusMessage what, String trackId, JSONObject param) {
+        statusListener.onStatus(what, trackId, param);
+    }
+}

package/android/src/main/java/org/dwbn/plugins/playlist/RmxAudioStatusMessage.java

@@ -0,0 +1,35 @@
+package org.dwbn.plugins.playlist;
+
+public enum RmxAudioStatusMessage {
+  RMXSTATUS_NONE(0),
+  RMXSTATUS_REGISTER(1),
+  RMXSTATUS_INIT(2),
+  RMXSTATUS_ERROR(5),
+
+  RMXSTATUS_LOADING(10),
+  RMXSTATUS_CANPLAY(11),
+  RMXSTATUS_LOADED(15),
+  RMXSTATUS_STALLED(20),
+  RMXSTATUS_BUFFERING(25),
+  RMXSTATUS_PLAYING(30),
+  RMXSTATUS_PAUSE(35),
+  RMXSTATUS_PLAYBACK_POSITION(40),
+  RMXSTATUS_SEEK(45),
+  RMXSTATUS_COMPLETED(50),
+  RMXSTATUS_DURATION(55),
+  RMXSTATUS_STOPPED(60),
+
+  RMX_STATUS_SKIP_FORWARD(90),
+  RMX_STATUS_SKIP_BACK(95),
+  RMXSTATUS_TRACK_CHANGED(100),
+  RMXSTATUS_PLAYLIST_COMPLETED(105),
+  RMXSTATUS_ITEM_ADDED(110),
+  RMXSTATUS_ITEM_REMOVED(115),
+  RMXSTATUS_PLAYLIST_CLEARED(120),
+
+  RMXSTATUS_VIEWDISAPPEAR(200); // just for testing
+
+  private final int id;
+  RmxAudioStatusMessage(int id) { this.id = id; }
+  public int getValue() { return id; }
+};

package/android/src/main/java/org/dwbn/plugins/playlist/RmxConstants.java

@@ -0,0 +1,42 @@
+package org.dwbn.plugins.playlist;
+
+public interface RmxConstants {
+  String DOCUMENTS_SCHEME_PREFIX  = "documents://";
+  String HTTP_SCHEME_PREFIX       = "http://";
+  String HTTPS_SCHEME_PREFIX      = "https://";
+  String CDVFILE_PREFIX           = "cdvfile://";
+
+  // Playlist item management
+  String SET_OPTIONS            = "setOptions";
+  String INITIALIZE             = "initialize";
+  String SET_PLAYLIST_ITEMS     = "setPlaylistItems";
+  String ADD_PLAYLIST_ITEM      = "addItem";
+  String ADD_PLAYLIST_ITEMS     = "addAllItems";
+  String REMOVE_PLAYLIST_ITEM   = "removeItem";
+  String REMOVE_PLAYLIST_ITEMS  = "removeItems";
+  String CLEAR_PLAYLIST_ITEMS   = "clearAllItems";
+
+  // Playback
+  String PLAY                   = "play";
+  String PLAY_BY_INDEX          = "playTrackByIndex";
+  String PLAY_BY_ID             = "playTrackById";
+  String SELECT_BY_INDEX        = "selectTrackByIndex";
+  String SELECT_BY_ID           = "selectTrackById";
+  String PAUSE                  = "pause";
+  String SKIP_FORWARD           = "skipForward";
+  String SKIP_BACK              = "skipBack";
+  String SEEK                   = "seekTo";
+  String SEEK_TO_QUEUE_POSITION = "seekToQueuePosition";
+  String SET_PLAYBACK_RATE      = "setPlaybackRate";
+  String SET_PLAYBACK_VOLUME    = "setPlaybackVolume";
+  String SET_LOOP_ALL           = "setLoopAll";
+
+  // Getters, should almost always be unneeded since the status is continually reported.
+  String GET_PLAYBACK_RATE      = "getPlaybackRate";
+  String GET_PLAYBACK_VOLUME    = "getPlaybackVolume";
+  String GET_PLAYBACK_POSITION  = "getPlaybackPosition";
+  String GET_BUFFER_STATUS      = "getCurrentBuffer";
+  String GET_QUEUE_POSITION     = "getQueuePosition";
+
+  String RELEASE = "release";
+}

package/android/src/main/java/org/dwbn/plugins/playlist/TrackRemovalItem.java

@@ -0,0 +1,12 @@
+package org.dwbn.plugins.playlist;
+
+public class TrackRemovalItem {
+    public int trackIndex = -1;
+    public String trackId = "";
+
+    TrackRemovalItem(int index, String id) {
+        trackIndex = index;
+        trackId = id;
+    }
+}
+

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

@@ -0,0 +1,94 @@
+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
+
+class AudioTrack (private val config: JSONObject) : PlaylistItem {
+    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)
+        }
+    var bufferPercent = 0
+        set(buff) {
+            field = Math.max(bufferPercent, buff)
+        }
+    var duration: Long = 0
+        set(dur) {
+            field = Math.max(0, dur)
+        }
+
+    fun toDict(): JSONObject {
+        val info = JSONObject()
+        try {
+            info.put("trackId", trackId)
+            info.put("isStream", isStream)
+            info.put("assetUrl", mediaUrl)
+            info.put("albumArt", thumbnailUrl)
+            info.put("artist", artist)
+            info.put("album", album)
+            info.put("title", title)
+        } catch (e: JSONException) {
+            // I can think of no reason this would ever fail
+        }
+        return info
+    }
+
+    override val id: Long
+        get() =
+            if (trackId == null) {
+                0
+            } else trackId.hashCode().toLong()
+
+    val isStream: Boolean
+        get() = config.optBoolean("isStream", false)
+
+    val trackId: String?
+        get() {
+            val trackId = config.optString("trackId")
+            return if (trackId == "") {
+                null
+            } 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...
+
+    // ... at which point we can return a value here.
+    override val downloadedMediaUri: String?
+        get() = null // ... at which point we can return a value here.
+
+    @get:SupportedMediaType
+    override val mediaType: Int
+        get() = BasePlaylistManager.AUDIO
+
+    override val mediaUrl: String
+        get() = config.optString("assetUrl", "")
+
+    // we should have a good default here.
+    override val thumbnailUrl: String?
+        get() {
+            val albumArt = config.optString("albumArt")
+            return if (albumArt == "") {
+                null
+            } else albumArt // we should have a good default here.
+        }
+
+    override val artworkUrl: String?
+        get() = thumbnailUrl
+
+    override val title: String
+        get() = config.optString("title")
+
+    override val album: String
+        get() = config.optString("album")
+
+    override val artist: String
+        get() = config.optString("artist")
+
+}

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

@@ -0,0 +1,13 @@
+package org.dwbn.plugins.playlist.manager
+
+import org.dwbn.plugins.playlist.data.AudioTrack
+
+/*
+* Interface to enable the PlaylistManager to send these events out.
+* We could add more like play/pause/toggle/stop, but right now there
+* are other ways to get all the other information.
+*/
+interface MediaControlsListener {
+    fun onNext(currentItem: AudioTrack?, currentIndex: Int)
+    fun onPrevious(currentItem: AudioTrack?, currentIndex: Int)
+}