@siteed/expo-audio-stream 1.1.17 → 1.2.0

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

@@ -0,0 +1,71 @@
+package net.siteed.audiostream
+
+import android.app.Service
+import android.content.Context
+import android.content.Intent
+import android.os.Build
+import android.os.IBinder
+import android.util.Log
+import android.os.Handler
+import android.os.Looper
+
+class AudioRecordingService : Service() {
+    private val notificationManager by lazy {
+        AudioNotificationManager.getInstance(applicationContext)
+    }
+    private val mainHandler = Handler(Looper.getMainLooper())
+    private var isRunning = false
+
+    override fun onBind(intent: Intent?): IBinder? = null
+
+    override fun onCreate() {
+        super.onCreate()
+        Log.d(Constants.TAG, "AudioRecordingService onCreate")
+    }
+
+    override fun onStartCommand(intent: Intent?, flags: Int, startId: Int): Int {
+        Log.d(Constants.TAG, "AudioRecordingService onStartCommand")
+
+        if (!isRunning) {
+            try {
+                val notification = notificationManager.getNotification()
+                startForeground(1, notification)
+                isRunning = true
+            } catch (e: Exception) {
+                Log.e(Constants.TAG, "Error starting foreground service", e)
+                stopSelf()
+            }
+        }
+
+        return START_NOT_STICKY
+    }
+
+    override fun onDestroy() {
+        Log.d(Constants.TAG, "AudioRecordingService onDestroy")
+
+        if (android.os.Build.VERSION.SDK_INT >= android.os.Build.VERSION_CODES.N) {
+            stopForeground(STOP_FOREGROUND_REMOVE)
+        } else {
+            @Suppress("DEPRECATION")
+            stopForeground(true)
+        }
+
+        isRunning = false
+        super.onDestroy()
+    }
+
+    companion object {
+        fun startService(context: Context) {
+            val serviceIntent = Intent(context, AudioRecordingService::class.java)
+            if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
+                context.startForegroundService(serviceIntent)
+            } else {
+                context.startService(serviceIntent)
+            }
+        }
+
+        fun stopService(context: Context) {
+            context.stopService(Intent(context, AudioRecordingService::class.java))
+        }
+    }
+}

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

@@ -5,20 +5,18 @@ import android.os.Build
 import android.os.Bundle
 import android.util.Log
 import androidx.annotation.RequiresApi
+import androidx.core.os.bundleOf
 import expo.modules.kotlin.Promise
 import expo.modules.kotlin.modules.Module
 import expo.modules.kotlin.modules.ModuleDefinition
 import expo.modules.interfaces.permissions.Permissions
 
-class ExpoAudioStreamModule() : Module(), EventSender {
+class ExpoAudioStreamModule : Module(), EventSender {
     private lateinit var audioRecorderManager: AudioRecorderManager
     private lateinit var audioProcessor: AudioProcessor
-    // 8081
 
     @RequiresApi(Build.VERSION_CODES.R)
     override fun definition() = ModuleDefinition {
-        // Sets the name of the module that JavaScript code will use to refer to the module. Takes a string as an argument.
-        // Can be inferred from module's class name, but it's recommended to set it explicitly for clarity.
         // The module will be accessible from `requireNativeModule('ExpoAudioStream')` in JavaScript.
         Name("ExpoAudioStream")
 
@@ -99,11 +97,75 @@ class ExpoAudioStreamModule() : Module(), EventSender {
         }
 
         AsyncFunction("requestPermissionsAsync") { promise: Promise ->
-            Permissions.askForPermissionsWithPermissionsManager(appContext.permissions, promise, Manifest.permission.RECORD_AUDIO)
+            try {
+                val permissions = mutableListOf(Manifest.permission.RECORD_AUDIO)
+
+                // Add foreground service permission for Android 14+
+                if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.UPSIDE_DOWN_CAKE) {
+                    Log.d(Constants.TAG, "Adding FOREGROUND_SERVICE_MICROPHONE permission request")
+                    permissions.add(Manifest.permission.FOREGROUND_SERVICE_MICROPHONE)
+                }
+
+                Log.d(Constants.TAG, "Requesting permissions: $permissions")
+                Permissions.askForPermissionsWithPermissionsManager(
+                    appContext.permissions,
+                    promise,
+                    *permissions.toTypedArray()
+                )
+            } catch (e: Exception) {
+                Log.e(Constants.TAG, "Error requesting permissions", e)
+                promise.reject("PERMISSION_ERROR", "Failed to request permissions: ${e.message}", e)
+            }
         }
 
         AsyncFunction("getPermissionsAsync") { promise: Promise ->
-            Permissions.getPermissionsWithPermissionsManager(appContext.permissions, promise, Manifest.permission.RECORD_AUDIO)
+            val permissions = mutableListOf(Manifest.permission.RECORD_AUDIO)
+
+            if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.UPSIDE_DOWN_CAKE) {
+                permissions.add(Manifest.permission.FOREGROUND_SERVICE_MICROPHONE)
+            }
+
+            Permissions.getPermissionsWithPermissionsManager(
+                appContext.permissions,
+                promise,
+                *permissions.toTypedArray()
+            )
+        }
+
+        AsyncFunction("requestNotificationPermissionsAsync") { promise: Promise ->
+            if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.TIRAMISU) {
+                Permissions.askForPermissionsWithPermissionsManager(
+                    appContext.permissions,
+                    promise,
+                    Manifest.permission.POST_NOTIFICATIONS
+                )
+            } else {
+                promise.resolve(
+                    bundleOf(
+                        "status" to "granted",
+                        "expires" to "never",
+                        "granted" to true
+                    )
+                )
+            }
+        }
+
+        AsyncFunction("getNotificationPermissionsAsync") { promise: Promise ->
+            if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.TIRAMISU) {
+                Permissions.getPermissionsWithPermissionsManager(
+                    appContext.permissions,
+                    promise,
+                    Manifest.permission.POST_NOTIFICATIONS
+                )
+            } else {
+                promise.resolve(
+                    bundleOf(
+                        "status" to "granted",
+                        "expires" to "never",
+                        "granted" to true
+                    )
+                )
+            }
         }
     }
 
