capacitor-plugin-playlist 0.4.0 → 0.4.2

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

@@ -0,0 +1,403 @@
+package org.dwbn.plugins.playlist
+
+import android.util.Log
+import com.devbrackets.android.playlistcore.data.MediaProgress
+import com.getcapacitor.*
+import com.getcapacitor.annotation.CapacitorPlugin
+import org.dwbn.plugins.playlist.data.AudioTrack
+import org.json.JSONArray
+import org.json.JSONObject
+import java.util.*
+
+@CapacitorPlugin(name = "Playlist")
+class PlaylistPlugin : Plugin(), OnStatusReportListener {
+    var TAG = "PlaylistPlugin"
+    private var statusCallback: OnStatusCallback? = null
+    private var audioPlayerImpl: RmxAudioPlayer? = null
+    private var resetStreamOnPause = true
+
+    override fun load() {
+        return;
+        audioPlayerImpl = RmxAudioPlayer(this, (this.context.applicationContext as App))
+    }
+
+    @PluginMethod
+    fun initialize(call: PluginCall) {
+        call.resolve()
+        return;
+        statusCallback = OnStatusCallback(this)
+        onStatus(RmxAudioStatusMessage.RMXSTATUS_REGISTER, "INIT", null)
+        Log.i(TAG, "Initialized...")
+        audioPlayerImpl!!.resume()
+    }
+    @PluginMethod
+    fun setOptions(call: PluginCall) {
+        call.resolve()
+        return;
+        val options: JSObject = call.getObject("options") ?: JSObject()
+        resetStreamOnPause = options.optBoolean("resetStreamOnPause", this.resetStreamOnPause)
+        Log.i("AudioPlayerOptions", options.toString())
+        audioPlayerImpl!!.resetStreamOnPause = resetStreamOnPause
+        audioPlayerImpl!!.setOptions(options)
+        call.resolve()
+    }
+
+    @PluginMethod
+    fun release(call: PluginCall) {
+        call.resolve()
+        return;
+        destroyResources()
+        call.resolve()
+        Log.i(TAG,"released")
+    }
+
+    @PluginMethod
+    fun setLoop(call: PluginCall) {
+        call.resolve()
+        return;
+        val loop: Boolean = call.getBoolean("loop", audioPlayerImpl!!.playlistManager.loop)!!
+        audioPlayerImpl!!.playlistManager.loop = loop
+        call.resolve()
+        Log.i(TAG,"setLoop: " + (if (loop)  "TRUE" else "FALSE"))
+    }
+
+    @PluginMethod
+    fun setPlaylistItems(call: PluginCall) {
+        call.resolve()
+        return;
+        val items: JSArray = call.getArray("items")
+        val optionsArgs: JSONObject = call.getObject("options")
+        val options = PlaylistItemOptions(optionsArgs)
+
+        val trackItems: ArrayList<AudioTrack> = getTrackItems(items)
+        audioPlayerImpl!!.playlistManager.setAllItems(trackItems, options)
+        for (playerItem in trackItems) {
+            if (playerItem.trackId != null) {
+                onStatus(RmxAudioStatusMessage.RMXSTATUS_ITEM_ADDED, playerItem.trackId, playerItem.toDict())
+            }
+        }
+
+        call.resolve()
+
+        Log.i(TAG,"setPlaylistItems" + items.length().toString())
+    }
+
+    @PluginMethod
+    fun addItem(call: PluginCall) {
+        call.resolve()
+        return;
+        val item: JSONObject = call.getObject("item")
+        val playerItem: AudioTrack? = getTrackItem(item)
+        audioPlayerImpl!!.getPlaylistManager().addItem(playerItem)
+x
+
+        if (playerItem?.trackId != null) {
+            onStatus(RmxAudioStatusMessage.RMXSTATUS_ITEM_ADDED, playerItem.trackId, playerItem.toDict())
+        }
+        call.resolve()
+        Log.i(TAG,"addItem")
+    }
+
+    @PluginMethod
+    fun addAllItems(call: PluginCall) {
+        call.resolve()
+        return;
+        val items: JSONArray = call.getArray("items")
+        val trackItems = getTrackItems(items)
+        audioPlayerImpl!!.playlistManager.addAllItems(trackItems)
+
+        for (playerItem in trackItems) {
+            if (playerItem.trackId != null) {
+                onStatus(RmxAudioStatusMessage.RMXSTATUS_ITEM_ADDED, playerItem.trackId, playerItem.toDict())
+            }
+        }
+        call.resolve()
+        Log.i(TAG,"addAllItems")
+    }
+
+    @PluginMethod
+    fun removeItem(call: PluginCall) {
+        call.resolve()
+        return;
+        val trackIndex: Int = call.getInt("index", -1)!!
+        val trackId: String = call.getString("id", "")!!
+        Log.i(TAG,"removeItem trackIn" )
+        val item = audioPlayerImpl!!.playlistManager.removeItem(trackIndex, trackId)
+
+        if (item != null) {
+            onStatus(RmxAudioStatusMessage.RMXSTATUS_ITEM_REMOVED, item.trackId, item.toDict())
+            call.resolve()
+        }
+        else {
+            call.reject("Could not find item!")
+        }
+    }
+
+    @PluginMethod
+    fun removeItems(call: PluginCall) {
+        call.resolve()
+        return;
+        val items: JSONArray = call.getArray("items")
+        var removed = 0
+
+        val removals = ArrayList<TrackRemovalItem>()
+        for (index in 0 until items.length()) {
+            val entry = items.optJSONObject(index) ?: continue
+            val trackIndex = entry.optInt("trackIndex", -1)
+            val trackId = entry.optString("trackId", "")
+            removals.add(TrackRemovalItem(trackIndex, trackId))
+            val removedTracks = audioPlayerImpl!!.playlistManager.removeAllItems(removals)
+            if (removedTracks.size > 0) {
+                for (removedItem in removedTracks) {
+                    onStatus(RmxAudioStatusMessage.RMXSTATUS_ITEM_REMOVED, removedItem.trackId, removedItem.toDict())
+                }
+                removed = removedTracks.size
+            }
+        }
+
+        val result = JSObject()
+        result.put("removed", removed)
+        call.resolve(result)
+
+        Log.i(TAG,"removeItems")
+    }
+
+    @PluginMethod
+    fun clearAllItems(call: PluginCall) {
+        call.resolve()
+        return;
+        audioPlayerImpl!!.playlistManager.clearItems()
+
+        onStatus(RmxAudioStatusMessage.RMXSTATUS_PLAYLIST_CLEARED, "INVALID", null)
+        call.resolve()
+
+        Log.i(TAG,"clearAllItems")
+    }
+
+    @PluginMethod
+    fun play(call: PluginCall) {
+        call.resolve()
+        return;
+        if (audioPlayerImpl!!.playlistManager.playlistHandler != null) {
+            val isPlaying = (audioPlayerImpl!!.playlistManager.playlistHandler?.currentMediaPlayer != null
+                    && audioPlayerImpl!!.playlistManager.playlistHandler?.currentMediaPlayer?.isPlaying!!)
+            // There's a bug in the threaded repeater that it stacks up the repeat calls instead of ignoring
+            // additional ones or starting a new one. E.g. every time this is called, you'd get a new repeat cycle,
+            // meaning you get N updates per second. Ew.
+            if (!isPlaying) {
+                audioPlayerImpl!!.playlistManager.playlistHandler?.play()
+                //audioPlayerImpl.getPlaylistManager().playlistHandler.seek(position)
+            }
+        }
+
+        call.resolve()
+
+        Log.i(TAG,"play")
+    }
+
+    @PluginMethod
+    fun playTrackByIndex(call: PluginCall) {
+        call.resolve()
+        return;
+        val index: Int = call.getInt("index", audioPlayerImpl!!.playlistManager.currentPosition)!!
+        val seekPosition = (call.getInt("position", 0)!! * 1000.0).toLong()
+
+        audioPlayerImpl!!.playlistManager.currentPosition = index
+        audioPlayerImpl!!.playlistManager.beginPlayback(seekPosition, false)
+
+        call.resolve()
+
+        Log.i(TAG,"playTrackByIndex")
+    }
+
+    @PluginMethod
+    fun playTrackById(call: PluginCall) {
+        call.resolve()
+        return;
+        val id: String = call.getString("id")!!
+        if ("" != id) {
+            // alternatively we could search for the item and set the current index to that item.
+            val code = id.hashCode()
+            val seekPosition = (call.getInt("position", 0)!! * 1000.0).toLong()
+            audioPlayerImpl!!.playlistManager.setCurrentItem(code.toLong())
+            audioPlayerImpl!!.playlistManager.beginPlayback(seekPosition, false)
+        }
+
+        call.resolve()
+
+        Log.i(TAG,"playTrackById")
+    }
+
+    @PluginMethod
+    fun selectTrackByIndex(call: PluginCall) {
+        call.resolve()
+        return;
+        val index: Int = call.getInt("index", audioPlayerImpl!!.playlistManager.currentPosition)!!
+
+        audioPlayerImpl!!.playlistManager.currentPosition = index
+
+        val seekPosition = (call.getInt("position", 0)!! * 1000.0).toLong()
+
+        audioPlayerImpl!!.playlistManager.beginPlayback(seekPosition, true)
+
+        call.resolve()
+
+        Log.i(TAG,"selectTrackByIndex")
+    }
+
+
+    @PluginMethod
+    fun selectTrackById(call: PluginCall) {
+        call.resolve()
+        return;
+        val id: String = call.getString("id")!!
+        if ("" != id) {
+            // alternatively we could search for the item and set the current index to that item.
+            val code = id.hashCode()
+            audioPlayerImpl!!.playlistManager.setCurrentItem(code.toLong())
+
+            val seekPosition = (call.getInt("position", 0)!! * 1000.0).toLong()
+
+            audioPlayerImpl!!.playlistManager.beginPlayback(seekPosition, true)
+        }
+        call.resolve()
+
+        Log.i(TAG,"selectTrackById")
+    }
+
+    @PluginMethod
+    fun pause(call: PluginCall) {
+        call.resolve()
+        return;
+        audioPlayerImpl!!.playlistManager.invokePausePlay()
+
+        call.resolve()
+
+        Log.i(TAG,"pause")
+    }
+
+    @PluginMethod
+    fun skipForward(call: PluginCall) {
+        call.resolve()
+        return;
+        audioPlayerImpl!!.playlistManager.invokeNext()
+
+        call.resolve()
+
+        Log.i(TAG,"skipForward")
+    }
+
+    @PluginMethod
+    fun skipBack(call: PluginCall) {
+        call.resolve()
+        return;
+        audioPlayerImpl!!.playlistManager.invokePrevious()
+
+        call.resolve()
+
+        Log.i(TAG,"skipBack")
+    }
+
+    @PluginMethod
+    fun seekTo(call: PluginCall) {
+        call.resolve()
+        return;
+        var position: Long = 0
+        val progress: MediaProgress? = audioPlayerImpl!!.playlistManager.currentProgress
+        if (progress != null) {
+            position = progress.position
+        }
+
+        val seekPosition = (call.getInt("position",  (position / 1000.0f).toInt())!! * 1000.0).toLong()
+
+        val isPlaying: Boolean? = audioPlayerImpl!!.playlistManager.playlistHandler?.currentMediaPlayer?.isPlaying
+        audioPlayerImpl!!.playlistManager.playlistHandler?.seek(seekPosition)
+        if (isPlaying === null || !isPlaying) {
+            audioPlayerImpl!!.playlistManager.playlistHandler?.pause(false)
+        }
+
+        call.resolve()
+
+        Log.i(TAG,"seekTo")
+    }
+
+    @PluginMethod
+    fun setPlaybackRate(call: PluginCall) {
+        call.resolve()
+        return;
+        val speed = call.getFloat("rate", audioPlayerImpl!!.playlistManager.getPlaybackSpeed())!!
+        audioPlayerImpl!!.playlistManager.setPlaybackSpeed(speed)
+
+        call.resolve()
+
+        Log.i(TAG,"setPlaybackRate")
+    }
+
+    @PluginMethod
+    fun setVolume(call: PluginCall) {
+        call.resolve()
+        return;
+        val volume = call.getFloat("volume", audioPlayerImpl!!.volume)!!
+        audioPlayerImpl!!.volume = volume
+
+        call.resolve()
+
+        Log.i(TAG,"addItem")
+    }
+
+    override fun handleOnDestroy() {
+        Log.d(TAG, "Plugin destroy")
+        super.handleOnDestroy()
+        return;
+        destroyResources()
+    }
+
+    override fun onError(errorCode: RmxAudioErrorType?, trackId: String?, message: String?) {
+        return;
+        if (statusCallback == null) {
+            return
+        }
+        val errorObj = OnStatusCallback.createErrorWithCode(errorCode, message)
+        onStatus(RmxAudioStatusMessage.RMXSTATUS_ERROR, trackId, errorObj)
+    }
+
+    override fun onStatus(what: RmxAudioStatusMessage, trackId: String?, param: JSONObject?) {
+        return;
+        if (statusCallback == null) {
+            return
+        }
+        statusCallback!!.onStatus(what, trackId, param)
+    }
+
+    private fun destroyResources() {
+        return;
+        statusCallback = null
+        audioPlayerImpl!!.playlistManager.clearItems()
+    }
+
+    private fun getTrackItem(item: JSONObject?): AudioTrack? {
+        if (item != null) {
+            val track = AudioTrack(item)
+            return if (track.trackId != null) {
+                track
+            } else null
+        }
+        return null
+    }
+    private fun getTrackItems(items: JSONArray?): ArrayList<AudioTrack> {
+        val trackItems = ArrayList<AudioTrack>()
+        if (items != null && items.length() > 0) {
+            for (index in 0 until items.length()) {
+                val obj = items.optJSONObject(index)
+                val track: AudioTrack = getTrackItem(obj) ?: continue
+                trackItems.add(track)
+            }
+        }
+        return trackItems
+    }
+
+    fun emit(name: String, data: JSObject) {
+        return;
+        this.notifyListeners(name, data, true)
+    }
+}

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"
+    }
+}