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

package/common/cpp/HostObjects/BaseAudioContextHostObject.cpp

@@ -1,250 +0,0 @@
-#include <thread>
-
-#include "BaseAudioContextHostObject.h"
-
-namespace audioapi {
-using namespace facebook;
-
-BaseAudioContextHostObject::BaseAudioContextHostObject(
-    const std::shared_ptr<BaseAudioContextWrapper> &wrapper,
-    std::shared_ptr<JsiPromise::PromiseVendor> promiseVendor)
-    : wrapper_(wrapper), promiseVendor_(promiseVendor) {
-  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"));
-  propertyNames.push_back(
-      jsi::PropNameID::forUtf8(runtime, "decodeAudioDataSource"));
-  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);
-        });
-  }
-
-  if (propName == "decodeAudioDataSource") {
-    auto decode = [this](
-                      jsi::Runtime &runtime,
-                      const jsi::Value &,
-                      const jsi::Value *arguments,
-                      size_t count) -> jsi::Value {
-      auto sourcePath = arguments[0].getString(runtime).utf8(runtime);
-
-      auto promise = promiseVendor_->createPromise(
-          [this, &runtime, sourcePath](
-              std::shared_ptr<JsiPromise::Promise> promise) {
-            std::thread([this,
-                         &runtime,
-                         sourcePath,
-                         promise = std::move(promise)]() {
-              auto results = wrapper_->decodeAudioDataSource(sourcePath);
-              auto audioBufferHostObject =
-                  AudioBufferHostObject::createFromWrapper(results);
-
-              promise->resolve(jsi::Object::createFromHostObject(
-                  runtime, audioBufferHostObject));
-            }).detach();
-          });
-
-      return promise;
-    };
-
-    return jsi::Function::createFromHostFunction(
-        runtime, propNameId, 1, decode);
-  }
-
-  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/BiquadFilterNodeHostObject.cpp

@@ -1,125 +0,0 @@
-#include "BiquadFilterNodeHostObject.h"
-
-namespace audioapi {
-using namespace facebook;
-
-std::shared_ptr<BiquadFilterNodeWrapper>
-BiquadFilterNodeHostObject::getBiquadFilterNodeWrapperFromAudioNodeWrapper() {
-  return std::static_pointer_cast<BiquadFilterNodeWrapper>(wrapper_);
-}
-
-BiquadFilterNodeHostObject::BiquadFilterNodeHostObject(
-    const std::shared_ptr<BiquadFilterNodeWrapper> &wrapper)
-    : AudioNodeHostObject(wrapper) {
-  auto frequencyParam = wrapper->getFrequencyParam();
-  frequencyParam_ = AudioParamHostObject::createFromWrapper(frequencyParam);
-  auto detuneParam = wrapper->getDetuneParam();
-  detuneParam_ = AudioParamHostObject::createFromWrapper(detuneParam);
-  auto QParam = wrapper->getQParam();
-  QParam_ = AudioParamHostObject::createFromWrapper(QParam);
-  auto gainParam = wrapper->getGainParam();
-  gainParam_ = AudioParamHostObject::createFromWrapper(gainParam);
-}
-
-std::vector<jsi::PropNameID> BiquadFilterNodeHostObject::getPropertyNames(
-    jsi::Runtime &runtime) {
-  std::vector<jsi::PropNameID> propertyNames =
-      AudioNodeHostObject::getPropertyNames(runtime);
-  propertyNames.push_back(jsi::PropNameID::forAscii(runtime, "frequency"));
-  propertyNames.push_back(jsi::PropNameID::forAscii(runtime, "detune"));
-  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;
-}
-
-jsi::Value BiquadFilterNodeHostObject::get(
-    jsi::Runtime &runtime,
-    const jsi::PropNameID &propNameId) {
-  auto propName = propNameId.utf8(runtime);
-
-  if (propName == "frequency") {
-    return jsi::Object::createFromHostObject(runtime, frequencyParam_);
-  }
-
-  if (propName == "detune") {
-    return jsi::Object::createFromHostObject(runtime, detuneParam_);
-  }
-
-  if (propName == "Q") {
-    return jsi::Object::createFromHostObject(runtime, QParam_);
-  }
-
-  if (propName == "gain") {
-    return jsi::Object::createFromHostObject(runtime, gainParam_);
-  }
-
-  if (propName == "type") {
-    auto wrapper = getBiquadFilterNodeWrapperFromAudioNodeWrapper();
-    auto waveType = wrapper->getType();
-    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);
-}
-
-void BiquadFilterNodeHostObject::set(
-    jsi::Runtime &runtime,
-    const jsi::PropNameID &propNameId,
-    const jsi::Value &value) {
-  auto propName = propNameId.utf8(runtime);
-
-  if (propName == "type") {
-    std::string filterType = value.getString(runtime).utf8(runtime);
-    auto wrapper = getBiquadFilterNodeWrapperFromAudioNodeWrapper();
-    wrapper->setType(filterType);
-    return;
-  }
-
-  return AudioNodeHostObject::set(runtime, propNameId, value);
-}
-} // namespace audioapi

