@javascriptcommon/react-native-track-player 1.2.9 → 1.2.24

package/android/src/main/java/com/guichaguri/trackplayer/kotlinaudio/players/QueuedAudioPlayer.kt

@@ -0,0 +1,269 @@
+package com.guichaguri.trackplayer.kotlinaudio.players
+
+import android.content.Context
+import android.util.Log
+import com.doublesymmetry.kotlinaudio.players.BaseAudioPlayer
+import com.google.android.exoplayer2.C
+import com.google.android.exoplayer2.IllegalSeekPositionException
+import com.google.android.exoplayer2.source.MediaSource
+import com.guichaguri.trackplayer.kotlinaudio.models.*
+import java.util.*
+import kotlin.math.max
+import kotlin.math.min
+
+class QueuedAudioPlayer(
+    context: Context,
+    playerConfig: PlayerConfig = PlayerConfig(),
+    bufferConfig: BufferConfig? = null,
+    cacheConfig: CacheConfig? = null,
+    mediaSessionCallback: AAMediaSessionCallBack
+) : BaseAudioPlayer(context, playerConfig, bufferConfig, cacheConfig, mediaSessionCallback) {
+    private val queue = LinkedList<MediaSource>()
+    override val playerOptions = DefaultQueuedPlayerOptions(exoPlayer)
+
+//    val currentIndex
+//        get() = exoPlayer.currentMediaItemIndex
+
+    val currentIndex = 0
+
+    override val currentItem: AudioItem?
+        get() = (queue.getOrNull(currentIndex)?.mediaItem?.localConfiguration?.tag as AudioItemHolder?)?.audioItem
+
+    val nextIndex: Int?
+        get() {
+            return if (exoPlayer.nextMediaItemIndex == C.INDEX_UNSET) null
+            else exoPlayer.nextMediaItemIndex
+        }
+
+    val previousIndex: Int?
+        get() {
+            return if (exoPlayer.previousMediaItemIndex == C.INDEX_UNSET) null
+            else exoPlayer.previousMediaItemIndex
+        }
+
+    val items: List<AudioItem>
+        get() = queue.map { (it.mediaItem.localConfiguration?.tag as AudioItemHolder).audioItem }
+
+    fun getQueueHead(): MediaSource? {
+        return if (queue.isNotEmpty()) {
+            queue.peek()
+        } else {
+            null
+        }
+    }
+
+    fun getQueueSize(): Int {
+        return queue.size
+    }
+
+    val previousItems: List<AudioItem>
+        get() {
+            return if (queue.isEmpty()) emptyList()
+            else queue
+                .subList(0, exoPlayer.currentMediaItemIndex)
+                .map { (it.mediaItem.localConfiguration?.tag as AudioItemHolder).audioItem }
+        }
+
+    val nextItems: List<AudioItem>
+        get() {
+            return if (queue.isEmpty()) emptyList()
+            else queue
+                .subList(exoPlayer.currentMediaItemIndex, queue.lastIndex)
+                .map { (it.mediaItem.localConfiguration?.tag as AudioItemHolder).audioItem }
+        }
+
+    val nextItem: AudioItem?
+        get() = items.getOrNull(currentIndex + 1)
+
+    val previousItem: AudioItem?
+        get() = items.getOrNull(currentIndex - 1)
+
+    override fun load(item: AudioItem, playWhenReady: Boolean) {
+        exoPlayer.playWhenReady = playWhenReady
+        load(item)
+    }
+
+    override fun load(item: AudioItem) {
+        if (queue.isEmpty()) {
+            add(item)
+        } else {
+            val mediaSource = getMediaSourceFromAudioItem(item)
+            queue[currentIndex] = mediaSource
+            exoPlayer.addMediaSource(currentIndex + 1, mediaSource)
+            exoPlayer.removeMediaItem(currentIndex)
+            exoPlayer.prepare()
+        }
+    }
+
+    /**
+     * Add a single item to the queue. If the AudioPlayer has no item loaded, it will load the `item`.
+     * @param item The [AudioItem] to add.
+     */
+    fun add(item: AudioItem, playWhenReady: Boolean) {
+        exoPlayer.playWhenReady = playWhenReady
+        add(item)
+    }
+
+    /**
+     * Add a single item to the queue. If the AudioPlayer has no item loaded, it will load the `item`.
+     * @param item The [AudioItem] to add.
+     * @param playWhenReady Whether playback starts automatically.
+     */
+    fun add(item: AudioItem) {
+        val mediaSource = getMediaSourceFromAudioItem(item)
+        queue.add(mediaSource)
+        exoPlayer.addMediaSource(mediaSource)
+        exoPlayer.prepare()
+    }
+
+    /**
+     * Add multiple items to the queue. If the AudioPlayer has no item loaded, it will load the first item in the list.
+     * @param items The [AudioItem]s to add.
+     * @param playWhenReady Whether playback starts automatically.
+     */
+    fun add(items: List<AudioItem>, playWhenReady: Boolean) {
+        exoPlayer.playWhenReady = playWhenReady
+        add(items)
+    }
+
+    /**
+     * Add multiple items to the queue. If the AudioPlayer has no item loaded, it will load the first item in the list.
+     * @param items The [AudioItem]s to add.
+     */
+    fun add(items: List<AudioItem>) {
+        val mediaSources = items.map { getMediaSourceFromAudioItem(it) }
+        queue.addAll(mediaSources)
+        exoPlayer.addMediaSources(mediaSources)
+        exoPlayer.prepare()
+    }
+
+    /**
+     * Add multiple items to the queue.
+     * @param items The [AudioItem]s to add.
+     * @param atIndex  Index to insert items at, if no items loaded this will not automatically start playback.
+     */
+    fun add(items: List<AudioItem>, atIndex: Int) {
+        val mediaSources = items.map { getMediaSourceFromAudioItem(it) }
+        queue.addAll(atIndex, mediaSources)
+        exoPlayer.addMediaSources(atIndex, mediaSources)
+        exoPlayer.prepare()
+    }
+
+    /**
+     * Remove an item from the queue.
+     * @param index The index of the item to remove.
+     */
+    fun remove(index: Int) {
+        queue.removeAt(index)
+        exoPlayer.removeMediaItem(index)
+    }
+
+    /**
+     * Remove items from the queue.
+     * @param indexes The indexes of the items to remove.
+     */
+    fun remove(indexes: List<Int>) {
+        var sorted = indexes.toList()
+        // Sort the indexes in descending order so we can safely remove them one by one
+        // without having the next index possibly newly pointing to another item than intended:
+        Collections.sort(sorted, Collections.reverseOrder());
+        sorted.forEach {
+            remove(it)
+        }
+    }
+
+    /**
+     * Skip to the next item in the queue, which may depend on the current repeat mode.
+     * Does nothing if there is no next item to skip to.
+     */
+    fun next() {
+        exoPlayer.seekToNextMediaItem()
+        exoPlayer.prepare()
+    }
+
+    /**
+     * Skip to the previous item in the queue, which may depend on the current repeat mode.
+     * Does nothing if there is no previous item to skip to.
+     */
+    fun previous() {
+        exoPlayer.seekToPreviousMediaItem()
+        exoPlayer.prepare()
+    }
+
+    /**
+     * Move an item in the queue from one position to another.
+     * @param fromIndex The index of the item ot move.
+     * @param toIndex The index to move the item to. If the index is larger than the size of the queue, the item is moved to the end of the queue instead.
+     */
+    fun move(fromIndex: Int, toIndex: Int) {
+        exoPlayer.moveMediaItem(fromIndex, toIndex)
+        var item = queue[fromIndex]
+        queue.removeAt(fromIndex)
+        queue.add(max(0, min(items.size, if (toIndex > fromIndex) toIndex else toIndex - 1)), item)
+    }
+
+    /**
+     * Jump to an item in the queue.
+     * @param index the index to jump to
+     * @param playWhenReady Whether playback starts automatically.
+     */
+    fun jumpToItem(index: Int, playWhenReady: Boolean) {
+        exoPlayer.playWhenReady = playWhenReady
+        jumpToItem(index)
+    }
+
+    /**
+     * Jump to an item in the queue.
+     * @param index the index to jump to
+     */
+    fun jumpToItem(index: Int) {
+        try {
+            exoPlayer.seekTo(index, C.TIME_UNSET)
+            exoPlayer.prepare()
+        } catch (e: IllegalSeekPositionException) {
+            throw Error("This item index $index does not exist. The size of the queue is ${queue.size} items.")
+        }
+    }
+
+    /**
+     * Replaces item at index in queue.
+     * If updating current index, we update the notification metadata if [automaticallyUpdateNotificationMetadata] is true.
+     */
+    fun replaceItem(index: Int, item: AudioItem) {
+        val mediaSource = getMediaSourceFromAudioItem(item)
+        queue[index] = mediaSource
+        if (index == currentIndex) {
+            updateNotificationMetadataIfAutomatic(item)
+        }
+    }
+
+    /**
+     * Removes all the upcoming items, if any (the ones returned by [next]).
+     */
+    fun removeUpcomingItems() {
+        if (queue.lastIndex == -1 || currentIndex == -1) return
+        val lastIndex = queue.lastIndex + 1
+        val fromIndex = currentIndex + 1
+
+        exoPlayer.removeMediaItems(fromIndex, lastIndex)
+        queue.subList(fromIndex, lastIndex).clear()
+    }
+
+    /**
+     * Removes all the previous items, if any (the ones returned by [previous]).
+     */
+    fun removePreviousItems() {
+        exoPlayer.removeMediaItems(0, currentIndex)
+        queue.subList(0, currentIndex).clear()
+    }
+
+    override fun destroy() {
+        queue.clear()
+        super.destroy()
+    }
+
+    override fun clear() {
+        queue.clear()
+        super.clear()
+    }
+}

