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

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

@@ -0,0 +1,183 @@
+#import <audioapi/ios/system/AudioSessionManager.h>
+
+@implementation AudioSessionManager
+
+static AudioSessionManager *_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 +[AudioSessionManager sharedInstance]" userInfo:nil];
+  return nil;
+}
+
+- (instancetype)initPrivate
+{
+  if (self = [super init]) {
+    self.audioSession = [AVAudioSession sharedInstance];
+
+    self.sessionCategory = AVAudioSessionCategoryPlayback;
+    self.sessionMode = AVAudioSessionModeDefault;
+    self.sessionOptions = AVAudioSessionCategoryOptionDuckOthers | AVAudioSessionCategoryOptionAllowBluetooth;
+
+    [self configureAudioSession];
+  }
+  return self;
+}
+
+- (void)cleanup
+{
+  NSLog(@"[AudioSessionManager] cleanup");
+
+  self.audioSession = nil;
+}
+
+- (NSNumber *)getDevicePreferredSampleRate
+{
+  return [NSNumber numberWithFloat:[self.audioSession sampleRate]];
+}
+
+- (void)setAudioSessionOptions:(NSString *)category mode:(NSString *)mode options:(NSArray *)options
+{
+  AVAudioSessionCategory sessionCategory = self.sessionCategory;
+  AVAudioSessionMode sessionMode = self.sessionMode;
+  AVAudioSessionCategoryOptions sessionOptions = 0;
+
+  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;
+  }
+
+  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;
+  }
+
+  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;
+    }
+
+    if ([option isEqualToString:@"allowBluetoothA2DP"]) {
+      sessionOptions |= AVAudioSessionCategoryOptionAllowBluetoothA2DP;
+    }
+
+    if ([option isEqualToString:@"overrideMutedMicrophoneInterruption"]) {
+      sessionOptions |= AVAudioSessionCategoryOptionOverrideMutedMicrophoneInterruption;
+    }
+
+    if ([option isEqualToString:@"interruptSpokenAudioAndMixWithOthers"]) {
+      sessionOptions |= AVAudioSessionCategoryOptionInterruptSpokenAudioAndMixWithOthers;
+    }
+  }
+
+  bool hasDirtySettings = false;
+
+  if (self.sessionCategory != sessionCategory) {
+    hasDirtySettings = true;
+    self.sessionCategory = sessionCategory;
+  }
+
+  if (self.sessionMode != sessionMode) {
+    hasDirtySettings = true;
+    self.sessionMode = sessionMode;
+  }
+
+  if (self.sessionOptions != sessionOptions) {
+    hasDirtySettings = true;
+    self.sessionOptions = sessionOptions;
+  }
+
+  if (hasDirtySettings) {
+    [self configureAudioSession];
+  }
+}
+
+- (bool)setActive:(bool)active error:(NSError **)error
+{
+  return [self.audioSession setActive:active error:error];
+}
+
+- (bool)configureAudioSession
+{
+  NSLog(
+      @"[AudioSessionManager] configureAudioSession, category: %@, mode: %@, options: %lu",
+      self.sessionCategory,
+      self.sessionMode,
+      (unsigned long)self.sessionOptions);
+
+  NSError *error = nil;
+
+  [self.audioSession setPreferredIOBufferDuration:0.022 error:&error];
+
+  if (error != nil) {
+    NSLog(@"Error while setting preffered IO buffer duration: %@", [error debugDescription]);
+    return false;
+  }
+
+  [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;
+  }
+
+  [self setActive:true error:&error];
+
+  if (error != nil) {
+    NSLog(@"Error while activating audio session: %@", [error debugDescription]);
+    return false;
+  }
+
+  return true;
+}
+
+@end

package/ios/audioapi/ios/system/LockScreenManager.h

