react-native-audio-api 0.11.0-alpha.3 → 0.11.0-alpha.5

package/ios/audioapi/ios/AudioAPIModule.mm

@@ -11,8 +11,8 @@
 #import <audioapi/AudioAPIModuleInstaller.h>
 #import <audioapi/ios/system/AudioEngine.h>
 #import <audioapi/ios/system/AudioSessionManager.h>
-#import <audioapi/ios/system/LockScreenManager.h>
 #import <audioapi/ios/system/NotificationManager.h>
+#import <audioapi/ios/system/notification/NotificationRegistry.h>
 
 #import <audioapi/events/AudioEventHandlerRegistry.h>
 
@@ -50,7 +50,7 @@ RCT_EXPORT_MODULE(AudioAPIModule);
   [self.audioEngine cleanup];
   [self.notificationManager cleanup];
   [self.audioSessionManager cleanup];
-  [self.lockScreenManager cleanup];
+  [self.notificationRegistry cleanup];
 
   _eventHandler = nullptr;
 
@@ -66,8 +66,8 @@ RCT_EXPORT_BLOCKING_SYNCHRONOUS_METHOD(install)
 {
   self.audioSessionManager = [[AudioSessionManager alloc] init];
   self.audioEngine = [[AudioEngine alloc] init];
-  self.lockScreenManager = [[LockScreenManager alloc] initWithAudioAPIModule:self];
   self.notificationManager = [[NotificationManager alloc] initWithAudioAPIModule:self];
+  self.notificationRegistry = [[NotificationRegistry alloc] initWithAudioAPIModule:self];
 
   auto jsiRuntime = reinterpret_cast<facebook::jsi::Runtime *>(self.bridge.runtime);
 
@@ -142,21 +142,6 @@ RCT_EXPORT_METHOD(
                                       allowHaptics:allowHaptics];
 }
 
-RCT_EXPORT_METHOD(setLockScreenInfo : (NSDictionary *)info)
-{
-  [self.lockScreenManager setLockScreenInfo:info];
-}
-
-RCT_EXPORT_METHOD(resetLockScreenInfo)
-{
-  [self.lockScreenManager resetLockScreenInfo];
-}
-
-RCT_EXPORT_METHOD(enableRemoteCommand : (NSString *)name enabled : (BOOL)enabled)
-{
-  [self.lockScreenManager enableRemoteCommand:name enabled:enabled];
-}
-
 RCT_EXPORT_METHOD(observeAudioInterruptions : (BOOL)enabled)
 {
   [self.notificationManager observeAudioInterruptions:enabled];
@@ -190,6 +175,25 @@ RCT_EXPORT_METHOD(
   });
 }
 
+RCT_EXPORT_METHOD(
+    requestNotificationPermissions : (nonnull RCTPromiseResolveBlock)
+        resolve reject : (nonnull RCTPromiseRejectBlock)reject)
+{
+  // iOS doesn't require explicit notification permissions for media controls
+  // MPNowPlayingInfoCenter and MPRemoteCommandCenter work without permissions
+  // Return 'granted' to match the spec interface
+  resolve(@"granted");
+}
+
+RCT_EXPORT_METHOD(
+    checkNotificationPermissions : (nonnull RCTPromiseResolveBlock)
+        resolve reject : (nonnull RCTPromiseRejectBlock)reject)
+{
+  // iOS doesn't require explicit notification permissions for media controls
+  // Return 'granted' to match the spec interface
+  resolve(@"granted");
+}
+
 RCT_EXPORT_METHOD(
     getDevicesInfo : (nonnull RCTPromiseResolveBlock)
         resolve reject : (nonnull RCTPromiseRejectBlock)reject)
@@ -204,6 +208,92 @@ RCT_EXPORT_METHOD(disableSessionManagement)
   [self.audioSessionManager disableSessionManagement];
 }
 
