react-native-nitro-player 0.0.1

package/android/build.gradle

@@ -0,0 +1,147 @@
+buildscript {
+  repositories {
+    google()
+    mavenCentral()
+  }
+
+  dependencies {
+    classpath "com.android.tools.build:gradle:8.13.0"
+  }
+}
+
+def reactNativeArchitectures() {
+  def value = rootProject.getProperties().get("reactNativeArchitectures")
+  return value ? value.split(",") : ["armeabi-v7a", "x86", "x86_64", "arm64-v8a"]
+}
+
+def isNewArchitectureEnabled() {
+  return rootProject.hasProperty("newArchEnabled") && rootProject.getProperty("newArchEnabled") == "true"
+}
+
+apply plugin: "com.android.library"
+apply plugin: 'org.jetbrains.kotlin.android'
+apply from: '../nitrogen/generated/android/NitroPlayer+autolinking.gradle'
+apply from: "./fix-prefab.gradle"
+
+if (isNewArchitectureEnabled()) {
+  apply plugin: "com.facebook.react"
+}
+
+def getExtOrDefault(name) {
+  return rootProject.ext.has(name) ? rootProject.ext.get(name) : project.properties["NitroPlayer_" + name]
+}
+
+def getExtOrIntegerDefault(name) {
+  return rootProject.ext.has(name) ? rootProject.ext.get(name) : (project.properties["NitroPlayer_" + name]).toInteger()
+}
+
+android {
+  namespace "com.margelo.nitro.nitroplayer"
+
+  ndkVersion getExtOrDefault("ndkVersion")
+  compileSdkVersion getExtOrIntegerDefault("compileSdkVersion")
+
+  defaultConfig {
+    minSdkVersion getExtOrIntegerDefault("minSdkVersion")
+    targetSdkVersion getExtOrIntegerDefault("targetSdkVersion")
+    buildConfigField "boolean", "IS_NEW_ARCHITECTURE_ENABLED", isNewArchitectureEnabled().toString()
+
+    externalNativeBuild {
+      cmake {
+        cppFlags "-frtti -fexceptions -Wall -Wextra -fstack-protector-all"
+        arguments "-DANDROID_STL=c++_shared", "-DANDROID_SUPPORT_FLEXIBLE_PAGE_SIZES=ON"
+        abiFilters (*reactNativeArchitectures())
+
+        buildTypes {
+          debug {
+            cppFlags "-O1 -g"
+          }
+          release {
+            cppFlags "-O2"
+          }
+        }
+      }
+    }
+  }
+
+  externalNativeBuild {
+    cmake {
+      path "CMakeLists.txt"
+    }
+  }
+
+  packagingOptions {
+    excludes = [
+            "META-INF",
+            "META-INF/**",
+            "**/libc++_shared.so",
+            "**/libfbjni.so",
+            "**/libjsi.so",
+            "**/libfolly_json.so",
+            "**/libfolly_runtime.so",
+            "**/libglog.so",
+            "**/libhermes.so",
+            "**/libhermes-executor-debug.so",
+            "**/libhermes_executor.so",
+            "**/libreactnative.so",
+            "**/libreactnativejni.so",
+            "**/libturbomodulejsijni.so",
+            "**/libreact_nativemodule_core.so",
+            "**/libjscexecutor.so"
+    ]
+  }
+
+  buildFeatures {
+    buildConfig true
+    prefab true
+  }
+
+  buildTypes {
+    release {
+      minifyEnabled false
+    }
+  }
+
+  lintOptions {
+    disable "GradleCompatible"
+  }
+
+  compileOptions {
+    sourceCompatibility JavaVersion.VERSION_1_8
+    targetCompatibility JavaVersion.VERSION_1_8
+  }
+
+  sourceSets {
+    main {
+      if (isNewArchitectureEnabled()) {
+        java.srcDirs += [
+          // React Codegen files
+          "${project.buildDir}/generated/source/codegen/java"
+        ]
+      }
+    }
+  }
+}
+
+repositories {
+  mavenCentral()
+  google()
+}
+
+
+def media3_version = "1.3.0"
+dependencies {
+  // For < 0.71, this will be from the local maven repo
+  // For > 0.71, this will be replaced by `com.facebook.react:react-android:$version` by react gradle plugin
+  //noinspection GradleDynamicVersion
+  implementation "com.facebook.react:react-native:+"
+
+  // Add a dependency on NitroModules
+  implementation project(":react-native-nitro-modules")
+
+  implementation "androidx.media3:media3-exoplayer:$media3_version"
+  implementation "androidx.media3:media3-session:$media3_version"
+  implementation "androidx.media3:media3-common:$media3_version"
+  implementation "androidx.media:media:1.7.0"
+}
+

