refactor: destination ownership and connection logic

Author: maciejmakowski2003

packages/react-native-audio-api/common/cpp/audioapi/HostObjects/AudioNodeHostObject.cpp

@@ -81,6 +81,7 @@ JSI_HOST_FUNCTION_IMPL(AudioNodeHostObject, disconnect) {
     // node_->disconnect();
     return jsi::Value::undefined();
   }
+
   auto obj = args[0].getObject(runtime);
   if (obj.isHostObject<AudioNodeHostObject>(runtime)) {
     auto node = obj.getHostObject<AudioNodeHostObject>(runtime);

packages/react-native-audio-api/common/cpp/audioapi/HostObjects/destinations/AudioDestinationNodeHostObject.cpp

@@ -1,4 +1,5 @@
 #include <audioapi/HostObjects/destinations/AudioDestinationNodeHostObject.h>
+#include <audioapi/HostObjects/utils/JsEnumParser.h>
 
 #include <memory>
 #include <utility>
@@ -7,24 +8,56 @@ namespace audioapi {
 
 AudioDestinationNodeHostObject::AudioDestinationNodeHostObject(
     utils::graph::HostGraph::Node *node,
-    std::shared_ptr<AudioDestinationNode> destination)
-    : node_(node), destination_(std::move(destination)) {
-  addGetters(
-      JSI_EXPORT_PROPERTY_GETTER(AudioDestinationNodeHostObject, numberOfInputs),
-      JSI_EXPORT_PROPERTY_GETTER(AudioDestinationNodeHostObject, numberOfOutputs),
-      JSI_EXPORT_PROPERTY_GETTER(AudioDestinationNodeHostObject, channelCount));
+    std::shared_ptr<AudioDestinationNode> destination,
+    const AudioDestinationOptions &options)
+    : node_(node), destination_(std::move(destination)),
+      numberOfInputs_(options.numberOfInputs),
+      numberOfOutputs_(options.numberOfOutputs),
+      channelCount_(options.channelCount),
+      channelCountMode_(options.channelCountMode),
+      channelInterpretation_(options.channelInterpretation) {
+    addGetters(
+        JSI_EXPORT_PROPERTY_GETTER(AudioDestinationNodeHostObject, numberOfInputs),
+        JSI_EXPORT_PROPERTY_GETTER(AudioDestinationNodeHostObject, numberOfOutputs),
+        JSI_EXPORT_PROPERTY_GETTER(AudioDestinationNodeHostObject, channelCount),
+        JSI_EXPORT_PROPERTY_GETTER(AudioDestinationNodeHostObject, channelCountMode),
+        JSI_EXPORT_PROPERTY_GETTER(AudioDestinationNodeHostObject, channelInterpretation));
+
+    addFunctions(
+        JSI_EXPORT_FUNCTION(AudioDestinationNodeHostObject, connect),
+        JSI_EXPORT_FUNCTION(AudioDestinationNodeHostObject, disconnect));
 }
 
 JSI_PROPERTY_GETTER_IMPL(AudioDestinationNodeHostObject, numberOfInputs) {
-  return {1};
+  return {numberOfInputs_};
 }
 
 JSI_PROPERTY_GETTER_IMPL(AudioDestinationNodeHostObject, numberOfOutputs) {
-  return {0};
+  return {numberOfOutputs_};
 }
 
 JSI_PROPERTY_GETTER_IMPL(AudioDestinationNodeHostObject, channelCount) {
-  return {static_cast<int>(destination_->getChannelCount())};
+    return {static_cast<int>(channelCount_)};
+}
+
+JSI_PROPERTY_GETTER_IMPL(AudioDestinationNodeHostObject, channelCountMode) {
+    return jsi::String::createFromUtf8(
+            runtime, js_enum_parser::channelCountModeToString(channelCountMode_));
+}
+
+JSI_PROPERTY_GETTER_IMPL(AudioDestinationNodeHostObject, channelInterpretation) {
+    return jsi::String::createFromUtf8(
+            runtime, js_enum_parser::channelInterpretationToString(channelInterpretation_));
+}
+
+/// AudioDestinationNode is the end point of the audio graph, it cannot connect to any other node, so connect and disconnect are no-op
+JSI_HOST_FUNCTION_IMPL(AudioDestinationNodeHostObject, connect) {
+  return jsi::Value::undefined();
+}
+
+/// AudioDestinationNode is the end point of the audio graph, it cannot connect to any other node, so connect and disconnect are no-op
+JSI_HOST_FUNCTION_IMPL(AudioDestinationNodeHostObject, disconnect) {
+  return jsi::Value::undefined();
 }
 
 } // namespace audioapi

packages/react-native-audio-api/common/cpp/audioapi/HostObjects/destinations/AudioDestinationNodeHostObject.h

@@ -3,17 +3,22 @@
 #include <audioapi/core/destinations/AudioDestinationNode.h>
 #include <audioapi/core/utils/graph/HostGraph.hpp>
 #include <audioapi/jsi/JsiHostObject.h>
+#include <audioapi/types/NodeOptions.h>
 
 #include <memory>
 
 namespace audioapi {
 using namespace facebook;
 
+/// HostObject for AudiodestinationNode, which is the end point of the audio graph.
+/// It is treated differently than other AudioNodes, because it shares ownership of underlying AudioDestinationNode with BaseAudioContext.
+/// Hence all AudioNodeHostObject methods and proprties has to be implemented duplicated.
 class AudioDestinationNodeHostObject : public JsiHostObject {
  public:
   explicit AudioDestinationNodeHostObject(
       utils::graph::HostGraph::Node *node,
-      std::shared_ptr<AudioDestinationNode> destination);
+      std::shared_ptr<AudioDestinationNode> destination,
+      const AudioDestinationOptions &options = AudioDestinationOptions());
 
   [[nodiscard]] utils::graph::HostGraph::Node *rawNode() const {
     return node_;
@@ -22,10 +27,24 @@ class AudioDestinationNodeHostObject : public JsiHostObject {
   JSI_PROPERTY_GETTER_DECL(numberOfInputs);
   JSI_PROPERTY_GETTER_DECL(numberOfOutputs);
   JSI_PROPERTY_GETTER_DECL(channelCount);
+  JSI_PROPERTY_GETTER_DECL(channelCountMode);
+  JSI_PROPERTY_GETTER_DECL(channelInterpretation);
+
+  JSI_HOST_FUNCTION_DECL(connect);
+  JSI_HOST_FUNCTION_DECL(disconnect);
 
  private:
-  utils::graph::HostGraph::Node *node_; // borrowed from BaseAudioContext; never removed
+  // borrowed from BaseAudioContext's graph - non-owning
+  // no risk of dangling pointer here since destination node in TS holds ref to context =>
+  // destination HO will not outlive context HO => graph is owned by context HO
+  utils::graph::HostGraph::Node *node_; // borrowed from BaseAudioContext's graph - non-owning
   std::shared_ptr<AudioDestinationNode> destination_;
+
+  const int numberOfInputs_;
+  const int numberOfOutputs_;
+  size_t channelCount_;
+  const ChannelCountMode channelCountMode_;
+  const ChannelInterpretation channelInterpretation_;
 };
 
 } // namespace audioapi

packages/react-native-audio-api/src/core/AudioNode.ts

@@ -2,7 +2,7 @@ import { IAudioNode } from '../interfaces';
 import AudioParam from './AudioParam';
 import { ChannelCountMode, ChannelInterpretation } from '../types';
 import BaseAudioContext from './BaseAudioContext';
-import { InvalidAccessError } from '../errors';
+import { IndexSizeError } from '../errors';
 
 export default class AudioNode {
   readonly context: BaseAudioContext;
@@ -27,14 +27,24 @@ export default class AudioNode {
   public connect(destination: AudioParam): void;
   public connect(destination: AudioNode | AudioParam): AudioNode | void {
     if (this.context !== destination.context) {
-      throw new InvalidAccessError(
+      throw new IndexSizeError(
         'Source and destination are from different BaseAudioContexts'
       );
     }
 
+    if (this.numberOfOutputs === 0) {
+      throw new IndexSizeError('Faild to connect: AudioNode has no output');
+    }
+
     if (destination instanceof AudioParam) {
       this.node.connect(destination.audioParam);
     } else {
+      if (destination.numberOfInputs === 0) {
+        throw new IndexSizeError(
+          'Failed to connect: destination AudioNode has no input'
+        );
+      }
+
       this.node.connect(destination.node);
       return destination;
     }