@siteed/expo-audio-stream 2.0.1 → 2.2.0

package/ios/FFT.swift

@@ -1,62 +0,0 @@
-//
-//  FFT.swift
-//  Pods
-//
-//  Created by Arthur Breton on 20/2/2025.
-//
-
-import Accelerate
-
-class FFT {
-    private let length: Int
-    private var setup: vDSP_DFT_Setup?
-    
-    init(_ length: Int) {
-        self.length = length
-        self.setup = vDSP_DFT_zop_CreateSetup(
-            nil,
-            vDSP_Length(length),
-            vDSP_DFT_Direction.FORWARD
-        )
-    }
-    
-    deinit {
-        if let setup = setup {
-            vDSP_DFT_DestroySetup(setup)
-        }
-    }
-    
-    func realForward(_ data: inout [Float]) {
-        var realIn = data
-        var imagIn = [Float](repeating: 0.0, count: length)
-        var realOut = [Float](repeating: 0.0, count: length)
-        var imagOut = [Float](repeating: 0.0, count: length)
-        
-        // Perform FFT
-        vDSP_DFT_Execute(setup!,
-                        &realIn,
-                        &imagIn,
-                        &realOut,
-                        &imagOut)
-        
-        // Ensure data array has enough space for both real and imaginary parts
-        if data.count < 2 * length {
-            data.append(contentsOf: [Float](repeating: 0.0, count: 2 * length - data.count))
-        }
-        
-        // Combine real and imaginary parts
-        for i in 0..<length {
-            let j = i * 2
-            data[j] = realOut[i]
-            data[j + 1] = imagOut[i]
-        }
-    }
-    
-    func processSegment(_ segment: [Float]) -> [Float] {
-        var fftData = segment.count < length ?
-            segment + [Float](repeating: 0, count: length - segment.count) :
-            Array(segment.prefix(length))
-        realForward(&fftData)
-        return fftData
-    }
-}

package/ios/Features.swift

@@ -1,95 +0,0 @@
-//
-//  Features.swift
-//  ExpoAudioStream
-//
-//  Created by Arthur Breton on 23/6/2024.
-//
-
-import Foundation
-
-public struct Features {
-    var energy: Float
-    var mfcc: [Float]
-    var rms: Float
-    var minAmplitude: Float
-    var maxAmplitude: Float
-    var zcr: Float
-    var spectralCentroid: Float
-    var spectralFlatness: Float
-    var spectralRollOff: Float?
-    var spectralBandwidth: Float?
-    var chromagram: [Float]?
-    var tempo: Float?
-    var hnr: Float?
-    var melSpectrogram: [Float]?
-    var spectralContrast: [Float]?
-    var tonnetz: [Float]?
-    var pitch: Float?
-    var crc32: UInt32?
-    
-    init(
-        energy: Float = 0,
-        mfcc: [Float] = [],
-        rms: Float = 0,
-        minAmplitude: Float = 0,
-        maxAmplitude: Float = 0,
-        zcr: Float = 0,
-        spectralCentroid: Float = 0,
-        spectralFlatness: Float = 0,
-        spectralRollOff: Float? = nil,
-        spectralBandwidth: Float? = nil,
-        chromagram: [Float]? = nil,
-        tempo: Float? = nil,
-        hnr: Float? = nil,
-        melSpectrogram: [Float]? = nil,
-        spectralContrast: [Float]? = nil,
-        tonnetz: [Float]? = nil,
-        pitch: Float? = nil,
-        crc32: UInt32? = nil
-    ) {
-        self.energy = energy
-        self.mfcc = mfcc
-        self.rms = rms
-        self.minAmplitude = minAmplitude
-        self.maxAmplitude = maxAmplitude
-        self.zcr = zcr
-        self.spectralCentroid = spectralCentroid
-        self.spectralFlatness = spectralFlatness
-        self.spectralRollOff = spectralRollOff
-        self.spectralBandwidth = spectralBandwidth
-        self.chromagram = chromagram
-        self.tempo = tempo
-        self.hnr = hnr
-        self.melSpectrogram = melSpectrogram
-        self.spectralContrast = spectralContrast
-        self.tonnetz = tonnetz
-        self.pitch = pitch
-        self.crc32 = crc32
-    }
-}
-
-extension Features {
-    func toDictionary() -> [String: Any] {
-        var dict: [String: Any] = [
-            "energy": energy,
-            "mfcc": mfcc,
-            "rms": rms,
-            "minAmplitude": minAmplitude,
-            "maxAmplitude": maxAmplitude,
-            "zcr": zcr,
-            "spectralCentroid": spectralCentroid,
-            "spectralFlatness": spectralFlatness,
-            "spectralRollOff": spectralRollOff ?? 0,
-            "spectralBandwidth": spectralBandwidth ?? 0,
-            "chromagram": chromagram ?? [],
-            "tempo": tempo ?? 0,
-            "hnr": hnr ?? 0,
-            "melSpectrogram": melSpectrogram ?? [],
-            "spectralContrast": spectralContrast ?? [],
-            "tonnetz": tonnetz ?? [],
-            "pitch": pitch ?? 0,
-            "crc32": crc32 ?? 0
-        ]
-        return dict
-    }
-}

