react-native-audio-api 0.1.0 → 0.2.0

package/common/cpp/HostObjects/AudioContextHostObject.cpp

@@ -5,29 +5,12 @@ using namespace facebook;
 
 AudioContextHostObject::AudioContextHostObject(
     const std::shared_ptr<AudioContextWrapper> &wrapper)
-    : wrapper_(wrapper) {
-  auto destinationNodeWrapper = wrapper_->getDestination();
-  destination_ =
-      AudioDestinationNodeHostObject::createFromWrapper(destinationNodeWrapper);
-}
+    : BaseAudioContextHostObject(wrapper) {}
 
 std::vector<jsi::PropNameID> AudioContextHostObject::getPropertyNames(
     jsi::Runtime &runtime) {
-  std::vector<jsi::PropNameID> propertyNames;
-  propertyNames.push_back(jsi::PropNameID::forUtf8(runtime, "destination"));
-  propertyNames.push_back(jsi::PropNameID::forUtf8(runtime, "state"));
-  propertyNames.push_back(jsi::PropNameID::forUtf8(runtime, "sampleRate"));
-  propertyNames.push_back(jsi::PropNameID::forUtf8(runtime, "currentTime"));
-  propertyNames.push_back(
-      jsi::PropNameID::forUtf8(runtime, "createOscillator"));
-  propertyNames.push_back(jsi::PropNameID::forUtf8(runtime, "createGain"));
-  propertyNames.push_back(
-      jsi::PropNameID::forUtf8(runtime, "createStereoPanner"));
-  propertyNames.push_back(
-      jsi::PropNameID::forUtf8(runtime, "createBiquadFilter"));
-  propertyNames.push_back(
-      jsi::PropNameID::forUtf8(runtime, "createBufferSource"));
-  propertyNames.push_back(jsi::PropNameID::forUtf8(runtime, "createBuffer"));
+  std::vector<jsi::PropNameID> propertyNames =
+      BaseAudioContextHostObject::getPropertyNames(runtime);
   propertyNames.push_back(jsi::PropNameID::forUtf8(runtime, "close"));
   return propertyNames;
 }
