feat(oscillator): Setup IOS Oscillator

cpp/OscillatorHostObject.cpp

@@ -0,0 +1,60 @@
+#include "OscillatorHostObject.h"
+#include <jsi/jsi.h>
+
+namespace audiocontext {
+  using namespace facebook;
+
+  std::vector<jsi::PropNameID> OscillatorHostObject::getPropertyNames(jsi::Runtime &runtime)
+  {
+    std::vector<jsi::PropNameID> propertyNames;
+    propertyNames.push_back(jsi::PropNameID::forAscii(runtime, "start"));
+    propertyNames.push_back(jsi::PropNameID::forAscii(runtime, "stop"));
+    return propertyNames;
+  }
+
+  jsi::Value OscillatorHostObject::get(jsi::Runtime &runtime, const jsi::PropNameID &propNameId) {
+    auto propName = propNameId.utf8(runtime);
+
+    if (propName == "start") {
+      return jsi::Function::createFromHostFunction(runtime, propNameId, 0,
+        [this](jsi::Runtime &rt, const jsi::Value &, const jsi::Value *args, size_t count) {
+          if (count != 0) {
+            throw std::invalid_argument("start expects exactly zero arguments");
+          }
+          platformOscillator_.start();
+          return jsi::Value::undefined();
+        });
+    }
+
+    if (propName == "stop") {
+      return jsi::Function::createFromHostFunction(runtime, propNameId, 0,
+        [this](jsi::Runtime &rt, const jsi::Value &, const jsi::Value *args, size_t count) {
+          if (count != 0) {
+            throw std::invalid_argument("stop expects exactly zero arguments");
+          }
+          platformOscillator_.stop();
+          return jsi::Value::undefined();
+        });
+    }
+
+    if (propName == "frequency") {
+      return jsi::Value(frequency_);
+    }
+
+    throw std::runtime_error("Not yet implemented!");
+  }
+
+  void OscillatorHostObject::set(jsi::Runtime &runtime, const jsi::PropNameID &propNameId, const jsi::Value &value)
+  {
+    auto propName = propNameId.utf8(runtime);
+
+    if (propName == "frequency") {
+      float frequency = static_cast<float>(value.asNumber());
+      frequency_ = frequency;
+      return platformOscillator_.changeFrequency(frequency);
+    }
+
+    throw std::runtime_error("Not yet implemented!");
+  }
+
+} // namespace audiocontext

cpp/OscillatorHostObject.h

@@ -0,0 +1,27 @@
+#ifndef OSCILLATORHOSTOBJECT_H
+#define OSCILLATORHOSTOBJECT_H
+
+#include <jsi/jsi.h>
+#include <PlatformOscillator.h>
+
+namespace audiocontext
+{
+
+  using namespace facebook;
+
+  class JSI_EXPORT OscillatorHostObject : public jsi::HostObject
+  {
+    public:
+      explicit OscillatorHostObject(float frequency) : frequency_(frequency), platformOscillator_(frequency) {}
+      jsi::Value get(jsi::Runtime &, const jsi::PropNameID &name) override;
+      void set(jsi::Runtime &, const jsi::PropNameID &name, const jsi::Value &value) override;
+      std::vector<jsi::PropNameID> getPropertyNames(jsi::Runtime &rt) override;
+
+    protected:
+      PlatformOscillator platformOscillator_;
+      float frequency_;
+  };
+
+} // namespace audiocontext
+
+#endif /* OSCILLATORHOSTOBJECT_H */

example/src/App.tsx

@@ -1,15 +1,56 @@
-import React from 'react';
-import { StyleSheet, View, Text } from 'react-native';
-import JSIExample from '../../src/JSIExample/JSIExample';
+import React, { useCallback, useRef, useState } from 'react';
+import { StyleSheet, View, Button, TextInput } from 'react-native';
+import { AudioContext, type OscillatorNode } from 'react-native-audio-context';
 
 const App: React.FC = () => {
-  const multiply = () => {
-    return JSIExample.multiply(2, 3);
-  };
+  const [frequency, setFrequency] = useState('440');
+  const osc = useRef<OscillatorNode | null>(null);
+
+  const start = useCallback(() => {
+    if (!osc.current) {
+      const context = new AudioContext();
+      osc.current = context.createOscillator(+frequency);
+    }
+
+    osc.current.start();
+  }, [frequency]);
+
+  const stop = useCallback(() => {
+    if (!osc.current) {
+      return;
+    }
+
+    osc.current.stop();
+  }, []);
+
+  const changeFrequency = useCallback(() => {
+    if (!osc.current) {
+      return;
+    }
+
+    osc.current.frequency = parseFloat(frequency);
+  }, [frequency]);
+
+  const getFrequency = useCallback(() => {
+    if (!osc.current) {
+      return;
+    }
+
+    console.log(osc.current.frequency);
+
+    return osc.current.frequency;
+  }, []);
 
   return (
     <View style={styles.container}>
-      <Text>{multiply()}</Text>
+      <Button title="Start1" onPress={start} />
+      <Button title="Stop1" onPress={stop} />
+      <TextInput
+        value={frequency}
+        onChangeText={(text) => setFrequency(text)}
+      />
+      <Button title="Change frequency" onPress={changeFrequency} />
+      <Button title="Get current frequency" onPress={getFrequency} />
     </View>
   );
 };

ios/AudioContextModule.h

