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

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

@@ -5,18 +5,16 @@ namespace audioapi {
 using namespace facebook::jni;
 
 AudioAPIInstaller::AudioAPIInstaller(
-    jni::alias_ref<AudioAPIInstaller::jhybridobject> &jThis)
-    : javaPart_(make_global(jThis)) {}
+    jni::alias_ref<AudioAPIInstaller::jhybridobject> &jThis,
+    jsi::Runtime *rnRuntime,
+    const std::shared_ptr<facebook::react::CallInvoker> &jsCallInvoker)
+    : javaPart_(make_global(jThis)),
+      rnRuntime_(rnRuntime),
+      jsCallInvoker_(jsCallInvoker) {}
 
-void AudioAPIInstaller::install(jlong jsContext) {
-  auto audioAPIInstallerWrapper =
-      std::make_shared<AudioAPIInstallerWrapper>(this);
-  AudioAPIInstallerHostObject::createAndInstallFromWrapper(
-      audioAPIInstallerWrapper, jsContext);
+void AudioAPIInstaller::install() {
+  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

@@ -1,20 +1,19 @@
 #pragma once
 
+#include <ReactCommon/CallInvokerHolder.h>
 #include <fbjni/fbjni.h>
-#include <jsi/jsi.h>
 #include <react/jni/CxxModuleWrapper.h>
 #include <react/jni/JMessageQueueThread.h>
 #include <memory>
 #include <utility>
 
 #include "AudioAPIInstallerHostObject.h"
-#include "AudioAPIInstallerWrapper.h"
 #include "AudioContext.h"
 
 namespace audioapi {
 
 using namespace facebook;
-using namespace facebook::jni;
+using namespace react;
 
 class AudioAPIInstaller : public jni::HybridClass<AudioAPIInstaller> {
  public:
@@ -22,8 +21,13 @@ class AudioAPIInstaller : public jni::HybridClass<AudioAPIInstaller> {
       "Lcom/swmansion/audioapi/module/AudioAPIInstaller;";
 
   static jni::local_ref<AudioAPIInstaller::jhybriddata> initHybrid(
-      jni::alias_ref<jhybridobject> jThis) {
-    return makeCxxInstance(jThis);
+      jni::alias_ref<jhybridobject> jThis,
+      jlong jsContext,
+      jni::alias_ref<facebook::react::CallInvokerHolder::javaobject>
+          jsCallInvokerHolder) {
+    auto jsCallInvoker = jsCallInvokerHolder->cthis()->getCallInvoker();
+    auto rnRuntime = reinterpret_cast<jsi::Runtime *>(jsContext);
+    return makeCxxInstance(jThis, rnRuntime, jsCallInvoker);
   }
 
   static void registerNatives() {
@@ -33,16 +37,19 @@ class AudioAPIInstaller : public jni::HybridClass<AudioAPIInstaller> {
     });
   }
 
-  std::shared_ptr<AudioContext> createAudioContext();
-  void install(jlong jsContext);
+  void install();
 
  private:
   friend HybridBase;
 
-  global_ref<AudioAPIInstaller::javaobject> javaPart_;
+  jni::global_ref<AudioAPIInstaller::javaobject> javaPart_;
+  jsi::Runtime *rnRuntime_;
+  std::shared_ptr<facebook::react::CallInvoker> jsCallInvoker_;
 
   explicit AudioAPIInstaller(
-      jni::alias_ref<AudioAPIInstaller::jhybridobject> &jThis);
+      jni::alias_ref<AudioAPIInstaller::jhybridobject> &jThis,
+      jsi::Runtime *rnRuntime,
+      const std::shared_ptr<facebook::react::CallInvoker> &jsCallInvoker);
 };
 
 } // namespace audioapi

package/android/src/main/cpp/AudioDecoder/AudioDecoder.cpp

@@ -0,0 +1,64 @@
+#include "AudioDecoder.h"
+
+#define MINIAUDIO_IMPLEMENTATION
+#include <android/log.h>
+#include <miniaudio.h>
+
+#include "AudioArray.h"
+#include "AudioBus.h"
+
+namespace audioapi {
+
+AudioDecoder::AudioDecoder(int sampleRate) : sampleRate_(sampleRate) {}
+
+AudioBus *AudioDecoder::decodeWithFilePath(const std::string &path) const {
+  ma_decoder decoder;
+  ma_decoder_config config =
+      ma_decoder_config_init(ma_format_f32, 2, sampleRate_);
+  ma_result result = ma_decoder_init_file(path.c_str(), &config, &decoder);
+  if (result != MA_SUCCESS) {
+    __android_log_print(
+        ANDROID_LOG_ERROR,
+        "AudioDecoder",
+        "Failed to initialize decoder for file: %s",
+        path.c_str());
+    return new AudioBus(1, 1, 1);
+  }
+
+  ma_uint64 totalFrameCount;
+  ma_decoder_get_length_in_pcm_frames(&decoder, &totalFrameCount);
+
+  auto *audioBus =
+      new AudioBus(sampleRate_, static_cast<int>(totalFrameCount), 2);
+  auto *buffer = new float[totalFrameCount * 2];
+
+  ma_uint64 framesDecoded;
+  ma_decoder_read_pcm_frames(&decoder, buffer, totalFrameCount, &framesDecoded);
+  if (framesDecoded == 0) {
+    __android_log_print(
+        ANDROID_LOG_ERROR,
+        "AudioDecoder",
+        "Failed to decode audio file: %s",
+        path.c_str());
+  }
+
+  for (int i = 0; i < decoder.outputChannels; ++i) {
+    float *channelData = audioBus->getChannel(i)->getData();
+
+    for (ma_uint64 j = 0; j < framesDecoded; ++j) {
+      channelData[j] = buffer[j * decoder.outputChannels + i];
+    }
+  }
+
+  delete[] buffer;
+  ma_decoder_uninit(&decoder);
+
+  return audioBus;
+}
+
+AudioBus *AudioDecoder::decodeWithArrayBuffer() const {
+  // TODO: implement this
+  return new AudioBus(1, 1, 1);
+}
+
+} // namespace audioapi

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

@@ -0,0 +1,21 @@
+#pragma once
+
+#include <string>
+
+namespace audioapi {
+
+class AudioBus;
+
+class AudioDecoder {
+ public:
+  explicit AudioDecoder(int sampleRate);
+
+  [[nodiscard]] AudioBus *decodeWithFilePath(const std::string &path) const;
+  // TODO: implement this
+  [[nodiscard]] AudioBus *decodeWithArrayBuffer() const;
+
+ private:
+  int sampleRate_;
+};
+
+} // namespace audioapi

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

@@ -14,8 +14,8 @@ class AudioPlayer : public AudioStreamDataCallback {
  public:
   explicit AudioPlayer(const std::function<void(AudioBus *, int)> &renderAudio);
 
-  int getSampleRate() const;
-  int getBufferSizeInFrames() const;
+  [[nodiscard]] int getSampleRate() const;
+  [[nodiscard]] int getBufferSizeInFrames() const;
   void start();
   void stop();
 

package/android/src/main/java/com/swmansion/audioapi/module/AudioAPIInstaller.kt

@@ -1,8 +1,14 @@
 package com.swmansion.audioapi.module
 
 import com.facebook.jni.HybridData
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.common.annotations.FrameworkAPI
+import com.facebook.react.turbomodule.core.CallInvokerHolderImpl
 
-class AudioAPIInstaller {
+@OptIn(FrameworkAPI::class)
+class AudioAPIInstaller(
+  reactContext: ReactApplicationContext,
+) {
   private val mHybridData: HybridData?
 
   companion object {
@@ -12,10 +18,14 @@ class AudioAPIInstaller {
   }
 
   init {
-    mHybridData = initHybrid()
+    val jsCallInvokerHolder = reactContext.jsCallInvokerHolder as CallInvokerHolderImpl
+    mHybridData = initHybrid(reactContext.javaScriptContextHolder!!.get(), jsCallInvokerHolder)
   }
 
-  external fun initHybrid(): HybridData?
+  external fun initHybrid(
+    jsContext: Long,
+    callInvoker: CallInvokerHolderImpl,
+  ): HybridData?
 
-  external fun install(jsContext: Long)
+  external fun install()
 }

package/android/src/main/java/com/swmansion/audioapi/nativemodules/AudioAPIModule.kt

@@ -12,9 +12,8 @@ class AudioAPIModule(
 
   @ReactMethod(isBlockingSynchronousMethod = true)
   fun install(): Boolean {
-    val audioAPIInstaller = AudioAPIInstaller()
-    val jsContext = reactContext.javaScriptContextHolder!!.get()
-    audioAPIInstaller.install(jsContext)
+    val audioAPIInstaller = AudioAPIInstaller(reactContext)
+    audioAPIInstaller.install()
 
     return true
   }

package/common/cpp/AudioAPIInstaller/AudioAPIInstallerHostObject.h

@@ -6,44 +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,
-      jlong jsContext) {
-    auto runtime = reinterpret_cast<jsi::Runtime *>(jsContext);
-    auto hostObject = std::make_shared<AudioAPIInstallerHostObject>(wrapper);
-    auto object = jsi::Object::createFromHostObject(*runtime, hostObject);
-    runtime->global().setProperty(
-        *runtime, "__AudioAPIInstaller", std::move(object));
-  }
-#endif
+      jsi::Runtime *runtime,
+      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,8 +4,7 @@
 #include <memory>
 #include <vector>
 
-#include"JsiPromise.h"
-#include "AudioContextWrapper.h"
+#include "AudioContext.h"
 #include "BaseAudioContextHostObject.h"
 
 namespace audioapi {
@@ -14,24 +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