react-native-audio-api 0.6.0-rc.5 → 0.6.0

package/ios/audioapi/ios/AudioAPIModule.mm

@@ -1,12 +1,16 @@
-#import "AudioAPIModule.h"
-
 #import <React/RCTBridge+Private.h>
-
+#import <audioapi/ios/AudioAPIModule.h>
 #ifdef RCT_NEW_ARCH_ENABLED
 #import <React/RCTCallInvoker.h>
 #endif // RCT_NEW_ARCH_ENABLED
 
-#include <audioapi/AudioAPIModuleInstaller.h>
+#import <audioapi/AudioAPIModuleInstaller.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>
+
+#import <audioapi/events/AudioEventHandlerRegistry.h>
 
 using namespace audioapi;
 using namespace facebook::react;
@@ -24,7 +28,9 @@ using namespace facebook::react;
 @end
 #endif // RCT_NEW_ARCH_ENABLED
 
-@implementation AudioAPIModule
+@implementation AudioAPIModule {
+  std::shared_ptr<AudioEventHandlerRegistry> _eventHandler;
+}
 
 #if defined(RCT_NEW_ARCH_ENABLED)
 @synthesize callInvoker = _callInvoker;
@@ -32,8 +38,25 @@ using namespace facebook::react;
 
 RCT_EXPORT_MODULE(AudioAPIModule);
 
+- (void)invalidate
+{
+  [self.audioEngine cleanup];
+  [self.notificationManager cleanup];
+  [self.audioSessionManager cleanup];
+  [self.lockScreenManager cleanup];
+
+  _eventHandler = nullptr;
+
+  [super invalidate];
+}
+
 RCT_EXPORT_BLOCKING_SYNCHRONOUS_METHOD(install)
 {
+  self.audioSessionManager = [[AudioSessionManager alloc] init];
+  self.audioEngine = [[AudioEngine alloc] initWithAudioSessionManager:self.audioSessionManager];
+  self.lockScreenManager = [[LockScreenManager alloc] initWithAudioAPIModule:self];
+  self.notificationManager = [[NotificationManager alloc] initWithAudioAPIModule:self];
+
   auto jsiRuntime = reinterpret_cast<facebook::jsi::Runtime *>(self.bridge.runtime);
 
 #if defined(RCT_NEW_ARCH_ENABLED)
@@ -44,12 +67,68 @@ RCT_EXPORT_BLOCKING_SYNCHRONOUS_METHOD(install)
 
   assert(jsiRuntime != nullptr);
 
-  audioapi::AudioAPIModuleInstaller::injectJSIBindings(jsiRuntime, jsCallInvoker);
+  _eventHandler = std::make_shared<AudioEventHandlerRegistry>(jsiRuntime, jsCallInvoker);
+
+  self.audioSessionManager = [[AudioSessionManager alloc] init];
+  self.audioEngine = [[AudioEngine alloc] initWithAudioSessionManager:self.audioSessionManager];
+  self.lockScreenManager = [[LockScreenManager alloc] initWithAudioAPIModule:self];
+  self.notificationManager = [[NotificationManager alloc] initWithAudioAPIModule:self];
+
+  audioapi::AudioAPIModuleInstaller::injectJSIBindings(jsiRuntime, jsCallInvoker, _eventHandler);
 
   NSLog(@"Successfully installed JSI bindings for react-native-audio-api!");
   return @true;
 }
 
