react-native-audio-api 0.11.0-alpha.1 → 0.11.0-alpha.11

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

@@ -1,30 +1,51 @@
 #include <android/log.h>
 #include <audioapi/android/core/utils/AndroidFileWriterBackend.h>
-#include <audioapi/android/core/utils/miniaudioBackend/MiniAudioFileOptions.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>
 
-constexpr double BYTES_TO_MB = 1024.0 * 1024.0;
+#include <cstdio>
+#include <memory>
+#include <string>
 
 namespace audioapi {
 
-MiniAudioFileWriter::MiniAudioFileWriter(
-    float sampleRate,
-    size_t channelCount,
-    size_t bitRate,
-    size_t androidFlags)
-    : AndroidFileWriterBackend(
-          sampleRate,
-          channelCount,
-          bitRate,
-          androidFlags) {
-  fileOptions_ = std::make_shared<MiniAudioFileOptions>(
-      sampleRate, channelCount, bitRate, androidFlags);
+/// @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);
-  fileOptions_.reset();
+  isFileOpen_.store(false, std::memory_order_release);
+  fileProperties_.reset();
 
   if (encoder_ != nullptr) {
     ma_encoder_uninit(encoder_.get());
@@ -43,43 +64,59 @@ MiniAudioFileWriter::~MiniAudioFileWriter() {
   }
 }
 
-std::string MiniAudioFileWriter::openFile(
-    int32_t streamSampleRate,
+/// @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;
-  bool success = false;
+  ma_result result;
+  framesWritten_.store(0, std::memory_order_release);
 
   isConverterRequired_.store(
-      (streamSampleRate_ != fileOptions_->getSampleRate()) ||
-      (streamChannelCount_ != fileOptions_->getChannelCount()) ||
-      (fileOptions_->getDataFormat() != ma_format_f32));
+      (streamSampleRate_ != fileProperties_->sampleRate) ||
+          (streamChannelCount_ != fileProperties_->channelCount) ||
+          (getDataFormat(fileProperties_) != ma_format_f32),
+      std::memory_order_release);
 
-  success = initializeConverterIfNeeded();
+  result = initializeConverterIfNeeded();
 
-  if (!success) {
-    return "";
+  if (result != MA_SUCCESS) {
+    return OpenFileResult ::Err(
+        "Failed to initialize converter" + std::string(ma_result_description(result)));
   }
 
-  success = initializeEncoder();
+  result = initializeEncoder();
 
-  if (!success) {
-    return "";
+  if (result != MA_SUCCESS) {
+    return OpenFileResult ::Err(
+        "Failed to initialize encoder" + std::string(ma_result_description(result)));
   }
 
-  isFileOpen_.store(true);
-
-  return filePath_;
+  isFileOpen_.store(true, std::memory_order_release);
+  return OpenFileResult ::Ok(filePath_);
 }
 
-std::tuple<double, double> MiniAudioFileWriter::closeFile() {
+/// @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 {0.0, 0.0};
+    return CloseFileResult ::Err("File is not open");
   }
 
-  isFileOpen_.store(false);
+  isFileOpen_.store(false, std::memory_order_release);
 
   if (encoder_ != nullptr) {
     ma_encoder_uninit(encoder_.get());
@@ -98,7 +135,6 @@ std::tuple<double, double> MiniAudioFileWriter::closeFile() {
   }
 
   // Retrieve duration and file size
-  std::string filePath = filePath_;
   double durationInSeconds = 0.0;
   double fileSizeInMB = 0.0;
 
@@ -107,10 +143,8 @@ std::tuple<double, double> MiniAudioFileWriter::closeFile() {
   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;
+    if (ma_decoder_get_length_in_pcm_frames(&decoder, &frameCount) == MA_SUCCESS) {
+      durationInSeconds = static_cast<double>(frameCount) / decoder.outputSampleRate;
     }
 
     ma_decoder_uninit(&decoder);
@@ -120,15 +154,22 @@ std::tuple<double, double> MiniAudioFileWriter::closeFile() {
 
   if (file != nullptr) {
     fseek(file, 0, SEEK_END);
-    long fileSizeInBytes = ftell(file);
+    uint64_t fileSizeInBytes = ftell(file);
     fclose(file);
-    fileSizeInMB = static_cast<double>(fileSizeInBytes) / BYTES_TO_MB;
+    fileSizeInMB = static_cast<double>(fileSizeInBytes) / MB_IN_BYTES;
   }
 
   filePath_ = "";
-  return {fileSizeInMB, durationInSeconds};
+  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;
@@ -138,25 +179,16 @@ bool MiniAudioFileWriter::writeAudioData(void *data, int numFrames) {
   }
 
   if (!isConverterRequired()) {
-    result = ma_encoder_write_pcm_frames(
-        encoder_.get(), data, numFrames, &framesWritten);
-
-    __android_log_print(
-        ANDROID_LOG_DEBUG,
-        "MiniAudioFileWriter",
-        "Writing %llu frames without conversion to file: %s",
-        framesWritten,
-        filePath_.c_str());
+    result = ma_encoder_write_pcm_frames(encoder_.get(), data, numFrames, &framesWritten);
 
     if (result != MA_SUCCESS) {
-      __android_log_print(
-          ANDROID_LOG_ERROR,
-          "MiniAudioFileWriter",
-          "Failed to write audio data to file: %s",
-          filePath_.c_str());
+      invokeOnErrorCallback(
+          "Failed to write audio data to file: " + filePath_ +
+          std::string(ma_result_description(result)));
+      return false;
     }
 
-    framesWritten_.fetch_add(numFrames);
+    framesWritten_.fetch_add(numFrames, std::memory_order_acq_rel);
     return result == MA_SUCCESS;
   }
 
@@ -166,17 +198,20 @@ bool MiniAudioFileWriter::writeAudioData(void *data, int numFrames) {
       encoder_.get(), processingBuffer_, convertedFrameCount, &framesWritten);
 
   if (result != MA_SUCCESS) {
-    __android_log_print(
-        ANDROID_LOG_ERROR,
-        "MiniAudioFileWriter",
-        "Failed to write converted audio data to file: %s",
-        filePath_.c_str());
+    invokeOnErrorCallback(
+        "Failed to write converted audio data to file: " + filePath_ +
+        std::string(ma_result_description(result)));
+    return false;
   }
 
-  framesWritten_.fetch_add(numFrames);
+  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;
@@ -185,85 +220,77 @@ ma_uint64 MiniAudioFileWriter::convertBuffer(void *data, int numFrames) {
       converter_.get(), inputFrameCount, &outputFrameCount);
 
   ma_data_converter_process_pcm_frames(
-      converter_.get(),
-      data,
-      &inputFrameCount,
-      processingBuffer_,
-      &outputFrameCount);
+      converter_.get(), data, &inputFrameCount, processingBuffer_, &outputFrameCount);
 
   return outputFrameCount;
 }
 
-bool MiniAudioFileWriter::initializeConverterIfNeeded() {
+/// @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 true;
+    return MA_SUCCESS;
   }
 
   ma_result result;
+  ma_format dataFormat = getDataFormat(fileProperties_);
 
   ma_data_converter_config converterConfig = ma_data_converter_config_init(
       ma_format_f32,
-      fileOptions_->getDataFormat(),
+      dataFormat,
       streamChannelCount_,
-      fileOptions_->getChannelCount(),
-      streamSampleRate_,
-      fileOptions_->getSampleRate());
+      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) {
-    __android_log_print(
-        ANDROID_LOG_ERROR,
-        "MiniAudioFileWriter",
-        "Failed to initialize miniaudio data converter for file: %s",
-        filePath_.c_str());
-    return false;
+    return result;
   }
 
   ma_data_converter_get_expected_output_frame_count(
       converter_.get(), streamMaxBufferSize_, &processingBufferLength_);
 
   processingBuffer_ = ma_malloc(
-      processingBufferLength_ * fileOptions_->getChannelCount() *
-          ma_get_bytes_per_sample(fileOptions_->getDataFormat()),
+      processingBufferLength_ * fileProperties_->channelCount * ma_get_bytes_per_sample(dataFormat),
       NULL);
 
-  return true;
+  return MA_SUCCESS;
 }
 
-bool MiniAudioFileWriter::initializeEncoder() {
-  filePath_ = fileOptions_->getFilePath("audio");
-
+/// @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(
-      fileOptions_->getFormat(),
-      fileOptions_->getDataFormat(),
-      fileOptions_->getChannelCount(),
-      fileOptions_->getSampleRate());
+      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());
 
-  if (result != MA_SUCCESS) {
-    __android_log_print(
-        ANDROID_LOG_ERROR,
-        "MiniAudioFileWriter",
-        "Failed to initialize miniaudio encoder for file: %s",
-        filePath_.c_str());
-    return false;
-  }
-
-  return true;
-}
-
-bool MiniAudioFileWriter::isFileOpen() {
-  return isFileOpen_.load();
+  return result;
 }
 
 bool MiniAudioFileWriter::isConverterRequired() {
-  return isConverterRequired_.load();
+  return isConverterRequired_.load(std::memory_order_acquire);
 }
 
 } // namespace audioapi

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

