react-native-audio-api 0.11.0-alpha.1 → 0.11.0-alpha.11

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

@@ -22,8 +22,6 @@ static NSString *NotificationManagerContext = @"NotificationManagerContext";
 
 - (void)cleanup
 {
-  NSLog(@"[NotificationManager] cleanup");
-
   self.notificationCenter = nil;
 }
 
@@ -37,7 +35,9 @@ static NSString *NotificationManagerContext = @"NotificationManagerContext";
   if (!enabled) {
     [self stopPollingSecondaryAudioHint];
 
-    [self.notificationCenter removeObserver:self name:AVAudioSessionSilenceSecondaryAudioHintNotification object:nil];
+    [self.notificationCenter removeObserver:self
+                                       name:AVAudioSessionSilenceSecondaryAudioHintNotification
+                                     object:nil];
     return;
   }
 
@@ -46,12 +46,11 @@ static NSString *NotificationManagerContext = @"NotificationManagerContext";
                                   name:AVAudioSessionSilenceSecondaryAudioHintNotification
                                 object:nil];
 
-  dispatch_async(dispatch_get_main_queue(), ^{
-    [self startPollingSecondaryAudioHint];
-  });
+  dispatch_async(dispatch_get_main_queue(), ^{ [self startPollingSecondaryAudioHint]; });
 }
 
