@siteed/audio-studio 3.0.0

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

@@ -0,0 +1,259 @@
+package net.siteed.audiostudio
+
+import android.media.AudioFormat
+import android.os.Build
+import java.io.File
+
+// New output configuration structure
+data class OutputConfig(
+    val primary: PrimaryOutput = PrimaryOutput(),
+    val compressed: CompressedOutput = CompressedOutput()
+) {
+    data class PrimaryOutput(
+        val enabled: Boolean = true,
+        val format: String = "wav"
+    )
+    
+    data class CompressedOutput(
+        val enabled: Boolean = false,
+        val format: String = "aac",
+        val bitrate: Int = 128000,
+        val preferRawStream: Boolean = false
+    )
+    
+    companion object {
+        fun fromMap(map: Map<String, Any?>?): OutputConfig {
+            if (map == null) return OutputConfig()
+            
+            val primaryMap = map.getTypedMap<Any?>("primary") { true }
+            val compressedMap = map.getTypedMap<Any?>("compressed") { true }
+            
+            val primary = PrimaryOutput(
+                enabled = primaryMap.getBooleanOrDefault("enabled", true),
+                format = primaryMap.getStringOrDefault("format", "wav")
+            )
+            
+            val compressed = CompressedOutput(
+                enabled = compressedMap.getBooleanOrDefault("enabled", false),
+                format = compressedMap.getStringOrDefault("format", "aac").lowercase(),
+                bitrate = compressedMap.getNumberOrDefault("bitrate", 128000),
+                preferRawStream = compressedMap.getBooleanOrDefault("preferRawStream", false)
+            )
+            
+            return OutputConfig(primary = primary, compressed = compressed)
+        }
+    }
+}
+
+data class RecordingConfig(
+    val sampleRate: Int = Constants.DEFAULT_SAMPLE_RATE,
+    val channels: Int = 1,
+    val encoding: String = "pcm_16bit",
+    val keepAwake: Boolean = true,
+    val interval: Long = Constants.DEFAULT_INTERVAL,
+    val intervalAnalysis: Long = Constants.DEFAULT_INTERVAL_ANALYSIS,
+    val enableProcessing: Boolean = false,
+    val segmentDurationMs: Int = 100,
+    val showNotification: Boolean = false,
+    val showWaveformInNotification: Boolean = false,
+    val notification: NotificationConfig = NotificationConfig(),
+    val features: Map<String, Boolean> = emptyMap(),
+    val output: OutputConfig = OutputConfig(),
+    val autoResumeAfterInterruption: Boolean = false,
+    val outputDirectory: String? = null,
+    val filename: String? = null,
+    val deviceId: String? = null,
+    val deviceDisconnectionBehavior: String? = null,
+    val audioFocusStrategy: String? = null,
+    val bufferDurationSeconds: Double? = null,
+    val streamFormat: String = "raw",
+) {
+    companion object {
+        fun fromMap(options: Map<String, Any?>?): Result<Pair<RecordingConfig, AudioFormatInfo>> {
+            if (options == null) {
+                val defaultConfig = RecordingConfig()
+                val defaultFormat = AudioFormatInfo(
+                    format = AudioFormat.ENCODING_PCM_16BIT,
+                    mimeType = "audio/wav",
+                    fileExtension = "wav"
+                )
+                return Result.success(Pair(defaultConfig, defaultFormat))
+            }
+
+            // Extract features using type-safe helper
+            val features = options.getTypedMap<Boolean>("features") { it is Boolean }
+
+            // Parse notification config using type-safe helper
+            val notificationMap = options.getTypedMap<Any?>("notification") { true }
+            val notificationConfig = NotificationConfig.fromMap(notificationMap)
+
+            // Parse output config
+            val outputMap = options.getTypedMap<Any?>("output") { true }
+            val outputConfig = OutputConfig.fromMap(outputMap)
+
+            // Validate bitrate if compression is enabled
+            if (outputConfig.compressed.enabled) {
+                when {
+                    outputConfig.compressed.bitrate < 8000 -> return Result.failure(
+                        IllegalArgumentException("Bitrate must be at least 8000 bps")
+                    )
+                    outputConfig.compressed.bitrate > 960000 -> return Result.failure(
+                        IllegalArgumentException("Bitrate cannot exceed 960000 bps")
+                    )
+                }
+            }
+
+            // Only validate directory if it's provided
+            val outputDirectory = options["outputDirectory"] as? String
+            if (outputDirectory != null) {
+                // Clean up the directory path by removing file:// protocol and normalizing
+                val cleanDirectory = outputDirectory
+                    .replace(Regex("^file://"), "")
+                    .trim('/')
+                    .replace("//", "/")
+
+                val directory = File(cleanDirectory)
+                if (!directory.exists()) {
+                    return Result.failure(IllegalArgumentException("Directory does not exist: $cleanDirectory"))
+                }
+                if (!directory.isDirectory) {
+                    return Result.failure(IllegalArgumentException("Path is not a directory: $cleanDirectory"))
+                }
+                if (!directory.canWrite()) {
+                    return Result.failure(IllegalArgumentException("Directory is not writable: $cleanDirectory"))
+                }
+            }
+
+            // Get device-related settings
+            val deviceId = options["deviceId"] as? String
+            val deviceDisconnectionBehavior = options["deviceDisconnectionBehavior"] as? String
+            
+            // Get Android-specific settings
+            val androidConfig = options["android"] as? Map<String, Any>
+            val audioFocusStrategy = androidConfig?.get("audioFocusStrategy") as? String
+
+            // Initialize the recording configuration with cleaned directory path
+            val tempRecordingConfig = RecordingConfig(
+                sampleRate = options.getNumberOrDefault("sampleRate", Constants.DEFAULT_SAMPLE_RATE),
+                channels = options.getNumberOrDefault("channels", 1),
+                encoding = options.getStringOrDefault("encoding", "pcm_16bit"),
+                keepAwake = options.getBooleanOrDefault("keepAwake", true),
+                // Enforce minimum intervals to prevent excessive CPU usage
+                interval = maxOf(Constants.MIN_INTERVAL, options.getNumberOrDefault("interval", Constants.DEFAULT_INTERVAL)),
+                intervalAnalysis = maxOf(Constants.MIN_INTERVAL, options.getNumberOrDefault("intervalAnalysis", Constants.DEFAULT_INTERVAL_ANALYSIS)),
+                enableProcessing = options.getBooleanOrDefault("enableProcessing", false),
+                segmentDurationMs = options.getNumberOrDefault("segmentDurationMs", 100),
+                showNotification = options.getBooleanOrDefault("showNotification", false),
+                showWaveformInNotification = options.getBooleanOrDefault("showWaveformInNotification", false),
+                notification = notificationConfig,
+                features = features,
+                output = outputConfig,
+                autoResumeAfterInterruption = options.getBooleanOrDefault("autoResumeAfterInterruption", false),
+                outputDirectory = outputDirectory?.let {
+                    it.replace(Regex("^file://"), "")
+                        .trim('/')
+                        .replace("//", "/")
+                },
+                filename = options["filename"] as? String,
+                deviceId = deviceId,
+                deviceDisconnectionBehavior = deviceDisconnectionBehavior,
+                audioFocusStrategy = audioFocusStrategy,
+                bufferDurationSeconds = (options["bufferDurationSeconds"] as? Number)?.toDouble(),
+                streamFormat = options.getStringOrDefault("streamFormat", "raw"),
+            )
+
+            // Validate sample rate and channels
+            if (tempRecordingConfig.sampleRate !in listOf(16000, 44100, 48000)) {
+                return Result.failure(
+                    IllegalArgumentException("Sample rate must be one of 16000, 44100, or 48000 Hz")
+                )
+            }
+            if (tempRecordingConfig.channels !in 1..2) {
+                return Result.failure(
+                    IllegalArgumentException("Channels must be either 1 (Mono) or 2 (Stereo)")
+                )
+            }
+
+            // Set encoding and file extension
+            val audioFormatInfo = when (tempRecordingConfig.encoding) {
+                "pcm_8bit" -> AudioFormatInfo(
+                    format = AudioFormat.ENCODING_PCM_8BIT,
+                    mimeType = "audio/wav",
+                    fileExtension = "wav"
+                )
+                "pcm_16bit" -> AudioFormatInfo(
+                    format = AudioFormat.ENCODING_PCM_16BIT,
+                    mimeType = "audio/wav",
+                    fileExtension = "wav"
+                )
+                "pcm_32bit" -> AudioFormatInfo(
+                    format = AudioFormat.ENCODING_PCM_FLOAT,
+                    mimeType = "audio/wav",
+                    fileExtension = "wav"
+                )
+                "opus" -> {
+                    if (Build.VERSION.SDK_INT < 29) {
+                        return Result.failure(
+                            IllegalArgumentException("Opus encoding not supported on this Android version.")
+                        )
+                    }
+                    AudioFormatInfo(
+                        format = if (Build.VERSION.SDK_INT >= 29) 20 else AudioFormat.ENCODING_DEFAULT, // 20 is ENCODING_OPUS
+                        mimeType = "audio/opus",
+                        fileExtension = "opus"
+                    )
+                }
+                "aac_lc" -> AudioFormatInfo(
+                    format = AudioFormat.ENCODING_AAC_LC,
+                    mimeType = "audio/aac",
+                    fileExtension = "aac"
+                )
+                else -> AudioFormatInfo(
+                    format = AudioFormat.ENCODING_DEFAULT,
+                    mimeType = "audio/wav",
+                    fileExtension = "wav"
+                )
+            }
+
+            return Result.success(Pair(tempRecordingConfig, audioFormatInfo))
+        }
+    }
+}
+
+// Extension functions for type-safe map access
+private inline fun <reified T> Map<String, Any?>.getTypedMap(
+    key: String,
+    predicate: (Any?) -> Boolean
+): Map<String, T> {
+    return (this[key] as? Map<*, *>)?.mapNotNull { (k, v) ->
+        if (k is String && predicate(v)) {
+            k to (v as T)
+        } else null
+    }?.toMap() ?: emptyMap()
+}
+
+private fun Map<String, Any?>.getStringOrDefault(key: String, default: String): String {
+    return this[key] as? String ?: default
+}
+
+private fun Map<String, Any?>.getBooleanOrDefault(key: String, default: Boolean): Boolean {
+    return this[key] as? Boolean ?: default
+}
+
+private fun Map<String, Any?>.getNumberOrDefault(key: String, default: Int): Int {
+    return (this[key] as? Number)?.toInt() ?: default
+}
+
+private fun Map<String, Any?>.getNumberOrDefault(key: String, default: Long): Long {
+    return (this[key] as? Number)?.toLong() ?: default
+}
+
+private fun Map<String, Any?>.getNumberOrDefault(key: String, default: Double): Double {
+    return (this[key] as? Number)?.toDouble() ?: default
+}
+
+data class AudioFormatInfo(
+    val format: Int,
+    val mimeType: String,
+    val fileExtension: String
+)

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