+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)
+{
+  [self.audioSessionManager setAudioSessionOptions:category mode:mode options:options];
+}
+
+RCT_EXPORT_BLOCKING_SYNCHRONOUS_METHOD(getDevicePreferredSampleRate)
+{
+  return [self.audioSessionManager getDevicePreferredSampleRate];
+}
+
+RCT_EXPORT_METHOD(observeAudioInterruptions : (BOOL)enabled)
+{
+  [self.notificationManager observeAudioInterruptions:enabled];
+}
+
+RCT_EXPORT_METHOD(observeVolumeChanges : (BOOL)enabled)
+{
+  [self.notificationManager observeVolumeChanges:(BOOL)enabled];
+}
+
+RCT_EXPORT_METHOD(requestRecordingPermissions : (nonnull RCTPromiseResolveBlock)
+                      resolve reject : (nonnull RCTPromiseRejectBlock)reject)
+{
+  NSString *res = [self.audioSessionManager requestRecordingPermissions];
+  resolve(res);
+}
+
+RCT_EXPORT_METHOD(checkRecordingPermissions : (nonnull RCTPromiseResolveBlock)
+                      resolve reject : (nonnull RCTPromiseRejectBlock)reject)
+{
+  NSString *res = [self.audioSessionManager checkRecordingPermissions];
+  resolve(res);
+}
+
 #ifdef RCT_NEW_ARCH_ENABLED
 - (std::shared_ptr<facebook::react::TurboModule>)getTurboModule:
     (const facebook::react::ObjCTurboModule::InitParams &)params
@@ -58,4 +137,34 @@ RCT_EXPORT_BLOCKING_SYNCHRONOUS_METHOD(install)
 }
 #endif // RCT_NEW_ARCH_ENABLED
 
+- (void)invokeHandlerWithEventName:(NSString *)eventName eventBody:(NSDictionary *)eventBody
+{
+  auto name = [eventName UTF8String];
+
+  std::unordered_map<std::string, EventValue> body = {};
+
+  for (NSString *key in eventBody) {
+    id value = eventBody[key];
+    std::string stdKey = [key UTF8String];
+
+    if ([value isKindOfClass:[NSString class]]) {
+      std::string stdValue = [value UTF8String];
+      body[stdKey] = EventValue(stdValue);
+    } else if ([value isKindOfClass:[NSNumber class]]) {
+      const char *type = [value objCType];
+      if (strcmp(type, @encode(int)) == 0) {
+        body[stdKey] = EventValue([value intValue]);
+      } else if (strcmp(type, @encode(double)) == 0) {
+        body[stdKey] = EventValue([value doubleValue]);
+      } else if (strcmp(type, @encode(float)) == 0) {
+        body[stdKey] = EventValue([value floatValue]);
+      } else if (strcmp(type, @encode(BOOL)) == 0) {
+        body[stdKey] = EventValue([value boolValue]);
+      }
+    }
+  }
+
+  _eventHandler->invokeHandlerWithEventBody(name, body);
+}
+
 @end

package/ios/audioapi/ios/core/IOSAudioRecorder.h

@@ -7,7 +7,6 @@ typedef struct objc_object NativeAudioRecorder;
 #endif // __OBJC__
 
 #include <audioapi/core/inputs/AudioRecorder.h>
-#include <functional>
 
 namespace audioapi {
 
@@ -19,10 +18,8 @@ class IOSAudioRecorder : public AudioRecorder {
   IOSAudioRecorder(
       float sampleRate,
       int bufferLength,
-      const std::function<void(void)> &onError,
-      const std::function<void(void)> &onStatusChange,
-      const std::function<void(std::shared_ptr<AudioBus>, int, double)>
-          &onAudioReady);
+      const std::shared_ptr<AudioEventHandlerRegistry>
+          &audioEventHandlerRegistry);
 
   ~IOSAudioRecorder() override;
 
@@ -31,11 +28,6 @@ class IOSAudioRecorder : public AudioRecorder {
 
  private:
   NativeAudioRecorder *audioRecorder_;
-  std::atomic<bool> isRunning_;
-
-  std::shared_ptr<CircularAudioArray> circularBuffer_;
-
-  void sendRemainingData();
 };
 
 } // namespace audioapi

package/ios/audioapi/ios/core/IOSAudioRecorder.mm

@@ -2,23 +2,21 @@
 
 #include <audioapi/core/Constants.h>
 #include <audioapi/dsp/VectorMath.h>
