react-native-mp3-player 1.0.0

package/android/src/main/java/com/doublesymmetry/trackplayer/extensions/AudioPlayerStateExt.kt

@@ -0,0 +1,19 @@
+package com.doublesymmetry.trackplayer.extensions
+
+import com.lovegaoshi.kotlinaudio.models.AudioPlayerState
+import com.doublesymmetry.trackplayer.model.State
+
+val AudioPlayerState.asLibState: State
+    get() {
+        return when(this) {
+            AudioPlayerState.LOADING -> State.Loading
+            AudioPlayerState.READY -> State.Ready
+            AudioPlayerState.BUFFERING -> State.Buffering
+            AudioPlayerState.PAUSED -> State.Paused
+            AudioPlayerState.PLAYING -> State.Playing
+            AudioPlayerState.IDLE -> State.None
+            AudioPlayerState.ENDED -> State.Ended
+            AudioPlayerState.ERROR -> State.Error
+            AudioPlayerState.STOPPED -> State.Stopped
+        }
+    }

package/android/src/main/java/com/doublesymmetry/trackplayer/extensions/EnumExtensions.kt

@@ -0,0 +1,5 @@
+package com.doublesymmetry.trackplayer.extensions
+
+inline fun <reified T : Enum<T>, V> ((T) -> V).find(value: V): T? {
+    return enumValues<T>().firstOrNull { this(it) == value }
+}

package/android/src/main/java/com/doublesymmetry/trackplayer/extensions/NumberExt.kt

@@ -0,0 +1,13 @@
+package com.doublesymmetry.trackplayer.extensions
+
+class NumberExt {
+    companion object {
+        fun Number.toSeconds(): Double {
+            return this.toDouble() / 1000
+        }
+
+        fun Number.toMilliseconds(): Long {
+            return (this.toDouble() * 1000).toLong()
+        }
+    }
+}

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

@@ -0,0 +1,227 @@
+package com.doublesymmetry.trackplayer.model
+
+import android.os.Bundle
+import androidx.annotation.OptIn
+import androidx.media3.common.Metadata
+import androidx.media3.common.MediaMetadata
+import androidx.media3.common.util.UnstableApi
+import androidx.media3.extractor.metadata.vorbis.VorbisComment
+import androidx.media3.extractor.metadata.icy.IcyHeaders
+import androidx.media3.extractor.metadata.icy.IcyInfo
+import androidx.media3.extractor.metadata.id3.ChapterFrame
+import androidx.media3.extractor.metadata.id3.TextInformationFrame
+import androidx.media3.extractor.metadata.id3.UrlLinkFrame
+import androidx.media3.container.MdtaMetadataEntry
+import timber.log.Timber
+
+sealed class MetadataAdapter {
+    companion object {
+        @OptIn(UnstableApi::class)
+        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.values[0])
+                                    rawEntry.putString("commonKey", "title")
+                                }
+                                "TALB", "TOAL", "TAL" -> {
+                                    putString("albumName", entry.values[0])
+                                    rawEntry.putString("commonKey", "albumName")
+                                }
+                                "TOPE", "TPE1", "TP1" -> {
+                                    putString("artist", entry.values[0])
+                                    rawEntry.putString("commonKey", "artist")
+                                }
+                                "TDRC", "TOR" -> {
+                                    putString("creationDate", entry.values[0])
+                                    rawEntry.putString("commonKey", "creationDate")
+                                }
+                                "TCON", "TCO" -> {
+                                    putString("genre", entry.values[0])
+                                    rawEntry.putString("commonKey", "genre")
+                                }
+                            }
+
+                            rawEntry.putString("key", entry.id.uppercase())
+                            rawEntry.putString("keySpace", "org.id3")
+                            rawEntry.putString("value", entry.values[0])
+                            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/doublesymmetry/trackplayer/model/NowPlayingMetadata.kt