@@ -0,0 +1,19 @@
+package net.siteed.audiostudio
+
+/**
+ * Configuration for the notification waveform visualization
+ * @property color The color of the waveform (e.g., "#FFFFFF" for white)
+ * @property opacity Opacity of the waveform (0.0-1.0)
+ * @property strokeWidth Width of the waveform line (default: 1.5f)
+ * @property style Drawing style: "stroke" for outline, "fill" for solid
+ * @property mirror Whether to mirror the waveform (symmetrical display)
+ * @property height Height of the waveform view in dp (default: 64)
+ */
+data class WaveformConfig(
+    val color: String = "#FFFFFF",
+    val opacity: Float = 1.0f,
+    val strokeWidth: Float = 1.5f,
+    val style: String = "stroke", // "stroke" or "fill"
+    val mirror: Boolean = true,
+    val height: Int = 64
+)

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

@@ -0,0 +1,159 @@
+// WaveformRenderer.kt
+package net.siteed.audiostudio
+
+import android.graphics.Bitmap
+import android.graphics.Canvas
+import android.graphics.Color
+import android.graphics.Paint
+import android.graphics.Path
+import kotlin.math.abs
+
+class WaveformRenderer {
+    private enum class Style {
+        STROKE,
+        FILL
+    }
+
+    private data class RenderConfig(
+        val color: Int = Color.WHITE,
+        val opacity: Float = 1.0f,
+        val strokeWidth: Float = 1.5f,
+        val style: Style = Style.STROKE,
+        val mirror: Boolean = true,
+        val height: Int = 64
+    ) {
+        companion object {
+            fun fromConfig(config: WaveformConfig?): RenderConfig {
+                if (config == null) return RenderConfig()
+
+                return RenderConfig(
+                    color = try {
+                        Color.parseColor(config.color)
+                    } catch (e: Exception) {
+                        Color.WHITE
+                    },
+                    opacity = config.opacity.coerceIn(0f, 1f),
+                    strokeWidth = config.strokeWidth.coerceAtLeast(0.5f),
+                    style = when (config.style.lowercase()) {
+                        "fill" -> Style.FILL
+                        else -> Style.STROKE
+                    },
+                    mirror = config.mirror,
+                    height = config.height.coerceIn(32, 128)
+                )
+            }
+        }
+    }
+
+    fun generateWaveform(audioData: FloatArray, config: WaveformConfig?): Bitmap {
+        return generateWaveform(audioData, RenderConfig.fromConfig(config))
+    }
+
+    fun e(audioData: FloatArray): Bitmap {
+        return generateWaveform(audioData, RenderConfig())
+    }
+
+    private fun generateWaveform(audioData: FloatArray, config: RenderConfig): Bitmap {
+        val width = 400 // Fixed width for notification
+        val height = config.height
+        val bitmap = Bitmap.createBitmap(width, height, Bitmap.Config.ARGB_8888)
+        val canvas = Canvas(bitmap)
+
+        val paint = Paint().apply {
+            color = config.color
+            alpha = (config.opacity * 255).toInt()
+            strokeWidth = config.strokeWidth
+            isAntiAlias = true
+            style = when (config.style) {
+                Style.FILL -> Paint.Style.FILL
+                Style.STROKE -> Paint.Style.STROKE
+            }
+            strokeCap = Paint.Cap.ROUND
+        }
+
+        canvas.drawColor(Color.TRANSPARENT)
+
+        val centerY = height / 2f
+        val pointsPerSegment = (audioData.size / width.toFloat()).coerceAtLeast(1f)
+        val path = Path()
+
+        // Calculate max amplitude for scaling
+        val maxAmplitude = audioData.maxOf { abs(it) }.coerceAtLeast(0.01f)
+        val scaleFactor = (height * 0.4f) / maxAmplitude
+
+        drawWaveform(path, audioData, width, centerY, pointsPerSegment, scaleFactor)
+
+        if (config.mirror) {
+            drawMirroredWaveform(path, audioData, width, centerY, pointsPerSegment, scaleFactor)
+        }
+
+        // Add shadow for filled style
+        if (config.style == Style.FILL) {
+            paint.setShadowLayer(4f, 0f, 2f, Color.argb(50, 0, 0, 0))
+        }
+
+        canvas.drawPath(path, paint)
+        return bitmap
+    }
+
+    private fun drawWaveform(
+        path: Path,
+        audioData: FloatArray,
+        width: Int,
+        centerY: Float,
+        pointsPerSegment: Float,
+        scaleFactor: Float
+    ) {
+        var firstPoint = true
+        for (i in 0 until width) {
+            val startIdx = (i * pointsPerSegment).toInt()
+            val endIdx = ((i + 1) * pointsPerSegment).toInt().coerceAtMost(audioData.size)
+
+            val avgAmplitude = calculateAverageAmplitude(audioData, startIdx, endIdx, scaleFactor)
+
+            val x = i.toFloat()
+            val y = centerY - avgAmplitude
+
+            if (firstPoint) {
+                path.moveTo(x, y)
+                firstPoint = false
+            } else {
+                path.lineTo(x, y)
+            }
+        }
+    }
+
+    private fun drawMirroredWaveform(
+        path: Path,
+        audioData: FloatArray,
+        width: Int,
+        centerY: Float,
+        pointsPerSegment: Float,
+        scaleFactor: Float
+    ) {
+        for (i in width - 1 downTo 0) {
+            val startIdx = (i * pointsPerSegment).toInt()
+            val endIdx = ((i + 1) * pointsPerSegment).toInt().coerceAtMost(audioData.size)
+
+            val avgAmplitude = calculateAverageAmplitude(audioData, startIdx, endIdx, scaleFactor)
+            path.lineTo(i.toFloat(), centerY + avgAmplitude)
+        }
+        path.close()
+    }
+
+    private fun calculateAverageAmplitude(
+        audioData: FloatArray,
+        startIdx: Int,
+        endIdx: Int,
+        scaleFactor: Float
+    ): Float {
+        return if (endIdx > startIdx) {
+            audioData.slice(startIdx until endIdx)
+                .map { abs(it) }
+                .average()
+                .toFloat() * scaleFactor
+        } else {
+            0f
+        }
+    }
+}

