react-native-audio-api 0.8.3 → 0.9.0

package/common/cpp/audioapi/HostObjects/OfflineAudioContextHostObject.cpp

@@ -0,0 +1,70 @@
+#include <audioapi/HostObjects/OfflineAudioContextHostObject.h>
+
+#include <audioapi/HostObjects/sources/AudioBufferHostObject.h>
+#include <audioapi/core/OfflineAudioContext.h>
+
+namespace audioapi {
+
+OfflineAudioContextHostObject::OfflineAudioContextHostObject(
+    const std::shared_ptr<OfflineAudioContext> &offlineAudioContext,
+    jsi::Runtime *runtime,
+    const std::shared_ptr<react::CallInvoker> &callInvoker)
+    : BaseAudioContextHostObject(offlineAudioContext, runtime, callInvoker) {
+  addFunctions(
+      JSI_EXPORT_FUNCTION(OfflineAudioContextHostObject, resume),
+      JSI_EXPORT_FUNCTION(OfflineAudioContextHostObject, suspend),
+      JSI_EXPORT_FUNCTION(OfflineAudioContextHostObject, startRendering));
+}
+
+JSI_HOST_FUNCTION_IMPL(OfflineAudioContextHostObject, resume) {
+  auto promise = promiseVendor_->createPromise(
+      [this](const std::shared_ptr<Promise> &promise) {
+        auto audioContext =
+            std::static_pointer_cast<OfflineAudioContext>(context_);
+        audioContext->resume();
+      });
+
+  return promise;
+}
+
+JSI_HOST_FUNCTION_IMPL(OfflineAudioContextHostObject, suspend) {
+  double when = args[0].getNumber();
+
+  auto promise = promiseVendor_->createPromise(
+      [this, when](const std::shared_ptr<Promise> &promise) {
+        auto audioContext =
+            std::static_pointer_cast<OfflineAudioContext>(context_);
+        OfflineAudioContextSuspendCallback callback = [promise]() {
+          promise->resolve(
+              [](jsi::Runtime &runtime) { return jsi::Value::undefined(); });
+        };
+        audioContext->suspend(when, callback);
+      });
+
+  return promise;
+}
+
+JSI_HOST_FUNCTION_IMPL(OfflineAudioContextHostObject, startRendering) {
+  auto promise = promiseVendor_->createPromise(
+      [this](const std::shared_ptr<Promise> &promise) {
+        auto audioContext =
+            std::static_pointer_cast<OfflineAudioContext>(context_);
+
+        OfflineAudioContextResultCallback callback =
+            [promise](const std::shared_ptr<AudioBuffer> &audioBuffer) -> void {
+          auto audioBufferHostObject =
+              std::make_shared<AudioBufferHostObject>(audioBuffer);
+          promise->resolve([audioBufferHostObject = std::move(
+                                audioBufferHostObject)](jsi::Runtime &runtime) {
+            return jsi::Object::createFromHostObject(
+                runtime, audioBufferHostObject);
+          });
+        };
+
+        audioContext->startRendering(callback);
+      });
+
+  return promise;
+}
+
+} // namespace audioapi

package/common/cpp/audioapi/HostObjects/OfflineAudioContextHostObject.h

@@ -1,6 +1,5 @@
 #pragma once
 
-#include <audioapi/core/OfflineAudioContext.h>
 #include <audioapi/HostObjects/BaseAudioContextHostObject.h>
 
 #include <jsi/jsi.h>
