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

package/android/src/main/AndroidManifest.xml

@@ -4,8 +4,21 @@
     <uses-permission android:name="android.permission.INTERNET" />
     <uses-permission android:name="android.permission.FOREGROUND_SERVICE" />
     <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" />
+
     <application>
+        <!-- PlaybackService keeps music alive when screen is locked / app backgrounded -->
+        <service
+            android:name="com.margelo.nitro.nitroplayer.media.NitroPlayerPlaybackService"
+            android:foregroundServiceType="mediaPlayback"
+            android:exported="true"
+            tools:node="merge">
+            <intent-filter>
+                <action android:name="androidx.media3.session.MediaSessionService" />
+            </intent-filter>
+        </service>
+
         <!-- WorkManager's SystemForegroundService for download notifications -->
         <service
             android:name="androidx.work.impl.foreground.SystemForegroundService"

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

@@ -14,14 +14,13 @@ class HybridAndroidAutoMediaLibrary : HybridAndroidAutoMediaLibrarySpec() {
     private val core: TrackPlayerCore
 
     init {
-        val context = NitroModules.applicationContext
-            ?: throw IllegalStateException("React Context is not initialized")
+        val context =
+            NitroModules.applicationContext
+                ?: throw IllegalStateException("React Context is not initialized")
         core = TrackPlayerCore.getInstance(context)
     }
 
-    override fun setMediaLibrary(libraryJson: String): Promise<Unit> =
-        Promise.async { core.setAndroidAutoMediaLibrary(libraryJson) }
+    override fun setMediaLibrary(libraryJson: String): Promise<Unit> = Promise.async { core.setAndroidAutoMediaLibrary(libraryJson) }
 
-    override fun clearMediaLibrary(): Promise<Unit> =
-        Promise.async { core.clearAndroidAutoMediaLibrary() }
+    override fun clearMediaLibrary(): Promise<Unit> = Promise.async { core.clearAndroidAutoMediaLibrary() }
 }

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