package/android/src/main/jni/AudioFeaturesJNI.cpp

@@ -0,0 +1,152 @@
+#include <jni.h>
+#include <android/log.h>
+#include "AudioFeatures.h"
+#include <memory>
+#include <mutex>
+
+#define LOG_TAG "AudioFeaturesJNI"
+#define LOGI(...) __android_log_print(ANDROID_LOG_INFO, LOG_TAG, __VA_ARGS__)
+#define LOGE(...) __android_log_print(ANDROID_LOG_ERROR, LOG_TAG, __VA_ARGS__)
+
+static std::unique_ptr<AudioFeaturesProcessor> cachedProcessor;
+static std::mutex cachedMutex;
+
+extern "C" JNIEXPORT void JNICALL
+Java_net_siteed_audiostudio_AudioFeaturesNative_init(
+    JNIEnv* env, jobject /* thiz */,
+    jint sampleRate, jint fftLength, jint nMfcc, jint nMelFilters,
+    jboolean computeMfcc, jboolean computeChroma)
+{
+    AudioFeaturesConfig config;
+    config.sampleRate = sampleRate;
+    config.fftLength = fftLength;
+    config.nMfcc = nMfcc;
+    config.nMelFilters = nMelFilters;
+    config.computeMfcc = computeMfcc;
+    config.computeChroma = computeChroma;
+
+    std::lock_guard<std::mutex> lock(cachedMutex);
+    if (!cachedProcessor || !(cachedProcessor->config() == config)) {
+        cachedProcessor = std::make_unique<AudioFeaturesProcessor>(config);
+    }
+    LOGI("init: sampleRate=%d, fftLength=%d, nMfcc=%d, nMelFilters=%d",
+         sampleRate, fftLength, nMfcc, nMelFilters);
+}
+
+extern "C" JNIEXPORT jobject JNICALL
+Java_net_siteed_audiostudio_AudioFeaturesNative_computeFrame(
+    JNIEnv* env, jobject /* thiz */,
+    jfloatArray jSamples, jint sampleRate, jint fftLength,
+    jint nMfcc, jint nMelFilters, jboolean computeMfcc, jboolean computeChroma)
+{
+    jfloat* samples = env->GetFloatArrayElements(jSamples, nullptr);
+    if (!samples) {
+        LOGE("computeFrame: failed to get samples array");
+        return nullptr;
+    }
+    jint numSamples = env->GetArrayLength(jSamples);
+
+    AudioFeaturesConfig config;
+    config.sampleRate = sampleRate;
+    config.fftLength = fftLength;
+    config.nMfcc = nMfcc;
+    config.nMelFilters = nMelFilters;
+    config.computeMfcc = computeMfcc;
+    config.computeChroma = computeChroma;
+
+    std::lock_guard<std::mutex> lock(cachedMutex);
+    if (!cachedProcessor || !(cachedProcessor->config() == config)) {
+        cachedProcessor = std::make_unique<AudioFeaturesProcessor>(config);
+    }
+
+    AudioFeaturesResult result = cachedProcessor->compute(samples, numSamples);
+
+    env->ReleaseFloatArrayElements(jSamples, samples, JNI_ABORT);
+
+    LOGI("computeFrame: centroid=%.2f, flatness=%.6f, rolloff=%.2f, bandwidth=%.2f, mfcc_size=%d, chroma_size=%d",
+         result.spectralCentroid, result.spectralFlatness,
+         result.spectralRolloff, result.spectralBandwidth,
+         (int)result.mfcc.size(), (int)result.chromagram.size());
+
+    // Build HashMap<String, Object>
+    jclass hashMapClass = env->FindClass("java/util/HashMap");
+    if (!hashMapClass || env->ExceptionCheck()) {
+        LOGE("computeFrame: failed to find HashMap class");
+        env->ExceptionClear();
+        return nullptr;
+    }
+    jmethodID hashMapInit = env->GetMethodID(hashMapClass, "<init>", "()V");
+    jmethodID hashMapPut = env->GetMethodID(hashMapClass, "put",
+        "(Ljava/lang/Object;Ljava/lang/Object;)Ljava/lang/Object;");
+    if (!hashMapInit || !hashMapPut || env->ExceptionCheck()) {
+        LOGE("computeFrame: failed to get HashMap methods");
+        env->ExceptionClear();
+        env->DeleteLocalRef(hashMapClass);
+        return nullptr;
+    }
+
+    jobject map = env->NewObject(hashMapClass, hashMapInit);
+    if (!map) {
+        LOGE("computeFrame: failed to create HashMap");
+        env->DeleteLocalRef(hashMapClass);
+        return nullptr;
+    }
+
+    // Helper: box a float as java.lang.Float
+    jclass floatClass = env->FindClass("java/lang/Float");
+    jmethodID floatValueOf = env->GetStaticMethodID(floatClass, "valueOf", "(F)Ljava/lang/Float;");
+    if (!floatClass || !floatValueOf || env->ExceptionCheck()) {
+        LOGE("computeFrame: failed to get Float class/method");
+        env->ExceptionClear();
+        if (floatClass) env->DeleteLocalRef(floatClass);
+        env->DeleteLocalRef(hashMapClass);
+        return map; // return partial map with no values
+    }
+
+    // Put scalar values
+    auto putFloat = [&](const char* key, float value) {
+        jstring jKey = env->NewStringUTF(key);
+        if (!jKey) return;
+        jobject jVal = env->CallStaticObjectMethod(floatClass, floatValueOf, value);
+        env->CallObjectMethod(map, hashMapPut, jKey, jVal);
+        env->DeleteLocalRef(jKey);
+        env->DeleteLocalRef(jVal);
+    };
+
+    putFloat("spectralCentroid", result.spectralCentroid);
+    putFloat("spectralFlatness", result.spectralFlatness);
+    putFloat("spectralRolloff", result.spectralRolloff);
+    putFloat("spectralBandwidth", result.spectralBandwidth);
+
+    // Put MFCC array
+    if (!result.mfcc.empty()) {
+        jfloatArray jMfcc = env->NewFloatArray(static_cast<jsize>(result.mfcc.size()));
+        if (jMfcc) {
+            env->SetFloatArrayRegion(jMfcc, 0, static_cast<jsize>(result.mfcc.size()), result.mfcc.data());
+            jstring key = env->NewStringUTF("mfcc");
+            if (key) {
+                env->CallObjectMethod(map, hashMapPut, key, jMfcc);
+                env->DeleteLocalRef(key);
+            }
+            env->DeleteLocalRef(jMfcc);
+        }
+    }
+
+    // Put chromagram array
+    if (!result.chromagram.empty()) {
+        jfloatArray jChroma = env->NewFloatArray(static_cast<jsize>(result.chromagram.size()));
+        if (jChroma) {
+            env->SetFloatArrayRegion(jChroma, 0, static_cast<jsize>(result.chromagram.size()), result.chromagram.data());
+            jstring key = env->NewStringUTF("chromagram");
+            if (key) {
+                env->CallObjectMethod(map, hashMapPut, key, jChroma);
+                env->DeleteLocalRef(key);
+            }
+            env->DeleteLocalRef(jChroma);
+        }
+    }
+
+    env->DeleteLocalRef(floatClass);
+    env->DeleteLocalRef(hashMapClass);
+    return map;
+}