@@ -11,60 +10,17 @@
 namespace audioapi {
 using namespace facebook;
 
+class OfflineAudioContext;
+
 class OfflineAudioContextHostObject : public BaseAudioContextHostObject {
  public:
   explicit OfflineAudioContextHostObject(
           const std::shared_ptr<OfflineAudioContext> &offlineAudioContext,
           jsi::Runtime *runtime,
-          const std::shared_ptr<react::CallInvoker> &callInvoker)
-      : BaseAudioContextHostObject(offlineAudioContext, runtime, callInvoker) {
-    addFunctions(
-      JSI_EXPORT_FUNCTION(OfflineAudioContextHostObject, resume),
-      JSI_EXPORT_FUNCTION(OfflineAudioContextHostObject, suspend),
-      JSI_EXPORT_FUNCTION(OfflineAudioContextHostObject, startRendering));
-  }
-
-  JSI_HOST_FUNCTION(resume) {
-    auto promise = promiseVendor_->createPromise([this](const std::shared_ptr<Promise>& promise) {
-      auto audioContext = std::static_pointer_cast<OfflineAudioContext>(context_);
-      audioContext->resume();
-    });
-
-    return promise;
-  }
-
-  JSI_HOST_FUNCTION(suspend) {
-    double when = args[0].getNumber();
-
-    auto promise = promiseVendor_->createPromise([this, when](const std::shared_ptr<Promise>& promise) {
-      auto audioContext = std::static_pointer_cast<OfflineAudioContext>(context_);
-      OfflineAudioContextSuspendCallback callback = [promise]() {
-        promise->resolve([](jsi::Runtime &runtime) {
-          return jsi::Value::undefined();
-        });
-      };
-      audioContext->suspend(when, callback);
-    });
-
-    return promise;
-  }
-
-  JSI_HOST_FUNCTION(startRendering) {
-    auto promise = promiseVendor_->createPromise([this](const std::shared_ptr<Promise>& promise) {
-      auto audioContext = std::static_pointer_cast<OfflineAudioContext>(context_);
-
-      OfflineAudioContextResultCallback callback =
-          [promise](const std::shared_ptr<AudioBuffer>& audioBuffer) -> void {
-        auto audioBufferHostObject = std::make_shared<AudioBufferHostObject>(audioBuffer);
-        promise->resolve([audioBufferHostObject = std::move(audioBufferHostObject)](jsi::Runtime &runtime) {
-          return jsi::Object::createFromHostObject(runtime, audioBufferHostObject);
-        });
-      };
-
-      audioContext->startRendering(callback);
-    });
+          const std::shared_ptr<react::CallInvoker> &callInvoker);
 
-    return promise;
-  }
+  JSI_HOST_FUNCTION_DECL(resume);
+  JSI_HOST_FUNCTION_DECL(suspend);
+  JSI_HOST_FUNCTION_DECL(startRendering);
 };
 } // namespace audioapi

package/common/cpp/audioapi/HostObjects/WorkletNodeHostObject.h

@@ -0,0 +1,18 @@
+#pragma once
+
+#include <audioapi/HostObjects/AudioNodeHostObject.h>
+#include <audioapi/core/effects/WorkletNode.h>
+
+#include <memory>
+#include <vector>
+
+namespace audioapi {
+using namespace facebook;
+
+class WorkletNodeHostObject : public AudioNodeHostObject {
+ public:
+  explicit WorkletNodeHostObject(const std::shared_ptr<WorkletNode> &node)
+      : AudioNodeHostObject(node) {
+  }
+};
+} // namespace audioapi

package/common/cpp/audioapi/HostObjects/WorkletProcessingNodeHostObject.h

@@ -0,0 +1,18 @@
+#pragma once
+
+#include <audioapi/HostObjects/AudioNodeHostObject.h>
+#include <audioapi/core/effects/WorkletProcessingNode.h>
+
+#include <memory>
+#include <vector>
+
+namespace audioapi {
+using namespace facebook;
+
+class WorkletProcessingNodeHostObject : public AudioNodeHostObject {
+ public:
+  explicit WorkletProcessingNodeHostObject(const std::shared_ptr<WorkletProcessingNode> &node)
+      : AudioNodeHostObject(node) {
+  }
+};
+} // namespace audioapi

package/common/cpp/audioapi/HostObjects/analysis/AnalyserNodeHostObject.cpp

