react-native-mp3 0.1.0

package/android/src/main/java/com/reactnativemp3/services/MusicService.kt

@@ -0,0 +1,309 @@
+package com.reactnativemp3.services
+
+import android.app.Notification
+import android.app.NotificationChannel
+import android.app.NotificationManager
+import android.app.PendingIntent
+import android.app.Service
+import android.content.Context
+import android.content.Intent
+import android.graphics.Bitmap
+import android.graphics.BitmapFactory
+import android.media.AudioManager
+import android.media.MediaPlayer
+import android.os.Binder
+import android.os.Build
+import android.os.IBinder
+import android.support.v4.media.session.MediaSessionCompat
+import androidx.core.app.NotificationCompat
+import androidx.media.app.NotificationCompat as MediaNotificationCompat
+import com.reactnativemp3.R
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.SupervisorJob
+import kotlinx.coroutines.launch
+import java.lang.ref.WeakReference
+
+class MusicService : Service(), AudioManager.OnAudioFocusChangeListener {
+    
+    companion object {
+        private const val NOTIFICATION_CHANNEL_ID = "music_service_channel"
+        private const val NOTIFICATION_ID = 1002
+        const val ACTION_PLAY = "com.reactnativemp3.ACTION_PLAY"
+        const val ACTION_PAUSE = "com.reactnativemp3.ACTION_PAUSE"
+        const val ACTION_NEXT = "com.reactnativemp3.ACTION_NEXT"
+        const val ACTION_PREVIOUS = "com.reactnativemp3.ACTION_PREVIOUS"
+        const val ACTION_STOP = "com.reactnativemp3.ACTION_STOP"
+        
+        fun createIntent(context: Context): Intent {
+            return Intent(context, MusicService::class.java)
+        }
+    }
+    
+    private val binder = MusicBinder()
+    private lateinit var notificationManager: NotificationManager
+    private lateinit var audioManager: AudioManager
+    private var mediaSession: MediaSessionCompat? = null
+    
+    private val scope = CoroutineScope(Dispatchers.IO + SupervisorJob())
+    
+    // Media player state
+    private var mediaPlayer: MediaPlayer? = null
+    private var isPlaying: Boolean = false
+    private var currentTitle: String = ""
+    private var currentArtist: String = ""
+    private var currentAlbum: String = ""
+    private var albumArtBitmap: Bitmap? = null
+    
+    inner class MusicBinder : Binder() {
+        fun getService(): MusicService = this@MusicService
+    }
+    
+    override fun onCreate() {
+        super.onCreate()
+        notificationManager = getSystemService(Context.NOTIFICATION_SERVICE) as NotificationManager
+        audioManager = getSystemService(Context.AUDIO_SERVICE) as AudioManager
+        createNotificationChannel()
+        setupMediaSession()
+    }
+    
+    override fun onStartCommand(intent: Intent?, flags: Int, startId: Int): Int {
+        intent?.action?.let { handleAction(it) }
+        return START_STICKY
+    }
+    
+    override fun onBind(intent: Intent?): IBinder {
+        return binder
+    }
+    
+    override fun onUnbind(intent: Intent?): Boolean {
+        stopForeground(true)
+        stopSelf()
+        return super.onUnbind(intent)
+    }
+    
+    override fun onDestroy() {
+        cleanup()
+        super.onDestroy()
+    }
+    
+    override fun onAudioFocusChange(focusChange: Int) {
+        when (focusChange) {
+            AudioManager.AUDIOFOCUS_LOSS -> {
+                // Lost audio focus for an indefinite period
+                pausePlayback()
+            }
+            AudioManager.AUDIOFOCUS_LOSS_TRANSIENT -> {
+                // Lost audio focus for a short time
+                pausePlayback()
+            }
+            AudioManager.AUDIOFOCUS_LOSS_TRANSIENT_CAN_DUCK -> {
+                // Lost focus but can play at a lower volume
+                mediaPlayer?.setVolume(0.2f, 0.2f)
+            }
+            AudioManager.AUDIOFOCUS_GAIN -> {
+                // Gained audio focus
+                mediaPlayer?.setVolume(1.0f, 1.0f)
+                if (isPlaying) {
+                    startPlayback()
+                }
+            }
+        }
+    }
+    
+    fun setPlaybackMetadata(title: String, artist: String, album: String, albumArt: Bitmap?) {
+        currentTitle = title
+        currentArtist = artist
+        currentAlbum = album
+        albumArtBitmap = albumArt
+        updateNotification()
+    }
+    
+    fun startPlayback() {
+        isPlaying = true
+        requestAudioFocus()
+        mediaPlayer?.start()
+        updateNotification()
+    }
+    
+    fun pausePlayback() {
+        isPlaying = false
+        mediaPlayer?.pause()
+        updateNotification()
+    }
+    
+    fun stopPlayback() {
+        isPlaying = false
+        mediaPlayer?.stop()
+        mediaPlayer?.release()
+        mediaPlayer = null
+        updateNotification()
+    }
+    
+    fun setMediaPlayer(player: MediaPlayer) {
+        mediaPlayer?.release()
+        mediaPlayer = player
+        isPlaying = player.isPlaying
+    }
+    
+    private fun handleAction(action: String) {
+        when (action) {
+            ACTION_PLAY -> startPlayback()
+            ACTION_PAUSE -> pausePlayback()
+            ACTION_NEXT -> {
+                // Forward to activity/receiver
+                sendBroadcast(Intent(ACTION_NEXT))
+            }
+            ACTION_PREVIOUS -> {
+                // Forward to activity/receiver
+                sendBroadcast(Intent(ACTION_PREVIOUS))
+            }
+            ACTION_STOP -> {
+                stopPlayback()
+                stopForeground(true)
+                stopSelf()
+            }
+        }
+    }
+    
+    private fun requestAudioFocus(): Boolean {
+        val result = audioManager.requestAudioFocus(
+            this,
+            AudioManager.STREAM_MUSIC,
+            AudioManager.AUDIOFOCUS_GAIN
+        )
+        return result == AudioManager.AUDIOFOCUS_REQUEST_GRANTED
+    }
+    
+    private fun createNotificationChannel() {
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
+            val channel = NotificationChannel(
+                NOTIFICATION_CHANNEL_ID,
+                "Music Playback",
+                NotificationManager.IMPORTANCE_LOW
+            ).apply {
+                description = "Shows music playback controls"
+                setShowBadge(false)
+                lockscreenVisibility = Notification.VISIBILITY_PUBLIC
+                setSound(null, null)
+            }
+            
+            notificationManager.createNotificationChannel(channel)
+        }
+    }
+    
+    private fun setupMediaSession() {
+        mediaSession = MediaSessionCompat(this, "MusicService").apply {
+            setFlags(
+                MediaSessionCompat.FLAG_HANDLES_MEDIA_BUTTONS or
+                        MediaSessionCompat.FLAG_HANDLES_TRANSPORT_CONTROLS
+            )
+            setCallback(object : MediaSessionCompat.Callback() {
+                override fun onPlay() {
+                    startPlayback()
+                }
+                
+                override fun onPause() {
+                    pausePlayback()
+                }
+                
+                override fun onSkipToNext() {
+                    sendBroadcast(Intent(ACTION_NEXT))
+                }
+                
+                override fun onSkipToPrevious() {
+                    sendBroadcast(Intent(ACTION_PREVIOUS))
+                }
+                
+                override fun onStop() {
+                    stopPlayback()
+                }
+            })
+            isActive = true
+        }
+    }
+    
+    private fun updateNotification() {
+        scope.launch {
+            val notification = buildNotification()
+            startForeground(NOTIFICATION_ID, notification)
+        }
+    }
+    
+    private suspend fun buildNotification(): Notification {
+        // Create pending intents
+        val playIntent = createPendingIntent(ACTION_PLAY)
+        val pauseIntent = createPendingIntent(ACTION_PAUSE)
+        val nextIntent = createPendingIntent(ACTION_NEXT)
+        val previousIntent = createPendingIntent(ACTION_PREVIOUS)
+        val stopIntent = createPendingIntent(ACTION_STOP)
+        
+        val builder = NotificationCompat.Builder(this, NOTIFICATION_CHANNEL_ID)
+            .setSmallIcon(R.drawable.ic_music_note)
+            .setContentTitle(currentTitle.ifEmpty { "Music Player" })
+            .setContentText(currentArtist.ifEmpty { "Unknown Artist" })
+            .setSubText(currentAlbum.ifEmpty { "Unknown Album" })
+            .setLargeIcon(albumArtBitmap)
+            .setStyle(
+                MediaNotificationCompat.MediaStyle()
+                    .setMediaSession(mediaSession?.sessionToken)
+                    .setShowActionsInCompactView(0, 1, 2)
+            )
+            .setVisibility(NotificationCompat.VISIBILITY_PUBLIC)
+            .setPriority(NotificationCompat.PRIORITY_LOW)
+            .setOngoing(isPlaying)
+            .setShowWhen(false)
+            .setAutoCancel(false)
+            .setDeleteIntent(stopIntent)
+        
+        // Add actions
+        if (isPlaying) {
+            builder.addAction(
+                R.drawable.ic_pause,
+                "Pause",
+                pauseIntent
+            )
+        } else {
+            builder.addAction(
+                R.drawable.ic_play,
+                "Play",
+                playIntent
+            )
+        }
+        
+        builder.addAction(
+            R.drawable.ic_skip_previous,
+            "Previous",
+            previousIntent
+        ).addAction(
+            R.drawable.ic_skip_next,
+            "Next",
+            nextIntent
+        )
+        
+        return builder.build()
+    }
+    
+    private fun createPendingIntent(action: String): PendingIntent {
+        val intent = Intent(action).apply {
+            setPackage(packageName)
+        }
+        
+        val flags = if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
+            PendingIntent.FLAG_UPDATE_CURRENT or PendingIntent.FLAG_IMMUTABLE
+        } else {
+            PendingIntent.FLAG_UPDATE_CURRENT
+        }
+        
+        return PendingIntent.getBroadcast(this, action.hashCode(), intent, flags)
+    }
+    
+    private fun cleanup() {
+        mediaPlayer?.release()
+        mediaPlayer = null
+        mediaSession?.release()
+        mediaSession = null
+        audioManager.abandonAudioFocus(this)
+        scope.cancel()
+    }
+}

