react-native-audio-api 0.12.0-nightly-3254662-20260127 → 0.12.0-nightly-1a3c43b-20260128

package/common/cpp/audioapi/core/sources/AudioBufferQueueSourceNode.cpp

@@ -19,7 +19,7 @@
 namespace audioapi {
 
 AudioBufferQueueSourceNode::AudioBufferQueueSourceNode(
-std::shared_ptr<BaseAudioContext> context,
+    const std::shared_ptr<BaseAudioContext> &context,
     const BaseAudioBufferSourceOptions &options)
     : AudioBufferBaseSourceNode(context, options) {
   buffers_ = {};
@@ -130,11 +130,11 @@ void AudioBufferQueueSourceNode::disable() {
 }
 
 void AudioBufferQueueSourceNode::setOnBufferEndedCallbackId(uint64_t callbackId) {
-    auto oldCallbackId = onBufferEndedCallbackId_.exchange(callbackId, std::memory_order_acq_rel);
+  auto oldCallbackId = onBufferEndedCallbackId_.exchange(callbackId, std::memory_order_acq_rel);
 
-    if (oldCallbackId != 0) {
-        audioEventHandlerRegistry_->unregisterHandler("bufferEnded", oldCallbackId);
-    }
+  if (oldCallbackId != 0) {
+    audioEventHandlerRegistry_->unregisterHandler(AudioEvent::BUFFER_ENDED, oldCallbackId);
+  }
 }
 
 std::shared_ptr<AudioBus> AudioBufferQueueSourceNode::processNode(
@@ -171,15 +171,15 @@ double AudioBufferQueueSourceNode::getCurrentPosition() const {
 }
 
 void AudioBufferQueueSourceNode::sendOnBufferEndedEvent(size_t bufferId, bool isLastBufferInQueue) {
-    auto onBufferEndedCallbackId = onBufferEndedCallbackId_.load(std::memory_order_acquire);
+  auto onBufferEndedCallbackId = onBufferEndedCallbackId_.load(std::memory_order_acquire);
 
-    if (onBufferEndedCallbackId != 0) {
-        std::unordered_map<std::string, EventValue> body =
-                {{"bufferId", std::to_string(bufferId)}, {"isLastBufferInQueue", isLastBufferInQueue}};
+  if (onBufferEndedCallbackId != 0) {
+    std::unordered_map<std::string, EventValue> body = {
+        {"bufferId", std::to_string(bufferId)}, {"isLastBufferInQueue", isLastBufferInQueue}};
 
-        audioEventHandlerRegistry_->invokeHandlerWithEventBody(
-                "bufferEnded", onBufferEndedCallbackId, body);
-    }
+    audioEventHandlerRegistry_->invokeHandlerWithEventBody(
+        AudioEvent::BUFFER_ENDED, onBufferEndedCallbackId, body);
+  }
 }
 
 /**
@@ -221,7 +221,7 @@ void AudioBufferQueueSourceNode::processWithoutInterpolation(
       buffers_.pop();
 
       if (!(buffers_.empty() && addExtraTailFrames_)) {
-          sendOnBufferEndedEvent(bufferId, buffers_.empty());
+        sendOnBufferEndedEvent(bufferId, buffers_.empty());
       }
 
       if (buffers_.empty()) {

package/common/cpp/audioapi/core/sources/AudioBufferQueueSourceNode.h

@@ -14,12 +14,12 @@ namespace audioapi {
 
 class AudioBus;
 class AudioParam;
-class BaseAudioBufferSourceOptions;
+struct BaseAudioBufferSourceOptions;
 
 class AudioBufferQueueSourceNode : public AudioBufferBaseSourceNode {
  public:
   explicit AudioBufferQueueSourceNode(
-      std::shared_ptr<BaseAudioContext> context,
+      const std::shared_ptr<BaseAudioContext> &context,
       const BaseAudioBufferSourceOptions &options);
   ~AudioBufferQueueSourceNode() override;
 

package/common/cpp/audioapi/core/sources/AudioBufferSourceNode.cpp

@@ -14,7 +14,7 @@
 namespace audioapi {
 
 AudioBufferSourceNode::AudioBufferSourceNode(
-    std::shared_ptr<BaseAudioContext> context,
+    const std::shared_ptr<BaseAudioContext> &context,
     const AudioBufferSourceOptions &options)
     : AudioBufferBaseSourceNode(context, options),
       loop_(options.loop),
@@ -105,8 +105,8 @@ void AudioBufferSourceNode::setBuffer(const std::shared_ptr<AudioBuffer> &buffer
   }
   audioBus_ =
       std::make_shared<AudioBus>(RENDER_QUANTUM_SIZE, channelCount_, context->getSampleRate());
-  playbackRateBus_ = std::make_shared<AudioBus>(
-      RENDER_QUANTUM_SIZE * 3, channelCount_, context->getSampleRate());
+  playbackRateBus_ =
+      std::make_shared<AudioBus>(RENDER_QUANTUM_SIZE * 3, channelCount_, context->getSampleRate());
 
   loopEnd_ = buffer_->getDuration();
 }
@@ -141,7 +141,7 @@ void AudioBufferSourceNode::setOnLoopEndedCallbackId(uint64_t callbackId) {
   auto oldCallbackId = onLoopEndedCallbackId_.exchange(callbackId, std::memory_order_acq_rel);
 
   if (oldCallbackId != 0) {
-    audioEventHandlerRegistry_->unregisterHandler("loopEnded", oldCallbackId);
+    audioEventHandlerRegistry_->unregisterHandler(AudioEvent::LOOP_ENDED, oldCallbackId);
   }
 }
 
@@ -176,7 +176,8 @@ double AudioBufferSourceNode::getCurrentPosition() const {
 void AudioBufferSourceNode::sendOnLoopEndedEvent() {
   auto onLoopEndedCallbackId = onLoopEndedCallbackId_.load(std::memory_order_acquire);
   if (onLoopEndedCallbackId != 0) {
-    audioEventHandlerRegistry_->invokeHandlerWithEventBody("loopEnded", onLoopEndedCallbackId, {});
+    audioEventHandlerRegistry_->invokeHandlerWithEventBody(
+        AudioEvent::LOOP_ENDED, onLoopEndedCallbackId, {});
   }
 }
 

package/common/cpp/audioapi/core/sources/AudioBufferSourceNode.h

@@ -13,12 +13,12 @@ namespace audioapi {
 
 class AudioBus;
 class AudioParam;
-class AudioBufferSourceOptions;
+struct AudioBufferSourceOptions;
 
 class AudioBufferSourceNode : public AudioBufferBaseSourceNode {
  public:
   explicit AudioBufferSourceNode(
-      std::shared_ptr<BaseAudioContext> context,
+      const std::shared_ptr<BaseAudioContext> &context,
       const AudioBufferSourceOptions &options);
   ~AudioBufferSourceNode() override;
 

package/common/cpp/audioapi/core/sources/AudioScheduledSourceNode.cpp

@@ -66,7 +66,7 @@ void AudioScheduledSourceNode::setOnEndedCallbackId(const uint64_t callbackId) {
   auto oldCallbackId = onEndedCallbackId_.exchange(callbackId, std::memory_order_acq_rel);
 
   if (oldCallbackId != 0) {
-    audioEventHandlerRegistry_->unregisterHandler("ended", oldCallbackId);
+    audioEventHandlerRegistry_->unregisterHandler(AudioEvent::ENDED, oldCallbackId);
   }
 }
 
@@ -167,7 +167,7 @@ void AudioScheduledSourceNode::disable() {
 
   auto onEndedCallbackId = onEndedCallbackId_.load(std::memory_order_acquire);
   if (onEndedCallbackId != 0) {
-    audioEventHandlerRegistry_->invokeHandlerWithEventBody("ended", onEndedCallbackId, {});
+    audioEventHandlerRegistry_->invokeHandlerWithEventBody(AudioEvent::ENDED, onEndedCallbackId, {});
   }
 }
 

package/common/cpp/audioapi/core/sources/ConstantSourceNode.cpp

@@ -7,7 +7,9 @@
 #include <memory>
 
 namespace audioapi {
-ConstantSourceNode::ConstantSourceNode(std::shared_ptr<BaseAudioContext> context, const ConstantSourceOptions &options)
+ConstantSourceNode::ConstantSourceNode(
+    const std::shared_ptr<BaseAudioContext> &context,
+    const ConstantSourceOptions &options)
     : AudioScheduledSourceNode(context) {
   offsetParam_ = std::make_shared<AudioParam>(
       options.offset, MOST_NEGATIVE_SINGLE_FLOAT, MOST_POSITIVE_SINGLE_FLOAT, context);
@@ -30,7 +32,13 @@ std::shared_ptr<AudioBus> ConstantSourceNode::processNode(
     return processingBus;
   }
 
-  updatePlaybackInfo(processingBus, framesToProcess, startOffset, offsetLength, context->getSampleRate(), context->getCurrentSampleFrame());
+  updatePlaybackInfo(
+      processingBus,
+      framesToProcess,
+      startOffset,
+      offsetLength,
+      context->getSampleRate(),
+      context->getCurrentSampleFrame());
 
   if (!isPlaying() && !isStopScheduled()) {
     processingBus->zero();

package/common/cpp/audioapi/core/sources/ConstantSourceNode.h

@@ -10,12 +10,12 @@
 namespace audioapi {
 
 class AudioBus;
-class ConstantSourceOptions;
+struct ConstantSourceOptions;
 
 class ConstantSourceNode : public AudioScheduledSourceNode {
  public:
   explicit ConstantSourceNode(
-      std::shared_ptr<BaseAudioContext> context,
+      const std::shared_ptr<BaseAudioContext> &context,
       const ConstantSourceOptions &options);
 
   [[nodiscard]] std::shared_ptr<AudioParam> getOffsetParam() const;

package/common/cpp/audioapi/core/sources/OscillatorNode.cpp

@@ -9,13 +9,12 @@
 
 namespace audioapi {
 
-OscillatorNode::OscillatorNode(std::shared_ptr<BaseAudioContext> context, const OscillatorOptions &options)
+OscillatorNode::OscillatorNode(
+    const std::shared_ptr<BaseAudioContext> &context,
+    const OscillatorOptions &options)
     : AudioScheduledSourceNode(context) {
   frequencyParam_ = std::make_shared<AudioParam>(
-      options.frequency,
-      -context->getNyquistFrequency(),
-      context->getNyquistFrequency(),
-      context);
+      options.frequency, -context->getNyquistFrequency(), context->getNyquistFrequency(), context);
   detuneParam_ = std::make_shared<AudioParam>(
       options.detune,
       -1200 * LOG2_MOST_POSITIVE_SINGLE_FLOAT,
@@ -69,7 +68,13 @@ std::shared_ptr<AudioBus> OscillatorNode::processNode(
     return processingBus;
   }
 
-  updatePlaybackInfo(processingBus, framesToProcess, startOffset, offsetLength, context->getSampleRate(), context->getCurrentSampleFrame());
+  updatePlaybackInfo(
+      processingBus,
+      framesToProcess,
+      startOffset,
+      offsetLength,
+      context->getSampleRate(),
+      context->getCurrentSampleFrame());
 
   if (!isPlaying() && !isStopScheduled()) {
     processingBus->zero();

package/common/cpp/audioapi/core/sources/OscillatorNode.h

@@ -13,12 +13,12 @@
 namespace audioapi {
 
 class AudioBus;
-class OscillatorOptions;
+struct OscillatorOptions;
 
 class OscillatorNode : public AudioScheduledSourceNode {
  public:
   explicit OscillatorNode(
-      std::shared_ptr<BaseAudioContext> context,
+      const std::shared_ptr<BaseAudioContext> &context,
       const OscillatorOptions &options);
 
   [[nodiscard]] std::shared_ptr<AudioParam> getFrequencyParam() const;

package/common/cpp/audioapi/core/sources/StreamerNode.cpp

@@ -23,7 +23,9 @@
 
 namespace audioapi {
 #if !RN_AUDIO_API_FFMPEG_DISABLED
-StreamerNode::StreamerNode(std::shared_ptr<BaseAudioContext> context, const StreamerOptions &options)
+StreamerNode::StreamerNode(
+    const std::shared_ptr<BaseAudioContext> &context,
+    const StreamerOptions &options)
     : AudioScheduledSourceNode(context),
       fmtCtx_(nullptr),
       codecCtx_(nullptr),
@@ -38,7 +40,10 @@ StreamerNode::StreamerNode(std::shared_ptr<BaseAudioContext> context, const Stre
       maxResampledSamples_(0),
       processedSamples_(0) {}
 #else
-StreamerNode::StreamerNode(std::shared_ptr<BaseAudioContext> context, const StreamerOptions &options) : AudioScheduledSourceNode(context) {}
+StreamerNode::StreamerNode(
+    const std::shared_ptr<BaseAudioContext> &context,
+    const StreamerOptions &options)
+    : AudioScheduledSourceNode(context) {}
 #endif // RN_AUDIO_API_FFMPEG_DISABLED
 
 StreamerNode::~StreamerNode() {
@@ -112,7 +117,13 @@ std::shared_ptr<AudioBus> StreamerNode::processNode(
     processingBus->zero();
     return processingBus;
   }
-  updatePlaybackInfo(processingBus, framesToProcess, startOffset, offsetLength, context->getSampleRate(), context->getCurrentSampleFrame());
+  updatePlaybackInfo(
+      processingBus,
+      framesToProcess,
+      startOffset,
+      offsetLength,
+      context->getSampleRate(),
+      context->getCurrentSampleFrame());
   isNodeFinished_.store(isFinished(), std::memory_order_release);
 
   if (!isPlaying() && !isStopScheduled()) {
@@ -217,7 +228,9 @@ void StreamerNode::streamAudio() {
   }
 }
 
-bool StreamerNode::processFrameWithResampler(AVFrame *frame, std::shared_ptr<BaseAudioContext> context) {
+bool StreamerNode::processFrameWithResampler(
+    AVFrame *frame,
+    std::shared_ptr<BaseAudioContext> context) {
   // Check if we need to reallocate the resampled buffer
   int out_samples = swr_get_out_samples(swrCtx_, frame->nb_samples);
   if (out_samples > maxResampledSamples_) {

package/common/cpp/audioapi/core/sources/StreamerNode.h

@@ -59,11 +59,13 @@ struct StreamingData {
 namespace audioapi {
 
 class AudioBus;
-class StreamerOptions;
+struct StreamerOptions;
 
 class StreamerNode : public AudioScheduledSourceNode {
  public:
-  explicit StreamerNode(std::shared_ptr<BaseAudioContext> context, const StreamerOptions &options);
+  explicit StreamerNode(
+      const std::shared_ptr<BaseAudioContext> &context,
+      const StreamerOptions &options);
   ~StreamerNode() override;
 
   /**

package/common/cpp/audioapi/core/utils/AudioFileWriter.cpp

@@ -30,7 +30,7 @@ void AudioFileWriter::invokeOnErrorCallback(const std::string &message) {
   }
 
   std::unordered_map<std::string, EventValue> eventPayload = {{"message", message}};
-  audioEventHandlerRegistry_->invokeHandlerWithEventBody("recorderError", callbackId, eventPayload);
+  audioEventHandlerRegistry_->invokeHandlerWithEventBody(AudioEvent::RECORDER_ERROR, callbackId, eventPayload);
 }
 
 bool AudioFileWriter::isFileOpen() {

package/common/cpp/audioapi/core/utils/AudioRecorderCallback.cpp

@@ -76,7 +76,7 @@ void AudioRecorderCallback::invokeCallback(const std::shared_ptr<AudioBus> &bus,
   eventPayload.insert({"numFrames", numFrames});
 
   if (audioEventHandlerRegistry_) {
-    audioEventHandlerRegistry_->invokeHandlerWithEventBody("audioReady", callbackId_, eventPayload);
+    audioEventHandlerRegistry_->invokeHandlerWithEventBody(AudioEvent::AUDIO_READY, callbackId_, eventPayload);
   }
 }
 
@@ -98,7 +98,7 @@ void AudioRecorderCallback::invokeOnErrorCallback(const std::string &message) {
   }
 
   std::unordered_map<std::string, EventValue> eventPayload = {{"message", message}};
-  audioEventHandlerRegistry_->invokeHandlerWithEventBody("recorderError", callbackId, eventPayload);
+  audioEventHandlerRegistry_->invokeHandlerWithEventBody(AudioEvent::RECORDER_ERROR, callbackId, eventPayload);
 }
 
 } // namespace audioapi

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

@@ -0,0 +1,30 @@
+#pragma once
+
+namespace audioapi {
+
+enum class AudioEvent {
+  PLAYBACK_NOTIFICATION_PLAY,
+  PLAYBACK_NOTIFICATION_PAUSE,
+  PLAYBACK_NOTIFICATION_STOP,
+  PLAYBACK_NOTIFICATION_NEXT_TRACK,
+  PLAYBACK_NOTIFICATION_PREVIOUS_TRACK,
+  PLAYBACK_NOTIFICATION_SKIP_FORWARD,
+  PLAYBACK_NOTIFICATION_SKIP_BACKWARD,
+  PLAYBACK_NOTIFICATION_SEEK_FORWARD,
+  PLAYBACK_NOTIFICATION_SEEK_BACKWARD,
+  PLAYBACK_NOTIFICATION_SEEK_TO,
+  PLAYBACK_NOTIFICATION_DISMISSED,
+  RECORDING_NOTIFICATION_RESUME,
+  RECORDING_NOTIFICATION_PAUSE,
+  ROUTE_CHANGE,
+  INTERRUPTION,
+  VOLUME_CHANGE,
+  DUCK,
+  ENDED,
+  LOOP_ENDED,
+  AUDIO_READY,
+  POSITION_CHANGED,
+  BUFFER_ENDED,
+  RECORDER_ERROR,
+};
+} // namespace audioapi

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/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/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;