@siteed/expo-audio-stream 2.0.1 → 2.2.0

package/android/build.gradle

@@ -1,105 +0,0 @@
-apply plugin: 'com.android.library'
-apply plugin: 'kotlin-android'
-apply plugin: 'maven-publish'
-
-group = 'net.siteed.audiostream'
-version = '0.1.0'
-
-buildscript {
-  def expoModulesCorePlugin = new File(project(":expo-modules-core").projectDir.absolutePath, "ExpoModulesCorePlugin.gradle")
-  if (expoModulesCorePlugin.exists()) {
-    apply from: expoModulesCorePlugin
-    applyKotlinExpoModulesCorePlugin()
-  }
-
-  // Simple helper that allows the root project to override versions declared by this library.
-  ext.safeExtGet = { prop, fallback ->
-    rootProject.ext.has(prop) ? rootProject.ext.get(prop) : fallback
-  }
-
-  // Ensures backward compatibility
-  ext.getKotlinVersion = {
-    if (ext.has("kotlinVersion")) {
-      ext.kotlinVersion()
-    } else {
-      ext.safeExtGet("kotlinVersion", "1.8.10")
-    }
-  }
-
-  repositories {
-    mavenCentral()
-  }
-
-  dependencies {
-    classpath("org.jetbrains.kotlin:kotlin-gradle-plugin:${getKotlinVersion()}")
-  }
-}
-
-afterEvaluate {
-  publishing {
-    publications {
-      release(MavenPublication) {
-        from components.release
-      }
-    }
-    repositories {
-      maven {
-        url = mavenLocal().url
-      }
-    }
-  }
-}
-
-android {
-  compileSdkVersion safeExtGet("compileSdkVersion", 34)
-
-  def agpVersion = com.android.Version.ANDROID_GRADLE_PLUGIN_VERSION
-  if (agpVersion.tokenize('.')[0].toInteger() < 8) {
-    compileOptions {
-      sourceCompatibility JavaVersion.VERSION_17
-      targetCompatibility JavaVersion.VERSION_17
-    }
-
-    tasks.withType(org.jetbrains.kotlin.gradle.tasks.KotlinCompile).configureEach {
-      kotlinOptions {
-        jvmTarget = '17'
-      }
-    }
-  }
-
-  namespace "net.siteed.audiostream"
-  defaultConfig {
-    minSdkVersion safeExtGet("minSdkVersion", 21)
-    targetSdkVersion safeExtGet("targetSdkVersion", 34)
-    versionCode 1
-    versionName "0.1.0"
-  }
-  lintOptions {
-    abortOnError false
-  }
-  publishing {
-    singleVariant("release") {
-      withSourcesJar()
-    }
-  }
-}
-
-repositories {
-  mavenCentral()
-}
-
-dependencies {
-  implementation project(':expo-modules-core')
-  implementation "org.jetbrains.kotlin:kotlin-stdlib-jdk7:${getKotlinVersion()}"
-
-  // Add testing dependencies
-  testImplementation 'junit:junit:4.13.2'
-  testImplementation 'org.jetbrains.kotlin:kotlin-test:1.8.10'
-  testImplementation 'org.jetbrains.kotlin:kotlin-test-junit:1.8.10'
-}
-
-kotlin {
-  jvmToolchain {
-    languageVersion.set(JavaLanguageVersion.of(17))
-  }
-}

package/android/src/main/AndroidManifest.xml

@@ -1,27 +0,0 @@
-<manifest xmlns:android="http://schemas.android.com/apk/res/android">
-    <!-- Permissions will be merged into the app's manifest -->
-    <uses-permission android:name="android.permission.READ_PHONE_STATE" />
-    <uses-permission android:name="android.permission.RECORD_AUDIO"/>
-    <uses-permission android:name="android.permission.FOREGROUND_SERVICE"/>
-    <uses-permission android:name="android.permission.FOREGROUND_SERVICE_MICROPHONE"/>
-    <uses-permission android:name="android.permission.WAKE_LOCK" />
-    <uses-permission android:name="android.permission.POST_NOTIFICATIONS"/>
-
-    <application>
-        <receiver 
-            android:name=".RecordingActionReceiver"
-            android:exported="false">
-            <intent-filter>
-                <action android:name="PAUSE_RECORDING" />
-                <action android:name="RESUME_RECORDING" />
-                <action android:name="STOP_RECORDING" />
-            </intent-filter>
-        </receiver>
-
-        <service
-            android:name=".AudioRecordingService"
-            android:enabled="true"
-            android:exported="false"
-            android:foregroundServiceType="microphone" />
-    </application>
-</manifest>