@@ -19,12 +19,16 @@ class HybridAudioDevices : HybridAudioDevicesSpec() {
     private val audioManager = applicationContext?.getSystemService(Context.AUDIO_SERVICE) as AudioManager
 
     private val validCommunicationDeviceTypes: Set<Int> by lazy {
-        val types = mutableSetOf(
-            AudioDeviceInfo.TYPE_BUILTIN_EARPIECE, AudioDeviceInfo.TYPE_BUILTIN_SPEAKER,
-            AudioDeviceInfo.TYPE_WIRED_HEADSET, AudioDeviceInfo.TYPE_WIRED_HEADPHONES,
-            AudioDeviceInfo.TYPE_BLUETOOTH_SCO, AudioDeviceInfo.TYPE_BLUETOOTH_A2DP,
-            AudioDeviceInfo.TYPE_USB_HEADSET,
-        )
+        val types =
+            mutableSetOf(
+                AudioDeviceInfo.TYPE_BUILTIN_EARPIECE,
+                AudioDeviceInfo.TYPE_BUILTIN_SPEAKER,
+                AudioDeviceInfo.TYPE_WIRED_HEADSET,
+                AudioDeviceInfo.TYPE_WIRED_HEADPHONES,
+                AudioDeviceInfo.TYPE_BLUETOOTH_SCO,
+                AudioDeviceInfo.TYPE_BLUETOOTH_A2DP,
+                AudioDeviceInfo.TYPE_USB_HEADSET,
+            )
         if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.S) {
             types.add(AudioDeviceInfo.TYPE_BLE_HEADSET)
             types.add(AudioDeviceInfo.TYPE_BLE_SPEAKER)
@@ -35,55 +39,70 @@ class HybridAudioDevices : HybridAudioDevicesSpec() {
     override fun getAudioDevices(): Array<TAudioDevice> {
         val devices = audioManager.getDevices(AudioManager.GET_DEVICES_OUTPUTS)
         val activeDevice: AudioDeviceInfo? = if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.S) audioManager.communicationDevice else null
-        return devices.filter { validCommunicationDeviceTypes.contains(it.type) }.map { device ->
-            TAudioDevice(
-                id = device.id.toDouble(),
-                name = device.productName?.toString() ?: getDeviceTypeName(device.type),
-                type = device.type.toDouble(),
-                isActive = device == activeDevice,
-            )
-        }.toTypedArray()
+        return devices
+            .filter { validCommunicationDeviceTypes.contains(it.type) }
+            .map { device ->
+                TAudioDevice(
+                    id = device.id.toDouble(),
+                    name = device.productName?.toString() ?: getDeviceTypeName(device.type),
+                    type = device.type.toDouble(),
+                    isActive = device == activeDevice,
+                )
+            }.toTypedArray()
     }
 
     /** v2: setAudioDevice now returns Promise<Unit> instead of Boolean */
-    override fun setAudioDevice(deviceId: Double): Promise<Unit> = Promise.async {
-        val device = audioManager.getDevices(AudioManager.GET_DEVICES_OUTPUTS)
-            .firstOrNull { it.id == deviceId.toInt() }
-            ?: throw IllegalArgumentException("Audio device $deviceId not found")
-        if (!validCommunicationDeviceTypes.contains(device.type)) {
-            throw IllegalArgumentException("Device type ${device.type} is not a valid communication device")
-        }
-        try {
-            if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.S) {
-                audioManager.setCommunicationDevice(device)
-            } else {
-                when (device.type) {
-                    AudioDeviceInfo.TYPE_BLUETOOTH_SCO, AudioDeviceInfo.TYPE_BLUETOOTH_A2DP -> {
-                        audioManager.startBluetoothSco(); audioManager.isBluetoothScoOn = true
-                    }
-                    AudioDeviceInfo.TYPE_BUILTIN_SPEAKER -> audioManager.isSpeakerphoneOn = true
-                    AudioDeviceInfo.TYPE_WIRED_HEADSET, AudioDeviceInfo.TYPE_WIRED_HEADPHONES -> {
-                        audioManager.isSpeakerphoneOn = false; audioManager.isBluetoothScoOn = false
+    override fun setAudioDevice(deviceId: Double): Promise<Unit> =
+        Promise.async {
+            val device =
+                audioManager
+                    .getDevices(AudioManager.GET_DEVICES_OUTPUTS)
+                    .firstOrNull { it.id == deviceId.toInt() }
+                    ?: throw IllegalArgumentException("Audio device $deviceId not found")
+            if (!validCommunicationDeviceTypes.contains(device.type)) {
+                throw IllegalArgumentException("Device type ${device.type} is not a valid communication device")
+            }
+            try {
+                if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.S) {
+                    audioManager.setCommunicationDevice(device)
+                } else {
+                    when (device.type) {
+                        AudioDeviceInfo.TYPE_BLUETOOTH_SCO, AudioDeviceInfo.TYPE_BLUETOOTH_A2DP -> {
+                            audioManager.startBluetoothSco()
+                            audioManager.isBluetoothScoOn = true
+                        }
+
+                        AudioDeviceInfo.TYPE_BUILTIN_SPEAKER -> {
+                            audioManager.isSpeakerphoneOn = true
+                        }
+
+                        AudioDeviceInfo.TYPE_WIRED_HEADSET, AudioDeviceInfo.TYPE_WIRED_HEADPHONES -> {
+                            audioManager.isSpeakerphoneOn = false
+                            audioManager.isBluetoothScoOn = false
+                        }
+
+                        else -> {
+                            throw IllegalArgumentException("Unsupported device type for pre-Android 12: ${device.type}")
+                        }
                     }
-                    else -> throw IllegalArgumentException("Unsupported device type for pre-Android 12: ${device.type}")
                 }
+            } catch (e: Exception) {
+                NitroPlayerLogger.log("HybridAudioDevices", "Error setting audio device: ${e.message}")
+                throw e
             }
-        } catch (e: Exception) {
-            NitroPlayerLogger.log("HybridAudioDevices", "Error setting audio device: ${e.message}")
-            throw e
         }
-    }
 
-    private fun getDeviceTypeName(type: Int): String = when (type) {
-        AudioDeviceInfo.TYPE_BUILTIN_EARPIECE -> "Built-in Earpiece"
-        AudioDeviceInfo.TYPE_BUILTIN_SPEAKER -> "Built-in Speaker"
-        AudioDeviceInfo.TYPE_WIRED_HEADSET -> "Wired Headset"
-        AudioDeviceInfo.TYPE_WIRED_HEADPHONES -> "Wired Headphones"
-        AudioDeviceInfo.TYPE_BLUETOOTH_SCO -> "Bluetooth SCO"
-        AudioDeviceInfo.TYPE_BLUETOOTH_A2DP -> "Bluetooth"
-        AudioDeviceInfo.TYPE_USB_HEADSET -> "USB Headset"
-        26 -> if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.S) "BLE Headset" else "Type 26"
-        27 -> if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.S) "BLE Speaker" else "Type 27"
-        else -> "Type $type"
-    }
+    private fun getDeviceTypeName(type: Int): String =
+        when (type) {
+            AudioDeviceInfo.TYPE_BUILTIN_EARPIECE -> "Built-in Earpiece"
+            AudioDeviceInfo.TYPE_BUILTIN_SPEAKER -> "Built-in Speaker"
+            AudioDeviceInfo.TYPE_WIRED_HEADSET -> "Wired Headset"
+            AudioDeviceInfo.TYPE_WIRED_HEADPHONES -> "Wired Headphones"
+            AudioDeviceInfo.TYPE_BLUETOOTH_SCO -> "Bluetooth SCO"
+            AudioDeviceInfo.TYPE_BLUETOOTH_A2DP -> "Bluetooth"
+            AudioDeviceInfo.TYPE_USB_HEADSET -> "USB Headset"
+            26 -> if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.S) "BLE Headset" else "Type 26"
+            27 -> if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.S) "BLE Speaker" else "Type 27"
+            else -> "Type $type"
+        }
 }

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

