react-native-audio-api 0.11.0-alpha.2 → 0.11.0-alpha.4

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

@@ -2,7 +2,11 @@
 #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>
@@ -29,6 +33,25 @@ AndroidAudioRecorder::AndroidAudioRecorder(
 }
 
 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_) {
@@ -86,7 +109,7 @@ Result<std::string, std::string> AndroidAudioRecorder::start() {
 
   if (usesFileOutput()) {
     auto fileResult =
-        std::dynamic_pointer_cast<AndroidFileWriterBackend>(fileWriter_)
+        std::static_pointer_cast<AndroidFileWriterBackend>(fileWriter_)
             ->openFile(streamSampleRate_, streamChannelCount_, streamMaxBufferSizeInFrames_);
 
     if (!fileResult.is_ok()) {
@@ -98,7 +121,7 @@ Result<std::string, std::string> AndroidAudioRecorder::start() {
   }
 
   if (usesCallback()) {
-    std::dynamic_pointer_cast<AndroidRecorderCallback>(dataCallback_)
+    std::static_pointer_cast<AndroidRecorderCallback>(dataCallback_)
         ->prepare(streamSampleRate_, streamChannelCount_, streamMaxBufferSizeInFrames_);
   }
 
@@ -172,13 +195,18 @@ Result<std::string, std::string> AndroidAudioRecorder::enableFileOutput(
   if (properties->format == AudioFileProperties::Format::WAV) {
     fileWriter_ = std::make_shared<MiniAudioFileWriter>(audioEventHandlerRegistry_, properties);
   } else {
+#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::dynamic_pointer_cast<AndroidFileWriterBackend>(fileWriter_)
+        std::static_pointer_cast<AndroidFileWriterBackend>(fileWriter_)
             ->openFile(streamSampleRate_, streamChannelCount_, streamMaxBufferSizeInFrames_);
 
     if (!fileResult.is_ok()) {
@@ -227,7 +255,7 @@ Result<NoneType, std::string> AndroidAudioRecorder::setOnAudioReadyCallback(
       audioEventHandlerRegistry_, sampleRate, bufferLength, channelCount, callbackId);
 
   if (!isIdle()) {
-    std::dynamic_pointer_cast<AndroidRecorderCallback>(dataCallback_)
+    std::static_pointer_cast<AndroidRecorderCallback>(dataCallback_)
         ->prepare(streamSampleRate_, streamChannelCount_, streamMaxBufferSizeInFrames_);
   }
 
@@ -271,14 +299,14 @@ oboe::DataCallbackResult AndroidAudioRecorder::onAudioReady(
 
   if (usesFileOutput()) {
     if (auto fileWriterLock = Locker::tryLock(fileWriterMutex_)) {
-      std::dynamic_pointer_cast<AndroidFileWriterBackend>(fileWriter_)
+      std::static_pointer_cast<AndroidFileWriterBackend>(fileWriter_)
           ->writeAudioData(audioData, numFrames);
     }
   }
 
   if (usesCallback()) {
     if (auto callbackLock = Locker::tryLock(callbackMutex_)) {
-      std::dynamic_pointer_cast<AndroidRecorderCallback>(dataCallback_)
+      std::static_pointer_cast<AndroidRecorderCallback>(dataCallback_)
           ->receiveAudioData(audioData, numFrames);
     }
   }

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

@@ -52,7 +52,6 @@ class AndroidAudioRecorder : public oboe::AudioStreamCallback, public AudioRecor
   void onErrorAfterClose(oboe::AudioStream *oboeStream, oboe::Result error) override;
 
  private:
-  std::string filePath_{""};
   std::shared_ptr<AudioArray> deinterleavingBuffer_;
 
   float streamSampleRate_;

package/android/src/main/cpp/audioapi/android/core/utils/ffmpegBackend/FFmpegFileWriter.cpp

@@ -1,3 +1,5 @@
+#if !RN_AUDIO_API_FFMPEG_DISABLED
+
 extern "C" {
 #include <libavcodec/avcodec.h>
 #include <libavformat/avformat.h>
@@ -508,3 +510,5 @@ CloseFileResult FFmpegAudioFileWriter::finalizeOutput() {
 }
 
 } // namespace audioapi::android::ffmpeg
+
+#endif // RN_AUDIO_API_FFMPEG_DISABLED

package/android/src/main/cpp/audioapi/android/core/utils/ffmpegBackend/ptrs.hpp

@@ -1,3 +1,7 @@
+#if !RN_AUDIO_API_FFMPEG_DISABLED
+
+#pragma once
+
 extern "C" {
 #include <libavcodec/avcodec.h>
 #include <libavformat/avformat.h>
@@ -46,3 +50,7 @@ template<> inline void AvDtor<AVAudioFifo>::operator()(AVAudioFifo* fifo) const
 }
 
 } // namespace audioapi::android::ffmpeg
+
+#else
+
+#endif // RN_AUDIO_API_FFMPEG_DISABLED

package/android/src/main/cpp/audioapi/android/core/utils/ffmpegBackend/utils.cpp

@@ -1,3 +1,5 @@
+#if !RN_AUDIO_API_FFMPEG_DISABLED
+
 extern "C" {
 #include <libavcodec/avcodec.h>
 }
@@ -108,3 +110,5 @@ std::string parseErrorCode(int errorCode) {
 }
 
 } // namespace audioapi::android::ffmpeg
+
+#endif // RN_AUDIO_API_FFMPEG_DISABLED

package/android/src/main/cpp/audioapi/android/core/utils/miniaudioBackend/MiniAudioFileWriter.h

@@ -3,6 +3,7 @@
 #include <audioapi/android/core/utils/AndroidFileWriterBackend.h>
 #include <audioapi/libs/miniaudio/miniaudio.h>
 
+#include <atomic>
 #include <string>
 #include <memory>
 #include <tuple>

package/common/cpp/audioapi/core/inputs/AudioRecorder.h

@@ -72,6 +72,7 @@ class AudioRecorder {
 
   std::atomic<uint64_t> errorCallbackId_{0};
 
+  std::string filePath_{""};
   std::shared_ptr<AudioFileWriter> fileWriter_ = nullptr;
   std::shared_ptr<RecorderAdapterNode> adapterNode_ = nullptr;
   std::shared_ptr<AudioRecorderCallback> dataCallback_ = nullptr;

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

@@ -1,6 +1,7 @@
 #pragma once
 
 #include <audioapi/utils/Result.hpp>
+#include <atomic>
 #include <memory>
 #include <string>
 #include <tuple>

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

@@ -1,6 +1,7 @@
 #pragma once
 
 #include <audioapi/utils/Result.hpp>
+#include <atomic>
 #include <memory>
 #include <string>
 #include <vector>

package/ios/audioapi/ios/core/IOSAudioRecorder.mm

@@ -31,14 +31,14 @@ IOSAudioRecorder::IOSAudioRecorder(
   AudioReceiverBlock receiverBlock = ^(const AudioBufferList *inputBuffer, int numFrames) {
     if (usesFileOutput()) {
       if (auto lock = Locker::tryLock(fileWriterMutex_)) {
-        std::dynamic_pointer_cast<IOSFileWriter>(fileWriter_)
+        std::static_pointer_cast<IOSFileWriter>(fileWriter_)
             ->writeAudioData(inputBuffer, numFrames);
       }
     }
 
     if (usesCallback()) {
       if (auto lock = Locker::tryLock(callbackMutex_)) {
-        std::dynamic_pointer_cast<IOSRecorderCallback>(dataCallback_)
+        std::static_pointer_cast<IOSRecorderCallback>(dataCallback_)
             ->receiveAudioData(inputBuffer, numFrames);
       }
     }
@@ -76,7 +76,7 @@ Result<std::string, std::string> IOSAudioRecorder::start()
     return Result<std::string, std::string>::Err("Microphone permissions are not granted");
   }
 
-  // TODO: recorder should probably request activating the session and setting the options if not set by user
+  // TODO: recorder should probably request the options if not set by user
   // but lets handle that in another PR
   if (![audioSessionManager isSessionActive]) {
     return Result<std::string, std::string>::Err("Audio session is not active");
@@ -90,11 +90,12 @@ Result<std::string, std::string> IOSAudioRecorder::start()
   // Engine will be started again once the native recorder starts
   [AudioEngine.sharedInstance stopIfNecessary];
 
+  // Estimate the maximum input buffer lengths that can be expected from the sink node
   size_t maxInputBufferLength = [nativeRecorder_ getBufferSize];
   auto inputFormat = [nativeRecorder_ getInputFormat];
 
   if (usesFileOutput()) {
-    auto fileResult = std::dynamic_pointer_cast<IOSFileWriter>(fileWriter_)
+    auto fileResult = std::static_pointer_cast<IOSFileWriter>(fileWriter_)
                           ->openFile(inputFormat, maxInputBufferLength);
 
     if (fileResult.is_err()) {
@@ -106,7 +107,7 @@ Result<std::string, std::string> IOSAudioRecorder::start()
   }
 
   if (usesCallback()) {
-    auto callbackResult = std::dynamic_pointer_cast<IOSRecorderCallback>(dataCallback_)
+    auto callbackResult = std::static_pointer_cast<IOSRecorderCallback>(dataCallback_)
                               ->prepare(inputFormat, maxInputBufferLength);
 
     if (callbackResult.is_err()) {
@@ -172,7 +173,7 @@ Result<std::string, std::string> IOSAudioRecorder::enableFileOutput(
   fileWriter_ = std::make_shared<IOSFileWriter>(audioEventHandlerRegistry_, properties);
 
   if (!isIdle()) {
-    auto result = std::dynamic_pointer_cast<IOSFileWriter>(fileWriter_)
+    auto result = std::static_pointer_cast<IOSFileWriter>(fileWriter_)
                       ->openFile([nativeRecorder_ getInputFormat], [nativeRecorder_ getBufferSize]);
 
     if (result.is_err()) {
@@ -273,7 +274,7 @@ Result<NoneType, std::string> IOSAudioRecorder::setOnAudioReadyCallback(
       audioEventHandlerRegistry_, sampleRate, bufferLength, channelCount, callbackId);
 
   if (!isIdle()) {
-    auto result = std::dynamic_pointer_cast<IOSRecorderCallback>(dataCallback_)
+    auto result = std::static_pointer_cast<IOSRecorderCallback>(dataCallback_)
                       ->prepare([nativeRecorder_ getInputFormat], [nativeRecorder_ getBufferSize]);
 
     if (result.is_err()) {

package/ios/audioapi/ios/core/NativeAudioPlayer.m

@@ -61,7 +61,7 @@
   assert(audioEngine != nil);
 
   [audioEngine detachSourceNodeWithId:self.sourceNodeId];
-  [audioEngine stopIfNecessary];
+  [audioEngine stopIfPossible];
   self.sourceNodeId = nil;
 }
 

package/ios/audioapi/ios/core/NativeAudioRecorder.m

@@ -95,7 +95,7 @@ static inline uint32_t nextPowerOfTwo(uint32_t x)
 {
   AudioEngine *audioEngine = [AudioEngine sharedInstance];
   assert(audioEngine != nil);
-  [audioEngine stopIfNecessary];
+  [audioEngine stopIfPossible];
   [audioEngine detachInputNode];
   [audioEngine restartAudioEngine];
 }

package/ios/audioapi/ios/system/AudioEngine.h

@@ -41,6 +41,8 @@ typedef NS_ENUM(NSInteger, AudioEngineState) {
 - (void)pauseIfNecessary;
 - (void)stopIfNecessary;
 
+- (void)stopIfPossible;
+
 - (void)restartAudioEngine;
 
 - (void)logAudioEngineState;

package/ios/audioapi/ios/system/AudioEngine.mm

@@ -57,8 +57,6 @@ static AudioEngine *_sharedInstance = nil;
 
 - (void)detachSourceNodeWithId:(NSString *)sourceNodeId
 {
-  NSLog(@"[AudioEngine] detaching source node with ID: %@", sourceNodeId);
-
   AVAudioSourceNode *sourceNode = [self.sourceNodes valueForKey:sourceNodeId];
 
   if (sourceNode == nil) {
@@ -75,7 +73,6 @@ static AudioEngine *_sharedInstance = nil;
 - (void)attachInputNode:(AVAudioSinkNode *)inputNode
 {
   self.inputNode = inputNode;
-
   AVAudioFormat *format = [self.audioEngine.inputNode inputFormatForBus:0];
 
   [self.audioEngine attachNode:inputNode];
@@ -105,11 +102,39 @@ static AudioEngine *_sharedInstance = nil;
 
 - (void)onInterruptionEnd:(bool)shouldResume
 {
+  NSError *error = nil;
+
   if (self.state != AudioEngineState::AudioEngineStateInterrupted) {
+    // If engine was not interrupted, do nothing
+    // Not a real condition, but better be safe than sorry :shrug:
+    return;
+  }
+
+  // Stop just in case, reset the engine and build it from scratch
+  [self stopIfNecessary];
+  [self.audioEngine reset];
+  [self rebuildAudioEngine];
+
+  // If shouldResume is false, mark the engine as paused and wait
+  // for JS-side resume command
+  // TODO: this should be notified to the user f.e. via Event Emitter
+  if (!shouldResume) {
+    self.state = AudioEngineState::AudioEngineStatePaused;
+    return;
+  }
+
+  [self.audioEngine prepare];
+  [self.audioEngine startAndReturnError:&error];
+
+  if (error != nil) {
+    NSLog(
+        @"Error while restarting the audio engine after interruption: %@",
+        [error debugDescription]);
+    self.state = AudioEngineState::AudioEngineStateIdle;
     return;
   }
 
-  // TODO: try to recover
+  self.state = AudioEngineState::AudioEngineStateRunning;
 }
 
 - (AudioEngineState)getState
@@ -117,6 +142,7 @@ static AudioEngine *_sharedInstance = nil;
   return self.state;
 }
 
+/// @brief Rebuilds the audio engine by re-attaching and re-connecting all source nodes and input node.
 - (void)rebuildAudioEngine
 {
   self.audioEngine = [[AVAudioEngine alloc] init];
@@ -135,6 +161,7 @@ static AudioEngine *_sharedInstance = nil;
   }
 }
 
+// @brief Starts the audio engine if not already running.
 - (bool)startEngine
 {
   NSError *error = nil;
@@ -208,6 +235,22 @@ static AudioEngine *_sharedInstance = nil;
   [self stopEngine];
 }
 
+- (void)stopIfPossible
+{
+  if (self.state == AudioEngineState::AudioEngineStateIdle) {
+    return;
+  }
+
+  bool hasInput = self.inputNode != nil;
+  bool hasSources = [self.sourceNodes count] > 0;
+
+  if (hasInput || hasSources) {
+    return;
+  }
+
+  [self stopEngine];
+}
+
 - (void)restartAudioEngine
 {
   if ([self.audioEngine isRunning]) {

package/ios/audioapi/ios/system/NotificationManager.mm

@@ -129,11 +129,12 @@ static NSString *NotificationManagerContext = @"NotificationManagerContext";
   }
 
   bool shouldResume = interruptionOption == AVAudioSessionInterruptionOptionShouldResume;
-  [audioEngine onInterruptionEnd:shouldResume];
 
   if (self.audioInterruptionsObserved) {
     NSDictionary *body = @{@"type" : @"ended", @"shouldResume" : @(shouldResume)};
     [self.audioAPIModule invokeHandlerWithEventName:@"interruption" eventBody:body];
+  } else {
+    [audioEngine onInterruptionEnd:shouldResume];
   }
 }
 
@@ -156,11 +157,12 @@ static NSString *NotificationManagerContext = @"NotificationManagerContext";
   }
 
   bool shouldResume = secondaryAudioType == AVAudioSessionSilenceSecondaryAudioHintTypeEnd;
-  [audioEngine onInterruptionEnd:shouldResume];
 
   if (self.audioInterruptionsObserved) {
     NSDictionary *body = @{@"type" : @"ended", @"shouldResume" : @(shouldResume)};
     [self.audioAPIModule invokeHandlerWithEventName:@"interruption" eventBody:body];
+  } else {
+    [audioEngine onInterruptionEnd:shouldResume];
   }
 }
 
@@ -273,11 +275,12 @@ static NSString *NotificationManagerContext = @"NotificationManagerContext";
     return;
   }
 
-  [audioEngine onInterruptionEnd:true];
   NSDictionary *body = @{@"type" : @"ended", @"shouldResume" : @true};
 
   if (self.audioInterruptionsObserved) {
     [self.audioAPIModule invokeHandlerWithEventName:@"interruption" eventBody:body];
+  } else {
+    [audioEngine onInterruptionEnd:true];
   }
 }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "react-native-audio-api",
-  "version": "0.11.0-alpha.2",
+  "version": "0.11.0-alpha.4",
   "description": "react-native-audio-api provides system for controlling audio in React Native environment compatible with Web Audio API specification",
   "bin": {
     "setup-rn-audio-api-web": "./scripts/setup-rn-audio-api-web.js"