package/android/src/main/java/com/guichaguri/trackplayer/kotlinaudio/players/components/MediaSourceExt.kt

@@ -0,0 +1,35 @@
+package com.guichaguri.trackplayer.kotlinaudio.players.components
+
+import android.support.v4.media.MediaMetadataCompat
+import android.support.v4.media.RatingCompat
+import android.util.Log
+import com.guichaguri.trackplayer.kotlinaudio.models.AudioItemHolder
+import com.google.android.exoplayer2.source.MediaSource
+
+fun MediaSource.getMediaMetadataCompat(): MediaMetadataCompat {
+    val audioItem = (mediaItem.localConfiguration?.tag as AudioItemHolder?)?.audioItem
+    val metadata = mediaItem.mediaMetadata
+    val title = metadata.title ?: audioItem?.title
+    val artist = metadata.artist ?: audioItem?.artist
+    val albumTitle = metadata.albumTitle ?: audioItem?.albumTitle
+    val genre = metadata.genre
+    val duration = audioItem?.duration ?: -1
+    val artwork = metadata.artworkUri ?: audioItem?.artwork
+    val rating = RatingCompat.fromRating(metadata.userRating)
+
+    return MediaMetadataCompat.Builder().apply {
+        putString(MediaMetadataCompat.METADATA_KEY_ARTIST, artist.toString())
+        putString(MediaMetadataCompat.METADATA_KEY_TITLE, title.toString())
+        putString(MediaMetadataCompat.METADATA_KEY_ALBUM, albumTitle.toString())
+        putString(MediaMetadataCompat.METADATA_KEY_GENRE, genre.toString())
+        putLong(MediaMetadataCompat.METADATA_KEY_DURATION, duration)
+
+        if (artwork != null) {
+            putString(MediaMetadataCompat.METADATA_KEY_ART_URI, artwork.toString())
+        }
+
+        if (rating != null) {
+            putRating(MediaMetadataCompat.METADATA_KEY_RATING, rating)
+        }
+    }.build()
+}