@@ -37,131 +20,6 @@ jsi::Value AudioContextHostObject::get(
     const jsi::PropNameID &propNameId) {
   auto propName = propNameId.utf8(runtime);
 
-  if (propName == "destination") {
-    return jsi::Object::createFromHostObject(runtime, destination_);
-  }
-
-  if (propName == "state") {
-    return jsi::String::createFromUtf8(runtime, wrapper_->getState());
-  }
-
-  if (propName == "sampleRate") {
-    return {wrapper_->getSampleRate()};
-  }
-
-  if (propName == "currentTime") {
-    return {wrapper_->getCurrentTime()};
-  }
-
-  if (propName == "createOscillator") {
-    return jsi::Function::createFromHostFunction(
-        runtime,
-        propNameId,
-        0,
-        [this](
-            jsi::Runtime &runtime,
-            const jsi::Value &thisValue,
-            const jsi::Value *arguments,
-            size_t count) -> jsi::Value {
-          auto oscillator = wrapper_->createOscillator();
-          auto oscillatorHostObject =
-              OscillatorNodeHostObject::createFromWrapper(oscillator);
-          return jsi::Object::createFromHostObject(
-              runtime, oscillatorHostObject);
-        });
-  }
-
-  if (propName == "createGain") {
-    return jsi::Function::createFromHostFunction(
-        runtime,
-        propNameId,
-        0,
-        [this](
-            jsi::Runtime &runtime,
-            const jsi::Value &thisValue,
-            const jsi::Value *arguments,
-            size_t count) -> jsi::Value {
-          auto gain = wrapper_->createGain();
-          auto gainHostObject = GainNodeHostObject::createFromWrapper(gain);
-          return jsi::Object::createFromHostObject(runtime, gainHostObject);
-        });
-  }
-
-  if (propName == "createStereoPanner") {
-    return jsi::Function::createFromHostFunction(
-        runtime,
-        propNameId,
-        0,
-        [this](
-            jsi::Runtime &runtime,
-            const jsi::Value &thisValue,
-            const jsi::Value *arguments,
-            size_t count) -> jsi::Value {
-          auto stereoPanner = wrapper_->createStereoPanner();
-          auto stereoPannerHostObject =
-              StereoPannerNodeHostObject::createFromWrapper(stereoPanner);
-          return jsi::Object::createFromHostObject(
-              runtime, stereoPannerHostObject);
-        });
-  }
-
-  if (propName == "createBiquadFilter") {
-    return jsi::Function::createFromHostFunction(
-        runtime,
-        propNameId,
-        0,
-        [this](
-            jsi::Runtime &runtime,
-            const jsi::Value &thisValue,
-            const jsi::Value *arguments,
-            size_t count) -> jsi::Value {
-          auto biquadFilter = wrapper_->createBiquadFilter();
-          auto biquadFilterHostObject =
-              BiquadFilterNodeHostObject::createFromWrapper(biquadFilter);
-          return jsi::Object::createFromHostObject(
-              runtime, biquadFilterHostObject);
-        });
-  }
-
-  if (propName == "createBufferSource") {
-    return jsi::Function::createFromHostFunction(
-        runtime,
-        propNameId,
-        0,
-        [this](
-            jsi::Runtime &runtime,
-            const jsi::Value &thisValue,
-            const jsi::Value *arguments,
-            size_t count) -> jsi::Value {
-          auto bufferSource = wrapper_->createBufferSource();
-          auto bufferSourceHostObject =
-              AudioBufferSourceNodeHostObject::createFromWrapper(bufferSource);
-          return jsi::Object::createFromHostObject(
-              runtime, bufferSourceHostObject);
-        });
-  }
-
-  if (propName == "createBuffer") {
-    return jsi::Function::createFromHostFunction(
-        runtime,
-        propNameId,
-        3,
-        [this](
-            jsi::Runtime &runtime,
-            const jsi::Value &thisValue,
-            const jsi::Value *arguments,
-            size_t count) -> jsi::Value {
-          auto numberOfChannels = static_cast<int>(arguments[0].getNumber());
-          auto length = static_cast<int>(arguments[1].getNumber());
-          auto sampleRate = static_cast<int>(arguments[2].getNumber());
-          auto buffer =
-              wrapper_->createBuffer(numberOfChannels, length, sampleRate);
-          auto bufferHostObject =
-              AudioBufferHostObject::createFromWrapper(buffer);
-          return jsi::Object::createFromHostObject(runtime, bufferHostObject);
-        });
-  }
-
   if (propName == "close") {
     return jsi::Function::createFromHostFunction(
         runtime,
@@ -172,12 +30,12 @@ jsi::Value AudioContextHostObject::get(
             const jsi::Value &thisValue,
             const jsi::Value *arguments,
             size_t count) -> jsi::Value {
-          wrapper_->close();
+          getAudioContextWrapperFromBaseAudioContextWrapper()->close();
           return jsi::Value::undefined();
         });
   }
 
-  throw std::runtime_error("Not yet implemented!");
+  return BaseAudioContextHostObject::get(runtime, propNameId);
 }
 
 void AudioContextHostObject::set(
@@ -186,6 +44,11 @@ void AudioContextHostObject::set(
     const jsi::Value &value) {
   auto propName = propNameId.utf8(runtime);
 
-  throw std::runtime_error("Not yet implemented!");
+  return BaseAudioContextHostObject::set(runtime, propNameId, value);
+}
+
+std::shared_ptr<AudioContextWrapper>
+AudioContextHostObject::getAudioContextWrapperFromBaseAudioContextWrapper() {
+  return std::static_pointer_cast<AudioContextWrapper>(wrapper_);
 }
 } // namespace audioapi

package/common/cpp/HostObjects/AudioContextHostObject.h

@@ -2,22 +2,15 @@
 
 #include <jsi/jsi.h>
 #include <memory>
-#include <utility>
 #include <vector>
 
-#include "AudioBufferHostObject.h"
-#include "AudioBufferSourceNodeHostObject.h"
 #include "AudioContextWrapper.h"
