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

package/android/src/main/java/com/guichaguri/trackplayer/service/MusicService.kt

@@ -0,0 +1,1268 @@
+package com.guichaguri.trackplayer.service
+
+import android.annotation.SuppressLint
+import android.app.ActivityManager
+import android.app.ForegroundServiceStartNotAllowedException
+import android.app.Notification
+import android.app.NotificationChannel
+import android.app.NotificationManager
+import android.app.PendingIntent
+import android.content.Context
+import android.content.Intent
+import android.content.pm.ServiceInfo
+import android.os.Build
+import android.os.Bundle
+import android.os.Handler
+import android.os.IBinder
+import android.support.v4.media.MediaBrowserCompat.MediaItem
+import android.support.v4.media.RatingCompat
+import android.support.v4.media.session.MediaSessionCompat
+import android.support.v4.media.session.PlaybackStateCompat
+import android.view.KeyEvent
+import android.view.KeyEvent.KEYCODE_MEDIA_STOP
+import androidx.annotation.MainThread
+import androidx.core.app.NotificationCompat
+import androidx.media.session.MediaButtonReceiver
+import androidx.media.utils.MediaConstants
+import com.facebook.react.ReactHost
+import com.facebook.react.ReactInstanceEventListener
+import com.facebook.react.ReactInstanceManager
+import com.facebook.react.bridge.Arguments
+import com.facebook.react.bridge.ReactContext
+import com.facebook.react.bridge.WritableNativeMap
+import com.facebook.react.defaults.DefaultNewArchitectureEntryPoint.bridgelessEnabled
+import com.facebook.react.jstasks.HeadlessJsTaskConfig
+import com.facebook.react.modules.appregistry.AppRegistry
+import com.facebook.react.modules.core.DeviceEventManagerModule
+import com.facebook.react.views.imagehelper.ResourceDrawableIdHelper
+import com.google.android.exoplayer2.source.MediaSource
+import com.guichaguri.trackplayer.HeadlessJsMediaService
+import com.guichaguri.trackplayer.R
+import com.guichaguri.trackplayer.extensions.asLibState
+import com.guichaguri.trackplayer.kotlinaudio.models.AAMediaSessionCallBack
+import com.guichaguri.trackplayer.kotlinaudio.models.AudioContentType
+import com.guichaguri.trackplayer.kotlinaudio.models.AudioItemTransitionReason
+import com.guichaguri.trackplayer.kotlinaudio.models.AudioPlayerState
+import com.guichaguri.trackplayer.kotlinaudio.models.BufferConfig
+import com.guichaguri.trackplayer.kotlinaudio.models.CacheConfig
+import com.guichaguri.trackplayer.kotlinaudio.models.Capability
+import com.guichaguri.trackplayer.kotlinaudio.models.MediaSessionCallback
+import com.guichaguri.trackplayer.kotlinaudio.models.NotificationButton
+import com.guichaguri.trackplayer.kotlinaudio.models.NotificationButton.CUSTOM_ACTION
+import com.guichaguri.trackplayer.kotlinaudio.models.NotificationButton.NEXT
+import com.guichaguri.trackplayer.kotlinaudio.models.NotificationButton.PLAY_PAUSE
+import com.guichaguri.trackplayer.kotlinaudio.models.NotificationButton.PREVIOUS
+import com.guichaguri.trackplayer.kotlinaudio.models.NotificationButton.SEEK_TO
+import com.guichaguri.trackplayer.kotlinaudio.models.NotificationButton.STOP
+import com.guichaguri.trackplayer.kotlinaudio.models.NotificationConfig
+import com.guichaguri.trackplayer.kotlinaudio.models.NotificationState
+import com.guichaguri.trackplayer.kotlinaudio.models.PlayerConfig
+import com.guichaguri.trackplayer.kotlinaudio.models.RepeatMode
+import com.guichaguri.trackplayer.kotlinaudio.players.QueuedAudioPlayer
+import com.guichaguri.trackplayer.model.Track
+import com.guichaguri.trackplayer.model.TrackAudioItem
+import com.guichaguri.trackplayer.module.AutoConnectionDetector
+import com.guichaguri.trackplayer.module.MusicEvents
+import com.guichaguri.trackplayer.module.MusicModule
+import com.guichaguri.trackplayer.module.MusicModule.Companion.autoConnectionDetector
+import com.guichaguri.trackplayer.service.Utils.setRating
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.Job
+import kotlinx.coroutines.MainScope
+import kotlinx.coroutines.delay
+import kotlinx.coroutines.flow.flow
+import kotlinx.coroutines.launch
+import kotlinx.coroutines.withContext
+import java.util.concurrent.TimeUnit
+
+/**
+ * @author Guichaguri
+ */
+
+class MusicService : HeadlessJsMediaService() {
+    private var player: QueuedAudioPlayer? = null
+    var manager: MusicManager? = null
+    var handler: Handler? = null
+    private var intentToStop = false
+    var mediaTree: MutableMap<String, MutableList<MediaItem>> = HashMap()
+    var toUpdateMediaItems: MutableMap<String, MutableList<MediaItem>> = HashMap()
+    var loadingChildrenParentMediaId: String? = null
+    var searchQuery: String? = null
+    var searchResult: Result<MutableList<MediaItem>>? = null
+
+    private val scope = MainScope()
+
+    val tracks: List<Track>
+        get() = player?.items?.map { (it as TrackAudioItem).track } ?: emptyList()
+
+    val state
+        get() = player?.playerState
+
+    var ratingType: Int
+        get() = player?.ratingType ?: RatingCompat.RATING_NONE
+        set(value) {
+            player?.ratingType = value
+        }
+
+    val playbackError
+        get() = player?.playbackError
+
+    val event
+        get() = player?.event
+
+    var playWhenReady: Boolean
+        get() = player?.playWhenReady ?: false
+        set(value) {
+            player?.playWhenReady = value
+        }
+
+    private var latestOptions: Bundle? = null
+
+    private var mediaSession: MediaSessionCompat? = null
+    private var stateBuilder: PlaybackStateCompat.Builder? = null
+
+    override fun getTaskConfig(intent: Intent): HeadlessJsTaskConfig {
+        return HeadlessJsTaskConfig("TrackPlayer", Arguments.createMap(), 0, true)
+    }
+
+    override fun onHeadlessJsTaskFinish(taskId: Int) {
+        // Overridden to prevent the service from being terminated
+    }
+
+    @SuppressLint("VisibleForTests")
+    @MainThread
+    fun emit(event: String, data: Bundle? = null) {
+        val currentReactContext = if (bridgelessEnabled) reactHost.currentReactContext else reactNativeHost.reactInstanceManager.currentReactContext
+        currentReactContext
+            ?.getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter::class.java)
+            ?.emit(event, data?.let { Arguments.fromBundle(it) })
+    }
+
+    fun destroy(intentToStop: Boolean) {
+        try {
+            if (handler != null) {
+                handler!!.removeMessages(0)
+                handler = null
+            }
+            if (manager != null) {
+                manager!!.destroy(intentToStop)
+                manager = null
+            }
+
+            if (autoConnectionDetector?.isCarConnected != true) {
+                player?.destroy()
+            }
+        } catch (_: Exception) {}
+    }
+
+    @SuppressLint("VisibleForTests")
+    private fun onStartForeground() {
+        var serviceForeground = false
+        if (manager != null) {
+            // The session is only active when the service is on foreground
+            serviceForeground = manager!!.metadata.session.isActive
+        }
+
+        if (!serviceForeground) {
+            val currentReactContext = if (bridgelessEnabled) reactHost.currentReactContext else reactNativeHost.reactInstanceManager.currentReactContext
+
+            // Checks whether there is a React activity
+            if (currentReactContext == null || !currentReactContext.hasCurrentActivity()) {
+                val channel = Utils.getNotificationChannel(this as Context)
+
+                // Sets the service to foreground with an empty notification
+                if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.Q) {
+                    startForeground(
+                        EMPTY_NOTIFICATION_ID,
+                        NotificationCompat.Builder(this, channel).build(),
+                        ServiceInfo.FOREGROUND_SERVICE_TYPE_MEDIA_PLAYBACK
+                    )
+                } else {
+                    startForeground(EMPTY_NOTIFICATION_ID, NotificationCompat.Builder(this, channel).build())
+                }
+                // Stops the service right after
+                stopSelf()
+            }
+        }
+    }
+
+    override fun onBind(intent: Intent): IBinder? {
+        /* if(Utils.CONNECT_INTENT.equals(intent.getAction())) {
+            return new MusicBinder(this, manager);
+        }
+        return super.onBind(intent); */
+
+        return if (SERVICE_INTERFACE == intent.action) {
+            super.onBind(intent)
+        } else MusicBinder(this, manager!!)
+    }
+
+    fun invokeStartTask(reactContext: ReactContext, restart: Boolean = false) {
+        try {
+            val catalystInstance = reactContext.catalystInstance
+            val jsAppModuleName = "AndroidAuto"
+            val appParams = WritableNativeMap()
+            appParams.putDouble("rootTag", 1.0)
+            appParams.putBoolean("restart", restart)
+            val appProperties = Bundle.EMPTY
+            if (appProperties != null) {
+                appParams.putMap("initialProps", Arguments.fromBundle(appProperties))
+            }
+            val jsModule = catalystInstance.getJSModule(AppRegistry::class.java)
+            if (jsModule !== null) jsModule.runApplication(jsAppModuleName, appParams)
+        } catch (e: Exception) {
+            e.printStackTrace()
+        }
+    }
+
+    override fun onSearch(query: String, extras: Bundle?, result: Result<MutableList<MediaItem>>) {
+        searchQuery = query
+        searchResult = result
+        result.detach()
+        emit(MusicEvents.SEARCH, Bundle().apply {
+            putString("query", query)
+        });
+    }
+
+    override fun onGetRoot(
+        clientPackageName: String,
+        clientUid: Int,
+        rootHints: Bundle?
+    ): BrowserRoot {
+        if (clientPackageName == "com.google.android.projection.gearhead") {
+            val currentReactContext = if (bridgelessEnabled) reactHost.currentReactContext else reactNativeHost.reactInstanceManager.currentReactContext
+
+            if (currentReactContext == null) {
+                if (bridgelessEnabled) { // new arch
+                    val reactHost: ReactHost = reactHost
+                    reactHost.addReactInstanceEventListener(
+                        object : ReactInstanceEventListener {
+                            override fun onReactContextInitialized(context: ReactContext) {
+                                invokeStartTask(context)
+                                reactHost.removeReactInstanceEventListener(this)
+                            }
+                        }
+                    )
+                    reactHost.start()
+                } else { // old arch
+                    val reactInstanceManager =
+                        reactNativeHost.reactInstanceManager
+                    reactInstanceManager.addReactInstanceEventListener(object :
+                        @Suppress("DEPRECATION")
+                        ReactInstanceManager.ReactInstanceEventListener {
+                        override fun onReactContextInitialized(context: ReactContext) {
+                            invokeStartTask(context)
+                            reactInstanceManager.removeReactInstanceEventListener(this)
+
+                            autoConnectionDetector?.isCarConnected = true
+
+                            val params = Arguments.createMap()
+                            params.putBoolean("connected", true)
+
+                            context.getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter::class.java)
+                                ?.emit(
+                                    "car-connection-update", params
+                                )
+                        }
+                    })
+                    reactInstanceManager.createReactContextInBackground()
+                }
+            } else {
+                if (MusicModule.isAppOpen) {
+                    autoConnectionDetector?.isCarConnected = true
+
+                    val params = Arguments.createMap()
+                    params.putBoolean("connected", true)
+
+                    currentReactContext.getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter::class.java)?.emit(
+                        "car-connection-update", params
+                    )
+                } else {
+                    if (bridgelessEnabled) { // new arch
+                        val reactHost: ReactHost = reactHost
+                        reactHost.destroy("track-player", null)
+                        reactHost.addReactInstanceEventListener(object :
+                            @Suppress("DEPRECATION")
+                            ReactInstanceEventListener {
+                            override fun onReactContextInitialized(context: ReactContext) {
+                                invokeStartTask(context)
+                                reactHost.removeReactInstanceEventListener(
+                                    this
+                                )
+
+                                autoConnectionDetector?.isCarConnected = true
+
+                                val params = Arguments.createMap()
+                                params.putBoolean("connected", true)
+
+                                context.getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter::class.java)
+                                    ?.emit(
+                                        "car-connection-update", params
+                                    )
+                            }
+                        })
+                        reactHost.start()
+                    } else { // old arch
+                        reactNativeHost.reactInstanceManager.destroy()
+                        reactNativeHost.reactInstanceManager.addReactInstanceEventListener(object :
+                            @Suppress("DEPRECATION")
+                            ReactInstanceManager.ReactInstanceEventListener {
+                            override fun onReactContextInitialized(context: ReactContext) {
+                                invokeStartTask(context)
+                                reactNativeHost.reactInstanceManager.removeReactInstanceEventListener(
+                                    this
+                                )
+
+                                autoConnectionDetector?.isCarConnected = true
+
+                                val params = Arguments.createMap()
+                                params.putBoolean("connected", true)
+
+                                context.getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter::class.java)
+                                    ?.emit(
+                                        "car-connection-update", params
+                                    )
+                            }
+                        })
+                        reactNativeHost.reactInstanceManager.createReactContextInBackground()
+                    }
+                }
+            }
+        }
+
+        val extras = Bundle()
+
+        extras.putBoolean(
+            MediaConstants.BROWSER_SERVICE_EXTRAS_KEY_SEARCH_SUPPORTED, true)
+
+        return BrowserRoot("/", extras)
+    }
+
+    @MainThread
+    fun add(track: Track) {
+        add(listOf(track))
+    }
+
+    @MainThread
+    fun add(tracks: List<Track>) {
+        val items = tracks.map {
+            val x = it
+            x.toAudioItem()
+        }
+        player?.add(items)
+    }
+
+    @MainThread
+    fun add(tracks: List<Track>, atIndex: Int) {
+        if (player != null && (atIndex <= (player?.getQueueSize() ?: -1))) {
+            val items = tracks.map {
+                val x = it
+                if (x.url.isEmpty()) {
+                    val rawId = R.raw.silent_5_seconds
+                    x.url = "android.resource://${applicationContext.packageName}/$rawId"
+                    x.duration = 10
+                }
+                x.toAudioItem()
+            }
+            player?.add(items, atIndex)
+        }
+    }
+
+    @MainThread
+    fun load(track: Track) {
+        val audioItem = track.toAudioItem()
+        player?.load(audioItem)
+    }
+
+    @MainThread
+    fun move(fromIndex: Int, toIndex: Int) {
+        player?.move(fromIndex, toIndex);
+    }
+
+    @MainThread
+    fun remove(index: Int) {
+        remove(listOf(index))
+    }
+
+    @MainThread
+    fun remove(indexes: List<Int>) {
+        player?.remove(indexes)
+    }
+
+    @MainThread
+    fun clear() {
+        player?.clear()
+    }
+
+    @MainThread
+    fun play() {
+        MusicModule.firstPlayDone = true
+        player?.play()
+    }
+
+    @MainThread
+    fun pause() {
+        player?.pause()
+    }
+
+    @MainThread
+    fun stop() {
+        player?.stop()
+    }
+
+    @MainThread
+    fun removeUpcomingTracks() {
+        player?.removeUpcomingItems()
+    }
+
+    @MainThread
+    fun removePreviousTracks() {
+        player?.removePreviousItems()
+    }
+
+    @MainThread
+    fun skip(index: Int) {
+        player?.jumpToItem(index)
+    }
+
+    @MainThread
+    fun skipToNext() {
+        player?.next()
+    }
+
+    @MainThread
+    fun skipToPrevious() {
+        player?.previous()
+    }
+
+    @MainThread
+    fun seekTo(seconds: Float) {
+        player?.seek((seconds * 1000).toLong(), TimeUnit.MILLISECONDS)
+    }
+
+    @MainThread
+    fun seekBy(offset: Float) {
+        player?.seekBy((offset.toLong()), TimeUnit.SECONDS)
+    }
+
+    @MainThread
+    fun retry() {
+        player?.prepare()
+    }
+
+    @MainThread
+    fun getCurrentTrackIndex(): Int {
+        // return player?.currentIndex ?: 0
+        return 0
+    }
+
+    @MainThread
+    fun getRate(): Float {
+        return player?.playbackSpeed ?: 1f
+    }
+
+    @MainThread
+    fun setRate(value: Float) {
+        if (player != null) {
+            player!!.playbackSpeed = value
+        }
+    }
+
+    @MainThread
+    fun getRepeatMode(): RepeatMode {
+        return player?.playerOptions?.repeatMode ?: RepeatMode.OFF
+    }
+
+    @MainThread
+    fun setRepeatMode(value: RepeatMode) {
+        if (player != null) {
+            player!!.playerOptions.repeatMode = value
+        }
+    }
+
+    @MainThread
+    fun getVolume(): Float {
+        return player?.volume ?: 0f
+    }
+
+    @MainThread
+    fun setVolume(value: Float) {
+        if (player != null) {
+            player!!.volume = value
+        }
+    }
+
+    @MainThread
+    fun getDurationInSeconds(): Double {
+        return ((player?.duration ?: 0) / 1000).toDouble()
+    }
+
+    @MainThread
+    fun getPositionInSeconds(): Double {
+        return ((player?.position ?: 0) / 1000).toDouble()
+    }
+
+    @MainThread
+    fun getBufferedPositionInSeconds(): Double {
+        return ((player?.bufferedPosition ?: 0) / 1000).toDouble()
+    }
+
+    @MainThread
+    fun getPlayerStateBundle(state: AudioPlayerState): Bundle {
+        val bundle = Bundle()
+        bundle.putString(STATE_KEY, state.asLibState.state)
+        if (state == AudioPlayerState.ERROR) {
+            bundle.putBundle(ERROR_KEY, getPlaybackErrorBundle())
+        }
+        return bundle
+    }
+
+    @MainThread
+    fun updateMetadataForTrack(index: Int, track: Track) {
+        player?.replaceItem(index, track.toAudioItem())
+    }
+
+    @MainThread
+    fun getPlayerQueueHead(): MediaSource? {
+        return player?.getQueueHead()
+    }
+
+//    @MainThread
+//    fun updateNowPlayingMetadata(track: Track) {
+//        val audioItem = track.toAudioItem()
+//        player.notificationManager.notificationMetadata = NotificationMetadata(audioItem?.title, audioItem?.artist, audioItem?.artwork, audioItem?.duration)
+//    }
+
+    @MainThread
+    fun clearNotificationMetadata() {
+        player?.notificationManager?.hideNotification()
+    }
+
+    //
+    // FORCED CURRENT INDEX TO 0
+    //
+    private fun emitPlaybackTrackChangedEvents(
+        // index: Int?,
+        previousIndex: Int?,
+        oldPosition: Double
+    ) {
+        if (player != null) {
+            val a = Bundle()
+            a.putDouble(POSITION_KEY, oldPosition)
+            //if (index != null) {
+            a.putInt(NEXT_TRACK_KEY, 0)
+            //}
+
+            if (previousIndex != null) {
+                a.putInt(TRACK_KEY, previousIndex)
+            }
+
+            emit(MusicEvents.PLAYBACK_TRACK_CHANGED, a)
+
+            val b = Bundle()
+            b.putDouble("lastPosition", oldPosition)
+            if (tracks.isNotEmpty()) {
+//            b.putInt("index", player.currentIndex)
+//            b.putBundle("track", tracks[player.currentIndex].originalItem)
+                b.putInt("index", 0)
+                b.putBundle("track", tracks[0].originalItem)
+                if (previousIndex != null) {
+                    b.putInt("lastIndex", previousIndex)
+                    b.putBundle("lastTrack", tracks[previousIndex].originalItem)
+                }
+            }
+            emit(MusicEvents.PLAYBACK_ACTIVE_TRACK_CHANGED, b)
+        }
+    }
+
+    override fun onLoadChildren(
+        parentMediaId: String,
+        result: Result<List<MediaItem>>
+    ) {
+        try {
+            val mediaIdParts = parentMediaId.split("-/-")
+            val itemType = mediaIdParts.getOrNull(1)
+
+            if (itemType == "empty") {
+                result.sendResult(emptyList())
+            }
+
+            if (mediaTree.keys.contains(parentMediaId) || parentMediaId == "/" || parentMediaId.contains(
+                    "tab"
+                )
+            ) {
+                result.sendResult(mediaTree[parentMediaId])
+            } else if (parentMediaId != loadingChildrenParentMediaId) {
+                loadingChildrenParentMediaId = parentMediaId
+                emit(MusicEvents.BUTTON_BROWSE, Bundle().apply {
+                    putString("mediaId", parentMediaId)
+                })
+                result.sendResult(mediaTree["placeholder"])
+            }
+        } catch (_: Exception) {}
+    }
+
+    override fun onLoadItem(itemId: String, result: Result<MediaItem>) {}
+
+    @SuppressLint("RestrictedApi")
+    override fun onCreate() {
+        super.onCreate()
+
+        // Create a MediaSessionCompat
+        // mediaSession = MediaSessionCompat(baseContext, PackageManagerCompat.LOG_TAG)
+
+        // Enable callbacks from MediaButtons and TransportControls
+//        @Suppress("DEPRECATION")
+//        mediaSession!!.setFlags(
+//            MediaSessionCompat.FLAG_HANDLES_MEDIA_BUTTONS or
+//                    MediaSessionCompat.FLAG_HANDLES_TRANSPORT_CONTROLS
+//        )
+
+        // Set an initial PlaybackState with ACTION_PLAY, so media buttons can start the player
+//        stateBuilder = PlaybackStateCompat.Builder()
+//            .setActions(
+//                PlaybackStateCompat.ACTION_SKIP_TO_NEXT
+//            )
+
+//        if (stateBuilder != null) {
+//            mediaSession!!.setPlaybackState(stateBuilder!!.build())
+//        }
+
+        // MySessionCallback() has methods that handle callbacks from a media controller
+        // mediaSession.setCallback(new MySessionCallback());
+
+        // Set the session's token so that client activities can communicate with it.
+
+        // remove comment if not using player
+        //sessionToken = mediaSession!!.sessionToken
+
+        //onStartForeground();
+        if (manager == null) manager = MusicManager(this)
+        @Suppress("DEPRECATION")
+        if (handler == null) handler = Handler()
+        val channel = Utils.getNotificationChannel(this as Context)
+
+        // Sets the service to foreground with an empty notification
+        try {
+            if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.Q) {
+                startForeground(
+                    EMPTY_NOTIFICATION_ID,
+                    NotificationCompat.Builder(this, channel).build(),
+                    ServiceInfo.FOREGROUND_SERVICE_TYPE_MEDIA_PLAYBACK
+                )
+            } else {
+                startForeground(EMPTY_NOTIFICATION_ID, NotificationCompat.Builder(this, channel).build())
+            }
+        } catch (_: Exception) { }
+    }
+
+    override fun onCustomAction(action: String, extras: Bundle?, result: Result<Bundle>) {}
+
+    /**
+     * Workaround for the "Context.startForegroundService() did not then call Service.startForeground()"
+     * within 5s" ANR and crash by creating an empty notification and stopping it right after. For more
+     * information see https://github.com/doublesymmetry/react-native-track-player/issues/1666
+     */
+    private fun startAndStopEmptyNotificationToAvoidANR() {
+        val notificationManager = this.getSystemService(NOTIFICATION_SERVICE) as NotificationManager
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
+            notificationManager.createNotificationChannel(
+                NotificationChannel("Playback", "Playback", NotificationManager.IMPORTANCE_LOW)
+            )
+        }
+
+        val resId = applicationContext.resources.getIdentifier("track_player_logo", "drawable", applicationContext.packageName)
+        val logo = if (resId != 0) resId else R.drawable.ic_play
+        val notificationBuilder: NotificationCompat.Builder = NotificationCompat.Builder(
+            this, "Playback"
+        )
+            .setPriority(NotificationCompat.PRIORITY_LOW)
+            .setCategory(NotificationCompat.CATEGORY_SERVICE)
+            .setSmallIcon(logo)
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.S) {
+            notificationBuilder.setForegroundServiceBehavior(NotificationCompat.FOREGROUND_SERVICE_IMMEDIATE)
+        }
+        val notification = notificationBuilder.build()
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.Q) {
+            startForeground(EMPTY_NOTIFICATION_ID, notification, ServiceInfo.FOREGROUND_SERVICE_TYPE_MEDIA_PLAYBACK)
+        } else {
+            startForeground(EMPTY_NOTIFICATION_ID, notification)
+        }
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.N) {
+            stopForeground(STOP_FOREGROUND_REMOVE)
+        } else {
+            @Suppress("DEPRECATION")
+            stopForeground(true)
+        }
+    }
+
+    override fun onStartCommand(intent: Intent?, flags: Int, startId: Int): Int {
+
+        if (intent == null) {
+            return START_NOT_STICKY
+        }
+
+        if (Intent.ACTION_MEDIA_BUTTON == intent.action) {
+            onStartForeground()
+
+            if (Build.VERSION.SDK_INT >= 33) {
+                try {
+                    startAndStopEmptyNotificationToAvoidANR()
+                } catch (_: java.lang.Exception) {}
+            }
+
+            @Suppress("DEPRECATION")
+            val intentExtra: KeyEvent? = intent.getParcelableExtra(Intent.EXTRA_KEY_EVENT)
+            if (intentExtra!!.keyCode == KEYCODE_MEDIA_STOP) {
+                intentToStop = true
+                startServiceOreoAndAbove()
+                stopSelf()
+            } else {
+                intentToStop = false
+            }
+
+            if (manager != null) {
+                MediaButtonReceiver.handleIntent(manager!!.metadata.session, intent)
+                return START_NOT_STICKY
+            }
+        }
+
+        if (manager == null) manager = MusicManager(this)
+
+        @Suppress("DEPRECATION")
+        if (handler == null) handler = Handler()
+
+        super.onStartCommand(intent, flags, startId)
+        return START_NOT_STICKY
+    }
+
+    private fun startServiceOreoAndAbove() {
+        // Needed to prevent crash when dismissing notification
+        // https://stackoverflow.com/questions/47609261/bound-service-crash-with-context-startforegroundservice-did-not-then-call-ser?rq=1
+        if (Build.VERSION.SDK_INT >= 26) {
+            val channelId = Utils.NOTIFICATION_CHANNEL
+            val channelName = "Playback"
+            val channel = NotificationChannel(
+                channelId,
+                channelName,
+                NotificationManager.IMPORTANCE_DEFAULT
+            )
+            (getSystemService(NOTIFICATION_SERVICE) as NotificationManager).createNotificationChannel(
+                channel
+            )
+            val resId = applicationContext.resources.getIdentifier("track_player_logo", "drawable", applicationContext.packageName)
+            val logo = if (resId != 0) resId else R.drawable.ic_play
+            val notification = NotificationCompat.Builder(this, channelId)
+                .setCategory(Notification.CATEGORY_SERVICE).setSmallIcon(logo)
+                .setPriority(
+                    NotificationCompat.PRIORITY_MIN
+                ).build()
+            if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.Q) {
+                startForeground(EMPTY_NOTIFICATION_ID, notification, ServiceInfo.FOREGROUND_SERVICE_TYPE_MEDIA_PLAYBACK)
+            } else {
+                startForeground(EMPTY_NOTIFICATION_ID, notification)
+            }
+        }
+    }
+
+    override fun onDestroy() {
+        super.onDestroy()
+        if (manager != null) {
+            manager!!.destroy(true)
+            manager = null
+        }
+    }
+
+    override fun onTaskRemoved(rootIntent: Intent) {
+        super.onTaskRemoved(rootIntent)
+        if (manager == null || manager!!.shouldStopWithApp()) {
+            destroy(true)
+            stopSelf()
+        }
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.N) {
+            stopForeground(STOP_FOREGROUND_REMOVE)
+        } else {
+            @Suppress("DEPRECATION")
+            stopForeground(true)
+        }
+    }
+
+    @MainThread
+    fun setupPlayer(playerOptions: Bundle?) {
+        if (player != null) {
+            print("Player was initialized. Prevent re-initializing again")
+            return
+        }
+
+        val bufferConfig = BufferConfig(
+            playerOptions?.getDouble(MIN_BUFFER_KEY)?.toInt(),
+            playerOptions?.getDouble(MAX_BUFFER_KEY)?.toInt(),
+            playerOptions?.getDouble(PLAY_BUFFER_KEY)?.toInt(),
+            playerOptions?.getDouble(BACK_BUFFER_KEY)?.toInt(),
+        )
+
+        val cacheConfig = CacheConfig(playerOptions?.getDouble(MAX_CACHE_SIZE_KEY)?.toLong())
+        val playerConfig = PlayerConfig(
+            interceptPlayerActionsTriggeredExternally = true,
+            handleAudioBecomingNoisy = true,
+            handleAudioFocus = true,
+            audioContentType = AudioContentType.MUSIC
+        )
+
+        val automaticallyUpdateNotificationMetadata = playerOptions?.getBoolean(AUTO_UPDATE_METADATA, true) ?: true
+        val mediaSessionCallback = object: AAMediaSessionCallBack {
+            override fun handleCustomActions(action: String?, extras: Bundle?) {}
+
+            override fun handlePlayFromMediaId(mediaId: String?, extras: Bundle?) {
+                val emitBundle = extras ?: Bundle()
+                emit(MusicEvents.BUTTON_PLAY_FROM_ID, emitBundle.apply {
+                    putString("mediaId", mediaId)
+                })
+            }
+
+            override fun handlePlayFromSearch(query: String?, extras: Bundle?) {
+                val emitBundle = extras ?: Bundle()
+                emit(MusicEvents.BUTTON_PLAY_FROM_SEARCH, emitBundle.apply {
+                    putString("query", query)
+                })
+            }
+
+            override fun handleSkipToQueueItem(id: Long) {
+                val emitBundle = Bundle()
+                emit(MusicEvents.BUTTON_PLAY_FROM_QUEUE, emitBundle.apply {
+                    putInt("index", id.toInt())
+                })
+            }
+        }
+        player = QueuedAudioPlayer(this@MusicService, playerConfig, bufferConfig, cacheConfig, mediaSessionCallback)
+        if (MusicModule.isAndroidTv) {
+            player!!.volume = 0f
+        }
+        player!!.automaticallyUpdateNotificationMetadata = automaticallyUpdateNotificationMetadata
+        sessionToken = player!!.getMediaSessionToken()
+
+        observeEvents()
+        setupForegrounding()
+    }
+
+    private fun getPlaybackErrorBundle(): Bundle {
+        val bundle = Bundle()
+        val error = playbackError
+        if (error?.message != null) {
+            bundle.putString("message", error.message)
+        }
+        if (error?.code != null) {
+            bundle.putString("code", "android-" + error.code)
+        }
+        return bundle
+    }
+
+    private fun emitQueueEndedEvent() {
+        if (player != null) {
+            val bundle = Bundle()
+            bundle.putInt(TRACK_KEY, player!!.currentIndex)
+            bundle.putDouble(POSITION_KEY, (player!!.position / 1000).toDouble())
+            emit(MusicEvents.PLAYBACK_QUEUE_ENDED, bundle)
+        }
+    }
+
+    private var capabilities: List<Capability> = emptyList()
+    private var notificationCapabilities: List<Capability> = emptyList()
+    private var compactCapabilities: List<Capability> = emptyList()
+    private var progressUpdateJob: Job? = null
+
+    private fun isCompact(capability: Capability): Boolean {
+        return compactCapabilities.contains(capability)
+    }
+
+    private fun getPendingIntentFlags(): Int {
+        return PendingIntent.FLAG_IMMUTABLE or PendingIntent.FLAG_CANCEL_CURRENT
+    }
+
+    private fun getIcon(options: Bundle, propertyName: String, defaultIcon: Int): Int {
+        if (!options.containsKey(propertyName)) return defaultIcon
+        val bundle = options.getBundle(propertyName) ?: return defaultIcon
+        val helper = ResourceDrawableIdHelper.getInstance()
+        val icon = helper.getResourceDrawableId(this, bundle.getString("uri"))
+        return if (icon == 0) defaultIcon else icon
+    }
+
+    @MainThread
+    fun updateOptions(options: Bundle) {
+        latestOptions = options
+        val androidOptions = options.getBundle(ANDROID_OPTIONS_KEY)
+
+        ratingType = BundleUtils.getInt(options, "ratingType", RatingCompat.RATING_NONE)
+
+        if (player != null) {
+            player!!.playerOptions.alwaysPauseOnInterruption =
+                androidOptions?.getBoolean(PAUSE_ON_INTERRUPTION_KEY) ?: false
+        }
+
+        capabilities = options.getIntegerArrayList("capabilities")?.map {
+            Capability.entries[it] } ?: emptyList()
+        notificationCapabilities = options.getIntegerArrayList("notificationCapabilities")?.map { Capability.entries[it] } ?: emptyList()
+        compactCapabilities = options.getIntegerArrayList("compactCapabilities")?.map { Capability.entries[it] } ?: emptyList()
+        val customActions = options.getStringArrayList(CUSTOM_ACTIONS_KEY)
+        if (notificationCapabilities.isEmpty()) notificationCapabilities = capabilities
+
+        fun customIcon(customAction: String): Int {
+            return when (customAction) {
+                "shuffle-on" -> R.mipmap.ic_shuffle_on_foreground
+                "shuffle-off" -> R.mipmap.ic_shuffle_off_foreground
+                "repeat-on" -> R.mipmap.ic_repeat_on_foreground
+                "repeat-off" -> R.mipmap.ic_repeat_off_foreground
+                "heart" -> R.mipmap.ic_heart_foreground
+                "heart-outlined" -> R.mipmap.ic_heart_outlined_foreground
+                "clock" -> R.mipmap.ic_clock_now_foreground
+                "arrow-down-circle" -> R.mipmap.ic_arrow_down_circle_foreground
+                "md-close" -> R.mipmap.ic_close_foreground
+                else -> R.mipmap.ic_heart_outlined_foreground
+            }
+        }
+
+        val buttonsList = mutableListOf<NotificationButton>()
+
+        notificationCapabilities.forEach { capability ->
+            when (capability) {
+                Capability.PLAY, Capability.PAUSE -> {
+                    val playIcon = getIcon(options, "playIcon", R.drawable.ic_play)
+                    val pauseIcon = getIcon(options, "pauseIcon", R.drawable.ic_pause)
+                    buttonsList.addAll(listOf(PLAY_PAUSE(playIcon = playIcon, pauseIcon = pauseIcon)))
+                }
+                Capability.STOP -> {
+                    val stopIcon = getIcon(options, "stopIcon", R.drawable.ic_stop)
+                    buttonsList.addAll(listOf(STOP(icon = stopIcon)))
+                }
+                Capability.SKIP_TO_NEXT -> {
+                    val nextIcon = getIcon(options, "nextIcon", R.drawable.ic_next)
+                    buttonsList.addAll(listOf(NEXT(icon = nextIcon, isCompact = isCompact(capability))))
+                }
+                Capability.SKIP_TO_PREVIOUS -> {
+                    val previousIcon = getIcon(options, "previousIcon", R.drawable.ic_previous)
+                    buttonsList.addAll(listOf(PREVIOUS(icon = previousIcon, isCompact = isCompact(capability))))
+                }
+//                Capability.JUMP_FORWARD -> {
+//                    val forwardIcon = BundleUtils.getIconOrNull(this, options, "forwardIcon")
+//                    buttonsList.addAll(listOf(FORWARD(icon = forwardIcon, isCompact = isCompact(capability))))
+//                }
+//                Capability.JUMP_BACKWARD -> {
+//                    val backwardIcon = BundleUtils.getIconOrNull(this, options, "rewindIcon")
+//                    buttonsList.addAll(listOf(BACKWARD(icon = backwardIcon, isCompact = isCompact(capability))))
+//                }
+                Capability.SEEK_TO -> {
+                    buttonsList.addAll(listOf(SEEK_TO))
+                }
+                else -> {}
+            }
+        }
+
+        if (customActions != null) {
+            for (customAction in customActions) {
+                val customIcon = customIcon(customAction)
+                buttonsList.add(CUSTOM_ACTION(icon=customIcon, customAction = customAction, isCompact = false))
+            }
+        }
+
+        val openAppIntent = packageManager.getLaunchIntentForPackage(packageName)?.apply {
+//            flags = Intent.FLAG_ACTIVITY_CLEAR_TOP or Intent.FLAG_ACTIVITY_SINGLE_TOP
+            flags = Intent.FLAG_ACTIVITY_SINGLE_TOP
+            action = Intent.ACTION_VIEW
+        }
+
+        val accentColor = BundleUtils.getIntOrNull(options, "color")
+        val resId = applicationContext.resources.getIdentifier("track_player_logo", "drawable", applicationContext.packageName)
+        val smallIcon = if (resId != 0) resId else R.drawable.ic_play
+        val pendingIntent = PendingIntent.getActivity(this, 0, openAppIntent, getPendingIntentFlags())
+        val notificationConfig = NotificationConfig(buttonsList, accentColor, smallIcon, pendingIntent)
+
+        // player.notificationManager.destroy()
+        player?.notificationManager?.createNotification(notificationConfig)
+
+        // setup progress update events if configured
+        progressUpdateJob?.cancel()
+        val updateInterval = BundleUtils.getIntOrNull(options, PROGRESS_UPDATE_EVENT_INTERVAL_KEY)
+        if (updateInterval != null && updateInterval > 0) {
+            progressUpdateJob = scope.launch {
+                progressUpdateEventFlow(updateInterval.toDouble()).collect { emit(MusicEvents.PLAYBACK_PROGRESS_UPDATED, it) }
+            }
+        }
+    }
+
+    @MainThread
+    private fun progressUpdateEventFlow(interval: Double) = flow {
+        while (true) {
+            if (player?.isPlaying == true) {
+                val bundle = progressUpdateEvent()
+                emit(bundle)
+            }
+
+            delay((interval * 1000).toLong())
+        }
+    }
+
+    @MainThread
+    private suspend fun progressUpdateEvent(): Bundle {
+        return withContext(Dispatchers.Main) {
+            player?.let {
+                Bundle().apply {
+                    putDouble(POSITION_KEY, (it.position / 1000).toDouble())
+                    putDouble(DURATION_KEY, (it.duration / 1000).toDouble())
+                    putDouble(BUFFERED_POSITION_KEY, (it.bufferedPosition / 1000).toDouble())
+                    putInt(TRACK_KEY, it.currentIndex)
+                }
+            } ?: Bundle()
+        }
+    }
+
+
+    @MainThread
+    private fun observeEvents() {
+        scope.launch {
+            event?.audioItemTransition?.collect {
+                if (it !is AudioItemTransitionReason.REPEAT && player != null) {
+                    //                    emitPlaybackTrackChangedEvents(
+                    //                        player.currentIndex,
+                    //                        player.previousIndex,
+                    //                        (it?.oldPosition ?: 0).toDouble()
+                    //                    )
+                    //
+                    // FORCED CURRENT INDEX TO 0
+                    //
+                    emitPlaybackTrackChangedEvents(
+                        player!!.previousIndex,
+                        (it?.oldPosition ?: 0).toDouble()
+                    )
+                }
+            }
+        }
+
+        scope.launch {
+            event?.onAudioFocusChanged?.collect {
+                Bundle().apply {
+                    putBoolean(IS_FOCUS_LOSS_PERMANENT_KEY, it.isFocusLostPermanently)
+                    putBoolean(IS_PAUSED_KEY, it.isPaused)
+                    emit(MusicEvents.BUTTON_DUCK, this)
+                }
+            }
+        }
+
+
+        scope.launch {
+            event?.onPlayerActionTriggeredExternally?.collect {
+                when (it) {
+                    is MediaSessionCallback.RATING -> {
+                        Bundle().apply {
+                            setRating(this, "rating", it.rating)
+                            emit(MusicEvents.BUTTON_SET_RATING, this)
+                        }
+                    }
+
+                    is MediaSessionCallback.SEEK -> {
+                        Bundle().apply {
+                            putDouble("position", (it.positionMs / 1000).toDouble())
+                            emit(MusicEvents.BUTTON_SEEK_TO, this)
+                        }
+                    }
+
+                    MediaSessionCallback.PLAY -> emit(MusicEvents.BUTTON_PLAY)
+                    MediaSessionCallback.PAUSE -> emit(MusicEvents.BUTTON_PAUSE)
+                    MediaSessionCallback.NEXT -> emit(MusicEvents.BUTTON_SKIP_NEXT)
+                    MediaSessionCallback.PREVIOUS -> emit(MusicEvents.BUTTON_SKIP_PREVIOUS)
+                    MediaSessionCallback.STOP -> emit(MusicEvents.BUTTON_STOP)
+                    MediaSessionCallback.FORWARD -> {
+                        //                        Bundle().apply {
+                        //                            val interval = latestOptions?.getDouble(FORWARD_JUMP_INTERVAL_KEY, DEFAULT_JUMP_INTERVAL) ?: DEFAULT_JUMP_INTERVAL
+                        //                            putInt("interval", interval.toInt())
+                        //                            emit(MusicEvents.BUTTON_JUMP_FORWARD, this)
+                        //                        }
+                    }
+
+                    MediaSessionCallback.REWIND -> {
+                        //                        Bundle().apply {
+                        //                            val interval = latestOptions?.getDouble(BACKWARD_JUMP_INTERVAL_KEY, DEFAULT_JUMP_INTERVAL) ?: DEFAULT_JUMP_INTERVAL
+                        //                            putInt("interval", interval.toInt())
+                        //                            emit(MusicEvents.BUTTON_JUMP_BACKWARD, this)
+                        //                        }
+                    }
+
+                    is MediaSessionCallback.CUSTOMACTION -> {
+                        Bundle().apply {
+                            if (it.customAction == "shuffle-on" || it.customAction == "shuffle-off") {
+                                emit(MusicEvents.BUTTON_SHUFFLE, this)
+                            } else if (it.customAction == "repeat-on" || it.customAction == "repeat-off") {
+                                emit(MusicEvents.BUTTON_REPEAT, this)
+                            } else if (it.customAction == "heart" || it.customAction == "heart-outlined" || it.customAction == "clock" || it.customAction == "arrow-down-circle" || it.customAction == "md-close") {
+                                emit(MusicEvents.BUTTON_TRACK_STATUS, this)
+                            }
+                        }
+                    }
+                }
+            }
+        }
+    }
+
+    @Suppress("DEPRECATION")
+    fun isForegroundService(): Boolean {
+        val manager = baseContext.getSystemService(Context.ACTIVITY_SERVICE) as ActivityManager
+        for (service in manager.getRunningServices(Int.MAX_VALUE)) {
+            if (MusicService::class.java.name == service.service.className) {
+                return service.foreground
+            }
+        }
+        return false
+    }
+
+    private var stopForegroundGracePeriod: Int = DEFAULT_STOP_FOREGROUND_GRACE_PERIOD
+
+    @MainThread
+    private fun setupForegrounding() {
+        // Implementation based on https://github.com/Automattic/pocket-casts-android/blob/ee8da0c095560ef64a82d3a31464491b8d713104/modules/services/repositories/src/main/java/au/com/shiftyjelly/pocketcasts/repositories/playback/PlaybackService.kt#L218
+        var notificationId: Int? = null
+        var notification: Notification? = null
+        var stopForegroundWhenNotOngoing = false
+        var removeNotificationWhenNotOngoing = false
+
+        fun startForegroundIfNecessary() {
+            if (isForegroundService()) {
+                return
+            }
+            if (notification == null) {
+                return
+            }
+            try {
+                if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.Q) {
+                    startForeground(
+                        notificationId!!,
+                        notification!!,
+                        ServiceInfo.FOREGROUND_SERVICE_TYPE_MEDIA_PLAYBACK
+                    )
+                } else {
+                    startForeground(notificationId!!, notification)
+                }
+            } catch (error: Exception) {
+                if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.S &&
+                    error is ForegroundServiceStartNotAllowedException
+                ) {
+                    emit(MusicEvents.PLAYER_ERROR, Bundle().apply {
+                        putString("message", error.message)
+                        putString("code", "android-foreground-service-start-not-allowed")
+                    });
+                }
+            }
+        }
+
+        scope.launch {
+            val BACKGROUNDABLE_STATES = listOf(
+                AudioPlayerState.IDLE,
+                AudioPlayerState.ENDED,
+                AudioPlayerState.STOPPED,
+                AudioPlayerState.ERROR,
+                AudioPlayerState.PAUSED
+            )
+            val REMOVABLE_STATES = listOf(
+                AudioPlayerState.IDLE,
+                AudioPlayerState.STOPPED,
+                AudioPlayerState.ERROR
+            )
+            val LOADING_STATES = listOf(
+                AudioPlayerState.LOADING,
+                AudioPlayerState.READY,
+                AudioPlayerState.BUFFERING
+            )
+            var stateCount = 0
+            event?.stateChange?.collect {
+                stateCount++
+                if (it in LOADING_STATES) return@collect;
+                // Skip initial idle state, since we are only interested when
+                // state becomes idle after not being idle
+                stopForegroundWhenNotOngoing = stateCount > 1 && it in BACKGROUNDABLE_STATES
+                removeNotificationWhenNotOngoing = stopForegroundWhenNotOngoing && it in REMOVABLE_STATES
+            }
+        }
+
+        fun shouldStopForeground(): Boolean {
+            return stopForegroundWhenNotOngoing && (removeNotificationWhenNotOngoing || isForegroundService())
+        }
+
+        scope.launch {
+            event?.notificationStateChange?.collect {
+                when (it) {
+                    is NotificationState.POSTED -> {
+                        notificationId = it.notificationId;
+                        notification = it.notification;
+                        if (it.ongoing) {
+                            if (player?.playWhenReady == true) {
+                                if (sWakeLock?.isHeld != true) {
+                                    sWakeLock?.acquire()
+                                }
+                                startForegroundIfNecessary()
+                            }
+                        } else if (shouldStopForeground()) {
+                            // Allow the application a grace period to complete any actions
+                            // that may necessitate keeping the service in a foreground state.
+                            // For instance, queuing new media (e.g., related music) after the
+                            // user's queue is complete. This prevents the service from potentially
+                            // being immediately destroyed once the player finishes playing media.
+                            scope.launch {
+                                if (sWakeLock?.isHeld == true) {
+                                    sWakeLock?.release()
+                                }
+                                // delay(stopForegroundGracePeriod.toLong() * 1000)
+                                // if (shouldStopForeground()) {
+                                // @Suppress("DEPRECATION")
+                                // stopForeground(removeNotificationWhenNotOngoing)
+                                // }
+                            }
+                        }
+                    }
+
+                    else -> {}
+                }
+            }
+        }
+    }
+
+    companion object {
+        const val EMPTY_NOTIFICATION_ID = 1
+        const val STATE_KEY = "state"
+        const val ERROR_KEY  = "error"
+        const val EVENT_KEY = "event"
+        const val DATA_KEY = "data"
+        const val TRACK_KEY = "track"
+        const val NEXT_TRACK_KEY = "nextTrack"
+        const val POSITION_KEY = "position"
+        const val DURATION_KEY = "duration"
+        const val BUFFERED_POSITION_KEY = "buffered"
+
+        const val TASK_KEY = "TrackPlayer"
+
+        const val MIN_BUFFER_KEY = "minBuffer"
+        const val MAX_BUFFER_KEY = "maxBuffer"
+        const val PLAY_BUFFER_KEY = "playBuffer"
+        const val BACK_BUFFER_KEY = "backBuffer"
+
+        const val FORWARD_JUMP_INTERVAL_KEY = "forwardJumpInterval"
+        const val BACKWARD_JUMP_INTERVAL_KEY = "backwardJumpInterval"
+        const val PROGRESS_UPDATE_EVENT_INTERVAL_KEY = "progressUpdateEventInterval"
+
+        const val MAX_CACHE_SIZE_KEY = "maxCacheSize"
+
+        const val ANDROID_OPTIONS_KEY = "android"
+
+        const val STOPPING_APP_PAUSES_PLAYBACK_KEY = "stoppingAppPausesPlayback"
+        const val APP_KILLED_PLAYBACK_BEHAVIOR_KEY = "appKilledPlaybackBehavior"
+        const val STOP_FOREGROUND_GRACE_PERIOD_KEY = "stopForegroundGracePeriod"
+        const val PAUSE_ON_INTERRUPTION_KEY = "alwaysPauseOnInterruption"
+        const val AUTO_UPDATE_METADATA = "autoUpdateMetadata"
+        const val AUTO_HANDLE_INTERRUPTIONS = "autoHandleInterruptions"
+        const val ANDROID_AUDIO_CONTENT_TYPE = "androidAudioContentType"
+        const val IS_FOCUS_LOSS_PERMANENT_KEY = "permanent"
+        const val IS_PAUSED_KEY = "paused"
+
+        const val DEFAULT_JUMP_INTERVAL = 15.0
+        const val DEFAULT_STOP_FOREGROUND_GRACE_PERIOD = 5
+
+        const val CUSTOM_ACTIONS_KEY = "customActions"
+    }
+}