react-native-audio-api 0.4.3 → 0.4.5

package/android/build.gradle

@@ -15,7 +15,7 @@ buildscript {
 
 def reactNativeArchitectures() {
   def value = rootProject.getProperties().get("reactNativeArchitectures")
-  return value ? value.split(",") : ["armeabi-v7a", "arm64-v8a", "x86_64"]
+  return value ? value.split(",") : ["armeabi-v7a", "arm64-v8a", "x86_64", "x86"]
 }
 
 def isNewArchitectureEnabled() {

package/common/cpp/HostObjects/BaseAudioContextHostObject.h

@@ -143,20 +143,16 @@ class BaseAudioContextHostObject : public JsiHostObject {
   JSI_HOST_FUNCTION(decodeAudioDataSource) {
     auto sourcePath = args[0].getString(runtime).utf8(runtime);
 
-    auto promise = promiseVendor_->createPromise(
-        [this, &runtime, sourcePath](std::shared_ptr<Promise> promise) {
-          std::thread([this,
-                       &runtime,
-                       sourcePath,
-                       promise = std::move(promise)]() {
-            auto results = context_->decodeAudioDataSource(sourcePath);
-            auto audioBufferHostObject =
-                std::make_shared<AudioBufferHostObject>(results);
-
-            promise->resolve(jsi::Object::createFromHostObject(
-                runtime, audioBufferHostObject));
-          }).detach();
+    auto promise = promiseVendor_->createPromise([this, sourcePath](std::shared_ptr<Promise> promise) {
+      std::thread([this, sourcePath, promise = std::move(promise)]() {
+        auto results = context_->decodeAudioDataSource(sourcePath);
+        auto audioBufferHostObject = std::make_shared<AudioBufferHostObject>(results);
+
+        promise->resolve([audioBufferHostObject = std::move(audioBufferHostObject)](jsi::Runtime &runtime) {
+          return jsi::Object::createFromHostObject(runtime, audioBufferHostObject);
         });
+      }).detach();
+    });
 
     return promise;
   }

package/common/cpp/core/AudioContext.cpp

@@ -35,7 +35,7 @@ AudioContext::AudioContext(float sampleRate) : BaseAudioContext() {
 }
 
 AudioContext::~AudioContext() {
-  if (isRunning()) {
+  if (isClosed()) {
     return;
   }
 
@@ -48,7 +48,7 @@ void AudioContext::close() {
 }
 
 std::function<void(AudioBus *, int)> AudioContext::renderAudio() {
-  if (!isRunning()) {
+  if (!isRunning() || !destination_) {
     return [](AudioBus *, int) {};
   }
 

package/common/cpp/core/AudioNode.cpp

@@ -13,7 +13,6 @@ AudioNode::AudioNode(BaseAudioContext *context) : context_(context) {
 }
 
 AudioNode::~AudioNode() {
-  isInitialized_ = false;
   cleanup();
 }
 
@@ -42,14 +41,9 @@ void AudioNode::connect(const std::shared_ptr<AudioNode> &node) {
       shared_from_this(), node, AudioNodeManager::ConnectionType::CONNECT);
 }
 
-void AudioNode::connectNode(const std::shared_ptr<AudioNode> &node) {
-  outputNodes_.push_back(node);
-  node->onInputConnected(this);
-}
-
 void AudioNode::disconnect() {
   for (auto &outputNode : outputNodes_) {
-    disconnectNode(outputNode);
+    disconnect(outputNode);
   }
 }
 
@@ -58,16 +52,6 @@ void AudioNode::disconnect(const std::shared_ptr<AudioNode> &node) {
       shared_from_this(), node, AudioNodeManager::ConnectionType::DISCONNECT);
 }
 
-void AudioNode::disconnectNode(const std::shared_ptr<AudioNode> &node) {
-  node->onInputDisconnected(this);
-
-  auto position = std::find(outputNodes_.begin(), outputNodes_.end(), node);
-
-  if (position != outputNodes_.end()) {
-    outputNodes_.erase(position);
-  }
-}
-
 bool AudioNode::isEnabled() const {
   return isEnabled_;
 }
@@ -186,10 +170,30 @@ AudioBus *AudioNode::processAudio(AudioBus *outputBus, int framesToProcess) {
 }
 
 void AudioNode::cleanup() {
+  isInitialized_ = false;
+
+  for (const auto &outputNode : outputNodes_) {
+    outputNode->onInputDisconnected(this);
+  }
+
+  for (const auto &inputNode : inputNodes_) {
+    inputNode->disconnectNode(shared_from_this());
+  }
+
   outputNodes_.clear();
   inputNodes_.clear();
 }
 
+void AudioNode::connectNode(const std::shared_ptr<AudioNode> &node) {
+  outputNodes_.insert(node);
+  node->onInputConnected(this);
+}
+
+void AudioNode::disconnectNode(const std::shared_ptr<AudioNode> &node) {
+  outputNodes_.erase(node);
+  node->onInputDisconnected(this);
+}
+
 void AudioNode::onInputEnabled() {
   numberOfEnabledInputNodes_ += 1;
 
@@ -211,7 +215,7 @@ void AudioNode::onInputConnected(AudioNode *node) {
     return;
   }
 
-  inputNodes_.push_back(node);
+  inputNodes_.insert(node);
 
   if (node->isEnabled()) {
     onInputEnabled();
@@ -223,23 +227,11 @@ void AudioNode::onInputDisconnected(AudioNode *node) {
     return;
   }
 
-  auto position = std::find(inputNodes_.begin(), inputNodes_.end(), node);
-
-  if (position != inputNodes_.end()) {
-    inputNodes_.erase(position);
-  }
-
-  if (!inputNodes_.empty()) {
-    return;
-  }
+  inputNodes_.erase(node);
 
   if (isEnabled()) {
     node->onInputDisabled();
   }
-
-  for (const auto &outputNode : outputNodes_) {
-    disconnectNode(outputNode);
-  }
 }
 
 } // namespace audioapi

package/common/cpp/core/AudioNode.h

@@ -2,7 +2,7 @@
 
 #include <memory>
 #include <string>
-#include <vector>
+#include <unordered_set>
 #include <cstddef>
 
 #include "ChannelCountMode.h"
@@ -18,6 +18,7 @@ class AudioNode : public std::enable_shared_from_this<AudioNode> {
  public:
   explicit AudioNode(BaseAudioContext *context);
   virtual ~AudioNode();
+
   int getNumberOfInputs() const;
   int getNumberOfOutputs() const;
   int getChannelCount() const;
@@ -45,8 +46,8 @@ class AudioNode : public std::enable_shared_from_this<AudioNode> {
   ChannelInterpretation channelInterpretation_ =
           ChannelInterpretation::SPEAKERS;
 
-    std::vector<AudioNode *> inputNodes_ = {};
-    std::vector<std::shared_ptr<AudioNode>> outputNodes_ = {};
+  std::unordered_set<AudioNode *> inputNodes_ = {};
+  std::unordered_set<std::shared_ptr<AudioNode>> outputNodes_ = {};
 
   int numberOfEnabledInputNodes_ = 0;
   bool isInitialized_ = false;

package/common/cpp/core/AudioNodeManager.cpp

@@ -7,7 +7,6 @@ namespace audioapi {
 
 AudioNodeManager::~AudioNodeManager() {
   audioNodesToConnect_.clear();
-  sourceNodes_.clear();
 }
 
 void AudioNodeManager::addPendingConnection(
@@ -19,31 +18,33 @@ void AudioNodeManager::addPendingConnection(
   audioNodesToConnect_.emplace_back(from, to, type);
 }
 
-void AudioNodeManager::addSourceNode(const std::shared_ptr<AudioNode> &node) {
-  Locker lock(getGraphLock());
-
-  sourceNodes_.push_back(node);
-}
-
 void AudioNodeManager::preProcessGraph() {
   if (!Locker::tryLock(getGraphLock())) {
     return;
   }
 
   settlePendingConnections();
-  removeFinishedSourceNodes();
+  prepareNodesForDestruction();
 }
 
 std::mutex &AudioNodeManager::getGraphLock() {
   return graphLock_;
 }
 
+void AudioNodeManager::addNode(const std::shared_ptr<AudioNode> &node) {
+  Locker lock(getGraphLock());
+
+  nodes_.insert(node);
+}
+
 void AudioNodeManager::settlePendingConnections() {
   for (auto &connection : audioNodesToConnect_) {
     std::shared_ptr<AudioNode> from = std::get<0>(connection);
     std::shared_ptr<AudioNode> to = std::get<1>(connection);
     ConnectionType type = std::get<2>(connection);
 
+    // add assert to check if from and to are neither null nor uninitialized
+
     if (type == ConnectionType::CONNECT) {
       from->connectNode(to);
     } else {
@@ -54,16 +55,11 @@ void AudioNodeManager::settlePendingConnections() {
   audioNodesToConnect_.clear();
 }
 
-void AudioNodeManager::removeFinishedSourceNodes() {
-  for (auto it = sourceNodes_.begin(); it != sourceNodes_.end();) {
-    auto currentNode = it->get();
-    // Release the source node if use count is equal to 1 (this vector)
-    if (!currentNode->isEnabled() && it->use_count() == 1) {
-      for (auto &outputNode : currentNode->outputNodes_) {
-        currentNode->disconnectNode(outputNode);
-      }
-
-      it = sourceNodes_.erase(it);
+void AudioNodeManager::prepareNodesForDestruction() {
+  for (auto it = nodes_.begin(); it != nodes_.end();) {
+    if (it->use_count() == 1) {
+      it->get()->cleanup();
+      it = nodes_.erase(it);
     } else {
       ++it;
     }

package/common/cpp/core/AudioNodeManager.h

@@ -4,6 +4,7 @@
 #include <mutex>
 #include <tuple>
 #include <vector>
+#include <unordered_set>
 
 namespace audioapi {
 
@@ -15,20 +16,24 @@ class AudioNodeManager {
   AudioNodeManager() = default;
   ~AudioNodeManager();
 
+  std::mutex &getGraphLock();
+
   void preProcessGraph();
+
   void addPendingConnection(
       const std::shared_ptr<AudioNode> &from,
       const std::shared_ptr<AudioNode> &to,
       ConnectionType type);
 
-  void addSourceNode(const std::shared_ptr<AudioNode> &node);
-
-  std::mutex &getGraphLock();
+  void addNode(const std::shared_ptr<AudioNode> &node);
 
  private:
   std::mutex graphLock_;
 
-  std::vector<std::shared_ptr<AudioNode>> sourceNodes_;
+  // all nodes created in the context
+  std::unordered_set<std::shared_ptr<AudioNode>> nodes_;
+
+  // connections to be settled
   std::vector<std::tuple<
       std::shared_ptr<AudioNode>,
       std::shared_ptr<AudioNode>,
@@ -36,7 +41,7 @@ class AudioNodeManager {
       audioNodesToConnect_;
 
   void settlePendingConnections();
-  void removeFinishedSourceNodes();
+  void prepareNodesForDestruction();
 };
 
 } // namespace audioapi

package/common/cpp/core/AudioScheduledSourceNode.cpp

@@ -18,8 +18,6 @@ AudioScheduledSourceNode::AudioScheduledSourceNode(BaseAudioContext *context)
 void AudioScheduledSourceNode::start(double time) {
   playbackState_ = PlaybackState::SCHEDULED;
   startTime_ = time;
-
-  context_->getNodeManager()->addSourceNode(shared_from_this());
 }
 
 void AudioScheduledSourceNode::stop(double time) {

package/common/cpp/core/BaseAudioContext.cpp

@@ -42,23 +42,33 @@ std::shared_ptr<AudioDestinationNode> BaseAudioContext::getDestination() {
 }
 
 std::shared_ptr<OscillatorNode> BaseAudioContext::createOscillator() {
-  return std::make_shared<OscillatorNode>(this);
+  auto oscillator = std::make_shared<OscillatorNode>(this);
+  nodeManager_->addNode(oscillator);
+  return oscillator;
 }
 
 std::shared_ptr<GainNode> BaseAudioContext::createGain() {
-  return std::make_shared<GainNode>(this);
+  auto gain = std::make_shared<GainNode>(this);
+  nodeManager_->addNode(gain);
+  return gain;
 }
 
 std::shared_ptr<StereoPannerNode> BaseAudioContext::createStereoPanner() {
-  return std::make_shared<StereoPannerNode>(this);
+  auto stereoPanner = std::make_shared<StereoPannerNode>(this);
+  nodeManager_->addNode(stereoPanner);
+  return stereoPanner;
 }
 
 std::shared_ptr<BiquadFilterNode> BaseAudioContext::createBiquadFilter() {
-  return std::make_shared<BiquadFilterNode>(this);
+  auto biquadFilter = std::make_shared<BiquadFilterNode>(this);
+  nodeManager_->addNode(biquadFilter);
+  return biquadFilter;
 }
 
 std::shared_ptr<AudioBufferSourceNode> BaseAudioContext::createBufferSource() {
-  return std::make_shared<AudioBufferSourceNode>(this);
+  auto bufferSource = std::make_shared<AudioBufferSourceNode>(this);
+  nodeManager_->addNode(bufferSource);
+  return bufferSource;
 }
 
 std::shared_ptr<AudioBuffer> BaseAudioContext::createBuffer(
@@ -78,7 +88,9 @@ std::shared_ptr<PeriodicWave> BaseAudioContext::createPeriodicWave(
 }
 
 std::shared_ptr<AnalyserNode> BaseAudioContext::createAnalyser() {
-  return std::make_shared<AnalyserNode>(this);
+  auto analyser = std::make_shared<AnalyserNode>(this);
+  nodeManager_->addNode(analyser);
+  return analyser;
 }
 
 std::shared_ptr<AudioBuffer> BaseAudioContext::decodeAudioDataSource(

package/common/cpp/jsi/JsiPromise.cpp

@@ -36,9 +36,12 @@ jsi::Value PromiseVendor::createPromise(
         auto reject = std::make_shared<jsi::Function>(std::move(rejectLocal));
 
         auto resolveWrapper =
-            [resolve, &runtime, callInvoker](jsi::Value value) -> void {
-          auto valueShared = std::make_shared<jsi::Value>(std::move(value));
-          callInvoker->invokeAsync([resolve, &runtime, valueShared]() -> void {
+            [resolve, &runtime, callInvoker](
+                const std::function<jsi::Value(jsi::Runtime &)> resolver)
+            -> void {
+          callInvoker->invokeAsync([resolve, &runtime, resolver]() -> void {
+            auto valueShared = std::make_shared<jsi::Value>(resolver(runtime));
+
             resolve->call(runtime, *valueShared);
           });
         };

package/common/cpp/jsi/JsiPromise.h

@@ -13,33 +13,26 @@ 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)) {}
+  Promise(std::function<void(const std::function<jsi::Value(jsi::Runtime&)>)> resolve, std::function<void(const std::string &)> reject) : resolve_(std::move(resolve)), reject_(std::move(reject)) {}
 
-  void resolve(jsi::Value &&value) {
-    resolve_(std::forward<jsi::Value>(value));
+  void resolve(const std::function<jsi::Value(jsi::Runtime&)> &resolver) {
+    resolve_(std::forward<const std::function<jsi::Value(jsi::Runtime&)>>(resolver));
   }
+
   void reject(const std::string &errorMessage) {
     reject_(errorMessage);
   }
 
  private:
-  std::function<void(jsi::Value)> resolve_;
+  std::function<void(const std::function<jsi::Value(jsi::Runtime&)>)> resolve_;
   std::function<void(const std::string &)> reject_;
 };
 
 class PromiseVendor {
  public:
-  PromiseVendor(
-      jsi::Runtime *runtime,
-      const std::shared_ptr<react::CallInvoker> &callInvoker)
-      : runtime_(runtime), callInvoker_(callInvoker) {}
+  PromiseVendor(jsi::Runtime *runtime, const std::shared_ptr<react::CallInvoker> &callInvoker): runtime_(runtime), callInvoker_(callInvoker) {}
 
- public:
-  jsi::Value createPromise(
-      const std::function<void(std::shared_ptr<Promise>)> &function);
+  jsi::Value createPromise(const std::function<void(std::shared_ptr<Promise>)> &function);
 
  private:
   jsi::Runtime *runtime_;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "react-native-audio-api",
-  "version": "0.4.3",
+  "version": "0.4.5",
   "description": "react-native-audio-api provides system for controlling audio in React Native environment compatible with Web Audio API specification",
   "main": "lib/commonjs/index",
   "module": "lib/module/index",