react-native-audio-api 0.8.3-nightly-d178688-20250925 → 0.8.3-nightly-cae1f96-20250927

package/common/cpp/audioapi/HostObjects/AudioContextHostObject.cpp

@@ -0,0 +1,57 @@
+#include <audioapi/HostObjects/AudioContextHostObject.h>
+
+#include <audioapi/core/AudioContext.h>
+
+namespace audioapi {
+
+AudioContextHostObject::AudioContextHostObject(
+    const std::shared_ptr<AudioContext> &audioContext,
+    jsi::Runtime *runtime,
+    const std::shared_ptr<react::CallInvoker> &callInvoker)
+    : BaseAudioContextHostObject(audioContext, runtime, callInvoker) {
+  addFunctions(
+      JSI_EXPORT_FUNCTION(AudioContextHostObject, close),
+      JSI_EXPORT_FUNCTION(AudioContextHostObject, resume),
+      JSI_EXPORT_FUNCTION(AudioContextHostObject, suspend));
+}
+
+JSI_HOST_FUNCTION_IMPL(AudioContextHostObject, close) {
+  auto audioContext = std::static_pointer_cast<AudioContext>(context_);
+  auto promise = promiseVendor_->createPromise(
+      [audioContext](const std::shared_ptr<Promise> &promise) {
+        audioContext->close();
+
+        promise->resolve(
+            [](jsi::Runtime &runtime) { return jsi::Value::undefined(); });
+      });
+
+  return promise;
+}
+
+JSI_HOST_FUNCTION_IMPL(AudioContextHostObject, resume) {
+  auto audioContext = std::static_pointer_cast<AudioContext>(context_);
+  auto promise = promiseVendor_->createPromise(
+      [audioContext](const std::shared_ptr<Promise> &promise) {
+        auto result = audioContext->resume();
+
+        promise->resolve(
+            [result](jsi::Runtime &runtime) { return jsi::Value(result); });
+      });
+
+  return promise;
+}
+
+JSI_HOST_FUNCTION_IMPL(AudioContextHostObject, suspend) {
+  auto audioContext = std::static_pointer_cast<AudioContext>(context_);
+  auto promise = promiseVendor_->createPromise(
+      [audioContext](const std::shared_ptr<Promise> &promise) {
+        auto result = audioContext->suspend();
+
+        promise->resolve(
+            [result](jsi::Runtime &runtime) { return jsi::Value(result); });
+      });
+
+  return promise;
+}
+
+} // namespace audioapi

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

@@ -1,6 +1,5 @@
 #pragma once
 
-#include <audioapi/core/AudioContext.h>
 #include <audioapi/HostObjects/BaseAudioContextHostObject.h>
 
 #include <jsi/jsi.h>
@@ -11,56 +10,17 @@
 namespace audioapi {
 using namespace facebook;
 
+class AudioContext;
+
 class AudioContextHostObject : public BaseAudioContextHostObject {
  public:
   explicit AudioContextHostObject(
       const std::shared_ptr<AudioContext> &audioContext,
       jsi::Runtime *runtime,
-      const std::shared_ptr<react::CallInvoker> &callInvoker)
-      : BaseAudioContextHostObject(audioContext, runtime, callInvoker) {
-    addFunctions(
-      JSI_EXPORT_FUNCTION(AudioContextHostObject, close),
-      JSI_EXPORT_FUNCTION(AudioContextHostObject, resume),
-      JSI_EXPORT_FUNCTION(AudioContextHostObject, suspend));
-  }
-
-  JSI_HOST_FUNCTION(close) {
-    auto audioContext = std::static_pointer_cast<AudioContext>(context_);
-    auto promise = promiseVendor_->createPromise([audioContext](const std::shared_ptr<Promise>& promise) {
-      audioContext->close();
-
-      promise->resolve([](jsi::Runtime &runtime) {
-          return jsi::Value::undefined();
-      });
-    });
-
-    return promise;
-  }
-
-  JSI_HOST_FUNCTION(resume) {
-    auto audioContext = std::static_pointer_cast<AudioContext>(context_);
-    auto promise = promiseVendor_->createPromise([audioContext](const std::shared_ptr<Promise>& promise) {
-        auto result = audioContext->resume();
-
-        promise->resolve([result](jsi::Runtime &runtime) {
-            return jsi::Value(result);
-        });
-    });
-
-    return promise;
-  }
-
-  JSI_HOST_FUNCTION(suspend) {
-    auto audioContext = std::static_pointer_cast<AudioContext>(context_);
-    auto promise = promiseVendor_->createPromise([audioContext](const std::shared_ptr<Promise>& promise) {
-      auto result = audioContext->suspend();
-
-      promise->resolve([result](jsi::Runtime &runtime) {
-        return jsi::Value(result);
-      });
-    });
+      const std::shared_ptr<react::CallInvoker> &callInvoker);
 
-    return promise;
-  }
+  JSI_HOST_FUNCTION_DECL(close);
+  JSI_HOST_FUNCTION_DECL(resume);
+  JSI_HOST_FUNCTION_DECL(suspend);
 };
 } // namespace audioapi