package/ios/Logger.swift

@@ -1,7 +0,0 @@
-class Logger {
-    static func debug(_ message: @autoclosure () -> String) {
-        #if DEBUG
-        print(message())
-        #endif
-    }
-}

package/ios/NotificationExtension.swift

@@ -1,15 +0,0 @@
-//
-//  NotificationExtension.swift
-//  Pods
-//
-//  Created by Arthur Breton on 27/10/2024.
-//
-
-
-import Foundation
-
-extension Notification.Name {
-    static let pauseRecording = Notification.Name("PAUSE_RECORDING")
-    static let resumeRecording = Notification.Name("RESUME_RECORDING")
-    static let notificationActionTriggered = Notification.Name("notificationActionTriggered")
-}

package/ios/RecordingResult.swift

@@ -1,22 +0,0 @@
-// RecordingResult.swift
-
-struct RecordingResult {
-    var fileUri: String
-    var filename: String
-    var mimeType: String
-    var duration: Int64
-    var size: Int64
-    var channels: Int
-    var bitDepth: Int
-    var sampleRate: Double
-    var compression: CompressedRecordingInfo?
-}
-
-struct StartRecordingResult {
-    var fileUri: String
-    var mimeType: String
-    var channels: Int
-    var bitDepth: Int
-    var sampleRate: Double
-    var compression: CompressedRecordingInfo?
-}

package/ios/RecordingSettings.swift