package/android/src/main/jni/Mp3TurboModule.cpp

@@ -0,0 +1,29 @@
+#include <jni.h>
+#include <string>
+#include <fbjni/fbjni.h>
+#include <ReactCommon/TurboModuleManagerDelegate.h>
+#include <ReactCommon/CallInvokerHolder.h>
+
+#include "Mp3TurboModule.h"
+
+using namespace facebook;
+using namespace facebook::react;
+
+// JNI Methods
+extern "C" JNIEXPORT jint JNICALL JNI_OnLoad(JavaVM* vm, void*) {
+    return jni::initialize(vm, [] {
+        Mp3TurboModule::registerNatives();
+    });
+}
+
+// Module registration
+JNIEXPORT jint JNICALL JNI_OnLoad(JavaVM* vm, void* reserved) {
+    JNIEnv* env;
+    if (vm->GetEnv(reinterpret_cast<void**>(&env), JNI_VERSION_1_6) != JNI_OK) {
+        return JNI_ERR;
+    }
+    
+    // Register your native methods here
+    
+    return JNI_VERSION_1_6;
+}

package/android/src/main/res/drawable/ic_music_note.xml

@@ -0,0 +1,11 @@
+<?xml version="1.0" encoding="utf-8"?>
+<vector xmlns:android="http://schemas.android.com/apk/res/android"
+    android:width="24dp"
+    android:height="24dp"
+    android:viewportWidth="24"
+    android:viewportHeight="24">
+    
+    <path
+        android:fillColor="#FFFFFF"
+        android:pathData="M12,3L12,12.26C11.5,12.09 11,12 10.5,12C8,12 6,14 6,16.5S8,21 10.5,21 15,19 15,16.5V6h4V3H12z"/>
+</vector>