package/common/cpp/audioapi/HostObjects/AudioNodeHostObject.cpp

@@ -1,9 +1,73 @@
 #include <audioapi/HostObjects/AudioNodeHostObject.h>
 
-// Explicitly define destructors here, as they to exist in order to act as a
-// "key function" for the audio classes - this allow for RTTI to work
-// properly across dynamic library boundaries (i.e. dynamic_cast that is used by
-// isHostObject method), android specific issue
+#include <audioapi/HostObjects/AudioParamHostObject.h>
+#include <audioapi/core/AudioNode.h>
+
 namespace audioapi {
-AudioNodeHostObject::~AudioNodeHostObject() = default;
-}
+
+AudioNodeHostObject::AudioNodeHostObject(const std::shared_ptr<AudioNode> &node)
+    : node_(node) {
+  addGetters(
+      JSI_EXPORT_PROPERTY_GETTER(AudioNodeHostObject, numberOfInputs),
+      JSI_EXPORT_PROPERTY_GETTER(AudioNodeHostObject, numberOfOutputs),
+      JSI_EXPORT_PROPERTY_GETTER(AudioNodeHostObject, channelCount),
+      JSI_EXPORT_PROPERTY_GETTER(AudioNodeHostObject, channelCountMode),
+      JSI_EXPORT_PROPERTY_GETTER(AudioNodeHostObject, channelInterpretation));
+
+  addFunctions(
+      JSI_EXPORT_FUNCTION(AudioNodeHostObject, connect),
+      JSI_EXPORT_FUNCTION(AudioNodeHostObject, disconnect));
+}
+
+JSI_PROPERTY_GETTER_IMPL(AudioNodeHostObject, numberOfInputs) {
+  return {node_->getNumberOfInputs()};
+}
+
+JSI_PROPERTY_GETTER_IMPL(AudioNodeHostObject, numberOfOutputs) {
+  return {node_->getNumberOfOutputs()};
+}
+
+JSI_PROPERTY_GETTER_IMPL(AudioNodeHostObject, channelCount) {
+  return {node_->getChannelCount()};
+}
+
+JSI_PROPERTY_GETTER_IMPL(AudioNodeHostObject, channelCountMode) {
+  return jsi::String::createFromUtf8(runtime, node_->getChannelCountMode());
+}
+
+JSI_PROPERTY_GETTER_IMPL(AudioNodeHostObject, channelInterpretation) {
+  return jsi::String::createFromUtf8(
+      runtime, node_->getChannelInterpretation());
+}
+
+JSI_HOST_FUNCTION_IMPL(AudioNodeHostObject, connect) {
+  auto obj = args[0].getObject(runtime);
+  if (obj.isHostObject<AudioNodeHostObject>(runtime)) {
+    auto node = obj.getHostObject<AudioNodeHostObject>(runtime);
+    node_->connect(std::shared_ptr<AudioNodeHostObject>(node)->node_);
+  }
+  if (obj.isHostObject<AudioParamHostObject>(runtime)) {
+    auto param = obj.getHostObject<AudioParamHostObject>(runtime);
+    node_->connect(std::shared_ptr<AudioParamHostObject>(param)->param_);
+  }
+  return jsi::Value::undefined();
+}
+
+JSI_HOST_FUNCTION_IMPL(AudioNodeHostObject, disconnect) {
+  if (args[0].isUndefined()) {
+    node_->disconnect();
+    return jsi::Value::undefined();
+  }
+  auto obj = args[0].getObject(runtime);
+  if (obj.isHostObject<AudioNodeHostObject>(runtime)) {
+    auto node = obj.getHostObject<AudioNodeHostObject>(runtime);
+    node_->disconnect(std::shared_ptr<AudioNodeHostObject>(node)->node_);
+  }
+
+  if (obj.isHostObject<AudioParamHostObject>(runtime)) {
+    auto param = obj.getHostObject<AudioParamHostObject>(runtime);
+    node_->disconnect(std::shared_ptr<AudioParamHostObject>(param)->param_);
+  }
+  return jsi::Value::undefined();
+}
+} // namespace audioapi

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