+#include <audioapi/events/AudioEventHandlerRegistry.h>
 #include <audioapi/ios/core/IOSAudioRecorder.h>
 #include <audioapi/utils/AudioArray.h>
 #include <audioapi/utils/AudioBus.h>
 #include <audioapi/utils/CircularAudioArray.h>
+#include <unordered_map>
 
 namespace audioapi {
 
 IOSAudioRecorder::IOSAudioRecorder(
     float sampleRate,
     int bufferLength,
-    const std::function<void(void)> &onError,
-    const std::function<void(void)> &onStatusChange,
-    const std::function<void(std::shared_ptr<AudioBus>, int, double)> &onAudioReady)
-    : AudioRecorder(sampleRate, bufferLength, onError, onStatusChange, onAudioReady)
+    const std::shared_ptr<AudioEventHandlerRegistry> &audioEventHandlerRegistry)
+    : AudioRecorder(sampleRate, bufferLength, audioEventHandlerRegistry)
 {
-  circularBuffer_ = std::make_shared<CircularAudioArray>(std::max(2 * bufferLength, 2048));
-
   AudioReceiverBlock audioReceiverBlock = ^(const AudioBufferList *inputBuffer, int numFrames, AVAudioTime *when) {
     if (isRunning_.load()) {
       auto *inputChannel = static_cast<float *>(inputBuffer->mBuffers[0].mData);
@@ -30,7 +28,8 @@ IOSAudioRecorder::IOSAudioRecorder(
       auto *outputChannel = bus->getChannel(0)->getData();
 
       circularBuffer_->pop_front(outputChannel, bufferLength_);
-      onAudioReady_(bus, bufferLength_, [when sampleTime] / [when sampleRate]);
+
+      invokeOnAudioReadyCallback(bus, bufferLength_, [when sampleTime] / [when sampleRate]);
     }
   };
 
@@ -69,14 +68,4 @@ void IOSAudioRecorder::stop()
   sendRemainingData();
 }
 
-void IOSAudioRecorder::sendRemainingData()
-{
-  auto bus = std::make_shared<AudioBus>(circularBuffer_->getNumberOfAvailableFrames(), 1, sampleRate_);
-  auto *outputChannel = bus->getChannel(0)->getData();
-  auto availableFrames = circularBuffer_->getNumberOfAvailableFrames();
-
-  circularBuffer_->pop_front(outputChannel, circularBuffer_->getNumberOfAvailableFrames());
-  onAudioReady_(bus, availableFrames, 0);
-}
-
 } // namespace audioapi

package/ios/audioapi/ios/core/NativeAudioPlayer.m

@@ -37,6 +37,7 @@
   NSLog(@"[AudioPlayer] start");
 
   AudioEngine *audioEngine = [AudioEngine sharedInstance];
+  assert(audioEngine != nil);
   self.sourceNodeId = [audioEngine attachSourceNode:self.sourceNode format:self.format];
 }
 
@@ -45,6 +46,7 @@
   NSLog(@"[AudioPlayer] stop");
 
   AudioEngine *audioEngine = [AudioEngine sharedInstance];
+  assert(audioEngine != nil);
   [audioEngine detachSourceNodeWithId:self.sourceNodeId];
   self.sourceNodeId = nil;
 }

package/ios/audioapi/ios/core/NativeAudioRecorder.m

@@ -14,7 +14,7 @@
 
     self.receiverBlock = [receiverBlock copy];
 
