@siteed/audio-studio 3.0.0

package/ios/AudioFeaturesWrapper.h

@@ -0,0 +1,21 @@
+#import <Foundation/Foundation.h>
+
+@interface AudioFeaturesWrapper : NSObject
+
++ (nullable NSDictionary *)computeFrameWithSamples:(const float *)samples
+                                        numSamples:(int)numSamples
+                                        sampleRate:(int)sampleRate
+                                         fftLength:(int)fftLength
+                                            nMfcc:(int)nMfcc
+                                       nMelFilters:(int)nMelFilters
+                                       computeMfcc:(BOOL)computeMfcc
+                                      computeChroma:(BOOL)computeChroma;
+
++ (void)initWithSampleRate:(int)sampleRate
+                 fftLength:(int)fftLength
+                    nMfcc:(int)nMfcc
+               nMelFilters:(int)nMelFilters
+               computeMfcc:(BOOL)computeMfcc
+              computeChroma:(BOOL)computeChroma;
+
+@end

package/ios/AudioFeaturesWrapper.mm

@@ -0,0 +1,63 @@
+#import "AudioFeaturesWrapper.h"
+
+// Only include the NEW AudioFeatures files.
+// kiss_fft and MelSpectrogram sources are already compiled via MelSpectrogramWrapper.mm.
+#include "AudioFeatures.cpp"
+#include "AudioFeaturesBridge.cpp"
+
+@implementation AudioFeaturesWrapper
+
++ (nullable NSDictionary *)computeFrameWithSamples:(const float *)samples
+                                        numSamples:(int)numSamples
+                                        sampleRate:(int)sampleRate
+                                         fftLength:(int)fftLength
+                                            nMfcc:(int)nMfcc
+                                       nMelFilters:(int)nMelFilters
+                                       computeMfcc:(BOOL)computeMfcc
+                                      computeChroma:(BOOL)computeChroma
+{
+    CAudioFeaturesResult* result = audio_features_compute(
+        samples, numSamples, sampleRate,
+        fftLength, nMfcc, nMelFilters,
+        computeMfcc ? 1 : 0, computeChroma ? 1 : 0);
+
+    if (!result) {
+        return nil;
+    }
+
+    NSMutableArray<NSNumber *> *mfccArray = [NSMutableArray arrayWithCapacity:result->mfccCount];
+    for (int i = 0; i < result->mfccCount; i++) {
+        [mfccArray addObject:@(result->mfcc[i])];
+    }
+
+    NSMutableArray<NSNumber *> *chromaArray = [NSMutableArray arrayWithCapacity:result->chromagramCount];
+    for (int i = 0; i < result->chromagramCount; i++) {
+        [chromaArray addObject:@(result->chromagram[i])];
+    }
+
+    NSDictionary *dict = @{
+        @"spectralCentroid": @(result->spectralCentroid),
+        @"spectralFlatness": @(result->spectralFlatness),
+        @"spectralRolloff": @(result->spectralRolloff),
+        @"spectralBandwidth": @(result->spectralBandwidth),
+        @"mfcc": mfccArray,
+        @"chromagram": chromaArray
+    };
+
+    audio_features_free(result);
+
+    return dict;
+}
+
++ (void)initWithSampleRate:(int)sampleRate
+                 fftLength:(int)fftLength
+                    nMfcc:(int)nMfcc
+               nMelFilters:(int)nMelFilters
+               computeMfcc:(BOOL)computeMfcc
+              computeChroma:(BOOL)computeChroma
+{
+    audio_features_init(sampleRate, fftLength, nMfcc, nMelFilters,
+        computeMfcc ? 1 : 0, computeChroma ? 1 : 0);
+}
+
+@end

package/ios/AudioNotificationManager.swift

