react-native-audio-api 0.5.7 → 0.6.0-rc.1

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

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,295 @@
+#import <MediaPlayer/MediaPlayer.h>
+#import <audioapi/ios/AudioManagerModule.h>
+#import <audioapi/ios/system/LockScreenManager.h>
+
+#define LOCK_SCREEN_INFO                                          \
+  @{                                                              \
+    @"album" : MPMediaItemPropertyAlbumTitle,                     \
+    @"artist" : MPMediaItemPropertyArtist,                        \
+    @"duration" : MPMediaItemPropertyPlaybackDuration,            \
+    @"title" : MPMediaItemPropertyTitle,                          \
+    @"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;
+    }
+  }
+
+  // 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:@{@"value" : [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:@{@"value" : [NSNumber numberWithDouble:event.interval]}];
+  return MPRemoteCommandHandlerStatusSuccess;
+}
+
+- (MPRemoteCommandHandlerStatus)onSkipBackward:(MPSkipIntervalCommandEvent *)event
+{
+  [self.audioManagerModule sendEventWithName:@"onRemoteSkipBackward"
+                                        body:@{@"value" : [NSNumber numberWithDouble:event.interval]}];
+  return MPRemoteCommandHandlerStatusSuccess;
+}
+
+- (MPRemoteCommandHandlerStatus)onChangePlaybackPosition:(MPChangePlaybackPositionCommandEvent *)event
+{
+  [self.audioManagerModule sendEventWithName:@"onRemoteChangePlaybackPosition"
+                                        body:@{@"value" : [NSNumber numberWithDouble:event.positionTime]}];
+  return MPRemoteCommandHandlerStatusSuccess;
+}
+
+@end

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

@@ -0,0 +1,22 @@
+#pragma once
+
+#import <AVFoundation/AVFoundation.h>
+#import <Foundation/Foundation.h>
+
+@class AudioManagerModule;
+
+@interface NotificationManager : NSObject
+
+@property (nonatomic, weak) AudioManagerModule *audioManagerModule;
+@property (nonatomic, weak) NSNotificationCenter *notificationCenter;
+
+@property (nonatomic, assign) bool isInterrupted;
+@property (nonatomic, assign) bool hadConfigurationChange;
+@property (nonatomic, assign) BOOL audioInterruptionsObserved;
+
++ (instancetype)sharedInstanceWithAudioManagerModule:(AudioManagerModule *)audioManagerModule;
+- (void)cleanup;
+
+- (void)observeAudioInterruptions:(BOOL)enabled;
+
+@end