react-native-audio-api 0.10.0-nightly-e16d7ff-20251030 → 0.11.0-alpha.1

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

@@ -0,0 +1,269 @@
+#include <android/log.h>
+#include <audioapi/android/core/utils/AndroidFileWriterBackend.h>
+#include <audioapi/android/core/utils/miniaudioBackend/MiniAudioFileOptions.h>
+#include <audioapi/android/core/utils/miniaudioBackend/MiniAudioFileWriter.h>
+#include <audioapi/libs/miniaudio/miniaudio.h>
+
+constexpr double BYTES_TO_MB = 1024.0 * 1024.0;
+
+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);
+}
+
+MiniAudioFileWriter::~MiniAudioFileWriter() {
+  isFileOpen_.store(false);
+  fileOptions_.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;
+  }
+}
+
+std::string MiniAudioFileWriter::openFile(
+    int32_t streamSampleRate,
+    int32_t streamChannelCount,
+    int32_t streamMaxBufferSize) {
+  streamSampleRate_ = streamSampleRate;
+  streamChannelCount_ = streamChannelCount;
+  streamMaxBufferSize_ = streamMaxBufferSize;
+  bool success = false;
+
+  isConverterRequired_.store(
+      (streamSampleRate_ != fileOptions_->getSampleRate()) ||
+      (streamChannelCount_ != fileOptions_->getChannelCount()) ||
+      (fileOptions_->getDataFormat() != ma_format_f32));
+
+  success = initializeConverterIfNeeded();
+
+  if (!success) {
+    return "";
+  }
+
+  success = initializeEncoder();
+
+  if (!success) {
+    return "";
+  }
+
+  isFileOpen_.store(true);
+
+  return filePath_;
+}
+
+std::tuple<double, double> MiniAudioFileWriter::closeFile() {
+  if (!isFileOpen()) {
+    return {0.0, 0.0};
+  }
+
+  isFileOpen_.store(false);
+
+  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
+  std::string filePath = filePath_;
+  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);
+    long fileSizeInBytes = ftell(file);
+    fclose(file);
+    fileSizeInMB = static_cast<double>(fileSizeInBytes) / BYTES_TO_MB;
+  }
+
+  filePath_ = "";
+  return {fileSizeInMB, durationInSeconds};
+}
+
+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);
+
+    __android_log_print(
+        ANDROID_LOG_DEBUG,
+        "MiniAudioFileWriter",
+        "Writing %llu frames without conversion to file: %s",
+        framesWritten,
+        filePath_.c_str());
+
+    if (result != MA_SUCCESS) {
+      __android_log_print(
+          ANDROID_LOG_ERROR,
+          "MiniAudioFileWriter",
+          "Failed to write audio data to file: %s",
+          filePath_.c_str());
+    }
+
+    framesWritten_.fetch_add(numFrames);
+    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) {
+    __android_log_print(
+        ANDROID_LOG_ERROR,
+        "MiniAudioFileWriter",
+        "Failed to write converted audio data to file: %s",
+        filePath_.c_str());
+  }
+
+  framesWritten_.fetch_add(numFrames);
+  return result == MA_SUCCESS;
+}
+
+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;
+}
+
+bool MiniAudioFileWriter::initializeConverterIfNeeded() {
+  if (!isConverterRequired_) {
+    return true;
+  }
+
+  ma_result result;
+
+  ma_data_converter_config converterConfig = ma_data_converter_config_init(
+      ma_format_f32,
+      fileOptions_->getDataFormat(),
+      streamChannelCount_,
+      fileOptions_->getChannelCount(),
+      streamSampleRate_,
+      fileOptions_->getSampleRate());
+
+  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;
+  }
+
+  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()),
+      NULL);
+
+  return true;
+}
+
+bool MiniAudioFileWriter::initializeEncoder() {
+  filePath_ = fileOptions_->getFilePath("audio");
+
+  ma_result result;
+
+  ma_encoder_config config = ma_encoder_config_init(
+      fileOptions_->getFormat(),
+      fileOptions_->getDataFormat(),
+      fileOptions_->getChannelCount(),
+      fileOptions_->getSampleRate());
+
+  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();
+}
+
+bool MiniAudioFileWriter::isConverterRequired() {
+  return isConverterRequired_.load();
+}
+
+} // namespace audioapi

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

@@ -0,0 +1,47 @@
+#pragma once
+
+#include <audioapi/android/core/utils/AndroidFileWriterBackend.h>
+#include <audioapi/libs/miniaudio/miniaudio.h>
+
+#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;
+
+  std::string openFile(int32_t streamSampleRate, int32_t streamChannelCount, int32_t streamMaxBufferSize) override;
+  std::tuple<double, double> 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};
+  std::unique_ptr<ma_data_converter> converter_{nullptr};
+  void *processingBuffer_{nullptr};
+  ma_uint64 processingBufferLength_{0};
+
+  bool initializeConverterIfNeeded();
+  bool initializeEncoder();
+  ma_uint64 convertBuffer(void *data, int numFrames);
+
+  bool isFileOpen();
+  bool isConverterRequired();
+};
+
+} // namespace audioapi

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

