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

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());
@@ -107,10 +144,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 +155,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 +180,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 +199,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 +221,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

@@ -9,26 +9,19 @@
 
 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 +29,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/java/com/swmansion/audioapi/AudioAPIModule.kt

@@ -1,6 +1,7 @@
 package com.swmansion.audioapi
 
 import com.facebook.jni.HybridData
+import com.facebook.react.bridge.LifecycleEventListener
 import com.facebook.react.bridge.Promise
 import com.facebook.react.bridge.ReactApplicationContext
 import com.facebook.react.bridge.ReadableArray
@@ -17,7 +18,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 +68,27 @@ 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)
+    // think about cleaning up resources, singletons etc.
+  }
+
   override fun getDevicePreferredSampleRate(): Double = MediaSessionManager.getDevicePreferredSampleRate()
 
   override fun setAudioSessionActivity(
@@ -84,6 +107,10 @@ class AudioAPIModule(
     // noting to do here
   }
 
+  override fun disableSessionManagement() {
+    // nothing to do here
+  }
+
   override fun setLockScreenInfo(info: ReadableMap?) {
     MediaSessionManager.setLockScreenInfo(info)
   }

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

@@ -42,13 +42,11 @@ class LockScreenManager(
   private var playbackState: Int = PlaybackStateCompat.STATE_PAUSED
 
   init {
-    this.pb.setActions(controls)
-
-    this.nb.setVisibility(NotificationCompat.VISIBILITY_PUBLIC)
-    this.nb.setPriority(NotificationCompat.PRIORITY_HIGH)
+    pb.setActions(controls)
+    nb.setPriority(NotificationCompat.PRIORITY_HIGH)
+    nb.setVisibility(NotificationCompat.VISIBILITY_PUBLIC)
 
     updateNotificationMediaStyle()
-
     mediaNotificationManager.get()?.updateActions(controls)
   }
 
@@ -157,6 +155,7 @@ class LockScreenManager(
         "state_playing" -> {
           this.playbackState = PlaybackStateCompat.STATE_PLAYING
         }
+
         "state_paused" -> {
           this.playbackState = PlaybackStateCompat.STATE_PAUSED
         }
@@ -174,8 +173,31 @@ class LockScreenManager(
     if (artworkThread != null && artworkThread!!.isAlive) artworkThread!!.interrupt()
     artworkThread = null
 
-    mediaNotificationManager.get()?.cancelNotification()
+    title = null
+    artist = null
+    album = null
+    description = null
+    duration = 0L
+    speed = 1.0F
+    elapsedTime = 0L
+    artwork = null
+    playbackState = PlaybackStateCompat.STATE_PAUSED
+    isPlaying = false
+
+    val emptyMetadata = MediaMetadataCompat.Builder().build()
+    mediaSession.get()?.setMetadata(emptyMetadata)
+
+    pb.setState(PlaybackStateCompat.STATE_NONE, 0, 0f)
+    pb.setActions(controls)
+    state = pb.build()
+    mediaSession.get()?.setPlaybackState(state)
     mediaSession.get()?.setActive(false)
+
+    nb.setContentTitle("")
+    nb.setContentText("")
+    nb.setContentInfo("")
+
+    mediaNotificationManager.get()?.updateNotification(nb, isPlaying)
   }
 
   fun enableRemoteCommand(

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

@@ -258,5 +258,16 @@ class MediaNotificationManager(
       }
       super.onDestroy()
     }
+
+    override fun onTimeout(startId: Int) {
+      stopForegroundService()
+    }
+
+    override fun onTimeout(
+      startId: Int,
+      fgsType: Int,
+    ) {
+      stopForegroundService()
+    }
   }
 }

package/android/src/oldarch/NativeAudioAPIModuleSpec.java

@@ -50,6 +50,10 @@
    @DoNotStrip
    public abstract void setAudioSessionOptions(String category, String mode, ReadableArray options, boolean allowHaptics);
 
+   @ReactMethod
+   @DoNotStrip
+   public abstract void disableSessionManagement();
+
    @ReactMethod
    @DoNotStrip
    public abstract void setLockScreenInfo(ReadableMap info);