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

package/common/cpp/audioapi/core/inputs/AudioRecorder.h

@@ -1,28 +1,26 @@
 #pragma once
 
 #include <memory>
-#include <functional>
 
 namespace audioapi {
 class AudioBus;
+class CircularAudioArray;
+class AudioEventHandlerRegistry;
 
 class AudioRecorder {
  public:
   explicit AudioRecorder(
     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
-  )
-    : sampleRate_(sampleRate),
-      bufferLength_(bufferLength),
-      onError_(onError),
-      onStatusChange_(onStatusChange),
-      onAudioReady_(onAudioReady) {}
+    const std::shared_ptr<AudioEventHandlerRegistry> &audioEventHandlerRegistry
+  );
 
   virtual ~AudioRecorder() = default;
 
+  void setOnAudioReadyCallbackId(uint64_t callbackId);
+  void invokeOnAudioReadyCallback(const std::shared_ptr<AudioBus> &bus, int numFrames, double when);
+  void sendRemainingData();
+
   virtual void start() = 0;
   virtual void stop() = 0;
 
@@ -30,9 +28,11 @@ class AudioRecorder {
   float sampleRate_;
   int bufferLength_;
 
-  std::function<void(void)> onError_;
-  std::function<void(void)> onStatusChange_;
-  std::function<void(std::shared_ptr<AudioBus>, int, double)> onAudioReady_;
+  std::atomic<bool> isRunning_;
+  std::shared_ptr<CircularAudioArray> circularBuffer_;
+
+  std::shared_ptr<AudioEventHandlerRegistry> audioEventHandlerRegistry_;
+  uint64_t onAudioReadyCallbackId_ = 0;
 };
 
 } // namespace audioapi

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

@@ -22,9 +22,9 @@ AudioBufferSourceNode::AudioBufferSourceNode(
   alignedBus_ = std::shared_ptr<AudioBus>(nullptr);
 
   detuneParam_ = std::make_shared<AudioParam>(
-      0.0, MOST_NEGATIVE_SINGLE_FLOAT, MOST_POSITIVE_SINGLE_FLOAT);
+      0.0, MOST_NEGATIVE_SINGLE_FLOAT, MOST_POSITIVE_SINGLE_FLOAT, context);
   playbackRateParam_ = std::make_shared<AudioParam>(
-      1.0, MOST_NEGATIVE_SINGLE_FLOAT, MOST_POSITIVE_SINGLE_FLOAT);
+      1.0, MOST_NEGATIVE_SINGLE_FLOAT, MOST_POSITIVE_SINGLE_FLOAT, context);
 
   playbackRateBus_ = std::make_shared<AudioBus>(
       RENDER_QUANTUM_SIZE * 3, channelCount_, context_->getSampleRate());
