feat: rotating file writer (#913)

Author: poneciak57

apps/common-app/src/demos/Record/Record.tsx

@@ -241,7 +241,7 @@ const Record: FC = () => {
   }, [onPauseRecording, onResumeRecording]);
 
   useEffect(() => {
-    Recorder.enableFileOutput();
+    Recorder.enableFileOutput({ rotateIntervalBytes: 1024 * 1024 });
 
     return () => {
       Recorder.disableFileOutput();

packages/audiodocs/docs/inputs/audio-recorder.mdx

@@ -145,7 +145,7 @@ const MyRecorder: React.FC = () => {
       return;
     }
 
-    console.log('Recording started to file:', result.path);
+    console.log('Recording started');
     setIsRecording(true);
   };
 
@@ -387,11 +387,7 @@ export default MyRecorder;
           fileNameOverride: `my_audio_${mySessionId}`
         });
 
-        if (result.status === 'success') {
-          const openedFilePath = result.path;
-        } else if (result.status === 'error') {
-          console.error(result.message);
-        }
+        console.log(result.status);
         ```
       </td>
     </tr>
@@ -412,7 +408,7 @@ export default MyRecorder;
         const result = audioRecorder.stop();
 
         if (result.status === 'success') {
-          const { path, duration, size } = result;
+          const { paths, duration, size } = result;
         } else if (result.status === 'error') {
           console.error(result.message);
         }
@@ -722,6 +718,7 @@ interface OnAudioReadyEventType {
 ```tsx
 interface AudioRecorderFileOptions {
   channelCount?: number;
+  rotateIntervalBytes?: number;
 
   format?: FileFormat;
   preset?: FilePresetType;
@@ -734,6 +731,7 @@ interface AudioRecorderFileOptions {
 ```
 
 - `channelCount` - The desired channel count in the resulting file. not all file formats supports all possible channel counts.
+- `rotateIntervalBytes` - The threshold size (in bytes) at which the recorder will start writing to a new file. If set to 0 (default), file output rotation is disabled. When active, new files are named with the original prefix appended with a timestamp.
 - `format` - The desired extension and file format of the recorder file. Check: [FileFormat](#fileformat) below.
 - `preset` - The desired recorder file properties, you can use either one of built-in properties or tweak low-level parameters yourself. Check [FilePresetType](#filepresettype) for more details.
 - `directory` - Either `FileDirectory.Cache` or `FileDirectory.Document` (default: `FileDirectory.Cache`). Determines the system directory that the file will be saved to.
@@ -760,13 +758,13 @@ enum FileFormat {
 
 ```tsx
 interface FileInfo {
-  path: string;
+  paths: string[];
   size: number;
   duration: number;
 }
 ```
 
-- `path` - The path to the recorded audio file.
+- `paths` - Paths to the recorded audio files. When file rotation is disabled it has only one entry, otherwise list of paths to recorder files is returned.
 - `size` - The file size (in MB).
 - `duration` - The recording duration (in seconds).
 

packages/react-native-audio-api/android/src/main/cpp/audioapi/android/core/AndroidAudioRecorder.cpp

@@ -1,3 +1,4 @@
+#include <android/log.h>
 #include <audioapi/android/core/AndroidAudioRecorder.h>
 #include <audioapi/android/core/utils/AndroidFileWriterBackend.h>
 #include <audioapi/android/core/utils/AndroidRecorderCallback.h>
@@ -6,6 +7,7 @@
 #include <audioapi/android/core/utils/ffmpegBackend/FFmpegFileWriter.h>
 #endif // RN_AUDIO_API_FFMPEG_DISABLED
 
+#include <audioapi/android/core/utils/AndroidRotatingFileWriter.h>
 #include <audioapi/android/core/utils/miniaudioBackend/MiniAudioFileWriter.h>
 #include <audioapi/core/sources/RecorderAdapterNode.h>
 #include <audioapi/core/utils/Constants.h>
@@ -19,6 +21,7 @@
 #include <string>
 #include <unordered_map>
 #include <utility>
+#include <vector>
 
 namespace audioapi {
 
@@ -102,37 +105,34 @@ Result<NoneType, std::string> AndroidAudioRecorder::openAudioStream() {
 /// 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(const std::string &fileNameOverride) {
+Result<NoneType, std::string> AndroidAudioRecorder::start(const std::string &fileNameOverride) {
   std::scoped_lock startLock(callbackMutex_, fileWriterMutex_, adapterNodeMutex_);
 
   if (!isIdle()) {
-    return Result<std::string, std::string>::Err("Recorder is already recording");
+    return Result<NoneType, std::string>::Err("Recorder is already recording");
   }
 
   auto streamResult = openAudioStream();
 
   if (!streamResult.is_ok()) {
-    return Result<std::string, std::string>::Err(streamResult.unwrap_err());
+    return Result<NoneType, std::string>::Err(streamResult.unwrap_err());
   }
 
   if (mStream_ == nullptr) {
-    return Result<std::string, std::string>::Err("Audio stream is not initialized.");
+    return Result<NoneType, std::string>::Err("Audio stream is not initialized.");
   }
 
   if (usesFileOutput()) {
-    auto fileResult = std::static_pointer_cast<AndroidFileWriterBackend>(fileWriter_)
-                          ->openFile(
-                              streamSampleRate_,
-                              streamChannelCount_,
-                              streamMaxBufferSizeInFrames_,
-                              fileNameOverride);
-
-    if (!fileResult.is_ok()) {
-      return Result<std::string, std::string>::Err(
-          "Failed to open file for writing: " + fileResult.unwrap_err());
+    recordingSegmentPaths_.clear();
+    auto writerResult = setupFileWriter(fileProperties_, fileNameOverride);
+    if (!writerResult.is_ok()) {
+      return writerResult;
     }
-
-    filePath_ = fileResult.unwrap();
+    __android_log_print(
+        ANDROID_LOG_INFO,
+        "AndroidAudioRecorder",
+        "File created successfully at path: %s",
+        filePath_.c_str());
   }
 
   if (usesCallback()) {
@@ -149,32 +149,32 @@ Result<std::string, std::string> AndroidAudioRecorder::start(const std::string &
   auto result = mStream_->requestStart();
 
   if (result != oboe::Result::OK) {
-    return Result<std::string, std::string>::Err(
+    return Result<NoneType, std::string>::Err(
         "Failed to start stream: " + std::string(oboe::convertToText(result)));
   }
 
   state_.store(RecorderState::Recording, std::memory_order_release);
-  return Result<std::string, std::string>::Ok(std::format("file://{}", filePath_));
+  return Result<NoneType, std::string>::Ok(None);
 }
 
 /// @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() {
+Result<std::tuple<std::vector<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 (isIdle()) {
-    return Result<std::tuple<std::string, double, double>, std::string>::Err(
+    return Result<std::tuple<std::vector<std::string>, double, double>, std::string>::Err(
         "Recorder is not in recording state.");
   }
 
   if (mStream_ == nullptr) {
-    return Result<std::tuple<std::string, double, double>, std::string>::Err(
+    return Result<std::tuple<std::vector<std::string>, double, double>, std::string>::Err(
         "Audio stream is not initialized.");
   }
 
@@ -185,7 +185,7 @@ Result<std::tuple<std::string, double, double>, std::string> AndroidAudioRecorde
     auto fileResult = fileWriter_->closeFile();
 
     if (!fileResult.is_ok()) {
-      return Result<std::tuple<std::string, double, double>, std::string>::Err(
+      return Result<std::tuple<std::vector<std::string>, double, double>, std::string>::Err(
           "Failed to close file: " + fileResult.unwrap_err());
     }
 
@@ -201,9 +201,20 @@ Result<std::tuple<std::string, double, double>, std::string> AndroidAudioRecorde
     adapterNode_->adapterCleanup();
   }
 
+  std::vector<std::string> outputPaths;
+  for (const auto &raw : recordingSegmentPaths_) {
+    if (!raw.empty()) {
+      outputPaths.push_back(std::format("file://{}", raw));
+    }
+  }
+  if (usesFileOutput() && outputPaths.empty() && !filePath_.empty()) {
+    outputPaths.push_back(std::format("file://{}", filePath_));
+  }
+
+  recordingSegmentPaths_.clear();
   filePath_ = "";
-  return Result<std::tuple<std::string, double, double>, std::string>::Ok(
-      {filePath, outputFileSize, outputDuration});
+  return Result<std::tuple<std::vector<std::string>, double, double>, std::string>::Ok(
+      std::make_tuple(std::move(outputPaths), outputFileSize, outputDuration));
 }
 
 /// @brief Enables file output for the recorder with the specified properties.
@@ -213,37 +224,85 @@ Result<std::tuple<std::string, double, double>, std::string> AndroidAudioRecorde
 /// 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(
+Result<NoneType, std::string> AndroidAudioRecorder::enableFileOutput(
     std::shared_ptr<AudioFileProperties> properties) {
   std::scoped_lock fileWriterLock(fileWriterMutex_);
+  fileProperties_ = properties;
 
-  if (properties->format == AudioFileProperties::Format::WAV) {
-    fileWriter_ = std::make_shared<MiniAudioFileWriter>(audioEventHandlerRegistry_, properties);
-  } else {
+  if (!isIdle()) {
+    auto writerResult = setupFileWriter(properties);
+    if (!writerResult.is_ok()) {
+      return writerResult;
+    }
+  }
+
+  fileOutputEnabled_.store(true, std::memory_order_release);
+  return Result<NoneType, std::string>::Ok(None);
+}
+
+std::shared_ptr<AudioFileWriter> AndroidAudioRecorder::createFileWriter(
+    const std::shared_ptr<AudioFileProperties> &props) {
+  if (props->format == AudioFileProperties::Format::WAV) {
+    return std::make_shared<MiniAudioFileWriter>(
+        audioEventHandlerRegistry_,
+        props,
+        streamSampleRate_,
+        streamChannelCount_,
+        streamMaxBufferSizeInFrames_);
+  }
 #if !RN_AUDIO_API_FFMPEG_DISABLED
-    fileWriter_ = std::make_shared<android::ffmpeg::FFmpegAudioFileWriter>(
-        audioEventHandlerRegistry_, properties);
+  return std::make_shared<android::ffmpeg::FFmpegAudioFileWriter>(
+      audioEventHandlerRegistry_,
+      props,
+      streamSampleRate_,
+      streamChannelCount_,
+      streamMaxBufferSizeInFrames_);
 #else
+  return nullptr;
+#endif
+}
+
+Result<NoneType, std::string> AndroidAudioRecorder::setupFileWriter(
+    const std::shared_ptr<AudioFileProperties> &properties,
+    const std::string &fileNameOverride) {
+#if RN_AUDIO_API_FFMPEG_DISABLED
+  if (properties->format != AudioFileProperties::Format::WAV) {
     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 (properties->rotateIntervalBytes > 0) {
+    fileWriter_ = std::make_shared<AndroidRotatingFileWriter>(
+        audioEventHandlerRegistry_,
+        properties,
+        properties->rotateIntervalBytes,
+        [this](const std::shared_ptr<AudioFileProperties> &p) { return createFileWriter(p); },
+        [this](const std::string &path) {
+          if (!path.empty()) {
+            recordingSegmentPaths_.push_back(path);
+          }
+        });
+  } else {
+    fileWriter_ = createFileWriter(properties);
   }
 
-  if (!isIdle()) {
-    auto fileResult =
-        std::static_pointer_cast<AndroidFileWriterBackend>(fileWriter_)
-            ->openFile(streamSampleRate_, streamChannelCount_, streamMaxBufferSizeInFrames_, "");
+  fileWriter_->setOnErrorCallback(errorCallbackId_.load(std::memory_order_acquire));
 
-    if (!fileResult.is_ok()) {
-      return Result<std::string, std::string>::Err(
-          "Failed to open file for writing: " + fileResult.unwrap_err());
-    }
+  auto backend = std::static_pointer_cast<AndroidFileWriterBackend>(fileWriter_);
+  auto fileResult = backend->openFile(
+      streamSampleRate_, streamChannelCount_, streamMaxBufferSizeInFrames_, fileNameOverride);
 
-    filePath_ = fileResult.unwrap();
+  if (!fileResult.is_ok()) {
+    return Result<NoneType, std::string>::Err(
+        "Failed to open file for writing: " + fileResult.unwrap_err());
   }
 
-  fileOutputEnabled_.store(true, std::memory_order_release);
-  return Result<std::string, std::string>::Ok(filePath_);
+  filePath_ = fileResult.unwrap();
+  if (properties->rotateIntervalBytes == 0) {
+    recordingSegmentPaths_.push_back(filePath_);
+  }
+  return Result<NoneType, std::string>::Ok(None);
 }
 
 /// @brief Disables file output for the recorder.
@@ -360,8 +419,7 @@ oboe::DataCallbackResult AndroidAudioRecorder::onAudioReady(
 
   if (usesFileOutput()) {
     if (auto fileWriterLock = Locker::tryLock(fileWriterMutex_)) {
-      std::static_pointer_cast<AndroidFileWriterBackend>(fileWriter_)
-          ->writeAudioData(audioData, numFrames);
+      fileWriter_->writeAudioData(audioData, numFrames);
     }
   }
 

packages/react-native-audio-api/android/src/main/cpp/audioapi/android/core/AndroidAudioRecorder.h

@@ -8,6 +8,7 @@
 #include <oboe/Oboe.h>
 #include <memory>
 #include <string>
+#include <vector>
 
 namespace audioapi {
 
@@ -23,10 +24,10 @@ class AndroidAudioRecorder : public oboe::AudioStreamCallback, public AudioRecor
   ~AndroidAudioRecorder() override;
   void cleanup();
 
-  Result<std::string, std::string> start(const std::string &fileNameOverride) override;
-  Result<std::tuple<std::string, double, double>, std::string> stop() override;
+  Result<NoneType, std::string> start(const std::string &fileNameOverride) override;
+  Result<std::tuple<std::vector<std::string>, double, double>, std::string> stop() override;
 
-  Result<std::string, std::string> enableFileOutput(
+  Result<NoneType, std::string> enableFileOutput(
       std::shared_ptr<AudioFileProperties> properties) override;
   void disableFileOutput() override;
 
@@ -60,7 +61,13 @@ class AndroidAudioRecorder : public oboe::AudioStreamCallback, public AudioRecor
   facebook::jni::global_ref<NativeAudioRecorder> nativeAudioRecorder_;
 
   std::shared_ptr<oboe::AudioStream> mStream_;
+  std::vector<std::string> recordingSegmentPaths_;
   Result<NoneType, std::string> openAudioStream();
+  std::shared_ptr<AudioFileWriter> createFileWriter(
+      const std::shared_ptr<AudioFileProperties> &props);
+  Result<NoneType, std::string> setupFileWriter(
+      const std::shared_ptr<AudioFileProperties> &properties,
+      const std::string &fileNameOverride = "");
 };
 
 } // namespace audioapi

packages/react-native-audio-api/android/src/main/cpp/audioapi/android/core/utils/AndroidFileWriterBackend.cpp

@@ -1,6 +1,6 @@
 #include <audioapi/android/core/utils/AndroidFileWriterBackend.h>
+
 #include <memory>
-#include <utility>
 
 namespace audioapi {
 AndroidFileWriterBackend::AndroidFileWriterBackend(
@@ -18,6 +18,6 @@ AndroidFileWriterBackend::AndroidFileWriterBackend(
 }
 
 void AndroidFileWriterBackend::writeAudioData(void *data, int numFrames) {
-  offloader_->getSender()->send({data, numFrames});
+  offloader_->getSender()->send({.data = data, .numFrames = numFrames});
 }
 } // namespace audioapi