@@ -3,32 +3,26 @@
 #include <audioapi/android/core/utils/AndroidFileWriterBackend.h>
 #include <audioapi/libs/miniaudio/miniaudio.h>
 
+#include <atomic>
 #include <string>
 #include <memory>
 #include <tuple>
 
 namespace audioapi {
 
-class MiniAudioFileOptions;
-
 class MiniAudioFileWriter : public AndroidFileWriterBackend {
  public:
-  MiniAudioFileWriter(
-    float sampleRate,
-    size_t channelCount,
-    size_t bitRate,
-    size_t androidFlags);
-  ~MiniAudioFileWriter() override;
+  explicit MiniAudioFileWriter(
+      const std::shared_ptr<AudioEventHandlerRegistry> &audioEventHandlerRegistry,
+      const std::shared_ptr<AudioFileProperties> &fileProperties);
+  ~MiniAudioFileWriter();
 
-  std::string openFile(int32_t streamSampleRate, int32_t streamChannelCount, int32_t streamMaxBufferSize) override;
-  std::tuple<double, double> closeFile() override;
+  OpenFileResult openFile(float streamSampleRate, int32_t streamChannelCount, int32_t streamMaxBufferSize) override;
+  CloseFileResult closeFile() override;
 
   bool writeAudioData(void *data, int numFrames) override;
 
  private:
-  std::shared_ptr<MiniAudioFileOptions> fileOptions_;
-
-  std::atomic<bool> isFileOpen_{false};
   std::atomic<bool> isConverterRequired_{false};
 
   std::unique_ptr<ma_encoder> encoder_{nullptr};
@@ -36,11 +30,10 @@ class MiniAudioFileWriter : public AndroidFileWriterBackend {
   void *processingBuffer_{nullptr};
   ma_uint64 processingBufferLength_{0};
 
-  bool initializeConverterIfNeeded();
-  bool initializeEncoder();
+  ma_result initializeConverterIfNeeded();
+  ma_result initializeEncoder();
   ma_uint64 convertBuffer(void *data, int numFrames);
 
-  bool isFileOpen();
   bool isConverterRequired();
 };
 

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

@@ -5,6 +5,7 @@
 #include <react/jni/JMessageQueueThread.h>
 #include <memory>
 #include <utility>
+#include <string>
 #include <unordered_map>
 
 namespace audioapi {
@@ -28,4 +29,4 @@ class NativeFileInfo : public jni::JavaClass<NativeFileInfo> {
   }
 };
 
-}
+} // namespace audioapi

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

