react-native-audio-api 0.11.0-nightly-95f9c99-20251215 → 0.11.0-nightly-dd83923-20251216

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

@@ -0,0 +1,114 @@
+#if !RN_AUDIO_API_FFMPEG_DISABLED
+
+extern "C" {
+#include <libavcodec/avcodec.h>
+}
+
+#include <audioapi/android/core/utils/ffmpegBackend/utils.h>
+
+#include <audioapi/android/core/utils/FileOptions.h>
+#include <audioapi/utils/AudioFileProperties.h>
+
+#include <memory>
+#include <string>
+
+namespace audioapi::android::ffmpeg {
+
+/// @brief Get the PCM codec ID based on the bit depth.
+/// Note: This function returns only PCM codec IDs and its different from getSampleFormat. :)
+/// @param properties The audio file properties.
+/// @return The corresponding PCM AVCodecID.
+AVCodecID getPCMCodecID(const std::shared_ptr<AudioFileProperties> &properties) {
+  switch (properties->bitDepth) {
+    case AudioFileProperties::BitDepth::Bit16:
+      return AV_CODEC_ID_PCM_S16LE;
+    case AudioFileProperties::BitDepth::Bit24:
+      return AV_CODEC_ID_PCM_S24LE;
+    case AudioFileProperties::BitDepth::Bit32:
+      return AV_CODEC_ID_PCM_F32LE;
+    default:
+      return AV_CODEC_ID_PCM_F32LE;
+  }
+}
+
+/// @brief Get the codec ID based on the audio file properties.
+/// Note: PCM codec is used with wav and caf formats as both are uncompressed formats.
+/// @param properties The audio file properties.
+/// @return The corresponding AVCodecID.
+AVCodecID getCodecID(const std::shared_ptr<AudioFileProperties> &properties) {
+  switch (properties->format) {
+    case AudioFileProperties::Format::WAV:
+    case AudioFileProperties::Format::CAF:
+      return getPCMCodecID(properties);
+    case AudioFileProperties::Format::M4A:
+      return AV_CODEC_ID_AAC;
+    case AudioFileProperties::Format::FLAC:
+      return AV_CODEC_ID_FLAC;
+    default:
+      return AV_CODEC_ID_AAC;
+  }
+}
+
+/// @brief Returns the appropriate AVSampleFormat for codecs that require it. (non-PCM codecs)
+/// @param properties The audio file properties.
+/// @return The corresponding AVSampleFormat.
+AVSampleFormat getSampleFormat(const std::shared_ptr<AudioFileProperties> &properties) {
+  if (properties->format == AudioFileProperties::Format::M4A) {
+    return AV_SAMPLE_FMT_FLTP;
+  }
+
+  switch (properties->bitDepth) {
+    case AudioFileProperties::BitDepth::Bit16:
+      return AV_SAMPLE_FMT_S16;
+    case AudioFileProperties::BitDepth::Bit24:
+      return AV_SAMPLE_FMT_S32;
+    case AudioFileProperties::BitDepth::Bit32:
+      return AV_SAMPLE_FMT_FLT;
+    default:
+      return AV_SAMPLE_FMT_FLT;
+  }
+}
+
+/// @brief Finds the appropriate codec based on the audio file properties.
+/// @param properties The audio file properties.
+/// @return A pointer to the AVCodec.
+const AVCodec *getCodec(const std::shared_ptr<AudioFileProperties> &properties) {
+  return avcodec_find_encoder(getCodecID(properties));
+}
+
+/// @brief Returns the appropriate muxer name based on the audio file properties.
+/// Note: most of the time, the muxer name is same as the file extension, (M4A uses MP4 muxer :))
+/// thus this is kept separate from format -> extension mapping.
+/// @param properties The audio file properties.
+/// @return The corresponding muxer name.
+std::string getMuxerName(const std::shared_ptr<AudioFileProperties> &properties) {
+  switch (properties->format) {
+    case AudioFileProperties::Format::WAV:
+      return "wav";
+    case AudioFileProperties::Format::CAF:
+      return "caf";
+    case AudioFileProperties::Format::M4A:
+      return "mp4";
+    case AudioFileProperties::Format::FLAC:
+      return "flac";
+    default:
+      return "mp4";
+  }
+}
+
+/// @brief Parses the FFmpeg error int code into a human-readable string.
+/// @param errorCode The FFmpeg error code.
+/// @return A human-readable string describing the error.
+std::string parseErrorCode(int errorCode) {
+  char errorBuffer[AV_ERROR_MAX_STRING_SIZE];
+
+  if (av_strerror(errorCode, errorBuffer, sizeof(errorBuffer)) < 0) {
+    return "Unknown FFmpeg error: " + std::to_string(errorCode);
+  }
+
+  return std::string(errorBuffer);
+}
+
+} // namespace audioapi::android::ffmpeg
+
+#endif // RN_AUDIO_API_FFMPEG_DISABLED

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