package/android/src/main/java/net/siteed/audiostream/AudioAnalysisData.kt

@@ -1,166 +0,0 @@
-// net/siteed/audiostream/AudioAnalysisData.kt
-package net.siteed.audiostream
-
-import android.os.Bundle
-import androidx.core.os.bundleOf
-
-data class SpeechFeatures(
-    val isActive: Boolean,
-    val speakerId: Int? = null
-) {
-    fun toDictionary(): Map<String, Any?> {
-        return mapOf(
-            "isActive" to isActive,
-            "speakerId" to speakerId
-        )
-    }
-
-    fun toBundle(): Bundle {
-        return bundleOf(
-            "isActive" to isActive,
-            "speakerId" to speakerId
-        )
-    }
-}
-
-data class DataPoint(
-    val id: Long,
-    val amplitude: Float,
-    val rms: Float,
-    val dB: Float,
-    val silent: Boolean,
-    val features: Features? = null,
-    val speech: SpeechFeatures? = null,
-    val startTime: Float? = null,
-    val endTime: Float? = null,
-    val startPosition: Int? = null,
-    val endPosition: Int? = null,
-    val samples: Int = 0
-) {
-    fun toDictionary(): Map<String, Any?> {
-        return mapOf(
-            "id" to id,
-            "amplitude" to amplitude,
-            "rms" to rms,
-            "dB" to dB,
-            "silent" to silent,
-            "features" to features?.toDictionary(),
-            "speech" to speech?.toDictionary(),
-            "startTime" to startTime,
-            "endTime" to endTime,
-            "startPosition" to startPosition,
-            "endPosition" to endPosition,
-            "samples" to samples
-        )
-    }
-
-    fun toBundle(): Bundle {
-        return bundleOf(
-            "id" to id,
-            "amplitude" to amplitude,
-            "rms" to rms,
-            "dB" to dB,
-            "silent" to silent,
-            "features" to features?.toBundle(),
-            "speech" to speech?.toBundle(),
-            "startTime" to startTime,
-            "endTime" to endTime,
-            "startPosition" to startPosition,
-            "endPosition" to endPosition,
-            "samples" to samples
-        )
-    }
-}
-
-data class AudioAnalysisData(
-    val segmentDurationMs: Int,
-    val durationMs: Int,
-    val bitDepth: Int,
-    val numberOfChannels: Int,
-    val sampleRate: Int,
-    val samples: Int,
-    val dataPoints: List<DataPoint>,
-    val amplitudeRange: AmplitudeRange,
-    val rmsRange: AmplitudeRange,
-    val speechAnalysis: SpeechAnalysis? = null,
-    val extractionTimeMs: Float
-) {
-    data class AmplitudeRange(val min: Float, val max: Float) {
-        fun toDictionary(): Map<String, Float> {
-            return mapOf("min" to min, "max" to max)
-        }
-
-        fun toBundle(): Bundle {
-            return bundleOf("min" to min, "max" to max)
-        }
-    }
-
-    data class SpeechAnalysis(
-        val speakerChanges: List<SpeakerChange>
-    ) {
-        fun toDictionary(): Map<String, Any> {
-            return mapOf(
-                "speakerChanges" to speakerChanges.map { it.toDictionary() }
-            )
-        }
-
-        fun toBundle(): Bundle {
-            return bundleOf(
-                "speakerChanges" to speakerChanges.map { it.toBundle() }.toTypedArray()
-            )
-        }
-    }
-
-    data class SpeakerChange(
-        val timestamp: Long,
-        val speakerId: Int
-    ) {
-        fun toDictionary(): Map<String, Any> {
-            return mapOf(
-                "timestamp" to timestamp,
-                "speakerId" to speakerId
-            )
-        }
-
-        fun toBundle(): Bundle {
-            return bundleOf(
-                "timestamp" to timestamp,
-                "speakerId" to speakerId
-            )
-        }
-    }
-
-    fun toDictionary(): Map<String, Any?> {
-        return mapOf(
-            "segmentDurationMs" to segmentDurationMs,
-            "durationMs" to durationMs,
-            "bitDepth" to bitDepth,
-            "numberOfChannels" to numberOfChannels,
-            "sampleRate" to sampleRate,
-            "samples" to samples,
-            "dataPoints" to dataPoints.map { it.toDictionary() },
-            "amplitudeRange" to amplitudeRange.toDictionary(),
-            "rmsRange" to rmsRange.toDictionary(),
-            "speechAnalysis" to speechAnalysis?.toDictionary(),
-            "extractionTimeMs" to extractionTimeMs
-        )
-    }
-
-    fun toBundle(): Bundle {
-        val dataPointsBundleArray = dataPoints.map { it.toBundle() }.toTypedArray()
-
-        return bundleOf(
-            "segmentDurationMs" to segmentDurationMs,
-            "durationMs" to durationMs,
-            "bitDepth" to bitDepth,
-            "numberOfChannels" to numberOfChannels,
-            "sampleRate" to sampleRate,
-            "samples" to samples,
-            "dataPoints" to dataPointsBundleArray,
-            "amplitudeRange" to amplitudeRange.toBundle(),
-            "rmsRange" to rmsRange.toBundle(),
-            "speechAnalysis" to speechAnalysis?.toBundle(),
-            "extractionTimeMs" to extractionTimeMs
-        )
-    }
-}