package/android/src/main/java/com/guichaguri/trackplayer/kotlinaudio/players/components/PlayerCache.kt

@@ -0,0 +1,26 @@
+package com.guichaguri.trackplayer.kotlinaudio.players.components
+
+import android.content.Context
+import com.guichaguri.trackplayer.kotlinaudio.models.CacheConfig
+import com.google.android.exoplayer2.database.DatabaseProvider
+import com.google.android.exoplayer2.database.StandaloneDatabaseProvider
+import com.google.android.exoplayer2.upstream.cache.LeastRecentlyUsedCacheEvictor
+import com.google.android.exoplayer2.upstream.cache.SimpleCache
+import java.io.File
+
+object PlayerCache {
+    @Volatile
+    private var instance: SimpleCache? = null
+
+    fun getInstance(context: Context, cacheConfig: CacheConfig): SimpleCache? {
+        val cacheDir = File(context.cacheDir, cacheConfig.identifier)
+        val db: DatabaseProvider = StandaloneDatabaseProvider(context)
+
+        instance ?: synchronized(this) {
+            instance ?: SimpleCache(cacheDir, LeastRecentlyUsedCacheEvictor(cacheConfig.maxCacheSize ?: 0), db)
+                .also { instance = it }
+        }
+
+        return instance
+    }
+}

