capacitor-plugin-playlist 0.4.0 → 0.4.1

package/android/bin/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/bin/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)
+}

package/android/bin/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/bin/src/main/java/org/dwbn/plugins/playlist/manager/PlaylistManager.kt

@@ -0,0 +1,286 @@
+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 {
+        Log.i(TAG, "onError: $e")
+        if (errorListener.get() != null) {
+            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
+            if (isAtEnd && loop) {
+                currentPosition = 0
+            } else {
+                currentPosition = (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!!)
+        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
+
+        // 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)
+        beginPlayback(currentPosition.toLong(), !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
+        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)
+        beginPlayback(currentPosition.toLong(), !wasPlaying)
+        return removedTracks
+    }
+
+    fun clearItems() {
+        if (playlistHandler != null) {
+            playlistHandler!!.stop()
+        }
+        audioTracks.clear()
+        items = audioTracks
+        currentPosition = INVALID_POSITION
+    }
+
+    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.0, to = 1.0) speed: Float) {
+        playbackSpeed = speed
+        if (playlistHandler!!.currentMediaPlayer != null &&  playlistHandler!!.currentMediaPlayer!! is AudioApi) {
+            Log.i(TAG, "setPlaybackSpeed completing with speed = $speed")
+            (playlistHandler!!.currentMediaPlayer as AudioApi?)!!.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/bin/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/bin/src/main/java/org/dwbn/plugins/playlist/playlist/AudioApi.kt

@@ -0,0 +1,101 @@
+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 com.devbrackets.android.exomedia.AudioPlayer
+import com.devbrackets.android.exomedia.listener.OnErrorListener
+import com.devbrackets.android.playlistcore.manager.BasePlaylistManager
+import com.google.android.exoplayer2.util.EventLogger
+import org.dwbn.plugins.playlist.data.AudioTrack
+import java.lang.ref.WeakReference
+import java.util.concurrent.locks.ReentrantLock
+
+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.setWakeMode(context, PowerManager.PARTIAL_WAKE_LOCK)
+        audioPlayer.setAudioStreamType(AudioManager.STREAM_MUSIC)
+        audioPlayer.setAnalyticsListener(EventLogger(null))
+    }
+
+    override fun play() {
+        audioPlayer.start()
+    }
+
+    override fun pause() {
+        audioPlayer.pause()
+    }
+
+    override fun stop() {
+        audioPlayer.stopPlayback()
+    }
+
+    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.setVolume(left, right)
+    }
+
+    override fun seekTo(@IntRange(from = 0L) milliseconds: Long) {
+        audioPlayer.seekTo(milliseconds.toInt().toLong())
+    }
+
+    override fun handlesItem(item: AudioTrack): Boolean {
+        return item.mediaType == BasePlaylistManager.AUDIO
+    }
+
+    fun setPlaybackSpeed(@FloatRange(from = 0.0, to = 1.0) speed: Float) {
+        audioPlayer.playbackSpeed = speed
+    }
+    override fun playItem(item: AudioTrack) {
+        try {
+            prepared = false
+            bufferPercent = 0
+            audioPlayer.setDataSource(Uri.parse(if (item.downloaded) item.downloadedMediaUri else item.mediaUrl))
+            audioPlayer.prepareAsync()
+        } catch (e: Exception) {
+            //Purposefully left blank
+        }
+    }
+
+    fun addErrorListener(listener: OnErrorListener) {
+        errorListenersLock.lock()
+        errorListeners.add(WeakReference<OnErrorListener>(listener))
+        errorListenersLock.unlock()
+    }
+}

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

@@ -0,0 +1,40 @@
+package org.dwbn.plugins.playlist.playlist
+
+import com.devbrackets.android.exomedia.listener.*
+import com.devbrackets.android.playlistcore.api.MediaPlayerApi
+import com.devbrackets.android.playlistcore.listener.MediaStatusListener
+import org.dwbn.plugins.playlist.data.AudioTrack
+
+abstract class BaseMediaApi : MediaPlayerApi<AudioTrack>, OnPreparedListener, OnCompletionListener,
+    OnErrorListener, OnSeekCompletionListener, OnBufferUpdateListener {
+    protected var prepared: Boolean = false
+    protected var bufferPercent: Int = 0
+
+    protected var statusListener: MediaStatusListener<AudioTrack>? = null
+
+    override fun setMediaStatusListener(listener: MediaStatusListener<AudioTrack>) {
+        statusListener = listener
+    }
+
+    override fun onCompletion() {
+        statusListener?.onCompletion(this)
+    }
+
+    override fun onError(e: Exception): Boolean {
+        return statusListener?.onError(this) == true
+    }
+
+    override fun onPrepared() {
+        prepared = true
+        statusListener?.onPrepared(this)
+    }
+
+    override fun onSeekComplete() {
+        statusListener?.onSeekComplete(this)
+    }
+
+    override fun onBufferingUpdate(percent: Int) {
+        bufferPercent = percent
+        statusListener?.onBufferingUpdate(this, percent)
+    }
+}