react-native-nitro-player 0.7.1-alpha.2 → 0.7.1-alpha.3

package/android/src/main/AndroidManifest.xml

@@ -6,6 +6,7 @@
     <uses-permission android:name="android.permission.FOREGROUND_SERVICE_DATA_SYNC" />
     <uses-permission android:name="android.permission.FOREGROUND_SERVICE_MEDIA_PLAYBACK" />
     <uses-permission android:name="android.permission.WAKE_LOCK" />
+    <uses-permission android:name="android.permission.POST_NOTIFICATIONS" />
 
     <application>
         <!-- PlaybackService keeps music alive when screen is locked / app backgrounded -->

package/android/src/main/java/com/margelo/nitro/nitroplayer/core/ExoPlayerCore.kt

@@ -1,59 +1,19 @@
 package com.margelo.nitro.nitroplayer.core
 
-import android.content.Context
-import android.os.HandlerThread
-import androidx.media3.common.AudioAttributes
-import androidx.media3.common.C
 import androidx.media3.common.MediaItem
 import androidx.media3.common.Player
-import androidx.media3.exoplayer.DefaultLoadControl
 import androidx.media3.exoplayer.ExoPlayer
 
+/**
+ * Thin wrapper around an [ExoPlayer] instance owned by the playback service.
+ * All delegation methods are unchanged — only the constructor now accepts an
+ * existing player instead of building one.
+ */
 class ExoPlayerCore(
-    context: Context,
-    playerThread: HandlerThread,
+    exoPlayer: ExoPlayer,
 ) {
-    /** The underlying ExoPlayer instance — accessible for MediaSessionManager wiring. */
-    internal val player: ExoPlayer = build(context, playerThread)
-
-    private fun build(
-        context: Context,
-        playerThread: HandlerThread,
-    ): ExoPlayer {
-        val loadControl =
-            DefaultLoadControl
-                .Builder()
-                .setBufferDurationsMs(
-                    // minBufferMs
-                    30_000,
-                    // maxBufferMs
-                    120_000,
-                    // bufferForPlayback
-                    2_500,
-                    // bufferForRebuffer
-                    5_000,
-                ).setBackBuffer(30_000, /* retainBackBufferFromKeyframe */ true)
-                .setTargetBufferBytes(C.LENGTH_UNSET)
-                .setPrioritizeTimeOverSizeThresholds(true)
-                .build()
-
-        val audioAttrs =
-            AudioAttributes
-                .Builder()
-                .setUsage(C.USAGE_MEDIA)
-                .setContentType(C.AUDIO_CONTENT_TYPE_MUSIC)
-                .build()
-
-        return ExoPlayer
-            .Builder(context)
-            .setLooper(playerThread.looper)
-            .setLoadControl(loadControl)
-            .setAudioAttributes(audioAttrs, /* handleAudioFocus */ true)
-            .setHandleAudioBecomingNoisy(true)
-            .setWakeMode(C.WAKE_MODE_NETWORK)
-            .setPauseAtEndOfMediaItems(false)
-            .build()
-    }
+    /** The underlying ExoPlayer instance — accessible for wiring. */
+    internal val player: ExoPlayer = exoPlayer
 
     // ── Playback ───────────────────────────────────────────────────────────
     fun play() = player.play()

package/android/src/main/java/com/margelo/nitro/nitroplayer/core/TrackPlayerCore.kt

@@ -2,9 +2,12 @@
 
 package com.margelo.nitro.nitroplayer.core
 
+import android.content.ComponentName
 import android.content.Context
+import android.content.Intent
+import android.content.ServiceConnection
 import android.os.Handler
-import android.os.HandlerThread
+import android.os.IBinder
 import android.os.Looper
 import com.margelo.nitro.nitroplayer.Reason
 import com.margelo.nitro.nitroplayer.RepeatMode
@@ -14,7 +17,9 @@ import com.margelo.nitro.nitroplayer.connection.AndroidAutoConnectionDetector
 import com.margelo.nitro.nitroplayer.download.DownloadManagerCore
 import com.margelo.nitro.nitroplayer.media.MediaLibraryManager
 import com.margelo.nitro.nitroplayer.media.MediaSessionManager
+import com.margelo.nitro.nitroplayer.media.NitroPlayerPlaybackService
 import com.margelo.nitro.nitroplayer.playlist.PlaylistManager
+import kotlinx.coroutines.CompletableDeferred
 import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.SupervisorJob
 import kotlinx.coroutines.cancel
@@ -26,13 +31,18 @@ class TrackPlayerCore private constructor(
     internal val context: Context,
 ) {
     // ── Thread infrastructure ──────────────────────────────────────────────
-    /** Main-looper handler — only for Android Auto connection callbacks */
+    /** Main-looper handler — used for player operations and Android Auto callbacks. */
     internal val handler = Handler(Looper.getMainLooper())
-    internal val playerThread = HandlerThread("NitroPlayer").apply { start() }
-    internal val playerHandler = Handler(playerThread.looper)
+
+    /** Populated from the service binder. Player runs on main looper. */
+    internal lateinit var playerHandler: Handler
+
     internal val scope = CoroutineScope(SupervisorJob())
 
-    // ── ExoPlayer wrapper (created on player thread inside initExoAndMedia) ──
+    /** Gates all player operations until the service is bound and init is complete. */
+    private val serviceReady = CompletableDeferred<Unit>()
+
+    // ── ExoPlayer wrapper (created on player thread inside initFromService) ──
     internal lateinit var exo: ExoPlayerCore
 
     /** Safe initialized check — backing field can only be read from the declaring class. */
@@ -112,6 +122,32 @@ class TrackPlayerCore private constructor(
             }
         }
 
+    // ── Service binding ────────────────────────────────────────────────────
+    private var serviceBound = false
+
+    private val serviceConnection =
+        object : ServiceConnection {
+            override fun onServiceConnected(
+                name: ComponentName?,
+                service: IBinder?,
+            ) {
+                val binder = service as NitroPlayerPlaybackService.LocalBinder
+                playerHandler = binder.handler
+                binder.service.trackPlayerCore = this@TrackPlayerCore
+                serviceBound = true
+
+                // Initialize on main thread (player now runs on main looper)
+                playerHandler.post {
+                    initFromService(binder)
+                    setupAndroidAutoDetector()
+                }
+            }
+
+            override fun onServiceDisconnected(name: ComponentName?) {
+                serviceBound = false
+            }
+        }
+
     // ── Singleton ──────────────────────────────────────────────────────────
     companion object {
         @Volatile
@@ -125,16 +161,26 @@ class TrackPlayerCore private constructor(
     }
 
     init {
-        // ExoPlayer must be created on its own thread
-        playerHandler.post { initExoAndMedia() }
-        // Android Auto receiver must be registered on the main thread
-        handler.post { setupAndroidAutoDetector() }
+        // Defer service start/bind to the main thread so it doesn't run
+        // synchronously on the JNI thread during HybridObject creation.
+        handler.post {
+            val intent = Intent(context, NitroPlayerPlaybackService::class.java)
+            context.startService(intent)
+
+            val bindIntent =
+                Intent(context, NitroPlayerPlaybackService::class.java).apply {
+                    action = NitroPlayerPlaybackService.ACTION_LOCAL_BIND
+                }
+            context.bindService(bindIntent, serviceConnection, Context.BIND_AUTO_CREATE)
+        }
     }
 
-    // ── Coroutine bridge to player thread ──────────────────────────────────
+    // ── Coroutine bridge to player looper (main thread) ────────────────────
 
     internal suspend fun <T> withPlayerContext(block: () -> T): T {
-        if (Looper.myLooper() == playerThread.looper) return block()
+        // Wait until the service is bound and player is initialized
+        serviceReady.await()
+        if (Looper.myLooper() == playerHandler.looper) return block()
         return suspendCancellableCoroutine { cont ->
             val r =
                 Runnable {
@@ -149,19 +195,33 @@ class TrackPlayerCore private constructor(
         }
     }
 
+    /** Called from initFromService once everything is wired up. */
+    internal fun completeServiceReady() {
+        serviceReady.complete(Unit)
+    }
+
     // ── Lifecycle ──────────────────────────────────────────────────────────
 
     fun destroy() {
-        playerHandler.post {
-            androidAutoConnectionDetector?.unregisterCarConnectionReceiver()
-            playerHandler.removeCallbacks(progressUpdateRunnable)
-            if (::exo.isInitialized) {
-                playerListener?.let { exo.removeListener(it) }
+        if (::playerHandler.isInitialized) {
+            playerHandler.post {
+                androidAutoConnectionDetector?.unregisterCarConnectionReceiver()
+                playerHandler.removeCallbacks(progressUpdateRunnable)
+                if (::exo.isInitialized) {
+                    playerListener?.let { exo.removeListener(it) }
+                }
+                playerListener = null
             }
-            playerListener = null
         }
         scope.cancel()
-        playerThread.quitSafely()
+        // Do NOT stop the service — it owns the player.
+        // Unbind so Android can clean up if needed.
+        if (serviceBound) {
+            try {
+                context.unbindService(serviceConnection)
+            } catch (_: Exception) {}
+            serviceBound = false
+        }
     }
 
     // ── Simple read-only accessors ─────────────────────────────────────────

package/android/src/main/java/com/margelo/nitro/nitroplayer/core/TrackPlayerListener.kt

@@ -12,7 +12,7 @@ import com.margelo.nitro.nitroplayer.media.NitroPlayerMediaBrowserService
 /**
  * ExoPlayer event listener — translates low-level ExoPlayer callbacks into
  * TrackPlayerCore state mutations and JS-facing listener notifications.
- * All callbacks fire on the player thread (ExoPlayerCore is built with playerThread.looper).
+ * All callbacks fire on the main looper (ExoPlayer uses the default application looper).
  */
 internal class TrackPlayerEventListener(
     private val core: TrackPlayerCore,

package/android/src/main/java/com/margelo/nitro/nitroplayer/core/TrackPlayerQueueBuild.kt

@@ -45,12 +45,26 @@ internal fun TrackPlayerCore.rebuildQueueFromCurrentPosition() {
 
     // If current track was removed from the playlist, jump to best substitute
     val currentTrackId = exo.currentMediaItem?.mediaId?.let { extractTrackId(it) }
-    if (currentTrackId != null && currentTracks.none { it.id == currentTrackId }) {
+
+    if (
+        currentTrackId != null && 
+        currentTracks.none { it.id == currentTrackId } &&
+        currentTemporaryType == TrackPlayerCore.TemporaryType.NONE
+    ) {
         if (currentTracks.isEmpty()) return
         playFromIndexInternal(minOf(currentTrackIndex, currentTracks.size - 1))
         return
     }
 
+    // Keep the logical playlist pointer in sync after playlist mutations.
+    // Without this, getActualQueue/getState can report a stale index until the next track transition.
+    if (currentTemporaryType == TrackPlayerCore.TemporaryType.NONE && currentTrackId != null) {
+        val resolvedIndex = currentTracks.indexOfFirst { it.id == currentTrackId }
+        if (resolvedIndex >= 0) {
+            currentTrackIndex = resolvedIndex
+        }
+    }
+
     val newQueueTracks = ArrayList<TrackItem>(playNextStack.size + upNextQueue.size + currentTracks.size)
     val currentId = exo.currentMediaItem?.mediaId?.let { extractTrackId(it) }
 

package/android/src/main/java/com/margelo/nitro/nitroplayer/core/TrackPlayerSetup.kt

@@ -1,18 +1,22 @@
 package com.margelo.nitro.nitroplayer.core
 
+import com.margelo.nitro.nitroplayer.equalizer.EqualizerCore
 import com.margelo.nitro.nitroplayer.media.MediaSessionManager
 import com.margelo.nitro.nitroplayer.media.NitroPlayerMediaBrowserService
+import com.margelo.nitro.nitroplayer.media.NitroPlayerPlaybackService
 
 /**
- * Initialises ExoPlayer (via ExoPlayerCore) and MediaSessionManager on the player thread.
- * Called once from TrackPlayerCore.init via playerHandler.post.
+ * Initialises ExoPlayerCore wrapper and MediaSessionManager from the service binder.
+ * Called once from TrackPlayerCore's ServiceConnection.onServiceConnected via playerHandler.post.
  */
-internal fun TrackPlayerCore.initExoAndMedia() {
-    exo = ExoPlayerCore(context, playerThread)
+internal fun TrackPlayerCore.initFromService(binder: NitroPlayerPlaybackService.LocalBinder) {
+    // Wrap the service-owned ExoPlayer
+    exo = ExoPlayerCore(binder.exoPlayer)
 
+    // Wrap the service-owned MediaSession (no longer creates its own)
     mediaSessionManager =
-        MediaSessionManager(context, exo.player, playlistManager).apply {
-            setTrackPlayerCore(this@initExoAndMedia)
+        MediaSessionManager(context, binder.session, playlistManager).apply {
+            setTrackPlayerCore(this@initFromService)
         }
 
     // Give MediaBrowserService access to this core and media session
@@ -24,6 +28,20 @@ internal fun TrackPlayerCore.initExoAndMedia() {
     playerListener = listener
     exo.addListener(listener)
 
-    // Start progress ticks on the player thread
+    // The audio session ID is assigned during ExoPlayer construction (in
+    // PlaybackService.onCreate), before our listener is attached.
+    // onAudioSessionIdChanged only fires on *changes*, so we'd miss the
+    // initial value. Manually feed it to the equalizer now.
+    val sessionId = binder.exoPlayer.audioSessionId
+    if (sessionId != 0) {
+        try {
+            EqualizerCore.getInstance(context).initialize(sessionId)
+        } catch (_: Exception) { }
+    }
+
+    // Start progress ticks on the main looper
     playerHandler.postDelayed(progressUpdateRunnable, 250)
+
+    // Signal that the player is ready — unblocks all withPlayerContext callers
+    completeServiceReady()
 }

package/android/src/main/java/com/margelo/nitro/nitroplayer/download/DownloadManagerCore.kt

@@ -111,6 +111,7 @@ class DownloadManagerCore private constructor(
             workDataOf(
                 DownloadWorker.KEY_DOWNLOAD_ID to downloadId,
                 DownloadWorker.KEY_TRACK_ID to track.id,
+                DownloadWorker.KEY_TRACK_TITLE to track.title,
                 DownloadWorker.KEY_URL to track.url,
                 DownloadWorker.KEY_PLAYLIST_ID to (playlistId ?: ""),
                 DownloadWorker.KEY_STORAGE_LOCATION to (config.storageLocation?.name ?: StorageLocation.PRIVATE.name),
@@ -169,6 +170,7 @@ class DownloadManagerCore private constructor(
                 workDataOf(
                     DownloadWorker.KEY_DOWNLOAD_ID to downloadId,
                     DownloadWorker.KEY_TRACK_ID to track.id,
+                    DownloadWorker.KEY_TRACK_TITLE to track.title,
                     DownloadWorker.KEY_URL to track.url,
                     DownloadWorker.KEY_PLAYLIST_ID to (playlistId ?: ""),
                     DownloadWorker.KEY_STORAGE_LOCATION to (config.storageLocation?.name ?: StorageLocation.PRIVATE.name),

package/android/src/main/java/com/margelo/nitro/nitroplayer/download/DownloadWorker.kt

@@ -13,7 +13,6 @@ import com.margelo.nitro.nitroplayer.*
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.withContext
 import java.io.BufferedInputStream
-import java.io.File
 import java.io.FileOutputStream
 import java.net.HttpURLConnection
 import java.net.URL
@@ -28,26 +27,34 @@ class DownloadWorker(
     companion object {
         const val KEY_DOWNLOAD_ID = "download_id"
         const val KEY_TRACK_ID = "track_id"
+        const val KEY_TRACK_TITLE = "track_title"
         const val KEY_URL = "url"
         const val KEY_PLAYLIST_ID = "playlist_id"
         const val KEY_STORAGE_LOCATION = "storage_location"
 
         private const val NOTIFICATION_CHANNEL_ID = "nitro_player_downloads"
-        private const val NOTIFICATION_ID = 2001
+        private const val BASE_NOTIFICATION_ID = 2001
         private const val BUFFER_SIZE = 8192
         private val CONTENT_DISPOSITION_REGEX = Regex("filename=\"?([^\";]+)\"?")
     }
 
     private val downloadManager = DownloadManagerCore.getInstance(context)
     private val fileManager = DownloadFileManager.getInstance(context)
+    private val notificationManager =
+        context.getSystemService(Context.NOTIFICATION_SERVICE) as NotificationManager
+    /** Stable notification ID per download — derived from trackId hash. */
+    private var notificationId = BASE_NOTIFICATION_ID
 
     override suspend fun doWork(): Result =
         withContext(Dispatchers.IO) {
             val downloadId = inputData.getString(KEY_DOWNLOAD_ID) ?: return@withContext Result.failure()
             val trackId = inputData.getString(KEY_TRACK_ID) ?: return@withContext Result.failure()
+            val trackTitle = inputData.getString(KEY_TRACK_TITLE) ?: "Unknown track"
             val urlString = inputData.getString(KEY_URL) ?: return@withContext Result.failure()
             val storageLocationStr = inputData.getString(KEY_STORAGE_LOCATION) ?: StorageLocation.PRIVATE.name
 
+            notificationId = BASE_NOTIFICATION_ID + trackId.hashCode().and(0xFFFF)
+
             val storageLocation =
                 try {
                     StorageLocation.valueOf(storageLocationStr)
@@ -56,14 +63,21 @@ class DownloadWorker(
                 }
 
             try {
-                // Set foreground notification
-                setForeground(createForegroundInfo(trackId))
+                // Set foreground notification — if POST_NOTIFICATIONS is denied,
+                // WorkManager still runs the task; the notification just won't show.
+                try {
+                    setForeground(createForegroundInfo(trackTitle, 0, true))
+                } catch (_: Exception) {
+                    // Foreground promotion failed (e.g. missing permission on some OEMs).
+                    // Download continues in background.
+                }
 
                 // Perform download
-                val localPath = downloadFile(downloadId, trackId, urlString, storageLocation)
+                val localPath = downloadFile(downloadId, trackId, trackTitle, urlString, storageLocation)
 
                 if (localPath != null) {
                     downloadManager.onComplete(downloadId, trackId, localPath)
+                    showCompletionNotification(trackTitle)
                     Result.success()
                 } else {
                     val error =
@@ -74,6 +88,7 @@ class DownloadWorker(
                             isRetryable = true,
                         )
                     downloadManager.onError(downloadId, trackId, error)
+                    showErrorNotification(trackTitle)
                     Result.retry()
                 }
             } catch (e: Exception) {
@@ -93,6 +108,7 @@ class DownloadWorker(
                         isRetryable = errorReason in listOf(DownloadErrorReason.NETWORK_ERROR, DownloadErrorReason.TIMEOUT),
                     )
                 downloadManager.onError(downloadId, trackId, error)
+                showErrorNotification(trackTitle)
 
                 if (error.isRetryable) {
                     Result.retry()
@@ -105,6 +121,7 @@ class DownloadWorker(
     private suspend fun downloadFile(
         downloadId: String,
         trackId: String,
+        trackTitle: String,
         urlString: String,
         storageLocation: StorageLocation,
     ): String? =
@@ -167,10 +184,12 @@ class DownloadWorker(
                     outputStream.write(buffer, 0, bytesRead)
                     bytesDownloaded += bytesRead
 
-                    // Update progress every 250ms
+                    // Update progress every 250ms — both the callback and the notification
                     val now = System.currentTimeMillis()
                     if (now - lastProgressUpdate >= 250) {
                         downloadManager.onProgress(downloadId, trackId, bytesDownloaded, totalBytes)
+                        val percent = if (totalBytes > 0) ((bytesDownloaded * 100) / totalBytes).toInt() else 0
+                        updateProgressNotification(trackTitle, percent)
                         lastProgressUpdate = now
                     }
                 }
@@ -194,31 +213,85 @@ class DownloadWorker(
             }
         }
 
-    private fun createForegroundInfo(trackId: String): ForegroundInfo {
-        createNotificationChannel()
+    // ── Notification helpers ──────────────────────────────────────────────
+
+    private fun createForegroundInfo(
+        trackTitle: String,
+        percent: Int,
+        indeterminate: Boolean,
+    ): ForegroundInfo {
+        ensureNotificationChannel()
 
-        val notification =
-            NotificationCompat
-                .Builder(context, NOTIFICATION_CHANNEL_ID)
-                .setContentTitle("Downloading")
-                .setContentText("Downloading track...")
-                .setSmallIcon(android.R.drawable.stat_sys_download)
-                .setOngoing(true)
-                .setProgress(100, 0, true)
-                .build()
+        val notification = buildProgressNotification(trackTitle, percent, indeterminate)
 
         return if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.UPSIDE_DOWN_CAKE) {
             ForegroundInfo(
-                NOTIFICATION_ID,
+                notificationId,
                 notification,
                 android.content.pm.ServiceInfo.FOREGROUND_SERVICE_TYPE_DATA_SYNC,
             )
         } else {
-            ForegroundInfo(NOTIFICATION_ID, notification)
+            ForegroundInfo(notificationId, notification)
+        }
+    }
+
+    private fun buildProgressNotification(
+        trackTitle: String,
+        percent: Int,
+        indeterminate: Boolean,
+    ) = NotificationCompat
+        .Builder(context, NOTIFICATION_CHANNEL_ID)
+        .setContentTitle("Downloading")
+        .setContentText(trackTitle)
+        .setSubText(if (!indeterminate) "$percent%" else null)
+        .setSmallIcon(android.R.drawable.stat_sys_download)
+        .setOngoing(true)
+        .setOnlyAlertOnce(true)
+        .setProgress(100, percent, indeterminate)
+        .build()
+
+    private fun updateProgressNotification(trackTitle: String, percent: Int) {
+        try {
+            notificationManager.notify(
+                notificationId,
+                buildProgressNotification(trackTitle, percent, false),
+            )
+        } catch (_: SecurityException) {
+            // POST_NOTIFICATIONS not granted — download continues silently
         }
     }
 
-    private fun createNotificationChannel() {
+    private fun showCompletionNotification(trackTitle: String) {
+        try {
+            notificationManager.notify(
+                notificationId,
+                NotificationCompat
+                    .Builder(context, NOTIFICATION_CHANNEL_ID)
+                    .setContentTitle("Download complete")
+                    .setContentText(trackTitle)
+                    .setSmallIcon(android.R.drawable.stat_sys_download_done)
+                    .setAutoCancel(true)
+                    .build(),
+            )
+        } catch (_: SecurityException) { }
+    }
+
+    private fun showErrorNotification(trackTitle: String) {
+        try {
+            notificationManager.notify(
+                notificationId,
+                NotificationCompat
+                    .Builder(context, NOTIFICATION_CHANNEL_ID)
+                    .setContentTitle("Download failed")
+                    .setContentText(trackTitle)
+                    .setSmallIcon(android.R.drawable.stat_notify_error)
+                    .setAutoCancel(true)
+                    .build(),
+            )
+        } catch (_: SecurityException) { }
+    }
+
+    private fun ensureNotificationChannel() {
         if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
             val channel =
                 NotificationChannel(
@@ -228,9 +301,7 @@ class DownloadWorker(
                 ).apply {
                     description = "Download progress notifications"
                 }
-
-            val notificationManager = context.getSystemService(NotificationManager::class.java)
-            notificationManager?.createNotificationChannel(channel)
+            notificationManager.createNotificationChannel(channel)
         }
     }
 }

package/android/src/main/java/com/margelo/nitro/nitroplayer/media/ExoPlayerBuilder.kt

@@ -0,0 +1,49 @@
+package com.margelo.nitro.nitroplayer.media
+
+import android.content.Context
+import androidx.media3.common.AudioAttributes
+import androidx.media3.common.C
+import androidx.media3.exoplayer.DefaultLoadControl
+import androidx.media3.exoplayer.ExoPlayer
+
+/**
+ * Builds an [ExoPlayer] with the standard NitroPlayer configuration.
+ * The player uses the main application looper so that Media3's
+ * [MediaSessionService] notification system works without thread conflicts.
+ */
+object ExoPlayerBuilder {
+    fun build(context: Context): ExoPlayer {
+        val loadControl =
+            DefaultLoadControl
+                .Builder()
+                .setBufferDurationsMs(
+                    // minBufferMs
+                    30_000,
+                    // maxBufferMs
+                    120_000,
+                    // bufferForPlayback
+                    2_500,
+                    // bufferForRebuffer
+                    5_000,
+                ).setBackBuffer(30_000, /* retainBackBufferFromKeyframe */ true)
+                .setTargetBufferBytes(C.LENGTH_UNSET)
+                .setPrioritizeTimeOverSizeThresholds(true)
+                .build()
+
+        val audioAttrs =
+            AudioAttributes
+                .Builder()
+                .setUsage(C.USAGE_MEDIA)
+                .setContentType(C.AUDIO_CONTENT_TYPE_MUSIC)
+                .build()
+
+        return ExoPlayer
+            .Builder(context)
+            .setLoadControl(loadControl)
+            .setAudioAttributes(audioAttrs, /* handleAudioFocus */ true)
+            .setHandleAudioBecomingNoisy(true)
+            .setWakeMode(C.WAKE_MODE_NETWORK)
+            .setPauseAtEndOfMediaItems(false)
+            .build()
+    }
+}