@@ -0,0 +1,23 @@
+#pragma once
+
+#import <AVFoundation/AVFoundation.h>
+#import <Foundation/Foundation.h>
+#import <MediaPlayer/MediaPlayer.h>
+
+@class AudioManagerModule;
+
+@interface LockScreenManager : NSObject
+
+@property (nonatomic, weak) AudioManagerModule *audioManagerModule;
+
+@property (nonatomic, weak) MPNowPlayingInfoCenter *playingInfoCenter;
+@property (nonatomic, copy) NSString *artworkUrl;
+
++ (instancetype)sharedInstanceWithAudioManagerModule:(AudioManagerModule *)audioManagerModule;
+- (void)cleanup;
+
+- (void)setLockScreenInfo:(NSDictionary *)info;
+- (void)resetLockScreenInfo;
+- (void)enableRemoteCommand:(NSString *)name enabled:(BOOL)enabled;
+
+@end

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

@@ -0,0 +1,299 @@
+#import <MediaPlayer/MediaPlayer.h>
+#import <audioapi/ios/AudioManagerModule.h>
+#import <audioapi/ios/system/LockScreenManager.h>
+
+#define LOCK_SCREEN_INFO                                          \
+  @{                                                              \
+    @"album" : MPMediaItemPropertyAlbumTitle,                     \
+    @"artist" : MPMediaItemPropertyArtist,                        \
+    @"genre" : MPMediaItemPropertyGenre,                          \
+    @"duration" : MPMediaItemPropertyPlaybackDuration,            \
+    @"title" : MPMediaItemPropertyTitle,                          \
+    @"isLiveStream" : MPNowPlayingInfoPropertyIsLiveStream,       \
+    @"speed" : MPNowPlayingInfoPropertyPlaybackRate,              \
+    @"elapsedTime" : MPNowPlayingInfoPropertyElapsedPlaybackTime, \
+  }
+
+@implementation LockScreenManager
+
+static LockScreenManager *_sharedInstance = nil;
+
++ (instancetype)sharedInstanceWithAudioManagerModule:(AudioManagerModule *)audioManagerModule
+{
+  static dispatch_once_t onceToken;
+  dispatch_once(&onceToken, ^{
+    _sharedInstance = [[self alloc] initPrivateWithAudioManagerModule:audioManagerModule];
+  });
+  return _sharedInstance;
+}
+
+- (instancetype)init
+{
+  @throw [NSException exceptionWithName:@"Singleton" reason:@"Use +[LockScreenManager sharedInstance]" userInfo:nil];
+  return nil;
+}
+
+- (instancetype)initPrivateWithAudioManagerModule:(AudioManagerModule *)audioManagerModule
+{
+  if (self = [super init]) {
+    self.audioManagerModule = audioManagerModule;
+    self.playingInfoCenter = [MPNowPlayingInfoCenter defaultCenter];
+    [[UIApplication sharedApplication] beginReceivingRemoteControlEvents];
+  }
+  return self;
+}
+
+- (void)cleanup
+{
+  NSLog(@"[LockScreenManager] cleanup");
+  [self resetLockScreenInfo];
+}
+
+- (void)setLockScreenInfo:(NSDictionary *)info
+{
+  // now playing info(lock screen info)
+  NSMutableDictionary *lockScreenInfoDict;
+
+  if (self.playingInfoCenter.nowPlayingInfo == nil) {
+    lockScreenInfoDict = [NSMutableDictionary dictionary];
+  } else {
+    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]];
+    }
+  }
+
+  self.playingInfoCenter.nowPlayingInfo = lockScreenInfoDict;
+
+  // playback state
+  NSString *state = [info objectForKey:@"state"];
+
+  if (state != nil) {
+    if ([state isEqualToString:@"state_playing"]) {
+      self.playingInfoCenter.playbackState = MPNowPlayingPlaybackStatePlaying;
+    } else if ([state isEqualToString:@"state_paused"]) {
+      self.playingInfoCenter.playbackState = MPNowPlayingPlaybackStatePaused;
+    } else if ([state isEqualToString:@"state_stopped"]) {
+      self.playingInfoCenter.playbackState = MPNowPlayingPlaybackStateStopped;
+    }
+  }
+
+  // artwork
+  NSString *artworkUrl = [self getArtworkUrl:[info objectForKey:@"artwork"]];
+  [self updateArtworkIfNeeded:artworkUrl];
+}
+
+- (void)resetLockScreenInfo
+{
+  self.playingInfoCenter.nowPlayingInfo = nil;
+  self.artworkUrl = nil;
+}
+
+- (NSString *)getArtworkUrl:(NSString *)artwork
+{
+  NSString *artworkUrl = nil;
+
+  if (artwork) {
+    if ([artwork isKindOfClass:[NSString class]]) {
+      artworkUrl = artwork;
+    } else if ([[artwork valueForKey:@"uri"] isKindOfClass:[NSString class]]) {
+      artworkUrl = [artwork valueForKey:@"uri"];
+    }
+  }
+
+  return artworkUrl;
+}
+
+- (void)updateArtworkIfNeeded:(id)artworkUrl
+{
+  if (artworkUrl == nil) {
+    return;
+  }
+
+  MPNowPlayingInfoCenter *center = [MPNowPlayingInfoCenter defaultCenter];
+  if ([artworkUrl isEqualToString:self.artworkUrl] &&
+      [center.nowPlayingInfo objectForKey:MPMediaItemPropertyArtwork] != nil) {
+    return;
+  }
+
+  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;
+    });
+  });
+}
+
+- (void)enableRemoteCommand:(NSString *)name enabled:(BOOL)enabled
+{
+  MPRemoteCommandCenter *remoteCenter = [MPRemoteCommandCenter sharedCommandCenter];
+
+  if ([name isEqual:@"play"]) {
+    [self enableCommand:remoteCenter.playCommand withSelector:@selector(onPlay:) enabled:enabled];
+  } else if ([name isEqual:@"pause"]) {
+    [self enableCommand:remoteCenter.pauseCommand withSelector:@selector(onPause:) enabled:enabled];
+  } else if ([name isEqual:@"stop"]) {
+    [self enableCommand:remoteCenter.stopCommand withSelector:@selector(onStop:) enabled:enabled];
+  } else if ([name isEqual:@"togglePlayPause"]) {
+    [self enableCommand:remoteCenter.togglePlayPauseCommand withSelector:@selector(onTogglePlayPause:) enabled:enabled];
+  } else if ([name isEqual:@"changePlaybackRate"]) {
+    [self enableCommand:remoteCenter.changePlaybackRateCommand
+           withSelector:@selector(onChangePlaybackRate:)
+                enabled:enabled];
+  } else if ([name isEqual:@"nextTrack"]) {
+    [self enableCommand:remoteCenter.nextTrackCommand withSelector:@selector(onNextTrack:) enabled:enabled];
+  } else if ([name isEqual:@"previousTrack"]) {
+    [self enableCommand:remoteCenter.previousTrackCommand withSelector:@selector(onPreviousTrack:) enabled:enabled];
+  } else if ([name isEqual:@"skipForward"]) {
+    [self enableCommand:remoteCenter.skipForwardCommand withSelector:@selector(onSkipForward:) enabled:enabled];
+  } else if ([name isEqual:@"skipBackward"]) {
+    [self enableCommand:remoteCenter.skipBackwardCommand withSelector:@selector(onSkipBackward:) enabled:enabled];
+  } else if ([name isEqual:@"seekForward"]) {
+    [self enableCommand:remoteCenter.seekForwardCommand withSelector:@selector(onSeekForward:) enabled:enabled];
+  } else if ([name isEqual:@"seekBackward"]) {
+    [self enableCommand:remoteCenter.seekBackwardCommand withSelector:@selector(onSeekBackward:) enabled:enabled];
+  } else if ([name isEqual:@"changePlaybackPosition"]) {
+    [self enableCommand:remoteCenter.changePlaybackPositionCommand
+           withSelector:@selector(onChangePlaybackPosition:)
+                enabled:enabled];
+  }
+}
+
+- (void)enableCommand:(MPRemoteCommand *)command withSelector:(SEL)selector enabled:(BOOL)enabled
+{
+  [command removeTarget:self action:selector];
+  if (enabled) {
+    [command addTarget:self action:selector];
+  }
+  command.enabled = enabled;
+}
+
+- (MPRemoteCommandHandlerStatus)onPlay:(MPRemoteCommandEvent *)event
+{
+  [self.audioManagerModule sendEventWithName:@"onRemotePlay" body:@{}];
+  return MPRemoteCommandHandlerStatusSuccess;
+}
+
+- (MPRemoteCommandHandlerStatus)onPause:(MPRemoteCommandEvent *)event
+{
+  [self.audioManagerModule sendEventWithName:@"onRemotePause" body:@{}];
+  return MPRemoteCommandHandlerStatusSuccess;
+}
+
+- (MPRemoteCommandHandlerStatus)onStop:(MPRemoteCommandEvent *)event
+{
+  [self.audioManagerModule sendEventWithName:@"onRemoteStop" body:@{}];
+  return MPRemoteCommandHandlerStatusSuccess;
+}
+
+- (MPRemoteCommandHandlerStatus)onTogglePlayPause:(MPRemoteCommandEvent *)event
+{
+  [self.audioManagerModule sendEventWithName:@"onRemoteTogglePlayPause" body:@{}];
+  return MPRemoteCommandHandlerStatusSuccess;
+}
+
+- (MPRemoteCommandHandlerStatus)onChangePlaybackRate:(MPChangePlaybackRateCommandEvent *)event
+{
+  [self.audioManagerModule sendEventWithName:@"onRemoteChangePlaybackRate"
+                                        body:@{@"playbackRate" : [NSNumber numberWithDouble:event.playbackRate]}];
+  return MPRemoteCommandHandlerStatusSuccess;
+}
+
+- (MPRemoteCommandHandlerStatus)onNextTrack:(MPRemoteCommandEvent *)event
+{
+  [self.audioManagerModule sendEventWithName:@"onRemoteNextTrack" body:@{}];
+  return MPRemoteCommandHandlerStatusSuccess;
+}
+
+- (MPRemoteCommandHandlerStatus)onPreviousTrack:(MPRemoteCommandEvent *)event
+{
+  [self.audioManagerModule sendEventWithName:@"onRemotePreviousTrack" body:@{}];
+  return MPRemoteCommandHandlerStatusSuccess;
+}
+
+- (MPRemoteCommandHandlerStatus)onSeekForward:(MPRemoteCommandEvent *)event
+{
+  [self.audioManagerModule sendEventWithName:@"onRemoteSeekForward" body:nil];
+  return MPRemoteCommandHandlerStatusSuccess;
+}
+
+- (MPRemoteCommandHandlerStatus)onSeekBackward:(MPRemoteCommandEvent *)event
+{
+  [self.audioManagerModule sendEventWithName:@"onRemoteSeekBackward" body:@{}];
+  return MPRemoteCommandHandlerStatusSuccess;
+}
+
+- (MPRemoteCommandHandlerStatus)onSkipForward:(MPSkipIntervalCommandEvent *)event
+{
+  [self.audioManagerModule sendEventWithName:@"onRemoteSkipForward"
+                                        body:@{@"interval" : [NSNumber numberWithDouble:event.interval]}];
+  return MPRemoteCommandHandlerStatusSuccess;
+}
+
+- (MPRemoteCommandHandlerStatus)onSkipBackward:(MPSkipIntervalCommandEvent *)event
+{
+  [self.audioManagerModule sendEventWithName:@"onRemoteSkipBackward"
+                                        body:@{@"interval" : [NSNumber numberWithDouble:event.interval]}];
+  return MPRemoteCommandHandlerStatusSuccess;
+}
+
+- (MPRemoteCommandHandlerStatus)onChangePlaybackPosition:(MPChangePlaybackPositionCommandEvent *)event
+{
+  [self.audioManagerModule sendEventWithName:@"onRemoteChangePlaybackPosition"
+                                        body:@{@"positionTime" : [NSNumber numberWithDouble:event.positionTime]}];
+  return MPRemoteCommandHandlerStatusSuccess;
+}
+
+@end