+// New notification system methods
+RCT_EXPORT_METHOD(
+    registerNotification : (NSString *)type key : (NSString *)key resolve : (RCTPromiseResolveBlock)
+        resolve reject : (RCTPromiseRejectBlock)reject)
+{
+  dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
+    BOOL success = [self.notificationRegistry registerNotificationType:type withKey:key];
+
+    if (success) {
+      resolve(@{@"success" : @true});
+    } else {
+      resolve(@{@"success" : @false, @"error" : @"Failed to register notification"});
+    }
+  });
+}
+
+RCT_EXPORT_METHOD(
+    showNotification : (NSString *)key options : (NSDictionary *)
+        options resolve : (RCTPromiseResolveBlock)resolve reject : (RCTPromiseRejectBlock)reject)
+{
+  dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
+    BOOL success = [self.notificationRegistry showNotificationWithKey:key options:options];
+
+    if (success) {
+      resolve(@{@"success" : @true});
+    } else {
+      resolve(@{@"success" : @false, @"error" : @"Failed to show notification"});
+    }
+  });
+}
+
+RCT_EXPORT_METHOD(
+    updateNotification : (NSString *)key options : (NSDictionary *)
+        options resolve : (RCTPromiseResolveBlock)resolve reject : (RCTPromiseRejectBlock)reject)
+{
+  dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
+    BOOL success = [self.notificationRegistry updateNotificationWithKey:key options:options];
+
+    if (success) {
+      resolve(@{@"success" : @true});
+    } else {
+      resolve(@{@"success" : @false, @"error" : @"Failed to update notification"});
+    }
+  });
+}
+
+RCT_EXPORT_METHOD(
+    hideNotification : (NSString *)key resolve : (RCTPromiseResolveBlock)
+        resolve reject : (RCTPromiseRejectBlock)reject)
+{
+  dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
+    BOOL success = [self.notificationRegistry hideNotificationWithKey:key];
+
+    if (success) {
+      resolve(@{@"success" : @true});
+    } else {
+      resolve(@{@"success" : @false, @"error" : @"Failed to hide notification"});
+    }
+  });
+}
+
+RCT_EXPORT_METHOD(
+    unregisterNotification : (NSString *)key resolve : (RCTPromiseResolveBlock)
+        resolve reject : (RCTPromiseRejectBlock)reject)
+{
+  dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
+    BOOL success = [self.notificationRegistry unregisterNotificationWithKey:key];
+
+    if (success) {
+      resolve(@{@"success" : @true});
+    } else {
+      resolve(@{@"success" : @false, @"error" : @"Failed to unregister notification"});
+    }
+  });
+}
+
+RCT_EXPORT_METHOD(
+    isNotificationActive : (NSString *)key resolve : (RCTPromiseResolveBlock)
+        resolve reject : (RCTPromiseRejectBlock)reject)
+{
+  dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
+    BOOL isActive = [self.notificationRegistry isNotificationActiveWithKey:key];
+    resolve(@(isActive));
+  });
+}
+
 #ifdef RCT_NEW_ARCH_ENABLED
 - (std::shared_ptr<facebook::react::TurboModule>)getTurboModule:
     (const facebook::react::ObjCTurboModule::InitParams &)params

package/ios/audioapi/ios/core/IOSAudioRecorder.mm