-#include "AudioDestinationNodeHostObject.h"
-#include "BiquadFilterNodeHostObject.h"
-#include "GainNodeHostObject.h"
-#include "OscillatorNodeHostObject.h"
-#include "StereoPannerNodeHostObject.h"
+#include "BaseAudioContextHostObject.h"
 
 namespace audioapi {
 using namespace facebook;
 
-class AudioContextHostObject : public jsi::HostObject {
+class AudioContextHostObject : public BaseAudioContextHostObject {
  public:
   explicit AudioContextHostObject(
       const std::shared_ptr<AudioContextWrapper> &wrapper);
@@ -37,7 +30,7 @@ class AudioContextHostObject : public jsi::HostObject {
   }
 
  private:
-  std::shared_ptr<AudioContextWrapper> wrapper_;
-  std::shared_ptr<AudioDestinationNodeHostObject> destination_;
+  std::shared_ptr<AudioContextWrapper>
+  getAudioContextWrapperFromBaseAudioContextWrapper();
 };
 } // namespace audioapi

package/common/cpp/HostObjects/AudioNodeHostObject.cpp

@@ -21,7 +21,6 @@ std::vector<jsi::PropNameID> AudioNodeHostObject::getPropertyNames(
       jsi::PropNameID::forAscii(runtime, "channelCountMode"));
   propertyNames.push_back(
       jsi::PropNameID::forAscii(runtime, "channelInterpretation"));
-  propertyNames.push_back(jsi::PropNameID::forAscii(runtime, "context"));
   return propertyNames;
 }
 
@@ -88,11 +87,6 @@ jsi::Value AudioNodeHostObject::get(
         runtime, wrapper_->getChannelInterpretation());
   }
 
-  if (propName == "context") {
-    // TODO fix this
-    return jsi::Value::undefined();
-  }
-
   throw std::runtime_error("Not yet implemented!");
 }
 

package/common/cpp/HostObjects/BaseAudioContextHostObject.cpp