package/ios/audioapi/ios/system/NotificationManager.h

@@ -0,0 +1,16 @@
+#pragma once
+
+#import <AVFoundation/AVFoundation.h>
+#import <Foundation/Foundation.h>
+
+@interface NotificationManager : NSObject
+
+@property (nonatomic, weak) NSNotificationCenter *notificationCenter;
+
+@property (nonatomic, assign) bool isInterrupted;
+@property (nonatomic, assign) bool hadConfigurationChange;
+
++ (instancetype)sharedInstance;
+- (void)cleanup;
+
+@end

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

@@ -0,0 +1,151 @@
+#import <audioapi/ios/system/AudioEngine.h>
+#import <audioapi/ios/system/AudioSessionManager.h>
+#import <audioapi/ios/system/NotificationManager.h>
+
+@implementation NotificationManager
+
+static NotificationManager *_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 +[NotificationManager sharedInstance]" userInfo:nil];
+  return nil;
+}
+
+- (instancetype)initPrivate
+{
+  if (self = [super init]) {
+    self.notificationCenter = [NSNotificationCenter defaultCenter];
+
+    [self configureNotifications];
+  }
+  return self;
+}
+
+- (void)cleanup
+{
+  NSLog(@"[NotificationManager] cleanup");
+
+  self.notificationCenter = nil;
+}
+
+- (void)configureNotifications
+{
+  [self.notificationCenter addObserver:self
+                              selector:@selector(handleInterruption:)
+                                  name:AVAudioSessionInterruptionNotification
+                                object:nil];
+  [self.notificationCenter addObserver:self
+                              selector:@selector(handleRouteChange:)
+                                  name:AVAudioSessionRouteChangeNotification
+                                object:nil];
+  [self.notificationCenter addObserver:self
+                              selector:@selector(handleMediaServicesReset:)
+                                  name:AVAudioSessionMediaServicesWereResetNotification
+                                object:nil];
+  [self.notificationCenter addObserver:self
+                              selector:@selector(handleEngineConfigurationChange:)
+                                  name:AVAudioEngineConfigurationChangeNotification
+                                object:nil];
+}
+
+- (void)handleInterruption:(NSNotification *)notification
+{
+  NSError *error;
+  UInt8 type = [[notification.userInfo valueForKey:AVAudioSessionInterruptionTypeKey] intValue];
+  UInt8 option = [[notification.userInfo valueForKey:AVAudioSessionInterruptionOptionKey] intValue];
+  AudioEngine *audioEngine = [AudioEngine sharedInstance];
+  AudioSessionManager *audioSessionManager = [AudioSessionManager sharedInstance];
+
+  if (type == AVAudioSessionInterruptionTypeBegan) {
+    self.isInterrupted = true;
+    NSLog(@"[NotificationManager] Detected interruption, stopping the engine");
+
+    [audioEngine stopEngine];
+
+    return;
+  }
+
+  if (type != AVAudioSessionInterruptionTypeEnded) {
+    NSLog(@"[NotificationManager] Unexpected interruption state, chilling");
+    return;
+  }
+
+  self.isInterrupted = false;
+
+  if (option != AVAudioSessionInterruptionOptionShouldResume) {
+    NSLog(@"[NotificationManager] Interruption ended, but engine is not allowed to resume");
+    return;
+  }
+
+  NSLog(@"[NotificationManager] Interruption ended, resuming the engine");
+  bool success = [audioSessionManager setActive:true error:&error];
+
+  if (!success) {
+    NSLog(@"[NotificationManager] Unable to activate the audio session, reason: %@", [error debugDescription]);
+    return;
+  }
+
+  if (self.hadConfigurationChange) {
+    [audioEngine rebuildAudioEngine];
+  }
+
+  [audioEngine startEngine];
+}
+
+- (void)handleRouteChange:(NSNotification *)notification
+{
+  UInt8 reason = [[notification.userInfo valueForKey:AVAudioSessionInterruptionTypeKey] intValue];
+  NSLog(@"[NotificationManager] Route change detected, reason: %u", reason);
+  AudioEngine *audioEngine = [AudioEngine sharedInstance];
+
+  if (reason == AVAudioSessionRouteChangeReasonOldDeviceUnavailable) {
+    NSLog(@"[NotificationManager] The previously used audio device became unavailable. Audio engine paused");
+    [audioEngine stopEngine];
+  }
+}
+
+- (void)handleMediaServicesReset:(NSNotification *)notification
+{
+  NSLog(@"[NotificationManager] Media services have been reset, tearing down and rebuilding everything.");
+  AudioEngine *audioEngine = [AudioEngine sharedInstance];
+  AudioSessionManager *audioSessionManager = [AudioSessionManager sharedInstance];
+
+  [self cleanup];
+  [audioSessionManager configureAudioSession];
+  [self configureNotifications];
+  [audioEngine rebuildAudioEngine];
+}
+
+- (void)handleEngineConfigurationChange:(NSNotification *)notification
+{
+  AudioEngine *audioEngine = [AudioEngine sharedInstance];
+
+  if (![audioEngine isRunning]) {
+    NSLog(
+        @"[NotificationManager] detected engine configuration change when engine is not running, marking for rebuild");
+    self.hadConfigurationChange = true;
+    return;
+  }
+
+  if (self.isInterrupted) {
+    NSLog(@"[NotificationManager] detected engine configuration change during interruption, marking for rebuild");
+    self.hadConfigurationChange = true;
+    return;
+  }
+
+  dispatch_async(dispatch_get_main_queue(), ^{
+    [audioEngine rebuildAudioEngine];
+  });
+}
+
+@end

