@mustafaj/capacitor-plugin-playlist 0.9.0

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

@@ -0,0 +1,77 @@
+/*
+ * Apache 2.0 License
+ *
+ * Copyright (c) Sebastian Katzer 2017
+ *
+ * This file contains Original Code and/or Modifications of Original Code
+ * as defined in and that are subject to the Apache License
+ * Version 2.0 (the 'License'). You may not use this file except in
+ * compliance with the License. Please obtain a copy of the License at
+ * http://opensource.org/licenses/Apache-2.0/ and read it before using this
+ * file.
+ *
+ * The Original Code and all software distributed under the License are
+ * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
+ * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
+ * Please see the License for the specific language governing rights and
+ * limitations under the License.
+ */
+package org.dwbn.plugins.playlist.manager
+
+import android.content.Context
+import org.json.JSONObject
+
+class Options {
+    /**
+     * Wrapped JSON object.
+     */
+    // The original JSON object
+    val dict: JSONObject
+
+    /**
+     * Application context.
+     */
+    // The application context
+    val context: Context
+
+    /**
+     * Constructor
+     *
+     * @param context The application context.
+     */
+    constructor(context: Context) {
+        this.context = context
+        dict = JSONObject()
+    }
+
+    /**
+     * Constructor
+     *
+     * @param context The application context.
+     * @param options The options dict map.
+     */
+    constructor(context: Context, options: JSONObject) {
+        this.context = context
+        dict = options
+    }
+
+    /**
+     * JSON object as string.
+     */
+    override fun toString(): String {
+        return dict.toString()
+    }
+
+    /**
+     * icon resource ID for the local notification.
+     */
+    val icon: String
+        get() = dict.optString("icon", DEFAULT_ICON)
+
+    companion object {
+        // Default icon path
+        private const val DEFAULT_ICON = "icon"
+    }
+}

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

