react-native-audio-api 0.13.4 → 0.13.6

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

@@ -6,30 +6,143 @@ import android.content.Intent
 import android.util.Log
 import com.swmansion.audioapi.AudioAPIModule
 import com.swmansion.audioapi.system.AudioEvent
+import com.swmansion.audioapi.system.MediaSessionManager
+import com.swmansion.audioapi.system.NativeRecorderControl
+import com.swmansion.audioapi.system.RecorderState
+import java.util.concurrent.Executors
 
 class RecordingNotificationReceiver(
   private val module: AudioAPIModule,
 ) : BroadcastReceiver() {
   companion object {
-    const val NOTIFICATION_RECORDING_STOPPED = "com.swmansion.audioapi.NOTIFICATION_RECORDING_STOPPED"
-    const val NOTIFICATION_RECORDING_RESUMED = "com.swmansion.audioapi.NOTIFICATION_RECORDING_RESUMED"
+    const val ACTION_PAUSE = "com.swmansion.audioapi.RECORDING_NOTIFICATION_PAUSE"
+    const val ACTION_RESUME = "com.swmansion.audioapi.RECORDING_NOTIFICATION_RESUME"
+    const val ACTION_STOP = "com.swmansion.audioapi.RECORDING_NOTIFICATION_STOP"
+    const val ACTION_DISMISSED = "com.swmansion.audioapi.RECORDING_NOTIFICATION_DISMISSED"
+
+    /** Boolean extra of [ACTION_DISMISSED]: whether the swipe ends the recording or the notification comes back. */
+    const val EXTRA_DISMISS_STOPS_RECORDING = "com.swmansion.audioapi.DISMISS_STOPS_RECORDING"
+
     private const val TAG = "RecordingNotificationReceiver"
+
+    private val controlExecutor = Executors.newSingleThreadExecutor()
   }
 
   override fun onReceive(
     context: Context?,
     intent: Intent?,
   ) {
-    when (intent?.action) {
-      NOTIFICATION_RECORDING_STOPPED -> {
-        Log.d(TAG, "Recording stopped via notification")
-        module.invokeHandlerWithEventNameAndEventBody(AudioEvent.RECORDING_NOTIFICATION_PAUSE.ordinal, mapOf())
+    if (intent == null) {
+      return
+    }
+    when (intent.action) {
+      ACTION_PAUSE -> {
+        applyToRecorder(
+          action = NativeRecorderControl::pause,
+          intendedState = RecorderState.PAUSED,
+          event = AudioEvent.RECORDING_NOTIFICATION_PAUSE,
+        )
+      }
+
+      ACTION_RESUME -> {
+        applyToRecorder(
+          action = NativeRecorderControl::resume,
+          intendedState = RecorderState.RECORDING,
+          event = AudioEvent.RECORDING_NOTIFICATION_RESUME,
+        )
+      }
+
+      ACTION_STOP -> {
+        stopRecording()
+      }
+
+      ACTION_DISMISSED -> {
+        if (intent.getBooleanExtra(EXTRA_DISMISS_STOPS_RECORDING, false)) {
+          stopRecording()
+        } else {
+          restoreWhileRecording()
+        }
+      }
+    }
+  }
+
+  private fun stopRecording() =
+    applyToRecorder(
+      action = NativeRecorderControl::stop,
+      intendedState = RecorderState.IDLE,
+      event = AudioEvent.RECORDING_NOTIFICATION_STOP,
+    )
+
+  /**
+   * Handles a swipe of a pinned notification. Since Android 14 the system lets the user
+   * swipe away an ongoing notification even when it belongs to a foreground service, and
+   * `setOngoing(true)` no longer prevents that. It can be set to rearming, even though
+   * the user cancels it, it shows again
+   */
+  private fun restoreWhileRecording() {
+    val pendingResult = goAsync()
+    controlExecutor.execute {
+      try {
+        when (NativeRecorderControl.currentState()) {
+          RecorderState.RECORDING -> MediaSessionManager.setRecordingNotificationPaused(false)
+          RecorderState.PAUSED -> MediaSessionManager.setRecordingNotificationPaused(true)
+          RecorderState.IDLE -> Unit
+        }
+      } catch (e: LinkageError) {
+        Log.e(TAG, "Native library unavailable, cannot restore the recording notification: ${e.message}", e)
+      } catch (e: Exception) {
+        Log.e(TAG, "Error while restoring the dismissed recording notification: ${e.message}", e)
+      } finally {
+        pendingResult.finish()
       }
+    }
+  }
 
-      NOTIFICATION_RECORDING_RESUMED -> {
-        Log.d(TAG, "Recording resumed via notification")
-        module.invokeHandlerWithEventNameAndEventBody(AudioEvent.RECORDING_NOTIFICATION_RESUME.ordinal, mapOf())
+  /**
+   * Every action acts on the recorder natively so the notification keeps working after
+   * the app task was removed, when no JS listener is reachable.
+   *
+   * Runs on an executor because [onReceive] is called on the main thread and the native
+   * calls take the recorder's locks
+   */
+  private fun applyToRecorder(
+    action: () -> RecorderState,
+    intendedState: RecorderState,
+    event: AudioEvent,
+  ) {
+    val pendingResult = goAsync()
+    controlExecutor.execute {
+      try {
+        val state = action()
+        renderNotification(state)
+        if (state == intendedState) {
+          dispatchEventToJs(event)
+        }
+      } catch (e: LinkageError) {
+        Log.e(TAG, "Native library unavailable, cannot handle ${event.name}: ${e.message}", e)
+      } catch (e: Exception) {
+        Log.e(TAG, "Error while handling ${event.name} on the recorder: ${e.message}", e)
+      } finally {
+        pendingResult.finish()
       }
     }
   }
+
+  private fun renderNotification(state: RecorderState) {
+    when (state) {
+      RecorderState.RECORDING -> MediaSessionManager.setRecordingNotificationPaused(false)
+      RecorderState.PAUSED -> MediaSessionManager.setRecordingNotificationPaused(true)
+      RecorderState.IDLE -> MediaSessionManager.hideRecordingNotification()
+    }
+  }
+
+  /** Syncing a live JS runtime is best-effort — in the task-removed scenario the JNI
+   * dispatch can throw, and that must not undo the native work that already completed. */
+  private fun dispatchEventToJs(event: AudioEvent) {
+    try {
+      module.invokeHandlerWithEventNameAndEventBody(event.ordinal, mapOf())
+    } catch (e: Exception) {
+      Log.e(TAG, "Recording notification action completed natively, but notifying JS failed: ${e.message}", e)
+    }
+  }
 }

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

@@ -1,24 +1,30 @@
 package com.swmansion.audioapi.system.notification.state
 
-import android.content.Intent
-import androidx.core.app.NotificationCompat
 import com.facebook.react.bridge.ReadableMap
 import com.swmansion.audioapi.system.notification.RecordingNotificationReceiver
 
-data class RecordingNotificationState(
-  var builder: NotificationCompat.Builder? = null,
+/**
+ * Options are sticky: a `show()` call keeps every value the previous call set unless the
+ * new options override it.
+ */
+class RecordingNotificationState(
   var receiver: RecordingNotificationReceiver? = null,
-  var initialized: Boolean,
-  var pauseIntent: Intent? = null,
-  var resumeIntent: Intent? = null,
+  var initialized: Boolean = false,
+  /** Last options map handed to `show()`, so an unchanged one can skip re-parsing. */
+  var cachedRNOptions: ReadableMap? = null,
   var title: String? = null,
   var contentText: String? = null,
   var paused: Boolean = false,
   var smallIconResourceName: String? = null,
   var largeIconResourceName: String? = null,
-  var pauseIconResourceName: String? = null,
-  var resumeIconResourceName: String? = null,
   var backgroundColor: Int? = null,
-  var cachedRNOptions: ReadableMap? = null,
-  var darkTheme: Boolean,
+  var showStopAction: Boolean = false,
+  var dismissible: Boolean = false,
+  var pauseActionTitle: String? = null,
+  var resumeActionTitle: String? = null,
+  var stopActionTitle: String? = null,
+  var deepLinkUri: String? = null,
+  var usesChronometer: Boolean = false,
+  var startedAtMs: Long? = null,
+  var pausedAtMs: Long? = null,
 )

package/common/cpp/audioapi/AudioAPIModuleInstaller.h

@@ -8,6 +8,7 @@
 #include <audioapi/HostObjects/utils/AudioFileUtilsHostObject.h>
 #include <audioapi/core/AudioContext.h>
 #include <audioapi/core/OfflineAudioContext.h>
+#include <audioapi/core/inputs/ActiveRecorderHandle.h>
 #include <audioapi/core/inputs/AudioRecorder.h>
 #include <audioapi/jsi/JsiPromise.h>
 #include <audioapi/utils/AudioBuffer.hpp>
@@ -18,6 +19,7 @@
 #include <audioapi/core/utils/worklets/SafeIncludes.h>
 
 #include <memory>
+#include <utility>
 namespace audioapi {
 
 using namespace facebook;
@@ -38,6 +40,8 @@ class AudioAPIModuleInstaller {
     auto createAudioBuffer = getCreateAudioBufferFunction(jsiRuntime);
     auto createAudioDecoder = getCreateAudioDecoderFunction(jsiRuntime, jsCallInvoker);
     auto createAudioFileUtils = getCreateAudioFileUtilsFunction(jsiRuntime, jsCallInvoker);
+    auto isRecordingOngoing = getIsRecordingOngoingFunction(jsiRuntime);
+    auto consumeLastRecordingResult = getConsumeLastRecordingResultFunction(jsiRuntime);
 
     jsiRuntime->global().setProperty(*jsiRuntime, "createAudioContext", createAudioContext);
     jsiRuntime->global().setProperty(*jsiRuntime, "createAudioRecorder", createAudioRecorder);
@@ -46,6 +50,9 @@ class AudioAPIModuleInstaller {
     jsiRuntime->global().setProperty(*jsiRuntime, "createAudioBuffer", createAudioBuffer);
     jsiRuntime->global().setProperty(*jsiRuntime, "createAudioDecoder", createAudioDecoder);
     jsiRuntime->global().setProperty(*jsiRuntime, "createAudioFileUtils", createAudioFileUtils);
+    jsiRuntime->global().setProperty(*jsiRuntime, "isRecordingOngoing", isRecordingOngoing);
+    jsiRuntime->global().setProperty(
+        *jsiRuntime, "consumeLastRecordingResult", consumeLastRecordingResult);
 
     auto audioEventHandlerRegistryHostObject =
         std::make_shared<AudioEventHandlerRegistryHostObject>(audioEventHandlerRegistry);
@@ -150,6 +157,43 @@ class AudioAPIModuleInstaller {
         });
   }
 
+  static jsi::Function getIsRecordingOngoingFunction(jsi::Runtime *jsiRuntime) {
+    return jsi::Function::createFromHostFunction(
+        *jsiRuntime,
+        jsi::PropNameID::forAscii(*jsiRuntime, "isRecordingOngoing"),
+        0,
+        [](jsi::Runtime &runtime, const jsi::Value &thisValue, const jsi::Value *args, size_t count)
+            -> jsi::Value {
+          return jsi::Value(ActiveRecorderHandle::global().isRecordingOngoing());
+        });
+  }
+
+  static jsi::Function getConsumeLastRecordingResultFunction(jsi::Runtime *jsiRuntime) {
+    return jsi::Function::createFromHostFunction(
+        *jsiRuntime,
+        jsi::PropNameID::forAscii(*jsiRuntime, "consumeLastRecordingResult"),
+        0,
+        [](jsi::Runtime &runtime, const jsi::Value &thisValue, const jsi::Value *args, size_t count)
+            -> jsi::Value {
+          auto result = ActiveRecorderHandle::global().consumeLastRecordingResult();
+          if (!result.has_value()) {
+            return jsi::Value::null();
+          }
+
+          auto jsResult = jsi::Object(runtime);
+          auto pathsArray = jsi::Array(runtime, result->paths.size());
+          for (size_t i = 0; i < result->paths.size(); ++i) {
+            pathsArray.setValueAtIndex(
+                runtime, i, jsi::String::createFromUtf8(runtime, result->paths[i]));
+          }
+          jsResult.setProperty(runtime, "paths", pathsArray);
+          jsResult.setProperty(runtime, "size", result->size);
+          jsResult.setProperty(runtime, "duration", result->duration);
+
+          return jsi::Value(std::move(jsResult));
+        });
+  }
+
   static jsi::Function getCreateAudioDecoderFunction(
       jsi::Runtime *jsiRuntime,
       const std::shared_ptr<react::CallInvoker> &jsCallInvoker) {

package/common/cpp/audioapi/HostObjects/inputs/AudioRecorderHostObject.cpp

@@ -2,12 +2,14 @@
 
 #include <audioapi/HostObjects/sources/AudioBufferHostObject.h>
 #include <audioapi/HostObjects/sources/RecorderAdapterNodeHostObject.h>
+#include <audioapi/core/inputs/ActiveRecorderHandle.h>
 #include <audioapi/core/inputs/AudioRecorder.h>
 #include <audioapi/events/AudioEventHandlerRegistry.h>
 #include <audioapi/jsi/JsiPromise.h>
 #include <audioapi/jsi/JsiUtils.h>
 #include <audioapi/utils/AudioBuffer.hpp>
 #include <audioapi/utils/AudioFileProperties.h>
+#include <audioapi/utils/Result.hpp>
 #ifdef ANDROID
 #include <audioapi/android/core/AndroidAudioRecorder.h>
 #else
@@ -49,13 +51,17 @@ AudioRecorderHostObject::AudioRecorderHostObject(
       JSI_EXPORT_FUNCTION(AudioRecorderHostObject, getCurrentDuration));
 }
 
+AudioRecorderHostObject::~AudioRecorderHostObject() {
+  ActiveRecorderHandle::global().stopAndReturnInfo(audioRecorder_);
+}
+
 JSI_HOST_FUNCTION_IMPL(AudioRecorderHostObject, start) {
   auto fileNameOverride = jsiutils::argToString(runtime, args, count, 0, "");
   auto audioRecorder = audioRecorder_;
 
   return promiseVendor_->createAsyncPromise(
       [audioRecorder, fileNameOverride = std::move(fileNameOverride)]() -> PromiseResolver {
-        auto result = audioRecorder->start(fileNameOverride);
+        auto result = ActiveRecorderHandle::global().tryStart(audioRecorder, fileNameOverride);
 
         return [result = std::move(result)](
                    jsi::Runtime &runtime) -> std::variant<jsi::Value, std::string> {
@@ -80,10 +86,11 @@ JSI_HOST_FUNCTION_IMPL(AudioRecorderHostObject, stop) {
   auto audioRecorder = audioRecorder_;
 
   return promiseVendor_->createAsyncPromise([audioRecorder]() -> PromiseResolver {
-    auto result = audioRecorder->stop();
+    auto result = ActiveRecorderHandle::global().stopAndReturnInfo(audioRecorder);
+
+    using returnValue = std::variant<jsi::Value, std::string>;
 
-    return [result =
-                std::move(result)](jsi::Runtime &runtime) -> std::variant<jsi::Value, std::string> {
+    return [result = std::move(result)](jsi::Runtime &runtime) -> returnValue {
       auto jsResult = jsi::Object(runtime);
 
       jsResult.setProperty(
@@ -92,15 +99,15 @@ JSI_HOST_FUNCTION_IMPL(AudioRecorderHostObject, stop) {
           jsi::String::createFromUtf8(runtime, result.is_ok() ? "success" : "error"));
 
       if (result.is_ok()) {
-        auto info = result.unwrap();
-        const auto &paths = std::get<0>(info);
-        auto pathsArray = jsi::Array(runtime, paths.size());
-        for (size_t i = 0; i < paths.size(); ++i) {
-          pathsArray.setValueAtIndex(runtime, i, jsi::String::createFromUtf8(runtime, paths[i]));
+        const auto &info = result.unwrap();
+        auto pathsArray = jsi::Array(runtime, info.paths.size());
+        for (size_t i = 0; i < info.paths.size(); ++i) {
+          pathsArray.setValueAtIndex(
+              runtime, i, jsi::String::createFromUtf8(runtime, info.paths[i]));
         }
         jsResult.setProperty(runtime, "paths", pathsArray);
-        jsResult.setProperty(runtime, "size", std::get<1>(info));
-        jsResult.setProperty(runtime, "duration", std::get<2>(info));
+        jsResult.setProperty(runtime, "size", info.size);
+        jsResult.setProperty(runtime, "duration", info.duration);
       } else {
         jsResult.setProperty(
             runtime, "message", jsi::String::createFromUtf8(runtime, result.unwrap_err()));

package/common/cpp/audioapi/HostObjects/inputs/AudioRecorderHostObject.h

@@ -18,6 +18,7 @@ class AudioRecorderHostObject : public JsiHostObject {
       const std::shared_ptr<AudioEventHandlerRegistry> &audioEventHandlerRegistry,
       jsi::Runtime *runtime,
       const std::shared_ptr<react::CallInvoker> &callInvoker);
+  ~AudioRecorderHostObject() override;
 
   JSI_HOST_FUNCTION_DECL(start);
   JSI_HOST_FUNCTION_DECL(stop);

package/common/cpp/audioapi/HostObjects/utils/JsEnumParser.cpp

@@ -150,6 +150,8 @@ AudioEvent audioEventFromString(const std::string &event) {
     return AudioEvent::RECORDER_ERROR;
   if (event == "bufferingStateChanged")
     return AudioEvent::BUFFERING_STATE_CHANGE;
+  if (event == "recordingNotificationStop")
+    return AudioEvent::RECORDING_NOTIFICATION_STOP;
 
   throw std::invalid_argument("Unknown audio event: " + event);
 }

package/common/cpp/audioapi/core/inputs/ActiveRecorderHandle.cpp

@@ -0,0 +1,117 @@
+#include <audioapi/core/inputs/ActiveRecorderHandle.h>
+
+#include <audioapi/core/inputs/AudioRecorder.h>
+
+#include <memory>
+#include <string>
+#include <tuple>
+#include <utility>
+
+namespace audioapi {
+
+ActiveRecorderHandle &ActiveRecorderHandle::global() {
+  static ActiveRecorderHandle handle;
+  return handle;
+}
+
+Result<NoneType, std::string> ActiveRecorderHandle::tryStart(
+    const std::shared_ptr<AudioRecorder> &recorder,
+    const std::string &fileNameOverride) {
+  if (!recorder) {
+    return Result<NoneType, std::string>::Err("Cannot start a null recorder");
+  }
+
+  std::scoped_lock lock(mutex_);
+
+  auto prevRecorder = recorder_.lock();
+  if (prevRecorder && prevRecorder != recorder && !prevRecorder->isIdle()) {
+    return Result<NoneType, std::string>::Err("Another recording is already in progress");
+  }
+
+  auto result = recorder->start(fileNameOverride);
+  if (result.is_ok()) {
+    recorder_ = recorder;
+  }
+  return result;
+}
+
+void ActiveRecorderHandle::clearRecorder() {
+  std::scoped_lock lock(mutex_);
+  recorder_.reset();
+}
+
+RecorderState ActiveRecorderHandle::currentState() const {
+  std::scoped_lock lock(mutex_);
+  const std::shared_ptr<AudioRecorder> recorder = recorder_.lock();
+  return stateOf(recorder);
+}
+
+bool ActiveRecorderHandle::isRecordingOngoing() const {
+  return currentState() != RecorderState::Idle;
+}
+
+RecorderState ActiveRecorderHandle::pause() {
+  std::scoped_lock lock(mutex_);
+  const std::shared_ptr<AudioRecorder> recorder = recorder_.lock();
+  if (recorder && recorder->isRecording()) {
+    recorder->pause();
+  }
+  return stateOf(recorder);
+}
+
+RecorderState ActiveRecorderHandle::resume() {
+  std::scoped_lock lock(mutex_);
+  const std::shared_ptr<AudioRecorder> recorder = recorder_.lock();
+  if (recorder && recorder->isPaused()) {
+    recorder->resume();
+  }
+  return stateOf(recorder);
+}
+
+Result<FileInfo, std::string> ActiveRecorderHandle::stopAndReturnInfo() {
+  std::scoped_lock lock(mutex_);
+  const std::shared_ptr<AudioRecorder> recorder = recorder_.lock();
+  if (!recorder) {
+    return Result<FileInfo, std::string>::Err("Recorder is not in recording state.");
+  }
+
+  auto result = recorder->stop();
+  if (!result.is_ok()) {
+    return Result<FileInfo, std::string>::Err(result.unwrap_err());
+  }
+
+  auto [paths, size, duration] = result.unwrap();
+  FileInfo recording{.paths = std::move(paths), .size = size, .duration = duration};
+  if (!recording.paths.empty()) {
+    lastResult_ = recording;
+  }
+  clearRecorder();
+  return Result<FileInfo, std::string>::Ok(std::move(recording));
+}
+
+Result<FileInfo, std::string> ActiveRecorderHandle::stopAndReturnInfo(
+    const std::shared_ptr<AudioRecorder> &expected) {
+  std::scoped_lock lock(mutex_);
+  if (recorder_.lock() != expected) {
+    // if we do not store provided recorder, it meands that it cannot be started, so it is in idle state
+    return Result<FileInfo, std::string>::Err("Recorder is not in recording state.");
+  }
+  return stopAndReturnInfo();
+}
+
+RecorderState ActiveRecorderHandle::stopAndReturnState() {
+  std::scoped_lock lock(mutex_);
+  stopAndReturnInfo();
+  return currentState();
+}
+
+std::optional<FileInfo> ActiveRecorderHandle::consumeLastRecordingResult() {
+  std::scoped_lock lock(mutex_);
+  return std::exchange(lastResult_, std::nullopt);
+}
+
+RecorderState ActiveRecorderHandle::stateOf(const std::shared_ptr<AudioRecorder> &recorder) {
+  return recorder ? recorder->getState() : RecorderState::Idle;
+}
+
+} // namespace audioapi

package/common/cpp/audioapi/core/inputs/ActiveRecorderHandle.h

@@ -0,0 +1,85 @@
+#pragma once
+
+#include <audioapi/core/inputs/RecorderState.h>
+#include <audioapi/utils/Macros.h>
+#include <audioapi/utils/Result.hpp>
+#include <memory>
+#include <mutex>
+#include <optional>
+#include <string>
+#include <vector>
+
+namespace audioapi {
+
+class AudioRecorder;
+
+struct FileInfo {
+  std::vector<std::string> paths;
+  double size;
+  double duration;
+};
+
+/// @brief The process-wide view of the recording session that is currently active.
+///
+/// The JavaScript host object owns the AudioRecorder. Native code still needs
+/// to reach that recorder when js is dead. This handle publishes a non-owning
+/// reference to the recorder so those actions can reach it.
+/// Only one recording session is published at a time.
+class ActiveRecorderHandle {
+ public:
+  static ActiveRecorderHandle &global();
+  DELETE_COPY_AND_MOVE(ActiveRecorderHandle);
+  ~ActiveRecorderHandle() = default;
+
+  /// @brief Starts @p recorder and stores it in the slot unless another non-idle
+  /// recorder already occupies it. The slot is assigned only if start succeeds.
+  Result<NoneType, std::string> tryStart(
+      const std::shared_ptr<AudioRecorder> &recorder,
+      const std::string &fileNameOverride);
+
+  /// @brief The state of the recorder in the slot, or Idle when the slot is empty.
+  [[nodiscard]] RecorderState currentState() const;
+
+  /// @brief True while a recording session is active; a paused recording counts as
+  /// ongoing because it still owns an open output file.
+  [[nodiscard]] bool isRecordingOngoing() const;
+
+  /// @brief Pauses an actively recording session; a no-op in any other state.
+  RecorderState pause();
+
+  /// @brief Resumes a paused session; a no-op in any other state.
+  RecorderState resume();
+
+  /// @brief Stops the occupant and returns AudioRecorder::stop()'s Result,
+  /// including the original error. On success with non-empty paths, stashes a
+  /// copy for consumeLastRecordingResult() and clears the slot. Blocks until
+  /// the output file is finalized. Because of this, don't call on a UI thread.
+  Result<FileInfo, std::string> stopAndReturnInfo();
+
+  /// @brief stopAndReturnInfo() if the slot still holds @p expected; otherwise
+  /// returns an error and does not stop the occupant.
+  Result<FileInfo, std::string> stopAndReturnInfo(const std::shared_ptr<AudioRecorder> &expected);
+
+  /// @brief Stops the occupant (same as stopAndReturnInfo) and returns the
+  /// resulting slot state. The stop Result is discarded; file info is still stashed.
+  RecorderState stopAndReturnState();
+
+  /// @brief Consume-once: returns the file info stashed by stopAndReturnInfo()
+  /// and clears it, or std::nullopt when nothing is stashed.
+  std::optional<FileInfo> consumeLastRecordingResult();
+
+ private:
+  ActiveRecorderHandle() = default;
+  friend struct ActiveRecorderHandleTestPeer;
+
+  static RecorderState stateOf(const std::shared_ptr<AudioRecorder> &recorder);
+
+  /// @brief Drops the slot without stopping the recorder.
+  void clearRecorder();
+
+  mutable std::recursive_mutex mutex_;
+  std::weak_ptr<AudioRecorder> recorder_;
+  std::optional<FileInfo> lastResult_;
+};
+
+} // namespace audioapi

package/common/cpp/audioapi/core/inputs/AudioRecorder.cpp

@@ -51,6 +51,14 @@ double AudioRecorder::getCurrentDuration() const {
   return duration;
 }
 
+RecorderState AudioRecorder::getState() const {
+  if (isIdle()) {
+    return RecorderState::Idle;
+  }
+
+  return isPaused() ? RecorderState::Paused : RecorderState::Recording;
+}
+
 bool AudioRecorder::usesCallback() const {
   return wantsCallback() && callbackOutputConfigured_.load(std::memory_order_acquire);
 }

package/common/cpp/audioapi/core/inputs/AudioRecorder.h

@@ -1,5 +1,6 @@
 #pragma once
 
+#include <audioapi/core/inputs/RecorderState.h>
 #include <audioapi/events/AudioEventHandlerRegistry.h>
 #include <audioapi/events/EventCaller.hpp>
 #include <audioapi/utils/AudioBuffer.hpp>
@@ -29,7 +30,6 @@ class AudioRecorder {
  public:
   using StopResult = Result<std::tuple<std::vector<std::string>, double, double>, std::string>;
 
-  enum class RecorderState : uint8_t { Idle = 0, Recording, Paused };
   explicit AudioRecorder(
       const std::shared_ptr<AudioEventHandlerRegistry> &audioEventHandlerRegistry)
       : audioEventHandlerRegistry_(audioEventHandlerRegistry),
@@ -86,6 +86,8 @@ class AudioRecorder {
   /// both platforms.
   bool isIdle() const;
 
+  RecorderState getState() const;
+
  protected:
   bool wantsCallback() const;
   bool wantsFileOutput() const;

package/common/cpp/audioapi/core/inputs/RecorderState.h

@@ -0,0 +1,13 @@
+#pragma once
+
+#include <cstdint>
+
+namespace audioapi {
+
+/// @brief Lifecycle state of an AudioRecorder.
+///
+/// Mirrored by Kotlin's com.swmansion.audioapi.system.RecorderState, which maps the
+/// values by ordinal — keep the two declarations in the same order.
+enum class RecorderState : uint8_t { Idle = 0, Recording, Paused };
+
+} // namespace audioapi

package/common/cpp/audioapi/core/sources/RecorderAdapterNode.h

@@ -57,7 +57,6 @@ class RecorderAdapterNode : public AudioNode {
   AudioBuffer overflowBuffer_;
   size_t overflowSize_ = 0;
 
-  std::atomic<bool> isInitialized_{false};
   /// Incremented around each processNode() call; adapterCleanup waits for quiescence.
   std::atomic<uint32_t> currentProcesses_{0};
 };

package/common/cpp/audioapi/core/utils/AudioRecorderCallback.cpp

@@ -76,14 +76,14 @@ void AudioRecorderCallback::invokeCallback(
   framesEmitted_ += numFrames;
 }
 
-void AudioRecorderCallback::assignOnErrorCallbackId(uint64_t callbackId) {
-  errorEvent_.assignCallbackId(callbackId);
-}
-
 /// @brief Invokes the error callback with the provided message.
 /// @param message The error message to be sent to the callback.
 void AudioRecorderCallback::invokeOnErrorCallback(const std::string &message) {
   errorEvent_.dispatch(StringPayload{.name = "message", .reason = message});
 }
 
+void AudioRecorderCallback::assignOnErrorCallbackId(uint64_t callbackId) {
+  errorEvent_.assignCallbackId(callbackId);
+}
+
 } // namespace audioapi

package/common/cpp/audioapi/core/utils/AudioRecorderCallback.h

@@ -4,6 +4,7 @@
 #include <audioapi/utils/AudioArray.hpp>
 #include <audioapi/utils/AudioBuffer.hpp>
 #include <audioapi/utils/CircularArray.hpp>
+#include <audioapi/utils/Macros.h>
 #include <audioapi/utils/Result.hpp>
 #include <audioapi/utils/SpscChannel.hpp>
 #include <audioapi/utils/TaskOffloader.hpp>
@@ -25,10 +26,7 @@ class AudioRecorderCallback {
       size_t bufferLength,
       int channelCount,
       uint64_t callbackId);
-  AudioRecorderCallback(const AudioRecorderCallback &) = delete;
-  AudioRecorderCallback(AudioRecorderCallback &&) = delete;
-  AudioRecorderCallback &operator=(const AudioRecorderCallback &) = delete;
-  AudioRecorderCallback &operator=(AudioRecorderCallback &&) = delete;
+  DELETE_COPY_AND_MOVE(AudioRecorderCallback);
   virtual ~AudioRecorderCallback();
 
   virtual void cleanup() = 0;