react-native-audio-api 0.8.3 → 0.9.0

package/common/cpp/audioapi/AudioAPIModuleInstaller.h

@@ -6,10 +6,12 @@
 #include <audioapi/core/inputs/AudioRecorder.h>
 #include <audioapi/HostObjects/AudioContextHostObject.h>
 #include <audioapi/HostObjects/OfflineAudioContextHostObject.h>
-#include <audioapi/HostObjects/AudioRecorderHostObject.h>
+#include <audioapi/HostObjects/inputs/AudioRecorderHostObject.h>
 
 #include <audioapi/events/AudioEventHandlerRegistry.h>
-#include <audioapi/events/AudioEventHandlerRegistryHostObject.h>
+#include <audioapi/HostObjects/events/AudioEventHandlerRegistryHostObject.h>
+
+#include <audioapi/core/utils/worklets/SafeIncludes.h>
 
 #include <memory>
 
@@ -19,10 +21,15 @@ using namespace facebook;
 
 class AudioAPIModuleInstaller {
  public:
-  static void injectJSIBindings(jsi::Runtime *jsiRuntime, const std::shared_ptr<react::CallInvoker> &jsCallInvoker, const std::shared_ptr<AudioEventHandlerRegistry> &audioEventHandlerRegistry) {
-    auto createAudioContext = getCreateAudioContextFunction(jsiRuntime, jsCallInvoker, audioEventHandlerRegistry);
+  static void injectJSIBindings(
+    jsi::Runtime *jsiRuntime,
+    const std::shared_ptr<react::CallInvoker> &jsCallInvoker,
+    const std::shared_ptr<AudioEventHandlerRegistry> &audioEventHandlerRegistry,
+    std::shared_ptr<worklets::WorkletRuntime> uiRuntime = nullptr) {
+
+    auto createAudioContext = getCreateAudioContextFunction(jsiRuntime, jsCallInvoker, audioEventHandlerRegistry, uiRuntime);
     auto createAudioRecorder = getCreateAudioRecorderFunction(jsiRuntime, audioEventHandlerRegistry);
-    auto createOfflineAudioContext = getCreateOfflineAudioContextFunction(jsiRuntime, jsCallInvoker, audioEventHandlerRegistry);
+    auto createOfflineAudioContext = getCreateOfflineAudioContextFunction(jsiRuntime, jsCallInvoker, audioEventHandlerRegistry, uiRuntime);
 
     jsiRuntime->global().setProperty(*jsiRuntime, "createAudioContext", createAudioContext);
     jsiRuntime->global().setProperty(*jsiRuntime, "createAudioRecorder", createAudioRecorder);
@@ -33,12 +40,16 @@ class AudioAPIModuleInstaller {
   }
 
  private:
-  static jsi::Function getCreateAudioContextFunction(jsi::Runtime *jsiRuntime, const std::shared_ptr<react::CallInvoker> &jsCallInvoker, const std::shared_ptr<AudioEventHandlerRegistry> &audioEventHandlerRegistry) {
+  static jsi::Function getCreateAudioContextFunction(
+    jsi::Runtime *jsiRuntime,
+    const std::shared_ptr<react::CallInvoker> &jsCallInvoker,
+    const std::shared_ptr<AudioEventHandlerRegistry> &audioEventHandlerRegistry,
+    const std::weak_ptr<worklets::WorkletRuntime> &uiRuntime) {
     return jsi::Function::createFromHostFunction(
         *jsiRuntime,
         jsi::PropNameID::forAscii(*jsiRuntime, "createAudioContext"),
         0,
-        [jsCallInvoker, audioEventHandlerRegistry](
+        [jsCallInvoker, audioEventHandlerRegistry, uiRuntime](
             jsi::Runtime &runtime,
             const jsi::Value &thisValue,
             const jsi::Value *args,
@@ -46,8 +57,17 @@ class AudioAPIModuleInstaller {
           std::shared_ptr<AudioContext> audioContext;
           auto sampleRate = static_cast<float>(args[0].getNumber());
           auto initSuspended = args[1].getBool();
-          audioContext = std::make_shared<AudioContext>(sampleRate, initSuspended, audioEventHandlerRegistry);
 
+          #if RN_AUDIO_API_ENABLE_WORKLETS
+              auto runtimeRegistry = RuntimeRegistry{
+                  .uiRuntime = uiRuntime,
+                  .audioRuntime = worklets::extractWorkletRuntime(runtime, args[2])
+              };
+          #else
+              auto runtimeRegistry = RuntimeRegistry{};
+          #endif
+
+          audioContext = std::make_shared<AudioContext>(sampleRate, initSuspended, audioEventHandlerRegistry, runtimeRegistry);
           auto audioContextHostObject = std::make_shared<AudioContextHostObject>(
               audioContext, &runtime, jsCallInvoker);
 
@@ -56,12 +76,16 @@ class AudioAPIModuleInstaller {
         });
   }
 
-  static jsi::Function getCreateOfflineAudioContextFunction(jsi::Runtime *jsiRuntime, const std::shared_ptr<react::CallInvoker> &jsCallInvoker, const std::shared_ptr<AudioEventHandlerRegistry> &audioEventHandlerRegistry) {
+  static jsi::Function getCreateOfflineAudioContextFunction(
+    jsi::Runtime *jsiRuntime,
+    const std::shared_ptr<react::CallInvoker> &jsCallInvoker,
+    const std::shared_ptr<AudioEventHandlerRegistry> &audioEventHandlerRegistry,
+    const std::weak_ptr<worklets::WorkletRuntime> &uiRuntime) {
     return jsi::Function::createFromHostFunction(
         *jsiRuntime,
         jsi::PropNameID::forAscii(*jsiRuntime, "createOfflineAudioContext"),
         0,
-        [jsCallInvoker, audioEventHandlerRegistry](
+        [jsCallInvoker, audioEventHandlerRegistry, uiRuntime](
             jsi::Runtime &runtime,
             const jsi::Value &thisValue,
             const jsi::Value *args,
@@ -70,16 +94,27 @@ class AudioAPIModuleInstaller {
             auto length = static_cast<size_t>(args[1].getNumber());
             auto sampleRate = static_cast<float>(args[2].getNumber());
 
-          auto offlineAudioContext = std::make_shared<OfflineAudioContext>(numberOfChannels, length, sampleRate, audioEventHandlerRegistry);
-          auto audioContextHostObject = std::make_shared<OfflineAudioContextHostObject>(
-              offlineAudioContext, &runtime, jsCallInvoker);
-
-          return jsi::Object::createFromHostObject(
-              runtime, audioContextHostObject);
+            #if RN_AUDIO_API_ENABLE_WORKLETS
+                auto runtimeRegistry = RuntimeRegistry{
+                    .uiRuntime = uiRuntime,
+                    .audioRuntime = worklets::extractWorkletRuntime(runtime, args[3])
+                };
+            #else
+            auto runtimeRegistry = RuntimeRegistry{};
+            #endif
+
+            auto offlineAudioContext = std::make_shared<OfflineAudioContext>(numberOfChannels, length, sampleRate, audioEventHandlerRegistry, runtimeRegistry);
+            auto audioContextHostObject = std::make_shared<OfflineAudioContextHostObject>(
+                offlineAudioContext, &runtime, jsCallInvoker);
+
+            return jsi::Object::createFromHostObject(
+                runtime, audioContextHostObject);
         });
   }
 
-  static jsi::Function getCreateAudioRecorderFunction(jsi::Runtime *jsiRuntime, const std::shared_ptr<AudioEventHandlerRegistry> &audioEventHandlerRegistry) {
+  static jsi::Function getCreateAudioRecorderFunction(
+    jsi::Runtime *jsiRuntime,
+    const std::shared_ptr<AudioEventHandlerRegistry> &audioEventHandlerRegistry) {
     return jsi::Function::createFromHostFunction(
         *jsiRuntime,
         jsi::PropNameID::forAscii(*jsiRuntime, "createAudioRecorder"),
@@ -94,7 +129,7 @@ class AudioAPIModuleInstaller {
           auto sampleRate = static_cast<float>(options.getProperty(runtime, "sampleRate").getNumber());
           auto bufferLength = static_cast<int>(options.getProperty(runtime, "bufferLengthInSamples").getNumber());
 
-          auto audioRecorderHostObject = std::make_shared<AudioRecorderHostObject>(&runtime, audioEventHandlerRegistry, sampleRate, bufferLength);
+          auto audioRecorderHostObject = std::make_shared<AudioRecorderHostObject>(audioEventHandlerRegistry, sampleRate, bufferLength);
 
           return jsi::Object::createFromHostObject(runtime, audioRecorderHostObject);
         });

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