@@ -15,77 +15,123 @@ class HybridDownloadManager : HybridDownloadManagerSpec() {
     private val core: DownloadManagerCore
 
     init {
-        val context = NitroModules.applicationContext
-            ?: throw IllegalStateException("React Context is not initialized")
+        val context =
+            NitroModules.applicationContext
+                ?: throw IllegalStateException("React Context is not initialized")
         core = DownloadManagerCore.getInstance(context)
     }
 
     // ── Configuration ─────────────────────────────────────────────────────────
     override fun configure(config: DownloadConfig) = core.configure(config)
+
     override fun getConfig(): DownloadConfig = core.getConfig()
 
     // ── Download operations ───────────────────────────────────────────────────
-    override fun downloadTrack(track: TrackItem, playlistId: String?): Promise<String> = Promise.async { core.downloadTrack(track, playlistId) }
-    override fun downloadPlaylist(playlistId: String, tracks: Array<TrackItem>): Promise<Array<String>> = Promise.async { core.downloadPlaylist(playlistId, tracks) }
+    override fun downloadTrack(
+        track: TrackItem,
+        playlistId: String?,
+    ): Promise<String> = Promise.async { core.downloadTrack(track, playlistId) }
+
+    override fun downloadPlaylist(
+        playlistId: String,
+        tracks: Array<TrackItem>,
+    ): Promise<Array<String>> = Promise.async { core.downloadPlaylist(playlistId, tracks) }
+
     override fun pauseDownload(downloadId: String): Promise<Unit> = Promise.async { core.pauseDownload(downloadId) }
+
     override fun resumeDownload(downloadId: String): Promise<Unit> = Promise.async { core.resumeDownload(downloadId) }
+
     override fun cancelDownload(downloadId: String): Promise<Unit> = Promise.async { core.cancelDownload(downloadId) }
+
     override fun retryDownload(downloadId: String): Promise<Unit> = Promise.async { core.retryDownload(downloadId) }
+
     override fun pauseAllDownloads(): Promise<Unit> = Promise.async { core.pauseAllDownloads() }
+
     override fun resumeAllDownloads(): Promise<Unit> = Promise.async { core.resumeAllDownloads() }
+
     override fun cancelAllDownloads(): Promise<Unit> = Promise.async { core.cancelAllDownloads() }
 
     // ── Download status (sync) ────────────────────────────────────────────────
     override fun getDownloadTask(downloadId: String): Variant_NullType_DownloadTask {
         val task = core.getDownloadTask(downloadId)
-        return if (task != null) Variant_NullType_DownloadTask.create(task)
-        else Variant_NullType_DownloadTask.create(NullType.NULL)
+        return if (task != null) {
+            Variant_NullType_DownloadTask.create(task)
+        } else {
+            Variant_NullType_DownloadTask.create(NullType.NULL)
+        }
     }
+
     override fun getActiveDownloads(): Array<DownloadTask> = core.getActiveDownloads()
+
     override fun getQueueStatus(): DownloadQueueStatus = core.getQueueStatus()
+
     override fun isDownloading(trackId: String): Boolean = core.isDownloading(trackId)
+
     override fun getDownloadState(trackId: String): DownloadState = core.getDownloadState(trackId)
 
     // ── Downloaded content queries (now async per spec) ───────────────────────
     override fun isTrackDownloaded(trackId: String): Promise<Boolean> = Promise.async { core.isTrackDownloaded(trackId) }
+
     override fun isPlaylistDownloaded(playlistId: String): Promise<Boolean> = Promise.async { core.isPlaylistDownloaded(playlistId) }
+
     override fun isPlaylistPartiallyDownloaded(playlistId: String): Promise<Boolean> = Promise.async { core.isPlaylistPartiallyDownloaded(playlistId) }
 
-    override fun getDownloadedTrack(trackId: String): Promise<Variant_NullType_DownloadedTrack> = Promise.async {
-        val track = core.getDownloadedTrack(trackId)
-        if (track != null) Variant_NullType_DownloadedTrack.create(track)
-        else Variant_NullType_DownloadedTrack.create(NullType.NULL)
-    }
+    override fun getDownloadedTrack(trackId: String): Promise<Variant_NullType_DownloadedTrack> =
+        Promise.async {
+            val track = core.getDownloadedTrack(trackId)
+            if (track != null) {
+                Variant_NullType_DownloadedTrack.create(track)
+            } else {
+                Variant_NullType_DownloadedTrack.create(NullType.NULL)
+            }
+        }
+
     override fun getAllDownloadedTracks(): Promise<Array<DownloadedTrack>> = Promise.async { core.getAllDownloadedTracks() }
 
-    override fun getDownloadedPlaylist(playlistId: String): Promise<Variant_NullType_DownloadedPlaylist> = Promise.async {
-        val playlist = core.getDownloadedPlaylist(playlistId)
-        if (playlist != null) Variant_NullType_DownloadedPlaylist.create(playlist)
-        else Variant_NullType_DownloadedPlaylist.create(NullType.NULL)
-    }
+    override fun getDownloadedPlaylist(playlistId: String): Promise<Variant_NullType_DownloadedPlaylist> =
+        Promise.async {
+            val playlist = core.getDownloadedPlaylist(playlistId)
+            if (playlist != null) {
+                Variant_NullType_DownloadedPlaylist.create(playlist)
+            } else {
+                Variant_NullType_DownloadedPlaylist.create(NullType.NULL)
+            }
+        }
+
     override fun getAllDownloadedPlaylists(): Promise<Array<DownloadedPlaylist>> = Promise.async { core.getAllDownloadedPlaylists() }
 
-    override fun getLocalPath(trackId: String): Promise<Variant_NullType_String> = Promise.async {
-        val path = core.getLocalPath(trackId)
-        if (path != null) Variant_NullType_String.create(path)
-        else Variant_NullType_String.create(NullType.NULL)
-    }
+    override fun getLocalPath(trackId: String): Promise<Variant_NullType_String> =
+        Promise.async {
+            val path = core.getLocalPath(trackId)
+            if (path != null) {
+                Variant_NullType_String.create(path)
+            } else {
+                Variant_NullType_String.create(NullType.NULL)
+            }
+        }
 
     override fun syncDownloads(): Promise<Double> = Promise.async { core.syncDownloads().toDouble() }
+
     override fun getEffectiveUrl(track: TrackItem): Promise<String> = Promise.async { core.getEffectiveUrl(track) }
 
     // ── Deletion ──────────────────────────────────────────────────────────────
     override fun deleteDownloadedTrack(trackId: String): Promise<Unit> = Promise.async { core.deleteDownloadedTrack(trackId) }
+
     override fun deleteDownloadedPlaylist(playlistId: String): Promise<Unit> = Promise.async { core.deleteDownloadedPlaylist(playlistId) }
+
     override fun deleteAllDownloads(): Promise<Unit> = Promise.async { core.deleteAllDownloads() }
+
     override fun getStorageInfo(): Promise<DownloadStorageInfo> = Promise.async { core.getStorageInfo() }
 
     // ── Playback source ───────────────────────────────────────────────────────
     override fun setPlaybackSourcePreference(preference: PlaybackSource) = core.setPlaybackSourcePreference(preference)
+
     override fun getPlaybackSourcePreference(): PlaybackSource = core.getPlaybackSourcePreference()
 
     // ── Events ────────────────────────────────────────────────────────────────
     override fun onDownloadProgress(callback: (progress: DownloadProgress) -> Unit) = core.addProgressCallback(callback)
+
     override fun onDownloadStateChange(callback: (downloadId: String, trackId: String, state: DownloadState, error: DownloadError?) -> Unit) = core.addStateChangeCallback(callback)
+
     override fun onDownloadComplete(callback: (downloadedTrack: DownloadedTrack) -> Unit) = core.addCompleteCallback(callback)
 }

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

