react-native-nitro-player 0.3.0-alpha.14 → 0.3.0-alpha.15

package/README.md

@@ -20,6 +20,7 @@ npm install react-native-nitro-modules
 
 ## API Reference
 
+
 ### React Hooks
 
 | Name                          | Platform | Description                                                                     |
@@ -31,6 +32,7 @@ npm install react-native-nitro-modules
 | `useNowPlaying`               | Both     | Returns complete player state (track, state, duration, playlist) in one object. |
 | `useActualQueue`              | Both     | Returns the efficient playback queue including temporary tracks.                |
 | `usePlaylist`                 | Both     | Manages playlist state, providing access to all playlists and tracks.           |
+| `useEqualizer`                | Both     | Controls the 5-band equalizer, including presets and individual band gains.     |
 | `useAndroidAutoConnection`    | Both     | Monitors Android Auto connection status.                                        |
 | `useAudioDevices`             | Android  | Returns list of available audio output devices.                                 |
 | `useDownloadProgress`         | Both     | Tracks download progress for tracks. Returns progress map and overall status.   |
@@ -584,6 +586,73 @@ if (AudioRoutePicker) {
 }
 ```
 
+
+## Equalizer
+
+The player includes a powerful 5-band equalizer that works on both iOS and Android.
+
+### `useEqualizer()`
+
+Returns the current equalizer state and control methods.
+
+**Returns:**
+
+- `isEnabled: boolean` - Whether the equalizer is currently active
+- `bands: EqualizerBand[]` - Current gain settings for all 5 bands
+- `currentPreset: string | null` - Name of the currently applied preset
+- `setEnabled(enabled: boolean): boolean` - Toggle the equalizer on/off
+- `setBandGain(index: number, gainDb: number): boolean` - Set gain for a specific band (range: -12dB to +12dB)
+- `setAllBandGains(gains: number[]): boolean` - Set all band gains at once
+- `reset(): void` - Reset to flat response
+
+**Bands:**
+
+The equalizer features 5 bands at the following center frequencies:
+1. **60 Hz** - Sub-bass/Bass
+2. **230 Hz** - Bass/Low-mids
+3. **910 Hz** - Mids
+4. **3.6 kHz** - Upper-mids/Treble
+5. **14 kHz** - High treble/Air
+
+**Example:**
+
+```typescript
+import { useEqualizer } from 'react-native-nitro-player'
+
+function EqualizerControl() {
+  const { 
+    isEnabled, 
+    setEnabled, 
+    bands, 
+    setBandGain, 
+    reset 
+  } = useEqualizer()
+
+  return (
+    <View>
+      <Switch 
+        value={isEnabled} 
+        onValueChange={setEnabled} 
+      />
+      
+      {bands.map((band) => (
+        <View key={band.index}>
+          <Text>{band.frequencyLabel}</Text>
+          <Slider
+            minimumValue={-12}
+            maximumValue={12}
+            value={band.gainDb}
+            onSlidingComplete={(value) => setBandGain(band.index, value)}
+          />
+        </View>
+      ))}
+      
+      <Button title="Reset" onPress={reset} />
+    </View>
+  )
+}
+```
+
 ## Repeat Mode
 
 Control how tracks repeat during playback.

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

@@ -0,0 +1,105 @@
+package com.margelo.nitro.nitroplayer
+
+import androidx.annotation.Keep
+import com.facebook.proguard.annotations.DoNotStrip
+import com.margelo.nitro.NitroModules
+import com.margelo.nitro.core.NullType
+import com.margelo.nitro.nitroplayer.equalizer.EqualizerCore
+
+@DoNotStrip
+@Keep
+class HybridEqualizer : HybridEqualizerSpec() {
+    private val core: EqualizerCore
+
+    init {
+        val context =
+            NitroModules.applicationContext ?: throw IllegalStateException("React Context is not initialized")
+
+        // Get the equalizer core - it will initialize lazily with audio session 0
+        // and be re-initialized with the proper session when onAudioSessionIdChanged fires
+        core = EqualizerCore.getInstance(context)
+        core.ensureInitialized()
+    }
+
+    @DoNotStrip
+    @Keep
+    override fun setEnabled(enabled: Boolean): Boolean = core.setEnabled(enabled)
+
+    @DoNotStrip
+    @Keep
+    override fun isEnabled(): Boolean = core.isEnabled()
+
+    @DoNotStrip
+    @Keep
+    override fun getBands(): Array<EqualizerBand> = core.getBands()
+
+    @DoNotStrip
+    @Keep
+    override fun setBandGain(
+        bandIndex: Double,
+        gainDb: Double,
+    ): Boolean = core.setBandGain(bandIndex.toInt(), gainDb)
+
+    @DoNotStrip
+    @Keep
+    override fun setAllBandGains(gains: DoubleArray): Boolean = core.setAllBandGains(gains)
+
+    @DoNotStrip
+    @Keep
+    override fun getBandRange(): GainRange = core.getBandRange()
+
+    @DoNotStrip
+    @Keep
+    override fun getPresets(): Array<EqualizerPreset> = core.getPresets()
+
+    @DoNotStrip
+    @Keep
+    override fun getBuiltInPresets(): Array<EqualizerPreset> = core.getBuiltInPresets()
+
+    @DoNotStrip
+    @Keep
+    override fun getCustomPresets(): Array<EqualizerPreset> = core.getCustomPresets()
+
+    @DoNotStrip
+    @Keep
+    override fun applyPreset(presetName: String): Boolean = core.applyPreset(presetName)
+
+    @DoNotStrip
+    @Keep
+    override fun getCurrentPresetName(): Variant_NullType_String {
+        val name = core.getCurrentPresetName()
+        return if (name != null) {
+            Variant_NullType_String.create(name)
+        } else {
+            Variant_NullType_String.create(NullType.NULL)
+        }
+    }
+
+    @DoNotStrip
+    @Keep
+    override fun saveCustomPreset(name: String): Boolean = core.saveCustomPreset(name)
+
+    @DoNotStrip
+    @Keep
+    override fun deleteCustomPreset(name: String): Boolean = core.deleteCustomPreset(name)
+
+    @DoNotStrip
+    @Keep
+    override fun getState(): EqualizerState = core.getState()
+
+    @DoNotStrip
+    @Keep
+    override fun reset() = core.reset()
+
+    override fun onEnabledChange(callback: (enabled: Boolean) -> Unit) {
+        core.addOnEnabledChangeListener(callback)
+    }
+
+    override fun onBandChange(callback: (bands: Array<EqualizerBand>) -> Unit) {
+        core.addOnBandChangeListener(callback)
+    }
+
+    override fun onPresetChange(callback: (presetName: Variant_NullType_String?) -> Unit) {
+        core.addOnPresetChangeListener(callback)
+    }
+}

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

@@ -23,6 +23,7 @@ import com.margelo.nitro.nitroplayer.Variant_NullType_String
 import com.margelo.nitro.nitroplayer.Variant_NullType_TrackItem
 import com.margelo.nitro.nitroplayer.connection.AndroidAutoConnectionDetector
 import com.margelo.nitro.nitroplayer.download.DownloadManagerCore
+import com.margelo.nitro.nitroplayer.equalizer.EqualizerCore
 import com.margelo.nitro.nitroplayer.media.MediaLibrary
 import com.margelo.nitro.nitroplayer.media.MediaLibraryManager
 import com.margelo.nitro.nitroplayer.media.MediaLibraryParser
@@ -49,6 +50,7 @@ class TrackPlayerCore private constructor(
     private var androidAutoConnectionDetector: AndroidAutoConnectionDetector? = null
     var onAndroidAutoConnectionChange: ((Boolean) -> Unit)? = null
     private var previousMediaItem: MediaItem? = null
+
     private val progressUpdateRunnable =
         object : Runnable {
             override fun run() {
@@ -106,219 +108,238 @@ class TrackPlayerCore private constructor(
     }
 
     init {
-        handler.post {
-            // ============================================================
-            // GAPLESS PLAYBACK CONFIGURATION
-            // ============================================================
-            // Configure LoadControl for maximum gapless playback
-            // Large buffers ensure next track is fully ready before current ends
-            val loadControl =
-                DefaultLoadControl
-                    .Builder()
-                    .setBufferDurationsMs(
-                        30_000, // MIN_BUFFER_MS: 30 seconds minimum buffer
-                        120_000, // MAX_BUFFER_MS: 2 minutes maximum buffer (enables preloading next tracks)
-                        2_500, // BUFFER_FOR_PLAYBACK_MS: 2.5s before playback starts
-                        5_000, // BUFFER_FOR_PLAYBACK_AFTER_REBUFFER_MS: 5s after rebuffer
-                    ).setBackBuffer(30_000, true) // Keep 30s back buffer for seamless seek-back
-                    .setTargetBufferBytes(C.LENGTH_UNSET) // No size limit - prioritize time
-                    .setPrioritizeTimeOverSizeThresholds(true) // Prioritize time-based buffering
-                    .build()
-
-            // Configure audio attributes for optimal music playback
-            // This enables gapless audio processing in the audio pipeline
-            val audioAttributes =
-                AudioAttributes
-                    .Builder()
-                    .setUsage(C.USAGE_MEDIA)
-                    .setContentType(C.AUDIO_CONTENT_TYPE_MUSIC)
-                    .build()
-
-            player =
-                ExoPlayer
-                    .Builder(context)
-                    .setLoadControl(loadControl)
-                    .setAudioAttributes(audioAttributes, true) // handleAudioFocus = true for gapless
-                    .setHandleAudioBecomingNoisy(true) // Pause when headphones disconnected
-                    .setPauseAtEndOfMediaItems(false) // Don't pause between items - key for gapless!
-                    .build()
-
-            println("🎵 TrackPlayerCore: Gapless playback configured - 120s buffer, audio focus handling enabled")
-            mediaSessionManager =
-                MediaSessionManager(context, player, playlistManager).apply {
-                    setTrackPlayerCore(this@TrackPlayerCore)
-                }
+        // Run synchronously on main thread to avoid deadlock
+        // when awaitInitialization is called from main thread
+        val initRunnable =
+            Runnable {
+                // ============================================================
+                // GAPLESS PLAYBACK CONFIGURATION
+                // ============================================================
+                // Configure LoadControl for maximum gapless playback
+                // Large buffers ensure next track is fully ready before current ends
+                val loadControl =
+                    DefaultLoadControl
+                        .Builder()
+                        .setBufferDurationsMs(
+                            30_000, // MIN_BUFFER_MS: 30 seconds minimum buffer
+                            120_000, // MAX_BUFFER_MS: 2 minutes maximum buffer (enables preloading next tracks)
+                            2_500, // BUFFER_FOR_PLAYBACK_MS: 2.5s before playback starts
+                            5_000, // BUFFER_FOR_PLAYBACK_AFTER_REBUFFER_MS: 5s after rebuffer
+                        ).setBackBuffer(30_000, true) // Keep 30s back buffer for seamless seek-back
+                        .setTargetBufferBytes(C.LENGTH_UNSET) // No size limit - prioritize time
+                        .setPrioritizeTimeOverSizeThresholds(true) // Prioritize time-based buffering
+                        .build()
+
+                // Configure audio attributes for optimal music playback
+                // This enables gapless audio processing in the audio pipeline
+                val audioAttributes =
+                    AudioAttributes
+                        .Builder()
+                        .setUsage(C.USAGE_MEDIA)
+                        .setContentType(C.AUDIO_CONTENT_TYPE_MUSIC)
+                        .build()
+
+                player =
+                    ExoPlayer
+                        .Builder(context)
+                        .setLoadControl(loadControl)
+                        .setAudioAttributes(audioAttributes, true) // handleAudioFocus = true for gapless
+                        .setHandleAudioBecomingNoisy(true) // Pause when headphones disconnected
+                        .setPauseAtEndOfMediaItems(false) // Don't pause between items - key for gapless!
+                        .build()
+
+                mediaSessionManager =
+                    MediaSessionManager(context, player, playlistManager).apply {
+                        setTrackPlayerCore(this@TrackPlayerCore)
+                    }
 
-            // Set references for MediaBrowserService
-            NitroPlayerMediaBrowserService.trackPlayerCore = this
-            NitroPlayerMediaBrowserService.mediaSessionManager = mediaSessionManager
+                // Set references for MediaBrowserService
+                NitroPlayerMediaBrowserService.trackPlayerCore = this
+                NitroPlayerMediaBrowserService.mediaSessionManager = mediaSessionManager
 
-            // Initialize Android Auto connection detector
-            androidAutoConnectionDetector =
-                AndroidAutoConnectionDetector(context).apply {
-                    onConnectionChanged = { connected, connectionType ->
-                        handler.post {
-                            isAndroidAutoConnected = connected
-                            NitroPlayerMediaBrowserService.isAndroidAutoConnected = connected
+                // Initialize Android Auto connection detector
+                androidAutoConnectionDetector =
+                    AndroidAutoConnectionDetector(context).apply {
+                        onConnectionChanged = { connected, connectionType ->
+                            handler.post {
+                                isAndroidAutoConnected = connected
+                                NitroPlayerMediaBrowserService.isAndroidAutoConnected = connected
 
-                            // Notify JavaScript
-                            onAndroidAutoConnectionChange?.invoke(connected)
+                                // Notify JavaScript
+                                onAndroidAutoConnectionChange?.invoke(connected)
 
-                            println("🚗 Android Auto connection changed: connected=$connected, type=$connectionType")
+                                println("🚗 Android Auto connection changed: connected=$connected, type=$connectionType")
+                            }
                         }
+                        registerCarConnectionReceiver()
                     }
-                    registerCarConnectionReceiver()
-                }
 
-            player.addListener(
-                object : Player.Listener {
-                    override fun onMediaItemTransition(
-                        mediaItem: MediaItem?,
-                        reason: Int,
-                    ) {
-                        println("\n🔄 onMediaItemTransition called")
-                        println(
-                            "   reason: ${when (reason) {
-                                Player.MEDIA_ITEM_TRANSITION_REASON_AUTO -> "AUTO (track ended)"
-                                Player.MEDIA_ITEM_TRANSITION_REASON_SEEK -> "SEEK"
-                                Player.MEDIA_ITEM_TRANSITION_REASON_PLAYLIST_CHANGED -> "PLAYLIST_CHANGED"
-                                Player.MEDIA_ITEM_TRANSITION_REASON_REPEAT -> "REPEAT"
-                                else -> "UNKNOWN($reason)"
-                            }}",
-                        )
-                        println("   previousMediaItem: ${previousMediaItem?.mediaId}")
-                        println("   new mediaItem: ${mediaItem?.mediaId}")
-                        println("   playNextStack: ${playNextStack.map { it.id }}")
-                        println("   upNextQueue: ${upNextQueue.map { it.id }}")
-
-                        // Remove finished track from temporary lists
-                        // Handle AUTO (natural end) and SEEK (skip next) transitions
-                        if ((
-                                reason == Player.MEDIA_ITEM_TRANSITION_REASON_AUTO ||
-                                    reason == Player.MEDIA_ITEM_TRANSITION_REASON_SEEK
-                            ) &&
-                            previousMediaItem != null
+                player.addListener(
+                    object : Player.Listener {
+                        override fun onMediaItemTransition(
+                            mediaItem: MediaItem?,
+                            reason: Int,
                         ) {
-                            previousMediaItem?.mediaId?.let { mediaId ->
-                                val trackId = extractTrackId(mediaId)
-                                println("🏁 Track finished/skipped, checking for removal: $trackId")
-
-                                // Find and remove from playNext stack (like iOS does)
-                                val playNextIndex = playNextStack.indexOfFirst { it.id == trackId }
-                                if (playNextIndex >= 0) {
-                                    val track = playNextStack.removeAt(playNextIndex)
-                                    println("   ✅ Removed from playNext stack: ${track.title}")
-                                } else {
-                                    // Find and remove from upNext queue
-                                    val upNextIndex = upNextQueue.indexOfFirst { it.id == trackId }
-                                    if (upNextIndex >= 0) {
-                                        val track = upNextQueue.removeAt(upNextIndex)
-                                        println("   ✅ Removed from upNext queue: ${track.title}")
+                            println("\n🔄 onMediaItemTransition called")
+                            println(
+                                "   reason: ${when (reason) {
+                                    Player.MEDIA_ITEM_TRANSITION_REASON_AUTO -> "AUTO (track ended)"
+                                    Player.MEDIA_ITEM_TRANSITION_REASON_SEEK -> "SEEK"
+                                    Player.MEDIA_ITEM_TRANSITION_REASON_PLAYLIST_CHANGED -> "PLAYLIST_CHANGED"
+                                    Player.MEDIA_ITEM_TRANSITION_REASON_REPEAT -> "REPEAT"
+                                    else -> "UNKNOWN($reason)"
+                                }}",
+                            )
+                            println("   previousMediaItem: ${previousMediaItem?.mediaId}")
+                            println("   new mediaItem: ${mediaItem?.mediaId}")
+                            println("   playNextStack: ${playNextStack.map { it.id }}")
+                            println("   upNextQueue: ${upNextQueue.map { it.id }}")
+
+                            // Remove finished track from temporary lists
+                            // Handle AUTO (natural end) and SEEK (skip next) transitions
+                            if ((
+                                    reason == Player.MEDIA_ITEM_TRANSITION_REASON_AUTO ||
+                                        reason == Player.MEDIA_ITEM_TRANSITION_REASON_SEEK
+                                ) &&
+                                previousMediaItem != null
+                            ) {
+                                previousMediaItem?.mediaId?.let { mediaId ->
+                                    val trackId = extractTrackId(mediaId)
+                                    println("🏁 Track finished/skipped, checking for removal: $trackId")
+
+                                    // Find and remove from playNext stack (like iOS does)
+                                    val playNextIndex = playNextStack.indexOfFirst { it.id == trackId }
+                                    if (playNextIndex >= 0) {
+                                        val track = playNextStack.removeAt(playNextIndex)
+                                        println("   ✅ Removed from playNext stack: ${track.title}")
                                     } else {
-                                        println("   ℹ️  Was an original playlist track")
+                                        // Find and remove from upNext queue
+                                        val upNextIndex = upNextQueue.indexOfFirst { it.id == trackId }
+                                        if (upNextIndex >= 0) {
+                                            val track = upNextQueue.removeAt(upNextIndex)
+                                            println("   ✅ Removed from upNext queue: ${track.title}")
+                                        } else {
+                                            println("   ℹ️  Was an original playlist track")
+                                        }
                                     }
                                 }
+                            } else {
+                                println("   ⏭️  Skipping removal (reason=$reason, prev=${previousMediaItem != null})")
                             }
-                        } else {
-                            println("   ⏭️  Skipping removal (reason=$reason, prev=${previousMediaItem != null})")
-                        }
 
-                        // Store current item as previous for next transition
-                        previousMediaItem = mediaItem
+                            // Store current item as previous for next transition
+                            previousMediaItem = mediaItem
 
-                        // Update temporary type for current track
-                        currentTemporaryType = determineCurrentTemporaryType()
-                        println("   Updated currentTemporaryType: $currentTemporaryType")
+                            // Update temporary type for current track
+                            currentTemporaryType = determineCurrentTemporaryType()
+                            println("   Updated currentTemporaryType: $currentTemporaryType")
 
-                        // Update currentTrackIndex when we land on an original playlist track
-                        if (currentTemporaryType == TemporaryType.NONE && mediaItem != null) {
-                            val trackId = extractTrackId(mediaItem.mediaId)
-                            val newIndex = currentTracks.indexOfFirst { it.id == trackId }
-                            if (newIndex >= 0 && newIndex != currentTrackIndex) {
-                                println("   📍 Updating currentTrackIndex from $currentTrackIndex to $newIndex")
-                                currentTrackIndex = newIndex
+                            // Update currentTrackIndex when we land on an original playlist track
+                            if (currentTemporaryType == TemporaryType.NONE && mediaItem != null) {
+                                val trackId = extractTrackId(mediaItem.mediaId)
+                                val newIndex = currentTracks.indexOfFirst { it.id == trackId }
+                                if (newIndex >= 0 && newIndex != currentTrackIndex) {
+                                    println("   📍 Updating currentTrackIndex from $currentTrackIndex to $newIndex")
+                                    currentTrackIndex = newIndex
+                                }
                             }
-                        }
 
-                        // Handle playlist switching if needed
-                        mediaItem?.mediaId?.let { mediaId ->
-                            if (mediaId.contains(':')) {
-                                val colonIndex = mediaId.indexOf(':')
-                                val playlistId = mediaId.substring(0, colonIndex)
-                                if (playlistId != currentPlaylistId) {
-                                    // Track from different playlist - ensure playlist is loaded
-                                    val playlist = playlistManager.getPlaylist(playlistId)
-                                    if (playlist != null && currentPlaylistId != playlistId) {
-                                        // This shouldn't happen if playlists are loaded correctly,
-                                        // but handle it as a safety measure
-                                        println(
-                                            "⚠️ TrackPlayerCore: Detected track from different playlist, updating...",
-                                        )
+                            // Handle playlist switching if needed
+                            mediaItem?.mediaId?.let { mediaId ->
+                                if (mediaId.contains(':')) {
+                                    val colonIndex = mediaId.indexOf(':')
+                                    val playlistId = mediaId.substring(0, colonIndex)
+                                    if (playlistId != currentPlaylistId) {
+                                        // Track from different playlist - ensure playlist is loaded
+                                        val playlist = playlistManager.getPlaylist(playlistId)
+                                        if (playlist != null && currentPlaylistId != playlistId) {
+                                            // This shouldn't happen if playlists are loaded correctly,
+                                            // but handle it as a safety measure
+                                            println(
+                                                "⚠️ TrackPlayerCore: Detected track from different playlist, updating...",
+                                            )
+                                        }
                                     }
                                 }
                             }
+
+                            // Use getCurrentTrack() which handles temporary tracks properly
+                            val track = getCurrentTrack()
+                            if (track != null) {
+                                val r =
+                                    when (reason) {
+                                        Player.MEDIA_ITEM_TRANSITION_REASON_AUTO -> Reason.END
+                                        Player.MEDIA_ITEM_TRANSITION_REASON_SEEK -> Reason.USER_ACTION
+                                        Player.MEDIA_ITEM_TRANSITION_REASON_PLAYLIST_CHANGED -> Reason.USER_ACTION
+                                        else -> null
+                                    }
+                                notifyTrackChange(track, r)
+                                mediaSessionManager?.onTrackChanged()
+                            }
                         }
 
-                        // Use getCurrentTrack() which handles temporary tracks properly
-                        val track = getCurrentTrack()
-                        if (track != null) {
+                        override fun onTimelineChanged(
+                            timeline: androidx.media3.common.Timeline,
+                            reason: Int,
+                        ) {
+                            if (reason == Player.TIMELINE_CHANGE_REASON_PLAYLIST_CHANGED) {
+                                // Playlist changed - update MediaBrowserService
+                                NitroPlayerMediaBrowserService.getInstance()?.onPlaylistsUpdated()
+                            }
+                        }
+
+                        override fun onPlayWhenReadyChanged(
+                            playWhenReady: Boolean,
+                            reason: Int,
+                        ) {
                             val r =
                                 when (reason) {
-                                    Player.MEDIA_ITEM_TRANSITION_REASON_AUTO -> Reason.END
-                                    Player.MEDIA_ITEM_TRANSITION_REASON_SEEK -> Reason.USER_ACTION
-                                    Player.MEDIA_ITEM_TRANSITION_REASON_PLAYLIST_CHANGED -> Reason.USER_ACTION
+                                    Player.PLAY_WHEN_READY_CHANGE_REASON_USER_REQUEST -> Reason.USER_ACTION
                                     else -> null
                                 }
-                            notifyTrackChange(track, r)
-                            mediaSessionManager?.onTrackChanged()
+                            emitStateChange(r)
                         }
-                    }
 
-                    override fun onTimelineChanged(
-                        timeline: androidx.media3.common.Timeline,
-                        reason: Int,
-                    ) {
-                        if (reason == Player.TIMELINE_CHANGE_REASON_PLAYLIST_CHANGED) {
-                            // Playlist changed - update MediaBrowserService
-                            NitroPlayerMediaBrowserService.getInstance()?.onPlaylistsUpdated()
+                        override fun onPlaybackStateChanged(playbackState: Int) {
+                            emitStateChange()
                         }
-                    }
-
-                    override fun onPlayWhenReadyChanged(
-                        playWhenReady: Boolean,
-                        reason: Int,
-                    ) {
-                        val r =
-                            when (reason) {
-                                Player.PLAY_WHEN_READY_CHANGE_REASON_USER_REQUEST -> Reason.USER_ACTION
-                                else -> null
-                            }
-                        emitStateChange(r)
-                    }
 
-                    override fun onPlaybackStateChanged(playbackState: Int) {
-                        emitStateChange()
-                    }
+                        override fun onIsPlayingChanged(isPlaying: Boolean) {
+                            emitStateChange()
+                        }
 
-                    override fun onIsPlayingChanged(isPlaying: Boolean) {
-                        emitStateChange()
-                    }
+                        override fun onPositionDiscontinuity(
+                            oldPosition: Player.PositionInfo,
+                            newPosition: Player.PositionInfo,
+                            reason: Int,
+                        ) {
+                            if (reason == Player.DISCONTINUITY_REASON_SEEK) {
+                                isManuallySeeked = true
+                                notifySeek(newPosition.positionMs / 1000.0, player.duration / 1000.0)
+                            }
+                        }
 
-                    override fun onPositionDiscontinuity(
-                        oldPosition: Player.PositionInfo,
-                        newPosition: Player.PositionInfo,
-                        reason: Int,
-                    ) {
-                        if (reason == Player.DISCONTINUITY_REASON_SEEK) {
-                            isManuallySeeked = true
-                            notifySeek(newPosition.positionMs / 1000.0, player.duration / 1000.0)
+                        override fun onAudioSessionIdChanged(audioSessionId: Int) {
+                            if (audioSessionId != 0) {
+                                try {
+                                    EqualizerCore.getInstance(context).initialize(audioSessionId)
+                                } catch (e: Exception) {
+                                    // Equalizer initialization failed - non-critical
+                                }
+                            }
                         }
-                    }
-                },
-            )
+                    },
+                )
+
+                // Start progress updates
+                handler.post(progressUpdateRunnable)
+            }
 
-            // Start progress updates
-            handler.post(progressUpdateRunnable)
+        // Execute on main thread: if already on main thread, run synchronously to avoid deadlock
+        if (android.os.Looper.myLooper() == android.os.Looper.getMainLooper()) {
+            initRunnable.run()
+        } else {
+            handler.post(initRunnable)
         }
     }