feat: added some audio context files

trying to implement host objects and hybrid classes for those audio context classes

Author: Maciej Makowski

android/CMakeLists.txt

@@ -17,9 +17,11 @@ include_directories(
 )
 
 find_package(ReactAndroid REQUIRED CONFIG)
+find_package(fbjni REQUIRED CONFIG)
 
 target_link_libraries(
   react-native-audio-context
   ReactAndroid::jsi
+  fbjni::fbjni
   android
 )

android/build.gradle

@@ -125,6 +125,7 @@ dependencies {
   //noinspection GradleDynamicVersion
   implementation "com.facebook.react:react-native:+"
   implementation 'androidx.core:core-ktx:1.13.1'
+  implementation 'com.facebook.fbjni:fbjni:0.6.0'
 }
 
 if (isNewArchitectureEnabled()) {

android/cpp-adapter.cpp

@@ -1,18 +1,18 @@
 #include <jni.h>
 #include <jsi/jsi.h>
-#include "JSIExampleHostObject.h"
+#include "AudioContextHostObject.h"
 
 using namespace facebook;
 
 void install(jsi::Runtime& runtime) {
-    auto hostObject = std::make_shared<example::JSIExampleHostObject>();
+    auto hostObject = std::make_shared<audiocontext::AudioContextHostObject>();
     auto object = jsi::Object::createFromHostObject(runtime, hostObject);
     runtime.global().setProperty(runtime, "__JSIExampleProxy", std::move(object));
 }
 
 extern "C"
 JNIEXPORT void JNICALL
-Java_com_audiocontext_jsi_JSIExampleModule_00024Companion_nativeInstall(JNIEnv *env, jobject clazz, jlong jsiPtr) {
+Java_com_audiocontext_jsi_AudioContextModule_00024Companion_nativeInstall(JNIEnv *env, jobject clazz, jlong jsiPtr) {
     auto runtime = reinterpret_cast<jsi::Runtime*>(jsiPtr);
     if (runtime) {
         install(*runtime);

android/src/main/cpp/AudioContext.h

@@ -0,0 +1,26 @@
+#include <fbjni/fbjni.h>
+#include <jsi/jsi.h>
+
+namespace audiocontext {
+    using namespace facebook;
+    using namespace facebook::jni;
+
+    class AudioContext: public HybridClass<AudioContext> {
+        public:
+            static auto constexpr kJavaDescriptor =
+                "Lcom/audiocontext/context/AudioContext;";
+
+            static void registerNatives() {
+                javaClassStatic()->registerNatives({
+                    makeNativeMethod("initHybrid", AudioContext::initHybrid),
+                });
+            }
+
+            static HybridBase* initHybrid(alias_ref<jhybridobject> jThis) {
+                return new AudioContext(jThis);
+            }
+
+    private:
+            global_ref<jobject> javaObject_;
+    };
+}

android/src/main/java/com/audiocontext/JSIExamplePackage.kt renamed to android/src/main/java/com/audiocontext/AudioContextPackage.kt

@@ -1,14 +1,14 @@
 package com.audiocontext
 
-import com.audiocontext.jsi.JSIExampleModule
+import com.audiocontext.jsi.AudioContextModule
 import com.facebook.react.ReactPackage
 import com.facebook.react.bridge.NativeModule
 import com.facebook.react.bridge.ReactApplicationContext
 import com.facebook.react.uimanager.ViewManager
 
-class JSIExamplePackage : ReactPackage {
+class AudioContextPackage : ReactPackage {
   override fun createNativeModules(reactContext: ReactApplicationContext): List<NativeModule> {
-    return listOf<NativeModule>(JSIExampleModule(reactContext))
+    return listOf<NativeModule>(AudioContextModule(reactContext))
   }
 
   override fun createViewManagers(reactContext: ReactApplicationContext): List<ViewManager<*, *>> {

android/src/main/java/com/audiocontext/AudioContextPackageeee.kt

@@ -0,0 +1,20 @@
+package com.audiocontext
+
+import android.view.View
+import com.audiocontext.nativemodules.AudioContextModule
+import com.facebook.react.ReactPackage
+import com.facebook.react.bridge.NativeModule
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.uimanager.ReactShadowNode
+import com.facebook.react.uimanager.ViewManager
+
+class AudioContextPackageeee : ReactPackage {
+
+  override fun createViewManagers(
+    reactContext: ReactApplicationContext
+  ): MutableList<ViewManager<View, ReactShadowNode<*>>> = mutableListOf()
+
+  override fun createNativeModules(
+    reactContext: ReactApplicationContext
+  ): MutableList<NativeModule> = listOf(AudioContextModule(reactContext)).toMutableList()
+}

android/src/main/java/com/audiocontext/context/AudioContext.kt

@@ -0,0 +1,43 @@
+package com.audiocontext.context
+
+import android.media.AudioTrack
+import com.audiocontext.nodes.AudioDestinationNode
+import com.audiocontext.nodes.AudioNode
+import com.audiocontext.nodes.gain.GainNode
+import com.audiocontext.nodes.oscillator.OscillatorNode
+import java.util.concurrent.CopyOnWriteArrayList
+
+class AudioContext : BaseAudioContext {
+  override var sampleRate: Int = 44100
+  override val destination: AudioDestinationNode = AudioDestinationNode(this)
+  override val sources = CopyOnWriteArrayList<AudioNode>()
+
+  override fun addNode(node: AudioNode) {
+    sources.add(node)
+  }
+
+  override fun removeNode(node: AudioNode) {
+    sources.remove(node)
+  }
+
+  override fun createOscillatorNode(): OscillatorNode {
+    val oscillatorNode = OscillatorNode(this)
+    addNode(oscillatorNode)
+    return oscillatorNode
+  }
+
+  override fun createGainNode(): GainNode {
+    val gainNode = GainNode(this)
+    return gainNode
+  }
+
+  override fun dispatchAudio(buffer: ShortArray, audioTrack: AudioTrack) {
+    val currentBuffer = buffer.clone()
+
+    synchronized(sources) {
+      sources.forEach { source ->
+        source.process(currentBuffer, audioTrack)
+      }
+    }
+  }
+}

android/src/main/java/com/audiocontext/context/AudioContextState.kt

@@ -0,0 +1,7 @@
+package com.audiocontext.context
+
+enum class AudioContextState {
+  SUSPENDED,
+  RUNNING,
+  CLOSED
+}

android/src/main/java/com/audiocontext/context/BaseAudioContext.kt

@@ -0,0 +1,21 @@
+package com.audiocontext.context
+
+import android.media.AudioTrack
+import android.provider.MediaStore.Audio
+import com.audiocontext.nodes.AudioDestinationNode
+import com.audiocontext.nodes.AudioNode
+import com.audiocontext.nodes.gain.GainNode
+import com.audiocontext.nodes.oscillator.OscillatorNode
+import java.util.concurrent.CopyOnWriteArrayList
+
+interface BaseAudioContext {
+  val sampleRate: Int
+  val destination: AudioDestinationNode
+  val sources: List<AudioNode>
+
+  fun createOscillatorNode(): OscillatorNode
+  fun createGainNode(): GainNode
+  fun dispatchAudio(buffer: ShortArray, audioTrack: AudioTrack)
+  fun addNode(node: AudioNode)
+  fun removeNode(node: AudioNode)
+}

android/src/main/java/com/audiocontext/jsi/JSIExampleModule.kt renamed to android/src/main/java/com/audiocontext/jsi/AudioContextModule.kt

@@ -6,8 +6,8 @@ import com.facebook.react.bridge.ReactContextBaseJavaModule
 import com.facebook.react.bridge.ReactMethod
 import com.facebook.react.module.annotations.ReactModule
 
-@ReactModule(name = JSIExampleModule.NAME)
-class JSIExampleModule(reactContext: ReactApplicationContext?) :
+@ReactModule(name = AudioContextModule.NAME)
+class AudioContextModule(reactContext: ReactApplicationContext?) :
   ReactContextBaseJavaModule(reactContext) {
   override fun getName(): String {
     return NAME
@@ -29,7 +29,7 @@ class JSIExampleModule(reactContext: ReactApplicationContext?) :
   }
 
   companion object {
-    const val NAME: String = "JSIExample"
+    const val NAME: String = "AudioContext"
 
     private external fun nativeInstall(jsiPtr: Long)
   }

android/src/main/java/com/audiocontext/nativemodules/AudioContextModule.kt

@@ -0,0 +1,44 @@
+package com.audiocontext.nativemodules
+
+import com.audiocontext.context.AudioContext
+import com.audiocontext.nodes.AudioNode
+import com.audiocontext.nodes.AudioScheduledSourceNode
+import com.audiocontext.nodes.gain.GainNode
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.bridge.ReactContextBaseJavaModule
+import com.facebook.react.bridge.ReactMethod
+
+class AudioContextModule(reactContext: ReactApplicationContext) : ReactContextBaseJavaModule(reactContext) {
+  private val audioContext = AudioContext()
+  private var source: AudioScheduledSourceNode? = null
+  private var destination: AudioNode = audioContext.destination
+
+  override fun getName(): String {
+    return "AudioContextModule"
+  }
+
+  @ReactMethod(isBlockingSynchronousMethod = true)
+  fun createOscillatorNode() {
+    source = audioContext.createOscillatorNode()
+  }
+
+  @ReactMethod
+  fun start() {
+    source?.start()
+  }
+
+  @ReactMethod
+  fun stop() {
+    source?.stop()
+  }
+
+  @ReactMethod
+  fun connect() {
+    source?.connect(destination)
+  }
+
+  @ReactMethod
+  fun disconnect() {
+    source?.disconnect()
+  }
+}

android/src/main/java/com/audiocontext/nodes/AudioDestinationNode.kt

@@ -0,0 +1,14 @@
+package com.audiocontext.nodes
+
+import android.media.AudioTrack
+import com.audiocontext.context.BaseAudioContext
+
+
+class AudioDestinationNode(context: BaseAudioContext): AudioNode(context) {
+  override val numberOfInputs = 1
+  override val numberOfOutputs = 0
+
+  override fun process(buffer: ShortArray, audioTrack: AudioTrack) {
+    audioTrack.write(buffer, 0, buffer.size)
+  }
+}

android/src/main/java/com/audiocontext/nodes/AudioNode.kt

@@ -0,0 +1,25 @@
+package com.audiocontext.nodes
+
+import android.media.AudioTrack
+import com.audiocontext.context.BaseAudioContext
+
+
+abstract class AudioNode(val context: BaseAudioContext) {
+  abstract val numberOfInputs: Int;
+  abstract val numberOfOutputs: Int;
+  private val connectedNodes = mutableListOf<AudioNode>()
+
+  fun connect(destination: AudioNode) {
+    if(this.numberOfOutputs > 0) {
+      connectedNodes.add(destination)
+    }
+  }
+
+  fun disconnect() {
+    connectedNodes.clear()
+  }
+
+  open fun process(buffer: ShortArray, audioTrack: AudioTrack) {
+    connectedNodes.forEach { it.process(buffer, audioTrack) }
+  }
+}

android/src/main/java/com/audiocontext/nodes/AudioScheduledSourceNode.kt

@@ -0,0 +1,8 @@
+package com.audiocontext.nodes
+
+import com.audiocontext.context.BaseAudioContext
+
+abstract class AudioScheduledSourceNode(context: BaseAudioContext) : AudioNode(context) {
+  abstract fun start()
+  abstract fun stop()
+}

android/src/main/java/com/audiocontext/nodes/gain/GainNode.kt

@@ -0,0 +1,22 @@
+package com.audiocontext.nodes.gain
+
+import android.media.AudioTrack
+import com.audiocontext.context.BaseAudioContext
+import com.audiocontext.nodes.AudioNode
+
+class GainNode(context: BaseAudioContext): AudioNode(context) {
+  override val numberOfInputs = 1
+  override val numberOfOutputs = 1
+  var gain: Double = 1.0
+    get() = field
+    set(value) {
+      field = value
+      if (field < 0) field = 0.0
+      if (field > 1) field = 1.0
+    }
+
+  override fun process(buffer: ShortArray, audioTrack: AudioTrack) {
+    audioTrack.setVolume(gain.toFloat())
+    super.process(buffer, audioTrack)
+  }
+}

android/src/main/java/com/audiocontext/nodes/oscillator/OscillatorNode.kt

@@ -0,0 +1,69 @@
+package com.audiocontext.nodes.oscillator
+
+import android.media.AudioFormat
+import android.media.AudioManager
+import android.media.AudioTrack
+import com.audiocontext.context.BaseAudioContext
+import com.audiocontext.nodes.AudioScheduledSourceNode
+import kotlin.math.abs
+import kotlin.math.floor
+import kotlin.math.sin
+
+class OscillatorNode(context: BaseAudioContext) : AudioScheduledSourceNode(context) {
+  override val numberOfInputs: Int = 0
+  override val numberOfOutputs: Int = 1
+  private var frequency: Double = 440.0
+  private var detune: Double = 0.0
+  private var waveType: WaveType = WaveType.SINE
+
+  private val audioTrack: AudioTrack
+  @Volatile private var isPlaying: Boolean = false
+  private var playbackThread: Thread? = null
+  private var buffer: ShortArray = ShortArray(1024)
+
+  init {
+    val bufferSize = AudioTrack.getMinBufferSize(
+      context.sampleRate,
+      AudioFormat.CHANNEL_OUT_MONO, AudioFormat.ENCODING_PCM_16BIT)
+    this.audioTrack = AudioTrack(
+      AudioManager.STREAM_MUSIC, context.sampleRate, AudioFormat.CHANNEL_OUT_MONO,
+      AudioFormat.ENCODING_PCM_16BIT, bufferSize, AudioTrack.MODE_STREAM
+    )
+  }
+
+  override fun start() {
+    if(isPlaying) return
+    isPlaying = true
+    audioTrack.play()
+    playbackThread = Thread { generateSound() }.apply{ start()}
+  }
+
+  override fun stop() {
+    if(!isPlaying) return
+    isPlaying = false
+    audioTrack.stop()
+    playbackThread?.join()
+  }
+
+  private fun generateSound() {
+    var wavePhase = 0.0
+    var phaseChange: Double
+
+    while(isPlaying) {
+      phaseChange = 2 * Math.PI * (frequency + detune) / context.sampleRate
+
+      for(i in buffer.indices) {
+        buffer[i] = when(waveType) {
+          WaveType.SINE -> (sin(wavePhase) * Short.MAX_VALUE).toInt().toShort()
+          WaveType.SQUARE -> ((if (sin(wavePhase) >= 0) 1 else -1) * Short.MAX_VALUE).toShort()
+          WaveType.SAWTOOTH -> ((2 * (wavePhase / (2 * Math.PI) - floor(wavePhase / (2 * Math.PI) + 0.5))) * Short.MAX_VALUE).toInt().toShort()
+          WaveType.TRIANGLE -> ((2 * abs(2 * (wavePhase / (2 * Math.PI) - floor(wavePhase / (2 * Math.PI) + 0.5))) - 1) * Short.MAX_VALUE).toInt().toShort()
+        }
+        wavePhase += phaseChange
+      }
+
+      context.dispatchAudio(buffer, audioTrack)
+    }
+    audioTrack.flush()
+  }
+}

android/src/main/java/com/audiocontext/nodes/oscillator/WaveType.kt

@@ -0,0 +1,8 @@
+package com.audiocontext.nodes.oscillator
+
+enum class WaveType {
+  SINE,
+  SQUARE,
+  SAWTOOTH,
+  TRIANGLE
+}