@@ -0,0 +1,214 @@
+#include "BaseAudioContextHostObject.h"
+
+namespace audioapi {
+using namespace facebook;
+
+BaseAudioContextHostObject::BaseAudioContextHostObject(
+    const std::shared_ptr<BaseAudioContextWrapper> &wrapper)
+    : wrapper_(wrapper) {
+  auto destinationNodeWrapper = wrapper_->getDestination();
+  destination_ =
+      AudioDestinationNodeHostObject::createFromWrapper(destinationNodeWrapper);
+}
+
+std::vector<jsi::PropNameID> BaseAudioContextHostObject::getPropertyNames(
+    jsi::Runtime &runtime) {
+  std::vector<jsi::PropNameID> propertyNames;
+  propertyNames.push_back(jsi::PropNameID::forUtf8(runtime, "destination"));
+  propertyNames.push_back(jsi::PropNameID::forUtf8(runtime, "state"));
+  propertyNames.push_back(jsi::PropNameID::forUtf8(runtime, "sampleRate"));
+  propertyNames.push_back(jsi::PropNameID::forUtf8(runtime, "currentTime"));
+  propertyNames.push_back(
+      jsi::PropNameID::forUtf8(runtime, "createOscillator"));
+  propertyNames.push_back(jsi::PropNameID::forUtf8(runtime, "createGain"));
+  propertyNames.push_back(
+      jsi::PropNameID::forUtf8(runtime, "createStereoPanner"));
+  propertyNames.push_back(
+      jsi::PropNameID::forUtf8(runtime, "createBiquadFilter"));
+  propertyNames.push_back(
+      jsi::PropNameID::forUtf8(runtime, "createBufferSource"));
+  propertyNames.push_back(jsi::PropNameID::forUtf8(runtime, "createBuffer"));
+  propertyNames.push_back(
+      jsi::PropNameID::forUtf8(runtime, "createPeriodicWave"));
+  return propertyNames;
+}
+
+jsi::Value BaseAudioContextHostObject::get(
+    jsi::Runtime &runtime,
+    const jsi::PropNameID &propNameId) {
+  auto propName = propNameId.utf8(runtime);
+
+  if (propName == "destination") {
+    return jsi::Object::createFromHostObject(runtime, destination_);
+  }
+
+  if (propName == "state") {
+    return jsi::String::createFromUtf8(runtime, wrapper_->getState());
+  }
+
+  if (propName == "sampleRate") {
+    return {wrapper_->getSampleRate()};
+  }
+
+  if (propName == "currentTime") {
+    return {wrapper_->getCurrentTime()};
+  }
+
+  if (propName == "createOscillator") {
+    return jsi::Function::createFromHostFunction(
+        runtime,
+        propNameId,
+        0,
+        [this](
+            jsi::Runtime &runtime,
+            const jsi::Value &thisValue,
+            const jsi::Value *arguments,
+            size_t count) -> jsi::Value {
+          auto oscillator = wrapper_->createOscillator();
+          auto oscillatorHostObject =
+              OscillatorNodeHostObject::createFromWrapper(oscillator);
+          return jsi::Object::createFromHostObject(
+              runtime, oscillatorHostObject);
+        });
+  }
+
+  if (propName == "createGain") {
+    return jsi::Function::createFromHostFunction(
+        runtime,
+        propNameId,
+        0,
+        [this](
+            jsi::Runtime &runtime,
+            const jsi::Value &thisValue,
+            const jsi::Value *arguments,
+            size_t count) -> jsi::Value {
+          auto gain = wrapper_->createGain();
+          auto gainHostObject = GainNodeHostObject::createFromWrapper(gain);
+          return jsi::Object::createFromHostObject(runtime, gainHostObject);
+        });
+  }
+
+  if (propName == "createStereoPanner") {
+    return jsi::Function::createFromHostFunction(
+        runtime,
+        propNameId,
+        0,
+        [this](
+            jsi::Runtime &runtime,
+            const jsi::Value &thisValue,
+            const jsi::Value *arguments,
+            size_t count) -> jsi::Value {
+          auto stereoPanner = wrapper_->createStereoPanner();
+          auto stereoPannerHostObject =
+              StereoPannerNodeHostObject::createFromWrapper(stereoPanner);
+          return jsi::Object::createFromHostObject(
+              runtime, stereoPannerHostObject);
+        });
+  }
+
+  if (propName == "createBiquadFilter") {
+    return jsi::Function::createFromHostFunction(
+        runtime,
+        propNameId,
+        0,
+        [this](
+            jsi::Runtime &runtime,
+            const jsi::Value &thisValue,
+            const jsi::Value *arguments,
+            size_t count) -> jsi::Value {
+          auto biquadFilter = wrapper_->createBiquadFilter();
+          auto biquadFilterHostObject =
+              BiquadFilterNodeHostObject::createFromWrapper(biquadFilter);
+          return jsi::Object::createFromHostObject(
+              runtime, biquadFilterHostObject);
+        });
+  }
+
+  if (propName == "createBufferSource") {
+    return jsi::Function::createFromHostFunction(
+        runtime,
+        propNameId,
+        0,
+        [this](
+            jsi::Runtime &runtime,
+            const jsi::Value &thisValue,
+            const jsi::Value *arguments,
+            size_t count) -> jsi::Value {
+          auto bufferSource = wrapper_->createBufferSource();
+          auto bufferSourceHostObject =
+              AudioBufferSourceNodeHostObject::createFromWrapper(bufferSource);
+          return jsi::Object::createFromHostObject(
+              runtime, bufferSourceHostObject);
+        });
+  }
+
+  if (propName == "createBuffer") {
+    return jsi::Function::createFromHostFunction(
+        runtime,
+        propNameId,
+        3,
+        [this](
+            jsi::Runtime &runtime,
+            const jsi::Value &thisValue,
+            const jsi::Value *arguments,
+            size_t count) -> jsi::Value {
+          auto numberOfChannels = static_cast<int>(arguments[0].getNumber());
+          auto length = static_cast<int>(arguments[1].getNumber());
+          auto sampleRate = static_cast<int>(arguments[2].getNumber());
+          auto buffer =
+              wrapper_->createBuffer(numberOfChannels, length, sampleRate);
+          auto bufferHostObject =
+              AudioBufferHostObject::createFromWrapper(buffer);
+          return jsi::Object::createFromHostObject(runtime, bufferHostObject);
+        });
+  }
+
+  if (propName == "createPeriodicWave") {
+    return jsi::Function::createFromHostFunction(
+        runtime,
+        propNameId,
+        3,
+        [this](
+            jsi::Runtime &runtime,
+            const jsi::Value &thisValue,
+            const jsi::Value *arguments,
+            size_t count) -> jsi::Value {
+          auto real = arguments[0].getObject(runtime).getArray(runtime);
+          auto imag = arguments[1].getObject(runtime).getArray(runtime);
+          auto disableNormalization = arguments[2].getBool();
+          auto length =
+              static_cast<int>(real.getProperty(runtime, "length").asNumber());
+
+          auto *realData = new float[length];
+          auto *imagData = new float[length];
+
+          for (size_t i = 0; i < real.length(runtime); i++) {
+            realData[i] = static_cast<float>(
+                real.getValueAtIndex(runtime, i).getNumber());
+          }
+          for (size_t i = 0; i < imag.length(runtime); i++) {
+            realData[i] = static_cast<float>(
+                imag.getValueAtIndex(runtime, i).getNumber());
+          }
+
+          auto periodicWave = wrapper_->createPeriodicWave(
+              realData, imagData, disableNormalization, length);
+          auto periodicWaveHostObject =
+              PeriodicWaveHostObject::createFromWrapper(periodicWave);
+          return jsi::Object::createFromHostObject(
+              runtime, periodicWaveHostObject);
+        });
+  }
+
+  throw std::runtime_error("Not yet implemented!");
+}
+
+void BaseAudioContextHostObject::set(
+    jsi::Runtime &runtime,
+    const jsi::PropNameID &propNameId,
+    const jsi::Value &value) {
+  auto propName = propNameId.utf8(runtime);
+
+  throw std::runtime_error("Not yet implemented!");
+}
+} // namespace audioapi