package/android/fix-prefab.gradle

@@ -0,0 +1,51 @@
+tasks.configureEach { task ->
+  // Make sure that we generate our prefab publication file only after having built the native library
+  // so that not a header publication file, but a full configuration publication will be generated, which
+  // will include the .so file
+
+  def prefabConfigurePattern = ~/^prefab(.+)ConfigurePackage$/
+  def matcher = task.name =~ prefabConfigurePattern
+  if (matcher.matches()) {
+    def variantName = matcher[0][1]
+    task.outputs.upToDateWhen { false }
+    task.dependsOn("externalNativeBuild${variantName}")
+  }
+}
+
+afterEvaluate {
+  def abis = reactNativeArchitectures()
+  rootProject.allprojects.each { proj ->
+    if (proj === rootProject) return
+
+    def dependsOnThisLib = proj.configurations.findAll { it.canBeResolved }.any { config ->
+      config.dependencies.any { dep ->
+        dep.group == project.group && dep.name == project.name
+      }
+    }
+    if (!dependsOnThisLib && proj != project) return
+
+    if (!proj.plugins.hasPlugin('com.android.application') && !proj.plugins.hasPlugin('com.android.library')) {
+      return
+    }
+
+    def variants = proj.android.hasProperty('applicationVariants') ? proj.android.applicationVariants : proj.android.libraryVariants
+    // Touch the prefab_config.json files to ensure that in ExternalNativeJsonGenerator.kt we will re-trigger the prefab CLI to
+    // generate a libnameConfig.cmake file that will contain our native library (.so).
+    // See this condition: https://cs.android.com/android-studio/platform/tools/base/+/mirror-goog-studio-main:build-system/gradle-core/src/main/java/com/android/build/gradle/tasks/ExternalNativeJsonGenerator.kt;l=207-219?q=createPrefabBuildSystemGlue
+    variants.all { variant ->
+      def variantName = variant.name
+      abis.each { abi ->
+        def searchDir = new File(proj.projectDir, ".cxx/${variantName}")
+        if (!searchDir.exists()) return
+        def matches = []
+        searchDir.eachDir { randomDir ->
+          def prefabFile = new File(randomDir, "${abi}/prefab_config.json")
+          if (prefabFile.exists()) matches << prefabFile
+        }
+        matches.each { prefabConfig ->
+          prefabConfig.setLastModified(System.currentTimeMillis())
+        }
+      }
+    }
+  }
+}

package/android/gradle.properties

@@ -0,0 +1,5 @@
+NitroPlayer_kotlinVersion=2.1.20
+NitroPlayer_minSdkVersion=23
+NitroPlayer_targetSdkVersion=36
+NitroPlayer_compileSdkVersion=36
+NitroPlayer_ndkVersion=27.1.12297006

package/android/src/main/AndroidManifest.xml

@@ -0,0 +1,2 @@
+<manifest xmlns:android="http://schemas.android.com/apk/res/android">
+</manifest>

package/android/src/main/cpp/cpp-adapter.cpp

@@ -0,0 +1,7 @@
+#include "NitroPlayerOnLoad.hpp"
+
+#include <jni.h>
+
+JNIEXPORT jint JNICALL JNI_OnLoad(JavaVM* vm, void*) {
+  return margelo::nitro::nitroplayer::initialize(vm);
+}

