react-native-audio-api 0.0.1 → 0.2.0

package/common/cpp/AudioAPIInstaller/AudioAPIInstallerHostObject.cpp

@@ -0,0 +1,52 @@
+#include "AudioAPIInstallerHostObject.h"
+
+namespace audioapi {
+using namespace facebook;
+
+AudioAPIInstallerHostObject::AudioAPIInstallerHostObject(
+    const std::shared_ptr<AudioAPIInstallerWrapper> &wrapper)
+    : wrapper_(wrapper) {}
+
+std::vector<jsi::PropNameID> AudioAPIInstallerHostObject::getPropertyNames(
+    jsi::Runtime &runtime) {
+  std::vector<jsi::PropNameID> propertyNames;
+  propertyNames.push_back(
+      jsi::PropNameID::forUtf8(runtime, "createAudioContext"));
+  return propertyNames;
+}
+
+jsi::Value AudioAPIInstallerHostObject::get(
+    jsi::Runtime &runtime,
+    const jsi::PropNameID &propNameId) {
+  auto propName = propNameId.utf8(runtime);
+
+  if (propName == "createAudioContext") {
+    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 audioContext = wrapper_->createAudioContext();
+          auto audioContextHostObject =
+              AudioContextHostObject::createFromWrapper(audioContext);
+          return jsi::Object::createFromHostObject(
+              runtime, audioContextHostObject);
+        });
+  }
+
+  throw std::runtime_error("Not yet implemented!");
+}
+
+void AudioAPIInstallerHostObject::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/AudioAPIInstaller/AudioAPIInstallerHostObject.h

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

package/common/cpp/AudioAPIInstaller/AudioAPIInstallerWrapper.h

@@ -0,0 +1,38 @@
+#pragma once
+
+#include <memory>
+#include <string>
+#include <utility>
+
+#include "AudioContextWrapper.h"
+
+#ifdef ANDROID
+#include "AudioAPIInstaller.h"
+#else
+#include "AudioContext.h"
+#endif
+
+namespace audioapi {
+
+#ifdef ANDROID
+class AudioAPIInstaller;
+#endif
+
+class AudioAPIInstallerWrapper {
+#ifdef ANDROID
+
+ public:
+  explicit AudioAPIInstallerWrapper(AudioAPIInstaller *audioAPIInstaller);
+
+ private:
+  AudioAPIInstaller *audioAPIInstaller_;
+#else
+
+ public:
+  AudioAPIInstallerWrapper() = default;
+#endif
+
+ public:
+  std::shared_ptr<AudioContextWrapper> createAudioContext() const;
+};
+} // namespace audioapi

package/common/cpp/AudioAPIInstaller/android/AudioAPIInstallerWrapper.cpp

@@ -0,0 +1,16 @@
+#ifdef ANDROID
+#include "AudioAPIInstallerWrapper.h"
+
+namespace audioapi {
+
+AudioAPIInstallerWrapper::AudioAPIInstallerWrapper(
+    AudioAPIInstaller *audioAPIInstaller)
+    : audioAPIInstaller_(audioAPIInstaller) {}
+
+std::shared_ptr<AudioContextWrapper>
+AudioAPIInstallerWrapper::createAudioContext() const {
+  auto audioContext = audioAPIInstaller_->createAudioContext();
+  return std::make_shared<AudioContextWrapper>(audioContext);
+}
+} // namespace audioapi
+#endif

package/common/cpp/AudioAPIInstaller/ios/AudioAPIInstallerWrapper.cpp

@@ -0,0 +1,12 @@
+#ifndef ANDROID
+#include "AudioAPIInstallerWrapper.h"
+
+namespace audioapi {
+
+std::shared_ptr<AudioContextWrapper>
+AudioAPIInstallerWrapper::createAudioContext() const {
+  auto audioContext = std::make_shared<AudioContext>();
+  return std::make_shared<audioapi::AudioContextWrapper>(audioContext);
+}
+} // namespace audioapi
+#endif

package/common/cpp/HostObjects/AudioBufferHostObject.cpp

