react-native-mp3 0.1.0

package/android/src/main/java/com/reactnativemp3/modules/PlayerModule.kt

@@ -0,0 +1,710 @@
+package com.reactnativemp3.modules
+
+import android.content.Context
+import android.media.AudioAttributes
+import android.media.AudioFocusRequest
+import android.media.AudioManager
+import android.media.MediaPlayer
+import android.media.audiofx.Equalizer
+import android.net.Uri
+import android.os.Build
+import android.os.Handler
+import android.os.Looper
+import androidx.annotation.RequiresApi
+import com.facebook.react.bridge.*
+import com.facebook.react.modules.core.DeviceEventManagerModule
+import com.reactnativemp3.Mp3TurboModule
+import com.reactnativemp3.database.MusicDatabase
+import com.reactnativemp3.database.entities.SongEntity
+import com.reactnativemp3.services.MusicService
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.SupervisorJob
+import kotlinx.coroutines.launch
+import java.util.*
+
+@ReactModule(name = PlayerModule.NAME)
+class PlayerModule(reactContext: ReactApplicationContext) :
+    Mp3TurboModule(reactContext, NAME) {
+    
+    companion object {
+        const val NAME = "PlayerModule"
+        
+        private const val EVENT_PLAYBACK_STATE_CHANGED = "PLAYBACK_STATE_CHANGED"
+        private const val EVENT_PLAYBACK_QUEUE_CHANGED = "PLAYBACK_QUEUE_CHANGED"
+        private const val EVENT_PLAYBACK_ERROR = "PLAYBACK_ERROR"
+        private const val EVENT_PLAYBACK_COMPLETE = "PLAYBACK_COMPLETE"
+        private const val EVENT_PLAYBACK_NEXT = "PLAYBACK_NEXT"
+        private const val EVENT_PLAYBACK_PREVIOUS = "PLAYBACK_PREVIOUS"
+        private const val EVENT_EQUALIZER_CHANGED = "EQUALIZER_CHANGED"
+        
+        private const val UPDATE_INTERVAL_MS = 250L
+    }
+    
+    private lateinit var database: MusicDatabase
+    private lateinit var audioManager: AudioManager
+    private var mediaPlayer: MediaPlayer? = null
+    private var equalizer: Equalizer? = null
+    
+    private val scope = CoroutineScope(Dispatchers.IO + SupervisorJob())
+    private val handler = Handler(Looper.getMainLooper())
+    private val updateRunnable = Runnable { updatePlaybackState() }
+    
+    private var currentSong: SongEntity? = null
+    private var queue: MutableList<SongEntity> = mutableListOf()
+    private var queuePosition: Int = -1
+    
+    private var isPlaying: Boolean = false
+    private var repeatMode: String = "none" // none, one, all
+    private var shuffleMode: Boolean = false
+    private var volume: Float = 1.0f
+    private var playbackRate: Float = 1.0f
+    
+    private var audioFocusRequest: Any? = null // AudioFocusRequest for API 26+
+    private var audioFocusGranted: Boolean = false
+    
+    override fun initialize() {
+        super.initialize()
+        database = MusicDatabase.getInstance(reactApplicationContext)
+        audioManager = reactApplicationContext.getSystemService(Context.AUDIO_SERVICE) as AudioManager
+    }
+    
+    @ReactMethod
+    fun play(uri: String, promise: Promise) {
+        scope.launch {
+            try {
+                val context = reactApplicationContext ?: throw Exception("Context not available")
+                
+                // Find song in database
+                val song = database.songDao().getAllSongs().first()
+                    .find { it.uri == uri || it.path == uri }
+                
+                if (song == null) {
+                    promise.reject("SONG_NOT_FOUND", "Song not found in database")
+                    return@launch
+                }
+                
+                currentSong = song
+                queuePosition = queue.indexOfFirst { it.id == song.id }
+                if (queuePosition == -1) {
+                    queue = mutableListOf(song)
+                    queuePosition = 0
+                    emitQueueChanged()
+                }
+                
+                prepareAndPlay(song, promise)
+            } catch (e: Exception) {
+                promise.reject("PLAY_ERROR", "Failed to play song", e)
+            }
+        }
+    }
+    
+    @ReactMethod
+    fun playFromQueue(index: Int) {
+        if (index < 0 || index >= queue.size) return
+        
+        scope.launch {
+            try {
+                val song = queue[index]
+                currentSong = song
+                queuePosition = index
+                prepareAndPlay(song, null)
+            } catch (e: Exception) {
+                emitPlaybackError("Failed to play from queue: ${e.message}")
+            }
+        }
+    }
+    
+    @ReactMethod
+    fun pause() {
+        mediaPlayer?.pause()
+        isPlaying = false
+        stopProgressUpdates()
+        emitPlaybackStateChanged()
+    }
+    
+    @ReactMethod
+    fun stop() {
+        mediaPlayer?.stop()
+        mediaPlayer?.release()
+        mediaPlayer = null
+        equalizer?.release()
+        equalizer = null
+        
+        isPlaying = false
+        stopProgressUpdates()
+        releaseAudioFocus()
+        emitPlaybackStateChanged()
+    }
+    
+    @ReactMethod
+    fun seekTo(position: Double) {
+        mediaPlayer?.seekTo(position.toInt())
+        emitPlaybackStateChanged()
+    }
+    
+    @ReactMethod
+    fun skipToNext() {
+        if (queue.isEmpty() || queuePosition == -1) return
+        
+        var nextPosition = queuePosition + 1
+        
+        when {
+            shuffleMode -> {
+                nextPosition = Random().nextInt(queue.size)
+            }
+            repeatMode == "one" -> {
+                // Play same song again
+                currentSong?.let { prepareAndPlay(it, null) }
+                return
+            }
+            nextPosition >= queue.size -> {
+                if (repeatMode == "all") {
+                    nextPosition = 0
+                } else {
+                    stop()
+                    return
+                }
+            }
+        }
+        
+        playFromQueue(nextPosition)
+        emitEvent(EVENT_PLAYBACK_NEXT, null)
+    }
+    
+    @ReactMethod
+    fun skipToPrevious() {
+        if (queue.isEmpty() || queuePosition == -1) return
+        
+        val currentTime = mediaPlayer?.currentPosition ?: 0
+        if (currentTime > 3000) {
+            // If more than 3 seconds into the song, restart it
+            seekTo(0.0)
+            return
+        }
+        
+        var prevPosition = queuePosition - 1
+        
+        when {
+            shuffleMode -> {
+                prevPosition = Random().nextInt(queue.size)
+            }
+            prevPosition < 0 -> {
+                if (repeatMode == "all") {
+                    prevPosition = queue.size - 1
+                } else {
+                    // Already at first song, just restart it
+                    seekTo(0.0)
+                    return
+                }
+            }
+        }
+        
+        playFromQueue(prevPosition)
+        emitEvent(EVENT_PLAYBACK_PREVIOUS, null)
+    }
+    
+    @ReactMethod
+    fun setVolume(volume: Double) {
+        this.volume = volume.toFloat()
+        mediaPlayer?.setVolume(volume.toFloat(), volume.toFloat())
+    }
+    
+    @ReactMethod
+    fun setPlaybackRate(rate: Double) {
+        this.playbackRate = rate.toFloat()
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
+            mediaPlayer?.playbackParams = mediaPlayer?.playbackParams?.setSpeed(rate.toFloat())
+        }
+    }
+    
+    @ReactMethod
+    fun setQueue(songs: ReadableArray) {
+        scope.launch {
+            try {
+                queue.clear()
+                for (i in 0 until songs.size()) {
+                    val songMap = songs.getMap(i)
+                    val songId = songMap?.getString("id") ?: continue
+                    
+                    val song = database.songDao().getById(songId)
+                    if (song != null) {
+                        queue.add(song)
+                    }
+                }
+                
+                queuePosition = -1
+                currentSong = null
+                emitQueueChanged()
+            } catch (e: Exception) {
+                emitPlaybackError("Failed to set queue: ${e.message}")
+            }
+        }
+    }
+    
+    @ReactMethod
+    fun addToQueue(songs: ReadableArray) {
+        scope.launch {
+            try {
+                for (i in 0 until songs.size()) {
+                    val songMap = songs.getMap(i)
+                    val songId = songMap?.getString("id") ?: continue
+                    
+                    val song = database.songDao().getById(songId)
+                    if (song != null) {
+                        queue.add(song)
+                    }
+                }
+                
+                emitQueueChanged()
+            } catch (e: Exception) {
+                emitPlaybackError("Failed to add to queue: ${e.message}")
+            }
+        }
+    }
+    
+    @ReactMethod
+    fun clearQueue() {
+        queue.clear()
+        queuePosition = -1
+        currentSong = null
+        emitQueueChanged()
+    }
+    
+    @ReactMethod
+    fun getQueue(promise: Promise) {
+        val result = Arguments.createArray()
+        queue.forEach { song ->
+            result.pushMap(convertSongToMap(song))
+        }
+        promise.resolve(result)
+    }
+    
+    @ReactMethod
+    fun getCurrentTrack(promise: Promise) {
+        currentSong?.let {
+            promise.resolve(convertSongToMap(it))
+        } ?: promise.resolve(null)
+    }
+    
+    @ReactMethod
+    fun getPlaybackState(promise: Promise) {
+        val state = Arguments.createMap()
+        state.putBoolean("isPlaying", isPlaying)
+        state.putDouble("currentTime", (mediaPlayer?.currentPosition ?: 0).toDouble())
+        state.putDouble("duration", (mediaPlayer?.duration ?: 0).toDouble())
+        state.putDouble("volume", volume.toDouble())
+        state.putDouble("playbackRate", playbackRate.toDouble())
+        state.putString("repeatMode", repeatMode)
+        state.putBoolean("shuffleMode", shuffleMode)
+        
+        currentSong?.let {
+            state.putMap("currentSong", convertSongToMap(it))
+        }
+        
+        val queueArray = Arguments.createArray()
+        queue.forEach { song ->
+            queueArray.pushMap(convertSongToMap(song))
+        }
+        state.putArray("queue", queueArray)
+        state.putInt("queuePosition", queuePosition)
+        
+        promise.resolve(state)
+    }
+    
+    @ReactMethod
+    fun getCurrentTime(promise: Promise) {
+        promise.resolve((mediaPlayer?.currentPosition ?: 0).toDouble())
+    }
+    
+    @ReactMethod
+    fun getDuration(promise: Promise) {
+        promise.resolve((mediaPlayer?.duration ?: 0).toDouble())
+    }
+    
+    @ReactMethod
+    fun isPlaying(promise: Promise) {
+        promise.resolve(isPlaying)
+    }
+    
+    @ReactMethod
+    fun setRepeatMode(mode: String) {
+        repeatMode = when (mode) {
+            "none", "one", "all" -> mode
+            else -> "none"
+        }
+        emitPlaybackStateChanged()
+    }
+    
+    @ReactMethod
+    fun setShuffleMode(enabled: Boolean) {
+        shuffleMode = enabled
+        emitPlaybackStateChanged()
+    }
+    
+    @ReactMethod
+    fun setEqualizerPreset(preset: String) {
+        equalizer?.let { eq ->
+            val presetId = when (preset.toLowerCase(Locale.US)) {
+                "normal" -> 0
+                "rock" -> 1
+                "pop" -> 2
+                "jazz" -> 3
+                "classic" -> 4
+                "dance" -> 5
+                else -> -1
+            }
+            
+            if (presetId >= 0) {
+                try {
+                    eq.usePreset(presetId.toShort())
+                    emitEqualizerChanged(preset, null)
+                } catch (e: Exception) {
+                    // Preset not available
+                }
+            }
+        }
+    }
+    
+    @ReactMethod
+    fun setEqualizerBands(bands: ReadableArray) {
+        equalizer?.let { eq ->
+            for (i in 0 until bands.size()) {
+                val bandValue = bands.getInt(i)
+                try {
+                    eq.setBandLevel(i.toShort(), bandValue.toShort())
+                } catch (e: Exception) {
+                    // Band index out of range
+                }
+            }
+            emitEqualizerChanged(null, bands)
+        }
+    }
+    
+    @ReactMethod
+    fun getEqualizerPresets(promise: Promise) {
+        val presets = Arguments.createArray()
+        
+        equalizer?.let { eq ->
+            val numberOfPresets = eq.numberOfPresets
+            for (i in 0 until numberOfPresets) {
+                val presetName = eq.getPresetName(i.toShort())
+                presets.pushString(presetName)
+            }
+        }
+        
+        promise.resolve(presets)
+    }
+    
+    @ReactMethod
+    fun enableEqualizer(enabled: Boolean) {
+        if (enabled) {
+            if (equalizer == null && mediaPlayer != null) {
+                try {
+                    equalizer = Equalizer(0, mediaPlayer!!.audioSessionId)
+                    equalizer?.enabled = true
+                } catch (e: Exception) {
+                    emitPlaybackError("Failed to enable equalizer: ${e.message}")
+                }
+            }
+        } else {
+            equalizer?.enabled = false
+        }
+        
+        val params = Arguments.createMap()
+        params.putBoolean("enabled", enabled)
+        emitEvent(EVENT_EQUALIZER_CHANGED, params)
+    }
+    
+    @ReactMethod
+    fun setSleepTimer(minutes: Int) {
+        // Implement sleep timer logic
+        handler.postDelayed({
+            pause()
+        }, (minutes * 60 * 1000).toLong())
+    }
+    
+    @ReactMethod
+    fun cancelSleepTimer() {
+        handler.removeCallbacksAndMessages(null)
+    }
+    
+    @ReactMethod
+    fun setupBackgroundPlayback(config: ReadableMap) {
+        val context = reactApplicationContext ?: return
+        
+        // Start foreground service for background playback
+        val serviceIntent = MusicService.createIntent(context)
+        
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
+            context.startForegroundService(serviceIntent)
+        } else {
+            context.startService(serviceIntent)
+        }
+    }
+    
+    @ReactMethod
+    fun stopBackgroundPlayback() {
+        val context = reactApplicationContext ?: return
+        val serviceIntent = MusicService.createIntent(context)
+        context.stopService(serviceIntent)
+    }
+    
+    override fun onCatalystInstanceDestroy() {
+        super.onCatalystInstanceDestroy()
+        stop()
+        handler.removeCallbacksAndMessages(null)
+        scope.cancel()
+    }
+    
+    // Private helper methods
+    
+    private fun prepareAndPlay(song: SongEntity, promise: Promise?) {
+        try {
+            // Release previous player
+            mediaPlayer?.release()
+            equalizer?.release()
+            
+            // Create new media player
+            val player = MediaPlayer().apply {
+                setAudioAttributes(
+                    AudioAttributes.Builder()
+                        .setUsage(AudioAttributes.USAGE_MEDIA)
+                        .setContentType(AudioAttributes.CONTENT_TYPE_MUSIC)
+                        .build()
+                )
+                
+                setDataSource(reactApplicationContext, Uri.parse(song.uri))
+                setVolume(volume, volume)
+                
+                setOnPreparedListener {
+                    requestAudioFocus()
+                    it.start()
+                    isPlaying = true
+                    startProgressUpdates()
+                    
+                    // Update play count in database
+                    scope.launch {
+                        database.songDao().incrementPlayCount(
+                            song.id,
+                            System.currentTimeMillis()
+                        )
+                    }
+                    
+                    promise?.resolve(null)
+                    emitPlaybackStateChanged()
+                }
+                
+                setOnCompletionListener {
+                    onPlaybackComplete()
+                }
+                
+                setOnErrorListener { _, what, extra ->
+                    emitPlaybackError("MediaPlayer error: what=$what, extra=$extra")
+                    false
+                }
+                
+                prepareAsync()
+            }
+            
+            mediaPlayer = player
+            
+            // Initialize equalizer
+            try {
+                equalizer = Equalizer(0, player.audioSessionId)
+                equalizer?.enabled = true
+            } catch (e: Exception) {
+                // Equalizer not supported on this device
+            }
+            
+        } catch (e: Exception) {
+            promise?.reject("PLAYBACK_ERROR", "Failed to prepare media player", e)
+            emitPlaybackError("Failed to prepare media player: ${e.message}")
+        }
+    }
+    
+    private fun requestAudioFocus() {
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
+            requestAudioFocusV26()
+        } else {
+            requestAudioFocusLegacy()
+        }
+    }
+    
+    @Suppress("DEPRECATION")
+    private fun requestAudioFocusLegacy() {
+        val result = audioManager.requestAudioFocus(
+            { focusChange ->
+                when (focusChange) {
+                    AudioManager.AUDIOFOCUS_LOSS -> {
+                        // Lost focus for an indefinite period
+                        pause()
+                        releaseAudioFocus()
+                    }
+                    AudioManager.AUDIOFOCUS_LOSS_TRANSIENT -> {
+                        // Lost focus for a short time
+                        pause()
+                    }
+                    AudioManager.AUDIOFOCUS_LOSS_TRANSIENT_CAN_DUCK -> {
+                        // Lost focus but can play at lower volume
+                        mediaPlayer?.setVolume(volume * 0.2f, volume * 0.2f)
+                    }
+                    AudioManager.AUDIOFOCUS_GAIN -> {
+                        // Gained focus
+                        mediaPlayer?.setVolume(volume, volume)
+                        if (isPlaying) {
+                            mediaPlayer?.start()
+                        }
+                    }
+                }
+            },
+            AudioManager.STREAM_MUSIC,
+            AudioManager.AUDIOFOCUS_GAIN
+        )
+        
+        audioFocusGranted = result == AudioManager.AUDIOFOCUS_REQUEST_GRANTED
+    }
+    
+    @RequiresApi(Build.VERSION_CODES.O)
+    private fun requestAudioFocusV26() {
+        val audioAttributes = AudioAttributes.Builder()
+            .setUsage(AudioAttributes.USAGE_MEDIA)
+            .setContentType(AudioAttributes.CONTENT_TYPE_MUSIC)
+            .build()
+        
+        val focusRequest = AudioFocusRequest.Builder(AudioManager.AUDIOFOCUS_GAIN)
+            .setAudioAttributes(audioAttributes)
+            .setAcceptsDelayedFocusGain(true)
+            .setOnAudioFocusChangeListener { focusChange ->
+                when (focusChange) {
+                    AudioManager.AUDIOFOCUS_LOSS -> {
+                        pause()
+                        releaseAudioFocus()
+                    }
+                    AudioManager.AUDIOFOCUS_LOSS_TRANSIENT -> {
+                        pause()
+                    }
+                    AudioManager.AUDIOFOCUS_LOSS_TRANSIENT_CAN_DUCK -> {
+                        mediaPlayer?.setVolume(volume * 0.2f, volume * 0.2f)
+                    }
+                    AudioManager.AUDIOFOCUS_GAIN -> {
+                        mediaPlayer?.setVolume(volume, volume)
+                        if (isPlaying) {
+                            mediaPlayer?.start()
+                        }
+                    }
+                }
+            }
+            .build()
+        
+        val result = audioManager.requestAudioFocus(focusRequest)
+        audioFocusGranted = result == AudioManager.AUDIOFOCUS_REQUEST_GRANTED
+        audioFocusRequest = focusRequest
+    }
+    
+    private fun releaseAudioFocus() {
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
+            (audioFocusRequest as? AudioFocusRequest)?.let {
+                audioManager.abandonAudioFocusRequest(it)
+            }
+        } else {
+            audioManager.abandonAudioFocus(null)
+        }
+        audioFocusGranted = false
+    }
+    
+    private fun onPlaybackComplete() {
+        emitEvent(EVENT_PLAYBACK_COMPLETE, null)
+        skipToNext()
+    }
+    
+    private fun startProgressUpdates() {
+        handler.postDelayed(updateRunnable, UPDATE_INTERVAL_MS)
+    }
+    
+    private fun stopProgressUpdates() {
+        handler.removeCallbacks(updateRunnable)
+    }
+    
+    private fun updatePlaybackState() {
+        if (isPlaying) {
+            emitPlaybackStateChanged()
+            handler.postDelayed(updateRunnable, UPDATE_INTERVAL_MS)
+        }
+    }
+    
+    private fun emitPlaybackStateChanged() {
+        val params = Arguments.createMap()
+        params.putBoolean("isPlaying", isPlaying)
+        params.putDouble("currentTime", (mediaPlayer?.currentPosition ?: 0).toDouble())
+        params.putDouble("duration", (mediaPlayer?.duration ?: 0).toDouble())
+        params.putDouble("volume", volume.toDouble())
+        params.putDouble("playbackRate", playbackRate.toDouble())
+        emitEvent(EVENT_PLAYBACK_STATE_CHANGED, params)
+    }
+    
+    private fun emitQueueChanged() {
+        val params = Arguments.createMap()
+        val queueArray = Arguments.createArray()
+        queue.forEach { song ->
+            queueArray.pushMap(convertSongToMap(song))
+        }
+        params.putArray("queue", queueArray)
+        params.putInt("position", queuePosition)
+        emitEvent(EVENT_PLAYBACK_QUEUE_CHANGED, params)
+    }
+    
+    private fun emitPlaybackError(message: String?) {
+        val params = Arguments.createMap()
+        params.putString("error", message ?: "Unknown error")
+        currentSong?.let {
+            params.putString("songId", it.id)
+        }
+        emitEvent(EVENT_PLAYBACK_ERROR, params)
+    }
+    
+    private fun emitEqualizerChanged(preset: String?, bands: ReadableArray?) {
+        val params = Arguments.createMap()
+        params.putBoolean("enabled", equalizer?.enabled ?: false)
+        preset?.let { params.putString("preset", it) }
+        bands?.let { params.putArray("bands", it) }
+        emitEvent(EVENT_EQUALIZER_CHANGED, params)
+    }
+    
+    private fun convertSongToMap(song: SongEntity): WritableMap {
+        val map = Arguments.createMap()
+        map.putString("id", song.id)
+        map.putString("title", song.title)
+        map.putString("artist", song.artist)
+        map.putString("album", song.album)
+        map.putDouble("duration", song.duration.toDouble())
+        map.putString("path", song.path)
+        map.putString("uri", song.uri)
+        map.putString("albumArtUri", song.albumArtUri)
+        map.putDouble("size", song.size.toDouble())
+        map.putString("mimeType", song.mimeType)
+        map.putInt("trackNumber", song.trackNumber)
+        map.putInt("year", song.year ?: 0)
+        map.putString("genre", song.genre)
+        map.putDouble("dateAdded", song.dateAdded.toDouble())
+        map.putDouble("lastModified", song.lastModified.toDouble())
+        map.putBoolean("isFavorite", song.isFavorite)
+        map.putInt("playCount", song.playCount)
+        map.putDouble("lastPlayed", song.lastPlayed?.toDouble() ?: 0.0)
+        map.putInt("bitrate", song.bitrate ?: 0)
+        map.putInt("sampleRate", song.sampleRate ?: 0)
+        map.putInt("channels", song.channels ?: 2)
+        map.putString("composer", song.composer)
+        map.putDouble("bookmark", song.bookmark.toDouble())
+        map.putBoolean("isPodcast", song.isPodcast)
+        map.putInt("rating", song.rating ?: 0)
+        
+        return map
+    }
+    
+    private fun emitEvent(eventName: String, params: WritableMap?) {
+        reactApplicationContext
+            ?.getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter::class.java)
+            ?.emit(eventName, params)
+    }
+}