-    float devicePrefferedSampleRate = [[[AudioSessionManager sharedInstance] getDevicePreferredSampleRate] floatValue];
+    float devicePrefferedSampleRate = [[AVAudioSession sharedInstance] sampleRate];
 
     self.inputFormat = [[AVAudioFormat alloc] initWithCommonFormat:AVAudioPCMFormatFloat32
                                                         sampleRate:devicePrefferedSampleRate
@@ -91,12 +91,16 @@
 
 - (void)start
 {
-  [[AudioEngine sharedInstance] attachInputNode:self.sinkNode];
+  AudioEngine *audioEngine = [AudioEngine sharedInstance];
+  assert(audioEngine != nil);
+  [audioEngine attachInputNode:self.sinkNode];
 }
 
 - (void)stop
 {
-  [[AudioEngine sharedInstance] detachInputNode];
+  AudioEngine *audioEngine = [AudioEngine sharedInstance];
+  assert(audioEngine != nil);
+  [audioEngine detachInputNode];
 }
 
 - (void)cleanup

package/ios/audioapi/ios/events/IOSAudioEventHandlerRegistry.h

@@ -0,0 +1,7 @@
+#pragma once
+
+#import <Foundation/Foundation.h>
+
+@interface IOSAudioEventHandlerRegistry : NSObject
+
+-

package/ios/audioapi/ios/events/IOSAudioEventHandlerRegistry.mm

@@ -0,0 +1,12 @@
+// #import <audioapi/ios/events/IOSAudioEventHandlerRegistry.h>
+//
+// #include <memory>
+// #include
+//
+//@implementation IOSAudioEventHandlerRegistry {
+//   std::shared_ptr<AudioEventHandlerRegistry> _eventHandler;
+//
+//
+// }
+//
+//@end

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

@@ -3,12 +3,17 @@
 #import <AVFoundation/AVFoundation.h>
 #import <Foundation/Foundation.h>
 
+@class AudioSessionManager;
+
 @interface AudioEngine : NSObject
 
 @property (nonatomic, strong) AVAudioEngine *audioEngine;
 @property (nonatomic, strong) NSMutableDictionary *sourceNodes;
 @property (nonatomic, strong) NSMutableDictionary *sourceFormats;
 @property (nonatomic, strong) AVAudioSinkNode *inputNode;
+@property (nonatomic, weak) AudioSessionManager *sessionManager;
+
+- (instancetype)initWithAudioSessionManager:(AudioSessionManager *)sessionManager;
 
 + (instancetype)sharedInstance;
 - (void)cleanup;

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

@@ -7,22 +7,10 @@ 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
+- (instancetype)initWithAudioSessionManager:(AudioSessionManager *)sessionManager
 {
   if (self = [super init]) {
     self.audioEngine = [[AVAudioEngine alloc] init];
@@ -31,9 +19,12 @@ static AudioEngine *_sharedInstance = nil;
     self.sourceNodes = [[NSMutableDictionary alloc] init];
     self.sourceFormats = [[NSMutableDictionary alloc] init];
 
-    [[AudioSessionManager sharedInstance] setActive:true];
+    self.sessionManager = sessionManager;
+    [self.sessionManager setActive:true];
   }
 
+  _sharedInstance = self;
+
   return self;
 }
 
@@ -49,7 +40,8 @@ static AudioEngine *_sharedInstance = nil;
   self.sourceFormats = nil;
   self.inputNode = nil;
 
-  [[AudioSessionManager sharedInstance] setActive:false];
+  [self.sessionManager setActive:false];
+  self.sessionManager = nil;
 }
 
 - (bool)rebuildAudioEngine

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

@@ -13,7 +13,7 @@
 @property (nonatomic, assign) AVAudioSessionCategory sessionCategory;
 @property (nonatomic, assign) AVAudioSessionCategoryOptions sessionOptions;
 
-+ (instancetype)sharedInstance;
+- (instancetype)init;
 - (void)cleanup;
 - (bool)configureAudioSession;
 

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

@@ -2,24 +2,7 @@
 
 @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];
@@ -194,7 +177,8 @@ static AudioSessionManager *_sharedInstance = nil;
 
 - (NSString *)requestRecordingPermissions
 {
-  [self.audioSession requestRecordPermission:^(BOOL granted) {}];
+  [self.audioSession requestRecordPermission:^(BOOL granted){
+  }];
   return [self checkRecordingPermissions];
 }
 

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

@@ -4,16 +4,16 @@
 #import <Foundation/Foundation.h>
 #import <MediaPlayer/MediaPlayer.h>
 