@@ -173,7 +173,7 @@ void AudioBufferSourceNode::processWithoutPitchCorrection(
   size_t startOffset = 0;
   size_t offsetLength = 0;
 
-  auto computedPlaybackRate = getComputedPlaybackRateValue();
+  auto computedPlaybackRate = getComputedPlaybackRateValue(framesToProcess);
   updatePlaybackInfo(processingBus, framesToProcess, startOffset, offsetLength);
 
   if (computedPlaybackRate == 0.0f || (!isPlaying() && !isStopScheduled())) {
@@ -197,10 +197,12 @@ void AudioBufferSourceNode::processWithPitchCorrection(
   size_t offsetLength = 0;
 
   auto time = context_->getCurrentTime();
-  auto playbackRate =
-      std::clamp(playbackRateParam_->getValueAtTime(time), 0.0f, 3.0f);
-  auto detune =
-      std::clamp(detuneParam_->getValueAtTime(time) / 100.0f, -12.0f, 12.0f);
+  auto playbackRate = std::clamp(
+      playbackRateParam_->processKRateParam(framesToProcess, time), 0.0f, 3.0f);
+  auto detune = std::clamp(
+      detuneParam_->processKRateParam(framesToProcess, time) / 100.0f,
+      -12.0f,
+      12.0f);
 
   playbackRateBus_->zero();
 
@@ -349,13 +351,15 @@ void AudioBufferSourceNode::processWithInterpolation(
   }
 }
 
-float AudioBufferSourceNode::getComputedPlaybackRateValue() {
+float AudioBufferSourceNode::getComputedPlaybackRateValue(int framesToProcess) {
   auto time = context_->getCurrentTime();
 
   auto sampleRateFactor =
       alignedBus_->getSampleRate() / context_->getSampleRate();
-  auto playbackRate = playbackRateParam_->getValueAtTime(time);
-  auto detune = std::pow(2.0f, detuneParam_->getValueAtTime(time) / 1200.0f);
+  auto playbackRate =
+      playbackRateParam_->processKRateParam(framesToProcess, time);
+  auto detune = std::pow(
+      2.0f, detuneParam_->processKRateParam(framesToProcess, time) / 1200.0f);
 
   return playbackRate * sampleRateFactor * detune;
 }

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

@@ -81,7 +81,7 @@ class AudioBufferSourceNode : public AudioScheduledSourceNode {
       size_t offsetLength,
       float playbackRate);
 
-  float getComputedPlaybackRateValue();
+  float getComputedPlaybackRateValue(int framesToProcess);
 
   double getVirtualStartFrame();
   double getVirtualEndFrame();

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

@@ -2,6 +2,7 @@
 #include <audioapi/core/sources/AudioScheduledSourceNode.h>
 #include <audioapi/core/utils/AudioNodeManager.h>
 #include <audioapi/dsp/AudioUtils.h>
+#include <audioapi/events/AudioEventHandlerRegistry.h>
 #include <audioapi/utils/AudioArray.h>
 #include <audioapi/utils/AudioBus.h>
 
@@ -44,9 +45,8 @@ bool AudioScheduledSourceNode::isStopScheduled() {
   return playbackState_ == PlaybackState::STOP_SCHEDULED;
 }
 
-void AudioScheduledSourceNode::setOnendedCallback(
-    const std::function<void(double)> &onendedCallback) {
-  onendedCallback_ = onendedCallback;
+void AudioScheduledSourceNode::setOnEndedCallbackId(const uint64_t callbackId) {
+  onEndedCallbackId_ = callbackId;
 }
 
 void AudioScheduledSourceNode::updatePlaybackInfo(
@@ -144,9 +144,10 @@ void AudioScheduledSourceNode::updatePlaybackInfo(
 void AudioScheduledSourceNode::disable() {
   AudioNode::disable();
 
-  if (onendedCallback_) {
-    onendedCallback_(getStopTime());
-  }
+  std::unordered_map<std::string, EventValue> body = {{"value", getStopTime()}};
+
+  context_->audioEventHandlerRegistry_->invokeHandlerWithEventBody(
+      "ended", onEndedCallbackId_, body);
 }
 
 void AudioScheduledSourceNode::handleStopScheduled() {

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

@@ -16,6 +16,8 @@
 
 namespace audioapi {
 
+class AudioEventHandlerRegistry;
+
 class AudioScheduledSourceNode : public AudioNode {
  public:
   // UNSCHEDULED: The node is not scheduled to play.
@@ -35,7 +37,7 @@ class AudioScheduledSourceNode : public AudioNode {
   bool isFinished();
   bool isStopScheduled();
 
-  void setOnendedCallback(const std::function<void(double)> &onendedCallback);
+  void setOnEndedCallbackId(uint64_t callbackId);
 
   virtual double getStopTime() const = 0;
   void disable() override;
@@ -43,8 +45,6 @@ class AudioScheduledSourceNode : public AudioNode {
  protected:
   PlaybackState playbackState_;
 
-  std::function<void(double)> onendedCallback_;
-
   void updatePlaybackInfo(
       const std::shared_ptr<AudioBus>& processingBus,
       int framesToProcess,
@@ -56,6 +56,8 @@ class AudioScheduledSourceNode : public AudioNode {
  private:
   double startTime_;
   double stopTime_;
+
+  uint64_t onEndedCallbackId_ = 0;
 };
 
 } // namespace audioapi

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

@@ -9,11 +9,15 @@ namespace audioapi {
 OscillatorNode::OscillatorNode(BaseAudioContext *context)
     : AudioScheduledSourceNode(context) {
   frequencyParam_ = std::make_shared<AudioParam>(
-      444.0, -context_->getNyquistFrequency(), context_->getNyquistFrequency());
+      444.0,
+      -context_->getNyquistFrequency(),
+      context_->getNyquistFrequency(),
+      context);
   detuneParam_ = std::make_shared<AudioParam>(
       0.0,
       -1200 * LOG2_MOST_POSITIVE_SINGLE_FLOAT,
-      1200 * LOG2_MOST_POSITIVE_SINGLE_FLOAT);
+      1200 * LOG2_MOST_POSITIVE_SINGLE_FLOAT,
+      context);
   type_ = OscillatorType::SINE;
   periodicWave_ = context_->getBasicWaveForm(type_);
 
@@ -56,15 +60,18 @@ void OscillatorNode::processNode(
     return;
   }
 
-  auto deltaTime = 1.0 / context_->getSampleRate();
-  auto time =
-      context_->getCurrentTime() + static_cast<double>(startOffset) * deltaTime;
+  auto time = context_->getCurrentTime() +
+      static_cast<double>(startOffset) * 1.0 / context_->getSampleRate();
+  auto detuneParamValues =
+      detuneParam_->processARateParam(framesToProcess, time);
+  auto frequencyParamValues =
+      frequencyParam_->processARateParam(framesToProcess, time);
 
   for (size_t i = startOffset; i < offsetLength; i += 1) {
-    auto detuneRatio =
-        std::pow(2.0f, detuneParam_->getValueAtTime(time) / 1200.0f);
+    auto detuneRatio = std::pow(
+        2.0f, detuneParamValues->getChannel(0)->getData()[i] / 1200.0f);
     auto detunedFrequency =
-        round(frequencyParam_->getValueAtTime(time) * detuneRatio);
+        frequencyParamValues->getChannel(0)->getData()[i] * detuneRatio;
     auto phaseIncrement = detunedFrequency * periodicWave_->getScale();
 
     float sample =
@@ -79,8 +86,6 @@ void OscillatorNode::processNode(
         floor(
             phase_ / static_cast<float>(periodicWave_->getPeriodicWaveSize())) *
         static_cast<float>(periodicWave_->getPeriodicWaveSize());
-
-    time += deltaTime;
   }
 
   handleStopScheduled();

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

@@ -1,4 +1,5 @@
 #include <audioapi/core/AudioNode.h>
+#include <audioapi/core/AudioParam.h>
 #include <audioapi/core/sources/AudioScheduledSourceNode.h>
 #include <audioapi/core/utils/AudioNodeManager.h>
 #include <audioapi/core/utils/Locker.h>
@@ -9,7 +10,7 @@ AudioNodeManager::~AudioNodeManager() {
   cleanup();
 }
 
-void AudioNodeManager::addPendingConnection(
+void AudioNodeManager::addPendingNodeConnection(
     const std::shared_ptr<AudioNode> &from,
     const std::shared_ptr<AudioNode> &to,
     ConnectionType type) {
@@ -18,6 +19,15 @@ void AudioNodeManager::addPendingConnection(
   audioNodesToConnect_.emplace_back(from, to, type);
 }
 
+void AudioNodeManager::addPendingParamConnection(
+    const std::shared_ptr<AudioNode> &from,
+    const std::shared_ptr<AudioParam> &to,
+    ConnectionType type) {
+  Locker lock(getGraphLock());
+
+  audioParamToConnect_.emplace_back(from, to, type);
+}
+
 void AudioNodeManager::preProcessGraph() {
   if (auto locker = Locker::tryLock(getGraphLock())) {
     settlePendingConnections();
@@ -41,6 +51,11 @@ void AudioNodeManager::addSourceNode(
   sourceNodes_.insert(node);
 }
 
+void AudioNodeManager::addAudioParam(const std::shared_ptr<AudioParam> &param) {
+  Locker lock(getGraphLock());
+  audioParams_.insert(param);
+}
+
 void AudioNodeManager::settlePendingConnections() {
   for (auto it = audioNodesToConnect_.begin(), end = audioNodesToConnect_.end();
        it != end;
@@ -60,6 +75,25 @@ void AudioNodeManager::settlePendingConnections() {
   }
 
   audioNodesToConnect_.clear();
+
+  for (auto it = audioParamToConnect_.begin(), end = audioParamToConnect_.end();
+       it != end;
+       ++it) {
+    std::shared_ptr<AudioNode> from = std::get<0>(*it);
+    std::shared_ptr<AudioParam> to = std::get<1>(*it);
+    ConnectionType type = std::get<2>(*it);
+
+    assert(from != nullptr);
+    assert(to != nullptr);
+
+    if (type == ConnectionType::CONNECT) {
+      from->connectParam(to);
+    } else {
+      from->disconnectParam(to);
+    }
+  }
+
+  audioParamToConnect_.clear();
 }
 
 void AudioNodeManager::cleanupNode(const std::shared_ptr<AudioNode> &node) {

package/common/cpp/audioapi/core/utils/AudioNodeManager.h

@@ -12,6 +12,7 @@ namespace audioapi {
 
 class AudioNode;
 class AudioScheduledSourceNode;
+class AudioParam;
 
 class AudioNodeManager {
  public:
@@ -23,13 +24,19 @@ class AudioNodeManager {
 
   void preProcessGraph();
 
-  void addPendingConnection(
+  void addPendingNodeConnection(
       const std::shared_ptr<AudioNode> &from,
       const std::shared_ptr<AudioNode> &to,
       ConnectionType type);
 
+  void addPendingParamConnection(
+      const std::shared_ptr<AudioNode> &from,
+      const std::shared_ptr<AudioParam> &to,
+    ConnectionType type);
+
   void addProcessingNode(const std::shared_ptr<AudioNode> &node);
   void addSourceNode(const std::shared_ptr<AudioScheduledSourceNode> &node);
+  void addAudioParam(const std::shared_ptr<AudioParam> &param);
 
   void cleanup();
 
@@ -40,6 +47,7 @@ class AudioNodeManager {
   // all nodes created in the context
   std::unordered_set<std::shared_ptr<AudioScheduledSourceNode>> sourceNodes_;
   std::unordered_set<std::shared_ptr<AudioNode>> processingNodes_;
+  std::unordered_set<std::shared_ptr<AudioParam>> audioParams_;
 
   // connections to be settled
   std::vector<std::tuple<
@@ -48,6 +56,12 @@ class AudioNodeManager {
       ConnectionType>>
       audioNodesToConnect_;
 
+  std::vector<std::tuple<
+      std::shared_ptr<AudioNode>,
+      std::shared_ptr<AudioParam>,
+      ConnectionType>>
+      audioParamToConnect_;
+
   void settlePendingConnections();
   void cleanupNode(const std::shared_ptr<AudioNode> &node);
   void prepareNodesForDestruction();

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

@@ -0,0 +1,108 @@
+#include <audioapi/events/AudioEventHandlerRegistry.h>
+
+namespace audioapi {
+
+AudioEventHandlerRegistry::AudioEventHandlerRegistry(
+    jsi::Runtime *runtime,
+    const std::shared_ptr<react::CallInvoker> &callInvoker) {
+  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)] = {};
+  }
+}
+
+AudioEventHandlerRegistry::~AudioEventHandlerRegistry() {
+  eventHandlers_.clear();
+}
+
+uint64_t AudioEventHandlerRegistry::registerHandler(
+    const std::string &eventName,
+    const std::shared_ptr<jsi::Function> &handler) {
+  static uint64_t LISTENER_ID = 0;
+
+  eventHandlers_[eventName][LISTENER_ID] = handler;
+
+  return LISTENER_ID++;
+}
+
+void AudioEventHandlerRegistry::unregisterHandler(
+    const std::string &eventName,
+    uint64_t listenerId) {
+  auto it = eventHandlers_.find(eventName);
+  if (it != eventHandlers_.end()) {
+    it->second.erase(listenerId);
+  }
+}
+
+void AudioEventHandlerRegistry::invokeHandlerWithEventBody(
+    const std::string &eventName,
+    const std::unordered_map<std::string, EventValue> &body) {
+  auto it = eventHandlers_.find(eventName);
+  if (it != eventHandlers_.end()) {
+    for (const auto &pair : it->second) {
+      auto handler = pair.second;
+      if (handler) {
+        callInvoker_->invokeAsync([this, handler, body]() {
+          auto eventObject = createEventObject(body);
+          handler->call(*runtime_, eventObject);
+        });
+      }
+    }
+  }
+}
+
+void AudioEventHandlerRegistry::invokeHandlerWithEventBody(
+    const std::string &eventName,
+    uint64_t listenerId,
+    const std::unordered_map<std::string, EventValue> &body) {
+  auto it = eventHandlers_.find(eventName);
+  if (it != eventHandlers_.end()) {
+    auto handlersMap = it->second;
+    auto handlerIt = handlersMap.find(listenerId);
+    if (handlerIt != handlersMap.end()) {
+      auto handler = handlerIt->second;
+      if (handler) {
+        callInvoker_->invokeAsync([this, handler, body]() {
+          auto eventObject = createEventObject(body);
+          handler->call(*runtime_, eventObject);
+        });
+      }
+    }
+  }
+}
+
+jsi::Object AudioEventHandlerRegistry::createEventObject(
+    const std::unordered_map<std::string, EventValue> &body) {
+  auto eventObject = jsi::Object(*runtime_);
+
+  for (const auto &pair : body) {
+    const auto name = pair.first.data();
+    const auto &value = pair.second;
+
+    if (holds_alternative<int>(value)) {
+      eventObject.setProperty(*runtime_, name, get<int>(value));
+    } else if (holds_alternative<double>(value)) {
+      eventObject.setProperty(*runtime_, name, get<double>(value));
+    } else if (holds_alternative<float>(value)) {
+      eventObject.setProperty(*runtime_, name, get<float>(value));
+    } else if (holds_alternative<bool>(value)) {
+      eventObject.setProperty(*runtime_, name, get<bool>(value));
+    } else if (holds_alternative<std::string>(value)) {
+      eventObject.setProperty(*runtime_, name, get<std::string>(value));
+    } else if (holds_alternative<std::shared_ptr<jsi::HostObject>>(value)) {
+      auto hostObject = jsi::Object::createFromHostObject(
+          *runtime_, get<std::shared_ptr<jsi::HostObject>>(value));
+      eventObject.setProperty(*runtime_, name, hostObject);
+    }
+  }
+
+  return eventObject;
+}
+
+} // namespace audioapi

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

@@ -0,0 +1,62 @@
+#pragma once
+
+#include <jsi/jsi.h>
+#include <ReactCommon/CallInvoker.h>
+#include <memory>
+#include <unordered_map>
+#include <array>
+#include <string>
+#include <variant>
+
+namespace audioapi {
+using namespace facebook;
+
+using EventValue = std::variant<int, float, double, std::string, bool, std::shared_ptr<jsi::HostObject>>;
+
+class AudioEventHandlerRegistry {
+ public:
+  explicit AudioEventHandlerRegistry(
+      jsi::Runtime *runtime,
+      const std::shared_ptr<react::CallInvoker> &callInvoker);
+  ~AudioEventHandlerRegistry();
+
+  uint64_t registerHandler(const std::string &eventName, const std::shared_ptr<jsi::Function> &handler);
+  void unregisterHandler(const std::string &eventName, uint64_t listenerId);
+
+  void invokeHandlerWithEventBody(const std::string &eventName, const std::unordered_map<std::string, EventValue> &body);
+  void invokeHandlerWithEventBody(const std::string &eventName, uint64_t listenerId, const std::unordered_map<std::string, EventValue> &body);
+
+ private:
+    std::shared_ptr<react::CallInvoker> callInvoker_;
+    jsi::Runtime *runtime_;
+    std::unordered_map<std::string, 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, 4> AUDIO_API_EVENT_NAMES = {
+      "ended",
+      "audioReady",
+      "audioError",
+      "systemStateChanged"
+    };
+
+    jsi::Object createEventObject(const std::unordered_map<std::string, EventValue> &body);
+};
+
+} // namespace audioapi

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

@@ -0,0 +1,48 @@
+#pragma once
+
+#include <audioapi/jsi/JsiHostObject.h>
+#include <audioapi/events/AudioEventHandlerRegistry.h>
+
+#include <jsi/jsi.h>
+#include <ReactCommon/CallInvoker.h>
+#include <memory>
+#include <unordered_map>
+#include <vector>
+#include <string>
+
+namespace audioapi {
+using namespace facebook;
+
+class AudioEventHandlerRegistryHostObject : public JsiHostObject {
+ public:
+    explicit AudioEventHandlerRegistryHostObject(const std::shared_ptr<AudioEventHandlerRegistry>& eventHandlerRegistry) {
+        eventHandlerRegistry_ = eventHandlerRegistry;
+
+        addFunctions(
+          JSI_EXPORT_FUNCTION(AudioEventHandlerRegistryHostObject, addAudioEventListener),
+          JSI_EXPORT_FUNCTION(AudioEventHandlerRegistryHostObject, removeAudioEventListener));
+    }
+
+    JSI_HOST_FUNCTION(addAudioEventListener) {
+      auto eventName = args[0].getString(runtime).utf8(runtime);
+      auto callback = std::make_shared<jsi::Function>(args[1].getObject(runtime).getFunction(runtime));
+
+      auto listenerId = eventHandlerRegistry_->registerHandler(eventName, callback);
+
+      return jsi::String::createFromUtf8(runtime, std::to_string(listenerId));
+    }
+
+    JSI_HOST_FUNCTION(removeAudioEventListener) {
+        auto eventName = args[0].getString(runtime).utf8(runtime);
+        uint64_t listenerId = std::stoull(args[1].getString(runtime).utf8(runtime));
+
+        eventHandlerRegistry_->unregisterHandler(eventName, listenerId);
+
+        return jsi::Value::undefined();
+    }
+
+ private:
+    std::shared_ptr<AudioEventHandlerRegistry> eventHandlerRegistry_;
+};
+} // namespace audioapi
+

package/common/cpp/audioapi/jsi/JsiPromise.cpp

@@ -44,10 +44,9 @@ jsi::Value PromiseVendor::createPromise(
 
         auto rejectWrapper = [reject, &runtime, callInvoker](
                                  const std::string &errorMessage) -> void {
-          auto error = jsi::JSError(runtime, errorMessage);
-          auto errorShared = std::make_shared<jsi::JSError>(error);
-          callInvoker->invokeAsync([reject, &runtime, errorShared]() -> void {
-            reject->call(runtime, errorShared->value());
+          callInvoker->invokeAsync([reject, &runtime, errorMessage]() -> void {
+            auto error = jsi::JSError(runtime, errorMessage);
+            reject->call(runtime, error.value());
           });
         };
 

package/ios/audioapi/ios/AudioAPIModule.h

@@ -7,10 +7,23 @@
 
 #import <React/RCTEventEmitter.h>
 
+@class AudioEngine;
+@class NotificationManager;
+@class AudioSessionManager;
+@class LockScreenManager;
+
 @interface AudioAPIModule : RCTEventEmitter
 #ifdef RCT_NEW_ARCH_ENABLED
                             <NativeAudioAPIModuleSpec, RCTCallInvokerModule>
 #else
                             <RCTBridgeModule>
 #endif // RCT_NEW_ARCH_ENABLED
+
+@property (nonatomic, strong) AudioEngine *audioEngine;
+@property (nonatomic, strong) NotificationManager *notificationManager;
+@property (nonatomic, strong) AudioSessionManager *audioSessionManager;
+@property (nonatomic, strong) LockScreenManager *lockScreenManager;
+
+- (void)invokeHandlerWithEventName:(NSString *)eventName eventBody:(NSDictionary *)eventBody;
+
 @end