@@ -0,0 +1,143 @@
+#include "AudioBufferHostObject.h"
+
+namespace audioapi {
+using namespace facebook;
+
+AudioBufferHostObject::AudioBufferHostObject(
+    const std::shared_ptr<AudioBufferWrapper> &wrapper)
+    : wrapper_(wrapper) {}
+
+std::vector<jsi::PropNameID> AudioBufferHostObject::getPropertyNames(
+    jsi::Runtime &runtime) {
+  std::vector<jsi::PropNameID> propertyNames;
+  propertyNames.push_back(jsi::PropNameID::forAscii(runtime, "buffer"));
+  propertyNames.push_back(jsi::PropNameID::forAscii(runtime, "sampleRate"));
+  propertyNames.push_back(jsi::PropNameID::forAscii(runtime, "length"));
+  propertyNames.push_back(jsi::PropNameID::forAscii(runtime, "duration"));
+  propertyNames.push_back(
+      jsi::PropNameID::forAscii(runtime, "numberOfChannels"));
+  propertyNames.push_back(jsi::PropNameID::forAscii(runtime, "getChannelData"));
+  propertyNames.push_back(
+      jsi::PropNameID::forAscii(runtime, "copyFromChannel"));
+  propertyNames.push_back(jsi::PropNameID::forAscii(runtime, "copyToChannel"));
+  return propertyNames;
+}
+
+jsi::Value AudioBufferHostObject::get(
+    jsi::Runtime &runtime,
+    const jsi::PropNameID &propNameId) {
+  auto propName = propNameId.utf8(runtime);
+
+  if (propName == "sampleRate") {
+    return {wrapper_->getSampleRate()};
+  }
+
+  if (propName == "length") {
+    return {wrapper_->getLength()};
+  }
+
+  if (propName == "duration") {
+    return {wrapper_->getDuration()};
+  }
+
+  if (propName == "numberOfChannels") {
+    return {wrapper_->getNumberOfChannels()};
+  }
+
+  if (propName == "getChannelData") {
+    return jsi::Function::createFromHostFunction(
+        runtime,
+        propNameId,
+        1,
+        [this](
+            jsi::Runtime &rt,
+            const jsi::Value &thisVal,
+            const jsi::Value *args,
+            size_t count) -> jsi::Value {
+          int channel = static_cast<int>(args[0].getNumber());
+          float *channelData = wrapper_->getChannelData(channel);
+
+          auto array = jsi::Array(rt, wrapper_->getLength());
+          for (int i = 0; i < wrapper_->getLength(); i++) {
+            array.setValueAtIndex(rt, i, jsi::Value(channelData[i]));
+          }
+
+          return array;
+        });
+  }
+
+  if (propName == "copyFromChannel") {
+    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 destination = args[0].getObject(rt).asArray(rt);
+          auto destinationLength = static_cast<int>(
+              destination.getProperty(rt, "length").asNumber());
+          auto channelNumber = static_cast<int>(args[1].getNumber());
+          auto startInChannel = static_cast<int>(args[2].getNumber());
+
+          auto *destinationData = new float[destinationLength];
+
+          wrapper_->copyFromChannel(
+              destinationData,
+              destinationLength,
+              channelNumber,
+              startInChannel);
+
+          for (int i = 0; i < destinationLength; i++) {
+            destination.setValueAtIndex(rt, i, jsi::Value(destinationData[i]));
+          }
+
+          return jsi::Value::undefined();
+        });
+  }
+
+  if (propName == "copyToChannel") {
+    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 source = args[0].getObject(rt).asArray(rt);
+          auto sourceLength =
+              static_cast<int>(source.getProperty(rt, "length").asNumber());
+          auto channelNumber = static_cast<int>(args[1].getNumber());
+          auto startInChannel = static_cast<int>(args[2].getNumber());
+
+          auto *sourceData = new float[sourceLength];
+
+          for (int i = 0; i < sourceLength; i++) {
+            sourceData[i] =
+                static_cast<float>(source.getValueAtIndex(rt, i).getNumber());
+          }
+
+          wrapper_->copyToChannel(
+              sourceData, sourceLength, channelNumber, startInChannel);
+
+          return jsi::Value::undefined();
+        });
+  }
+
+  throw std::runtime_error("Not yet implemented!");
+}
+
+void AudioBufferHostObject::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/AudioBufferHostObject.h

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