package/common/cpp/HostObjects/BaseAudioContextHostObject.h

@@ -0,0 +1,39 @@
+#pragma once
+
+#include <jsi/jsi.h>
+#include <memory>
+#include <utility>
+#include <vector>
+
+#include "AudioBufferHostObject.h"
+#include "AudioBufferSourceNodeHostObject.h"
+#include "AudioDestinationNodeHostObject.h"
+#include "BaseAudioContextWrapper.h"
+#include "BiquadFilterNodeHostObject.h"
+#include "GainNodeHostObject.h"
+#include "OscillatorNodeHostObject.h"
+#include "PeriodicWaveHostObject.h"
+#include "StereoPannerNodeHostObject.h"
+
+namespace audioapi {
+using namespace facebook;
+
+class BaseAudioContextHostObject : public jsi::HostObject {
+ public:
+  explicit BaseAudioContextHostObject(
+      const std::shared_ptr<BaseAudioContextWrapper> &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;
+
+ protected:
+  std::shared_ptr<BaseAudioContextWrapper> wrapper_;
+  std::shared_ptr<AudioDestinationNodeHostObject> destination_;
+};
+} // namespace audioapi

package/common/cpp/HostObjects/BiquadFilterNodeHostObject.cpp

@@ -30,6 +30,8 @@ std::vector<jsi::PropNameID> BiquadFilterNodeHostObject::getPropertyNames(
   propertyNames.push_back(jsi::PropNameID::forAscii(runtime, "Q"));
   propertyNames.push_back(jsi::PropNameID::forAscii(runtime, "gain"));
   propertyNames.push_back(jsi::PropNameID::forAscii(runtime, "type"));
+  propertyNames.push_back(
+      jsi::PropNameID::forAscii(runtime, "getFrequencyResponse"));
   return propertyNames;
 }
 
@@ -60,6 +62,48 @@ jsi::Value BiquadFilterNodeHostObject::get(
     return jsi::String::createFromUtf8(runtime, waveType);
   }
 
+  if (propName == "getFrequencyResponse") {
+    return jsi::Function::createFromHostFunction(
+        runtime,
+        propNameId,
+        3,
+        [this](
+            jsi::Runtime &rt,
+            const jsi::Value &thisVal,
+            const jsi::Value *args,
+            size_t count) -> jsi::Value {
+          auto frequencyArray = args[0].getObject(rt).asArray(rt);
+          auto magResponseOut = args[1].getObject(rt).asArray(rt);
+          auto phaseResponseOut = args[2].getObject(rt).asArray(rt);
+
+          std::vector<float> frequencyArrayVector(frequencyArray.length(rt));
+          for (size_t i = 0; i < frequencyArray.length(rt); i++) {
+            frequencyArrayVector[i] = static_cast<float>(
+                frequencyArray.getValueAtIndex(rt, i).getNumber());
+          }
+
+          std::vector<float> magResponseOutVector(magResponseOut.length(rt));
+          std::vector<float> phaseResponseOutVector(
+              phaseResponseOut.length(rt));
+
+          auto wrapper = getBiquadFilterNodeWrapperFromAudioNodeWrapper();
+          wrapper->getFrequencyResponse(
+              frequencyArrayVector,
+              magResponseOutVector,
+              phaseResponseOutVector);
+
+          for (size_t i = 0; i < magResponseOutVector.size(); i++) {
+            magResponseOut.setValueAtIndex(rt, i, magResponseOutVector[i]);
+          }
+
+          for (size_t i = 0; i < phaseResponseOutVector.size(); i++) {
+            phaseResponseOut.setValueAtIndex(rt, i, phaseResponseOutVector[i]);
+          }
+
+          return jsi::Value::undefined();
+        });
+  }
+
   return AudioNodeHostObject::get(runtime, propNameId);
 }
 