-// WARNING: this does not work in a simulator environment, test it on a real device
+// WARNING: this does not work in a simulator environment, test it on a real
+// device
 - (void)observeVolumeChanges:(BOOL)enabled
 {
   if (self.volumeChangesObserved == enabled) {
@@ -110,11 +109,18 @@ static NSString *NotificationManagerContext = @"NotificationManagerContext";
 - (void)handleInterruption:(NSNotification *)notification
 {
   AudioEngine *audioEngine = self.audioAPIModule.audioEngine;
-  NSInteger interruptionType = [notification.userInfo[AVAudioSessionInterruptionTypeKey] integerValue];
-  NSInteger interruptionOption = [notification.userInfo[AVAudioSessionInterruptionOptionKey] integerValue];
+  AudioSessionManager *sessionManager = self.audioAPIModule.audioSessionManager;
+
+  NSInteger interruptionType =
+      [notification.userInfo[AVAudioSessionInterruptionTypeKey] integerValue];
+  NSInteger interruptionOption =
+      [notification.userInfo[AVAudioSessionInterruptionOptionKey] integerValue];
 
   if (interruptionType == AVAudioSessionInterruptionTypeBegan) {
-    [audioEngine markAsInterrupted];
+    dispatch_async(dispatch_get_main_queue(), ^{
+      [audioEngine onInterruptionBegin];
+      [sessionManager markInactive];
+    });
 
     if (self.audioInterruptionsObserved) {
       NSDictionary *body = @{@"type" : @"began", @"shouldResume" : @false};
@@ -124,61 +130,50 @@ static NSString *NotificationManagerContext = @"NotificationManagerContext";
     return;
   }
 
-  if (interruptionOption == AVAudioSessionInterruptionOptionShouldResume) {
-    [audioEngine unmarkAsInterrupted];
-
-    if (self.audioInterruptionsObserved) {
-      NSDictionary *body = @{@"type" : @"ended", @"shouldResume" : @true};
-      [self.audioAPIModule invokeHandlerWithEventName:@"interruption" eventBody:body];
-    }
-
-    return;
-  }
+  bool shouldResume = interruptionOption == AVAudioSessionInterruptionOptionShouldResume;
 
   if (self.audioInterruptionsObserved) {
-    NSDictionary *body = @{@"type" : @"ended", @"shouldResume" : @false};
+    NSDictionary *body = @{@"type" : @"ended", @"shouldResume" : @(shouldResume)};
     [self.audioAPIModule invokeHandlerWithEventName:@"interruption" eventBody:body];
+  } else {
+    dispatch_async(dispatch_get_main_queue(), ^{ [audioEngine onInterruptionEnd:shouldResume]; });
   }
 }
 
 - (void)handleSecondaryAudio:(NSNotification *)notification
 {
   AudioEngine *audioEngine = self.audioAPIModule.audioEngine;
-  NSInteger secondaryAudioType = [notification.userInfo[AVAudioSessionSilenceSecondaryAudioHintTypeKey] integerValue];
-
-  NSLog(@"handleSecondaryAudio");
+  AudioSessionManager *sessionManager = self.audioAPIModule.audioSessionManager;
+  NSInteger secondaryAudioType =
+      [notification.userInfo[AVAudioSessionSilenceSecondaryAudioHintTypeKey] integerValue];
 
   if (secondaryAudioType == AVAudioSessionSilenceSecondaryAudioHintTypeBegin) {
-    [audioEngine markAsInterrupted];
+    dispatch_async(dispatch_get_main_queue(), ^{
+      [sessionManager markInactive];
+      [audioEngine onInterruptionBegin];
+    });
 
     if (self.audioInterruptionsObserved) {
       NSDictionary *body = @{@"type" : @"began", @"shouldResume" : @false};
       [self.audioAPIModule invokeHandlerWithEventName:@"interruption" eventBody:body];
     }
-
     return;
   }
 
-  if (secondaryAudioType == AVAudioSessionSilenceSecondaryAudioHintTypeEnd) {
-    [audioEngine unmarkAsInterrupted];
-
-    if (self.audioInterruptionsObserved) {
-      NSDictionary *body = @{@"type" : @"ended", @"shouldResume" : @true};
-      [self.audioAPIModule invokeHandlerWithEventName:@"interruption" eventBody:body];
-    }
-
-    return;
-  }
+  bool shouldResume = secondaryAudioType == AVAudioSessionSilenceSecondaryAudioHintTypeEnd;
 
   if (self.audioInterruptionsObserved) {
-    NSDictionary *body = @{@"type" : @"ended", @"shouldResume" : @false};
+    NSDictionary *body = @{@"type" : @"ended", @"shouldResume" : @(shouldResume)};
     [self.audioAPIModule invokeHandlerWithEventName:@"interruption" eventBody:body];
+  } else {
+    dispatch_async(dispatch_get_main_queue(), ^{ [audioEngine onInterruptionEnd:shouldResume]; });
   }
 }
 
 - (void)handleRouteChange:(NSNotification *)notification
 {
-  NSInteger routeChangeReason = [notification.userInfo[AVAudioSessionRouteChangeReasonKey] integerValue];
+  NSInteger routeChangeReason =
+      [notification.userInfo[AVAudioSessionRouteChangeReasonKey] integerValue];
   NSString *reasonStr;
 
   switch (routeChangeReason) {
@@ -218,12 +213,11 @@ static NSString *NotificationManagerContext = @"NotificationManagerContext";
 
 - (void)handleMediaServicesReset:(NSNotification *)notification
 {
-  NSLog(@"[NotificationManager] Media services have been reset, tearing down and rebuilding everything.");
+  NSLog(
+      @"[NotificationManager] Media services have been reset, tearing down and rebuilding everything.");
   AudioEngine *audioEngine = self.audioAPIModule.audioEngine;
-  AudioSessionManager *audioSessionManager = self.audioAPIModule.audioSessionManager;
 
-  [audioSessionManager reconfigureAudioSession];
-  [audioEngine restartAudioEngine];
+  dispatch_async(dispatch_get_main_queue(), ^{ [audioEngine restartAudioEngine]; });
 }
 
 - (void)handleEngineConfigurationChange:(NSNotification *)notification
@@ -231,15 +225,9 @@ static NSString *NotificationManagerContext = @"NotificationManagerContext";
   AudioEngine *audioEngine = self.audioAPIModule.audioEngine;
   AudioSessionManager *sessionManager = self.audioAPIModule.audioSessionManager;
 
-  if (![audioEngine isSupposedToBeRunning]) {
-    NSLog(@"[NotificationManager] detected engine configuration change when engine is not running");
-    [sessionManager markSettingsAsDirty];
-    return;
-  }
-
   dispatch_async(dispatch_get_main_queue(), ^{
-    [sessionManager markSettingsAsDirty];
-    [audioEngine rebuildAudioEngineAndStartIfNecessary];
+    [sessionManager markInactive];
+    [audioEngine restartAudioEngine];
   });
 }
 
@@ -255,7 +243,7 @@ static NSString *NotificationManagerContext = @"NotificationManagerContext";
                                                            target:self
                                                          selector:@selector(checkSecondaryAudioHint)
                                                          userInfo:nil
-                                                          repeats:YES];
+                                                          repeats:true];
 
   [[NSRunLoop mainRunLoop] addTimer:self.hintPollingTimer forMode:NSRunLoopCommonModes];
 }
@@ -275,10 +263,15 @@ static NSString *NotificationManagerContext = @"NotificationManagerContext";
   }
 
   AudioEngine *audioEngine = self.audioAPIModule.audioEngine;
