react-native-mp3 0.1.0

package/android/build.gradle

@@ -0,0 +1,111 @@
+buildscript {
+    ext {
+        kotlinVersion = "1.8.0"
+        minSdkVersion = 21
+        compileSdkVersion = 33
+        targetSdkVersion = 33
+        roomVersion = "2.5.0"
+    }
+    repositories {
+        google()
+        mavenCentral()
+    }
+    dependencies {
+        classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:$kotlinVersion"
+    }
+}
+
+apply plugin: 'com.android.library'
+apply plugin: 'kotlin-android'
+apply plugin: 'kotlin-kapt'
+
+android {
+    compileSdkVersion rootProject.ext.compileSdkVersion
+
+    defaultConfig {
+        minSdkVersion rootProject.ext.minSdkVersion
+        targetSdkVersion rootProject.ext.targetSdkVersion
+        versionCode 1
+        versionName "1.0"
+        
+        buildConfigField "boolean", "IS_NEW_ARCHITECTURE_ENABLED", isNewArchitectureEnabled().toString()
+        
+        if (isNewArchitectureEnabled()) {
+            externalNativeBuild {
+                ndkBuild {
+                    arguments "APP_PLATFORM=android-21",
+                            "APP_STL=c++_shared",
+                            "NDK_TOOLCHAIN_VERSION=clang",
+                            "GENERATED_SRC_DIR=$buildDir/generated/source",
+                            "PROJECT_BUILD_DIR=$buildDir",
+                            "REACT_ANDROID_DIR=$rootDir/../node_modules/react-native/ReactAndroid",
+                            "REACT_ANDROID_BUILD_DIR=$rootDir/../node_modules/react-native/ReactAndroid/build"
+                    cFlags "-Wall", "-Werror", "-fexceptions", "-frtti", "-DWITH_INSPECTOR=1"
+                    cppFlags "-std=c++17"
+                    targets "reactnativemp3"
+                }
+            }
+        }
+    }
+    
+    externalNativeBuild {
+        ndkBuild {
+            path "src/main/jni/Android.mk"
+        }
+    }
+    
+    buildFeatures {
+        buildConfig true
+    }
+    
+    sourceSets {
+        main {
+            if (isNewArchitectureEnabled()) {
+                java.srcDirs += ["$buildDir/generated/source/codegen/java"]
+            }
+        }
+    }
+    
+    compileOptions {
+        sourceCompatibility JavaVersion.VERSION_1_8
+        targetCompatibility JavaVersion.VERSION_1_8
+    }
+    
+    kotlinOptions {
+        jvmTarget = "1.8"
+    }
+}
+
+dependencies {
+    implementation "com.facebook.react:react-native:+"
+    implementation "org.jetbrains.kotlin:kotlin-stdlib:$kotlinVersion"
+    
+    // Room Database
+    implementation "androidx.room:room-runtime:$roomVersion"
+    kapt "androidx.room:room-compiler:$roomVersion"
+    implementation "androidx.room:room-ktx:$roomVersion"
+    
+    // Lifecycle components
+    implementation "androidx.lifecycle:lifecycle-viewmodel-ktx:2.6.1"
+    implementation "androidx.lifecycle:lifecycle-livedata-ktx:2.6.1"
+    implementation "androidx.lifecycle:lifecycle-common-java8:2.6.1"
+    
+    // WorkManager for background tasks
+    implementation "androidx.work:work-runtime-ktx:2.8.1"
+    
+    // Coroutines
+    implementation "org.jetbrains.kotlinx:kotlinx-coroutines-android:1.6.4"
+    
+    // Media and ExoPlayer for advanced features
+    implementation "androidx.media:media:1.6.0"
+    implementation "com.google.android.exoplayer:exoplayer-core:2.18.7"
+    implementation "com.google.android.exoplayer:exoplayer-ui:2.18.7"
+    
+    // Glide for image loading/caching
+    implementation "com.github.bumptech.glide:glide:4.15.1"
+    kapt "com.github.bumptech.glide:compiler:4.15.1"
+}
+
+def isNewArchitectureEnabled() {
+    return project.hasProperty("newArchEnabled") && project.newArchEnabled == "true"
+}