package/android/src/main/java/net/siteed/audiostream/AudioDataEncoder.kt

@@ -1,9 +0,0 @@
-package net.siteed.audiostream
-
-import android.util.Base64
-
-class AudioDataEncoder {
-    public fun encodeToBase64(rawData: ByteArray): String {
-        return Base64.encodeToString(rawData, Base64.NO_WRAP)
-    }
-}

package/android/src/main/java/net/siteed/audiostream/AudioFileHandler.kt

@@ -1,131 +0,0 @@
-package net.siteed.audiostream
-
-import android.util.Log
-import java.io.File
-import java.io.IOException
-import java.io.OutputStream
-import java.io.RandomAccessFile
-import java.util.UUID
-
-class AudioFileHandler(private val filesDir: File) {
-    // Method to write WAV file header
-    fun writeWavHeader(out: OutputStream, sampleRateInHz: Int, channels: Int, bitDepth: Int) {
-        val header = ByteArray(44)
-        val byteRate = sampleRateInHz * channels * bitDepth / 8
-        val blockAlign = channels * bitDepth / 8
-
-        // RIFF/WAVE header
-        "RIFF".toByteArray().copyInto(header, 0)
-        // (file size - 8) to be updated later
-        header[4] = 0 // Placeholder
-        header[5] = 0 // Placeholder
-        header[6] = 0 // Placeholder
-        header[7] = 0 // Placeholder
-        "WAVE".toByteArray().copyInto(header, 8)
-        "fmt ".toByteArray().copyInto(header, 12)
-
-        // 16 for PCM
-        header[16] = 16
-        header[17] = 0
-        header[18] = 0
-        header[19] = 0
-
-        // PCM format ID
-        header[20] = 1 // Audio format 1 for PCM (not compressed)
-        header[21] = 0
-
-        // Number of channels
-        header[22] = (channels and 0xff).toByte()
-        header[23] = (channels shr 8 and 0xff).toByte()
-
-        // Sample rate
-        header[24] = (sampleRateInHz and 0xff).toByte()
-        header[25] = (sampleRateInHz shr 8 and 0xff).toByte()
-        header[26] = (sampleRateInHz shr 16 and 0xff).toByte()
-        header[27] = (sampleRateInHz shr 24 and 0xff).toByte()
-
-        // Byte rate
-        header[28] = (byteRate and 0xff).toByte()
-        header[29] = (byteRate shr 8 and 0xff).toByte()
-        header[30] = (byteRate shr 16 and 0xff).toByte()
-        header[31] = (byteRate shr 24 and 0xff).toByte()
-
-        // Block align
-        header[32] = (blockAlign and 0xff).toByte()
-        header[33] = (blockAlign shr 8 and 0xff).toByte()
-
-        // Bits per sample
-        header[34] = (bitDepth and 0xff).toByte()
-        header[35] = (bitDepth shr 8 and 0xff).toByte()
-
-        // Data chunk
-        "data".toByteArray().copyInto(header, 36)
-        // Data size to be updated later
-        header[40] = 0 // Placeholder
-        header[41] = 0 // Placeholder
-        header[42] = 0 // Placeholder
-        header[43] = 0 // Placeholder
-
-        out.write(header, 0, 44)
-    }
-
-    fun updateWavHeader(file: File) {
-        try {
-            RandomAccessFile(file, "rw").use { raf ->
-                val fileSize = raf.length()
-                val dataSize = fileSize - 44 // Subtract the header size
-
-                raf.seek(4) // Write correct file size, excluding the first 8 bytes of the RIFF header
-                raf.writeInt(Integer.reverseBytes((dataSize + 36).toInt()))
-
-                raf.seek(40) // Go to the data size position
-                raf.writeInt(Integer.reverseBytes(dataSize.toInt())) // Write the size of the data segment
-            }
-        } catch (e: IOException) {
-            println("Could not update WAV header: ${e.message}")
-        }
-    }
-
-    fun clearAudioStorage() {
-        filesDir.listFiles()?.forEach {
-            it.delete()
-        }
-    }
-
-    fun createAudioFile(extension: String): File {
-        val timestamp = System.currentTimeMillis()
-        val uuid = UUID.randomUUID().toString()
-        val filename = "recording_${timestamp}_${uuid}.${extension}"
-        
-        return try {
-            File(filesDir, filename).apply {
-                parentFile?.mkdirs() // Create directories if they don't exist
-                createNewFile()      // Create the file
-            }
-        } catch (e: Exception) {
-            Log.e(Constants.TAG, "Failed to create audio file", e)
-            throw e
-        }
-    }
-
-    fun deleteFile(file: File?): Boolean {
-        return try {
-            if (file == null) {
-                Log.w(Constants.TAG, "Attempted to delete null file")
-                false
-            } else if (!file.exists()) {
-                Log.w(Constants.TAG, "File does not exist: ${file.absolutePath}")
-                false
-            } else {
-                val wasDeleted = file.delete()
-                if (!wasDeleted) {
-                    Log.w(Constants.TAG, "Failed to delete file: ${file.absolutePath}")
-                }
-                wasDeleted
-            }
-        } catch (e: Exception) {
-            Log.e(Constants.TAG, "Error deleting file: ${file?.absolutePath}", e)
-            false
-        }
-    }
-}

