react-native-audio-api 0.13.5 → 0.13.6

package/android/src/main/cpp/audioapi/android/OnLoad.cpp

@@ -1,9 +1,13 @@
 #include <audioapi/android/AudioAPIModule.h>
+#include <audioapi/android/system/NativeRecorderControl.h>
 
 #include <fbjni/fbjni.h>
 
 using namespace audioapi;
 
 JNIEXPORT jint JNICALL JNI_OnLoad(JavaVM *vm, void *) {
-  return facebook::jni::initialize(vm, [] { AudioAPIModule::registerNatives(); });
+  return facebook::jni::initialize(vm, [] {
+    AudioAPIModule::registerNatives();
+    NativeRecorderControl::registerNatives();
+  });
 }

package/android/src/main/cpp/audioapi/android/core/AndroidAudioRecorder.cpp

@@ -224,27 +224,26 @@ AudioRecorder::StopResult AndroidAudioRecorder::stop() {
 }
 
 /// @brief Enables file output for the recorder with the specified properties.
-/// If the recorder is already active, it will prepare and open the file for writing immediately.
-/// Due to the nature of RN this might be called multiple times during recording session (especially during development),
-/// thus the requirement of handling the "already active" case.
+/// The file itself is created by the next start(). An active (recording or paused) session keeps
+/// the output it started with, so calling this during a session fails and changes nothing.
 /// This method should be called from the JS thread only.
 /// @param properties Properties defining the audio file format and encoding options.
-/// @returns On success, returns the file URI where the recording is being saved, otherwise returns an error message.
+/// @returns Ok when the properties were stored, otherwise an error message.
 Result<NoneType, std::string> AndroidAudioRecorder::enableFileOutput(
     std::shared_ptr<AudioFileProperties> properties) {
-  std::scoped_lock fileWriterLock(fileWriterMutex_);
-  fileProperties_ = properties;
-  fileOutputEnabled_.store(true, std::memory_order_release);
-  fileOutputConfigured_.store(false, std::memory_order_release);
+  // start() holds fileWriterMutex_ for its whole idle check and setup, so the
+  // idle test below cannot interleave with a session that is just starting.
+  std::scoped_lock lock(fileWriterMutex_);
 
   if (!isIdle()) {
-    auto writerResult = setupFileWriter(properties);
-    if (!writerResult.is_ok()) {
-      fileOutputEnabled_.store(false, std::memory_order_release);
-      return writerResult;
-    }
+    return Result<NoneType, std::string>::Err(
+        "File output cannot be changed while a recording session is active");
   }
 
+  fileProperties_ = properties;
+  fileOutputEnabled_.store(true, std::memory_order_release);
+  fileOutputConfigured_.store(false, std::memory_order_release);
+
   return Result<NoneType, std::string>::Ok(None);
 }
 
@@ -489,11 +488,11 @@ void AndroidAudioRecorder::onErrorAfterClose(oboe::AudioStream *stream, oboe::Re
     return;
   }
 
-  // Only restart if the recorder is still supposed to be running. Restarting
+  // Only reclaim the stream if the recorder still owns a session. Reopening
   // unconditionally resurrected stopped recorders, so any audio route change
   // (e.g. a Bluetooth headset connecting or disconnecting) turned the mic
   // back on after stop().
-  if (isIdle() || isPaused()) {
+  if (isIdle()) {
     return;
   }
 
@@ -508,8 +507,16 @@ void AndroidAudioRecorder::onErrorAfterClose(oboe::AudioStream *stream, oboe::Re
     return;
   }
 
+  // A paused session keeps its state across the reclaim: the fresh stream is
+  // left stopped until resume(), instead of forcing the recorder back to recording.
+  const auto stateBeforeTeardown = state_.load(std::memory_order_acquire);
+
   cleanup();
 
+  if (stateBeforeTeardown == RecorderState::Idle) {
+    return;
+  }
+
   auto streamResult = openAudioStream();
 
   if (!streamResult.is_ok()) {
@@ -518,8 +525,10 @@ void AndroidAudioRecorder::onErrorAfterClose(oboe::AudioStream *stream, oboe::Re
     return;
   }
 
-  mStream_->requestStart();
-  state_.store(RecorderState::Recording, std::memory_order_release);
+  if (stateBeforeTeardown == RecorderState::Recording) {
+    mStream_->requestStart();
+  }
+  state_.store(stateBeforeTeardown, std::memory_order_release);
 }
 
 } // namespace audioapi