package/android/src/main/AndroidManifest.xml

@@ -0,0 +1,44 @@
+<?xml version="1.0" encoding="utf-8"?>
+<manifest xmlns:android="http://schemas.android.com/apk/res/android"
+    package="com.reactnativemp3">
+
+    <!-- Storage Permissions -->
+    <uses-permission android:name="android.permission.READ_EXTERNAL_STORAGE" />
+    <uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE" />
+    <uses-permission android:name="android.permission.MANAGE_EXTERNAL_STORAGE"
+        android:minSdkVersion="30" />
+    
+    <!-- Audio Permissions -->
+    <uses-permission android:name="android.permission.FOREGROUND_SERVICE" />
+    <uses-permission android:name="android.permission.WAKE_LOCK" />
+    
+    <!-- Network Permissions (for online streaming) -->
+    <uses-permission android:name="android.permission.INTERNET" />
+    <uses-permission android:name="android.permission.ACCESS_NETWORK_STATE" />
+    
+    <application>
+        <!-- Music Service for background playback -->
+        <service
+            android:name=".services.MusicService"
+            android:enabled="true"
+            android:exported="false"
+            android:foregroundServiceType="mediaPlayback">
+            <intent-filter>
+                <action android:name="android.intent.action.MEDIA_BUTTON" />
+            </intent-filter>
+        </service>
+        
+        <!-- File Monitoring Service -->
+        <service
+            android:name=".services.FileObserverService"
+            android:enabled="true"
+            android:exported="false" />
+            
+        <!-- Broadcast Receiver for Audio Focus -->
+        <receiver android:name=".services.AudioFocusReceiver">
+            <intent-filter>
+                <action android:name="android.media.AUDIO_BECOMING_NOISY" />
+            </intent-filter>
+        </receiver>
+    </application>
+</manifest>

package/android/src/main/java/com/reactnativemp3/Mp3Package.kt

@@ -0,0 +1,23 @@
+package com.reactnativemp3
+
+import android.view.View
+import com.facebook.react.ReactPackage
+import com.facebook.react.bridge.NativeModule
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.uimanager.ReactShadowNode
+import com.facebook.react.uimanager.ViewManager
+
+class Mp3Package : ReactPackage {
+    override fun createNativeModules(reactContext: ReactApplicationContext): List<NativeModule> {
+        return listOf(
+            ScannerModule(reactContext),
+            PlayerModule(reactContext),
+            MetadataModule(reactContext),
+            NotificationModule(reactContext)
+        )
+    }
+
+    override fun createViewManagers(reactContext: ReactApplicationContext): List<ViewManager<View, ReactShadowNode<*>>> {
+        return emptyList()
+    }
+}

package/android/src/main/java/com/reactnativemp3/Mp3TurboModule.kt

@@ -0,0 +1,43 @@
+package com.reactnativemp3
+
+import com.facebook.jni.HybridData
+import com.facebook.proguard.annotations.DoNotStrip
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.bridge.WritableMap
+import com.facebook.react.turbomodule.core.CallInvokerHolderImpl
+import com.facebook.react.turbomodule.core.interfaces.TurboModule
+import java.lang.ref.WeakReference
+
+@DoNotStrip
+abstract class Mp3TurboModule(
+    reactContext: ReactApplicationContext,
+    moduleName: String
+) : TurboModule {
+    
+    protected val reactContextRef: WeakReference<ReactApplicationContext> = WeakReference(reactContext)
+    
+    @DoNotStrip
+    @Suppress("UNUSED")
+    private val mHybridData: HybridData
+    
+    init {
+        mHybridData = initHybrid(reactContext.jsCallInvokerHolder as CallInvokerHolderImpl)
+    }
+    
+    @DoNotStrip
+    private external fun initHybrid(callInvokerHolder: CallInvokerHolderImpl): HybridData
+    
+    override fun getName(): String = moduleName
+    
+    override fun invalidate() {
+        mHybridData.resetNative()
+    }
+    
+    protected fun getReactApplicationContext(): ReactApplicationContext? {
+        return reactContextRef.get()
+    }
+    
+    // Helper methods for emitting events to JS
+    @DoNotStrip
+    protected external fun emitEvent(eventName: String, params: WritableMap?)
+}