@@ -0,0 +1,148 @@
+#include <audioapi/HostObjects/analysis/AnalyserNodeHostObject.h>
+
+#include <audioapi/core/analysis/AnalyserNode.h>
+
+namespace audioapi {
+
+AnalyserNodeHostObject::AnalyserNodeHostObject(
+    const std::shared_ptr<AnalyserNode> &node)
+    : AudioNodeHostObject(node) {
+  addGetters(
+      JSI_EXPORT_PROPERTY_GETTER(AnalyserNodeHostObject, fftSize),
+      JSI_EXPORT_PROPERTY_GETTER(AnalyserNodeHostObject, frequencyBinCount),
+      JSI_EXPORT_PROPERTY_GETTER(AnalyserNodeHostObject, minDecibels),
+      JSI_EXPORT_PROPERTY_GETTER(AnalyserNodeHostObject, maxDecibels),
+      JSI_EXPORT_PROPERTY_GETTER(AnalyserNodeHostObject, smoothingTimeConstant),
+      JSI_EXPORT_PROPERTY_GETTER(AnalyserNodeHostObject, window));
+
+  addSetters(
+      JSI_EXPORT_PROPERTY_SETTER(AnalyserNodeHostObject, fftSize),
+      JSI_EXPORT_PROPERTY_SETTER(AnalyserNodeHostObject, minDecibels),
+      JSI_EXPORT_PROPERTY_SETTER(AnalyserNodeHostObject, maxDecibels),
+      JSI_EXPORT_PROPERTY_SETTER(AnalyserNodeHostObject, smoothingTimeConstant),
+      JSI_EXPORT_PROPERTY_SETTER(AnalyserNodeHostObject, window));
+
+  addFunctions(
+      JSI_EXPORT_FUNCTION(AnalyserNodeHostObject, getFloatFrequencyData),
+      JSI_EXPORT_FUNCTION(AnalyserNodeHostObject, getByteFrequencyData),
+      JSI_EXPORT_FUNCTION(AnalyserNodeHostObject, getFloatTimeDomainData),
+      JSI_EXPORT_FUNCTION(AnalyserNodeHostObject, getByteTimeDomainData));
+}
+
+JSI_PROPERTY_GETTER_IMPL(AnalyserNodeHostObject, fftSize) {
+  auto analyserNode = std::static_pointer_cast<AnalyserNode>(node_);
+  return {static_cast<int>(analyserNode->getFftSize())};
+}
+
+JSI_PROPERTY_GETTER_IMPL(AnalyserNodeHostObject, frequencyBinCount) {
+  auto analyserNode = std::static_pointer_cast<AnalyserNode>(node_);
+  return {static_cast<int>(analyserNode->getFrequencyBinCount())};
+}
+
+JSI_PROPERTY_GETTER_IMPL(AnalyserNodeHostObject, minDecibels) {
+  auto analyserNode = std::static_pointer_cast<AnalyserNode>(node_);
+  return {analyserNode->getMinDecibels()};
+}
+
+JSI_PROPERTY_GETTER_IMPL(AnalyserNodeHostObject, maxDecibels) {
+  auto analyserNode = std::static_pointer_cast<AnalyserNode>(node_);
+  return {analyserNode->getMaxDecibels()};
+}
+
+JSI_PROPERTY_GETTER_IMPL(AnalyserNodeHostObject, smoothingTimeConstant) {
+  auto analyserNode = std::static_pointer_cast<AnalyserNode>(node_);
+  return {analyserNode->getSmoothingTimeConstant()};
+}
+
+JSI_PROPERTY_GETTER_IMPL(AnalyserNodeHostObject, window) {
+  auto analyserNode = std::static_pointer_cast<AnalyserNode>(node_);
+  auto windowType = analyserNode->getWindowType();
+  return jsi::String::createFromUtf8(runtime, windowType);
+}
+
+JSI_PROPERTY_SETTER_IMPL(AnalyserNodeHostObject, fftSize) {
+  auto analyserNode = std::static_pointer_cast<AnalyserNode>(node_);
+  auto fftSize = static_cast<int>(value.getNumber());
+  analyserNode->setFftSize(fftSize);
+}
+
+JSI_PROPERTY_SETTER_IMPL(AnalyserNodeHostObject, minDecibels) {
+  auto analyserNode = std::static_pointer_cast<AnalyserNode>(node_);
+  auto minDecibels = static_cast<float>(value.getNumber());
+  analyserNode->setMinDecibels(minDecibels);
+}
+
+JSI_PROPERTY_SETTER_IMPL(AnalyserNodeHostObject, maxDecibels) {
+  auto analyserNode = std::static_pointer_cast<AnalyserNode>(node_);
+  auto maxDecibels = static_cast<float>(value.getNumber());
+  analyserNode->setMaxDecibels(maxDecibels);
+}
+
+JSI_PROPERTY_SETTER_IMPL(AnalyserNodeHostObject, smoothingTimeConstant) {
+  auto analyserNode = std::static_pointer_cast<AnalyserNode>(node_);
+  auto smoothingTimeConstant = static_cast<float>(value.getNumber());
+  analyserNode->setSmoothingTimeConstant(smoothingTimeConstant);
+}
+
+JSI_PROPERTY_SETTER_IMPL(AnalyserNodeHostObject, window) {
+  auto analyserNode = std::static_pointer_cast<AnalyserNode>(node_);
+  analyserNode->setWindowType(value.getString(runtime).utf8(runtime));
+}
+
+JSI_HOST_FUNCTION_IMPL(AnalyserNodeHostObject, getFloatFrequencyData) {
+  auto arrayBuffer = args[0]
+                         .getObject(runtime)
+                         .getPropertyAsObject(runtime, "buffer")
+                         .getArrayBuffer(runtime);
+  auto data = reinterpret_cast<float *>(arrayBuffer.data(runtime));
+  auto length = static_cast<int>(arrayBuffer.size(runtime));
+
+  auto analyserNode = std::static_pointer_cast<AnalyserNode>(node_);
+  analyserNode->getFloatFrequencyData(data, length);
+
+  return jsi::Value::undefined();
+}
+
+JSI_HOST_FUNCTION_IMPL(AnalyserNodeHostObject, getByteFrequencyData) {
+  auto arrayBuffer = args[0]
+                         .getObject(runtime)
+                         .getPropertyAsObject(runtime, "buffer")
+                         .getArrayBuffer(runtime);
+  auto data = arrayBuffer.data(runtime);
+  auto length = static_cast<int>(arrayBuffer.size(runtime));
+
+  auto analyserNode = std::static_pointer_cast<AnalyserNode>(node_);
+  analyserNode->getByteFrequencyData(data, length);
+
+  return jsi::Value::undefined();
+}
+
+JSI_HOST_FUNCTION_IMPL(AnalyserNodeHostObject, getFloatTimeDomainData) {
+  auto arrayBuffer = args[0]
+                         .getObject(runtime)
+                         .getPropertyAsObject(runtime, "buffer")
+                         .getArrayBuffer(runtime);
+  auto data = reinterpret_cast<float *>(arrayBuffer.data(runtime));
+  auto length = static_cast<int>(arrayBuffer.size(runtime));
+
+  auto analyserNode = std::static_pointer_cast<AnalyserNode>(node_);
+  analyserNode->getFloatTimeDomainData(data, length);
+
+  return jsi::Value::undefined();
+}
+
+JSI_HOST_FUNCTION_IMPL(AnalyserNodeHostObject, getByteTimeDomainData) {
+  auto arrayBuffer = args[0]
+                         .getObject(runtime)
+                         .getPropertyAsObject(runtime, "buffer")
+                         .getArrayBuffer(runtime);
+  auto data = arrayBuffer.data(runtime);
+  auto length = static_cast<int>(arrayBuffer.size(runtime));
+
+  auto analyserNode = std::static_pointer_cast<AnalyserNode>(node_);
+  analyserNode->getByteTimeDomainData(data, length);
+
+  return jsi::Value::undefined();
+}
+
+} // namespace audioapi