+  AudioSessionManager *sessionManager = self.audioAPIModule.audioSessionManager;
+
   self.wasOtherAudioPlaying = shouldSilence;
 
   if (shouldSilence) {
-    [audioEngine markAsInterrupted];
+    dispatch_async(dispatch_get_main_queue(), ^{
+      [sessionManager markInactive];
+      [audioEngine onInterruptionBegin];
+    });
     NSDictionary *body = @{@"type" : @"began", @"shouldResume" : @false};
 
     if (self.audioInterruptionsObserved) {
@@ -288,11 +281,12 @@ static NSString *NotificationManagerContext = @"NotificationManagerContext";
     return;
   }
 
-  [audioEngine unmarkAsInterrupted];
   NSDictionary *body = @{@"type" : @"ended", @"shouldResume" : @true};
 
   if (self.audioInterruptionsObserved) {
     [self.audioAPIModule invokeHandlerWithEventName:@"interruption" eventBody:body];
+  } else {
+    dispatch_async(dispatch_get_main_queue(), ^{ [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

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

@@ -0,0 +1,172 @@
+#import <audioapi/ios/AudioAPIModule.h>
+#import <audioapi/ios/system/notification/NotificationRegistry.h>
+#import <audioapi/ios/system/notification/PlaybackNotification.h>
+
+@implementation NotificationRegistry {
+  NSMutableDictionary<NSString *, id<BaseNotification>> *_notifications;
+}
+
+- (instancetype)initWithAudioAPIModule:(AudioAPIModule *)audioAPIModule
+{
+  if (self = [super init]) {
+    self.audioAPIModule = audioAPIModule;
+    _notifications = [[NSMutableDictionary alloc] init];
+
+    NSLog(@"[NotificationRegistry] Initialized");
+  }
+
+  return self;
+}
+
+- (BOOL)registerNotificationType:(NSString *)type withKey:(NSString *)key
+{
+  if (!type || !key) {
+    NSLog(@"[NotificationRegistry] Invalid type or key");
+    return false;
+  }
+
+  // Check if already registered
+  if (_notifications[key]) {
+    NSLog(@"[NotificationRegistry] Notification with key '%@' already registered", key);
+    return false;
+  }
+
+  // Create the appropriate notification type
+  id<BaseNotification> notification = [self createNotificationForType:type];
+
+  if (!notification) {
+    NSLog(@"[NotificationRegistry] Unknown notification type: %@", type);
+    return false;
+  }
+
+  // Store the notification
+  _notifications[key] = notification;
+
+  NSLog(@"[NotificationRegistry] Registered notification type '%@' with key '%@'", type, key);
+  return true;
+}
+
+- (BOOL)showNotificationWithKey:(NSString *)key options:(NSDictionary *)options
+{
+  id<BaseNotification> notification = _notifications[key];
+
+  if (!notification) {
+    NSLog(@"[NotificationRegistry] No notification found with key: %@", key);
+    return false;
+  }
+
+  // Initialize if first time showing
+  if (![notification isActive]) {
+    if (![notification initializeWithOptions:options]) {
+      NSLog(@"[NotificationRegistry] Failed to initialize notification: %@", key);
+      return false;
+    }
+  }
+
+  BOOL success = [notification showWithOptions:options];
+
+  if (success) {
+    NSLog(@"[NotificationRegistry] Showed notification: %@", key);
+  } else {
+    NSLog(@"[NotificationRegistry] Failed to show notification: %@", key);
+  }
+
+  return success;
+}
+
+- (BOOL)updateNotificationWithKey:(NSString *)key options:(NSDictionary *)options
+{
+  id<BaseNotification> notification = _notifications[key];
+
+  if (!notification) {
+    NSLog(@"[NotificationRegistry] No notification found with key: %@", key);
+    return false;
+  }
+
+  BOOL success = [notification updateWithOptions:options];
+
+  if (success) {
+    NSLog(@"[NotificationRegistry] Updated notification: %@", key);
+  } else {
+    NSLog(@"[NotificationRegistry] Failed to update notification: %@", key);
+  }
+
+  return success;
+}
+
+- (BOOL)hideNotificationWithKey:(NSString *)key
+{
+  id<BaseNotification> notification = _notifications[key];
+
+  if (!notification) {
+    NSLog(@"[NotificationRegistry] No notification found with key: %@", key);
+    return false;
+  }
+
+  BOOL success = [notification hide];
+
+  if (success) {
+    NSLog(@"[NotificationRegistry] Hid notification: %@", key);
+  } else {
+    NSLog(@"[NotificationRegistry] Failed to hide notification: %@", key);
+  }
+
+  return success;
+}
+
+- (BOOL)unregisterNotificationWithKey:(NSString *)key
+{
+  id<BaseNotification> notification = _notifications[key];
+
+  if (!notification) {
+    NSLog(@"[NotificationRegistry] No notification found with key: %@", key);
+    return false;
+  }
+
+  // Clean up and remove
+  [notification cleanup];
+  [_notifications removeObjectForKey:key];
+
+  NSLog(@"[NotificationRegistry] Unregistered notification: %@", key);
+  return true;
+}
+
+- (BOOL)isNotificationActiveWithKey:(NSString *)key
+{
+  id<BaseNotification> notification = _notifications[key];
+
+  if (!notification) {
+    return false;
+  }
+
+  return [notification isActive];
+}
+
+- (void)cleanup
+{
+  NSLog(@"[NotificationRegistry] Cleaning up all notifications");
+
+  // Clean up all notifications
+  for (id<BaseNotification> notification in [_notifications allValues]) {
+    [notification cleanup];
+  }
+
+  [_notifications removeAllObjects];
+}
+
+#pragma mark - Private Methods
+
+- (id<BaseNotification>)createNotificationForType:(NSString *)type
+{
+  if ([type isEqualToString:@"playback"]) {
+    return [[PlaybackNotification alloc] initWithAudioAPIModule:self.audioAPIModule];
+  }
+  // Future: Add more notification types here
+  // else if ([type isEqualToString:@"recording"]) {
+  //   return [[RecordingNotification alloc] initWithAudioAPIModule:self.audioAPIModule];
+  // }
+
+  return nil;
+}
+
+@end

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

@@ -0,0 +1,27 @@
+#pragma once
+
+#import <Foundation/Foundation.h>
+#import <MediaPlayer/MediaPlayer.h>
+#import <audioapi/ios/system/notification/BaseNotification.h>
+
+@class AudioAPIModule;
+
+/**
+ * PlaybackNotification
+ *
+ * iOS playback notification using MPNowPlayingInfoCenter and MPRemoteCommandCenter.
+ * Provides lock screen controls, Control Center integration, and Now Playing display.
+ *
+ * Note: On iOS, this only manages metadata. Notification visibility is controlled
+ * by the AudioContext state (active audio session shows controls).
+ */
+@interface PlaybackNotification : NSObject <BaseNotification>
+
+@property (nonatomic, weak) AudioAPIModule *audioAPIModule;
+@property (nonatomic, weak) MPNowPlayingInfoCenter *playingInfoCenter;
+@property (nonatomic, copy) NSString *artworkUrl;
+@property (nonatomic, assign) BOOL isActive;
+
+- (instancetype)initWithAudioAPIModule:(AudioAPIModule *)audioAPIModule;
+
+@end