@@ -0,0 +1,34 @@
+#pragma once
+
+extern "C" {
+#include <libavcodec/avcodec.h>
+}
+
+#include <string>
+#include <memory>
+
+namespace audioapi {
+
+class AudioFileProperties;
+
+namespace android::ffmpeg {
+
+template <typename AVT>
+struct AvDtor {
+  void operator()(AVT* ptr) const;
+};
+
+template<typename AVT>
+using av_unique_ptr = std::unique_ptr<AVT, AvDtor<AVT>>;
+
+AVCodecID getPCMCodecID(const std::shared_ptr<AudioFileProperties> &properties);
+AVCodecID getCodecID(const std::shared_ptr<AudioFileProperties> &properties);
+AVSampleFormat getSampleFormat(const std::shared_ptr<AudioFileProperties> &properties);
+const AVCodec* getCodec(const std::shared_ptr<AudioFileProperties> &properties);
+std::string getMuxerName(const std::shared_ptr<AudioFileProperties> &properties);
+
+std::string parseErrorCode(int errorCode);
+
+} // namespace android::ffmpeg
+
+} // namespace audioapi

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

@@ -0,0 +1,296 @@
+#include <android/log.h>
+#include <audioapi/android/core/utils/AndroidFileWriterBackend.h>
+#include <audioapi/android/core/utils/FileOptions.h>
+#include <audioapi/android/core/utils/miniaudioBackend/MiniAudioFileWriter.h>
+#include <audioapi/libs/miniaudio/miniaudio.h>
+#include <audioapi/utils/AudioFileProperties.h>
+#include <audioapi/utils/UnitConversion.h>
+
+#include <cstdio>
+#include <memory>
+#include <string>
+
+namespace audioapi {
+
+/// @brief Get the encoding format based on the audio file properties (only WAV supported).
+// Currently, miniaudio supports only WAV encoding, but out of convenience
+// or potential future shenanigans, we keep this as a separate function.
+inline ma_encoding_format getFormat(const std::shared_ptr<AudioFileProperties> &properties) {
+  return ma_encoding_format_wav;
+}
+
+/// @brief Get the data format based on the bit depth.
+/// @param properties The audio file properties.
+/// @return The corresponding ma_format.
+inline ma_format getDataFormat(const std::shared_ptr<AudioFileProperties> &properties) {
+  switch (properties->bitDepth) {
+    case AudioFileProperties::BitDepth::Bit16:
+      return ma_format_s16;
+
+    case AudioFileProperties::BitDepth::Bit24:
+      return ma_format_s24;
+
+    case AudioFileProperties::BitDepth::Bit32:
+      return ma_format_f32;
+
+    default:
+      return ma_format_f32;
+  }
+}
+
+MiniAudioFileWriter::MiniAudioFileWriter(
+    const std::shared_ptr<AudioEventHandlerRegistry> &audioEventHandlerRegistry,
+    const std::shared_ptr<AudioFileProperties> &fileProperties)
+    : AndroidFileWriterBackend(audioEventHandlerRegistry, fileProperties) {}
+
+MiniAudioFileWriter::~MiniAudioFileWriter() {
+  isFileOpen_.store(false, std::memory_order_release);
+  fileProperties_.reset();
+
+  if (encoder_ != nullptr) {
+    ma_encoder_uninit(encoder_.get());
+    encoder_.reset();
+  }
+
+  if (converter_ != nullptr) {
+    ma_data_converter_uninit(converter_.get(), NULL);
+    converter_.reset();
+  }
+
+  if (processingBuffer_ != nullptr) {
+    ma_free(processingBuffer_, NULL);
+    processingBuffer_ = nullptr;
+    processingBufferLength_ = 0;
+  }
+}
+
+/// @brief Opens the audio file for writing.
+/// This method initializes the audio converter and encoder together with any
+/// necessary buffers required during the writing process.
+/// this method should be called only on the JS thread.
+/// @param streamSampleRate The sample rate of the incoming audio stream.
+/// @param streamChannelCount The channel count of the incoming audio stream.
+/// @param streamMaxBufferSize The maximum buffer size of the incoming audio stream.
+/// @return The status of the file opening operation.
+OpenFileResult MiniAudioFileWriter::openFile(
+    float streamSampleRate,
+    int32_t streamChannelCount,
+    int32_t streamMaxBufferSize) {
+  streamSampleRate_ = streamSampleRate;
+  streamChannelCount_ = streamChannelCount;
+  streamMaxBufferSize_ = streamMaxBufferSize;
+  ma_result result;
+  framesWritten_.store(0, std::memory_order_release);
+
+  isConverterRequired_.store(
+      (streamSampleRate_ != fileProperties_->sampleRate) ||
+          (streamChannelCount_ != fileProperties_->channelCount) ||
+          (getDataFormat(fileProperties_) != ma_format_f32),
+      std::memory_order_release);
+
+  result = initializeConverterIfNeeded();
+
+  if (result != MA_SUCCESS) {
+    return OpenFileResult ::Err(
+        "Failed to initialize converter" + std::string(ma_result_description(result)));
+  }
+
+  result = initializeEncoder();
+
+  if (result != MA_SUCCESS) {
+    return OpenFileResult ::Err(
+        "Failed to initialize encoder" + std::string(ma_result_description(result)));
+  }
+
+  isFileOpen_.store(true, std::memory_order_release);
+  return OpenFileResult ::Ok(filePath_);
+}
+
+/// @brief Closes the audio file.
+/// This method finalizes the writing process, releases resources,
+/// and retrieves the duration and size of the written audio file.
+/// It should be called only on the JS thread.
+/// @return The status of the file closing operation.
+CloseFileResult MiniAudioFileWriter::closeFile() {
+  if (!isFileOpen()) {
+    return CloseFileResult ::Err("File is not open");
+  }
+
+  isFileOpen_.store(false, std::memory_order_release);
+
+  if (encoder_ != nullptr) {
+    ma_encoder_uninit(encoder_.get());
+    encoder_.reset();
+  }
+
+  if (converter_ != nullptr) {
+    ma_data_converter_uninit(converter_.get(), NULL);
+    converter_.reset();
+  }
+
+  if (processingBuffer_ != nullptr) {
+    ma_free(processingBuffer_, NULL);
+    processingBuffer_ = nullptr;
+    processingBufferLength_ = 0;
+  }
+
+  // Retrieve duration and file size
+  double durationInSeconds = 0.0;
+  double fileSizeInMB = 0.0;
+
+  ma_decoder decoder;
+
+  if (ma_decoder_init_file(filePath_.c_str(), NULL, &decoder) == MA_SUCCESS) {
+    ma_uint64 frameCount = 0;
+
+    if (ma_decoder_get_length_in_pcm_frames(&decoder, &frameCount) == MA_SUCCESS) {
+      durationInSeconds = static_cast<double>(frameCount) / decoder.outputSampleRate;
+    }
+
+    ma_decoder_uninit(&decoder);
+  }
+
+  FILE *file = fopen(filePath_.c_str(), "rb");
+
+  if (file != nullptr) {
+    fseek(file, 0, SEEK_END);
+    uint64_t fileSizeInBytes = ftell(file);
+    fclose(file);
+    fileSizeInMB = static_cast<double>(fileSizeInBytes) / MB_IN_BYTES;
+  }
+
+  filePath_ = "";
+  return CloseFileResult ::Ok({fileSizeInMB, durationInSeconds});
+}
+
+/// @brief Writes audio data to the file.
+/// If possible (sample format, channel count, and interleaving matches),
+/// the data is written directly, otherwise in-memory conversion is performed first
+/// It should be called only on the audio thread.
+/// @param data Pointer to the audio data buffer. (Interleaved float32 format - as oboe likes it)
+/// @param numFrames Number of audio frames to write.
+/// @return True if the write operation was successful, false otherwise.
+bool MiniAudioFileWriter::writeAudioData(void *data, int numFrames) {
+  ma_uint64 framesWritten = 0;
+  ma_result result;
+
+  if (!isFileOpen()) {
+    return false;
+  }
+
+  if (!isConverterRequired()) {
+    result = ma_encoder_write_pcm_frames(encoder_.get(), data, numFrames, &framesWritten);
+
+    if (result != MA_SUCCESS) {
+      invokeOnErrorCallback(
+          "Failed to write audio data to file: " + filePath_ +
+          std::string(ma_result_description(result)));
+      return false;
+    }
+
+    framesWritten_.fetch_add(numFrames, std::memory_order_acq_rel);
+    return result == MA_SUCCESS;
+  }
+
+  ma_uint64 convertedFrameCount = convertBuffer(data, numFrames);
+
+  result = ma_encoder_write_pcm_frames(
+      encoder_.get(), processingBuffer_, convertedFrameCount, &framesWritten);
+
+  if (result != MA_SUCCESS) {
+    invokeOnErrorCallback(
+        "Failed to write converted audio data to file: " + filePath_ +
+        std::string(ma_result_description(result)));
+    return false;
+  }
+
+  framesWritten_.fetch_add(numFrames, std::memory_order_acq_rel);
+  return result == MA_SUCCESS;
+}
+
+/// @brief Converts the audio data buffer if necessary.
+/// @param data Pointer to the audio data buffer.
+/// @param numFrames Number of audio frames to convert.
+/// @return The number of frames after conversion.
+ma_uint64 MiniAudioFileWriter::convertBuffer(void *data, int numFrames) {
+  ma_uint64 inputFrameCount = numFrames;
+  ma_uint64 outputFrameCount = 0;
+
+  ma_data_converter_get_expected_output_frame_count(
+      converter_.get(), inputFrameCount, &outputFrameCount);
+
+  ma_data_converter_process_pcm_frames(
+      converter_.get(), data, &inputFrameCount, processingBuffer_, &outputFrameCount);
+
+  return outputFrameCount;
+}
+
+/// @brief Initializes the data converter if needed.
+/// This method sets up the data converter and allocates, so it should be called
+/// only on the JS thread. (during file opening)
+/// @return MA_SUCCESS if initialization was successful, otherwise an error code.
+ma_result MiniAudioFileWriter::initializeConverterIfNeeded() {
+  if (!isConverterRequired_) {
+    return MA_SUCCESS;
+  }
+
+  ma_result result;
+  ma_format dataFormat = getDataFormat(fileProperties_);
+
+  ma_data_converter_config converterConfig = ma_data_converter_config_init(
+      ma_format_f32,
+      dataFormat,
+      streamChannelCount_,
+      fileProperties_->channelCount,
+      static_cast<int32_t>(streamSampleRate_),
+      fileProperties_->sampleRate);
+
+  converter_ = std::make_unique<ma_data_converter>();
+  result = ma_data_converter_init(&converterConfig, NULL, converter_.get());
+
+  if (result != MA_SUCCESS) {
+    return result;
+  }
+
+  ma_data_converter_get_expected_output_frame_count(
+      converter_.get(), streamMaxBufferSize_, &processingBufferLength_);
+
+  processingBuffer_ = ma_malloc(
+      processingBufferLength_ * fileProperties_->channelCount * ma_get_bytes_per_sample(dataFormat),
+      NULL);
+
+  return MA_SUCCESS;
+}
+
+/// @brief Initializes the audio encoder.
+/// This method sets up the audio encoder for writing to the file,
+/// it should be called only on the JS thread. (during file opening)
+/// @return MA_SUCCESS if initialization was successful, otherwise an error code.
+ma_result MiniAudioFileWriter::initializeEncoder() {
+  ma_result result;
+  Result<std::string, std::string> filePathResult =
+      android::fileoptions::getFilePath(fileProperties_);
+
+  if (!filePathResult.is_ok()) {
+    return MA_ERROR;
+  }
+
+  filePath_ = filePathResult.unwrap();
+
+  ma_encoder_config config = ma_encoder_config_init(
+      getFormat(fileProperties_),
+      getDataFormat(fileProperties_),
+      fileProperties_->channelCount,
+      fileProperties_->sampleRate);
+
+  encoder_ = std::make_unique<ma_encoder>();
+  result = ma_encoder_init_file(filePath_.c_str(), &config, encoder_.get());
+
+  return result;
+}
+
+bool MiniAudioFileWriter::isConverterRequired() {
+  return isConverterRequired_.load(std::memory_order_acquire);
+}
+
+} // namespace audioapi

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

