react-native-audio-api 0.11.0-alpha.0 → 0.11.0-alpha.10

package/android/src/main/cpp/audioapi/android/core/AndroidAudioRecorder.cpp

@@ -1,40 +1,61 @@
 #include <android/log.h>
 #include <audioapi/android/core/AndroidAudioRecorder.h>
 #include <audioapi/android/core/utils/AndroidFileWriterBackend.h>
+#include <audioapi/android/core/utils/AndroidRecorderCallback.h>
+
+#if !RN_AUDIO_API_FFMPEG_DISABLED
 #include <audioapi/android/core/utils/ffmpegBackend/FFmpegFileWriter.h>
+#endif // RN_AUDIO_API_FFMPEG_DISABLED
+
 #include <audioapi/android/core/utils/miniaudioBackend/MiniAudioFileWriter.h>
 #include <audioapi/core/sources/RecorderAdapterNode.h>
 #include <audioapi/core/utils/Constants.h>
+#include <audioapi/core/utils/Locker.h>
 #include <audioapi/events/AudioEventHandlerRegistry.h>
 #include <audioapi/utils/AudioArray.h>
 #include <audioapi/utils/AudioBus.h>
+#include <audioapi/utils/AudioFileProperties.h>
 #include <audioapi/utils/CircularAudioArray.h>
 #include <audioapi/utils/CircularOverflowableAudioArray.h>
 