@@ -1,265 +0,0 @@
-// RecordingSettings.swift
-
-import AVFoundation
-
-struct NotificationAction {
-    var title: String
-    var identifier: String
-}
-
-struct IOSAudioSessionConfig {
-    var category: AVAudioSession.Category
-    var mode: AVAudioSession.Mode
-    var categoryOptions: AVAudioSession.CategoryOptions
-}
-
-struct IOSNotificationConfig {
-    var categoryIdentifier: String?
-}
-
-struct CompressedRecordingInfo {
-    var compressedFileUri: String
-    var mimeType: String
-    var bitrate: Int
-    var format: String
-    var size: Int64 = 0  // Add size with default value
-    
-    static func validate(format: String, bitrate: Int) -> Result<(String, Int), Error> {
-        // Validate format
-        guard ["aac", "opus"].contains(format.lowercased()) else {
-            return .failure(RecordingError.unsupportedFormat(format))
-        }
-        
-        // Adjust bitrate based on format
-        let adjustedBitrate: Int
-        if format.lowercased() == "aac" {
-            // Standard AAC bitrates (bps)
-            let standardAACBitrates = [32000, 48000, 64000, 96000, 128000, 160000, 192000, 256000, 320000]
-            adjustedBitrate = standardAACBitrates.min(by: { abs($0 - bitrate) < abs($1 - bitrate) }) ?? 128000
-        } else {
-            // For Opus, allow lower bitrates (especially good for voice)
-            // Typical Opus voice bitrates: 8-24 kbps, music: 32-128 kbps
-            adjustedBitrate = min(max(bitrate, 8000), 320000)
-        }
-        
-        return .success((format, adjustedBitrate))
-    }
-}
-
-struct NotificationConfig {
-    var title: String?
-    var text: String?
-    var icon: String?
-    var ios: IOSNotificationConfig?
-}
-
-struct IOSConfig {
-    var audioSession: IOSAudioSessionConfig?
-}
-
-enum RecordingError: Error {
-    case unsupportedFormat(String)
-    case invalidBitrate(Int)
-    case invalidOutputDirectory(String)
-    
-    var localizedDescription: String {
-        switch self {
-        case .unsupportedFormat(let format):
-            return "Unsupported compression format: \(format). iOS only supports AAC."
-        case .invalidBitrate(let bitrate):
-            return "Invalid bitrate: \(bitrate). Must be between 8000 and 960000 bps."
-        case .invalidOutputDirectory(let directory):
-            return "Invalid output directory: \(directory). Directory does not exist, is not a directory, or is not writable."
-        }
-    }
-}
-
-struct RecordingSettings {
-    // Core recording settings
-    var sampleRate: Double
-    var desiredSampleRate: Double
-    var numberOfChannels: Int = 1
-    var bitDepth: Int = 16
-    var interval: Int?
-    var intervalAnalysis: Int?
-    
-    // Feature flags
-    var keepAwake: Bool = true
-    var showNotification: Bool = false
-    var enableProcessing: Bool = false
-    
-    // Remove pointsPerSecond and algorithm
-    var featureOptions: [String: Bool]? = ["rms": true, "zcr": true]
-    
-    // iOS-specific configuration
-    var ios: IOSConfig?
-    
-    // Notification configuration
-    var notification: NotificationConfig?
-    
-    let enableCompressedOutput: Bool
-    let compressedFormat: String // "aac" or "opus"
-    let compressedBitRate: Int
-    
-    let autoResumeAfterInterruption: Bool
-    
-    var outputDirectory: String? = nil
-    var filename: String? = nil
-    
-    // Update default to 100ms
-    var segmentDurationMs: Int = 100  // Default 100ms segments
-    
-    static func fromDictionary(_ dict: [String: Any]) -> Result<RecordingSettings, Error> {
-        // Extract compression settings
-        let compression = dict["compression"] as? [String: Any]
-        let enableCompressedOutput = compression?["enabled"] as? Bool ?? false
-        let compressedFormat = (compression?["format"] as? String)?.lowercased() ?? "opus"
-        let compressedBitRate = compression?["bitrate"] as? Int ?? 24000
-        
-        // Validate compression settings if enabled
-        if enableCompressedOutput {
-            // Validate format and bitrate
-            if case .failure(let error) = CompressedRecordingInfo.validate(
-                format: compressedFormat,
-                bitrate: compressedBitRate
-            ) {
-                return .failure(error)
-            }
-        }
-        
-        // Create settings
-        var settings = RecordingSettings(
-            sampleRate: dict["sampleRate"] as? Double ?? 44100.0,
-            desiredSampleRate: dict["desiredSampleRate"] as? Double ?? 44100.0,
-            enableCompressedOutput: enableCompressedOutput,
-            compressedFormat: compressedFormat,
-            compressedBitRate: compressedBitRate,
-            autoResumeAfterInterruption: dict["autoResumeAfterInterruption"] as? Bool ?? false
-        )
-        
-        // Parse core settings
-        settings.numberOfChannels = dict["channels"] as? Int ?? 1
-        settings.bitDepth = dict["bitDepth"] as? Int ?? 16
-        settings.interval = dict["interval"] as? Int
-        settings.intervalAnalysis = dict["intervalAnalysis"] as? Int
-        
-        // Parse feature flags
-        settings.keepAwake = dict["keepAwake"] as? Bool ?? true
-        settings.showNotification = dict["showNotification"] as? Bool ?? false
-        settings.enableProcessing = dict["enableProcessing"] as? Bool ?? false
-        
-        settings.featureOptions = dict["features"] as? [String: Bool]
-        
-        // Update segmentDurationMs parsing
-        settings.segmentDurationMs = dict["segmentDurationMs"] as? Int ?? 100
-        
-        // Parse iOS-specific config
-        if let iosDict = dict["ios"] as? [String: Any],
-           let audioSessionDict = iosDict["audioSession"] as? [String: Any] {
-            
-            // Map category
-            let category: AVAudioSession.Category
-            if let categoryStr = audioSessionDict["category"] as? String {
-                switch categoryStr {
-                    case "Ambient": category = .ambient
-                    case "SoloAmbient": category = .soloAmbient
-                    case "Playback": category = .playback
-                    case "Record": category = .record
-                    case "PlayAndRecord": category = .playAndRecord
-                    case "MultiRoute": category = .multiRoute
-                    default: category = .record
-                }
-            } else {
-                category = .record
-            }
-            
-            // Map mode
-            let mode: AVAudioSession.Mode
-            if let modeStr = audioSessionDict["mode"] as? String {
-                switch modeStr {
-                    case "Default": mode = .default
-                    case "VoiceChat": mode = .voiceChat
-                    case "VideoChat": mode = .videoChat
-                    case "GameChat": mode = .gameChat
-                    case "VideoRecording": mode = .videoRecording
-                    case "Measurement": mode = .measurement
-                    case "MoviePlayback": mode = .moviePlayback
-                    case "SpokenAudio": mode = .spokenAudio
-                    default: mode = .default
-                }
-            } else {
-                mode = .default
-            }
-            
-            // Map category options
-            var categoryOptions: AVAudioSession.CategoryOptions = []
-            if let optionsArray = audioSessionDict["categoryOptions"] as? [String] {
-                for option in optionsArray {
-                    switch option {
-                        case "MixWithOthers": categoryOptions.insert(.mixWithOthers)
-                        case "DuckOthers": categoryOptions.insert(.duckOthers)
-                        case "InterruptSpokenAudioAndMixWithOthers": categoryOptions.insert(.interruptSpokenAudioAndMixWithOthers)
-                        case "AllowBluetooth": categoryOptions.insert(.allowBluetooth)
-                        case "AllowBluetoothA2DP": categoryOptions.insert(.allowBluetoothA2DP)
-                        case "AllowAirPlay": categoryOptions.insert(.allowAirPlay)
-                        case "DefaultToSpeaker": categoryOptions.insert(.defaultToSpeaker)
-                        default: break
-                    }
-                }
-            }
-            
-            settings.ios = IOSConfig(audioSession: IOSAudioSessionConfig(
-                category: category,
-                mode: mode,
-                categoryOptions: categoryOptions
-            ))
-        }
-        
-        // Parse notification config
-        if let notificationDict = dict["notification"] as? [String: Any] {
-            var notificationConfig = NotificationConfig()
-            notificationConfig.title = notificationDict["title"] as? String
-            notificationConfig.text = notificationDict["text"] as? String
-            notificationConfig.icon = notificationDict["icon"] as? String
-            
-            // Parse iOS-specific notification config
-            if let iosNotificationDict = notificationDict["ios"] as? [String: Any] {
-                notificationConfig.ios = IOSNotificationConfig(
-                    categoryIdentifier: iosNotificationDict["categoryIdentifier"] as? String
-                )
-            }
-            
-            settings.notification = notificationConfig
-        }
-        
-        // Parse output settings (they remain nil if not provided)
-        if let directory = dict["outputDirectory"] as? String {
-            // Only validate if a custom directory is provided
-            let fileManager = FileManager.default
-            var isDirectory: ObjCBool = false
-            
-            // Clean up the directory path by removing file:// protocol if present
-            let cleanDirectory = directory.replacingOccurrences(of: "file://", with: "")
-                .trimmingCharacters(in: CharacterSet(charactersIn: "/"))
-                .replacingOccurrences(of: "//", with: "/")
-            
-            if !fileManager.fileExists(atPath: cleanDirectory, isDirectory: &isDirectory) {
-                return .failure(RecordingError.invalidOutputDirectory("Directory does not exist: \(cleanDirectory)"))
-            }
-            
-            if !isDirectory.boolValue {
-                return .failure(RecordingError.invalidOutputDirectory("Path is not a directory: \(cleanDirectory)"))
-            }
-            
-            if !fileManager.isWritableFile(atPath: cleanDirectory) {
-                return .failure(RecordingError.invalidOutputDirectory("Directory is not writable: \(cleanDirectory)"))
-            }
-            
-            settings.outputDirectory = cleanDirectory
-        }
-        
-        settings.filename = dict["filename"] as? String
-        
-        return .success(settings)
-    }
-}