@@ -13,37 +13,59 @@ class HybridEqualizer : HybridEqualizerSpec() {
     private val core: EqualizerCore
 
     init {
-        val context = NitroModules.applicationContext
-            ?: throw IllegalStateException("React Context is not initialized")
+        val context =
+            NitroModules.applicationContext
+                ?: throw IllegalStateException("React Context is not initialized")
         core = EqualizerCore.getInstance(context)
         core.ensureInitialized()
     }
 
     // ── Sync reads ────────────────────────────────────────────────────────────
     override fun isEnabled(): Boolean = core.isEnabled()
+
     override fun getBandRange(): GainRange = core.getBandRange()
+
     override fun getPresets(): Array<EqualizerPreset> = core.getPresets()
+
     override fun getBuiltInPresets(): Array<EqualizerPreset> = core.getBuiltInPresets()
+
     override fun getCustomPresets(): Array<EqualizerPreset> = core.getCustomPresets()
+
     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)
+        return if (name != null) {
+            Variant_NullType_String.create(name)
+        } else {
+            Variant_NullType_String.create(NullType.NULL)
+        }
     }
 
     // ── Async mutations (per v2 spec) ─────────────────────────────────────────
     override fun setEnabled(enabled: Boolean): Promise<Unit> = Promise.async { core.setEnabled(enabled) }