package/common/cpp/HostObjects/GainNodeHostObject.cpp

@@ -1,41 +0,0 @@
-#include "GainNodeHostObject.h"
-
-namespace audioapi {
-using namespace facebook;
-
-GainNodeHostObject::GainNodeHostObject(
-    const std::shared_ptr<GainNodeWrapper> &wrapper)
-    : AudioNodeHostObject(wrapper) {
-  auto gainParamWrapper = wrapper->getGainParam();
-  gainParam_ = AudioParamHostObject::createFromWrapper(gainParamWrapper);
-}
-
-std::vector<jsi::PropNameID> GainNodeHostObject::getPropertyNames(
-    jsi::Runtime &runtime) {
-  std::vector<jsi::PropNameID> propertyNames =
-      AudioNodeHostObject::getPropertyNames(runtime);
-  propertyNames.push_back(jsi::PropNameID::forAscii(runtime, "gain"));
-  return propertyNames;
-}
-
-jsi::Value GainNodeHostObject::get(
-    jsi::Runtime &runtime,
-    const jsi::PropNameID &propNameId) {
-  auto propName = propNameId.utf8(runtime);
-
-  if (propName == "gain") {
-    return jsi::Object::createFromHostObject(runtime, gainParam_);
-  }
-
-  return AudioNodeHostObject::get(runtime, propNameId);
-}
-
-void GainNodeHostObject::set(
-    jsi::Runtime &runtime,
-    const jsi::PropNameID &propNameId,
-    const jsi::Value &value) {
-  auto propName = propNameId.utf8(runtime);
-
-  return AudioNodeHostObject::set(runtime, propNameId, value);
-}
-} // namespace audioapi

package/common/cpp/HostObjects/OscillatorNodeHostObject.cpp

@@ -1,88 +0,0 @@
-#include "OscillatorNodeHostObject.h"
-
-namespace audioapi {
-using namespace facebook;
-
-std::shared_ptr<OscillatorNodeWrapper>
-OscillatorNodeHostObject::getOscillatorNodeWrapperFromAudioNodeWrapper() {
-  return std::static_pointer_cast<OscillatorNodeWrapper>(wrapper_);
-}
-
-OscillatorNodeHostObject::OscillatorNodeHostObject(
-    const std::shared_ptr<OscillatorNodeWrapper> &wrapper)
-    : AudioScheduledSourceNodeHostObject(wrapper) {
-  auto frequencyParam = wrapper->getFrequencyParam();
-  frequencyParam_ = AudioParamHostObject::createFromWrapper(frequencyParam);
-  auto detuneParam = wrapper->getDetuneParam();
-  detuneParam_ = AudioParamHostObject::createFromWrapper(detuneParam);
-}
-
-std::vector<jsi::PropNameID> OscillatorNodeHostObject::getPropertyNames(
-    jsi::Runtime &runtime) {
-  std::vector<jsi::PropNameID> propertyNames =
-      AudioScheduledSourceNodeHostObject::getPropertyNames(runtime);
-  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;
-}
-
-jsi::Value OscillatorNodeHostObject::get(
-    jsi::Runtime &runtime,
-    const jsi::PropNameID &propNameId) {
-  auto propName = propNameId.utf8(runtime);
-
-  if (propName == "frequency") {
-    return jsi::Object::createFromHostObject(runtime, frequencyParam_);
-  }
-
-  if (propName == "detune") {
-    return jsi::Object::createFromHostObject(runtime, detuneParam_);
-  }
-
-  if (propName == "type") {
-    auto wrapper = getOscillatorNodeWrapperFromAudioNodeWrapper();
-    auto waveType = wrapper->getType();
-    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);
-}
-
-void OscillatorNodeHostObject::set(
-    jsi::Runtime &runtime,
-    const jsi::PropNameID &propNameId,
-    const jsi::Value &value) {
-  auto propName = propNameId.utf8(runtime);
-
-  if (propName == "type") {
-    std::string waveType = value.getString(runtime).utf8(runtime);
-    auto wrapper = getOscillatorNodeWrapperFromAudioNodeWrapper();
-    wrapper->setType(waveType);
-    return;
-  }
-
-  return AudioScheduledSourceNodeHostObject::set(runtime, propNameId, value);
-}
-} // namespace audioapi

package/common/cpp/HostObjects/PeriodicWaveHostObject.cpp

@@ -1,33 +0,0 @@
-#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/StereoPannerNodeHostObject.cpp