package/android/src/main/java/com/margelo/nitro/nitroplayer/HybridAndroidAutoMediaLibrary.kt

@@ -0,0 +1,29 @@
+package com.margelo.nitro.nitroplayer
+
+import androidx.annotation.Keep
+import com.facebook.proguard.annotations.DoNotStrip
+import com.margelo.nitro.NitroModules
+import com.margelo.nitro.nitroplayer.core.TrackPlayerCore
+
+class HybridAndroidAutoMediaLibrary : HybridAndroidAutoMediaLibrarySpec() {
+    private val core: TrackPlayerCore
+
+    init {
+        val context =
+            NitroModules.applicationContext
+                ?: throw IllegalStateException("React Context is not initialized")
+        core = TrackPlayerCore.getInstance(context)
+    }
+
+    @DoNotStrip
+    @Keep
+    override fun setMediaLibrary(libraryJson: String) {
+        core.setAndroidAutoMediaLibrary(libraryJson)
+    }
+
+    @DoNotStrip
+    @Keep
+    override fun clearMediaLibrary() {
+        core.clearAndroidAutoMediaLibrary()
+    }
+}

package/android/src/main/java/com/margelo/nitro/nitroplayer/HybridAudioDevices.kt

@@ -0,0 +1,116 @@
+package com.margelo.nitro.nitroplayer
+
+import android.content.Context
+import android.media.AudioDeviceInfo
+import android.media.AudioManager
+import android.os.Build
+import com.margelo.nitro.NitroModules
+
+class HybridAudioDevices : HybridAudioDevicesSpec() {
+
+    val applicationContext = NitroModules.applicationContext;
+    private val audioManager = applicationContext?.getSystemService(Context.AUDIO_SERVICE) as AudioManager
+    
+    // Device types that can be set as communication devices
+    private val validCommunicationDeviceTypes: Set<Int> by lazy {
+        val types = mutableSetOf(
+            AudioDeviceInfo.TYPE_BUILTIN_EARPIECE,
+            AudioDeviceInfo.TYPE_BUILTIN_SPEAKER,
+            AudioDeviceInfo.TYPE_WIRED_HEADSET,
+            AudioDeviceInfo.TYPE_WIRED_HEADPHONES,
+            AudioDeviceInfo.TYPE_BLUETOOTH_SCO,
+            AudioDeviceInfo.TYPE_BLUETOOTH_A2DP,
+            AudioDeviceInfo.TYPE_USB_HEADSET
+        )
+        // BLE types are only available on Android S (API 31) and above
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.S) {
+            types.add(AudioDeviceInfo.TYPE_BLE_HEADSET)
+            types.add(AudioDeviceInfo.TYPE_BLE_SPEAKER)
+        }
+        types
+    }
+    
+    override fun getAudioDevices(): Array<TAudioDevice> {
+        val devices = audioManager.getDevices(android.media.AudioManager.GET_DEVICES_OUTPUTS)
+        var activeDevice: AudioDeviceInfo? = null
+
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.S) {
+            activeDevice = audioManager.communicationDevice
+        }
+        
+        // Filter to only include valid communication devices
+        return devices.filter { device ->
+            validCommunicationDeviceTypes.contains(device.type)
+        }.map { device -> TAudioDevice(
+            id = device.id.toDouble(),
+            name = device.productName?.toString() ?: getDeviceTypeName(device.type),
+            type = device.type.toDouble(),
+            isActive = device == activeDevice
+        ) }.toTypedArray()
+    }
+    
+    private fun getDeviceTypeName(type: Int): String {
+        return when (type) {
+            AudioDeviceInfo.TYPE_BUILTIN_EARPIECE -> "Built-in Earpiece"
+            AudioDeviceInfo.TYPE_BUILTIN_SPEAKER -> "Built-in Speaker"
+            AudioDeviceInfo.TYPE_WIRED_HEADSET -> "Wired Headset"
+            AudioDeviceInfo.TYPE_WIRED_HEADPHONES -> "Wired Headphones"
+            AudioDeviceInfo.TYPE_BLUETOOTH_SCO -> "Bluetooth SCO"
+            AudioDeviceInfo.TYPE_BLUETOOTH_A2DP -> "Bluetooth"
+            AudioDeviceInfo.TYPE_USB_HEADSET -> "USB Headset"
+            26 -> if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.S) "BLE Headset" else "Type 26"
+            27 -> if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.S) "BLE Speaker" else "Type 27"
+            else -> "Type $type"
+        }
+    }
+
+    override fun setAudioDevice(deviceId: Double): Boolean {
+        val device =
+            audioManager.getDevices(android.media.AudioManager.GET_DEVICES_OUTPUTS)
+                .firstOrNull { it.id == deviceId.toInt() }
+                ?: return false
+
+        // Check if device type is valid for communication
+        if (!validCommunicationDeviceTypes.contains(device.type)) {
+            android.util.Log.w(TAG, "Device type ${device.type} is not a valid communication device")
+            return false
+        }
+
+        return try {
+            if (android.os.Build.VERSION.SDK_INT >= android.os.Build.VERSION_CODES.S) {
+                audioManager.setCommunicationDevice(device)
+            } else {
+                // Pre-Android 12 fallback (best-effort)
+                when (device.type) {
+                    android.media.AudioDeviceInfo.TYPE_BLUETOOTH_SCO,
+                    android.media.AudioDeviceInfo.TYPE_BLUETOOTH_A2DP -> {
+                        audioManager.startBluetoothSco()
+                        audioManager.isBluetoothScoOn = true
+                        true
+                    }
+                    android.media.AudioDeviceInfo.TYPE_BUILTIN_SPEAKER -> {
+                        audioManager.isSpeakerphoneOn = true
+                        true
+                    }
+                    android.media.AudioDeviceInfo.TYPE_WIRED_HEADSET,
+                    android.media.AudioDeviceInfo.TYPE_WIRED_HEADPHONES -> {
+                        audioManager.isSpeakerphoneOn = false
+                        audioManager.isBluetoothScoOn = false
+                        true
+                    }
+                    else -> {
+                        android.util.Log.w(TAG, "Unsupported device type for pre-Android 12: ${device.type}")
+                        false
+                    }
+                }
+            }
+        } catch (e: Exception) {
+            android.util.Log.e(TAG, "Error setting audio device: ${e.message}", e)
+            false
+        }
+    }
+
+    companion object {
+        private const val TAG = "HybridAudioDevices"
+    }
+}

