react-native-audio-api 0.3.0-rc2 → 0.3.1

package/android/CMakeLists.txt

@@ -21,12 +21,12 @@ file(GLOB_RECURSE SOURCE_FILES
   "../common/cpp/*.h"
   "../common/cpp/core/*.cpp"
   "../common/cpp/core/*.h"
-  "../common/cpp/wrappers/*.cpp"
-  "../common/cpp/wrappers/*.h"
   "../common/cpp/HostObjects/*.cpp"
   "../common/cpp/HostObjects/*.h"
   "../common/cpp/utils/*.cpp"
   "../common/cpp/utils/*.h"
+  "../common/cpp/jsi/*.h"
+  "../common/cpp/jsi/*.cpp"
   "../common/cpp/types/*.h"
 )
 

package/android/src/main/cpp/AudioAPIInstaller/AudioAPIInstaller.cpp

@@ -13,14 +13,8 @@ AudioAPIInstaller::AudioAPIInstaller(
       jsCallInvoker_(jsCallInvoker) {}
 
 void AudioAPIInstaller::install() {
-  auto audioAPIInstallerWrapper =
-      std::make_shared<AudioAPIInstallerWrapper>(this);
-  AudioAPIInstallerHostObject::createAndInstallFromWrapper(
-      audioAPIInstallerWrapper, rnRuntime_, jsCallInvoker_);
+  auto hostObject =
+      std::make_shared<AudioAPIInstallerHostObject>(rnRuntime_, jsCallInvoker_);
+  hostObject->install();
 }
-
-std::shared_ptr<AudioContext> AudioAPIInstaller::createAudioContext() {
-  return std::make_shared<AudioContext>();
-}
-
 } // namespace audioapi

package/android/src/main/cpp/AudioAPIInstaller/AudioAPIInstaller.h

@@ -8,7 +8,6 @@
 #include <utility>
 
 #include "AudioAPIInstallerHostObject.h"
-#include "AudioAPIInstallerWrapper.h"
 #include "AudioContext.h"
 
 namespace audioapi {
@@ -38,7 +37,6 @@ class AudioAPIInstaller : public jni::HybridClass<AudioAPIInstaller> {
     });
   }
 
-  std::shared_ptr<AudioContext> createAudioContext();
   void install();
 
  private:

package/common/cpp/AudioAPIInstaller/AudioAPIInstallerHostObject.h

@@ -6,46 +6,43 @@
 #include <utility>
 #include <vector>
 
-#include "AudioAPIInstallerWrapper.h"
+#include <JsiHostObject.h>
+#include <JsiPromise.h>
 #include "AudioContextHostObject.h"
-#include "JsiPromise.h"
 
 namespace audioapi {
 using namespace facebook;
 
-class AudioAPIInstallerWrapper;
-
-class AudioAPIInstallerHostObject : public jsi::HostObject {
+class AudioAPIInstallerHostObject
+    : public JsiHostObject,
+      public std::enable_shared_from_this<AudioAPIInstallerHostObject> {
  public:
   explicit AudioAPIInstallerHostObject(
-      const std::shared_ptr<AudioAPIInstallerWrapper> &wrapper,
       jsi::Runtime *runtime,
-      const std::shared_ptr<react::CallInvoker> &jsInvoker);
-
-#ifdef ANDROID
-  static void createAndInstallFromWrapper(
-      const std::shared_ptr<AudioAPIInstallerWrapper> &wrapper,
-      jsi::Runtime *rnRuntime,
-      const std::shared_ptr<react::CallInvoker> &jsInvoker) {
-    auto hostObject = std::make_shared<AudioAPIInstallerHostObject>(
-        wrapper, rnRuntime, jsInvoker);
-    auto object = jsi::Object::createFromHostObject(*rnRuntime, hostObject);
-    rnRuntime->global().setProperty(
-        *rnRuntime, "__AudioAPIInstaller", std::move(object));
-  }
-#endif
+      const std::shared_ptr<react::CallInvoker> &jsInvoker)
+      : rnRuntime_(runtime) {
+    promiseVendor_ = std::make_shared<PromiseVendor>(runtime, jsInvoker);
 
-  jsi::Value get(jsi::Runtime &runtime, const jsi::PropNameID &name) override;
+    addFunctions(
+        JSI_EXPORT_FUNCTION(AudioAPIInstallerHostObject, createAudioContext));
+  }
 
-  void set(
-      jsi::Runtime &runtime,
-      const jsi::PropNameID &name,
-      const jsi::Value &value) override;
+  void install() {
+    auto object =
+        jsi::Object::createFromHostObject(*rnRuntime_, shared_from_this());
+    rnRuntime_->global().setProperty(
+        *rnRuntime_, "__AudioAPIInstaller", std::move(object));
+  }
 
-  std::vector<jsi::PropNameID> getPropertyNames(jsi::Runtime &rt) override;
+  JSI_HOST_FUNCTION(createAudioContext) {
+    auto audioContext = std::make_shared<AudioContext>();
+    auto audioContextHostObject =
+        std::make_shared<AudioContextHostObject>(audioContext, promiseVendor_);
+    return jsi::Object::createFromHostObject(runtime, audioContextHostObject);
+  }
 
  private:
-  std::shared_ptr<AudioAPIInstallerWrapper> wrapper_;
-  std::shared_ptr<JsiPromise::PromiseVendor> promiseVendor_;
+  std::shared_ptr<PromiseVendor> promiseVendor_;
+  jsi::Runtime *rnRuntime_;
 };
 } // namespace audioapi