package/android/src/main/java/com/reactnativemp3/database/MusicDatabase.kt

@@ -0,0 +1,48 @@
+package com.reactnativemp3.database
+
+import android.content.Context
+import androidx.room.Database
+import androidx.room.Room
+import androidx.room.RoomDatabase
+import androidx.room.TypeConverters
+import com.reactnativemp3.database.dao.*
+import com.reactnativemp3.database.entities.*
+
+@Database(
+    entities = [
+        SongEntity::class,
+        PlaylistEntity::class,
+        PlaylistSongEntity::class,
+        ThumbnailCacheEntity::class
+    ],
+    version = 1,
+    exportSchema = true
+)
+@TypeConverters(Converters::class)
+abstract class MusicDatabase : RoomDatabase() {
+    
+    abstract fun songDao(): SongDao
+    abstract fun playlistDao(): PlaylistDao
+    abstract fun thumbnailCacheDao(): ThumbnailCacheDao
+    
+    companion object {
+        @Volatile
+        private var INSTANCE: MusicDatabase? = null
+        
+        fun getInstance(context: Context): MusicDatabase {
+            return INSTANCE ?: synchronized(this) {
+                val instance = Room.databaseBuilder(
+                    context.applicationContext,
+                    MusicDatabase::class.java,
+                    "music_database"
+                )
+                .addMigrations() // Add migrations here as needed
+                .setJournalMode(JournalMode.TRUNCATE)
+                .build()
+                
+                INSTANCE = instance
+                instance
+            }
+        }
+    }
+}

package/android/src/main/java/com/reactnativemp3/database/dao/SongDao.kt

@@ -0,0 +1,72 @@
+package com.reactnativemp3.database.dao
+
+import androidx.room.*
+import com.reactnativemp3.database.entities.SongEntity
+import kotlinx.coroutines.flow.Flow
+
+@Dao
+interface SongDao {
+    
+    @Insert(onConflict = OnConflictStrategy.REPLACE)
+    suspend fun insert(song: SongEntity)
+    
+    @Insert(onConflict = OnConflictStrategy.REPLACE)
+    suspend fun insertAll(songs: List<SongEntity>)
+    
+    @Update
+    suspend fun update(song: SongEntity)
+    
+    @Delete
+    suspend fun delete(song: SongEntity)
+    
+    @Query("DELETE FROM songs WHERE id = :songId")
+    suspend fun deleteById(songId: String)
+    
+    @Query("SELECT * FROM songs WHERE id = :songId")
+    suspend fun getById(songId: String): SongEntity?
+    
+    @Query("SELECT * FROM songs ORDER BY title COLLATE NOCASE")
+    fun getAllSongs(): Flow<List<SongEntity>>
+    
+    @Query("SELECT * FROM songs ORDER BY date_added DESC")
+    fun getRecentlyAdded(): Flow<List<SongEntity>>
+    
+    @Query("SELECT * FROM songs WHERE last_played IS NOT NULL ORDER BY last_played DESC")
+    fun getRecentlyPlayed(): Flow<List<SongEntity>>
+    
+    @Query("SELECT * FROM songs WHERE is_favorite = 1 ORDER BY title COLLATE NOCASE")
+    fun getFavorites(): Flow<List<SongEntity>>
+    
+    @Query("SELECT * FROM songs WHERE album = :album ORDER BY track_number, title")
+    fun getSongsByAlbum(album: String): Flow<List<SongEntity>>
+    
+    @Query("SELECT DISTINCT album FROM songs WHERE album IS NOT NULL AND album != '' ORDER BY album COLLATE NOCASE")
+    fun getAllAlbums(): Flow<List<String>>
+    
+    @Query("SELECT DISTINCT artist FROM songs WHERE artist IS NOT NULL AND artist != '' ORDER BY artist COLLATE NOCASE")
+    fun getAllArtists(): Flow<List<String>>
+    
+    @Query("SELECT DISTINCT genre FROM songs WHERE genre IS NOT NULL AND genre != '' ORDER BY genre COLLATE NOCASE")
+    fun getAllGenres(): Flow<List<String>>
+    
+    @Query("SELECT COUNT(*) FROM songs")
+    suspend fun getCount(): Int
+    
+    @Query("SELECT * FROM songs WHERE title LIKE :query OR artist LIKE :query OR album LIKE :query")
+    fun search(query: String): Flow<List<SongEntity>>
+    
+    @Query("UPDATE songs SET play_count = play_count + 1, last_played = :timestamp WHERE id = :songId")
+    suspend fun incrementPlayCount(songId: String, timestamp: Long)
+    
+    @Query("UPDATE songs SET is_favorite = :isFavorite WHERE id = :songId")
+    suspend fun setFavorite(songId: String, isFavorite: Boolean)
+    
+    @Query("UPDATE songs SET bookmark = :position WHERE id = :songId")
+    suspend fun setBookmark(songId: String, position: Long)
+    
+    @Query("SELECT * FROM songs WHERE path = :filePath")
+    suspend fun getByPath(filePath: String): SongEntity?
+    
+    @Query("DELETE FROM songs WHERE path = :filePath")
+    suspend fun deleteByPath(filePath: String)
+}