@@ -0,0 +1,40 @@
+#pragma once
+
+#include <audioapi/android/core/utils/AndroidFileWriterBackend.h>
+#include <audioapi/libs/miniaudio/miniaudio.h>
+
+#include <atomic>
+#include <string>
+#include <memory>
+#include <tuple>
+
+namespace audioapi {
+
+class MiniAudioFileWriter : public AndroidFileWriterBackend {
+ public:
+  explicit MiniAudioFileWriter(
+      const std::shared_ptr<AudioEventHandlerRegistry> &audioEventHandlerRegistry,
+      const std::shared_ptr<AudioFileProperties> &fileProperties);
+  ~MiniAudioFileWriter();
+
+  OpenFileResult openFile(float streamSampleRate, int32_t streamChannelCount, int32_t streamMaxBufferSize) override;
+  CloseFileResult closeFile() override;
+
+  bool writeAudioData(void *data, int numFrames) override;
+
+ private:
+  std::atomic<bool> isConverterRequired_{false};
+
+  std::unique_ptr<ma_encoder> encoder_{nullptr};
+  std::unique_ptr<ma_data_converter> converter_{nullptr};
+  void *processingBuffer_{nullptr};
+  ma_uint64 processingBufferLength_{0};
+
+  ma_result initializeConverterIfNeeded();
+  ma_result initializeEncoder();
+  ma_uint64 convertBuffer(void *data, int numFrames);
+
+  bool isConverterRequired();
+};
+
+} // namespace audioapi

