react-native-audio-api 0.5.5 → 0.6.0-rc.0

package/ios/audioapi/ios/AudioManagerModule.mm

@@ -0,0 +1,92 @@
+#import <audioapi/ios/AudioManagerModule.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>
+
+@implementation AudioManagerModule
+
+RCT_EXPORT_MODULE(AudioManagerModule);
+
+- (id)init
+{
+  if (self == [super init]) {
+    self.audioEngine = [AudioEngine sharedInstance];
+    self.audioSessionManager = [AudioSessionManager sharedInstance];
+    self.notificationManager = [NotificationManager sharedInstance];
+    self.lockScreenManager = [LockScreenManager sharedInstanceWithAudioManagerModule:self];
+  }
+
+  return self;
+}
+
+- (void)cleanup
+{
+  [self.audioEngine cleanup];
+  [self.notificationManager cleanup];
+  [self.audioSessionManager cleanup];
+  [self.lockScreenManager cleanup];
+}
+
+- (void)dealloc
+{
+  [self cleanup];
+}
+
+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(setAudioSessionOptions : (NSString *)category mode : (NSString *)mode options : (NSArray *)
+                      options active : (BOOL)active)
+{
+  NSError *error = nil;
+
+  if (active) {
+    [self.audioSessionManager setAudioSessionOptions:category mode:mode options:options];
+  } else {
+    [self.audioSessionManager setActive:false error:&error];
+  }
+}
+
+RCT_EXPORT_BLOCKING_SYNCHRONOUS_METHOD(getDevicePreferredSampleRate)
+{
+  return [self.audioSessionManager getDevicePreferredSampleRate];
+}
+
+- (NSArray<NSString *> *)supportedEvents
+{
+  return @[
+    @"onRemotePlay",
+    @"onRemotePause",
+    @"onRemoteStop",
+    @"onRemoteTogglePlayPause",
+    @"onRemoteChangePlaybackRate",
+    @"onRemoteNextTrack",
+    @"onRemotePreviousTrack",
+    @"onRemoteSkipForward",
+    @"onRemoteSkipBackward",
+    @"onRemoteSeekForward",
+    @"onRemoteSeekBackward",
+    @"onRemoteChangePlaybackPosition"
+  ];
+}
+
+- (void)sendEventWithValue:(NSString *)event withValue:(NSString *)value
+{
+  [self sendEventWithName:@"AudioManagerModule" body:@{@"name" : event, @"value" : value}];
+}
+
+@end

package/ios/audioapi/ios/core/AudioPlayer.h

@@ -7,22 +7,18 @@ typedef void (^RenderAudioBlock)(AudioBufferList *outputBuffer, int numFrames);
 
 @interface AudioPlayer : NSObject
 
-@property (nonatomic, strong) AVAudioEngine *audioEngine;
-@property (nonatomic, weak) AVAudioSession *audioSession;
-@property (nonatomic, weak) NSNotificationCenter *notificationCenter;
 @property (nonatomic, strong) AVAudioFormat *format;
 @property (nonatomic, strong) AVAudioSourceNode *sourceNode;
 @property (nonatomic, copy) RenderAudioBlock renderAudio;
 @property (nonatomic, assign) float sampleRate;
 @property (nonatomic, assign) int channelCount;
 @property (nonatomic, assign) bool isRunning;
+@property (nonatomic, strong) NSString *sourceNodeId;
 @property (nonatomic, strong) AVAudioSourceNodeRenderBlock renderBlock;
 
-- (instancetype)initWithRenderAudioBlock:(RenderAudioBlock)renderAudio channelCount:(int)channelCount;
-
-- (instancetype)initWithRenderAudioBlock:(RenderAudioBlock)renderAudio
-                              sampleRate:(float)sampleRate
-                            channelCount:(int)channelCount;
+- (instancetype)initWithRenderAudio:(RenderAudioBlock)renderAudio
+                         sampleRate:(float)sampleRate
+                       channelCount:(int)channelCount;
 
 - (float)getSampleRate;
 