package/android/src/main/java/com/guichaguri/trackplayer/kotlinaudio/utils/Utils.kt

@@ -0,0 +1,12 @@
+package com.guichaguri.trackplayer.kotlinaudio.utils
+
+import android.content.ContentResolver
+import android.net.Uri
+import com.google.android.exoplayer2.upstream.RawResourceDataSource
+
+fun isUriLocal(uri: Uri?): Boolean {
+    if (uri == null) return false
+    val scheme = uri.scheme
+    val host = uri.host
+    return scheme == null || scheme == ContentResolver.SCHEME_FILE || scheme == ContentResolver.SCHEME_ANDROID_RESOURCE || scheme == ContentResolver.SCHEME_CONTENT || scheme == RawResourceDataSource.RAW_RESOURCE_SCHEME || scheme == "res" || host == null || host == "localhost" || host == "127.0.0.1" || host == "[::1]"
+}

package/android/src/main/java/com/guichaguri/trackplayer/model/MetadataAdapter.kt

@@ -0,0 +1,224 @@
+package com.guichaguri.trackplayer.model
+
+import android.os.Bundle
+import com.google.android.exoplayer2.MediaMetadata
+import com.google.android.exoplayer2.metadata.Metadata
+import com.google.android.exoplayer2.metadata.flac.VorbisComment
+import com.google.android.exoplayer2.metadata.icy.IcyHeaders
+import com.google.android.exoplayer2.metadata.icy.IcyInfo
+import com.google.android.exoplayer2.metadata.id3.ChapterFrame
+import com.google.android.exoplayer2.metadata.id3.TextInformationFrame
+import com.google.android.exoplayer2.metadata.id3.UrlLinkFrame
+import com.google.android.exoplayer2.metadata.mp4.MdtaMetadataEntry
+import timber.log.Timber
+
+sealed class MetadataAdapter {
+    companion object {
+        fun fromMetadata(metadata: Metadata): List<Bundle> {
+            val group = mutableListOf<Bundle>()
+
+            (0 until metadata.length()).forEach { i ->
+                group.add(Bundle().apply {
+                    val rawEntries = mutableListOf<Bundle>()
+
+                    when (val entry = metadata[i]) {
+                        is ChapterFrame -> {
+                            Timber.d("ChapterFrame: ${entry.id}")
+                        }
+                        is TextInformationFrame -> {
+                            val rawEntry = Bundle()
+
+                            when (entry.id.uppercase()) {
+                                "TIT2", "TT2" -> {
+                                    putString("title", entry.value)
+                                    rawEntry.putString("commonKey", "title")
+                                }
+                                "TALB", "TOAL", "TAL" -> {
+                                    putString("albumName", entry.value)
+                                    rawEntry.putString("commonKey", "albumName")
+                                }
+                                "TOPE", "TPE1", "TP1" -> {
+                                    putString("artist", entry.value)
+                                    rawEntry.putString("commonKey", "artist")
+                                }
+                                "TDRC", "TOR" -> {
+                                    putString("creationDate", entry.value)
+                                    rawEntry.putString("commonKey", "creationDate")
+                                }
+                                "TCON", "TCO" -> {
+                                    putString("genre", entry.value)
+                                    rawEntry.putString("commonKey", "genre")
+                                }
+                            }
+
+                            rawEntry.putString("key", entry.id.uppercase())
+                            rawEntry.putString("keySpace", "org.id3")
+                            rawEntry.putString("value", entry.value)
+                            rawEntry.putString("time", "-1")
+                            rawEntries.add(rawEntry)
+                        }
+
+                        is UrlLinkFrame -> {
+                            rawEntries.add(Bundle().apply {
+                                putString("value", entry.url)
+                                putString("key", entry.id.uppercase())
+                                putString("keySpace", "org.id3")
+                                putString("time", "-1")
+                            })
+                        }
+
+                        is IcyHeaders -> {
+                            putString("title", entry.name)
+                            putString("genre", entry.genre)
+
+                            rawEntries.add(Bundle().apply {
+                                putString("value", entry.name)
+                                putString("commonKey", "title")
+                                putString("key", "StreamTitle")
+                                putString("keySpace", "icy")
+                                putString("time", "-1")
+                            })
+
+                            rawEntries.add(Bundle().apply {
+                                putString("value", entry.url)
+                                putString("key", "StreamURL")
+                                putString("keySpace", "icy")
+                                putString("time", "-1")
+                            })
+
+                            rawEntries.add(Bundle().apply {
+                                putString("value", entry.genre)
+                                putString("commonKey", "genre")
+                                putString("key", "StreamGenre")
+                                putString("keySpace", "icy")
+                                putString("time", "-1")
+                            })
+                        }
+
+                        is IcyInfo -> {
+                            putString("title", entry.title)
+
+                            rawEntries.add(Bundle().apply {
+                                putString("value", entry.url)
+                                putString("key", "StreamURL")
+                                putString("keySpace", "icy")
+                                putString("time", "-1")
+                            })
+
+                            rawEntries.add(Bundle().apply {
+                                putString("value", entry.title)
+                                putString("commonKey", "title")
+                                putString("key", "StreamTitle")
+                                putString("keySpace", "icy")
+                                putString("time", "-1")
+                            })
+                        }
+
+                        is VorbisComment -> {
+                            val rawEntry = Bundle()
+
+                            when (entry.key) {
+                                "TITLE" -> {
+                                    putString("title", entry.value)
+                                    rawEntry.putString("commonKey", "title")
+                                }
+                                "ARTIST" -> {
+                                    putString("artist", entry.value)
+                                    rawEntry.putString("commonKey", "artist")
+                                }
+                                "ALBUM" -> {
+                                    putString("albumName", entry.value)
+                                    rawEntry.putString("commonKey", "albumName")
+                                }
+                                "DATE" -> {
+                                    putString("creationDate", entry.value)
+                                    rawEntry.putString("commonKey", "creationDate")
+                                }
+                                "GENRE" -> {
+                                    putString("genre", entry.value)
+                                    rawEntry.putString("commonKey", "genre")
+                                }
+                                "URL" -> {
+                                    putString("url", entry.value)
+                                }
+                            }
+
+                            rawEntry.putString("key", entry.key)
+                            rawEntry.putString("keySpace", "org.vorbis")
+                            rawEntry.putString("value", entry.value)
+                            rawEntry.putString("time", "-1")
+                            rawEntries.add(rawEntry)
+                        }
+
+                        is MdtaMetadataEntry -> {
+                            val rawEntry = Bundle()
+                            when (entry.key) {
+                                "com.apple.quicktime.title" -> {
+                                    putString("title", entry.value.toString())
+                                    rawEntry.putString("commonKey", "title")
+                                }
+                                "com.apple.quicktime.artist" -> {
+                                    putString("artist", entry.value.toString())
+                                    rawEntry.putString("commonKey", "artist")
+                                }
+                                "com.apple.quicktime.album" -> {
+                                    putString("albumName", entry.value.toString())
+                                    rawEntry.putString("commonKey", "albumName")
+                                }
+                                "com.apple.quicktime.creationdate" -> {
+                                    putString("creationDate", entry.value.toString())
+                                    rawEntry.putString("commonKey", "creationDate")
+                                }
+                                "com.apple.quicktime.genre" -> {
+                                    putString("genre", entry.value.toString())
+                                    rawEntry.putString("commonKey", "genre")
+                                }
+                            }
+
+                            rawEntry.putString("key", entry.key.substringAfterLast("."))
+                            rawEntry.putString("keySpace", "com.apple.quicktime")
+                            rawEntry.putString("value", entry.value.toString())
+                            rawEntry.putString("time", "-1")
+                            rawEntries.add(rawEntry)
+                        }
+                    }
+
+                    putParcelableArray("raw", rawEntries.toTypedArray())
+                })
+            }
+
+            return group
+        }
+
+        fun fromMediaMetadata(metadata: MediaMetadata): Bundle {
+            return Bundle().apply {
+                metadata.title?.let { putString("title", it.toString()) }
+                metadata.artist?.let { putString("artist", it.toString()) }
+                metadata.albumTitle?.let { putString("albumName", it.toString()) }
+                metadata.subtitle?.let { putString("subtitle", it.toString()) }
+                metadata.description?.let { putString("description", it.toString()) }
+                metadata.artworkUri?.let { putString("artworkUri", it.toString()) }
+                metadata.trackNumber?.let { putInt("trackNumber", it) }
+                metadata.composer?.let { putString("composer", it.toString()) }
+                metadata.conductor?.let { putString("conductor", it.toString()) }
+                metadata.genre?.let { putString("genre", it.toString()) }
+                metadata.compilation?.let { putString("compilation", it.toString()) }
+                metadata.station?.let { putString("station", it.toString()) }
+                // metadata.mediaType?.let { putInt("mediaType", it) }
+
+                // This is how SwiftAudioEx outputs it in the metadata dictionary
+                (metadata.recordingDay to metadata.recordingMonth).let { (day, month) ->
+                    // if both are not null, combine them into a single string
+                    if (day != null && month != null) {
+                        putString("creationDate", "${String.format("%02d", day)}${String.format("%02d", month)}")
+                    } else if (day != null) {
+                        putString("creationDate", String.format("%02d", day))
+                    } else if (month != null) {
+                        putString("creationDate", String.format("%02d", month))
+                    }
+                }
+                metadata.recordingYear?.let { putString("creationYear", it.toString()) }
+            }
+        }
+    }
+}

package/android/src/main/java/com/guichaguri/trackplayer/model/State.kt

@@ -0,0 +1,13 @@
+package com.guichaguri.trackplayer.model
+
+enum class State(val state: String) {
+    Buffering("buffering"),
+    None("none"),
+    Ready("ready"),
+    Paused("paused"),
+    Stopped("stopped"),
+    Playing("playing"),
+    Loading("loading"),
+    Error("error"),
+    Ended("ended"),
+}