package/android/src/main/res/drawable/ic_pause.xml

@@ -0,0 +1,11 @@
+<?xml version="1.0" encoding="utf-8"?>
+<vector xmlns:android="http://schemas.android.com/apk/res/android"
+    android:width="24dp"
+    android:height="24dp"
+    android:viewportWidth="24"
+    android:viewportHeight="24">
+    
+    <path
+        android:fillColor="#FFFFFF"
+        android:pathData="M6,19h4V5H6V19zM14,5v14h4V5H14z"/>
+</vector>

package/android/src/main/res/drawable/ic_play.xml

@@ -0,0 +1,11 @@
+<?xml version="1.0" encoding="utf-8"?>
+<vector xmlns:android="http://schemas.android.com/apk/res/android"
+    android:width="24dp"
+    android:height="24dp"
+    android:viewportWidth="24"
+    android:viewportHeight="24">
+    
+    <path
+        android:fillColor="#FFFFFF"
+        android:pathData="M8,5.14V19.14L19,12.14L8,5.14Z"/>
+</vector>

package/android/src/main/res/drawable/ic_skip_next.xml

@@ -0,0 +1,11 @@
+<?xml version="1.0" encoding="utf-8"?>
+<vector xmlns:android="http://schemas.android.com/apk/res/android"
+    android:width="24dp"
+    android:height="24dp"
+    android:viewportWidth="24"
+    android:viewportHeight="24">
+    
+    <path
+        android:fillColor="#FFFFFF"
+        android:pathData="M6,18l8.5-6L6,6v12zM16,6v12h2V6h-2z"/>
+</vector>

