react-native-nitro-player 0.6.1 → 0.7.1-alpha.0

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

@@ -3,7 +3,10 @@ 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.Promise
 import com.margelo.nitro.nitroplayer.core.TrackPlayerCore
+import com.margelo.nitro.nitroplayer.core.clearAndroidAutoMediaLibrary
+import com.margelo.nitro.nitroplayer.core.setAndroidAutoMediaLibrary
 
 @DoNotStrip
 @Keep
@@ -11,21 +14,14 @@ 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)
     }
 
-    @DoNotStrip
-    @Keep
-    override fun setMediaLibrary(libraryJson: String) {
-        core.setAndroidAutoMediaLibrary(libraryJson)
-    }
+    override fun setMediaLibrary(libraryJson: String): Promise<Unit> =
+        Promise.async { core.setAndroidAutoMediaLibrary(libraryJson) }
 
-    @DoNotStrip
-    @Keep
-    override fun clearMediaLibrary() {
-        core.clearAndroidAutoMediaLibrary()
-    }
+    override fun clearMediaLibrary(): Promise<Unit> =
+        Promise.async { core.clearAndroidAutoMediaLibrary() }
 }

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

@@ -1,3 +1,5 @@
+@file:Suppress("ktlint:standard:max-line-length")
+
 package com.margelo.nitro.nitroplayer
 
 import android.content.Context
@@ -7,6 +9,7 @@ import android.os.Build
 import androidx.annotation.Keep
 import com.facebook.proguard.annotations.DoNotStrip
 import com.margelo.nitro.NitroModules
+import com.margelo.nitro.core.Promise
 import com.margelo.nitro.nitroplayer.core.NitroPlayerLogger
 
 @DoNotStrip
@@ -15,19 +18,13 @@ class HybridAudioDevices : HybridAudioDevicesSpec() {
     val applicationContext = NitroModules.applicationContext
     private val audioManager = applicationContext?.getSystemService(Context.AUDIO_SERVICE) as AudioManager
 
-    // Device types that can be set as communication devices
     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,
-            )
-        // BLE types are only available on Android S (API 31) and above
+        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,100 +32,58 @@ class HybridAudioDevices : HybridAudioDevicesSpec() {
         types
     }
 
-    @DoNotStrip
-    @Keep
     override fun getAudioDevices(): Array<TAudioDevice> {
-        val devices = audioManager.getDevices(android.media.AudioManager.GET_DEVICES_OUTPUTS)
-        var activeDevice: AudioDeviceInfo? = null
-
-        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.S) {
-            activeDevice = audioManager.communicationDevice
-        }
-
-        // Filter to only include valid communication devices
-        return devices
-            .filter { device ->
-                validCommunicationDeviceTypes.contains(device.type)
-            }.map { device ->
-                TAudioDevice(
-                    id = device.id.toDouble(),
-                    name = device.productName?.toString() ?: getDeviceTypeName(device.type),
-                    type = device.type.toDouble(),
-                    isActive = device == activeDevice,
-                )
-            }.toTypedArray()
+        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()
     }
 