package/android/src/main/java/com/margelo/nitro/nitroplayer/HybridPlayerQueue.kt

@@ -0,0 +1,167 @@
+package com.margelo.nitro.nitroplayer
+
+import androidx.annotation.Keep
+import com.facebook.jni.HybridData
+import com.facebook.proguard.annotations.DoNotStrip
+import com.margelo.nitro.NitroModules
+import com.margelo.nitro.core.NullType
+import com.margelo.nitro.nitroplayer.core.TrackPlayerCore
+import com.margelo.nitro.nitroplayer.playlist.PlaylistManager
+import java.util.UUID
+import com.margelo.nitro.nitroplayer.playlist.Playlist as InternalPlaylist
+
+class HybridPlayerQueue : HybridPlayerQueueSpec() {
+    private val core: TrackPlayerCore
+    private val playlistManager: PlaylistManager
+
+    init {
+        val context = NitroModules.applicationContext ?: throw IllegalStateException("React Context is not initialized")
+        core = TrackPlayerCore.getInstance(context)
+        playlistManager = core.getPlaylistManager()
+    }
+
+    private var playlistsChangeListener: (() -> Unit)? = null
+    private val playlistChangeListeners = mutableMapOf<String, () -> Unit>()
+
+    @DoNotStrip
+    @Keep
+    override fun createPlaylist(
+        name: String,
+        description: String?,
+        artwork: String?,
+    ): String = playlistManager.createPlaylist(name, description, artwork)
+
+    @DoNotStrip
+    @Keep
+    override fun deletePlaylist(playlistId: String) {
+        playlistManager.deletePlaylist(playlistId)
+    }
+
+    @DoNotStrip
+    @Keep
+    override fun updatePlaylist(
+        playlistId: String,
+        name: String?,
+        description: String?,
+        artwork: String?,
+    ) {
+        playlistManager.updatePlaylist(playlistId, name, description, artwork)
+    }
+
+    @DoNotStrip
+    @Keep
+    override fun getPlaylist(playlistId: String): Variant_NullType_Playlist {
+        val playlist = playlistManager.getPlaylist(playlistId)
+        return if (playlist != null) {
+            Variant_NullType_Playlist.create(playlist.toPlaylist())
+        } else {
+            Variant_NullType_Playlist.create(NullType.NULL)
+        }
+    }
+
+    @DoNotStrip
+    @Keep
+    override fun getAllPlaylists(): Array<Playlist> =
+        playlistManager
+            .getAllPlaylists()
+            .map {
+                it.toPlaylist()
+            }.toTypedArray()
+
+    @DoNotStrip
+    @Keep
+    override fun addTrackToPlaylist(
+        playlistId: String,
+        track: TrackItem,
+        index: Double?,
+    ) {
+        val insertIndex = index?.toInt()
+        playlistManager.addTrackToPlaylist(playlistId, track, insertIndex)
+    }
+
+    @DoNotStrip
+    @Keep
+    override fun addTracksToPlaylist(
+        playlistId: String,
+        tracks: Array<TrackItem>,
+        index: Double?,
+    ) {
+        val insertIndex = index?.toInt()
+        playlistManager.addTracksToPlaylist(playlistId, tracks.toList(), insertIndex)
+    }
+
+    @DoNotStrip
+    @Keep
+    override fun removeTrackFromPlaylist(
+        playlistId: String,
+        trackId: String,
+    ) {
+        playlistManager.removeTrackFromPlaylist(playlistId, trackId)
+    }
+
+    @DoNotStrip
+    @Keep
+    override fun reorderTrackInPlaylist(
+        playlistId: String,
+        trackId: String,
+        newIndex: Double,
+    ) {
+        playlistManager.reorderTrackInPlaylist(playlistId, trackId, newIndex.toInt())
+    }
+
+    @DoNotStrip
+    @Keep
+    override fun loadPlaylist(playlistId: String) {
+        playlistManager.loadPlaylist(playlistId)
+    }
+
+    @DoNotStrip
+    @Keep
+    override fun getCurrentPlaylistId(): Variant_NullType_String {
+        val playlistId = playlistManager.getCurrentPlaylistId()
+        return if (playlistId != null) {
+            Variant_NullType_String.create(playlistId)
+        } else {
+            Variant_NullType_String.create(NullType.NULL)
+        }
+    }
+
+    @DoNotStrip
+    @Keep
+    override fun onPlaylistsChanged(callback: (playlists: Array<Playlist>, operation: QueueOperation?) -> Unit) {
+        // Remove previous listener if exists
+        playlistsChangeListener?.invoke()
+
+        // Add new listener
+        playlistsChangeListener =
+            playlistManager.addPlaylistsChangeListener { playlists, operation ->
+                callback(playlists.map { it.toPlaylist() }.toTypedArray(), operation)
+            }
+    }
+
+    @DoNotStrip
+    @Keep
+    override fun onPlaylistChanged(callback: (playlistId: String, playlist: Playlist, operation: QueueOperation?) -> Unit) {
+        // Listen to all playlists and filter by playlistId
+        val listenerId = UUID.randomUUID().toString()
+
+        // For each playlist, add a listener
+        playlistManager.getAllPlaylists().forEach { internalPlaylist ->
+            val removeListener =
+                playlistManager.addPlaylistChangeListener(internalPlaylist.id) { playlist, operation ->
+                    callback(playlist.id, playlist.toPlaylist(), operation)
+                }
+            playlistChangeListeners[listenerId] = removeListener
+        }
+    }
+
+    // Helper to convert internal Playlist to generated Playlist type
+    private fun InternalPlaylist.toPlaylist(): Playlist =
+        Playlist(
+            id = this.id,
+            name = this.name,
+            description = this.description?.let { Variant_NullType_String.create(it) },
+            artwork = this.artwork?.let { Variant_NullType_String.create(it) },
+            tracks = this.tracks.toTypedArray(),
+        )
+}