@@ -1,6 +1,8 @@
 package com.swmansion.audioapi
 
 import com.facebook.jni.HybridData
+import com.facebook.react.bridge.Arguments
+import com.facebook.react.bridge.LifecycleEventListener
 import com.facebook.react.bridge.Promise
 import com.facebook.react.bridge.ReactApplicationContext
 import com.facebook.react.bridge.ReadableArray
@@ -8,6 +10,7 @@ import com.facebook.react.bridge.ReadableMap
 import com.facebook.react.common.annotations.FrameworkAPI
 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
@@ -17,7 +20,8 @@ import java.lang.ref.WeakReference
 @ReactModule(name = AudioAPIModule.NAME)
 class AudioAPIModule(
   reactContext: ReactApplicationContext,
-) : NativeAudioAPIModuleSpec(reactContext) {
+) : NativeAudioAPIModuleSpec(reactContext),
+  LifecycleEventListener {
   companion object {
     const val NAME = NativeAudioAPIModuleSpec.NAME
   }
@@ -66,6 +70,28 @@ class AudioAPIModule(
     return true
   }
 
+  override fun onHostResume() {
+    // do nothing
+  }
+
+  override fun onHostPause() {
+    // do nothing
+  }
+
+  override fun onHostDestroy() {
+    // do nothing
+  }
+
+  override fun initialize() {
+    reactContext.get()?.addLifecycleEventListener(this)
+  }
+
+  override fun invalidate() {
+    reactContext.get()?.removeLifecycleEventListener(this)
+    // Cleanup foreground service manager
+    ForegroundServiceManager.cleanup()
+  }
+
   override fun getDevicePreferredSampleRate(): Double = MediaSessionManager.getDevicePreferredSampleRate()
 
   override fun setAudioSessionActivity(
@@ -84,19 +110,8 @@ class AudioAPIModule(
     // noting to do here
   }
 
-  override fun setLockScreenInfo(info: ReadableMap?) {
-    MediaSessionManager.setLockScreenInfo(info)
-  }
-
-  override fun resetLockScreenInfo() {
-    MediaSessionManager.resetLockScreenInfo()
-  }
-
-  override fun enableRemoteCommand(
-    name: String?,
-    enabled: Boolean,
-  ) {
-    MediaSessionManager.enableRemoteCommand(name!!, enabled)
+  override fun disableSessionManagement() {
+    // nothing to do here
   }
 
   override fun observeAudioInterruptions(enabled: Boolean) {
@@ -120,7 +135,167 @@ class AudioAPIModule(
     promise.resolve(MediaSessionManager.checkRecordingPermissions())
   }
 
+  override fun requestNotificationPermissions(promise: Promise) {
+    val permissionRequestListener = PermissionRequestListener(promise)
+    MediaSessionManager.requestNotificationPermissions(permissionRequestListener)
+  }
+
+  override fun checkNotificationPermissions(promise: Promise) {
+    promise.resolve(MediaSessionManager.checkNotificationPermissions())
+  }
+
   override fun getDevicesInfo(promise: Promise) {
     promise.resolve(MediaSessionManager.getDevicesInfo())
   }
+
+  // New notification system methods
+  override fun registerNotification(
+    type: String?,
+    key: String?,
+    promise: Promise?,
+  ) {
+    try {
+      if (type == null || key == null) {
+        val result = Arguments.createMap()
+        result.putBoolean("success", false)
+        result.putString("error", "Type and key are required")
+        promise?.resolve(result)
+        return
+      }
+
+      MediaSessionManager.registerNotification(type, key)
+
+      val result = Arguments.createMap()
+      result.putBoolean("success", true)
+      promise?.resolve(result)
+    } catch (e: Exception) {
+      val result = Arguments.createMap()
+      result.putBoolean("success", false)
+      result.putString("error", e.message ?: "Unknown error")
+      promise?.resolve(result)
+    }
+  }
+
+  override fun showNotification(
+    key: String?,
+    options: ReadableMap?,
+    promise: Promise?,
+  ) {
+    try {
+      if (key == null) {
+        val result = Arguments.createMap()
+        result.putBoolean("success", false)
+        result.putString("error", "Key is required")
+        promise?.resolve(result)
+        return
+      }
+
+      MediaSessionManager.showNotification(key, options)
+
+      val result = Arguments.createMap()
+      result.putBoolean("success", true)
+      promise?.resolve(result)
+    } catch (e: Exception) {
+      val result = Arguments.createMap()
+      result.putBoolean("success", false)
+      result.putString("error", e.message ?: "Unknown error")
+      promise?.resolve(result)
+    }
+  }
+
+  override fun updateNotification(
+    key: String?,
+    options: ReadableMap?,
+    promise: Promise?,
+  ) {
+    try {
+      if (key == null) {
+        val result = Arguments.createMap()
+        result.putBoolean("success", false)
+        result.putString("error", "Key is required")
+        promise?.resolve(result)
+        return
+      }
+
+      MediaSessionManager.updateNotification(key, options)
+
+      val result = Arguments.createMap()
+      result.putBoolean("success", true)
+      promise?.resolve(result)
+    } catch (e: Exception) {
+      val result = Arguments.createMap()
+      result.putBoolean("success", false)
+      result.putString("error", e.message ?: "Unknown error")
+      promise?.resolve(result)
+    }
+  }
+
+  override fun hideNotification(
+    key: String?,
+    promise: Promise?,
+  ) {
+    try {
+      if (key == null) {
+        val result = Arguments.createMap()
+        result.putBoolean("success", false)
+        result.putString("error", "Key is required")
+        promise?.resolve(result)
+        return
+      }
+
+      MediaSessionManager.hideNotification(key)
+
+      val result = Arguments.createMap()
+      result.putBoolean("success", true)
+      promise?.resolve(result)
+    } catch (e: Exception) {
+      val result = Arguments.createMap()
+      result.putBoolean("success", false)
+      result.putString("error", e.message ?: "Unknown error")
+      promise?.resolve(result)
+    }
+  }
+
+  override fun unregisterNotification(
+    key: String?,
+    promise: Promise?,
+  ) {
+    try {
+      if (key == null) {
+        val result = Arguments.createMap()
+        result.putBoolean("success", false)
+        result.putString("error", "Key is required")
+        promise?.resolve(result)
+        return
+      }
+
+      MediaSessionManager.unregisterNotification(key)
+
+      val result = Arguments.createMap()
+      result.putBoolean("success", true)
+      promise?.resolve(result)
+    } catch (e: Exception) {
+      val result = Arguments.createMap()
+      result.putBoolean("success", false)
+      result.putString("error", e.message ?: "Unknown error")
+      promise?.resolve(result)
+    }
+  }
+
+  override fun isNotificationActive(
+    key: String?,
+    promise: Promise?,
+  ) {
+    try {
+      if (key == null) {
+        promise?.resolve(false)
+        return
+      }
+
+      val isActive = MediaSessionManager.isNotificationActive(key)
+      promise?.resolve(isActive)
+    } catch (e: Exception) {
+      promise?.resolve(false)
+    }
+  }
 }