-@class AudioManagerModule;
+@class AudioAPIModule;
 
 @interface LockScreenManager : NSObject
 
-@property (nonatomic, weak) AudioManagerModule *audioManagerModule;
+@property (nonatomic, weak) AudioAPIModule *audioAPIModule;
 
 @property (nonatomic, weak) MPNowPlayingInfoCenter *playingInfoCenter;
 @property (nonatomic, copy) NSString *artworkUrl;
 
-+ (instancetype)sharedInstanceWithAudioManagerModule:(AudioManagerModule *)audioManagerModule;
+- (instancetype)initWithAudioAPIModule:(AudioAPIModule *)audioAPIModule;
 - (void)cleanup;
 
 - (void)setLockScreenInfo:(NSDictionary *)info;

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

@@ -1,5 +1,5 @@
 #import <MediaPlayer/MediaPlayer.h>
-#import <audioapi/ios/AudioManagerModule.h>
+#import <audioapi/ios/AudioAPIModule.h>
 #import <audioapi/ios/system/LockScreenManager.h>
 
 #define LOCK_SCREEN_INFO                                          \
@@ -14,30 +14,14 @@
 
 @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
+- (instancetype)initWithAudioAPIModule:(AudioAPIModule *)audioAPIModule
 {
   if (self = [super init]) {
-    self.audioManagerModule = audioManagerModule;
+    self.audioAPIModule = audioAPIModule;
     self.playingInfoCenter = [MPNowPlayingInfoCenter defaultCenter];
     [[UIApplication sharedApplication] beginReceivingRemoteControlEvents];
   }
+
   return self;
 }
 