package/android/src/main/java/com/reactnativemp3/database/entities/PlaylistEntity.kt

@@ -0,0 +1,58 @@
+package com.reactnativemp3.database.entities
+
+import androidx.room.*
+
+@Entity(
+    tableName = "playlists",
+    indices = [Index(value = ["name"], unique = true)]
+)
+data class PlaylistEntity(
+    @PrimaryKey(autoGenerate = true)
+    @ColumnInfo(name = "id")
+    val id: Long = 0,
+    
+    @ColumnInfo(name = "name")
+    val name: String,
+    
+    @ColumnInfo(name = "created_at")
+    val createdAt: Long = System.currentTimeMillis(),
+    
+    @ColumnInfo(name = "song_count")
+    val songCount: Int = 0,
+    
+    @ColumnInfo(name = "thumbnail_uri")
+    val thumbnailUri: String? = null
+)
+
+@Entity(
+    tableName = "playlist_songs",
+    primaryKeys = ["playlist_id", "song_id"],
+    foreignKeys = [
+        ForeignKey(
+            entity = PlaylistEntity::class,
+            parentColumns = ["id"],
+            childColumns = ["playlist_id"],
+            onDelete = ForeignKey.CASCADE
+        ),
+        ForeignKey(
+            entity = SongEntity::class,
+            parentColumns = ["id"],
+            childColumns = ["song_id"],
+            onDelete = ForeignKey.CASCADE
+        )
+    ],
+    indices = [
+        Index(value = ["playlist_id"]),
+        Index(value = ["song_id"])
+    ]
+)
+data class PlaylistSongEntity(
+    @ColumnInfo(name = "playlist_id")
+    val playlistId: Long,
+    
+    @ColumnInfo(name = "song_id")
+    val songId: String,
+    
+    @ColumnInfo(name = "position")
+    val position: Int
+)

package/android/src/main/java/com/reactnativemp3/database/entities/SongEntity.kt

