react-native-mp3 0.1.0

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

@@ -0,0 +1,640 @@
+package com.reactnativemp3.modules
+
+import android.Manifest
+import android.content.ContentUris
+import android.content.pm.PackageManager
+import android.database.Cursor
+import android.net.Uri
+import android.os.Build
+import android.os.Environment
+import android.provider.MediaStore
+import android.provider.Settings
+import androidx.core.content.ContextCompat
+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.utils.MediaStoreUtils
+import kotlinx.coroutines.*
+import java.io.File
+import java.util.*
+
+@ReactModule(name = ScannerModule.NAME)
+class ScannerModule(reactContext: ReactApplicationContext) : 
+    Mp3TurboModule(reactContext, NAME) {
+    
+    companion object {
+        const val NAME = "ScannerModule"
+        
+        private const val PERMISSION_REQUEST_CODE = 1001
+        private const val EVENT_SCAN_PROGRESS = "SCAN_PROGRESS"
+        private const val EVENT_SCAN_COMPLETE = "SCAN_COMPLETE"
+        private const val EVENT_FILE_ADDED = "FILE_ADDED"
+        private const val EVENT_FILE_DELETED = "FILE_DELETED"
+        private const val EVENT_PERMISSION_STATUS = "PERMISSION_STATUS"
+    }
+    
+    private val scope = CoroutineScope(Dispatchers.IO + SupervisorJob())
+    private lateinit var database: MusicDatabase
+    
+    override fun initialize() {
+        super.initialize()
+        database = MusicDatabase.getInstance(reactApplicationContext)
+    }
+    
+    @ReactMethod
+    fun requestStoragePermission(promise: Promise) {
+        val context = reactApplicationContext ?: run {
+            promise.reject("NO_CONTEXT", "React context not available")
+            return
+        }
+        
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.R) {
+            // Android 11+ requires MANAGE_EXTERNAL_STORAGE
+            if (Environment.isExternalStorageManager()) {
+                promise.resolve(true)
+                emitPermissionStatus(true)
+                return
+            }
+            
+            try {
+                val intent = Intent(Settings.ACTION_MANAGE_APP_ALL_FILES_ACCESS_PERMISSION)
+                intent.addCategory("android.intent.category.DEFAULT")
+                intent.data = Uri.parse("package:${context.packageName}")
+                
+                val activity = context.currentActivity
+                if (activity != null) {
+                    activity.startActivityForResult(intent, PERMISSION_REQUEST_CODE)
+                    // We'll resolve the promise when permission is granted via callback
+                    promise.resolve(null)
+                } else {
+                    promise.reject("NO_ACTIVITY", "No activity available to request permission")
+                }
+            } catch (e: Exception) {
+                promise.reject("PERMISSION_ERROR", "Failed to request permission", e)
+            }
+        } else {
+            // Android 10 and below
+            val permissions = arrayOf(
+                Manifest.permission.READ_EXTERNAL_STORAGE,
+                Manifest.permission.WRITE_EXTERNAL_STORAGE
+            )
+            
+            val granted = permissions.all {
+                ContextCompat.checkSelfPermission(context, it) == PackageManager.PERMISSION_GRANTED
+            }
+            
+            if (granted) {
+                promise.resolve(true)
+                emitPermissionStatus(true)
+            } else {
+                val activity = context.currentActivity
+                if (activity != null) {
+                    activity.requestPermissions(permissions, PERMISSION_REQUEST_CODE)
+                    promise.resolve(null)
+                } else {
+                    promise.reject("NO_ACTIVITY", "No activity available to request permission")
+                }
+            }
+        }
+    }
+    
+    @ReactMethod
+    fun checkPermissionStatus(promise: Promise) {
+        val context = reactApplicationContext ?: run {
+            promise.reject("NO_CONTEXT", "React context not available")
+            return
+        }
+        
+        val hasPermission = if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.R) {
+            Environment.isExternalStorageManager()
+        } else {
+            ContextCompat.checkSelfPermission(
+                context, 
+                Manifest.permission.READ_EXTERNAL_STORAGE
+            ) == PackageManager.PERMISSION_GRANTED &&
+            ContextCompat.checkSelfPermission(
+                context, 
+                Manifest.permission.WRITE_EXTERNAL_STORAGE
+            ) == PackageManager.PERMISSION_GRANTED
+        }
+        
+        promise.resolve(hasPermission)
+        emitPermissionStatus(hasPermission)
+    }
+    
+    @ReactMethod
+    fun scanMusicFiles(options: ReadableMap?, promise: Promise) {
+        val context = reactApplicationContext ?: run {
+            promise.reject("NO_CONTEXT", "React context not available")
+            return
+        }
+        
+        scope.launch {
+            try {
+                val forceRescan = options?.getBoolean("forceRescan") ?: false
+                val scanPaths = if (options?.hasKey("paths") == true) {
+                    val pathsArray = options.getArray("paths")
+                    val paths = mutableListOf<String>()
+                    for (i in 0 until pathsArray!!.size()) {
+                        paths.add(pathsArray.getString(i)!!)
+                    }
+                    paths
+                } else {
+                    getDefaultMusicPaths()
+                }
+                
+                val totalSongs = scanAndSaveToDatabase(context, scanPaths, forceRescan)
+                
+                withContext(Dispatchers.Main) {
+                    val result = Arguments.createMap()
+                    result.putInt("totalSongs", totalSongs)
+                    result.putStringArray("scanPaths", scanPaths.toTypedArray())
+                    promise.resolve(result)
+                    
+                    // Emit completion event
+                    emitEvent(EVENT_SCAN_COMPLETE, result)
+                }
+            } catch (e: Exception) {
+                withContext(Dispatchers.Main) {
+                    promise.reject("SCAN_ERROR", "Failed to scan music files", e)
+                }
+            }
+        }
+    }
+    
+    @ReactMethod
+    fun getCachedSongs(options: ReadableMap?, promise: Promise) {
+        scope.launch {
+            try {
+                val limit = options?.getInt("limit") ?: 0
+                val offset = options?.getInt("offset") ?: 0
+                val sortBy = options?.getString("sortBy") ?: "title"
+                val sortOrder = options?.getString("sortOrder") ?: "asc"
+                val filter = options?.getString("filter") // album, artist, genre, favorite
+                val filterValue = options?.getString("filterValue")
+                
+                val songs = when (filter) {
+                    "album" -> database.songDao().getSongsByAlbum(filterValue ?: "").first()
+                    "artist" -> {
+                        // Need to implement this in DAO
+                        database.songDao().getAllSongs().first()
+                            .filter { it.artist == filterValue }
+                    }
+                    "genre" -> {
+                        database.songDao().getAllSongs().first()
+                            .filter { it.genre == filterValue }
+                    }
+                    "favorite" -> database.songDao().getFavorites().first()
+                    else -> database.songDao().getAllSongs().first()
+                }
+                
+                // Apply sorting
+                val sortedSongs = when (sortBy) {
+                    "title" -> if (sortOrder == "asc") 
+                        songs.sortedBy { it.title.lowercase(Locale.getDefault()) }
+                    else 
+                        songs.sortedByDescending { it.title.lowercase(Locale.getDefault()) }
+                    "artist" -> if (sortOrder == "asc")
+                        songs.sortedBy { it.artist.lowercase(Locale.getDefault()) }
+                    else
+                        songs.sortedByDescending { it.artist.lowercase(Locale.getDefault()) }
+                    "album" -> if (sortOrder == "asc")
+                        songs.sortedBy { it.album.lowercase(Locale.getDefault()) }
+                    else
+                        songs.sortedByDescending { it.album.lowercase(Locale.getDefault()) }
+                    "dateAdded" -> if (sortOrder == "asc")
+                        songs.sortedBy { it.dateAdded }
+                    else
+                        songs.sortedByDescending { it.dateAdded }
+                    "duration" -> if (sortOrder == "asc")
+                        songs.sortedBy { it.duration }
+                    else
+                        songs.sortedByDescending { it.duration }
+                    else -> songs
+                }
+                
+                // Apply pagination
+                val paginatedSongs = if (limit > 0) {
+                    sortedSongs.drop(offset).take(limit)
+                } else {
+                    sortedSongs
+                }
+                
+                val result = Arguments.createArray()
+                paginatedSongs.forEach { song ->
+                    result.pushMap(convertSongToMap(song))
+                }
+                
+                withContext(Dispatchers.Main) {
+                    promise.resolve(result)
+                }
+            } catch (e: Exception) {
+                withContext(Dispatchers.Main) {
+                    promise.reject("DB_ERROR", "Failed to get cached songs", e)
+                }
+            }
+        }
+    }
+    
+    @ReactMethod
+    fun deleteSong(songId: String, promise: Promise) {
+        scope.launch {
+            try {
+                val song = database.songDao().getById(songId)
+                if (song == null) {
+                    withContext(Dispatchers.Main) {
+                        promise.reject("NOT_FOUND", "Song not found")
+                    }
+                    return@launch
+                }
+                
+                val file = File(song.path)
+                val deleted = if (file.exists()) {
+                    file.delete()
+                } else {
+                    false
+                }
+                
+                if (deleted) {
+                    database.songDao().deleteById(songId)
+                    
+                    // Emit deletion event
+                    val eventParams = Arguments.createMap()
+                    eventParams.putString("songId", songId)
+                    eventParams.putString("path", song.path)
+                    emitEvent(EVENT_FILE_DELETED, eventParams)
+                    
+                    withContext(Dispatchers.Main) {
+                        promise.resolve(true)
+                    }
+                } else {
+                    withContext(Dispatchers.Main) {
+                        promise.reject("DELETE_FAILED", "Failed to delete file")
+                    }
+                }
+            } catch (e: Exception) {
+                withContext(Dispatchers.Main) {
+                    promise.reject("DELETE_ERROR", "Error deleting song", e)
+                }
+            }
+        }
+    }
+    
+    @ReactMethod
+    fun startFileMonitoring() {
+        // Implementation for real-time file monitoring
+        // Will use FileObserver and ContentObserver
+        // This is a placeholder - actual implementation requires Service
+    }
+    
+    @ReactMethod
+    fun stopFileMonitoring() {
+        // Stop monitoring
+    }
+    
+    @ReactMethod
+    fun getAlbums(promise: Promise) {
+        scope.launch {
+            try {
+                val albums = database.songDao().getAllAlbums().first()
+                val result = Arguments.createArray()
+                albums.forEach { albumName ->
+                    val albumSongs = database.songDao().getSongsByAlbum(albumName).first()
+                    val albumMap = Arguments.createMap()
+                    albumMap.putString("name", albumName)
+                    albumMap.putInt("songCount", albumSongs.size)
+                    
+                    // Get album art from first song
+                    val albumArtUri = albumSongs.firstOrNull()?.albumArtUri
+                    albumMap.putString("albumArtUri", albumArtUri)
+                    
+                    result.pushMap(albumMap)
+                }
+                
+                withContext(Dispatchers.Main) {
+                    promise.resolve(result)
+                }
+            } catch (e: Exception) {
+                withContext(Dispatchers.Main) {
+                    promise.reject("DB_ERROR", "Failed to get albums", e)
+                }
+            }
+        }
+    }
+    
+    @ReactMethod
+    fun getArtists(promise: Promise) {
+        scope.launch {
+            try {
+                val artists = database.songDao().getAllArtists().first()
+                val result = Arguments.createArray()
+                artists.forEach { artistName ->
+                    val artistSongs = database.songDao().getAllSongs().first()
+                        .filter { it.artist == artistName }
+                    
+                    val artistMap = Arguments.createMap()
+                    artistMap.putString("name", artistName)
+                    artistMap.putInt("songCount", artistSongs.size)
+                    artistMap.putInt("albumCount", artistSongs.map { it.album }.distinct().size)
+                    result.pushMap(artistMap)
+                }
+                
+                withContext(Dispatchers.Main) {
+                    promise.resolve(result)
+                }
+            } catch (e: Exception) {
+                withContext(Dispatchers.Main) {
+                    promise.reject("DB_ERROR", "Failed to get artists", e)
+                }
+            }
+        }
+    }
+    
+    @ReactMethod
+    fun searchSongs(query: String, promise: Promise) {
+        scope.launch {
+            try {
+                val songs = database.songDao().search("%$query%").first()
+                val result = Arguments.createArray()
+                songs.forEach { song ->
+                    result.pushMap(convertSongToMap(song))
+                }
+                
+                withContext(Dispatchers.Main) {
+                    promise.resolve(result)
+                }
+            } catch (e: Exception) {
+                withContext(Dispatchers.Main) {
+                    promise.reject("SEARCH_ERROR", "Failed to search songs", e)
+                }
+            }
+        }
+    }
+    
+    @ReactMethod
+    fun addToFavorites(songId: String, promise: Promise) {
+        scope.launch {
+            try {
+                database.songDao().setFavorite(songId, true)
+                withContext(Dispatchers.Main) {
+                    promise.resolve(true)
+                }
+            } catch (e: Exception) {
+                withContext(Dispatchers.Main) {
+                    promise.reject("DB_ERROR", "Failed to add to favorites", e)
+                }
+            }
+        }
+    }
+    
+    @ReactMethod
+    fun removeFromFavorites(songId: String, promise: Promise) {
+        scope.launch {
+            try {
+                database.songDao().setFavorite(songId, false)
+                withContext(Dispatchers.Main) {
+                    promise.resolve(true)
+                }
+            } catch (e: Exception) {
+                withContext(Dispatchers.Main) {
+                    promise.reject("DB_ERROR", "Failed to remove from favorites", e)
+                }
+            }
+        }
+    }
+    
+    @ReactMethod
+    fun clearCache(promise: Promise) {
+        scope.launch {
+            try {
+                // Note: This only clears our database cache, not the actual files
+                // For actual file deletion, use deleteSong method
+                database.clearAllTables()
+                withContext(Dispatchers.Main) {
+                    promise.resolve(true)
+                }
+            } catch (e: Exception) {
+                withContext(Dispatchers.Main) {
+                    promise.reject("CLEAR_ERROR", "Failed to clear cache", e)
+                }
+            }
+        }
+    }
+    
+    override fun onCatalystInstanceDestroy() {
+        super.onCatalystInstanceDestroy()
+        scope.cancel()
+    }
+    
+    // Private helper methods
+    
+    private suspend fun scanAndSaveToDatabase(
+        context: android.content.Context,
+        scanPaths: List<String>,
+        forceRescan: Boolean
+    ): Int {
+        val songs = mutableListOf<SongEntity>()
+        
+        // Query MediaStore for audio files
+        val projection = arrayOf(
+            MediaStore.Audio.Media._ID,
+            MediaStore.Audio.Media.TITLE,
+            MediaStore.Audio.Media.ARTIST,
+            MediaStore.Audio.Media.ALBUM,
+            MediaStore.Audio.Media.DURATION,
+            MediaStore.Audio.Media.DATA,
+            MediaStore.Audio.Media.SIZE,
+            MediaStore.Audio.Media.MIME_TYPE,
+            MediaStore.Audio.Media.DATE_ADDED,
+            MediaStore.Audio.Media.DATE_MODIFIED,
+            MediaStore.Audio.Media.TRACK,
+            MediaStore.Audio.Media.YEAR,
+            MediaStore.Audio.Media.GENRE,
+            MediaStore.Audio.Media.ALBUM_ID,
+            MediaStore.Audio.Media.COMPOSER
+        )
+        
+        val selection = "${MediaStore.Audio.Media.IS_MUSIC} != 0"
+        val sortOrder = "${MediaStore.Audio.Media.DATE_ADDED} DESC"
+        
+        val cursor: Cursor? = context.contentResolver.query(
+            MediaStore.Audio.Media.EXTERNAL_CONTENT_URI,
+            projection,
+            selection,
+            null,
+            sortOrder
+        )
+        
+        cursor?.use { c ->
+            val idColumn = c.getColumnIndexOrThrow(MediaStore.Audio.Media._ID)
+            val titleColumn = c.getColumnIndexOrThrow(MediaStore.Audio.Media.TITLE)
+            val artistColumn = c.getColumnIndexOrThrow(MediaStore.Audio.Media.ARTIST)
+            val albumColumn = c.getColumnIndexOrThrow(MediaStore.Audio.Media.ALBUM)
+            val durationColumn = c.getColumnIndexOrThrow(MediaStore.Audio.Media.DURATION)
+            val pathColumn = c.getColumnIndexOrThrow(MediaStore.Audio.Media.DATA)
+            val sizeColumn = c.getColumnIndexOrThrow(MediaStore.Audio.Media.SIZE)
+            val mimeTypeColumn = c.getColumnIndexOrThrow(MediaStore.Audio.Media.MIME_TYPE)
+            val dateAddedColumn = c.getColumnIndexOrThrow(MediaStore.Audio.Media.DATE_ADDED)
+            val dateModifiedColumn = c.getColumnIndexOrThrow(MediaStore.Audio.Media.DATE_MODIFIED)
+            val trackColumn = c.getColumnIndexOrThrow(MediaStore.Audio.Media.TRACK)
+            val yearColumn = c.getColumnIndexOrThrow(MediaStore.Audio.Media.YEAR)
+            val genreColumn = c.getColumnIndexOrThrow(MediaStore.Audio.Media.GENRE)
+            val albumIdColumn = c.getColumnIndexOrThrow(MediaStore.Audio.Media.ALBUM_ID)
+            val composerColumn = c.getColumnIndexOrThrow(MediaStore.Audio.Media.COMPOSER)
+            
+            var processed = 0
+            val total = c.count
+            
+            while (c.moveToNext()) {
+                val path = c.getString(pathColumn)
+                
+                // Filter by scan paths if provided
+                if (scanPaths.isNotEmpty() && !isInScanPath(path, scanPaths)) {
+                    continue
+                }
+                
+                val id = c.getLong(idColumn)
+                val title = c.getString(titleColumn) ?: "Unknown"
+                val artist = c.getString(artistColumn) ?: "Unknown Artist"
+                val album = c.getString(albumColumn) ?: "Unknown Album"
+                val duration = c.getLong(durationColumn)
+                val size = c.getLong(sizeColumn)
+                val mimeType = c.getString(mimeTypeColumn) ?: "audio/mpeg"
+                val dateAdded = c.getLong(dateAddedColumn) * 1000 // Convert to milliseconds
+                val dateModified = c.getLong(dateModifiedColumn) * 1000
+                val trackNumber = c.getInt(trackColumn)
+                val year = if (!c.isNull(yearColumn)) c.getInt(yearColumn) else null
+                val genre = c.getString(genreColumn)
+                val albumId = c.getLong(albumIdColumn)
+                val composer = c.getString(composerColumn)
+                
+                // Get album art URI
+                val albumArtUri = if (albumId > 0) {
+                    val albumArtUri = Uri.parse("content://media/external/audio/albumart")
+                    ContentUris.withAppendedId(albumArtUri, albumId).toString()
+                } else {
+                    null
+                }
+                
+                // Generate unique ID
+                val songId = SongEntity.generateId(path)
+                
+                val song = SongEntity(
+                    id = songId,
+                    title = title,
+                    artist = artist,
+                    album = album,
+                    duration = duration,
+                    path = path,
+                    uri = MediaStore.Audio.Media.EXTERNAL_CONTENT_URI
+                        .buildUpon()
+                        .appendPath(id.toString())
+                        .build()
+                        .toString(),
+                    albumArtUri = albumArtUri,
+                    size = size,
+                    mimeType = mimeType,
+                    trackNumber = trackNumber,
+                    year = year,
+                    genre = genre,
+                    dateAdded = dateAdded,
+                    lastModified = dateModified,
+                    composer = composer
+                )
+                
+                songs.add(song)
+                processed++
+                
+                // Emit progress update every 10 songs
+                if (processed % 10 == 0) {
+                    val progress = Arguments.createMap()
+                    progress.putInt("processed", processed)
+                    progress.putInt("total", total)
+                    progress.putDouble("percentage", (processed.toDouble() / total) * 100)
+                    emitEvent(EVENT_SCAN_PROGRESS, progress)
+                }
+            }
+        }
+        
+        // Save to database
+        database.songDao().insertAll(songs)
+        
+        return songs.size
+    }
+    
+    private fun isInScanPath(filePath: String, scanPaths: List<String>): Boolean {
+        return scanPaths.any { filePath.startsWith(it) }
+    }
+    
+    private fun getDefaultMusicPaths(): List<String> {
+        val paths = mutableListOf<String>()
+        
+        // Common music directories
+        val musicDir = Environment.getExternalStoragePublicDirectory(Environment.DIRECTORY_MUSIC)
+        if (musicDir.exists()) {
+            paths.add(musicDir.absolutePath)
+        }
+        
+        // Add Download directory (users often download music there)
+        val downloadDir = Environment.getExternalStoragePublicDirectory(Environment.DIRECTORY_DOWNLOADS)
+        if (downloadDir.exists()) {
+            paths.add(downloadDir.absolutePath)
+        }
+        
+        // Add SD card paths if available
+        val externalDirs = reactApplicationContext?.getExternalFilesDirs(null)
+        externalDirs?.forEach { dir ->
+            if (dir != null && dir.exists() && Environment.isExternalStorageRemovable(dir)) {
+                paths.add(dir.absolutePath)
+            }
+        }
+        
+        return paths
+    }
+    
+    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 emitPermissionStatus(granted: Boolean) {
+        val params = Arguments.createMap()
+        params.putBoolean("granted", granted)
+        params.putString("message", if (granted) "Permission granted" else "Permission denied")
+        emitEvent(EVENT_PERMISSION_STATUS, params)
+    }
+    
+    private fun emitEvent(eventName: String, params: WritableMap?) {
+        reactApplicationContext
+            ?.getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter::class.java)
+            ?.emit(eventName, params)
+    }
+}