package/common/cpp/audioapi/HostObjects/analysis/AnalyserNodeHostObject.h

@@ -0,0 +1,37 @@
+#pragma once
+
+#include <audioapi/HostObjects/AudioNodeHostObject.h>
+
+#include <memory>
+#include <string>
+#include <vector>
+
+namespace audioapi {
+using namespace facebook;
+
+class AnalyserNode;
+
+class AnalyserNodeHostObject : public AudioNodeHostObject {
+ public:
+  explicit AnalyserNodeHostObject(const std::shared_ptr<AnalyserNode> &node);
+
+  JSI_PROPERTY_GETTER_DECL(fftSize);
+  JSI_PROPERTY_GETTER_DECL(frequencyBinCount);
+  JSI_PROPERTY_GETTER_DECL(minDecibels);
+  JSI_PROPERTY_GETTER_DECL(maxDecibels);
+  JSI_PROPERTY_GETTER_DECL(smoothingTimeConstant);
+  JSI_PROPERTY_GETTER_DECL(window);
+
+  JSI_PROPERTY_SETTER_DECL(fftSize);
+  JSI_PROPERTY_SETTER_DECL(minDecibels);
+  JSI_PROPERTY_SETTER_DECL(maxDecibels);
+  JSI_PROPERTY_SETTER_DECL(smoothingTimeConstant);
+  JSI_PROPERTY_SETTER_DECL(window);
+
+  JSI_HOST_FUNCTION_DECL(getFloatFrequencyData);
+  JSI_HOST_FUNCTION_DECL(getByteFrequencyData);
+  JSI_HOST_FUNCTION_DECL(getFloatTimeDomainData);
+  JSI_HOST_FUNCTION_DECL(getByteTimeDomainData);
+};
+
+} // namespace audioapi