@@ -36,8 +32,4 @@ typedef void (^RenderAudioBlock)(AudioBufferList *outputBuffer, int numFrames);
 
 - (void)cleanup;
 
-- (void)setupAndInitAudioSession;
-
-- (void)connectAudioEngine;
-
 @end

package/ios/audioapi/ios/core/AudioPlayer.m

@@ -1,52 +1,17 @@
 #import <audioapi/ios/core/AudioPlayer.h>
+#import <audioapi/ios/system/AudioEngine.h>
 
 @implementation AudioPlayer
 
-- (instancetype)initWithRenderAudioBlock:(RenderAudioBlock)renderAudio channelCount:(int)channelCount
+- (instancetype)initWithRenderAudio:(RenderAudioBlock)renderAudio
+                         sampleRate:(float)sampleRate
+                       channelCount:(int)channelCount
 {
   if (self = [super init]) {
-    self.renderAudio = [renderAudio copy];
-    self.audioEngine = [[AVAudioEngine alloc] init];
-    self.audioEngine.mainMixerNode.outputVolume = 1;
-    self.isRunning = true;
-
-    [self setupAndInitAudioSession];
+    self.sampleRate = sampleRate;
 
-    self.sampleRate = [self.audioSession sampleRate];
     self.channelCount = channelCount;
-
-    __weak typeof(self) weakSelf = self;
-    self.renderBlock = ^OSStatus(
-        BOOL *isSilence, const AudioTimeStamp *timestamp, AVAudioFrameCount frameCount, AudioBufferList *outputData) {
-      if (outputData->mNumberBuffers != weakSelf.channelCount) {
-        return kAudioServicesBadPropertySizeError;
-      }
-
-      weakSelf.renderAudio(outputData, frameCount);
-      return kAudioServicesNoError;
-    };
-
-    _format = [[AVAudioFormat alloc] initStandardFormatWithSampleRate:self.sampleRate channels:self.channelCount];
-    _sourceNode = [[AVAudioSourceNode alloc] initWithFormat:self.format renderBlock:self.renderBlock];
-  }
-
-  return self;
-}
-
-- (instancetype)initWithRenderAudioBlock:(RenderAudioBlock)renderAudio
-                              sampleRate:(float)sampleRate
-                            channelCount:(int)channelCount
-{
-  if (self = [super init]) {
     self.renderAudio = [renderAudio copy];
-    self.audioEngine = [[AVAudioEngine alloc] init];
-    self.audioEngine.mainMixerNode.outputVolume = 1;
-    self.isRunning = true;
-
-    [self setupAndInitAudioSession];
-
-    self.sampleRate = sampleRate;
-    self.channelCount = channelCount;
 
     __weak typeof(self) weakSelf = self;
     self.renderBlock = ^OSStatus(
@@ -73,96 +38,49 @@
 
 - (void)start
 {
+  NSLog(@"[AudioPlayer] start");
+  AudioEngine *audioEngine = [AudioEngine sharedInstance];
   self.isRunning = true;
-  [self connectAudioEngine];
+  self.sourceNodeId = [audioEngine attachSourceNode:self.sourceNode format:self.format];
 }
 
 - (void)stop
 {
-  self.isRunning = false;
-  [self.audioEngine detachNode:self.sourceNode];
-
-  if (self.audioEngine.isRunning) {
-    [self.audioEngine stop];
+  NSLog(@"[AudioPlayer] stop");
+  if (!self.isRunning) {
+    return;
   }
 
-  NSError *error = nil;
-  [self.audioSession setActive:false error:&error];
-
-  if (error != nil) {
-    NSLog(@"Error while deactivating audio session: %@", [error debugDescription]);
-  }
+  AudioEngine *audioEngine = [AudioEngine sharedInstance];
+  self.isRunning = false;
+  [audioEngine detachSourceNodeWithId:self.sourceNodeId];
+  self.sourceNodeId = nil;
 }
 
 - (void)suspend
 {
-  [self.audioEngine pause];
+  NSLog(@"[AudioPlayer] suspend");
+  if (!self.isRunning) {
+    return;
+  }
+
+  AudioEngine *audioEngine = [AudioEngine sharedInstance];
   self.isRunning = false;
+  [audioEngine detachSourceNodeWithId:self.sourceNodeId];
+  self.sourceNodeId = nil;
 }
 
 - (void)resume
 {
+  NSLog(@"[AudioPlayer] resume");
+  AudioEngine *audioEngine = [AudioEngine sharedInstance];
   self.isRunning = true;
-  [self setupAndInitAudioSession];
-  [self connectAudioEngine];
+  self.sourceNodeId = [audioEngine attachSourceNode:self.sourceNode format:self.format];
 }
 
 - (void)cleanup
 {
-  self.audioEngine = nil;
-  self.audioSession = nil;
   self.renderAudio = nil;
 }
 
-- (void)setupAndInitAudioSession
-{
-  NSError *error = nil;
-
-  if (!self.audioSession) {
-    self.audioSession = [AVAudioSession sharedInstance];
-  }
-
-  [self.audioSession setCategory:AVAudioSessionCategoryPlayback
-                            mode:AVAudioSessionModeDefault
-                         options:AVAudioSessionCategoryOptionDuckOthers | AVAudioSessionCategoryOptionAllowAirPlay
-                           error:&error];
-
-  if (error != nil) {
-    NSLog(@"Error while configuring audio session: %@", [error debugDescription]);
-    return;
-  }
-
-  [self.audioSession setPreferredIOBufferDuration:0.022 error:&error];
-
-  if (error != nil) {
-    NSLog(@"Error while setting buffer size in audio session: %@", [error debugDescription]);
-    return;
-  }
-
-  [self.audioSession setActive:true error:&error];
-
-  if (error != nil) {
-    NSLog(@"Error while activating audio session: %@", [error debugDescription]);
-    return;
-  }
-}
-
-- (void)connectAudioEngine
-{
-  if ([self.audioEngine isRunning]) {
-    return;
-  }
-
-  [self.audioEngine attachNode:self.sourceNode];
-  [self.audioEngine connect:self.sourceNode to:self.audioEngine.mainMixerNode format:self.format];
-
-  if (![self.audioEngine isRunning]) {
-    NSError *error = nil;
-
-    if (![self.audioEngine startAndReturnError:&error]) {
-      NSLog(@"Error starting audio engine: %@", [error debugDescription]);
-    }
-  }
-}
-
 @end

package/ios/audioapi/ios/core/IOSAudioPlayer.h

@@ -10,8 +10,8 @@ typedef struct objc_object AudioPlayer;
 
 namespace audioapi {
 
-class AudioContext;
 class AudioBus;
+class AudioContext;
 
 class IOSAudioPlayer {
  protected:
@@ -21,8 +21,6 @@ class IOSAudioPlayer {
   int channelCount_;
 
  public:
-  explicit IOSAudioPlayer(
-      const std::function<void(std::shared_ptr<AudioBus>, int)> &renderAudio);
   IOSAudioPlayer(
       const std::function<void(std::shared_ptr<AudioBus>, int)> &renderAudio,
       float sampleRate);

package/ios/audioapi/ios/core/IOSAudioPlayer.mm

@@ -8,31 +8,6 @@
 
 namespace audioapi {
 
-IOSAudioPlayer::IOSAudioPlayer(const std::function<void(std::shared_ptr<AudioBus>, int)> &renderAudio)
-    : channelCount_(2), renderAudio_(renderAudio), audioBus_(0)
-{
-  RenderAudioBlock renderAudioBlock = ^(AudioBufferList *outputData, int numFrames) {
-    int processedFrames = 0;
-
-    while (processedFrames < numFrames) {
-      int framesToProcess = std::min(numFrames - processedFrames, RENDER_QUANTUM_SIZE);
-      renderAudio_(audioBus_, framesToProcess);
-
-      for (int channel = 0; channel < channelCount_; channel += 1) {
-        float *outputChannel = (float *)outputData->mBuffers[channel].mData;
-        auto *inputChannel = audioBus_->getChannel(channel)->getData();
-
-        memcpy(outputChannel + processedFrames, inputChannel, framesToProcess * sizeof(float));
-      }
-
-      processedFrames += framesToProcess;
-    }
-  };
-
-  audioPlayer_ = [[AudioPlayer alloc] initWithRenderAudioBlock:renderAudioBlock channelCount:channelCount_];
-  audioBus_ = std::make_shared<AudioBus>(RENDER_QUANTUM_SIZE, channelCount_, getSampleRate());
-}
-
 IOSAudioPlayer::IOSAudioPlayer(const std::function<void(std::shared_ptr<AudioBus>, int)> &renderAudio, float sampleRate)
     : channelCount_(2), renderAudio_(renderAudio), audioBus_(0)
 {
@@ -54,9 +29,10 @@ IOSAudioPlayer::IOSAudioPlayer(const std::function<void(std::shared_ptr<AudioBus
     }
   };
 
-  audioPlayer_ = [[AudioPlayer alloc] initWithRenderAudioBlock:renderAudioBlock
-                                                    sampleRate:sampleRate
-                                                  channelCount:channelCount_];
+  audioPlayer_ = [[AudioPlayer alloc] initWithRenderAudio:renderAudioBlock
+                                               sampleRate:sampleRate
+                                             channelCount:channelCount_];
+
   audioBus_ = std::make_shared<AudioBus>(RENDER_QUANTUM_SIZE, channelCount_, getSampleRate());
 }
 

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

@@ -0,0 +1,23 @@
+#pragma once
+
+#import <AVFoundation/AVFoundation.h>
+#import <Foundation/Foundation.h>
+
+@interface AudioEngine : NSObject
+
+@property (nonatomic, strong) AVAudioEngine *audioEngine;
+@property (nonatomic, strong) NSMutableDictionary *sourceNodes;
+@property (nonatomic, strong) NSMutableDictionary *sourceFormats;
+
++ (instancetype)sharedInstance;
+- (void)cleanup;
+
+- (bool)rebuildAudioEngine;
+- (void)startEngine;
+- (void)stopEngine;
+- (bool)isRunning;
+
+- (NSString *)attachSourceNode:(AVAudioSourceNode *)sourceNode format:(AVAudioFormat *)format;
+- (void)detachSourceNodeWithId:(NSString *)sourceNodeId;
+
+@end

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

@@ -0,0 +1,137 @@
+#import <audioapi/ios/system/AudioEngine.h>
+
+@implementation AudioEngine
+
+static AudioEngine *_sharedInstance = nil;
+
++ (instancetype)sharedInstance
+{
+  static dispatch_once_t onceToken;
+  dispatch_once(&onceToken, ^{
+    _sharedInstance = [[self alloc] initPrivate];
+  });
+  return _sharedInstance;
+}
+
+- (instancetype)init
+{
+  @throw [NSException exceptionWithName:@"Singleton" reason:@"Use +[AudioEngine sharedInstance]" userInfo:nil];
+  return nil;
+}
+
+- (instancetype)initPrivate
+{
+  if (self = [super init]) {
+    self.audioEngine = [[AVAudioEngine alloc] init];
+    self.audioEngine.mainMixerNode.outputVolume = 1;
+    self.sourceNodes = [[NSMutableDictionary alloc] init];
+    self.sourceFormats = [[NSMutableDictionary alloc] init];
+  }
+  return self;
+}
+
+- (void)cleanup
+{
+  NSLog(@"[AudioEngine] cleanup");
+  if ([self.audioEngine isRunning]) {
+    [self.audioEngine stop];
+  }
+
+  self.audioEngine = nil;
+  self.sourceNodes = nil;
+  self.sourceFormats = nil;
+}
+
+- (bool)rebuildAudioEngine
+{
+  NSError *error = nil;
+
+  if ([self.audioEngine isRunning]) {
+    return true;
+  }
+
+  for (id sourceNodeId in self.sourceNodes) {
+    AVAudioSourceNode *sourceNode = [self.sourceNodes valueForKey:sourceNodeId];
+    AVAudioFormat *format = [self.sourceFormats valueForKey:sourceNodeId];
+
+    [self.audioEngine attachNode:sourceNode];
+    [self.audioEngine connect:sourceNode to:self.audioEngine.mainMixerNode format:format];
+  }
+
+  if ([self.audioEngine isRunning]) {
+    return true;
+  }
+
+  if (![self.audioEngine startAndReturnError:&error]) {
+    NSLog(@"Error while rebuilding audio engine: %@", [error debugDescription]);
+    return false;
+  }
+
+  return true;
+}
+
+- (void)startEngine
+{
+  NSLog(@"[AudioEngine] startEngine");
+  NSError *error = nil;
+
+  if ([self.audioEngine isRunning]) {
+    return;
+  }
+
+  [self.audioEngine startAndReturnError:&error];
+
+  if (error != nil) {
+    NSLog(@"Error while starting the audio engine: %@", [error debugDescription]);
+  }
+}
+
+- (void)stopEngine
+{
+  NSLog(@"[AudioEngine] stopEngine");
+  if (![self.audioEngine isRunning]) {
+    return;
+  }
+
+  [self.audioEngine pause];
+}
+
+- (bool)isRunning
+{
+  return [self.audioEngine isRunning];
+}
+
+- (NSString *)attachSourceNode:(AVAudioSourceNode *)sourceNode format:(AVAudioFormat *)format
+{
+  NSString *sourceNodeId = [[NSUUID UUID] UUIDString];
+  NSLog(@"[AudioEngine] attaching new source node with ID: %@", sourceNodeId);
+
+  [self.sourceNodes setValue:sourceNode forKey:sourceNodeId];
+  [self.sourceFormats setValue:format forKey:sourceNodeId];
+
+  [self.audioEngine attachNode:sourceNode];
+  [self.audioEngine connect:sourceNode to:self.audioEngine.mainMixerNode format:format];
+
+  if ([self.sourceNodes count] == 1) {
+    [self startEngine];
+  }
+
+  return sourceNodeId;
+}
+
+- (void)detachSourceNodeWithId:(NSString *)sourceNodeId
+{
+  NSLog(@"[AudioEngine] detaching source nde with ID: %@", sourceNodeId);
+
+  AVAudioSourceNode *sourceNode = [self.sourceNodes valueForKey:sourceNodeId];
+  [self.audioEngine detachNode:sourceNode];
+
+  [self.sourceNodes removeObjectForKey:sourceNodeId];
+  [self.sourceFormats removeObjectForKey:sourceNodeId];
+
+  if ([self.sourceNodes count] == 0) {
+    [self stopEngine];
+  }
+}
+
+@end

package/ios/audioapi/ios/system/AudioSessionManager.h

@@ -0,0 +1,22 @@
+#pragma once
+
+#import <AVFoundation/AVFoundation.h>
+#import <Foundation/Foundation.h>
+
+@interface AudioSessionManager : NSObject
+
+@property (nonatomic, weak) AVAudioSession *audioSession;
+
+@property (nonatomic, assign) AVAudioSessionMode sessionMode;
+@property (nonatomic, assign) AVAudioSessionCategory sessionCategory;
+@property (nonatomic, assign) AVAudioSessionCategoryOptions sessionOptions;
+
++ (instancetype)sharedInstance;
+- (void)cleanup;
+- (bool)configureAudioSession;
+
+- (NSNumber *)getDevicePreferredSampleRate;
+- (void)setAudioSessionOptions:(NSString *)category mode:(NSString *)mode options:(NSArray *)options;
+- (bool)setActive:(bool)active error:(NSError **)error;
+
+@end