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

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

@@ -1,151 +1,133 @@
+#import <AVFAudio/AVFAudio.h>
 #import <audioapi/ios/system/AudioSessionManager.h>
 
 @implementation AudioSessionManager
 
+static AudioSessionManager *_sharedInstance = nil;
+
 - (instancetype)init
 {
   if (self = [super init]) {
     self.audioSession = [AVAudioSession sharedInstance];
 
-    self.sessionCategory = AVAudioSessionCategoryPlayback;
-    self.sessionMode = AVAudioSessionModeDefault;
-    self.sessionOptions = 0;
-    self.allowHapticsAndSystemSoundsDuringRecording = false;
-    self.hasDirtySettings = true;
     self.isActive = false;
+    self.shouldManageSession = true;
+
+    self.desiredCategory = AVAudioSessionCategoryPlayback;
+    self.desiredMode = AVAudioSessionModeDefault;
+    self.desiredOptions = 0;
+    self.allowHapticsAndSounds = false;
   }
 
+  _sharedInstance = self;
   return self;
 }
 
-- (void)cleanup
++ (instancetype)sharedInstance
 {
-  NSLog(@"[AudioSessionManager] cleanup");
+  return _sharedInstance;
+}
 
+- (void)cleanup
+{
   self.audioSession = nil;
 }
 
-- (NSNumber *)getDevicePreferredSampleRate
+- (bool)areDesiredOptionsSet
 {
-  return [NSNumber numberWithFloat:[self.audioSession sampleRate]];
+  return (
+      self.audioSession.category == self.desiredCategory &&
+      self.audioSession.mode == self.desiredMode &&
+      self.audioSession.categoryOptions == self.desiredOptions &&
+      self.audioSession.allowHapticsAndSystemSoundsDuringRecording == self.allowHapticsAndSounds);
 }
 
