react-native-audio-api 0.12.0-nightly-6a44b58-20260126 → 0.12.0-nightly-1a3c43b-20260128

package/common/cpp/audioapi/events/AudioEventHandlerRegistry.cpp

@@ -9,25 +9,14 @@ namespace audioapi {
 AudioEventHandlerRegistry::AudioEventHandlerRegistry(
     jsi::Runtime *runtime,
     const std::shared_ptr<react::CallInvoker> &callInvoker)
-    : IAudioEventHandlerRegistry() {
-  runtime_ = runtime;
-  callInvoker_ = callInvoker;
-
-  for (const auto &eventName : SYSTEM_EVENT_NAMES) {
-    eventHandlers_[std::string(eventName)] = {};
-  }
-
-  for (const auto &eventName : AUDIO_API_EVENT_NAMES) {
-    eventHandlers_[std::string(eventName)] = {};
-  }
-}
+    : IAudioEventHandlerRegistry(), callInvoker_(callInvoker), runtime_(runtime) {}
 
 AudioEventHandlerRegistry::~AudioEventHandlerRegistry() {
   eventHandlers_.clear();
 }
 
 uint64_t AudioEventHandlerRegistry::registerHandler(
-    const std::string &eventName,
+    AudioEvent eventName,
     const std::shared_ptr<jsi::Function> &handler) {
   uint64_t listenerId = listenerIdCounter_++;
 
@@ -45,7 +34,7 @@ uint64_t AudioEventHandlerRegistry::registerHandler(
 }
 
 void AudioEventHandlerRegistry::unregisterHandler(
-    const std::string &eventName,
+    AudioEvent eventName,
     uint64_t listenerId) {
   if (callInvoker_ == nullptr || runtime_ == nullptr) {
     // If callInvoker or runtime is not valid, we cannot unregister the handler
@@ -69,7 +58,7 @@ void AudioEventHandlerRegistry::unregisterHandler(
 }
 
 void AudioEventHandlerRegistry::invokeHandlerWithEventBody(
-    const std::string &eventName,
+    AudioEvent eventName,
     const std::unordered_map<std::string, EventValue> &body) {
   // callInvoker_ and runtime_ must be valid to invoke handlers
   // this might happen when react-native is reloaded or the app is closed
@@ -100,7 +89,7 @@ void AudioEventHandlerRegistry::invokeHandlerWithEventBody(
         jsi::Object eventObject(*runtime_);
         // handle special logic for microphone, because we pass audio buffer
         // which has significant size
-        if (eventName.compare("audioReady") == 0) {
+        if (eventName == AudioEvent::AUDIO_READY) {
           auto bufferIt = body.find("buffer");
           if (bufferIt != body.end()) {
             auto bufferHostObject = std::static_pointer_cast<AudioBufferHostObject>(
@@ -117,14 +106,14 @@ void AudioEventHandlerRegistry::invokeHandlerWithEventBody(
         throw;
       } catch (...) {
         printf(
-            "Unknown exception occurred while invoking handler for event: %s\n", eventName.c_str());
+            "Unknown exception occurred while invoking handler for event: %d\n", eventName);
       }
     }
   });
 }
 
 void AudioEventHandlerRegistry::invokeHandlerWithEventBody(
-    const std::string &eventName,
+    AudioEvent eventName,
     uint64_t listenerId,
     const std::unordered_map<std::string, EventValue> &body) {
   // callInvoker_ and runtime_ must be valid to invoke handlers
@@ -164,7 +153,7 @@ void AudioEventHandlerRegistry::invokeHandlerWithEventBody(
       jsi::Object eventObject(*runtime_);
       // handle special logic for microphone, because we pass audio buffer which
       // has significant size
-      if (eventName.compare("audioReady") == 0) {
+      if (eventName == AudioEvent::AUDIO_READY) {
         auto bufferIt = body.find("buffer");
         if (bufferIt != body.end()) {
           auto bufferHostObject = std::static_pointer_cast<AudioBufferHostObject>(
@@ -181,7 +170,7 @@ void AudioEventHandlerRegistry::invokeHandlerWithEventBody(
       throw;
     } catch (...) {
       printf(
-          "Unknown exception occurred while invoking handler for event: %s\n", eventName.c_str());
+          "Unknown exception occurred while invoking handler for event: %d\n", eventName);
     }
   });
 }

package/common/cpp/audioapi/events/AudioEventHandlerRegistry.h

@@ -1,6 +1,7 @@
 #pragma once
 
 #include <ReactCommon/CallInvoker.h>
+#include <audioapi/events/AudioEvent.h>
 #include <audioapi/events/IAudioEventHandlerRegistry.h>
 #include <jsi/jsi.h>
 #include <array>
@@ -23,16 +24,15 @@ class AudioEventHandlerRegistry : public IAudioEventHandlerRegistry {
       const std::shared_ptr<react::CallInvoker> &callInvoker);
   ~AudioEventHandlerRegistry() override;
 
-  uint64_t registerHandler(
-      const std::string &eventName,
-      const std::shared_ptr<jsi::Function> &handler) override;
-  void unregisterHandler(const std::string &eventName, uint64_t listenerId) override;
+  uint64_t registerHandler(AudioEvent eventName, const std::shared_ptr<jsi::Function> &handler)
+      override;
+  void unregisterHandler(AudioEvent eventName, uint64_t listenerId) override;
 
   void invokeHandlerWithEventBody(
-      const std::string &eventName,
+      AudioEvent eventName,
       const std::unordered_map<std::string, EventValue> &body) override;
   void invokeHandlerWithEventBody(
-      const std::string &eventName,
+      AudioEvent eventName,
       uint64_t listenerId,
       const std::unordered_map<std::string, EventValue> &body) override;
 
@@ -41,36 +41,9 @@ class AudioEventHandlerRegistry : public IAudioEventHandlerRegistry {
 
   std::shared_ptr<react::CallInvoker> callInvoker_;
   jsi::Runtime *runtime_;
-  std::unordered_map<std::string, std::unordered_map<uint64_t, std::shared_ptr<jsi::Function>>>
+  std::unordered_map<AudioEvent, std::unordered_map<uint64_t, std::shared_ptr<jsi::Function>>>
       eventHandlers_;
 
-  static constexpr std::array<std::string_view, 15> SYSTEM_EVENT_NAMES = {
-      "remotePlay",
-      "remotePause",
-      "remoteStop",
-      "remoteTogglePlayPause",
-      "remoteChangePlaybackRate",
-      "remoteNextTrack",
-      "remotePreviousTrack",
-      "remoteSkipForward",
-      "remoteSkipBackward",
-      "remoteSeekForward",
-      "remoteSeekBackward",
-      "remoteChangePlaybackPosition",
-      "routeChange",
-      "interruption",
-      "volumeChange",
-  };
-
-  static constexpr std::array<std::string_view, 7> AUDIO_API_EVENT_NAMES = {
-      "ended",
-      "loopEnded",
-      "audioReady",
-      "positionChanged",
-      "bufferEnded",
-      "audioError",
-      "systemStateChanged"};
-
   jsi::Object createEventObject(const std::unordered_map<std::string, EventValue> &body);
   jsi::Object createEventObject(
       const std::unordered_map<std::string, EventValue> &body,

package/common/cpp/audioapi/events/IAudioEventHandlerRegistry.h

@@ -1,6 +1,7 @@
 #pragma once
 
 #include <ReactCommon/CallInvoker.h>
+#include <audioapi/events/AudioEvent.h>
 #include <jsi/jsi.h>
 #include <memory>
 #include <string>
@@ -17,15 +18,15 @@ class IAudioEventHandlerRegistry {
   virtual ~IAudioEventHandlerRegistry() = default;
 
   virtual uint64_t registerHandler(
-      const std::string &eventName,
+      AudioEvent eventName,
       const std::shared_ptr<facebook::jsi::Function> &handler) = 0;
-  virtual void unregisterHandler(const std::string &eventName, uint64_t listenerId) = 0;
+  virtual void unregisterHandler(AudioEvent eventName, uint64_t listenerId) = 0;
 
   virtual void invokeHandlerWithEventBody(
-      const std::string &eventName,
+      AudioEvent eventName,
       const std::unordered_map<std::string, EventValue> &body) = 0;
   virtual void invokeHandlerWithEventBody(
-      const std::string &eventName,
+      AudioEvent eventName,
       uint64_t listenerId,
       const std::unordered_map<std::string, EventValue> &body) = 0;
 };

package/common/cpp/audioapi/jsi/JsiUtils.cpp

@@ -0,0 +1,21 @@
+#include <audioapi/jsi/JsiUtils.h>
+#include <string>
+
+namespace audioapi::jsiutils {
+
+using namespace facebook;
+
+std::string argToString(
+    jsi::Runtime &runtime,
+    const jsi::Value *args,
+    size_t count,
+    size_t index,
+    const std::string &defaultValue) {
+  if (index < count && args[index].isString()) {
+    return args[index].asString(runtime).utf8(runtime);
+  }
+
+  return defaultValue;
+}
+
+} // namespace audioapi::jsiutils

package/common/cpp/audioapi/jsi/JsiUtils.h

@@ -0,0 +1,17 @@
+#pragma once
+
+#include <jsi/jsi.h>
+#include <string>
+
+namespace audioapi::jsiutils {
+
+using namespace facebook;
+
+std::string argToString(
+    jsi::Runtime &runtime,
+    const jsi::Value *args,
+    size_t count,
+    size_t index,
+    const std::string &defaultValue = "");
+
+} // namespace audioapi::jsiutils

package/{android/src/main/cpp/audioapi/android/core → common/cpp/audioapi}/utils/MiniaudioImplementation.cpp

@@ -1,8 +1,7 @@
-/// Miniaudio implementation for Android platform.
+/// Miniaudio implementation
 /// this define tells the miniaudio to also include the definitions and not only declarations.
 /// Which should be done only once in the whole project.
 /// This make its safe to include the header file in multiple places, without causing multiple definition errors.
-/// TODO: Consider moving this file to common scope to re-use the miniaudio also for iOS platform.
 #define MINIAUDIO_IMPLEMENTATION
 #define MA_DEBUG_OUTPUT
 #include <audioapi/libs/miniaudio/miniaudio.h>

package/common/cpp/test/src/MockAudioEventHandlerRegistry.h

@@ -1,5 +1,6 @@
 #pragma once
 
+#include <audioapi/events/AudioEvent.h>
 #include <audioapi/events/IAudioEventHandlerRegistry.h>
 #include <gmock/gmock.h>
 #include <memory>
@@ -15,18 +16,12 @@ class MockAudioEventHandlerRegistry : public IAudioEventHandlerRegistry {
   MOCK_METHOD(
       uint64_t,
       registerHandler,
-      (const std::string &eventName, const std::shared_ptr<facebook::jsi::Function> &handler),
-      (override));
-  MOCK_METHOD(
-      void,
-      unregisterHandler,
-      (const std::string &eventName, uint64_t listenerId),
+      (AudioEvent eventName, const std::shared_ptr<facebook::jsi::Function> &handler),
       (override));
+  MOCK_METHOD(void, unregisterHandler, (AudioEvent eventName, uint64_t listenerId), (override));
 
-  MOCK_METHOD2(
-      invokeHandlerWithEventBody,
-      void(const std::string &eventName, const EventMap &body));
+  MOCK_METHOD2(invokeHandlerWithEventBody, void(AudioEvent eventName, const EventMap &body));
   MOCK_METHOD3(
       invokeHandlerWithEventBody,
-      void(const std::string &eventName, uint64_t listenerId, const EventMap &body));
+      void(AudioEvent eventName, uint64_t listenerId, const EventMap &body));
 };

package/ios/audioapi/ios/AudioAPIModule.h

@@ -7,6 +7,7 @@
 #endif // RCT_NEW_ARCH_ENABLED
 
 #import <React/RCTEventEmitter.h>
+#import <audioapi/events/AudioEvent.h>
 
 @class AudioEngine;
 @class SystemNotificationManager;
@@ -25,6 +26,7 @@
 @property (nonatomic, strong) AudioSessionManager *audioSessionManager;
 @property (nonatomic, strong) NotificationRegistry *notificationRegistry;
 
-- (void)invokeHandlerWithEventName:(NSString *)eventName eventBody:(NSDictionary *)eventBody;
+- (void)invokeHandlerWithEventName:(audioapi::AudioEvent)eventName
+                         eventBody:(NSDictionary *)eventBody;
 
 @end

package/ios/audioapi/ios/AudioAPIModule.mm

@@ -152,7 +152,8 @@ RCT_EXPORT_METHOD(
 
 RCT_EXPORT_METHOD(
     setAudioSessionOptions : (NSString *)category mode : (NSString *)mode options : (NSArray *)
-        options allowHaptics : (BOOL)allowHaptics)
+        options allowHaptics : (BOOL)allowHaptics notifyOthersOnDeactivation : (BOOL)
+            notifyOthersOnDeactivation)
 {
   if (!self.audioSessionManager.shouldManageSession) {
     [self.audioSessionManager setShouldManageSession:true];
@@ -160,7 +161,8 @@ RCT_EXPORT_METHOD(
   [self.audioSessionManager setAudioSessionOptions:category
                                               mode:mode
                                            options:options
-                                      allowHaptics:allowHaptics];
+                                      allowHaptics:allowHaptics
+                        notifyOthersOnDeactivation:notifyOthersOnDeactivation];
 }
 
 RCT_EXPORT_METHOD(observeAudioInterruptions : (NSString *)focusType enabled : (BOOL)enabled)
@@ -280,10 +282,9 @@ RCT_EXPORT_METHOD(
 }
 #endif // RCT_NEW_ARCH_ENABLED
 
-- (void)invokeHandlerWithEventName:(NSString *)eventName eventBody:(NSDictionary *)eventBody
+- (void)invokeHandlerWithEventName:(audioapi::AudioEvent)eventName
+                         eventBody:(NSDictionary *)eventBody
 {
-  auto name = [eventName UTF8String];
-
   std::unordered_map<std::string, EventValue> body = {};
 
   for (NSString *key in eventBody) {
@@ -308,7 +309,7 @@ RCT_EXPORT_METHOD(
   }
 
   if (_eventHandler != nullptr) {
-    _eventHandler->invokeHandlerWithEventBody(name, body);
+    _eventHandler->invokeHandlerWithEventBody(eventName, body);
   }
 }
 

package/ios/audioapi/ios/core/utils/AudioDecoder.mm

@@ -1,8 +1,6 @@
-#define MINIAUDIO_IMPLEMENTATION
-#import <audioapi/libs/miniaudio/miniaudio.h>
-
 #include <audioapi/libs/miniaudio/decoders/libopus/miniaudio_libopus.h>
 #include <audioapi/libs/miniaudio/decoders/libvorbis/miniaudio_libvorbis.h>
+#include <audioapi/libs/miniaudio/miniaudio.h>
 
 #include <audioapi/core/sources/AudioBuffer.h>
 #include <audioapi/core/utils/AudioDecoder.h>

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

@@ -17,6 +17,7 @@
 @property (nonatomic, assign) AVAudioSessionCategory desiredCategory;
 @property (nonatomic, assign) AVAudioSessionCategoryOptions desiredOptions;
 @property (nonatomic, assign) bool allowHapticsAndSounds;
+@property (nonatomic, assign) bool notifyOthersOnDeactivation;
 
 - (instancetype)init;
 + (instancetype)sharedInstance;
@@ -26,7 +27,8 @@
 - (void)setAudioSessionOptions:(NSString *)category
                           mode:(NSString *)mode
                        options:(NSArray *)options
-                  allowHaptics:(BOOL)allowHaptics;
+                  allowHaptics:(BOOL)allowHaptics
+    notifyOthersOnDeactivation:(BOOL)notifyOthersOnDeactivation;
 
 - (bool)configureAudioSession;
 - (bool)setActive:(bool)active error:(NSError **)error;

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

@@ -17,6 +17,7 @@ static AudioSessionManager *_sharedInstance = nil;
     self.desiredMode = AVAudioSessionModeDefault;
     self.desiredOptions = 0;
     self.allowHapticsAndSounds = false;
+    self.notifyOthersOnDeactivation = true;
   }
 
   _sharedInstance = self;
@@ -88,6 +89,7 @@ static AudioSessionManager *_sharedInstance = nil;
                           mode:(NSString *)modeStr
                        options:(NSArray *)optionsArray
                   allowHaptics:(BOOL)allowHaptics
+    notifyOthersOnDeactivation:(BOOL)notifyOthersOnDeactivation
 {
   AVAudioSessionCategory category = [self categoryFromString:categoryStr];
   AVAudioSessionMode mode = [self modeFromString:modeStr];
@@ -103,6 +105,7 @@ static AudioSessionManager *_sharedInstance = nil;
   self.desiredMode = mode;
   self.desiredOptions = options;
   self.allowHapticsAndSounds = allowHaptics;
+  self.notifyOthersOnDeactivation = notifyOthersOnDeactivation;
 
   if (configChanged && self.isActive) {
     [self configureAudioSession];
@@ -129,7 +132,11 @@ static AudioSessionManager *_sharedInstance = nil;
     }
   }
 
-  success = [self.audioSession setActive:active error:error];
+  AVAudioSessionSetActiveOptions options = active
+      ? 0
+      : (self.notifyOthersOnDeactivation ? AVAudioSessionSetActiveOptionNotifyOthersOnDeactivation
+                                         : 0);
+  success = [self.audioSession setActive:active withOptions:options error:error];
 
   if (success) {
     self.isActive = active;

package/ios/audioapi/ios/system/SystemNotificationManager.mm

@@ -1,3 +1,4 @@
+#import <audioapi/events/AudioEvent.h>
 #import <audioapi/ios/AudioAPIModule.h>
 #import <audioapi/ios/system/AudioEngine.h>
 #import <audioapi/ios/system/AudioSessionManager.h>
@@ -101,7 +102,8 @@ static NSString *NotificationManagerContext = @"SystemNotificationManagerContext
   if ([keyPath isEqualToString:@"outputVolume"]) {
     NSDictionary *body = @{@"value" : [NSNumber numberWithFloat:[change[@"new"] floatValue]]};
     if (self.volumeChangesObserved) {
-      [self.audioAPIModule invokeHandlerWithEventName:@"volumeChange" eventBody:body];
+      [self.audioAPIModule invokeHandlerWithEventName:audioapi::AudioEvent::VOLUME_CHANGE
+                                            eventBody:body];
     }
   }
 }
@@ -124,7 +126,8 @@ static NSString *NotificationManagerContext = @"SystemNotificationManagerContext
 
     if (self.audioInterruptionsObserved) {
       NSDictionary *body = @{@"type" : @"began", @"shouldResume" : @false};
-      [self.audioAPIModule invokeHandlerWithEventName:@"interruption" eventBody:body];
+      [self.audioAPIModule invokeHandlerWithEventName:audioapi::AudioEvent::INTERRUPTION
+                                            eventBody:body];
     }
 
     return;
@@ -134,7 +137,8 @@ static NSString *NotificationManagerContext = @"SystemNotificationManagerContext
 
   if (self.audioInterruptionsObserved) {
     NSDictionary *body = @{@"type" : @"ended", @"shouldResume" : @(shouldResume)};
-    [self.audioAPIModule invokeHandlerWithEventName:@"interruption" eventBody:body];
+    [self.audioAPIModule invokeHandlerWithEventName:audioapi::AudioEvent::INTERRUPTION
+                                          eventBody:body];
   } else {
     dispatch_async(dispatch_get_main_queue(), ^{ [audioEngine onInterruptionEnd:shouldResume]; });
   }
@@ -155,7 +159,8 @@ static NSString *NotificationManagerContext = @"SystemNotificationManagerContext
 
     if (self.audioInterruptionsObserved) {
       NSDictionary *body = @{@"type" : @"began", @"shouldResume" : @false};
-      [self.audioAPIModule invokeHandlerWithEventName:@"interruption" eventBody:body];
+      [self.audioAPIModule invokeHandlerWithEventName:audioapi::AudioEvent::INTERRUPTION
+                                            eventBody:body];
     }
     return;
   }
@@ -164,7 +169,8 @@ static NSString *NotificationManagerContext = @"SystemNotificationManagerContext
 
   if (self.audioInterruptionsObserved) {
     NSDictionary *body = @{@"type" : @"ended", @"shouldResume" : @(shouldResume)};
-    [self.audioAPIModule invokeHandlerWithEventName:@"interruption" eventBody:body];
+    [self.audioAPIModule invokeHandlerWithEventName:audioapi::AudioEvent::INTERRUPTION
+                                          eventBody:body];
   } else {
     dispatch_async(dispatch_get_main_queue(), ^{ [audioEngine onInterruptionEnd:shouldResume]; });
   }
@@ -208,7 +214,8 @@ static NSString *NotificationManagerContext = @"SystemNotificationManagerContext
 
   NSDictionary *body = @{@"reason" : reasonStr};
 
-  [self.audioAPIModule invokeHandlerWithEventName:@"routeChange" eventBody:body];
+  [self.audioAPIModule invokeHandlerWithEventName:audioapi::AudioEvent::ROUTE_CHANGE
+                                        eventBody:body];
 }
 
 - (void)handleMediaServicesReset:(NSNotification *)notification
@@ -280,7 +287,8 @@ static NSString *NotificationManagerContext = @"SystemNotificationManagerContext
     NSDictionary *body = @{@"type" : @"began", @"shouldResume" : @false};
 
     if (self.audioInterruptionsObserved) {
-      [self.audioAPIModule invokeHandlerWithEventName:@"interruption" eventBody:body];
+      [self.audioAPIModule invokeHandlerWithEventName:audioapi::AudioEvent::INTERRUPTION
+                                            eventBody:body];
     }
 
     return;
@@ -289,7 +297,8 @@ static NSString *NotificationManagerContext = @"SystemNotificationManagerContext
   NSDictionary *body = @{@"type" : @"ended", @"shouldResume" : @true};
 
   if (self.audioInterruptionsObserved) {
-    [self.audioAPIModule invokeHandlerWithEventName:@"interruption" eventBody:body];
+    [self.audioAPIModule invokeHandlerWithEventName:audioapi::AudioEvent::INTERRUPTION
+                                          eventBody:body];
   } else {
     dispatch_async(dispatch_get_main_queue(), ^{ [audioEngine onInterruptionEnd:true]; });
   }

package/ios/audioapi/ios/system/notification/PlaybackNotification.mm

@@ -46,11 +46,11 @@
   // Enable default remote commands
   [self enableRemoteCommand:@"play" enabled:true];
   [self enableRemoteCommand:@"pause" enabled:true];
-  [self enableRemoteCommand:@"next" enabled:true];
-  [self enableRemoteCommand:@"previous" enabled:true];
+  [self enableRemoteCommand:@"nextTrack" enabled:true];
+  [self enableRemoteCommand:@"previousTrack" enabled:true];
   [self enableRemoteCommand:@"skipForward" enabled:true];
   [self enableRemoteCommand:@"skipBackward" enabled:true];
-  [self enableRemoteCommand:@"seek" enabled:true];
+  [self enableRemoteCommand:@"seekTo" enabled:true];
 
   _isInitialized = true;
   return true;
@@ -109,7 +109,6 @@
   [remoteCenter.playCommand removeTarget:self];
   [remoteCenter.pauseCommand removeTarget:self];
   [remoteCenter.stopCommand removeTarget:self];
-  [remoteCenter.togglePlayPauseCommand removeTarget:self];
   [remoteCenter.nextTrackCommand removeTarget:self];
   [remoteCenter.previousTrackCommand removeTarget:self];
   [remoteCenter.skipForwardCommand removeTarget:self];
@@ -270,11 +269,12 @@
 {
   NSSet *validControls = [NSSet setWithObjects:@"play",
                                                @"pause",
-                                               @"next",
-                                               @"previous",
+                                               @"stop",
+                                               @"nextTrack",
+                                               @"previousTrack",
                                                @"skipForward",
                                                @"skipBackward",
-                                               @"seek",
+                                               @"seekTo",
                                                nil];
   if ([validControls containsObject:control]) {
     [self enableRemoteCommand:control enabled:enabled];
@@ -291,15 +291,11 @@
     [self enableCommand:remoteCenter.pauseCommand withSelector:@selector(onPause:) enabled:enabled];
   } else if ([name isEqualToString:@"stop"]) {
     [self enableCommand:remoteCenter.stopCommand withSelector:@selector(onStop:) enabled:enabled];
-  } else if ([name isEqualToString:@"togglePlayPause"]) {
-    [self enableCommand:remoteCenter.togglePlayPauseCommand
-           withSelector:@selector(onTogglePlayPause:)
-                enabled:enabled];
-  } else if ([name isEqualToString:@"next"]) {
+  } else if ([name isEqualToString:@"nextTrack"]) {
     [self enableCommand:remoteCenter.nextTrackCommand
            withSelector:@selector(onNextTrack:)
                 enabled:enabled];
-  } else if ([name isEqualToString:@"previous"]) {
+  } else if ([name isEqualToString:@"previousTrack"]) {
     [self enableCommand:remoteCenter.previousTrackCommand
            withSelector:@selector(onPreviousTrack:)
                 enabled:enabled];
@@ -321,7 +317,7 @@
     [self enableCommand:remoteCenter.seekBackwardCommand
            withSelector:@selector(onSeekBackward:)
                 enabled:enabled];
-  } else if ([name isEqualToString:@"seek"]) {
+  } else if ([name isEqualToString:@"seekTo"]) {
     [self enableCommand:remoteCenter.changePlaybackPositionCommand
            withSelector:@selector(onChangePlaybackPosition:)
                 enabled:enabled];
@@ -341,67 +337,72 @@
 
 - (MPRemoteCommandHandlerStatus)onPlay:(MPRemoteCommandEvent *)event
 {
-  [self.audioAPIModule invokeHandlerWithEventName:@"playbackNotificationPlay" eventBody:@{}];
+  [self.audioAPIModule invokeHandlerWithEventName:audioapi::AudioEvent::PLAYBACK_NOTIFICATION_PLAY
+                                        eventBody:@{}];
   return MPRemoteCommandHandlerStatusSuccess;
 }
 
 - (MPRemoteCommandHandlerStatus)onPause:(MPRemoteCommandEvent *)event
 {
-  [self.audioAPIModule invokeHandlerWithEventName:@"playbackNotificationPause" eventBody:@{}];
+  [self.audioAPIModule invokeHandlerWithEventName:audioapi::AudioEvent::PLAYBACK_NOTIFICATION_PAUSE
+                                        eventBody:@{}];
   return MPRemoteCommandHandlerStatusSuccess;
 }
 
 - (MPRemoteCommandHandlerStatus)onStop:(MPRemoteCommandEvent *)event
 {
-  [self.audioAPIModule invokeHandlerWithEventName:@"playbackNotificationStop" eventBody:@{}];
-  return MPRemoteCommandHandlerStatusSuccess;
-}
-
-- (MPRemoteCommandHandlerStatus)onTogglePlayPause:(MPRemoteCommandEvent *)event
-{
-  [self.audioAPIModule invokeHandlerWithEventName:@"playbackNotificationTogglePlayPause"
+  [self.audioAPIModule invokeHandlerWithEventName:audioapi::AudioEvent::PLAYBACK_NOTIFICATION_STOP
                                         eventBody:@{}];
   return MPRemoteCommandHandlerStatusSuccess;
 }
 
 - (MPRemoteCommandHandlerStatus)onNextTrack:(MPRemoteCommandEvent *)event
 {
-  [self.audioAPIModule invokeHandlerWithEventName:@"playbackNotificationNext" eventBody:@{}];
+  [self.audioAPIModule
+      invokeHandlerWithEventName:audioapi::AudioEvent::PLAYBACK_NOTIFICATION_NEXT_TRACK
+                       eventBody:@{}];
   return MPRemoteCommandHandlerStatusSuccess;
 }
 
 - (MPRemoteCommandHandlerStatus)onPreviousTrack:(MPRemoteCommandEvent *)event
 {
-  [self.audioAPIModule invokeHandlerWithEventName:@"playbackNotificationPrevious" eventBody:@{}];
+  [self.audioAPIModule
+      invokeHandlerWithEventName:audioapi::AudioEvent::PLAYBACK_NOTIFICATION_PREVIOUS_TRACK
+                       eventBody:@{}];
   return MPRemoteCommandHandlerStatusSuccess;
 }
 
 - (MPRemoteCommandHandlerStatus)onSeekForward:(MPRemoteCommandEvent *)event
 {
-  [self.audioAPIModule invokeHandlerWithEventName:@"playbackNotificationSeekForward" eventBody:@{}];
+  [self.audioAPIModule
+      invokeHandlerWithEventName:audioapi::AudioEvent::PLAYBACK_NOTIFICATION_SEEK_FORWARD
+                       eventBody:@{}];
   return MPRemoteCommandHandlerStatusSuccess;
 }
 
 - (MPRemoteCommandHandlerStatus)onSeekBackward:(MPRemoteCommandEvent *)event
 {
-  [self.audioAPIModule invokeHandlerWithEventName:@"playbackNotificationSeekBackward"
-                                        eventBody:@{}];
+  [self.audioAPIModule
+      invokeHandlerWithEventName:audioapi::AudioEvent::PLAYBACK_NOTIFICATION_SEEK_BACKWARD
+                       eventBody:@{}];
   return MPRemoteCommandHandlerStatusSuccess;
 }
 
 - (MPRemoteCommandHandlerStatus)onSkipForward:(MPSkipIntervalCommandEvent *)event
 {
   NSDictionary *body = @{@"value" : @(event.interval)};
-  [self.audioAPIModule invokeHandlerWithEventName:@"playbackNotificationSkipForward"
-                                        eventBody:body];
+  [self.audioAPIModule
+      invokeHandlerWithEventName:audioapi::AudioEvent::PLAYBACK_NOTIFICATION_SKIP_FORWARD
+                       eventBody:body];
   return MPRemoteCommandHandlerStatusSuccess;
 }
 
 - (MPRemoteCommandHandlerStatus)onSkipBackward:(MPSkipIntervalCommandEvent *)event
 {
   NSDictionary *body = @{@"value" : @(event.interval)};
-  [self.audioAPIModule invokeHandlerWithEventName:@"playbackNotificationSkipBackward"
-                                        eventBody:body];
+  [self.audioAPIModule
+      invokeHandlerWithEventName:audioapi::AudioEvent::PLAYBACK_NOTIFICATION_SKIP_BACKWARD
+                       eventBody:body];
   return MPRemoteCommandHandlerStatusSuccess;
 }
 
@@ -409,7 +410,9 @@
     (MPChangePlaybackPositionCommandEvent *)event
 {
   NSDictionary *body = @{@"value" : @(event.positionTime)};
-  [self.audioAPIModule invokeHandlerWithEventName:@"playbackNotificationSeekTo" eventBody:body];
+  [self.audioAPIModule
+      invokeHandlerWithEventName:audioapi::AudioEvent::PLAYBACK_NOTIFICATION_SEEK_TO
+                       eventBody:body];
   return MPRemoteCommandHandlerStatusSuccess;
 }
 

package/lib/commonjs/core/AudioDecoder.js

@@ -6,9 +6,9 @@ Object.defineProperty(exports, "__esModule", {
 exports.decodeAudioData = decodeAudioData;
 exports.decodePCMInBase64 = decodePCMInBase64;
 var _reactNative = require("react-native");
+var _errors = require("../errors");
 var _paths = require("../utils/paths");
 var _AudioBuffer = _interopRequireDefault(require("./AudioBuffer"));
-var _errors = require("../errors");
 function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
 class AudioDecoder {
   static instance = null;
@@ -38,7 +38,7 @@ class AudioDecoder {
       const buffer = await this.decoder.decodeWithMemoryBlock(new Uint8Array(arrayBuffer), sampleRate ?? 0);
       return new _AudioBuffer.default(buffer);
     }
-    if (!(typeof input === 'string')) {
+    if (!(typeof stringSource === 'string')) {
       throw new TypeError('Input must be a module, uri or ArrayBuffer');
     }