package/android/src/main/cpp/audioapi/android/system/NativeRecorderControl.cpp

@@ -0,0 +1,41 @@
+#include <audioapi/android/system/NativeRecorderControl.h>
+
+#include <audioapi/core/inputs/ActiveRecorderHandle.h>
+#include <audioapi/core/inputs/RecorderState.h>
+
+namespace audioapi {
+
+namespace {
+
+jint toOrdinal(RecorderState state) {
+  return static_cast<jint>(state);
+}
+
+} // namespace
+
+void NativeRecorderControl::registerNatives() {
+  javaClassStatic()->registerNatives({
+      makeNativeMethod("stopActiveRecording", NativeRecorderControl::stopActiveRecording),
+      makeNativeMethod("pauseActiveRecording", NativeRecorderControl::pauseActiveRecording),
+      makeNativeMethod("resumeActiveRecording", NativeRecorderControl::resumeActiveRecording),
+      makeNativeMethod("currentRecorderState", NativeRecorderControl::currentRecorderState),
+  });
+}
+
+jint NativeRecorderControl::stopActiveRecording(jni::alias_ref<jni::JClass> /*clazz*/) {
+  return toOrdinal(ActiveRecorderHandle::global().stopAndReturnState());
+}
+
+jint NativeRecorderControl::pauseActiveRecording(jni::alias_ref<jni::JClass> /*clazz*/) {
+  return toOrdinal(ActiveRecorderHandle::global().pause());
+}
+
+jint NativeRecorderControl::resumeActiveRecording(jni::alias_ref<jni::JClass> /*clazz*/) {
+  return toOrdinal(ActiveRecorderHandle::global().resume());
+}
+
+jint NativeRecorderControl::currentRecorderState(jni::alias_ref<jni::JClass> /*clazz*/) {
+  return toOrdinal(ActiveRecorderHandle::global().currentState());
+}
+
+} // namespace audioapi

package/android/src/main/cpp/audioapi/android/system/NativeRecorderControl.h

@@ -0,0 +1,23 @@
+#pragma once
+
+#include <fbjni/fbjni.h>
+
+namespace audioapi {
+
+using namespace facebook;
+
+/// @brief JNI statics that let Kotlin reach the active recorder without a JS runtime,
+// e.g. from the recording-notification stop action after the app task was removed.
+class NativeRecorderControl : public jni::JavaClass<NativeRecorderControl> {
+ public:
+  static auto constexpr kJavaDescriptor = "Lcom/swmansion/audioapi/system/NativeRecorderControl;";
+
+  static void registerNatives();
+
+  static jint stopActiveRecording(jni::alias_ref<jni::JClass>);
+  static jint pauseActiveRecording(jni::alias_ref<jni::JClass>);
+  static jint resumeActiveRecording(jni::alias_ref<jni::JClass>);
+  static jint currentRecorderState(jni::alias_ref<jni::JClass>);
+};
+
+} // namespace audioapi

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

@@ -26,4 +26,5 @@ enum class AudioEvent {
   BUFFER_ENDED,
   RECORDER_ERROR,
   BUFFERING_STATE_CHANGE,
+  RECORDING_NOTIFICATION_STOP,
 }

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

@@ -4,11 +4,15 @@ import android.app.Notification
 import android.app.NotificationChannel
 import android.app.NotificationManager
 import android.app.Service
+import android.content.ComponentName
 import android.content.Context
 import android.content.Intent
