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

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

package/android/src/main/java/com/doublesymmetry/trackplayer/module/MusicEvents.kt

@@ -0,0 +1,67 @@
+package com.doublesymmetry.trackplayer.module
+
+import android.content.BroadcastReceiver
+import android.content.Context
+import android.content.Intent
+import com.facebook.react.bridge.Arguments
+import com.facebook.react.bridge.ReactContext
+import com.facebook.react.modules.core.DeviceEventManagerModule.RCTDeviceEventEmitter
+
+/**
+ * @author Milen Pivchev @mpivchev
+ */
+class MusicEvents(private val reactContext: ReactContext) : BroadcastReceiver() {
+    override fun onReceive(context: Context, intent: Intent) {
+        val event = intent.getStringExtra("event")
+        val data = intent.getBundleExtra("data")
+        val map = if (data != null) Arguments.fromBundle(data) else null
+        reactContext.emitDeviceEvent(event!!, map)
+    }
+
+    companion object {
+        // Media Control Events
+        const val BUTTON_PLAY = "remote-play"
+        const val BUTTON_PLAY_PAUSE = "remote-play-pause"
+        const val BUTTON_PLAY_FROM_ID = "remote-play-id"
+        const val BUTTON_PLAY_FROM_SEARCH = "remote-play-search"
+        const val BUTTON_SEARCH = "remote-search"
+        const val BUTTON_PAUSE = "remote-pause"
+        const val BUTTON_STOP = "remote-stop"
+        const val BUTTON_SKIP = "remote-skip"
+        const val BUTTON_SKIP_NEXT = "remote-next"
+        const val BUTTON_SKIP_PREVIOUS = "remote-previous"
+        const val BUTTON_SEEK_TO = "remote-seek"
+        const val BUTTON_SET_RATING = "remote-set-rating"
+        const val BUTTON_JUMP_FORWARD = "remote-jump-forward"
+        const val BUTTON_JUMP_BACKWARD = "remote-jump-backward"
+        const val BUTTON_DUCK = "remote-duck"
+        const val BUTTON_BROWSE = "remote-browse"
+        const val BUTTON_CUSTOM_ACTION = "remote-custom-action"
+
+        // Playback Events
+        const val PLAYBACK_PLAY_WHEN_READY_CHANGED = "playback-play-when-ready-changed"
+        const val PLAYBACK_STATE = "playback-state"
+        const val PLAYBACK_TRACK_CHANGED = "playback-track-changed"
+        const val PLAYBACK_ACTIVE_TRACK_CHANGED = "playback-active-track-changed"
+        const val PLAYBACK_QUEUE_ENDED = "playback-queue-ended"
+        const val PLAYBACK_METADATA = "playback-metadata-received"
+        const val PLAYBACK_PROGRESS_UPDATED = "playback-progress-updated"
+        const val PLAYBACK_ERROR = "playback-error"
+        const val PLAYBACK_ANIMATED_VOLUME_CHANGED = "playback-animated-volume-changed"
+        const val PLAYBACK_RESUME = "playback-resume-android"
+        const val FFT_UPDATED = "fft-updated"
+
+        // Metadata Events
+        const val METADATA_CHAPTER_RECEIVED = "metadata-chapter-received"
+        const val METADATA_TIMED_RECEIVED = "metadata-timed-received"
+        const val METADATA_COMMON_RECEIVED = "metadata-common-received"
+        const val METADATA_PAYLOAD_KEY = "metadata"
+
+        // Other
+        const val PLAYER_ERROR = "player-error"
+        const val CONNECTOR_CONNECTED = "android-controller-connected"
+        const val CONNECTOR_DISCONNECTED = "android-controller-disconnected"
+
+        const val EVENT_INTENT = "com.doublesymmetry.trackplayer.event"
+    }
+}