@@ -31,14 +31,14 @@ IOSAudioRecorder::IOSAudioRecorder(
   AudioReceiverBlock receiverBlock = ^(const AudioBufferList *inputBuffer, int numFrames) {
     if (usesFileOutput()) {
       if (auto lock = Locker::tryLock(fileWriterMutex_)) {
-        std::dynamic_pointer_cast<IOSFileWriter>(fileWriter_)
+        std::static_pointer_cast<IOSFileWriter>(fileWriter_)
             ->writeAudioData(inputBuffer, numFrames);
       }
     }
 
     if (usesCallback()) {
       if (auto lock = Locker::tryLock(callbackMutex_)) {
-        std::dynamic_pointer_cast<IOSRecorderCallback>(dataCallback_)
+        std::static_pointer_cast<IOSRecorderCallback>(dataCallback_)
             ->receiveAudioData(inputBuffer, numFrames);
       }
     }
@@ -76,7 +76,7 @@ Result<std::string, std::string> IOSAudioRecorder::start()
     return Result<std::string, std::string>::Err("Microphone permissions are not granted");
   }
 
-  // TODO: recorder should probably request activating the session and setting the options if not set by user
+  // TODO: recorder should probably request the options if not set by user
   // but lets handle that in another PR
   if (![audioSessionManager isSessionActive]) {
     return Result<std::string, std::string>::Err("Audio session is not active");
@@ -90,11 +90,12 @@ Result<std::string, std::string> IOSAudioRecorder::start()
   // Engine will be started again once the native recorder starts
   [AudioEngine.sharedInstance stopIfNecessary];
 
+  // Estimate the maximum input buffer lengths that can be expected from the sink node
   size_t maxInputBufferLength = [nativeRecorder_ getBufferSize];
   auto inputFormat = [nativeRecorder_ getInputFormat];
 
   if (usesFileOutput()) {
-    auto fileResult = std::dynamic_pointer_cast<IOSFileWriter>(fileWriter_)
+    auto fileResult = std::static_pointer_cast<IOSFileWriter>(fileWriter_)
                           ->openFile(inputFormat, maxInputBufferLength);
 
     if (fileResult.is_err()) {
@@ -106,7 +107,7 @@ Result<std::string, std::string> IOSAudioRecorder::start()
   }
 
   if (usesCallback()) {
-    auto callbackResult = std::dynamic_pointer_cast<IOSRecorderCallback>(dataCallback_)
+    auto callbackResult = std::static_pointer_cast<IOSRecorderCallback>(dataCallback_)
                               ->prepare(inputFormat, maxInputBufferLength);
 
     if (callbackResult.is_err()) {
@@ -172,7 +173,7 @@ Result<std::string, std::string> IOSAudioRecorder::enableFileOutput(
   fileWriter_ = std::make_shared<IOSFileWriter>(audioEventHandlerRegistry_, properties);
 
   if (!isIdle()) {
-    auto result = std::dynamic_pointer_cast<IOSFileWriter>(fileWriter_)
+    auto result = std::static_pointer_cast<IOSFileWriter>(fileWriter_)
                       ->openFile([nativeRecorder_ getInputFormat], [nativeRecorder_ getBufferSize]);
 
     if (result.is_err()) {
@@ -273,7 +274,7 @@ Result<NoneType, std::string> IOSAudioRecorder::setOnAudioReadyCallback(
       audioEventHandlerRegistry_, sampleRate, bufferLength, channelCount, callbackId);
 
   if (!isIdle()) {
-    auto result = std::dynamic_pointer_cast<IOSRecorderCallback>(dataCallback_)
+    auto result = std::static_pointer_cast<IOSRecorderCallback>(dataCallback_)
                       ->prepare([nativeRecorder_ getInputFormat], [nativeRecorder_ getBufferSize]);
 
     if (result.is_err()) {

package/ios/audioapi/ios/core/NativeAudioPlayer.m

@@ -61,7 +61,7 @@
   assert(audioEngine != nil);
 
   [audioEngine detachSourceNodeWithId:self.sourceNodeId];
-  [audioEngine stopIfNecessary];
+  [audioEngine stopIfPossible];
   self.sourceNodeId = nil;
 }
 

package/ios/audioapi/ios/core/NativeAudioRecorder.m

@@ -42,6 +42,7 @@ static inline uint32_t nextPowerOfTwo(uint32_t x)
   return self;
 }
 
+// Note: this method should be called only after the session is activated
 - (AVAudioFormat *)getInputFormat
 {
   AVAudioFormat *format = [AudioEngine.sharedInstance.audioEngine.inputNode inputFormatForBus:0];
@@ -95,9 +96,15 @@ static inline uint32_t nextPowerOfTwo(uint32_t x)
 {
   AudioEngine *audioEngine = [AudioEngine sharedInstance];
   assert(audioEngine != nil);
-  [audioEngine stopIfNecessary];
+  [audioEngine stopIfPossible];
   [audioEngine detachInputNode];
-  [audioEngine restartAudioEngine];
+
+  // This makes sure that the engine releases the input properly when we no longer need it
+  // (i.e. no more misleading dot)
+  // Restart only if is not running to avoid interruptions of playback
+  if ([audioEngine getState] != AudioEngineStateRunning) {
+    [audioEngine restartAudioEngine];
+  }
 }
 
 - (void)pause

package/ios/audioapi/ios/system/AudioEngine.h

@@ -41,6 +41,8 @@ typedef NS_ENUM(NSInteger, AudioEngineState) {
 - (void)pauseIfNecessary;
 - (void)stopIfNecessary;
 
+- (void)stopIfPossible;
+
 - (void)restartAudioEngine;
 
 - (void)logAudioEngineState;

package/ios/audioapi/ios/system/AudioEngine.mm

@@ -57,8 +57,6 @@ static AudioEngine *_sharedInstance = nil;
 
 - (void)detachSourceNodeWithId:(NSString *)sourceNodeId
 {
-  NSLog(@"[AudioEngine] detaching source node with ID: %@", sourceNodeId);
-
   AVAudioSourceNode *sourceNode = [self.sourceNodes valueForKey:sourceNodeId];
 
   if (sourceNode == nil) {
@@ -75,7 +73,6 @@ static AudioEngine *_sharedInstance = nil;
 - (void)attachInputNode:(AVAudioSinkNode *)inputNode
 {
   self.inputNode = inputNode;
-
   AVAudioFormat *format = [self.audioEngine.inputNode inputFormatForBus:0];
 
   [self.audioEngine attachNode:inputNode];
@@ -105,11 +102,39 @@ static AudioEngine *_sharedInstance = nil;
 
 - (void)onInterruptionEnd:(bool)shouldResume
 {
+  NSError *error = nil;
+
   if (self.state != AudioEngineState::AudioEngineStateInterrupted) {
+    // If engine was not interrupted, do nothing
+    // Not a real condition, but better be safe than sorry :shrug:
+    return;
+  }
+
+  // Stop just in case, reset the engine and build it from scratch
+  [self stopIfNecessary];
+  [self.audioEngine reset];
+  [self rebuildAudioEngine];
+
+  // If shouldResume is false, mark the engine as paused and wait
+  // for JS-side resume command
+  // TODO: this should be notified to the user f.e. via Event Emitter
+  if (!shouldResume) {
+    self.state = AudioEngineState::AudioEngineStatePaused;
+    return;
+  }
+
+  [self.audioEngine prepare];
+  [self.audioEngine startAndReturnError:&error];
+
+  if (error != nil) {
+    NSLog(
+        @"Error while restarting the audio engine after interruption: %@",
+        [error debugDescription]);
+    self.state = AudioEngineState::AudioEngineStateIdle;
     return;
   }
 
-  // TODO: try to recover
+  self.state = AudioEngineState::AudioEngineStateRunning;
 }
 
 - (AudioEngineState)getState
@@ -117,6 +142,7 @@ static AudioEngine *_sharedInstance = nil;
   return self.state;
 }
 
+/// @brief Rebuilds the audio engine by re-attaching and re-connecting all source nodes and input node.
 - (void)rebuildAudioEngine
 {
   self.audioEngine = [[AVAudioEngine alloc] init];
@@ -135,6 +161,7 @@ static AudioEngine *_sharedInstance = nil;
   }
 }
 
+// @brief Starts the audio engine if not already running.
 - (bool)startEngine
 {
   NSError *error = nil;
@@ -208,6 +235,22 @@ static AudioEngine *_sharedInstance = nil;
   [self stopEngine];
 }
 
+- (void)stopIfPossible
+{
+  if (self.state == AudioEngineState::AudioEngineStateIdle) {
+    return;
+  }
+
+  bool hasInput = self.inputNode != nil;
+  bool hasSources = [self.sourceNodes count] > 0;
+
+  if (hasInput || hasSources) {
+    return;
+  }
+
+  [self stopEngine];
+}
+
 - (void)restartAudioEngine
 {
   if ([self.audioEngine isRunning]) {
@@ -225,10 +268,10 @@ static AudioEngine *_sharedInstance = nil;
   NSLog(@"================ 🎧 AVAudioEngine STATE ================");
 
   // AVAudioEngine state
-  NSLog(@"➡️ engine.isRunning: %@", self.audioEngine.isRunning ? @"YES" : @"NO");
+  NSLog(@"➡️ engine.isRunning: %@", self.audioEngine.isRunning ? @"true" : @"false");
   NSLog(
       @"➡️ engine.isInManualRenderingMode: %@",
-      self.audioEngine.isInManualRenderingMode ? @"YES" : @"NO");
+      self.audioEngine.isInManualRenderingMode ? @"true" : @"false");
 
   // Session state
   NSLog(@"🎚️ Session category: %@", session.category);

package/ios/audioapi/ios/system/AudioSessionManager.mm

@@ -66,15 +66,18 @@ static AudioSessionManager *_sharedInstance = nil;
         (unsigned long)self.audioSession.categoryOptions);
   }
 
-  if (self.audioSession.allowHapticsAndSystemSoundsDuringRecording != self.allowHapticsAndSounds) {
-    [self.audioSession setAllowHapticsAndSystemSoundsDuringRecording:self.allowHapticsAndSounds
-                                                               error:&error];
-
-    if (error != nil) {
-      NSLog(
-          @"Error while setting allowHapticsAndSystemSoundsDuringRecording: %@",
-          [error debugDescription]);
-      return false;
+  if (@available(iOS 13.0, *)) {
+    if (self.audioSession.allowHapticsAndSystemSoundsDuringRecording !=
+        self.allowHapticsAndSounds) {
+      [self.audioSession setAllowHapticsAndSystemSoundsDuringRecording:self.allowHapticsAndSounds
+                                                                 error:&error];
+
+      if (error != nil) {
+        NSLog(
+            @"Error while setting allowHapticsAndSystemSoundsDuringRecording: %@",
+            [error debugDescription]);
+        return false;
+      }
     }
   }
 

package/ios/audioapi/ios/system/NotificationManager.mm

@@ -129,11 +129,12 @@ static NSString *NotificationManagerContext = @"NotificationManagerContext";
   }
 
   bool shouldResume = interruptionOption == AVAudioSessionInterruptionOptionShouldResume;
-  [audioEngine onInterruptionEnd:shouldResume];
 
   if (self.audioInterruptionsObserved) {
     NSDictionary *body = @{@"type" : @"ended", @"shouldResume" : @(shouldResume)};
     [self.audioAPIModule invokeHandlerWithEventName:@"interruption" eventBody:body];
+  } else {
+    [audioEngine onInterruptionEnd:shouldResume];
   }
 }
 
@@ -156,11 +157,12 @@ static NSString *NotificationManagerContext = @"NotificationManagerContext";
   }
 
   bool shouldResume = secondaryAudioType == AVAudioSessionSilenceSecondaryAudioHintTypeEnd;
-  [audioEngine onInterruptionEnd:shouldResume];
 
   if (self.audioInterruptionsObserved) {
     NSDictionary *body = @{@"type" : @"ended", @"shouldResume" : @(shouldResume)};
     [self.audioAPIModule invokeHandlerWithEventName:@"interruption" eventBody:body];
+  } else {
+    [audioEngine onInterruptionEnd:shouldResume];
   }
 }
 
@@ -237,7 +239,7 @@ static NSString *NotificationManagerContext = @"NotificationManagerContext";
                                                            target:self
                                                          selector:@selector(checkSecondaryAudioHint)
                                                          userInfo:nil
-                                                          repeats:YES];
+                                                          repeats:true];
 
   [[NSRunLoop mainRunLoop] addTimer:self.hintPollingTimer forMode:NSRunLoopCommonModes];
 }
@@ -273,11 +275,12 @@ static NSString *NotificationManagerContext = @"NotificationManagerContext";
     return;
   }
 
-  [audioEngine onInterruptionEnd:true];
   NSDictionary *body = @{@"type" : @"ended", @"shouldResume" : @true};
 
   if (self.audioInterruptionsObserved) {
     [self.audioAPIModule invokeHandlerWithEventName:@"interruption" eventBody:body];
+  } else {
+    [audioEngine onInterruptionEnd:true];
   }
 }
 

package/ios/audioapi/ios/system/notification/BaseNotification.h

@@ -0,0 +1,58 @@
+#pragma once
+
+#import <Foundation/Foundation.h>
+
+/**
+ * BaseNotification protocol
+ *
+ * Interface that all notification types must implement.
+ */
+@protocol BaseNotification <NSObject>
+
+@required
+
+/**
+ * Initialize the notification.
+ * @param options Initialization options (can be nil)
+ * @return YES if successful
+ */
+- (BOOL)initializeWithOptions:(NSDictionary *)options;
+
+/**
+ * Show the notification (sets metadata on iOS).
+ * @param options Notification options
+ * @return YES if successful
+ */
+- (BOOL)showWithOptions:(NSDictionary *)options;
+
+/**
+ * Update notification metadata.
+ * @param options Updated information
+ * @return YES if successful
+ */
+- (BOOL)updateWithOptions:(NSDictionary *)options;
+
+/**
+ * Hide the notification (clears metadata on iOS).
+ * @return YES if successful
+ */
+- (BOOL)hide;
+
+/**
+ * Clean up and release resources.
+ */
+- (void)cleanup;
+
+/**
+ * Check if notification is active.
+ * @return YES if active
+ */
+- (BOOL)isActive;
+
+/**
+ * Get notification type identifier.
+ * @return Type identifier (e.g., "playback", "recording")
+ */
+- (NSString *)getNotificationType;
+
+@end

package/ios/audioapi/ios/system/notification/NotificationRegistry.h

@@ -0,0 +1,70 @@
+#pragma once
+
+#import <Foundation/Foundation.h>
+#import <audioapi/ios/system/notification/BaseNotification.h>
+
+@class AudioAPIModule;
+
+/**
+ * NotificationRegistry
+ *
+ * Central manager for all notification types.
+ * Manages registration, lifecycle, and routing of notification implementations.
+ */
+@interface NotificationRegistry : NSObject
+
+@property (nonatomic, weak) AudioAPIModule *audioAPIModule;
+
+- (instancetype)initWithAudioAPIModule:(AudioAPIModule *)audioAPIModule;
+
+/**
+ * Register a new notification type.
+ * @param type The notification type identifier (e.g., "playback", "recording")
+ * @param key Unique key for this notification instance
+ * @return YES if registration succeeded, NO otherwise
+ */
+- (BOOL)registerNotificationType:(NSString *)type withKey:(NSString *)key;
+
+/**
+ * Show a registered notification.
+ * @param key The notification key
+ * @param options Options for showing the notification
+ * @return YES if successful, NO otherwise
+ */
+- (BOOL)showNotificationWithKey:(NSString *)key options:(NSDictionary *)options;
+
+/**
+ * Update a shown notification.
+ * @param key The notification key
+ * @param options Updated options
+ * @return YES if successful, NO otherwise
+ */
+- (BOOL)updateNotificationWithKey:(NSString *)key options:(NSDictionary *)options;
+
+/**
+ * Hide a notification.
+ * @param key The notification key
+ * @return YES if successful, NO otherwise
+ */
+- (BOOL)hideNotificationWithKey:(NSString *)key;
+
+/**
+ * Unregister and clean up a notification.
+ * @param key The notification key
+ * @return YES if successful, NO otherwise
+ */
+- (BOOL)unregisterNotificationWithKey:(NSString *)key;
+
+/**
+ * Check if a notification is active.
+ * @param key The notification key
+ * @return YES if active, NO otherwise
+ */
+- (BOOL)isNotificationActiveWithKey:(NSString *)key;
+
+/**
+ * Clean up all notifications.
+ */
+- (void)cleanup;
+
+@end