package/ios/WaveformExtractor.swift

@@ -1,105 +0,0 @@
-// WaveformExtractor.swift
-
-import Accelerate
-import AVFoundation
-
-/// This class is responsible for extracting waveform data from an audio file.
-public class WaveformExtractor {
-    public private(set) var audioFile: AVAudioFile?
-    private var result: (Any) -> Void
-    private var reject: (String, String) -> Void
-    private var waveformData = Array<Float>()
-    private var progress: Float = 0.0
-    private var channelCount: Int = 1
-    private var currentProgress: Float = 0.0
-    private let extractionQueue = DispatchQueue(label: "WaveformExtractor", attributes: .concurrent)
-    private var _abortWaveformExtraction: Bool = false
-
-    /// Indicates whether the waveform extraction process should be aborted.
-    public var abortWaveformExtraction: Bool {
-        get { _abortWaveformExtraction }
-        set { _abortWaveformExtraction = newValue }
-    }
-
-    /// Initializes the waveform extractor with an audio file URL, resolve, and reject callbacks.
-    ///
-    /// - Parameters:
-    ///   - url: The URL of the audio file to be read.
-    ///   - resolve: The callback to be called on successful extraction.
-    ///   - reject: The callback to be called on extraction failure.
-    public init(url: URL, resolve: @escaping (Any) -> Void, reject: @escaping (String, String) -> Void) throws {
-        self.audioFile = try AVAudioFile(forReading: url)
-        self.result = resolve
-        self.reject = reject
-    }
-
-    deinit {
-        audioFile = nil
-    }
-
-    /// Extracts the waveform data from the audio file.
-    ///
-    /// - Parameters:
-    ///   - numberOfSamples: The number of samples to extract for the waveform.
-    ///   - offset: The offset to start reading from.
-    ///   - length: The length of the audio to read.
-    /// - Returns: A 2D array of floats where each sub-array represents waveform data for a specific channel.
-    public func extractWaveform(numberOfSamples: Int?, offset: Int? = 0, length: UInt? = nil) -> [[Float]]? {
-        guard let audioFile = audioFile else { return nil }
-        
-        let numberOfSamples = max(1, numberOfSamples ?? 100)
-        let totalFrameCount = AVAudioFrameCount(audioFile.length)
-        var framesPerBuffer = totalFrameCount / AVAudioFrameCount(numberOfSamples)
-        
-        guard let rmsBuffer = AVAudioPCMBuffer(pcmFormat: audioFile.processingFormat, frameCapacity: AVAudioFrameCount(framesPerBuffer)) else { return nil }
-        
-        channelCount = Int(audioFile.processingFormat.channelCount)
-        var data = Array(repeating: [Float](repeating: 0, count: numberOfSamples), count: channelCount)
-        
-        var startFrame: AVAudioFramePosition = offset == nil ? audioFile.framePosition : Int64(offset! * Int(framesPerBuffer))
-        var end = numberOfSamples
-        if let length = length {
-            end = Int(length)
-        }
-        
-        for i in 0..<end {
-            if abortWaveformExtraction {
-                audioFile.framePosition = startFrame
-                abortWaveformExtraction = false
-                return nil
-            }
-            
-            do {
-                audioFile.framePosition = startFrame
-                try audioFile.read(into: rmsBuffer, frameCount: framesPerBuffer)
-            } catch {
-                reject("AUDIO_READ_ERROR", "Couldn't read into buffer")
-                return nil
-            }
-            
-            guard let floatData = rmsBuffer.floatChannelData else { return nil }
-            
-            for channel in 0..<channelCount {
-                var rms: Float = 0.0
-                vDSP_rmsqv(floatData[channel], 1, &rms, vDSP_Length(rmsBuffer.frameLength))
-                data[channel][i] = rms
-            }
-            
-            currentProgress += 1
-            progress = currentProgress / Float(numberOfSamples)
-            
-            startFrame += AVAudioFramePosition(framesPerBuffer)
-            if startFrame + AVAudioFramePosition(framesPerBuffer) > AVAudioFramePosition(totalFrameCount) {
-                framesPerBuffer = totalFrameCount - AVAudioFrameCount(startFrame)
-                if framesPerBuffer <= 0 { break }
-            }
-        }
-        
-        return data
-    }
-
-    /// Cancels the waveform extraction process.
-    public func cancel() {
-        abortWaveformExtraction = true
-    }
-}

package/plugin/build/index.d.ts

@@ -1,21 +0,0 @@
-import { ConfigPlugin } from '@expo/config-plugins';
-interface AudioStreamPluginOptions {
-    enablePhoneStateHandling?: boolean;
-    enableNotifications?: boolean;
-    enableBackgroundAudio?: boolean;
-    iosBackgroundModes?: {
-        useVoIP?: boolean;
-        useAudio?: boolean;
-        useProcessing?: boolean;
-        useLocation?: boolean;
-        useExternalAccessory?: boolean;
-    };
-    iosConfig?: {
-        allowBackgroundAudioControls?: boolean;
-        backgroundProcessingTitle?: string;
-        microphoneUsageDescription?: string;
-        notificationUsageDescription?: string;
-    };
-}
-declare const withRecordingPermission: ConfigPlugin<AudioStreamPluginOptions>;
-export default withRecordingPermission;