package/common/cpp/audioapi/HostObjects/effects/BiquadFilterNodeHostObject.cpp

@@ -0,0 +1,92 @@
+#include <audioapi/HostObjects/effects/BiquadFilterNodeHostObject.h>
+
+#include <audioapi/HostObjects/AudioParamHostObject.h>
+#include <audioapi/core/effects/BiquadFilterNode.h>
+
+namespace audioapi {
+
+BiquadFilterNodeHostObject::BiquadFilterNodeHostObject(
+    const std::shared_ptr<BiquadFilterNode> &node)
+    : AudioNodeHostObject(node) {
+  addGetters(
+      JSI_EXPORT_PROPERTY_GETTER(BiquadFilterNodeHostObject, frequency),
+      JSI_EXPORT_PROPERTY_GETTER(BiquadFilterNodeHostObject, detune),
+      JSI_EXPORT_PROPERTY_GETTER(BiquadFilterNodeHostObject, Q),
+      JSI_EXPORT_PROPERTY_GETTER(BiquadFilterNodeHostObject, gain),
+      JSI_EXPORT_PROPERTY_GETTER(BiquadFilterNodeHostObject, type));
+
+  addSetters(JSI_EXPORT_PROPERTY_SETTER(BiquadFilterNodeHostObject, type));
+
+  addFunctions(
+      JSI_EXPORT_FUNCTION(BiquadFilterNodeHostObject, getFrequencyResponse));
+}
+
+JSI_PROPERTY_GETTER_IMPL(BiquadFilterNodeHostObject, frequency) {
+  auto biquadFilterNode = std::static_pointer_cast<BiquadFilterNode>(node_);
+  auto frequencyParam_ = std::make_shared<AudioParamHostObject>(
+      biquadFilterNode->getFrequencyParam());
+  return jsi::Object::createFromHostObject(runtime, frequencyParam_);
+}
+
+JSI_PROPERTY_GETTER_IMPL(BiquadFilterNodeHostObject, detune) {
+  auto biquadFilterNode = std::static_pointer_cast<BiquadFilterNode>(node_);
+  auto detuneParam_ = std::make_shared<AudioParamHostObject>(
+      biquadFilterNode->getDetuneParam());
+  return jsi::Object::createFromHostObject(runtime, detuneParam_);
+}
+
+JSI_PROPERTY_GETTER_IMPL(BiquadFilterNodeHostObject, Q) {
+  auto biquadFilterNode = std::static_pointer_cast<BiquadFilterNode>(node_);
+  auto QParam_ =
+      std::make_shared<AudioParamHostObject>(biquadFilterNode->getQParam());
+  return jsi::Object::createFromHostObject(runtime, QParam_);
+}
+
+JSI_PROPERTY_GETTER_IMPL(BiquadFilterNodeHostObject, gain) {
+  auto biquadFilterNode = std::static_pointer_cast<BiquadFilterNode>(node_);
+  auto gainParam_ =
+      std::make_shared<AudioParamHostObject>(biquadFilterNode->getGainParam());
+  return jsi::Object::createFromHostObject(runtime, gainParam_);
+}
+
+JSI_PROPERTY_GETTER_IMPL(BiquadFilterNodeHostObject, type) {
+  auto biquadFilterNode = std::static_pointer_cast<BiquadFilterNode>(node_);
+  auto type = biquadFilterNode->getType();
+  return jsi::String::createFromUtf8(runtime, type);
+}
+
+JSI_PROPERTY_SETTER_IMPL(BiquadFilterNodeHostObject, type) {
+  auto biquadFilterNode = std::static_pointer_cast<BiquadFilterNode>(node_);
+  biquadFilterNode->setType(value.getString(runtime).utf8(runtime));
+}
+
+JSI_HOST_FUNCTION_IMPL(BiquadFilterNodeHostObject, getFrequencyResponse) {
+  auto arrayBufferFrequency = args[0]
+                                  .getObject(runtime)
+                                  .getPropertyAsObject(runtime, "buffer")
+                                  .getArrayBuffer(runtime);
+  auto frequencyArray =
+      reinterpret_cast<float *>(arrayBufferFrequency.data(runtime));
+  auto length = static_cast<int>(arrayBufferFrequency.size(runtime));
+
+  auto arrayBufferMag = args[1]
+                            .getObject(runtime)
+                            .getPropertyAsObject(runtime, "buffer")
+                            .getArrayBuffer(runtime);
+  auto magResponseOut = reinterpret_cast<float *>(arrayBufferMag.data(runtime));
+
+  auto arrayBufferPhase = args[2]
+                              .getObject(runtime)
+                              .getPropertyAsObject(runtime, "buffer")
+                              .getArrayBuffer(runtime);
+  auto phaseResponseOut =
+      reinterpret_cast<float *>(arrayBufferPhase.data(runtime));
+
+  auto biquadFilterNode = std::static_pointer_cast<BiquadFilterNode>(node_);
+  biquadFilterNode->getFrequencyResponse(
+      frequencyArray, magResponseOut, phaseResponseOut, length);
+
+  return jsi::Value::undefined();
+}
+
+} // namespace audioapi