@@ -0,0 +1,31 @@
+#pragma once
+
+#include <fbjni/fbjni.h>
+#include <react/jni/CxxModuleWrapper.h>
+#include <react/jni/JMessageQueueThread.h>
+#include <memory>
+#include <utility>
+#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();
+  }
+};
+
+}

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

@@ -1,8 +1,6 @@
 package com.swmansion.audioapi
 
 import com.facebook.jni.HybridData
-import com.facebook.react.bridge.LifecycleEventListener
-import com.facebook.react.bridge.NativeModule
 import com.facebook.react.bridge.Promise
 import com.facebook.react.bridge.ReactApplicationContext
 import com.facebook.react.bridge.ReadableArray
@@ -11,6 +9,7 @@ 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.MediaSessionManager
+import com.swmansion.audioapi.system.NativeFileInfo
 import com.swmansion.audioapi.system.PermissionRequestListener
 import java.lang.ref.WeakReference
 
@@ -18,8 +17,7 @@ import java.lang.ref.WeakReference
 @ReactModule(name = AudioAPIModule.NAME)
 class AudioAPIModule(
   reactContext: ReactApplicationContext,
-) : NativeAudioAPIModuleSpec(reactContext),
-  LifecycleEventListener {
+) : NativeAudioAPIModuleSpec(reactContext) {
   companion object {
     const val NAME = NativeAudioAPIModuleSpec.NAME
   }
@@ -27,7 +25,6 @@ class AudioAPIModule(
   val reactContext: WeakReference<ReactApplicationContext> = WeakReference(reactContext)
 
   private val mHybridData: HybridData
-  private var reanimatedModule: NativeModule? = null
 
   external fun initHybrid(
     workletsModule: Any?,
@@ -42,8 +39,6 @@ class AudioAPIModule(
     eventBody: Map<String, Any>,
   )
 
-  private external fun closeAllContexts()
-
   init {
     try {
       System.loadLibrary("react-native-audio-api")
@@ -65,33 +60,12 @@ class AudioAPIModule(
 
   override fun install(): Boolean {
     MediaSessionManager.initialize(WeakReference(this), reactContext)
+    NativeFileInfo.initialize(reactContext)
     injectJSIBindings()
 
     return true
   }
 
-  override fun onHostResume() {
-    // do nothing
-  }
-
-  override fun onHostPause() {
-    // do nothing
-  }
-
-  override fun onHostDestroy() {
-    closeAllContexts()
-  }
-
-  override fun initialize() {
-    reactContext.get()?.addLifecycleEventListener(this)
-  }
-
-  override fun invalidate() {
-    closeAllContexts()
-    reactContext.get()?.removeLifecycleEventListener(this)
-    // think about cleaning up resources, singletons etc.
-  }
-
   override fun getDevicePreferredSampleRate(): Double = MediaSessionManager.getDevicePreferredSampleRate()
 
   override fun setAudioSessionActivity(

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

@@ -13,14 +13,12 @@ class AudioFocusListener(
   private val audioAPIModule: WeakReference<AudioAPIModule>,
   private val lockScreenManager: WeakReference<LockScreenManager>,
 ) : AudioManager.OnAudioFocusChangeListener {
-  private var playOnAudioFocus: Boolean = false
   private var focusRequest: AudioFocusRequest? = null
 
   override fun onAudioFocusChange(focusChange: Int) {
     Log.d("AudioFocusListener", "onAudioFocusChange: $focusChange")
     when (focusChange) {
       AudioManager.AUDIOFOCUS_LOSS -> {
-        playOnAudioFocus = false
         val body =
           HashMap<String, Any>().apply {
             put("type", "began")
@@ -28,33 +26,23 @@ class AudioFocusListener(
           }
         audioAPIModule.get()?.invokeHandlerWithEventNameAndEventBody("interruption", body)
       }
+
       AudioManager.AUDIOFOCUS_LOSS_TRANSIENT -> {
-        playOnAudioFocus = lockScreenManager.get()?.isPlaying == true
         val body =
           HashMap<String, Any>().apply {
             put("type", "began")
-            put("shouldResume", playOnAudioFocus)
+            put("shouldResume", false)
           }
         audioAPIModule.get()?.invokeHandlerWithEventNameAndEventBody("interruption", body)
       }
-      AudioManager.AUDIOFOCUS_GAIN -> {
-        if (playOnAudioFocus) {
-          val body =
-            HashMap<String, Any>().apply {
-              put("type", "ended")
-              put("shouldResume", true)
-            }
-          audioAPIModule.get()?.invokeHandlerWithEventNameAndEventBody("interruption", body)
-        } else {
-          val body =
-            HashMap<String, Any>().apply {
-              put("type", "ended")
-              put("shouldResume", false)
-            }
-          audioAPIModule.get()?.invokeHandlerWithEventNameAndEventBody("interruption", body)
-        }
 
-        playOnAudioFocus = false
+      AudioManager.AUDIOFOCUS_GAIN -> {
+        val body =
+          HashMap<String, Any>().apply {
+            put("type", "ended")
+            put("shouldResume", true)
+          }
+        audioAPIModule.get()?.invokeHandlerWithEventNameAndEventBody("interruption", body)
       }
     }
   }

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

@@ -42,11 +42,13 @@ class LockScreenManager(
   private var playbackState: Int = PlaybackStateCompat.STATE_PAUSED
 
   init {
-    pb.setActions(controls)
-    nb.setPriority(NotificationCompat.PRIORITY_HIGH)
-    nb.setVisibility(NotificationCompat.VISIBILITY_PUBLIC)
+    this.pb.setActions(controls)
+
+    this.nb.setVisibility(NotificationCompat.VISIBILITY_PUBLIC)
+    this.nb.setPriority(NotificationCompat.PRIORITY_HIGH)
 
     updateNotificationMediaStyle()
+
     mediaNotificationManager.get()?.updateActions(controls)
   }
 
@@ -172,31 +174,8 @@ class LockScreenManager(
     if (artworkThread != null && artworkThread!!.isAlive) artworkThread!!.interrupt()
     artworkThread = null
 
-    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)
+    mediaNotificationManager.get()?.cancelNotification()
     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,16 +258,5 @@ class MediaNotificationManager(
       }
       super.onDestroy()
     }
-
-    override fun onTimeout(startId: Int) {
-      stopForegroundService()
-    }
-
-    override fun onTimeout(
-      startId: Int,
-      fgsType: Int,
-    ) {
-      stopForegroundService()
-    }
   }
 }

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/common/cpp/audioapi/AudioAPIModuleInstaller.h

@@ -16,16 +16,13 @@
 #include <audioapi/core/utils/worklets/SafeIncludes.h>
 
 #include <memory>
-#include <vector>
+#include <string>
 
 namespace audioapi {
 
 using namespace facebook;
 
 class AudioAPIModuleInstaller {
- private:
-  inline static std::vector<std::weak_ptr<AudioContext>> contexts_ = {};
-
  public:
   static void injectJSIBindings(
       jsi::Runtime *jsiRuntime,
@@ -65,19 +62,6 @@ class AudioAPIModuleInstaller {
             *jsiRuntime, audioEventHandlerRegistryHostObject));
   }
 
-  static void closeAllContexts() {
-    for (auto it = contexts_.begin(); it != contexts_.end(); ++it) {
-      auto weakContext = *it;
-
-      if (auto context = weakContext.lock()) {
-        context->close();
-      }
-
-      it = contexts_.erase(it);
-    --it;
-    }
-  }
-
  private:
   static jsi::Function getCreateAudioContextFunction(
       jsi::Runtime *jsiRuntime,
@@ -112,8 +96,6 @@ class AudioAPIModuleInstaller {
               initSuspended,
               audioEventHandlerRegistry,
               runtimeRegistry);
-          AudioAPIModuleInstaller::contexts_.push_back(audioContext);
-
           auto audioContextHostObject =
               std::make_shared<AudioContextHostObject>(
                   audioContext, &runtime, jsCallInvoker);
@@ -157,7 +139,6 @@ class AudioAPIModuleInstaller {
               sampleRate,
               audioEventHandlerRegistry,
               runtimeRegistry);
-
             auto audioContextHostObject =
               std::make_shared<OfflineAudioContextHostObject>(
                     offlineAudioContext, &runtime, jsCallInvoker);
@@ -180,17 +161,8 @@ class AudioAPIModuleInstaller {
             const jsi::Value &thisValue,
             const jsi::Value *args,
             size_t count) -> jsi::Value {
-          auto options = args[0].getObject(runtime);
-
-          auto sampleRate = static_cast<float>(
-              options.getProperty(runtime, "sampleRate").getNumber());
-          auto bufferLength = static_cast<int>(
-              options.getProperty(runtime, "bufferLengthInSamples")
-                  .getNumber());
-
           auto audioRecorderHostObject =
-              std::make_shared<AudioRecorderHostObject>(
-                  audioEventHandlerRegistry, sampleRate, bufferLength);
+              std::make_shared<AudioRecorderHostObject>(audioEventHandlerRegistry);
 
           return jsi::Object::createFromHostObject(
               runtime, audioRecorderHostObject);