-- (void)setAudioSessionOptions:(NSString *)category
-                          mode:(NSString *)mode
-                       options:(NSArray *)options
-                  allowHaptics:(BOOL)allowHaptics
+- (bool)configureAudioSession
 {
-  AVAudioSessionCategory sessionCategory = self.sessionCategory;
-  AVAudioSessionMode sessionMode = self.sessionMode;
-  AVAudioSessionCategoryOptions sessionOptions = 0;
-  bool allowHapticsAndSystemSoundsDuringRecording = allowHaptics;
-
-  if ([category isEqualToString:@"record"]) {
-    sessionCategory = AVAudioSessionCategoryRecord;
-  } else if ([category isEqualToString:@"ambient"]) {
-    sessionCategory = AVAudioSessionCategoryAmbient;
-  } else if ([category isEqualToString:@"playback"]) {
-    sessionCategory = AVAudioSessionCategoryPlayback;
-  } else if ([category isEqualToString:@"multiRoute"]) {
-    sessionCategory = AVAudioSessionCategoryMultiRoute;
-  } else if ([category isEqualToString:@"soloAmbient"]) {
-    sessionCategory = AVAudioSessionCategorySoloAmbient;
-  } else if ([category isEqualToString:@"playAndRecord"]) {
-    sessionCategory = AVAudioSessionCategoryPlayAndRecord;
-  }
+  NSError *error = nil;
 
-  if ([mode isEqualToString:@"default"]) {
-    sessionMode = AVAudioSessionModeDefault;
-  } else if ([mode isEqualToString:@"gameChat"]) {
-    sessionMode = AVAudioSessionModeGameChat;
-  } else if ([mode isEqualToString:@"videoChat"]) {
-    sessionMode = AVAudioSessionModeVideoChat;
-  } else if ([mode isEqualToString:@"voiceChat"]) {
-    sessionMode = AVAudioSessionModeVoiceChat;
-  } else if ([mode isEqualToString:@"measurement"]) {
-    sessionMode = AVAudioSessionModeMeasurement;
-  } else if ([mode isEqualToString:@"voicePrompt"]) {
-    sessionMode = AVAudioSessionModeVoicePrompt;
-  } else if ([mode isEqualToString:@"spokenAudio"]) {
-    sessionMode = AVAudioSessionModeSpokenAudio;
-  } else if ([mode isEqualToString:@"moviePlayback"]) {
-    sessionMode = AVAudioSessionModeMoviePlayback;
-  } else if ([mode isEqualToString:@"videoRecording"]) {
-    sessionMode = AVAudioSessionModeVideoRecording;
+  if (!self.shouldManageSession || [self areDesiredOptionsSet]) {
+    return true;
   }
 
-  for (NSString *option in options) {
-    if ([option isEqualToString:@"duckOthers"]) {
-      sessionOptions |= AVAudioSessionCategoryOptionDuckOthers;
-    }
-
-    if ([option isEqualToString:@"allowAirPlay"]) {
-      sessionOptions |= AVAudioSessionCategoryOptionAllowAirPlay;
-    }
-
-    if ([option isEqualToString:@"mixWithOthers"]) {
-      sessionOptions |= AVAudioSessionCategoryOptionMixWithOthers;
-    }
-
-    if ([option isEqualToString:@"allowBluetooth"]) {
-      sessionOptions |= AVAudioSessionCategoryOptionAllowBluetooth;
-    }
-
-    if ([option isEqualToString:@"defaultToSpeaker"]) {
-      sessionOptions |= AVAudioSessionCategoryOptionDefaultToSpeaker;
-    }
+  [self.audioSession setCategory:self.desiredCategory
+                            mode:self.desiredMode
+                         options:self.desiredOptions
+                           error:&error];
 
-    if ([option isEqualToString:@"allowBluetoothA2DP"]) {
-      sessionOptions |= AVAudioSessionCategoryOptionAllowBluetoothA2DP;
-    }
+  if (error != nil) {
+    NSLog(@"Error while configuring audio session: %@", [error debugDescription]);
+    return false;
+  } else {
+    NSLog(
+        @"[AudioSessionManager] Configured audio session: category=%@, mode=%@, options=%lu",
+        self.audioSession.category,
+        self.audioSession.mode,
+        (unsigned long)self.audioSession.categoryOptions);
+  }
 
-    if ([option isEqualToString:@"overrideMutedMicrophoneInterruption"]) {
-      sessionOptions |= AVAudioSessionCategoryOptionOverrideMutedMicrophoneInterruption;
-    }
+  if (self.audioSession.allowHapticsAndSystemSoundsDuringRecording != self.allowHapticsAndSounds) {
+    [self.audioSession setAllowHapticsAndSystemSoundsDuringRecording:self.allowHapticsAndSounds
+                                                               error:&error];
 
-    if ([option isEqualToString:@"interruptSpokenAudioAndMixWithOthers"]) {
-      sessionOptions |= AVAudioSessionCategoryOptionInterruptSpokenAudioAndMixWithOthers;
+    if (error != nil) {
+      NSLog(
+          @"Error while setting allowHapticsAndSystemSoundsDuringRecording: %@",
+          [error debugDescription]);
+      return false;
     }
   }
 
-  if (self.sessionCategory != sessionCategory) {
-    self.hasDirtySettings = true;
-    self.sessionCategory = sessionCategory;
-  }
-
-  if (self.sessionMode != sessionMode) {
-    self.hasDirtySettings = true;
-    self.sessionMode = sessionMode;
-  }
+  return true;
+}
 
-  if (self.sessionOptions != sessionOptions) {
-    self.hasDirtySettings = true;
-    self.sessionOptions = sessionOptions;
+- (void)setAudioSessionOptions:(NSString *)categoryStr
+                          mode:(NSString *)modeStr
+                       options:(NSArray *)optionsArray
+                  allowHaptics:(BOOL)allowHaptics
+{
+  AVAudioSessionCategory category = [self categoryFromString:categoryStr];
+  AVAudioSessionMode mode = [self modeFromString:modeStr];
+  AVAudioSessionCategoryOptions options = [self optionsFromArray:optionsArray];
+  bool configChanged = false;
+
+  if (category != self.desiredCategory || mode != self.desiredMode ||
+      options != self.desiredOptions || allowHaptics != self.allowHapticsAndSounds) {
+    configChanged = true;
   }
 
-  if (self.allowHapticsAndSystemSoundsDuringRecording != allowHapticsAndSystemSoundsDuringRecording) {
-    self.hasDirtySettings = true;
-    self.allowHapticsAndSystemSoundsDuringRecording = allowHapticsAndSystemSoundsDuringRecording;
-  }
+  self.desiredCategory = category;
+  self.desiredMode = mode;
+  self.desiredOptions = options;
+  self.allowHapticsAndSounds = allowHaptics;
 
-  if (self.isActive) {
+  if (configChanged && self.isActive) {
     [self configureAudioSession];
   }
 }
 
 - (bool)setActive:(bool)active
 {
-  if (active == self.isActive) {
+  if (!self.shouldManageSession) {
     return true;
   }
 
-  if (active) {
-    [self configureAudioSession];
+  NSError *error = nil;
+  bool success = false;
+
+  if (self.isActive == active) {
+    return true;
   }
 
-  NSError *error = nil;
+  if (active) {
+    success = [self configureAudioSession];
+
+    if (!success) {
+      return false;
+    }
+  }
 
-  bool success = [self.audioSession setActive:active error:&error];
+  success = [self.audioSession setActive:active error:&error];
 
   if (success) {
     self.isActive = active;
@@ -160,119 +142,108 @@
   return success;
 }
 
-- (bool)configureAudioSession
+- (void)markInactive
 {
-  if (![self hasDirtySettings]) {
-    return true;
-  }
-
-  NSLog(
-      @"[AudioSessionManager] configureAudioSession, category: %@, mode: %@, options: %lu, allowHaptics: %@",
-      self.sessionCategory,
-      self.sessionMode,
-      (unsigned long)self.sessionOptions,
-      self.allowHapticsAndSystemSoundsDuringRecording ? @"YES" : @"NO");
-
-  NSError *error = nil;
-
-  [self.audioSession setCategory:self.sessionCategory mode:self.sessionMode options:self.sessionOptions error:&error];
-
-  if (error != nil) {
-    NSLog(@"Error while configuring audio session: %@", [error debugDescription]);
-    return false;
-  }
-
-  if (@available(iOS 13.0, *)) {
-    [self.audioSession setAllowHapticsAndSystemSoundsDuringRecording:self.allowHapticsAndSystemSoundsDuringRecording
-                                                               error:&error];
+  // Mark as inactive no matter the state reported by AVAudioSession,
+  // this is used during interruptions to "force" going through configure&activate flow
+  // which is necessary after some of the interruptions (f.e. when the other app re-configures the hardware)
+  self.isActive = false;
+}
 
-    if (error != nil) {
-      NSLog(@"Error while setting allowHapticsAndSystemSoundsDuringRecording: %@", [error debugDescription]);
-    }
-  }
+- (void)disableSessionManagement
+{
+  self.shouldManageSession = false;
+}
 
-  self.hasDirtySettings = false;
-  return true;
+- (NSNumber *)getDevicePreferredSampleRate
+{
+  return [NSNumber numberWithFloat:[self.audioSession sampleRate]];
 }
 
-- (bool)reconfigureAudioSession
+- (NSNumber *)getDevicePreferredInputChannelCount
 {
-  self.hasDirtySettings = true;
-  if (self.isActive) {
-    self.isActive = false;
-    return [self setActive:true];
-  }
-  return true;
+  return [NSNumber numberWithInteger:[self.audioSession inputNumberOfChannels]];
 }
 
-- (void)markSettingsAsDirty
+- (void)requestRecordingPermissions:(RCTPromiseResolveBlock)resolve
+                             reject:(RCTPromiseRejectBlock)reject
 {
-  self.hasDirtySettings = true;
-  self.isActive = false;
+  id value = [[NSBundle mainBundle] objectForInfoDictionaryKey:@"NSMicrophoneUsageDescription"];
+  // if there is no entry NSMicrophoneUsageDescription calling
+  // requestRecordPermission will quit an app
+  if (value == nil) {
+    reject(
+        nil,
+        @"There is no NSMicrophoneUsageDescription entry in info.plist file. App cannot access microphone without it.",
+        nil);
+    return;
+  }
+
+  resolve([self requestRecordingPermissions]);
 }
 
-- (void)requestRecordingPermissions:(RCTPromiseResolveBlock)resolve reject:(RCTPromiseRejectBlock)reject
+- (NSString *)requestRecordingPermissions
 {
-  if (@available(iOS 17, *)) {
-    [AVAudioSession.sharedInstance requestRecordPermission:^(BOOL granted) {
-      if (granted) {
-        resolve(@"Granted");
-      } else {
-        resolve(@"Denied");
-      }
+  id value = [[NSBundle mainBundle] objectForInfoDictionaryKey:@"NSMicrophoneUsageDescription"];
+
+  if (value == nil) {
+    return @"Denied";
+  }
+
+  __block NSString *result = @"Denied";
+  dispatch_semaphore_t sem = dispatch_semaphore_create(0);
+
+#if TARGET_OS_SIMULATOR
+  [self.audioSession requestRecordPermission:^(BOOL granted) {
+    result = granted ? @"Granted" : @"Denied";
+    dispatch_semaphore_signal(sem);
+  }];
+
+  dispatch_semaphore_wait(sem, DISPATCH_TIME_FOREVER);
+  return result;
+#else
+  if (@available(iOS 17.0, *)) {
+    [AVAudioApplication requestRecordPermissionWithCompletionHandler:^(BOOL granted) {
+      result = granted ? @"Granted" : @"Denied";
+      dispatch_semaphore_signal(sem);
     }];
   } else {
     [self.audioSession requestRecordPermission:^(BOOL granted) {
-      if (granted) {
-        resolve(@"Granted");
-      } else {
-        resolve(@"Denied");
-      }
+      result = granted ? @"Granted" : @"Denied";
+      dispatch_semaphore_signal(sem);
     }];
   }
+
+  dispatch_semaphore_wait(sem, DISPATCH_TIME_FOREVER);
+  return result;
+#endif
 }
 
-- (void)checkRecordingPermissions:(RCTPromiseResolveBlock)resolve reject:(RCTPromiseRejectBlock)reject
+- (void)checkRecordingPermissions:(RCTPromiseResolveBlock)resolve
+                           reject:(RCTPromiseRejectBlock)reject
 {
-  if (@available(iOS 17, *)) {
-    NSInteger res = [[AVAudioApplication sharedInstance] recordPermission];
-    switch (res) {
-      case AVAudioApplicationRecordPermissionUndetermined:
-        resolve(@"Undetermined");
-        break;
-      case AVAudioApplicationRecordPermissionGranted:
-        resolve(@"Granted");
-        break;
-      case AVAudioApplicationRecordPermissionDenied:
-        resolve(@"Denied");
-        break;
-      default:
-        resolve(@"Undetermined");
-        break;
-    }
-  } else {
-    NSInteger res = [self.audioSession recordPermission];
-    switch (res) {
-      case AVAudioSessionRecordPermissionUndetermined:
-        resolve(@"Undetermined");
-        break;
-      case AVAudioSessionRecordPermissionGranted:
-        resolve(@"Granted");
-        break;
-      case AVAudioSessionRecordPermissionDenied:
-        resolve(@"Denied");
-        break;
-      default:
-        resolve(@"Undetermined");
-        break;
-    }
-  }
+  resolve([self checkRecordingPermissions]);
 }
 
 - (NSString *)checkRecordingPermissions
 {
+#if TARGET_OS_SIMULATOR
+  NSInteger res = [self.audioSession recordPermission];
+
+  switch (res) {
+    case AVAudioSessionRecordPermissionUndetermined:
+      return @"Undetermined";
+    case AVAudioSessionRecordPermissionGranted:
+      return @"Granted";
+    case AVAudioSessionRecordPermissionDenied:
+      return @"Denied";
+    default:
+      return @"Undetermined";
+  }
+#else
   if (@available(iOS 17, *)) {
     NSInteger res = [[AVAudioApplication sharedInstance] recordPermission];
+
     switch (res) {
       case AVAudioApplicationRecordPermissionUndetermined:
         return @"Undetermined";
@@ -283,29 +254,35 @@
       default:
         return @"Undetermined";
     }
-  } else {
-    NSInteger res = [self.audioSession recordPermission];
-    switch (res) {
-      case AVAudioSessionRecordPermissionUndetermined:
-        return @"Undetermined";
-      case AVAudioSessionRecordPermissionGranted:
-        return @"Granted";
-      case AVAudioSessionRecordPermissionDenied:
-        return @"Denied";
-      default:
-        return @"Undetermined";
-    }
   }
+
+  NSInteger res = [self.audioSession recordPermission];
+
+  switch (res) {
+    case AVAudioSessionRecordPermissionUndetermined:
+      return @"Undetermined";
+    case AVAudioSessionRecordPermissionGranted:
+      return @"Granted";
+    case AVAudioSessionRecordPermissionDenied:
+      return @"Denied";
+    default:
+      return @"Undetermined";
+  }
+#endif
 }
 
 - (void)getDevicesInfo:(RCTPromiseResolveBlock)resolve reject:(RCTPromiseRejectBlock)reject
 {
   NSMutableDictionary *devicesInfo = [[NSMutableDictionary alloc] init];
 
-  [devicesInfo setValue:[self parseDeviceList:[self.audioSession availableInputs]] forKey:@"availableInputs"];
-  [devicesInfo setValue:[self parseDeviceList:[[self.audioSession currentRoute] inputs]] forKey:@"currentInputs"];
-  [devicesInfo setValue:[self parseDeviceList:[[self.audioSession currentRoute] outputs]] forKey:@"availableOutputs"];
-  [devicesInfo setValue:[self parseDeviceList:[[self.audioSession currentRoute] outputs]] forKey:@"currentOutputs"];
+  [devicesInfo setValue:[self parseDeviceList:[self.audioSession availableInputs]]
+                 forKey:@"availableInputs"];
+  [devicesInfo setValue:[self parseDeviceList:[[self.audioSession currentRoute] inputs]]
+                 forKey:@"currentInputs"];
+  [devicesInfo setValue:[self parseDeviceList:[[self.audioSession currentRoute] outputs]]
+                 forKey:@"availableOutputs"];
+  [devicesInfo setValue:[self parseDeviceList:[[self.audioSession currentRoute] outputs]]
+                 forKey:@"currentOutputs"];
 
   resolve(devicesInfo);
 }
@@ -324,4 +301,98 @@
   return deviceList;
 }
 
+- (AVAudioSessionCategory)categoryFromString:(NSString *)categorySTR
+{
+  AVAudioSessionCategory category = 0;
+
+  if ([categorySTR isEqualToString:@"record"]) {
+    category = AVAudioSessionCategoryRecord;
+  } else if ([categorySTR isEqualToString:@"ambient"]) {
+    category = AVAudioSessionCategoryAmbient;
+  } else if ([categorySTR isEqualToString:@"playback"]) {
+    category = AVAudioSessionCategoryPlayback;
+  } else if ([categorySTR isEqualToString:@"multiRoute"]) {
+    category = AVAudioSessionCategoryMultiRoute;
+  } else if ([categorySTR isEqualToString:@"soloAmbient"]) {
+    category = AVAudioSessionCategorySoloAmbient;
+  } else if ([categorySTR isEqualToString:@"playAndRecord"]) {
+    category = AVAudioSessionCategoryPlayAndRecord;
+  }
+
+  return category;
+}
+
+- (AVAudioSessionMode)modeFromString:(NSString *)modeSTR
+{
+  AVAudioSessionMode mode = 0;
+
+  if ([modeSTR isEqualToString:@"default"]) {
+    mode = AVAudioSessionModeDefault;
+  } else if ([modeSTR isEqualToString:@"gameChat"]) {
+    mode = AVAudioSessionModeGameChat;
+  } else if ([modeSTR isEqualToString:@"videoChat"]) {
+    mode = AVAudioSessionModeVideoChat;
+  } else if ([modeSTR isEqualToString:@"voiceChat"]) {
+    mode = AVAudioSessionModeVoiceChat;
+  } else if ([modeSTR isEqualToString:@"measurement"]) {
+    mode = AVAudioSessionModeMeasurement;
+  } else if ([modeSTR isEqualToString:@"voicePrompt"]) {
+    mode = AVAudioSessionModeVoicePrompt;
+  } else if ([modeSTR isEqualToString:@"spokenAudio"]) {
+    mode = AVAudioSessionModeSpokenAudio;
+  } else if ([modeSTR isEqualToString:@"moviePlayback"]) {
+    mode = AVAudioSessionModeMoviePlayback;
+  } else if ([modeSTR isEqualToString:@"videoRecording"]) {
+    mode = AVAudioSessionModeVideoRecording;
+  }
+
+  return mode;
+}
+
+- (AVAudioSessionCategoryOptions)optionsFromArray:(NSArray *)optionsArray
+{
+  AVAudioSessionCategoryOptions options = 0;
+
+  for (NSString *option in optionsArray) {
+    if ([option isEqualToString:@"duckOthers"]) {
+      options |= AVAudioSessionCategoryOptionDuckOthers;
+    }
+
+    if ([option isEqualToString:@"allowAirPlay"]) {
+      options |= AVAudioSessionCategoryOptionAllowAirPlay;
+    }
+
+    if ([option isEqualToString:@"mixWithOthers"]) {
+      options |= AVAudioSessionCategoryOptionMixWithOthers;
+    }
+
+    if ([option isEqualToString:@"allowBluetooth"]) {
+      options |= AVAudioSessionCategoryOptionAllowBluetooth;
+    }
+
+    if ([option isEqualToString:@"defaultToSpeaker"]) {
+      options |= AVAudioSessionCategoryOptionDefaultToSpeaker;
+    }
+
+    if ([option isEqualToString:@"allowBluetoothA2DP"]) {
+      options |= AVAudioSessionCategoryOptionAllowBluetoothA2DP;
+    }
+
+    if ([option isEqualToString:@"overrideMutedMicrophoneInterruption"]) {
+      options |= AVAudioSessionCategoryOptionOverrideMutedMicrophoneInterruption;
+    }
+
+    if ([option isEqualToString:@"interruptSpokenAudioAndMixWithOthers"]) {
+      options |= AVAudioSessionCategoryOptionInterruptSpokenAudioAndMixWithOthers;
+    }
+  }
+
+  return options;
+}
+
+- (bool)isSessionActive
+{
+  return self.isActive;
+}
+
 @end