react-native-audio-api 0.10.0-nightly-44925d7-20251104 → 0.10.0-nightly-98d2e0d-20251106

package/android/src/main/java/com/swmansion/audioapi/AudioAPIModule.kt

@@ -2,7 +2,6 @@ package com.swmansion.audioapi
 
 import com.facebook.jni.HybridData
 import com.facebook.react.bridge.LifecycleEventListener
-import com.facebook.react.bridge.NativeModule
 import com.facebook.react.bridge.Promise
 import com.facebook.react.bridge.ReactApplicationContext
 import com.facebook.react.bridge.ReadableArray
@@ -27,7 +26,6 @@ class AudioAPIModule(
   val reactContext: WeakReference<ReactApplicationContext> = WeakReference(reactContext)
 
   private val mHybridData: HybridData
-  private var reanimatedModule: NativeModule? = null
 
   external fun initHybrid(
     workletsModule: Any?,

package/common/cpp/audioapi/HostObjects/sources/AudioBufferBaseSourceNodeHostObject.cpp

@@ -28,7 +28,7 @@ AudioBufferBaseSourceNodeHostObject::~AudioBufferBaseSourceNodeHostObject() {
   // When JSI object is garbage collected (together with the eventual callback),
   // underlying source node might still be active and try to call the
   // non-existing callback.
-  sourceNode->clearOnPositionChangedCallback();
+  sourceNode->setOnPositionChangedCallbackId(0);
 }
 
 JSI_PROPERTY_GETTER_IMPL(AudioBufferBaseSourceNodeHostObject, detune) {

package/common/cpp/audioapi/HostObjects/sources/AudioBufferSourceNodeHostObject.cpp

@@ -37,7 +37,7 @@ AudioBufferSourceNodeHostObject::~AudioBufferSourceNodeHostObject() {
   // When JSI object is garbage collected (together with the eventual callback),
   // underlying source node might still be active and try to call the
   // non-existing callback.
-  audioBufferSourceNode->clearOnLoopEndedCallback();
+  audioBufferSourceNode->setOnLoopEndedCallbackId(0);
 }
 
 JSI_PROPERTY_GETTER_IMPL(AudioBufferSourceNodeHostObject, loop) {

package/common/cpp/audioapi/HostObjects/sources/AudioScheduledSourceNodeHostObject.cpp

@@ -22,7 +22,7 @@ AudioScheduledSourceNodeHostObject::~AudioScheduledSourceNodeHostObject() {
   // When JSI object is garbage collected (together with the eventual callback),
   // underlying source node might still be active and try to call the
   // non-existing callback.
-  audioScheduledSourceNode->clearOnEndedCallback();
+  audioScheduledSourceNode->setOnEndedCallbackId(0);
 }
 
 JSI_PROPERTY_SETTER_IMPL(AudioScheduledSourceNodeHostObject, onEnded) {

package/common/cpp/audioapi/core/effects/ConvolverNode.cpp

@@ -11,16 +11,16 @@
 namespace audioapi {
 ConvolverNode::ConvolverNode(
     BaseAudioContext *context,
-    std::shared_ptr<AudioBuffer> buffer,
+    const std::shared_ptr<AudioBuffer> &buffer,
     bool disableNormalization)
     : AudioNode(context),
-      buffer_(nullptr),
-      internalBuffer_(nullptr),
-      signalledToStop_(false),
       remainingSegments_(0),
       internalBufferIndex_(0),
+      signalledToStop_(false),
       scaleFactor_(1.0f),
-      intermediateBus_(nullptr) {
+      intermediateBus_(nullptr),
+      buffer_(nullptr),
+      internalBuffer_(nullptr) {
   channelCount_ = 2;
   channelCountMode_ = ChannelCountMode::CLAMPED_MAX;
   normalize_ = !disableNormalization;

package/common/cpp/audioapi/core/effects/ConvolverNode.h

@@ -19,7 +19,7 @@ class AudioBuffer;
 
 class ConvolverNode : public AudioNode {
  public:
-    explicit ConvolverNode(BaseAudioContext *context, std::shared_ptr<AudioBuffer> buffer, bool disableNormalization);
+    explicit ConvolverNode(BaseAudioContext *context, const std::shared_ptr<AudioBuffer>& buffer, bool disableNormalization);
 
     [[nodiscard]] bool getNormalize_() const;
     [[nodiscard]] const std::shared_ptr<AudioBuffer> &getBuffer() const;

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

@@ -36,20 +36,15 @@ std::shared_ptr<AudioParam> AudioBufferBaseSourceNode::getPlaybackRateParam()
   return playbackRateParam_;
 }
 
-void AudioBufferBaseSourceNode::clearOnPositionChangedCallback() {
-  if (onPositionChangedCallbackId_ == 0 || context_ == nullptr ||
-      context_->audioEventHandlerRegistry_ == nullptr) {
-    return;
-  }
-
-  context_->audioEventHandlerRegistry_->unregisterHandler(
-      "positionChanged", onPositionChangedCallbackId_);
-  onPositionChangedCallbackId_ = 0;
-}
-
 void AudioBufferBaseSourceNode::setOnPositionChangedCallbackId(
     uint64_t callbackId) {
-  onPositionChangedCallbackId_ = callbackId;
+  auto oldCallbackId = onPositionChangedCallbackId_.exchange(
+      callbackId, std::memory_order_acq_rel);
+
+  if (oldCallbackId != 0) {
+    audioEventHandlerRegistry_->unregisterHandler(
+        "positionChanged", oldCallbackId);
+  }
 }
 
 void AudioBufferBaseSourceNode::setOnPositionChangedInterval(int interval) {
@@ -66,14 +61,16 @@ std::mutex &AudioBufferBaseSourceNode::getBufferLock() {
 }
 
 void AudioBufferBaseSourceNode::sendOnPositionChangedEvent() {
-  if (onPositionChangedCallbackId_ != 0 &&
-      onPositionChangedTime_ > onPositionChangedInterval_ &&
-      context_->audioEventHandlerRegistry_ != nullptr) {
+  auto onPositionChangedCallbackId =
+      onPositionChangedCallbackId_.load(std::memory_order_acquire);
+
+  if (onPositionChangedCallbackId != 0 &&
+      onPositionChangedTime_ > onPositionChangedInterval_) {
     std::unordered_map<std::string, EventValue> body = {
         {"value", getCurrentPosition()}};
 
-    context_->audioEventHandlerRegistry_->invokeHandlerWithEventBody(
-        "positionChanged", onPositionChangedCallbackId_, body);
+    audioEventHandlerRegistry_->invokeHandlerWithEventBody(
+        "positionChanged", onPositionChangedCallbackId, body);
 
     onPositionChangedTime_ = 0;
   }

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

@@ -19,7 +19,6 @@ class AudioBufferBaseSourceNode : public AudioScheduledSourceNode {
   [[nodiscard]] std::shared_ptr<AudioParam> getDetuneParam() const;
   [[nodiscard]] std::shared_ptr<AudioParam> getPlaybackRateParam() const;
 
-  void clearOnPositionChangedCallback();
   void setOnPositionChangedCallbackId(uint64_t callbackId);
   void setOnPositionChangedInterval(int interval);
   [[nodiscard]] int getOnPositionChangedInterval() const;

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

@@ -123,19 +123,13 @@ void AudioBufferSourceNode::disable() {
   alignedBus_.reset();
 }
 
-void AudioBufferSourceNode::clearOnLoopEndedCallback() {
-  if (onLoopEndedCallbackId_ == 0 || context_ == nullptr ||
-      context_->audioEventHandlerRegistry_ == nullptr) {
-    return;
-  }
-
-  context_->audioEventHandlerRegistry_->unregisterHandler(
-      "loopEnded", onLoopEndedCallbackId_);
-  onLoopEndedCallbackId_ = 0;
-}
-
 void AudioBufferSourceNode::setOnLoopEndedCallbackId(uint64_t callbackId) {
-  onLoopEndedCallbackId_ = callbackId;
+  auto oldCallbackId =
+      onLoopEndedCallbackId_.exchange(callbackId, std::memory_order_acq_rel);
+
+  if (oldCallbackId != 0) {
+    audioEventHandlerRegistry_->unregisterHandler("loopEnded", oldCallbackId);
+  }
 }
 
 std::shared_ptr<AudioBus> AudioBufferSourceNode::processNode(
@@ -171,8 +165,8 @@ void AudioBufferSourceNode::sendOnLoopEndedEvent() {
   auto onLoopEndedCallbackId =
       onLoopEndedCallbackId_.load(std::memory_order_acquire);
   if (onLoopEndedCallbackId != 0) {
-    context_->audioEventHandlerRegistry_->invokeHandlerWithEventBody(
-        "loopEnded", onLoopEndedCallbackId_, {});
+    audioEventHandlerRegistry_->invokeHandlerWithEventBody(
+        "loopEnded", onLoopEndedCallbackId, {});
   }
 }
 

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

@@ -34,7 +34,6 @@ class AudioBufferSourceNode : public AudioBufferBaseSourceNode {
   void start(double when, double offset, double duration = -1);
   void disable() override;
 
-  void clearOnLoopEndedCallback();
   void setOnLoopEndedCallbackId(uint64_t callbackId);
 
  protected:

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

@@ -14,6 +14,7 @@ AudioScheduledSourceNode::AudioScheduledSourceNode(BaseAudioContext *context)
       stopTime_(-1.0),
       playbackState_(PlaybackState::UNSCHEDULED) {
   numberOfInputs_ = 0;
+  audioEventHandlerRegistry_ = context_->audioEventHandlerRegistry_;
 }
 
 void AudioScheduledSourceNode::start(double when) {
@@ -45,19 +46,13 @@ bool AudioScheduledSourceNode::isStopScheduled() {
   return playbackState_ == PlaybackState::STOP_SCHEDULED;
 }
 
-void AudioScheduledSourceNode::clearOnEndedCallback() {
-  if (onEndedCallbackId_ == 0 || context_ == nullptr ||
-      context_->audioEventHandlerRegistry_ == nullptr) {
-    return;
-  }
-
-  context_->audioEventHandlerRegistry_->unregisterHandler(
-      "ended", onEndedCallbackId_);
-  onEndedCallbackId_ = 0;
-}
-
 void AudioScheduledSourceNode::setOnEndedCallbackId(const uint64_t callbackId) {
-  onEndedCallbackId_ = callbackId;
+  auto oldCallbackId =
+      onEndedCallbackId_.exchange(callbackId, std::memory_order_acq_rel);
+
+  if (oldCallbackId != 0) {
+    audioEventHandlerRegistry_->unregisterHandler("ended", oldCallbackId);
+  }
 }
 
 void AudioScheduledSourceNode::updatePlaybackInfo(
@@ -76,7 +71,7 @@ void AudioScheduledSourceNode::updatePlaybackInfo(
   auto sampleRate = context_->getSampleRate();
 
   size_t firstFrame = context_->getCurrentSampleFrame();
-  size_t lastFrame = firstFrame + framesToProcess;
+  size_t lastFrame = firstFrame + framesToProcess - 1;
 
   size_t startFrame =
       std::max(dsp::timeToSampleFrame(startTime_, sampleRate), firstFrame);
@@ -105,7 +100,7 @@ void AudioScheduledSourceNode::updatePlaybackInfo(
         ? std::max(startFrame, firstFrame) - firstFrame
         : 0;
     nonSilentFramesToProcess =
-        std::max(std::min(lastFrame, stopFrame), startFrame) - startFrame;
+        std::max(std::min(lastFrame, stopFrame) + 1, startFrame) - startFrame;
 
     assert(startOffset <= framesToProcess);
     assert(nonSilentFramesToProcess <= framesToProcess);
@@ -124,7 +119,7 @@ void AudioScheduledSourceNode::updatePlaybackInfo(
 
   // stop will happen in this render quantum
   // zero remaining frames after stop frame
-  if (stopFrame < lastFrame && stopFrame >= firstFrame) {
+  if (stopFrame <= lastFrame && stopFrame >= firstFrame) {
     playbackState_ = PlaybackState::STOP_SCHEDULED;
     startOffset = 0;
     nonSilentFramesToProcess = stopFrame - firstFrame;
@@ -160,9 +155,10 @@ void AudioScheduledSourceNode::updatePlaybackInfo(
 void AudioScheduledSourceNode::disable() {
   AudioNode::disable();
 
-  if (context_->audioEventHandlerRegistry_ != nullptr) {
-    context_->audioEventHandlerRegistry_->invokeHandlerWithEventBody(
-        "ended", onEndedCallbackId_, {});
+  auto onEndedCallbackId = onEndedCallbackId_.load(std::memory_order_acquire);
+  if (onEndedCallbackId != 0) {
+    audioEventHandlerRegistry_->invokeHandlerWithEventBody(
+        "ended", onEndedCallbackId, {});
   }
 }
 

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

@@ -16,7 +16,7 @@
 
 namespace audioapi {
 
-class AudioEventHandlerRegistry;
+class IAudioEventHandlerRegistry;
 
 class AudioScheduledSourceNode : public AudioNode {
  public:
@@ -37,7 +37,6 @@ class AudioScheduledSourceNode : public AudioNode {
   bool isFinished();
   bool isStopScheduled();
 
-  void clearOnEndedCallback();
   void setOnEndedCallbackId(uint64_t callbackId);
 
   void disable() override;
@@ -49,6 +48,7 @@ class AudioScheduledSourceNode : public AudioNode {
   PlaybackState playbackState_;
 
   std::atomic<uint64_t> onEndedCallbackId_ = 0;
+  std::shared_ptr<IAudioEventHandlerRegistry> audioEventHandlerRegistry_;
 
   void updatePlaybackInfo(
       const std::shared_ptr<AudioBus>& processingBus,

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

@@ -25,10 +25,10 @@ StreamerNode::StreamerNode(BaseAudioContext *context)
       codecpar_(nullptr),
       pkt_(nullptr),
       frame_(nullptr),
-      bufferedBus_(nullptr),
-      audio_stream_index_(-1),
       swrCtx_(nullptr),
       resampledData_(nullptr),
+      bufferedBus_(nullptr),
+      audio_stream_index_(-1),
       maxResampledSamples_(0),
       processedSamples_(0) {}
 

package/common/cpp/audioapi/core/utils/worklets/WorkletsRunner.cpp

@@ -4,7 +4,7 @@ namespace audioapi {
 
 WorkletsRunner::WorkletsRunner(
     std::weak_ptr<worklets::WorkletRuntime> weakRuntime,
-    std::shared_ptr<worklets::SerializableWorklet> shareableWorklet,
+    const std::shared_ptr<worklets::SerializableWorklet> &shareableWorklet,
     bool shouldLockRuntime)
     : weakRuntime_(std::move(weakRuntime)),
       shouldLockRuntime(shouldLockRuntime) {
@@ -33,8 +33,8 @@ WorkletsRunner::WorkletsRunner(
 WorkletsRunner::WorkletsRunner(WorkletsRunner &&other)
     : weakRuntime_(std::move(other.weakRuntime_)),
       unsafeRuntimePtr(other.unsafeRuntimePtr),
-      shouldLockRuntime(other.shouldLockRuntime),
-      workletInitialized(other.workletInitialized) {
+      workletInitialized(other.workletInitialized),
+      shouldLockRuntime(other.shouldLockRuntime) {
   if (workletInitialized) {
     std::memcpy(&unsafeWorklet, &other.unsafeWorklet, sizeof(unsafeWorklet));
     other.workletInitialized = false;

package/common/cpp/audioapi/core/utils/worklets/WorkletsRunner.h

@@ -28,7 +28,7 @@ class WorkletsRunner {
  public:
   explicit WorkletsRunner(
     std::weak_ptr<worklets::WorkletRuntime> weakRuntime,
-    std::shared_ptr<worklets::SerializableWorklet> shareableWorklet,
+    const std::shared_ptr<worklets::SerializableWorklet>& shareableWorklet,
     bool shouldLockRuntime = true);
   WorkletsRunner(WorkletsRunner&&);
   ~WorkletsRunner();

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

@@ -20,7 +20,7 @@ class AudioEventHandlerRegistry : public IAudioEventHandlerRegistry {
   explicit AudioEventHandlerRegistry(
       jsi::Runtime *runtime,
       const std::shared_ptr<react::CallInvoker> &callInvoker);
-  ~AudioEventHandlerRegistry();
+  ~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;

package/common/cpp/test/src/AudioParamTest.cpp

@@ -8,7 +8,7 @@ using namespace audioapi;
 
 class AudioParamTest : public ::testing::Test {
  protected:
-  std::shared_ptr<IAudioEventHandlerRegistry> eventRegistry;
+  std::shared_ptr<MockAudioEventHandlerRegistry> eventRegistry;
   std::unique_ptr<OfflineAudioContext> context;
   static constexpr int sampleRate = 44100;
 

package/common/cpp/test/src/AudioScheduledSourceTest.cpp

@@ -0,0 +1,134 @@
+#include <audioapi/core/OfflineAudioContext.h>
+#include <audioapi/core/destinations/AudioDestinationNode.h>
+#include <audioapi/core/sources/AudioScheduledSourceNode.h>
+#include <audioapi/core/utils/worklets/SafeIncludes.h>
+#include <audioapi/utils/AudioBus.h>
+#include <gtest/gtest.h>
+#include <test/src/MockAudioEventHandlerRegistry.h>
+
+using namespace audioapi;
+static constexpr int SAMPLE_RATE = 44100;
+static constexpr int RENDER_QUANTUM = 128;
+static constexpr double RENDER_QUANTUM_TIME =
+    static_cast<double>(RENDER_QUANTUM) / SAMPLE_RATE;
+
+class AudioScheduledSourceTest : public ::testing::Test {
+ protected:
+  std::shared_ptr<MockAudioEventHandlerRegistry> eventRegistry;
+  std::unique_ptr<OfflineAudioContext> context;
+
+  void SetUp() override {
+    eventRegistry = std::make_shared<MockAudioEventHandlerRegistry>();
+    context = std::make_unique<OfflineAudioContext>(
+        2, 5 * SAMPLE_RATE, SAMPLE_RATE, eventRegistry, RuntimeRegistry{});
+  }
+};
+
+class TestableAudioScheduledSourceNode : public AudioScheduledSourceNode {
+ public:
+  explicit TestableAudioScheduledSourceNode(BaseAudioContext *context)
+      : AudioScheduledSourceNode(context) {
+    isInitialized_ = true;
+  }
+
+  void updatePlaybackInfo(
+      const std::shared_ptr<AudioBus> &processingBus,
+      int framesToProcess,
+      size_t &startOffset,
+      size_t &nonSilentFramesToProcess) {
+    AudioScheduledSourceNode::updatePlaybackInfo(
+        processingBus, framesToProcess, startOffset, nonSilentFramesToProcess);
+  }
+
+  std::shared_ptr<AudioBus> processNode(const std::shared_ptr<AudioBus> &, int)
+      override {
+    return nullptr;
+  }
+
+  PlaybackState getPlaybackState() const {
+    return playbackState_;
+  }
+
+  void playFrames(int frames) {
+    size_t startOffset = 0;
+    size_t nonSilentFramesToProcess = 0;
+    auto processingBus =
+        std::make_shared<AudioBus>(128, 2, static_cast<float>(SAMPLE_RATE));
+    updatePlaybackInfo(
+        processingBus, frames, startOffset, nonSilentFramesToProcess);
+    context_->getDestination()->renderAudio(processingBus, frames);
+  }
+};
+
+TEST_F(AudioScheduledSourceTest, IsUnscheduledStateSetCorrectly) {
+  auto sourceNode = TestableAudioScheduledSourceNode(context.get());
+  EXPECT_EQ(
+      sourceNode.getPlaybackState(),
+      AudioScheduledSourceNode::PlaybackState::UNSCHEDULED);
+
+  sourceNode.start(RENDER_QUANTUM_TIME);
+  EXPECT_NE(
+      sourceNode.getPlaybackState(),
+      AudioScheduledSourceNode::PlaybackState::UNSCHEDULED);
+}
+
+TEST_F(AudioScheduledSourceTest, IsScheduledStateSetCorrectly) {
+  auto sourceNode = TestableAudioScheduledSourceNode(context.get());
+  sourceNode.start(RENDER_QUANTUM_TIME);
+  EXPECT_EQ(
+      sourceNode.getPlaybackState(),
+      AudioScheduledSourceNode::PlaybackState::SCHEDULED);
+
+  sourceNode.playFrames(RENDER_QUANTUM);
+  EXPECT_EQ(
+      sourceNode.getPlaybackState(),
+      AudioScheduledSourceNode::PlaybackState::SCHEDULED);
+
+  sourceNode.playFrames(1);
+  EXPECT_NE(
+      sourceNode.getPlaybackState(),
+      AudioScheduledSourceNode::PlaybackState::SCHEDULED);
+}
+
+TEST_F(AudioScheduledSourceTest, IsPlayingStateSetCorrectly) {
+  auto sourceNode = TestableAudioScheduledSourceNode(context.get());
+  sourceNode.start(0);
+  sourceNode.stop(RENDER_QUANTUM_TIME);
+
+  sourceNode.playFrames(RENDER_QUANTUM);
+  EXPECT_EQ(
+      sourceNode.getPlaybackState(),
+      AudioScheduledSourceNode::PlaybackState::PLAYING);
+
+  sourceNode.playFrames(1);
+  EXPECT_NE(
+      sourceNode.getPlaybackState(),
+      AudioScheduledSourceNode::PlaybackState::PLAYING);
+}
+
+TEST_F(AudioScheduledSourceTest, IsStopScheduledStateSetCorrectly) {
+  auto sourceNode = TestableAudioScheduledSourceNode(context.get());
+  sourceNode.start(0);
+  sourceNode.stop(RENDER_QUANTUM_TIME);
+  sourceNode.playFrames(1); // start playing
+  sourceNode.playFrames(RENDER_QUANTUM);
+  EXPECT_EQ(
+      sourceNode.getPlaybackState(),
+      AudioScheduledSourceNode::PlaybackState::STOP_SCHEDULED);
+
+  sourceNode.playFrames(1);
+  EXPECT_NE(
+      sourceNode.getPlaybackState(),
+      AudioScheduledSourceNode::PlaybackState::STOP_SCHEDULED);
+}
+
+TEST_F(AudioScheduledSourceTest, IsFinishedStateSetCorrectly) {
+  auto sourceNode = TestableAudioScheduledSourceNode(context.get());
+  sourceNode.start(0);
+  sourceNode.stop(RENDER_QUANTUM_TIME);
+  sourceNode.playFrames(1); // start playing
+
+  sourceNode.playFrames(RENDER_QUANTUM);
+  sourceNode.playFrames(1);
+  EXPECT_TRUE(sourceNode.isFinished());
+}

package/common/cpp/test/src/ConstantSourceTest.cpp

@@ -10,7 +10,7 @@ using namespace audioapi;
 
 class ConstantSourceTest : public ::testing::Test {
  protected:
-  std::shared_ptr<IAudioEventHandlerRegistry> eventRegistry;
+  std::shared_ptr<MockAudioEventHandlerRegistry> eventRegistry;
   std::unique_ptr<OfflineAudioContext> context;
   static constexpr int sampleRate = 44100;
 

package/common/cpp/test/src/GainTest.cpp

@@ -10,7 +10,7 @@ using namespace audioapi;
 
 class GainTest : public ::testing::Test {
  protected:
-  std::shared_ptr<IAudioEventHandlerRegistry> eventRegistry;
+  std::shared_ptr<MockAudioEventHandlerRegistry> eventRegistry;
   std::unique_ptr<OfflineAudioContext> context;
   static constexpr int sampleRate = 44100;
 

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

@@ -17,8 +17,8 @@ class MockAudioEventHandlerRegistry : public IAudioEventHandlerRegistry {
   MOCK_METHOD(void, unregisterHandler,
               (const std::string &eventName, uint64_t listenerId), (override));
 
-  MOCK_METHOD(void, invokeHandlerWithEventBody,
-              (const std::string &eventName, const EventMap &body), (override));
-  MOCK_METHOD(void, invokeHandlerWithEventBody,
-              (const std::string &eventName, uint64_t listenerId, const EventMap &body), (override));
+  MOCK_METHOD2(invokeHandlerWithEventBody, void
+              (const std::string &eventName, const EventMap &body));
+  MOCK_METHOD3(invokeHandlerWithEventBody, void
+              (const std::string &eventName, uint64_t listenerId, const EventMap &body));
 };

package/common/cpp/test/src/OscillatorTest.cpp

@@ -8,7 +8,7 @@ using namespace audioapi;
 
 class OscillatorTest : public ::testing::Test {
  protected:
-  std::shared_ptr<IAudioEventHandlerRegistry> eventRegistry;
+  std::shared_ptr<MockAudioEventHandlerRegistry> eventRegistry;
   std::unique_ptr<OfflineAudioContext> context;
   static constexpr int sampleRate = 44100;
 

package/common/cpp/test/src/StereoPannerTest.cpp

@@ -10,7 +10,7 @@ using namespace audioapi;
 
 class StereoPannerTest : public ::testing::Test {
  protected:
-  std::shared_ptr<IAudioEventHandlerRegistry> eventRegistry;
+  std::shared_ptr<MockAudioEventHandlerRegistry> eventRegistry;
   std::unique_ptr<OfflineAudioContext> context;
   static constexpr int sampleRate = 44100;
 

package/common/cpp/test/src/biquad/BiquadFilterTest.h

@@ -14,7 +14,7 @@ static constexpr float tolerance = 0.0001f;
 namespace audioapi {
 class BiquadFilterTest : public ::testing::Test {
  protected:
-  std::shared_ptr<IAudioEventHandlerRegistry> eventRegistry;
+  std::shared_ptr<MockAudioEventHandlerRegistry> eventRegistry;
   std::unique_ptr<OfflineAudioContext> context;
 
   void SetUp() override {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "react-native-audio-api",
-  "version": "0.10.0-nightly-44925d7-20251104",
+  "version": "0.10.0-nightly-98d2e0d-20251106",
   "description": "react-native-audio-api provides system for controlling audio in React Native environment compatible with Web Audio API specification",
   "bin": {
     "setup-rn-audio-api-web": "./scripts/setup-rn-audio-api-web.js"