+import android.content.pm.PackageManager
+import android.content.pm.ServiceInfo
 import android.os.Build
 import android.os.IBinder
 import android.util.Log
+import androidx.annotation.RequiresApi
 import androidx.core.app.NotificationCompat
 import com.swmansion.audioapi.system.MediaSessionManager.CHANNEL_ID
 import com.swmansion.audioapi.system.notification.NotificationRegistry
@@ -23,10 +27,18 @@ class CentralizedForegroundService : Service() {
     private const val TAG = "CentralizedForegroundService"
     const val ACTION_START = "START_FOREGROUND"
     const val ACTION_STOP = "STOP_FOREGROUND"
+
+    private const val PLACEHOLDER_CHANNEL_ID = "audio_service_placeholder"
+    private const val PLACEHOLDER_NOTIFICATION_ID = 300
   }
 
   override fun onBind(intent: Intent?): IBinder? = null
 
+  override fun onCreate() {
+    super.onCreate()
+    ForegroundServiceManager.onServiceCreated()
+  }
+
   override fun onStartCommand(
     intent: Intent?,
     flags: Int,
@@ -38,34 +50,39 @@ class CentralizedForegroundService : Service() {
       }
 
       ACTION_STOP -> {
-        stopForeground(STOP_FOREGROUND_REMOVE)
-        stopSelf()
+        if (stopSelfResult(startId)) {
+          stopForeground(STOP_FOREGROUND_REMOVE)
+        } else {
+          Log.d(TAG, "Stop superseded by a newer start request, service stays in the foreground")
+        }
       }
     }
     return START_NOT_STICKY
   }
 
+  override fun onTaskRemoved(rootIntent: Intent?) {
+    // Fires only when the app opted into android:stopWithTask="false" — the service
+    // intentionally outlives the removed task.
+    Log.i(TAG, "App task removed, foreground service keeps running")
+    super.onTaskRemoved(rootIntent)
+  }
+
   private fun startForegroundWithNotification() {
     try {
-      createNotificationChannelIfNeeded()
+      createLowImportanceChannelIfNeeded(CHANNEL_ID, "Audio Service", "Background audio processing")
 
       // Get the first available notification
       val existingNotification = findExistingNotification()
       if (existingNotification == null) {
-        Log.w(TAG, "No notification available to start foreground service")
+        // The service was started with Context.startForegroundService(), so startForeground()
+        // must still be called — skipping it crashes with ForegroundServiceDidNotStartInTimeException.
+        Log.w(TAG, "No notification available, starting foreground with a placeholder and stopping")
+        startForegroundWithPlaceholderAndStop()
         return
       }
 
       val (notificationId, notification) = existingNotification
-
-      if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.Q) {
-        startForeground(
-          notificationId,
-          notification,
-        )
-      } else {
-        startForeground(notificationId, notification)
-      }
+      startForegroundCompat(notificationId, notification)
 
       Log.d(TAG, "Centralized foreground service started with notification ID: $notificationId")
     } catch (e: Exception) {
@@ -73,6 +90,87 @@ class CentralizedForegroundService : Service() {
     }
   }
 