@@ -0,0 +1,308 @@
+package org.dwbn.plugins.playlist.manager
+
+import android.app.Application
+import android.util.Log
+import androidx.annotation.FloatRange
+import androidx.annotation.IntRange
+import com.devbrackets.android.exomedia.listener.OnErrorListener
+import com.devbrackets.android.playlistcore.api.MediaPlayerApi
+import com.devbrackets.android.playlistcore.manager.ListPlaylistManager
+import org.dwbn.plugins.playlist.PlaylistItemOptions
+import org.dwbn.plugins.playlist.TrackRemovalItem
+import org.dwbn.plugins.playlist.data.AudioTrack
+import org.dwbn.plugins.playlist.playlist.AudioApi
+import org.dwbn.plugins.playlist.service.MediaService
+import java.lang.ref.WeakReference
+import java.util.*
+
+/**
+ * A PlaylistManager that extends the [ListPlaylistManager] for use with the
+ * [MediaService] which extends [com.devbrackets.android.playlistcore.service.BasePlaylistService].
+ */
+class PlaylistManager(application: Application) :
+    ListPlaylistManager<AudioTrack>(application, MediaService::class.java), OnErrorListener {
+    private val audioTracks: MutableList<AudioTrack> = ArrayList()
+    private var volumeLeft = 1.0f
+    private var volumeRight = 1.0f
+    private var playbackSpeed = 1.0f
+    var loop = false
+    var isShouldStopPlaylist = false
+    var currentErrorTrack: AudioTrack? = null
+
+    // Really need a way to propagate the settings through the app
+    var resetStreamOnPause = true
+    var options: Options
+    private var mediaControlsListener = WeakReference<MediaControlsListener?>(null)
+    private var errorListener = WeakReference<OnErrorListener?>(null)
+    private var currentMediaPlayer: WeakReference<MediaPlayerApi<AudioTrack>?>? =
+        WeakReference(null)
+
+    fun setOnErrorListener(listener: OnErrorListener?) {
+        errorListener = WeakReference(listener)
+    }
+
+    fun setMediaControlsListener(listener: MediaControlsListener?) {
+        mediaControlsListener = WeakReference(listener)
+    }
+
+    val isPlaying: Boolean
+        get() = playlistHandler != null && playlistHandler!!.currentMediaPlayer != null && playlistHandler!!.currentMediaPlayer!!.isPlaying
+
+    override fun onError(e: Exception?): Boolean {
+
+        if (e != null && errorListener.get() != null) {
+            Log.i(TAG, "onError: $e")
+            errorListener.get()!!.onError(e)
+        }
+        return true
+    }
+
+    /*
+     * isNextAvailable, getCurrentItem, and next() are overridden because there is
+     * a glaring bug in playlist core where when an item completes, isNextAvailable and
+     * getCurrentItem return wildly contradictory things, resulting in endless repeat
+     * of the last item in the playlist.
+     */
+    override val isNextAvailable: Boolean
+        get() {
+            if (itemCount <= 1) {
+                return false;
+            }
+            val isAtEnd = currentPosition + 1 >= itemCount
+            val isConstrained = currentPosition + 1 in 0 until itemCount
+            return if (isAtEnd) {
+                loop
+            } else isConstrained
+        }
+
+    override operator fun next(): AudioTrack? {
+        if (isNextAvailable) {
+            val isAtEnd = currentPosition + 1 >= itemCount
+            currentPosition = if (isAtEnd && loop) {
+                0
+            } else {
+                (currentPosition + 1).coerceAtMost(itemCount)
+            }
+        } else {
+            if (loop) {
+                currentPosition = INVALID_POSITION
+            } else {
+                isShouldStopPlaylist = true
+                return null
+            }
+        }
+
+        return currentItem
+    }
+
+
+    /*
+     * List management
+     */
+    fun setAllItems(items: List<AudioTrack>?, options: PlaylistItemOptions) {
+        clearItems()
+        addAllItems(items)
+        currentPosition = 0
+        // If the options said to start from a specific position, do so.
+        var seekStart: Long = 0
+        if (options.playFromPosition > 0) {
+            seekStart = options.playFromPosition
+        } else if (options.retainPosition) {
+            val progress = currentProgress
+            if (progress != null) {
+              seekStart = progress.position
+            }
+        }
+
+        // If the options said to start from a specific id, do so.
+        var idStart: String? = null
+        if (options.playFromId != null) {
+            idStart = options.playFromId
+        }
+        if (idStart != null && "" != idStart) {
+            val code = idStart.hashCode()
+            setCurrentItem(code.toLong())
+        }
+
+        // We assume that if the playlist is fully loaded in one go,
+        // that the next thing to happen will be to play. So let's start
+        // paused, which will allow the player to pre-buffer until the
+        // user says Go.
+        beginPlayback(seekStart, options.startPaused)
+    }
+
+    fun addItem(item: AudioTrack?) {
+        if (item == null) {
+            return
+        }
+        val countBefore = audioTracks.size;
+        audioTracks.add(item)
+        items = audioTracks
+        if (countBefore == 0) {
+            currentPosition = 0
+            beginPlayback(1, true)
+        }
+        if (this.playlistHandler != null) {
+            this.playlistHandler!!.updateMediaControls()
+        }
+    }
+
+    fun addAllItems(its: List<AudioTrack>?) {
+        val currentItem = currentItem // may be null
+        audioTracks.addAll(its.orEmpty())
+        items =
+            audioTracks // not *strictly* needed since they share the reference, but for good measure..
+        currentPosition = audioTracks.indexOf(currentItem)
+    }
+
+    fun removeItem(index: Int, itemId: String): AudioTrack? {
+        val wasPlaying = isPlaying
+        if (playlistHandler != null) {
+            playlistHandler!!.pause(true)
+        }
+        var currentPosition = currentPosition
+        var foundItem: AudioTrack? = null
+        var removingCurrent = false
+
+        // Get the current playback position in milliseconds before removing items
+        val progress = currentProgress
+        val seekPosition: Long = if (progress != null) progress.position else 0
+
+        // If isPlaying is true, and currentItem is not null,
+        // that implies that currentItem is the currently playing item.
+        // If removingCurrent gets set to true, we are removing the currently playing item,
+        // and we need to restart playback once we do.
+        val resolvedIndex = resolveItemPosition(index, itemId)
+        if (resolvedIndex >= 0) {
+            foundItem = audioTracks[resolvedIndex]
+            if (foundItem == currentItem) {
+                removingCurrent = true
+            }
+            audioTracks.removeAt(resolvedIndex)
+        }
+        items = audioTracks
+        currentPosition = if (removingCurrent) currentPosition else audioTracks.indexOf(currentItem)
+        // If removing the current item, start from beginning (0), otherwise preserve playback position
+        val seekStart = if (removingCurrent) 0 else seekPosition
+        beginPlayback(seekStart, !wasPlaying)
+        if (this.playlistHandler != null) {
+            this.playlistHandler!!.updateMediaControls()
+        }
+        return foundItem
+    }
+
+    fun removeAllItems(its: ArrayList<TrackRemovalItem>): ArrayList<AudioTrack> {
+        val removedTracks = ArrayList<AudioTrack>()
+        val wasPlaying = isPlaying
+        if (playlistHandler != null) {
+            playlistHandler!!.pause(true)
+        }
+        var currentPosition = currentPosition
+        val currentItem = currentItem // may be null
+        var removingCurrent = false
+
+        // Get the current playback position in milliseconds before removing items
+        val progress = currentProgress
+        val seekPosition: Long = if (progress != null) progress.position else 0
+
+        for (item in its) {
+            val resolvedIndex = resolveItemPosition(item.trackIndex, item.trackId)
+            if (resolvedIndex >= 0) {
+                val foundItem = audioTracks[resolvedIndex]
+                if (foundItem == currentItem) {
+                    removingCurrent = true
+                }
+                removedTracks.add(foundItem)
+                audioTracks.removeAt(resolvedIndex)
+            }
+        }
+        items = audioTracks
+        currentPosition = if (removingCurrent) currentPosition else audioTracks.indexOf(currentItem)
+        // If removing the current item, start from beginning (0), otherwise preserve playback position
+        val seekStart = if (removingCurrent) 0 else seekPosition
+        beginPlayback(seekStart, !wasPlaying)
+        return removedTracks
+    }
+
+    fun clearItems() {
+        playlistHandler?.stop()
+        audioTracks.clear()
+        items = audioTracks
+        currentPosition = INVALID_POSITION
+    }
+
+    fun getAllItems(): List<AudioTrack> {
+        return audioTracks.toList()
+    }
+
+    private fun resolveItemPosition(trackIndex: Int, trackId: String): Int {
+        var resolvedPosition = -1
+        if (trackIndex >= 0 && trackIndex < audioTracks.size) {
+            resolvedPosition = trackIndex
+        } else if ("" != trackId) {
+            val itemPos = getPositionForItem(trackId.hashCode().toLong())
+            if (itemPos != INVALID_POSITION) {
+                resolvedPosition = itemPos
+            }
+        }
+        return resolvedPosition
+    }
+
+    fun getVolumeLeft(): Float {
+        return volumeLeft
+    }
+
+    fun getVolumeRight(): Float {
+        return volumeRight
+    }
+
+    fun setVolume(
+        @FloatRange(from = 0.0, to = 1.0) left: Float,
+        @FloatRange(from = 0.0, to = 1.0) right: Float
+    ) {
+        volumeLeft = left
+        volumeRight = right
+        if (currentMediaPlayer != null && currentMediaPlayer!!.get() != null) {
+            Log.i("PlaylistManager", "setVolume completing with volume = $left")
+            currentMediaPlayer!!.get()!!.setVolume(volumeLeft, volumeRight)
+        }
+    }
+
+    fun getPlaybackSpeed(): Float {
+        return playbackSpeed
+    }
+
+    fun setPlaybackSpeed(@FloatRange(from = 0.0625, to = 16.0) speed: Float) {
+        val validSpeed = speed.coerceIn(0.0625f, 16.0f)
+        playbackSpeed = validSpeed
+        playlistHandler?.let { handler ->
+            handler.currentMediaPlayer?.let { mediaPlayer ->
+                if (mediaPlayer is AudioApi) {
+                    Log.i(TAG, "setPlaybackSpeed completing with speed = $validSpeed")
+                    mediaPlayer.setPlaybackSpeed(playbackSpeed)
+                }
+            }
+        }
+    }
+
+    fun beginPlayback(@IntRange(from = 0) seekPosition: Long, startPaused: Boolean) {
+        currentItem ?: return
+        super.play(seekPosition, startPaused)
+        try {
+            setVolume(volumeLeft, volumeRight)
+            setPlaybackSpeed(playbackSpeed)
+        } catch (e: Exception) {
+            Log.w(TAG, "beginPlayback: Error setting volume or playback speed: " + e.message)
+        }
+    }
+
+    companion object {
+        private const val TAG = "PlaylistManager"
+    }
+
+    init {
+        setParameters(audioTracks, 0)
+        options = Options(application.baseContext)
+    }
+
+}