package/android/src/main/java/net/siteed/audiostream/AudioFormatUtils.kt

@@ -1,103 +0,0 @@
-package net.siteed.audiostream
-
-import android.media.AudioFormat
-import java.nio.ByteBuffer
-import java.nio.ByteOrder
-
-object AudioFormatUtils {
-    /**
-     * Converts a byte array of audio data to a float array based on the given encoding.
-     * @param audioData The raw audio data in bytes.
-     * @param encoding The encoding format (e.g., "pcm_8bit", "pcm_16bit", "pcm_32bit").
-     * @return A float array with normalized audio samples in the range [-1.0, 1.0].
-     */
-    fun convertByteArrayToFloatArray(audioData: ByteArray, encoding: String): FloatArray {
-        return when (encoding) {
-            "pcm_8bit" -> {
-                val floatArray = FloatArray(audioData.size)
-                for (i in audioData.indices) {
-                    // Convert unsigned 8-bit to float in range [-1.0, 1.0]
-                    floatArray[i] = ((audioData[i].toInt() and 0xFF) - 128) / 128.0f
-                }
-                floatArray
-            }
-            "pcm_16bit" -> {
-                val floatArray = FloatArray(audioData.size / 2)
-                val buffer = ByteBuffer.wrap(audioData).order(ByteOrder.LITTLE_ENDIAN)
-                for (i in floatArray.indices) {
-                    floatArray[i] = buffer.short / 32768.0f // Normalize to [-1.0, 1.0]
-                }
-                floatArray
-            }
-            "pcm_32bit" -> {
-                val floatArray = FloatArray(audioData.size / 4)
-                val buffer = ByteBuffer.wrap(audioData).order(ByteOrder.LITTLE_ENDIAN)
-                for (i in floatArray.indices) {
-                    floatArray[i] = buffer.int / 2_147_483_648.0f // Normalize to [-1.0, 1.0]
-                }
-                floatArray
-            }
-            else -> {
-                // Default to 16-bit PCM if encoding is not recognized
-                val floatArray = FloatArray(audioData.size / 2)
-                val buffer = ByteBuffer.wrap(audioData).order(ByteOrder.LITTLE_ENDIAN)
-                for (i in floatArray.indices) {
-                    floatArray[i] = buffer.short / 32768.0f
-                }
-                floatArray
-            }
-        }
-    }
-
-    /**
-     * Calculates the bit depth (number of bits per sample) based on the encoding string.
-     * @param encoding The encoding format (e.g., "pcm_8bit", "pcm_16bit", "pcm_32bit").
-     * @return The bit depth as an integer.
-     */
-    fun getBitDepth(encoding: String): Int {
-        return when (encoding) {
-            "pcm_8bit" -> 8
-            "pcm_16bit" -> 16
-            "pcm_32bit" -> 32
-            else -> 16 // Default to 16-bit if not recognized
-        }
-    }
-
-    /**
-     * Determines the AudioFormat encoding constant based on the encoding string.
-     * @param encoding The encoding format (e.g., "pcm_8bit", "pcm_16bit", "pcm_32bit").
-     * @return The corresponding AudioFormat constant.
-     */
-    fun getAudioFormat(encoding: String): Int {
-        return when (encoding) {
-            "pcm_8bit" -> AudioFormat.ENCODING_PCM_8BIT
-            "pcm_16bit" -> AudioFormat.ENCODING_PCM_16BIT
-            "pcm_32bit" -> AudioFormat.ENCODING_PCM_FLOAT
-            else -> AudioFormat.ENCODING_PCM_16BIT // Default to 16-bit PCM
-        }
-    }
-
-    /**
-     * Converts audio data between different bit depths
-     * @param audioData The raw audio data
-     * @param sourceBitDepth The original bit depth
-     * @param targetBitDepth The desired bit depth
-     * @return The converted audio data
-     */
-    fun convertBitDepth(audioData: ByteArray, sourceBitDepth: Int, targetBitDepth: Int): ByteArray {
-        // First convert to float array for normalization
-        val floatArray = convertByteArrayToFloatArray(audioData, "pcm_${sourceBitDepth}bit")
-        
-        // Convert back to bytes with new bit depth
-        return when (targetBitDepth) {
-            8 -> floatArray.map { ((it + 1.0f) * 127.5f).toInt().toByte() }.toByteArray()
-            16 -> ByteBuffer.allocate(floatArray.size * 2).order(ByteOrder.LITTLE_ENDIAN).apply {
-                floatArray.forEach { asShortBuffer().put((it * 32767f).toInt().toShort()) }
-            }.array()
-            32 -> ByteBuffer.allocate(floatArray.size * 4).order(ByteOrder.LITTLE_ENDIAN).apply {
-                floatArray.forEach { putFloat(it) }
-            }.array()
-            else -> throw IllegalArgumentException("Unsupported target bit depth: $targetBitDepth")
-        }
-    }
-}