package/common/cpp/HostObjects/AudioBufferSourceNodeHostObject.cpp

@@ -0,0 +1,79 @@
+#include "AudioBufferSourceNodeHostObject.h"
+
+namespace audioapi {
+using namespace facebook;
+
+AudioBufferSourceNodeHostObject::AudioBufferSourceNodeHostObject(
+    const std::shared_ptr<AudioBufferSourceNodeWrapper> &wrapper)
+    : AudioScheduledSourceNodeHostObject(wrapper) {}
+
+std::shared_ptr<AudioBufferSourceNodeWrapper> AudioBufferSourceNodeHostObject::
+    getAudioBufferSourceNodeWrapperFromAudioNodeWrapper() {
+  return std::static_pointer_cast<AudioBufferSourceNodeWrapper>(wrapper_);
+}
+
+std::vector<jsi::PropNameID> AudioBufferSourceNodeHostObject::getPropertyNames(
+    jsi::Runtime &runtime) {
+  std::vector<jsi::PropNameID> propertyNames =
+      AudioScheduledSourceNodeHostObject::getPropertyNames(runtime);
+  propertyNames.push_back(jsi::PropNameID::forAscii(runtime, "loop"));
+  propertyNames.push_back(jsi::PropNameID::forAscii(runtime, "buffer"));
+  propertyNames.push_back(jsi::PropNameID::forAscii(runtime, "resetBuffer"));
+  return propertyNames;
+}
+
+jsi::Value AudioBufferSourceNodeHostObject::get(
+    jsi::Runtime &runtime,
+    const jsi::PropNameID &propNameId) {
+  auto propName = propNameId.utf8(runtime);
+
+  if (propName == "loop") {
+    auto wrapper = getAudioBufferSourceNodeWrapperFromAudioNodeWrapper();
+    auto loop = wrapper->getLoop();
+    return {loop};
+  }
+
+  if (propName == "buffer") {
+    auto wrapper = getAudioBufferSourceNodeWrapperFromAudioNodeWrapper();
+    auto buffer = wrapper->getBuffer();
+
+    if (!buffer) {
+      return jsi::Value::null();
+    }
+
+    auto bufferHostObject = AudioBufferHostObject::createFromWrapper(buffer);
+    return jsi::Object::createFromHostObject(runtime, bufferHostObject);
+  }
+
+  return AudioScheduledSourceNodeHostObject::get(runtime, propNameId);
+}
+
+void AudioBufferSourceNodeHostObject::set(
+    jsi::Runtime &runtime,
+    const jsi::PropNameID &propNameId,
+    const jsi::Value &value) {
+  auto propName = propNameId.utf8(runtime);
+
+  if (propName == "loop") {
+    auto wrapper = getAudioBufferSourceNodeWrapperFromAudioNodeWrapper();
+    wrapper->setLoop(value.getBool());
+    return;
+  }
+
+  if (propName == "buffer") {
+    auto wrapper = getAudioBufferSourceNodeWrapperFromAudioNodeWrapper();
+
+    if (value.isNull()) {
+      wrapper->setBuffer(std::shared_ptr<AudioBufferWrapper>(nullptr));
+      return;
+    }
+
+    auto bufferHostObject =
+        value.getObject(runtime).asHostObject<AudioBufferHostObject>(runtime);
+    wrapper->setBuffer(bufferHostObject->wrapper_);
+    return;
+  }
+
+  AudioScheduledSourceNodeHostObject::set(runtime, propNameId, value);
+}
+} // namespace audioapi

package/common/cpp/HostObjects/AudioBufferSourceNodeHostObject.h

