react-native-audio-api 0.11.0-nightly-010ea11-20251110 → 0.11.0-nightly-c8d92af-20251111

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

@@ -101,11 +101,13 @@
     }
 
     if ([option isEqualToString:@"overrideMutedMicrophoneInterruption"]) {
-      sessionOptions |= AVAudioSessionCategoryOptionOverrideMutedMicrophoneInterruption;
+      sessionOptions |=
+          AVAudioSessionCategoryOptionOverrideMutedMicrophoneInterruption;
     }
 
     if ([option isEqualToString:@"interruptSpokenAudioAndMixWithOthers"]) {
-      sessionOptions |= AVAudioSessionCategoryOptionInterruptSpokenAudioAndMixWithOthers;
+      sessionOptions |=
+          AVAudioSessionCategoryOptionInterruptSpokenAudioAndMixWithOthers;
     }
   }
 
@@ -124,9 +126,11 @@
     self.sessionOptions = sessionOptions;
   }
 
-  if (self.allowHapticsAndSystemSoundsDuringRecording != allowHapticsAndSystemSoundsDuringRecording) {
+  if (self.allowHapticsAndSystemSoundsDuringRecording !=
+      allowHapticsAndSystemSoundsDuringRecording) {
     self.hasDirtySettings = true;
-    self.allowHapticsAndSystemSoundsDuringRecording = allowHapticsAndSystemSoundsDuringRecording;
+    self.allowHapticsAndSystemSoundsDuringRecording =
+        allowHapticsAndSystemSoundsDuringRecording;
   }
 
   if (self.isActive) {
@@ -156,9 +160,13 @@
   }
 
   if (error != nil) {
-    NSLog(@"[AudioSessionManager] setting session as %@ failed", active ? @"ACTIVE" : @"INACTIVE");
+    NSLog(
+        @"[AudioSessionManager] setting session as %@ failed",
+        active ? @"ACTIVE" : @"INACTIVE");
   } else {
-    NSLog(@"[AudioSessionManager] session is %@", active ? @"ACTIVE" : @"INACTIVE");
+    NSLog(
+        @"[AudioSessionManager] session is %@",
+        active ? @"ACTIVE" : @"INACTIVE");
   }
 
   return success;
@@ -167,7 +175,8 @@
 - (bool)configureAudioSession
 {
   if (!self.shouldManageSession) {
-    NSLog(@"[AudioSessionManager] Skipping AVAudioSession configuration, shouldManageSession is false");
+    NSLog(
+        @"[AudioSessionManager] Skipping AVAudioSession configuration, shouldManageSession is false");
     return true;
   }
 
@@ -184,19 +193,26 @@
 
   NSError *error = nil;
 
-  [self.audioSession setCategory:self.sessionCategory mode:self.sessionMode options:self.sessionOptions error:&error];
+  [self.audioSession setCategory:self.sessionCategory
+                            mode:self.sessionMode
+                         options:self.sessionOptions
+                           error:&error];
 
   if (error != nil) {
-    NSLog(@"Error while configuring audio session: %@", [error debugDescription]);
+    NSLog(
+        @"Error while configuring audio session: %@", [error debugDescription]);
     return false;
   }
 
   if (@available(iOS 13.0, *)) {
-    [self.audioSession setAllowHapticsAndSystemSoundsDuringRecording:self.allowHapticsAndSystemSoundsDuringRecording
+    [self.audioSession setAllowHapticsAndSystemSoundsDuringRecording:
+                           self.allowHapticsAndSystemSoundsDuringRecording
                                                                error:&error];
 
     if (error != nil) {
-      NSLog(@"Error while setting allowHapticsAndSystemSoundsDuringRecording: %@", [error debugDescription]);
+      NSLog(
+          @"Error while setting allowHapticsAndSystemSoundsDuringRecording: %@",
+          [error debugDescription]);
     }
   }
 
@@ -226,10 +242,13 @@
   self.hasDirtySettings = false;
 }
 
-- (void)requestRecordingPermissions:(RCTPromiseResolveBlock)resolve reject:(RCTPromiseRejectBlock)reject
+- (void)requestRecordingPermissions:(RCTPromiseResolveBlock)resolve
+                             reject:(RCTPromiseRejectBlock)reject
 {
-  id value = [[NSBundle mainBundle] objectForInfoDictionaryKey:@"NSMicrophoneUsageDescription"];
-  // if there is no entry NSMicrophoneUsageDescription calling requestRecordPermission will quit an app
+  id value = [[NSBundle mainBundle]
+      objectForInfoDictionaryKey:@"NSMicrophoneUsageDescription"];
+  // if there is no entry NSMicrophoneUsageDescription calling
+  // requestRecordPermission will quit an app
   if (value == nil) {
     reject(
         nil,
@@ -256,7 +275,8 @@
   }
 }
 
-- (void)checkRecordingPermissions:(RCTPromiseResolveBlock)resolve reject:(RCTPromiseRejectBlock)reject
+- (void)checkRecordingPermissions:(RCTPromiseResolveBlock)resolve
+                           reject:(RCTPromiseRejectBlock)reject
 {
   if (@available(iOS 17, *)) {
     NSInteger res = [[AVAudioApplication sharedInstance] recordPermission];
@@ -322,19 +342,29 @@
   }
 }
 
-- (void)getDevicesInfo:(RCTPromiseResolveBlock)resolve reject:(RCTPromiseRejectBlock)reject
+- (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);
 }
 
-- (NSArray<NSDictionary *> *)parseDeviceList:(NSArray<AVAudioSessionPortDescription *> *)devices
+- (NSArray<NSDictionary *> *)parseDeviceList:
+    (NSArray<AVAudioSessionPortDescription *> *)devices
 {
   NSMutableArray<NSDictionary *> *deviceList = [[NSMutableArray alloc] init];
 

package/ios/audioapi/ios/system/LockScreenManager.mm

@@ -2,13 +2,13 @@
 #import <audioapi/ios/AudioAPIModule.h>
 #import <audioapi/ios/system/LockScreenManager.h>
 
-#define LOCK_SCREEN_INFO                                          \
-  @{                                                              \
-    @"album" : MPMediaItemPropertyAlbumTitle,                     \
-    @"artist" : MPMediaItemPropertyArtist,                        \
-    @"duration" : MPMediaItemPropertyPlaybackDuration,            \
-    @"title" : MPMediaItemPropertyTitle,                          \
-    @"speed" : MPNowPlayingInfoPropertyPlaybackRate,              \
+#define LOCK_SCREEN_INFO \
+  @{ \
+    @"album" : MPMediaItemPropertyAlbumTitle, \
+    @"artist" : MPMediaItemPropertyArtist, \
+    @"duration" : MPMediaItemPropertyPlaybackDuration, \
+    @"title" : MPMediaItemPropertyTitle, \
+    @"speed" : MPNowPlayingInfoPropertyPlaybackRate, \
     @"elapsedTime" : MPNowPlayingInfoPropertyElapsedPlaybackTime, \
   }
 
@@ -48,12 +48,14 @@
   if (self.playingInfoCenter.nowPlayingInfo == nil) {
     lockScreenInfoDict = [NSMutableDictionary dictionary];
   } else {
-    lockScreenInfoDict = [[NSMutableDictionary alloc] initWithDictionary:self.playingInfoCenter.nowPlayingInfo];
+    lockScreenInfoDict = [[NSMutableDictionary alloc]
+        initWithDictionary:self.playingInfoCenter.nowPlayingInfo];
   }
 
   for (NSString *key in LOCK_SCREEN_INFO) {
     if ([info objectForKey:key] != nil) {
-      [lockScreenInfoDict setValue:[info objectForKey:key] forKey:[LOCK_SCREEN_INFO objectForKey:key]];
+      [lockScreenInfoDict setValue:[info objectForKey:key]
+                            forKey:[LOCK_SCREEN_INFO objectForKey:key]];
     }
   }
 
@@ -114,90 +116,119 @@
   self.artworkUrl = artworkUrl;
 
   // Custom handling of artwork in another thread, will be loaded async
-  dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_BACKGROUND, 0), ^{
-    UIImage *image = nil;
-
-    // check whether artwork path is present
-    if ([artworkUrl isEqual:@""]) {
-      return;
-    }
-
-    // artwork is url download from the interwebs
-    if ([artworkUrl hasPrefix:@"http://"] || [artworkUrl hasPrefix:@"https://"]) {
-      NSURL *imageURL = [NSURL URLWithString:artworkUrl];
-      NSData *imageData = [NSData dataWithContentsOfURL:imageURL];
-      image = [UIImage imageWithData:imageData];
-    } else {
-      NSString *localArtworkUrl = [artworkUrl stringByReplacingOccurrencesOfString:@"file://" withString:@""];
-      BOOL fileExists = [[NSFileManager defaultManager] fileExistsAtPath:localArtworkUrl];
-      if (fileExists) {
-        image = [UIImage imageNamed:localArtworkUrl];
-      }
-    }
-
-    // Check if image was available otherwise don't do anything
-    if (image == nil) {
-      return;
-    }
-
-    // check whether image is loaded
-    CGImageRef cgref = [image CGImage];
-    CIImage *cim = [image CIImage];
-
-    if (cim == nil && cgref == NULL) {
-      return;
-    }
-
-    dispatch_async(dispatch_get_main_queue(), ^{
-      // Check if URL wasn't changed in the meantime
-      if (![artworkUrl isEqual:self.artworkUrl]) {
-        return;
-      }
-
-      MPNowPlayingInfoCenter *center = [MPNowPlayingInfoCenter defaultCenter];
-      MPMediaItemArtwork *artwork = [[MPMediaItemArtwork alloc] initWithBoundsSize:image.size
-                                                                    requestHandler:^UIImage *_Nonnull(CGSize size) {
-                                                                      return image;
-                                                                    }];
-      NSMutableDictionary *mediaDict = (center.nowPlayingInfo != nil)
-          ? [[NSMutableDictionary alloc] initWithDictionary:center.nowPlayingInfo]
-          : [NSMutableDictionary dictionary];
-      [mediaDict setValue:artwork forKey:MPMediaItemPropertyArtwork];
-      center.nowPlayingInfo = mediaDict;
-    });
-  });
+  dispatch_async(
+      dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_BACKGROUND, 0), ^{
+        UIImage *image = nil;
+
+        // check whether artwork path is present
+        if ([artworkUrl isEqual:@""]) {
+          return;
+        }
+
+        // artwork is url download from the interwebs
+        if ([artworkUrl hasPrefix:@"http://"] ||
+            [artworkUrl hasPrefix:@"https://"]) {
+          NSURL *imageURL = [NSURL URLWithString:artworkUrl];
+          NSData *imageData = [NSData dataWithContentsOfURL:imageURL];
+          image = [UIImage imageWithData:imageData];
+        } else {
+          NSString *localArtworkUrl =
+              [artworkUrl stringByReplacingOccurrencesOfString:@"file://"
+                                                    withString:@""];
+          BOOL fileExists =
+              [[NSFileManager defaultManager] fileExistsAtPath:localArtworkUrl];
+          if (fileExists) {
+            image = [UIImage imageNamed:localArtworkUrl];
+          }
+        }
+
+        // Check if image was available otherwise don't do anything
+        if (image == nil) {
+          return;
+        }
+
+        // check whether image is loaded
+        CGImageRef cgref = [image CGImage];
+        CIImage *cim = [image CIImage];
+
+        if (cim == nil && cgref == NULL) {
+          return;
+        }
+
+        dispatch_async(dispatch_get_main_queue(), ^{
+          // Check if URL wasn't changed in the meantime
+          if (![artworkUrl isEqual:self.artworkUrl]) {
+            return;
+          }
+
+          MPNowPlayingInfoCenter *center =
+              [MPNowPlayingInfoCenter defaultCenter];
+          MPMediaItemArtwork *artwork = [[MPMediaItemArtwork alloc]
+              initWithBoundsSize:image.size
+                  requestHandler:^UIImage *_Nonnull(CGSize size) {
+                    return image;
+                  }];
+          NSMutableDictionary *mediaDict = (center.nowPlayingInfo != nil)
+              ? [[NSMutableDictionary alloc]
+                    initWithDictionary:center.nowPlayingInfo]
+              : [NSMutableDictionary dictionary];
+          [mediaDict setValue:artwork forKey:MPMediaItemPropertyArtwork];
+          center.nowPlayingInfo = mediaDict;
+        });
+      });
 }
 
 - (void)enableRemoteCommand:(NSString *)name enabled:(BOOL)enabled
 {
-  MPRemoteCommandCenter *remoteCenter = [MPRemoteCommandCenter sharedCommandCenter];
+  MPRemoteCommandCenter *remoteCenter =
+      [MPRemoteCommandCenter sharedCommandCenter];
 
   if ([name isEqual:@"remotePlay"]) {
-    [self enableCommand:remoteCenter.playCommand withSelector:@selector(onPlay:) enabled:enabled];
+    [self enableCommand:remoteCenter.playCommand
+           withSelector:@selector(onPlay:)
+                enabled:enabled];
   } else if ([name isEqual:@"remotePause"]) {
-    [self enableCommand:remoteCenter.pauseCommand withSelector:@selector(onPause:) enabled:enabled];
+    [self enableCommand:remoteCenter.pauseCommand
+           withSelector:@selector(onPause:)
+                enabled:enabled];
   } else if ([name isEqual:@"remoteStop"]) {
-    [self enableCommand:remoteCenter.stopCommand withSelector:@selector(onStop:) enabled:enabled];
+    [self enableCommand:remoteCenter.stopCommand
+           withSelector:@selector(onStop:)
+                enabled:enabled];
   } else if ([name isEqual:@"remoteTogglePlayPause"]) {
-    [self enableCommand:remoteCenter.togglePlayPauseCommand withSelector:@selector(onTogglePlayPause:) enabled:enabled];
+    [self enableCommand:remoteCenter.togglePlayPauseCommand
+           withSelector:@selector(onTogglePlayPause:)
+                enabled:enabled];
   } else if ([name isEqual:@"remoteChangePlaybackRate"]) {
     [self enableCommand:remoteCenter.changePlaybackRateCommand
            withSelector:@selector(onChangePlaybackRate:)
                 enabled:enabled];
   } else if ([name isEqual:@"remoteNextTrack"]) {
-    [self enableCommand:remoteCenter.nextTrackCommand withSelector:@selector(onNextTrack:) enabled:enabled];
+    [self enableCommand:remoteCenter.nextTrackCommand
+           withSelector:@selector(onNextTrack:)
+                enabled:enabled];
   } else if ([name isEqual:@"remotePreviousTrack"]) {
-    [self enableCommand:remoteCenter.previousTrackCommand withSelector:@selector(onPreviousTrack:) enabled:enabled];
+    [self enableCommand:remoteCenter.previousTrackCommand
+           withSelector:@selector(onPreviousTrack:)
+                enabled:enabled];
   } else if ([name isEqual:@"remoteSkipForward"]) {
     remoteCenter.skipForwardCommand.preferredIntervals = @[ @15 ];
-    [self enableCommand:remoteCenter.skipForwardCommand withSelector:@selector(onSkipForward:) enabled:enabled];
+    [self enableCommand:remoteCenter.skipForwardCommand
+           withSelector:@selector(onSkipForward:)
+                enabled:enabled];
   } else if ([name isEqual:@"remoteSkipBackward"]) {
     remoteCenter.skipBackwardCommand.preferredIntervals = @[ @15 ];
-    [self enableCommand:remoteCenter.skipBackwardCommand withSelector:@selector(onSkipBackward:) enabled:enabled];
+    [self enableCommand:remoteCenter.skipBackwardCommand
+           withSelector:@selector(onSkipBackward:)
+                enabled:enabled];
   } else if ([name isEqual:@"remoteSeekForward"]) {
-    [self enableCommand:remoteCenter.seekForwardCommand withSelector:@selector(onSeekForward:) enabled:enabled];
+    [self enableCommand:remoteCenter.seekForwardCommand
+           withSelector:@selector(onSeekForward:)
+                enabled:enabled];
   } else if ([name isEqual:@"remoteSeekBackward"]) {
-    [self enableCommand:remoteCenter.seekBackwardCommand withSelector:@selector(onSeekBackward:) enabled:enabled];
+    [self enableCommand:remoteCenter.seekBackwardCommand
+           withSelector:@selector(onSeekBackward:)
+                enabled:enabled];
   } else if ([name isEqual:@"remoteChangePlaybackPosition"]) {
     [self enableCommand:remoteCenter.changePlaybackPositionCommand
            withSelector:@selector(onChangePlaybackPosition:)
@@ -205,7 +236,9 @@
   }
 }
 
-- (void)enableCommand:(MPRemoteCommand *)command withSelector:(SEL)selector enabled:(BOOL)enabled
+- (void)enableCommand:(MPRemoteCommand *)command
+         withSelector:(SEL)selector
+              enabled:(BOOL)enabled
 {
   [command removeTarget:self action:selector];
   if (enabled) {
@@ -234,63 +267,79 @@
 
 - (MPRemoteCommandHandlerStatus)onTogglePlayPause:(MPRemoteCommandEvent *)event
 {
-  [self.audioAPIModule invokeHandlerWithEventName:@"remoteTogglePlayPause" eventBody:nil];
+  [self.audioAPIModule invokeHandlerWithEventName:@"remoteTogglePlayPause"
+                                        eventBody:nil];
   return MPRemoteCommandHandlerStatusSuccess;
 }
 
-- (MPRemoteCommandHandlerStatus)onChangePlaybackRate:(MPChangePlaybackRateCommandEvent *)event
+- (MPRemoteCommandHandlerStatus)onChangePlaybackRate:
+    (MPChangePlaybackRateCommandEvent *)event
 {
-  NSDictionary *body = @{@"value" : [NSNumber numberWithDouble:event.playbackRate]};
+  NSDictionary *body =
+      @{@"value" : [NSNumber numberWithDouble:event.playbackRate]};
 
-  [self.audioAPIModule invokeHandlerWithEventName:@"remoteChangePlaybackRate" eventBody:body];
+  [self.audioAPIModule invokeHandlerWithEventName:@"remoteChangePlaybackRate"
+                                        eventBody:body];
   return MPRemoteCommandHandlerStatusSuccess;
 }
 
 - (MPRemoteCommandHandlerStatus)onNextTrack:(MPRemoteCommandEvent *)event
 {
-  [self.audioAPIModule invokeHandlerWithEventName:@"remoteNextTrack" eventBody:nil];
+  [self.audioAPIModule invokeHandlerWithEventName:@"remoteNextTrack"
+                                        eventBody:nil];
   return MPRemoteCommandHandlerStatusSuccess;
 }
 
 - (MPRemoteCommandHandlerStatus)onPreviousTrack:(MPRemoteCommandEvent *)event
 {
-  [self.audioAPIModule invokeHandlerWithEventName:@"remotePreviousTrack" eventBody:nil];
+  [self.audioAPIModule invokeHandlerWithEventName:@"remotePreviousTrack"
+                                        eventBody:nil];
   return MPRemoteCommandHandlerStatusSuccess;
 }
 
 - (MPRemoteCommandHandlerStatus)onSeekForward:(MPRemoteCommandEvent *)event
 {
-  [self.audioAPIModule invokeHandlerWithEventName:@"remoteSeekForward" eventBody:nil];
+  [self.audioAPIModule invokeHandlerWithEventName:@"remoteSeekForward"
+                                        eventBody:nil];
   return MPRemoteCommandHandlerStatusSuccess;
 }
 
 - (MPRemoteCommandHandlerStatus)onSeekBackward:(MPRemoteCommandEvent *)event
 {
-  [self.audioAPIModule invokeHandlerWithEventName:@"remoteSeekBackward" eventBody:nil];
+  [self.audioAPIModule invokeHandlerWithEventName:@"remoteSeekBackward"
+                                        eventBody:nil];
   return MPRemoteCommandHandlerStatusSuccess;
 }
 
-- (MPRemoteCommandHandlerStatus)onSkipForward:(MPSkipIntervalCommandEvent *)event
+- (MPRemoteCommandHandlerStatus)onSkipForward:
+    (MPSkipIntervalCommandEvent *)event
 {
   NSDictionary *body = @{@"value" : [NSNumber numberWithDouble:event.interval]};
 
-  [self.audioAPIModule invokeHandlerWithEventName:@"remoteSkipForward" eventBody:body];
+  [self.audioAPIModule invokeHandlerWithEventName:@"remoteSkipForward"
+                                        eventBody:body];
   return MPRemoteCommandHandlerStatusSuccess;
 }
 
-- (MPRemoteCommandHandlerStatus)onSkipBackward:(MPSkipIntervalCommandEvent *)event
+- (MPRemoteCommandHandlerStatus)onSkipBackward:
+    (MPSkipIntervalCommandEvent *)event
 {
   NSDictionary *body = @{@"value" : [NSNumber numberWithDouble:event.interval]};
 
-  [self.audioAPIModule invokeHandlerWithEventName:@"remoteSkipBackward" eventBody:body];
+  [self.audioAPIModule invokeHandlerWithEventName:@"remoteSkipBackward"
+                                        eventBody:body];
   return MPRemoteCommandHandlerStatusSuccess;
 }
 
-- (MPRemoteCommandHandlerStatus)onChangePlaybackPosition:(MPChangePlaybackPositionCommandEvent *)event
+- (MPRemoteCommandHandlerStatus)onChangePlaybackPosition:
+    (MPChangePlaybackPositionCommandEvent *)event
 {
-  NSDictionary *body = @{@"value" : [NSNumber numberWithDouble:event.positionTime]};
+  NSDictionary *body =
+      @{@"value" : [NSNumber numberWithDouble:event.positionTime]};
 
-  [self.audioAPIModule invokeHandlerWithEventName:@"remoteChangePlaybackPosition" eventBody:body];
+  [self.audioAPIModule
+      invokeHandlerWithEventName:@"remoteChangePlaybackPosition"
+                       eventBody:body];
   return MPRemoteCommandHandlerStatusSuccess;
 }