react-native-audio-api 0.11.0-nightly-db51488-20251208 → 0.11.0-nightly-6ba0571-20251209

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.PermissionRequestListener
 import java.lang.ref.WeakReference
@@ -84,7 +86,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()
@@ -109,21 +112,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)
   }
@@ -145,7 +133,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,52 +11,37 @@ 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 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")
-            put("shouldResume", false)
+            put("isTransient", false)
           }
         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("isTransient", true)
           }
         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
+        val body =
+          HashMap<String, Any>().apply {
+            put("type", "ended")
+            put("isTransient", false)
+          }
+        audioAPIModule.get()?.invokeHandlerWithEventNameAndEventBody("interruption", body)
       }
     }
   }

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

@@ -0,0 +1,127 @@
+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()
+  }
+}

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

@@ -0,0 +1,116 @@
+package com.swmansion.audioapi.system
+
+import android.content.Intent
+import android.os.Build
+import android.util.Log
+import com.facebook.react.bridge.ReactApplicationContext
+import java.lang.ref.WeakReference
+
+/**
+ * Centralized manager for foreground service lifecycle.
+ * Handles starting/stopping foreground service based on active subscribers.
+ */
+object ForegroundServiceManager {
+  private const val TAG = "ForegroundServiceManager"
+
+  private lateinit var reactContext: WeakReference<ReactApplicationContext>
+  private val subscribers = mutableSetOf<String>()
+  private var isServiceRunning = false
+
+  fun initialize(reactContext: WeakReference<ReactApplicationContext>) {
+    this.reactContext = reactContext
+  }
+
+  /**
+   * Subscribe to foreground service. Service will start if not already running.
+   * @param subscriberId Unique identifier for the subscriber
+   */
+  @Synchronized
+  fun subscribe(subscriberId: String) {
+    if (subscribers.add(subscriberId)) {
+      Log.d(TAG, "Subscriber added: $subscriberId (total: ${subscribers.size})")
+      startServiceIfNeeded()
+    }
+  }
+
+  /**
+   * Unsubscribe from foreground service. Service will stop if no more subscribers.
+   * @param subscriberId Unique identifier for the subscriber
+   */
+  @Synchronized
+  fun unsubscribe(subscriberId: String) {
+    if (subscribers.remove(subscriberId)) {
+      Log.d(TAG, "Subscriber removed: $subscriberId (total: ${subscribers.size})")
+      stopServiceIfNotNeeded()
+    }
+  }
+
+  /**
+   * Get count of active subscribers
+   */
+  fun getSubscriberCount(): Int = subscribers.size
+
+  /**
+   * Check if service is currently running
+   */
+  fun isServiceRunning(): Boolean = isServiceRunning
+
+  private fun startServiceIfNeeded() {
+    if (!isServiceRunning && subscribers.isNotEmpty()) {
+      startForegroundService()
+    }
+  }
+
+  private fun stopServiceIfNotNeeded() {
+    if (isServiceRunning && subscribers.isEmpty()) {
+      stopForegroundService()
+    }
+  }
+
+  private fun startForegroundService() {
+    val context = reactContext.get() ?: return
+
+    try {
+      val intent = Intent(context, CentralizedForegroundService::class.java)
+      intent.action = CentralizedForegroundService.ACTION_START
+
+      if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
+        context.startForegroundService(intent)
+      } else {
+        context.startService(intent)
+      }
+
+      isServiceRunning = true
+      Log.d(TAG, "Centralized foreground service started")
+    } catch (e: Exception) {
+      Log.e(TAG, "Error starting foreground service: ${e.message}", e)
+    }
+  }
+
+  private fun stopForegroundService() {
+    val context = reactContext.get() ?: return
+
+    try {
+      val intent = Intent(context, CentralizedForegroundService::class.java)
+      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)
+    }
+  }
+
+  /**
+   * Cleanup all subscribers and stop service
+   */
+  fun cleanup() {
+    synchronized(this) {
+      subscribers.clear()
+      if (isServiceRunning) {
+        stopForegroundService()
+      }
+    }
+  }
+}