react-native-mp3 0.1.0

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

@@ -0,0 +1,330 @@
+package com.reactnativemp3.modules
+
+import android.content.ContentResolver
+import android.graphics.Bitmap
+import android.graphics.BitmapFactory
+import android.media.MediaMetadataRetriever
+import android.net.Uri
+import android.util.Base64
+import com.facebook.react.bridge.*
+import com.reactnativemp3.Mp3TurboModule
+import kotlinx.coroutines.*
+import java.io.ByteArrayOutputStream
+import java.io.File
+
+@ReactModule(name = MetadataModule.NAME)
+class MetadataModule(reactContext: ReactApplicationContext) :
+    Mp3TurboModule(reactContext, NAME) {
+    
+    companion object {
+        const val NAME = "MetadataModule"
+    }
+    
+    private val scope = CoroutineScope(Dispatchers.IO + SupervisorJob())
+    
+    @ReactMethod
+    fun extractMetadata(uri: String, promise: Promise) {
+        scope.launch {
+            try {
+                val metadata = extractMetadataFromUri(uri)
+                withContext(Dispatchers.Main) {
+                    promise.resolve(metadata)
+                }
+            } catch (e: Exception) {
+                withContext(Dispatchers.Main) {
+                    promise.reject("METADATA_ERROR", "Failed to extract metadata", e)
+                }
+            }
+        }
+    }
+    
+    @ReactMethod
+    fun getAlbumArt(uri: String, size: Int, promise: Promise) {
+        scope.launch {
+            try {
+                val albumArt = getAlbumArtFromUri(uri, size)
+                withContext(Dispatchers.Main) {
+                    promise.resolve(albumArt)
+                }
+            } catch (e: Exception) {
+                withContext(Dispatchers.Main) {
+                    promise.reject("ALBUM_ART_ERROR", "Failed to get album art", e)
+                }
+            }
+        }
+    }
+    
+    @ReactMethod
+    fun getLyrics(uri: String, promise: Promise) {
+        scope.launch {
+            try {
+                val lyrics = extractLyrics(uri)
+                withContext(Dispatchers.Main) {
+                    promise.resolve(lyrics)
+                }
+            } catch (e: Exception) {
+                withContext(Dispatchers.Main) {
+                    promise.reject("LYRICS_ERROR", "Failed to extract lyrics", e)
+                }
+            }
+        }
+    }
+    
+    @ReactMethod
+    fun updateMetadata(uri: String, metadata: ReadableMap, promise: Promise) {
+        // Note: Updating metadata of audio files is complex and requires external libraries
+        // This is a placeholder implementation
+        scope.launch {
+            try {
+                // For now, just return success
+                withContext(Dispatchers.Main) {
+                    promise.resolve(true)
+                }
+            } catch (e: Exception) {
+                withContext(Dispatchers.Main) {
+                    promise.reject("UPDATE_ERROR", "Failed to update metadata", e)
+                }
+            }
+        }
+    }
+    
+    private fun extractMetadataFromUri(uriString: String): WritableMap {
+        val metadata = Arguments.createMap()
+        val retriever = MediaMetadataRetriever()
+        
+        try {
+            val uri = Uri.parse(uriString)
+            
+            if (uri.scheme == ContentResolver.SCHEME_CONTENT) {
+                reactApplicationContext?.contentResolver?.let { resolver ->
+                    resolver.openFileDescriptor(uri, "r")?.use { pfd ->
+                        retriever.setDataSource(pfd.fileDescriptor)
+                    }
+                }
+            } else if (uri.scheme == ContentResolver.SCHEME_FILE) {
+                retriever.setDataSource(uri.path)
+            } else {
+                retriever.setDataSource(uriString)
+            }
+            
+            // Extract all available metadata
+            extractStandardMetadata(retriever, metadata)
+            extractExtendedMetadata(retriever, metadata)
+            
+        } finally {
+            retriever.release()
+        }
+        
+        return metadata
+    }
+    
+    private fun extractStandardMetadata(retriever: MediaMetadataRetriever, metadata: WritableMap) {
+        // Title
+        val title = retriever.extractMetadata(MediaMetadataRetriever.METADATA_KEY_TITLE)
+        metadata.putString("title", title ?: "")
+        
+        // Artist
+        val artist = retriever.extractMetadata(MediaMetadataRetriever.METADATA_KEY_ARTIST)
+        metadata.putString("artist", artist ?: "Unknown Artist")
+        
+        // Album
+        val album = retriever.extractMetadata(MediaMetadataRetriever.METADATA_KEY_ALBUM)
+        metadata.putString("album", album ?: "Unknown Album")
+        
+        // Album Artist
+        val albumArtist = retriever.extractMetadata(MediaMetadataRetriever.METADATA_KEY_ALBUMARTIST)
+        metadata.putString("albumArtist", albumArtist ?: artist)
+        
+        // Genre
+        val genre = retriever.extractMetadata(MediaMetadataRetriever.METADATA_KEY_GENRE)
+        metadata.putString("genre", genre ?: "")
+        
+        // Duration
+        val duration = retriever.extractMetadata(MediaMetadataRetriever.METADATA_KEY_DURATION)
+        metadata.putDouble("duration", duration?.toLongOrNull()?.toDouble() ?: 0.0)
+        
+        // Year
+        val year = retriever.extractMetadata(MediaMetadataRetriever.METADATA_KEY_YEAR)
+        metadata.putString("year", year ?: "")
+        
+        // Track Number
+        val trackNumber = retriever.extractMetadata(MediaMetadataRetriever.METADATA_KEY_CD_TRACK_NUMBER)
+        metadata.putString("trackNumber", trackNumber ?: "0")
+        
+        // Disc Number
+        val discNumber = retriever.extractMetadata(MediaMetadataRetriever.METADATA_KEY_DISC_NUMBER)
+        metadata.putString("discNumber", discNumber ?: "0")
+        
+        // Composer
+        val composer = retriever.extractMetadata(MediaMetadataRetriever.METADATA_KEY_COMPOSER)
+        metadata.putString("composer", composer ?: "")
+        
+        // Writer
+        val writer = retriever.extractMetadata(MediaMetadataRetriever.METADATA_KEY_WRITER)
+        metadata.putString("writer", writer ?: "")
+        
+        // Bitrate
+        val bitrate = retriever.extractMetadata(MediaMetadataRetriever.METADATA_KEY_BITRATE)
+        metadata.putInt("bitrate", bitrate?.toIntOrNull() ?: 0)
+        
+        // Sample Rate
+        val sampleRate = retriever.extractMetadata(MediaMetadataRetriever.METADATA_KEY_SAMPLERATE)
+        metadata.putInt("sampleRate", sampleRate?.toIntOrNull() ?: 0)
+        
+        // Channels
+        val channels = retriever.extractMetadata(MediaMetadataRetriever.METADATA_KEY_NUM_TRACKS)
+        metadata.putInt("channels", channels?.toIntOrNull() ?: 2)
+        
+        // MIME Type
+        val mimeType = retriever.extractMetadata(MediaMetadataRetriever.METADATA_KEY_MIMETYPE)
+        metadata.putString("mimeType", mimeType ?: "audio/mpeg")
+    }
+    
+    private fun extractExtendedMetadata(retriever: MediaMetadataRetriever, metadata: WritableMap) {
+        // Lyrics (embedded)
+        val lyrics = retriever.extractMetadata(MediaMetadataRetriever.METADATA_KEY_LYRICIST)
+        metadata.putString("lyrics", lyrics ?: "")
+        
+        // Has Album Art
+        val picture = retriever.embeddedPicture
+        metadata.putBoolean("hasEmbeddedArt", picture != null)
+        
+        // Location (GPS coordinates if available in some audio formats)
+        val location = retriever.extractMetadata(MediaMetadataRetriever.METADATA_KEY_LOCATION)
+        metadata.putString("location", location ?: "")
+        
+        // Copyright
+        val copyright = retriever.extractMetadata(MediaMetadataRetriever.METADATA_KEY_COPYRIGHT)
+        metadata.putString("copyright", copyright ?: "")
+        
+        // Encoder
+        val encoder = retriever.extractMetadata(MediaMetadataRetriever.METADATA_KEY_ENCODER)
+        metadata.putString("encoder", encoder ?: "")
+        
+        // Date
+        val date = retriever.extractMetadata(MediaMetadataRetriever.METADATA_KEY_DATE)
+        metadata.putString("date", date ?: "")
+        
+        // Capturing information for podcasts/audiobooks
+        val captureSessionId = retriever.extractMetadata(MediaMetadataRetriever.METADATA_KEY_CAPTURE_SESSION_ID)
+        metadata.putString("captureSessionId", captureSessionId ?: "")
+    }
+    
+    private fun getAlbumArtFromUri(uriString: String, size: Int): String {
+        val retriever = MediaMetadataRetriever()
+        
+        try {
+            val uri = Uri.parse(uriString)
+            
+            if (uri.scheme == ContentResolver.SCHEME_CONTENT) {
+                reactApplicationContext?.contentResolver?.let { resolver ->
+                    resolver.openFileDescriptor(uri, "r")?.use { pfd ->
+                        retriever.setDataSource(pfd.fileDescriptor)
+                    }
+                }
+            } else if (uri.scheme == ContentResolver.SCHEME_FILE) {
+                retriever.setDataSource(uri.path)
+            } else {
+                retriever.setDataSource(uriString)
+            }
+            
+            // Try to get embedded picture
+            val picture = retriever.embeddedPicture
+            if (picture != null) {
+                return encodeBitmapToBase64(picture, size)
+            }
+            
+            // If no embedded picture, try to get album art from MediaStore
+            val albumId = retriever.extractMetadata(MediaMetadataRetriever.METADATA_KEY_ALBUM)
+            if (albumId != null) {
+                // Try to find album art in MediaStore
+                // This is simplified - in real implementation you'd query MediaStore
+            }
+            
+        } finally {
+            retriever.release()
+        }
+        
+        return ""
+    }
+    
+    private fun encodeBitmapToBase64(picture: ByteArray, targetSize: Int): String {
+        try {
+            // Decode the bitmap
+            val options = BitmapFactory.Options()
+            options.inJustDecodeBounds = true
+            BitmapFactory.decodeByteArray(picture, 0, picture.size, options)
+            
+            // Calculate inSampleSize
+            options.inSampleSize = calculateInSampleSize(options, targetSize, targetSize)
+            options.inJustDecodeBounds = false
+            
+            // Decode bitmap with sampling
+            val bitmap = BitmapFactory.decodeByteArray(picture, 0, picture.size, options)
+                ?: return ""
+            
+            // Compress to JPEG
+            val outputStream = ByteArrayOutputStream()
+            bitmap.compress(Bitmap.CompressFormat.JPEG, 80, outputStream)
+            val compressedBytes = outputStream.toByteArray()
+            
+            // Encode to Base64
+            return Base64.encodeToString(compressedBytes, Base64.DEFAULT)
+            
+        } catch (e: Exception) {
+            return ""
+        }
+    }
+    
+    private fun calculateInSampleSize(
+        options: BitmapFactory.Options,
+        reqWidth: Int,
+        reqHeight: Int
+    ): Int {
+        val height = options.outHeight
+        val width = options.outWidth
+        var inSampleSize = 1
+        
+        if (height > reqHeight || width > reqWidth) {
+            val halfHeight = height / 2
+            val halfWidth = width / 2
+            
+            while (halfHeight / inSampleSize >= reqHeight && halfWidth / inSampleSize >= reqWidth) {
+                inSampleSize *= 2
+            }
+        }
+        
+        return inSampleSize
+    }
+    
+    private fun extractLyrics(uriString: String): String? {
+        val retriever = MediaMetadataRetriever()
+        
+        try {
+            val uri = Uri.parse(uriString)
+            
+            if (uri.scheme == ContentResolver.SCHEME_CONTENT) {
+                reactApplicationContext?.contentResolver?.let { resolver ->
+                    resolver.openFileDescriptor(uri, "r")?.use { pfd ->
+                        retriever.setDataSource(pfd.fileDescriptor)
+                    }
+                }
+            } else if (uri.scheme == ContentResolver.SCHEME_FILE) {
+                retriever.setDataSource(uri.path)
+            } else {
+                retriever.setDataSource(uriString)
+            }
+            
+            // Try to get lyrics from metadata
+            return retriever.extractMetadata(MediaMetadataRetriever.METADATA_KEY_LYRICIST)
+            
+        } finally {
+            retriever.release()
+        }
+    }
+    
+    override fun onCatalystInstanceDestroy() {
+        super.onCatalystInstanceDestroy()
+        scope.cancel()
+    }
+}

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

