@siteed/audio-studio 3.0.0

package/android/src/main/java/net/siteed/audiostudio/Constants.kt

@@ -0,0 +1,37 @@
+package net.siteed.audiostudio
+
+/**
+ * Constants used throughout the AudioStudio module
+ */
+object Constants {
+    // Event names
+    const val TAG = "AudioStudio"
+    const val AUDIO_EVENT_NAME = "AudioData"
+    const val AUDIO_ANALYSIS_EVENT_NAME = "AudioAnalysis"
+    const val RECORDING_INTERRUPTED_EVENT_NAME = "onRecordingInterrupted"
+    const val TRIM_PROGRESS_EVENT = "TrimProgress"
+    const val DEVICE_CHANGED_EVENT = "deviceChangedEvent"
+    
+    // Audio constants
+    const val DEFAULT_SAMPLE_RATE = 16000 // Default sample rate for audio recording
+    const val DEFAULT_CHANNEL_CONFIG = 1 // Mono
+    const val DEFAULT_AUDIO_FORMAT = 16 // 16-bit PCM
+    const val DEFAULT_INTERVAL = 1000L
+    const val DEFAULT_INTERVAL_ANALYSIS = 500L
+    const val MIN_INTERVAL = 10L // Minimum interval in ms for emitting audio data
+    const val WAV_HEADER_SIZE = 44
+    const val RIFF_HEADER = 0x52494646 // "RIFF"
+    const val WAVE_HEADER = 0x57415645 // "WAVE"
+    const val FMT_CHUNK_ID = 0x666d7420 // "fmt "
+    const val DATA_CHUNK_ID = 0x64617461 // "data"
+    const val INFO_CHUNK_ID = 0x494E464F // "info"
+    
+    // Device constants
+    const val DEVICE_TYPE_BUILTIN_MIC = "builtin_mic"
+    const val DEVICE_TYPE_BLUETOOTH = "bluetooth"
+    const val DEVICE_TYPE_USB = "usb"
+    const val DEVICE_TYPE_WIRED_HEADSET = "wired_headset"
+    const val DEVICE_TYPE_WIRED_HEADPHONES = "wired_headphones"
+    const val DEVICE_TYPE_SPEAKER = "speaker"
+    const val DEVICE_TYPE_UNKNOWN = "unknown"
+}

package/android/src/main/java/net/siteed/audiostudio/EventSender.kt

@@ -0,0 +1,7 @@
+package net.siteed.audiostudio
+
+import android.os.Bundle
+
+interface EventSender {
+    fun sendExpoEvent(eventName: String, params: Bundle)
+}

package/android/src/main/java/net/siteed/audiostudio/FFT.kt

@@ -0,0 +1,100 @@
+// packages/audio-studio/android/src/main/java/net/siteed/audiostudio/FFT.kt
+package net.siteed.audiostudio
+
+import kotlin.math.PI
+import kotlin.math.cos
+import kotlin.math.sin
+import kotlin.math.sqrt
+
+@Deprecated("Use MelSpectrogramNative C++ implementation instead")
+class FFT(private val n: Int) {
+    private val cosTable = FloatArray(n / 2)
+    private val sinTable = FloatArray(n / 2)
+    private val hannWindow = FloatArray(n)
+
+    init {
+        // Precompute trig tables
+        for (i in 0 until n / 2) {
+            cosTable[i] = cos(2.0 * PI * i / n).toFloat()
+            sinTable[i] = sin(2.0 * PI * i / n).toFloat()
+        }
+        
+        // Precompute normalized Hann window to match vDSP
+        val normalizationFactor = sqrt(2.0f / n)  // Match vDSP normalization
+        for (i in hannWindow.indices) {
+            hannWindow[i] = normalizationFactor * 0.5f * (1 - cos(2.0 * PI * i / (n - 1))).toFloat()
+        }
+    }
+
+    fun processSegment(segment: FloatArray): FloatArray {
+        // Pad or truncate input to match FFT length
+        val paddedSegment = if (segment.size < n) {
+            segment + FloatArray(n - segment.size)
+        } else {
+            segment.copyOf(n)
+        }
+
+        // Apply normalized Hann window
+        for (i in paddedSegment.indices) {
+            paddedSegment[i] *= hannWindow[i]
+        }
+
+        // Perform FFT
+        realForward(paddedSegment)
+
+        return paddedSegment
+    }
+
+    fun realForward(data: FloatArray) {
+        realForwardRecursive(data)
+    }
+
+    private fun realForwardRecursive(data: FloatArray) {
+        val n = data.size
+        if (n <= 1) return
+
+        val even = FloatArray(n / 2)
+        val odd = FloatArray(n / 2)
+
+        for (i in 0 until n / 2) {
+            even[i] = data[2 * i]
+            odd[i] = data[2 * i + 1]
+        }
+
+        realForwardRecursive(even)
+        realForwardRecursive(odd)
+
+        for (i in 0 until n / 2) {
+            val t = cosTable[i] * odd[i] - sinTable[i] * even[i]
+            val u = sinTable[i] * odd[i] + cosTable[i] * even[i]
+            data[i] = even[i] + t
+            data[i + n / 2] = even[i] - t
+        }
+    }
+
+    fun realInverse(powerSpectrum: FloatArray, output: FloatArray) {
+        // Copy power spectrum to complex format for inverse FFT
+        val complexData = FloatArray(n * 2)
+        for (i in 0 until n/2 + 1) {
+            complexData[2 * i] = powerSpectrum[i]
+            if (2 * i + 1 < complexData.size) {
+                complexData[2 * i + 1] = 0f
+            }
+        }
+
+        // Conjugate for inverse FFT
+        for (i in 0 until n) {
+            if (2 * i + 1 < complexData.size) {
+                complexData[2 * i + 1] = -complexData[2 * i + 1]
+            }
+        }
+
+        // Perform forward FFT (which is inverse when input is conjugated)
+        realForward(complexData)
+
+        // Copy real part to output and conjugate again
+        for (i in 0 until n) {
+            output[i] = complexData[2 * i] / n
+        }
+    }
+}