package/common/cpp/HostObjects/AudioBufferHostObject.h

@@ -4,30 +4,96 @@
 #include <memory>
 #include <vector>
 
-#include "AudioBufferWrapper.h"
+#include <JsiHostObject.h>
+#include "AudioBuffer.h"
 
 namespace audioapi {
 using namespace facebook;
 
-class AudioBufferHostObject : public jsi::HostObject {
+class AudioBufferHostObject : public JsiHostObject {
  public:
-  std::shared_ptr<AudioBufferWrapper> wrapper_;
+  std::shared_ptr<AudioBuffer> audioBuffer_;
 
   explicit AudioBufferHostObject(
-      const std::shared_ptr<AudioBufferWrapper> &wrapper);
+      const std::shared_ptr<AudioBuffer> &audioBuffer)
+      : audioBuffer_(audioBuffer) {
+    addGetters(
+        JSI_EXPORT_PROPERTY_GETTER(AudioBufferHostObject, sampleRate),
+        JSI_EXPORT_PROPERTY_GETTER(AudioBufferHostObject, length),
+        JSI_EXPORT_PROPERTY_GETTER(AudioBufferHostObject, duration),
+        JSI_EXPORT_PROPERTY_GETTER(AudioBufferHostObject, numberOfChannels));
 
-  jsi::Value get(jsi::Runtime &runtime, const jsi::PropNameID &name) override;
+    addFunctions(
+        JSI_EXPORT_FUNCTION(AudioBufferHostObject, getChannelData),
+        JSI_EXPORT_FUNCTION(AudioBufferHostObject, copyFromChannel),
+        JSI_EXPORT_FUNCTION(AudioBufferHostObject, copyToChannel));
+  }
+
+  JSI_PROPERTY_GETTER(sampleRate) {
+    return {audioBuffer_->getSampleRate()};
+  }
+
+  JSI_PROPERTY_GETTER(length) {
+    return {audioBuffer_->getLength()};
+  }
+
+  JSI_PROPERTY_GETTER(duration) {
+    return {audioBuffer_->getDuration()};
+  }
+
+  JSI_PROPERTY_GETTER(numberOfChannels) {
+    return {audioBuffer_->getNumberOfChannels()};
+  }
+
+  JSI_HOST_FUNCTION(getChannelData) {
+    int channel = static_cast<int>(args[0].getNumber());
+    float *channelData = audioBuffer_->getChannelData(channel);
+
+    auto array = jsi::Array(runtime, audioBuffer_->getLength());
+    for (int i = 0; i < audioBuffer_->getLength(); i++) {
+      array.setValueAtIndex(runtime, i, jsi::Value(channelData[i]));
+    }
+
+    return array;
+  }
+
+  JSI_HOST_FUNCTION(copyFromChannel) {
+    auto destination = args[0].getObject(runtime).asArray(runtime);
+    auto destinationLength =
+        static_cast<int>(destination.getProperty(runtime, "length").asNumber());
+    auto channelNumber = static_cast<int>(args[1].getNumber());
+    auto startInChannel = static_cast<int>(args[2].getNumber());
+
+    auto *destinationData = new float[destinationLength];
+
+    audioBuffer_->copyFromChannel(
+        destinationData, destinationLength, channelNumber, startInChannel);
+
+    for (int i = 0; i < destinationLength; i++) {
+      destination.setValueAtIndex(runtime, i, jsi::Value(destinationData[i]));
+    }
+
+    return jsi::Value::undefined();
+  }
+
+  JSI_HOST_FUNCTION(copyToChannel) {
+    auto source = args[0].getObject(runtime).asArray(runtime);
+    auto sourceLength =
+        static_cast<int>(source.getProperty(runtime, "length").asNumber());
+    auto channelNumber = static_cast<int>(args[1].getNumber());
+    auto startInChannel = static_cast<int>(args[2].getNumber());
+
+    auto *sourceData = new float[sourceLength];
 
-  void set(
-      jsi::Runtime &runtime,
-      const jsi::PropNameID &name,
-      const jsi::Value &value) override;
+    for (int i = 0; i < sourceLength; i++) {
+      sourceData[i] =
+          static_cast<float>(source.getValueAtIndex(runtime, i).getNumber());
+    }
 
-  std::vector<jsi::PropNameID> getPropertyNames(jsi::Runtime &rt) override;
+    audioBuffer_->copyToChannel(
+        sourceData, sourceLength, channelNumber, startInChannel);
 
-  static std::shared_ptr<AudioBufferHostObject> createFromWrapper(
-      const std::shared_ptr<AudioBufferWrapper> &wrapper) {
-    return std::make_shared<AudioBufferHostObject>(wrapper);
+    return jsi::Value::undefined();
   }
 };
 } // namespace audioapi

package/common/cpp/HostObjects/AudioBufferSourceNodeHostObject.h

@@ -4,7 +4,8 @@
 #include <vector>
 
 #include "AudioBufferHostObject.h"
-#include "AudioBufferSourceNodeWrapper.h"
+#include "AudioBufferSourceNode.h"
+#include "AudioParamHostObject.h"
 #include "AudioScheduledSourceNodeHostObject.h"
 
 namespace audioapi {
@@ -14,24 +15,102 @@ class AudioBufferSourceNodeHostObject
     : public AudioScheduledSourceNodeHostObject {
  public:
   explicit AudioBufferSourceNodeHostObject(
-      const std::shared_ptr<AudioBufferSourceNodeWrapper> &wrapper);
+      const std::shared_ptr<AudioBufferSourceNode> &node)
+      : AudioScheduledSourceNodeHostObject(node) {
+    addGetters(
+        JSI_EXPORT_PROPERTY_GETTER(AudioBufferSourceNodeHostObject, loop),
+        JSI_EXPORT_PROPERTY_GETTER(AudioBufferSourceNodeHostObject, buffer),
+        JSI_EXPORT_PROPERTY_GETTER(AudioBufferSourceNodeHostObject, loopStart),
+        JSI_EXPORT_PROPERTY_GETTER(AudioBufferSourceNodeHostObject, loopEnd),
+        JSI_EXPORT_PROPERTY_GETTER(AudioBufferSourceNodeHostObject, detune),
+        JSI_EXPORT_PROPERTY_GETTER(
+            AudioBufferSourceNodeHostObject, playbackRate));
+    addSetters(
+        JSI_EXPORT_PROPERTY_SETTER(AudioBufferSourceNodeHostObject, loop),
+        JSI_EXPORT_PROPERTY_SETTER(AudioBufferSourceNodeHostObject, buffer));
+  }
+
+  JSI_PROPERTY_GETTER(loop) {
+    auto audioBufferSourceNode =
+        std::static_pointer_cast<AudioBufferSourceNode>(node_);
+    auto loop = audioBufferSourceNode->getLoop();
+    return {loop};
+  }
+
+  JSI_PROPERTY_GETTER(buffer) {
+    auto audioBufferSourceNode =
+        std::static_pointer_cast<AudioBufferSourceNode>(node_);
+    auto buffer = audioBufferSourceNode->getBuffer();
+
+    if (!buffer) {
+      return jsi::Value::null();
+    }
 
-  jsi::Value get(jsi::Runtime &runtime, const jsi::PropNameID &name) override;
+    auto bufferHostObject = std::make_shared<AudioBufferHostObject>(buffer);
+    return jsi::Object::createFromHostObject(runtime, bufferHostObject);
+  }
 
-  void set(
-      jsi::Runtime &runtime,
-      const jsi::PropNameID &name,
-      const jsi::Value &value) override;
+  JSI_PROPERTY_GETTER(loopStart) {
+    auto audioBufferSourceNode =
+        std::static_pointer_cast<AudioBufferSourceNode>(node_);
+    auto loopStart = audioBufferSourceNode->getLoopStart();
+    return {loopStart};
+  }
 
-  std::vector<jsi::PropNameID> getPropertyNames(jsi::Runtime &rt) override;
+  JSI_PROPERTY_GETTER(loopEnd) {
+    auto audioBufferSourceNode =
+        std::static_pointer_cast<AudioBufferSourceNode>(node_);
+    auto loopEnd = audioBufferSourceNode->getLoopEnd();
+    return {loopEnd};
+  }
+
+  JSI_PROPERTY_GETTER(detune) {
+    auto audioBufferSourceNode =
+        std::static_pointer_cast<AudioBufferSourceNode>(node_);
+    auto detune = audioBufferSourceNode->getDetuneParam();
+    auto detuneHostObject = std::make_shared<AudioParamHostObject>(detune);
+    return jsi::Object::createFromHostObject(runtime, detuneHostObject);
+  }
 
-  static std::shared_ptr<AudioBufferSourceNodeHostObject> createFromWrapper(
-      const std::shared_ptr<AudioBufferSourceNodeWrapper> &wrapper) {
-    return std::make_shared<AudioBufferSourceNodeHostObject>(wrapper);
+  JSI_PROPERTY_GETTER(playbackRate) {
+    auto audioBufferSourceNode =
+        std::static_pointer_cast<AudioBufferSourceNode>(node_);
+    auto playbackRate = audioBufferSourceNode->getPlaybackRateParam();
+    auto playbackRateHostObject =
+        std::make_shared<AudioParamHostObject>(playbackRate);
+    return jsi::Object::createFromHostObject(runtime, playbackRateHostObject);
   }
 
- private:
-  std::shared_ptr<AudioBufferSourceNodeWrapper>
-  getAudioBufferSourceNodeWrapperFromAudioNodeWrapper();
+  JSI_PROPERTY_SETTER(loop) {
+    auto audioBufferSourceNode =
+        std::static_pointer_cast<AudioBufferSourceNode>(node_);
+    audioBufferSourceNode->setLoop(value.getBool());
+  }
+
+  JSI_PROPERTY_SETTER(buffer) {
+    auto audioBufferSourceNode =
+        std::static_pointer_cast<AudioBufferSourceNode>(node_);
+    if (value.isNull()) {
+      audioBufferSourceNode->setBuffer(std::shared_ptr<AudioBuffer>(nullptr));
+      return;
+    }
+
+    auto bufferHostObject =
+        value.getObject(runtime).asHostObject<AudioBufferHostObject>(runtime);
+    audioBufferSourceNode->setBuffer(bufferHostObject->audioBuffer_);
+  }
+
+  JSI_PROPERTY_SETTER(loopStart) {
+    auto audioBufferSourceNode =
+        std::static_pointer_cast<AudioBufferSourceNode>(node_);
+    audioBufferSourceNode->setLoopStart(value.getNumber());
+  }
+
+  JSI_PROPERTY_SETTER(loopEnd) {
+    auto audioBufferSourceNode =
+        std::static_pointer_cast<AudioBufferSourceNode>(node_);
+    audioBufferSourceNode->setLoopEnd(value.getNumber());
+  }
 };
+
 } // namespace audioapi

package/common/cpp/HostObjects/AudioContextHostObject.h

@@ -4,9 +4,8 @@
 #include <memory>
 #include <vector>
 
-#include "AudioContextWrapper.h"
+#include "AudioContext.h"
 #include "BaseAudioContextHostObject.h"
-#include "JsiPromise.h"
 
 namespace audioapi {
 using namespace facebook;
@@ -14,26 +13,16 @@ using namespace facebook;
 class AudioContextHostObject : public BaseAudioContextHostObject {
  public:
   explicit AudioContextHostObject(
-      const std::shared_ptr<AudioContextWrapper> &wrapper,
-      std::shared_ptr<JsiPromise::PromiseVendor> promiseVendor);
-
-  jsi::Value get(jsi::Runtime &runtime, const jsi::PropNameID &name) override;
-
-  void set(
-      jsi::Runtime &runtime,
-      const jsi::PropNameID &name,
-      const jsi::Value &value) override;
-
-  std::vector<jsi::PropNameID> getPropertyNames(jsi::Runtime &rt) override;
-
-  static std::shared_ptr<AudioContextHostObject> createFromWrapper(
-      const std::shared_ptr<AudioContextWrapper> &wrapper,
-      std::shared_ptr<JsiPromise::PromiseVendor> promiseVendor) {
-    return std::make_shared<AudioContextHostObject>(wrapper, promiseVendor);
+      const std::shared_ptr<AudioContext> &audioContext,
+      const std::shared_ptr<PromiseVendor> &promiseVendor)
+      : BaseAudioContextHostObject(audioContext, promiseVendor) {
+    addFunctions(JSI_EXPORT_FUNCTION(AudioContextHostObject, close));
   }
 
- private:
-  std::shared_ptr<AudioContextWrapper>
-  getAudioContextWrapperFromBaseAudioContextWrapper();
+  JSI_HOST_FUNCTION(close) {
+    auto audioContext = std::static_pointer_cast<AudioContext>(context_);
+    audioContext->close();
+    return jsi::Value::undefined();
+  }
 };
 } // namespace audioapi

package/common/cpp/HostObjects/AudioDestinationNodeHostObject.h

@@ -3,7 +3,7 @@
 #include <memory>
 #include <vector>
 
-#include "AudioDestinationNodeWrapper.h"
+#include "AudioDestinationNode.h"
 #include "AudioNodeHostObject.h"
 
 namespace audioapi {
@@ -12,20 +12,7 @@ using namespace facebook;
 class AudioDestinationNodeHostObject : public AudioNodeHostObject {
  public:
   explicit AudioDestinationNodeHostObject(
-      const std::shared_ptr<AudioDestinationNodeWrapper> &wrapper);
-
-  jsi::Value get(jsi::Runtime &runtime, const jsi::PropNameID &name) override;
-
-  void set(
-      jsi::Runtime &runtime,
-      const jsi::PropNameID &name,
-      const jsi::Value &value) override;
-
-  std::vector<jsi::PropNameID> getPropertyNames(jsi::Runtime &rt) override;
-
-  static std::shared_ptr<AudioDestinationNodeHostObject> createFromWrapper(
-      const std::shared_ptr<AudioDestinationNodeWrapper> &wrapper) {
-    return std::make_shared<AudioDestinationNodeHostObject>(wrapper);
-  }
+      const std::shared_ptr<AudioDestinationNode> &node)
+      : AudioNodeHostObject(node) {}
 };
 } // namespace audioapi