package/common/cpp/audioapi/HostObjects/effects/BiquadFilterNodeHostObject.h

@@ -0,0 +1,29 @@
+#pragma once
+
+#include <audioapi/HostObjects/AudioNodeHostObject.h>
+
+#include <memory>
+#include <string>
+#include <vector>
+
+namespace audioapi {
+using namespace facebook;
+
+class BiquadFilterNode;
+
+class BiquadFilterNodeHostObject : public AudioNodeHostObject {
+ public:
+  explicit BiquadFilterNodeHostObject(
+      const std::shared_ptr<BiquadFilterNode> &node);
+
+  JSI_PROPERTY_GETTER_DECL(frequency);
+  JSI_PROPERTY_GETTER_DECL(detune);
+  JSI_PROPERTY_GETTER_DECL(Q);
+  JSI_PROPERTY_GETTER_DECL(gain);
+  JSI_PROPERTY_GETTER_DECL(type);
+
+  JSI_PROPERTY_SETTER_DECL(type);
+
+  JSI_HOST_FUNCTION_DECL(getFrequencyResponse);
+};
+} // namespace audioapi

package/common/cpp/audioapi/HostObjects/effects/GainNodeHostObject.cpp

@@ -0,0 +1,20 @@
+#include <audioapi/HostObjects/effects/GainNodeHostObject.h>
+
+#include <audioapi/HostObjects/AudioParamHostObject.h>
+#include <audioapi/core/effects/GainNode.h>
+
+namespace audioapi {
+
+GainNodeHostObject::GainNodeHostObject(const std::shared_ptr<GainNode> &node)
+    : AudioNodeHostObject(node) {
+  addGetters(JSI_EXPORT_PROPERTY_GETTER(GainNodeHostObject, gain));
+}
+
+JSI_PROPERTY_GETTER_IMPL(GainNodeHostObject, gain) {
+  auto gainNode = std::static_pointer_cast<GainNode>(node_);
+  auto gainParam =
+      std::make_shared<AudioParamHostObject>(gainNode->getGainParam());
+  return jsi::Object::createFromHostObject(runtime, gainParam);
+}
+
+} // namespace audioapi

package/common/cpp/audioapi/HostObjects/effects/GainNodeHostObject.h