package/lib/module/api.js

@@ -6,7 +6,7 @@ import NativeAudioAPIModule from "./specs/NativeAudioAPIModule.js";
 
 /* eslint-disable no-var */
 
-if (global.createAudioContext == null) {
+if (global.createAudioContext == null || global.createOfflineAudioContext == null) {
   if (!NativeAudioAPIModule) {
     throw new Error(`Failed to install react-native-audio-api: The native module could not be found.`);
   }
@@ -15,6 +15,7 @@ if (global.createAudioContext == null) {
 export { default as AudioBuffer } from "./core/AudioBuffer.js";
 export { default as AudioBufferSourceNode } from "./core/AudioBufferSourceNode.js";
 export { default as AudioContext } from "./core/AudioContext.js";
+export { default as OfflineAudioContext } from "./core/OfflineAudioContext.js";
 export { default as AudioDestinationNode } from "./core/AudioDestinationNode.js";
 export { default as AudioNode } from "./core/AudioNode.js";
 export { default as AnalyserNode } from "./core/AnalyserNode.js";
@@ -25,6 +26,7 @@ export { default as BiquadFilterNode } from "./core/BiquadFilterNode.js";
 export { default as GainNode } from "./core/GainNode.js";
 export { default as OscillatorNode } from "./core/OscillatorNode.js";
 export { default as StereoPannerNode } from "./core/StereoPannerNode.js";
+export { default as AudioManager } from "./system/index.js";
 export { OscillatorType, BiquadFilterType, ChannelCountMode, ChannelInterpretation, ContextState, WindowType, PeriodicWaveConstraints } from "./types.js";
 export { IndexSizeError, InvalidAccessError, InvalidStateError, RangeError, NotSupportedError } from "./errors/index.js";
 //# sourceMappingURL=api.js.map