package/android/src/main/java/net/siteed/audiostudio/Features.kt

@@ -0,0 +1,98 @@
+package net.siteed.audiostudio
+
+import android.os.Bundle
+import androidx.core.os.bundleOf
+
+data class Features(
+    val energy: Float = 0f,
+    val mfcc: List<Float> = emptyList(),
+    val rms: Float = 0f,
+    val minAmplitude: Float = 0f,
+    val maxAmplitude: Float = 0f,
+    val zcr: Float = 0f,
+    val spectralCentroid: Float = 0f,
+    val spectralFlatness: Float = 0f,
+    val spectralRolloff: Float = 0f,
+    val spectralBandwidth: Float = 0f,
+    val tempo: Float = 0f,
+    val hnr: Float = 0f,
+    val melSpectrogram: List<Float> = emptyList(),
+    val chromagram: List<Float> = emptyList(),
+    val spectralContrast: List<Float> = emptyList(),
+    val tonnetz: List<Float> = emptyList(),
+    val pitch: Float = 0f,
+    val crc32: Long? = null
+) {
+    fun toDictionary(): Map<String, Any> {
+        val baseMap = mapOf(
+            "energy" to energy,
+            "mfcc" to mfcc,
+            "rms" to rms,
+            "minAmplitude" to minAmplitude,
+            "maxAmplitude" to maxAmplitude,
+            "zcr" to zcr,
+            "spectralCentroid" to spectralCentroid,
+            "spectralFlatness" to spectralFlatness,
+            "spectralRolloff" to spectralRolloff,
+            "spectralBandwidth" to spectralBandwidth,
+            "tempo" to tempo,
+            "hnr" to hnr,
+            "melSpectrogram" to melSpectrogram,
+            "chromagram" to chromagram,
+            "spectralContrast" to spectralContrast,
+            "tonnetz" to tonnetz,
+            "pitch" to pitch,
+            "crc32" to (crc32 ?: 0)
+        )
+        return baseMap.filterValues { it != null }
+    }
+
+    fun toBundle(): Bundle {
+        return bundleOf(
+            "energy" to energy,
+            "mfcc" to mfcc,
+            "rms" to rms,
+            "minAmplitude" to minAmplitude,
+            "maxAmplitude" to maxAmplitude,
+            "zcr" to zcr,
+            "spectralCentroid" to spectralCentroid,
+            "spectralFlatness" to spectralFlatness,
+            "spectralRolloff" to spectralRolloff,
+            "spectralBandwidth" to spectralBandwidth,
+            "tempo" to tempo,
+            "hnr" to hnr,
+            "melSpectrogram" to melSpectrogram,
+            "chromagram" to chromagram,
+            "spectralContrast" to spectralContrast,
+            "tonnetz" to tonnetz,
+            "pitch" to pitch,
+            "crc32" to (crc32 ?: 0)
+        )
+    }
+
+    companion object {
+        fun parseFeatureOptions(options: Map<*, *>?): Map<String, Boolean> {
+            return options?.let { map ->
+                mapOf(
+                    "energy" to (map["energy"] as? Boolean ?: false),
+                    "mfcc" to (map["mfcc"] as? Boolean ?: false),
+                    "rms" to (map["rms"] as? Boolean ?: false),
+                    "zcr" to (map["zcr"] as? Boolean ?: false),
+                    "dB" to (map["dB"] as? Boolean ?: false),
+                    "spectralCentroid" to (map["spectralCentroid"] as? Boolean ?: false),
+                    "spectralFlatness" to (map["spectralFlatness"] as? Boolean ?: false),
+                    "spectralRolloff" to (map["spectralRolloff"] as? Boolean ?: false),
+                    "spectralBandwidth" to (map["spectralBandwidth"] as? Boolean ?: false),
+                    "chromagram" to (map["chromagram"] as? Boolean ?: false),
+                    "tempo" to (map["tempo"] as? Boolean ?: false),
+                    "hnr" to (map["hnr"] as? Boolean ?: false),
+                    "melSpectrogram" to (map["melSpectrogram"] as? Boolean ?: false),
+                    "spectralContrast" to (map["spectralContrast"] as? Boolean ?: false),
+                    "tonnetz" to (map["tonnetz"] as? Boolean ?: false),
+                    "pitch" to (map["pitch"] as? Boolean ?: false),
+                    "crc32" to (map["crc32"] as? Boolean ?: false)
+                )
+            } ?: emptyMap()
+        }
+    }
+}