package/android/src/main/cpp/audioapi/android/system/NativeFileInfo.hpp

@@ -0,0 +1,32 @@
+#pragma once
+
+#include <fbjni/fbjni.h>
+#include <react/jni/CxxModuleWrapper.h>
+#include <react/jni/JMessageQueueThread.h>
+#include <memory>
+#include <utility>
+#include <string>
+#include <unordered_map>
+
+namespace audioapi {
+
+using namespace facebook;
+using namespace react;
+
+class NativeFileInfo : public jni::JavaClass<NativeFileInfo> {
+ public:
+  static auto constexpr kJavaDescriptor =
+            "Lcom/swmansion/audioapi/system/NativeFileInfo;";
+
+  static std::string getFilesDir() {
+    static const auto method = javaClassStatic()->getStaticMethod<jni::JString()>("getFilesDir");
+    return method(javaClassStatic())->toStdString();
+  }
+
+  static std::string getCacheDir() {
+    static const auto method = javaClassStatic()->getStaticMethod<jni::JString()>("getCacheDir");
+    return method(javaClassStatic())->toStdString();
+  }
+};
+
+} // namespace audioapi

package/android/src/main/java/com/swmansion/audioapi/AudioAPIModule.kt

@@ -12,6 +12,7 @@ import com.facebook.react.module.annotations.ReactModule
 import com.facebook.react.turbomodule.core.CallInvokerHolderImpl
 import com.swmansion.audioapi.system.ForegroundServiceManager
 import com.swmansion.audioapi.system.MediaSessionManager