package/common/cpp/HostObjects/AudioNodeHostObject.h

@@ -4,26 +4,63 @@
 #include <memory>
 #include <vector>
 
-#include "AudioNodeWrapper.h"
+#include <JsiHostObject.h>
+#include "AudioNode.h"
 
 namespace audioapi {
 using namespace facebook;
 
-class AudioNodeHostObject : public jsi::HostObject {
+class AudioNodeHostObject : public JsiHostObject {
  public:
-  explicit AudioNodeHostObject(
-      const std::shared_ptr<AudioNodeWrapper> &wrapper);
+  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));
+  }
 
-  jsi::Value get(jsi::Runtime &runtime, const jsi::PropNameID &name) override;
+  JSI_PROPERTY_GETTER(numberOfInputs) {
+    return {node_->getNumberOfInputs()};
+  }
 
-  void set(
-      jsi::Runtime &runtime,
-      const jsi::PropNameID &name,
-      const jsi::Value &value) override;
+  JSI_PROPERTY_GETTER(numberOfOutputs) {
+    return {node_->getNumberOfOutputs()};
+  }
 
-  std::vector<jsi::PropNameID> getPropertyNames(jsi::Runtime &rt) override;
+  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 node =
+        args[0].getObject(runtime).getHostObject<AudioNodeHostObject>(runtime);
+    node_->connect(std::shared_ptr<AudioNodeHostObject>(node)->node_);
+    return jsi::Value::undefined();
+  }
+
+  JSI_HOST_FUNCTION(disconnect) {
+    auto node =
+        args[0].getObject(runtime).getHostObject<AudioNodeHostObject>(runtime);
+    node_->disconnect(std::shared_ptr<AudioNodeHostObject>(node)->node_);
+    return jsi::Value::undefined();
+  }
 
  protected:
-  std::shared_ptr<AudioNodeWrapper> wrapper_;
+  std::shared_ptr<AudioNode> node_;
 };
 } // namespace audioapi

package/common/cpp/HostObjects/AudioParamHostObject.h

@@ -4,31 +4,73 @@
 #include <memory>
 #include <vector>
 
-#include "AudioParamWrapper.h"
+#include <JsiHostObject.h>
+#include "AudioParam.h"
 
 namespace audioapi {
 using namespace facebook;
 
-class AudioParamHostObject : public jsi::HostObject {
+class AudioParamHostObject : public JsiHostObject {
  public:
-  explicit AudioParamHostObject(
-      const std::shared_ptr<AudioParamWrapper> &wrapper);
+  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::Value get(jsi::Runtime &runtime, const jsi::PropNameID &name) override;
+    addFunctions(
+        JSI_EXPORT_FUNCTION(AudioParamHostObject, setValueAtTime),
+        JSI_EXPORT_FUNCTION(AudioParamHostObject, linearRampToValueAtTime),
+        JSI_EXPORT_FUNCTION(
+            AudioParamHostObject, exponentialRampToValueAtTime));
 
-  void set(
-      jsi::Runtime &runtime,
-      const jsi::PropNameID &name,
-      const jsi::Value &value) override;
+    addSetters(JSI_EXPORT_PROPERTY_SETTER(AudioParamHostObject, value));
+  }
+
+  JSI_PROPERTY_GETTER(value) {
+    return {param_->getValue()};
+  }
+
+  JSI_PROPERTY_GETTER(defaultValue) {
+    return {param_->getDefaultValue()};
+  }
+
+  JSI_PROPERTY_GETTER(minValue) {
+    return {param_->getMinValue()};
+  }
 
-  std::vector<jsi::PropNameID> getPropertyNames(jsi::Runtime &rt) override;
+  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();
+  }
 
-  static std::shared_ptr<AudioParamHostObject> createFromWrapper(
-      const std::shared_ptr<AudioParamWrapper> &wrapper) {
-    return std::make_shared<AudioParamHostObject>(wrapper);
+  JSI_PROPERTY_SETTER(value) {
+    param_->setValue(static_cast<float>(value.getNumber()));
   }
 
  private:
-  std::shared_ptr<AudioParamWrapper> wrapper_;
+  std::shared_ptr<AudioParam> param_;
 };
 } // namespace audioapi