@@ -0,0 +1,16 @@
+package com.doublesymmetry.trackplayer.model
+
+import android.content.Context
+import android.os.Bundle
+
+class NowPlayingMetadata(context: Context, bundle: Bundle?, ratingType: Int) : TrackMetadata() {
+    var elapsedTime = 0.0
+    override fun setMetadata(context: Context, bundle: Bundle?, ratingType: Int) {
+        super.setMetadata(context, bundle, ratingType)
+        elapsedTime = bundle!!.getDouble("elapsedTime", 0.0)
+    }
+
+    init {
+        setMetadata(context, bundle, ratingType)
+    }
+}

package/android/src/main/java/com/doublesymmetry/trackplayer/model/PlaybackMetadata.kt

@@ -0,0 +1,203 @@
+package com.doublesymmetry.trackplayer.model
+
+import androidx.annotation.OptIn
+import androidx.media3.common.Metadata
+import androidx.media3.common.util.UnstableApi
+import androidx.media3.extractor.metadata.vorbis.VorbisComment
+import androidx.media3.extractor.metadata.icy.IcyHeaders
+import androidx.media3.extractor.metadata.icy.IcyInfo
+import androidx.media3.extractor.metadata.id3.TextInformationFrame
+import androidx.media3.extractor.metadata.id3.UrlLinkFrame
+import androidx.media3.container.MdtaMetadataEntry
+
+@OptIn(UnstableApi::class)
+data class PlaybackMetadata(
+    val source: String,
+    var title: String? = null,
+    var url: String? = null,
+    var artist: String? = null,
+    var album: String? = null,
+    var date: String? = null,
+    var genre: String? = null
+) {
+    companion object {
+        /**
+         * ID3 Metadata (MP3)
+         * https://en.wikipedia.org/wiki/ID3
+         */
+        fun fromId3Metadata(metadata: Metadata): PlaybackMetadata? {
+            var handled = false
+
+            var title: String? = null
+            var url: String? = null
+            var artist: String? = null
+            var album: String? = null
+            var date: String? = null
+            var genre: String? = null
+
+            (0 until metadata.length()).forEach { i ->
+                when (val entry = metadata[i]) {
+                    is TextInformationFrame -> {
+                        when (entry.id.uppercase()) {
+                            "TIT2", "TT2" -> {
+                                handled = true
+                                title = entry.values[0]
+                            }
+                            "TALB", "TOAL", "TAL" -> {
+                                handled = true
+                                album = entry.values[0]
+                            }
+                            "TOPE", "TPE1", "TP1" -> {
+                                handled = true
+                                artist = entry.values[0]
+                            }
+                            "TDRC", "TOR" -> {
+                                handled = true
+                                date = entry.values[0]
+                            }
+                            "TCON", "TCO" -> {
+                                handled = true
+                                genre = entry.values[0]
+                            }
+
+                        }
+                    }
+                    is UrlLinkFrame -> {
+                        when (entry.id.uppercase()) {
+                            "WOAS", "WOAF", "WOAR", "WAR" -> {
+                                handled = true
+                                url = entry.url
+                            }
+                        }
+                    }
+                }
+            }
+
+
+            return if (handled) PlaybackMetadata("id3", title, url, artist, album, date, genre) else null
+        }
+
+        /**
+         * Shoutcast / Icecast metadata (ICY protocol)
+         * https://cast.readme.io/docs/icy
+         */
+        fun fromIcy(metadata: Metadata): PlaybackMetadata? {
+            for (i in 0 until metadata.length()) {
+                when (val entry = metadata[i]) {
+                    is IcyHeaders -> {
+                        return PlaybackMetadata("icy-headers", title = entry.name, url = entry.url, genre = entry.genre)
+                    }
+                    is IcyInfo -> {
+                        val artist: String?
+                        val title: String?
+                        val index =
+                            if (entry.title == null) -1 else entry.title!!.indexOf(" - ")
+                        if (index != -1) {
+                            artist = entry.title!!.substring(0, index)
+                            title = entry.title!!.substring(index + 3)
+                        } else {
+                            artist = null
+                            title = entry.title
+                        }
+
+                        return PlaybackMetadata("icy", title = title, url = entry.url, artist = artist)
+                    }
+                }
+            }
+
+            return null
+        }
+
+        /**
+         * Vorbis Comments (Vorbis, FLAC, Opus, Speex, Theora)
+         * https://xiph.org/vorbis/doc/v-comment.html
+         */
+        fun fromVorbisComment(metadata: Metadata): PlaybackMetadata? {
+            var handled = false
+
+            var title: String? = null
+            var url: String? = null
+            var artist: String? = null
+            var album: String? = null
+            var date: String? = null
+            var genre: String? = null
+
+            for (i in 0 until metadata.length()) {
+                val entry = metadata[i]
+                if (entry is VorbisComment) {
+                    when (entry.key) {
+                        "TITLE" -> {
+                            handled = true
+                            title = entry.value
+                        }
+                        "ARTIST" -> {
+                            handled = true
+                            artist = entry.value
+                        }
+                        "ALBUM" -> {
+                            handled = true
+                            album = entry.value
+                        }
+                        "DATE" -> {
+                            handled = true
+                            date = entry.value
+                        }
+                        "GENRE" -> {
+                            handled = true
+                            genre = entry.value
+                        }
+                        "URL" -> {
+                            handled = true
+                            url = entry.value
+                        }
+                    }
+                }
+            }
+            return if (handled) PlaybackMetadata("vorbis-comment", title, url, artist, album, date, genre) else null
+        }
+
+        /**
+         * QuickTime MDTA metadata (mov, qt)
+         * https://developer.apple.com/library/archive/documentation/QuickTime/QTFF/Metadata/Metadata.html
+         */
+        fun fromQuickTime(metadata: Metadata): PlaybackMetadata? {
+            var handled = false
+
+            var title: String? = null
+            var artist: String? = null
+            var album: String? = null
+            var date: String? = null
+            var genre: String? = null
+
+            for (i in 0 until metadata.length()) {
+                val entry = metadata[i]
+                if (entry is MdtaMetadataEntry) {
+                    when (entry.key) {
+                        "com.apple.quicktime.title" -> {
+                            handled = true
+                            title = entry.value.toString()
+                        }
+                        "com.apple.quicktime.artist" -> {
+                            handled = true
+                            artist = entry.value.toString()
+                        }
+                        "com.apple.quicktime.album" -> {
+                            handled = true
+                            album = entry.value.toString()
+                        }
+                        "com.apple.quicktime.creationdate" -> {
+                            handled = true
+                            date = entry.value.toString()
+                        }
+                        "com.apple.quicktime.genre" -> {
+                            handled = true
+                            genre = entry.value.toString()
+                        }
+                    }
+                }
+            }
+
+            return if (handled) PlaybackMetadata("quicktime", title = title, artist = artist, album = album, date = date, genre = genre) else null
+        }
+    }
+}

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