@@ -176,31 +160,31 @@ static LockScreenManager *_sharedInstance = nil;
 {
   MPRemoteCommandCenter *remoteCenter = [MPRemoteCommandCenter sharedCommandCenter];
 
-  if ([name isEqual:@"play"]) {
+  if ([name isEqual:@"remotePlay"]) {
     [self enableCommand:remoteCenter.playCommand withSelector:@selector(onPlay:) enabled:enabled];
-  } else if ([name isEqual:@"pause"]) {
+  } else if ([name isEqual:@"remotePause"]) {
     [self enableCommand:remoteCenter.pauseCommand withSelector:@selector(onPause:) enabled:enabled];
-  } else if ([name isEqual:@"stop"]) {
+  } else if ([name isEqual:@"remoteStop"]) {
     [self enableCommand:remoteCenter.stopCommand withSelector:@selector(onStop:) enabled:enabled];
-  } else if ([name isEqual:@"togglePlayPause"]) {
+  } else if ([name isEqual:@"remoteTogglePlayPause"]) {
     [self enableCommand:remoteCenter.togglePlayPauseCommand withSelector:@selector(onTogglePlayPause:) enabled:enabled];
-  } else if ([name isEqual:@"changePlaybackRate"]) {
+  } else if ([name isEqual:@"remoteChangePlaybackRate"]) {
     [self enableCommand:remoteCenter.changePlaybackRateCommand
            withSelector:@selector(onChangePlaybackRate:)
                 enabled:enabled];
-  } else if ([name isEqual:@"nextTrack"]) {
+  } else if ([name isEqual:@"remoteNextTrack"]) {
     [self enableCommand:remoteCenter.nextTrackCommand withSelector:@selector(onNextTrack:) enabled:enabled];
-  } else if ([name isEqual:@"previousTrack"]) {
+  } else if ([name isEqual:@"remotePreviousTrack"]) {
     [self enableCommand:remoteCenter.previousTrackCommand withSelector:@selector(onPreviousTrack:) enabled:enabled];
-  } else if ([name isEqual:@"skipForward"]) {
+  } else if ([name isEqual:@"remoteSkipForward"]) {
     [self enableCommand:remoteCenter.skipForwardCommand withSelector:@selector(onSkipForward:) enabled:enabled];
-  } else if ([name isEqual:@"skipBackward"]) {
+  } else if ([name isEqual:@"remoteSkipBackward"]) {
     [self enableCommand:remoteCenter.skipBackwardCommand withSelector:@selector(onSkipBackward:) enabled:enabled];
-  } else if ([name isEqual:@"seekForward"]) {
+  } else if ([name isEqual:@"remoteSeekForward"]) {
     [self enableCommand:remoteCenter.seekForwardCommand withSelector:@selector(onSeekForward:) enabled:enabled];
-  } else if ([name isEqual:@"seekBackward"]) {
+  } else if ([name isEqual:@"remoteSeekBackward"]) {
     [self enableCommand:remoteCenter.seekBackwardCommand withSelector:@selector(onSeekBackward:) enabled:enabled];
-  } else if ([name isEqual:@"changePlaybackPosition"]) {
+  } else if ([name isEqual:@"remoteChangePlaybackPosition"]) {
     [self enableCommand:remoteCenter.changePlaybackPositionCommand
            withSelector:@selector(onChangePlaybackPosition:)
                 enabled:enabled];
@@ -218,77 +202,81 @@ static LockScreenManager *_sharedInstance = nil;
 
 - (MPRemoteCommandHandlerStatus)onPlay:(MPRemoteCommandEvent *)event
 {
-  [self.audioManagerModule sendEventWithName:@"onRemotePlay" body:@{}];
+  [self.audioAPIModule invokeHandlerWithEventName:@"remotePlay" eventBody:nil];
   return MPRemoteCommandHandlerStatusSuccess;
 }
 
 - (MPRemoteCommandHandlerStatus)onPause:(MPRemoteCommandEvent *)event
 {
-  [self.audioManagerModule sendEventWithName:@"onRemotePause" body:@{}];
+  [self.audioAPIModule invokeHandlerWithEventName:@"remotePause" eventBody:nil];
   return MPRemoteCommandHandlerStatusSuccess;
 }
 
 - (MPRemoteCommandHandlerStatus)onStop:(MPRemoteCommandEvent *)event
 {
-  [self.audioManagerModule sendEventWithName:@"onRemoteStop" body:@{}];
+  [self.audioAPIModule invokeHandlerWithEventName:@"remoteStop" eventBody:nil];
   return MPRemoteCommandHandlerStatusSuccess;
 }
 
 - (MPRemoteCommandHandlerStatus)onTogglePlayPause:(MPRemoteCommandEvent *)event
 {
-  [self.audioManagerModule sendEventWithName:@"onRemoteTogglePlayPause" body:@{}];
+  [self.audioAPIModule invokeHandlerWithEventName:@"remoteTogglePlayPause" eventBody:nil];
   return MPRemoteCommandHandlerStatusSuccess;
 }
 
 - (MPRemoteCommandHandlerStatus)onChangePlaybackRate:(MPChangePlaybackRateCommandEvent *)event
 {
-  [self.audioManagerModule sendEventWithName:@"onRemoteChangePlaybackRate"
-                                        body:@{@"value" : [NSNumber numberWithDouble:event.playbackRate]}];
+  NSDictionary *body = @{@"value" : [NSNumber numberWithDouble:event.playbackRate]};
+
+  [self.audioAPIModule invokeHandlerWithEventName:@"remoteChangePlaybackRate" eventBody:body];
   return MPRemoteCommandHandlerStatusSuccess;
 }
 
 - (MPRemoteCommandHandlerStatus)onNextTrack:(MPRemoteCommandEvent *)event
 {
-  [self.audioManagerModule sendEventWithName:@"onRemoteNextTrack" body:@{}];
+  [self.audioAPIModule invokeHandlerWithEventName:@"remoteNextTrack" eventBody:nil];
   return MPRemoteCommandHandlerStatusSuccess;
 }
 
 - (MPRemoteCommandHandlerStatus)onPreviousTrack:(MPRemoteCommandEvent *)event
 {
-  [self.audioManagerModule sendEventWithName:@"onRemotePreviousTrack" body:@{}];
+  [self.audioAPIModule invokeHandlerWithEventName:@"remotePreviousTrack" eventBody:nil];
   return MPRemoteCommandHandlerStatusSuccess;
 }
 
 - (MPRemoteCommandHandlerStatus)onSeekForward:(MPRemoteCommandEvent *)event
 {
-  [self.audioManagerModule sendEventWithName:@"onRemoteSeekForward" body:nil];
+  [self.audioAPIModule invokeHandlerWithEventName:@"remoteSeekForward" eventBody:nil];
   return MPRemoteCommandHandlerStatusSuccess;
 }
 
 - (MPRemoteCommandHandlerStatus)onSeekBackward:(MPRemoteCommandEvent *)event
 {
-  [self.audioManagerModule sendEventWithName:@"onRemoteSeekBackward" body:@{}];
+  [self.audioAPIModule invokeHandlerWithEventName:@"remoteSeekBackward" eventBody:nil];
   return MPRemoteCommandHandlerStatusSuccess;
 }
 
 - (MPRemoteCommandHandlerStatus)onSkipForward:(MPSkipIntervalCommandEvent *)event
 {
-  [self.audioManagerModule sendEventWithName:@"onRemoteSkipForward"
-                                        body:@{@"value" : [NSNumber numberWithDouble:event.interval]}];
+  NSDictionary *body = @{@"value" : [NSNumber numberWithDouble:event.interval]};
+
+  [self.audioAPIModule invokeHandlerWithEventName:@"remoteSkipForward" eventBody:body];
   return MPRemoteCommandHandlerStatusSuccess;
 }
 
 - (MPRemoteCommandHandlerStatus)onSkipBackward:(MPSkipIntervalCommandEvent *)event
 {
-  [self.audioManagerModule sendEventWithName:@"onRemoteSkipBackward"
-                                        body:@{@"value" : [NSNumber numberWithDouble:event.interval]}];
+  NSDictionary *body = @{@"value" : [NSNumber numberWithDouble:event.interval]};
+
+  [self.audioAPIModule invokeHandlerWithEventName:@"remoteSkipBackward" eventBody:body];
   return MPRemoteCommandHandlerStatusSuccess;
 }
 
 - (MPRemoteCommandHandlerStatus)onChangePlaybackPosition:(MPChangePlaybackPositionCommandEvent *)event
 {
-  [self.audioManagerModule sendEventWithName:@"onRemoteChangePlaybackPosition"
-                                        body:@{@"value" : [NSNumber numberWithDouble:event.positionTime]}];
+  NSDictionary *body = @{@"value" : [NSNumber numberWithDouble:event.positionTime]};
+
+  [self.audioAPIModule invokeHandlerWithEventName:@"remoteChangePlaybackPosition" eventBody:body];
   return MPRemoteCommandHandlerStatusSuccess;
 }
 

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

@@ -3,11 +3,11 @@
 #import <AVFoundation/AVFoundation.h>
 #import <Foundation/Foundation.h>
 
-@class AudioManagerModule;
+@class AudioAPIModule;
 
 @interface NotificationManager : NSObject
 
-@property (nonatomic, weak) AudioManagerModule *audioManagerModule;
+@property (nonatomic, weak) AudioAPIModule *audioAPIModule;
 @property (nonatomic, weak) NSNotificationCenter *notificationCenter;
 
 @property (nonatomic, assign) bool isInterrupted;
@@ -15,7 +15,7 @@
 @property (nonatomic, assign) bool audioInterruptionsObserved;
 @property (nonatomic, assign) bool volumeChangesObserved;
 
-+ (instancetype)sharedInstanceWithAudioManagerModule:(AudioManagerModule *)audioManagerModule;
+- (instancetype)initWithAudioAPIModule:(AudioAPIModule *)audioAPIModule;
 - (void)cleanup;
 
 - (void)observeAudioInterruptions:(BOOL)enabled;