react-native-nitro-player 0.3.0-alpha.9 → 0.4.0

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

@@ -0,0 +1,225 @@
+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.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")
+        core = DownloadManagerCore.getInstance(context)
+    }
+
+    // Configuration
+    @DoNotStrip
+    @Keep
+    override fun configure(config: DownloadConfig) {
+        core.configure(config)
+    }
+
+    @DoNotStrip
+    @Keep
+    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
+    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)
+        }
+    }
+
+    @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)
+
+    @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 {
+        val track = core.getDownloadedTrack(trackId)
+        return if (track != null) {
+            Variant_NullType_DownloadedTrack.create(track)
+        } else {
+            Variant_NullType_DownloadedTrack.create(NullType.NULL)
+        }
+    }
+
+    @DoNotStrip
+    @Keep
+    override fun getAllDownloadedTracks(): Array<DownloadedTrack> = core.getAllDownloadedTracks()
+
+    @DoNotStrip
+    @Keep
+    override fun getDownloadedPlaylist(playlistId: String): Variant_NullType_DownloadedPlaylist {
+        val playlist = core.getDownloadedPlaylist(playlistId)
+        return if (playlist != null) {
+            Variant_NullType_DownloadedPlaylist.create(playlist)
+        } else {
+            Variant_NullType_DownloadedPlaylist.create(NullType.NULL)
+        }
+    }
+
+    @DoNotStrip
+    @Keep
+    override fun getAllDownloadedPlaylists(): Array<DownloadedPlaylist> = core.getAllDownloadedPlaylists()
+
+    @DoNotStrip
+    @Keep
+    override fun getLocalPath(trackId: String): Variant_NullType_String {
+        val path = core.getLocalPath(trackId)
+        return 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 deleteDownloadedPlaylist(playlistId: String): Promise<Unit> =
+        Promise.async {
+            core.deleteDownloadedPlaylist(playlistId)
+        }
+
+    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
+    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)
+    }
+}

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/HybridPlayerQueue.kt

@@ -10,6 +10,8 @@ import com.margelo.nitro.nitroplayer.playlist.PlaylistManager
 import java.util.UUID
 import com.margelo.nitro.nitroplayer.playlist.Playlist as InternalPlaylist
 
+@DoNotStrip
+@Keep
 class HybridPlayerQueue : HybridPlayerQueueSpec() {
     private val core: TrackPlayerCore
     private val playlistManager: PlaylistManager
@@ -20,7 +22,7 @@ class HybridPlayerQueue : HybridPlayerQueueSpec() {
         playlistManager = core.getPlaylistManager()
     }
 
-    private var playlistsChangeListener: (() -> Unit)? = null
+    private val playlistsChangeListeners = mutableListOf<() -> Unit>()
     private val playlistChangeListeners = mutableMapOf<String, () -> Unit>()
 
     @DoNotStrip
@@ -129,14 +131,12 @@ class HybridPlayerQueue : HybridPlayerQueueSpec() {
     @DoNotStrip
     @Keep
     override fun onPlaylistsChanged(callback: (playlists: Array<Playlist>, operation: QueueOperation?) -> Unit) {
-        // Remove previous listener if exists
-        playlistsChangeListener?.invoke()
-
-        // Add new listener
-        playlistsChangeListener =
+        // Add new listener and store the cleanup function
+        val removeListener =
             playlistManager.addPlaylistsChangeListener { playlists, operation ->
                 callback(playlists.map { it.toPlaylist() }.toTypedArray(), operation)
             }
+        playlistsChangeListeners.add(removeListener)
     }
 
     @DoNotStrip

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

@@ -3,8 +3,11 @@ 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
 
+@DoNotStrip
+@Keep
 class HybridTrackPlayer : HybridTrackPlayerSpec() {
     private val core: TrackPlayerCore
 
@@ -26,14 +29,13 @@ class HybridTrackPlayer : HybridTrackPlayerSpec() {
         core.pause()
     }
 
-    @DoNotStrip
-    @Keep
     override fun playSong(
         songId: String,
         fromPlaylist: String?,
-    ) {
-        core.playSong(songId, fromPlaylist)
-    }
+    ): Promise<Unit> =
+        Promise.async {
+            core.playSong(songId, fromPlaylist)
+        }
 
     @DoNotStrip
     @Keep
@@ -53,28 +55,44 @@ class HybridTrackPlayer : HybridTrackPlayerSpec() {
         core.seek(position)
     }
 
-    @DoNotStrip
-    @Keep
-    override fun getState(): PlayerState = core.getState()
+    override fun addToUpNext(trackId: String): Promise<Unit> =
+        Promise.async {
+            core.addToUpNext(trackId)
+        }
+
+    override fun playNext(trackId: String): Promise<Unit> =
+        Promise.async {
+            core.playNext(trackId)
+        }
+
+    override fun getActualQueue(): Promise<Array<TrackItem>> =
+        Promise.async {
+            core.getActualQueue().toTypedArray()
+        }
+
+    override fun getState(): Promise<PlayerState> =
+        Promise.async {
+            core.getState()
+        }
 
     @DoNotStrip
     @Keep
     override fun setRepeatMode(mode: RepeatMode): Boolean = core.setRepeatMode(mode)
 
     override fun onChangeTrack(callback: (track: TrackItem, reason: Reason?) -> Unit) {
-        core.onChangeTrack = callback
+        core.addOnChangeTrackListener(callback)
     }
 
     override fun onPlaybackStateChange(callback: (state: TrackPlayerState, reason: Reason?) -> Unit) {
-        core.onPlaybackStateChange = callback
+        core.addOnPlaybackStateChangeListener(callback)
     }
 
     override fun onSeek(callback: (position: Double, totalDuration: Double) -> Unit) {
-        core.onSeek = callback
+        core.addOnSeekListener(callback)
     }
 
     override fun onPlaybackProgressChange(callback: (position: Double, totalDuration: Double, isManuallySeeked: Boolean?) -> Unit) {
-        core.onPlaybackProgressChange = callback
+        core.addOnPlaybackProgressChangeListener(callback)
     }
 
     @DoNotStrip
@@ -98,4 +116,11 @@ class HybridTrackPlayer : HybridTrackPlayerSpec() {
     @DoNotStrip
     @Keep
     override fun setVolume(volume: Double): Boolean = core.setVolume(volume)
+
+    @DoNotStrip
+    @Keep
+    override fun skipToIndex(index: Double): Promise<Boolean> =
+        Promise.async {
+            core.skipToIndex(index.toInt())
+        }
 }