@@ -0,0 +1,13 @@
+package com.doublesymmetry.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"),
+}

package/android/src/main/java/com/doublesymmetry/trackplayer/model/Track.kt

@@ -0,0 +1,67 @@
+package com.doublesymmetry.trackplayer.model
+
+import android.content.ContentResolver
+import android.content.Context
+import android.net.Uri
+import android.os.Bundle
+import androidx.annotation.OptIn
+import androidx.media3.common.util.UnstableApi
+import com.lovegaoshi.kotlinaudio.models.AudioItemOptions
+import com.lovegaoshi.kotlinaudio.models.MediaType
+import com.doublesymmetry.trackplayer.utils.BundleUtils
+
+/**
+ * @author Milen Pivchev @mpivchev
+ */
+@OptIn(UnstableApi::class)
+class Track
+    (context: Context, bundle: Bundle, ratingType: Int) : TrackMetadata() {
+    var uri: Uri? = null
+    var resourceId: Int?
+    var type = MediaType.DEFAULT
+    var contentType: String?
+    var userAgent: String?
+    var originalItem: Bundle?
+    var headers: HashMap<String, String>? = null
+    val queueId: Long
+
+    override fun setMetadata(context: Context, bundle: Bundle?, ratingType: Int) {
+        super.setMetadata(context, bundle, ratingType)
+        if (originalItem != null && originalItem != bundle) originalItem!!.putAll(bundle)
+    }
+
+    fun toAudioItem(): TrackAudioItem {
+        return TrackAudioItem(this, type, uri.toString(), artist, title, album, artwork.toString(), duration,
+                AudioItemOptions(headers, userAgent, resourceId), mediaId)
+    }
+
+    init {
+        resourceId = BundleUtils.getRawResourceId(context, bundle, "url")
+        uri = if (resourceId == 0) {
+            resourceId = null
+            BundleUtils.getUri(context, bundle, "url")
+        } else {
+            // RawResourceDataSource.buildRawResourceUri(resourceId!!)
+            Uri.Builder().scheme(ContentResolver.SCHEME_ANDROID_RESOURCE).path(resourceId!!.toString()).build()
+        }
+        val trackType = bundle.getString("type", "default")
+        for (t in MediaType.entries) {
+            if (t.name.equals(trackType, ignoreCase = true)) {
+                type = t
+                break
+            }
+        }
+        contentType = bundle.getString("contentType")
+        userAgent = bundle.getString("userAgent")
+        val httpHeaders = bundle.getBundle("headers")
+        if (httpHeaders != null) {
+            headers = HashMap()
+            for (header in httpHeaders.keySet()) {
+                headers!![header] = httpHeaders.getString(header)!!
+            }
+        }
+        setMetadata(context, bundle, ratingType)
+        queueId = System.currentTimeMillis()
+        originalItem = bundle
+    }
+}