package/android/src/main/java/net/siteed/audiostudio/LogUtils.kt

@@ -0,0 +1,93 @@
+package net.siteed.audiostudio
+
+import android.util.Log
+
+/**
+ * Utility class for standardized logging across the AudioStudio library.
+ * Provides consistent logging format and tags for easier filtering in logcat.
+ */
+object LogUtils {
+    // Format: [AudioStudio:ClassName]
+    private const val TAG_PREFIX = "AudioStudio"
+    
+    // Check if we're running in a test environment
+    private val isInTest: Boolean by lazy {
+        try {
+            Class.forName("org.junit.Test")
+            true
+        } catch (e: ClassNotFoundException) {
+            false
+        }
+    }
+    
+    /**
+     * Logs a debug message with a consistent format.
+     * 
+     * @param className The name of the class generating the log
+     * @param message The message to log
+     */
+    fun d(className: String, message: String) {
+        if (isInTest) {
+            println("D/$TAG_PREFIX:$className: $message")
+        } else {
+            Log.d("$TAG_PREFIX:$className", message)
+        }
+    }
+    
+    /**
+     * Logs an error message with a consistent format.
+     * 
+     * @param className The name of the class generating the log
+     * @param message The message to log
+     * @param throwable Optional throwable to include in the log
+     */
+    fun e(className: String, message: String, throwable: Throwable? = null) {
+        if (isInTest) {
+            println("E/$TAG_PREFIX:$className: $message")
+            throwable?.printStackTrace()
+        } else {
+            Log.e("$TAG_PREFIX:$className", message, throwable)
+        }
+    }
+    
+    /**
+     * Logs a warning message with a consistent format.
+     * 
+     * @param className The name of the class generating the log
+     * @param message The message to log
+     * @param throwable Optional throwable to include in the log
+     */
+    fun w(className: String, message: String, throwable: Throwable? = null) {
+        if (isInTest) {
+            println("W/$TAG_PREFIX:$className: $message")
+            throwable?.printStackTrace()
+        } else {
+            Log.w("$TAG_PREFIX:$className", message, throwable)
+        }
+    }
+    
+    /**
+     * Logs an info message with a consistent format.
+     * 
+     * @param className The name of the class generating the log
+     * @param message The message to log
+     */
+    fun i(className: String, message: String) {
+        if (isInTest) {
+            println("I/$TAG_PREFIX:$className: $message")
+        } else {
+            Log.i("$TAG_PREFIX:$className", message)
+        }
+    }
+    
+    /**
+     * Creates a formatted tag for direct use with Android Log methods.
+     * Use this if you need to use the Android Log methods directly.
+     * 
+     * @param className The name of the class generating the log
+     * @return A formatted tag string
+     */
+    fun tag(className: String): String {
+        return "$TAG_PREFIX:$className"
+    }
+} 

package/android/src/main/java/net/siteed/audiostudio/MelSpectrogramNative.kt

