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

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

@@ -2,7 +2,11 @@
 #include <audioapi/android/core/AndroidAudioRecorder.h>
 #include <audioapi/android/core/utils/AndroidFileWriterBackend.h>
 #include <audioapi/android/core/utils/AndroidRecorderCallback.h>
+
+#if !RN_AUDIO_API_FFMPEG_DISABLED
 #include <audioapi/android/core/utils/ffmpegBackend/FFmpegFileWriter.h>
+#endif // RN_AUDIO_API_FFMPEG_DISABLED
+
 #include <audioapi/android/core/utils/miniaudioBackend/MiniAudioFileWriter.h>
 #include <audioapi/core/sources/RecorderAdapterNode.h>
 #include <audioapi/core/utils/Constants.h>
@@ -29,6 +33,25 @@ AndroidAudioRecorder::AndroidAudioRecorder(
 }
 
 AndroidAudioRecorder::~AndroidAudioRecorder() {
+  {
+    std::scoped_lock dtorLock(callbackMutex_, fileWriterMutex_, adapterNodeMutex_);
+
+    if (usesFileOutput()) {
+      fileOutputEnabled_.store(false, std::memory_order_release);
+      fileWriter_->closeFile();
+    }
+
+    if (usesCallback()) {
+      callbackOutputEnabled_.store(false, std::memory_order_release);
+      dataCallback_->cleanup();
+    }
+
+    if (isConnected()) {
+      isConnected_.store(false, std::memory_order_release);
+      adapterNode_->cleanup();
+    }
+  }
+
   nativeAudioRecorder_.release();
 
   if (mStream_) {
@@ -86,7 +109,7 @@ Result<std::string, std::string> AndroidAudioRecorder::start() {
 
   if (usesFileOutput()) {
     auto fileResult =
-        std::dynamic_pointer_cast<AndroidFileWriterBackend>(fileWriter_)
+        std::static_pointer_cast<AndroidFileWriterBackend>(fileWriter_)
             ->openFile(streamSampleRate_, streamChannelCount_, streamMaxBufferSizeInFrames_);
 
     if (!fileResult.is_ok()) {
@@ -98,7 +121,7 @@ Result<std::string, std::string> AndroidAudioRecorder::start() {
   }
 
   if (usesCallback()) {
-    std::dynamic_pointer_cast<AndroidRecorderCallback>(dataCallback_)
+    std::static_pointer_cast<AndroidRecorderCallback>(dataCallback_)
         ->prepare(streamSampleRate_, streamChannelCount_, streamMaxBufferSizeInFrames_);
   }
 
@@ -172,13 +195,18 @@ Result<std::string, std::string> AndroidAudioRecorder::enableFileOutput(
   if (properties->format == AudioFileProperties::Format::WAV) {
     fileWriter_ = std::make_shared<MiniAudioFileWriter>(audioEventHandlerRegistry_, properties);
   } else {
+#if !RN_AUDIO_API_FFMPEG_DISABLED
     fileWriter_ = std::make_shared<android::ffmpeg::FFmpegAudioFileWriter>(
         audioEventHandlerRegistry_, properties);
+#else
+    return Result<std::string, std::string>::Err(
+        "FFmpeg backend is disabled. Cannot create file writer for the requested format. Use WAV format instead.");
+#endif
   }
 
   if (!isIdle()) {
     auto fileResult =
-        std::dynamic_pointer_cast<AndroidFileWriterBackend>(fileWriter_)
+        std::static_pointer_cast<AndroidFileWriterBackend>(fileWriter_)
             ->openFile(streamSampleRate_, streamChannelCount_, streamMaxBufferSizeInFrames_);
 
     if (!fileResult.is_ok()) {
@@ -227,7 +255,7 @@ Result<NoneType, std::string> AndroidAudioRecorder::setOnAudioReadyCallback(
       audioEventHandlerRegistry_, sampleRate, bufferLength, channelCount, callbackId);
 
   if (!isIdle()) {
-    std::dynamic_pointer_cast<AndroidRecorderCallback>(dataCallback_)
+    std::static_pointer_cast<AndroidRecorderCallback>(dataCallback_)
         ->prepare(streamSampleRate_, streamChannelCount_, streamMaxBufferSizeInFrames_);
   }
 
@@ -271,14 +299,14 @@ oboe::DataCallbackResult AndroidAudioRecorder::onAudioReady(
 
   if (usesFileOutput()) {
     if (auto fileWriterLock = Locker::tryLock(fileWriterMutex_)) {
-      std::dynamic_pointer_cast<AndroidFileWriterBackend>(fileWriter_)
+      std::static_pointer_cast<AndroidFileWriterBackend>(fileWriter_)
           ->writeAudioData(audioData, numFrames);
     }
   }
 
   if (usesCallback()) {
     if (auto callbackLock = Locker::tryLock(callbackMutex_)) {
-      std::dynamic_pointer_cast<AndroidRecorderCallback>(dataCallback_)
+      std::static_pointer_cast<AndroidRecorderCallback>(dataCallback_)
           ->receiveAudioData(audioData, numFrames);
     }
   }

package/android/src/main/cpp/audioapi/android/core/utils/ffmpegBackend/FFmpegFileWriter.cpp

@@ -1,3 +1,5 @@
+#if !RN_AUDIO_API_FFMPEG_DISABLED
+
 extern "C" {
 #include <libavcodec/avcodec.h>
 #include <libavformat/avformat.h>
@@ -508,3 +510,5 @@ CloseFileResult FFmpegAudioFileWriter::finalizeOutput() {
 }
 
 } // namespace audioapi::android::ffmpeg
+
+#endif // RN_AUDIO_API_FFMPEG_DISABLED

package/android/src/main/cpp/audioapi/android/core/utils/ffmpegBackend/ptrs.hpp

@@ -1,3 +1,7 @@
+#if !RN_AUDIO_API_FFMPEG_DISABLED
+
+#pragma once
+
 extern "C" {
 #include <libavcodec/avcodec.h>
 #include <libavformat/avformat.h>
@@ -46,3 +50,7 @@ template<> inline void AvDtor<AVAudioFifo>::operator()(AVAudioFifo* fifo) const
 }
 
 } // namespace audioapi::android::ffmpeg
+
+#else
+
+#endif // RN_AUDIO_API_FFMPEG_DISABLED

package/android/src/main/cpp/audioapi/android/core/utils/ffmpegBackend/utils.cpp

@@ -1,3 +1,5 @@
+#if !RN_AUDIO_API_FFMPEG_DISABLED
+
 extern "C" {
 #include <libavcodec/avcodec.h>
 }
@@ -108,3 +110,5 @@ std::string parseErrorCode(int errorCode) {
 }
 
 } // namespace audioapi::android::ffmpeg
+
+#endif // RN_AUDIO_API_FFMPEG_DISABLED

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

@@ -3,6 +3,7 @@
 #include <audioapi/android/core/utils/AndroidFileWriterBackend.h>
 #include <audioapi/libs/miniaudio/miniaudio.h>
 
+#include <atomic>
 #include <string>
 #include <memory>
 #include <tuple>

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.Arguments
 import com.facebook.react.bridge.LifecycleEventListener
 import com.facebook.react.bridge.Promise
 import com.facebook.react.bridge.ReactApplicationContext
@@ -9,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
@@ -86,7 +88,8 @@ class AudioAPIModule(
 
   override fun invalidate() {
     reactContext.get()?.removeLifecycleEventListener(this)
-    // think about cleaning up resources, singletons etc.
+    // Cleanup foreground service manager
+    ForegroundServiceManager.cleanup()
   }
 
   override fun getDevicePreferredSampleRate(): Double = MediaSessionManager.getDevicePreferredSampleRate()
@@ -111,21 +114,6 @@ class AudioAPIModule(
     // nothing 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 observeAudioInterruptions(enabled: Boolean) {
     MediaSessionManager.observeAudioInterruptions(enabled)
   }
@@ -147,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)
+    }
+  }
 }

package/android/src/main/java/com/swmansion/audioapi/core/NativeAudioPlayer.kt

@@ -1,24 +1,26 @@
 package com.swmansion.audioapi.core
 
 import com.facebook.common.internal.DoNotStrip
-import com.swmansion.audioapi.system.MediaSessionManager
+import com.swmansion.audioapi.system.ForegroundServiceManager
+import java.util.UUID
 
 @DoNotStrip
 class NativeAudioPlayer {
-  private var sourceNodeId: String? = null
+  private var playerId: String? = null
 
   @DoNotStrip
   fun start() {
-    this.sourceNodeId = MediaSessionManager.attachAudioPlayer(this)
-    MediaSessionManager.startForegroundServiceIfNecessary()
+    if (playerId == null) {
+      playerId = UUID.randomUUID().toString()
+      ForegroundServiceManager.subscribe("player_$playerId")
+    }
   }
 
   @DoNotStrip
   fun stop() {
-    this.sourceNodeId?.let {
-      MediaSessionManager.detachAudioPlayer(it)
-      this.sourceNodeId = null
+    playerId?.let {
+      ForegroundServiceManager.unsubscribe("player_$it")
+      playerId = null
     }
-    MediaSessionManager.stopForegroundServiceIfNecessary()
   }
 }

package/android/src/main/java/com/swmansion/audioapi/core/NativeAudioRecorder.kt

@@ -1,24 +1,26 @@
 package com.swmansion.audioapi.core
 
 import com.facebook.common.internal.DoNotStrip
-import com.swmansion.audioapi.system.MediaSessionManager
+import com.swmansion.audioapi.system.ForegroundServiceManager
+import java.util.UUID
 
 @DoNotStrip
 class NativeAudioRecorder {
-  private var inputNodeId: String? = null
+  private var recorderId: String? = null
 
   @DoNotStrip
   fun start() {
-    this.inputNodeId = MediaSessionManager.attachAudioRecorder(this)
-    MediaSessionManager.startForegroundServiceIfNecessary()
+    if (recorderId == null) {
+      recorderId = UUID.randomUUID().toString()
+      ForegroundServiceManager.subscribe("recorder_$recorderId")
+    }
   }
 
   @DoNotStrip
   fun stop() {
-    this.inputNodeId?.let {
-      MediaSessionManager.detachAudioRecorder(it)
-      this.inputNodeId = null
+    recorderId?.let {
+      ForegroundServiceManager.unsubscribe("recorder_$it")
+      recorderId = null
     }
-    MediaSessionManager.stopForegroundServiceIfNecessary()
   }
 }

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

@@ -11,7 +11,6 @@ import java.util.HashMap
 class AudioFocusListener(
   private val audioManager: WeakReference<AudioManager>,
   private val audioAPIModule: WeakReference<AudioAPIModule>,
-  private val lockScreenManager: WeakReference<LockScreenManager>,
 ) : AudioManager.OnAudioFocusChangeListener {
   private var focusRequest: AudioFocusRequest? = null
 
@@ -22,7 +21,7 @@ class AudioFocusListener(
         val body =
           HashMap<String, Any>().apply {
             put("type", "began")
-            put("shouldResume", false)
+            put("isTransient", false)
           }
         audioAPIModule.get()?.invokeHandlerWithEventNameAndEventBody("interruption", body)
       }
@@ -31,7 +30,7 @@ class AudioFocusListener(
         val body =
           HashMap<String, Any>().apply {
             put("type", "began")
-            put("shouldResume", false)
+            put("isTransient", true)
           }
         audioAPIModule.get()?.invokeHandlerWithEventNameAndEventBody("interruption", body)
       }
@@ -40,7 +39,7 @@ class AudioFocusListener(
         val body =
           HashMap<String, Any>().apply {
             put("type", "ended")
-            put("shouldResume", true)
+            put("isTransient", false)
           }
         audioAPIModule.get()?.invokeHandlerWithEventNameAndEventBody("interruption", body)
       }

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

@@ -0,0 +1,128 @@
+package com.swmansion.audioapi.system
+
+import android.app.Notification
+import android.app.NotificationChannel
+import android.app.NotificationManager
+import android.app.Service
+import android.content.Context
+import android.content.Intent
+import android.content.pm.ServiceInfo
+import android.os.Build
+import android.os.IBinder
+import android.util.Log
+import androidx.core.app.NotificationCompat
+import com.swmansion.audioapi.system.MediaSessionManager.CHANNEL_ID
+import com.swmansion.audioapi.system.notification.NotificationRegistry
+
+/**
+ * Centralized foreground service that can be used by any component that needs foreground capabilities.
+ */
+class CentralizedForegroundService : Service() {
+  companion object {
+    private const val TAG = "CentralizedForegroundService"
+    private const val NOTIFICATION_ID = 100
+    const val ACTION_START = "START_FOREGROUND"
+    const val ACTION_STOP = "STOP_FOREGROUND"
+  }
+
+  override fun onBind(intent: Intent?): IBinder? = null
+
+  override fun onStartCommand(
+    intent: Intent?,
+    flags: Int,
+    startId: Int,
+  ): Int {
+    when (intent?.action) {
+      ACTION_START -> {
+        startForegroundWithNotification()
+      }
+
+      ACTION_STOP -> {
+        stopForeground(STOP_FOREGROUND_REMOVE)
+        stopSelf()
+      }
+    }
+    return START_NOT_STICKY
+  }
+
+  private fun startForegroundWithNotification() {
+    try {
+      createNotificationChannelIfNeeded()
+
+      // Try to use an existing notification first
+      val existingNotification = findExistingNotification()
+      val (notificationId, notification) =
+        if (existingNotification != null) {
+          existingNotification
+        } else {
+          // Fallback to default service notification
+          NOTIFICATION_ID to createServiceNotification()
+        }
+
+      if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.Q) {
+        startForeground(
+          notificationId,
+          notification,
+          ServiceInfo.FOREGROUND_SERVICE_TYPE_MEDIA_PLAYBACK,
+        )
+      } else {
+        startForeground(notificationId, notification)
+      }
+
+      Log.d(TAG, "Centralized foreground service started with notification ID: $notificationId")
+    } catch (e: Exception) {
+      Log.e(TAG, "Error starting foreground service: ${e.message}", e)
+    }
+  }
+
+  private fun findExistingNotification(): Pair<Int, Notification>? {
+    // Check for recording notification first (priority)
+    NotificationRegistry.getBuiltNotification(101)?.let {
+      return 101 to it
+    }
+
+    // Check for playback notification
+    NotificationRegistry.getBuiltNotification(100)?.let {
+      return 100 to it
+    }
+
+    return null
+  }
+
+  private fun createServiceNotification(): Notification =
+    NotificationCompat
+      .Builder(this, CHANNEL_ID)
+      .setContentTitle("Audio Service")
+      .setContentText("Audio processing in progress")
+      .setSmallIcon(android.R.drawable.ic_btn_speak_now)
+      .setPriority(NotificationCompat.PRIORITY_LOW)
+      .setVisibility(NotificationCompat.VISIBILITY_PUBLIC)
+      .setOngoing(true)
+      .setAutoCancel(false)
+      .build()
+
+  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)
+      }
+    }
+  }
+
+  override fun onDestroy() {
+    Log.d(TAG, "Centralized foreground service destroyed")
+    super.onDestroy()
+  }
+}