react-native-audio-api 0.8.3-nightly-ea268f4-20251006 → 0.8.4

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

@@ -1,5 +1,6 @@
 #pragma once
 
+#include <audioapi/core/AudioContext.h>
 #include <audioapi/HostObjects/BaseAudioContextHostObject.h>
 
 #include <jsi/jsi.h>
@@ -10,17 +11,56 @@
 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);
+      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);
+      });
+    });
 
-  JSI_HOST_FUNCTION_DECL(close);
-  JSI_HOST_FUNCTION_DECL(resume);
-  JSI_HOST_FUNCTION_DECL(suspend);
+    return promise;
+  }
 };
 } // namespace audioapi

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

@@ -1,73 +1,9 @@
 #include <audioapi/HostObjects/AudioNodeHostObject.h>
 
-#include <audioapi/HostObjects/AudioParamHostObject.h>
-#include <audioapi/core/AudioNode.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
 namespace audioapi {
-
-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
+AudioNodeHostObject::~AudioNodeHostObject() = default;
+}

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

@@ -1,5 +1,7 @@
 #pragma once
 
+#include <audioapi/HostObjects/AudioParamHostObject.h>
+#include <audioapi/core/AudioNode.h>
 #include <audioapi/jsi/JsiHostObject.h>
 
 #include <jsi/jsi.h>
@@ -9,20 +11,74 @@
 namespace audioapi {
 using namespace facebook;
 
-class AudioNode;
-
 class AudioNodeHostObject : public JsiHostObject {
  public:
-  explicit AudioNodeHostObject(const std::shared_ptr<AudioNode> &node);
+  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();
+  }
 
-  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);
+  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_HOST_FUNCTION_DECL(connect);
-  JSI_HOST_FUNCTION_DECL(disconnect);
+    if (obj.isHostObject<AudioParamHostObject>(runtime)) {
+      auto param = obj.getHostObject<AudioParamHostObject>(runtime);
+      node_->disconnect(std::shared_ptr<AudioParamHostObject>(param)->param_);
+    }
+    return jsi::Value::undefined();
+  }
 
  protected:
   std::shared_ptr<AudioNode> node_;

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

@@ -1,6 +1,7 @@
 #pragma once
 
 #include <audioapi/jsi/JsiHostObject.h>
+#include <audioapi/core/AudioParam.h>
 
 #include <jsi/jsi.h>
 #include <utility>
@@ -11,30 +12,103 @@
 namespace audioapi {
 using namespace facebook;
 
-class AudioParam;
-
 class AudioParamHostObject : public JsiHostObject {
  public:
-  explicit AudioParamHostObject(const std::shared_ptr<AudioParam> &param);
+  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));
 
-  JSI_PROPERTY_GETTER_DECL(value);
-  JSI_PROPERTY_GETTER_DECL(defaultValue);
-  JSI_PROPERTY_GETTER_DECL(minValue);
-  JSI_PROPERTY_GETTER_DECL(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));
 
-  JSI_PROPERTY_SETTER_DECL(value);
+    addSetters(JSI_EXPORT_PROPERTY_SETTER(AudioParamHostObject, value));
+  }
+  friend class AudioNodeHostObject;
 
-  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);
+  JSI_PROPERTY_GETTER(value) {
+    return {param_->getValue()};
+  }
 
- private:
-  friend class AudioNodeHostObject;
+  JSI_PROPERTY_GETTER(defaultValue) {
+    return {param_->getDefaultValue()};
+  }
+
+  JSI_PROPERTY_GETTER(minValue) {
+    return {param_->getMinValue()};
+  }
+
+  JSI_PROPERTY_GETTER(maxValue) {
+    return {param_->getMaxValue()};
+  }
+
+  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_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_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()));
+  }
+
+ private:
   std::shared_ptr<AudioParam> param_;
 };
 } // namespace audioapi

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