package/common/cpp/HostObjects/AudioScheduledSourceNodeHostObject.h

@@ -4,7 +4,7 @@
 #include <vector>
 
 #include "AudioNodeHostObject.h"
-#include "AudioScheduledSourceNodeWrapper.h"
+#include "AudioScheduledSourceNode.h"
 
 namespace audioapi {
 using namespace facebook;
@@ -12,20 +12,27 @@ using namespace facebook;
 class AudioScheduledSourceNodeHostObject : public AudioNodeHostObject {
  public:
   explicit AudioScheduledSourceNodeHostObject(
-      const std::shared_ptr<AudioScheduledSourceNodeWrapper> &wrapper)
-      : AudioNodeHostObject(wrapper) {}
-
-  jsi::Value get(jsi::Runtime &runtime, const jsi::PropNameID &name) override;
-
-  void set(
-      jsi::Runtime &runtime,
-      const jsi::PropNameID &name,
-      const jsi::Value &value) override;
-
-  std::vector<jsi::PropNameID> getPropertyNames(jsi::Runtime &rt) override;
-
- private:
-  std::shared_ptr<AudioScheduledSourceNodeWrapper>
-  getAudioScheduledSourceNodeWrapperFromAudioNodeWrapper();
+      const std::shared_ptr<AudioScheduledSourceNode> &node)
+      : AudioNodeHostObject(node) {
+    addFunctions(
+        JSI_EXPORT_FUNCTION(AudioScheduledSourceNodeHostObject, start),
+        JSI_EXPORT_FUNCTION(AudioScheduledSourceNodeHostObject, stop));
+  }
+
+  JSI_HOST_FUNCTION(start) {
+    auto time = args[0].getNumber();
+    auto audioScheduleSourceNode =
+        std::static_pointer_cast<AudioScheduledSourceNode>(node_);
+    audioScheduleSourceNode->start(time);
+    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