react-native-audio-api 0.6.0-rc.4 → 0.6.0

package/android/src/main/java/com/swmansion/audioapi/system/MediaReceiver.kt

@@ -4,12 +4,17 @@ import android.content.BroadcastReceiver
 import android.content.Context
 import android.content.Intent
 import android.media.AudioManager
+import android.support.v4.media.session.MediaSessionCompat
 import android.view.KeyEvent
 import com.facebook.react.bridge.ReactApplicationContext
+import com.swmansion.audioapi.AudioAPIModule
+import java.lang.ref.WeakReference
 
 class MediaReceiver(
-  val reactContext: ReactApplicationContext,
-  private val mediaSessionManager: MediaSessionManager,
+  private val reactContext: WeakReference<ReactApplicationContext>,
+  private val mediaSession: WeakReference<MediaSessionCompat>,
+  private val mediaNotificationManager: WeakReference<MediaNotificationManager>,
+  private val audioAPIModule: WeakReference<AudioAPIModule>,
 ) : BroadcastReceiver() {
   override fun onReceive(
     context: Context?,
@@ -20,26 +25,31 @@ class MediaReceiver(
     if (MediaNotificationManager.REMOVE_NOTIFICATION == action) {
       if (!checkApp(intent)) return
 
-      mediaSessionManager.mediaNotificationManager.hide()
-      mediaSessionManager.mediaSession.isActive = false
+      mediaNotificationManager.get()?.hide()
+      mediaSession.get()?.isActive = false
 
-      mediaSessionManager.eventEmitter.sendEvent("onCloseNotification", null)
+      audioAPIModule.get()?.invokeHandlerWithEventNameAndEventBody("closeNotification", mapOf()) // add to ts events
     } else if (MediaNotificationManager.MEDIA_BUTTON == action || Intent.ACTION_MEDIA_BUTTON == action) {
       if (!intent.hasExtra(Intent.EXTRA_KEY_EVENT)) return
       if (!checkApp(intent)) return
 
       val keyEvent = intent.getParcelableExtra<KeyEvent>(Intent.EXTRA_KEY_EVENT)
-      mediaSessionManager.mediaSession.controller.dispatchMediaButtonEvent(keyEvent)
+      mediaSession.get()?.controller?.dispatchMediaButtonEvent(keyEvent)
     } else if (AudioManager.ACTION_AUDIO_BECOMING_NOISY == action) {
-      mediaSessionManager.mediaSession.controller.transportControls
-        .pause()
+      mediaSession
+        .get()
+        ?.controller
+        ?.transportControls
+        ?.pause()
     }
   }
 
   private fun checkApp(intent: Intent): Boolean {
     if (intent.hasExtra(MediaNotificationManager.PACKAGE_NAME)) {
       val name = intent.getStringExtra(MediaNotificationManager.PACKAGE_NAME)
-      if (!reactContext.packageName.equals(name)) return false
+      if (!reactContext.get()?.packageName.equals(name)) {
+        return false
+      }
     }
     return true
   }

package/android/src/main/java/com/swmansion/audioapi/system/MediaSessionCallback.kt

@@ -1,39 +1,58 @@
 package com.swmansion.audioapi.system
 
+import android.content.Intent
+import android.os.Build
 import android.support.v4.media.session.MediaSessionCompat
 import android.support.v4.media.session.PlaybackStateCompat
+import androidx.core.app.NotificationManagerCompat
+import com.swmansion.audioapi.AudioAPIModule
+import java.lang.ref.WeakReference
+import java.util.HashMap
 
 class MediaSessionCallback(
-  val eventEmitter: MediaSessionEventEmitter,
-  private val lockScreenManager: LockScreenManager,
+  private val audioAPIModule: WeakReference<AudioAPIModule>,
+  private val lockScreenManager: WeakReference<LockScreenManager>,
 ) : MediaSessionCompat.Callback() {
   override fun onPlay() {
-    lockScreenManager.updatePlaybackState(PlaybackStateCompat.STATE_PLAYING)
-    eventEmitter.onPlay()
+    lockScreenManager.get()?.updatePlaybackState(PlaybackStateCompat.STATE_PLAYING)
+    audioAPIModule.get()?.invokeHandlerWithEventNameAndEventBody("remotePlay", mapOf())
   }
 
   override fun onPause() {
-    lockScreenManager.updatePlaybackState(PlaybackStateCompat.STATE_PAUSED)
-    eventEmitter.onPause()
+    lockScreenManager.get()?.updatePlaybackState(PlaybackStateCompat.STATE_PAUSED)
+    audioAPIModule.get()?.invokeHandlerWithEventNameAndEventBody("remotePause", mapOf())
   }
 
   override fun onStop() {
-    eventEmitter.onStop()
+    val reactContext = audioAPIModule.get()?.reactContext?.get()!!
+    NotificationManagerCompat.from(reactContext).cancel(MediaSessionManager.NOTIFICATION_ID)
+    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
+      val myIntent =
+        Intent(reactContext, MediaNotificationManager.NotificationService::class.java)
+      reactContext.stopService(myIntent)
+    }
+
+    audioAPIModule.get()?.invokeHandlerWithEventNameAndEventBody("remoteStop", mapOf())
   }
 
   override fun onSkipToNext() {
-    eventEmitter.onSkipToNext()
+    audioAPIModule.get()?.invokeHandlerWithEventNameAndEventBody("remoteNextTrack", mapOf())
   }
 
   override fun onSkipToPrevious() {
-    eventEmitter.onSkipToPrevious()
+    audioAPIModule.get()?.invokeHandlerWithEventNameAndEventBody("remotePreviousTrack", mapOf())
   }
 
   override fun onFastForward() {
-    eventEmitter.onFastForward()
+    audioAPIModule.get()?.invokeHandlerWithEventNameAndEventBody("remoteSkipForward", mapOf())
   }
 
   override fun onRewind() {
-    eventEmitter.onRewind()
+    audioAPIModule.get()?.invokeHandlerWithEventNameAndEventBody("remoteSkipBackward", mapOf())
+  }
+
+  override fun onSeekTo(pos: Long) {
+    val body = HashMap<String, Any>().apply { put("value", (pos.toDouble() / 1000)) }
+    audioAPIModule.get()?.invokeHandlerWithEventNameAndEventBody("remoteChangePlaybackPosition", body)
   }
 }

package/android/src/main/java/com/swmansion/audioapi/system/MediaSessionManager.kt

@@ -1,5 +1,7 @@
 package com.swmansion.audioapi.system
 
+import android.Manifest
+import android.app.Activity
 import android.app.NotificationChannel
 import android.app.NotificationManager
 import android.content.ComponentName
@@ -7,27 +9,31 @@ import android.content.Context
 import android.content.Intent
 import android.content.IntentFilter
 import android.content.ServiceConnection
+import android.content.pm.PackageManager
 import android.media.AudioManager
 import android.os.Build
 import android.os.IBinder
 import android.support.v4.media.session.MediaSessionCompat
 import android.util.Log
 import androidx.annotation.RequiresApi
+import androidx.core.app.ActivityCompat
 import androidx.core.app.NotificationCompat
 import androidx.core.content.ContextCompat
 import com.facebook.react.bridge.ReactApplicationContext
 import com.facebook.react.bridge.ReadableMap
+import com.swmansion.audioapi.AudioAPIModule
+import java.lang.ref.WeakReference
 
 object MediaSessionManager {
-  lateinit var reactContext: ReactApplicationContext
-  val notificationId = 100
-  val channelId = "react-native-audio-api"
+  private lateinit var audioAPIModule: WeakReference<AudioAPIModule>
+  private lateinit var reactContext: WeakReference<ReactApplicationContext>
+  const val NOTIFICATION_ID = 100
+  const val CHANNEL_ID = "react-native-audio-api"
 
   private lateinit var audioManager: AudioManager
-  lateinit var mediaSession: MediaSessionCompat
+  private lateinit var mediaSession: MediaSessionCompat
   lateinit var mediaNotificationManager: MediaNotificationManager
   private lateinit var lockScreenManager: LockScreenManager
-  lateinit var eventEmitter: MediaSessionEventEmitter
   private lateinit var audioFocusListener: AudioFocusListener
   private lateinit var volumeChangeListener: VolumeChangeListener
   private lateinit var mediaReceiver: MediaReceiver
@@ -42,7 +48,7 @@ object MediaSessionManager {
         val binder = service as MediaNotificationManager.NotificationService.LocalBinder
         val notificationService = binder.getService()
         notificationService?.forceForeground()
-        reactContext.unbindService(this)
+        reactContext.get()?.unbindService(this)
       }
 
       override fun onServiceDisconnected(name: ComponentName) {
@@ -58,20 +64,24 @@ object MediaSessionManager {
       }
     }
 
-  fun initialize(reactContext: ReactApplicationContext) {
+  fun initialize(
+    audioAPIModule: WeakReference<AudioAPIModule>,
+    reactContext: WeakReference<ReactApplicationContext>,
+  ) {
+    this.audioAPIModule = audioAPIModule
     this.reactContext = reactContext
-    this.audioManager = reactContext.getSystemService(Context.AUDIO_SERVICE) as AudioManager
-    this.mediaSession = MediaSessionCompat(reactContext, "MediaSessionManager")
+    this.audioManager = reactContext.get()?.getSystemService(Context.AUDIO_SERVICE) as AudioManager
+    this.mediaSession = MediaSessionCompat(reactContext.get()!!, "MediaSessionManager")
 
     if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
       createChannel()
     }
 
-    this.mediaNotificationManager = MediaNotificationManager(reactContext, notificationId, channelId)
-    this.lockScreenManager = LockScreenManager(reactContext, mediaSession, mediaNotificationManager, channelId)
-    this.eventEmitter = MediaSessionEventEmitter(reactContext, notificationId)
-    this.mediaReceiver = MediaReceiver(reactContext, this)
-    this.mediaSession.setCallback(MediaSessionCallback(eventEmitter, lockScreenManager))
+    this.mediaNotificationManager = MediaNotificationManager(this.reactContext)
+    this.lockScreenManager = LockScreenManager(this.reactContext, WeakReference(this.mediaSession), WeakReference(mediaNotificationManager))
+    this.mediaReceiver =
+      MediaReceiver(this.reactContext, WeakReference(this.mediaSession), WeakReference(mediaNotificationManager), this.audioAPIModule)
+    this.mediaSession.setCallback(MediaSessionCallback(this.audioAPIModule, WeakReference(this.lockScreenManager)))
 
     val filter = IntentFilter()
     filter.addAction(MediaNotificationManager.REMOVE_NOTIFICATION)
@@ -80,29 +90,30 @@ object MediaSessionManager {
     filter.addAction(AudioManager.ACTION_AUDIO_BECOMING_NOISY)
 
     if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.TIRAMISU) {
-      reactContext.registerReceiver(mediaReceiver, filter, Context.RECEIVER_EXPORTED)
+      this.reactContext.get()!!.registerReceiver(mediaReceiver, filter, Context.RECEIVER_EXPORTED)
     } else {
       ContextCompat.registerReceiver(
-        reactContext,
+        this.reactContext.get()!!,
         mediaReceiver,
         filter,
         ContextCompat.RECEIVER_NOT_EXPORTED,
       )
     }
 
-    this.audioFocusListener = AudioFocusListener(audioManager, eventEmitter, lockScreenManager)
-    this.volumeChangeListener = VolumeChangeListener(audioManager, eventEmitter)
+    this.audioFocusListener =
+      AudioFocusListener(WeakReference(this.audioManager), this.audioAPIModule, WeakReference(this.lockScreenManager))
+    this.volumeChangeListener = VolumeChangeListener(WeakReference(this.audioManager), this.audioAPIModule)
 
-    val myIntent = Intent(reactContext, MediaNotificationManager.NotificationService::class.java)
+    val myIntent = Intent(this.reactContext.get(), MediaNotificationManager.NotificationService::class.java)
 
     if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
       try {
-        reactContext.bindService(myIntent, connection, Context.BIND_AUTO_CREATE)
+        this.reactContext.get()?.bindService(myIntent, connection, Context.BIND_AUTO_CREATE)
       } catch (ignored: Exception) {
-        ContextCompat.startForegroundService(reactContext, myIntent)
+        ContextCompat.startForegroundService(this.reactContext.get()!!, myIntent)
       }
     } else {
-      reactContext.startService(myIntent)
+      this.reactContext.get()?.startService(myIntent)
     }
   }
 
@@ -137,23 +148,39 @@ object MediaSessionManager {
   fun observeVolumeChanges(observe: Boolean) {
     if (observe) {
       ContextCompat.registerReceiver(
-        reactContext,
+        reactContext.get()!!,
         volumeChangeListener,
         volumeChangeListener.getIntentFilter(),
         ContextCompat.RECEIVER_NOT_EXPORTED,
       )
     } else {
-      reactContext.unregisterReceiver(volumeChangeListener)
+      reactContext.get()?.unregisterReceiver(volumeChangeListener)
     }
   }
 
+  fun requestRecordingPermissions(currentActivity: Activity?): String {
+    ActivityCompat.requestPermissions(currentActivity!!, arrayOf(Manifest.permission.RECORD_AUDIO), 200)
+    return checkRecordingPermissions()
+  }
+
+  fun checkRecordingPermissions(): String =
+    if (ContextCompat.checkSelfPermission(
+        reactContext.get()!!,
+        Manifest.permission.RECORD_AUDIO,
+      ) == PackageManager.PERMISSION_GRANTED
+    ) {
+      "Granted"
+    } else {
+      "Denied"
+    }
+
   @RequiresApi(Build.VERSION_CODES.O)
   private fun createChannel() {
     val notificationManager =
-      reactContext.getSystemService(Context.NOTIFICATION_SERVICE) as NotificationManager
+      reactContext.get()?.getSystemService(Context.NOTIFICATION_SERVICE) as NotificationManager
 
     val mChannel =
-      NotificationChannel(channelId, "Audio manager", NotificationManager.IMPORTANCE_LOW)
+      NotificationChannel(CHANNEL_ID, "Audio manager", NotificationManager.IMPORTANCE_LOW)
     mChannel.description = "Audio manager"
     mChannel.setShowBadge(false)
     mChannel.lockscreenVisibility = NotificationCompat.VISIBILITY_PUBLIC

package/android/src/main/java/com/swmansion/audioapi/system/VolumeChangeListener.kt

@@ -5,18 +5,23 @@ import android.content.Context
 import android.content.Intent
 import android.content.IntentFilter
 import android.media.AudioManager
+import com.swmansion.audioapi.AudioAPIModule
+import java.lang.ref.WeakReference
+import java.util.HashMap
 
 class VolumeChangeListener(
-  private val audioManager: AudioManager,
-  private val eventEmitter: MediaSessionEventEmitter,
+  private val audioManager: WeakReference<AudioManager>,
+  private val audioAPIModule: WeakReference<AudioAPIModule>,
 ) : BroadcastReceiver() {
   override fun onReceive(
     context: Context?,
     intent: Intent?,
   ) {
-    val currentVolume = audioManager.getStreamVolume(AudioManager.STREAM_MUSIC).toDouble()
-    val maxVolume = audioManager.getStreamMaxVolume(AudioManager.STREAM_MUSIC).toDouble()
-    eventEmitter.onVolumeChange(mapOf("value" to currentVolume / maxVolume))
+    val currentVolume = audioManager.get()?.getStreamVolume(AudioManager.STREAM_MUSIC)?.toDouble()!!
+    val maxVolume = audioManager.get()?.getStreamMaxVolume(AudioManager.STREAM_MUSIC)?.toDouble()!!
+
+    val body = HashMap<String, Any>().apply { put("value", currentVolume / maxVolume) }
+    audioAPIModule.get()?.invokeHandlerWithEventNameAndEventBody("volumeChange", body)
   }
 
   fun getIntentFilter(): IntentFilter {

package/android/src/oldarch/NativeAudioAPIModuleSpec.java

@@ -13,9 +13,12 @@
 package com.swmansion.audioapi;
 
 import com.facebook.proguard.annotations.DoNotStrip;
+import com.facebook.react.bridge.Promise;
 import com.facebook.react.bridge.ReactApplicationContext;
 import com.facebook.react.bridge.ReactContextBaseJavaModule;
 import com.facebook.react.bridge.ReactMethod;
+import com.facebook.react.bridge.ReadableArray;
+import com.facebook.react.bridge.ReadableMap;
 import com.facebook.react.turbomodule.core.interfaces.TurboModule;
 import javax.annotation.Nonnull;
 
@@ -34,4 +37,40 @@ public abstract class NativeAudioAPIModuleSpec extends ReactContextBaseJavaModul
   @ReactMethod(isBlockingSynchronousMethod = true)
   @DoNotStrip
   public abstract boolean install();
+
+  @ReactMethod
+  @DoNotStrip
+  public abstract void setLockScreenInfo(ReadableMap info);
+
+  @ReactMethod
+  @DoNotStrip
+  public abstract void resetLockScreenInfo();
+
+  @ReactMethod
+  @DoNotStrip
+  public abstract void enableRemoteCommand(String name, boolean enabled);
+
+  @ReactMethod
+  @DoNotStrip
+  public abstract void setAudioSessionOptions(String category, String mode, ReadableArray options);
+
+  @ReactMethod(isBlockingSynchronousMethod = true)
+  @DoNotStrip
+  public abstract double getDevicePreferredSampleRate();
+
+  @ReactMethod
+  @DoNotStrip
+  public abstract void observeAudioInterruptions(boolean enabled);
+
+  @ReactMethod
+  @DoNotStrip
+  public abstract void observeVolumeChanges(boolean enabled);
+
+  @ReactMethod
+  @DoNotStrip
+  public abstract void requestRecordingPermissions(Promise promise);
+
+  @ReactMethod
+  @DoNotStrip
+  public abstract void checkRecordingPermissions(Promise promise);
 }

package/common/cpp/audioapi/AudioAPIModuleInstaller.h

@@ -8,6 +8,9 @@
 #include <audioapi/HostObjects/OfflineAudioContextHostObject.h>
 #include <audioapi/HostObjects/AudioRecorderHostObject.h>
 
+#include <audioapi/events/AudioEventHandlerRegistry.h>
+#include <audioapi/events/AudioEventHandlerRegistryHostObject.h>
+
 #include <memory>
 
 namespace audioapi {
@@ -16,30 +19,33 @@ using namespace facebook;
 
 class AudioAPIModuleInstaller {
  public:
-  static void injectJSIBindings(jsi::Runtime *jsiRuntime, const std::shared_ptr<react::CallInvoker> &jsCallInvoker) {
-    auto createAudioContext = getCreateAudioContextFunction(jsiRuntime, jsCallInvoker);
-    auto createAudioRecorder = getCreateAudioRecorderFunction(jsiRuntime, jsCallInvoker);
-    auto createOfflineAudioContext = getCreateOfflineAudioContextFunction(jsiRuntime, jsCallInvoker);
+  static void injectJSIBindings(jsi::Runtime *jsiRuntime, const std::shared_ptr<react::CallInvoker> &jsCallInvoker, const std::shared_ptr<AudioEventHandlerRegistry> &audioEventHandlerRegistry) {
+    auto createAudioContext = getCreateAudioContextFunction(jsiRuntime, jsCallInvoker, audioEventHandlerRegistry);
+    auto createAudioRecorder = getCreateAudioRecorderFunction(jsiRuntime, audioEventHandlerRegistry);
+    auto createOfflineAudioContext = getCreateOfflineAudioContextFunction(jsiRuntime, jsCallInvoker, audioEventHandlerRegistry);
 
     jsiRuntime->global().setProperty(*jsiRuntime, "createAudioContext", createAudioContext);
     jsiRuntime->global().setProperty(*jsiRuntime, "createAudioRecorder", createAudioRecorder);
     jsiRuntime->global().setProperty(*jsiRuntime, "createOfflineAudioContext", createOfflineAudioContext);
+
+    auto audioEventHandlerRegistryHostObject = std::make_shared<AudioEventHandlerRegistryHostObject>(audioEventHandlerRegistry);
+    jsiRuntime->global().setProperty(*jsiRuntime, "AudioEventEmitter", jsi::Object::createFromHostObject(*jsiRuntime, audioEventHandlerRegistryHostObject));
   }
 
  private:
-  static jsi::Function getCreateAudioContextFunction(jsi::Runtime *jsiRuntime, const std::shared_ptr<react::CallInvoker> &jsCallInvoker) {
+  static jsi::Function getCreateAudioContextFunction(jsi::Runtime *jsiRuntime, const std::shared_ptr<react::CallInvoker> &jsCallInvoker, const std::shared_ptr<AudioEventHandlerRegistry> &audioEventHandlerRegistry) {
     return jsi::Function::createFromHostFunction(
         *jsiRuntime,
         jsi::PropNameID::forAscii(*jsiRuntime, "createAudioContext"),
         0,
-        [jsCallInvoker](
+        [jsCallInvoker, audioEventHandlerRegistry](
             jsi::Runtime &runtime,
             const jsi::Value &thisValue,
             const jsi::Value *args,
             size_t count) -> jsi::Value {
           std::shared_ptr<AudioContext> audioContext;
           auto sampleRate = static_cast<float>(args[0].getNumber());
-          audioContext = std::make_shared<AudioContext>(sampleRate);
+          audioContext = std::make_shared<AudioContext>(sampleRate, audioEventHandlerRegistry);
 
           auto audioContextHostObject = std::make_shared<AudioContextHostObject>(
               audioContext, &runtime, jsCallInvoker);
@@ -49,12 +55,12 @@ class AudioAPIModuleInstaller {
         });
   }
 
-  static jsi::Function getCreateOfflineAudioContextFunction(jsi::Runtime *jsiRuntime, const std::shared_ptr<react::CallInvoker> &jsCallInvoker) {
+  static jsi::Function getCreateOfflineAudioContextFunction(jsi::Runtime *jsiRuntime, const std::shared_ptr<react::CallInvoker> &jsCallInvoker, const std::shared_ptr<AudioEventHandlerRegistry> &audioEventHandlerRegistry) {
     return jsi::Function::createFromHostFunction(
         *jsiRuntime,
         jsi::PropNameID::forAscii(*jsiRuntime, "createOfflineAudioContext"),
         0,
-        [jsiRuntime, jsCallInvoker](
+        [jsCallInvoker, audioEventHandlerRegistry](
             jsi::Runtime &runtime,
             const jsi::Value &thisValue,
             const jsi::Value *args,
@@ -63,21 +69,21 @@ class AudioAPIModuleInstaller {
             auto length = static_cast<size_t>(args[1].getNumber());
             auto sampleRate = static_cast<float>(args[2].getNumber());
 
-          auto offlineAudioContext = std::make_shared<OfflineAudioContext>(numberOfChannels, length, sampleRate);
+          auto offlineAudioContext = std::make_shared<OfflineAudioContext>(numberOfChannels, length, sampleRate, audioEventHandlerRegistry);
           auto audioContextHostObject = std::make_shared<OfflineAudioContextHostObject>(
-              offlineAudioContext, jsiRuntime, jsCallInvoker);
+              offlineAudioContext, &runtime, jsCallInvoker);
 
           return jsi::Object::createFromHostObject(
               runtime, audioContextHostObject);
         });
   }
 
-  static jsi::Function getCreateAudioRecorderFunction(jsi::Runtime *jsiRuntime, const std::shared_ptr<react::CallInvoker> &jsCallInvoker) {
+  static jsi::Function getCreateAudioRecorderFunction(jsi::Runtime *jsiRuntime, const std::shared_ptr<AudioEventHandlerRegistry> &audioEventHandlerRegistry) {
     return jsi::Function::createFromHostFunction(
         *jsiRuntime,
         jsi::PropNameID::forAscii(*jsiRuntime, "createAudioRecorder"),
         0,
-        [jsCallInvoker](
+        [audioEventHandlerRegistry](
             jsi::Runtime &runtime,
             const jsi::Value &thisValue,
             const jsi::Value *args,
@@ -87,7 +93,7 @@ class AudioAPIModuleInstaller {
           auto sampleRate = static_cast<float>(options.getProperty(runtime, "sampleRate").getNumber());
           auto bufferLength = static_cast<int>(options.getProperty(runtime, "bufferLengthInSamples").getNumber());
 
-          auto audioRecorderHostObject = std::make_shared<AudioRecorderHostObject>(&runtime, jsCallInvoker, sampleRate, bufferLength);
+          auto audioRecorderHostObject = std::make_shared<AudioRecorderHostObject>(&runtime, audioEventHandlerRegistry, sampleRate, bufferLength);
 
           return jsi::Object::createFromHostObject(runtime, audioRecorderHostObject);
         });

package/common/cpp/audioapi/HostObjects/AudioBufferSourceNodeHostObject.h

@@ -15,9 +15,8 @@ class AudioBufferSourceNodeHostObject
     : public AudioScheduledSourceNodeHostObject {
  public:
   explicit AudioBufferSourceNodeHostObject(
-      const std::shared_ptr<AudioBufferSourceNode> &node,
-      const std::shared_ptr<react::CallInvoker> &callInvoker)
-      : AudioScheduledSourceNodeHostObject(node, callInvoker) {
+      const std::shared_ptr<AudioBufferSourceNode> &node)
+      : AudioScheduledSourceNodeHostObject(node) {
     addGetters(
         JSI_EXPORT_PROPERTY_GETTER(AudioBufferSourceNodeHostObject, loop),
         JSI_EXPORT_PROPERTY_GETTER(AudioBufferSourceNodeHostObject, buffer),

package/common/cpp/audioapi/HostObjects/AudioNodeHostObject.h

@@ -1,7 +1,8 @@
 #pragma once
 
-#include <audioapi/jsi/JsiHostObject.h>
+#include <audioapi/HostObjects/AudioParamHostObject.h>
 #include <audioapi/core/AudioNode.h>
+#include <audioapi/jsi/JsiHostObject.h>
 
 #include <jsi/jsi.h>
 #include <memory>
@@ -47,21 +48,33 @@ class AudioNodeHostObject : public JsiHostObject {
   }
 
   JSI_HOST_FUNCTION(connect) {
-    auto node =
-        args[0].getObject(runtime).getHostObject<AudioNodeHostObject>(runtime);
-    node_->connect(std::shared_ptr<AudioNodeHostObject>(node)->node_);
+    auto obj = args[0].getObject(runtime);
+    if (obj.isHostObject<AudioNodeHostObject>(runtime)) {
+      auto node = obj.getHostObject<AudioNodeHostObject>(runtime);
+      node_->connect(std::shared_ptr<AudioNodeHostObject>(node)->node_);
+    }
+    if (obj.isHostObject<AudioParamHostObject>(runtime)) {
+      auto param = obj.getHostObject<AudioParamHostObject>(runtime);
+      node_->connect(std::shared_ptr<AudioParamHostObject>(param)->param_);
+    }
     return jsi::Value::undefined();
   }
 
   JSI_HOST_FUNCTION(disconnect) {
-      if(args[0].isUndefined()) {
-          node_->disconnect();
-          return jsi::Value::undefined();
-      }
+    if (args[0].isUndefined()) {
+      node_->disconnect();
+      return jsi::Value::undefined();
+    }
+    auto obj = args[0].getObject(runtime);
+    if (obj.isHostObject<AudioNodeHostObject>(runtime)) {
+      auto node = obj.getHostObject<AudioNodeHostObject>(runtime);
+      node_->disconnect(std::shared_ptr<AudioNodeHostObject>(node)->node_);
+    }
 
-    auto node =
-        args[0].getObject(runtime).getHostObject<AudioNodeHostObject>(runtime);
-    node_->disconnect(std::shared_ptr<AudioNodeHostObject>(node)->node_);
+    if (obj.isHostObject<AudioParamHostObject>(runtime)) {
+      auto param = obj.getHostObject<AudioParamHostObject>(runtime);
+      node_->disconnect(std::shared_ptr<AudioParamHostObject>(param)->param_);
+    }
     return jsi::Value::undefined();
   }
 

package/common/cpp/audioapi/HostObjects/AudioParamHostObject.h

@@ -32,6 +32,7 @@ class AudioParamHostObject : public JsiHostObject {
 
     addSetters(JSI_EXPORT_PROPERTY_SETTER(AudioParamHostObject, value));
   }
+  friend class AudioNodeHostObject;
 
   JSI_PROPERTY_GETTER(value) {
     return {param_->getValue()};