+import com.swmansion.audioapi.system.NativeFileInfo
 import com.swmansion.audioapi.system.PermissionRequestListener
 import java.lang.ref.WeakReference
 
@@ -63,6 +64,7 @@ class AudioAPIModule(
 
   override fun install(): Boolean {
     MediaSessionManager.initialize(WeakReference(this), reactContext)
+    NativeFileInfo.initialize(reactContext)
     injectJSIBindings()
 
     return true

package/android/src/main/java/com/swmansion/audioapi/system/AudioFocusListener.kt

@@ -13,6 +13,7 @@ class AudioFocusListener(
   private val audioAPIModule: WeakReference<AudioAPIModule>,
 ) : AudioManager.OnAudioFocusChangeListener {
   private var focusRequest: AudioFocusRequest? = null
+  private var isTransientLoss: Boolean = false
 
   override fun onAudioFocusChange(focusChange: Int) {
     Log.d("AudioFocusListener", "onAudioFocusChange: $focusChange")
@@ -21,7 +22,8 @@ class AudioFocusListener(
         val body =
           HashMap<String, Any>().apply {
             put("type", "began")
-            put("isTransient", false)
+            put("shouldResume", false)
+            isTransientLoss = false
           }
         audioAPIModule.get()?.invokeHandlerWithEventNameAndEventBody("interruption", body)
       }
@@ -30,7 +32,8 @@ class AudioFocusListener(
         val body =
           HashMap<String, Any>().apply {
             put("type", "began")
-            put("isTransient", true)
+            put("shouldResume", false)
+            isTransientLoss = true
           }
         audioAPIModule.get()?.invokeHandlerWithEventNameAndEventBody("interruption", body)
       }
@@ -39,7 +42,8 @@ class AudioFocusListener(
         val body =
           HashMap<String, Any>().apply {
             put("type", "ended")
-            put("isTransient", false)
+            put("shouldResume", isTransientLoss)
+            isTransientLoss = false
           }
         audioAPIModule.get()?.invokeHandlerWithEventNameAndEventBody("interruption", body)
       }

package/android/src/main/java/com/swmansion/audioapi/system/CentralizedForegroundService.kt

@@ -36,6 +36,7 @@ class CentralizedForegroundService : Service() {
       ACTION_START -> {
         startForegroundWithNotification()
       }
+
       ACTION_STOP -> {
         stopForeground(STOP_FOREGROUND_REMOVE)
         stopSelf()

package/android/src/main/java/com/swmansion/audioapi/system/NativeFileInfo.kt

@@ -0,0 +1,18 @@
+package com.swmansion.audioapi.system
+
+import com.facebook.react.bridge.ReactApplicationContext
+import java.lang.ref.WeakReference
+
+object NativeFileInfo {
+  private lateinit var reactContext: WeakReference<ReactApplicationContext>
+
+  fun initialize(reactContext: WeakReference<ReactApplicationContext>) {
+    this.reactContext = reactContext
+  }
+
+  @JvmStatic
+  fun getFilesDir(): String = reactContext.get()?.filesDir?.absolutePath ?: ""
+
+  @JvmStatic
+  fun getCacheDir(): String = reactContext.get()?.cacheDir?.absolutePath ?: ""
+}

package/android/src/main/java/com/swmansion/audioapi/system/notification/PlaybackNotification.kt

@@ -283,6 +283,7 @@ class PlaybackNotification(
         "playing" -> {
           playbackPlayingState = PlaybackStateCompat.STATE_PLAYING
         }
+
         "paused" -> {
           playbackPlayingState = PlaybackStateCompat.STATE_PAUSED
         }

package/android/src/main/java/com/swmansion/audioapi/system/notification/RecordingNotificationReceiver.kt

@@ -30,10 +30,12 @@ class RecordingNotificationReceiver : BroadcastReceiver() {
         Log.d(TAG, "Recording notification dismissed by user")
         audioAPIModule?.invokeHandlerWithEventNameAndEventBody("recordingNotificationDismissed", mapOf())
       }
+
       RecordingNotification.ACTION_START -> {
         Log.d(TAG, "Start recording action received")
         audioAPIModule?.invokeHandlerWithEventNameAndEventBody("recordingNotificationStart", mapOf())
       }
+
       RecordingNotification.ACTION_STOP -> {
         Log.d(TAG, "Stop recording action received")
         audioAPIModule?.invokeHandlerWithEventNameAndEventBody("recordingNotificationStop", mapOf())