@@ -0,0 +1,104 @@
+package com.reactnativemp3.database.entities
+
+import androidx.room.ColumnInfo
+import androidx.room.Entity
+import androidx.room.Index
+import androidx.room.PrimaryKey
+import java.util.*
+
+@Entity(
+    tableName = "songs",
+    indices = [
+        Index(value = ["title"]),
+        Index(value = ["artist"]),
+        Index(value = ["album"]),
+        Index(value = ["date_added"], orders = [Index.Order.DESC]),
+        Index(value = ["last_played"], orders = [Index.Order.DESC])
+    ]
+)
+data class SongEntity(
+    @PrimaryKey
+    @ColumnInfo(name = "id")
+    val id: String,
+    
+    @ColumnInfo(name = "title")
+    val title: String,
+    
+    @ColumnInfo(name = "artist")
+    val artist: String = "Unknown Artist",
+    
+    @ColumnInfo(name = "album")
+    val album: String = "Unknown Album",
+    
+    @ColumnInfo(name = "duration")
+    val duration: Long,
+    
+    @ColumnInfo(name = "path")
+    val path: String,
+    
+    @ColumnInfo(name = "uri")
+    val uri: String,
+    
+    @ColumnInfo(name = "album_art_uri")
+    val albumArtUri: String?,
+    
+    @ColumnInfo(name = "size")
+    val size: Long,
+    
+    @ColumnInfo(name = "mime_type")
+    val mimeType: String,
+    
+    @ColumnInfo(name = "track_number")
+    val trackNumber: Int = 0,
+    
+    @ColumnInfo(name = "year")
+    val year: Int? = null,
+    
+    @ColumnInfo(name = "genre")
+    val genre: String? = null,
+    
+    @ColumnInfo(name = "date_added")
+    val dateAdded: Long,
+    
+    @ColumnInfo(name = "last_modified")
+    val lastModified: Long,
+    
+    @ColumnInfo(name = "is_favorite")
+    val isFavorite: Boolean = false,
+    
+    @ColumnInfo(name = "play_count")
+    val playCount: Int = 0,
+    
+    @ColumnInfo(name = "last_played")
+    val lastPlayed: Long? = null,
+    
+    @ColumnInfo(name = "bitrate")
+    val bitrate: Int? = null,
+    
+    @ColumnInfo(name = "sample_rate")
+    val sampleRate: Int? = null,
+    
+    @ColumnInfo(name = "channels")
+    val channels: Int? = null,
+    
+    @ColumnInfo(name = "composer")
+    val composer: String? = null,
+    
+    @ColumnInfo(name = "lyrics")
+    val lyrics: String? = null,
+    
+    @ColumnInfo(name = "rating")
+    val rating: Int? = null,
+    
+    @ColumnInfo(name = "is_podcast")
+    val isPodcast: Boolean = false,
+    
+    @ColumnInfo(name = "bookmark")
+    val bookmark: Long = 0
+) {
+    companion object {
+        fun generateId(path: String): String {
+            return UUID.nameUUIDFromBytes(path.toByteArray()).toString()
+        }
+    }
+}

package/android/src/main/java/com/reactnativemp3/database/entities/ThumbnailCacheEntity.kt

@@ -0,0 +1,43 @@
+package com.reactnativemp3.database.entities
+
+import androidx.room.ColumnInfo
+import androidx.room.Entity
+import androidx.room.PrimaryKey
+
+@Entity(tableName = "thumbnail_cache")
+data class ThumbnailCacheEntity(
+    @PrimaryKey
+    @ColumnInfo(name = "song_id")
+    val songId: String,
+    
+    @ColumnInfo(name = "thumbnail_data")
+    val thumbnailData: ByteArray,
+    
+    @ColumnInfo(name = "last_accessed")
+    val lastAccessed: Long = System.currentTimeMillis(),
+    
+    @ColumnInfo(name = "size")
+    val size: Int
+) {
+    override fun equals(other: Any?): Boolean {
+        if (this === other) return true
+        if (javaClass != other?.javaClass) return false
+        
+        other as ThumbnailCacheEntity
+        
+        if (songId != other.songId) return false
+        if (!thumbnailData.contentEquals(other.thumbnailData)) return false
+        if (lastAccessed != other.lastAccessed) return false
+        if (size != other.size) return false
+        
+        return true
+    }
+    
+    override fun hashCode(): Int {
+        var result = songId.hashCode()
+        result = 31 * result + thumbnailData.contentHashCode()
+        result = 31 * result + lastAccessed.hashCode()
+        result = 31 * result + size
+        return result
+    }
+}