package/android/src/main/java/org/dwbn/plugins/playlist/notification/PlaylistNotificationProvider.kt

@@ -0,0 +1,26 @@
+package org.dwbn.plugins.playlist.notification
+
+import android.annotation.SuppressLint
+import android.app.PendingIntent
+import android.app.PendingIntent.FLAG_UPDATE_CURRENT
+import android.app.PendingIntent.FLAG_IMMUTABLE
+import android.content.Context
+import android.content.Intent
+import com.devbrackets.android.playlistcore.components.notification.DefaultPlaylistNotificationProvider
+
+class PlaylistNotificationProvider(context: Context?) : DefaultPlaylistNotificationProvider(context!!) {
+    override val clickPendingIntent: PendingIntent?
+        @SuppressLint("UnspecifiedImmutableFlag")
+        get() {
+            val context = context
+            val pkgName = context.packageName
+            val intent = context
+                    .packageManager
+                    .getLaunchIntentForPackage(pkgName)
+            intent!!.addFlags(
+                    Intent.FLAG_ACTIVITY_REORDER_TO_FRONT or Intent.FLAG_ACTIVITY_SINGLE_TOP)
+            return PendingIntent.getActivity(this.context,
+                    0, intent, FLAG_UPDATE_CURRENT or FLAG_IMMUTABLE
+            )
+        }
+}

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