+
     override fun getBands(): Promise<Array<EqualizerBand>> = Promise.async { core.getBands() }
-    override fun setBandGain(bandIndex: Double, gainDb: Double): Promise<Unit> = Promise.async { core.setBandGain(bandIndex.toInt(), gainDb) }
+
+    override fun setBandGain(
+        bandIndex: Double,
+        gainDb: Double,
+    ): Promise<Unit> = Promise.async { core.setBandGain(bandIndex.toInt(), gainDb) }
+
     override fun setAllBandGains(gains: DoubleArray): Promise<Unit> = Promise.async { core.setAllBandGains(gains) }
+
     override fun applyPreset(presetName: String): Promise<Unit> = Promise.async { core.applyPreset(presetName) }
+
     override fun saveCustomPreset(name: String): Promise<Unit> = Promise.async { core.saveCustomPreset(name) }
+
     override fun deleteCustomPreset(name: String): Promise<Unit> = Promise.async { core.deleteCustomPreset(name) }
+
     override fun getState(): Promise<EqualizerState> = Promise.async { core.getState() }
+
     override fun reset(): Promise<Unit> = Promise.async { core.reset() }
 
     // ── Events ────────────────────────────────────────────────────────────────
     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/HybridPlayerQueue.kt

@@ -21,8 +21,9 @@ class HybridPlayerQueue : HybridPlayerQueueSpec() {
     private val playlistManager: PlaylistManager
 
     init {
-        val context = NitroModules.applicationContext
-            ?: throw IllegalStateException("React Context is not initialized")
+        val context =
+            NitroModules.applicationContext
+                ?: throw IllegalStateException("React Context is not initialized")
         core = TrackPlayerCore.getInstance(context)
         playlistManager = core.getPlaylistManager()
     }
@@ -32,87 +33,125 @@ class HybridPlayerQueue : HybridPlayerQueueSpec() {
 
     // ── Playlist CRUD ─────────────────────────────────────────────────────────
 
-    override fun createPlaylist(name: String, description: String?, artwork: String?): Promise<String> =
-        Promise.async { playlistManager.createPlaylist(name, description, artwork) }
+    override fun createPlaylist(
+        name: String,
+        description: String?,
+        artwork: String?,
+    ): Promise<String> = Promise.async { playlistManager.createPlaylist(name, description, artwork) }
 
-    override fun deletePlaylist(playlistId: String): Promise<Unit> = Promise.async {
-        playlistManager.deletePlaylist(playlistId)
-    }
+    override fun deletePlaylist(playlistId: String): Promise<Unit> =
+        Promise.async {
+            playlistManager.deletePlaylist(playlistId)
+        }
 
-    override fun updatePlaylist(playlistId: String, name: String?, description: String?, artwork: String?): Promise<Unit> = Promise.async {
-        playlistManager.updatePlaylist(playlistId, name, description, artwork)
-        core.updatePlaylist(playlistId)
-    }
+    override fun updatePlaylist(
+        playlistId: String,
+        name: String?,
+        description: String?,
+        artwork: String?,
+    ): Promise<Unit> =
+        Promise.async {
+            playlistManager.updatePlaylist(playlistId, name, description, artwork)
+            core.updatePlaylist(playlistId)
+        }
 
     override fun getPlaylist(playlistId: String): Variant_NullType_Playlist {
         val playlist = playlistManager.getPlaylist(playlistId)
-        return if (playlist != null) Variant_NullType_Playlist.create(playlist.toPlaylist())
-        else Variant_NullType_Playlist.create(NullType.NULL)
+        return if (playlist != null) {
+            Variant_NullType_Playlist.create(playlist.toPlaylist())
+        } else {
+            Variant_NullType_Playlist.create(NullType.NULL)
+        }
     }
 
-    override fun getAllPlaylists(): Array<Playlist> =
-        playlistManager.getAllPlaylists().map { it.toPlaylist() }.toTypedArray()
+    override fun getAllPlaylists(): Array<Playlist> = playlistManager.getAllPlaylists().map { it.toPlaylist() }.toTypedArray()
 
     // ── Track mutations ───────────────────────────────────────────────────────
 
-    override fun addTrackToPlaylist(playlistId: String, track: TrackItem, index: Double?): Promise<Unit> = Promise.async {
-        playlistManager.addTrackToPlaylist(playlistId, track, index?.toInt())
-        core.updatePlaylist(playlistId)
-    }
+    override fun addTrackToPlaylist(
+        playlistId: String,
+        track: TrackItem,
+        index: Double?,
+    ): Promise<Unit> =
+        Promise.async {
+            playlistManager.addTrackToPlaylist(playlistId, track, index?.toInt())
+            core.updatePlaylist(playlistId)
+        }
 
-    override fun addTracksToPlaylist(playlistId: String, tracks: Array<TrackItem>, index: Double?): Promise<Unit> = Promise.async {
-        playlistManager.addTracksToPlaylist(playlistId, tracks.toList(), index?.toInt())
-        core.updatePlaylist(playlistId)
-    }
+    override fun addTracksToPlaylist(
+        playlistId: String,
+        tracks: Array<TrackItem>,
+        index: Double?,
+    ): Promise<Unit> =
+        Promise.async {
+            playlistManager.addTracksToPlaylist(playlistId, tracks.toList(), index?.toInt())
+            core.updatePlaylist(playlistId)
+        }
 
-    override fun removeTrackFromPlaylist(playlistId: String, trackId: String): Promise<Unit> = Promise.async {
-        playlistManager.removeTrackFromPlaylist(playlistId, trackId)
-        core.updatePlaylist(playlistId)
-    }
+    override fun removeTrackFromPlaylist(
+        playlistId: String,
+        trackId: String,
+    ): Promise<Unit> =
+        Promise.async {
+            playlistManager.removeTrackFromPlaylist(playlistId, trackId)
+            core.updatePlaylist(playlistId)
+        }
 
-    override fun reorderTrackInPlaylist(playlistId: String, trackId: String, newIndex: Double): Promise<Unit> = Promise.async {
-        playlistManager.reorderTrackInPlaylist(playlistId, trackId, newIndex.toInt())
-        core.updatePlaylist(playlistId)
-    }
+    override fun reorderTrackInPlaylist(
+        playlistId: String,
+        trackId: String,
+        newIndex: Double,
+    ): Promise<Unit> =
+        Promise.async {
+            playlistManager.reorderTrackInPlaylist(playlistId, trackId, newIndex.toInt())
+            core.updatePlaylist(playlistId)
+        }
 
     // ── Playback control ──────────────────────────────────────────────────────
 
-    override fun loadPlaylist(playlistId: String): Promise<Unit> = Promise.async {
-        core.loadPlaylist(playlistId)
-    }
+    override fun loadPlaylist(playlistId: String): Promise<Unit> =
+        Promise.async {
+            core.loadPlaylist(playlistId)
+        }
 
     override fun getCurrentPlaylistId(): Variant_NullType_String {
         val id = core.getCurrentPlaylistId()
-        return if (id != null) Variant_NullType_String.create(id)
-        else Variant_NullType_String.create(NullType.NULL)
+        return if (id != null) {
+            Variant_NullType_String.create(id)
+        } else {
+            Variant_NullType_String.create(NullType.NULL)
+        }
     }
 
     // ── Events ────────────────────────────────────────────────────────────────
 
     override fun onPlaylistsChanged(callback: (playlists: Array<Playlist>, operation: QueueOperation?) -> Unit) {
-        val removeListener = playlistManager.addPlaylistsChangeListener { playlists, operation ->
-            callback(playlists.map { it.toPlaylist() }.toTypedArray(), operation)
-        }
+        val removeListener =
+            playlistManager.addPlaylistsChangeListener { playlists, operation ->
+                callback(playlists.map { it.toPlaylist() }.toTypedArray(), operation)
+            }
         playlistsChangeListeners.add(removeListener)
     }
 
     override fun onPlaylistChanged(callback: (playlistId: String, playlist: Playlist, operation: QueueOperation?) -> Unit) {
         val listenerId = UUID.randomUUID().toString()
         playlistManager.getAllPlaylists().forEach { internalPlaylist ->
-            val removeListener = playlistManager.addPlaylistChangeListener(internalPlaylist.id) { playlist, operation ->
-                callback(playlist.id, playlist.toPlaylist(), operation)
-            }
+            val removeListener =
+                playlistManager.addPlaylistChangeListener(internalPlaylist.id) { playlist, operation ->
+                    callback(playlist.id, playlist.toPlaylist(), operation)
+                }
             playlistChangeListeners[listenerId] = removeListener
         }
     }
 
     // ── Helper ────────────────────────────────────────────────────────────────
 
-    private fun InternalPlaylist.toPlaylist(): Playlist = Playlist(
-        id = this.id,
-        name = this.name,
-        description = this.description?.let { Variant_NullType_String.create(it) },
-        artwork = this.artwork?.let { Variant_NullType_String.create(it) },
-        tracks = this.tracks.toTypedArray(),
-    )
+    private fun InternalPlaylist.toPlaylist(): Playlist =
+        Playlist(
+            id = this.id,
+            name = this.name,
+            description = this.description?.let { Variant_NullType_String.create(it) },
+            artwork = this.artwork?.let { Variant_NullType_String.create(it) },
+            tracks = this.tracks.toTypedArray(),
+        )
 }