-    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"
-        }
-
-    @DoNotStrip
-    @Keep
-    override fun setAudioDevice(deviceId: Double): Boolean {
-        val device =
-            audioManager
-                .getDevices(android.media.AudioManager.GET_DEVICES_OUTPUTS)
-                .firstOrNull { it.id == deviceId.toInt() }
-                ?: return false
-
-        // Check if device type is valid for communication
+    /** 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)) {
-            NitroPlayerLogger.log("HybridAudioDevices", "Device type ${device.type} is not a valid communication device")
-            return false
+            throw IllegalArgumentException("Device type ${device.type} is not a valid communication device")
         }
-
-        return try {
-            if (android.os.Build.VERSION.SDK_INT >= android.os.Build.VERSION_CODES.S) {
+        try {
+            if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.S) {
                 audioManager.setCommunicationDevice(device)
             } else {
-                // Pre-Android 12 fallback (best-effort)
                 when (device.type) {
-                    android.media.AudioDeviceInfo.TYPE_BLUETOOTH_SCO,
-                    android.media.AudioDeviceInfo.TYPE_BLUETOOTH_A2DP,
-                    -> {
-                        audioManager.startBluetoothSco()
-                        audioManager.isBluetoothScoOn = true
-                        true
-                    }
-
-                    android.media.AudioDeviceInfo.TYPE_BUILTIN_SPEAKER -> {
-                        audioManager.isSpeakerphoneOn = true
-                        true
-                    }
-
-                    android.media.AudioDeviceInfo.TYPE_WIRED_HEADSET,
-                    android.media.AudioDeviceInfo.TYPE_WIRED_HEADPHONES,
-                    -> {
-                        audioManager.isSpeakerphoneOn = false
-                        audioManager.isBluetoothScoOn = false
-                        true
+                    AudioDeviceInfo.TYPE_BLUETOOTH_SCO, AudioDeviceInfo.TYPE_BLUETOOTH_A2DP -> {
+                        audioManager.startBluetoothSco(); audioManager.isBluetoothScoOn = true
                     }
-
-                    else -> {
-                        NitroPlayerLogger.log("HybridAudioDevices", "Unsupported device type for pre-Android 12: ${device.type}")
-                        false
+                    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}")
                 }
             }
         } catch (e: Exception) {
             NitroPlayerLogger.log("HybridAudioDevices", "Error setting audio device: ${e.message}")
-            e.printStackTrace()
-            false
+            throw e
         }
     }
 
-    companion object {
-        private const val TAG = "HybridAudioDevices"
+    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

@@ -1,3 +1,5 @@
+@file:Suppress("ktlint:standard:max-line-length")
+
 package com.margelo.nitro.nitroplayer
 
 import androidx.annotation.Keep
@@ -7,219 +9,83 @@ import com.margelo.nitro.core.NullType
 import com.margelo.nitro.core.Promise
 import com.margelo.nitro.nitroplayer.download.DownloadManagerCore
 
-/**
- * Hybrid implementation of DownloadManagerSpec for Android
- * Bridges Nitro modules with the native DownloadManagerCore implementation
- */
 @DoNotStrip
 @Keep
 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
-    @DoNotStrip
-    @Keep
-    override fun configure(config: DownloadConfig) {
-        core.configure(config)
-    }
-
-    @DoNotStrip
-    @Keep
+    // ── 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)
-        }
-
-    // Download Control
-    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
-    @DoNotStrip
-    @Keep
+    // ── 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 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)
     }
-
-    @DoNotStrip
-    @Keep
     override fun getActiveDownloads(): Array<DownloadTask> = core.getActiveDownloads()
-
-    @DoNotStrip
-    @Keep
     override fun getQueueStatus(): DownloadQueueStatus = core.getQueueStatus()
-
-    @DoNotStrip
-    @Keep
     override fun isDownloading(trackId: String): Boolean = core.isDownloading(trackId)
-
-    @DoNotStrip
-    @Keep
     override fun getDownloadState(trackId: String): DownloadState = core.getDownloadState(trackId)
 
-    // Downloaded Content Queries
-    @DoNotStrip
-    @Keep
-    override fun isTrackDownloaded(trackId: String): Boolean = core.isTrackDownloaded(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) }
 