@@ -0,0 +1,114 @@
+
+package org.dwbn.plugins.playlist.playlist
+
+import android.content.Context
+import android.media.AudioManager
+import android.net.Uri
+import android.os.PowerManager
+import androidx.annotation.FloatRange
+import androidx.annotation.IntRange
+import androidx.annotation.OptIn
+import androidx.media3.common.AudioAttributes
+import androidx.media3.common.C
+import androidx.media3.common.util.UnstableApi
+import androidx.media3.exoplayer.util.EventLogger
+import com.devbrackets.android.exomedia.AudioPlayer
+import com.devbrackets.android.exomedia.listener.OnErrorListener
+import com.devbrackets.android.playlistcore.manager.BasePlaylistManager
+import org.dwbn.plugins.playlist.data.AudioTrack
+import java.lang.ref.WeakReference
+import java.util.concurrent.locks.ReentrantLock
+
+@OptIn(UnstableApi::class)
+class AudioApi(context: Context) : BaseMediaApi() {
+    private val audioPlayer: AudioPlayer = AudioPlayer(context.applicationContext)
+
+    private val errorListenersLock = ReentrantLock(true)
+    private val errorListeners = ArrayList<WeakReference<OnErrorListener>>()
+
+    override val isPlaying: Boolean
+        get() = audioPlayer.isPlaying
+
+    override val handlesOwnAudioFocus: Boolean
+        get() = false
+
+    override val currentPosition: Long
+        get() = if (prepared) audioPlayer.currentPosition else 0
+
+    override val duration: Long
+        get() = if (prepared) audioPlayer.duration else 0
+
+    override val bufferedPercent: Int
+        get() = bufferPercent
+
+    init {
+        audioPlayer.setOnErrorListener(this)
+        audioPlayer.setOnPreparedListener(this)
+        audioPlayer.setOnCompletionListener(this)
+        audioPlayer.setOnSeekCompletionListener(this)
+        audioPlayer.setOnBufferUpdateListener(this)
+
+        audioPlayer.setWakeLevel(PowerManager.PARTIAL_WAKE_LOCK)
+        audioPlayer.setAudioAttributes(getAudioAttributes(C.USAGE_MEDIA, C.AUDIO_CONTENT_TYPE_MUSIC))
+        audioPlayer.setAnalyticsListener(EventLogger())
+    }
+
+    override fun play() {
+        audioPlayer.start()
+    }
+
+    override fun pause() {
+        audioPlayer.pause()
+    }
+
+    override fun stop() {
+        audioPlayer.stop()
+    }
+
+    override fun reset() {
+        audioPlayer.reset()
+    }
+
+    override fun release() {
+        audioPlayer.release()
+    }
+
+    override fun setVolume(@FloatRange(from = 0.0, to = 1.0) left: Float, @FloatRange(from = 0.0, to = 1.0) right: Float) {
+        audioPlayer.volume = (left + right) / 2
+    }
+
+    override fun seekTo(@IntRange(from = 0L) milliseconds: Long) {
+        audioPlayer.seekTo(milliseconds.toInt().toLong())
+    }
+
+    override fun handlesItem(item: AudioTrack): Boolean {
+        return item.mediaType == BasePlaylistManager.AUDIO
+    }
+
+    override fun playItem(item: AudioTrack) {
+        try {
+            bufferPercent = 0
+            audioPlayer.setMedia(Uri.parse(if (item.downloaded) item.downloadedMediaUri else item.mediaUrl))
+        } catch (e: Exception) {
+            //Purposefully left blank
+        }
+    }
+
+    fun setPlaybackSpeed(@FloatRange(from = 0.0, to = 1.0) speed: Float) {
+        audioPlayer.setPlaybackSpeed(speed)
+    }
+
+    fun addErrorListener(listener: OnErrorListener) {
+        errorListenersLock.lock()
+        errorListeners.add(WeakReference<OnErrorListener>(listener))
+        errorListenersLock.unlock()
+    }
+
+    @Suppress("SameParameterValue")
+    private fun getAudioAttributes(@C.AudioUsage usage: Int, @C.AudioContentType contentType: Int): AudioAttributes {
+        return AudioAttributes.Builder()
+            .setUsage(usage)
+            .setContentType(contentType)
+            .build()
+    }
+}

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

