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

package/common/cpp/audioapi/core/utils/AudioNodeManager.h

@@ -12,6 +12,7 @@ namespace audioapi {
 
 class AudioNode;
 class AudioScheduledSourceNode;
+class AudioParam;
 
 class AudioNodeManager {
  public:
@@ -23,13 +24,19 @@ class AudioNodeManager {
 
   void preProcessGraph();
 
-  void addPendingConnection(
+  void addPendingNodeConnection(
       const std::shared_ptr<AudioNode> &from,
       const std::shared_ptr<AudioNode> &to,
       ConnectionType type);
 
+  void addPendingParamConnection(
+      const std::shared_ptr<AudioNode> &from,
+      const std::shared_ptr<AudioParam> &to,
+    ConnectionType type);
+
   void addProcessingNode(const std::shared_ptr<AudioNode> &node);
   void addSourceNode(const std::shared_ptr<AudioScheduledSourceNode> &node);
+  void addAudioParam(const std::shared_ptr<AudioParam> &param);
 
   void cleanup();
 
@@ -40,6 +47,7 @@ class AudioNodeManager {
   // all nodes created in the context
   std::unordered_set<std::shared_ptr<AudioScheduledSourceNode>> sourceNodes_;
   std::unordered_set<std::shared_ptr<AudioNode>> processingNodes_;
+  std::unordered_set<std::shared_ptr<AudioParam>> audioParams_;
 
   // connections to be settled
   std::vector<std::tuple<
@@ -48,6 +56,12 @@ class AudioNodeManager {
       ConnectionType>>
       audioNodesToConnect_;
 
+  std::vector<std::tuple<
+      std::shared_ptr<AudioNode>,
+      std::shared_ptr<AudioParam>,
+      ConnectionType>>
+      audioParamToConnect_;
+
   void settlePendingConnections();
   void cleanupNode(const std::shared_ptr<AudioNode> &node);
   void prepareNodesForDestruction();

package/common/cpp/audioapi/events/AudioEventHandlerRegistry.cpp

@@ -0,0 +1,108 @@
+#include <audioapi/events/AudioEventHandlerRegistry.h>
+
+namespace audioapi {
+
+AudioEventHandlerRegistry::AudioEventHandlerRegistry(
+    jsi::Runtime *runtime,
+    const std::shared_ptr<react::CallInvoker> &callInvoker) {
+  runtime_ = runtime;
+  callInvoker_ = callInvoker;
+
+  for (const auto &eventName : SYSTEM_EVENT_NAMES) {
+    eventHandlers_[std::string(eventName)] = {};
+  }
+
+  for (const auto &eventName : AUDIO_API_EVENT_NAMES) {
+    eventHandlers_[std::string(eventName)] = {};
+  }
+}
+
+AudioEventHandlerRegistry::~AudioEventHandlerRegistry() {
+  eventHandlers_.clear();
+}
+
+uint64_t AudioEventHandlerRegistry::registerHandler(
+    const std::string &eventName,
+    const std::shared_ptr<jsi::Function> &handler) {
+  static uint64_t LISTENER_ID = 0;
+
+  eventHandlers_[eventName][LISTENER_ID] = handler;
+
+  return LISTENER_ID++;
+}
+
+void AudioEventHandlerRegistry::unregisterHandler(
+    const std::string &eventName,
+    uint64_t listenerId) {
+  auto it = eventHandlers_.find(eventName);
+  if (it != eventHandlers_.end()) {
+    it->second.erase(listenerId);
+  }
+}
+
+void AudioEventHandlerRegistry::invokeHandlerWithEventBody(
+    const std::string &eventName,
+    const std::unordered_map<std::string, EventValue> &body) {
+  auto it = eventHandlers_.find(eventName);
+  if (it != eventHandlers_.end()) {
+    for (const auto &pair : it->second) {
+      auto handler = pair.second;
+      if (handler) {
+        callInvoker_->invokeAsync([this, handler, body]() {
+          auto eventObject = createEventObject(body);
+          handler->call(*runtime_, eventObject);
+        });
+      }
+    }
+  }
+}
+
+void AudioEventHandlerRegistry::invokeHandlerWithEventBody(
+    const std::string &eventName,
+    uint64_t listenerId,
+    const std::unordered_map<std::string, EventValue> &body) {
+  auto it = eventHandlers_.find(eventName);
+  if (it != eventHandlers_.end()) {
+    auto handlersMap = it->second;
+    auto handlerIt = handlersMap.find(listenerId);
+    if (handlerIt != handlersMap.end()) {
+      auto handler = handlerIt->second;
+      if (handler) {
+        callInvoker_->invokeAsync([this, handler, body]() {
+          auto eventObject = createEventObject(body);
+          handler->call(*runtime_, eventObject);
+        });
+      }
+    }
+  }
+}
+
+jsi::Object AudioEventHandlerRegistry::createEventObject(
+    const std::unordered_map<std::string, EventValue> &body) {
+  auto eventObject = jsi::Object(*runtime_);
+
+  for (const auto &pair : body) {
+    const auto name = pair.first.data();
+    const auto &value = pair.second;
+
+    if (holds_alternative<int>(value)) {
+      eventObject.setProperty(*runtime_, name, get<int>(value));
+    } else if (holds_alternative<double>(value)) {
+      eventObject.setProperty(*runtime_, name, get<double>(value));
+    } else if (holds_alternative<float>(value)) {
+      eventObject.setProperty(*runtime_, name, get<float>(value));
+    } else if (holds_alternative<bool>(value)) {
+      eventObject.setProperty(*runtime_, name, get<bool>(value));
+    } else if (holds_alternative<std::string>(value)) {
+      eventObject.setProperty(*runtime_, name, get<std::string>(value));
+    } else if (holds_alternative<std::shared_ptr<jsi::HostObject>>(value)) {
+      auto hostObject = jsi::Object::createFromHostObject(
+          *runtime_, get<std::shared_ptr<jsi::HostObject>>(value));
+      eventObject.setProperty(*runtime_, name, hostObject);
+    }
+  }
+
+  return eventObject;
+}
+
+} // namespace audioapi

package/common/cpp/audioapi/events/AudioEventHandlerRegistry.h

@@ -0,0 +1,62 @@
+#pragma once
+
+#include <jsi/jsi.h>
+#include <ReactCommon/CallInvoker.h>
+#include <memory>
+#include <unordered_map>
+#include <array>
+#include <string>
+#include <variant>
+
+namespace audioapi {
+using namespace facebook;
+
+using EventValue = std::variant<int, float, double, std::string, bool, std::shared_ptr<jsi::HostObject>>;
+
+class AudioEventHandlerRegistry {
+ public:
+  explicit AudioEventHandlerRegistry(
+      jsi::Runtime *runtime,
+      const std::shared_ptr<react::CallInvoker> &callInvoker);
+  ~AudioEventHandlerRegistry();
+
+  uint64_t registerHandler(const std::string &eventName, const std::shared_ptr<jsi::Function> &handler);
+  void unregisterHandler(const std::string &eventName, uint64_t listenerId);
+
+  void invokeHandlerWithEventBody(const std::string &eventName, const std::unordered_map<std::string, EventValue> &body);
+  void invokeHandlerWithEventBody(const std::string &eventName, uint64_t listenerId, const std::unordered_map<std::string, EventValue> &body);
+
+ private:
+    std::shared_ptr<react::CallInvoker> callInvoker_;
+    jsi::Runtime *runtime_;
+    std::unordered_map<std::string, std::unordered_map<uint64_t, std::shared_ptr<jsi::Function>>> eventHandlers_;
+
+    static constexpr std::array<std::string_view, 15> SYSTEM_EVENT_NAMES = {
+        "remotePlay",
+        "remotePause",
+        "remoteStop",
+        "remoteTogglePlayPause",
+        "remoteChangePlaybackRate",
+        "remoteNextTrack",
+        "remotePreviousTrack",
+        "remoteSkipForward",
+        "remoteSkipBackward",
+        "remoteSeekForward",
+        "remoteSeekBackward",
+        "remoteChangePlaybackPosition",
+        "routeChange",
+        "interruption",
+        "volumeChange",
+    };
+
+    static constexpr std::array<std::string_view, 4> AUDIO_API_EVENT_NAMES = {
+      "ended",
+      "audioReady",
+      "audioError",
+      "systemStateChanged"
+    };
+
+    jsi::Object createEventObject(const std::unordered_map<std::string, EventValue> &body);
+};
+
+} // namespace audioapi

package/common/cpp/audioapi/events/AudioEventHandlerRegistryHostObject.h

@@ -0,0 +1,48 @@
+#pragma once
+
+#include <audioapi/jsi/JsiHostObject.h>
+#include <audioapi/events/AudioEventHandlerRegistry.h>
+
+#include <jsi/jsi.h>
+#include <ReactCommon/CallInvoker.h>
+#include <memory>
+#include <unordered_map>
+#include <vector>
+#include <string>
+
+namespace audioapi {
+using namespace facebook;
+
+class AudioEventHandlerRegistryHostObject : public JsiHostObject {
+ public:
+    explicit AudioEventHandlerRegistryHostObject(const std::shared_ptr<AudioEventHandlerRegistry>& eventHandlerRegistry) {
+        eventHandlerRegistry_ = eventHandlerRegistry;
+
+        addFunctions(
+          JSI_EXPORT_FUNCTION(AudioEventHandlerRegistryHostObject, addAudioEventListener),
+          JSI_EXPORT_FUNCTION(AudioEventHandlerRegistryHostObject, removeAudioEventListener));
+    }
+
+    JSI_HOST_FUNCTION(addAudioEventListener) {
+      auto eventName = args[0].getString(runtime).utf8(runtime);
+      auto callback = std::make_shared<jsi::Function>(args[1].getObject(runtime).getFunction(runtime));
+
+      auto listenerId = eventHandlerRegistry_->registerHandler(eventName, callback);
+
+      return jsi::String::createFromUtf8(runtime, std::to_string(listenerId));
+    }
+
+    JSI_HOST_FUNCTION(removeAudioEventListener) {
+        auto eventName = args[0].getString(runtime).utf8(runtime);
+        uint64_t listenerId = std::stoull(args[1].getString(runtime).utf8(runtime));
+
+        eventHandlerRegistry_->unregisterHandler(eventName, listenerId);
+
+        return jsi::Value::undefined();
+    }
+
+ private:
+    std::shared_ptr<AudioEventHandlerRegistry> eventHandlerRegistry_;
+};
+} // namespace audioapi
+

package/common/cpp/audioapi/jsi/JsiPromise.cpp

@@ -44,10 +44,9 @@ jsi::Value PromiseVendor::createPromise(
 
         auto rejectWrapper = [reject, &runtime, callInvoker](
                                  const std::string &errorMessage) -> void {
-          auto error = jsi::JSError(runtime, errorMessage);
-          auto errorShared = std::make_shared<jsi::JSError>(error);
-          callInvoker->invokeAsync([reject, &runtime, errorShared]() -> void {
-            reject->call(runtime, errorShared->value());
+          callInvoker->invokeAsync([reject, &runtime, errorMessage]() -> void {
+            auto error = jsi::JSError(runtime, errorMessage);
+            reject->call(runtime, error.value());
           });
         };
 

package/common/cpp/audioapi/utils/AudioArray.h

@@ -42,7 +42,7 @@ class AudioArray {
       size_t destinationStart,
       size_t length);
 
- private:
+ protected:
   float *data_;
   size_t size_;
 };

package/common/cpp/audioapi/utils/CircularAudioArray.cpp

@@ -0,0 +1,94 @@
+#include <audioapi/utils/CircularAudioArray.h>
+
+namespace audioapi {
+
+CircularAudioArray::CircularAudioArray(size_t size) : AudioArray(size) {}
+
+void CircularAudioArray::push_back(
+    const float *data,
+    size_t size,
+    bool skipAvailableSpaceCheck) {
+  if (size > size_) {
+    throw std::overflow_error("size exceeds CircularAudioArray size_");
+  }
+
+  if (size > getAvailableSpace() && !skipAvailableSpaceCheck) {
+    throw std::overflow_error("not enough space in CircularAudioArray");
+  }
+
+  if (vWriteIndex_ + size > size_) {
+    auto partSize = size_ - vWriteIndex_;
+    memcpy(data_ + vWriteIndex_, data, partSize * sizeof(float));
+    memcpy(data_, data + partSize, (size - partSize) * sizeof(float));
+  } else {
+    memcpy(data_ + vWriteIndex_, data, size * sizeof(float));
+  }
+
+  vWriteIndex_ = vWriteIndex_ + size > size_ ? vWriteIndex_ + size - size_
+                                             : vWriteIndex_ + size;
+}
+
+void CircularAudioArray::pop_front(
+    float *data,
+    size_t size,
+    bool skipAvailableDataCheck) {
+  if (size > size_) {
+    throw std::overflow_error("size exceeds CircularAudioArray size_");
+  }
+
+  if (size > getNumberOfAvailableFrames() && !skipAvailableDataCheck) {
+    throw std::overflow_error("not enough data in CircularAudioArray");
+  }
+
+  if (vReadIndex_ + size > size_) {
+    auto partSize = size_ - vReadIndex_;
+    memcpy(data, data_ + vReadIndex_, partSize * sizeof(float));
+    memcpy(data + partSize, data_, (size - partSize) * sizeof(float));
+  } else {
+    memcpy(data, data_ + vReadIndex_, size * sizeof(float));
+  }
+
+  vReadIndex_ = vReadIndex_ + size > size_ ? vReadIndex_ + size - size_
+                                           : vReadIndex_ + size;
+}
+
+void CircularAudioArray::pop_back(
+    float *data,
+    size_t size,
+    size_t offset,
+    bool skipAvailableDataCheck) {
+  if (size > size_) {
+    throw std::overflow_error("size exceeds CircularAudioArray size_");
+  }
+
+  if (size + offset > getNumberOfAvailableFrames() && !skipAvailableDataCheck) {
+    throw std::overflow_error("not enough data in CircularAudioArray");
+  }
+
+  if (vWriteIndex_ <= offset) {
+    memcpy(
+        data,
+        data_ + size_ - (offset - vWriteIndex_) - size,
+        size * sizeof(float));
+  } else if (vWriteIndex_ <= size + offset) {
+    auto partSize = size + offset - vWriteIndex_;
+    memcpy(data, data_ + size_ - partSize, partSize * sizeof(float));
+    memcpy(data + partSize, data_, (size - partSize) * sizeof(float));
+  } else {
+    memcpy(data, data_ + vWriteIndex_ - size - offset, size * sizeof(float));
+  }
+
+  vReadIndex_ = vWriteIndex_ - offset < 0 ? size + vWriteIndex_ - offset
+                                          : vWriteIndex_ - offset;
+}
+
+size_t CircularAudioArray::getNumberOfAvailableFrames() const {
+  return vWriteIndex_ >= vReadIndex_ ? vWriteIndex_ - vReadIndex_
+                                     : size_ - vReadIndex_ + vWriteIndex_;
+}
+
+size_t CircularAudioArray::getAvailableSpace() const {
+  return size_ - getNumberOfAvailableFrames();
+}
+
+} // namespace audioapi

package/common/cpp/audioapi/utils/CircularAudioArray.h

@@ -0,0 +1,26 @@
+#pragma once
+
+#include <audioapi/utils/AudioArray.h>
+
+namespace audioapi {
+
+class CircularAudioArray : public AudioArray {
+ public:
+  explicit CircularAudioArray(size_t size);
+  CircularAudioArray(const CircularAudioArray &other) = default;
+  ~CircularAudioArray() = default;
+
+  void push_back(const float *data, size_t size, bool skipAvailableSpaceCheck = false);
+  void pop_front(float *data, size_t size, bool skipAvailableDataCheck = false);
+  void pop_back(float *data, size_t size, size_t offset = 0, bool skipAvailableDataCheck = false);
+
+  [[nodiscard]] size_t getNumberOfAvailableFrames() const;
+
+ private:
+  size_t vWriteIndex_ = 0;
+  size_t vReadIndex_ = 0;
+
+  [[nodiscard]] size_t getAvailableSpace() const;
+};
+
+} // namespace audioapi

package/ios/audioapi/ios/AudioAPIModule.h

@@ -7,10 +7,23 @@
 
 #import <React/RCTEventEmitter.h>
 
+@class AudioEngine;
+@class NotificationManager;
+@class AudioSessionManager;
+@class LockScreenManager;
+
 @interface AudioAPIModule : RCTEventEmitter
 #ifdef RCT_NEW_ARCH_ENABLED
                             <NativeAudioAPIModuleSpec, RCTCallInvokerModule>
 #else
                             <RCTBridgeModule>
 #endif // RCT_NEW_ARCH_ENABLED
+
+@property (nonatomic, strong) AudioEngine *audioEngine;
+@property (nonatomic, strong) NotificationManager *notificationManager;
+@property (nonatomic, strong) AudioSessionManager *audioSessionManager;
+@property (nonatomic, strong) LockScreenManager *lockScreenManager;
+
+- (void)invokeHandlerWithEventName:(NSString *)eventName eventBody:(NSDictionary *)eventBody;
+
 @end

package/ios/audioapi/ios/AudioAPIModule.mm

@@ -1,12 +1,16 @@
-#import "AudioAPIModule.h"
-
 #import <React/RCTBridge+Private.h>
-
+#import <audioapi/ios/AudioAPIModule.h>
 #ifdef RCT_NEW_ARCH_ENABLED
 #import <React/RCTCallInvoker.h>
 #endif // RCT_NEW_ARCH_ENABLED
 
-#include <audioapi/AudioAPIModuleInstaller.h>
+#import <audioapi/AudioAPIModuleInstaller.h>
+#import <audioapi/ios/system/AudioEngine.h>
+#import <audioapi/ios/system/AudioSessionManager.h>
+#import <audioapi/ios/system/LockScreenManager.h>
+#import <audioapi/ios/system/NotificationManager.h>
+
+#import <audioapi/events/AudioEventHandlerRegistry.h>
 
 using namespace audioapi;
 using namespace facebook::react;
@@ -24,7 +28,9 @@ using namespace facebook::react;
 @end
 #endif // RCT_NEW_ARCH_ENABLED
 
-@implementation AudioAPIModule
+@implementation AudioAPIModule {
+  std::shared_ptr<AudioEventHandlerRegistry> _eventHandler;
+}
 
 #if defined(RCT_NEW_ARCH_ENABLED)
 @synthesize callInvoker = _callInvoker;
@@ -32,8 +38,25 @@ using namespace facebook::react;
 
 RCT_EXPORT_MODULE(AudioAPIModule);
 
+- (void)invalidate
+{
+  [self.audioEngine cleanup];
+  [self.notificationManager cleanup];
+  [self.audioSessionManager cleanup];
+  [self.lockScreenManager cleanup];
+
+  _eventHandler = nullptr;
+
+  [super invalidate];
+}
+
 RCT_EXPORT_BLOCKING_SYNCHRONOUS_METHOD(install)
 {
+  self.audioSessionManager = [[AudioSessionManager alloc] init];
+  self.audioEngine = [[AudioEngine alloc] initWithAudioSessionManager:self.audioSessionManager];
+  self.lockScreenManager = [[LockScreenManager alloc] initWithAudioAPIModule:self];
+  self.notificationManager = [[NotificationManager alloc] initWithAudioAPIModule:self];
+
   auto jsiRuntime = reinterpret_cast<facebook::jsi::Runtime *>(self.bridge.runtime);
 
 #if defined(RCT_NEW_ARCH_ENABLED)
@@ -44,12 +67,68 @@ RCT_EXPORT_BLOCKING_SYNCHRONOUS_METHOD(install)
 
   assert(jsiRuntime != nullptr);
 
-  audioapi::AudioAPIModuleInstaller::injectJSIBindings(jsiRuntime, jsCallInvoker);
+  _eventHandler = std::make_shared<AudioEventHandlerRegistry>(jsiRuntime, jsCallInvoker);
+
+  self.audioSessionManager = [[AudioSessionManager alloc] init];
+  self.audioEngine = [[AudioEngine alloc] initWithAudioSessionManager:self.audioSessionManager];
+  self.lockScreenManager = [[LockScreenManager alloc] initWithAudioAPIModule:self];
+  self.notificationManager = [[NotificationManager alloc] initWithAudioAPIModule:self];
+
+  audioapi::AudioAPIModuleInstaller::injectJSIBindings(jsiRuntime, jsCallInvoker, _eventHandler);
 
   NSLog(@"Successfully installed JSI bindings for react-native-audio-api!");
   return @true;
 }
 
+RCT_EXPORT_METHOD(setLockScreenInfo : (NSDictionary *)info)
+{
+  [self.lockScreenManager setLockScreenInfo:info];
+}
+
+RCT_EXPORT_METHOD(resetLockScreenInfo)
+{
+  [self.lockScreenManager resetLockScreenInfo];
+}
+
+RCT_EXPORT_METHOD(enableRemoteCommand : (NSString *)name enabled : (BOOL)enabled)
+{
+  [self.lockScreenManager enableRemoteCommand:name enabled:enabled];
+}
+
+RCT_EXPORT_METHOD(setAudioSessionOptions : (NSString *)category mode : (NSString *)mode options : (NSArray *)options)
+{
+  [self.audioSessionManager setAudioSessionOptions:category mode:mode options:options];
+}
+
+RCT_EXPORT_BLOCKING_SYNCHRONOUS_METHOD(getDevicePreferredSampleRate)
+{
+  return [self.audioSessionManager getDevicePreferredSampleRate];
+}
+
+RCT_EXPORT_METHOD(observeAudioInterruptions : (BOOL)enabled)
+{
+  [self.notificationManager observeAudioInterruptions:enabled];
+}
+
+RCT_EXPORT_METHOD(observeVolumeChanges : (BOOL)enabled)
+{
+  [self.notificationManager observeVolumeChanges:(BOOL)enabled];
+}
+
+RCT_EXPORT_METHOD(requestRecordingPermissions : (nonnull RCTPromiseResolveBlock)
+                      resolve reject : (nonnull RCTPromiseRejectBlock)reject)
+{
+  NSString *res = [self.audioSessionManager requestRecordingPermissions];
+  resolve(res);
+}
+
+RCT_EXPORT_METHOD(checkRecordingPermissions : (nonnull RCTPromiseResolveBlock)
+                      resolve reject : (nonnull RCTPromiseRejectBlock)reject)
+{
+  NSString *res = [self.audioSessionManager checkRecordingPermissions];
+  resolve(res);
+}
+
 #ifdef RCT_NEW_ARCH_ENABLED
 - (std::shared_ptr<facebook::react::TurboModule>)getTurboModule:
     (const facebook::react::ObjCTurboModule::InitParams &)params
@@ -58,4 +137,34 @@ RCT_EXPORT_BLOCKING_SYNCHRONOUS_METHOD(install)
 }
 #endif // RCT_NEW_ARCH_ENABLED
 
+- (void)invokeHandlerWithEventName:(NSString *)eventName eventBody:(NSDictionary *)eventBody
+{
+  auto name = [eventName UTF8String];
+
+  std::unordered_map<std::string, EventValue> body = {};
+
+  for (NSString *key in eventBody) {
+    id value = eventBody[key];
+    std::string stdKey = [key UTF8String];
+
+    if ([value isKindOfClass:[NSString class]]) {
+      std::string stdValue = [value UTF8String];
+      body[stdKey] = EventValue(stdValue);
+    } else if ([value isKindOfClass:[NSNumber class]]) {
+      const char *type = [value objCType];
+      if (strcmp(type, @encode(int)) == 0) {
+        body[stdKey] = EventValue([value intValue]);
+      } else if (strcmp(type, @encode(double)) == 0) {
+        body[stdKey] = EventValue([value doubleValue]);
+      } else if (strcmp(type, @encode(float)) == 0) {
+        body[stdKey] = EventValue([value floatValue]);
+      } else if (strcmp(type, @encode(BOOL)) == 0) {
+        body[stdKey] = EventValue([value boolValue]);
+      }
+    }
+  }
+
+  _eventHandler->invokeHandlerWithEventBody(name, body);
+}
+
 @end

package/ios/audioapi/ios/core/IOSAudioRecorder.h

@@ -7,21 +7,19 @@ typedef struct objc_object NativeAudioRecorder;
 #endif // __OBJC__
 
 #include <audioapi/core/inputs/AudioRecorder.h>
-#include <functional>
 
 namespace audioapi {
 
 class AudioBus;
+class CircularAudioArray;
 
 class IOSAudioRecorder : public AudioRecorder {
  public:
   IOSAudioRecorder(
       float sampleRate,
       int bufferLength,
-      const std::function<void(void)> &onError,
-      const std::function<void(void)> &onStatusChange,
-      const std::function<void(std::shared_ptr<AudioBus>, int, double)>
-          &onAudioReady);
+      const std::shared_ptr<AudioEventHandlerRegistry>
+          &audioEventHandlerRegistry);
 
   ~IOSAudioRecorder() override;
 
@@ -30,11 +28,6 @@ class IOSAudioRecorder : public AudioRecorder {
 
  private:
   NativeAudioRecorder *audioRecorder_;
-  std::atomic<bool> isRunning_;
-
-  std::shared_ptr<AudioBus> circularBuffer_;
-  int writeIdx_ = 0;
-  int readIdx_ = 0;
 };
 
 } // namespace audioapi