-    @DoNotStrip
-    @Keep
-    override fun isPlaylistDownloaded(playlistId: String): Boolean = core.isPlaylistDownloaded(playlistId)
-
-    @DoNotStrip
-    @Keep
-    override fun isPlaylistPartiallyDownloaded(playlistId: String): Boolean = core.isPlaylistPartiallyDownloaded(playlistId)
-
-    @DoNotStrip
-    @Keep
-    override fun getDownloadedTrack(trackId: String): Variant_NullType_DownloadedTrack {
+    override fun getDownloadedTrack(trackId: String): Promise<Variant_NullType_DownloadedTrack> = Promise.async {
         val track = core.getDownloadedTrack(trackId)
-        return if (track != null) {
-            Variant_NullType_DownloadedTrack.create(track)
-        } else {
-            Variant_NullType_DownloadedTrack.create(NullType.NULL)
-        }
+        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() }
 
-    @DoNotStrip
-    @Keep
-    override fun getAllDownloadedTracks(): Array<DownloadedTrack> = core.getAllDownloadedTracks()
-
-    @DoNotStrip
-    @Keep
-    override fun getDownloadedPlaylist(playlistId: String): Variant_NullType_DownloadedPlaylist {
+    override fun getDownloadedPlaylist(playlistId: String): Promise<Variant_NullType_DownloadedPlaylist> = Promise.async {
         val playlist = core.getDownloadedPlaylist(playlistId)
-        return if (playlist != null) {
-            Variant_NullType_DownloadedPlaylist.create(playlist)
-        } else {
-            Variant_NullType_DownloadedPlaylist.create(NullType.NULL)
-        }
+        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() }
 
-    @DoNotStrip
-    @Keep
-    override fun getAllDownloadedPlaylists(): Array<DownloadedPlaylist> = core.getAllDownloadedPlaylists()
-
-    @DoNotStrip
-    @Keep
-    override fun getLocalPath(trackId: String): Variant_NullType_String {
+    override fun getLocalPath(trackId: String): Promise<Variant_NullType_String> = Promise.async {
         val path = core.getLocalPath(trackId)
-        return if (path != null) {
-            Variant_NullType_String.create(path)
-        } else {
-            Variant_NullType_String.create(NullType.NULL)
-        }
+        if (path != null) Variant_NullType_String.create(path)
+        else Variant_NullType_String.create(NullType.NULL)
     }
 
-    // Deletion
-    override fun deleteDownloadedTrack(trackId: String): Promise<Unit> =
-        Promise.async {
-            core.deleteDownloadedTrack(trackId)
-        }
+    override fun syncDownloads(): Promise<Double> = Promise.async { core.syncDownloads().toDouble() }
+    override fun getEffectiveUrl(track: TrackItem): Promise<String> = Promise.async { core.getEffectiveUrl(track) }
 
-    override fun deleteDownloadedPlaylist(playlistId: String): Promise<Unit> =
-        Promise.async {
-            core.deleteDownloadedPlaylist(playlistId)
-        }
+    // ── 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() }
 
-    override fun deleteAllDownloads(): Promise<Unit> =
-        Promise.async {
-            core.deleteAllDownloads()
-        }
-
-    // Storage Management
-    override fun getStorageInfo(): Promise<DownloadStorageInfo> =
-        Promise.async {
-            core.getStorageInfo()
-        }
-
-    @DoNotStrip
-    @Keep
-    override fun syncDownloads(): Double = core.syncDownloads().toDouble()
-
-    // Playback Source Preference
-    @DoNotStrip
-    @Keep
-    override fun setPlaybackSourcePreference(preference: PlaybackSource) {
-        core.setPlaybackSourcePreference(preference)
-    }
-
-    @DoNotStrip
-    @Keep
+    // ── Playback source ───────────────────────────────────────────────────────
+    override fun setPlaybackSourcePreference(preference: PlaybackSource) = core.setPlaybackSourcePreference(preference)
     override fun getPlaybackSourcePreference(): PlaybackSource = core.getPlaybackSourcePreference()
 
-    @DoNotStrip
-    @Keep
-    override fun getEffectiveUrl(track: TrackItem): String = core.getEffectiveUrl(track)
-
-    // Event Callbacks
-    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)
-    }
+    // ── 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

@@ -4,6 +4,7 @@ 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.core.Promise
 import com.margelo.nitro.nitroplayer.equalizer.EqualizerCore
 
 @DoNotStrip
@@ -12,94 +13,37 @@ 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
+        val context = NitroModules.applicationContext
+            ?: throw IllegalStateException("React Context is not initialized")
         core = EqualizerCore.getInstance(context)
         core.ensureInitialized()
     }
 
-    @DoNotStrip
-    @Keep
-    override fun setEnabled(enabled: Boolean): Boolean = core.setEnabled(enabled)
-
-    @DoNotStrip
-    @Keep
+    // ── Sync reads ────────────────────────────────────────────────────────────
     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)
+        return if (name != null) Variant_NullType_String.create(name)
+        else Variant_NullType_String.create(NullType.NULL)
     }
 
-    override fun onBandChange(callback: (bands: Array<EqualizerBand>) -> Unit) {
-        core.addOnBandChangeListener(callback)
-    }
-
-    override fun onPresetChange(callback: (presetName: Variant_NullType_String?) -> Unit) {
-        core.addOnPresetChangeListener(callback)
-    }
+    // ── 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 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)
 }