@@ -0,0 +1,154 @@
+class AudioNotificationManager {
+    private let notificationCenter = UNUserNotificationCenter.current()
+    private let notificationId = "audio_recording_notification"
+    private var updateTimer: Timer?
+    private var config: NotificationConfig?
+    private var currentDuration: TimeInterval = 0
+    private var lastUpdateTime: Date = Date()
+    private var minUpdateInterval: TimeInterval = 1.0  // Minimum time between updates
+    
+    func initialize(with config: NotificationConfig?) {
+        self.config = config
+        setupNotificationCategories()
+        showInitialNotification()
+    }
+    
+    private func setupNotificationCategories() {
+        let pauseAction = UNNotificationAction(
+            identifier: "PAUSE_RECORDING",
+            title: "Pause",
+            options: [.foreground]
+        )
+        
+        let resumeAction = UNNotificationAction(
+            identifier: "RESUME_RECORDING",
+            title: "Resume",
+            options: [.foreground]
+        )
+        
+        let category = UNNotificationCategory(
+            identifier: config?.ios?.categoryIdentifier ?? "recording_category",
+            actions: [pauseAction, resumeAction],
+            intentIdentifiers: [],
+            options: [.customDismissAction]
+        )
+        
+        notificationCenter.setNotificationCategories([category])
+    }
+    
+    func showInitialNotification() {
+        // Wrap notification generation in a main thread dispatch
+        DispatchQueue.main.async { [weak self] in
+            guard let self = self else { return }
+            
+            // No need for try-catch as this method doesn't throw
+            self.updateNotification()
+        }
+    }
+    
+    func startUpdates(startTime: Date) {
+        // Cancel any existing timer first
+        stopUpdates()
+        
+        // Create a new timer on the main thread
+        DispatchQueue.main.async { [weak self] in
+            guard let self = self else { return }
+            
+            self.updateTimer = Timer.scheduledTimer(withTimeInterval: 1.0, repeats: true) { [weak self] _ in
+                guard let self = self else { return }
+                self.currentDuration = Date().timeIntervalSince(startTime)
+                self.updateState(isPaused: false)
+            }
+            
+            // Run the timer even when scrolling
+            self.updateTimer?.tolerance = 0.1
+            RunLoop.current.add(self.updateTimer!, forMode: .common)
+            
+            // Update notification immediately
+            self.updateState(isPaused: false)
+        }
+    }
+    
+    func stopUpdates() {
+        // Always execute timer invalidation on main thread
+        DispatchQueue.main.async { [weak self] in
+            guard let self = self else { return }
+            
+            self.updateTimer?.invalidate()
+            self.updateTimer = nil
+            
+            // Clean up notification
+            self.notificationCenter.removeDeliveredNotifications(withIdentifiers: [self.notificationId])
+            self.notificationCenter.removePendingNotificationRequests(withIdentifiers: [self.notificationId])
+        }
+    }
+    
+    func updateState(isPaused: Bool) {
+        DispatchQueue.main.async { [weak self] in
+            guard let self = self else { return }
+            
+            let now = Date()
+            if now.timeIntervalSince(self.lastUpdateTime) >= self.minUpdateInterval {
+                // No need for try-catch as this method doesn't throw
+                self.updateNotification(forcePauseState: isPaused)
+                self.lastUpdateTime = now
+            }
+        }
+    }
+    
+    func updateDuration(_ duration: TimeInterval) {
+        currentDuration = max(0, duration)
+        let now = Date()
+        if now.timeIntervalSince(lastUpdateTime) >= minUpdateInterval {
+            updateNotification()
+            lastUpdateTime = now
+        }
+    }
+    
+    private func updateNotification(forcePauseState: Bool? = nil) {
+        // First, check if we already have a notification
+        notificationCenter.getDeliveredNotifications { [weak self] notifications in
+            guard let self = self else { return }
+            
+            // If we have a notification and it was recently updated, skip
+            if let _ = notifications.first(where: { $0.request.identifier == self.notificationId }),
+               Date().timeIntervalSince(self.lastUpdateTime) < self.minUpdateInterval {
+                return
+            }
+            
+            // Create notification content
+            let content = UNMutableNotificationContent()
+            content.title = forcePauseState == true ?
+                "Recording Paused" :
+                (self.config?.title ?? "Recording in Progress")
+            
+            let durationText = self.formatDuration(self.currentDuration)
+            let configText = self.config?.text ?? ""
+            content.body = configText.isEmpty ? durationText : "\(configText) - \(durationText)"
+            
+            content.categoryIdentifier = self.config?.ios?.categoryIdentifier ?? "recording_category"
+            content.sound = nil
+            
+            // Create request
+            let request = UNNotificationRequest(
+                identifier: self.notificationId,
+                content: content,
+                trigger: nil
+            )
+            
+            // Replace the existing notification
+            self.notificationCenter.removeDeliveredNotifications(withIdentifiers: [self.notificationId])
+            self.notificationCenter.add(request) { error in
+                if let error = error {
+                    print("Failed to update notification: \(error)")
+                }
+            }
+        }
+    }
+    
+    private func formatDuration(_ duration: TimeInterval) -> String {
+        let minutes = Int(duration) / 60
+        let seconds = Int(duration) % 60
+        return String(format: "%02d:%02d", minutes, seconds)
+    }
+}