@@ -0,0 +1,86 @@
+#pragma once
+
+#include <jsi/jsi.h>
+
+#include <audioapi/core/sources/AudioBuffer.h>
+#include <audioapi/HostObjects/AudioBufferHostObject.h>
+#include <audioapi/core/inputs/AudioRecorder.h>
+#include <audioapi/HostObjects/RecorderAdapterNodeHostObject.h>
+
+#ifdef ANDROID
+#include <audioapi/android/core/AndroidAudioRecorder.h>
+#else
+#include <audioapi/ios/core/IOSAudioRecorder.h>
+#endif
+
+#include <memory>
+#include <utility>
+#include <vector>
+#include <cstdio>
+
+namespace audioapi {
+using namespace facebook;
+
+class AudioRecorderHostObject : public JsiHostObject {
+ public:
+  explicit AudioRecorderHostObject(
+      jsi::Runtime *runtime,
+      const std::shared_ptr<AudioEventHandlerRegistry> &audioEventHandlerRegistry,
+      float sampleRate,
+      int bufferLength) {
+#ifdef ANDROID
+    audioRecorder_ = std::make_shared<AndroidAudioRecorder>(
+      sampleRate,
+      bufferLength,
+      audioEventHandlerRegistry
+    );
+#else
+  audioRecorder_ = std::make_shared<IOSAudioRecorder>(
+      sampleRate,
+      bufferLength,
+      audioEventHandlerRegistry
+    );
+#endif
+
+    addSetters(JSI_EXPORT_PROPERTY_SETTER(AudioRecorderHostObject, onAudioReady));
+
+    addFunctions(
+      JSI_EXPORT_FUNCTION(AudioRecorderHostObject, start),
+      JSI_EXPORT_FUNCTION(AudioRecorderHostObject, stop),
+      JSI_EXPORT_FUNCTION(AudioRecorderHostObject, connect),
+      JSI_EXPORT_FUNCTION(AudioRecorderHostObject, disconnect)
+    );
+  }
+
+  JSI_HOST_FUNCTION(connect) {
+    auto adapterNodeHostObject = args[0].getObject(runtime).getHostObject<RecorderAdapterNodeHostObject>(runtime);
+    audioRecorder_->connect(
+        std::static_pointer_cast<RecorderAdapterNode>(adapterNodeHostObject->node_));
+    return jsi::Value::undefined();
+  }
+
+  JSI_HOST_FUNCTION(disconnect) {
+    audioRecorder_->disconnect();
+    return jsi::Value::undefined();
+  }
+
+  JSI_HOST_FUNCTION(start) {
+    audioRecorder_->start();
+
+    return jsi::Value::undefined();
+  }
+
+  JSI_HOST_FUNCTION(stop) {
+    audioRecorder_->stop();
+
+    return jsi::Value::undefined();
+  }
+
+  JSI_PROPERTY_SETTER(onAudioReady) {
+    audioRecorder_->setOnAudioReadyCallbackId(std::stoull(value.getString(runtime).utf8(runtime)));
+  }
+
+ private:
+  std::shared_ptr<AudioRecorder> audioRecorder_;
+};
+} // namespace audioapi

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

@@ -0,0 +1,56 @@
+#pragma once
+
+#include <audioapi/HostObjects/AudioNodeHostObject.h>
+#include <audioapi/core/sources/AudioScheduledSourceNode.h>
+
+#include <memory>
+#include <vector>
+
+namespace audioapi {
+using namespace facebook;
+
+class AudioScheduledSourceNodeHostObject : public AudioNodeHostObject {
+ public:
+  explicit AudioScheduledSourceNodeHostObject(
+      const std::shared_ptr<AudioScheduledSourceNode> &node)
+      : AudioNodeHostObject(node) {
+    addSetters(
+      JSI_EXPORT_PROPERTY_SETTER(AudioScheduledSourceNodeHostObject, onEnded));
+    addFunctions(
+        JSI_EXPORT_FUNCTION(AudioScheduledSourceNodeHostObject, start),
+        JSI_EXPORT_FUNCTION(AudioScheduledSourceNodeHostObject, stop));
+  }
+
+  ~AudioScheduledSourceNodeHostObject() {
+    auto audioScheduledSourceNode =
+        std::static_pointer_cast<AudioScheduledSourceNode>(node_);
+
+    // 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();
+  }
+
+  JSI_PROPERTY_SETTER(onEnded) {
+    auto audioScheduleSourceNode =
+            std::static_pointer_cast<AudioScheduledSourceNode>(node_);
+
+    audioScheduleSourceNode->setOnEndedCallbackId(std::stoull(value.getString(runtime).utf8(runtime)));
+  }
+
+  JSI_HOST_FUNCTION(start) {
+    auto when = args[0].getNumber();
+    auto audioScheduleSourceNode =
+        std::static_pointer_cast<AudioScheduledSourceNode>(node_);
+    audioScheduleSourceNode->start(when);
+    return jsi::Value::undefined();
+  }
+
+  JSI_HOST_FUNCTION(stop) {
+    auto time = args[0].getNumber();
+    auto audioScheduleSourceNode =
+        std::static_pointer_cast<AudioScheduledSourceNode>(node_);
+    audioScheduleSourceNode->stop(time);
+    return jsi::Value::undefined();
+  }
+};
+} // namespace audioapi