@@ -113,10 +175,18 @@ class ExpoAudioStreamModule() : Module(), EventSender {
         val permissionUtils = PermissionUtils(androidContext)
         val audioEncoder = AudioDataEncoder()
         audioRecorderManager =
-            AudioRecorderManager(androidContext.filesDir, permissionUtils, audioEncoder, this)
-        audioProcessor = AudioProcessor(androidContext.filesDir) // Instantiate here with filesDir
+            AudioRecorderManager(androidContext, androidContext.filesDir, permissionUtils, audioEncoder, this)
+        audioRecorderManager = AudioRecorderManager.initialize(
+            androidContext,
+            androidContext.filesDir,
+            permissionUtils,
+            audioEncoder,
+            this
+        )
+        audioProcessor = AudioProcessor(androidContext.filesDir)
     }
 
+
     override fun sendExpoEvent(eventName: String, params: Bundle) {
         Log.d(Constants.TAG, "Sending event: $eventName")
         this@ExpoAudioStreamModule.sendEvent(eventName, params)

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

@@ -0,0 +1,70 @@
+package net.siteed.audiostream
+
+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
+) {
+    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
+            )
+        }
+
+        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/audiostream/PermissionUtils.kt

@@ -2,15 +2,50 @@ package net.siteed.audiostream
 
 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) {
-
-    /**
-     * Checks if the recording permission has been granted.
-     * @return Boolean indicating whether the RECORD_AUDIO permission is granted.
-     */
     fun checkRecordingPermission(): Boolean {
-        return ContextCompat.checkSelfPermission(context, android.Manifest.permission.RECORD_AUDIO) == PackageManager.PERMISSION_GRANTED
+        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+
+        val hasForegroundService = if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.UPSIDE_DOWN_CAKE) {
+            val result = ContextCompat.checkSelfPermission(
+                context,
+                Manifest.permission.FOREGROUND_SERVICE_MICROPHONE
+            ) == PackageManager.PERMISSION_GRANTED
+            Log.d(Constants.TAG, "FOREGROUND_SERVICE_MICROPHONE permission: $result (Android 14+)")
+            result
+        } 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
+    }
+
+    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
     }
 }

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

@@ -0,0 +1,59 @@
+package net.siteed.audiostream
+
+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.audiostream.PAUSE_RECORDING"
+        const val ACTION_RESUME_RECORDING = "net.siteed.audiostream.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)
+        }
+    }
+}

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

@@ -1,12 +1,149 @@
 package net.siteed.audiostream
 
+import android.media.AudioFormat
+import android.os.Build
+
 data class RecordingConfig(
     val sampleRate: Int = Constants.DEFAULT_SAMPLE_RATE,
     val channels: Int = 1,
     val encoding: String = "pcm_16bit",
+    val keepAwake: Boolean = false,
     val interval: Long = Constants.DEFAULT_INTERVAL,
     val enableProcessing: Boolean = false,
     val pointsPerSecond: Double = 20.0,
     val algorithm: String = "rms",
+    val showNotification: Boolean = false,
+    val showWaveformInNotification: Boolean = false,
+    val notification: NotificationConfig = NotificationConfig(),
     val features: Map<String, Boolean> = emptyMap()
-)
+) {
+    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)
+
+            // Initialize the recording configuration
+            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", false),
+                interval = options.getNumberOrDefault("interval", Constants.DEFAULT_INTERVAL),
+                enableProcessing = options.getBooleanOrDefault("enableProcessing", false),
+                pointsPerSecond = options.getNumberOrDefault("pointsPerSecond", 20.0),
+                algorithm = options.getStringOrDefault("algorithm", "rms"),
+                showNotification = options.getBooleanOrDefault("showNotification", false),
+                showWaveformInNotification = options.getBooleanOrDefault("showWaveformInNotification", false),
+                notification = notificationConfig,
+                features = features
+            )
+
+            // 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/audiostream/WaveformConfig.kt

@@ -0,0 +1,19 @@
+package net.siteed.audiostream
+
+/**
+ * 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
+)