package/android/src/main/java/com/margelo/nitro/nitroplayer/HybridTrackPlayer.kt

@@ -0,0 +1,93 @@
+package com.margelo.nitro.nitroplayer
+
+import androidx.annotation.Keep
+import com.facebook.proguard.annotations.DoNotStrip
+import com.margelo.nitro.NitroModules
+import com.margelo.nitro.nitroplayer.core.TrackPlayerCore
+
+class HybridTrackPlayer : HybridTrackPlayerSpec() {
+    private val core: TrackPlayerCore
+
+    init {
+        val context =
+            NitroModules.applicationContext ?: throw IllegalStateException("React Context is not initialized")
+        core = TrackPlayerCore.getInstance(context)
+    }
+
+    @DoNotStrip
+    @Keep
+    override fun play() {
+        core.play()
+    }
+
+    @DoNotStrip
+    @Keep
+    override fun pause() {
+        core.pause()
+    }
+
+    @DoNotStrip
+    @Keep
+    override fun playSong(
+        songId: String,
+        fromPlaylist: String?,
+    ) {
+        core.playSong(songId, fromPlaylist)
+    }
+
+    @DoNotStrip
+    @Keep
+    override fun skipToNext() {
+        core.skipToNext()
+    }
+
+    @DoNotStrip
+    @Keep
+    override fun skipToPrevious() {
+        core.skipToPrevious()
+    }
+
+    @DoNotStrip
+    @Keep
+    override fun seek(position: Double) {
+        core.seek(position)
+    }
+
+    @DoNotStrip
+    @Keep
+    override fun getState(): PlayerState = core.getState()
+
+    override fun onChangeTrack(callback: (track: TrackItem, reason: Reason?) -> Unit) {
+        core.onChangeTrack = callback
+    }
+
+    override fun onPlaybackStateChange(callback: (state: TrackPlayerState, reason: Reason?) -> Unit) {
+        core.onPlaybackStateChange = callback
+    }
+
+    override fun onSeek(callback: (position: Double, totalDuration: Double) -> Unit) {
+        core.onSeek = callback
+    }
+
+    override fun onPlaybackProgressChange(callback: (position: Double, totalDuration: Double, isManuallySeeked: Boolean?) -> Unit) {
+        core.onPlaybackProgressChange = callback
+    }
+
+    @DoNotStrip
+    @Keep
+    override fun configure(config: PlayerConfig) {
+        core.configure(
+            androidAutoEnabled = config.androidAutoEnabled,
+            carPlayEnabled = config.carPlayEnabled,
+            showInNotification = config.showInNotification,
+        )
+    }
+
+    @Keep
+    override fun onAndroidAutoConnectionChange(callback: (Boolean) -> Unit) {
+        core.onAndroidAutoConnectionChange = callback
+    }
+
+    @Keep
+    override fun isAndroidAutoConnected(): Boolean = core.isAndroidAutoConnected()
+}

package/android/src/main/java/com/margelo/nitro/nitroplayer/NitroPlayerPackage.kt

@@ -0,0 +1,21 @@
+package com.margelo.nitro.nitroplayer
+
+import com.facebook.react.BaseReactPackage
+import com.facebook.react.bridge.NativeModule
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.module.model.ReactModuleInfoProvider
+
+class NitroPlayerPackage : BaseReactPackage() {
+    override fun getModule(
+        name: String,
+        reactContext: ReactApplicationContext,
+    ): NativeModule? = null
+
+    override fun getReactModuleInfoProvider(): ReactModuleInfoProvider = ReactModuleInfoProvider { HashMap() }
+
+    companion object {
+        init {
+            NitroPlayerOnLoad.initializeNative()
+        }
+    }
+}