@@ -0,0 +1,37 @@
+#pragma once
+
+#include <memory>
+#include <vector>
+
+#include "AudioBufferHostObject.h"
+#include "AudioBufferSourceNodeWrapper.h"
+#include "AudioScheduledSourceNodeHostObject.h"
+
+namespace audioapi {
+using namespace facebook;
+
+class AudioBufferSourceNodeHostObject
+    : public AudioScheduledSourceNodeHostObject {
+ public:
+  explicit AudioBufferSourceNodeHostObject(
+      const std::shared_ptr<AudioBufferSourceNodeWrapper> &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<AudioBufferSourceNodeHostObject> createFromWrapper(
+      const std::shared_ptr<AudioBufferSourceNodeWrapper> &wrapper) {
+    return std::make_shared<AudioBufferSourceNodeHostObject>(wrapper);
+  }
+
+ private:
+  std::shared_ptr<AudioBufferSourceNodeWrapper>
+  getAudioBufferSourceNodeWrapperFromAudioNodeWrapper();
+};
+} // namespace audioapi

package/common/cpp/HostObjects/AudioContextHostObject.cpp

@@ -0,0 +1,54 @@
+#include "AudioContextHostObject.h"
+
+namespace audioapi {
+using namespace facebook;
+
+AudioContextHostObject::AudioContextHostObject(
+    const std::shared_ptr<AudioContextWrapper> &wrapper)
+    : BaseAudioContextHostObject(wrapper) {}
+
+std::vector<jsi::PropNameID> AudioContextHostObject::getPropertyNames(
+    jsi::Runtime &runtime) {
+  std::vector<jsi::PropNameID> propertyNames =
+      BaseAudioContextHostObject::getPropertyNames(runtime);
+  propertyNames.push_back(jsi::PropNameID::forUtf8(runtime, "close"));
+  return propertyNames;
+}
+
+jsi::Value AudioContextHostObject::get(
+    jsi::Runtime &runtime,
+    const jsi::PropNameID &propNameId) {
+  auto propName = propNameId.utf8(runtime);
+
+  if (propName == "close") {
+    return jsi::Function::createFromHostFunction(
+        runtime,
+        propNameId,
+        0,
+        [this](
+            jsi::Runtime &runtime,
+            const jsi::Value &thisValue,
+            const jsi::Value *arguments,
+            size_t count) -> jsi::Value {
+          getAudioContextWrapperFromBaseAudioContextWrapper()->close();
+          return jsi::Value::undefined();
+        });
+  }
+
+  return BaseAudioContextHostObject::get(runtime, propNameId);
+}
+
+void AudioContextHostObject::set(
+    jsi::Runtime &runtime,
+    const jsi::PropNameID &propNameId,
+    const jsi::Value &value) {
+  auto propName = propNameId.utf8(runtime);
+
+  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

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

package/common/cpp/HostObjects/AudioDestinationNodeHostObject.cpp

@@ -0,0 +1,33 @@
+#include "AudioDestinationNodeHostObject.h"
+
+namespace audioapi {
+using namespace facebook;
+
+AudioDestinationNodeHostObject::AudioDestinationNodeHostObject(
+    const std::shared_ptr<AudioDestinationNodeWrapper> &wrapper)
+    : AudioNodeHostObject(wrapper) {}
+
+std::vector<jsi::PropNameID> AudioDestinationNodeHostObject::getPropertyNames(
+    jsi::Runtime &runtime) {
+  std::vector<jsi::PropNameID> propertyNames;
+  return propertyNames;
+}
+
+jsi::Value AudioDestinationNodeHostObject::get(
+    jsi::Runtime &runtime,
+    const jsi::PropNameID &propNameId) {
+  auto propName = propNameId.utf8(runtime);
+
+  return AudioNodeHostObject::get(runtime, propNameId);
+}
+
+void AudioDestinationNodeHostObject::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/AudioDestinationNodeHostObject.h

@@ -0,0 +1,31 @@
+#pragma once
+
+#include <memory>
+#include <vector>
+
+#include "AudioDestinationNodeWrapper.h"
+#include "AudioNodeHostObject.h"
+
+namespace audioapi {
+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);
+  }
+};
+} // namespace audioapi