@@ -0,0 +1,146 @@
+package org.dwbn.plugins.playlist.playlist;
+
+import android.app.Service;
+import android.content.Context;
+import android.util.Log;
+
+import androidx.annotation.Nullable;
+
+import com.devbrackets.android.playlistcore.api.MediaPlayerApi;
+import com.devbrackets.android.playlistcore.api.PlaylistItem;
+import com.devbrackets.android.playlistcore.components.audiofocus.AudioFocusProvider;
+import com.devbrackets.android.playlistcore.components.audiofocus.DefaultAudioFocusProvider;
+import com.devbrackets.android.playlistcore.components.image.ImageProvider;
+import com.devbrackets.android.playlistcore.components.mediacontrols.DefaultMediaControlsProvider;
+import com.devbrackets.android.playlistcore.components.mediacontrols.MediaControlsProvider;
+import com.devbrackets.android.playlistcore.components.mediasession.DefaultMediaSessionProvider;
+import com.devbrackets.android.playlistcore.components.mediasession.MediaSessionProvider;
+import com.devbrackets.android.playlistcore.components.playlisthandler.DefaultPlaylistHandler;
+import com.devbrackets.android.playlistcore.manager.BasePlaylistManager;
+
+import org.dwbn.plugins.playlist.RmxAudioPlayer;
+import org.dwbn.plugins.playlist.data.AudioTrack;
+import org.dwbn.plugins.playlist.manager.PlaylistManager;
+import org.dwbn.plugins.playlist.notification.PlaylistNotificationProvider;
+import org.jetbrains.annotations.NotNull;
+
+
+public class AudioPlaylistHandler<I extends PlaylistItem, M extends BasePlaylistManager<I>>
+            extends DefaultPlaylistHandler<I, M> {
+
+    private static final String TAG = "PlaylistAudioPlaylistHandler";
+
+    AudioPlaylistHandler(
+            Context context,
+            Class<? extends Service> serviceClass,
+            M playlistManager,
+            ImageProvider<I> imageProvider,
+            com.devbrackets.android.playlistcore.components.notification.PlaylistNotificationProvider notificationProvider,
+            MediaSessionProvider mediaSessionProvider,
+            MediaControlsProvider mediaControlsProvider,
+            AudioFocusProvider<I> audioFocusProvider,
+            @Nullable Listener<I> listener
+    ) {
+        super(context, serviceClass, playlistManager, imageProvider, notificationProvider,
+                mediaSessionProvider, mediaControlsProvider, audioFocusProvider, listener);
+        // Lmao this entire class exists for the sake of this one line
+        // The default value is 30fps (e.g 33ms), which would overwhelm the Cordova webview with messages
+        // Ideally we could make this configurable.
+        getMediaProgressPoll().setProgressPollDelay(1000);
+    }
+
+    public void next() {
+        if (!getPlaylistManager().isNextAvailable()) {
+            return;
+        }
+        getPlaylistManager().next();
+        startItemPlayback(0, !this.isPlaying());
+    }
+
+    public void previous() {
+        if (!getPlaylistManager().isPreviousAvailable()) {
+            return;
+        }
+        getPlaylistManager().previous();
+        startItemPlayback(0, !this.isPlaying());
+    }
+
+    @Override
+    public void onPrepared(@NotNull MediaPlayerApi<I> mediaPlayer) {
+        super.onPrepared(mediaPlayer);
+    }
+
+    @Override
+    public boolean onError(@NotNull MediaPlayerApi<I> mediaPlayer) {
+        ((PlaylistManager)getPlaylistManager()).setCurrentErrorTrack((AudioTrack) getCurrentPlaylistItem());
+        int currentIndex = getPlaylistManager().getCurrentPosition();
+        int currentErrorCount = getSequentialErrors();
+
+        super.onError(mediaPlayer);
+        // Do not set startPaused to false if we are at the first item.
+        // For all other items, the user MUST have triggered playback;
+        // for item 0, they will never have done so at this point (since the tracks
+        // are auto-buffered when a list is loaded).
+        // This is a bit of a guess. What happens of tracks 2,3,4 are also broken?
+        // User has no network? The only way to be *certain* is to capture all user interaction
+        // input points and create a global flag "somewhere" that says the user has tried to play.
+        // Maintaining that would be a nightmare.
+        if (currentIndex > 0 && currentErrorCount <= 3) {
+            Log.e(TAG, "ListHandler error: setting startPaused to false");
+            setStartPaused(false);
+        }
+
+        return false;
+    }
+
+    @Override
+    public void onSeekComplete(MediaPlayerApi<I> mediaPlayer) {
+        Log.i(TAG, "onSeekComplete! " + mediaPlayer.getCurrentPosition());
+        getCurrentMediaProgress().update(mediaPlayer.getCurrentPosition(), mediaPlayer.getBufferedPercent(), mediaPlayer.getDuration());
+        super.onSeekComplete(mediaPlayer);
+    }
+
+    @Override
+    public void onCompletion(@NotNull MediaPlayerApi<I> mediaPlayer) {
+        ((RmxAudioPlayer)super.getPlaylistManager().getPlaybackStatusListener()).onCompletion((AudioTrack) getCurrentPlaylistItem());
+        Log.i("AudioPlaylistHandler", "onCompletion");
+        // This is called when a single item completes playback.
+        // For now, the superclass does the right thing, but we may need to override.
+        super.onCompletion(mediaPlayer);
+    }
+
+
+    public static class Builder<I extends PlaylistItem, M extends BasePlaylistManager<I>> {
+
+        Context context;
+        Class<? extends Service> serviceClass;
+        M playlistManager;
+        ImageProvider<I> imageProvider;
+
+        com.devbrackets.android.playlistcore.components.notification.PlaylistNotificationProvider notificationProvider = null;
+        MediaSessionProvider mediaSessionProvider = null;
+        MediaControlsProvider mediaControlsProvider = null;
+        AudioFocusProvider<I> audioFocusProvider = null;
+        Listener<I> listener;
+        public Builder(Context context, Class<? extends Service> serviceClass,
+                       M playlistManager, ImageProvider<I> imageProvider, Listener<I> listener) {
+            this.context = context;
+            this.serviceClass = serviceClass;
+            this.playlistManager = playlistManager;
+            this.imageProvider = imageProvider;
+            this.listener = listener;
+        }
+
+        public AudioPlaylistHandler<I, M> build() {
+            return new AudioPlaylistHandler<>(context,
+                serviceClass,
+                playlistManager,
+                imageProvider,
+                notificationProvider != null ? notificationProvider : new PlaylistNotificationProvider(context),
+                mediaSessionProvider != null ? mediaSessionProvider : new DefaultMediaSessionProvider(context, serviceClass),
+                mediaControlsProvider != null ? mediaControlsProvider : new DefaultMediaControlsProvider(context),
+                audioFocusProvider != null ? audioFocusProvider : new DefaultAudioFocusProvider<I>(context),
+                listener);
+        }
+    }
+}