@@ -0,0 +1,19 @@
+#pragma once
+
+#include <audioapi/HostObjects/AudioNodeHostObject.h>
+
+#include <memory>
+#include <vector>
+
+namespace audioapi {
+using namespace facebook;
+
+class GainNode;
+
+class GainNodeHostObject : public AudioNodeHostObject {
+ public:
+  explicit GainNodeHostObject(const std::shared_ptr<GainNode> &node);
+
+  JSI_PROPERTY_GETTER_DECL(gain);
+};
+} // namespace audioapi

package/common/cpp/audioapi/HostObjects/effects/StereoPannerNodeHostObject.cpp

@@ -0,0 +1,21 @@
+#include <audioapi/HostObjects/effects/StereoPannerNodeHostObject.h>
+
+#include <audioapi/HostObjects/AudioParamHostObject.h>
+#include <audioapi/core/effects/StereoPannerNode.h>
+
+namespace audioapi {
+
+StereoPannerNodeHostObject::StereoPannerNodeHostObject(
+    const std::shared_ptr<StereoPannerNode> &node)
+    : AudioNodeHostObject(node) {
+  addGetters(JSI_EXPORT_PROPERTY_GETTER(StereoPannerNodeHostObject, pan));
+}
+
+JSI_PROPERTY_GETTER_IMPL(StereoPannerNodeHostObject, pan) {
+  auto stereoPannerNode = std::static_pointer_cast<StereoPannerNode>(node_);
+  auto panParam_ =
+      std::make_shared<AudioParamHostObject>(stereoPannerNode->getPanParam());
+  return jsi::Object::createFromHostObject(runtime, panParam_);
+}
+
+} // namespace audioapi

package/common/cpp/audioapi/HostObjects/effects/StereoPannerNodeHostObject.h

@@ -0,0 +1,21 @@
+#pragma once
+
+#include <audioapi/HostObjects/AudioNodeHostObject.h>
+
+#include <memory>
+#include <string>
+#include <vector>
+
+namespace audioapi {
+using namespace facebook;
+
+class StereoPannerNode;
+
+class StereoPannerNodeHostObject : public AudioNodeHostObject {
+ public:
+  explicit StereoPannerNodeHostObject(
+      const std::shared_ptr<StereoPannerNode> &node);
+
+  JSI_PROPERTY_GETTER_DECL(pan);
+};
+} // namespace audioapi

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

@@ -0,0 +1,41 @@
+#include <audioapi/HostObjects/events/AudioEventHandlerRegistryHostObject.h>
+
+#include <audioapi/events/AudioEventHandlerRegistry.h>
+
+namespace audioapi {
+
+AudioEventHandlerRegistryHostObject::AudioEventHandlerRegistryHostObject(
+    const std::shared_ptr<AudioEventHandlerRegistry> &eventHandlerRegistry) {
+  eventHandlerRegistry_ = eventHandlerRegistry;
+
+  addFunctions(
+      JSI_EXPORT_FUNCTION(
+          AudioEventHandlerRegistryHostObject, addAudioEventListener),
+      JSI_EXPORT_FUNCTION(
+          AudioEventHandlerRegistryHostObject, removeAudioEventListener));
+}
+
+JSI_HOST_FUNCTION_IMPL(
+    AudioEventHandlerRegistryHostObject,
+    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_IMPL(
+    AudioEventHandlerRegistryHostObject,
+    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();
+}
+
+} // namespace audioapi

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

@@ -0,0 +1,28 @@
+#pragma once
+
+#include <audioapi/jsi/JsiHostObject.h>
+
+#include <jsi/jsi.h>
+#include <ReactCommon/CallInvoker.h>
+#include <memory>
+#include <unordered_map>
+#include <vector>
+#include <string>
+
+namespace audioapi {
+using namespace facebook;
+
+class AudioEventHandlerRegistry;
+
+class AudioEventHandlerRegistryHostObject : public JsiHostObject {
+ public:
+    explicit AudioEventHandlerRegistryHostObject(const std::shared_ptr<AudioEventHandlerRegistry>& eventHandlerRegistry);
+
+    JSI_HOST_FUNCTION_DECL(addAudioEventListener);
+    JSI_HOST_FUNCTION_DECL(removeAudioEventListener);
+
+ private:
+    std::shared_ptr<AudioEventHandlerRegistry> eventHandlerRegistry_;
+};
+} // namespace audioapi
+