@@ -1,7 +1,5 @@
 #pragma once
 
-#include <audioapi/HostObjects/AudioParamHostObject.h>
-#include <audioapi/core/AudioNode.h>
 #include <audioapi/jsi/JsiHostObject.h>
 
 #include <jsi/jsi.h>
@@ -11,74 +9,20 @@
 namespace audioapi {
 using namespace facebook;
 
+class AudioNode;
+
 class AudioNodeHostObject : public JsiHostObject {
  public:
-  explicit AudioNodeHostObject(const std::shared_ptr<AudioNode> &node)
-      : node_(node) {
-    addGetters(
-        JSI_EXPORT_PROPERTY_GETTER(AudioNodeHostObject, numberOfInputs),
-        JSI_EXPORT_PROPERTY_GETTER(AudioNodeHostObject, numberOfOutputs),
-        JSI_EXPORT_PROPERTY_GETTER(AudioNodeHostObject, channelCount),
-        JSI_EXPORT_PROPERTY_GETTER(AudioNodeHostObject, channelCountMode),
-        JSI_EXPORT_PROPERTY_GETTER(AudioNodeHostObject, channelInterpretation));
-    addFunctions(
-        JSI_EXPORT_FUNCTION(AudioNodeHostObject, connect),
-        JSI_EXPORT_FUNCTION(AudioNodeHostObject, disconnect));
-  }
-
-  ~AudioNodeHostObject() override;
-
-  JSI_PROPERTY_GETTER(numberOfInputs) {
-    return {node_->getNumberOfInputs()};
-  }
-
-  JSI_PROPERTY_GETTER(numberOfOutputs) {
-    return {node_->getNumberOfOutputs()};
-  }
-
-  JSI_PROPERTY_GETTER(channelCount) {
-    return {node_->getChannelCount()};
-  }
-
-  JSI_PROPERTY_GETTER(channelCountMode) {
-    return jsi::String::createFromUtf8(runtime, node_->getChannelCountMode());
-  }
-
-  JSI_PROPERTY_GETTER(channelInterpretation) {
-    return jsi::String::createFromUtf8(
-        runtime, node_->getChannelInterpretation());
-  }
-
-  JSI_HOST_FUNCTION(connect) {
-    auto obj = args[0].getObject(runtime);
-    if (obj.isHostObject<AudioNodeHostObject>(runtime)) {
-      auto node = obj.getHostObject<AudioNodeHostObject>(runtime);
-      node_->connect(std::shared_ptr<AudioNodeHostObject>(node)->node_);
-    }
-    if (obj.isHostObject<AudioParamHostObject>(runtime)) {
-      auto param = obj.getHostObject<AudioParamHostObject>(runtime);
-      node_->connect(std::shared_ptr<AudioParamHostObject>(param)->param_);
-    }
-    return jsi::Value::undefined();
-  }
+  explicit AudioNodeHostObject(const std::shared_ptr<AudioNode> &node);
 
-  JSI_HOST_FUNCTION(disconnect) {
-    if (args[0].isUndefined()) {
-      node_->disconnect();
-      return jsi::Value::undefined();
-    }
-    auto obj = args[0].getObject(runtime);
-    if (obj.isHostObject<AudioNodeHostObject>(runtime)) {
-      auto node = obj.getHostObject<AudioNodeHostObject>(runtime);
-      node_->disconnect(std::shared_ptr<AudioNodeHostObject>(node)->node_);
-    }
+  JSI_PROPERTY_GETTER_DECL(numberOfInputs);
+  JSI_PROPERTY_GETTER_DECL(numberOfOutputs);
+  JSI_PROPERTY_GETTER_DECL(channelCount);
+  JSI_PROPERTY_GETTER_DECL(channelCountMode);
+  JSI_PROPERTY_GETTER_DECL(channelInterpretation);
 
-    if (obj.isHostObject<AudioParamHostObject>(runtime)) {
-      auto param = obj.getHostObject<AudioParamHostObject>(runtime);
-      node_->disconnect(std::shared_ptr<AudioParamHostObject>(param)->param_);
-    }
-    return jsi::Value::undefined();
-  }
+  JSI_HOST_FUNCTION_DECL(connect);
+  JSI_HOST_FUNCTION_DECL(disconnect);
 
  protected:
   std::shared_ptr<AudioNode> node_;

package/common/cpp/audioapi/HostObjects/AudioParamHostObject.cpp

@@ -0,0 +1,105 @@
+#include <audioapi/HostObjects/AudioParamHostObject.h>
+
+#include <audioapi/core/AudioParam.h>
+
+namespace audioapi {
+
+AudioParamHostObject::AudioParamHostObject(
+    const std::shared_ptr<AudioParam> &param)
+    : param_(param) {
+  addGetters(
+      JSI_EXPORT_PROPERTY_GETTER(AudioParamHostObject, value),
+      JSI_EXPORT_PROPERTY_GETTER(AudioParamHostObject, defaultValue),
+      JSI_EXPORT_PROPERTY_GETTER(AudioParamHostObject, minValue),
+      JSI_EXPORT_PROPERTY_GETTER(AudioParamHostObject, maxValue));
+
+  addFunctions(
+      JSI_EXPORT_FUNCTION(AudioParamHostObject, setValueAtTime),
+      JSI_EXPORT_FUNCTION(AudioParamHostObject, linearRampToValueAtTime),
+      JSI_EXPORT_FUNCTION(AudioParamHostObject, exponentialRampToValueAtTime),
+      JSI_EXPORT_FUNCTION(AudioParamHostObject, setTargetAtTime),
+      JSI_EXPORT_FUNCTION(AudioParamHostObject, setValueCurveAtTime),
+      JSI_EXPORT_FUNCTION(AudioParamHostObject, cancelScheduledValues),
+      JSI_EXPORT_FUNCTION(AudioParamHostObject, cancelAndHoldAtTime));
+
+  addSetters(JSI_EXPORT_PROPERTY_SETTER(AudioParamHostObject, value));
+}
+
+JSI_PROPERTY_GETTER_IMPL(AudioParamHostObject, value) {
+  return {param_->getValue()};
+}
+
+JSI_PROPERTY_GETTER_IMPL(AudioParamHostObject, defaultValue) {
+  return {param_->getDefaultValue()};
+}
+
+JSI_PROPERTY_GETTER_IMPL(AudioParamHostObject, minValue) {
+  return {param_->getMinValue()};
+}
+
+JSI_PROPERTY_GETTER_IMPL(AudioParamHostObject, maxValue) {
+  return {param_->getMaxValue()};
+}
+
+JSI_PROPERTY_SETTER_IMPL(AudioParamHostObject, value) {
+  param_->setValue(static_cast<float>(value.getNumber()));
+}
+
+JSI_HOST_FUNCTION_IMPL(AudioParamHostObject, setValueAtTime) {
+  auto value = static_cast<float>(args[0].getNumber());
+  double startTime = args[1].getNumber();
+  param_->setValueAtTime(value, startTime);
+  return jsi::Value::undefined();
+}
+
+JSI_HOST_FUNCTION_IMPL(AudioParamHostObject, linearRampToValueAtTime) {
+  auto value = static_cast<float>(args[0].getNumber());
+  double endTime = args[1].getNumber();
+  param_->linearRampToValueAtTime(value, endTime);
+  return jsi::Value::undefined();
+}
+
+JSI_HOST_FUNCTION_IMPL(AudioParamHostObject, exponentialRampToValueAtTime) {
+  auto value = static_cast<float>(args[0].getNumber());
+  double endTime = args[1].getNumber();
+  param_->exponentialRampToValueAtTime(value, endTime);
+  return jsi::Value::undefined();
+}
+
+JSI_HOST_FUNCTION_IMPL(AudioParamHostObject, setTargetAtTime) {
+  auto target = static_cast<float>(args[0].getNumber());
+  double startTime = args[1].getNumber();
+  double timeConstant = args[2].getNumber();
+  param_->setTargetAtTime(target, startTime, timeConstant);
+  return jsi::Value::undefined();
+}
+
+JSI_HOST_FUNCTION_IMPL(AudioParamHostObject, setValueCurveAtTime) {
+  auto arrayBuffer = args[0]
+                         .getObject(runtime)
+                         .getPropertyAsObject(runtime, "buffer")
+                         .getArrayBuffer(runtime);
+  auto rawValues = reinterpret_cast<float *>(arrayBuffer.data(runtime));
+  auto length = static_cast<int>(arrayBuffer.size(runtime));
+  auto values =
+      std::make_unique<std::vector<float>>(rawValues, rawValues + length);
+
+  double startTime = args[1].getNumber();
+  double duration = args[2].getNumber();
+  param_->setValueCurveAtTime(std::move(values), length, startTime, duration);
+  return jsi::Value::undefined();
+}
+
+JSI_HOST_FUNCTION_IMPL(AudioParamHostObject, cancelScheduledValues) {
+  double cancelTime = args[0].getNumber();
+  param_->cancelScheduledValues(cancelTime);
+  return jsi::Value::undefined();
+}
+
+JSI_HOST_FUNCTION_IMPL(AudioParamHostObject, cancelAndHoldAtTime) {
+  double cancelTime = args[0].getNumber();
+  param_->cancelAndHoldAtTime(cancelTime);
+  return jsi::Value::undefined();
+}
+
+} // namespace audioapi

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

@@ -1,7 +1,6 @@
 #pragma once
 
 #include <audioapi/jsi/JsiHostObject.h>
-#include <audioapi/core/AudioParam.h>
 
 #include <jsi/jsi.h>
 #include <utility>
@@ -12,103 +11,30 @@
 namespace audioapi {
 using namespace facebook;
 
+class AudioParam;
+
 class AudioParamHostObject : public JsiHostObject {
  public:
-  explicit AudioParamHostObject(const std::shared_ptr<AudioParam> &param)
-      : param_(param) {
-    addGetters(
-        JSI_EXPORT_PROPERTY_GETTER(AudioParamHostObject, value),
-        JSI_EXPORT_PROPERTY_GETTER(AudioParamHostObject, defaultValue),
-        JSI_EXPORT_PROPERTY_GETTER(AudioParamHostObject, minValue),
-        JSI_EXPORT_PROPERTY_GETTER(AudioParamHostObject, maxValue));
-
-    addFunctions(
-        JSI_EXPORT_FUNCTION(AudioParamHostObject, setValueAtTime),
-        JSI_EXPORT_FUNCTION(AudioParamHostObject, linearRampToValueAtTime),
-        JSI_EXPORT_FUNCTION(AudioParamHostObject, exponentialRampToValueAtTime),
-        JSI_EXPORT_FUNCTION(AudioParamHostObject, setTargetAtTime),
-        JSI_EXPORT_FUNCTION(AudioParamHostObject, setValueCurveAtTime),
-        JSI_EXPORT_FUNCTION(AudioParamHostObject, cancelScheduledValues),
-        JSI_EXPORT_FUNCTION(AudioParamHostObject, cancelAndHoldAtTime));
-
-    addSetters(JSI_EXPORT_PROPERTY_SETTER(AudioParamHostObject, value));
-  }
-  friend class AudioNodeHostObject;
-
-  JSI_PROPERTY_GETTER(value) {
-    return {param_->getValue()};
-  }
-
-  JSI_PROPERTY_GETTER(defaultValue) {
-    return {param_->getDefaultValue()};
-  }
-
-  JSI_PROPERTY_GETTER(minValue) {
-    return {param_->getMinValue()};
-  }
-
-  JSI_PROPERTY_GETTER(maxValue) {
-    return {param_->getMaxValue()};
-  }
+  explicit AudioParamHostObject(const std::shared_ptr<AudioParam> &param);
 
-  JSI_HOST_FUNCTION(setValueAtTime) {
-    auto value = static_cast<float>(args[0].getNumber());
-    double startTime = args[1].getNumber();
-    param_->setValueAtTime(value, startTime);
-    return jsi::Value::undefined();
-  }
+  JSI_PROPERTY_GETTER_DECL(value);
+  JSI_PROPERTY_GETTER_DECL(defaultValue);
+  JSI_PROPERTY_GETTER_DECL(minValue);
+  JSI_PROPERTY_GETTER_DECL(maxValue);
 
-  JSI_HOST_FUNCTION(linearRampToValueAtTime) {
-    auto value = static_cast<float>(args[0].getNumber());
-    double endTime = args[1].getNumber();
-    param_->linearRampToValueAtTime(value, endTime);
-    return jsi::Value::undefined();
-  }
+  JSI_PROPERTY_SETTER_DECL(value);
 
-  JSI_HOST_FUNCTION(exponentialRampToValueAtTime) {
-    auto value = static_cast<float>(args[0].getNumber());
-    double endTime = args[1].getNumber();
-    param_->exponentialRampToValueAtTime(value, endTime);
-    return jsi::Value::undefined();
-  }
-
-  JSI_HOST_FUNCTION(setTargetAtTime) {
-    auto target = static_cast<float>(args[0].getNumber());
-    double startTime = args[1].getNumber();
-    double timeConstant = args[2].getNumber();
-    param_->setTargetAtTime(target, startTime, timeConstant);
-    return jsi::Value::undefined();
-  }
-
-  JSI_HOST_FUNCTION(setValueCurveAtTime) {
-    auto arrayBuffer = args[0].getObject(runtime).getPropertyAsObject(runtime, "buffer").getArrayBuffer(runtime);
-    auto rawValues = reinterpret_cast<float *>(arrayBuffer.data(runtime));
-    auto length = static_cast<int>(arrayBuffer.size(runtime));
-    auto values = std::make_unique<std::vector<float>>(rawValues, rawValues + length);
-
-    double startTime = args[1].getNumber();
-    double duration = args[2].getNumber();
-    param_->setValueCurveAtTime(std::move(values), length, startTime, duration);
-    return jsi::Value::undefined();
-  }
-
-  JSI_HOST_FUNCTION(cancelScheduledValues) {
-    double cancelTime = args[0].getNumber();
-    param_->cancelScheduledValues(cancelTime);
-    return jsi::Value::undefined();
-  }
-
-  JSI_HOST_FUNCTION(cancelAndHoldAtTime) {
-    double cancelTime = args[0].getNumber();
-    param_->cancelAndHoldAtTime(cancelTime);
-    return jsi::Value::undefined();
-  }
-
-  JSI_PROPERTY_SETTER(value) {
-    param_->setValue(static_cast<float>(value.getNumber()));
-  }
+  JSI_HOST_FUNCTION_DECL(setValueAtTime);
+  JSI_HOST_FUNCTION_DECL(linearRampToValueAtTime);
+  JSI_HOST_FUNCTION_DECL(exponentialRampToValueAtTime);
+  JSI_HOST_FUNCTION_DECL(setTargetAtTime);
+  JSI_HOST_FUNCTION_DECL(setValueCurveAtTime);
+  JSI_HOST_FUNCTION_DECL(cancelScheduledValues);
+  JSI_HOST_FUNCTION_DECL(cancelAndHoldAtTime);
 
  private:
+  friend class AudioNodeHostObject;
+
   std::shared_ptr<AudioParam> param_;
 };
 } // namespace audioapi