package/common/cpp/HostObjects/OscillatorNodeHostObject.cpp

@@ -24,6 +24,8 @@ std::vector<jsi::PropNameID> OscillatorNodeHostObject::getPropertyNames(
   propertyNames.push_back(jsi::PropNameID::forAscii(runtime, "frequency"));
   propertyNames.push_back(jsi::PropNameID::forAscii(runtime, "detune"));
   propertyNames.push_back(jsi::PropNameID::forAscii(runtime, "type"));
+  propertyNames.push_back(
+      jsi::PropNameID::forAscii(runtime, "setPeriodicWave"));
   return propertyNames;
 }
 
@@ -46,6 +48,25 @@ jsi::Value OscillatorNodeHostObject::get(
     return jsi::String::createFromUtf8(runtime, waveType);
   }
 
+  if (propName == "setPeriodicWave") {
+    return jsi::Function::createFromHostFunction(
+        runtime,
+        propNameId,
+        1,
+        [this](
+            jsi::Runtime &rt,
+            const jsi::Value &thisVal,
+            const jsi::Value *args,
+            size_t count) -> jsi::Value {
+          auto wrapper = getOscillatorNodeWrapperFromAudioNodeWrapper();
+          auto periodicWaveHostObject =
+              args[0].getObject(rt).asHostObject<PeriodicWaveHostObject>(rt);
+
+          wrapper->setPeriodicWave(periodicWaveHostObject->wrapper_);
+          return jsi::Value::undefined();
+        });
+  }
+
   return AudioScheduledSourceNodeHostObject::get(runtime, propNameId);
 }
 

package/common/cpp/HostObjects/OscillatorNodeHostObject.h

@@ -7,6 +7,7 @@
 #include "AudioParamHostObject.h"
 #include "AudioScheduledSourceNodeHostObject.h"
 #include "OscillatorNodeWrapper.h"
+#include "PeriodicWaveHostObject.h"
 
 namespace audioapi {
 using namespace facebook;

package/common/cpp/HostObjects/PeriodicWaveHostObject.cpp

@@ -0,0 +1,33 @@
+#include "PeriodicWaveHostObject.h"
+
+namespace audioapi {
+using namespace facebook;
+
+PeriodicWaveHostObject::PeriodicWaveHostObject(
+    const std::shared_ptr<PeriodicWaveWrapper> &wrapper)
+    : wrapper_(wrapper) {}
+
+std::vector<jsi::PropNameID> PeriodicWaveHostObject::getPropertyNames(
+    jsi::Runtime &runtime) {
+  std::vector<jsi::PropNameID> propertyNames;
+  return propertyNames;
+}
+
+jsi::Value PeriodicWaveHostObject::get(
+    jsi::Runtime &runtime,
+    const jsi::PropNameID &propNameId) {
+  auto propName = propNameId.utf8(runtime);
+
+  throw std::runtime_error("Not yet implemented!");
+}
+
+void PeriodicWaveHostObject::set(
+    jsi::Runtime &runtime,
+    const jsi::PropNameID &propNameId,
+    const jsi::Value &value) {
+  auto propName = propNameId.utf8(runtime);
+
+  throw std::runtime_error("Not yet implemented!");
+}
+
+} // namespace audioapi

package/common/cpp/HostObjects/PeriodicWaveHostObject.h

@@ -0,0 +1,33 @@
+#pragma once
+
+#include <jsi/jsi.h>
+#include <memory>
+#include <vector>
+
+#include "PeriodicWaveWrapper.h"
+
+namespace audioapi {
+using namespace facebook;
+
+class PeriodicWaveHostObject : public jsi::HostObject {
+ public:
+  std::shared_ptr<PeriodicWaveWrapper> wrapper_;
+
+  explicit PeriodicWaveHostObject(
+      const std::shared_ptr<PeriodicWaveWrapper> &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<PeriodicWaveHostObject> createFromWrapper(
+      const std::shared_ptr<PeriodicWaveWrapper> &wrapper) {
+    return std::make_shared<PeriodicWaveHostObject>(wrapper);
+  }
+};
+} // namespace audioapi