package/android/src/main/java/com/doublesymmetry/trackplayer/model/TrackAudioItem.kt

@@ -0,0 +1,18 @@
+package com.doublesymmetry.trackplayer.model
+
+import com.lovegaoshi.kotlinaudio.models.AudioItem
+import com.lovegaoshi.kotlinaudio.models.AudioItemOptions
+import com.lovegaoshi.kotlinaudio.models.MediaType
+
+data class TrackAudioItem(
+    val track: Track,
+    override val type: MediaType,
+    override var audioUrl: String,
+    override var artist: String? = null,
+    override var title: String? = null,
+    override var albumTitle: String? = null,
+    override val artwork: String? = null,
+    override val duration: Long? = null,
+    override val options: AudioItemOptions? = null,
+    override val mediaId: String? = null
+): AudioItem

package/android/src/main/java/com/doublesymmetry/trackplayer/model/TrackMetadata.kt

@@ -0,0 +1,38 @@
+package com.doublesymmetry.trackplayer.model
+
+import android.content.Context
+import android.net.Uri
+import android.os.Bundle
+import androidx.media3.common.Rating
+import com.doublesymmetry.trackplayer.extensions.NumberExt.Companion.toMilliseconds
+import com.doublesymmetry.trackplayer.utils.BundleUtils
+
+abstract class TrackMetadata {
+    var artwork: Uri? = null
+    var title: String? = null
+    var artist: String? = null
+    var album: String? = null
+    var date: String? = null
+    var genre: String? = null
+    var duration: Long? = null
+    var rating: Rating? = null
+    var mediaId: String? = null
+
+    open fun setMetadata(context: Context, bundle: Bundle?, ratingType: Int) {
+        artwork = BundleUtils.getUri(context, bundle, "artwork")
+        title = bundle!!.getString("title")
+        artist = bundle.getString("artist")
+        album = bundle.getString("album")
+        date = bundle.getString("date")
+        genre = bundle.getString("genre")
+        mediaId = bundle.getString("mediaId")
+
+        duration = if (bundle.containsKey("duration")) {
+            bundle.getDouble("duration").toMilliseconds()
+        } else {
+            null
+        }
+
+        rating = BundleUtils.getRating(bundle, "rating", ratingType)
+    }
+}