@@ -1,41 +0,0 @@
-#include "StereoPannerNodeHostObject.h"
-
-namespace audioapi {
-using namespace facebook;
-
-StereoPannerNodeHostObject::StereoPannerNodeHostObject(
-    const std::shared_ptr<StereoPannerNodeWrapper> &wrapper)
-    : AudioNodeHostObject(wrapper) {
-  auto panParam = wrapper->getPanParam();
-  panParam_ = AudioParamHostObject::createFromWrapper(panParam);
-}
-
-std::vector<jsi::PropNameID> StereoPannerNodeHostObject::getPropertyNames(
-    jsi::Runtime &runtime) {
-  std::vector<jsi::PropNameID> propertyNames =
-      AudioNodeHostObject::getPropertyNames(runtime);
-  propertyNames.push_back(jsi::PropNameID::forAscii(runtime, "pan"));
-  return propertyNames;
-}
-
-jsi::Value StereoPannerNodeHostObject::get(
-    jsi::Runtime &runtime,
-    const jsi::PropNameID &propNameId) {
-  auto propName = propNameId.utf8(runtime);
-
-  if (propName == "pan") {
-    return jsi::Object::createFromHostObject(runtime, panParam_);
-  }
-
-  return AudioNodeHostObject::get(runtime, propNameId);
-}
-
-void StereoPannerNodeHostObject::set(
-    jsi::Runtime &runtime,
-    const jsi::PropNameID &propNameId,
-    const jsi::Value &value) {
-  auto propName = propNameId.utf8(runtime);
-
-  return AudioNodeHostObject::set(runtime, propNameId, value);
-}
-} // namespace audioapi

package/common/cpp/core/ParamChange.cpp

@@ -1,46 +0,0 @@
-#include "ParamChange.h"
-
-#include <utility>
-
-namespace audioapi {
-
-ParamChange::ParamChange(
-    double startTime,
-    double endTime,
-    float startValue,
-    float endValue,
-    std::function<float(double, double, float, float, double)> calculateValue)
-    : startTime_(startTime),
-      endTime_(endTime),
-      startValue_(startValue),
-      endValue_(endValue),
-      calculateValue_(std::move(calculateValue)) {}
-
-double ParamChange::getEndTime() const {
-  return endTime_;
-}
-
-double ParamChange::getStartTime() const {
-  return startTime_;
-}
-
-float ParamChange::getEndValue() const {
-  return endValue_;
-}
-
-float ParamChange::getStartValue() const {
-  return startValue_;
-}
-
-std::function<float(double, double, float, float, double)>
-ParamChange::getCalculateValue() const {
-  return calculateValue_;
-}
-
-bool ParamChange::operator<(const ParamChange &other) const {
-  if (startTime_ != other.startTime_)
-    return startTime_ < other.startTime_;
-  return endTime_ < other.endTime_;
-}
-
-} // namespace audioapi

package/common/cpp/utils/JsiPromise.h

@@ -1,48 +0,0 @@
-#pragma once
-
-#include <ReactCommon/CallInvoker.h>
-#include <jsi/jsi.h>
-#include <memory>
-#include <string>
-#include <utility>
-
-namespace JsiPromise {
-
-using namespace facebook;
-
-class Promise {
- public:
-  Promise(
-      std::function<void(jsi::Value)> resolve,
-      std::function<void(const std::string &)> reject)
-      : _resolve(std::move(resolve)), _reject(std::move(reject)) {}
-
-  bool isResolved;
-  void resolve(jsi::Value &&value) {
-    _resolve(std::forward<jsi::Value>(value));
-  }
-  void reject(const std::string &errorMessage) {
-    _reject(errorMessage);
-  }
-
- private:
-  std::function<void(jsi::Value)> _resolve;
-  std::function<void(const std::string &)> _reject;
-};
-
-class PromiseVendor {
- public:
-  PromiseVendor(
-      jsi::Runtime *runtime,
-      std::shared_ptr<react::CallInvoker> callInvoker)
-      : _runtime(runtime), _callInvoker(callInvoker) {}
-
- public:
-  jsi::Value createPromise(std::function<void(std::shared_ptr<Promise>)> func);
-
- private:
-  jsi::Runtime *_runtime;
-  std::shared_ptr<react::CallInvoker> _callInvoker;
-};
-
-} // namespace JsiPromise

package/common/cpp/utils/android/FFTFrame.cpp

@@ -1,23 +0,0 @@
-#if defined(ANDROID)
-#include "FFTFrame.h"
-#include <fftw3.h>
-
-namespace audioapi {
-void FFTFrame::inverse(float *timeDomainData) {
-  fftwf_complex *freqDomainData = fftwf_alloc_complex(size_ / 2);
-  for (int i = 0; i < size_ / 2; i++) {
-    freqDomainData[i][0] = realData_[i];
-    freqDomainData[i][1] = imaginaryData_[i];
-  }
-
-  auto plan = fftwf_plan_dft_c2r_1d(
-      size_, freqDomainData, timeDomainData, FFTW_ESTIMATE);
-  fftwf_execute(plan);
-  fftwf_destroy_plan(plan);
-  fftwf_free(freqDomainData);
-
-  VectorMath::multiplyByScalar(
-      timeDomainData, 1.0f / static_cast<float>(size_), timeDomainData, size_);
-}
-} // namespace audioapi
-#endif