+  private fun startForegroundWithPlaceholderAndStop() {
+    createLowImportanceChannelIfNeeded(
+      PLACEHOLDER_CHANNEL_ID,
+      "Audio Service Placeholder",
+      "Short-lived notification shown while the audio service shuts down",
+    )
+
+    val placeholderNotification =
+      NotificationCompat
+        .Builder(this, PLACEHOLDER_CHANNEL_ID)
+        .setSmallIcon(android.R.drawable.ic_media_play)
+        .setContentTitle("Audio service")
+        .setPriority(NotificationCompat.PRIORITY_LOW)
+        .build()
+
+    try {
+      startForegroundCompat(PLACEHOLDER_NOTIFICATION_ID, placeholderNotification)
+    } finally {
+      // The service must exit even when startForeground throws (e.g. API 34+
+      // ForegroundServiceStartNotAllowedException) — otherwise the system kills the
+      // process with ForegroundServiceDidNotStartInTimeException. Unlike ACTION_STOP this
+      // exit is unconditional, because there is nothing to keep in the foreground; a start
+      // racing it is picked up again by ForegroundServiceManager.onServiceDestroyed.
+      stopForeground(STOP_FOREGROUND_REMOVE)
+      stopSelf()
+    }
+  }
+
+  private fun startForegroundCompat(
+    notificationId: Int,
+    notification: Notification,
+  ) {
+    if (Build.VERSION.SDK_INT < Build.VERSION_CODES.Q) {
+      startForeground(notificationId, notification)
+      return
+    }
+
+    val serviceTypes = activeNotificationServiceTypes() and manifestDeclaredServiceTypes()
+    when {
+      serviceTypes != 0 -> {
+        startForeground(notificationId, notification, serviceTypes)
+      }
+
+      Build.VERSION.SDK_INT >= Build.VERSION_CODES.UPSIDE_DOWN_CAKE -> {
+        startForeground(notificationId, notification, ServiceInfo.FOREGROUND_SERVICE_TYPE_MANIFEST)
+      }
+
+      else -> {
+        startForeground(notificationId, notification)
+      }
+    }
+  }
+
+  @RequiresApi(Build.VERSION_CODES.Q)
+  private fun activeNotificationServiceTypes(): Int {
+    var serviceTypes = 0
+
+    if (NotificationRegistry.getBuiltNotification(PlaybackNotification.ID) != null) {
+      serviceTypes = serviceTypes or ServiceInfo.FOREGROUND_SERVICE_TYPE_MEDIA_PLAYBACK
+    }
+
+    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.R &&
+      NotificationRegistry.getBuiltNotification(RecordingNotification.ID) != null
+    ) {
+      serviceTypes = serviceTypes or ServiceInfo.FOREGROUND_SERVICE_TYPE_MICROPHONE
+    }
+
+    return serviceTypes
+  }
+
+  @RequiresApi(Build.VERSION_CODES.Q)
+  private fun manifestDeclaredServiceTypes(): Int =
+    try {
+      packageManager
+        .getServiceInfo(ComponentName(this, CentralizedForegroundService::class.java), PackageManager.GET_META_DATA)
+        .foregroundServiceType
+    } catch (e: PackageManager.NameNotFoundException) {
+      Log.w(TAG, "Unable to read foreground service types declared in the manifest: ${e.message}")
+      0
+    }
+
   private fun findExistingNotification(): Pair<Int, Notification>? {
     // Check for playback notification first (priority)
     NotificationRegistry.getBuiltNotification(PlaybackNotification.ID)?.let {
@@ -86,28 +184,36 @@ class CentralizedForegroundService : Service() {
     return null
   }
 
-  private fun createNotificationChannelIfNeeded() {
-    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
-      val notificationManager = getSystemService(Context.NOTIFICATION_SERVICE) as NotificationManager
-
-      if (notificationManager.getNotificationChannel(CHANNEL_ID) == null) {
-        val channel =
-          NotificationChannel(
-            CHANNEL_ID,
-            "Audio Service",
-            NotificationManager.IMPORTANCE_LOW,
-          ).apply {
-            description = "Background audio processing"
-            setShowBadge(false)
-            lockscreenVisibility = NotificationCompat.VISIBILITY_PUBLIC
-          }
-        notificationManager.createNotificationChannel(channel)
-      }
+  private fun createLowImportanceChannelIfNeeded(
+    id: String,
+    name: String,
+    channelDescription: String,
+  ) {
+    if (Build.VERSION.SDK_INT < Build.VERSION_CODES.O) {
+      return
     }
+
+    val notificationManager = getSystemService(Context.NOTIFICATION_SERVICE) as NotificationManager
+    if (notificationManager.getNotificationChannel(id) != null) {
+      return
+    }
+
+    val channel =
+      NotificationChannel(
+        id,
+        name,
+        NotificationManager.IMPORTANCE_LOW,
+      ).apply {
+        description = channelDescription
+        setShowBadge(false)
+        lockscreenVisibility = NotificationCompat.VISIBILITY_PUBLIC
+      }
+    notificationManager.createNotificationChannel(channel)
   }
 
   override fun onDestroy() {
     Log.d(TAG, "Centralized foreground service destroyed")
+    ForegroundServiceManager.onServiceDestroyed()
     super.onDestroy()
   }
 }

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

@@ -10,6 +10,11 @@ import java.lang.ref.WeakReference
 /**
  * Centralized manager for foreground service lifecycle.
  * Handles starting/stopping foreground service based on active subscribers.
+ *
+ * Subscribe and unsubscribe run on the caller's thread (the JS thread, or the recording
+ * notification receiver's executor), while the service's own callbacks run on the main
+ * thread. The manager therefore tracks what it asked for ([startIntentSent]) separately
+ * from what the service reports ([isServiceRunning]), and never infers one from the other.
  */
 object ForegroundServiceManager {
   private const val TAG = "ForegroundServiceManager"
@@ -17,6 +22,11 @@ object ForegroundServiceManager {
   private lateinit var reactContext: WeakReference<ReactApplicationContext>
   private val subscribers = mutableSetOf<BaseNotification>()
   private var isServiceRunning = false
+  private var startIntentSent = false
+
+  /** Set while a restart triggered by [onServiceDestroyed] is in flight, so a service that
+   * never comes up cannot be restarted in a loop. */
+  private var restartAfterDestroyPending = false
 
   fun initialize(reactContext: WeakReference<ReactApplicationContext>) {
     this.reactContext = reactContext
@@ -49,21 +59,50 @@ object ForegroundServiceManager {
   /**
    * Get count of active subscribers
    */
+  @Synchronized
   fun getSubscriberCount(): Int = subscribers.size
 
   /**
    * Check if service is currently running
    */
+  @Synchronized
   fun isServiceRunning(): Boolean = isServiceRunning
 
+  /**
+   * Called from [CentralizedForegroundService.onCreate].
+   */
+  @Synchronized
+  internal fun onServiceCreated() {
+    isServiceRunning = true
+    restartAfterDestroyPending = false
+  }
+
+  @Synchronized
+  internal fun onServiceDestroyed() {
+    isServiceRunning = false
+
+    val stillWanted = startIntentSent && subscribers.isNotEmpty() && !restartAfterDestroyPending
+    // The instance is gone, so the previous request is spent either way: anything that
+    // needs the service from here on has to ask for it again.
+    startIntentSent = false
+
+    if (!stillWanted) {
+      return
+    }
+
+    Log.w(TAG, "Service destroyed while ${subscribers.size} subscriber(s) still need it, restarting")
+    restartAfterDestroyPending = true
+    startForegroundService()
+  }
+
   private fun startServiceIfNeeded() {
-    if (!isServiceRunning && subscribers.isNotEmpty()) {
+    if (subscribers.isNotEmpty()) {
       startForegroundService()
     }
   }
 
   private fun stopServiceIfNotNeeded() {
-    if (isServiceRunning && subscribers.isEmpty()) {
+    if ((startIntentSent || isServiceRunning) && subscribers.isEmpty()) {
       stopForegroundService()
     }
   }
@@ -81,14 +120,15 @@ object ForegroundServiceManager {
         context.startService(intent)
       }
 
-      isServiceRunning = true
-      Log.d(TAG, "Centralized foreground service started")
+      startIntentSent = true
     } catch (e: Exception) {
       Log.e(TAG, "Error starting foreground service: ${e.message}", e)
     }
   }
 
   private fun stopForegroundService() {
+    startIntentSent = false
+
     val context = reactContext.get() ?: return
 
     try {
@@ -96,8 +136,6 @@ object ForegroundServiceManager {
       intent.action = CentralizedForegroundService.ACTION_STOP
 
       context.startService(intent)
-      isServiceRunning = false
-      Log.d(TAG, "Centralized foreground service stopped")
     } catch (e: Exception) {
       Log.e(TAG, "Error stopping foreground service: ${e.message}", e)
     }
@@ -106,12 +144,9 @@ object ForegroundServiceManager {
   /**
    * Cleanup all subscribers and stop service
    */
+  @Synchronized
   fun cleanup() {
-    synchronized(this) {
-      subscribers.clear()
-      if (isServiceRunning) {
-        stopForegroundService()
-      }
-    }
+    subscribers.clear()
+    stopServiceIfNotNeeded()
   }
 }

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

@@ -24,6 +24,7 @@ import com.swmansion.audioapi.system.PermissionRequestListener.Companion.RECORDI
 import com.swmansion.audioapi.system.notification.NotificationRegistry
 import com.swmansion.audioapi.system.notification.PlaybackNotification
 import com.swmansion.audioapi.system.notification.PlaybackNotificationReceiver
+import com.swmansion.audioapi.system.notification.RecordingNotification
 import java.lang.ref.WeakReference
 
 object MediaSessionManager {
@@ -262,5 +263,27 @@ object MediaSessionManager {
     notificationRegistry.hideNotification(key)
   }
 
+  /**
+   * Used by the  notification stop action, which also
+   * unwinds the foreground service through the registry's unsubscribe path.
+   */
+  fun hideRecordingNotification() {
+    if (!::notificationRegistry.isInitialized) {
+      return
+    }
+    notificationRegistry.hideNotification(RecordingNotification.ID)
+  }
+
+  /**
+   * Used by native-initiated pause/resume, which can't go through [showNotification] — there
+   * is no JS to supply options.
+   */
+  fun setRecordingNotificationPaused(paused: Boolean) {
+    if (!::notificationRegistry.isInitialized) {
+      return
+    }
+    notificationRegistry.updateRecordingNotificationPausedState(paused)
+  }
+
   fun isNotificationActive(key: String): Boolean = notificationRegistry.isNotificationActive(key)
 }

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

@@ -0,0 +1,39 @@
+package com.swmansion.audioapi.system
+
+/**
+ * Direct access to the active C++ recorder, independent of the JS runtime.
+ * This is what allows the recording-notification stop action to end a recording
+ * after the app task has been removed.
+ */
+object NativeRecorderControl {
+  init {
+    System.loadLibrary("react-native-audio-api")
+  }
+
+  /**
+   * The file info is stashed natively for
+   * `AudioRecorder.consumeLastRecordingResult()` on the JS side.
+   */
+  fun stop(): RecorderState = RecorderState.fromOrdinal(stopActiveRecording())
+
+  /** Pauses an actively recording session; a no-op in any other state. */
+  fun pause(): RecorderState = RecorderState.fromOrdinal(pauseActiveRecording())
+
+  /** Resumes a paused session; a no-op in any other state. */
+  fun resume(): RecorderState = RecorderState.fromOrdinal(resumeActiveRecording())
+
+  /** Non-blocking read of the recorder state; [RecorderState.IDLE] when there is none. */
+  fun currentState(): RecorderState = RecorderState.fromOrdinal(currentRecorderState())
+
+  @JvmStatic
+  private external fun stopActiveRecording(): Int
+
+  @JvmStatic
+  private external fun pauseActiveRecording(): Int
+
+  @JvmStatic
+  private external fun resumeActiveRecording(): Int
+
+  @JvmStatic
+  private external fun currentRecorderState(): Int
+}

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

@@ -0,0 +1,17 @@
+package com.swmansion.audioapi.system
+
+/**
+ * Lifecycle state of the native audio recorder.
+ *
+ * Mirrors C++ `audioapi::RecorderState`
+ */
+enum class RecorderState {
+  IDLE,
+  RECORDING,
+  PAUSED,
+  ;
+
+  companion object {
+    fun fromOrdinal(ordinal: Int): RecorderState = entries.getOrElse(ordinal) { IDLE }
+  }
+}