@@ -0,0 +1,5 @@
+#import <React/RCTBridgeModule.h>
+
+@interface AudioContextModule : NSObject <RCTBridgeModule>
+
+@end

ios/AudioContextModule.mm

@@ -0,0 +1,53 @@
+#import "AudioContextModule.h"
+
+#import <React/RCTBridge+Private.h>
+#import <React/RCTUtils.h>
+#import <jsi/jsi.h>
+
+#import "../cpp/OscillatorHostObject.h"
+
+@implementation AudioContextModule
+
+RCT_EXPORT_MODULE(AudioContext)
+
+RCT_EXPORT_BLOCKING_SYNCHRONOUS_METHOD(install)
+{
+    NSLog(@"Installing JSI bindings for react-native-audio-context...");
+    RCTBridge* bridge = [RCTBridge currentBridge];
+    RCTCxxBridge* cxxBridge = (RCTCxxBridge*)bridge;
+    if (cxxBridge == nil) {
+        return @false;
+    }
+
+    using namespace facebook;
+
+    auto jsiRuntime = (jsi::Runtime*) cxxBridge.runtime;
+    if (jsiRuntime == nil) {
+        return @false;
+    }
+    auto& runtime = *jsiRuntime;
+
+    runtime.global().setProperty(
+        runtime,
+        jsi::String::createFromUtf8(runtime, "createOscillator"),
+        jsi::Function::createFromHostFunction(
+            runtime,
+            jsi::PropNameID::forUtf8(runtime, "createOscillator"),
+            0,
+            [](jsi::Runtime& runtime, const jsi::Value& thisVal, const jsi::Value* args, size_t count) -> jsi::Value {
+                const float frequency = static_cast<float>(args[0].asNumber());
+
+                auto cppOscillatorHostObjectPtr = std::make_shared<audiocontext::OscillatorHostObject>(frequency);
+
+                const auto& jsiOscillatorHostObject = jsi::Object::createFromHostObject(runtime, cppOscillatorHostObjectPtr);
+
+                return jsi::Value(runtime, jsiOscillatorHostObject);
+            }
+        )
+    );
+
+    NSLog(@"Successfully installed JSI bindings for react-native-audio-context!");
+    return @true;
+}
+
+@end

ios/IOSOscillator.h

@@ -0,0 +1,21 @@
+#import <Foundation/Foundation.h>
+#import <AVFoundation/AVFoundation.h>
+
+@interface IOSOscillator : NSObject
+
+@property (nonatomic, strong) AVAudioEngine *audioEngine;
+@property (nonatomic, strong) AVAudioPlayerNode *playerNode;
+@property (nonatomic, strong) AVAudioPCMBuffer *buffer;
+@property (nonatomic, strong) AVAudioFormat *format;
+@property (nonatomic, assign) float frequency;
+@property (nonatomic, assign) double sampleRate;
+
+- (instancetype)init:(float)frequency;
+
+- (void)start;
+
+- (void)stop;
+
+- (void)changeFrequency:(float)frequency;
+
+@end

ios/IOSOscillator.m

@@ -0,0 +1,61 @@
+#import <IOSOscillator.h>
+
+@implementation IOSOscillator {}
+
+- (instancetype)init:(float)frequency {
+    if (self = [super init]) {
+        self.frequency = frequency;
+        self.sampleRate = 44100;
+
+        self.audioEngine = [[AVAudioEngine alloc] init];
+        self.playerNode = [[AVAudioPlayerNode alloc] init];
+
+        self.format = [[AVAudioFormat alloc] initStandardFormatWithSampleRate:self.sampleRate channels:1];
+        AVAudioFrameCount bufferFrameCapacity = (AVAudioFrameCount)self.sampleRate;
+        self.buffer = [[AVAudioPCMBuffer alloc] initWithPCMFormat:self.format frameCapacity:bufferFrameCapacity];
+        self.buffer.frameLength = bufferFrameCapacity;
+
+        [self.audioEngine attachNode:self.playerNode];
+        [self.audioEngine connect:self.playerNode to:self.audioEngine.mainMixerNode format: self.format];
+        [self setBuffer];
+
+        NSError *error = nil;
+        if (![self.audioEngine startAndReturnError:&error]) {
+            NSLog(@"Error starting audio engine: %@", [error localizedDescription]);
+        }
+    }
+
+    return self;
+}
+
+- (void)start {
+    [self.playerNode scheduleBuffer:self.buffer atTime:nil options:AVAudioPlayerNodeBufferLoops completionHandler:nil];
+    [self.playerNode play];
+}
+
+- (void)stop {
+    [self.playerNode stop];
+}
+
+- (void)setBuffer {
+    AVAudioFrameCount bufferFrameCapacity = (AVAudioFrameCount)self.sampleRate;
+
+    double thetaIncrement = 2.0 * M_PI * self.frequency / self.sampleRate;
+    double theta = 0.0;
+    float *audioBufferPointer = self.buffer.floatChannelData[0];
+
+    for (int frame = 0; frame < bufferFrameCapacity; frame++) {
+        audioBufferPointer[frame] = sin(theta);
+        theta += thetaIncrement;
+        if (theta > 2.0 * M_PI) {
+            theta -= 2.0 * M_PI;
+        }
+    }
+}
+
+- (void)changeFrequency:(float)frequency {
+    self.frequency = frequency;
+    [self setBuffer];
+}
+
+@end