package/android/src/main/res/drawable/ic_skip_previous.xml

@@ -0,0 +1,11 @@
+<?xml version="1.0" encoding="utf-8"?>
+<vector xmlns:android="http://schemas.android.com/apk/res/android"
+    android:width="24dp"
+    android:height="24dp"
+    android:viewportWidth="24"
+    android:viewportHeight="24">
+    
+    <path
+        android:fillColor="#FFFFFF"
+        android:pathData="M6,6h2v12H6zm3.5,6l8.5,6V6z"/>
+</vector>

package/android/src/main/res/drawable/ic_stop.xml

@@ -0,0 +1,11 @@
+<?xml version="1.0" encoding="utf-8"?>
+<vector xmlns:android="http://schemas.android.com/apk/res/android"
+    android:width="24dp"
+    android:height="24dp"
+    android:viewportWidth="24"
+    android:viewportHeight="24">
+    
+    <path
+        android:fillColor="#FFFFFF"
+        android:pathData="M6,6h12v12H6z"/>
+</vector>

package/lib/components/MusicList.js

@@ -0,0 +1 @@
+"use strict";

package/lib/components/MusicPlayerUI.js

@@ -0,0 +1 @@
+"use strict";

package/lib/hooks/useMusicPlayer.d.ts

@@ -0,0 +1,38 @@
+import type { Song, PlaybackState, PlayerOptions } from '../types/common.types';
+interface UseMusicPlayerProps {
+    autoSetup?: boolean;
+    playerOptions?: PlayerOptions;
+}
+interface UseMusicPlayerReturn {
+    playbackState: PlaybackState;
+    currentSong: Song | null;
+    queue: Song[];
+    isPlaying: boolean;
+    isLoading: boolean;
+    error: string | null;
+    play: (uri: string) => Promise<void>;
+    playSong: (song: Song) => Promise<void>;
+    playFromQueue: (index: number) => void;
+    pause: () => void;
+    stop: () => void;
+    seekTo: (position: number) => void;
+    skipToNext: () => void;
+    skipToPrevious: () => void;
+    setVolume: (volume: number) => void;
+    setPlaybackRate: (rate: number) => void;
+    setQueue: (songs: Song[]) => void;
+    addToQueue: (songs: Song[]) => void;
+    clearQueue: () => void;
+    getQueue: () => Promise<Song[]>;
+    setRepeatMode: (mode: 'none' | 'one' | 'all') => void;
+    setShuffleMode: (enabled: boolean) => void;
+    setEqualizerPreset: (preset: string) => void;
+    setEqualizerBands: (bands: number[]) => void;
+    enableEqualizer: (enabled: boolean) => void;
+    setupBackgroundPlayback: (config?: any) => void;
+    stopBackgroundPlayback: () => void;
+    setSleepTimer: (minutes: number) => void;
+    cancelSleepTimer: () => void;
+}
+export declare const useMusicPlayer: ({ autoSetup, playerOptions, }?: UseMusicPlayerProps) => UseMusicPlayerReturn;
+export {};