Fix/initializing context/deconstruction bug (#295)

* refactor: added extra checks to AudioContext

* fix: fixed preparing node for deconstruction process

---------

Co-authored-by: Maciej Makowski <maciej.makowski2608@gmail.com>

Author: maciejmakowski2003

packages/react-native-audio-api/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) {};
   }
 

packages/react-native-audio-api/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

packages/react-native-audio-api/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;

packages/react-native-audio-api/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;
     }

packages/react-native-audio-api/common/cpp/core/AudioNodeManager.h

@@ -4,6 +4,7 @@
 #include <mutex>
 #include <tuple>
 #include <vector>
+#include <unordered_set>
 
 namespace audioapi {
 
@@ -15,28 +16,32 @@ 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>,
       ConnectionType>>
       audioNodesToConnect_;
 
   void settlePendingConnections();
-  void removeFinishedSourceNodes();
+  void prepareNodesForDestruction();
 };
 
 } // namespace audioapi

packages/react-native-audio-api/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) {

packages/react-native-audio-api/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(