@@ -0,0 +1,236 @@
+package com.reactnativemp3.modules
+
+import android.app.*
+import android.content.Context
+import android.content.Intent
+import android.graphics.Bitmap
+import android.graphics.BitmapFactory
+import android.os.Build
+import android.support.v4.media.session.MediaSessionCompat
+import androidx.core.app.NotificationCompat
+import androidx.media.app.NotificationCompat as MediaNotificationCompat
+import com.facebook.react.bridge.*
+import com.reactnativemp3.Mp3TurboModule
+import com.reactnativemp3.R
+import kotlinx.coroutines.*
+import java.net.URL
+
+@ReactModule(name = NotificationModule.NAME)
+class NotificationModule(reactContext: ReactApplicationContext) :
+    Mp3TurboModule(reactContext, NAME) {
+    
+    companion object {
+        const val NAME = "NotificationModule"
+        const val NOTIFICATION_CHANNEL_ID = "music_player_channel"
+        const val NOTIFICATION_ID = 1001
+        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"
+    }
+    
+    private val scope = CoroutineScope(Dispatchers.IO + SupervisorJob())
+    private lateinit var notificationManager: NotificationManager
+    private var mediaSession: MediaSessionCompat? = null
+    private var currentNotification: Notification? = null
+    
+    override fun initialize() {
+        super.initialize()
+        notificationManager = reactApplicationContext
+            .getSystemService(Context.NOTIFICATION_SERVICE) as NotificationManager
+        setupNotificationChannel()
+    }
+    
+    @ReactMethod
+    fun setupNotificationChannel() {
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
+            val channel = NotificationChannel(
+                NOTIFICATION_CHANNEL_ID,
+                "Music Player",
+                NotificationManager.IMPORTANCE_LOW
+            ).apply {
+                description = "Music playback controls"
+                setShowBadge(false)
+                lockscreenVisibility = Notification.VISIBILITY_PUBLIC
+                setSound(null, null)
+            }
+            
+            notificationManager.createNotificationChannel(channel)
+        }
+    }
+    
+    @ReactMethod
+    fun updateNotification(metadata: ReadableMap) {
+        scope.launch {
+            try {
+                val notification = buildNotification(metadata)
+                currentNotification = notification
+                
+                withContext(Dispatchers.Main) {
+                    notificationManager.notify(NOTIFICATION_ID, notification)
+                }
+            } catch (e: Exception) {
+                // Log error but don't crash
+                e.printStackTrace()
+            }
+        }
+    }
+    
+    @ReactMethod
+    fun showNotification() {
+        currentNotification?.let {
+            notificationManager.notify(NOTIFICATION_ID, it)
+        }
+    }
+    
+    @ReactMethod
+    fun hideNotification() {
+        notificationManager.cancel(NOTIFICATION_ID)
+    }
+    
+    @ReactMethod
+    fun setMediaSessionToken(sessionToken: String, promise: Promise) {
+        // This would be used to connect to MediaSession from service
+        promise.resolve(true)
+    }
+    
+    private suspend fun buildNotification(metadata: ReadableMap): Notification {
+        val context = reactApplicationContext ?: throw IllegalStateException("Context not available")
+        
+        // Create media session if not exists
+        if (mediaSession == null) {
+            mediaSession = MediaSessionCompat(context, "MusicPlayer").apply {
+                setFlags(MediaSessionCompat.FLAG_HANDLES_MEDIA_BUTTONS or
+                        MediaSessionCompat.FLAG_HANDLES_TRANSPORT_CONTROLS)
+            }
+        }
+        
+        // Extract metadata
+        val title = metadata.getString("title") ?: "Unknown Title"
+        val artist = metadata.getString("artist") ?: "Unknown Artist"
+        val album = metadata.getString("album") ?: "Unknown Album"
+        val albumArtUri = metadata.getString("albumArtUri")
+        val isPlaying = metadata.getBoolean("isPlaying")
+        
+        // Load album art
+        val albumArt = loadAlbumArt(albumArtUri)
+        
+        // Create pending intents for actions
+        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)
+        
+        // Build notification
+        val builder = NotificationCompat.Builder(context, NOTIFICATION_CHANNEL_ID)
+            .setSmallIcon(R.drawable.ic_music_note)
+            .setContentTitle(title)
+            .setContentText(artist)
+            .setSubText(album)
+            .setLargeIcon(albumArt)
+            .setStyle(
+                androidx.media.app.NotificationCompat.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
+        ).addAction(
+            R.drawable.ic_stop,
+            "Stop",
+            stopIntent
+        )
+        
+        return builder.build()
+    }
+    
+    private suspend fun loadAlbumArt(albumArtUri: String?): Bitmap? {
+        if (albumArtUri.isNullOrEmpty()) {
+            return null
+        }
+        
+        return withContext(Dispatchers.IO) {
+            try {
+                when {
+                    albumArtUri.startsWith("http://") || albumArtUri.startsWith("https://") -> {
+                        // Load from URL
+                        URL(albumArtUri).openStream().use { input ->
+                            BitmapFactory.decodeStream(input)
+                        }
+                    }
+                    albumArtUri.startsWith("content://") -> {
+                        // Load from content URI
+                        val uri = android.net.Uri.parse(albumArtUri)
+                        reactApplicationContext?.contentResolver?.openInputStream(uri)?.use { input ->
+                            BitmapFactory.decodeStream(input)
+                        }
+                    }
+                    albumArtUri.startsWith("file://") -> {
+                        // Load from file
+                        BitmapFactory.decodeFile(albumArtUri.removePrefix("file://"))
+                    }
+                    else -> {
+                        // Try as file path
+                        BitmapFactory.decodeFile(albumArtUri)
+                    }
+                }
+            } catch (e: Exception) {
+                // Return null if can't load
+                null
+            }
+        }
+    }
+    
+    private fun createPendingIntent(action: String): PendingIntent {
+        val context = reactApplicationContext ?: throw IllegalStateException("Context not available")
+        
+        val intent = Intent(action).apply {
+            setPackage(context.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(context, action.hashCode(), intent, flags)
+    }
+    
+    override fun onCatalystInstanceDestroy() {
+        super.onCatalystInstanceDestroy()
+        scope.cancel()
+        mediaSession?.release()
+        mediaSession = null
+    }
+}