@@ -0,0 +1,36 @@
+package net.siteed.audiostudio
+
+object MelSpectrogramNative {
+    init {
+        System.loadLibrary("audio-studio-cpp")
+    }
+
+    external fun compute(
+        samples: FloatArray,
+        sampleRate: Int,
+        fftLength: Int,
+        windowSizeSamples: Int,
+        hopLengthSamples: Int,
+        nMels: Int,
+        fMin: Float,
+        fMax: Float,
+        windowType: Int,
+        logScale: Boolean,
+        normalize: Boolean
+    ): Array<FloatArray>
+
+    external fun init(
+        sampleRate: Int,
+        fftLength: Int,
+        windowSizeSamples: Int,
+        hopLengthSamples: Int,
+        nMels: Int,
+        fMin: Float,
+        fMax: Float,
+        windowType: Int
+    )
+
+    external fun computeFrame(frame: FloatArray, melOutput: FloatArray): Boolean
+
+    external fun getNMels(): Int
+}

package/android/src/main/java/net/siteed/audiostudio/NotificationConfig.kt

@@ -0,0 +1,72 @@
+package net.siteed.audiostudio
+
+data class NotificationConfig(
+    val title: String = "Recording...",
+    val text: String = "",
+    val icon: String? = null,
+    val channelId: String = "audio_recording_channel",
+    val notificationId: Int = 1,
+    val actions: List<NotificationAction> = emptyList(),
+    val channelName: String = "Audio Recording",
+    val channelDescription: String = "Shows audio recording status",
+    val waveform: WaveformConfig? = null,
+    val lightColor: String = "#FF0000",
+    val priority: String = "high",
+    val accentColor: String? = null,
+    val showPauseResumeActions: Boolean = true
+) {
+    companion object {
+        fun fromMap(map: Map<String, Any?>?): NotificationConfig {
+            if (map == null) return NotificationConfig()
+
+            val androidMap = map["android"] as? Map<String, Any?> ?: emptyMap()
+
+            return NotificationConfig(
+                title = map["title"] as? String ?: "Recording...",
+                text = map["text"] as? String ?: "",
+                icon = map["icon"] as? String,
+                channelId = androidMap["channelId"] as? String ?: "audio_recording_channel",
+                notificationId = (androidMap["notificationId"] as? Number)?.toInt() ?: 1,
+                actions = parseNotificationActions(androidMap["actions"] as? List<Map<String, Any?>>),
+                channelName = androidMap["channelName"] as? String ?: "Audio Recording",
+                channelDescription = androidMap["channelDescription"] as? String ?: "Shows audio recording status",
+                waveform = parseWaveformConfig(androidMap["waveform"] as? Map<String, Any?>),
+                lightColor = androidMap["lightColor"] as? String ?: "#FF0000",
+                priority = androidMap["priority"] as? String ?: "high",
+                accentColor = androidMap["accentColor"] as? String,
+                showPauseResumeActions = androidMap["showPauseResumeActions"] as? Boolean ?: true
+            )
+        }
+
+        private fun parseNotificationActions(actionsList: List<Map<String, Any?>>?): List<NotificationAction> {
+            return actionsList?.mapNotNull { actionMap ->
+                if (actionMap["title"] != null && actionMap["identifier"] != null) {
+                    NotificationAction(
+                        title = actionMap["title"] as String,
+                        icon = actionMap["icon"] as? String,
+                        intentAction = actionMap["identifier"] as String
+                    )
+                } else null
+            } ?: emptyList()
+        }
+
+        private fun parseWaveformConfig(waveformMap: Map<String, Any?>?): WaveformConfig? {
+            if (waveformMap == null) return null
+
+            return WaveformConfig(
+                color = waveformMap["color"] as? String ?: "#FFFFFF",
+                opacity = (waveformMap["opacity"] as? Number)?.toFloat() ?: 1.0f,
+                strokeWidth = (waveformMap["strokeWidth"] as? Number)?.toFloat() ?: 1.5f,
+                style = waveformMap["style"] as? String ?: "stroke",
+                mirror = waveformMap["mirror"] as? Boolean ?: true,
+                height = (waveformMap["height"] as? Number)?.toInt() ?: 64
+            )
+        }
+    }
+}
+
+data class NotificationAction(
+    val title: String,
+    val icon: String? = null,
+    val intentAction: String
+)

package/android/src/main/java/net/siteed/audiostudio/PermissionUtils.kt