+#include <memory>
+#include <string>
+
 namespace audioapi {
 
 AndroidAudioRecorder::AndroidAudioRecorder(
     const std::shared_ptr<AudioEventHandlerRegistry> &audioEventHandlerRegistry)
-    : AudioRecorder(audioEventHandlerRegistry) {
-  AudioStreamBuilder builder;
-
-  builder.setSharingMode(SharingMode::Exclusive)
-      ->setDirection(Direction::Input)
-      ->setFormat(AudioFormat::Float)
-      ->setFormatConversionAllowed(true)
-      ->setPerformanceMode(PerformanceMode::None)
-      ->setSampleRateConversionQuality(SampleRateConversionQuality::Medium)
-      ->setDataCallback(this)
-      ->openStream(mStream_);
-
-  streamSampleRate_ = mStream_->getSampleRate();
-  streamChannelCount_ = mStream_->getChannelCount();
-  streamMaxBufferSizeInFrames_ = mStream_->getBufferSizeInFrames();
-
+    : AudioRecorder(audioEventHandlerRegistry),
+      streamSampleRate_(0.0),
+      streamChannelCount_(0),
+      streamMaxBufferSizeInFrames_(0) {
   nativeAudioRecorder_ = jni::make_global(NativeAudioRecorder::create());
 }
 
+/// @brief Destructor ensures that the audio stream and each output type are closed and flushed up remaining data.
+/// TODO: Possibly locks here are not necessary, but we might have an issue with oboe having raw pointer to the
+/// recorder (and player) instances, thus creating race conditions during destruction.
+/// callable from the JS thread only (i hope).
 AndroidAudioRecorder::~AndroidAudioRecorder() {
+  {
+    std::scoped_lock dtorLock(callbackMutex_, fileWriterMutex_, adapterNodeMutex_);
+
+    if (usesFileOutput()) {
+      fileOutputEnabled_.store(false, std::memory_order_release);
+      fileWriter_->closeFile();
+    }
+
+    if (usesCallback()) {
+      callbackOutputEnabled_.store(false, std::memory_order_release);
+      dataCallback_->cleanup();
+    }
+
+    if (isConnected()) {
+      isConnected_.store(false, std::memory_order_release);
+      adapterNode_->cleanup();
+    }
+  }
+
   nativeAudioRecorder_.release();
 
   if (mStream_) {
@@ -44,114 +65,372 @@ AndroidAudioRecorder::~AndroidAudioRecorder() {
   }
 }
 
-void AndroidAudioRecorder::start() {
+/// @brief Creates and opens the Oboe audio input stream for recording.
+/// calculates the "native" or hardware stream parameters for other interfaces
+/// to use.
+/// Callable from the JS thread only.
+/// @returns Success status or Error status with message.
+Result<NoneType, std::string> AndroidAudioRecorder::openAudioStream() {
+  if (mStream_) {
+    return Result<NoneType, std::string>::Ok(None);
+  }
+
+  oboe::AudioStreamBuilder builder;
+  builder.setSharingMode(oboe::SharingMode::Exclusive)
+      ->setDirection(oboe::Direction::Input)
+      ->setFormat(oboe::AudioFormat::Float)
+      ->setFormatConversionAllowed(true)
+      ->setPerformanceMode(oboe::PerformanceMode::None)
+      ->setSampleRateConversionQuality(oboe::SampleRateConversionQuality::Medium)
+      ->setDataCallback(this)
+      ->setErrorCallback(this);
+
+  auto result = builder.openStream(mStream_);
+
+  if (result != oboe::Result::OK || mStream_ == nullptr) {
+    return Result<NoneType, std::string>::Err(
+        "Failed to open audio stream: " + std::string(oboe::convertToText(result)));
+  }
+
+  streamSampleRate_ = static_cast<float>(mStream_->getSampleRate());
+  streamChannelCount_ = mStream_->getChannelCount();
+  streamMaxBufferSizeInFrames_ = mStream_->getBufferSizeInFrames();
+
+  return Result<NoneType, std::string>::Ok(None);
+}
+
+/// @brief prepares and starts the audio recording process.
+/// If audio stream is opened correctly, it will set up any output configured
+/// (file writing, callback, adapter node) and start the stream.
+/// This method should be called from the JS thread only.
+/// NOTE: I've noticed some possibly invalid file paths being returned on Android,
+/// RN side requires their "file://" prefix, but sometimes it returned raw path.
+/// Most likely this was due to alpha version mistakes, but in case of problems leaving this here. (ㆆ _ ㆆ)
+/// @returns On success, returns the file URI where the recording is being saved (if file output is enabled).
+Result<std::string, std::string> AndroidAudioRecorder::start() {
+  std::scoped_lock startLock(callbackMutex_, fileWriterMutex_, adapterNodeMutex_);
+
   if (isRecording()) {
-    return;
+    return Result<std::string, std::string>::Ok(std::format("file://{}", filePath_));
+  }
+
+  auto streamResult = openAudioStream();
+
+  if (!streamResult.is_ok()) {
+    return Result<std::string, std::string>::Err(streamResult.unwrap_err());
   }
 
   if (!mStream_ || !nativeAudioRecorder_) {
-    __android_log_print(
-        ANDROID_LOG_ERROR,
-        "AndroidAudioRecorder",
-        "Audio stream is not initialized.\n");
-    return;
+    return Result<std::string, std::string>::Err("Audio stream is not initialized.");
   }
 
   if (usesFileOutput()) {
-    fileWriter_->openFile(
-        streamSampleRate_, streamChannelCount_, streamMaxBufferSizeInFrames_);
+    auto fileResult =
+        std::static_pointer_cast<AndroidFileWriterBackend>(fileWriter_)
+            ->openFile(streamSampleRate_, streamChannelCount_, streamMaxBufferSizeInFrames_);
+
+    if (!fileResult.is_ok()) {
+      return Result<std::string, std::string>::Err(
+          "Failed to open file for writing: " + fileResult.unwrap_err());
+    }
+
+    filePath_ = fileResult.unwrap();
   }
 
   if (usesCallback()) {
-    // TODO: create circular buffer and converter?
+    std::static_pointer_cast<AndroidRecorderCallback>(dataCallback_)
+        ->prepare(streamSampleRate_, streamChannelCount_, streamMaxBufferSizeInFrames_);
   }
 
   if (isConnected()) {
-    // TODO: set adapter node properties?
+    adapterNode_->init(streamMaxBufferSizeInFrames_, streamChannelCount_);
+  }
+
+  auto result = mStream_->requestStart();
+
+  if (result != oboe::Result::OK) {
+    return Result<std::string, std::string>::Err(
+        "Failed to start stream: " + std::string(oboe::convertToText(result)));
   }
 
-  nativeAudioRecorder_->start();
-  mStream_->requestStart();
-  isRunning_.store(true);
+  jni::ThreadScope::WithClassLoader([this]() { nativeAudioRecorder_->start(); });
+
+  state_.store(RecorderState::Recording, std::memory_order_release);
+  return Result<std::string, std::string>::Ok(std::format("file://{}", filePath_));
 }
 
-std::string AndroidAudioRecorder::stop() {
+/// @brief Stops the audio stream and finalizes any output (file writing, callback, adapter node).
+/// This method should be called from the JS thread only.
+/// @returns On success, returns the file URI, size in MB and duration in seconds of the recorded file (if file output is enabled).
+/// NOTE: due to the file access nature on Android, the size might sometimes be zeroed (really long files).
+Result<std::tuple<std::string, double, double>, std::string> AndroidAudioRecorder::stop() {
+  std::scoped_lock stopLock(callbackMutex_, fileWriterMutex_, adapterNodeMutex_);
+
+  std::string filePath = std::format("file://{}", filePath_);
+  double outputFileSize = 0.0;
+  double outputDuration = 0.0;
+
   if (!isRecording()) {
-    return "";
+    return Result<std::tuple<std::string, double, double>, std::string>::Err(
+        "Recorder is not in recording state.");
   }
 
   if (!mStream_ || !nativeAudioRecorder_) {
-    __android_log_print(
-        ANDROID_LOG_ERROR,
-        "AndroidAudioRecorder",
-        "Audio stream is not initialized.\n");
-    return "";
+    return Result<std::tuple<std::string, double, double>, std::string>::Err(
+        "Audio stream is not initialized.");
   }
 
-  nativeAudioRecorder_->stop();
+  state_.store(RecorderState::Idle, std::memory_order_release);
+  jni::ThreadScope::WithClassLoader([this]() { nativeAudioRecorder_->stop(); });
   mStream_->requestStop();
-  isRunning_.store(false);
-
-  // TODO: sendRemainingData() ?
 
   if (usesFileOutput()) {
-    return fileWriter_->closeFile();
+    auto fileResult = fileWriter_->closeFile();
+
+    if (!fileResult.is_ok()) {
+      return Result<std::tuple<std::string, double, double>, std::string>::Err(
+          "Failed to close file: " + fileResult.unwrap_err());
+    }
+
+    outputFileSize = std::get<0>(fileResult.unwrap());
+    outputDuration = std::get<1>(fileResult.unwrap());
+  }
+
+  if (usesCallback()) {
+    dataCallback_->cleanup();
+  }
+
+  if (isConnected()) {
+    adapterNode_->cleanup();
   }
 
-  return "";
+  filePath_ = "";
+  return Result<std::tuple<std::string, double, double>, std::string>::Ok(
+      {filePath, outputFileSize, outputDuration});
 }
 
-void AndroidAudioRecorder::enableFileOutput(
-    float sampleRate,
-    size_t channelCount,
-    size_t bitRate,
-    size_t iosFlags,
-    size_t androidFlags) {
-  uint8_t format = static_cast<uint8_t>(androidFlags & 0xF);
-
-  if (format == 1) {
-    fileWriter_ = std::make_shared<MiniAudioFileWriter>(
-        sampleRate, channelCount, bitRate, androidFlags);
+/// @brief Enables file output for the recorder with the specified properties.
+/// If the recorder is already active, it will prepare and open the file for writing immediately.
+/// Due to the nature of RN this might be called multiple times during recording session (especially during development),
+/// thus the requirement of handling the "already active" case.
+/// This method should be called from the JS thread only.
+/// @param properties Properties defining the audio file format and encoding options.
+/// @returns On success, returns the file URI where the recording is being saved, otherwise returns an error message.
+Result<std::string, std::string> AndroidAudioRecorder::enableFileOutput(
+    std::shared_ptr<AudioFileProperties> properties) {
+  std::scoped_lock fileWriterLock(fileWriterMutex_);
+
+  if (properties->format == AudioFileProperties::Format::WAV) {
+    fileWriter_ = std::make_shared<MiniAudioFileWriter>(audioEventHandlerRegistry_, properties);
   } else {
-    fileWriter_ = std::make_shared<FFmpegAudioFileWriter>(
-        sampleRate, channelCount, bitRate, androidFlags);
+#if !RN_AUDIO_API_FFMPEG_DISABLED
+    fileWriter_ = std::make_shared<android::ffmpeg::FFmpegAudioFileWriter>(
+        audioEventHandlerRegistry_, properties);
+#else
+    return Result<std::string, std::string>::Err(
+        "FFmpeg backend is disabled. Cannot create file writer for the requested format. Use WAV format instead.");
+#endif
+  }
+
+  if (!isIdle()) {
+    auto fileResult =
+        std::static_pointer_cast<AndroidFileWriterBackend>(fileWriter_)
+            ->openFile(streamSampleRate_, streamChannelCount_, streamMaxBufferSizeInFrames_);
+
+    if (!fileResult.is_ok()) {
+      return Result<std::string, std::string>::Err(
+          "Failed to open file for writing: " + fileResult.unwrap_err());
+    }
+
+    filePath_ = fileResult.unwrap();
   }
 
-  fileOutputEnabled_.store(true);
+  fileOutputEnabled_.store(true, std::memory_order_release);
+  return Result<std::string, std::string>::Ok(filePath_);
 }
 
+/// @brief Disables file output for the recorder.
+/// If the recorder is currently active, it will finalize and close the file immediately.
+/// This method should be called from the JS thread only.
 void AndroidAudioRecorder::disableFileOutput() {
-  fileOutputEnabled_.store(false);
+  std::scoped_lock fileWriterLock(fileWriterMutex_);
+  fileOutputEnabled_.store(false, std::memory_order_release);
   fileWriter_ = nullptr;
 }
 
-void AndroidAudioRecorder::pause() {}
+/// @brief Pauses the audio recording stream.
+/// For session without active file output, this method acts same as stop().
+/// This method should be called from the JS thread only.
+void AndroidAudioRecorder::pause() {
+  if (!isRecording()) {
+    return;
+  }
+
+  mStream_->pause(0);
+  state_.store(RecorderState::Paused, std::memory_order_release);
+}
+
+/// @brief Resumes the audio recording stream if it was previously paused.
+/// This method should be called from the JS thread only.
+void AndroidAudioRecorder::resume() {
+  if (!isPaused()) {
+    return;
+  }
+
+  mStream_->start(0);
+  state_.store(RecorderState::Recording, std::memory_order_release);
+}
+
+/// @brief Sets the callback to be invoked when audio data is ready.
+/// If the recorder is already active, it will prepare the callback for receiving audio data immediately.
+/// This method should be called from the JS thread only.
+/// @param sampleRate Desired sample rate for the callback audio data.
+/// @param bufferLength Desired buffer length in frames for the callback audio data.
+/// @param channelCount Number of channels for the callback audio data.
+/// @param callbackId Identifier for the JS callback to be invoked.
+/// @returns Success status or Error status with message.
+Result<NoneType, std::string> AndroidAudioRecorder::setOnAudioReadyCallback(
+    float sampleRate,
+    size_t bufferLength,
+    int channelCount,
+    uint64_t callbackId) {
+  std::scoped_lock callbackLock(callbackMutex_);
+  dataCallback_ = std::make_shared<AndroidRecorderCallback>(
+      audioEventHandlerRegistry_, sampleRate, bufferLength, channelCount, callbackId);
+
+  if (!isIdle()) {
+    std::static_pointer_cast<AndroidRecorderCallback>(dataCallback_)
+        ->prepare(streamSampleRate_, streamChannelCount_, streamMaxBufferSizeInFrames_);
+  }
+
+  callbackOutputEnabled_.store(true, std::memory_order_release);
 
-void AndroidAudioRecorder::resume() {}
+  return Result<NoneType, std::string>::Ok(None);
+}
+
+/// @brief Clears the audio data callback.
+/// If the recorder is currently active, it will stop invoking the callback immediately.
+/// This method should be called from the JS thread only.
+void AndroidAudioRecorder::clearOnAudioReadyCallback() {
+  std::scoped_lock callbackLock(callbackMutex_);
+  callbackOutputEnabled_.store(false, std::memory_order_release);
+  dataCallback_ = nullptr;
+}
+
+/// @brief Connects a RecorderAdapterNode to the recorder for audio data routing.
+/// If the recorder is already active, it will initialize the adapter node immediately.
+/// This method should be called from the JS thread only.
+/// @param node Shared pointer to the RecorderAdapterNode to connect.
+void AndroidAudioRecorder::connect(const std::shared_ptr<RecorderAdapterNode> &node) {
+  std::scoped_lock adapterLock(adapterNodeMutex_);
+  adapterNode_ = node;
+  deinterleavingBuffer_ = std::make_shared<AudioArray>(streamMaxBufferSizeInFrames_);
+
+  if (!isIdle()) {
+    adapterNode_->init(streamMaxBufferSizeInFrames_, streamChannelCount_);
+  }
+
+  isConnected_.store(true, std::memory_order_release);
+}
+
+/// @brief Disconnects the currently connected RecorderAdapterNode from the recorder.
+/// If the recorder is currently active, it will stop routing audio data immediately.
+/// This method should be called from the JS thread only.
+void AndroidAudioRecorder::disconnect() {
+  std::scoped_lock adapterLock(adapterNodeMutex_);
+  isConnected_.store(false, std::memory_order_release);
+  deinterleavingBuffer_ = nullptr;
+  adapterNode_ = nullptr;
+}
 
-DataCallbackResult AndroidAudioRecorder::onAudioReady(
+/// @brief onAudioReady callback that is invoked by the Oboe stream when new audio data is available.
+/// This method runs on the audio thread.
+/// It routes the audio data to the enabled outputs: file writer, callback, and adapter node.
+/// For safety measures (check note about RN of enableFileOutput), each output is protected by a lock
+/// additionally to the enabled checks.
+/// @param oboeStream Pointer to the Oboe audio stream.
+/// @param audioData Pointer to the audio data buffer (interleaved float samples).
+/// @param numFrames Number of audio frames in the data buffer.
+/// @returns DataCallbackResult indicating whether to continue or stop the stream.
+oboe::DataCallbackResult AndroidAudioRecorder::onAudioReady(
     oboe::AudioStream *oboeStream,
     void *audioData,
     int32_t numFrames) {
+  if (isPaused()) {
+    return oboe::DataCallbackResult::Continue;
+  }
+
   if (usesFileOutput()) {
-    fileWriter_->writeAudioData(audioData, numFrames);
+    if (auto fileWriterLock = Locker::tryLock(fileWriterMutex_)) {
+      std::static_pointer_cast<AndroidFileWriterBackend>(fileWriter_)
+          ->writeAudioData(audioData, numFrames);
+    }
   }
 
-  return DataCallbackResult::Continue;
+  if (usesCallback()) {
+    if (auto callbackLock = Locker::tryLock(callbackMutex_)) {
+      std::static_pointer_cast<AndroidRecorderCallback>(dataCallback_)
+          ->receiveAudioData(audioData, numFrames);
+    }
+  }
+
+  if (isConnected()) {
+    if (auto adapterLock = Locker::tryLock(adapterNodeMutex_)) {
+      for (int channel = 0; channel < streamChannelCount_; ++channel) {
+        for (int frame = 0; frame < numFrames; ++frame) {
+          deinterleavingBuffer_->getData()[frame] =
+              static_cast<float *>(audioData)[frame * streamChannelCount_ + channel];
+        }
+
+        adapterNode_->buff_[channel]->write(deinterleavingBuffer_->getData(), numFrames);
+      }
+    }
+  }
+
+  return oboe::DataCallbackResult::Continue;
 }
 
-} // namespace audioapi
+bool AndroidAudioRecorder::isRecording() const {
+  return state_.load(std::memory_order_acquire) == RecorderState::Recording &&
+      mStream_->getState() == oboe::StreamState::Started;
+}
 
-// if (isRunning_.load()) {
-//   auto *inputChannel = static_cast<float *>(audioData);
-//   writeToBuffers(inputChannel, numFrames);
-// }
+bool AndroidAudioRecorder::isPaused() const {
+  return state_.load(std::memory_order_acquire) == RecorderState::Paused;
+}
 
-// while (circularBuffer_->getNumberOfAvailableFrames() >= bufferLength_) {
-//   auto bus = std::make_shared<AudioBus>(bufferLength_, 1, sampleRate_);
-//   auto *outputChannel = bus->getChannel(0)->getData();
+bool AndroidAudioRecorder::isIdle() const {
+  return state_.load(std::memory_order_acquire) == RecorderState::Idle;
+}
 
-//   circularBuffer_->pop_front(outputChannel, bufferLength_);
+void AndroidAudioRecorder::cleanup() {
+  state_.store(RecorderState::Idle, std::memory_order_release);
 
-//   invokeOnAudioReadyCallback(bus, bufferLength_);
-// }
+  if (mStream_) {
+    mStream_->close();
+    mStream_.reset();
+  }
+}
+
+/// @brief onError callback that is invoked by the Oboe stream when an error occurs.
+/// This method runs on the audio thread.
+/// If the error is a disconnection, it attempts to reopen the stream and resume recording.
+/// @param oboeStream Pointer to the Oboe audio stream.
+/// @param error The oboe::Result error code.
+void AndroidAudioRecorder::onErrorAfterClose(oboe::AudioStream *stream, oboe::Result error) {
+  if (error == oboe::Result::ErrorDisconnected) {
+    cleanup();
+
+    auto streamResult = openAudioStream();
+
+    if (!streamResult.is_ok()) {
+      // TODO: call error callback
+      return;
+    }
+
+    mStream_->requestStart();
+    state_.store(RecorderState::Recording, std::memory_order_release);
+  }
+}
+
+} // namespace audioapi

package/android/src/main/cpp/audioapi/android/core/AndroidAudioRecorder.h

@@ -1,54 +1,67 @@
 #pragma once
 
 #include <audioapi/core/inputs/AudioRecorder.h>
-
 #include <oboe/Oboe.h>
 #include <functional>
 #include <memory>
 #include <string>
-
+#include <tuple>
+#include <mutex>
+#include <audioapi/utils/Result.hpp>
 #include <audioapi/android/core/NativeAudioRecorder.hpp>
 
 namespace audioapi {
 
-using namespace oboe;
-
 class AudioBus;
+class AudioArray;
 class CircularAudioArray;
+class AudioFileProperties;
+class AndroidRecorderCallback;
 class AndroidFileWriterBackend;
 class AudioEventHandlerRegistry;
 
-class AndroidAudioRecorder : public AudioStreamDataCallback, public AudioRecorder {
+class AndroidAudioRecorder : public oboe::AudioStreamCallback, public AudioRecorder {
  public:
   explicit AndroidAudioRecorder(const std::shared_ptr<AudioEventHandlerRegistry> &audioEventHandlerRegistry);
   ~AndroidAudioRecorder() override;
+  void cleanup();
 
-  void start() override;
-  std::string stop() override;
+  Result<std::string, std::string> start() override;
+  Result<std::tuple<std::string, double, double>, std::string> stop() override;
 
-  void enableFileOutput(
-      float sampleRate,
-      size_t channelCount,
-      size_t bitRate,
-      size_t iosFlags,
-      size_t androidFlags) override;
+  Result<std::string, std::string> enableFileOutput(std::shared_ptr<AudioFileProperties> properties) override;
   void disableFileOutput() override;
 
   void pause() override;
   void resume() override;
+  bool isRecording() const override;
+  bool isPaused() const override;
+  bool isIdle() const override;
+
+  Result<NoneType, std::string> setOnAudioReadyCallback(float sampleRate, size_t bufferLength, int channelCount, uint64_t callbackId)
+      override;
+  void clearOnAudioReadyCallback() override;
+
+  void connect(const std::shared_ptr<RecorderAdapterNode> &node) override;
+  void disconnect() override;
 
-  DataCallbackResult onAudioReady(
-          AudioStream *oboeStream,
+  oboe::DataCallbackResult onAudioReady(
+          oboe::AudioStream *oboeStream,
           void *audioData,
           int32_t numFrames) override;
+  void onErrorAfterClose(oboe::AudioStream *oboeStream, oboe::Result error) override;
 
  private:
-  std::shared_ptr<AndroidFileWriterBackend> fileWriter_;
-  std::shared_ptr<AudioStream> mStream_;
-  facebook::jni::global_ref<NativeAudioRecorder> nativeAudioRecorder_;
-  int32_t streamSampleRate_;
+  std::shared_ptr<AudioArray> deinterleavingBuffer_;
+
+  float streamSampleRate_;
   int32_t streamChannelCount_;
   int32_t streamMaxBufferSizeInFrames_;
+
+  facebook::jni::global_ref<NativeAudioRecorder> nativeAudioRecorder_;
+
+  std::shared_ptr<oboe::AudioStream> mStream_;
+  Result<NoneType, std::string> openAudioStream();
 };
 
 } // namespace audioapi

package/android/src/main/cpp/audioapi/android/core/AudioPlayer.cpp

@@ -4,6 +4,10 @@
 #include <audioapi/core/utils/Constants.h>
 #include <audioapi/utils/AudioArray.h>
 #include <audioapi/utils/AudioBus.h>
+#include <jni.h>
+
+#include <algorithm>
+#include <memory>
 
 namespace audioapi {
 
@@ -11,9 +15,7 @@ AudioPlayer::AudioPlayer(
     const std::function<void(std::shared_ptr<AudioBus>, int)> &renderAudio,
     float sampleRate,
     int channelCount)
-    : renderAudio_(renderAudio),
-      sampleRate_(sampleRate),
-      channelCount_(channelCount) {
+    : renderAudio_(renderAudio), sampleRate_(sampleRate), channelCount_(channelCount) {
   isInitialized_ = openAudioStream();
 
   nativeAudioPlayer_ = jni::make_global(NativeAudioPlayer::create());
@@ -35,21 +37,17 @@ bool AudioPlayer::openAudioStream() {
   auto result = builder.openStream(mStream_);
   if (result != oboe::Result::OK || mStream_ == nullptr) {
     __android_log_print(
-        ANDROID_LOG_ERROR,
-        "AudioPlayer",
-        "Failed to open stream: %s",
-        oboe::convertToText(result));
+        ANDROID_LOG_ERROR, "AudioPlayer", "Failed to open stream: %s", oboe::convertToText(result));
     return false;
   }
 
-  mBus_ = std::make_shared<AudioBus>(
-      RENDER_QUANTUM_SIZE, channelCount_, sampleRate_);
+  mBus_ = std::make_shared<AudioBus>(RENDER_QUANTUM_SIZE, channelCount_, sampleRate_);
   return true;
 }
 
 bool AudioPlayer::start() {
   if (mStream_) {
-    nativeAudioPlayer_->start();
+    jni::ThreadScope::WithClassLoader([this]() { nativeAudioPlayer_->start(); });
     auto result = mStream_->requestStart();
     return result == oboe::Result::OK;
   }
@@ -59,7 +57,7 @@ bool AudioPlayer::start() {
 
 void AudioPlayer::stop() {
   if (mStream_) {
-    nativeAudioPlayer_->stop();
+    jni::ThreadScope::WithClassLoader([this]() { nativeAudioPlayer_->stop(); });
     mStream_->requestStop();
   }
 }
@@ -92,10 +90,8 @@ bool AudioPlayer::isRunning() const {
   return mStream_ && mStream_->getState() == oboe::StreamState::Started;
 }
 
-DataCallbackResult AudioPlayer::onAudioReady(
-    AudioStream *oboeStream,
-    void *audioData,
-    int32_t numFrames) {
+DataCallbackResult
+AudioPlayer::onAudioReady(AudioStream *oboeStream, void *audioData, int32_t numFrames) {
   if (!isInitialized_) {
     return DataCallbackResult::Continue;
   }
@@ -106,8 +102,7 @@ DataCallbackResult AudioPlayer::onAudioReady(
   assert(buffer != nullptr);
 
   while (processedFrames < numFrames) {
-    int framesToProcess =
-        std::min(numFrames - processedFrames, RENDER_QUANTUM_SIZE);
+    int framesToProcess = std::min(numFrames - processedFrames, RENDER_QUANTUM_SIZE);
     renderAudio_(mBus_, framesToProcess);
 
     // TODO: optimize this with SIMD?
@@ -124,9 +119,7 @@ DataCallbackResult AudioPlayer::onAudioReady(
   return DataCallbackResult::Continue;
 }
 
-void AudioPlayer::onErrorAfterClose(
-    oboe::AudioStream *stream,
-    oboe::Result error) {
+void AudioPlayer::onErrorAfterClose(oboe::AudioStream *stream, oboe::Result error) {
   if (error == oboe::Result::ErrorDisconnected) {
     cleanup();
     if (openAudioStream()) {