@@ -0,0 +1,68 @@
+package net.siteed.audiostudio
+
+import android.content.Context
+import android.content.pm.PackageManager
+import android.os.Build
+import androidx.core.content.ContextCompat
+import android.Manifest
+import android.util.Log
+
+class PermissionUtils(private val context: Context) {
+    fun checkRecordingPermission(enableBackgroundAudio: Boolean = true): Boolean {
+        val hasRecordPermission = ContextCompat.checkSelfPermission(
+            context,
+            Manifest.permission.RECORD_AUDIO
+        ) == PackageManager.PERMISSION_GRANTED
+
+        Log.d(Constants.TAG, "RECORD_AUDIO permission: $hasRecordPermission")
+
+        // Check for foreground service permission on Android 14+ only if background audio is enabled
+        val hasForegroundService = if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.UPSIDE_DOWN_CAKE && enableBackgroundAudio) {
+            val result = ContextCompat.checkSelfPermission(
+                context,
+                Manifest.permission.FOREGROUND_SERVICE_MICROPHONE
+            ) == PackageManager.PERMISSION_GRANTED
+            Log.d(Constants.TAG, "FOREGROUND_SERVICE_MICROPHONE permission: $result (Android 14+, background audio enabled)")
+            result
+        } else {
+            if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.UPSIDE_DOWN_CAKE) {
+                Log.d(Constants.TAG, "FOREGROUND_SERVICE_MICROPHONE not required (background audio disabled)")
+            } else {
+                Log.d(Constants.TAG, "FOREGROUND_SERVICE_MICROPHONE not required (Android < 14)")
+            }
+            true
+        }
+
+        val result = hasRecordPermission && hasForegroundService
+        Log.d(Constants.TAG, "Final recording permission result: $result")
+        return result
+    }
+
+    // Overload the original method for backward compatibility
+    fun checkRecordingPermission(): Boolean {
+        return checkRecordingPermission(true)
+    }
+
+    fun checkNotificationPermission(): Boolean {
+        val result = if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.TIRAMISU) {
+            val hasPermission = ContextCompat.checkSelfPermission(
+                context,
+                Manifest.permission.POST_NOTIFICATIONS
+            ) == PackageManager.PERMISSION_GRANTED
+            Log.d(Constants.TAG, "POST_NOTIFICATIONS permission: $hasPermission (Android 13+)")
+            hasPermission
+        } else {
+            Log.d(Constants.TAG, "POST_NOTIFICATIONS not required (Android < 13)")
+            true
+        }
+        return result
+    }
+
+    fun checkPhoneStatePermission(): Boolean {
+        return if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
+            context.checkSelfPermission(android.Manifest.permission.READ_PHONE_STATE) == PackageManager.PERMISSION_GRANTED
+        } else {
+            true
+        }
+    }
+}

package/android/src/main/java/net/siteed/audiostudio/RecordingActionReceiver.kt

@@ -0,0 +1,59 @@
+package net.siteed.audiostudio
+
+import android.content.BroadcastReceiver
+import android.content.Context
+import android.content.Intent
+import android.util.Log
+import expo.modules.kotlin.Promise
+import java.util.concurrent.atomic.AtomicBoolean
+
+class RecordingActionReceiver : BroadcastReceiver() {
+    companion object {
+        const val ACTION_PAUSE_RECORDING = "net.siteed.audiostudio.PAUSE_RECORDING"
+        const val ACTION_RESUME_RECORDING = "net.siteed.audiostudio.RESUME_RECORDING"
+        private val isProcessingAction = AtomicBoolean(false)
+    }
+
+    override fun onReceive(context: Context, intent: Intent) {
+        when (intent.action) {
+            ACTION_PAUSE_RECORDING, ACTION_RESUME_RECORDING -> handleRecordingAction(intent.action)
+            else -> Log.w("RecordingActionReceiver", "Unknown action: ${intent.action}")
+        }
+    }
+
+    private fun handleRecordingAction(action: String?) {
+        if (!isProcessingAction.compareAndSet(false, true)) {
+            Log.d("RecordingActionReceiver", "Action already in progress, skipping")
+            return
+        }
+
+        try {
+            val audioRecorderManager = AudioRecorderManager.getInstance()
+            if (audioRecorderManager == null) {
+                Log.e("RecordingActionReceiver", "AudioRecorderManager instance is null")
+                isProcessingAction.set(false)
+                return
+            }
+
+            val notificationPromise = object : Promise {
+                override fun resolve(value: Any?) {
+                    Log.d("RecordingActionReceiver", "$action completed successfully")
+                    isProcessingAction.set(false)
+                }
+
+                override fun reject(code: String, message: String?, cause: Throwable?) {
+                    Log.e("RecordingActionReceiver", "$action failed: $message", cause)
+                    isProcessingAction.set(false)
+                }
+            }
+
+            when (action) {
+                ACTION_PAUSE_RECORDING -> audioRecorderManager.pauseRecording(notificationPromise)
+                ACTION_RESUME_RECORDING -> audioRecorderManager.resumeRecording(notificationPromise)
+            }
+        } catch (e: Exception) {
+            Log.e("RecordingActionReceiver", "Error processing $action", e)
+            isProcessingAction.set(false)
+        }
+    }
+}